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.32 by tdb, Sun Apr 4 11:02:30 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){
68          proc_state_t *proc_state = NULL;
69          proc_state_t *proc_state_ptr;
70          int proc_state_size = 0;
71 + #ifdef ALLBSD
72 +        int mib[3];
73 +        size_t size;
74 +        struct kinfo_proc *kp_stats;
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;
82          struct dirent *dir_entry;
# Line 186 | Line 200 | int get_proc_snapshot(proc_state_t **ps){
200   #endif
201  
202                  proc_state_size++;
189 #endif
203  
191
204                  fclose(f);
205          }
206          closedir(proc_dir);
207 <        *ps = proc_state;
207 > #endif
208  
209 + #ifdef ALLBSD
210 +        kvmd = kvm_openfiles(_PATH_DEVNULL, _PATH_DEVNULL, NULL, O_RDONLY, NULL);
211 +
212 +        if(kvmd == NULL) return NULL;
213 +
214 +        kp_stats = kvm_getprocs(kvmd, KERN_PROC_ALL, 0, &procs);
215 +
216 +        if (kp_stats == NULL || procs < 0) {
217 +                return NULL;
218 +        }
219 +
220 +        for (i = 0; i < procs; i++) {
221 +                /* replace with something more sensible */
222 +                proc_state = realloc(proc_state,
223 +                                (1+proc_state_size)*sizeof(proc_state_t));
224 +                if(proc_state == NULL ) {
225 +                        return NULL;
226 +                }
227 +                proc_state_ptr = proc_state+proc_state_size;
228 +
229 + #ifdef FREEBSD5
230 +                proc_state_ptr->process_name =
231 +                        strdup(kp_stats[i].ki_comm);
232 + #else
233 +                proc_state_ptr->process_name =
234 +                        strdup(kp_stats[i].kp_proc.p_comm);
235 + #endif
236 +
237 +                args = kvm_getargv(kvmd, &(kp_stats[i]), 0);
238 +                if(args != NULL) {
239 +                        alloc = 1;
240 +                        proctitle = malloc(alloc);
241 +                        if(proctitle == NULL) {
242 +                                return NULL;
243 +                        }
244 +                        while(*args != NULL) {
245 +                                if(strlen(proctitle) + strlen(*args) >= alloc) {
246 +                                        alloc = (alloc + strlen(*args)) << 1;
247 +                                        proctitle = realloc(proctitle, alloc);
248 +                                        if(proctitle == NULL) {
249 +                                                return NULL;
250 +                                        }
251 +                                }
252 +                                strncat(proctitle, *args, strlen(*args));
253 +                                strncat(proctitle, " ", 1);
254 +                                args++;
255 +                        }
256 +                        /* remove trailing space */
257 +                        proctitle[strlen(proctitle)-1] = NULL;
258 +                        proc_state_ptr->proctitle = proctitle;
259 +                }
260 +                else {
261 +                        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);
268 +                }
269 +
270 + #ifdef FREEBSD5
271 +                proc_state_ptr->pid = kp_stats[i].ki_pid;
272 +                proc_state_ptr->parent = kp_stats[i].ki_ppid;
273 +                proc_state_ptr->pgid = kp_stats[i].ki_pgid;
274 + #else
275 +                proc_state_ptr->pid = kp_stats[i].kp_proc.p_pid;
276 +                proc_state_ptr->parent = kp_stats[i].kp_eproc.e_ppid;
277 +                proc_state_ptr->pgid = kp_stats[i].kp_eproc.e_pgid;
278 + #endif
279 +
280 + #ifdef FREEBSD5
281 +                proc_state_ptr->uid = kp_stats[i].ki_ruid;
282 +                proc_state_ptr->euid = kp_stats[i].ki_uid;
283 +                proc_state_ptr->gid = kp_stats[i].ki_rgid;
284 +                proc_state_ptr->egid = kp_stats[i].ki_svgid;
285 + #else
286 +                proc_state_ptr->uid = kp_stats[i].kp_eproc.e_pcred.p_ruid;
287 +                proc_state_ptr->euid = kp_stats[i].kp_eproc.e_pcred.p_svuid;
288 +                proc_state_ptr->gid = kp_stats[i].kp_eproc.e_pcred.p_rgid;
289 +                proc_state_ptr->egid = kp_stats[i].kp_eproc.e_pcred.p_svgid;
290 + #endif
291 +
292 + #ifdef FREEBSD5
293 +                proc_state_ptr->proc_size = kp_stats[i].ki_size;
294 +                /* This is in pages */
295 +                proc_state_ptr->proc_resident =
296 +                        kp_stats[i].ki_rssize * getpagesize();
297 +                /* This is in microseconds */
298 +                proc_state_ptr->time_spent = kp_stats[i].ki_runtime / 1000000;
299 +                proc_state_ptr->cpu_percent =
300 +                        ((double)kp_stats[i].ki_pctcpu / FSCALE) * 100.0;
301 +                proc_state_ptr->nice = kp_stats[i].ki_nice;
302 + #else
303 +                proc_state_ptr->proc_size =
304 +                        kp_stats[i].kp_eproc.e_vm.vm_map.size;
305 +                /* This is in pages */
306 +                proc_state_ptr->proc_resident =
307 +                        kp_stats[i].kp_eproc.e_vm.vm_rssize * getpagesize();
308 +                /* This is in microseconds */
309 +                proc_state_ptr->time_spent =
310 +                        kp_stats[i].kp_proc.p_runtime / 1000000;
311 +                proc_state_ptr->cpu_percent =
312 +                        ((double)kp_stats[i].kp_proc.p_pctcpu / FSCALE) * 100.0;
313 +                proc_state_ptr->nice = kp_stats[i].kp_proc.p_nice;
314 + #endif
315 +
316 + #ifdef FREEBSD5
317 +                switch (kp_stats[i].ki_stat) {
318 + #else
319 +                switch (kp_stats[i].kp_proc.p_stat) {
320 + #endif
321 +                case SIDL:
322 +                case SRUN:
323 + #ifdef SONPROC
324 +                case SONPROC: /* NetBSD */
325 + #endif
326 +                        proc_state_ptr->state = RUNNING;
327 +                        break;
328 +                case SSLEEP:
329 + #ifdef SWAIT
330 +                case SWAIT: /* FreeBSD 5 */
331 + #endif
332 + #ifdef SLOCK
333 +                case SLOCK: /* FreeBSD 5 */
334 + #endif
335 +                        proc_state_ptr->state = SLEEPING;
336 +                        break;
337 +                case SSTOP:
338 +                        proc_state_ptr->state = STOPPED;
339 +                        break;
340 +                case SZOMB:
341 + #ifdef SDEAD
342 +                case SDEAD: /* OpenBSD & NetBSD */
343 + #endif
344 +                        proc_state_ptr->state = ZOMBIE;
345 +                        break;
346 +                default:
347 +                        proc_state_ptr->state = UNKNOWN;
348 +                        break;
349 +                }
350 +                proc_state_size++;
351 +        }
352 +
353 +        free(kp_stats);
354 + #endif
355 +
356 +        *ps = proc_state;
357          return proc_state_size;
358   }
359  
360 + process_stat_t *get_process_stats() {
361 +        static process_stat_t process_stat;
362 +        proc_state_t *ps;
363 +        int ps_size, x;
364 +
365 +        process_stat.sleeping = 0;
366 +        process_stat.running = 0;
367 +        process_stat.zombie = 0;
368 +        process_stat.stopped = 0;
369 +        process_stat.total = 0;
370 +
371 +        ps_size = get_proc_snapshot(&ps);
372 +
373 +        if(ps_size == NULL) {
374 +                return NULL;
375 +        }
376 +
377 +        for(x = 0; x < ps_size; x++) {
378 +                switch (ps->state) {
379 +                /* currently no mapping for UNKNOWN in process_stat_t */
380 +                case RUNNING:
381 +                        process_stat.running++;
382 +                        break;
383 +                case SLEEPING:
384 +                        process_stat.sleeping++;
385 +                        break;
386 +                case STOPPED:
387 +                        process_stat.stopped++;
388 +                        break;
389 +                case ZOMBIE:
390 +                        process_stat.zombie++;
391 +                        break;
392 +                }
393 +                ps++;
394 +        }
395 +
396 +        process_stat.total = ps_size;
397 +
398 +        return &process_stat;
399 + }

Diff Legend

Removed lines
+ Added lines
< Changed lines
> Changed lines