[thirdparty/systemd.git] / src / cgtop.c

/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/

/***
  This file is part of systemd.

  Copyright 2012 Lennart Poettering

  systemd is free software; you can redistribute it and/or modify it
  under the terms of the GNU Lesser General Public License as published by
  the Free Software Foundation; either version 2.1 of the License, or
  (at your option) any later version.

  systemd 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
  Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public License
  along with systemd; If not, see <http://www.gnu.org/licenses/>.
***/

#include <errno.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <alloca.h>
#include <getopt.h>

#include "util.h"
#include "hashmap.h"
#include "cgroup-util.h"

typedef struct Group {
        char *path;

        bool n_tasks_valid:1;
        bool cpu_valid:1;
        bool memory_valid:1;
        bool io_valid:1;

        unsigned n_tasks;

        unsigned cpu_iteration;
        uint64_t cpu_usage;
        struct timespec cpu_timestamp;
        double cpu_fraction;

        uint64_t memory;

        unsigned io_iteration;
        uint64_t io_input, io_output;
        struct timespec io_timestamp;
        uint64_t io_input_bps, io_output_bps;
} Group;

static unsigned arg_depth = 2;
static usec_t arg_delay = 1*USEC_PER_SEC;

static enum {
        ORDER_PATH,
        ORDER_TASKS,
        ORDER_CPU,
        ORDER_MEMORY,
        ORDER_IO
} arg_order = ORDER_CPU;

static void group_free(Group *g) {
        assert(g);

        free(g->path);
        free(g);
}

static void group_hashmap_clear(Hashmap *h) {
        Group *g;

        while ((g = hashmap_steal_first(h)))
                group_free(g);
}

static void group_hashmap_free(Hashmap *h) {
        group_hashmap_clear(h);
        hashmap_free(h);
}

static int process(const char *controller, const char *path, Hashmap *a, Hashmap *b, unsigned iteration) {
        Group *g;
        int r;
        FILE *f;
        pid_t pid;
        unsigned n;

        assert(controller);
        assert(path);
        assert(a);

        g = hashmap_get(a, path);
        if (!g) {
                g = hashmap_get(b, path);
                if (!g) {
                        g = new0(Group, 1);
                        if (!g)
                                return -ENOMEM;

                        g->path = strdup(path);
                        if (!g->path) {
                                group_free(g);
                                return -ENOMEM;
                        }

                        r = hashmap_put(a, g->path, g);
                        if (r < 0) {
                                group_free(g);
                                return r;
                        }
                } else {
                        assert_se(hashmap_move_one(a, b, path) == 0);
                        g->cpu_valid = g->memory_valid = g->io_valid = g->n_tasks_valid = false;
                }
        }

        /* Regardless which controller, let's find the maximum number
         * of processes in any of it */

        r = cg_enumerate_tasks(controller, path, &f);
        if (r < 0)
                return r;

        n = 0;
        while (cg_read_pid(f, &pid) > 0)
                n++;
        fclose(f);

        if (n > 0) {
                if (g->n_tasks_valid)
                        g->n_tasks = MAX(g->n_tasks, n);
                else
                        g->n_tasks = n;

                g->n_tasks_valid = true;
        }

        if (streq(controller, "cpuacct")) {
                uint64_t new_usage;
                char *p, *v;
                struct timespec ts;

                r = cg_get_path(controller, path, "cpuacct.usage", &p);
                if (r < 0)
                        return r;

                r = read_one_line_file(p, &v);
                free(p);
                if (r < 0)
                        return r;

                r = safe_atou64(v, &new_usage);
                free(v);
                if (r < 0)
                        return r;

                assert_se(clock_gettime(CLOCK_MONOTONIC, &ts) == 0);

                if (g->cpu_iteration == iteration - 1) {
                        uint64_t x, y;

                        x = ((uint64_t) ts.tv_sec * 1000000000ULL + (uint64_t) ts.tv_nsec) -
                                ((uint64_t) g->cpu_timestamp.tv_sec * 1000000000ULL + (uint64_t) g->cpu_timestamp.tv_nsec);

                        y = new_usage - g->cpu_usage;

                        if (y > 0) {
                                g->cpu_fraction = (double) y / (double) x;
                                g->cpu_valid = true;
                        }
                }

                g->cpu_usage = new_usage;
                g->cpu_timestamp = ts;
                g->cpu_iteration = iteration;

        } else if (streq(controller, "memory")) {
                char *p, *v;

                r = cg_get_path(controller, path, "memory.usage_in_bytes", &p);
                if (r < 0)
                        return r;

                r = read_one_line_file(p, &v);
                free(p);
                if (r < 0)
                        return r;

                r = safe_atou64(v, &g->memory);
                free(v);
                if (r < 0)
                        return r;

                if (g->memory > 0)
                        g->memory_valid = true;

        } else if (streq(controller, "blkio")) {
                char *p;
                uint64_t wr = 0, rd = 0;
                struct timespec ts;

                r = cg_get_path(controller, path, "blkio.io_service_bytes", &p);
                if (r < 0)
                        return r;

                f = fopen(p, "re");
                free(p);

                if (!f)
                        return -errno;

                for (;;) {
                        char line[LINE_MAX], *l;
                        uint64_t k, *q;

                        if (!fgets(line, sizeof(line), f))
                                break;

                        l = strstrip(line);
                        l += strcspn(l, WHITESPACE);
                        l += strspn(l, WHITESPACE);

                        if (first_word(l, "Read")) {
                                l += 4;
                                q = &rd;
                        } else if (first_word(l, "Write")) {
                                l += 5;
                                q = &wr;
                        } else
                                continue;

                        l += strspn(l, WHITESPACE);
                        r = safe_atou64(l, &k);
                        if (r < 0)
                                continue;

                        *q += k;
                }

                fclose(f);

                assert_se(clock_gettime(CLOCK_MONOTONIC, &ts) == 0);

                if (g->io_iteration == iteration - 1) {
                        uint64_t x, yr, yw;

                        x = ((uint64_t) ts.tv_sec * 1000000000ULL + (uint64_t) ts.tv_nsec) -
                                ((uint64_t) g->io_timestamp.tv_sec * 1000000000ULL + (uint64_t) g->io_timestamp.tv_nsec);

                        yr = rd - g->io_input;
                        yw = wr - g->io_output;

                        if (yr > 0 || yw > 0) {
                                g->io_input_bps = (yr * 1000000000ULL) / x;
                                g->io_output_bps = (yw * 1000000000ULL) / x;
                                g->io_valid = true;

                        }
                }

                g->io_input = rd;
                g->io_output = wr;
                g->io_timestamp = ts;
                g->io_iteration = iteration;
        }

        return 0;
}

static int refresh_one(
                const char *controller,
                const char *path,
                Hashmap *a,
                Hashmap *b,
                unsigned iteration,
                unsigned depth) {

        DIR *d = NULL;
        int r;

        assert(controller);
        assert(path);
        assert(a);

        if (depth > arg_depth)
                return 0;

        r = process(controller, path, a, b, iteration);
        if (r < 0)
                return r;

        r = cg_enumerate_subgroups(controller, path, &d);
        if (r < 0) {
                if (r == ENOENT)
                        return 0;

                return r;
        }

        for (;;) {
                char *fn, *p;

                r = cg_read_subgroup(d, &fn);
                if (r <= 0)
                        goto finish;

                p = join(path, "/", fn, NULL);
                free(fn);

                if (!p) {
                        r = -ENOMEM;
                        goto finish;
                }

                path_kill_slashes(p);

                r = refresh_one(controller, p, a, b, iteration, depth + 1);
                free(p);

                if (r < 0)
                        goto finish;
        }

finish:
        if (d)
                closedir(d);

        return r;
}

static int refresh(Hashmap *a, Hashmap *b, unsigned iteration) {
        int r;

        assert(a);

        r = refresh_one("name=systemd", "/", a, b, iteration, 0);
        if (r < 0)
                return r;

        r = refresh_one("cpuacct", "/", a, b, iteration, 0);
        if (r < 0)
                return r;

        r = refresh_one("memory", "/", a, b, iteration, 0);
        if (r < 0)
                return r;

        return refresh_one("blkio", "/", a, b, iteration, 0);
}

static int group_compare(const void*a, const void *b) {
        const Group *x = *(Group**)a, *y = *(Group**)b;

        if (path_startswith(y->path, x->path))
                return -1;
        if (path_startswith(x->path, y->path))
                return 1;

        if (arg_order == ORDER_CPU) {
                if (x->cpu_valid && y->cpu_valid) {

                        if (x->cpu_fraction > y->cpu_fraction)
                                return -1;
                        else if (x->cpu_fraction < y->cpu_fraction)
                                return 1;
                } else if (x->cpu_valid)
                        return -1;
                else if (y->cpu_valid)
                        return 1;
        }

        if (arg_order == ORDER_TASKS) {

                if (x->n_tasks_valid && y->n_tasks_valid) {
                        if (x->n_tasks > y->n_tasks)
                                return -1;
                        else if (x->n_tasks < y->n_tasks)
                                return 1;
                } else if (x->n_tasks_valid)
                        return -1;
                else if (y->n_tasks_valid)
                        return 1;
        }

        if (arg_order == ORDER_MEMORY) {
                if (x->memory_valid && y->memory_valid) {
                        if (x->memory > y->memory)
                                return -1;
                        else if (x->memory < y->memory)
                                return 1;
                } else if (x->memory_valid)
                        return -1;
                else if (y->memory_valid)
                        return 1;
        }

        if (arg_order == ORDER_IO) {
                if (x->io_valid && y->io_valid) {
                        if (x->io_input_bps + x->io_output_bps > y->io_input_bps + y->io_output_bps)
                                return -1;
                        else if (x->io_input_bps + x->io_output_bps < y->io_input_bps + y->io_output_bps)
                                return 1;
                } else if (x->io_valid)
                        return -1;
                else if (y->io_valid)
                        return 1;
        }

        return strcmp(x->path, y->path);
}

static int display(Hashmap *a) {
        Iterator i;
        Group *g;
        Group **array;
        unsigned rows, n = 0, j;

        assert(a);

        /* Set cursor to top left corner and clear screen */
        fputs("\033[H"
              "\033[2J", stdout);

        array = alloca(sizeof(Group*) * hashmap_size(a));

        HASHMAP_FOREACH(g, a, i)
                if (g->n_tasks_valid || g->cpu_valid || g->memory_valid || g->io_valid)
                        array[n++] = g;

        qsort(array, n, sizeof(Group*), group_compare);

        rows = fd_lines(STDOUT_FILENO);
        if (rows <= 0)
                rows = 25;

        printf("%s%-37s%s %s%7s%s %s%6s%s %s%8s%s %s%8s%s %s%8s%s\n\n",
               arg_order == ORDER_PATH   ? ANSI_HIGHLIGHT_ON : "", "Path",     arg_order == ORDER_PATH   ? ANSI_HIGHLIGHT_OFF : "",
               arg_order == ORDER_TASKS  ? ANSI_HIGHLIGHT_ON : "", "Tasks",    arg_order == ORDER_TASKS  ? ANSI_HIGHLIGHT_OFF : "",
               arg_order == ORDER_CPU    ? ANSI_HIGHLIGHT_ON : "", "%CPU",     arg_order == ORDER_CPU    ? ANSI_HIGHLIGHT_OFF : "",
               arg_order == ORDER_MEMORY ? ANSI_HIGHLIGHT_ON : "", "Memory",   arg_order == ORDER_MEMORY ? ANSI_HIGHLIGHT_OFF : "",
               arg_order == ORDER_IO     ? ANSI_HIGHLIGHT_ON : "", "Input/s",  arg_order == ORDER_IO     ? ANSI_HIGHLIGHT_OFF : "",
               arg_order == ORDER_IO     ? ANSI_HIGHLIGHT_ON : "", "Output/s", arg_order == ORDER_IO     ? ANSI_HIGHLIGHT_OFF : "");

        for (j = 0; j < n; j++) {
                char *p;
                char m[FORMAT_BYTES_MAX];

                if (j + 5 > rows)
                        break;

                g = array[j];

                p = ellipsize(g->path, 37, 33);
                printf("%-37s", p ? p : g->path);
                free(p);

                if (g->n_tasks_valid)
                        printf(" %7u", g->n_tasks);
                else
                        fputs("       -", stdout);

                if (g->cpu_valid)
                        printf(" %6.1f", g->cpu_fraction*100);
                else
                        fputs("      -", stdout);

                if (g->memory_valid)
                        printf(" %8s", format_bytes(m, sizeof(m), g->memory));
                else
                        fputs("        -", stdout);

                if (g->io_valid) {
                        printf(" %8s",
                               format_bytes(m, sizeof(m), g->io_input_bps));
                        printf(" %8s",
                               format_bytes(m, sizeof(m), g->io_output_bps));
                } else
                        fputs("        -        -", stdout);

                putchar('\n');
        }

        return 0;
}

static void help(void) {

        printf("%s [OPTIONS...]\n\n"
               "Show top control groups by their resource usage.\n\n"
               "  -h --help           Show this help\n"
               "  -p                  Order by path\n"
               "  -t                  Order by number of tasks\n"
               "  -c                  Order by CPU load\n"
               "  -m                  Order by memory load\n"
               "  -i                  Order by IO load\n"
               "  -d --delay=DELAY    Specify delay\n"
               "     --depth=DEPTH    Maximum traversal depth (default: 2)\n",
               program_invocation_short_name);
}

static int parse_argv(int argc, char *argv[]) {

        enum {
                ARG_DEPTH = 0x100
        };

        static const struct option options[] = {
                { "help",  no_argument,       NULL, 'h'       },
                { "delay", required_argument, NULL, 'd'       },
                { "depth", required_argument, NULL, ARG_DEPTH },
                { NULL,    0,                 NULL, 0         }
        };

        int c;
        int r;

        assert(argc >= 1);
        assert(argv);

        while ((c = getopt_long(argc, argv, "hptcmid:", options, NULL)) >= 0) {

                switch (c) {

                case 'h':
                        help();
                        return 0;

                case ARG_DEPTH:
                        r = safe_atou(optarg, &arg_depth);
                        if (r < 0) {
                                log_error("Failed to parse depth parameter.");
                                return -EINVAL;
                        }

                        break;

                case 'd':
                        r = parse_usec(optarg, &arg_delay);
                        if (r < 0 || arg_delay <= 0) {
                                log_error("Failed to parse delay parameter.");
                                return -EINVAL;
                        }

                        break;

                case 'p':
                        arg_order = ORDER_PATH;
                        break;

                case 't':
                        arg_order = ORDER_TASKS;
                        break;

                case 'c':
                        arg_order = ORDER_CPU;
                        break;

                case 'm':
                        arg_order = ORDER_MEMORY;
                        break;

                case 'i':
                        arg_order = ORDER_IO;
                        break;

                case '?':
                        return -EINVAL;

                default:
                        log_error("Unknown option code %c", c);
                        return -EINVAL;
                }
        }

        if (optind < argc) {
                log_error("Too many arguments.");
                return -EINVAL;
        }

        return 1;
}

int main(int argc, char *argv[]) {
        int r;
        Hashmap *a = NULL, *b = NULL;
        unsigned iteration = 0;
        usec_t last_refresh = 0;
        bool quit = false, immediate_refresh = false;

        log_parse_environment();
        log_open();

        r = parse_argv(argc, argv);
        if (r <= 0)
                goto finish;

        a = hashmap_new(string_hash_func, string_compare_func);
        b = hashmap_new(string_hash_func, string_compare_func);
        if (!a || !b) {
                log_error("Out of memory");
                r = -ENOMEM;
                goto finish;
        }

        while (!quit) {
                Hashmap *c;
                usec_t t;
                char key;
                char h[FORMAT_TIMESPAN_MAX];

                t = now(CLOCK_MONOTONIC);

                if (t >= last_refresh + arg_delay || immediate_refresh) {

                        r = refresh(a, b, iteration++);
                        if (r < 0)
                                goto finish;

                        group_hashmap_clear(b);

                        c = a;
                        a = b;
                        b = c;

                        last_refresh = t;
                        immediate_refresh = false;
                }

                r = display(b);
                if (r < 0)
                        goto finish;

                r = read_one_char(stdin, &key, last_refresh + arg_delay - t, NULL);
                if (r == -ETIMEDOUT)
                        continue;
                if (r < 0) {
                        log_error("Couldn't read key: %s", strerror(-r));
                        goto finish;
                }

                fputs("\r \r", stdout);
                fflush(stdout);

                switch (key) {

                case ' ':
                        immediate_refresh = true;
                        break;

                case 'q':
                        quit = true;
                        break;

                case 'p':
                        arg_order = ORDER_PATH;
                        break;

                case 't':
                        arg_order = ORDER_TASKS;
                        break;

                case 'c':
                        arg_order = ORDER_CPU;
                        break;

                case 'm':
                        arg_order = ORDER_MEMORY;
                        break;

                case 'i':
                        arg_order = ORDER_IO;
                        break;

                case '+':
                        if (arg_delay < USEC_PER_SEC)
                                arg_delay += USEC_PER_MSEC*250;
                        else
                                arg_delay += USEC_PER_SEC;

                        fprintf(stdout, "\nIncreased delay to %s.", format_timespan(h, sizeof(h), arg_delay));
                        fflush(stdout);
                        sleep(1);
                        break;

                case '-':
                        if (arg_delay <= USEC_PER_MSEC*500)
                                arg_delay = USEC_PER_MSEC*250;
                        else if (arg_delay < USEC_PER_MSEC*1250)
                                arg_delay -= USEC_PER_MSEC*250;
                        else
                                arg_delay -= USEC_PER_SEC;

                        fprintf(stdout, "\nDecreased delay to %s.", format_timespan(h, sizeof(h), arg_delay));
                        fflush(stdout);
                        sleep(1);
                        break;

                case '?':
                case 'h':
                        fprintf(stdout,
                                "\t<" ANSI_HIGHLIGHT_ON "P" ANSI_HIGHLIGHT_OFF "> By path; <" ANSI_HIGHLIGHT_ON "T" ANSI_HIGHLIGHT_OFF "> By tasks; <" ANSI_HIGHLIGHT_ON "C" ANSI_HIGHLIGHT_OFF "> By CPU; <" ANSI_HIGHLIGHT_ON "M" ANSI_HIGHLIGHT_OFF "> By memory; <" ANSI_HIGHLIGHT_ON "I" ANSI_HIGHLIGHT_OFF "> By I/O\n"
                                "\t<" ANSI_HIGHLIGHT_ON "Q" ANSI_HIGHLIGHT_OFF "> Quit; <" ANSI_HIGHLIGHT_ON "+" ANSI_HIGHLIGHT_OFF "> Increase delay; <" ANSI_HIGHLIGHT_ON "-" ANSI_HIGHLIGHT_OFF "> Decrease delay; <" ANSI_HIGHLIGHT_ON "SPACE" ANSI_HIGHLIGHT_OFF "> Refresh");
                        fflush(stdout);
                        sleep(3);
                        break;

                default:
                        fprintf(stdout, "\nUnknown key '%c'. Ignoring.", key);
                        fflush(stdout);
                        sleep(1);
                        break;
                }
        }

        log_info("Exiting.");

        r = 0;

finish:
        group_hashmap_free(a);
        group_hashmap_free(b);

        return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
}
Commit	Line	Data
8f2d43a0 LP	1	/-- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil --/
	2
	3	/***
	4	This file is part of systemd.
	5
	6	Copyright 2012 Lennart Poettering
	7
	8	systemd is free software; you can redistribute it and/or modify it
5430f7f2 LP	9	under the terms of the GNU Lesser General Public License as published by
5430f7f2 LP	10	the Free Software Foundation; either version 2.1 of the License, or
8f2d43a0 LP	11	(at your option) any later version.
	12
	13	systemd is distributed in the hope that it will be useful, but
	14	WITHOUT ANY WARRANTY; without even the implied warranty of
	15	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
5430f7f2	16	Lesser General Public License for more details.
8f2d43a0	17
5430f7f2	18	You should have received a copy of the GNU Lesser General Public License
8f2d43a0 LP	19	along with systemd; If not, see <http://www.gnu.org/licenses/>.
	20	***/
	21
	22	#include <errno.h>
	23	#include <string.h>
	24	#include <stdlib.h>
	25	#include <unistd.h>
	26	#include <alloca.h>
	27	#include <getopt.h>
	28
	29	#include "util.h"
	30	#include "hashmap.h"
	31	#include "cgroup-util.h"
	32
	33	typedef struct Group {
	34	char *path;
	35
	36	bool n_tasks_valid:1;
	37	bool cpu_valid:1;
	38	bool memory_valid:1;
	39	bool io_valid:1;
	40
	41	unsigned n_tasks;
	42
	43	unsigned cpu_iteration;
	44	uint64_t cpu_usage;
	45	struct timespec cpu_timestamp;
	46	double cpu_fraction;
	47
	48	uint64_t memory;
	49
	50	unsigned io_iteration;
	51	uint64_t io_input, io_output;
	52	struct timespec io_timestamp;
	53	uint64_t io_input_bps, io_output_bps;
	54	} Group;
	55
	56	static unsigned arg_depth = 2;
	57	static usec_t arg_delay = 1*USEC_PER_SEC;
	58
	59	static enum {
	60	ORDER_PATH,
	61	ORDER_TASKS,
	62	ORDER_CPU,
	63	ORDER_MEMORY,
	64	ORDER_IO
	65	} arg_order = ORDER_CPU;
	66
	67	static void group_free(Group *g) {
	68	assert(g);
	69
	70	free(g->path);
	71	free(g);
	72	}
	73
	74	static void group_hashmap_clear(Hashmap *h) {
	75	Group *g;
	76
	77	while ((g = hashmap_steal_first(h)))
	78	group_free(g);
	79	}
	80
	81	static void group_hashmap_free(Hashmap *h) {
	82	group_hashmap_clear(h);
83	hashmap_free(h);
84	}
85
86	static int process(const char controller, const char path, Hashmap a, Hashmap b, unsigned iteration) {
87	Group *g;
88	int r;
89	FILE *f;
90	pid_t pid;
91	unsigned n;
92
93	assert(controller);
94	assert(path);
95	assert(a);
96
97	g = hashmap_get(a, path);
98	if (!g) {
99	g = hashmap_get(b, path);
100	if (!g) {
101	g = new0(Group, 1);
102	if (!g)
103	return -ENOMEM;
104
105	g->path = strdup(path);
106	if (!g->path) {
107	group_free(g);
108	return -ENOMEM;
109	}
110
111	r = hashmap_put(a, g->path, g);
112	if (r < 0) {
113	group_free(g);
114	return r;
115	}
116	} else {
117	assert_se(hashmap_move_one(a, b, path) == 0);
118	g->cpu_valid = g->memory_valid = g->io_valid = g->n_tasks_valid = false;
119	}
120	}
121
122	/* Regardless which controller, let's find the maximum number
123	* of processes in any of it */
124
125	r = cg_enumerate_tasks(controller, path, &f);
126	if (r < 0)
127	return r;
128
129	n = 0;
130	while (cg_read_pid(f, &pid) > 0)
131	n++;
132	fclose(f);
133
134	if (n > 0) {
135	if (g->n_tasks_valid)
136	g->n_tasks = MAX(g->n_tasks, n);
137	else
138	g->n_tasks = n;
139
140	g->n_tasks_valid = true;
141	}
142
143	if (streq(controller, "cpuacct")) {
144	uint64_t new_usage;
145	char p, v;
146	struct timespec ts;
147
148	r = cg_get_path(controller, path, "cpuacct.usage", &p);
149	if (r < 0)
150	return r;
151
152	r = read_one_line_file(p, &v);
153	free(p);
154	if (r < 0)
155	return r;
156
157	r = safe_atou64(v, &new_usage);
158	free(v);
159	if (r < 0)
160	return r;
161
162	assert_se(clock_gettime(CLOCK_MONOTONIC, &ts) == 0);
163
164	if (g->cpu_iteration == iteration - 1) {
165	uint64_t x, y;
166
167	x = ((uint64_t) ts.tv_sec * 1000000000ULL + (uint64_t) ts.tv_nsec) -
168	((uint64_t) g->cpu_timestamp.tv_sec * 1000000000ULL + (uint64_t) g->cpu_timestamp.tv_nsec);
169
170	y = new_usage - g->cpu_usage;
171
172	if (y > 0) {
173	g->cpu_fraction = (double) y / (double) x;
174	g->cpu_valid = true;
175	}
176	}
177
178	g->cpu_usage = new_usage;
179	g->cpu_timestamp = ts;
180	g->cpu_iteration = iteration;
181
182	} else if (streq(controller, "memory")) {
183	char p, v;
184
185	r = cg_get_path(controller, path, "memory.usage_in_bytes", &p);
186	if (r < 0)
187	return r;
188
189	r = read_one_line_file(p, &v);
190	free(p);
191	if (r < 0)
192	return r;
193
194	r = safe_atou64(v, &g->memory);
195	free(v);
196	if (r < 0)
197	return r;
198
199	if (g->memory > 0)
200	g->memory_valid = true;
201
202	} else if (streq(controller, "blkio")) {
203	char *p;
204	uint64_t wr = 0, rd = 0;
205	struct timespec ts;
206
207	r = cg_get_path(controller, path, "blkio.io_service_bytes", &p);
208	if (r < 0)
209	return r;
210
211	f = fopen(p, "re");
212	free(p);
213
214	if (!f)
215	return -errno;
216
217	for (;;) {
218	char line[LINE_MAX], *l;
219	uint64_t k, *q;
220
221	if (!fgets(line, sizeof(line), f))
222	break;
223
224	l = strstrip(line);
225	l += strcspn(l, WHITESPACE);
226	l += strspn(l, WHITESPACE);
227
228	if (first_word(l, "Read")) {
229	l += 4;
230	q = &rd;
231	} else if (first_word(l, "Write")) {
232	l += 5;
233	q = &wr;
234	} else
235	continue;
236
237	l += strspn(l, WHITESPACE);
238	r = safe_atou64(l, &k);
239	if (r < 0)
240	continue;
241
242	*q += k;
243	}
244
245	fclose(f);
246
247	assert_se(clock_gettime(CLOCK_MONOTONIC, &ts) == 0);
248
249	if (g->io_iteration == iteration - 1) {
250	uint64_t x, yr, yw;
251
252	x = ((uint64_t) ts.tv_sec * 1000000000ULL + (uint64_t) ts.tv_nsec) -
253	((uint64_t) g->io_timestamp.tv_sec * 1000000000ULL + (uint64_t) g->io_timestamp.tv_nsec);
254
255	yr = rd - g->io_input;
256	yw = wr - g->io_output;
257
258	if (yr > 0 \|\| yw > 0) {
259	g->io_input_bps = (yr * 1000000000ULL) / x;
260	g->io_output_bps = (yw * 1000000000ULL) / x;
261	g->io_valid = true;
262
263	}
264	}
265
266	g->io_input = rd;
267	g->io_output = wr;
268	g->io_timestamp = ts;
269	g->io_iteration = iteration;
270	}
271
272	return 0;
273	}
274
275	static int refresh_one(
276	const char *controller,
277	const char *path,
278	Hashmap *a,
279	Hashmap *b,
280	unsigned iteration,
281	unsigned depth) {
282
283	DIR *d = NULL;
284	int r;
285
286	assert(controller);
287	assert(path);
288	assert(a);
289
290	if (depth > arg_depth)
291	return 0;
292
293	r = process(controller, path, a, b, iteration);
294	if (r < 0)
295	return r;
296
297	r = cg_enumerate_subgroups(controller, path, &d);
298	if (r < 0) {
299	if (r == ENOENT)
300	return 0;
301
302	return r;
303	}
304
305	for (;;) {
306	char fn, p;
307
308	r = cg_read_subgroup(d, &fn);
309	if (r <= 0)
310	goto finish;
311
312	p = join(path, "/", fn, NULL);
313	free(fn);
314
315	if (!p) {
316	r = -ENOMEM;
317	goto finish;
318	}
319
320	path_kill_slashes(p);
321
322	r = refresh_one(controller, p, a, b, iteration, depth + 1);
323	free(p);
324
325	if (r < 0)
326	goto finish;
327	}
328
329	finish:
330	if (d)
331	closedir(d);
332
333	return r;
334	}
335
336	static int refresh(Hashmap a, Hashmap b, unsigned iteration) {
337	int r;
338
339	assert(a);
340
341	r = refresh_one("name=systemd", "/", a, b, iteration, 0);
342	if (r < 0)
343	return r;
344
345	r = refresh_one("cpuacct", "/", a, b, iteration, 0);
346	if (r < 0)
347	return r;
348
349	r = refresh_one("memory", "/", a, b, iteration, 0);
350	if (r < 0)
351	return r;
352
353	return refresh_one("blkio", "/", a, b, iteration, 0);
354	}
355
356	static int group_compare(const voida, const void b) {
357	const Group x = (Group*)a, y = (Group*)b;
358
359	if (path_startswith(y->path, x->path))
360	return -1;
361	if (path_startswith(x->path, y->path))
362	return 1;
363
364	if (arg_order == ORDER_CPU) {
365	if (x->cpu_valid && y->cpu_valid) {
366
367	if (x->cpu_fraction > y->cpu_fraction)
368	return -1;
369	else if (x->cpu_fraction < y->cpu_fraction)
370	return 1;
371	} else if (x->cpu_valid)
372	return -1;
373	else if (y->cpu_valid)
374	return 1;
375	}
376
377	if (arg_order == ORDER_TASKS) {
378
379	if (x->n_tasks_valid && y->n_tasks_valid) {
380	if (x->n_tasks > y->n_tasks)
381	return -1;
382	else if (x->n_tasks < y->n_tasks)
383	return 1;
384	} else if (x->n_tasks_valid)
385	return -1;
386	else if (y->n_tasks_valid)
387	return 1;
388	}
389
390	if (arg_order == ORDER_MEMORY) {
391	if (x->memory_valid && y->memory_valid) {
392	if (x->memory > y->memory)
393	return -1;
394	else if (x->memory < y->memory)
395	return 1;
396	} else if (x->memory_valid)
397	return -1;
398	else if (y->memory_valid)
399	return 1;
400	}
401
402	if (arg_order == ORDER_IO) {
403	if (x->io_valid && y->io_valid) {
404	if (x->io_input_bps + x->io_output_bps > y->io_input_bps + y->io_output_bps)
405	return -1;
406	else if (x->io_input_bps + x->io_output_bps < y->io_input_bps + y->io_output_bps)
407	return 1;
408	} else if (x->io_valid)
409	return -1;
410	else if (y->io_valid)
411	return 1;
412	}
413
414	return strcmp(x->path, y->path);
415	}
416
417	static int display(Hashmap *a) {
418	Iterator i;
419	Group *g;
420	Group **array;
421	unsigned rows, n = 0, j;
422
423	assert(a);
424
425	/* Set cursor to top left corner and clear screen */
426	fputs("\033[H"
427	"\033[2J", stdout);
428
429	array = alloca(sizeof(Group) hashmap_size(a));
430
431	HASHMAP_FOREACH(g, a, i)
432	if (g->n_tasks_valid \|\| g->cpu_valid \|\| g->memory_valid \|\| g->io_valid)
433	array[n++] = g;
434
435	qsort(array, n, sizeof(Group*), group_compare);
436
437	rows = fd_lines(STDOUT_FILENO);
438	if (rows <= 0)
439	rows = 25;
440
441	printf("%s%-37s%s %s%7s%s %s%6s%s %s%8s%s %s%8s%s %s%8s%s\n\n",
442	arg_order == ORDER_PATH ? ANSI_HIGHLIGHT_ON : "", "Path", arg_order == ORDER_PATH ? ANSI_HIGHLIGHT_OFF : "",
443	arg_order == ORDER_TASKS ? ANSI_HIGHLIGHT_ON : "", "Tasks", arg_order == ORDER_TASKS ? ANSI_HIGHLIGHT_OFF : "",
444	arg_order == ORDER_CPU ? ANSI_HIGHLIGHT_ON : "", "%CPU", arg_order == ORDER_CPU ? ANSI_HIGHLIGHT_OFF : "",
445	arg_order == ORDER_MEMORY ? ANSI_HIGHLIGHT_ON : "", "Memory", arg_order == ORDER_MEMORY ? ANSI_HIGHLIGHT_OFF : "",
446	arg_order == ORDER_IO ? ANSI_HIGHLIGHT_ON : "", "Input/s", arg_order == ORDER_IO ? ANSI_HIGHLIGHT_OFF : "",
447	arg_order == ORDER_IO ? ANSI_HIGHLIGHT_ON : "", "Output/s", arg_order == ORDER_IO ? ANSI_HIGHLIGHT_OFF : "");
448
449	for (j = 0; j < n; j++) {
450	char *p;
451	char m[FORMAT_BYTES_MAX];
452
453	if (j + 5 > rows)
454	break;
455
456	g = array[j];
457
458	p = ellipsize(g->path, 37, 33);
459	printf("%-37s", p ? p : g->path);
460	free(p);
461
462	if (g->n_tasks_valid)
463	printf(" %7u", g->n_tasks);
464	else
465	fputs(" -", stdout);
466
467	if (g->cpu_valid)
468	printf(" %6.1f", g->cpu_fraction*100);
469	else
470	fputs(" -", stdout);
471
472	if (g->memory_valid)
473	printf(" %8s", format_bytes(m, sizeof(m), g->memory));
474	else
475	fputs(" -", stdout);
476
477	if (g->io_valid) {
478	printf(" %8s",
479	format_bytes(m, sizeof(m), g->io_input_bps));
480	printf(" %8s",
481	format_bytes(m, sizeof(m), g->io_output_bps));
482	} else
483	fputs(" - -", stdout);
484
485	putchar('\n');
486	}
487
488	return 0;
489	}
490
491	static void help(void) {
492
493	printf("%s [OPTIONS...]\n\n"
494	"Show top control groups by their resource usage.\n\n"
495	" -h --help Show this help\n"
496	" -p Order by path\n"
497	" -t Order by number of tasks\n"
498	" -c Order by CPU load\n"
499	" -m Order by memory load\n"
500	" -i Order by IO load\n"
501	" -d --delay=DELAY Specify delay\n"
caa94887	502	" --depth=DEPTH Maximum traversal depth (default: 2)\n",
8f2d43a0 LP	503	program_invocation_short_name);
	504	}
	505
	506	static int parse_argv(int argc, char *argv[]) {
	507
	508	enum {
	509	ARG_DEPTH = 0x100
	510	};
	511
	512	static const struct option options[] = {
	513	{ "help", no_argument, NULL, 'h' },
	514	{ "delay", required_argument, NULL, 'd' },
	515	{ "depth", required_argument, NULL, ARG_DEPTH },
	516	{ NULL, 0, NULL, 0 }
	517	};
	518
	519	int c;
	520	int r;
	521
	522	assert(argc >= 1);
	523	assert(argv);
	524
	525	while ((c = getopt_long(argc, argv, "hptcmid:", options, NULL)) >= 0) {
	526
	527	switch (c) {
	528
	529	case 'h':
	530	help();
	531	return 0;
	532
	533	case ARG_DEPTH:
	534	r = safe_atou(optarg, &arg_depth);
	535	if (r < 0) {
	536	log_error("Failed to parse depth parameter.");
	537	return -EINVAL;
	538	}
	539
	540	break;
	541
	542	case 'd':
	543	r = parse_usec(optarg, &arg_delay);
	544	if (r < 0 \|\| arg_delay <= 0) {
	545	log_error("Failed to parse delay parameter.");
	546	return -EINVAL;
	547	}
	548
	549	break;
	550
	551	case 'p':
	552	arg_order = ORDER_PATH;
	553	break;
	554
	555	case 't':
	556	arg_order = ORDER_TASKS;
	557	break;
	558
	559	case 'c':
	560	arg_order = ORDER_CPU;
	561	break;
	562
	563	case 'm':
	564	arg_order = ORDER_MEMORY;
	565	break;
	566
567	case 'i':
568	arg_order = ORDER_IO;
569	break;
570
571	case '?':
572	return -EINVAL;
573
574	default:
575	log_error("Unknown option code %c", c);
576	return -EINVAL;
577	}
578	}
579
580	if (optind < argc) {
581	log_error("Too many arguments.");
582	return -EINVAL;
583	}
584
585	return 1;
586	}
587
588	int main(int argc, char *argv[]) {
589	int r;
590	Hashmap a = NULL, b = NULL;
591	unsigned iteration = 0;
592	usec_t last_refresh = 0;
593	bool quit = false, immediate_refresh = false;
594
595	log_parse_environment();
596	log_open();
597
598	r = parse_argv(argc, argv);
599	if (r <= 0)
600	goto finish;
601
602	a = hashmap_new(string_hash_func, string_compare_func);
603	b = hashmap_new(string_hash_func, string_compare_func);
604	if (!a \|\| !b) {
605	log_error("Out of memory");
606	r = -ENOMEM;
607	goto finish;
608	}
609
610	while (!quit) {
611	Hashmap *c;
612	usec_t t;
613	char key;
614	char h[FORMAT_TIMESPAN_MAX];
615
616	t = now(CLOCK_MONOTONIC);
617
618	if (t >= last_refresh + arg_delay \|\| immediate_refresh) {
619
620	r = refresh(a, b, iteration++);
621	if (r < 0)
622	goto finish;
623
624	group_hashmap_clear(b);
625
626	c = a;
627	a = b;
628	b = c;
629
630	last_refresh = t;
631	immediate_refresh = false;
632	}
633
634	r = display(b);
635	if (r < 0)
636	goto finish;
637
638	r = read_one_char(stdin, &key, last_refresh + arg_delay - t, NULL);
639	if (r == -ETIMEDOUT)
640	continue;
641	if (r < 0) {
642	log_error("Couldn't read key: %s", strerror(-r));
643	goto finish;
644	}
645
646	fputs("\r \r", stdout);
647	fflush(stdout);
648
649	switch (key) {
650
651	case ' ':
652	immediate_refresh = true;
653	break;
654
655	case 'q':
656	quit = true;
657	break;
658
659	case 'p':
660	arg_order = ORDER_PATH;
661	break;
662
663	case 't':
664	arg_order = ORDER_TASKS;
665	break;
666
667	case 'c':
668	arg_order = ORDER_CPU;
669	break;
670
671	case 'm':
672	arg_order = ORDER_MEMORY;
673	break;
674
675	case 'i':
676	arg_order = ORDER_IO;
677	break;
678
679	case '+':
680	if (arg_delay < USEC_PER_SEC)
681	arg_delay += USEC_PER_MSEC*250;
682	else
683	arg_delay += USEC_PER_SEC;
684
685	fprintf(stdout, "\nIncreased delay to %s.", format_timespan(h, sizeof(h), arg_delay));
686	fflush(stdout);
687	sleep(1);
688	break;
689
690	case '-':
691	if (arg_delay <= USEC_PER_MSEC*500)
692	arg_delay = USEC_PER_MSEC*250;
693	else if (arg_delay < USEC_PER_MSEC*1250)
694	arg_delay -= USEC_PER_MSEC*250;
695	else
696	arg_delay -= USEC_PER_SEC;
697
698	fprintf(stdout, "\nDecreased delay to %s.", format_timespan(h, sizeof(h), arg_delay));
699	fflush(stdout);
700	sleep(1);
701	break;
702
703	case '?':
704	case 'h':
705	fprintf(stdout,
706	"\t<" ANSI_HIGHLIGHT_ON "P" ANSI_HIGHLIGHT_OFF "> By path; <" ANSI_HIGHLIGHT_ON "T" ANSI_HIGHLIGHT_OFF "> By tasks; <" ANSI_HIGHLIGHT_ON "C" ANSI_HIGHLIGHT_OFF "> By CPU; <" ANSI_HIGHLIGHT_ON "M" ANSI_HIGHLIGHT_OFF "> By memory; <" ANSI_HIGHLIGHT_ON "I" ANSI_HIGHLIGHT_OFF "> By I/O\n"
707	"\t<" ANSI_HIGHLIGHT_ON "Q" ANSI_HIGHLIGHT_OFF "> Quit; <" ANSI_HIGHLIGHT_ON "+" ANSI_HIGHLIGHT_OFF "> Increase delay; <" ANSI_HIGHLIGHT_ON "-" ANSI_HIGHLIGHT_OFF "> Decrease delay; <" ANSI_HIGHLIGHT_ON "SPACE" ANSI_HIGHLIGHT_OFF "> Refresh");
708	fflush(stdout);
709	sleep(3);
710	break;
711
712	default:
713	fprintf(stdout, "\nUnknown key '%c'. Ignoring.", key);
714	fflush(stdout);
715	sleep(1);
716	break;
717	}
718	}
719
720	log_info("Exiting.");
721
722	r = 0;
723
724	finish:
725	group_hashmap_free(a);
726	group_hashmap_free(b);
727
728	return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;
729	}