Commit 0697e439 authored by Alexei Starovoitov's avatar Alexei Starovoitov
Browse files

Merge branch 'bpf: Move kernel test kfuncs into bpf_testmod' 

Jiri Olsa says:

====================
hi,
I noticed several times in discussions that we should move test kfuncs
into kernel module, now perhaps even more pressing with all the kfunc
effort. This patchset moves all the test kfuncs into bpf_testmod.

I added bpf_testmod/bpf_testmod_kfunc.h header that is shared between
bpf_testmod kernel module and BPF programs.

v4 changes:
  - s390 supports long calls [1] now, so it can call now kfuncs from module [Ilya]
  - added acks [David]
  - cleanups for ptr_to_u64 function [David]
  - use relative path for bpf_testmod_kfunc.h include [Andrii]
  - new libbpf fix (patch 1) for gen_loader

v3 changes:
  - added acks [David]
  - added bpf_testmod.ko make dependency for bpf test progs [David]
  - better handling of __ksym and refcount_t in bpf_testmod_kfunc.h [David]
  - removed 'extern' from kfuncs declarations [David]
  - typo in header guard macro [David]
  - use only stdout in un/load_bpf_testmod

v2 changes:
  - add 74bc3a5a into bpf-next/master CI, so the test would pass
    https://github.com/kernel-patches/vmtest/pull/192


  - remove extra externs [Artem]
  - using un/load_bpf_testmod in other tests
  - rebased

thanks,
jirka

[1] 1cf3bfc6 bpf: Support 64-bit pointers to kfuncs
====================

Signed-off-by: default avatarAlexei Starovoitov <ast@kernel.org>
parents de58ef41 65eb006d

net/bpf/test_run.c

+0 −201
Original line number Diff line number Diff line
@@ -561,29 +561,6 @@ __bpf_kfunc int bpf_modify_return_test(int a, int *b) 
	return a + *b;

}



__bpf_kfunc u64 bpf_kfunc_call_test1(struct sock *sk, u32 a, u64 b, u32 c, u64 d)

{

	return a + b + c + d;

}



__bpf_kfunc int bpf_kfunc_call_test2(struct sock *sk, u32 a, u32 b)

{

	return a + b;

}



__bpf_kfunc struct sock *bpf_kfunc_call_test3(struct sock *sk)

{

	return sk;

}



long noinline bpf_kfunc_call_test4(signed char a, short b, int c, long d)

{

	/* Provoke the compiler to assume that the caller has sign-extended a,

	 * b and c on platforms where this is required (e.g. s390x).

	 */

	return (long)a + (long)b + (long)c + d;

}



int noinline bpf_fentry_shadow_test(int a)

{

	return a + 1;
@@ -606,32 +583,6 @@ struct prog_test_ref_kfunc { 
	refcount_t cnt;

};



static struct prog_test_ref_kfunc prog_test_struct = {

	.a = 42,

	.b = 108,

	.next = &prog_test_struct,

	.cnt = REFCOUNT_INIT(1),

};



__bpf_kfunc struct prog_test_ref_kfunc *

bpf_kfunc_call_test_acquire(unsigned long *scalar_ptr)

{

	refcount_inc(&prog_test_struct.cnt);

	return &prog_test_struct;

}



__bpf_kfunc void bpf_kfunc_call_test_offset(struct prog_test_ref_kfunc *p)

{

	WARN_ON_ONCE(1);

}



__bpf_kfunc struct prog_test_member *

bpf_kfunc_call_memb_acquire(void)

{

	WARN_ON_ONCE(1);

	return NULL;

}



__bpf_kfunc void bpf_kfunc_call_test_release(struct prog_test_ref_kfunc *p)

{

	refcount_dec(&p->cnt);
@@ -641,134 +592,6 @@ __bpf_kfunc void bpf_kfunc_call_memb_release(struct prog_test_member *p) 
{

}



__bpf_kfunc void bpf_kfunc_call_memb1_release(struct prog_test_member1 *p)

{

	WARN_ON_ONCE(1);

}



static int *__bpf_kfunc_call_test_get_mem(struct prog_test_ref_kfunc *p, const int size)

{

	if (size > 2 * sizeof(int))

		return NULL;



	return (int *)p;

}



__bpf_kfunc int *bpf_kfunc_call_test_get_rdwr_mem(struct prog_test_ref_kfunc *p,

						  const int rdwr_buf_size)

{

	return __bpf_kfunc_call_test_get_mem(p, rdwr_buf_size);

}



__bpf_kfunc int *bpf_kfunc_call_test_get_rdonly_mem(struct prog_test_ref_kfunc *p,

						    const int rdonly_buf_size)

{

	return __bpf_kfunc_call_test_get_mem(p, rdonly_buf_size);

}



/* the next 2 ones can't be really used for testing expect to ensure

 * that the verifier rejects the call.

 * Acquire functions must return struct pointers, so these ones are

 * failing.

 */

__bpf_kfunc int *bpf_kfunc_call_test_acq_rdonly_mem(struct prog_test_ref_kfunc *p,

						    const int rdonly_buf_size)

{

	return __bpf_kfunc_call_test_get_mem(p, rdonly_buf_size);

}



__bpf_kfunc void bpf_kfunc_call_int_mem_release(int *p)

{

}



struct prog_test_pass1 {

	int x0;

	struct {

		int x1;

		struct {

			int x2;

			struct {

				int x3;

			};

		};

	};

};



struct prog_test_pass2 {

	int len;

	short arr1[4];

	struct {

		char arr2[4];

		unsigned long arr3[8];

	} x;

};



struct prog_test_fail1 {

	void *p;

	int x;

};



struct prog_test_fail2 {

	int x8;

	struct prog_test_pass1 x;

};



struct prog_test_fail3 {

	int len;

	char arr1[2];

	char arr2[];

};



__bpf_kfunc void bpf_kfunc_call_test_pass_ctx(struct __sk_buff *skb)

{

}



__bpf_kfunc void bpf_kfunc_call_test_pass1(struct prog_test_pass1 *p)

{

}



__bpf_kfunc void bpf_kfunc_call_test_pass2(struct prog_test_pass2 *p)

{

}



__bpf_kfunc void bpf_kfunc_call_test_fail1(struct prog_test_fail1 *p)

{

}



__bpf_kfunc void bpf_kfunc_call_test_fail2(struct prog_test_fail2 *p)

{

}



__bpf_kfunc void bpf_kfunc_call_test_fail3(struct prog_test_fail3 *p)

{

}



__bpf_kfunc void bpf_kfunc_call_test_mem_len_pass1(void *mem, int mem__sz)

{

}



__bpf_kfunc void bpf_kfunc_call_test_mem_len_fail1(void *mem, int len)

{

}



__bpf_kfunc void bpf_kfunc_call_test_mem_len_fail2(u64 *mem, int len)

{

}



__bpf_kfunc void bpf_kfunc_call_test_ref(struct prog_test_ref_kfunc *p)

{

	/* p != NULL, but p->cnt could be 0 */

}



__bpf_kfunc void bpf_kfunc_call_test_destructive(void)

{

}



__bpf_kfunc static u32 bpf_kfunc_call_test_static_unused_arg(u32 arg, u32 unused)

{

	return arg;

}



__diag_pop();



BTF_SET8_START(bpf_test_modify_return_ids)
@@ -782,32 +605,8 @@ static const struct btf_kfunc_id_set bpf_test_modify_return_set = { 
};



BTF_SET8_START(test_sk_check_kfunc_ids)

BTF_ID_FLAGS(func, bpf_kfunc_call_test1)

BTF_ID_FLAGS(func, bpf_kfunc_call_test2)

BTF_ID_FLAGS(func, bpf_kfunc_call_test3)

BTF_ID_FLAGS(func, bpf_kfunc_call_test4)

BTF_ID_FLAGS(func, bpf_kfunc_call_test_acquire, KF_ACQUIRE | KF_RET_NULL)

BTF_ID_FLAGS(func, bpf_kfunc_call_memb_acquire, KF_ACQUIRE | KF_RET_NULL)

BTF_ID_FLAGS(func, bpf_kfunc_call_test_release, KF_RELEASE)

BTF_ID_FLAGS(func, bpf_kfunc_call_memb_release, KF_RELEASE)

BTF_ID_FLAGS(func, bpf_kfunc_call_memb1_release, KF_RELEASE)

BTF_ID_FLAGS(func, bpf_kfunc_call_test_get_rdwr_mem, KF_RET_NULL)

BTF_ID_FLAGS(func, bpf_kfunc_call_test_get_rdonly_mem, KF_RET_NULL)

BTF_ID_FLAGS(func, bpf_kfunc_call_test_acq_rdonly_mem, KF_ACQUIRE | KF_RET_NULL)

BTF_ID_FLAGS(func, bpf_kfunc_call_int_mem_release, KF_RELEASE)

BTF_ID_FLAGS(func, bpf_kfunc_call_test_pass_ctx)

BTF_ID_FLAGS(func, bpf_kfunc_call_test_pass1)

BTF_ID_FLAGS(func, bpf_kfunc_call_test_pass2)

BTF_ID_FLAGS(func, bpf_kfunc_call_test_fail1)

BTF_ID_FLAGS(func, bpf_kfunc_call_test_fail2)

BTF_ID_FLAGS(func, bpf_kfunc_call_test_fail3)

BTF_ID_FLAGS(func, bpf_kfunc_call_test_mem_len_pass1)

BTF_ID_FLAGS(func, bpf_kfunc_call_test_mem_len_fail1)

BTF_ID_FLAGS(func, bpf_kfunc_call_test_mem_len_fail2)

BTF_ID_FLAGS(func, bpf_kfunc_call_test_ref, KF_TRUSTED_ARGS | KF_RCU)

BTF_ID_FLAGS(func, bpf_kfunc_call_test_destructive, KF_DESTRUCTIVE)

BTF_ID_FLAGS(func, bpf_kfunc_call_test_static_unused_arg)

BTF_ID_FLAGS(func, bpf_kfunc_call_test_offset)

BTF_SET8_END(test_sk_check_kfunc_ids)



static void *bpf_test_init(const union bpf_attr *kattr, u32 user_size,

tools/lib/bpf/gen_loader.c

+7 −7
Original line number Diff line number Diff line
@@ -703,17 +703,17 @@ static void emit_relo_kfunc_btf(struct bpf_gen *gen, struct ksym_relo_desc *relo 
	/* obtain fd in BPF_REG_9 */

	emit(gen, BPF_MOV64_REG(BPF_REG_9, BPF_REG_7));

	emit(gen, BPF_ALU64_IMM(BPF_RSH, BPF_REG_9, 32));

	/* jump to fd_array store if fd denotes module BTF */

	emit(gen, BPF_JMP_IMM(BPF_JNE, BPF_REG_9, 0, 2));

	/* set the default value for off */

	emit(gen, BPF_ST_MEM(BPF_H, BPF_REG_8, offsetof(struct bpf_insn, off), 0));

	/* skip BTF fd store for vmlinux BTF */

	emit(gen, BPF_JMP_IMM(BPF_JA, 0, 0, 4));

	/* load fd_array slot pointer */

	emit2(gen, BPF_LD_IMM64_RAW_FULL(BPF_REG_0, BPF_PSEUDO_MAP_IDX_VALUE,

					 0, 0, 0, blob_fd_array_off(gen, btf_fd_idx)));

	/* store BTF fd in slot */

	/* store BTF fd in slot, 0 for vmlinux */

	emit(gen, BPF_STX_MEM(BPF_W, BPF_REG_0, BPF_REG_9, 0));

	/* jump to insn[insn_idx].off store if fd denotes module BTF */

	emit(gen, BPF_JMP_IMM(BPF_JNE, BPF_REG_9, 0, 2));

	/* set the default value for off */

	emit(gen, BPF_ST_MEM(BPF_H, BPF_REG_8, offsetof(struct bpf_insn, off), 0));

	/* skip BTF fd store for vmlinux BTF */

	emit(gen, BPF_JMP_IMM(BPF_JA, 0, 0, 1));

	/* store index into insn[insn_idx].off */

	emit(gen, BPF_ST_MEM(BPF_H, BPF_REG_8, offsetof(struct bpf_insn, off), btf_fd_idx));

log:

tools/testing/selftests/bpf/bpf_testmod/bpf_testmod.c

+166 −0
Original line number Diff line number Diff line
@@ -9,6 +9,7 @@ 
#include <linux/sysfs.h>

#include <linux/tracepoint.h>

#include "bpf_testmod.h"

#include "bpf_testmod_kfunc.h"



#define CREATE_TRACE_POINTS

#include "bpf_testmod-events.h"
@@ -289,8 +290,171 @@ static const struct btf_kfunc_id_set bpf_testmod_common_kfunc_set = { 
	.set   = &bpf_testmod_common_kfunc_ids,

};



__bpf_kfunc u64 bpf_kfunc_call_test1(struct sock *sk, u32 a, u64 b, u32 c, u64 d)

{

	return a + b + c + d;

}



__bpf_kfunc int bpf_kfunc_call_test2(struct sock *sk, u32 a, u32 b)

{

	return a + b;

}



__bpf_kfunc struct sock *bpf_kfunc_call_test3(struct sock *sk)

{

	return sk;

}



__bpf_kfunc long noinline bpf_kfunc_call_test4(signed char a, short b, int c, long d)

{

	/* Provoke the compiler to assume that the caller has sign-extended a,

	 * b and c on platforms where this is required (e.g. s390x).

	 */

	return (long)a + (long)b + (long)c + d;

}



static struct prog_test_ref_kfunc prog_test_struct = {

	.a = 42,

	.b = 108,

	.next = &prog_test_struct,

	.cnt = REFCOUNT_INIT(1),

};



__bpf_kfunc struct prog_test_ref_kfunc *

bpf_kfunc_call_test_acquire(unsigned long *scalar_ptr)

{

	refcount_inc(&prog_test_struct.cnt);

	return &prog_test_struct;

}



__bpf_kfunc void bpf_kfunc_call_test_offset(struct prog_test_ref_kfunc *p)

{

	WARN_ON_ONCE(1);

}



__bpf_kfunc struct prog_test_member *

bpf_kfunc_call_memb_acquire(void)

{

	WARN_ON_ONCE(1);

	return NULL;

}



__bpf_kfunc void bpf_kfunc_call_memb1_release(struct prog_test_member1 *p)

{

	WARN_ON_ONCE(1);

}



static int *__bpf_kfunc_call_test_get_mem(struct prog_test_ref_kfunc *p, const int size)

{

	if (size > 2 * sizeof(int))

		return NULL;



	return (int *)p;

}



__bpf_kfunc int *bpf_kfunc_call_test_get_rdwr_mem(struct prog_test_ref_kfunc *p,

						  const int rdwr_buf_size)

{

	return __bpf_kfunc_call_test_get_mem(p, rdwr_buf_size);

}



__bpf_kfunc int *bpf_kfunc_call_test_get_rdonly_mem(struct prog_test_ref_kfunc *p,

						    const int rdonly_buf_size)

{

	return __bpf_kfunc_call_test_get_mem(p, rdonly_buf_size);

}



/* the next 2 ones can't be really used for testing expect to ensure

 * that the verifier rejects the call.

 * Acquire functions must return struct pointers, so these ones are

 * failing.

 */

__bpf_kfunc int *bpf_kfunc_call_test_acq_rdonly_mem(struct prog_test_ref_kfunc *p,

						    const int rdonly_buf_size)

{

	return __bpf_kfunc_call_test_get_mem(p, rdonly_buf_size);

}



__bpf_kfunc void bpf_kfunc_call_int_mem_release(int *p)

{

}



__bpf_kfunc void bpf_kfunc_call_test_pass_ctx(struct __sk_buff *skb)

{

}



__bpf_kfunc void bpf_kfunc_call_test_pass1(struct prog_test_pass1 *p)

{

}



__bpf_kfunc void bpf_kfunc_call_test_pass2(struct prog_test_pass2 *p)

{

}



__bpf_kfunc void bpf_kfunc_call_test_fail1(struct prog_test_fail1 *p)

{

}



__bpf_kfunc void bpf_kfunc_call_test_fail2(struct prog_test_fail2 *p)

{

}



__bpf_kfunc void bpf_kfunc_call_test_fail3(struct prog_test_fail3 *p)

{

}



__bpf_kfunc void bpf_kfunc_call_test_mem_len_pass1(void *mem, int mem__sz)

{

}



__bpf_kfunc void bpf_kfunc_call_test_mem_len_fail1(void *mem, int len)

{

}



__bpf_kfunc void bpf_kfunc_call_test_mem_len_fail2(u64 *mem, int len)

{

}



__bpf_kfunc void bpf_kfunc_call_test_ref(struct prog_test_ref_kfunc *p)

{

	/* p != NULL, but p->cnt could be 0 */

}



__bpf_kfunc void bpf_kfunc_call_test_destructive(void)

{

}



__bpf_kfunc static u32 bpf_kfunc_call_test_static_unused_arg(u32 arg, u32 unused)

{

	return arg;

}



BTF_SET8_START(bpf_testmod_check_kfunc_ids)

BTF_ID_FLAGS(func, bpf_testmod_test_mod_kfunc)

BTF_ID_FLAGS(func, bpf_kfunc_call_test1)

BTF_ID_FLAGS(func, bpf_kfunc_call_test2)

BTF_ID_FLAGS(func, bpf_kfunc_call_test3)

BTF_ID_FLAGS(func, bpf_kfunc_call_test4)

BTF_ID_FLAGS(func, bpf_kfunc_call_test_mem_len_pass1)

BTF_ID_FLAGS(func, bpf_kfunc_call_test_mem_len_fail1)

BTF_ID_FLAGS(func, bpf_kfunc_call_test_mem_len_fail2)

BTF_ID_FLAGS(func, bpf_kfunc_call_test_acquire, KF_ACQUIRE | KF_RET_NULL)

BTF_ID_FLAGS(func, bpf_kfunc_call_memb_acquire, KF_ACQUIRE | KF_RET_NULL)

BTF_ID_FLAGS(func, bpf_kfunc_call_memb1_release, KF_RELEASE)

BTF_ID_FLAGS(func, bpf_kfunc_call_test_get_rdwr_mem, KF_RET_NULL)

BTF_ID_FLAGS(func, bpf_kfunc_call_test_get_rdonly_mem, KF_RET_NULL)

BTF_ID_FLAGS(func, bpf_kfunc_call_test_acq_rdonly_mem, KF_ACQUIRE | KF_RET_NULL)

BTF_ID_FLAGS(func, bpf_kfunc_call_int_mem_release, KF_RELEASE)

BTF_ID_FLAGS(func, bpf_kfunc_call_test_pass_ctx)

BTF_ID_FLAGS(func, bpf_kfunc_call_test_pass1)

BTF_ID_FLAGS(func, bpf_kfunc_call_test_pass2)

BTF_ID_FLAGS(func, bpf_kfunc_call_test_fail1)

BTF_ID_FLAGS(func, bpf_kfunc_call_test_fail2)

BTF_ID_FLAGS(func, bpf_kfunc_call_test_fail3)

BTF_ID_FLAGS(func, bpf_kfunc_call_test_ref, KF_TRUSTED_ARGS | KF_RCU)

BTF_ID_FLAGS(func, bpf_kfunc_call_test_destructive, KF_DESTRUCTIVE)

BTF_ID_FLAGS(func, bpf_kfunc_call_test_static_unused_arg)

BTF_ID_FLAGS(func, bpf_kfunc_call_test_offset)

BTF_SET8_END(bpf_testmod_check_kfunc_ids)



static const struct btf_kfunc_id_set bpf_testmod_kfunc_set = {
@@ -312,6 +476,8 @@ static int bpf_testmod_init(void) 


	ret = register_btf_kfunc_id_set(BPF_PROG_TYPE_UNSPEC, &bpf_testmod_common_kfunc_set);

	ret = ret ?: register_btf_kfunc_id_set(BPF_PROG_TYPE_SCHED_CLS, &bpf_testmod_kfunc_set);

	ret = ret ?: register_btf_kfunc_id_set(BPF_PROG_TYPE_TRACING, &bpf_testmod_kfunc_set);

	ret = ret ?: register_btf_kfunc_id_set(BPF_PROG_TYPE_SYSCALL, &bpf_testmod_kfunc_set);

	if (ret < 0)

		return ret;

	if (bpf_fentry_test1(0) < 0)

tools/testing/selftests/bpf/bpf_testmod/bpf_testmod_kfunc.h

0 → 100644
+100 −0
Original line number Diff line number Diff line 
/* SPDX-License-Identifier: GPL-2.0 */



#ifndef _BPF_TESTMOD_KFUNC_H

#define _BPF_TESTMOD_KFUNC_H



#ifndef __KERNEL__

#include <vmlinux.h>

#include <bpf/bpf_helpers.h>

#else

#define __ksym

struct prog_test_member1 {

	int a;

};



struct prog_test_member {

	struct prog_test_member1 m;

	int c;

};



struct prog_test_ref_kfunc {

	int a;

	int b;

	struct prog_test_member memb;

	struct prog_test_ref_kfunc *next;

	refcount_t cnt;

};

#endif



struct prog_test_pass1 {

	int x0;

	struct {

		int x1;

		struct {

			int x2;

			struct {

				int x3;

			};

		};

	};

};



struct prog_test_pass2 {

	int len;

	short arr1[4];

	struct {

		char arr2[4];

		unsigned long arr3[8];

	} x;

};



struct prog_test_fail1 {

	void *p;

	int x;

};



struct prog_test_fail2 {

	int x8;

	struct prog_test_pass1 x;

};



struct prog_test_fail3 {

	int len;

	char arr1[2];

	char arr2[];

};



struct prog_test_ref_kfunc *

bpf_kfunc_call_test_acquire(unsigned long *scalar_ptr) __ksym;

void bpf_kfunc_call_test_release(struct prog_test_ref_kfunc *p) __ksym;

void bpf_kfunc_call_test_ref(struct prog_test_ref_kfunc *p) __ksym;



void bpf_kfunc_call_test_mem_len_pass1(void *mem, int len) __ksym;

int *bpf_kfunc_call_test_get_rdwr_mem(struct prog_test_ref_kfunc *p, const int rdwr_buf_size) __ksym;

int *bpf_kfunc_call_test_get_rdonly_mem(struct prog_test_ref_kfunc *p, const int rdonly_buf_size) __ksym;

int *bpf_kfunc_call_test_acq_rdonly_mem(struct prog_test_ref_kfunc *p, const int rdonly_buf_size) __ksym;

void bpf_kfunc_call_int_mem_release(int *p) __ksym;



/* The bpf_kfunc_call_test_static_unused_arg is defined as static,

 * but bpf program compilation needs to see it as global symbol.

 */

#ifndef __KERNEL__

u32 bpf_kfunc_call_test_static_unused_arg(u32 arg, u32 unused) __ksym;

#endif



void bpf_testmod_test_mod_kfunc(int i) __ksym;



__u64 bpf_kfunc_call_test1(struct sock *sk, __u32 a, __u64 b,

				__u32 c, __u64 d) __ksym;

int bpf_kfunc_call_test2(struct sock *sk, __u32 a, __u32 b) __ksym;

struct sock *bpf_kfunc_call_test3(struct sock *sk) __ksym;

long bpf_kfunc_call_test4(signed char a, short b, int c, long d) __ksym;



void bpf_kfunc_call_test_pass_ctx(struct __sk_buff *skb) __ksym;

void bpf_kfunc_call_test_pass1(struct prog_test_pass1 *p) __ksym;

void bpf_kfunc_call_test_pass2(struct prog_test_pass2 *p) __ksym;

void bpf_kfunc_call_test_mem_len_fail2(__u64 *mem, int len) __ksym;



void bpf_kfunc_call_test_destructive(void) __ksym;



#endif /* _BPF_TESTMOD_KFUNC_H */

tools/testing/selftests/bpf/prog_tests/bpf_mod_race.c

+5 −29
Original line number Diff line number Diff line
@@ -11,6 +11,7 @@ 
#include "ksym_race.skel.h"

#include "bpf_mod_race.skel.h"

#include "kfunc_call_race.skel.h"

#include "testing_helpers.h"



/* This test crafts a race between btf_try_get_module and do_init_module, and

 * checks whether btf_try_get_module handles the invocation for a well-formed
@@ -44,35 +45,10 @@ enum bpf_test_state { 


static _Atomic enum bpf_test_state state = _TS_INVALID;



static int sys_finit_module(int fd, const char *param_values, int flags)

{

	return syscall(__NR_finit_module, fd, param_values, flags);

}



static int sys_delete_module(const char *name, unsigned int flags)

{

	return syscall(__NR_delete_module, name, flags);

}



static int load_module(const char *mod)

{

	int ret, fd;



	fd = open("bpf_testmod.ko", O_RDONLY);

	if (fd < 0)

		return fd;



	ret = sys_finit_module(fd, "", 0);

	close(fd);

	if (ret < 0)

		return ret;

	return 0;

}



static void *load_module_thread(void *p)

{



	if (!ASSERT_NEQ(load_module("bpf_testmod.ko"), 0, "load_module_thread must fail"))

	if (!ASSERT_NEQ(load_bpf_testmod(false), 0, "load_module_thread must fail"))

		atomic_store(&state, TS_MODULE_LOAD);

	else

		atomic_store(&state, TS_MODULE_LOAD_FAIL);
@@ -124,7 +100,7 @@ static void test_bpf_mod_race_config(const struct test_config *config) 
	if (!ASSERT_NEQ(fault_addr, MAP_FAILED, "mmap for uffd registration"))

		return;



	if (!ASSERT_OK(sys_delete_module("bpf_testmod", 0), "unload bpf_testmod"))

	if (!ASSERT_OK(unload_bpf_testmod(false), "unload bpf_testmod"))

		goto end_mmap;



	skel = bpf_mod_race__open();
@@ -202,8 +178,8 @@ static void test_bpf_mod_race_config(const struct test_config *config) 
	bpf_mod_race__destroy(skel);

	ASSERT_OK(kern_sync_rcu(), "kern_sync_rcu");

end_module:

	sys_delete_module("bpf_testmod", 0);

	ASSERT_OK(load_module("bpf_testmod.ko"), "restore bpf_testmod");

	unload_bpf_testmod(false);

	ASSERT_OK(load_bpf_testmod(false), "restore bpf_testmod");

end_mmap:

	munmap(fault_addr, 4096);

	atomic_store(&state, _TS_INVALID);