ViewVC Help
View File | Revision Log | Show Annotations | Revision Graph | Root Listing
root/i-scream/projects/libstatgrab/src/libstatgrab/process_stats.c
Revision: 1.74
Committed: Sun Jul 18 21:30:11 2004 UTC (19 years, 10 months ago) by ats
Content type: text/plain
Branch: MAIN
CVS Tags: LIBSTATGRAB_0_10_3, LIBSTATGRAB_0_10_2, LIBSTATGRAB_0_10_1
Changes since 1.73: +9 -7 lines
Log Message: 
Use sg_set_error_with_errno whenever errno's valid.
Change the one user of SG_ERROR_ENOENT to SG_ERROR_SYSCTL instead (since
that's what it should have been).

File Contents

# Content
1 /*
2 * i-scream libstatgrab
3 * http://www.i-scream.org
4 * Copyright (C) 2000-2004 i-scream
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
19 * 02111-1307 USA
20 *
21 * $Id: process_stats.c,v 1.73 2004/06/21 14:48:48 tdb Exp $
22 */
23
24 #ifdef HAVE_CONFIG_H
25 #include "config.h"
26 #endif
27
28 #include "statgrab.h"
29 #include "tools.h"
30 #include "vector.h"
31 #if defined(SOLARIS) || defined(LINUX)
32 #include <stdio.h>
33 #include <stdlib.h>
34 #include <sys/types.h>
35 #include <dirent.h>
36 #include <string.h>
37 #endif
38
39 #ifdef SOLARIS
40 #include <procfs.h>
41 #include <limits.h>
42 #define PROC_LOCATION "/proc"
43 #define MAX_FILE_LENGTH PATH_MAX
44 #endif
45 #ifdef LINUX
46 #include <limits.h>
47 #include <unistd.h>
48 #include <sys/stat.h>
49 #include <fcntl.h>
50 #define PROC_LOCATION "/proc"
51 #define MAX_FILE_LENGTH PATH_MAX
52 #endif
53 #ifdef ALLBSD
54 #include <errno.h>
55 #include <stdlib.h>
56 #include <sys/param.h>
57 #include <sys/sysctl.h>
58 #if defined(FREEBSD) || defined(DFBSD)
59 #include <sys/user.h>
60 #else
61 #include <sys/proc.h>
62 #endif
63 #include <string.h>
64 #include <paths.h>
65 #include <fcntl.h>
66 #include <limits.h>
67 #if (defined(FREEBSD) && !defined(FREEBSD5)) || defined(DFBSD)
68 #include <kvm.h>
69 #endif
70 #include <unistd.h>
71 #ifdef NETBSD2
72 #include <sys/lwp.h>
73 #endif
74 #endif
75
76 static void proc_state_init(sg_process_stats *s) {
77 s->process_name = NULL;
78 s->proctitle = NULL;
79 }
80
81 static void proc_state_destroy(sg_process_stats *s) {
82 free(s->process_name);
83 free(s->proctitle);
84 }
85
86 sg_process_stats *sg_get_process_stats(int *entries){
87 VECTOR_DECLARE_STATIC(proc_state, sg_process_stats, 64,
88 proc_state_init, proc_state_destroy);
89 int proc_state_size = 0;
90 sg_process_stats *proc_state_ptr;
91 #ifdef ALLBSD
92 int mib[4];
93 size_t size;
94 struct kinfo_proc *kp_stats;
95 int procs, i;
96 char *proctitle;
97 #if (defined(FREEBSD) && !defined(FREEBSD5)) || defined(DFBSD)
98 kvm_t *kvmd;
99 char **args, **argsp;
100 int argslen = 0;
101 #else
102 long buflen;
103 char *p, *proctitletmp;
104 #endif
105 #ifdef NETBSD2
106 int lwps;
107 struct kinfo_lwp *kl_stats;
108 #endif
109 #endif
110 #if defined(SOLARIS) || defined(LINUX)
111 DIR *proc_dir;
112 struct dirent *dir_entry;
113 char filename[MAX_FILE_LENGTH];
114 FILE *f;
115 #ifdef SOLARIS
116 psinfo_t process_info;
117 #endif
118 #ifdef LINUX
119 char s;
120 /* If someone has a executable of 4k filename length, they deserve to get it truncated :) */
121 char ps_name[4096];
122 char *ptr;
123 VECTOR_DECLARE_STATIC(psargs, char, 128, NULL, NULL);
124 unsigned long stime, utime, starttime;
125 int x;
126 int fn;
127 int len;
128 int rc;
129 time_t uptime;
130 #endif
131
132 #ifdef LINUX
133 if ((f=fopen("/proc/uptime", "r")) == NULL) {
134 sg_set_error_with_errno(SG_ERROR_OPEN, "/proc/uptime");
135 return NULL;
136 }
137 if((fscanf(f,"%lu %*d",&uptime)) != 1){
138 sg_set_error(SG_ERROR_PARSE, NULL);
139 return NULL;
140 }
141 fclose(f);
142 #endif
143
144 if((proc_dir=opendir(PROC_LOCATION))==NULL){
145 sg_set_error_with_errno(SG_ERROR_OPENDIR, PROC_LOCATION);
146 return NULL;
147 }
148
149 while((dir_entry=readdir(proc_dir))!=NULL){
150 if(atoi(dir_entry->d_name) == 0) continue;
151
152 #ifdef SOLARIS
153 snprintf(filename, MAX_FILE_LENGTH, "/proc/%s/psinfo", dir_entry->d_name);
154 #endif
155 #ifdef LINUX
156 snprintf(filename, MAX_FILE_LENGTH, "/proc/%s/stat", dir_entry->d_name);
157 #endif
158 if((f=fopen(filename, "r"))==NULL){
159 /* Open failed.. Process since vanished, or the path was too long.
160 * Ah well, move onwards to the next one */
161 continue;
162 }
163 #ifdef SOLARIS
164 fread(&process_info, sizeof(psinfo_t), 1, f);
165 fclose(f);
166 #endif
167
168 if (VECTOR_RESIZE(proc_state, proc_state_size + 1) < 0) {
169 return NULL;
170 }
171 proc_state_ptr = proc_state+proc_state_size;
172
173 #ifdef SOLARIS
174 proc_state_ptr->pid = process_info.pr_pid;
175 proc_state_ptr->parent = process_info.pr_ppid;
176 proc_state_ptr->pgid = process_info.pr_pgid;
177 proc_state_ptr->uid = process_info.pr_uid;
178 proc_state_ptr->euid = process_info.pr_euid;
179 proc_state_ptr->gid = process_info.pr_gid;
180 proc_state_ptr->egid = process_info.pr_egid;
181 proc_state_ptr->proc_size = (process_info.pr_size) * 1024;
182 proc_state_ptr->proc_resident = (process_info.pr_rssize) * 1024;
183 proc_state_ptr->time_spent = process_info.pr_time.tv_sec;
184 proc_state_ptr->cpu_percent = (process_info.pr_pctcpu * 100.0) / 0x8000;
185 proc_state_ptr->nice = (int)process_info.pr_lwp.pr_nice - 20;
186 if (sg_update_string(&proc_state_ptr->process_name,
187 process_info.pr_fname) < 0) {
188 return NULL;
189 }
190 if (sg_update_string(&proc_state_ptr->proctitle,
191 process_info.pr_psargs) < 0) {
192 return NULL;
193 }
194
195 if(process_info.pr_lwp.pr_state==1) proc_state_ptr->state = SG_PROCESS_STATE_SLEEPING;
196 if(process_info.pr_lwp.pr_state==2) proc_state_ptr->state = SG_PROCESS_STATE_RUNNING;
197 if(process_info.pr_lwp.pr_state==3) proc_state_ptr->state = SG_PROCESS_STATE_ZOMBIE;
198 if(process_info.pr_lwp.pr_state==4) proc_state_ptr->state = SG_PROCESS_STATE_STOPPED;
199 if(process_info.pr_lwp.pr_state==6) proc_state_ptr->state = SG_PROCESS_STATE_RUNNING;
200 #endif
201 #ifdef LINUX
202 x = fscanf(f, "%d %4096s %c %d %d %*d %*d %*d %*u %*u %*u %*u %*u %lu %lu %*d %*d %*d %d %*d %*d %lu %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), &starttime, &(proc_state_ptr->proc_size), &(proc_state_ptr->proc_resident));
203 /* +3 becuase man page says "Resident Set Size: number of pages the process has in real memory, minus 3 for administrative purposes." */
204 proc_state_ptr->proc_resident = (proc_state_ptr->proc_resident + 3) * getpagesize();
205 if(s == 'S') proc_state_ptr->state = SG_PROCESS_STATE_SLEEPING;
206 if(s == 'R') proc_state_ptr->state = SG_PROCESS_STATE_RUNNING;
207 if(s == 'Z') proc_state_ptr->state = SG_PROCESS_STATE_ZOMBIE;
208 if(s == 'T') proc_state_ptr->state = SG_PROCESS_STATE_STOPPED;
209 if(s == 'D') proc_state_ptr->state = SG_PROCESS_STATE_STOPPED;
210
211 /* pa_name[0] should = '(' */
212 ptr = strchr(&ps_name[1], ')');
213 if(ptr !=NULL) *ptr='\0';
214
215 if (sg_update_string(&proc_state_ptr->process_name,
216 &ps_name[1]) < 0) {
217 return NULL;
218 }
219
220 /* cpu */
221 proc_state_ptr->cpu_percent = (100.0 * (utime + stime)) / ((uptime * 100.0) - starttime);
222
223 fclose(f);
224
225 /* uid / gid */
226 snprintf(filename, MAX_FILE_LENGTH, "/proc/%s/status", dir_entry->d_name);
227 if ((f=fopen(filename, "r")) == NULL) {
228 /* Open failed.. Process since vanished, or the path was too long.
229 * Ah well, move onwards to the next one */
230 continue;
231 }
232
233 if((ptr=sg_f_read_line(f, "Uid:"))==NULL){
234 fclose(f);
235 continue;
236 }
237 sscanf(ptr, "Uid:\t%d\t%d\t%*d\t%*d\n", &(proc_state_ptr->uid), &(proc_state_ptr->euid));
238
239 if((ptr=sg_f_read_line(f, "Gid:"))==NULL){
240 fclose(f);
241 continue;
242 }
243 sscanf(ptr, "Gid:\t%d\t%d\t%*d\t%*d\n", &(proc_state_ptr->gid), &(proc_state_ptr->egid));
244
245 fclose(f);
246
247 /* proctitle */
248 snprintf(filename, MAX_FILE_LENGTH, "/proc/%s/cmdline", dir_entry->d_name);
249
250 if((fn=open(filename, O_RDONLY)) == -1){
251 /* Open failed.. Process since vanished, or the path was too long.
252 * Ah well, move onwards to the next one */
253 continue;
254 }
255
256 #define READ_BLOCK_SIZE 128
257 len = 0;
258 do {
259 if (VECTOR_RESIZE(psargs, len + READ_BLOCK_SIZE) < 0) {
260 return NULL;
261 }
262 rc = read(fn, psargs + len, READ_BLOCK_SIZE);
263 if (rc > 0) {
264 len += rc;
265 }
266 } while (rc == READ_BLOCK_SIZE);
267 close(fn);
268
269 if (rc == -1) {
270 /* Read failed; move on. */
271 continue;
272 }
273
274 /* Turn \0s into spaces within the command line. */
275 ptr = psargs;
276 for(x = 0; x < len; x++) {
277 if (*ptr == '\0') *ptr = ' ';
278 ptr++;
279 }
280
281 if (len == 0) {
282 /* We want psargs to be NULL. */
283 if (VECTOR_RESIZE(psargs, 0) < 0) {
284 return NULL;
285 }
286 } else {
287 /* Not empty, so append a \0. */
288 if (VECTOR_RESIZE(psargs, len + 1) < 0) {
289 return NULL;
290 }
291 psargs[len] = '\0';
292 }
293
294 if (sg_update_string(&proc_state_ptr->proctitle, psargs) < 0) {
295 return NULL;
296 }
297 #endif
298
299 proc_state_size++;
300 }
301 closedir(proc_dir);
302 #endif
303
304 #ifdef ALLBSD
305 mib[0] = CTL_KERN;
306 mib[1] = KERN_PROC;
307 mib[2] = KERN_PROC_ALL;
308
309 if(sysctl(mib, 3, NULL, &size, NULL, 0) < 0) {
310 sg_set_error_with_errno(SG_ERROR_SYSCTL,
311 "CTL_KERN.KERN_PROC.KERN_PROC_ALL");
312 return NULL;
313 }
314
315 procs = size / sizeof(struct kinfo_proc);
316
317 kp_stats = sg_malloc(size);
318 if(kp_stats == NULL) {
319 return NULL;
320 }
321 memset(kp_stats, 0, size);
322
323 if(sysctl(mib, 3, kp_stats, &size, NULL, 0) < 0) {
324 sg_set_error_with_errno(SG_ERROR_SYSCTL,
325 "CTL_KERN.KERN_PROC.KERN_PROC_ALL");
326 free(kp_stats);
327 return NULL;
328 }
329
330 #if (defined(FREEBSD) && !defined(FREEBSD5)) || defined(DFBSD)
331 kvmd = sg_get_kvm2();
332 #endif
333
334 for (i = 0; i < procs; i++) {
335 const char *name;
336
337 #ifdef FREEBSD5
338 if (kp_stats[i].ki_stat == 0) {
339 #else
340 if (kp_stats[i].kp_proc.p_stat == 0) {
341 #endif
342 /* FreeBSD 5 deliberately overallocates the array that
343 * the sysctl returns, so we'll get a few junk
344 * processes on the end that we have to ignore. (Search
345 * for "overestimate by 5 procs" in
346 * src/sys/kern/kern_proc.c for more details.) */
347 continue;
348 }
349
350 if (VECTOR_RESIZE(proc_state, proc_state_size + 1) < 0) {
351 return NULL;
352 }
353 proc_state_ptr = proc_state+proc_state_size;
354
355 #ifdef FREEBSD5
356 name = kp_stats[i].ki_comm;
357 #elif defined(DFBSD)
358 name = kp_stats[i].kp_thread.td_comm;
359 #else
360 name = kp_stats[i].kp_proc.p_comm;
361 #endif
362 if (sg_update_string(&proc_state_ptr->process_name, name) < 0) {
363 return NULL;
364 }
365
366 #if defined(FREEBSD5) || defined(NETBSD) || defined(OPENBSD)
367
368 #ifdef FREEBSD5
369 mib[2] = KERN_PROC_ARGS;
370 mib[3] = kp_stats[i].ki_pid;
371 #else
372 mib[1] = KERN_PROC_ARGS;
373 mib[2] = kp_stats[i].kp_proc.p_pid;
374 mib[3] = KERN_PROC_ARGV;
375 #endif
376
377 free(proc_state_ptr->proctitle);
378 proc_state_ptr->proctitle = NULL;
379
380 /* Starting size - we'll double this straight away */
381 #define PROCTITLE_START_SIZE 64
382 buflen = PROCTITLE_START_SIZE;
383 size = buflen;
384 proctitle = NULL;
385
386 do {
387 if(size >= buflen) {
388 buflen *= 2;
389 size = buflen;
390 proctitletmp = sg_realloc(proctitle, buflen);
391 if(proctitletmp == NULL) {
392 free(proctitle);
393 proctitle = NULL;
394 proc_state_ptr->proctitle = NULL;
395 size = 0;
396 break;
397 }
398 proctitle = proctitletmp;
399 bzero(proctitle, buflen);
400 }
401
402 if(sysctl(mib, 4, proctitle, &size, NULL, 0) < 0) {
403 free(proctitle);
404 proctitle = NULL;
405 proc_state_ptr->proctitle = NULL;
406 size = 0;
407 break;
408 }
409 } while(size >= buflen);
410
411 if(size > 0) {
412 proc_state_ptr->proctitle = sg_malloc(size+1);
413 if(proc_state_ptr->proctitle == NULL) {
414 return NULL;
415 }
416 p = proctitle;
417 #ifdef OPENBSD
418 /* On OpenBSD, this value has the argv pointers (which
419 * are terminated by a NULL) at the front, so we have
420 * to skip over them to get to the strings. */
421 while (*(char ***)p != NULL) {
422 p += sizeof(char **);
423 }
424 p += sizeof(char **);
425 #endif
426 proc_state_ptr->proctitle[0] = '\0';
427 do {
428 sg_strlcat(proc_state_ptr->proctitle, p, size+1);
429 sg_strlcat(proc_state_ptr->proctitle, " ", size+1);
430 p += strlen(p) + 1;
431 } while (p < proctitle + size);
432 free(proctitle);
433 proctitle = NULL;
434 /* remove trailing space */
435 proc_state_ptr->proctitle[strlen(proc_state_ptr->proctitle)-1] = '\0';
436 }
437 else {
438 if(proctitle != NULL) {
439 free(proctitle);
440 proctitle = NULL;
441 }
442 proc_state_ptr->proctitle = NULL;
443 }
444 #else
445 free(proc_state_ptr->proctitle);
446 proc_state_ptr->proctitle = NULL;
447 if(kvmd != NULL) {
448 args = kvm_getargv(kvmd, &(kp_stats[i]), 0);
449 if(args != NULL) {
450 argsp = args;
451 while(*argsp != NULL) {
452 argslen += strlen(*argsp) + 1;
453 argsp++;
454 }
455 proctitle = sg_malloc(argslen + 1);
456 proctitle[0] = '\0';
457 if(proctitle == NULL) {
458 return NULL;
459 }
460 while(*args != NULL) {
461 sg_strlcat(proctitle, *args, argslen + 1);
462 sg_strlcat(proctitle, " ", argslen + 1);
463 args++;
464 }
465 /* remove trailing space */
466 proctitle[strlen(proctitle)-1] = '\0';
467 proc_state_ptr->proctitle = proctitle;
468 }
469 else {
470 proc_state_ptr->proctitle = NULL;
471 }
472 }
473 else {
474 proc_state_ptr->proctitle = NULL;
475 }
476 #endif
477
478 #ifdef FREEBSD5
479 proc_state_ptr->pid = kp_stats[i].ki_pid;
480 proc_state_ptr->parent = kp_stats[i].ki_ppid;
481 proc_state_ptr->pgid = kp_stats[i].ki_pgid;
482 #else
483 proc_state_ptr->pid = kp_stats[i].kp_proc.p_pid;
484 proc_state_ptr->parent = kp_stats[i].kp_eproc.e_ppid;
485 proc_state_ptr->pgid = kp_stats[i].kp_eproc.e_pgid;
486 #endif
487
488 #ifdef FREEBSD5
489 proc_state_ptr->uid = kp_stats[i].ki_ruid;
490 proc_state_ptr->euid = kp_stats[i].ki_uid;
491 proc_state_ptr->gid = kp_stats[i].ki_rgid;
492 proc_state_ptr->egid = kp_stats[i].ki_svgid;
493 #elif defined(DFBSD)
494 proc_state_ptr->uid = kp_stats[i].kp_eproc.e_ucred.cr_ruid;
495 proc_state_ptr->euid = kp_stats[i].kp_eproc.e_ucred.cr_svuid;
496 proc_state_ptr->gid = kp_stats[i].kp_eproc.e_ucred.cr_rgid;
497 proc_state_ptr->egid = kp_stats[i].kp_eproc.e_ucred.cr_svgid;
498 #else
499 proc_state_ptr->uid = kp_stats[i].kp_eproc.e_pcred.p_ruid;
500 proc_state_ptr->euid = kp_stats[i].kp_eproc.e_pcred.p_svuid;
501 proc_state_ptr->gid = kp_stats[i].kp_eproc.e_pcred.p_rgid;
502 proc_state_ptr->egid = kp_stats[i].kp_eproc.e_pcred.p_svgid;
503 #endif
504
505 #ifdef FREEBSD5
506 proc_state_ptr->proc_size = kp_stats[i].ki_size;
507 /* This is in pages */
508 proc_state_ptr->proc_resident =
509 kp_stats[i].ki_rssize * getpagesize();
510 /* This is in microseconds */
511 proc_state_ptr->time_spent = kp_stats[i].ki_runtime / 1000000;
512 proc_state_ptr->cpu_percent =
513 ((double)kp_stats[i].ki_pctcpu / FSCALE) * 100.0;
514 proc_state_ptr->nice = kp_stats[i].ki_nice;
515 #else
516 proc_state_ptr->proc_size =
517 kp_stats[i].kp_eproc.e_vm.vm_map.size;
518 /* This is in pages */
519 proc_state_ptr->proc_resident =
520 kp_stats[i].kp_eproc.e_vm.vm_rssize * getpagesize();
521 #if defined(NETBSD) || defined(OPENBSD)
522 proc_state_ptr->time_spent =
523 kp_stats[i].kp_proc.p_rtime.tv_sec;
524 #elif defined(DFBSD)
525 proc_state_ptr->time_spent =
526 ( kp_stats[i].kp_thread.td_uticks +
527 kp_stats[i].kp_thread.td_sticks +
528 kp_stats[i].kp_thread.td_iticks ) / 1000000;
529 #else
530 /* This is in microseconds */
531 proc_state_ptr->time_spent =
532 kp_stats[i].kp_proc.p_runtime / 1000000;
533 #endif
534 proc_state_ptr->cpu_percent =
535 ((double)kp_stats[i].kp_proc.p_pctcpu / FSCALE) * 100.0;
536 proc_state_ptr->nice = kp_stats[i].kp_proc.p_nice;
537 #endif
538
539 #ifdef NETBSD2
540 {
541 size_t size;
542 int mib[5];
543
544 mib[0] = CTL_KERN;
545 mib[1] = KERN_LWP;
546 mib[2] = kp_stats[i].kp_proc.p_pid;
547 mib[3] = sizeof(struct kinfo_lwp);
548 mib[4] = 0;
549
550 if(sysctl(mib, 5, NULL, &size, NULL, 0) < 0) {
551 sg_set_error_with_errno(SG_ERROR_SYSCTL, "CTL_KERN.KERN_LWP.pid.structsize.0");
552 return NULL;
553 }
554
555 lwps = size / sizeof(struct kinfo_lwp);
556 mib[4] = lwps;
557
558 kl_stats = sg_malloc(size);
559 if(kl_stats == NULL) {
560 return NULL;
561 }
562
563 if(sysctl(mib, 5, kl_stats, &size, NULL, 0) < 0) {
564 sg_set_error_with_errno(SG_ERROR_SYSCTL, "CTL_KERN.KERN_LWP.pid.structsize.buffersize");
565 return NULL;
566 }
567 }
568
569 switch(kp_stats[i].kp_proc.p_stat) {
570 case SIDL:
571 proc_state_ptr->state = SG_PROCESS_STATE_RUNNING;
572 break;
573 case SACTIVE:
574 {
575 int i;
576
577 for(i = 0; i < lwps; i++) {
578 switch(kl_stats[i].l_stat) {
579 case LSONPROC:
580 case LSRUN:
581 proc_state_ptr->state = SG_PROCESS_STATE_RUNNING;
582 goto end;
583 case LSSLEEP:
584 proc_state_ptr->state = SG_PROCESS_STATE_SLEEPING;
585 goto end;
586 case LSSTOP:
587 case LSSUSPENDED:
588 proc_state_ptr->state = SG_PROCESS_STATE_STOPPED;
589 goto end;
590 }
591 proc_state_ptr->state = SG_PROCESS_STATE_UNKNOWN;
592 }
593 end: ;
594 }
595 break;
596 case SSTOP:
597 proc_state_ptr->state = SG_PROCESS_STATE_STOPPED;
598 break;
599 case SZOMB:
600 proc_state_ptr->state = SG_PROCESS_STATE_ZOMBIE;
601 break;
602 default:
603 proc_state_ptr->state = SG_PROCESS_STATE_UNKNOWN;
604 break;
605 }
606
607 free(kl_stats);
608 #else
609 #ifdef FREEBSD5
610 switch (kp_stats[i].ki_stat) {
611 #else
612 switch (kp_stats[i].kp_proc.p_stat) {
613 #endif
614 case SIDL:
615 case SRUN:
616 #ifdef SONPROC
617 case SONPROC: /* NetBSD */
618 #endif
619 proc_state_ptr->state = SG_PROCESS_STATE_RUNNING;
620 break;
621 case SSLEEP:
622 #ifdef SWAIT
623 case SWAIT: /* FreeBSD 5 */
624 #endif
625 #ifdef SLOCK
626 case SLOCK: /* FreeBSD 5 */
627 #endif
628 proc_state_ptr->state = SG_PROCESS_STATE_SLEEPING;
629 break;
630 case SSTOP:
631 proc_state_ptr->state = SG_PROCESS_STATE_STOPPED;
632 break;
633 case SZOMB:
634 #ifdef SDEAD
635 case SDEAD: /* OpenBSD & NetBSD */
636 #endif
637 proc_state_ptr->state = SG_PROCESS_STATE_ZOMBIE;
638 break;
639 default:
640 proc_state_ptr->state = SG_PROCESS_STATE_UNKNOWN;
641 break;
642 }
643 #endif
644 proc_state_size++;
645 }
646
647 free(kp_stats);
648 #endif
649
650 #ifdef CYGWIN
651 sg_set_error(SG_ERROR_UNSUPPORTED, "Cygwin");
652 return NULL;
653 #endif
654
655 *entries = proc_state_size;
656 return proc_state;
657 }
658
659 sg_process_count *sg_get_process_count() {
660 static sg_process_count process_stat;
661 sg_process_stats *ps;
662 int ps_size, x;
663
664 process_stat.sleeping = 0;
665 process_stat.running = 0;
666 process_stat.zombie = 0;
667 process_stat.stopped = 0;
668 process_stat.total = 0;
669
670 ps = sg_get_process_stats(&ps_size);
671 if (ps == NULL) {
672 return NULL;
673 }
674
675 for(x = 0; x < ps_size; x++) {
676 switch (ps->state) {
677 case SG_PROCESS_STATE_RUNNING:
678 process_stat.running++;
679 break;
680 case SG_PROCESS_STATE_SLEEPING:
681 process_stat.sleeping++;
682 break;
683 case SG_PROCESS_STATE_STOPPED:
684 process_stat.stopped++;
685 break;
686 case SG_PROCESS_STATE_ZOMBIE:
687 process_stat.zombie++;
688 break;
689 default:
690 /* currently no mapping for SG_PROCESS_STATE_UNKNOWN in
691 * sg_process_count */
692 break;
693 }
694 ps++;
695 }
696
697 process_stat.total = ps_size;
698
699 return &process_stat;
700 }
701
702 int sg_process_compare_name(const void *va, const void *vb) {
703 const sg_process_stats *a = (sg_process_stats *)va;
704 const sg_process_stats *b = (sg_process_stats *)vb;
705
706 return strcmp(a->process_name, b->process_name);
707 }
708
709 int sg_process_compare_pid(const void *va, const void *vb) {
710 const sg_process_stats *a = (sg_process_stats *)va;
711 const sg_process_stats *b = (sg_process_stats *)vb;
712
713 if (a->pid < b->pid) {
714 return -1;
715 } else if (a->pid == b->pid) {
716 return 0;
717 } else {
718 return 1;
719 }
720 }
721
722 int sg_process_compare_uid(const void *va, const void *vb) {
723 const sg_process_stats *a = (sg_process_stats *)va;
724 const sg_process_stats *b = (sg_process_stats *)vb;
725
726 if (a->uid < b->uid) {
727 return -1;
728 } else if (a->uid == b->uid) {
729 return 0;
730 } else {
731 return 1;
732 }
733 }
734
735 int sg_process_compare_gid(const void *va, const void *vb) {
736 const sg_process_stats *a = (sg_process_stats *)va;
737 const sg_process_stats *b = (sg_process_stats *)vb;
738
739 if (a->gid < b->gid) {
740 return -1;
741 } else if (a->gid == b->gid) {
742 return 0;
743 } else {
744 return 1;
745 }
746 }
747
748 int sg_process_compare_size(const void *va, const void *vb) {
749 const sg_process_stats *a = (sg_process_stats *)va;
750 const sg_process_stats *b = (sg_process_stats *)vb;
751
752 if (a->proc_size < b->proc_size) {
753 return -1;
754 } else if (a->proc_size == b->proc_size) {
755 return 0;
756 } else {
757 return 1;
758 }
759 }
760
761 int sg_process_compare_res(const void *va, const void *vb) {
762 const sg_process_stats *a = (sg_process_stats *)va;
763 const sg_process_stats *b = (sg_process_stats *)vb;
764
765 if (a->proc_resident < b->proc_resident) {
766 return -1;
767 } else if (a->proc_resident == b->proc_resident) {
768 return 0;
769 } else {
770 return 1;
771 }
772 }
773
774 int sg_process_compare_cpu(const void *va, const void *vb) {
775 const sg_process_stats *a = (sg_process_stats *)va;
776 const sg_process_stats *b = (sg_process_stats *)vb;
777
778 if (a->cpu_percent < b->cpu_percent) {
779 return -1;
780 } else if (a->cpu_percent == b->cpu_percent) {
781 return 0;
782 } else {
783 return 1;
784 }
785 }
786
787 int sg_process_compare_time(const void *va, const void *vb) {
788 const sg_process_stats *a = (sg_process_stats *)va;
789 const sg_process_stats *b = (sg_process_stats *)vb;
790
791 if (a->time_spent < b->time_spent) {
792 return -1;
793 } else if (a->time_spent == b->time_spent) {
794 return 0;
795 } else {
796 return 1;
797 }
798 }
799