bpf: Remove runqslower tool (bd5bdd20) · Commits · git / linux-net

tools/bpf/Makefile

+3 −10

Original line number	Diff line number	Diff line
		@@ -32,7 +32,7 @@ FEATURE_TESTS = libbfd disassembler-four-args disassembler-init-styled
		FEATURE_DISPLAY = libbfd

		check_feat := 1
		NON_CHECK_FEAT_TARGETS := clean bpftool_clean runqslower_clean resolve_btfids_clean
		NON_CHECK_FEAT_TARGETS := clean bpftool_clean resolve_btfids_clean
		ifdef MAKECMDGOALS
		ifeq ($(filter-out $(NON_CHECK_FEAT_TARGETS),$(MAKECMDGOALS)),)
		check_feat := 0
		@@ -70,7 +70,7 @@ $(OUTPUT)%.lex.o: $(OUTPUT)%.lex.c

		PROGS = $(OUTPUT)bpf_jit_disasm $(OUTPUT)bpf_dbg $(OUTPUT)bpf_asm

		all: $(PROGS) bpftool runqslower
		all: $(PROGS) bpftool

		$(OUTPUT)bpf_jit_disasm: CFLAGS += -DPACKAGE='bpf_jit_disasm'
		$(OUTPUT)bpf_jit_disasm: $(OUTPUT)bpf_jit_disasm.o
		@@ -86,7 +86,7 @@ $(OUTPUT)bpf_exp.lex.c: $(OUTPUT)bpf_exp.yacc.c
		$(OUTPUT)bpf_exp.yacc.o: $(OUTPUT)bpf_exp.yacc.c
		$(OUTPUT)bpf_exp.lex.o: $(OUTPUT)bpf_exp.lex.c

		clean: bpftool_clean runqslower_clean resolve_btfids_clean
		clean: bpftool_clean resolve_btfids_clean
		$(call QUIET_CLEAN, bpf-progs)
		$(Q)$(RM) -r -- $(OUTPUT)*.o $(OUTPUT)bpf_jit_disasm $(OUTPUT)bpf_dbg \
		$(OUTPUT)bpf_asm $(OUTPUT)bpf_exp.yacc.* $(OUTPUT)bpf_exp.lex.*
		@@ -112,12 +112,6 @@ bpftool_install:
		bpftool_clean:
		$(call descend,bpftool,clean)

		runqslower:
		$(call descend,runqslower)

		runqslower_clean:
		$(call descend,runqslower,clean)

		resolve_btfids:
		$(call descend,resolve_btfids)

		@@ -125,5 +119,4 @@ resolve_btfids_clean:
		$(call descend,resolve_btfids,clean)

		.PHONY: all install clean bpftool bpftool_install bpftool_clean \
		runqslower runqslower_clean \
		resolve_btfids resolve_btfids_clean

tools/bpf/runqslower/.gitignore

deleted100644 → 0

+0 −2

Original line number	Diff line number	Diff line
		# SPDX-License-Identifier: GPL-2.0-only
		/.output

tools/bpf/runqslower/Makefile

deleted100644 → 0

+0 −91

Original line number	Diff line number	Diff line
		# SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause)
		include ../../scripts/Makefile.include

		OUTPUT ?= $(abspath .output)/

		BPFTOOL_OUTPUT := $(OUTPUT)bpftool/
		DEFAULT_BPFTOOL := $(BPFTOOL_OUTPUT)bootstrap/bpftool
		BPFTOOL ?= $(DEFAULT_BPFTOOL)
		BPF_TARGET_ENDIAN ?= --target=bpf
		LIBBPF_SRC := $(abspath ../../lib/bpf)
		BPFOBJ_OUTPUT := $(OUTPUT)libbpf/
		BPFOBJ := $(BPFOBJ_OUTPUT)libbpf.a
		BPF_DESTDIR := $(BPFOBJ_OUTPUT)
		BPF_INCLUDE := $(BPF_DESTDIR)/include
		INCLUDES := -I$(OUTPUT) -I$(BPF_INCLUDE) -I$(abspath ../../include/uapi)
		CFLAGS := -g -Wall $(CLANG_CROSS_FLAGS)
		CFLAGS += $(EXTRA_CFLAGS)
		LDFLAGS += $(EXTRA_LDFLAGS)
		LDLIBS += -lelf -lz

		# Try to detect best kernel BTF source
		KERNEL_REL := $(shell uname -r)
		VMLINUX_BTF_PATHS := $(if $(O),$(O)/vmlinux) \
		$(if $(KBUILD_OUTPUT),$(KBUILD_OUTPUT)/vmlinux) \
		../../../vmlinux /sys/kernel/btf/vmlinux \
		/boot/vmlinux-$(KERNEL_REL)
		VMLINUX_BTF_PATH := $(or $(VMLINUX_BTF),$(firstword \
		$(wildcard $(VMLINUX_BTF_PATHS))))

		ifneq ($(V),1)
		MAKEFLAGS += --no-print-directory
		submake_extras := feature_display=0
		endif

		.DELETE_ON_ERROR:

		.PHONY: all clean runqslower libbpf_hdrs
		all: runqslower

		runqslower: $(OUTPUT)/runqslower

		clean:
		$(call QUIET_CLEAN, runqslower)
		$(Q)$(RM) -r $(BPFOBJ_OUTPUT) $(BPFTOOL_OUTPUT)
		$(Q)$(RM) $(OUTPUT).o $(OUTPUT).d
		$(Q)$(RM) $(OUTPUT)*.skel.h $(OUTPUT)vmlinux.h
		$(Q)$(RM) $(OUTPUT)runqslower
		$(Q)$(RM) -r .output

		libbpf_hdrs: $(BPFOBJ)

		$(OUTPUT)/runqslower: $(OUTPUT)/runqslower.o $(BPFOBJ)
		$(QUIET_LINK)$(CC) $(CFLAGS) $(LDFLAGS) $^ $(LDLIBS) -o $@

		$(OUTPUT)/runqslower.o: runqslower.h $(OUTPUT)/runqslower.skel.h \
		$(OUTPUT)/runqslower.bpf.o \| libbpf_hdrs

		$(OUTPUT)/runqslower.bpf.o: $(OUTPUT)/vmlinux.h runqslower.h \| libbpf_hdrs

		$(OUTPUT)/%.skel.h: $(OUTPUT)/%.bpf.o \| $(BPFTOOL)
		$(QUIET_GEN)$(BPFTOOL) gen skeleton $< > $@

		$(OUTPUT)/%.bpf.o: %.bpf.c $(BPFOBJ) \| $(OUTPUT)
		$(QUIET_GEN)$(CLANG) -g -O2 $(BPF_TARGET_ENDIAN) $(INCLUDES) \
		-c $(filter %.c,$^) -o $@ && \
		$(LLVM_STRIP) -g $@

		$(OUTPUT)/%.o: %.c \| $(OUTPUT)
		$(QUIET_CC)$(CC) $(CFLAGS) $(INCLUDES) -c $(filter %.c,$^) -o $@

		$(OUTPUT) $(BPFOBJ_OUTPUT) $(BPFTOOL_OUTPUT):
		$(QUIET_MKDIR)mkdir -p $@

		$(OUTPUT)/vmlinux.h: $(VMLINUX_BTF_PATH) \| $(OUTPUT) $(BPFTOOL)
		ifeq ($(VMLINUX_H),)
		$(Q)if [ ! -e "$(VMLINUX_BTF_PATH)" ] ; then \
		echo "Couldn't find kernel BTF; set VMLINUX_BTF to" \
		"specify its location." >&2; \
		exit 1;\
		fi
		$(QUIET_GEN)$(BPFTOOL) btf dump file $(VMLINUX_BTF_PATH) format c > $@
		else
		$(Q)cp "$(VMLINUX_H)" $@
		endif

		$(BPFOBJ): $(wildcard $(LIBBPF_SRC)/*.[ch] $(LIBBPF_SRC)/Makefile) \| $(BPFOBJ_OUTPUT)
		$(Q)$(MAKE) $(submake_extras) -C $(LIBBPF_SRC) OUTPUT=$(BPFOBJ_OUTPUT) \
		DESTDIR=$(BPFOBJ_OUTPUT) prefix= $(abspath $@) install_headers

		$(DEFAULT_BPFTOOL): \| $(BPFTOOL_OUTPUT)
		$(Q)$(MAKE) $(submake_extras) -C ../bpftool OUTPUT=$(BPFTOOL_OUTPUT) bootstrap

tools/bpf/runqslower/runqslower.bpf.c

deleted100644 → 0

+0 −106

Original line number	Diff line number	Diff line
		// SPDX-License-Identifier: GPL-2.0
		// Copyright (c) 2019 Facebook
		#include "vmlinux.h"
		#include <bpf/bpf_helpers.h>
		#include "runqslower.h"

		#define TASK_RUNNING 0
		#define BPF_F_CURRENT_CPU 0xffffffffULL

		const volatile __u64 min_us = 0;
		const volatile pid_t targ_pid = 0;

		struct {
		__uint(type, BPF_MAP_TYPE_TASK_STORAGE);
		__uint(map_flags, BPF_F_NO_PREALLOC);
		__type(key, int);
		__type(value, u64);
		} start SEC(".maps");

		struct {
		__uint(type, BPF_MAP_TYPE_PERF_EVENT_ARRAY);
		__uint(key_size, sizeof(u32));
		__uint(value_size, sizeof(u32));
		} events SEC(".maps");

		/* record enqueue timestamp */
		__always_inline
		static int trace_enqueue(struct task_struct *t)
		{
		u32 pid = t->pid;
		u64 *ptr;

		if (!pid \|\| (targ_pid && targ_pid != pid))
		return 0;

		ptr = bpf_task_storage_get(&start, t, 0,
		BPF_LOCAL_STORAGE_GET_F_CREATE);
		if (!ptr)
		return 0;

		*ptr = bpf_ktime_get_ns();
		return 0;
		}

		SEC("tp_btf/sched_wakeup")
		int handle__sched_wakeup(u64 *ctx)
		{
		/* TP_PROTO(struct task_struct p) /
		struct task_struct p = (void )ctx[0];

		return trace_enqueue(p);
		}

		SEC("tp_btf/sched_wakeup_new")
		int handle__sched_wakeup_new(u64 *ctx)
		{
		/* TP_PROTO(struct task_struct p) /
		struct task_struct p = (void )ctx[0];

		return trace_enqueue(p);
		}

		SEC("tp_btf/sched_switch")
		int handle__sched_switch(u64 *ctx)
		{
		/* TP_PROTO(bool preempt, struct task_struct *prev,
		* struct task_struct *next)
		*/
		struct task_struct prev = (struct task_struct )ctx[1];
		struct task_struct next = (struct task_struct )ctx[2];
		struct runq_event event = {};
		u64 *tsp, delta_us;
		u32 pid;

		/* ivcsw: treat like an enqueue event and store timestamp */
		if (prev->__state == TASK_RUNNING)
		trace_enqueue(prev);

		pid = next->pid;

		/* For pid mismatch, save a bpf_task_storage_get */
		if (!pid \|\| (targ_pid && targ_pid != pid))
		return 0;

		/* fetch timestamp and calculate delta */
		tsp = bpf_task_storage_get(&start, next, 0, 0);
		if (!tsp)
		return 0; /* missed enqueue */

		delta_us = (bpf_ktime_get_ns() - *tsp) / 1000;
		if (min_us && delta_us <= min_us)
		return 0;

		event.pid = pid;
		event.delta_us = delta_us;
		bpf_get_current_comm(&event.task, sizeof(event.task));

		/* output */
		bpf_perf_event_output(ctx, &events, BPF_F_CURRENT_CPU,
		&event, sizeof(event));

		bpf_task_storage_delete(&start, next);
		return 0;
		}

		char LICENSE[] SEC("license") = "GPL";

tools/bpf/runqslower/runqslower.c

deleted100644 → 0

+0 −171

Original line number	Diff line number	Diff line
		// 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 <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 = "<bpf@vger.kernel.org>";
		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);
		}

		void handle_event(void ctx, int cpu, void data, __u32 data_sz)
		{
		const struct runq_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 *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);

		/* Use libbpf 1.0 API mode */
		libbpf_set_strict_mode(LIBBPF_STRICT_ALL);

		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 = perf_buffer__new(bpf_map__fd(obj->maps.events), 64,
		handle_event, handle_lost_events, NULL, NULL);
		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;
		}