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.45 by tdb, Sun Apr 4 23:35:45 2004 UTC vs.
Revision 1.59 by tdb, Tue Apr 6 21:08:03 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 26 | Line 26
26   #endif
27  
28   #include "statgrab.h"
29 + #include "tools.h"
30 + #include "vector.h"
31   #if defined(SOLARIS) || defined(LINUX)
32   #include <stdio.h>
33   #include <stdlib.h>
# Line 63 | Line 65
65   #include <limits.h>
66   #if (defined(FREEBSD) && !defined(FREEBSD5)) || defined(DFBSD)
67   #include <kvm.h>
66 – #include <tools.h>
68   #endif
69   #include <unistd.h>
70 + #ifdef NETBSD2
71 + #include <sys/lwp.h>
72   #endif
73 + #endif
74  
75 < int get_proc_snapshot(proc_state_t **ps){
76 <        proc_state_t *proc_state = NULL;
77 <        proc_state_t *proc_state_ptr;
75 > static void proc_state_init(sg_process_stats *s) {
76 >        s->process_name = NULL;
77 >        s->proctitle = NULL;
78 > }
79 >
80 > static void proc_state_destroy(sg_process_stats *s) {
81 >        free(s->process_name);
82 >        free(s->proctitle);
83 > }
84 >
85 > sg_process_stats *sg_get_process_stats(int *entries){
86 >        VECTOR_DECLARE_STATIC(proc_state, sg_process_stats, 64,
87 >                              proc_state_init, proc_state_destroy);
88          int proc_state_size = 0;
89 +        sg_process_stats *proc_state_ptr;
90   #ifdef ALLBSD
91          int mib[4];
92          size_t size;
# Line 80 | Line 95 | int get_proc_snapshot(proc_state_t **ps){
95          char *proctitle;
96   #if (defined(FREEBSD) && !defined(FREEBSD5)) || defined(DFBSD)
97          kvm_t *kvmd;
98 <        char **args;
99 <        int alloc;
85 <        char *proctitletmp;
98 >        char **args, **argsp;
99 >        int argslen = 0;
100   #else
101          long buflen;
102          char *p;
103   #endif
104 + #ifdef NETBSD2
105 +        int lwps;
106 +        struct kinfo_lwp *kl_stats;
107   #endif
108 + #endif
109   #if defined(SOLARIS) || defined(LINUX)
110          DIR *proc_dir;
111          struct dirent *dir_entry;
# Line 101 | Line 119 | int get_proc_snapshot(proc_state_t **ps){
119          /* If someone has a executable of 4k filename length, they deserve to get it truncated :) */
120          char ps_name[4096];
121          char *ptr;
122 <        static char *psargs = NULL;
123 <        static int psarg_size = 0;
106 <        unsigned long stime, utime;
122 >        VECTOR_DECLARE_STATIC(psargs, char, 128, NULL, NULL);
123 >        unsigned long stime, utime, starttime;
124          int x;
125          int fn;
126 <        int toread;
127 <        ssize_t size;
128 <        int t_read;
126 >        int len;
127 >        int rc;
128 >        time_t uptime;
129   #endif
130  
131 + #ifdef LINUX
132 +        if ((f=fopen("/proc/uptime", "r")) == NULL) {
133 +                return NULL;
134 +        }
135 +        if((fscanf(f,"%lu %*d",&uptime)) != 1){
136 +                return NULL;
137 +        }
138 +        fclose(f);
139 + #endif
140 +
141          if((proc_dir=opendir(PROC_LOCATION))==NULL){
142 <                return -1;
142 >                return NULL;
143          }
144  
145          while((dir_entry=readdir(proc_dir))!=NULL){
# Line 133 | Line 160 | int get_proc_snapshot(proc_state_t **ps){
160                  fread(&process_info, sizeof(psinfo_t), 1, f);
161   #endif
162  
163 <                proc_state = realloc(proc_state, (1+proc_state_size)*sizeof(proc_state_t));
163 >                if (VECTOR_RESIZE(proc_state, proc_state_size + 1) < 0) {
164 >                        return NULL;
165 >                }
166                  proc_state_ptr = proc_state+proc_state_size;
167 +
168   #ifdef SOLARIS          
169                  proc_state_ptr->pid = process_info.pr_pid;
170                  proc_state_ptr->parent = process_info.pr_ppid;
# Line 150 | Line 180 | int get_proc_snapshot(proc_state_t **ps){
180                  proc_state_ptr->process_name = strdup(process_info.pr_fname);
181                  proc_state_ptr->proctitle = strdup(process_info.pr_psargs);
182  
183 <                if(process_info.pr_lwp.pr_state==1) proc_state_ptr->state = SLEEPING;
184 <                if(process_info.pr_lwp.pr_state==2) proc_state_ptr->state = RUNNING;
185 <                if(process_info.pr_lwp.pr_state==3) proc_state_ptr->state = ZOMBIE;
186 <                if(process_info.pr_lwp.pr_state==4) proc_state_ptr->state = STOPPED;
187 <                if(process_info.pr_lwp.pr_state==6) proc_state_ptr->state = RUNNING;
183 >                if(process_info.pr_lwp.pr_state==1) proc_state_ptr->state = SG_PROCESS_STATE_SLEEPING;
184 >                if(process_info.pr_lwp.pr_state==2) proc_state_ptr->state = SG_PROCESS_STATE_RUNNING;
185 >                if(process_info.pr_lwp.pr_state==3) proc_state_ptr->state = SG_PROCESS_STATE_ZOMBIE;
186 >                if(process_info.pr_lwp.pr_state==4) proc_state_ptr->state = SG_PROCESS_STATE_STOPPED;
187 >                if(process_info.pr_lwp.pr_state==6) proc_state_ptr->state = SG_PROCESS_STATE_RUNNING;
188   #endif
189   #ifdef LINUX
190 <                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));
191 <                proc_state_ptr->proc_resident = proc_state_ptr->proc_resident * getpagesize();
192 <                if(s == 'S') proc_state_ptr->state = SLEEPING;
193 <                if(s == 'R') proc_state_ptr->state = RUNNING;
194 <                if(s == 'Z') proc_state_ptr->state = ZOMBIE;
195 <                if(s == 'T') proc_state_ptr->state = STOPPED;
196 <                if(s == 'D') proc_state_ptr->state = STOPPED;
190 >                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));
191 >                /* +3 becuase man page says "Resident  Set Size: number of pages the process has in real memory, minus 3 for administrative purposes." */
192 >                proc_state_ptr->proc_resident = (proc_state_ptr->proc_resident + 3) * getpagesize();
193 >                if(s == 'S') proc_state_ptr->state = SG_PROCESS_STATE_SLEEPING;
194 >                if(s == 'R') proc_state_ptr->state = SG_PROCESS_STATE_RUNNING;
195 >                if(s == 'Z') proc_state_ptr->state = SG_PROCESS_STATE_ZOMBIE;
196 >                if(s == 'T') proc_state_ptr->state = SG_PROCESS_STATE_STOPPED;
197 >                if(s == 'D') proc_state_ptr->state = SG_PROCESS_STATE_STOPPED;
198          
199                  /* pa_name[0] should = '(' */
200                  ptr = strchr(&ps_name[1], ')');
201                  if(ptr !=NULL) *ptr='\0';
171 –                proc_state_ptr->process_name = strdup(&ps_name[1]);
202  
203 <                /* Need to do cpu */
204 <                
203 >                if (sg_update_string(&proc_state_ptr->process_name,
204 >                                     &ps_name[1]) < 0) {
205 >                        return NULL;
206 >                }
207  
208 +                /* cpu */
209 +                proc_state_ptr->cpu_percent = (100.0 * (utime + stime)) / ((uptime * 100.0) - starttime);
210 +                printf("%s  ut: %lu st: %lu up: %lu start: %lu\n", proc_state_ptr->process_name, utime, stime, uptime , starttime);
211 +
212 +                fclose(f);
213 +
214                  /* proctitle */
215                  snprintf(filename, MAX_FILE_LENGTH, "/proc/%s/cmdline", dir_entry->d_name);
216  
# Line 181 | Line 219 | int get_proc_snapshot(proc_state_t **ps){
219                           * Ah well, move onwards to the next one */
220                          continue;
221                  }
222 < #define         PSARG_START_SIZE 128
223 <                if(psargs == NULL){
224 <                        psargs = malloc(PSARG_START_SIZE);
225 <                        psarg_size = PSARG_START_SIZE;
222 >
223 > #define READ_BLOCK_SIZE 128
224 >                len = 0;
225 >                do {
226 >                        if (VECTOR_RESIZE(psargs, len + READ_BLOCK_SIZE) < 0) {
227 >                                return NULL;
228 >                        }
229 >                        rc = read(fn, psargs + len, READ_BLOCK_SIZE);
230 >                        if (rc > 0) {
231 >                                len += rc;
232 >                        }
233 >                } while (rc == READ_BLOCK_SIZE);
234 >                close(fn);
235 >
236 >                if (rc == -1) {
237 >                        /* Read failed; move on. */
238 >                        continue;
239                  }
189 –                ptr = psargs;  
190 –                t_read = 0;
191 –                toread = psarg_size;
192 –                while((size = read(fn, ptr, toread)) == toread){
193 –                        psargs = realloc(psargs, (psarg_size + PSARG_START_SIZE));
194 –                        ptr = psargs+psarg_size;
195 –                        t_read = psarg_size;
196 –                        psarg_size+=PSARG_START_SIZE;
197 –                        toread = PSARG_START_SIZE;
198 –                }
199 –                if(size != -1) t_read+=size;
240  
241 +                /* Turn \0s into spaces within the command line. */
242                  ptr = psargs;
243 <                for(x=0; x<t_read; x++){
243 >                for(x = 0; x < len; x++) {
244                          if (*ptr == '\0') *ptr = ' ';
245                          ptr++;
246                  }
206 –                /*  for safety sake */
207 –                psargs[t_read] = '\0';
247  
248 <                proc_state_ptr->proctitle = strdup(psargs);
248 >                if (len == 0) {
249 >                        /* We want psargs to be NULL. */
250 >                        if (VECTOR_RESIZE(psargs, 0) < 0) {
251 >                                return NULL;
252 >                        }
253 >                } else {
254 >                        /* Not empty, so append a \0. */
255 >                        if (VECTOR_RESIZE(psargs, len + 1) < 0) {
256 >                                return NULL;
257 >                        }
258 >                        psargs[len] = '\0';
259 >                }
260  
261 +                if (sg_update_string(&proc_state_ptr->proctitle, psargs) < 0) {
262 +                        return NULL;
263 +                }
264   #endif
265  
266                  proc_state_size++;
214 –
215 –                fclose(f);
267          }
268          closedir(proc_dir);
269   #endif
# Line 232 | Line 283 | int get_proc_snapshot(proc_state_t **ps){
283          if(kp_stats == NULL) {
284                  return NULL;
285          }
286 +        memset(kp_stats, 0, size);
287  
288          if(sysctl(mib, 3, kp_stats, &size, NULL, 0) < 0) {
289                  free(kp_stats);
# Line 239 | Line 291 | int get_proc_snapshot(proc_state_t **ps){
291          }
292  
293   #if (defined(FREEBSD) && !defined(FREEBSD5)) || defined(DFBSD)
294 <        kvmd = get_kvm2();
294 >        kvmd = sg_get_kvm2();
295   #endif
296  
297          for (i = 0; i < procs; i++) {
298 <                /* replace with something more sensible */
299 <                proc_state = realloc(proc_state,
300 <                                (1+proc_state_size)*sizeof(proc_state_t));
301 <                if(proc_state == NULL ) {
298 >                const char *name;
299 >
300 > #ifdef FREEBSD5
301 >                if (kp_stats[i].ki_stat == 0) {
302 > #else
303 >                if (kp_stats[i].kp_proc.p_stat == 0) {
304 > #endif
305 >                        /* FreeBSD 5 deliberately overallocates the array that
306 >                         * the sysctl returns, so we'll get a few junk
307 >                         * processes on the end that we have to ignore. (Search
308 >                         * for "overestimate by 5 procs" in
309 >                         * src/sys/kern/kern_proc.c for more details.) */
310 >                        continue;
311 >                }
312 >
313 >                if (VECTOR_RESIZE(proc_state, proc_state_size + 1) < 0) {
314                          return NULL;
315                  }
316                  proc_state_ptr = proc_state+proc_state_size;
317  
318   #ifdef FREEBSD5
319 <                proc_state_ptr->process_name =
256 <                        strdup(kp_stats[i].ki_comm);
319 >                name = kp_stats[i].ki_comm;
320   #elif defined(DFBSD)
321 <                proc_state_ptr->process_name =
259 <                        strdup(kp_stats[i].kp_thread.td_comm);
321 >                name = kp_stats[i].kp_thread.td_comm;
322   #else
323 <                proc_state_ptr->process_name =
262 <                        strdup(kp_stats[i].kp_proc.p_comm);
323 >                name = kp_stats[i].kp_proc.p_comm;
324   #endif
325 +                if (sg_update_string(&proc_state_ptr->process_name, name) < 0) {
326 +                        return NULL;
327 +                }
328  
329   #if defined(FREEBSD5) || defined(NETBSD) || defined(OPENBSD)
330                  size = sizeof(buflen);
# Line 270 | Line 334 | int get_proc_snapshot(proc_state_t **ps){
334                          return NULL;
335                  }
336   #else
337 +                /* FIXME - this value can be too large on some of
338 +                   the BSD's, which causes sysctl not to return
339 +                   anything. Maybe we need something smaller? */
340                  mib[1] = KERN_ARGMAX;
341  
342                  if(sysctl(mib, 2, &buflen, &size, NULL, 0) < 0) {
# Line 293 | Line 360 | int get_proc_snapshot(proc_state_t **ps){
360                  mib[3] = KERN_PROC_ARGV;
361   #endif
362  
363 +                free(proc_state_ptr->proctitle);
364                  if(sysctl(mib, 4, proctitle, &size, NULL, 0) < 0) {
365                          free(proctitle);
366                          proc_state_ptr->proctitle = NULL;
# Line 303 | Line 371 | int get_proc_snapshot(proc_state_t **ps){
371                                  return NULL;
372                          }
373                          p = proctitle;
374 <                        proc_state_ptr->proctitle[0] = NULL;
374 >                        proc_state_ptr->proctitle[0] = '\0';
375                          do {
376 <                                strlcat(proc_state_ptr->proctitle, p, size+1);
377 <                                strlcat(proc_state_ptr->proctitle, " ", size+1);
376 >                                sg_strlcat(proc_state_ptr->proctitle, p, size+1);
377 >                                sg_strlcat(proc_state_ptr->proctitle, " ", size+1);
378                                  p += strlen(p) + 1;
379                          } while (p < proctitle + size);
380                          free(proctitle);
# Line 318 | Line 386 | int get_proc_snapshot(proc_state_t **ps){
386                          proc_state_ptr->proctitle = NULL;
387                  }
388   #else
389 +                free(proc_state_ptr->proctitle);
390                  if(kvmd != NULL) {
391                          args = kvm_getargv(kvmd, &(kp_stats[i]), 0);
392                          if(args != NULL) {
393 <                                alloc = 1;
394 <                                proctitle = malloc(alloc);
393 >                                argsp = args;
394 >                                while(*argsp != NULL) {
395 >                                        argslen += strlen(*argsp) + 1;
396 >                                        argsp++;
397 >                                }
398 >                                proctitle = malloc(argslen + 1);
399 >                                proctitle[0] = '\0';
400                                  if(proctitle == NULL) {
401                                          return NULL;
402                                  }
403                                  while(*args != NULL) {
404 <                                        if(strlen(proctitle) + strlen(*args) >= alloc) {
405 <                                                alloc = (alloc + strlen(*args)) * 2;
332 <                                                proctitletmp = realloc(proctitle, alloc);
333 <                                                if(proctitletmp == NULL) {
334 <                                                        return NULL;
335 <                                                }
336 <                                                proctitle = proctitletmp;
337 <                                        }
338 <                                        strlcat(proctitle, *args, alloc);
339 <                                        strlcat(proctitle, " ", alloc);
404 >                                        sg_strlcat(proctitle, *args, argslen + 1);
405 >                                        sg_strlcat(proctitle, " ", argslen + 1);
406                                          args++;
407                                  }
408                                  /* remove trailing space */
# Line 413 | Line 479 | int get_proc_snapshot(proc_state_t **ps){
479                  proc_state_ptr->nice = kp_stats[i].kp_proc.p_nice;
480   #endif
481  
482 + #ifdef NETBSD2
483 +                {
484 +                        size_t size;
485 +                        int mib[5];
486 +
487 +                        mib[0] = CTL_KERN;
488 +                        mib[1] = KERN_LWP;
489 +                        mib[2] = kp_stats[i].kp_proc.p_pid;
490 +                        mib[3] = sizeof(struct kinfo_lwp);
491 +                        mib[4] = 0;
492 +
493 +                        if(sysctl(mib, 5, NULL, &size, NULL, 0) < 0) {
494 +                                return NULL;
495 +                        }
496 +
497 +                        lwps = size / sizeof(struct kinfo_lwp);
498 +                        mib[4] = lwps;
499 +
500 +                        kl_stats = malloc(size);
501 +                        if(kl_stats == NULL) {
502 +                                return NULL;
503 +                        }
504 +
505 +                        if(sysctl(mib, 5, kl_stats, &size, NULL, 0) < 0) {
506 +                                return NULL;
507 +                        }
508 +                }
509 +
510 +                switch(kp_stats[i].kp_proc.p_stat) {
511 +                case SIDL:
512 +                        proc_state_ptr->state = SG_PROCESS_STATE_RUNNING;
513 +                        break;
514 +                case SACTIVE:
515 +                        {
516 +                                int i;
517 +
518 +                                for(i = 0; i < lwps; i++) {
519 +                                        switch(kl_stats[i].l_stat) {
520 +                                        case LSONPROC:
521 +                                        case LSRUN:
522 +                                                proc_state_ptr->state = SG_PROCESS_STATE_RUNNING;
523 +                                                goto end;
524 +                                        case LSSLEEP:
525 +                                                proc_state_ptr->state = SG_PROCESS_STATE_SLEEPING;
526 +                                                goto end;
527 +                                        case LSSTOP:
528 +                                        case LSSUSPENDED:
529 +                                                proc_state_ptr->state = SG_PROCESS_STATE_STOPPED;
530 +                                                goto end;
531 +                                        }
532 +                                        proc_state_ptr->state = SG_PROCESS_STATE_UNKNOWN;
533 +                                }
534 +                                end: ;
535 +                        }
536 +                        break;
537 +                case SSTOP:
538 +                        proc_state_ptr->state = SG_PROCESS_STATE_STOPPED;
539 +                        break;
540 +                case SZOMB:
541 +                        proc_state_ptr->state = SG_PROCESS_STATE_ZOMBIE;
542 +                        break;
543 +                default:
544 +                        proc_state_ptr->state = SG_PROCESS_STATE_UNKNOWN;
545 +                        break;
546 +                }
547 + #else
548   #ifdef FREEBSD5
549                  switch (kp_stats[i].ki_stat) {
550   #else
# Line 423 | Line 555 | int get_proc_snapshot(proc_state_t **ps){
555   #ifdef SONPROC
556                  case SONPROC: /* NetBSD */
557   #endif
558 <                        proc_state_ptr->state = RUNNING;
558 >                        proc_state_ptr->state = SG_PROCESS_STATE_RUNNING;
559                          break;
560                  case SSLEEP:
561   #ifdef SWAIT
# Line 432 | Line 564 | int get_proc_snapshot(proc_state_t **ps){
564   #ifdef SLOCK
565                  case SLOCK: /* FreeBSD 5 */
566   #endif
567 <                        proc_state_ptr->state = SLEEPING;
567 >                        proc_state_ptr->state = SG_PROCESS_STATE_SLEEPING;
568                          break;
569                  case SSTOP:
570 <                        proc_state_ptr->state = STOPPED;
570 >                        proc_state_ptr->state = SG_PROCESS_STATE_STOPPED;
571                          break;
572                  case SZOMB:
573   #ifdef SDEAD
574                  case SDEAD: /* OpenBSD & NetBSD */
575   #endif
576 <                        proc_state_ptr->state = ZOMBIE;
576 >                        proc_state_ptr->state = SG_PROCESS_STATE_ZOMBIE;
577                          break;
578                  default:
579 <                        proc_state_ptr->state = UNKNOWN;
579 >                        proc_state_ptr->state = SG_PROCESS_STATE_UNKNOWN;
580                          break;
581                  }
582 + #endif
583                  proc_state_size++;
584          }
585  
586          free(kp_stats);
587   #endif
588  
589 <        *ps = proc_state;
590 <        return proc_state_size;
589 > #ifdef CYGWIN
590 >        return NULL;
591 > #endif
592 >
593 >        *entries = proc_state_size;
594 >        return proc_state;
595   }
596  
597 < process_stat_t *get_process_stats() {
598 <        static process_stat_t process_stat;
599 <        proc_state_t *ps;
597 > sg_process_count *sg_get_process_count() {
598 >        static sg_process_count process_stat;
599 >        sg_process_stats *ps;
600          int ps_size, x;
601  
602          process_stat.sleeping = 0;
# Line 468 | Line 605 | process_stat_t *get_process_stats() {
605          process_stat.stopped = 0;
606          process_stat.total = 0;
607  
608 <        ps_size = get_proc_snapshot(&ps);
609 <
473 <        if(ps_size == 0) {
608 >        ps = sg_get_process_stats(&ps_size);
609 >        if (ps == NULL) {
610                  return NULL;
611          }
612  
613          for(x = 0; x < ps_size; x++) {
614                  switch (ps->state) {
615 <                case RUNNING:
615 >                case SG_PROCESS_STATE_RUNNING:
616                          process_stat.running++;
617                          break;
618 <                case SLEEPING:
618 >                case SG_PROCESS_STATE_SLEEPING:
619                          process_stat.sleeping++;
620                          break;
621 <                case STOPPED:
621 >                case SG_PROCESS_STATE_STOPPED:
622                          process_stat.stopped++;
623                          break;
624 <                case ZOMBIE:
624 >                case SG_PROCESS_STATE_ZOMBIE:
625                          process_stat.zombie++;
626                          break;
627                  default:
628 <                        /* currently no mapping for UNKNOWN in process_stat_t */
628 >                        /* currently no mapping for SG_PROCESS_STATE_UNKNOWN in
629 >                         * sg_process_count */
630                          break;
631                  }
632                  ps++;

Diff Legend

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