src/statgrab/statgrab.c

/* 
 * i-scream central monitoring system
 * http://www.i-scream.org
 * Copyright (C) 2000-2003 i-scream
 * 
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 * 
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * 
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 */

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include <statgrab.h>
#include <string.h>
#include <stdio.h>
#include <stdarg.h>
#include <stdlib.h>
#include <unistd.h>

typedef enum {
        LONG_LONG = 0,
        TIME_T,
        FLOAT,
        DOUBLE,
        STRING,
        INT
} stat_type;

typedef enum {
        DISPLAY_LINUX = 0,
        DISPLAY_BSD,
        DISPLAY_MRTG,
        DISPLAY_PLAIN
} display_mode_type;

typedef enum {
        REPEAT_NONE = 0,
        REPEAT_ONCE,
        REPEAT_FOREVER
} repeat_mode_type;

typedef struct {
        char *name;
        stat_type type;
        void *stat;
} stat;

stat *stats = NULL;
int num_stats = 0;
int alloc_stats = 0;
#define INCREMENT_STATS 64

display_mode_type display_mode = DISPLAY_LINUX;
repeat_mode_type repeat_mode = REPEAT_NONE;
int repeat_time = 1;
int use_cpu_percent = 0;

/* Exit with an error message. */
void die(const char *s) {
        fprintf(stderr, "fatal: %s\n", s);
        exit(1);
}

/* Remove all the recorded stats. */
void clear_stats() {
        int i;

        for (i = 0; i < num_stats; i++)
                free(stats[i].name);
        num_stats = 0;
}

/* Add a stat. The varargs make up the name, joined with dots; the name is
   terminated with a NULL. */
void add_stat(stat_type type, void *stat, ...) {
        va_list ap;
        int len = 0;
        char *name, *p;

        /* Figure out how long the name will be, including dots and trailing
           \0. */
        va_start(ap, stat);
        while (1) {
                const char *part = va_arg(ap, const char *);
                if (part == NULL)
                        break;
                len += 1 + strlen(part);
        }
        va_end(ap);

        /* Paste the name together. */
        name = malloc(len);
        if (name == NULL)
                die("out of memory");
        p = name;
        va_start(ap, stat);
        while (1) {
                const char *part = va_arg(ap, const char *);
                int partlen;
                if (part == NULL)
                        break;
                partlen = strlen(part);
                memcpy(p, part, partlen);
                p += partlen;
                *p++ = '.';
        }
        va_end(ap);
        *--p = '\0';

        /* Replace spaces with underscores. */
        for (p = name; *p != '\0'; p++) {
                if (*p == ' ')
                        *p = '_';
        }

        /* Stretch the stats array if necessary. */
        if (num_stats >= alloc_stats) {
                alloc_stats += INCREMENT_STATS;
                stats = realloc(stats, alloc_stats * sizeof *stats);
                if (stats == NULL)
                        die("out of memory");
        }

        stats[num_stats].name = name;
        stats[num_stats].type = type;
        stats[num_stats].stat = stat;
        ++num_stats;
}

/* Compare two stats by name, for sorting purposes. */
int stats_compare(const void *a, const void *b) {
        return strcmp(((stat *)a)->name, ((stat *)b)->name);
}

/* Clear and rebuild the stats array. */
void get_stats(int use_diffs) {
        cpu_states_t *cpu_s;
        cpu_percent_t *cpu_p;
        mem_stat_t *mem;
        load_stat_t *load;
        user_stat_t *user;
        swap_stat_t *swap;
        general_stat_t *gen;
        disk_stat_t *disk;
        diskio_stat_t *diskio;
        process_stat_t *proc;
        network_stat_t *net;
        page_stat_t *page;
        static int zero = 0;
        int n, i;

        clear_stats();

        /* Constants, for use with MRTG mode. */
        add_stat(INT, &zero, "const", "0", NULL);

        /* FIXME when only fetching some stats, it'd be more efficient to only
           do the libstatgrab calls needed, rather than fetching everything. */

        if (use_cpu_percent) {
                cpu_p = cpu_percent_usage();
                if (cpu_p != NULL) {
                        add_stat(FLOAT, &cpu_p->user,
                                 "cpu", "user", NULL);
                        add_stat(FLOAT, &cpu_p->kernel,
                                 "cpu", "kernel", NULL);
                        add_stat(FLOAT, &cpu_p->idle,
                                 "cpu", "idle", NULL);
                        add_stat(FLOAT, &cpu_p->iowait,
                                 "cpu", "iowait", NULL);
                        add_stat(FLOAT, &cpu_p->swap,
                                 "cpu", "swap", NULL);
                        add_stat(FLOAT, &cpu_p->nice,
                                 "cpu", "nice", NULL);
                        add_stat(TIME_T, &cpu_p->systime,
                                 "cpu", "time_taken", NULL);
                }
        } else {
                cpu_s = use_diffs ? get_cpu_diff() : get_cpu_totals();
                if (cpu_s != NULL) {
                        add_stat(LONG_LONG, &cpu_s->user,
                                 "cpu", "user", NULL);
                        add_stat(LONG_LONG, &cpu_s->kernel,
                                 "cpu", "kernel", NULL);
                        add_stat(LONG_LONG, &cpu_s->idle,
                                 "cpu", "idle", NULL);
                        add_stat(LONG_LONG, &cpu_s->iowait,
                                 "cpu", "iowait", NULL);
                        add_stat(LONG_LONG, &cpu_s->swap,
                                 "cpu", "swap", NULL);
                        add_stat(LONG_LONG, &cpu_s->nice,
                                 "cpu", "nice", NULL);
                        add_stat(LONG_LONG, &cpu_s->total,
                                 "cpu", "total", NULL);
                        add_stat(TIME_T, &cpu_s->systime,
                                 "cpu", "systime", NULL);
                }
        }

        mem = get_memory_stats();
        if (mem != NULL) {
                add_stat(LONG_LONG, &mem->total, "mem", "total", NULL);
                add_stat(LONG_LONG, &mem->free, "mem", "free", NULL);
                add_stat(LONG_LONG, &mem->used, "mem", "used", NULL);
                add_stat(LONG_LONG, &mem->cache, "mem", "cache", NULL);
        }

        load = get_load_stats();
        if (load != NULL) {
                add_stat(DOUBLE, &load->min1, "load", "min1", NULL);
                add_stat(DOUBLE, &load->min5, "load", "min5", NULL);
                add_stat(DOUBLE, &load->min15, "load", "min15", NULL);
        }

        user = get_user_stats();
        if (user != NULL) {
                add_stat(INT, &user->num_entries, "user", "num", NULL);
                add_stat(STRING, &user->name_list, "user", "names", NULL);
        }

        swap = get_swap_stats();
        if (swap != NULL) {
                add_stat(LONG_LONG, &swap->total, "swap", "total", NULL);
                add_stat(LONG_LONG, &swap->used, "swap", "used", NULL);
                add_stat(LONG_LONG, &swap->free, "swap", "free", NULL);
        }

        gen = get_general_stats();
        if (gen != NULL) {
                add_stat(STRING, &gen->os_name,
                         "general", "os_name", NULL);
                add_stat(STRING, &gen->os_release,
                         "general", "os_release", NULL);
                add_stat(STRING, &gen->os_version,
                         "general", "os_version", NULL);
                add_stat(STRING, &gen->platform, "general", "platform", NULL);
                add_stat(STRING, &gen->hostname, "general", "hostname", NULL);
                add_stat(TIME_T, &gen->uptime, "general", "uptime", NULL);
        }

        disk = get_disk_stats(&n);
        if (disk != NULL) {
                for (i = 0; i < n; i++) {
                        /* FIXME it'd be nicer if libstatgrab did this */
                        const char *name = disk[i].device_name,
                                   *p = strrchr(name, '/');
                        if (p != NULL)
                                name = p + 1;
                        if (*name == '\0')
                                name = "root";
        
                        add_stat(STRING, &disk[i].device_name,
                                 "fs", name, "device_name", NULL);
                        add_stat(STRING, &disk[i].fs_type,
                                 "fs", name, "fs_type", NULL);
                        add_stat(STRING, &disk[i].mnt_point,
                                 "fs", name, "mnt_point", NULL);
                        add_stat(LONG_LONG, &disk[i].size,
                                 "fs", name, "size", NULL);
                        add_stat(LONG_LONG, &disk[i].used,
                                 "fs", name, "used", NULL);
                        add_stat(LONG_LONG, &disk[i].avail,
                                 "fs", name, "avail", NULL);
                        add_stat(LONG_LONG, &disk[i].total_inodes,
                                 "fs", name, "total_inodes", NULL);
                        add_stat(LONG_LONG, &disk[i].used_inodes,
                                 "fs", name, "used_inodes", NULL);
                        add_stat(LONG_LONG, &disk[i].free_inodes,
                                 "fs", name, "free_inodes", NULL);
                }
        }

        diskio = use_diffs ? get_diskio_stats_diff(&n) : get_diskio_stats(&n);
        if (diskio != NULL) {
                for (i = 0; i < n; i++) {
                        const char *name = diskio[i].disk_name;
        
                        add_stat(STRING, &diskio[i].disk_name,
                                 "disk", name, "disk_name", NULL);
                        add_stat(LONG_LONG, &diskio[i].read_bytes,
                                 "disk", name, "read_bytes", NULL);
                        add_stat(LONG_LONG, &diskio[i].write_bytes,
                                 "disk", name, "write_bytes", NULL);
                        add_stat(TIME_T, &diskio[i].systime,
                                 "disk", name, "systime", NULL);
                }
        }

        proc = get_process_stats();
        if (proc != NULL) {
                add_stat(INT, &proc->total, "proc", "total", NULL);
                add_stat(INT, &proc->running, "proc", "running", NULL);
                add_stat(INT, &proc->sleeping, "proc", "sleeping", NULL);
                add_stat(INT, &proc->stopped, "proc", "stopped", NULL);
                add_stat(INT, &proc->zombie, "proc", "zombie", NULL);
        }

        net = use_diffs ? get_network_stats_diff(&n) : get_network_stats(&n);
        if (net != NULL) {
                for (i = 0; i < n; i++) {
                        const char *name = net[i].interface_name;
        
                        add_stat(STRING, &net[i].interface_name,
                                 "net", name, "interface_name", NULL);
                        add_stat(LONG_LONG, &net[i].tx,
                                 "net", name, "tx", NULL);
                        add_stat(LONG_LONG, &net[i].rx,
                                 "net", name, "rx", NULL);
                        add_stat(TIME_T, &net[i].systime,
                                 "net", name, "systime", NULL);
                }
        }

        page = use_diffs ? get_page_stats_diff() : get_page_stats();
        if (page != NULL) {
                add_stat(LONG_LONG, &page->pages_pagein, "page", "in", NULL);
                add_stat(LONG_LONG, &page->pages_pageout, "page", "out", NULL);
                add_stat(LONG_LONG, &page->systime, "page", "systime", NULL);
        }

        qsort(stats, num_stats, sizeof *stats, stats_compare);
}

/* Print the value of a stat. */
void print_stat_value(const stat *s) {
        void *v = s->stat;

        switch (s->type) {
        case LONG_LONG:
                printf("%lld", *(long long *)v);
                break;
        case TIME_T:
                /* FIXME option for formatted time? */
                printf("%ld", *(time_t *)v);
                break;
        case FLOAT:
                printf("%f", *(float *)v);
                break;
        case DOUBLE:
                printf("%f", *(double *)v);
                break;
        case STRING:
                /* FIXME escaping? */
                printf("%s", *(char **)v);
                break;
        case INT:
                printf("%d", *(int *)v);
                break;
        }
}

/* Print the name and value of a stat. */
void print_stat(const stat *s) {
        switch (display_mode) {
        case DISPLAY_LINUX:
                printf("%s = ", s->name);
                break;
        case DISPLAY_BSD:
                printf("%s: ", s->name);
                break;
        case DISPLAY_MRTG:
        case DISPLAY_PLAIN:
                break;
        }
        print_stat_value(s);
        printf("\n");
}

/* Print stats as specified on the provided command line. */
void print_stats(int argc, char **argv) {
        int i;

        if (argc == optind) {
                /* Print all stats. */
                for (i = 0; i < num_stats; i++)
                        print_stat(&stats[i]);
        } else {
                /* Print selected stats. */
                for (i = optind; i < argc; i++) {
                        stat key;
                        const stat *s;

                        key.name = argv[i];
                        s = (const stat *)bsearch(&key, stats, num_stats,
                                                  sizeof *stats,
                                                  stats_compare);
                        if (s != NULL) {
                                print_stat(s);
                        }
                }
        }
}

void usage() {
        printf("Usage: statgrab [OPTION]... [STAT]...\n"
               "Display system statistics (all statistics by default).\n"
               "\n");
        printf("  -l         Linux sysctl-style output (default)\n"
               "  -b         BSD sysctl-style output\n"
               "  -m         MRTG-compatible output\n"
               "  -u         Plain output (only show values)\n"
               "  -n         Display cumulative stats once (default)\n"
               "  -s         Display stat differences repeatedly\n"
               "  -o         Display stat differences once\n"
               "  -t DELAY   When repeating, wait DELAY seconds between updates (default 1)\n"
               "  -p         Display CPU usage differences as percentages rather than\n"
               "             absolute values\n"
               "\n");
        printf("Version %s - report bugs to <%s>.\n",
               PACKAGE_VERSION, PACKAGE_BUGREPORT);
        exit(1);
}

int main(int argc, char **argv) {
        opterr = 0;
        while (1) {
                int c = getopt(argc, argv, "lbmunsot:p");
                if (c == -1)
                        break;
                switch (c) {
                case 'l':
                        display_mode = DISPLAY_LINUX;
                        break;
                case 'b':
                        display_mode = DISPLAY_BSD;
                        break;
                case 'm':
                        display_mode = DISPLAY_MRTG;
                        break;
                case 'u':
                        display_mode = DISPLAY_PLAIN;
                        break;
                case 'n':
                        repeat_mode = REPEAT_NONE;
                        break;
                case 's':
                        repeat_mode = REPEAT_FOREVER;
                        break;
                case 'o':
                        repeat_mode = REPEAT_ONCE;
                        break;
                case 't':
                        repeat_time = atoi(optarg);
                        break;
                case 'p':
                        use_cpu_percent = 1;
                        break;
                default:
                        usage();
                }
        }

        if (display_mode == DISPLAY_MRTG) {
                if ((argc - optind) != 2)
                        die("mrtg mode: must specify exactly two stats");
                if (repeat_mode == REPEAT_FOREVER)
                        die("mrtg mode: cannot repeat display");
        }

        if (use_cpu_percent && repeat_mode == REPEAT_NONE)
                die("CPU percentage usage display requires stat differences");

        switch (repeat_mode) {
        case REPEAT_NONE:
                get_stats(0);
                print_stats(argc, argv);
                break;
        case REPEAT_ONCE:
                get_stats(1);
                sleep(repeat_time);
                get_stats(1);
                print_stats(argc, argv);
                break;
        case REPEAT_FOREVER:
                while (1) {
                        get_stats(1);
                        print_stats(argc, argv);
                        printf("\n");
                        sleep(repeat_time);
                }
        }

        if (display_mode == DISPLAY_MRTG) {
                printf("\n");
                printf("statgrab\n");
        }

        return 0;
}

Revision:	1.6
Committed:	Fri Aug 29 06:48:04 2003 UTC (21 years, 3 months ago) by ats
Content type:	text/plain
Branch:	MAIN
Changes since 1.5:	+1 -1 lines
Log Message:	Fill in time_taken correctly.
#	User	Rev	Content
1	tdb	1.1	/*
2			* i-scream central monitoring system
3			* http://www.i-scream.org
4			* Copyright (C) 2000-2003 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
8			* as published by the Free Software Foundation; either version 2
9			* of the License, or (at your option) any later version.
10			*
11			* This program is distributed in the hope that it will be useful,
12			* but WITHOUT ANY WARRANTY; without even the implied warranty of
13			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14			* GNU General Public License for more details.
15			*
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
21	tdb	1.3	#ifdef HAVE_CONFIG_H
22			#include "config.h"
23			#endif
24
25	tdb	1.1	#include <statgrab.h>
26			#include <string.h>
27			#include <stdio.h>
28			#include <stdarg.h>
29			#include <stdlib.h>
30			#include <unistd.h>
31
32			typedef enum {
33			LONG_LONG = 0,
34			TIME_T,
35			FLOAT,
36			DOUBLE,
37			STRING,
38			INT
39			} stat_type;
40
41			typedef enum {
42			DISPLAY_LINUX = 0,
43			DISPLAY_BSD,
44			DISPLAY_MRTG,
45			DISPLAY_PLAIN
46			} display_mode_type;
47
48			typedef enum {
49			REPEAT_NONE = 0,
50			REPEAT_ONCE,
51			REPEAT_FOREVER
52			} repeat_mode_type;
53
54			typedef struct {
55			char *name;
56			stat_type type;
57			void *stat;
58			} stat;
59
60			stat *stats = NULL;
61			int num_stats = 0;
62			int alloc_stats = 0;
63			#define INCREMENT_STATS 64
64
65			display_mode_type display_mode = DISPLAY_LINUX;
66			repeat_mode_type repeat_mode = REPEAT_NONE;
67			int repeat_time = 1;
68			int use_cpu_percent = 0;
69
70			/* Exit with an error message. */
71			void die(const char *s) {
72			fprintf(stderr, "fatal: %s\n", s);
73			exit(1);
74			}
75
76			/* Remove all the recorded stats. */
77			void clear_stats() {
78			int i;
79
80			for (i = 0; i < num_stats; i++)
81			free(stats[i].name);
82			num_stats = 0;
83			}
84
85			/* Add a stat. The varargs make up the name, joined with dots; the name is
86			terminated with a NULL. */
87			void add_stat(stat_type type, void *stat, ...) {
88			va_list ap;
89			int len = 0;
90			char name, p;
91
92			/* Figure out how long the name will be, including dots and trailing
93			\0. */
94			va_start(ap, stat);
95			while (1) {
96			const char part = va_arg(ap, const char );
97			if (part == NULL)
98			break;
99			len += 1 + strlen(part);
100			}
101			va_end(ap);
102
103			/* Paste the name together. */
104			name = malloc(len);
105			if (name == NULL)
106			die("out of memory");
107			p = name;
108			va_start(ap, stat);
109			while (1) {
110			const char part = va_arg(ap, const char );
111			int partlen;
112			if (part == NULL)
113			break;
114			partlen = strlen(part);
115			memcpy(p, part, partlen);
116			p += partlen;
117			*p++ = '.';
118			}
119			va_end(ap);
120			*--p = '\0';
121
122			/* Replace spaces with underscores. */
123			for (p = name; *p != '\0'; p++) {
124			if (*p == ' ')
125			*p = '_';
126			}
127
128			/* Stretch the stats array if necessary. */
129			if (num_stats >= alloc_stats) {
130			alloc_stats += INCREMENT_STATS;
131			stats = realloc(stats, alloc_stats * sizeof *stats);
132			if (stats == NULL)
133			die("out of memory");
134			}
135
136			stats[num_stats].name = name;
137			stats[num_stats].type = type;
138			stats[num_stats].stat = stat;
139			++num_stats;
140			}
141
142			/* Compare two stats by name, for sorting purposes. */
143			int stats_compare(const void a, const void b) {
144			return strcmp(((stat )a)->name, ((stat )b)->name);
145			}
146
147			/* Clear and rebuild the stats array. */
148			void get_stats(int use_diffs) {
149			cpu_states_t *cpu_s;
150			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;
163
164			clear_stats();
165
166			/* Constants, for use with MRTG mode. */
167			add_stat(INT, &zero, "const", "0", NULL);
168
169			/* FIXME when only fetching some stats, it'd be more efficient to only
170			do the libstatgrab calls needed, rather than fetching everything. */
171
172			if (use_cpu_percent) {
173			cpu_p = cpu_percent_usage();
174			if (cpu_p != NULL) {
175			add_stat(FLOAT, &cpu_p->user,
176			"cpu", "user", NULL);
177			add_stat(FLOAT, &cpu_p->kernel,
178			"cpu", "kernel", NULL);
179			add_stat(FLOAT, &cpu_p->idle,
180			"cpu", "idle", NULL);
181			add_stat(FLOAT, &cpu_p->iowait,
182			"cpu", "iowait", NULL);
183			add_stat(FLOAT, &cpu_p->swap,
184			"cpu", "swap", NULL);
185			add_stat(FLOAT, &cpu_p->nice,
186			"cpu", "nice", NULL);
187	ats	1.6	add_stat(TIME_T, &cpu_p->systime,
188	tdb	1.1	"cpu", "time_taken", NULL);
189			}
190			} else {
191			cpu_s = use_diffs ? get_cpu_diff() : get_cpu_totals();
192			if (cpu_s != NULL) {
193			add_stat(LONG_LONG, &cpu_s->user,
194			"cpu", "user", NULL);
195			add_stat(LONG_LONG, &cpu_s->kernel,
196			"cpu", "kernel", NULL);
197			add_stat(LONG_LONG, &cpu_s->idle,
198			"cpu", "idle", NULL);
199			add_stat(LONG_LONG, &cpu_s->iowait,
200			"cpu", "iowait", NULL);
201			add_stat(LONG_LONG, &cpu_s->swap,
202			"cpu", "swap", NULL);
203			add_stat(LONG_LONG, &cpu_s->nice,
204			"cpu", "nice", NULL);
205			add_stat(LONG_LONG, &cpu_s->total,
206			"cpu", "total", NULL);
207			add_stat(TIME_T, &cpu_s->systime,
208			"cpu", "systime", NULL);
209			}
210			}
211
212			mem = get_memory_stats();
213			if (mem != NULL) {
214			add_stat(LONG_LONG, &mem->total, "mem", "total", NULL);
215			add_stat(LONG_LONG, &mem->free, "mem", "free", NULL);
216			add_stat(LONG_LONG, &mem->used, "mem", "used", NULL);
217			add_stat(LONG_LONG, &mem->cache, "mem", "cache", NULL);
218			}
219
220			load = get_load_stats();
221			if (load != NULL) {
222			add_stat(DOUBLE, &load->min1, "load", "min1", NULL);
223			add_stat(DOUBLE, &load->min5, "load", "min5", NULL);
224			add_stat(DOUBLE, &load->min15, "load", "min15", NULL);
225			}
226
227			user = get_user_stats();
228			if (user != NULL) {
229			add_stat(INT, &user->num_entries, "user", "num", NULL);
230			add_stat(STRING, &user->name_list, "user", "names", NULL);
231			}
232
233			swap = get_swap_stats();
234			if (swap != NULL) {
235			add_stat(LONG_LONG, &swap->total, "swap", "total", NULL);
236			add_stat(LONG_LONG, &swap->used, "swap", "used", NULL);
237			add_stat(LONG_LONG, &swap->free, "swap", "free", NULL);
238			}
239
240			gen = get_general_stats();
241			if (gen != NULL) {
242			add_stat(STRING, &gen->os_name,
243			"general", "os_name", NULL);
244			add_stat(STRING, &gen->os_release,
245			"general", "os_release", NULL);
246			add_stat(STRING, &gen->os_version,
247			"general", "os_version", NULL);
248			add_stat(STRING, &gen->platform, "general", "platform", NULL);
249			add_stat(STRING, &gen->hostname, "general", "hostname", NULL);
250			add_stat(TIME_T, &gen->uptime, "general", "uptime", NULL);
251			}
252
253			disk = get_disk_stats(&n);
254			if (disk != NULL) {
255			for (i = 0; i < n; i++) {
256			/* FIXME it'd be nicer if libstatgrab did this */
257			const char *name = disk[i].device_name,
258			*p = strrchr(name, '/');
259			if (p != NULL)
260			name = p + 1;
261			if (*name == '\0')
262			name = "root";
263
264			add_stat(STRING, &disk[i].device_name,
265			"fs", name, "device_name", NULL);
266			add_stat(STRING, &disk[i].fs_type,
267			"fs", name, "fs_type", NULL);
268			add_stat(STRING, &disk[i].mnt_point,
269			"fs", name, "mnt_point", NULL);
270			add_stat(LONG_LONG, &disk[i].size,
271			"fs", name, "size", NULL);
272			add_stat(LONG_LONG, &disk[i].used,
273			"fs", name, "used", NULL);
274			add_stat(LONG_LONG, &disk[i].avail,
275			"fs", name, "avail", NULL);
276			add_stat(LONG_LONG, &disk[i].total_inodes,
277			"fs", name, "total_inodes", NULL);
278			add_stat(LONG_LONG, &disk[i].used_inodes,
279			"fs", name, "used_inodes", NULL);
280			add_stat(LONG_LONG, &disk[i].free_inodes,
281			"fs", name, "free_inodes", NULL);
282			}
283			}
284
285			diskio = use_diffs ? get_diskio_stats_diff(&n) : get_diskio_stats(&n);
286			if (diskio != NULL) {
287			for (i = 0; i < n; i++) {
288			const char *name = diskio[i].disk_name;
289
290			add_stat(STRING, &diskio[i].disk_name,
291			"disk", name, "disk_name", NULL);
292			add_stat(LONG_LONG, &diskio[i].read_bytes,
293			"disk", name, "read_bytes", NULL);
294			add_stat(LONG_LONG, &diskio[i].write_bytes,
295			"disk", name, "write_bytes", NULL);
296			add_stat(TIME_T, &diskio[i].systime,
297			"disk", name, "systime", NULL);
298			}
299			}
300
301			proc = get_process_stats();
302			if (proc != NULL) {
303			add_stat(INT, &proc->total, "proc", "total", NULL);
304			add_stat(INT, &proc->running, "proc", "running", NULL);
305			add_stat(INT, &proc->sleeping, "proc", "sleeping", NULL);
306			add_stat(INT, &proc->stopped, "proc", "stopped", NULL);
307			add_stat(INT, &proc->zombie, "proc", "zombie", NULL);
308			}
309
310			net = use_diffs ? get_network_stats_diff(&n) : get_network_stats(&n);
311			if (net != NULL) {
312			for (i = 0; i < n; i++) {
313			const char *name = net[i].interface_name;
314
315			add_stat(STRING, &net[i].interface_name,
316			"net", name, "interface_name", NULL);
317			add_stat(LONG_LONG, &net[i].tx,
318			"net", name, "tx", NULL);
319			add_stat(LONG_LONG, &net[i].rx,
320			"net", name, "rx", NULL);
321			add_stat(TIME_T, &net[i].systime,
322			"net", name, "systime", NULL);
323			}
324			}
325
326			page = use_diffs ? get_page_stats_diff() : get_page_stats();
327			if (page != NULL) {
328			add_stat(LONG_LONG, &page->pages_pagein, "page", "in", NULL);
329			add_stat(LONG_LONG, &page->pages_pageout, "page", "out", NULL);
330			add_stat(LONG_LONG, &page->systime, "page", "systime", NULL);
331			}
332
333			qsort(stats, num_stats, sizeof *stats, stats_compare);
334			}
335
336			/* Print the value of a stat. */
337			void print_stat_value(const stat *s) {
338			void *v = s->stat;
339
340			switch (s->type) {
341			case LONG_LONG:
342			printf("%lld", (long long )v);
343			break;
344			case TIME_T:
345			/* FIXME option for formatted time? */
346			printf("%ld", (time_t )v);
347			break;
348			case FLOAT:
349			printf("%f", (float )v);
350			break;
351			case DOUBLE:
352			printf("%f", (double )v);
353			break;
354			case STRING:
355			/* FIXME escaping? */
356			printf("%s", (char *)v);
357			break;
358			case INT:
359			printf("%d", (int )v);
360			break;
361			}
362			}
363
364			/* Print the name and value of a stat. */
365			void print_stat(const stat *s) {
366			switch (display_mode) {
367			case DISPLAY_LINUX:
368			printf("%s = ", s->name);
369			break;
370			case DISPLAY_BSD:
371			printf("%s: ", s->name);
372			break;
373			case DISPLAY_MRTG:
374			case DISPLAY_PLAIN:
375			break;
376			}
377			print_stat_value(s);
378			printf("\n");
379			}
380
381			/* Print stats as specified on the provided command line. */
382			void print_stats(int argc, char **argv) {
383			int i;
384
385			if (argc == optind) {
386			/* Print all stats. */
387			for (i = 0; i < num_stats; i++)
388			print_stat(&stats[i]);
389			} else {
390			/* Print selected stats. */
391			for (i = optind; i < argc; i++) {
392			stat key;
393			const stat *s;
394
395			key.name = argv[i];
396			s = (const stat *)bsearch(&key, stats, num_stats,
397			sizeof *stats,
398			stats_compare);
399			if (s != NULL) {
400			print_stat(s);
401			}
402			}
403			}
404			}
405
406			void usage() {
407			printf("Usage: statgrab [OPTION]... [STAT]...\n"
408			"Display system statistics (all statistics by default).\n"
409			"\n");
410			printf(" -l Linux sysctl-style output (default)\n"
411			" -b BSD sysctl-style output\n"
412			" -m MRTG-compatible output\n"
413			" -u Plain output (only show values)\n"
414			" -n Display cumulative stats once (default)\n"
415			" -s Display stat differences repeatedly\n"
416			" -o Display stat differences once\n"
417			" -t DELAY When repeating, wait DELAY seconds between updates (default 1)\n"
418	ats	1.5	" -p Display CPU usage differences as percentages rather than\n"
419			" absolute values\n"
420	tdb	1.1	"\n");
421	tdb	1.2	printf("Version %s - report bugs to <%s>.\n",
422	ats	1.5	PACKAGE_VERSION, PACKAGE_BUGREPORT);
423	tdb	1.1	exit(1);
424			}
425
426			int main(int argc, char **argv) {
427			opterr = 0;
428			while (1) {
429			int c = getopt(argc, argv, "lbmunsot:p");
430			if (c == -1)
431			break;
432			switch (c) {
433			case 'l':
434			display_mode = DISPLAY_LINUX;
435			break;
436			case 'b':
437			display_mode = DISPLAY_BSD;
438			break;
439			case 'm':
440			display_mode = DISPLAY_MRTG;
441			break;
442			case 'u':
443			display_mode = DISPLAY_PLAIN;
444			break;
445			case 'n':
446			repeat_mode = REPEAT_NONE;
447			break;
448			case 's':
449			repeat_mode = REPEAT_FOREVER;
450			break;
451			case 'o':
452			repeat_mode = REPEAT_ONCE;
453			break;
454			case 't':
455			repeat_time = atoi(optarg);
456			break;
457			case 'p':
458			use_cpu_percent = 1;
459			break;
460			default:
461			usage();
462			}
463			}
464
465			if (display_mode == DISPLAY_MRTG) {
466			if ((argc - optind) != 2)
467			die("mrtg mode: must specify exactly two stats");
468	ats	1.5	if (repeat_mode == REPEAT_FOREVER)
469	tdb	1.1	die("mrtg mode: cannot repeat display");
470			}
471	ats	1.5
472			if (use_cpu_percent && repeat_mode == REPEAT_NONE)
473			die("CPU percentage usage display requires stat differences");
474	tdb	1.1
475			switch (repeat_mode) {
476			case REPEAT_NONE:
477			get_stats(0);
478			print_stats(argc, argv);
479			break;
480			case REPEAT_ONCE:
481			get_stats(1);
482			sleep(repeat_time);
483			get_stats(1);
484			print_stats(argc, argv);
485			break;
486			case REPEAT_FOREVER:
487			while (1) {
488			get_stats(1);
489			print_stats(argc, argv);
490			printf("\n");
491			sleep(repeat_time);
492			}
493			}
494
495			if (display_mode == DISPLAY_MRTG) {
496			printf("\n");
497			printf("statgrab\n");
498			}
499
500			return 0;
501			}
502