[linux-2.6-block.git] / samples / bpf / test_overhead_user.c

// 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 <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

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)
{
	__u64 start_time;
	char buf[] = "test\n";
	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_urandom_read(int cpu)
{
	__u64 start_time;
	char buf[4];
	int i, fd;

	fd = open("/dev/urandom", O_RDONLY);
	if (fd < 0) {
		printf("couldn't open /dev/urandom\n");
		exit(1);
	}
	start_time = time_get_ns();
	for (i = 0; i < MAX_CNT; i++) {
		if (read(fd, buf, sizeof(buf)) < 0) {
			printf("failed to read from /dev/urandom: %s\n", strerror(errno));
			close(fd);
			return;
		}
	}
	printf("urandom_read:%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_urandom_read(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_kern.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_kern.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_kern.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;
}
Commit	Line	Data
25763b3c	1	// SPDX-License-Identifier: GPL-2.0-only
e3edfdec	2	/* Copyright (c) 2016 Facebook
e3edfdec AS	3	*/
	4	#define _GNU_SOURCE
	5	#include <sched.h>
02a2f000	6	#include <errno.h>
e3edfdec AS	7	#include <stdio.h>
	8	#include <sys/types.h>
	9	#include <asm/unistd.h>
	10	#include <fcntl.h>
	11	#include <unistd.h>
	12	#include <assert.h>
	13	#include <sys/wait.h>
	14	#include <stdlib.h>
	15	#include <signal.h>
	16	#include <linux/bpf.h>
	17	#include <string.h>
	18	#include <time.h>
2bf3e2ef	19	#include <bpf/bpf.h>
c6497df0	20	#include <bpf/libbpf.h>
e3edfdec AS	21
	22	#define MAX_CNT 1000000
	23
c6497df0 DL	24	static struct bpf_link *links[2];
	25	static struct bpf_object *obj;
	26	static int cnt;
	27
e3edfdec AS	28	static __u64 time_get_ns(void)
	29	{
	30	struct timespec ts;
	31
	32	clock_gettime(CLOCK_MONOTONIC, &ts);
	33	return ts.tv_sec * 1000000000ull + ts.tv_nsec;
	34	}
	35
	36	static void test_task_rename(int cpu)
	37	{
	38	__u64 start_time;
	39	char buf[] = "test\n";
	40	int i, fd;
	41
	42	fd = open("/proc/self/comm", O_WRONLY\|O_TRUNC);
	43	if (fd < 0) {
	44	printf("couldn't open /proc\n");
	45	exit(1);
	46	}
	47	start_time = time_get_ns();
02a2f000 TS	48	for (i = 0; i < MAX_CNT; i++) {
	49	if (write(fd, buf, sizeof(buf)) < 0) {
	50	printf("task rename failed: %s\n", strerror(errno));
	51	close(fd);
	52	return;
	53	}
	54	}
e3edfdec AS	55	printf("task_rename:%d: %lld events per sec\n",
	56	cpu, MAX_CNT * 1000000000ll / (time_get_ns() - start_time));
	57	close(fd);
	58	}
	59
	60	static void test_urandom_read(int cpu)
	61	{
	62	__u64 start_time;
	63	char buf[4];
	64	int i, fd;
	65
	66	fd = open("/dev/urandom", O_RDONLY);
	67	if (fd < 0) {
	68	printf("couldn't open /dev/urandom\n");
	69	exit(1);
	70	}
	71	start_time = time_get_ns();
02a2f000 TS	72	for (i = 0; i < MAX_CNT; i++) {
	73	if (read(fd, buf, sizeof(buf)) < 0) {
	74	printf("failed to read from /dev/urandom: %s\n", strerror(errno));
	75	close(fd);
	76	return;
	77	}
	78	}
e3edfdec AS	79	printf("urandom_read:%d: %lld events per sec\n",
	80	cpu, MAX_CNT * 1000000000ll / (time_get_ns() - start_time));
	81	close(fd);
	82	}
	83
	84	static void loop(int cpu, int flags)
	85	{
	86	cpu_set_t cpuset;
	87
	88	CPU_ZERO(&cpuset);
	89	CPU_SET(cpu, &cpuset);
	90	sched_setaffinity(0, sizeof(cpuset), &cpuset);
	91
	92	if (flags & 1)
	93	test_task_rename(cpu);
	94	if (flags & 2)
	95	test_urandom_read(cpu);
	96	}
	97
	98	static void run_perf_test(int tasks, int flags)
	99	{
	100	pid_t pid[tasks];
	101	int i;
	102
	103	for (i = 0; i < tasks; i++) {
	104	pid[i] = fork();
	105	if (pid[i] == 0) {
	106	loop(i, flags);
	107	exit(0);
	108	} else if (pid[i] == -1) {
	109	printf("couldn't spawn #%d process\n", i);
	110	exit(1);
	111	}
	112	}
	113	for (i = 0; i < tasks; i++) {
	114	int status;
	115
	116	assert(waitpid(pid[i], &status, 0) == pid[i]);
	117	assert(status == 0);
	118	}
	119	}
	120
c6497df0 DL	121	static int load_progs(char *filename)
	122	{
	123	struct bpf_program *prog;
	124	int err = 0;
	125
	126	obj = bpf_object__open_file(filename, NULL);
	127	err = libbpf_get_error(obj);
	128	if (err < 0) {
	129	fprintf(stderr, "ERROR: opening BPF object file failed\n");
	130	return err;
	131	}
	132
	133	/* load BPF program */
	134	err = bpf_object__load(obj);
	135	if (err < 0) {
	136	fprintf(stderr, "ERROR: loading BPF object file failed\n");
	137	return err;
	138	}
	139
	140	bpf_object__for_each_program(prog, obj) {
	141	links[cnt] = bpf_program__attach(prog);
	142	err = libbpf_get_error(links[cnt]);
	143	if (err < 0) {
	144	fprintf(stderr, "ERROR: bpf_program__attach failed\n");
	145	links[cnt] = NULL;
	146	return err;
	147	}
	148	cnt++;
	149	}
	150
	151	return err;
	152	}
	153
e3edfdec AS	154	static void unload_progs(void)
e3edfdec AS	155	{
c6497df0 DL	156	while (cnt)
	157	bpf_link__destroy(links[--cnt]);
	158
	159	bpf_object__close(obj);
e3edfdec AS	160	}
	161
	162	int main(int argc, char **argv)
	163	{
c6497df0	164	int num_cpu = sysconf(_SC_NPROCESSORS_ONLN);
e3edfdec	165	int test_flags = ~0;
c6497df0 DL	166	char filename[256];
c6497df0 DL	167	int err = 0;
e3edfdec	168
e3edfdec AS	169
	170	if (argc > 1)
	171	test_flags = atoi(argv[1]) ? : test_flags;
	172	if (argc > 2)
	173	num_cpu = atoi(argv[2]) ? : num_cpu;
	174
	175	if (test_flags & 0x3) {
	176	printf("BASE\n");
	177	run_perf_test(num_cpu, test_flags);
	178	}
	179
	180	if (test_flags & 0xC) {
	181	snprintf(filename, sizeof(filename),
	182	"%s_kprobe_kern.o", argv[0]);
c6497df0	183
e3edfdec	184	printf("w/KPROBE\n");
c6497df0 DL	185	err = load_progs(filename);
	186	if (!err)
	187	run_perf_test(num_cpu, test_flags >> 2);
	188
e3edfdec AS	189	unload_progs();
	190	}
	191
	192	if (test_flags & 0x30) {
	193	snprintf(filename, sizeof(filename),
	194	"%s_tp_kern.o", argv[0]);
e3edfdec	195	printf("w/TRACEPOINT\n");
c6497df0 DL	196	err = load_progs(filename);
	197	if (!err)
	198	run_perf_test(num_cpu, test_flags >> 4);
	199
e3edfdec AS	200	unload_progs();
	201	}
	202
4662a4e5 AS	203	if (test_flags & 0xC0) {
	204	snprintf(filename, sizeof(filename),
	205	"%s_raw_tp_kern.o", argv[0]);
4662a4e5	206	printf("w/RAW_TRACEPOINT\n");
c6497df0 DL	207	err = load_progs(filename);
	208	if (!err)
	209	run_perf_test(num_cpu, test_flags >> 6);
	210
4662a4e5 AS	211	unload_progs();
	212	}
	213
c6497df0	214	return err;
e3edfdec	215	}