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.83 by tdb, Sun Oct 3 18:35:58 2010 UTC

#	Line 28 | Line 28
28		#include "statgrab.h"
29		#include "tools.h"
30		#include "vector.h"
31	<	#if defined(SOLARIS) || defined(LINUX)
31	>	#if defined(SOLARIS) || defined(LINUX) || defined(AIX)
32		#include <stdio.h>
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	+	#ifdef AIX
86	+	#include <unistd.h>
87	+	#include <errno.h>
88	+	#include <time.h>
89	+	#include <procinfo.h>
90	+	#include <sys/time.h>
91	+	extern int getprocs64(struct procentry64 *, int, struct fdsinfo64 *, int, pid_t *, int);
92	+	extern int getargs(struct procentry64 *, int, char *, int);
93	+	#endif
94
95		static void proc_state_init(sg_process_stats *s) {
96		s->process_name = NULL;
#	Line 94 | Line 108 | sg_process_stats *sg_get_process_stats(int *entries){
108		int proc_state_size = 0;
109		sg_process_stats *proc_state_ptr;
110		#ifdef HPUX
111	<	struct pst_status pstat_procinfo;
111	>	struct pst_status pstat_procinfo[PROCESS_BATCH];
112		long procidx = 0;
113	<	long long pagesize = 0;
113	>	long long pagesize;
114	>	int num, i;
115		#endif
116	+	#ifdef AIX
117	+	struct procentry64 *procs = NULL;
118	+	long long pagesize;
119	+	int fetched = 0;
120	+	pid_t index = 0;
121	+	unsigned proc_idx;
122	+	time_t utime, stime;
123	+	int ncpus;
124	+	struct timeval now_tval;
125	+	double now_time;
126	+	char cmndline[ARG_MAX];
127	+	char comm[ARG_MAX];
128	+	struct procentry64 curproc_for_getargs;
129	+	#define PROCS_TO_FETCH  1000
130	+	#endif
131		#ifdef ALLBSD
132		int mib[4];
133		size_t size;
#	Line 137 | Line 167 | sg_process_stats *sg_get_process_stats(int *entries){
167		int len;
168		int rc;
169		time_t uptime;
170	+	long tickspersec;
171		#endif
172
173		#ifdef LINUX
#	Line 249 | Line 280 | sg_process_stats *sg_get_process_stats(int *entries){
280
281		/* cpu */
282		proc_state_ptr->cpu_percent = (100.0 * (utime + stime)) / ((uptime * 100.0) - starttime);
283	+	tickspersec = sysconf (_SC_CLK_TCK);
284	+	if (tickspersec < 0) {
285	+	proc_state_ptr->time_spent = 0;
286	+	}
287	+	else {
288	+	proc_state_ptr->time_spent = (utime + stime) / tickspersec;
289	+	}
290
291		fclose(f);
292
#	Line 414 | Line 452 | sg_process_stats *sg_get_process_stats(int *entries){
452		proctitle = NULL;
453
454		do {
455	<	if(size >= buflen) {
455	>	if((long) size >= buflen) {
456		buflen *= 2;
457		size = buflen;
458		proctitletmp = sg_realloc(proctitle, buflen);
#	Line 436 | Line 474 | sg_process_stats *sg_get_process_stats(int *entries){
474		size = 0;
475		break;
476		}
477	<	} while(size >= buflen);
477	>	} while((long) size >= buflen);
478
479		if(size > 0) {
480		proc_state_ptr->proctitle = sg_malloc(size+1);
#	Line 678 | Line 716 | sg_process_stats *sg_get_process_stats(int *entries){
716		#endif
717
718		#ifdef HPUX
719	<	if((pagesize=sysconf(_SC_PAGESIZE)) == -1){
719	>	if ((pagesize = sysconf(_SC_PAGESIZE)) == -1) {
720		sg_set_error_with_errno(SG_ERROR_SYSCONF, "_SC_PAGESIZE");
721		return NULL;
722		}
723
724	<	for (procidx = 0; procidx < 65536; procidx++) {
725	<	if (pstat_getproc(&pstat_procinfo, sizeof(pstat_procinfo), 1, procidx) == -1) {
724	>	while (1) {
725	>	num = pstat_getproc(pstat_procinfo, sizeof pstat_procinfo[0],
726	>	PROCESS_BATCH, procidx);
727	>	if (num == -1) {
728	>	sg_set_error_with_errno(SG_ERROR_PSTAT,
729	>	"pstat_getproc");
730	>	return NULL;
731	>	} else if (num == 0) {
732		break;
733		}
690	–	if (pstat_procinfo.pst_idx != procidx) {
691	–	continue;
692	–	}
734
735	<	if (VECTOR_RESIZE(proc_state, proc_state_size + 1) < 0) {
736	<	return NULL;
735	>	for (i = 0; i < num; i++) {
736	>	struct pst_status *pi = &pstat_procinfo[i];
737	>
738	>	if (VECTOR_RESIZE(proc_state, proc_state_size + 1) < 0) {
739	>	return NULL;
740	>	}
741	>	proc_state_ptr = proc_state+proc_state_size;
742	>
743	>	proc_state_ptr->pid = pi->pst_pid;
744	>	proc_state_ptr->parent = pi->pst_ppid;
745	>	proc_state_ptr->pgid = pi->pst_pgrp;
746	>	proc_state_ptr->uid = pi->pst_uid;
747	>	proc_state_ptr->euid = pi->pst_euid;
748	>	proc_state_ptr->gid = pi->pst_gid;
749	>	proc_state_ptr->egid = pi->pst_egid;
750	>	proc_state_ptr->proc_size = (pi->pst_dsize + pi->pst_tsize + pi->pst_ssize) * pagesize;
751	>	proc_state_ptr->proc_resident = pi->pst_rssize * pagesize;
752	>	proc_state_ptr->time_spent = pi->pst_time;
753	>	proc_state_ptr->cpu_percent = (pi->pst_pctcpu * 100.0) / 0x8000;
754	>	proc_state_ptr->nice = pi->pst_nice;
755	>
756	>	if (sg_update_string(&proc_state_ptr->process_name,
757	>	pi->pst_ucomm) < 0) {
758	>	return NULL;
759	>	}
760	>	if (sg_update_string(&proc_state_ptr->proctitle,
761	>	pi->pst_cmd) < 0) {
762	>	return NULL;
763	>	}
764	>
765	>	switch (pi->pst_stat) {
766	>	case PS_SLEEP:
767	>	proc_state_ptr->state = SG_PROCESS_STATE_SLEEPING;
768	>	break;
769	>	case PS_RUN:
770	>	proc_state_ptr->state = SG_PROCESS_STATE_RUNNING;
771	>	break;
772	>	case PS_STOP:
773	>	proc_state_ptr->state = SG_PROCESS_STATE_STOPPED;
774	>	break;
775	>	case PS_ZOMBIE:
776	>	proc_state_ptr->state = SG_PROCESS_STATE_ZOMBIE;
777	>	break;
778	>	case PS_IDLE:
779	>	case PS_OTHER:
780	>	proc_state_ptr->state = SG_PROCESS_STATE_UNKNOWN;
781	>	break;
782	>	}
783	>
784	>	proc_state_size++;
785		}
786	<	proc_state_ptr = proc_state+proc_state_size;
786	>	procidx = pstat_procinfo[num - 1].pst_idx + 1;
787	>	}
788	>	#endif
789
790	<	proc_state_ptr->pid = pstat_procinfo.pst_pid;
791	<	proc_state_ptr->parent = pstat_procinfo.pst_ppid;
792	<	proc_state_ptr->pgid = pstat_procinfo.pst_pgrp;
793	<	proc_state_ptr->uid = pstat_procinfo.pst_uid;
794	<	proc_state_ptr->euid = pstat_procinfo.pst_euid;
795	<	proc_state_ptr->gid = pstat_procinfo.pst_gid;
796	<	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;
790	>	#ifdef AIX
791	>	#define TVALU_TO_SEC(x) ((x).tv_sec + ((double)((x).tv_usec) / 1000000.0))
792	>	#define TVALN_TO_SEC(x) ((x).tv_sec + ((double)((x).tv_usec) / 1000000000.0))
793	>	ncpus = sysconf(_SC_NPROCESSORS_ONLN);
794	>	if( -1 == ncpus ) {
795	>	ncpus = 1; /* sysconf error - assume 1 */
796	>	}
797
798	<	if (sg_update_string(&proc_state_ptr->process_name,
799	<	pstat_procinfo.pst_ucomm) < 0) {
798	>	if ((pagesize = sysconf(_SC_PAGESIZE)) == -1) {
799	>	sg_set_error_with_errno(SG_ERROR_SYSCONF, "_SC_PAGESIZE");
800	>	return NULL;
801	>	}
802	>
803	>	proc_idx = 0;
804	>	procs = /* (struct procentry64 *) */ malloc(sizeof(*procs) * PROCS_TO_FETCH);
805	>	if(NULL == procs) {
806	>	sg_set_error_with_errno(SG_ERROR_MALLOC, "sg_get_process_stats");
807	>	return 0;
808	>	}
809	>
810	>	gettimeofday(&now_tval, 0);
811	>	now_time = TVALU_TO_SEC(now_tval);
812	>
813	>	/* keep on grabbing chunks of processes until getprocs returns a smaller
814	>	block than we asked for */
815	>	do {
816	>	int i;
817	>	fetched = getprocs64(procs, sizeof(*procs), NULL, 0, &index, PROCS_TO_FETCH);
818	>	if (VECTOR_RESIZE(proc_state, proc_state_size + fetched) < 0) {
819	>	sg_set_error_with_errno(SG_ERROR_MALLOC, "sg_get_process_stats");
820	>	free(procs);
821		return NULL;
822		}
823	<	if (sg_update_string(&proc_state_ptr->proctitle,
824	<	pstat_procinfo.pst_cmd) < 0) {
825	<	return NULL;
719	<	}
823	>	for( i = 0; i < fetched; ++i ) {
824	>	struct procentry64 *pi = procs+i;
825	>	int zombie = 0;
826
827	<	switch (pstat_procinfo.pst_stat) {
828	<	case PS_SLEEP:
829	<	proc_state_ptr->state = SG_PROCESS_STATE_SLEEPING;
830	<	break;
831	<	case PS_RUN:
832	<	proc_state_ptr->state = SG_PROCESS_STATE_RUNNING;
833	<	break;
834	<	case PS_STOP:
835	<	proc_state_ptr->state = SG_PROCESS_STATE_STOPPED;
836	<	break;
837	<	case PS_ZOMBIE:
838	<	proc_state_ptr->state = SG_PROCESS_STATE_ZOMBIE;
839	<	break;
840	<	case PS_IDLE:
841	<	case PS_OTHER:
842	<	proc_state_ptr->state = SG_PROCESS_STATE_UNKNOWN;
843	<	break;
827	>	proc_state_ptr = proc_state + proc_idx;
828	>
829	>	zombie = 0;
830	>
831	>	/* set a descriptive name for the process state */
832	>	switch( pi->pi_state ) {
833	>	case SSLEEP:
834	>	proc_state_ptr->state = SG_PROCESS_STATE_SLEEPING;
835	>	break;
836	>	case SRUN:
837	>	proc_state_ptr->state = SG_PROCESS_STATE_RUNNING;
838	>	break;
839	>	case SZOMB:
840	>	proc_state_ptr->state = SG_PROCESS_STATE_ZOMBIE;
841	>	zombie = 1;
842	>	break;
843	>	case SSTOP:
844	>	proc_state_ptr->state = SG_PROCESS_STATE_STOPPED;
845	>	break;
846	>	case SACTIVE:
847	>	proc_state_ptr->state = SG_PROCESS_STATE_RUNNING;
848	>	break;
849	>	case SIDL:
850	>	default:
851	>	proc_state_ptr->state = SG_PROCESS_STATE_UNKNOWN;
852	>	break;
853	>	}
854	>
855	>	if( zombie ) {
856	>	utime = pi->pi_utime;
857	>	stime = pi->pi_stime;
858	>	} else {
859	>	utime = TVALN_TO_SEC(pi->pi_ru.ru_utime) + TVALN_TO_SEC(pi->pi_cru.ru_utime);
860	>	stime = TVALN_TO_SEC(pi->pi_ru.ru_stime) + TVALN_TO_SEC(pi->pi_cru.ru_stime);
861	>	}
862	>
863	>	proc_state_ptr->pid = pi->pi_pid;
864	>	proc_state_ptr->parent = pi->pi_ppid;
865	>	proc_state_ptr->pgid = pi->pi_pgrp;
866	>	proc_state_ptr->uid = pi->pi_cred.crx_ruid;
867	>	proc_state_ptr->euid = pi->pi_cred.crx_uid;
868	>	proc_state_ptr->gid = pi->pi_cred.crx_rgid;
869	>	proc_state_ptr->egid = pi->pi_cred.crx_gid;
870	>	proc_state_ptr->proc_size = pi->pi_size;
871	>	proc_state_ptr->proc_resident = pi->pi_drss + pi->pi_trss; /* XXX might be wrong, see P::PT */
872	>	proc_state_ptr->time_spent = utime + stime;
873	>	proc_state_ptr->cpu_percent = (((double)(utime + stime) * 100) / ( now_time - pi->pi_start )) / ncpus;
874	>	proc_state_ptr->nice = pi->pi_nice;
875	>
876	>	/* determine comm & cmndline */
877	>	if( (pi->pi_flags & SKPROC) == SKPROC ) {
878	>	if( pi->pi_pid == 0 ) {
879	>	snprintf(comm, ARG_MAX, "kproc (swapper)");
880	>	snprintf(cmndline, ARG_MAX, "kproc (swapper)");
881	>	} else {
882	>	snprintf(comm, ARG_MAX, "kproc (%s)", pi->pi_comm);
883	>	snprintf(cmndline, ARG_MAX, "kproc (%s)", pi->pi_comm);
884	>	}
885	>	} else {
886	>	snprintf(comm, ARG_MAX, "%s", pi->pi_comm);
887	>	curproc_for_getargs.pi_pid = pi->pi_pid;
888	>	if( getargs(&curproc_for_getargs, sizeof(curproc_for_getargs), cmndline, ARG_MAX) < 0 ) {
889	>	snprintf(cmndline, ARG_MAX, "%s", pi->pi_comm);
890	>	} else {
891	>	int done = 0;
892	>	/* replace NUL characters in command line with spaces */
893	>	char *c = cmndline;
894	>	while( ! done ) {
895	>	if( *c == '\0' ) {
896	>	if( *(c+1) == '\0' ) {
897	>	done = 1;
898	>	} else {
899	>	*c++ = ' ';
900	>	}
901	>	} else {
902	>	++c;
903	>	}
904	>	}
905	>	}
906	>	}
907	>
908	>
909	>	if (sg_update_string(&proc_state_ptr->process_name, comm) < 0) {
910	>	free(procs);
911	>	return NULL;
912	>	}
913	>	if (sg_update_string(&proc_state_ptr->proctitle, cmndline) < 0) {
914	>	free(procs);
915	>	return NULL;
916	>	}
917	>
918	>	proc_idx++;
919		}
920	+	} while( fetched >= PROCS_TO_FETCH );
921
922	<	proc_state_size++;
741	<	}
922	>	proc_state_size = proc_idx;
923
924	+	free(procs);
925		#endif
926
927	+
928		#ifdef CYGWIN
929		sg_set_error(SG_ERROR_UNSUPPORTED, "Cygwin");
930		return NULL;
931		#endif
932	+	#ifdef WIN32
933	+	/* FIXME The data needed for this is probably do able with the
934	+	* "performance registry". Although using this appears to be a black
935	+	* art and closely guarded secret.
936	+	* This is not directly used in ihost, so not considered a priority */
937	+	sg_set_error(SG_ERROR_UNSUPPORTED, "Win32");
938	+	return NULL;
939	+	#endif
940
941		*entries = proc_state_size;
942		return proc_state;
#	Line 753 | Line 944 | sg_process_stats *sg_get_process_stats(int *entries){
944
945		sg_process_count *sg_get_process_count() {
946		static sg_process_count process_stat;
947	+	#ifndef WIN32
948		sg_process_stats *ps;
949		int ps_size, x;
950	+	#else
951	+	DWORD aProcesses[1024];
952	+	DWORD cbNeeded;
953	+	#endif
954
955		process_stat.sleeping = 0;
956		process_stat.running = 0;
#	Line 762 | Line 958 | sg_process_count *sg_get_process_count() {
958		process_stat.stopped = 0;
959		process_stat.total = 0;
960
961	+	#ifndef WIN32
962		ps = sg_get_process_stats(&ps_size);
963		if (ps == NULL) {
964		return NULL;
#	Line 790 | Line 987 | sg_process_count *sg_get_process_count() {
987		}
988
989		process_stat.total = ps_size;
990	+	#else
991	+	if (!EnumProcesses(aProcesses, sizeof(aProcesses), &cbNeeded))
992	+	return NULL;
993	+	process_stat.total = cbNeeded / sizeof(DWORD);
994	+	#endif
995
996		return &process_stat;
997		}

Diff Legend

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