Commit 0e6f601e authored by Alexei Starovoitov's avatar Alexei Starovoitov
Browse files

Merge branch 'Integrate kernel module BTF support' 

Andrii Nakryiko says:

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

This patch set adds BTF generation for kernel modules using a compact split
BTF approach. Respective patches have all the details.

Kernel module BTFs rely on pahole's split BTF support, which is added in [0]
and will be available starting from v1.19. Support for it is detected
automatically during kernel build time.

This patch set implements in-kernel support for split BTF loading and
validation. It also extends GET_OBJ_INFO API for BTFs to return BTF's module
name and a flag whether BTF itself is in-kernel or user-provided. vmlinux BTF
is also exposed to user-space through the same BTF object iteration APIs.

Follow up patch set will utilize the fact that vmlinux and module BTFs now
have associated ID to provide ability to attach BPF fentry/fexit/etc programs
to functions defined in kernel modules.

bpftool is also extended to show module/vmlinux BTF's name.

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



v3->v4:
  - copy_to_user() on ENOSPC in btf_get_info_by_fd() (Martin);
v2->v3:
  - get rid of unnecessary gotos (Song);
v2->v1:
  - drop WARNs, add fewer pr_warn()'s instead (Greg);
  - properly initialize sysfs binary attribute structure (Greg);
  - add __maybe_unused to any_section_objs, used conditionally by module BTF;
rfc->v1:
  - CONFIG_DEBUG_INFO_BTF_MODULES is derived automatically (Alexei);
  - vmlinux BTF now has explicit "vmlinux" name (Alexei);
  - added sysfs ABI documentation for /sys/kernel/btf/<module> (Greg).

Cc: Arnaldo Carvalho de Melo <acme@redhat.com>
Cc: Greg Kroah-Hartman <gregkh@linuxfoundation.org>
====================

Signed-off-by: default avatarAlexei Starovoitov <ast@kernel.org>
parents f52b8fd3 cecaf4a0

Documentation/ABI/testing/sysfs-kernel-btf

+8 −0
Original line number Diff line number Diff line
@@ -15,3 +15,11 @@ Description: 
		information with description of all internal kernel types. See

		Documentation/bpf/btf.rst for detailed description of format

		itself.



What:		/sys/kernel/btf/<module-name>

Date:		Nov 2020

KernelVersion:	5.11

Contact:	bpf@vger.kernel.org

Description:

		Read-only binary attribute exposing kernel module's BTF type

		information as an add-on to the kernel's BTF (/sys/kernel/btf/vmlinux).

include/linux/bpf.h

+2 −0
Original line number Diff line number Diff line
@@ -36,9 +36,11 @@ struct seq_operations; 
struct bpf_iter_aux_info;

struct bpf_local_storage;

struct bpf_local_storage_map;

struct kobject;



extern struct idr btf_idr;

extern spinlock_t btf_idr_lock;

extern struct kobject *btf_kobj;



typedef int (*bpf_iter_init_seq_priv_t)(void *private_data,

					struct bpf_iter_aux_info *aux);

include/linux/module.h

+4 −0
Original line number Diff line number Diff line
@@ -475,6 +475,10 @@ struct module { 
	unsigned int num_bpf_raw_events;

	struct bpf_raw_event_map *bpf_raw_events;

#endif

#ifdef CONFIG_DEBUG_INFO_BTF_MODULES

	unsigned int btf_data_size;

	void *btf_data;

#endif

#ifdef CONFIG_JUMP_LABEL

	struct jump_entry *jump_entries;

	unsigned int num_jump_entries;

include/uapi/linux/bpf.h

+3 −0
Original line number Diff line number Diff line
@@ -4466,6 +4466,9 @@ struct bpf_btf_info { 
	__aligned_u64 btf;

	__u32 btf_size;

	__u32 id;

	__aligned_u64 name;

	__u32 name_len;

	__u32 kernel_btf;

} __attribute__((aligned(8)));



struct bpf_link_info {

kernel/bpf/btf.c

+352 −54
Original line number Diff line number Diff line
@@ -22,6 +22,8 @@ 
#include <linux/skmsg.h>

#include <linux/perf_event.h>

#include <linux/bsearch.h>

#include <linux/kobject.h>

#include <linux/sysfs.h>

#include <net/sock.h>



/* BTF (BPF Type Format) is the meta data format which describes
@@ -203,12 +205,19 @@ struct btf { 
	const char *strings;

	void *nohdr_data;

	struct btf_header hdr;

	u32 nr_types;

	u32 nr_types; /* includes VOID for base BTF */

	u32 types_size;

	u32 data_size;

	refcount_t refcnt;

	u32 id;

	struct rcu_head rcu;



	/* split BTF support */

	struct btf *base_btf;

	u32 start_id; /* first type ID in this BTF (0 for base BTF) */

	u32 start_str_off; /* first string offset (0 for base BTF) */

	char name[MODULE_NAME_LEN];

	bool kernel_btf;

};



enum verifier_phase {
@@ -449,14 +458,27 @@ static bool btf_type_is_datasec(const struct btf_type *t) 
	return BTF_INFO_KIND(t->info) == BTF_KIND_DATASEC;

}



static u32 btf_nr_types_total(const struct btf *btf)

{

	u32 total = 0;



	while (btf) {

		total += btf->nr_types;

		btf = btf->base_btf;

	}



	return total;

}



s32 btf_find_by_name_kind(const struct btf *btf, const char *name, u8 kind)

{

	const struct btf_type *t;

	const char *tname;

	u32 i;

	u32 i, total;



	for (i = 1; i <= btf->nr_types; i++) {

		t = btf->types[i];

	total = btf_nr_types_total(btf);

	for (i = 1; i < total; i++) {

		t = btf_type_by_id(btf, i);

		if (BTF_INFO_KIND(t->info) != kind)

			continue;
@@ -599,8 +621,14 @@ static const struct btf_kind_operations *btf_type_ops(const struct btf_type *t) 


static bool btf_name_offset_valid(const struct btf *btf, u32 offset)

{

	return BTF_STR_OFFSET_VALID(offset) &&

		offset < btf->hdr.str_len;

	if (!BTF_STR_OFFSET_VALID(offset))

		return false;



	while (offset < btf->start_str_off)

		btf = btf->base_btf;



	offset -= btf->start_str_off;

	return offset < btf->hdr.str_len;

}



static bool __btf_name_char_ok(char c, bool first, bool dot_ok)
@@ -614,10 +642,22 @@ static bool __btf_name_char_ok(char c, bool first, bool dot_ok) 
	return true;

}



static const char *btf_str_by_offset(const struct btf *btf, u32 offset)

{

	while (offset < btf->start_str_off)

		btf = btf->base_btf;



	offset -= btf->start_str_off;

	if (offset < btf->hdr.str_len)

		return &btf->strings[offset];



	return NULL;

}



static bool __btf_name_valid(const struct btf *btf, u32 offset, bool dot_ok)

{

	/* offset must be valid */

	const char *src = &btf->strings[offset];

	const char *src = btf_str_by_offset(btf, offset);

	const char *src_limit;



	if (!__btf_name_char_ok(*src, true, dot_ok))
@@ -650,27 +690,28 @@ static bool btf_name_valid_section(const struct btf *btf, u32 offset) 


static const char *__btf_name_by_offset(const struct btf *btf, u32 offset)

{

	const char *name;



	if (!offset)

		return "(anon)";

	else if (offset < btf->hdr.str_len)

		return &btf->strings[offset];

	else

		return "(invalid-name-offset)";



	name = btf_str_by_offset(btf, offset);

	return name ?: "(invalid-name-offset)";

}



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

{

	if (offset < btf->hdr.str_len)

		return &btf->strings[offset];



	return NULL;

	return btf_str_by_offset(btf, offset);

}



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

{

	if (type_id > btf->nr_types)

		return NULL;

	while (type_id < btf->start_id)

		btf = btf->base_btf;



	type_id -= btf->start_id;

	if (type_id >= btf->nr_types)

		return NULL;

	return btf->types[type_id];

}
@@ -1390,17 +1431,13 @@ static int btf_add_type(struct btf_verifier_env *env, struct btf_type *t) 
{

	struct btf *btf = env->btf;



	/* < 2 because +1 for btf_void which is always in btf->types[0].

	 * btf_void is not accounted in btf->nr_types because btf_void

	 * does not come from the BTF file.

	 */

	if (btf->types_size - btf->nr_types < 2) {

	if (btf->types_size == btf->nr_types) {

		/* Expand 'types' array */



		struct btf_type **new_types;

		u32 expand_by, new_size;



		if (btf->types_size == BTF_MAX_TYPE) {

		if (btf->start_id + btf->types_size == BTF_MAX_TYPE) {

			btf_verifier_log(env, "Exceeded max num of types");

			return -E2BIG;

		}
@@ -1414,18 +1451,23 @@ static int btf_add_type(struct btf_verifier_env *env, struct btf_type *t) 
		if (!new_types)

			return -ENOMEM;



		if (btf->nr_types == 0)

		if (btf->nr_types == 0) {

			if (!btf->base_btf) {

				/* lazily init VOID type */

				new_types[0] = &btf_void;

		else

				btf->nr_types++;

			}

		} else {

			memcpy(new_types, btf->types,

			       sizeof(*btf->types) * (btf->nr_types + 1));

			       sizeof(*btf->types) * btf->nr_types);

		}



		kvfree(btf->types);

		btf->types = new_types;

		btf->types_size = new_size;

	}



	btf->types[++(btf->nr_types)] = t;

	btf->types[btf->nr_types++] = t;



	return 0;

}
@@ -1498,18 +1540,17 @@ static int env_resolve_init(struct btf_verifier_env *env) 
	u32 *resolved_ids = NULL;

	u8 *visit_states = NULL;



	/* +1 for btf_void */

	resolved_sizes = kvcalloc(nr_types + 1, sizeof(*resolved_sizes),

	resolved_sizes = kvcalloc(nr_types, sizeof(*resolved_sizes),

				  GFP_KERNEL | __GFP_NOWARN);

	if (!resolved_sizes)

		goto nomem;



	resolved_ids = kvcalloc(nr_types + 1, sizeof(*resolved_ids),

	resolved_ids = kvcalloc(nr_types, sizeof(*resolved_ids),

				GFP_KERNEL | __GFP_NOWARN);

	if (!resolved_ids)

		goto nomem;



	visit_states = kvcalloc(nr_types + 1, sizeof(*visit_states),

	visit_states = kvcalloc(nr_types, sizeof(*visit_states),

				GFP_KERNEL | __GFP_NOWARN);

	if (!visit_states)

		goto nomem;
@@ -1561,21 +1602,27 @@ static bool env_type_is_resolve_sink(const struct btf_verifier_env *env, 
static bool env_type_is_resolved(const struct btf_verifier_env *env,

				 u32 type_id)

{

	return env->visit_states[type_id] == RESOLVED;

	/* base BTF types should be resolved by now */

	if (type_id < env->btf->start_id)

		return true;



	return env->visit_states[type_id - env->btf->start_id] == RESOLVED;

}



static int env_stack_push(struct btf_verifier_env *env,

			  const struct btf_type *t, u32 type_id)

{

	const struct btf *btf = env->btf;

	struct resolve_vertex *v;



	if (env->top_stack == MAX_RESOLVE_DEPTH)

		return -E2BIG;



	if (env->visit_states[type_id] != NOT_VISITED)

	if (type_id < btf->start_id

	    || env->visit_states[type_id - btf->start_id] != NOT_VISITED)

		return -EEXIST;



	env->visit_states[type_id] = VISITED;

	env->visit_states[type_id - btf->start_id] = VISITED;



	v = &env->stack[env->top_stack++];

	v->t = t;
@@ -1605,6 +1652,7 @@ static void env_stack_pop_resolved(struct btf_verifier_env *env, 
	u32 type_id = env->stack[--(env->top_stack)].type_id;

	struct btf *btf = env->btf;



	type_id -= btf->start_id; /* adjust to local type id */

	btf->resolved_sizes[type_id] = resolved_size;

	btf->resolved_ids[type_id] = resolved_type_id;

	env->visit_states[type_id] = RESOLVED;
@@ -1709,14 +1757,30 @@ btf_resolve_size(const struct btf *btf, const struct btf_type *type, 
	return __btf_resolve_size(btf, type, type_size, NULL, NULL, NULL, NULL);

}



static u32 btf_resolved_type_id(const struct btf *btf, u32 type_id)

{

	while (type_id < btf->start_id)

		btf = btf->base_btf;



	return btf->resolved_ids[type_id - btf->start_id];

}



/* The input param "type_id" must point to a needs_resolve type */

static const struct btf_type *btf_type_id_resolve(const struct btf *btf,

						  u32 *type_id)

{

	*type_id = btf->resolved_ids[*type_id];

	*type_id = btf_resolved_type_id(btf, *type_id);

	return btf_type_by_id(btf, *type_id);

}



static u32 btf_resolved_type_size(const struct btf *btf, u32 type_id)

{

	while (type_id < btf->start_id)

		btf = btf->base_btf;



	return btf->resolved_sizes[type_id - btf->start_id];

}



const struct btf_type *btf_type_id_size(const struct btf *btf,

					u32 *type_id, u32 *ret_size)

{
@@ -1731,7 +1795,7 @@ const struct btf_type *btf_type_id_size(const struct btf *btf, 
	if (btf_type_has_size(size_type)) {

		size = size_type->size;

	} else if (btf_type_is_array(size_type)) {

		size = btf->resolved_sizes[size_type_id];

		size = btf_resolved_type_size(btf, size_type_id);

	} else if (btf_type_is_ptr(size_type)) {

		size = sizeof(void *);

	} else {
@@ -1739,14 +1803,14 @@ const struct btf_type *btf_type_id_size(const struct btf *btf, 
				 !btf_type_is_var(size_type)))

			return NULL;



		size_type_id = btf->resolved_ids[size_type_id];

		size_type_id = btf_resolved_type_id(btf, size_type_id);

		size_type = btf_type_by_id(btf, size_type_id);

		if (btf_type_nosize_or_null(size_type))

			return NULL;

		else if (btf_type_has_size(size_type))

			size = size_type->size;

		else if (btf_type_is_array(size_type))

			size = btf->resolved_sizes[size_type_id];

			size = btf_resolved_type_size(btf, size_type_id);

		else if (btf_type_is_ptr(size_type))

			size = sizeof(void *);

		else
@@ -3798,7 +3862,7 @@ static int btf_check_all_metas(struct btf_verifier_env *env) 
	cur = btf->nohdr_data + hdr->type_off;

	end = cur + hdr->type_len;



	env->log_type_id = 1;

	env->log_type_id = btf->base_btf ? btf->start_id : 1;

	while (cur < end) {

		struct btf_type *t = cur;

		s32 meta_size;
@@ -3825,8 +3889,8 @@ static bool btf_resolve_valid(struct btf_verifier_env *env, 
		return false;



	if (btf_type_is_struct(t) || btf_type_is_datasec(t))

		return !btf->resolved_ids[type_id] &&

		       !btf->resolved_sizes[type_id];

		return !btf_resolved_type_id(btf, type_id) &&

		       !btf_resolved_type_size(btf, type_id);



	if (btf_type_is_modifier(t) || btf_type_is_ptr(t) ||

	    btf_type_is_var(t)) {
@@ -3846,7 +3910,7 @@ static bool btf_resolve_valid(struct btf_verifier_env *env, 
		elem_type = btf_type_id_size(btf, &elem_type_id, &elem_size);

		return elem_type && !btf_type_is_modifier(elem_type) &&

			(array->nelems * elem_size ==

			 btf->resolved_sizes[type_id]);

			 btf_resolved_type_size(btf, type_id));

	}



	return false;
@@ -3888,7 +3952,8 @@ static int btf_resolve(struct btf_verifier_env *env, 
static int btf_check_all_types(struct btf_verifier_env *env)

{

	struct btf *btf = env->btf;

	u32 type_id;

	const struct btf_type *t;

	u32 type_id, i;

	int err;



	err = env_resolve_init(env);
@@ -3896,8 +3961,9 @@ static int btf_check_all_types(struct btf_verifier_env *env) 
		return err;



	env->phase++;

	for (type_id = 1; type_id <= btf->nr_types; type_id++) {

		const struct btf_type *t = btf_type_by_id(btf, type_id);

	for (i = btf->base_btf ? 0 : 1; i < btf->nr_types; i++) {

		type_id = btf->start_id + i;

		t = btf_type_by_id(btf, type_id);



		env->log_type_id = type_id;

		if (btf_type_needs_resolve(t) &&
@@ -3934,7 +4000,7 @@ static int btf_parse_type_sec(struct btf_verifier_env *env) 
		return -EINVAL;

	}



	if (!hdr->type_len) {

	if (!env->btf->base_btf && !hdr->type_len) {

		btf_verifier_log(env, "No type found");

		return -EINVAL;

	}
@@ -3961,13 +4027,18 @@ static int btf_parse_str_sec(struct btf_verifier_env *env) 
		return -EINVAL;

	}



	if (!hdr->str_len || hdr->str_len - 1 > BTF_MAX_NAME_OFFSET ||

	    start[0] || end[-1]) {

	btf->strings = start;



	if (btf->base_btf && !hdr->str_len)

		return 0;

	if (!hdr->str_len || hdr->str_len - 1 > BTF_MAX_NAME_OFFSET || end[-1]) {

		btf_verifier_log(env, "Invalid string section");

		return -EINVAL;

	}

	if (!btf->base_btf && start[0]) {

		btf_verifier_log(env, "Invalid string section");

		return -EINVAL;

	}



	btf->strings = start;



	return 0;

}
@@ -4362,6 +4433,8 @@ struct btf *btf_parse_vmlinux(void) 


	btf->data = __start_BTF;

	btf->data_size = __stop_BTF - __start_BTF;

	btf->kernel_btf = true;

	snprintf(btf->name, sizeof(btf->name), "vmlinux");



	err = btf_parse_hdr(env);

	if (err)
@@ -4387,6 +4460,79 @@ struct btf *btf_parse_vmlinux(void) 


	bpf_struct_ops_init(btf, log);



	refcount_set(&btf->refcnt, 1);



	err = btf_alloc_id(btf);

	if (err)

		goto errout;



	btf_verifier_env_free(env);

	return btf;



errout:

	btf_verifier_env_free(env);

	if (btf) {

		kvfree(btf->types);

		kfree(btf);

	}

	return ERR_PTR(err);

}



static struct btf *btf_parse_module(const char *module_name, const void *data, unsigned int data_size)

{

	struct btf_verifier_env *env = NULL;

	struct bpf_verifier_log *log;

	struct btf *btf = NULL, *base_btf;

	int err;



	base_btf = bpf_get_btf_vmlinux();

	if (IS_ERR(base_btf))

		return base_btf;

	if (!base_btf)

		return ERR_PTR(-EINVAL);



	env = kzalloc(sizeof(*env), GFP_KERNEL | __GFP_NOWARN);

	if (!env)

		return ERR_PTR(-ENOMEM);



	log = &env->log;

	log->level = BPF_LOG_KERNEL;



	btf = kzalloc(sizeof(*btf), GFP_KERNEL | __GFP_NOWARN);

	if (!btf) {

		err = -ENOMEM;

		goto errout;

	}

	env->btf = btf;



	btf->base_btf = base_btf;

	btf->start_id = base_btf->nr_types;

	btf->start_str_off = base_btf->hdr.str_len;

	btf->kernel_btf = true;

	snprintf(btf->name, sizeof(btf->name), "%s", module_name);



	btf->data = kvmalloc(data_size, GFP_KERNEL | __GFP_NOWARN);

	if (!btf->data) {

		err = -ENOMEM;

		goto errout;

	}

	memcpy(btf->data, data, data_size);

	btf->data_size = data_size;



	err = btf_parse_hdr(env);

	if (err)

		goto errout;



	btf->nohdr_data = btf->data + btf->hdr.hdr_len;



	err = btf_parse_str_sec(env);

	if (err)

		goto errout;



	err = btf_check_all_metas(env);

	if (err)

		goto errout;



	btf_verifier_env_free(env);

	refcount_set(&btf->refcnt, 1);

	return btf;
@@ -4394,6 +4540,7 @@ struct btf *btf_parse_vmlinux(void) 
errout:

	btf_verifier_env_free(env);

	if (btf) {

		kvfree(btf->data);

		kvfree(btf->types);

		kfree(btf);

	}
@@ -4908,7 +5055,7 @@ static int __get_type_size(struct btf *btf, u32 btf_id, 
	while (t && btf_type_is_modifier(t))

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

	if (!t) {

		*bad_type = btf->types[0];

		*bad_type = btf_type_by_id(btf, 0);

		return -EINVAL;

	}

	if (btf_type_is_ptr(t))
@@ -5486,7 +5633,9 @@ int btf_get_info_by_fd(const struct btf *btf, 
	struct bpf_btf_info info;

	u32 info_copy, btf_copy;

	void __user *ubtf;

	u32 uinfo_len;

	char __user *uname;

	u32 uinfo_len, uname_len, name_len;

	int ret = 0;



	uinfo = u64_to_user_ptr(attr->info.info);

	uinfo_len = attr->info.info_len;
@@ -5503,11 +5652,37 @@ int btf_get_info_by_fd(const struct btf *btf, 
		return -EFAULT;

	info.btf_size = btf->data_size;



	info.kernel_btf = btf->kernel_btf;



	uname = u64_to_user_ptr(info.name);

	uname_len = info.name_len;

	if (!uname ^ !uname_len)

		return -EINVAL;



	name_len = strlen(btf->name);

	info.name_len = name_len;



	if (uname) {

		if (uname_len >= name_len + 1) {

			if (copy_to_user(uname, btf->name, name_len + 1))

				return -EFAULT;

		} else {

			char zero = '\0';



			if (copy_to_user(uname, btf->name, uname_len - 1))

				return -EFAULT;

			if (put_user(zero, uname + uname_len - 1))

				return -EFAULT;

			/* let user-space know about too short buffer */

			ret = -ENOSPC;

		}

	}



	if (copy_to_user(uinfo, &info, info_copy) ||

	    put_user(info_copy, &uattr->info.info_len))

		return -EFAULT;



	return 0;

	return ret;

}



int btf_get_fd_by_id(u32 id)
@@ -5547,3 +5722,126 @@ bool btf_id_set_contains(const struct btf_id_set *set, u32 id) 
{

	return bsearch(&id, set->ids, set->cnt, sizeof(u32), btf_id_cmp_func) != NULL;

}



#ifdef CONFIG_DEBUG_INFO_BTF_MODULES

struct btf_module {

	struct list_head list;

	struct module *module;

	struct btf *btf;

	struct bin_attribute *sysfs_attr;

};



static LIST_HEAD(btf_modules);

static DEFINE_MUTEX(btf_module_mutex);



static ssize_t

btf_module_read(struct file *file, struct kobject *kobj,

		struct bin_attribute *bin_attr,

		char *buf, loff_t off, size_t len)

{

	const struct btf *btf = bin_attr->private;



	memcpy(buf, btf->data + off, len);

	return len;

}



static int btf_module_notify(struct notifier_block *nb, unsigned long op,

			     void *module)

{

	struct btf_module *btf_mod, *tmp;

	struct module *mod = module;

	struct btf *btf;

	int err = 0;



	if (mod->btf_data_size == 0 ||

	    (op != MODULE_STATE_COMING && op != MODULE_STATE_GOING))

		goto out;



	switch (op) {

	case MODULE_STATE_COMING:

		btf_mod = kzalloc(sizeof(*btf_mod), GFP_KERNEL);

		if (!btf_mod) {

			err = -ENOMEM;

			goto out;

		}

		btf = btf_parse_module(mod->name, mod->btf_data, mod->btf_data_size);

		if (IS_ERR(btf)) {

			pr_warn("failed to validate module [%s] BTF: %ld\n",

				mod->name, PTR_ERR(btf));

			kfree(btf_mod);

			err = PTR_ERR(btf);

			goto out;

		}

		err = btf_alloc_id(btf);

		if (err) {

			btf_free(btf);

			kfree(btf_mod);

			goto out;

		}



		mutex_lock(&btf_module_mutex);

		btf_mod->module = module;

		btf_mod->btf = btf;

		list_add(&btf_mod->list, &btf_modules);

		mutex_unlock(&btf_module_mutex);



		if (IS_ENABLED(CONFIG_SYSFS)) {

			struct bin_attribute *attr;



			attr = kzalloc(sizeof(*attr), GFP_KERNEL);

			if (!attr)

				goto out;



			sysfs_bin_attr_init(attr);

			attr->attr.name = btf->name;

			attr->attr.mode = 0444;

			attr->size = btf->data_size;

			attr->private = btf;

			attr->read = btf_module_read;



			err = sysfs_create_bin_file(btf_kobj, attr);

			if (err) {

				pr_warn("failed to register module [%s] BTF in sysfs: %d\n",

					mod->name, err);

				kfree(attr);

				err = 0;

				goto out;

			}



			btf_mod->sysfs_attr = attr;

		}



		break;

	case MODULE_STATE_GOING:

		mutex_lock(&btf_module_mutex);

		list_for_each_entry_safe(btf_mod, tmp, &btf_modules, list) {

			if (btf_mod->module != module)

				continue;



			list_del(&btf_mod->list);

			if (btf_mod->sysfs_attr)

				sysfs_remove_bin_file(btf_kobj, btf_mod->sysfs_attr);

			btf_put(btf_mod->btf);

			kfree(btf_mod->sysfs_attr);

			kfree(btf_mod);

			break;

		}

		mutex_unlock(&btf_module_mutex);

		break;

	}

out:

	return notifier_from_errno(err);

}



static struct notifier_block btf_module_nb = {

	.notifier_call = btf_module_notify,

};



static int __init btf_module_init(void)

{

	register_module_notifier(&btf_module_nb);

	return 0;

}



fs_initcall(btf_module_init);

#endif /* CONFIG_DEBUG_INFO_BTF_MODULES */