lael-labs/linux

tools/bpf/bpftool/Makefile+7−6

 $(LIBBPF_BOOTSTRAP): $(wildcard $(BPF_DIR)/*.[ch] $(BPF_DIR)/Makefile) | $(LIBBPF_BOOTSTRAP_OUTPUT)
 	$(Q)$(MAKE) -C $(BPF_DIR) OUTPUT=$(LIBBPF_BOOTSTRAP_OUTPUT) \
 		DESTDIR=$(LIBBPF_BOOTSTRAP_DESTDIR) prefix= \
-		ARCH= CC=$(HOSTCC) LD=$(HOSTLD) $@ install_headers
+		ARCH= CROSS_COMPILE= CC=$(HOSTCC) LD=$(HOSTLD) $@ install_headers
 $(LIBBPF_BOOTSTRAP_INTERNAL_HDRS): $(LIBBPF_BOOTSTRAP_HDRS_DIR)/%.h: $(BPF_DIR)/%.h | $(LIBBPF_BOOTSTRAP_HDRS_DIR)
 	$(call QUIET_INSTALL, $@)
 SRCS += $(BFD_SRCS)
 endif
+HOST_CFLAGS = $(subst -I$(LIBBPF_INCLUDE),-I$(LIBBPF_BOOTSTRAP_INCLUDE),\
+		$(subst $(CLANG_CROSS_FLAGS),,$(CFLAGS)))
 BPFTOOL_BOOTSTRAP := $(BOOTSTRAP_OUTPUT)bpftool
 BOOTSTRAP_OBJS = $(addprefix $(BOOTSTRAP_OUTPUT),main.o common.o json_writer.o gen.o btf.o xlated_dumper.o btf_dumper.o disasm.o)
 CFLAGS += $(if $(BUILD_BPF_SKELS),,-DBPFTOOL_WITHOUT_SKELETONS)
 $(BOOTSTRAP_OUTPUT)disasm.o: $(srctree)/kernel/bpf/disasm.c
-	$(QUIET_CC)$(HOSTCC) $(CFLAGS) -c -MMD $< -o $@
+	$(QUIET_CC)$(HOSTCC) $(HOST_CFLAGS) -c -MMD $< -o $@
 $(OUTPUT)disasm.o: $(srctree)/kernel/bpf/disasm.c
 	$(QUIET_CC)$(CC) $(CFLAGS) -c -MMD $< -o $@
 endif
 $(BPFTOOL_BOOTSTRAP): $(BOOTSTRAP_OBJS) $(LIBBPF_BOOTSTRAP)
-	$(QUIET_LINK)$(HOSTCC) $(CFLAGS) $(LDFLAGS) $(BOOTSTRAP_OBJS) $(LIBS_BOOTSTRAP) -o $@
+	$(QUIET_LINK)$(HOSTCC) $(HOST_CFLAGS) $(LDFLAGS) $(BOOTSTRAP_OBJS) $(LIBS_BOOTSTRAP) -o $@
 $(OUTPUT)bpftool: $(OBJS) $(LIBBPF)
 	$(QUIET_LINK)$(CC) $(CFLAGS) $(LDFLAGS) $(OBJS) $(LIBS) -o $@
 $(BOOTSTRAP_OUTPUT)%.o: %.c $(LIBBPF_BOOTSTRAP_INTERNAL_HDRS) | $(BOOTSTRAP_OUTPUT)
-	$(QUIET_CC)$(HOSTCC) \
+	$(QUIET_CC)$(HOSTCC) $(HOST_CFLAGS) -c -MMD $< -o $@
-		$(subst -I$(LIBBPF_INCLUDE),-I$(LIBBPF_BOOTSTRAP_INCLUDE),$(CFLAGS)) \
-		-c -MMD $< -o $@
 $(OUTPUT)%.o: %.c
 	$(QUIET_CC)$(CC) $(CFLAGS) -c -MMD $< -o $@

tools/bpf/bpftool/feature.c+23−3

@@ -642,12 +642,32 @@ probe_helpers_for_progtype(enum bpf_prog_type prog_type, bool supported_type, · 641 unmodified lines
642	printf("\n");	642	printf("\n");
643	}	643	}
644		644
645	static void	645	/*
646	probe_large_insn_limit(const char *define_prefix, __u32 ifindex)	646	* Probe for availability of kernel commit (5.3):
		647	*
		648	* c04c0d2b968a ("bpf: increase complexity limit and maximum program size")
		649	*/
		650	static void probe_large_insn_limit(const char *define_prefix, __u32 ifindex)
647	{	651	{
		652	LIBBPF_OPTS(bpf_prog_load_opts, opts,
		653	.prog_ifindex = ifindex,
		654	);
		655	struct bpf_insn insns[BPF_MAXINSNS + 1];
648	bool res;	656	bool res;
		657	int i, fd;
		658
		659	for (i = 0; i < BPF_MAXINSNS; i++)
		660	insns[i] = BPF_MOV64_IMM(BPF_REG_0, 1);
		661	insns[BPF_MAXINSNS] = BPF_EXIT_INSN();
		662
		663	errno = 0;
		664	fd = bpf_prog_load(BPF_PROG_TYPE_SCHED_CLS, NULL, "GPL",
		665	insns, ARRAY_SIZE(insns), &opts);
		666	res = fd >= 0 \|\| (errno != E2BIG && errno != EINVAL);
		667
		668	if (fd >= 0)
		669	close(fd);
649		670
650	res = bpf_probe_large_insn_limit(ifindex);
651	print_bool_feature("have_large_insn_limit",	671	print_bool_feature("have_large_insn_limit",
652	"Large program size limit",	672	"Large program size limit",
653	"LARGE_INSN_LIMIT",	673	"LARGE_INSN_LIMIT",

tools/bpf/bpftool/main.c+2−0

@@ -408,6 +408,8 @@ int main(int argc, char **argv) · 407 unmodified lines
408	bool version_requested = false;	408	bool version_requested = false;
409	int opt, ret;	409	int opt, ret;
410		410
		411	setlinebuf(stdout);
		412
411	last_do_help = do_help;	413	last_do_help = do_help;
412	pretty_output = false;	414	pretty_output = false;
413	json_output = false;	415	json_output = false;

tools/bpf/resolve_btfids/Makefile+1−0

@@ -19,6 +19,7 @@ CC = $(HOSTCC) · 18 unmodified lines
19	LD = $(HOSTLD)	19	LD = $(HOSTLD)
20	ARCH = $(HOSTARCH)	20	ARCH = $(HOSTARCH)
21	RM ?= rm	21	RM ?= rm
		22	CROSS_COMPILE =
22		23
23	OUTPUT ?= $(srctree)/tools/bpf/resolve_btfids/	24	OUTPUT ?= $(srctree)/tools/bpf/resolve_btfids/
24		25

tools/bpf/runqslower/Makefile+2−2

@@ -12,7 +12,7 @@ BPFOBJ := $(BPFOBJ_OUTPUT)libbpf.a · 11 unmodified lines
12	BPF_DESTDIR := $(BPFOBJ_OUTPUT)	12	BPF_DESTDIR := $(BPFOBJ_OUTPUT)
13	BPF_INCLUDE := $(BPF_DESTDIR)/include	13	BPF_INCLUDE := $(BPF_DESTDIR)/include
14	INCLUDES := -I$(OUTPUT) -I$(BPF_INCLUDE) -I$(abspath ../../include/uapi)	14	INCLUDES := -I$(OUTPUT) -I$(BPF_INCLUDE) -I$(abspath ../../include/uapi)
15	CFLAGS := -g -Wall	15	CFLAGS := -g -Wall $(CLANG_CROSS_FLAGS)
16		16
17	# Try to detect best kernel BTF source	17	# Try to detect best kernel BTF source
18	KERNEL_REL := $(shell uname -r)	18	KERNEL_REL := $(shell uname -r)
@@ -88,4 +88,4 @@ $(BPFOBJ): $(wildcard $(LIBBPF_SRC)/*.[ch] $(LIBBPF_SRC)/Makefile) \| $(BPFOBJ_OU · 69 unmodified lines
88		88
89	$(DEFAULT_BPFTOOL): $(BPFOBJ) \| $(BPFTOOL_OUTPUT)	89	$(DEFAULT_BPFTOOL): $(BPFOBJ) \| $(BPFTOOL_OUTPUT)
90	$(Q)$(MAKE) $(submake_extras) -C ../bpftool OUTPUT=$(BPFTOOL_OUTPUT) \	90	$(Q)$(MAKE) $(submake_extras) -C ../bpftool OUTPUT=$(BPFTOOL_OUTPUT) \
91	CC=$(HOSTCC) LD=$(HOSTLD)	91	ARCH= CROSS_COMPILE= CC=$(HOSTCC) LD=$(HOSTLD)

tools/include/uapi/linux/bpf.h+39−0

@@ -4983,6 +4983,41 @@ union bpf_attr { · 4982 unmodified lines
4983	* Return	4983	* Return
4984	* The number of loops performed, -EINVAL for invalid flags,	4984	* The number of loops performed, -EINVAL for invalid flags,
4985	* -E2BIG if nr_loops exceeds the maximum number of loops.	4985	* -E2BIG if nr_loops exceeds the maximum number of loops.
		4986	*
		4987	* long bpf_strncmp(const char s1, u32 s1_sz, const char s2)
		4988	* Description
		4989	* Do strncmp() between s1 and s2. s1 doesn't need
		4990	* to be null-terminated and s1_sz is the maximum storage
		4991	* size of s1. s2 must be a read-only string.
		4992	* Return
		4993	* An integer less than, equal to, or greater than zero
		4994	* if the first s1_sz bytes of s1 is found to be
		4995	* less than, to match, or be greater than s2.
		4996	*
		4997	* long bpf_get_func_arg(void ctx, u32 n, u64 value)
		4998	* Description
		4999	* Get n-th argument (zero based) of the traced function (for tracing programs)
		5000	* returned in value.
		5001	*
		5002	* Return
		5003	* 0 on success.
		5004	* -EINVAL if n >= arguments count of traced function.
		5005	*
		5006	* long bpf_get_func_ret(void ctx, u64 value)
		5007	* Description
		5008	* Get return value of the traced function (for tracing programs)
		5009	* in value.
		5010	*
		5011	* Return
		5012	* 0 on success.
		5013	* -EOPNOTSUPP for tracing programs other than BPF_TRACE_FEXIT or BPF_MODIFY_RETURN.
		5014	*
		5015	* long bpf_get_func_arg_cnt(void *ctx)
		5016	* Description
		5017	* Get number of arguments of the traced function (for tracing programs).
		5018	*
		5019	* Return
		5020	* The number of arguments of the traced function.
4986	*/	5021	*/
4987	#define __BPF_FUNC_MAPPER(FN) \	5022	#define __BPF_FUNC_MAPPER(FN) \
4988	FN(unspec), \	5023	FN(unspec), \
@@ -5167,6 +5202,10 @@ union bpf_attr { · 178 unmodified lines
5167	FN(kallsyms_lookup_name), \	5202	FN(kallsyms_lookup_name), \
5168	FN(find_vma), \	5203	FN(find_vma), \
5169	FN(loop), \	5204	FN(loop), \
		5205	FN(strncmp), \
		5206	FN(get_func_arg), \
		5207	FN(get_func_ret), \
		5208	FN(get_func_arg_cnt), \
5170	/* */	5209	/* */
5171		5210
5172	/* integer value in 'imm' field of BPF_CALL instruction selects which helper	5211	/* integer value in 'imm' field of BPF_CALL instruction selects which helper

tools/lib/bpf/Makefile+2−1

 override CFLAGS += $(INCLUDES)
 override CFLAGS += -fvisibility=hidden
 override CFLAGS += -D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64
+override CFLAGS += $(CLANG_CROSS_FLAGS)
 # flags specific for shared library
 SHLIB_FLAGS := -DSHARED -fPIC
 $(OUTPUT)libbpf.so: $(OUTPUT)libbpf.so.$(LIBBPF_VERSION)
 $(OUTPUT)libbpf.so.$(LIBBPF_VERSION): $(BPF_IN_SHARED) $(VERSION_SCRIPT)
-	$(QUIET_LINK)$(CC) $(LDFLAGS) \
+	$(QUIET_LINK)$(CC) $(CFLAGS) $(LDFLAGS) \
 		--shared -Wl,-soname,libbpf.so.$(LIBBPF_MAJOR_VERSION) \
 		-Wl,--version-script=$(VERSION_SCRIPT) $< -lelf -lz -o $@
 	@ln -sf $(@F) $(OUTPUT)libbpf.so

tools/lib/bpf/bpf.c+83−2

@@ -28,7 +28,9 @@ · 27 unmodified lines
28	#include <asm/unistd.h>	28	#include <asm/unistd.h>
29	#include <errno.h>	29	#include <errno.h>
30	#include <linux/bpf.h>	30	#include <linux/bpf.h>
		31	#include <linux/filter.h>
31	#include <limits.h>	32	#include <limits.h>
		33	#include <sys/resource.h>
32	#include "bpf.h"	34	#include "bpf.h"
33	#include "libbpf.h"	35	#include "libbpf.h"
34	#include "libbpf_internal.h"	36	#include "libbpf_internal.h"
@@ -94,6 +96,77 @@ static inline int sys_bpf_prog_load(union bpf_attr *attr, unsigned int size, int · 59 unmodified lines
94	return fd;	96	return fd;
95	}	97	}
96		98
		99	/* Probe whether kernel switched from memlock-based (RLIMIT_MEMLOCK) to
		100	* memcg-based memory accounting for BPF maps and progs. This was done in [0].
		101	* We use the support for bpf_ktime_get_coarse_ns() helper, which was added in
		102	* the same 5.11 Linux release ([1]), to detect memcg-based accounting for BPF.
		103	*
		104	* [0] https://lore.kernel.org/bpf/20201201215900.3569844-1-guro@fb.com/
		105	* [1] d05512618056 ("bpf: Add bpf_ktime_get_coarse_ns helper")
		106	*/
		107	int probe_memcg_account(void)
		108	{
		109	const size_t prog_load_attr_sz = offsetofend(union bpf_attr, attach_btf_obj_fd);
		110	struct bpf_insn insns[] = {
		111	BPF_EMIT_CALL(BPF_FUNC_ktime_get_coarse_ns),
		112	BPF_EXIT_INSN(),
		113	};
		114	size_t insn_cnt = sizeof(insns) / sizeof(insns[0]);
		115	union bpf_attr attr;
		116	int prog_fd;
		117
		118	/* attempt loading freplace trying to use custom BTF */
		119	memset(&attr, 0, prog_load_attr_sz);
		120	attr.prog_type = BPF_PROG_TYPE_SOCKET_FILTER;
		121	attr.insns = ptr_to_u64(insns);
		122	attr.insn_cnt = insn_cnt;
		123	attr.license = ptr_to_u64("GPL");
		124
		125	prog_fd = sys_bpf_fd(BPF_PROG_LOAD, &attr, prog_load_attr_sz);
		126	if (prog_fd >= 0) {
		127	close(prog_fd);
		128	return 1;
		129	}
		130	return 0;
		131	}
		132
		133	static bool memlock_bumped;
		134	static rlim_t memlock_rlim = RLIM_INFINITY;
		135
		136	int libbpf_set_memlock_rlim(size_t memlock_bytes)
		137	{
		138	if (memlock_bumped)
		139	return libbpf_err(-EBUSY);
		140
		141	memlock_rlim = memlock_bytes;
		142	return 0;
		143	}
		144
		145	int bump_rlimit_memlock(void)
		146	{
		147	struct rlimit rlim;
		148
		149	/* this the default in libbpf 1.0, but for now user has to opt-in explicitly */
		150	if (!(libbpf_mode & LIBBPF_STRICT_AUTO_RLIMIT_MEMLOCK))
		151	return 0;
		152
		153	/* if kernel supports memcg-based accounting, skip bumping RLIMIT_MEMLOCK */
		154	if (memlock_bumped \|\| kernel_supports(NULL, FEAT_MEMCG_ACCOUNT))
		155	return 0;
		156
		157	memlock_bumped = true;
		158
		159	/* zero memlock_rlim_max disables auto-bumping RLIMIT_MEMLOCK */
		160	if (memlock_rlim == 0)
		161	return 0;
		162
		163	rlim.rlim_cur = rlim.rlim_max = memlock_rlim;
		164	if (setrlimit(RLIMIT_MEMLOCK, &rlim))
		165	return -errno;
		166
		167	return 0;
		168	}
		169
97	int bpf_map_create(enum bpf_map_type map_type,	170	int bpf_map_create(enum bpf_map_type map_type,
98	const char *map_name,	171	const char *map_name,
99	__u32 key_size,	172	__u32 key_size,
@@ -105,6 +178,8 @@ int bpf_map_create(enum bpf_map_type map_type, · 5 unmodified lines
105	union bpf_attr attr;	178	union bpf_attr attr;
106	int fd;	179	int fd;
107		180
		181	bump_rlimit_memlock();
		182
108	memset(&attr, 0, attr_sz);	183	memset(&attr, 0, attr_sz);
109		184
110	if (!OPTS_VALID(opts, bpf_map_create_opts))	185	if (!OPTS_VALID(opts, bpf_map_create_opts))
@@ -112,7 +187,7 @@ int bpf_map_create(enum bpf_map_type map_type, · 1 unmodified line
112		187
113	attr.map_type = map_type;	188	attr.map_type = map_type;
114	if (map_name)	189	if (map_name)
115	strncat(attr.map_name, map_name, sizeof(attr.map_name) - 1);	190	libbpf_strlcpy(attr.map_name, map_name, sizeof(attr.map_name));
116	attr.key_size = key_size;	191	attr.key_size = key_size;
117	attr.value_size = value_size;	192	attr.value_size = value_size;
118	attr.max_entries = max_entries;	193	attr.max_entries = max_entries;
@@ -251,6 +326,8 @@ int bpf_prog_load_v0_6_0(enum bpf_prog_type prog_type, · 132 unmodified lines
251	union bpf_attr attr;	326	union bpf_attr attr;
252	char *log_buf;	327	char *log_buf;
253		328
		329	bump_rlimit_memlock();
		330
254	if (!OPTS_VALID(opts, bpf_prog_load_opts))	331	if (!OPTS_VALID(opts, bpf_prog_load_opts))
255	return libbpf_err(-EINVAL);	332	return libbpf_err(-EINVAL);
256		333
@@ -271,7 +348,7 @@ int bpf_prog_load_v0_6_0(enum bpf_prog_type prog_type, · 14 unmodified lines
271	attr.kern_version = OPTS_GET(opts, kern_version, 0);	348	attr.kern_version = OPTS_GET(opts, kern_version, 0);
272		349
273	if (prog_name)	350	if (prog_name)
274	strncat(attr.prog_name, prog_name, sizeof(attr.prog_name) - 1);	351	libbpf_strlcpy(attr.prog_name, prog_name, sizeof(attr.prog_name));
275	attr.license = ptr_to_u64(license);	352	attr.license = ptr_to_u64(license);
276		353
277	if (insn_cnt > UINT_MAX)	354	if (insn_cnt > UINT_MAX)
@@ -456,6 +533,8 @@ int bpf_verify_program(enum bpf_prog_type type, const struct bpf_insn *insns, · 178 unmodified lines
456	union bpf_attr attr;	533	union bpf_attr attr;
457	int fd;	534	int fd;
458		535
		536	bump_rlimit_memlock();
		537
459	memset(&attr, 0, sizeof(attr));	538	memset(&attr, 0, sizeof(attr));
460	attr.prog_type = type;	539	attr.prog_type = type;
461	attr.insn_cnt = (__u32)insns_cnt;	540	attr.insn_cnt = (__u32)insns_cnt;
@@ -1056,6 +1135,8 @@ int bpf_btf_load(const void *btf_data, size_t btf_size, const struct bpf_btf_loa · 594 unmodified lines
1056	__u32 log_level;	1135	__u32 log_level;
1057	int fd;	1136	int fd;
1058		1137
		1138	bump_rlimit_memlock();
		1139
1059	memset(&attr, 0, attr_sz);	1140	memset(&attr, 0, attr_sz);
1060		1141
1061	if (!OPTS_VALID(opts, bpf_btf_load_opts))	1142	if (!OPTS_VALID(opts, bpf_btf_load_opts))

tools/lib/bpf/bpf.h+2−0

@@ -35,6 +35,8 @@ · 34 unmodified lines
35	extern "C" {	35	extern "C" {
36	#endif	36	#endif
37		37
		38	int libbpf_set_memlock_rlim(size_t memlock_bytes);
		39
38	struct bpf_map_create_opts {	40	struct bpf_map_create_opts {
39	size_t sz; /* size of this struct for forward/backward compatibility */	41	size_t sz; /* size of this struct for forward/backward compatibility */
40		42

tools/lib/bpf/bpf_tracing.h+174−257

@@ -66,277 +66,204 @@ · 65 unmodified lines
66		66
67	#if defined(__KERNEL__) \|\| defined(__VMLINUX_H__)	67	#if defined(__KERNEL__) \|\| defined(__VMLINUX_H__)
68		68
69	#define PT_REGS_PARM1(x) ((x)->di)	69	#define __PT_PARM1_REG di
70	#define PT_REGS_PARM2(x) ((x)->si)	70	#define __PT_PARM2_REG si
71	#define PT_REGS_PARM3(x) ((x)->dx)	71	#define __PT_PARM3_REG dx
72	#define PT_REGS_PARM4(x) ((x)->cx)	72	#define __PT_PARM4_REG cx
73	#define PT_REGS_PARM5(x) ((x)->r8)	73	#define __PT_PARM5_REG r8
74	#define PT_REGS_RET(x) ((x)->sp)	74	#define __PT_RET_REG sp
75	#define PT_REGS_FP(x) ((x)->bp)	75	#define __PT_FP_REG bp
76	#define PT_REGS_RC(x) ((x)->ax)	76	#define __PT_RC_REG ax
77	#define PT_REGS_SP(x) ((x)->sp)	77	#define __PT_SP_REG sp
78	#define PT_REGS_IP(x) ((x)->ip)	78	#define __PT_IP_REG ip
79
80	#define PT_REGS_PARM1_CORE(x) BPF_CORE_READ((x), di)
81	#define PT_REGS_PARM2_CORE(x) BPF_CORE_READ((x), si)
82	#define PT_REGS_PARM3_CORE(x) BPF_CORE_READ((x), dx)
83	#define PT_REGS_PARM4_CORE(x) BPF_CORE_READ((x), cx)
84	#define PT_REGS_PARM5_CORE(x) BPF_CORE_READ((x), r8)
85	#define PT_REGS_RET_CORE(x) BPF_CORE_READ((x), sp)
86	#define PT_REGS_FP_CORE(x) BPF_CORE_READ((x), bp)
87	#define PT_REGS_RC_CORE(x) BPF_CORE_READ((x), ax)
88	#define PT_REGS_SP_CORE(x) BPF_CORE_READ((x), sp)
89	#define PT_REGS_IP_CORE(x) BPF_CORE_READ((x), ip)
90		79
91	#else	80	#else
92		81
93	#ifdef __i386__	82	#ifdef __i386__
94	/* i386 kernel is built with -mregparm=3 */
95	#define PT_REGS_PARM1(x) ((x)->eax)
96	#define PT_REGS_PARM2(x) ((x)->edx)
97	#define PT_REGS_PARM3(x) ((x)->ecx)
98	#define PT_REGS_PARM4(x) 0
99	#define PT_REGS_PARM5(x) 0
100	#define PT_REGS_RET(x) ((x)->esp)
101	#define PT_REGS_FP(x) ((x)->ebp)
102	#define PT_REGS_RC(x) ((x)->eax)
103	#define PT_REGS_SP(x) ((x)->esp)
104	#define PT_REGS_IP(x) ((x)->eip)
105
106	#define PT_REGS_PARM1_CORE(x) BPF_CORE_READ((x), eax)
107	#define PT_REGS_PARM2_CORE(x) BPF_CORE_READ((x), edx)
108	#define PT_REGS_PARM3_CORE(x) BPF_CORE_READ((x), ecx)
109	#define PT_REGS_PARM4_CORE(x) 0
110	#define PT_REGS_PARM5_CORE(x) 0
111	#define PT_REGS_RET_CORE(x) BPF_CORE_READ((x), esp)
112	#define PT_REGS_FP_CORE(x) BPF_CORE_READ((x), ebp)
113	#define PT_REGS_RC_CORE(x) BPF_CORE_READ((x), eax)
114	#define PT_REGS_SP_CORE(x) BPF_CORE_READ((x), esp)
115	#define PT_REGS_IP_CORE(x) BPF_CORE_READ((x), eip)
116
117	#else
118		83
119	#define PT_REGS_PARM1(x) ((x)->rdi)	84	#define __PT_PARM1_REG eax
120	#define PT_REGS_PARM2(x) ((x)->rsi)	85	#define __PT_PARM2_REG edx
121	#define PT_REGS_PARM3(x) ((x)->rdx)	86	#define __PT_PARM3_REG ecx
122	#define PT_REGS_PARM4(x) ((x)->rcx)	87	/* i386 kernel is built with -mregparm=3 */
123	#define PT_REGS_PARM5(x) ((x)->r8)	88	#define __PT_PARM4_REG __unsupported__
124	#define PT_REGS_RET(x) ((x)->rsp)	89	#define __PT_PARM5_REG __unsupported__
125	#define PT_REGS_FP(x) ((x)->rbp)	90	#define __PT_RET_REG esp
126	#define PT_REGS_RC(x) ((x)->rax)	91	#define __PT_FP_REG ebp
127	#define PT_REGS_SP(x) ((x)->rsp)	92	#define __PT_RC_REG eax
128	#define PT_REGS_IP(x) ((x)->rip)	93	#define __PT_SP_REG esp
129		94	#define __PT_IP_REG eip
130	#define PT_REGS_PARM1_CORE(x) BPF_CORE_READ((x), rdi)	95
131	#define PT_REGS_PARM2_CORE(x) BPF_CORE_READ((x), rsi)	96	#else /* __i386__ */
132	#define PT_REGS_PARM3_CORE(x) BPF_CORE_READ((x), rdx)	97
133	#define PT_REGS_PARM4_CORE(x) BPF_CORE_READ((x), rcx)	98	#define __PT_PARM1_REG rdi
134	#define PT_REGS_PARM5_CORE(x) BPF_CORE_READ((x), r8)	99	#define __PT_PARM2_REG rsi
135	#define PT_REGS_RET_CORE(x) BPF_CORE_READ((x), rsp)	100	#define __PT_PARM3_REG rdx
136	#define PT_REGS_FP_CORE(x) BPF_CORE_READ((x), rbp)	101	#define __PT_PARM4_REG rcx
137	#define PT_REGS_RC_CORE(x) BPF_CORE_READ((x), rax)	102	#define __PT_PARM5_REG r8
138	#define PT_REGS_SP_CORE(x) BPF_CORE_READ((x), rsp)	103	#define __PT_RET_REG rsp
139	#define PT_REGS_IP_CORE(x) BPF_CORE_READ((x), rip)	104	#define __PT_FP_REG rbp
140		105	#define __PT_RC_REG rax
141	#endif	106	#define __PT_SP_REG rsp
142	#endif	107	#define __PT_IP_REG rip
		108
		109	#endif /* __i386__ */
		110
		111	#endif /* __KERNEL__ \|\| __VMLINUX_H__ */
143		112
144	#elif defined(bpf_target_s390)	113	#elif defined(bpf_target_s390)
145		114
146	/* s390 provides user_pt_regs instead of struct pt_regs to userspace */	115	/* s390 provides user_pt_regs instead of struct pt_regs to userspace */
147	struct pt_regs;	116	#define __PT_REGS_CAST(x) ((const user_pt_regs *)(x))
148	#define PT_REGS_S390 const volatile user_pt_regs	117	#define __PT_PARM1_REG gprs[2]
149	#define PT_REGS_PARM1(x) (((PT_REGS_S390 *)(x))->gprs[2])	118	#define __PT_PARM2_REG gprs[3]
150	#define PT_REGS_PARM2(x) (((PT_REGS_S390 *)(x))->gprs[3])	119	#define __PT_PARM3_REG gprs[4]
151	#define PT_REGS_PARM3(x) (((PT_REGS_S390 *)(x))->gprs[4])	120	#define __PT_PARM4_REG gprs[5]
152	#define PT_REGS_PARM4(x) (((PT_REGS_S390 *)(x))->gprs[5])	121	#define __PT_PARM5_REG gprs[6]
153	#define PT_REGS_PARM5(x) (((PT_REGS_S390 *)(x))->gprs[6])	122	#define __PT_RET_REG grps[14]
154	#define PT_REGS_RET(x) (((PT_REGS_S390 *)(x))->gprs[14])	123	#define __PT_FP_REG gprs[11] /* Works only with CONFIG_FRAME_POINTER */
155	/* Works only with CONFIG_FRAME_POINTER */	124	#define __PT_RC_REG gprs[2]
156	#define PT_REGS_FP(x) (((PT_REGS_S390 *)(x))->gprs[11])	125	#define __PT_SP_REG gprs[15]
157	#define PT_REGS_RC(x) (((PT_REGS_S390 *)(x))->gprs[2])	126	#define __PT_IP_REG psw.addr
158	#define PT_REGS_SP(x) (((PT_REGS_S390 *)(x))->gprs[15])
159	#define PT_REGS_IP(x) (((PT_REGS_S390 *)(x))->psw.addr)
160
161	#define PT_REGS_PARM1_CORE(x) BPF_CORE_READ((PT_REGS_S390 *)(x), gprs[2])
162	#define PT_REGS_PARM2_CORE(x) BPF_CORE_READ((PT_REGS_S390 *)(x), gprs[3])
163	#define PT_REGS_PARM3_CORE(x) BPF_CORE_READ((PT_REGS_S390 *)(x), gprs[4])
164	#define PT_REGS_PARM4_CORE(x) BPF_CORE_READ((PT_REGS_S390 *)(x), gprs[5])
165	#define PT_REGS_PARM5_CORE(x) BPF_CORE_READ((PT_REGS_S390 *)(x), gprs[6])
166	#define PT_REGS_RET_CORE(x) BPF_CORE_READ((PT_REGS_S390 *)(x), gprs[14])
167	#define PT_REGS_FP_CORE(x) BPF_CORE_READ((PT_REGS_S390 *)(x), gprs[11])
168	#define PT_REGS_RC_CORE(x) BPF_CORE_READ((PT_REGS_S390 *)(x), gprs[2])
169	#define PT_REGS_SP_CORE(x) BPF_CORE_READ((PT_REGS_S390 *)(x), gprs[15])
170	#define PT_REGS_IP_CORE(x) BPF_CORE_READ((PT_REGS_S390 *)(x), psw.addr)
171		127
172	#elif defined(bpf_target_arm)	128	#elif defined(bpf_target_arm)
173		129
174	#define PT_REGS_PARM1(x) ((x)->uregs[0])	130	#define __PT_PARM1_REG uregs[0]
175	#define PT_REGS_PARM2(x) ((x)->uregs[1])	131	#define __PT_PARM2_REG uregs[1]
176	#define PT_REGS_PARM3(x) ((x)->uregs[2])	132	#define __PT_PARM3_REG uregs[2]
177	#define PT_REGS_PARM4(x) ((x)->uregs[3])	133	#define __PT_PARM4_REG uregs[3]
178	#define PT_REGS_PARM5(x) ((x)->uregs[4])	134	#define __PT_PARM5_REG uregs[4]
179	#define PT_REGS_RET(x) ((x)->uregs[14])	135	#define __PT_RET_REG uregs[14]
180	#define PT_REGS_FP(x) ((x)->uregs[11]) /* Works only with CONFIG_FRAME_POINTER */	136	#define __PT_FP_REG uregs[11] /* Works only with CONFIG_FRAME_POINTER */
181	#define PT_REGS_RC(x) ((x)->uregs[0])	137	#define __PT_RC_REG uregs[0]
182	#define PT_REGS_SP(x) ((x)->uregs[13])	138	#define __PT_SP_REG uregs[13]
183	#define PT_REGS_IP(x) ((x)->uregs[12])	139	#define __PT_IP_REG uregs[12]
184
185	#define PT_REGS_PARM1_CORE(x) BPF_CORE_READ((x), uregs[0])
186	#define PT_REGS_PARM2_CORE(x) BPF_CORE_READ((x), uregs[1])
187	#define PT_REGS_PARM3_CORE(x) BPF_CORE_READ((x), uregs[2])
188	#define PT_REGS_PARM4_CORE(x) BPF_CORE_READ((x), uregs[3])
189	#define PT_REGS_PARM5_CORE(x) BPF_CORE_READ((x), uregs[4])
190	#define PT_REGS_RET_CORE(x) BPF_CORE_READ((x), uregs[14])
191	#define PT_REGS_FP_CORE(x) BPF_CORE_READ((x), uregs[11])
192	#define PT_REGS_RC_CORE(x) BPF_CORE_READ((x), uregs[0])
193	#define PT_REGS_SP_CORE(x) BPF_CORE_READ((x), uregs[13])
194	#define PT_REGS_IP_CORE(x) BPF_CORE_READ((x), uregs[12])
195		140
196	#elif defined(bpf_target_arm64)	141	#elif defined(bpf_target_arm64)
197		142
198	/* arm64 provides struct user_pt_regs instead of struct pt_regs to userspace */	143	/* arm64 provides struct user_pt_regs instead of struct pt_regs to userspace */
199	struct pt_regs;	144	#define __PT_REGS_CAST(x) ((const struct user_pt_regs *)(x))
200	#define PT_REGS_ARM64 const volatile struct user_pt_regs	145	#define __PT_PARM1_REG regs[0]
201	#define PT_REGS_PARM1(x) (((PT_REGS_ARM64 *)(x))->regs[0])	146	#define __PT_PARM2_REG regs[1]
202	#define PT_REGS_PARM2(x) (((PT_REGS_ARM64 *)(x))->regs[1])	147	#define __PT_PARM3_REG regs[2]
203	#define PT_REGS_PARM3(x) (((PT_REGS_ARM64 *)(x))->regs[2])	148	#define __PT_PARM4_REG regs[3]
204	#define PT_REGS_PARM4(x) (((PT_REGS_ARM64 *)(x))->regs[3])	149	#define __PT_PARM5_REG regs[4]
205	#define PT_REGS_PARM5(x) (((PT_REGS_ARM64 *)(x))->regs[4])	150	#define __PT_RET_REG regs[30]
206	#define PT_REGS_RET(x) (((PT_REGS_ARM64 *)(x))->regs[30])	151	#define __PT_FP_REG regs[29] /* Works only with CONFIG_FRAME_POINTER */
207	/* Works only with CONFIG_FRAME_POINTER */	152	#define __PT_RC_REG regs[0]
208	#define PT_REGS_FP(x) (((PT_REGS_ARM64 *)(x))->regs[29])	153	#define __PT_SP_REG sp
209	#define PT_REGS_RC(x) (((PT_REGS_ARM64 *)(x))->regs[0])	154	#define __PT_IP_REG pc
210	#define PT_REGS_SP(x) (((PT_REGS_ARM64 *)(x))->sp)
211	#define PT_REGS_IP(x) (((PT_REGS_ARM64 *)(x))->pc)
212
213	#define PT_REGS_PARM1_CORE(x) BPF_CORE_READ((PT_REGS_ARM64 *)(x), regs[0])
214	#define PT_REGS_PARM2_CORE(x) BPF_CORE_READ((PT_REGS_ARM64 *)(x), regs[1])
215	#define PT_REGS_PARM3_CORE(x) BPF_CORE_READ((PT_REGS_ARM64 *)(x), regs[2])
216	#define PT_REGS_PARM4_CORE(x) BPF_CORE_READ((PT_REGS_ARM64 *)(x), regs[3])
217	#define PT_REGS_PARM5_CORE(x) BPF_CORE_READ((PT_REGS_ARM64 *)(x), regs[4])
218	#define PT_REGS_RET_CORE(x) BPF_CORE_READ((PT_REGS_ARM64 *)(x), regs[30])
219	#define PT_REGS_FP_CORE(x) BPF_CORE_READ((PT_REGS_ARM64 *)(x), regs[29])
220	#define PT_REGS_RC_CORE(x) BPF_CORE_READ((PT_REGS_ARM64 *)(x), regs[0])
221	#define PT_REGS_SP_CORE(x) BPF_CORE_READ((PT_REGS_ARM64 *)(x), sp)
222	#define PT_REGS_IP_CORE(x) BPF_CORE_READ((PT_REGS_ARM64 *)(x), pc)
223		155
224	#elif defined(bpf_target_mips)	156	#elif defined(bpf_target_mips)
225		157
226	#define PT_REGS_PARM1(x) ((x)->regs[4])	158	#define __PT_PARM1_REG regs[4]
227	#define PT_REGS_PARM2(x) ((x)->regs[5])	159	#define __PT_PARM2_REG regs[5]
228	#define PT_REGS_PARM3(x) ((x)->regs[6])	160	#define __PT_PARM3_REG regs[6]
229	#define PT_REGS_PARM4(x) ((x)->regs[7])	161	#define __PT_PARM4_REG regs[7]
230	#define PT_REGS_PARM5(x) ((x)->regs[8])	162	#define __PT_PARM5_REG regs[8]
231	#define PT_REGS_RET(x) ((x)->regs[31])	163	#define __PT_RET_REG regs[31]
232	#define PT_REGS_FP(x) ((x)->regs[30]) /* Works only with CONFIG_FRAME_POINTER */	164	#define __PT_FP_REG regs[30] /* Works only with CONFIG_FRAME_POINTER */
233	#define PT_REGS_RC(x) ((x)->regs[2])	165	#define __PT_RC_REG regs[2]
234	#define PT_REGS_SP(x) ((x)->regs[29])	166	#define __PT_SP_REG regs[29]
235	#define PT_REGS_IP(x) ((x)->cp0_epc)	167	#define __PT_IP_REG cp0_epc
236
237	#define PT_REGS_PARM1_CORE(x) BPF_CORE_READ((x), regs[4])
238	#define PT_REGS_PARM2_CORE(x) BPF_CORE_READ((x), regs[5])
239	#define PT_REGS_PARM3_CORE(x) BPF_CORE_READ((x), regs[6])
240	#define PT_REGS_PARM4_CORE(x) BPF_CORE_READ((x), regs[7])
241	#define PT_REGS_PARM5_CORE(x) BPF_CORE_READ((x), regs[8])
242	#define PT_REGS_RET_CORE(x) BPF_CORE_READ((x), regs[31])
243	#define PT_REGS_FP_CORE(x) BPF_CORE_READ((x), regs[30])
244	#define PT_REGS_RC_CORE(x) BPF_CORE_READ((x), regs[2])
245	#define PT_REGS_SP_CORE(x) BPF_CORE_READ((x), regs[29])
246	#define PT_REGS_IP_CORE(x) BPF_CORE_READ((x), cp0_epc)
247		168
248	#elif defined(bpf_target_powerpc)	169	#elif defined(bpf_target_powerpc)
249		170
250	#define PT_REGS_PARM1(x) ((x)->gpr[3])	171	#define __PT_PARM1_REG gpr[3]
251	#define PT_REGS_PARM2(x) ((x)->gpr[4])	172	#define __PT_PARM2_REG gpr[4]
252	#define PT_REGS_PARM3(x) ((x)->gpr[5])	173	#define __PT_PARM3_REG gpr[5]
253	#define PT_REGS_PARM4(x) ((x)->gpr[6])	174	#define __PT_PARM4_REG gpr[6]
254	#define PT_REGS_PARM5(x) ((x)->gpr[7])	175	#define __PT_PARM5_REG gpr[7]
255	#define PT_REGS_RC(x) ((x)->gpr[3])	176	#define __PT_RET_REG regs[31]
256	#define PT_REGS_SP(x) ((x)->sp)	177	#define __PT_FP_REG __unsupported__
257	#define PT_REGS_IP(x) ((x)->nip)	178	#define __PT_RC_REG gpr[3]
258		179	#define __PT_SP_REG sp
259	#define PT_REGS_PARM1_CORE(x) BPF_CORE_READ((x), gpr[3])	180	#define __PT_IP_REG nip
260	#define PT_REGS_PARM2_CORE(x) BPF_CORE_READ((x), gpr[4])
261	#define PT_REGS_PARM3_CORE(x) BPF_CORE_READ((x), gpr[5])
262	#define PT_REGS_PARM4_CORE(x) BPF_CORE_READ((x), gpr[6])
263	#define PT_REGS_PARM5_CORE(x) BPF_CORE_READ((x), gpr[7])
264	#define PT_REGS_RC_CORE(x) BPF_CORE_READ((x), gpr[3])
265	#define PT_REGS_SP_CORE(x) BPF_CORE_READ((x), sp)
266	#define PT_REGS_IP_CORE(x) BPF_CORE_READ((x), nip)
267		181
268	#elif defined(bpf_target_sparc)	182	#elif defined(bpf_target_sparc)
269		183
270	#define PT_REGS_PARM1(x) ((x)->u_regs[UREG_I0])	184	#define __PT_PARM1_REG u_regs[UREG_I0]
271	#define PT_REGS_PARM2(x) ((x)->u_regs[UREG_I1])	185	#define __PT_PARM2_REG u_regs[UREG_I1]
272	#define PT_REGS_PARM3(x) ((x)->u_regs[UREG_I2])	186	#define __PT_PARM3_REG u_regs[UREG_I2]
273	#define PT_REGS_PARM4(x) ((x)->u_regs[UREG_I3])	187	#define __PT_PARM4_REG u_regs[UREG_I3]
274	#define PT_REGS_PARM5(x) ((x)->u_regs[UREG_I4])	188	#define __PT_PARM5_REG u_regs[UREG_I4]
275	#define PT_REGS_RET(x) ((x)->u_regs[UREG_I7])	189	#define __PT_RET_REG u_regs[UREG_I7]
276	#define PT_REGS_RC(x) ((x)->u_regs[UREG_I0])	190	#define __PT_FP_REG __unsupported__
277	#define PT_REGS_SP(x) ((x)->u_regs[UREG_FP])	191	#define __PT_RC_REG u_regs[UREG_I0]
278		192	#define __PT_SP_REG u_regs[UREG_FP]
279	#define PT_REGS_PARM1_CORE(x) BPF_CORE_READ((x), u_regs[UREG_I0])
280	#define PT_REGS_PARM2_CORE(x) BPF_CORE_READ((x), u_regs[UREG_I1])
281	#define PT_REGS_PARM3_CORE(x) BPF_CORE_READ((x), u_regs[UREG_I2])
282	#define PT_REGS_PARM4_CORE(x) BPF_CORE_READ((x), u_regs[UREG_I3])
283	#define PT_REGS_PARM5_CORE(x) BPF_CORE_READ((x), u_regs[UREG_I4])
284	#define PT_REGS_RET_CORE(x) BPF_CORE_READ((x), u_regs[UREG_I7])
285	#define PT_REGS_RC_CORE(x) BPF_CORE_READ((x), u_regs[UREG_I0])
286	#define PT_REGS_SP_CORE(x) BPF_CORE_READ((x), u_regs[UREG_FP])
287
288	/* Should this also be a bpf_target check for the sparc case? */	193	/* Should this also be a bpf_target check for the sparc case? */
289	#if defined(__arch64__)	194	#if defined(__arch64__)
290	#define PT_REGS_IP(x) ((x)->tpc)	195	#define __PT_IP_REG tpc
291	#define PT_REGS_IP_CORE(x) BPF_CORE_READ((x), tpc)
292	#else	196	#else
293	#define PT_REGS_IP(x) ((x)->pc)	197	#define __PT_IP_REG pc
294	#define PT_REGS_IP_CORE(x) BPF_CORE_READ((x), pc)
295	#endif	198	#endif
296		199
297	#elif defined(bpf_target_riscv)	200	#elif defined(bpf_target_riscv)
298		201
		202	#define __PT_REGS_CAST(x) ((const struct user_regs_struct *)(x))
		203	#define __PT_PARM1_REG a0
		204	#define __PT_PARM2_REG a1
		205	#define __PT_PARM3_REG a2
		206	#define __PT_PARM4_REG a3
		207	#define __PT_PARM5_REG a4
		208	#define __PT_RET_REG ra
		209	#define __PT_FP_REG fp
		210	#define __PT_RC_REG a5
		211	#define __PT_SP_REG sp
		212	#define __PT_IP_REG epc
		213
		214	#endif
		215
		216	#if defined(bpf_target_defined)
		217
299	struct pt_regs;	218	struct pt_regs;
300	#define PT_REGS_RV const volatile struct user_regs_struct
301	#define PT_REGS_PARM1(x) (((PT_REGS_RV *)(x))->a0)
302	#define PT_REGS_PARM2(x) (((PT_REGS_RV *)(x))->a1)
303	#define PT_REGS_PARM3(x) (((PT_REGS_RV *)(x))->a2)
304	#define PT_REGS_PARM4(x) (((PT_REGS_RV *)(x))->a3)
305	#define PT_REGS_PARM5(x) (((PT_REGS_RV *)(x))->a4)
306	#define PT_REGS_RET(x) (((PT_REGS_RV *)(x))->ra)
307	#define PT_REGS_FP(x) (((PT_REGS_RV *)(x))->s5)
308	#define PT_REGS_RC(x) (((PT_REGS_RV *)(x))->a5)
309	#define PT_REGS_SP(x) (((PT_REGS_RV *)(x))->sp)
310	#define PT_REGS_IP(x) (((PT_REGS_RV *)(x))->epc)
311
312	#define PT_REGS_PARM1_CORE(x) BPF_CORE_READ((PT_REGS_RV *)(x), a0)
313	#define PT_REGS_PARM2_CORE(x) BPF_CORE_READ((PT_REGS_RV *)(x), a1)
314	#define PT_REGS_PARM3_CORE(x) BPF_CORE_READ((PT_REGS_RV *)(x), a2)
315	#define PT_REGS_PARM4_CORE(x) BPF_CORE_READ((PT_REGS_RV *)(x), a3)
316	#define PT_REGS_PARM5_CORE(x) BPF_CORE_READ((PT_REGS_RV *)(x), a4)
317	#define PT_REGS_RET_CORE(x) BPF_CORE_READ((PT_REGS_RV *)(x), ra)
318	#define PT_REGS_FP_CORE(x) BPF_CORE_READ((PT_REGS_RV *)(x), fp)
319	#define PT_REGS_RC_CORE(x) BPF_CORE_READ((PT_REGS_RV *)(x), a5)
320	#define PT_REGS_SP_CORE(x) BPF_CORE_READ((PT_REGS_RV *)(x), sp)
321	#define PT_REGS_IP_CORE(x) BPF_CORE_READ((PT_REGS_RV *)(x), epc)
322		219
		220	/* allow some architecutres to override `struct pt_regs` */
		221	#ifndef __PT_REGS_CAST
		222	#define __PT_REGS_CAST(x) (x)
323	#endif	223	#endif
324		224
		225	#define PT_REGS_PARM1(x) (__PT_REGS_CAST(x)->__PT_PARM1_REG)
		226	#define PT_REGS_PARM2(x) (__PT_REGS_CAST(x)->__PT_PARM2_REG)
		227	#define PT_REGS_PARM3(x) (__PT_REGS_CAST(x)->__PT_PARM3_REG)
		228	#define PT_REGS_PARM4(x) (__PT_REGS_CAST(x)->__PT_PARM4_REG)
		229	#define PT_REGS_PARM5(x) (__PT_REGS_CAST(x)->__PT_PARM5_REG)
		230	#define PT_REGS_RET(x) (__PT_REGS_CAST(x)->__PT_RET_REG)
		231	#define PT_REGS_FP(x) (__PT_REGS_CAST(x)->__PT_FP_REG)
		232	#define PT_REGS_RC(x) (__PT_REGS_CAST(x)->__PT_RC_REG)
		233	#define PT_REGS_SP(x) (__PT_REGS_CAST(x)->__PT_SP_REG)
		234	#define PT_REGS_IP(x) (__PT_REGS_CAST(x)->__PT_IP_REG)
		235
		236	#define PT_REGS_PARM1_CORE(x) BPF_CORE_READ(__PT_REGS_CAST(x), __PT_PARM1_REG)
		237	#define PT_REGS_PARM2_CORE(x) BPF_CORE_READ(__PT_REGS_CAST(x), __PT_PARM2_REG)
		238	#define PT_REGS_PARM3_CORE(x) BPF_CORE_READ(__PT_REGS_CAST(x), __PT_PARM3_REG)
		239	#define PT_REGS_PARM4_CORE(x) BPF_CORE_READ(__PT_REGS_CAST(x), __PT_PARM4_REG)
		240	#define PT_REGS_PARM5_CORE(x) BPF_CORE_READ(__PT_REGS_CAST(x), __PT_PARM5_REG)
		241	#define PT_REGS_RET_CORE(x) BPF_CORE_READ(__PT_REGS_CAST(x), __PT_RET_REG)
		242	#define PT_REGS_FP_CORE(x) BPF_CORE_READ(__PT_REGS_CAST(x), __PT_FP_REG)
		243	#define PT_REGS_RC_CORE(x) BPF_CORE_READ(__PT_REGS_CAST(x), __PT_RC_REG)
		244	#define PT_REGS_SP_CORE(x) BPF_CORE_READ(__PT_REGS_CAST(x), __PT_SP_REG)
		245	#define PT_REGS_IP_CORE(x) BPF_CORE_READ(__PT_REGS_CAST(x), __PT_IP_REG)
		246
325	#if defined(bpf_target_powerpc)	247	#if defined(bpf_target_powerpc)
		248
326	#define BPF_KPROBE_READ_RET_IP(ip, ctx) ({ (ip) = (ctx)->link; })	249	#define BPF_KPROBE_READ_RET_IP(ip, ctx) ({ (ip) = (ctx)->link; })
327	#define BPF_KRETPROBE_READ_RET_IP BPF_KPROBE_READ_RET_IP	250	#define BPF_KRETPROBE_READ_RET_IP BPF_KPROBE_READ_RET_IP
		251
328	#elif defined(bpf_target_sparc)	252	#elif defined(bpf_target_sparc)
		253
329	#define BPF_KPROBE_READ_RET_IP(ip, ctx) ({ (ip) = PT_REGS_RET(ctx); })	254	#define BPF_KPROBE_READ_RET_IP(ip, ctx) ({ (ip) = PT_REGS_RET(ctx); })
330	#define BPF_KRETPROBE_READ_RET_IP BPF_KPROBE_READ_RET_IP	255	#define BPF_KRETPROBE_READ_RET_IP BPF_KPROBE_READ_RET_IP
331	#elif defined(bpf_target_defined)	256
		257	#else
		258
332	#define BPF_KPROBE_READ_RET_IP(ip, ctx) \	259	#define BPF_KPROBE_READ_RET_IP(ip, ctx) \
333	({ bpf_probe_read_kernel(&(ip), sizeof(ip), (void *)PT_REGS_RET(ctx)); })	260	({ bpf_probe_read_kernel(&(ip), sizeof(ip), (void *)PT_REGS_RET(ctx)); })
334	#define BPF_KRETPROBE_READ_RET_IP(ip, ctx) \	261	#define BPF_KRETPROBE_READ_RET_IP(ip, ctx) \
335	({ bpf_probe_read_kernel(&(ip), sizeof(ip), \	262	({ bpf_probe_read_kernel(&(ip), sizeof(ip), (void *)(PT_REGS_FP(ctx) + sizeof(ip))); })
336	(void *)(PT_REGS_FP(ctx) + sizeof(ip))); })	263
337	#endif	264	#endif
338		265
339	#if !defined(bpf_target_defined)	266	#else /* defined(bpf_target_defined) */
340		267
341	#define PT_REGS_PARM1(x) ({ _Pragma(__BPF_TARGET_MISSING); 0l; })	268	#define PT_REGS_PARM1(x) ({ _Pragma(__BPF_TARGET_MISSING); 0l; })
342	#define PT_REGS_PARM2(x) ({ _Pragma(__BPF_TARGET_MISSING); 0l; })	269	#define PT_REGS_PARM2(x) ({ _Pragma(__BPF_TARGET_MISSING); 0l; })
@@ -363,7 +290,7 @@ struct pt_regs; · 20 unmodified lines
363	#define BPF_KPROBE_READ_RET_IP(ip, ctx) ({ _Pragma(__BPF_TARGET_MISSING); 0l; })	290	#define BPF_KPROBE_READ_RET_IP(ip, ctx) ({ _Pragma(__BPF_TARGET_MISSING); 0l; })
364	#define BPF_KRETPROBE_READ_RET_IP(ip, ctx) ({ _Pragma(__BPF_TARGET_MISSING); 0l; })	291	#define BPF_KRETPROBE_READ_RET_IP(ip, ctx) ({ _Pragma(__BPF_TARGET_MISSING); 0l; })
365		292
366	#endif /* !defined(bpf_target_defined) */	293	#endif /* defined(bpf_target_defined) */
367		294
368	#ifndef ___bpf_concat	295	#ifndef ___bpf_concat
369	#define ___bpf_concat(a, b) a ## b	296	#define ___bpf_concat(a, b) a ## b
@@ -375,25 +302,23 @@ struct pt_regs; · 5 unmodified lines
375	#define ___bpf_nth(_, _1, _2, _3, _4, _5, _6, _7, _8, _9, _a, _b, _c, N, ...) N	302	#define ___bpf_nth(_, _1, _2, _3, _4, _5, _6, _7, _8, _9, _a, _b, _c, N, ...) N
376	#endif	303	#endif
377	#ifndef ___bpf_narg	304	#ifndef ___bpf_narg
378	#define ___bpf_narg(...) \	305	#define ___bpf_narg(...) ___bpf_nth(_, ##__VA_ARGS__, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0)
379	___bpf_nth(_, ##__VA_ARGS__, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0)
380	#endif	306	#endif
381		307
382	#define ___bpf_ctx_cast0() ctx	308	#define ___bpf_ctx_cast0() ctx
383	#define ___bpf_ctx_cast1(x) ___bpf_ctx_cast0(), (void *)ctx[0]	309	#define ___bpf_ctx_cast1(x) ___bpf_ctx_cast0(), (void *)ctx[0]
384	#define ___bpf_ctx_cast2(x, args...) ___bpf_ctx_cast1(args), (void *)ctx[1]	310	#define ___bpf_ctx_cast2(x, args...) ___bpf_ctx_cast1(args), (void *)ctx[1]
385	#define ___bpf_ctx_cast3(x, args...) ___bpf_ctx_cast2(args), (void *)ctx[2]	311	#define ___bpf_ctx_cast3(x, args...) ___bpf_ctx_cast2(args), (void *)ctx[2]
386	#define ___bpf_ctx_cast4(x, args...) ___bpf_ctx_cast3(args), (void *)ctx[3]	312	#define ___bpf_ctx_cast4(x, args...) ___bpf_ctx_cast3(args), (void *)ctx[3]
387	#define ___bpf_ctx_cast5(x, args...) ___bpf_ctx_cast4(args), (void *)ctx[4]	313	#define ___bpf_ctx_cast5(x, args...) ___bpf_ctx_cast4(args), (void *)ctx[4]
388	#define ___bpf_ctx_cast6(x, args...) ___bpf_ctx_cast5(args), (void *)ctx[5]	314	#define ___bpf_ctx_cast6(x, args...) ___bpf_ctx_cast5(args), (void *)ctx[5]
389	#define ___bpf_ctx_cast7(x, args...) ___bpf_ctx_cast6(args), (void *)ctx[6]	315	#define ___bpf_ctx_cast7(x, args...) ___bpf_ctx_cast6(args), (void *)ctx[6]
390	#define ___bpf_ctx_cast8(x, args...) ___bpf_ctx_cast7(args), (void *)ctx[7]	316	#define ___bpf_ctx_cast8(x, args...) ___bpf_ctx_cast7(args), (void *)ctx[7]
391	#define ___bpf_ctx_cast9(x, args...) ___bpf_ctx_cast8(args), (void *)ctx[8]	317	#define ___bpf_ctx_cast9(x, args...) ___bpf_ctx_cast8(args), (void *)ctx[8]
392	#define ___bpf_ctx_cast10(x, args...) ___bpf_ctx_cast9(args), (void *)ctx[9]	318	#define ___bpf_ctx_cast10(x, args...) ___bpf_ctx_cast9(args), (void *)ctx[9]
393	#define ___bpf_ctx_cast11(x, args...) ___bpf_ctx_cast10(args), (void *)ctx[10]	319	#define ___bpf_ctx_cast11(x, args...) ___bpf_ctx_cast10(args), (void *)ctx[10]
394	#define ___bpf_ctx_cast12(x, args...) ___bpf_ctx_cast11(args), (void *)ctx[11]	320	#define ___bpf_ctx_cast12(x, args...) ___bpf_ctx_cast11(args), (void *)ctx[11]
395	#define ___bpf_ctx_cast(args...) \	321	#define ___bpf_ctx_cast(args...) ___bpf_apply(___bpf_ctx_cast, ___bpf_narg(args))(args)
396	___bpf_apply(___bpf_ctx_cast, ___bpf_narg(args))(args)
397		322
398	/*	323	/*
399	* BPF_PROG is a convenience wrapper for generic tp_btf/fentry/fexit and	324	* BPF_PROG is a convenience wrapper for generic tp_btf/fentry/fexit and
@@ -426,19 +351,13 @@ ____##name(unsigned long long *ctx, ##args) · 26 unmodified lines
426		351
427	struct pt_regs;	352	struct pt_regs;
428		353
429	#define ___bpf_kprobe_args0() ctx	354	#define ___bpf_kprobe_args0() ctx
430	#define ___bpf_kprobe_args1(x) \	355	#define ___bpf_kprobe_args1(x) ___bpf_kprobe_args0(), (void *)PT_REGS_PARM1(ctx)
431	___bpf_kprobe_args0(), (void *)PT_REGS_PARM1(ctx)	356	#define ___bpf_kprobe_args2(x, args...) ___bpf_kprobe_args1(args), (void *)PT_REGS_PARM2(ctx)
432	#define ___bpf_kprobe_args2(x, args...) \	357	#define ___bpf_kprobe_args3(x, args...) ___bpf_kprobe_args2(args), (void *)PT_REGS_PARM3(ctx)
433	___bpf_kprobe_args1(args), (void *)PT_REGS_PARM2(ctx)	358	#define ___bpf_kprobe_args4(x, args...) ___bpf_kprobe_args3(args), (void *)PT_REGS_PARM4(ctx)
434	#define ___bpf_kprobe_args3(x, args...) \	359	#define ___bpf_kprobe_args5(x, args...) ___bpf_kprobe_args4(args), (void *)PT_REGS_PARM5(ctx)
435	___bpf_kprobe_args2(args), (void *)PT_REGS_PARM3(ctx)	360	#define ___bpf_kprobe_args(args...) ___bpf_apply(___bpf_kprobe_args, ___bpf_narg(args))(args)
436	#define ___bpf_kprobe_args4(x, args...) \
437	___bpf_kprobe_args3(args), (void *)PT_REGS_PARM4(ctx)
438	#define ___bpf_kprobe_args5(x, args...) \
439	___bpf_kprobe_args4(args), (void *)PT_REGS_PARM5(ctx)
440	#define ___bpf_kprobe_args(args...) \
441	___bpf_apply(___bpf_kprobe_args, ___bpf_narg(args))(args)
442		361
443	/*	362	/*
444	* BPF_KPROBE serves the same purpose for kprobes as BPF_PROG for	363	* BPF_KPROBE serves the same purpose for kprobes as BPF_PROG for
@@ -464,11 +383,9 @@ typeof(name(0)) name(struct pt_regs *ctx) \ · 19 unmodified lines
464	static __attribute__((always_inline)) typeof(name(0)) \	383	static __attribute__((always_inline)) typeof(name(0)) \
465	____##name(struct pt_regs *ctx, ##args)	384	____##name(struct pt_regs *ctx, ##args)
466		385
467	#define ___bpf_kretprobe_args0() ctx	386	#define ___bpf_kretprobe_args0() ctx
468	#define ___bpf_kretprobe_args1(x) \	387	#define ___bpf_kretprobe_args1(x) ___bpf_kretprobe_args0(), (void *)PT_REGS_RC(ctx)
469	___bpf_kretprobe_args0(), (void *)PT_REGS_RC(ctx)	388	#define ___bpf_kretprobe_args(args...) ___bpf_apply(___bpf_kretprobe_args, ___bpf_narg(args))(args)
470	#define ___bpf_kretprobe_args(args...) \
471	___bpf_apply(___bpf_kretprobe_args, ___bpf_narg(args))(args)
472		389
473	/*	390	/*
474	* BPF_KRETPROBE is similar to BPF_KPROBE, except, it only provides optional	391	* BPF_KRETPROBE is similar to BPF_KPROBE, except, it only provides optional

tools/lib/bpf/btf.h+6−0

  *
  * The rest works just like in case of ___libbpf_override() usage with symbol
  * versioning.
+ *
+ * C++ compilers don't support __builtin_types_compatible_p(), so at least
+ * don't screw up compilation for them and let C++ users pick btf_dump__new
+ * vs btf_dump__new_deprecated explicitly.
  */
+#ifndef __cplusplus
 #define btf_dump__new(a1, a2, a3, a4) __builtin_choose_expr(				\
 	__builtin_types_compatible_p(typeof(a4), btf_dump_printf_fn_t) ||		\
 	__builtin_types_compatible_p(typeof(a4), void(void *, const char *, va_list)),	\
 	btf_dump__new_deprecated((void *)a1, (void *)a2, (void *)a3, (void *)a4),	\
 	btf_dump__new((void *)a1, (void *)a2, (void *)a3, (void *)a4))
+#endif
 LIBBPF_API void btf_dump__free(struct btf_dump *d);

tools/lib/bpf/btf_dump.c+2−2

@@ -2321,8 +2321,8 @@ int btf_dump__dump_type_data(struct btf_dump *d, __u32 id, · 2320 unmodified lines
2321	if (!opts->indent_str)	2321	if (!opts->indent_str)
2322	d->typed_dump->indent_str[0] = '\t';	2322	d->typed_dump->indent_str[0] = '\t';
2323	else	2323	else
2324	strncat(d->typed_dump->indent_str, opts->indent_str,	2324	libbpf_strlcpy(d->typed_dump->indent_str, opts->indent_str,
2325	sizeof(d->typed_dump->indent_str) - 1);	2325	sizeof(d->typed_dump->indent_str));
2326		2326
2327	d->typed_dump->compact = OPTS_GET(opts, compact, false);	2327	d->typed_dump->compact = OPTS_GET(opts, compact, false);
2328	d->typed_dump->skip_names = OPTS_GET(opts, skip_names, false);	2328	d->typed_dump->skip_names = OPTS_GET(opts, skip_names, false);

tools/lib/bpf/gen_loader.c+5−6

 {
 	int i;
-	if (nr_progs != gen->nr_progs || nr_maps != gen->nr_maps) {
+	if (nr_progs < gen->nr_progs || nr_maps != gen->nr_maps) {
-		pr_warn("progs/maps mismatch\n");
+		pr_warn("nr_progs %d/%d nr_maps %d/%d mismatch\n",
+			nr_progs, gen->nr_progs, nr_maps, gen->nr_maps);
 		gen->error = -EFAULT;
 		return gen->error;
 	}
 	attr.map_flags = map_attr->map_flags;
 	attr.map_extra = map_attr->map_extra;
 	if (map_name)
-		memcpy(attr.map_name, map_name,
+		libbpf_strlcpy(attr.map_name, map_name, sizeof(attr.map_name));
-		       min((unsigned)strlen(map_name), BPF_OBJ_NAME_LEN - 1));
 	attr.numa_node = map_attr->numa_node;
 	attr.map_ifindex = map_attr->map_ifindex;
 	attr.max_entries = max_entries;
 	core_relos = add_data(gen, gen->core_relos,
 			     attr.core_relo_cnt * attr.core_relo_rec_size);
-	memcpy(attr.prog_name, prog_name,
+	libbpf_strlcpy(attr.prog_name, prog_name, sizeof(attr.prog_name));
-	       min((unsigned)strlen(prog_name), BPF_OBJ_NAME_LEN - 1));
 	prog_load_attr = add_data(gen, &attr, attr_size);
 	/* populate union bpf_attr with a pointer to license */

tools/lib/bpf/libbpf.c+41−44

 #undef __S
 }
-enum kern_feature_id {
-	/* v4.14: kernel support for program & map names. */
-	FEAT_PROG_NAME,
-	/* v5.2: kernel support for global data sections. */
-	FEAT_GLOBAL_DATA,
-	/* BTF support */
-	FEAT_BTF,
-	/* BTF_KIND_FUNC and BTF_KIND_FUNC_PROTO support */
-	FEAT_BTF_FUNC,
-	/* BTF_KIND_VAR and BTF_KIND_DATASEC support */
-	FEAT_BTF_DATASEC,
-	/* BTF_FUNC_GLOBAL is supported */
-	FEAT_BTF_GLOBAL_FUNC,
-	/* BPF_F_MMAPABLE is supported for arrays */
-	FEAT_ARRAY_MMAP,
-	/* kernel support for expected_attach_type in BPF_PROG_LOAD */
-	FEAT_EXP_ATTACH_TYPE,
-	/* bpf_probe_read_{kernel,user}[_str] helpers */
-	FEAT_PROBE_READ_KERN,
-	/* BPF_PROG_BIND_MAP is supported */
-	FEAT_PROG_BIND_MAP,
-	/* Kernel support for module BTFs */
-	FEAT_MODULE_BTF,
-	/* BTF_KIND_FLOAT support */
-	FEAT_BTF_FLOAT,
-	/* BPF perf link support */
-	FEAT_PERF_LINK,
-	/* BTF_KIND_DECL_TAG support */
-	FEAT_BTF_DECL_TAG,
-	/* BTF_KIND_TYPE_TAG support */
-	FEAT_BTF_TYPE_TAG,
-	__FEAT_CNT,
-};
-static bool kernel_supports(const struct bpf_object *obj, enum kern_feature_id feat_id);
 enum reloc_type {
 	RELO_LD64,
 	RELO_CALL,
 	return 0;
 }
-static __u32 get_kernel_version(void)
+__u32 get_kernel_version(void)
 {
+	/* On Ubuntu LINUX_VERSION_CODE doesn't correspond to info.release,
+	 * but Ubuntu provides /proc/version_signature file, as described at
+	 * https://ubuntu.com/kernel, with an example contents below, which we
+	 * can use to get a proper LINUX_VERSION_CODE.
+	 *
+	 *   Ubuntu 5.4.0-12.15-generic 5.4.8
+	 *
+	 * In the above, 5.4.8 is what kernel is actually expecting, while
+	 * uname() call will return 5.4.0 in info.release.
+	 */
+	const char *ubuntu_kver_file = "/proc/version_signature";
 	__u32 major, minor, patch;
 	struct utsname info;
+	if (access(ubuntu_kver_file, R_OK) == 0) {
+		FILE *f;
+		f = fopen(ubuntu_kver_file, "r");
+		if (f) {
+			if (fscanf(f, "%*s %*s %d.%d.%d\n", &major, &minor, &patch) == 3) {
+				fclose(f);
+				return KERNEL_VERSION(major, minor, patch);
+			}
+			fclose(f);
+		}
+		/* something went wrong, fall back to uname() approach */
+	}
 	uname(&info);
 	if (sscanf(info.release, "%u.%u.%u", &major, &minor, &patch) != 3)
 		return 0;
 	strcpy(obj->path, path);
 	if (obj_name) {
-		strncpy(obj->name, obj_name, sizeof(obj->name) - 1);
+		libbpf_strlcpy(obj->name, obj_name, sizeof(obj->name));
-		obj->name[sizeof(obj->name) - 1] = 0;
 	} else {
 		/* Using basename() GNU version which doesn't modify arg. */
-		strncpy(obj->name, basename((void *)path),
+		libbpf_strlcpy(obj->name, basename((void *)path), sizeof(obj->name));
-			sizeof(obj->name) - 1);
 		end = strchr(obj->name, '.');
 		if (end)
 			*end = 0;
 static int
 bpf_object__init_license(struct bpf_object *obj, void *data, size_t size)
 {
-	memcpy(obj->license, data, min(size, sizeof(obj->license) - 1));
+	/* libbpf_strlcpy() only copies first N - 1 bytes, so size + 1 won't
+	 * go over allowed ELF data section buffer
+	 */
+	libbpf_strlcpy(obj->license, data, min(size + 1, sizeof(obj->license)));
 	pr_debug("license of %s is %s\n", obj->path, obj->license);
 	return 0;
 }
 	if (obj->gen_loader)
 		return 0;
+	ret = bump_rlimit_memlock();
+	if (ret)
+		pr_warn("Failed to bump RLIMIT_MEMLOCK (err = %d), you might need to do it explicitly!\n", ret);
 	/* make sure basic loading works */
 	ret = bpf_prog_load(BPF_PROG_TYPE_SOCKET_FILTER, NULL, "GPL", insns, insn_cnt, NULL);
 	if (ret < 0)
 	[FEAT_BTF_TYPE_TAG] = {
 		"BTF_KIND_TYPE_TAG support", probe_kern_btf_type_tag,
 	},
+	[FEAT_MEMCG_ACCOUNT] = {
+		"memcg-based memory accounting", probe_memcg_account,
+	},
 };
-static bool kernel_supports(const struct bpf_object *obj, enum kern_feature_id feat_id)
+bool kernel_supports(const struct bpf_object *obj, enum kern_feature_id feat_id)
 {
 	struct kern_feature_desc *feat = &feature_probes[feat_id];
 	int ret;
-	if (obj->gen_loader)
+	if (obj && obj->gen_loader)
 		/* To generate loader program assume the latest kernel
 		 * to avoid doing extra prog_load, map_create syscalls.
 		 */

tools/lib/bpf/libbpf.h+73−4

@@ -227,6 +227,7 @@ struct btf; · 226 unmodified lines
227	LIBBPF_API struct btf bpf_object__btf(const struct bpf_object obj);	227	LIBBPF_API struct btf bpf_object__btf(const struct bpf_object obj);
228	LIBBPF_API int bpf_object__btf_fd(const struct bpf_object *obj);	228	LIBBPF_API int bpf_object__btf_fd(const struct bpf_object *obj);
229		229
		230	LIBBPF_DEPRECATED_SINCE(0, 7, "use bpf_object__find_program_by_name() instead")
230	LIBBPF_API struct bpf_program *	231	LIBBPF_API struct bpf_program *
231	bpf_object__find_program_by_title(const struct bpf_object *obj,	232	bpf_object__find_program_by_title(const struct bpf_object *obj,
232	const char *title);	233	const char *title);
@@ -339,7 +340,31 @@ LIBBPF_DEPRECATED_SINCE(0, 7, "multi-instance bpf_program support is deprecated" · 106 unmodified lines
339	LIBBPF_API int bpf_program__unpin_instance(struct bpf_program *prog,	340	LIBBPF_API int bpf_program__unpin_instance(struct bpf_program *prog,
340	const char *path,	341	const char *path,
341	int instance);	342	int instance);
		343
		344	/**
		345	* @brief bpf_program__pin() pins the BPF program to a file
		346	* in the BPF FS specified by a path. This increments the programs
		347	* reference count, allowing it to stay loaded after the process
		348	* which loaded it has exited.
		349	*
		350	* @param prog BPF program to pin, must already be loaded
		351	* @param path file path in a BPF file system
		352	* @return 0, on success; negative error code, otherwise
		353	*/
342	LIBBPF_API int bpf_program__pin(struct bpf_program prog, const char path);	354	LIBBPF_API int bpf_program__pin(struct bpf_program prog, const char path);
		355
		356	/**
		357	* @brief bpf_program__unpin() unpins the BPF program from a file
		358	* in the BPFFS specified by a path. This decrements the programs
		359	* reference count.
		360	*
		361	* The file pinning the BPF program can also be unlinked by a different
		362	* process in which case this function will return an error.
		363	*
		364	* @param prog BPF program to unpin
		365	* @param path file path to the pin in a BPF file system
		366	* @return 0, on success; negative error code, otherwise
		367	*/
343	LIBBPF_API int bpf_program__unpin(struct bpf_program prog, const char path);	368	LIBBPF_API int bpf_program__unpin(struct bpf_program prog, const char path);
344	LIBBPF_API void bpf_program__unload(struct bpf_program *prog);	369	LIBBPF_API void bpf_program__unload(struct bpf_program *prog);
345		370
@@ -1027,13 +1052,57 @@ bpf_prog_linfo__lfind(const struct bpf_prog_linfo *prog_linfo, · 681 unmodified lines
1027	* user, causing subsequent probes to fail. In this case, the caller may want	1052	* user, causing subsequent probes to fail. In this case, the caller may want
1028	* to adjust that limit with setrlimit().	1053	* to adjust that limit with setrlimit().
1029	*/	1054	*/
1030	LIBBPF_API bool bpf_probe_prog_type(enum bpf_prog_type prog_type,	1055	LIBBPF_DEPRECATED_SINCE(0, 8, "use libbpf_probe_bpf_prog_type() instead")
1031	__u32 ifindex);	1056	LIBBPF_API bool bpf_probe_prog_type(enum bpf_prog_type prog_type, __u32 ifindex);
		1057	LIBBPF_DEPRECATED_SINCE(0, 8, "use libbpf_probe_bpf_map_type() instead")
1032	LIBBPF_API bool bpf_probe_map_type(enum bpf_map_type map_type, __u32 ifindex);	1058	LIBBPF_API bool bpf_probe_map_type(enum bpf_map_type map_type, __u32 ifindex);
1033	LIBBPF_API bool bpf_probe_helper(enum bpf_func_id id,	1059	LIBBPF_DEPRECATED_SINCE(0, 8, "use libbpf_probe_bpf_helper() instead")
1034	enum bpf_prog_type prog_type, __u32 ifindex);	1060	LIBBPF_API bool bpf_probe_helper(enum bpf_func_id id, enum bpf_prog_type prog_type, __u32 ifindex);
		1061	LIBBPF_DEPRECATED_SINCE(0, 8, "implement your own or use bpftool for feature detection")
1035	LIBBPF_API bool bpf_probe_large_insn_limit(__u32 ifindex);	1062	LIBBPF_API bool bpf_probe_large_insn_limit(__u32 ifindex);
1036		1063
		1064	/**
		1065	* @brief libbpf_probe_bpf_prog_type() detects if host kernel supports
		1066	* BPF programs of a given type.
		1067	* @param prog_type BPF program type to detect kernel support for
		1068	* @param opts reserved for future extensibility, should be NULL
		1069	* @return 1, if given program type is supported; 0, if given program type is
		1070	* not supported; negative error code if feature detection failed or can't be
		1071	* performed
		1072	*
		1073	* Make sure the process has required set of CAP_* permissions (or runs as
		1074	* root) when performing feature checking.
		1075	*/
		1076	LIBBPF_API int libbpf_probe_bpf_prog_type(enum bpf_prog_type prog_type, const void *opts);
		1077	/**
		1078	* @brief libbpf_probe_bpf_map_type() detects if host kernel supports
		1079	* BPF maps of a given type.
		1080	* @param map_type BPF map type to detect kernel support for
		1081	* @param opts reserved for future extensibility, should be NULL
		1082	* @return 1, if given map type is supported; 0, if given map type is
		1083	* not supported; negative error code if feature detection failed or can't be
		1084	* performed
		1085	*
		1086	* Make sure the process has required set of CAP_* permissions (or runs as
		1087	* root) when performing feature checking.
		1088	*/
		1089	LIBBPF_API int libbpf_probe_bpf_map_type(enum bpf_map_type map_type, const void *opts);
		1090	/**
		1091	* @brief libbpf_probe_bpf_helper() detects if host kernel supports the
		1092	* use of a given BPF helper from specified BPF program type.
		1093	* @param prog_type BPF program type used to check the support of BPF helper
		1094	* @param helper_id BPF helper ID (enum bpf_func_id) to check support for
		1095	* @param opts reserved for future extensibility, should be NULL
		1096	* @return 1, if given combination of program type and helper is supported; 0,
		1097	* if the combination is not supported; negative error code if feature
		1098	* detection for provided input arguments failed or can't be performed
		1099	*
		1100	* Make sure the process has required set of CAP_* permissions (or runs as
		1101	* root) when performing feature checking.
		1102	*/
		1103	LIBBPF_API int libbpf_probe_bpf_helper(enum bpf_prog_type prog_type,
		1104	enum bpf_func_id helper_id, const void *opts);
		1105
1037	/*	1106	/*
1038	* Get bpf_prog_info in continuous memory	1107	* Get bpf_prog_info in continuous memory
1039	*	1108	*

tools/lib/bpf/libbpf.map+4−0

 		bpf_program__log_level;
 		bpf_program__set_log_buf;
 		bpf_program__set_log_level;
+		libbpf_probe_bpf_helper;
+		libbpf_probe_bpf_map_type;
+		libbpf_probe_bpf_prog_type;
+		libbpf_set_memlock_rlim_max;
 };

tools/lib/bpf/libbpf_internal.h+60−0

@@ -169,6 +169,27 @@ static inline void libbpf_reallocarray(void ptr, size_t nmemb, size_t size) · 168 unmodified lines
169	return realloc(ptr, total);	169	return realloc(ptr, total);
170	}	170	}
171		171
		172	/* Copy up to sz - 1 bytes from zero-terminated src string and ensure that dst
		173	* is zero-terminated string no matter what (unless sz == 0, in which case
		174	* it's a no-op). It's conceptually close to FreeBSD's strlcpy(), but differs
		175	* in what is returned. Given this is internal helper, it's trivial to extend
		176	* this, when necessary. Use this instead of strncpy inside libbpf source code.
		177	*/
		178	static inline void libbpf_strlcpy(char dst, const char src, size_t sz)
		179	{
		180	size_t i;
		181
		182	if (sz == 0)
		183	return;
		184
		185	sz--;
		186	for (i = 0; i < sz && src[i]; i++)
		187	dst[i] = src[i];
		188	dst[i] = '\0';
		189	}
		190
		191	__u32 get_kernel_version(void);
		192
172	struct btf;	193	struct btf;
173	struct btf_type;	194	struct btf_type;
174		195
@@ -272,6 +293,45 @@ static inline bool libbpf_validate_opts(const char *opts, · 97 unmodified lines
272	(opts)->sz - __off); \	293	(opts)->sz - __off); \
273	})	294	})
274		295
		296	enum kern_feature_id {
		297	/* v4.14: kernel support for program & map names. */
		298	FEAT_PROG_NAME,
		299	/* v5.2: kernel support for global data sections. */
		300	FEAT_GLOBAL_DATA,
		301	/* BTF support */
		302	FEAT_BTF,
		303	/* BTF_KIND_FUNC and BTF_KIND_FUNC_PROTO support */
		304	FEAT_BTF_FUNC,
		305	/* BTF_KIND_VAR and BTF_KIND_DATASEC support */
		306	FEAT_BTF_DATASEC,
		307	/* BTF_FUNC_GLOBAL is supported */
		308	FEAT_BTF_GLOBAL_FUNC,
		309	/* BPF_F_MMAPABLE is supported for arrays */
		310	FEAT_ARRAY_MMAP,
		311	/* kernel support for expected_attach_type in BPF_PROG_LOAD */
		312	FEAT_EXP_ATTACH_TYPE,
		313	/* bpf_probe_read_{kernel,user}[_str] helpers */
		314	FEAT_PROBE_READ_KERN,
		315	/* BPF_PROG_BIND_MAP is supported */
		316	FEAT_PROG_BIND_MAP,
		317	/* Kernel support for module BTFs */
		318	FEAT_MODULE_BTF,
		319	/* BTF_KIND_FLOAT support */
		320	FEAT_BTF_FLOAT,
		321	/* BPF perf link support */
		322	FEAT_PERF_LINK,
		323	/* BTF_KIND_DECL_TAG support */
		324	FEAT_BTF_DECL_TAG,
		325	/* BTF_KIND_TYPE_TAG support */
		326	FEAT_BTF_TYPE_TAG,
		327	/* memcg-based accounting for BPF maps and progs */
		328	FEAT_MEMCG_ACCOUNT,
		329	__FEAT_CNT,
		330	};
		331
		332	int probe_memcg_account(void);
		333	bool kernel_supports(const struct bpf_object *obj, enum kern_feature_id feat_id);
		334	int bump_rlimit_memlock(void);
275		335
276	int parse_cpu_mask_str(const char s, bool mask, int mask_sz);	336	int parse_cpu_mask_str(const char s, bool mask, int mask_sz);
277	int parse_cpu_mask_file(const char fcpu, bool mask, int mask_sz);	337	int parse_cpu_mask_file(const char fcpu, bool mask, int mask_sz);

tools/lib/bpf/libbpf_legacy.h+11−1

 	 * (positive) error code.
 	 */
 	LIBBPF_STRICT_DIRECT_ERRS = 0x02,
 	/*
 	 * Enforce strict BPF program section (SEC()) names.
 	 * E.g., while prefiously SEC("xdp_whatever") or SEC("perf_event_blah") were
 	 * Clients can maintain it on their own if it is valuable for them.
 	 */
 	LIBBPF_STRICT_NO_OBJECT_LIST = 0x08,
+	/*
+	 * Automatically bump RLIMIT_MEMLOCK using setrlimit() before the
+	 * first BPF program or map creation operation. This is done only if
+	 * kernel is too old to support memcg-based memory accounting for BPF
+	 * subsystem. By default, RLIMIT_MEMLOCK limit is set to RLIM_INFINITY,
+	 * but it can be overriden with libbpf_set_memlock_rlim_max() API.
+	 * Note that libbpf_set_memlock_rlim_max() needs to be called before
+	 * the very first bpf_prog_load(), bpf_map_create() or bpf_object__load()
+	 * operation.
+	 */
+	LIBBPF_STRICT_AUTO_RLIMIT_MEMLOCK = 0x10,
 	__LIBBPF_STRICT_LAST,
 };

tools/lib/bpf/libbpf_probes.c+185−66

@@ -48,28 +48,20 @@ static int get_vendor_id(int ifindex) · 47 unmodified lines
48	return strtol(buf, NULL, 0);	48	return strtol(buf, NULL, 0);
49	}	49	}
50		50
51	static int get_kernel_version(void)	51	static int probe_prog_load(enum bpf_prog_type prog_type,
		52	const struct bpf_insn *insns, size_t insns_cnt,
		53	char *log_buf, size_t log_buf_sz,
		54	__u32 ifindex)
52	{	55	{
53	int version, subversion, patchlevel;	56	LIBBPF_OPTS(bpf_prog_load_opts, opts,
54	struct utsname utsn;	57	.log_buf = log_buf,
55		58	.log_size = log_buf_sz,
56	/* Return 0 on failure, and attempt to probe with empty kversion */	59	.log_level = log_buf ? 1 : 0,
57	if (uname(&utsn))	60	.prog_ifindex = ifindex,
58	return 0;	61	);
59		62	int fd, err, exp_err = 0;
60	if (sscanf(utsn.release, "%d.%d.%d",	63	const char *exp_msg = NULL;
61	&version, &subversion, &patchlevel) != 3)	64	char buf[4096];
62	return 0;
63
64	return (version << 16) + (subversion << 8) + patchlevel;
65	}
66
67	static void
68	probe_load(enum bpf_prog_type prog_type, const struct bpf_insn *insns,
69	size_t insns_cnt, char *buf, size_t buf_len, __u32 ifindex)
70	{
71	LIBBPF_OPTS(bpf_prog_load_opts, opts);
72	int fd;
73		65
74	switch (prog_type) {	66	switch (prog_type) {
75	case BPF_PROG_TYPE_CGROUP_SOCK_ADDR:	67	case BPF_PROG_TYPE_CGROUP_SOCK_ADDR:
@@ -84,6 +76,38 @@ probe_load(enum bpf_prog_type prog_type, const struct bpf_insn *insns, · 8 unmodified lines
84	case BPF_PROG_TYPE_KPROBE:	76	case BPF_PROG_TYPE_KPROBE:
85	opts.kern_version = get_kernel_version();	77	opts.kern_version = get_kernel_version();
86	break;	78	break;
		79	case BPF_PROG_TYPE_LIRC_MODE2:
		80	opts.expected_attach_type = BPF_LIRC_MODE2;
		81	break;
		82	case BPF_PROG_TYPE_TRACING:
		83	case BPF_PROG_TYPE_LSM:
		84	opts.log_buf = buf;
		85	opts.log_size = sizeof(buf);
		86	opts.log_level = 1;
		87	if (prog_type == BPF_PROG_TYPE_TRACING)
		88	opts.expected_attach_type = BPF_TRACE_FENTRY;
		89	else
		90	opts.expected_attach_type = BPF_MODIFY_RETURN;
		91	opts.attach_btf_id = 1;
		92
		93	exp_err = -EINVAL;
		94	exp_msg = "attach_btf_id 1 is not a function";
		95	break;
		96	case BPF_PROG_TYPE_EXT:
		97	opts.log_buf = buf;
		98	opts.log_size = sizeof(buf);
		99	opts.log_level = 1;
		100	opts.attach_btf_id = 1;
		101
		102	exp_err = -EINVAL;
		103	exp_msg = "Cannot replace kernel functions";
		104	break;
		105	case BPF_PROG_TYPE_SYSCALL:
		106	opts.prog_flags = BPF_F_SLEEPABLE;
		107	break;
		108	case BPF_PROG_TYPE_STRUCT_OPS:
		109	exp_err = -524; /* -ENOTSUPP */
		110	break;
87	case BPF_PROG_TYPE_UNSPEC:	111	case BPF_PROG_TYPE_UNSPEC:
88	case BPF_PROG_TYPE_SOCKET_FILTER:	112	case BPF_PROG_TYPE_SOCKET_FILTER:
89	case BPF_PROG_TYPE_SCHED_CLS:	113	case BPF_PROG_TYPE_SCHED_CLS:
@@ -103,25 +127,42 @@ probe_load(enum bpf_prog_type prog_type, const struct bpf_insn *insns, · 13 unmodified lines
103	case BPF_PROG_TYPE_RAW_TRACEPOINT:	127	case BPF_PROG_TYPE_RAW_TRACEPOINT:
104	case BPF_PROG_TYPE_RAW_TRACEPOINT_WRITABLE:	128	case BPF_PROG_TYPE_RAW_TRACEPOINT_WRITABLE:
105	case BPF_PROG_TYPE_LWT_SEG6LOCAL:	129	case BPF_PROG_TYPE_LWT_SEG6LOCAL:
106	case BPF_PROG_TYPE_LIRC_MODE2:
107	case BPF_PROG_TYPE_SK_REUSEPORT:	130	case BPF_PROG_TYPE_SK_REUSEPORT:
108	case BPF_PROG_TYPE_FLOW_DISSECTOR:	131	case BPF_PROG_TYPE_FLOW_DISSECTOR:
109	case BPF_PROG_TYPE_CGROUP_SYSCTL:	132	case BPF_PROG_TYPE_CGROUP_SYSCTL:
110	case BPF_PROG_TYPE_TRACING:
111	case BPF_PROG_TYPE_STRUCT_OPS:
112	case BPF_PROG_TYPE_EXT:
113	case BPF_PROG_TYPE_LSM:
114	default:
115	break;	133	break;
		134	default:
		135	return -EOPNOTSUPP;
116	}	136	}
117		137
118	opts.prog_ifindex = ifindex;	138	fd = bpf_prog_load(prog_type, NULL, "GPL", insns, insns_cnt, &opts);
119	opts.log_buf = buf;	139	err = -errno;
120	opts.log_size = buf_len;
121
122	fd = bpf_prog_load(prog_type, NULL, "GPL", insns, insns_cnt, NULL);
123	if (fd >= 0)	140	if (fd >= 0)
124	close(fd);	141	close(fd);
		142	if (exp_err) {
		143	if (fd >= 0 \|\| err != exp_err)
		144	return 0;
		145	if (exp_msg && !strstr(buf, exp_msg))
		146	return 0;
		147	return 1;
		148	}
		149	return fd >= 0 ? 1 : 0;
		150	}
		151
		152	int libbpf_probe_bpf_prog_type(enum bpf_prog_type prog_type, const void *opts)
		153	{
		154	struct bpf_insn insns[] = {
		155	BPF_MOV64_IMM(BPF_REG_0, 0),
		156	BPF_EXIT_INSN()
		157	};
		158	const size_t insn_cnt = ARRAY_SIZE(insns);
		159	int ret;
		160
		161	if (opts)
		162	return libbpf_err(-EINVAL);
		163
		164	ret = probe_prog_load(prog_type, insns, insn_cnt, NULL, 0, 0);
		165	return libbpf_err(ret);
125	}	166	}
126		167
127	bool bpf_probe_prog_type(enum bpf_prog_type prog_type, __u32 ifindex)	168	bool bpf_probe_prog_type(enum bpf_prog_type prog_type, __u32 ifindex)
@@ -131,12 +172,16 @@ bool bpf_probe_prog_type(enum bpf_prog_type prog_type, __u32 ifindex) · 3 unmodified lines
131	BPF_EXIT_INSN()	172	BPF_EXIT_INSN()
132	};	173	};
133		174
		175	/* prefer libbpf_probe_bpf_prog_type() unless offload is requested */
		176	if (ifindex == 0)
		177	return libbpf_probe_bpf_prog_type(prog_type, NULL) == 1;
		178
134	if (ifindex && prog_type == BPF_PROG_TYPE_SCHED_CLS)	179	if (ifindex && prog_type == BPF_PROG_TYPE_SCHED_CLS)
135	/* nfp returns -EINVAL on exit(0) with TC offload */	180	/* nfp returns -EINVAL on exit(0) with TC offload */
136	insns[0].imm = 2;	181	insns[0].imm = 2;
137		182
138	errno = 0;	183	errno = 0;
139	probe_load(prog_type, insns, ARRAY_SIZE(insns), NULL, 0, ifindex);	184	probe_prog_load(prog_type, insns, ARRAY_SIZE(insns), NULL, 0, ifindex);
140		185
141	return errno != EINVAL && errno != EOPNOTSUPP;	186	return errno != EINVAL && errno != EOPNOTSUPP;
142	}	187	}
@@ -197,16 +242,18 @@ static int load_local_storage_btf(void) · 54 unmodified lines
197	strs, sizeof(strs));	242	strs, sizeof(strs));
198	}	243	}
199		244
200	bool bpf_probe_map_type(enum bpf_map_type map_type, __u32 ifindex)	245	static int probe_map_create(enum bpf_map_type map_type, __u32 ifindex)
201	{	246	{
202	int key_size, value_size, max_entries, map_flags;	247	LIBBPF_OPTS(bpf_map_create_opts, opts);
		248	int key_size, value_size, max_entries;
203	__u32 btf_key_type_id = 0, btf_value_type_id = 0;	249	__u32 btf_key_type_id = 0, btf_value_type_id = 0;
204	int fd = -1, btf_fd = -1, fd_inner;	250	int fd = -1, btf_fd = -1, fd_inner = -1, exp_err = 0, err;
		251
		252	opts.map_ifindex = ifindex;
205		253
206	key_size = sizeof(__u32);	254	key_size = sizeof(__u32);
207	value_size = sizeof(__u32);	255	value_size = sizeof(__u32);
208	max_entries = 1;	256	max_entries = 1;
209	map_flags = 0;
210		257
211	switch (map_type) {	258	switch (map_type) {
212	case BPF_MAP_TYPE_STACK_TRACE:	259	case BPF_MAP_TYPE_STACK_TRACE:
@@ -215,7 +262,7 @@ bool bpf_probe_map_type(enum bpf_map_type map_type, __u32 ifindex) · 2 unmodified lines
215	case BPF_MAP_TYPE_LPM_TRIE:	262	case BPF_MAP_TYPE_LPM_TRIE:
216	key_size = sizeof(__u64);	263	key_size = sizeof(__u64);
217	value_size = sizeof(__u64);	264	value_size = sizeof(__u64);
218	map_flags = BPF_F_NO_PREALLOC;	265	opts.map_flags = BPF_F_NO_PREALLOC;
219	break;	266	break;
220	case BPF_MAP_TYPE_CGROUP_STORAGE:	267	case BPF_MAP_TYPE_CGROUP_STORAGE:
221	case BPF_MAP_TYPE_PERCPU_CGROUP_STORAGE:	268	case BPF_MAP_TYPE_PERCPU_CGROUP_STORAGE:
@@ -234,17 +281,25 @@ bool bpf_probe_map_type(enum bpf_map_type map_type, __u32 ifindex) · 12 unmodified lines
234	btf_value_type_id = 3;	281	btf_value_type_id = 3;
235	value_size = 8;	282	value_size = 8;
236	max_entries = 0;	283	max_entries = 0;
237	map_flags = BPF_F_NO_PREALLOC;	284	opts.map_flags = BPF_F_NO_PREALLOC;
238	btf_fd = load_local_storage_btf();	285	btf_fd = load_local_storage_btf();
239	if (btf_fd < 0)	286	if (btf_fd < 0)
240	return false;	287	return btf_fd;
241	break;	288	break;
242	case BPF_MAP_TYPE_RINGBUF:	289	case BPF_MAP_TYPE_RINGBUF:
243	key_size = 0;	290	key_size = 0;
244	value_size = 0;	291	value_size = 0;
245	max_entries = 4096;	292	max_entries = 4096;
246	break;	293	break;
247	case BPF_MAP_TYPE_UNSPEC:	294	case BPF_MAP_TYPE_STRUCT_OPS:
		295	/* we'll get -ENOTSUPP for invalid BTF type ID for struct_ops */
		296	opts.btf_vmlinux_value_type_id = 1;
		297	exp_err = -524; /* -ENOTSUPP */
		298	break;
		299	case BPF_MAP_TYPE_BLOOM_FILTER:
		300	key_size = 0;
		301	max_entries = 1;
		302	break;
248	case BPF_MAP_TYPE_HASH:	303	case BPF_MAP_TYPE_HASH:
249	case BPF_MAP_TYPE_ARRAY:	304	case BPF_MAP_TYPE_ARRAY:
250	case BPF_MAP_TYPE_PROG_ARRAY:	305	case BPF_MAP_TYPE_PROG_ARRAY:
@@ -263,49 +318,114 @@ bool bpf_probe_map_type(enum bpf_map_type map_type, __u32 ifindex) · 12 unmodified lines
263	case BPF_MAP_TYPE_XSKMAP:	318	case BPF_MAP_TYPE_XSKMAP:
264	case BPF_MAP_TYPE_SOCKHASH:	319	case BPF_MAP_TYPE_SOCKHASH:
265	case BPF_MAP_TYPE_REUSEPORT_SOCKARRAY:	320	case BPF_MAP_TYPE_REUSEPORT_SOCKARRAY:
266	case BPF_MAP_TYPE_STRUCT_OPS:
267	default:
268	break;	321	break;
		322	case BPF_MAP_TYPE_UNSPEC:
		323	default:
		324	return -EOPNOTSUPP;
269	}	325	}
270		326
271	if (map_type == BPF_MAP_TYPE_ARRAY_OF_MAPS \|\|	327	if (map_type == BPF_MAP_TYPE_ARRAY_OF_MAPS \|\|
272	map_type == BPF_MAP_TYPE_HASH_OF_MAPS) {	328	map_type == BPF_MAP_TYPE_HASH_OF_MAPS) {
273	LIBBPF_OPTS(bpf_map_create_opts, opts);
274
275	/* TODO: probe for device, once libbpf has a function to create	329	/* TODO: probe for device, once libbpf has a function to create
276	* map-in-map for offload	330	* map-in-map for offload
277	*/	331	*/
278	if (ifindex)	332	if (ifindex)
279	return false;	333	goto cleanup;
280		334
281	fd_inner = bpf_map_create(BPF_MAP_TYPE_HASH, NULL,	335	fd_inner = bpf_map_create(BPF_MAP_TYPE_HASH, NULL,
282	sizeof(__u32), sizeof(__u32), 1, NULL);	336	sizeof(__u32), sizeof(__u32), 1, NULL);
283	if (fd_inner < 0)	337	if (fd_inner < 0)
284	return false;	338	goto cleanup;
285		339
286	opts.inner_map_fd = fd_inner;	340	opts.inner_map_fd = fd_inner;
287	fd = bpf_map_create(map_type, NULL, sizeof(__u32), sizeof(__u32), 1, &opts);	341	}
288	close(fd_inner);
289	} else {
290	LIBBPF_OPTS(bpf_map_create_opts, opts);
291
292	/* Note: No other restriction on map type probes for offload */
293	opts.map_flags = map_flags;
294	opts.map_ifindex = ifindex;
295	if (btf_fd >= 0) {
296	opts.btf_fd = btf_fd;
297	opts.btf_key_type_id = btf_key_type_id;
298	opts.btf_value_type_id = btf_value_type_id;
299	}
300		342
301	fd = bpf_map_create(map_type, NULL, key_size, value_size, max_entries, &opts);	343	if (btf_fd >= 0) {
		344	opts.btf_fd = btf_fd;
		345	opts.btf_key_type_id = btf_key_type_id;
		346	opts.btf_value_type_id = btf_value_type_id;
302	}	347	}
		348
		349	fd = bpf_map_create(map_type, NULL, key_size, value_size, max_entries, &opts);
		350	err = -errno;
		351
		352	cleanup:
303	if (fd >= 0)	353	if (fd >= 0)
304	close(fd);	354	close(fd);
		355	if (fd_inner >= 0)
		356	close(fd_inner);
305	if (btf_fd >= 0)	357	if (btf_fd >= 0)
306	close(btf_fd);	358	close(btf_fd);
307		359
308	return fd >= 0;	360	if (exp_err)
		361	return fd < 0 && err == exp_err ? 1 : 0;
		362	else
		363	return fd >= 0 ? 1 : 0;
		364	}
		365
		366	int libbpf_probe_bpf_map_type(enum bpf_map_type map_type, const void *opts)
		367	{
		368	int ret;
		369
		370	if (opts)
		371	return libbpf_err(-EINVAL);
		372
		373	ret = probe_map_create(map_type, 0);
		374	return libbpf_err(ret);
		375	}
		376
		377	bool bpf_probe_map_type(enum bpf_map_type map_type, __u32 ifindex)
		378	{
		379	return probe_map_create(map_type, ifindex) == 1;
		380	}
		381
		382	int libbpf_probe_bpf_helper(enum bpf_prog_type prog_type, enum bpf_func_id helper_id,
		383	const void *opts)
		384	{
		385	struct bpf_insn insns[] = {
		386	BPF_EMIT_CALL((__u32)helper_id),
		387	BPF_EXIT_INSN(),
		388	};
		389	const size_t insn_cnt = ARRAY_SIZE(insns);
		390	char buf[4096];
		391	int ret;
		392
		393	if (opts)
		394	return libbpf_err(-EINVAL);
		395
		396	/* we can't successfully load all prog types to check for BPF helper
		397	* support, so bail out with -EOPNOTSUPP error
		398	*/
		399	switch (prog_type) {
		400	case BPF_PROG_TYPE_TRACING:
		401	case BPF_PROG_TYPE_EXT:
		402	case BPF_PROG_TYPE_LSM:
		403	case BPF_PROG_TYPE_STRUCT_OPS:
		404	return -EOPNOTSUPP;
		405	default:
		406	break;
		407	}
		408
		409	buf[0] = '\0';
		410	ret = probe_prog_load(prog_type, insns, insn_cnt, buf, sizeof(buf), 0);
		411	if (ret < 0)
		412	return libbpf_err(ret);
		413
		414	/* If BPF verifier doesn't recognize BPF helper ID (enum bpf_func_id)
		415	* at all, it will emit something like "invalid func unknown#181".
		416	* If BPF verifier recognizes BPF helper but it's not supported for
		417	* given BPF program type, it will emit "unknown func bpf_sys_bpf#166".
		418	* In both cases, provided combination of BPF program type and BPF
		419	* helper is not supported by the kernel.
		420	* In all other cases, probe_prog_load() above will either succeed (e.g.,
		421	* because BPF helper happens to accept no input arguments or it
		422	* accepts one input argument and initial PTR_TO_CTX is fine for
		423	* that), or we'll get some more specific BPF verifier error about
		424	* some unsatisfied conditions.
		425	*/
		426	if (ret == 0 && (strstr(buf, "invalid func ") \|\| strstr(buf, "unknown func ")))
		427	return 0;
		428	return 1; /* assume supported */
309	}	429	}
310		430
311	bool bpf_probe_helper(enum bpf_func_id id, enum bpf_prog_type prog_type,	431	bool bpf_probe_helper(enum bpf_func_id id, enum bpf_prog_type prog_type,
@@ -318,8 +438,7 @@ bool bpf_probe_helper(enum bpf_func_id id, enum bpf_prog_type prog_type, · 6 unmodified lines
318	char buf[4096] = {};	438	char buf[4096] = {};
319	bool res;	439	bool res;
320		440
321	probe_load(prog_type, insns, ARRAY_SIZE(insns), buf, sizeof(buf),	441	probe_prog_load(prog_type, insns, ARRAY_SIZE(insns), buf, sizeof(buf), ifindex);
322	ifindex);
323	res = !grep(buf, "invalid func ") && !grep(buf, "unknown func ");	442	res = !grep(buf, "invalid func ") && !grep(buf, "unknown func ");
324		443
325	if (ifindex) {	444	if (ifindex) {
@@ -351,8 +470,8 @@ bool bpf_probe_large_insn_limit(__u32 ifindex) · 25 unmodified lines
351	insns[BPF_MAXINSNS] = BPF_EXIT_INSN();	470	insns[BPF_MAXINSNS] = BPF_EXIT_INSN();
352		471
353	errno = 0;	472	errno = 0;
354	probe_load(BPF_PROG_TYPE_SCHED_CLS, insns, ARRAY_SIZE(insns), NULL, 0,	473	probe_prog_load(BPF_PROG_TYPE_SCHED_CLS, insns, ARRAY_SIZE(insns), NULL, 0,
355	ifindex);	474	ifindex);
356		475
357	return errno != E2BIG && errno != EINVAL;	476	return errno != E2BIG && errno != EINVAL;
358	}	477	}

tools/lib/bpf/relo_core.c+15−5

 static int bpf_core_calc_type_relo(const struct bpf_core_relo *relo,
 				   const struct bpf_core_spec *spec,
-				   __u32 *val)
+				   __u32 *val, bool *validate)
 {
 	__s64 sz;
+	/* by default, always check expected value in bpf_insn */
+	if (validate)
+		*validate = true;
 	/* type-based relos return zero when target type is not found */
 	if (!spec) {
 		*val = 0;
 	switch (relo->kind) {
 	case BPF_CORE_TYPE_ID_TARGET:
 		*val = spec->root_type_id;
+		/* type ID, embedded in bpf_insn, might change during linking,
+		 * so enforcing it is pointless
+		 */
+		if (validate)
+			*validate = false;
 		break;
 	case BPF_CORE_TYPE_EXISTS:
 		*val = 1;
 			res->fail_memsz_adjust = true;
 		}
 	} else if (core_relo_is_type_based(relo->kind)) {
-		err = bpf_core_calc_type_relo(relo, local_spec, &res->orig_val);
+		err = bpf_core_calc_type_relo(relo, local_spec, &res->orig_val, &res->validate);
-		err = err ?: bpf_core_calc_type_relo(relo, targ_spec, &res->new_val);
+		err = err ?: bpf_core_calc_type_relo(relo, targ_spec, &res->new_val, NULL);
 	} else if (core_relo_is_enumval_based(relo->kind)) {
 		err = bpf_core_calc_enumval_relo(relo, local_spec, &res->orig_val);
 		err = err ?: bpf_core_calc_enumval_relo(relo, targ_spec, &res->new_val);
 	/* TYPE_ID_LOCAL relo is special and doesn't need candidate search */
 	if (relo->kind == BPF_CORE_TYPE_ID_LOCAL) {
-		targ_res.validate = true;
+		/* bpf_insn's imm value could get out of sync during linking */
+		memset(&targ_res, 0, sizeof(targ_res));
+		targ_res.validate = false;
 		targ_res.poison = false;
 		targ_res.orig_val = local_spec->root_type_id;
 		targ_res.new_val = local_spec->root_type_id;
 		return -EOPNOTSUPP;
 	}
 	for (i = 0, j = 0; i < cands->len; i++) {
 		err = bpf_core_spec_match(local_spec, cands->cands[i].btf,
 					  cands->cands[i].id, cand_spec);

tools/lib/bpf/xsk.c+3−6

 		return -errno;
 	ifr.ifr_data = (void *)&channels;
-	memcpy(ifr.ifr_name, ctx->ifname, IFNAMSIZ - 1);
+	libbpf_strlcpy(ifr.ifr_name, ctx->ifname, IFNAMSIZ);
-	ifr.ifr_name[IFNAMSIZ - 1] = '\0';
 	err = ioctl(fd, SIOCETHTOOL, &ifr);
 	if (err && errno != EOPNOTSUPP) {
 		ret = -errno;
 	}
 	ctx->ifindex = ifindex;
-	memcpy(ctx->ifname, ifname, IFNAMSIZ -1);
+	libbpf_strlcpy(ctx->ifname, ifname, IFNAMSIZ);
-	ctx->ifname[IFNAMSIZ - 1] = 0;
 	xsk->ctx = ctx;
 	xsk->ctx->has_bpf_link = xsk_probe_bpf_link();
 	ctx->refcount = 1;
 	ctx->umem = umem;
 	ctx->queue_id = queue_id;
-	memcpy(ctx->ifname, ifname, IFNAMSIZ - 1);
+	libbpf_strlcpy(ctx->ifname, ifname, IFNAMSIZ);
-	ctx->ifname[IFNAMSIZ - 1] = '\0';
 	ctx->fill = fill;
 	ctx->comp = comp;

tools/perf/builtin-trace.c+12−1

@@ -3257,10 +3257,21 @@ static void trace__set_bpf_map_syscalls(struct trace *trace) · 3256 unmodified lines
3257		3257
3258	static struct bpf_program trace__find_bpf_program_by_title(struct trace trace, const char *name)	3258	static struct bpf_program trace__find_bpf_program_by_title(struct trace trace, const char *name)
3259	{	3259	{
		3260	struct bpf_program pos, prog = NULL;
		3261	const char *sec_name;
		3262
3260	if (trace->bpf_obj == NULL)	3263	if (trace->bpf_obj == NULL)
3261	return NULL;	3264	return NULL;
3262		3265
3263	return bpf_object__find_program_by_title(trace->bpf_obj, name);	3266	bpf_object__for_each_program(pos, trace->bpf_obj) {
		3267	sec_name = bpf_program__section_name(pos);
		3268	if (sec_name && !strcmp(sec_name, name)) {
		3269	prog = pos;
		3270	break;
		3271	}
		3272	}
		3273
		3274	return prog;
3264	}	3275	}
3265		3276
3266	static struct bpf_program trace__find_syscall_bpf_prog(struct trace trace, struct syscall *sc,	3277	static struct bpf_program trace__find_syscall_bpf_prog(struct trace trace, struct syscall *sc,

tools/scripts/Makefile.include+12−1

@@ -87,7 +87,18 @@ LLVM_STRIP ?= llvm-strip · 86 unmodified lines
87		87
88	ifeq ($(CC_NO_CLANG), 1)	88	ifeq ($(CC_NO_CLANG), 1)
89	EXTRA_WARNINGS += -Wstrict-aliasing=3	89	EXTRA_WARNINGS += -Wstrict-aliasing=3
90	endif	90
		91	else ifneq ($(CROSS_COMPILE),)
		92	CLANG_CROSS_FLAGS := --target=$(notdir $(CROSS_COMPILE:%-=%))
		93	GCC_TOOLCHAIN_DIR := $(dir $(shell which $(CROSS_COMPILE)gcc))
		94	ifneq ($(GCC_TOOLCHAIN_DIR),)
		95	CLANG_CROSS_FLAGS += --prefix=$(GCC_TOOLCHAIN_DIR)$(notdir $(CROSS_COMPILE))
		96	CLANG_CROSS_FLAGS += --sysroot=$(shell $(CROSS_COMPILE)gcc -print-sysroot)
		97	CLANG_CROSS_FLAGS += --gcc-toolchain=$(realpath $(GCC_TOOLCHAIN_DIR)/..)
		98	endif # GCC_TOOLCHAIN_DIR
		99	CFLAGS += $(CLANG_CROSS_FLAGS)
		100	AFLAGS += $(CLANG_CROSS_FLAGS)
		101	endif # CROSS_COMPILE
91		102
92	# Hack to avoid type-punned warnings on old systems such as RHEL5:	103	# Hack to avoid type-punned warnings on old systems such as RHEL5:
93	# We should be changing CFLAGS and checking gcc version, but this	104	# We should be changing CFLAGS and checking gcc version, but this

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"