ViewVC Help
View File | Revision Log | Show Annotations | Revision Graph | Root Listing
root/i-scream/projects/libstatgrab/src/libstatgrab/process_stats.c
Revision: 1.46
Committed: Sun Apr 4 23:57:33 2004 UTC (20 years, 1 month ago) by tdb
Content type: text/plain
Branch: MAIN
Changes since 1.45: +12 -12 lines
Log Message: 
Returning NULL in a function that returns int's is wrong :)

Now returns -1 on failure. Also change code that calls us to check for < 0
for failures.

File Contents

# User Rev Content
1 tdb 1.17 /*
2 pajs 1.1 * i-scream central monitoring system
3 tdb 1.8 * http://www.i-scream.org
4 tdb 1.17 * Copyright (C) 2000-2004 i-scream
5 pajs 1.1 *
6 tdb 1.17 * 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 pajs 1.1 *
11 tdb 1.17 * This library is distributed in the hope that it will be useful,
12 pajs 1.1 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 tdb 1.17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14     * Lesser General Public License for more details.
15 pajs 1.1 *
16 tdb 1.17 * 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 tdb 1.18 *
21 tdb 1.46 * $Id: process_stats.c,v 1.45 2004/04/04 23:35:45 tdb Exp $
22 pajs 1.1 */
23    
24     #ifdef HAVE_CONFIG_H
25     #include "config.h"
26     #endif
27    
28 pajs 1.6 #include "statgrab.h"
29     #if defined(SOLARIS) || defined(LINUX)
30 pajs 1.1 #include <stdio.h>
31     #include <stdlib.h>
32 pajs 1.5 #include <sys/types.h>
33     #include <dirent.h>
34     #include <string.h>
35 pajs 1.6 #endif
36 pajs 1.1
37     #ifdef SOLARIS
38     #include <procfs.h>
39     #include <limits.h>
40 pajs 1.5 #define PROC_LOCATION "/proc"
41     #define MAX_FILE_LENGTH PATH_MAX
42     #endif
43     #ifdef LINUX
44 ats 1.16 #include <limits.h>
45 pajs 1.25 #include <unistd.h>
46     #include <sys/stat.h>
47     #include <fcntl.h>
48 pajs 1.1 #define PROC_LOCATION "/proc"
49     #define MAX_FILE_LENGTH PATH_MAX
50     #endif
51 ats 1.13 #ifdef ALLBSD
52 tdb 1.19 #include <stdlib.h>
53 pajs 1.6 #include <sys/param.h>
54     #include <sys/sysctl.h>
55 tdb 1.22 #if defined(FREEBSD) || defined(DFBSD)
56     #include <sys/user.h>
57     #else
58 tdb 1.19 #include <sys/proc.h>
59 ats 1.13 #endif
60 tdb 1.29 #include <string.h>
61     #include <paths.h>
62     #include <fcntl.h>
63     #include <limits.h>
64 tdb 1.41 #if (defined(FREEBSD) && !defined(FREEBSD5)) || defined(DFBSD)
65 tdb 1.29 #include <kvm.h>
66 tdb 1.43 #include <tools.h>
67 pajs 1.6 #endif
68 tdb 1.41 #include <unistd.h>
69     #endif
70 pajs 1.1
71 pajs 1.23 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 tdb 1.26 #ifdef ALLBSD
76 tdb 1.37 int mib[4];
77 tdb 1.26 size_t size;
78     struct kinfo_proc *kp_stats;
79 tdb 1.41 int procs, i;
80 tdb 1.45 char *proctitle;
81 tdb 1.41 #if (defined(FREEBSD) && !defined(FREEBSD5)) || defined(DFBSD)
82 tdb 1.42 kvm_t *kvmd;
83 tdb 1.41 char **args;
84     int alloc;
85 tdb 1.45 char *proctitletmp;
86 tdb 1.41 #else
87 tdb 1.37 long buflen;
88     char *p;
89     #endif
90 tdb 1.26 #endif
91 pajs 1.24 #if defined(SOLARIS) || defined(LINUX)
92 pajs 1.23 DIR *proc_dir;
93     struct dirent *dir_entry;
94     char filename[MAX_FILE_LENGTH];
95     FILE *f;
96 pajs 1.24 #ifdef SOLARIS
97 pajs 1.5 psinfo_t process_info;
98 pajs 1.24 #endif
99 pajs 1.25 #ifdef LINUX
100     char s;
101     /* If someone has a executable of 4k filename length, they deserve to get it truncated :) */
102     char ps_name[4096];
103     char *ptr;
104     static char *psargs = NULL;
105     static int psarg_size = 0;
106     unsigned long stime, utime;
107     int x;
108     int fn;
109     int toread;
110     ssize_t size;
111     int t_read;
112     #endif
113 pajs 1.1
114 pajs 1.23 if((proc_dir=opendir(PROC_LOCATION))==NULL){
115 pajs 1.25 return -1;
116 pajs 1.23 }
117    
118     while((dir_entry=readdir(proc_dir))!=NULL){
119     if(atoi(dir_entry->d_name) == 0) continue;
120    
121 pajs 1.24 #ifdef SOLARIS
122 pajs 1.23 snprintf(filename, MAX_FILE_LENGTH, "/proc/%s/psinfo", dir_entry->d_name);
123 pajs 1.24 #endif
124 pajs 1.25 #ifdef LINUX
125     snprintf(filename, MAX_FILE_LENGTH, "/proc/%s/stat", dir_entry->d_name);
126     #endif
127 pajs 1.23 if((f=fopen(filename, "r"))==NULL){
128     /* Open failed.. Process since vanished, or the path was too long.
129     * Ah well, move onwards to the next one */
130     continue;
131     }
132 pajs 1.24 #ifdef SOLARIS
133 pajs 1.23 fread(&process_info, sizeof(psinfo_t), 1, f);
134 pajs 1.25 #endif
135 pajs 1.1
136 pajs 1.23 proc_state = realloc(proc_state, (1+proc_state_size)*sizeof(proc_state_t));
137     proc_state_ptr = proc_state+proc_state_size;
138 pajs 1.25 #ifdef SOLARIS
139 pajs 1.23 proc_state_ptr->pid = process_info.pr_pid;
140     proc_state_ptr->parent = process_info.pr_ppid;
141     proc_state_ptr->pgid = process_info.pr_pgid;
142     proc_state_ptr->uid = process_info.pr_uid;
143     proc_state_ptr->euid = process_info.pr_euid;
144     proc_state_ptr->gid = process_info.pr_gid;
145     proc_state_ptr->egid = process_info.pr_egid;
146     proc_state_ptr->proc_size = (process_info.pr_size) * 1024;
147     proc_state_ptr->proc_resident = (process_info.pr_rssize) * 1024;
148     proc_state_ptr->time_spent = process_info.pr_time.tv_sec;
149     proc_state_ptr->cpu_percent = (process_info.pr_pctcpu * 100.0) / 0x8000;
150     proc_state_ptr->process_name = strdup(process_info.pr_fname);
151     proc_state_ptr->proctitle = strdup(process_info.pr_psargs);
152 pajs 1.24
153     if(process_info.pr_lwp.pr_state==1) proc_state_ptr->state = SLEEPING;
154     if(process_info.pr_lwp.pr_state==2) proc_state_ptr->state = RUNNING;
155     if(process_info.pr_lwp.pr_state==3) proc_state_ptr->state = ZOMBIE;
156     if(process_info.pr_lwp.pr_state==4) proc_state_ptr->state = STOPPED;
157     if(process_info.pr_lwp.pr_state==6) proc_state_ptr->state = RUNNING;
158 pajs 1.25 #endif
159     #ifdef LINUX
160 ats 1.38 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));
161 pajs 1.25 proc_state_ptr->proc_resident = proc_state_ptr->proc_resident * getpagesize();
162     if(s == 'S') proc_state_ptr->state = SLEEPING;
163     if(s == 'R') proc_state_ptr->state = RUNNING;
164     if(s == 'Z') proc_state_ptr->state = ZOMBIE;
165     if(s == 'T') proc_state_ptr->state = STOPPED;
166     if(s == 'D') proc_state_ptr->state = STOPPED;
167    
168     /* pa_name[0] should = '(' */
169     ptr = strchr(&ps_name[1], ')');
170     if(ptr !=NULL) *ptr='\0';
171     proc_state_ptr->process_name = strdup(&ps_name[1]);
172    
173     /* Need to do cpu */
174    
175    
176     /* proctitle */
177     snprintf(filename, MAX_FILE_LENGTH, "/proc/%s/cmdline", dir_entry->d_name);
178    
179     if((fn=open(filename, O_RDONLY)) == -1){
180     /* Open failed.. Process since vanished, or the path was too long.
181     * Ah well, move onwards to the next one */
182     continue;
183     }
184     #define PSARG_START_SIZE 128
185     if(psargs == NULL){
186     psargs = malloc(PSARG_START_SIZE);
187     psarg_size = PSARG_START_SIZE;
188     }
189     ptr = psargs;
190     t_read = 0;
191     toread = psarg_size;
192     while((size = read(fn, ptr, toread)) == toread){
193     psargs = realloc(psargs, (psarg_size + PSARG_START_SIZE));
194     ptr = psargs+psarg_size;
195     t_read = psarg_size;
196     psarg_size+=PSARG_START_SIZE;
197     toread = PSARG_START_SIZE;
198     }
199     if(size != -1) t_read+=size;
200    
201     ptr = psargs;
202     for(x=0; x<t_read; x++){
203     if (*ptr == '\0') *ptr = ' ';
204     ptr++;
205     }
206     /* for safety sake */
207     psargs[t_read] = '\0';
208    
209     proc_state_ptr->proctitle = strdup(psargs);
210    
211 pajs 1.24 #endif
212 pajs 1.23
213     proc_state_size++;
214 pajs 1.1
215 pajs 1.23 fclose(f);
216     }
217     closedir(proc_dir);
218 tdb 1.26 #endif
219    
220     #ifdef ALLBSD
221 tdb 1.36 mib[0] = CTL_KERN;
222     mib[1] = KERN_PROC;
223     mib[2] = KERN_PROC_ALL;
224    
225     if(sysctl(mib, 3, NULL, &size, NULL, 0) < 0) {
226 tdb 1.46 return -1;
227 tdb 1.36 }
228    
229     procs = size / sizeof(struct kinfo_proc);
230    
231     kp_stats = malloc(size);
232     if(kp_stats == NULL) {
233 tdb 1.46 return -1;
234 tdb 1.36 }
235    
236     if(sysctl(mib, 3, kp_stats, &size, NULL, 0) < 0) {
237     free(kp_stats);
238 tdb 1.46 return -1;
239 tdb 1.36 }
240 tdb 1.33
241 tdb 1.37 #if (defined(FREEBSD) && !defined(FREEBSD5)) || defined(DFBSD)
242 tdb 1.42 kvmd = get_kvm2();
243 tdb 1.33 #endif
244 tdb 1.26
245     for (i = 0; i < procs; i++) {
246 tdb 1.29 /* replace with something more sensible */
247 tdb 1.30 proc_state = realloc(proc_state,
248     (1+proc_state_size)*sizeof(proc_state_t));
249 tdb 1.29 if(proc_state == NULL ) {
250 tdb 1.46 return -1;
251 tdb 1.29 }
252 tdb 1.26 proc_state_ptr = proc_state+proc_state_size;
253 tdb 1.30
254     #ifdef FREEBSD5
255     proc_state_ptr->process_name =
256     strdup(kp_stats[i].ki_comm);
257 tdb 1.35 #elif defined(DFBSD)
258     proc_state_ptr->process_name =
259     strdup(kp_stats[i].kp_thread.td_comm);
260 tdb 1.30 #else
261     proc_state_ptr->process_name =
262     strdup(kp_stats[i].kp_proc.p_comm);
263     #endif
264 tdb 1.29
265 tdb 1.37 #if defined(FREEBSD5) || defined(NETBSD) || defined(OPENBSD)
266     size = sizeof(buflen);
267    
268     #ifdef FREEBSD5
269     if(sysctlbyname("kern.ps_arg_cache_limit", &buflen, &size, NULL, 0) < 0) {
270 tdb 1.46 return -1;
271 tdb 1.37 }
272     #else
273     mib[1] = KERN_ARGMAX;
274    
275     if(sysctl(mib, 2, &buflen, &size, NULL, 0) < 0) {
276 tdb 1.46 return -1;
277 tdb 1.37 }
278     #endif
279    
280     proctitle = malloc(buflen);
281     if(proctitle == NULL) {
282 tdb 1.46 return -1;
283 tdb 1.37 }
284    
285     size = buflen;
286    
287     #ifdef FREEBSD5
288     mib[2] = KERN_PROC_ARGS;
289     mib[3] = kp_stats[i].ki_pid;
290     #else
291     mib[1] = KERN_PROC_ARGS;
292     mib[2] = kp_stats[i].kp_proc.p_pid;
293     mib[3] = KERN_PROC_ARGV;
294     #endif
295    
296     if(sysctl(mib, 4, proctitle, &size, NULL, 0) < 0) {
297     free(proctitle);
298     proc_state_ptr->proctitle = NULL;
299     }
300     else if(size > 0) {
301 tdb 1.44 proc_state_ptr->proctitle = malloc(size+1);
302 tdb 1.37 if(proc_state_ptr->proctitle == NULL) {
303 tdb 1.46 return -1;
304 tdb 1.29 }
305 tdb 1.37 p = proctitle;
306     proc_state_ptr->proctitle[0] = NULL;
307     do {
308 tdb 1.44 strlcat(proc_state_ptr->proctitle, p, size+1);
309     strlcat(proc_state_ptr->proctitle, " ", size+1);
310 tdb 1.37 p += strlen(p) + 1;
311     } while (p < proctitle + size);
312     free(proctitle);
313 tdb 1.45 /* remove trailing space */
314     proc_state_ptr->proctitle[strlen(proc_state_ptr->proctitle)-1] = '\0';
315 tdb 1.37 }
316     else {
317     free(proctitle);
318     proc_state_ptr->proctitle = NULL;
319     }
320     #else
321     if(kvmd != NULL) {
322     args = kvm_getargv(kvmd, &(kp_stats[i]), 0);
323     if(args != NULL) {
324     alloc = 1;
325     proctitle = malloc(alloc);
326     if(proctitle == NULL) {
327 tdb 1.46 return -1;
328 tdb 1.37 }
329     while(*args != NULL) {
330     if(strlen(proctitle) + strlen(*args) >= alloc) {
331 tdb 1.44 alloc = (alloc + strlen(*args)) * 2;
332     proctitletmp = realloc(proctitle, alloc);
333     if(proctitletmp == NULL) {
334 tdb 1.46 return -1;
335 tdb 1.37 }
336 tdb 1.44 proctitle = proctitletmp;
337 tdb 1.29 }
338 tdb 1.44 strlcat(proctitle, *args, alloc);
339     strlcat(proctitle, " ", alloc);
340 tdb 1.37 args++;
341 tdb 1.29 }
342 tdb 1.37 /* remove trailing space */
343 tdb 1.45 proctitle[strlen(proctitle)-1] = '\0';
344 tdb 1.37 proc_state_ptr->proctitle = proctitle;
345     }
346     else {
347     proc_state_ptr->proctitle = NULL;
348 tdb 1.29 }
349     }
350     else {
351 tdb 1.37 proc_state_ptr->proctitle = NULL;
352 tdb 1.29 }
353 tdb 1.37 #endif
354 tdb 1.26
355 tdb 1.30 #ifdef FREEBSD5
356 tdb 1.26 proc_state_ptr->pid = kp_stats[i].ki_pid;
357     proc_state_ptr->parent = kp_stats[i].ki_ppid;
358     proc_state_ptr->pgid = kp_stats[i].ki_pgid;
359 tdb 1.30 #else
360     proc_state_ptr->pid = kp_stats[i].kp_proc.p_pid;
361     proc_state_ptr->parent = kp_stats[i].kp_eproc.e_ppid;
362     proc_state_ptr->pgid = kp_stats[i].kp_eproc.e_pgid;
363     #endif
364 tdb 1.26
365 tdb 1.30 #ifdef FREEBSD5
366 tdb 1.26 proc_state_ptr->uid = kp_stats[i].ki_ruid;
367     proc_state_ptr->euid = kp_stats[i].ki_uid;
368     proc_state_ptr->gid = kp_stats[i].ki_rgid;
369     proc_state_ptr->egid = kp_stats[i].ki_svgid;
370 tdb 1.35 #elif defined(DFBSD)
371     proc_state_ptr->uid = kp_stats[i].kp_eproc.e_ucred.cr_ruid;
372     proc_state_ptr->euid = kp_stats[i].kp_eproc.e_ucred.cr_svuid;
373     proc_state_ptr->gid = kp_stats[i].kp_eproc.e_ucred.cr_rgid;
374     proc_state_ptr->egid = kp_stats[i].kp_eproc.e_ucred.cr_svgid;
375 tdb 1.30 #else
376     proc_state_ptr->uid = kp_stats[i].kp_eproc.e_pcred.p_ruid;
377     proc_state_ptr->euid = kp_stats[i].kp_eproc.e_pcred.p_svuid;
378     proc_state_ptr->gid = kp_stats[i].kp_eproc.e_pcred.p_rgid;
379     proc_state_ptr->egid = kp_stats[i].kp_eproc.e_pcred.p_svgid;
380     #endif
381 tdb 1.26
382 tdb 1.30 #ifdef FREEBSD5
383 tdb 1.26 proc_state_ptr->proc_size = kp_stats[i].ki_size;
384     /* This is in pages */
385 tdb 1.30 proc_state_ptr->proc_resident =
386     kp_stats[i].ki_rssize * getpagesize();
387 tdb 1.28 /* This is in microseconds */
388 tdb 1.26 proc_state_ptr->time_spent = kp_stats[i].ki_runtime / 1000000;
389 tdb 1.30 proc_state_ptr->cpu_percent =
390     ((double)kp_stats[i].ki_pctcpu / FSCALE) * 100.0;
391 tdb 1.26 proc_state_ptr->nice = kp_stats[i].ki_nice;
392 tdb 1.30 #else
393     proc_state_ptr->proc_size =
394     kp_stats[i].kp_eproc.e_vm.vm_map.size;
395     /* This is in pages */
396     proc_state_ptr->proc_resident =
397     kp_stats[i].kp_eproc.e_vm.vm_rssize * getpagesize();
398 tdb 1.34 #if defined(NETBSD) || defined(OPENBSD)
399 tdb 1.33 proc_state_ptr->time_spent =
400     kp_stats[i].kp_proc.p_rtime.tv_sec;
401 tdb 1.35 #elif defined(DFBSD)
402     proc_state_ptr->time_spent =
403     ( kp_stats[i].kp_thread.td_uticks +
404     kp_stats[i].kp_thread.td_sticks +
405     kp_stats[i].kp_thread.td_iticks ) / 1000000;
406 tdb 1.33 #else
407 tdb 1.36 /* This is in microseconds */
408 tdb 1.30 proc_state_ptr->time_spent =
409     kp_stats[i].kp_proc.p_runtime / 1000000;
410 tdb 1.33 #endif
411 tdb 1.30 proc_state_ptr->cpu_percent =
412     ((double)kp_stats[i].kp_proc.p_pctcpu / FSCALE) * 100.0;
413     proc_state_ptr->nice = kp_stats[i].kp_proc.p_nice;
414     #endif
415 tdb 1.26
416 tdb 1.30 #ifdef FREEBSD5
417 tdb 1.26 switch (kp_stats[i].ki_stat) {
418 tdb 1.30 #else
419     switch (kp_stats[i].kp_proc.p_stat) {
420     #endif
421 tdb 1.26 case SIDL:
422     case SRUN:
423     #ifdef SONPROC
424     case SONPROC: /* NetBSD */
425     #endif
426     proc_state_ptr->state = RUNNING;
427     break;
428     case SSLEEP:
429     #ifdef SWAIT
430     case SWAIT: /* FreeBSD 5 */
431     #endif
432     #ifdef SLOCK
433     case SLOCK: /* FreeBSD 5 */
434     #endif
435     proc_state_ptr->state = SLEEPING;
436     break;
437     case SSTOP:
438     proc_state_ptr->state = STOPPED;
439     break;
440     case SZOMB:
441     #ifdef SDEAD
442     case SDEAD: /* OpenBSD & NetBSD */
443     #endif
444     proc_state_ptr->state = ZOMBIE;
445 tdb 1.31 break;
446     default:
447     proc_state_ptr->state = UNKNOWN;
448 tdb 1.26 break;
449     }
450     proc_state_size++;
451     }
452    
453     free(kp_stats);
454     #endif
455    
456 pajs 1.23 *ps = proc_state;
457     return proc_state_size;
458 tdb 1.27 }
459    
460     process_stat_t *get_process_stats() {
461     static process_stat_t process_stat;
462     proc_state_t *ps;
463     int ps_size, x;
464    
465 tdb 1.30 process_stat.sleeping = 0;
466     process_stat.running = 0;
467     process_stat.zombie = 0;
468     process_stat.stopped = 0;
469     process_stat.total = 0;
470 tdb 1.27
471     ps_size = get_proc_snapshot(&ps);
472 tdb 1.32
473 tdb 1.46 if(ps_size < 0) {
474 tdb 1.32 return NULL;
475     }
476 tdb 1.27
477     for(x = 0; x < ps_size; x++) {
478     switch (ps->state) {
479     case RUNNING:
480     process_stat.running++;
481     break;
482     case SLEEPING:
483     process_stat.sleeping++;
484     break;
485     case STOPPED:
486     process_stat.stopped++;
487     break;
488     case ZOMBIE:
489     process_stat.zombie++;
490 ats 1.40 break;
491     default:
492     /* currently no mapping for UNKNOWN in process_stat_t */
493 tdb 1.27 break;
494     }
495     ps++;
496     }
497    
498     process_stat.total = ps_size;
499    
500     return &process_stat;
501 pajs 1.23 }