Apply patch to run binaries on Debian 10

2026-03-14 05:19:06 +08:00 · 2024-01-24 12:45:57 +00:00
62 changed files with 96670 additions and 102084 deletions
--- a/.github/PULL_REQUEST_TEMPLATE.md
+++ b/.github/PULL_REQUEST_TEMPLATE.md
@@ -0,0 +1,3 @@
+Thank you for considering a contribution!
+
+Please note that the `libbpf` authoritative source code is developed as part of bpf-next Linux source tree under tools/lib/bpf subdirectory and is periodically synced to Github. As such, all the libbpf changes should be sent to BPF mailing list, please don't open PRs here unless you are changing Github-specific parts of libbpf (e.g., Github-specific Makefile).
--- a/.github/actions/build-selftests/prepare_selftests-4.9.0.sh
+++ b/.github/actions/build-selftests/prepare_selftests-4.9.0.sh
@@ -1,5 +1,3 @@
 #!/bin/bash

 printf "all:\n\ttouch bpf_testmod.ko\n\nclean:\n" > bpf_testmod/Makefile
-printf "all:\n\ttouch bpf_test_no_cfi.ko\n\nclean:\n" > bpf_test_no_cfi/Makefile
-
--- a/.github/actions/build-selftests/prepare_selftests-5.5.0.sh
+++ b/.github/actions/build-selftests/prepare_selftests-5.5.0.sh
@@ -1,5 +1,3 @@
 #!/bin/bash

 printf "all:\n\ttouch bpf_testmod.ko\n\nclean:\n" > bpf_testmod/Makefile
-printf "all:\n\ttouch bpf_test_no_cfi.ko\n\nclean:\n" > bpf_test_no_cfi/Makefile
-
--- a/.github/actions/build-selftests/vmlinux.h
+++ b/.github/actions/build-selftests/vmlinux.h
--- a/.github/actions/vmtest/action.yml
+++ b/.github/actions/vmtest/action.yml
@@ -37,7 +37,6 @@ runs:
      uses: libbpf/ci/setup-build-env@main
      with:
        pahole: ${{ inputs.pahole }}
-        arch: ${{ inputs.arch }}
    # 1. download CHECKPOINT kernel source
    - name: Get checkpoint commit
      shell: bash
--- a/.github/workflows/build.yml
+++ b/.github/workflows/build.yml
@@ -42,7 +42,7 @@ jobs:
          - name: gcc-12
            target: RUN_GCC12
    steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v3
        name: Checkout
      - uses: ./.github/actions/setup
        name: Setup
@@ -53,7 +53,7 @@ jobs:

  ubuntu:
    runs-on: ubuntu-latest
-    name: Ubuntu Build (${{ matrix.arch }})
+    name: Ubuntu Focal Build (${{ matrix.arch }})
    strategy:
      fail-fast: false
      matrix:
@@ -63,19 +63,19 @@ jobs:
          - arch: s390x
          - arch: x86
    steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v3
        name: Checkout
      - uses: ./.github/actions/setup
        name: Pre-Setup
      - run: source /tmp/ci_setup && sudo -E $CI_ROOT/managers/ubuntu.sh
        if: matrix.arch == 'x86'
        name: Setup
-      - uses: uraimo/run-on-arch-action@v2.7.1
+      - uses: uraimo/run-on-arch-action@v2.0.5
        name: Build in docker
        if: matrix.arch != 'x86'
        with:
          distro:
-            ubuntu22.04
+            ubuntu20.04
          arch:
            ${{ matrix.arch }}
          setup:
--- a/.github/workflows/codeql.yml
+++ b/.github/workflows/codeql.yml
@@ -17,7 +17,7 @@ permissions:
 jobs:
  analyze:
    name: Analyze
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-22.04
    concurrency:
      group: ${{ github.workflow }}-${{ matrix.language }}-${{ github.ref }}
      cancel-in-progress: true
@@ -32,7 +32,7 @@ jobs:

    steps:
      - name: Checkout repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3

      - name: Initialize CodeQL
        uses: github/codeql-action/init@v2
--- a/.github/workflows/coverity.yml
+++ b/.github/workflows/coverity.yml
@@ -11,7 +11,7 @@ jobs:
    if: github.repository == 'libbpf/libbpf'
    name: Coverity
    steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v3
      - uses: ./.github/actions/setup
      - name: Run coverity
        run: |
--- a/.github/workflows/lint.yml
+++ b/.github/workflows/lint.yml
@@ -12,7 +12,7 @@ jobs:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout repository
-        uses: actions/checkout@v4
+        uses: actions/checkout@v3
      - name: Run ShellCheck
        uses: ludeeus/action-shellcheck@master
        env:
--- a/.github/workflows/ondemand.yml
+++ b/.github/workflows/ondemand.yml
@@ -25,7 +25,7 @@ jobs:
    runs-on: ubuntu-latest
    name: vmtest with customized pahole/Kernel
    steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v3
      - uses: ./.github/actions/setup
      - uses: ./.github/actions/vmtest
        with:
--- a/.github/workflows/pahole.yml
+++ b/.github/workflows/pahole.yml
@@ -1,10 +1,10 @@
 name: pahole-staging

 on:
-  workflow_dispatch:
  schedule:
    - cron:  '0 18 * * *'

+
 jobs:
  vmtest:
    runs-on: ubuntu-20.04
@@ -12,7 +12,7 @@ jobs:
    env:
      STAGING: tmp.master
    steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v3
      - uses: ./.github/actions/setup
      - uses: ./.github/actions/vmtest
        with:
--- a/.github/workflows/test.yml
+++ b/.github/workflows/test.yml
@@ -31,7 +31,7 @@ jobs:
            runs_on: s390x
            arch: 's390x'
    steps:
-      - uses: actions/checkout@v4
+      - uses: actions/checkout@v3
        name: Checkout
      - uses: ./.github/actions/setup
        name: Setup
--- a/.mailmap
+++ b/.mailmap
@@ -1,21 +0,0 @@
-Alexei Starovoitov <ast@kernel.org> <alexei.starovoitov@gmail.com>
-Antoine Tenart <atenart@kernel.org> <antoine.tenart@bootlin.com>
-Benjamin Tissoires <bentiss@kernel.org> <benjamin.tissoires@redhat.com>
-Björn Töpel <bjorn@kernel.org> <bjorn.topel@intel.com>
-Changbin Du <changbin.du@intel.com> <changbin.du@gmail.com>
-Colin Ian King <colin.i.king@gmail.com> <colin.king@canonical.com>
-Dan Carpenter <error27@gmail.com> <dan.carpenter@oracle.com>
-Geliang Tang <geliang@kernel.org> <geliang.tang@suse.com>
-Herbert Xu <herbert@gondor.apana.org.au>
-Jakub Kicinski <kuba@kernel.org> <jakub.kicinski@netronome.com>
-Kees Cook <kees@kernel.org> <keescook@chromium.org>
-Leo Yan <leo.yan@linux.dev> <leo.yan@linaro.org>
-Mark Starovoytov <mstarovo@pm.me> <mstarovoitov@marvell.com>
-Maxim Mikityanskiy <maxtram95@gmail.com> <maximmi@mellanox.com>
-Maxim Mikityanskiy <maxtram95@gmail.com> <maximmi@nvidia.com>
-Puranjay Mohan <puranjay@kernel.org> <puranjay12@gmail.com>
-Quentin Monnet <qmo@kernel.org> <quentin@isovalent.com>
-Quentin Monnet <qmo@kernel.org> <quentin.monnet@netronome.com>
-Stanislav Fomichev <sdf@fomichev.me> <sdf@google.com>
-Vadim Fedorenko <vadim.fedorenko@linux.dev> <vadfed@meta.com>
-Vadim Fedorenko <vadim.fedorenko@linux.dev> <vfedorenko@novek.ru>
--- a/2
+++ b/2
@@ -1 +1 @@
-e1533b6319ab9c3a97dad314dd88b3783bc41b69
+7c5e046bdcb2513f9decb3765d8bf92d604279cf
--- a/2
+++ b/2
@@ -1 +1 @@
-ec5b8c76ab1c6d163762d60cfbedcd27e7527144
+98e20e5e13d2811898921f999288be7151a11954
--- a/README.md
+++ b/README.md
@@ -146,7 +146,7 @@ Distributions packaging libbpf from this mirror:
  - [Gentoo](https://packages.gentoo.org/packages/dev-libs/libbpf)
  - [Debian](https://packages.debian.org/source/sid/libbpf)
  - [Arch](https://archlinux.org/packages/core/x86_64/libbpf/)
-  - [Ubuntu](https://packages.ubuntu.com/source/jammy/libbpf)
+  - [Ubuntu](https://packages.ubuntu.com/source/impish/libbpf)
  - [Alpine](https://pkgs.alpinelinux.org/packages?name=libbpf)

 Benefits of packaging from the mirror over packaging from kernel sources:
--- a/ci/diffs/0001-arch-Kconfig-Move-SPECULATION_MITIGATIONS-to-arch-Kc.patch
+++ b/ci/diffs/0001-arch-Kconfig-Move-SPECULATION_MITIGATIONS-to-arch-Kc.patch
@@ -1,69 +0,0 @@
-From c71766e8ff7a7f950522d25896fba758585500df Mon Sep 17 00:00:00 2001
-From: Song Liu <song@kernel.org>
-Date: Mon, 22 Apr 2024 21:14:40 -0700
-Subject: [PATCH] arch/Kconfig: Move SPECULATION_MITIGATIONS to arch/Kconfig
-
-SPECULATION_MITIGATIONS is currently defined only for x86. As a result,
-IS_ENABLED(CONFIG_SPECULATION_MITIGATIONS) is always false for other
-archs. f337a6a21e2f effectively set "mitigations=off" by default on
-non-x86 archs, which is not desired behavior. Jakub observed this
-change when running bpf selftests on s390 and arm64.
-
-Fix this by moving SPECULATION_MITIGATIONS to arch/Kconfig so that it is
-available in all archs and thus can be used safely in kernel/cpu.c
-
-Fixes: f337a6a21e2f ("x86/cpu: Actually turn off mitigations by default for SPECULATION_MITIGATIONS=n")
-Cc: stable@vger.kernel.org
-Cc: Sean Christopherson <seanjc@google.com>
-Cc: Ingo Molnar <mingo@kernel.org>
-Cc: Daniel Sneddon <daniel.sneddon@linux.intel.com>
-Cc: Jakub Kicinski <kuba@kernel.org>
-Signed-off-by: Song Liu <song@kernel.org>
---
- arch/Kconfig     | 10 ++++++++++
- arch/x86/Kconfig | 10 ----------
- 2 files changed, 10 insertions(+), 10 deletions(-)
-
-diff --git a/arch/Kconfig b/arch/Kconfig
-index 9f066785bb71..8f4af75005f8 100644
--- a/arch/Kconfig
-+++ b/arch/Kconfig
-@@ -1609,4 +1609,14 @@ config CC_HAS_SANE_FUNCTION_ALIGNMENT
- 	# strict alignment always, even with -falign-functions.
- 	def_bool CC_HAS_MIN_FUNCTION_ALIGNMENT || CC_IS_CLANG
- 
-+menuconfig SPECULATION_MITIGATIONS
-+	bool "Mitigations for speculative execution vulnerabilities"
-+	default y
-+	help
-+	  Say Y here to enable options which enable mitigations for
-+	  speculative execution hardware vulnerabilities.
-+
-+	  If you say N, all mitigations will be disabled. You really
-+	  should know what you are doing to say so.
-+
- endmenu
-diff --git a/arch/x86/Kconfig b/arch/x86/Kconfig
-index 39886bab943a..50c890fce5e0 100644
--- a/arch/x86/Kconfig
-+++ b/arch/x86/Kconfig
-@@ -2486,16 +2486,6 @@ config PREFIX_SYMBOLS
- 	def_bool y
- 	depends on CALL_PADDING && !CFI_CLANG
- 
-menuconfig SPECULATION_MITIGATIONS
-	bool "Mitigations for speculative execution vulnerabilities"
-	default y
-	help
-	  Say Y here to enable options which enable mitigations for
-	  speculative execution hardware vulnerabilities.
-
-	  If you say N, all mitigations will be disabled. You really
-	  should know what you are doing to say so.
-
- if SPECULATION_MITIGATIONS
- 
- config MITIGATION_PAGE_TABLE_ISOLATION
-- 
-2.43.0
-
--- a/ci/diffs/0001-bpf-patch-out-BPF_F_TEST_REG_INVARIANTS-for-old-kern.patch
+++ b/ci/diffs/0001-bpf-patch-out-BPF_F_TEST_REG_INVARIANTS-for-old-kern.patch
@@ -0,0 +1,29 @@
+From 61e8893a1e32ab57d15974427f41b75de608dbda Mon Sep 17 00:00:00 2001
+From: Andrii Nakryiko <andrii@kernel.org>
+Date: Mon, 4 Dec 2023 21:21:23 -0800
+Subject: [PATCH] bpf: patch out BPF_F_TEST_REG_INVARIANTS for old kernels
+
+CI-only patch to avoid setting BPF_F_TEST_REG_INVARIANTS flag for old
+kernels that don't support it.
+
+Signed-off-by: Andrii Nakryiko <andrii@kernel.org>
+---
+ tools/include/uapi/linux/bpf.h | 2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+diff --git a/tools/include/uapi/linux/bpf.h b/tools/include/uapi/linux/bpf.h
+index e88746ba7d21..8344c9ce60e0 100644
+--- a/tools/include/uapi/linux/bpf.h
+++ b/tools/include/uapi/linux/bpf.h
+@@ -1201,7 +1201,7 @@ enum bpf_perf_event_type {
+ #define BPF_F_XDP_DEV_BOUND_ONLY	(1U << 6)
+ 
+ /* The verifier internal test flag. Behavior is undefined */
+-#define BPF_F_TEST_REG_INVARIANTS	(1U << 7)
+#define BPF_F_TEST_REG_INVARIANTS	(0)
+ 
+ /* link_create.kprobe_multi.flags used in LINK_CREATE command for
+  * BPF_TRACE_KPROBE_MULTI attach type to create return probe.
+-- 
+2.34.1
+
--- a/ci/diffs/0001-selftests-bpf-fix-inet_csk_accept-prototype-in-test_.patch
+++ b/ci/diffs/0001-selftests-bpf-fix-inet_csk_accept-prototype-in-test_.patch
@@ -1,32 +0,0 @@
-From 0daad0a615e687e1247230f3d0c31ae60ba32314 Mon Sep 17 00:00:00 2001
-From: Andrii Nakryiko <andrii@kernel.org>
-Date: Tue, 28 May 2024 15:29:38 -0700
-Subject: [PATCH bpf-next] selftests/bpf: fix inet_csk_accept prototype in
- test_sk_storage_tracing.c
-
-Recent kernel change ([0]) changed inet_csk_accept() prototype. Adapt
-progs/test_sk_storage_tracing.c to take that into account.
-
-  [0] 92ef0fd55ac8 ("net: change proto and proto_ops accept type")
-
-Signed-off-by: Andrii Nakryiko <andrii@kernel.org>
---
- tools/testing/selftests/bpf/progs/test_sk_storage_tracing.c | 2 +-
- 1 file changed, 1 insertion(+), 1 deletion(-)
-
-diff --git a/tools/testing/selftests/bpf/progs/test_sk_storage_tracing.c b/tools/testing/selftests/bpf/progs/test_sk_storage_tracing.c
-index 02e718f06e0f..40531e56776e 100644
--- a/tools/testing/selftests/bpf/progs/test_sk_storage_tracing.c
-+++ b/tools/testing/selftests/bpf/progs/test_sk_storage_tracing.c
-@@ -84,7 +84,7 @@ int BPF_PROG(trace_tcp_connect, struct sock *sk)
- }
- 
- SEC("fexit/inet_csk_accept")
-int BPF_PROG(inet_csk_accept, struct sock *sk, int flags, int *err, bool kern,
-+int BPF_PROG(inet_csk_accept, struct sock *sk, struct proto_accept_arg *arg,
- 	     struct sock *accepted_sk)
- {
- 	set_task_info(accepted_sk);
-- 
-2.43.0
-
--- a/ci/diffs/0001-selftests-bpf-xskxceiver-ksft_print_msg-fix-format-t.patch
+++ b/ci/diffs/0001-selftests-bpf-xskxceiver-ksft_print_msg-fix-format-t.patch
@@ -0,0 +1,89 @@
+From fe69a1b1b6ed9ffc2c578c63f526026a8ab74f0c Mon Sep 17 00:00:00 2001
+From: Anders Roxell <anders.roxell@linaro.org>
+Date: Thu, 9 Nov 2023 18:43:28 +0100
+Subject: [PATCH] selftests: bpf: xskxceiver: ksft_print_msg: fix format type
+ error
+
+Crossbuilding selftests/bpf for architecture arm64, format specifies
+type error show up like.
+
+xskxceiver.c:912:34: error: format specifies type 'int' but the argument
+has type '__u64' (aka 'unsigned long long') [-Werror,-Wformat]
+ ksft_print_msg("[%s] expected meta_count [%d], got meta_count [%d]\n",
+                                                                ~~
+                                                                %llu
+                __func__, pkt->pkt_nb, meta->count);
+                                       ^~~~~~~~~~~
+xskxceiver.c:929:55: error: format specifies type 'unsigned long long' but
+ the argument has type 'u64' (aka 'unsigned long') [-Werror,-Wformat]
+ ksft_print_msg("Frag invalid addr: %llx len: %u\n", addr, len);
+                                    ~~~~             ^~~~
+
+Fixing the issues by casting to (unsigned long long) and changing the
+specifiers to be %llu from %d and %u, since with u64s it might be %llx
+or %lx, depending on architecture.
+
+Signed-off-by: Anders Roxell <anders.roxell@linaro.org>
+Link: https://lore.kernel.org/r/20231109174328.1774571-1-anders.roxell@linaro.org
+Signed-off-by: Alexei Starovoitov <ast@kernel.org>
+---
+ tools/testing/selftests/bpf/xskxceiver.c | 19 ++++++++++++-------
+ 1 file changed, 12 insertions(+), 7 deletions(-)
+
+diff --git a/tools/testing/selftests/bpf/xskxceiver.c b/tools/testing/selftests/bpf/xskxceiver.c
+index 591ca9637b23..b604c570309a 100644
+--- a/tools/testing/selftests/bpf/xskxceiver.c
+++ b/tools/testing/selftests/bpf/xskxceiver.c
+@@ -908,8 +908,9 @@ static bool is_metadata_correct(struct pkt *pkt, void *buffer, u64 addr)
+ 	struct xdp_info *meta = data - sizeof(struct xdp_info);
+ 
+ 	if (meta->count != pkt->pkt_nb) {
+-		ksft_print_msg("[%s] expected meta_count [%d], got meta_count [%d]\n",
+-			       __func__, pkt->pkt_nb, meta->count);
+		ksft_print_msg("[%s] expected meta_count [%d], got meta_count [%llu]\n",
+			       __func__, pkt->pkt_nb,
+			       (unsigned long long)meta->count);
+ 		return false;
+ 	}
+ 
+@@ -926,11 +927,13 @@ static bool is_frag_valid(struct xsk_umem_info *umem, u64 addr, u32 len, u32 exp
+ 
+ 	if (addr >= umem->num_frames * umem->frame_size ||
+ 	    addr + len > umem->num_frames * umem->frame_size) {
+-		ksft_print_msg("Frag invalid addr: %llx len: %u\n", addr, len);
+		ksft_print_msg("Frag invalid addr: %llx len: %u\n",
+			       (unsigned long long)addr, len);
+ 		return false;
+ 	}
+ 	if (!umem->unaligned_mode && addr % umem->frame_size + len > umem->frame_size) {
+-		ksft_print_msg("Frag crosses frame boundary addr: %llx len: %u\n", addr, len);
+		ksft_print_msg("Frag crosses frame boundary addr: %llx len: %u\n",
+			       (unsigned long long)addr, len);
+ 		return false;
+ 	}
+ 
+@@ -1029,7 +1032,8 @@ static int complete_pkts(struct xsk_socket_info *xsk, int batch_size)
+ 			u64 addr = *xsk_ring_cons__comp_addr(&xsk->umem->cq, idx + rcvd - 1);
+ 
+ 			ksft_print_msg("[%s] Too many packets completed\n", __func__);
+-			ksft_print_msg("Last completion address: %llx\n", addr);
+			ksft_print_msg("Last completion address: %llx\n",
+				       (unsigned long long)addr);
+ 			return TEST_FAILURE;
+ 		}
+ 
+@@ -1513,8 +1517,9 @@ static int validate_tx_invalid_descs(struct ifobject *ifobject)
+ 	}
+ 
+ 	if (stats.tx_invalid_descs != ifobject->xsk->pkt_stream->nb_pkts / 2) {
+-		ksft_print_msg("[%s] tx_invalid_descs incorrect. Got [%u] expected [%u]\n",
+-			       __func__, stats.tx_invalid_descs,
+		ksft_print_msg("[%s] tx_invalid_descs incorrect. Got [%llu] expected [%u]\n",
+			       __func__,
+			       (unsigned long long)stats.tx_invalid_descs,
+ 			       ifobject->xsk->pkt_stream->nb_pkts);
+ 		return TEST_FAILURE;
+ 	}
+-- 
+2.34.1
+
--- a/ci/diffs/0002-xdp-bonding-Fix-feature-flags-when-there-are-no-slav.patch
+++ b/ci/diffs/0002-xdp-bonding-Fix-feature-flags-when-there-are-no-slav.patch
@@ -1,56 +0,0 @@
-From f267f262815033452195f46c43b572159262f533 Mon Sep 17 00:00:00 2001
-From: Daniel Borkmann <daniel@iogearbox.net>
-Date: Tue, 5 Mar 2024 10:08:28 +0100
-Subject: [PATCH 2/2] xdp, bonding: Fix feature flags when there are no slave
- devs anymore
-MIME-Version: 1.0
-Content-Type: text/plain; charset=UTF-8
-Content-Transfer-Encoding: 8bit
-
-Commit 9b0ed890ac2a ("bonding: do not report NETDEV_XDP_ACT_XSK_ZEROCOPY")
-changed the driver from reporting everything as supported before a device
-was bonded into having the driver report that no XDP feature is supported
-until a real device is bonded as it seems to be more truthful given
-eventually real underlying devices decide what XDP features are supported.
-
-The change however did not take into account when all slave devices get
-removed from the bond device. In this case after 9b0ed890ac2a, the driver
-keeps reporting a feature mask of 0x77, that is, NETDEV_XDP_ACT_MASK &
-~NETDEV_XDP_ACT_XSK_ZEROCOPY whereas it should have reported a feature
-mask of 0.
-
-Fix it by resetting XDP feature flags in the same way as if no XDP program
-is attached to the bond device. This was uncovered by the XDP bond selftest
-which let BPF CI fail. After adjusting the starting masks on the latter
-to 0 instead of NETDEV_XDP_ACT_MASK the test passes again together with
-this fix.
-
-Fixes: 9b0ed890ac2a ("bonding: do not report NETDEV_XDP_ACT_XSK_ZEROCOPY")
-Signed-off-by: Daniel Borkmann <daniel@iogearbox.net>
-Cc: Magnus Karlsson <magnus.karlsson@intel.com>
-Cc: Prashant Batra <prbatra.mail@gmail.com>
-Cc: Toke Høiland-Jørgensen <toke@redhat.com>
-Cc: Jakub Kicinski <kuba@kernel.org>
-Reviewed-by: Toke Høiland-Jørgensen <toke@redhat.com>
-Message-ID: <20240305090829.17131-1-daniel@iogearbox.net>
-Signed-off-by: Alexei Starovoitov <ast@kernel.org>
---
- drivers/net/bonding/bond_main.c | 2 +-
- 1 file changed, 1 insertion(+), 1 deletion(-)
-
-diff --git a/drivers/net/bonding/bond_main.c b/drivers/net/bonding/bond_main.c
-index a11748b8d69b..cd0683bcca03 100644
--- a/drivers/net/bonding/bond_main.c
-+++ b/drivers/net/bonding/bond_main.c
-@@ -1811,7 +1811,7 @@ void bond_xdp_set_features(struct net_device *bond_dev)
- 
- 	ASSERT_RTNL();
- 
-	if (!bond_xdp_check(bond)) {
-+	if (!bond_xdp_check(bond) || !bond_has_slaves(bond)) {
- 		xdp_clear_features_flag(bond_dev);
- 		return;
- 	}
-- 
-2.43.0
-
--- a/ci/vmtest/configs/ALLOWLIST-5.5.0
+++ b/ci/vmtest/configs/ALLOWLIST-5.5.0
@@ -41,7 +41,7 @@ task_fd_query_rawtp
 task_fd_query_tp
 tc_bpf
 tcp_estats
-test_global_funcs/arg_tag_ctx*
+tcp_rtt
 tp_attach_query
 usdt/urand_pid_attach
 xdp
--- a/ci/vmtest/configs/DENYLIST
+++ b/ci/vmtest/configs/DENYLIST
@@ -1,14 +0,0 @@
-# TEMPORARY
-btf_dump/btf_dump: syntax
-kprobe_multi_bench_attach
-core_reloc/enum64val
-core_reloc/size___diff_sz
-core_reloc/type_based___diff_sz
-test_ima	# All of CI is broken on it following 6.3-rc1 merge
-
-lwt_reroute      # crashes kernel after netnext merge from 2ab1efad60ad "net/sched: cls_api: complement tcf_tfilter_dump_policy"
-tc_links_ingress # started failing after net-next merge from 2ab1efad60ad "net/sched: cls_api: complement tcf_tfilter_dump_policy"
-xdp_bonding/xdp_bonding_features     # started failing after net merge from 359e54a93ab4 "l2tp: pass correct message length to ip6_append_data"
-tc_redirect/tc_redirect_dtime # uapi breakage after net-next commit 885c36e59f46 ("net: Re-use and set mono_delivery_time bit for userspace tstamp packets")
-migrate_reuseport/IPv4 TCP_NEW_SYN_RECV reqsk_timer_handler # flaky, under investigation
-migrate_reuseport/IPv6 TCP_NEW_SYN_RECV reqsk_timer_handler # flaky, under investigation
--- a/ci/vmtest/configs/DENYLIST-latest
+++ b/ci/vmtest/configs/DENYLIST-latest
@@ -10,4 +10,3 @@ send_signal/send_signal_nmi_thread

 lwt_reroute # crashes kernel, fix pending upstream
 tc_links_ingress # fails, same fix is pending upstream
-tc_redirect		  # enough is enough, banned for life for flakiness
--- a/ci/vmtest/configs/DENYLIST-latest.s390x
+++ b/ci/vmtest/configs/DENYLIST-latest.s390x
@@ -2,16 +2,3 @@
 sockmap_listen/sockhash VSOCK test_vsock_redir
 usdt/basic                               # failing verifier due to bounds check after LLVM update
 usdt/multispec                           # same as above
-
-deny_namespace                           # not yet in bpf denylist
-tc_redirect/tc_redirect_dtime            # very flaky
-lru_bug                                  # not yet in bpf-next denylist
-
-# Disabled temporarily for a crash.
-# https://lore.kernel.org/bpf/c9923c1d-971d-4022-8dc8-1364e929d34c@gmail.com/
-dummy_st_ops/dummy_init_ptr_arg
-fexit_bpf2bpf
-tailcalls
-trace_ext
-xdp_bpf2bpf
-xdp_metadata
--- a/docs/libbpf_overview.rst
+++ b/docs/libbpf_overview.rst
@@ -219,14 +219,6 @@ compilation and skeleton generation. Using Libbpf-rs will make building user
 space part of the BPF application easier. Note that the BPF program themselves
 must still be written in plain C.

-libbpf logging
-==============
-
-By default, libbpf logs informational and warning messages to stderr. The
-verbosity of these messages can be controlled by setting the environment
-variable LIBBPF_LOG_LEVEL to either warn, info, or debug. A custom log
-callback can be set using ``libbpf_set_print()``.
-
 Additional Documentation
 ========================

--- a/include/linux/filter.h
+++ b/include/linux/filter.h
@@ -37,14 +37,6 @@
 		.off   = 0,					\
 		.imm   = IMM })

-#define BPF_CALL_REL(DST)					\
-	((struct bpf_insn) {					\
-		.code = BPF_JMP | BPF_CALL,			\
-		.dst_reg = 0,					\
-		.src_reg = BPF_PSEUDO_CALL,			\
-		.off = 0,					\
-		.imm = DST })
-
 #define BPF_EXIT_INSN()						\
 	((struct bpf_insn) {					\
 		.code  = BPF_JMP | BPF_EXIT,			\
--- a/include/linux/kernel.h
+++ b/include/linux/kernel.h
@@ -3,8 +3,6 @@
 #ifndef __LINUX_KERNEL_H
 #define __LINUX_KERNEL_H

-#include <linux/compiler.h>
-
 #ifndef offsetof
 #define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER)
 #endif
--- a/include/uapi/linux/bpf.h
+++ b/include/uapi/linux/bpf.h
@@ -42,7 +42,6 @@
 #define BPF_JSGE	0x70	/* SGE is signed '>=', GE in x86 */
 #define BPF_JSLT	0xc0	/* SLT is signed, '<' */
 #define BPF_JSLE	0xd0	/* SLE is signed, '<=' */
-#define BPF_JCOND	0xe0	/* conditional pseudo jumps: may_goto, goto_or_nop */
 #define BPF_CALL	0x80	/* function call */
 #define BPF_EXIT	0x90	/* function return */

@@ -51,10 +50,6 @@
 #define BPF_XCHG	(0xe0 | BPF_FETCH)	/* atomic exchange */
 #define BPF_CMPXCHG	(0xf0 | BPF_FETCH)	/* atomic compare-and-write */

-enum bpf_cond_pseudo_jmp {
-	BPF_MAY_GOTO = 0,
-};
-
 /* Register numbers */
 enum {
 	BPF_REG_0 = 0,
@@ -82,29 +77,12 @@ struct bpf_insn {
 	__s32	imm;		/* signed immediate constant */
 };

-/* Deprecated: use struct bpf_lpm_trie_key_u8 (when the "data" member is needed for
- * byte access) or struct bpf_lpm_trie_key_hdr (when using an alternative type for
- * the trailing flexible array member) instead.
- */
+/* Key of an a BPF_MAP_TYPE_LPM_TRIE entry */
 struct bpf_lpm_trie_key {
 	__u32	prefixlen;	/* up to 32 for AF_INET, 128 for AF_INET6 */
 	__u8	data[0];	/* Arbitrary size */
 };

-/* Header for bpf_lpm_trie_key structs */
-struct bpf_lpm_trie_key_hdr {
-	__u32	prefixlen;
-};
-
-/* Key of an a BPF_MAP_TYPE_LPM_TRIE entry, with trailing byte array. */
-struct bpf_lpm_trie_key_u8 {
-	union {
-		struct bpf_lpm_trie_key_hdr	hdr;
-		__u32				prefixlen;
-	};
-	__u8	data[];		/* Arbitrary size */
-};
-
 struct bpf_cgroup_storage_key {
 	__u64	cgroup_inode_id;	/* cgroup inode id */
 	__u32	attach_type;		/* program attach type (enum bpf_attach_type) */
@@ -639,11 +617,7 @@ union bpf_iter_link_info {
 *		to NULL to begin the batched operation. After each subsequent
 *		**BPF_MAP_LOOKUP_BATCH**, the caller should pass the resultant
 *		*out_batch* as the *in_batch* for the next operation to
- *		continue iteration from the current point. Both *in_batch* and
- *		*out_batch* must point to memory large enough to hold a key,
- *		except for maps of type **BPF_MAP_TYPE_{HASH, PERCPU_HASH,
- *		LRU_HASH, LRU_PERCPU_HASH}**, for which batch parameters
- *		must be at least 4 bytes wide regardless of key size.
+ *		continue iteration from the current point.
 *
 *		The *keys* and *values* are output parameters which must point
 *		to memory large enough to hold *count* items based on the key
@@ -873,36 +847,6 @@ union bpf_iter_link_info {
 *		Returns zero on success. On error, -1 is returned and *errno*
 *		is set appropriately.
 *
- * BPF_TOKEN_CREATE
- *	Description
- *		Create BPF token with embedded information about what
- *		BPF-related functionality it allows:
- *		- a set of allowed bpf() syscall commands;
- *		- a set of allowed BPF map types to be created with
- *		BPF_MAP_CREATE command, if BPF_MAP_CREATE itself is allowed;
- *		- a set of allowed BPF program types and BPF program attach
- *		types to be loaded with BPF_PROG_LOAD command, if
- *		BPF_PROG_LOAD itself is allowed.
- *
- *		BPF token is created (derived) from an instance of BPF FS,
- *		assuming it has necessary delegation mount options specified.
- *		This BPF token can be passed as an extra parameter to various
- *		bpf() syscall commands to grant BPF subsystem functionality to
- *		unprivileged processes.
- *
- *		When created, BPF token is "associated" with the owning
- *		user namespace of BPF FS instance (super block) that it was
- *		derived from, and subsequent BPF operations performed with
- *		BPF token would be performing capabilities checks (i.e.,
- *		CAP_BPF, CAP_PERFMON, CAP_NET_ADMIN, CAP_SYS_ADMIN) within
- *		that user namespace. Without BPF token, such capabilities
- *		have to be granted in init user namespace, making bpf()
- *		syscall incompatible with user namespace, for the most part.
- *
- *	Return
- *		A new file descriptor (a nonnegative integer), or -1 if an
- *		error occurred (in which case, *errno* is set appropriately).
- *
 * NOTES
 *	eBPF objects (maps and programs) can be shared between processes.
 *
@@ -957,8 +901,6 @@ enum bpf_cmd {
 	BPF_ITER_CREATE,
 	BPF_LINK_DETACH,
 	BPF_PROG_BIND_MAP,
-	BPF_TOKEN_CREATE,
-	__MAX_BPF_CMD,
 };

 enum bpf_map_type {
@@ -1009,8 +951,6 @@ enum bpf_map_type {
 	BPF_MAP_TYPE_BLOOM_FILTER,
 	BPF_MAP_TYPE_USER_RINGBUF,
 	BPF_MAP_TYPE_CGRP_STORAGE,
-	BPF_MAP_TYPE_ARENA,
-	__MAX_BPF_MAP_TYPE
 };

 /* Note that tracing related programs such as
@@ -1055,7 +995,6 @@ enum bpf_prog_type {
 	BPF_PROG_TYPE_SK_LOOKUP,
 	BPF_PROG_TYPE_SYSCALL, /* a program that can execute syscalls */
 	BPF_PROG_TYPE_NETFILTER,
-	__MAX_BPF_PROG_TYPE
 };

 enum bpf_attach_type {
@@ -1115,7 +1054,6 @@ enum bpf_attach_type {
 	BPF_CGROUP_UNIX_GETSOCKNAME,
 	BPF_NETKIT_PRIMARY,
 	BPF_NETKIT_PEER,
-	BPF_TRACE_KPROBE_SESSION,
 	__MAX_BPF_ATTACH_TYPE
 };

@@ -1136,7 +1074,6 @@ enum bpf_link_type {
 	BPF_LINK_TYPE_TCX = 11,
 	BPF_LINK_TYPE_UPROBE_MULTI = 12,
 	BPF_LINK_TYPE_NETKIT = 13,
-	BPF_LINK_TYPE_SOCKMAP = 14,
 	__MAX_BPF_LINK_TYPE,
 };

@@ -1341,10 +1278,6 @@ enum {
 */
 #define BPF_PSEUDO_KFUNC_CALL	2

-enum bpf_addr_space_cast {
-	BPF_ADDR_SPACE_CAST = 1,
-};
-
 /* flags for BPF_MAP_UPDATE_ELEM command */
 enum {
 	BPF_ANY		= 0, /* create new element or update existing */
@@ -1397,18 +1330,6 @@ enum {

 /* Get path from provided FD in BPF_OBJ_PIN/BPF_OBJ_GET commands */
 	BPF_F_PATH_FD		= (1U << 14),
-
-/* Flag for value_type_btf_obj_fd, the fd is available */
-	BPF_F_VTYPE_BTF_OBJ_FD	= (1U << 15),
-
-/* BPF token FD is passed in a corresponding command's token_fd field */
-	BPF_F_TOKEN_FD          = (1U << 16),
-
-/* When user space page faults in bpf_arena send SIGSEGV instead of inserting new page */
-	BPF_F_SEGV_ON_FAULT	= (1U << 17),
-
-/* Do not translate kernel bpf_arena pointers to user pointers */
-	BPF_F_NO_USER_CONV	= (1U << 18),
 };

 /* Flags for BPF_PROG_QUERY. */
@@ -1425,8 +1346,6 @@ enum {
 #define BPF_F_TEST_RUN_ON_CPU	(1U << 0)
 /* If set, XDP frames will be transmitted after processing */
 #define BPF_F_TEST_XDP_LIVE_FRAMES	(1U << 1)
-/* If set, apply CHECKSUM_COMPLETE to skb and validate the checksum */
-#define BPF_F_TEST_SKB_CHECKSUM_COMPLETE	(1U << 2)

 /* type for BPF_ENABLE_STATS */
 enum bpf_stats_type {
@@ -1482,20 +1401,8 @@ union bpf_attr {
 		 * BPF_MAP_TYPE_BLOOM_FILTER - the lowest 4 bits indicate the
 		 * number of hash functions (if 0, the bloom filter will default
 		 * to using 5 hash functions).
-		 *
-		 * BPF_MAP_TYPE_ARENA - contains the address where user space
-		 * is going to mmap() the arena. It has to be page aligned.
 		 */
 		__u64	map_extra;
-
-		__s32   value_type_btf_obj_fd;	/* fd pointing to a BTF
-						 * type data for
-						 * btf_vmlinux_value_type_id.
-						 */
-		/* BPF token FD to use with BPF_MAP_CREATE operation.
-		 * If provided, map_flags should have BPF_F_TOKEN_FD flag set.
-		 */
-		__s32	map_token_fd;
 	};

 	struct { /* anonymous struct used by BPF_MAP_*_ELEM commands */
@@ -1565,10 +1472,6 @@ union bpf_attr {
 		 * truncated), or smaller (if log buffer wasn't filled completely).
 		 */
 		__u32		log_true_size;
-		/* BPF token FD to use with BPF_PROG_LOAD operation.
-		 * If provided, prog_flags should have BPF_F_TOKEN_FD flag set.
-		 */
-		__s32		prog_token_fd;
 	};

 	struct { /* anonymous struct used by BPF_OBJ_* commands */
@@ -1666,10 +1569,8 @@ union bpf_attr {
 	} query;

 	struct { /* anonymous struct used by BPF_RAW_TRACEPOINT_OPEN command */
-		__u64		name;
-		__u32		prog_fd;
-		__u32		:32;
-		__aligned_u64	cookie;
+		__u64 name;
+		__u32 prog_fd;
 	} raw_tracepoint;

 	struct { /* anonymous struct for BPF_BTF_LOAD */
@@ -1683,11 +1584,6 @@ union bpf_attr {
 		 * truncated), or smaller (if log buffer wasn't filled completely).
 		 */
 		__u32		btf_log_true_size;
-		__u32		btf_flags;
-		/* BPF token FD to use with BPF_BTF_LOAD operation.
-		 * If provided, btf_flags should have BPF_F_TOKEN_FD flag set.
-		 */
-		__s32		btf_token_fd;
 	};

 	struct {
@@ -1818,11 +1714,6 @@ union bpf_attr {
 		__u32		flags;		/* extra flags */
 	} prog_bind_map;

-	struct { /* struct used by BPF_TOKEN_CREATE command */
-		__u32		flags;
-		__u32		bpffs_fd;
-	} token_create;
-
 } __attribute__((aligned(8)));

 /* The description below is an attempt at providing documentation to eBPF
@@ -3398,10 +3289,6 @@ union bpf_attr {
 *			for the nexthop. If the src addr cannot be derived,
 *			**BPF_FIB_LKUP_RET_NO_SRC_ADDR** is returned. In this
 *			case, *params*->dmac and *params*->smac are not set either.
- *		**BPF_FIB_LOOKUP_MARK**
- *			Use the mark present in *params*->mark for the fib lookup.
- *			This option should not be used with BPF_FIB_LOOKUP_DIRECT,
- *			as it only has meaning for full lookups.
 *
 *		*ctx* is either **struct xdp_md** for XDP programs or
 *		**struct sk_buff** tc cls_act programs.
@@ -4952,9 +4839,9 @@ union bpf_attr {
 * 		going through the CPU's backlog queue.
 *
 * 		The *flags* argument is reserved and must be 0. The helper is
- * 		currently only supported for tc BPF program types at the
- * 		ingress hook and for veth and netkit target device types. The
- * 		peer device must reside in a different network namespace.
+ * 		currently only supported for tc BPF program types at the ingress
+ * 		hook and for veth device types. The peer device must reside in a
+ * 		different network namespace.
 * 	Return
 * 		The helper returns **TC_ACT_REDIRECT** on success or
 * 		**TC_ACT_SHOT** on error.
@@ -5030,7 +4917,7 @@ union bpf_attr {
 *		bytes will be copied to *dst*
 *	Return
 *		The **hash_algo** is returned on success,
- *		**-EOPNOTSUPP** if IMA is disabled or **-EINVAL** if
+ *		**-EOPNOTSUP** if IMA is disabled or **-EINVAL** if
 *		invalid arguments are passed.
 *
 * struct socket *bpf_sock_from_file(struct file *file)
@@ -5516,7 +5403,7 @@ union bpf_attr {
 *		bytes will be copied to *dst*
 *	Return
 *		The **hash_algo** is returned on success,
- *		**-EOPNOTSUPP** if the hash calculation failed or **-EINVAL** if
+ *		**-EOPNOTSUP** if the hash calculation failed or **-EINVAL** if
 *		invalid arguments are passed.
 *
 * void *bpf_kptr_xchg(void *map_value, void *ptr)
@@ -6209,17 +6096,12 @@ union {					\
 	__u64 :64;			\
 } __attribute__((aligned(8)))

-/* The enum used in skb->tstamp_type. It specifies the clock type
- * of the time stored in the skb->tstamp.
- */
 enum {
-	BPF_SKB_TSTAMP_UNSPEC = 0,		/* DEPRECATED */
-	BPF_SKB_TSTAMP_DELIVERY_MONO = 1,	/* DEPRECATED */
-	BPF_SKB_CLOCK_REALTIME = 0,
-	BPF_SKB_CLOCK_MONOTONIC = 1,
-	BPF_SKB_CLOCK_TAI = 2,
-	/* For any future BPF_SKB_CLOCK_* that the bpf prog cannot handle,
-	 * the bpf prog can try to deduce it by ingress/egress/skb->sk->sk_clockid.
+	BPF_SKB_TSTAMP_UNSPEC,
+	BPF_SKB_TSTAMP_DELIVERY_MONO,	/* tstamp has mono delivery time */
+	/* For any BPF_SKB_TSTAMP_* that the bpf prog cannot handle,
+	 * the bpf prog should handle it like BPF_SKB_TSTAMP_UNSPEC
+	 * and try to deduce it by ingress, egress or skb->sk->sk_clockid.
 	 */
 };

@@ -6605,7 +6487,7 @@ struct bpf_map_info {
 	__u32 btf_id;
 	__u32 btf_key_type_id;
 	__u32 btf_value_type_id;
-	__u32 btf_vmlinux_id;
+	__u32 :32;	/* alignment pad */
 	__u64 map_extra;
 } __attribute__((aligned(8)));

@@ -6681,7 +6563,6 @@ struct bpf_link_info {
 			__u32 count; /* in/out: kprobe_multi function count */
 			__u32 flags;
 			__u64 missed;
-			__aligned_u64 cookies;
 		} kprobe_multi;
 		struct {
 			__aligned_u64 path;
@@ -6701,7 +6582,6 @@ struct bpf_link_info {
 					__aligned_u64 file_name; /* in/out */
 					__u32 name_len;
 					__u32 offset; /* offset from file_name */
-					__u64 cookie;
 				} uprobe; /* BPF_PERF_EVENT_UPROBE, BPF_PERF_EVENT_URETPROBE */
 				struct {
 					__aligned_u64 func_name; /* in/out */
@@ -6709,19 +6589,14 @@ struct bpf_link_info {
 					__u32 offset; /* offset from func_name */
 					__u64 addr;
 					__u64 missed;
-					__u64 cookie;
 				} kprobe; /* BPF_PERF_EVENT_KPROBE, BPF_PERF_EVENT_KRETPROBE */
 				struct {
 					__aligned_u64 tp_name;   /* in/out */
 					__u32 name_len;
-					__u32 :32;
-					__u64 cookie;
 				} tracepoint; /* BPF_PERF_EVENT_TRACEPOINT */
 				struct {
 					__u64 config;
 					__u32 type;
-					__u32 :32;
-					__u64 cookie;
 				} event; /* BPF_PERF_EVENT_EVENT */
 			};
 		} perf_event;
@@ -6733,10 +6608,6 @@ struct bpf_link_info {
 			__u32 ifindex;
 			__u32 attach_type;
 		} netkit;
-		struct {
-			__u32 map_id;
-			__u32 attach_type;
-		} sockmap;
 	};
 } __attribute__((aligned(8)));

@@ -6955,8 +6826,6 @@ enum {
 					 * socket transition to LISTEN state.
 					 */
 	BPF_SOCK_OPS_RTT_CB,		/* Called on every RTT.
-					 * Arg1: measured RTT input (mrtt)
-					 * Arg2: updated srtt
 					 */
 	BPF_SOCK_OPS_PARSE_HDR_OPT_CB,	/* Parse the header option.
 					 * It will be called to handle
@@ -7035,7 +6904,6 @@ enum {
 	BPF_TCP_LISTEN,
 	BPF_TCP_CLOSING,	/* Now a valid state */
 	BPF_TCP_NEW_SYN_RECV,
-	BPF_TCP_BOUND_INACTIVE,

 	BPF_TCP_MAX_STATES	/* Leave at the end! */
 };
@@ -7139,7 +7007,6 @@ enum {
 	BPF_FIB_LOOKUP_SKIP_NEIGH = (1U << 2),
 	BPF_FIB_LOOKUP_TBID    = (1U << 3),
 	BPF_FIB_LOOKUP_SRC     = (1U << 4),
-	BPF_FIB_LOOKUP_MARK    = (1U << 5),
 };

 enum {
@@ -7172,7 +7039,7 @@ struct bpf_fib_lookup {

 		/* output: MTU value */
 		__u16	mtu_result;
-	} __attribute__((packed, aligned(2)));
+	};
 	/* input: L3 device index for lookup
 	 * output: device index from FIB lookup
 	 */
@@ -7217,19 +7084,8 @@ struct bpf_fib_lookup {
 		__u32	tbid;
 	};

-	union {
-		/* input */
-		struct {
-			__u32	mark;   /* policy routing */
-			/* 2 4-byte holes for input */
-		};
-
-		/* output: source and dest mac */
-		struct {
-			__u8	smac[6];	/* ETH_ALEN */
-			__u8	dmac[6];	/* ETH_ALEN */
-		};
-	};
+	__u8	smac[6];     /* ETH_ALEN */
+	__u8	dmac[6];     /* ETH_ALEN */
 };

 struct bpf_redir_neigh {
@@ -7316,10 +7172,6 @@ struct bpf_timer {
 	__u64 __opaque[2];
 } __attribute__((aligned(8)));

-struct bpf_wq {
-	__u64 __opaque[2];
-} __attribute__((aligned(8)));
-
 struct bpf_dynptr {
 	__u64 __opaque[2];
 } __attribute__((aligned(8)));
--- a/include/uapi/linux/fcntl.h
+++ b/include/uapi/linux/fcntl.h
@@ -0,0 +1,120 @@
+/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
+#ifndef _UAPI_LINUX_FCNTL_H
+#define _UAPI_LINUX_FCNTL_H
+
+#include <asm/fcntl.h>
+#include <linux/openat2.h>
+
+#define F_SETLEASE	(F_LINUX_SPECIFIC_BASE + 0)
+#define F_GETLEASE	(F_LINUX_SPECIFIC_BASE + 1)
+
+/*
+ * Cancel a blocking posix lock; internal use only until we expose an
+ * asynchronous lock api to userspace:
+ */
+#define F_CANCELLK	(F_LINUX_SPECIFIC_BASE + 5)
+
+/* Create a file descriptor with FD_CLOEXEC set. */
+#define F_DUPFD_CLOEXEC	(F_LINUX_SPECIFIC_BASE + 6)
+
+/*
+ * Request nofications on a directory.
+ * See below for events that may be notified.
+ */
+#define F_NOTIFY	(F_LINUX_SPECIFIC_BASE+2)
+
+/*
+ * Set and get of pipe page size array
+ */
+#define F_SETPIPE_SZ	(F_LINUX_SPECIFIC_BASE + 7)
+#define F_GETPIPE_SZ	(F_LINUX_SPECIFIC_BASE + 8)
+
+/*
+ * Set/Get seals
+ */
+#define F_ADD_SEALS	(F_LINUX_SPECIFIC_BASE + 9)
+#define F_GET_SEALS	(F_LINUX_SPECIFIC_BASE + 10)
+
+/*
+ * Types of seals
+ */
+#define F_SEAL_SEAL	0x0001	/* prevent further seals from being set */
+#define F_SEAL_SHRINK	0x0002	/* prevent file from shrinking */
+#define F_SEAL_GROW	0x0004	/* prevent file from growing */
+#define F_SEAL_WRITE	0x0008	/* prevent writes */
+#define F_SEAL_FUTURE_WRITE	0x0010  /* prevent future writes while mapped */
+#define F_SEAL_EXEC	0x0020  /* prevent chmod modifying exec bits */
+/* (1U << 31) is reserved for signed error codes */
+
+/*
+ * Set/Get write life time hints. {GET,SET}_RW_HINT operate on the
+ * underlying inode, while {GET,SET}_FILE_RW_HINT operate only on
+ * the specific file.
+ */
+#define F_GET_RW_HINT		(F_LINUX_SPECIFIC_BASE + 11)
+#define F_SET_RW_HINT		(F_LINUX_SPECIFIC_BASE + 12)
+#define F_GET_FILE_RW_HINT	(F_LINUX_SPECIFIC_BASE + 13)
+#define F_SET_FILE_RW_HINT	(F_LINUX_SPECIFIC_BASE + 14)
+
+/*
+ * Valid hint values for F_{GET,SET}_RW_HINT. 0 is "not set", or can be
+ * used to clear any hints previously set.
+ */
+#define RWH_WRITE_LIFE_NOT_SET	0
+#define RWH_WRITE_LIFE_NONE	1
+#define RWH_WRITE_LIFE_SHORT	2
+#define RWH_WRITE_LIFE_MEDIUM	3
+#define RWH_WRITE_LIFE_LONG	4
+#define RWH_WRITE_LIFE_EXTREME	5
+
+/*
+ * The originally introduced spelling is remained from the first
+ * versions of the patch set that introduced the feature, see commit
+ * v4.13-rc1~212^2~51.
+ */
+#define RWF_WRITE_LIFE_NOT_SET	RWH_WRITE_LIFE_NOT_SET
+
+/*
+ * Types of directory notifications that may be requested.
+ */
+#define DN_ACCESS	0x00000001	/* File accessed */
+#define DN_MODIFY	0x00000002	/* File modified */
+#define DN_CREATE	0x00000004	/* File created */
+#define DN_DELETE	0x00000008	/* File removed */
+#define DN_RENAME	0x00000010	/* File renamed */
+#define DN_ATTRIB	0x00000020	/* File changed attibutes */
+#define DN_MULTISHOT	0x80000000	/* Don't remove notifier */
+
+/*
+ * The constants AT_REMOVEDIR and AT_EACCESS have the same value.  AT_EACCESS is
+ * meaningful only to faccessat, while AT_REMOVEDIR is meaningful only to
+ * unlinkat.  The two functions do completely different things and therefore,
+ * the flags can be allowed to overlap.  For example, passing AT_REMOVEDIR to
+ * faccessat would be undefined behavior and thus treating it equivalent to
+ * AT_EACCESS is valid undefined behavior.
+ */
+#define AT_FDCWD		-100    /* Special value used to indicate
+                                           openat should use the current
+                                           working directory. */
+#define AT_SYMLINK_NOFOLLOW	0x100   /* Do not follow symbolic links.  */
+#define AT_EACCESS		0x200	/* Test access permitted for
+                                           effective IDs, not real IDs.  */
+#define AT_REMOVEDIR		0x200   /* Remove directory instead of
+                                           unlinking file.  */
+#define AT_SYMLINK_FOLLOW	0x400   /* Follow symbolic links.  */
+#define AT_NO_AUTOMOUNT		0x800	/* Suppress terminal automount traversal */
+#define AT_EMPTY_PATH		0x1000	/* Allow empty relative pathname */
+
+#define AT_STATX_SYNC_TYPE	0x6000	/* Type of synchronisation required from statx() */
+#define AT_STATX_SYNC_AS_STAT	0x0000	/* - Do whatever stat() does */
+#define AT_STATX_FORCE_SYNC	0x2000	/* - Force the attributes to be sync'd with the server */
+#define AT_STATX_DONT_SYNC	0x4000	/* - Don't sync attributes with the server */
+
+#define AT_RECURSIVE		0x8000	/* Apply to the entire subtree */
+
+/* Flags for name_to_handle_at(2). We reuse AT_ flag space to save bits... */
+#define AT_HANDLE_FID		AT_REMOVEDIR	/* file handle is needed to
+					compare object identity and may not
+					be usable to open_by_handle_at(2) */
+
+#endif /* _UAPI_LINUX_FCNTL_H */
--- a/include/uapi/linux/if_link.h
+++ b/include/uapi/linux/if_link.h
@@ -974,7 +974,6 @@ enum {
 	IFLA_BOND_AD_LACP_ACTIVE,
 	IFLA_BOND_MISSED_MAX,
 	IFLA_BOND_NS_IP6_TARGET,
-	IFLA_BOND_COUPLED_CONTROL,
 	__IFLA_BOND_MAX,
 };

--- a/include/uapi/linux/netdev.h
+++ b/include/uapi/linux/netdev.h
@@ -63,6 +63,9 @@ enum netdev_xdp_rx_metadata {
 enum netdev_xsk_flags {
 	NETDEV_XSK_FLAGS_TX_TIMESTAMP = 1,
 	NETDEV_XSK_FLAGS_TX_CHECKSUM = 2,
+
+	/* private: */
+	NETDEV_XSK_FLAGS_MASK = 3,
 };

 enum netdev_queue_type {
@@ -70,10 +73,6 @@ enum netdev_queue_type {
 	NETDEV_QUEUE_TYPE_TX,
 };

-enum netdev_qstats_scope {
-	NETDEV_QSTATS_SCOPE_QUEUE = 1,
-};
-
 enum {
 	NETDEV_A_DEV_IFINDEX = 1,
 	NETDEV_A_DEV_PAD,
@@ -136,43 +135,6 @@ enum {
 	NETDEV_A_QUEUE_MAX = (__NETDEV_A_QUEUE_MAX - 1)
 };

-enum {
-	NETDEV_A_QSTATS_IFINDEX = 1,
-	NETDEV_A_QSTATS_QUEUE_TYPE,
-	NETDEV_A_QSTATS_QUEUE_ID,
-	NETDEV_A_QSTATS_SCOPE,
-	NETDEV_A_QSTATS_RX_PACKETS = 8,
-	NETDEV_A_QSTATS_RX_BYTES,
-	NETDEV_A_QSTATS_TX_PACKETS,
-	NETDEV_A_QSTATS_TX_BYTES,
-	NETDEV_A_QSTATS_RX_ALLOC_FAIL,
-	NETDEV_A_QSTATS_RX_HW_DROPS,
-	NETDEV_A_QSTATS_RX_HW_DROP_OVERRUNS,
-	NETDEV_A_QSTATS_RX_CSUM_COMPLETE,
-	NETDEV_A_QSTATS_RX_CSUM_UNNECESSARY,
-	NETDEV_A_QSTATS_RX_CSUM_NONE,
-	NETDEV_A_QSTATS_RX_CSUM_BAD,
-	NETDEV_A_QSTATS_RX_HW_GRO_PACKETS,
-	NETDEV_A_QSTATS_RX_HW_GRO_BYTES,
-	NETDEV_A_QSTATS_RX_HW_GRO_WIRE_PACKETS,
-	NETDEV_A_QSTATS_RX_HW_GRO_WIRE_BYTES,
-	NETDEV_A_QSTATS_RX_HW_DROP_RATELIMITS,
-	NETDEV_A_QSTATS_TX_HW_DROPS,
-	NETDEV_A_QSTATS_TX_HW_DROP_ERRORS,
-	NETDEV_A_QSTATS_TX_CSUM_NONE,
-	NETDEV_A_QSTATS_TX_NEEDS_CSUM,
-	NETDEV_A_QSTATS_TX_HW_GSO_PACKETS,
-	NETDEV_A_QSTATS_TX_HW_GSO_BYTES,
-	NETDEV_A_QSTATS_TX_HW_GSO_WIRE_PACKETS,
-	NETDEV_A_QSTATS_TX_HW_GSO_WIRE_BYTES,
-	NETDEV_A_QSTATS_TX_HW_DROP_RATELIMITS,
-	NETDEV_A_QSTATS_TX_STOP,
-	NETDEV_A_QSTATS_TX_WAKE,
-
-	__NETDEV_A_QSTATS_MAX,
-	NETDEV_A_QSTATS_MAX = (__NETDEV_A_QSTATS_MAX - 1)
-};
-
 enum {
 	NETDEV_CMD_DEV_GET = 1,
 	NETDEV_CMD_DEV_ADD_NTF,
@@ -185,7 +147,6 @@ enum {
 	NETDEV_CMD_PAGE_POOL_STATS_GET,
 	NETDEV_CMD_QUEUE_GET,
 	NETDEV_CMD_NAPI_GET,
-	NETDEV_CMD_QSTATS_GET,

 	__NETDEV_CMD_MAX,
 	NETDEV_CMD_MAX = (__NETDEV_CMD_MAX - 1)
--- a/include/uapi/linux/openat2.h
+++ b/include/uapi/linux/openat2.h
@@ -0,0 +1,43 @@
+/* SPDX-License-Identifier: GPL-2.0 WITH Linux-syscall-note */
+#ifndef _UAPI_LINUX_OPENAT2_H
+#define _UAPI_LINUX_OPENAT2_H
+
+#include <linux/types.h>
+
+/*
+ * Arguments for how openat2(2) should open the target path. If only @flags and
+ * @mode are non-zero, then openat2(2) operates very similarly to openat(2).
+ *
+ * However, unlike openat(2), unknown or invalid bits in @flags result in
+ * -EINVAL rather than being silently ignored. @mode must be zero unless one of
+ * {O_CREAT, O_TMPFILE} are set.
+ *
+ * @flags: O_* flags.
+ * @mode: O_CREAT/O_TMPFILE file mode.
+ * @resolve: RESOLVE_* flags.
+ */
+struct open_how {
+	__u64 flags;
+	__u64 mode;
+	__u64 resolve;
+};
+
+/* how->resolve flags for openat2(2). */
+#define RESOLVE_NO_XDEV		0x01 /* Block mount-point crossings
+					(includes bind-mounts). */
+#define RESOLVE_NO_MAGICLINKS	0x02 /* Block traversal through procfs-style
+					"magic-links". */
+#define RESOLVE_NO_SYMLINKS	0x04 /* Block traversal through all symlinks
+					(implies OEXT_NO_MAGICLINKS) */
+#define RESOLVE_BENEATH		0x08 /* Block "lexical" trickery like
+					"..", symlinks, and absolute
+					paths which escape the dirfd. */
+#define RESOLVE_IN_ROOT		0x10 /* Make all jumps to "/" and ".."
+					be scoped inside the dirfd
+					(similar to chroot(2)). */
+#define RESOLVE_CACHED		0x20 /* Only complete if resolution can be
+					completed through cached lookup. May
+					return -EAGAIN if that's not
+					possible. */
+
+#endif /* _UAPI_LINUX_OPENAT2_H */
--- a/include/uapi/linux/perf_event.h
+++ b/include/uapi/linux/perf_event.h
@@ -204,8 +204,6 @@ enum perf_branch_sample_type_shift {

 	PERF_SAMPLE_BRANCH_PRIV_SAVE_SHIFT	= 18, /* save privilege mode */

-	PERF_SAMPLE_BRANCH_COUNTERS_SHIFT	= 19, /* save occurrences of events on a branch */
-
 	PERF_SAMPLE_BRANCH_MAX_SHIFT		/* non-ABI */
 };

@@ -237,8 +235,6 @@ enum perf_branch_sample_type {

 	PERF_SAMPLE_BRANCH_PRIV_SAVE	= 1U << PERF_SAMPLE_BRANCH_PRIV_SAVE_SHIFT,

-	PERF_SAMPLE_BRANCH_COUNTERS	= 1U << PERF_SAMPLE_BRANCH_COUNTERS_SHIFT,
-
 	PERF_SAMPLE_BRANCH_MAX		= 1U << PERF_SAMPLE_BRANCH_MAX_SHIFT,
 };

@@ -986,12 +982,6 @@ enum perf_event_type {
 	 *	{ u64                   nr;
 	 *	  { u64	hw_idx; } && PERF_SAMPLE_BRANCH_HW_INDEX
 	 *        { u64 from, to, flags } lbr[nr];
-	 *        #
-	 *        # The format of the counters is decided by the
-	 *        # "branch_counter_nr" and "branch_counter_width",
-	 *        # which are defined in the ABI.
-	 *        #
-	 *        { u64 counters; } cntr[nr] && PERF_SAMPLE_BRANCH_COUNTERS
 	 *      } && PERF_SAMPLE_BRANCH_STACK
 	 *
 	 * 	{ u64			abi; # enum perf_sample_regs_abi
@@ -1437,9 +1427,6 @@ struct perf_branch_entry {
 		reserved:31;
 };

-/* Size of used info bits in struct perf_branch_entry */
-#define PERF_BRANCH_ENTRY_INFO_BITS_MAX		33
-
 union perf_sample_weight {
 	__u64		full;
 #if defined(__LITTLE_ENDIAN_BITFIELD)
--- a/scripts/mailmap-update.sh
+++ b/scripts/mailmap-update.sh
@@ -1,37 +0,0 @@
-#!/usr/bin/env bash
-
-set -eu
-
-usage () {
-    echo "USAGE: ./mailmap-update.sh <libbpf-repo> <linux-repo>"
-    exit 1
-}
-
-LIBBPF_REPO="${1-""}"
-LINUX_REPO="${2-""}"
-
-if [ -z "${LIBBPF_REPO}" ] || [ -z "${LINUX_REPO}" ]; then
-    echo "Error: libbpf or linux repos are not specified"
-    usage
-fi
-
-LIBBPF_MAILMAP="${LIBBPF_REPO}/.mailmap"
-LINUX_MAILMAP="${LINUX_REPO}/.mailmap"
-
-tmpfile="$(mktemp)"
-cleanup() {
-    rm -f "${tmpfile}"
-}
-trap cleanup EXIT
-
-grep_lines() {
-    local pattern="$1"
-    local file="$2"
-    grep "${pattern}" "${file}" || true
-}
-
-while read -r email; do
-    grep_lines "${email}$" "${LINUX_MAILMAP}" >> "${tmpfile}"
-done < <(git log --format='<%ae>' | sort -u)
-
-sort -u "${tmpfile}" > "${LIBBPF_MAILMAP}"
--- a/scripts/sync-kernel.sh
+++ b/scripts/sync-kernel.sh
@@ -295,22 +295,6 @@ Latest changes to BPF helper definitions.
 " -- src/bpf_helper_defs.h
 fi

-echo "Regenerating .mailmap..."
-cd_to "${LINUX_REPO}"
-git checkout "${TIP_SYM_REF}"
-cd_to "${LIBBPF_REPO}"
-"${LIBBPF_REPO}"/scripts/mailmap-update.sh "${LIBBPF_REPO}" "${LINUX_REPO}"
-# if anything changed, commit it
-mailmap_changes=$(git status --porcelain .mailmap | wc -l)
-if ((${mailmap_changes} == 1)); then
-	git add .mailmap
-	git commit -s -m "sync: update .mailmap
-
-Update .mailmap based on libbpf's list of contributors and on the latest
-.mailmap version in the upstream repository.
-" -- .mailmap
-fi
-
 # Use generated cover-letter as a template for "sync commit" with
 # baseline and checkpoint commits from kernel repo (and leave summary
 # from cover letter intact, of course)
--- a/src/Makefile
+++ b/src/Makefile
@@ -9,7 +9,7 @@ else
 endif

 LIBBPF_MAJOR_VERSION := 1
-LIBBPF_MINOR_VERSION := 5
+LIBBPF_MINOR_VERSION := 4
 LIBBPF_PATCH_VERSION := 0
 LIBBPF_VERSION := $(LIBBPF_MAJOR_VERSION).$(LIBBPF_MINOR_VERSION).$(LIBBPF_PATCH_VERSION)
 LIBBPF_MAJMIN_VERSION := $(LIBBPF_MAJOR_VERSION).$(LIBBPF_MINOR_VERSION).0
@@ -55,7 +55,7 @@ STATIC_OBJDIR := $(OBJDIR)/staticobjs
 OBJS := bpf.o btf.o libbpf.o libbpf_errno.o netlink.o \
 	nlattr.o str_error.o libbpf_probes.o bpf_prog_linfo.o \
 	btf_dump.o hashmap.o ringbuf.o strset.o linker.o gen_loader.o \
-	relo_core.o usdt.o zip.o elf.o features.o btf_iter.o btf_relocate.o
+	relo_core.o usdt.o zip.o elf.o
 SHARED_OBJS := $(addprefix $(SHARED_OBJDIR)/,$(OBJS))
 STATIC_OBJS := $(addprefix $(STATIC_OBJDIR)/,$(OBJS))

--- a/src/bpf.c
+++ b/src/bpf.c
@@ -103,9 +103,9 @@ int sys_bpf_prog_load(union bpf_attr *attr, unsigned int size, int attempts)
 *   [0] https://lore.kernel.org/bpf/20201201215900.3569844-1-guro@fb.com/
 *   [1] d05512618056 ("bpf: Add bpf_ktime_get_coarse_ns helper")
 */
-int probe_memcg_account(int token_fd)
+int probe_memcg_account(void)
 {
-	const size_t attr_sz = offsetofend(union bpf_attr, prog_token_fd);
+	const size_t attr_sz = offsetofend(union bpf_attr, attach_btf_obj_fd);
 	struct bpf_insn insns[] = {
 		BPF_EMIT_CALL(BPF_FUNC_ktime_get_coarse_ns),
 		BPF_EXIT_INSN(),
@@ -120,9 +120,6 @@ int probe_memcg_account(int token_fd)
 	attr.insns = ptr_to_u64(insns);
 	attr.insn_cnt = insn_cnt;
 	attr.license = ptr_to_u64("GPL");
-	attr.prog_token_fd = token_fd;
-	if (token_fd)
-		attr.prog_flags |= BPF_F_TOKEN_FD;

 	prog_fd = sys_bpf_fd(BPF_PROG_LOAD, &attr, attr_sz);
 	if (prog_fd >= 0) {
@@ -149,7 +146,7 @@ int bump_rlimit_memlock(void)
 	struct rlimit rlim;

 	/* if kernel supports memcg-based accounting, skip bumping RLIMIT_MEMLOCK */
-	if (memlock_bumped || feat_supported(NULL, FEAT_MEMCG_ACCOUNT))
+	if (memlock_bumped || kernel_supports(NULL, FEAT_MEMCG_ACCOUNT))
 		return 0;

 	memlock_bumped = true;
@@ -172,7 +169,7 @@ int bpf_map_create(enum bpf_map_type map_type,
 		   __u32 max_entries,
 		   const struct bpf_map_create_opts *opts)
 {
-	const size_t attr_sz = offsetofend(union bpf_attr, map_token_fd);
+	const size_t attr_sz = offsetofend(union bpf_attr, map_extra);
 	union bpf_attr attr;
 	int fd;

@@ -184,7 +181,7 @@ int bpf_map_create(enum bpf_map_type map_type,
 		return libbpf_err(-EINVAL);

 	attr.map_type = map_type;
-	if (map_name && feat_supported(NULL, FEAT_PROG_NAME))
+	if (map_name && kernel_supports(NULL, FEAT_PROG_NAME))
 		libbpf_strlcpy(attr.map_name, map_name, sizeof(attr.map_name));
 	attr.key_size = key_size;
 	attr.value_size = value_size;
@@ -194,7 +191,6 @@ int bpf_map_create(enum bpf_map_type map_type,
 	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.value_type_btf_obj_fd = OPTS_GET(opts, value_type_btf_obj_fd, 0);

 	attr.inner_map_fd = OPTS_GET(opts, inner_map_fd, 0);
 	attr.map_flags = OPTS_GET(opts, map_flags, 0);
@@ -202,8 +198,6 @@ int bpf_map_create(enum bpf_map_type map_type,
 	attr.numa_node = OPTS_GET(opts, numa_node, 0);
 	attr.map_ifindex = OPTS_GET(opts, map_ifindex, 0);

-	attr.map_token_fd = OPTS_GET(opts, token_fd, 0);
-
 	fd = sys_bpf_fd(BPF_MAP_CREATE, &attr, attr_sz);
 	return libbpf_err_errno(fd);
 }
@@ -238,7 +232,7 @@ int bpf_prog_load(enum bpf_prog_type prog_type,
 		  const struct bpf_insn *insns, size_t insn_cnt,
 		  struct bpf_prog_load_opts *opts)
 {
-	const size_t attr_sz = offsetofend(union bpf_attr, prog_token_fd);
+	const size_t attr_sz = offsetofend(union bpf_attr, log_true_size);
 	void *finfo = NULL, *linfo = NULL;
 	const char *func_info, *line_info;
 	__u32 log_size, log_level, attach_prog_fd, attach_btf_obj_fd;
@@ -267,9 +261,8 @@ int bpf_prog_load(enum bpf_prog_type prog_type,
 	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);
-	attr.prog_token_fd = OPTS_GET(opts, token_fd, 0);

-	if (prog_name && feat_supported(NULL, FEAT_PROG_NAME))
+	if (prog_name && kernel_supports(NULL, FEAT_PROG_NAME))
 		libbpf_strlcpy(attr.prog_name, prog_name, sizeof(attr.prog_name));
 	attr.license = ptr_to_u64(license);

@@ -766,7 +759,6 @@ int bpf_link_create(int prog_fd, int target_fd,
 			return libbpf_err(-EINVAL);
 		break;
 	case BPF_TRACE_KPROBE_MULTI:
-	case BPF_TRACE_KPROBE_SESSION:
 		attr.link_create.kprobe_multi.flags = OPTS_GET(opts, kprobe_multi.flags, 0);
 		attr.link_create.kprobe_multi.cnt = OPTS_GET(opts, kprobe_multi.cnt, 0);
 		attr.link_create.kprobe_multi.syms = ptr_to_u64(OPTS_GET(opts, kprobe_multi.syms, 0));
@@ -786,7 +778,6 @@ int bpf_link_create(int prog_fd, int target_fd,
 		if (!OPTS_ZEROED(opts, uprobe_multi))
 			return libbpf_err(-EINVAL);
 		break;
-	case BPF_TRACE_RAW_TP:
 	case BPF_TRACE_FENTRY:
 	case BPF_TRACE_FEXIT:
 	case BPF_MODIFY_RETURN:
@@ -1175,34 +1166,23 @@ int bpf_link_get_info_by_fd(int link_fd, struct bpf_link_info *info, __u32 *info
 	return bpf_obj_get_info_by_fd(link_fd, info, info_len);
 }

-int bpf_raw_tracepoint_open_opts(int prog_fd, struct bpf_raw_tp_opts *opts)
+int bpf_raw_tracepoint_open(const char *name, int prog_fd)
 {
 	const size_t attr_sz = offsetofend(union bpf_attr, raw_tracepoint);
 	union bpf_attr attr;
 	int fd;

-	if (!OPTS_VALID(opts, bpf_raw_tp_opts))
-		return libbpf_err(-EINVAL);
-
 	memset(&attr, 0, attr_sz);
+	attr.raw_tracepoint.name = ptr_to_u64(name);
 	attr.raw_tracepoint.prog_fd = prog_fd;
-	attr.raw_tracepoint.name = ptr_to_u64(OPTS_GET(opts, tp_name, NULL));
-	attr.raw_tracepoint.cookie = OPTS_GET(opts, cookie, 0);

 	fd = sys_bpf_fd(BPF_RAW_TRACEPOINT_OPEN, &attr, attr_sz);
 	return libbpf_err_errno(fd);
 }

-int bpf_raw_tracepoint_open(const char *name, int prog_fd)
-{
-	LIBBPF_OPTS(bpf_raw_tp_opts, opts, .tp_name = name);
-
-	return bpf_raw_tracepoint_open_opts(prog_fd, &opts);
-}
-
 int bpf_btf_load(const void *btf_data, size_t btf_size, struct bpf_btf_load_opts *opts)
 {
-	const size_t attr_sz = offsetofend(union bpf_attr, btf_token_fd);
+	const size_t attr_sz = offsetofend(union bpf_attr, btf_log_true_size);
 	union bpf_attr attr;
 	char *log_buf;
 	size_t log_size;
@@ -1227,10 +1207,6 @@ int bpf_btf_load(const void *btf_data, size_t btf_size, struct bpf_btf_load_opts

 	attr.btf = ptr_to_u64(btf_data);
 	attr.btf_size = btf_size;
-
-	attr.btf_flags = OPTS_GET(opts, btf_flags, 0);
-	attr.btf_token_fd = OPTS_GET(opts, token_fd, 0);
-
 	/* log_level == 0 and log_buf != NULL means "try loading without
 	 * log_buf, but retry with log_buf and log_level=1 on error", which is
 	 * consistent across low-level and high-level BTF and program loading
@@ -1311,20 +1287,3 @@ int bpf_prog_bind_map(int prog_fd, int map_fd,
 	ret = sys_bpf(BPF_PROG_BIND_MAP, &attr, attr_sz);
 	return libbpf_err_errno(ret);
 }
-
-int bpf_token_create(int bpffs_fd, struct bpf_token_create_opts *opts)
-{
-	const size_t attr_sz = offsetofend(union bpf_attr, token_create);
-	union bpf_attr attr;
-	int fd;
-
-	if (!OPTS_VALID(opts, bpf_token_create_opts))
-		return libbpf_err(-EINVAL);
-
-	memset(&attr, 0, attr_sz);
-	attr.token_create.bpffs_fd = bpffs_fd;
-	attr.token_create.flags = OPTS_GET(opts, flags, 0);
-
-	fd = sys_bpf_fd(BPF_TOKEN_CREATE, &attr, attr_sz);
-	return libbpf_err_errno(fd);
-}
--- a/src/bpf.h
+++ b/src/bpf.h
@@ -35,7 +35,7 @@
 extern "C" {
 #endif

-LIBBPF_API int libbpf_set_memlock_rlim(size_t memlock_bytes);
+int libbpf_set_memlock_rlim(size_t memlock_bytes);

 struct bpf_map_create_opts {
 	size_t sz; /* size of this struct for forward/backward compatibility */
@@ -51,12 +51,8 @@ struct bpf_map_create_opts {

 	__u32 numa_node;
 	__u32 map_ifindex;
-	__s32 value_type_btf_obj_fd;
-
-	__u32 token_fd;
-	size_t :0;
 };
-#define bpf_map_create_opts__last_field token_fd
+#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,
@@ -106,10 +102,9 @@ struct bpf_prog_load_opts {
 	 * If kernel doesn't support this feature, log_size is left unchanged.
 	 */
 	__u32 log_true_size;
-	__u32 token_fd;
 	size_t :0;
 };
-#define bpf_prog_load_opts__last_field token_fd
+#define bpf_prog_load_opts__last_field log_true_size

 LIBBPF_API int bpf_prog_load(enum bpf_prog_type prog_type,
 			     const char *prog_name, const char *license,
@@ -135,12 +130,9 @@ struct bpf_btf_load_opts {
 	 * If kernel doesn't support this feature, log_size is left unchanged.
 	 */
 	__u32 log_true_size;
-
-	__u32 btf_flags;
-	__u32 token_fd;
 	size_t :0;
 };
-#define bpf_btf_load_opts__last_field token_fd
+#define bpf_btf_load_opts__last_field log_true_size

 LIBBPF_API int bpf_btf_load(const void *btf_data, size_t btf_size,
 			    struct bpf_btf_load_opts *opts);
@@ -190,14 +182,10 @@ LIBBPF_API int bpf_map_delete_batch(int fd, const void *keys,
 /**
 * @brief **bpf_map_lookup_batch()** allows for batch lookup of BPF map elements.
 *
- * The parameter *in_batch* is the address of the first element in the batch to
- * read. *out_batch* is an output parameter that should be passed as *in_batch*
- * to subsequent calls to **bpf_map_lookup_batch()**. NULL can be passed for
- * *in_batch* to indicate that the batched lookup starts from the beginning of
- * the map. Both *in_batch* and *out_batch* must point to memory large enough to
- * hold a single key, except for maps of type **BPF_MAP_TYPE_{HASH, PERCPU_HASH,
- * LRU_HASH, LRU_PERCPU_HASH}**, for which the memory size must be at
- * least 4 bytes wide regardless of key size.
+ * The parameter *in_batch* is the address of the first element in the batch to read.
+ * *out_batch* is an output parameter that should be passed as *in_batch* to subsequent
+ * calls to **bpf_map_lookup_batch()**. NULL can be passed for *in_batch* to indicate
+ * that the batched lookup starts from the beginning of the map.
 *
 * The *keys* and *values* are output parameters which must point to memory large enough to
 * hold *count* items based on the key and value size of the map *map_fd*. The *keys*
@@ -230,10 +218,7 @@ LIBBPF_API int bpf_map_lookup_batch(int fd, void *in_batch, void *out_batch,
 *
 * @param fd BPF map file descriptor
 * @param in_batch address of the first element in batch to read, can pass NULL to
- * get address of the first element in *out_batch*. If not NULL, must be large
- * enough to hold a key. For **BPF_MAP_TYPE_{HASH, PERCPU_HASH, LRU_HASH,
- * LRU_PERCPU_HASH}**, the memory size must be at least 4 bytes wide regardless
- * of key size.
+ * get address of the first element in *out_batch*
 * @param out_batch output parameter that should be passed to next call as *in_batch*
 * @param keys pointer to an array of *count* keys
 * @param values pointer to an array large enough for *count* values
@@ -507,10 +492,7 @@ LIBBPF_API int bpf_obj_get_info_by_fd(int bpf_fd, void *info, __u32 *info_len);
 * program corresponding to *prog_fd*.
 *
 * Populates up to *info_len* bytes of *info* and updates *info_len* with the
- * actual number of bytes written to *info*. Note that *info* should be
- * zero-initialized or initialized as expected by the requested *info*
- * type. Failing to (zero-)initialize *info* under certain circumstances can
- * result in this helper returning an error.
+ * actual number of bytes written to *info*.
 *
 * @param prog_fd BPF program file descriptor
 * @param info pointer to **struct bpf_prog_info** that will be populated with
@@ -527,10 +509,7 @@ LIBBPF_API int bpf_prog_get_info_by_fd(int prog_fd, struct bpf_prog_info *info,
 * map corresponding to *map_fd*.
 *
 * Populates up to *info_len* bytes of *info* and updates *info_len* with the
- * actual number of bytes written to *info*. Note that *info* should be
- * zero-initialized or initialized as expected by the requested *info*
- * type. Failing to (zero-)initialize *info* under certain circumstances can
- * result in this helper returning an error.
+ * actual number of bytes written to *info*.
 *
 * @param map_fd BPF map file descriptor
 * @param info pointer to **struct bpf_map_info** that will be populated with
@@ -543,14 +522,11 @@ LIBBPF_API int bpf_prog_get_info_by_fd(int prog_fd, struct bpf_prog_info *info,
 LIBBPF_API int bpf_map_get_info_by_fd(int map_fd, struct bpf_map_info *info, __u32 *info_len);

 /**
- * @brief **bpf_btf_get_info_by_fd()** obtains information about the
+ * @brief **bpf_btf_get_info_by_fd()** obtains information about the 
 * BTF object corresponding to *btf_fd*.
 *
 * Populates up to *info_len* bytes of *info* and updates *info_len* with the
- * actual number of bytes written to *info*. Note that *info* should be
- * zero-initialized or initialized as expected by the requested *info*
- * type. Failing to (zero-)initialize *info* under certain circumstances can
- * result in this helper returning an error.
+ * actual number of bytes written to *info*.
 *
 * @param btf_fd BTF object file descriptor
 * @param info pointer to **struct bpf_btf_info** that will be populated with
@@ -567,10 +543,7 @@ LIBBPF_API int bpf_btf_get_info_by_fd(int btf_fd, struct bpf_btf_info *info, __u
 * link corresponding to *link_fd*.
 *
 * Populates up to *info_len* bytes of *info* and updates *info_len* with the
- * actual number of bytes written to *info*. Note that *info* should be
- * zero-initialized or initialized as expected by the requested *info*
- * type. Failing to (zero-)initialize *info* under certain circumstances can
- * result in this helper returning an error.
+ * actual number of bytes written to *info*.
 *
 * @param link_fd BPF link file descriptor
 * @param info pointer to **struct bpf_link_info** that will be populated with
@@ -617,15 +590,6 @@ LIBBPF_API int bpf_prog_query(int target_fd, enum bpf_attach_type type,
 			      __u32 query_flags, __u32 *attach_flags,
 			      __u32 *prog_ids, __u32 *prog_cnt);

-struct bpf_raw_tp_opts {
-	size_t sz; /* size of this struct for forward/backward compatibility */
-	const char *tp_name;
-	__u64 cookie;
-	size_t :0;
-};
-#define bpf_raw_tp_opts__last_field cookie
-
-LIBBPF_API int bpf_raw_tracepoint_open_opts(int prog_fd, struct bpf_raw_tp_opts *opts);
 LIBBPF_API int bpf_raw_tracepoint_open(const char *name, int prog_fd);
 LIBBPF_API int bpf_task_fd_query(int pid, int fd, __u32 flags, char *buf,
 				 __u32 *buf_len, __u32 *prog_id, __u32 *fd_type,
@@ -676,30 +640,6 @@ struct bpf_test_run_opts {
 LIBBPF_API int bpf_prog_test_run_opts(int prog_fd,
 				      struct bpf_test_run_opts *opts);

-struct bpf_token_create_opts {
-	size_t sz; /* size of this struct for forward/backward compatibility */
-	__u32 flags;
-	size_t :0;
-};
-#define bpf_token_create_opts__last_field flags
-
-/**
- * @brief **bpf_token_create()** creates a new instance of BPF token derived
- * from specified BPF FS mount point.
- *
- * BPF token created with this API can be passed to bpf() syscall for
- * commands like BPF_PROG_LOAD, BPF_MAP_CREATE, etc.
- *
- * @param bpffs_fd FD for BPF FS instance from which to derive a BPF token
- * instance.
- * @param opts optional BPF token creation options, can be NULL
- *
- * @return BPF token FD > 0, on success; negative error code, otherwise (errno
- * is also set to the error code)
- */
-LIBBPF_API int bpf_token_create(int bpffs_fd,
-				struct bpf_token_create_opts *opts);
-
 #ifdef __cplusplus
 } /* extern "C" */
 #endif
--- a/src/bpf_core_read.h
+++ b/src/bpf_core_read.h
@@ -2,8 +2,6 @@
 #ifndef __BPF_CORE_READ_H__
 #define __BPF_CORE_READ_H__

-#include "bpf_helpers.h"
-
 /*
 * enum bpf_field_info_kind is passed as a second argument into
 * __builtin_preserve_field_info() built-in to get a specific aspect of
@@ -46,7 +44,7 @@ enum bpf_enum_value_kind {
 #if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
 #define __CORE_BITFIELD_PROBE_READ(dst, src, fld)			      \
 	bpf_probe_read_kernel(						      \
-			(void *)dst,					      \
+			(void *)dst,				      \
 			__CORE_RELO(src, fld, BYTE_SIZE),		      \
 			(const void *)src + __CORE_RELO(src, fld, BYTE_OFFSET))
 #else
@@ -104,7 +102,6 @@ enum bpf_enum_value_kind {
 	case 2: val = *(const unsigned short *)p; break;		      \
 	case 4: val = *(const unsigned int *)p; break;			      \
 	case 8: val = *(const unsigned long long *)p; break;		      \
-	default: val = 0; break;					      \
 	}								      \
 	val <<= __CORE_RELO(s, field, LSHIFT_U64);			      \
 	if (__CORE_RELO(s, field, SIGNED))				      \
@@ -146,29 +143,8 @@ enum bpf_enum_value_kind {
 	}								\
 })

-/* Differentiator between compilers builtin implementations. This is a
- * requirement due to the compiler parsing differences where GCC optimizes
- * early in parsing those constructs of type pointers to the builtin specific
- * type, resulting in not being possible to collect the required type
- * information in the builtin expansion.
- */
-#ifdef __clang__
-#define ___bpf_typeof(type) ((typeof(type) *) 0)
-#else
-#define ___bpf_typeof1(type, NR) ({					    \
-	extern typeof(type) *___concat(bpf_type_tmp_, NR);		    \
-	___concat(bpf_type_tmp_, NR);					    \
-})
-#define ___bpf_typeof(type) ___bpf_typeof1(type, __COUNTER__)
-#endif
-
-#ifdef __clang__
 #define ___bpf_field_ref1(field)	(field)
-#define ___bpf_field_ref2(type, field)	(___bpf_typeof(type)->field)
-#else
-#define ___bpf_field_ref1(field)	(&(field))
-#define ___bpf_field_ref2(type, field)	(&(___bpf_typeof(type)->field))
-#endif
+#define ___bpf_field_ref2(type, field)	(((typeof(type) *)0)->field)
 #define ___bpf_field_ref(args...)					    \
 	___bpf_apply(___bpf_field_ref, ___bpf_narg(args))(args)

@@ -218,7 +194,7 @@ enum bpf_enum_value_kind {
 * BTF. Always succeeds.
 */
 #define bpf_core_type_id_local(type)					    \
-	__builtin_btf_type_id(*___bpf_typeof(type), BPF_TYPE_ID_LOCAL)
+	__builtin_btf_type_id(*(typeof(type) *)0, BPF_TYPE_ID_LOCAL)

 /*
 * Convenience macro to get BTF type ID of a target kernel's type that matches
@@ -228,7 +204,7 @@ enum bpf_enum_value_kind {
 *    - 0, if no matching type was found in a target kernel BTF.
 */
 #define bpf_core_type_id_kernel(type)					    \
-	__builtin_btf_type_id(*___bpf_typeof(type), BPF_TYPE_ID_TARGET)
+	__builtin_btf_type_id(*(typeof(type) *)0, BPF_TYPE_ID_TARGET)

 /*
 * Convenience macro to check that provided named type
@@ -238,7 +214,7 @@ enum bpf_enum_value_kind {
 *    0, if no matching type is found.
 */
 #define bpf_core_type_exists(type)					    \
-	__builtin_preserve_type_info(*___bpf_typeof(type), BPF_TYPE_EXISTS)
+	__builtin_preserve_type_info(*(typeof(type) *)0, BPF_TYPE_EXISTS)

 /*
 * Convenience macro to check that provided named type
@@ -248,7 +224,7 @@ enum bpf_enum_value_kind {
 *    0, if the type does not match any in the target kernel
 */
 #define bpf_core_type_matches(type)					    \
-	__builtin_preserve_type_info(*___bpf_typeof(type), BPF_TYPE_MATCHES)
+	__builtin_preserve_type_info(*(typeof(type) *)0, BPF_TYPE_MATCHES)

 /*
 * Convenience macro to get the byte size of a provided named type
@@ -258,7 +234,7 @@ enum bpf_enum_value_kind {
 *    0, if no matching type is found.
 */
 #define bpf_core_type_size(type)					    \
-	__builtin_preserve_type_info(*___bpf_typeof(type), BPF_TYPE_SIZE)
+	__builtin_preserve_type_info(*(typeof(type) *)0, BPF_TYPE_SIZE)

 /*
 * Convenience macro to check that provided enumerator value is defined in
@@ -268,13 +244,8 @@ enum bpf_enum_value_kind {
 *    kernel's BTF;
 *    0, if no matching enum and/or enum value within that enum is found.
 */
-#ifdef __clang__
 #define bpf_core_enum_value_exists(enum_type, enum_value)		    \
 	__builtin_preserve_enum_value(*(typeof(enum_type) *)enum_value, BPF_ENUMVAL_EXISTS)
-#else
-#define bpf_core_enum_value_exists(enum_type, enum_value)		    \
-	__builtin_preserve_enum_value(___bpf_typeof(enum_type), enum_value, BPF_ENUMVAL_EXISTS)
-#endif

 /*
 * Convenience macro to get the integer value of an enumerator value in
@@ -284,13 +255,8 @@ enum bpf_enum_value_kind {
 *    present in target kernel's BTF;
 *    0, if no matching enum and/or enum value within that enum is found.
 */
-#ifdef __clang__
 #define bpf_core_enum_value(enum_type, enum_value)			    \
 	__builtin_preserve_enum_value(*(typeof(enum_type) *)enum_value, BPF_ENUMVAL_VALUE)
-#else
-#define bpf_core_enum_value(enum_type, enum_value)			    \
-	__builtin_preserve_enum_value(___bpf_typeof(enum_type), enum_value, BPF_ENUMVAL_VALUE)
-#endif

 /*
 * bpf_core_read() abstracts away bpf_probe_read_kernel() call and captures
@@ -302,7 +268,7 @@ enum bpf_enum_value_kind {
 * a relocation, which records BTF type ID describing root struct/union and an
 * accessor string which describes exact embedded field that was used to take
 * an address. See detailed description of this relocation format and
- * semantics in comments to struct bpf_core_relo in include/uapi/linux/bpf.h.
+ * semantics in comments to struct bpf_field_reloc in libbpf_internal.h.
 *
 * This relocation allows libbpf to adjust BPF instruction to use correct
 * actual field offset, based on target kernel BTF type that matches original
@@ -326,17 +292,6 @@ enum bpf_enum_value_kind {
 #define bpf_core_read_user_str(dst, sz, src)				    \
 	bpf_probe_read_user_str(dst, sz, (const void *)__builtin_preserve_access_index(src))

-extern void *bpf_rdonly_cast(const void *obj, __u32 btf_id) __ksym __weak;
-
-/*
- * Cast provided pointer *ptr* into a pointer to a specified *type* in such
- * a way that BPF verifier will become aware of associated kernel-side BTF
- * type. This allows to access members of kernel types directly without the
- * need to use BPF_CORE_READ() macros.
- */
-#define bpf_core_cast(ptr, type)					    \
-	((typeof(type) *)bpf_rdonly_cast((ptr), bpf_core_type_id_kernel(type)))
-
 #define ___concat(a, b) a ## b
 #define ___apply(fn, n) ___concat(fn, n)
 #define ___nth(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10, __11, N, ...) N
--- a/src/bpf_helper_defs.h
+++ b/src/bpf_helper_defs.h
--- a/src/bpf_helpers.h
+++ b/src/bpf_helpers.h
@@ -13,7 +13,6 @@
 #define __uint(name, val) int (*name)[val]
 #define __type(name, val) typeof(val) *name
 #define __array(name, val) typeof(val) *name[]
-#define __ulong(name, val) enum { ___bpf_concat(__unique_value, __COUNTER__) = val } name

 /*
 * Helper macro to place programs, maps, license in
@@ -137,8 +136,7 @@
 /*
 * Helper function to perform a tail call with a constant/immediate map slot.
 */
-#if (defined(__clang__) && __clang_major__ >= 8) || (!defined(__clang__) && __GNUC__ > 12)
-#if defined(__bpf__)
+#if __clang_major__ >= 8 && defined(__bpf__)
 static __always_inline void
 bpf_tail_call_static(void *ctx, const void *map, const __u32 slot)
 {
@@ -166,7 +164,6 @@ bpf_tail_call_static(void *ctx, const void *map, const __u32 slot)
 		     : "r0", "r1", "r2", "r3", "r4", "r5");
 }
 #endif
-#endif

 enum libbpf_pin_type {
 	LIBBPF_PIN_NONE,
@@ -186,27 +183,13 @@ enum libbpf_tristate {
 #define __kptr __attribute__((btf_type_tag("kptr")))
 #define __percpu_kptr __attribute__((btf_type_tag("percpu_kptr")))

-#if defined (__clang__)
-#define bpf_ksym_exists(sym) ({						\
-	_Static_assert(!__builtin_constant_p(!!sym),			\
-		       #sym " should be marked as __weak");		\
-	!!sym;								\
+#define bpf_ksym_exists(sym) ({									\
+	_Static_assert(!__builtin_constant_p(!!sym), #sym " should be marked as __weak");	\
+	!!sym;											\
 })
-#elif __GNUC__ > 8
-#define bpf_ksym_exists(sym) ({						\
-	_Static_assert(__builtin_has_attribute (*sym, __weak__),	\
-		       #sym " should be marked as __weak");		\
-	!!sym;								\
-})
-#else
-#define bpf_ksym_exists(sym) !!sym
-#endif

 #define __arg_ctx __attribute__((btf_decl_tag("arg:ctx")))
 #define __arg_nonnull __attribute((btf_decl_tag("arg:nonnull")))
-#define __arg_nullable __attribute((btf_decl_tag("arg:nullable")))
-#define __arg_trusted __attribute((btf_decl_tag("arg:trusted")))
-#define __arg_arena __attribute((btf_decl_tag("arg:arena")))

 #ifndef ___bpf_concat
 #define ___bpf_concat(a, b) a ## b
--- a/src/bpf_tracing.h
+++ b/src/bpf_tracing.h
@@ -633,18 +633,18 @@ struct pt_regs;
 #endif

 #define ___bpf_ctx_cast0()            ctx
-#define ___bpf_ctx_cast1(x)           ___bpf_ctx_cast0(), ctx[0]
-#define ___bpf_ctx_cast2(x, args...)  ___bpf_ctx_cast1(args), ctx[1]
-#define ___bpf_ctx_cast3(x, args...)  ___bpf_ctx_cast2(args), ctx[2]
-#define ___bpf_ctx_cast4(x, args...)  ___bpf_ctx_cast3(args), ctx[3]
-#define ___bpf_ctx_cast5(x, args...)  ___bpf_ctx_cast4(args), ctx[4]
-#define ___bpf_ctx_cast6(x, args...)  ___bpf_ctx_cast5(args), ctx[5]
-#define ___bpf_ctx_cast7(x, args...)  ___bpf_ctx_cast6(args), ctx[6]
-#define ___bpf_ctx_cast8(x, args...)  ___bpf_ctx_cast7(args), ctx[7]
-#define ___bpf_ctx_cast9(x, args...)  ___bpf_ctx_cast8(args), ctx[8]
-#define ___bpf_ctx_cast10(x, args...) ___bpf_ctx_cast9(args), ctx[9]
-#define ___bpf_ctx_cast11(x, args...) ___bpf_ctx_cast10(args), ctx[10]
-#define ___bpf_ctx_cast12(x, args...) ___bpf_ctx_cast11(args), ctx[11]
+#define ___bpf_ctx_cast1(x)           ___bpf_ctx_cast0(), (void *)ctx[0]
+#define ___bpf_ctx_cast2(x, args...)  ___bpf_ctx_cast1(args), (void *)ctx[1]
+#define ___bpf_ctx_cast3(x, args...)  ___bpf_ctx_cast2(args), (void *)ctx[2]
+#define ___bpf_ctx_cast4(x, args...)  ___bpf_ctx_cast3(args), (void *)ctx[3]
+#define ___bpf_ctx_cast5(x, args...)  ___bpf_ctx_cast4(args), (void *)ctx[4]
+#define ___bpf_ctx_cast6(x, args...)  ___bpf_ctx_cast5(args), (void *)ctx[5]
+#define ___bpf_ctx_cast7(x, args...)  ___bpf_ctx_cast6(args), (void *)ctx[6]
+#define ___bpf_ctx_cast8(x, args...)  ___bpf_ctx_cast7(args), (void *)ctx[7]
+#define ___bpf_ctx_cast9(x, args...)  ___bpf_ctx_cast8(args), (void *)ctx[8]
+#define ___bpf_ctx_cast10(x, args...) ___bpf_ctx_cast9(args), (void *)ctx[9]
+#define ___bpf_ctx_cast11(x, args...) ___bpf_ctx_cast10(args), (void *)ctx[10]
+#define ___bpf_ctx_cast12(x, args...) ___bpf_ctx_cast11(args), (void *)ctx[11]
 #define ___bpf_ctx_cast(args...)      ___bpf_apply(___bpf_ctx_cast, ___bpf_narg(args))(args)

 /*
@@ -786,14 +786,14 @@ ____##name(unsigned long long *ctx ___bpf_ctx_decl(args))
 struct pt_regs;

 #define ___bpf_kprobe_args0()           ctx
-#define ___bpf_kprobe_args1(x)          ___bpf_kprobe_args0(), (unsigned long long)PT_REGS_PARM1(ctx)
-#define ___bpf_kprobe_args2(x, args...) ___bpf_kprobe_args1(args), (unsigned long long)PT_REGS_PARM2(ctx)
-#define ___bpf_kprobe_args3(x, args...) ___bpf_kprobe_args2(args), (unsigned long long)PT_REGS_PARM3(ctx)
-#define ___bpf_kprobe_args4(x, args...) ___bpf_kprobe_args3(args), (unsigned long long)PT_REGS_PARM4(ctx)
-#define ___bpf_kprobe_args5(x, args...) ___bpf_kprobe_args4(args), (unsigned long long)PT_REGS_PARM5(ctx)
-#define ___bpf_kprobe_args6(x, args...) ___bpf_kprobe_args5(args), (unsigned long long)PT_REGS_PARM6(ctx)
-#define ___bpf_kprobe_args7(x, args...) ___bpf_kprobe_args6(args), (unsigned long long)PT_REGS_PARM7(ctx)
-#define ___bpf_kprobe_args8(x, args...) ___bpf_kprobe_args7(args), (unsigned long long)PT_REGS_PARM8(ctx)
+#define ___bpf_kprobe_args1(x)          ___bpf_kprobe_args0(), (void *)PT_REGS_PARM1(ctx)
+#define ___bpf_kprobe_args2(x, args...) ___bpf_kprobe_args1(args), (void *)PT_REGS_PARM2(ctx)
+#define ___bpf_kprobe_args3(x, args...) ___bpf_kprobe_args2(args), (void *)PT_REGS_PARM3(ctx)
+#define ___bpf_kprobe_args4(x, args...) ___bpf_kprobe_args3(args), (void *)PT_REGS_PARM4(ctx)
+#define ___bpf_kprobe_args5(x, args...) ___bpf_kprobe_args4(args), (void *)PT_REGS_PARM5(ctx)
+#define ___bpf_kprobe_args6(x, args...) ___bpf_kprobe_args5(args), (void *)PT_REGS_PARM6(ctx)
+#define ___bpf_kprobe_args7(x, args...) ___bpf_kprobe_args6(args), (void *)PT_REGS_PARM7(ctx)
+#define ___bpf_kprobe_args8(x, args...) ___bpf_kprobe_args7(args), (void *)PT_REGS_PARM8(ctx)
 #define ___bpf_kprobe_args(args...)     ___bpf_apply(___bpf_kprobe_args, ___bpf_narg(args))(args)

 /*
@@ -821,7 +821,7 @@ static __always_inline typeof(name(0))					    \
 ____##name(struct pt_regs *ctx, ##args)

 #define ___bpf_kretprobe_args0()       ctx
-#define ___bpf_kretprobe_args1(x)      ___bpf_kretprobe_args0(), (unsigned long long)PT_REGS_RC(ctx)
+#define ___bpf_kretprobe_args1(x)      ___bpf_kretprobe_args0(), (void *)PT_REGS_RC(ctx)
 #define ___bpf_kretprobe_args(args...) ___bpf_apply(___bpf_kretprobe_args, ___bpf_narg(args))(args)

 /*
@@ -845,24 +845,24 @@ static __always_inline typeof(name(0)) ____##name(struct pt_regs *ctx, ##args)

 /* If kernel has CONFIG_ARCH_HAS_SYSCALL_WRAPPER, read pt_regs directly */
 #define ___bpf_syscall_args0()           ctx
-#define ___bpf_syscall_args1(x)          ___bpf_syscall_args0(), (unsigned long long)PT_REGS_PARM1_SYSCALL(regs)
-#define ___bpf_syscall_args2(x, args...) ___bpf_syscall_args1(args), (unsigned long long)PT_REGS_PARM2_SYSCALL(regs)
-#define ___bpf_syscall_args3(x, args...) ___bpf_syscall_args2(args), (unsigned long long)PT_REGS_PARM3_SYSCALL(regs)
-#define ___bpf_syscall_args4(x, args...) ___bpf_syscall_args3(args), (unsigned long long)PT_REGS_PARM4_SYSCALL(regs)
-#define ___bpf_syscall_args5(x, args...) ___bpf_syscall_args4(args), (unsigned long long)PT_REGS_PARM5_SYSCALL(regs)
-#define ___bpf_syscall_args6(x, args...) ___bpf_syscall_args5(args), (unsigned long long)PT_REGS_PARM6_SYSCALL(regs)
-#define ___bpf_syscall_args7(x, args...) ___bpf_syscall_args6(args), (unsigned long long)PT_REGS_PARM7_SYSCALL(regs)
+#define ___bpf_syscall_args1(x)          ___bpf_syscall_args0(), (void *)PT_REGS_PARM1_SYSCALL(regs)
+#define ___bpf_syscall_args2(x, args...) ___bpf_syscall_args1(args), (void *)PT_REGS_PARM2_SYSCALL(regs)
+#define ___bpf_syscall_args3(x, args...) ___bpf_syscall_args2(args), (void *)PT_REGS_PARM3_SYSCALL(regs)
+#define ___bpf_syscall_args4(x, args...) ___bpf_syscall_args3(args), (void *)PT_REGS_PARM4_SYSCALL(regs)
+#define ___bpf_syscall_args5(x, args...) ___bpf_syscall_args4(args), (void *)PT_REGS_PARM5_SYSCALL(regs)
+#define ___bpf_syscall_args6(x, args...) ___bpf_syscall_args5(args), (void *)PT_REGS_PARM6_SYSCALL(regs)
+#define ___bpf_syscall_args7(x, args...) ___bpf_syscall_args6(args), (void *)PT_REGS_PARM7_SYSCALL(regs)
 #define ___bpf_syscall_args(args...)     ___bpf_apply(___bpf_syscall_args, ___bpf_narg(args))(args)

 /* If kernel doesn't have CONFIG_ARCH_HAS_SYSCALL_WRAPPER, we have to BPF_CORE_READ from pt_regs */
 #define ___bpf_syswrap_args0()           ctx
-#define ___bpf_syswrap_args1(x)          ___bpf_syswrap_args0(), (unsigned long long)PT_REGS_PARM1_CORE_SYSCALL(regs)
-#define ___bpf_syswrap_args2(x, args...) ___bpf_syswrap_args1(args), (unsigned long long)PT_REGS_PARM2_CORE_SYSCALL(regs)
-#define ___bpf_syswrap_args3(x, args...) ___bpf_syswrap_args2(args), (unsigned long long)PT_REGS_PARM3_CORE_SYSCALL(regs)
-#define ___bpf_syswrap_args4(x, args...) ___bpf_syswrap_args3(args), (unsigned long long)PT_REGS_PARM4_CORE_SYSCALL(regs)
-#define ___bpf_syswrap_args5(x, args...) ___bpf_syswrap_args4(args), (unsigned long long)PT_REGS_PARM5_CORE_SYSCALL(regs)
-#define ___bpf_syswrap_args6(x, args...) ___bpf_syswrap_args5(args), (unsigned long long)PT_REGS_PARM6_CORE_SYSCALL(regs)
-#define ___bpf_syswrap_args7(x, args...) ___bpf_syswrap_args6(args), (unsigned long long)PT_REGS_PARM7_CORE_SYSCALL(regs)
+#define ___bpf_syswrap_args1(x)          ___bpf_syswrap_args0(), (void *)PT_REGS_PARM1_CORE_SYSCALL(regs)
+#define ___bpf_syswrap_args2(x, args...) ___bpf_syswrap_args1(args), (void *)PT_REGS_PARM2_CORE_SYSCALL(regs)
+#define ___bpf_syswrap_args3(x, args...) ___bpf_syswrap_args2(args), (void *)PT_REGS_PARM3_CORE_SYSCALL(regs)
+#define ___bpf_syswrap_args4(x, args...) ___bpf_syswrap_args3(args), (void *)PT_REGS_PARM4_CORE_SYSCALL(regs)
+#define ___bpf_syswrap_args5(x, args...) ___bpf_syswrap_args4(args), (void *)PT_REGS_PARM5_CORE_SYSCALL(regs)
+#define ___bpf_syswrap_args6(x, args...) ___bpf_syswrap_args5(args), (void *)PT_REGS_PARM6_CORE_SYSCALL(regs)
+#define ___bpf_syswrap_args7(x, args...) ___bpf_syswrap_args6(args), (void *)PT_REGS_PARM7_CORE_SYSCALL(regs)
 #define ___bpf_syswrap_args(args...)     ___bpf_apply(___bpf_syswrap_args, ___bpf_narg(args))(args)

 /*
--- a/src/btf.c
+++ b/src/btf.c
@@ -116,9 +116,6 @@ struct btf {
 	/* whether strings are already deduplicated */
 	bool strs_deduped;

-	/* whether base_btf should be freed in btf_free for this instance */
-	bool owns_base;
-
 	/* BTF object FD, if loaded into kernel */
 	int fd;

@@ -601,7 +598,7 @@ static int btf_sanity_check(const struct btf *btf)
 	__u32 i, n = btf__type_cnt(btf);
 	int err;

-	for (i = btf->start_id; i < n; i++) {
+	for (i = 1; i < n; i++) {
 		t = btf_type_by_id(btf, i);
 		err = btf_validate_type(btf, t, i);
 		if (err)
@@ -972,8 +969,6 @@ void btf__free(struct btf *btf)
 	free(btf->raw_data);
 	free(btf->raw_data_swapped);
 	free(btf->type_offs);
-	if (btf->owns_base)
-		btf__free(btf->base_btf);
 	free(btf);
 }

@@ -1084,91 +1079,16 @@ struct btf *btf__new(const void *data, __u32 size)
 	return libbpf_ptr(btf_new(data, size, NULL));
 }

-struct btf *btf__new_split(const void *data, __u32 size, struct btf *base_btf)
-{
-	return libbpf_ptr(btf_new(data, size, base_btf));
-}
-
-struct btf_elf_secs {
-	Elf_Data *btf_data;
-	Elf_Data *btf_ext_data;
-	Elf_Data *btf_base_data;
-};
-
-static int btf_find_elf_sections(Elf *elf, const char *path, struct btf_elf_secs *secs)
-{
-	Elf_Scn *scn = NULL;
-	Elf_Data *data;
-	GElf_Ehdr ehdr;
-	size_t shstrndx;
-	int idx = 0;
-
-	if (!gelf_getehdr(elf, &ehdr)) {
-		pr_warn("failed to get EHDR from %s\n", path);
-		goto err;
-	}
-
-	if (elf_getshdrstrndx(elf, &shstrndx)) {
-		pr_warn("failed to get section names section index for %s\n",
-			path);
-		goto err;
-	}
-
-	if (!elf_rawdata(elf_getscn(elf, shstrndx), NULL)) {
-		pr_warn("failed to get e_shstrndx from %s\n", path);
-		goto err;
-	}
-
-	while ((scn = elf_nextscn(elf, scn)) != NULL) {
-		Elf_Data **field;
-		GElf_Shdr sh;
-		char *name;
-
-		idx++;
-		if (gelf_getshdr(scn, &sh) != &sh) {
-			pr_warn("failed to get section(%d) header from %s\n",
-				idx, path);
-			goto err;
-		}
-		name = elf_strptr(elf, shstrndx, sh.sh_name);
-		if (!name) {
-			pr_warn("failed to get section(%d) name from %s\n",
-				idx, path);
-			goto err;
-		}
-
-		if (strcmp(name, BTF_ELF_SEC) == 0)
-			field = &secs->btf_data;
-		else if (strcmp(name, BTF_EXT_ELF_SEC) == 0)
-			field = &secs->btf_ext_data;
-		else if (strcmp(name, BTF_BASE_ELF_SEC) == 0)
-			field = &secs->btf_base_data;
-		else
-			continue;
-
-		data = elf_getdata(scn, 0);
-		if (!data) {
-			pr_warn("failed to get section(%d, %s) data from %s\n",
-				idx, name, path);
-			goto err;
-		}
-		*field = data;
-	}
-
-	return 0;
-
-err:
-	return -LIBBPF_ERRNO__FORMAT;
-}
-
 static struct btf *btf_parse_elf(const char *path, struct btf *base_btf,
 				 struct btf_ext **btf_ext)
 {
-	struct btf_elf_secs secs = {};
-	struct btf *dist_base_btf = NULL;
+	Elf_Data *btf_data = NULL, *btf_ext_data = NULL;
+	int err = 0, fd = -1, idx = 0;
 	struct btf *btf = NULL;
-	int err = 0, fd = -1;
+	Elf_Scn *scn = NULL;
 	Elf *elf = NULL;
+	GElf_Ehdr ehdr;
+	size_t shstrndx;

 	if (elf_version(EV_CURRENT) == EV_NONE) {
 		pr_warn("failed to init libelf for %s\n", path);
@@ -1182,48 +1102,73 @@ static struct btf *btf_parse_elf(const char *path, struct btf *base_btf,
 		return ERR_PTR(err);
 	}

+	err = -LIBBPF_ERRNO__FORMAT;
+
 	elf = elf_begin(fd, ELF_C_READ, NULL);
 	if (!elf) {
 		pr_warn("failed to open %s as ELF file\n", path);
 		goto done;
 	}
-
-	err = btf_find_elf_sections(elf, path, &secs);
-	if (err)
+	if (!gelf_getehdr(elf, &ehdr)) {
+		pr_warn("failed to get EHDR from %s\n", path);
 		goto done;
+	}

-	if (!secs.btf_data) {
+	if (elf_getshdrstrndx(elf, &shstrndx)) {
+		pr_warn("failed to get section names section index for %s\n",
+			path);
+		goto done;
+	}
+
+	if (!elf_rawdata(elf_getscn(elf, shstrndx), NULL)) {
+		pr_warn("failed to get e_shstrndx from %s\n", path);
+		goto done;
+	}
+
+	while ((scn = elf_nextscn(elf, scn)) != NULL) {
+		GElf_Shdr sh;
+		char *name;
+
+		idx++;
+		if (gelf_getshdr(scn, &sh) != &sh) {
+			pr_warn("failed to get section(%d) header from %s\n",
+				idx, path);
+			goto done;
+		}
+		name = elf_strptr(elf, shstrndx, sh.sh_name);
+		if (!name) {
+			pr_warn("failed to get section(%d) name from %s\n",
+				idx, path);
+			goto done;
+		}
+		if (strcmp(name, BTF_ELF_SEC) == 0) {
+			btf_data = elf_getdata(scn, 0);
+			if (!btf_data) {
+				pr_warn("failed to get section(%d, %s) data from %s\n",
+					idx, name, path);
+				goto done;
+			}
+			continue;
+		} else if (btf_ext && strcmp(name, BTF_EXT_ELF_SEC) == 0) {
+			btf_ext_data = elf_getdata(scn, 0);
+			if (!btf_ext_data) {
+				pr_warn("failed to get section(%d, %s) data from %s\n",
+					idx, name, path);
+				goto done;
+			}
+			continue;
+		}
+	}
+
+	if (!btf_data) {
 		pr_warn("failed to find '%s' ELF section in %s\n", BTF_ELF_SEC, path);
 		err = -ENODATA;
 		goto done;
 	}
-
-	if (secs.btf_base_data) {
-		dist_base_btf = btf_new(secs.btf_base_data->d_buf, secs.btf_base_data->d_size,
-					NULL);
-		if (IS_ERR(dist_base_btf)) {
-			err = PTR_ERR(dist_base_btf);
-			dist_base_btf = NULL;
-			goto done;
-		}
-	}
-
-	btf = btf_new(secs.btf_data->d_buf, secs.btf_data->d_size,
-		      dist_base_btf ?: base_btf);
-	if (IS_ERR(btf)) {
-		err = PTR_ERR(btf);
+	btf = btf_new(btf_data->d_buf, btf_data->d_size, base_btf);
+	err = libbpf_get_error(btf);
+	if (err)
 		goto done;
-	}
-	if (dist_base_btf && base_btf) {
-		err = btf__relocate(btf, base_btf);
-		if (err)
-			goto done;
-		btf__free(dist_base_btf);
-		dist_base_btf = NULL;
-	}
-
-	if (dist_base_btf)
-		btf->owns_base = true;

 	switch (gelf_getclass(elf)) {
 	case ELFCLASS32:
@@ -1237,12 +1182,11 @@ static struct btf *btf_parse_elf(const char *path, struct btf *base_btf,
 		break;
 	}

-	if (btf_ext && secs.btf_ext_data) {
-		*btf_ext = btf_ext__new(secs.btf_ext_data->d_buf, secs.btf_ext_data->d_size);
-		if (IS_ERR(*btf_ext)) {
-			err = PTR_ERR(*btf_ext);
+	if (btf_ext && btf_ext_data) {
+		*btf_ext = btf_ext__new(btf_ext_data->d_buf, btf_ext_data->d_size);
+		err = libbpf_get_error(*btf_ext);
+		if (err)
 			goto done;
-		}
 	} else if (btf_ext) {
 		*btf_ext = NULL;
 	}
@@ -1256,7 +1200,6 @@ done:

 	if (btf_ext)
 		btf_ext__free(*btf_ext);
-	btf__free(dist_base_btf);
 	btf__free(btf);

 	return ERR_PTR(err);
@@ -1374,9 +1317,7 @@ struct btf *btf__parse_split(const char *path, struct btf *base_btf)

 static void *btf_get_raw_data(const struct btf *btf, __u32 *size, bool swap_endian);

-int btf_load_into_kernel(struct btf *btf,
-			 char *log_buf, size_t log_sz, __u32 log_level,
-			 int token_fd)
+int btf_load_into_kernel(struct btf *btf, char *log_buf, size_t log_sz, __u32 log_level)
 {
 	LIBBPF_OPTS(bpf_btf_load_opts, opts);
 	__u32 buf_sz = 0, raw_size;
@@ -1426,10 +1367,6 @@ retry_load:
 		opts.log_level = log_level;
 	}

-	opts.token_fd = token_fd;
-	if (token_fd)
-		opts.btf_flags |= BPF_F_TOKEN_FD;
-
 	btf->fd = bpf_btf_load(raw_data, raw_size, &opts);
 	if (btf->fd < 0) {
 		/* time to turn on verbose mode and try again */
@@ -1457,7 +1394,7 @@ done:

 int btf__load_into_kernel(struct btf *btf)
 {
-	return btf_load_into_kernel(btf, NULL, 0, 0, 0);
+	return btf_load_into_kernel(btf, NULL, 0, 0);
 }

 int btf__fd(const struct btf *btf)
@@ -1791,8 +1728,9 @@ struct btf_pipe {
 	struct hashmap *str_off_map; /* map string offsets from src to dst */
 };

-static int btf_rewrite_str(struct btf_pipe *p, __u32 *str_off)
+static int btf_rewrite_str(__u32 *str_off, void *ctx)
 {
+	struct btf_pipe *p = ctx;
 	long mapped_off;
 	int off, err;

@@ -1822,11 +1760,10 @@ static int btf_rewrite_str(struct btf_pipe *p, __u32 *str_off)
 	return 0;
 }

-static int btf_add_type(struct btf_pipe *p, const struct btf_type *src_type)
+int btf__add_type(struct btf *btf, const struct btf *src_btf, const struct btf_type *src_type)
 {
-	struct btf_field_iter it;
+	struct btf_pipe p = { .src = src_btf, .dst = btf };
 	struct btf_type *t;
-	__u32 *str_off;
 	int sz, err;

 	sz = btf_type_size(src_type);
@@ -1834,33 +1771,35 @@ static int btf_add_type(struct btf_pipe *p, const struct btf_type *src_type)
 		return libbpf_err(sz);

 	/* deconstruct BTF, if necessary, and invalidate raw_data */
-	if (btf_ensure_modifiable(p->dst))
+	if (btf_ensure_modifiable(btf))
 		return libbpf_err(-ENOMEM);

-	t = btf_add_type_mem(p->dst, sz);
+	t = btf_add_type_mem(btf, sz);
 	if (!t)
 		return libbpf_err(-ENOMEM);

 	memcpy(t, src_type, sz);

-	err = btf_field_iter_init(&it, t, BTF_FIELD_ITER_STRS);
+	err = btf_type_visit_str_offs(t, btf_rewrite_str, &p);
 	if (err)
 		return libbpf_err(err);

-	while ((str_off = btf_field_iter_next(&it))) {
-		err = btf_rewrite_str(p, str_off);
-		if (err)
-			return libbpf_err(err);
-	}
-
-	return btf_commit_type(p->dst, sz);
+	return btf_commit_type(btf, sz);
 }

-int btf__add_type(struct btf *btf, const struct btf *src_btf, const struct btf_type *src_type)
+static int btf_rewrite_type_ids(__u32 *type_id, void *ctx)
 {
-	struct btf_pipe p = { .src = src_btf, .dst = btf };
+	struct btf *btf = ctx;

-	return btf_add_type(&p, src_type);
+	if (!*type_id) /* nothing to do for VOID references */
+		return 0;
+
+	/* we haven't updated btf's type count yet, so
+	 * btf->start_id + btf->nr_types - 1 is the type ID offset we should
+	 * add to all newly added BTF types
+	 */
+	*type_id += btf->start_id + btf->nr_types - 1;
+	return 0;
 }

 static size_t btf_dedup_identity_hash_fn(long key, void *ctx);
@@ -1908,9 +1847,6 @@ int btf__add_btf(struct btf *btf, const struct btf *src_btf)
 	memcpy(t, src_btf->types_data, data_sz);

 	for (i = 0; i < cnt; i++) {
-		struct btf_field_iter it;
-		__u32 *type_id, *str_off;
-
 		sz = btf_type_size(t);
 		if (sz < 0) {
 			/* unlikely, has to be corrupted src_btf */
@@ -1922,31 +1858,15 @@ int btf__add_btf(struct btf *btf, const struct btf *src_btf)
 		*off = t - btf->types_data;

 		/* add, dedup, and remap strings referenced by this BTF type */
-		err = btf_field_iter_init(&it, t, BTF_FIELD_ITER_STRS);
+		err = btf_type_visit_str_offs(t, btf_rewrite_str, &p);
 		if (err)
 			goto err_out;
-		while ((str_off = btf_field_iter_next(&it))) {
-			err = btf_rewrite_str(&p, str_off);
-			if (err)
-				goto err_out;
-		}

 		/* remap all type IDs referenced from this BTF type */
-		err = btf_field_iter_init(&it, t, BTF_FIELD_ITER_IDS);
+		err = btf_type_visit_type_ids(t, btf_rewrite_type_ids, btf);
 		if (err)
 			goto err_out;

-		while ((type_id = btf_field_iter_next(&it))) {
-			if (!*type_id) /* nothing to do for VOID references */
-				continue;
-
-			/* we haven't updated btf's type count yet, so
-			 * btf->start_id + btf->nr_types - 1 is the type ID offset we should
-			 * add to all newly added BTF types
-			 */
-			*type_id += btf->start_id + btf->nr_types - 1;
-		}
-
 		/* go to next type data and type offset index entry */
 		t += sz;
 		off++;
@@ -3119,16 +3039,12 @@ done:
 	return btf_ext;
 }

-const void *btf_ext__raw_data(const struct btf_ext *btf_ext, __u32 *size)
+const void *btf_ext__get_raw_data(const struct btf_ext *btf_ext, __u32 *size)
 {
 	*size = btf_ext->data_size;
 	return btf_ext->data;
 }

-__attribute__((alias("btf_ext__raw_data")))
-const void *btf_ext__get_raw_data(const struct btf_ext *btf_ext, __u32 *size);
-
-
 struct btf_dedup;

 static struct btf_dedup *btf_dedup_new(struct btf *btf, const struct btf_dedup_opts *opts);
@@ -3522,19 +3438,11 @@ static int btf_for_each_str_off(struct btf_dedup *d, str_off_visit_fn fn, void *
 	int i, r;

 	for (i = 0; i < d->btf->nr_types; i++) {
-		struct btf_field_iter it;
 		struct btf_type *t = btf_type_by_id(d->btf, d->btf->start_id + i);
-		__u32 *str_off;

-		r = btf_field_iter_init(&it, t, BTF_FIELD_ITER_STRS);
+		r = btf_type_visit_str_offs(t, fn, ctx);
 		if (r)
 			return r;
-
-		while ((str_off = btf_field_iter_next(&it))) {
-			r = fn(str_off, ctx);
-			if (r)
-				return r;
-		}
 	}

 	if (!d->btf_ext)
@@ -4996,23 +4904,10 @@ static int btf_dedup_remap_types(struct btf_dedup *d)

 	for (i = 0; i < d->btf->nr_types; i++) {
 		struct btf_type *t = btf_type_by_id(d->btf, d->btf->start_id + i);
-		struct btf_field_iter it;
-		__u32 *type_id;

-		r = btf_field_iter_init(&it, t, BTF_FIELD_ITER_IDS);
+		r = btf_type_visit_type_ids(t, btf_dedup_remap_type_id, d);
 		if (r)
 			return r;
-
-		while ((type_id = btf_field_iter_next(&it))) {
-			__u32 resolved_id, new_id;
-
-			resolved_id = resolve_type_id(d, *type_id);
-			new_id = d->hypot_map[resolved_id];
-			if (new_id > BTF_MAX_NR_TYPES)
-				return -EINVAL;
-
-			*type_id = new_id;
-		}
 	}

 	if (!d->btf_ext)
@@ -5031,9 +4926,10 @@ static int btf_dedup_remap_types(struct btf_dedup *d)
 */
 struct btf *btf__load_vmlinux_btf(void)
 {
-	const char *sysfs_btf_path = "/sys/kernel/btf/vmlinux";
-	/* fall back locations, trying to find vmlinux on disk */
 	const char *locations[] = {
+		/* try canonical vmlinux BTF through sysfs first */
+		"/sys/kernel/btf/vmlinux",
+		/* fall back to trying to find vmlinux on disk otherwise */
 		"/boot/vmlinux-%1$s",
 		"/lib/modules/%1$s/vmlinux-%1$s",
 		"/lib/modules/%1$s/build/vmlinux",
@@ -5047,23 +4943,8 @@ struct btf *btf__load_vmlinux_btf(void)
 	struct btf *btf;
 	int i, err;

-	/* is canonical sysfs location accessible? */
-	if (faccessat(AT_FDCWD, sysfs_btf_path, F_OK, AT_EACCESS) < 0) {
-		pr_warn("kernel BTF is missing at '%s', was CONFIG_DEBUG_INFO_BTF enabled?\n",
-			sysfs_btf_path);
-	} else {
-		btf = btf__parse(sysfs_btf_path, NULL);
-		if (!btf) {
-			err = -errno;
-			pr_warn("failed to read kernel BTF from '%s': %d\n", sysfs_btf_path, err);
-			return libbpf_err_ptr(err);
-		}
-		pr_debug("loaded kernel BTF from '%s'\n", sysfs_btf_path);
-		return btf;
-	}
-
-	/* try fallback locations */
 	uname(&buf);
+
 	for (i = 0; i < ARRAY_SIZE(locations); i++) {
 		snprintf(path, PATH_MAX, locations[i], buf.release);

@@ -5093,6 +4974,136 @@ struct btf *btf__load_module_btf(const char *module_name, struct btf *vmlinux_bt
 	return btf__parse_split(path, vmlinux_btf);
 }

+int btf_type_visit_type_ids(struct btf_type *t, type_id_visit_fn visit, void *ctx)
+{
+	int i, n, err;
+
+	switch (btf_kind(t)) {
+	case BTF_KIND_INT:
+	case BTF_KIND_FLOAT:
+	case BTF_KIND_ENUM:
+	case BTF_KIND_ENUM64:
+		return 0;
+
+	case BTF_KIND_FWD:
+	case BTF_KIND_CONST:
+	case BTF_KIND_VOLATILE:
+	case BTF_KIND_RESTRICT:
+	case BTF_KIND_PTR:
+	case BTF_KIND_TYPEDEF:
+	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: {
+		struct btf_array *a = btf_array(t);
+
+		err = visit(&a->type, ctx);
+		err = err ?: visit(&a->index_type, ctx);
+		return err;
+	}
+
+	case BTF_KIND_STRUCT:
+	case BTF_KIND_UNION: {
+		struct btf_member *m = btf_members(t);
+
+		for (i = 0, n = btf_vlen(t); i < n; i++, m++) {
+			err = visit(&m->type, ctx);
+			if (err)
+				return err;
+		}
+		return 0;
+	}
+
+	case BTF_KIND_FUNC_PROTO: {
+		struct btf_param *m = btf_params(t);
+
+		err = visit(&t->type, ctx);
+		if (err)
+			return err;
+		for (i = 0, n = btf_vlen(t); i < n; i++, m++) {
+			err = visit(&m->type, ctx);
+			if (err)
+				return err;
+		}
+		return 0;
+	}
+
+	case BTF_KIND_DATASEC: {
+		struct btf_var_secinfo *m = btf_var_secinfos(t);
+
+		for (i = 0, n = btf_vlen(t); i < n; i++, m++) {
+			err = visit(&m->type, ctx);
+			if (err)
+				return err;
+		}
+		return 0;
+	}
+
+	default:
+		return -EINVAL;
+	}
+}
+
+int btf_type_visit_str_offs(struct btf_type *t, str_off_visit_fn visit, void *ctx)
+{
+	int i, n, err;
+
+	err = visit(&t->name_off, ctx);
+	if (err)
+		return err;
+
+	switch (btf_kind(t)) {
+	case BTF_KIND_STRUCT:
+	case BTF_KIND_UNION: {
+		struct btf_member *m = btf_members(t);
+
+		for (i = 0, n = btf_vlen(t); i < n; i++, m++) {
+			err = visit(&m->name_off, ctx);
+			if (err)
+				return err;
+		}
+		break;
+	}
+	case BTF_KIND_ENUM: {
+		struct btf_enum *m = btf_enum(t);
+
+		for (i = 0, n = btf_vlen(t); i < n; i++, m++) {
+			err = visit(&m->name_off, ctx);
+			if (err)
+				return err;
+		}
+		break;
+	}
+	case BTF_KIND_ENUM64: {
+		struct btf_enum64 *m = btf_enum64(t);
+
+		for (i = 0, n = btf_vlen(t); i < n; i++, m++) {
+			err = visit(&m->name_off, ctx);
+			if (err)
+				return err;
+		}
+		break;
+	}
+	case BTF_KIND_FUNC_PROTO: {
+		struct btf_param *m = btf_params(t);
+
+		for (i = 0, n = btf_vlen(t); i < n; i++, m++) {
+			err = visit(&m->name_off, ctx);
+			if (err)
+				return err;
+		}
+		break;
+	}
+	default:
+		break;
+	}
+
+	return 0;
+}
+
 int btf_ext_visit_type_ids(struct btf_ext *btf_ext, type_id_visit_fn visit, void *ctx)
 {
 	const struct btf_ext_info *seg;
@@ -5172,325 +5183,3 @@ int btf_ext_visit_str_offs(struct btf_ext *btf_ext, str_off_visit_fn visit, void

 	return 0;
 }
-
-struct btf_distill {
-	struct btf_pipe pipe;
-	int *id_map;
-	unsigned int split_start_id;
-	unsigned int split_start_str;
-	int diff_id;
-};
-
-static int btf_add_distilled_type_ids(struct btf_distill *dist, __u32 i)
-{
-	struct btf_type *split_t = btf_type_by_id(dist->pipe.src, i);
-	struct btf_field_iter it;
-	__u32 *id;
-	int err;
-
-	err = btf_field_iter_init(&it, split_t, BTF_FIELD_ITER_IDS);
-	if (err)
-		return err;
-	while ((id = btf_field_iter_next(&it))) {
-		struct btf_type *base_t;
-
-		if (!*id)
-			continue;
-		/* split BTF id, not needed */
-		if (*id >= dist->split_start_id)
-			continue;
-		/* already added ? */
-		if (dist->id_map[*id] > 0)
-			continue;
-
-		/* only a subset of base BTF types should be referenced from
-		 * split BTF; ensure nothing unexpected is referenced.
-		 */
-		base_t = btf_type_by_id(dist->pipe.src, *id);
-		switch (btf_kind(base_t)) {
-		case BTF_KIND_INT:
-		case BTF_KIND_FLOAT:
-		case BTF_KIND_FWD:
-		case BTF_KIND_ARRAY:
-		case BTF_KIND_STRUCT:
-		case BTF_KIND_UNION:
-		case BTF_KIND_TYPEDEF:
-		case BTF_KIND_ENUM:
-		case BTF_KIND_ENUM64:
-		case BTF_KIND_PTR:
-		case BTF_KIND_CONST:
-		case BTF_KIND_RESTRICT:
-		case BTF_KIND_VOLATILE:
-		case BTF_KIND_FUNC_PROTO:
-		case BTF_KIND_TYPE_TAG:
-			dist->id_map[*id] = *id;
-			break;
-		default:
-			pr_warn("unexpected reference to base type[%u] of kind [%u] when creating distilled base BTF.\n",
-				*id, btf_kind(base_t));
-			return -EINVAL;
-		}
-		/* If a base type is used, ensure types it refers to are
-		 * marked as used also; so for example if we find a PTR to INT
-		 * we need both the PTR and INT.
-		 *
-		 * The only exception is named struct/unions, since distilled
-		 * base BTF composite types have no members.
-		 */
-		if (btf_is_composite(base_t) && base_t->name_off)
-			continue;
-		err = btf_add_distilled_type_ids(dist, *id);
-		if (err)
-			return err;
-	}
-	return 0;
-}
-
-static int btf_add_distilled_types(struct btf_distill *dist)
-{
-	bool adding_to_base = dist->pipe.dst->start_id == 1;
-	int id = btf__type_cnt(dist->pipe.dst);
-	struct btf_type *t;
-	int i, err = 0;
-
-
-	/* Add types for each of the required references to either distilled
-	 * base or split BTF, depending on type characteristics.
-	 */
-	for (i = 1; i < dist->split_start_id; i++) {
-		const char *name;
-		int kind;
-
-		if (!dist->id_map[i])
-			continue;
-		t = btf_type_by_id(dist->pipe.src, i);
-		kind = btf_kind(t);
-		name = btf__name_by_offset(dist->pipe.src, t->name_off);
-
-		switch (kind) {
-		case BTF_KIND_INT:
-		case BTF_KIND_FLOAT:
-		case BTF_KIND_FWD:
-			/* Named int, float, fwd are added to base. */
-			if (!adding_to_base)
-				continue;
-			err = btf_add_type(&dist->pipe, t);
-			break;
-		case BTF_KIND_STRUCT:
-		case BTF_KIND_UNION:
-			/* Named struct/union are added to base as 0-vlen
-			 * struct/union of same size.  Anonymous struct/unions
-			 * are added to split BTF as-is.
-			 */
-			if (adding_to_base) {
-				if (!t->name_off)
-					continue;
-				err = btf_add_composite(dist->pipe.dst, kind, name, t->size);
-			} else {
-				if (t->name_off)
-					continue;
-				err = btf_add_type(&dist->pipe, t);
-			}
-			break;
-		case BTF_KIND_ENUM:
-		case BTF_KIND_ENUM64:
-			/* Named enum[64]s are added to base as a sized
-			 * enum; relocation will match with appropriately-named
-			 * and sized enum or enum64.
-			 *
-			 * Anonymous enums are added to split BTF as-is.
-			 */
-			if (adding_to_base) {
-				if (!t->name_off)
-					continue;
-				err = btf__add_enum(dist->pipe.dst, name, t->size);
-			} else {
-				if (t->name_off)
-					continue;
-				err = btf_add_type(&dist->pipe, t);
-			}
-			break;
-		case BTF_KIND_ARRAY:
-		case BTF_KIND_TYPEDEF:
-		case BTF_KIND_PTR:
-		case BTF_KIND_CONST:
-		case BTF_KIND_RESTRICT:
-		case BTF_KIND_VOLATILE:
-		case BTF_KIND_FUNC_PROTO:
-		case BTF_KIND_TYPE_TAG:
-			/* All other types are added to split BTF. */
-			if (adding_to_base)
-				continue;
-			err = btf_add_type(&dist->pipe, t);
-			break;
-		default:
-			pr_warn("unexpected kind when adding base type '%s'[%u] of kind [%u] to distilled base BTF.\n",
-				name, i, kind);
-			return -EINVAL;
-
-		}
-		if (err < 0)
-			break;
-		dist->id_map[i] = id++;
-	}
-	return err;
-}
-
-/* Split BTF ids without a mapping will be shifted downwards since distilled
- * base BTF is smaller than the original base BTF.  For those that have a
- * mapping (either to base or updated split BTF), update the id based on
- * that mapping.
- */
-static int btf_update_distilled_type_ids(struct btf_distill *dist, __u32 i)
-{
-	struct btf_type *t = btf_type_by_id(dist->pipe.dst, i);
-	struct btf_field_iter it;
-	__u32 *id;
-	int err;
-
-	err = btf_field_iter_init(&it, t, BTF_FIELD_ITER_IDS);
-	if (err)
-		return err;
-	while ((id = btf_field_iter_next(&it))) {
-		if (dist->id_map[*id])
-			*id = dist->id_map[*id];
-		else if (*id >= dist->split_start_id)
-			*id -= dist->diff_id;
-	}
-	return 0;
-}
-
-/* Create updated split BTF with distilled base BTF; distilled base BTF
- * consists of BTF information required to clarify the types that split
- * BTF refers to, omitting unneeded details.  Specifically it will contain
- * base types and memberless definitions of named structs, unions and enumerated
- * types. Associated reference types like pointers, arrays and anonymous
- * structs, unions and enumerated types will be added to split BTF.
- * Size is recorded for named struct/unions to help guide matching to the
- * target base BTF during later relocation.
- *
- * The only case where structs, unions or enumerated types are fully represented
- * is when they are anonymous; in such cases, the anonymous type is added to
- * split BTF in full.
- *
- * We return newly-created split BTF where the split BTF refers to a newly-created
- * distilled base BTF. Both must be freed separately by the caller.
- */
-int btf__distill_base(const struct btf *src_btf, struct btf **new_base_btf,
-		      struct btf **new_split_btf)
-{
-	struct btf *new_base = NULL, *new_split = NULL;
-	const struct btf *old_base;
-	unsigned int n = btf__type_cnt(src_btf);
-	struct btf_distill dist = {};
-	struct btf_type *t;
-	int i, err = 0;
-
-	/* src BTF must be split BTF. */
-	old_base = btf__base_btf(src_btf);
-	if (!new_base_btf || !new_split_btf || !old_base)
-		return libbpf_err(-EINVAL);
-
-	new_base = btf__new_empty();
-	if (!new_base)
-		return libbpf_err(-ENOMEM);
-	dist.id_map = calloc(n, sizeof(*dist.id_map));
-	if (!dist.id_map) {
-		err = -ENOMEM;
-		goto done;
-	}
-	dist.pipe.src = src_btf;
-	dist.pipe.dst = new_base;
-	dist.pipe.str_off_map = hashmap__new(btf_dedup_identity_hash_fn, btf_dedup_equal_fn, NULL);
-	if (IS_ERR(dist.pipe.str_off_map)) {
-		err = -ENOMEM;
-		goto done;
-	}
-	dist.split_start_id = btf__type_cnt(old_base);
-	dist.split_start_str = old_base->hdr->str_len;
-
-	/* Pass over src split BTF; generate the list of base BTF type ids it
-	 * references; these will constitute our distilled BTF set to be
-	 * distributed over base and split BTF as appropriate.
-	 */
-	for (i = src_btf->start_id; i < n; i++) {
-		err = btf_add_distilled_type_ids(&dist, i);
-		if (err < 0)
-			goto done;
-	}
-	/* Next add types for each of the required references to base BTF and split BTF
-	 * in turn.
-	 */
-	err = btf_add_distilled_types(&dist);
-	if (err < 0)
-		goto done;
-
-	/* Create new split BTF with distilled base BTF as its base; the final
-	 * state is split BTF with distilled base BTF that represents enough
-	 * about its base references to allow it to be relocated with the base
-	 * BTF available.
-	 */
-	new_split = btf__new_empty_split(new_base);
-	if (!new_split) {
-		err = -errno;
-		goto done;
-	}
-	dist.pipe.dst = new_split;
-	/* First add all split types */
-	for (i = src_btf->start_id; i < n; i++) {
-		t = btf_type_by_id(src_btf, i);
-		err = btf_add_type(&dist.pipe, t);
-		if (err < 0)
-			goto done;
-	}
-	/* Now add distilled types to split BTF that are not added to base. */
-	err = btf_add_distilled_types(&dist);
-	if (err < 0)
-		goto done;
-
-	/* All split BTF ids will be shifted downwards since there are less base
-	 * BTF ids in distilled base BTF.
-	 */
-	dist.diff_id = dist.split_start_id - btf__type_cnt(new_base);
-
-	n = btf__type_cnt(new_split);
-	/* Now update base/split BTF ids. */
-	for (i = 1; i < n; i++) {
-		err = btf_update_distilled_type_ids(&dist, i);
-		if (err < 0)
-			break;
-	}
-done:
-	free(dist.id_map);
-	hashmap__free(dist.pipe.str_off_map);
-	if (err) {
-		btf__free(new_split);
-		btf__free(new_base);
-		return libbpf_err(err);
-	}
-	*new_base_btf = new_base;
-	*new_split_btf = new_split;
-
-	return 0;
-}
-
-const struct btf_header *btf_header(const struct btf *btf)
-{
-	return btf->hdr;
-}
-
-void btf_set_base_btf(struct btf *btf, const struct btf *base_btf)
-{
-	btf->base_btf = (struct btf *)base_btf;
-	btf->start_id = btf__type_cnt(base_btf);
-	btf->start_str_off = base_btf->hdr->str_len;
-}
-
-int btf__relocate(struct btf *btf, const struct btf *base_btf)
-{
-	int err = btf_relocate(btf, base_btf, NULL);
-
-	if (!err)
-		btf->owns_base = false;
-	return libbpf_err(err);
-}
--- a/src/btf.h
+++ b/src/btf.h
@@ -18,7 +18,6 @@ extern "C" {

 #define BTF_ELF_SEC ".BTF"
 #define BTF_EXT_ELF_SEC ".BTF.ext"
-#define BTF_BASE_ELF_SEC ".BTF.base"
 #define MAPS_ELF_SEC ".maps"

 struct btf;
@@ -108,27 +107,6 @@ LIBBPF_API struct btf *btf__new_empty(void);
 */
 LIBBPF_API struct btf *btf__new_empty_split(struct btf *base_btf);

-/**
- * @brief **btf__distill_base()** creates new versions of the split BTF
- * *src_btf* and its base BTF. The new base BTF will only contain the types
- * needed to improve robustness of the split BTF to small changes in base BTF.
- * When that split BTF is loaded against a (possibly changed) base, this
- * distilled base BTF will help update references to that (possibly changed)
- * base BTF.
- *
- * Both the new split and its associated new base BTF must be freed by
- * the caller.
- *
- * If successful, 0 is returned and **new_base_btf** and **new_split_btf**
- * will point at new base/split BTF. Both the new split and its associated
- * new base BTF must be freed by the caller.
- *
- * A negative value is returned on error and the thread-local `errno` variable
- * is set to the error code as well.
- */
-LIBBPF_API int btf__distill_base(const struct btf *src_btf, struct btf **new_base_btf,
-				 struct btf **new_split_btf);
-
 LIBBPF_API struct btf *btf__parse(const char *path, struct btf_ext **btf_ext);
 LIBBPF_API struct btf *btf__parse_split(const char *path, struct btf *base_btf);
 LIBBPF_API struct btf *btf__parse_elf(const char *path, struct btf_ext **btf_ext);
@@ -253,20 +231,6 @@ struct btf_dedup_opts {

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

-/**
- * @brief **btf__relocate()** will check the split BTF *btf* for references
- * to base BTF kinds, and verify those references are compatible with
- * *base_btf*; if they are, *btf* is adjusted such that is re-parented to
- * *base_btf* and type ids and strings are adjusted to accommodate this.
- *
- * If successful, 0 is returned and **btf** now has **base_btf** as its
- * base.
- *
- * A negative value is returned on error and the thread-local `errno` variable
- * is set to the error code as well.
- */
-LIBBPF_API int btf__relocate(struct btf *btf, const struct btf *base_btf);
-
 struct btf_dump;

 struct btf_dump_opts {
--- a/src/btf_dump.c
+++ b/src/btf_dump.c
@@ -1929,7 +1929,6 @@ static int btf_dump_int_data(struct btf_dump *d,
 			if (d->typed_dump->is_array_terminated)
 				break;
 			if (*(char *)data == '\0') {
-				btf_dump_type_values(d, "'\\0'");
 				d->typed_dump->is_array_terminated = true;
 				break;
 			}
@@ -2032,7 +2031,6 @@ static int btf_dump_array_data(struct btf_dump *d,
 	__u32 i, elem_type_id;
 	__s64 elem_size;
 	bool is_array_member;
-	bool is_array_terminated;

 	elem_type_id = array->type;
 	elem_type = skip_mods_and_typedefs(d->btf, elem_type_id, NULL);
@@ -2068,15 +2066,12 @@ static int btf_dump_array_data(struct btf_dump *d,
 	 */
 	is_array_member = d->typed_dump->is_array_member;
 	d->typed_dump->is_array_member = true;
-	is_array_terminated = d->typed_dump->is_array_terminated;
-	d->typed_dump->is_array_terminated = false;
 	for (i = 0; i < array->nelems; i++, data += elem_size) {
 		if (d->typed_dump->is_array_terminated)
 			break;
 		btf_dump_dump_type_data(d, NULL, elem_type, elem_type_id, data, 0, 0);
 	}
 	d->typed_dump->is_array_member = is_array_member;
-	d->typed_dump->is_array_terminated = is_array_terminated;
 	d->typed_dump->depth--;
 	btf_dump_data_pfx(d);
 	btf_dump_type_values(d, "]");
--- a/src/btf_iter.c
+++ b/src/btf_iter.c
@@ -1,177 +0,0 @@
-// SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause)
-/* Copyright (c) 2021 Facebook */
-/* Copyright (c) 2024, Oracle and/or its affiliates. */
-
-#ifdef __KERNEL__
-#include <linux/bpf.h>
-#include <linux/btf.h>
-
-#define btf_var_secinfos(t)	(struct btf_var_secinfo *)btf_type_var_secinfo(t)
-
-#else
-#include "btf.h"
-#include "libbpf_internal.h"
-#endif
-
-int btf_field_iter_init(struct btf_field_iter *it, struct btf_type *t,
-			enum btf_field_iter_kind iter_kind)
-{
-	it->p = NULL;
-	it->m_idx = -1;
-	it->off_idx = 0;
-	it->vlen = 0;
-
-	switch (iter_kind) {
-	case BTF_FIELD_ITER_IDS:
-		switch (btf_kind(t)) {
-		case BTF_KIND_UNKN:
-		case BTF_KIND_INT:
-		case BTF_KIND_FLOAT:
-		case BTF_KIND_ENUM:
-		case BTF_KIND_ENUM64:
-			it->desc = (struct btf_field_desc) {};
-			break;
-		case BTF_KIND_FWD:
-		case BTF_KIND_CONST:
-		case BTF_KIND_VOLATILE:
-		case BTF_KIND_RESTRICT:
-		case BTF_KIND_PTR:
-		case BTF_KIND_TYPEDEF:
-		case BTF_KIND_FUNC:
-		case BTF_KIND_VAR:
-		case BTF_KIND_DECL_TAG:
-		case BTF_KIND_TYPE_TAG:
-			it->desc = (struct btf_field_desc) { 1, {offsetof(struct btf_type, type)} };
-			break;
-		case BTF_KIND_ARRAY:
-			it->desc = (struct btf_field_desc) {
-				2, {sizeof(struct btf_type) + offsetof(struct btf_array, type),
-				sizeof(struct btf_type) + offsetof(struct btf_array, index_type)}
-			};
-			break;
-		case BTF_KIND_STRUCT:
-		case BTF_KIND_UNION:
-			it->desc = (struct btf_field_desc) {
-				0, {},
-				sizeof(struct btf_member),
-				1, {offsetof(struct btf_member, type)}
-			};
-			break;
-		case BTF_KIND_FUNC_PROTO:
-			it->desc = (struct btf_field_desc) {
-				1, {offsetof(struct btf_type, type)},
-				sizeof(struct btf_param),
-				1, {offsetof(struct btf_param, type)}
-			};
-			break;
-		case BTF_KIND_DATASEC:
-			it->desc = (struct btf_field_desc) {
-				0, {},
-				sizeof(struct btf_var_secinfo),
-				1, {offsetof(struct btf_var_secinfo, type)}
-			};
-			break;
-		default:
-			return -EINVAL;
-		}
-		break;
-	case BTF_FIELD_ITER_STRS:
-		switch (btf_kind(t)) {
-		case BTF_KIND_UNKN:
-			it->desc = (struct btf_field_desc) {};
-			break;
-		case BTF_KIND_INT:
-		case BTF_KIND_FLOAT:
-		case BTF_KIND_FWD:
-		case BTF_KIND_ARRAY:
-		case BTF_KIND_CONST:
-		case BTF_KIND_VOLATILE:
-		case BTF_KIND_RESTRICT:
-		case BTF_KIND_PTR:
-		case BTF_KIND_TYPEDEF:
-		case BTF_KIND_FUNC:
-		case BTF_KIND_VAR:
-		case BTF_KIND_DECL_TAG:
-		case BTF_KIND_TYPE_TAG:
-		case BTF_KIND_DATASEC:
-			it->desc = (struct btf_field_desc) {
-				1, {offsetof(struct btf_type, name_off)}
-			};
-			break;
-		case BTF_KIND_ENUM:
-			it->desc = (struct btf_field_desc) {
-				1, {offsetof(struct btf_type, name_off)},
-				sizeof(struct btf_enum),
-				1, {offsetof(struct btf_enum, name_off)}
-			};
-			break;
-		case BTF_KIND_ENUM64:
-			it->desc = (struct btf_field_desc) {
-				1, {offsetof(struct btf_type, name_off)},
-				sizeof(struct btf_enum64),
-				1, {offsetof(struct btf_enum64, name_off)}
-			};
-			break;
-		case BTF_KIND_STRUCT:
-		case BTF_KIND_UNION:
-			it->desc = (struct btf_field_desc) {
-				1, {offsetof(struct btf_type, name_off)},
-				sizeof(struct btf_member),
-				1, {offsetof(struct btf_member, name_off)}
-			};
-			break;
-		case BTF_KIND_FUNC_PROTO:
-			it->desc = (struct btf_field_desc) {
-				1, {offsetof(struct btf_type, name_off)},
-				sizeof(struct btf_param),
-				1, {offsetof(struct btf_param, name_off)}
-			};
-			break;
-		default:
-			return -EINVAL;
-		}
-		break;
-	default:
-		return -EINVAL;
-	}
-
-	if (it->desc.m_sz)
-		it->vlen = btf_vlen(t);
-
-	it->p = t;
-	return 0;
-}
-
-__u32 *btf_field_iter_next(struct btf_field_iter *it)
-{
-	if (!it->p)
-		return NULL;
-
-	if (it->m_idx < 0) {
-		if (it->off_idx < it->desc.t_off_cnt)
-			return it->p + it->desc.t_offs[it->off_idx++];
-		/* move to per-member iteration */
-		it->m_idx = 0;
-		it->p += sizeof(struct btf_type);
-		it->off_idx = 0;
-	}
-
-	/* if type doesn't have members, stop */
-	if (it->desc.m_sz == 0) {
-		it->p = NULL;
-		return NULL;
-	}
-
-	if (it->off_idx >= it->desc.m_off_cnt) {
-		/* exhausted this member's fields, go to the next member */
-		it->m_idx++;
-		it->p += it->desc.m_sz;
-		it->off_idx = 0;
-	}
-
-	if (it->m_idx < it->vlen)
-		return it->p + it->desc.m_offs[it->off_idx++];
-
-	it->p = NULL;
-	return NULL;
-}
--- a/src/btf_relocate.c
+++ b/src/btf_relocate.c
@@ -1,519 +0,0 @@
-// SPDX-License-Identifier: GPL-2.0
-/* Copyright (c) 2024, Oracle and/or its affiliates. */
-
-#ifndef _GNU_SOURCE
-#define _GNU_SOURCE
-#endif
-
-#ifdef __KERNEL__
-#include <linux/bpf.h>
-#include <linux/bsearch.h>
-#include <linux/btf.h>
-#include <linux/sort.h>
-#include <linux/string.h>
-#include <linux/bpf_verifier.h>
-
-#define btf_type_by_id				(struct btf_type *)btf_type_by_id
-#define btf__type_cnt				btf_nr_types
-#define btf__base_btf				btf_base_btf
-#define btf__name_by_offset			btf_name_by_offset
-#define btf__str_by_offset			btf_str_by_offset
-#define btf_kflag				btf_type_kflag
-
-#define calloc(nmemb, sz)			kvcalloc(nmemb, sz, GFP_KERNEL | __GFP_NOWARN)
-#define free(ptr)				kvfree(ptr)
-#define qsort(base, num, sz, cmp)		sort(base, num, sz, cmp, NULL)
-
-#else
-
-#include "btf.h"
-#include "bpf.h"
-#include "libbpf.h"
-#include "libbpf_internal.h"
-
-#endif /* __KERNEL__ */
-
-struct btf;
-
-struct btf_relocate {
-	struct btf *btf;
-	const struct btf *base_btf;
-	const struct btf *dist_base_btf;
-	unsigned int nr_base_types;
-	unsigned int nr_split_types;
-	unsigned int nr_dist_base_types;
-	int dist_str_len;
-	int base_str_len;
-	__u32 *id_map;
-	__u32 *str_map;
-};
-
-/* Set temporarily in relocation id_map if distilled base struct/union is
- * embedded in a split BTF struct/union; in such a case, size information must
- * match between distilled base BTF and base BTF representation of type.
- */
-#define BTF_IS_EMBEDDED ((__u32)-1)
-
-/* <name, size, id> triple used in sorting/searching distilled base BTF. */
-struct btf_name_info {
-	const char *name;
-	/* set when search requires a size match */
-	bool needs_size: 1;
-	unsigned int size: 31;
-	__u32 id;
-};
-
-static int btf_relocate_rewrite_type_id(struct btf_relocate *r, __u32 i)
-{
-	struct btf_type *t = btf_type_by_id(r->btf, i);
-	struct btf_field_iter it;
-	__u32 *id;
-	int err;
-
-	err = btf_field_iter_init(&it, t, BTF_FIELD_ITER_IDS);
-	if (err)
-		return err;
-
-	while ((id = btf_field_iter_next(&it)))
-		*id = r->id_map[*id];
-	return 0;
-}
-
-/* Simple string comparison used for sorting within BTF, since all distilled
- * types are named.  If strings match, and size is non-zero for both elements
- * fall back to using size for ordering.
- */
-static int cmp_btf_name_size(const void *n1, const void *n2)
-{
-	const struct btf_name_info *ni1 = n1;
-	const struct btf_name_info *ni2 = n2;
-	int name_diff = strcmp(ni1->name, ni2->name);
-
-	if (!name_diff && ni1->needs_size && ni2->needs_size)
-		return ni2->size - ni1->size;
-	return name_diff;
-}
-
-/* Binary search with a small twist; find leftmost element that matches
- * so that we can then iterate through all exact matches.  So for example
- * searching { "a", "bb", "bb", "c" }  we would always match on the
- * leftmost "bb".
- */
-static struct btf_name_info *search_btf_name_size(struct btf_name_info *key,
-						  struct btf_name_info *vals,
-						  int nelems)
-{
-	struct btf_name_info *ret = NULL;
-	int high = nelems - 1;
-	int low = 0;
-
-	while (low <= high) {
-		int mid = (low + high)/2;
-		struct btf_name_info *val = &vals[mid];
-		int diff = cmp_btf_name_size(key, val);
-
-		if (diff == 0)
-			ret = val;
-		/* even if found, keep searching for leftmost match */
-		if (diff <= 0)
-			high = mid - 1;
-		else
-			low = mid + 1;
-	}
-	return ret;
-}
-
-/* If a member of a split BTF struct/union refers to a base BTF
- * struct/union, mark that struct/union id temporarily in the id_map
- * with BTF_IS_EMBEDDED.  Members can be const/restrict/volatile/typedef
- * reference types, but if a pointer is encountered, the type is no longer
- * considered embedded.
- */
-static int btf_mark_embedded_composite_type_ids(struct btf_relocate *r, __u32 i)
-{
-	struct btf_type *t = btf_type_by_id(r->btf, i);
-	struct btf_field_iter it;
-	__u32 *id;
-	int err;
-
-	if (!btf_is_composite(t))
-		return 0;
-
-	err = btf_field_iter_init(&it, t, BTF_FIELD_ITER_IDS);
-	if (err)
-		return err;
-
-	while ((id = btf_field_iter_next(&it))) {
-		__u32 next_id = *id;
-
-		while (next_id) {
-			t = btf_type_by_id(r->btf, next_id);
-			switch (btf_kind(t)) {
-			case BTF_KIND_CONST:
-			case BTF_KIND_RESTRICT:
-			case BTF_KIND_VOLATILE:
-			case BTF_KIND_TYPEDEF:
-			case BTF_KIND_TYPE_TAG:
-				next_id = t->type;
-				break;
-			case BTF_KIND_ARRAY: {
-				struct btf_array *a = btf_array(t);
-
-				next_id = a->type;
-				break;
-			}
-			case BTF_KIND_STRUCT:
-			case BTF_KIND_UNION:
-				if (next_id < r->nr_dist_base_types)
-					r->id_map[next_id] = BTF_IS_EMBEDDED;
-				next_id = 0;
-				break;
-			default:
-				next_id = 0;
-				break;
-			}
-		}
-	}
-
-	return 0;
-}
-
-/* Build a map from distilled base BTF ids to base BTF ids. To do so, iterate
- * through base BTF looking up distilled type (using binary search) equivalents.
- */
-static int btf_relocate_map_distilled_base(struct btf_relocate *r)
-{
-	struct btf_name_info *info, *info_end;
-	struct btf_type *base_t, *dist_t;
-	__u8 *base_name_cnt = NULL;
-	int err = 0;
-	__u32 id;
-
-	/* generate a sort index array of name/type ids sorted by name for
-	 * distilled base BTF to speed name-based lookups.
-	 */
-	info = calloc(r->nr_dist_base_types, sizeof(*info));
-	if (!info) {
-		err = -ENOMEM;
-		goto done;
-	}
-	info_end = info + r->nr_dist_base_types;
-	for (id = 0; id < r->nr_dist_base_types; id++) {
-		dist_t = btf_type_by_id(r->dist_base_btf, id);
-		info[id].name = btf__name_by_offset(r->dist_base_btf, dist_t->name_off);
-		info[id].id = id;
-		info[id].size = dist_t->size;
-		info[id].needs_size = true;
-	}
-	qsort(info, r->nr_dist_base_types, sizeof(*info), cmp_btf_name_size);
-
-	/* Mark distilled base struct/union members of split BTF structs/unions
-	 * in id_map with BTF_IS_EMBEDDED; this signals that these types
-	 * need to match both name and size, otherwise embedding the base
-	 * struct/union in the split type is invalid.
-	 */
-	for (id = r->nr_dist_base_types; id < r->nr_split_types; id++) {
-		err = btf_mark_embedded_composite_type_ids(r, id);
-		if (err)
-			goto done;
-	}
-
-	/* Collect name counts for composite types in base BTF.  If multiple
-	 * instances of a struct/union of the same name exist, we need to use
-	 * size to determine which to map to since name alone is ambiguous.
-	 */
-	base_name_cnt = calloc(r->base_str_len, sizeof(*base_name_cnt));
-	if (!base_name_cnt) {
-		err = -ENOMEM;
-		goto done;
-	}
-	for (id = 1; id < r->nr_base_types; id++) {
-		base_t = btf_type_by_id(r->base_btf, id);
-		if (!btf_is_composite(base_t) || !base_t->name_off)
-			continue;
-		if (base_name_cnt[base_t->name_off] < 255)
-			base_name_cnt[base_t->name_off]++;
-	}
-
-	/* Now search base BTF for matching distilled base BTF types. */
-	for (id = 1; id < r->nr_base_types; id++) {
-		struct btf_name_info *dist_info, base_info = {};
-		int dist_kind, base_kind;
-
-		base_t = btf_type_by_id(r->base_btf, id);
-		/* distilled base consists of named types only. */
-		if (!base_t->name_off)
-			continue;
-		base_kind = btf_kind(base_t);
-		base_info.id = id;
-		base_info.name = btf__name_by_offset(r->base_btf, base_t->name_off);
-		switch (base_kind) {
-		case BTF_KIND_INT:
-		case BTF_KIND_FLOAT:
-		case BTF_KIND_ENUM:
-		case BTF_KIND_ENUM64:
-			/* These types should match both name and size */
-			base_info.needs_size = true;
-			base_info.size = base_t->size;
-			break;
-		case BTF_KIND_FWD:
-			/* No size considerations for fwds. */
-			break;
-		case BTF_KIND_STRUCT:
-		case BTF_KIND_UNION:
-			/* Size only needs to be used for struct/union if there
-			 * are multiple types in base BTF with the same name.
-			 * If there are multiple _distilled_ types with the same
-			 * name (a very unlikely scenario), that doesn't matter
-			 * unless corresponding _base_ types to match them are
-			 * missing.
-			 */
-			base_info.needs_size = base_name_cnt[base_t->name_off] > 1;
-			base_info.size = base_t->size;
-			break;
-		default:
-			continue;
-		}
-		/* iterate over all matching distilled base types */
-		for (dist_info = search_btf_name_size(&base_info, info, r->nr_dist_base_types);
-		     dist_info != NULL && dist_info < info_end &&
-		     cmp_btf_name_size(&base_info, dist_info) == 0;
-		     dist_info++) {
-			if (!dist_info->id || dist_info->id >= r->nr_dist_base_types) {
-				pr_warn("base BTF id [%d] maps to invalid distilled base BTF id [%d]\n",
-					id, dist_info->id);
-				err = -EINVAL;
-				goto done;
-			}
-			dist_t = btf_type_by_id(r->dist_base_btf, dist_info->id);
-			dist_kind = btf_kind(dist_t);
-
-			/* Validate that the found distilled type is compatible.
-			 * Do not error out on mismatch as another match may
-			 * occur for an identically-named type.
-			 */
-			switch (dist_kind) {
-			case BTF_KIND_FWD:
-				switch (base_kind) {
-				case BTF_KIND_FWD:
-					if (btf_kflag(dist_t) != btf_kflag(base_t))
-						continue;
-					break;
-				case BTF_KIND_STRUCT:
-					if (btf_kflag(base_t))
-						continue;
-					break;
-				case BTF_KIND_UNION:
-					if (!btf_kflag(base_t))
-						continue;
-					break;
-				default:
-					continue;
-				}
-				break;
-			case BTF_KIND_INT:
-				if (dist_kind != base_kind ||
-				    btf_int_encoding(base_t) != btf_int_encoding(dist_t))
-					continue;
-				break;
-			case BTF_KIND_FLOAT:
-				if (dist_kind != base_kind)
-					continue;
-				break;
-			case BTF_KIND_ENUM:
-				/* ENUM and ENUM64 are encoded as sized ENUM in
-				 * distilled base BTF.
-				 */
-				if (base_kind != dist_kind && base_kind != BTF_KIND_ENUM64)
-					continue;
-				break;
-			case BTF_KIND_STRUCT:
-			case BTF_KIND_UNION:
-				/* size verification is required for embedded
-				 * struct/unions.
-				 */
-				if (r->id_map[dist_info->id] == BTF_IS_EMBEDDED &&
-				    base_t->size != dist_t->size)
-					continue;
-				break;
-			default:
-				continue;
-			}
-			if (r->id_map[dist_info->id] &&
-			    r->id_map[dist_info->id] != BTF_IS_EMBEDDED) {
-				/* we already have a match; this tells us that
-				 * multiple base types of the same name
-				 * have the same size, since for cases where
-				 * multiple types have the same name we match
-				 * on name and size.  In this case, we have
-				 * no way of determining which to relocate
-				 * to in base BTF, so error out.
-				 */
-				pr_warn("distilled base BTF type '%s' [%u], size %u has multiple candidates of the same size (ids [%u, %u]) in base BTF\n",
-					base_info.name, dist_info->id,
-					base_t->size, id, r->id_map[dist_info->id]);
-				err = -EINVAL;
-				goto done;
-			}
-			/* map id and name */
-			r->id_map[dist_info->id] = id;
-			r->str_map[dist_t->name_off] = base_t->name_off;
-		}
-	}
-	/* ensure all distilled BTF ids now have a mapping... */
-	for (id = 1; id < r->nr_dist_base_types; id++) {
-		const char *name;
-
-		if (r->id_map[id] && r->id_map[id] != BTF_IS_EMBEDDED)
-			continue;
-		dist_t = btf_type_by_id(r->dist_base_btf, id);
-		name = btf__name_by_offset(r->dist_base_btf, dist_t->name_off);
-		pr_warn("distilled base BTF type '%s' [%d] is not mapped to base BTF id\n",
-			name, id);
-		err = -EINVAL;
-		break;
-	}
-done:
-	free(base_name_cnt);
-	free(info);
-	return err;
-}
-
-/* distilled base should only have named int/float/enum/fwd/struct/union types. */
-static int btf_relocate_validate_distilled_base(struct btf_relocate *r)
-{
-	unsigned int i;
-
-	for (i = 1; i < r->nr_dist_base_types; i++) {
-		struct btf_type *t = btf_type_by_id(r->dist_base_btf, i);
-		int kind = btf_kind(t);
-
-		switch (kind) {
-		case BTF_KIND_INT:
-		case BTF_KIND_FLOAT:
-		case BTF_KIND_ENUM:
-		case BTF_KIND_STRUCT:
-		case BTF_KIND_UNION:
-		case BTF_KIND_FWD:
-			if (t->name_off)
-				break;
-			pr_warn("type [%d], kind [%d] is invalid for distilled base BTF; it is anonymous\n",
-				i, kind);
-			return -EINVAL;
-		default:
-			pr_warn("type [%d] in distilled based BTF has unexpected kind [%d]\n",
-				i, kind);
-			return -EINVAL;
-		}
-	}
-	return 0;
-}
-
-static int btf_relocate_rewrite_strs(struct btf_relocate *r, __u32 i)
-{
-	struct btf_type *t = btf_type_by_id(r->btf, i);
-	struct btf_field_iter it;
-	__u32 *str_off;
-	int off, err;
-
-	err = btf_field_iter_init(&it, t, BTF_FIELD_ITER_STRS);
-	if (err)
-		return err;
-
-	while ((str_off = btf_field_iter_next(&it))) {
-		if (!*str_off)
-			continue;
-		if (*str_off >= r->dist_str_len) {
-			*str_off += r->base_str_len - r->dist_str_len;
-		} else {
-			off = r->str_map[*str_off];
-			if (!off) {
-				pr_warn("string '%s' [offset %u] is not mapped to base BTF",
-					btf__str_by_offset(r->btf, off), *str_off);
-				return -ENOENT;
-			}
-			*str_off = off;
-		}
-	}
-	return 0;
-}
-
-/* If successful, output of relocation is updated BTF with base BTF pointing
- * at base_btf, and type ids, strings adjusted accordingly.
- */
-int btf_relocate(struct btf *btf, const struct btf *base_btf, __u32 **id_map)
-{
-	unsigned int nr_types = btf__type_cnt(btf);
-	const struct btf_header *dist_base_hdr;
-	const struct btf_header *base_hdr;
-	struct btf_relocate r = {};
-	int err = 0;
-	__u32 id, i;
-
-	r.dist_base_btf = btf__base_btf(btf);
-	if (!base_btf || r.dist_base_btf == base_btf)
-		return -EINVAL;
-
-	r.nr_dist_base_types = btf__type_cnt(r.dist_base_btf);
-	r.nr_base_types = btf__type_cnt(base_btf);
-	r.nr_split_types = nr_types - r.nr_dist_base_types;
-	r.btf = btf;
-	r.base_btf = base_btf;
-
-	r.id_map = calloc(nr_types, sizeof(*r.id_map));
-	r.str_map = calloc(btf_header(r.dist_base_btf)->str_len, sizeof(*r.str_map));
-	dist_base_hdr = btf_header(r.dist_base_btf);
-	base_hdr = btf_header(r.base_btf);
-	r.dist_str_len = dist_base_hdr->str_len;
-	r.base_str_len = base_hdr->str_len;
-	if (!r.id_map || !r.str_map) {
-		err = -ENOMEM;
-		goto err_out;
-	}
-
-	err = btf_relocate_validate_distilled_base(&r);
-	if (err)
-		goto err_out;
-
-	/* Split BTF ids need to be adjusted as base and distilled base
-	 * have different numbers of types, changing the start id of split
-	 * BTF.
-	 */
-	for (id = r.nr_dist_base_types; id < nr_types; id++)
-		r.id_map[id] = id + r.nr_base_types - r.nr_dist_base_types;
-
-	/* Build a map from distilled base ids to actual base BTF ids; it is used
-	 * to update split BTF id references.  Also build a str_map mapping from
-	 * distilled base BTF names to base BTF names.
-	 */
-	err = btf_relocate_map_distilled_base(&r);
-	if (err)
-		goto err_out;
-
-	/* Next, rewrite type ids in split BTF, replacing split ids with updated
-	 * ids based on number of types in base BTF, and base ids with
-	 * relocated ids from base_btf.
-	 */
-	for (i = 0, id = r.nr_dist_base_types; i < r.nr_split_types; i++, id++) {
-		err = btf_relocate_rewrite_type_id(&r, id);
-		if (err)
-			goto err_out;
-	}
-	/* String offsets now need to be updated using the str_map. */
-	for (i = 0; i < r.nr_split_types; i++) {
-		err = btf_relocate_rewrite_strs(&r, i + r.nr_dist_base_types);
-		if (err)
-			goto err_out;
-	}
-	/* Finally reset base BTF to be base_btf */
-	btf_set_base_btf(btf, base_btf);
-
-	if (id_map) {
-		*id_map = r.id_map;
-		r.id_map = NULL;
-	}
-err_out:
-	free(r.id_map);
-	free(r.str_map);
-	return err;
-}
--- a/src/elf.c
+++ b/src/elf.c
@@ -11,6 +11,8 @@
 #include "libbpf_internal.h"
 #include "str_error.h"

+#define STRERR_BUFSIZE  128
+
 /* A SHT_GNU_versym section holds 16-bit words. This bit is set if
 * the symbol is hidden and can only be seen when referenced using an
 * explicit version number. This is a GNU extension.
--- a/src/features.c
+++ b/src/features.c
@@ -1,613 +0,0 @@
-// SPDX-License-Identifier: (LGPL-2.1 OR BSD-2-Clause)
-/* Copyright (c) 2023 Meta Platforms, Inc. and affiliates. */
-#include <linux/kernel.h>
-#include <linux/filter.h>
-#include "bpf.h"
-#include "libbpf.h"
-#include "libbpf_common.h"
-#include "libbpf_internal.h"
-#include "str_error.h"
-
-static inline __u64 ptr_to_u64(const void *ptr)
-{
-	return (__u64)(unsigned long)ptr;
-}
-
-int probe_fd(int fd)
-{
-	if (fd >= 0)
-		close(fd);
-	return fd >= 0;
-}
-
-static int probe_kern_prog_name(int token_fd)
-{
-	const size_t attr_sz = offsetofend(union bpf_attr, prog_token_fd);
-	struct bpf_insn insns[] = {
-		BPF_MOV64_IMM(BPF_REG_0, 0),
-		BPF_EXIT_INSN(),
-	};
-	union bpf_attr attr;
-	int ret;
-
-	memset(&attr, 0, attr_sz);
-	attr.prog_type = BPF_PROG_TYPE_SOCKET_FILTER;
-	attr.license = ptr_to_u64("GPL");
-	attr.insns = ptr_to_u64(insns);
-	attr.insn_cnt = (__u32)ARRAY_SIZE(insns);
-	attr.prog_token_fd = token_fd;
-	if (token_fd)
-		attr.prog_flags |= BPF_F_TOKEN_FD;
-	libbpf_strlcpy(attr.prog_name, "libbpf_nametest", sizeof(attr.prog_name));
-
-	/* make sure loading with name works */
-	ret = sys_bpf_prog_load(&attr, attr_sz, PROG_LOAD_ATTEMPTS);
-	return probe_fd(ret);
-}
-
-static int probe_kern_global_data(int token_fd)
-{
-	char *cp, errmsg[STRERR_BUFSIZE];
-	struct bpf_insn insns[] = {
-		BPF_LD_MAP_VALUE(BPF_REG_1, 0, 16),
-		BPF_ST_MEM(BPF_DW, BPF_REG_1, 0, 42),
-		BPF_MOV64_IMM(BPF_REG_0, 0),
-		BPF_EXIT_INSN(),
-	};
-	LIBBPF_OPTS(bpf_map_create_opts, map_opts,
-		.token_fd = token_fd,
-		.map_flags = token_fd ? BPF_F_TOKEN_FD : 0,
-	);
-	LIBBPF_OPTS(bpf_prog_load_opts, prog_opts,
-		.token_fd = token_fd,
-		.prog_flags = token_fd ? BPF_F_TOKEN_FD : 0,
-	);
-	int ret, map, insn_cnt = ARRAY_SIZE(insns);
-
-	map = bpf_map_create(BPF_MAP_TYPE_ARRAY, "libbpf_global", sizeof(int), 32, 1, &map_opts);
-	if (map < 0) {
-		ret = -errno;
-		cp = libbpf_strerror_r(ret, errmsg, sizeof(errmsg));
-		pr_warn("Error in %s():%s(%d). Couldn't create simple array map.\n",
-			__func__, cp, -ret);
-		return ret;
-	}
-
-	insns[0].imm = map;
-
-	ret = bpf_prog_load(BPF_PROG_TYPE_SOCKET_FILTER, NULL, "GPL", insns, insn_cnt, &prog_opts);
-	close(map);
-	return probe_fd(ret);
-}
-
-static int probe_kern_btf(int token_fd)
-{
-	static const char strs[] = "\0int";
-	__u32 types[] = {
-		/* int */
-		BTF_TYPE_INT_ENC(1, BTF_INT_SIGNED, 0, 32, 4),
-	};
-
-	return probe_fd(libbpf__load_raw_btf((char *)types, sizeof(types),
-					     strs, sizeof(strs), token_fd));
-}
-
-static int probe_kern_btf_func(int token_fd)
-{
-	static const char strs[] = "\0int\0x\0a";
-	/* void x(int a) {} */
-	__u32 types[] = {
-		/* int */
-		BTF_TYPE_INT_ENC(1, BTF_INT_SIGNED, 0, 32, 4),  /* [1] */
-		/* FUNC_PROTO */                                /* [2] */
-		BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_FUNC_PROTO, 0, 1), 0),
-		BTF_PARAM_ENC(7, 1),
-		/* FUNC x */                                    /* [3] */
-		BTF_TYPE_ENC(5, BTF_INFO_ENC(BTF_KIND_FUNC, 0, 0), 2),
-	};
-
-	return probe_fd(libbpf__load_raw_btf((char *)types, sizeof(types),
-					     strs, sizeof(strs), token_fd));
-}
-
-static int probe_kern_btf_func_global(int token_fd)
-{
-	static const char strs[] = "\0int\0x\0a";
-	/* static void x(int a) {} */
-	__u32 types[] = {
-		/* int */
-		BTF_TYPE_INT_ENC(1, BTF_INT_SIGNED, 0, 32, 4),  /* [1] */
-		/* FUNC_PROTO */                                /* [2] */
-		BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_FUNC_PROTO, 0, 1), 0),
-		BTF_PARAM_ENC(7, 1),
-		/* FUNC x BTF_FUNC_GLOBAL */                    /* [3] */
-		BTF_TYPE_ENC(5, BTF_INFO_ENC(BTF_KIND_FUNC, 0, BTF_FUNC_GLOBAL), 2),
-	};
-
-	return probe_fd(libbpf__load_raw_btf((char *)types, sizeof(types),
-					     strs, sizeof(strs), token_fd));
-}
-
-static int probe_kern_btf_datasec(int token_fd)
-{
-	static const char strs[] = "\0x\0.data";
-	/* static int a; */
-	__u32 types[] = {
-		/* int */
-		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),  /* [1] */
-		/* VAR x */                                     /* [2] */
-		BTF_TYPE_ENC(1, BTF_INFO_ENC(BTF_KIND_VAR, 0, 0), 1),
-		BTF_VAR_STATIC,
-		/* DATASEC val */                               /* [3] */
-		BTF_TYPE_ENC(3, BTF_INFO_ENC(BTF_KIND_DATASEC, 0, 1), 4),
-		BTF_VAR_SECINFO_ENC(2, 0, 4),
-	};
-
-	return probe_fd(libbpf__load_raw_btf((char *)types, sizeof(types),
-					     strs, sizeof(strs), token_fd));
-}
-
-static int probe_kern_btf_qmark_datasec(int token_fd)
-{
-	static const char strs[] = "\0x\0?.data";
-	/* static int a; */
-	__u32 types[] = {
-		/* int */
-		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),  /* [1] */
-		/* VAR x */                                     /* [2] */
-		BTF_TYPE_ENC(1, BTF_INFO_ENC(BTF_KIND_VAR, 0, 0), 1),
-		BTF_VAR_STATIC,
-		/* DATASEC ?.data */                            /* [3] */
-		BTF_TYPE_ENC(3, BTF_INFO_ENC(BTF_KIND_DATASEC, 0, 1), 4),
-		BTF_VAR_SECINFO_ENC(2, 0, 4),
-	};
-
-	return probe_fd(libbpf__load_raw_btf((char *)types, sizeof(types),
-					     strs, sizeof(strs), token_fd));
-}
-
-static int probe_kern_btf_float(int token_fd)
-{
-	static const char strs[] = "\0float";
-	__u32 types[] = {
-		/* float */
-		BTF_TYPE_FLOAT_ENC(1, 4),
-	};
-
-	return probe_fd(libbpf__load_raw_btf((char *)types, sizeof(types),
-					     strs, sizeof(strs), token_fd));
-}
-
-static int probe_kern_btf_decl_tag(int token_fd)
-{
-	static const char strs[] = "\0tag";
-	__u32 types[] = {
-		/* int */
-		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),  /* [1] */
-		/* VAR x */                                     /* [2] */
-		BTF_TYPE_ENC(1, BTF_INFO_ENC(BTF_KIND_VAR, 0, 0), 1),
-		BTF_VAR_STATIC,
-		/* attr */
-		BTF_TYPE_DECL_TAG_ENC(1, 2, -1),
-	};
-
-	return probe_fd(libbpf__load_raw_btf((char *)types, sizeof(types),
-					     strs, sizeof(strs), token_fd));
-}
-
-static int probe_kern_btf_type_tag(int token_fd)
-{
-	static const char strs[] = "\0tag";
-	__u32 types[] = {
-		/* int */
-		BTF_TYPE_INT_ENC(0, BTF_INT_SIGNED, 0, 32, 4),		/* [1] */
-		/* attr */
-		BTF_TYPE_TYPE_TAG_ENC(1, 1),				/* [2] */
-		/* ptr */
-		BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_PTR, 0, 0), 2),	/* [3] */
-	};
-
-	return probe_fd(libbpf__load_raw_btf((char *)types, sizeof(types),
-					     strs, sizeof(strs), token_fd));
-}
-
-static int probe_kern_array_mmap(int token_fd)
-{
-	LIBBPF_OPTS(bpf_map_create_opts, opts,
-		.map_flags = BPF_F_MMAPABLE | (token_fd ? BPF_F_TOKEN_FD : 0),
-		.token_fd = token_fd,
-	);
-	int fd;
-
-	fd = bpf_map_create(BPF_MAP_TYPE_ARRAY, "libbpf_mmap", sizeof(int), sizeof(int), 1, &opts);
-	return probe_fd(fd);
-}
-
-static int probe_kern_exp_attach_type(int token_fd)
-{
-	LIBBPF_OPTS(bpf_prog_load_opts, opts,
-		.expected_attach_type = BPF_CGROUP_INET_SOCK_CREATE,
-		.token_fd = token_fd,
-		.prog_flags = token_fd ? BPF_F_TOKEN_FD : 0,
-	);
-	struct bpf_insn insns[] = {
-		BPF_MOV64_IMM(BPF_REG_0, 0),
-		BPF_EXIT_INSN(),
-	};
-	int fd, insn_cnt = ARRAY_SIZE(insns);
-
-	/* use any valid combination of program type and (optional)
-	 * non-zero expected attach type (i.e., not a BPF_CGROUP_INET_INGRESS)
-	 * to see if kernel supports expected_attach_type field for
-	 * BPF_PROG_LOAD command
-	 */
-	fd = bpf_prog_load(BPF_PROG_TYPE_CGROUP_SOCK, NULL, "GPL", insns, insn_cnt, &opts);
-	return probe_fd(fd);
-}
-
-static int probe_kern_probe_read_kernel(int token_fd)
-{
-	LIBBPF_OPTS(bpf_prog_load_opts, opts,
-		.token_fd = token_fd,
-		.prog_flags = token_fd ? BPF_F_TOKEN_FD : 0,
-	);
-	struct bpf_insn insns[] = {
-		BPF_MOV64_REG(BPF_REG_1, BPF_REG_10),	/* r1 = r10 (fp) */
-		BPF_ALU64_IMM(BPF_ADD, BPF_REG_1, -8),	/* r1 += -8 */
-		BPF_MOV64_IMM(BPF_REG_2, 8),		/* r2 = 8 */
-		BPF_MOV64_IMM(BPF_REG_3, 0),		/* r3 = 0 */
-		BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_probe_read_kernel),
-		BPF_EXIT_INSN(),
-	};
-	int fd, insn_cnt = ARRAY_SIZE(insns);
-
-	fd = bpf_prog_load(BPF_PROG_TYPE_TRACEPOINT, NULL, "GPL", insns, insn_cnt, &opts);
-	return probe_fd(fd);
-}
-
-static int probe_prog_bind_map(int token_fd)
-{
-	char *cp, errmsg[STRERR_BUFSIZE];
-	struct bpf_insn insns[] = {
-		BPF_MOV64_IMM(BPF_REG_0, 0),
-		BPF_EXIT_INSN(),
-	};
-	LIBBPF_OPTS(bpf_map_create_opts, map_opts,
-		.token_fd = token_fd,
-		.map_flags = token_fd ? BPF_F_TOKEN_FD : 0,
-	);
-	LIBBPF_OPTS(bpf_prog_load_opts, prog_opts,
-		.token_fd = token_fd,
-		.prog_flags = token_fd ? BPF_F_TOKEN_FD : 0,
-	);
-	int ret, map, prog, insn_cnt = ARRAY_SIZE(insns);
-
-	map = bpf_map_create(BPF_MAP_TYPE_ARRAY, "libbpf_det_bind", sizeof(int), 32, 1, &map_opts);
-	if (map < 0) {
-		ret = -errno;
-		cp = libbpf_strerror_r(ret, errmsg, sizeof(errmsg));
-		pr_warn("Error in %s():%s(%d). Couldn't create simple array map.\n",
-			__func__, cp, -ret);
-		return ret;
-	}
-
-	prog = bpf_prog_load(BPF_PROG_TYPE_SOCKET_FILTER, NULL, "GPL", insns, insn_cnt, &prog_opts);
-	if (prog < 0) {
-		close(map);
-		return 0;
-	}
-
-	ret = bpf_prog_bind_map(prog, map, NULL);
-
-	close(map);
-	close(prog);
-
-	return ret >= 0;
-}
-
-static int probe_module_btf(int token_fd)
-{
-	static const char strs[] = "\0int";
-	__u32 types[] = {
-		/* int */
-		BTF_TYPE_INT_ENC(1, BTF_INT_SIGNED, 0, 32, 4),
-	};
-	struct bpf_btf_info info;
-	__u32 len = sizeof(info);
-	char name[16];
-	int fd, err;
-
-	fd = libbpf__load_raw_btf((char *)types, sizeof(types), strs, sizeof(strs), token_fd);
-	if (fd < 0)
-		return 0; /* BTF not supported at all */
-
-	memset(&info, 0, sizeof(info));
-	info.name = ptr_to_u64(name);
-	info.name_len = sizeof(name);
-
-	/* check that BPF_OBJ_GET_INFO_BY_FD supports specifying name pointer;
-	 * kernel's module BTF support coincides with support for
-	 * name/name_len fields in struct bpf_btf_info.
-	 */
-	err = bpf_btf_get_info_by_fd(fd, &info, &len);
-	close(fd);
-	return !err;
-}
-
-static int probe_perf_link(int token_fd)
-{
-	struct bpf_insn insns[] = {
-		BPF_MOV64_IMM(BPF_REG_0, 0),
-		BPF_EXIT_INSN(),
-	};
-	LIBBPF_OPTS(bpf_prog_load_opts, opts,
-		.token_fd = token_fd,
-		.prog_flags = token_fd ? BPF_F_TOKEN_FD : 0,
-	);
-	int prog_fd, link_fd, err;
-
-	prog_fd = bpf_prog_load(BPF_PROG_TYPE_TRACEPOINT, NULL, "GPL",
-				insns, ARRAY_SIZE(insns), &opts);
-	if (prog_fd < 0)
-		return -errno;
-
-	/* use invalid perf_event FD to get EBADF, if link is supported;
-	 * otherwise EINVAL should be returned
-	 */
-	link_fd = bpf_link_create(prog_fd, -1, BPF_PERF_EVENT, NULL);
-	err = -errno; /* close() can clobber errno */
-
-	if (link_fd >= 0)
-		close(link_fd);
-	close(prog_fd);
-
-	return link_fd < 0 && err == -EBADF;
-}
-
-static int probe_uprobe_multi_link(int token_fd)
-{
-	LIBBPF_OPTS(bpf_prog_load_opts, load_opts,
-		.expected_attach_type = BPF_TRACE_UPROBE_MULTI,
-		.token_fd = token_fd,
-		.prog_flags = token_fd ? BPF_F_TOKEN_FD : 0,
-	);
-	LIBBPF_OPTS(bpf_link_create_opts, link_opts);
-	struct bpf_insn insns[] = {
-		BPF_MOV64_IMM(BPF_REG_0, 0),
-		BPF_EXIT_INSN(),
-	};
-	int prog_fd, link_fd, err;
-	unsigned long offset = 0;
-
-	prog_fd = bpf_prog_load(BPF_PROG_TYPE_KPROBE, NULL, "GPL",
-				insns, ARRAY_SIZE(insns), &load_opts);
-	if (prog_fd < 0)
-		return -errno;
-
-	/* Creating uprobe in '/' binary should fail with -EBADF. */
-	link_opts.uprobe_multi.path = "/";
-	link_opts.uprobe_multi.offsets = &offset;
-	link_opts.uprobe_multi.cnt = 1;
-
-	link_fd = bpf_link_create(prog_fd, -1, BPF_TRACE_UPROBE_MULTI, &link_opts);
-	err = -errno; /* close() can clobber errno */
-
-	if (link_fd >= 0 || err != -EBADF) {
-		if (link_fd >= 0)
-			close(link_fd);
-		close(prog_fd);
-		return 0;
-	}
-
-	/* Initial multi-uprobe support in kernel didn't handle PID filtering
-	 * correctly (it was doing thread filtering, not process filtering).
-	 * So now we'll detect if PID filtering logic was fixed, and, if not,
-	 * we'll pretend multi-uprobes are not supported, if not.
-	 * Multi-uprobes are used in USDT attachment logic, and we need to be
-	 * conservative here, because multi-uprobe selection happens early at
-	 * load time, while the use of PID filtering is known late at
-	 * attachment time, at which point it's too late to undo multi-uprobe
-	 * selection.
-	 *
-	 * Creating uprobe with pid == -1 for (invalid) '/' binary will fail
-	 * early with -EINVAL on kernels with fixed PID filtering logic;
-	 * otherwise -ESRCH would be returned if passed correct binary path
-	 * (but we'll just get -BADF, of course).
-	 */
-	link_opts.uprobe_multi.pid = -1; /* invalid PID */
-	link_opts.uprobe_multi.path = "/"; /* invalid path */
-	link_opts.uprobe_multi.offsets = &offset;
-	link_opts.uprobe_multi.cnt = 1;
-
-	link_fd = bpf_link_create(prog_fd, -1, BPF_TRACE_UPROBE_MULTI, &link_opts);
-	err = -errno; /* close() can clobber errno */
-
-	if (link_fd >= 0)
-		close(link_fd);
-	close(prog_fd);
-
-	return link_fd < 0 && err == -EINVAL;
-}
-
-static int probe_kern_bpf_cookie(int token_fd)
-{
-	struct bpf_insn insns[] = {
-		BPF_RAW_INSN(BPF_JMP | BPF_CALL, 0, 0, 0, BPF_FUNC_get_attach_cookie),
-		BPF_EXIT_INSN(),
-	};
-	LIBBPF_OPTS(bpf_prog_load_opts, opts,
-		.token_fd = token_fd,
-		.prog_flags = token_fd ? BPF_F_TOKEN_FD : 0,
-	);
-	int ret, insn_cnt = ARRAY_SIZE(insns);
-
-	ret = bpf_prog_load(BPF_PROG_TYPE_TRACEPOINT, NULL, "GPL", insns, insn_cnt, &opts);
-	return probe_fd(ret);
-}
-
-static int probe_kern_btf_enum64(int token_fd)
-{
-	static const char strs[] = "\0enum64";
-	__u32 types[] = {
-		BTF_TYPE_ENC(1, BTF_INFO_ENC(BTF_KIND_ENUM64, 0, 0), 8),
-	};
-
-	return probe_fd(libbpf__load_raw_btf((char *)types, sizeof(types),
-					     strs, sizeof(strs), token_fd));
-}
-
-static int probe_kern_arg_ctx_tag(int token_fd)
-{
-	static const char strs[] = "\0a\0b\0arg:ctx\0";
-	const __u32 types[] = {
-		/* [1] INT */
-		BTF_TYPE_INT_ENC(1 /* "a" */, BTF_INT_SIGNED, 0, 32, 4),
-		/* [2] PTR -> VOID */
-		BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_PTR, 0, 0), 0),
-		/* [3] FUNC_PROTO `int(void *a)` */
-		BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_FUNC_PROTO, 0, 1), 1),
-		BTF_PARAM_ENC(1 /* "a" */, 2),
-		/* [4] FUNC 'a' -> FUNC_PROTO (main prog) */
-		BTF_TYPE_ENC(1 /* "a" */, BTF_INFO_ENC(BTF_KIND_FUNC, 0, BTF_FUNC_GLOBAL), 3),
-		/* [5] FUNC_PROTO `int(void *b __arg_ctx)` */
-		BTF_TYPE_ENC(0, BTF_INFO_ENC(BTF_KIND_FUNC_PROTO, 0, 1), 1),
-		BTF_PARAM_ENC(3 /* "b" */, 2),
-		/* [6] FUNC 'b' -> FUNC_PROTO (subprog) */
-		BTF_TYPE_ENC(3 /* "b" */, BTF_INFO_ENC(BTF_KIND_FUNC, 0, BTF_FUNC_GLOBAL), 5),
-		/* [7] DECL_TAG 'arg:ctx' -> func 'b' arg 'b' */
-		BTF_TYPE_DECL_TAG_ENC(5 /* "arg:ctx" */, 6, 0),
-	};
-	const struct bpf_insn insns[] = {
-		/* main prog */
-		BPF_CALL_REL(+1),
-		BPF_EXIT_INSN(),
-		/* global subprog */
-		BPF_EMIT_CALL(BPF_FUNC_get_func_ip), /* needs PTR_TO_CTX */
-		BPF_EXIT_INSN(),
-	};
-	const struct bpf_func_info_min func_infos[] = {
-		{ 0, 4 }, /* main prog -> FUNC 'a' */
-		{ 2, 6 }, /* subprog -> FUNC 'b' */
-	};
-	LIBBPF_OPTS(bpf_prog_load_opts, opts,
-		.token_fd = token_fd,
-		.prog_flags = token_fd ? BPF_F_TOKEN_FD : 0,
-	);
-	int prog_fd, btf_fd, insn_cnt = ARRAY_SIZE(insns);
-
-	btf_fd = libbpf__load_raw_btf((char *)types, sizeof(types), strs, sizeof(strs), token_fd);
-	if (btf_fd < 0)
-		return 0;
-
-	opts.prog_btf_fd = btf_fd;
-	opts.func_info = &func_infos;
-	opts.func_info_cnt = ARRAY_SIZE(func_infos);
-	opts.func_info_rec_size = sizeof(func_infos[0]);
-
-	prog_fd = bpf_prog_load(BPF_PROG_TYPE_KPROBE, "det_arg_ctx",
-				"GPL", insns, insn_cnt, &opts);
-	close(btf_fd);
-
-	return probe_fd(prog_fd);
-}
-
-typedef int (*feature_probe_fn)(int /* token_fd */);
-
-static struct kern_feature_cache feature_cache;
-
-static struct kern_feature_desc {
-	const char *desc;
-	feature_probe_fn probe;
-} feature_probes[__FEAT_CNT] = {
-	[FEAT_PROG_NAME] = {
-		"BPF program name", probe_kern_prog_name,
-	},
-	[FEAT_GLOBAL_DATA] = {
-		"global variables", probe_kern_global_data,
-	},
-	[FEAT_BTF] = {
-		"minimal BTF", probe_kern_btf,
-	},
-	[FEAT_BTF_FUNC] = {
-		"BTF functions", probe_kern_btf_func,
-	},
-	[FEAT_BTF_GLOBAL_FUNC] = {
-		"BTF global function", probe_kern_btf_func_global,
-	},
-	[FEAT_BTF_DATASEC] = {
-		"BTF data section and variable", probe_kern_btf_datasec,
-	},
-	[FEAT_ARRAY_MMAP] = {
-		"ARRAY map mmap()", probe_kern_array_mmap,
-	},
-	[FEAT_EXP_ATTACH_TYPE] = {
-		"BPF_PROG_LOAD expected_attach_type attribute",
-		probe_kern_exp_attach_type,
-	},
-	[FEAT_PROBE_READ_KERN] = {
-		"bpf_probe_read_kernel() helper", probe_kern_probe_read_kernel,
-	},
-	[FEAT_PROG_BIND_MAP] = {
-		"BPF_PROG_BIND_MAP support", probe_prog_bind_map,
-	},
-	[FEAT_MODULE_BTF] = {
-		"module BTF support", probe_module_btf,
-	},
-	[FEAT_BTF_FLOAT] = {
-		"BTF_KIND_FLOAT support", probe_kern_btf_float,
-	},
-	[FEAT_PERF_LINK] = {
-		"BPF perf link support", probe_perf_link,
-	},
-	[FEAT_BTF_DECL_TAG] = {
-		"BTF_KIND_DECL_TAG support", probe_kern_btf_decl_tag,
-	},
-	[FEAT_BTF_TYPE_TAG] = {
-		"BTF_KIND_TYPE_TAG support", probe_kern_btf_type_tag,
-	},
-	[FEAT_MEMCG_ACCOUNT] = {
-		"memcg-based memory accounting", probe_memcg_account,
-	},
-	[FEAT_BPF_COOKIE] = {
-		"BPF cookie support", probe_kern_bpf_cookie,
-	},
-	[FEAT_BTF_ENUM64] = {
-		"BTF_KIND_ENUM64 support", probe_kern_btf_enum64,
-	},
-	[FEAT_SYSCALL_WRAPPER] = {
-		"Kernel using syscall wrapper", probe_kern_syscall_wrapper,
-	},
-	[FEAT_UPROBE_MULTI_LINK] = {
-		"BPF multi-uprobe link support", probe_uprobe_multi_link,
-	},
-	[FEAT_ARG_CTX_TAG] = {
-		"kernel-side __arg_ctx tag", probe_kern_arg_ctx_tag,
-	},
-	[FEAT_BTF_QMARK_DATASEC] = {
-		"BTF DATASEC names starting from '?'", probe_kern_btf_qmark_datasec,
-	},
-};
-
-bool feat_supported(struct kern_feature_cache *cache, enum kern_feature_id feat_id)
-{
-	struct kern_feature_desc *feat = &feature_probes[feat_id];
-	int ret;
-
-	/* assume global feature cache, unless custom one is provided */
-	if (!cache)
-		cache = &feature_cache;
-
-	if (READ_ONCE(cache->res[feat_id]) == FEAT_UNKNOWN) {
-		ret = feat->probe(cache->token_fd);
-		if (ret > 0) {
-			WRITE_ONCE(cache->res[feat_id], FEAT_SUPPORTED);
-		} else if (ret == 0) {
-			WRITE_ONCE(cache->res[feat_id], FEAT_MISSING);
-		} else {
-			pr_warn("Detection of kernel %s support failed: %d\n", feat->desc, ret);
-			WRITE_ONCE(cache->res[feat_id], FEAT_MISSING);
-		}
-	}
-
-	return READ_ONCE(cache->res[feat_id]) == FEAT_SUPPORTED;
-}
--- a/src/libbpf.c
+++ b/src/libbpf.c
--- a/src/libbpf.h
+++ b/src/libbpf.h
@@ -98,10 +98,7 @@ typedef int (*libbpf_print_fn_t)(enum libbpf_print_level level,

 /**
 * @brief **libbpf_set_print()** sets user-provided log callback function to
- * be used for libbpf warnings and informational messages. If the user callback
- * is not set, messages are logged to stderr by default. The verbosity of these
- * messages can be controlled by setting the environment variable
- * LIBBPF_LOG_LEVEL to either warn, info, or debug.
+ * be used for libbpf warnings and informational messages.
 * @param fn The log print function. If NULL, libbpf won't print anything.
 * @return Pointer to old print function.
 *
@@ -180,29 +177,10 @@ struct bpf_object_open_opts {
 	 * logs through its print callback.
 	 */
 	__u32 kernel_log_level;
-	/* Path to BPF FS mount point to derive BPF token from.
-	 *
-	 * Created BPF token will be used for all bpf() syscall operations
-	 * that accept BPF token (e.g., map creation, BTF and program loads,
-	 * etc) automatically within instantiated BPF object.
-	 *
-	 * If bpf_token_path is not specified, libbpf will consult
-	 * LIBBPF_BPF_TOKEN_PATH environment variable. If set, it will be
-	 * taken as a value of bpf_token_path option and will force libbpf to
-	 * either create BPF token from provided custom BPF FS path, or will
-	 * disable implicit BPF token creation, if envvar value is an empty
-	 * string. bpf_token_path overrides LIBBPF_BPF_TOKEN_PATH, if both are
-	 * set at the same time.
-	 *
-	 * Setting bpf_token_path option to empty string disables libbpf's
-	 * automatic attempt to create BPF token from default BPF FS mount
-	 * point (/sys/fs/bpf), in case this default behavior is undesirable.
-	 */
-	const char *bpf_token_path;

 	size_t :0;
 };
-#define bpf_object_open_opts__last_field bpf_token_path
+#define bpf_object_open_opts__last_field kernel_log_level

 /**
 * @brief **bpf_object__open()** creates a bpf_object by opening
@@ -542,12 +520,10 @@ struct bpf_kprobe_multi_opts {
 	size_t cnt;
 	/* create return kprobes */
 	bool retprobe;
-	/* create session kprobes */
-	bool session;
 	size_t :0;
 };

-#define bpf_kprobe_multi_opts__last_field session
+#define bpf_kprobe_multi_opts__last_field retprobe

 LIBBPF_API struct bpf_link *
 bpf_program__attach_kprobe_multi_opts(const struct bpf_program *prog,
@@ -765,20 +741,9 @@ bpf_program__attach_tracepoint_opts(const struct bpf_program *prog,
 				    const char *tp_name,
 				    const struct bpf_tracepoint_opts *opts);

-struct bpf_raw_tracepoint_opts {
-	size_t sz; /* size of this struct for forward/backward compatibility */
-	__u64 cookie;
-	size_t :0;
-};
-#define bpf_raw_tracepoint_opts__last_field cookie
-
 LIBBPF_API struct bpf_link *
 bpf_program__attach_raw_tracepoint(const struct bpf_program *prog,
 				   const char *tp_name);
-LIBBPF_API struct bpf_link *
-bpf_program__attach_raw_tracepoint_opts(const struct bpf_program *prog,
-					const char *tp_name,
-					struct bpf_raw_tracepoint_opts *opts);

 struct bpf_trace_opts {
 	/* size of this struct, for forward/backward compatibility */
@@ -800,8 +765,6 @@ bpf_program__attach_cgroup(const struct bpf_program *prog, int cgroup_fd);
 LIBBPF_API struct bpf_link *
 bpf_program__attach_netns(const struct bpf_program *prog, int netns_fd);
 LIBBPF_API struct bpf_link *
-bpf_program__attach_sockmap(const struct bpf_program *prog, int map_fd);
-LIBBPF_API struct bpf_link *
 bpf_program__attach_xdp(const struct bpf_program *prog, int ifindex);
 LIBBPF_API struct bpf_link *
 bpf_program__attach_freplace(const struct bpf_program *prog,
@@ -978,23 +941,6 @@ bpf_object__prev_map(const struct bpf_object *obj, const struct bpf_map *map);
 LIBBPF_API int bpf_map__set_autocreate(struct bpf_map *map, bool autocreate);
 LIBBPF_API bool bpf_map__autocreate(const struct bpf_map *map);

-/**
- * @brief **bpf_map__set_autoattach()** sets whether libbpf has to auto-attach
- * map during BPF skeleton attach phase.
- * @param map the BPF map instance
- * @param autoattach whether to attach map during BPF skeleton attach phase
- * @return 0 on success; negative error code, otherwise
- */
-LIBBPF_API int bpf_map__set_autoattach(struct bpf_map *map, bool autoattach);
-
-/**
- * @brief **bpf_map__autoattach()** returns whether BPF map is configured to
- * auto-attach during BPF skeleton attach phase.
- * @param map the BPF map instance
- * @return true if map is set to auto-attach during skeleton attach phase; false, otherwise
- */
-LIBBPF_API bool bpf_map__autoattach(const struct bpf_map *map);
-
 /**
 * @brief **bpf_map__fd()** gets the file descriptor of the passed
 * BPF map
@@ -1049,7 +995,7 @@ LIBBPF_API int bpf_map__set_map_extra(struct bpf_map *map, __u64 map_extra);

 LIBBPF_API int bpf_map__set_initial_value(struct bpf_map *map,
 					  const void *data, size_t size);
-LIBBPF_API void *bpf_map__initial_value(const struct bpf_map *map, size_t *psize);
+LIBBPF_API void *bpf_map__initial_value(struct bpf_map *map, size_t *psize);

 /**
 * @brief **bpf_map__is_internal()** tells the caller whether or not the
@@ -1317,7 +1263,6 @@ LIBBPF_API int ring_buffer__add(struct ring_buffer *rb, int map_fd,
 				ring_buffer_sample_fn sample_cb, void *ctx);
 LIBBPF_API int ring_buffer__poll(struct ring_buffer *rb, int timeout_ms);
 LIBBPF_API int ring_buffer__consume(struct ring_buffer *rb);
-LIBBPF_API int ring_buffer__consume_n(struct ring_buffer *rb, size_t n);
 LIBBPF_API int ring_buffer__epoll_fd(const struct ring_buffer *rb);

 /**
@@ -1392,17 +1337,6 @@ LIBBPF_API int ring__map_fd(const struct ring *r);
 */
 LIBBPF_API int ring__consume(struct ring *r);

-/**
- * @brief **ring__consume_n()** consumes up to a requested amount of items from
- * a ringbuffer without event polling.
- *
- * @param r A ringbuffer object.
- * @param n Maximum amount of items to consume.
- * @return The number of items consumed, or a negative number if any of the
- * callbacks return an error.
- */
-LIBBPF_API int ring__consume_n(struct ring *r, size_t n);
-
 struct user_ring_buffer_opts {
 	size_t sz; /* size of this struct, for forward/backward compatibility */
 };
@@ -1689,7 +1623,6 @@ struct bpf_map_skeleton {
 	const char *name;
 	struct bpf_map **map;
 	void **mmaped;
-	struct bpf_link **link;
 };

 struct bpf_prog_skeleton {
--- a/src/libbpf.map
+++ b/src/libbpf.map
@@ -245,6 +245,7 @@ LIBBPF_0.3.0 {
 		btf__parse_raw_split;
 		btf__parse_split;
 		btf__new_empty_split;
+		btf__new_split;
 		ring_buffer__epoll_fd;
 } LIBBPF_0.2.0;

@@ -325,6 +326,7 @@ LIBBPF_0.7.0 {
 		bpf_xdp_detach;
 		bpf_xdp_query;
 		bpf_xdp_query_id;
+		btf_ext__raw_data;
 		libbpf_probe_bpf_helper;
 		libbpf_probe_bpf_map_type;
 		libbpf_probe_bpf_prog_type;
@@ -409,21 +411,4 @@ LIBBPF_1.3.0 {
 } LIBBPF_1.2.0;

 LIBBPF_1.4.0 {
-	global:
-		bpf_program__attach_raw_tracepoint_opts;
-		bpf_raw_tracepoint_open_opts;
-		bpf_token_create;
-		btf__new_split;
-		btf_ext__raw_data;
 } LIBBPF_1.3.0;
-
-LIBBPF_1.5.0 {
-	global:
-		btf__distill_base;
-		btf__relocate;
-		bpf_map__autoattach;
-		bpf_map__set_autoattach;
-		bpf_program__attach_sockmap;
-		ring__consume_n;
-		ring_buffer__consume_n;
-} LIBBPF_1.4.0;
--- a/src/libbpf_internal.h
+++ b/src/libbpf_internal.h
@@ -15,24 +15,9 @@
 #include <linux/err.h>
 #include <fcntl.h>
 #include <unistd.h>
-#include <sys/syscall.h>
 #include <libelf.h>
 #include "relo_core.h"

-/* Android's libc doesn't support AT_EACCESS in faccessat() implementation
- * ([0]), and just returns -EINVAL even if file exists and is accessible.
- * See [1] for issues caused by this.
- *
- * So just redefine it to 0 on Android.
- *
- * [0] https://android.googlesource.com/platform/bionic/+/refs/heads/android13-release/libc/bionic/faccessat.cpp#50
- * [1] https://github.com/libbpf/libbpf-bootstrap/issues/250#issuecomment-1911324250
- */
-#ifdef __ANDROID__
-#undef AT_EACCESS
-#define AT_EACCESS 0
-#endif
-
 /* make sure libbpf doesn't use kernel-only integer typedefs */
 #pragma GCC poison u8 u16 u32 u64 s8 s16 s32 s64

@@ -234,9 +219,6 @@ struct btf_type;
 struct btf_type *btf_type_by_id(const struct btf *btf, __u32 type_id);
 const char *btf_kind_str(const struct btf_type *t);
 const struct btf_type *skip_mods_and_typedefs(const struct btf *btf, __u32 id, __u32 *res_id);
-const struct btf_header *btf_header(const struct btf *btf);
-void btf_set_base_btf(struct btf *btf, const struct btf *base_btf);
-int btf_relocate(struct btf *btf, const struct btf *base_btf, __u32 **id_map);

 static inline enum btf_func_linkage btf_func_linkage(const struct btf_type *t)
 {
@@ -375,39 +357,18 @@ enum kern_feature_id {
 	FEAT_SYSCALL_WRAPPER,
 	/* BPF multi-uprobe link support */
 	FEAT_UPROBE_MULTI_LINK,
-	/* Kernel supports arg:ctx tag (__arg_ctx) for global subprogs natively */
-	FEAT_ARG_CTX_TAG,
-	/* Kernel supports '?' at the front of datasec names */
-	FEAT_BTF_QMARK_DATASEC,
 	__FEAT_CNT,
 };

-enum kern_feature_result {
-	FEAT_UNKNOWN = 0,
-	FEAT_SUPPORTED = 1,
-	FEAT_MISSING = 2,
-};
-
-struct kern_feature_cache {
-	enum kern_feature_result res[__FEAT_CNT];
-	int token_fd;
-};
-
-bool feat_supported(struct kern_feature_cache *cache, enum kern_feature_id feat_id);
+int probe_memcg_account(void);
 bool kernel_supports(const struct bpf_object *obj, enum kern_feature_id feat_id);
-
-int probe_kern_syscall_wrapper(int token_fd);
-int probe_memcg_account(int token_fd);
 int bump_rlimit_memlock(void);

 int parse_cpu_mask_str(const char *s, bool **mask, int *mask_sz);
 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,
-			 int token_fd);
-int btf_load_into_kernel(struct btf *btf,
-			 char *log_buf, size_t log_sz, __u32 log_level,
-			 int token_fd);
+			 const char *str_sec, size_t str_len);
+int btf_load_into_kernel(struct btf *btf, char *log_buf, size_t log_sz, __u32 log_level);

 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,
@@ -511,38 +472,21 @@ struct bpf_line_info_min {
 	__u32	line_col;
 };

-enum btf_field_iter_kind {
-	BTF_FIELD_ITER_IDS,
-	BTF_FIELD_ITER_STRS,
-};
-
-struct btf_field_desc {
-	/* once-per-type offsets */
-	int t_off_cnt, t_offs[2];
-	/* member struct size, or zero, if no members */
-	int m_sz;
-	/* repeated per-member offsets */
-	int m_off_cnt, m_offs[1];
-};
-
-struct btf_field_iter {
-	struct btf_field_desc desc;
-	void *p;
-	int m_idx;
-	int off_idx;
-	int vlen;
-};
-
-int btf_field_iter_init(struct btf_field_iter *it, struct btf_type *t, enum btf_field_iter_kind iter_kind);
-__u32 *btf_field_iter_next(struct btf_field_iter *it);

 typedef int (*type_id_visit_fn)(__u32 *type_id, void *ctx);
 typedef int (*str_off_visit_fn)(__u32 *str_off, void *ctx);
+int btf_type_visit_type_ids(struct btf_type *t, type_id_visit_fn visit, void *ctx);
+int btf_type_visit_str_offs(struct btf_type *t, str_off_visit_fn visit, void *ctx);
 int btf_ext_visit_type_ids(struct btf_ext *btf_ext, type_id_visit_fn visit, void *ctx);
 int btf_ext_visit_str_offs(struct btf_ext *btf_ext, str_off_visit_fn visit, void *ctx);
 __s32 btf__find_by_name_kind_own(const struct btf *btf, const char *type_name,
 				 __u32 kind);

+typedef int (*kallsyms_cb_t)(unsigned long long sym_addr, char sym_type,
+			     const char *sym_name, void *ctx);
+
+int libbpf_kallsyms_parse(kallsyms_cb_t cb, void *arg);
+
 /* handle direct returned errors */
 static inline int libbpf_err(int ret)
 {
@@ -588,17 +532,6 @@ static inline bool is_ldimm64_insn(struct bpf_insn *insn)
 	return insn->code == (BPF_LD | BPF_IMM | BPF_DW);
 }

-/* Unconditionally dup FD, ensuring it doesn't use [0, 2] range.
- * Original FD is not closed or altered in any other way.
- * Preserves original FD value, if it's invalid (negative).
- */
-static inline int dup_good_fd(int fd)
-{
-	if (fd < 0)
-		return fd;
-	return fcntl(fd, F_DUPFD_CLOEXEC, 3);
-}
-
 /* if fd is stdin, stdout, or stderr, dup to a fd greater than 2
 * Takes ownership of the fd passed in, and closes it if calling
 * fcntl(fd, F_DUPFD_CLOEXEC, 3).
@@ -610,7 +543,7 @@ static inline int ensure_good_fd(int fd)
 	if (fd < 0)
 		return fd;
 	if (fd < 3) {
-		fd = dup_good_fd(fd);
+		fd = fcntl(fd, F_DUPFD_CLOEXEC, 3);
 		saved_errno = errno;
 		close(old_fd);
 		errno = saved_errno;
@@ -622,11 +555,6 @@ static inline int ensure_good_fd(int fd)
 	return fd;
 }

-static inline int sys_dup3(int oldfd, int newfd, int flags)
-{
-	return syscall(__NR_dup3, oldfd, newfd, flags);
-}
-
 /* Point *fixed_fd* to the same file that *tmp_fd* points to.
 * Regardless of success, *tmp_fd* is closed.
 * Whatever *fixed_fd* pointed to is closed silently.
@@ -635,7 +563,7 @@ static inline int reuse_fd(int fixed_fd, int tmp_fd)
 {
 	int err;

-	err = sys_dup3(tmp_fd, fixed_fd, O_CLOEXEC);
+	err = dup2(tmp_fd, fixed_fd);
 	err = err < 0 ? -errno : 0;
 	close(tmp_fd); /* clean up temporary FD */
 	return err;
@@ -685,6 +613,4 @@ int elf_resolve_syms_offsets(const char *binary_path, int cnt,
 int elf_resolve_pattern_offsets(const char *binary_path, const char *pattern,
 				 unsigned long **poffsets, size_t *pcnt);

-int probe_fd(int fd);
-
 #endif /* __LIBBPF_LIBBPF_INTERNAL_H */
--- a/src/libbpf_probes.c
+++ b/src/libbpf_probes.c
@@ -74,6 +74,9 @@ static __u32 get_debian_kernel_version(struct utsname *info)
 	if (sscanf(p, "Debian %u.%u.%u", &major, &minor, &patch) != 3)
 		return 0;

+        if (major == 4 && minor == 19 && patch > 255)
+                return KERNEL_VERSION(major, minor, 255);
+
 	return KERNEL_VERSION(major, minor, patch);
 }

@@ -219,8 +222,7 @@ int libbpf_probe_bpf_prog_type(enum bpf_prog_type prog_type, const void *opts)
 }

 int libbpf__load_raw_btf(const char *raw_types, size_t types_len,
-			 const char *str_sec, size_t str_len,
-			 int token_fd)
+			 const char *str_sec, size_t str_len)
 {
 	struct btf_header hdr = {
 		.magic = BTF_MAGIC,
@@ -230,10 +232,6 @@ int libbpf__load_raw_btf(const char *raw_types, size_t types_len,
 		.str_off = types_len,
 		.str_len = str_len,
 	};
-	LIBBPF_OPTS(bpf_btf_load_opts, opts,
-		.token_fd = token_fd,
-		.btf_flags = token_fd ? BPF_F_TOKEN_FD : 0,
-	);
 	int btf_fd, btf_len;
 	__u8 *raw_btf;

@@ -246,7 +244,7 @@ int libbpf__load_raw_btf(const char *raw_types, size_t types_len,
 	memcpy(raw_btf + hdr.hdr_len, raw_types, hdr.type_len);
 	memcpy(raw_btf + hdr.hdr_len + hdr.type_len, str_sec, hdr.str_len);

-	btf_fd = bpf_btf_load(raw_btf, btf_len, &opts);
+	btf_fd = bpf_btf_load(raw_btf, btf_len, NULL);

 	free(raw_btf);
 	return btf_fd;
@@ -276,7 +274,7 @@ static int load_local_storage_btf(void)
 	};

 	return libbpf__load_raw_btf((char *)types, sizeof(types),
-				     strs, sizeof(strs), 0);
+				     strs, sizeof(strs));
 }

 static int probe_map_create(enum bpf_map_type map_type)
@@ -331,20 +329,12 @@ static int probe_map_create(enum bpf_map_type map_type)
 	case BPF_MAP_TYPE_STRUCT_OPS:
 		/* we'll get -ENOTSUPP for invalid BTF type ID for struct_ops */
 		opts.btf_vmlinux_value_type_id = 1;
-		opts.value_type_btf_obj_fd = -1;
 		exp_err = -524; /* -ENOTSUPP */
 		break;
 	case BPF_MAP_TYPE_BLOOM_FILTER:
 		key_size = 0;
 		max_entries = 1;
 		break;
-	case BPF_MAP_TYPE_ARENA:
-		key_size	= 0;
-		value_size	= 0;
-		max_entries	= 1; /* one page */
-		opts.map_extra	= 0; /* can mmap() at any address */
-		opts.map_flags	= BPF_F_MMAPABLE;
-		break;
 	case BPF_MAP_TYPE_HASH:
 	case BPF_MAP_TYPE_ARRAY:
 	case BPF_MAP_TYPE_PROG_ARRAY:
@@ -448,8 +438,7 @@ int libbpf_probe_bpf_helper(enum bpf_prog_type prog_type, enum bpf_func_id helpe
 	/* If BPF verifier doesn't recognize BPF helper ID (enum bpf_func_id)
 	 * at all, it will emit something like "invalid func unknown#181".
 	 * If BPF verifier recognizes BPF helper but it's not supported for
-	 * given BPF program type, it will emit "unknown func bpf_sys_bpf#166"
-	 * or "program of this type cannot use helper bpf_sys_bpf#166".
+	 * given BPF program type, it will emit "unknown func bpf_sys_bpf#166".
 	 * In both cases, provided combination of BPF program type and BPF
 	 * helper is not supported by the kernel.
 	 * In all other cases, probe_prog_load() above will either succeed (e.g.,
@@ -458,8 +447,7 @@ int libbpf_probe_bpf_helper(enum bpf_prog_type prog_type, enum bpf_func_id helpe
 	 * that), or we'll get some more specific BPF verifier error about
 	 * some unsatisfied conditions.
 	 */
-	if (ret == 0 && (strstr(buf, "invalid func ") || strstr(buf, "unknown func ") ||
-			 strstr(buf, "program of this type cannot use helper ")))
+	if (ret == 0 && (strstr(buf, "invalid func ") || strstr(buf, "unknown func ")))
 		return 0;
 	return 1; /* assume supported */
 }
--- a/src/libbpf_version.h
+++ b/src/libbpf_version.h
@@ -4,6 +4,6 @@
 #define __LIBBPF_VERSION_H

 #define LIBBPF_MAJOR_VERSION 1
-#define LIBBPF_MINOR_VERSION 5
+#define LIBBPF_MINOR_VERSION 4

 #endif /* __LIBBPF_VERSION_H */
--- a/src/linker.c
+++ b/src/linker.c
@@ -957,33 +957,19 @@ static int check_btf_str_off(__u32 *str_off, void *ctx)
 static int linker_sanity_check_btf(struct src_obj *obj)
 {
 	struct btf_type *t;
-	int i, n, err;
+	int i, n, err = 0;

 	if (!obj->btf)
 		return 0;

 	n = btf__type_cnt(obj->btf);
 	for (i = 1; i < n; i++) {
-		struct btf_field_iter it;
-		__u32 *type_id, *str_off;
-
 		t = btf_type_by_id(obj->btf, i);

-		err = btf_field_iter_init(&it, t, BTF_FIELD_ITER_IDS);
+		err = err ?: btf_type_visit_type_ids(t, check_btf_type_id, obj->btf);
+		err = err ?: btf_type_visit_str_offs(t, check_btf_str_off, obj->btf);
 		if (err)
 			return err;
-		while ((type_id = btf_field_iter_next(&it))) {
-			if (*type_id >= n)
-				return -EINVAL;
-		}
-
-		err = btf_field_iter_init(&it, t, BTF_FIELD_ITER_STRS);
-		if (err)
-			return err;
-		while ((str_off = btf_field_iter_next(&it))) {
-			if (!btf__str_by_offset(obj->btf, *str_off))
-				return -EINVAL;
-		}
 	}

 	return 0;
@@ -2227,17 +2213,10 @@ static int linker_fixup_btf(struct src_obj *obj)
 		vi = btf_var_secinfos(t);
 		for (j = 0, m = btf_vlen(t); j < m; j++, vi++) {
 			const struct btf_type *vt = btf__type_by_id(obj->btf, vi->type);
-			const char *var_name;
-			int var_linkage;
+			const char *var_name = btf__str_by_offset(obj->btf, vt->name_off);
+			int var_linkage = btf_var(vt)->linkage;
 			Elf64_Sym *sym;

-			/* could be a variable or function */
-			if (!btf_is_var(vt))
-				continue;
-
-			var_name = btf__str_by_offset(obj->btf, vt->name_off);
-			var_linkage = btf_var(vt)->linkage;
-
 			/* no need to patch up static or extern vars */
 			if (var_linkage != BTF_VAR_GLOBAL_ALLOCATED)
 				continue;
@@ -2255,10 +2234,26 @@ static int linker_fixup_btf(struct src_obj *obj)
 	return 0;
 }

+static int remap_type_id(__u32 *type_id, void *ctx)
+{
+	int *id_map = ctx;
+	int new_id = id_map[*type_id];
+
+	/* Error out if the type wasn't remapped. Ignore VOID which stays VOID. */
+	if (new_id == 0 && *type_id != 0) {
+		pr_warn("failed to find new ID mapping for original BTF type ID %u\n", *type_id);
+		return -EINVAL;
+	}
+
+	*type_id = id_map[*type_id];
+
+	return 0;
+}
+
 static int linker_append_btf(struct bpf_linker *linker, struct src_obj *obj)
 {
 	const struct btf_type *t;
-	int i, j, n, start_id, id, err;
+	int i, j, n, start_id, id;
 	const char *name;

 	if (!obj->btf)
@@ -2329,25 +2324,9 @@ static int linker_append_btf(struct bpf_linker *linker, struct src_obj *obj)
 	n = btf__type_cnt(linker->btf);
 	for (i = start_id; i < n; i++) {
 		struct btf_type *dst_t = btf_type_by_id(linker->btf, i);
-		struct btf_field_iter it;
-		__u32 *type_id;

-		err = btf_field_iter_init(&it, dst_t, BTF_FIELD_ITER_IDS);
-		if (err)
-			return err;
-
-		while ((type_id = btf_field_iter_next(&it))) {
-			int new_id = obj->btf_type_map[*type_id];
-
-			/* Error out if the type wasn't remapped. Ignore VOID which stays VOID. */
-			if (new_id == 0 && *type_id != 0) {
-				pr_warn("failed to find new ID mapping for original BTF type ID %u\n",
-					*type_id);
-				return -EINVAL;
-			}
-
-			*type_id = obj->btf_type_map[*type_id];
-		}
+		if (btf_type_visit_type_ids(dst_t, remap_type_id, obj->btf_type_map))
+			return -EINVAL;
 	}

 	/* Rewrite VAR/FUNC underlying types (i.e., FUNC's FUNC_PROTO and VAR's
@@ -2753,7 +2732,7 @@ static int finalize_btf(struct bpf_linker *linker)

 	/* Emit .BTF.ext section */
 	if (linker->btf_ext) {
-		raw_data = btf_ext__raw_data(linker->btf_ext, &raw_sz);
+		raw_data = btf_ext__get_raw_data(linker->btf_ext, &raw_sz);
 		if (!raw_data)
 			return -ENOMEM;

--- a/src/netlink.c
+++ b/src/netlink.c
@@ -496,8 +496,8 @@ int bpf_xdp_query(int ifindex, int xdp_flags, struct bpf_xdp_query_opts *opts)
 	if (err)
 		return libbpf_err(err);

-	OPTS_SET(opts, feature_flags, md.flags);
-	OPTS_SET(opts, xdp_zc_max_segs, md.xdp_zc_max_segs);
+	opts->feature_flags = md.flags;
+	opts->xdp_zc_max_segs = md.xdp_zc_max_segs;

 skip_feature_flags:
 	return 0;
--- a/src/ringbuf.c
+++ b/src/ringbuf.c
@@ -231,7 +231,7 @@ static inline int roundup_len(__u32 len)
 	return (len + 7) / 8 * 8;
 }

-static int64_t ringbuf_process_ring(struct ring *r, size_t n)
+static int64_t ringbuf_process_ring(struct ring *r)
 {
 	int *len_ptr, len, err;
 	/* 64-bit to avoid overflow in case of extreme application behavior */
@@ -268,42 +268,12 @@ static int64_t ringbuf_process_ring(struct ring *r, size_t n)
 			}

 			smp_store_release(r->consumer_pos, cons_pos);
-
-			if (cnt >= n)
-				goto done;
 		}
 	} while (got_new_data);
 done:
 	return cnt;
 }

-/* Consume available ring buffer(s) data without event polling, up to n
- * records.
- *
- * Returns number of records consumed across all registered ring buffers (or
- * n, whichever is less), or negative number if any of the callbacks return
- * error.
- */
-int ring_buffer__consume_n(struct ring_buffer *rb, size_t n)
-{
-	int64_t err, res = 0;
-	int i;
-
-	for (i = 0; i < rb->ring_cnt; i++) {
-		struct ring *ring = rb->rings[i];
-
-		err = ringbuf_process_ring(ring, n);
-		if (err < 0)
-			return libbpf_err(err);
-		res += err;
-		n -= err;
-
-		if (n == 0)
-			break;
-	}
-	return res > INT_MAX ? INT_MAX : res;
-}
-
 /* Consume available ring buffer(s) data without event polling.
 * Returns number of records consumed across all registered ring buffers (or
 * INT_MAX, whichever is less), or negative number if any of the callbacks
@@ -317,15 +287,13 @@ int ring_buffer__consume(struct ring_buffer *rb)
 	for (i = 0; i < rb->ring_cnt; i++) {
 		struct ring *ring = rb->rings[i];

-		err = ringbuf_process_ring(ring, INT_MAX);
+		err = ringbuf_process_ring(ring);
 		if (err < 0)
 			return libbpf_err(err);
 		res += err;
-		if (res > INT_MAX) {
-			res = INT_MAX;
-			break;
-		}
 	}
+	if (res > INT_MAX)
+		return INT_MAX;
 	return res;
 }

@@ -346,13 +314,13 @@ int ring_buffer__poll(struct ring_buffer *rb, int timeout_ms)
 		__u32 ring_id = rb->events[i].data.fd;
 		struct ring *ring = rb->rings[ring_id];

-		err = ringbuf_process_ring(ring, INT_MAX);
+		err = ringbuf_process_ring(ring);
 		if (err < 0)
 			return libbpf_err(err);
 		res += err;
 	}
 	if (res > INT_MAX)
-		res = INT_MAX;
+		return INT_MAX;
 	return res;
 }

@@ -403,22 +371,17 @@ int ring__map_fd(const struct ring *r)
 	return r->map_fd;
 }

-int ring__consume_n(struct ring *r, size_t n)
+int ring__consume(struct ring *r)
 {
 	int64_t res;

-	res = ringbuf_process_ring(r, n);
+	res = ringbuf_process_ring(r);
 	if (res < 0)
 		return libbpf_err(res);

 	return res > INT_MAX ? INT_MAX : res;
 }

-int ring__consume(struct ring *r)
-{
-	return ring__consume_n(r, INT_MAX);
-}
-
 static void user_ringbuf_unmap_ring(struct user_ring_buffer *rb)
 {
 	if (rb->consumer_pos) {
--- a/src/str_error.c
+++ b/src/str_error.c
@@ -2,7 +2,6 @@
 #undef _GNU_SOURCE
 #include <string.h>
 #include <stdio.h>
-#include <errno.h>
 #include "str_error.h"

 /* make sure libbpf doesn't use kernel-only integer typedefs */
@@ -16,18 +15,7 @@
 char *libbpf_strerror_r(int err, char *dst, int len)
 {
 	int ret = strerror_r(err < 0 ? -err : err, dst, len);
-	/* on glibc <2.13, ret == -1 and errno is set, if strerror_r() can't
-	 * handle the error, on glibc >=2.13 *positive* (errno-like) error
-	 * code is returned directly
-	 */
-	if (ret == -1)
-		ret = errno;
-	if (ret) {
-		if (ret == EINVAL)
-			/* strerror_r() doesn't recognize this specific error */
-			snprintf(dst, len, "unknown error (%d)", err < 0 ? err : -err);
-		else
-			snprintf(dst, len, "ERROR: strerror_r(%d)=%d", err, ret);
-	}
+	if (ret)
+		snprintf(dst, len, "ERROR: strerror_r(%d)=%d", err, ret);
 	return dst;
 }
--- a/src/str_error.h
+++ b/src/str_error.h
@@ -2,8 +2,5 @@
 #ifndef __LIBBPF_STR_ERROR_H
 #define __LIBBPF_STR_ERROR_H

-#define STRERR_BUFSIZE  128
-
 char *libbpf_strerror_r(int err, char *dst, int len);
-
 #endif /* __LIBBPF_STR_ERROR_H */
--- a/src/usdt.bpf.h
+++ b/src/usdt.bpf.h
@@ -214,18 +214,18 @@ long bpf_usdt_cookie(struct pt_regs *ctx)

 /* we rely on ___bpf_apply() and ___bpf_narg() macros already defined in bpf_tracing.h */
 #define ___bpf_usdt_args0() ctx
-#define ___bpf_usdt_args1(x) ___bpf_usdt_args0(), ({ long _x; bpf_usdt_arg(ctx, 0, &_x); _x; })
-#define ___bpf_usdt_args2(x, args...) ___bpf_usdt_args1(args), ({ long _x; bpf_usdt_arg(ctx, 1, &_x); _x; })
-#define ___bpf_usdt_args3(x, args...) ___bpf_usdt_args2(args), ({ long _x; bpf_usdt_arg(ctx, 2, &_x); _x; })
-#define ___bpf_usdt_args4(x, args...) ___bpf_usdt_args3(args), ({ long _x; bpf_usdt_arg(ctx, 3, &_x); _x; })
-#define ___bpf_usdt_args5(x, args...) ___bpf_usdt_args4(args), ({ long _x; bpf_usdt_arg(ctx, 4, &_x); _x; })
-#define ___bpf_usdt_args6(x, args...) ___bpf_usdt_args5(args), ({ long _x; bpf_usdt_arg(ctx, 5, &_x); _x; })
-#define ___bpf_usdt_args7(x, args...) ___bpf_usdt_args6(args), ({ long _x; bpf_usdt_arg(ctx, 6, &_x); _x; })
-#define ___bpf_usdt_args8(x, args...) ___bpf_usdt_args7(args), ({ long _x; bpf_usdt_arg(ctx, 7, &_x); _x; })
-#define ___bpf_usdt_args9(x, args...) ___bpf_usdt_args8(args), ({ long _x; bpf_usdt_arg(ctx, 8, &_x); _x; })
-#define ___bpf_usdt_args10(x, args...) ___bpf_usdt_args9(args), ({ long _x; bpf_usdt_arg(ctx, 9, &_x); _x; })
-#define ___bpf_usdt_args11(x, args...) ___bpf_usdt_args10(args), ({ long _x; bpf_usdt_arg(ctx, 10, &_x); _x; })
-#define ___bpf_usdt_args12(x, args...) ___bpf_usdt_args11(args), ({ long _x; bpf_usdt_arg(ctx, 11, &_x); _x; })
+#define ___bpf_usdt_args1(x) ___bpf_usdt_args0(), ({ long _x; bpf_usdt_arg(ctx, 0, &_x); (void *)_x; })
+#define ___bpf_usdt_args2(x, args...) ___bpf_usdt_args1(args), ({ long _x; bpf_usdt_arg(ctx, 1, &_x); (void *)_x; })
+#define ___bpf_usdt_args3(x, args...) ___bpf_usdt_args2(args), ({ long _x; bpf_usdt_arg(ctx, 2, &_x); (void *)_x; })
+#define ___bpf_usdt_args4(x, args...) ___bpf_usdt_args3(args), ({ long _x; bpf_usdt_arg(ctx, 3, &_x); (void *)_x; })
+#define ___bpf_usdt_args5(x, args...) ___bpf_usdt_args4(args), ({ long _x; bpf_usdt_arg(ctx, 4, &_x); (void *)_x; })
+#define ___bpf_usdt_args6(x, args...) ___bpf_usdt_args5(args), ({ long _x; bpf_usdt_arg(ctx, 5, &_x); (void *)_x; })
+#define ___bpf_usdt_args7(x, args...) ___bpf_usdt_args6(args), ({ long _x; bpf_usdt_arg(ctx, 6, &_x); (void *)_x; })
+#define ___bpf_usdt_args8(x, args...) ___bpf_usdt_args7(args), ({ long _x; bpf_usdt_arg(ctx, 7, &_x); (void *)_x; })
+#define ___bpf_usdt_args9(x, args...) ___bpf_usdt_args8(args), ({ long _x; bpf_usdt_arg(ctx, 8, &_x); (void *)_x; })
+#define ___bpf_usdt_args10(x, args...) ___bpf_usdt_args9(args), ({ long _x; bpf_usdt_arg(ctx, 9, &_x); (void *)_x; })
+#define ___bpf_usdt_args11(x, args...) ___bpf_usdt_args10(args), ({ long _x; bpf_usdt_arg(ctx, 10, &_x); (void *)_x; })
+#define ___bpf_usdt_args12(x, args...) ___bpf_usdt_args11(args), ({ long _x; bpf_usdt_arg(ctx, 11, &_x); (void *)_x; })
 #define ___bpf_usdt_args(args...) ___bpf_apply(___bpf_usdt_args, ___bpf_narg(args))(args)

 /*