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