2 This file is part of systemd.
4 Copyright 2012 Lennart Poettering
6 systemd is free software; you can redistribute it and/or modify it
7 under the terms of the GNU Lesser General Public License as published by
8 the Free Software Foundation; either version 2.1 of the License, or
9 (at your option) any later version.
11 systemd is distributed in the hope that it will be useful, but
12 WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 Lesser General Public License for more details.
16 You should have received a copy of the GNU Lesser General Public License
17 along with systemd; If not, see <http://www.gnu.org/licenses/>.
31 #include "alloc-util.h"
32 #include "bus-error.h"
34 #include "cgroup-util.h"
38 #include "parse-util.h"
39 #include "path-util.h"
40 #include "process-util.h"
41 #include "stdio-util.h"
42 #include "terminal-util.h"
43 #include "unit-name.h"
46 typedef struct Group
{
56 unsigned cpu_iteration
;
63 unsigned io_iteration
;
64 uint64_t io_input
, io_output
;
66 uint64_t io_input_bps
, io_output_bps
;
69 static unsigned arg_depth
= 3;
70 static unsigned arg_iterations
= (unsigned) -1;
71 static bool arg_batch
= false;
72 static bool arg_raw
= false;
73 static usec_t arg_delay
= 1*USEC_PER_SEC
;
74 static char* arg_machine
= NULL
;
75 static char* arg_root
= NULL
;
76 static bool arg_recursive
= true;
80 COUNT_USERSPACE_PROCESSES
,
82 } arg_count
= COUNT_PIDS
;
90 } arg_order
= ORDER_CPU
;
95 } arg_cpu_type
= CPU_PERCENT
;
97 static void group_free(Group
*g
) {
104 static void group_hashmap_clear(Hashmap
*h
) {
107 while ((g
= hashmap_steal_first(h
)))
111 static void group_hashmap_free(Hashmap
*h
) {
112 group_hashmap_clear(h
);
116 static const char *maybe_format_bytes(char *buf
, size_t l
, bool is_valid
, uint64_t t
) {
120 snprintf(buf
, l
, "%jd", t
);
123 return format_bytes(buf
, l
, t
);
127 const char *controller
,
141 g
= hashmap_get(a
, path
);
143 g
= hashmap_get(b
, path
);
149 g
->path
= strdup(path
);
155 r
= hashmap_put(a
, g
->path
, g
);
161 r
= hashmap_move_one(a
, b
, path
);
165 g
->cpu_valid
= g
->memory_valid
= g
->io_valid
= g
->n_tasks_valid
= false;
169 if (streq(controller
, SYSTEMD_CGROUP_CONTROLLER
) && IN_SET(arg_count
, COUNT_ALL_PROCESSES
, COUNT_USERSPACE_PROCESSES
)) {
170 _cleanup_fclose_
FILE *f
= NULL
;
173 r
= cg_enumerate_processes(controller
, path
, &f
);
180 while (cg_read_pid(f
, &pid
) > 0) {
182 if (arg_count
== COUNT_USERSPACE_PROCESSES
&& is_kernel_thread(pid
) > 0)
189 g
->n_tasks_valid
= true;
191 } else if (streq(controller
, "pids") && arg_count
== COUNT_PIDS
) {
192 _cleanup_free_
char *p
= NULL
, *v
= NULL
;
194 r
= cg_get_path(controller
, path
, "pids.current", &p
);
198 r
= read_one_line_file(p
, &v
);
204 r
= safe_atou64(v
, &g
->n_tasks
);
209 g
->n_tasks_valid
= true;
211 } else if (streq(controller
, "cpu") || streq(controller
, "cpuacct")) {
212 _cleanup_free_
char *p
= NULL
, *v
= NULL
;
216 if (cg_unified() > 0) {
217 const char *keys
[] = { "usage_usec", NULL
};
218 _cleanup_free_
char *val
= NULL
;
220 if (!streq(controller
, "cpu"))
223 r
= cg_get_keyed_attribute("cpu", path
, "cpu.stat", keys
, &val
);
229 r
= safe_atou64(val
, &new_usage
);
233 new_usage
*= NSEC_PER_USEC
;
235 if (!streq(controller
, "cpuacct"))
238 r
= cg_get_path(controller
, path
, "cpuacct.usage", &p
);
242 r
= read_one_line_file(p
, &v
);
248 r
= safe_atou64(v
, &new_usage
);
253 timestamp
= now_nsec(CLOCK_MONOTONIC
);
255 if (g
->cpu_iteration
== iteration
- 1 &&
256 (nsec_t
) new_usage
> g
->cpu_usage
) {
260 x
= timestamp
- g
->cpu_timestamp
;
264 y
= (nsec_t
) new_usage
- g
->cpu_usage
;
265 g
->cpu_fraction
= (double) y
/ (double) x
;
269 g
->cpu_usage
= (nsec_t
) new_usage
;
270 g
->cpu_timestamp
= timestamp
;
271 g
->cpu_iteration
= iteration
;
273 } else if (streq(controller
, "memory")) {
274 _cleanup_free_
char *p
= NULL
, *v
= NULL
;
276 if (cg_unified() <= 0)
277 r
= cg_get_path(controller
, path
, "memory.usage_in_bytes", &p
);
279 r
= cg_get_path(controller
, path
, "memory.current", &p
);
283 r
= read_one_line_file(p
, &v
);
289 r
= safe_atou64(v
, &g
->memory
);
294 g
->memory_valid
= true;
296 } else if ((streq(controller
, "io") && cg_unified() > 0) ||
297 (streq(controller
, "blkio") && cg_unified() <= 0)) {
298 _cleanup_fclose_
FILE *f
= NULL
;
299 _cleanup_free_
char *p
= NULL
;
300 bool unified
= cg_unified() > 0;
301 uint64_t wr
= 0, rd
= 0;
304 r
= cg_get_path(controller
, path
, unified
? "io.stat" : "blkio.io_service_bytes", &p
);
316 char line
[LINE_MAX
], *l
;
319 if (!fgets(line
, sizeof(line
), f
))
322 /* Trim and skip the device */
324 l
+= strcspn(l
, WHITESPACE
);
325 l
+= strspn(l
, WHITESPACE
);
328 while (!isempty(l
)) {
329 if (sscanf(l
, "rbytes=%" SCNu64
, &k
))
331 else if (sscanf(l
, "wbytes=%" SCNu64
, &k
))
334 l
+= strcspn(l
, WHITESPACE
);
335 l
+= strspn(l
, WHITESPACE
);
338 if (first_word(l
, "Read")) {
341 } else if (first_word(l
, "Write")) {
347 l
+= strspn(l
, WHITESPACE
);
348 r
= safe_atou64(l
, &k
);
356 timestamp
= now_nsec(CLOCK_MONOTONIC
);
358 if (g
->io_iteration
== iteration
- 1) {
361 x
= (uint64_t) (timestamp
- g
->io_timestamp
);
365 if (rd
> g
->io_input
)
366 yr
= rd
- g
->io_input
;
370 if (wr
> g
->io_output
)
371 yw
= wr
- g
->io_output
;
375 if (yr
> 0 || yw
> 0) {
376 g
->io_input_bps
= (yr
* 1000000000ULL) / x
;
377 g
->io_output_bps
= (yw
* 1000000000ULL) / x
;
384 g
->io_timestamp
= timestamp
;
385 g
->io_iteration
= iteration
;
394 static int refresh_one(
395 const char *controller
,
403 _cleanup_closedir_
DIR *d
= NULL
;
411 if (depth
> arg_depth
)
414 r
= process(controller
, path
, a
, b
, iteration
, &ours
);
418 r
= cg_enumerate_subgroups(controller
, path
, &d
);
425 _cleanup_free_
char *fn
= NULL
, *p
= NULL
;
428 r
= cg_read_subgroup(d
, &fn
);
434 p
= strjoin(path
, "/", fn
, NULL
);
438 path_kill_slashes(p
);
440 r
= refresh_one(controller
, p
, a
, b
, iteration
, depth
+ 1, &child
);
445 IN_SET(arg_count
, COUNT_ALL_PROCESSES
, COUNT_USERSPACE_PROCESSES
) &&
447 child
->n_tasks_valid
&&
448 streq(controller
, SYSTEMD_CGROUP_CONTROLLER
)) {
450 /* Recursively sum up processes */
452 if (ours
->n_tasks_valid
)
453 ours
->n_tasks
+= child
->n_tasks
;
455 ours
->n_tasks
= child
->n_tasks
;
456 ours
->n_tasks_valid
= true;
467 static int refresh(const char *root
, Hashmap
*a
, Hashmap
*b
, unsigned iteration
) {
472 r
= refresh_one(SYSTEMD_CGROUP_CONTROLLER
, root
, a
, b
, iteration
, 0, NULL
);
475 r
= refresh_one("cpu", root
, a
, b
, iteration
, 0, NULL
);
478 r
= refresh_one("cpuacct", root
, a
, b
, iteration
, 0, NULL
);
481 r
= refresh_one("memory", root
, a
, b
, iteration
, 0, NULL
);
484 r
= refresh_one("io", root
, a
, b
, iteration
, 0, NULL
);
487 r
= refresh_one("blkio", root
, a
, b
, iteration
, 0, NULL
);
490 r
= refresh_one("pids", root
, a
, b
, iteration
, 0, NULL
);
497 static int group_compare(const void*a
, const void *b
) {
498 const Group
*x
= *(Group
**)a
, *y
= *(Group
**)b
;
500 if (arg_order
!= ORDER_TASKS
|| arg_recursive
) {
501 /* Let's make sure that the parent is always before
502 * the child. Except when ordering by tasks and
503 * recursive summing is off, since that is actually
504 * not accumulative for all children. */
506 if (path_startswith(y
->path
, x
->path
))
508 if (path_startswith(x
->path
, y
->path
))
518 if (arg_cpu_type
== CPU_PERCENT
) {
519 if (x
->cpu_valid
&& y
->cpu_valid
) {
520 if (x
->cpu_fraction
> y
->cpu_fraction
)
522 else if (x
->cpu_fraction
< y
->cpu_fraction
)
524 } else if (x
->cpu_valid
)
526 else if (y
->cpu_valid
)
529 if (x
->cpu_usage
> y
->cpu_usage
)
531 else if (x
->cpu_usage
< y
->cpu_usage
)
538 if (x
->n_tasks_valid
&& y
->n_tasks_valid
) {
539 if (x
->n_tasks
> y
->n_tasks
)
541 else if (x
->n_tasks
< y
->n_tasks
)
543 } else if (x
->n_tasks_valid
)
545 else if (y
->n_tasks_valid
)
551 if (x
->memory_valid
&& y
->memory_valid
) {
552 if (x
->memory
> y
->memory
)
554 else if (x
->memory
< y
->memory
)
556 } else if (x
->memory_valid
)
558 else if (y
->memory_valid
)
564 if (x
->io_valid
&& y
->io_valid
) {
565 if (x
->io_input_bps
+ x
->io_output_bps
> y
->io_input_bps
+ y
->io_output_bps
)
567 else if (x
->io_input_bps
+ x
->io_output_bps
< y
->io_input_bps
+ y
->io_output_bps
)
569 } else if (x
->io_valid
)
571 else if (y
->io_valid
)
575 return path_compare(x
->path
, y
->path
);
578 static void display(Hashmap
*a
) {
583 unsigned rows
, n
= 0, j
, maxtcpu
= 0, maxtpath
= 3; /* 3 for ellipsize() to work properly */
584 char buffer
[MAX3(21, FORMAT_BYTES_MAX
, FORMAT_TIMESPAN_MAX
)];
588 if (!terminal_is_dumb())
589 fputs(ANSI_HOME_CLEAR
, stdout
);
591 array
= alloca(sizeof(Group
*) * hashmap_size(a
));
593 HASHMAP_FOREACH(g
, a
, i
)
594 if (g
->n_tasks_valid
|| g
->cpu_valid
|| g
->memory_valid
|| g
->io_valid
)
597 qsort_safe(array
, n
, sizeof(Group
*), group_compare
);
599 /* Find the longest names in one run */
600 for (j
= 0; j
< n
; j
++) {
601 unsigned cputlen
, pathtlen
;
603 format_timespan(buffer
, sizeof(buffer
), (usec_t
) (array
[j
]->cpu_usage
/ NSEC_PER_USEC
), 0);
604 cputlen
= strlen(buffer
);
605 maxtcpu
= MAX(maxtcpu
, cputlen
);
607 pathtlen
= strlen(array
[j
]->path
);
608 maxtpath
= MAX(maxtpath
, pathtlen
);
611 if (arg_cpu_type
== CPU_PERCENT
)
612 xsprintf(buffer
, "%6s", "%CPU");
614 xsprintf(buffer
, "%*s", maxtcpu
, "CPU Time");
621 const char *on
, *off
;
623 path_columns
= columns() - 36 - strlen(buffer
);
624 if (path_columns
< 10)
627 on
= ansi_highlight_underline();
628 off
= ansi_underline();
630 printf("%s%s%-*s%s %s%7s%s %s%s%s %s%8s%s %s%8s%s %s%8s%s%s\n",
632 arg_order
== ORDER_PATH
? on
: "", path_columns
, "Control Group",
633 arg_order
== ORDER_PATH
? off
: "",
634 arg_order
== ORDER_TASKS
? on
: "", arg_count
== COUNT_PIDS
? "Tasks" : arg_count
== COUNT_USERSPACE_PROCESSES
? "Procs" : "Proc+",
635 arg_order
== ORDER_TASKS
? off
: "",
636 arg_order
== ORDER_CPU
? on
: "", buffer
,
637 arg_order
== ORDER_CPU
? off
: "",
638 arg_order
== ORDER_MEMORY
? on
: "", "Memory",
639 arg_order
== ORDER_MEMORY
? off
: "",
640 arg_order
== ORDER_IO
? on
: "", "Input/s",
641 arg_order
== ORDER_IO
? off
: "",
642 arg_order
== ORDER_IO
? on
: "", "Output/s",
643 arg_order
== ORDER_IO
? off
: "",
646 path_columns
= maxtpath
;
648 for (j
= 0; j
< n
; j
++) {
649 _cleanup_free_
char *ellipsized
= NULL
;
652 if (on_tty() && j
+ 6 > rows
)
657 path
= isempty(g
->path
) ? "/" : g
->path
;
658 ellipsized
= ellipsize(path
, path_columns
, 33);
659 printf("%-*s", path_columns
, ellipsized
?: path
);
661 if (g
->n_tasks_valid
)
662 printf(" %7" PRIu64
, g
->n_tasks
);
666 if (arg_cpu_type
== CPU_PERCENT
) {
668 printf(" %6.1f", g
->cpu_fraction
*100);
672 printf(" %*s", maxtcpu
, format_timespan(buffer
, sizeof(buffer
), (usec_t
) (g
->cpu_usage
/ NSEC_PER_USEC
), 0));
674 printf(" %8s", maybe_format_bytes(buffer
, sizeof(buffer
), g
->memory_valid
, g
->memory
));
675 printf(" %8s", maybe_format_bytes(buffer
, sizeof(buffer
), g
->io_valid
, g
->io_input_bps
));
676 printf(" %8s", maybe_format_bytes(buffer
, sizeof(buffer
), g
->io_valid
, g
->io_output_bps
));
682 static void help(void) {
683 printf("%s [OPTIONS...] [CGROUP]\n\n"
684 "Show top control groups by their resource usage.\n\n"
685 " -h --help Show this help\n"
686 " --version Show package version\n"
687 " -p --order=path Order by path\n"
688 " -t --order=tasks Order by number of tasks/processes\n"
689 " -c --order=cpu Order by CPU load (default)\n"
690 " -m --order=memory Order by memory load\n"
691 " -i --order=io Order by IO load\n"
692 " -r --raw Provide raw (not human-readable) numbers\n"
693 " --cpu=percentage Show CPU usage as percentage (default)\n"
694 " --cpu=time Show CPU usage as time\n"
695 " -P Count userspace processes instead of tasks (excl. kernel)\n"
696 " -k Count all processes instead of tasks (incl. kernel)\n"
697 " --recursive=BOOL Sum up process count recursively\n"
698 " -d --delay=DELAY Delay between updates\n"
699 " -n --iterations=N Run for N iterations before exiting\n"
700 " -b --batch Run in batch mode, accepting no input\n"
701 " --depth=DEPTH Maximum traversal depth (default: %u)\n"
702 " -M --machine= Show container\n"
703 , program_invocation_short_name
, arg_depth
);
706 static int parse_argv(int argc
, char *argv
[]) {
716 static const struct option options
[] = {
717 { "help", no_argument
, NULL
, 'h' },
718 { "version", no_argument
, NULL
, ARG_VERSION
},
719 { "delay", required_argument
, NULL
, 'd' },
720 { "iterations", required_argument
, NULL
, 'n' },
721 { "batch", no_argument
, NULL
, 'b' },
722 { "raw", no_argument
, NULL
, 'r' },
723 { "depth", required_argument
, NULL
, ARG_DEPTH
},
724 { "cpu", optional_argument
, NULL
, ARG_CPU_TYPE
},
725 { "order", required_argument
, NULL
, ARG_ORDER
},
726 { "recursive", required_argument
, NULL
, ARG_RECURSIVE
},
727 { "machine", required_argument
, NULL
, 'M' },
731 bool recursive_unset
= false;
737 while ((c
= getopt_long(argc
, argv
, "hptcmin:brd:kPM:", options
, NULL
)) >= 0)
750 if (streq(optarg
, "time"))
751 arg_cpu_type
= CPU_TIME
;
752 else if (streq(optarg
, "percentage"))
753 arg_cpu_type
= CPU_PERCENT
;
755 log_error("Unknown argument to --cpu=: %s", optarg
);
759 arg_cpu_type
= CPU_TIME
;
764 r
= safe_atou(optarg
, &arg_depth
);
766 log_error("Failed to parse depth parameter.");
773 r
= parse_sec(optarg
, &arg_delay
);
774 if (r
< 0 || arg_delay
<= 0) {
775 log_error("Failed to parse delay parameter.");
782 r
= safe_atou(optarg
, &arg_iterations
);
784 log_error("Failed to parse iterations parameter.");
799 arg_order
= ORDER_PATH
;
803 arg_order
= ORDER_TASKS
;
807 arg_order
= ORDER_CPU
;
811 arg_order
= ORDER_MEMORY
;
815 arg_order
= ORDER_IO
;
819 if (streq(optarg
, "path"))
820 arg_order
= ORDER_PATH
;
821 else if (streq(optarg
, "tasks"))
822 arg_order
= ORDER_TASKS
;
823 else if (streq(optarg
, "cpu"))
824 arg_order
= ORDER_CPU
;
825 else if (streq(optarg
, "memory"))
826 arg_order
= ORDER_MEMORY
;
827 else if (streq(optarg
, "io"))
828 arg_order
= ORDER_IO
;
830 log_error("Invalid argument to --order=: %s", optarg
);
836 arg_count
= COUNT_ALL_PROCESSES
;
840 arg_count
= COUNT_USERSPACE_PROCESSES
;
844 r
= parse_boolean(optarg
);
846 log_error("Failed to parse --recursive= argument: %s", optarg
);
851 recursive_unset
= r
== 0;
855 arg_machine
= optarg
;
862 assert_not_reached("Unhandled option");
865 if (optind
== argc
-1) {
867 log_error("Specifying a control group path together with the -M option is not allowed");
870 arg_root
= argv
[optind
];
871 } else if (optind
< argc
) {
872 log_error("Too many arguments.");
876 if (recursive_unset
&& arg_count
== COUNT_PIDS
) {
877 log_error("Non-recursive counting is only supported when counting processes, not tasks. Use -P or -k.");
884 static const char* counting_what(void) {
885 if (arg_count
== COUNT_PIDS
)
887 else if (arg_count
== COUNT_ALL_PROCESSES
)
888 return "all processes (incl. kernel)";
890 return "userspace processes (excl. kernel)";
893 static int get_cgroup_root(char **ret
) {
894 _cleanup_(sd_bus_error_free
) sd_bus_error error
= SD_BUS_ERROR_NULL
;
895 _cleanup_(sd_bus_flush_close_unrefp
) sd_bus
*bus
= NULL
;
896 _cleanup_free_
char *unit
= NULL
, *path
= NULL
;
903 aux
= strdup(arg_root
);
912 r
= cg_get_root_path(ret
);
914 return log_error_errno(r
, "Failed to get root control group path: %m");
919 m
= strjoina("/run/systemd/machines/", arg_machine
);
920 r
= parse_env_file(m
, NEWLINE
, "SCOPE", &unit
, NULL
);
922 return log_error_errno(r
, "Failed to load machine data: %m");
924 path
= unit_dbus_path_from_name(unit
);
928 r
= bus_connect_transport_systemd(BUS_TRANSPORT_LOCAL
, NULL
, false, &bus
);
930 return log_error_errno(r
, "Failed to create bus connection: %m");
932 r
= sd_bus_get_property_string(
934 "org.freedesktop.systemd1",
936 unit_dbus_interface_from_name(unit
),
941 return log_error_errno(r
, "Failed to query unit control group path: %s", bus_error_message(&error
, r
));
946 int main(int argc
, char *argv
[]) {
948 Hashmap
*a
= NULL
, *b
= NULL
;
949 unsigned iteration
= 0;
950 usec_t last_refresh
= 0;
951 bool quit
= false, immediate_refresh
= false;
952 _cleanup_free_
char *root
= NULL
;
955 log_parse_environment();
958 r
= cg_mask_supported(&mask
);
960 log_error_errno(r
, "Failed to determine supported controllers: %m");
964 arg_count
= (mask
& CGROUP_MASK_PIDS
) ? COUNT_PIDS
: COUNT_USERSPACE_PROCESSES
;
966 r
= parse_argv(argc
, argv
);
970 r
= get_cgroup_root(&root
);
972 log_error_errno(r
, "Failed to get root control group path: %m");
976 a
= hashmap_new(&string_hash_ops
);
977 b
= hashmap_new(&string_hash_ops
);
983 signal(SIGWINCH
, columns_lines_cache_reset
);
985 if (arg_iterations
== (unsigned) -1)
986 arg_iterations
= on_tty() ? 0 : 1;
992 char h
[FORMAT_TIMESPAN_MAX
];
994 t
= now(CLOCK_MONOTONIC
);
996 if (t
>= last_refresh
+ arg_delay
|| immediate_refresh
) {
998 r
= refresh(root
, a
, b
, iteration
++);
1000 log_error_errno(r
, "Failed to refresh: %m");
1004 group_hashmap_clear(b
);
1011 immediate_refresh
= false;
1016 if (arg_iterations
&& iteration
>= arg_iterations
)
1019 if (!on_tty()) /* non-TTY: Empty newline as delimiter between polls */
1020 fputs("\n", stdout
);
1024 (void) usleep(last_refresh
+ arg_delay
- t
);
1026 r
= read_one_char(stdin
, &key
, last_refresh
+ arg_delay
- t
, NULL
);
1027 if (r
== -ETIMEDOUT
)
1030 log_error_errno(r
, "Couldn't read key: %m");
1035 if (on_tty()) { /* TTY: Clear any user keystroke */
1036 fputs("\r \r", stdout
);
1046 immediate_refresh
= true;
1054 arg_order
= ORDER_PATH
;
1058 arg_order
= ORDER_TASKS
;
1062 arg_order
= ORDER_CPU
;
1066 arg_order
= ORDER_MEMORY
;
1070 arg_order
= ORDER_IO
;
1074 arg_cpu_type
= arg_cpu_type
== CPU_TIME
? CPU_PERCENT
: CPU_TIME
;
1078 arg_count
= arg_count
!= COUNT_ALL_PROCESSES
? COUNT_ALL_PROCESSES
: COUNT_PIDS
;
1079 fprintf(stdout
, "\nCounting: %s.", counting_what());
1085 arg_count
= arg_count
!= COUNT_USERSPACE_PROCESSES
? COUNT_USERSPACE_PROCESSES
: COUNT_PIDS
;
1086 fprintf(stdout
, "\nCounting: %s.", counting_what());
1092 if (arg_count
== COUNT_PIDS
)
1093 fprintf(stdout
, "\n\aCannot toggle recursive counting, not available in task counting mode.");
1095 arg_recursive
= !arg_recursive
;
1096 fprintf(stdout
, "\nRecursive process counting: %s", yes_no(arg_recursive
));
1103 if (arg_delay
< USEC_PER_SEC
)
1104 arg_delay
+= USEC_PER_MSEC
*250;
1106 arg_delay
+= USEC_PER_SEC
;
1108 fprintf(stdout
, "\nIncreased delay to %s.", format_timespan(h
, sizeof(h
), arg_delay
, 0));
1114 if (arg_delay
<= USEC_PER_MSEC
*500)
1115 arg_delay
= USEC_PER_MSEC
*250;
1116 else if (arg_delay
< USEC_PER_MSEC
*1250)
1117 arg_delay
-= USEC_PER_MSEC
*250;
1119 arg_delay
-= USEC_PER_SEC
;
1121 fprintf(stdout
, "\nDecreased delay to %s.", format_timespan(h
, sizeof(h
), arg_delay
, 0));
1129 #define ON ANSI_HIGHLIGHT
1130 #define OFF ANSI_NORMAL
1133 "\t<" ON
"p" OFF
"> By path; <" ON
"t" OFF
"> By tasks/procs; <" ON
"c" OFF
"> By CPU; <" ON
"m" OFF
"> By memory; <" ON
"i" OFF
"> By I/O\n"
1134 "\t<" ON
"+" OFF
"> Inc. delay; <" ON
"-" OFF
"> Dec. delay; <" ON
"%%" OFF
"> Toggle time; <" ON
"SPACE" OFF
"> Refresh\n"
1135 "\t<" ON
"P" OFF
"> Toggle count userspace processes; <" ON
"k" OFF
"> Toggle count all processes\n"
1136 "\t<" ON
"r" OFF
"> Count processes recursively; <" ON
"q" OFF
"> Quit");
1143 fprintf(stdout
, "\nUnknown key '\\x%x'. Ignoring.", key
);
1145 fprintf(stdout
, "\nUnknown key '%c'. Ignoring.", key
);
1155 group_hashmap_free(a
);
1156 group_hashmap_free(b
);
1158 return r
< 0 ? EXIT_FAILURE
: EXIT_SUCCESS
;