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);
        free(stats);
        stats = NULL;
        num_stats = 0;
        alloc_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_s->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 as percentages rather than 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_NONE)
                        die("mrtg mode: cannot repeat display");
        }

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