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.58 by pajs, Tue Apr 6 16:29:44 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 114 | Line 121 | sg_process_stats *sg_get_process_stats(int *entries){
121          char ps_name[4096];
122          char *ptr;
123          VECTOR_DECLARE_STATIC(psargs, char, 128, NULL, NULL);
124 <        unsigned long stime, utime;
124 >        unsigned long stime, utime, starttime;
125          int x;
126          int fn;
127          int len;
128          int rc;
129 +        time_t uptime;
130   #endif
131  
132 + #ifdef LINUX
133 +        if ((f=fopen("/proc/uptime", "r")) == NULL) {
134 +                return NULL;
135 +        }
136 +        if((fscanf(f,"%lu %*d",&uptime)) != 1){
137 +                return NULL;
138 +        }
139 +        fclose(f);
140 + #endif
141 +
142          if((proc_dir=opendir(PROC_LOCATION))==NULL){
143                  return NULL;
144          }
# Line 170 | Line 188 | sg_process_stats *sg_get_process_stats(int *entries){
188                  if(process_info.pr_lwp.pr_state==6) proc_state_ptr->state = SG_PROCESS_STATE_RUNNING;
189   #endif
190   #ifdef LINUX
191 <                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));
192 <                proc_state_ptr->proc_resident = proc_state_ptr->proc_resident * getpagesize();
191 >                x = fscanf(f, "%d %4096s %c %d %d %*d %*d %*d %*u %*u %*u %*u %*u %lu %lu %*d %*d %*d %d %*d %*d %lu %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), &starttime, &(proc_state_ptr->proc_size), &(proc_state_ptr->proc_resident));
192 >                /* +3 becuase man page says "Resident  Set Size: number of pages the process has in real memory, minus 3 for administrative purposes." */
193 >                proc_state_ptr->proc_resident = (proc_state_ptr->proc_resident + 3) * getpagesize();
194                  if(s == 'S') proc_state_ptr->state = SG_PROCESS_STATE_SLEEPING;
195                  if(s == 'R') proc_state_ptr->state = SG_PROCESS_STATE_RUNNING;
196                  if(s == 'Z') proc_state_ptr->state = SG_PROCESS_STATE_ZOMBIE;
# Line 187 | Line 206 | sg_process_stats *sg_get_process_stats(int *entries){
206                          return NULL;
207                  }
208  
209 <                /* Need to do cpu */
210 <                
209 >                /* cpu */
210 >                proc_state_ptr->cpu_percent = (100.0 * (utime + stime)) / ((uptime * 100.0) - starttime);
211 >                printf("%s  ut: %lu st: %lu up: %lu start: %lu\n", proc_state_ptr->process_name, utime, stime, uptime , starttime);
212  
213                  fclose(f);
214  
# Line 264 | Line 284 | sg_process_stats *sg_get_process_stats(int *entries){
284          if(kp_stats == NULL) {
285                  return NULL;
286          }
287 +        memset(kp_stats, 0, size);
288  
289          if(sysctl(mib, 3, kp_stats, &size, NULL, 0) < 0) {
290                  free(kp_stats);
# Line 277 | Line 298 | sg_process_stats *sg_get_process_stats(int *entries){
298          for (i = 0; i < procs; i++) {
299                  const char *name;
300  
301 + #ifdef FREEBSD5
302 +                if (kp_stats[i].ki_stat == 0) {
303 + #else
304 +                if (kp_stats[i].kp_proc.p_stat == 0) {
305 + #endif
306 +                        /* FreeBSD 5 deliberately overallocates the array that
307 +                         * the sysctl returns, so we'll get a few junk
308 +                         * processes on the end that we have to ignore. (Search
309 +                         * for "overestimate by 5 procs" in
310 +                         * src/sys/kern/kern_proc.c for more details.) */
311 +                        continue;
312 +                }
313 +
314                  if (VECTOR_RESIZE(proc_state, proc_state_size + 1) < 0) {
315                          return NULL;
316                  }
# Line 301 | Line 335 | sg_process_stats *sg_get_process_stats(int *entries){
335                          return NULL;
336                  }
337   #else
338 +                /* FIXME - this value can be too large on some of
339 +                   the BSD's, which causes sysctl not to return
340 +                   anything. Maybe we need something smaller? */
341                  mib[1] = KERN_ARGMAX;
342  
343                  if(sysctl(mib, 2, &buflen, &size, NULL, 0) < 0) {
# Line 443 | Line 480 | sg_process_stats *sg_get_process_stats(int *entries){
480                  proc_state_ptr->nice = kp_stats[i].kp_proc.p_nice;
481   #endif
482  
483 + #ifdef NETBSD2
484 +                {
485 +                        size_t size;
486 +                        int mib[5];
487 +
488 +                        mib[0] = CTL_KERN;
489 +                        mib[1] = KERN_LWP;
490 +                        mib[2] = kp_stats[i].kp_proc.p_pid;
491 +                        mib[3] = sizeof(struct kinfo_lwp);
492 +                        mib[4] = 0;
493 +
494 +                        if(sysctl(mib, 5, NULL, &size, NULL, 0) < 0) {
495 +                                return NULL;
496 +                        }
497 +
498 +                        lwps = size / sizeof(struct kinfo_lwp);
499 +                        mib[4] = lwps;
500 +
501 +                        kl_stats = malloc(size);
502 +                        if(kl_stats == NULL) {
503 +                                return NULL;
504 +                        }
505 +
506 +                        if(sysctl(mib, 5, kl_stats, &size, NULL, 0) < 0) {
507 +                                return NULL;
508 +                        }
509 +                }
510 +
511 +                switch(kp_stats[i].kp_proc.p_stat) {
512 +                case SIDL:
513 +                        proc_state_ptr->state = SG_PROCESS_STATE_RUNNING;
514 +                        break;
515 +                case SACTIVE:
516 +                        {
517 +                                int i;
518 +
519 +                                for(i = 0; i < lwps; i++) {
520 +                                        switch(kl_stats[i].l_stat) {
521 +                                        case LSONPROC:
522 +                                        case LSRUN:
523 +                                                proc_state_ptr->state = SG_PROCESS_STATE_RUNNING;
524 +                                                goto end;
525 +                                        case LSSLEEP:
526 +                                                proc_state_ptr->state = SG_PROCESS_STATE_SLEEPING;
527 +                                                goto end;
528 +                                        case LSSTOP:
529 +                                        case LSSUSPENDED:
530 +                                                proc_state_ptr->state = SG_PROCESS_STATE_STOPPED;
531 +                                                goto end;
532 +                                        }
533 +                                        proc_state_ptr->state = SG_PROCESS_STATE_UNKNOWN;
534 +                                }
535 +                                end: ;
536 +                        }
537 +                        break;
538 +                case SSTOP:
539 +                        proc_state_ptr->state = SG_PROCESS_STATE_STOPPED;
540 +                        break;
541 +                case SZOMB:
542 +                        proc_state_ptr->state = SG_PROCESS_STATE_ZOMBIE;
543 +                        break;
544 +                default:
545 +                        proc_state_ptr->state = SG_PROCESS_STATE_UNKNOWN;
546 +                        break;
547 +                }
548 + #else
549   #ifdef FREEBSD5
550                  switch (kp_stats[i].ki_stat) {
551   #else
# Line 477 | Line 580 | sg_process_stats *sg_get_process_stats(int *entries){
580                          proc_state_ptr->state = SG_PROCESS_STATE_UNKNOWN;
581                          break;
582                  }
583 + #endif
584                  proc_state_size++;
585          }
586  

Diff Legend

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