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: statgrab.c,v 1.19 2004/02/13 15:13:37 ats Exp $
 */

#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,
        BOOL,
        DUPLEX
} 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;
        network_iface_stat_t *iface;

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

        iface = get_network_iface_stats(&n);
        if (iface != NULL) {
                for (i = 0; i < n; i++) {
                        const char *name = iface[i].interface_name;

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