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.2 by tdb, Wed Aug 27 14:00:12 2003 UTC vs.
Revision 1.20 by ats, Sat Feb 14 00:06:00 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
24	+	#include "config.h"
25	+	#endif
26	+
27		#include <statgrab.h>
28		#include <string.h>
29		#include <stdio.h>
#	Line 31 | 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 62 | 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 75 | Line 84 | void clear_stats() {
84
85		for (i = 0; i < num_stats; i++)
86		free(stats[i].name);
78	–	free(stats);
79	–	stats = NULL;
87		num_stats = 0;
81	–	alloc_stats = 0;
88		}
89
90		/* Add a stat. The varargs make up the name, joined with dots; the name is
#	Line 138 | 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;
150	<	mem_stat_t *mem;
151	<	load_stat_t *load;
152	<	user_stat_t *user;
153	<	swap_stat_t *swap;
154	<	general_stat_t *gen;
155	<	disk_stat_t *disk;
156	<	diskio_stat_t *diskio;
157	<	process_stat_t *proc;
158	<	network_stat_t *net;
159	<	page_stat_t *page;
160	<	static int zero = 0;
161	<	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
169	<	do the libstatgrab calls needed, rather than fetching everything. */
170	<
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 183 | 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 207 | 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 248 | 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 278 | 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 296 | 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 305 | 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 322 | 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	+	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		qsort(stats, num_stats, sizeof *stats, stats_compare);
453		}
454
#	Line 357 | Line 477 | void print_stat_value(const stat *s) {
477		case INT:
478		printf("%d", *(int *)v);
479		break;
480	+	case BOOL:
481	+	printf("%s", *(int *)v ? "true" : "false");
482	+	break;
483	+	case DUPLEX:
484	+	switch (*(statgrab_duplex *) v) {
485	+	case FULL_DUPLEX:
486	+	printf("full");
487	+	break;
488	+	case HALF_DUPLEX:
489	+	printf("half");
490	+	break;
491	+	default:
492	+	printf("unknown");
493	+	break;
494	+	}
495	+	break;
496		}
497		}
498
#	Line 388 | Line 524 | void print_stats(int argc, char **argv) {
524		} else {
525		/* Print selected stats. */
526		for (i = optind; i < argc; i++) {
527	+	char *name = argv[i];
528		stat key;
529	<	const stat *s;
529	>	const stat *s, *end;
530	>	int (*compare)(const void *, const void *);
531
532	<	key.name = argv[i];
532	>	key.name = name;
533	>	if (name[strlen(name) - 1] == '.')
534	>	compare = stats_compare_prefix;
535	>	else
536	>	compare = stats_compare;
537	>
538		s = (const stat *)bsearch(&key, stats, num_stats,
539	<	sizeof *stats,
540	<	stats_compare);
541	<	if (s != NULL) {
539	>	sizeof *stats, compare);
540	>	if (s == NULL) {
541	>	printf("Unknown stat %s\n", name);
542	>	continue;
543	>	}
544	>
545	>	/* Find the range of stats the user wanted. */
546	>	for (; s >= stats; s--) {
547	>	if (compare(&key, s) != 0)
548	>	break;
549	>	}
550	>	s++;
551	>	for (end = s; end < &stats[num_stats]; end++) {
552	>	if (compare(&key, end) != 0)
553	>	break;
554	>	}
555	>
556	>	/* And print them. */
557	>	for (; s < end; s++) {
558		print_stat(s);
559		}
560		}
#	Line 404 | Line 563 | void print_stats(int argc, char **argv) {
563
564		void usage() {
565		printf("Usage: statgrab [OPTION]... [STAT]...\n"
566	<	"Display system statistics (all statistics by default).\n"
566	>	"Display system statistics.\n"
567	>	"\n"
568	>	"If no STATs are given, all will be displayed. Specify 'STAT.' to display all\n"
569	>	"statistics starting with that prefix.\n"
570		"\n");
571		printf("  -l         Linux sysctl-style output (default)\n"
572		"  -b         BSD sysctl-style output\n"
#	Line 414 | Line 576 | void usage() {
576		"  -s         Display stat differences repeatedly\n"
577		"  -o         Display stat differences once\n"
578		"  -t DELAY   When repeating, wait DELAY seconds between updates (default 1)\n"
579	<	"  -p         Display CPU usage as percentages rather than absolute values\n"
579	>	"  -p         Display CPU usage differences as percentages rather than\n"
580	>	"             absolute values\n"
581		"\n");
582		printf("Version %s - report bugs to <%s>.\n",
583	<	PACKAGE_VERSION, PACKAGE_BUGREPORT);
583	>	PACKAGE_VERSION, PACKAGE_BUGREPORT);
584		exit(1);
585		}
586
#	Line 463 | Line 626 | int main(int argc, char **argv) {
626		if (display_mode == DISPLAY_MRTG) {
627		if ((argc - optind) != 2)
628		die("mrtg mode: must specify exactly two stats");
629	<	if (repeat_mode != REPEAT_NONE)
629	>	if (repeat_mode == REPEAT_FOREVER)
630		die("mrtg mode: cannot repeat display");
631		}
632
633	+	if (use_cpu_percent && repeat_mode == REPEAT_NONE)
634	+	die("CPU percentage usage display requires stat differences");
635	+
636	+	if (repeat_mode == REPEAT_NONE)
637	+	use_diffs = 0;
638	+	else
639	+	use_diffs = 1;
640	+
641	+	select_interesting(argc - optind, &argv[optind]);
642	+
643	+	/* We don't care if statgrab_init fails, because we can just display
644	+	the statistics that can be read as non-root. */
645	+	statgrab_init();
646	+	if (statgrab_drop_privileges() != 0)
647	+	die("Failed to drop setuid/setgid privileges");
648	+
649		switch (repeat_mode) {
650		case REPEAT_NONE:
651	<	get_stats(0);
651	>	get_stats();
652		print_stats(argc, argv);
653		break;
654		case REPEAT_ONCE:
655	<	get_stats(1);
655	>	get_stats();
656		sleep(repeat_time);
657	<	get_stats(1);
657	>	get_stats();
658		print_stats(argc, argv);
659		break;
660		case REPEAT_FOREVER:
661		while (1) {
662	<	get_stats(1);
662	>	get_stats();
663		print_stats(argc, argv);
664		printf("\n");
665		sleep(repeat_time);

Diff Legend

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