src/statgrab/statgrab.c

/* 
 * i-scream central monitoring system
 * http://www.i-scream.org
 * Copyright (C) 2000-2004 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.
 *
 * $Id$
 */

#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;
int use_diffs = 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 qsort and bsearch. */
int stats_compare(const void *a, const void *b) {
        return strcmp(((stat *)a)->name, ((stat *)b)->name);
}

/* Compare up to the length of the key for bsearch. */
int stats_compare_prefix(const void *key, const void *item) {
        const char *kn = ((stat *)key)->name;
        const char *in = ((stat *)item)->name;

        return strncmp(kn, in, strlen(kn));
}

void populate_const() {
        static int zero = 0;

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

void populate_cpu() {
        if (use_cpu_percent) {
                cpu_percent_t *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->time_taken,
                                 "cpu", "time_taken", NULL);
                }
        } else {
                cpu_states_t *cpu_s;

                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);
                }
        }
}

void populate_mem() {
        mem_stat_t *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);
        }
}

void populate_load() {
        load_stat_t *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);
        }
}

void populate_user() {
        user_stat_t *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);
        }
}

void populate_swap() {
        swap_stat_t *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);
        }
}

void populate_general() {
        general_stat_t *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);
        }
}

void populate_fs() {
        int n, i;
        disk_stat_t *disk = get_disk_stats(&n);

        if (disk != NULL) {
                for (i = 0; i < n; i++) {
                        /* FIXME it'd be nicer if libstatgrab did this */
                        char *buf, *name, *p;
                        const char *device = disk[i].device_name;

                        if (strcmp(device, "/") == 0)
                                device = "root";

                        buf = strdup(device);
                        if (buf == NULL)
                                die("out of memory");

                        name = buf;
                        if (strlen(name) == 2 && name[1] == ':')
                                name[1] = '\0';
                        if (strncmp(name, "/dev/", 5) == 0)
                                name += 5;
                        while ((p = strchr(name, '/')) != NULL)
                                *p = '_';

                        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);

                        free(buf);
                }
        }
}

void populate_disk() {
        int n, i;
        diskio_stat_t *diskio;

        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);
                }
        }
}

void populate_proc() {
        process_stat_t *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);
        }
}

void populate_net() {
        int n, i;
        network_stat_t *net;

        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);
                }
        }
}

void populate_page() {
        page_stat_t *page;

        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(TIME_T, &page->systime, "page", "systime", NULL);
        }
}

typedef struct {
        const char *name;
        void (*populate)();
        int interesting;
} toplevel;
toplevel toplevels[] = {
        {"const.", populate_const, 0},
        {"cpu.", populate_cpu, 0},
        {"mem.", populate_mem, 0},
        {"load.", populate_load, 0},
        {"user.", populate_user, 0},
        {"swap.", populate_swap, 0},
        {"general.", populate_general, 0},
        {"fs.", populate_fs, 0},
        {"disk.", populate_disk, 0},
        {"proc.", populate_proc, 0},
        {"net.", populate_net, 0},
        {"page.", populate_page, 0},
        {NULL, NULL, 0}
};

/* Set the "interesting" flag on the sections that we actually need to
   fetch. */
void select_interesting(int argc, char **argv) {
        toplevel *t;

        if (argc == 0) {
                for (t = &toplevels[0]; t->name != NULL; t++)
                        t->interesting = 1;
        } else {
                int i;

                for (i = 0; i < argc; i++) {
                        for (t = &toplevels[0]; t->name != NULL; t++) {
                                if (strncmp(argv[i], t->name,
                                            strlen(t->name)) == 0) {
                                        t->interesting = 1;
                                        break;
                                }
                        }
                }
        }
}

/* Clear and rebuild the stats array. */
void get_stats() {
        toplevel *t;

        clear_stats();

        for (t = &toplevels[0]; t->name != NULL; t++) {
                if (t->interesting)
                        t->populate();
        }

        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++) {
                        char *name = argv[i];
                        stat key;
                        const stat *s, *end;
                        int (*compare)(const void *, const void *);

                        key.name = name;
                        if (name[strlen(name) - 1] == '.')
                                compare = stats_compare_prefix;
                        else
                                compare = stats_compare;

                        s = (const stat *)bsearch(&key, stats, num_stats,
                                                  sizeof *stats, compare);
                        if (s == NULL) {
                                printf("Unknown stat %s\n", name);
                                continue;
                        }

                        /* Find the range of stats the user wanted. */
                        for (; s >= stats; s--) {
                                if (compare(&key, s) != 0)
                                        break;
                        }
                        s++;
                        for (end = s; end < &stats[num_stats]; end++) {
                                if (compare(&key, end) != 0)
                                        break;
                        }

                        /* And print them. */
                        for (; s < end; s++) {
                                print_stat(s);
                        }
                }
        }
}

void usage() {
        printf("Usage: statgrab [OPTION]... [STAT]...\n"
               "Display system statistics.\n"
               "\n"
               "If no STATs are given, all will be displayed. Specify 'STAT.' to display all\n"
               "statistics starting with that prefix.\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");

        if (repeat_mode == REPEAT_NONE)
                use_diffs = 0;
        else
                use_diffs = 1;

        select_interesting(argc - optind, &argv[optind]);

        /* We don't care if statgrab_init fails, because we can just display
           the statistics that can be read as non-root. */
        statgrab_init();
        if (statgrab_drop_privileges() != 0)
                die("Failed to drop setuid/setgid privileges");

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

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

        return 0;
}

Revision:	1.17
Committed:	Mon Jan 19 16:49:23 2004 UTC (20 years, 10 months ago) by tdb
Content type:	text/plain
Branch:	MAIN
CVS Tags:	LIBSTATGRAB_0_8_2, LIBSTATGRAB_0_8_1
Changes since 1.16:	+2 -0 lines
Log Message:	A whole bunch of minor cosmetic changes.
#	User	Rev	Content
1	tdb	1.1	/*
2			* i-scream central monitoring system
3			* http://www.i-scream.org
4	tdb	1.16	* Copyright (C) 2000-2004 i-scream
5	tdb	1.1	*
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	tdb	1.17	*
20			* $Id$
21	tdb	1.1	*/
22
23	tdb	1.3	#ifdef HAVE_CONFIG_H
24			#include "config.h"
25			#endif
26
27	tdb	1.1	#include <statgrab.h>
28			#include <string.h>
29			#include <stdio.h>
30			#include <stdarg.h>
31			#include <stdlib.h>
32			#include <unistd.h>
33
34			typedef enum {
35			LONG_LONG = 0,
36			TIME_T,
37			FLOAT,
38			DOUBLE,
39			STRING,
40			INT
41			} stat_type;
42
43			typedef enum {
44			DISPLAY_LINUX = 0,
45			DISPLAY_BSD,
46			DISPLAY_MRTG,
47			DISPLAY_PLAIN
48			} display_mode_type;
49
50			typedef enum {
51			REPEAT_NONE = 0,
52			REPEAT_ONCE,
53			REPEAT_FOREVER
54			} repeat_mode_type;
55
56			typedef struct {
57			char *name;
58			stat_type type;
59			void *stat;
60			} stat;
61
62			stat *stats = NULL;
63			int num_stats = 0;
64			int alloc_stats = 0;
65			#define INCREMENT_STATS 64
66
67			display_mode_type display_mode = DISPLAY_LINUX;
68			repeat_mode_type repeat_mode = REPEAT_NONE;
69			int repeat_time = 1;
70			int use_cpu_percent = 0;
71	ats	1.8	int use_diffs = 0;
72	tdb	1.1
73			/* Exit with an error message. */
74			void die(const char *s) {
75			fprintf(stderr, "fatal: %s\n", s);
76			exit(1);
77			}
78
79			/* Remove all the recorded stats. */
80			void clear_stats() {
81			int i;
82
83			for (i = 0; i < num_stats; i++)
84			free(stats[i].name);
85			num_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	ats	1.9	/* Compare two stats by name for qsort and bsearch. */
146	tdb	1.1	int stats_compare(const void a, const void b) {
147			return strcmp(((stat )a)->name, ((stat )b)->name);
148			}
149
150	ats	1.9	/* Compare up to the length of the key for bsearch. */
151			int stats_compare_prefix(const void key, const void item) {
152			const char kn = ((stat )key)->name;
153			const char in = ((stat )item)->name;
154
155			return strncmp(kn, in, strlen(kn));
156			}
157
158	ats	1.8	void populate_const() {
159	tdb	1.1	static int zero = 0;
160
161			/* Constants, for use with MRTG mode. */
162			add_stat(INT, &zero, "const", "0", NULL);
163	ats	1.8	}
164	tdb	1.1
165	ats	1.8	void populate_cpu() {
166			if (use_cpu_percent) {
167			cpu_percent_t *cpu_p = cpu_percent_usage();
168	tdb	1.1
169			if (cpu_p != NULL) {
170			add_stat(FLOAT, &cpu_p->user,
171			"cpu", "user", NULL);
172			add_stat(FLOAT, &cpu_p->kernel,
173			"cpu", "kernel", NULL);
174			add_stat(FLOAT, &cpu_p->idle,
175			"cpu", "idle", NULL);
176			add_stat(FLOAT, &cpu_p->iowait,
177			"cpu", "iowait", NULL);
178			add_stat(FLOAT, &cpu_p->swap,
179			"cpu", "swap", NULL);
180			add_stat(FLOAT, &cpu_p->nice,
181			"cpu", "nice", NULL);
182	ats	1.7	add_stat(TIME_T, &cpu_p->time_taken,
183	tdb	1.1	"cpu", "time_taken", NULL);
184			}
185			} else {
186	ats	1.8	cpu_states_t *cpu_s;
187
188	tdb	1.1	cpu_s = use_diffs ? get_cpu_diff() : get_cpu_totals();
189			if (cpu_s != NULL) {
190			add_stat(LONG_LONG, &cpu_s->user,
191			"cpu", "user", NULL);
192			add_stat(LONG_LONG, &cpu_s->kernel,
193			"cpu", "kernel", NULL);
194			add_stat(LONG_LONG, &cpu_s->idle,
195			"cpu", "idle", NULL);
196			add_stat(LONG_LONG, &cpu_s->iowait,
197			"cpu", "iowait", NULL);
198			add_stat(LONG_LONG, &cpu_s->swap,
199			"cpu", "swap", NULL);
200			add_stat(LONG_LONG, &cpu_s->nice,
201			"cpu", "nice", NULL);
202			add_stat(LONG_LONG, &cpu_s->total,
203			"cpu", "total", NULL);
204			add_stat(TIME_T, &cpu_s->systime,
205			"cpu", "systime", NULL);
206			}
207			}
208	ats	1.8	}
209
210			void populate_mem() {
211			mem_stat_t *mem = get_memory_stats();
212	tdb	1.1
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	ats	1.8	}
220
221			void populate_load() {
222			load_stat_t *load = get_load_stats();
223	tdb	1.1
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	ats	1.8	}
230
231			void populate_user() {
232			user_stat_t *user = get_user_stats();
233	tdb	1.1
234			if (user != NULL) {
235			add_stat(INT, &user->num_entries, "user", "num", NULL);
236			add_stat(STRING, &user->name_list, "user", "names", NULL);
237			}
238	ats	1.8	}
239
240			void populate_swap() {
241			swap_stat_t *swap = get_swap_stats();
242	tdb	1.1
243			if (swap != NULL) {
244			add_stat(LONG_LONG, &swap->total, "swap", "total", NULL);
245			add_stat(LONG_LONG, &swap->used, "swap", "used", NULL);
246			add_stat(LONG_LONG, &swap->free, "swap", "free", NULL);
247			}
248	ats	1.8	}
249
250			void populate_general() {
251			general_stat_t *gen = get_general_stats();
252	tdb	1.1
253			if (gen != NULL) {
254			add_stat(STRING, &gen->os_name,
255			"general", "os_name", NULL);
256			add_stat(STRING, &gen->os_release,
257			"general", "os_release", NULL);
258			add_stat(STRING, &gen->os_version,
259			"general", "os_version", NULL);
260			add_stat(STRING, &gen->platform, "general", "platform", NULL);
261			add_stat(STRING, &gen->hostname, "general", "hostname", NULL);
262			add_stat(TIME_T, &gen->uptime, "general", "uptime", NULL);
263			}
264	ats	1.8	}
265
266			void populate_fs() {
267			int n, i;
268			disk_stat_t *disk = get_disk_stats(&n);
269	tdb	1.1
270			if (disk != NULL) {
271			for (i = 0; i < n; i++) {
272			/* FIXME it'd be nicer if libstatgrab did this */
273	ats	1.10	char buf, name, *p;
274			const char *device = disk[i].device_name;
275
276			if (strcmp(device, "/") == 0)
277			device = "root";
278
279			buf = strdup(device);
280			if (buf == NULL)
281			die("out of memory");
282
283			name = buf;
284	ats	1.13	if (strlen(name) == 2 && name[1] == ':')
285			name[1] = '\0';
286	ats	1.10	if (strncmp(name, "/dev/", 5) == 0)
287			name += 5;
288			while ((p = strchr(name, '/')) != NULL)
289			*p = '_';
290
291	tdb	1.1	add_stat(STRING, &disk[i].device_name,
292			"fs", name, "device_name", NULL);
293			add_stat(STRING, &disk[i].fs_type,
294			"fs", name, "fs_type", NULL);
295			add_stat(STRING, &disk[i].mnt_point,
296			"fs", name, "mnt_point", NULL);
297			add_stat(LONG_LONG, &disk[i].size,
298			"fs", name, "size", NULL);
299			add_stat(LONG_LONG, &disk[i].used,
300			"fs", name, "used", NULL);
301			add_stat(LONG_LONG, &disk[i].avail,
302			"fs", name, "avail", NULL);
303			add_stat(LONG_LONG, &disk[i].total_inodes,
304			"fs", name, "total_inodes", NULL);
305			add_stat(LONG_LONG, &disk[i].used_inodes,
306			"fs", name, "used_inodes", NULL);
307			add_stat(LONG_LONG, &disk[i].free_inodes,
308			"fs", name, "free_inodes", NULL);
309	ats	1.10
310			free(buf);
311	tdb	1.1	}
312			}
313	ats	1.8	}
314
315			void populate_disk() {
316			int n, i;
317			diskio_stat_t *diskio;
318	tdb	1.1
319			diskio = use_diffs ? get_diskio_stats_diff(&n) : get_diskio_stats(&n);
320			if (diskio != NULL) {
321			for (i = 0; i < n; i++) {
322			const char *name = diskio[i].disk_name;
323
324			add_stat(STRING, &diskio[i].disk_name,
325			"disk", name, "disk_name", NULL);
326			add_stat(LONG_LONG, &diskio[i].read_bytes,
327			"disk", name, "read_bytes", NULL);
328			add_stat(LONG_LONG, &diskio[i].write_bytes,
329			"disk", name, "write_bytes", NULL);
330			add_stat(TIME_T, &diskio[i].systime,
331			"disk", name, "systime", NULL);
332			}
333			}
334	ats	1.8	}
335
336			void populate_proc() {
337			process_stat_t *proc = get_process_stats();
338	tdb	1.1
339			if (proc != NULL) {
340			add_stat(INT, &proc->total, "proc", "total", NULL);
341			add_stat(INT, &proc->running, "proc", "running", NULL);
342			add_stat(INT, &proc->sleeping, "proc", "sleeping", NULL);
343			add_stat(INT, &proc->stopped, "proc", "stopped", NULL);
344			add_stat(INT, &proc->zombie, "proc", "zombie", NULL);
345			}
346	ats	1.8	}
347
348			void populate_net() {
349			int n, i;
350			network_stat_t *net;
351	tdb	1.1
352			net = use_diffs ? get_network_stats_diff(&n) : get_network_stats(&n);
353			if (net != NULL) {
354			for (i = 0; i < n; i++) {
355			const char *name = net[i].interface_name;
356
357			add_stat(STRING, &net[i].interface_name,
358			"net", name, "interface_name", NULL);
359			add_stat(LONG_LONG, &net[i].tx,
360			"net", name, "tx", NULL);
361			add_stat(LONG_LONG, &net[i].rx,
362			"net", name, "rx", NULL);
363			add_stat(TIME_T, &net[i].systime,
364			"net", name, "systime", NULL);
365			}
366			}
367	ats	1.8	}
368
369			void populate_page() {
370			page_stat_t *page;
371	tdb	1.1
372			page = use_diffs ? get_page_stats_diff() : get_page_stats();
373			if (page != NULL) {
374			add_stat(LONG_LONG, &page->pages_pagein, "page", "in", NULL);
375			add_stat(LONG_LONG, &page->pages_pageout, "page", "out", NULL);
376	ats	1.11	add_stat(TIME_T, &page->systime, "page", "systime", NULL);
377	tdb	1.1	}
378	ats	1.8	}
379
380			typedef struct {
381			const char *name;
382			void (*populate)();
383			int interesting;
384			} toplevel;
385			toplevel toplevels[] = {
386			{"const.", populate_const, 0},
387			{"cpu.", populate_cpu, 0},
388			{"mem.", populate_mem, 0},
389			{"load.", populate_load, 0},
390			{"user.", populate_user, 0},
391			{"swap.", populate_swap, 0},
392			{"general.", populate_general, 0},
393			{"fs.", populate_fs, 0},
394			{"disk.", populate_disk, 0},
395			{"proc.", populate_proc, 0},
396			{"net.", populate_net, 0},
397			{"page.", populate_page, 0},
398			{NULL, NULL, 0}
399			};
400
401			/* Set the "interesting" flag on the sections that we actually need to
402			fetch. */
403			void select_interesting(int argc, char **argv) {
404			toplevel *t;
405
406			if (argc == 0) {
407			for (t = &toplevels[0]; t->name != NULL; t++)
408			t->interesting = 1;
409			} else {
410			int i;
411
412			for (i = 0; i < argc; i++) {
413			for (t = &toplevels[0]; t->name != NULL; t++) {
414			if (strncmp(argv[i], t->name,
415			strlen(t->name)) == 0) {
416			t->interesting = 1;
417			break;
418			}
419			}
420			}
421			}
422			}
423
424			/* Clear and rebuild the stats array. */
425			void get_stats() {
426			toplevel *t;
427
428			clear_stats();
429
430			for (t = &toplevels[0]; t->name != NULL; t++) {
431			if (t->interesting)
432			t->populate();
433			}
434	tdb	1.1
435			qsort(stats, num_stats, sizeof *stats, stats_compare);
436			}
437
438			/* Print the value of a stat. */
439			void print_stat_value(const stat *s) {
440			void *v = s->stat;
441
442			switch (s->type) {
443			case LONG_LONG:
444			printf("%lld", (long long )v);
445			break;
446			case TIME_T:
447			/* FIXME option for formatted time? */
448			printf("%ld", (time_t )v);
449			break;
450			case FLOAT:
451			printf("%f", (float )v);
452			break;
453			case DOUBLE:
454			printf("%f", (double )v);
455			break;
456			case STRING:
457			/* FIXME escaping? */
458			printf("%s", (char *)v);
459			break;
460			case INT:
461			printf("%d", (int )v);
462			break;
463			}
464			}
465
466			/* Print the name and value of a stat. */
467			void print_stat(const stat *s) {
468			switch (display_mode) {
469			case DISPLAY_LINUX:
470			printf("%s = ", s->name);
471			break;
472			case DISPLAY_BSD:
473			printf("%s: ", s->name);
474			break;
475			case DISPLAY_MRTG:
476			case DISPLAY_PLAIN:
477			break;
478			}
479			print_stat_value(s);
480			printf("\n");
481			}
482
483			/* Print stats as specified on the provided command line. */
484			void print_stats(int argc, char **argv) {
485			int i;
486
487			if (argc == optind) {
488			/* Print all stats. */
489			for (i = 0; i < num_stats; i++)
490			print_stat(&stats[i]);
491			} else {
492			/* Print selected stats. */
493			for (i = optind; i < argc; i++) {
494	ats	1.9	char *name = argv[i];
495	tdb	1.1	stat key;
496	ats	1.9	const stat s, end;
497			int (compare)(const void , const void *);
498
499			key.name = name;
500			if (name[strlen(name) - 1] == '.')
501			compare = stats_compare_prefix;
502			else
503			compare = stats_compare;
504	tdb	1.1
505			s = (const stat *)bsearch(&key, stats, num_stats,
506	ats	1.9	sizeof *stats, compare);
507			if (s == NULL) {
508			printf("Unknown stat %s\n", name);
509			continue;
510			}
511
512			/* Find the range of stats the user wanted. */
513			for (; s >= stats; s--) {
514			if (compare(&key, s) != 0)
515			break;
516			}
517			s++;
518			for (end = s; end < &stats[num_stats]; end++) {
519			if (compare(&key, end) != 0)
520			break;
521			}
522
523			/* And print them. */
524			for (; s < end; s++) {
525	tdb	1.1	print_stat(s);
526			}
527			}
528			}
529			}
530
531			void usage() {
532			printf("Usage: statgrab [OPTION]... [STAT]...\n"
533	ats	1.9	"Display system statistics.\n"
534			"\n"
535			"If no STATs are given, all will be displayed. Specify 'STAT.' to display all\n"
536			"statistics starting with that prefix.\n"
537	tdb	1.1	"\n");
538			printf(" -l Linux sysctl-style output (default)\n"
539			" -b BSD sysctl-style output\n"
540			" -m MRTG-compatible output\n"
541			" -u Plain output (only show values)\n"
542			" -n Display cumulative stats once (default)\n"
543			" -s Display stat differences repeatedly\n"
544			" -o Display stat differences once\n"
545			" -t DELAY When repeating, wait DELAY seconds between updates (default 1)\n"
546	ats	1.5	" -p Display CPU usage differences as percentages rather than\n"
547			" absolute values\n"
548	tdb	1.1	"\n");
549	tdb	1.2	printf("Version %s - report bugs to <%s>.\n",
550	ats	1.5	PACKAGE_VERSION, PACKAGE_BUGREPORT);
551	tdb	1.1	exit(1);
552			}
553
554			int main(int argc, char **argv) {
555			opterr = 0;
556			while (1) {
557			int c = getopt(argc, argv, "lbmunsot:p");
558			if (c == -1)
559			break;
560			switch (c) {
561			case 'l':
562			display_mode = DISPLAY_LINUX;
563			break;
564			case 'b':
565			display_mode = DISPLAY_BSD;
566			break;
567			case 'm':
568			display_mode = DISPLAY_MRTG;
569			break;
570			case 'u':
571			display_mode = DISPLAY_PLAIN;
572			break;
573			case 'n':
574			repeat_mode = REPEAT_NONE;
575			break;
576			case 's':
577			repeat_mode = REPEAT_FOREVER;
578			break;
579			case 'o':
580			repeat_mode = REPEAT_ONCE;
581			break;
582			case 't':
583			repeat_time = atoi(optarg);
584			break;
585			case 'p':
586			use_cpu_percent = 1;
587			break;
588			default:
589			usage();
590			}
591			}
592
593			if (display_mode == DISPLAY_MRTG) {
594			if ((argc - optind) != 2)
595			die("mrtg mode: must specify exactly two stats");
596	ats	1.5	if (repeat_mode == REPEAT_FOREVER)
597	tdb	1.1	die("mrtg mode: cannot repeat display");
598			}
599	ats	1.5
600			if (use_cpu_percent && repeat_mode == REPEAT_NONE)
601			die("CPU percentage usage display requires stat differences");
602	tdb	1.1
603	ats	1.8	if (repeat_mode == REPEAT_NONE)
604			use_diffs = 0;
605			else
606			use_diffs = 1;
607
608			select_interesting(argc - optind, &argv[optind]);
609
610	ats	1.12	/* We don't care if statgrab_init fails, because we can just display
611			the statistics that can be read as non-root. */
612			statgrab_init();
613	ats	1.15	if (statgrab_drop_privileges() != 0)
614			die("Failed to drop setuid/setgid privileges");
615	ats	1.12
616	tdb	1.1	switch (repeat_mode) {
617			case REPEAT_NONE:
618	ats	1.8	get_stats();
619	tdb	1.1	print_stats(argc, argv);
620			break;
621			case REPEAT_ONCE:
622	ats	1.8	get_stats();
623	tdb	1.1	sleep(repeat_time);
624	ats	1.8	get_stats();
625	tdb	1.1	print_stats(argc, argv);
626			break;
627			case REPEAT_FOREVER:
628			while (1) {
629	ats	1.8	get_stats();
630	tdb	1.1	print_stats(argc, argv);
631			printf("\n");
632			sleep(repeat_time);
633			}
634			}
635
636			if (display_mode == DISPLAY_MRTG) {
637			printf("\n");
638			printf("statgrab\n");
639			}
640
641			return 0;
642			}
643