ViewVC Help
View File | Revision Log | Show Annotations | Revision Graph | Root Listing
root/i-scream/projects/libstatgrab/src/libstatgrab/process_stats.c
(Generate patch)

Comparing projects/libstatgrab/src/libstatgrab/process_stats.c (file contents):
Revision 1.34 by tdb, Sun Apr 4 11:46:08 2004 UTC vs.
Revision 1.40 by ats, Sun Apr 4 21:44:00 2004 UTC

# Line 69 | Line 69 | int get_proc_snapshot(proc_state_t **ps){
69          proc_state_t *proc_state_ptr;
70          int proc_state_size = 0;
71   #ifdef ALLBSD
72 <        int mib[3];
72 >        int mib[4];
73          size_t size;
74          struct kinfo_proc *kp_stats;
75          int procs, i, alloc;
76 +        char *proctitle;
77 + #if defined(FREEBSD5) || defined(NETBSD) || defined(OPENBSD)
78 +        long buflen;
79 +        char *p;
80 +        int argc;
81 +        int j = 0;
82 + #else
83          static kvm_t *kvmd;
84          char **args;
78 –        char *proctitle;
85   #endif
86 + #endif
87   #if defined(SOLARIS) || defined(LINUX)
88          DIR *proc_dir;
89          struct dirent *dir_entry;
# Line 146 | Line 153 | int get_proc_snapshot(proc_state_t **ps){
153                  if(process_info.pr_lwp.pr_state==6) proc_state_ptr->state = RUNNING;
154   #endif
155   #ifdef LINUX
156 <                x = fscanf(f, "%d %4096s %c %d %d %*d %*d %*d %*lu %*lu %*lu %*lu %*lu %lu %lu %*ld %*ld %*ld %d %*ld %*ld %*lu %llu %llu %*lu %*lu %*lu %*lu %*lu %*lu %*lu %*lu %*lu %*lu %*lu %*lu %*lu %*d %*d\n", &(proc_state_ptr->pid), ps_name, &s, &(proc_state_ptr->parent), &(proc_state_ptr->pgid), &utime, &stime, &(proc_state_ptr->nice), &(proc_state_ptr->proc_size), &(proc_state_ptr->proc_resident));
156 >                x = fscanf(f, "%d %4096s %c %d %d %*d %*d %*d %*u %*u %*u %*u %*u %lu %lu %*d %*d %*d %d %*d %*d %*u %llu %llu %*u %*u %*u %*u %*u %*u %*u %*u %*u %*u %*u %*u %*u %*d %*d\n", &(proc_state_ptr->pid), ps_name, &s, &(proc_state_ptr->parent), &(proc_state_ptr->pgid), &utime, &stime, &(proc_state_ptr->nice), &(proc_state_ptr->proc_size), &(proc_state_ptr->proc_resident));
157                  proc_state_ptr->proc_resident = proc_state_ptr->proc_resident * getpagesize();
158                  if(s == 'S') proc_state_ptr->state = SLEEPING;
159                  if(s == 'R') proc_state_ptr->state = RUNNING;
# Line 207 | Line 214 | int get_proc_snapshot(proc_state_t **ps){
214   #endif
215  
216   #ifdef ALLBSD
217 +        mib[0] = CTL_KERN;
218 +        mib[1] = KERN_PROC;
219 +        mib[2] = KERN_PROC_ALL;
220  
221 < #if defined(NETBSD) || defined(OPENBSD)
222 <        kvmd = kvm_openfiles(NULL, NULL, NULL, O_RDONLY, NULL);
223 < #else
214 <        kvmd = kvm_openfiles(_PATH_DEVNULL, _PATH_DEVNULL, NULL, O_RDONLY, NULL);
215 < #endif
221 >        if(sysctl(mib, 3, NULL, &size, NULL, 0) < 0) {
222 >                return NULL;
223 >        }
224  
225 <        if(kvmd == NULL) return NULL;
225 >        procs = size / sizeof(struct kinfo_proc);
226  
227 <        kp_stats = kvm_getprocs(kvmd, KERN_PROC_ALL, 0, &procs);
227 >        kp_stats = malloc(size);
228 >        if(kp_stats == NULL) {
229 >                return NULL;
230 >        }
231  
232 <        if (kp_stats == NULL || procs < 0) {
232 >        if(sysctl(mib, 3, kp_stats, &size, NULL, 0) < 0) {
233 >                free(kp_stats);
234                  return NULL;
235          }
236  
237 + #if (defined(FREEBSD) && !defined(FREEBSD5)) || defined(DFBSD)
238 +        kvmd = kvm_openfiles(_PATH_DEVNULL, _PATH_DEVNULL, NULL, O_RDONLY, NULL);
239 + #endif
240 +
241          for (i = 0; i < procs; i++) {
242                  /* replace with something more sensible */
243                  proc_state = realloc(proc_state,
# Line 234 | Line 250 | int get_proc_snapshot(proc_state_t **ps){
250   #ifdef FREEBSD5
251                  proc_state_ptr->process_name =
252                          strdup(kp_stats[i].ki_comm);
253 + #elif defined(DFBSD)
254 +                proc_state_ptr->process_name =
255 +                        strdup(kp_stats[i].kp_thread.td_comm);
256   #else
257                  proc_state_ptr->process_name =
258                          strdup(kp_stats[i].kp_proc.p_comm);
259   #endif
260  
261 <                args = kvm_getargv(kvmd, &(kp_stats[i]), 0);
262 <                if(args != NULL) {
263 <                        alloc = 1;
264 <                        proctitle = malloc(alloc);
265 <                        if(proctitle == NULL) {
261 > #if defined(FREEBSD5) || defined(NETBSD) || defined(OPENBSD)
262 >                size = sizeof(buflen);
263 >
264 > #ifdef FREEBSD5
265 >                if(sysctlbyname("kern.ps_arg_cache_limit", &buflen, &size, NULL, 0) < 0) {
266 >                        return NULL;
267 >                }
268 > #else
269 >                mib[1] = KERN_ARGMAX;
270 >
271 >                if(sysctl(mib, 2, &buflen, &size, NULL, 0) < 0) {
272 >                        return NULL;
273 >                }
274 > #endif
275 >
276 >                proctitle = malloc(buflen);
277 >                if(proctitle == NULL) {
278 >                        return NULL;
279 >                }
280 >
281 >                size = buflen;
282 >
283 > #ifdef FREEBSD5
284 >                mib[2] = KERN_PROC_ARGS;
285 >                mib[3] = kp_stats[i].ki_pid;
286 > #else
287 >                mib[1] = KERN_PROC_ARGS;
288 >                mib[2] = kp_stats[i].kp_proc.p_pid;
289 >                mib[3] = KERN_PROC_ARGV;
290 > #endif
291 >
292 >                if(sysctl(mib, 4, proctitle, &size, NULL, 0) < 0) {
293 >                        free(proctitle);
294 >                        proc_state_ptr->proctitle = NULL;
295 >                }
296 >                else if(size > 0) {
297 >                        proc_state_ptr->proctitle = malloc(size);
298 >                        if(proc_state_ptr->proctitle == NULL) {
299                                  return NULL;
300                          }
301 <                        while(*args != NULL) {
302 <                                if(strlen(proctitle) + strlen(*args) >= alloc) {
303 <                                        alloc = (alloc + strlen(*args)) << 1;
304 <                                        proctitle = realloc(proctitle, alloc);
305 <                                        if(proctitle == NULL) {
306 <                                                return NULL;
301 >                        p = proctitle;
302 >                        proc_state_ptr->proctitle[0] = NULL;
303 >                        do {
304 >                                strncat(proc_state_ptr->proctitle, p, strlen(p));
305 >                                strncat(proc_state_ptr->proctitle, " ", 1);
306 >                                p += strlen(p) + 1;
307 >                        } while (p < proctitle + size);
308 >                        free(proctitle);
309 >                        proc_state_ptr->proctitle[strlen(proc_state_ptr->proctitle)-1] = NULL;
310 >                }
311 >                else {
312 >                        free(proctitle);
313 >                        proc_state_ptr->proctitle = NULL;
314 >                }
315 > #else
316 >                if(kvmd != NULL) {
317 >                        args = kvm_getargv(kvmd, &(kp_stats[i]), 0);
318 >                        if(args != NULL) {
319 >                                alloc = 1;
320 >                                proctitle = malloc(alloc);
321 >                                if(proctitle == NULL) {
322 >                                        return NULL;
323 >                                }
324 >                                while(*args != NULL) {
325 >                                        if(strlen(proctitle) + strlen(*args) >= alloc) {
326 >                                                alloc = (alloc + strlen(*args)) << 1;
327 >                                                proctitle = realloc(proctitle, alloc);
328 >                                                if(proctitle == NULL) {
329 >                                                        return NULL;
330 >                                                }
331                                          }
332 +                                        strncat(proctitle, *args, strlen(*args));
333 +                                        strncat(proctitle, " ", 1);
334 +                                        args++;
335                                  }
336 <                                strncat(proctitle, *args, strlen(*args));
337 <                                strncat(proctitle, " ", 1);
338 <                                args++;
336 >                                /* remove trailing space */
337 >                                proctitle[strlen(proctitle)-1] = NULL;
338 >                                proc_state_ptr->proctitle = proctitle;
339                          }
340 <                        /* remove trailing space */
341 <                        proctitle[strlen(proctitle)-1] = NULL;
342 <                        proc_state_ptr->proctitle = proctitle;
340 >                        else {
341 >                                proc_state_ptr->proctitle = NULL;
342 >                        }
343                  }
344                  else {
345 <                        proc_state_ptr->proctitle =
267 <                                malloc(strlen(proc_state_ptr->process_name)+4);
268 <                        if(proc_state_ptr->proctitle == NULL) {
269 <                                return NULL;
270 <                        }
271 <                        sprintf(proc_state_ptr->proctitle, " (%s)",
272 <                                proc_state_ptr->process_name);
345 >                        proc_state_ptr->proctitle = NULL;
346                  }
347 + #endif
348  
349   #ifdef FREEBSD5
350                  proc_state_ptr->pid = kp_stats[i].ki_pid;
# Line 287 | Line 361 | int get_proc_snapshot(proc_state_t **ps){
361                  proc_state_ptr->euid = kp_stats[i].ki_uid;
362                  proc_state_ptr->gid = kp_stats[i].ki_rgid;
363                  proc_state_ptr->egid = kp_stats[i].ki_svgid;
364 + #elif defined(DFBSD)
365 +                proc_state_ptr->uid = kp_stats[i].kp_eproc.e_ucred.cr_ruid;
366 +                proc_state_ptr->euid = kp_stats[i].kp_eproc.e_ucred.cr_svuid;
367 +                proc_state_ptr->gid = kp_stats[i].kp_eproc.e_ucred.cr_rgid;
368 +                proc_state_ptr->egid = kp_stats[i].kp_eproc.e_ucred.cr_svgid;
369   #else
370                  proc_state_ptr->uid = kp_stats[i].kp_eproc.e_pcred.p_ruid;
371                  proc_state_ptr->euid = kp_stats[i].kp_eproc.e_pcred.p_svuid;
# Line 310 | Line 389 | int get_proc_snapshot(proc_state_t **ps){
389                  /* This is in pages */
390                  proc_state_ptr->proc_resident =
391                          kp_stats[i].kp_eproc.e_vm.vm_rssize * getpagesize();
313 –                /* This is in microseconds */
392   #if defined(NETBSD) || defined(OPENBSD)
393                  proc_state_ptr->time_spent =
394                          kp_stats[i].kp_proc.p_rtime.tv_sec;
395 + #elif defined(DFBSD)
396 +                proc_state_ptr->time_spent =
397 +                        ( kp_stats[i].kp_thread.td_uticks +
398 +                        kp_stats[i].kp_thread.td_sticks +
399 +                        kp_stats[i].kp_thread.td_iticks ) / 1000000;
400   #else
401 +                /* This is in microseconds */
402                  proc_state_ptr->time_spent =
403                          kp_stats[i].kp_proc.p_runtime / 1000000;
404   #endif
# Line 380 | Line 464 | process_stat_t *get_process_stats() {
464  
465          ps_size = get_proc_snapshot(&ps);
466  
467 <        if(ps_size == NULL) {
467 >        if(ps_size == 0) {
468                  return NULL;
469          }
470  
471          for(x = 0; x < ps_size; x++) {
472                  switch (ps->state) {
389 –                /* currently no mapping for UNKNOWN in process_stat_t */
473                  case RUNNING:
474                          process_stat.running++;
475                          break;
# Line 398 | Line 481 | process_stat_t *get_process_stats() {
481                          break;
482                  case ZOMBIE:
483                          process_stat.zombie++;
484 +                        break;
485 +                default:
486 +                        /* currently no mapping for UNKNOWN in process_stat_t */
487                          break;
488                  }
489                  ps++;

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines