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.66 by pajs, Thu Apr 8 11:26:42 2004 UTC vs.
Revision 1.77 by ats, Sat Nov 6 15:10:07 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 71 | Line 72
72   #include <sys/lwp.h>
73   #endif
74   #endif
75 + #ifdef HPUX
76 + #include <sys/param.h>
77 + #include <sys/pstat.h>
78 + #include <unistd.h>
79 + #define PROCESS_BATCH 30
80 + #endif
81  
82   static void proc_state_init(sg_process_stats *s) {
83          s->process_name = NULL;
# Line 87 | Line 94 | sg_process_stats *sg_get_process_stats(int *entries){
94                                proc_state_init, proc_state_destroy);
95          int proc_state_size = 0;
96          sg_process_stats *proc_state_ptr;
97 + #ifdef HPUX
98 +        struct pst_status pstat_procinfo[PROCESS_BATCH];
99 +        long procidx = 0;
100 +        long long pagesize;
101 +        int num, i;
102 + #endif
103   #ifdef ALLBSD
104          int mib[4];
105          size_t size;
# Line 99 | Line 112 | sg_process_stats *sg_get_process_stats(int *entries){
112          int argslen = 0;
113   #else
114          long buflen;
115 <        char *p;
115 >        char *p, *proctitletmp;
116   #endif
117   #ifdef NETBSD2
118          int lwps;
# Line 130 | Line 143 | sg_process_stats *sg_get_process_stats(int *entries){
143  
144   #ifdef LINUX
145          if ((f=fopen("/proc/uptime", "r")) == NULL) {
146 <                sg_set_error(SG_ERROR_OPEN, "/proc/uptime");
146 >                sg_set_error_with_errno(SG_ERROR_OPEN, "/proc/uptime");
147                  return NULL;
148          }
149          if((fscanf(f,"%lu %*d",&uptime)) != 1){
# Line 141 | Line 154 | sg_process_stats *sg_get_process_stats(int *entries){
154   #endif
155  
156          if((proc_dir=opendir(PROC_LOCATION))==NULL){
157 <                sg_set_error(SG_ERROR_OPENDIR, PROC_LOCATION);
157 >                sg_set_error_with_errno(SG_ERROR_OPENDIR, PROC_LOCATION);
158                  return NULL;
159          }
160  
# Line 191 | Line 204 | sg_process_stats *sg_get_process_stats(int *entries){
204                          return NULL;
205                  }
206  
207 <                if(process_info.pr_lwp.pr_state==1) proc_state_ptr->state = SG_PROCESS_STATE_SLEEPING;
208 <                if(process_info.pr_lwp.pr_state==2) proc_state_ptr->state = SG_PROCESS_STATE_RUNNING;
209 <                if(process_info.pr_lwp.pr_state==3) proc_state_ptr->state = SG_PROCESS_STATE_ZOMBIE;
210 <                if(process_info.pr_lwp.pr_state==4) proc_state_ptr->state = SG_PROCESS_STATE_STOPPED;
211 <                if(process_info.pr_lwp.pr_state==6) proc_state_ptr->state = SG_PROCESS_STATE_RUNNING;
207 >                switch (process_info.pr_lwp.pr_state) {
208 >                case 1:
209 >                        proc_state_ptr->state = SG_PROCESS_STATE_SLEEPING;
210 >                        break;
211 >                case 2:
212 >                case 5:
213 >                        proc_state_ptr->state = SG_PROCESS_STATE_RUNNING;
214 >                        break;
215 >                case 3:
216 >                        proc_state_ptr->state = SG_PROCESS_STATE_ZOMBIE;
217 >                        break;
218 >                case 4:
219 >                        proc_state_ptr->state = SG_PROCESS_STATE_STOPPED;
220 >                        break;
221 >                }
222   #endif
223   #ifdef LINUX
224                  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));
225                  /* +3 becuase man page says "Resident  Set Size: number of pages the process has in real memory, minus 3 for administrative purposes." */
226                  proc_state_ptr->proc_resident = (proc_state_ptr->proc_resident + 3) * getpagesize();
227 <                if(s == 'S') proc_state_ptr->state = SG_PROCESS_STATE_SLEEPING;
228 <                if(s == 'R') proc_state_ptr->state = SG_PROCESS_STATE_RUNNING;
229 <                if(s == 'Z') proc_state_ptr->state = SG_PROCESS_STATE_ZOMBIE;
230 <                if(s == 'T') proc_state_ptr->state = SG_PROCESS_STATE_STOPPED;
231 <                if(s == 'D') proc_state_ptr->state = SG_PROCESS_STATE_STOPPED;
227 >                switch (s) {
228 >                case 'S':
229 >                        proc_state_ptr->state = SG_PROCESS_STATE_SLEEPING;
230 >                        break;
231 >                case 'R':
232 >                        proc_state_ptr->state = SG_PROCESS_STATE_RUNNING;
233 >                        break;
234 >                case 'Z':
235 >                        proc_state_ptr->state = SG_PROCESS_STATE_ZOMBIE;
236 >                        break;
237 >                case 'T':
238 >                case 'D':
239 >                        proc_state_ptr->state = SG_PROCESS_STATE_STOPPED;
240 >                        break;
241 >                }
242          
243                  /* pa_name[0] should = '(' */
244                  ptr = strchr(&ps_name[1], ')');
# Line 306 | Line 339 | sg_process_stats *sg_get_process_stats(int *entries){
339          mib[2] = KERN_PROC_ALL;
340  
341          if(sysctl(mib, 3, NULL, &size, NULL, 0) < 0) {
342 <                sg_set_error(SG_ERROR_SYSCTL, "CTL_KERN.KERN_PROC.KERN_PROC_ALL");
342 >                sg_set_error_with_errno(SG_ERROR_SYSCTL,
343 >                                        "CTL_KERN.KERN_PROC.KERN_PROC_ALL");
344                  return NULL;
345          }
346  
# Line 319 | Line 353 | sg_process_stats *sg_get_process_stats(int *entries){
353          memset(kp_stats, 0, size);
354  
355          if(sysctl(mib, 3, kp_stats, &size, NULL, 0) < 0) {
356 <                sg_set_error(SG_ERROR_SYSCTL, "CTL_KERN.KERN_PROC.KERN_PROC_ALL");
356 >                sg_set_error_with_errno(SG_ERROR_SYSCTL,
357 >                                        "CTL_KERN.KERN_PROC.KERN_PROC_ALL");
358                  free(kp_stats);
359                  return NULL;
360          }
# Line 361 | Line 396 | sg_process_stats *sg_get_process_stats(int *entries){
396                  }
397  
398   #if defined(FREEBSD5) || defined(NETBSD) || defined(OPENBSD)
364 –                size = sizeof(buflen);
399  
400   #ifdef FREEBSD5
367 –                if(sysctlbyname("kern.ps_arg_cache_limit", &buflen, &size, NULL, 0) < 0) {
368 –                        sg_set_error(SG_ERROR_SYSCTLBYNAME, "kern.ps_arg_cache_limit");
369 –                        return NULL;
370 –                }
371 – #else
372 –                /* FIXME - this value can be too large on some of
373 –                   the BSD's, which causes sysctl not to return
374 –                   anything. Maybe we need something smaller? */
375 –                mib[1] = KERN_ARGMAX;
376 –
377 –                if(sysctl(mib, 2, &buflen, &size, NULL, 0) < 0) {
378 –                        sg_set_error(SG_ERROR_SYSCTL, "CTL_KERN.KERN_ARGMAX");
379 –                        return NULL;
380 –                }
381 – #endif
382 –
383 –                proctitle = sg_malloc(buflen);
384 –                if(proctitle == NULL) {
385 –                        return NULL;
386 –                }
387 –
388 –                size = buflen;
389 –
390 – #ifdef FREEBSD5
401                  mib[2] = KERN_PROC_ARGS;
402                  mib[3] = kp_stats[i].ki_pid;
403   #else
# Line 397 | Line 407 | sg_process_stats *sg_get_process_stats(int *entries){
407   #endif
408  
409                  free(proc_state_ptr->proctitle);
410 <                if(sysctl(mib, 4, proctitle, &size, NULL, 0) < 0) {
411 <                        free(proctitle);
412 <                        proc_state_ptr->proctitle = NULL;
413 <                }
414 <                else if(size > 0) {
410 >                proc_state_ptr->proctitle = NULL;
411 >
412 > /* Starting size - we'll double this straight away */
413 > #define PROCTITLE_START_SIZE 64
414 >                buflen = PROCTITLE_START_SIZE;
415 >                size = buflen;
416 >                proctitle = NULL;
417 >
418 >                do {
419 >                        if(size >= buflen) {
420 >                                buflen *= 2;
421 >                                size = buflen;
422 >                                proctitletmp = sg_realloc(proctitle, buflen);
423 >                                if(proctitletmp == NULL) {
424 >                                        free(proctitle);
425 >                                        proctitle = NULL;
426 >                                        proc_state_ptr->proctitle = NULL;
427 >                                        size = 0;
428 >                                        break;
429 >                                }
430 >                                proctitle = proctitletmp;
431 >                                bzero(proctitle, buflen);
432 >                        }
433 >
434 >                        if(sysctl(mib, 4, proctitle, &size, NULL, 0) < 0) {
435 >                                free(proctitle);
436 >                                proctitle = NULL;
437 >                                proc_state_ptr->proctitle = NULL;
438 >                                size = 0;
439 >                                break;
440 >                        }
441 >                } while(size >= buflen);
442 >
443 >                if(size > 0) {
444                          proc_state_ptr->proctitle = sg_malloc(size+1);
445                          if(proc_state_ptr->proctitle == NULL) {
446                                  return NULL;
447                          }
448                          p = proctitle;
449 + #ifdef OPENBSD
450 +                        /* On OpenBSD, this value has the argv pointers (which
451 +                         * are terminated by a NULL) at the front, so we have
452 +                         * to skip over them to get to the strings. */
453 +                        while (*(char ***)p != NULL) {
454 +                                p += sizeof(char **);
455 +                        }
456 +                        p += sizeof(char **);
457 + #endif
458                          proc_state_ptr->proctitle[0] = '\0';
459                          do {
460                                  sg_strlcat(proc_state_ptr->proctitle, p, size+1);
# Line 414 | Line 462 | sg_process_stats *sg_get_process_stats(int *entries){
462                                  p += strlen(p) + 1;
463                          } while (p < proctitle + size);
464                          free(proctitle);
465 +                        proctitle = NULL;
466                          /* remove trailing space */
467                          proc_state_ptr->proctitle[strlen(proc_state_ptr->proctitle)-1] = '\0';
468                  }
469                  else {
470 <                        free(proctitle);
470 >                        if(proctitle != NULL) {
471 >                                free(proctitle);
472 >                                proctitle = NULL;
473 >                        }
474                          proc_state_ptr->proctitle = NULL;
475                  }
476   #else
477                  free(proc_state_ptr->proctitle);
478 +                proc_state_ptr->proctitle = NULL;
479                  if(kvmd != NULL) {
480                          args = kvm_getargv(kvmd, &(kp_stats[i]), 0);
481                          if(args != NULL) {
# Line 527 | Line 580 | sg_process_stats *sg_get_process_stats(int *entries){
580                          mib[4] = 0;
581  
582                          if(sysctl(mib, 5, NULL, &size, NULL, 0) < 0) {
583 <                                sg_set_error(SG_ERROR_SYSCTL, "CTL_KERN.KERN_LWP.pid.structsize.0");
583 >                                sg_set_error_with_errno(SG_ERROR_SYSCTL, "CTL_KERN.KERN_LWP.pid.structsize.0");
584                                  return NULL;
585                          }
586  
# Line 540 | Line 593 | sg_process_stats *sg_get_process_stats(int *entries){
593                          }
594  
595                          if(sysctl(mib, 5, kl_stats, &size, NULL, 0) < 0) {
596 <                                sg_set_error(SG_ERROR_SYSCTL, "CTL_KERN.KERN_LWP.pid.structsize.buffersize");
596 >                                sg_set_error_with_errno(SG_ERROR_SYSCTL, "CTL_KERN.KERN_LWP.pid.structsize.buffersize");
597                                  return NULL;
598                          }
599                  }
# Line 582 | Line 635 | sg_process_stats *sg_get_process_stats(int *entries){
635                          proc_state_ptr->state = SG_PROCESS_STATE_UNKNOWN;
636                          break;
637                  }
638 +
639 +                free(kl_stats);
640   #else
641   #ifdef FREEBSD5
642                  switch (kp_stats[i].ki_stat) {
# Line 624 | Line 679 | sg_process_stats *sg_get_process_stats(int *entries){
679          free(kp_stats);
680   #endif
681  
682 + #ifdef HPUX
683 +        if ((pagesize = sysconf(_SC_PAGESIZE)) == -1) {
684 +                sg_set_error_with_errno(SG_ERROR_SYSCONF, "_SC_PAGESIZE");
685 +                return NULL;
686 +        }
687 +
688 +        do {
689 +                num = pstat_getproc(pstat_procinfo, sizeof pstat_procinfo[0],
690 +                                    PROCESS_BATCH, procidx);
691 +
692 +                for (i = 0; i < num; i++) {
693 +                        struct pst_status *pi = &pstat_procinfo[i];
694 +
695 +                        if (VECTOR_RESIZE(proc_state, proc_state_size + 1) < 0) {
696 +                                return NULL;
697 +                        }
698 +                        proc_state_ptr = proc_state+proc_state_size;
699 +        
700 +                        proc_state_ptr->pid = pi->pst_pid;
701 +                        proc_state_ptr->parent = pi->pst_ppid;
702 +                        proc_state_ptr->pgid = pi->pst_pgrp;
703 +                        proc_state_ptr->uid = pi->pst_uid;
704 +                        proc_state_ptr->euid = pi->pst_euid;
705 +                        proc_state_ptr->gid = pi->pst_gid;
706 +                        proc_state_ptr->egid = pi->pst_egid;
707 +                        proc_state_ptr->proc_size = (pi->pst_dsize + pi->pst_tsize + pi->pst_ssize) * pagesize;
708 +                        proc_state_ptr->proc_resident = pi->pst_rssize * pagesize;
709 +                        proc_state_ptr->time_spent = pi->pst_time;
710 +                        proc_state_ptr->cpu_percent = (pi->pst_pctcpu * 100.0) / 0x8000;
711 +                        proc_state_ptr->nice = pi->pst_nice;
712 +        
713 +                        if (sg_update_string(&proc_state_ptr->process_name,
714 +                                             pi->pst_ucomm) < 0) {
715 +                                return NULL;
716 +                        }
717 +                        if (sg_update_string(&proc_state_ptr->proctitle,
718 +                                             pi->pst_cmd) < 0) {
719 +                                return NULL;
720 +                        }
721 +        
722 +                        switch (pi->pst_stat) {
723 +                        case PS_SLEEP:
724 +                                proc_state_ptr->state = SG_PROCESS_STATE_SLEEPING;
725 +                                break;
726 +                        case PS_RUN:
727 +                                proc_state_ptr->state = SG_PROCESS_STATE_RUNNING;
728 +                                break;
729 +                        case PS_STOP:
730 +                                proc_state_ptr->state = SG_PROCESS_STATE_STOPPED;
731 +                                break;
732 +                        case PS_ZOMBIE:
733 +                                proc_state_ptr->state = SG_PROCESS_STATE_ZOMBIE;
734 +                                break;
735 +                        case PS_IDLE:
736 +                        case PS_OTHER:
737 +                                proc_state_ptr->state = SG_PROCESS_STATE_UNKNOWN;
738 +                                break;
739 +                        }
740 +        
741 +                        proc_state_size++;
742 +                }
743 +                procidx = pstat_procinfo[n - 1].pst_idx + 1;
744 +        } while (num > 0);
745 + #endif
746 +
747   #ifdef CYGWIN
748          sg_set_error(SG_ERROR_UNSUPPORTED, "Cygwin");
749          return NULL;
# Line 676 | Line 796 | sg_process_count *sg_get_process_count() {
796          return &process_stat;
797   }
798  
799 < int sg_compare_pid(const void *va, const void *vb) {
799 > int sg_process_compare_name(const void *va, const void *vb) {
800          const sg_process_stats *a = (sg_process_stats *)va;
801          const sg_process_stats *b = (sg_process_stats *)vb;
802  
803 +        return strcmp(a->process_name, b->process_name);
804 + }
805 +
806 + int sg_process_compare_pid(const void *va, const void *vb) {
807 +        const sg_process_stats *a = (sg_process_stats *)va;
808 +        const sg_process_stats *b = (sg_process_stats *)vb;
809 +
810          if (a->pid < b->pid) {
811                  return -1;
812          } else if (a->pid == b->pid) {
# Line 689 | Line 816 | int sg_compare_pid(const void *va, const void *vb) {
816          }
817   }
818  
819 < int sg_compare_uid(const void *va, const void *vb) {
819 > int sg_process_compare_uid(const void *va, const void *vb) {
820          const sg_process_stats *a = (sg_process_stats *)va;
821          const sg_process_stats *b = (sg_process_stats *)vb;
822  
# Line 702 | Line 829 | int sg_compare_uid(const void *va, const void *vb) {
829          }
830   }
831  
832 < int sg_compare_gid(const void *va, const void *vb) {
832 > int sg_process_compare_gid(const void *va, const void *vb) {
833          const sg_process_stats *a = (sg_process_stats *)va;
834          const sg_process_stats *b = (sg_process_stats *)vb;
835  
# Line 715 | Line 842 | int sg_compare_gid(const void *va, const void *vb) {
842          }
843   }
844  
845 < int sg_compare_size(const void *va, const void *vb) {
845 > int sg_process_compare_size(const void *va, const void *vb) {
846          const sg_process_stats *a = (sg_process_stats *)va;
847          const sg_process_stats *b = (sg_process_stats *)vb;
848  
# Line 728 | Line 855 | int sg_compare_size(const void *va, const void *vb) {
855          }
856   }
857  
858 < int sg_compare_res(const void *va, const void *vb) {
858 > int sg_process_compare_res(const void *va, const void *vb) {
859          const sg_process_stats *a = (sg_process_stats *)va;
860          const sg_process_stats *b = (sg_process_stats *)vb;
861  
# Line 741 | Line 868 | int sg_compare_res(const void *va, const void *vb) {
868          }
869   }
870  
871 < int sg_compare_cpu(const void *va, const void *vb) {
871 > int sg_process_compare_cpu(const void *va, const void *vb) {
872          const sg_process_stats *a = (sg_process_stats *)va;
873          const sg_process_stats *b = (sg_process_stats *)vb;
874  
# Line 754 | Line 881 | int sg_compare_cpu(const void *va, const void *vb) {
881          }
882   }
883  
884 < int sg_compare_time(const void *va, const void *vb) {
884 > int sg_process_compare_time(const void *va, const void *vb) {
885          const sg_process_stats *a = (sg_process_stats *)va;
886          const sg_process_stats *b = (sg_process_stats *)vb;
887  
# Line 767 | Line 894 | int sg_compare_time(const void *va, const void *vb) {
894          }
895   }
896  
770 – void sg_sort(sg_process_stats *ps, int num_ps, sg_sort_method sm){
771 –        int (*sortby_ptr)(const void *a, const void *b);
772 –
773 –        switch(sm){
774 –        case SG_PS_PID:
775 –                sortby_ptr = sg_compare_pid;
776 –                break;
777 –        case SG_PS_UID:
778 –                sortby_ptr = sg_compare_uid;
779 –                break;
780 –        case SG_PS_GID:
781 –                sortby_ptr = sg_compare_gid;
782 –                break;
783 –        case SG_PS_SIZE:
784 –                sortby_ptr = sg_compare_size;
785 –                break;
786 –        case SG_PS_RES:
787 –                sortby_ptr = sg_compare_res;
788 –                break;
789 –        case SG_PS_CPU:
790 –                sortby_ptr = sg_compare_cpu;
791 –                break;
792 –        case SG_PS_TIME:
793 –                sortby_ptr = sg_compare_time;
794 –                break;
795 –        }
796 –
797 –        qsort(ps, num_ps, sizeof(*ps), sortby_ptr);
798 –
799 –        return;
800 – }

Diff Legend

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