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.45 by tdb, Sun Apr 4 23:35:45 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 68 | Line 70
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[4];
90		size_t size;
#	Line 80 | Line 93 | int get_proc_snapshot(proc_state_t **ps){
93		char *proctitle;
94		#if (defined(FREEBSD) && !defined(FREEBSD5)) || defined(DFBSD)
95		kvm_t *kvmd;
96	<	char **args;
97	<	int alloc;
85	<	char *proctitletmp;
96	>	char **args, **argsp;
97	>	int argslen = 0;
98		#else
99		long buflen;
100		char *p;
#	Line 101 | 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;
105	<	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;
111	<	int t_read;
120	>	int len;
121	>	int rc;
122		#endif
123
124		if((proc_dir=opendir(PROC_LOCATION))==NULL){
#	Line 133 | 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 168 | 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';
171	–	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 181 | 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		}
189	–	ptr = psargs;
190	–	t_read = 0;
191	–	toread = psarg_size;
192	–	while((size = read(fn, ptr, toread)) == toread){
193	–	psargs = realloc(psargs, (psarg_size + PSARG_START_SIZE));
194	–	ptr = psargs+psarg_size;
195	–	t_read = psarg_size;
196	–	psarg_size+=PSARG_START_SIZE;
197	–	toread = PSARG_START_SIZE;
198	–	}
199	–	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++;
214	–
215	–	fclose(f);
237		}
238		closedir(proc_dir);
239		#endif
#	Line 223 | Line 244 | int get_proc_snapshot(proc_state_t **ps){
244		mib[2] = KERN_PROC_ALL;
245
246		if(sysctl(mib, 3, NULL, &size, NULL, 0) < 0) {
247	<	return NULL;
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;
254	>	return -1;
255		}
256
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)
#	Line 243 | Line 264 | int get_proc_snapshot(proc_state_t **ps){
264		#endif
265
266		for (i = 0; i < procs; i++) {
267	<	/* replace with something more sensible */
268	<	proc_state = realloc(proc_state,
269	<	(1+proc_state_size)*sizeof(proc_state_t));
270	<	if(proc_state == NULL ) {
250	<	return NULL;
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;
273
274		#ifdef FREEBSD5
275	<	proc_state_ptr->process_name =
256	<	strdup(kp_stats[i].ki_comm);
275	>	name = kp_stats[i].ki_comm;
276		#elif defined(DFBSD)
277	<	proc_state_ptr->process_name =
259	<	strdup(kp_stats[i].kp_thread.td_comm);
277	>	name = kp_stats[i].kp_thread.td_comm;
278		#else
279	<	proc_state_ptr->process_name =
262	<	strdup(kp_stats[i].kp_proc.p_comm);
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 NULL;
290	>	return -1;
291		}
292		#else
293		mib[1] = KERN_ARGMAX;
294
295		if(sysctl(mib, 2, &buflen, &size, NULL, 0) < 0) {
296	<	return NULL;
296	>	return -1;
297		}
298		#endif
299
300		proctitle = malloc(buflen);
301		if(proctitle == NULL) {
302	<	return NULL;
302	>	return -1;
303		}
304
305		size = buflen;
#	Line 293 | Line 313 | int get_proc_snapshot(proc_state_t **ps){
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;
#	Line 300 | Line 321 | int get_proc_snapshot(proc_state_t **ps){
321		else if(size > 0) {
322		proc_state_ptr->proctitle = malloc(size+1);
323		if(proc_state_ptr->proctitle == NULL) {
324	<	return NULL;
324	>	return -1;
325		}
326		p = proctitle;
327	<	proc_state_ptr->proctitle[0] = NULL;
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);
#	Line 318 | Line 339 | int get_proc_snapshot(proc_state_t **ps){
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	<	alloc = 1;
347	<	proctitle = malloc(alloc);
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 NULL;
354	>	return -1;
355		}
356		while(*args != NULL) {
357	<	if(strlen(proctitle) + strlen(*args) >= alloc) {
358	<	alloc = (alloc + strlen(*args)) * 2;
332	<	proctitletmp = realloc(proctitle, alloc);
333	<	if(proctitletmp == NULL) {
334	<	return NULL;
335	<	}
336	<	proctitle = proctitletmp;
337	<	}
338	<	strlcat(proctitle, *args, alloc);
339	<	strlcat(proctitle, " ", alloc);
357	>	strlcat(proctitle, *args, argslen);
358	>	strlcat(proctitle, " ", argslen);
359		args++;
360		}
361		/* remove trailing space */
#	Line 453 | 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 470 | Line 493 | process_stat_t *get_process_stats() {
493
494		ps_size = get_proc_snapshot(&ps);
495
496	<	if(ps_size == 0) {
496	>	if(ps_size < 0) {
497		return NULL;
498		}
499

Diff Legend

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