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.35 by tdb, Sun Apr 4 15:56:53 2004 UTC vs.
Revision 1.50 by tdb, Mon Apr 5 09:33:38 2004 UTC

# Line 26 | Line 26
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>
# Line 61 | Line 63
63   #include <paths.h>
64   #include <fcntl.h>
65   #include <limits.h>
66 + #if (defined(FREEBSD) && !defined(FREEBSD5)) || defined(DFBSD)
67   #include <kvm.h>
68 + #include <tools.h>
69   #endif
70 + #include <unistd.h>
71 + #endif
72  
73 + static void proc_state_init(proc_state_t *s) {
74 +        s->process_name = NULL;
75 +        s->proctitle = NULL;
76 + }
77 +
78 + static void proc_state_destroy(proc_state_t *s) {
79 +        free(s->process_name);
80 +        free(s->proctitle);
81 + }
82 +
83   int get_proc_snapshot(proc_state_t **ps){
84 <        proc_state_t *proc_state = NULL;
85 <        proc_state_t *proc_state_ptr;
84 >        VECTOR_DECLARE_STATIC(proc_state, proc_state_t, 64,
85 >                              proc_state_init, proc_state_destroy);
86          int proc_state_size = 0;
87 +        proc_state_t *proc_state_ptr;
88   #ifdef ALLBSD
89 <        int mib[3];
89 >        int mib[4];
90          size_t size;
91          struct kinfo_proc *kp_stats;
92 <        int procs, i, alloc;
76 <        static kvm_t *kvmd;
77 <        char **args;
92 >        int procs, i;
93          char *proctitle;
94 + #if (defined(FREEBSD) && !defined(FREEBSD5)) || defined(DFBSD)
95 +        kvm_t *kvmd;
96 +        char **args, **argsp;
97 +        int argslen = 0;
98 + #else
99 +        long buflen;
100 +        char *p;
101   #endif
102 + #endif
103   #if defined(SOLARIS) || defined(LINUX)
104          DIR *proc_dir;
105          struct dirent *dir_entry;
# Line 90 | Line 113 | int get_proc_snapshot(proc_state_t **ps){
113          /* If someone has a executable of 4k filename length, they deserve to get it truncated :) */
114          char ps_name[4096];
115          char *ptr;
116 <        static char *psargs = NULL;
94 <        static int psarg_size = 0;
116 >        VECTOR_DECLARE_STATIC(psargs, char, 128, NULL, NULL);
117          unsigned long stime, utime;
118          int x;
119          int fn;
120 <        int toread;
121 <        ssize_t size;
100 <        int t_read;
120 >        int len;
121 >        int rc;
122   #endif
123  
124          if((proc_dir=opendir(PROC_LOCATION))==NULL){
# Line 122 | Line 143 | int get_proc_snapshot(proc_state_t **ps){
143                  fread(&process_info, sizeof(psinfo_t), 1, f);
144   #endif
145  
146 <                proc_state = realloc(proc_state, (1+proc_state_size)*sizeof(proc_state_t));
146 >                if (VECTOR_RESIZE(proc_state, proc_state_size + 1) < 0) {
147 >                        return -1;
148 >                }
149                  proc_state_ptr = proc_state+proc_state_size;
150 +
151   #ifdef SOLARIS          
152                  proc_state_ptr->pid = process_info.pr_pid;
153                  proc_state_ptr->parent = process_info.pr_ppid;
# Line 146 | Line 170 | int get_proc_snapshot(proc_state_t **ps){
170                  if(process_info.pr_lwp.pr_state==6) proc_state_ptr->state = RUNNING;
171   #endif
172   #ifdef LINUX
173 <                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));
173 >                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));
174                  proc_state_ptr->proc_resident = proc_state_ptr->proc_resident * getpagesize();
175                  if(s == 'S') proc_state_ptr->state = SLEEPING;
176                  if(s == 'R') proc_state_ptr->state = RUNNING;
# Line 157 | Line 181 | int get_proc_snapshot(proc_state_t **ps){
181                  /* pa_name[0] should = '(' */
182                  ptr = strchr(&ps_name[1], ')');
183                  if(ptr !=NULL) *ptr='\0';
160 –                proc_state_ptr->process_name = strdup(&ps_name[1]);
184  
185 +                if (update_string(&proc_state_ptr->process_name,
186 +                                  &ps_name[1]) == NULL) {
187 +                        return -1;
188 +                }
189 +
190                  /* Need to do cpu */
191                  
192  
193 +                fclose(f);
194 +
195                  /* proctitle */
196                  snprintf(filename, MAX_FILE_LENGTH, "/proc/%s/cmdline", dir_entry->d_name);
197  
# Line 170 | Line 200 | int get_proc_snapshot(proc_state_t **ps){
200                           * Ah well, move onwards to the next one */
201                          continue;
202                  }
203 < #define         PSARG_START_SIZE 128
204 <                if(psargs == NULL){
205 <                        psargs = malloc(PSARG_START_SIZE);
206 <                        psarg_size = PSARG_START_SIZE;
203 >
204 > #define READ_BLOCK_SIZE 128
205 >                len = 0;
206 >                do {
207 >                        if (VECTOR_RESIZE(psargs, len + READ_BLOCK_SIZE + 1) < 0) {
208 >                                return -1;
209 >                        }
210 >                        rc = read(fn, psargs + len, READ_BLOCK_SIZE);
211 >                        if (rc > 0) {
212 >                                len += rc;
213 >                        }
214 >                } while (rc == READ_BLOCK_SIZE);
215 >                close(fn);
216 >
217 >                if (rc == -1) {
218 >                        /* Read failed; move on. */
219 >                        continue;
220                  }
178 –                ptr = psargs;  
179 –                t_read = 0;
180 –                toread = psarg_size;
181 –                while((size = read(fn, ptr, toread)) == toread){
182 –                        psargs = realloc(psargs, (psarg_size + PSARG_START_SIZE));
183 –                        ptr = psargs+psarg_size;
184 –                        t_read = psarg_size;
185 –                        psarg_size+=PSARG_START_SIZE;
186 –                        toread = PSARG_START_SIZE;
187 –                }
188 –                if(size != -1) t_read+=size;
221  
222 +                /* Turn \0s into spaces within the command line. */
223                  ptr = psargs;
224 <                for(x=0; x<t_read; x++){
224 >                for(x = 0; x < len; x++) {
225                          if (*ptr == '\0') *ptr = ' ';
226                          ptr++;
227                  }
228 <                /*  for safety sake */
229 <                psargs[t_read] = '\0';
228 >                /* for safety's sake */
229 >                psargs[len] = '\0';
230  
231 <                proc_state_ptr->proctitle = strdup(psargs);
232 <
231 >                if (update_string(&proc_state_ptr->proctitle, psargs) == NULL) {
232 >                        return -1;
233 >                }
234   #endif
235  
236                  proc_state_size++;
203 –
204 –                fclose(f);
237          }
238          closedir(proc_dir);
239   #endif
240  
241   #ifdef ALLBSD
242 +        mib[0] = CTL_KERN;
243 +        mib[1] = KERN_PROC;
244 +        mib[2] = KERN_PROC_ALL;
245  
246 < #if defined(NETBSD) || defined(OPENBSD)
247 <        kvmd = kvm_openfiles(NULL, NULL, NULL, O_RDONLY, NULL);
248 < #else
214 <        kvmd = kvm_openfiles(_PATH_DEVNULL, _PATH_DEVNULL, NULL, O_RDONLY, NULL);
215 < #endif
246 >        if(sysctl(mib, 3, NULL, &size, NULL, 0) < 0) {
247 >                return -1;
248 >        }
249  
250 <        if(kvmd == NULL) return NULL;
250 >        procs = size / sizeof(struct kinfo_proc);
251  
252 <        kp_stats = kvm_getprocs(kvmd, KERN_PROC_ALL, 0, &procs);
252 >        kp_stats = malloc(size);
253 >        if(kp_stats == NULL) {
254 >                return -1;
255 >        }
256  
257 <        if (kp_stats == NULL || procs < 0) {
258 <                return NULL;
257 >        if(sysctl(mib, 3, kp_stats, &size, NULL, 0) < 0) {
258 >                free(kp_stats);
259 >                return -1;
260          }
261  
262 + #if (defined(FREEBSD) && !defined(FREEBSD5)) || defined(DFBSD)
263 +        kvmd = get_kvm2();
264 + #endif
265 +
266          for (i = 0; i < procs; i++) {
267 <                /* replace with something more sensible */
268 <                proc_state = realloc(proc_state,
269 <                                (1+proc_state_size)*sizeof(proc_state_t));
270 <                if(proc_state == NULL ) {
230 <                        return NULL;
267 >                const char *name;
268 >
269 >                if (VECTOR_RESIZE(proc_state, proc_state_size + 1) < 0) {
270 >                        return -1;
271                  }
272                  proc_state_ptr = proc_state+proc_state_size;
273  
274   #ifdef FREEBSD5
275 <                proc_state_ptr->process_name =
236 <                        strdup(kp_stats[i].ki_comm);
275 >                name = kp_stats[i].ki_comm;
276   #elif defined(DFBSD)
277 <                proc_state_ptr->process_name =
239 <                        strdup(kp_stats[i].kp_thread.td_comm);
277 >                name = kp_stats[i].kp_thread.td_comm;
278   #else
279 <                proc_state_ptr->process_name =
242 <                        strdup(kp_stats[i].kp_proc.p_comm);
279 >                name = kp_stats[i].kp_proc.p_comm;
280   #endif
281 +                if (update_string(&proc_state_ptr->process_name, name) == NULL) {
282 +                        return -1;
283 +                }
284  
285 <                args = kvm_getargv(kvmd, &(kp_stats[i]), 0);
286 <                if(args != NULL) {
287 <                        alloc = 1;
288 <                        proctitle = malloc(alloc);
289 <                        if(proctitle == NULL) {
290 <                                return NULL;
285 > #if defined(FREEBSD5) || defined(NETBSD) || defined(OPENBSD)
286 >                size = sizeof(buflen);
287 >
288 > #ifdef FREEBSD5
289 >                if(sysctlbyname("kern.ps_arg_cache_limit", &buflen, &size, NULL, 0) < 0) {
290 >                        return -1;
291 >                }
292 > #else
293 >                mib[1] = KERN_ARGMAX;
294 >
295 >                if(sysctl(mib, 2, &buflen, &size, NULL, 0) < 0) {
296 >                        return -1;
297 >                }
298 > #endif
299 >
300 >                proctitle = malloc(buflen);
301 >                if(proctitle == NULL) {
302 >                        return -1;
303 >                }
304 >
305 >                size = buflen;
306 >
307 > #ifdef FREEBSD5
308 >                mib[2] = KERN_PROC_ARGS;
309 >                mib[3] = kp_stats[i].ki_pid;
310 > #else
311 >                mib[1] = KERN_PROC_ARGS;
312 >                mib[2] = kp_stats[i].kp_proc.p_pid;
313 >                mib[3] = KERN_PROC_ARGV;
314 > #endif
315 >
316 >                free(proc_state_ptr->proctitle);
317 >                if(sysctl(mib, 4, proctitle, &size, NULL, 0) < 0) {
318 >                        free(proctitle);
319 >                        proc_state_ptr->proctitle = NULL;
320 >                }
321 >                else if(size > 0) {
322 >                        proc_state_ptr->proctitle = malloc(size+1);
323 >                        if(proc_state_ptr->proctitle == NULL) {
324 >                                return -1;
325                          }
326 <                        while(*args != NULL) {
327 <                                if(strlen(proctitle) + strlen(*args) >= alloc) {
328 <                                        alloc = (alloc + strlen(*args)) << 1;
329 <                                        proctitle = realloc(proctitle, alloc);
330 <                                        if(proctitle == NULL) {
331 <                                                return NULL;
332 <                                        }
333 <                                }
260 <                                strncat(proctitle, *args, strlen(*args));
261 <                                strncat(proctitle, " ", 1);
262 <                                args++;
263 <                        }
326 >                        p = proctitle;
327 >                        proc_state_ptr->proctitle[0] = '\0';
328 >                        do {
329 >                                strlcat(proc_state_ptr->proctitle, p, size+1);
330 >                                strlcat(proc_state_ptr->proctitle, " ", size+1);
331 >                                p += strlen(p) + 1;
332 >                        } while (p < proctitle + size);
333 >                        free(proctitle);
334                          /* remove trailing space */
335 <                        proctitle[strlen(proctitle)-1] = NULL;
266 <                        proc_state_ptr->proctitle = proctitle;
335 >                        proc_state_ptr->proctitle[strlen(proc_state_ptr->proctitle)-1] = '\0';
336                  }
337                  else {
338 <                        proc_state_ptr->proctitle =
339 <                                malloc(strlen(proc_state_ptr->process_name)+4);
340 <                        if(proc_state_ptr->proctitle == NULL) {
341 <                                return NULL;
338 >                        free(proctitle);
339 >                        proc_state_ptr->proctitle = NULL;
340 >                }
341 > #else
342 >                free(proc_state_ptr->proctitle);
343 >                if(kvmd != NULL) {
344 >                        args = kvm_getargv(kvmd, &(kp_stats[i]), 0);
345 >                        if(args != NULL) {
346 >                                argsp = args;
347 >                                while(*argsp != NULL) {
348 >                                        argslen += strlen(*args);
349 >                                        args++;
350 >                                }
351 >                                proctitle = malloc(argslen + 1);
352 >                                proctitle[0] = '\0';
353 >                                if(proctitle == NULL) {
354 >                                        return -1;
355 >                                }
356 >                                while(*args != NULL) {
357 >                                        strlcat(proctitle, *args, argslen);
358 >                                        strlcat(proctitle, " ", argslen);
359 >                                        args++;
360 >                                }
361 >                                /* remove trailing space */
362 >                                proctitle[strlen(proctitle)-1] = '\0';
363 >                                proc_state_ptr->proctitle = proctitle;
364                          }
365 <                        sprintf(proc_state_ptr->proctitle, " (%s)",
366 <                                proc_state_ptr->process_name);
365 >                        else {
366 >                                proc_state_ptr->proctitle = NULL;
367 >                        }
368                  }
369 +                else {
370 +                        proc_state_ptr->proctitle = NULL;
371 +                }
372 + #endif
373  
374   #ifdef FREEBSD5
375                  proc_state_ptr->pid = kp_stats[i].ki_pid;
# Line 318 | Line 414 | int get_proc_snapshot(proc_state_t **ps){
414                  /* This is in pages */
415                  proc_state_ptr->proc_resident =
416                          kp_stats[i].kp_eproc.e_vm.vm_rssize * getpagesize();
321 –                /* This is in microseconds */
417   #if defined(NETBSD) || defined(OPENBSD)
418                  proc_state_ptr->time_spent =
419                          kp_stats[i].kp_proc.p_rtime.tv_sec;
# Line 328 | Line 423 | int get_proc_snapshot(proc_state_t **ps){
423                          kp_stats[i].kp_thread.td_sticks +
424                          kp_stats[i].kp_thread.td_iticks ) / 1000000;
425   #else
426 +                /* This is in microseconds */
427                  proc_state_ptr->time_spent =
428                          kp_stats[i].kp_proc.p_runtime / 1000000;
429   #endif
# Line 376 | Line 472 | int get_proc_snapshot(proc_state_t **ps){
472          free(kp_stats);
473   #endif
474  
475 + #ifdef CYGWIN
476 +        return -1;
477 + #endif
478 +
479          *ps = proc_state;
480          return proc_state_size;
481   }
# Line 393 | Line 493 | process_stat_t *get_process_stats() {
493  
494          ps_size = get_proc_snapshot(&ps);
495  
496 <        if(ps_size == NULL) {
496 >        if(ps_size < 0) {
497                  return NULL;
498          }
499  
500          for(x = 0; x < ps_size; x++) {
501                  switch (ps->state) {
402 –                /* currently no mapping for UNKNOWN in process_stat_t */
502                  case RUNNING:
503                          process_stat.running++;
504                          break;
# Line 411 | Line 510 | process_stat_t *get_process_stats() {
510                          break;
511                  case ZOMBIE:
512                          process_stat.zombie++;
513 +                        break;
514 +                default:
515 +                        /* currently no mapping for UNKNOWN in process_stat_t */
516                          break;
517                  }
518                  ps++;

Diff Legend

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