// SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause) // Copyright (c) 2020 Wenbo Zhang // // Based on cpudist(8) from BCC by Brendan Gregg & Dina Goldshtein. // 8-May-2020 Wenbo Zhang Created this. #include #include #include #include #include #include #include #include "cpudist.h" #include "cpudist.skel.h" #include "trace_helpers.h" static struct env { time_t interval; pid_t pid; int times; bool offcpu; bool timestamp; bool per_process; bool per_thread; bool milliseconds; bool verbose; } env = { .interval = 99999999, .pid = -1, .times = 99999999, }; static volatile bool exiting; const char *argp_program_version = "cpudist 0.1"; const char *argp_program_bug_address = "https://github.com/iovisor/bcc/tree/master/libbpf-tools"; const char argp_program_doc[] = "Summarize on-CPU time per task as a histogram.\n" "\n" "USAGE: cpudist [--help] [-O] [-T] [-m] [-P] [-L] [-p PID] [interval] [count]\n" "\n" "EXAMPLES:\n" " cpudist # summarize on-CPU time as a histogram" " cpudist -O # summarize off-CPU time as a histogram" " cpudist 1 10 # print 1 second summaries, 10 times" " cpudist -mT 1 # 1s summaries, milliseconds, and timestamps" " cpudist -P # show each PID separately" " cpudist -p 185 # trace PID 185 only"; static const struct argp_option opts[] = { { "offcpu", 'O', NULL, 0, "Measure off-CPU time" }, { "timestamp", 'T', NULL, 0, "Include timestamp on output" }, { "milliseconds", 'm', NULL, 0, "Millisecond histogram" }, { "pids", 'P', NULL, 0, "Print a histogram per process ID" }, { "tids", 'L', NULL, 0, "Print a histogram per thread ID" }, { "pid", 'p', "PID", 0, "Trace this PID only" }, { "verbose", 'v', NULL, 0, "Verbose debug output" }, { NULL, 'h', NULL, OPTION_HIDDEN, "Show the full help" }, {}, }; static error_t parse_arg(int key, char *arg, struct argp_state *state) { static int pos_args; switch (key) { case 'h': argp_state_help(state, stderr, ARGP_HELP_STD_HELP); break; case 'v': env.verbose = true; break; case 'm': env.milliseconds = true; break; case 'p': errno = 0; env.pid = strtol(arg, NULL, 10); if (errno) { fprintf(stderr, "invalid PID: %s\n", arg); argp_usage(state); } break; case 'O': env.offcpu = true; break; case 'P': env.per_process = true; break; case 'L': env.per_thread = true; break; case 'T': env.timestamp = true; break; case ARGP_KEY_ARG: errno = 0; if (pos_args == 0) { env.interval = strtol(arg, NULL, 10); if (errno) { fprintf(stderr, "invalid internal\n"); argp_usage(state); } } else if (pos_args == 1) { env.times = strtol(arg, NULL, 10); if (errno) { fprintf(stderr, "invalid times\n"); argp_usage(state); } } else { fprintf(stderr, "unrecognized positional argument: %s\n", arg); argp_usage(state); } pos_args++; break; default: return ARGP_ERR_UNKNOWN; } return 0; } int libbpf_print_fn(enum libbpf_print_level level, const char *format, va_list args) { if (level == LIBBPF_DEBUG && !env.verbose) return 0; return vfprintf(stderr, format, args); } static int get_pid_max(void) { int pid_max; FILE *f; f = fopen("/proc/sys/kernel/pid_max", "r"); if (!f) return -1; if (fscanf(f, "%d\n", &pid_max) != 1) pid_max = -1; fclose(f); return pid_max; } static void sig_handler(int sig) { exiting = true; } static int print_log2_hists(int fd) { char *units = env.milliseconds ? "msecs" : "usecs"; __u32 lookup_key = -2, next_key; struct hist hist; int err; while (!bpf_map_get_next_key(fd, &lookup_key, &next_key)) { err = bpf_map_lookup_elem(fd, &next_key, &hist); if (err < 0) { fprintf(stderr, "failed to lookup hist: %d\n", err); return -1; } if (env.per_process) printf("\npid = %d %s\n", next_key, hist.comm); if (env.per_thread) printf("\ntid = %d %s\n", next_key, hist.comm); print_log2_hist(hist.slots, MAX_SLOTS, units); lookup_key = next_key; } lookup_key = -2; while (!bpf_map_get_next_key(fd, &lookup_key, &next_key)) { err = bpf_map_delete_elem(fd, &next_key); if (err < 0) { fprintf(stderr, "failed to cleanup hist : %d\n", err); return -1; } lookup_key = next_key; } return 0; } int main(int argc, char **argv) { static const struct argp argp = { .options = opts, .parser = parse_arg, .doc = argp_program_doc, }; struct cpudist_bpf *obj; int pid_max, fd, err; struct tm *tm; char ts[32]; time_t t; err = argp_parse(&argp, argc, argv, 0, NULL, NULL); if (err) return err; libbpf_set_print(libbpf_print_fn); err = bump_memlock_rlimit(); if (err) { fprintf(stderr, "failed to increase rlimit: %d\n", err); return 1; } obj = cpudist_bpf__open(); if (!obj) { fprintf(stderr, "failed to open BPF object\n"); return 1; } /* initialize global data (filtering options) */ obj->rodata->targ_per_process = env.per_process; obj->rodata->targ_per_thread = env.per_thread; obj->rodata->targ_ms = env.milliseconds; obj->rodata->targ_offcpu = env.offcpu; obj->rodata->targ_tgid = env.pid; pid_max = get_pid_max(); if (pid_max < 0) { fprintf(stderr, "failed to get pid_max\n"); return 1; } bpf_map__resize(obj->maps.start, pid_max); if (!env.per_process && !env.per_thread) bpf_map__resize(obj->maps.hists, 1); else bpf_map__resize(obj->maps.hists, pid_max); err = cpudist_bpf__load(obj); if (err) { fprintf(stderr, "failed to load BPF object: %d\n", err); goto cleanup; } err = cpudist_bpf__attach(obj); if (err) { fprintf(stderr, "failed to attach BPF programs\n"); goto cleanup; } fd = bpf_map__fd(obj->maps.hists); signal(SIGINT, sig_handler); printf("Tracing %s-CPU time... Hit Ctrl-C to end.\n", env.offcpu ? "off" : "on"); /* main: poll */ while (1) { sleep(env.interval); printf("\n"); if (env.timestamp) { time(&t); tm = localtime(&t); strftime(ts, sizeof(ts), "%H:%M:%S", tm); printf("%-8s\n", ts); } err = print_log2_hists(fd); if (err) break; if (exiting || --env.times == 0) break; } cleanup: cpudist_bpf__destroy(obj); return err != 0; }