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

Diff Legend

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