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.28 by tdb, Sat Apr 3 16:57:32 2004 UTC vs.
Revision 1.45 by tdb, Sun Apr 4 23:35:45 2004 UTC

# Line 57 | Line 57
57   #else
58   #include <sys/proc.h>
59   #endif
60 + #include <string.h>
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;
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 138 | 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 203 | Line 222 | int get_proc_snapshot(proc_state_t **ps){
222          mib[1] = KERN_PROC;
223          mib[2] = KERN_PROC_ALL;
224  
225 <        if (sysctl(mib, 3, NULL, &size, NULL, 0) < 0) {
225 >        if(sysctl(mib, 3, NULL, &size, NULL, 0) < 0) {
226                  return NULL;
227          }
228  
229          procs = size / sizeof(struct kinfo_proc);
230  
231          kp_stats = malloc(size);
232 <        if (kp_stats == NULL) {
232 >        if(kp_stats == NULL) {
233                  return NULL;
234          }
235  
236 <        if (sysctl(mib, 3, kp_stats, &size, NULL, 0) < 0) {
236 >        if(sysctl(mib, 3, kp_stats, &size, NULL, 0) < 0) {
237                  free(kp_stats);
238                  return NULL;
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 <                proc_state = realloc(proc_state, (1+proc_state_size)*sizeof(proc_state_t));
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;
251 >                }
252                  proc_state_ptr = proc_state+proc_state_size;
225 –                
226 –                proc_state_ptr->process_name = strdup(kp_stats[i].ki_comm);
227 –                /* Seems we don't have access to that bit of memory */
228 –                /*proc_state_ptr->proctitle = strdup(kp_stats[i].ki_args->ar_args);*/
229 –                proc_state_ptr->proctitle = NULL;
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 + #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 NULL;
271 +                }
272 + #else
273 +                mib[1] = KERN_ARGMAX;
274 +
275 +                if(sysctl(mib, 2, &buflen, &size, NULL, 0) < 0) {
276 +                        return NULL;
277 +                }
278 + #endif
279 +
280 +                proctitle = malloc(buflen);
281 +                if(proctitle == NULL) {
282 +                        return NULL;
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 NULL;
304 +                        }
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 NULL;
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 NULL;
335 +                                                }
336 +                                                proctitle = proctitletmp;
337 +                                        }
338 +                                        strlcat(proctitle, *args, alloc);
339 +                                        strlcat(proctitle, " ", alloc);
340 +                                        args++;
341 +                                }
342 +                                /* remove trailing space */
343 +                                proctitle[strlen(proctitle)-1] = '\0';
344 +                                proc_state_ptr->proctitle = proctitle;
345 +                        }
346 +                        else {
347 +                                proc_state_ptr->proctitle = NULL;
348 +                        }
349 +                }
350 +                else {
351 +                        proc_state_ptr->proctitle = NULL;
352 +                }
353 + #endif
354 +
355 + #ifdef FREEBSD5
356                  proc_state_ptr->pid = kp_stats[i].ki_pid;
357                  proc_state_ptr->parent = kp_stats[i].ki_ppid;
358                  proc_state_ptr->pgid = kp_stats[i].ki_pgid;
359 + #else
360 +                proc_state_ptr->pid = kp_stats[i].kp_proc.p_pid;
361 +                proc_state_ptr->parent = kp_stats[i].kp_eproc.e_ppid;
362 +                proc_state_ptr->pgid = kp_stats[i].kp_eproc.e_pgid;
363 + #endif
364  
365 + #ifdef FREEBSD5
366                  proc_state_ptr->uid = kp_stats[i].ki_ruid;
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;
378 +                proc_state_ptr->gid = kp_stats[i].kp_eproc.e_pcred.p_rgid;
379 +                proc_state_ptr->egid = kp_stats[i].kp_eproc.e_pcred.p_svgid;
380 + #endif
381  
382 + #ifdef FREEBSD5
383                  proc_state_ptr->proc_size = kp_stats[i].ki_size;
384                  /* This is in pages */
385 <                proc_state_ptr->proc_resident = kp_stats[i].ki_rssize * getpagesize();
385 >                proc_state_ptr->proc_resident =
386 >                        kp_stats[i].ki_rssize * getpagesize();
387                  /* This is in microseconds */
388                  proc_state_ptr->time_spent = kp_stats[i].ki_runtime / 1000000;
389 <                proc_state_ptr->cpu_percent = ((double) kp_stats[i].ki_pctcpu / FSCALE) * 100.0;
389 >                proc_state_ptr->cpu_percent =
390 >                        ((double)kp_stats[i].ki_pctcpu / FSCALE) * 100.0;
391                  proc_state_ptr->nice = kp_stats[i].ki_nice;
392 + #else
393 +                proc_state_ptr->proc_size =
394 +                        kp_stats[i].kp_eproc.e_vm.vm_map.size;
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;
414 + #endif
415  
416 + #ifdef FREEBSD5
417                  switch (kp_stats[i].ki_stat) {
418 + #else
419 +                switch (kp_stats[i].kp_proc.p_stat) {
420 + #endif
421                  case SIDL:
422                  case SRUN:
423   #ifdef SONPROC
# Line 271 | Line 443 | int get_proc_snapshot(proc_state_t **ps){
443   #endif
444                          proc_state_ptr->state = ZOMBIE;
445                          break;
446 +                default:
447 +                        proc_state_ptr->state = UNKNOWN;
448 +                        break;
449                  }
450                  proc_state_size++;
451          }
# Line 287 | Line 462 | process_stat_t *get_process_stats() {
462          proc_state_t *ps;
463          int ps_size, x;
464  
465 <        process_stat.sleeping=0;
466 <        process_stat.running=0;
467 <        process_stat.zombie=0;
468 <        process_stat.stopped=0;
469 <        process_stat.total=0;
465 >        process_stat.sleeping = 0;
466 >        process_stat.running = 0;
467 >        process_stat.zombie = 0;
468 >        process_stat.stopped = 0;
469 >        process_stat.total = 0;
470  
471          ps_size = get_proc_snapshot(&ps);
472  
473 +        if(ps_size == 0) {
474 +                return NULL;
475 +        }
476 +
477          for(x = 0; x < ps_size; x++) {
478                  switch (ps->state) {
479                  case RUNNING:
# Line 308 | Line 487 | process_stat_t *get_process_stats() {
487                          break;
488                  case ZOMBIE:
489                          process_stat.zombie++;
490 +                        break;
491 +                default:
492 +                        /* currently no mapping for UNKNOWN in process_stat_t */
493                          break;
494                  }
495                  ps++;

Diff Legend

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