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.25 by pajs, Tue Mar 30 13:41:31 2004 UTC vs.
Revision 1.43 by tdb, Sun Apr 4 22:48:50 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[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 + #else
86 +        long buflen;
87 +        char *p;
88 + #endif
89 + #endif
90   #if defined(SOLARIS) || defined(LINUX)
91          DIR *proc_dir;
92          struct dirent *dir_entry;
# Line 132 | Line 156 | int get_proc_snapshot(proc_state_t **ps){
156                  if(process_info.pr_lwp.pr_state==6) proc_state_ptr->state = RUNNING;
157   #endif
158   #ifdef LINUX
159 <                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));
159 >                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));
160                  proc_state_ptr->proc_resident = proc_state_ptr->proc_resident * getpagesize();
161                  if(s == 'S') proc_state_ptr->state = SLEEPING;
162                  if(s == 'R') proc_state_ptr->state = RUNNING;
# Line 186 | Line 210 | int get_proc_snapshot(proc_state_t **ps){
210   #endif
211  
212                  proc_state_size++;
189 #endif
213  
191
214                  fclose(f);
215          }
216          closedir(proc_dir);
217 <        *ps = proc_state;
217 > #endif
218  
219 + #ifdef ALLBSD
220 +        mib[0] = CTL_KERN;
221 +        mib[1] = KERN_PROC;
222 +        mib[2] = KERN_PROC_ALL;
223 +
224 +        if(sysctl(mib, 3, NULL, &size, NULL, 0) < 0) {
225 +                return NULL;
226 +        }
227 +
228 +        procs = size / sizeof(struct kinfo_proc);
229 +
230 +        kp_stats = malloc(size);
231 +        if(kp_stats == NULL) {
232 +                return NULL;
233 +        }
234 +
235 +        if(sysctl(mib, 3, kp_stats, &size, NULL, 0) < 0) {
236 +                free(kp_stats);
237 +                return NULL;
238 +        }
239 +
240 + #if (defined(FREEBSD) && !defined(FREEBSD5)) || defined(DFBSD)
241 +        kvmd = get_kvm2();
242 + #endif
243 +
244 +        for (i = 0; i < procs; i++) {
245 +                /* replace with something more sensible */
246 +                proc_state = realloc(proc_state,
247 +                                (1+proc_state_size)*sizeof(proc_state_t));
248 +                if(proc_state == NULL ) {
249 +                        return NULL;
250 +                }
251 +                proc_state_ptr = proc_state+proc_state_size;
252 +
253 + #ifdef FREEBSD5
254 +                proc_state_ptr->process_name =
255 +                        strdup(kp_stats[i].ki_comm);
256 + #elif defined(DFBSD)
257 +                proc_state_ptr->process_name =
258 +                        strdup(kp_stats[i].kp_thread.td_comm);
259 + #else
260 +                proc_state_ptr->process_name =
261 +                        strdup(kp_stats[i].kp_proc.p_comm);
262 + #endif
263 +
264 + #if defined(FREEBSD5) || defined(NETBSD) || defined(OPENBSD)
265 +                size = sizeof(buflen);
266 +
267 + #ifdef FREEBSD5
268 +                if(sysctlbyname("kern.ps_arg_cache_limit", &buflen, &size, NULL, 0) < 0) {
269 +                        return NULL;
270 +                }
271 + #else
272 +                mib[1] = KERN_ARGMAX;
273 +
274 +                if(sysctl(mib, 2, &buflen, &size, NULL, 0) < 0) {
275 +                        return NULL;
276 +                }
277 + #endif
278 +
279 +                proctitle = malloc(buflen);
280 +                if(proctitle == NULL) {
281 +                        return NULL;
282 +                }
283 +
284 +                size = buflen;
285 +
286 + #ifdef FREEBSD5
287 +                mib[2] = KERN_PROC_ARGS;
288 +                mib[3] = kp_stats[i].ki_pid;
289 + #else
290 +                mib[1] = KERN_PROC_ARGS;
291 +                mib[2] = kp_stats[i].kp_proc.p_pid;
292 +                mib[3] = KERN_PROC_ARGV;
293 + #endif
294 +
295 +                if(sysctl(mib, 4, proctitle, &size, NULL, 0) < 0) {
296 +                        free(proctitle);
297 +                        proc_state_ptr->proctitle = NULL;
298 +                }
299 +                else if(size > 0) {
300 +                        proc_state_ptr->proctitle = malloc(size);
301 +                        if(proc_state_ptr->proctitle == NULL) {
302 +                                return NULL;
303 +                        }
304 +                        p = proctitle;
305 +                        proc_state_ptr->proctitle[0] = NULL;
306 +                        do {
307 +                                strncat(proc_state_ptr->proctitle, p, strlen(p));
308 +                                strncat(proc_state_ptr->proctitle, " ", 1);
309 +                                p += strlen(p) + 1;
310 +                        } while (p < proctitle + size);
311 +                        free(proctitle);
312 +                        proc_state_ptr->proctitle[strlen(proc_state_ptr->proctitle)-1] = NULL;
313 +                }
314 +                else {
315 +                        free(proctitle);
316 +                        proc_state_ptr->proctitle = NULL;
317 +                }
318 + #else
319 +                if(kvmd != NULL) {
320 +                        args = kvm_getargv(kvmd, &(kp_stats[i]), 0);
321 +                        if(args != NULL) {
322 +                                alloc = 1;
323 +                                proctitle = malloc(alloc);
324 +                                if(proctitle == NULL) {
325 +                                        return NULL;
326 +                                }
327 +                                while(*args != NULL) {
328 +                                        if(strlen(proctitle) + strlen(*args) >= alloc) {
329 +                                                alloc = (alloc + strlen(*args)) << 1;
330 +                                                proctitle = realloc(proctitle, alloc);
331 +                                                if(proctitle == NULL) {
332 +                                                        return NULL;
333 +                                                }
334 +                                        }
335 +                                        strncat(proctitle, *args, strlen(*args));
336 +                                        strncat(proctitle, " ", 1);
337 +                                        args++;
338 +                                }
339 +                                /* remove trailing space */
340 +                                proctitle[strlen(proctitle)-1] = NULL;
341 +                                proc_state_ptr->proctitle = proctitle;
342 +                        }
343 +                        else {
344 +                                proc_state_ptr->proctitle = NULL;
345 +                        }
346 +                }
347 +                else {
348 +                        proc_state_ptr->proctitle = NULL;
349 +                }
350 + #endif
351 +
352 + #ifdef FREEBSD5
353 +                proc_state_ptr->pid = kp_stats[i].ki_pid;
354 +                proc_state_ptr->parent = kp_stats[i].ki_ppid;
355 +                proc_state_ptr->pgid = kp_stats[i].ki_pgid;
356 + #else
357 +                proc_state_ptr->pid = kp_stats[i].kp_proc.p_pid;
358 +                proc_state_ptr->parent = kp_stats[i].kp_eproc.e_ppid;
359 +                proc_state_ptr->pgid = kp_stats[i].kp_eproc.e_pgid;
360 + #endif
361 +
362 + #ifdef FREEBSD5
363 +                proc_state_ptr->uid = kp_stats[i].ki_ruid;
364 +                proc_state_ptr->euid = kp_stats[i].ki_uid;
365 +                proc_state_ptr->gid = kp_stats[i].ki_rgid;
366 +                proc_state_ptr->egid = kp_stats[i].ki_svgid;
367 + #elif defined(DFBSD)
368 +                proc_state_ptr->uid = kp_stats[i].kp_eproc.e_ucred.cr_ruid;
369 +                proc_state_ptr->euid = kp_stats[i].kp_eproc.e_ucred.cr_svuid;
370 +                proc_state_ptr->gid = kp_stats[i].kp_eproc.e_ucred.cr_rgid;
371 +                proc_state_ptr->egid = kp_stats[i].kp_eproc.e_ucred.cr_svgid;
372 + #else
373 +                proc_state_ptr->uid = kp_stats[i].kp_eproc.e_pcred.p_ruid;
374 +                proc_state_ptr->euid = kp_stats[i].kp_eproc.e_pcred.p_svuid;
375 +                proc_state_ptr->gid = kp_stats[i].kp_eproc.e_pcred.p_rgid;
376 +                proc_state_ptr->egid = kp_stats[i].kp_eproc.e_pcred.p_svgid;
377 + #endif
378 +
379 + #ifdef FREEBSD5
380 +                proc_state_ptr->proc_size = kp_stats[i].ki_size;
381 +                /* This is in pages */
382 +                proc_state_ptr->proc_resident =
383 +                        kp_stats[i].ki_rssize * getpagesize();
384 +                /* This is in microseconds */
385 +                proc_state_ptr->time_spent = kp_stats[i].ki_runtime / 1000000;
386 +                proc_state_ptr->cpu_percent =
387 +                        ((double)kp_stats[i].ki_pctcpu / FSCALE) * 100.0;
388 +                proc_state_ptr->nice = kp_stats[i].ki_nice;
389 + #else
390 +                proc_state_ptr->proc_size =
391 +                        kp_stats[i].kp_eproc.e_vm.vm_map.size;
392 +                /* This is in pages */
393 +                proc_state_ptr->proc_resident =
394 +                        kp_stats[i].kp_eproc.e_vm.vm_rssize * getpagesize();
395 + #if defined(NETBSD) || defined(OPENBSD)
396 +                proc_state_ptr->time_spent =
397 +                        kp_stats[i].kp_proc.p_rtime.tv_sec;
398 + #elif defined(DFBSD)
399 +                proc_state_ptr->time_spent =
400 +                        ( kp_stats[i].kp_thread.td_uticks +
401 +                        kp_stats[i].kp_thread.td_sticks +
402 +                        kp_stats[i].kp_thread.td_iticks ) / 1000000;
403 + #else
404 +                /* This is in microseconds */
405 +                proc_state_ptr->time_spent =
406 +                        kp_stats[i].kp_proc.p_runtime / 1000000;
407 + #endif
408 +                proc_state_ptr->cpu_percent =
409 +                        ((double)kp_stats[i].kp_proc.p_pctcpu / FSCALE) * 100.0;
410 +                proc_state_ptr->nice = kp_stats[i].kp_proc.p_nice;
411 + #endif
412 +
413 + #ifdef FREEBSD5
414 +                switch (kp_stats[i].ki_stat) {
415 + #else
416 +                switch (kp_stats[i].kp_proc.p_stat) {
417 + #endif
418 +                case SIDL:
419 +                case SRUN:
420 + #ifdef SONPROC
421 +                case SONPROC: /* NetBSD */
422 + #endif
423 +                        proc_state_ptr->state = RUNNING;
424 +                        break;
425 +                case SSLEEP:
426 + #ifdef SWAIT
427 +                case SWAIT: /* FreeBSD 5 */
428 + #endif
429 + #ifdef SLOCK
430 +                case SLOCK: /* FreeBSD 5 */
431 + #endif
432 +                        proc_state_ptr->state = SLEEPING;
433 +                        break;
434 +                case SSTOP:
435 +                        proc_state_ptr->state = STOPPED;
436 +                        break;
437 +                case SZOMB:
438 + #ifdef SDEAD
439 +                case SDEAD: /* OpenBSD & NetBSD */
440 + #endif
441 +                        proc_state_ptr->state = ZOMBIE;
442 +                        break;
443 +                default:
444 +                        proc_state_ptr->state = UNKNOWN;
445 +                        break;
446 +                }
447 +                proc_state_size++;
448 +        }
449 +
450 +        free(kp_stats);
451 + #endif
452 +
453 +        *ps = proc_state;
454          return proc_state_size;
455   }
456  
457 + process_stat_t *get_process_stats() {
458 +        static process_stat_t process_stat;
459 +        proc_state_t *ps;
460 +        int ps_size, x;
461 +
462 +        process_stat.sleeping = 0;
463 +        process_stat.running = 0;
464 +        process_stat.zombie = 0;
465 +        process_stat.stopped = 0;
466 +        process_stat.total = 0;
467 +
468 +        ps_size = get_proc_snapshot(&ps);
469 +
470 +        if(ps_size == 0) {
471 +                return NULL;
472 +        }
473 +
474 +        for(x = 0; x < ps_size; x++) {
475 +                switch (ps->state) {
476 +                case RUNNING:
477 +                        process_stat.running++;
478 +                        break;
479 +                case SLEEPING:
480 +                        process_stat.sleeping++;
481 +                        break;
482 +                case STOPPED:
483 +                        process_stat.stopped++;
484 +                        break;
485 +                case ZOMBIE:
486 +                        process_stat.zombie++;
487 +                        break;
488 +                default:
489 +                        /* currently no mapping for UNKNOWN in process_stat_t */
490 +                        break;
491 +                }
492 +                ps++;
493 +        }
494 +
495 +        process_stat.total = ps_size;
496 +
497 +        return &process_stat;
498 + }

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines