ViewVC Help

View File | Revision Log | Show Annotations | Revision Graph | Root Listing

root/i-scream/projects/libstatgrab/src/libstatgrab/process_stats.c

Comparing projects/libstatgrab/src/libstatgrab/process_stats.c (file contents):
Revision 1.76 by tdb, Mon Nov 1 18:30:17 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 76 | Line 76
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 94 | Line 99 | sg_process_stats *sg_get_process_stats(int *entries){
99		int proc_state_size = 0;
100		sg_process_stats *proc_state_ptr;
101		#ifdef HPUX
102	<	struct pst_status pstat_procinfo;
102	>	struct pst_status pstat_procinfo[PROCESS_BATCH];
103		long procidx = 0;
104	<	long long pagesize = 0;
104	>	long long pagesize;
105	>	int num, i;
106		#endif
107		#ifdef ALLBSD
108		int mib[4];
#	Line 137 | 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 249 | 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 414 | 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 436 | 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 678 | Line 692 | sg_process_stats *sg_get_process_stats(int *entries){
692		#endif
693
694		#ifdef HPUX
695	<	if((pagesize=sysconf(_SC_PAGESIZE)) == -1){
695	>	if ((pagesize = sysconf(_SC_PAGESIZE)) == -1) {
696		sg_set_error_with_errno(SG_ERROR_SYSCONF, "_SC_PAGESIZE");
697		return NULL;
698		}
699
700	<	for (procidx = 0; procidx < 65536; procidx++) {
701	<	if (pstat_getproc(&pstat_procinfo, sizeof(pstat_procinfo), 1, procidx) == -1) {
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		}
690	–	if (pstat_procinfo.pst_idx != procidx) {
691	–	continue;
692	–	}
710
711	<	if (VECTOR_RESIZE(proc_state, proc_state_size + 1) < 0) {
712	<	return NULL;
696	<	}
697	<	proc_state_ptr = proc_state+proc_state_size;
711	>	for (i = 0; i < num; i++) {
712	>	struct pst_status *pi = &pstat_procinfo[i];
713
714	<	proc_state_ptr->pid = pstat_procinfo.pst_pid;
715	<	proc_state_ptr->parent = pstat_procinfo.pst_ppid;
716	<	proc_state_ptr->pgid = pstat_procinfo.pst_pgrp;
717	<	proc_state_ptr->uid = pstat_procinfo.pst_uid;
718	<	proc_state_ptr->euid = pstat_procinfo.pst_euid;
719	<	proc_state_ptr->gid = pstat_procinfo.pst_gid;
720	<	proc_state_ptr->egid = pstat_procinfo.pst_egid;
721	<	proc_state_ptr->proc_size = (pstat_procinfo.pst_dsize + pstat_procinfo.pst_tsize + pstat_procinfo.pst_ssize) * pagesize;
722	<	proc_state_ptr->proc_resident = pstat_procinfo.pst_rssize * pagesize;
723	<	proc_state_ptr->time_spent = pstat_procinfo.pst_time;
724	<	proc_state_ptr->cpu_percent = (pstat_procinfo.pst_pctcpu * 100.0) / 0x8000;
725	<	proc_state_ptr->nice = pstat_procinfo.pst_nice;
726	<
727	<	if (sg_update_string(&proc_state_ptr->process_name,
728	<	pstat_procinfo.pst_ucomm) < 0) {
729	<	return NULL;
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	<	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++;
762	>	procidx = pstat_procinfo[num - 1].pst_idx + 1;
763		}
742	–
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 753 | 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 762 | 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 790 | 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