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.50 by tdb, Mon Apr 5 09:33:38 2004 UTC vs.
Revision 1.53 by ats, Mon Apr 5 18:10:11 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  
268          if(sysctl(mib, 3, kp_stats, &size, NULL, 0) < 0) {
269                  free(kp_stats);
270 <                return -1;
270 >                return NULL;
271          }
272  
273   #if (defined(FREEBSD) && !defined(FREEBSD5)) || defined(DFBSD)
274 <        kvmd = get_kvm2();
274 >        kvmd = sg_get_kvm2();
275   #endif
276  
277          for (i = 0; i < procs; i++) {
278                  const char *name;
279  
280                  if (VECTOR_RESIZE(proc_state, proc_state_size + 1) < 0) {
281 <                        return -1;
281 >                        return NULL;
282                  }
283                  proc_state_ptr = proc_state+proc_state_size;
284  
# Line 278 | Line 289 | int get_proc_snapshot(proc_state_t **ps){
289   #else
290                  name = kp_stats[i].kp_proc.p_comm;
291   #endif
292 <                if (update_string(&proc_state_ptr->process_name, name) == NULL) {
293 <                        return -1;
292 >                if (sg_update_string(&proc_state_ptr->process_name, name) < 0) {
293 >                        return NULL;
294                  }
295  
296   #if defined(FREEBSD5) || defined(NETBSD) || defined(OPENBSD)
# Line 287 | Line 298 | int get_proc_snapshot(proc_state_t **ps){
298  
299   #ifdef FREEBSD5
300                  if(sysctlbyname("kern.ps_arg_cache_limit", &buflen, &size, NULL, 0) < 0) {
301 <                        return -1;
301 >                        return NULL;
302                  }
303   #else
304                  mib[1] = KERN_ARGMAX;
305  
306                  if(sysctl(mib, 2, &buflen, &size, NULL, 0) < 0) {
307 <                        return -1;
307 >                        return NULL;
308                  }
309   #endif
310  
311                  proctitle = malloc(buflen);
312                  if(proctitle == NULL) {
313 <                        return -1;
313 >                        return NULL;
314                  }
315  
316                  size = buflen;
# Line 321 | Line 332 | int get_proc_snapshot(proc_state_t **ps){
332                  else if(size > 0) {
333                          proc_state_ptr->proctitle = malloc(size+1);
334                          if(proc_state_ptr->proctitle == NULL) {
335 <                                return -1;
335 >                                return NULL;
336                          }
337                          p = proctitle;
338                          proc_state_ptr->proctitle[0] = '\0';
339                          do {
340 <                                strlcat(proc_state_ptr->proctitle, p, size+1);
341 <                                strlcat(proc_state_ptr->proctitle, " ", size+1);
340 >                                sg_strlcat(proc_state_ptr->proctitle, p, size+1);
341 >                                sg_strlcat(proc_state_ptr->proctitle, " ", size+1);
342                                  p += strlen(p) + 1;
343                          } while (p < proctitle + size);
344                          free(proctitle);
# Line 345 | Line 356 | int get_proc_snapshot(proc_state_t **ps){
356                          if(args != NULL) {
357                                  argsp = args;
358                                  while(*argsp != NULL) {
359 <                                        argslen += strlen(*args);
360 <                                        args++;
359 >                                        argslen += strlen(*argsp) + 1;
360 >                                        argsp++;
361                                  }
362                                  proctitle = malloc(argslen + 1);
363                                  proctitle[0] = '\0';
364                                  if(proctitle == NULL) {
365 <                                        return -1;
365 >                                        return NULL;
366                                  }
367                                  while(*args != NULL) {
368 <                                        strlcat(proctitle, *args, argslen);
369 <                                        strlcat(proctitle, " ", argslen);
368 >                                        sg_strlcat(proctitle, *args, argslen + 1);
369 >                                        sg_strlcat(proctitle, " ", argslen + 1);
370                                          args++;
371                                  }
372                                  /* remove trailing space */
# Line 442 | Line 453 | int get_proc_snapshot(proc_state_t **ps){
453   #ifdef SONPROC
454                  case SONPROC: /* NetBSD */
455   #endif
456 <                        proc_state_ptr->state = RUNNING;
456 >                        proc_state_ptr->state = SG_PROCESS_STATE_RUNNING;
457                          break;
458                  case SSLEEP:
459   #ifdef SWAIT
# Line 451 | Line 462 | int get_proc_snapshot(proc_state_t **ps){
462   #ifdef SLOCK
463                  case SLOCK: /* FreeBSD 5 */
464   #endif
465 <                        proc_state_ptr->state = SLEEPING;
465 >                        proc_state_ptr->state = SG_PROCESS_STATE_SLEEPING;
466                          break;
467                  case SSTOP:
468 <                        proc_state_ptr->state = STOPPED;
468 >                        proc_state_ptr->state = SG_PROCESS_STATE_STOPPED;
469                          break;
470                  case SZOMB:
471   #ifdef SDEAD
472                  case SDEAD: /* OpenBSD & NetBSD */
473   #endif
474 <                        proc_state_ptr->state = ZOMBIE;
474 >                        proc_state_ptr->state = SG_PROCESS_STATE_ZOMBIE;
475                          break;
476                  default:
477 <                        proc_state_ptr->state = UNKNOWN;
477 >                        proc_state_ptr->state = SG_PROCESS_STATE_UNKNOWN;
478                          break;
479                  }
480                  proc_state_size++;
# Line 473 | Line 484 | int get_proc_snapshot(proc_state_t **ps){
484   #endif
485  
486   #ifdef CYGWIN
487 <        return -1;
487 >        return NULL;
488   #endif
489  
490 <        *ps = proc_state;
491 <        return proc_state_size;
490 >        *entries = proc_state_size;
491 >        return proc_state;
492   }
493  
494 < process_stat_t *get_process_stats() {
495 <        static process_stat_t process_stat;
496 <        proc_state_t *ps;
494 > sg_process_count *sg_get_process_count() {
495 >        static sg_process_count process_stat;
496 >        sg_process_stats *ps;
497          int ps_size, x;
498  
499          process_stat.sleeping = 0;
# Line 491 | Line 502 | process_stat_t *get_process_stats() {
502          process_stat.stopped = 0;
503          process_stat.total = 0;
504  
505 <        ps_size = get_proc_snapshot(&ps);
506 <
496 <        if(ps_size < 0) {
505 >        ps = sg_get_process_stats(&ps_size);
506 >        if (ps == NULL) {
507                  return NULL;
508          }
509  
510          for(x = 0; x < ps_size; x++) {
511                  switch (ps->state) {
512 <                case RUNNING:
512 >                case SG_PROCESS_STATE_RUNNING:
513                          process_stat.running++;
514                          break;
515 <                case SLEEPING:
515 >                case SG_PROCESS_STATE_SLEEPING:
516                          process_stat.sleeping++;
517                          break;
518 <                case STOPPED:
518 >                case SG_PROCESS_STATE_STOPPED:
519                          process_stat.stopped++;
520                          break;
521 <                case ZOMBIE:
521 >                case SG_PROCESS_STATE_ZOMBIE:
522                          process_stat.zombie++;
523                          break;
524                  default:
525 <                        /* currently no mapping for UNKNOWN in process_stat_t */
525 >                        /* currently no mapping for SG_PROCESS_STATE_UNKNOWN in
526 >                         * sg_process_count */
527                          break;
528                  }
529                  ps++;

Diff Legend

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