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.52 by ats, Mon Apr 5 15:40:15 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,
185 >                if (sg_update_string(&proc_state_ptr->process_name,
186                                    &ps_name[1]) == NULL) {
187 <                        return -1;
187 >                        return NULL;
188                  }
189  
190                  /* Need to do cpu */
# Line 205 | Line 205 | int get_proc_snapshot(proc_state_t **ps){
205                  len = 0;
206                  do {
207                          if (VECTOR_RESIZE(psargs, len + READ_BLOCK_SIZE + 1) < 0) {
208 <                                return -1;
208 >                                return NULL;
209                          }
210                          rc = read(fn, psargs + len, READ_BLOCK_SIZE);
211                          if (rc > 0) {
# Line 228 | Line 228 | int get_proc_snapshot(proc_state_t **ps){
228                  /* for safety's sake */
229                  psargs[len] = '\0';
230  
231 <                if (update_string(&proc_state_ptr->proctitle, psargs) == NULL) {
232 <                        return -1;
231 >                if (sg_update_string(&proc_state_ptr->proctitle, psargs) == NULL) {
232 >                        return NULL;
233                  }
234   #endif
235  
# Line 244 | Line 244 | int get_proc_snapshot(proc_state_t **ps){
244          mib[2] = KERN_PROC_ALL;
245  
246          if(sysctl(mib, 3, NULL, &size, NULL, 0) < 0) {
247 <                return -1;
247 >                return NULL;
248          }
249  
250          procs = size / sizeof(struct kinfo_proc);
251  
252          kp_stats = malloc(size);
253          if(kp_stats == NULL) {
254 <                return -1;
254 >                return NULL;
255          }
256  
257          if(sysctl(mib, 3, kp_stats, &size, NULL, 0) < 0) {
258                  free(kp_stats);
259 <                return -1;
259 >                return NULL;
260          }
261  
262   #if (defined(FREEBSD) && !defined(FREEBSD5)) || defined(DFBSD)
263 <        kvmd = get_kvm2();
263 >        kvmd = sg_get_kvm2();
264   #endif
265  
266          for (i = 0; i < procs; i++) {
267                  const char *name;
268  
269                  if (VECTOR_RESIZE(proc_state, proc_state_size + 1) < 0) {
270 <                        return -1;
270 >                        return NULL;
271                  }
272                  proc_state_ptr = proc_state+proc_state_size;
273  
# Line 278 | Line 278 | int get_proc_snapshot(proc_state_t **ps){
278   #else
279                  name = kp_stats[i].kp_proc.p_comm;
280   #endif
281 <                if (update_string(&proc_state_ptr->process_name, name) == NULL) {
282 <                        return -1;
281 >                if (sg_update_string(&proc_state_ptr->process_name, name) == NULL) {
282 >                        return NULL;
283                  }
284  
285   #if defined(FREEBSD5) || defined(NETBSD) || defined(OPENBSD)
# Line 287 | Line 287 | int get_proc_snapshot(proc_state_t **ps){
287  
288   #ifdef FREEBSD5
289                  if(sysctlbyname("kern.ps_arg_cache_limit", &buflen, &size, NULL, 0) < 0) {
290 <                        return -1;
290 >                        return NULL;
291                  }
292   #else
293                  mib[1] = KERN_ARGMAX;
294  
295                  if(sysctl(mib, 2, &buflen, &size, NULL, 0) < 0) {
296 <                        return -1;
296 >                        return NULL;
297                  }
298   #endif
299  
300                  proctitle = malloc(buflen);
301                  if(proctitle == NULL) {
302 <                        return -1;
302 >                        return NULL;
303                  }
304  
305                  size = buflen;
# Line 321 | Line 321 | int get_proc_snapshot(proc_state_t **ps){
321                  else if(size > 0) {
322                          proc_state_ptr->proctitle = malloc(size+1);
323                          if(proc_state_ptr->proctitle == NULL) {
324 <                                return -1;
324 >                                return NULL;
325                          }
326                          p = proctitle;
327                          proc_state_ptr->proctitle[0] = '\0';
328                          do {
329 <                                strlcat(proc_state_ptr->proctitle, p, size+1);
330 <                                strlcat(proc_state_ptr->proctitle, " ", size+1);
329 >                                sg_strlcat(proc_state_ptr->proctitle, p, size+1);
330 >                                sg_strlcat(proc_state_ptr->proctitle, " ", size+1);
331                                  p += strlen(p) + 1;
332                          } while (p < proctitle + size);
333                          free(proctitle);
# Line 351 | Line 351 | int get_proc_snapshot(proc_state_t **ps){
351                                  proctitle = malloc(argslen + 1);
352                                  proctitle[0] = '\0';
353                                  if(proctitle == NULL) {
354 <                                        return -1;
354 >                                        return NULL;
355                                  }
356                                  while(*args != NULL) {
357 <                                        strlcat(proctitle, *args, argslen + 1);
358 <                                        strlcat(proctitle, " ", argslen + 1);
357 >                                        sg_strlcat(proctitle, *args, argslen + 1);
358 >                                        sg_strlcat(proctitle, " ", argslen + 1);
359                                          args++;
360                                  }
361                                  /* remove trailing space */
# Line 442 | Line 442 | int get_proc_snapshot(proc_state_t **ps){
442   #ifdef SONPROC
443                  case SONPROC: /* NetBSD */
444   #endif
445 <                        proc_state_ptr->state = RUNNING;
445 >                        proc_state_ptr->state = SG_PROCESS_STATE_RUNNING;
446                          break;
447                  case SSLEEP:
448   #ifdef SWAIT
# Line 451 | Line 451 | int get_proc_snapshot(proc_state_t **ps){
451   #ifdef SLOCK
452                  case SLOCK: /* FreeBSD 5 */
453   #endif
454 <                        proc_state_ptr->state = SLEEPING;
454 >                        proc_state_ptr->state = SG_PROCESS_STATE_SLEEPING;
455                          break;
456                  case SSTOP:
457 <                        proc_state_ptr->state = STOPPED;
457 >                        proc_state_ptr->state = SG_PROCESS_STATE_STOPPED;
458                          break;
459                  case SZOMB:
460   #ifdef SDEAD
461                  case SDEAD: /* OpenBSD & NetBSD */
462   #endif
463 <                        proc_state_ptr->state = ZOMBIE;
463 >                        proc_state_ptr->state = SG_PROCESS_STATE_ZOMBIE;
464                          break;
465                  default:
466 <                        proc_state_ptr->state = UNKNOWN;
466 >                        proc_state_ptr->state = SG_PROCESS_STATE_UNKNOWN;
467                          break;
468                  }
469                  proc_state_size++;
# Line 473 | Line 473 | int get_proc_snapshot(proc_state_t **ps){
473   #endif
474  
475   #ifdef CYGWIN
476 <        return -1;
476 >        return NULL;
477   #endif
478  
479 <        *ps = proc_state;
480 <        return proc_state_size;
479 >        *entries = proc_state_size;
480 >        return proc_state;
481   }
482  
483 < process_stat_t *get_process_stats() {
484 <        static process_stat_t process_stat;
485 <        proc_state_t *ps;
483 > sg_process_count *sg_get_process_count() {
484 >        static sg_process_count process_stat;
485 >        sg_process_stats *ps;
486          int ps_size, x;
487  
488          process_stat.sleeping = 0;
# Line 491 | Line 491 | process_stat_t *get_process_stats() {
491          process_stat.stopped = 0;
492          process_stat.total = 0;
493  
494 <        ps_size = get_proc_snapshot(&ps);
495 <
496 <        if(ps_size < 0) {
494 >        ps = sg_get_process_stats(&ps_size);
495 >        if (ps == NULL) {
496                  return NULL;
497          }
498  
499          for(x = 0; x < ps_size; x++) {
500                  switch (ps->state) {
501 <                case RUNNING:
501 >                case SG_PROCESS_STATE_RUNNING:
502                          process_stat.running++;
503                          break;
504 <                case SLEEPING:
504 >                case SG_PROCESS_STATE_SLEEPING:
505                          process_stat.sleeping++;
506                          break;
507 <                case STOPPED:
507 >                case SG_PROCESS_STATE_STOPPED:
508                          process_stat.stopped++;
509                          break;
510 <                case ZOMBIE:
510 >                case SG_PROCESS_STATE_ZOMBIE:
511                          process_stat.zombie++;
512                          break;
513                  default:
514 <                        /* currently no mapping for UNKNOWN in process_stat_t */
514 >                        /* currently no mapping for SG_PROCESS_STATE_UNKNOWN in
515 >                         * sg_process_count */
516                          break;
517                  }
518                  ps++;

Diff Legend

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