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.71 by tdb, Thu Apr 8 17:20:51 2004 UTC vs.
Revision 1.76 by tdb, Mon Nov 1 18:30:17 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 + #endif
80  
81   static void proc_state_init(sg_process_stats *s) {
82          s->process_name = NULL;
# Line 88 | Line 93 | sg_process_stats *sg_get_process_stats(int *entries){
93                                proc_state_init, proc_state_destroy);
94          int proc_state_size = 0;
95          sg_process_stats *proc_state_ptr;
96 + #ifdef HPUX
97 +        struct pst_status pstat_procinfo;
98 +        long procidx = 0;
99 +        long long pagesize = 0;
100 + #endif
101   #ifdef ALLBSD
102          int mib[4];
103          size_t size;
# Line 131 | Line 141 | sg_process_stats *sg_get_process_stats(int *entries){
141  
142   #ifdef LINUX
143          if ((f=fopen("/proc/uptime", "r")) == NULL) {
144 <                sg_set_error(SG_ERROR_OPEN, "/proc/uptime");
144 >                sg_set_error_with_errno(SG_ERROR_OPEN, "/proc/uptime");
145                  return NULL;
146          }
147          if((fscanf(f,"%lu %*d",&uptime)) != 1){
# Line 142 | Line 152 | sg_process_stats *sg_get_process_stats(int *entries){
152   #endif
153  
154          if((proc_dir=opendir(PROC_LOCATION))==NULL){
155 <                sg_set_error(SG_ERROR_OPENDIR, PROC_LOCATION);
155 >                sg_set_error_with_errno(SG_ERROR_OPENDIR, PROC_LOCATION);
156                  return NULL;
157          }
158  
# Line 192 | Line 202 | sg_process_stats *sg_get_process_stats(int *entries){
202                          return NULL;
203                  }
204  
205 <                if(process_info.pr_lwp.pr_state==1) proc_state_ptr->state = SG_PROCESS_STATE_SLEEPING;
206 <                if(process_info.pr_lwp.pr_state==2) proc_state_ptr->state = SG_PROCESS_STATE_RUNNING;
207 <                if(process_info.pr_lwp.pr_state==3) proc_state_ptr->state = SG_PROCESS_STATE_ZOMBIE;
208 <                if(process_info.pr_lwp.pr_state==4) proc_state_ptr->state = SG_PROCESS_STATE_STOPPED;
209 <                if(process_info.pr_lwp.pr_state==6) proc_state_ptr->state = SG_PROCESS_STATE_RUNNING;
205 >                switch (process_info.pr_lwp.pr_state) {
206 >                case 1:
207 >                        proc_state_ptr->state = SG_PROCESS_STATE_SLEEPING;
208 >                        break;
209 >                case 2:
210 >                case 5:
211 >                        proc_state_ptr->state = SG_PROCESS_STATE_RUNNING;
212 >                        break;
213 >                case 3:
214 >                        proc_state_ptr->state = SG_PROCESS_STATE_ZOMBIE;
215 >                        break;
216 >                case 4:
217 >                        proc_state_ptr->state = SG_PROCESS_STATE_STOPPED;
218 >                        break;
219 >                }
220   #endif
221   #ifdef LINUX
222                  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));
223                  /* +3 becuase man page says "Resident  Set Size: number of pages the process has in real memory, minus 3 for administrative purposes." */
224                  proc_state_ptr->proc_resident = (proc_state_ptr->proc_resident + 3) * getpagesize();
225 <                if(s == 'S') proc_state_ptr->state = SG_PROCESS_STATE_SLEEPING;
226 <                if(s == 'R') proc_state_ptr->state = SG_PROCESS_STATE_RUNNING;
227 <                if(s == 'Z') proc_state_ptr->state = SG_PROCESS_STATE_ZOMBIE;
228 <                if(s == 'T') proc_state_ptr->state = SG_PROCESS_STATE_STOPPED;
229 <                if(s == 'D') proc_state_ptr->state = SG_PROCESS_STATE_STOPPED;
225 >                switch (s) {
226 >                case 'S':
227 >                        proc_state_ptr->state = SG_PROCESS_STATE_SLEEPING;
228 >                        break;
229 >                case 'R':
230 >                        proc_state_ptr->state = SG_PROCESS_STATE_RUNNING;
231 >                        break;
232 >                case 'Z':
233 >                        proc_state_ptr->state = SG_PROCESS_STATE_ZOMBIE;
234 >                        break;
235 >                case 'T':
236 >                case 'D':
237 >                        proc_state_ptr->state = SG_PROCESS_STATE_STOPPED;
238 >                        break;
239 >                }
240          
241                  /* pa_name[0] should = '(' */
242                  ptr = strchr(&ps_name[1], ')');
# Line 307 | Line 337 | sg_process_stats *sg_get_process_stats(int *entries){
337          mib[2] = KERN_PROC_ALL;
338  
339          if(sysctl(mib, 3, NULL, &size, NULL, 0) < 0) {
340 <                sg_set_error(SG_ERROR_SYSCTL, "CTL_KERN.KERN_PROC.KERN_PROC_ALL");
340 >                sg_set_error_with_errno(SG_ERROR_SYSCTL,
341 >                                        "CTL_KERN.KERN_PROC.KERN_PROC_ALL");
342                  return NULL;
343          }
344  
# Line 320 | Line 351 | sg_process_stats *sg_get_process_stats(int *entries){
351          memset(kp_stats, 0, size);
352  
353          if(sysctl(mib, 3, kp_stats, &size, NULL, 0) < 0) {
354 <                sg_set_error(SG_ERROR_SYSCTL, "CTL_KERN.KERN_PROC.KERN_PROC_ALL");
354 >                sg_set_error_with_errno(SG_ERROR_SYSCTL,
355 >                                        "CTL_KERN.KERN_PROC.KERN_PROC_ALL");
356                  free(kp_stats);
357                  return NULL;
358          }
# Line 412 | Line 444 | sg_process_stats *sg_get_process_stats(int *entries){
444                                  return NULL;
445                          }
446                          p = proctitle;
447 + #ifdef OPENBSD
448 +                        /* On OpenBSD, this value has the argv pointers (which
449 +                         * are terminated by a NULL) at the front, so we have
450 +                         * to skip over them to get to the strings. */
451 +                        while (*(char ***)p != NULL) {
452 +                                p += sizeof(char **);
453 +                        }
454 +                        p += sizeof(char **);
455 + #endif
456                          proc_state_ptr->proctitle[0] = '\0';
457                          do {
458                                  sg_strlcat(proc_state_ptr->proctitle, p, size+1);
# Line 537 | Line 578 | sg_process_stats *sg_get_process_stats(int *entries){
578                          mib[4] = 0;
579  
580                          if(sysctl(mib, 5, NULL, &size, NULL, 0) < 0) {
581 <                                sg_set_error(SG_ERROR_SYSCTL, "CTL_KERN.KERN_LWP.pid.structsize.0");
581 >                                sg_set_error_with_errno(SG_ERROR_SYSCTL, "CTL_KERN.KERN_LWP.pid.structsize.0");
582                                  return NULL;
583                          }
584  
# Line 550 | Line 591 | sg_process_stats *sg_get_process_stats(int *entries){
591                          }
592  
593                          if(sysctl(mib, 5, kl_stats, &size, NULL, 0) < 0) {
594 <                                sg_set_error(SG_ERROR_SYSCTL, "CTL_KERN.KERN_LWP.pid.structsize.buffersize");
594 >                                sg_set_error_with_errno(SG_ERROR_SYSCTL, "CTL_KERN.KERN_LWP.pid.structsize.buffersize");
595                                  return NULL;
596                          }
597                  }
# Line 592 | Line 633 | sg_process_stats *sg_get_process_stats(int *entries){
633                          proc_state_ptr->state = SG_PROCESS_STATE_UNKNOWN;
634                          break;
635                  }
636 +
637 +                free(kl_stats);
638   #else
639   #ifdef FREEBSD5
640                  switch (kp_stats[i].ki_stat) {
# Line 632 | Line 675 | sg_process_stats *sg_get_process_stats(int *entries){
675          }
676  
677          free(kp_stats);
678 + #endif
679 +
680 + #ifdef HPUX
681 +        if((pagesize=sysconf(_SC_PAGESIZE)) == -1){
682 +                sg_set_error_with_errno(SG_ERROR_SYSCONF, "_SC_PAGESIZE");
683 +                return NULL;
684 +        }
685 +
686 +        for (procidx = 0; procidx < 65536; procidx++) {
687 +                if (pstat_getproc(&pstat_procinfo, sizeof(pstat_procinfo), 1, procidx) == -1) {
688 +                        break;
689 +                }
690 +                if (pstat_procinfo.pst_idx != procidx) {
691 +                        continue;
692 +                }
693 +
694 +                if (VECTOR_RESIZE(proc_state, proc_state_size + 1) < 0) {
695 +                        return NULL;
696 +                }
697 +                proc_state_ptr = proc_state+proc_state_size;
698 +
699 +                proc_state_ptr->pid = pstat_procinfo.pst_pid;
700 +                proc_state_ptr->parent = pstat_procinfo.pst_ppid;
701 +                proc_state_ptr->pgid = pstat_procinfo.pst_pgrp;
702 +                proc_state_ptr->uid = pstat_procinfo.pst_uid;
703 +                proc_state_ptr->euid = pstat_procinfo.pst_euid;
704 +                proc_state_ptr->gid = pstat_procinfo.pst_gid;
705 +                proc_state_ptr->egid = pstat_procinfo.pst_egid;
706 +                proc_state_ptr->proc_size = (pstat_procinfo.pst_dsize + pstat_procinfo.pst_tsize + pstat_procinfo.pst_ssize) * pagesize;
707 +                proc_state_ptr->proc_resident = pstat_procinfo.pst_rssize * pagesize;
708 +                proc_state_ptr->time_spent = pstat_procinfo.pst_time;
709 +                proc_state_ptr->cpu_percent = (pstat_procinfo.pst_pctcpu * 100.0) / 0x8000;
710 +                proc_state_ptr->nice = pstat_procinfo.pst_nice;
711 +
712 +                if (sg_update_string(&proc_state_ptr->process_name,
713 +                                     pstat_procinfo.pst_ucomm) < 0) {
714 +                        return NULL;
715 +                }
716 +                if (sg_update_string(&proc_state_ptr->proctitle,
717 +                                     pstat_procinfo.pst_cmd) < 0) {
718 +                        return NULL;
719 +                }
720 +
721 +                switch (pstat_procinfo.pst_stat) {
722 +                case PS_SLEEP:
723 +                        proc_state_ptr->state = SG_PROCESS_STATE_SLEEPING;
724 +                        break;
725 +                case PS_RUN:
726 +                        proc_state_ptr->state = SG_PROCESS_STATE_RUNNING;
727 +                        break;
728 +                case PS_STOP:
729 +                        proc_state_ptr->state = SG_PROCESS_STATE_STOPPED;
730 +                        break;
731 +                case PS_ZOMBIE:
732 +                        proc_state_ptr->state = SG_PROCESS_STATE_ZOMBIE;
733 +                        break;
734 +                case PS_IDLE:
735 +                case PS_OTHER:
736 +                        proc_state_ptr->state = SG_PROCESS_STATE_UNKNOWN;
737 +                        break;
738 +                }
739 +
740 +                proc_state_size++;
741 +        }
742 +
743   #endif
744  
745   #ifdef CYGWIN

Diff Legend

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