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.30 by tdb, Sat Apr 3 22:59:30 2004 UTC vs.
Revision 1.41 by tdb, Sun Apr 4 21:54:49 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   #endif
67 + #include <unistd.h>
68 + #endif
69  
70   int get_proc_snapshot(proc_state_t **ps){
71          proc_state_t *proc_state = NULL;
72          proc_state_t *proc_state_ptr;
73          int proc_state_size = 0;
74   #ifdef ALLBSD
75 <        int mib[3];
75 >        int mib[4];
76          size_t size;
77          struct kinfo_proc *kp_stats;
78 <        int procs, i, alloc;
78 >        int procs, i;
79 >        char *proctitle;
80 > #if (defined(FREEBSD) && !defined(FREEBSD5)) || defined(DFBSD)
81          static kvm_t *kvmd;
82          char **args;
83 <        char *proctitle;
83 >        int alloc;
84 > #else
85 >        long buflen;
86 >        char *p;
87   #endif
88 + #endif
89   #if defined(SOLARIS) || defined(LINUX)
90          DIR *proc_dir;
91          struct dirent *dir_entry;
# Line 146 | Line 155 | int get_proc_snapshot(proc_state_t **ps){
155                  if(process_info.pr_lwp.pr_state==6) proc_state_ptr->state = RUNNING;
156   #endif
157   #ifdef LINUX
158 <                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));
158 >                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));
159                  proc_state_ptr->proc_resident = proc_state_ptr->proc_resident * getpagesize();
160                  if(s == 'S') proc_state_ptr->state = SLEEPING;
161                  if(s == 'R') proc_state_ptr->state = RUNNING;
# Line 207 | Line 216 | int get_proc_snapshot(proc_state_t **ps){
216   #endif
217  
218   #ifdef ALLBSD
219 <        kvmd = kvm_openfiles(_PATH_DEVNULL, _PATH_DEVNULL, NULL, O_RDONLY, NULL);
219 >        mib[0] = CTL_KERN;
220 >        mib[1] = KERN_PROC;
221 >        mib[2] = KERN_PROC_ALL;
222  
223 <        if(kvmd == NULL) return NULL;
223 >        if(sysctl(mib, 3, NULL, &size, NULL, 0) < 0) {
224 >                return NULL;
225 >        }
226  
227 <        kp_stats = kvm_getprocs(kvmd, KERN_PROC_ALL, 0, &procs);
227 >        procs = size / sizeof(struct kinfo_proc);
228  
229 <        if (kp_stats == NULL || procs < 0) {
229 >        kp_stats = malloc(size);
230 >        if(kp_stats == NULL) {
231                  return NULL;
232          }
233  
234 +        if(sysctl(mib, 3, kp_stats, &size, NULL, 0) < 0) {
235 +                free(kp_stats);
236 +                return NULL;
237 +        }
238 +
239 + #if (defined(FREEBSD) && !defined(FREEBSD5)) || defined(DFBSD)
240 +        kvmd = kvm_openfiles(_PATH_DEVNULL, _PATH_DEVNULL, NULL, O_RDONLY, NULL);
241 + #endif
242 +
243          for (i = 0; i < procs; i++) {
244                  /* replace with something more sensible */
245                  proc_state = realloc(proc_state,
# Line 229 | Line 252 | int get_proc_snapshot(proc_state_t **ps){
252   #ifdef FREEBSD5
253                  proc_state_ptr->process_name =
254                          strdup(kp_stats[i].ki_comm);
255 + #elif defined(DFBSD)
256 +                proc_state_ptr->process_name =
257 +                        strdup(kp_stats[i].kp_thread.td_comm);
258   #else
259                  proc_state_ptr->process_name =
260                          strdup(kp_stats[i].kp_proc.p_comm);
261   #endif
262  
263 <                args = kvm_getargv(kvmd, &(kp_stats[i]), 0);
264 <                if(args != NULL) {
265 <                        alloc = 1;
266 <                        proctitle = malloc(alloc);
267 <                        if(proctitle == NULL) {
263 > #if defined(FREEBSD5) || defined(NETBSD) || defined(OPENBSD)
264 >                size = sizeof(buflen);
265 >
266 > #ifdef FREEBSD5
267 >                if(sysctlbyname("kern.ps_arg_cache_limit", &buflen, &size, NULL, 0) < 0) {
268 >                        return NULL;
269 >                }
270 > #else
271 >                mib[1] = KERN_ARGMAX;
272 >
273 >                if(sysctl(mib, 2, &buflen, &size, NULL, 0) < 0) {
274 >                        return NULL;
275 >                }
276 > #endif
277 >
278 >                proctitle = malloc(buflen);
279 >                if(proctitle == NULL) {
280 >                        return NULL;
281 >                }
282 >
283 >                size = buflen;
284 >
285 > #ifdef FREEBSD5
286 >                mib[2] = KERN_PROC_ARGS;
287 >                mib[3] = kp_stats[i].ki_pid;
288 > #else
289 >                mib[1] = KERN_PROC_ARGS;
290 >                mib[2] = kp_stats[i].kp_proc.p_pid;
291 >                mib[3] = KERN_PROC_ARGV;
292 > #endif
293 >
294 >                if(sysctl(mib, 4, proctitle, &size, NULL, 0) < 0) {
295 >                        free(proctitle);
296 >                        proc_state_ptr->proctitle = NULL;
297 >                }
298 >                else if(size > 0) {
299 >                        proc_state_ptr->proctitle = malloc(size);
300 >                        if(proc_state_ptr->proctitle == NULL) {
301                                  return NULL;
302                          }
303 <                        while(*args != NULL) {
304 <                                if(strlen(proctitle) + strlen(*args) >= alloc) {
305 <                                        alloc = (alloc + strlen(*args)) << 1;
306 <                                        proctitle = realloc(proctitle, alloc);
307 <                                        if(proctitle == NULL) {
308 <                                                return NULL;
303 >                        p = proctitle;
304 >                        proc_state_ptr->proctitle[0] = NULL;
305 >                        do {
306 >                                strncat(proc_state_ptr->proctitle, p, strlen(p));
307 >                                strncat(proc_state_ptr->proctitle, " ", 1);
308 >                                p += strlen(p) + 1;
309 >                        } while (p < proctitle + size);
310 >                        free(proctitle);
311 >                        proc_state_ptr->proctitle[strlen(proc_state_ptr->proctitle)-1] = NULL;
312 >                }
313 >                else {
314 >                        free(proctitle);
315 >                        proc_state_ptr->proctitle = NULL;
316 >                }
317 > #else
318 >                if(kvmd != NULL) {
319 >                        args = kvm_getargv(kvmd, &(kp_stats[i]), 0);
320 >                        if(args != NULL) {
321 >                                alloc = 1;
322 >                                proctitle = malloc(alloc);
323 >                                if(proctitle == NULL) {
324 >                                        return NULL;
325 >                                }
326 >                                while(*args != NULL) {
327 >                                        if(strlen(proctitle) + strlen(*args) >= alloc) {
328 >                                                alloc = (alloc + strlen(*args)) << 1;
329 >                                                proctitle = realloc(proctitle, alloc);
330 >                                                if(proctitle == NULL) {
331 >                                                        return NULL;
332 >                                                }
333                                          }
334 +                                        strncat(proctitle, *args, strlen(*args));
335 +                                        strncat(proctitle, " ", 1);
336 +                                        args++;
337                                  }
338 <                                strncat(proctitle, *args, strlen(*args));
339 <                                strncat(proctitle, " ", 1);
340 <                                args++;
338 >                                /* remove trailing space */
339 >                                proctitle[strlen(proctitle)-1] = NULL;
340 >                                proc_state_ptr->proctitle = proctitle;
341                          }
342 <                        /* remove trailing space */
343 <                        proctitle[strlen(proctitle)-1] = NULL;
344 <                        proc_state_ptr->proctitle = proctitle;
342 >                        else {
343 >                                proc_state_ptr->proctitle = NULL;
344 >                        }
345                  }
346                  else {
347 <                        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);
347 >                        proc_state_ptr->proctitle = NULL;
348                  }
349 + #endif
350  
351   #ifdef FREEBSD5
352                  proc_state_ptr->pid = kp_stats[i].ki_pid;
# Line 282 | Line 363 | int get_proc_snapshot(proc_state_t **ps){
363                  proc_state_ptr->euid = kp_stats[i].ki_uid;
364                  proc_state_ptr->gid = kp_stats[i].ki_rgid;
365                  proc_state_ptr->egid = kp_stats[i].ki_svgid;
366 + #elif defined(DFBSD)
367 +                proc_state_ptr->uid = kp_stats[i].kp_eproc.e_ucred.cr_ruid;
368 +                proc_state_ptr->euid = kp_stats[i].kp_eproc.e_ucred.cr_svuid;
369 +                proc_state_ptr->gid = kp_stats[i].kp_eproc.e_ucred.cr_rgid;
370 +                proc_state_ptr->egid = kp_stats[i].kp_eproc.e_ucred.cr_svgid;
371   #else
372                  proc_state_ptr->uid = kp_stats[i].kp_eproc.e_pcred.p_ruid;
373                  proc_state_ptr->euid = kp_stats[i].kp_eproc.e_pcred.p_svuid;
# Line 305 | Line 391 | int get_proc_snapshot(proc_state_t **ps){
391                  /* This is in pages */
392                  proc_state_ptr->proc_resident =
393                          kp_stats[i].kp_eproc.e_vm.vm_rssize * getpagesize();
394 + #if defined(NETBSD) || defined(OPENBSD)
395 +                proc_state_ptr->time_spent =
396 +                        kp_stats[i].kp_proc.p_rtime.tv_sec;
397 + #elif defined(DFBSD)
398 +                proc_state_ptr->time_spent =
399 +                        ( kp_stats[i].kp_thread.td_uticks +
400 +                        kp_stats[i].kp_thread.td_sticks +
401 +                        kp_stats[i].kp_thread.td_iticks ) / 1000000;
402 + #else
403                  /* This is in microseconds */
404                  proc_state_ptr->time_spent =
405                          kp_stats[i].kp_proc.p_runtime / 1000000;
406 + #endif
407                  proc_state_ptr->cpu_percent =
408                          ((double)kp_stats[i].kp_proc.p_pctcpu / FSCALE) * 100.0;
409                  proc_state_ptr->nice = kp_stats[i].kp_proc.p_nice;
# Line 343 | Line 439 | int get_proc_snapshot(proc_state_t **ps){
439   #endif
440                          proc_state_ptr->state = ZOMBIE;
441                          break;
442 +                default:
443 +                        proc_state_ptr->state = UNKNOWN;
444 +                        break;
445                  }
446                  proc_state_size++;
447          }
# Line 367 | Line 466 | process_stat_t *get_process_stats() {
466  
467          ps_size = get_proc_snapshot(&ps);
468  
469 +        if(ps_size == 0) {
470 +                return NULL;
471 +        }
472 +
473          for(x = 0; x < ps_size; x++) {
474                  switch (ps->state) {
372 –                /* currently no mapping for UNKNOWN in process_stat_t */
475                  case RUNNING:
476                          process_stat.running++;
477                          break;
# Line 381 | Line 483 | process_stat_t *get_process_stats() {
483                          break;
484                  case ZOMBIE:
485                          process_stat.zombie++;
486 +                        break;
487 +                default:
488 +                        /* currently no mapping for UNKNOWN in process_stat_t */
489                          break;
490                  }
491                  ps++;

Diff Legend

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