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

Merge branch 'libbpf: remove deprecated APIs' 

Andrii Nakryiko says:

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

This patch set removes all the deprecated APIs in preparation for 1.0 release.
It also makes libbpf_set_strict_mode() a no-op (but keeps it to let per-1.0
applications buildable and dynamically linkable against libbpf 1.0 if they
were already libbpf-1.0 ready) and starts enforcing all the
behaviors that were previously opt-in through libbpf_set_strict_mode().

xsk.{c,h} parts that are now properly provided by libxdp ([0]) are still used
by xdpxceiver.c in selftest/bpf, so I've moved xsk.{c,h} with barely any
changes to under selftests/bpf.

Other than that, apart from removing all the LIBBPF_DEPRECATED-marked APIs,
there is a bunch of internal clean ups allowed by that. I've also "restored"
libbpf.map inheritance chain while removing all the deprecated APIs. I think
that's the right way to do this, as applications using libbpf as shared
library but not relying on any deprecated APIs (i.e., "good citizens" that
prepared for libbpf 1.0 release ahead of time to minimize disruption) should
be able to link both against 0.x and 1.x versions. Either way, it doesn't seem
to break anything and preserve a history on when each "surviving" API was
added.

  [0] https://github.com/xdp-project/xdp-tools/tree/master/lib/libxdp



v1->v2:
  - rebase on latest bpf-next now that Jiri's perf patches landed;
  - fix xsk.o dependency in Makefile to ensure libbpf headers are installed
    reliably.
====================

Signed-off-by: default avatarAlexei Starovoitov <ast@kernel.org>
parents 697fb80a ab9a5a05

tools/lib/bpf/Build

+1 −1
Original line number Diff line number Diff line 
libbpf-y := libbpf.o bpf.o nlattr.o btf.o libbpf_errno.o str_error.o \

	    netlink.o bpf_prog_linfo.o libbpf_probes.o xsk.o hashmap.o \

	    netlink.o bpf_prog_linfo.o libbpf_probes.o hashmap.o \

	    btf_dump.o ringbuf.o strset.o linker.o gen_loader.o relo_core.o \

	    usdt.o

tools/lib/bpf/Makefile

+1 −1
Original line number Diff line number Diff line
@@ -237,7 +237,7 @@ install_lib: all_cmd 
		$(call do_install_mkdir,$(libdir_SQ)); \

		cp -fpR $(LIB_FILE) $(DESTDIR)$(libdir_SQ)



SRC_HDRS := bpf.h libbpf.h btf.h libbpf_common.h libbpf_legacy.h xsk.h	     \

SRC_HDRS := bpf.h libbpf.h btf.h libbpf_common.h libbpf_legacy.h	     \

	    bpf_helpers.h bpf_tracing.h bpf_endian.h bpf_core_read.h	     \

	    skel_internal.h libbpf_version.h usdt.bpf.h

GEN_HDRS := $(BPF_GENERATED)

tools/lib/bpf/bpf.c

+4 −174
Original line number Diff line number Diff line
@@ -147,10 +147,6 @@ int bump_rlimit_memlock(void) 
{

	struct rlimit rlim;



	/* this the default in libbpf 1.0, but for now user has to opt-in explicitly */

	if (!(libbpf_mode & LIBBPF_STRICT_AUTO_RLIMIT_MEMLOCK))

		return 0;



	/* if kernel supports memcg-based accounting, skip bumping RLIMIT_MEMLOCK */

	if (memlock_bumped || kernel_supports(NULL, FEAT_MEMCG_ACCOUNT))

		return 0;
@@ -233,8 +229,7 @@ alloc_zero_tailing_info(const void *orecord, __u32 cnt, 
	return info;

}



DEFAULT_VERSION(bpf_prog_load_v0_6_0, bpf_prog_load, LIBBPF_0.6.0)

int bpf_prog_load_v0_6_0(enum bpf_prog_type prog_type,

int bpf_prog_load(enum bpf_prog_type prog_type,

		  const char *prog_name, const char *license,

		  const struct bpf_insn *insns, size_t insn_cnt,

		  const struct bpf_prog_load_opts *opts)
@@ -384,94 +379,6 @@ int bpf_prog_load_v0_6_0(enum bpf_prog_type prog_type, 
	return libbpf_err_errno(fd);

}



__attribute__((alias("bpf_load_program_xattr2")))

int bpf_load_program_xattr(const struct bpf_load_program_attr *load_attr,

			   char *log_buf, size_t log_buf_sz);



static int bpf_load_program_xattr2(const struct bpf_load_program_attr *load_attr,

				   char *log_buf, size_t log_buf_sz)

{

	LIBBPF_OPTS(bpf_prog_load_opts, p);



	if (!load_attr || !log_buf != !log_buf_sz)

		return libbpf_err(-EINVAL);



	p.expected_attach_type = load_attr->expected_attach_type;

	switch (load_attr->prog_type) {

	case BPF_PROG_TYPE_STRUCT_OPS:

	case BPF_PROG_TYPE_LSM:

		p.attach_btf_id = load_attr->attach_btf_id;

		break;

	case BPF_PROG_TYPE_TRACING:

	case BPF_PROG_TYPE_EXT:

		p.attach_btf_id = load_attr->attach_btf_id;

		p.attach_prog_fd = load_attr->attach_prog_fd;

		break;

	default:

		p.prog_ifindex = load_attr->prog_ifindex;

		p.kern_version = load_attr->kern_version;

	}

	p.log_level = load_attr->log_level;

	p.log_buf = log_buf;

	p.log_size = log_buf_sz;

	p.prog_btf_fd = load_attr->prog_btf_fd;

	p.func_info_rec_size = load_attr->func_info_rec_size;

	p.func_info_cnt = load_attr->func_info_cnt;

	p.func_info = load_attr->func_info;

	p.line_info_rec_size = load_attr->line_info_rec_size;

	p.line_info_cnt = load_attr->line_info_cnt;

	p.line_info = load_attr->line_info;

	p.prog_flags = load_attr->prog_flags;



	return bpf_prog_load(load_attr->prog_type, load_attr->name, load_attr->license,

			     load_attr->insns, load_attr->insns_cnt, &p);

}



int bpf_load_program(enum bpf_prog_type type, const struct bpf_insn *insns,

		     size_t insns_cnt, const char *license,

		     __u32 kern_version, char *log_buf,

		     size_t log_buf_sz)

{

	struct bpf_load_program_attr load_attr;



	memset(&load_attr, 0, sizeof(struct bpf_load_program_attr));

	load_attr.prog_type = type;

	load_attr.expected_attach_type = 0;

	load_attr.name = NULL;

	load_attr.insns = insns;

	load_attr.insns_cnt = insns_cnt;

	load_attr.license = license;

	load_attr.kern_version = kern_version;



	return bpf_load_program_xattr2(&load_attr, log_buf, log_buf_sz);

}



int bpf_verify_program(enum bpf_prog_type type, const struct bpf_insn *insns,

		       size_t insns_cnt, __u32 prog_flags, const char *license,

		       __u32 kern_version, char *log_buf, size_t log_buf_sz,

		       int log_level)

{

	union bpf_attr attr;

	int fd;



	bump_rlimit_memlock();



	memset(&attr, 0, sizeof(attr));

	attr.prog_type = type;

	attr.insn_cnt = (__u32)insns_cnt;

	attr.insns = ptr_to_u64(insns);

	attr.license = ptr_to_u64(license);

	attr.log_buf = ptr_to_u64(log_buf);

	attr.log_size = log_buf_sz;

	attr.log_level = log_level;

	log_buf[0] = 0;

	attr.kern_version = kern_version;

	attr.prog_flags = prog_flags;



	fd = sys_bpf_prog_load(&attr, sizeof(attr), PROG_LOAD_ATTEMPTS);

	return libbpf_err_errno(fd);

}



int bpf_map_update_elem(int fd, const void *key, const void *value,

			__u64 flags)

{
@@ -910,62 +817,6 @@ int bpf_prog_query(int target_fd, enum bpf_attach_type type, __u32 query_flags, 
	return libbpf_err_errno(ret);

}



int bpf_prog_test_run(int prog_fd, int repeat, void *data, __u32 size,

		      void *data_out, __u32 *size_out, __u32 *retval,

		      __u32 *duration)

{

	union bpf_attr attr;

	int ret;



	memset(&attr, 0, sizeof(attr));

	attr.test.prog_fd = prog_fd;

	attr.test.data_in = ptr_to_u64(data);

	attr.test.data_out = ptr_to_u64(data_out);

	attr.test.data_size_in = size;

	attr.test.repeat = repeat;



	ret = sys_bpf(BPF_PROG_TEST_RUN, &attr, sizeof(attr));



	if (size_out)

		*size_out = attr.test.data_size_out;

	if (retval)

		*retval = attr.test.retval;

	if (duration)

		*duration = attr.test.duration;



	return libbpf_err_errno(ret);

}



int bpf_prog_test_run_xattr(struct bpf_prog_test_run_attr *test_attr)

{

	union bpf_attr attr;

	int ret;



	if (!test_attr->data_out && test_attr->data_size_out > 0)

		return libbpf_err(-EINVAL);



	memset(&attr, 0, sizeof(attr));

	attr.test.prog_fd = test_attr->prog_fd;

	attr.test.data_in = ptr_to_u64(test_attr->data_in);

	attr.test.data_out = ptr_to_u64(test_attr->data_out);

	attr.test.data_size_in = test_attr->data_size_in;

	attr.test.data_size_out = test_attr->data_size_out;

	attr.test.ctx_in = ptr_to_u64(test_attr->ctx_in);

	attr.test.ctx_out = ptr_to_u64(test_attr->ctx_out);

	attr.test.ctx_size_in = test_attr->ctx_size_in;

	attr.test.ctx_size_out = test_attr->ctx_size_out;

	attr.test.repeat = test_attr->repeat;



	ret = sys_bpf(BPF_PROG_TEST_RUN, &attr, sizeof(attr));



	test_attr->data_size_out = attr.test.data_size_out;

	test_attr->ctx_size_out = attr.test.ctx_size_out;

	test_attr->retval = attr.test.retval;

	test_attr->duration = attr.test.duration;



	return libbpf_err_errno(ret);

}



int bpf_prog_test_run_opts(int prog_fd, struct bpf_test_run_opts *opts)

{

	union bpf_attr attr;
@@ -1162,27 +1013,6 @@ int bpf_btf_load(const void *btf_data, size_t btf_size, const struct bpf_btf_loa 
	return libbpf_err_errno(fd);

}



int bpf_load_btf(const void *btf, __u32 btf_size, char *log_buf, __u32 log_buf_size, bool do_log)

{

	LIBBPF_OPTS(bpf_btf_load_opts, opts);

	int fd;



retry:

	if (do_log && log_buf && log_buf_size) {

		opts.log_buf = log_buf;

		opts.log_size = log_buf_size;

		opts.log_level = 1;

	}



	fd = bpf_btf_load(btf, btf_size, &opts);

	if (fd < 0 && !do_log && log_buf && log_buf_size) {

		do_log = true;

		goto retry;

	}



	return libbpf_err_errno(fd);

}



int bpf_task_fd_query(int pid, int fd, __u32 flags, char *buf, __u32 *buf_len,

		      __u32 *prog_id, __u32 *fd_type, __u64 *probe_offset,

		      __u64 *probe_addr)

tools/lib/bpf/bpf.h

+0 −83
Original line number Diff line number Diff line
@@ -103,54 +103,6 @@ LIBBPF_API int bpf_prog_load(enum bpf_prog_type prog_type, 
			     const char *prog_name, const char *license,

			     const struct bpf_insn *insns, size_t insn_cnt,

			     const struct bpf_prog_load_opts *opts);

/* this "specialization" should go away in libbpf 1.0 */

LIBBPF_API int bpf_prog_load_v0_6_0(enum bpf_prog_type prog_type,

				    const char *prog_name, const char *license,

				    const struct bpf_insn *insns, size_t insn_cnt,

				    const struct bpf_prog_load_opts *opts);



/* This is an elaborate way to not conflict with deprecated bpf_prog_load()

 * API, defined in libbpf.h. Once we hit libbpf 1.0, all this will be gone.

 * With this approach, if someone is calling bpf_prog_load() with

 * 4 arguments, they will use the deprecated API, which keeps backwards

 * compatibility (both source code and binary). If bpf_prog_load() is called

 * with 6 arguments, though, it gets redirected to __bpf_prog_load.

 * So looking forward to libbpf 1.0 when this hack will be gone and

 * __bpf_prog_load() will be called just bpf_prog_load().

 */

#ifndef bpf_prog_load

#define bpf_prog_load(...) ___libbpf_overload(___bpf_prog_load, __VA_ARGS__)

#define ___bpf_prog_load4(file, type, pobj, prog_fd) \

	bpf_prog_load_deprecated(file, type, pobj, prog_fd)

#define ___bpf_prog_load6(prog_type, prog_name, license, insns, insn_cnt, opts) \

	bpf_prog_load(prog_type, prog_name, license, insns, insn_cnt, opts)

#endif /* bpf_prog_load */



struct bpf_load_program_attr {

	enum bpf_prog_type prog_type;

	enum bpf_attach_type expected_attach_type;

	const char *name;

	const struct bpf_insn *insns;

	size_t insns_cnt;

	const char *license;

	union {

		__u32 kern_version;

		__u32 attach_prog_fd;

	};

	union {

		__u32 prog_ifindex;

		__u32 attach_btf_id;

	};

	__u32 prog_btf_fd;

	__u32 func_info_rec_size;

	const void *func_info;

	__u32 func_info_cnt;

	__u32 line_info_rec_size;

	const void *line_info;

	__u32 line_info_cnt;

	__u32 log_level;

	__u32 prog_flags;

};



/* Flags to direct loading requirements */

#define MAPS_RELAX_COMPAT	0x01
@@ -158,22 +110,6 @@ struct bpf_load_program_attr { 
/* Recommended log buffer size */

#define BPF_LOG_BUF_SIZE (UINT32_MAX >> 8) /* verifier maximum in kernels <= 5.1 */



LIBBPF_DEPRECATED_SINCE(0, 7, "use bpf_prog_load() instead")

LIBBPF_API int bpf_load_program_xattr(const struct bpf_load_program_attr *load_attr,

				      char *log_buf, size_t log_buf_sz);

LIBBPF_DEPRECATED_SINCE(0, 7, "use bpf_prog_load() instead")

LIBBPF_API int bpf_load_program(enum bpf_prog_type type,

				const struct bpf_insn *insns, size_t insns_cnt,

				const char *license, __u32 kern_version,

				char *log_buf, size_t log_buf_sz);

LIBBPF_DEPRECATED_SINCE(0, 7, "use bpf_prog_load() instead")

LIBBPF_API int bpf_verify_program(enum bpf_prog_type type,

				  const struct bpf_insn *insns,

				  size_t insns_cnt, __u32 prog_flags,

				  const char *license, __u32 kern_version,

				  char *log_buf, size_t log_buf_sz,

				  int log_level);



struct bpf_btf_load_opts {

	size_t sz; /* size of this struct for forward/backward compatibility */
@@ -187,10 +123,6 @@ struct bpf_btf_load_opts { 
LIBBPF_API int bpf_btf_load(const void *btf_data, size_t btf_size,

			    const struct bpf_btf_load_opts *opts);



LIBBPF_DEPRECATED_SINCE(0, 8, "use bpf_btf_load() instead")

LIBBPF_API int bpf_load_btf(const void *btf, __u32 btf_size, char *log_buf,

			    __u32 log_buf_size, bool do_log);



LIBBPF_API int bpf_map_update_elem(int fd, const void *key, const void *value,

				   __u64 flags);
@@ -353,10 +285,6 @@ LIBBPF_API int bpf_prog_attach(int prog_fd, int attachable_fd, 
LIBBPF_API int bpf_prog_attach_opts(int prog_fd, int attachable_fd,

				     enum bpf_attach_type type,

				     const struct bpf_prog_attach_opts *opts);

LIBBPF_DEPRECATED_SINCE(0, 8, "use bpf_prog_attach_opts() instead")

LIBBPF_API int bpf_prog_attach_xattr(int prog_fd, int attachable_fd,

				     enum bpf_attach_type type,

				     const struct bpf_prog_attach_opts *opts);

LIBBPF_API int bpf_prog_detach(int attachable_fd, enum bpf_attach_type type);

LIBBPF_API int bpf_prog_detach2(int prog_fd, int attachable_fd,

				enum bpf_attach_type type);
@@ -422,17 +350,6 @@ struct bpf_prog_test_run_attr { 
			     * out: length of cxt_out */

};



LIBBPF_DEPRECATED_SINCE(0, 7, "use bpf_prog_test_run_opts() instead")

LIBBPF_API int bpf_prog_test_run_xattr(struct bpf_prog_test_run_attr *test_attr);



/*

 * bpf_prog_test_run does not check that data_out is large enough. Consider

 * using bpf_prog_test_run_opts instead.

 */

LIBBPF_DEPRECATED_SINCE(0, 7, "use bpf_prog_test_run_opts() instead")

LIBBPF_API int bpf_prog_test_run(int prog_fd, int repeat, void *data,

				 __u32 size, void *data_out, __u32 *size_out,

				 __u32 *retval, __u32 *duration);

LIBBPF_API int bpf_prog_get_next_id(__u32 start_id, __u32 *next_id);

LIBBPF_API int bpf_map_get_next_id(__u32 start_id, __u32 *next_id);

LIBBPF_API int bpf_btf_get_next_id(__u32 start_id, __u32 *next_id);

tools/lib/bpf/btf.c

+1 −182
Original line number Diff line number Diff line
@@ -448,11 +448,6 @@ static int btf_parse_type_sec(struct btf *btf) 
	return 0;

}



__u32 btf__get_nr_types(const struct btf *btf)

{

	return btf->start_id + btf->nr_types - 1;

}



__u32 btf__type_cnt(const struct btf *btf)

{

	return btf->start_id + btf->nr_types;
@@ -1408,92 +1403,6 @@ struct btf *btf__load_from_kernel_by_id(__u32 id) 
	return btf__load_from_kernel_by_id_split(id, NULL);

}



int btf__get_from_id(__u32 id, struct btf **btf)

{

	struct btf *res;

	int err;



	*btf = NULL;

	res = btf__load_from_kernel_by_id(id);

	err = libbpf_get_error(res);



	if (err)

		return libbpf_err(err);



	*btf = res;

	return 0;

}



int btf__get_map_kv_tids(const struct btf *btf, const char *map_name,

			 __u32 expected_key_size, __u32 expected_value_size,

			 __u32 *key_type_id, __u32 *value_type_id)

{

	const struct btf_type *container_type;

	const struct btf_member *key, *value;

	const size_t max_name = 256;

	char container_name[max_name];

	__s64 key_size, value_size;

	__s32 container_id;



	if (snprintf(container_name, max_name, "____btf_map_%s", map_name) == max_name) {

		pr_warn("map:%s length of '____btf_map_%s' is too long\n",

			map_name, map_name);

		return libbpf_err(-EINVAL);

	}



	container_id = btf__find_by_name(btf, container_name);

	if (container_id < 0) {

		pr_debug("map:%s container_name:%s cannot be found in BTF. Missing BPF_ANNOTATE_KV_PAIR?\n",

			 map_name, container_name);

		return libbpf_err(container_id);

	}



	container_type = btf__type_by_id(btf, container_id);

	if (!container_type) {

		pr_warn("map:%s cannot find BTF type for container_id:%u\n",

			map_name, container_id);

		return libbpf_err(-EINVAL);

	}



	if (!btf_is_struct(container_type) || btf_vlen(container_type) < 2) {

		pr_warn("map:%s container_name:%s is an invalid container struct\n",

			map_name, container_name);

		return libbpf_err(-EINVAL);

	}



	key = btf_members(container_type);

	value = key + 1;



	key_size = btf__resolve_size(btf, key->type);

	if (key_size < 0) {

		pr_warn("map:%s invalid BTF key_type_size\n", map_name);

		return libbpf_err(key_size);

	}



	if (expected_key_size != key_size) {

		pr_warn("map:%s btf_key_type_size:%u != map_def_key_size:%u\n",

			map_name, (__u32)key_size, expected_key_size);

		return libbpf_err(-EINVAL);

	}



	value_size = btf__resolve_size(btf, value->type);

	if (value_size < 0) {

		pr_warn("map:%s invalid BTF value_type_size\n", map_name);

		return libbpf_err(value_size);

	}



	if (expected_value_size != value_size) {

		pr_warn("map:%s btf_value_type_size:%u != map_def_value_size:%u\n",

			map_name, (__u32)value_size, expected_value_size);

		return libbpf_err(-EINVAL);

	}



	*key_type_id = key->type;

	*value_type_id = value->type;



	return 0;

}



static void btf_invalidate_raw_data(struct btf *btf)

{

	if (btf->raw_data) {
@@ -2965,81 +2874,6 @@ const void *btf_ext__get_raw_data(const struct btf_ext *btf_ext, __u32 *size) 
	return btf_ext->data;

}



static int btf_ext_reloc_info(const struct btf *btf,

			      const struct btf_ext_info *ext_info,

			      const char *sec_name, __u32 insns_cnt,

			      void **info, __u32 *cnt)

{

	__u32 sec_hdrlen = sizeof(struct btf_ext_info_sec);

	__u32 i, record_size, existing_len, records_len;

	struct btf_ext_info_sec *sinfo;

	const char *info_sec_name;

	__u64 remain_len;

	void *data;



	record_size = ext_info->rec_size;

	sinfo = ext_info->info;

	remain_len = ext_info->len;

	while (remain_len > 0) {

		records_len = sinfo->num_info * record_size;

		info_sec_name = btf__name_by_offset(btf, sinfo->sec_name_off);

		if (strcmp(info_sec_name, sec_name)) {

			remain_len -= sec_hdrlen + records_len;

			sinfo = (void *)sinfo + sec_hdrlen + records_len;

			continue;

		}



		existing_len = (*cnt) * record_size;

		data = realloc(*info, existing_len + records_len);

		if (!data)

			return libbpf_err(-ENOMEM);



		memcpy(data + existing_len, sinfo->data, records_len);

		/* adjust insn_off only, the rest data will be passed

		 * to the kernel.

		 */

		for (i = 0; i < sinfo->num_info; i++) {

			__u32 *insn_off;



			insn_off = data + existing_len + (i * record_size);

			*insn_off = *insn_off / sizeof(struct bpf_insn) + insns_cnt;

		}

		*info = data;

		*cnt += sinfo->num_info;

		return 0;

	}



	return libbpf_err(-ENOENT);

}



int btf_ext__reloc_func_info(const struct btf *btf,

			     const struct btf_ext *btf_ext,

			     const char *sec_name, __u32 insns_cnt,

			     void **func_info, __u32 *cnt)

{

	return btf_ext_reloc_info(btf, &btf_ext->func_info, sec_name,

				  insns_cnt, func_info, cnt);

}



int btf_ext__reloc_line_info(const struct btf *btf,

			     const struct btf_ext *btf_ext,

			     const char *sec_name, __u32 insns_cnt,

			     void **line_info, __u32 *cnt)

{

	return btf_ext_reloc_info(btf, &btf_ext->line_info, sec_name,

				  insns_cnt, line_info, cnt);

}



__u32 btf_ext__func_info_rec_size(const struct btf_ext *btf_ext)

{

	return btf_ext->func_info.rec_size;

}



__u32 btf_ext__line_info_rec_size(const struct btf_ext *btf_ext)

{

	return btf_ext->line_info.rec_size;

}



struct btf_dedup;



static struct btf_dedup *btf_dedup_new(struct btf *btf, const struct btf_dedup_opts *opts);
@@ -3189,9 +3023,7 @@ static int btf_dedup_remap_types(struct btf_dedup *d); 
 * deduplicating structs/unions is described in greater details in comments for

 * `btf_dedup_is_equiv` function.

 */



DEFAULT_VERSION(btf__dedup_v0_6_0, btf__dedup, LIBBPF_0.6.0)

int btf__dedup_v0_6_0(struct btf *btf, const struct btf_dedup_opts *opts)

int btf__dedup(struct btf *btf, const struct btf_dedup_opts *opts)

{

	struct btf_dedup *d;

	int err;
@@ -3251,19 +3083,6 @@ int btf__dedup_v0_6_0(struct btf *btf, const struct btf_dedup_opts *opts) 
	return libbpf_err(err);

}



COMPAT_VERSION(btf__dedup_deprecated, btf__dedup, LIBBPF_0.0.2)

int btf__dedup_deprecated(struct btf *btf, struct btf_ext *btf_ext, const void *unused_opts)

{

	LIBBPF_OPTS(btf_dedup_opts, opts, .btf_ext = btf_ext);



	if (unused_opts) {

		pr_warn("please use new version of btf__dedup() that supports options\n");

		return libbpf_err(-ENOTSUP);

	}



	return btf__dedup(btf, &opts);

}



#define BTF_UNPROCESSED_ID ((__u32)-1)

#define BTF_IN_PROGRESS_ID ((__u32)-2)