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.52 by ats, Mon Apr 5 15:40:15 2004 UTC vs.
Revision 1.57 by tdb, Tue Apr 6 14:52:58 2004 UTC

#	Line 1 | Line 1
1		/*
2	<	* i-scream central monitoring system
2	>	* i-scream libstatgrab
3		* http://www.i-scream.org
4		* Copyright (C) 2000-2004 i-scream
5		*
#	Line 68 | Line 68
68		#include <tools.h>
69		#endif
70		#include <unistd.h>
71	+	#ifdef NETBSD2
72	+	#include <sys/lwp.h>
73		#endif
74	+	#endif
75
76		static void proc_state_init(sg_process_stats *s) {
77		s->process_name = NULL;
#	Line 99 | Line 102 | sg_process_stats *sg_get_process_stats(int *entries){
102		long buflen;
103		char *p;
104		#endif
105	+	#ifdef NETBSD2
106	+	int lwps;
107	+	struct kinfo_lwp *kl_stats;
108		#endif
109	+	#endif
110		#if defined(SOLARIS) || defined(LINUX)
111		DIR *proc_dir;
112		struct dirent *dir_entry;
#	Line 183 | Line 190 | sg_process_stats *sg_get_process_stats(int *entries){
190		if(ptr !=NULL) *ptr='\0';
191
192		if (sg_update_string(&proc_state_ptr->process_name,
193	<	&ps_name[1]) == NULL) {
193	>	&ps_name[1]) < 0) {
194		return NULL;
195		}
196
#	Line 204 | Line 211 | sg_process_stats *sg_get_process_stats(int *entries){
211		#define READ_BLOCK_SIZE 128
212		len = 0;
213		do {
214	<	if (VECTOR_RESIZE(psargs, len + READ_BLOCK_SIZE + 1) < 0) {
214	>	if (VECTOR_RESIZE(psargs, len + READ_BLOCK_SIZE) < 0) {
215		return NULL;
216		}
217		rc = read(fn, psargs + len, READ_BLOCK_SIZE);
#	Line 225 | Line 232 | sg_process_stats *sg_get_process_stats(int *entries){
232		if (*ptr == '\0') *ptr = ' ';
233		ptr++;
234		}
228	–	/* for safety's sake */
229	–	psargs[len] = '\0';
235
236	<	if (sg_update_string(&proc_state_ptr->proctitle, psargs) == NULL) {
236	>	if (len == 0) {
237	>	/* We want psargs to be NULL. */
238	>	if (VECTOR_RESIZE(psargs, 0) < 0) {
239	>	return NULL;
240	>	}
241	>	} else {
242	>	/* Not empty, so append a \0. */
243	>	if (VECTOR_RESIZE(psargs, len + 1) < 0) {
244	>	return NULL;
245	>	}
246	>	psargs[len] = '\0';
247	>	}
248	>
249	>	if (sg_update_string(&proc_state_ptr->proctitle, psargs) < 0) {
250		return NULL;
251		}
252		#endif
#	Line 253 | Line 271 | sg_process_stats *sg_get_process_stats(int *entries){
271		if(kp_stats == NULL) {
272		return NULL;
273		}
274	+	memset(kp_stats, 0, size);
275
276		if(sysctl(mib, 3, kp_stats, &size, NULL, 0) < 0) {
277		free(kp_stats);
#	Line 266 | Line 285 | sg_process_stats *sg_get_process_stats(int *entries){
285		for (i = 0; i < procs; i++) {
286		const char *name;
287
288	+	#ifdef FREEBSD5
289	+	if (kp_stats[i].ki_stat == 0) {
290	+	#else
291	+	if (kp_stats[i].kp_proc.p_stat == 0) {
292	+	#endif
293	+	/* FreeBSD 5 deliberately overallocates the array that
294	+	* the sysctl returns, so we'll get a few junk
295	+	* processes on the end that we have to ignore. (Search
296	+	* for "overestimate by 5 procs" in
297	+	* src/sys/kern/kern_proc.c for more details.) */
298	+	continue;
299	+	}
300	+
301		if (VECTOR_RESIZE(proc_state, proc_state_size + 1) < 0) {
302		return NULL;
303		}
#	Line 278 | Line 310 | sg_process_stats *sg_get_process_stats(int *entries){
310		#else
311		name = kp_stats[i].kp_proc.p_comm;
312		#endif
313	<	if (sg_update_string(&proc_state_ptr->process_name, name) == NULL) {
313	>	if (sg_update_string(&proc_state_ptr->process_name, name) < 0) {
314		return NULL;
315		}
316
#	Line 290 | Line 322 | sg_process_stats *sg_get_process_stats(int *entries){
322		return NULL;
323		}
324		#else
325	+	/* FIXME - this value can be too large on some of
326	+	the BSD's, which causes sysctl not to return
327	+	anything. Maybe we need something smaller? */
328		mib[1] = KERN_ARGMAX;
329
330		if(sysctl(mib, 2, &buflen, &size, NULL, 0) < 0) {
#	Line 432 | Line 467 | sg_process_stats *sg_get_process_stats(int *entries){
467		proc_state_ptr->nice = kp_stats[i].kp_proc.p_nice;
468		#endif
469
470	+	#ifdef NETBSD2
471	+	{
472	+	size_t size;
473	+	int mib[5];
474	+
475	+	mib[0] = CTL_KERN;
476	+	mib[1] = KERN_LWP;
477	+	mib[2] = kp_stats[i].kp_proc.p_pid;
478	+	mib[3] = sizeof(struct kinfo_lwp);
479	+	mib[4] = 0;
480	+
481	+	if(sysctl(mib, 5, NULL, &size, NULL, 0) < 0) {
482	+	return NULL;
483	+	}
484	+
485	+	lwps = size / sizeof(struct kinfo_lwp);
486	+	mib[4] = lwps;
487	+
488	+	kl_stats = malloc(size);
489	+	if(kl_stats == NULL) {
490	+	return NULL;
491	+	}
492	+
493	+	if(sysctl(mib, 5, kl_stats, &size, NULL, 0) < 0) {
494	+	return NULL;
495	+	}
496	+	}
497	+
498	+	switch(kp_stats[i].kp_proc.p_stat) {
499	+	case SIDL:
500	+	proc_state_ptr->state = SG_PROCESS_STATE_RUNNING;
501	+	break;
502	+	case SACTIVE:
503	+	{
504	+	int i;
505	+
506	+	for(i = 0; i < lwps; i++) {
507	+	switch(kl_stats[i].l_stat) {
508	+	case LSONPROC:
509	+	case LSRUN:
510	+	proc_state_ptr->state = SG_PROCESS_STATE_RUNNING;
511	+	goto end;
512	+	case LSSLEEP:
513	+	proc_state_ptr->state = SG_PROCESS_STATE_SLEEPING;
514	+	goto end;
515	+	case LSSTOP:
516	+	case LSSUSPENDED:
517	+	proc_state_ptr->state = SG_PROCESS_STATE_STOPPED;
518	+	goto end;
519	+	}
520	+	proc_state_ptr->state = SG_PROCESS_STATE_UNKNOWN;
521	+	}
522	+	end: ;
523	+	}
524	+	break;
525	+	case SSTOP:
526	+	proc_state_ptr->state = SG_PROCESS_STATE_STOPPED;
527	+	break;
528	+	case SZOMB:
529	+	proc_state_ptr->state = SG_PROCESS_STATE_ZOMBIE;
530	+	break;
531	+	default:
532	+	proc_state_ptr->state = SG_PROCESS_STATE_UNKNOWN;
533	+	break;
534	+	}
535	+	#else
536		#ifdef FREEBSD5
537		switch (kp_stats[i].ki_stat) {
538		#else
#	Line 466 | Line 567 | sg_process_stats *sg_get_process_stats(int *entries){
567		proc_state_ptr->state = SG_PROCESS_STATE_UNKNOWN;
568		break;
569		}
570	+	#endif
571		proc_state_size++;
572		}
573

Diff Legend

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