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.22 by tdb, Mon Feb 16 14:55:32 2004 UTC vs.
Revision 1.25 by pajs, Tue Mar 30 13:41:31 2004 UTC

#	Line 34 | Line 34
34		#include <string.h>
35		#endif
36
37	–	#include "tools.h"
37		#ifdef SOLARIS
38		#include <procfs.h>
39		#include <limits.h>
#	Line 43 | Line 42
42		#endif
43		#ifdef LINUX
44		#include <limits.h>
45	+	#include <unistd.h>
46	+	#include <sys/stat.h>
47	+	#include <fcntl.h>
48		#define PROC_LOCATION "/proc"
49		#define MAX_FILE_LENGTH PATH_MAX
50		#endif
#	Line 57 | Line 59
59		#endif
60		#endif
61
62	<	process_stat_t *get_process_stats(){
63	<
64	<	static process_stat_t process_stat;
65	<
62	>	int get_proc_snapshot(proc_state_t **ps){
63	>	proc_state_t *proc_state = NULL;
64	>	proc_state_t *proc_state_ptr;
65	>	int proc_state_size = 0;
66		#if defined(SOLARIS) || defined(LINUX)
67	<	DIR *proc_dir;
68	<	struct dirent *dir_entry;
69	<	char filename[MAX_FILE_LENGTH];
70	<	FILE *f;
69	<	#endif
70	<	#ifdef LINUX
71	<	char *line_ptr;
72	<	#endif
67	>	DIR *proc_dir;
68	>	struct dirent *dir_entry;
69	>	char filename[MAX_FILE_LENGTH];
70	>	FILE *f;
71		#ifdef SOLARIS
72		psinfo_t process_info;
73		#endif
74	<	#ifdef ALLBSD
75	<	int mib[3];
76	<	size_t size;
77	<	struct kinfo_proc *kp_stats;
78	<	int procs, i;
74	>	#ifdef LINUX
75	>	char s;
76	>	/* If someone has a executable of 4k filename length, they deserve to get it truncated :) */
77	>	char ps_name[4096];
78	>	char *ptr;
79	>	static char *psargs = NULL;
80	>	static int psarg_size = 0;
81	>	unsigned long stime, utime;
82	>	int x;
83	>	int fn;
84	>	int toread;
85	>	ssize_t size;
86	>	int t_read;
87		#endif
88
89	<	process_stat.sleeping=0;
90	<	process_stat.running=0;
91	<	process_stat.zombie=0;
86	<	process_stat.stopped=0;
87	<	process_stat.total=0;
89	>	if((proc_dir=opendir(PROC_LOCATION))==NULL){
90	>	return -1;
91	>	}
92
93	<	#if defined(SOLARIS) || defined(LINUX)
94	<	if((proc_dir=opendir(PROC_LOCATION))==NULL){
91	<	return NULL;
92	<	}
93	>	while((dir_entry=readdir(proc_dir))!=NULL){
94	>	if(atoi(dir_entry->d_name) == 0) continue;
95
94	–	while((dir_entry=readdir(proc_dir))!=NULL){
95	–	if(atoi(dir_entry->d_name) == 0) continue;
96	–
96		#ifdef SOLARIS
97	<	snprintf(filename, MAX_FILE_LENGTH, "/proc/%s/psinfo", dir_entry->d_name);
97	>	snprintf(filename, MAX_FILE_LENGTH, "/proc/%s/psinfo", dir_entry->d_name);
98		#endif
99		#ifdef LINUX
100	<	snprintf(filename, MAX_FILE_LENGTH, "/proc/%s/status", dir_entry->d_name);
100	>	snprintf(filename, MAX_FILE_LENGTH, "/proc/%s/stat", dir_entry->d_name);
101		#endif
102	<
103	<	if((f=fopen(filename, "r"))==NULL){
104	<	/* Open failed.. Process since vanished, or the path was too long.
105	<	* Ah well, move onwards to the next one */
106	<	continue;
108	<	}
109	<
102	>	if((f=fopen(filename, "r"))==NULL){
103	>	/* Open failed.. Process since vanished, or the path was too long.
104	>	* Ah well, move onwards to the next one */
105	>	continue;
106	>	}
107		#ifdef SOLARIS
108	<	fread(&process_info, sizeof(psinfo_t), 1, f);
112	<	if(process_info.pr_lwp.pr_state==1) process_stat.sleeping++;
113	<	if(process_info.pr_lwp.pr_state==2) process_stat.running++;
114	<	if(process_info.pr_lwp.pr_state==3) process_stat.zombie++;
115	<	if(process_info.pr_lwp.pr_state==4) process_stat.stopped++;
116	<	if(process_info.pr_lwp.pr_state==6) process_stat.running++;
108	>	fread(&process_info, sizeof(psinfo_t), 1, f);
109		#endif
118	–	#ifdef LINUX
119	–	if((line_ptr=f_read_line(f, "State:"))==NULL){
120	–	fclose(f);
121	–	continue;
122	–	}
123	–	if((line_ptr=strchr(line_ptr, '\t'))==NULL){
124	–	fclose(f);
125	–	continue;
126	–	}
127	–	line_ptr++;
128	–	if(line_ptr=='\0'){
129	–	fclose(f);
130	–	continue;
131	–	}
110
111	<	if(*line_ptr=='S') process_stat.sleeping++;
112	<	if(*line_ptr=='R') process_stat.running++;
113	<	if(*line_ptr=='Z') process_stat.zombie++;
114	<	if(*line_ptr=='T') process_stat.stopped++;
115	<	if(*line_ptr=='D') process_stat.stopped++;
116	<	#endif
111	>	proc_state = realloc(proc_state, (1+proc_state_size)*sizeof(proc_state_t));
112	>	proc_state_ptr = proc_state+proc_state_size;
113	>	#ifdef SOLARIS
114	>	proc_state_ptr->pid = process_info.pr_pid;
115	>	proc_state_ptr->parent = process_info.pr_ppid;
116	>	proc_state_ptr->pgid = process_info.pr_pgid;
117	>	proc_state_ptr->uid = process_info.pr_uid;
118	>	proc_state_ptr->euid = process_info.pr_euid;
119	>	proc_state_ptr->gid = process_info.pr_gid;
120	>	proc_state_ptr->egid = process_info.pr_egid;
121	>	proc_state_ptr->proc_size = (process_info.pr_size) * 1024;
122	>	proc_state_ptr->proc_resident = (process_info.pr_rssize) * 1024;
123	>	proc_state_ptr->time_spent = process_info.pr_time.tv_sec;
124	>	proc_state_ptr->cpu_percent = (process_info.pr_pctcpu * 100.0) / 0x8000;
125	>	proc_state_ptr->process_name = strdup(process_info.pr_fname);
126	>	proc_state_ptr->proctitle = strdup(process_info.pr_psargs);
127
128	<	fclose(f);
129	<	}
130	<	closedir(proc_dir);
128	>	if(process_info.pr_lwp.pr_state==1) proc_state_ptr->state = SLEEPING;
129	>	if(process_info.pr_lwp.pr_state==2) proc_state_ptr->state = RUNNING;
130	>	if(process_info.pr_lwp.pr_state==3) proc_state_ptr->state = ZOMBIE;
131	>	if(process_info.pr_lwp.pr_state==4) proc_state_ptr->state = STOPPED;
132	>	if(process_info.pr_lwp.pr_state==6) proc_state_ptr->state = RUNNING;
133		#endif
134	<	#ifdef ALLBSD
135	<	mib[0] = CTL_KERN;
136	<	mib[1] = KERN_PROC;
137	<	mib[2] = KERN_PROC_ALL;
134	>	#ifdef LINUX
135	>	x = fscanf(f, "%d %4096s %c %d %d %*d %*d %*d %*lu %*lu %*lu %*lu %*lu %lu %lu %*ld %*ld %*ld %d %*ld %*ld %*lu %llu %llu %*lu %*lu %*lu %*lu %*lu %*lu %*lu %*lu %*lu %*lu %*lu %*lu %*lu %*d %*d\n", &(proc_state_ptr->pid), ps_name, &s, &(proc_state_ptr->parent), &(proc_state_ptr->pgid), &utime, &stime, &(proc_state_ptr->nice), &(proc_state_ptr->proc_size), &(proc_state_ptr->proc_resident));
136	>	proc_state_ptr->proc_resident = proc_state_ptr->proc_resident * getpagesize();
137	>	if(s == 'S') proc_state_ptr->state = SLEEPING;
138	>	if(s == 'R') proc_state_ptr->state = RUNNING;
139	>	if(s == 'Z') proc_state_ptr->state = ZOMBIE;
140	>	if(s == 'T') proc_state_ptr->state = STOPPED;
141	>	if(s == 'D') proc_state_ptr->state = STOPPED;
142	>
143	>	/* pa_name[0] should = '(' */
144	>	ptr = strchr(&ps_name[1], ')');
145	>	if(ptr !=NULL) *ptr='\0';
146	>	proc_state_ptr->process_name = strdup(&ps_name[1]);
147
148	<	if (sysctl(mib, 3, NULL, &size, NULL, 0) < 0) {
149	<	return NULL;
151	<	}
152	<
153	<	procs = size / sizeof(struct kinfo_proc);
148	>	/* Need to do cpu */
149	>
150
151	<	kp_stats = malloc(size);
152	<	if (kp_stats == NULL) {
157	<	return NULL;
158	<	}
159	<
160	<	if (sysctl(mib, 3, kp_stats, &size, NULL, 0) < 0) {
161	<	free(kp_stats);
162	<	return NULL;
163	<	}
151	>	/* proctitle */
152	>	snprintf(filename, MAX_FILE_LENGTH, "/proc/%s/cmdline", dir_entry->d_name);
153
154	<	for (i = 0; i < procs; i++) {
155	<	#ifdef FREEBSD5
156	<	switch (kp_stats[i].ki_stat) {
157	<	#else
169	<	switch (kp_stats[i].kp_proc.p_stat) {
170	<	#endif
171	<	case SIDL:
172	<	case SRUN:
173	<	#ifdef SONPROC
174	<	case SONPROC: /* NetBSD */
175	<	#endif
176	<	process_stat.running++;
177	<	break;
178	<	case SSLEEP:
179	<	#ifdef SWAIT
180	<	case SWAIT: /* FreeBSD 5 */
181	<	#endif
182	<	#ifdef SLOCK
183	<	case SLOCK: /* FreeBSD 5 */
184	<	#endif
185	<	process_stat.sleeping++;
186	<	break;
187	<	case SSTOP:
188	<	process_stat.stopped++;
189	<	break;
190	<	case SZOMB:
191	<	#ifdef SDEAD
192	<	case SDEAD: /* OpenBSD & NetBSD */
193	<	#endif
194	<	process_stat.zombie++;
195	<	break;
154	>	if((fn=open(filename, O_RDONLY)) == -1){
155	>	/* Open failed.. Process since vanished, or the path was too long.
156	>	* Ah well, move onwards to the next one */
157	>	continue;
158		}
159	<	}
159	>	#define         PSARG_START_SIZE 128
160	>	if(psargs == NULL){
161	>	psargs = malloc(PSARG_START_SIZE);
162	>	psarg_size = PSARG_START_SIZE;
163	>	}
164	>	ptr = psargs;
165	>	t_read = 0;
166	>	toread = psarg_size;
167	>	while((size = read(fn, ptr, toread)) == toread){
168	>	psargs = realloc(psargs, (psarg_size + PSARG_START_SIZE));
169	>	ptr = psargs+psarg_size;
170	>	t_read = psarg_size;
171	>	psarg_size+=PSARG_START_SIZE;
172	>	toread = PSARG_START_SIZE;
173	>	}
174	>	if(size != -1) t_read+=size;
175
176	<	free(kp_stats);
176	>	ptr = psargs;
177	>	for(x=0; x<t_read; x++){
178	>	if (*ptr == '\0') *ptr = ' ';
179	>	ptr++;
180	>	}
181	>	/*  for safety sake */
182	>	psargs[t_read] = '\0';
183	>
184	>	proc_state_ptr->proctitle = strdup(psargs);
185	>
186		#endif
187
188	<	#ifdef CYGWIN
203	<	return NULL;
188	>	proc_state_size++;
189		#endif
190
206	–	process_stat.total=process_stat.sleeping+process_stat.running+process_stat.zombie+process_stat.stopped;
191
192	<	return &process_stat;
192	>	fclose(f);
193	>	}
194	>	closedir(proc_dir);
195	>	*ps = proc_state;
196	>
197	>	return proc_state_size;
198		}
199	+

Diff Legend

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