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 <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
14 struct env {
15 pid_t pid;
16 __u64 min_us;
17 bool verbose;
18 } env = {
19 .min_us = 10000,
20 };
21
22 const char *argp_program_version = "runqslower 0.1";
23 const char *argp_program_bug_address = "<bpf@vger.kernel.org>";
24 const 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
38 static 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
parse_arg(int key,char * arg,struct argp_state * state)44 static 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
libbpf_print_fn(enum libbpf_print_level level,const char * format,va_list args)83 int 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
bump_memlock_rlimit(void)91 static 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
handle_event(void * ctx,int cpu,void * data,__u32 data_sz)101 void 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
handle_lost_events(void * ctx,int cpu,__u64 lost_cnt)114 void 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
main(int argc,char ** argv)119 int 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 /* initialize global data (filtering options) */
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
182 cleanup:
183 perf_buffer__free(pb);
184 runqslower_bpf__destroy(obj);
185
186 return err != 0;
187 }
188
