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.32 by tdb, Sun Apr 4 11:02:30 2004 UTC vs.
Revision 1.47 by tdb, Mon Apr 5 00:21:29 2004 UTC

# Line 61 | Line 61
61   #include <paths.h>
62   #include <fcntl.h>
63   #include <limits.h>
64 + #if (defined(FREEBSD) && !defined(FREEBSD5)) || defined(DFBSD)
65   #include <kvm.h>
66 + #include <tools.h>
67   #endif
68 + #include <unistd.h>
69 + #endif
70  
71   int get_proc_snapshot(proc_state_t **ps){
72          proc_state_t *proc_state = NULL;
73          proc_state_t *proc_state_ptr;
74          int proc_state_size = 0;
75   #ifdef ALLBSD
76 <        int mib[3];
76 >        int mib[4];
77          size_t size;
78          struct kinfo_proc *kp_stats;
79 <        int procs, i, alloc;
76 <        static kvm_t *kvmd;
77 <        char **args;
79 >        int procs, i;
80          char *proctitle;
81 + #if (defined(FREEBSD) && !defined(FREEBSD5)) || defined(DFBSD)
82 +        kvm_t *kvmd;
83 +        char **args;
84 +        int alloc;
85 +        char *proctitletmp;
86 + #else
87 +        long buflen;
88 +        char *p;
89   #endif
90 + #endif
91   #if defined(SOLARIS) || defined(LINUX)
92          DIR *proc_dir;
93          struct dirent *dir_entry;
# Line 146 | Line 157 | int get_proc_snapshot(proc_state_t **ps){
157                  if(process_info.pr_lwp.pr_state==6) proc_state_ptr->state = RUNNING;
158   #endif
159   #ifdef LINUX
160 <                x = fscanf(f, "%d %4096s %c %d %d %*d %*d %*d %*lu %*lu %*lu %*lu %*lu %lu %lu %*ld %*ld %*ld %d %*ld %*ld %*lu %llu %llu %*lu %*lu %*lu %*lu %*lu %*lu %*lu %*lu %*lu %*lu %*lu %*lu %*lu %*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));
160 >                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));
161                  proc_state_ptr->proc_resident = proc_state_ptr->proc_resident * getpagesize();
162                  if(s == 'S') proc_state_ptr->state = SLEEPING;
163                  if(s == 'R') proc_state_ptr->state = RUNNING;
# Line 207 | Line 218 | int get_proc_snapshot(proc_state_t **ps){
218   #endif
219  
220   #ifdef ALLBSD
221 <        kvmd = kvm_openfiles(_PATH_DEVNULL, _PATH_DEVNULL, NULL, O_RDONLY, NULL);
221 >        mib[0] = CTL_KERN;
222 >        mib[1] = KERN_PROC;
223 >        mib[2] = KERN_PROC_ALL;
224  
225 <        if(kvmd == NULL) return NULL;
225 >        if(sysctl(mib, 3, NULL, &size, NULL, 0) < 0) {
226 >                return -1;
227 >        }
228  
229 <        kp_stats = kvm_getprocs(kvmd, KERN_PROC_ALL, 0, &procs);
229 >        procs = size / sizeof(struct kinfo_proc);
230  
231 <        if (kp_stats == NULL || procs < 0) {
232 <                return NULL;
231 >        kp_stats = malloc(size);
232 >        if(kp_stats == NULL) {
233 >                return -1;
234          }
235  
236 +        if(sysctl(mib, 3, kp_stats, &size, NULL, 0) < 0) {
237 +                free(kp_stats);
238 +                return -1;
239 +        }
240 +
241 + #if (defined(FREEBSD) && !defined(FREEBSD5)) || defined(DFBSD)
242 +        kvmd = get_kvm2();
243 + #endif
244 +
245          for (i = 0; i < procs; i++) {
246                  /* replace with something more sensible */
247                  proc_state = realloc(proc_state,
248                                  (1+proc_state_size)*sizeof(proc_state_t));
249                  if(proc_state == NULL ) {
250 <                        return NULL;
250 >                        return -1;
251                  }
252                  proc_state_ptr = proc_state+proc_state_size;
253  
254   #ifdef FREEBSD5
255                  proc_state_ptr->process_name =
256                          strdup(kp_stats[i].ki_comm);
257 + #elif defined(DFBSD)
258 +                proc_state_ptr->process_name =
259 +                        strdup(kp_stats[i].kp_thread.td_comm);
260   #else
261                  proc_state_ptr->process_name =
262                          strdup(kp_stats[i].kp_proc.p_comm);
263   #endif
264  
265 <                args = kvm_getargv(kvmd, &(kp_stats[i]), 0);
266 <                if(args != NULL) {
267 <                        alloc = 1;
268 <                        proctitle = malloc(alloc);
269 <                        if(proctitle == NULL) {
270 <                                return NULL;
265 > #if defined(FREEBSD5) || defined(NETBSD) || defined(OPENBSD)
266 >                size = sizeof(buflen);
267 >
268 > #ifdef FREEBSD5
269 >                if(sysctlbyname("kern.ps_arg_cache_limit", &buflen, &size, NULL, 0) < 0) {
270 >                        return -1;
271 >                }
272 > #else
273 >                mib[1] = KERN_ARGMAX;
274 >
275 >                if(sysctl(mib, 2, &buflen, &size, NULL, 0) < 0) {
276 >                        return -1;
277 >                }
278 > #endif
279 >
280 >                proctitle = malloc(buflen);
281 >                if(proctitle == NULL) {
282 >                        return -1;
283 >                }
284 >
285 >                size = buflen;
286 >
287 > #ifdef FREEBSD5
288 >                mib[2] = KERN_PROC_ARGS;
289 >                mib[3] = kp_stats[i].ki_pid;
290 > #else
291 >                mib[1] = KERN_PROC_ARGS;
292 >                mib[2] = kp_stats[i].kp_proc.p_pid;
293 >                mib[3] = KERN_PROC_ARGV;
294 > #endif
295 >
296 >                if(sysctl(mib, 4, proctitle, &size, NULL, 0) < 0) {
297 >                        free(proctitle);
298 >                        proc_state_ptr->proctitle = NULL;
299 >                }
300 >                else if(size > 0) {
301 >                        proc_state_ptr->proctitle = malloc(size+1);
302 >                        if(proc_state_ptr->proctitle == NULL) {
303 >                                return -1;
304                          }
305 <                        while(*args != NULL) {
306 <                                if(strlen(proctitle) + strlen(*args) >= alloc) {
307 <                                        alloc = (alloc + strlen(*args)) << 1;
308 <                                        proctitle = realloc(proctitle, alloc);
309 <                                        if(proctitle == NULL) {
310 <                                                return NULL;
305 >                        p = proctitle;
306 >                        proc_state_ptr->proctitle[0] = NULL;
307 >                        do {
308 >                                strlcat(proc_state_ptr->proctitle, p, size+1);
309 >                                strlcat(proc_state_ptr->proctitle, " ", size+1);
310 >                                p += strlen(p) + 1;
311 >                        } while (p < proctitle + size);
312 >                        free(proctitle);
313 >                        /* remove trailing space */
314 >                        proc_state_ptr->proctitle[strlen(proc_state_ptr->proctitle)-1] = '\0';
315 >                }
316 >                else {
317 >                        free(proctitle);
318 >                        proc_state_ptr->proctitle = NULL;
319 >                }
320 > #else
321 >                if(kvmd != NULL) {
322 >                        args = kvm_getargv(kvmd, &(kp_stats[i]), 0);
323 >                        if(args != NULL) {
324 >                                alloc = 1;
325 >                                proctitle = malloc(alloc);
326 >                                if(proctitle == NULL) {
327 >                                        return -1;
328 >                                }
329 >                                while(*args != NULL) {
330 >                                        if(strlen(proctitle) + strlen(*args) >= alloc) {
331 >                                                alloc = (alloc + strlen(*args)) * 2;
332 >                                                proctitletmp = realloc(proctitle, alloc);
333 >                                                if(proctitletmp == NULL) {
334 >                                                        return -1;
335 >                                                }
336 >                                                proctitle = proctitletmp;
337                                          }
338 +                                        strlcat(proctitle, *args, alloc);
339 +                                        strlcat(proctitle, " ", alloc);
340 +                                        args++;
341                                  }
342 <                                strncat(proctitle, *args, strlen(*args));
343 <                                strncat(proctitle, " ", 1);
344 <                                args++;
342 >                                /* remove trailing space */
343 >                                proctitle[strlen(proctitle)-1] = '\0';
344 >                                proc_state_ptr->proctitle = proctitle;
345                          }
346 <                        /* remove trailing space */
347 <                        proctitle[strlen(proctitle)-1] = NULL;
348 <                        proc_state_ptr->proctitle = proctitle;
346 >                        else {
347 >                                proc_state_ptr->proctitle = NULL;
348 >                        }
349                  }
350                  else {
351 <                        proc_state_ptr->proctitle =
262 <                                malloc(strlen(proc_state_ptr->process_name)+4);
263 <                        if(proc_state_ptr->proctitle == NULL) {
264 <                                return NULL;
265 <                        }
266 <                        sprintf(proc_state_ptr->proctitle, " (%s)",
267 <                                proc_state_ptr->process_name);
351 >                        proc_state_ptr->proctitle = NULL;
352                  }
353 + #endif
354  
355   #ifdef FREEBSD5
356                  proc_state_ptr->pid = kp_stats[i].ki_pid;
# Line 282 | Line 367 | int get_proc_snapshot(proc_state_t **ps){
367                  proc_state_ptr->euid = kp_stats[i].ki_uid;
368                  proc_state_ptr->gid = kp_stats[i].ki_rgid;
369                  proc_state_ptr->egid = kp_stats[i].ki_svgid;
370 + #elif defined(DFBSD)
371 +                proc_state_ptr->uid = kp_stats[i].kp_eproc.e_ucred.cr_ruid;
372 +                proc_state_ptr->euid = kp_stats[i].kp_eproc.e_ucred.cr_svuid;
373 +                proc_state_ptr->gid = kp_stats[i].kp_eproc.e_ucred.cr_rgid;
374 +                proc_state_ptr->egid = kp_stats[i].kp_eproc.e_ucred.cr_svgid;
375   #else
376                  proc_state_ptr->uid = kp_stats[i].kp_eproc.e_pcred.p_ruid;
377                  proc_state_ptr->euid = kp_stats[i].kp_eproc.e_pcred.p_svuid;
# Line 305 | Line 395 | int get_proc_snapshot(proc_state_t **ps){
395                  /* This is in pages */
396                  proc_state_ptr->proc_resident =
397                          kp_stats[i].kp_eproc.e_vm.vm_rssize * getpagesize();
398 + #if defined(NETBSD) || defined(OPENBSD)
399 +                proc_state_ptr->time_spent =
400 +                        kp_stats[i].kp_proc.p_rtime.tv_sec;
401 + #elif defined(DFBSD)
402 +                proc_state_ptr->time_spent =
403 +                        ( kp_stats[i].kp_thread.td_uticks +
404 +                        kp_stats[i].kp_thread.td_sticks +
405 +                        kp_stats[i].kp_thread.td_iticks ) / 1000000;
406 + #else
407                  /* This is in microseconds */
408                  proc_state_ptr->time_spent =
409                          kp_stats[i].kp_proc.p_runtime / 1000000;
410 + #endif
411                  proc_state_ptr->cpu_percent =
412                          ((double)kp_stats[i].kp_proc.p_pctcpu / FSCALE) * 100.0;
413                  proc_state_ptr->nice = kp_stats[i].kp_proc.p_nice;
# Line 353 | Line 453 | int get_proc_snapshot(proc_state_t **ps){
453          free(kp_stats);
454   #endif
455  
456 + #ifdef CYGWIN
457 +        return -1;
458 + #endif
459 +
460          *ps = proc_state;
461          return proc_state_size;
462   }
# Line 370 | Line 474 | process_stat_t *get_process_stats() {
474  
475          ps_size = get_proc_snapshot(&ps);
476  
477 <        if(ps_size == NULL) {
477 >        if(ps_size < 0) {
478                  return NULL;
479          }
480  
481          for(x = 0; x < ps_size; x++) {
482                  switch (ps->state) {
379 –                /* currently no mapping for UNKNOWN in process_stat_t */
483                  case RUNNING:
484                          process_stat.running++;
485                          break;
# Line 388 | Line 491 | process_stat_t *get_process_stats() {
491                          break;
492                  case ZOMBIE:
493                          process_stat.zombie++;
494 +                        break;
495 +                default:
496 +                        /* currently no mapping for UNKNOWN in process_stat_t */
497                          break;
498                  }
499                  ps++;

Diff Legend

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