[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 General Public License as published by
  the Free Software Foundation; either version 2 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
  General Public License for more details.

  You should have received a copy of the GNU 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\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
	9	under the terms of the GNU General Public License as published by
	10	the Free Software Foundation; either version 2 of the License, or
	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
	16	General Public License for more details.
	17
	18	You should have received a copy of the GNU General Public License
	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"
502	" --depth=DEPTH Maximum traversal depth\n",
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	}