tools/bpf/runqslower/runqslower.c

   1 // SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause)
   2 // Copyright (c) 2019 Facebook
   3 #include <argp.h>
   4 #include <stdio.h>
   5 #include <stdlib.h>
   6 #include <string.h>
   7 #include <time.h>
   8 #include <bpf/libbpf.h>
   9 #include <bpf/bpf.h>
  10 #include "runqslower.h"
  11 #include "runqslower.skel.h"
  12
  13 struct env {
  14         pid_t pid;
  15         __u64 min_us;
  16         bool verbose;
  17 } env = {
  18         .min_us = 10000,
  19 };
  20
  21 const char *argp_program_version = "runqslower 0.1";
  22 const char *argp_program_bug_address = "<bpf@vger.kernel.org>";
  23 const char argp_program_doc[] =
  24 "runqslower    Trace long process scheduling delays.\n"
  25 "              For Linux, uses eBPF, BPF CO-RE, libbpf, BTF.\n"
  26 "\n"
  27 "This script traces high scheduling delays between tasks being\n"
  28 "ready to run and them running on CPU after that.\n"
  29 "\n"
  30 "USAGE: runqslower [-p PID] [min_us]\n"
  31 "\n"
  32 "EXAMPLES:\n"
  33 "    runqslower         # trace run queue latency higher than 10000 us (default)\n"
  34 "    runqslower 1000    # trace run queue latency higher than 1000 us\n"
  35 "    runqslower -p 123  # trace pid 123 only\n";
  36
  37 static const struct argp_option opts[] = {
  38         { "pid", 'p', "PID", 0, "Process PID to trace"},
  39         { "verbose", 'v', NULL, 0, "Verbose debug output" },
  40         {},
  41 };
  42
  43 static error_t parse_arg(int key, char *arg, struct argp_state *state)
  44 {
  45         static int pos_args;
  46         int pid;
  47         long long min_us;
  48
  49         switch (key) {
  50         case 'v':
  51                 env.verbose = true;
  52                 break;
  53         case 'p':
  54                 errno = 0;
  55                 pid = strtol(arg, NULL, 10);
  56                 if (errno || pid <= 0) {
  57                         fprintf(stderr, "Invalid PID: %s\n", arg);
  58                         argp_usage(state);
  59                 }
  60                 env.pid = pid;
  61                 break;
  62         case ARGP_KEY_ARG:
  63                 if (pos_args++) {
  64                         fprintf(stderr,
  65                                 "Unrecognized positional argument: %s\n", arg);
  66                         argp_usage(state);
  67                 }
  68                 errno = 0;
  69                 min_us = strtoll(arg, NULL, 10);
  70                 if (errno || min_us <= 0) {
  71                         fprintf(stderr, "Invalid delay (in us): %s\n", arg);
  72                         argp_usage(state);
  73                 }
  74                 env.min_us = min_us;
  75                 break;
  76         default:
  77                 return ARGP_ERR_UNKNOWN;
  78         }
  79         return 0;
  80 }
  81
  82 int libbpf_print_fn(enum libbpf_print_level level,
  83                     const char *format, va_list args)
  84 {
  85         if (level == LIBBPF_DEBUG && !env.verbose)
  86                 return 0;
  87         return vfprintf(stderr, format, args);
  88 }
  89
  90 void handle_event(void *ctx, int cpu, void *data, __u32 data_sz)
  91 {
  92         const struct runq_event *e = data;
  93         struct tm *tm;
  94         char ts[32];
  95         time_t t;
  96
  97         time(&t);
  98         tm = localtime(&t);
  99         strftime(ts, sizeof(ts), "%H:%M:%S", tm);
 100         printf("%-8s %-16s %-6d %14llu\n", ts, e->task, e->pid, e->delta_us);
 101 }
 102
 103 void handle_lost_events(void *ctx, int cpu, __u64 lost_cnt)
 104 {
 105         printf("Lost %llu events on CPU #%d!\n", lost_cnt, cpu);
 106 }
 107
 108 int main(int argc, char **argv)
 109 {
 110         static const struct argp argp = {
 111                 .options = opts,
 112                 .parser = parse_arg,
 113                 .doc = argp_program_doc,
 114         };
 115         struct perf_buffer *pb = NULL;
 116         struct runqslower_bpf *obj;
 117         int err;
 118
 119         err = argp_parse(&argp, argc, argv, 0, NULL, NULL);
 120         if (err)
 121                 return err;
 122
 123         libbpf_set_print(libbpf_print_fn);
 124
 125         /* Use libbpf 1.0 API mode */
 126         libbpf_set_strict_mode(LIBBPF_STRICT_ALL);
 127
 128         obj = runqslower_bpf__open();
 129         if (!obj) {
 130                 fprintf(stderr, "failed to open and/or load BPF object\n");
 131                 return 1;
 132         }
 133
 134         /* initialize global data (filtering options) */
 135         obj->rodata->targ_pid = env.pid;
 136         obj->rodata->min_us = env.min_us;
 137
 138         err = runqslower_bpf__load(obj);
 139         if (err) {
 140                 fprintf(stderr, "failed to load BPF object: %d\n", err);
 141                 goto cleanup;
 142         }
 143
 144         err = runqslower_bpf__attach(obj);
 145         if (err) {
 146                 fprintf(stderr, "failed to attach BPF programs\n");
 147                 goto cleanup;
 148         }
 149
 150         printf("Tracing run queue latency higher than %llu us\n", env.min_us);
 151         printf("%-8s %-16s %-6s %14s\n", "TIME", "COMM", "PID", "LAT(us)");
 152
 153         pb = perf_buffer__new(bpf_map__fd(obj->maps.events), 64,
 154                               handle_event, handle_lost_events, NULL, NULL);
 155         err = libbpf_get_error(pb);
 156         if (err) {
 157                 pb = NULL;
 158                 fprintf(stderr, "failed to open perf buffer: %d\n", err);
 159                 goto cleanup;
 160         }
 161
 162         while ((err = perf_buffer__poll(pb, 100)) >= 0)
 163                 ;
 164         printf("Error polling perf buffer: %d\n", err);
 165
 166 cleanup:
 167         perf_buffer__free(pb);
 168         runqslower_bpf__destroy(obj);
 169
 170         return err != 0;
 171 }