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.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 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 66 | 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 < int get_proc_snapshot(proc_state_t **ps){
77 <        proc_state_t *proc_state = NULL;
78 <        proc_state_t *proc_state_ptr;
76 > static void proc_state_init(sg_process_stats *s) {
77 >        s->process_name = NULL;
78 >        s->proctitle = NULL;
79 > }
80 >
81 > static void proc_state_destroy(sg_process_stats *s) {
82 >        free(s->process_name);
83 >        free(s->proctitle);
84 > }
85 >
86 > sg_process_stats *sg_get_process_stats(int *entries){
87 >        VECTOR_DECLARE_STATIC(proc_state, sg_process_stats, 64,
88 >                              proc_state_init, proc_state_destroy);
89          int proc_state_size = 0;
90 +        sg_process_stats *proc_state_ptr;
91   #ifdef ALLBSD
92          int mib[4];
93          size_t size;
# Line 80 | Line 96 | int get_proc_snapshot(proc_state_t **ps){
96          char *proctitle;
97   #if (defined(FREEBSD) && !defined(FREEBSD5)) || defined(DFBSD)
98          kvm_t *kvmd;
99 <        char **args;
100 <        int alloc;
85 <        char *proctitletmp;
99 >        char **args, **argsp;
100 >        int argslen = 0;
101   #else
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 101 | Line 120 | int get_proc_snapshot(proc_state_t **ps){
120          /* If someone has a executable of 4k filename length, they deserve to get it truncated :) */
121          char ps_name[4096];
122          char *ptr;
123 <        static char *psargs = NULL;
124 <        static int psarg_size = 0;
106 <        unsigned long stime, utime;
123 >        VECTOR_DECLARE_STATIC(psargs, char, 128, NULL, NULL);
124 >        unsigned long stime, utime, starttime;
125          int x;
126          int fn;
127 <        int toread;
128 <        ssize_t size;
129 <        int t_read;
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 -1;
143 >                return NULL;
144          }
145  
146          while((dir_entry=readdir(proc_dir))!=NULL){
# Line 133 | Line 161 | int get_proc_snapshot(proc_state_t **ps){
161                  fread(&process_info, sizeof(psinfo_t), 1, f);
162   #endif
163  
164 <                proc_state = realloc(proc_state, (1+proc_state_size)*sizeof(proc_state_t));
164 >                if (VECTOR_RESIZE(proc_state, proc_state_size + 1) < 0) {
165 >                        return NULL;
166 >                }
167                  proc_state_ptr = proc_state+proc_state_size;
168 +
169   #ifdef SOLARIS          
170                  proc_state_ptr->pid = process_info.pr_pid;
171                  proc_state_ptr->parent = process_info.pr_ppid;
# Line 150 | Line 181 | int get_proc_snapshot(proc_state_t **ps){
181                  proc_state_ptr->process_name = strdup(process_info.pr_fname);
182                  proc_state_ptr->proctitle = strdup(process_info.pr_psargs);
183  
184 <                if(process_info.pr_lwp.pr_state==1) proc_state_ptr->state = SLEEPING;
185 <                if(process_info.pr_lwp.pr_state==2) proc_state_ptr->state = RUNNING;
186 <                if(process_info.pr_lwp.pr_state==3) proc_state_ptr->state = ZOMBIE;
187 <                if(process_info.pr_lwp.pr_state==4) proc_state_ptr->state = STOPPED;
188 <                if(process_info.pr_lwp.pr_state==6) proc_state_ptr->state = RUNNING;
184 >                if(process_info.pr_lwp.pr_state==1) proc_state_ptr->state = SG_PROCESS_STATE_SLEEPING;
185 >                if(process_info.pr_lwp.pr_state==2) proc_state_ptr->state = SG_PROCESS_STATE_RUNNING;
186 >                if(process_info.pr_lwp.pr_state==3) proc_state_ptr->state = SG_PROCESS_STATE_ZOMBIE;
187 >                if(process_info.pr_lwp.pr_state==4) proc_state_ptr->state = SG_PROCESS_STATE_STOPPED;
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();
193 <                if(s == 'S') proc_state_ptr->state = SLEEPING;
194 <                if(s == 'R') proc_state_ptr->state = RUNNING;
195 <                if(s == 'Z') proc_state_ptr->state = ZOMBIE;
196 <                if(s == 'T') proc_state_ptr->state = STOPPED;
197 <                if(s == 'D') proc_state_ptr->state = STOPPED;
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;
197 >                if(s == 'T') proc_state_ptr->state = SG_PROCESS_STATE_STOPPED;
198 >                if(s == 'D') proc_state_ptr->state = SG_PROCESS_STATE_STOPPED;
199          
200                  /* pa_name[0] should = '(' */
201                  ptr = strchr(&ps_name[1], ')');
202                  if(ptr !=NULL) *ptr='\0';
171 –                proc_state_ptr->process_name = strdup(&ps_name[1]);
203  
204 <                /* Need to do cpu */
205 <                
204 >                if (sg_update_string(&proc_state_ptr->process_name,
205 >                                     &ps_name[1]) < 0) {
206 >                        return NULL;
207 >                }
208  
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 +
215                  /* proctitle */
216                  snprintf(filename, MAX_FILE_LENGTH, "/proc/%s/cmdline", dir_entry->d_name);
217  
# Line 181 | Line 220 | int get_proc_snapshot(proc_state_t **ps){
220                           * Ah well, move onwards to the next one */
221                          continue;
222                  }
223 < #define         PSARG_START_SIZE 128
224 <                if(psargs == NULL){
225 <                        psargs = malloc(PSARG_START_SIZE);
226 <                        psarg_size = PSARG_START_SIZE;
223 >
224 > #define READ_BLOCK_SIZE 128
225 >                len = 0;
226 >                do {
227 >                        if (VECTOR_RESIZE(psargs, len + READ_BLOCK_SIZE) < 0) {
228 >                                return NULL;
229 >                        }
230 >                        rc = read(fn, psargs + len, READ_BLOCK_SIZE);
231 >                        if (rc > 0) {
232 >                                len += rc;
233 >                        }
234 >                } while (rc == READ_BLOCK_SIZE);
235 >                close(fn);
236 >
237 >                if (rc == -1) {
238 >                        /* Read failed; move on. */
239 >                        continue;
240                  }
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;
241  
242 +                /* Turn \0s into spaces within the command line. */
243                  ptr = psargs;
244 <                for(x=0; x<t_read; x++){
244 >                for(x = 0; x < len; x++) {
245                          if (*ptr == '\0') *ptr = ' ';
246                          ptr++;
247                  }
206 –                /*  for safety sake */
207 –                psargs[t_read] = '\0';
248  
249 <                proc_state_ptr->proctitle = strdup(psargs);
249 >                if (len == 0) {
250 >                        /* We want psargs to be NULL. */
251 >                        if (VECTOR_RESIZE(psargs, 0) < 0) {
252 >                                return NULL;
253 >                        }
254 >                } else {
255 >                        /* Not empty, so append a \0. */
256 >                        if (VECTOR_RESIZE(psargs, len + 1) < 0) {
257 >                                return NULL;
258 >                        }
259 >                        psargs[len] = '\0';
260 >                }
261  
262 +                if (sg_update_string(&proc_state_ptr->proctitle, psargs) < 0) {
263 +                        return NULL;
264 +                }
265   #endif
266  
267                  proc_state_size++;
214 –
215 –                fclose(f);
268          }
269          closedir(proc_dir);
270   #endif
# Line 232 | Line 284 | int get_proc_snapshot(proc_state_t **ps){
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 239 | Line 292 | int get_proc_snapshot(proc_state_t **ps){
292          }
293  
294   #if (defined(FREEBSD) && !defined(FREEBSD5)) || defined(DFBSD)
295 <        kvmd = get_kvm2();
295 >        kvmd = sg_get_kvm2();
296   #endif
297  
298          for (i = 0; i < procs; i++) {
299 <                /* replace with something more sensible */
300 <                proc_state = realloc(proc_state,
301 <                                (1+proc_state_size)*sizeof(proc_state_t));
302 <                if(proc_state == NULL ) {
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                  }
317                  proc_state_ptr = proc_state+proc_state_size;
318  
319   #ifdef FREEBSD5
320 <                proc_state_ptr->process_name =
256 <                        strdup(kp_stats[i].ki_comm);
320 >                name = kp_stats[i].ki_comm;
321   #elif defined(DFBSD)
322 <                proc_state_ptr->process_name =
259 <                        strdup(kp_stats[i].kp_thread.td_comm);
322 >                name = kp_stats[i].kp_thread.td_comm;
323   #else
324 <                proc_state_ptr->process_name =
262 <                        strdup(kp_stats[i].kp_proc.p_comm);
324 >                name = kp_stats[i].kp_proc.p_comm;
325   #endif
326 +                if (sg_update_string(&proc_state_ptr->process_name, name) < 0) {
327 +                        return NULL;
328 +                }
329  
330   #if defined(FREEBSD5) || defined(NETBSD) || defined(OPENBSD)
331                  size = sizeof(buflen);
# Line 270 | Line 335 | int get_proc_snapshot(proc_state_t **ps){
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 293 | Line 361 | int get_proc_snapshot(proc_state_t **ps){
361                  mib[3] = KERN_PROC_ARGV;
362   #endif
363  
364 +                free(proc_state_ptr->proctitle);
365                  if(sysctl(mib, 4, proctitle, &size, NULL, 0) < 0) {
366                          free(proctitle);
367                          proc_state_ptr->proctitle = NULL;
# Line 303 | Line 372 | int get_proc_snapshot(proc_state_t **ps){
372                                  return NULL;
373                          }
374                          p = proctitle;
375 <                        proc_state_ptr->proctitle[0] = NULL;
375 >                        proc_state_ptr->proctitle[0] = '\0';
376                          do {
377 <                                strlcat(proc_state_ptr->proctitle, p, size+1);
378 <                                strlcat(proc_state_ptr->proctitle, " ", size+1);
377 >                                sg_strlcat(proc_state_ptr->proctitle, p, size+1);
378 >                                sg_strlcat(proc_state_ptr->proctitle, " ", size+1);
379                                  p += strlen(p) + 1;
380                          } while (p < proctitle + size);
381                          free(proctitle);
# Line 318 | Line 387 | int get_proc_snapshot(proc_state_t **ps){
387                          proc_state_ptr->proctitle = NULL;
388                  }
389   #else
390 +                free(proc_state_ptr->proctitle);
391                  if(kvmd != NULL) {
392                          args = kvm_getargv(kvmd, &(kp_stats[i]), 0);
393                          if(args != NULL) {
394 <                                alloc = 1;
395 <                                proctitle = malloc(alloc);
394 >                                argsp = args;
395 >                                while(*argsp != NULL) {
396 >                                        argslen += strlen(*argsp) + 1;
397 >                                        argsp++;
398 >                                }
399 >                                proctitle = malloc(argslen + 1);
400 >                                proctitle[0] = '\0';
401                                  if(proctitle == NULL) {
402                                          return NULL;
403                                  }
404                                  while(*args != NULL) {
405 <                                        if(strlen(proctitle) + strlen(*args) >= alloc) {
406 <                                                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);
405 >                                        sg_strlcat(proctitle, *args, argslen + 1);
406 >                                        sg_strlcat(proctitle, " ", argslen + 1);
407                                          args++;
408                                  }
409                                  /* remove trailing space */
# Line 413 | Line 480 | int get_proc_snapshot(proc_state_t **ps){
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 423 | Line 556 | int get_proc_snapshot(proc_state_t **ps){
556   #ifdef SONPROC
557                  case SONPROC: /* NetBSD */
558   #endif
559 <                        proc_state_ptr->state = RUNNING;
559 >                        proc_state_ptr->state = SG_PROCESS_STATE_RUNNING;
560                          break;
561                  case SSLEEP:
562   #ifdef SWAIT
# Line 432 | Line 565 | int get_proc_snapshot(proc_state_t **ps){
565   #ifdef SLOCK
566                  case SLOCK: /* FreeBSD 5 */
567   #endif
568 <                        proc_state_ptr->state = SLEEPING;
568 >                        proc_state_ptr->state = SG_PROCESS_STATE_SLEEPING;
569                          break;
570                  case SSTOP:
571 <                        proc_state_ptr->state = STOPPED;
571 >                        proc_state_ptr->state = SG_PROCESS_STATE_STOPPED;
572                          break;
573                  case SZOMB:
574   #ifdef SDEAD
575                  case SDEAD: /* OpenBSD & NetBSD */
576   #endif
577 <                        proc_state_ptr->state = ZOMBIE;
577 >                        proc_state_ptr->state = SG_PROCESS_STATE_ZOMBIE;
578                          break;
579                  default:
580 <                        proc_state_ptr->state = UNKNOWN;
580 >                        proc_state_ptr->state = SG_PROCESS_STATE_UNKNOWN;
581                          break;
582                  }
583 + #endif
584                  proc_state_size++;
585          }
586  
587          free(kp_stats);
588   #endif
589  
590 <        *ps = proc_state;
591 <        return proc_state_size;
590 > #ifdef CYGWIN
591 >        return NULL;
592 > #endif
593 >
594 >        *entries = proc_state_size;
595 >        return proc_state;
596   }
597  
598 < process_stat_t *get_process_stats() {
599 <        static process_stat_t process_stat;
600 <        proc_state_t *ps;
598 > sg_process_count *sg_get_process_count() {
599 >        static sg_process_count process_stat;
600 >        sg_process_stats *ps;
601          int ps_size, x;
602  
603          process_stat.sleeping = 0;
# Line 468 | Line 606 | process_stat_t *get_process_stats() {
606          process_stat.stopped = 0;
607          process_stat.total = 0;
608  
609 <        ps_size = get_proc_snapshot(&ps);
610 <
473 <        if(ps_size == 0) {
609 >        ps = sg_get_process_stats(&ps_size);
610 >        if (ps == NULL) {
611                  return NULL;
612          }
613  
614          for(x = 0; x < ps_size; x++) {
615                  switch (ps->state) {
616 <                case RUNNING:
616 >                case SG_PROCESS_STATE_RUNNING:
617                          process_stat.running++;
618                          break;
619 <                case SLEEPING:
619 >                case SG_PROCESS_STATE_SLEEPING:
620                          process_stat.sleeping++;
621                          break;
622 <                case STOPPED:
622 >                case SG_PROCESS_STATE_STOPPED:
623                          process_stat.stopped++;
624                          break;
625 <                case ZOMBIE:
625 >                case SG_PROCESS_STATE_ZOMBIE:
626                          process_stat.zombie++;
627                          break;
628                  default:
629 <                        /* currently no mapping for UNKNOWN in process_stat_t */
629 >                        /* currently no mapping for SG_PROCESS_STATE_UNKNOWN in
630 >                         * sg_process_count */
631                          break;
632                  }
633                  ps++;

Diff Legend

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