v0.5.1_netdata_patch: Apply patch

Merge remote-tracking branch 'upstream/master'
2026-03-18 07:19:07 +08:00 · 2021-11-11 19:28:58 +00:00 · 2021-11-11 19:17:34 +00:00 · 2021-10-19 16:58:24 +00:00 · 2021-08-20 01:33:45 +00:00 · 2021-08-06 20:09:33 -07:00
49 changed files with 867 additions and 4479 deletions
--- a/.github/actions/setup/action.yml
+++ b/.github/actions/setup/action.yml
@@ -12,7 +12,7 @@ runs:
        echo 'echo ::group::Env setup' > /tmp/ci_setup
        echo export DEBIAN_FRONTEND=noninteractive >> /tmp/ci_setup
        echo sudo apt-get update >> /tmp/ci_setup
-        echo sudo apt-get install -y aptitude qemu-kvm zstd binutils-dev elfutils libcap-dev libelf-dev libdw-dev libguestfs-tools >> /tmp/ci_setup
+        echo sudo apt-get install -y aptitude qemu-kvm zstd binutils-dev elfutils libcap-dev libelf-dev libdw-dev >> /tmp/ci_setup
        echo export PROJECT_NAME='libbpf' >> /tmp/ci_setup
        echo export AUTHOR_EMAIL="$(git log -1 --pretty=\"%aE\")" >> /tmp/ci_setup
        echo export REPO_ROOT=$GITHUB_WORKSPACE >> /tmp/ci_setup
--- a/.github/workflows/test.yml
+++ b/.github/workflows/test.yml
@@ -12,20 +12,15 @@ concurrency:

 jobs:
  vmtest:
-    runs-on: ${{ matrix.runs_on }}
-    name: Kernel ${{ matrix.kernel }} on ${{ matrix.runs_on }} + selftests
+    runs-on: ubuntu-latest
+    name: Kernel ${{ matrix.kernel }} + selftests
    strategy:
      fail-fast: false
      matrix:
        include:
          - kernel: 'LATEST'
-            runs_on: ubuntu-latest
-          - kernel: 'LATEST'
-            runs_on: z15
          - kernel: '5.5.0'
-            runs_on: ubuntu-latest
          - kernel: '4.9.0'
-            runs_on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2
        name: Checkout
--- a/2
+++ b/2
@@ -1 +1 @@
-c0d95d3380ee099d735e08618c0d599e72f6c8b0
+47b3708c6088a60e7dc3b809dbb0d4c46590b32f
--- a/2
+++ b/2
@@ -1 +1 @@
-43174f0d4597325cb91f1f1f55263eb6e6101036
+b8b5cb55f5d3f03cc1479a3768d68173a10359ad
--- a/docs/index.rst
+++ b/docs/index.rst
@@ -3,6 +3,8 @@
 libbpf
 ======

+For API documentation see the `versioned API documentation site <https://libbpf.readthedocs.io/en/latest/api.html>`_.
+
 .. toctree::
   :maxdepth: 1

@@ -12,8 +14,6 @@ libbpf
 This is documentation for libbpf, a userspace library for loading and
 interacting with bpf programs.

-For API documentation see the `versioned API documentation site <https://libbpf.readthedocs.io/en/latest/api.html>`_.
-
 All general BPF questions, including kernel functionality, libbpf APIs and
 their application, should be sent to bpf@vger.kernel.org mailing list.
 You can `subscribe <http://vger.kernel.org/vger-lists.html#bpf>`_ to the
--- a/include/uapi/linux/bpf.h
+++ b/include/uapi/linux/bpf.h
@@ -1744,7 +1744,7 @@ union bpf_attr {
 * 		if the maximum number of tail calls has been reached for this
 * 		chain of programs. This limit is defined in the kernel by the
 * 		macro **MAX_TAIL_CALL_CNT** (not accessible to user space),
- *		which is currently set to 33.
+ * 		which is currently set to 32.
 * 	Return
 * 		0 on success, or a negative error in case of failure.
 *
@@ -4938,25 +4938,6 @@ union bpf_attr {
 *		**-ENOENT** if symbol is not found.
 *
 *		**-EPERM** if caller does not have permission to obtain kernel address.
- *
- * long bpf_find_vma(struct task_struct *task, u64 addr, void *callback_fn, void *callback_ctx, u64 flags)
- *	Description
- *		Find vma of *task* that contains *addr*, call *callback_fn*
- *		function with *task*, *vma*, and *callback_ctx*.
- *		The *callback_fn* should be a static function and
- *		the *callback_ctx* should be a pointer to the stack.
- *		The *flags* is used to control certain aspects of the helper.
- *		Currently, the *flags* must be 0.
- *
- *		The expected callback signature is
- *
- *		long (\*callback_fn)(struct task_struct \*task, struct vm_area_struct \*vma, void \*callback_ctx);
- *
- *	Return
- *		0 on success.
- *		**-ENOENT** if *task->mm* is NULL, or no vma contains *addr*.
- *		**-EBUSY** if failed to try lock mmap_lock.
- *		**-EINVAL** for invalid **flags**.
 */
 #define __BPF_FUNC_MAPPER(FN)		\
 	FN(unspec),			\
@@ -5139,7 +5120,6 @@ union bpf_attr {
 	FN(trace_vprintk),		\
 	FN(skc_to_unix_sock),		\
 	FN(kallsyms_lookup_name),	\
-	FN(find_vma),			\
 	/* */

 /* integer value in 'imm' field of BPF_CALL instruction selects which helper
@@ -6316,7 +6296,6 @@ struct bpf_sk_lookup {
 	__u32 local_ip4;	/* Network byte order */
 	__u32 local_ip6[4];	/* Network byte order */
 	__u32 local_port;	/* Host byte order */
-	__u32 ingress_ifindex;		/* The arriving interface. Determined by inet_iif. */
 };

 /*
--- a/include/uapi/linux/btf.h
+++ b/include/uapi/linux/btf.h
@@ -43,7 +43,7 @@ struct btf_type {
 	 * "size" tells the size of the type it is describing.
 	 *
 	 * "type" is used by PTR, TYPEDEF, VOLATILE, CONST, RESTRICT,
-	 * FUNC, FUNC_PROTO, VAR, DECL_TAG and TYPE_TAG.
+	 * FUNC, FUNC_PROTO, VAR and DECL_TAG.
 	 * "type" is a type_id referring to another type.
 	 */
 	union {
@@ -75,7 +75,6 @@ enum {
 	BTF_KIND_DATASEC	= 15,	/* Section	*/
 	BTF_KIND_FLOAT		= 16,	/* Floating point	*/
 	BTF_KIND_DECL_TAG	= 17,	/* Decl Tag */
-	BTF_KIND_TYPE_TAG	= 18,	/* Type Tag */

 	NR_BTF_KINDS,
 	BTF_KIND_MAX		= NR_BTF_KINDS - 1,
--- a/scripts/sync-kernel.sh
+++ b/scripts/sync-kernel.sh
@@ -263,11 +263,8 @@ cd_to ${LIBBPF_REPO}
 git checkout -b ${LIBBPF_SYNC_TAG}

 for patch in $(ls -1 ${TMP_DIR}/patches | tail -n +2); do
-	if ! git am -3 --committer-date-is-author-date "${TMP_DIR}/patches/${patch}"; then
-		if ! git apply -3 "${TMP_DIR}/patches/${patch}"; then
-			read -p "Applying ${TMP_DIR}/patches/${patch} failed, please resolve manually and press <return> to proceed..."
-		fi
-		git am --continue
+	if ! git am --3way --committer-date-is-author-date "${TMP_DIR}/patches/${patch}"; then
+		read -p "Applying ${TMP_DIR}/patches/${patch} failed, please resolve manually and press <return> to proceed..."
 	fi
 done

--- a/src/Makefile
+++ b/src/Makefile
@@ -5,7 +5,7 @@ ifeq ($(V),1)
 	msg =
 else
 	Q = @
-	msg = @printf '  %-8s %s%s\n' "$(1)" "$(2)" "$(if $(3), $(3))";
+	msg = @printf '  %-8s %s%s\n' "$(1)" "$(notdir $(2))" "$(if $(3), $(3))";
 endif

 LIBBPF_VERSION := $(shell \
@@ -20,7 +20,7 @@ ALL_CFLAGS := $(INCLUDES)

 SHARED_CFLAGS += -fPIC -fvisibility=hidden -DSHARED

-CFLAGS ?= -g -O2 -Werror -Wall -std=gnu89
+CFLAGS ?= -g -O2 -Werror -Wall
 ALL_CFLAGS += $(CFLAGS) -D_LARGEFILE64_SOURCE -D_FILE_OFFSET_BITS=64
 ALL_LDFLAGS += $(LDFLAGS)
 ifdef NO_PKG_CONFIG
--- a/src/bpf.c
+++ b/src/bpf.c
@@ -28,7 +28,6 @@
 #include <asm/unistd.h>
 #include <errno.h>
 #include <linux/bpf.h>
-#include <limits.h>
 #include "bpf.h"
 #include "libbpf.h"
 #include "libbpf_internal.h"
@@ -50,12 +49,6 @@
 #  define __NR_bpf 351
 # elif defined(__arc__)
 #  define __NR_bpf 280
-# elif defined(__mips__) && defined(_ABIO32)
-#  define __NR_bpf 4355
-# elif defined(__mips__) && defined(_ABIN32)
-#  define __NR_bpf 6319
-# elif defined(__mips__) && defined(_ABI64)
-#  define __NR_bpf 5315
 # else
 #  error __NR_bpf not defined. libbpf does not support your arch.
 # endif
@@ -81,135 +74,158 @@ static inline int sys_bpf_fd(enum bpf_cmd cmd, union bpf_attr *attr,
 	return ensure_good_fd(fd);
 }

-#define PROG_LOAD_ATTEMPTS 5
-
-static inline int sys_bpf_prog_load(union bpf_attr *attr, unsigned int size, int attempts)
+static inline int sys_bpf_prog_load(union bpf_attr *attr, unsigned int size)
 {
+	int retries = 5;
 	int fd;

 	do {
 		fd = sys_bpf_fd(BPF_PROG_LOAD, attr, size);
-	} while (fd < 0 && errno == EAGAIN && --attempts > 0);
+	} while (fd < 0 && errno == EAGAIN && retries-- > 0);

 	return fd;
 }

-int bpf_map_create(enum bpf_map_type map_type,
-		   const char *map_name,
-		   __u32 key_size,
-		   __u32 value_size,
-		   __u32 max_entries,
-		   const struct bpf_map_create_opts *opts)
+int libbpf__bpf_create_map_xattr(const struct bpf_create_map_params *create_attr)
 {
-	const size_t attr_sz = offsetofend(union bpf_attr, map_extra);
 	union bpf_attr attr;
 	int fd;

-	memset(&attr, 0, attr_sz);
+	memset(&attr, '\0', sizeof(attr));

-	if (!OPTS_VALID(opts, bpf_map_create_opts))
-		return libbpf_err(-EINVAL);
+	attr.map_type = create_attr->map_type;
+	attr.key_size = create_attr->key_size;
+	attr.value_size = create_attr->value_size;
+	attr.max_entries = create_attr->max_entries;
+	attr.map_flags = create_attr->map_flags;
+	if (create_attr->name)
+		memcpy(attr.map_name, create_attr->name,
+		       min(strlen(create_attr->name), BPF_OBJ_NAME_LEN - 1));
+	attr.numa_node = create_attr->numa_node;
+	attr.btf_fd = create_attr->btf_fd;
+	attr.btf_key_type_id = create_attr->btf_key_type_id;
+	attr.btf_value_type_id = create_attr->btf_value_type_id;
+	attr.map_ifindex = create_attr->map_ifindex;
+	if (attr.map_type == BPF_MAP_TYPE_STRUCT_OPS)
+		attr.btf_vmlinux_value_type_id =
+			create_attr->btf_vmlinux_value_type_id;
+	else
+		attr.inner_map_fd = create_attr->inner_map_fd;
+	attr.map_extra = create_attr->map_extra;

-	attr.map_type = map_type;
-	if (map_name)
-		strncat(attr.map_name, map_name, sizeof(attr.map_name) - 1);
-	attr.key_size = key_size;
-	attr.value_size = value_size;
-	attr.max_entries = max_entries;
-
-	attr.btf_fd = OPTS_GET(opts, btf_fd, 0);
-	attr.btf_key_type_id = OPTS_GET(opts, btf_key_type_id, 0);
-	attr.btf_value_type_id = OPTS_GET(opts, btf_value_type_id, 0);
-	attr.btf_vmlinux_value_type_id = OPTS_GET(opts, btf_vmlinux_value_type_id, 0);
-
-	attr.inner_map_fd = OPTS_GET(opts, inner_map_fd, 0);
-	attr.map_flags = OPTS_GET(opts, map_flags, 0);
-	attr.map_extra = OPTS_GET(opts, map_extra, 0);
-	attr.numa_node = OPTS_GET(opts, numa_node, 0);
-	attr.map_ifindex = OPTS_GET(opts, map_ifindex, 0);
-
-	fd = sys_bpf_fd(BPF_MAP_CREATE, &attr, attr_sz);
+	fd = sys_bpf_fd(BPF_MAP_CREATE, &attr, sizeof(attr));
 	return libbpf_err_errno(fd);
 }

 int bpf_create_map_xattr(const struct bpf_create_map_attr *create_attr)
 {
-	LIBBPF_OPTS(bpf_map_create_opts, p);
+	struct bpf_create_map_params p = {};

+	p.map_type = create_attr->map_type;
+	p.key_size = create_attr->key_size;
+	p.value_size = create_attr->value_size;
+	p.max_entries = create_attr->max_entries;
 	p.map_flags = create_attr->map_flags;
+	p.name = create_attr->name;
 	p.numa_node = create_attr->numa_node;
 	p.btf_fd = create_attr->btf_fd;
 	p.btf_key_type_id = create_attr->btf_key_type_id;
 	p.btf_value_type_id = create_attr->btf_value_type_id;
 	p.map_ifindex = create_attr->map_ifindex;
-	if (create_attr->map_type == BPF_MAP_TYPE_STRUCT_OPS)
-		p.btf_vmlinux_value_type_id = create_attr->btf_vmlinux_value_type_id;
+	if (p.map_type == BPF_MAP_TYPE_STRUCT_OPS)
+		p.btf_vmlinux_value_type_id =
+			create_attr->btf_vmlinux_value_type_id;
 	else
 		p.inner_map_fd = create_attr->inner_map_fd;

-	return bpf_map_create(create_attr->map_type, create_attr->name,
-			      create_attr->key_size, create_attr->value_size,
-			      create_attr->max_entries, &p);
+	return libbpf__bpf_create_map_xattr(&p);
 }

 int bpf_create_map_node(enum bpf_map_type map_type, const char *name,
 			int key_size, int value_size, int max_entries,
 			__u32 map_flags, int node)
 {
-	LIBBPF_OPTS(bpf_map_create_opts, opts);
+	struct bpf_create_map_attr map_attr = {};

-	opts.map_flags = map_flags;
+	map_attr.name = name;
+	map_attr.map_type = map_type;
+	map_attr.map_flags = map_flags;
+	map_attr.key_size = key_size;
+	map_attr.value_size = value_size;
+	map_attr.max_entries = max_entries;
 	if (node >= 0) {
-		opts.numa_node = node;
-		opts.map_flags |= BPF_F_NUMA_NODE;
+		map_attr.numa_node = node;
+		map_attr.map_flags |= BPF_F_NUMA_NODE;
 	}

-	return bpf_map_create(map_type, name, key_size, value_size, max_entries, &opts);
+	return bpf_create_map_xattr(&map_attr);
 }

 int bpf_create_map(enum bpf_map_type map_type, int key_size,
 		   int value_size, int max_entries, __u32 map_flags)
 {
-	LIBBPF_OPTS(bpf_map_create_opts, opts, .map_flags = map_flags);
+	struct bpf_create_map_attr map_attr = {};

-	return bpf_map_create(map_type, NULL, key_size, value_size, max_entries, &opts);
+	map_attr.map_type = map_type;
+	map_attr.map_flags = map_flags;
+	map_attr.key_size = key_size;
+	map_attr.value_size = value_size;
+	map_attr.max_entries = max_entries;
+
+	return bpf_create_map_xattr(&map_attr);
 }

 int bpf_create_map_name(enum bpf_map_type map_type, const char *name,
 			int key_size, int value_size, int max_entries,
 			__u32 map_flags)
 {
-	LIBBPF_OPTS(bpf_map_create_opts, opts, .map_flags = map_flags);
+	struct bpf_create_map_attr map_attr = {};

-	return bpf_map_create(map_type, name, key_size, value_size, max_entries, &opts);
+	map_attr.name = name;
+	map_attr.map_type = map_type;
+	map_attr.map_flags = map_flags;
+	map_attr.key_size = key_size;
+	map_attr.value_size = value_size;
+	map_attr.max_entries = max_entries;
+
+	return bpf_create_map_xattr(&map_attr);
 }

 int bpf_create_map_in_map_node(enum bpf_map_type map_type, const char *name,
 			       int key_size, int inner_map_fd, int max_entries,
 			       __u32 map_flags, int node)
 {
-	LIBBPF_OPTS(bpf_map_create_opts, opts);
+	union bpf_attr attr;
+	int fd;
+
+	memset(&attr, '\0', sizeof(attr));
+
+	attr.map_type = map_type;
+	attr.key_size = key_size;
+	attr.value_size = 4;
+	attr.inner_map_fd = inner_map_fd;
+	attr.max_entries = max_entries;
+	attr.map_flags = map_flags;
+	if (name)
+		memcpy(attr.map_name, name,
+		       min(strlen(name), BPF_OBJ_NAME_LEN - 1));

-	opts.inner_map_fd = inner_map_fd;
-	opts.map_flags = map_flags;
 	if (node >= 0) {
-		opts.map_flags |= BPF_F_NUMA_NODE;
-		opts.numa_node = node;
+		attr.map_flags |= BPF_F_NUMA_NODE;
+		attr.numa_node = node;
 	}

-	return bpf_map_create(map_type, name, key_size, 4, max_entries, &opts);
+	fd = sys_bpf_fd(BPF_MAP_CREATE, &attr, sizeof(attr));
+	return libbpf_err_errno(fd);
 }

 int bpf_create_map_in_map(enum bpf_map_type map_type, const char *name,
 			  int key_size, int inner_map_fd, int max_entries,
 			  __u32 map_flags)
 {
-	LIBBPF_OPTS(bpf_map_create_opts, opts,
-		.inner_map_fd = inner_map_fd,
-		.map_flags = map_flags,
-	);
-
-	return bpf_map_create(map_type, name, key_size, 4, max_entries, &opts);
+	return bpf_create_map_in_map_node(map_type, name, key_size,
+					  inner_map_fd, max_entries, map_flags,
+					  -1);
 }

 static void *
@@ -237,91 +253,58 @@ 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,
-		         const char *prog_name, const char *license,
-		         const struct bpf_insn *insns, size_t insn_cnt,
-		         const struct bpf_prog_load_opts *opts)
+int libbpf__bpf_prog_load(const struct bpf_prog_load_params *load_attr)
 {
 	void *finfo = NULL, *linfo = NULL;
-	const char *func_info, *line_info;
-	__u32 log_size, log_level, attach_prog_fd, attach_btf_obj_fd;
-	__u32 func_info_rec_size, line_info_rec_size;
-	int fd, attempts;
 	union bpf_attr attr;
-	char *log_buf;
+	int fd;

-	if (!OPTS_VALID(opts, bpf_prog_load_opts))
+	if (!load_attr->log_buf != !load_attr->log_buf_sz)
 		return libbpf_err(-EINVAL);

-	attempts = OPTS_GET(opts, attempts, 0);
-	if (attempts < 0)
+	if (load_attr->log_level > (4 | 2 | 1) || (load_attr->log_level && !load_attr->log_buf))
 		return libbpf_err(-EINVAL);
-	if (attempts == 0)
-		attempts = PROG_LOAD_ATTEMPTS;

 	memset(&attr, 0, sizeof(attr));
+	attr.prog_type = load_attr->prog_type;
+	attr.expected_attach_type = load_attr->expected_attach_type;

-	attr.prog_type = prog_type;
-	attr.expected_attach_type = OPTS_GET(opts, expected_attach_type, 0);
-
-	attr.prog_btf_fd = OPTS_GET(opts, prog_btf_fd, 0);
-	attr.prog_flags = OPTS_GET(opts, prog_flags, 0);
-	attr.prog_ifindex = OPTS_GET(opts, prog_ifindex, 0);
-	attr.kern_version = OPTS_GET(opts, kern_version, 0);
-
-	if (prog_name)
-		strncat(attr.prog_name, prog_name, sizeof(attr.prog_name) - 1);
-	attr.license = ptr_to_u64(license);
-
-	if (insn_cnt > UINT_MAX)
-		return libbpf_err(-E2BIG);
-
-	attr.insns = ptr_to_u64(insns);
-	attr.insn_cnt = (__u32)insn_cnt;
-
-	attach_prog_fd = OPTS_GET(opts, attach_prog_fd, 0);
-	attach_btf_obj_fd = OPTS_GET(opts, attach_btf_obj_fd, 0);
-
-	if (attach_prog_fd && attach_btf_obj_fd)
-		return libbpf_err(-EINVAL);
-
-	attr.attach_btf_id = OPTS_GET(opts, attach_btf_id, 0);
-	if (attach_prog_fd)
-		attr.attach_prog_fd = attach_prog_fd;
+	if (load_attr->attach_prog_fd)
+		attr.attach_prog_fd = load_attr->attach_prog_fd;
 	else
-		attr.attach_btf_obj_fd = attach_btf_obj_fd;
+		attr.attach_btf_obj_fd = load_attr->attach_btf_obj_fd;
+	attr.attach_btf_id = load_attr->attach_btf_id;

-	log_buf = OPTS_GET(opts, log_buf, NULL);
-	log_size = OPTS_GET(opts, log_size, 0);
-	log_level = OPTS_GET(opts, log_level, 0);
+	attr.prog_ifindex = load_attr->prog_ifindex;
+	attr.kern_version = load_attr->kern_version;

-	if (!!log_buf != !!log_size)
-		return libbpf_err(-EINVAL);
-	if (log_level > (4 | 2 | 1))
-		return libbpf_err(-EINVAL);
-	if (log_level && !log_buf)
-		return libbpf_err(-EINVAL);
+	attr.insn_cnt = (__u32)load_attr->insn_cnt;
+	attr.insns = ptr_to_u64(load_attr->insns);
+	attr.license = ptr_to_u64(load_attr->license);

-	attr.log_level = log_level;
-	attr.log_buf = ptr_to_u64(log_buf);
-	attr.log_size = log_size;
+	attr.log_level = load_attr->log_level;
+	if (attr.log_level) {
+		attr.log_buf = ptr_to_u64(load_attr->log_buf);
+		attr.log_size = load_attr->log_buf_sz;
+	}

-	func_info_rec_size = OPTS_GET(opts, func_info_rec_size, 0);
-	func_info = OPTS_GET(opts, func_info, NULL);
-	attr.func_info_rec_size = func_info_rec_size;
-	attr.func_info = ptr_to_u64(func_info);
-	attr.func_info_cnt = OPTS_GET(opts, func_info_cnt, 0);
+	attr.prog_btf_fd = load_attr->prog_btf_fd;
+	attr.prog_flags = load_attr->prog_flags;

-	line_info_rec_size = OPTS_GET(opts, line_info_rec_size, 0);
-	line_info = OPTS_GET(opts, line_info, NULL);
-	attr.line_info_rec_size = line_info_rec_size;
-	attr.line_info = ptr_to_u64(line_info);
-	attr.line_info_cnt = OPTS_GET(opts, line_info_cnt, 0);
+	attr.func_info_rec_size = load_attr->func_info_rec_size;
+	attr.func_info_cnt = load_attr->func_info_cnt;
+	attr.func_info = ptr_to_u64(load_attr->func_info);

-	attr.fd_array = ptr_to_u64(OPTS_GET(opts, fd_array, NULL));
+	attr.line_info_rec_size = load_attr->line_info_rec_size;
+	attr.line_info_cnt = load_attr->line_info_cnt;
+	attr.line_info = ptr_to_u64(load_attr->line_info);
+	attr.fd_array = ptr_to_u64(load_attr->fd_array);

-	fd = sys_bpf_prog_load(&attr, sizeof(attr), attempts);
+	if (load_attr->name)
+		memcpy(attr.prog_name, load_attr->name,
+		       min(strlen(load_attr->name), (size_t)BPF_OBJ_NAME_LEN - 1));
+
+	fd = sys_bpf_prog_load(&attr, sizeof(attr));
 	if (fd >= 0)
 		return fd;

@@ -331,11 +314,11 @@ int bpf_prog_load_v0_6_0(enum bpf_prog_type prog_type,
 	 */
 	while (errno == E2BIG && (!finfo || !linfo)) {
 		if (!finfo && attr.func_info_cnt &&
-		    attr.func_info_rec_size < func_info_rec_size) {
+		    attr.func_info_rec_size < load_attr->func_info_rec_size) {
 			/* try with corrected func info records */
-			finfo = alloc_zero_tailing_info(func_info,
-							attr.func_info_cnt,
-							func_info_rec_size,
+			finfo = alloc_zero_tailing_info(load_attr->func_info,
+							load_attr->func_info_cnt,
+							load_attr->func_info_rec_size,
 							attr.func_info_rec_size);
 			if (!finfo) {
 				errno = E2BIG;
@@ -343,12 +326,13 @@ int bpf_prog_load_v0_6_0(enum bpf_prog_type prog_type,
 			}

 			attr.func_info = ptr_to_u64(finfo);
-			attr.func_info_rec_size = func_info_rec_size;
+			attr.func_info_rec_size = load_attr->func_info_rec_size;
 		} else if (!linfo && attr.line_info_cnt &&
-			   attr.line_info_rec_size < line_info_rec_size) {
-			linfo = alloc_zero_tailing_info(line_info,
-							attr.line_info_cnt,
-							line_info_rec_size,
+			   attr.line_info_rec_size <
+			   load_attr->line_info_rec_size) {
+			linfo = alloc_zero_tailing_info(load_attr->line_info,
+							load_attr->line_info_cnt,
+							load_attr->line_info_rec_size,
 							attr.line_info_rec_size);
 			if (!linfo) {
 				errno = E2BIG;
@@ -356,26 +340,26 @@ int bpf_prog_load_v0_6_0(enum bpf_prog_type prog_type,
 			}

 			attr.line_info = ptr_to_u64(linfo);
-			attr.line_info_rec_size = line_info_rec_size;
+			attr.line_info_rec_size = load_attr->line_info_rec_size;
 		} else {
 			break;
 		}

-		fd = sys_bpf_prog_load(&attr, sizeof(attr), attempts);
+		fd = sys_bpf_prog_load(&attr, sizeof(attr));
 		if (fd >= 0)
 			goto done;
 	}

-	if (log_level || !log_buf)
+	if (load_attr->log_level || !load_attr->log_buf)
 		goto done;

 	/* Try again with log */
-	log_buf[0] = 0;
-	attr.log_buf = ptr_to_u64(log_buf);
-	attr.log_size = log_size;
+	attr.log_buf = ptr_to_u64(load_attr->log_buf);
+	attr.log_size = load_attr->log_buf_sz;
 	attr.log_level = 1;
+	load_attr->log_buf[0] = 0;

-	fd = sys_bpf_prog_load(&attr, sizeof(attr), attempts);
+	fd = sys_bpf_prog_load(&attr, sizeof(attr));
 done:
 	/* free() doesn't affect errno, so we don't need to restore it */
 	free(finfo);
@@ -383,20 +367,17 @@ done:
 	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)
+			   char *log_buf, size_t log_buf_sz)
 {
-	LIBBPF_OPTS(bpf_prog_load_opts, p);
+	struct bpf_prog_load_params p = {};

 	if (!load_attr || !log_buf != !log_buf_sz)
 		return libbpf_err(-EINVAL);

+	p.prog_type = load_attr->prog_type;
 	p.expected_attach_type = load_attr->expected_attach_type;
-	switch (load_attr->prog_type) {
+	switch (p.prog_type) {
 	case BPF_PROG_TYPE_STRUCT_OPS:
 	case BPF_PROG_TYPE_LSM:
 		p.attach_btf_id = load_attr->attach_btf_id;
@@ -410,9 +391,12 @@ static int bpf_load_program_xattr2(const struct bpf_load_program_attr *load_attr
 		p.prog_ifindex = load_attr->prog_ifindex;
 		p.kern_version = load_attr->kern_version;
 	}
+	p.insn_cnt = load_attr->insns_cnt;
+	p.insns = load_attr->insns;
+	p.license = load_attr->license;
 	p.log_level = load_attr->log_level;
 	p.log_buf = log_buf;
-	p.log_size = log_buf_sz;
+	p.log_buf_sz = 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;
@@ -420,10 +404,10 @@ static int bpf_load_program_xattr2(const struct bpf_load_program_attr *load_attr
 	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.name = load_attr->name;
 	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);
+	return libbpf__bpf_prog_load(&p);
 }

 int bpf_load_program(enum bpf_prog_type type, const struct bpf_insn *insns,
@@ -442,7 +426,7 @@ int bpf_load_program(enum bpf_prog_type type, const struct bpf_insn *insns,
 	load_attr.license = license;
 	load_attr.kern_version = kern_version;

-	return bpf_load_program_xattr2(&load_attr, log_buf, log_buf_sz);
+	return bpf_load_program_xattr(&load_attr, log_buf, log_buf_sz);
 }

 int bpf_verify_program(enum bpf_prog_type type, const struct bpf_insn *insns,
@@ -465,7 +449,7 @@ int bpf_verify_program(enum bpf_prog_type type, const struct bpf_insn *insns,
 	attr.kern_version = kern_version;
 	attr.prog_flags = prog_flags;

-	fd = sys_bpf_prog_load(&attr, sizeof(attr), PROG_LOAD_ATTEMPTS);
+	fd = sys_bpf_prog_load(&attr, sizeof(attr));
 	return libbpf_err_errno(fd);
 }

--- a/src/bpf.h
+++ b/src/bpf.h
@@ -29,36 +29,11 @@
 #include <stdint.h>

 #include "libbpf_common.h"
-#include "libbpf_legacy.h"

 #ifdef __cplusplus
 extern "C" {
 #endif

-struct bpf_map_create_opts {
-	size_t sz; /* size of this struct for forward/backward compatibility */
-
-	__u32 btf_fd;
-	__u32 btf_key_type_id;
-	__u32 btf_value_type_id;
-	__u32 btf_vmlinux_value_type_id;
-
-	int inner_map_fd;
-	int map_flags;
-	__u64 map_extra;
-
-	int numa_node;
-	int map_ifindex;
-};
-#define bpf_map_create_opts__last_field map_ifindex
-
-LIBBPF_API int bpf_map_create(enum bpf_map_type map_type,
-			      const char *map_name,
-			      __u32 key_size,
-			      __u32 value_size,
-			      __u32 max_entries,
-			      const struct bpf_map_create_opts *opts);
-
 struct bpf_create_map_attr {
 	const char *name;
 	enum bpf_map_type map_type;
@@ -77,95 +52,25 @@ struct bpf_create_map_attr {
 	};
 };

-LIBBPF_DEPRECATED_SINCE(0, 7, "use bpf_map_create() instead")
-LIBBPF_API int bpf_create_map_xattr(const struct bpf_create_map_attr *create_attr);
-LIBBPF_DEPRECATED_SINCE(0, 7, "use bpf_map_create() instead")
+LIBBPF_API int
+bpf_create_map_xattr(const struct bpf_create_map_attr *create_attr);
 LIBBPF_API int bpf_create_map_node(enum bpf_map_type map_type, const char *name,
 				   int key_size, int value_size,
 				   int max_entries, __u32 map_flags, int node);
-LIBBPF_DEPRECATED_SINCE(0, 7, "use bpf_map_create() instead")
 LIBBPF_API int bpf_create_map_name(enum bpf_map_type map_type, const char *name,
 				   int key_size, int value_size,
 				   int max_entries, __u32 map_flags);
-LIBBPF_DEPRECATED_SINCE(0, 7, "use bpf_map_create() instead")
 LIBBPF_API int bpf_create_map(enum bpf_map_type map_type, int key_size,
 			      int value_size, int max_entries, __u32 map_flags);
-LIBBPF_DEPRECATED_SINCE(0, 7, "use bpf_map_create() instead")
 LIBBPF_API int bpf_create_map_in_map_node(enum bpf_map_type map_type,
 					  const char *name, int key_size,
 					  int inner_map_fd, int max_entries,
 					  __u32 map_flags, int node);
-LIBBPF_DEPRECATED_SINCE(0, 7, "use bpf_map_create() instead")
 LIBBPF_API int bpf_create_map_in_map(enum bpf_map_type map_type,
 				     const char *name, int key_size,
 				     int inner_map_fd, int max_entries,
 				     __u32 map_flags);

-struct bpf_prog_load_opts {
-	size_t sz; /* size of this struct for forward/backward compatibility */
-
-	/* libbpf can retry BPF_PROG_LOAD command if bpf() syscall returns
-	 * -EAGAIN. This field determines how many attempts libbpf has to
-	 *  make. If not specified, libbpf will use default value of 5.
-	 */
-	int attempts;
-
-	enum bpf_attach_type expected_attach_type;
-	__u32 prog_btf_fd;
-	__u32 prog_flags;
-	__u32 prog_ifindex;
-	__u32 kern_version;
-
-	__u32 attach_btf_id;
-	__u32 attach_prog_fd;
-	__u32 attach_btf_obj_fd;
-
-	const int *fd_array;
-
-	/* .BTF.ext func info data */
-	const void *func_info;
-	__u32 func_info_cnt;
-	__u32 func_info_rec_size;
-
-	/* .BTF.ext line info data */
-	const void *line_info;
-	__u32 line_info_cnt;
-	__u32 line_info_rec_size;
-
-	/* verifier log options */
-	__u32 log_level;
-	__u32 log_size;
-	char *log_buf;
-};
-#define bpf_prog_load_opts__last_field log_buf
-
-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;
@@ -197,15 +102,13 @@ struct bpf_load_program_attr {

 /* Recommend 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_xattr(const struct bpf_load_program_attr *load_attr,
+		       char *log_buf, size_t log_buf_sz);
 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,
--- a/src/bpf_gen_internal.h
+++ b/src/bpf_gen_internal.h
@@ -3,8 +3,6 @@
 #ifndef __BPF_GEN_INTERNAL_H
 #define __BPF_GEN_INTERNAL_H

-#include "bpf.h"
-
 struct ksym_relo_desc {
 	const char *name;
 	int kind;
@@ -47,18 +45,13 @@ struct bpf_gen {
 	int nr_fd_array;
 };

-void bpf_gen__init(struct bpf_gen *gen, int log_level, int nr_progs, int nr_maps);
-int bpf_gen__finish(struct bpf_gen *gen, int nr_progs, int nr_maps);
+void bpf_gen__init(struct bpf_gen *gen, int log_level);
+int bpf_gen__finish(struct bpf_gen *gen);
 void bpf_gen__free(struct bpf_gen *gen);
 void bpf_gen__load_btf(struct bpf_gen *gen, const void *raw_data, __u32 raw_size);
-void bpf_gen__map_create(struct bpf_gen *gen,
-			 enum bpf_map_type map_type, const char *map_name,
-			 __u32 key_size, __u32 value_size, __u32 max_entries,
-			 struct bpf_map_create_opts *map_attr, int map_idx);
-void bpf_gen__prog_load(struct bpf_gen *gen,
-			enum bpf_prog_type prog_type, const char *prog_name,
-			const char *license, struct bpf_insn *insns, size_t insn_cnt,
-			struct bpf_prog_load_opts *load_attr, int prog_idx);
+void bpf_gen__map_create(struct bpf_gen *gen, struct bpf_create_map_params *map_attr, int map_idx);
+struct bpf_prog_load_params;
+void bpf_gen__prog_load(struct bpf_gen *gen, struct bpf_prog_load_params *load_attr, int prog_idx);
 void bpf_gen__map_update_elem(struct bpf_gen *gen, int map_idx, void *value, __u32 value_size);
 void bpf_gen__map_freeze(struct bpf_gen *gen, int map_idx);
 void bpf_gen__record_attach_target(struct bpf_gen *gen, const char *name, enum bpf_attach_type type);
--- a/src/bpf_helper_defs.h
+++ b/src/bpf_helper_defs.h
@@ -314,7 +314,7 @@ static long (*bpf_l4_csum_replace)(struct __sk_buff *skb, __u32 offset, __u64 fr
 * 	if the maximum number of tail calls has been reached for this
 * 	chain of programs. This limit is defined in the kernel by the
 * 	macro **MAX_TAIL_CALL_CNT** (not accessible to user space),
- * 	which is currently set to 33.
+ * 	which is currently set to 32.
 *
 * Returns
 * 	0 on success, or a negative error in case of failure.
@@ -4113,27 +4113,4 @@ static struct unix_sock *(*bpf_skc_to_unix_sock)(void *sk) = (void *) 178;
 */
 static long (*bpf_kallsyms_lookup_name)(const char *name, int name_sz, int flags, __u64 *res) = (void *) 179;

-/*
- * bpf_find_vma
- *
- * 	Find vma of *task* that contains *addr*, call *callback_fn*
- * 	function with *task*, *vma*, and *callback_ctx*.
- * 	The *callback_fn* should be a static function and
- * 	the *callback_ctx* should be a pointer to the stack.
- * 	The *flags* is used to control certain aspects of the helper.
- * 	Currently, the *flags* must be 0.
- *
- * 	The expected callback signature is
- *
- * 	long (\*callback_fn)(struct task_struct \*task, struct vm_area_struct \*vma, void \*callback_ctx);
- *
- *
- * Returns
- * 	0 on success.
- * 	**-ENOENT** if *task->mm* is NULL, or no vma contains *addr*.
- * 	**-EBUSY** if failed to try lock mmap_lock.
- * 	**-EINVAL** for invalid **flags**.
- */
-static long (*bpf_find_vma)(struct task_struct *task, __u64 addr, void *callback_fn, void *callback_ctx, __u64 flags) = (void *) 180;
-

--- a/src/btf.c
+++ b/src/btf.c
@@ -299,7 +299,6 @@ static int btf_type_size(const struct btf_type *t)
 	case BTF_KIND_TYPEDEF:
 	case BTF_KIND_FUNC:
 	case BTF_KIND_FLOAT:
-	case BTF_KIND_TYPE_TAG:
 		return base_size;
 	case BTF_KIND_INT:
 		return base_size + sizeof(__u32);
@@ -350,7 +349,6 @@ static int btf_bswap_type_rest(struct btf_type *t)
 	case BTF_KIND_TYPEDEF:
 	case BTF_KIND_FUNC:
 	case BTF_KIND_FLOAT:
-	case BTF_KIND_TYPE_TAG:
 		return 0;
 	case BTF_KIND_INT:
 		*(__u32 *)(t + 1) = bswap_32(*(__u32 *)(t + 1));
@@ -610,7 +608,6 @@ __s64 btf__resolve_size(const struct btf *btf, __u32 type_id)
 		case BTF_KIND_RESTRICT:
 		case BTF_KIND_VAR:
 		case BTF_KIND_DECL_TAG:
-		case BTF_KIND_TYPE_TAG:
 			type_id = t->type;
 			break;
 		case BTF_KIND_ARRAY:
@@ -652,7 +649,6 @@ int btf__align_of(const struct btf *btf, __u32 id)
 	case BTF_KIND_VOLATILE:
 	case BTF_KIND_CONST:
 	case BTF_KIND_RESTRICT:
-	case BTF_KIND_TYPE_TAG:
 		return btf__align_of(btf, t->type);
 	case BTF_KIND_ARRAY:
 		return btf__align_of(btf, btf_array(t)->type);
@@ -2239,22 +2235,6 @@ int btf__add_restrict(struct btf *btf, int ref_type_id)
 	return btf_add_ref_kind(btf, BTF_KIND_RESTRICT, NULL, ref_type_id);
 }

-/*
- * Append new BTF_KIND_TYPE_TAG type with:
- *   - *value*, non-empty/non-NULL tag value;
- *   - *ref_type_id* - referenced type ID, it might not exist yet;
- * Returns:
- *   - >0, type ID of newly added BTF type;
- *   - <0, on error.
- */
-int btf__add_type_tag(struct btf *btf, const char *value, int ref_type_id)
-{
-	if (!value|| !value[0])
-		return libbpf_err(-EINVAL);
-
-	return btf_add_ref_kind(btf, BTF_KIND_TYPE_TAG, value, ref_type_id);
-}
-
 /*
 * Append new BTF_KIND_FUNC type with:
 *   - *name*, non-empty/non-NULL name;
@@ -2731,11 +2711,15 @@ void btf_ext__free(struct btf_ext *btf_ext)
 	free(btf_ext);
 }

-struct btf_ext *btf_ext__new(const __u8 *data, __u32 size)
+struct btf_ext *btf_ext__new(__u8 *data, __u32 size)
 {
 	struct btf_ext *btf_ext;
 	int err;

+	err = btf_ext_parse_hdr(data, size);
+	if (err)
+		return libbpf_err_ptr(err);
+
 	btf_ext = calloc(1, sizeof(struct btf_ext));
 	if (!btf_ext)
 		return libbpf_err_ptr(-ENOMEM);
@@ -2748,10 +2732,6 @@ struct btf_ext *btf_ext__new(const __u8 *data, __u32 size)
 	}
 	memcpy(btf_ext->data, data, size);

-	err = btf_ext_parse_hdr(btf_ext->data, size);
-	if (err)
-		goto done;
-
 	if (btf_ext->hdr->hdr_len < offsetofend(struct btf_ext_header, line_info_len)) {
 		err = -EINVAL;
 		goto done;
@@ -2866,7 +2846,8 @@ __u32 btf_ext__line_info_rec_size(const struct btf_ext *btf_ext)

 struct btf_dedup;

-static struct btf_dedup *btf_dedup_new(struct btf *btf, const struct btf_dedup_opts *opts);
+static struct btf_dedup *btf_dedup_new(struct btf *btf, struct btf_ext *btf_ext,
+				       const struct btf_dedup_opts *opts);
 static void btf_dedup_free(struct btf_dedup *d);
 static int btf_dedup_prep(struct btf_dedup *d);
 static int btf_dedup_strings(struct btf_dedup *d);
@@ -3013,17 +2994,12 @@ 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, struct btf_ext *btf_ext,
+	       const struct btf_dedup_opts *opts)
 {
-	struct btf_dedup *d;
+	struct btf_dedup *d = btf_dedup_new(btf, btf_ext, opts);
 	int err;

-	if (!OPTS_VALID(opts, btf_dedup_opts))
-		return libbpf_err(-EINVAL);
-
-	d = btf_dedup_new(btf, opts);
 	if (IS_ERR(d)) {
 		pr_debug("btf_dedup_new failed: %ld", PTR_ERR(d));
 		return libbpf_err(-EINVAL);
@@ -3075,19 +3051,6 @@ done:
 	return libbpf_err(err);
 }

-COMPAT_VERSION(bpf__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)

@@ -3200,7 +3163,8 @@ static bool btf_dedup_equal_fn(const void *k1, const void *k2, void *ctx)
 	return k1 == k2;
 }

-static struct btf_dedup *btf_dedup_new(struct btf *btf, const struct btf_dedup_opts *opts)
+static struct btf_dedup *btf_dedup_new(struct btf *btf, struct btf_ext *btf_ext,
+				       const struct btf_dedup_opts *opts)
 {
 	struct btf_dedup *d = calloc(1, sizeof(struct btf_dedup));
 	hashmap_hash_fn hash_fn = btf_dedup_identity_hash_fn;
@@ -3209,11 +3173,13 @@ static struct btf_dedup *btf_dedup_new(struct btf *btf, const struct btf_dedup_o
 	if (!d)
 		return ERR_PTR(-ENOMEM);

-	if (OPTS_GET(opts, force_collisions, false))
+	d->opts.dont_resolve_fwds = opts && opts->dont_resolve_fwds;
+	/* dedup_table_size is now used only to force collisions in tests */
+	if (opts && opts->dedup_table_size == 1)
 		hash_fn = btf_dedup_collision_hash_fn;

 	d->btf = btf;
-	d->btf_ext = OPTS_GET(opts, btf_ext, NULL);
+	d->btf_ext = btf_ext;

 	d->dedup_table = hashmap__new(hash_fn, btf_dedup_equal_fn, NULL);
 	if (IS_ERR(d->dedup_table)) {
@@ -3477,8 +3443,8 @@ static long btf_hash_struct(struct btf_type *t)
 }

 /*
- * Check structural compatibility of two STRUCTs/UNIONs, ignoring referenced
- * type IDs. This check is performed during type graph equivalence check and
+ * Check structural compatibility of two FUNC_PROTOs, ignoring referenced type
+ * IDs. This check is performed during type graph equivalence check and
 * referenced types equivalence is checked separately.
 */
 static bool btf_shallow_equal_struct(struct btf_type *t1, struct btf_type *t2)
@@ -3659,7 +3625,6 @@ static int btf_dedup_prep(struct btf_dedup *d)
 		case BTF_KIND_TYPEDEF:
 		case BTF_KIND_FUNC:
 		case BTF_KIND_FLOAT:
-		case BTF_KIND_TYPE_TAG:
 			h = btf_hash_common(t);
 			break;
 		case BTF_KIND_INT:
@@ -3720,7 +3685,6 @@ static int btf_dedup_prim_type(struct btf_dedup *d, __u32 type_id)
 	case BTF_KIND_VAR:
 	case BTF_KIND_DATASEC:
 	case BTF_KIND_DECL_TAG:
-	case BTF_KIND_TYPE_TAG:
 		return 0;

 	case BTF_KIND_INT:
@@ -3744,6 +3708,8 @@ static int btf_dedup_prim_type(struct btf_dedup *d, __u32 type_id)
 				new_id = cand_id;
 				break;
 			}
+			if (d->opts.dont_resolve_fwds)
+				continue;
 			if (btf_compat_enum(t, cand)) {
 				if (btf_is_enum_fwd(t)) {
 					/* resolve fwd to full enum */
@@ -3851,31 +3817,6 @@ static int btf_dedup_identical_arrays(struct btf_dedup *d, __u32 id1, __u32 id2)
 	return btf_equal_array(t1, t2);
 }

-/* Check if given two types are identical STRUCT/UNION definitions */
-static bool btf_dedup_identical_structs(struct btf_dedup *d, __u32 id1, __u32 id2)
-{
-	const struct btf_member *m1, *m2;
-	struct btf_type *t1, *t2;
-	int n, i;
-
-	t1 = btf_type_by_id(d->btf, id1);
-	t2 = btf_type_by_id(d->btf, id2);
-
-	if (!btf_is_composite(t1) || btf_kind(t1) != btf_kind(t2))
-		return false;
-
-	if (!btf_shallow_equal_struct(t1, t2))
-		return false;
-
-	m1 = btf_members(t1);
-	m2 = btf_members(t2);
-	for (i = 0, n = btf_vlen(t1); i < n; i++, m1++, m2++) {
-		if (m1->type != m2->type)
-			return false;
-	}
-	return true;
-}
-
 /*
 * Check equivalence of BTF type graph formed by candidate struct/union (we'll
 * call it "candidate graph" in this description for brevity) to a type graph
@@ -3987,8 +3928,6 @@ static int btf_dedup_is_equiv(struct btf_dedup *d, __u32 cand_id,

 	hypot_type_id = d->hypot_map[canon_id];
 	if (hypot_type_id <= BTF_MAX_NR_TYPES) {
-		if (hypot_type_id == cand_id)
-			return 1;
 		/* In some cases compiler will generate different DWARF types
 		 * for *identical* array type definitions and use them for
 		 * different fields within the *same* struct. This breaks type
@@ -3997,18 +3936,8 @@ static int btf_dedup_is_equiv(struct btf_dedup *d, __u32 cand_id,
 		 * types within a single CU. So work around that by explicitly
 		 * allowing identical array types here.
 		 */
-		if (btf_dedup_identical_arrays(d, hypot_type_id, cand_id))
-			return 1;
-		/* It turns out that similar situation can happen with
-		 * struct/union sometimes, sigh... Handle the case where
-		 * structs/unions are exactly the same, down to the referenced
-		 * type IDs. Anything more complicated (e.g., if referenced
-		 * types are different, but equivalent) is *way more*
-		 * complicated and requires a many-to-many equivalence mapping.
-		 */
-		if (btf_dedup_identical_structs(d, hypot_type_id, cand_id))
-			return 1;
-		return 0;
+		return hypot_type_id == cand_id ||
+		       btf_dedup_identical_arrays(d, hypot_type_id, cand_id);
 	}

 	if (btf_dedup_hypot_map_add(d, canon_id, cand_id))
@@ -4023,7 +3952,8 @@ static int btf_dedup_is_equiv(struct btf_dedup *d, __u32 cand_id,
 		return 0;

 	/* FWD <--> STRUCT/UNION equivalence check, if enabled */
-	if ((cand_kind == BTF_KIND_FWD || canon_kind == BTF_KIND_FWD)
+	if (!d->opts.dont_resolve_fwds
+	    && (cand_kind == BTF_KIND_FWD || canon_kind == BTF_KIND_FWD)
 	    && cand_kind != canon_kind) {
 		__u16 real_kind;
 		__u16 fwd_kind;
@@ -4049,7 +3979,10 @@ static int btf_dedup_is_equiv(struct btf_dedup *d, __u32 cand_id,
 		return btf_equal_int_tag(cand_type, canon_type);

 	case BTF_KIND_ENUM:
-		return btf_compat_enum(cand_type, canon_type);
+		if (d->opts.dont_resolve_fwds)
+			return btf_equal_enum(cand_type, canon_type);
+		else
+			return btf_compat_enum(cand_type, canon_type);

 	case BTF_KIND_FWD:
 	case BTF_KIND_FLOAT:
@@ -4061,7 +3994,6 @@ static int btf_dedup_is_equiv(struct btf_dedup *d, __u32 cand_id,
 	case BTF_KIND_PTR:
 	case BTF_KIND_TYPEDEF:
 	case BTF_KIND_FUNC:
-	case BTF_KIND_TYPE_TAG:
 		if (cand_type->info != canon_type->info)
 			return 0;
 		return btf_dedup_is_equiv(d, cand_type->type, canon_type->type);
@@ -4357,7 +4289,6 @@ static int btf_dedup_ref_type(struct btf_dedup *d, __u32 type_id)
 	case BTF_KIND_PTR:
 	case BTF_KIND_TYPEDEF:
 	case BTF_KIND_FUNC:
-	case BTF_KIND_TYPE_TAG:
 		ref_type_id = btf_dedup_ref_type(d, t->type);
 		if (ref_type_id < 0)
 			return ref_type_id;
@@ -4664,7 +4595,6 @@ int btf_type_visit_type_ids(struct btf_type *t, type_id_visit_fn visit, void *ct
 	case BTF_KIND_FUNC:
 	case BTF_KIND_VAR:
 	case BTF_KIND_DECL_TAG:
-	case BTF_KIND_TYPE_TAG:
 		return visit(&t->type, ctx);

 	case BTF_KIND_ARRAY: {
--- a/src/btf.h
+++ b/src/btf.h
@@ -157,7 +157,7 @@ LIBBPF_API int btf__get_map_kv_tids(const struct btf *btf, const char *map_name,
 				    __u32 expected_value_size,
 				    __u32 *key_type_id, __u32 *value_type_id);

-LIBBPF_API struct btf_ext *btf_ext__new(const __u8 *data, __u32 size);
+LIBBPF_API struct btf_ext *btf_ext__new(__u8 *data, __u32 size);
 LIBBPF_API void btf_ext__free(struct btf_ext *btf_ext);
 LIBBPF_API const void *btf_ext__get_raw_data(const struct btf_ext *btf_ext,
 					     __u32 *size);
@@ -227,7 +227,6 @@ LIBBPF_API int btf__add_typedef(struct btf *btf, const char *name, int ref_type_
 LIBBPF_API int btf__add_volatile(struct btf *btf, int ref_type_id);
 LIBBPF_API int btf__add_const(struct btf *btf, int ref_type_id);
 LIBBPF_API int btf__add_restrict(struct btf *btf, int ref_type_id);
-LIBBPF_API int btf__add_type_tag(struct btf *btf, const char *value, int ref_type_id);

 /* func and func_proto construction APIs */
 LIBBPF_API int btf__add_func(struct btf *btf, const char *name,
@@ -246,80 +245,25 @@ LIBBPF_API int btf__add_decl_tag(struct btf *btf, const char *value, int ref_typ
 			    int component_idx);

 struct btf_dedup_opts {
-	size_t sz;
-	/* optional .BTF.ext info to dedup along the main BTF info */
-	struct btf_ext *btf_ext;
-	/* force hash collisions (used for testing) */
-	bool force_collisions;
-	size_t :0;
+	unsigned int dedup_table_size;
+	bool dont_resolve_fwds;
 };
-#define btf_dedup_opts__last_field force_collisions

-LIBBPF_API int btf__dedup(struct btf *btf, const struct btf_dedup_opts *opts);
-
-LIBBPF_API int btf__dedup_v0_6_0(struct btf *btf, const struct btf_dedup_opts *opts);
-
-LIBBPF_DEPRECATED_SINCE(0, 7, "use btf__dedup() instead")
-LIBBPF_API int btf__dedup_deprecated(struct btf *btf, struct btf_ext *btf_ext, const void *opts);
-#define btf__dedup(...) ___libbpf_overload(___btf_dedup, __VA_ARGS__)
-#define ___btf_dedup3(btf, btf_ext, opts) btf__dedup_deprecated(btf, btf_ext, opts)
-#define ___btf_dedup2(btf, opts) btf__dedup(btf, opts)
+LIBBPF_API int btf__dedup(struct btf *btf, struct btf_ext *btf_ext,
+			  const struct btf_dedup_opts *opts);

 struct btf_dump;

 struct btf_dump_opts {
-	union {
-		size_t sz;
-		void *ctx; /* DEPRECATED: will be gone in v1.0 */
-	};
+	void *ctx;
 };

 typedef void (*btf_dump_printf_fn_t)(void *ctx, const char *fmt, va_list args);

 LIBBPF_API struct btf_dump *btf_dump__new(const struct btf *btf,
-					  btf_dump_printf_fn_t printf_fn,
-					  void *ctx,
-					  const struct btf_dump_opts *opts);
-
-LIBBPF_API struct btf_dump *btf_dump__new_v0_6_0(const struct btf *btf,
-						 btf_dump_printf_fn_t printf_fn,
-						 void *ctx,
-						 const struct btf_dump_opts *opts);
-
-LIBBPF_API struct btf_dump *btf_dump__new_deprecated(const struct btf *btf,
-						     const struct btf_ext *btf_ext,
-						     const struct btf_dump_opts *opts,
-						     btf_dump_printf_fn_t printf_fn);
-
-/* Choose either btf_dump__new() or btf_dump__new_deprecated() based on the
- * type of 4th argument. If it's btf_dump's print callback, use deprecated
- * API; otherwise, choose the new btf_dump__new(). ___libbpf_override()
- * doesn't work here because both variants have 4 input arguments.
- *
- * (void *) casts are necessary to avoid compilation warnings about type
- * mismatches, because even though __builtin_choose_expr() only ever evaluates
- * one side the other side still has to satisfy type constraints (this is
- * compiler implementation limitation which might be lifted eventually,
- * according to the documentation). So passing struct btf_ext in place of
- * btf_dump_printf_fn_t would be generating compilation warning.  Casting to
- * void * avoids this issue.
- *
- * Also, two type compatibility checks for a function and function pointer are
- * required because passing function reference into btf_dump__new() as
- * btf_dump__new(..., my_callback, ...) and as btf_dump__new(...,
- * &my_callback, ...) (not explicit ampersand in the latter case) actually
- * differs as far as __builtin_types_compatible_p() is concerned. Thus two
- * checks are combined to detect callback argument.
- *
- * The rest works just like in case of ___libbpf_override() usage with symbol
- * versioning.
- */
-#define btf_dump__new(a1, a2, a3, a4) __builtin_choose_expr(				\
-	__builtin_types_compatible_p(typeof(a4), btf_dump_printf_fn_t) ||		\
-	__builtin_types_compatible_p(typeof(a4), void(void *, const char *, va_list)),	\
-	btf_dump__new_deprecated((void *)a1, (void *)a2, (void *)a3, (void *)a4),	\
-	btf_dump__new((void *)a1, (void *)a2, (void *)a3, (void *)a4))
-
+					  const struct btf_ext *btf_ext,
+					  const struct btf_dump_opts *opts,
+					  btf_dump_printf_fn_t printf_fn);
 LIBBPF_API void btf_dump__free(struct btf_dump *d);

 LIBBPF_API int btf_dump__dump_type(struct btf_dump *d, __u32 id);
@@ -459,8 +403,7 @@ static inline bool btf_is_mod(const struct btf_type *t)

 	return kind == BTF_KIND_VOLATILE ||
 	       kind == BTF_KIND_CONST ||
-	       kind == BTF_KIND_RESTRICT ||
-	       kind == BTF_KIND_TYPE_TAG;
+	       kind == BTF_KIND_RESTRICT;
 }

 static inline bool btf_is_func(const struct btf_type *t)
@@ -493,11 +436,6 @@ static inline bool btf_is_decl_tag(const struct btf_type *t)
 	return btf_kind(t) == BTF_KIND_DECL_TAG;
 }

-static inline bool btf_is_type_tag(const struct btf_type *t)
-{
-	return btf_kind(t) == BTF_KIND_TYPE_TAG;
-}
-
 static inline __u8 btf_int_encoding(const struct btf_type *t)
 {
 	return BTF_INT_ENCODING(*(__u32 *)(t + 1));
--- a/src/btf_dump.c
+++ b/src/btf_dump.c
@@ -77,8 +77,9 @@ struct btf_dump_data {

 struct btf_dump {
 	const struct btf *btf;
+	const struct btf_ext *btf_ext;
 	btf_dump_printf_fn_t printf_fn;
-	void *cb_ctx;
+	struct btf_dump_opts opts;
 	int ptr_sz;
 	bool strip_mods;
 	bool skip_anon_defs;
@@ -137,32 +138,29 @@ static void btf_dump_printf(const struct btf_dump *d, const char *fmt, ...)
 	va_list args;

 	va_start(args, fmt);
-	d->printf_fn(d->cb_ctx, fmt, args);
+	d->printf_fn(d->opts.ctx, fmt, args);
 	va_end(args);
 }

 static int btf_dump_mark_referenced(struct btf_dump *d);
 static int btf_dump_resize(struct btf_dump *d);

-DEFAULT_VERSION(btf_dump__new_v0_6_0, btf_dump__new, LIBBPF_0.6.0)
-struct btf_dump *btf_dump__new_v0_6_0(const struct btf *btf,
-				      btf_dump_printf_fn_t printf_fn,
-				      void *ctx,
-				      const struct btf_dump_opts *opts)
+struct btf_dump *btf_dump__new(const struct btf *btf,
+			       const struct btf_ext *btf_ext,
+			       const struct btf_dump_opts *opts,
+			       btf_dump_printf_fn_t printf_fn)
 {
 	struct btf_dump *d;
 	int err;

-	if (!printf_fn)
-		return libbpf_err_ptr(-EINVAL);
-
 	d = calloc(1, sizeof(struct btf_dump));
 	if (!d)
 		return libbpf_err_ptr(-ENOMEM);

 	d->btf = btf;
+	d->btf_ext = btf_ext;
 	d->printf_fn = printf_fn;
-	d->cb_ctx = ctx;
+	d->opts.ctx = opts ? opts->ctx : NULL;
 	d->ptr_sz = btf__pointer_size(btf) ? : sizeof(void *);

 	d->type_names = hashmap__new(str_hash_fn, str_equal_fn, NULL);
@@ -188,17 +186,6 @@ err:
 	return libbpf_err_ptr(err);
 }

-COMPAT_VERSION(btf_dump__new_deprecated, btf_dump__new, LIBBPF_0.0.4)
-struct btf_dump *btf_dump__new_deprecated(const struct btf *btf,
-					  const struct btf_ext *btf_ext,
-					  const struct btf_dump_opts *opts,
-					  btf_dump_printf_fn_t printf_fn)
-{
-	if (!printf_fn)
-		return libbpf_err_ptr(-EINVAL);
-	return btf_dump__new_v0_6_0(btf, printf_fn, opts ? opts->ctx : NULL, opts);
-}
-
 static int btf_dump_resize(struct btf_dump *d)
 {
 	int err, last_id = btf__type_cnt(d->btf) - 1;
@@ -330,7 +317,6 @@ static int btf_dump_mark_referenced(struct btf_dump *d)
 		case BTF_KIND_FUNC:
 		case BTF_KIND_VAR:
 		case BTF_KIND_DECL_TAG:
-		case BTF_KIND_TYPE_TAG:
 			d->type_states[t->type].referenced = 1;
 			break;

@@ -574,7 +560,6 @@ static int btf_dump_order_type(struct btf_dump *d, __u32 id, bool through_ptr)
 	case BTF_KIND_VOLATILE:
 	case BTF_KIND_CONST:
 	case BTF_KIND_RESTRICT:
-	case BTF_KIND_TYPE_TAG:
 		return btf_dump_order_type(d, t->type, through_ptr);

 	case BTF_KIND_FUNC_PROTO: {
@@ -749,7 +734,6 @@ static void btf_dump_emit_type(struct btf_dump *d, __u32 id, __u32 cont_id)
 	case BTF_KIND_VOLATILE:
 	case BTF_KIND_CONST:
 	case BTF_KIND_RESTRICT:
-	case BTF_KIND_TYPE_TAG:
 		btf_dump_emit_type(d, t->type, cont_id);
 		break;
 	case BTF_KIND_ARRAY:
@@ -1170,7 +1154,6 @@ skip_mod:
 		case BTF_KIND_CONST:
 		case BTF_KIND_RESTRICT:
 		case BTF_KIND_FUNC_PROTO:
-		case BTF_KIND_TYPE_TAG:
 			id = t->type;
 			break;
 		case BTF_KIND_ARRAY:
@@ -1339,11 +1322,6 @@ static void btf_dump_emit_type_chain(struct btf_dump *d,
 		case BTF_KIND_RESTRICT:
 			btf_dump_printf(d, " restrict");
 			break;
-		case BTF_KIND_TYPE_TAG:
-			btf_dump_emit_mods(d, decls);
-			name = btf_name_of(d, t->name_off);
-			btf_dump_printf(d, " __attribute__((btf_type_tag(\"%s\")))", name);
-			break;
 		case BTF_KIND_ARRAY: {
 			const struct btf_array *a = btf_array(t);
 			const struct btf_type *next_t;
@@ -2216,7 +2194,7 @@ static int btf_dump_dump_type_data(struct btf_dump *d,
 				   __u8 bits_offset,
 				   __u8 bit_sz)
 {
-	int size, err = 0;
+	int size, err;

 	size = btf_dump_type_data_check_overflow(d, t, id, data, bits_offset);
 	if (size < 0)
--- a/src/gen_loader.c
+++ b/src/gen_loader.c
@@ -18,7 +18,7 @@
 #define MAX_USED_MAPS	64
 #define MAX_USED_PROGS	32
 #define MAX_KFUNC_DESCS 256
-#define MAX_FD_ARRAY_SZ (MAX_USED_MAPS + MAX_KFUNC_DESCS)
+#define MAX_FD_ARRAY_SZ (MAX_USED_PROGS + MAX_KFUNC_DESCS)

 /* The following structure describes the stack layout of the loader program.
 * In addition R6 contains the pointer to context.
@@ -33,8 +33,8 @@
 */
 struct loader_stack {
 	__u32 btf_fd;
-	__u32 inner_map_fd;
 	__u32 prog_fd[MAX_USED_PROGS];
+	__u32 inner_map_fd;
 };

 #define stack_off(field) \
@@ -42,11 +42,6 @@ struct loader_stack {

 #define attr_field(attr, field) (attr + offsetof(union bpf_attr, field))

-static int blob_fd_array_off(struct bpf_gen *gen, int index)
-{
-	return gen->fd_array + index * sizeof(int);
-}
-
 static int realloc_insn_buf(struct bpf_gen *gen, __u32 size)
 {
 	size_t off = gen->insn_cur - gen->insn_start;
@@ -107,15 +102,11 @@ static void emit2(struct bpf_gen *gen, struct bpf_insn insn1, struct bpf_insn in
 	emit(gen, insn2);
 }

-static int add_data(struct bpf_gen *gen, const void *data, __u32 size);
-static void emit_sys_close_blob(struct bpf_gen *gen, int blob_off);
-
-void bpf_gen__init(struct bpf_gen *gen, int log_level, int nr_progs, int nr_maps)
+void bpf_gen__init(struct bpf_gen *gen, int log_level)
 {
-	size_t stack_sz = sizeof(struct loader_stack), nr_progs_sz;
+	size_t stack_sz = sizeof(struct loader_stack);
 	int i;

-	gen->fd_array = add_data(gen, NULL, MAX_FD_ARRAY_SZ * sizeof(int));
 	gen->log_level = log_level;
 	/* save ctx pointer into R6 */
 	emit(gen, BPF_MOV64_REG(BPF_REG_6, BPF_REG_1));
@@ -127,27 +118,19 @@ void bpf_gen__init(struct bpf_gen *gen, int log_level, int nr_progs, int nr_maps
 	emit(gen, BPF_MOV64_IMM(BPF_REG_3, 0));
 	emit(gen, BPF_EMIT_CALL(BPF_FUNC_probe_read_kernel));

-	/* amount of stack actually used, only used to calculate iterations, not stack offset */
-	nr_progs_sz = offsetof(struct loader_stack, prog_fd[nr_progs]);
 	/* jump over cleanup code */
 	emit(gen, BPF_JMP_IMM(BPF_JA, 0, 0,
-			      /* size of cleanup code below (including map fd cleanup) */
-			      (nr_progs_sz / 4) * 3 + 2 +
-			      /* 6 insns for emit_sys_close_blob,
-			       * 6 insns for debug_regs in emit_sys_close_blob
-			       */
-			      nr_maps * (6 + (gen->log_level ? 6 : 0))));
+			      /* size of cleanup code below */
+			      (stack_sz / 4) * 3 + 2));

 	/* remember the label where all error branches will jump to */
 	gen->cleanup_label = gen->insn_cur - gen->insn_start;
 	/* emit cleanup code: close all temp FDs */
-	for (i = 0; i < nr_progs_sz; i += 4) {
+	for (i = 0; i < stack_sz; i += 4) {
 		emit(gen, BPF_LDX_MEM(BPF_W, BPF_REG_1, BPF_REG_10, -stack_sz + i));
 		emit(gen, BPF_JMP_IMM(BPF_JSLE, BPF_REG_1, 0, 1));
 		emit(gen, BPF_EMIT_CALL(BPF_FUNC_sys_close));
 	}
-	for (i = 0; i < nr_maps; i++)
-		emit_sys_close_blob(gen, blob_fd_array_off(gen, i));
 	/* R7 contains the error code from sys_bpf. Copy it into R0 and exit. */
 	emit(gen, BPF_MOV64_REG(BPF_REG_0, BPF_REG_7));
 	emit(gen, BPF_EXIT_INSN());
@@ -177,6 +160,8 @@ static int add_data(struct bpf_gen *gen, const void *data, __u32 size)
 */
 static int add_map_fd(struct bpf_gen *gen)
 {
+	if (!gen->fd_array)
+		gen->fd_array = add_data(gen, NULL, MAX_FD_ARRAY_SZ * sizeof(int));
 	if (gen->nr_maps == MAX_USED_MAPS) {
 		pr_warn("Total maps exceeds %d\n", MAX_USED_MAPS);
 		gen->error = -E2BIG;
@@ -189,6 +174,8 @@ static int add_kfunc_btf_fd(struct bpf_gen *gen)
 {
 	int cur;

+	if (!gen->fd_array)
+		gen->fd_array = add_data(gen, NULL, MAX_FD_ARRAY_SZ * sizeof(int));
 	if (gen->nr_fd_array == MAX_KFUNC_DESCS) {
 		cur = add_data(gen, NULL, sizeof(int));
 		return (cur - gen->fd_array) / sizeof(int);
@@ -196,6 +183,11 @@ static int add_kfunc_btf_fd(struct bpf_gen *gen)
 	return MAX_USED_MAPS + gen->nr_fd_array++;
 }

+static int blob_fd_array_off(struct bpf_gen *gen, int index)
+{
+	return gen->fd_array + index * sizeof(int);
+}
+
 static int insn_bytes_to_bpf_size(__u32 sz)
 {
 	switch (sz) {
@@ -367,15 +359,10 @@ static void emit_sys_close_blob(struct bpf_gen *gen, int blob_off)
 	__emit_sys_close(gen);
 }

-int bpf_gen__finish(struct bpf_gen *gen, int nr_progs, int nr_maps)
+int bpf_gen__finish(struct bpf_gen *gen)
 {
 	int i;

-	if (nr_progs != gen->nr_progs || nr_maps != gen->nr_maps) {
-		pr_warn("progs/maps mismatch\n");
-		gen->error = -EFAULT;
-		return gen->error;
-	}
 	emit_sys_close_stack(gen, stack_off(btf_fd));
 	for (i = 0; i < gen->nr_progs; i++)
 		move_stack2ctx(gen,
@@ -445,33 +432,47 @@ void bpf_gen__load_btf(struct bpf_gen *gen, const void *btf_raw_data,
 }

 void bpf_gen__map_create(struct bpf_gen *gen,
-			 enum bpf_map_type map_type,
-			 const char *map_name,
-			 __u32 key_size, __u32 value_size, __u32 max_entries,
-			 struct bpf_map_create_opts *map_attr, int map_idx)
+			 struct bpf_create_map_params *map_attr, int map_idx)
 {
-	int attr_size = offsetofend(union bpf_attr, map_extra);
+	int attr_size = offsetofend(union bpf_attr, btf_vmlinux_value_type_id);
 	bool close_inner_map_fd = false;
 	int map_create_attr, idx;
 	union bpf_attr attr;

 	memset(&attr, 0, attr_size);
-	attr.map_type = map_type;
-	attr.key_size = key_size;
-	attr.value_size = value_size;
+	attr.map_type = map_attr->map_type;
+	attr.key_size = map_attr->key_size;
+	attr.value_size = map_attr->value_size;
 	attr.map_flags = map_attr->map_flags;
 	attr.map_extra = map_attr->map_extra;
-	if (map_name)
-		memcpy(attr.map_name, map_name,
-		       min((unsigned)strlen(map_name), BPF_OBJ_NAME_LEN - 1));
+	memcpy(attr.map_name, map_attr->name,
+	       min((unsigned)strlen(map_attr->name), BPF_OBJ_NAME_LEN - 1));
 	attr.numa_node = map_attr->numa_node;
 	attr.map_ifindex = map_attr->map_ifindex;
-	attr.max_entries = max_entries;
-	attr.btf_key_type_id = map_attr->btf_key_type_id;
-	attr.btf_value_type_id = map_attr->btf_value_type_id;
+	attr.max_entries = map_attr->max_entries;
+	switch (attr.map_type) {
+	case BPF_MAP_TYPE_PERF_EVENT_ARRAY:
+	case BPF_MAP_TYPE_CGROUP_ARRAY:
+	case BPF_MAP_TYPE_STACK_TRACE:
+	case BPF_MAP_TYPE_ARRAY_OF_MAPS:
+	case BPF_MAP_TYPE_HASH_OF_MAPS:
+	case BPF_MAP_TYPE_DEVMAP:
+	case BPF_MAP_TYPE_DEVMAP_HASH:
+	case BPF_MAP_TYPE_CPUMAP:
+	case BPF_MAP_TYPE_XSKMAP:
+	case BPF_MAP_TYPE_SOCKMAP:
+	case BPF_MAP_TYPE_SOCKHASH:
+	case BPF_MAP_TYPE_QUEUE:
+	case BPF_MAP_TYPE_STACK:
+	case BPF_MAP_TYPE_RINGBUF:
+		break;
+	default:
+		attr.btf_key_type_id = map_attr->btf_key_type_id;
+		attr.btf_value_type_id = map_attr->btf_value_type_id;
+	}

 	pr_debug("gen: map_create: %s idx %d type %d value_type_id %d\n",
-		 attr.map_name, map_idx, map_type, attr.btf_value_type_id);
+		 attr.map_name, map_idx, map_attr->map_type, attr.btf_value_type_id);

 	map_create_attr = add_data(gen, &attr, attr_size);
 	if (attr.btf_value_type_id)
@@ -498,7 +499,7 @@ void bpf_gen__map_create(struct bpf_gen *gen,
 	/* emit MAP_CREATE command */
 	emit_sys_bpf(gen, BPF_MAP_CREATE, map_create_attr, attr_size);
 	debug_ret(gen, "map_create %s idx %d type %d value_size %d value_btf_id %d",
-		  attr.map_name, map_idx, map_type, value_size,
+		  attr.map_name, map_idx, map_attr->map_type, attr.value_size,
 		  attr.btf_value_type_id);
 	emit_check_err(gen);
 	/* remember map_fd in the stack, if successful */
@@ -900,27 +901,27 @@ static void cleanup_relos(struct bpf_gen *gen, int insns)
 }

 void bpf_gen__prog_load(struct bpf_gen *gen,
-			enum bpf_prog_type prog_type, const char *prog_name,
-			const char *license, struct bpf_insn *insns, size_t insn_cnt,
-			struct bpf_prog_load_opts *load_attr, int prog_idx)
+			struct bpf_prog_load_params *load_attr, int prog_idx)
 {
 	int attr_size = offsetofend(union bpf_attr, fd_array);
-	int prog_load_attr, license_off, insns_off, func_info, line_info;
+	int prog_load_attr, license, insns, func_info, line_info;
 	union bpf_attr attr;

 	memset(&attr, 0, attr_size);
-	pr_debug("gen: prog_load: type %d insns_cnt %zd\n", prog_type, insn_cnt);
+	pr_debug("gen: prog_load: type %d insns_cnt %zd\n",
+		 load_attr->prog_type, load_attr->insn_cnt);
 	/* add license string to blob of bytes */
-	license_off = add_data(gen, license, strlen(license) + 1);
+	license = add_data(gen, load_attr->license, strlen(load_attr->license) + 1);
 	/* add insns to blob of bytes */
-	insns_off = add_data(gen, insns, insn_cnt * sizeof(struct bpf_insn));
+	insns = add_data(gen, load_attr->insns,
+			 load_attr->insn_cnt * sizeof(struct bpf_insn));

-	attr.prog_type = prog_type;
+	attr.prog_type = load_attr->prog_type;
 	attr.expected_attach_type = load_attr->expected_attach_type;
 	attr.attach_btf_id = load_attr->attach_btf_id;
 	attr.prog_ifindex = load_attr->prog_ifindex;
 	attr.kern_version = 0;
-	attr.insn_cnt = (__u32)insn_cnt;
+	attr.insn_cnt = (__u32)load_attr->insn_cnt;
 	attr.prog_flags = load_attr->prog_flags;

 	attr.func_info_rec_size = load_attr->func_info_rec_size;
@@ -933,15 +934,15 @@ void bpf_gen__prog_load(struct bpf_gen *gen,
 	line_info = add_data(gen, load_attr->line_info,
 			     attr.line_info_cnt * attr.line_info_rec_size);

-	memcpy(attr.prog_name, prog_name,
-	       min((unsigned)strlen(prog_name), BPF_OBJ_NAME_LEN - 1));
+	memcpy(attr.prog_name, load_attr->name,
+	       min((unsigned)strlen(load_attr->name), BPF_OBJ_NAME_LEN - 1));
 	prog_load_attr = add_data(gen, &attr, attr_size);

 	/* populate union bpf_attr with a pointer to license */
-	emit_rel_store(gen, attr_field(prog_load_attr, license), license_off);
+	emit_rel_store(gen, attr_field(prog_load_attr, license), license);

 	/* populate union bpf_attr with a pointer to instructions */
-	emit_rel_store(gen, attr_field(prog_load_attr, insns), insns_off);
+	emit_rel_store(gen, attr_field(prog_load_attr, insns), insns);

 	/* populate union bpf_attr with a pointer to func_info */
 	emit_rel_store(gen, attr_field(prog_load_attr, func_info), func_info);
@@ -973,12 +974,12 @@ void bpf_gen__prog_load(struct bpf_gen *gen,
 		emit(gen, BPF_STX_MEM(BPF_W, BPF_REG_0, BPF_REG_7,
 				      offsetof(union bpf_attr, attach_btf_obj_fd)));
 	}
-	emit_relos(gen, insns_off);
+	emit_relos(gen, insns);
 	/* emit PROG_LOAD command */
 	emit_sys_bpf(gen, BPF_PROG_LOAD, prog_load_attr, attr_size);
 	debug_ret(gen, "prog_load %s insn_cnt %d", attr.prog_name, attr.insn_cnt);
 	/* successful or not, close btf module FDs used in extern ksyms and attach_btf_obj_fd */
-	cleanup_relos(gen, insns_off);
+	cleanup_relos(gen, insns);
 	if (gen->attach_kind)
 		emit_sys_close_blob(gen,
 				    attr_field(prog_load_attr, attach_btf_obj_fd));
--- a/src/libbpf.c
+++ b/src/libbpf.c
--- a/src/libbpf.h
+++ b/src/libbpf.h
@@ -24,10 +24,6 @@
 extern "C" {
 #endif

-LIBBPF_API __u32 libbpf_major_version(void);
-LIBBPF_API __u32 libbpf_minor_version(void);
-LIBBPF_API const char *libbpf_version_string(void);
-
 enum libbpf_errno {
 	__LIBBPF_ERRNO__START = 4000,

@@ -435,6 +431,7 @@ bpf_program__attach_iter(const struct bpf_program *prog,
 * one instance. In this case bpf_program__fd(prog) is equal to
 * bpf_program__nth_fd(prog, 0).
 */
+LIBBPF_DEPRECATED_SINCE(0, 7, "use bpf_program__insns() for getting bpf_program instructions")
 struct bpf_prog_prep_result {
 	/*
 	 * If not NULL, load new instruction array.
@@ -497,9 +494,6 @@ LIBBPF_API void
 bpf_program__set_expected_attach_type(struct bpf_program *prog,
 				      enum bpf_attach_type type);

-LIBBPF_API __u32 bpf_program__flags(const struct bpf_program *prog);
-LIBBPF_API int bpf_program__set_flags(struct bpf_program *prog, __u32 flags);
-
 LIBBPF_API int
 bpf_program__set_attach_target(struct bpf_program *prog, int attach_prog_fd,
 			       const char *attach_func_name);
@@ -682,9 +676,8 @@ struct bpf_prog_load_attr {

 LIBBPF_API int bpf_prog_load_xattr(const struct bpf_prog_load_attr *attr,
 				   struct bpf_object **pobj, int *prog_fd);
-LIBBPF_DEPRECATED_SINCE(0, 7, "use bpf_object__open() and bpf_object__load() instead")
-LIBBPF_API int bpf_prog_load_deprecated(const char *file, enum bpf_prog_type type,
-					struct bpf_object **pobj, int *prog_fd);
+LIBBPF_API int bpf_prog_load(const char *file, enum bpf_prog_type type,
+			     struct bpf_object **pobj, int *prog_fd);

 /* XDP related API */
 struct xdp_link_info {
@@ -782,52 +775,18 @@ typedef void (*perf_buffer_lost_fn)(void *ctx, int cpu, __u64 cnt);

 /* common use perf buffer options */
 struct perf_buffer_opts {
-	union {
-		size_t sz;
-		struct { /* DEPRECATED: will be removed in v1.0 */
-			/* if specified, sample_cb is called for each sample */
-			perf_buffer_sample_fn sample_cb;
-			/* if specified, lost_cb is called for each batch of lost samples */
-			perf_buffer_lost_fn lost_cb;
-			/* ctx is provided to sample_cb and lost_cb */
-			void *ctx;
-		};
-	};
+	/* if specified, sample_cb is called for each sample */
+	perf_buffer_sample_fn sample_cb;
+	/* if specified, lost_cb is called for each batch of lost samples */
+	perf_buffer_lost_fn lost_cb;
+	/* ctx is provided to sample_cb and lost_cb */
+	void *ctx;
 };
-#define perf_buffer_opts__last_field sz

-/**
- * @brief **perf_buffer__new()** creates BPF perfbuf manager for a specified
- * BPF_PERF_EVENT_ARRAY map
- * @param map_fd FD of BPF_PERF_EVENT_ARRAY BPF map that will be used by BPF
- * code to send data over to user-space
- * @param page_cnt number of memory pages allocated for each per-CPU buffer
- * @param sample_cb function called on each received data record
- * @param lost_cb function called when record loss has occurred
- * @param ctx user-provided extra context passed into *sample_cb* and *lost_cb*
- * @return a new instance of struct perf_buffer on success, NULL on error with
- * *errno* containing an error code
- */
 LIBBPF_API struct perf_buffer *
 perf_buffer__new(int map_fd, size_t page_cnt,
-		 perf_buffer_sample_fn sample_cb, perf_buffer_lost_fn lost_cb, void *ctx,
 		 const struct perf_buffer_opts *opts);

-LIBBPF_API struct perf_buffer *
-perf_buffer__new_v0_6_0(int map_fd, size_t page_cnt,
-			perf_buffer_sample_fn sample_cb, perf_buffer_lost_fn lost_cb, void *ctx,
-			const struct perf_buffer_opts *opts);
-
-LIBBPF_API LIBBPF_DEPRECATED_SINCE(0, 7, "use new variant of perf_buffer__new() instead")
-struct perf_buffer *perf_buffer__new_deprecated(int map_fd, size_t page_cnt,
-						const struct perf_buffer_opts *opts);
-
-#define perf_buffer__new(...) ___libbpf_overload(___perf_buffer_new, __VA_ARGS__)
-#define ___perf_buffer_new6(map_fd, page_cnt, sample_cb, lost_cb, ctx, opts) \
-	perf_buffer__new(map_fd, page_cnt, sample_cb, lost_cb, ctx, opts)
-#define ___perf_buffer_new3(map_fd, page_cnt, opts) \
-	perf_buffer__new_deprecated(map_fd, page_cnt, opts)
-
 enum bpf_perf_event_ret {
 	LIBBPF_PERF_EVENT_DONE	= 0,
 	LIBBPF_PERF_EVENT_ERROR	= -1,
@@ -841,21 +800,12 @@ typedef enum bpf_perf_event_ret

 /* raw perf buffer options, giving most power and control */
 struct perf_buffer_raw_opts {
-	union {
-		struct {
-			size_t sz;
-			long :0;
-			long :0;
-		};
-		struct { /* DEPRECATED: will be removed in v1.0 */
-			/* perf event attrs passed directly into perf_event_open() */
-			struct perf_event_attr *attr;
-			/* raw event callback */
-			perf_buffer_event_fn event_cb;
-			/* ctx is provided to event_cb */
-			void *ctx;
-		};
-	};
+	/* perf event attrs passed directly into perf_event_open() */
+	struct perf_event_attr *attr;
+	/* raw event callback */
+	perf_buffer_event_fn event_cb;
+	/* ctx is provided to event_cb */
+	void *ctx;
 	/* if cpu_cnt == 0, open all on all possible CPUs (up to the number of
 	 * max_entries of given PERF_EVENT_ARRAY map)
 	 */
@@ -865,28 +815,11 @@ struct perf_buffer_raw_opts {
 	/* if cpu_cnt > 0, map_keys specify map keys to set per-CPU FDs for */
 	int *map_keys;
 };
-#define perf_buffer_raw_opts__last_field map_keys

 LIBBPF_API struct perf_buffer *
-perf_buffer__new_raw(int map_fd, size_t page_cnt, struct perf_event_attr *attr,
-		     perf_buffer_event_fn event_cb, void *ctx,
+perf_buffer__new_raw(int map_fd, size_t page_cnt,
 		     const struct perf_buffer_raw_opts *opts);

-LIBBPF_API struct perf_buffer *
-perf_buffer__new_raw_v0_6_0(int map_fd, size_t page_cnt, struct perf_event_attr *attr,
-			    perf_buffer_event_fn event_cb, void *ctx,
-			    const struct perf_buffer_raw_opts *opts);
-
-LIBBPF_API LIBBPF_DEPRECATED_SINCE(0, 7, "use new variant of perf_buffer__new_raw() instead")
-struct perf_buffer *perf_buffer__new_raw_deprecated(int map_fd, size_t page_cnt,
-						    const struct perf_buffer_raw_opts *opts);
-
-#define perf_buffer__new_raw(...) ___libbpf_overload(___perf_buffer_new_raw, __VA_ARGS__)
-#define ___perf_buffer_new_raw6(map_fd, page_cnt, attr, event_cb, ctx, opts) \
-	perf_buffer__new_raw(map_fd, page_cnt, attr, event_cb, ctx, opts)
-#define ___perf_buffer_new_raw3(map_fd, page_cnt, opts) \
-	perf_buffer__new_raw_deprecated(map_fd, page_cnt, opts)
-
 LIBBPF_API void perf_buffer__free(struct perf_buffer *pb);
 LIBBPF_API int perf_buffer__epoll_fd(const struct perf_buffer *pb);
 LIBBPF_API int perf_buffer__poll(struct perf_buffer *pb, int timeout_ms);
--- a/src/libbpf.map
+++ b/src/libbpf.map
@@ -391,31 +391,14 @@ LIBBPF_0.6.0 {
 	global:
 		bpf_map__map_extra;
 		bpf_map__set_map_extra;
-		bpf_map_create;
 		bpf_object__next_map;
 		bpf_object__next_program;
 		bpf_object__prev_map;
 		bpf_object__prev_program;
-		bpf_prog_load_deprecated;
-		bpf_prog_load;
-		bpf_program__flags;
 		bpf_program__insn_cnt;
 		bpf_program__insns;
-		bpf_program__set_flags;
 		btf__add_btf;
 		btf__add_decl_tag;
-		btf__add_type_tag;
-		btf__dedup;
-		btf__dedup_deprecated;
 		btf__raw_data;
 		btf__type_cnt;
-		btf_dump__new;
-		btf_dump__new_deprecated;
-		libbpf_major_version;
-		libbpf_minor_version;
-		libbpf_version_string;
-		perf_buffer__new;
-		perf_buffer__new_deprecated;
-		perf_buffer__new_raw;
-		perf_buffer__new_raw_deprecated;
 } LIBBPF_0.5.0;
--- a/src/libbpf_common.h
+++ b/src/libbpf_common.h
@@ -41,18 +41,6 @@
 #define __LIBBPF_MARK_DEPRECATED_0_7(X)
 #endif

-/* This set of internal macros allows to do "function overloading" based on
- * number of arguments provided by used in backwards-compatible way during the
- * transition to libbpf 1.0
- * It's ugly but necessary evil that will be cleaned up when we get to 1.0.
- * See bpf_prog_load() overload for example.
- */
-#define ___libbpf_cat(A, B) A ## B
-#define ___libbpf_select(NAME, NUM) ___libbpf_cat(NAME, NUM)
-#define ___libbpf_nth(_1, _2, _3, _4, _5, _6, N, ...) N
-#define ___libbpf_cnt(...) ___libbpf_nth(__VA_ARGS__, 6, 5, 4, 3, 2, 1)
-#define ___libbpf_overload(NAME, ...) ___libbpf_select(NAME, ___libbpf_cnt(__VA_ARGS__))(__VA_ARGS__)
-
 /* Helper macro to declare and initialize libbpf options struct
 *
 * This dance with uninitialized declaration, followed by memset to zero,
@@ -66,7 +54,7 @@
 * including any extra padding, it with memset() and then assigns initial
 * values provided by users in struct initializer-syntax as varargs.
 */
-#define LIBBPF_OPTS(TYPE, NAME, ...)					    \
+#define DECLARE_LIBBPF_OPTS(TYPE, NAME, ...)				    \
 	struct TYPE NAME = ({ 						    \
 		memset(&NAME, 0, sizeof(struct TYPE));			    \
 		(struct TYPE) {						    \
--- a/src/libbpf_internal.h
+++ b/src/libbpf_internal.h
@@ -73,8 +73,6 @@
 	BTF_TYPE_ENC(name, BTF_INFO_ENC(BTF_KIND_FLOAT, 0, 0), sz)
 #define BTF_TYPE_DECL_TAG_ENC(value, type, component_idx) \
 	BTF_TYPE_ENC(value, BTF_INFO_ENC(BTF_KIND_DECL_TAG, 0, 0), type), (component_idx)
-#define BTF_TYPE_TYPE_TAG_ENC(value, type) \
-	BTF_TYPE_ENC(value, BTF_INFO_ENC(BTF_KIND_TYPE_TAG, 0, 0), type)

 #ifndef likely
 #define likely(x) __builtin_expect(!!(x), 1)
@@ -278,6 +276,58 @@ int parse_cpu_mask_file(const char *fcpu, bool **mask, int *mask_sz);
 int libbpf__load_raw_btf(const char *raw_types, size_t types_len,
 			 const char *str_sec, size_t str_len);

+struct bpf_prog_load_params {
+	enum bpf_prog_type prog_type;
+	enum bpf_attach_type expected_attach_type;
+	const char *name;
+	const struct bpf_insn *insns;
+	size_t insn_cnt;
+	const char *license;
+	__u32 kern_version;
+	__u32 attach_prog_fd;
+	__u32 attach_btf_obj_fd;
+	__u32 attach_btf_id;
+	__u32 prog_ifindex;
+	__u32 prog_btf_fd;
+	__u32 prog_flags;
+
+	__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;
+	char *log_buf;
+	size_t log_buf_sz;
+	int *fd_array;
+};
+
+int libbpf__bpf_prog_load(const struct bpf_prog_load_params *load_attr);
+
+struct bpf_create_map_params {
+	const char *name;
+	enum bpf_map_type map_type;
+	__u32 map_flags;
+	__u32 key_size;
+	__u32 value_size;
+	__u32 max_entries;
+	__u32 numa_node;
+	__u32 btf_fd;
+	__u32 btf_key_type_id;
+	__u32 btf_value_type_id;
+	__u32 map_ifindex;
+	union {
+		__u32 inner_map_fd;
+		__u32 btf_vmlinux_value_type_id;
+	};
+	__u64 map_extra;
+};
+
+int libbpf__bpf_create_map_xattr(const struct bpf_create_map_params *create_attr);
+
 struct btf *btf_get_from_fd(int btf_fd, struct btf *base_btf);
 void btf_get_kernel_prefix_kind(enum bpf_attach_type attach_type,
 				const char **prefix, int *kind);
--- a/src/libbpf_legacy.h
+++ b/src/libbpf_legacy.h
@@ -69,7 +69,6 @@ enum libbpf_strict_mode {

 LIBBPF_API int libbpf_set_strict_mode(enum libbpf_strict_mode mode);

-#define DECLARE_LIBBPF_OPTS LIBBPF_OPTS

 #ifdef __cplusplus
 } /* extern "C" */
--- a/src/libbpf_probes.c
+++ b/src/libbpf_probes.c
@@ -68,21 +68,21 @@ static void
 probe_load(enum bpf_prog_type prog_type, const struct bpf_insn *insns,
 	   size_t insns_cnt, char *buf, size_t buf_len, __u32 ifindex)
 {
-	LIBBPF_OPTS(bpf_prog_load_opts, opts);
+	struct bpf_load_program_attr xattr = {};
 	int fd;

 	switch (prog_type) {
 	case BPF_PROG_TYPE_CGROUP_SOCK_ADDR:
-		opts.expected_attach_type = BPF_CGROUP_INET4_CONNECT;
+		xattr.expected_attach_type = BPF_CGROUP_INET4_CONNECT;
 		break;
 	case BPF_PROG_TYPE_CGROUP_SOCKOPT:
-		opts.expected_attach_type = BPF_CGROUP_GETSOCKOPT;
+		xattr.expected_attach_type = BPF_CGROUP_GETSOCKOPT;
 		break;
 	case BPF_PROG_TYPE_SK_LOOKUP:
-		opts.expected_attach_type = BPF_SK_LOOKUP;
+		xattr.expected_attach_type = BPF_SK_LOOKUP;
 		break;
 	case BPF_PROG_TYPE_KPROBE:
-		opts.kern_version = get_kernel_version();
+		xattr.kern_version = get_kernel_version();
 		break;
 	case BPF_PROG_TYPE_UNSPEC:
 	case BPF_PROG_TYPE_SOCKET_FILTER:
@@ -115,11 +115,13 @@ probe_load(enum bpf_prog_type prog_type, const struct bpf_insn *insns,
 		break;
 	}

-	opts.prog_ifindex = ifindex;
-	opts.log_buf = buf;
-	opts.log_size = buf_len;
+	xattr.prog_type = prog_type;
+	xattr.insns = insns;
+	xattr.insns_cnt = insns_cnt;
+	xattr.license = "GPL";
+	xattr.prog_ifindex = ifindex;

-	fd = bpf_prog_load(prog_type, NULL, "GPL", insns, insns_cnt, NULL);
+	fd = bpf_load_program_xattr(&xattr, buf, buf_len);
 	if (fd >= 0)
 		close(fd);
 }
@@ -201,6 +203,7 @@ bool bpf_probe_map_type(enum bpf_map_type map_type, __u32 ifindex)
 {
 	int key_size, value_size, max_entries, map_flags;
 	__u32 btf_key_type_id = 0, btf_value_type_id = 0;
+	struct bpf_create_map_attr attr = {};
 	int fd = -1, btf_fd = -1, fd_inner;

 	key_size	= sizeof(__u32);
@@ -270,35 +273,34 @@ bool bpf_probe_map_type(enum bpf_map_type map_type, __u32 ifindex)

 	if (map_type == BPF_MAP_TYPE_ARRAY_OF_MAPS ||
 	    map_type == BPF_MAP_TYPE_HASH_OF_MAPS) {
-		LIBBPF_OPTS(bpf_map_create_opts, opts);
-
 		/* TODO: probe for device, once libbpf has a function to create
 		 * map-in-map for offload
 		 */
 		if (ifindex)
 			return false;

-		fd_inner = bpf_map_create(BPF_MAP_TYPE_HASH, NULL,
-					  sizeof(__u32), sizeof(__u32), 1, NULL);
+		fd_inner = bpf_create_map(BPF_MAP_TYPE_HASH,
+					  sizeof(__u32), sizeof(__u32), 1, 0);
 		if (fd_inner < 0)
 			return false;
-
-		opts.inner_map_fd = fd_inner;
-		fd = bpf_map_create(map_type, NULL, sizeof(__u32), sizeof(__u32), 1, &opts);
+		fd = bpf_create_map_in_map(map_type, NULL, sizeof(__u32),
+					   fd_inner, 1, 0);
 		close(fd_inner);
 	} else {
-		LIBBPF_OPTS(bpf_map_create_opts, opts);
-
 		/* Note: No other restriction on map type probes for offload */
-		opts.map_flags = map_flags;
-		opts.map_ifindex = ifindex;
+		attr.map_type = map_type;
+		attr.key_size = key_size;
+		attr.value_size = value_size;
+		attr.max_entries = max_entries;
+		attr.map_flags = map_flags;
+		attr.map_ifindex = ifindex;
 		if (btf_fd >= 0) {
-			opts.btf_fd = btf_fd;
-			opts.btf_key_type_id = btf_key_type_id;
-			opts.btf_value_type_id = btf_value_type_id;
+			attr.btf_fd = btf_fd;
+			attr.btf_key_type_id = btf_key_type_id;
+			attr.btf_value_type_id = btf_value_type_id;
 		}

-		fd = bpf_map_create(map_type, NULL, key_size, value_size, max_entries, &opts);
+		fd = bpf_create_map_xattr(&attr);
 	}
 	if (fd >= 0)
 		close(fd);
--- a/src/linker.c
+++ b/src/linker.c
@@ -210,7 +210,6 @@ void bpf_linker__free(struct bpf_linker *linker)
 	}
 	free(linker->secs);

-	free(linker->glob_syms);
 	free(linker);
 }

@@ -2000,7 +1999,7 @@ add_sym:
 static int linker_append_elf_relos(struct bpf_linker *linker, struct src_obj *obj)
 {
 	struct src_sec *src_symtab = &obj->secs[obj->symtab_sec_idx];
-	struct dst_sec *dst_symtab;
+	struct dst_sec *dst_symtab = &linker->secs[linker->symtab_sec_idx];
 	int i, err;

 	for (i = 1; i < obj->sec_cnt; i++) {
@@ -2033,9 +2032,6 @@ static int linker_append_elf_relos(struct bpf_linker *linker, struct src_obj *ob
 			return -1;
 		}

-		/* add_dst_sec() above could have invalidated linker->secs */
-		dst_symtab = &linker->secs[linker->symtab_sec_idx];
-
 		/* shdr->sh_link points to SYMTAB */
 		dst_sec->shdr->sh_link = linker->symtab_sec_idx;

@@ -2654,7 +2650,6 @@ static int emit_elf_data_sec(struct bpf_linker *linker, const char *sec_name,

 static int finalize_btf(struct bpf_linker *linker)
 {
-	LIBBPF_OPTS(btf_dedup_opts, opts);
 	struct btf *btf = linker->btf;
 	const void *raw_data;
 	int i, j, id, err;
@@ -2691,8 +2686,7 @@ static int finalize_btf(struct bpf_linker *linker)
 		return err;
 	}

-	opts.btf_ext = linker->btf_ext;
-	err = btf__dedup(linker->btf, &opts);
+	err = btf__dedup(linker->btf, linker->btf_ext, NULL);
 	if (err) {
 		pr_warn("BTF dedup failed: %d\n", err);
 		return err;
--- a/src/skel_internal.h
+++ b/src/skel_internal.h
@@ -7,16 +7,6 @@
 #include <sys/syscall.h>
 #include <sys/mman.h>

-#ifndef __NR_bpf
-# if defined(__mips__) && defined(_ABIO32)
-#  define __NR_bpf 4355
-# elif defined(__mips__) && defined(_ABIN32)
-#  define __NR_bpf 6319
-# elif defined(__mips__) && defined(_ABI64)
-#  define __NR_bpf 5315
-# endif
-#endif
-
 /* This file is a base header for auto-generated *.lskel.h files.
 * Its contents will change and may become part of auto-generation in the future.
 *
@@ -75,7 +65,8 @@ static inline int bpf_load_and_run(struct bpf_load_and_run_opts *opts)
 	int map_fd = -1, prog_fd = -1, key = 0, err;
 	union bpf_attr attr;

-	map_fd = bpf_map_create(BPF_MAP_TYPE_ARRAY, "__loader.map", 4, opts->data_sz, 1, NULL);
+	map_fd = bpf_create_map_name(BPF_MAP_TYPE_ARRAY, "__loader.map", 4,
+				     opts->data_sz, 1, 0);
 	if (map_fd < 0) {
 		opts->errstr = "failed to create loader map";
 		err = -errno;
--- a/src/xsk.c
+++ b/src/xsk.c
@@ -35,11 +35,6 @@
 #include "libbpf_internal.h"
 #include "xsk.h"

-/* entire xsk.h and xsk.c is going away in libbpf 1.0, so ignore all internal
- * uses of deprecated APIs
- */
-#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
-
 #ifndef SOL_XDP
 #define SOL_XDP 283
 #endif
@@ -369,6 +364,8 @@ int xsk_umem__create_v0_0_2(struct xsk_umem **umem_ptr, void *umem_area,
 static enum xsk_prog get_xsk_prog(void)
 {
 	enum xsk_prog detected = XSK_PROG_FALLBACK;
+	struct bpf_load_program_attr prog_attr;
+	struct bpf_create_map_attr map_attr;
 	__u32 size_out, retval, duration;
 	char data_in = 0, data_out;
 	struct bpf_insn insns[] = {
@@ -378,15 +375,27 @@ static enum xsk_prog get_xsk_prog(void)
 		BPF_EMIT_CALL(BPF_FUNC_redirect_map),
 		BPF_EXIT_INSN(),
 	};
-	int prog_fd, map_fd, ret, insn_cnt = ARRAY_SIZE(insns);
+	int prog_fd, map_fd, ret;

-	map_fd = bpf_map_create(BPF_MAP_TYPE_XSKMAP, NULL, sizeof(int), sizeof(int), 1, NULL);
+	memset(&map_attr, 0, sizeof(map_attr));
+	map_attr.map_type = BPF_MAP_TYPE_XSKMAP;
+	map_attr.key_size = sizeof(int);
+	map_attr.value_size = sizeof(int);
+	map_attr.max_entries = 1;
+
+	map_fd = bpf_create_map_xattr(&map_attr);
 	if (map_fd < 0)
 		return detected;

 	insns[0].imm = map_fd;

-	prog_fd = bpf_prog_load(BPF_PROG_TYPE_XDP, NULL, "GPL", insns, insn_cnt, NULL);
+	memset(&prog_attr, 0, sizeof(prog_attr));
+	prog_attr.prog_type = BPF_PROG_TYPE_XDP;
+	prog_attr.insns = insns;
+	prog_attr.insns_cnt = ARRAY_SIZE(insns);
+	prog_attr.license = "GPL";
+
+	prog_fd = bpf_load_program_xattr(&prog_attr, NULL, 0);
 	if (prog_fd < 0) {
 		close(map_fd);
 		return detected;
@@ -486,13 +495,10 @@ static int xsk_load_xdp_prog(struct xsk_socket *xsk)
 	};
 	struct bpf_insn *progs[] = {prog, prog_redirect_flags};
 	enum xsk_prog option = get_xsk_prog();
-	LIBBPF_OPTS(bpf_prog_load_opts, opts,
-		.log_buf = log_buf,
-		.log_size = log_buf_size,
-	);

-	prog_fd = bpf_prog_load(BPF_PROG_TYPE_XDP, NULL, "LGPL-2.1 or BSD-2-Clause",
-				progs[option], insns_cnt[option], &opts);
+	prog_fd = bpf_load_program(BPF_PROG_TYPE_XDP, progs[option], insns_cnt[option],
+				   "LGPL-2.1 or BSD-2-Clause", 0, log_buf,
+				   log_buf_size);
 	if (prog_fd < 0) {
 		pr_warn("BPF log buffer:\n%s", log_buf);
 		return prog_fd;
@@ -584,8 +590,8 @@ static int xsk_create_bpf_maps(struct xsk_socket *xsk)
 	if (max_queues < 0)
 		return max_queues;

-	fd = bpf_map_create(BPF_MAP_TYPE_XSKMAP, "xsks_map",
-			    sizeof(int), sizeof(int), max_queues, NULL);
+	fd = bpf_create_map_name(BPF_MAP_TYPE_XSKMAP, "xsks_map",
+				 sizeof(int), sizeof(int), max_queues, 0);
 	if (fd < 0)
 		return fd;

@@ -719,12 +725,14 @@ static int xsk_link_lookup(int ifindex, __u32 *prog_id, int *link_fd)

 static bool xsk_probe_bpf_link(void)
 {
-	LIBBPF_OPTS(bpf_link_create_opts, opts, .flags = XDP_FLAGS_SKB_MODE);
+	DECLARE_LIBBPF_OPTS(bpf_link_create_opts, opts,
+			    .flags = XDP_FLAGS_SKB_MODE);
+	struct bpf_load_program_attr prog_attr;
 	struct bpf_insn insns[2] = {
 		BPF_MOV64_IMM(BPF_REG_0, XDP_PASS),
 		BPF_EXIT_INSN()
 	};
-	int prog_fd, link_fd = -1, insn_cnt = ARRAY_SIZE(insns);
+	int prog_fd, link_fd = -1;
 	int ifindex_lo = 1;
 	bool ret = false;
 	int err;
@@ -736,7 +744,13 @@ static bool xsk_probe_bpf_link(void)
 	if (link_fd >= 0)
 		return true;

-	prog_fd = bpf_prog_load(BPF_PROG_TYPE_XDP, NULL, "GPL", insns, insn_cnt, NULL);
+	memset(&prog_attr, 0, sizeof(prog_attr));
+	prog_attr.prog_type = BPF_PROG_TYPE_XDP;
+	prog_attr.insns = insns;
+	prog_attr.insns_cnt = ARRAY_SIZE(insns);
+	prog_attr.license = "GPL";
+
+	prog_fd = bpf_load_program_xattr(&prog_attr, NULL, 0);
 	if (prog_fd < 0)
 		return ret;

--- a/travis-ci/vmtest/build_selftests.sh
+++ b/travis-ci/vmtest/build_selftests.sh
@@ -6,7 +6,7 @@ source $(cd $(dirname $0) && pwd)/helpers.sh

 travis_fold start prepare_selftests "Building selftests"

-sudo apt-get -y install python3-docutils # for rst2man
+sudo apt-get -y install python-docutils # for rst2man

 LLVM_VER=14
 LIBBPF_PATH="${REPO_ROOT}"
@@ -37,6 +37,6 @@ cd ${LIBBPF_PATH}
 rm selftests/bpf/.gitignore
 git add selftests

-git add "${VMTEST_ROOT}"/configs/blacklist/BLACKLIST-* "${VMTEST_ROOT}"/configs/whitelist/WHITELIST-*
+git add "${VMTEST_ROOT}/configs/blacklist"

 travis_fold end prepare_selftests
--- a/travis-ci/vmtest/configs/INDEX
+++ b/travis-ci/vmtest/configs/INDEX
@@ -1,9 +1,8 @@
 INDEX	https://libbpf-vmtest.s3-us-west-1.amazonaws.com/x86_64/INDEX
-x86_64/libbpf-vmtest-rootfs-2020.09.27.tar.zst	https://libbpf-vmtest.s3-us-west-1.amazonaws.com/x86_64/libbpf-vmtest-rootfs-2020.09.27.tar.zst
-x86_64/vmlinux-4.9.0.zst	https://libbpf-vmtest.s3-us-west-1.amazonaws.com/x86_64/vmlinux-4.9.0.zst
-x86_64/vmlinux-5.5.0-rc6.zst	https://libbpf-vmtest.s3-us-west-1.amazonaws.com/x86_64/vmlinux-5.5.0-rc6.zst
-x86_64/vmlinux-5.5.0.zst	https://libbpf-vmtest.s3-us-west-1.amazonaws.com/x86_64/vmlinux-5.5.0.zst
-x86_64/vmlinuz-5.5.0-rc6	https://libbpf-vmtest.s3-us-west-1.amazonaws.com/x86_64/vmlinuz-5.5.0-rc6
-x86_64/vmlinuz-5.5.0	https://libbpf-vmtest.s3-us-west-1.amazonaws.com/x86_64/vmlinuz-5.5.0
-x86_64/vmlinuz-4.9.0	https://libbpf-vmtest.s3-us-west-1.amazonaws.com/x86_64/vmlinuz-4.9.0
-s390x/libbpf-vmtest-rootfs-2021.03.24.tar.zst	https://libbpf-vmtest.s3-us-west-1.amazonaws.com/s390x/libbpf-vmtest-rootfs-2021.03.24.tar.zst
+libbpf-vmtest-rootfs-2020.09.27.tar.zst	https://libbpf-vmtest.s3-us-west-1.amazonaws.com/x86_64/libbpf-vmtest-rootfs-2020.09.27.tar.zst
+vmlinux-4.9.0.zst	https://libbpf-vmtest.s3-us-west-1.amazonaws.com/x86_64/vmlinux-4.9.0.zst
+vmlinux-5.5.0-rc6.zst	https://libbpf-vmtest.s3-us-west-1.amazonaws.com/x86_64/vmlinux-5.5.0-rc6.zst
+vmlinux-5.5.0.zst	https://libbpf-vmtest.s3-us-west-1.amazonaws.com/x86_64/vmlinux-5.5.0.zst
+vmlinuz-5.5.0-rc6	https://libbpf-vmtest.s3-us-west-1.amazonaws.com/x86_64/vmlinuz-5.5.0-rc6
+vmlinuz-5.5.0	https://libbpf-vmtest.s3-us-west-1.amazonaws.com/x86_64/vmlinuz-5.5.0
+vmlinuz-4.9.0	https://libbpf-vmtest.s3-us-west-1.amazonaws.com/x86_64/vmlinuz-4.9.0
--- a/travis-ci/vmtest/configs/blacklist/BLACKLIST-5.5.0
+++ b/travis-ci/vmtest/configs/blacklist/BLACKLIST-5.5.0
@@ -1,6 +1,3 @@
-# This file is not used and is there for historic purposes only.
-# See WHITELIST-5.5.0 instead.
-
 # PERMANENTLY DISABLED
 align			# verifier output format changed
 atomics			# new atomic operations (v5.12+)
--- a/travis-ci/vmtest/configs/blacklist/BLACKLIST-latest.s390x
+++ b/travis-ci/vmtest/configs/blacklist/BLACKLIST-latest.s390x
@@ -1,52 +0,0 @@
-# TEMPORARY
-atomics                                  # attach(add): actual -524 <= expected 0                                      (trampoline)
-bpf_iter_setsockopt                      # JIT does not support calling kernel function                                (kfunc)
-bloom_filter_map                         # failed to find kernel BTF type ID of '__x64_sys_getpgid': -3                (?)
-bpf_tcp_ca                               # JIT does not support calling kernel function                                (kfunc)
-core_read_macros                         # unknown func bpf_probe_read#4                                               (overlapping)
-d_path                                   # failed to auto-attach program 'prog_stat': -524                             (trampoline)
-dummy_st_ops                             # test_run unexpected error: -524 (errno 524)                                 (trampoline)
-fentry_fexit                             # fentry attach failed: -524                                                  (trampoline)
-fentry_test                              # fentry_first_attach unexpected error: -524                                  (trampoline)
-fexit_bpf2bpf                            # freplace_attach_trace unexpected error: -524                                (trampoline)
-fexit_sleep                              # fexit_skel_load fexit skeleton failed                                       (trampoline)
-fexit_stress                             # fexit attach failed prog 0 failed: -524                                     (trampoline)
-fexit_test                               # fexit_first_attach unexpected error: -524                                   (trampoline)
-get_func_ip_test                         # get_func_ip_test__attach unexpected error: -524                             (trampoline)
-get_stack_raw_tp                         # user_stack corrupted user stack                                             (no backchain userspace)
-kfree_skb                                # attach fentry unexpected error: -524                                        (trampoline)
-kfunc_call                               # 'bpf_prog_active': not found in kernel BTF                                  (?)
-ksyms_module                             # test_ksyms_module__open_and_load unexpected error: -9                       (?)
-ksyms_module_libbpf                      # JIT does not support calling kernel function                                (kfunc)
-ksyms_module_lskel                       # test_ksyms_module_lskel__open_and_load unexpected error: -9                 (?)
-modify_return                            # modify_return attach failed: -524                                           (trampoline)
-module_attach                            # skel_attach skeleton attach failed: -524                                    (trampoline)
-netcnt                                   # failed to load BPF skeleton 'netcnt_prog': -7                               (?)
-probe_user                               # check_kprobe_res wrong kprobe res from probe read                           (?)
-recursion                                # skel_attach unexpected error: -524                                          (trampoline)
-ringbuf                                  # skel_load skeleton load failed                                              (?)
-sk_assign                                # Can't read on server: Invalid argument                                      (?)
-sk_storage_tracing                       # test_sk_storage_tracing__attach unexpected error: -524                      (trampoline)
-skc_to_unix_sock                         # could not attach BPF object unexpected error: -524                          (trampoline)
-socket_cookie                            # prog_attach unexpected error: -524                                          (trampoline)
-stacktrace_build_id                      # compare_map_keys stackid_hmap vs. stackmap err -2 errno 2                   (?)
-tailcalls                                # tail_calls are not allowed in non-JITed programs with bpf-to-bpf calls      (?)
-task_local_storage                       # failed to auto-attach program 'trace_exit_creds': -524                      (trampoline)
-test_bpffs                               # bpffs test  failed 255                                                      (iterator)
-test_bprm_opts                           # failed to auto-attach program 'secure_exec': -524                           (trampoline)
-test_ima                                 # failed to auto-attach program 'ima': -524                                   (trampoline)
-test_local_storage                       # failed to auto-attach program 'unlink_hook': -524                           (trampoline)
-test_lsm                                 # failed to find kernel BTF type ID of '__x64_sys_setdomainname': -3          (?)
-test_overhead                            # attach_fentry unexpected error: -524                                        (trampoline)
-test_profiler                            # unknown func bpf_probe_read_str#45                                          (overlapping)
-timer                                    # failed to auto-attach program 'test1': -524                                 (trampoline)
-timer_mim                                # failed to auto-attach program 'test1': -524                                 (trampoline)
-trace_ext                                # failed to auto-attach program 'test_pkt_md_access_new': -524                (trampoline)
-trace_printk                             # trace_printk__load unexpected error: -2 (errno 2)                           (?)
-trace_vprintk                            # trace_vprintk__open_and_load unexpected error: -9                           (?)
-trampoline_count                         # prog 'prog1': failed to attach: ERROR: strerror_r(-524)=22                  (trampoline)
-verif_stats                              # trace_vprintk__open_and_load unexpected error: -9                           (?)
-vmlinux                                  # failed to auto-attach program 'handle__fentry': -524                        (trampoline)
-xdp_adjust_tail                          # case-128 err 0 errno 28 retval 1 size 128 expect-size 3520                  (?)
-xdp_bonding                              # failed to auto-attach program 'trace_on_entry': -524                        (trampoline)
-xdp_bpf2bpf                              # failed to auto-attach program 'trace_on_entry': -524                        (trampoline)
--- a/travis-ci/vmtest/configs/config-latest.s390x
+++ b/travis-ci/vmtest/configs/config-latest.s390x
--- a/travis-ci/vmtest/configs/config-latest.x86_64
+++ b/travis-ci/vmtest/configs/config-latest.x86_64
--- a/travis-ci/vmtest/configs/whitelist/WHITELIST-4.9.0
+++ b/travis-ci/vmtest/configs/whitelist/WHITELIST-4.9.0
@@ -2,7 +2,6 @@
 core_retro
 cpu_mask
 hashmap
-legacy_printk
 perf_buffer
 section_names

--- a/travis-ci/vmtest/configs/whitelist/WHITELIST-5.5.0
+++ b/travis-ci/vmtest/configs/whitelist/WHITELIST-5.5.0
@@ -18,7 +18,6 @@ global_data_init
 global_func_args
 hashmap
 l4lb_all
-legacy_printk
 linked_funcs
 linked_maps
 map_lock
--- a/travis-ci/vmtest/helpers.sh
+++ b/travis-ci/vmtest/helpers.sh
@@ -22,25 +22,3 @@ travis_fold() {
    echo -e "$line"
  fi
 }
-
-ARCH=$(uname -m)
-
-__print() {
-  local TITLE=""
-  if [[ -n $2 ]]; then
-      TITLE=" title=$2"
-  fi
-  echo "::$1${TITLE}::$3"
-}
-
-# $1 - title
-# $2 - message
-print_error() {
-  __print error $1 $2
-}
-
-# $1 - title
-# $2 - message
-print_notice() {
-  __print notice $1 $2
-}
--- a/travis-ci/vmtest/mkrootfs_arch.sh
+++ b/travis-ci/vmtest/mkrootfs_arch.sh
@@ -100,7 +100,59 @@ rm -rf "$root/var/lib/pacman/sync/"
 # We don't need any documentation.
 rm -rf "$root/usr/share/{doc,help,man,texinfo}"

-"$(dirname "$0")"/mkrootfs_tweak.sh "$root"
+chroot "${root}" /bin/busybox --install

+cat > "$root/etc/inittab" << "EOF"
+::sysinit:/etc/init.d/rcS
+::ctrlaltdel:/sbin/reboot
+::shutdown:/sbin/swapoff -a
+::shutdown:/bin/umount -a -r
+::restart:/sbin/init
+EOF
+chmod 644 "$root/etc/inittab"
+
+mkdir -m 755 "$root/etc/init.d" "$root/etc/rcS.d"
+cat > "$root/etc/rcS.d/S10-mount" << "EOF"
+#!/bin/sh
+
+set -eux
+
+/bin/mount proc /proc -t proc
+
+# Mount devtmpfs if not mounted
+if [[ -z $(/bin/mount -l -t devtmpfs) ]]; then
+	/bin/mount devtmpfs /dev -t devtmpfs
+fi
+
+/bin/mount sysfs /sys -t sysfs
+/bin/mount bpffs /sys/fs/bpf -t bpf
+/bin/mount debugfs /sys/kernel/debug -t debugfs
+
+echo 'Listing currently mounted file systems'
+/bin/mount
+EOF
+chmod 755 "$root/etc/rcS.d/S10-mount"
+
+cat > "$root/etc/rcS.d/S40-network" << "EOF"
+#!/bin/sh
+
+set -eux
+
+ip link set lo up
+EOF
+chmod 755 "$root/etc/rcS.d/S40-network"
+
+cat > "$root/etc/init.d/rcS" << "EOF"
+#!/bin/sh
+
+set -eux
+
+for path in /etc/rcS.d/S*; do
+	[ -x "$path" ] && "$path"
+done
+EOF
+chmod 755 "$root/etc/init.d/rcS"
+
+chmod 755 "$root"
 tar -C "$root" -c . | zstd -T0 -19 -o "$NAME"
 chmod 644 "$NAME"
--- a/travis-ci/vmtest/mkrootfs_debian.sh
+++ b/travis-ci/vmtest/mkrootfs_debian.sh
@@ -1,40 +0,0 @@
-#!/bin/bash
-# This script builds a Debian root filesystem image for testing libbpf in a
-# virtual machine. Requires debootstrap >= 1.0.95 and zstd.
-
-set -e -u -x -o pipefail
-
-# Check whether we are root now in order to avoid confusing errors later.
-if [ "$(id -u)" != 0 ]; then
-	echo "$0 must run as root" >&2
-	exit 1
-fi
-
-# Create a working directory and schedule its deletion.
-root=$(mktemp -d -p "$PWD")
-trap 'rm -r "$root"' EXIT
-
-# Install packages.
-packages=binutils,busybox,elfutils,iproute2,libcap2,libelf1,strace,zlib1g
-debootstrap --include="$packages" --variant=minbase bullseye "$root"
-
-# Remove the init scripts (tests use their own). Also remove various
-# unnecessary files in order to save space.
-rm -rf \
-	"$root"/etc/rcS.d \
-	"$root"/usr/share/{doc,info,locale,man,zoneinfo} \
-	"$root"/var/cache/apt/archives/* \
-	"$root"/var/lib/apt/lists/*
-
-# Save some more space by removing coreutils - the tests use busybox. Before
-# doing that, delete the buggy postrm script, which uses the rm command.
-rm -f "$root/var/lib/dpkg/info/coreutils.postrm"
-chroot "$root" dpkg --remove --force-remove-essential coreutils
-
-# Apply common tweaks.
-"$(dirname "$0")"/mkrootfs_tweak.sh "$root"
-
-# Save the result.
-name="libbpf-vmtest-rootfs-$(date +%Y.%m.%d).tar.zst"
-rm -f "$name"
-tar -C "$root" -c . | zstd -T0 -19 -o "$name"
--- a/travis-ci/vmtest/mkrootfs_tweak.sh
+++ b/travis-ci/vmtest/mkrootfs_tweak.sh
@@ -1,61 +0,0 @@
-#!/bin/bash
-# This script prepares a mounted root filesystem for testing libbpf in a virtual
-# machine.
-set -e -u -x -o pipefail
-root=$1
-shift
-
-chroot "${root}" /bin/busybox --install
-
-cat > "$root/etc/inittab" << "EOF"
-::sysinit:/etc/init.d/rcS
-::ctrlaltdel:/sbin/reboot
-::shutdown:/sbin/swapoff -a
-::shutdown:/bin/umount -a -r
-::restart:/sbin/init
-EOF
-chmod 644 "$root/etc/inittab"
-
-mkdir -m 755 -p "$root/etc/init.d" "$root/etc/rcS.d"
-cat > "$root/etc/rcS.d/S10-mount" << "EOF"
-#!/bin/sh
-
-set -eux
-
-/bin/mount proc /proc -t proc
-
-# Mount devtmpfs if not mounted
-if [[ -z $(/bin/mount -l -t devtmpfs) ]]; then
-	/bin/mount devtmpfs /dev -t devtmpfs
-fi
-
-/bin/mount sysfs /sys -t sysfs
-/bin/mount bpffs /sys/fs/bpf -t bpf
-/bin/mount debugfs /sys/kernel/debug -t debugfs
-
-echo 'Listing currently mounted file systems'
-/bin/mount
-EOF
-chmod 755 "$root/etc/rcS.d/S10-mount"
-
-cat > "$root/etc/rcS.d/S40-network" << "EOF"
-#!/bin/sh
-
-set -eux
-
-ip link set lo up
-EOF
-chmod 755 "$root/etc/rcS.d/S40-network"
-
-cat > "$root/etc/init.d/rcS" << "EOF"
-#!/bin/sh
-
-set -eux
-
-for path in /etc/rcS.d/S*; do
-	[ -x "$path" ] && "$path"
-done
-EOF
-chmod 755 "$root/etc/init.d/rcS"
-
-chmod 755 "$root"
--- a/travis-ci/vmtest/prepare_selftests.sh
+++ b/travis-ci/vmtest/prepare_selftests.sh
@@ -14,7 +14,7 @@ fi
 if [[ "${KERNEL}" = 'LATEST' ]]; then
 	travis_fold start build_kernel "Kernel build"

-	cp "$VMTEST_ROOT"/configs/config-latest."$ARCH" .config
+	cp ${VMTEST_ROOT}/configs/latest.config .config
 	make -j $((4*$(nproc))) olddefconfig all >/dev/null
 	travis_fold end build_kernel
 fi
--- a/travis-ci/vmtest/run.sh
+++ b/travis-ci/vmtest/run.sh
@@ -15,7 +15,7 @@ Run "${PROJECT_NAME}" tests in a virtual machine.
 This exits with status 0 on success, 1 if the virtual machine ran successfully
 but tests failed, and 2 if we encountered a fatal error.

-This script uses sudo to work around a libguestfs bug.
+This script uses sudo to mount and modify the disk image.

 Arguments:
  IMG                 path of virtual machine disk image to create
@@ -177,11 +177,6 @@ else
 	fi
 	IMG="${!OPTIND}"
 fi
-if [[ "${SOURCE_FULLCOPY}" == "1" ]]; then
-	img_size=2G
-else
-	img_size=8G
-fi

 unset URLS
 cache_urls() {
@@ -199,7 +194,7 @@ matching_kernel_releases() {
 	local pattern="$1"
 	{
 	for file in "${!URLS[@]}"; do
-		if [[ $file =~ ^${ARCH}/vmlinux-(.*).zst$ ]]; then
+		if [[ $file =~ ^vmlinux-(.*).zst$ ]]; then
 			release="${BASH_REMATCH[1]}"
 			case "$release" in
 				$pattern)
@@ -216,7 +211,7 @@ matching_kernel_releases() {
 newest_rootfs_version() {
 	{
 	for file in "${!URLS[@]}"; do
-		if [[ $file =~ ^${ARCH}/${PROJECT_NAME}-vmtest-rootfs-(.*)\.tar\.zst$ ]]; then
+		if [[ $file =~ ^${PROJECT_NAME}-vmtest-rootfs-(.*)\.tar\.zst$ ]]; then
 			echo "${BASH_REMATCH[1]}"
 		fi
 	done
@@ -247,29 +242,15 @@ cp_img() {
 create_rootfs_img() {
 	local path="$1"
 	set_nocow "$path"
-	truncate -s "$img_size" "$path"
+	truncate -s 2G "$path"
 	mkfs.ext4 -q "$path"
 }

 download_rootfs() {
 	local rootfsversion="$1"
-	download "${ARCH}/${PROJECT_NAME}-vmtest-rootfs-$rootfsversion.tar.zst" |
-		zstd -d
-}
-
-tar_in() {
-	local dst_path="$1"
-	# guestfish --remote does not forward file descriptors, which prevents
-	# us from using `tar-in -` or bash process substitution. We don't want
-	# to copy all the data into a temporary file, so use a FIFO.
-	tmp=$(mktemp -d)
-	mkfifo "$tmp/fifo"
-	cat >"$tmp/fifo" &
-	local cat_pid=$!
-	guestfish --remote tar-in "$tmp/fifo" "$dst_path"
-	wait "$cat_pid"
-	rm -r "$tmp"
-	tmp=
+	local dir="$2"
+	download "${PROJECT_NAME}-vmtest-rootfs-$rootfsversion.tar.zst" |
+		zstd -d | sudo tar -C "$dir" -x
 }

 if (( LIST )); then
@@ -301,11 +282,11 @@ if [[ $SKIPIMG -eq 0 && ! -v ROOTFSVERSION ]]; then
 	ROOTFSVERSION="$(newest_rootfs_version)"
 fi

-travis_fold start vmlinux_setup "Preparing Linux image"
-
 echo "Kernel release: $KERNELRELEASE" >&2
 echo

+travis_fold start vmlinux_setup "Preparing Linux image"
+
 if (( SKIPIMG )); then
 	echo "Not extracting root filesystem" >&2
 else
@@ -314,14 +295,20 @@ fi
 echo "Disk image: $IMG" >&2

 tmp=
-ARCH_DIR="$DIR/$ARCH"
+ARCH_DIR="$DIR/x86_64"
 mkdir -p "$ARCH_DIR"
+mnt="$(mktemp -d -p "$DIR" mnt.XXXXXXXXXX)"

 cleanup() {
 	if [[ -n $tmp ]]; then
-		rm -rf "$tmp" || true
+		rm -f "$tmp" || true
+	fi
+	if mountpoint -q "$mnt"; then
+		sudo umount "$mnt" || true
+	fi
+	if [[ -d "$mnt" ]]; then
+		rmdir "$mnt" || true
 	fi
-	guestfish --remote exit 2>/dev/null || true
 }
 trap cleanup EXIT

@@ -331,25 +318,18 @@ else
 	vmlinuz="${ARCH_DIR}/vmlinuz-${KERNELRELEASE}"
 	if [[ ! -e $vmlinuz ]]; then
 		tmp="$(mktemp "$vmlinuz.XXX.part")"
-		download "${ARCH}/vmlinuz-${KERNELRELEASE}" -o "$tmp"
+		download "vmlinuz-${KERNELRELEASE}" -o "$tmp"
 		mv "$tmp" "$vmlinuz"
 		tmp=
 	fi
 fi

-# Mount and set up the rootfs image. Use a persistent guestfish session in
-# order to avoid the startup overhead.
-# Work around https://bugs.launchpad.net/fuel/+bug/1467579.
-sudo chmod +r /boot/vmlinuz*
-eval "$(guestfish --listen)"
+# Mount and set up the rootfs image.
 if (( ONESHOT )); then
 	rm -f "$IMG"
 	create_rootfs_img "$IMG"
-	guestfish --remote \
-		add "$IMG" label:img : \
-		launch : \
-		mount /dev/disk/guestfs/img /
-	download_rootfs "$ROOTFSVERSION" | tar_in /
+	sudo mount -o loop "$IMG" "$mnt"
+	download_rootfs "$ROOTFSVERSION" "$mnt"
 else
 	if (( ! SKIPIMG )); then
 		rootfs_img="${ARCH_DIR}/${PROJECT_NAME}-vmtest-rootfs-${ROOTFSVERSION}.img"
@@ -357,15 +337,13 @@ else
 		if [[ ! -e $rootfs_img ]]; then
 			tmp="$(mktemp "$rootfs_img.XXX.part")"
 			set_nocow "$tmp"
-			truncate -s "$img_size" "$tmp"
+			truncate -s 2G "$tmp"
 			mkfs.ext4 -q "$tmp"
+			sudo mount -o loop "$tmp" "$mnt"

-			# libguestfs supports hotplugging only with a libvirt
-			# backend, which we are not using here, so handle the
-			# temporary image in a separate session.
-			download_rootfs "$ROOTFSVERSION" |
-				guestfish -a "$tmp" tar-in - /
+			download_rootfs "$ROOTFSVERSION" "$mnt"

+			sudo umount "$mnt"
 			mv "$tmp" "$rootfs_img"
 			tmp=
 		fi
@@ -373,14 +351,11 @@ else
 		rm -f "$IMG"
 		cp_img "$rootfs_img" "$IMG"
 	fi
-	guestfish --remote \
-		add "$IMG" label:img : \
-		launch : \
-		mount /dev/disk/guestfs/img /
+	sudo mount -o loop "$IMG" "$mnt"
 fi

 # Install vmlinux.
-vmlinux="/boot/vmlinux-${KERNELRELEASE}"
+vmlinux="$mnt/boot/vmlinux-${KERNELRELEASE}"
 if [[ -v BUILDDIR || $ONESHOT -eq 0 ]]; then
 	if [[ -v BUILDDIR ]]; then
 		source_vmlinux="${BUILDDIR}/vmlinux"
@@ -388,19 +363,20 @@ if [[ -v BUILDDIR || $ONESHOT -eq 0 ]]; then
 		source_vmlinux="${ARCH_DIR}/vmlinux-${KERNELRELEASE}"
 		if [[ ! -e $source_vmlinux ]]; then
 			tmp="$(mktemp "$source_vmlinux.XXX.part")"
-			download "${ARCH}/vmlinux-${KERNELRELEASE}.zst" | zstd -dfo "$tmp"
+			download "vmlinux-${KERNELRELEASE}.zst" | zstd -dfo "$tmp"
 			mv "$tmp" "$source_vmlinux"
 			tmp=
 		fi
 	fi
+	echo "Copying vmlinux..." >&2
+	sudo rsync -cp --chmod 0644 "$source_vmlinux" "$vmlinux"
 else
-	source_vmlinux="${ARCH_DIR}/vmlinux-${KERNELRELEASE}"
-	download "${ARCH}/vmlinux-${KERNELRELEASE}.zst" | zstd -d >"$source_vmlinux"
+	# We could use "sudo zstd -o", but let's not run zstd as root with
+	# input from the internet.
+	download "vmlinux-${KERNELRELEASE}.zst" |
+		zstd -d | sudo tee "$vmlinux" > /dev/null
+	sudo chmod 644 "$vmlinux"
 fi
-echo "Copying vmlinux..." >&2
-guestfish --remote \
-	upload "$source_vmlinux" "$vmlinux" : \
-	chmod 644 "$vmlinux"

 travis_fold end vmlinux_setup

@@ -408,24 +384,14 @@ REPO_PATH="${SELFTEST_REPO_PATH:-travis-ci/vmtest/bpf-next}"
 LIBBPF_PATH="${REPO_ROOT}" \
 	VMTEST_ROOT="${VMTEST_ROOT}" \
 	REPO_PATH="${REPO_PATH}" \
-	VMLINUX_BTF=$(realpath ${source_vmlinux}) ${VMTEST_ROOT}/build_selftests.sh
+	VMLINUX_BTF=${vmlinux} ${VMTEST_ROOT}/build_selftests.sh

 travis_fold start bpftool_checks "Running bpftool checks..."
-bpftool_exitstatus=
 if [[ "${KERNEL}" = 'LATEST' ]]; then
-	# "&& true" does not change the return code (it is not executed if the
-	# Python script fails), but it prevents the trap on ERR set at the top
-	# of this file to trigger on failure.
-	"${REPO_ROOT}/${REPO_PATH}/tools/testing/selftests/bpf/test_bpftool_synctypes.py" && true
-	bpftool_exitstatus=$?
-	if [[ "$bpftool_exitstatus" -eq 0 ]]; then
-		print_notice bpftool_checks "bpftool checks passed successfully."
-	else
-		print_error bpftool_checks "bpftool checks returned ${bpftool_exitstatus}."
-	fi
-	bpftool_exitstatus="bpftool:${bpftool_exitstatus}"
+	"${REPO_ROOT}/${REPO_PATH}/tools/testing/selftests/bpf/test_bpftool_synctypes.py" && \
+		echo "Consistency checks passed successfully."
 else
-	echo "bpftool checks skipped."
+	echo "Consistency checks skipped."
 fi
 travis_fold end bpftool_checks

@@ -436,31 +402,23 @@ if (( SKIPSOURCE )); then
 else
 	echo "Copying source files..." >&2
 	# Copy the source files in.
-	guestfish --remote \
-		mkdir-p "/${PROJECT_NAME}" : \
-		chmod 0755 "/${PROJECT_NAME}"
+	sudo mkdir -p -m 0755 "$mnt/${PROJECT_NAME}"
 	if [[ "${SOURCE_FULLCOPY}" == "1" ]]; then
-		git ls-files -z | tar --null --files-from=- -c | tar_in "/${PROJECT_NAME}"
+		git ls-files -z | sudo rsync --files-from=- -0cpt . "$mnt/${PROJECT_NAME}"
 	else
-		guestfish --remote \
-			mkdir-p "/${PROJECT_NAME}/selftests" : \
-			chmod 0755 "/${PROJECT_NAME}/selftests" : \
-			mkdir-p "/${PROJECT_NAME}/travis-ci" : \
-			chmod 0755 "/${PROJECT_NAME}/travis-ci"
+		sudo mkdir -p -m 0755 ${mnt}/${PROJECT_NAME}/{selftests,travis-ci}
 		tree --du -shaC "${REPO_ROOT}/selftests/bpf"
-		tar -C "${REPO_ROOT}/selftests" -c bpf | tar_in "/${PROJECT_NAME}/selftests"
-		tar -C "${REPO_ROOT}/travis-ci" -c vmtest | tar_in "/${PROJECT_NAME}/travis-ci"
-	fi
+		sudo rsync -avm "${REPO_ROOT}/selftests/bpf" "$mnt/${PROJECT_NAME}/selftests/"
+		sudo rsync -avm "${REPO_ROOT}/travis-ci/vmtest" "$mnt/${PROJECT_NAME}/travis-ci/"
+        fi
+
 fi

-tmp=$(mktemp)
-cat <<HERE >"$tmp"
-"#!/bin/sh
+setup_script="#!/bin/sh

 echo 'Skipping setup commands'
-echo vm_start:0 > /exitstatus
-chmod 644 /exitstatus
-HERE
+echo 0 > /exitstatus
+chmod 644 /exitstatus"

 # Create the init scripts.
 if [[ ! -z SETUPCMD ]]; then
@@ -469,101 +427,51 @@ if [[ ! -z SETUPCMD ]]; then
 	kernel="${KERNELRELEASE}"
 	if [[ -v BUILDDIR ]]; then kernel='latest'; fi
 	setup_envvars="export KERNEL=${kernel}"
-	cat <<HERE >"$tmp"
-#!/bin/sh
+	setup_script=$(printf "#!/bin/sh
 set -eux

 echo 'Running setup commands'
-${setup_envvars}
-set +e
-${setup_cmd}; exitstatus=\$?
-echo -e '$(travis_fold start collect_status "Collect status")'
-set -e
-# If setup command did not write its exit status to /exitstatus, do it now
-if [[ ! -s /exitstatus ]]; then
-	echo setup_cmd:\$exitstatus > /exitstatus
-fi
-chmod 644 /exitstatus
-echo -e '$(travis_fold end collect_status)'
-echo -e '$(travis_fold start shutdown Shutdown)'
-HERE
+%s
+set +e; %s; exitstatus=\$?; set -e
+echo \$exitstatus > /exitstatus
+chmod 644 /exitstatus" "${setup_envvars}" "${setup_cmd}")
 fi

-guestfish --remote \
-	upload "$tmp" /etc/rcS.d/S50-run-tests : \
-	chmod 755 /etc/rcS.d/S50-run-tests
+echo "${setup_script}" | sudo tee "$mnt/etc/rcS.d/S50-run-tests" > /dev/null
+sudo chmod 755 "$mnt/etc/rcS.d/S50-run-tests"

-cat <<HERE >"$tmp"
-#!/bin/sh
+fold_shutdown="$(travis_fold start shutdown)"
+poweroff_script="#!/bin/sh

-poweroff
-HERE
-guestfish --remote \
-	upload "$tmp" /etc/rcS.d/S99-poweroff : \
-	chmod 755 /etc/rcS.d/S99-poweroff
-rm "$tmp"
-tmp=
+echo ${fold_shutdown}
+echo -e '\033[1;33mShutdown\033[0m\n'

-guestfish --remote exit
+poweroff"
+echo "${poweroff_script}" | sudo tee "$mnt/etc/rcS.d/S99-poweroff" > /dev/null
+sudo chmod 755 "$mnt/etc/rcS.d/S99-poweroff"
+
+sudo umount "$mnt"

 echo "Starting VM with $(nproc) CPUs..."

-case "$ARCH" in
-s390x)
-	qemu="qemu-system-s390x"
-	console="ttyS1"
-	smp=2
-	kvm_accel="-enable-kvm"
-	tcg_accel="-machine accel=tcg"
-	;;
-x86_64)
-	qemu="qemu-system-x86_64"
-	console="ttyS0,115200"
-	smp=$(nproc)
-	kvm_accel="-cpu kvm64 -enable-kvm"
-	tcg_accel="-cpu qemu64 -machine accel=tcg"
-	;;
-*)
-	echo "Unsupported architecture"
-	exit 1
-	;;
-esac
 if kvm-ok ; then
-  accel=$kvm_accel
+  accel="-cpu kvm64 -enable-kvm"
 else
-  accel=$tcg_accel
+  accel="-cpu qemu64 -machine accel=tcg"
 fi
-"$qemu" -nodefaults -display none -serial mon:stdio \
-  ${accel} -smp "$smp" -m 4G \
+qemu-system-x86_64 -nodefaults -display none -serial mon:stdio -no-reboot \
+  ${accel} -smp "$(nproc)" -m 4G \
  -drive file="$IMG",format=raw,index=1,media=disk,if=virtio,cache=none \
-  -kernel "$vmlinuz" -append "root=/dev/vda rw console=$console kernel.panic=-1 $APPEND"
-
-# Set exit status to 1 if at least one group test returned non-0
-exitfile="${bpftool_exitstatus}${bpftool_exitstatus:+\n}"
-exitfile+="$(guestfish --ro -a "$IMG" -i cat /exitstatus 2>/dev/null)"
-exitstatus="$(echo -e "$exitfile" | awk --field-separator ':' \
-	'BEGIN { s=0 } { if ($2) {s=1} } END { print s }')"
-
-if [[ "$exitstatus" =~ ^[0-9]+$ ]]; then
+  -kernel "$vmlinuz" -append "root=/dev/vda rw console=ttyS0,115200 kernel.panic=-1 $APPEND"
+sudo mount -o loop "$IMG" "$mnt"
+if exitstatus="$(cat "$mnt/exitstatus" 2>/dev/null)"; then
 	printf '\nTests exit status: %s\n' "$exitstatus" >&2
 else
-	printf '\nCould not read tests exit status ("%s")\n' "$exitstatus" >&2
+	printf '\nCould not read tests exit status\n' >&2
 	exitstatus=1
 fi
+sudo umount "$mnt"

 travis_fold end shutdown

-# Final summary - Don't use a fold, keep it visible
-echo -e "\033[1;33mTest Results:\033[0m"
-echo -e "$exitfile" | while read result; do
-	testgroup=${result%:*}
-	status=${result#*:}
-	# Print final result for each group of tests
-	if [[ "$status" -eq 0 ]]; then
-		printf "%20s: \033[1;32mPASS\033[0m\n" "$testgroup"
-	else
-		printf "%20s: \033[1;31mFAIL\033[0m (returned %s)\n" "$testgroup" "$status"
-	fi
-done
-
 exit "$exitstatus"
--- a/travis-ci/vmtest/run_selftests.sh
+++ b/travis-ci/vmtest/run_selftests.sh
@@ -4,52 +4,42 @@ set -euo pipefail

 source $(cd $(dirname $0) && pwd)/helpers.sh

-STATUS_FILE=/exitstatus
-
-read_lists() {
-	(for path in "$@"; do
-		if [[ -s "$path" ]]; then
-			cat "$path"
-		fi;
-	done) | cut -d'#' -f1 | tr -s ' \t\n' ','
-}
-
 test_progs() {
 	if [[ "${KERNEL}" != '4.9.0' ]]; then
 		travis_fold start test_progs "Testing test_progs"
-		# "&& true" does not change the return code (it is not executed
-		# if the Python script fails), but it prevents exiting on a
-		# failure due to the "set -e".
-		./test_progs ${BLACKLIST:+-d$BLACKLIST} ${WHITELIST:+-a$WHITELIST} && true
-		echo "test_progs:$?" >> "${STATUS_FILE}"
+		./test_progs ${BLACKLIST:+-d$BLACKLIST} ${WHITELIST:+-a$WHITELIST}
 		travis_fold end test_progs
 	fi

 	travis_fold start test_progs-no_alu32 "Testing test_progs-no_alu32"
-	./test_progs-no_alu32 ${BLACKLIST:+-d$BLACKLIST} ${WHITELIST:+-a$WHITELIST} && true
-	echo "test_progs-no_alu32:$?" >> "${STATUS_FILE}"
+	./test_progs-no_alu32 ${BLACKLIST:+-d$BLACKLIST} ${WHITELIST:+-a$WHITELIST}
 	travis_fold end test_progs-no_alu32
 }

 test_maps() {
 	travis_fold start test_maps "Testing test_maps"
-	./test_maps && true
-	echo "test_maps:$?" >> "${STATUS_FILE}"
+	./test_maps
 	travis_fold end test_maps
 }

 test_verifier() {
 	travis_fold start test_verifier "Testing test_verifier"
-	./test_verifier && true
-	echo "test_verifier:$?" >> "${STATUS_FILE}"
+	./test_verifier
 	travis_fold end test_verifier
 }

 travis_fold end vm_init

-configs_path=libbpf/travis-ci/vmtest/configs
-BLACKLIST=$(read_lists "$configs_path/blacklist/BLACKLIST-${KERNEL}" "$configs_path/blacklist/BLACKLIST-${KERNEL}.${ARCH}")
-WHITELIST=$(read_lists "$configs_path/whitelist/WHITELIST-${KERNEL}" "$configs_path/whitelist/WHITELIST-${KERNEL}.${ARCH}")
+configs_path='libbpf/travis-ci/vmtest/configs'
+blacklist_path="$configs_path/blacklist/BLACKLIST-${KERNEL}"
+if [[ -s "${blacklist_path}" ]]; then
+	BLACKLIST=$(cat "${blacklist_path}" | cut -d'#' -f1 | tr -s '[:space:]' ',')
+fi
+
+whitelist_path="$configs_path/whitelist/WHITELIST-${KERNEL}"
+if [[ -s "${whitelist_path}" ]]; then
+	WHITELIST=$(cat "${whitelist_path}" | cut -d'#' -f1 | tr -s '[:space:]' ',')
+fi

 cd libbpf/selftests/bpf

--- a/travis-ci/vmtest/run_vmtest.sh
+++ b/travis-ci/vmtest/run_vmtest.sh
@@ -23,7 +23,7 @@ sudo add-apt-repository "deb http://apt.llvm.org/focal/ llvm-toolchain-focal mai
 sudo apt-get update
 sudo apt-get install --allow-downgrades -y libc6=2.31-0ubuntu9.2
 sudo aptitude install -y g++ libelf-dev
-sudo aptitude install -y clang-14 llvm-14
+sudo aptitude install -y clang-14 lld-14 llvm-14

 travis_fold end install_clang

@@ -35,13 +35,11 @@ else
  ${VMTEST_ROOT}/prepare_selftests.sh
 fi

-travis_fold start adduser_to_kvm "Add user ${USER}"
-sudo adduser "${USER}" kvm
-travis_fold stop adduser_to_kvm
-
 # Escape whitespace characters.
 setup_cmd=$(sed 's/\([[:space:]]\)/\\\1/g' <<< "${VMTEST_SETUPCMD}")

+sudo adduser "${USER}" kvm
+
 if [[ "${KERNEL}" = 'LATEST' ]]; then
  if [[ "$CHECKOUT_KERNEL" == "1" ]]; then
    sudo -E sudo -E -u "${USER}" "${VMTEST_ROOT}/run.sh" -b travis-ci/vmtest/bpf-next -o -d ~ -s "${setup_cmd}" ~/root.img
--- a/travis-ci/vmtest/s390x-self-hosted-builder/README.md
+++ b/travis-ci/vmtest/s390x-self-hosted-builder/README.md
@@ -1,72 +0,0 @@
-# IBM Z self-hosted builder
-
-libbpf CI uses an IBM-provided z15 self-hosted builder. There are no IBM Z
-builds of GitHub Actions runner, and stable qemu-user has problems with .NET
-apps, so the builder runs the x86_64 runner version with qemu-user built from
-the master branch.
-
-## Configuring the builder.
-
-### Install prerequisites.
-
-```
-$ sudo dnf install docker
-```
-
-### Add services.
-
-```
-$ sudo cp *.service /etc/systemd/system/
-$ sudo systemctl daemon-reload
-```
-
-### Create a config file.
-
-```
-$ sudo tee /etc/actions-runner-libbpf
-repo=<owner>/<name>
-access_token=<ghp_***>
-```
-
-Access token should have the repo scope, consult
-https://docs.github.com/en/rest/reference/actions#create-a-registration-token-for-a-repository
-for details.
-
-### Autostart the x86_64 emulation support.
-
-```
-$ sudo systemctl enable --now qemu-user-static
-```
-
-### Autostart the runner.
-
-```
-$ sudo systemctl enable --now actions-runner-libbpf
-```
-
-## Rebuilding the image
-
-In order to update the `iiilinuxibmcom/actions-runner-libbpf` image, e.g. to
-get the latest OS security fixes, use the following commands:
-
-```
-$ sudo docker build \
-      --pull \
-      -f actions-runner-libbpf.Dockerfile \
-      -t iiilinuxibmcom/actions-runner-libbpf
-$ sudo systemctl restart actions-runner-libbpf
-```
-
-## Removing persistent data
-
-The `actions-runner-libbpf` service stores various temporary data, such as
-runner  registration information, work directories and logs, in the
-`actions-runner-libbpf` volume. In order to remove it and start from scratch,
-e.g. when switching the runner to a different repository, use the following
-commands:
-
-```
-$ sudo systemctl stop actions-runner-libbpf
-$ sudo docker rm -f actions-runner-libbpf
-$ sudo docker volume rm actions-runner-libbpf
-```
--- a/travis-ci/vmtest/s390x-self-hosted-builder/actions-runner-libbpf.Dockerfile
+++ b/travis-ci/vmtest/s390x-self-hosted-builder/actions-runner-libbpf.Dockerfile
@@ -1,48 +0,0 @@
-# Self-Hosted IBM Z Github Actions Runner.
-
-# Temporary image: amd64 dependencies.
-FROM amd64/ubuntu:20.04 as ld-prefix
-ENV DEBIAN_FRONTEND=noninteractive
-RUN apt-get update && apt-get -y install ca-certificates libicu66 libssl1.1
-
-# Main image.
-FROM s390x/ubuntu:20.04
-
-# Packages for libbpf testing that are not installed by .github/actions/setup.
-ENV DEBIAN_FRONTEND=noninteractive
-RUN apt-get update && apt-get -y install \
-        bc \
-        bison \
-        cmake \
-        cpu-checker \
-        curl \
-        flex \
-        git \
-        jq \
-        linux-image-generic \
-        qemu-system-s390x \
-        rsync \
-        software-properties-common \
-        sudo \
-        tree
-
-# amd64 dependencies.
-COPY --from=ld-prefix / /usr/x86_64-linux-gnu/
-RUN ln -fs ../lib/x86_64-linux-gnu/ld-linux-x86-64.so.2 /usr/x86_64-linux-gnu/lib64/
-RUN ln -fs /etc/resolv.conf /usr/x86_64-linux-gnu/etc/
-ENV QEMU_LD_PREFIX=/usr/x86_64-linux-gnu
-
-# amd64 Github Actions Runner.
-RUN useradd -m actions-runner
-RUN echo "actions-runner ALL=(ALL) NOPASSWD: ALL" >>/etc/sudoers
-RUN echo "Defaults env_keep += \"DEBIAN_FRONTEND\"" >>/etc/sudoers
-USER actions-runner
-ENV USER=actions-runner
-WORKDIR /home/actions-runner
-RUN curl -L https://github.com/actions/runner/releases/download/v2.283.2/actions-runner-linux-x64-2.283.2.tar.gz | tar -xz
-VOLUME /home/actions-runner
-
-# Scripts.
-COPY fs/ /
-ENTRYPOINT ["/usr/bin/entrypoint"]
-CMD ["/usr/bin/actions-runner"]
--- a/travis-ci/vmtest/s390x-self-hosted-builder/actions-runner-libbpf.service
+++ b/travis-ci/vmtest/s390x-self-hosted-builder/actions-runner-libbpf.service
@@ -1,24 +0,0 @@
-[Unit]
-Description=Self-Hosted IBM Z Github Actions Runner
-Wants=qemu-user-static
-After=qemu-user-static
-StartLimitIntervalSec=0
-
-[Service]
-Type=simple
-Restart=always
-ExecStart=/usr/bin/docker run \
-              --device=/dev/kvm \
-              --env-file=/etc/actions-runner-libbpf \
-              --init \
-              --interactive \
-              --name=actions-runner-libbpf \
-              --rm \
-              --volume=actions-runner-libbpf:/home/actions-runner \
-              iiilinuxibmcom/actions-runner-libbpf
-ExecStop=/bin/sh -c "docker exec actions-runner-libbpf kill -INT -- -1"
-ExecStop=/bin/sh -c "docker wait actions-runner-libbpf"
-ExecStop=/bin/sh -c "docker rm actions-runner-libbpf"
-
-[Install]
-WantedBy=multi-user.target
--- a/travis-ci/vmtest/s390x-self-hosted-builder/fs/usr/bin/actions-runner
+++ b/travis-ci/vmtest/s390x-self-hosted-builder/fs/usr/bin/actions-runner
@@ -1,40 +0,0 @@
-#!/bin/bash
-
-#
-# Ephemeral runner startup script.
-#
-# Expects the following environment variables:
-#
-# - repo=<owner>/<name>
-# - access_token=<ghp_***>
-#
-
-set -e -u
-
-# Check the cached registration token.
-token_file=registration-token.json
-set +e
-expires_at=$(jq --raw-output .expires_at "$token_file" 2>/dev/null)
-status=$?
-set -e
-if [[ $status -ne 0 || $(date +%s) -ge $(date -d "$expires_at" +%s) ]]; then
-    # Refresh the cached registration token.
-    curl \
-        -X POST \
-        -H "Accept: application/vnd.github.v3+json" \
-        -H "Authorization: token $access_token" \
-        "https://api.github.com/repos/$repo/actions/runners/registration-token" \
-        -o "$token_file"
-fi
-
-# (Re-)register the runner.
-registration_token=$(jq --raw-output .token "$token_file")
-./config.sh remove --token "$registration_token" || true
-./config.sh \
-    --url "https://github.com/$repo" \
-    --token "$registration_token" \
-    --labels z15 \
-    --ephemeral
-
-# Run one job.
-./run.sh
--- a/travis-ci/vmtest/s390x-self-hosted-builder/fs/usr/bin/entrypoint
+++ b/travis-ci/vmtest/s390x-self-hosted-builder/fs/usr/bin/entrypoint
@@ -1,35 +0,0 @@
-#!/bin/bash
-
-#
-# Container entrypoint that waits for all spawned processes.
-#
-
-set -e -u
-
-# /dev/kvm has host permissions, fix it.
-if [ -e /dev/kvm ]; then
-    sudo chown root:kvm /dev/kvm
-fi
-
-# Create a FIFO and start reading from its read end.
-tempdir=$(mktemp -d "/tmp/done.XXXXXXXXXX")
-trap 'rm -r "$tempdir"' EXIT
-done="$tempdir/pipe"
-mkfifo "$done"
-cat "$done" & waiter=$!
-
-# Start the workload. Its descendants will inherit the FIFO's write end.
-status=0
-if [ "$#" -eq 0 ]; then
-    bash 9>"$done" || status=$?
-else
-    "$@" 9>"$done" || status=$?
-fi
-
-# When the workload and all of its descendants exit, the FIFO's write end will
-# be closed and `cat "$done"` will exit. Wait until it happens. This is needed
-# in order to handle SelfUpdater, which the workload may start in background
-# before exiting.
-wait "$waiter"
-
-exit "$status"
--- a/travis-ci/vmtest/s390x-self-hosted-builder/qemu-user-static.service
+++ b/travis-ci/vmtest/s390x-self-hosted-builder/qemu-user-static.service
@@ -1,11 +0,0 @@
-[Unit]
-Description=Support for transparent execution of non-native binaries with QEMU user emulation
-
-[Service]
-Type=oneshot
-# The source code for iiilinuxibmcom/qemu-user-static is at https://github.com/iii-i/qemu-user-static/tree/v6.1.0-1
-# TODO: replace it with multiarch/qemu-user-static once version >6.1 is available
-ExecStart=/usr/bin/docker run --rm --interactive --privileged iiilinuxibmcom/qemu-user-static --reset -p yes
-
-[Install]
-WantedBy=multi-user.target
Author	SHA1	Message	Date
Thiago Marques	4a4afa5b52	v0.5.1_netdata_patch: Apply patch	2021-11-11 19:28:58 +00:00
Thiago Marques	86175df408	Merge remote-tracking branch 'upstream/master'	2021-11-11 19:17:34 +00:00
Thiago Marques	720324afab	Merge remote-tracking branch 'upstream/master'	2021-10-19 16:58:24 +00:00
Thiago Marques	aea40f7179	Merge remote-tracking branch 'upstream/master'	2021-08-20 01:33:45 +00:00
Andrii Nakryiko	54a7bc87d5	ci: restore all temporary disabled tests Upstream bpf-next should be good, so no temporary blocked tests should remain. Signed-off-by: Andrii Nakryiko <andrii@kernel.org>	2021-08-06 20:09:33 -07:00
Yucong Sun	9979463ccf	Remove shared linking for now	2021-08-06 15:04:04 -07:00
Yucong Sun	b91ca01922	Add a test step to produce a minimal binary using libbpf. This patch adds a test step to link a minimal program to libbpf library produced, making sure that the library works.	2021-08-06 15:04:04 -07:00
Rafael David Tinoco	8ded7c6db0	makefile: fix missing object for static compilation Makefile needs relo_core object added to objects list to avoid static linking errors when doing static compilation: /bin/ld: .../libbpf.a(libbpf.o): in function `bpf_core_apply_relo': .../libbpf/src/libbpf.c:5134: undefined reference to `bpf_core_apply_relo_insn' Signed-off-by: Rafael David Tinoco <rafaeldtinoco@gmail.com>	2021-08-06 13:50:20 -07:00
Andrii Nakryiko	7df4ea0f0d	ci: make CI build log less verbose Only keep stderr output in case of errors for kernel and selftests builds. Having a multi-thousand-line output isn't useful and slows down Github Actions' log view UI. Also quiet down wget's "progress bar" output. While at the same time see some totals from tar, just for the fun of it. Signed-off-by: Andrii Nakryiko <andrii@kernel.org>	2021-08-04 23:54:46 -07:00
Andrii Nakryiko	02333ba360	ci: blacklist newly migrated netcnt selftest Seems like netcnt uses some map operations not supported by 5.5. Signed-off-by: Andrii Nakryiko <andrii@kernel.org>	2021-08-04 18:27:12 -07:00
Andrii Nakryiko	6921017d25	sync: latest libbpf changes from kernel Syncing latest libbpf commits from kernel repository. Baseline bpf-next commit: 807b8f0e24e6004984094e1bcbbd2b297011a085 Checkpoint bpf-next commit: 372642ea83ff1c71a5d567a704c912359eb59776 Baseline bpf commit: d6371c76e20d7d3f61b05fd67b596af4d14a8886 Checkpoint bpf commit: a02215ce72a37a19a690803b23b091186ee4f7b2 Alexei Starovoitov (4): libbpf: Cleanup the layering between CORE and bpf_program. libbpf: Split bpf_core_apply_relo() into bpf_program independent helper. libbpf: Move CO-RE types into relo_core.h. libbpf: Split CO-RE logic into relo_core.c. Daniel Xu (1): libbpf: Do not close un-owned FD 0 on errors Evgeniy Litvinenko (1): libbpf: Add bpf_map__pin_path function Hengqi Chen (1): libbpf: Add btf__load_vmlinux_btf/btf__load_module_btf Jason Wang (1): libbpf: Fix comment typo Jiri Olsa (3): libbpf: Fix func leak in attach_kprobe libbpf: Allow decimal offset for kprobes libbpf: Export bpf_program__attach_kprobe_opts function Martynas Pumputis (1): libbpf: Fix race when pinning maps in parallel Quentin Monnet (4): libbpf: Return non-null error on failures in libbpf_find_prog_btf_id() libbpf: Rename btf__load() as btf__load_into_kernel() libbpf: Rename btf__get_from_id() as btf__load_from_kernel_by_id() libbpf: Add split BTF support for btf__load_from_kernel_by_id() Robin Gögge (1): libbpf: Fix probe for BPF_PROG_TYPE_CGROUP_SOCKOPT src/btf.c \| 50 +- src/btf.h \| 12 +- src/libbpf.c \| 1419 +++-------------------------------------- src/libbpf.h \| 16 + src/libbpf.map \| 7 + src/libbpf_internal.h \| 81 +-- src/libbpf_probes.c \| 4 +- src/relo_core.c \| 1295 +++++++++++++++++++++++++++++++++++++ src/relo_core.h \| 100 +++ 9 files changed, 1561 insertions(+), 1423 deletions(-) create mode 100644 src/relo_core.c create mode 100644 src/relo_core.h -- 2.30.2	2021-08-04 18:27:12 -07:00