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.75 by ats, Fri Sep 10 15:15:00 2004 UTC vs.
Revision 1.82 by tdb, Mon Oct 9 14:47:58 2006 UTC

# Line 33 | Line 33
33   #include <stdlib.h>
34   #include <sys/types.h>
35   #include <dirent.h>
36 – #include <string.h>
36   #endif
37 + #include <string.h>
38  
39   #ifdef SOLARIS
40   #include <procfs.h>
# 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 + #ifdef WIN32
82 + #include <windows.h>
83 + #include <psapi.h>
84 + #endif
85  
86   static void proc_state_init(sg_process_stats *s) {
87          s->process_name = NULL;
# Line 88 | Line 98 | sg_process_stats *sg_get_process_stats(int *entries){
98                                proc_state_init, proc_state_destroy);
99          int proc_state_size = 0;
100          sg_process_stats *proc_state_ptr;
101 + #ifdef HPUX
102 +        struct pst_status pstat_procinfo[PROCESS_BATCH];
103 +        long procidx = 0;
104 +        long long pagesize;
105 +        int num, i;
106 + #endif
107   #ifdef ALLBSD
108          int mib[4];
109          size_t size;
# Line 127 | Line 143 | sg_process_stats *sg_get_process_stats(int *entries){
143          int len;
144          int rc;
145          time_t uptime;
146 +        long tickspersec;
147   #endif
148  
149   #ifdef LINUX
# Line 239 | Line 256 | sg_process_stats *sg_get_process_stats(int *entries){
256  
257                  /* cpu */
258                  proc_state_ptr->cpu_percent = (100.0 * (utime + stime)) / ((uptime * 100.0) - starttime);
259 +                tickspersec = sysconf (_SC_CLK_TCK);
260 +                if (tickspersec < 0) {
261 +                        proc_state_ptr->time_spent = 0;
262 +                }
263 +                else {
264 +                        proc_state_ptr->time_spent = (utime + stime) / tickspersec;
265 +                }
266  
267                  fclose(f);
268  
# Line 404 | Line 428 | sg_process_stats *sg_get_process_stats(int *entries){
428                  proctitle = NULL;
429  
430                  do {
431 <                        if(size >= buflen) {
431 >                        if((long) size >= buflen) {
432                                  buflen *= 2;
433                                  size = buflen;
434                                  proctitletmp = sg_realloc(proctitle, buflen);
# Line 426 | Line 450 | sg_process_stats *sg_get_process_stats(int *entries){
450                                  size = 0;
451                                  break;
452                          }
453 <                } while(size >= buflen);
453 >                } while((long) size >= buflen);
454  
455                  if(size > 0) {
456                          proc_state_ptr->proctitle = sg_malloc(size+1);
# Line 667 | Line 691 | sg_process_stats *sg_get_process_stats(int *entries){
691          free(kp_stats);
692   #endif
693  
694 + #ifdef HPUX
695 +        if ((pagesize = sysconf(_SC_PAGESIZE)) == -1) {
696 +                sg_set_error_with_errno(SG_ERROR_SYSCONF, "_SC_PAGESIZE");
697 +                return NULL;
698 +        }
699 +
700 +        while (1) {
701 +                num = pstat_getproc(pstat_procinfo, sizeof pstat_procinfo[0],
702 +                                    PROCESS_BATCH, procidx);
703 +                if (num == -1) {
704 +                        sg_set_error_with_errno(SG_ERROR_PSTAT,
705 +                                                "pstat_getproc");
706 +                        return NULL;
707 +                } else if (num == 0) {
708 +                        break;
709 +                }
710 +
711 +                for (i = 0; i < num; i++) {
712 +                        struct pst_status *pi = &pstat_procinfo[i];
713 +
714 +                        if (VECTOR_RESIZE(proc_state, proc_state_size + 1) < 0) {
715 +                                return NULL;
716 +                        }
717 +                        proc_state_ptr = proc_state+proc_state_size;
718 +        
719 +                        proc_state_ptr->pid = pi->pst_pid;
720 +                        proc_state_ptr->parent = pi->pst_ppid;
721 +                        proc_state_ptr->pgid = pi->pst_pgrp;
722 +                        proc_state_ptr->uid = pi->pst_uid;
723 +                        proc_state_ptr->euid = pi->pst_euid;
724 +                        proc_state_ptr->gid = pi->pst_gid;
725 +                        proc_state_ptr->egid = pi->pst_egid;
726 +                        proc_state_ptr->proc_size = (pi->pst_dsize + pi->pst_tsize + pi->pst_ssize) * pagesize;
727 +                        proc_state_ptr->proc_resident = pi->pst_rssize * pagesize;
728 +                        proc_state_ptr->time_spent = pi->pst_time;
729 +                        proc_state_ptr->cpu_percent = (pi->pst_pctcpu * 100.0) / 0x8000;
730 +                        proc_state_ptr->nice = pi->pst_nice;
731 +        
732 +                        if (sg_update_string(&proc_state_ptr->process_name,
733 +                                             pi->pst_ucomm) < 0) {
734 +                                return NULL;
735 +                        }
736 +                        if (sg_update_string(&proc_state_ptr->proctitle,
737 +                                             pi->pst_cmd) < 0) {
738 +                                return NULL;
739 +                        }
740 +        
741 +                        switch (pi->pst_stat) {
742 +                        case PS_SLEEP:
743 +                                proc_state_ptr->state = SG_PROCESS_STATE_SLEEPING;
744 +                                break;
745 +                        case PS_RUN:
746 +                                proc_state_ptr->state = SG_PROCESS_STATE_RUNNING;
747 +                                break;
748 +                        case PS_STOP:
749 +                                proc_state_ptr->state = SG_PROCESS_STATE_STOPPED;
750 +                                break;
751 +                        case PS_ZOMBIE:
752 +                                proc_state_ptr->state = SG_PROCESS_STATE_ZOMBIE;
753 +                                break;
754 +                        case PS_IDLE:
755 +                        case PS_OTHER:
756 +                                proc_state_ptr->state = SG_PROCESS_STATE_UNKNOWN;
757 +                                break;
758 +                        }
759 +        
760 +                        proc_state_size++;
761 +                }
762 +                procidx = pstat_procinfo[num - 1].pst_idx + 1;
763 +        }
764 + #endif
765 +
766   #ifdef CYGWIN
767          sg_set_error(SG_ERROR_UNSUPPORTED, "Cygwin");
768          return NULL;
769   #endif
770 + #ifdef WIN32
771 +        /* FIXME The data needed for this is probably do able with the
772 +         * "performance registry". Although using this appears to be a black
773 +         * art and closely guarded secret.
774 +         * This is not directly used in ihost, so not considered a priority */
775 +        sg_set_error(SG_ERROR_UNSUPPORTED, "Win32");
776 +        return NULL;
777 + #endif
778  
779          *entries = proc_state_size;
780          return proc_state;
# Line 678 | Line 782 | sg_process_stats *sg_get_process_stats(int *entries){
782  
783   sg_process_count *sg_get_process_count() {
784          static sg_process_count process_stat;
785 + #ifndef WIN32
786          sg_process_stats *ps;
787          int ps_size, x;
788 + #else
789 +        DWORD aProcesses[1024];
790 +        DWORD cbNeeded;
791 + #endif
792  
793          process_stat.sleeping = 0;
794          process_stat.running = 0;
# Line 687 | Line 796 | sg_process_count *sg_get_process_count() {
796          process_stat.stopped = 0;
797          process_stat.total = 0;
798  
799 + #ifndef WIN32
800          ps = sg_get_process_stats(&ps_size);
801          if (ps == NULL) {
802                  return NULL;
# Line 715 | Line 825 | sg_process_count *sg_get_process_count() {
825          }
826  
827          process_stat.total = ps_size;
828 + #else
829 +        if (!EnumProcesses(aProcesses, sizeof(aProcesses), &cbNeeded))
830 +                return NULL;
831 +        process_stat.total = cbNeeded / sizeof(DWORD);
832 + #endif
833  
834          return &process_stat;
835   }

Diff Legend

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