mirror of https://github.com/Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
187 lines
4.2 KiB
187 lines
4.2 KiB
// SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause) |
|
// Copyright (c) 2019 Facebook |
|
#include <argp.h> |
|
#include <stdio.h> |
|
#include <stdlib.h> |
|
#include <string.h> |
|
#include <sys/resource.h> |
|
#include <time.h> |
|
#include <bpf/libbpf.h> |
|
#include <bpf/bpf.h> |
|
#include "runqslower.h" |
|
#include "runqslower.skel.h" |
|
|
|
struct env { |
|
pid_t pid; |
|
__u64 min_us; |
|
bool verbose; |
|
} env = { |
|
.min_us = 10000, |
|
}; |
|
|
|
const char *argp_program_version = "runqslower 0.1"; |
|
const char *argp_program_bug_address = "<[email protected]>"; |
|
const char argp_program_doc[] = |
|
"runqslower Trace long process scheduling delays.\n" |
|
" For Linux, uses eBPF, BPF CO-RE, libbpf, BTF.\n" |
|
"\n" |
|
"This script traces high scheduling delays between tasks being\n" |
|
"ready to run and them running on CPU after that.\n" |
|
"\n" |
|
"USAGE: runqslower [-p PID] [min_us]\n" |
|
"\n" |
|
"EXAMPLES:\n" |
|
" runqslower # trace run queue latency higher than 10000 us (default)\n" |
|
" runqslower 1000 # trace run queue latency higher than 1000 us\n" |
|
" runqslower -p 123 # trace pid 123 only\n"; |
|
|
|
static const struct argp_option opts[] = { |
|
{ "pid", 'p', "PID", 0, "Process PID to trace"}, |
|
{ "verbose", 'v', NULL, 0, "Verbose debug output" }, |
|
{}, |
|
}; |
|
|
|
static error_t parse_arg(int key, char *arg, struct argp_state *state) |
|
{ |
|
static int pos_args; |
|
int pid; |
|
long long min_us; |
|
|
|
switch (key) { |
|
case 'v': |
|
env.verbose = true; |
|
break; |
|
case 'p': |
|
errno = 0; |
|
pid = strtol(arg, NULL, 10); |
|
if (errno || pid <= 0) { |
|
fprintf(stderr, "Invalid PID: %s\n", arg); |
|
argp_usage(state); |
|
} |
|
env.pid = pid; |
|
break; |
|
case ARGP_KEY_ARG: |
|
if (pos_args++) { |
|
fprintf(stderr, |
|
"Unrecognized positional argument: %s\n", arg); |
|
argp_usage(state); |
|
} |
|
errno = 0; |
|
min_us = strtoll(arg, NULL, 10); |
|
if (errno || min_us <= 0) { |
|
fprintf(stderr, "Invalid delay (in us): %s\n", arg); |
|
argp_usage(state); |
|
} |
|
env.min_us = min_us; |
|
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 bump_memlock_rlimit(void) |
|
{ |
|
struct rlimit rlim_new = { |
|
.rlim_cur = RLIM_INFINITY, |
|
.rlim_max = RLIM_INFINITY, |
|
}; |
|
|
|
return setrlimit(RLIMIT_MEMLOCK, &rlim_new); |
|
} |
|
|
|
void handle_event(void *ctx, int cpu, void *data, __u32 data_sz) |
|
{ |
|
const struct event *e = data; |
|
struct tm *tm; |
|
char ts[32]; |
|
time_t t; |
|
|
|
time(&t); |
|
tm = localtime(&t); |
|
strftime(ts, sizeof(ts), "%H:%M:%S", tm); |
|
printf("%-8s %-16s %-6d %14llu\n", ts, e->task, e->pid, e->delta_us); |
|
} |
|
|
|
void handle_lost_events(void *ctx, int cpu, __u64 lost_cnt) |
|
{ |
|
printf("Lost %llu events on CPU #%d!\n", lost_cnt, cpu); |
|
} |
|
|
|
int main(int argc, char **argv) |
|
{ |
|
static const struct argp argp = { |
|
.options = opts, |
|
.parser = parse_arg, |
|
.doc = argp_program_doc, |
|
}; |
|
struct perf_buffer_opts pb_opts; |
|
struct perf_buffer *pb = NULL; |
|
struct runqslower_bpf *obj; |
|
int err; |
|
|
|
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", err); |
|
return 1; |
|
} |
|
|
|
obj = runqslower_bpf__open(); |
|
if (!obj) { |
|
fprintf(stderr, "failed to open and/or load BPF object\n"); |
|
return 1; |
|
} |
|
|
|
/* initialize global data (filtering options) */ |
|
obj->rodata->targ_pid = env.pid; |
|
obj->rodata->min_us = env.min_us; |
|
|
|
err = runqslower_bpf__load(obj); |
|
if (err) { |
|
fprintf(stderr, "failed to load BPF object: %d\n", err); |
|
goto cleanup; |
|
} |
|
|
|
err = runqslower_bpf__attach(obj); |
|
if (err) { |
|
fprintf(stderr, "failed to attach BPF programs\n"); |
|
goto cleanup; |
|
} |
|
|
|
printf("Tracing run queue latency higher than %llu us\n", env.min_us); |
|
printf("%-8s %-16s %-6s %14s\n", "TIME", "COMM", "PID", "LAT(us)"); |
|
|
|
pb_opts.sample_cb = handle_event; |
|
pb_opts.lost_cb = handle_lost_events; |
|
pb = perf_buffer__new(bpf_map__fd(obj->maps.events), 64, &pb_opts); |
|
err = libbpf_get_error(pb); |
|
if (err) { |
|
pb = NULL; |
|
fprintf(stderr, "failed to open perf buffer: %d\n", err); |
|
goto cleanup; |
|
} |
|
|
|
while ((err = perf_buffer__poll(pb, 100)) >= 0) |
|
; |
|
printf("Error polling perf buffer: %d\n", err); |
|
|
|
cleanup: |
|
perf_buffer__free(pb); |
|
runqslower_bpf__destroy(obj); |
|
|
|
return err != 0; |
|
}
|
|
|