Commit 118740b8 authored by Daniel T. Lee's avatar Daniel T. Lee Committed by Alexei Starovoitov
Browse files

samples/bpf: remove obsolete tracing related tests 

The samples/bpf has become outdated and often does not follow up with
the latest. This commit removes obsolete tracing-related tests.

Specifically, 'test_overhead' is duplicate with selftests (and bench),
and 'test_override_return', 'test_probe_write_user' tests are obsolete
since they have been replaced by kprobe_multi_override and probe_user
from selftests respectively.

The following files are removed:
- test_overhead: tests the overhead of BPF programs with task_rename,
  now covered by selftests and benchmark tests (rename-*). [1]

- test_override_return: tests the return override functionality, now
  handled by kprobe_multi_override in selftests.

- test_probe_write_user: tests the probe_write_user functionality,
  now replaced by the probe_user test in selftests.

This cleanup will help to streamline the testing framework by removing
redundant tests.

[1]: https://patchwork.kernel.org/cover/13759916



Signed-off-by: default avatarDaniel T. Lee <danieltimlee@gmail.com>
Link: https://lore.kernel.org/r/20241011044847.51584-5-danieltimlee@gmail.com


Signed-off-by: default avatarAlexei Starovoitov <ast@kernel.org>
parent 5ea68f04

samples/bpf/Makefile

+0 −11
Original line number Diff line number Diff line
@@ -17,14 +17,11 @@ tprogs-y += tracex3 
tprogs-y += tracex4

tprogs-y += tracex5

tprogs-y += tracex6

tprogs-y += tracex7

tprogs-y += test_probe_write_user

tprogs-y += trace_output

tprogs-y += lathist

tprogs-y += offwaketime

tprogs-y += spintest

tprogs-y += map_perf_test

tprogs-y += test_overhead

tprogs-y += xdp_router_ipv4

tprogs-y += trace_event

tprogs-y += sampleip
@@ -61,8 +58,6 @@ tracex3-objs := tracex3_user.o 
tracex4-objs := tracex4_user.o

tracex5-objs := tracex5_user.o $(TRACE_HELPERS)

tracex6-objs := tracex6_user.o

tracex7-objs := tracex7_user.o

test_probe_write_user-objs := test_probe_write_user_user.o

trace_output-objs := trace_output_user.o

lathist-objs := lathist_user.o

offwaketime-objs := offwaketime_user.o $(TRACE_HELPERS)
@@ -96,8 +91,6 @@ always-y += tracex3.bpf.o 
always-y += tracex4.bpf.o

always-y += tracex5.bpf.o

always-y += tracex6.bpf.o

always-y += tracex7.bpf.o

always-y += test_probe_write_user.bpf.o

always-y += trace_output.bpf.o

always-y += tcbpf1_kern.o

always-y += tc_l2_redirect_kern.o
@@ -105,9 +98,6 @@ always-y += lathist_kern.o 
always-y += offwaketime.bpf.o

always-y += spintest.bpf.o

always-y += map_perf_test.bpf.o

always-y += test_overhead_tp.bpf.o

always-y += test_overhead_raw_tp.bpf.o

always-y += test_overhead_kprobe.bpf.o

always-y += parse_varlen.o parse_simple.o parse_ldabs.o

always-y += trace_event_kern.o

always-y += sampleip_kern.o
@@ -181,7 +171,6 @@ TPROGLDLIBS_xdp_router_ipv4 += -lm -pthread 
TPROGLDLIBS_tracex4		+= -lrt

TPROGLDLIBS_trace_output	+= -lrt

TPROGLDLIBS_map_perf_test	+= -lrt

TPROGLDLIBS_test_overhead	+= -lrt



# Allows pointing LLC/CLANG to a LLVM backend with bpf support, redefine on cmdline:

# make M=samples/bpf LLC=~/git/llvm-project/llvm/build/bin/llc CLANG=~/git/llvm-project/llvm/build/bin/clang

samples/bpf/test_overhead_kprobe.bpf.c

deleted100644 → 0
+0 −41
Original line number Diff line number Diff line 
/* Copyright (c) 2016 Facebook

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of version 2 of the GNU General Public

 * License as published by the Free Software Foundation.

 */

#include "vmlinux.h"

#include <linux/version.h>

#include <bpf/bpf_helpers.h>

#include <bpf/bpf_tracing.h>

#include <bpf/bpf_core_read.h>



SEC("kprobe/__set_task_comm")

int prog(struct pt_regs *ctx)

{

	struct signal_struct *signal;

	struct task_struct *tsk;

	char oldcomm[TASK_COMM_LEN] = {};

	char newcomm[TASK_COMM_LEN] = {};

	u16 oom_score_adj;

	u32 pid;



	tsk = (void *)PT_REGS_PARM1_CORE(ctx);



	pid = BPF_CORE_READ(tsk, pid);

	bpf_core_read_str(oldcomm, sizeof(oldcomm), &tsk->comm);

	bpf_core_read_str(newcomm, sizeof(newcomm),

				  (void *)PT_REGS_PARM2(ctx));

	signal = BPF_CORE_READ(tsk, signal);

	oom_score_adj = BPF_CORE_READ(signal, oom_score_adj);

	return 0;

}



SEC("kprobe/fib_table_lookup")

int prog2(struct pt_regs *ctx)

{

	return 0;

}



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

u32 _version SEC("version") = LINUX_VERSION_CODE;

samples/bpf/test_overhead_raw_tp.bpf.c

deleted100644 → 0
+0 −17
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0

/* Copyright (c) 2018 Facebook */

#include "vmlinux.h"

#include <bpf/bpf_helpers.h>



SEC("raw_tracepoint/task_rename")

int prog(struct bpf_raw_tracepoint_args *ctx)

{

	return 0;

}



SEC("raw_tracepoint/fib_table_lookup")

int prog2(struct bpf_raw_tracepoint_args *ctx)

{

	return 0;

}

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

samples/bpf/test_overhead_tp.bpf.c

deleted100644 → 0
+0 −23
Original line number Diff line number Diff line 
/* Copyright (c) 2016 Facebook

 *

 * This program is free software; you can redistribute it and/or

 * modify it under the terms of version 2 of the GNU General Public

 * License as published by the Free Software Foundation.

 */

#include "vmlinux.h"

#include <bpf/bpf_helpers.h>



/* from /sys/kernel/tracing/events/task/task_rename/format */

SEC("tracepoint/task/task_rename")

int prog(struct trace_event_raw_task_rename *ctx)

{

	return 0;

}



/* from /sys/kernel/tracing/events/fib/fib_table_lookup/format */

SEC("tracepoint/fib/fib_table_lookup")

int prog2(struct trace_event_raw_fib_table_lookup *ctx)

{

	return 0;

}

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

samples/bpf/test_overhead_user.c

deleted100644 → 0
+0 −225
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0-only

/* Copyright (c) 2016 Facebook

 */

#define _GNU_SOURCE

#include <sched.h>

#include <errno.h>

#include <stdio.h>

#include <sys/types.h>

#include <asm/unistd.h>

#include <fcntl.h>

#include <unistd.h>

#include <assert.h>

#include <sys/wait.h>

#include <sys/socket.h>

#include <arpa/inet.h>

#include <stdlib.h>

#include <signal.h>

#include <linux/bpf.h>

#include <string.h>

#include <time.h>

#include <bpf/bpf.h>

#include <bpf/libbpf.h>



#define MAX_CNT 1000000

#define DUMMY_IP "127.0.0.1"

#define DUMMY_PORT 80



static struct bpf_link *links[2];

static struct bpf_object *obj;

static int cnt;



static __u64 time_get_ns(void)

{

	struct timespec ts;



	clock_gettime(CLOCK_MONOTONIC, &ts);

	return ts.tv_sec * 1000000000ull + ts.tv_nsec;

}



static void test_task_rename(int cpu)

{

	char buf[] = "test\n";

	__u64 start_time;

	int i, fd;



	fd = open("/proc/self/comm", O_WRONLY|O_TRUNC);

	if (fd < 0) {

		printf("couldn't open /proc\n");

		exit(1);

	}

	start_time = time_get_ns();

	for (i = 0; i < MAX_CNT; i++) {

		if (write(fd, buf, sizeof(buf)) < 0) {

			printf("task rename failed: %s\n", strerror(errno));

			close(fd);

			return;

		}

	}

	printf("task_rename:%d: %lld events per sec\n",

	       cpu, MAX_CNT * 1000000000ll / (time_get_ns() - start_time));

	close(fd);

}



static void test_fib_table_lookup(int cpu)

{

	struct sockaddr_in addr;

	char buf[] = "test\n";

	__u64 start_time;

	int i, fd;



	fd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);

	if (fd < 0) {

		printf("couldn't open socket\n");

		exit(1);

	}

	memset((char *)&addr, 0, sizeof(addr));

	addr.sin_addr.s_addr = inet_addr(DUMMY_IP);

	addr.sin_port = htons(DUMMY_PORT);

	addr.sin_family = AF_INET;

	start_time = time_get_ns();

	for (i = 0; i < MAX_CNT; i++) {

		if (sendto(fd, buf, strlen(buf), 0,

			   (struct sockaddr *)&addr, sizeof(addr)) < 0) {

			printf("failed to start ping: %s\n", strerror(errno));

			close(fd);

			return;

		}

	}

	printf("fib_table_lookup:%d: %lld events per sec\n",

	       cpu, MAX_CNT * 1000000000ll / (time_get_ns() - start_time));

	close(fd);

}



static void loop(int cpu, int flags)

{

	cpu_set_t cpuset;



	CPU_ZERO(&cpuset);

	CPU_SET(cpu, &cpuset);

	sched_setaffinity(0, sizeof(cpuset), &cpuset);



	if (flags & 1)

		test_task_rename(cpu);

	if (flags & 2)

		test_fib_table_lookup(cpu);

}



static void run_perf_test(int tasks, int flags)

{

	pid_t pid[tasks];

	int i;



	for (i = 0; i < tasks; i++) {

		pid[i] = fork();

		if (pid[i] == 0) {

			loop(i, flags);

			exit(0);

		} else if (pid[i] == -1) {

			printf("couldn't spawn #%d process\n", i);

			exit(1);

		}

	}

	for (i = 0; i < tasks; i++) {

		int status;



		assert(waitpid(pid[i], &status, 0) == pid[i]);

		assert(status == 0);

	}

}



static int load_progs(char *filename)

{

	struct bpf_program *prog;

	int err = 0;



	obj = bpf_object__open_file(filename, NULL);

	err = libbpf_get_error(obj);

	if (err < 0) {

		fprintf(stderr, "ERROR: opening BPF object file failed\n");

		return err;

	}



	/* load BPF program */

	err = bpf_object__load(obj);

	if (err < 0) {

		fprintf(stderr, "ERROR: loading BPF object file failed\n");

		return err;

	}



	bpf_object__for_each_program(prog, obj) {

		links[cnt] = bpf_program__attach(prog);

		err = libbpf_get_error(links[cnt]);

		if (err < 0) {

			fprintf(stderr, "ERROR: bpf_program__attach failed\n");

			links[cnt] = NULL;

			return err;

		}

		cnt++;

	}



	return err;

}



static void unload_progs(void)

{

	while (cnt)

		bpf_link__destroy(links[--cnt]);



	bpf_object__close(obj);

}



int main(int argc, char **argv)

{

	int num_cpu = sysconf(_SC_NPROCESSORS_ONLN);

	int test_flags = ~0;

	char filename[256];

	int err = 0;





	if (argc > 1)

		test_flags = atoi(argv[1]) ? : test_flags;

	if (argc > 2)

		num_cpu = atoi(argv[2]) ? : num_cpu;



	if (test_flags & 0x3) {

		printf("BASE\n");

		run_perf_test(num_cpu, test_flags);

	}



	if (test_flags & 0xC) {

		snprintf(filename, sizeof(filename),

			 "%s_kprobe.bpf.o", argv[0]);



		printf("w/KPROBE\n");

		err = load_progs(filename);

		if (!err)

			run_perf_test(num_cpu, test_flags >> 2);



		unload_progs();

	}



	if (test_flags & 0x30) {

		snprintf(filename, sizeof(filename),

			 "%s_tp.bpf.o", argv[0]);

		printf("w/TRACEPOINT\n");

		err = load_progs(filename);

		if (!err)

			run_perf_test(num_cpu, test_flags >> 4);



		unload_progs();

	}



	if (test_flags & 0xC0) {

		snprintf(filename, sizeof(filename),

			 "%s_raw_tp.bpf.o", argv[0]);

		printf("w/RAW_TRACEPOINT\n");

		err = load_progs(filename);

		if (!err)

			run_perf_test(num_cpu, test_flags >> 6);



		unload_progs();

	}



	return err;

}