ViewVC Help

View File | Revision Log | Show Annotations | Revision Graph | Root Listing

root/i-scream/projects/libstatgrab/src/statgrab/statgrab.c

Comparing projects/libstatgrab/src/statgrab/statgrab.c (file contents):
Revision 1.5 by ats, Thu Aug 28 21:21:32 2003 UTC vs.
Revision 1.21 by ats, Wed Feb 18 17:29:15 2004 UTC

#	Line 1 | Line 1
1		/*
2		* i-scream central monitoring system
3		* http://www.i-scream.org
4	<	* Copyright (C) 2000-2003 i-scream
4	>	* Copyright (C) 2000-2004 i-scream
5		*
6		* This program is free software; you can redistribute it and/or
7		* modify it under the terms of the GNU General Public License
#	Line 16 | Line 16
16		* You should have received a copy of the GNU General Public License
17		* along with this program; if not, write to the Free Software
18		* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
19	+	*
20	+	* $Id$
21		*/
22
23		#ifdef HAVE_CONFIG_H
#	Line 35 | Line 37 | typedef enum {
37		FLOAT,
38		DOUBLE,
39		STRING,
40	<	INT
40	>	INT,
41	>	BOOL,
42	>	DUPLEX
43		} stat_type;
44
45		typedef enum {
#	Line 66 | Line 70 | display_mode_type display_mode = DISPLAY_LINUX;
70		repeat_mode_type repeat_mode = REPEAT_NONE;
71		int repeat_time = 1;
72		int use_cpu_percent = 0;
73	+	int use_diffs = 0;
74
75		/* Exit with an error message. */
76		void die(const char *s) {
#	Line 139 | Line 144 | void add_stat(stat_type type, void *stat, ...) {
144		++num_stats;
145		}
146
147	<	/* Compare two stats by name, for sorting purposes. */
147	>	/* Compare two stats by name for qsort and bsearch. */
148		int stats_compare(const void *a, const void *b) {
149		return strcmp(((stat *)a)->name, ((stat *)b)->name);
150		}
151
152	<	/* Clear and rebuild the stats array. */
153	<	void get_stats(int use_diffs) {
154	<	cpu_states_t *cpu_s;
155	<	cpu_percent_t *cpu_p;
151	<	mem_stat_t *mem;
152	<	load_stat_t *load;
153	<	user_stat_t *user;
154	<	swap_stat_t *swap;
155	<	general_stat_t *gen;
156	<	disk_stat_t *disk;
157	<	diskio_stat_t *diskio;
158	<	process_stat_t *proc;
159	<	network_stat_t *net;
160	<	page_stat_t *page;
161	<	static int zero = 0;
162	<	int n, i;
152	>	/* Compare up to the length of the key for bsearch. */
153	>	int stats_compare_prefix(const void *key, const void *item) {
154	>	const char *kn = ((stat *)key)->name;
155	>	const char *in = ((stat *)item)->name;
156
157	<	clear_stats();
157	>	return strncmp(kn, in, strlen(kn));
158	>	}
159
160	+	void populate_const() {
161	+	static int zero = 0;
162	+
163		/* Constants, for use with MRTG mode. */
164		add_stat(INT, &zero, "const", "0", NULL);
165	+	}
166
167	<	/* FIXME when only fetching some stats, it'd be more efficient to only
170	<	do the libstatgrab calls needed, rather than fetching everything. */
171	<
167	>	void populate_cpu() {
168		if (use_cpu_percent) {
169	<	cpu_p = cpu_percent_usage();
169	>	cpu_percent_t *cpu_p = cpu_percent_usage();
170	>
171		if (cpu_p != NULL) {
172		add_stat(FLOAT, &cpu_p->user,
173		"cpu", "user", NULL);
#	Line 184 | Line 181 | void get_stats(int use_diffs) {
181		"cpu", "swap", NULL);
182		add_stat(FLOAT, &cpu_p->nice,
183		"cpu", "nice", NULL);
184	<	add_stat(TIME_T, &cpu_s->systime,
184	>	add_stat(TIME_T, &cpu_p->time_taken,
185		"cpu", "time_taken", NULL);
186		}
187		} else {
188	+	cpu_states_t *cpu_s;
189	+
190		cpu_s = use_diffs ? get_cpu_diff() : get_cpu_totals();
191		if (cpu_s != NULL) {
192		add_stat(LONG_LONG, &cpu_s->user,
#	Line 208 | Line 207 | void get_stats(int use_diffs) {
207		"cpu", "systime", NULL);
208		}
209		}
210	+	}
211
212	<	mem = get_memory_stats();
212	>	void populate_mem() {
213	>	mem_stat_t *mem = get_memory_stats();
214	>
215		if (mem != NULL) {
216		add_stat(LONG_LONG, &mem->total, "mem", "total", NULL);
217		add_stat(LONG_LONG, &mem->free, "mem", "free", NULL);
218		add_stat(LONG_LONG, &mem->used, "mem", "used", NULL);
219		add_stat(LONG_LONG, &mem->cache, "mem", "cache", NULL);
220		}
221	+	}
222
223	<	load = get_load_stats();
223	>	void populate_load() {
224	>	load_stat_t *load = get_load_stats();
225	>
226		if (load != NULL) {
227		add_stat(DOUBLE, &load->min1, "load", "min1", NULL);
228		add_stat(DOUBLE, &load->min5, "load", "min5", NULL);
229		add_stat(DOUBLE, &load->min15, "load", "min15", NULL);
230		}
231	+	}
232
233	<	user = get_user_stats();
233	>	void populate_user() {
234	>	user_stat_t *user = get_user_stats();
235	>
236		if (user != NULL) {
237		add_stat(INT, &user->num_entries, "user", "num", NULL);
238		add_stat(STRING, &user->name_list, "user", "names", NULL);
239		}
240	+	}
241
242	<	swap = get_swap_stats();
242	>	void populate_swap() {
243	>	swap_stat_t *swap = get_swap_stats();
244	>
245		if (swap != NULL) {
246		add_stat(LONG_LONG, &swap->total, "swap", "total", NULL);
247		add_stat(LONG_LONG, &swap->used, "swap", "used", NULL);
248		add_stat(LONG_LONG, &swap->free, "swap", "free", NULL);
249		}
250	+	}
251
252	<	gen = get_general_stats();
252	>	void populate_general() {
253	>	general_stat_t *gen = get_general_stats();
254	>
255		if (gen != NULL) {
256		add_stat(STRING, &gen->os_name,
257		"general", "os_name", NULL);
#	Line 249 | Line 263 | void get_stats(int use_diffs) {
263		add_stat(STRING, &gen->hostname, "general", "hostname", NULL);
264		add_stat(TIME_T, &gen->uptime, "general", "uptime", NULL);
265		}
266	+	}
267
268	<	disk = get_disk_stats(&n);
268	>	void populate_fs() {
269	>	int n, i;
270	>	disk_stat_t *disk = get_disk_stats(&n);
271	>
272		if (disk != NULL) {
273		for (i = 0; i < n; i++) {
274		/* FIXME it'd be nicer if libstatgrab did this */
275	<	const char *name = disk[i].device_name,
276	<	*p = strrchr(name, '/');
277	<	if (p != NULL)
278	<	name = p + 1;
279	<	if (*name == '\0')
280	<	name = "root";
281	<
275	>	char *buf, *name, *p;
276	>	const char *device = disk[i].device_name;
277	>
278	>	if (strcmp(device, "/") == 0)
279	>	device = "root";
280	>
281	>	buf = strdup(device);
282	>	if (buf == NULL)
283	>	die("out of memory");
284	>
285	>	name = buf;
286	>	if (strlen(name) == 2 && name[1] == ':')
287	>	name[1] = '\0';
288	>	if (strncmp(name, "/dev/", 5) == 0)
289	>	name += 5;
290	>	while ((p = strchr(name, '/')) != NULL)
291	>	*p = '_';
292	>
293		add_stat(STRING, &disk[i].device_name,
294		"fs", name, "device_name", NULL);
295		add_stat(STRING, &disk[i].fs_type,
#	Line 279 | Line 308 | void get_stats(int use_diffs) {
308		"fs", name, "used_inodes", NULL);
309		add_stat(LONG_LONG, &disk[i].free_inodes,
310		"fs", name, "free_inodes", NULL);
311	+
312	+	free(buf);
313		}
314		}
315	+	}
316
317	+	void populate_disk() {
318	+	int n, i;
319	+	diskio_stat_t *diskio;
320	+
321		diskio = use_diffs ? get_diskio_stats_diff(&n) : get_diskio_stats(&n);
322		if (diskio != NULL) {
323		for (i = 0; i < n; i++) {
#	Line 297 | Line 333 | void get_stats(int use_diffs) {
333		"disk", name, "systime", NULL);
334		}
335		}
336	+	}
337
338	<	proc = get_process_stats();
338	>	void populate_proc() {
339	>	process_stat_t *proc = get_process_stats();
340	>
341		if (proc != NULL) {
342		add_stat(INT, &proc->total, "proc", "total", NULL);
343		add_stat(INT, &proc->running, "proc", "running", NULL);
#	Line 306 | Line 345 | void get_stats(int use_diffs) {
345		add_stat(INT, &proc->stopped, "proc", "stopped", NULL);
346		add_stat(INT, &proc->zombie, "proc", "zombie", NULL);
347		}
348	+	}
349
350	+	void populate_net() {
351	+	int n, i;
352	+	network_stat_t *net;
353	+	network_iface_stat_t *iface;
354	+
355		net = use_diffs ? get_network_stats_diff(&n) : get_network_stats(&n);
356		if (net != NULL) {
357		for (i = 0; i < n; i++) {
#	Line 323 | Line 368 | void get_stats(int use_diffs) {
368		}
369		}
370
371	+	iface = get_network_iface_stats(&n);
372	+	if (iface != NULL) {
373	+	for (i = 0; i < n; i++) {
374	+	const char *name = iface[i].interface_name;
375	+
376	+	add_stat(INT, &iface[i].speed,
377	+	"net", name, "speed", NULL);
378	+	add_stat(BOOL, &iface[i].up,
379	+	"net", name, "up", NULL);
380	+	add_stat(DUPLEX, &iface[i].dup,
381	+	"net", name, "duplex", NULL);
382	+	}
383	+	}
384	+	}
385	+
386	+	void populate_page() {
387	+	page_stat_t *page;
388	+
389		page = use_diffs ? get_page_stats_diff() : get_page_stats();
390		if (page != NULL) {
391		add_stat(LONG_LONG, &page->pages_pagein, "page", "in", NULL);
392		add_stat(LONG_LONG, &page->pages_pageout, "page", "out", NULL);
393	<	add_stat(LONG_LONG, &page->systime, "page", "systime", NULL);
393	>	add_stat(TIME_T, &page->systime, "page", "systime", NULL);
394		}
395	+	}
396
397	<	qsort(stats, num_stats, sizeof *stats, stats_compare);
397	>	typedef struct {
398	>	const char *name;
399	>	void (*populate)();
400	>	int interesting;
401	>	} toplevel;
402	>	toplevel toplevels[] = {
403	>	{"const.", populate_const, 0},
404	>	{"cpu.", populate_cpu, 0},
405	>	{"mem.", populate_mem, 0},
406	>	{"load.", populate_load, 0},
407	>	{"user.", populate_user, 0},
408	>	{"swap.", populate_swap, 0},
409	>	{"general.", populate_general, 0},
410	>	{"fs.", populate_fs, 0},
411	>	{"disk.", populate_disk, 0},
412	>	{"proc.", populate_proc, 0},
413	>	{"net.", populate_net, 0},
414	>	{"page.", populate_page, 0},
415	>	{NULL, NULL, 0}
416	>	};
417	>
418	>	/* Set the "interesting" flag on the sections that we actually need to
419	>	fetch. */
420	>	void select_interesting(int argc, char **argv) {
421	>	toplevel *t;
422	>
423	>	if (argc == 0) {
424	>	for (t = &toplevels[0]; t->name != NULL; t++)
425	>	t->interesting = 1;
426	>	} else {
427	>	int i;
428	>
429	>	for (i = 0; i < argc; i++) {
430	>	for (t = &toplevels[0]; t->name != NULL; t++) {
431	>	if (strncmp(argv[i], t->name,
432	>	strlen(t->name)) == 0) {
433	>	t->interesting = 1;
434	>	break;
435	>	}
436	>	}
437	>	}
438	>	}
439		}
440
441	+	/* Clear and rebuild the stats array. */
442	+	void get_stats() {
443	+	toplevel *t;
444	+
445	+	clear_stats();
446	+
447	+	for (t = &toplevels[0]; t->name != NULL; t++) {
448	+	if (t->interesting)
449	+	t->populate();
450	+	}
451	+
452	+	if (stats != NULL)
453	+	qsort(stats, num_stats, sizeof *stats, stats_compare);
454	+	}
455	+
456		/* Print the value of a stat. */
457		void print_stat_value(const stat *s) {
458		void *v = s->stat;
#	Line 358 | Line 478 | void print_stat_value(const stat *s) {
478		case INT:
479		printf("%d", *(int *)v);
480		break;
481	+	case BOOL:
482	+	printf("%s", *(int *)v ? "true" : "false");
483	+	break;
484	+	case DUPLEX:
485	+	switch (*(statgrab_duplex *) v) {
486	+	case FULL_DUPLEX:
487	+	printf("full");
488	+	break;
489	+	case HALF_DUPLEX:
490	+	printf("half");
491	+	break;
492	+	default:
493	+	printf("unknown");
494	+	break;
495	+	}
496	+	break;
497		}
498		}
499
#	Line 389 | Line 525 | void print_stats(int argc, char **argv) {
525		} else {
526		/* Print selected stats. */
527		for (i = optind; i < argc; i++) {
528	+	char *name = argv[i];
529		stat key;
530	<	const stat *s;
530	>	const stat *s, *end;
531	>	int (*compare)(const void *, const void *);
532
533	<	key.name = argv[i];
534	<	s = (const stat *)bsearch(&key, stats, num_stats,
535	<	sizeof *stats,
536	<	stats_compare);
537	<	if (s != NULL) {
533	>	key.name = name;
534	>	if (name[strlen(name) - 1] == '.')
535	>	compare = stats_compare_prefix;
536	>	else
537	>	compare = stats_compare;
538	>
539	>	if (stats == NULL) {
540	>	s = NULL;
541	>	} else {
542	>	s = (const stat *)bsearch(&key, stats,
543	>	num_stats,
544	>	sizeof *stats,
545	>	compare);
546	>	}
547	>
548	>	if (s == NULL) {
549	>	printf("Unknown stat %s\n", name);
550	>	continue;
551	>	}
552	>
553	>	/* Find the range of stats the user wanted. */
554	>	for (; s >= stats; s--) {
555	>	if (compare(&key, s) != 0)
556	>	break;
557	>	}
558	>	s++;
559	>	for (end = s; end < &stats[num_stats]; end++) {
560	>	if (compare(&key, end) != 0)
561	>	break;
562	>	}
563	>
564	>	/* And print them. */
565	>	for (; s < end; s++) {
566		print_stat(s);
567		}
568		}
#	Line 405 | Line 571 | void print_stats(int argc, char **argv) {
571
572		void usage() {
573		printf("Usage: statgrab [OPTION]... [STAT]...\n"
574	<	"Display system statistics (all statistics by default).\n"
574	>	"Display system statistics.\n"
575	>	"\n"
576	>	"If no STATs are given, all will be displayed. Specify 'STAT.' to display all\n"
577	>	"statistics starting with that prefix.\n"
578		"\n");
579		printf("  -l         Linux sysctl-style output (default)\n"
580		"  -b         BSD sysctl-style output\n"
#	Line 472 | Line 641 | int main(int argc, char **argv) {
641		if (use_cpu_percent && repeat_mode == REPEAT_NONE)
642		die("CPU percentage usage display requires stat differences");
643
644	+	if (repeat_mode == REPEAT_NONE)
645	+	use_diffs = 0;
646	+	else
647	+	use_diffs = 1;
648	+
649	+	select_interesting(argc - optind, &argv[optind]);
650	+
651	+	/* We don't care if statgrab_init fails, because we can just display
652	+	the statistics that can be read as non-root. */
653	+	statgrab_init();
654	+	if (statgrab_drop_privileges() != 0)
655	+	die("Failed to drop setuid/setgid privileges");
656	+
657		switch (repeat_mode) {
658		case REPEAT_NONE:
659	<	get_stats(0);
659	>	get_stats();
660		print_stats(argc, argv);
661		break;
662		case REPEAT_ONCE:
663	<	get_stats(1);
663	>	get_stats();
664		sleep(repeat_time);
665	<	get_stats(1);
665	>	get_stats();
666		print_stats(argc, argv);
667		break;
668		case REPEAT_FOREVER:
669		while (1) {
670	<	get_stats(1);
670	>	get_stats();
671		print_stats(argc, argv);
672		printf("\n");
673		sleep(repeat_time);

Diff Legend

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