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.73 by tdb, Mon Jun 21 14:48:48 2004 UTC vs.
Revision 1.78 by ats, Sat Nov 6 15:31:26 2004 UTC

# Line 72 | 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 88 | 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 131 | 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 142 | 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 192 | 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 307 | 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 320 | 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 546 | 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 559 | 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 643 | Line 677 | sg_process_stats *sg_get_process_stats(int *entries){
677          }
678  
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 +        while (1) {
689 +                num = pstat_getproc(pstat_procinfo, sizeof pstat_procinfo[0],
690 +                                    PROCESS_BATCH, procidx);
691 +                if (num == -1) {
692 +                        sg_set_error_with_errno(SG_ERROR_PSTAT,
693 +                                                "pstat_getproc");
694 +                        return NULL;
695 +                } else if (num == 0) {
696 +                        break;
697 +                }
698 +
699 +                for (i = 0; i < num; i++) {
700 +                        struct pst_status *pi = &pstat_procinfo[i];
701 +
702 +                        if (VECTOR_RESIZE(proc_state, proc_state_size + 1) < 0) {
703 +                                return NULL;
704 +                        }
705 +                        proc_state_ptr = proc_state+proc_state_size;
706 +        
707 +                        proc_state_ptr->pid = pi->pst_pid;
708 +                        proc_state_ptr->parent = pi->pst_ppid;
709 +                        proc_state_ptr->pgid = pi->pst_pgrp;
710 +                        proc_state_ptr->uid = pi->pst_uid;
711 +                        proc_state_ptr->euid = pi->pst_euid;
712 +                        proc_state_ptr->gid = pi->pst_gid;
713 +                        proc_state_ptr->egid = pi->pst_egid;
714 +                        proc_state_ptr->proc_size = (pi->pst_dsize + pi->pst_tsize + pi->pst_ssize) * pagesize;
715 +                        proc_state_ptr->proc_resident = pi->pst_rssize * pagesize;
716 +                        proc_state_ptr->time_spent = pi->pst_time;
717 +                        proc_state_ptr->cpu_percent = (pi->pst_pctcpu * 100.0) / 0x8000;
718 +                        proc_state_ptr->nice = pi->pst_nice;
719 +        
720 +                        if (sg_update_string(&proc_state_ptr->process_name,
721 +                                             pi->pst_ucomm) < 0) {
722 +                                return NULL;
723 +                        }
724 +                        if (sg_update_string(&proc_state_ptr->proctitle,
725 +                                             pi->pst_cmd) < 0) {
726 +                                return NULL;
727 +                        }
728 +        
729 +                        switch (pi->pst_stat) {
730 +                        case PS_SLEEP:
731 +                                proc_state_ptr->state = SG_PROCESS_STATE_SLEEPING;
732 +                                break;
733 +                        case PS_RUN:
734 +                                proc_state_ptr->state = SG_PROCESS_STATE_RUNNING;
735 +                                break;
736 +                        case PS_STOP:
737 +                                proc_state_ptr->state = SG_PROCESS_STATE_STOPPED;
738 +                                break;
739 +                        case PS_ZOMBIE:
740 +                                proc_state_ptr->state = SG_PROCESS_STATE_ZOMBIE;
741 +                                break;
742 +                        case PS_IDLE:
743 +                        case PS_OTHER:
744 +                                proc_state_ptr->state = SG_PROCESS_STATE_UNKNOWN;
745 +                                break;
746 +                        }
747 +        
748 +                        proc_state_size++;
749 +                }
750 +                procidx = pstat_procinfo[num - 1].pst_idx + 1;
751 +        }
752   #endif
753  
754   #ifdef CYGWIN

Diff Legend

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