Commit 8158c5fd authored by Alexei Starovoitov's avatar Alexei Starovoitov
Browse files

Merge branch 'Support BTF-powered BPF tracing programs for kernel modules' 

Andrii Nakryiko says:

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

This patch sets extends kernel and libbpf with support for attaching
BTF-powered raw tracepoint (tp_btf) and tracing (fentry/fexit/fmod_ret/lsm)
BPF programs to BPF hooks defined in kernel modules. As part of that, libbpf
now supports performing CO-RE relocations against types in kernel module BTFs,
in addition to existing vmlinux BTF support.

Kernel UAPI for BPF_PROG_LOAD now allows to specify kernel module (or vmlinux)
BTF object FD in attach_btf_obj_fd field, aliased to attach_prog_fd. This is
used to identify which BTF object needs to be used for finding BTF type by
provided attach_btf_id.

This patch set also sets up a convenient and fully-controlled custom kernel
module (called "bpf_testmod"), that is a predictable playground for all the
BPF selftests, that rely on module BTFs. Currently pahole doesn't generate
BTF_KIND_FUNC info for ftrace-able static functions in kernel modules, so
expose traced function in bpf_sidecar.ko. Once pahole is enhanced, we can go
back to static function.

From end user perspective there are no extra actions that need to happen.
Libbpf will continue searching across all kernel module BTFs, if desired
attach BTF type is not found in vmlinux. That way it doesn't matter if BPF
hook that user is trying to attach to is built into vmlinux image or is
loaded in kernel module.

v5->v6:
  - move btf_put() back to syscall.c (kernel test robot);
  - added close(fd) in patch #5 (John);
v4->v5:
  - use FD to specify BTF object (Alexei);
  - move prog->aux->attach_btf putting into bpf_prog_free() for consistency
    with putting prog->aux->dst_prog;
  - fix BTF FD leak(s) in libbpf;
v3->v4:
  - merge together patch sets [0] and [1];
  - avoid increasing bpf_reg_state by reordering fields (Alexei);
  - preserve btf_data_size in struct module;
v2->v3:
  - fix subtle uninitialized variable use in BTF ID iteration code;
v1->v2:
  - module_put() inside preempt_disable() region (Alexei);
  - bpf_sidecar -> bpf_testmod rename (Alexei);
  - test_progs more relaxed handling of bpf_testmod;
  - test_progs marks skipped sub-tests properly as SKIP now.

  [0] https://patchwork.kernel.org/project/netdevbpf/list/?series=393677&state=*
  [1] https://patchwork.kernel.org/project/netdevbpf/list/?series=393679&state=*


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

Signed-off-by: default avatarAlexei Starovoitov <ast@kernel.org>
parents cadd6480 1e38abef

include/linux/bpf.h

+9 −4
Original line number Diff line number Diff line
@@ -421,8 +421,11 @@ struct bpf_insn_access_aux { 
	enum bpf_reg_type reg_type;

	union {

		int ctx_field_size;

		struct {

			struct btf *btf;

			u32 btf_id;

		};

	};

	struct bpf_verifier_log *log; /* for verbose logs */

};
@@ -458,6 +461,7 @@ struct bpf_verifier_ops { 
				  struct bpf_insn *dst,

				  struct bpf_prog *prog, u32 *target_size);

	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,

				 u32 *next_btf_id);
@@ -771,6 +775,7 @@ struct bpf_prog_aux { 
	u32 ctx_arg_info_size;

	u32 max_rdonly_access;

	u32 max_rdwr_access;

	struct btf *attach_btf;

	const struct bpf_ctx_arg_aux *ctx_arg_info;

	struct mutex dst_mutex; /* protects dst_* pointers below, *after* prog becomes visible */

	struct bpf_prog *dst_prog;
@@ -1005,7 +1010,6 @@ struct bpf_event_entry { 


bool bpf_prog_array_compatible(struct bpf_array *array, const struct bpf_prog *fp);

int bpf_prog_calc_tag(struct bpf_prog *fp);

const char *kernel_type_name(u32 btf_type_id);



const struct bpf_func_proto *bpf_get_trace_printk_proto(void);
@@ -1450,12 +1454,13 @@ int bpf_prog_test_run_raw_tp(struct bpf_prog *prog, 
bool btf_ctx_access(int off, int size, enum bpf_access_type type,

		    const struct bpf_prog *prog,

		    struct bpf_insn_access_aux *info);

int btf_struct_access(struct bpf_verifier_log *log,

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,

		      u32 *next_btf_id);

bool btf_struct_ids_match(struct bpf_verifier_log *log,

			  int off, u32 id, u32 need_type_id);

			  const struct btf *btf, u32 id, int off,

			  const struct btf *need_btf, u32 need_type_id);



int btf_distill_func_proto(struct bpf_verifier_log *log,

			   struct btf *btf,

include/linux/bpf_verifier.h

+21 −7
Original line number Diff line number Diff line
@@ -5,6 +5,7 @@ 
#define _LINUX_BPF_VERIFIER_H 1



#include <linux/bpf.h> /* for enum bpf_reg_type */

#include <linux/btf.h> /* for struct btf and btf_id() */

#include <linux/filter.h> /* for MAX_BPF_STACK */

#include <linux/tnum.h>
@@ -43,6 +44,8 @@ enum bpf_reg_liveness { 
struct bpf_reg_state {

	/* Ordering of fields matters.  See states_equal() */

	enum bpf_reg_type type;

	/* Fixed part of pointer offset, pointer types only */

	s32 off;

	union {

		/* valid when type == PTR_TO_PACKET */

		int range;
@@ -52,15 +55,20 @@ struct bpf_reg_state { 
		 */

		struct bpf_map *map_ptr;



		u32 btf_id; /* for PTR_TO_BTF_ID */

		/* for PTR_TO_BTF_ID */

		struct {

			struct btf *btf;

			u32 btf_id;

		};



		u32 mem_size; /* for PTR_TO_MEM | PTR_TO_MEM_OR_NULL */



		/* Max size from any of the above. */

		unsigned long raw;

		struct {

			unsigned long raw1;

			unsigned long raw2;

		} raw;

	};

	/* Fixed part of pointer offset, pointer types only */

	s32 off;

	/* For PTR_TO_PACKET, used to find other pointers with the same variable

	 * offset, so they can share range knowledge.

	 * For PTR_TO_MAP_VALUE_OR_NULL this is used to share which map value we
@@ -311,7 +319,10 @@ struct bpf_insn_aux_data { 
		struct {

			enum bpf_reg_type reg_type;	/* type of pseudo_btf_id */

			union {

				struct {

					struct btf *btf;

					u32 btf_id;	/* btf_id for struct typed var */

				};

				u32 mem_size;	/* mem_size for non-struct typed var */

			};

		} btf_var;
@@ -459,9 +470,12 @@ int check_ctx_reg(struct bpf_verifier_env *env, 


/* this lives here instead of in bpf.h because it needs to dereference tgt_prog */

static inline u64 bpf_trampoline_compute_key(const struct bpf_prog *tgt_prog,

					     u32 btf_id)

					     struct btf *btf, u32 btf_id)

{

        return tgt_prog ? (((u64)tgt_prog->aux->id) << 32 | btf_id) : btf_id;

	if (tgt_prog)

		return ((u64)tgt_prog->aux->id << 32) | btf_id;

	else

		return ((u64)btf_obj_id(btf) << 32) | 0x80000000 | btf_id;

}



int bpf_check_attach_target(struct bpf_verifier_log *log,

include/linux/btf.h

+5 −1
Original line number Diff line number Diff line
@@ -18,6 +18,7 @@ struct btf_show; 


extern const struct file_operations btf_fops;



void btf_get(struct btf *btf);

void btf_put(struct btf *btf);

int btf_new_fd(const union bpf_attr *attr);

struct btf *btf_get_by_fd(int fd);
@@ -88,7 +89,8 @@ int btf_type_snprintf_show(const struct btf *btf, u32 type_id, void *obj, 
			   char *buf, int len, u64 flags);



int btf_get_fd_by_id(u32 id);

u32 btf_id(const struct btf *btf);

u32 btf_obj_id(const struct btf *btf);

bool btf_is_kernel(const struct btf *btf);

bool btf_member_is_reg_int(const struct btf *btf, const struct btf_type *s,

			   const struct btf_member *m,

			   u32 expected_offset, u32 expected_size);
@@ -206,6 +208,8 @@ static inline const struct btf_var_secinfo *btf_type_var_secinfo( 
}



#ifdef CONFIG_BPF_SYSCALL

struct bpf_prog;



const struct btf_type *btf_type_by_id(const struct btf *btf, u32 type_id);

const char *btf_name_by_offset(const struct btf *btf, u32 offset);

struct btf *btf_parse_vmlinux(void);

include/uapi/linux/bpf.h

+6 −1
Original line number Diff line number Diff line
@@ -557,7 +557,12 @@ union bpf_attr { 
		__aligned_u64	line_info;	/* line info */

		__u32		line_info_cnt;	/* number of bpf_line_info records */

		__u32		attach_btf_id;	/* in-kernel BTF type id to attach to */

		__u32		attach_prog_fd; /* 0 to attach to vmlinux */

		union {

			/* valid prog_fd to attach to bpf prog */

			__u32		attach_prog_fd;

			/* or valid module BTF object fd or 0 to attach to vmlinux */

			__u32		attach_btf_obj_fd;

		};

	};



	struct { /* anonymous struct used by BPF_OBJ_* commands */

kernel/bpf/btf.c

+49 −21
Original line number Diff line number Diff line
@@ -1524,6 +1524,11 @@ static void btf_free_rcu(struct rcu_head *rcu) 
	btf_free(btf);

}



void btf_get(struct btf *btf)

{

	refcount_inc(&btf->refcnt);

}



void btf_put(struct btf *btf)

{

	if (btf && refcount_dec_and_test(&btf->refcnt)) {
@@ -4555,11 +4560,10 @@ struct btf *bpf_prog_get_target_btf(const struct bpf_prog *prog) 
{

	struct bpf_prog *tgt_prog = prog->aux->dst_prog;



	if (tgt_prog) {

	if (tgt_prog)

		return tgt_prog->aux->btf;

	} else {

		return btf_vmlinux;

	}

	else

		return prog->aux->attach_btf;

}



static bool is_string_ptr(struct btf *btf, const struct btf_type *t)
@@ -4700,6 +4704,7 @@ bool btf_ctx_access(int off, int size, enum bpf_access_type type, 


		if (ctx_arg_info->offset == off) {

			info->reg_type = ctx_arg_info->reg_type;

			info->btf = btf_vmlinux;

			info->btf_id = ctx_arg_info->btf_id;

			return true;

		}
@@ -4716,6 +4721,7 @@ bool btf_ctx_access(int off, int size, enum bpf_access_type type, 


		ret = btf_translate_to_vmlinux(log, btf, t, tgt_type, arg);

		if (ret > 0) {

			info->btf = btf_vmlinux;

			info->btf_id = ret;

			return true;

		} else {
@@ -4723,6 +4729,7 @@ bool btf_ctx_access(int off, int size, enum bpf_access_type type, 
		}

	}



	info->btf = btf;

	info->btf_id = t->type;

	t = btf_type_by_id(btf, t->type);

	/* skip modifiers */
@@ -4749,7 +4756,7 @@ enum bpf_struct_walk_result { 
	WALK_STRUCT,

};



static int btf_struct_walk(struct bpf_verifier_log *log,

static int btf_struct_walk(struct bpf_verifier_log *log, const struct btf *btf,

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

			   u32 *next_btf_id)

{
@@ -4760,7 +4767,7 @@ static int btf_struct_walk(struct bpf_verifier_log *log, 
	u32 vlen, elem_id, mid;



again:

	tname = __btf_name_by_offset(btf_vmlinux, t->name_off);

	tname = __btf_name_by_offset(btf, t->name_off);

	if (!btf_type_is_struct(t)) {

		bpf_log(log, "Type '%s' is not a struct\n", tname);

		return -EINVAL;
@@ -4777,7 +4784,7 @@ again: 
			goto error;



		member = btf_type_member(t) + vlen - 1;

		mtype = btf_type_skip_modifiers(btf_vmlinux, member->type,

		mtype = btf_type_skip_modifiers(btf, member->type,

						NULL);

		if (!btf_type_is_array(mtype))

			goto error;
@@ -4793,7 +4800,7 @@ again: 
		/* Only allow structure for now, can be relaxed for

		 * other types later.

		 */

		t = btf_type_skip_modifiers(btf_vmlinux, array_elem->type,

		t = btf_type_skip_modifiers(btf, array_elem->type,

					    NULL);

		if (!btf_type_is_struct(t))

			goto error;
@@ -4851,10 +4858,10 @@ error: 


		/* type of the field */

		mid = member->type;

		mtype = btf_type_by_id(btf_vmlinux, member->type);

		mname = __btf_name_by_offset(btf_vmlinux, member->name_off);

		mtype = btf_type_by_id(btf, member->type);

		mname = __btf_name_by_offset(btf, member->name_off);



		mtype = __btf_resolve_size(btf_vmlinux, mtype, &msize,

		mtype = __btf_resolve_size(btf, mtype, &msize,

					   &elem_type, &elem_id, &total_nelems,

					   &mid);

		if (IS_ERR(mtype)) {
@@ -4949,7 +4956,7 @@ error: 
					mname, moff, tname, off, size);

				return -EACCES;

			}

			stype = btf_type_skip_modifiers(btf_vmlinux, mtype->type, &id);

			stype = btf_type_skip_modifiers(btf, mtype->type, &id);

			if (btf_type_is_struct(stype)) {

				*next_btf_id = id;

				return WALK_PTR;
@@ -4975,7 +4982,7 @@ error: 
	return -EINVAL;

}



int btf_struct_access(struct bpf_verifier_log *log,

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 __maybe_unused,

		      u32 *next_btf_id)
@@ -4984,7 +4991,7 @@ int btf_struct_access(struct bpf_verifier_log *log, 
	u32 id;



	do {

		err = btf_struct_walk(log, t, off, size, &id);

		err = btf_struct_walk(log, btf, t, off, size, &id);



		switch (err) {

		case WALK_PTR:
@@ -5000,7 +5007,7 @@ int btf_struct_access(struct bpf_verifier_log *log, 
			 * by diving in it. At this point the offset is

			 * aligned with the new type, so set it to 0.

			 */

			t = btf_type_by_id(btf_vmlinux, id);

			t = btf_type_by_id(btf, id);

			off = 0;

			break;

		default:
@@ -5016,21 +5023,37 @@ int btf_struct_access(struct bpf_verifier_log *log, 
	return -EINVAL;

}



/* Check that two BTF types, each specified as an BTF object + id, are exactly

 * the same. Trivial ID check is not enough due to module BTFs, because we can

 * end up with two different module BTFs, but IDs point to the common type in

 * vmlinux BTF.

 */

static bool btf_types_are_same(const struct btf *btf1, u32 id1,

			       const struct btf *btf2, u32 id2)

{

	if (id1 != id2)

		return false;

	if (btf1 == btf2)

		return true;

	return btf_type_by_id(btf1, id1) == btf_type_by_id(btf2, id2);

}



bool btf_struct_ids_match(struct bpf_verifier_log *log,

			  int off, u32 id, u32 need_type_id)

			  const struct btf *btf, u32 id, int off,

			  const struct btf *need_btf, u32 need_type_id)

{

	const struct btf_type *type;

	int err;



	/* Are we already done? */

	if (need_type_id == id && off == 0)

	if (off == 0 && btf_types_are_same(btf, id, need_btf, need_type_id))

		return true;



again:

	type = btf_type_by_id(btf_vmlinux, id);

	type = btf_type_by_id(btf, id);

	if (!type)

		return false;

	err = btf_struct_walk(log, type, off, 1, &id);

	err = btf_struct_walk(log, btf, type, off, 1, &id);

	if (err != WALK_STRUCT)

		return false;
@@ -5039,7 +5062,7 @@ again: 
	 * continue the search with offset 0 in the new

	 * type.

	 */

	if (need_type_id != id) {

	if (!btf_types_are_same(btf, id, need_btf, need_type_id)) {

		off = 0;

		goto again;

	}
@@ -5710,11 +5733,16 @@ int btf_get_fd_by_id(u32 id) 
	return fd;

}



u32 btf_id(const struct btf *btf)

u32 btf_obj_id(const struct btf *btf)

{

	return btf->id;

}



bool btf_is_kernel(const struct btf *btf)

{

	return btf->kernel_btf;

}



static int btf_id_cmp_func(const void *a, const void *b)

{

	const int *pa = a, *pb = b;

CRA Git | Maintained and supported by SUSTech CRA and CCSE