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.64 by pajs, Wed Apr 7 15:46:34 2004 UTC vs.
Revision 1.72 by ats, Thu Apr 8 23:30:29 2004 UTC

# Line 51 | Line 51
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>
# Line 99 | Line 100 | sg_process_stats *sg_get_process_stats(int *entries){
100          int argslen = 0;
101   #else
102          long buflen;
103 <        char *p;
103 >        char *p, *proctitletmp;
104   #endif
105   #ifdef NETBSD2
106          int lwps;
# Line 130 | Line 131 | sg_process_stats *sg_get_process_stats(int *entries){
131  
132   #ifdef LINUX
133          if ((f=fopen("/proc/uptime", "r")) == NULL) {
134 +                sg_set_error(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(SG_ERROR_OPENDIR, PROC_LOCATION);
146                  return NULL;
147          }
148  
# Line 303 | Line 307 | sg_process_stats *sg_get_process_stats(int *entries){
307          mib[2] = KERN_PROC_ALL;
308  
309          if(sysctl(mib, 3, NULL, &size, NULL, 0) < 0) {
310 +                sg_set_error(SG_ERROR_SYSCTL, "CTL_KERN.KERN_PROC.KERN_PROC_ALL");
311                  return NULL;
312          }
313  
# Line 315 | Line 320 | sg_process_stats *sg_get_process_stats(int *entries){
320          memset(kp_stats, 0, size);
321  
322          if(sysctl(mib, 3, kp_stats, &size, NULL, 0) < 0) {
323 +                sg_set_error(SG_ERROR_SYSCTL, "CTL_KERN.KERN_PROC.KERN_PROC_ALL");
324                  free(kp_stats);
325                  return NULL;
326          }
# Line 356 | Line 362 | sg_process_stats *sg_get_process_stats(int *entries){
362                  }
363  
364   #if defined(FREEBSD5) || defined(NETBSD) || defined(OPENBSD)
359 –                size = sizeof(buflen);
365  
366   #ifdef FREEBSD5
362 –                if(sysctlbyname("kern.ps_arg_cache_limit", &buflen, &size, NULL, 0) < 0) {
363 –                        return NULL;
364 –                }
365 – #else
366 –                /* FIXME - this value can be too large on some of
367 –                   the BSD's, which causes sysctl not to return
368 –                   anything. Maybe we need something smaller? */
369 –                mib[1] = KERN_ARGMAX;
370 –
371 –                if(sysctl(mib, 2, &buflen, &size, NULL, 0) < 0) {
372 –                        return NULL;
373 –                }
374 – #endif
375 –
376 –                proctitle = sg_malloc(buflen);
377 –                if(proctitle == NULL) {
378 –                        return NULL;
379 –                }
380 –
381 –                size = buflen;
382 –
383 – #ifdef FREEBSD5
367                  mib[2] = KERN_PROC_ARGS;
368                  mib[3] = kp_stats[i].ki_pid;
369   #else
# Line 390 | Line 373 | sg_process_stats *sg_get_process_stats(int *entries){
373   #endif
374  
375                  free(proc_state_ptr->proctitle);
376 <                if(sysctl(mib, 4, proctitle, &size, NULL, 0) < 0) {
377 <                        free(proctitle);
378 <                        proc_state_ptr->proctitle = NULL;
379 <                }
380 <                else if(size > 0) {
376 >                proc_state_ptr->proctitle = NULL;
377 >
378 > /* Starting size - we'll double this straight away */
379 > #define PROCTITLE_START_SIZE 64
380 >                buflen = PROCTITLE_START_SIZE;
381 >                size = buflen;
382 >                proctitle = NULL;
383 >
384 >                do {
385 >                        if(size >= buflen) {
386 >                                buflen *= 2;
387 >                                size = buflen;
388 >                                proctitletmp = sg_realloc(proctitle, buflen);
389 >                                if(proctitletmp == NULL) {
390 >                                        free(proctitle);
391 >                                        proctitle = NULL;
392 >                                        proc_state_ptr->proctitle = NULL;
393 >                                        size = 0;
394 >                                        break;
395 >                                }
396 >                                proctitle = proctitletmp;
397 >                                bzero(proctitle, buflen);
398 >                        }
399 >
400 >                        if(sysctl(mib, 4, proctitle, &size, NULL, 0) < 0) {
401 >                                free(proctitle);
402 >                                proctitle = NULL;
403 >                                proc_state_ptr->proctitle = NULL;
404 >                                size = 0;
405 >                                break;
406 >                        }
407 >                } while(size >= buflen);
408 >
409 >                if(size > 0) {
410                          proc_state_ptr->proctitle = sg_malloc(size+1);
411                          if(proc_state_ptr->proctitle == NULL) {
412                                  return NULL;
413                          }
414                          p = proctitle;
415 + #ifdef OPENBSD
416 +                        /* On OpenBSD, this value has the argv pointers (which
417 +                         * are terminated by a NULL) at the front, so we have
418 +                         * to skip over them to get to the strings. */
419 +                        while (*(char ***)p != NULL) {
420 +                                p += sizeof(char **);
421 +                        }
422 +                        p += sizeof(char **);
423 + #endif
424                          proc_state_ptr->proctitle[0] = '\0';
425                          do {
426                                  sg_strlcat(proc_state_ptr->proctitle, p, size+1);
# Line 407 | Line 428 | sg_process_stats *sg_get_process_stats(int *entries){
428                                  p += strlen(p) + 1;
429                          } while (p < proctitle + size);
430                          free(proctitle);
431 +                        proctitle = NULL;
432                          /* remove trailing space */
433                          proc_state_ptr->proctitle[strlen(proc_state_ptr->proctitle)-1] = '\0';
434                  }
435                  else {
436 <                        free(proctitle);
436 >                        if(proctitle != NULL) {
437 >                                free(proctitle);
438 >                                proctitle = NULL;
439 >                        }
440                          proc_state_ptr->proctitle = NULL;
441                  }
442   #else
443                  free(proc_state_ptr->proctitle);
444 +                proc_state_ptr->proctitle = NULL;
445                  if(kvmd != NULL) {
446                          args = kvm_getargv(kvmd, &(kp_stats[i]), 0);
447                          if(args != NULL) {
# Line 520 | Line 546 | sg_process_stats *sg_get_process_stats(int *entries){
546                          mib[4] = 0;
547  
548                          if(sysctl(mib, 5, NULL, &size, NULL, 0) < 0) {
549 +                                sg_set_error(SG_ERROR_SYSCTL, "CTL_KERN.KERN_LWP.pid.structsize.0");
550                                  return NULL;
551                          }
552  
# Line 532 | Line 559 | sg_process_stats *sg_get_process_stats(int *entries){
559                          }
560  
561                          if(sysctl(mib, 5, kl_stats, &size, NULL, 0) < 0) {
562 +                                sg_set_error(SG_ERROR_SYSCTL, "CTL_KERN.KERN_LWP.pid.structsize.buffersize");
563                                  return NULL;
564                          }
565                  }
# Line 616 | Line 644 | sg_process_stats *sg_get_process_stats(int *entries){
644   #endif
645  
646   #ifdef CYGWIN
647 +        sg_set_error(SG_ERROR_UNSUPPORTED, "Cygwin");
648          return NULL;
649   #endif
650  
# Line 665 | Line 694 | sg_process_count *sg_get_process_count() {
694  
695          return &process_stat;
696   }
697 +
698 + int sg_process_compare_name(const void *va, const void *vb) {
699 +        const sg_process_stats *a = (sg_process_stats *)va;
700 +        const sg_process_stats *b = (sg_process_stats *)vb;
701 +
702 +        return strcmp(a->process_name, b->process_name);
703 + }
704 +
705 + int sg_process_compare_pid(const void *va, const void *vb) {
706 +        const sg_process_stats *a = (sg_process_stats *)va;
707 +        const sg_process_stats *b = (sg_process_stats *)vb;
708 +
709 +        if (a->pid < b->pid) {
710 +                return -1;
711 +        } else if (a->pid == b->pid) {
712 +                return 0;
713 +        } else {
714 +                return 1;
715 +        }
716 + }
717 +
718 + int sg_process_compare_uid(const void *va, const void *vb) {
719 +        const sg_process_stats *a = (sg_process_stats *)va;
720 +        const sg_process_stats *b = (sg_process_stats *)vb;
721 +
722 +        if (a->uid < b->uid) {
723 +                return -1;
724 +        } else if (a->uid == b->uid) {
725 +                return 0;
726 +        } else {
727 +                return 1;
728 +        }
729 + }
730 +
731 + int sg_process_compare_gid(const void *va, const void *vb) {
732 +        const sg_process_stats *a = (sg_process_stats *)va;
733 +        const sg_process_stats *b = (sg_process_stats *)vb;
734 +
735 +        if (a->gid < b->gid) {
736 +                return -1;
737 +        } else if (a->gid == b->gid) {
738 +                return 0;
739 +        } else {
740 +                return 1;
741 +        }
742 + }
743 +
744 + int sg_process_compare_size(const void *va, const void *vb) {
745 +        const sg_process_stats *a = (sg_process_stats *)va;
746 +        const sg_process_stats *b = (sg_process_stats *)vb;
747 +
748 +        if (a->proc_size < b->proc_size) {
749 +                return -1;
750 +        } else if (a->proc_size == b->proc_size) {
751 +                return 0;
752 +        } else {
753 +                return 1;
754 +        }
755 + }
756 +
757 + int sg_process_compare_res(const void *va, const void *vb) {
758 +        const sg_process_stats *a = (sg_process_stats *)va;
759 +        const sg_process_stats *b = (sg_process_stats *)vb;
760 +
761 +        if (a->proc_resident < b->proc_resident) {
762 +                return -1;
763 +        } else if (a->proc_resident == b->proc_resident) {
764 +                return 0;
765 +        } else {
766 +                return 1;
767 +        }
768 + }
769 +
770 + int sg_process_compare_cpu(const void *va, const void *vb) {
771 +        const sg_process_stats *a = (sg_process_stats *)va;
772 +        const sg_process_stats *b = (sg_process_stats *)vb;
773 +
774 +        if (a->cpu_percent < b->cpu_percent) {
775 +                return -1;
776 +        } else if (a->cpu_percent == b->cpu_percent) {
777 +                return 0;
778 +        } else {
779 +                return 1;
780 +        }
781 + }
782 +
783 + int sg_process_compare_time(const void *va, const void *vb) {
784 +        const sg_process_stats *a = (sg_process_stats *)va;
785 +        const sg_process_stats *b = (sg_process_stats *)vb;
786 +
787 +        if (a->time_spent < b->time_spent) {
788 +                return -1;
789 +        } else if (a->time_spent == b->time_spent) {
790 +                return 0;
791 +        } else {
792 +                return 1;
793 +        }
794 + }
795 +

Diff Legend

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