[thirdparty/systemd.git] / src / cgtop / 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/>.
***/

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

#include "path-util.h"
#include "util.h"
#include "hashmap.h"
#include "cgroup-util.h"
#include "build.h"
#include "fileio.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 = 3;
static unsigned arg_iterations = 0;
static bool arg_batch = false;
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 enum {
        CPU_PERCENT,
        CPU_TIME,
} arg_cpu_type = CPU_PERCENT;

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 = strjoin(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)
                if (r != -ENOENT)
                    return r;
        r = refresh_one("cpuacct", "/", a, b, iteration, 0);
        if (r < 0)
                if (r != -ENOENT)
                    return r;
        r = refresh_one("memory", "/", a, b, iteration, 0);
        if (r < 0)
                if (r != -ENOENT)
                    return r;

        r = refresh_one("blkio", "/", a, b, iteration, 0);
        if (r < 0)
                if (r != -ENOENT)
                    return r;
        return 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 (arg_cpu_type == CPU_PERCENT) {
                        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;
                } else {
                        if (x->cpu_usage > y->cpu_usage)
                                return -1;
                        else if (x->cpu_usage < y->cpu_usage)
                                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);
}

#define ON ANSI_HIGHLIGHT_ON
#define OFF ANSI_HIGHLIGHT_OFF

static int display(Hashmap *a) {
        Iterator i;
        Group *g;
        Group **array;
        signed path_columns;
        unsigned rows, n = 0, j, maxtcpu = 0, maxtpath = 0;
        char cpu_title[21];

        assert(a);

        /* Set cursor to top left corner and clear screen */
        if (on_tty())
                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);

        /* Find the longest names in one run */
        for (j = 0; j < n; j++) {
                unsigned cputlen, pathtlen;
                snprintf(cpu_title, sizeof(cpu_title), "%"PRIu64, array[j]->cpu_usage);
                cputlen = strlen(cpu_title);
                maxtcpu = MAX(maxtcpu, cputlen);
                pathtlen = strlen(array[j]->path);
                maxtpath = MAX(maxtpath, pathtlen);
        }

        if (arg_cpu_type == CPU_PERCENT)
                snprintf(cpu_title, sizeof(cpu_title), "%6s", "%CPU");
        else
                snprintf(cpu_title, sizeof(cpu_title), "%*s", maxtcpu, "CPU Time");

        rows = lines();
        if (rows <= 10)
                rows = 10;

        if (on_tty()) {
                path_columns = columns() - 36 - strlen(cpu_title);
                if (path_columns < 10)
                        path_columns = 10;

                printf("%s%-*s%s %s%7s%s %s%s%s %s%8s%s %s%8s%s %s%8s%s\n\n",
                       arg_order == ORDER_PATH ? ON : "", path_columns, "Path",
                       arg_order == ORDER_PATH ? OFF : "",
                       arg_order == ORDER_TASKS ? ON : "", "Tasks",
                       arg_order == ORDER_TASKS ? OFF : "",
                       arg_order == ORDER_CPU ? ON : "", cpu_title,
                       arg_order == ORDER_CPU ? OFF : "",
                       arg_order == ORDER_MEMORY ? ON : "", "Memory",
                       arg_order == ORDER_MEMORY ? OFF : "",
                       arg_order == ORDER_IO ? ON : "", "Input/s",
                       arg_order == ORDER_IO ? OFF : "",
                       arg_order == ORDER_IO ? ON : "", "Output/s",
                       arg_order == ORDER_IO ? OFF : "");
        } else
                path_columns = maxtpath;

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

                if (on_tty() && j + 5 > rows)
                        break;

                g = array[j];

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

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

                if (arg_cpu_type == CPU_PERCENT)
                        if (g->cpu_valid)
                                printf(" %6.1f", g->cpu_fraction*100);
                        else
                                fputs("      -", stdout);
                else
                        printf(" %*"PRIu64, maxtcpu, g->cpu_usage);

                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"
               "  --version           Print version and exit\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"
               "     --cpu[=TYPE]     Show CPU usage as time or percentage (default)\n"
               "  -d --delay=DELAY    Delay between updates\n"
               "  -n --iterations=N   Run for N iterations before exiting\n"
               "  -b --batch          Run in batch mode, accepting no input\n"
               "     --depth=DEPTH    Maximum traversal depth (default: %d)\n",
               program_invocation_short_name, arg_depth);
}

static void version(void) {
        puts(PACKAGE_STRING " cgtop");
}

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

        enum {
                ARG_VERSION = 0x100,
                ARG_DEPTH,
                ARG_CPU_TYPE
        };

        static const struct option options[] = {
                { "help",       no_argument,       NULL, 'h'         },
                { "version",    no_argument,       NULL, ARG_VERSION },
                { "delay",      required_argument, NULL, 'd'         },
                { "iterations", required_argument, NULL, 'n'         },
                { "batch",      no_argument,       NULL, 'b'         },
                { "depth",      required_argument, NULL, ARG_DEPTH   },
                { "cpu",        optional_argument, NULL, ARG_CPU_TYPE},
                { NULL,         0,                 NULL, 0           }
        };

        int c;
        int r;

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

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

                switch (c) {

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

                case ARG_VERSION:
                        version();
                        return 0;

                case ARG_CPU_TYPE:
                        if (optarg) {
                                if (strcmp(optarg, "time") == 0)
                                        arg_cpu_type = CPU_TIME;
                                else if (strcmp(optarg, "percentage") == 0)
                                        arg_cpu_type = CPU_PERCENT;
                                else
                                        return -EINVAL;
                        }
                        break;

                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_sec(optarg, &arg_delay);
                        if (r < 0 || arg_delay <= 0) {
                                log_error("Failed to parse delay parameter.");
                                return -EINVAL;
                        }

                        break;

                case 'n':
                        r = safe_atou(optarg, &arg_iterations);
                        if (r < 0) {
                                log_error("Failed to parse iterations parameter.");
                                return -EINVAL;
                        }

                        break;

                case 'b':
                        arg_batch = 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 '?':
                        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) {
                r = log_oom();
                goto finish;
        }

        signal(SIGWINCH, columns_lines_cache_reset);

        if (!on_tty())
                arg_iterations = 1;

        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;

                if (arg_iterations && iteration >= arg_iterations)
                        break;

                if (arg_batch) {
                        usleep(last_refresh + arg_delay - t);
                } else {
                        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);

                if (arg_batch)
                        continue;

                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 '%':
                        arg_cpu_type = arg_cpu_type == CPU_TIME ? CPU_PERCENT : CPU_TIME;
                        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, 0));
                        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, 0));
                        fflush(stdout);
                        sleep(1);
                        break;

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

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

        r = 0;

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

        if (r < 0) {
                log_error("Exiting with failure: %s", strerror(-r));
                return EXIT_FAILURE;
        }

        return 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
1e913bcb	22	#define __STDC_FORMAT_MACROS
8f2d43a0 LP	23	#include <errno.h>
	24	#include <string.h>
	25	#include <stdlib.h>
1e913bcb	26	#include <stdint.h>
8f2d43a0 LP	27	#include <unistd.h>
	28	#include <alloca.h>
	29	#include <getopt.h>
	30
9eb977db	31	#include "path-util.h"
8f2d43a0 LP	32	#include "util.h"
	33	#include "hashmap.h"
	34	#include "cgroup-util.h"
0d7e32fa	35	#include "build.h"
a5c32cff	36	#include "fileio.h"
8f2d43a0 LP	37
	38	typedef struct Group {
	39	char *path;
	40
	41	bool n_tasks_valid:1;
	42	bool cpu_valid:1;
	43	bool memory_valid:1;
	44	bool io_valid:1;
	45
	46	unsigned n_tasks;
	47
	48	unsigned cpu_iteration;
	49	uint64_t cpu_usage;
	50	struct timespec cpu_timestamp;
	51	double cpu_fraction;
	52
	53	uint64_t memory;
	54
	55	unsigned io_iteration;
	56	uint64_t io_input, io_output;
	57	struct timespec io_timestamp;
	58	uint64_t io_input_bps, io_output_bps;
	59	} Group;
	60
30edf116	61	static unsigned arg_depth = 3;
a152771a	62	static unsigned arg_iterations = 0;
e66bb58b	63	static bool arg_batch = false;
8f2d43a0 LP	64	static usec_t arg_delay = 1*USEC_PER_SEC;
	65
	66	static enum {
	67	ORDER_PATH,
	68	ORDER_TASKS,
	69	ORDER_CPU,
	70	ORDER_MEMORY,
	71	ORDER_IO
	72	} arg_order = ORDER_CPU;
	73
1e913bcb UTL	74	static enum {
	75	CPU_PERCENT,
	76	CPU_TIME,
	77	} arg_cpu_type = CPU_PERCENT;
	78
8f2d43a0 LP	79	static void group_free(Group *g) {
	80	assert(g);
	81
	82	free(g->path);
	83	free(g);
	84	}
	85
	86	static void group_hashmap_clear(Hashmap *h) {
	87	Group *g;
	88
	89	while ((g = hashmap_steal_first(h)))
	90	group_free(g);
	91	}
	92
	93	static void group_hashmap_free(Hashmap *h) {
	94	group_hashmap_clear(h);
	95	hashmap_free(h);
	96	}
	97
	98	static int process(const char controller, const char path, Hashmap a, Hashmap b, unsigned iteration) {
	99	Group *g;
	100	int r;
	101	FILE *f;
	102	pid_t pid;
	103	unsigned n;
	104
	105	assert(controller);
	106	assert(path);
	107	assert(a);
	108
	109	g = hashmap_get(a, path);
	110	if (!g) {
	111	g = hashmap_get(b, path);
	112	if (!g) {
	113	g = new0(Group, 1);
	114	if (!g)
	115	return -ENOMEM;
	116
	117	g->path = strdup(path);
	118	if (!g->path) {
	119	group_free(g);
	120	return -ENOMEM;
	121	}
	122
	123	r = hashmap_put(a, g->path, g);
	124	if (r < 0) {
	125	group_free(g);
	126	return r;
	127	}
	128	} else {
	129	assert_se(hashmap_move_one(a, b, path) == 0);
	130	g->cpu_valid = g->memory_valid = g->io_valid = g->n_tasks_valid = false;
	131	}
	132	}
	133
	134	/* Regardless which controller, let's find the maximum number
	135	* of processes in any of it */
	136
	137	r = cg_enumerate_tasks(controller, path, &f);
	138	if (r < 0)
	139	return r;
	140
	141	n = 0;
	142	while (cg_read_pid(f, &pid) > 0)
143	n++;
144	fclose(f);
145
146	if (n > 0) {
147	if (g->n_tasks_valid)
148	g->n_tasks = MAX(g->n_tasks, n);
149	else
150	g->n_tasks = n;
151
152	g->n_tasks_valid = true;
153	}
154
155	if (streq(controller, "cpuacct")) {
156	uint64_t new_usage;
157	char p, v;
158	struct timespec ts;
159
160	r = cg_get_path(controller, path, "cpuacct.usage", &p);
161	if (r < 0)
162	return r;
163
164	r = read_one_line_file(p, &v);
165	free(p);
166	if (r < 0)
167	return r;
168
169	r = safe_atou64(v, &new_usage);
170	free(v);
171	if (r < 0)
172	return r;
173
174	assert_se(clock_gettime(CLOCK_MONOTONIC, &ts) == 0);
175
176	if (g->cpu_iteration == iteration - 1) {
177	uint64_t x, y;
178
179	x = ((uint64_t) ts.tv_sec * 1000000000ULL + (uint64_t) ts.tv_nsec) -
180	((uint64_t) g->cpu_timestamp.tv_sec * 1000000000ULL + (uint64_t) g->cpu_timestamp.tv_nsec);
181
182	y = new_usage - g->cpu_usage;
183
184	if (y > 0) {
185	g->cpu_fraction = (double) y / (double) x;
186	g->cpu_valid = true;
187	}
188	}
189
190	g->cpu_usage = new_usage;
191	g->cpu_timestamp = ts;
192	g->cpu_iteration = iteration;
193
194	} else if (streq(controller, "memory")) {
195	char p, v;
196
197	r = cg_get_path(controller, path, "memory.usage_in_bytes", &p);
198	if (r < 0)
199	return r;
200
201	r = read_one_line_file(p, &v);
202	free(p);
203	if (r < 0)
204	return r;
205
206	r = safe_atou64(v, &g->memory);
207	free(v);
208	if (r < 0)
209	return r;
210
211	if (g->memory > 0)
212	g->memory_valid = true;
213
214	} else if (streq(controller, "blkio")) {
215	char *p;
216	uint64_t wr = 0, rd = 0;
217	struct timespec ts;
218
219	r = cg_get_path(controller, path, "blkio.io_service_bytes", &p);
220	if (r < 0)
221	return r;
222
223	f = fopen(p, "re");
224	free(p);
225
226	if (!f)
227	return -errno;
228
229	for (;;) {
230	char line[LINE_MAX], *l;
231	uint64_t k, *q;
232
233	if (!fgets(line, sizeof(line), f))
234	break;
235
236	l = strstrip(line);
237	l += strcspn(l, WHITESPACE);
238	l += strspn(l, WHITESPACE);
239
240	if (first_word(l, "Read")) {
241	l += 4;
242	q = &rd;
243	} else if (first_word(l, "Write")) {
244	l += 5;
245	q = &wr;
246	} else
247	continue;
248
249	l += strspn(l, WHITESPACE);
250	r = safe_atou64(l, &k);
251	if (r < 0)
252	continue;
253
254	*q += k;
255	}
256
257	fclose(f);
258
259	assert_se(clock_gettime(CLOCK_MONOTONIC, &ts) == 0);
260
261	if (g->io_iteration == iteration - 1) {
262	uint64_t x, yr, yw;
263
264	x = ((uint64_t) ts.tv_sec * 1000000000ULL + (uint64_t) ts.tv_nsec) -
265	((uint64_t) g->io_timestamp.tv_sec * 1000000000ULL + (uint64_t) g->io_timestamp.tv_nsec);
266
267	yr = rd - g->io_input;
268	yw = wr - g->io_output;
269
270	if (yr > 0 \|\| yw > 0) {
271	g->io_input_bps = (yr * 1000000000ULL) / x;
272	g->io_output_bps = (yw * 1000000000ULL) / x;
273	g->io_valid = true;
274
275	}
276	}
277
278	g->io_input = rd;
279	g->io_output = wr;
280	g->io_timestamp = ts;
281	g->io_iteration = iteration;
282	}
283
284	return 0;
285	}
286
287	static int refresh_one(
288	const char *controller,
289	const char *path,
290	Hashmap *a,
291	Hashmap *b,
292	unsigned iteration,
293	unsigned depth) {
294
295	DIR *d = NULL;
296	int r;
297
298	assert(controller);
299	assert(path);
300	assert(a);
301
302	if (depth > arg_depth)
303	return 0;
304
305	r = process(controller, path, a, b, iteration);
306	if (r < 0)
307	return r;
308
309	r = cg_enumerate_subgroups(controller, path, &d);
310	if (r < 0) {
2f29c419	311	if (r == -ENOENT)
8f2d43a0 LP	312	return 0;
	313
	314	return r;
	315	}
	316
	317	for (;;) {
	318	char fn, p;
	319
	320	r = cg_read_subgroup(d, &fn);
	321	if (r <= 0)
	322	goto finish;
	323
b7def684	324	p = strjoin(path, "/", fn, NULL);
8f2d43a0 LP	325	free(fn);
	326
	327	if (!p) {
	328	r = -ENOMEM;
	329	goto finish;
	330	}
	331
	332	path_kill_slashes(p);
	333
	334	r = refresh_one(controller, p, a, b, iteration, depth + 1);
	335	free(p);
	336
	337	if (r < 0)
	338	goto finish;
	339	}
	340
	341	finish:
	342	if (d)
	343	closedir(d);
	344
	345	return r;
	346	}
	347
	348	static int refresh(Hashmap a, Hashmap b, unsigned iteration) {
	349	int r;
	350
	351	assert(a);
	352
	353	r = refresh_one("name=systemd", "/", a, b, iteration, 0);
	354	if (r < 0)
63210a15 SL	355	if (r != -ENOENT)
63210a15 SL	356	return r;
8f2d43a0 LP	357	r = refresh_one("cpuacct", "/", a, b, iteration, 0);
8f2d43a0 LP	358	if (r < 0)
63210a15 SL	359	if (r != -ENOENT)
63210a15 SL	360	return r;
8f2d43a0 LP	361	r = refresh_one("memory", "/", a, b, iteration, 0);
8f2d43a0 LP	362	if (r < 0)
63210a15 SL	363	if (r != -ENOENT)
63210a15 SL	364	return r;
8f2d43a0	365
63210a15 SL	366	r = refresh_one("blkio", "/", a, b, iteration, 0);
	367	if (r < 0)
	368	if (r != -ENOENT)
	369	return r;
	370	return 0;
8f2d43a0 LP	371	}
	372
	373	static int group_compare(const voida, const void b) {
	374	const Group x = (Group*)a, y = (Group*)b;
	375
	376	if (path_startswith(y->path, x->path))
	377	return -1;
	378	if (path_startswith(x->path, y->path))
	379	return 1;
	380
	381	if (arg_order == ORDER_CPU) {
1e913bcb UTL	382	if (arg_cpu_type == CPU_PERCENT) {
	383	if (x->cpu_valid && y->cpu_valid) {
	384	if (x->cpu_fraction > y->cpu_fraction)
	385	return -1;
	386	else if (x->cpu_fraction < y->cpu_fraction)
	387	return 1;
	388	} else if (x->cpu_valid)
8f2d43a0	389	return -1;
1e913bcb	390	else if (y->cpu_valid)
8f2d43a0	391	return 1;
1e913bcb UTL	392	} else {
	393	if (x->cpu_usage > y->cpu_usage)
	394	return -1;
	395	else if (x->cpu_usage < y->cpu_usage)
	396	return 1;
	397	}
8f2d43a0 LP	398	}
	399
	400	if (arg_order == ORDER_TASKS) {
	401
	402	if (x->n_tasks_valid && y->n_tasks_valid) {
	403	if (x->n_tasks > y->n_tasks)
	404	return -1;
	405	else if (x->n_tasks < y->n_tasks)
	406	return 1;
	407	} else if (x->n_tasks_valid)
	408	return -1;
	409	else if (y->n_tasks_valid)
	410	return 1;
	411	}
	412
	413	if (arg_order == ORDER_MEMORY) {
	414	if (x->memory_valid && y->memory_valid) {
	415	if (x->memory > y->memory)
	416	return -1;
	417	else if (x->memory < y->memory)
	418	return 1;
	419	} else if (x->memory_valid)
	420	return -1;
	421	else if (y->memory_valid)
	422	return 1;
	423	}
	424
	425	if (arg_order == ORDER_IO) {
	426	if (x->io_valid && y->io_valid) {
	427	if (x->io_input_bps + x->io_output_bps > y->io_input_bps + y->io_output_bps)
	428	return -1;
	429	else if (x->io_input_bps + x->io_output_bps < y->io_input_bps + y->io_output_bps)
	430	return 1;
	431	} else if (x->io_valid)
	432	return -1;
	433	else if (y->io_valid)
	434	return 1;
	435	}
	436
	437	return strcmp(x->path, y->path);
	438	}
	439
1e913bcb UTL	440	#define ON ANSI_HIGHLIGHT_ON
	441	#define OFF ANSI_HIGHLIGHT_OFF
	442
8f2d43a0 LP	443	static int display(Hashmap *a) {
	444	Iterator i;
	445	Group *g;
	446	Group **array;
1e913bcb UTL	447	signed path_columns;
	448	unsigned rows, n = 0, j, maxtcpu = 0, maxtpath = 0;
	449	char cpu_title[21];
8f2d43a0 LP	450
	451	assert(a);
	452
	453	/* Set cursor to top left corner and clear screen */
1e913bcb UTL	454	if (on_tty())
	455	fputs("\033[H"
	456	"\033[2J", stdout);
8f2d43a0 LP	457
	458	array = alloca(sizeof(Group) hashmap_size(a));
	459
	460	HASHMAP_FOREACH(g, a, i)
	461	if (g->n_tasks_valid \|\| g->cpu_valid \|\| g->memory_valid \|\| g->io_valid)
	462	array[n++] = g;
	463
	464	qsort(array, n, sizeof(Group*), group_compare);
	465
1e913bcb UTL	466	/* Find the longest names in one run */
	467	for (j = 0; j < n; j++) {
	468	unsigned cputlen, pathtlen;
	469	snprintf(cpu_title, sizeof(cpu_title), "%"PRIu64, array[j]->cpu_usage);
	470	cputlen = strlen(cpu_title);
	471	maxtcpu = MAX(maxtcpu, cputlen);
	472	pathtlen = strlen(array[j]->path);
	473	maxtpath = MAX(maxtpath, pathtlen);
	474	}
	475
	476	if (arg_cpu_type == CPU_PERCENT)
	477	snprintf(cpu_title, sizeof(cpu_title), "%6s", "%CPU");
	478	else
	479	snprintf(cpu_title, sizeof(cpu_title), "%*s", maxtcpu, "CPU Time");
	480
ed757c0c LP	481	rows = lines();
	482	if (rows <= 10)
	483	rows = 10;
8f2d43a0	484
1e913bcb UTL	485	if (on_tty()) {
	486	path_columns = columns() - 36 - strlen(cpu_title);
	487	if (path_columns < 10)
	488	path_columns = 10;
	489
	490	printf("%s%-*s%s %s%7s%s %s%s%s %s%8s%s %s%8s%s %s%8s%s\n\n",
	491	arg_order == ORDER_PATH ? ON : "", path_columns, "Path",
	492	arg_order == ORDER_PATH ? OFF : "",
	493	arg_order == ORDER_TASKS ? ON : "", "Tasks",
	494	arg_order == ORDER_TASKS ? OFF : "",
	495	arg_order == ORDER_CPU ? ON : "", cpu_title,
	496	arg_order == ORDER_CPU ? OFF : "",
	497	arg_order == ORDER_MEMORY ? ON : "", "Memory",
	498	arg_order == ORDER_MEMORY ? OFF : "",
	499	arg_order == ORDER_IO ? ON : "", "Input/s",
	500	arg_order == ORDER_IO ? OFF : "",
	501	arg_order == ORDER_IO ? ON : "", "Output/s",
	502	arg_order == ORDER_IO ? OFF : "");
	503	} else
	504	path_columns = maxtpath;
8f2d43a0 LP	505
	506	for (j = 0; j < n; j++) {
	507	char *p;
	508	char m[FORMAT_BYTES_MAX];
	509
1e913bcb	510	if (on_tty() && j + 5 > rows)
8f2d43a0 LP	511	break;
	512
	513	g = array[j];
	514
11f96fac ZJS	515	p = ellipsize(g->path, path_columns, 33);
11f96fac ZJS	516	printf("%-*s", path_columns, p ? p : g->path);
8f2d43a0 LP	517	free(p);
	518
	519	if (g->n_tasks_valid)
	520	printf(" %7u", g->n_tasks);
	521	else
	522	fputs(" -", stdout);
	523
1e913bcb UTL	524	if (arg_cpu_type == CPU_PERCENT)
	525	if (g->cpu_valid)
	526	printf(" %6.1f", g->cpu_fraction*100);
	527	else
	528	fputs(" -", stdout);
8f2d43a0	529	else
1e913bcb	530	printf(" %*"PRIu64, maxtcpu, g->cpu_usage);
8f2d43a0 LP	531
	532	if (g->memory_valid)
	533	printf(" %8s", format_bytes(m, sizeof(m), g->memory));
	534	else
	535	fputs(" -", stdout);
	536
	537	if (g->io_valid) {
	538	printf(" %8s",
	539	format_bytes(m, sizeof(m), g->io_input_bps));
	540	printf(" %8s",
	541	format_bytes(m, sizeof(m), g->io_output_bps));
	542	} else
	543	fputs(" - -", stdout);
	544
	545	putchar('\n');
	546	}
	547
	548	return 0;
	549	}
	550
	551	static void help(void) {
	552
	553	printf("%s [OPTIONS...]\n\n"
	554	"Show top control groups by their resource usage.\n\n"
	555	" -h --help Show this help\n"
0d7e32fa	556	" --version Print version and exit\n"
8f2d43a0 LP	557	" -p Order by path\n"
	558	" -t Order by number of tasks\n"
	559	" -c Order by CPU load\n"
	560	" -m Order by memory load\n"
	561	" -i Order by IO load\n"
1e913bcb UTL	562	" --cpu[=TYPE] Show CPU usage as time or percentage (default)\n"
1e913bcb UTL	563	" -d --delay=DELAY Delay between updates\n"
a152771a	564	" -n --iterations=N Run for N iterations before exiting\n"
e66bb58b	565	" -b --batch Run in batch mode, accepting no input\n"
813ac7d3 MM	566	" --depth=DEPTH Maximum traversal depth (default: %d)\n",
813ac7d3 MM	567	program_invocation_short_name, arg_depth);
8f2d43a0 LP	568	}
8f2d43a0 LP	569
0d7e32fa ZJS	570	static void version(void) {
	571	puts(PACKAGE_STRING " cgtop");
	572	}
	573
8f2d43a0 LP	574	static int parse_argv(int argc, char *argv[]) {
	575
	576	enum {
0d7e32fa ZJS	577	ARG_VERSION = 0x100,
0d7e32fa ZJS	578	ARG_DEPTH,
1e913bcb	579	ARG_CPU_TYPE
8f2d43a0 LP	580	};
	581
	582	static const struct option options[] = {
0d7e32fa ZJS	583	{ "help", no_argument, NULL, 'h' },
	584	{ "version", no_argument, NULL, ARG_VERSION },
	585	{ "delay", required_argument, NULL, 'd' },
	586	{ "iterations", required_argument, NULL, 'n' },
	587	{ "batch", no_argument, NULL, 'b' },
	588	{ "depth", required_argument, NULL, ARG_DEPTH },
1e913bcb	589	{ "cpu", optional_argument, NULL, ARG_CPU_TYPE},
0d7e32fa	590	{ NULL, 0, NULL, 0 }
8f2d43a0 LP	591	};
	592
	593	int c;
	594	int r;
	595
	596	assert(argc >= 1);
	597	assert(argv);
	598
e66bb58b	599	while ((c = getopt_long(argc, argv, "hptcmin:bd:", options, NULL)) >= 0) {
8f2d43a0 LP	600
	601	switch (c) {
	602
	603	case 'h':
	604	help();
	605	return 0;
	606
0d7e32fa ZJS	607	case ARG_VERSION:
	608	version();
	609	return 0;
	610
1e913bcb UTL	611	case ARG_CPU_TYPE:
	612	if (optarg) {
	613	if (strcmp(optarg, "time") == 0)
	614	arg_cpu_type = CPU_TIME;
	615	else if (strcmp(optarg, "percentage") == 0)
	616	arg_cpu_type = CPU_PERCENT;
	617	else
	618	return -EINVAL;
	619	}
	620	break;
	621
8f2d43a0 LP	622	case ARG_DEPTH:
	623	r = safe_atou(optarg, &arg_depth);
	624	if (r < 0) {
	625	log_error("Failed to parse depth parameter.");
	626	return -EINVAL;
	627	}
	628
	629	break;
	630
	631	case 'd':
7f602784	632	r = parse_sec(optarg, &arg_delay);
8f2d43a0 LP	633	if (r < 0 \|\| arg_delay <= 0) {
	634	log_error("Failed to parse delay parameter.");
	635	return -EINVAL;
	636	}
	637
	638	break;
	639
a152771a DS	640	case 'n':
	641	r = safe_atou(optarg, &arg_iterations);
	642	if (r < 0) {
	643	log_error("Failed to parse iterations parameter.");
	644	return -EINVAL;
	645	}
	646
	647	break;
	648
e66bb58b DS	649	case 'b':
	650	arg_batch = true;
	651	break;
	652
8f2d43a0 LP	653	case 'p':
	654	arg_order = ORDER_PATH;
	655	break;
	656
	657	case 't':
	658	arg_order = ORDER_TASKS;
	659	break;
	660
	661	case 'c':
	662	arg_order = ORDER_CPU;
	663	break;
	664
	665	case 'm':
	666	arg_order = ORDER_MEMORY;
	667	break;
	668
	669	case 'i':
	670	arg_order = ORDER_IO;
	671	break;
	672
	673	case '?':
	674	return -EINVAL;
	675
	676	default:
	677	log_error("Unknown option code %c", c);
	678	return -EINVAL;
	679	}
	680	}
	681
	682	if (optind < argc) {
	683	log_error("Too many arguments.");
	684	return -EINVAL;
	685	}
	686
	687	return 1;
	688	}
	689
	690	int main(int argc, char *argv[]) {
	691	int r;
	692	Hashmap a = NULL, b = NULL;
	693	unsigned iteration = 0;
	694	usec_t last_refresh = 0;
	695	bool quit = false, immediate_refresh = false;
	696
	697	log_parse_environment();
	698	log_open();
	699
	700	r = parse_argv(argc, argv);
	701	if (r <= 0)
	702	goto finish;
	703
	704	a = hashmap_new(string_hash_func, string_compare_func);
	705	b = hashmap_new(string_hash_func, string_compare_func);
	706	if (!a \|\| !b) {
0d0f0c50	707	r = log_oom();
8f2d43a0 LP	708	goto finish;
	709	}
	710
ed757c0c	711	signal(SIGWINCH, columns_lines_cache_reset);
28917d7d	712
1e913bcb UTL	713	if (!on_tty())
	714	arg_iterations = 1;
	715
8f2d43a0 LP	716	while (!quit) {
	717	Hashmap *c;
	718	usec_t t;
	719	char key;
	720	char h[FORMAT_TIMESPAN_MAX];
	721
	722	t = now(CLOCK_MONOTONIC);
	723
	724	if (t >= last_refresh + arg_delay \|\| immediate_refresh) {
	725
	726	r = refresh(a, b, iteration++);
	727	if (r < 0)
	728	goto finish;
	729
	730	group_hashmap_clear(b);
	731
	732	c = a;
	733	a = b;
	734	b = c;
	735
	736	last_refresh = t;
	737	immediate_refresh = false;
	738	}
	739
	740	r = display(b);
	741	if (r < 0)
	742	goto finish;
	743
a152771a DS	744	if (arg_iterations && iteration >= arg_iterations)
	745	break;
	746
e66bb58b DS	747	if (arg_batch) {
	748	usleep(last_refresh + arg_delay - t);
	749	} else {
	750	r = read_one_char(stdin, &key,
	751	last_refresh + arg_delay - t, NULL);
	752	if (r == -ETIMEDOUT)
	753	continue;
	754	if (r < 0) {
	755	log_error("Couldn't read key: %s", strerror(-r));
	756	goto finish;
	757	}
8f2d43a0 LP	758	}
	759
	760	fputs("\r \r", stdout);
	761	fflush(stdout);
	762
e66bb58b DS	763	if (arg_batch)
	764	continue;
	765
8f2d43a0 LP	766	switch (key) {
	767
	768	case ' ':
	769	immediate_refresh = true;
	770	break;
	771
	772	case 'q':
	773	quit = true;
	774	break;
	775
	776	case 'p':
	777	arg_order = ORDER_PATH;
	778	break;
	779
	780	case 't':
	781	arg_order = ORDER_TASKS;
	782	break;
	783
	784	case 'c':
	785	arg_order = ORDER_CPU;
	786	break;
	787
	788	case 'm':
	789	arg_order = ORDER_MEMORY;
	790	break;
	791
	792	case 'i':
	793	arg_order = ORDER_IO;
	794	break;
	795
2bfc1eda ZJS	796	case '%':
	797	arg_cpu_type = arg_cpu_type == CPU_TIME ? CPU_PERCENT : CPU_TIME;
	798	break;
	799
8f2d43a0 LP	800	case '+':
	801	if (arg_delay < USEC_PER_SEC)
	802	arg_delay += USEC_PER_MSEC*250;
	803	else
	804	arg_delay += USEC_PER_SEC;
	805
2fa4092c	806	fprintf(stdout, "\nIncreased delay to %s.", format_timespan(h, sizeof(h), arg_delay, 0));
8f2d43a0 LP	807	fflush(stdout);
	808	sleep(1);
	809	break;
	810
	811	case '-':
	812	if (arg_delay <= USEC_PER_MSEC*500)
	813	arg_delay = USEC_PER_MSEC*250;
	814	else if (arg_delay < USEC_PER_MSEC*1250)
	815	arg_delay -= USEC_PER_MSEC*250;
	816	else
	817	arg_delay -= USEC_PER_SEC;
	818
2fa4092c	819	fprintf(stdout, "\nDecreased delay to %s.", format_timespan(h, sizeof(h), arg_delay, 0));
8f2d43a0 LP	820	fflush(stdout);
	821	sleep(1);
	822	break;
	823
	824	case '?':
	825	case 'h':
	826	fprintf(stdout,
1e913bcb	827	"\t<" ON "P" OFF "> By path; <" ON "T" OFF "> By tasks; <" ON "C" OFF "> By CPU; <" ON "M" OFF "> By memory; <" ON "I" OFF "> By I/O\n"
2bfc1eda ZJS	828	"\t<" ON "+" OFF "> Increase delay; <" ON "-" OFF "> Decrease delay; <" ON "%%" OFF "> Toggle time\n"
2bfc1eda ZJS	829	"\t<" ON "Q" OFF "> Quit; <" ON "SPACE" OFF "> Refresh");
8f2d43a0 LP	830	fflush(stdout);
	831	sleep(3);
	832	break;
	833
	834	default:
	835	fprintf(stdout, "\nUnknown key '%c'. Ignoring.", key);
	836	fflush(stdout);
	837	sleep(1);
	838	break;
	839	}
	840	}
	841
8f2d43a0 LP	842	r = 0;
	843
	844	finish:
	845	group_hashmap_free(a);
	846	group_hashmap_free(b);
	847
14212119 SL	848	if (r < 0) {
	849	log_error("Exiting with failure: %s", strerror(-r));
	850	return EXIT_FAILURE;
	851	}
	852
	853	return EXIT_SUCCESS;
8f2d43a0	854	}