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.53 by ats, Mon Apr 5 18:10:11 2004 UTC vs.
Revision 1.57 by tdb, Tue Apr 6 14:52:58 2004 UTC

# Line 1 | Line 1
1   /*
2 < * i-scream central monitoring system
2 > * i-scream libstatgrab
3   * http://www.i-scream.org
4   * Copyright (C) 2000-2004 i-scream
5   *
# Line 68 | Line 68
68   #include <tools.h>
69   #endif
70   #include <unistd.h>
71 + #ifdef NETBSD2
72 + #include <sys/lwp.h>
73   #endif
74 + #endif
75  
76   static void proc_state_init(sg_process_stats *s) {
77          s->process_name = NULL;
# Line 99 | Line 102 | sg_process_stats *sg_get_process_stats(int *entries){
102          long buflen;
103          char *p;
104   #endif
105 + #ifdef NETBSD2
106 +        int lwps;
107 +        struct kinfo_lwp *kl_stats;
108   #endif
109 + #endif
110   #if defined(SOLARIS) || defined(LINUX)
111          DIR *proc_dir;
112          struct dirent *dir_entry;
# Line 264 | Line 271 | sg_process_stats *sg_get_process_stats(int *entries){
271          if(kp_stats == NULL) {
272                  return NULL;
273          }
274 +        memset(kp_stats, 0, size);
275  
276          if(sysctl(mib, 3, kp_stats, &size, NULL, 0) < 0) {
277                  free(kp_stats);
# Line 277 | Line 285 | sg_process_stats *sg_get_process_stats(int *entries){
285          for (i = 0; i < procs; i++) {
286                  const char *name;
287  
288 + #ifdef FREEBSD5
289 +                if (kp_stats[i].ki_stat == 0) {
290 + #else
291 +                if (kp_stats[i].kp_proc.p_stat == 0) {
292 + #endif
293 +                        /* FreeBSD 5 deliberately overallocates the array that
294 +                         * the sysctl returns, so we'll get a few junk
295 +                         * processes on the end that we have to ignore. (Search
296 +                         * for "overestimate by 5 procs" in
297 +                         * src/sys/kern/kern_proc.c for more details.) */
298 +                        continue;
299 +                }
300 +
301                  if (VECTOR_RESIZE(proc_state, proc_state_size + 1) < 0) {
302                          return NULL;
303                  }
# Line 301 | Line 322 | sg_process_stats *sg_get_process_stats(int *entries){
322                          return NULL;
323                  }
324   #else
325 +                /* FIXME - this value can be too large on some of
326 +                   the BSD's, which causes sysctl not to return
327 +                   anything. Maybe we need something smaller? */
328                  mib[1] = KERN_ARGMAX;
329  
330                  if(sysctl(mib, 2, &buflen, &size, NULL, 0) < 0) {
# Line 443 | Line 467 | sg_process_stats *sg_get_process_stats(int *entries){
467                  proc_state_ptr->nice = kp_stats[i].kp_proc.p_nice;
468   #endif
469  
470 + #ifdef NETBSD2
471 +                {
472 +                        size_t size;
473 +                        int mib[5];
474 +
475 +                        mib[0] = CTL_KERN;
476 +                        mib[1] = KERN_LWP;
477 +                        mib[2] = kp_stats[i].kp_proc.p_pid;
478 +                        mib[3] = sizeof(struct kinfo_lwp);
479 +                        mib[4] = 0;
480 +
481 +                        if(sysctl(mib, 5, NULL, &size, NULL, 0) < 0) {
482 +                                return NULL;
483 +                        }
484 +
485 +                        lwps = size / sizeof(struct kinfo_lwp);
486 +                        mib[4] = lwps;
487 +
488 +                        kl_stats = malloc(size);
489 +                        if(kl_stats == NULL) {
490 +                                return NULL;
491 +                        }
492 +
493 +                        if(sysctl(mib, 5, kl_stats, &size, NULL, 0) < 0) {
494 +                                return NULL;
495 +                        }
496 +                }
497 +
498 +                switch(kp_stats[i].kp_proc.p_stat) {
499 +                case SIDL:
500 +                        proc_state_ptr->state = SG_PROCESS_STATE_RUNNING;
501 +                        break;
502 +                case SACTIVE:
503 +                        {
504 +                                int i;
505 +
506 +                                for(i = 0; i < lwps; i++) {
507 +                                        switch(kl_stats[i].l_stat) {
508 +                                        case LSONPROC:
509 +                                        case LSRUN:
510 +                                                proc_state_ptr->state = SG_PROCESS_STATE_RUNNING;
511 +                                                goto end;
512 +                                        case LSSLEEP:
513 +                                                proc_state_ptr->state = SG_PROCESS_STATE_SLEEPING;
514 +                                                goto end;
515 +                                        case LSSTOP:
516 +                                        case LSSUSPENDED:
517 +                                                proc_state_ptr->state = SG_PROCESS_STATE_STOPPED;
518 +                                                goto end;
519 +                                        }
520 +                                        proc_state_ptr->state = SG_PROCESS_STATE_UNKNOWN;
521 +                                }
522 +                                end: ;
523 +                        }
524 +                        break;
525 +                case SSTOP:
526 +                        proc_state_ptr->state = SG_PROCESS_STATE_STOPPED;
527 +                        break;
528 +                case SZOMB:
529 +                        proc_state_ptr->state = SG_PROCESS_STATE_ZOMBIE;
530 +                        break;
531 +                default:
532 +                        proc_state_ptr->state = SG_PROCESS_STATE_UNKNOWN;
533 +                        break;
534 +                }
535 + #else
536   #ifdef FREEBSD5
537                  switch (kp_stats[i].ki_stat) {
538   #else
# Line 477 | Line 567 | sg_process_stats *sg_get_process_stats(int *entries){
567                          proc_state_ptr->state = SG_PROCESS_STATE_UNKNOWN;
568                          break;
569                  }
570 + #endif
571                  proc_state_size++;
572          }
573  

Diff Legend

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