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.27 by tdb, Fri Apr 2 21:20:23 2004 UTC vs.
Revision 1.50 by tdb, Mon Apr 5 09:33:38 2004 UTC

#	Line 26 | Line 26
26		#endif
27
28		#include "statgrab.h"
29	+	#include "tools.h"
30	+	#include "vector.h"
31		#if defined(SOLARIS) || defined(LINUX)
32		#include <stdio.h>
33		#include <stdlib.h>
#	Line 57 | Line 59
59		#else
60		#include <sys/proc.h>
61		#endif
62	+	#include <string.h>
63	+	#include <paths.h>
64	+	#include <fcntl.h>
65	+	#include <limits.h>
66	+	#if (defined(FREEBSD) && !defined(FREEBSD5)) || defined(DFBSD)
67	+	#include <kvm.h>
68	+	#include <tools.h>
69		#endif
70	+	#include <unistd.h>
71	+	#endif
72
73	+	static void proc_state_init(proc_state_t *s) {
74	+	s->process_name = NULL;
75	+	s->proctitle = NULL;
76	+	}
77	+
78	+	static void proc_state_destroy(proc_state_t *s) {
79	+	free(s->process_name);
80	+	free(s->proctitle);
81	+	}
82	+
83		int get_proc_snapshot(proc_state_t **ps){
84	<	proc_state_t *proc_state = NULL;
85	<	proc_state_t *proc_state_ptr;
84	>	VECTOR_DECLARE_STATIC(proc_state, proc_state_t, 64,
85	>	proc_state_init, proc_state_destroy);
86		int proc_state_size = 0;
87	+	proc_state_t *proc_state_ptr;
88		#ifdef ALLBSD
89	<	int mib[3];
89	>	int mib[4];
90		size_t size;
91		struct kinfo_proc *kp_stats;
92		int procs, i;
93	+	char *proctitle;
94	+	#if (defined(FREEBSD) && !defined(FREEBSD5)) || defined(DFBSD)
95	+	kvm_t *kvmd;
96	+	char **args, **argsp;
97	+	int argslen = 0;
98	+	#else
99	+	long buflen;
100	+	char *p;
101		#endif
102	+	#endif
103		#if defined(SOLARIS) || defined(LINUX)
104		DIR *proc_dir;
105		struct dirent *dir_entry;
#	Line 82 | Line 113 | int get_proc_snapshot(proc_state_t **ps){
113		/* If someone has a executable of 4k filename length, they deserve to get it truncated :) */
114		char ps_name[4096];
115		char *ptr;
116	<	static char *psargs = NULL;
86	<	static int psarg_size = 0;
116	>	VECTOR_DECLARE_STATIC(psargs, char, 128, NULL, NULL);
117		unsigned long stime, utime;
118		int x;
119		int fn;
120	<	int toread;
121	<	ssize_t size;
92	<	int t_read;
120	>	int len;
121	>	int rc;
122		#endif
123
124		if((proc_dir=opendir(PROC_LOCATION))==NULL){
#	Line 114 | Line 143 | int get_proc_snapshot(proc_state_t **ps){
143		fread(&process_info, sizeof(psinfo_t), 1, f);
144		#endif
145
146	<	proc_state = realloc(proc_state, (1+proc_state_size)*sizeof(proc_state_t));
146	>	if (VECTOR_RESIZE(proc_state, proc_state_size + 1) < 0) {
147	>	return -1;
148	>	}
149		proc_state_ptr = proc_state+proc_state_size;
150	+
151		#ifdef SOLARIS
152		proc_state_ptr->pid = process_info.pr_pid;
153		proc_state_ptr->parent = process_info.pr_ppid;
#	Line 138 | Line 170 | int get_proc_snapshot(proc_state_t **ps){
170		if(process_info.pr_lwp.pr_state==6) proc_state_ptr->state = RUNNING;
171		#endif
172		#ifdef LINUX
173	<	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));
173	>	x = fscanf(f, "%d %4096s %c %d %d %*d %*d %*d %*u %*u %*u %*u %*u %lu %lu %*d %*d %*d %d %*d %*d %*u %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), &(proc_state_ptr->proc_size), &(proc_state_ptr->proc_resident));
174		proc_state_ptr->proc_resident = proc_state_ptr->proc_resident * getpagesize();
175		if(s == 'S') proc_state_ptr->state = SLEEPING;
176		if(s == 'R') proc_state_ptr->state = RUNNING;
#	Line 149 | Line 181 | int get_proc_snapshot(proc_state_t **ps){
181		/* pa_name[0] should = '(' */
182		ptr = strchr(&ps_name[1], ')');
183		if(ptr !=NULL) *ptr='\0';
152	–	proc_state_ptr->process_name = strdup(&ps_name[1]);
184
185	+	if (update_string(&proc_state_ptr->process_name,
186	+	&ps_name[1]) == NULL) {
187	+	return -1;
188	+	}
189	+
190		/* Need to do cpu */
191
192
193	+	fclose(f);
194	+
195		/* proctitle */
196		snprintf(filename, MAX_FILE_LENGTH, "/proc/%s/cmdline", dir_entry->d_name);
197
#	Line 162 | Line 200 | int get_proc_snapshot(proc_state_t **ps){
200		* Ah well, move onwards to the next one */
201		continue;
202		}
203	<	#define         PSARG_START_SIZE 128
204	<	if(psargs == NULL){
205	<	psargs = malloc(PSARG_START_SIZE);
206	<	psarg_size = PSARG_START_SIZE;
203	>
204	>	#define READ_BLOCK_SIZE 128
205	>	len = 0;
206	>	do {
207	>	if (VECTOR_RESIZE(psargs, len + READ_BLOCK_SIZE + 1) < 0) {
208	>	return -1;
209	>	}
210	>	rc = read(fn, psargs + len, READ_BLOCK_SIZE);
211	>	if (rc > 0) {
212	>	len += rc;
213	>	}
214	>	} while (rc == READ_BLOCK_SIZE);
215	>	close(fn);
216	>
217	>	if (rc == -1) {
218	>	/* Read failed; move on. */
219	>	continue;
220		}
170	–	ptr = psargs;
171	–	t_read = 0;
172	–	toread = psarg_size;
173	–	while((size = read(fn, ptr, toread)) == toread){
174	–	psargs = realloc(psargs, (psarg_size + PSARG_START_SIZE));
175	–	ptr = psargs+psarg_size;
176	–	t_read = psarg_size;
177	–	psarg_size+=PSARG_START_SIZE;
178	–	toread = PSARG_START_SIZE;
179	–	}
180	–	if(size != -1) t_read+=size;
221
222	+	/* Turn \0s into spaces within the command line. */
223		ptr = psargs;
224	<	for(x=0; x<t_read; x++){
224	>	for(x = 0; x < len; x++) {
225		if (*ptr == '\0') *ptr = ' ';
226		ptr++;
227		}
228	<	/*  for safety sake */
229	<	psargs[t_read] = '\0';
228	>	/* for safety's sake */
229	>	psargs[len] = '\0';
230
231	<	proc_state_ptr->proctitle = strdup(psargs);
232	<
231	>	if (update_string(&proc_state_ptr->proctitle, psargs) == NULL) {
232	>	return -1;
233	>	}
234		#endif
235
236		proc_state_size++;
195	–
196	–	fclose(f);
237		}
238		closedir(proc_dir);
239		#endif
#	Line 203 | Line 243 | int get_proc_snapshot(proc_state_t **ps){
243		mib[1] = KERN_PROC;
244		mib[2] = KERN_PROC_ALL;
245
246	<	if (sysctl(mib, 3, NULL, &size, NULL, 0) < 0) {
247	<	return NULL;
246	>	if(sysctl(mib, 3, NULL, &size, NULL, 0) < 0) {
247	>	return -1;
248		}
249
250		procs = size / sizeof(struct kinfo_proc);
251
252		kp_stats = malloc(size);
253	<	if (kp_stats == NULL) {
254	<	return NULL;
253	>	if(kp_stats == NULL) {
254	>	return -1;
255		}
256
257	<	if (sysctl(mib, 3, kp_stats, &size, NULL, 0) < 0) {
257	>	if(sysctl(mib, 3, kp_stats, &size, NULL, 0) < 0) {
258		free(kp_stats);
259	<	return NULL;
259	>	return -1;
260		}
261
262	+	#if (defined(FREEBSD) && !defined(FREEBSD5)) || defined(DFBSD)
263	+	kvmd = get_kvm2();
264	+	#endif
265	+
266		for (i = 0; i < procs; i++) {
267	<	proc_state = realloc(proc_state, (1+proc_state_size)*sizeof(proc_state_t));
267	>	const char *name;
268	>
269	>	if (VECTOR_RESIZE(proc_state, proc_state_size + 1) < 0) {
270	>	return -1;
271	>	}
272		proc_state_ptr = proc_state+proc_state_size;
225	–
226	–	proc_state_ptr->process_name = strdup(kp_stats[i].ki_comm);
227	–	/* Seems we don't have access to that bit of memory */
228	–	/*proc_state_ptr->proctitle = strdup(kp_stats[i].ki_args->ar_args);*/
273
274	+	#ifdef FREEBSD5
275	+	name = kp_stats[i].ki_comm;
276	+	#elif defined(DFBSD)
277	+	name = kp_stats[i].kp_thread.td_comm;
278	+	#else
279	+	name = kp_stats[i].kp_proc.p_comm;
280	+	#endif
281	+	if (update_string(&proc_state_ptr->process_name, name) == NULL) {
282	+	return -1;
283	+	}
284	+
285	+	#if defined(FREEBSD5) || defined(NETBSD) || defined(OPENBSD)
286	+	size = sizeof(buflen);
287	+
288	+	#ifdef FREEBSD5
289	+	if(sysctlbyname("kern.ps_arg_cache_limit", &buflen, &size, NULL, 0) < 0) {
290	+	return -1;
291	+	}
292	+	#else
293	+	mib[1] = KERN_ARGMAX;
294	+
295	+	if(sysctl(mib, 2, &buflen, &size, NULL, 0) < 0) {
296	+	return -1;
297	+	}
298	+	#endif
299	+
300	+	proctitle = malloc(buflen);
301	+	if(proctitle == NULL) {
302	+	return -1;
303	+	}
304	+
305	+	size = buflen;
306	+
307	+	#ifdef FREEBSD5
308	+	mib[2] = KERN_PROC_ARGS;
309	+	mib[3] = kp_stats[i].ki_pid;
310	+	#else
311	+	mib[1] = KERN_PROC_ARGS;
312	+	mib[2] = kp_stats[i].kp_proc.p_pid;
313	+	mib[3] = KERN_PROC_ARGV;
314	+	#endif
315	+
316	+	free(proc_state_ptr->proctitle);
317	+	if(sysctl(mib, 4, proctitle, &size, NULL, 0) < 0) {
318	+	free(proctitle);
319	+	proc_state_ptr->proctitle = NULL;
320	+	}
321	+	else if(size > 0) {
322	+	proc_state_ptr->proctitle = malloc(size+1);
323	+	if(proc_state_ptr->proctitle == NULL) {
324	+	return -1;
325	+	}
326	+	p = proctitle;
327	+	proc_state_ptr->proctitle[0] = '\0';
328	+	do {
329	+	strlcat(proc_state_ptr->proctitle, p, size+1);
330	+	strlcat(proc_state_ptr->proctitle, " ", size+1);
331	+	p += strlen(p) + 1;
332	+	} while (p < proctitle + size);
333	+	free(proctitle);
334	+	/* remove trailing space */
335	+	proc_state_ptr->proctitle[strlen(proc_state_ptr->proctitle)-1] = '\0';
336	+	}
337	+	else {
338	+	free(proctitle);
339	+	proc_state_ptr->proctitle = NULL;
340	+	}
341	+	#else
342	+	free(proc_state_ptr->proctitle);
343	+	if(kvmd != NULL) {
344	+	args = kvm_getargv(kvmd, &(kp_stats[i]), 0);
345	+	if(args != NULL) {
346	+	argsp = args;
347	+	while(*argsp != NULL) {
348	+	argslen += strlen(*args);
349	+	args++;
350	+	}
351	+	proctitle = malloc(argslen + 1);
352	+	proctitle[0] = '\0';
353	+	if(proctitle == NULL) {
354	+	return -1;
355	+	}
356	+	while(*args != NULL) {
357	+	strlcat(proctitle, *args, argslen);
358	+	strlcat(proctitle, " ", argslen);
359	+	args++;
360	+	}
361	+	/* remove trailing space */
362	+	proctitle[strlen(proctitle)-1] = '\0';
363	+	proc_state_ptr->proctitle = proctitle;
364	+	}
365	+	else {
366	+	proc_state_ptr->proctitle = NULL;
367	+	}
368	+	}
369	+	else {
370	+	proc_state_ptr->proctitle = NULL;
371	+	}
372	+	#endif
373	+
374	+	#ifdef FREEBSD5
375		proc_state_ptr->pid = kp_stats[i].ki_pid;
376		proc_state_ptr->parent = kp_stats[i].ki_ppid;
377		proc_state_ptr->pgid = kp_stats[i].ki_pgid;
378	+	#else
379	+	proc_state_ptr->pid = kp_stats[i].kp_proc.p_pid;
380	+	proc_state_ptr->parent = kp_stats[i].kp_eproc.e_ppid;
381	+	proc_state_ptr->pgid = kp_stats[i].kp_eproc.e_pgid;
382	+	#endif
383
384	+	#ifdef FREEBSD5
385		proc_state_ptr->uid = kp_stats[i].ki_ruid;
386		proc_state_ptr->euid = kp_stats[i].ki_uid;
387		proc_state_ptr->gid = kp_stats[i].ki_rgid;
388		proc_state_ptr->egid = kp_stats[i].ki_svgid;
389	+	#elif defined(DFBSD)
390	+	proc_state_ptr->uid = kp_stats[i].kp_eproc.e_ucred.cr_ruid;
391	+	proc_state_ptr->euid = kp_stats[i].kp_eproc.e_ucred.cr_svuid;
392	+	proc_state_ptr->gid = kp_stats[i].kp_eproc.e_ucred.cr_rgid;
393	+	proc_state_ptr->egid = kp_stats[i].kp_eproc.e_ucred.cr_svgid;
394	+	#else
395	+	proc_state_ptr->uid = kp_stats[i].kp_eproc.e_pcred.p_ruid;
396	+	proc_state_ptr->euid = kp_stats[i].kp_eproc.e_pcred.p_svuid;
397	+	proc_state_ptr->gid = kp_stats[i].kp_eproc.e_pcred.p_rgid;
398	+	proc_state_ptr->egid = kp_stats[i].kp_eproc.e_pcred.p_svgid;
399	+	#endif
400
401	+	#ifdef FREEBSD5
402		proc_state_ptr->proc_size = kp_stats[i].ki_size;
403		/* This is in pages */
404	<	proc_state_ptr->proc_resident = kp_stats[i].ki_rssize * getpagesize();
405	<	/* This seems to be in microseconds */
404	>	proc_state_ptr->proc_resident =
405	>	kp_stats[i].ki_rssize * getpagesize();
406	>	/* This is in microseconds */
407		proc_state_ptr->time_spent = kp_stats[i].ki_runtime / 1000000;
408	<	proc_state_ptr->cpu_percent = kp_stats[i].ki_pctcpu;
408	>	proc_state_ptr->cpu_percent =
409	>	((double)kp_stats[i].ki_pctcpu / FSCALE) * 100.0;
410		proc_state_ptr->nice = kp_stats[i].ki_nice;
411	+	#else
412	+	proc_state_ptr->proc_size =
413	+	kp_stats[i].kp_eproc.e_vm.vm_map.size;
414	+	/* This is in pages */
415	+	proc_state_ptr->proc_resident =
416	+	kp_stats[i].kp_eproc.e_vm.vm_rssize * getpagesize();
417	+	#if defined(NETBSD) || defined(OPENBSD)
418	+	proc_state_ptr->time_spent =
419	+	kp_stats[i].kp_proc.p_rtime.tv_sec;
420	+	#elif defined(DFBSD)
421	+	proc_state_ptr->time_spent =
422	+	( kp_stats[i].kp_thread.td_uticks +
423	+	kp_stats[i].kp_thread.td_sticks +
424	+	kp_stats[i].kp_thread.td_iticks ) / 1000000;
425	+	#else
426	+	/* This is in microseconds */
427	+	proc_state_ptr->time_spent =
428	+	kp_stats[i].kp_proc.p_runtime / 1000000;
429	+	#endif
430	+	proc_state_ptr->cpu_percent =
431	+	((double)kp_stats[i].kp_proc.p_pctcpu / FSCALE) * 100.0;
432	+	proc_state_ptr->nice = kp_stats[i].kp_proc.p_nice;
433	+	#endif
434
435	+	#ifdef FREEBSD5
436		switch (kp_stats[i].ki_stat) {
437	+	#else
438	+	switch (kp_stats[i].kp_proc.p_stat) {
439	+	#endif
440		case SIDL:
441		case SRUN:
442		#ifdef SONPROC
#	Line 270 | Line 462 | int get_proc_snapshot(proc_state_t **ps){
462		#endif
463		proc_state_ptr->state = ZOMBIE;
464		break;
465	+	default:
466	+	proc_state_ptr->state = UNKNOWN;
467	+	break;
468		}
469		proc_state_size++;
470		}
#	Line 277 | Line 472 | int get_proc_snapshot(proc_state_t **ps){
472		free(kp_stats);
473		#endif
474
475	+	#ifdef CYGWIN
476	+	return -1;
477	+	#endif
478	+
479		*ps = proc_state;
480		return proc_state_size;
481		}
#	Line 286 | Line 485 | process_stat_t *get_process_stats() {
485		proc_state_t *ps;
486		int ps_size, x;
487
488	<	process_stat.sleeping=0;
489	<	process_stat.running=0;
490	<	process_stat.zombie=0;
491	<	process_stat.stopped=0;
492	<	process_stat.total=0;
488	>	process_stat.sleeping = 0;
489	>	process_stat.running = 0;
490	>	process_stat.zombie = 0;
491	>	process_stat.stopped = 0;
492	>	process_stat.total = 0;
493
494		ps_size = get_proc_snapshot(&ps);
495
496	+	if(ps_size < 0) {
497	+	return NULL;
498	+	}
499	+
500		for(x = 0; x < ps_size; x++) {
501		switch (ps->state) {
502		case RUNNING:
#	Line 307 | Line 510 | process_stat_t *get_process_stats() {
510		break;
511		case ZOMBIE:
512		process_stat.zombie++;
513	+	break;
514	+	default:
515	+	/* currently no mapping for UNKNOWN in process_stat_t */
516		break;
517		}
518		ps++;

Diff Legend

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