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