Commit f27a6fad authored by Alexei Starovoitov's avatar Alexei Starovoitov
Browse files

Merge branch 'introduce dummy BPF STRUCT_OPS' 

Hou Tao says:

====================

Hi,

Currently the test of BPF STRUCT_OPS depends on the specific bpf
implementation (e.g, tcp_congestion_ops), but it can not cover all
basic functionalities (e.g, return value handling), so introduce
a dummy BPF STRUCT_OPS for test purpose.

Instead of loading a userspace-implemeted bpf_dummy_ops map into
kernel and calling the specific function by writing to sysfs provided
by bpf_testmode.ko, only loading bpf_dummy_ops related prog into
kernel and calling these prog by bpf_prog_test_run(). The latter
is more flexible and has no dependency on extra kernel module.

Now the return value handling is supported by test_1(...) ops,
and passing multiple arguments is supported by test_2(...) ops.
If more is needed, test_x(...) ops can be added afterwards.

Comments are always welcome.
Regards,
Hou

Change Log:
v4:
 * add Acked-by tags in patch 1~4
 * patch 2: remove unncessary comments and update commit message
            accordingly
 * patch 4: remove unnecessary nr checking in dummy_ops_init_args()

v3: https://www.spinics.net/lists/bpf/msg48303.html
 * rebase on bpf-next
 * address comments for Martin, mainly include: merge patch 3 &
   patch 4 in v2, fix names of btf ctx access check helpers,
   handle CONFIG_NET, fix leak in dummy_ops_init_args(), and
   simplify bpf_dummy_init()
 * patch 4: use a loop to check args in test_dummy_multiple_args()

v2: https://www.spinics.net/lists/bpf/msg47948.html
 * rebase on bpf-next
 * add test_2(...) ops to test the passing of multiple arguments
 * a new patch (patch #2) is added to factor out ctx access helpers
 * address comments from Martin & Andrii

v1: https://www.spinics.net/lists/bpf/msg46787.html

RFC: https://www.spinics.net/lists/bpf/msg46117.html


====================

Signed-off-by: default avatarAlexei Starovoitov <ast@kernel.org>
parents 36e70b9b 31122b2f

include/linux/bpf.h

+43 −0
Original line number Diff line number Diff line
@@ -1000,6 +1000,10 @@ bool bpf_struct_ops_get(const void *kdata); 
void bpf_struct_ops_put(const void *kdata);

int bpf_struct_ops_map_sys_lookup_elem(struct bpf_map *map, void *key,

				       void *value);

int bpf_struct_ops_prepare_trampoline(struct bpf_tramp_progs *tprogs,

				      struct bpf_prog *prog,

				      const struct btf_func_model *model,

				      void *image, void *image_end);

static inline bool bpf_try_module_get(const void *data, struct module *owner)

{

	if (owner == BPF_MODULE_OWNER)
@@ -1014,6 +1018,22 @@ static inline void bpf_module_put(const void *data, struct module *owner) 
	else

		module_put(owner);

}



#ifdef CONFIG_NET

/* Define it here to avoid the use of forward declaration */

struct bpf_dummy_ops_state {

	int val;

};



struct bpf_dummy_ops {

	int (*test_1)(struct bpf_dummy_ops_state *cb);

	int (*test_2)(struct bpf_dummy_ops_state *cb, int a1, unsigned short a2,

		      char a3, unsigned long a4);

};



int bpf_struct_ops_test_run(struct bpf_prog *prog, const union bpf_attr *kattr,

			    union bpf_attr __user *uattr);

#endif

#else

static inline const struct bpf_struct_ops *bpf_struct_ops_find(u32 type_id)

{
@@ -1646,6 +1666,29 @@ bool bpf_prog_test_check_kfunc_call(u32 kfunc_id, struct module *owner); 
bool btf_ctx_access(int off, int size, enum bpf_access_type type,

		    const struct bpf_prog *prog,

		    struct bpf_insn_access_aux *info);



static inline bool bpf_tracing_ctx_access(int off, int size,

					  enum bpf_access_type type)

{

	if (off < 0 || off >= sizeof(__u64) * MAX_BPF_FUNC_ARGS)

		return false;

	if (type != BPF_READ)

		return false;

	if (off % size != 0)

		return false;

	return true;

}



static inline bool bpf_tracing_btf_ctx_access(int off, int size,

					      enum bpf_access_type type,

					      const struct bpf_prog *prog,

					      struct bpf_insn_access_aux *info)

{

	if (!bpf_tracing_ctx_access(off, size, type))

		return false;

	return btf_ctx_access(off, size, type, prog, info);

}



int btf_struct_access(struct bpf_verifier_log *log, const struct btf *btf,

		      const struct btf_type *t, int off, int size,

		      enum bpf_access_type atype,

kernel/bpf/bpf_struct_ops.c

+22 −10
Original line number Diff line number Diff line
@@ -93,6 +93,9 @@ const struct bpf_verifier_ops bpf_struct_ops_verifier_ops = { 
};



const struct bpf_prog_ops bpf_struct_ops_prog_ops = {

#ifdef CONFIG_NET

	.test_run = bpf_struct_ops_test_run,

#endif

};



static const struct btf_type *module_type;
@@ -312,6 +315,20 @@ static int check_zero_holes(const struct btf_type *t, void *data) 
	return 0;

}



int bpf_struct_ops_prepare_trampoline(struct bpf_tramp_progs *tprogs,

				      struct bpf_prog *prog,

				      const struct btf_func_model *model,

				      void *image, void *image_end)

{

	u32 flags;



	tprogs[BPF_TRAMP_FENTRY].progs[0] = prog;

	tprogs[BPF_TRAMP_FENTRY].nr_progs = 1;

	flags = model->ret_size > 0 ? BPF_TRAMP_F_RET_FENTRY_RET : 0;

	return arch_prepare_bpf_trampoline(NULL, image, image_end,

					   model, flags, tprogs, NULL);

}



static int bpf_struct_ops_map_update_elem(struct bpf_map *map, void *key,

					  void *value, u64 flags)

{
@@ -323,7 +340,7 @@ static int bpf_struct_ops_map_update_elem(struct bpf_map *map, void *key, 
	struct bpf_tramp_progs *tprogs = NULL;

	void *udata, *kdata;

	int prog_fd, err = 0;

	void *image;

	void *image, *image_end;

	u32 i;



	if (flags)
@@ -363,12 +380,12 @@ static int bpf_struct_ops_map_update_elem(struct bpf_map *map, void *key, 
	udata = &uvalue->data;

	kdata = &kvalue->data;

	image = st_map->image;

	image_end = st_map->image + PAGE_SIZE;



	for_each_member(i, t, member) {

		const struct btf_type *mtype, *ptype;

		struct bpf_prog *prog;

		u32 moff;

		u32 flags;



		moff = btf_member_bit_offset(t, member) / 8;

		ptype = btf_type_resolve_ptr(btf_vmlinux, member->type, NULL);
@@ -430,14 +447,9 @@ static int bpf_struct_ops_map_update_elem(struct bpf_map *map, void *key, 
			goto reset_unlock;

		}



		tprogs[BPF_TRAMP_FENTRY].progs[0] = prog;

		tprogs[BPF_TRAMP_FENTRY].nr_progs = 1;

		flags = st_ops->func_models[i].ret_size > 0 ?

			BPF_TRAMP_F_RET_FENTRY_RET : 0;

		err = arch_prepare_bpf_trampoline(NULL, image,

						  st_map->image + PAGE_SIZE,

		err = bpf_struct_ops_prepare_trampoline(tprogs, prog,

							&st_ops->func_models[i],

						  flags, tprogs, NULL);

							image, image_end);

		if (err < 0)

			goto reset_unlock;

kernel/bpf/bpf_struct_ops_types.h

+3 −0
Original line number Diff line number Diff line
@@ -2,6 +2,9 @@ 
/* internal file - do not include directly */



#ifdef CONFIG_BPF_JIT

#ifdef CONFIG_NET

BPF_STRUCT_OPS_TYPE(bpf_dummy_ops)

#endif

#ifdef CONFIG_INET

#include <net/tcp.h>

BPF_STRUCT_OPS_TYPE(tcp_congestion_ops)

kernel/trace/bpf_trace.c

+2 −14
Original line number Diff line number Diff line
@@ -1646,13 +1646,7 @@ static bool raw_tp_prog_is_valid_access(int off, int size, 
					const struct bpf_prog *prog,

					struct bpf_insn_access_aux *info)

{

	if (off < 0 || off >= sizeof(__u64) * MAX_BPF_FUNC_ARGS)

		return false;

	if (type != BPF_READ)

		return false;

	if (off % size != 0)

		return false;

	return true;

	return bpf_tracing_ctx_access(off, size, type);

}



static bool tracing_prog_is_valid_access(int off, int size,
@@ -1660,13 +1654,7 @@ static bool tracing_prog_is_valid_access(int off, int size, 
					 const struct bpf_prog *prog,

					 struct bpf_insn_access_aux *info)

{

	if (off < 0 || off >= sizeof(__u64) * MAX_BPF_FUNC_ARGS)

		return false;

	if (type != BPF_READ)

		return false;

	if (off % size != 0)

		return false;

	return btf_ctx_access(off, size, type, prog, info);

	return bpf_tracing_btf_ctx_access(off, size, type, prog, info);

}



int __weak bpf_prog_test_run_tracing(struct bpf_prog *prog,

net/bpf/Makefile

+3 −0
Original line number Diff line number Diff line 
# SPDX-License-Identifier: GPL-2.0-only

obj-$(CONFIG_BPF_SYSCALL)	:= test_run.o

ifeq ($(CONFIG_BPF_JIT),y)

obj-$(CONFIG_BPF_SYSCALL)	+= bpf_dummy_struct_ops.o

endif