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.27 by tdb, Fri Apr 2 21:20:23 2004 UTC vs.
Revision 1.36 by tdb, Sun Apr 4 16:12:59 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 67 | Line 72 | int get_proc_snapshot(proc_state_t **ps){
72          int mib[3];
73          size_t size;
74          struct kinfo_proc *kp_stats;
75 <        int procs, i;
75 >        int procs, i, alloc;
76 >        static kvm_t *kvmd;
77 >        char **args;
78 >        char *proctitle;
79   #endif
80   #if defined(SOLARIS) || defined(LINUX)
81          DIR *proc_dir;
# Line 203 | Line 211 | int get_proc_snapshot(proc_state_t **ps){
211          mib[1] = KERN_PROC;
212          mib[2] = KERN_PROC_ALL;
213  
214 <        if (sysctl(mib, 3, NULL, &size, NULL, 0) < 0) {
214 >        if(sysctl(mib, 3, NULL, &size, NULL, 0) < 0) {
215                  return NULL;
216          }
217  
218          procs = size / sizeof(struct kinfo_proc);
219  
220          kp_stats = malloc(size);
221 <        if (kp_stats == NULL) {
221 >        if(kp_stats == NULL) {
222                  return NULL;
223          }
224  
225 <        if (sysctl(mib, 3, kp_stats, &size, NULL, 0) < 0) {
225 >        if(sysctl(mib, 3, kp_stats, &size, NULL, 0) < 0) {
226                  free(kp_stats);
227                  return NULL;
228          }
229  
230 + #if defined(NETBSD) || defined(OPENBSD)
231 +        kvmd = kvm_openfiles(NULL, NULL, NULL, O_RDONLY, NULL);
232 + #else
233 +        kvmd = kvm_openfiles(_PATH_DEVNULL, _PATH_DEVNULL, NULL, O_RDONLY, NULL);
234 + #endif
235 +
236          for (i = 0; i < procs; i++) {
237 <                proc_state = realloc(proc_state, (1+proc_state_size)*sizeof(proc_state_t));
237 >                /* replace with something more sensible */
238 >                proc_state = realloc(proc_state,
239 >                                (1+proc_state_size)*sizeof(proc_state_t));
240 >                if(proc_state == NULL ) {
241 >                        return NULL;
242 >                }
243                  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);*/
244  
245 + #ifdef FREEBSD5
246 +                proc_state_ptr->process_name =
247 +                        strdup(kp_stats[i].ki_comm);
248 + #elif defined(DFBSD)
249 +                proc_state_ptr->process_name =
250 +                        strdup(kp_stats[i].kp_thread.td_comm);
251 + #else
252 +                proc_state_ptr->process_name =
253 +                        strdup(kp_stats[i].kp_proc.p_comm);
254 + #endif
255 +
256 +                args = kvm_getargv(kvmd, &(kp_stats[i]), 0);
257 +                if(args != NULL) {
258 +                        alloc = 1;
259 +                        proctitle = malloc(alloc);
260 +                        if(proctitle == NULL) {
261 +                                return NULL;
262 +                        }
263 +                        while(*args != NULL) {
264 +                                if(strlen(proctitle) + strlen(*args) >= alloc) {
265 +                                        alloc = (alloc + strlen(*args)) << 1;
266 +                                        proctitle = realloc(proctitle, alloc);
267 +                                        if(proctitle == NULL) {
268 +                                                return NULL;
269 +                                        }
270 +                                }
271 +                                strncat(proctitle, *args, strlen(*args));
272 +                                strncat(proctitle, " ", 1);
273 +                                args++;
274 +                        }
275 +                        /* remove trailing space */
276 +                        proctitle[strlen(proctitle)-1] = NULL;
277 +                        proc_state_ptr->proctitle = proctitle;
278 +                }
279 +                else {
280 +                        /* Should probably be returning NULL here */
281 +                        proc_state_ptr->proctitle =
282 +                                malloc(strlen(proc_state_ptr->process_name)+4);
283 +                        if(proc_state_ptr->proctitle == NULL) {
284 +                                return NULL;
285 +                        }
286 +                        sprintf(proc_state_ptr->proctitle, " (%s)",
287 +                                proc_state_ptr->process_name);
288 +                }
289 +
290 + #ifdef FREEBSD5
291                  proc_state_ptr->pid = kp_stats[i].ki_pid;
292                  proc_state_ptr->parent = kp_stats[i].ki_ppid;
293                  proc_state_ptr->pgid = kp_stats[i].ki_pgid;
294 + #else
295 +                proc_state_ptr->pid = kp_stats[i].kp_proc.p_pid;
296 +                proc_state_ptr->parent = kp_stats[i].kp_eproc.e_ppid;
297 +                proc_state_ptr->pgid = kp_stats[i].kp_eproc.e_pgid;
298 + #endif
299  
300 + #ifdef FREEBSD5
301                  proc_state_ptr->uid = kp_stats[i].ki_ruid;
302                  proc_state_ptr->euid = kp_stats[i].ki_uid;
303                  proc_state_ptr->gid = kp_stats[i].ki_rgid;
304                  proc_state_ptr->egid = kp_stats[i].ki_svgid;
305 + #elif defined(DFBSD)
306 +                proc_state_ptr->uid = kp_stats[i].kp_eproc.e_ucred.cr_ruid;
307 +                proc_state_ptr->euid = kp_stats[i].kp_eproc.e_ucred.cr_svuid;
308 +                proc_state_ptr->gid = kp_stats[i].kp_eproc.e_ucred.cr_rgid;
309 +                proc_state_ptr->egid = kp_stats[i].kp_eproc.e_ucred.cr_svgid;
310 + #else
311 +                proc_state_ptr->uid = kp_stats[i].kp_eproc.e_pcred.p_ruid;
312 +                proc_state_ptr->euid = kp_stats[i].kp_eproc.e_pcred.p_svuid;
313 +                proc_state_ptr->gid = kp_stats[i].kp_eproc.e_pcred.p_rgid;
314 +                proc_state_ptr->egid = kp_stats[i].kp_eproc.e_pcred.p_svgid;
315 + #endif
316  
317 + #ifdef FREEBSD5
318                  proc_state_ptr->proc_size = kp_stats[i].ki_size;
319                  /* This is in pages */
320 <                proc_state_ptr->proc_resident = kp_stats[i].ki_rssize * getpagesize();
321 <                /* This seems to be in microseconds */
320 >                proc_state_ptr->proc_resident =
321 >                        kp_stats[i].ki_rssize * getpagesize();
322 >                /* This is in microseconds */
323                  proc_state_ptr->time_spent = kp_stats[i].ki_runtime / 1000000;
324 <                proc_state_ptr->cpu_percent = kp_stats[i].ki_pctcpu;
324 >                proc_state_ptr->cpu_percent =
325 >                        ((double)kp_stats[i].ki_pctcpu / FSCALE) * 100.0;
326                  proc_state_ptr->nice = kp_stats[i].ki_nice;
327 + #else
328 +                proc_state_ptr->proc_size =
329 +                        kp_stats[i].kp_eproc.e_vm.vm_map.size;
330 +                /* This is in pages */
331 +                proc_state_ptr->proc_resident =
332 +                        kp_stats[i].kp_eproc.e_vm.vm_rssize * getpagesize();
333 + #if defined(NETBSD) || defined(OPENBSD)
334 +                proc_state_ptr->time_spent =
335 +                        kp_stats[i].kp_proc.p_rtime.tv_sec;
336 + #elif defined(DFBSD)
337 +                proc_state_ptr->time_spent =
338 +                        ( kp_stats[i].kp_thread.td_uticks +
339 +                        kp_stats[i].kp_thread.td_sticks +
340 +                        kp_stats[i].kp_thread.td_iticks ) / 1000000;
341 + #else
342 +                /* This is in microseconds */
343 +                proc_state_ptr->time_spent =
344 +                        kp_stats[i].kp_proc.p_runtime / 1000000;
345 + #endif
346 +                proc_state_ptr->cpu_percent =
347 +                        ((double)kp_stats[i].kp_proc.p_pctcpu / FSCALE) * 100.0;
348 +                proc_state_ptr->nice = kp_stats[i].kp_proc.p_nice;
349 + #endif
350  
351 + #ifdef FREEBSD5
352                  switch (kp_stats[i].ki_stat) {
353 + #else
354 +                switch (kp_stats[i].kp_proc.p_stat) {
355 + #endif
356                  case SIDL:
357                  case SRUN:
358   #ifdef SONPROC
# Line 270 | Line 378 | int get_proc_snapshot(proc_state_t **ps){
378   #endif
379                          proc_state_ptr->state = ZOMBIE;
380                          break;
381 +                default:
382 +                        proc_state_ptr->state = UNKNOWN;
383 +                        break;
384                  }
385                  proc_state_size++;
386          }
# Line 286 | Line 397 | process_stat_t *get_process_stats() {
397          proc_state_t *ps;
398          int ps_size, x;
399  
400 <        process_stat.sleeping=0;
401 <        process_stat.running=0;
402 <        process_stat.zombie=0;
403 <        process_stat.stopped=0;
404 <        process_stat.total=0;
400 >        process_stat.sleeping = 0;
401 >        process_stat.running = 0;
402 >        process_stat.zombie = 0;
403 >        process_stat.stopped = 0;
404 >        process_stat.total = 0;
405  
406          ps_size = get_proc_snapshot(&ps);
407  
408 +        if(ps_size == NULL) {
409 +                return NULL;
410 +        }
411 +
412          for(x = 0; x < ps_size; x++) {
413                  switch (ps->state) {
414 +                /* currently no mapping for UNKNOWN in process_stat_t */
415                  case RUNNING:
416                          process_stat.running++;
417                          break;

Diff Legend

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