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.51 by tdb, Mon Apr 5 11:21:49 2004 UTC vs.
Revision 1.54 by ats, Mon Apr 5 19:55:27 2004 UTC

# Line 70 | Line 70
70   #include <unistd.h>
71   #endif
72  
73 < static void proc_state_init(proc_state_t *s) {
73 > static void proc_state_init(sg_process_stats *s) {
74          s->process_name = NULL;
75          s->proctitle = NULL;
76   }
77  
78 < static void proc_state_destroy(proc_state_t *s) {
78 > static void proc_state_destroy(sg_process_stats *s) {
79          free(s->process_name);
80          free(s->proctitle);
81   }
82  
83 < int get_proc_snapshot(proc_state_t **ps){
84 <        VECTOR_DECLARE_STATIC(proc_state, proc_state_t, 64,
83 > sg_process_stats *sg_get_process_stats(int *entries){
84 >        VECTOR_DECLARE_STATIC(proc_state, sg_process_stats, 64,
85                                proc_state_init, proc_state_destroy);
86          int proc_state_size = 0;
87 <        proc_state_t *proc_state_ptr;
87 >        sg_process_stats *proc_state_ptr;
88   #ifdef ALLBSD
89          int mib[4];
90          size_t size;
# Line 122 | Line 122 | int get_proc_snapshot(proc_state_t **ps){
122   #endif
123  
124          if((proc_dir=opendir(PROC_LOCATION))==NULL){
125 <                return -1;
125 >                return NULL;
126          }
127  
128          while((dir_entry=readdir(proc_dir))!=NULL){
# Line 144 | Line 144 | int get_proc_snapshot(proc_state_t **ps){
144   #endif
145  
146                  if (VECTOR_RESIZE(proc_state, proc_state_size + 1) < 0) {
147 <                        return -1;
147 >                        return NULL;
148                  }
149                  proc_state_ptr = proc_state+proc_state_size;
150  
# Line 163 | Line 163 | int get_proc_snapshot(proc_state_t **ps){
163                  proc_state_ptr->process_name = strdup(process_info.pr_fname);
164                  proc_state_ptr->proctitle = strdup(process_info.pr_psargs);
165  
166 <                if(process_info.pr_lwp.pr_state==1) proc_state_ptr->state = SLEEPING;
167 <                if(process_info.pr_lwp.pr_state==2) proc_state_ptr->state = RUNNING;
168 <                if(process_info.pr_lwp.pr_state==3) proc_state_ptr->state = ZOMBIE;
169 <                if(process_info.pr_lwp.pr_state==4) proc_state_ptr->state = STOPPED;
170 <                if(process_info.pr_lwp.pr_state==6) proc_state_ptr->state = RUNNING;
166 >                if(process_info.pr_lwp.pr_state==1) proc_state_ptr->state = SG_PROCESS_STATE_SLEEPING;
167 >                if(process_info.pr_lwp.pr_state==2) proc_state_ptr->state = SG_PROCESS_STATE_RUNNING;
168 >                if(process_info.pr_lwp.pr_state==3) proc_state_ptr->state = SG_PROCESS_STATE_ZOMBIE;
169 >                if(process_info.pr_lwp.pr_state==4) proc_state_ptr->state = SG_PROCESS_STATE_STOPPED;
170 >                if(process_info.pr_lwp.pr_state==6) proc_state_ptr->state = SG_PROCESS_STATE_RUNNING;
171   #endif
172   #ifdef LINUX
173                  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));
174                  proc_state_ptr->proc_resident = proc_state_ptr->proc_resident * getpagesize();
175 <                if(s == 'S') proc_state_ptr->state = SLEEPING;
176 <                if(s == 'R') proc_state_ptr->state = RUNNING;
177 <                if(s == 'Z') proc_state_ptr->state = ZOMBIE;
178 <                if(s == 'T') proc_state_ptr->state = STOPPED;
179 <                if(s == 'D') proc_state_ptr->state = STOPPED;
175 >                if(s == 'S') proc_state_ptr->state = SG_PROCESS_STATE_SLEEPING;
176 >                if(s == 'R') proc_state_ptr->state = SG_PROCESS_STATE_RUNNING;
177 >                if(s == 'Z') proc_state_ptr->state = SG_PROCESS_STATE_ZOMBIE;
178 >                if(s == 'T') proc_state_ptr->state = SG_PROCESS_STATE_STOPPED;
179 >                if(s == 'D') proc_state_ptr->state = SG_PROCESS_STATE_STOPPED;
180          
181                  /* pa_name[0] should = '(' */
182                  ptr = strchr(&ps_name[1], ')');
183                  if(ptr !=NULL) *ptr='\0';
184  
185 <                if (update_string(&proc_state_ptr->process_name,
186 <                                  &ps_name[1]) == NULL) {
187 <                        return -1;
185 >                if (sg_update_string(&proc_state_ptr->process_name,
186 >                                     &ps_name[1]) < 0) {
187 >                        return NULL;
188                  }
189  
190                  /* Need to do cpu */
# Line 204 | Line 204 | int get_proc_snapshot(proc_state_t **ps){
204   #define READ_BLOCK_SIZE 128
205                  len = 0;
206                  do {
207 <                        if (VECTOR_RESIZE(psargs, len + READ_BLOCK_SIZE + 1) < 0) {
208 <                                return -1;
207 >                        if (VECTOR_RESIZE(psargs, len + READ_BLOCK_SIZE) < 0) {
208 >                                return NULL;
209                          }
210                          rc = read(fn, psargs + len, READ_BLOCK_SIZE);
211                          if (rc > 0) {
# Line 225 | Line 225 | int get_proc_snapshot(proc_state_t **ps){
225                          if (*ptr == '\0') *ptr = ' ';
226                          ptr++;
227                  }
228 –                /* for safety's sake */
229 –                psargs[len] = '\0';
228  
229 <                if (update_string(&proc_state_ptr->proctitle, psargs) == NULL) {
230 <                        return -1;
229 >                if (len == 0) {
230 >                        /* We want psargs to be NULL. */
231 >                        if (VECTOR_RESIZE(psargs, 0) < 0) {
232 >                                return NULL;
233 >                        }
234 >                } else {
235 >                        /* Not empty, so append a \0. */
236 >                        if (VECTOR_RESIZE(psargs, len + 1) < 0) {
237 >                                return NULL;
238 >                        }
239 >                        psargs[len] = '\0';
240                  }
241 +
242 +                if (sg_update_string(&proc_state_ptr->proctitle, psargs) < 0) {
243 +                        return NULL;
244 +                }
245   #endif
246  
247                  proc_state_size++;
# Line 244 | Line 255 | int get_proc_snapshot(proc_state_t **ps){
255          mib[2] = KERN_PROC_ALL;
256  
257          if(sysctl(mib, 3, NULL, &size, NULL, 0) < 0) {
258 <                return -1;
258 >                return NULL;
259          }
260  
261          procs = size / sizeof(struct kinfo_proc);
262  
263          kp_stats = malloc(size);
264          if(kp_stats == NULL) {
265 <                return -1;
265 >                return NULL;
266          }
267 +        memset(kp_stats, 0, size);
268  
269          if(sysctl(mib, 3, kp_stats, &size, NULL, 0) < 0) {
270                  free(kp_stats);
271 <                return -1;
271 >                return NULL;
272          }
273  
274   #if (defined(FREEBSD) && !defined(FREEBSD5)) || defined(DFBSD)
275 <        kvmd = get_kvm2();
275 >        kvmd = sg_get_kvm2();
276   #endif
277  
278          for (i = 0; i < procs; i++) {
279                  const char *name;
280  
281 +                if (kp_stats[i].ki_stat == 0) {
282 +                        /* FreeBSD 5 deliberately overallocates the array that
283 +                         * the sysctl returns, so we'll get a few junk
284 +                         * processes on the end that we have to ignore. (Search
285 +                         * for "overestimate by 5 procs" in
286 +                         * src/sys/kern/kern_proc.c for more details.) */
287 +                        continue;
288 +                }
289 +
290                  if (VECTOR_RESIZE(proc_state, proc_state_size + 1) < 0) {
291 <                        return -1;
291 >                        return NULL;
292                  }
293                  proc_state_ptr = proc_state+proc_state_size;
294  
# Line 278 | Line 299 | int get_proc_snapshot(proc_state_t **ps){
299   #else
300                  name = kp_stats[i].kp_proc.p_comm;
301   #endif
302 <                if (update_string(&proc_state_ptr->process_name, name) == NULL) {
303 <                        return -1;
302 >                if (sg_update_string(&proc_state_ptr->process_name, name) < 0) {
303 >                        return NULL;
304                  }
305  
306   #if defined(FREEBSD5) || defined(NETBSD) || defined(OPENBSD)
# Line 287 | Line 308 | int get_proc_snapshot(proc_state_t **ps){
308  
309   #ifdef FREEBSD5
310                  if(sysctlbyname("kern.ps_arg_cache_limit", &buflen, &size, NULL, 0) < 0) {
311 <                        return -1;
311 >                        return NULL;
312                  }
313   #else
314                  mib[1] = KERN_ARGMAX;
315  
316                  if(sysctl(mib, 2, &buflen, &size, NULL, 0) < 0) {
317 <                        return -1;
317 >                        return NULL;
318                  }
319   #endif
320  
321                  proctitle = malloc(buflen);
322                  if(proctitle == NULL) {
323 <                        return -1;
323 >                        return NULL;
324                  }
325  
326                  size = buflen;
# Line 321 | Line 342 | int get_proc_snapshot(proc_state_t **ps){
342                  else if(size > 0) {
343                          proc_state_ptr->proctitle = malloc(size+1);
344                          if(proc_state_ptr->proctitle == NULL) {
345 <                                return -1;
345 >                                return NULL;
346                          }
347                          p = proctitle;
348                          proc_state_ptr->proctitle[0] = '\0';
349                          do {
350 <                                strlcat(proc_state_ptr->proctitle, p, size+1);
351 <                                strlcat(proc_state_ptr->proctitle, " ", size+1);
350 >                                sg_strlcat(proc_state_ptr->proctitle, p, size+1);
351 >                                sg_strlcat(proc_state_ptr->proctitle, " ", size+1);
352                                  p += strlen(p) + 1;
353                          } while (p < proctitle + size);
354                          free(proctitle);
# Line 351 | Line 372 | int get_proc_snapshot(proc_state_t **ps){
372                                  proctitle = malloc(argslen + 1);
373                                  proctitle[0] = '\0';
374                                  if(proctitle == NULL) {
375 <                                        return -1;
375 >                                        return NULL;
376                                  }
377                                  while(*args != NULL) {
378 <                                        strlcat(proctitle, *args, argslen + 1);
379 <                                        strlcat(proctitle, " ", argslen + 1);
378 >                                        sg_strlcat(proctitle, *args, argslen + 1);
379 >                                        sg_strlcat(proctitle, " ", argslen + 1);
380                                          args++;
381                                  }
382                                  /* remove trailing space */
# Line 442 | Line 463 | int get_proc_snapshot(proc_state_t **ps){
463   #ifdef SONPROC
464                  case SONPROC: /* NetBSD */
465   #endif
466 <                        proc_state_ptr->state = RUNNING;
466 >                        proc_state_ptr->state = SG_PROCESS_STATE_RUNNING;
467                          break;
468                  case SSLEEP:
469   #ifdef SWAIT
# Line 451 | Line 472 | int get_proc_snapshot(proc_state_t **ps){
472   #ifdef SLOCK
473                  case SLOCK: /* FreeBSD 5 */
474   #endif
475 <                        proc_state_ptr->state = SLEEPING;
475 >                        proc_state_ptr->state = SG_PROCESS_STATE_SLEEPING;
476                          break;
477                  case SSTOP:
478 <                        proc_state_ptr->state = STOPPED;
478 >                        proc_state_ptr->state = SG_PROCESS_STATE_STOPPED;
479                          break;
480                  case SZOMB:
481   #ifdef SDEAD
482                  case SDEAD: /* OpenBSD & NetBSD */
483   #endif
484 <                        proc_state_ptr->state = ZOMBIE;
484 >                        proc_state_ptr->state = SG_PROCESS_STATE_ZOMBIE;
485                          break;
486                  default:
487 <                        proc_state_ptr->state = UNKNOWN;
487 >                        proc_state_ptr->state = SG_PROCESS_STATE_UNKNOWN;
488                          break;
489                  }
490                  proc_state_size++;
# Line 473 | Line 494 | int get_proc_snapshot(proc_state_t **ps){
494   #endif
495  
496   #ifdef CYGWIN
497 <        return -1;
497 >        return NULL;
498   #endif
499  
500 <        *ps = proc_state;
501 <        return proc_state_size;
500 >        *entries = proc_state_size;
501 >        return proc_state;
502   }
503  
504 < process_stat_t *get_process_stats() {
505 <        static process_stat_t process_stat;
506 <        proc_state_t *ps;
504 > sg_process_count *sg_get_process_count() {
505 >        static sg_process_count process_stat;
506 >        sg_process_stats *ps;
507          int ps_size, x;
508  
509          process_stat.sleeping = 0;
# Line 491 | Line 512 | process_stat_t *get_process_stats() {
512          process_stat.stopped = 0;
513          process_stat.total = 0;
514  
515 <        ps_size = get_proc_snapshot(&ps);
516 <
496 <        if(ps_size < 0) {
515 >        ps = sg_get_process_stats(&ps_size);
516 >        if (ps == NULL) {
517                  return NULL;
518          }
519  
520          for(x = 0; x < ps_size; x++) {
521                  switch (ps->state) {
522 <                case RUNNING:
522 >                case SG_PROCESS_STATE_RUNNING:
523                          process_stat.running++;
524                          break;
525 <                case SLEEPING:
525 >                case SG_PROCESS_STATE_SLEEPING:
526                          process_stat.sleeping++;
527                          break;
528 <                case STOPPED:
528 >                case SG_PROCESS_STATE_STOPPED:
529                          process_stat.stopped++;
530                          break;
531 <                case ZOMBIE:
531 >                case SG_PROCESS_STATE_ZOMBIE:
532                          process_stat.zombie++;
533                          break;
534                  default:
535 <                        /* currently no mapping for UNKNOWN in process_stat_t */
535 >                        /* currently no mapping for SG_PROCESS_STATE_UNKNOWN in
536 >                         * sg_process_count */
537                          break;
538                  }
539                  ps++;

Diff Legend

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