lael-labs/linux

tools/testing/selftests/bpf/Makefile+7−5

 $(OUTPUT)/urandom_read: urandom_read.c
 	$(call msg,BINARY,,$@)
-	$(Q)$(CC) $(LDFLAGS) $< $(LDLIBS) -Wl,--build-id=sha1 -o $@
+	$(Q)$(CC) $(CFLAGS) $(LDFLAGS) $< $(LDLIBS) -Wl,--build-id=sha1 -o $@
 $(OUTPUT)/bpf_testmod.ko: $(VMLINUX_BTF) $(wildcard bpf_testmod/Makefile bpf_testmod/*.[ch])
 	$(call msg,MOD,,$@)
 $(DEFAULT_BPFTOOL): $(wildcard $(BPFTOOLDIR)/*.[ch] $(BPFTOOLDIR)/Makefile)    \
 		    $(HOST_BPFOBJ) | $(HOST_BUILD_DIR)/bpftool
 	$(Q)$(MAKE) $(submake_extras)  -C $(BPFTOOLDIR)			       \
-		    CC=$(HOSTCC) LD=$(HOSTLD)				       \
+		    ARCH= CROSS_COMPILE= CC=$(HOSTCC) LD=$(HOSTLD) 	       \
 		    EXTRA_CFLAGS='-g -O0'				       \
 		    OUTPUT=$(HOST_BUILD_DIR)/bpftool/			       \
 		    LIBBPF_OUTPUT=$(HOST_BUILD_DIR)/libbpf/		       \
 		$(APIDIR)/linux/bpf.h					       \
 		| $(HOST_BUILD_DIR)/libbpf
 	$(Q)$(MAKE) $(submake_extras) -C $(BPFDIR)                             \
-		    EXTRA_CFLAGS='-g -O0'				       \
+		    EXTRA_CFLAGS='-g -O0' ARCH= CROSS_COMPILE=		       \
 		    OUTPUT=$(HOST_BUILD_DIR)/libbpf/ CC=$(HOSTCC) LD=$(HOSTLD) \
 		    DESTDIR=$(HOST_SCRATCH_DIR)/ prefix= all install_headers
 endif
 			    $(OUTPUT)/perfbuf_bench.skel.h
 $(OUTPUT)/bench_bloom_filter_map.o: $(OUTPUT)/bloom_filter_bench.skel.h
 $(OUTPUT)/bench_bpf_loop.o: $(OUTPUT)/bpf_loop_bench.skel.h
+$(OUTPUT)/bench_strncmp.o: $(OUTPUT)/strncmp_bench.skel.h
 $(OUTPUT)/bench.o: bench.h testing_helpers.h $(BPFOBJ)
 $(OUTPUT)/bench: LDLIBS += -lm
 $(OUTPUT)/bench: $(OUTPUT)/bench.o \
 		 $(OUTPUT)/bench_trigger.o \
 		 $(OUTPUT)/bench_ringbufs.o \
 		 $(OUTPUT)/bench_bloom_filter_map.o \
-		 $(OUTPUT)/bench_bpf_loop.o
+		 $(OUTPUT)/bench_bpf_loop.o \
+		 $(OUTPUT)/bench_strncmp.o
 	$(call msg,BINARY,,$@)
-	$(Q)$(CC) $(LDFLAGS) $(filter %.a %.o,$^) $(LDLIBS) -o $@
+	$(Q)$(CC) $(CFLAGS) $(LDFLAGS) $(filter %.a %.o,$^) $(LDLIBS) -o $@
 EXTRA_CLEAN := $(TEST_CUSTOM_PROGS) $(SCRATCH_DIR) $(HOST_SCRATCH_DIR)	\
 	prog_tests/tests.h map_tests/tests.h verifier/tests.h		\

tools/testing/selftests/bpf/bench.c+7−17

 	return vfprintf(stderr, format, args);
 }
-static int bump_memlock_rlimit(void)
+void setup_libbpf(void)
 {
-	struct rlimit rlim_new = {
-		.rlim_cur	= RLIM_INFINITY,
-		.rlim_max	= RLIM_INFINITY,
-	};
-	return setrlimit(RLIMIT_MEMLOCK, &rlim_new);
-}
-void setup_libbpf()
-{
-	int err;
 	libbpf_set_strict_mode(LIBBPF_STRICT_ALL);
 	libbpf_set_print(libbpf_print_fn);
-	err = bump_memlock_rlimit();
-	if (err)
-		fprintf(stderr, "failed to increase RLIMIT_MEMLOCK: %d", err);
 }
 void false_hits_report_progress(int iter, struct bench_res *res, long delta_ns)
 extern struct argp bench_ringbufs_argp;
 extern struct argp bench_bloom_map_argp;
 extern struct argp bench_bpf_loop_argp;
+extern struct argp bench_strncmp_argp;
 static const struct argp_child bench_parsers[] = {
 	{ &bench_ringbufs_argp, 0, "Ring buffers benchmark", 0 },
 	{ &bench_bloom_map_argp, 0, "Bloom filter map benchmark", 0 },
 	{ &bench_bpf_loop_argp, 0, "bpf_loop helper benchmark", 0 },
+	{ &bench_strncmp_argp, 0, "bpf_strncmp helper benchmark", 0 },
 	{},
 };
 extern const struct bench bench_hashmap_without_bloom;
 extern const struct bench bench_hashmap_with_bloom;
 extern const struct bench bench_bpf_loop;
+extern const struct bench bench_strncmp_no_helper;
+extern const struct bench bench_strncmp_helper;
 static const struct bench *benchs[] = {
 	&bench_count_global,
 	&bench_hashmap_without_bloom,
 	&bench_hashmap_with_bloom,
 	&bench_bpf_loop,
+	&bench_strncmp_no_helper,
+	&bench_strncmp_helper,
 };
 static void setup_benchmark()

tools/testing/selftests/bpf/bench.h+5−4

 struct bench {
 	const char *name;
-	void (*validate)();
+	void (*validate)(void);
-	void (*setup)();
+	void (*setup)(void);
 	void *(*producer_thread)(void *ctx);
 	void *(*consumer_thread)(void *ctx);
 	void (*measure)(struct bench_res* res);
 extern struct env env;
 extern const struct bench *bench;
-void setup_libbpf();
+void setup_libbpf(void);
 void hits_drops_report_progress(int iter, struct bench_res *res, long delta_ns);
 void hits_drops_report_final(struct bench_res res[], int res_cnt);
 void false_hits_report_progress(int iter, struct bench_res *res, long delta_ns);
 void ops_report_progress(int iter, struct bench_res *res, long delta_ns);
 void ops_report_final(struct bench_res res[], int res_cnt);
-static inline __u64 get_time_ns() {
+static inline __u64 get_time_ns(void)
+{
 	struct timespec t;
 	clock_gettime(CLOCK_MONOTONIC, &t);

tools/testing/selftests/bpf/benchs/bench_count.c+1−1

@@ -36,7 +36,7 @@ static struct count_local_ctx { · 35 unmodified lines
36	struct counter *hits;	36	struct counter *hits;
37	} count_local_ctx;	37	} count_local_ctx;
38		38
39	static void count_local_setup()	39	static void count_local_setup(void)
40	{	40	{
41	struct count_local_ctx *ctx = &count_local_ctx;	41	struct count_local_ctx *ctx = &count_local_ctx;
42		42

tools/testing/selftests/bpf/benchs/bench_rename.c+8−8

@@ -11,7 +11,7 @@ static struct ctx { · 10 unmodified lines
11	int fd;	11	int fd;
12	} ctx;	12	} ctx;
13		13
14	static void validate()	14	static void validate(void)
15	{	15	{
16	if (env.producer_cnt != 1) {	16	if (env.producer_cnt != 1) {
17	fprintf(stderr, "benchmark doesn't support multi-producer!\n");	17	fprintf(stderr, "benchmark doesn't support multi-producer!\n");
@@ -43,7 +43,7 @@ static void measure(struct bench_res *res) · 25 unmodified lines
43	res->hits = atomic_swap(&ctx.hits.value, 0);	43	res->hits = atomic_swap(&ctx.hits.value, 0);
44	}	44	}
45		45
46	static void setup_ctx()	46	static void setup_ctx(void)
47	{	47	{
48	setup_libbpf();	48	setup_libbpf();
49		49
@@ -71,36 +71,36 @@ static void attach_bpf(struct bpf_program *prog) · 21 unmodified lines
71	}	71	}
72	}	72	}
73		73
74	static void setup_base()	74	static void setup_base(void)
75	{	75	{
76	setup_ctx();	76	setup_ctx();
77	}	77	}
78		78
79	static void setup_kprobe()	79	static void setup_kprobe(void)
80	{	80	{
81	setup_ctx();	81	setup_ctx();
82	attach_bpf(ctx.skel->progs.prog1);	82	attach_bpf(ctx.skel->progs.prog1);
83	}	83	}
84		84
85	static void setup_kretprobe()	85	static void setup_kretprobe(void)
86	{	86	{
87	setup_ctx();	87	setup_ctx();
88	attach_bpf(ctx.skel->progs.prog2);	88	attach_bpf(ctx.skel->progs.prog2);
89	}	89	}
90		90
91	static void setup_rawtp()	91	static void setup_rawtp(void)
92	{	92	{
93	setup_ctx();	93	setup_ctx();
94	attach_bpf(ctx.skel->progs.prog3);	94	attach_bpf(ctx.skel->progs.prog3);
95	}	95	}
96		96
97	static void setup_fentry()	97	static void setup_fentry(void)
98	{	98	{
99	setup_ctx();	99	setup_ctx();
100	attach_bpf(ctx.skel->progs.prog4);	100	attach_bpf(ctx.skel->progs.prog4);
101	}	101	}
102		102
103	static void setup_fexit()	103	static void setup_fexit(void)
104	{	104	{
105	setup_ctx();	105	setup_ctx();
106	attach_bpf(ctx.skel->progs.prog5);	106	attach_bpf(ctx.skel->progs.prog5);

tools/testing/selftests/bpf/benchs/bench_ringbufs.c+7−7

@@ -88,12 +88,12 @@ const struct argp bench_ringbufs_argp = { · 87 unmodified lines
88		88
89	static struct counter buf_hits;	89	static struct counter buf_hits;
90		90
91	static inline void bufs_trigger_batch()	91	static inline void bufs_trigger_batch(void)
92	{	92	{
93	(void)syscall(__NR_getpgid);	93	(void)syscall(__NR_getpgid);
94	}	94	}
95		95
96	static void bufs_validate()	96	static void bufs_validate(void)
97	{	97	{
98	if (env.consumer_cnt != 1) {	98	if (env.consumer_cnt != 1) {
99	fprintf(stderr, "rb-libbpf benchmark doesn't support multi-consumer!\n");	99	fprintf(stderr, "rb-libbpf benchmark doesn't support multi-consumer!\n");
@@ -132,7 +132,7 @@ static void ringbuf_libbpf_measure(struct bench_res *res) · 32 unmodified lines
132	res->drops = atomic_swap(&ctx->skel->bss->dropped, 0);	132	res->drops = atomic_swap(&ctx->skel->bss->dropped, 0);
133	}	133	}
134		134
135	static struct ringbuf_bench *ringbuf_setup_skeleton()	135	static struct ringbuf_bench *ringbuf_setup_skeleton(void)
136	{	136	{
137	struct ringbuf_bench *skel;	137	struct ringbuf_bench *skel;
138		138
@@ -167,7 +167,7 @@ static int buf_process_sample(void ctx, void data, size_t len) · 28 unmodified lines
167	return 0;	167	return 0;
168	}	168	}
169		169
170	static void ringbuf_libbpf_setup()	170	static void ringbuf_libbpf_setup(void)
171	{	171	{
172	struct ringbuf_libbpf_ctx *ctx = &ringbuf_libbpf_ctx;	172	struct ringbuf_libbpf_ctx *ctx = &ringbuf_libbpf_ctx;
173	struct bpf_link *link;	173	struct bpf_link *link;
@@ -223,7 +223,7 @@ static void ringbuf_custom_measure(struct bench_res *res) · 49 unmodified lines
223	res->drops = atomic_swap(&ctx->skel->bss->dropped, 0);	223	res->drops = atomic_swap(&ctx->skel->bss->dropped, 0);
224	}	224	}
225		225
226	static void ringbuf_custom_setup()	226	static void ringbuf_custom_setup(void)
227	{	227	{
228	struct ringbuf_custom_ctx *ctx = &ringbuf_custom_ctx;	228	struct ringbuf_custom_ctx *ctx = &ringbuf_custom_ctx;
229	const size_t page_size = getpagesize();	229	const size_t page_size = getpagesize();
@@ -352,7 +352,7 @@ static void perfbuf_measure(struct bench_res *res) · 122 unmodified lines
352	res->drops = atomic_swap(&ctx->skel->bss->dropped, 0);	352	res->drops = atomic_swap(&ctx->skel->bss->dropped, 0);
353	}	353	}
354		354
355	static struct perfbuf_bench *perfbuf_setup_skeleton()	355	static struct perfbuf_bench *perfbuf_setup_skeleton(void)
356	{	356	{
357	struct perfbuf_bench *skel;	357	struct perfbuf_bench *skel;
358		358
@@ -390,7 +390,7 @@ perfbuf_process_sample_raw(void *input_ctx, int cpu, · 31 unmodified lines
390	return LIBBPF_PERF_EVENT_CONT;	390	return LIBBPF_PERF_EVENT_CONT;
391	}	391	}
392		392
393	static void perfbuf_libbpf_setup()	393	static void perfbuf_libbpf_setup(void)
394	{	394	{
395	struct perfbuf_libbpf_ctx *ctx = &perfbuf_libbpf_ctx;	395	struct perfbuf_libbpf_ctx *ctx = &perfbuf_libbpf_ctx;
396	struct perf_event_attr attr;	396	struct perf_event_attr attr;

tools/testing/selftests/bpf/benchs/bench_strncmp.c+161−0

@@ -0,0 +1,161 @@
	1	// SPDX-License-Identifier: GPL-2.0
	2	/* Copyright (C) 2021. Huawei Technologies Co., Ltd */
	3	#include <argp.h>
	4	#include "bench.h"
	5	#include "strncmp_bench.skel.h"
	6
	7	static struct strncmp_ctx {
	8	struct strncmp_bench *skel;
	9	} ctx;
	10
	11	static struct strncmp_args {
	12	u32 cmp_str_len;
	13	} args = {
	14	.cmp_str_len = 32,
	15	};
	16
	17	enum {
	18	ARG_CMP_STR_LEN = 5000,
	19	};
	20
	21	static const struct argp_option opts[] = {
	22	{ "cmp-str-len", ARG_CMP_STR_LEN, "CMP_STR_LEN", 0,
	23	"Set the length of compared string" },
	24	{},
	25	};
	26
	27	static error_t strncmp_parse_arg(int key, char arg, struct argp_state state)
	28	{
	29	switch (key) {
	30	case ARG_CMP_STR_LEN:
	31	args.cmp_str_len = strtoul(arg, NULL, 10);
	32	if (!args.cmp_str_len \|\|
	33	args.cmp_str_len >= sizeof(ctx.skel->bss->str)) {
	34	fprintf(stderr, "Invalid cmp str len (limit %zu)\n",
	35	sizeof(ctx.skel->bss->str));
	36	argp_usage(state);
	37	}
	38	break;
	39	default:
	40	return ARGP_ERR_UNKNOWN;
	41	}
	42
	43	return 0;
	44	}
	45
	46	const struct argp bench_strncmp_argp = {
	47	.options = opts,
	48	.parser = strncmp_parse_arg,
	49	};
	50
	51	static void strncmp_validate(void)
	52	{
	53	if (env.consumer_cnt != 1) {
	54	fprintf(stderr, "strncmp benchmark doesn't support multi-consumer!\n");
	55	exit(1);
	56	}
	57	}
	58
	59	static void strncmp_setup(void)
	60	{
	61	int err;
	62	char *target;
	63	size_t i, sz;
	64
	65	sz = sizeof(ctx.skel->rodata->target);
	66	if (!sz \|\| sz < sizeof(ctx.skel->bss->str)) {
	67	fprintf(stderr, "invalid string size (target %zu, src %zu)\n",
	68	sz, sizeof(ctx.skel->bss->str));
	69	exit(1);
	70	}
	71
	72	setup_libbpf();
	73
	74	ctx.skel = strncmp_bench__open();
	75	if (!ctx.skel) {
	76	fprintf(stderr, "failed to open skeleton\n");
	77	exit(1);
	78	}
	79
	80	srandom(time(NULL));
	81	target = ctx.skel->rodata->target;
	82	for (i = 0; i < sz - 1; i++)
	83	target[i] = '1' + random() % 9;
	84	target[sz - 1] = '\0';
	85
	86	ctx.skel->rodata->cmp_str_len = args.cmp_str_len;
	87
	88	memcpy(ctx.skel->bss->str, target, args.cmp_str_len);
	89	ctx.skel->bss->str[args.cmp_str_len] = '\0';
	90	/* Make bss->str < rodata->target */
	91	ctx.skel->bss->str[args.cmp_str_len - 1] -= 1;
	92
	93	err = strncmp_bench__load(ctx.skel);
	94	if (err) {
	95	fprintf(stderr, "failed to load skeleton\n");
	96	strncmp_bench__destroy(ctx.skel);
	97	exit(1);
	98	}
	99	}
	100
	101	static void strncmp_attach_prog(struct bpf_program *prog)
	102	{
	103	struct bpf_link *link;
	104
	105	link = bpf_program__attach(prog);
	106	if (!link) {
	107	fprintf(stderr, "failed to attach program!\n");
	108	exit(1);
	109	}
	110	}
	111
	112	static void strncmp_no_helper_setup(void)
	113	{
	114	strncmp_setup();
	115	strncmp_attach_prog(ctx.skel->progs.strncmp_no_helper);
	116	}
	117
	118	static void strncmp_helper_setup(void)
	119	{
	120	strncmp_setup();
	121	strncmp_attach_prog(ctx.skel->progs.strncmp_helper);
	122	}
	123
	124	static void strncmp_producer(void ctx)
	125	{
	126	while (true)
	127	(void)syscall(__NR_getpgid);
	128	return NULL;
	129	}
	130
	131	static void strncmp_consumer(void ctx)
	132	{
	133	return NULL;
	134	}
	135
	136	static void strncmp_measure(struct bench_res *res)
	137	{
	138	res->hits = atomic_swap(&ctx.skel->bss->hits, 0);
	139	}
	140
	141	const struct bench bench_strncmp_no_helper = {
	142	.name = "strncmp-no-helper",
	143	.validate = strncmp_validate,
	144	.setup = strncmp_no_helper_setup,
	145	.producer_thread = strncmp_producer,
	146	.consumer_thread = strncmp_consumer,
	147	.measure = strncmp_measure,
	148	.report_progress = hits_drops_report_progress,
	149	.report_final = hits_drops_report_final,
	150	};
	151
	152	const struct bench bench_strncmp_helper = {
	153	.name = "strncmp-helper",
	154	.validate = strncmp_validate,
	155	.setup = strncmp_helper_setup,
	156	.producer_thread = strncmp_producer,
	157	.consumer_thread = strncmp_consumer,
	158	.measure = strncmp_measure,
	159	.report_progress = hits_drops_report_progress,
	160	.report_final = hits_drops_report_final,
	161	};

tools/testing/selftests/bpf/benchs/bench_trigger.c+12−12

@@ -11,7 +11,7 @@ static struct trigger_ctx { · 10 unmodified lines
11		11
12	static struct counter base_hits;	12	static struct counter base_hits;
13		13
14	static void trigger_validate()	14	static void trigger_validate(void)
15	{	15	{
16	if (env.consumer_cnt != 1) {	16	if (env.consumer_cnt != 1) {
17	fprintf(stderr, "benchmark doesn't support multi-consumer!\n");	17	fprintf(stderr, "benchmark doesn't support multi-consumer!\n");
@@ -45,7 +45,7 @@ static void trigger_measure(struct bench_res *res) · 27 unmodified lines
45	res->hits = atomic_swap(&ctx.skel->bss->hits, 0);	45	res->hits = atomic_swap(&ctx.skel->bss->hits, 0);
46	}	46	}
47		47
48	static void setup_ctx()	48	static void setup_ctx(void)
49	{	49	{
50	setup_libbpf();	50	setup_libbpf();
51		51
@@ -67,37 +67,37 @@ static void attach_bpf(struct bpf_program *prog) · 15 unmodified lines
67	}	67	}
68	}	68	}
69		69
70	static void trigger_tp_setup()	70	static void trigger_tp_setup(void)
71	{	71	{
72	setup_ctx();	72	setup_ctx();
73	attach_bpf(ctx.skel->progs.bench_trigger_tp);	73	attach_bpf(ctx.skel->progs.bench_trigger_tp);
74	}	74	}
75		75
76	static void trigger_rawtp_setup()	76	static void trigger_rawtp_setup(void)
77	{	77	{
78	setup_ctx();	78	setup_ctx();
79	attach_bpf(ctx.skel->progs.bench_trigger_raw_tp);	79	attach_bpf(ctx.skel->progs.bench_trigger_raw_tp);
80	}	80	}
81		81
82	static void trigger_kprobe_setup()	82	static void trigger_kprobe_setup(void)
83	{	83	{
84	setup_ctx();	84	setup_ctx();
85	attach_bpf(ctx.skel->progs.bench_trigger_kprobe);	85	attach_bpf(ctx.skel->progs.bench_trigger_kprobe);
86	}	86	}
87		87
88	static void trigger_fentry_setup()	88	static void trigger_fentry_setup(void)
89	{	89	{
90	setup_ctx();	90	setup_ctx();
91	attach_bpf(ctx.skel->progs.bench_trigger_fentry);	91	attach_bpf(ctx.skel->progs.bench_trigger_fentry);
92	}	92	}
93		93
94	static void trigger_fentry_sleep_setup()	94	static void trigger_fentry_sleep_setup(void)
95	{	95	{
96	setup_ctx();	96	setup_ctx();
97	attach_bpf(ctx.skel->progs.bench_trigger_fentry_sleep);	97	attach_bpf(ctx.skel->progs.bench_trigger_fentry_sleep);
98	}	98	}
99		99
100	static void trigger_fmodret_setup()	100	static void trigger_fmodret_setup(void)
101	{	101	{
102	setup_ctx();	102	setup_ctx();
103	attach_bpf(ctx.skel->progs.bench_trigger_fmodret);	103	attach_bpf(ctx.skel->progs.bench_trigger_fmodret);
@@ -183,22 +183,22 @@ static void usetup(bool use_retprobe, bool use_nop) · 79 unmodified lines
183	ctx.skel->links.bench_trigger_uprobe = link;	183	ctx.skel->links.bench_trigger_uprobe = link;
184	}	184	}
185		185
186	static void uprobe_setup_with_nop()	186	static void uprobe_setup_with_nop(void)
187	{	187	{
188	usetup(false, true);	188	usetup(false, true);
189	}	189	}
190		190
191	static void uretprobe_setup_with_nop()	191	static void uretprobe_setup_with_nop(void)
192	{	192	{
193	usetup(true, true);	193	usetup(true, true);
194	}	194	}
195		195
196	static void uprobe_setup_without_nop()	196	static void uprobe_setup_without_nop(void)
197	{	197	{
198	usetup(false, false);	198	usetup(false, false);
199	}	199	}
200		200
201	static void uretprobe_setup_without_nop()	201	static void uretprobe_setup_without_nop(void)
202	{	202	{
203	usetup(true, false);	203	usetup(true, false);
204	}	204	}

tools/testing/selftests/bpf/benchs/run_bench_strncmp.sh+12−0

@@ -0,0 +1,12 @@
	1	#!/bin/bash
	2	# SPDX-License-Identifier: GPL-2.0
	3
	4	source ./benchs/run_common.sh
	5
	6	set -eufo pipefail
	7
	8	for s in 1 8 64 512 2048 4095; do
	9	for b in no-helper helper; do
	10	summarize ${b}-${s} "$($RUN_BENCH --cmp-str-len=$s strncmp-${b})"
	11	done
	12	done

tools/testing/selftests/bpf/config+2−0

 CONFIG_BPF_JIT=y
 CONFIG_BPF_LSM=y
 CONFIG_SECURITY=y
+CONFIG_RC_CORE=y
 CONFIG_LIRC=y
+CONFIG_BPF_LIRC_MODE2=y
 CONFIG_IMA=y
 CONFIG_SECURITYFS=y
 CONFIG_IMA_WRITE_POLICY=y

tools/testing/selftests/bpf/prog_tests/align.c+103−88

 		},
 		.prog_type = BPF_PROG_TYPE_SCHED_CLS,
 		.matches = {
-			{1, "R1=ctx(id=0,off=0,imm=0)"},
+			{0, "R1=ctx(id=0,off=0,imm=0)"},
-			{1, "R10=fp0"},
+			{0, "R10=fp0"},
-			{1, "R3_w=inv2"},
+			{0, "R3_w=inv2"},
-			{2, "R3_w=inv4"},
+			{1, "R3_w=inv4"},
-			{3, "R3_w=inv8"},
+			{2, "R3_w=inv8"},
-			{4, "R3_w=inv16"},
+			{3, "R3_w=inv16"},
-			{5, "R3_w=inv32"},
+			{4, "R3_w=inv32"},
 		},
 	},
 	{
 		},
 		.prog_type = BPF_PROG_TYPE_SCHED_CLS,
 		.matches = {
-			{1, "R1=ctx(id=0,off=0,imm=0)"},
+			{0, "R1=ctx(id=0,off=0,imm=0)"},
-			{1, "R10=fp0"},
+			{0, "R10=fp0"},
-			{1, "R3_w=inv1"},
+			{0, "R3_w=inv1"},
-			{2, "R3_w=inv2"},
+			{1, "R3_w=inv2"},
-			{3, "R3_w=inv4"},
+			{2, "R3_w=inv4"},
-			{4, "R3_w=inv8"},
+			{3, "R3_w=inv8"},
-			{5, "R3_w=inv16"},
+			{4, "R3_w=inv16"},
-			{6, "R3_w=inv1"},
+			{5, "R3_w=inv1"},
-			{7, "R4_w=inv32"},
+			{6, "R4_w=inv32"},
-			{8, "R4_w=inv16"},
+			{7, "R4_w=inv16"},
-			{9, "R4_w=inv8"},
+			{8, "R4_w=inv8"},
-			{10, "R4_w=inv4"},
+			{9, "R4_w=inv4"},
-			{11, "R4_w=inv2"},
+			{10, "R4_w=inv2"},
 		},
 	},
 	{
 		},
 		.prog_type = BPF_PROG_TYPE_SCHED_CLS,
 		.matches = {
-			{1, "R1=ctx(id=0,off=0,imm=0)"},
+			{0, "R1=ctx(id=0,off=0,imm=0)"},
-			{1, "R10=fp0"},
+			{0, "R10=fp0"},
-			{1, "R3_w=inv4"},
+			{0, "R3_w=inv4"},
-			{2, "R3_w=inv8"},
+			{1, "R3_w=inv8"},
-			{3, "R3_w=inv10"},
+			{2, "R3_w=inv10"},
-			{4, "R4_w=inv8"},
+			{3, "R4_w=inv8"},
-			{5, "R4_w=inv12"},
+			{4, "R4_w=inv12"},
-			{6, "R4_w=inv14"},
+			{5, "R4_w=inv14"},
 		},
 	},
 	{
 		},
 		.prog_type = BPF_PROG_TYPE_SCHED_CLS,
 		.matches = {
-			{1, "R1=ctx(id=0,off=0,imm=0)"},
+			{0, "R1=ctx(id=0,off=0,imm=0)"},
-			{1, "R10=fp0"},
+			{0, "R10=fp0"},
+			{0, "R3_w=inv7"},
 			{1, "R3_w=inv7"},
-			{2, "R3_w=inv7"},
+			{2, "R3_w=inv14"},
-			{3, "R3_w=inv14"},
+			{3, "R3_w=inv56"},
-			{4, "R3_w=inv56"},
 		},
 	},
 		},
 		.prog_type = BPF_PROG_TYPE_SCHED_CLS,
 		.matches = {
-			{7, "R0_w=pkt(id=0,off=8,r=8,imm=0)"},
+			{6, "R0_w=pkt(id=0,off=8,r=8,imm=0)"},
-			{7, "R3_w=inv(id=0,umax_value=255,var_off=(0x0; 0xff))"},
+			{6, "R3_w=inv(id=0,umax_value=255,var_off=(0x0; 0xff))"},
-			{8, "R3_w=inv(id=0,umax_value=510,var_off=(0x0; 0x1fe))"},
+			{7, "R3_w=inv(id=0,umax_value=510,var_off=(0x0; 0x1fe))"},
-			{9, "R3_w=inv(id=0,umax_value=1020,var_off=(0x0; 0x3fc))"},
+			{8, "R3_w=inv(id=0,umax_value=1020,var_off=(0x0; 0x3fc))"},
-			{10, "R3_w=inv(id=0,umax_value=2040,var_off=(0x0; 0x7f8))"},
+			{9, "R3_w=inv(id=0,umax_value=2040,var_off=(0x0; 0x7f8))"},
-			{11, "R3_w=inv(id=0,umax_value=4080,var_off=(0x0; 0xff0))"},
+			{10, "R3_w=inv(id=0,umax_value=4080,var_off=(0x0; 0xff0))"},
-			{18, "R3=pkt_end(id=0,off=0,imm=0)"},
+			{12, "R3_w=pkt_end(id=0,off=0,imm=0)"},
-			{18, "R4_w=inv(id=0,umax_value=255,var_off=(0x0; 0xff))"},
+			{17, "R4_w=inv(id=0,umax_value=255,var_off=(0x0; 0xff))"},
-			{19, "R4_w=inv(id=0,umax_value=8160,var_off=(0x0; 0x1fe0))"},
+			{18, "R4_w=inv(id=0,umax_value=8160,var_off=(0x0; 0x1fe0))"},
-			{20, "R4_w=inv(id=0,umax_value=4080,var_off=(0x0; 0xff0))"},
+			{19, "R4_w=inv(id=0,umax_value=4080,var_off=(0x0; 0xff0))"},
-			{21, "R4_w=inv(id=0,umax_value=2040,var_off=(0x0; 0x7f8))"},
+			{20, "R4_w=inv(id=0,umax_value=2040,var_off=(0x0; 0x7f8))"},
-			{22, "R4_w=inv(id=0,umax_value=1020,var_off=(0x0; 0x3fc))"},
+			{21, "R4_w=inv(id=0,umax_value=1020,var_off=(0x0; 0x3fc))"},
-			{23, "R4_w=inv(id=0,umax_value=510,var_off=(0x0; 0x1fe))"},
+			{22, "R4_w=inv(id=0,umax_value=510,var_off=(0x0; 0x1fe))"},
 		},
 	},
 	{
 		},
 		.prog_type = BPF_PROG_TYPE_SCHED_CLS,
 		.matches = {
-			{7, "R3_w=inv(id=0,umax_value=255,var_off=(0x0; 0xff))"},
+			{6, "R3_w=inv(id=0,umax_value=255,var_off=(0x0; 0xff))"},
-			{8, "R4_w=inv(id=1,umax_value=255,var_off=(0x0; 0xff))"},
+			{7, "R4_w=inv(id=1,umax_value=255,var_off=(0x0; 0xff))"},
-			{9, "R4_w=inv(id=0,umax_value=255,var_off=(0x0; 0xff))"},
+			{8, "R4_w=inv(id=0,umax_value=255,var_off=(0x0; 0xff))"},
-			{10, "R4_w=inv(id=1,umax_value=255,var_off=(0x0; 0xff))"},
+			{9, "R4_w=inv(id=1,umax_value=255,var_off=(0x0; 0xff))"},
-			{11, "R4_w=inv(id=0,umax_value=510,var_off=(0x0; 0x1fe))"},
+			{10, "R4_w=inv(id=0,umax_value=510,var_off=(0x0; 0x1fe))"},
-			{12, "R4_w=inv(id=1,umax_value=255,var_off=(0x0; 0xff))"},
+			{11, "R4_w=inv(id=1,umax_value=255,var_off=(0x0; 0xff))"},
-			{13, "R4_w=inv(id=0,umax_value=1020,var_off=(0x0; 0x3fc))"},
+			{12, "R4_w=inv(id=0,umax_value=1020,var_off=(0x0; 0x3fc))"},
-			{14, "R4_w=inv(id=1,umax_value=255,var_off=(0x0; 0xff))"},
+			{13, "R4_w=inv(id=1,umax_value=255,var_off=(0x0; 0xff))"},
-			{15, "R4_w=inv(id=0,umax_value=2040,var_off=(0x0; 0x7f8))"},
+			{14, "R4_w=inv(id=0,umax_value=2040,var_off=(0x0; 0x7f8))"},
-			{16, "R4_w=inv(id=0,umax_value=4080,var_off=(0x0; 0xff0))"},
+			{15, "R4_w=inv(id=0,umax_value=4080,var_off=(0x0; 0xff0))"},
 		},
 	},
 	{
 		},
 		.prog_type = BPF_PROG_TYPE_SCHED_CLS,
 		.matches = {
-			{4, "R5_w=pkt(id=0,off=0,r=0,imm=0)"},
+			{2, "R5_w=pkt(id=0,off=0,r=0,imm=0)"},
-			{5, "R5_w=pkt(id=0,off=14,r=0,imm=0)"},
+			{4, "R5_w=pkt(id=0,off=14,r=0,imm=0)"},
-			{6, "R4_w=pkt(id=0,off=14,r=0,imm=0)"},
+			{5, "R4_w=pkt(id=0,off=14,r=0,imm=0)"},
-			{10, "R2=pkt(id=0,off=0,r=18,imm=0)"},
+			{9, "R2=pkt(id=0,off=0,r=18,imm=0)"},
 			{10, "R5=pkt(id=0,off=14,r=18,imm=0)"},
 			{10, "R4_w=inv(id=0,umax_value=255,var_off=(0x0; 0xff))"},
+			{13, "R4_w=inv(id=0,umax_value=65535,var_off=(0x0; 0xffff))"},
 			{14, "R4_w=inv(id=0,umax_value=65535,var_off=(0x0; 0xffff))"},
-			{15, "R4_w=inv(id=0,umax_value=65535,var_off=(0x0; 0xffff))"},
 		},
 	},
 	{
 			/* Calculated offset in R6 has unknown value, but known
 			 * alignment of 4.
 			 */
-			{8, "R2_w=pkt(id=0,off=0,r=8,imm=0)"},
+			{6, "R2_w=pkt(id=0,off=0,r=8,imm=0)"},
-			{8, "R6_w=inv(id=0,umax_value=1020,var_off=(0x0; 0x3fc))"},
+			{7, "R6_w=inv(id=0,umax_value=1020,var_off=(0x0; 0x3fc))"},
 			/* Offset is added to packet pointer R5, resulting in
 			 * known fixed offset, and variable offset from R6.
 			 */
 			/* Variable offset is added to R5 packet pointer,
 			 * resulting in auxiliary alignment of 4.
 			 */
-			{18, "R5_w=pkt(id=2,off=0,r=0,umax_value=1020,var_off=(0x0; 0x3fc))"},
+			{17, "R5_w=pkt(id=2,off=0,r=0,umax_value=1020,var_off=(0x0; 0x3fc))"},
 			/* Constant offset is added to R5, resulting in
 			 * reg->off of 14.
 			 */
-			{19, "R5_w=pkt(id=2,off=14,r=0,umax_value=1020,var_off=(0x0; 0x3fc))"},
+			{18, "R5_w=pkt(id=2,off=14,r=0,umax_value=1020,var_off=(0x0; 0x3fc))"},
 			/* At the time the word size load is performed from R5,
 			 * its total fixed offset is NET_IP_ALIGN + reg->off
 			 * (14) which is 16.  Then the variable offset is 4-byte
 			/* Constant offset is added to R5 packet pointer,
 			 * resulting in reg->off value of 14.
 			 */
-			{26, "R5_w=pkt(id=0,off=14,r=8"},
+			{25, "R5_w=pkt(id=0,off=14,r=8"},
 			/* Variable offset is added to R5, resulting in a
 			 * variable offset of (4n).
 			 */
-			{27, "R5_w=pkt(id=3,off=14,r=0,umax_value=1020,var_off=(0x0; 0x3fc))"},
+			{26, "R5_w=pkt(id=3,off=14,r=0,umax_value=1020,var_off=(0x0; 0x3fc))"},
 			/* Constant is added to R5 again, setting reg->off to 18. */
-			{28, "R5_w=pkt(id=3,off=18,r=0,umax_value=1020,var_off=(0x0; 0x3fc))"},
+			{27, "R5_w=pkt(id=3,off=18,r=0,umax_value=1020,var_off=(0x0; 0x3fc))"},
 			/* And once more we add a variable; resulting var_off
 			 * is still (4n), fixed offset is not changed.
 			 * Also, we create a new reg->id.
 			 */
-			{29, "R5_w=pkt(id=4,off=18,r=0,umax_value=2040,var_off=(0x0; 0x7fc)"},
+			{28, "R5_w=pkt(id=4,off=18,r=0,umax_value=2040,var_off=(0x0; 0x7fc)"},
 			/* At the time the word size load is performed from R5,
 			 * its total fixed offset is NET_IP_ALIGN + reg->off (18)
 			 * which is 20.  Then the variable offset is (4n), so
 			/* Calculated offset in R6 has unknown value, but known
 			 * alignment of 4.
 			 */
-			{8, "R2_w=pkt(id=0,off=0,r=8,imm=0)"},
+			{6, "R2_w=pkt(id=0,off=0,r=8,imm=0)"},
-			{8, "R6_w=inv(id=0,umax_value=1020,var_off=(0x0; 0x3fc))"},
+			{7, "R6_w=inv(id=0,umax_value=1020,var_off=(0x0; 0x3fc))"},
 			/* Adding 14 makes R6 be (4n+2) */
-			{9, "R6_w=inv(id=0,umin_value=14,umax_value=1034,var_off=(0x2; 0x7fc))"},
+			{8, "R6_w=inv(id=0,umin_value=14,umax_value=1034,var_off=(0x2; 0x7fc))"},
 			/* Packet pointer has (4n+2) offset */
 			{11, "R5_w=pkt(id=1,off=0,r=0,umin_value=14,umax_value=1034,var_off=(0x2; 0x7fc)"},
-			{13, "R4=pkt(id=1,off=4,r=0,umin_value=14,umax_value=1034,var_off=(0x2; 0x7fc)"},
+			{12, "R4=pkt(id=1,off=4,r=0,umin_value=14,umax_value=1034,var_off=(0x2; 0x7fc)"},
 			/* At the time the word size load is performed from R5,
 			 * its total fixed offset is NET_IP_ALIGN + reg->off (0)
 			 * which is 2.  Then the variable offset is (4n+2), so
 			/* Newly read value in R6 was shifted left by 2, so has
 			 * known alignment of 4.
 			 */
-			{18, "R6_w=inv(id=0,umax_value=1020,var_off=(0x0; 0x3fc))"},
+			{17, "R6_w=inv(id=0,umax_value=1020,var_off=(0x0; 0x3fc))"},
 			/* Added (4n) to packet pointer's (4n+2) var_off, giving
 			 * another (4n+2).
 			 */
 			{19, "R5_w=pkt(id=2,off=0,r=0,umin_value=14,umax_value=2054,var_off=(0x2; 0xffc)"},
-			{21, "R4=pkt(id=2,off=4,r=0,umin_value=14,umax_value=2054,var_off=(0x2; 0xffc)"},
+			{20, "R4=pkt(id=2,off=4,r=0,umin_value=14,umax_value=2054,var_off=(0x2; 0xffc)"},
 			/* At the time the word size load is performed from R5,
 			 * its total fixed offset is NET_IP_ALIGN + reg->off (0)
 			 * which is 2.  Then the variable offset is (4n+2), so
 		.prog_type = BPF_PROG_TYPE_SCHED_CLS,
 		.result = REJECT,
 		.matches = {
-			{4, "R5_w=pkt_end(id=0,off=0,imm=0)"},
+			{3, "R5_w=pkt_end(id=0,off=0,imm=0)"},
 			/* (ptr - ptr) << 2 == unknown, (4n) */
-			{6, "R5_w=inv(id=0,smax_value=9223372036854775804,umax_value=18446744073709551612,var_off=(0x0; 0xfffffffffffffffc)"},
+			{5, "R5_w=inv(id=0,smax_value=9223372036854775804,umax_value=18446744073709551612,var_off=(0x0; 0xfffffffffffffffc)"},
 			/* (4n) + 14 == (4n+2).  We blow our bounds, because
 			 * the add could overflow.
 			 */
-			{7, "R5_w=inv(id=0,smin_value=-9223372036854775806,smax_value=9223372036854775806,umin_value=2,umax_value=18446744073709551614,var_off=(0x2; 0xfffffffffffffffc)"},
+			{6, "R5_w=inv(id=0,smin_value=-9223372036854775806,smax_value=9223372036854775806,umin_value=2,umax_value=18446744073709551614,var_off=(0x2; 0xfffffffffffffffc)"},
 			/* Checked s>=0 */
 			{9, "R5=inv(id=0,umin_value=2,umax_value=9223372036854775806,var_off=(0x2; 0x7ffffffffffffffc)"},
 			/* packet pointer + nonnegative (4n+2) */
 			{11, "R6_w=pkt(id=1,off=0,r=0,umin_value=2,umax_value=9223372036854775806,var_off=(0x2; 0x7ffffffffffffffc)"},
-			{13, "R4_w=pkt(id=1,off=4,r=0,umin_value=2,umax_value=9223372036854775806,var_off=(0x2; 0x7ffffffffffffffc)"},
+			{12, "R4_w=pkt(id=1,off=4,r=0,umin_value=2,umax_value=9223372036854775806,var_off=(0x2; 0x7ffffffffffffffc)"},
 			/* NET_IP_ALIGN + (4n+2) == (4n), alignment is fine.
 			 * We checked the bounds, but it might have been able
 			 * to overflow if the packet pointer started in the
 			/* Calculated offset in R6 has unknown value, but known
 			 * alignment of 4.
 			 */
-			{7, "R2_w=pkt(id=0,off=0,r=8,imm=0)"},
+			{6, "R2_w=pkt(id=0,off=0,r=8,imm=0)"},
-			{9, "R6_w=inv(id=0,umax_value=1020,var_off=(0x0; 0x3fc))"},
+			{8, "R6_w=inv(id=0,umax_value=1020,var_off=(0x0; 0x3fc))"},
 			/* Adding 14 makes R6 be (4n+2) */
-			{10, "R6_w=inv(id=0,umin_value=14,umax_value=1034,var_off=(0x2; 0x7fc))"},
+			{9, "R6_w=inv(id=0,umin_value=14,umax_value=1034,var_off=(0x2; 0x7fc))"},
 			/* New unknown value in R7 is (4n) */
-			{11, "R7_w=inv(id=0,umax_value=1020,var_off=(0x0; 0x3fc))"},
+			{10, "R7_w=inv(id=0,umax_value=1020,var_off=(0x0; 0x3fc))"},
 			/* Subtracting it from R6 blows our unsigned bounds */
-			{12, "R6=inv(id=0,smin_value=-1006,smax_value=1034,umin_value=2,umax_value=18446744073709551614,var_off=(0x2; 0xfffffffffffffffc)"},
+			{11, "R6=inv(id=0,smin_value=-1006,smax_value=1034,umin_value=2,umax_value=18446744073709551614,var_off=(0x2; 0xfffffffffffffffc)"},
 			/* Checked s>= 0 */
 			{14, "R6=inv(id=0,umin_value=2,umax_value=1034,var_off=(0x2; 0x7fc))"},
 			/* At the time the word size load is performed from R5,
 			/* Calculated offset in R6 has unknown value, but known
 			 * alignment of 4.
 			 */
-			{7, "R2_w=pkt(id=0,off=0,r=8,imm=0)"},
+			{6, "R2_w=pkt(id=0,off=0,r=8,imm=0)"},
-			{10, "R6_w=inv(id=0,umax_value=60,var_off=(0x0; 0x3c))"},
+			{9, "R6_w=inv(id=0,umax_value=60,var_off=(0x0; 0x3c))"},
 			/* Adding 14 makes R6 be (4n+2) */
-			{11, "R6_w=inv(id=0,umin_value=14,umax_value=74,var_off=(0x2; 0x7c))"},
+			{10, "R6_w=inv(id=0,umin_value=14,umax_value=74,var_off=(0x2; 0x7c))"},
 			/* Subtracting from packet pointer overflows ubounds */
 			{13, "R5_w=pkt(id=2,off=0,r=8,umin_value=18446744073709551542,umax_value=18446744073709551602,var_off=(0xffffffffffffff82; 0x7c)"},
 			/* New unknown value in R7 is (4n), >= 76 */
-			{15, "R7_w=inv(id=0,umin_value=76,umax_value=1096,var_off=(0x0; 0x7fc))"},
+			{14, "R7_w=inv(id=0,umin_value=76,umax_value=1096,var_off=(0x0; 0x7fc))"},
 			/* Adding it to packet pointer gives nice bounds again */
 			{16, "R5_w=pkt(id=3,off=0,r=0,umin_value=2,umax_value=1082,var_off=(0x2; 0xfffffffc)"},
 			/* At the time the word size load is performed from R5,
 		line_ptr = strtok(bpf_vlog_copy, "\n");
 		for (i = 0; i < MAX_MATCHES; i++) {
 			struct bpf_reg_match m = test->matches[i];
+			int tmp;
 			if (!m.match)
 				break;
 			while (line_ptr) {
 				cur_line = -1;
 				sscanf(line_ptr, "%u: ", &cur_line);
+				if (cur_line == -1)
+					sscanf(line_ptr, "from %u to %u: ", &tmp, &cur_line);
 				if (cur_line == m.line)
 					break;
 				line_ptr = strtok(NULL, "\n");
 				printf("%s", bpf_vlog);
 				break;
 			}
+			/* Check the next line as well in case the previous line
+			 * did not have a corresponding bpf insn. Example:
+			 * func#0 @0
+			 * 0: R1=ctx(id=0,off=0,imm=0) R10=fp0
+			 * 0: (b7) r3 = 2                 ; R3_w=inv2
+			 */
 			if (!strstr(line_ptr, m.match)) {
+				cur_line = -1;
+				line_ptr = strtok(NULL, "\n");
+				sscanf(line_ptr, "%u: ", &cur_line);
+			}
+			if (cur_line != m.line || !line_ptr ||
+			    !strstr(line_ptr, m.match)) {
 				printf("Failed to find match %u: %s\n",
 				       m.line, m.match);
 				ret = 1;

tools/testing/selftests/bpf/prog_tests/bpf_obj_id.c+2−2

@@ -65,8 +65,8 @@ void serial_test_bpf_obj_id(void) · 64 unmodified lines
65	if (CHECK_FAIL(err))	65	if (CHECK_FAIL(err))
66	goto done;	66	goto done;
67		67
68	prog = bpf_object__find_program_by_title(objs[i],	68	prog = bpf_object__find_program_by_name(objs[i],
69	"raw_tp/sys_enter");	69	"test_obj_id");
70	if (CHECK_FAIL(!prog))	70	if (CHECK_FAIL(!prog))
71	goto done;	71	goto done;
72	links[i] = bpf_program__attach(prog);	72	links[i] = bpf_program__attach(prog);

tools/testing/selftests/bpf/prog_tests/bpf_tcp_ca.c+3−4

 static int libbpf_debug_print(enum libbpf_print_level level,
 			      const char *format, va_list args)
 {
-	const char *log_buf;
+	const char *prog_name, *log_buf;
 	if (level != LIBBPF_WARN ||
 	    !strstr(format, "-- BEGIN PROG LOAD LOG --")) {
 		return 0;
 	}
-	/* skip prog_name */
+	prog_name = va_arg(args, char *);
-	va_arg(args, char *);
 	log_buf = va_arg(args, char *);
 	if (!log_buf)
 		goto out;
 	if (err_str && strstr(log_buf, err_str) != NULL)
 		found = true;
 out:
-	printf(format, log_buf);
+	printf(format, prog_name, log_buf);
 	return 0;
 }

tools/testing/selftests/bpf/prog_tests/btf.c+0−1

@@ -22,7 +22,6 @@ · 21 unmodified lines
22	#include <bpf/libbpf.h>	22	#include <bpf/libbpf.h>
23	#include <bpf/btf.h>	23	#include <bpf/btf.h>
24		24
25	#include "bpf_rlimit.h"
26	#include "bpf_util.h"	25	#include "bpf_util.h"
27	#include "../test_btf.h"	26	#include "../test_btf.h"
28	#include "test_progs.h"	27	#include "test_progs.h"

tools/testing/selftests/bpf/prog_tests/connect_force_port.c+9−9

@@ -67,9 +67,9 @@ static int run_test(int cgroup_fd, int server_fd, int family, int type) · 66 unmodified lines
67	goto close_bpf_object;	67	goto close_bpf_object;
68	}	68	}
69		69
70	prog = bpf_object__find_program_by_title(obj, v4 ?	70	prog = bpf_object__find_program_by_name(obj, v4 ?
71	"cgroup/connect4" :	71	"connect4" :
72	"cgroup/connect6");	72	"connect6");
73	if (CHECK(!prog, "find_prog", "connect prog not found\n")) {	73	if (CHECK(!prog, "find_prog", "connect prog not found\n")) {
74	err = -EIO;	74	err = -EIO;
75	goto close_bpf_object;	75	goto close_bpf_object;
@@ -83,9 +83,9 @@ static int run_test(int cgroup_fd, int server_fd, int family, int type) · 7 unmodified lines
83	goto close_bpf_object;	83	goto close_bpf_object;
84	}	84	}
85		85
86	prog = bpf_object__find_program_by_title(obj, v4 ?	86	prog = bpf_object__find_program_by_name(obj, v4 ?
87	"cgroup/getpeername4" :	87	"getpeername4" :
88	"cgroup/getpeername6");	88	"getpeername6");
89	if (CHECK(!prog, "find_prog", "getpeername prog not found\n")) {	89	if (CHECK(!prog, "find_prog", "getpeername prog not found\n")) {
90	err = -EIO;	90	err = -EIO;
91	goto close_bpf_object;	91	goto close_bpf_object;
@@ -99,9 +99,9 @@ static int run_test(int cgroup_fd, int server_fd, int family, int type) · 7 unmodified lines
99	goto close_bpf_object;	99	goto close_bpf_object;
100	}	100	}
101		101
102	prog = bpf_object__find_program_by_title(obj, v4 ?	102	prog = bpf_object__find_program_by_name(obj, v4 ?
103	"cgroup/getsockname4" :	103	"getsockname4" :
104	"cgroup/getsockname6");	104	"getsockname6");
105	if (CHECK(!prog, "find_prog", "getsockname prog not found\n")) {	105	if (CHECK(!prog, "find_prog", "getsockname prog not found\n")) {
106	err = -EIO;	106	err = -EIO;
107	goto close_bpf_object;	107	goto close_bpf_object;

tools/testing/selftests/bpf/prog_tests/core_reloc.c+53−26

 #define STRUCT_TO_CHAR_PTR(struct_name) (const char *)&(struct struct_name)
-#define MODULES_CASE(name, sec_name, tp_name) {				\
+#define MODULES_CASE(name, pg_name, tp_name) {				\
 	.case_name = name,						\
 	.bpf_obj_file = "test_core_reloc_module.o",			\
 	.btf_src_file = NULL, /* find in kernel module BTFs */		\
 		.comm_len = sizeof("test_progs"),			\
 	},								\
 	.output_len = sizeof(struct core_reloc_module_output),		\
-	.prog_sec_name = sec_name,					\
+	.prog_name = pg_name,						\
 	.raw_tp_name = tp_name,						\
 	.trigger = __trigger_module_test_read,				\
 	.needs_testmod = true,						\
 #define FLAVORS_CASE_COMMON(name)					\
 	.case_name = #name,						\
 	.bpf_obj_file = "test_core_reloc_flavors.o",			\
-	.btf_src_file = "btf__core_reloc_" #name ".o"			\
+	.btf_src_file = "btf__core_reloc_" #name ".o",			\
+	.raw_tp_name = "sys_enter",					\
+	.prog_name = "test_core_flavors"				\
 #define FLAVORS_CASE(name) {						\
 	FLAVORS_CASE_COMMON(name),					\
 #define NESTING_CASE_COMMON(name)					\
 	.case_name = #name,						\
 	.bpf_obj_file = "test_core_reloc_nesting.o",			\
-	.btf_src_file = "btf__core_reloc_" #name ".o"
+	.btf_src_file = "btf__core_reloc_" #name ".o",			\
+	.raw_tp_name = "sys_enter",					\
+	.prog_name = "test_core_nesting"				\
 #define NESTING_CASE(name) {						\
 	NESTING_CASE_COMMON(name),					\
 #define ARRAYS_CASE_COMMON(name)					\
 	.case_name = #name,						\
 	.bpf_obj_file = "test_core_reloc_arrays.o",			\
-	.btf_src_file = "btf__core_reloc_" #name ".o"
+	.btf_src_file = "btf__core_reloc_" #name ".o",			\
+	.raw_tp_name = "sys_enter",					\
+	.prog_name = "test_core_arrays"					\
 #define ARRAYS_CASE(name) {						\
 	ARRAYS_CASE_COMMON(name),					\
 #define PRIMITIVES_CASE_COMMON(name)					\
 	.case_name = #name,						\
 	.bpf_obj_file = "test_core_reloc_primitives.o",			\
-	.btf_src_file = "btf__core_reloc_" #name ".o"
+	.btf_src_file = "btf__core_reloc_" #name ".o",			\
+	.raw_tp_name = "sys_enter",					\
+	.prog_name = "test_core_primitives"				\
 #define PRIMITIVES_CASE(name) {						\
 	PRIMITIVES_CASE_COMMON(name),					\
 		.e = 5, .f = 6, .g = 7, .h = 8,				\
 	},								\
 	.output_len = sizeof(struct core_reloc_mods_output),		\
+	.raw_tp_name = "sys_enter",					\
+	.prog_name = "test_core_mods",					\
 }
 #define PTR_AS_ARR_CASE(name) {						\
 		.a = 3,							\
 	},								\
 	.output_len = sizeof(struct core_reloc_ptr_as_arr),		\
+	.raw_tp_name = "sys_enter",					\
+	.prog_name = "test_core_ptr_as_arr",				\
 }
 #define INTS_DATA(struct_name) STRUCT_TO_CHAR_PTR(struct_name) {	\
 #define INTS_CASE_COMMON(name)						\
 	.case_name = #name,						\
 	.bpf_obj_file = "test_core_reloc_ints.o",			\
-	.btf_src_file = "btf__core_reloc_" #name ".o"
+	.btf_src_file = "btf__core_reloc_" #name ".o",			\
+	.raw_tp_name = "sys_enter",					\
+	.prog_name = "test_core_ints"
 #define INTS_CASE(name) {						\
 	INTS_CASE_COMMON(name),						\
 #define FIELD_EXISTS_CASE_COMMON(name)					\
 	.case_name = #name,						\
 	.bpf_obj_file = "test_core_reloc_existence.o",			\
-	.btf_src_file = "btf__core_reloc_" #name ".o"			\
+	.btf_src_file = "btf__core_reloc_" #name ".o",			\
+	.raw_tp_name = "sys_enter",					\
+	.prog_name = "test_core_existence"
 #define BITFIELDS_CASE_COMMON(objfile, test_name_prefix,  name)		\
 	.case_name = test_name_prefix#name,				\
 	.output = STRUCT_TO_CHAR_PTR(core_reloc_bitfields_output)	\
 		__VA_ARGS__,						\
 	.output_len = sizeof(struct core_reloc_bitfields_output),	\
+	.raw_tp_name = "sys_enter",					\
+	.prog_name = "test_core_bitfields",				\
 }, {									\
 	BITFIELDS_CASE_COMMON("test_core_reloc_bitfields_direct.o",	\
 			      "direct:", name),				\
 	.output = STRUCT_TO_CHAR_PTR(core_reloc_bitfields_output)	\
 		__VA_ARGS__,						\
 	.output_len = sizeof(struct core_reloc_bitfields_output),	\
-	.prog_sec_name = "tp_btf/sys_enter",				\
+	.prog_name = "test_core_bitfields_direct",			\
 }
 	BITFIELDS_CASE_COMMON("test_core_reloc_bitfields_probed.o",	\
 			      "probed:", name),				\
 	.fails = true,							\
+	.raw_tp_name = "sys_enter",					\
+	.prog_name = "test_core_bitfields",				\
 }, {									\
 	BITFIELDS_CASE_COMMON("test_core_reloc_bitfields_direct.o",	\
 			      "direct:", name),				\
-	.prog_sec_name = "tp_btf/sys_enter",				\
 	.fails = true,							\
+	.prog_name = "test_core_bitfields_direct",			\
 }
 #define SIZE_CASE_COMMON(name)						\
 	.case_name = #name,						\
 	.bpf_obj_file = "test_core_reloc_size.o",			\
-	.btf_src_file = "btf__core_reloc_" #name ".o"
+	.btf_src_file = "btf__core_reloc_" #name ".o",			\
+	.raw_tp_name = "sys_enter",					\
+	.prog_name = "test_core_size"
 #define SIZE_OUTPUT_DATA(type)						\
 	STRUCT_TO_CHAR_PTR(core_reloc_size_output) {			\
 #define TYPE_BASED_CASE_COMMON(name)					\
 	.case_name = #name,						\
-	.bpf_obj_file = "test_core_reloc_type_based.o",		\
+	.bpf_obj_file = "test_core_reloc_type_based.o",			\
-	.btf_src_file = "btf__core_reloc_" #name ".o"			\
+	.btf_src_file = "btf__core_reloc_" #name ".o",			\
+	.raw_tp_name = "sys_enter",					\
+	.prog_name = "test_core_type_based"
 #define TYPE_BASED_CASE(name, ...) {					\
 	TYPE_BASED_CASE_COMMON(name),					\
 #define TYPE_ID_CASE_COMMON(name)					\
 	.case_name = #name,						\
 	.bpf_obj_file = "test_core_reloc_type_id.o",			\
-	.btf_src_file = "btf__core_reloc_" #name ".o"			\
+	.btf_src_file = "btf__core_reloc_" #name ".o",			\
+	.raw_tp_name = "sys_enter",					\
+	.prog_name = "test_core_type_id"
 #define TYPE_ID_CASE(name, setup_fn) {					\
 	TYPE_ID_CASE_COMMON(name),					\
 #define ENUMVAL_CASE_COMMON(name)					\
 	.case_name = #name,						\
 	.bpf_obj_file = "test_core_reloc_enumval.o",			\
-	.btf_src_file = "btf__core_reloc_" #name ".o"			\
+	.btf_src_file = "btf__core_reloc_" #name ".o",			\
+	.raw_tp_name = "sys_enter",					\
+	.prog_name = "test_core_enumval"
 #define ENUMVAL_CASE(name, ...) {					\
 	ENUMVAL_CASE_COMMON(name),					\
 	bool fails;
 	bool needs_testmod;
 	bool relaxed_core_relocs;
-	const char *prog_sec_name;
+	const char *prog_name;
 	const char *raw_tp_name;
 	setup_test_fn setup;
 	trigger_test_fn trigger;
 			.comm_len = sizeof("test_progs"),
 		},
 		.output_len = sizeof(struct core_reloc_kernel_output),
+		.raw_tp_name = "sys_enter",
+		.prog_name = "test_core_kernel",
 	},
 	/* validate we can find kernel module BTF types for relocs/attach */
-	MODULES_CASE("module_probed", "raw_tp/bpf_testmod_test_read", "bpf_testmod_test_read"),
+	MODULES_CASE("module_probed", "test_core_module_probed", "bpf_testmod_test_read"),
-	MODULES_CASE("module_direct", "tp_btf/bpf_testmod_test_read", NULL),
+	MODULES_CASE("module_direct", "test_core_module_direct", NULL),
 	/* validate BPF program can use multiple flavors to match against
 	 * single target BTF type
 			.c = 0, /* BUG in clang, should be 3 */
 		},
 		.output_len = sizeof(struct core_reloc_misc_output),
+		.raw_tp_name = "sys_enter",
+		.prog_name = "test_core_misc",
 	},
 	/* validate field existence checks */
 		if (!ASSERT_OK_PTR(obj, "obj_open"))
 			goto cleanup;
-		probe_name = "raw_tracepoint/sys_enter";
+		probe_name = test_case->prog_name;
-		tp_name = "sys_enter";
+		tp_name = test_case->raw_tp_name; /* NULL for tp_btf */
-		if (test_case->prog_sec_name) {
+		prog = bpf_object__find_program_by_name(obj, probe_name);
-			probe_name = test_case->prog_sec_name;
-			tp_name = test_case->raw_tp_name; /* NULL for tp_btf */
-		}
-		prog = bpf_object__find_program_by_title(obj, probe_name);
 		if (CHECK(!prog, "find_probe",
 			  "prog '%s' not found\n", probe_name))
 			goto cleanup;

tools/testing/selftests/bpf/prog_tests/fexit_bpf2bpf.c+13−4

 	for (i = 0; i < prog_cnt; i++) {
 		struct bpf_link_info link_info;
+		struct bpf_program *pos;
+		const char *pos_sec_name;
 		char *tgt_name;
 		__s32 btf_id;
 			goto close_prog;
 		btf_id = btf__find_by_name_kind(btf, tgt_name + 1, BTF_KIND_FUNC);
-		prog[i] = bpf_object__find_program_by_title(obj, prog_name[i]);
+		prog[i] = NULL;
+		bpf_object__for_each_program(pos, obj) {
+			pos_sec_name = bpf_program__section_name(pos);
+			if (pos_sec_name && !strcmp(pos_sec_name, prog_name[i])) {
+				prog[i] = pos;
+				break;
+			}
+		}
 		if (!ASSERT_OK_PTR(prog[i], prog_name[i]))
 			goto close_prog;
 static int test_second_attach(struct bpf_object *obj)
 {
-	const char *prog_name = "freplace/get_constant";
+	const char *prog_name = "security_new_get_constant";
-	const char *tgt_name = prog_name + 9; /* cut off freplace/ */
+	const char *tgt_name = "get_constant";
 	const char *tgt_obj_file = "./test_pkt_access.o";
 	struct bpf_program *prog = NULL;
 	struct bpf_object *tgt_obj;
 	struct bpf_link *link;
 	int err = 0, tgt_fd;
-	prog = bpf_object__find_program_by_title(obj, prog_name);
+	prog = bpf_object__find_program_by_name(obj, prog_name);
 	if (CHECK(!prog, "find_prog", "prog %s not found\n", prog_name))
 		return -ENOENT;

tools/testing/selftests/bpf/prog_tests/get_func_args_test.c+44−0

@@ -0,0 +1,44 @@
	1	// SPDX-License-Identifier: GPL-2.0
	2	#include <test_progs.h>
	3	#include "get_func_args_test.skel.h"
	4
	5	void test_get_func_args_test(void)
	6	{
	7	struct get_func_args_test *skel = NULL;
	8	__u32 duration = 0, retval;
	9	int err, prog_fd;
	10
	11	skel = get_func_args_test__open_and_load();
	12	if (!ASSERT_OK_PTR(skel, "get_func_args_test__open_and_load"))
	13	return;
	14
	15	err = get_func_args_test__attach(skel);
	16	if (!ASSERT_OK(err, "get_func_args_test__attach"))
	17	goto cleanup;
	18
	19	/* This runs bpf_fentry_test* functions and triggers
	20	* fentry/fexit programs.
	21	*/
	22	prog_fd = bpf_program__fd(skel->progs.test1);
	23	err = bpf_prog_test_run(prog_fd, 1, NULL, 0,
	24	NULL, NULL, &retval, &duration);
	25	ASSERT_OK(err, "test_run");
	26	ASSERT_EQ(retval, 0, "test_run");
	27
	28	/* This runs bpf_modify_return_test function and triggers
	29	* fmod_ret_test and fexit_test programs.
	30	*/
	31	prog_fd = bpf_program__fd(skel->progs.fmod_ret_test);
	32	err = bpf_prog_test_run(prog_fd, 1, NULL, 0,
	33	NULL, NULL, &retval, &duration);
	34	ASSERT_OK(err, "test_run");
	35	ASSERT_EQ(retval, 1234, "test_run");
	36
	37	ASSERT_EQ(skel->bss->test1_result, 1, "test1_result");
	38	ASSERT_EQ(skel->bss->test2_result, 1, "test2_result");
	39	ASSERT_EQ(skel->bss->test3_result, 1, "test3_result");
	40	ASSERT_EQ(skel->bss->test4_result, 1, "test4_result");
	41
	42	cleanup:
	43	get_func_args_test__destroy(skel);
	44	}

tools/testing/selftests/bpf/prog_tests/get_stack_raw_tp.c+2−2

@@ -89,7 +89,7 @@ void test_get_stack_raw_tp(void) · 88 unmodified lines
89	{	89	{
90	const char *file = "./test_get_stack_rawtp.o";	90	const char *file = "./test_get_stack_rawtp.o";
91	const char *file_err = "./test_get_stack_rawtp_err.o";	91	const char *file_err = "./test_get_stack_rawtp_err.o";
92	const char *prog_name = "raw_tracepoint/sys_enter";	92	const char *prog_name = "bpf_prog1";
93	int i, err, prog_fd, exp_cnt = MAX_CNT_RAWTP;	93	int i, err, prog_fd, exp_cnt = MAX_CNT_RAWTP;
94	struct perf_buffer *pb = NULL;	94	struct perf_buffer *pb = NULL;
95	struct bpf_link *link = NULL;	95	struct bpf_link *link = NULL;
@@ -107,7 +107,7 @@ void test_get_stack_raw_tp(void) · 11 unmodified lines
107	if (CHECK(err, "prog_load raw tp", "err %d errno %d\n", err, errno))	107	if (CHECK(err, "prog_load raw tp", "err %d errno %d\n", err, errno))
108	return;	108	return;
109		109
110	prog = bpf_object__find_program_by_title(obj, prog_name);	110	prog = bpf_object__find_program_by_name(obj, prog_name);
111	if (CHECK(!prog, "find_probe", "prog '%s' not found\n", prog_name))	111	if (CHECK(!prog, "find_probe", "prog '%s' not found\n", prog_name))
112	goto close_prog;	112	goto close_prog;
113		113

tools/testing/selftests/bpf/prog_tests/ksyms_btf.c+14−0

 #include "test_ksyms_btf_null_check.skel.h"
 #include "test_ksyms_weak.skel.h"
 #include "test_ksyms_weak.lskel.h"
+#include "test_ksyms_btf_write_check.skel.h"
 static int duration;
 	test_ksyms_weak_lskel__destroy(skel);
 }
+static void test_write_check(void)
+{
+	struct test_ksyms_btf_write_check *skel;
+	skel = test_ksyms_btf_write_check__open_and_load();
+	ASSERT_ERR_PTR(skel, "unexpected load of a prog writing to ksym memory\n");
+	test_ksyms_btf_write_check__destroy(skel);
+}
 void test_ksyms_btf(void)
 {
 	int percpu_datasec;
 	if (test__start_subtest("weak_ksyms_lskel"))
 		test_weak_syms_lskel();
+	if (test__start_subtest("write_check"))
+		test_write_check();
 }

tools/testing/selftests/bpf/prog_tests/libbpf_probes.c+124−0

@@ -0,0 +1,124 @@
	1	/* SPDX-License-Identifier: GPL-2.0 */
	2	/* Copyright (c) 2021 Facebook */
	3
	4	#include <test_progs.h>
	5	#include <bpf/btf.h>
	6
	7	void test_libbpf_probe_prog_types(void)
	8	{
	9	struct btf *btf;
	10	const struct btf_type *t;
	11	const struct btf_enum *e;
	12	int i, n, id;
	13
	14	btf = btf__parse("/sys/kernel/btf/vmlinux", NULL);
	15	if (!ASSERT_OK_PTR(btf, "btf_parse"))
	16	return;
	17
	18	/* find enum bpf_prog_type and enumerate each value */
	19	id = btf__find_by_name_kind(btf, "bpf_prog_type", BTF_KIND_ENUM);
	20	if (!ASSERT_GT(id, 0, "bpf_prog_type_id"))
	21	goto cleanup;
	22	t = btf__type_by_id(btf, id);
	23	if (!ASSERT_OK_PTR(t, "bpf_prog_type_enum"))
	24	goto cleanup;
	25
	26	for (e = btf_enum(t), i = 0, n = btf_vlen(t); i < n; e++, i++) {
	27	const char *prog_type_name = btf__str_by_offset(btf, e->name_off);
	28	enum bpf_prog_type prog_type = (enum bpf_prog_type)e->val;
	29	int res;
	30
	31	if (prog_type == BPF_PROG_TYPE_UNSPEC)
	32	continue;
	33
	34	if (!test__start_subtest(prog_type_name))
	35	continue;
	36
	37	res = libbpf_probe_bpf_prog_type(prog_type, NULL);
	38	ASSERT_EQ(res, 1, prog_type_name);
	39	}
	40
	41	cleanup:
	42	btf__free(btf);
	43	}
	44
	45	void test_libbpf_probe_map_types(void)
	46	{
	47	struct btf *btf;
	48	const struct btf_type *t;
	49	const struct btf_enum *e;
	50	int i, n, id;
	51
	52	btf = btf__parse("/sys/kernel/btf/vmlinux", NULL);
	53	if (!ASSERT_OK_PTR(btf, "btf_parse"))
	54	return;
	55
	56	/* find enum bpf_map_type and enumerate each value */
	57	id = btf__find_by_name_kind(btf, "bpf_map_type", BTF_KIND_ENUM);
	58	if (!ASSERT_GT(id, 0, "bpf_map_type_id"))
	59	goto cleanup;
	60	t = btf__type_by_id(btf, id);
	61	if (!ASSERT_OK_PTR(t, "bpf_map_type_enum"))
	62	goto cleanup;
	63
	64	for (e = btf_enum(t), i = 0, n = btf_vlen(t); i < n; e++, i++) {
	65	const char *map_type_name = btf__str_by_offset(btf, e->name_off);
	66	enum bpf_map_type map_type = (enum bpf_map_type)e->val;
	67	int res;
	68
	69	if (map_type == BPF_MAP_TYPE_UNSPEC)
	70	continue;
	71
	72	if (!test__start_subtest(map_type_name))
	73	continue;
	74
	75	res = libbpf_probe_bpf_map_type(map_type, NULL);
	76	ASSERT_EQ(res, 1, map_type_name);
	77	}
	78
	79	cleanup:
	80	btf__free(btf);
	81	}
	82
	83	void test_libbpf_probe_helpers(void)
	84	{
	85	#define CASE(prog, helper, supp) { \
	86	.prog_type_name = "BPF_PROG_TYPE_" # prog, \
	87	.helper_name = "bpf_" # helper, \
	88	.prog_type = BPF_PROG_TYPE_ ## prog, \
	89	.helper_id = BPF_FUNC_ ## helper, \
	90	.supported = supp, \
	91	}
	92	const struct case_def {
	93	const char *prog_type_name;
	94	const char *helper_name;
	95	enum bpf_prog_type prog_type;
	96	enum bpf_func_id helper_id;
	97	bool supported;
	98	} cases[] = {
	99	CASE(KPROBE, unspec, false),
	100	CASE(KPROBE, map_lookup_elem, true),
	101	CASE(KPROBE, loop, true),
	102
	103	CASE(KPROBE, ktime_get_coarse_ns, false),
	104	CASE(SOCKET_FILTER, ktime_get_coarse_ns, true),
	105
	106	CASE(KPROBE, sys_bpf, false),
	107	CASE(SYSCALL, sys_bpf, true),
	108	};
	109	size_t case_cnt = ARRAY_SIZE(cases), i;
	110	char buf[128];
	111
	112	for (i = 0; i < case_cnt; i++) {
	113	const struct case_def *d = &cases[i];
	114	int res;
	115
	116	snprintf(buf, sizeof(buf), "%s+%s", d->prog_type_name, d->helper_name);
	117
	118	if (!test__start_subtest(buf))
	119	continue;
	120
	121	res = libbpf_probe_bpf_helper(d->prog_type, d->helper_id, NULL);
	122	ASSERT_EQ(res, d->supported, buf);
	123	}
	124	}

tools/testing/selftests/bpf/prog_tests/select_reuseport.c+0−1

@@ -18,7 +18,6 @@ · 17 unmodified lines
18	#include <netinet/in.h>	18	#include <netinet/in.h>
19	#include <bpf/bpf.h>	19	#include <bpf/bpf.h>
20	#include <bpf/libbpf.h>	20	#include <bpf/libbpf.h>
21	#include "bpf_rlimit.h"
22	#include "bpf_util.h"	21	#include "bpf_util.h"
23		22
24	#include "test_progs.h"	23	#include "test_progs.h"

tools/testing/selftests/bpf/prog_tests/sk_lookup.c+0−1

@@ -30,7 +30,6 @@ · 29 unmodified lines
30	#include <bpf/bpf.h>	30	#include <bpf/bpf.h>
31		31
32	#include "test_progs.h"	32	#include "test_progs.h"
33	#include "bpf_rlimit.h"
34	#include "bpf_util.h"	33	#include "bpf_util.h"
35	#include "cgroup_helpers.h"	34	#include "cgroup_helpers.h"
36	#include "network_helpers.h"	35	#include "network_helpers.h"

tools/testing/selftests/bpf/prog_tests/sock_fields.c+0−1

@@ -15,7 +15,6 @@ · 14 unmodified lines
15	#include "network_helpers.h"	15	#include "network_helpers.h"
16	#include "cgroup_helpers.h"	16	#include "cgroup_helpers.h"
17	#include "test_progs.h"	17	#include "test_progs.h"
18	#include "bpf_rlimit.h"
19	#include "test_sock_fields.skel.h"	18	#include "test_sock_fields.skel.h"
20		19
21	enum bpf_linum_array_idx {	20	enum bpf_linum_array_idx {

tools/testing/selftests/bpf/prog_tests/sockopt_inherit.c+8−7

 	return fd;
 }
-static int prog_attach(struct bpf_object *obj, int cgroup_fd, const char *title)
+static int prog_attach(struct bpf_object *obj, int cgroup_fd, const char *title,
+		       const char *prog_name)
 {
 	enum bpf_attach_type attach_type;
 	enum bpf_prog_type prog_type;
 	err = libbpf_prog_type_by_name(title, &prog_type, &attach_type);
 	if (err) {
-		log_err("Failed to deduct types for %s BPF program", title);
+		log_err("Failed to deduct types for %s BPF program", prog_name);
 		return -1;
 	}
-	prog = bpf_object__find_program_by_title(obj, title);
+	prog = bpf_object__find_program_by_name(obj, prog_name);
 	if (!prog) {
-		log_err("Failed to find %s BPF program", title);
+		log_err("Failed to find %s BPF program", prog_name);
 		return -1;
 	}
 	err = bpf_prog_attach(bpf_program__fd(prog), cgroup_fd,
 			      attach_type, 0);
 	if (err) {
-		log_err("Failed to attach %s BPF program", title);
+		log_err("Failed to attach %s BPF program", prog_name);
 		return -1;
 	}
 	if (!ASSERT_OK(err, "obj_load"))
 		goto close_bpf_object;
-	err = prog_attach(obj, cgroup_fd, "cgroup/getsockopt");
+	err = prog_attach(obj, cgroup_fd, "cgroup/getsockopt", "_getsockopt");
 	if (CHECK_FAIL(err))
 		goto close_bpf_object;
-	err = prog_attach(obj, cgroup_fd, "cgroup/setsockopt");
+	err = prog_attach(obj, cgroup_fd, "cgroup/setsockopt", "_setsockopt");
 	if (CHECK_FAIL(err))
 		goto close_bpf_object;

tools/testing/selftests/bpf/prog_tests/stacktrace_map.c+2−2

@@ -4,7 +4,7 @@ · 3 unmodified lines
4	void test_stacktrace_map(void)	4	void test_stacktrace_map(void)
5	{	5	{
6	int control_map_fd, stackid_hmap_fd, stackmap_fd, stack_amap_fd;	6	int control_map_fd, stackid_hmap_fd, stackmap_fd, stack_amap_fd;
7	const char *prog_name = "tracepoint/sched/sched_switch";	7	const char *prog_name = "oncpu";
8	int err, prog_fd, stack_trace_len;	8	int err, prog_fd, stack_trace_len;
9	const char *file = "./test_stacktrace_map.o";	9	const char *file = "./test_stacktrace_map.o";
10	__u32 key, val, duration = 0;	10	__u32 key, val, duration = 0;
@@ -16,7 +16,7 @@ void test_stacktrace_map(void) · 5 unmodified lines
16	if (CHECK(err, "prog_load", "err %d errno %d\n", err, errno))	16	if (CHECK(err, "prog_load", "err %d errno %d\n", err, errno))
17	return;	17	return;
18		18
19	prog = bpf_object__find_program_by_title(obj, prog_name);	19	prog = bpf_object__find_program_by_name(obj, prog_name);
20	if (CHECK(!prog, "find_prog", "prog '%s' not found\n", prog_name))	20	if (CHECK(!prog, "find_prog", "prog '%s' not found\n", prog_name))
21	goto close_prog;	21	goto close_prog;
22		22

tools/testing/selftests/bpf/prog_tests/stacktrace_map_raw_tp.c+2−2

@@ -3,7 +3,7 @@ · 2 unmodified lines
3		3
4	void test_stacktrace_map_raw_tp(void)	4	void test_stacktrace_map_raw_tp(void)
5	{	5	{
6	const char *prog_name = "tracepoint/sched/sched_switch";	6	const char *prog_name = "oncpu";
7	int control_map_fd, stackid_hmap_fd, stackmap_fd;	7	int control_map_fd, stackid_hmap_fd, stackmap_fd;
8	const char *file = "./test_stacktrace_map.o";	8	const char *file = "./test_stacktrace_map.o";
9	__u32 key, val, duration = 0;	9	__u32 key, val, duration = 0;
@@ -16,7 +16,7 @@ void test_stacktrace_map_raw_tp(void) · 6 unmodified lines
16	if (CHECK(err, "prog_load raw tp", "err %d errno %d\n", err, errno))	16	if (CHECK(err, "prog_load raw tp", "err %d errno %d\n", err, errno))
17	return;	17	return;
18		18
19	prog = bpf_object__find_program_by_title(obj, prog_name);	19	prog = bpf_object__find_program_by_name(obj, prog_name);
20	if (CHECK(!prog, "find_prog", "prog '%s' not found\n", prog_name))	20	if (CHECK(!prog, "find_prog", "prog '%s' not found\n", prog_name))
21	goto close_prog;	21	goto close_prog;
22		22

tools/testing/selftests/bpf/prog_tests/test_local_storage.c+6−14

 struct storage {
 	void *inode;
 	unsigned int value;
-	/* Lock ensures that spin locked versions of local stoage operations
-	 * also work, most operations in this tests are still single threaded
-	 */
-	struct bpf_spin_lock lock;
 };
 /* Fork and exec the provided rm binary and return the exit code of the
 static bool check_syscall_operations(int map_fd, int obj_fd)
 {
-	struct storage val = { .value = TEST_STORAGE_VALUE, .lock = { 0 } },
+	struct storage val = { .value = TEST_STORAGE_VALUE },
-		       lookup_val = { .value = 0, .lock = { 0 } };
+		       lookup_val = { .value = 0 };
 	int err;
 	/* Looking up an existing element should fail initially */
-	err = bpf_map_lookup_elem_flags(map_fd, &obj_fd, &lookup_val,
+	err = bpf_map_lookup_elem_flags(map_fd, &obj_fd, &lookup_val, 0);
-					BPF_F_LOCK);
 	if (CHECK(!err || errno != ENOENT, "bpf_map_lookup_elem",
 		  "err:%d errno:%d\n", err, errno))
 		return false;
 	/* Create a new element */
-	err = bpf_map_update_elem(map_fd, &obj_fd, &val,
+	err = bpf_map_update_elem(map_fd, &obj_fd, &val, BPF_NOEXIST);
-				  BPF_NOEXIST | BPF_F_LOCK);
 	if (CHECK(err < 0, "bpf_map_update_elem", "err:%d errno:%d\n", err,
 		  errno))
 		return false;
 	/* Lookup the newly created element */
-	err = bpf_map_lookup_elem_flags(map_fd, &obj_fd, &lookup_val,
+	err = bpf_map_lookup_elem_flags(map_fd, &obj_fd, &lookup_val, 0);
-					BPF_F_LOCK);
 	if (CHECK(err < 0, "bpf_map_lookup_elem", "err:%d errno:%d", err,
 		  errno))
 		return false;
 		return false;
 	/* The lookup should fail, now that the element has been deleted */
-	err = bpf_map_lookup_elem_flags(map_fd, &obj_fd, &lookup_val,
+	err = bpf_map_lookup_elem_flags(map_fd, &obj_fd, &lookup_val, 0);
-					BPF_F_LOCK);
 	if (CHECK(!err || errno != ENOENT, "bpf_map_lookup_elem",
 		  "err:%d errno:%d\n", err, errno))
 		return false;

tools/testing/selftests/bpf/prog_tests/test_overhead.c+10−10

@@ -56,11 +56,11 @@ static void setaffinity(void) · 55 unmodified lines
56		56
57	void test_test_overhead(void)	57	void test_test_overhead(void)
58	{	58	{
59	const char *kprobe_name = "kprobe/__set_task_comm";	59	const char *kprobe_name = "prog1";
60	const char *kretprobe_name = "kretprobe/__set_task_comm";	60	const char *kretprobe_name = "prog2";
61	const char *raw_tp_name = "raw_tp/task_rename";	61	const char *raw_tp_name = "prog3";
62	const char *fentry_name = "fentry/__set_task_comm";	62	const char *fentry_name = "prog4";
63	const char *fexit_name = "fexit/__set_task_comm";	63	const char *fexit_name = "prog5";
64	const char *kprobe_func = "__set_task_comm";	64	const char *kprobe_func = "__set_task_comm";
65	struct bpf_program kprobe_prog, kretprobe_prog, *raw_tp_prog;	65	struct bpf_program kprobe_prog, kretprobe_prog, *raw_tp_prog;
66	struct bpf_program fentry_prog, fexit_prog;	66	struct bpf_program fentry_prog, fexit_prog;
@@ -76,23 +76,23 @@ void test_test_overhead(void) · 9 unmodified lines
76	if (!ASSERT_OK_PTR(obj, "obj_open_file"))	76	if (!ASSERT_OK_PTR(obj, "obj_open_file"))
77	return;	77	return;
78		78
79	kprobe_prog = bpf_object__find_program_by_title(obj, kprobe_name);	79	kprobe_prog = bpf_object__find_program_by_name(obj, kprobe_name);
80	if (CHECK(!kprobe_prog, "find_probe",	80	if (CHECK(!kprobe_prog, "find_probe",
81	"prog '%s' not found\n", kprobe_name))	81	"prog '%s' not found\n", kprobe_name))
82	goto cleanup;	82	goto cleanup;
83	kretprobe_prog = bpf_object__find_program_by_title(obj, kretprobe_name);	83	kretprobe_prog = bpf_object__find_program_by_name(obj, kretprobe_name);
84	if (CHECK(!kretprobe_prog, "find_probe",	84	if (CHECK(!kretprobe_prog, "find_probe",
85	"prog '%s' not found\n", kretprobe_name))	85	"prog '%s' not found\n", kretprobe_name))
86	goto cleanup;	86	goto cleanup;
87	raw_tp_prog = bpf_object__find_program_by_title(obj, raw_tp_name);	87	raw_tp_prog = bpf_object__find_program_by_name(obj, raw_tp_name);
88	if (CHECK(!raw_tp_prog, "find_probe",	88	if (CHECK(!raw_tp_prog, "find_probe",
89	"prog '%s' not found\n", raw_tp_name))	89	"prog '%s' not found\n", raw_tp_name))
90	goto cleanup;	90	goto cleanup;
91	fentry_prog = bpf_object__find_program_by_title(obj, fentry_name);	91	fentry_prog = bpf_object__find_program_by_name(obj, fentry_name);
92	if (CHECK(!fentry_prog, "find_probe",	92	if (CHECK(!fentry_prog, "find_probe",
93	"prog '%s' not found\n", fentry_name))	93	"prog '%s' not found\n", fentry_name))
94	goto cleanup;	94	goto cleanup;
95	fexit_prog = bpf_object__find_program_by_title(obj, fexit_name);	95	fexit_prog = bpf_object__find_program_by_name(obj, fexit_name);
96	if (CHECK(!fexit_prog, "find_probe",	96	if (CHECK(!fexit_prog, "find_probe",
97	"prog '%s' not found\n", fexit_name))	97	"prog '%s' not found\n", fexit_name))
98	goto cleanup;	98	goto cleanup;

tools/testing/selftests/bpf/prog_tests/test_strncmp.c+167−0

@@ -0,0 +1,167 @@
	1	// SPDX-License-Identifier: GPL-2.0
	2	/* Copyright (C) 2021. Huawei Technologies Co., Ltd */
	3	#include <test_progs.h>
	4	#include "strncmp_test.skel.h"
	5
	6	static int trigger_strncmp(const struct strncmp_test *skel)
	7	{
	8	int cmp;
	9
	10	usleep(1);
	11
	12	cmp = skel->bss->cmp_ret;
	13	if (cmp > 0)
	14	return 1;
	15	if (cmp < 0)
	16	return -1;
	17	return 0;
	18	}
	19
	20	/*
	21	* Compare str and target after making str[i] != target[i].
	22	* When exp is -1, make str[i] < target[i] and delta = -1.
	23	*/
	24	static void strncmp_full_str_cmp(struct strncmp_test skel, const char name,
	25	int exp)
	26	{
	27	size_t nr = sizeof(skel->bss->str);
	28	char *str = skel->bss->str;
	29	int delta = exp;
	30	int got;
	31	size_t i;
	32
	33	memcpy(str, skel->rodata->target, nr);
	34	for (i = 0; i < nr - 1; i++) {
	35	str[i] += delta;
	36
	37	got = trigger_strncmp(skel);
	38	ASSERT_EQ(got, exp, name);
	39
	40	str[i] -= delta;
	41	}
	42	}
	43
	44	static void test_strncmp_ret(void)
	45	{
	46	struct strncmp_test *skel;
	47	struct bpf_program *prog;
	48	int err, got;
	49
	50	skel = strncmp_test__open();
	51	if (!ASSERT_OK_PTR(skel, "strncmp_test open"))
	52	return;
	53
	54	bpf_object__for_each_program(prog, skel->obj)
	55	bpf_program__set_autoload(prog, false);
	56
	57	bpf_program__set_autoload(skel->progs.do_strncmp, true);
	58
	59	err = strncmp_test__load(skel);
	60	if (!ASSERT_EQ(err, 0, "strncmp_test load"))
	61	goto out;
	62
	63	err = strncmp_test__attach(skel);
	64	if (!ASSERT_EQ(err, 0, "strncmp_test attach"))
	65	goto out;
	66
	67	skel->bss->target_pid = getpid();
	68
	69	/* Empty str */
	70	skel->bss->str[0] = '\0';
	71	got = trigger_strncmp(skel);
	72	ASSERT_EQ(got, -1, "strncmp: empty str");
	73
	74	/* Same string */
	75	memcpy(skel->bss->str, skel->rodata->target, sizeof(skel->bss->str));
	76	got = trigger_strncmp(skel);
	77	ASSERT_EQ(got, 0, "strncmp: same str");
	78
	79	/* Not-null-termainted string */
	80	memcpy(skel->bss->str, skel->rodata->target, sizeof(skel->bss->str));
	81	skel->bss->str[sizeof(skel->bss->str) - 1] = 'A';
	82	got = trigger_strncmp(skel);
	83	ASSERT_EQ(got, 1, "strncmp: not-null-term str");
	84
	85	strncmp_full_str_cmp(skel, "strncmp: less than", -1);
	86	strncmp_full_str_cmp(skel, "strncmp: greater than", 1);
	87	out:
	88	strncmp_test__destroy(skel);
	89	}
	90
	91	static void test_strncmp_bad_not_const_str_size(void)
	92	{
	93	struct strncmp_test *skel;
	94	struct bpf_program *prog;
	95	int err;
	96
	97	skel = strncmp_test__open();
	98	if (!ASSERT_OK_PTR(skel, "strncmp_test open"))
	99	return;
	100
	101	bpf_object__for_each_program(prog, skel->obj)
	102	bpf_program__set_autoload(prog, false);
	103
	104	bpf_program__set_autoload(skel->progs.strncmp_bad_not_const_str_size,
	105	true);
	106
	107	err = strncmp_test__load(skel);
	108	ASSERT_ERR(err, "strncmp_test load bad_not_const_str_size");
	109
	110	strncmp_test__destroy(skel);
	111	}
	112
	113	static void test_strncmp_bad_writable_target(void)
	114	{
	115	struct strncmp_test *skel;
	116	struct bpf_program *prog;
	117	int err;
	118
	119	skel = strncmp_test__open();
	120	if (!ASSERT_OK_PTR(skel, "strncmp_test open"))
	121	return;
	122
	123	bpf_object__for_each_program(prog, skel->obj)
	124	bpf_program__set_autoload(prog, false);
	125
	126	bpf_program__set_autoload(skel->progs.strncmp_bad_writable_target,
	127	true);
	128
	129	err = strncmp_test__load(skel);
	130	ASSERT_ERR(err, "strncmp_test load bad_writable_target");
	131
	132	strncmp_test__destroy(skel);
	133	}
	134
	135	static void test_strncmp_bad_not_null_term_target(void)
	136	{
	137	struct strncmp_test *skel;
	138	struct bpf_program *prog;
	139	int err;
	140
	141	skel = strncmp_test__open();
	142	if (!ASSERT_OK_PTR(skel, "strncmp_test open"))
	143	return;
	144
	145	bpf_object__for_each_program(prog, skel->obj)
	146	bpf_program__set_autoload(prog, false);
	147
	148	bpf_program__set_autoload(skel->progs.strncmp_bad_not_null_term_target,
	149	true);
	150
	151	err = strncmp_test__load(skel);
	152	ASSERT_ERR(err, "strncmp_test load bad_not_null_term_target");
	153
	154	strncmp_test__destroy(skel);
	155	}
	156
	157	void test_test_strncmp(void)
	158	{
	159	if (test__start_subtest("strncmp_ret"))
	160	test_strncmp_ret();
	161	if (test__start_subtest("strncmp_bad_not_const_str_size"))
	162	test_strncmp_bad_not_const_str_size();
	163	if (test__start_subtest("strncmp_bad_writable_target"))
	164	test_strncmp_bad_writable_target();
	165	if (test__start_subtest("strncmp_bad_not_null_term_target"))
	166	test_strncmp_bad_not_null_term_target();
	167	}

tools/testing/selftests/bpf/prog_tests/trampoline_count.c+3−3

@@ -35,7 +35,7 @@ static struct bpf_link load(struct bpf_object obj, const char *name) · 34 unmodified lines
35	struct bpf_program *prog;	35	struct bpf_program *prog;
36	int duration = 0;	36	int duration = 0;
37		37
38	prog = bpf_object__find_program_by_title(obj, name);	38	prog = bpf_object__find_program_by_name(obj, name);
39	if (CHECK(!prog, "find_probe", "prog '%s' not found\n", name))	39	if (CHECK(!prog, "find_probe", "prog '%s' not found\n", name))
40	return ERR_PTR(-EINVAL);	40	return ERR_PTR(-EINVAL);
41	return bpf_program__attach_trace(prog);	41	return bpf_program__attach_trace(prog);
@@ -44,8 +44,8 @@ static struct bpf_link load(struct bpf_object obj, const char *name) · 2 unmodified lines
44	/* TODO: use different target function to run in concurrent mode */	44	/* TODO: use different target function to run in concurrent mode */
45	void serial_test_trampoline_count(void)	45	void serial_test_trampoline_count(void)
46	{	46	{
47	const char *fentry_name = "fentry/__set_task_comm";	47	const char *fentry_name = "prog1";
48	const char *fexit_name = "fexit/__set_task_comm";	48	const char *fexit_name = "prog2";
49	const char *object = "test_trampoline_count.o";	49	const char *object = "test_trampoline_count.o";
50	struct inst inst[MAX_TRAMP_PROGS] = {};	50	struct inst inst[MAX_TRAMP_PROGS] = {};
51	int err, i = 0, duration = 0;	51	int err, i = 0, duration = 0;

tools/testing/selftests/bpf/progs/get_func_args_test.c+123−0

@@ -0,0 +1,123 @@
	1	// SPDX-License-Identifier: GPL-2.0
	2	#include <linux/bpf.h>
	3	#include <bpf/bpf_helpers.h>
	4	#include <bpf/bpf_tracing.h>
	5	#include <errno.h>
	6
	7	char _license[] SEC("license") = "GPL";
	8
	9	__u64 test1_result = 0;
	10	SEC("fentry/bpf_fentry_test1")
	11	int BPF_PROG(test1)
	12	{
	13	__u64 cnt = bpf_get_func_arg_cnt(ctx);
	14	__u64 a = 0, z = 0, ret = 0;
	15	__s64 err;
	16
	17	test1_result = cnt == 1;
	18
	19	/* valid arguments */
	20	err = bpf_get_func_arg(ctx, 0, &a);
	21
	22	/* We need to cast access to traced function argument values with
	23	* proper type cast, because trampoline uses type specific instruction
	24	* to save it, like for 'int a' with 32-bit mov like:
	25	*
	26	* mov %edi,-0x8(%rbp)
	27	*
	28	* so the upper 4 bytes are not zeroed.
	29	*/
	30	test1_result &= err == 0 && ((int) a == 1);
	31
	32	/* not valid argument */
	33	err = bpf_get_func_arg(ctx, 1, &z);
	34	test1_result &= err == -EINVAL;
	35
	36	/* return value fails in fentry */
	37	err = bpf_get_func_ret(ctx, &ret);
	38	test1_result &= err == -EOPNOTSUPP;
	39	return 0;
	40	}
	41
	42	__u64 test2_result = 0;
	43	SEC("fexit/bpf_fentry_test2")
	44	int BPF_PROG(test2)
	45	{
	46	__u64 cnt = bpf_get_func_arg_cnt(ctx);
	47	__u64 a = 0, b = 0, z = 0, ret = 0;
	48	__s64 err;
	49
	50	test2_result = cnt == 2;
	51
	52	/* valid arguments */
	53	err = bpf_get_func_arg(ctx, 0, &a);
	54	test2_result &= err == 0 && (int) a == 2;
	55
	56	err = bpf_get_func_arg(ctx, 1, &b);
	57	test2_result &= err == 0 && b == 3;
	58
	59	/* not valid argument */
	60	err = bpf_get_func_arg(ctx, 2, &z);
	61	test2_result &= err == -EINVAL;
	62
	63	/* return value */
	64	err = bpf_get_func_ret(ctx, &ret);
	65	test2_result &= err == 0 && ret == 5;
	66	return 0;
	67	}
	68
	69	__u64 test3_result = 0;
	70	SEC("fmod_ret/bpf_modify_return_test")
	71	int BPF_PROG(fmod_ret_test, int _a, int *_b, int _ret)
	72	{
	73	__u64 cnt = bpf_get_func_arg_cnt(ctx);
	74	__u64 a = 0, b = 0, z = 0, ret = 0;
	75	__s64 err;
	76
	77	test3_result = cnt == 2;
	78
	79	/* valid arguments */
	80	err = bpf_get_func_arg(ctx, 0, &a);
	81	test3_result &= err == 0 && ((int) a == 1);
	82
	83	err = bpf_get_func_arg(ctx, 1, &b);
	84	test3_result &= err == 0 && ((int *) b == _b);
	85
	86	/* not valid argument */
	87	err = bpf_get_func_arg(ctx, 2, &z);
	88	test3_result &= err == -EINVAL;
	89
	90	/* return value */
	91	err = bpf_get_func_ret(ctx, &ret);
	92	test3_result &= err == 0 && ret == 0;
	93
	94	/* change return value, it's checked in fexit_test program */
	95	return 1234;
	96	}
	97
	98	__u64 test4_result = 0;
	99	SEC("fexit/bpf_modify_return_test")
	100	int BPF_PROG(fexit_test, int _a, int *_b, int _ret)
	101	{
	102	__u64 cnt = bpf_get_func_arg_cnt(ctx);
	103	__u64 a = 0, b = 0, z = 0, ret = 0;
	104	__s64 err;
	105
	106	test4_result = cnt == 2;
	107
	108	/* valid arguments */
	109	err = bpf_get_func_arg(ctx, 0, &a);
	110	test4_result &= err == 0 && ((int) a == 1);
	111
	112	err = bpf_get_func_arg(ctx, 1, &b);
	113	test4_result &= err == 0 && ((int *) b == _b);
	114
	115	/* not valid argument */
	116	err = bpf_get_func_arg(ctx, 2, &z);
	117	test4_result &= err == -EINVAL;
	118
	119	/* return value */
	120	err = bpf_get_func_ret(ctx, &ret);
	121	test4_result &= err == 0 && ret == 1234;
	122	return 0;
	123	}

tools/testing/selftests/bpf/progs/local_storage.c+5−19

 struct local_storage {
 	struct inode *exec_inode;
 	__u32 value;
-	struct bpf_spin_lock lock;
 };
 struct {
 				       bpf_get_current_task_btf(), 0, 0);
 	if (storage) {
 		/* Don't let an executable delete itself */
-		bpf_spin_lock(&storage->lock);
 		is_self_unlink = storage->exec_inode == victim->d_inode;
-		bpf_spin_unlock(&storage->lock);
 		if (is_self_unlink)
 			return -EPERM;
 	}
 	return 0;
 }
-SEC("lsm/inode_rename")
+SEC("lsm.s/inode_rename")
 int BPF_PROG(inode_rename, struct inode *old_dir, struct dentry *old_dentry,
 	     struct inode *new_dir, struct dentry *new_dentry,
 	     unsigned int flags)
 	if (!storage)
 		return 0;
-	bpf_spin_lock(&storage->lock);
 	if (storage->value != DUMMY_STORAGE_VALUE)
 		inode_storage_result = -1;
-	bpf_spin_unlock(&storage->lock);
 	err = bpf_inode_storage_delete(&inode_storage_map, old_dentry->d_inode);
 	if (!err)
 	return 0;
 }
-SEC("lsm/socket_bind")
+SEC("lsm.s/socket_bind")
 int BPF_PROG(socket_bind, struct socket *sock, struct sockaddr *address,
 	     int addrlen)
 {
 	if (!storage)
 		return 0;
-	bpf_spin_lock(&storage->lock);
 	if (storage->value != DUMMY_STORAGE_VALUE)
 		sk_storage_result = -1;
-	bpf_spin_unlock(&storage->lock);
 	err = bpf_sk_storage_delete(&sk_storage_map, sock->sk);
 	if (!err)
 	return 0;
 }
-SEC("lsm/socket_post_create")
+SEC("lsm.s/socket_post_create")
 int BPF_PROG(socket_post_create, struct socket *sock, int family, int type,
 	     int protocol, int kern)
 {
 	if (!storage)
 		return 0;
-	bpf_spin_lock(&storage->lock);
 	storage->value = DUMMY_STORAGE_VALUE;
-	bpf_spin_unlock(&storage->lock);
 	return 0;
 }
 /* This uses the local storage to remember the inode of the binary that a
  * process was originally executing.
  */
-SEC("lsm/bprm_committed_creds")
+SEC("lsm.s/bprm_committed_creds")
 void BPF_PROG(exec, struct linux_binprm *bprm)
 {
 	__u32 pid = bpf_get_current_pid_tgid() >> 32;
 	storage = bpf_task_storage_get(&task_storage_map,
 				       bpf_get_current_task_btf(), 0,
 				       BPF_LOCAL_STORAGE_GET_F_CREATE);
-	if (storage) {
+	if (storage)
-		bpf_spin_lock(&storage->lock);
 		storage->exec_inode = bprm->file->f_inode;
-		bpf_spin_unlock(&storage->lock);
-	}
 	storage = bpf_inode_storage_get(&inode_storage_map, bprm->file->f_inode,
 					0, BPF_LOCAL_STORAGE_GET_F_CREATE);
 	if (!storage)
 		return;
-	bpf_spin_lock(&storage->lock);
 	storage->value = DUMMY_STORAGE_VALUE;
-	bpf_spin_unlock(&storage->lock);
 }

tools/testing/selftests/bpf/progs/strncmp_bench.c+50−0

@@ -0,0 +1,50 @@
	1	// SPDX-License-Identifier: GPL-2.0
	2	/* Copyright (C) 2021. Huawei Technologies Co., Ltd */
	3	#include <linux/types.h>
	4	#include <linux/bpf.h>
	5	#include <bpf/bpf_helpers.h>
	6	#include <bpf/bpf_tracing.h>
	7
	8	#define STRNCMP_STR_SZ 4096
	9
	10	/* Will be updated by benchmark before program loading */
	11	const volatile unsigned int cmp_str_len = 1;
	12	const char target[STRNCMP_STR_SZ];
	13
	14	long hits = 0;
	15	char str[STRNCMP_STR_SZ];
	16
	17	char _license[] SEC("license") = "GPL";
	18
	19	static __always_inline int local_strncmp(const char *s1, unsigned int sz,
	20	const char *s2)
	21	{
	22	int ret = 0;
	23	unsigned int i;
	24
	25	for (i = 0; i < sz; i++) {
	26	/* E.g. 0xff > 0x31 */
	27	ret = (unsigned char)s1[i] - (unsigned char)s2[i];
	28	if (ret \|\| !s1[i])
	29	break;
	30	}
	31
	32	return ret;
	33	}
	34
	35	SEC("tp/syscalls/sys_enter_getpgid")
	36	int strncmp_no_helper(void *ctx)
	37	{
	38	if (local_strncmp(str, cmp_str_len + 1, target) < 0)
	39	__sync_add_and_fetch(&hits, 1);
	40	return 0;
	41	}
	42
	43	SEC("tp/syscalls/sys_enter_getpgid")
	44	int strncmp_helper(void *ctx)
	45	{
	46	if (bpf_strncmp(str, cmp_str_len + 1, target) < 0)
	47	__sync_add_and_fetch(&hits, 1);
	48	return 0;
	49	}
	50

tools/testing/selftests/bpf/progs/strncmp_test.c+54−0

@@ -0,0 +1,54 @@
	1	// SPDX-License-Identifier: GPL-2.0
	2	/* Copyright (C) 2021. Huawei Technologies Co., Ltd */
	3	#include <stdbool.h>
	4	#include <linux/types.h>
	5	#include <linux/bpf.h>
	6	#include <bpf/bpf_helpers.h>
	7	#include <bpf/bpf_tracing.h>
	8
	9	#define STRNCMP_STR_SZ 8
	10
	11	const char target[STRNCMP_STR_SZ] = "EEEEEEE";
	12	char str[STRNCMP_STR_SZ];
	13	int cmp_ret = 0;
	14	int target_pid = 0;
	15
	16	const char no_str_target[STRNCMP_STR_SZ] = "12345678";
	17	char writable_target[STRNCMP_STR_SZ];
	18	unsigned int no_const_str_size = STRNCMP_STR_SZ;
	19
	20	char _license[] SEC("license") = "GPL";
	21
	22	SEC("tp/syscalls/sys_enter_nanosleep")
	23	int do_strncmp(void *ctx)
	24	{
	25	if ((bpf_get_current_pid_tgid() >> 32) != target_pid)
	26	return 0;
	27
	28	cmp_ret = bpf_strncmp(str, STRNCMP_STR_SZ, target);
	29	return 0;
	30	}
	31
	32	SEC("tp/syscalls/sys_enter_nanosleep")
	33	int strncmp_bad_not_const_str_size(void *ctx)
	34	{
	35	/* The value of string size is not const, so will fail */
	36	cmp_ret = bpf_strncmp(str, no_const_str_size, target);
	37	return 0;
	38	}
	39
	40	SEC("tp/syscalls/sys_enter_nanosleep")
	41	int strncmp_bad_writable_target(void *ctx)
	42	{
	43	/* Compared target is not read-only, so will fail */
	44	cmp_ret = bpf_strncmp(str, STRNCMP_STR_SZ, writable_target);
	45	return 0;
	46	}
	47
	48	SEC("tp/syscalls/sys_enter_nanosleep")
	49	int strncmp_bad_not_null_term_target(void *ctx)
	50	{
	51	/* Compared target is not null-terminated, so will fail */
	52	cmp_ret = bpf_strncmp(str, STRNCMP_STR_SZ, no_str_target);
	53	return 0;
	54	}

tools/testing/selftests/bpf/progs/test_ksyms_btf_write_check.c+29−0

@@ -0,0 +1,29 @@
	1	// SPDX-License-Identifier: GPL-2.0
	2	/* Copyright (c) 2021 Google */
	3
	4	#include "vmlinux.h"
	5
	6	#include <bpf/bpf_helpers.h>
	7
	8	extern const int bpf_prog_active __ksym; /* int type global var. */
	9
	10	SEC("raw_tp/sys_enter")
	11	int handler(const void *ctx)
	12	{
	13	int *active;
	14	__u32 cpu;
	15
	16	cpu = bpf_get_smp_processor_id();
	17	active = (int *)bpf_per_cpu_ptr(&bpf_prog_active, cpu);
	18	if (active) {
	19	/* Kernel memory obtained from bpf_{per,this}_cpu_ptr
	20	* is read-only, should _not_ pass verification.
	21	*/
	22	/* WRITE_ONCE */
	23	(volatile int )active = -1;
	24	}
	25
	26	return 0;
	27	}
	28
	29	char _license[] SEC("license") = "GPL";

tools/testing/selftests/bpf/test_cpp.cpp+8−1

 /* do nothing, just make sure we can link successfully */
+static void dump_printf(void *ctx, const char *fmt, va_list args)
+{
+}
 int main(int argc, char *argv[])
 {
+	struct btf_dump_opts opts = { };
 	struct test_core_extern *skel;
+	struct btf *btf;
 	/* libbpf.h */
 	libbpf_set_print(NULL);
 	bpf_prog_get_fd_by_id(0);
 	/* btf.h */
-	btf__new(NULL, 0);
+	btf = btf__new(NULL, 0);
+	btf_dump__new(btf, dump_printf, nullptr, &opts);
 	/* BPF skeleton */
 	skel = test_core_extern__open_and_load();

tools/testing/selftests/bpf/test_maps.c+0−1

@@ -23,7 +23,6 @@ · 22 unmodified lines
23	#include <bpf/libbpf.h>	23	#include <bpf/libbpf.h>
24		24
25	#include "bpf_util.h"	25	#include "bpf_util.h"
26	#include "bpf_rlimit.h"
27	#include "test_maps.h"	26	#include "test_maps.h"
28	#include "testing_helpers.h"	27	#include "testing_helpers.h"
29		28

tools/testing/selftests/bpf/test_progs.c+0−2

 #define _GNU_SOURCE
 #include "test_progs.h"
 #include "cgroup_helpers.h"
-#include "bpf_rlimit.h"
 #include <argp.h>
 #include <pthread.h>
 #include <sched.h>
 	/* Use libbpf 1.0 API mode */
 	libbpf_set_strict_mode(LIBBPF_STRICT_ALL);
 	libbpf_set_print(libbpf_print_fn);
 	srand(time(NULL));

tools/testing/selftests/bpf/test_verifier.c+8−10

@@ -41,7 +41,6 @@ · 40 unmodified lines
41	# define CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS 1	41	# define CONFIG_HAVE_EFFICIENT_UNALIGNED_ACCESS 1
42	# endif	42	# endif
43	#endif	43	#endif
44	#include "bpf_rlimit.h"
45	#include "bpf_rand.h"	44	#include "bpf_rand.h"
46	#include "bpf_util.h"	45	#include "bpf_util.h"
47	#include "test_btf.h"	46	#include "test_btf.h"
@@ -701,22 +700,18 @@ static int create_sk_storage_map(void) · 653 unmodified lines
701		700
702	static int create_map_timer(void)	701	static int create_map_timer(void)
703	{	702	{
704	struct bpf_create_map_attr attr = {	703	LIBBPF_OPTS(bpf_map_create_opts, opts,
705	.name = "test_map",
706	.map_type = BPF_MAP_TYPE_ARRAY,
707	.key_size = 4,
708	.value_size = 16,
709	.max_entries = 1,
710	.btf_key_type_id = 1,	704	.btf_key_type_id = 1,
711	.btf_value_type_id = 5,	705	.btf_value_type_id = 5,
712	};	706	);
713	int fd, btf_fd;	707	int fd, btf_fd;
714		708
715	btf_fd = load_btf();	709	btf_fd = load_btf();
716	if (btf_fd < 0)	710	if (btf_fd < 0)
717	return -1;	711	return -1;
718	attr.btf_fd = btf_fd;	712
719	fd = bpf_create_map_xattr(&attr);	713	opts.btf_fd = btf_fd;
		714	fd = bpf_map_create(BPF_MAP_TYPE_ARRAY, "test_map", 4, 16, 1, &opts);
720	if (fd < 0)	715	if (fd < 0)
721	printf("Failed to create map with timer\n");	716	printf("Failed to create map with timer\n");
722	return fd;	717	return fd;
@@ -1399,6 +1394,9 @@ int main(int argc, char **argv) · 676 unmodified lines
1399	return EXIT_FAILURE;	1394	return EXIT_FAILURE;
1400	}	1395	}
1401		1396
		1397	/* Use libbpf 1.0 API mode */
		1398	libbpf_set_strict_mode(LIBBPF_STRICT_ALL);
		1399
1402	bpf_semi_rand_init();	1400	bpf_semi_rand_init();
1403	return do_test(unpriv, from, to);	1401	return do_test(unpriv, from, to);
1404	}	1402	}

tools/testing/selftests/bpf/verifier/btf_ctx_access.c+12−0

@@ -0,0 +1,12 @@
	1	{
	2	"btf_ctx_access accept",
	3	.insns = {
	4	BPF_LDX_MEM(BPF_W, BPF_REG_2, BPF_REG_1, 8), /* load 2nd argument value (int pointer) */
	5	BPF_MOV64_IMM(BPF_REG_0, 0),
	6	BPF_EXIT_INSN(),
	7	},
	8	.result = ACCEPT,
	9	.prog_type = BPF_PROG_TYPE_TRACING,
	10	.expected_attach_type = BPF_TRACE_FENTRY,
	11	.kfunc = "bpf_modify_return_test",
	12	},

tools/testing/selftests/bpf/vmtest.sh+1−1

@@ -32,7 +32,7 @@ ROOTFS_IMAGE="root.img" · 31 unmodified lines
32	OUTPUT_DIR="$HOME/.bpf_selftests"	32	OUTPUT_DIR="$HOME/.bpf_selftests"
33	KCONFIG_URL="https://raw.githubusercontent.com/libbpf/libbpf/master/travis-ci/vmtest/configs/config-latest.${ARCH}"	33	KCONFIG_URL="https://raw.githubusercontent.com/libbpf/libbpf/master/travis-ci/vmtest/configs/config-latest.${ARCH}"
34	KCONFIG_API_URL="https://api.github.com/repos/libbpf/libbpf/contents/travis-ci/vmtest/configs/config-latest.${ARCH}"	34	KCONFIG_API_URL="https://api.github.com/repos/libbpf/libbpf/contents/travis-ci/vmtest/configs/config-latest.${ARCH}"
35	INDEX_URL="https://raw.githubusercontent.com/libbpf/libbpf/master/travis-ci/vmtest/configs/INDEX"	35	INDEX_URL="https://raw.githubusercontent.com/libbpf/ci/master/INDEX"
36	NUM_COMPILE_JOBS="$(nproc)"	36	NUM_COMPILE_JOBS="$(nproc)"
37	LOG_FILE_BASE="$(date +"bpf_selftests.%Y-%m-%d_%H-%M-%S")"	37	LOG_FILE_BASE="$(date +"bpf_selftests.%Y-%m-%d_%H-%M-%S")"
38	LOG_FILE="${LOG_FILE_BASE}.log"	38	LOG_FILE="${LOG_FILE_BASE}.log"