From 126006852e0fd9c0d94b8598dc4c37549a00f82a Mon Sep 17 00:00:00 2001
From: Daniel J Walsh <dwalsh@redhat.com>
Date: Tue, 6 Aug 2024 07:46:23 -0400
Subject: [PATCH] Bump runc, storage, image vendor to latest containers/common

Signed-off-by: Daniel J Walsh <dwalsh@redhat.com>
---
 go.mod                                        |   11 +-
 go.sum                                        |   24 +-
 vendor/github.com/cilium/ebpf/.clang-format   |   19 -
 vendor/github.com/cilium/ebpf/.gitignore      |   14 -
 vendor/github.com/cilium/ebpf/.golangci.yaml  |   26 -
 vendor/github.com/cilium/ebpf/ARCHITECTURE.md |   92 -
 .../github.com/cilium/ebpf/CODE_OF_CONDUCT.md |   46 -
 vendor/github.com/cilium/ebpf/CONTRIBUTING.md |   48 -
 vendor/github.com/cilium/ebpf/LICENSE         |   23 -
 vendor/github.com/cilium/ebpf/MAINTAINERS.md  |    3 -
 vendor/github.com/cilium/ebpf/Makefile        |  115 --
 vendor/github.com/cilium/ebpf/README.md       |   82 -
 vendor/github.com/cilium/ebpf/asm/alu.go      |  149 --
 .../github.com/cilium/ebpf/asm/alu_string.go  |  107 --
 vendor/github.com/cilium/ebpf/asm/doc.go      |    2 -
 vendor/github.com/cilium/ebpf/asm/func.go     |  250 ---
 .../github.com/cilium/ebpf/asm/func_string.go |  235 ---
 .../github.com/cilium/ebpf/asm/instruction.go |  877 ----------
 vendor/github.com/cilium/ebpf/asm/jump.go     |  127 --
 .../github.com/cilium/ebpf/asm/jump_string.go |   53 -
 .../github.com/cilium/ebpf/asm/load_store.go  |  204 ---
 .../cilium/ebpf/asm/load_store_string.go      |   80 -
 vendor/github.com/cilium/ebpf/asm/metadata.go |   80 -
 vendor/github.com/cilium/ebpf/asm/opcode.go   |  271 ---
 .../cilium/ebpf/asm/opcode_string.go          |   30 -
 vendor/github.com/cilium/ebpf/asm/register.go |   51 -
 .../cilium/ebpf/attachtype_string.go          |   66 -
 vendor/github.com/cilium/ebpf/btf/btf.go      |  869 ----------
 .../github.com/cilium/ebpf/btf/btf_types.go   |  371 -----
 .../cilium/ebpf/btf/btf_types_string.go       |   80 -
 vendor/github.com/cilium/ebpf/btf/core.go     | 1011 -----------
 vendor/github.com/cilium/ebpf/btf/doc.go      |    5 -
 vendor/github.com/cilium/ebpf/btf/ext_info.go |  768 ---------
 vendor/github.com/cilium/ebpf/btf/format.go   |  344 ----
 vendor/github.com/cilium/ebpf/btf/handle.go   |  287 ----
 vendor/github.com/cilium/ebpf/btf/marshal.go  |  543 ------
 vendor/github.com/cilium/ebpf/btf/strings.go  |  214 ---
 .../github.com/cilium/ebpf/btf/traversal.go   |  141 --
 vendor/github.com/cilium/ebpf/btf/types.go    | 1258 --------------
 .../github.com/cilium/ebpf/btf/workarounds.go |   26 -
 vendor/github.com/cilium/ebpf/collection.go   |  841 ----------
 vendor/github.com/cilium/ebpf/doc.go          |   25 -
 vendor/github.com/cilium/ebpf/elf_reader.go   | 1314 ---------------
 vendor/github.com/cilium/ebpf/info.go         |  373 -----
 .../github.com/cilium/ebpf/internal/align.go  |    8 -
 .../github.com/cilium/ebpf/internal/buffer.go |   31 -
 vendor/github.com/cilium/ebpf/internal/cpu.go |   51 -
 .../github.com/cilium/ebpf/internal/deque.go  |   91 -
 vendor/github.com/cilium/ebpf/internal/elf.go |  102 --
 .../cilium/ebpf/internal/endian_be.go         |   12 -
 .../cilium/ebpf/internal/endian_le.go         |   12 -
 .../github.com/cilium/ebpf/internal/errors.go |  198 ---
 .../cilium/ebpf/internal/feature.go           |  184 --
 vendor/github.com/cilium/ebpf/internal/io.go  |  128 --
 .../cilium/ebpf/internal/kconfig/kconfig.go   |  267 ---
 .../cilium/ebpf/internal/memoize.go           |   26 -
 .../github.com/cilium/ebpf/internal/output.go |   97 --
 .../cilium/ebpf/internal/pinning.go           |   65 -
 .../cilium/ebpf/internal/platform.go          |   43 -
 .../github.com/cilium/ebpf/internal/prog.go   |   11 -
 .../github.com/cilium/ebpf/internal/statfs.go |   23 -
 .../cilium/ebpf/internal/sys/doc.go           |    6 -
 .../github.com/cilium/ebpf/internal/sys/fd.go |  133 --
 .../cilium/ebpf/internal/sys/fd_trace.go      |   93 --
 .../ebpf/internal/sys/mapflags_string.go      |   49 -
 .../cilium/ebpf/internal/sys/ptr.go           |   52 -
 .../cilium/ebpf/internal/sys/ptr_32_be.go     |   14 -
 .../cilium/ebpf/internal/sys/ptr_32_le.go     |   14 -
 .../cilium/ebpf/internal/sys/ptr_64.go        |   13 -
 .../cilium/ebpf/internal/sys/signals.go       |   83 -
 .../cilium/ebpf/internal/sys/syscall.go       |  178 --
 .../cilium/ebpf/internal/sys/types.go         | 1117 -------------
 .../cilium/ebpf/internal/tracefs/kprobe.go    |  359 ----
 .../ebpf/internal/tracefs/probetype_string.go |   24 -
 .../cilium/ebpf/internal/tracefs/uprobe.go    |   16 -
 .../cilium/ebpf/internal/unix/doc.go          |   11 -
 .../cilium/ebpf/internal/unix/types_linux.go  |  202 ---
 .../cilium/ebpf/internal/unix/types_other.go  |  294 ----
 .../github.com/cilium/ebpf/internal/vdso.go   |  153 --
 .../cilium/ebpf/internal/version.go           |  106 --
 vendor/github.com/cilium/ebpf/link/cgroup.go  |  190 ---
 vendor/github.com/cilium/ebpf/link/doc.go     |    2 -
 vendor/github.com/cilium/ebpf/link/iter.go    |   85 -
 vendor/github.com/cilium/ebpf/link/kprobe.go  |  357 ----
 .../cilium/ebpf/link/kprobe_multi.go          |  180 --
 vendor/github.com/cilium/ebpf/link/link.go    |  336 ----
 vendor/github.com/cilium/ebpf/link/netns.go   |   36 -
 .../github.com/cilium/ebpf/link/perf_event.go |  270 ---
 vendor/github.com/cilium/ebpf/link/program.go |   76 -
 vendor/github.com/cilium/ebpf/link/query.go   |   63 -
 .../cilium/ebpf/link/raw_tracepoint.go        |   87 -
 .../cilium/ebpf/link/socket_filter.go         |   40 -
 .../github.com/cilium/ebpf/link/syscalls.go   |  123 --
 .../github.com/cilium/ebpf/link/tracepoint.go |   68 -
 vendor/github.com/cilium/ebpf/link/tracing.go |  199 ---
 vendor/github.com/cilium/ebpf/link/uprobe.go  |  328 ----
 vendor/github.com/cilium/ebpf/link/xdp.go     |   54 -
 vendor/github.com/cilium/ebpf/linker.go       |  391 -----
 vendor/github.com/cilium/ebpf/map.go          | 1478 -----------------
 vendor/github.com/cilium/ebpf/marshalers.go   |  249 ---
 vendor/github.com/cilium/ebpf/prog.go         | 1026 ------------
 vendor/github.com/cilium/ebpf/run-tests.sh    |  152 --
 vendor/github.com/cilium/ebpf/syscalls.go     |  305 ----
 vendor/github.com/cilium/ebpf/types.go        |  279 ----
 vendor/github.com/cilium/ebpf/types_string.go |  118 --
 .../containers/image/v5/copy/compression.go   |  121 +-
 .../containers/image/v5/copy/encryption.go    |    2 +-
 .../containers/image/v5/copy/progress_bars.go |    2 +-
 .../containers/image/v5/copy/single.go        |   24 +-
 .../internal/blobinfocache/blobinfocache.go   |    9 +-
 .../image/v5/internal/blobinfocache/types.go  |   25 +-
 .../image/v5/manifest/docker_schema2.go       |    2 +-
 .../containers/image/v5/manifest/oci.go       |    2 +-
 .../containers/image/v5/ostree/ostree_src.go  |    6 +-
 .../internal/prioritize/prioritize.go         |  134 +-
 .../v5/pkg/blobinfocache/memory/memory.go     |   90 +-
 .../image/v5/pkg/blobinfocache/none/none.go   |   13 +
 .../v5/pkg/blobinfocache/sqlite/sqlite.go     |  107 +-
 .../image/v5/pkg/shortnames/shortnames.go     |    6 +-
 .../image/v5/storage/storage_dest.go          |  372 +++--
 .../containers/image/v5/version/version.go    |    4 +-
 vendor/github.com/containers/storage/VERSION  |    2 +-
 .../storage/drivers/overlay/composefs.go      |   53 +-
 .../storage/drivers/overlay/overlay.go        |    2 +-
 .../storage/pkg/chunked/filesystem_linux.go   |   10 +-
 .../storage/pkg/idmap/idmapped_utils.go       |   13 +-
 .../mattn/go-runewidth/runewidth_table.go     |  323 ++--
 vendor/github.com/opencontainers/runc/NOTICE  |    4 +-
 .../libcontainer/apparmor/apparmor_linux.go   |   15 +-
 .../apparmor/apparmor_unsupported.go          |    1 -
 .../runc/libcontainer/cgroups/cgroups.go      |   16 +
 .../cgroups/devices/devices_emulator.go       |  386 -----
 .../cgroups/ebpf/devicefilter/devicefilter.go |  208 ---
 .../libcontainer/cgroups/ebpf/ebpf_linux.go   |  253 ---
 .../runc/libcontainer/cgroups/file.go         |   44 +-
 .../runc/libcontainer/cgroups/fs/cpu.go       |   37 +
 .../runc/libcontainer/cgroups/fs/cpuset.go    |    2 +-
 .../runc/libcontainer/cgroups/fs/devices.go   |   82 +-
 .../runc/libcontainer/cgroups/fs/fs.go        |   34 +-
 .../runc/libcontainer/cgroups/fs/paths.go     |    5 +-
 .../runc/libcontainer/cgroups/fs2/cpu.go      |   33 +-
 .../libcontainer/cgroups/fs2/defaultpath.go   |    3 +
 .../runc/libcontainer/cgroups/fs2/devices.go  |   75 -
 .../runc/libcontainer/cgroups/fs2/fs2.go      |  101 +-
 .../runc/libcontainer/cgroups/fs2/memory.go   |   10 +-
 .../runc/libcontainer/cgroups/fs2/misc.go     |   52 +
 .../runc/libcontainer/cgroups/fs2/psi.go      |   89 +
 .../runc/libcontainer/cgroups/stats.go        |   27 +-
 .../runc/libcontainer/cgroups/utils.go        |  112 +-
 .../runc/libcontainer/cgroups/v1_utils.go     |   31 +-
 .../runc/libcontainer/configs/blkio_device.go |    8 +-
 .../runc/libcontainer/configs/cgroup_linux.go |   11 +
 .../configs/cgroup_unsupported.go             |    1 -
 .../runc/libcontainer/configs/config.go       |  122 +-
 .../runc/libcontainer/configs/config_linux.go |   31 +-
 .../libcontainer/configs/configs_fuzzer.go    |    1 -
 .../runc/libcontainer/configs/mount.go        |   43 +-
 .../runc/libcontainer/configs/mount_linux.go  |   66 +
 .../libcontainer/configs/mount_unsupported.go |    9 +
 .../libcontainer/configs/namespaces_linux.go  |    7 +
 .../configs/namespaces_syscall.go             |   14 +-
 .../configs/namespaces_syscall_unsupported.go |    1 -
 .../configs/namespaces_unsupported.go         |    1 -
 .../runc/libcontainer/devices/device_unix.go  |    1 -
 .../runc/libcontainer/user/lookup_unix.go     |  157 --
 .../runc/libcontainer/user/user.go            |  604 -------
 .../runc/libcontainer/user/user_fuzzer.go     |   43 -
 .../runc/libcontainer/userns/userns.go        |    9 +-
 .../runc/libcontainer/userns/userns_fuzzer.go |   16 -
 .../runc/libcontainer/userns/userns_linux.go  |   58 +-
 .../userns/userns_linux_fuzzer.go             |    8 +
 .../runc/libcontainer/userns/userns_maps.c    |   79 -
 .../libcontainer/userns/userns_maps_linux.go  |  186 ---
 .../libcontainer/userns/userns_unsupported.go |   16 +-
 .../runc/libcontainer/utils/cmsg.go           |   85 +-
 .../runc/libcontainer/utils/utils.go          |   58 +-
 .../runc/libcontainer/utils/utils_unix.go     |  170 +-
 vendor/github.com/vbauerster/mpb/v8/bar.go    |   15 +-
 vendor/modules.txt                            |   27 +-
 179 files changed, 1843 insertions(+), 25259 deletions(-)
 delete mode 100644 vendor/github.com/cilium/ebpf/.clang-format
 delete mode 100644 vendor/github.com/cilium/ebpf/.gitignore
 delete mode 100644 vendor/github.com/cilium/ebpf/.golangci.yaml
 delete mode 100644 vendor/github.com/cilium/ebpf/ARCHITECTURE.md
 delete mode 100644 vendor/github.com/cilium/ebpf/CODE_OF_CONDUCT.md
 delete mode 100644 vendor/github.com/cilium/ebpf/CONTRIBUTING.md
 delete mode 100644 vendor/github.com/cilium/ebpf/LICENSE
 delete mode 100644 vendor/github.com/cilium/ebpf/MAINTAINERS.md
 delete mode 100644 vendor/github.com/cilium/ebpf/Makefile
 delete mode 100644 vendor/github.com/cilium/ebpf/README.md
 delete mode 100644 vendor/github.com/cilium/ebpf/asm/alu.go
 delete mode 100644 vendor/github.com/cilium/ebpf/asm/alu_string.go
 delete mode 100644 vendor/github.com/cilium/ebpf/asm/doc.go
 delete mode 100644 vendor/github.com/cilium/ebpf/asm/func.go
 delete mode 100644 vendor/github.com/cilium/ebpf/asm/func_string.go
 delete mode 100644 vendor/github.com/cilium/ebpf/asm/instruction.go
 delete mode 100644 vendor/github.com/cilium/ebpf/asm/jump.go
 delete mode 100644 vendor/github.com/cilium/ebpf/asm/jump_string.go
 delete mode 100644 vendor/github.com/cilium/ebpf/asm/load_store.go
 delete mode 100644 vendor/github.com/cilium/ebpf/asm/load_store_string.go
 delete mode 100644 vendor/github.com/cilium/ebpf/asm/metadata.go
 delete mode 100644 vendor/github.com/cilium/ebpf/asm/opcode.go
 delete mode 100644 vendor/github.com/cilium/ebpf/asm/opcode_string.go
 delete mode 100644 vendor/github.com/cilium/ebpf/asm/register.go
 delete mode 100644 vendor/github.com/cilium/ebpf/attachtype_string.go
 delete mode 100644 vendor/github.com/cilium/ebpf/btf/btf.go
 delete mode 100644 vendor/github.com/cilium/ebpf/btf/btf_types.go
 delete mode 100644 vendor/github.com/cilium/ebpf/btf/btf_types_string.go
 delete mode 100644 vendor/github.com/cilium/ebpf/btf/core.go
 delete mode 100644 vendor/github.com/cilium/ebpf/btf/doc.go
 delete mode 100644 vendor/github.com/cilium/ebpf/btf/ext_info.go
 delete mode 100644 vendor/github.com/cilium/ebpf/btf/format.go
 delete mode 100644 vendor/github.com/cilium/ebpf/btf/handle.go
 delete mode 100644 vendor/github.com/cilium/ebpf/btf/marshal.go
 delete mode 100644 vendor/github.com/cilium/ebpf/btf/strings.go
 delete mode 100644 vendor/github.com/cilium/ebpf/btf/traversal.go
 delete mode 100644 vendor/github.com/cilium/ebpf/btf/types.go
 delete mode 100644 vendor/github.com/cilium/ebpf/btf/workarounds.go
 delete mode 100644 vendor/github.com/cilium/ebpf/collection.go
 delete mode 100644 vendor/github.com/cilium/ebpf/doc.go
 delete mode 100644 vendor/github.com/cilium/ebpf/elf_reader.go
 delete mode 100644 vendor/github.com/cilium/ebpf/info.go
 delete mode 100644 vendor/github.com/cilium/ebpf/internal/align.go
 delete mode 100644 vendor/github.com/cilium/ebpf/internal/buffer.go
 delete mode 100644 vendor/github.com/cilium/ebpf/internal/cpu.go
 delete mode 100644 vendor/github.com/cilium/ebpf/internal/deque.go
 delete mode 100644 vendor/github.com/cilium/ebpf/internal/elf.go
 delete mode 100644 vendor/github.com/cilium/ebpf/internal/endian_be.go
 delete mode 100644 vendor/github.com/cilium/ebpf/internal/endian_le.go
 delete mode 100644 vendor/github.com/cilium/ebpf/internal/errors.go
 delete mode 100644 vendor/github.com/cilium/ebpf/internal/feature.go
 delete mode 100644 vendor/github.com/cilium/ebpf/internal/io.go
 delete mode 100644 vendor/github.com/cilium/ebpf/internal/kconfig/kconfig.go
 delete mode 100644 vendor/github.com/cilium/ebpf/internal/memoize.go
 delete mode 100644 vendor/github.com/cilium/ebpf/internal/output.go
 delete mode 100644 vendor/github.com/cilium/ebpf/internal/pinning.go
 delete mode 100644 vendor/github.com/cilium/ebpf/internal/platform.go
 delete mode 100644 vendor/github.com/cilium/ebpf/internal/prog.go
 delete mode 100644 vendor/github.com/cilium/ebpf/internal/statfs.go
 delete mode 100644 vendor/github.com/cilium/ebpf/internal/sys/doc.go
 delete mode 100644 vendor/github.com/cilium/ebpf/internal/sys/fd.go
 delete mode 100644 vendor/github.com/cilium/ebpf/internal/sys/fd_trace.go
 delete mode 100644 vendor/github.com/cilium/ebpf/internal/sys/mapflags_string.go
 delete mode 100644 vendor/github.com/cilium/ebpf/internal/sys/ptr.go
 delete mode 100644 vendor/github.com/cilium/ebpf/internal/sys/ptr_32_be.go
 delete mode 100644 vendor/github.com/cilium/ebpf/internal/sys/ptr_32_le.go
 delete mode 100644 vendor/github.com/cilium/ebpf/internal/sys/ptr_64.go
 delete mode 100644 vendor/github.com/cilium/ebpf/internal/sys/signals.go
 delete mode 100644 vendor/github.com/cilium/ebpf/internal/sys/syscall.go
 delete mode 100644 vendor/github.com/cilium/ebpf/internal/sys/types.go
 delete mode 100644 vendor/github.com/cilium/ebpf/internal/tracefs/kprobe.go
 delete mode 100644 vendor/github.com/cilium/ebpf/internal/tracefs/probetype_string.go
 delete mode 100644 vendor/github.com/cilium/ebpf/internal/tracefs/uprobe.go
 delete mode 100644 vendor/github.com/cilium/ebpf/internal/unix/doc.go
 delete mode 100644 vendor/github.com/cilium/ebpf/internal/unix/types_linux.go
 delete mode 100644 vendor/github.com/cilium/ebpf/internal/unix/types_other.go
 delete mode 100644 vendor/github.com/cilium/ebpf/internal/vdso.go
 delete mode 100644 vendor/github.com/cilium/ebpf/internal/version.go
 delete mode 100644 vendor/github.com/cilium/ebpf/link/cgroup.go
 delete mode 100644 vendor/github.com/cilium/ebpf/link/doc.go
 delete mode 100644 vendor/github.com/cilium/ebpf/link/iter.go
 delete mode 100644 vendor/github.com/cilium/ebpf/link/kprobe.go
 delete mode 100644 vendor/github.com/cilium/ebpf/link/kprobe_multi.go
 delete mode 100644 vendor/github.com/cilium/ebpf/link/link.go
 delete mode 100644 vendor/github.com/cilium/ebpf/link/netns.go
 delete mode 100644 vendor/github.com/cilium/ebpf/link/perf_event.go
 delete mode 100644 vendor/github.com/cilium/ebpf/link/program.go
 delete mode 100644 vendor/github.com/cilium/ebpf/link/query.go
 delete mode 100644 vendor/github.com/cilium/ebpf/link/raw_tracepoint.go
 delete mode 100644 vendor/github.com/cilium/ebpf/link/socket_filter.go
 delete mode 100644 vendor/github.com/cilium/ebpf/link/syscalls.go
 delete mode 100644 vendor/github.com/cilium/ebpf/link/tracepoint.go
 delete mode 100644 vendor/github.com/cilium/ebpf/link/tracing.go
 delete mode 100644 vendor/github.com/cilium/ebpf/link/uprobe.go
 delete mode 100644 vendor/github.com/cilium/ebpf/link/xdp.go
 delete mode 100644 vendor/github.com/cilium/ebpf/linker.go
 delete mode 100644 vendor/github.com/cilium/ebpf/map.go
 delete mode 100644 vendor/github.com/cilium/ebpf/marshalers.go
 delete mode 100644 vendor/github.com/cilium/ebpf/prog.go
 delete mode 100644 vendor/github.com/cilium/ebpf/run-tests.sh
 delete mode 100644 vendor/github.com/cilium/ebpf/syscalls.go
 delete mode 100644 vendor/github.com/cilium/ebpf/types.go
 delete mode 100644 vendor/github.com/cilium/ebpf/types_string.go
 delete mode 100644 vendor/github.com/opencontainers/runc/libcontainer/cgroups/devices/devices_emulator.go
 delete mode 100644 vendor/github.com/opencontainers/runc/libcontainer/cgroups/ebpf/devicefilter/devicefilter.go
 delete mode 100644 vendor/github.com/opencontainers/runc/libcontainer/cgroups/ebpf/ebpf_linux.go
 delete mode 100644 vendor/github.com/opencontainers/runc/libcontainer/cgroups/fs2/devices.go
 create mode 100644 vendor/github.com/opencontainers/runc/libcontainer/cgroups/fs2/misc.go
 create mode 100644 vendor/github.com/opencontainers/runc/libcontainer/cgroups/fs2/psi.go
 create mode 100644 vendor/github.com/opencontainers/runc/libcontainer/configs/mount_linux.go
 create mode 100644 vendor/github.com/opencontainers/runc/libcontainer/configs/mount_unsupported.go
 delete mode 100644 vendor/github.com/opencontainers/runc/libcontainer/user/lookup_unix.go
 delete mode 100644 vendor/github.com/opencontainers/runc/libcontainer/user/user.go
 delete mode 100644 vendor/github.com/opencontainers/runc/libcontainer/user/user_fuzzer.go
 delete mode 100644 vendor/github.com/opencontainers/runc/libcontainer/userns/userns_fuzzer.go
 create mode 100644 vendor/github.com/opencontainers/runc/libcontainer/userns/userns_linux_fuzzer.go
 delete mode 100644 vendor/github.com/opencontainers/runc/libcontainer/userns/userns_maps.c
 delete mode 100644 vendor/github.com/opencontainers/runc/libcontainer/userns/userns_maps_linux.go

diff --git a/go.mod b/go.mod
index 7f407799b..9e6a2e858 100644
--- a/go.mod
+++ b/go.mod
@@ -11,9 +11,9 @@ require (
 	github.com/containerd/containerd v1.7.18
 	github.com/containernetworking/cni v1.2.3
 	github.com/containernetworking/plugins v1.5.1
-	github.com/containers/image/v5 v5.32.0
+	github.com/containers/image/v5 v5.32.1-0.20240806084436-e3e9287ca8e6
 	github.com/containers/ocicrypt v1.2.0
-	github.com/containers/storage v1.55.0
+	github.com/containers/storage v1.55.1-0.20240805140222-b8f828d4a2dc
 	github.com/coreos/go-systemd/v22 v22.5.0
 	github.com/cyphar/filepath-securejoin v0.3.1
 	github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc
@@ -30,7 +30,7 @@ require (
 	github.com/onsi/gomega v1.34.1
 	github.com/opencontainers/go-digest v1.0.0
 	github.com/opencontainers/image-spec v1.1.0
-	github.com/opencontainers/runc v1.1.13
+	github.com/opencontainers/runc v1.2.0-rc.2.0.20240801140032-ad5b481dace5
 	github.com/opencontainers/runtime-spec v1.2.0
 	github.com/opencontainers/runtime-tools v0.9.1-0.20230914150019-408c51e934dc
 	github.com/opencontainers/selinux v1.11.0
@@ -62,7 +62,6 @@ require (
 	github.com/acarl005/stripansi v0.0.0-20180116102854-5a71ef0e047d // indirect
 	github.com/asaskevich/govalidator v0.0.0-20230301143203-a9d515a09cc2 // indirect
 	github.com/chzyer/readline v1.5.1 // indirect
-	github.com/cilium/ebpf v0.11.0 // indirect
 	github.com/containerd/cgroups/v3 v3.0.3 // indirect
 	github.com/containerd/errdefs v0.1.0 // indirect
 	github.com/containerd/log v0.1.0 // indirect
@@ -105,7 +104,7 @@ require (
 	github.com/letsencrypt/boulder v0.0.0-20240418210053-89b07f4543e0 // indirect
 	github.com/mailru/easyjson v0.7.7 // indirect
 	github.com/manifoldco/promptui v0.9.0 // indirect
-	github.com/mattn/go-runewidth v0.0.15 // indirect
+	github.com/mattn/go-runewidth v0.0.16 // indirect
 	github.com/mattn/go-sqlite3 v1.14.22 // indirect
 	github.com/miekg/pkcs11 v1.1.1 // indirect
 	github.com/mistifyio/go-zfs/v3 v3.0.1 // indirect
@@ -130,7 +129,7 @@ require (
 	github.com/titanous/rocacheck v0.0.0-20171023193734-afe73141d399 // indirect
 	github.com/ulikunitz/xz v0.5.12 // indirect
 	github.com/vbatts/tar-split v0.11.5 // indirect
-	github.com/vbauerster/mpb/v8 v8.7.4 // indirect
+	github.com/vbauerster/mpb/v8 v8.7.5 // indirect
 	github.com/vishvananda/netns v0.0.4 // indirect
 	go.mongodb.org/mongo-driver v1.14.0 // indirect
 	go.mozilla.org/pkcs7 v0.0.0-20210826202110-33d05740a352 // indirect
diff --git a/go.sum b/go.sum
index 3c785d78d..4ad0f8413 100644
--- a/go.sum
+++ b/go.sum
@@ -41,8 +41,6 @@ github.com/chzyer/readline v1.5.1/go.mod h1:Eh+b79XXUwfKfcPLepksvw2tcLE/Ct21YObk
 github.com/chzyer/test v0.0.0-20180213035817-a1ea475d72b1/go.mod h1:Q3SI9o4m/ZMnBNeIyt5eFwwo7qiLfzFZmjNmxjkiQlU=
 github.com/chzyer/test v1.0.0 h1:p3BQDXSxOhOG0P9z6/hGnII4LGiEPOYBhs8asl/fC04=
 github.com/chzyer/test v1.0.0/go.mod h1:2JlltgoNkt4TW/z9V/IzDdFaMTM2JPIi26O1pF38GC8=
-github.com/cilium/ebpf v0.11.0 h1:V8gS/bTCCjX9uUnkUFUpPsksM8n1lXBAvHcpiFk1X2Y=
-github.com/cilium/ebpf v0.11.0/go.mod h1:WE7CZAnqOL2RouJ4f1uyNhqr2P4CCvXFIqdRDUgWsVs=
 github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDkc90ppPyw=
 github.com/cncf/udpa/go v0.0.0-20191209042840-269d4d468f6f/go.mod h1:M8M6+tZqaGXZJjfX53e64911xZQV5JYwmTeXPW+k8Sc=
 github.com/containerd/cgroups/v3 v3.0.3 h1:S5ByHZ/h9PMe5IOQoN7E+nMc2UcLEM/V48DGDJ9kip0=
@@ -59,14 +57,14 @@ github.com/containernetworking/cni v1.2.3 h1:hhOcjNVUQTnzdRJ6alC5XF+wd9mfGIUaj8F
 github.com/containernetworking/cni v1.2.3/go.mod h1:DuLgF+aPd3DzcTQTtp/Nvl1Kim23oFKdm2okJzBQA5M=
 github.com/containernetworking/plugins v1.5.1 h1:T5ji+LPYjjgW0QM+KyrigZbLsZ8jaX+E5J/EcKOE4gQ=
 github.com/containernetworking/plugins v1.5.1/go.mod h1:MIQfgMayGuHYs0XdNudf31cLLAC+i242hNm6KuDGqCM=
-github.com/containers/image/v5 v5.32.0 h1:yjbweazPfr8xOzQ2hkkYm1A2V0jN96/kES6Gwyxj7hQ=
-github.com/containers/image/v5 v5.32.0/go.mod h1:x5e0RDfGaY6bnQ13gJ2LqbfHvzssfB/y5a8HduGFxJc=
+github.com/containers/image/v5 v5.32.1-0.20240806084436-e3e9287ca8e6 h1:nXEEUAo8l2HLlMBy+LsHju2AikpA30jvlTSHbnjJXVw=
+github.com/containers/image/v5 v5.32.1-0.20240806084436-e3e9287ca8e6/go.mod h1:r//zsX8SjmVH0F87d+gakcgR4W5HTFGSgSLB4sufW6A=
 github.com/containers/libtrust v0.0.0-20230121012942-c1716e8a8d01 h1:Qzk5C6cYglewc+UyGf6lc8Mj2UaPTHy/iF2De0/77CA=
 github.com/containers/libtrust v0.0.0-20230121012942-c1716e8a8d01/go.mod h1:9rfv8iPl1ZP7aqh9YA68wnZv2NUDbXdcdPHVz0pFbPY=
 github.com/containers/ocicrypt v1.2.0 h1:X14EgRK3xNFvJEfI5O4Qn4T3E25ANudSOZz/sirVuPM=
 github.com/containers/ocicrypt v1.2.0/go.mod h1:ZNviigQajtdlxIZGibvblVuIFBKIuUI2M0QM12SD31U=
-github.com/containers/storage v1.55.0 h1:wTWZ3YpcQf1F+dSP4KxG9iqDfpQY1otaUXjPpffuhgg=
-github.com/containers/storage v1.55.0/go.mod h1:28cB81IDk+y7ok60Of6u52RbCeBRucbFOeLunhER1RQ=
+github.com/containers/storage v1.55.1-0.20240805140222-b8f828d4a2dc h1:tQeSKrTv05ukW4F/EhQvINdLqU6drRxxUfNATxJELvo=
+github.com/containers/storage v1.55.1-0.20240805140222-b8f828d4a2dc/go.mod h1:4iA5DfO4KcBPIe2Gaub12GM7nDIt1qM4zk03EV6lF/w=
 github.com/coreos/go-systemd/v22 v22.5.0 h1:RrqgGjYQKalulkV8NGVIfkXQf6YYmOyiJKk8iXXhfZs=
 github.com/coreos/go-systemd/v22 v22.5.0/go.mod h1:Y58oyj3AT4RCenI/lSvhwexgC+NSVTIJ3seZv2GcEnc=
 github.com/cpuguy83/go-md2man/v2 v2.0.4/go.mod h1:tgQtvFlXSQOSOSIRvRPT7W67SCa46tRHOmNcaadrF8o=
@@ -102,8 +100,6 @@ github.com/envoyproxy/go-control-plane v0.9.4/go.mod h1:6rpuAdCZL397s3pYoYcLgu1m
 github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c=
 github.com/felixge/httpsnoop v1.0.4 h1:NFTV2Zj1bL4mc9sqWACXbQFVBBg2W3GPvqp8/ESS2Wg=
 github.com/felixge/httpsnoop v1.0.4/go.mod h1:m8KPJKqk1gH5J9DgRY2ASl2lWCfGKXixSwevea8zH2U=
-github.com/frankban/quicktest v1.14.5 h1:dfYrrRyLtiqT9GyKXgdh+k4inNeTvmGbuSgZ3lx3GhA=
-github.com/frankban/quicktest v1.14.5/go.mod h1:4ptaffx2x8+WTWXmUCuVU6aPUX1/Mz7zb5vbUoiM6w0=
 github.com/fsnotify/fsnotify v1.7.0 h1:8JEhPFa5W2WU7YfeZzPNqzMP6Lwt7L2715Ggo0nosvA=
 github.com/fsnotify/fsnotify v1.7.0/go.mod h1:40Bi/Hjc2AVfZrqy+aj+yEI+/bRxZnMJyTJwOpGvigM=
 github.com/go-jose/go-jose/v4 v4.0.2 h1:R3l3kkBds16bO7ZFAEEcofK0MkrAJt3jlJznWZG0nvk=
@@ -215,8 +211,8 @@ github.com/mailru/easyjson v0.7.7 h1:UGYAvKxe3sBsEDzO8ZeWOSlIQfWFlxbzLZe7hwFURr0
 github.com/mailru/easyjson v0.7.7/go.mod h1:xzfreul335JAWq5oZzymOObrkdz5UnU4kGfJJLY9Nlc=
 github.com/manifoldco/promptui v0.9.0 h1:3V4HzJk1TtXW1MTZMP7mdlwbBpIinw3HztaIlYthEiA=
 github.com/manifoldco/promptui v0.9.0/go.mod h1:ka04sppxSGFAtxX0qhlYQjISsg9mR4GWtQEhdbn6Pgg=
-github.com/mattn/go-runewidth v0.0.15 h1:UNAjwbU9l54TA3KzvqLGxwWjHmMgBUVhBiTjelZgg3U=
-github.com/mattn/go-runewidth v0.0.15/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
+github.com/mattn/go-runewidth v0.0.16 h1:E5ScNMtiwvlvB5paMFdw9p4kSQzbXFikJ5SQO6TULQc=
+github.com/mattn/go-runewidth v0.0.16/go.mod h1:Jdepj2loyihRzMpdS35Xk/zdY8IAYHsh153qUoGf23w=
 github.com/mattn/go-sqlite3 v1.14.22 h1:2gZY6PC6kBnID23Tichd1K+Z0oS6nE/XwU+Vz/5o4kU=
 github.com/mattn/go-sqlite3 v1.14.22/go.mod h1:Uh1q+B4BYcTPb+yiD3kU8Ct7aC0hY9fxUwlHK0RXw+Y=
 github.com/miekg/pkcs11 v1.1.1 h1:Ugu9pdy6vAYku5DEpVWVFPYnzV+bxB+iRdbuFSu7TvU=
@@ -250,8 +246,8 @@ github.com/opencontainers/go-digest v1.0.0 h1:apOUWs51W5PlhuyGyz9FCeeBIOUDA/6nW8
 github.com/opencontainers/go-digest v1.0.0/go.mod h1:0JzlMkj0TRzQZfJkVvzbP0HBR3IKzErnv2BNG4W4MAM=
 github.com/opencontainers/image-spec v1.1.0 h1:8SG7/vwALn54lVB/0yZ/MMwhFrPYtpEHQb2IpWsCzug=
 github.com/opencontainers/image-spec v1.1.0/go.mod h1:W4s4sFTMaBeK1BQLXbG4AdM2szdn85PY75RI83NrTrM=
-github.com/opencontainers/runc v1.1.13 h1:98S2srgG9vw0zWcDpFMn5TRrh8kLxa/5OFUstuUhmRs=
-github.com/opencontainers/runc v1.1.13/go.mod h1:R016aXacfp/gwQBYw2FDGa9m+n6atbLWrYY8hNMT/sA=
+github.com/opencontainers/runc v1.2.0-rc.2.0.20240801140032-ad5b481dace5 h1:VqTLG6pS4DlCwEAiwoYoQ3kXnhYCEeHB85vsYeM5ico=
+github.com/opencontainers/runc v1.2.0-rc.2.0.20240801140032-ad5b481dace5/go.mod h1:H8njh/SD+WY9bYMmVsEEWDJgJdviOSDjNeXMjeNbYCE=
 github.com/opencontainers/runtime-spec v1.2.0 h1:z97+pHb3uELt/yiAWD691HNHQIF07bE7dzrbT927iTk=
 github.com/opencontainers/runtime-spec v1.2.0/go.mod h1:jwyrGlmzljRJv/Fgzds9SsS/C5hL+LL3ko9hs6T5lQ0=
 github.com/opencontainers/runtime-tools v0.9.1-0.20230914150019-408c51e934dc h1:d2hUh5O6MRBvStV55MQ8we08t42zSTqBbscoQccWmMc=
@@ -328,8 +324,8 @@ github.com/ulikunitz/xz v0.5.12 h1:37Nm15o69RwBkXM0J6A5OlE67RZTfzUxTj8fB3dfcsc=
 github.com/ulikunitz/xz v0.5.12/go.mod h1:nbz6k7qbPmH4IRqmfOplQw/tblSgqTqBwxkY0oWt/14=
 github.com/vbatts/tar-split v0.11.5 h1:3bHCTIheBm1qFTcgh9oPu+nNBtX+XJIupG/vacinCts=
 github.com/vbatts/tar-split v0.11.5/go.mod h1:yZbwRsSeGjusneWgA781EKej9HF8vme8okylkAeNKLk=
-github.com/vbauerster/mpb/v8 v8.7.4 h1:p4f16iMfUt3PkAC73SCzAtgtSf8TYDqEbJUT3odPrPo=
-github.com/vbauerster/mpb/v8 v8.7.4/go.mod h1:r1B5k2Ljj5KJFCekfihbiqyV4VaaRTANYmvWA2btufI=
+github.com/vbauerster/mpb/v8 v8.7.5 h1:hUF3zaNsuaBBwzEFoCvfuX3cpesQXZC0Phm/JcHZQ+c=
+github.com/vbauerster/mpb/v8 v8.7.5/go.mod h1:bRCnR7K+mj5WXKsy0NWB6Or+wctYGvVwKn6huwvxKa0=
 github.com/vishvananda/netlink v1.2.1-beta.2 h1:Llsql0lnQEbHj0I1OuKyp8otXp0r3q0mPkuhwHfStVs=
 github.com/vishvananda/netlink v1.2.1-beta.2/go.mod h1:twkDnbuQxJYemMlGd4JFIcuhgX83tXhKS2B/PRMpOho=
 github.com/vishvananda/netns v0.0.0-20200728191858-db3c7e526aae/go.mod h1:DD4vA1DwXk04H54A1oHXtwZmA0grkVMdPxx/VGLCah0=
diff --git a/vendor/github.com/cilium/ebpf/.clang-format b/vendor/github.com/cilium/ebpf/.clang-format
deleted file mode 100644
index 3f74dc023..000000000
--- a/vendor/github.com/cilium/ebpf/.clang-format
+++ /dev/null
@@ -1,19 +0,0 @@
----
-Language:        Cpp
-BasedOnStyle:    LLVM
-AlignAfterOpenBracket: DontAlign
-AlignConsecutiveAssignments: true
-AlignEscapedNewlines: DontAlign
-AlwaysBreakBeforeMultilineStrings: true
-AlwaysBreakTemplateDeclarations: false
-AllowAllParametersOfDeclarationOnNextLine: false
-AllowShortFunctionsOnASingleLine: false
-BreakBeforeBraces: Attach
-IndentWidth:     4
-KeepEmptyLinesAtTheStartOfBlocks: false
-TabWidth:        4
-UseTab:          ForContinuationAndIndentation
-ColumnLimit:     1000
-# Go compiler comments need to stay unindented.
-CommentPragmas: '^go:.*'
-...
diff --git a/vendor/github.com/cilium/ebpf/.gitignore b/vendor/github.com/cilium/ebpf/.gitignore
deleted file mode 100644
index b46162b8e..000000000
--- a/vendor/github.com/cilium/ebpf/.gitignore
+++ /dev/null
@@ -1,14 +0,0 @@
-# Binaries for programs and plugins
-*.exe
-*.exe~
-*.dll
-*.so
-*.dylib
-*.o
-!*_bpf*.o
-
-# Test binary, build with `go test -c`
-*.test
-
-# Output of the go coverage tool, specifically when used with LiteIDE
-*.out
diff --git a/vendor/github.com/cilium/ebpf/.golangci.yaml b/vendor/github.com/cilium/ebpf/.golangci.yaml
deleted file mode 100644
index 06743dfc9..000000000
--- a/vendor/github.com/cilium/ebpf/.golangci.yaml
+++ /dev/null
@@ -1,26 +0,0 @@
----
-issues:
-  exclude-rules:
-    # syscall param structs will have unused fields in Go code.
-    - path: syscall.*.go
-      linters:
-        - structcheck
-
-linters:
-  disable-all: true
-  enable:
-    - errcheck
-    - goimports
-    - gosimple
-    - govet
-    - ineffassign
-    - misspell
-    - staticcheck
-    - typecheck
-    - unused
-    - gofmt
-
-    # Could be enabled later:
-    # - gocyclo
-    # - maligned
-    # - gosec
diff --git a/vendor/github.com/cilium/ebpf/ARCHITECTURE.md b/vendor/github.com/cilium/ebpf/ARCHITECTURE.md
deleted file mode 100644
index 26f555eb7..000000000
--- a/vendor/github.com/cilium/ebpf/ARCHITECTURE.md
+++ /dev/null
@@ -1,92 +0,0 @@
-Architecture of the library
-===
-
-```mermaid
-graph RL
-    Program --> ProgramSpec --> ELF
-    btf.Spec --> ELF
-    Map --> MapSpec --> ELF
-    Links --> Map & Program
-    ProgramSpec -.-> btf.Spec
-    MapSpec -.-> btf.Spec
-    subgraph Collection
-        Program & Map
-    end
-    subgraph CollectionSpec
-        ProgramSpec & MapSpec & btf.Spec
-    end
-```
-
-ELF
----
-
-BPF is usually produced by using Clang to compile a subset of C. Clang outputs
-an ELF file which contains program byte code (aka BPF), but also metadata for
-maps used by the program. The metadata follows the conventions set by libbpf
-shipped with the kernel. Certain ELF sections have special meaning
-and contain structures defined by libbpf. Newer versions of clang emit
-additional metadata in [BPF Type Format](#BTF).
-
-The library aims to be compatible with libbpf so that moving from a C toolchain
-to a Go one creates little friction. To that end, the [ELF reader](elf_reader.go)
-is tested against the Linux selftests and avoids introducing custom behaviour
-if possible.
-
-The output of the ELF reader is a `CollectionSpec` which encodes
-all of the information contained in the ELF in a form that is easy to work with
-in Go. The returned `CollectionSpec` should be deterministic: reading the same ELF
-file on different systems must produce the same output.
-As a corollary, any changes that depend on the runtime environment like the
-current kernel version must happen when creating [Objects](#Objects).
-
-Specifications
----
-
-`CollectionSpec` is a very simple container for `ProgramSpec`, `MapSpec` and
-`btf.Spec`. Avoid adding functionality to it if possible.
-
-`ProgramSpec` and `MapSpec` are blueprints for in-kernel
-objects and contain everything necessary to execute the relevant `bpf(2)`
-syscalls. They refer to `btf.Spec` for type information such as `Map` key and
-value types.
-
-The [asm](asm/) package provides an assembler that can be used to generate
-`ProgramSpec` on the fly.
-
-Objects
----
-
-`Program` and `Map` are the result of loading specifications into the kernel.
-Features that depend on knowledge of the current system (e.g kernel version)
-are implemented at this point.
-
-Sometimes loading a spec will fail because the kernel is too old, or a feature is not
-enabled. There are multiple ways the library deals with that:
-
-* Fallback: older kernels don't allow naming programs and maps. The library
-  automatically detects support for names, and omits them during load if
-  necessary. This works since name is primarily a debug aid.
-
-* Sentinel error: sometimes it's possible to detect that a feature isn't available.
-  In that case the library will return an error wrapping `ErrNotSupported`.
-  This is also useful to skip tests that can't run on the current kernel.
-
-Once program and map objects are loaded they expose the kernel's low-level API,
-e.g. `NextKey`. Often this API is awkward to use in Go, so there are safer
-wrappers on top of the low-level API, like `MapIterator`. The low-level API is
-useful when our higher-level API doesn't support a particular use case.
-
-Links
----
-
-Programs can be attached to many different points in the kernel and newer BPF hooks
-tend to use bpf_link to do so. Older hooks unfortunately use a combination of
-syscalls, netlink messages, etc. Adding support for a new link type should not
-pull in large dependencies like netlink, so XDP programs or tracepoints are
-out of scope.
-
-Each bpf_link_type has one corresponding Go type, e.g. `link.tracing` corresponds
-to BPF_LINK_TRACING. In general, these types should be unexported as long as they
-don't export methods outside of the Link interface. Each Go type may have multiple
-exported constructors. For example `AttachTracing` and `AttachLSM` create a
-tracing link, but are distinct functions since they may require different arguments.
diff --git a/vendor/github.com/cilium/ebpf/CODE_OF_CONDUCT.md b/vendor/github.com/cilium/ebpf/CODE_OF_CONDUCT.md
deleted file mode 100644
index 8e42838c5..000000000
--- a/vendor/github.com/cilium/ebpf/CODE_OF_CONDUCT.md
+++ /dev/null
@@ -1,46 +0,0 @@
-# Contributor Covenant Code of Conduct
-
-## Our Pledge
-
-In the interest of fostering an open and welcoming environment, we as contributors and maintainers pledge to making participation in our project and our community a harassment-free experience for everyone, regardless of age, body size, disability, ethnicity, gender identity and expression, level of experience, nationality, personal appearance, race, religion, or sexual identity and orientation.
-
-## Our Standards
-
-Examples of behavior that contributes to creating a positive environment include:
-
-* Using welcoming and inclusive language
-* Being respectful of differing viewpoints and experiences
-* Gracefully accepting constructive criticism
-* Focusing on what is best for the community
-* Showing empathy towards other community members
-
-Examples of unacceptable behavior by participants include:
-
-* The use of sexualized language or imagery and unwelcome sexual attention or advances
-* Trolling, insulting/derogatory comments, and personal or political attacks
-* Public or private harassment
-* Publishing others' private information, such as a physical or electronic address, without explicit permission
-* Other conduct which could reasonably be considered inappropriate in a professional setting
-
-## Our Responsibilities
-
-Project maintainers are responsible for clarifying the standards of acceptable behavior and are expected to take appropriate and fair corrective action in response to any instances of unacceptable behavior.
-
-Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct, or to ban temporarily or permanently any contributor for other behaviors that they deem inappropriate, threatening, offensive, or harmful.
-
-## Scope
-
-This Code of Conduct applies both within project spaces and in public spaces when an individual is representing the project or its community. Examples of representing a project or community include using an official project e-mail address, posting via an official social media account, or acting as an appointed representative at an online or offline event. Representation of a project may be further defined and clarified by project maintainers.
-
-## Enforcement
-
-Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by contacting the project team at nathanjsweet at gmail dot com or i at lmb dot io. The project team will review and investigate all complaints, and will respond in a way that it deems appropriate to the circumstances. The project team is obligated to maintain confidentiality with regard to the reporter of an incident. Further details of specific enforcement policies may be posted separately.
-
-Project maintainers who do not follow or enforce the Code of Conduct in good faith may face temporary or permanent repercussions as determined by other members of the project's leadership.
-
-## Attribution
-
-This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4, available at [http://contributor-covenant.org/version/1/4][version]
-
-[homepage]: http://contributor-covenant.org
-[version]: http://contributor-covenant.org/version/1/4/
diff --git a/vendor/github.com/cilium/ebpf/CONTRIBUTING.md b/vendor/github.com/cilium/ebpf/CONTRIBUTING.md
deleted file mode 100644
index bf57da939..000000000
--- a/vendor/github.com/cilium/ebpf/CONTRIBUTING.md
+++ /dev/null
@@ -1,48 +0,0 @@
-# How to contribute
-
-Development is on [GitHub](https://github.com/cilium/ebpf) and contributions in
-the form of pull requests and issues reporting bugs or suggesting new features
-are welcome. Please take a look at [the architecture](ARCHITECTURE.md) to get
-a better understanding for the high-level goals.
-
-## Adding a new feature
-
-1. [Join](https://ebpf.io/slack) the
-[#ebpf-go](https://cilium.slack.com/messages/ebpf-go) channel to discuss your requirements and how the feature can be implemented. The most important part is figuring out how much new exported API is necessary. **The less new API is required the easier it will be to land the feature.**
-2. (*optional*) Create a draft PR if you want to discuss the implementation or have hit a problem. It's fine if this doesn't compile or contains debug statements.
-3. Create a PR that is ready to merge. This must pass CI and have tests.
-
-### API stability
-
-The library doesn't guarantee the stability of its API at the moment.
-
-1. If possible avoid breakage by introducing new API and deprecating the old one
-   at the same time. If an API was deprecated in v0.x it can be removed in v0.x+1.
-2. Breaking API in a way that causes compilation failures is acceptable but must
-   have good reasons.
-3. Changing the semantics of the API without causing compilation failures is
-   heavily discouraged.
-
-## Running the tests
-
-Many of the tests require privileges to set resource limits and load eBPF code.
-The easiest way to obtain these is to run the tests with `sudo`.
-
-To test the current package with your local kernel you can simply run:
-```
-go test -exec sudo  ./...
-```
-
-To test the current package with a different kernel version you can use the [run-tests.sh](run-tests.sh) script.
-It requires [virtme](https://github.com/amluto/virtme) and qemu to be installed.
-
-Examples:
-
-```bash
-# Run all tests on a 5.4 kernel
-./run-tests.sh 5.4
-
-# Run a subset of tests:
-./run-tests.sh 5.4 ./link
-```
-
diff --git a/vendor/github.com/cilium/ebpf/LICENSE b/vendor/github.com/cilium/ebpf/LICENSE
deleted file mode 100644
index c637ae99c..000000000
--- a/vendor/github.com/cilium/ebpf/LICENSE
+++ /dev/null
@@ -1,23 +0,0 @@
-MIT License
-
-Copyright (c) 2017 Nathan Sweet
-Copyright (c) 2018, 2019 Cloudflare
-Copyright (c) 2019 Authors of Cilium
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
diff --git a/vendor/github.com/cilium/ebpf/MAINTAINERS.md b/vendor/github.com/cilium/ebpf/MAINTAINERS.md
deleted file mode 100644
index a56a03e39..000000000
--- a/vendor/github.com/cilium/ebpf/MAINTAINERS.md
+++ /dev/null
@@ -1,3 +0,0 @@
-# Maintainers
-
-Maintainers can be found in the [Cilium Maintainers file](https://github.com/cilium/community/blob/main/roles/Maintainers.md)
diff --git a/vendor/github.com/cilium/ebpf/Makefile b/vendor/github.com/cilium/ebpf/Makefile
deleted file mode 100644
index abcd6c1a4..000000000
--- a/vendor/github.com/cilium/ebpf/Makefile
+++ /dev/null
@@ -1,115 +0,0 @@
-# The development version of clang is distributed as the 'clang' binary,
-# while stable/released versions have a version number attached.
-# Pin the default clang to a stable version.
-CLANG ?= clang-14
-STRIP ?= llvm-strip-14
-OBJCOPY ?= llvm-objcopy-14
-CFLAGS := -O2 -g -Wall -Werror $(CFLAGS)
-
-CI_KERNEL_URL ?= https://github.com/cilium/ci-kernels/raw/master/
-
-# Obtain an absolute path to the directory of the Makefile.
-# Assume the Makefile is in the root of the repository.
-REPODIR := $(shell dirname $(realpath $(firstword $(MAKEFILE_LIST))))
-UIDGID := $(shell stat -c '%u:%g' ${REPODIR})
-
-# Prefer podman if installed, otherwise use docker.
-# Note: Setting the var at runtime will always override.
-CONTAINER_ENGINE ?= $(if $(shell command -v podman), podman, docker)
-CONTAINER_RUN_ARGS ?= $(if $(filter ${CONTAINER_ENGINE}, podman), --log-driver=none, --user "${UIDGID}")
-
-IMAGE := $(shell cat ${REPODIR}/testdata/docker/IMAGE)
-VERSION := $(shell cat ${REPODIR}/testdata/docker/VERSION)
-
-
-# clang <8 doesn't tag relocs properly (STT_NOTYPE)
-# clang 9 is the first version emitting BTF
-TARGETS := \
-	testdata/loader-clang-7 \
-	testdata/loader-clang-9 \
-	testdata/loader-$(CLANG) \
-	testdata/manyprogs \
-	testdata/btf_map_init \
-	testdata/invalid_map \
-	testdata/raw_tracepoint \
-	testdata/invalid_map_static \
-	testdata/invalid_btf_map_init \
-	testdata/strings \
-	testdata/freplace \
-	testdata/iproute2_map_compat \
-	testdata/map_spin_lock \
-	testdata/subprog_reloc \
-	testdata/fwd_decl \
-	testdata/kconfig \
-	testdata/kconfig_config \
-	testdata/kfunc \
-	testdata/invalid-kfunc \
-	testdata/kfunc-kmod \
-	btf/testdata/relocs \
-	btf/testdata/relocs_read \
-	btf/testdata/relocs_read_tgt \
-	cmd/bpf2go/testdata/minimal
-
-.PHONY: all clean container-all container-shell generate
-
-.DEFAULT_TARGET = container-all
-
-# Build all ELF binaries using a containerized LLVM toolchain.
-container-all:
-	+${CONTAINER_ENGINE} run --rm -ti ${CONTAINER_RUN_ARGS} \
-		-v "${REPODIR}":/ebpf -w /ebpf --env MAKEFLAGS \
-		--env CFLAGS="-fdebug-prefix-map=/ebpf=." \
-		--env HOME="/tmp" \
-		"${IMAGE}:${VERSION}" \
-		make all
-
-# (debug) Drop the user into a shell inside the container as root.
-container-shell:
-	${CONTAINER_ENGINE} run --rm -ti \
-		-v "${REPODIR}":/ebpf -w /ebpf \
-		"${IMAGE}:${VERSION}"
-
-clean:
-	-$(RM) testdata/*.elf
-	-$(RM) btf/testdata/*.elf
-
-format:
-	find . -type f -name "*.c" | xargs clang-format -i
-
-all: format $(addsuffix -el.elf,$(TARGETS)) $(addsuffix -eb.elf,$(TARGETS)) generate
-	ln -srf testdata/loader-$(CLANG)-el.elf testdata/loader-el.elf
-	ln -srf testdata/loader-$(CLANG)-eb.elf testdata/loader-eb.elf
-
-# $BPF_CLANG is used in go:generate invocations.
-generate: export BPF_CLANG := $(CLANG)
-generate: export BPF_CFLAGS := $(CFLAGS)
-generate:
-	go generate ./...
-
-testdata/loader-%-el.elf: testdata/loader.c
-	$* $(CFLAGS) -target bpfel -c $< -o $@
-	$(STRIP) -g $@
-
-testdata/loader-%-eb.elf: testdata/loader.c
-	$* $(CFLAGS) -target bpfeb -c $< -o $@
-	$(STRIP) -g $@
-
-%-el.elf: %.c
-	$(CLANG) $(CFLAGS) -target bpfel -c $< -o $@
-	$(STRIP) -g $@
-
-%-eb.elf : %.c
-	$(CLANG) $(CFLAGS) -target bpfeb -c $< -o $@
-	$(STRIP) -g $@
-
-.PHONY: generate-btf
-generate-btf: KERNEL_VERSION?=5.19
-generate-btf:
-	$(eval TMP := $(shell mktemp -d))
-	curl -fL "$(CI_KERNEL_URL)/linux-$(KERNEL_VERSION).bz" -o "$(TMP)/bzImage"
-	/lib/modules/$(uname -r)/build/scripts/extract-vmlinux "$(TMP)/bzImage" > "$(TMP)/vmlinux"
-	$(OBJCOPY) --dump-section .BTF=/dev/stdout "$(TMP)/vmlinux" /dev/null | gzip > "btf/testdata/vmlinux.btf.gz"
-	curl -fL "$(CI_KERNEL_URL)/linux-$(KERNEL_VERSION)-selftests-bpf.tgz" -o "$(TMP)/selftests.tgz"
-	tar -xf "$(TMP)/selftests.tgz" --to-stdout tools/testing/selftests/bpf/bpf_testmod/bpf_testmod.ko | \
-		$(OBJCOPY) --dump-section .BTF="btf/testdata/btf_testmod.btf" - /dev/null
-	$(RM) -r "$(TMP)"
diff --git a/vendor/github.com/cilium/ebpf/README.md b/vendor/github.com/cilium/ebpf/README.md
deleted file mode 100644
index eff08d8df..000000000
--- a/vendor/github.com/cilium/ebpf/README.md
+++ /dev/null
@@ -1,82 +0,0 @@
-# eBPF
-
-[![PkgGoDev](https://pkg.go.dev/badge/github.com/cilium/ebpf)](https://pkg.go.dev/github.com/cilium/ebpf)
-
-![HoneyGopher](.github/images/cilium-ebpf.png)
-
-ebpf-go is a pure Go library that provides utilities for loading, compiling, and
-debugging eBPF programs. It has minimal external dependencies and is intended to
-be used in long running processes.
-
-See [ebpf.io](https://ebpf.io) for complementary projects from the wider eBPF
-ecosystem.
-
-## Getting Started
-
-A small collection of Go and eBPF programs that serve as examples for building
-your own tools can be found under [examples/](examples/).
-
-[Contributions](CONTRIBUTING.md) are highly encouraged, as they highlight certain use cases of
-eBPF and the library, and help shape the future of the project.
-
-## Getting Help
-
-The community actively monitors our [GitHub Discussions](https://github.com/cilium/ebpf/discussions) page.
-Please search for existing threads before starting a new one. Refrain from
-opening issues on the bug tracker if you're just starting out or if you're not
-sure if something is a bug in the library code.
-
-Alternatively, [join](https://ebpf.io/slack) the
-[#ebpf-go](https://cilium.slack.com/messages/ebpf-go) channel on Slack if you
-have other questions regarding the project. Note that this channel is ephemeral
-and has its history erased past a certain point, which is less helpful for
-others running into the same problem later.
-
-## Packages
-
-This library includes the following packages:
-
-* [asm](https://pkg.go.dev/github.com/cilium/ebpf/asm) contains a basic
-  assembler, allowing you to write eBPF assembly instructions directly
-  within your Go code. (You don't need to use this if you prefer to write your eBPF program in C.)
-* [cmd/bpf2go](https://pkg.go.dev/github.com/cilium/ebpf/cmd/bpf2go) allows
-  compiling and embedding eBPF programs written in C within Go code. As well as
-  compiling the C code, it auto-generates Go code for loading and manipulating
-  the eBPF program and map objects.
-* [link](https://pkg.go.dev/github.com/cilium/ebpf/link) allows attaching eBPF
-  to various hooks
-* [perf](https://pkg.go.dev/github.com/cilium/ebpf/perf) allows reading from a
-  `PERF_EVENT_ARRAY`
-* [ringbuf](https://pkg.go.dev/github.com/cilium/ebpf/ringbuf) allows reading from a
-  `BPF_MAP_TYPE_RINGBUF` map
-* [features](https://pkg.go.dev/github.com/cilium/ebpf/features) implements the equivalent
-  of `bpftool feature probe` for discovering BPF-related kernel features using native Go.
-* [rlimit](https://pkg.go.dev/github.com/cilium/ebpf/rlimit) provides a convenient API to lift
-  the `RLIMIT_MEMLOCK` constraint on kernels before 5.11.
-* [btf](https://pkg.go.dev/github.com/cilium/ebpf/btf) allows reading the BPF Type Format.
-
-## Requirements
-
-* A version of Go that is [supported by
-  upstream](https://golang.org/doc/devel/release.html#policy)
-* Linux >= 4.9. CI is run against kernel.org LTS releases. 4.4 should work but is
-  not tested against.
-
-## Regenerating Testdata
-
-Run `make` in the root of this repository to rebuild testdata in all
-subpackages. This requires Docker, as it relies on a standardized build
-environment to keep the build output stable.
-
-It is possible to regenerate data using Podman by overriding the `CONTAINER_*`
-variables: `CONTAINER_ENGINE=podman CONTAINER_RUN_ARGS= make`.
-
-The toolchain image build files are kept in [testdata/docker/](testdata/docker/).
-
-## License
-
-MIT
-
-### eBPF Gopher
-
-The eBPF honeygopher is based on the Go gopher designed by Renee French.
diff --git a/vendor/github.com/cilium/ebpf/asm/alu.go b/vendor/github.com/cilium/ebpf/asm/alu.go
deleted file mode 100644
index 3f60245f2..000000000
--- a/vendor/github.com/cilium/ebpf/asm/alu.go
+++ /dev/null
@@ -1,149 +0,0 @@
-package asm
-
-//go:generate stringer -output alu_string.go -type=Source,Endianness,ALUOp
-
-// Source of ALU / ALU64 / Branch operations
-//
-//	msb      lsb
-//	+----+-+---+
-//	|op  |S|cls|
-//	+----+-+---+
-type Source uint8
-
-const sourceMask OpCode = 0x08
-
-// Source bitmask
-const (
-	// InvalidSource is returned by getters when invoked
-	// on non ALU / branch OpCodes.
-	InvalidSource Source = 0xff
-	// ImmSource src is from constant
-	ImmSource Source = 0x00
-	// RegSource src is from register
-	RegSource Source = 0x08
-)
-
-// The Endianness of a byte swap instruction.
-type Endianness uint8
-
-const endianMask = sourceMask
-
-// Endian flags
-const (
-	InvalidEndian Endianness = 0xff
-	// Convert to little endian
-	LE Endianness = 0x00
-	// Convert to big endian
-	BE Endianness = 0x08
-)
-
-// ALUOp are ALU / ALU64 operations
-//
-//	msb      lsb
-//	+----+-+---+
-//	|OP  |s|cls|
-//	+----+-+---+
-type ALUOp uint8
-
-const aluMask OpCode = 0xf0
-
-const (
-	// InvalidALUOp is returned by getters when invoked
-	// on non ALU OpCodes
-	InvalidALUOp ALUOp = 0xff
-	// Add - addition
-	Add ALUOp = 0x00
-	// Sub - subtraction
-	Sub ALUOp = 0x10
-	// Mul - multiplication
-	Mul ALUOp = 0x20
-	// Div - division
-	Div ALUOp = 0x30
-	// Or - bitwise or
-	Or ALUOp = 0x40
-	// And - bitwise and
-	And ALUOp = 0x50
-	// LSh - bitwise shift left
-	LSh ALUOp = 0x60
-	// RSh - bitwise shift right
-	RSh ALUOp = 0x70
-	// Neg - sign/unsign signing bit
-	Neg ALUOp = 0x80
-	// Mod - modulo
-	Mod ALUOp = 0x90
-	// Xor - bitwise xor
-	Xor ALUOp = 0xa0
-	// Mov - move value from one place to another
-	Mov ALUOp = 0xb0
-	// ArSh - arithmatic shift
-	ArSh ALUOp = 0xc0
-	// Swap - endian conversions
-	Swap ALUOp = 0xd0
-)
-
-// HostTo converts from host to another endianness.
-func HostTo(endian Endianness, dst Register, size Size) Instruction {
-	var imm int64
-	switch size {
-	case Half:
-		imm = 16
-	case Word:
-		imm = 32
-	case DWord:
-		imm = 64
-	default:
-		return Instruction{OpCode: InvalidOpCode}
-	}
-
-	return Instruction{
-		OpCode:   OpCode(ALUClass).SetALUOp(Swap).SetSource(Source(endian)),
-		Dst:      dst,
-		Constant: imm,
-	}
-}
-
-// Op returns the OpCode for an ALU operation with a given source.
-func (op ALUOp) Op(source Source) OpCode {
-	return OpCode(ALU64Class).SetALUOp(op).SetSource(source)
-}
-
-// Reg emits `dst (op) src`.
-func (op ALUOp) Reg(dst, src Register) Instruction {
-	return Instruction{
-		OpCode: op.Op(RegSource),
-		Dst:    dst,
-		Src:    src,
-	}
-}
-
-// Imm emits `dst (op) value`.
-func (op ALUOp) Imm(dst Register, value int32) Instruction {
-	return Instruction{
-		OpCode:   op.Op(ImmSource),
-		Dst:      dst,
-		Constant: int64(value),
-	}
-}
-
-// Op32 returns the OpCode for a 32-bit ALU operation with a given source.
-func (op ALUOp) Op32(source Source) OpCode {
-	return OpCode(ALUClass).SetALUOp(op).SetSource(source)
-}
-
-// Reg32 emits `dst (op) src`, zeroing the upper 32 bit of dst.
-func (op ALUOp) Reg32(dst, src Register) Instruction {
-	return Instruction{
-		OpCode: op.Op32(RegSource),
-		Dst:    dst,
-		Src:    src,
-	}
-}
-
-// Imm32 emits `dst (op) value`, zeroing the upper 32 bit of dst.
-func (op ALUOp) Imm32(dst Register, value int32) Instruction {
-	return Instruction{
-		OpCode:   op.Op32(ImmSource),
-		Dst:      dst,
-		Constant: int64(value),
-	}
-}
diff --git a/vendor/github.com/cilium/ebpf/asm/alu_string.go b/vendor/github.com/cilium/ebpf/asm/alu_string.go
deleted file mode 100644
index 72d3fe629..000000000
--- a/vendor/github.com/cilium/ebpf/asm/alu_string.go
+++ /dev/null
@@ -1,107 +0,0 @@
-// Code generated by "stringer -output alu_string.go -type=Source,Endianness,ALUOp"; DO NOT EDIT.
-
-package asm
-
-import "strconv"
-
-func _() {
-	// An "invalid array index" compiler error signifies that the constant values have changed.
-	// Re-run the stringer command to generate them again.
-	var x [1]struct{}
-	_ = x[InvalidSource-255]
-	_ = x[ImmSource-0]
-	_ = x[RegSource-8]
-}
-
-const (
-	_Source_name_0 = "ImmSource"
-	_Source_name_1 = "RegSource"
-	_Source_name_2 = "InvalidSource"
-)
-
-func (i Source) String() string {
-	switch {
-	case i == 0:
-		return _Source_name_0
-	case i == 8:
-		return _Source_name_1
-	case i == 255:
-		return _Source_name_2
-	default:
-		return "Source(" + strconv.FormatInt(int64(i), 10) + ")"
-	}
-}
-func _() {
-	// An "invalid array index" compiler error signifies that the constant values have changed.
-	// Re-run the stringer command to generate them again.
-	var x [1]struct{}
-	_ = x[InvalidEndian-255]
-	_ = x[LE-0]
-	_ = x[BE-8]
-}
-
-const (
-	_Endianness_name_0 = "LE"
-	_Endianness_name_1 = "BE"
-	_Endianness_name_2 = "InvalidEndian"
-)
-
-func (i Endianness) String() string {
-	switch {
-	case i == 0:
-		return _Endianness_name_0
-	case i == 8:
-		return _Endianness_name_1
-	case i == 255:
-		return _Endianness_name_2
-	default:
-		return "Endianness(" + strconv.FormatInt(int64(i), 10) + ")"
-	}
-}
-func _() {
-	// An "invalid array index" compiler error signifies that the constant values have changed.
-	// Re-run the stringer command to generate them again.
-	var x [1]struct{}
-	_ = x[InvalidALUOp-255]
-	_ = x[Add-0]
-	_ = x[Sub-16]
-	_ = x[Mul-32]
-	_ = x[Div-48]
-	_ = x[Or-64]
-	_ = x[And-80]
-	_ = x[LSh-96]
-	_ = x[RSh-112]
-	_ = x[Neg-128]
-	_ = x[Mod-144]
-	_ = x[Xor-160]
-	_ = x[Mov-176]
-	_ = x[ArSh-192]
-	_ = x[Swap-208]
-}
-
-const _ALUOp_name = "AddSubMulDivOrAndLShRShNegModXorMovArShSwapInvalidALUOp"
-
-var _ALUOp_map = map[ALUOp]string{
-	0:   _ALUOp_name[0:3],
-	16:  _ALUOp_name[3:6],
-	32:  _ALUOp_name[6:9],
-	48:  _ALUOp_name[9:12],
-	64:  _ALUOp_name[12:14],
-	80:  _ALUOp_name[14:17],
-	96:  _ALUOp_name[17:20],
-	112: _ALUOp_name[20:23],
-	128: _ALUOp_name[23:26],
-	144: _ALUOp_name[26:29],
-	160: _ALUOp_name[29:32],
-	176: _ALUOp_name[32:35],
-	192: _ALUOp_name[35:39],
-	208: _ALUOp_name[39:43],
-	255: _ALUOp_name[43:55],
-}
-
-func (i ALUOp) String() string {
-	if str, ok := _ALUOp_map[i]; ok {
-		return str
-	}
-	return "ALUOp(" + strconv.FormatInt(int64(i), 10) + ")"
-}
diff --git a/vendor/github.com/cilium/ebpf/asm/doc.go b/vendor/github.com/cilium/ebpf/asm/doc.go
deleted file mode 100644
index 7031bdc27..000000000
--- a/vendor/github.com/cilium/ebpf/asm/doc.go
+++ /dev/null
@@ -1,2 +0,0 @@
-// Package asm is an assembler for eBPF bytecode.
-package asm
diff --git a/vendor/github.com/cilium/ebpf/asm/func.go b/vendor/github.com/cilium/ebpf/asm/func.go
deleted file mode 100644
index 18f6a75db..000000000
--- a/vendor/github.com/cilium/ebpf/asm/func.go
+++ /dev/null
@@ -1,250 +0,0 @@
-package asm
-
-//go:generate stringer -output func_string.go -type=BuiltinFunc
-
-// BuiltinFunc is a built-in eBPF function.
-type BuiltinFunc int32
-
-func (_ BuiltinFunc) Max() BuiltinFunc {
-	return maxBuiltinFunc - 1
-}
-
-// eBPF built-in functions
-//
-// You can regenerate this list using the following gawk script:
-//
-//	/FN\(.+\),/ {
-//	  match($1, /\(([a-z_0-9]+),/, r)
-//	  split(r[1], p, "_")
-//	  printf "Fn"
-//	  for (i in p) {
-//	    printf "%s%s", toupper(substr(p[i], 1, 1)), substr(p[i], 2)
-//	  }
-//	  print ""
-//	}
-//
-// The script expects include/uapi/linux/bpf.h as it's input.
-const (
-	FnUnspec BuiltinFunc = iota
-	FnMapLookupElem
-	FnMapUpdateElem
-	FnMapDeleteElem
-	FnProbeRead
-	FnKtimeGetNs
-	FnTracePrintk
-	FnGetPrandomU32
-	FnGetSmpProcessorId
-	FnSkbStoreBytes
-	FnL3CsumReplace
-	FnL4CsumReplace
-	FnTailCall
-	FnCloneRedirect
-	FnGetCurrentPidTgid
-	FnGetCurrentUidGid
-	FnGetCurrentComm
-	FnGetCgroupClassid
-	FnSkbVlanPush
-	FnSkbVlanPop
-	FnSkbGetTunnelKey
-	FnSkbSetTunnelKey
-	FnPerfEventRead
-	FnRedirect
-	FnGetRouteRealm
-	FnPerfEventOutput
-	FnSkbLoadBytes
-	FnGetStackid
-	FnCsumDiff
-	FnSkbGetTunnelOpt
-	FnSkbSetTunnelOpt
-	FnSkbChangeProto
-	FnSkbChangeType
-	FnSkbUnderCgroup
-	FnGetHashRecalc
-	FnGetCurrentTask
-	FnProbeWriteUser
-	FnCurrentTaskUnderCgroup
-	FnSkbChangeTail
-	FnSkbPullData
-	FnCsumUpdate
-	FnSetHashInvalid
-	FnGetNumaNodeId
-	FnSkbChangeHead
-	FnXdpAdjustHead
-	FnProbeReadStr
-	FnGetSocketCookie
-	FnGetSocketUid
-	FnSetHash
-	FnSetsockopt
-	FnSkbAdjustRoom
-	FnRedirectMap
-	FnSkRedirectMap
-	FnSockMapUpdate
-	FnXdpAdjustMeta
-	FnPerfEventReadValue
-	FnPerfProgReadValue
-	FnGetsockopt
-	FnOverrideReturn
-	FnSockOpsCbFlagsSet
-	FnMsgRedirectMap
-	FnMsgApplyBytes
-	FnMsgCorkBytes
-	FnMsgPullData
-	FnBind
-	FnXdpAdjustTail
-	FnSkbGetXfrmState
-	FnGetStack
-	FnSkbLoadBytesRelative
-	FnFibLookup
-	FnSockHashUpdate
-	FnMsgRedirectHash
-	FnSkRedirectHash
-	FnLwtPushEncap
-	FnLwtSeg6StoreBytes
-	FnLwtSeg6AdjustSrh
-	FnLwtSeg6Action
-	FnRcRepeat
-	FnRcKeydown
-	FnSkbCgroupId
-	FnGetCurrentCgroupId
-	FnGetLocalStorage
-	FnSkSelectReuseport
-	FnSkbAncestorCgroupId
-	FnSkLookupTcp
-	FnSkLookupUdp
-	FnSkRelease
-	FnMapPushElem
-	FnMapPopElem
-	FnMapPeekElem
-	FnMsgPushData
-	FnMsgPopData
-	FnRcPointerRel
-	FnSpinLock
-	FnSpinUnlock
-	FnSkFullsock
-	FnTcpSock
-	FnSkbEcnSetCe
-	FnGetListenerSock
-	FnSkcLookupTcp
-	FnTcpCheckSyncookie
-	FnSysctlGetName
-	FnSysctlGetCurrentValue
-	FnSysctlGetNewValue
-	FnSysctlSetNewValue
-	FnStrtol
-	FnStrtoul
-	FnSkStorageGet
-	FnSkStorageDelete
-	FnSendSignal
-	FnTcpGenSyncookie
-	FnSkbOutput
-	FnProbeReadUser
-	FnProbeReadKernel
-	FnProbeReadUserStr
-	FnProbeReadKernelStr
-	FnTcpSendAck
-	FnSendSignalThread
-	FnJiffies64
-	FnReadBranchRecords
-	FnGetNsCurrentPidTgid
-	FnXdpOutput
-	FnGetNetnsCookie
-	FnGetCurrentAncestorCgroupId
-	FnSkAssign
-	FnKtimeGetBootNs
-	FnSeqPrintf
-	FnSeqWrite
-	FnSkCgroupId
-	FnSkAncestorCgroupId
-	FnRingbufOutput
-	FnRingbufReserve
-	FnRingbufSubmit
-	FnRingbufDiscard
-	FnRingbufQuery
-	FnCsumLevel
-	FnSkcToTcp6Sock
-	FnSkcToTcpSock
-	FnSkcToTcpTimewaitSock
-	FnSkcToTcpRequestSock
-	FnSkcToUdp6Sock
-	FnGetTaskStack
-	FnLoadHdrOpt
-	FnStoreHdrOpt
-	FnReserveHdrOpt
-	FnInodeStorageGet
-	FnInodeStorageDelete
-	FnDPath
-	FnCopyFromUser
-	FnSnprintfBtf
-	FnSeqPrintfBtf
-	FnSkbCgroupClassid
-	FnRedirectNeigh
-	FnPerCpuPtr
-	FnThisCpuPtr
-	FnRedirectPeer
-	FnTaskStorageGet
-	FnTaskStorageDelete
-	FnGetCurrentTaskBtf
-	FnBprmOptsSet
-	FnKtimeGetCoarseNs
-	FnImaInodeHash
-	FnSockFromFile
-	FnCheckMtu
-	FnForEachMapElem
-	FnSnprintf
-	FnSysBpf
-	FnBtfFindByNameKind
-	FnSysClose
-	FnTimerInit
-	FnTimerSetCallback
-	FnTimerStart
-	FnTimerCancel
-	FnGetFuncIp
-	FnGetAttachCookie
-	FnTaskPtRegs
-	FnGetBranchSnapshot
-	FnTraceVprintk
-	FnSkcToUnixSock
-	FnKallsymsLookupName
-	FnFindVma
-	FnLoop
-	FnStrncmp
-	FnGetFuncArg
-	FnGetFuncRet
-	FnGetFuncArgCnt
-	FnGetRetval
-	FnSetRetval
-	FnXdpGetBuffLen
-	FnXdpLoadBytes
-	FnXdpStoreBytes
-	FnCopyFromUserTask
-	FnSkbSetTstamp
-	FnImaFileHash
-	FnKptrXchg
-	FnMapLookupPercpuElem
-	FnSkcToMptcpSock
-	FnDynptrFromMem
-	FnRingbufReserveDynptr
-	FnRingbufSubmitDynptr
-	FnRingbufDiscardDynptr
-	FnDynptrRead
-	FnDynptrWrite
-	FnDynptrData
-	FnTcpRawGenSyncookieIpv4
-	FnTcpRawGenSyncookieIpv6
-	FnTcpRawCheckSyncookieIpv4
-	FnTcpRawCheckSyncookieIpv6
-	FnKtimeGetTaiNs
-	FnUserRingbufDrain
-	FnCgrpStorageGet
-	FnCgrpStorageDelete
-
-	maxBuiltinFunc
-)
-
-// Call emits a function call.
-func (fn BuiltinFunc) Call() Instruction {
-	return Instruction{
-		OpCode:   OpCode(JumpClass).SetJumpOp(Call),
-		Constant: int64(fn),
-	}
-}
diff --git a/vendor/github.com/cilium/ebpf/asm/func_string.go b/vendor/github.com/cilium/ebpf/asm/func_string.go
deleted file mode 100644
index 47150bc4f..000000000
--- a/vendor/github.com/cilium/ebpf/asm/func_string.go
+++ /dev/null
@@ -1,235 +0,0 @@
-// Code generated by "stringer -output func_string.go -type=BuiltinFunc"; DO NOT EDIT.
-
-package asm
-
-import "strconv"
-
-func _() {
-	// An "invalid array index" compiler error signifies that the constant values have changed.
-	// Re-run the stringer command to generate them again.
-	var x [1]struct{}
-	_ = x[FnUnspec-0]
-	_ = x[FnMapLookupElem-1]
-	_ = x[FnMapUpdateElem-2]
-	_ = x[FnMapDeleteElem-3]
-	_ = x[FnProbeRead-4]
-	_ = x[FnKtimeGetNs-5]
-	_ = x[FnTracePrintk-6]
-	_ = x[FnGetPrandomU32-7]
-	_ = x[FnGetSmpProcessorId-8]
-	_ = x[FnSkbStoreBytes-9]
-	_ = x[FnL3CsumReplace-10]
-	_ = x[FnL4CsumReplace-11]
-	_ = x[FnTailCall-12]
-	_ = x[FnCloneRedirect-13]
-	_ = x[FnGetCurrentPidTgid-14]
-	_ = x[FnGetCurrentUidGid-15]
-	_ = x[FnGetCurrentComm-16]
-	_ = x[FnGetCgroupClassid-17]
-	_ = x[FnSkbVlanPush-18]
-	_ = x[FnSkbVlanPop-19]
-	_ = x[FnSkbGetTunnelKey-20]
-	_ = x[FnSkbSetTunnelKey-21]
-	_ = x[FnPerfEventRead-22]
-	_ = x[FnRedirect-23]
-	_ = x[FnGetRouteRealm-24]
-	_ = x[FnPerfEventOutput-25]
-	_ = x[FnSkbLoadBytes-26]
-	_ = x[FnGetStackid-27]
-	_ = x[FnCsumDiff-28]
-	_ = x[FnSkbGetTunnelOpt-29]
-	_ = x[FnSkbSetTunnelOpt-30]
-	_ = x[FnSkbChangeProto-31]
-	_ = x[FnSkbChangeType-32]
-	_ = x[FnSkbUnderCgroup-33]
-	_ = x[FnGetHashRecalc-34]
-	_ = x[FnGetCurrentTask-35]
-	_ = x[FnProbeWriteUser-36]
-	_ = x[FnCurrentTaskUnderCgroup-37]
-	_ = x[FnSkbChangeTail-38]
-	_ = x[FnSkbPullData-39]
-	_ = x[FnCsumUpdate-40]
-	_ = x[FnSetHashInvalid-41]
-	_ = x[FnGetNumaNodeId-42]
-	_ = x[FnSkbChangeHead-43]
-	_ = x[FnXdpAdjustHead-44]
-	_ = x[FnProbeReadStr-45]
-	_ = x[FnGetSocketCookie-46]
-	_ = x[FnGetSocketUid-47]
-	_ = x[FnSetHash-48]
-	_ = x[FnSetsockopt-49]
-	_ = x[FnSkbAdjustRoom-50]
-	_ = x[FnRedirectMap-51]
-	_ = x[FnSkRedirectMap-52]
-	_ = x[FnSockMapUpdate-53]
-	_ = x[FnXdpAdjustMeta-54]
-	_ = x[FnPerfEventReadValue-55]
-	_ = x[FnPerfProgReadValue-56]
-	_ = x[FnGetsockopt-57]
-	_ = x[FnOverrideReturn-58]
-	_ = x[FnSockOpsCbFlagsSet-59]
-	_ = x[FnMsgRedirectMap-60]
-	_ = x[FnMsgApplyBytes-61]
-	_ = x[FnMsgCorkBytes-62]
-	_ = x[FnMsgPullData-63]
-	_ = x[FnBind-64]
-	_ = x[FnXdpAdjustTail-65]
-	_ = x[FnSkbGetXfrmState-66]
-	_ = x[FnGetStack-67]
-	_ = x[FnSkbLoadBytesRelative-68]
-	_ = x[FnFibLookup-69]
-	_ = x[FnSockHashUpdate-70]
-	_ = x[FnMsgRedirectHash-71]
-	_ = x[FnSkRedirectHash-72]
-	_ = x[FnLwtPushEncap-73]
-	_ = x[FnLwtSeg6StoreBytes-74]
-	_ = x[FnLwtSeg6AdjustSrh-75]
-	_ = x[FnLwtSeg6Action-76]
-	_ = x[FnRcRepeat-77]
-	_ = x[FnRcKeydown-78]
-	_ = x[FnSkbCgroupId-79]
-	_ = x[FnGetCurrentCgroupId-80]
-	_ = x[FnGetLocalStorage-81]
-	_ = x[FnSkSelectReuseport-82]
-	_ = x[FnSkbAncestorCgroupId-83]
-	_ = x[FnSkLookupTcp-84]
-	_ = x[FnSkLookupUdp-85]
-	_ = x[FnSkRelease-86]
-	_ = x[FnMapPushElem-87]
-	_ = x[FnMapPopElem-88]
-	_ = x[FnMapPeekElem-89]
-	_ = x[FnMsgPushData-90]
-	_ = x[FnMsgPopData-91]
-	_ = x[FnRcPointerRel-92]
-	_ = x[FnSpinLock-93]
-	_ = x[FnSpinUnlock-94]
-	_ = x[FnSkFullsock-95]
-	_ = x[FnTcpSock-96]
-	_ = x[FnSkbEcnSetCe-97]
-	_ = x[FnGetListenerSock-98]
-	_ = x[FnSkcLookupTcp-99]
-	_ = x[FnTcpCheckSyncookie-100]
-	_ = x[FnSysctlGetName-101]
-	_ = x[FnSysctlGetCurrentValue-102]
-	_ = x[FnSysctlGetNewValue-103]
-	_ = x[FnSysctlSetNewValue-104]
-	_ = x[FnStrtol-105]
-	_ = x[FnStrtoul-106]
-	_ = x[FnSkStorageGet-107]
-	_ = x[FnSkStorageDelete-108]
-	_ = x[FnSendSignal-109]
-	_ = x[FnTcpGenSyncookie-110]
-	_ = x[FnSkbOutput-111]
-	_ = x[FnProbeReadUser-112]
-	_ = x[FnProbeReadKernel-113]
-	_ = x[FnProbeReadUserStr-114]
-	_ = x[FnProbeReadKernelStr-115]
-	_ = x[FnTcpSendAck-116]
-	_ = x[FnSendSignalThread-117]
-	_ = x[FnJiffies64-118]
-	_ = x[FnReadBranchRecords-119]
-	_ = x[FnGetNsCurrentPidTgid-120]
-	_ = x[FnXdpOutput-121]
-	_ = x[FnGetNetnsCookie-122]
-	_ = x[FnGetCurrentAncestorCgroupId-123]
-	_ = x[FnSkAssign-124]
-	_ = x[FnKtimeGetBootNs-125]
-	_ = x[FnSeqPrintf-126]
-	_ = x[FnSeqWrite-127]
-	_ = x[FnSkCgroupId-128]
-	_ = x[FnSkAncestorCgroupId-129]
-	_ = x[FnRingbufOutput-130]
-	_ = x[FnRingbufReserve-131]
-	_ = x[FnRingbufSubmit-132]
-	_ = x[FnRingbufDiscard-133]
-	_ = x[FnRingbufQuery-134]
-	_ = x[FnCsumLevel-135]
-	_ = x[FnSkcToTcp6Sock-136]
-	_ = x[FnSkcToTcpSock-137]
-	_ = x[FnSkcToTcpTimewaitSock-138]
-	_ = x[FnSkcToTcpRequestSock-139]
-	_ = x[FnSkcToUdp6Sock-140]
-	_ = x[FnGetTaskStack-141]
-	_ = x[FnLoadHdrOpt-142]
-	_ = x[FnStoreHdrOpt-143]
-	_ = x[FnReserveHdrOpt-144]
-	_ = x[FnInodeStorageGet-145]
-	_ = x[FnInodeStorageDelete-146]
-	_ = x[FnDPath-147]
-	_ = x[FnCopyFromUser-148]
-	_ = x[FnSnprintfBtf-149]
-	_ = x[FnSeqPrintfBtf-150]
-	_ = x[FnSkbCgroupClassid-151]
-	_ = x[FnRedirectNeigh-152]
-	_ = x[FnPerCpuPtr-153]
-	_ = x[FnThisCpuPtr-154]
-	_ = x[FnRedirectPeer-155]
-	_ = x[FnTaskStorageGet-156]
-	_ = x[FnTaskStorageDelete-157]
-	_ = x[FnGetCurrentTaskBtf-158]
-	_ = x[FnBprmOptsSet-159]
-	_ = x[FnKtimeGetCoarseNs-160]
-	_ = x[FnImaInodeHash-161]
-	_ = x[FnSockFromFile-162]
-	_ = x[FnCheckMtu-163]
-	_ = x[FnForEachMapElem-164]
-	_ = x[FnSnprintf-165]
-	_ = x[FnSysBpf-166]
-	_ = x[FnBtfFindByNameKind-167]
-	_ = x[FnSysClose-168]
-	_ = x[FnTimerInit-169]
-	_ = x[FnTimerSetCallback-170]
-	_ = x[FnTimerStart-171]
-	_ = x[FnTimerCancel-172]
-	_ = x[FnGetFuncIp-173]
-	_ = x[FnGetAttachCookie-174]
-	_ = x[FnTaskPtRegs-175]
-	_ = x[FnGetBranchSnapshot-176]
-	_ = x[FnTraceVprintk-177]
-	_ = x[FnSkcToUnixSock-178]
-	_ = x[FnKallsymsLookupName-179]
-	_ = x[FnFindVma-180]
-	_ = x[FnLoop-181]
-	_ = x[FnStrncmp-182]
-	_ = x[FnGetFuncArg-183]
-	_ = x[FnGetFuncRet-184]
-	_ = x[FnGetFuncArgCnt-185]
-	_ = x[FnGetRetval-186]
-	_ = x[FnSetRetval-187]
-	_ = x[FnXdpGetBuffLen-188]
-	_ = x[FnXdpLoadBytes-189]
-	_ = x[FnXdpStoreBytes-190]
-	_ = x[FnCopyFromUserTask-191]
-	_ = x[FnSkbSetTstamp-192]
-	_ = x[FnImaFileHash-193]
-	_ = x[FnKptrXchg-194]
-	_ = x[FnMapLookupPercpuElem-195]
-	_ = x[FnSkcToMptcpSock-196]
-	_ = x[FnDynptrFromMem-197]
-	_ = x[FnRingbufReserveDynptr-198]
-	_ = x[FnRingbufSubmitDynptr-199]
-	_ = x[FnRingbufDiscardDynptr-200]
-	_ = x[FnDynptrRead-201]
-	_ = x[FnDynptrWrite-202]
-	_ = x[FnDynptrData-203]
-	_ = x[FnTcpRawGenSyncookieIpv4-204]
-	_ = x[FnTcpRawGenSyncookieIpv6-205]
-	_ = x[FnTcpRawCheckSyncookieIpv4-206]
-	_ = x[FnTcpRawCheckSyncookieIpv6-207]
-	_ = x[FnKtimeGetTaiNs-208]
-	_ = x[FnUserRingbufDrain-209]
-	_ = x[FnCgrpStorageGet-210]
-	_ = x[FnCgrpStorageDelete-211]
-	_ = x[maxBuiltinFunc-212]
-}
-
-const _BuiltinFunc_name = "FnUnspecFnMapLookupElemFnMapUpdateElemFnMapDeleteElemFnProbeReadFnKtimeGetNsFnTracePrintkFnGetPrandomU32FnGetSmpProcessorIdFnSkbStoreBytesFnL3CsumReplaceFnL4CsumReplaceFnTailCallFnCloneRedirectFnGetCurrentPidTgidFnGetCurrentUidGidFnGetCurrentCommFnGetCgroupClassidFnSkbVlanPushFnSkbVlanPopFnSkbGetTunnelKeyFnSkbSetTunnelKeyFnPerfEventReadFnRedirectFnGetRouteRealmFnPerfEventOutputFnSkbLoadBytesFnGetStackidFnCsumDiffFnSkbGetTunnelOptFnSkbSetTunnelOptFnSkbChangeProtoFnSkbChangeTypeFnSkbUnderCgroupFnGetHashRecalcFnGetCurrentTaskFnProbeWriteUserFnCurrentTaskUnderCgroupFnSkbChangeTailFnSkbPullDataFnCsumUpdateFnSetHashInvalidFnGetNumaNodeIdFnSkbChangeHeadFnXdpAdjustHeadFnProbeReadStrFnGetSocketCookieFnGetSocketUidFnSetHashFnSetsockoptFnSkbAdjustRoomFnRedirectMapFnSkRedirectMapFnSockMapUpdateFnXdpAdjustMetaFnPerfEventReadValueFnPerfProgReadValueFnGetsockoptFnOverrideReturnFnSockOpsCbFlagsSetFnMsgRedirectMapFnMsgApplyBytesFnMsgCorkBytesFnMsgPullDataFnBindFnXdpAdjustTailFnSkbGetXfrmStateFnGetStackFnSkbLoadBytesRelativeFnFibLookupFnSockHashUpdateFnMsgRedirectHashFnSkRedirectHashFnLwtPushEncapFnLwtSeg6StoreBytesFnLwtSeg6AdjustSrhFnLwtSeg6ActionFnRcRepeatFnRcKeydownFnSkbCgroupIdFnGetCurrentCgroupIdFnGetLocalStorageFnSkSelectReuseportFnSkbAncestorCgroupIdFnSkLookupTcpFnSkLookupUdpFnSkReleaseFnMapPushElemFnMapPopElemFnMapPeekElemFnMsgPushDataFnMsgPopDataFnRcPointerRelFnSpinLockFnSpinUnlockFnSkFullsockFnTcpSockFnSkbEcnSetCeFnGetListenerSockFnSkcLookupTcpFnTcpCheckSyncookieFnSysctlGetNameFnSysctlGetCurrentValueFnSysctlGetNewValueFnSysctlSetNewValueFnStrtolFnStrtoulFnSkStorageGetFnSkStorageDeleteFnSendSignalFnTcpGenSyncookieFnSkbOutputFnProbeReadUserFnProbeReadKernelFnProbeReadUserStrFnProbeReadKernelStrFnTcpSendAckFnSendSignalThreadFnJiffies64FnReadBranchRecordsFnGetNsCurrentPidTgidFnXdpOutputFnGetNetnsCookieFnGetCurrentAncestorCgroupIdFnSkAssignFnKtimeGetBootNsFnSeqPrintfFnSeqWriteFnSkCgroupIdFnSkAncestorCgroupIdFnRingbufOutputFnRingbufReserveFnRingbufSubmitFnRingbufDiscardFnRingbufQueryFnCsumLevelFnSkcToTcp6SockFnSkcToTcpSockFnSkcToTcpTimewaitSockFnSkcToTcpRequestSockFnSkcToUdp6SockFnGetTaskStackFnLoadHdrOptFnStoreHdrOptFnReserveHdrOptFnInodeStorageGetFnInodeStorageDeleteFnDPathFnCopyFromUserFnSnprintfBtfFnSeqPrintfBtfFnSkbCgroupClassidFnRedirectNeighFnPerCpuPtrFnThisCpuPtrFnRedirectPeerFnTaskStorageGetFnTaskStorageDeleteFnGetCurrentTaskBtfFnBprmOptsSetFnKtimeGetCoarseNsFnImaInodeHashFnSockFromFileFnCheckMtuFnForEachMapElemFnSnprintfFnSysBpfFnBtfFindByNameKindFnSysCloseFnTimerInitFnTimerSetCallbackFnTimerStartFnTimerCancelFnGetFuncIpFnGetAttachCookieFnTaskPtRegsFnGetBranchSnapshotFnTraceVprintkFnSkcToUnixSockFnKallsymsLookupNameFnFindVmaFnLoopFnStrncmpFnGetFuncArgFnGetFuncRetFnGetFuncArgCntFnGetRetvalFnSetRetvalFnXdpGetBuffLenFnXdpLoadBytesFnXdpStoreBytesFnCopyFromUserTaskFnSkbSetTstampFnImaFileHashFnKptrXchgFnMapLookupPercpuElemFnSkcToMptcpSockFnDynptrFromMemFnRingbufReserveDynptrFnRingbufSubmitDynptrFnRingbufDiscardDynptrFnDynptrReadFnDynptrWriteFnDynptrDataFnTcpRawGenSyncookieIpv4FnTcpRawGenSyncookieIpv6FnTcpRawCheckSyncookieIpv4FnTcpRawCheckSyncookieIpv6FnKtimeGetTaiNsFnUserRingbufDrainFnCgrpStorageGetFnCgrpStorageDeletemaxBuiltinFunc"
-
-var _BuiltinFunc_index = [...]uint16{0, 8, 23, 38, 53, 64, 76, 89, 104, 123, 138, 153, 168, 178, 193, 212, 230, 246, 264, 277, 289, 306, 323, 338, 348, 363, 380, 394, 406, 416, 433, 450, 466, 481, 497, 512, 528, 544, 568, 583, 596, 608, 624, 639, 654, 669, 683, 700, 714, 723, 735, 750, 763, 778, 793, 808, 828, 847, 859, 875, 894, 910, 925, 939, 952, 958, 973, 990, 1000, 1022, 1033, 1049, 1066, 1082, 1096, 1115, 1133, 1148, 1158, 1169, 1182, 1202, 1219, 1238, 1259, 1272, 1285, 1296, 1309, 1321, 1334, 1347, 1359, 1373, 1383, 1395, 1407, 1416, 1429, 1446, 1460, 1479, 1494, 1517, 1536, 1555, 1563, 1572, 1586, 1603, 1615, 1632, 1643, 1658, 1675, 1693, 1713, 1725, 1743, 1754, 1773, 1794, 1805, 1821, 1849, 1859, 1875, 1886, 1896, 1908, 1928, 1943, 1959, 1974, 1990, 2004, 2015, 2030, 2044, 2066, 2087, 2102, 2116, 2128, 2141, 2156, 2173, 2193, 2200, 2214, 2227, 2241, 2259, 2274, 2285, 2297, 2311, 2327, 2346, 2365, 2378, 2396, 2410, 2424, 2434, 2450, 2460, 2468, 2487, 2497, 2508, 2526, 2538, 2551, 2562, 2579, 2591, 2610, 2624, 2639, 2659, 2668, 2674, 2683, 2695, 2707, 2722, 2733, 2744, 2759, 2773, 2788, 2806, 2820, 2833, 2843, 2864, 2880, 2895, 2917, 2938, 2960, 2972, 2985, 2997, 3021, 3045, 3071, 3097, 3112, 3130, 3146, 3165, 3179}
-
-func (i BuiltinFunc) String() string {
-	if i < 0 || i >= BuiltinFunc(len(_BuiltinFunc_index)-1) {
-		return "BuiltinFunc(" + strconv.FormatInt(int64(i), 10) + ")"
-	}
-	return _BuiltinFunc_name[_BuiltinFunc_index[i]:_BuiltinFunc_index[i+1]]
-}
diff --git a/vendor/github.com/cilium/ebpf/asm/instruction.go b/vendor/github.com/cilium/ebpf/asm/instruction.go
deleted file mode 100644
index ef01eaa35..000000000
--- a/vendor/github.com/cilium/ebpf/asm/instruction.go
+++ /dev/null
@@ -1,877 +0,0 @@
-package asm
-
-import (
-	"crypto/sha1"
-	"encoding/binary"
-	"encoding/hex"
-	"errors"
-	"fmt"
-	"io"
-	"math"
-	"sort"
-	"strings"
-
-	"github.com/cilium/ebpf/internal/sys"
-	"github.com/cilium/ebpf/internal/unix"
-)
-
-// InstructionSize is the size of a BPF instruction in bytes
-const InstructionSize = 8
-
-// RawInstructionOffset is an offset in units of raw BPF instructions.
-type RawInstructionOffset uint64
-
-var ErrUnreferencedSymbol = errors.New("unreferenced symbol")
-var ErrUnsatisfiedMapReference = errors.New("unsatisfied map reference")
-var ErrUnsatisfiedProgramReference = errors.New("unsatisfied program reference")
-
-// Bytes returns the offset of an instruction in bytes.
-func (rio RawInstructionOffset) Bytes() uint64 {
-	return uint64(rio) * InstructionSize
-}
-
-// Instruction is a single eBPF instruction.
-type Instruction struct {
-	OpCode   OpCode
-	Dst      Register
-	Src      Register
-	Offset   int16
-	Constant int64
-
-	// Metadata contains optional metadata about this instruction.
-	Metadata Metadata
-}
-
-// Unmarshal decodes a BPF instruction.
-func (ins *Instruction) Unmarshal(r io.Reader, bo binary.ByteOrder) (uint64, error) {
-	data := make([]byte, InstructionSize)
-	if _, err := io.ReadFull(r, data); err != nil {
-		return 0, err
-	}
-
-	ins.OpCode = OpCode(data[0])
-
-	regs := data[1]
-	switch bo {
-	case binary.LittleEndian:
-		ins.Dst, ins.Src = Register(regs&0xF), Register(regs>>4)
-	case binary.BigEndian:
-		ins.Dst, ins.Src = Register(regs>>4), Register(regs&0xf)
-	}
-
-	ins.Offset = int16(bo.Uint16(data[2:4]))
-	// Convert to int32 before widening to int64
-	// to ensure the signed bit is carried over.
-	ins.Constant = int64(int32(bo.Uint32(data[4:8])))
-
-	if !ins.OpCode.IsDWordLoad() {
-		return InstructionSize, nil
-	}
-
-	// Pull another instruction from the stream to retrieve the second
-	// half of the 64-bit immediate value.
-	if _, err := io.ReadFull(r, data); err != nil {
-		// No Wrap, to avoid io.EOF clash
-		return 0, errors.New("64bit immediate is missing second half")
-	}
-
-	// Require that all fields other than the value are zero.
-	if bo.Uint32(data[0:4]) != 0 {
-		return 0, errors.New("64bit immediate has non-zero fields")
-	}
-
-	cons1 := uint32(ins.Constant)
-	cons2 := int32(bo.Uint32(data[4:8]))
-	ins.Constant = int64(cons2)<<32 | int64(cons1)
-
-	return 2 * InstructionSize, nil
-}
-
-// Marshal encodes a BPF instruction.
-func (ins Instruction) Marshal(w io.Writer, bo binary.ByteOrder) (uint64, error) {
-	if ins.OpCode == InvalidOpCode {
-		return 0, errors.New("invalid opcode")
-	}
-
-	isDWordLoad := ins.OpCode.IsDWordLoad()
-
-	cons := int32(ins.Constant)
-	if isDWordLoad {
-		// Encode least significant 32bit first for 64bit operations.
-		cons = int32(uint32(ins.Constant))
-	}
-
-	regs, err := newBPFRegisters(ins.Dst, ins.Src, bo)
-	if err != nil {
-		return 0, fmt.Errorf("can't marshal registers: %s", err)
-	}
-
-	data := make([]byte, InstructionSize)
-	data[0] = byte(ins.OpCode)
-	data[1] = byte(regs)
-	bo.PutUint16(data[2:4], uint16(ins.Offset))
-	bo.PutUint32(data[4:8], uint32(cons))
-	if _, err := w.Write(data); err != nil {
-		return 0, err
-	}
-
-	if !isDWordLoad {
-		return InstructionSize, nil
-	}
-
-	// The first half of the second part of a double-wide instruction
-	// must be zero. The second half carries the value.
-	bo.PutUint32(data[0:4], 0)
-	bo.PutUint32(data[4:8], uint32(ins.Constant>>32))
-	if _, err := w.Write(data); err != nil {
-		return 0, err
-	}
-
-	return 2 * InstructionSize, nil
-}
-
-// AssociateMap associates a Map with this Instruction.
-//
-// Implicitly clears the Instruction's Reference field.
-//
-// Returns an error if the Instruction is not a map load.
-func (ins *Instruction) AssociateMap(m FDer) error {
-	if !ins.IsLoadFromMap() {
-		return errors.New("not a load from a map")
-	}
-
-	ins.Metadata.Set(referenceMeta{}, nil)
-	ins.Metadata.Set(mapMeta{}, m)
-
-	return nil
-}
-
-// RewriteMapPtr changes an instruction to use a new map fd.
-//
-// Returns an error if the instruction doesn't load a map.
-//
-// Deprecated: use AssociateMap instead. If you cannot provide a Map,
-// wrap an fd in a type implementing FDer.
-func (ins *Instruction) RewriteMapPtr(fd int) error {
-	if !ins.IsLoadFromMap() {
-		return errors.New("not a load from a map")
-	}
-
-	ins.encodeMapFD(fd)
-
-	return nil
-}
-
-func (ins *Instruction) encodeMapFD(fd int) {
-	// Preserve the offset value for direct map loads.
-	offset := uint64(ins.Constant) & (math.MaxUint32 << 32)
-	rawFd := uint64(uint32(fd))
-	ins.Constant = int64(offset | rawFd)
-}
-
-// MapPtr returns the map fd for this instruction.
-//
-// The result is undefined if the instruction is not a load from a map,
-// see IsLoadFromMap.
-//
-// Deprecated: use Map() instead.
-func (ins *Instruction) MapPtr() int {
-	// If there is a map associated with the instruction, return its FD.
-	if fd := ins.Metadata.Get(mapMeta{}); fd != nil {
-		return fd.(FDer).FD()
-	}
-
-	// Fall back to the fd stored in the Constant field
-	return ins.mapFd()
-}
-
-// mapFd returns the map file descriptor stored in the 32 least significant
-// bits of ins' Constant field.
-func (ins *Instruction) mapFd() int {
-	return int(int32(ins.Constant))
-}
-
-// RewriteMapOffset changes the offset of a direct load from a map.
-//
-// Returns an error if the instruction is not a direct load.
-func (ins *Instruction) RewriteMapOffset(offset uint32) error {
-	if !ins.OpCode.IsDWordLoad() {
-		return fmt.Errorf("%s is not a 64 bit load", ins.OpCode)
-	}
-
-	if ins.Src != PseudoMapValue {
-		return errors.New("not a direct load from a map")
-	}
-
-	fd := uint64(ins.Constant) & math.MaxUint32
-	ins.Constant = int64(uint64(offset)<<32 | fd)
-	return nil
-}
-
-func (ins *Instruction) mapOffset() uint32 {
-	return uint32(uint64(ins.Constant) >> 32)
-}
-
-// IsLoadFromMap returns true if the instruction loads from a map.
-//
-// This covers both loading the map pointer and direct map value loads.
-func (ins *Instruction) IsLoadFromMap() bool {
-	return ins.OpCode == LoadImmOp(DWord) && (ins.Src == PseudoMapFD || ins.Src == PseudoMapValue)
-}
-
-// IsFunctionCall returns true if the instruction calls another BPF function.
-//
-// This is not the same thing as a BPF helper call.
-func (ins *Instruction) IsFunctionCall() bool {
-	return ins.OpCode.JumpOp() == Call && ins.Src == PseudoCall
-}
-
-// IsKfuncCall returns true if the instruction calls a kfunc.
-//
-// This is not the same thing as a BPF helper call.
-func (ins *Instruction) IsKfuncCall() bool {
-	return ins.OpCode.JumpOp() == Call && ins.Src == PseudoKfuncCall
-}
-
-// IsLoadOfFunctionPointer returns true if the instruction loads a function pointer.
-func (ins *Instruction) IsLoadOfFunctionPointer() bool {
-	return ins.OpCode.IsDWordLoad() && ins.Src == PseudoFunc
-}
-
-// IsFunctionReference returns true if the instruction references another BPF
-// function, either by invoking a Call jump operation or by loading a function
-// pointer.
-func (ins *Instruction) IsFunctionReference() bool {
-	return ins.IsFunctionCall() || ins.IsLoadOfFunctionPointer()
-}
-
-// IsBuiltinCall returns true if the instruction is a built-in call, i.e. BPF helper call.
-func (ins *Instruction) IsBuiltinCall() bool {
-	return ins.OpCode.JumpOp() == Call && ins.Src == R0 && ins.Dst == R0
-}
-
-// IsConstantLoad returns true if the instruction loads a constant of the
-// given size.
-func (ins *Instruction) IsConstantLoad(size Size) bool {
-	return ins.OpCode == LoadImmOp(size) && ins.Src == R0 && ins.Offset == 0
-}
-
-// Format implements fmt.Formatter.
-func (ins Instruction) Format(f fmt.State, c rune) {
-	if c != 'v' {
-		fmt.Fprintf(f, "{UNRECOGNIZED: %c}", c)
-		return
-	}
-
-	op := ins.OpCode
-
-	if op == InvalidOpCode {
-		fmt.Fprint(f, "INVALID")
-		return
-	}
-
-	// Omit trailing space for Exit
-	if op.JumpOp() == Exit {
-		fmt.Fprint(f, op)
-		return
-	}
-
-	if ins.IsLoadFromMap() {
-		fd := ins.mapFd()
-		m := ins.Map()
-		switch ins.Src {
-		case PseudoMapFD:
-			if m != nil {
-				fmt.Fprintf(f, "LoadMapPtr dst: %s map: %s", ins.Dst, m)
-			} else {
-				fmt.Fprintf(f, "LoadMapPtr dst: %s fd: %d", ins.Dst, fd)
-			}
-
-		case PseudoMapValue:
-			if m != nil {
-				fmt.Fprintf(f, "LoadMapValue dst: %s, map: %s off: %d", ins.Dst, m, ins.mapOffset())
-			} else {
-				fmt.Fprintf(f, "LoadMapValue dst: %s, fd: %d off: %d", ins.Dst, fd, ins.mapOffset())
-			}
-		}
-
-		goto ref
-	}
-
-	fmt.Fprintf(f, "%v ", op)
-	switch cls := op.Class(); {
-	case cls.isLoadOrStore():
-		switch op.Mode() {
-		case ImmMode:
-			fmt.Fprintf(f, "dst: %s imm: %d", ins.Dst, ins.Constant)
-		case AbsMode:
-			fmt.Fprintf(f, "imm: %d", ins.Constant)
-		case IndMode:
-			fmt.Fprintf(f, "dst: %s src: %s imm: %d", ins.Dst, ins.Src, ins.Constant)
-		case MemMode:
-			fmt.Fprintf(f, "dst: %s src: %s off: %d imm: %d", ins.Dst, ins.Src, ins.Offset, ins.Constant)
-		case XAddMode:
-			fmt.Fprintf(f, "dst: %s src: %s", ins.Dst, ins.Src)
-		}
-
-	case cls.IsALU():
-		fmt.Fprintf(f, "dst: %s ", ins.Dst)
-		if op.ALUOp() == Swap || op.Source() == ImmSource {
-			fmt.Fprintf(f, "imm: %d", ins.Constant)
-		} else {
-			fmt.Fprintf(f, "src: %s", ins.Src)
-		}
-
-	case cls.IsJump():
-		switch jop := op.JumpOp(); jop {
-		case Call:
-			switch ins.Src {
-			case PseudoCall:
-				// bpf-to-bpf call
-				fmt.Fprint(f, ins.Constant)
-			case PseudoKfuncCall:
-				// kfunc call
-				fmt.Fprintf(f, "Kfunc(%d)", ins.Constant)
-			default:
-				fmt.Fprint(f, BuiltinFunc(ins.Constant))
-			}
-
-		default:
-			fmt.Fprintf(f, "dst: %s off: %d ", ins.Dst, ins.Offset)
-			if op.Source() == ImmSource {
-				fmt.Fprintf(f, "imm: %d", ins.Constant)
-			} else {
-				fmt.Fprintf(f, "src: %s", ins.Src)
-			}
-		}
-	}
-
-ref:
-	if ins.Reference() != "" {
-		fmt.Fprintf(f, " <%s>", ins.Reference())
-	}
-}
-
-func (ins Instruction) equal(other Instruction) bool {
-	return ins.OpCode == other.OpCode &&
-		ins.Dst == other.Dst &&
-		ins.Src == other.Src &&
-		ins.Offset == other.Offset &&
-		ins.Constant == other.Constant
-}
-
-// Size returns the amount of bytes ins would occupy in binary form.
-func (ins Instruction) Size() uint64 {
-	return uint64(InstructionSize * ins.OpCode.rawInstructions())
-}
-
-// WithMetadata sets the given Metadata on the Instruction. e.g. to copy
-// Metadata from another Instruction when replacing it.
-func (ins Instruction) WithMetadata(meta Metadata) Instruction {
-	ins.Metadata = meta
-	return ins
-}
-
-type symbolMeta struct{}
-
-// WithSymbol marks the Instruction as a Symbol, which other Instructions
-// can point to using corresponding calls to WithReference.
-func (ins Instruction) WithSymbol(name string) Instruction {
-	ins.Metadata.Set(symbolMeta{}, name)
-	return ins
-}
-
-// Sym creates a symbol.
-//
-// Deprecated: use WithSymbol instead.
-func (ins Instruction) Sym(name string) Instruction {
-	return ins.WithSymbol(name)
-}
-
-// Symbol returns the value ins has been marked with using WithSymbol,
-// otherwise returns an empty string. A symbol is often an Instruction
-// at the start of a function body.
-func (ins Instruction) Symbol() string {
-	sym, _ := ins.Metadata.Get(symbolMeta{}).(string)
-	return sym
-}
-
-type referenceMeta struct{}
-
-// WithReference makes ins reference another Symbol or map by name.
-func (ins Instruction) WithReference(ref string) Instruction {
-	ins.Metadata.Set(referenceMeta{}, ref)
-	return ins
-}
-
-// Reference returns the Symbol or map name referenced by ins, if any.
-func (ins Instruction) Reference() string {
-	ref, _ := ins.Metadata.Get(referenceMeta{}).(string)
-	return ref
-}
-
-type mapMeta struct{}
-
-// Map returns the Map referenced by ins, if any.
-// An Instruction will contain a Map if e.g. it references an existing,
-// pinned map that was opened during ELF loading.
-func (ins Instruction) Map() FDer {
-	fd, _ := ins.Metadata.Get(mapMeta{}).(FDer)
-	return fd
-}
-
-type sourceMeta struct{}
-
-// WithSource adds source information about the Instruction.
-func (ins Instruction) WithSource(src fmt.Stringer) Instruction {
-	ins.Metadata.Set(sourceMeta{}, src)
-	return ins
-}
-
-// Source returns source information about the Instruction. The field is
-// present when the compiler emits BTF line info about the Instruction and
-// usually contains the line of source code responsible for it.
-func (ins Instruction) Source() fmt.Stringer {
-	str, _ := ins.Metadata.Get(sourceMeta{}).(fmt.Stringer)
-	return str
-}
-
-// A Comment can be passed to Instruction.WithSource to add a comment
-// to an instruction.
-type Comment string
-
-func (s Comment) String() string {
-	return string(s)
-}
-
-// FDer represents a resource tied to an underlying file descriptor.
-// Used as a stand-in for e.g. ebpf.Map since that type cannot be
-// imported here and FD() is the only method we rely on.
-type FDer interface {
-	FD() int
-}
-
-// Instructions is an eBPF program.
-type Instructions []Instruction
-
-// Unmarshal unmarshals an Instructions from a binary instruction stream.
-// All instructions in insns are replaced by instructions decoded from r.
-func (insns *Instructions) Unmarshal(r io.Reader, bo binary.ByteOrder) error {
-	if len(*insns) > 0 {
-		*insns = nil
-	}
-
-	var offset uint64
-	for {
-		var ins Instruction
-		n, err := ins.Unmarshal(r, bo)
-		if errors.Is(err, io.EOF) {
-			break
-		}
-		if err != nil {
-			return fmt.Errorf("offset %d: %w", offset, err)
-		}
-
-		*insns = append(*insns, ins)
-		offset += n
-	}
-
-	return nil
-}
-
-// Name returns the name of the function insns belongs to, if any.
-func (insns Instructions) Name() string {
-	if len(insns) == 0 {
-		return ""
-	}
-	return insns[0].Symbol()
-}
-
-func (insns Instructions) String() string {
-	return fmt.Sprint(insns)
-}
-
-// Size returns the amount of bytes insns would occupy in binary form.
-func (insns Instructions) Size() uint64 {
-	var sum uint64
-	for _, ins := range insns {
-		sum += ins.Size()
-	}
-	return sum
-}
-
-// AssociateMap updates all Instructions that Reference the given symbol
-// to point to an existing Map m instead.
-//
-// Returns ErrUnreferencedSymbol error if no references to symbol are found
-// in insns. If symbol is anything else than the symbol name of map (e.g.
-// a bpf2bpf subprogram), an error is returned.
-func (insns Instructions) AssociateMap(symbol string, m FDer) error {
-	if symbol == "" {
-		return errors.New("empty symbol")
-	}
-
-	var found bool
-	for i := range insns {
-		ins := &insns[i]
-		if ins.Reference() != symbol {
-			continue
-		}
-
-		if err := ins.AssociateMap(m); err != nil {
-			return err
-		}
-
-		found = true
-	}
-
-	if !found {
-		return fmt.Errorf("symbol %s: %w", symbol, ErrUnreferencedSymbol)
-	}
-
-	return nil
-}
-
-// RewriteMapPtr rewrites all loads of a specific map pointer to a new fd.
-//
-// Returns ErrUnreferencedSymbol if the symbol isn't used.
-//
-// Deprecated: use AssociateMap instead.
-func (insns Instructions) RewriteMapPtr(symbol string, fd int) error {
-	if symbol == "" {
-		return errors.New("empty symbol")
-	}
-
-	var found bool
-	for i := range insns {
-		ins := &insns[i]
-		if ins.Reference() != symbol {
-			continue
-		}
-
-		if !ins.IsLoadFromMap() {
-			return errors.New("not a load from a map")
-		}
-
-		ins.encodeMapFD(fd)
-
-		found = true
-	}
-
-	if !found {
-		return fmt.Errorf("symbol %s: %w", symbol, ErrUnreferencedSymbol)
-	}
-
-	return nil
-}
-
-// SymbolOffsets returns the set of symbols and their offset in
-// the instructions.
-func (insns Instructions) SymbolOffsets() (map[string]int, error) {
-	offsets := make(map[string]int)
-
-	for i, ins := range insns {
-		if ins.Symbol() == "" {
-			continue
-		}
-
-		if _, ok := offsets[ins.Symbol()]; ok {
-			return nil, fmt.Errorf("duplicate symbol %s", ins.Symbol())
-		}
-
-		offsets[ins.Symbol()] = i
-	}
-
-	return offsets, nil
-}
-
-// FunctionReferences returns a set of symbol names these Instructions make
-// bpf-to-bpf calls to.
-func (insns Instructions) FunctionReferences() []string {
-	calls := make(map[string]struct{})
-	for _, ins := range insns {
-		if ins.Constant != -1 {
-			// BPF-to-BPF calls have -1 constants.
-			continue
-		}
-
-		if ins.Reference() == "" {
-			continue
-		}
-
-		if !ins.IsFunctionReference() {
-			continue
-		}
-
-		calls[ins.Reference()] = struct{}{}
-	}
-
-	result := make([]string, 0, len(calls))
-	for call := range calls {
-		result = append(result, call)
-	}
-
-	sort.Strings(result)
-	return result
-}
-
-// ReferenceOffsets returns the set of references and their offset in
-// the instructions.
-func (insns Instructions) ReferenceOffsets() map[string][]int {
-	offsets := make(map[string][]int)
-
-	for i, ins := range insns {
-		if ins.Reference() == "" {
-			continue
-		}
-
-		offsets[ins.Reference()] = append(offsets[ins.Reference()], i)
-	}
-
-	return offsets
-}
-
-// Format implements fmt.Formatter.
-//
-// You can control indentation of symbols by
-// specifying a width. Setting a precision controls the indentation of
-// instructions.
-// The default character is a tab, which can be overridden by specifying
-// the ' ' space flag.
-func (insns Instructions) Format(f fmt.State, c rune) {
-	if c != 's' && c != 'v' {
-		fmt.Fprintf(f, "{UNKNOWN FORMAT '%c'}", c)
-		return
-	}
-
-	// Precision is better in this case, because it allows
-	// specifying 0 padding easily.
-	padding, ok := f.Precision()
-	if !ok {
-		padding = 1
-	}
-
-	indent := strings.Repeat("\t", padding)
-	if f.Flag(' ') {
-		indent = strings.Repeat(" ", padding)
-	}
-
-	symPadding, ok := f.Width()
-	if !ok {
-		symPadding = padding - 1
-	}
-	if symPadding < 0 {
-		symPadding = 0
-	}
-
-	symIndent := strings.Repeat("\t", symPadding)
-	if f.Flag(' ') {
-		symIndent = strings.Repeat(" ", symPadding)
-	}
-
-	// Guess how many digits we need at most, by assuming that all instructions
-	// are double wide.
-	highestOffset := len(insns) * 2
-	offsetWidth := int(math.Ceil(math.Log10(float64(highestOffset))))
-
-	iter := insns.Iterate()
-	for iter.Next() {
-		if iter.Ins.Symbol() != "" {
-			fmt.Fprintf(f, "%s%s:\n", symIndent, iter.Ins.Symbol())
-		}
-		if src := iter.Ins.Source(); src != nil {
-			line := strings.TrimSpace(src.String())
-			if line != "" {
-				fmt.Fprintf(f, "%s%*s; %s\n", indent, offsetWidth, " ", line)
-			}
-		}
-		fmt.Fprintf(f, "%s%*d: %v\n", indent, offsetWidth, iter.Offset, iter.Ins)
-	}
-}
-
-// Marshal encodes a BPF program into the kernel format.
-//
-// insns may be modified if there are unresolved jumps or bpf2bpf calls.
-//
-// Returns ErrUnsatisfiedProgramReference if there is a Reference Instruction
-// without a matching Symbol Instruction within insns.
-func (insns Instructions) Marshal(w io.Writer, bo binary.ByteOrder) error {
-	if err := insns.encodeFunctionReferences(); err != nil {
-		return err
-	}
-
-	if err := insns.encodeMapPointers(); err != nil {
-		return err
-	}
-
-	for i, ins := range insns {
-		if _, err := ins.Marshal(w, bo); err != nil {
-			return fmt.Errorf("instruction %d: %w", i, err)
-		}
-	}
-	return nil
-}
-
-// Tag calculates the kernel tag for a series of instructions.
-//
-// It mirrors bpf_prog_calc_tag in the kernel and so can be compared
-// to ProgramInfo.Tag to figure out whether a loaded program matches
-// certain instructions.
-func (insns Instructions) Tag(bo binary.ByteOrder) (string, error) {
-	h := sha1.New()
-	for i, ins := range insns {
-		if ins.IsLoadFromMap() {
-			ins.Constant = 0
-		}
-		_, err := ins.Marshal(h, bo)
-		if err != nil {
-			return "", fmt.Errorf("instruction %d: %w", i, err)
-		}
-	}
-	return hex.EncodeToString(h.Sum(nil)[:unix.BPF_TAG_SIZE]), nil
-}
-
-// encodeFunctionReferences populates the Offset (or Constant, depending on
-// the instruction type) field of instructions with a Reference field to point
-// to the offset of the corresponding instruction with a matching Symbol field.
-//
-// Only Reference Instructions that are either jumps or BPF function references
-// (calls or function pointer loads) are populated.
-//
-// Returns ErrUnsatisfiedProgramReference if there is a Reference Instruction
-// without at least one corresponding Symbol Instruction within insns.
-func (insns Instructions) encodeFunctionReferences() error {
-	// Index the offsets of instructions tagged as a symbol.
-	symbolOffsets := make(map[string]RawInstructionOffset)
-	iter := insns.Iterate()
-	for iter.Next() {
-		ins := iter.Ins
-
-		if ins.Symbol() == "" {
-			continue
-		}
-
-		if _, ok := symbolOffsets[ins.Symbol()]; ok {
-			return fmt.Errorf("duplicate symbol %s", ins.Symbol())
-		}
-
-		symbolOffsets[ins.Symbol()] = iter.Offset
-	}
-
-	// Find all instructions tagged as references to other symbols.
-	// Depending on the instruction type, populate their constant or offset
-	// fields to point to the symbol they refer to within the insn stream.
-	iter = insns.Iterate()
-	for iter.Next() {
-		i := iter.Index
-		offset := iter.Offset
-		ins := iter.Ins
-
-		if ins.Reference() == "" {
-			continue
-		}
-
-		switch {
-		case ins.IsFunctionReference() && ins.Constant == -1:
-			symOffset, ok := symbolOffsets[ins.Reference()]
-			if !ok {
-				return fmt.Errorf("%s at insn %d: symbol %q: %w", ins.OpCode, i, ins.Reference(), ErrUnsatisfiedProgramReference)
-			}
-
-			ins.Constant = int64(symOffset - offset - 1)
-
-		case ins.OpCode.Class().IsJump() && ins.Offset == -1:
-			symOffset, ok := symbolOffsets[ins.Reference()]
-			if !ok {
-				return fmt.Errorf("%s at insn %d: symbol %q: %w", ins.OpCode, i, ins.Reference(), ErrUnsatisfiedProgramReference)
-			}
-
-			ins.Offset = int16(symOffset - offset - 1)
-		}
-	}
-
-	return nil
-}
-
-// encodeMapPointers finds all Map Instructions and encodes their FDs
-// into their Constant fields.
-func (insns Instructions) encodeMapPointers() error {
-	iter := insns.Iterate()
-	for iter.Next() {
-		ins := iter.Ins
-
-		if !ins.IsLoadFromMap() {
-			continue
-		}
-
-		m := ins.Map()
-		if m == nil {
-			continue
-		}
-
-		fd := m.FD()
-		if fd < 0 {
-			return fmt.Errorf("map %s: %w", m, sys.ErrClosedFd)
-		}
-
-		ins.encodeMapFD(m.FD())
-	}
-
-	return nil
-}
-
-// Iterate allows iterating a BPF program while keeping track of
-// various offsets.
-//
-// Modifying the instruction slice will lead to undefined behaviour.
-func (insns Instructions) Iterate() *InstructionIterator {
-	return &InstructionIterator{insns: insns}
-}
-
-// InstructionIterator iterates over a BPF program.
-type InstructionIterator struct {
-	insns Instructions
-	// The instruction in question.
-	Ins *Instruction
-	// The index of the instruction in the original instruction slice.
-	Index int
-	// The offset of the instruction in raw BPF instructions. This accounts
-	// for double-wide instructions.
-	Offset RawInstructionOffset
-}
-
-// Next returns true as long as there are any instructions remaining.
-func (iter *InstructionIterator) Next() bool {
-	if len(iter.insns) == 0 {
-		return false
-	}
-
-	if iter.Ins != nil {
-		iter.Index++
-		iter.Offset += RawInstructionOffset(iter.Ins.OpCode.rawInstructions())
-	}
-	iter.Ins = &iter.insns[0]
-	iter.insns = iter.insns[1:]
-	return true
-}
-
-type bpfRegisters uint8
-
-func newBPFRegisters(dst, src Register, bo binary.ByteOrder) (bpfRegisters, error) {
-	switch bo {
-	case binary.LittleEndian:
-		return bpfRegisters((src << 4) | (dst & 0xF)), nil
-	case binary.BigEndian:
-		return bpfRegisters((dst << 4) | (src & 0xF)), nil
-	default:
-		return 0, fmt.Errorf("unrecognized ByteOrder %T", bo)
-	}
-}
-
-// IsUnreferencedSymbol returns true if err was caused by
-// an unreferenced symbol.
-//
-// Deprecated: use errors.Is(err, asm.ErrUnreferencedSymbol).
-func IsUnreferencedSymbol(err error) bool {
-	return errors.Is(err, ErrUnreferencedSymbol)
-}
diff --git a/vendor/github.com/cilium/ebpf/asm/jump.go b/vendor/github.com/cilium/ebpf/asm/jump.go
deleted file mode 100644
index 2c8a3dbb7..000000000
--- a/vendor/github.com/cilium/ebpf/asm/jump.go
+++ /dev/null
@@ -1,127 +0,0 @@
-package asm
-
-//go:generate stringer -output jump_string.go -type=JumpOp
-
-// JumpOp affect control flow.
-//
-//	msb      lsb
-//	+----+-+---+
-//	|OP  |s|cls|
-//	+----+-+---+
-type JumpOp uint8
-
-const jumpMask OpCode = aluMask
-
-const (
-	// InvalidJumpOp is returned by getters when invoked
-	// on non branch OpCodes
-	InvalidJumpOp JumpOp = 0xff
-	// Ja jumps by offset unconditionally
-	Ja JumpOp = 0x00
-	// JEq jumps by offset if r == imm
-	JEq JumpOp = 0x10
-	// JGT jumps by offset if r > imm
-	JGT JumpOp = 0x20
-	// JGE jumps by offset if r >= imm
-	JGE JumpOp = 0x30
-	// JSet jumps by offset if r & imm
-	JSet JumpOp = 0x40
-	// JNE jumps by offset if r != imm
-	JNE JumpOp = 0x50
-	// JSGT jumps by offset if signed r > signed imm
-	JSGT JumpOp = 0x60
-	// JSGE jumps by offset if signed r >= signed imm
-	JSGE JumpOp = 0x70
-	// Call builtin or user defined function from imm
-	Call JumpOp = 0x80
-	// Exit ends execution, with value in r0
-	Exit JumpOp = 0x90
-	// JLT jumps by offset if r < imm
-	JLT JumpOp = 0xa0
-	// JLE jumps by offset if r <= imm
-	JLE JumpOp = 0xb0
-	// JSLT jumps by offset if signed r < signed imm
-	JSLT JumpOp = 0xc0
-	// JSLE jumps by offset if signed r <= signed imm
-	JSLE JumpOp = 0xd0
-)
-
-// Return emits an exit instruction.
-//
-// Requires a return value in R0.
-func Return() Instruction {
-	return Instruction{
-		OpCode: OpCode(JumpClass).SetJumpOp(Exit),
-	}
-}
-
-// Op returns the OpCode for a given jump source.
-func (op JumpOp) Op(source Source) OpCode {
-	return OpCode(JumpClass).SetJumpOp(op).SetSource(source)
-}
-
-// Imm compares 64 bit dst to 64 bit value (sign extended), and adjusts PC by offset if the condition is fulfilled.
-func (op JumpOp) Imm(dst Register, value int32, label string) Instruction {
-	return Instruction{
-		OpCode:   op.opCode(JumpClass, ImmSource),
-		Dst:      dst,
-		Offset:   -1,
-		Constant: int64(value),
-	}.WithReference(label)
-}
-
-// Imm32 compares 32 bit dst to 32 bit value, and adjusts PC by offset if the condition is fulfilled.
-// Requires kernel 5.1.
-func (op JumpOp) Imm32(dst Register, value int32, label string) Instruction {
-	return Instruction{
-		OpCode:   op.opCode(Jump32Class, ImmSource),
-		Dst:      dst,
-		Offset:   -1,
-		Constant: int64(value),
-	}.WithReference(label)
-}
-
-// Reg compares 64 bit dst to 64 bit src, and adjusts PC by offset if the condition is fulfilled.
-func (op JumpOp) Reg(dst, src Register, label string) Instruction {
-	return Instruction{
-		OpCode: op.opCode(JumpClass, RegSource),
-		Dst:    dst,
-		Src:    src,
-		Offset: -1,
-	}.WithReference(label)
-}
-
-// Reg32 compares 32 bit dst to 32 bit src, and adjusts PC by offset if the condition is fulfilled.
-// Requires kernel 5.1.
-func (op JumpOp) Reg32(dst, src Register, label string) Instruction {
-	return Instruction{
-		OpCode: op.opCode(Jump32Class, RegSource),
-		Dst:    dst,
-		Src:    src,
-		Offset: -1,
-	}.WithReference(label)
-}
-
-func (op JumpOp) opCode(class Class, source Source) OpCode {
-	if op == Exit || op == Call || op == Ja {
-		return InvalidOpCode
-	}
-
-	return OpCode(class).SetJumpOp(op).SetSource(source)
-}
-
-// Label adjusts PC to the address of the label.
-func (op JumpOp) Label(label string) Instruction {
-	if op == Call {
-		return Instruction{
-			OpCode:   OpCode(JumpClass).SetJumpOp(Call),
-			Src:      PseudoCall,
-			Constant: -1,
-		}.WithReference(label)
-	}
-
-	return Instruction{
-		OpCode: OpCode(JumpClass).SetJumpOp(op),
-		Offset: -1,
-	}.WithReference(label)
-}
diff --git a/vendor/github.com/cilium/ebpf/asm/jump_string.go b/vendor/github.com/cilium/ebpf/asm/jump_string.go
deleted file mode 100644
index 85a4aaffa..000000000
--- a/vendor/github.com/cilium/ebpf/asm/jump_string.go
+++ /dev/null
@@ -1,53 +0,0 @@
-// Code generated by "stringer -output jump_string.go -type=JumpOp"; DO NOT EDIT.
-
-package asm
-
-import "strconv"
-
-func _() {
-	// An "invalid array index" compiler error signifies that the constant values have changed.
-	// Re-run the stringer command to generate them again.
-	var x [1]struct{}
-	_ = x[InvalidJumpOp-255]
-	_ = x[Ja-0]
-	_ = x[JEq-16]
-	_ = x[JGT-32]
-	_ = x[JGE-48]
-	_ = x[JSet-64]
-	_ = x[JNE-80]
-	_ = x[JSGT-96]
-	_ = x[JSGE-112]
-	_ = x[Call-128]
-	_ = x[Exit-144]
-	_ = x[JLT-160]
-	_ = x[JLE-176]
-	_ = x[JSLT-192]
-	_ = x[JSLE-208]
-}
-
-const _JumpOp_name = "JaJEqJGTJGEJSetJNEJSGTJSGECallExitJLTJLEJSLTJSLEInvalidJumpOp"
-
-var _JumpOp_map = map[JumpOp]string{
-	0:   _JumpOp_name[0:2],
-	16:  _JumpOp_name[2:5],
-	32:  _JumpOp_name[5:8],
-	48:  _JumpOp_name[8:11],
-	64:  _JumpOp_name[11:15],
-	80:  _JumpOp_name[15:18],
-	96:  _JumpOp_name[18:22],
-	112: _JumpOp_name[22:26],
-	128: _JumpOp_name[26:30],
-	144: _JumpOp_name[30:34],
-	160: _JumpOp_name[34:37],
-	176: _JumpOp_name[37:40],
-	192: _JumpOp_name[40:44],
-	208: _JumpOp_name[44:48],
-	255: _JumpOp_name[48:61],
-}
-
-func (i JumpOp) String() string {
-	if str, ok := _JumpOp_map[i]; ok {
-		return str
-	}
-	return "JumpOp(" + strconv.FormatInt(int64(i), 10) + ")"
-}
diff --git a/vendor/github.com/cilium/ebpf/asm/load_store.go b/vendor/github.com/cilium/ebpf/asm/load_store.go
deleted file mode 100644
index f109497ae..000000000
--- a/vendor/github.com/cilium/ebpf/asm/load_store.go
+++ /dev/null
@@ -1,204 +0,0 @@
-package asm
-
-//go:generate stringer -output load_store_string.go -type=Mode,Size
-
-// Mode for load and store operations
-//
-//	msb      lsb
-//	+---+--+---+
-//	|MDE|sz|cls|
-//	+---+--+---+
-type Mode uint8
-
-const modeMask OpCode = 0xe0
-
-const (
-	// InvalidMode is returned by getters when invoked
-	// on non load / store OpCodes
-	InvalidMode Mode = 0xff
-	// ImmMode - immediate value
-	ImmMode Mode = 0x00
-	// AbsMode - immediate value + offset
-	AbsMode Mode = 0x20
-	// IndMode - indirect (imm+src)
-	IndMode Mode = 0x40
-	// MemMode - load from memory
-	MemMode Mode = 0x60
-	// XAddMode - add atomically across processors.
-	XAddMode Mode = 0xc0
-)
-
-// Size of load and store operations
-//
-//	msb      lsb
-//	+---+--+---+
-//	|mde|SZ|cls|
-//	+---+--+---+
-type Size uint8
-
-const sizeMask OpCode = 0x18
-
-const (
-	// InvalidSize is returned by getters when invoked
-	// on non load / store OpCodes
-	InvalidSize Size = 0xff
-	// DWord - double word; 64 bits
-	DWord Size = 0x18
-	// Word - word; 32 bits
-	Word Size = 0x00
-	// Half - half-word; 16 bits
-	Half Size = 0x08
-	// Byte - byte; 8 bits
-	Byte Size = 0x10
-)
-
-// Sizeof returns the size in bytes.
-func (s Size) Sizeof() int {
-	switch s {
-	case DWord:
-		return 8
-	case Word:
-		return 4
-	case Half:
-		return 2
-	case Byte:
-		return 1
-	default:
-		return -1
-	}
-}
-
-// LoadMemOp returns the OpCode to load a value of given size from memory.
-func LoadMemOp(size Size) OpCode {
-	return OpCode(LdXClass).SetMode(MemMode).SetSize(size)
-}
-
-// LoadMem emits `dst = *(size *)(src + offset)`.
-func LoadMem(dst, src Register, offset int16, size Size) Instruction {
-	return Instruction{
-		OpCode: LoadMemOp(size),
-		Dst:    dst,
-		Src:    src,
-		Offset: offset,
-	}
-}
-
-// LoadImmOp returns the OpCode to load an immediate of given size.
-//
-// As of kernel 4.20, only DWord size is accepted.
-func LoadImmOp(size Size) OpCode {
-	return OpCode(LdClass).SetMode(ImmMode).SetSize(size)
-}
-
-// LoadImm emits `dst = (size)value`.
-//
-// As of kernel 4.20, only DWord size is accepted.
-func LoadImm(dst Register, value int64, size Size) Instruction {
-	return Instruction{
-		OpCode:   LoadImmOp(size),
-		Dst:      dst,
-		Constant: value,
-	}
-}
-
-// LoadMapPtr stores a pointer to a map in dst.
-func LoadMapPtr(dst Register, fd int) Instruction {
-	if fd < 0 {
-		return Instruction{OpCode: InvalidOpCode}
-	}
-
-	return Instruction{
-		OpCode:   LoadImmOp(DWord),
-		Dst:      dst,
-		Src:      PseudoMapFD,
-		Constant: int64(uint32(fd)),
-	}
-}
-
-// LoadMapValue stores a pointer to the value at a certain offset of a map.
-func LoadMapValue(dst Register, fd int, offset uint32) Instruction {
-	if fd < 0 {
-		return Instruction{OpCode: InvalidOpCode}
-	}
-
-	fdAndOffset := (uint64(offset) << 32) | uint64(uint32(fd))
-	return Instruction{
-		OpCode:   LoadImmOp(DWord),
-		Dst:      dst,
-		Src:      PseudoMapValue,
-		Constant: int64(fdAndOffset),
-	}
-}
-
-// LoadIndOp returns the OpCode for loading a value of given size from an sk_buff.
-func LoadIndOp(size Size) OpCode {
-	return OpCode(LdClass).SetMode(IndMode).SetSize(size)
-}
-
-// LoadInd emits `dst = ntoh(*(size *)(((sk_buff *)R6)->data + src + offset))`.
-func LoadInd(dst, src Register, offset int32, size Size) Instruction {
-	return Instruction{
-		OpCode:   LoadIndOp(size),
-		Dst:      dst,
-		Src:      src,
-		Constant: int64(offset),
-	}
-}
-
-// LoadAbsOp returns the OpCode for loading a value of given size from an sk_buff.
-func LoadAbsOp(size Size) OpCode {
-	return OpCode(LdClass).SetMode(AbsMode).SetSize(size)
-}
-
-// LoadAbs emits `r0 = ntoh(*(size *)(((sk_buff *)R6)->data + offset))`.
-func LoadAbs(offset int32, size Size) Instruction {
-	return Instruction{
-		OpCode:   LoadAbsOp(size),
-		Dst:      R0,
-		Constant: int64(offset),
-	}
-}
-
-// StoreMemOp returns the OpCode for storing a register of given size in memory.
-func StoreMemOp(size Size) OpCode {
-	return OpCode(StXClass).SetMode(MemMode).SetSize(size)
-}
-
-// StoreMem emits `*(size *)(dst + offset) = src`
-func StoreMem(dst Register, offset int16, src Register, size Size) Instruction {
-	return Instruction{
-		OpCode: StoreMemOp(size),
-		Dst:    dst,
-		Src:    src,
-		Offset: offset,
-	}
-}
-
-// StoreImmOp returns the OpCode for storing an immediate of given size in memory.
-func StoreImmOp(size Size) OpCode {
-	return OpCode(StClass).SetMode(MemMode).SetSize(size)
-}
-
-// StoreImm emits `*(size *)(dst + offset) = value`.
-func StoreImm(dst Register, offset int16, value int64, size Size) Instruction {
-	return Instruction{
-		OpCode:   StoreImmOp(size),
-		Dst:      dst,
-		Offset:   offset,
-		Constant: value,
-	}
-}
-
-// StoreXAddOp returns the OpCode to atomically add a register to a value in memory.
-func StoreXAddOp(size Size) OpCode {
-	return OpCode(StXClass).SetMode(XAddMode).SetSize(size)
-}
-
-// StoreXAdd atomically adds src to *dst.
-func StoreXAdd(dst, src Register, size Size) Instruction {
-	return Instruction{
-		OpCode: StoreXAddOp(size),
-		Dst:    dst,
-		Src:    src,
-	}
-}
diff --git a/vendor/github.com/cilium/ebpf/asm/load_store_string.go b/vendor/github.com/cilium/ebpf/asm/load_store_string.go
deleted file mode 100644
index 76d29a075..000000000
--- a/vendor/github.com/cilium/ebpf/asm/load_store_string.go
+++ /dev/null
@@ -1,80 +0,0 @@
-// Code generated by "stringer -output load_store_string.go -type=Mode,Size"; DO NOT EDIT.
-
-package asm
-
-import "strconv"
-
-func _() {
-	// An "invalid array index" compiler error signifies that the constant values have changed.
-	// Re-run the stringer command to generate them again.
-	var x [1]struct{}
-	_ = x[InvalidMode-255]
-	_ = x[ImmMode-0]
-	_ = x[AbsMode-32]
-	_ = x[IndMode-64]
-	_ = x[MemMode-96]
-	_ = x[XAddMode-192]
-}
-
-const (
-	_Mode_name_0 = "ImmMode"
-	_Mode_name_1 = "AbsMode"
-	_Mode_name_2 = "IndMode"
-	_Mode_name_3 = "MemMode"
-	_Mode_name_4 = "XAddMode"
-	_Mode_name_5 = "InvalidMode"
-)
-
-func (i Mode) String() string {
-	switch {
-	case i == 0:
-		return _Mode_name_0
-	case i == 32:
-		return _Mode_name_1
-	case i == 64:
-		return _Mode_name_2
-	case i == 96:
-		return _Mode_name_3
-	case i == 192:
-		return _Mode_name_4
-	case i == 255:
-		return _Mode_name_5
-	default:
-		return "Mode(" + strconv.FormatInt(int64(i), 10) + ")"
-	}
-}
-func _() {
-	// An "invalid array index" compiler error signifies that the constant values have changed.
-	// Re-run the stringer command to generate them again.
-	var x [1]struct{}
-	_ = x[InvalidSize-255]
-	_ = x[DWord-24]
-	_ = x[Word-0]
-	_ = x[Half-8]
-	_ = x[Byte-16]
-}
-
-const (
-	_Size_name_0 = "Word"
-	_Size_name_1 = "Half"
-	_Size_name_2 = "Byte"
-	_Size_name_3 = "DWord"
-	_Size_name_4 = "InvalidSize"
-)
-
-func (i Size) String() string {
-	switch {
-	case i == 0:
-		return _Size_name_0
-	case i == 8:
-		return _Size_name_1
-	case i == 16:
-		return _Size_name_2
-	case i == 24:
-		return _Size_name_3
-	case i == 255:
-		return _Size_name_4
-	default:
-		return "Size(" + strconv.FormatInt(int64(i), 10) + ")"
-	}
-}
diff --git a/vendor/github.com/cilium/ebpf/asm/metadata.go b/vendor/github.com/cilium/ebpf/asm/metadata.go
deleted file mode 100644
index dd368a936..000000000
--- a/vendor/github.com/cilium/ebpf/asm/metadata.go
+++ /dev/null
@@ -1,80 +0,0 @@
-package asm
-
-// Metadata contains metadata about an instruction.
-type Metadata struct {
-	head *metaElement
-}
-
-type metaElement struct {
-	next       *metaElement
-	key, value interface{}
-}
-
-// Find the element containing key.
-//
-// Returns nil if there is no such element.
-func (m *Metadata) find(key interface{}) *metaElement {
-	for e := m.head; e != nil; e = e.next {
-		if e.key == key {
-			return e
-		}
-	}
-	return nil
-}
-
-// Remove an element from the linked list.
-//
-// Copies as many elements of the list as necessary to remove r, but doesn't
-// perform a full copy.
-func (m *Metadata) remove(r *metaElement) {
-	current := &m.head
-	for e := m.head; e != nil; e = e.next {
-		if e == r {
-			// We've found the element we want to remove.
-			*current = e.next
-
-			// No need to copy the tail.
-			return
-		}
-
-		// There is another element in front of the one we want to remove.
-		// We have to copy it to be able to change metaElement.next.
-		cpy := &metaElement{key: e.key, value: e.value}
-		*current = cpy
-		current = &cpy.next
-	}
-}
-
-// Set a key to a value.
-//
-// If value is nil, the key is removed. Avoids modifying old metadata by
-// copying if necessary.
-func (m *Metadata) Set(key, value interface{}) {
-	if e := m.find(key); e != nil {
-		if e.value == value {
-			// Key is present and the value is the same. Nothing to do.
-			return
-		}
-
-		// Key is present with a different value. Create a copy of the list
-		// which doesn't have the element in it.
-		m.remove(e)
-	}
-
-	// m.head is now a linked list that doesn't contain key.
-	if value == nil {
-		return
-	}
-
-	m.head = &metaElement{key: key, value: value, next: m.head}
-}
-
-// Get the value of a key.
-//
-// Returns nil if no value with the given key is present.
-func (m *Metadata) Get(key interface{}) interface{} {
-	if e := m.find(key); e != nil {
-		return e.value
-	}
-	return nil
-}
diff --git a/vendor/github.com/cilium/ebpf/asm/opcode.go b/vendor/github.com/cilium/ebpf/asm/opcode.go
deleted file mode 100644
index 9e3c30b0b..000000000
--- a/vendor/github.com/cilium/ebpf/asm/opcode.go
+++ /dev/null
@@ -1,271 +0,0 @@
-package asm
-
-import (
-	"fmt"
-	"strings"
-)
-
-//go:generate stringer -output opcode_string.go -type=Class
-
-// Class of operations
-//
-//	msb      lsb
-//	+---+--+---+
-//	|  ??  |CLS|
-//	+---+--+---+
-type Class uint8
-
-const classMask OpCode = 0x07
-
-const (
-	// LdClass loads immediate values into registers.
-	// Also used for non-standard load operations from cBPF.
-	LdClass Class = 0x00
-	// LdXClass loads memory into registers.
-	LdXClass Class = 0x01
-	// StClass stores immediate values to memory.
-	StClass Class = 0x02
-	// StXClass stores registers to memory.
-	StXClass Class = 0x03
-	// ALUClass describes arithmetic operators.
-	ALUClass Class = 0x04
-	// JumpClass describes jump operators.
-	JumpClass Class = 0x05
-	// Jump32Class describes jump operators with 32-bit comparisons.
-	// Requires kernel 5.1.
-	Jump32Class Class = 0x06
-	// ALU64Class describes arithmetic operators in 64-bit mode.
-	ALU64Class Class = 0x07
-)
-
-// IsLoad checks if this is either LdClass or LdXClass.
-func (cls Class) IsLoad() bool {
-	return cls == LdClass || cls == LdXClass
-}
-
-// IsStore checks if this is either StClass or StXClass.
-func (cls Class) IsStore() bool {
-	return cls == StClass || cls == StXClass
-}
-
-func (cls Class) isLoadOrStore() bool {
-	return cls.IsLoad() || cls.IsStore()
-}
-
-// IsALU checks if this is either ALUClass or ALU64Class.
-func (cls Class) IsALU() bool {
-	return cls == ALUClass || cls == ALU64Class
-}
-
-// IsJump checks if this is either JumpClass or Jump32Class.
-func (cls Class) IsJump() bool {
-	return cls == JumpClass || cls == Jump32Class
-}
-
-func (cls Class) isJumpOrALU() bool {
-	return cls.IsJump() || cls.IsALU()
-}
-
-// OpCode is a packed eBPF opcode.
-//
-// Its encoding is defined by a Class value:
-//
-//	msb      lsb
-//	+----+-+---+
-//	| ???? |CLS|
-//	+----+-+---+
-type OpCode uint8
-
-// InvalidOpCode is returned by setters on OpCode
-const InvalidOpCode OpCode = 0xff
-
-// rawInstructions returns the number of BPF instructions required
-// to encode this opcode.
-func (op OpCode) rawInstructions() int {
-	if op.IsDWordLoad() {
-		return 2
-	}
-	return 1
-}
-
-func (op OpCode) IsDWordLoad() bool {
-	return op == LoadImmOp(DWord)
-}
-
-// Class returns the class of operation.
-func (op OpCode) Class() Class {
-	return Class(op & classMask)
-}
-
-// Mode returns the mode for load and store operations.
-func (op OpCode) Mode() Mode {
-	if !op.Class().isLoadOrStore() {
-		return InvalidMode
-	}
-	return Mode(op & modeMask)
-}
-
-// Size returns the size for load and store operations.
-func (op OpCode) Size() Size {
-	if !op.Class().isLoadOrStore() {
-		return InvalidSize
-	}
-	return Size(op & sizeMask)
-}
-
-// Source returns the source for branch and ALU operations.
-func (op OpCode) Source() Source {
-	if !op.Class().isJumpOrALU() || op.ALUOp() == Swap {
-		return InvalidSource
-	}
-	return Source(op & sourceMask)
-}
-
-// ALUOp returns the ALUOp.
-func (op OpCode) ALUOp() ALUOp {
-	if !op.Class().IsALU() {
-		return InvalidALUOp
-	}
-	return ALUOp(op & aluMask)
-}
-
-// Endianness returns the Endianness for a byte swap instruction.
-func (op OpCode) Endianness() Endianness {
-	if op.ALUOp() != Swap {
-		return InvalidEndian
-	}
-	return Endianness(op & endianMask)
-}
-
-// JumpOp returns the JumpOp.
-// Returns InvalidJumpOp if it doesn't encode a jump.
-func (op OpCode) JumpOp() JumpOp {
-	if !op.Class().IsJump() {
-		return InvalidJumpOp
-	}
-
-	jumpOp := JumpOp(op & jumpMask)
-
-	// Some JumpOps are only supported by JumpClass, not Jump32Class.
-	if op.Class() == Jump32Class && (jumpOp == Exit || jumpOp == Call || jumpOp == Ja) {
-		return InvalidJumpOp
-	}
-
-	return jumpOp
-}
-
-// SetMode sets the mode on load and store operations.
-//
-// Returns InvalidOpCode if op is of the wrong class.
-func (op OpCode) SetMode(mode Mode) OpCode {
-	if !op.Class().isLoadOrStore() || !valid(OpCode(mode), modeMask) {
-		return InvalidOpCode
-	}
-	return (op & ^modeMask) | OpCode(mode)
-}
-
-// SetSize sets the size on load and store operations.
-//
-// Returns InvalidOpCode if op is of the wrong class.
-func (op OpCode) SetSize(size Size) OpCode {
-	if !op.Class().isLoadOrStore() || !valid(OpCode(size), sizeMask) {
-		return InvalidOpCode
-	}
-	return (op & ^sizeMask) | OpCode(size)
-}
-
-// SetSource sets the source on jump and ALU operations.
-//
-// Returns InvalidOpCode if op is of the wrong class.
-func (op OpCode) SetSource(source Source) OpCode {
-	if !op.Class().isJumpOrALU() || !valid(OpCode(source), sourceMask) {
-		return InvalidOpCode
-	}
-	return (op & ^sourceMask) | OpCode(source)
-}
-
-// SetALUOp sets the ALUOp on ALU operations.
-//
-// Returns InvalidOpCode if op is of the wrong class.
-func (op OpCode) SetALUOp(alu ALUOp) OpCode {
-	if !op.Class().IsALU() || !valid(OpCode(alu), aluMask) {
-		return InvalidOpCode
-	}
-	return (op & ^aluMask) | OpCode(alu)
-}
-
-// SetJumpOp sets the JumpOp on jump operations.
-//
-// Returns InvalidOpCode if op is of the wrong class.
-func (op OpCode) SetJumpOp(jump JumpOp) OpCode {
-	if !op.Class().IsJump() || !valid(OpCode(jump), jumpMask) {
-		return InvalidOpCode
-	}
-
-	newOp := (op & ^jumpMask) | OpCode(jump)
-
-	// Check newOp is legal.
-	if newOp.JumpOp() == InvalidJumpOp {
-		return InvalidOpCode
-	}
-
-	return newOp
-}
-
-func (op OpCode) String() string {
-	var f strings.Builder
-
-	switch class := op.Class(); {
-	case class.isLoadOrStore():
-		f.WriteString(strings.TrimSuffix(class.String(), "Class"))
-
-		mode := op.Mode()
-		f.WriteString(strings.TrimSuffix(mode.String(), "Mode"))
-
-		switch op.Size() {
-		case DWord:
-			f.WriteString("DW")
-		case Word:
-			f.WriteString("W")
-		case Half:
-			f.WriteString("H")
-		case Byte:
-			f.WriteString("B")
-		}
-
-	case class.IsALU():
-		f.WriteString(op.ALUOp().String())
-
-		if op.ALUOp() == Swap {
-			// Width for Endian is controlled by Constant
-			f.WriteString(op.Endianness().String())
-		} else {
-			if class == ALUClass {
-				f.WriteString("32")
-			}
-
-			f.WriteString(strings.TrimSuffix(op.Source().String(), "Source"))
-		}
-
-	case class.IsJump():
-		f.WriteString(op.JumpOp().String())
-
-		if class == Jump32Class {
-			f.WriteString("32")
-		}
-
-		if jop := op.JumpOp(); jop != Exit && jop != Call {
-			f.WriteString(strings.TrimSuffix(op.Source().String(), "Source"))
-		}
-
-	default:
-		fmt.Fprintf(&f, "OpCode(%#x)", uint8(op))
-	}
-
-	return f.String()
-}
-
-// valid returns true if all bits in value are covered by mask.
-func valid(value, mask OpCode) bool {
-	return value & ^mask == 0
-}
diff --git a/vendor/github.com/cilium/ebpf/asm/opcode_string.go b/vendor/github.com/cilium/ebpf/asm/opcode_string.go
deleted file mode 100644
index 58bc3e7e7..000000000
--- a/vendor/github.com/cilium/ebpf/asm/opcode_string.go
+++ /dev/null
@@ -1,30 +0,0 @@
-// Code generated by "stringer -output opcode_string.go -type=Class"; DO NOT EDIT.
-
-package asm
-
-import "strconv"
-
-func _() {
-	// An "invalid array index" compiler error signifies that the constant values have changed.
-	// Re-run the stringer command to generate them again.
-	var x [1]struct{}
-	_ = x[LdClass-0]
-	_ = x[LdXClass-1]
-	_ = x[StClass-2]
-	_ = x[StXClass-3]
-	_ = x[ALUClass-4]
-	_ = x[JumpClass-5]
-	_ = x[Jump32Class-6]
-	_ = x[ALU64Class-7]
-}
-
-const _Class_name = "LdClassLdXClassStClassStXClassALUClassJumpClassJump32ClassALU64Class"
-
-var _Class_index = [...]uint8{0, 7, 15, 22, 30, 38, 47, 58, 68}
-
-func (i Class) String() string {
-	if i >= Class(len(_Class_index)-1) {
-		return "Class(" + strconv.FormatInt(int64(i), 10) + ")"
-	}
-	return _Class_name[_Class_index[i]:_Class_index[i+1]]
-}
diff --git a/vendor/github.com/cilium/ebpf/asm/register.go b/vendor/github.com/cilium/ebpf/asm/register.go
deleted file mode 100644
index 457a3b8a8..000000000
--- a/vendor/github.com/cilium/ebpf/asm/register.go
+++ /dev/null
@@ -1,51 +0,0 @@
-package asm
-
-import (
-	"fmt"
-)
-
-// Register is the source or destination of most operations.
-type Register uint8
-
-// R0 contains return values.
-const R0 Register = 0
-
-// Registers for function arguments.
-const (
-	R1 Register = R0 + 1 + iota
-	R2
-	R3
-	R4
-	R5
-)
-
-// Callee saved registers preserved by function calls.
-const (
-	R6 Register = R5 + 1 + iota
-	R7
-	R8
-	R9
-)
-
-// Read-only frame pointer to access stack.
-const (
-	R10 Register = R9 + 1
-	RFP          = R10
-)
-
-// Pseudo registers used by 64bit loads and jumps
-const (
-	PseudoMapFD     = R1 // BPF_PSEUDO_MAP_FD
-	PseudoMapValue  = R2 // BPF_PSEUDO_MAP_VALUE
-	PseudoCall      = R1 // BPF_PSEUDO_CALL
-	PseudoFunc      = R4 // BPF_PSEUDO_FUNC
-	PseudoKfuncCall = R2 // BPF_PSEUDO_KFUNC_CALL
-)
-
-func (r Register) String() string {
-	v := uint8(r)
-	if v == 10 {
-		return "rfp"
-	}
-	return fmt.Sprintf("r%d", v)
-}
diff --git a/vendor/github.com/cilium/ebpf/attachtype_string.go b/vendor/github.com/cilium/ebpf/attachtype_string.go
deleted file mode 100644
index add2a3b5c..000000000
--- a/vendor/github.com/cilium/ebpf/attachtype_string.go
+++ /dev/null
@@ -1,66 +0,0 @@
-// Code generated by "stringer -type AttachType -trimprefix Attach"; DO NOT EDIT.
-
-package ebpf
-
-import "strconv"
-
-func _() {
-	// An "invalid array index" compiler error signifies that the constant values have changed.
-	// Re-run the stringer command to generate them again.
-	var x [1]struct{}
-	_ = x[AttachNone-0]
-	_ = x[AttachCGroupInetIngress-0]
-	_ = x[AttachCGroupInetEgress-1]
-	_ = x[AttachCGroupInetSockCreate-2]
-	_ = x[AttachCGroupSockOps-3]
-	_ = x[AttachSkSKBStreamParser-4]
-	_ = x[AttachSkSKBStreamVerdict-5]
-	_ = x[AttachCGroupDevice-6]
-	_ = x[AttachSkMsgVerdict-7]
-	_ = x[AttachCGroupInet4Bind-8]
-	_ = x[AttachCGroupInet6Bind-9]
-	_ = x[AttachCGroupInet4Connect-10]
-	_ = x[AttachCGroupInet6Connect-11]
-	_ = x[AttachCGroupInet4PostBind-12]
-	_ = x[AttachCGroupInet6PostBind-13]
-	_ = x[AttachCGroupUDP4Sendmsg-14]
-	_ = x[AttachCGroupUDP6Sendmsg-15]
-	_ = x[AttachLircMode2-16]
-	_ = x[AttachFlowDissector-17]
-	_ = x[AttachCGroupSysctl-18]
-	_ = x[AttachCGroupUDP4Recvmsg-19]
-	_ = x[AttachCGroupUDP6Recvmsg-20]
-	_ = x[AttachCGroupGetsockopt-21]
-	_ = x[AttachCGroupSetsockopt-22]
-	_ = x[AttachTraceRawTp-23]
-	_ = x[AttachTraceFEntry-24]
-	_ = x[AttachTraceFExit-25]
-	_ = x[AttachModifyReturn-26]
-	_ = x[AttachLSMMac-27]
-	_ = x[AttachTraceIter-28]
-	_ = x[AttachCgroupInet4GetPeername-29]
-	_ = x[AttachCgroupInet6GetPeername-30]
-	_ = x[AttachCgroupInet4GetSockname-31]
-	_ = x[AttachCgroupInet6GetSockname-32]
-	_ = x[AttachXDPDevMap-33]
-	_ = x[AttachCgroupInetSockRelease-34]
-	_ = x[AttachXDPCPUMap-35]
-	_ = x[AttachSkLookup-36]
-	_ = x[AttachXDP-37]
-	_ = x[AttachSkSKBVerdict-38]
-	_ = x[AttachSkReuseportSelect-39]
-	_ = x[AttachSkReuseportSelectOrMigrate-40]
-	_ = x[AttachPerfEvent-41]
-	_ = x[AttachTraceKprobeMulti-42]
-}
-
-const _AttachType_name = "NoneCGroupInetEgressCGroupInetSockCreateCGroupSockOpsSkSKBStreamParserSkSKBStreamVerdictCGroupDeviceSkMsgVerdictCGroupInet4BindCGroupInet6BindCGroupInet4ConnectCGroupInet6ConnectCGroupInet4PostBindCGroupInet6PostBindCGroupUDP4SendmsgCGroupUDP6SendmsgLircMode2FlowDissectorCGroupSysctlCGroupUDP4RecvmsgCGroupUDP6RecvmsgCGroupGetsockoptCGroupSetsockoptTraceRawTpTraceFEntryTraceFExitModifyReturnLSMMacTraceIterCgroupInet4GetPeernameCgroupInet6GetPeernameCgroupInet4GetSocknameCgroupInet6GetSocknameXDPDevMapCgroupInetSockReleaseXDPCPUMapSkLookupXDPSkSKBVerdictSkReuseportSelectSkReuseportSelectOrMigratePerfEventTraceKprobeMulti"
-
-var _AttachType_index = [...]uint16{0, 4, 20, 40, 53, 70, 88, 100, 112, 127, 142, 160, 178, 197, 216, 233, 250, 259, 272, 284, 301, 318, 334, 350, 360, 371, 381, 393, 399, 408, 430, 452, 474, 496, 505, 526, 535, 543, 546, 558, 575, 601, 610, 626}
-
-func (i AttachType) String() string {
-	if i >= AttachType(len(_AttachType_index)-1) {
-		return "AttachType(" + strconv.FormatInt(int64(i), 10) + ")"
-	}
-	return _AttachType_name[_AttachType_index[i]:_AttachType_index[i+1]]
-}
diff --git a/vendor/github.com/cilium/ebpf/btf/btf.go b/vendor/github.com/cilium/ebpf/btf/btf.go
deleted file mode 100644
index 86eb7d681..000000000
--- a/vendor/github.com/cilium/ebpf/btf/btf.go
+++ /dev/null
@@ -1,869 +0,0 @@
-package btf
-
-import (
-	"bufio"
-	"debug/elf"
-	"encoding/binary"
-	"errors"
-	"fmt"
-	"io"
-	"math"
-	"os"
-	"reflect"
-	"sync"
-
-	"github.com/cilium/ebpf/internal"
-	"github.com/cilium/ebpf/internal/sys"
-	"github.com/cilium/ebpf/internal/unix"
-)
-
-const btfMagic = 0xeB9F
-
-// Errors returned by BTF functions.
-var (
-	ErrNotSupported    = internal.ErrNotSupported
-	ErrNotFound        = errors.New("not found")
-	ErrNoExtendedInfo  = errors.New("no extended info")
-	ErrMultipleMatches = errors.New("multiple matching types")
-)
-
-// ID represents the unique ID of a BTF object.
-type ID = sys.BTFID
-
-// Spec allows querying a set of Types and loading the set into the
-// kernel.
-type Spec struct {
-	// All types contained by the spec, not including types from the base in
-	// case the spec was parsed from split BTF.
-	types []Type
-
-	// Type IDs indexed by type.
-	typeIDs map[Type]TypeID
-
-	// The ID of the first type in types.
-	firstTypeID TypeID
-
-	// Types indexed by essential name.
-	// Includes all struct flavors and types with the same name.
-	namedTypes map[essentialName][]Type
-
-	// String table from ELF, may be nil.
-	strings *stringTable
-
-	// Byte order of the ELF we decoded the spec from, may be nil.
-	byteOrder binary.ByteOrder
-}
-
-var btfHeaderLen = binary.Size(&btfHeader{})
-
-type btfHeader struct {
-	Magic   uint16
-	Version uint8
-	Flags   uint8
-	HdrLen  uint32
-
-	TypeOff   uint32
-	TypeLen   uint32
-	StringOff uint32
-	StringLen uint32
-}
-
-// typeStart returns the offset from the beginning of the .BTF section
-// to the start of its type entries.
-func (h *btfHeader) typeStart() int64 {
-	return int64(h.HdrLen + h.TypeOff)
-}
-
-// stringStart returns the offset from the beginning of the .BTF section
-// to the start of its string table.
-func (h *btfHeader) stringStart() int64 {
-	return int64(h.HdrLen + h.StringOff)
-}
-
-// newSpec creates a Spec containing only Void.
-func newSpec() *Spec {
-	return &Spec{
-		[]Type{(*Void)(nil)},
-		map[Type]TypeID{(*Void)(nil): 0},
-		0,
-		make(map[essentialName][]Type),
-		nil,
-		nil,
-	}
-}
-
-// LoadSpec opens file and calls LoadSpecFromReader on it.
-func LoadSpec(file string) (*Spec, error) {
-	fh, err := os.Open(file)
-	if err != nil {
-		return nil, err
-	}
-	defer fh.Close()
-
-	return LoadSpecFromReader(fh)
-}
-
-// LoadSpecFromReader reads from an ELF or a raw BTF blob.
-//
-// Returns ErrNotFound if reading from an ELF which contains no BTF. ExtInfos
-// may be nil.
-func LoadSpecFromReader(rd io.ReaderAt) (*Spec, error) {
-	file, err := internal.NewSafeELFFile(rd)
-	if err != nil {
-		if bo := guessRawBTFByteOrder(rd); bo != nil {
-			return loadRawSpec(io.NewSectionReader(rd, 0, math.MaxInt64), bo, nil)
-		}
-
-		return nil, err
-	}
-
-	return loadSpecFromELF(file)
-}
-
-// LoadSpecAndExtInfosFromReader reads from an ELF.
-//
-// ExtInfos may be nil if the ELF doesn't contain section metadata.
-// Returns ErrNotFound if the ELF contains no BTF.
-func LoadSpecAndExtInfosFromReader(rd io.ReaderAt) (*Spec, *ExtInfos, error) {
-	file, err := internal.NewSafeELFFile(rd)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	spec, err := loadSpecFromELF(file)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	extInfos, err := loadExtInfosFromELF(file, spec)
-	if err != nil && !errors.Is(err, ErrNotFound) {
-		return nil, nil, err
-	}
-
-	return spec, extInfos, nil
-}
-
-// symbolOffsets extracts all symbols offsets from an ELF and indexes them by
-// section and variable name.
-//
-// References to variables in BTF data sections carry unsigned 32-bit offsets.
-// Some ELF symbols (e.g. in vmlinux) may point to virtual memory that is well
-// beyond this range. Since these symbols cannot be described by BTF info,
-// ignore them here.
-func symbolOffsets(file *internal.SafeELFFile) (map[symbol]uint32, error) {
-	symbols, err := file.Symbols()
-	if err != nil {
-		return nil, fmt.Errorf("can't read symbols: %v", err)
-	}
-
-	offsets := make(map[symbol]uint32)
-	for _, sym := range symbols {
-		if idx := sym.Section; idx >= elf.SHN_LORESERVE && idx <= elf.SHN_HIRESERVE {
-			// Ignore things like SHN_ABS
-			continue
-		}
-
-		if sym.Value > math.MaxUint32 {
-			// VarSecinfo offset is u32, cannot reference symbols in higher regions.
-			continue
-		}
-
-		if int(sym.Section) >= len(file.Sections) {
-			return nil, fmt.Errorf("symbol %s: invalid section %d", sym.Name, sym.Section)
-		}
-
-		secName := file.Sections[sym.Section].Name
-		offsets[symbol{secName, sym.Name}] = uint32(sym.Value)
-	}
-
-	return offsets, nil
-}
-
-func loadSpecFromELF(file *internal.SafeELFFile) (*Spec, error) {
-	var (
-		btfSection   *elf.Section
-		sectionSizes = make(map[string]uint32)
-	)
-
-	for _, sec := range file.Sections {
-		switch sec.Name {
-		case ".BTF":
-			btfSection = sec
-		default:
-			if sec.Type != elf.SHT_PROGBITS && sec.Type != elf.SHT_NOBITS {
-				break
-			}
-
-			if sec.Size > math.MaxUint32 {
-				return nil, fmt.Errorf("section %s exceeds maximum size", sec.Name)
-			}
-
-			sectionSizes[sec.Name] = uint32(sec.Size)
-		}
-	}
-
-	if btfSection == nil {
-		return nil, fmt.Errorf("btf: %w", ErrNotFound)
-	}
-
-	offsets, err := symbolOffsets(file)
-	if err != nil {
-		return nil, err
-	}
-
-	if btfSection.ReaderAt == nil {
-		return nil, fmt.Errorf("compressed BTF is not supported")
-	}
-
-	spec, err := loadRawSpec(btfSection.ReaderAt, file.ByteOrder, nil)
-	if err != nil {
-		return nil, err
-	}
-
-	err = fixupDatasec(spec.types, sectionSizes, offsets)
-	if err != nil {
-		return nil, err
-	}
-
-	return spec, nil
-}
-
-func loadRawSpec(btf io.ReaderAt, bo binary.ByteOrder, base *Spec) (*Spec, error) {
-	var (
-		baseStrings *stringTable
-		firstTypeID TypeID
-		err         error
-	)
-
-	if base != nil {
-		if base.firstTypeID != 0 {
-			return nil, fmt.Errorf("can't use split BTF as base")
-		}
-
-		if base.strings == nil {
-			return nil, fmt.Errorf("parse split BTF: base must be loaded from an ELF")
-		}
-
-		baseStrings = base.strings
-
-		firstTypeID, err = base.nextTypeID()
-		if err != nil {
-			return nil, err
-		}
-	}
-
-	rawTypes, rawStrings, err := parseBTF(btf, bo, baseStrings)
-	if err != nil {
-		return nil, err
-	}
-
-	types, err := inflateRawTypes(rawTypes, rawStrings, base)
-	if err != nil {
-		return nil, err
-	}
-
-	typeIDs, typesByName := indexTypes(types, firstTypeID)
-
-	return &Spec{
-		namedTypes:  typesByName,
-		typeIDs:     typeIDs,
-		types:       types,
-		firstTypeID: firstTypeID,
-		strings:     rawStrings,
-		byteOrder:   bo,
-	}, nil
-}
-
-func indexTypes(types []Type, firstTypeID TypeID) (map[Type]TypeID, map[essentialName][]Type) {
-	namedTypes := 0
-	for _, typ := range types {
-		if typ.TypeName() != "" {
-			// Do a pre-pass to figure out how big types by name has to be.
-			// Most types have unique names, so it's OK to ignore essentialName
-			// here.
-			namedTypes++
-		}
-	}
-
-	typeIDs := make(map[Type]TypeID, len(types))
-	typesByName := make(map[essentialName][]Type, namedTypes)
-
-	for i, typ := range types {
-		if name := newEssentialName(typ.TypeName()); name != "" {
-			typesByName[name] = append(typesByName[name], typ)
-		}
-		typeIDs[typ] = firstTypeID + TypeID(i)
-	}
-
-	return typeIDs, typesByName
-}
-
-// LoadKernelSpec returns the current kernel's BTF information.
-//
-// Defaults to /sys/kernel/btf/vmlinux and falls back to scanning the file system
-// for vmlinux ELFs. Returns an error wrapping ErrNotSupported if BTF is not enabled.
-func LoadKernelSpec() (*Spec, error) {
-	spec, _, err := kernelSpec()
-	if err != nil {
-		return nil, err
-	}
-	return spec.Copy(), nil
-}
-
-var kernelBTF struct {
-	sync.RWMutex
-	spec *Spec
-	// True if the spec was read from an ELF instead of raw BTF in /sys.
-	fallback bool
-}
-
-// FlushKernelSpec removes any cached kernel type information.
-func FlushKernelSpec() {
-	kernelBTF.Lock()
-	defer kernelBTF.Unlock()
-
-	kernelBTF.spec, kernelBTF.fallback = nil, false
-}
-
-func kernelSpec() (*Spec, bool, error) {
-	kernelBTF.RLock()
-	spec, fallback := kernelBTF.spec, kernelBTF.fallback
-	kernelBTF.RUnlock()
-
-	if spec == nil {
-		kernelBTF.Lock()
-		defer kernelBTF.Unlock()
-
-		spec, fallback = kernelBTF.spec, kernelBTF.fallback
-	}
-
-	if spec != nil {
-		return spec, fallback, nil
-	}
-
-	spec, fallback, err := loadKernelSpec()
-	if err != nil {
-		return nil, false, err
-	}
-
-	kernelBTF.spec, kernelBTF.fallback = spec, fallback
-	return spec, fallback, nil
-}
-
-func loadKernelSpec() (_ *Spec, fallback bool, _ error) {
-	fh, err := os.Open("/sys/kernel/btf/vmlinux")
-	if err == nil {
-		defer fh.Close()
-
-		spec, err := loadRawSpec(fh, internal.NativeEndian, nil)
-		return spec, false, err
-	}
-
-	file, err := findVMLinux()
-	if err != nil {
-		return nil, false, err
-	}
-	defer file.Close()
-
-	spec, err := loadSpecFromELF(file)
-	return spec, true, err
-}
-
-// findVMLinux scans multiple well-known paths for vmlinux kernel images.
-func findVMLinux() (*internal.SafeELFFile, error) {
-	release, err := internal.KernelRelease()
-	if err != nil {
-		return nil, err
-	}
-
-	// use same list of locations as libbpf
-	// https://github.com/libbpf/libbpf/blob/9a3a42608dbe3731256a5682a125ac1e23bced8f/src/btf.c#L3114-L3122
-	locations := []string{
-		"/boot/vmlinux-%s",
-		"/lib/modules/%s/vmlinux-%[1]s",
-		"/lib/modules/%s/build/vmlinux",
-		"/usr/lib/modules/%s/kernel/vmlinux",
-		"/usr/lib/debug/boot/vmlinux-%s",
-		"/usr/lib/debug/boot/vmlinux-%s.debug",
-		"/usr/lib/debug/lib/modules/%s/vmlinux",
-	}
-
-	for _, loc := range locations {
-		file, err := internal.OpenSafeELFFile(fmt.Sprintf(loc, release))
-		if errors.Is(err, os.ErrNotExist) {
-			continue
-		}
-		return file, err
-	}
-
-	return nil, fmt.Errorf("no BTF found for kernel version %s: %w", release, internal.ErrNotSupported)
-}
-
-// parseBTFHeader parses the header of the .BTF section.
-func parseBTFHeader(r io.Reader, bo binary.ByteOrder) (*btfHeader, error) {
-	var header btfHeader
-	if err := binary.Read(r, bo, &header); err != nil {
-		return nil, fmt.Errorf("can't read header: %v", err)
-	}
-
-	if header.Magic != btfMagic {
-		return nil, fmt.Errorf("incorrect magic value %v", header.Magic)
-	}
-
-	if header.Version != 1 {
-		return nil, fmt.Errorf("unexpected version %v", header.Version)
-	}
-
-	if header.Flags != 0 {
-		return nil, fmt.Errorf("unsupported flags %v", header.Flags)
-	}
-
-	remainder := int64(header.HdrLen) - int64(binary.Size(&header))
-	if remainder < 0 {
-		return nil, errors.New("header length shorter than btfHeader size")
-	}
-
-	if _, err := io.CopyN(internal.DiscardZeroes{}, r, remainder); err != nil {
-		return nil, fmt.Errorf("header padding: %v", err)
-	}
-
-	return &header, nil
-}
-
-func guessRawBTFByteOrder(r io.ReaderAt) binary.ByteOrder {
-	buf := new(bufio.Reader)
-	for _, bo := range []binary.ByteOrder{
-		binary.LittleEndian,
-		binary.BigEndian,
-	} {
-		buf.Reset(io.NewSectionReader(r, 0, math.MaxInt64))
-		if _, err := parseBTFHeader(buf, bo); err == nil {
-			return bo
-		}
-	}
-
-	return nil
-}
-
-// parseBTF reads a .BTF section into memory and parses it into a list of
-// raw types and a string table.
-func parseBTF(btf io.ReaderAt, bo binary.ByteOrder, baseStrings *stringTable) ([]rawType, *stringTable, error) {
-	buf := internal.NewBufferedSectionReader(btf, 0, math.MaxInt64)
-	header, err := parseBTFHeader(buf, bo)
-	if err != nil {
-		return nil, nil, fmt.Errorf("parsing .BTF header: %v", err)
-	}
-
-	rawStrings, err := readStringTable(io.NewSectionReader(btf, header.stringStart(), int64(header.StringLen)),
-		baseStrings)
-	if err != nil {
-		return nil, nil, fmt.Errorf("can't read type names: %w", err)
-	}
-
-	buf.Reset(io.NewSectionReader(btf, header.typeStart(), int64(header.TypeLen)))
-	rawTypes, err := readTypes(buf, bo, header.TypeLen)
-	if err != nil {
-		return nil, nil, fmt.Errorf("can't read types: %w", err)
-	}
-
-	return rawTypes, rawStrings, nil
-}
-
-type symbol struct {
-	section string
-	name    string
-}
-
-// fixupDatasec attempts to patch up missing info in Datasecs and its members by
-// supplementing them with information from the ELF headers and symbol table.
-func fixupDatasec(types []Type, sectionSizes map[string]uint32, offsets map[symbol]uint32) error {
-	for _, typ := range types {
-		ds, ok := typ.(*Datasec)
-		if !ok {
-			continue
-		}
-
-		name := ds.Name
-
-		// Some Datasecs are virtual and don't have corresponding ELF sections.
-		switch name {
-		case ".ksyms":
-			// .ksyms describes forward declarations of kfunc signatures.
-			// Nothing to fix up, all sizes and offsets are 0.
-			for _, vsi := range ds.Vars {
-				_, ok := vsi.Type.(*Func)
-				if !ok {
-					// Only Funcs are supported in the .ksyms Datasec.
-					return fmt.Errorf("data section %s: expected *btf.Func, not %T: %w", name, vsi.Type, ErrNotSupported)
-				}
-			}
-
-			continue
-		case ".kconfig":
-			// .kconfig has a size of 0 and has all members' offsets set to 0.
-			// Fix up all offsets and set the Datasec's size.
-			if err := fixupDatasecLayout(ds); err != nil {
-				return err
-			}
-
-			// Fix up extern to global linkage to avoid a BTF verifier error.
-			for _, vsi := range ds.Vars {
-				vsi.Type.(*Var).Linkage = GlobalVar
-			}
-
-			continue
-		}
-
-		if ds.Size != 0 {
-			continue
-		}
-
-		ds.Size, ok = sectionSizes[name]
-		if !ok {
-			return fmt.Errorf("data section %s: missing size", name)
-		}
-
-		for i := range ds.Vars {
-			symName := ds.Vars[i].Type.TypeName()
-			ds.Vars[i].Offset, ok = offsets[symbol{name, symName}]
-			if !ok {
-				return fmt.Errorf("data section %s: missing offset for symbol %s", name, symName)
-			}
-		}
-	}
-
-	return nil
-}
-
-// fixupDatasecLayout populates ds.Vars[].Offset according to var sizes and
-// alignment. Calculate and set ds.Size.
-func fixupDatasecLayout(ds *Datasec) error {
-	var off uint32
-
-	for i, vsi := range ds.Vars {
-		v, ok := vsi.Type.(*Var)
-		if !ok {
-			return fmt.Errorf("member %d: unsupported type %T", i, vsi.Type)
-		}
-
-		size, err := Sizeof(v.Type)
-		if err != nil {
-			return fmt.Errorf("variable %s: getting size: %w", v.Name, err)
-		}
-		align, err := alignof(v.Type)
-		if err != nil {
-			return fmt.Errorf("variable %s: getting alignment: %w", v.Name, err)
-		}
-
-		// Align the current member based on the offset of the end of the previous
-		// member and the alignment of the current member.
-		off = internal.Align(off, uint32(align))
-
-		ds.Vars[i].Offset = off
-
-		off += uint32(size)
-	}
-
-	ds.Size = off
-
-	return nil
-}
-
-// Copy creates a copy of Spec.
-func (s *Spec) Copy() *Spec {
-	types := copyTypes(s.types, nil)
-	typeIDs, typesByName := indexTypes(types, s.firstTypeID)
-
-	// NB: Other parts of spec are not copied since they are immutable.
-	return &Spec{
-		types,
-		typeIDs,
-		s.firstTypeID,
-		typesByName,
-		s.strings,
-		s.byteOrder,
-	}
-}
-
-type sliceWriter []byte
-
-func (sw sliceWriter) Write(p []byte) (int, error) {
-	if len(p) != len(sw) {
-		return 0, errors.New("size doesn't match")
-	}
-
-	return copy(sw, p), nil
-}
-
-// nextTypeID returns the next unallocated type ID or an error if there are no
-// more type IDs.
-func (s *Spec) nextTypeID() (TypeID, error) {
-	id := s.firstTypeID + TypeID(len(s.types))
-	if id < s.firstTypeID {
-		return 0, fmt.Errorf("no more type IDs")
-	}
-	return id, nil
-}
-
-// TypeByID returns the BTF Type with the given type ID.
-//
-// Returns an error wrapping ErrNotFound if a Type with the given ID
-// does not exist in the Spec.
-func (s *Spec) TypeByID(id TypeID) (Type, error) {
-	if id < s.firstTypeID {
-		return nil, fmt.Errorf("look up type with ID %d (first ID is %d): %w", id, s.firstTypeID, ErrNotFound)
-	}
-
-	index := int(id - s.firstTypeID)
-	if index >= len(s.types) {
-		return nil, fmt.Errorf("look up type with ID %d: %w", id, ErrNotFound)
-	}
-
-	return s.types[index], nil
-}
-
-// TypeID returns the ID for a given Type.
-//
-// Returns an error wrapping ErrNoFound if the type isn't part of the Spec.
-func (s *Spec) TypeID(typ Type) (TypeID, error) {
-	if _, ok := typ.(*Void); ok {
-		// Equality is weird for void, since it is a zero sized type.
-		return 0, nil
-	}
-
-	id, ok := s.typeIDs[typ]
-	if !ok {
-		return 0, fmt.Errorf("no ID for type %s: %w", typ, ErrNotFound)
-	}
-
-	return id, nil
-}
-
-// AnyTypesByName returns a list of BTF Types with the given name.
-//
-// If the BTF blob describes multiple compilation units like vmlinux, multiple
-// Types with the same name and kind can exist, but might not describe the same
-// data structure.
-//
-// Returns an error wrapping ErrNotFound if no matching Type exists in the Spec.
-func (s *Spec) AnyTypesByName(name string) ([]Type, error) {
-	types := s.namedTypes[newEssentialName(name)]
-	if len(types) == 0 {
-		return nil, fmt.Errorf("type name %s: %w", name, ErrNotFound)
-	}
-
-	// Return a copy to prevent changes to namedTypes.
-	result := make([]Type, 0, len(types))
-	for _, t := range types {
-		// Match against the full name, not just the essential one
-		// in case the type being looked up is a struct flavor.
-		if t.TypeName() == name {
-			result = append(result, t)
-		}
-	}
-	return result, nil
-}
-
-// AnyTypeByName returns a Type with the given name.
-//
-// Returns an error if multiple types of that name exist.
-func (s *Spec) AnyTypeByName(name string) (Type, error) {
-	types, err := s.AnyTypesByName(name)
-	if err != nil {
-		return nil, err
-	}
-
-	if len(types) > 1 {
-		return nil, fmt.Errorf("found multiple types: %v", types)
-	}
-
-	return types[0], nil
-}
-
-// TypeByName searches for a Type with a specific name. Since multiple Types
-// with the same name can exist, the parameter typ is taken to narrow down the
-// search in case of a clash.
-//
-// typ must be a non-nil pointer to an implementation of a Type. On success, the
-// address of the found Type will be copied to typ.
-//
-// Returns an error wrapping ErrNotFound if no matching Type exists in the Spec.
-// Returns an error wrapping ErrMultipleTypes if multiple candidates are found.
-func (s *Spec) TypeByName(name string, typ interface{}) error {
-	typeInterface := reflect.TypeOf((*Type)(nil)).Elem()
-
-	// typ may be **T or *Type
-	typValue := reflect.ValueOf(typ)
-	if typValue.Kind() != reflect.Ptr {
-		return fmt.Errorf("%T is not a pointer", typ)
-	}
-
-	typPtr := typValue.Elem()
-	if !typPtr.CanSet() {
-		return fmt.Errorf("%T cannot be set", typ)
-	}
-
-	wanted := typPtr.Type()
-	if wanted == typeInterface {
-		// This is *Type. Unwrap the value's type.
-		wanted = typPtr.Elem().Type()
-	}
-
-	if !wanted.AssignableTo(typeInterface) {
-		return fmt.Errorf("%T does not satisfy Type interface", typ)
-	}
-
-	types, err := s.AnyTypesByName(name)
-	if err != nil {
-		return err
-	}
-
-	var candidate Type
-	for _, typ := range types {
-		if reflect.TypeOf(typ) != wanted {
-			continue
-		}
-
-		if candidate != nil {
-			return fmt.Errorf("type %s(%T): %w", name, typ, ErrMultipleMatches)
-		}
-
-		candidate = typ
-	}
-
-	if candidate == nil {
-		return fmt.Errorf("%s %s: %w", wanted, name, ErrNotFound)
-	}
-
-	typPtr.Set(reflect.ValueOf(candidate))
-
-	return nil
-}
-
-// LoadSplitSpecFromReader loads split BTF from a reader.
-//
-// Types from base are used to resolve references in the split BTF.
-// The returned Spec only contains types from the split BTF, not from the base.
-func LoadSplitSpecFromReader(r io.ReaderAt, base *Spec) (*Spec, error) {
-	return loadRawSpec(r, internal.NativeEndian, base)
-}
-
-// TypesIterator iterates over types of a given spec.
-type TypesIterator struct {
-	types []Type
-	index int
-	// The last visited type in the spec.
-	Type Type
-}
-
-// Iterate returns the types iterator.
-func (s *Spec) Iterate() *TypesIterator {
-	// We share the backing array of types with the Spec. This is safe since
-	// we don't allow deletion or shuffling of types.
-	return &TypesIterator{types: s.types, index: 0}
-}
-
-// Next returns true as long as there are any remaining types.
-func (iter *TypesIterator) Next() bool {
-	if len(iter.types) <= iter.index {
-		return false
-	}
-
-	iter.Type = iter.types[iter.index]
-	iter.index++
-	return true
-}
-
-// haveBTF attempts to load a BTF blob containing an Int. It should pass on any
-// kernel that supports BPF_BTF_LOAD.
-var haveBTF = internal.NewFeatureTest("BTF", "4.18", func() error {
-	// 0-length anonymous integer
-	err := probeBTF(&Int{})
-	if errors.Is(err, unix.EINVAL) || errors.Is(err, unix.EPERM) {
-		return internal.ErrNotSupported
-	}
-	return err
-})
-
-// haveMapBTF attempts to load a minimal BTF blob containing a Var. It is
-// used as a proxy for .bss, .data and .rodata map support, which generally
-// come with a Var and Datasec. These were introduced in Linux 5.2.
-var haveMapBTF = internal.NewFeatureTest("Map BTF (Var/Datasec)", "5.2", func() error {
-	if err := haveBTF(); err != nil {
-		return err
-	}
-
-	v := &Var{
-		Name: "a",
-		Type: &Pointer{(*Void)(nil)},
-	}
-
-	err := probeBTF(v)
-	if errors.Is(err, unix.EINVAL) || errors.Is(err, unix.EPERM) {
-		// Treat both EINVAL and EPERM as not supported: creating the map may still
-		// succeed without Btf* attrs.
-		return internal.ErrNotSupported
-	}
-	return err
-})
-
-// haveProgBTF attempts to load a BTF blob containing a Func and FuncProto. It
-// is used as a proxy for ext_info (func_info) support, which depends on
-// Func(Proto) by definition.
-var haveProgBTF = internal.NewFeatureTest("Program BTF (func/line_info)", "5.0", func() error {
-	if err := haveBTF(); err != nil {
-		return err
-	}
-
-	fn := &Func{
-		Name: "a",
-		Type: &FuncProto{Return: (*Void)(nil)},
-	}
-
-	err := probeBTF(fn)
-	if errors.Is(err, unix.EINVAL) || errors.Is(err, unix.EPERM) {
-		return internal.ErrNotSupported
-	}
-	return err
-})
-
-var haveFuncLinkage = internal.NewFeatureTest("BTF func linkage", "5.6", func() error {
-	if err := haveProgBTF(); err != nil {
-		return err
-	}
-
-	fn := &Func{
-		Name:    "a",
-		Type:    &FuncProto{Return: (*Void)(nil)},
-		Linkage: GlobalFunc,
-	}
-
-	err := probeBTF(fn)
-	if errors.Is(err, unix.EINVAL) {
-		return internal.ErrNotSupported
-	}
-	return err
-})
-
-func probeBTF(typ Type) error {
-	b, err := NewBuilder([]Type{typ})
-	if err != nil {
-		return err
-	}
-
-	buf, err := b.Marshal(nil, nil)
-	if err != nil {
-		return err
-	}
-
-	fd, err := sys.BtfLoad(&sys.BtfLoadAttr{
-		Btf:     sys.NewSlicePointer(buf),
-		BtfSize: uint32(len(buf)),
-	})
-
-	if err == nil {
-		fd.Close()
-	}
-
-	return err
-}
diff --git a/vendor/github.com/cilium/ebpf/btf/btf_types.go b/vendor/github.com/cilium/ebpf/btf/btf_types.go
deleted file mode 100644
index a253b7c9b..000000000
--- a/vendor/github.com/cilium/ebpf/btf/btf_types.go
+++ /dev/null
@@ -1,371 +0,0 @@
-package btf
-
-import (
-	"encoding/binary"
-	"fmt"
-	"io"
-	"unsafe"
-)
-
-//go:generate stringer -linecomment -output=btf_types_string.go -type=FuncLinkage,VarLinkage,btfKind
-
-// btfKind describes a Type.
-type btfKind uint8
-
-// Equivalents of the BTF_KIND_* constants.
-const (
-	kindUnknown  btfKind = iota // Unknown
-	kindInt                     // Int
-	kindPointer                 // Pointer
-	kindArray                   // Array
-	kindStruct                  // Struct
-	kindUnion                   // Union
-	kindEnum                    // Enum
-	kindForward                 // Forward
-	kindTypedef                 // Typedef
-	kindVolatile                // Volatile
-	kindConst                   // Const
-	kindRestrict                // Restrict
-	// Added ~4.20
-	kindFunc      // Func
-	kindFuncProto // FuncProto
-	// Added ~5.1
-	kindVar     // Var
-	kindDatasec // Datasec
-	// Added ~5.13
-	kindFloat // Float
-	// Added 5.16
-	kindDeclTag // DeclTag
-	kindTypeTag // TypeTag
-	// Added 6.0
-	kindEnum64 // Enum64
-)
-
-// FuncLinkage describes BTF function linkage metadata.
-type FuncLinkage int
-
-// Equivalent of enum btf_func_linkage.
-const (
-	StaticFunc FuncLinkage = iota // static
-	GlobalFunc                    // global
-	ExternFunc                    // extern
-)
-
-// VarLinkage describes BTF variable linkage metadata.
-type VarLinkage int
-
-const (
-	StaticVar VarLinkage = iota // static
-	GlobalVar                   // global
-	ExternVar                   // extern
-)
-
-const (
-	btfTypeKindShift     = 24
-	btfTypeKindLen       = 5
-	btfTypeVlenShift     = 0
-	btfTypeVlenMask      = 16
-	btfTypeKindFlagShift = 31
-	btfTypeKindFlagMask  = 1
-)
-
-var btfTypeLen = binary.Size(btfType{})
-
-// btfType is equivalent to struct btf_type in Documentation/bpf/btf.rst.
-type btfType struct {
-	NameOff uint32
-	/* "info" bits arrangement
-	 * bits  0-15: vlen (e.g. # of struct's members), linkage
-	 * bits 16-23: unused
-	 * bits 24-28: kind (e.g. int, ptr, array...etc)
-	 * bits 29-30: unused
-	 * bit     31: kind_flag, currently used by
-	 *             struct, union and fwd
-	 */
-	Info uint32
-	/* "size" is used by INT, ENUM, STRUCT and UNION.
-	 * "size" tells the size of the type it is describing.
-	 *
-	 * "type" is used by PTR, TYPEDEF, VOLATILE, CONST, RESTRICT,
-	 * FUNC and FUNC_PROTO.
-	 * "type" is a type_id referring to another type.
-	 */
-	SizeType uint32
-}
-
-func mask(len uint32) uint32 {
-	return (1 << len) - 1
-}
-
-func readBits(value, len, shift uint32) uint32 {
-	return (value >> shift) & mask(len)
-}
-
-func writeBits(value, len, shift, new uint32) uint32 {
-	value &^= mask(len) << shift
-	value |= (new & mask(len)) << shift
-	return value
-}
-
-func (bt *btfType) info(len, shift uint32) uint32 {
-	return readBits(bt.Info, len, shift)
-}
-
-func (bt *btfType) setInfo(value, len, shift uint32) {
-	bt.Info = writeBits(bt.Info, len, shift, value)
-}
-
-func (bt *btfType) Kind() btfKind {
-	return btfKind(bt.info(btfTypeKindLen, btfTypeKindShift))
-}
-
-func (bt *btfType) SetKind(kind btfKind) {
-	bt.setInfo(uint32(kind), btfTypeKindLen, btfTypeKindShift)
-}
-
-func (bt *btfType) Vlen() int {
-	return int(bt.info(btfTypeVlenMask, btfTypeVlenShift))
-}
-
-func (bt *btfType) SetVlen(vlen int) {
-	bt.setInfo(uint32(vlen), btfTypeVlenMask, btfTypeVlenShift)
-}
-
-func (bt *btfType) kindFlagBool() bool {
-	return bt.info(btfTypeKindFlagMask, btfTypeKindFlagShift) == 1
-}
-
-func (bt *btfType) setKindFlagBool(set bool) {
-	var value uint32
-	if set {
-		value = 1
-	}
-	bt.setInfo(value, btfTypeKindFlagMask, btfTypeKindFlagShift)
-}
-
-// Bitfield returns true if the struct or union contain a bitfield.
-func (bt *btfType) Bitfield() bool {
-	return bt.kindFlagBool()
-}
-
-func (bt *btfType) SetBitfield(isBitfield bool) {
-	bt.setKindFlagBool(isBitfield)
-}
-
-func (bt *btfType) FwdKind() FwdKind {
-	return FwdKind(bt.info(btfTypeKindFlagMask, btfTypeKindFlagShift))
-}
-
-func (bt *btfType) SetFwdKind(kind FwdKind) {
-	bt.setInfo(uint32(kind), btfTypeKindFlagMask, btfTypeKindFlagShift)
-}
-
-func (bt *btfType) Signed() bool {
-	return bt.kindFlagBool()
-}
-
-func (bt *btfType) SetSigned(signed bool) {
-	bt.setKindFlagBool(signed)
-}
-
-func (bt *btfType) Linkage() FuncLinkage {
-	return FuncLinkage(bt.info(btfTypeVlenMask, btfTypeVlenShift))
-}
-
-func (bt *btfType) SetLinkage(linkage FuncLinkage) {
-	bt.setInfo(uint32(linkage), btfTypeVlenMask, btfTypeVlenShift)
-}
-
-func (bt *btfType) Type() TypeID {
-	// TODO: Panic here if wrong kind?
-	return TypeID(bt.SizeType)
-}
-
-func (bt *btfType) SetType(id TypeID) {
-	bt.SizeType = uint32(id)
-}
-
-func (bt *btfType) Size() uint32 {
-	// TODO: Panic here if wrong kind?
-	return bt.SizeType
-}
-
-func (bt *btfType) SetSize(size uint32) {
-	bt.SizeType = size
-}
-
-func (bt *btfType) Marshal(w io.Writer, bo binary.ByteOrder) error {
-	buf := make([]byte, unsafe.Sizeof(*bt))
-	bo.PutUint32(buf[0:], bt.NameOff)
-	bo.PutUint32(buf[4:], bt.Info)
-	bo.PutUint32(buf[8:], bt.SizeType)
-	_, err := w.Write(buf)
-	return err
-}
-
-type rawType struct {
-	btfType
-	data interface{}
-}
-
-func (rt *rawType) Marshal(w io.Writer, bo binary.ByteOrder) error {
-	if err := rt.btfType.Marshal(w, bo); err != nil {
-		return err
-	}
-
-	if rt.data == nil {
-		return nil
-	}
-
-	return binary.Write(w, bo, rt.data)
-}
-
-// btfInt encodes additional data for integers.
-//
-//	? ? ? ? e e e e o o o o o o o o ? ? ? ? ? ? ? ? b b b b b b b b
-//	? = undefined
-//	e = encoding
-//	o = offset (bitfields?)
-//	b = bits (bitfields)
-type btfInt struct {
-	Raw uint32
-}
-
-const (
-	btfIntEncodingLen   = 4
-	btfIntEncodingShift = 24
-	btfIntOffsetLen     = 8
-	btfIntOffsetShift   = 16
-	btfIntBitsLen       = 8
-	btfIntBitsShift     = 0
-)
-
-func (bi btfInt) Encoding() IntEncoding {
-	return IntEncoding(readBits(bi.Raw, btfIntEncodingLen, btfIntEncodingShift))
-}
-
-func (bi *btfInt) SetEncoding(e IntEncoding) {
-	bi.Raw = writeBits(uint32(bi.Raw), btfIntEncodingLen, btfIntEncodingShift, uint32(e))
-}
-
-func (bi btfInt) Offset() Bits {
-	return Bits(readBits(bi.Raw, btfIntOffsetLen, btfIntOffsetShift))
-}
-
-func (bi *btfInt) SetOffset(offset uint32) {
-	bi.Raw = writeBits(bi.Raw, btfIntOffsetLen, btfIntOffsetShift, offset)
-}
-
-func (bi btfInt) Bits() Bits {
-	return Bits(readBits(bi.Raw, btfIntBitsLen, btfIntBitsShift))
-}
-
-func (bi *btfInt) SetBits(bits byte) {
-	bi.Raw = writeBits(bi.Raw, btfIntBitsLen, btfIntBitsShift, uint32(bits))
-}
-
-type btfArray struct {
-	Type      TypeID
-	IndexType TypeID
-	Nelems    uint32
-}
-
-type btfMember struct {
-	NameOff uint32
-	Type    TypeID
-	Offset  uint32
-}
-
-type btfVarSecinfo struct {
-	Type   TypeID
-	Offset uint32
-	Size   uint32
-}
-
-type btfVariable struct {
-	Linkage uint32
-}
-
-type btfEnum struct {
-	NameOff uint32
-	Val     uint32
-}
-
-type btfEnum64 struct {
-	NameOff uint32
-	ValLo32 uint32
-	ValHi32 uint32
-}
-
-type btfParam struct {
-	NameOff uint32
-	Type    TypeID
-}
-
-type btfDeclTag struct {
-	ComponentIdx uint32
-}
-
-func readTypes(r io.Reader, bo binary.ByteOrder, typeLen uint32) ([]rawType, error) {
-	var header btfType
-	// because of the interleaving between types and struct members it is difficult to
-	// precompute the numbers of raw types this will parse
-	// this "guess" is a good first estimation
-	sizeOfbtfType := uintptr(btfTypeLen)
-	tyMaxCount := uintptr(typeLen) / sizeOfbtfType / 2
-	types := make([]rawType, 0, tyMaxCount)
-
-	for id := TypeID(1); ; id++ {
-		if err := binary.Read(r, bo, &header); err == io.EOF {
-			return types, nil
-		} else if err != nil {
-			return nil, fmt.Errorf("can't read type info for id %v: %v", id, err)
-		}
-
-		var data interface{}
-		switch header.Kind() {
-		case kindInt:
-			data = new(btfInt)
-		case kindPointer:
-		case kindArray:
-			data = new(btfArray)
-		case kindStruct:
-			fallthrough
-		case kindUnion:
-			data = make([]btfMember, header.Vlen())
-		case kindEnum:
-			data = make([]btfEnum, header.Vlen())
-		case kindForward:
-		case kindTypedef:
-		case kindVolatile:
-		case kindConst:
-		case kindRestrict:
-		case kindFunc:
-		case kindFuncProto:
-			data = make([]btfParam, header.Vlen())
-		case kindVar:
-			data = new(btfVariable)
-		case kindDatasec:
-			data = make([]btfVarSecinfo, header.Vlen())
-		case kindFloat:
-		case kindDeclTag:
-			data = new(btfDeclTag)
-		case kindTypeTag:
-		case kindEnum64:
-			data = make([]btfEnum64, header.Vlen())
-		default:
-			return nil, fmt.Errorf("type id %v: unknown kind: %v", id, header.Kind())
-		}
-
-		if data == nil {
-			types = append(types, rawType{header, nil})
-			continue
-		}
-
-		if err := binary.Read(r, bo, data); err != nil {
-			return nil, fmt.Errorf("type id %d: kind %v: can't read %T: %v", id, header.Kind(), data, err)
-		}
-
-		types = append(types, rawType{header, data})
-	}
-}
diff --git a/vendor/github.com/cilium/ebpf/btf/btf_types_string.go b/vendor/github.com/cilium/ebpf/btf/btf_types_string.go
deleted file mode 100644
index b7a1b80d1..000000000
--- a/vendor/github.com/cilium/ebpf/btf/btf_types_string.go
+++ /dev/null
@@ -1,80 +0,0 @@
-// Code generated by "stringer -linecomment -output=btf_types_string.go -type=FuncLinkage,VarLinkage,btfKind"; DO NOT EDIT.
-
-package btf
-
-import "strconv"
-
-func _() {
-	// An "invalid array index" compiler error signifies that the constant values have changed.
-	// Re-run the stringer command to generate them again.
-	var x [1]struct{}
-	_ = x[StaticFunc-0]
-	_ = x[GlobalFunc-1]
-	_ = x[ExternFunc-2]
-}
-
-const _FuncLinkage_name = "staticglobalextern"
-
-var _FuncLinkage_index = [...]uint8{0, 6, 12, 18}
-
-func (i FuncLinkage) String() string {
-	if i < 0 || i >= FuncLinkage(len(_FuncLinkage_index)-1) {
-		return "FuncLinkage(" + strconv.FormatInt(int64(i), 10) + ")"
-	}
-	return _FuncLinkage_name[_FuncLinkage_index[i]:_FuncLinkage_index[i+1]]
-}
-func _() {
-	// An "invalid array index" compiler error signifies that the constant values have changed.
-	// Re-run the stringer command to generate them again.
-	var x [1]struct{}
-	_ = x[StaticVar-0]
-	_ = x[GlobalVar-1]
-	_ = x[ExternVar-2]
-}
-
-const _VarLinkage_name = "staticglobalextern"
-
-var _VarLinkage_index = [...]uint8{0, 6, 12, 18}
-
-func (i VarLinkage) String() string {
-	if i < 0 || i >= VarLinkage(len(_VarLinkage_index)-1) {
-		return "VarLinkage(" + strconv.FormatInt(int64(i), 10) + ")"
-	}
-	return _VarLinkage_name[_VarLinkage_index[i]:_VarLinkage_index[i+1]]
-}
-func _() {
-	// An "invalid array index" compiler error signifies that the constant values have changed.
-	// Re-run the stringer command to generate them again.
-	var x [1]struct{}
-	_ = x[kindUnknown-0]
-	_ = x[kindInt-1]
-	_ = x[kindPointer-2]
-	_ = x[kindArray-3]
-	_ = x[kindStruct-4]
-	_ = x[kindUnion-5]
-	_ = x[kindEnum-6]
-	_ = x[kindForward-7]
-	_ = x[kindTypedef-8]
-	_ = x[kindVolatile-9]
-	_ = x[kindConst-10]
-	_ = x[kindRestrict-11]
-	_ = x[kindFunc-12]
-	_ = x[kindFuncProto-13]
-	_ = x[kindVar-14]
-	_ = x[kindDatasec-15]
-	_ = x[kindFloat-16]
-	_ = x[kindDeclTag-17]
-	_ = x[kindTypeTag-18]
-	_ = x[kindEnum64-19]
-}
-
-const _btfKind_name = "UnknownIntPointerArrayStructUnionEnumForwardTypedefVolatileConstRestrictFuncFuncProtoVarDatasecFloatDeclTagTypeTagEnum64"
-
-var _btfKind_index = [...]uint8{0, 7, 10, 17, 22, 28, 33, 37, 44, 51, 59, 64, 72, 76, 85, 88, 95, 100, 107, 114, 120}
-
-func (i btfKind) String() string {
-	if i >= btfKind(len(_btfKind_index)-1) {
-		return "btfKind(" + strconv.FormatInt(int64(i), 10) + ")"
-	}
-	return _btfKind_name[_btfKind_index[i]:_btfKind_index[i+1]]
-}
diff --git a/vendor/github.com/cilium/ebpf/btf/core.go b/vendor/github.com/cilium/ebpf/btf/core.go
deleted file mode 100644
index a5c40d36a..000000000
--- a/vendor/github.com/cilium/ebpf/btf/core.go
+++ /dev/null
@@ -1,1011 +0,0 @@
-package btf
-
-import (
-	"encoding/binary"
-	"errors"
-	"fmt"
-	"math"
-	"reflect"
-	"strconv"
-	"strings"
-
-	"github.com/cilium/ebpf/asm"
-)
-
-// Code in this file is derived from libbpf, which is available under a BSD
-// 2-Clause license.
-
-// COREFixup is the result of computing a CO-RE relocation for a target.
-type COREFixup struct {
-	kind   coreKind
-	local  uint32
-	target uint32
-	// True if there is no valid fixup. The instruction is replaced with an
-	// invalid dummy.
-	poison bool
-	// True if the validation of the local value should be skipped. Used by
-	// some kinds of bitfield relocations.
-	skipLocalValidation bool
-}
-
-func (f *COREFixup) equal(other COREFixup) bool {
-	return f.local == other.local && f.target == other.target
-}
-
-func (f *COREFixup) String() string {
-	if f.poison {
-		return fmt.Sprintf("%s=poison", f.kind)
-	}
-	return fmt.Sprintf("%s=%d->%d", f.kind, f.local, f.target)
-}
-
-func (f *COREFixup) Apply(ins *asm.Instruction) error {
-	if f.poison {
-		const badRelo = 0xbad2310
-
-		*ins = asm.BuiltinFunc(badRelo).Call()
-		return nil
-	}
-
-	switch class := ins.OpCode.Class(); class {
-	case asm.LdXClass, asm.StClass, asm.StXClass:
-		if want := int16(f.local); !f.skipLocalValidation && want != ins.Offset {
-			return fmt.Errorf("invalid offset %d, expected %d", ins.Offset, f.local)
-		}
-
-		if f.target > math.MaxInt16 {
-			return fmt.Errorf("offset %d exceeds MaxInt16", f.target)
-		}
-
-		ins.Offset = int16(f.target)
-
-	case asm.LdClass:
-		if !ins.IsConstantLoad(asm.DWord) {
-			return fmt.Errorf("not a dword-sized immediate load")
-		}
-
-		if want := int64(f.local); !f.skipLocalValidation && want != ins.Constant {
-			return fmt.Errorf("invalid immediate %d, expected %d (fixup: %v)", ins.Constant, want, f)
-		}
-
-		ins.Constant = int64(f.target)
-
-	case asm.ALUClass:
-		if ins.OpCode.ALUOp() == asm.Swap {
-			return fmt.Errorf("relocation against swap")
-		}
-
-		fallthrough
-
-	case asm.ALU64Class:
-		if src := ins.OpCode.Source(); src != asm.ImmSource {
-			return fmt.Errorf("invalid source %s", src)
-		}
-
-		if want := int64(f.local); !f.skipLocalValidation && want != ins.Constant {
-			return fmt.Errorf("invalid immediate %d, expected %d (fixup: %v, kind: %v, ins: %v)", ins.Constant, want, f, f.kind, ins)
-		}
-
-		if f.target > math.MaxInt32 {
-			return fmt.Errorf("immediate %d exceeds MaxInt32", f.target)
-		}
-
-		ins.Constant = int64(f.target)
-
-	default:
-		return fmt.Errorf("invalid class %s", class)
-	}
-
-	return nil
-}
-
-func (f COREFixup) isNonExistant() bool {
-	return f.kind.checksForExistence() && f.target == 0
-}
-
-// coreKind is the type of CO-RE relocation as specified in BPF source code.
-type coreKind uint32
-
-const (
-	reloFieldByteOffset coreKind = iota /* field byte offset */
-	reloFieldByteSize                   /* field size in bytes */
-	reloFieldExists                     /* field existence in target kernel */
-	reloFieldSigned                     /* field signedness (0 - unsigned, 1 - signed) */
-	reloFieldLShiftU64                  /* bitfield-specific left bitshift */
-	reloFieldRShiftU64                  /* bitfield-specific right bitshift */
-	reloTypeIDLocal                     /* type ID in local BPF object */
-	reloTypeIDTarget                    /* type ID in target kernel */
-	reloTypeExists                      /* type existence in target kernel */
-	reloTypeSize                        /* type size in bytes */
-	reloEnumvalExists                   /* enum value existence in target kernel */
-	reloEnumvalValue                    /* enum value integer value */
-)
-
-func (k coreKind) checksForExistence() bool {
-	return k == reloEnumvalExists || k == reloTypeExists || k == reloFieldExists
-}
-
-func (k coreKind) String() string {
-	switch k {
-	case reloFieldByteOffset:
-		return "byte_off"
-	case reloFieldByteSize:
-		return "byte_sz"
-	case reloFieldExists:
-		return "field_exists"
-	case reloFieldSigned:
-		return "signed"
-	case reloFieldLShiftU64:
-		return "lshift_u64"
-	case reloFieldRShiftU64:
-		return "rshift_u64"
-	case reloTypeIDLocal:
-		return "local_type_id"
-	case reloTypeIDTarget:
-		return "target_type_id"
-	case reloTypeExists:
-		return "type_exists"
-	case reloTypeSize:
-		return "type_size"
-	case reloEnumvalExists:
-		return "enumval_exists"
-	case reloEnumvalValue:
-		return "enumval_value"
-	default:
-		return "unknown"
-	}
-}
-
-// CORERelocate calculates changes needed to adjust eBPF instructions for differences
-// in types.
-//
-// Returns a list of fixups which can be applied to instructions to make them
-// match the target type(s).
-//
-// Fixups are returned in the order of relos, e.g. fixup[i] is the solution
-// for relos[i].
-func CORERelocate(relos []*CORERelocation, target *Spec, bo binary.ByteOrder) ([]COREFixup, error) {
-	if target == nil {
-		var err error
-		target, _, err = kernelSpec()
-		if err != nil {
-			return nil, fmt.Errorf("load kernel spec: %w", err)
-		}
-	}
-
-	if bo != target.byteOrder {
-		return nil, fmt.Errorf("can't relocate %s against %s", bo, target.byteOrder)
-	}
-
-	type reloGroup struct {
-		relos []*CORERelocation
-		// Position of each relocation in relos.
-		indices []int
-	}
-
-	// Split relocations into per Type lists.
-	relosByType := make(map[Type]*reloGroup)
-	result := make([]COREFixup, len(relos))
-	for i, relo := range relos {
-		if relo.kind == reloTypeIDLocal {
-			// Filtering out reloTypeIDLocal here makes our lives a lot easier
-			// down the line, since it doesn't have a target at all.
-			if len(relo.accessor) > 1 || relo.accessor[0] != 0 {
-				return nil, fmt.Errorf("%s: unexpected accessor %v", relo.kind, relo.accessor)
-			}
-
-			result[i] = COREFixup{
-				kind:  relo.kind,
-				local: uint32(relo.id),
-				// NB: Using relo.id as the target here is incorrect, since
-				// it doesn't match the BTF we generate on the fly. This isn't
-				// too bad for now since there are no uses of the local type ID
-				// in the kernel, yet.
-				target: uint32(relo.id),
-			}
-			continue
-		}
-
-		group, ok := relosByType[relo.typ]
-		if !ok {
-			group = &reloGroup{}
-			relosByType[relo.typ] = group
-		}
-		group.relos = append(group.relos, relo)
-		group.indices = append(group.indices, i)
-	}
-
-	for localType, group := range relosByType {
-		localTypeName := localType.TypeName()
-		if localTypeName == "" {
-			return nil, fmt.Errorf("relocate unnamed or anonymous type %s: %w", localType, ErrNotSupported)
-		}
-
-		targets := target.namedTypes[newEssentialName(localTypeName)]
-		fixups, err := coreCalculateFixups(group.relos, target, targets, bo)
-		if err != nil {
-			return nil, fmt.Errorf("relocate %s: %w", localType, err)
-		}
-
-		for j, index := range group.indices {
-			result[index] = fixups[j]
-		}
-	}
-
-	return result, nil
-}
-
-var errAmbiguousRelocation = errors.New("ambiguous relocation")
-var errImpossibleRelocation = errors.New("impossible relocation")
-var errIncompatibleTypes = errors.New("incompatible types")
-
-// coreCalculateFixups finds the target type that best matches all relocations.
-//
-// All relos must target the same type.
-//
-// The best target is determined by scoring: the less poisoning we have to do
-// the better the target is.
-func coreCalculateFixups(relos []*CORERelocation, targetSpec *Spec, targets []Type, bo binary.ByteOrder) ([]COREFixup, error) {
-	bestScore := len(relos)
-	var bestFixups []COREFixup
-	for _, target := range targets {
-		targetID, err := targetSpec.TypeID(target)
-		if err != nil {
-			return nil, fmt.Errorf("target type ID: %w", err)
-		}
-
-		score := 0 // lower is better
-		fixups := make([]COREFixup, 0, len(relos))
-		for _, relo := range relos {
-			fixup, err := coreCalculateFixup(relo, target, targetID, bo)
-			if err != nil {
-				return nil, fmt.Errorf("target %s: %s: %w", target, relo.kind, err)
-			}
-			if fixup.poison || fixup.isNonExistant() {
-				score++
-			}
-			fixups = append(fixups, fixup)
-		}
-
-		if score > bestScore {
-			// We have a better target already, ignore this one.
-			continue
-		}
-
-		if score < bestScore {
-			// This is the best target yet, use it.
-			bestScore = score
-			bestFixups = fixups
-			continue
-		}
-
-		// Some other target has the same score as the current one. Make sure
-		// the fixups agree with each other.
-		for i, fixup := range bestFixups {
-			if !fixup.equal(fixups[i]) {
-				return nil, fmt.Errorf("%s: multiple types match: %w", fixup.kind, errAmbiguousRelocation)
-			}
-		}
-	}
-
-	if bestFixups == nil {
-		// Nothing at all matched, probably because there are no suitable
-		// targets at all.
-		//
-		// Poison everything except checksForExistence.
-		bestFixups = make([]COREFixup, len(relos))
-		for i, relo := range relos {
-			if relo.kind.checksForExistence() {
-				bestFixups[i] = COREFixup{kind: relo.kind, local: 1, target: 0}
-			} else {
-				bestFixups[i] = COREFixup{kind: relo.kind, poison: true}
-			}
-		}
-	}
-
-	return bestFixups, nil
-}
-
-var errNoSignedness = errors.New("no signedness")
-
-// coreCalculateFixup calculates the fixup for a single local type, target type
-// and relocation.
-func coreCalculateFixup(relo *CORERelocation, target Type, targetID TypeID, bo binary.ByteOrder) (COREFixup, error) {
-	fixup := func(local, target uint32) (COREFixup, error) {
-		return COREFixup{kind: relo.kind, local: local, target: target}, nil
-	}
-	fixupWithoutValidation := func(local, target uint32) (COREFixup, error) {
-		return COREFixup{kind: relo.kind, local: local, target: target, skipLocalValidation: true}, nil
-	}
-	poison := func() (COREFixup, error) {
-		if relo.kind.checksForExistence() {
-			return fixup(1, 0)
-		}
-		return COREFixup{kind: relo.kind, poison: true}, nil
-	}
-	zero := COREFixup{}
-
-	local := relo.typ
-
-	switch relo.kind {
-	case reloTypeIDTarget, reloTypeSize, reloTypeExists:
-		if len(relo.accessor) > 1 || relo.accessor[0] != 0 {
-			return zero, fmt.Errorf("unexpected accessor %v", relo.accessor)
-		}
-
-		err := coreAreTypesCompatible(local, target)
-		if errors.Is(err, errIncompatibleTypes) {
-			return poison()
-		}
-		if err != nil {
-			return zero, err
-		}
-
-		switch relo.kind {
-		case reloTypeExists:
-			return fixup(1, 1)
-
-		case reloTypeIDTarget:
-			return fixup(uint32(relo.id), uint32(targetID))
-
-		case reloTypeSize:
-			localSize, err := Sizeof(local)
-			if err != nil {
-				return zero, err
-			}
-
-			targetSize, err := Sizeof(target)
-			if err != nil {
-				return zero, err
-			}
-
-			return fixup(uint32(localSize), uint32(targetSize))
-		}
-
-	case reloEnumvalValue, reloEnumvalExists:
-		localValue, targetValue, err := coreFindEnumValue(local, relo.accessor, target)
-		if errors.Is(err, errImpossibleRelocation) {
-			return poison()
-		}
-		if err != nil {
-			return zero, err
-		}
-
-		switch relo.kind {
-		case reloEnumvalExists:
-			return fixup(1, 1)
-
-		case reloEnumvalValue:
-			return fixup(uint32(localValue.Value), uint32(targetValue.Value))
-		}
-
-	case reloFieldByteOffset, reloFieldByteSize, reloFieldExists, reloFieldLShiftU64, reloFieldRShiftU64, reloFieldSigned:
-		if _, ok := as[*Fwd](target); ok {
-			// We can't relocate fields using a forward declaration, so
-			// skip it. If a non-forward declaration is present in the BTF
-			// we'll find it in one of the other iterations.
-			return poison()
-		}
-
-		localField, targetField, err := coreFindField(local, relo.accessor, target)
-		if errors.Is(err, errImpossibleRelocation) {
-			return poison()
-		}
-		if err != nil {
-			return zero, err
-		}
-
-		maybeSkipValidation := func(f COREFixup, err error) (COREFixup, error) {
-			f.skipLocalValidation = localField.bitfieldSize > 0
-			return f, err
-		}
-
-		switch relo.kind {
-		case reloFieldExists:
-			return fixup(1, 1)
-
-		case reloFieldByteOffset:
-			return maybeSkipValidation(fixup(localField.offset, targetField.offset))
-
-		case reloFieldByteSize:
-			localSize, err := Sizeof(localField.Type)
-			if err != nil {
-				return zero, err
-			}
-
-			targetSize, err := Sizeof(targetField.Type)
-			if err != nil {
-				return zero, err
-			}
-			return maybeSkipValidation(fixup(uint32(localSize), uint32(targetSize)))
-
-		case reloFieldLShiftU64:
-			var target uint32
-			if bo == binary.LittleEndian {
-				targetSize, err := targetField.sizeBits()
-				if err != nil {
-					return zero, err
-				}
-
-				target = uint32(64 - targetField.bitfieldOffset - targetSize)
-			} else {
-				loadWidth, err := Sizeof(targetField.Type)
-				if err != nil {
-					return zero, err
-				}
-
-				target = uint32(64 - Bits(loadWidth*8) + targetField.bitfieldOffset)
-			}
-			return fixupWithoutValidation(0, target)
-
-		case reloFieldRShiftU64:
-			targetSize, err := targetField.sizeBits()
-			if err != nil {
-				return zero, err
-			}
-
-			return fixupWithoutValidation(0, uint32(64-targetSize))
-
-		case reloFieldSigned:
-			switch local := UnderlyingType(localField.Type).(type) {
-			case *Enum:
-				target, ok := as[*Enum](targetField.Type)
-				if !ok {
-					return zero, fmt.Errorf("target isn't *Enum but %T", targetField.Type)
-				}
-
-				return fixup(boolToUint32(local.Signed), boolToUint32(target.Signed))
-			case *Int:
-				target, ok := as[*Int](targetField.Type)
-				if !ok {
-					return zero, fmt.Errorf("target isn't *Int but %T", targetField.Type)
-				}
-
-				return fixup(
-					uint32(local.Encoding&Signed),
-					uint32(target.Encoding&Signed),
-				)
-			default:
-				return zero, fmt.Errorf("type %T: %w", local, errNoSignedness)
-			}
-		}
-	}
-
-	return zero, ErrNotSupported
-}
-
-func boolToUint32(val bool) uint32 {
-	if val {
-		return 1
-	}
-	return 0
-}
-
-/* coreAccessor contains a path through a struct. It contains at least one index.
- *
- * The interpretation depends on the kind of the relocation. The following is
- * taken from struct bpf_core_relo in libbpf_internal.h:
- *
- * - for field-based relocations, string encodes an accessed field using
- *   a sequence of field and array indices, separated by colon (:). It's
- *   conceptually very close to LLVM's getelementptr ([0]) instruction's
- *   arguments for identifying offset to a field.
- * - for type-based relocations, strings is expected to be just "0";
- * - for enum value-based relocations, string contains an index of enum
- *   value within its enum type;
- *
- * Example to provide a better feel.
- *
- *   struct sample {
- *       int a;
- *       struct {
- *           int b[10];
- *       };
- *   };
- *
- *   struct sample s = ...;
- *   int x = &s->a;     // encoded as "0:0" (a is field #0)
- *   int y = &s->b[5];  // encoded as "0:1:0:5" (anon struct is field #1,
- *                      // b is field #0 inside anon struct, accessing elem #5)
- *   int z = &s[10]->b; // encoded as "10:1" (ptr is used as an array)
- */
-type coreAccessor []int
-
-func parseCOREAccessor(accessor string) (coreAccessor, error) {
-	if accessor == "" {
-		return nil, fmt.Errorf("empty accessor")
-	}
-
-	parts := strings.Split(accessor, ":")
-	result := make(coreAccessor, 0, len(parts))
-	for _, part := range parts {
-		// 31 bits to avoid overflowing int on 32 bit platforms.
-		index, err := strconv.ParseUint(part, 10, 31)
-		if err != nil {
-			return nil, fmt.Errorf("accessor index %q: %s", part, err)
-		}
-
-		result = append(result, int(index))
-	}
-
-	return result, nil
-}
-
-func (ca coreAccessor) String() string {
-	strs := make([]string, 0, len(ca))
-	for _, i := range ca {
-		strs = append(strs, strconv.Itoa(i))
-	}
-	return strings.Join(strs, ":")
-}
-
-func (ca coreAccessor) enumValue(t Type) (*EnumValue, error) {
-	e, ok := as[*Enum](t)
-	if !ok {
-		return nil, fmt.Errorf("not an enum: %s", t)
-	}
-
-	if len(ca) > 1 {
-		return nil, fmt.Errorf("invalid accessor %s for enum", ca)
-	}
-
-	i := ca[0]
-	if i >= len(e.Values) {
-		return nil, fmt.Errorf("invalid index %d for %s", i, e)
-	}
-
-	return &e.Values[i], nil
-}
-
-// coreField represents the position of a "child" of a composite type from the
-// start of that type.
-//
-//	/- start of composite
-//	| offset * 8 | bitfieldOffset | bitfieldSize | ... |
-//	             \- start of field       end of field -/
-type coreField struct {
-	Type Type
-
-	// The position of the field from the start of the composite type in bytes.
-	offset uint32
-
-	// The offset of the bitfield in bits from the start of the field.
-	bitfieldOffset Bits
-
-	// The size of the bitfield in bits.
-	//
-	// Zero if the field is not a bitfield.
-	bitfieldSize Bits
-}
-
-func (cf *coreField) adjustOffsetToNthElement(n int) error {
-	if n == 0 {
-		return nil
-	}
-
-	size, err := Sizeof(cf.Type)
-	if err != nil {
-		return err
-	}
-
-	cf.offset += uint32(n) * uint32(size)
-	return nil
-}
-
-func (cf *coreField) adjustOffsetBits(offset Bits) error {
-	align, err := alignof(cf.Type)
-	if err != nil {
-		return err
-	}
-
-	// We can compute the load offset by:
-	// 1) converting the bit offset to bytes with a flooring division.
-	// 2) dividing and multiplying that offset by the alignment, yielding the
-	//    load size aligned offset.
-	offsetBytes := uint32(offset/8) / uint32(align) * uint32(align)
-
-	// The number of bits remaining is the bit offset less the number of bits
-	// we can "skip" with the aligned offset.
-	cf.bitfieldOffset = offset - Bits(offsetBytes*8)
-
-	// We know that cf.offset is aligned at to at least align since we get it
-	// from the compiler via BTF. Adding an aligned offsetBytes preserves the
-	// alignment.
-	cf.offset += offsetBytes
-	return nil
-}
-
-func (cf *coreField) sizeBits() (Bits, error) {
-	if cf.bitfieldSize > 0 {
-		return cf.bitfieldSize, nil
-	}
-
-	// Someone is trying to access a non-bitfield via a bit shift relocation.
-	// This happens when a field changes from a bitfield to a regular field
-	// between kernel versions. Synthesise the size to make the shifts work.
-	size, err := Sizeof(cf.Type)
-	if err != nil {
-		return 0, err
-	}
-	return Bits(size * 8), nil
-}
-
-// coreFindField descends into the local type using the accessor and tries to
-// find an equivalent field in target at each step.
-//
-// Returns the field and the offset of the field from the start of
-// target in bits.
-func coreFindField(localT Type, localAcc coreAccessor, targetT Type) (coreField, coreField, error) {
-	local := coreField{Type: localT}
-	target := coreField{Type: targetT}
-
-	if err := coreAreMembersCompatible(local.Type, target.Type); err != nil {
-		return coreField{}, coreField{}, fmt.Errorf("fields: %w", err)
-	}
-
-	// The first index is used to offset a pointer of the base type like
-	// when accessing an array.
-	if err := local.adjustOffsetToNthElement(localAcc[0]); err != nil {
-		return coreField{}, coreField{}, err
-	}
-
-	if err := target.adjustOffsetToNthElement(localAcc[0]); err != nil {
-		return coreField{}, coreField{}, err
-	}
-
-	var localMaybeFlex, targetMaybeFlex bool
-	for i, acc := range localAcc[1:] {
-		switch localType := UnderlyingType(local.Type).(type) {
-		case composite:
-			// For composite types acc is used to find the field in the local type,
-			// and then we try to find a field in target with the same name.
-			localMembers := localType.members()
-			if acc >= len(localMembers) {
-				return coreField{}, coreField{}, fmt.Errorf("invalid accessor %d for %s", acc, localType)
-			}
-
-			localMember := localMembers[acc]
-			if localMember.Name == "" {
-				localMemberType, ok := as[composite](localMember.Type)
-				if !ok {
-					return coreField{}, coreField{}, fmt.Errorf("unnamed field with type %s: %s", localMember.Type, ErrNotSupported)
-				}
-
-				// This is an anonymous struct or union, ignore it.
-				local = coreField{
-					Type:   localMemberType,
-					offset: local.offset + localMember.Offset.Bytes(),
-				}
-				localMaybeFlex = false
-				continue
-			}
-
-			targetType, ok := as[composite](target.Type)
-			if !ok {
-				return coreField{}, coreField{}, fmt.Errorf("target not composite: %w", errImpossibleRelocation)
-			}
-
-			targetMember, last, err := coreFindMember(targetType, localMember.Name)
-			if err != nil {
-				return coreField{}, coreField{}, err
-			}
-
-			local = coreField{
-				Type:         localMember.Type,
-				offset:       local.offset,
-				bitfieldSize: localMember.BitfieldSize,
-			}
-			localMaybeFlex = acc == len(localMembers)-1
-
-			target = coreField{
-				Type:         targetMember.Type,
-				offset:       target.offset,
-				bitfieldSize: targetMember.BitfieldSize,
-			}
-			targetMaybeFlex = last
-
-			if local.bitfieldSize == 0 && target.bitfieldSize == 0 {
-				local.offset += localMember.Offset.Bytes()
-				target.offset += targetMember.Offset.Bytes()
-				break
-			}
-
-			// Either of the members is a bitfield. Make sure we're at the
-			// end of the accessor.
-			if next := i + 1; next < len(localAcc[1:]) {
-				return coreField{}, coreField{}, fmt.Errorf("can't descend into bitfield")
-			}
-
-			if err := local.adjustOffsetBits(localMember.Offset); err != nil {
-				return coreField{}, coreField{}, err
-			}
-
-			if err := target.adjustOffsetBits(targetMember.Offset); err != nil {
-				return coreField{}, coreField{}, err
-			}
-
-		case *Array:
-			// For arrays, acc is the index in the target.
-			targetType, ok := as[*Array](target.Type)
-			if !ok {
-				return coreField{}, coreField{}, fmt.Errorf("target not array: %w", errImpossibleRelocation)
-			}
-
-			if localType.Nelems == 0 && !localMaybeFlex {
-				return coreField{}, coreField{}, fmt.Errorf("local type has invalid flexible array")
-			}
-			if targetType.Nelems == 0 && !targetMaybeFlex {
-				return coreField{}, coreField{}, fmt.Errorf("target type has invalid flexible array")
-			}
-
-			if localType.Nelems > 0 && acc >= int(localType.Nelems) {
-				return coreField{}, coreField{}, fmt.Errorf("invalid access of %s at index %d", localType, acc)
-			}
-			if targetType.Nelems > 0 && acc >= int(targetType.Nelems) {
-				return coreField{}, coreField{}, fmt.Errorf("out of bounds access of target: %w", errImpossibleRelocation)
-			}
-
-			local = coreField{
-				Type:   localType.Type,
-				offset: local.offset,
-			}
-			localMaybeFlex = false
-
-			if err := local.adjustOffsetToNthElement(acc); err != nil {
-				return coreField{}, coreField{}, err
-			}
-
-			target = coreField{
-				Type:   targetType.Type,
-				offset: target.offset,
-			}
-			targetMaybeFlex = false
-
-			if err := target.adjustOffsetToNthElement(acc); err != nil {
-				return coreField{}, coreField{}, err
-			}
-
-		default:
-			return coreField{}, coreField{}, fmt.Errorf("relocate field of %T: %w", localType, ErrNotSupported)
-		}
-
-		if err := coreAreMembersCompatible(local.Type, target.Type); err != nil {
-			return coreField{}, coreField{}, err
-		}
-	}
-
-	return local, target, nil
-}
-
-// coreFindMember finds a member in a composite type while handling anonymous
-// structs and unions.
-func coreFindMember(typ composite, name string) (Member, bool, error) {
-	if name == "" {
-		return Member{}, false, errors.New("can't search for anonymous member")
-	}
-
-	type offsetTarget struct {
-		composite
-		offset Bits
-	}
-
-	targets := []offsetTarget{{typ, 0}}
-	visited := make(map[composite]bool)
-
-	for i := 0; i < len(targets); i++ {
-		target := targets[i]
-
-		// Only visit targets once to prevent infinite recursion.
-		if visited[target] {
-			continue
-		}
-		if len(visited) >= maxTypeDepth {
-			// This check is different than libbpf, which restricts the entire
-			// path to BPF_CORE_SPEC_MAX_LEN items.
-			return Member{}, false, fmt.Errorf("type is nested too deep")
-		}
-		visited[target] = true
-
-		members := target.members()
-		for j, member := range members {
-			if member.Name == name {
-				// NB: This is safe because member is a copy.
-				member.Offset += target.offset
-				return member, j == len(members)-1, nil
-			}
-
-			// The names don't match, but this member could be an anonymous struct
-			// or union.
-			if member.Name != "" {
-				continue
-			}
-
-			comp, ok := as[composite](member.Type)
-			if !ok {
-				return Member{}, false, fmt.Errorf("anonymous non-composite type %T not allowed", member.Type)
-			}
-
-			targets = append(targets, offsetTarget{comp, target.offset + member.Offset})
-		}
-	}
-
-	return Member{}, false, fmt.Errorf("no matching member: %w", errImpossibleRelocation)
-}
-
-// coreFindEnumValue follows localAcc to find the equivalent enum value in target.
-func coreFindEnumValue(local Type, localAcc coreAccessor, target Type) (localValue, targetValue *EnumValue, _ error) {
-	localValue, err := localAcc.enumValue(local)
-	if err != nil {
-		return nil, nil, err
-	}
-
-	targetEnum, ok := as[*Enum](target)
-	if !ok {
-		return nil, nil, errImpossibleRelocation
-	}
-
-	localName := newEssentialName(localValue.Name)
-	for i, targetValue := range targetEnum.Values {
-		if newEssentialName(targetValue.Name) != localName {
-			continue
-		}
-
-		return localValue, &targetEnum.Values[i], nil
-	}
-
-	return nil, nil, errImpossibleRelocation
-}
-
-// CheckTypeCompatibility checks local and target types for Compatibility according to CO-RE rules.
-//
-// Only layout compatibility is checked, ignoring names of the root type.
-func CheckTypeCompatibility(localType Type, targetType Type) error {
-	return coreAreTypesCompatible(localType, targetType)
-}
-
-/* The comment below is from bpf_core_types_are_compat in libbpf.c:
- *
- * Check local and target types for compatibility. This check is used for
- * type-based CO-RE relocations and follow slightly different rules than
- * field-based relocations. This function assumes that root types were already
- * checked for name match. Beyond that initial root-level name check, names
- * are completely ignored. Compatibility rules are as follows:
- *   - any two STRUCTs/UNIONs/FWDs/ENUMs/INTs are considered compatible, but
- *     kind should match for local and target types (i.e., STRUCT is not
- *     compatible with UNION);
- *   - for ENUMs, the size is ignored;
- *   - for INT, size and signedness are ignored;
- *   - for ARRAY, dimensionality is ignored, element types are checked for
- *     compatibility recursively;
- *   - CONST/VOLATILE/RESTRICT modifiers are ignored;
- *   - TYPEDEFs/PTRs are compatible if types they pointing to are compatible;
- *   - FUNC_PROTOs are compatible if they have compatible signature: same
- *     number of input args and compatible return and argument types.
- * These rules are not set in stone and probably will be adjusted as we get
- * more experience with using BPF CO-RE relocations.
- *
- * Returns errIncompatibleTypes if types are not compatible.
- */
-func coreAreTypesCompatible(localType Type, targetType Type) error {
-
-	var (
-		localTs, targetTs typeDeque
-		l, t              = &localType, &targetType
-		depth             = 0
-	)
-
-	for ; l != nil && t != nil; l, t = localTs.Shift(), targetTs.Shift() {
-		if depth >= maxTypeDepth {
-			return errors.New("types are nested too deep")
-		}
-
-		localType = UnderlyingType(*l)
-		targetType = UnderlyingType(*t)
-
-		if reflect.TypeOf(localType) != reflect.TypeOf(targetType) {
-			return fmt.Errorf("type mismatch: %w", errIncompatibleTypes)
-		}
-
-		switch lv := (localType).(type) {
-		case *Void, *Struct, *Union, *Enum, *Fwd, *Int:
-			// Nothing to do here
-
-		case *Pointer, *Array:
-			depth++
-			walkType(localType, localTs.Push)
-			walkType(targetType, targetTs.Push)
-
-		case *FuncProto:
-			tv := targetType.(*FuncProto)
-			if len(lv.Params) != len(tv.Params) {
-				return fmt.Errorf("function param mismatch: %w", errIncompatibleTypes)
-			}
-
-			depth++
-			walkType(localType, localTs.Push)
-			walkType(targetType, targetTs.Push)
-
-		default:
-			return fmt.Errorf("unsupported type %T", localType)
-		}
-	}
-
-	if l != nil {
-		return fmt.Errorf("dangling local type %T", *l)
-	}
-
-	if t != nil {
-		return fmt.Errorf("dangling target type %T", *t)
-	}
-
-	return nil
-}
-
-/* coreAreMembersCompatible checks two types for field-based relocation compatibility.
- *
- * The comment below is from bpf_core_fields_are_compat in libbpf.c:
- *
- * Check two types for compatibility for the purpose of field access
- * relocation. const/volatile/restrict and typedefs are skipped to ensure we
- * are relocating semantically compatible entities:
- *   - any two STRUCTs/UNIONs are compatible and can be mixed;
- *   - any two FWDs are compatible, if their names match (modulo flavor suffix);
- *   - any two PTRs are always compatible;
- *   - for ENUMs, names should be the same (ignoring flavor suffix) or at
- *     least one of enums should be anonymous;
- *   - for ENUMs, check sizes, names are ignored;
- *   - for INT, size and signedness are ignored;
- *   - any two FLOATs are always compatible;
- *   - for ARRAY, dimensionality is ignored, element types are checked for
- *     compatibility recursively;
- *     [ NB: coreAreMembersCompatible doesn't recurse, this check is done
- *       by coreFindField. ]
- *   - everything else shouldn't be ever a target of relocation.
- * These rules are not set in stone and probably will be adjusted as we get
- * more experience with using BPF CO-RE relocations.
- *
- * Returns errImpossibleRelocation if the members are not compatible.
- */
-func coreAreMembersCompatible(localType Type, targetType Type) error {
-	localType = UnderlyingType(localType)
-	targetType = UnderlyingType(targetType)
-
-	doNamesMatch := func(a, b string) error {
-		if a == "" || b == "" {
-			// allow anonymous and named type to match
-			return nil
-		}
-
-		if newEssentialName(a) == newEssentialName(b) {
-			return nil
-		}
-
-		return fmt.Errorf("names don't match: %w", errImpossibleRelocation)
-	}
-
-	_, lok := localType.(composite)
-	_, tok := targetType.(composite)
-	if lok && tok {
-		return nil
-	}
-
-	if reflect.TypeOf(localType) != reflect.TypeOf(targetType) {
-		return fmt.Errorf("type mismatch: %w", errImpossibleRelocation)
-	}
-
-	switch lv := localType.(type) {
-	case *Array, *Pointer, *Float, *Int:
-		return nil
-
-	case *Enum:
-		tv := targetType.(*Enum)
-		return doNamesMatch(lv.Name, tv.Name)
-
-	case *Fwd:
-		tv := targetType.(*Fwd)
-		return doNamesMatch(lv.Name, tv.Name)
-
-	default:
-		return fmt.Errorf("type %s: %w", localType, ErrNotSupported)
-	}
-}
diff --git a/vendor/github.com/cilium/ebpf/btf/doc.go b/vendor/github.com/cilium/ebpf/btf/doc.go
deleted file mode 100644
index b1f4b1fc3..000000000
--- a/vendor/github.com/cilium/ebpf/btf/doc.go
+++ /dev/null
@@ -1,5 +0,0 @@
-// Package btf handles data encoded according to the BPF Type Format.
-//
-// The canonical documentation lives in the Linux kernel repository and is
-// available at https://www.kernel.org/doc/html/latest/bpf/btf.html
-package btf
diff --git a/vendor/github.com/cilium/ebpf/btf/ext_info.go b/vendor/github.com/cilium/ebpf/btf/ext_info.go
deleted file mode 100644
index b764fb7bc..000000000
--- a/vendor/github.com/cilium/ebpf/btf/ext_info.go
+++ /dev/null
@@ -1,768 +0,0 @@
-package btf
-
-import (
-	"bytes"
-	"encoding/binary"
-	"errors"
-	"fmt"
-	"io"
-	"math"
-	"sort"
-
-	"github.com/cilium/ebpf/asm"
-	"github.com/cilium/ebpf/internal"
-)
-
-// ExtInfos contains ELF section metadata.
-type ExtInfos struct {
-	// The slices are sorted by offset in ascending order.
-	funcInfos       map[string][]funcInfo
-	lineInfos       map[string][]lineInfo
-	relocationInfos map[string][]coreRelocationInfo
-}
-
-// loadExtInfosFromELF parses ext infos from the .BTF.ext section in an ELF.
-//
-// Returns an error wrapping ErrNotFound if no ext infos are present.
-func loadExtInfosFromELF(file *internal.SafeELFFile, spec *Spec) (*ExtInfos, error) {
-	section := file.Section(".BTF.ext")
-	if section == nil {
-		return nil, fmt.Errorf("btf ext infos: %w", ErrNotFound)
-	}
-
-	if section.ReaderAt == nil {
-		return nil, fmt.Errorf("compressed ext_info is not supported")
-	}
-
-	return loadExtInfos(section.ReaderAt, file.ByteOrder, spec, spec.strings)
-}
-
-// loadExtInfos parses bare ext infos.
-func loadExtInfos(r io.ReaderAt, bo binary.ByteOrder, spec *Spec, strings *stringTable) (*ExtInfos, error) {
-	// Open unbuffered section reader. binary.Read() calls io.ReadFull on
-	// the header structs, resulting in one syscall per header.
-	headerRd := io.NewSectionReader(r, 0, math.MaxInt64)
-	extHeader, err := parseBTFExtHeader(headerRd, bo)
-	if err != nil {
-		return nil, fmt.Errorf("parsing BTF extension header: %w", err)
-	}
-
-	coreHeader, err := parseBTFExtCOREHeader(headerRd, bo, extHeader)
-	if err != nil {
-		return nil, fmt.Errorf("parsing BTF CO-RE header: %w", err)
-	}
-
-	buf := internal.NewBufferedSectionReader(r, extHeader.funcInfoStart(), int64(extHeader.FuncInfoLen))
-	btfFuncInfos, err := parseFuncInfos(buf, bo, strings)
-	if err != nil {
-		return nil, fmt.Errorf("parsing BTF function info: %w", err)
-	}
-
-	funcInfos := make(map[string][]funcInfo, len(btfFuncInfos))
-	for section, bfis := range btfFuncInfos {
-		funcInfos[section], err = newFuncInfos(bfis, spec)
-		if err != nil {
-			return nil, fmt.Errorf("section %s: func infos: %w", section, err)
-		}
-	}
-
-	buf = internal.NewBufferedSectionReader(r, extHeader.lineInfoStart(), int64(extHeader.LineInfoLen))
-	btfLineInfos, err := parseLineInfos(buf, bo, strings)
-	if err != nil {
-		return nil, fmt.Errorf("parsing BTF line info: %w", err)
-	}
-
-	lineInfos := make(map[string][]lineInfo, len(btfLineInfos))
-	for section, blis := range btfLineInfos {
-		lineInfos[section], err = newLineInfos(blis, strings)
-		if err != nil {
-			return nil, fmt.Errorf("section %s: line infos: %w", section, err)
-		}
-	}
-
-	if coreHeader == nil || coreHeader.COREReloLen == 0 {
-		return &ExtInfos{funcInfos, lineInfos, nil}, nil
-	}
-
-	var btfCORERelos map[string][]bpfCORERelo
-	buf = internal.NewBufferedSectionReader(r, extHeader.coreReloStart(coreHeader), int64(coreHeader.COREReloLen))
-	btfCORERelos, err = parseCORERelos(buf, bo, strings)
-	if err != nil {
-		return nil, fmt.Errorf("parsing CO-RE relocation info: %w", err)
-	}
-
-	coreRelos := make(map[string][]coreRelocationInfo, len(btfCORERelos))
-	for section, brs := range btfCORERelos {
-		coreRelos[section], err = newRelocationInfos(brs, spec, strings)
-		if err != nil {
-			return nil, fmt.Errorf("section %s: CO-RE relocations: %w", section, err)
-		}
-	}
-
-	return &ExtInfos{funcInfos, lineInfos, coreRelos}, nil
-}
-
-type funcInfoMeta struct{}
-type coreRelocationMeta struct{}
-
-// Assign per-section metadata from BTF to a section's instructions.
-func (ei *ExtInfos) Assign(insns asm.Instructions, section string) {
-	funcInfos := ei.funcInfos[section]
-	lineInfos := ei.lineInfos[section]
-	reloInfos := ei.relocationInfos[section]
-
-	iter := insns.Iterate()
-	for iter.Next() {
-		if len(funcInfos) > 0 && funcInfos[0].offset == iter.Offset {
-			*iter.Ins = WithFuncMetadata(*iter.Ins, funcInfos[0].fn)
-			funcInfos = funcInfos[1:]
-		}
-
-		if len(lineInfos) > 0 && lineInfos[0].offset == iter.Offset {
-			*iter.Ins = iter.Ins.WithSource(lineInfos[0].line)
-			lineInfos = lineInfos[1:]
-		}
-
-		if len(reloInfos) > 0 && reloInfos[0].offset == iter.Offset {
-			iter.Ins.Metadata.Set(coreRelocationMeta{}, reloInfos[0].relo)
-			reloInfos = reloInfos[1:]
-		}
-	}
-}
-
-// MarshalExtInfos encodes function and line info embedded in insns into kernel
-// wire format.
-//
-// Returns ErrNotSupported if the kernel doesn't support BTF-associated programs.
-func MarshalExtInfos(insns asm.Instructions) (_ *Handle, funcInfos, lineInfos []byte, _ error) {
-	// Bail out early if the kernel doesn't support Func(Proto). If this is the
-	// case, func_info will also be unsupported.
-	if err := haveProgBTF(); err != nil {
-		return nil, nil, nil, err
-	}
-
-	iter := insns.Iterate()
-	for iter.Next() {
-		_, ok := iter.Ins.Source().(*Line)
-		fn := FuncMetadata(iter.Ins)
-		if ok || fn != nil {
-			goto marshal
-		}
-	}
-
-	return nil, nil, nil, nil
-
-marshal:
-	var b Builder
-	var fiBuf, liBuf bytes.Buffer
-	for {
-		if fn := FuncMetadata(iter.Ins); fn != nil {
-			fi := &funcInfo{
-				fn:     fn,
-				offset: iter.Offset,
-			}
-			if err := fi.marshal(&fiBuf, &b); err != nil {
-				return nil, nil, nil, fmt.Errorf("write func info: %w", err)
-			}
-		}
-
-		if line, ok := iter.Ins.Source().(*Line); ok {
-			li := &lineInfo{
-				line:   line,
-				offset: iter.Offset,
-			}
-			if err := li.marshal(&liBuf, &b); err != nil {
-				return nil, nil, nil, fmt.Errorf("write line info: %w", err)
-			}
-		}
-
-		if !iter.Next() {
-			break
-		}
-	}
-
-	handle, err := NewHandle(&b)
-	return handle, fiBuf.Bytes(), liBuf.Bytes(), err
-}
-
-// btfExtHeader is found at the start of the .BTF.ext section.
-type btfExtHeader struct {
-	Magic   uint16
-	Version uint8
-	Flags   uint8
-
-	// HdrLen is larger than the size of struct btfExtHeader when it is
-	// immediately followed by a btfExtCOREHeader.
-	HdrLen uint32
-
-	FuncInfoOff uint32
-	FuncInfoLen uint32
-	LineInfoOff uint32
-	LineInfoLen uint32
-}
-
-// parseBTFExtHeader parses the header of the .BTF.ext section.
-func parseBTFExtHeader(r io.Reader, bo binary.ByteOrder) (*btfExtHeader, error) {
-	var header btfExtHeader
-	if err := binary.Read(r, bo, &header); err != nil {
-		return nil, fmt.Errorf("can't read header: %v", err)
-	}
-
-	if header.Magic != btfMagic {
-		return nil, fmt.Errorf("incorrect magic value %v", header.Magic)
-	}
-
-	if header.Version != 1 {
-		return nil, fmt.Errorf("unexpected version %v", header.Version)
-	}
-
-	if header.Flags != 0 {
-		return nil, fmt.Errorf("unsupported flags %v", header.Flags)
-	}
-
-	if int64(header.HdrLen) < int64(binary.Size(&header)) {
-		return nil, fmt.Errorf("header length shorter than btfExtHeader size")
-	}
-
-	return &header, nil
-}
-
-// funcInfoStart returns the offset from the beginning of the .BTF.ext section
-// to the start of its func_info entries.
-func (h *btfExtHeader) funcInfoStart() int64 {
-	return int64(h.HdrLen + h.FuncInfoOff)
-}
-
-// lineInfoStart returns the offset from the beginning of the .BTF.ext section
-// to the start of its line_info entries.
-func (h *btfExtHeader) lineInfoStart() int64 {
-	return int64(h.HdrLen + h.LineInfoOff)
-}
-
-// coreReloStart returns the offset from the beginning of the .BTF.ext section
-// to the start of its CO-RE relocation entries.
-func (h *btfExtHeader) coreReloStart(ch *btfExtCOREHeader) int64 {
-	return int64(h.HdrLen + ch.COREReloOff)
-}
-
-// btfExtCOREHeader is found right after the btfExtHeader when its HdrLen
-// field is larger than its size.
-type btfExtCOREHeader struct {
-	COREReloOff uint32
-	COREReloLen uint32
-}
-
-// parseBTFExtCOREHeader parses the tail of the .BTF.ext header. If additional
-// header bytes are present, extHeader.HdrLen will be larger than the struct,
-// indicating the presence of a CO-RE extension header.
-func parseBTFExtCOREHeader(r io.Reader, bo binary.ByteOrder, extHeader *btfExtHeader) (*btfExtCOREHeader, error) {
-	extHdrSize := int64(binary.Size(&extHeader))
-	remainder := int64(extHeader.HdrLen) - extHdrSize
-
-	if remainder == 0 {
-		return nil, nil
-	}
-
-	var coreHeader btfExtCOREHeader
-	if err := binary.Read(r, bo, &coreHeader); err != nil {
-		return nil, fmt.Errorf("can't read header: %v", err)
-	}
-
-	return &coreHeader, nil
-}
-
-type btfExtInfoSec struct {
-	SecNameOff uint32
-	NumInfo    uint32
-}
-
-// parseExtInfoSec parses a btf_ext_info_sec header within .BTF.ext,
-// appearing within func_info and line_info sub-sections.
-// These headers appear once for each program section in the ELF and are
-// followed by one or more func/line_info records for the section.
-func parseExtInfoSec(r io.Reader, bo binary.ByteOrder, strings *stringTable) (string, *btfExtInfoSec, error) {
-	var infoHeader btfExtInfoSec
-	if err := binary.Read(r, bo, &infoHeader); err != nil {
-		return "", nil, fmt.Errorf("read ext info header: %w", err)
-	}
-
-	secName, err := strings.Lookup(infoHeader.SecNameOff)
-	if err != nil {
-		return "", nil, fmt.Errorf("get section name: %w", err)
-	}
-	if secName == "" {
-		return "", nil, fmt.Errorf("extinfo header refers to empty section name")
-	}
-
-	if infoHeader.NumInfo == 0 {
-		return "", nil, fmt.Errorf("section %s has zero records", secName)
-	}
-
-	return secName, &infoHeader, nil
-}
-
-// parseExtInfoRecordSize parses the uint32 at the beginning of a func_infos
-// or line_infos segment that describes the length of all extInfoRecords in
-// that segment.
-func parseExtInfoRecordSize(r io.Reader, bo binary.ByteOrder) (uint32, error) {
-	const maxRecordSize = 256
-
-	var recordSize uint32
-	if err := binary.Read(r, bo, &recordSize); err != nil {
-		return 0, fmt.Errorf("can't read record size: %v", err)
-	}
-
-	if recordSize < 4 {
-		// Need at least InsnOff worth of bytes per record.
-		return 0, errors.New("record size too short")
-	}
-	if recordSize > maxRecordSize {
-		return 0, fmt.Errorf("record size %v exceeds %v", recordSize, maxRecordSize)
-	}
-
-	return recordSize, nil
-}
-
-// The size of a FuncInfo in BTF wire format.
-var FuncInfoSize = uint32(binary.Size(bpfFuncInfo{}))
-
-type funcInfo struct {
-	fn     *Func
-	offset asm.RawInstructionOffset
-}
-
-type bpfFuncInfo struct {
-	// Instruction offset of the function within an ELF section.
-	InsnOff uint32
-	TypeID  TypeID
-}
-
-func newFuncInfo(fi bpfFuncInfo, spec *Spec) (*funcInfo, error) {
-	typ, err := spec.TypeByID(fi.TypeID)
-	if err != nil {
-		return nil, err
-	}
-
-	fn, ok := typ.(*Func)
-	if !ok {
-		return nil, fmt.Errorf("type ID %d is a %T, but expected a Func", fi.TypeID, typ)
-	}
-
-	// C doesn't have anonymous functions, but check just in case.
-	if fn.Name == "" {
-		return nil, fmt.Errorf("func with type ID %d doesn't have a name", fi.TypeID)
-	}
-
-	return &funcInfo{
-		fn,
-		asm.RawInstructionOffset(fi.InsnOff),
-	}, nil
-}
-
-func newFuncInfos(bfis []bpfFuncInfo, spec *Spec) ([]funcInfo, error) {
-	fis := make([]funcInfo, 0, len(bfis))
-	for _, bfi := range bfis {
-		fi, err := newFuncInfo(bfi, spec)
-		if err != nil {
-			return nil, fmt.Errorf("offset %d: %w", bfi.InsnOff, err)
-		}
-		fis = append(fis, *fi)
-	}
-	sort.Slice(fis, func(i, j int) bool {
-		return fis[i].offset <= fis[j].offset
-	})
-	return fis, nil
-}
-
-// marshal into the BTF wire format.
-func (fi *funcInfo) marshal(w *bytes.Buffer, b *Builder) error {
-	id, err := b.Add(fi.fn)
-	if err != nil {
-		return err
-	}
-	bfi := bpfFuncInfo{
-		InsnOff: uint32(fi.offset),
-		TypeID:  id,
-	}
-	buf := make([]byte, FuncInfoSize)
-	internal.NativeEndian.PutUint32(buf, bfi.InsnOff)
-	internal.NativeEndian.PutUint32(buf[4:], uint32(bfi.TypeID))
-	_, err = w.Write(buf)
-	return err
-}
-
-// parseFuncInfos parses a func_info sub-section within .BTF.ext ito a map of
-// func infos indexed by section name.
-func parseFuncInfos(r io.Reader, bo binary.ByteOrder, strings *stringTable) (map[string][]bpfFuncInfo, error) {
-	recordSize, err := parseExtInfoRecordSize(r, bo)
-	if err != nil {
-		return nil, err
-	}
-
-	result := make(map[string][]bpfFuncInfo)
-	for {
-		secName, infoHeader, err := parseExtInfoSec(r, bo, strings)
-		if errors.Is(err, io.EOF) {
-			return result, nil
-		}
-		if err != nil {
-			return nil, err
-		}
-
-		records, err := parseFuncInfoRecords(r, bo, recordSize, infoHeader.NumInfo)
-		if err != nil {
-			return nil, fmt.Errorf("section %v: %w", secName, err)
-		}
-
-		result[secName] = records
-	}
-}
-
-// parseFuncInfoRecords parses a stream of func_infos into a funcInfos.
-// These records appear after a btf_ext_info_sec header in the func_info
-// sub-section of .BTF.ext.
-func parseFuncInfoRecords(r io.Reader, bo binary.ByteOrder, recordSize uint32, recordNum uint32) ([]bpfFuncInfo, error) {
-	var out []bpfFuncInfo
-	var fi bpfFuncInfo
-
-	if exp, got := FuncInfoSize, recordSize; exp != got {
-		// BTF blob's record size is longer than we know how to parse.
-		return nil, fmt.Errorf("expected FuncInfo record size %d, but BTF blob contains %d", exp, got)
-	}
-
-	for i := uint32(0); i < recordNum; i++ {
-		if err := binary.Read(r, bo, &fi); err != nil {
-			return nil, fmt.Errorf("can't read function info: %v", err)
-		}
-
-		if fi.InsnOff%asm.InstructionSize != 0 {
-			return nil, fmt.Errorf("offset %v is not aligned with instruction size", fi.InsnOff)
-		}
-
-		// ELF tracks offset in bytes, the kernel expects raw BPF instructions.
-		// Convert as early as possible.
-		fi.InsnOff /= asm.InstructionSize
-
-		out = append(out, fi)
-	}
-
-	return out, nil
-}
-
-var LineInfoSize = uint32(binary.Size(bpfLineInfo{}))
-
-// Line represents the location and contents of a single line of source
-// code a BPF ELF was compiled from.
-type Line struct {
-	fileName   string
-	line       string
-	lineNumber uint32
-	lineColumn uint32
-}
-
-func (li *Line) FileName() string {
-	return li.fileName
-}
-
-func (li *Line) Line() string {
-	return li.line
-}
-
-func (li *Line) LineNumber() uint32 {
-	return li.lineNumber
-}
-
-func (li *Line) LineColumn() uint32 {
-	return li.lineColumn
-}
-
-func (li *Line) String() string {
-	return li.line
-}
-
-type lineInfo struct {
-	line   *Line
-	offset asm.RawInstructionOffset
-}
-
-// Constants for the format of bpfLineInfo.LineCol.
-const (
-	bpfLineShift = 10
-	bpfLineMax   = (1 << (32 - bpfLineShift)) - 1
-	bpfColumnMax = (1 << bpfLineShift) - 1
-)
-
-type bpfLineInfo struct {
-	// Instruction offset of the line within the whole instruction stream, in instructions.
-	InsnOff     uint32
-	FileNameOff uint32
-	LineOff     uint32
-	LineCol     uint32
-}
-
-func newLineInfo(li bpfLineInfo, strings *stringTable) (*lineInfo, error) {
-	line, err := strings.Lookup(li.LineOff)
-	if err != nil {
-		return nil, fmt.Errorf("lookup of line: %w", err)
-	}
-
-	fileName, err := strings.Lookup(li.FileNameOff)
-	if err != nil {
-		return nil, fmt.Errorf("lookup of filename: %w", err)
-	}
-
-	lineNumber := li.LineCol >> bpfLineShift
-	lineColumn := li.LineCol & bpfColumnMax
-
-	return &lineInfo{
-		&Line{
-			fileName,
-			line,
-			lineNumber,
-			lineColumn,
-		},
-		asm.RawInstructionOffset(li.InsnOff),
-	}, nil
-}
-
-func newLineInfos(blis []bpfLineInfo, strings *stringTable) ([]lineInfo, error) {
-	lis := make([]lineInfo, 0, len(blis))
-	for _, bli := range blis {
-		li, err := newLineInfo(bli, strings)
-		if err != nil {
-			return nil, fmt.Errorf("offset %d: %w", bli.InsnOff, err)
-		}
-		lis = append(lis, *li)
-	}
-	sort.Slice(lis, func(i, j int) bool {
-		return lis[i].offset <= lis[j].offset
-	})
-	return lis, nil
-}
-
-// marshal writes the binary representation of the LineInfo to w.
-func (li *lineInfo) marshal(w *bytes.Buffer, b *Builder) error {
-	line := li.line
-	if line.lineNumber > bpfLineMax {
-		return fmt.Errorf("line %d exceeds %d", line.lineNumber, bpfLineMax)
-	}
-
-	if line.lineColumn > bpfColumnMax {
-		return fmt.Errorf("column %d exceeds %d", line.lineColumn, bpfColumnMax)
-	}
-
-	fileNameOff, err := b.addString(line.fileName)
-	if err != nil {
-		return fmt.Errorf("file name %q: %w", line.fileName, err)
-	}
-
-	lineOff, err := b.addString(line.line)
-	if err != nil {
-		return fmt.Errorf("line %q: %w", line.line, err)
-	}
-
-	bli := bpfLineInfo{
-		uint32(li.offset),
-		fileNameOff,
-		lineOff,
-		(line.lineNumber << bpfLineShift) | line.lineColumn,
-	}
-
-	buf := make([]byte, LineInfoSize)
-	internal.NativeEndian.PutUint32(buf, bli.InsnOff)
-	internal.NativeEndian.PutUint32(buf[4:], bli.FileNameOff)
-	internal.NativeEndian.PutUint32(buf[8:], bli.LineOff)
-	internal.NativeEndian.PutUint32(buf[12:], bli.LineCol)
-	_, err = w.Write(buf)
-	return err
-}
-
-// parseLineInfos parses a line_info sub-section within .BTF.ext ito a map of
-// line infos indexed by section name.
-func parseLineInfos(r io.Reader, bo binary.ByteOrder, strings *stringTable) (map[string][]bpfLineInfo, error) {
-	recordSize, err := parseExtInfoRecordSize(r, bo)
-	if err != nil {
-		return nil, err
-	}
-
-	result := make(map[string][]bpfLineInfo)
-	for {
-		secName, infoHeader, err := parseExtInfoSec(r, bo, strings)
-		if errors.Is(err, io.EOF) {
-			return result, nil
-		}
-		if err != nil {
-			return nil, err
-		}
-
-		records, err := parseLineInfoRecords(r, bo, recordSize, infoHeader.NumInfo)
-		if err != nil {
-			return nil, fmt.Errorf("section %v: %w", secName, err)
-		}
-
-		result[secName] = records
-	}
-}
-
-// parseLineInfoRecords parses a stream of line_infos into a lineInfos.
-// These records appear after a btf_ext_info_sec header in the line_info
-// sub-section of .BTF.ext.
-func parseLineInfoRecords(r io.Reader, bo binary.ByteOrder, recordSize uint32, recordNum uint32) ([]bpfLineInfo, error) {
-	var out []bpfLineInfo
-	var li bpfLineInfo
-
-	if exp, got := uint32(binary.Size(li)), recordSize; exp != got {
-		// BTF blob's record size is longer than we know how to parse.
-		return nil, fmt.Errorf("expected LineInfo record size %d, but BTF blob contains %d", exp, got)
-	}
-
-	for i := uint32(0); i < recordNum; i++ {
-		if err := binary.Read(r, bo, &li); err != nil {
-			return nil, fmt.Errorf("can't read line info: %v", err)
-		}
-
-		if li.InsnOff%asm.InstructionSize != 0 {
-			return nil, fmt.Errorf("offset %v is not aligned with instruction size", li.InsnOff)
-		}
-
-		// ELF tracks offset in bytes, the kernel expects raw BPF instructions.
-		// Convert as early as possible.
-		li.InsnOff /= asm.InstructionSize
-
-		out = append(out, li)
-	}
-
-	return out, nil
-}
-
-// bpfCORERelo matches the kernel's struct bpf_core_relo.
-type bpfCORERelo struct {
-	InsnOff      uint32
-	TypeID       TypeID
-	AccessStrOff uint32
-	Kind         coreKind
-}
-
-type CORERelocation struct {
-	// The local type of the relocation, stripped of typedefs and qualifiers.
-	typ      Type
-	accessor coreAccessor
-	kind     coreKind
-	// The ID of the local type in the source BTF.
-	id TypeID
-}
-
-func (cr *CORERelocation) String() string {
-	return fmt.Sprintf("CORERelocation(%s, %s[%s], local_id=%d)", cr.kind, cr.typ, cr.accessor, cr.id)
-}
-
-func CORERelocationMetadata(ins *asm.Instruction) *CORERelocation {
-	relo, _ := ins.Metadata.Get(coreRelocationMeta{}).(*CORERelocation)
-	return relo
-}
-
-type coreRelocationInfo struct {
-	relo   *CORERelocation
-	offset asm.RawInstructionOffset
-}
-
-func newRelocationInfo(relo bpfCORERelo, spec *Spec, strings *stringTable) (*coreRelocationInfo, error) {
-	typ, err := spec.TypeByID(relo.TypeID)
-	if err != nil {
-		return nil, err
-	}
-
-	accessorStr, err := strings.Lookup(relo.AccessStrOff)
-	if err != nil {
-		return nil, err
-	}
-
-	accessor, err := parseCOREAccessor(accessorStr)
-	if err != nil {
-		return nil, fmt.Errorf("accessor %q: %s", accessorStr, err)
-	}
-
-	return &coreRelocationInfo{
-		&CORERelocation{
-			typ,
-			accessor,
-			relo.Kind,
-			relo.TypeID,
-		},
-		asm.RawInstructionOffset(relo.InsnOff),
-	}, nil
-}
-
-func newRelocationInfos(brs []bpfCORERelo, spec *Spec, strings *stringTable) ([]coreRelocationInfo, error) {
-	rs := make([]coreRelocationInfo, 0, len(brs))
-	for _, br := range brs {
-		relo, err := newRelocationInfo(br, spec, strings)
-		if err != nil {
-			return nil, fmt.Errorf("offset %d: %w", br.InsnOff, err)
-		}
-		rs = append(rs, *relo)
-	}
-	sort.Slice(rs, func(i, j int) bool {
-		return rs[i].offset < rs[j].offset
-	})
-	return rs, nil
-}
-
-var extInfoReloSize = binary.Size(bpfCORERelo{})
-
-// parseCORERelos parses a core_relos sub-section within .BTF.ext ito a map of
-// CO-RE relocations indexed by section name.
-func parseCORERelos(r io.Reader, bo binary.ByteOrder, strings *stringTable) (map[string][]bpfCORERelo, error) {
-	recordSize, err := parseExtInfoRecordSize(r, bo)
-	if err != nil {
-		return nil, err
-	}
-
-	if recordSize != uint32(extInfoReloSize) {
-		return nil, fmt.Errorf("expected record size %d, got %d", extInfoReloSize, recordSize)
-	}
-
-	result := make(map[string][]bpfCORERelo)
-	for {
-		secName, infoHeader, err := parseExtInfoSec(r, bo, strings)
-		if errors.Is(err, io.EOF) {
-			return result, nil
-		}
-		if err != nil {
-			return nil, err
-		}
-
-		records, err := parseCOREReloRecords(r, bo, recordSize, infoHeader.NumInfo)
-		if err != nil {
-			return nil, fmt.Errorf("section %v: %w", secName, err)
-		}
-
-		result[secName] = records
-	}
-}
-
-// parseCOREReloRecords parses a stream of CO-RE relocation entries into a
-// coreRelos. These records appear after a btf_ext_info_sec header in the
-// core_relos sub-section of .BTF.ext.
-func parseCOREReloRecords(r io.Reader, bo binary.ByteOrder, recordSize uint32, recordNum uint32) ([]bpfCORERelo, error) {
-	var out []bpfCORERelo
-
-	var relo bpfCORERelo
-	for i := uint32(0); i < recordNum; i++ {
-		if err := binary.Read(r, bo, &relo); err != nil {
-			return nil, fmt.Errorf("can't read CO-RE relocation: %v", err)
-		}
-
-		if relo.InsnOff%asm.InstructionSize != 0 {
-			return nil, fmt.Errorf("offset %v is not aligned with instruction size", relo.InsnOff)
-		}
-
-		// ELF tracks offset in bytes, the kernel expects raw BPF instructions.
-		// Convert as early as possible.
-		relo.InsnOff /= asm.InstructionSize
-
-		out = append(out, relo)
-	}
-
-	return out, nil
-}
diff --git a/vendor/github.com/cilium/ebpf/btf/format.go b/vendor/github.com/cilium/ebpf/btf/format.go
deleted file mode 100644
index e85220259..000000000
--- a/vendor/github.com/cilium/ebpf/btf/format.go
+++ /dev/null
@@ -1,344 +0,0 @@
-package btf
-
-import (
-	"errors"
-	"fmt"
-	"strings"
-)
-
-var errNestedTooDeep = errors.New("nested too deep")
-
-// GoFormatter converts a Type to Go syntax.
-//
-// A zero GoFormatter is valid to use.
-type GoFormatter struct {
-	w strings.Builder
-
-	// Types present in this map are referred to using the given name if they
-	// are encountered when outputting another type.
-	Names map[Type]string
-
-	// Identifier is called for each field of struct-like types. By default the
-	// field name is used as is.
-	Identifier func(string) string
-
-	// EnumIdentifier is called for each element of an enum. By default the
-	// name of the enum type is concatenated with Identifier(element).
-	EnumIdentifier func(name, element string) string
-}
-
-// TypeDeclaration generates a Go type declaration for a BTF type.
-func (gf *GoFormatter) TypeDeclaration(name string, typ Type) (string, error) {
-	gf.w.Reset()
-	if err := gf.writeTypeDecl(name, typ); err != nil {
-		return "", err
-	}
-	return gf.w.String(), nil
-}
-
-func (gf *GoFormatter) identifier(s string) string {
-	if gf.Identifier != nil {
-		return gf.Identifier(s)
-	}
-
-	return s
-}
-
-func (gf *GoFormatter) enumIdentifier(name, element string) string {
-	if gf.EnumIdentifier != nil {
-		return gf.EnumIdentifier(name, element)
-	}
-
-	return name + gf.identifier(element)
-}
-
-// writeTypeDecl outputs a declaration of the given type.
-//
-// It encodes https://golang.org/ref/spec#Type_declarations:
-//
-//	type foo struct { bar uint32; }
-//	type bar int32
-func (gf *GoFormatter) writeTypeDecl(name string, typ Type) error {
-	if name == "" {
-		return fmt.Errorf("need a name for type %s", typ)
-	}
-
-	typ = skipQualifiers(typ)
-	fmt.Fprintf(&gf.w, "type %s ", name)
-	if err := gf.writeTypeLit(typ, 0); err != nil {
-		return err
-	}
-
-	e, ok := typ.(*Enum)
-	if !ok || len(e.Values) == 0 {
-		return nil
-	}
-
-	gf.w.WriteString("; const ( ")
-	for _, ev := range e.Values {
-		id := gf.enumIdentifier(name, ev.Name)
-		fmt.Fprintf(&gf.w, "%s %s = %d; ", id, name, ev.Value)
-	}
-	gf.w.WriteString(")")
-
-	return nil
-}
-
-// writeType outputs the name of a named type or a literal describing the type.
-//
-// It encodes https://golang.org/ref/spec#Types.
-//
-//	foo                  (if foo is a named type)
-//	uint32
-func (gf *GoFormatter) writeType(typ Type, depth int) error {
-	typ = skipQualifiers(typ)
-
-	name := gf.Names[typ]
-	if name != "" {
-		gf.w.WriteString(name)
-		return nil
-	}
-
-	return gf.writeTypeLit(typ, depth)
-}
-
-// writeTypeLit outputs a literal describing the type.
-//
-// The function ignores named types.
-//
-// It encodes https://golang.org/ref/spec#TypeLit.
-//
-//	struct { bar uint32; }
-//	uint32
-func (gf *GoFormatter) writeTypeLit(typ Type, depth int) error {
-	depth++
-	if depth > maxTypeDepth {
-		return errNestedTooDeep
-	}
-
-	var err error
-	switch v := skipQualifiers(typ).(type) {
-	case *Int:
-		err = gf.writeIntLit(v)
-
-	case *Enum:
-		if !v.Signed {
-			gf.w.WriteRune('u')
-		}
-		switch v.Size {
-		case 1:
-			gf.w.WriteString("int8")
-		case 2:
-			gf.w.WriteString("int16")
-		case 4:
-			gf.w.WriteString("int32")
-		case 8:
-			gf.w.WriteString("int64")
-		default:
-			err = fmt.Errorf("invalid enum size %d", v.Size)
-		}
-
-	case *Typedef:
-		err = gf.writeType(v.Type, depth)
-
-	case *Array:
-		fmt.Fprintf(&gf.w, "[%d]", v.Nelems)
-		err = gf.writeType(v.Type, depth)
-
-	case *Struct:
-		err = gf.writeStructLit(v.Size, v.Members, depth)
-
-	case *Union:
-		// Always choose the first member to represent the union in Go.
-		err = gf.writeStructLit(v.Size, v.Members[:1], depth)
-
-	case *Datasec:
-		err = gf.writeDatasecLit(v, depth)
-
-	default:
-		return fmt.Errorf("type %T: %w", v, ErrNotSupported)
-	}
-
-	if err != nil {
-		return fmt.Errorf("%s: %w", typ, err)
-	}
-
-	return nil
-}
-
-func (gf *GoFormatter) writeIntLit(i *Int) error {
-	bits := i.Size * 8
-	switch i.Encoding {
-	case Bool:
-		if i.Size != 1 {
-			return fmt.Errorf("bool with size %d", i.Size)
-		}
-		gf.w.WriteString("bool")
-	case Char:
-		if i.Size != 1 {
-			return fmt.Errorf("char with size %d", i.Size)
-		}
-		// BTF doesn't have a way to specify the signedness of a char. Assume
-		// we are dealing with unsigned, since this works nicely with []byte
-		// in Go code.
-		fallthrough
-	case Unsigned, Signed:
-		stem := "uint"
-		if i.Encoding == Signed {
-			stem = "int"
-		}
-		if i.Size > 8 {
-			fmt.Fprintf(&gf.w, "[%d]byte /* %s%d */", i.Size, stem, i.Size*8)
-		} else {
-			fmt.Fprintf(&gf.w, "%s%d", stem, bits)
-		}
-	default:
-		return fmt.Errorf("can't encode %s", i.Encoding)
-	}
-	return nil
-}
-
-func (gf *GoFormatter) writeStructLit(size uint32, members []Member, depth int) error {
-	gf.w.WriteString("struct { ")
-
-	prevOffset := uint32(0)
-	skippedBitfield := false
-	for i, m := range members {
-		if m.BitfieldSize > 0 {
-			skippedBitfield = true
-			continue
-		}
-
-		offset := m.Offset.Bytes()
-		if n := offset - prevOffset; skippedBitfield && n > 0 {
-			fmt.Fprintf(&gf.w, "_ [%d]byte /* unsupported bitfield */; ", n)
-		} else {
-			gf.writePadding(n)
-		}
-
-		fieldSize, err := Sizeof(m.Type)
-		if err != nil {
-			return fmt.Errorf("field %d: %w", i, err)
-		}
-
-		prevOffset = offset + uint32(fieldSize)
-		if prevOffset > size {
-			return fmt.Errorf("field %d of size %d exceeds type size %d", i, fieldSize, size)
-		}
-
-		if err := gf.writeStructField(m, depth); err != nil {
-			return fmt.Errorf("field %d: %w", i, err)
-		}
-	}
-
-	gf.writePadding(size - prevOffset)
-	gf.w.WriteString("}")
-	return nil
-}
-
-func (gf *GoFormatter) writeStructField(m Member, depth int) error {
-	if m.BitfieldSize > 0 {
-		return fmt.Errorf("bitfields are not supported")
-	}
-	if m.Offset%8 != 0 {
-		return fmt.Errorf("unsupported offset %d", m.Offset)
-	}
-
-	if m.Name == "" {
-		// Special case a nested anonymous union like
-		//     struct foo { union { int bar; int baz }; }
-		// by replacing the whole union with its first member.
-		union, ok := m.Type.(*Union)
-		if !ok {
-			return fmt.Errorf("anonymous fields are not supported")
-
-		}
-
-		if len(union.Members) == 0 {
-			return errors.New("empty anonymous union")
-		}
-
-		depth++
-		if depth > maxTypeDepth {
-			return errNestedTooDeep
-		}
-
-		m := union.Members[0]
-		size, err := Sizeof(m.Type)
-		if err != nil {
-			return err
-		}
-
-		if err := gf.writeStructField(m, depth); err != nil {
-			return err
-		}
-
-		gf.writePadding(union.Size - uint32(size))
-		return nil
-
-	}
-
-	fmt.Fprintf(&gf.w, "%s ", gf.identifier(m.Name))
-
-	if err := gf.writeType(m.Type, depth); err != nil {
-		return err
-	}
-
-	gf.w.WriteString("; ")
-	return nil
-}
-
-func (gf *GoFormatter) writeDatasecLit(ds *Datasec, depth int) error {
-	gf.w.WriteString("struct { ")
-
-	prevOffset := uint32(0)
-	for i, vsi := range ds.Vars {
-		v, ok := vsi.Type.(*Var)
-		if !ok {
-			return fmt.Errorf("can't format %s as part of data section", vsi.Type)
-		}
-
-		if v.Linkage != GlobalVar {
-			// Ignore static, extern, etc. for now.
-			continue
-		}
-
-		if v.Name == "" {
-			return fmt.Errorf("variable %d: empty name", i)
-		}
-
-		gf.writePadding(vsi.Offset - prevOffset)
-		prevOffset = vsi.Offset + vsi.Size
-
-		fmt.Fprintf(&gf.w, "%s ", gf.identifier(v.Name))
-
-		if err := gf.writeType(v.Type, depth); err != nil {
-			return fmt.Errorf("variable %d: %w", i, err)
-		}
-
-		gf.w.WriteString("; ")
-	}
-
-	gf.writePadding(ds.Size - prevOffset)
-	gf.w.WriteString("}")
-	return nil
-}
-
-func (gf *GoFormatter) writePadding(bytes uint32) {
-	if bytes > 0 {
-		fmt.Fprintf(&gf.w, "_ [%d]byte; ", bytes)
-	}
-}
-
-func skipQualifiers(typ Type) Type {
-	result := typ
-	for depth := 0; depth <= maxTypeDepth; depth++ {
-		switch v := (result).(type) {
-		case qualifier:
-			result = v.qualify()
-		default:
-			return result
-		}
-	}
-	return &cycle{typ}
-}
diff --git a/vendor/github.com/cilium/ebpf/btf/handle.go b/vendor/github.com/cilium/ebpf/btf/handle.go
deleted file mode 100644
index b6b3e87f5..000000000
--- a/vendor/github.com/cilium/ebpf/btf/handle.go
+++ /dev/null
@@ -1,287 +0,0 @@
-package btf
-
-import (
-	"bytes"
-	"errors"
-	"fmt"
-	"math"
-	"os"
-
-	"github.com/cilium/ebpf/internal"
-	"github.com/cilium/ebpf/internal/sys"
-	"github.com/cilium/ebpf/internal/unix"
-)
-
-// Handle is a reference to BTF loaded into the kernel.
-type Handle struct {
-	fd *sys.FD
-
-	// Size of the raw BTF in bytes.
-	size uint32
-
-	needsKernelBase bool
-}
-
-// NewHandle loads the contents of a [Builder] into the kernel.
-//
-// Returns an error wrapping ErrNotSupported if the kernel doesn't support BTF.
-func NewHandle(b *Builder) (*Handle, error) {
-	small := getByteSlice()
-	defer putByteSlice(small)
-
-	buf, err := b.Marshal(*small, KernelMarshalOptions())
-	if err != nil {
-		return nil, fmt.Errorf("marshal BTF: %w", err)
-	}
-
-	return NewHandleFromRawBTF(buf)
-}
-
-// NewHandleFromRawBTF loads raw BTF into the kernel.
-//
-// Returns an error wrapping ErrNotSupported if the kernel doesn't support BTF.
-func NewHandleFromRawBTF(btf []byte) (*Handle, error) {
-	if uint64(len(btf)) > math.MaxUint32 {
-		return nil, errors.New("BTF exceeds the maximum size")
-	}
-
-	attr := &sys.BtfLoadAttr{
-		Btf:     sys.NewSlicePointer(btf),
-		BtfSize: uint32(len(btf)),
-	}
-
-	fd, err := sys.BtfLoad(attr)
-	if err == nil {
-		return &Handle{fd, attr.BtfSize, false}, nil
-	}
-
-	if err := haveBTF(); err != nil {
-		return nil, err
-	}
-
-	logBuf := make([]byte, 64*1024)
-	attr.BtfLogBuf = sys.NewSlicePointer(logBuf)
-	attr.BtfLogSize = uint32(len(logBuf))
-	attr.BtfLogLevel = 1
-
-	// Up until at least kernel 6.0, the BTF verifier does not return ENOSPC
-	// if there are other verification errors. ENOSPC is only returned when
-	// the BTF blob is correct, a log was requested, and the provided buffer
-	// is too small.
-	_, ve := sys.BtfLoad(attr)
-	return nil, internal.ErrorWithLog("load btf", err, logBuf, errors.Is(ve, unix.ENOSPC))
-}
-
-// NewHandleFromID returns the BTF handle for a given id.
-//
-// Prefer calling [ebpf.Program.Handle] or [ebpf.Map.Handle] if possible.
-//
-// Returns ErrNotExist, if there is no BTF with the given id.
-//
-// Requires CAP_SYS_ADMIN.
-func NewHandleFromID(id ID) (*Handle, error) {
-	fd, err := sys.BtfGetFdById(&sys.BtfGetFdByIdAttr{
-		Id: uint32(id),
-	})
-	if err != nil {
-		return nil, fmt.Errorf("get FD for ID %d: %w", id, err)
-	}
-
-	info, err := newHandleInfoFromFD(fd)
-	if err != nil {
-		_ = fd.Close()
-		return nil, err
-	}
-
-	return &Handle{fd, info.size, info.IsModule()}, nil
-}
-
-// Spec parses the kernel BTF into Go types.
-//
-// base must contain type information for vmlinux if the handle is for
-// a kernel module. It may be nil otherwise.
-func (h *Handle) Spec(base *Spec) (*Spec, error) {
-	var btfInfo sys.BtfInfo
-	btfBuffer := make([]byte, h.size)
-	btfInfo.Btf, btfInfo.BtfSize = sys.NewSlicePointerLen(btfBuffer)
-
-	if err := sys.ObjInfo(h.fd, &btfInfo); err != nil {
-		return nil, err
-	}
-
-	if h.needsKernelBase && base == nil {
-		return nil, fmt.Errorf("missing base types")
-	}
-
-	return loadRawSpec(bytes.NewReader(btfBuffer), internal.NativeEndian, base)
-}
-
-// Close destroys the handle.
-//
-// Subsequent calls to FD will return an invalid value.
-func (h *Handle) Close() error {
-	if h == nil {
-		return nil
-	}
-
-	return h.fd.Close()
-}
-
-// FD returns the file descriptor for the handle.
-func (h *Handle) FD() int {
-	return h.fd.Int()
-}
-
-// Info returns metadata about the handle.
-func (h *Handle) Info() (*HandleInfo, error) {
-	return newHandleInfoFromFD(h.fd)
-}
-
-// HandleInfo describes a Handle.
-type HandleInfo struct {
-	// ID of this handle in the kernel. The ID is only valid as long as the
-	// associated handle is kept alive.
-	ID ID
-
-	// Name is an identifying name for the BTF, currently only used by the
-	// kernel.
-	Name string
-
-	// IsKernel is true if the BTF originated with the kernel and not
-	// userspace.
-	IsKernel bool
-
-	// Size of the raw BTF in bytes.
-	size uint32
-}
-
-func newHandleInfoFromFD(fd *sys.FD) (*HandleInfo, error) {
-	// We invoke the syscall once with a empty BTF and name buffers to get size
-	// information to allocate buffers. Then we invoke it a second time with
-	// buffers to receive the data.
-	var btfInfo sys.BtfInfo
-	if err := sys.ObjInfo(fd, &btfInfo); err != nil {
-		return nil, fmt.Errorf("get BTF info for fd %s: %w", fd, err)
-	}
-
-	if btfInfo.NameLen > 0 {
-		// NameLen doesn't account for the terminating NUL.
-		btfInfo.NameLen++
-	}
-
-	// Don't pull raw BTF by default, since it may be quite large.
-	btfSize := btfInfo.BtfSize
-	btfInfo.BtfSize = 0
-
-	nameBuffer := make([]byte, btfInfo.NameLen)
-	btfInfo.Name, btfInfo.NameLen = sys.NewSlicePointerLen(nameBuffer)
-	if err := sys.ObjInfo(fd, &btfInfo); err != nil {
-		return nil, err
-	}
-
-	return &HandleInfo{
-		ID:       ID(btfInfo.Id),
-		Name:     unix.ByteSliceToString(nameBuffer),
-		IsKernel: btfInfo.KernelBtf != 0,
-		size:     btfSize,
-	}, nil
-}
-
-// IsVmlinux returns true if the BTF is for the kernel itself.
-func (i *HandleInfo) IsVmlinux() bool {
-	return i.IsKernel && i.Name == "vmlinux"
-}
-
-// IsModule returns true if the BTF is for a kernel module.
-func (i *HandleInfo) IsModule() bool {
-	return i.IsKernel && i.Name != "vmlinux"
-}
-
-// HandleIterator allows enumerating BTF blobs loaded into the kernel.
-type HandleIterator struct {
-	// The ID of the current handle. Only valid after a call to Next.
-	ID ID
-	// The current Handle. Only valid until a call to Next.
-	// See Take if you want to retain the handle.
-	Handle *Handle
-	err    error
-}
-
-// Next retrieves a handle for the next BTF object.
-//
-// Returns true if another BTF object was found. Call [HandleIterator.Err] after
-// the function returns false.
-func (it *HandleIterator) Next() bool {
-	id := it.ID
-	for {
-		attr := &sys.BtfGetNextIdAttr{Id: id}
-		err := sys.BtfGetNextId(attr)
-		if errors.Is(err, os.ErrNotExist) {
-			// There are no more BTF objects.
-			break
-		} else if err != nil {
-			it.err = fmt.Errorf("get next BTF ID: %w", err)
-			break
-		}
-
-		id = attr.NextId
-		handle, err := NewHandleFromID(id)
-		if errors.Is(err, os.ErrNotExist) {
-			// Try again with the next ID.
-			continue
-		} else if err != nil {
-			it.err = fmt.Errorf("retrieve handle for ID %d: %w", id, err)
-			break
-		}
-
-		it.Handle.Close()
-		it.ID, it.Handle = id, handle
-		return true
-	}
-
-	// No more handles or we encountered an error.
-	it.Handle.Close()
-	it.Handle = nil
-	return false
-}
-
-// Take the ownership of the current handle.
-//
-// It's the callers responsibility to close the handle.
-func (it *HandleIterator) Take() *Handle {
-	handle := it.Handle
-	it.Handle = nil
-	return handle
-}
-
-// Err returns an error if iteration failed for some reason.
-func (it *HandleIterator) Err() error {
-	return it.err
-}
-
-// FindHandle returns the first handle for which predicate returns true.
-//
-// Requires CAP_SYS_ADMIN.
-//
-// Returns an error wrapping ErrNotFound if predicate never returns true or if
-// there is no BTF loaded into the kernel.
-func FindHandle(predicate func(info *HandleInfo) bool) (*Handle, error) {
-	it := new(HandleIterator)
-	defer it.Handle.Close()
-
-	for it.Next() {
-		info, err := it.Handle.Info()
-		if err != nil {
-			return nil, fmt.Errorf("info for ID %d: %w", it.ID, err)
-		}
-
-		if predicate(info) {
-			return it.Take(), nil
-		}
-	}
-	if err := it.Err(); err != nil {
-		return nil, fmt.Errorf("iterate handles: %w", err)
-	}
-
-	return nil, fmt.Errorf("find handle: %w", ErrNotFound)
-}
diff --git a/vendor/github.com/cilium/ebpf/btf/marshal.go b/vendor/github.com/cilium/ebpf/btf/marshal.go
deleted file mode 100644
index bfe53b410..000000000
--- a/vendor/github.com/cilium/ebpf/btf/marshal.go
+++ /dev/null
@@ -1,543 +0,0 @@
-package btf
-
-import (
-	"bytes"
-	"encoding/binary"
-	"errors"
-	"fmt"
-	"math"
-	"sync"
-
-	"github.com/cilium/ebpf/internal"
-
-	"golang.org/x/exp/slices"
-)
-
-type MarshalOptions struct {
-	// Target byte order. Defaults to the system's native endianness.
-	Order binary.ByteOrder
-	// Remove function linkage information for compatibility with <5.6 kernels.
-	StripFuncLinkage bool
-}
-
-// KernelMarshalOptions will generate BTF suitable for the current kernel.
-func KernelMarshalOptions() *MarshalOptions {
-	return &MarshalOptions{
-		Order:            internal.NativeEndian,
-		StripFuncLinkage: haveFuncLinkage() != nil,
-	}
-}
-
-// encoder turns Types into raw BTF.
-type encoder struct {
-	MarshalOptions
-
-	pending internal.Deque[Type]
-	buf     *bytes.Buffer
-	strings *stringTableBuilder
-	ids     map[Type]TypeID
-	lastID  TypeID
-}
-
-var bufferPool = sync.Pool{
-	New: func() any {
-		buf := make([]byte, btfHeaderLen+128)
-		return &buf
-	},
-}
-
-func getByteSlice() *[]byte {
-	return bufferPool.Get().(*[]byte)
-}
-
-func putByteSlice(buf *[]byte) {
-	*buf = (*buf)[:0]
-	bufferPool.Put(buf)
-}
-
-// Builder turns Types into raw BTF.
-//
-// The default value may be used and represents an empty BTF blob. Void is
-// added implicitly if necessary.
-type Builder struct {
-	// Explicitly added types.
-	types []Type
-	// IDs for all added types which the user knows about.
-	stableIDs map[Type]TypeID
-	// Explicitly added strings.
-	strings *stringTableBuilder
-}
-
-// NewBuilder creates a Builder from a list of types.
-//
-// It is more efficient than calling [Add] individually.
-//
-// Returns an error if adding any of the types fails.
-func NewBuilder(types []Type) (*Builder, error) {
-	b := &Builder{
-		make([]Type, 0, len(types)),
-		make(map[Type]TypeID, len(types)),
-		nil,
-	}
-
-	for _, typ := range types {
-		_, err := b.Add(typ)
-		if err != nil {
-			return nil, fmt.Errorf("add %s: %w", typ, err)
-		}
-	}
-
-	return b, nil
-}
-
-// Add a Type and allocate a stable ID for it.
-//
-// Adding the identical Type multiple times is valid and will return the same ID.
-//
-// See [Type] for details on identity.
-func (b *Builder) Add(typ Type) (TypeID, error) {
-	if b.stableIDs == nil {
-		b.stableIDs = make(map[Type]TypeID)
-	}
-
-	if _, ok := typ.(*Void); ok {
-		// Equality is weird for void, since it is a zero sized type.
-		return 0, nil
-	}
-
-	if ds, ok := typ.(*Datasec); ok {
-		if err := datasecResolveWorkaround(b, ds); err != nil {
-			return 0, err
-		}
-	}
-
-	id, ok := b.stableIDs[typ]
-	if ok {
-		return id, nil
-	}
-
-	b.types = append(b.types, typ)
-
-	id = TypeID(len(b.types))
-	if int(id) != len(b.types) {
-		return 0, fmt.Errorf("no more type IDs")
-	}
-
-	b.stableIDs[typ] = id
-	return id, nil
-}
-
-// Marshal encodes all types in the Marshaler into BTF wire format.
-//
-// opts may be nil.
-func (b *Builder) Marshal(buf []byte, opts *MarshalOptions) ([]byte, error) {
-	stb := b.strings
-	if stb == nil {
-		// Assume that most types are named. This makes encoding large BTF like
-		// vmlinux a lot cheaper.
-		stb = newStringTableBuilder(len(b.types))
-	} else {
-		// Avoid modifying the Builder's string table.
-		stb = b.strings.Copy()
-	}
-
-	if opts == nil {
-		opts = &MarshalOptions{Order: internal.NativeEndian}
-	}
-
-	// Reserve space for the BTF header.
-	buf = slices.Grow(buf, btfHeaderLen)[:btfHeaderLen]
-
-	w := internal.NewBuffer(buf)
-	defer internal.PutBuffer(w)
-
-	e := encoder{
-		MarshalOptions: *opts,
-		buf:            w,
-		strings:        stb,
-		lastID:         TypeID(len(b.types)),
-		ids:            make(map[Type]TypeID, len(b.types)),
-	}
-
-	// Ensure that types are marshaled in the exact order they were Add()ed.
-	// Otherwise the ID returned from Add() won't match.
-	e.pending.Grow(len(b.types))
-	for _, typ := range b.types {
-		e.pending.Push(typ)
-		e.ids[typ] = b.stableIDs[typ]
-	}
-
-	if err := e.deflatePending(); err != nil {
-		return nil, err
-	}
-
-	length := e.buf.Len()
-	typeLen := uint32(length - btfHeaderLen)
-
-	stringLen := e.strings.Length()
-	buf = e.strings.AppendEncoded(e.buf.Bytes())
-
-	// Fill out the header, and write it out.
-	header := &btfHeader{
-		Magic:     btfMagic,
-		Version:   1,
-		Flags:     0,
-		HdrLen:    uint32(btfHeaderLen),
-		TypeOff:   0,
-		TypeLen:   typeLen,
-		StringOff: typeLen,
-		StringLen: uint32(stringLen),
-	}
-
-	err := binary.Write(sliceWriter(buf[:btfHeaderLen]), e.Order, header)
-	if err != nil {
-		return nil, fmt.Errorf("write header: %v", err)
-	}
-
-	return buf, nil
-}
-
-// addString adds a string to the resulting BTF.
-//
-// Adding the same string multiple times will return the same result.
-//
-// Returns an identifier into the string table or an error if the string
-// contains invalid characters.
-func (b *Builder) addString(str string) (uint32, error) {
-	if b.strings == nil {
-		b.strings = newStringTableBuilder(0)
-	}
-
-	return b.strings.Add(str)
-}
-
-func (e *encoder) allocateID(typ Type) error {
-	id := e.lastID + 1
-	if id < e.lastID {
-		return errors.New("type ID overflow")
-	}
-
-	e.pending.Push(typ)
-	e.ids[typ] = id
-	e.lastID = id
-	return nil
-}
-
-// id returns the ID for the given type or panics with an error.
-func (e *encoder) id(typ Type) TypeID {
-	if _, ok := typ.(*Void); ok {
-		return 0
-	}
-
-	id, ok := e.ids[typ]
-	if !ok {
-		panic(fmt.Errorf("no ID for type %v", typ))
-	}
-
-	return id
-}
-
-func (e *encoder) deflatePending() error {
-	// Declare root outside of the loop to avoid repeated heap allocations.
-	var root Type
-	skip := func(t Type) (skip bool) {
-		if t == root {
-			// Force descending into the current root type even if it already
-			// has an ID. Otherwise we miss children of types that have their
-			// ID pre-allocated via Add.
-			return false
-		}
-
-		_, isVoid := t.(*Void)
-		_, alreadyEncoded := e.ids[t]
-		return isVoid || alreadyEncoded
-	}
-
-	for !e.pending.Empty() {
-		root = e.pending.Shift()
-
-		// Allocate IDs for all children of typ, including transitive dependencies.
-		iter := postorderTraversal(root, skip)
-		for iter.Next() {
-			if iter.Type == root {
-				// The iterator yields root at the end, do not allocate another ID.
-				break
-			}
-
-			if err := e.allocateID(iter.Type); err != nil {
-				return err
-			}
-		}
-
-		if err := e.deflateType(root); err != nil {
-			id := e.ids[root]
-			return fmt.Errorf("deflate %v with ID %d: %w", root, id, err)
-		}
-	}
-
-	return nil
-}
-
-func (e *encoder) deflateType(typ Type) (err error) {
-	defer func() {
-		if r := recover(); r != nil {
-			var ok bool
-			err, ok = r.(error)
-			if !ok {
-				panic(r)
-			}
-		}
-	}()
-
-	var raw rawType
-	raw.NameOff, err = e.strings.Add(typ.TypeName())
-	if err != nil {
-		return err
-	}
-
-	switch v := typ.(type) {
-	case *Void:
-		return errors.New("Void is implicit in BTF wire format")
-
-	case *Int:
-		raw.SetKind(kindInt)
-		raw.SetSize(v.Size)
-
-		var bi btfInt
-		bi.SetEncoding(v.Encoding)
-		// We need to set bits in addition to size, since btf_type_int_is_regular
-		// otherwise flags this as a bitfield.
-		bi.SetBits(byte(v.Size) * 8)
-		raw.data = bi
-
-	case *Pointer:
-		raw.SetKind(kindPointer)
-		raw.SetType(e.id(v.Target))
-
-	case *Array:
-		raw.SetKind(kindArray)
-		raw.data = &btfArray{
-			e.id(v.Type),
-			e.id(v.Index),
-			v.Nelems,
-		}
-
-	case *Struct:
-		raw.SetKind(kindStruct)
-		raw.SetSize(v.Size)
-		raw.data, err = e.convertMembers(&raw.btfType, v.Members)
-
-	case *Union:
-		raw.SetKind(kindUnion)
-		raw.SetSize(v.Size)
-		raw.data, err = e.convertMembers(&raw.btfType, v.Members)
-
-	case *Enum:
-		raw.SetSize(v.size())
-		raw.SetVlen(len(v.Values))
-		raw.SetSigned(v.Signed)
-
-		if v.has64BitValues() {
-			raw.SetKind(kindEnum64)
-			raw.data, err = e.deflateEnum64Values(v.Values)
-		} else {
-			raw.SetKind(kindEnum)
-			raw.data, err = e.deflateEnumValues(v.Values)
-		}
-
-	case *Fwd:
-		raw.SetKind(kindForward)
-		raw.SetFwdKind(v.Kind)
-
-	case *Typedef:
-		raw.SetKind(kindTypedef)
-		raw.SetType(e.id(v.Type))
-
-	case *Volatile:
-		raw.SetKind(kindVolatile)
-		raw.SetType(e.id(v.Type))
-
-	case *Const:
-		raw.SetKind(kindConst)
-		raw.SetType(e.id(v.Type))
-
-	case *Restrict:
-		raw.SetKind(kindRestrict)
-		raw.SetType(e.id(v.Type))
-
-	case *Func:
-		raw.SetKind(kindFunc)
-		raw.SetType(e.id(v.Type))
-		if !e.StripFuncLinkage {
-			raw.SetLinkage(v.Linkage)
-		}
-
-	case *FuncProto:
-		raw.SetKind(kindFuncProto)
-		raw.SetType(e.id(v.Return))
-		raw.SetVlen(len(v.Params))
-		raw.data, err = e.deflateFuncParams(v.Params)
-
-	case *Var:
-		raw.SetKind(kindVar)
-		raw.SetType(e.id(v.Type))
-		raw.data = btfVariable{uint32(v.Linkage)}
-
-	case *Datasec:
-		raw.SetKind(kindDatasec)
-		raw.SetSize(v.Size)
-		raw.SetVlen(len(v.Vars))
-		raw.data = e.deflateVarSecinfos(v.Vars)
-
-	case *Float:
-		raw.SetKind(kindFloat)
-		raw.SetSize(v.Size)
-
-	case *declTag:
-		raw.SetKind(kindDeclTag)
-		raw.SetType(e.id(v.Type))
-		raw.data = &btfDeclTag{uint32(v.Index)}
-		raw.NameOff, err = e.strings.Add(v.Value)
-
-	case *typeTag:
-		raw.SetKind(kindTypeTag)
-		raw.SetType(e.id(v.Type))
-		raw.NameOff, err = e.strings.Add(v.Value)
-
-	default:
-		return fmt.Errorf("don't know how to deflate %T", v)
-	}
-
-	if err != nil {
-		return err
-	}
-
-	return raw.Marshal(e.buf, e.Order)
-}
-
-func (e *encoder) convertMembers(header *btfType, members []Member) ([]btfMember, error) {
-	bms := make([]btfMember, 0, len(members))
-	isBitfield := false
-	for _, member := range members {
-		isBitfield = isBitfield || member.BitfieldSize > 0
-
-		offset := member.Offset
-		if isBitfield {
-			offset = member.BitfieldSize<<24 | (member.Offset & 0xffffff)
-		}
-
-		nameOff, err := e.strings.Add(member.Name)
-		if err != nil {
-			return nil, err
-		}
-
-		bms = append(bms, btfMember{
-			nameOff,
-			e.id(member.Type),
-			uint32(offset),
-		})
-	}
-
-	header.SetVlen(len(members))
-	header.SetBitfield(isBitfield)
-	return bms, nil
-}
-
-func (e *encoder) deflateEnumValues(values []EnumValue) ([]btfEnum, error) {
-	bes := make([]btfEnum, 0, len(values))
-	for _, value := range values {
-		nameOff, err := e.strings.Add(value.Name)
-		if err != nil {
-			return nil, err
-		}
-
-		if value.Value > math.MaxUint32 {
-			return nil, fmt.Errorf("value of enum %q exceeds 32 bits", value.Name)
-		}
-
-		bes = append(bes, btfEnum{
-			nameOff,
-			uint32(value.Value),
-		})
-	}
-
-	return bes, nil
-}
-
-func (e *encoder) deflateEnum64Values(values []EnumValue) ([]btfEnum64, error) {
-	bes := make([]btfEnum64, 0, len(values))
-	for _, value := range values {
-		nameOff, err := e.strings.Add(value.Name)
-		if err != nil {
-			return nil, err
-		}
-
-		bes = append(bes, btfEnum64{
-			nameOff,
-			uint32(value.Value),
-			uint32(value.Value >> 32),
-		})
-	}
-
-	return bes, nil
-}
-
-func (e *encoder) deflateFuncParams(params []FuncParam) ([]btfParam, error) {
-	bps := make([]btfParam, 0, len(params))
-	for _, param := range params {
-		nameOff, err := e.strings.Add(param.Name)
-		if err != nil {
-			return nil, err
-		}
-
-		bps = append(bps, btfParam{
-			nameOff,
-			e.id(param.Type),
-		})
-	}
-	return bps, nil
-}
-
-func (e *encoder) deflateVarSecinfos(vars []VarSecinfo) []btfVarSecinfo {
-	vsis := make([]btfVarSecinfo, 0, len(vars))
-	for _, v := range vars {
-		vsis = append(vsis, btfVarSecinfo{
-			e.id(v.Type),
-			v.Offset,
-			v.Size,
-		})
-	}
-	return vsis
-}
-
-// MarshalMapKV creates a BTF object containing a map key and value.
-//
-// The function is intended for the use of the ebpf package and may be removed
-// at any point in time.
-func MarshalMapKV(key, value Type) (_ *Handle, keyID, valueID TypeID, err error) {
-	var b Builder
-
-	if key != nil {
-		keyID, err = b.Add(key)
-		if err != nil {
-			return nil, 0, 0, fmt.Errorf("add key type: %w", err)
-		}
-	}
-
-	if value != nil {
-		valueID, err = b.Add(value)
-		if err != nil {
-			return nil, 0, 0, fmt.Errorf("add value type: %w", err)
-		}
-	}
-
-	handle, err := NewHandle(&b)
-	if err != nil {
-		// Check for 'full' map BTF support, since kernels between 4.18 and 5.2
-		// already support BTF blobs for maps without Var or Datasec just fine.
-		if err := haveMapBTF(); err != nil {
-			return nil, 0, 0, err
-		}
-	}
-	return handle, keyID, valueID, err
-}
diff --git a/vendor/github.com/cilium/ebpf/btf/strings.go b/vendor/github.com/cilium/ebpf/btf/strings.go
deleted file mode 100644
index bc6aff281..000000000
--- a/vendor/github.com/cilium/ebpf/btf/strings.go
+++ /dev/null
@@ -1,214 +0,0 @@
-package btf
-
-import (
-	"bufio"
-	"bytes"
-	"errors"
-	"fmt"
-	"io"
-	"strings"
-
-	"golang.org/x/exp/maps"
-)
-
-type stringTable struct {
-	base    *stringTable
-	offsets []uint32
-	strings []string
-}
-
-// sizedReader is implemented by bytes.Reader, io.SectionReader, strings.Reader, etc.
-type sizedReader interface {
-	io.Reader
-	Size() int64
-}
-
-func readStringTable(r sizedReader, base *stringTable) (*stringTable, error) {
-	// When parsing split BTF's string table, the first entry offset is derived
-	// from the last entry offset of the base BTF.
-	firstStringOffset := uint32(0)
-	if base != nil {
-		idx := len(base.offsets) - 1
-		firstStringOffset = base.offsets[idx] + uint32(len(base.strings[idx])) + 1
-	}
-
-	// Derived from vmlinux BTF.
-	const averageStringLength = 16
-
-	n := int(r.Size() / averageStringLength)
-	offsets := make([]uint32, 0, n)
-	strings := make([]string, 0, n)
-
-	offset := firstStringOffset
-	scanner := bufio.NewScanner(r)
-	scanner.Split(splitNull)
-	for scanner.Scan() {
-		str := scanner.Text()
-		offsets = append(offsets, offset)
-		strings = append(strings, str)
-		offset += uint32(len(str)) + 1
-	}
-	if err := scanner.Err(); err != nil {
-		return nil, err
-	}
-
-	if len(strings) == 0 {
-		return nil, errors.New("string table is empty")
-	}
-
-	if firstStringOffset == 0 && strings[0] != "" {
-		return nil, errors.New("first item in string table is non-empty")
-	}
-
-	return &stringTable{base, offsets, strings}, nil
-}
-
-func splitNull(data []byte, atEOF bool) (advance int, token []byte, err error) {
-	i := bytes.IndexByte(data, 0)
-	if i == -1 {
-		if atEOF && len(data) > 0 {
-			return 0, nil, errors.New("string table isn't null terminated")
-		}
-		return 0, nil, nil
-	}
-
-	return i + 1, data[:i], nil
-}
-
-func (st *stringTable) Lookup(offset uint32) (string, error) {
-	if st.base != nil && offset <= st.base.offsets[len(st.base.offsets)-1] {
-		return st.base.lookup(offset)
-	}
-	return st.lookup(offset)
-}
-
-func (st *stringTable) lookup(offset uint32) (string, error) {
-	i := search(st.offsets, offset)
-	if i == len(st.offsets) || st.offsets[i] != offset {
-		return "", fmt.Errorf("offset %d isn't start of a string", offset)
-	}
-
-	return st.strings[i], nil
-}
-
-func (st *stringTable) Marshal(w io.Writer) error {
-	for _, str := range st.strings {
-		_, err := io.WriteString(w, str)
-		if err != nil {
-			return err
-		}
-		_, err = w.Write([]byte{0})
-		if err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-// Num returns the number of strings in the table.
-func (st *stringTable) Num() int {
-	return len(st.strings)
-}
-
-// search is a copy of sort.Search specialised for uint32.
-//
-// Licensed under https://go.dev/LICENSE
-func search(ints []uint32, needle uint32) int {
-	// Define f(-1) == false and f(n) == true.
-	// Invariant: f(i-1) == false, f(j) == true.
-	i, j := 0, len(ints)
-	for i < j {
-		h := int(uint(i+j) >> 1) // avoid overflow when computing h
-		// i ≤ h < j
-		if !(ints[h] >= needle) {
-			i = h + 1 // preserves f(i-1) == false
-		} else {
-			j = h // preserves f(j) == true
-		}
-	}
-	// i == j, f(i-1) == false, and f(j) (= f(i)) == true  =>  answer is i.
-	return i
-}
-
-// stringTableBuilder builds BTF string tables.
-type stringTableBuilder struct {
-	length  uint32
-	strings map[string]uint32
-}
-
-// newStringTableBuilder creates a builder with the given capacity.
-//
-// capacity may be zero.
-func newStringTableBuilder(capacity int) *stringTableBuilder {
-	var stb stringTableBuilder
-
-	if capacity == 0 {
-		// Use the runtime's small default size.
-		stb.strings = make(map[string]uint32)
-	} else {
-		stb.strings = make(map[string]uint32, capacity)
-	}
-
-	// Ensure that the empty string is at index 0.
-	stb.append("")
-	return &stb
-}
-
-// Add a string to the table.
-//
-// Adding the same string multiple times will only store it once.
-func (stb *stringTableBuilder) Add(str string) (uint32, error) {
-	if strings.IndexByte(str, 0) != -1 {
-		return 0, fmt.Errorf("string contains null: %q", str)
-	}
-
-	offset, ok := stb.strings[str]
-	if ok {
-		return offset, nil
-	}
-
-	return stb.append(str), nil
-}
-
-func (stb *stringTableBuilder) append(str string) uint32 {
-	offset := stb.length
-	stb.length += uint32(len(str)) + 1
-	stb.strings[str] = offset
-	return offset
-}
-
-// Lookup finds the offset of a string in the table.
-//
-// Returns an error if str hasn't been added yet.
-func (stb *stringTableBuilder) Lookup(str string) (uint32, error) {
-	offset, ok := stb.strings[str]
-	if !ok {
-		return 0, fmt.Errorf("string %q is not in table", str)
-	}
-
-	return offset, nil
-}
-
-// Length returns the length in bytes.
-func (stb *stringTableBuilder) Length() int {
-	return int(stb.length)
-}
-
-// AppendEncoded appends the string table to the end of the provided buffer.
-func (stb *stringTableBuilder) AppendEncoded(buf []byte) []byte {
-	n := len(buf)
-	buf = append(buf, make([]byte, stb.Length())...)
-	strings := buf[n:]
-	for str, offset := range stb.strings {
-		copy(strings[offset:], str)
-	}
-	return buf
-}
-
-// Copy the string table builder.
-func (stb *stringTableBuilder) Copy() *stringTableBuilder {
-	return &stringTableBuilder{
-		stb.length,
-		maps.Clone(stb.strings),
-	}
-}
diff --git a/vendor/github.com/cilium/ebpf/btf/traversal.go b/vendor/github.com/cilium/ebpf/btf/traversal.go
deleted file mode 100644
index a3a9dec94..000000000
--- a/vendor/github.com/cilium/ebpf/btf/traversal.go
+++ /dev/null
@@ -1,141 +0,0 @@
-package btf
-
-import (
-	"fmt"
-
-	"github.com/cilium/ebpf/internal"
-)
-
-// Functions to traverse a cyclic graph of types. The below was very useful:
-// https://eli.thegreenplace.net/2015/directed-graph-traversal-orderings-and-applications-to-data-flow-analysis/#post-order-and-reverse-post-order
-
-type postorderIterator struct {
-	// Iteration skips types for which this function returns true.
-	skip func(Type) bool
-	// The root type. May be nil if skip(root) is true.
-	root Type
-
-	// Contains types which need to be either walked or yielded.
-	types typeDeque
-	// Contains a boolean whether the type has been walked or not.
-	walked internal.Deque[bool]
-	// The set of types which has been pushed onto types.
-	pushed map[Type]struct{}
-
-	// The current type. Only valid after a call to Next().
-	Type Type
-}
-
-// postorderTraversal iterates all types reachable from root by visiting the
-// leaves of the graph first.
-//
-// Types for which skip returns true are ignored. skip may be nil.
-func postorderTraversal(root Type, skip func(Type) (skip bool)) postorderIterator {
-	// Avoid allocations for the common case of a skipped root.
-	if skip != nil && skip(root) {
-		return postorderIterator{}
-	}
-
-	po := postorderIterator{root: root, skip: skip}
-	walkType(root, po.push)
-
-	return po
-}
-
-func (po *postorderIterator) push(t *Type) {
-	if _, ok := po.pushed[*t]; ok || *t == po.root {
-		return
-	}
-
-	if po.skip != nil && po.skip(*t) {
-		return
-	}
-
-	if po.pushed == nil {
-		// Lazily allocate pushed to avoid an allocation for Types without children.
-		po.pushed = make(map[Type]struct{})
-	}
-
-	po.pushed[*t] = struct{}{}
-	po.types.Push(t)
-	po.walked.Push(false)
-}
-
-// Next returns true if there is another Type to traverse.
-func (po *postorderIterator) Next() bool {
-	for !po.types.Empty() {
-		t := po.types.Pop()
-
-		if !po.walked.Pop() {
-			// Push the type again, so that we re-evaluate it in done state
-			// after all children have been handled.
-			po.types.Push(t)
-			po.walked.Push(true)
-
-			// Add all direct children to todo.
-			walkType(*t, po.push)
-		} else {
-			// We've walked this type previously, so we now know that all
-			// children have been handled.
-			po.Type = *t
-			return true
-		}
-	}
-
-	// Only return root once.
-	po.Type, po.root = po.root, nil
-	return po.Type != nil
-}
-
-// walkType calls fn on each child of typ.
-func walkType(typ Type, fn func(*Type)) {
-	// Explicitly type switch on the most common types to allow the inliner to
-	// do its work. This avoids allocating intermediate slices from walk() on
-	// the heap.
-	switch v := typ.(type) {
-	case *Void, *Int, *Enum, *Fwd, *Float:
-		// No children to traverse.
-	case *Pointer:
-		fn(&v.Target)
-	case *Array:
-		fn(&v.Index)
-		fn(&v.Type)
-	case *Struct:
-		for i := range v.Members {
-			fn(&v.Members[i].Type)
-		}
-	case *Union:
-		for i := range v.Members {
-			fn(&v.Members[i].Type)
-		}
-	case *Typedef:
-		fn(&v.Type)
-	case *Volatile:
-		fn(&v.Type)
-	case *Const:
-		fn(&v.Type)
-	case *Restrict:
-		fn(&v.Type)
-	case *Func:
-		fn(&v.Type)
-	case *FuncProto:
-		fn(&v.Return)
-		for i := range v.Params {
-			fn(&v.Params[i].Type)
-		}
-	case *Var:
-		fn(&v.Type)
-	case *Datasec:
-		for i := range v.Vars {
-			fn(&v.Vars[i].Type)
-		}
-	case *declTag:
-		fn(&v.Type)
-	case *typeTag:
-		fn(&v.Type)
-	case *cycle:
-		// cycle has children, but we ignore them deliberately.
-	default:
-		panic(fmt.Sprintf("don't know how to walk Type %T", v))
-	}
-}
diff --git a/vendor/github.com/cilium/ebpf/btf/types.go b/vendor/github.com/cilium/ebpf/btf/types.go
deleted file mode 100644
index 68d4a1757..000000000
--- a/vendor/github.com/cilium/ebpf/btf/types.go
+++ /dev/null
@@ -1,1258 +0,0 @@
-package btf
-
-import (
-	"errors"
-	"fmt"
-	"io"
-	"math"
-	"reflect"
-	"strings"
-
-	"github.com/cilium/ebpf/asm"
-	"github.com/cilium/ebpf/internal"
-	"github.com/cilium/ebpf/internal/sys"
-)
-
-const maxTypeDepth = 32
-
-// TypeID identifies a type in a BTF section.
-type TypeID = sys.TypeID
-
-// Type represents a type described by BTF.
-//
-// Identity of Type follows the [Go specification]: two Types are considered
-// equal if they have the same concrete type and the same dynamic value, aka
-// they point at the same location in memory. This means that the following
-// Types are considered distinct even though they have the same "shape".
-//
-//	a := &Int{Size: 1}
-//	b := &Int{Size: 1}
-//	a != b
-//
-// [Go specification]: https://go.dev/ref/spec#Comparison_operators
-type Type interface {
-	// Type can be formatted using the %s and %v verbs. %s outputs only the
-	// identity of the type, without any detail. %v outputs additional detail.
-	//
-	// Use the '+' flag to include the address of the type.
-	//
-	// Use the width to specify how many levels of detail to output, for example
-	// %1v will output detail for the root type and a short description of its
-	// children. %2v would output details of the root type and its children
-	// as well as a short description of the grandchildren.
-	fmt.Formatter
-
-	// Name of the type, empty for anonymous types and types that cannot
-	// carry a name, like Void and Pointer.
-	TypeName() string
-
-	// Make a copy of the type, without copying Type members.
-	copy() Type
-
-	// New implementations must update walkType.
-}
-
-var (
-	_ Type = (*Int)(nil)
-	_ Type = (*Struct)(nil)
-	_ Type = (*Union)(nil)
-	_ Type = (*Enum)(nil)
-	_ Type = (*Fwd)(nil)
-	_ Type = (*Func)(nil)
-	_ Type = (*Typedef)(nil)
-	_ Type = (*Var)(nil)
-	_ Type = (*Datasec)(nil)
-	_ Type = (*Float)(nil)
-	_ Type = (*declTag)(nil)
-	_ Type = (*typeTag)(nil)
-	_ Type = (*cycle)(nil)
-)
-
-// Void is the unit type of BTF.
-type Void struct{}
-
-func (v *Void) Format(fs fmt.State, verb rune) { formatType(fs, verb, v) }
-func (v *Void) TypeName() string               { return "" }
-func (v *Void) size() uint32                   { return 0 }
-func (v *Void) copy() Type                     { return (*Void)(nil) }
-
-type IntEncoding byte
-
-// Valid IntEncodings.
-//
-// These may look like they are flags, but they aren't.
-const (
-	Unsigned IntEncoding = 0
-	Signed   IntEncoding = 1
-	Char     IntEncoding = 2
-	Bool     IntEncoding = 4
-)
-
-func (ie IntEncoding) String() string {
-	switch ie {
-	case Char:
-		// NB: There is no way to determine signedness for char.
-		return "char"
-	case Bool:
-		return "bool"
-	case Signed:
-		return "signed"
-	case Unsigned:
-		return "unsigned"
-	default:
-		return fmt.Sprintf("IntEncoding(%d)", byte(ie))
-	}
-}
-
-// Int is an integer of a given length.
-//
-// See https://www.kernel.org/doc/html/latest/bpf/btf.html#btf-kind-int
-type Int struct {
-	Name string
-
-	// The size of the integer in bytes.
-	Size     uint32
-	Encoding IntEncoding
-}
-
-func (i *Int) Format(fs fmt.State, verb rune) {
-	formatType(fs, verb, i, i.Encoding, "size=", i.Size*8)
-}
-
-func (i *Int) TypeName() string { return i.Name }
-func (i *Int) size() uint32     { return i.Size }
-func (i *Int) copy() Type {
-	cpy := *i
-	return &cpy
-}
-
-// Pointer is a pointer to another type.
-type Pointer struct {
-	Target Type
-}
-
-func (p *Pointer) Format(fs fmt.State, verb rune) {
-	formatType(fs, verb, p, "target=", p.Target)
-}
-
-func (p *Pointer) TypeName() string { return "" }
-func (p *Pointer) size() uint32     { return 8 }
-func (p *Pointer) copy() Type {
-	cpy := *p
-	return &cpy
-}
-
-// Array is an array with a fixed number of elements.
-type Array struct {
-	Index  Type
-	Type   Type
-	Nelems uint32
-}
-
-func (arr *Array) Format(fs fmt.State, verb rune) {
-	formatType(fs, verb, arr, "index=", arr.Index, "type=", arr.Type, "n=", arr.Nelems)
-}
-
-func (arr *Array) TypeName() string { return "" }
-
-func (arr *Array) copy() Type {
-	cpy := *arr
-	return &cpy
-}
-
-// Struct is a compound type of consecutive members.
-type Struct struct {
-	Name string
-	// The size of the struct including padding, in bytes
-	Size    uint32
-	Members []Member
-}
-
-func (s *Struct) Format(fs fmt.State, verb rune) {
-	formatType(fs, verb, s, "fields=", len(s.Members))
-}
-
-func (s *Struct) TypeName() string { return s.Name }
-
-func (s *Struct) size() uint32 { return s.Size }
-
-func (s *Struct) copy() Type {
-	cpy := *s
-	cpy.Members = copyMembers(s.Members)
-	return &cpy
-}
-
-func (s *Struct) members() []Member {
-	return s.Members
-}
-
-// Union is a compound type where members occupy the same memory.
-type Union struct {
-	Name string
-	// The size of the union including padding, in bytes.
-	Size    uint32
-	Members []Member
-}
-
-func (u *Union) Format(fs fmt.State, verb rune) {
-	formatType(fs, verb, u, "fields=", len(u.Members))
-}
-
-func (u *Union) TypeName() string { return u.Name }
-
-func (u *Union) size() uint32 { return u.Size }
-
-func (u *Union) copy() Type {
-	cpy := *u
-	cpy.Members = copyMembers(u.Members)
-	return &cpy
-}
-
-func (u *Union) members() []Member {
-	return u.Members
-}
-
-func copyMembers(orig []Member) []Member {
-	cpy := make([]Member, len(orig))
-	copy(cpy, orig)
-	return cpy
-}
-
-type composite interface {
-	Type
-	members() []Member
-}
-
-var (
-	_ composite = (*Struct)(nil)
-	_ composite = (*Union)(nil)
-)
-
-// A value in bits.
-type Bits uint32
-
-// Bytes converts a bit value into bytes.
-func (b Bits) Bytes() uint32 {
-	return uint32(b / 8)
-}
-
-// Member is part of a Struct or Union.
-//
-// It is not a valid Type.
-type Member struct {
-	Name         string
-	Type         Type
-	Offset       Bits
-	BitfieldSize Bits
-}
-
-// Enum lists possible values.
-type Enum struct {
-	Name string
-	// Size of the enum value in bytes.
-	Size uint32
-	// True if the values should be interpreted as signed integers.
-	Signed bool
-	Values []EnumValue
-}
-
-func (e *Enum) Format(fs fmt.State, verb rune) {
-	formatType(fs, verb, e, "size=", e.Size, "values=", len(e.Values))
-}
-
-func (e *Enum) TypeName() string { return e.Name }
-
-// EnumValue is part of an Enum
-//
-// Is is not a valid Type
-type EnumValue struct {
-	Name  string
-	Value uint64
-}
-
-func (e *Enum) size() uint32 { return e.Size }
-func (e *Enum) copy() Type {
-	cpy := *e
-	cpy.Values = make([]EnumValue, len(e.Values))
-	copy(cpy.Values, e.Values)
-	return &cpy
-}
-
-// has64BitValues returns true if the Enum contains a value larger than 32 bits.
-// Kernels before 6.0 have enum values that overrun u32 replaced with zeroes.
-//
-// 64-bit enums have their Enum.Size attributes correctly set to 8, but if we
-// use the size attribute as a heuristic during BTF marshaling, we'll emit
-// ENUM64s to kernels that don't support them.
-func (e *Enum) has64BitValues() bool {
-	for _, v := range e.Values {
-		if v.Value > math.MaxUint32 {
-			return true
-		}
-	}
-	return false
-}
-
-// FwdKind is the type of forward declaration.
-type FwdKind int
-
-// Valid types of forward declaration.
-const (
-	FwdStruct FwdKind = iota
-	FwdUnion
-)
-
-func (fk FwdKind) String() string {
-	switch fk {
-	case FwdStruct:
-		return "struct"
-	case FwdUnion:
-		return "union"
-	default:
-		return fmt.Sprintf("%T(%d)", fk, int(fk))
-	}
-}
-
-// Fwd is a forward declaration of a Type.
-type Fwd struct {
-	Name string
-	Kind FwdKind
-}
-
-func (f *Fwd) Format(fs fmt.State, verb rune) {
-	formatType(fs, verb, f, f.Kind)
-}
-
-func (f *Fwd) TypeName() string { return f.Name }
-
-func (f *Fwd) copy() Type {
-	cpy := *f
-	return &cpy
-}
-
-// Typedef is an alias of a Type.
-type Typedef struct {
-	Name string
-	Type Type
-}
-
-func (td *Typedef) Format(fs fmt.State, verb rune) {
-	formatType(fs, verb, td, td.Type)
-}
-
-func (td *Typedef) TypeName() string { return td.Name }
-
-func (td *Typedef) copy() Type {
-	cpy := *td
-	return &cpy
-}
-
-// Volatile is a qualifier.
-type Volatile struct {
-	Type Type
-}
-
-func (v *Volatile) Format(fs fmt.State, verb rune) {
-	formatType(fs, verb, v, v.Type)
-}
-
-func (v *Volatile) TypeName() string { return "" }
-
-func (v *Volatile) qualify() Type { return v.Type }
-func (v *Volatile) copy() Type {
-	cpy := *v
-	return &cpy
-}
-
-// Const is a qualifier.
-type Const struct {
-	Type Type
-}
-
-func (c *Const) Format(fs fmt.State, verb rune) {
-	formatType(fs, verb, c, c.Type)
-}
-
-func (c *Const) TypeName() string { return "" }
-
-func (c *Const) qualify() Type { return c.Type }
-func (c *Const) copy() Type {
-	cpy := *c
-	return &cpy
-}
-
-// Restrict is a qualifier.
-type Restrict struct {
-	Type Type
-}
-
-func (r *Restrict) Format(fs fmt.State, verb rune) {
-	formatType(fs, verb, r, r.Type)
-}
-
-func (r *Restrict) TypeName() string { return "" }
-
-func (r *Restrict) qualify() Type { return r.Type }
-func (r *Restrict) copy() Type {
-	cpy := *r
-	return &cpy
-}
-
-// Func is a function definition.
-type Func struct {
-	Name    string
-	Type    Type
-	Linkage FuncLinkage
-}
-
-func FuncMetadata(ins *asm.Instruction) *Func {
-	fn, _ := ins.Metadata.Get(funcInfoMeta{}).(*Func)
-	return fn
-}
-
-// WithFuncMetadata adds a btf.Func to the Metadata of asm.Instruction.
-func WithFuncMetadata(ins asm.Instruction, fn *Func) asm.Instruction {
-	ins.Metadata.Set(funcInfoMeta{}, fn)
-	return ins
-}
-
-func (f *Func) Format(fs fmt.State, verb rune) {
-	formatType(fs, verb, f, f.Linkage, "proto=", f.Type)
-}
-
-func (f *Func) TypeName() string { return f.Name }
-
-func (f *Func) copy() Type {
-	cpy := *f
-	return &cpy
-}
-
-// FuncProto is a function declaration.
-type FuncProto struct {
-	Return Type
-	Params []FuncParam
-}
-
-func (fp *FuncProto) Format(fs fmt.State, verb rune) {
-	formatType(fs, verb, fp, "args=", len(fp.Params), "return=", fp.Return)
-}
-
-func (fp *FuncProto) TypeName() string { return "" }
-
-func (fp *FuncProto) copy() Type {
-	cpy := *fp
-	cpy.Params = make([]FuncParam, len(fp.Params))
-	copy(cpy.Params, fp.Params)
-	return &cpy
-}
-
-type FuncParam struct {
-	Name string
-	Type Type
-}
-
-// Var is a global variable.
-type Var struct {
-	Name    string
-	Type    Type
-	Linkage VarLinkage
-}
-
-func (v *Var) Format(fs fmt.State, verb rune) {
-	formatType(fs, verb, v, v.Linkage)
-}
-
-func (v *Var) TypeName() string { return v.Name }
-
-func (v *Var) copy() Type {
-	cpy := *v
-	return &cpy
-}
-
-// Datasec is a global program section containing data.
-type Datasec struct {
-	Name string
-	Size uint32
-	Vars []VarSecinfo
-}
-
-func (ds *Datasec) Format(fs fmt.State, verb rune) {
-	formatType(fs, verb, ds)
-}
-
-func (ds *Datasec) TypeName() string { return ds.Name }
-
-func (ds *Datasec) size() uint32 { return ds.Size }
-
-func (ds *Datasec) copy() Type {
-	cpy := *ds
-	cpy.Vars = make([]VarSecinfo, len(ds.Vars))
-	copy(cpy.Vars, ds.Vars)
-	return &cpy
-}
-
-// VarSecinfo describes variable in a Datasec.
-//
-// It is not a valid Type.
-type VarSecinfo struct {
-	// Var or Func.
-	Type   Type
-	Offset uint32
-	Size   uint32
-}
-
-// Float is a float of a given length.
-type Float struct {
-	Name string
-
-	// The size of the float in bytes.
-	Size uint32
-}
-
-func (f *Float) Format(fs fmt.State, verb rune) {
-	formatType(fs, verb, f, "size=", f.Size*8)
-}
-
-func (f *Float) TypeName() string { return f.Name }
-func (f *Float) size() uint32     { return f.Size }
-func (f *Float) copy() Type {
-	cpy := *f
-	return &cpy
-}
-
-// declTag associates metadata with a declaration.
-type declTag struct {
-	Type  Type
-	Value string
-	// The index this tag refers to in the target type. For composite types,
-	// a value of -1 indicates that the tag refers to the whole type. Otherwise
-	// it indicates which member or argument the tag applies to.
-	Index int
-}
-
-func (dt *declTag) Format(fs fmt.State, verb rune) {
-	formatType(fs, verb, dt, "type=", dt.Type, "value=", dt.Value, "index=", dt.Index)
-}
-
-func (dt *declTag) TypeName() string { return "" }
-func (dt *declTag) copy() Type {
-	cpy := *dt
-	return &cpy
-}
-
-// typeTag associates metadata with a type.
-type typeTag struct {
-	Type  Type
-	Value string
-}
-
-func (tt *typeTag) Format(fs fmt.State, verb rune) {
-	formatType(fs, verb, tt, "type=", tt.Type, "value=", tt.Value)
-}
-
-func (tt *typeTag) TypeName() string { return "" }
-func (tt *typeTag) qualify() Type    { return tt.Type }
-func (tt *typeTag) copy() Type {
-	cpy := *tt
-	return &cpy
-}
-
-// cycle is a type which had to be elided since it exceeded maxTypeDepth.
-type cycle struct {
-	root Type
-}
-
-func (c *cycle) ID() TypeID                     { return math.MaxUint32 }
-func (c *cycle) Format(fs fmt.State, verb rune) { formatType(fs, verb, c, "root=", c.root) }
-func (c *cycle) TypeName() string               { return "" }
-func (c *cycle) copy() Type {
-	cpy := *c
-	return &cpy
-}
-
-type sizer interface {
-	size() uint32
-}
-
-var (
-	_ sizer = (*Int)(nil)
-	_ sizer = (*Pointer)(nil)
-	_ sizer = (*Struct)(nil)
-	_ sizer = (*Union)(nil)
-	_ sizer = (*Enum)(nil)
-	_ sizer = (*Datasec)(nil)
-)
-
-type qualifier interface {
-	qualify() Type
-}
-
-var (
-	_ qualifier = (*Const)(nil)
-	_ qualifier = (*Restrict)(nil)
-	_ qualifier = (*Volatile)(nil)
-	_ qualifier = (*typeTag)(nil)
-)
-
-var errUnsizedType = errors.New("type is unsized")
-
-// Sizeof returns the size of a type in bytes.
-//
-// Returns an error if the size can't be computed.
-func Sizeof(typ Type) (int, error) {
-	var (
-		n    = int64(1)
-		elem int64
-	)
-
-	for i := 0; i < maxTypeDepth; i++ {
-		switch v := typ.(type) {
-		case *Array:
-			if n > 0 && int64(v.Nelems) > math.MaxInt64/n {
-				return 0, fmt.Errorf("type %s: overflow", typ)
-			}
-
-			// Arrays may be of zero length, which allows
-			// n to be zero as well.
-			n *= int64(v.Nelems)
-			typ = v.Type
-			continue
-
-		case sizer:
-			elem = int64(v.size())
-
-		case *Typedef:
-			typ = v.Type
-			continue
-
-		case qualifier:
-			typ = v.qualify()
-			continue
-
-		default:
-			return 0, fmt.Errorf("type %T: %w", typ, errUnsizedType)
-		}
-
-		if n > 0 && elem > math.MaxInt64/n {
-			return 0, fmt.Errorf("type %s: overflow", typ)
-		}
-
-		size := n * elem
-		if int64(int(size)) != size {
-			return 0, fmt.Errorf("type %s: overflow", typ)
-		}
-
-		return int(size), nil
-	}
-
-	return 0, fmt.Errorf("type %s: exceeded type depth", typ)
-}
-
-// alignof returns the alignment of a type.
-//
-// Returns an error if the Type can't be aligned, like an integer with an uneven
-// size. Currently only supports the subset of types necessary for bitfield
-// relocations.
-func alignof(typ Type) (int, error) {
-	var n int
-
-	switch t := UnderlyingType(typ).(type) {
-	case *Enum:
-		n = int(t.size())
-	case *Int:
-		n = int(t.Size)
-	case *Array:
-		return alignof(t.Type)
-	default:
-		return 0, fmt.Errorf("can't calculate alignment of %T", t)
-	}
-
-	if !pow(n) {
-		return 0, fmt.Errorf("alignment value %d is not a power of two", n)
-	}
-
-	return n, nil
-}
-
-// pow returns true if n is a power of two.
-func pow(n int) bool {
-	return n != 0 && (n&(n-1)) == 0
-}
-
-// Transformer modifies a given Type and returns the result.
-//
-// For example, UnderlyingType removes any qualifiers or typedefs from a type.
-// See the example on Copy for how to use a transform.
-type Transformer func(Type) Type
-
-// Copy a Type recursively.
-//
-// typ may form a cycle. If transform is not nil, it is called with the
-// to be copied type, and the returned value is copied instead.
-func Copy(typ Type, transform Transformer) Type {
-	copies := copier{copies: make(map[Type]Type)}
-	copies.copy(&typ, transform)
-	return typ
-}
-
-// copy a slice of Types recursively.
-//
-// See Copy for the semantics.
-func copyTypes(types []Type, transform Transformer) []Type {
-	result := make([]Type, len(types))
-	copy(result, types)
-
-	copies := copier{copies: make(map[Type]Type, len(types))}
-	for i := range result {
-		copies.copy(&result[i], transform)
-	}
-
-	return result
-}
-
-type copier struct {
-	copies map[Type]Type
-	work   typeDeque
-}
-
-func (c *copier) copy(typ *Type, transform Transformer) {
-	for t := typ; t != nil; t = c.work.Pop() {
-		// *t is the identity of the type.
-		if cpy := c.copies[*t]; cpy != nil {
-			*t = cpy
-			continue
-		}
-
-		var cpy Type
-		if transform != nil {
-			cpy = transform(*t).copy()
-		} else {
-			cpy = (*t).copy()
-		}
-
-		c.copies[*t] = cpy
-		*t = cpy
-
-		// Mark any nested types for copying.
-		walkType(cpy, c.work.Push)
-	}
-}
-
-type typeDeque = internal.Deque[*Type]
-
-// inflateRawTypes takes a list of raw btf types linked via type IDs, and turns
-// it into a graph of Types connected via pointers.
-//
-// If base is provided, then the raw types are considered to be of a split BTF
-// (e.g., a kernel module).
-//
-// Returns a slice of types indexed by TypeID. Since BTF ignores compilation
-// units, multiple types may share the same name. A Type may form a cyclic graph
-// by pointing at itself.
-func inflateRawTypes(rawTypes []rawType, rawStrings *stringTable, base *Spec) ([]Type, error) {
-	types := make([]Type, 0, len(rawTypes)+1) // +1 for Void added to base types
-
-	// Void is defined to always be type ID 0, and is thus omitted from BTF.
-	types = append(types, (*Void)(nil))
-
-	firstTypeID := TypeID(0)
-	if base != nil {
-		var err error
-		firstTypeID, err = base.nextTypeID()
-		if err != nil {
-			return nil, err
-		}
-
-		// Split BTF doesn't contain Void.
-		types = types[:0]
-	}
-
-	type fixupDef struct {
-		id  TypeID
-		typ *Type
-	}
-
-	var fixups []fixupDef
-	fixup := func(id TypeID, typ *Type) bool {
-		if id < firstTypeID {
-			if baseType, err := base.TypeByID(id); err == nil {
-				*typ = baseType
-				return true
-			}
-		}
-
-		idx := int(id - firstTypeID)
-		if idx < len(types) {
-			// We've already inflated this type, fix it up immediately.
-			*typ = types[idx]
-			return true
-		}
-
-		fixups = append(fixups, fixupDef{id, typ})
-		return false
-	}
-
-	type assertion struct {
-		id   TypeID
-		typ  *Type
-		want reflect.Type
-	}
-
-	var assertions []assertion
-	fixupAndAssert := func(id TypeID, typ *Type, want reflect.Type) error {
-		if !fixup(id, typ) {
-			assertions = append(assertions, assertion{id, typ, want})
-			return nil
-		}
-
-		// The type has already been fixed up, check the type immediately.
-		if reflect.TypeOf(*typ) != want {
-			return fmt.Errorf("type ID %d: expected %s, got %T", id, want, *typ)
-		}
-		return nil
-	}
-
-	type bitfieldFixupDef struct {
-		id TypeID
-		m  *Member
-	}
-
-	var (
-		legacyBitfields = make(map[TypeID][2]Bits) // offset, size
-		bitfieldFixups  []bitfieldFixupDef
-	)
-	convertMembers := func(raw []btfMember, kindFlag bool) ([]Member, error) {
-		// NB: The fixup below relies on pre-allocating this array to
-		// work, since otherwise append might re-allocate members.
-		members := make([]Member, 0, len(raw))
-		for i, btfMember := range raw {
-			name, err := rawStrings.Lookup(btfMember.NameOff)
-			if err != nil {
-				return nil, fmt.Errorf("can't get name for member %d: %w", i, err)
-			}
-
-			members = append(members, Member{
-				Name:   name,
-				Offset: Bits(btfMember.Offset),
-			})
-
-			m := &members[i]
-			fixup(raw[i].Type, &m.Type)
-
-			if kindFlag {
-				m.BitfieldSize = Bits(btfMember.Offset >> 24)
-				m.Offset &= 0xffffff
-				// We ignore legacy bitfield definitions if the current composite
-				// is a new-style bitfield. This is kind of safe since offset and
-				// size on the type of the member must be zero if kindFlat is set
-				// according to spec.
-				continue
-			}
-
-			// This may be a legacy bitfield, try to fix it up.
-			data, ok := legacyBitfields[raw[i].Type]
-			if ok {
-				// Bingo!
-				m.Offset += data[0]
-				m.BitfieldSize = data[1]
-				continue
-			}
-
-			if m.Type != nil {
-				// We couldn't find a legacy bitfield, but we know that the member's
-				// type has already been inflated. Hence we know that it can't be
-				// a legacy bitfield and there is nothing left to do.
-				continue
-			}
-
-			// We don't have fixup data, and the type we're pointing
-			// at hasn't been inflated yet. No choice but to defer
-			// the fixup.
-			bitfieldFixups = append(bitfieldFixups, bitfieldFixupDef{
-				raw[i].Type,
-				m,
-			})
-		}
-		return members, nil
-	}
-
-	var declTags []*declTag
-	for _, raw := range rawTypes {
-		var (
-			id  = firstTypeID + TypeID(len(types))
-			typ Type
-		)
-
-		if id < firstTypeID {
-			return nil, fmt.Errorf("no more type IDs")
-		}
-
-		name, err := rawStrings.Lookup(raw.NameOff)
-		if err != nil {
-			return nil, fmt.Errorf("get name for type id %d: %w", id, err)
-		}
-
-		switch raw.Kind() {
-		case kindInt:
-			size := raw.Size()
-			bi := raw.data.(*btfInt)
-			if bi.Offset() > 0 || bi.Bits().Bytes() != size {
-				legacyBitfields[id] = [2]Bits{bi.Offset(), bi.Bits()}
-			}
-			typ = &Int{name, raw.Size(), bi.Encoding()}
-
-		case kindPointer:
-			ptr := &Pointer{nil}
-			fixup(raw.Type(), &ptr.Target)
-			typ = ptr
-
-		case kindArray:
-			btfArr := raw.data.(*btfArray)
-			arr := &Array{nil, nil, btfArr.Nelems}
-			fixup(btfArr.IndexType, &arr.Index)
-			fixup(btfArr.Type, &arr.Type)
-			typ = arr
-
-		case kindStruct:
-			members, err := convertMembers(raw.data.([]btfMember), raw.Bitfield())
-			if err != nil {
-				return nil, fmt.Errorf("struct %s (id %d): %w", name, id, err)
-			}
-			typ = &Struct{name, raw.Size(), members}
-
-		case kindUnion:
-			members, err := convertMembers(raw.data.([]btfMember), raw.Bitfield())
-			if err != nil {
-				return nil, fmt.Errorf("union %s (id %d): %w", name, id, err)
-			}
-			typ = &Union{name, raw.Size(), members}
-
-		case kindEnum:
-			rawvals := raw.data.([]btfEnum)
-			vals := make([]EnumValue, 0, len(rawvals))
-			signed := raw.Signed()
-			for i, btfVal := range rawvals {
-				name, err := rawStrings.Lookup(btfVal.NameOff)
-				if err != nil {
-					return nil, fmt.Errorf("get name for enum value %d: %s", i, err)
-				}
-				value := uint64(btfVal.Val)
-				if signed {
-					// Sign extend values to 64 bit.
-					value = uint64(int32(btfVal.Val))
-				}
-				vals = append(vals, EnumValue{name, value})
-			}
-			typ = &Enum{name, raw.Size(), signed, vals}
-
-		case kindForward:
-			typ = &Fwd{name, raw.FwdKind()}
-
-		case kindTypedef:
-			typedef := &Typedef{name, nil}
-			fixup(raw.Type(), &typedef.Type)
-			typ = typedef
-
-		case kindVolatile:
-			volatile := &Volatile{nil}
-			fixup(raw.Type(), &volatile.Type)
-			typ = volatile
-
-		case kindConst:
-			cnst := &Const{nil}
-			fixup(raw.Type(), &cnst.Type)
-			typ = cnst
-
-		case kindRestrict:
-			restrict := &Restrict{nil}
-			fixup(raw.Type(), &restrict.Type)
-			typ = restrict
-
-		case kindFunc:
-			fn := &Func{name, nil, raw.Linkage()}
-			if err := fixupAndAssert(raw.Type(), &fn.Type, reflect.TypeOf((*FuncProto)(nil))); err != nil {
-				return nil, err
-			}
-			typ = fn
-
-		case kindFuncProto:
-			rawparams := raw.data.([]btfParam)
-			params := make([]FuncParam, 0, len(rawparams))
-			for i, param := range rawparams {
-				name, err := rawStrings.Lookup(param.NameOff)
-				if err != nil {
-					return nil, fmt.Errorf("get name for func proto parameter %d: %s", i, err)
-				}
-				params = append(params, FuncParam{
-					Name: name,
-				})
-			}
-			for i := range params {
-				fixup(rawparams[i].Type, &params[i].Type)
-			}
-
-			fp := &FuncProto{nil, params}
-			fixup(raw.Type(), &fp.Return)
-			typ = fp
-
-		case kindVar:
-			variable := raw.data.(*btfVariable)
-			v := &Var{name, nil, VarLinkage(variable.Linkage)}
-			fixup(raw.Type(), &v.Type)
-			typ = v
-
-		case kindDatasec:
-			btfVars := raw.data.([]btfVarSecinfo)
-			vars := make([]VarSecinfo, 0, len(btfVars))
-			for _, btfVar := range btfVars {
-				vars = append(vars, VarSecinfo{
-					Offset: btfVar.Offset,
-					Size:   btfVar.Size,
-				})
-			}
-			for i := range vars {
-				fixup(btfVars[i].Type, &vars[i].Type)
-			}
-			typ = &Datasec{name, raw.Size(), vars}
-
-		case kindFloat:
-			typ = &Float{name, raw.Size()}
-
-		case kindDeclTag:
-			btfIndex := raw.data.(*btfDeclTag).ComponentIdx
-			if uint64(btfIndex) > math.MaxInt {
-				return nil, fmt.Errorf("type id %d: index exceeds int", id)
-			}
-
-			dt := &declTag{nil, name, int(int32(btfIndex))}
-			fixup(raw.Type(), &dt.Type)
-			typ = dt
-
-			declTags = append(declTags, dt)
-
-		case kindTypeTag:
-			tt := &typeTag{nil, name}
-			fixup(raw.Type(), &tt.Type)
-			typ = tt
-
-		case kindEnum64:
-			rawvals := raw.data.([]btfEnum64)
-			vals := make([]EnumValue, 0, len(rawvals))
-			for i, btfVal := range rawvals {
-				name, err := rawStrings.Lookup(btfVal.NameOff)
-				if err != nil {
-					return nil, fmt.Errorf("get name for enum64 value %d: %s", i, err)
-				}
-				value := (uint64(btfVal.ValHi32) << 32) | uint64(btfVal.ValLo32)
-				vals = append(vals, EnumValue{name, value})
-			}
-			typ = &Enum{name, raw.Size(), raw.Signed(), vals}
-
-		default:
-			return nil, fmt.Errorf("type id %d: unknown kind: %v", id, raw.Kind())
-		}
-
-		types = append(types, typ)
-	}
-
-	for _, fixup := range fixups {
-		if fixup.id < firstTypeID {
-			return nil, fmt.Errorf("fixup for base type id %d is not expected", fixup.id)
-		}
-
-		idx := int(fixup.id - firstTypeID)
-		if idx >= len(types) {
-			return nil, fmt.Errorf("reference to invalid type id: %d", fixup.id)
-		}
-
-		*fixup.typ = types[idx]
-	}
-
-	for _, bitfieldFixup := range bitfieldFixups {
-		if bitfieldFixup.id < firstTypeID {
-			return nil, fmt.Errorf("bitfield fixup from split to base types is not expected")
-		}
-
-		data, ok := legacyBitfields[bitfieldFixup.id]
-		if ok {
-			// This is indeed a legacy bitfield, fix it up.
-			bitfieldFixup.m.Offset += data[0]
-			bitfieldFixup.m.BitfieldSize = data[1]
-		}
-	}
-
-	for _, assertion := range assertions {
-		if reflect.TypeOf(*assertion.typ) != assertion.want {
-			return nil, fmt.Errorf("type ID %d: expected %s, got %T", assertion.id, assertion.want, *assertion.typ)
-		}
-	}
-
-	for _, dt := range declTags {
-		switch t := dt.Type.(type) {
-		case *Var, *Typedef:
-			if dt.Index != -1 {
-				return nil, fmt.Errorf("type %s: index %d is not -1", dt, dt.Index)
-			}
-
-		case composite:
-			if dt.Index >= len(t.members()) {
-				return nil, fmt.Errorf("type %s: index %d exceeds members of %s", dt, dt.Index, t)
-			}
-
-		case *Func:
-			if dt.Index >= len(t.Type.(*FuncProto).Params) {
-				return nil, fmt.Errorf("type %s: index %d exceeds params of %s", dt, dt.Index, t)
-			}
-
-		default:
-			return nil, fmt.Errorf("type %s: decl tag for type %s is not supported", dt, t)
-		}
-	}
-
-	return types, nil
-}
-
-// essentialName represents the name of a BTF type stripped of any flavor
-// suffixes after a ___ delimiter.
-type essentialName string
-
-// newEssentialName returns name without a ___ suffix.
-//
-// CO-RE has the concept of 'struct flavors', which are used to deal with
-// changes in kernel data structures. Anything after three underscores
-// in a type name is ignored for the purpose of finding a candidate type
-// in the kernel's BTF.
-func newEssentialName(name string) essentialName {
-	if name == "" {
-		return ""
-	}
-	lastIdx := strings.LastIndex(name, "___")
-	if lastIdx > 0 {
-		return essentialName(name[:lastIdx])
-	}
-	return essentialName(name)
-}
-
-// UnderlyingType skips qualifiers and Typedefs.
-func UnderlyingType(typ Type) Type {
-	result := typ
-	for depth := 0; depth <= maxTypeDepth; depth++ {
-		switch v := (result).(type) {
-		case qualifier:
-			result = v.qualify()
-		case *Typedef:
-			result = v.Type
-		default:
-			return result
-		}
-	}
-	return &cycle{typ}
-}
-
-// as returns typ if is of type T. Otherwise it peels qualifiers and Typedefs
-// until it finds a T.
-//
-// Returns the zero value and false if there is no T or if the type is nested
-// too deeply.
-func as[T Type](typ Type) (T, bool) {
-	for depth := 0; depth <= maxTypeDepth; depth++ {
-		switch v := (typ).(type) {
-		case T:
-			return v, true
-		case qualifier:
-			typ = v.qualify()
-		case *Typedef:
-			typ = v.Type
-		default:
-			goto notFound
-		}
-	}
-notFound:
-	var zero T
-	return zero, false
-}
-
-type formatState struct {
-	fmt.State
-	depth int
-}
-
-// formattableType is a subset of Type, to ease unit testing of formatType.
-type formattableType interface {
-	fmt.Formatter
-	TypeName() string
-}
-
-// formatType formats a type in a canonical form.
-//
-// Handles cyclical types by only printing cycles up to a certain depth. Elements
-// in extra are separated by spaces unless the preceding element is a string
-// ending in '='.
-func formatType(f fmt.State, verb rune, t formattableType, extra ...interface{}) {
-	if verb != 'v' && verb != 's' {
-		fmt.Fprintf(f, "{UNRECOGNIZED: %c}", verb)
-		return
-	}
-
-	_, _ = io.WriteString(f, internal.GoTypeName(t))
-
-	if name := t.TypeName(); name != "" {
-		// Output BTF type name if present.
-		fmt.Fprintf(f, ":%q", name)
-	}
-
-	if f.Flag('+') {
-		// Output address if requested.
-		fmt.Fprintf(f, ":%#p", t)
-	}
-
-	if verb == 's' {
-		// %s omits details.
-		return
-	}
-
-	var depth int
-	if ps, ok := f.(*formatState); ok {
-		depth = ps.depth
-		f = ps.State
-	}
-
-	maxDepth, ok := f.Width()
-	if !ok {
-		maxDepth = 0
-	}
-
-	if depth > maxDepth {
-		// We've reached the maximum depth. This avoids infinite recursion even
-		// for cyclical types.
-		return
-	}
-
-	if len(extra) == 0 {
-		return
-	}
-
-	wantSpace := false
-	_, _ = io.WriteString(f, "[")
-	for _, arg := range extra {
-		if wantSpace {
-			_, _ = io.WriteString(f, " ")
-		}
-
-		switch v := arg.(type) {
-		case string:
-			_, _ = io.WriteString(f, v)
-			wantSpace = len(v) > 0 && v[len(v)-1] != '='
-			continue
-
-		case formattableType:
-			v.Format(&formatState{f, depth + 1}, verb)
-
-		default:
-			fmt.Fprint(f, arg)
-		}
-
-		wantSpace = true
-	}
-	_, _ = io.WriteString(f, "]")
-}
diff --git a/vendor/github.com/cilium/ebpf/btf/workarounds.go b/vendor/github.com/cilium/ebpf/btf/workarounds.go
deleted file mode 100644
index 12a89b87e..000000000
--- a/vendor/github.com/cilium/ebpf/btf/workarounds.go
+++ /dev/null
@@ -1,26 +0,0 @@
-package btf
-
-// datasecResolveWorkaround ensures that certain vars in a Datasec are added
-// to a Spec before the Datasec. This avoids a bug in kernel BTF validation.
-//
-// See https://lore.kernel.org/bpf/20230302123440.1193507-1-lmb@isovalent.com/
-func datasecResolveWorkaround(b *Builder, ds *Datasec) error {
-	for _, vsi := range ds.Vars {
-		v, ok := vsi.Type.(*Var)
-		if !ok {
-			continue
-		}
-
-		switch v.Type.(type) {
-		case *Typedef, *Volatile, *Const, *Restrict, *typeTag:
-			// NB: We must never call Add on a Datasec, otherwise we risk
-			// infinite recursion.
-			_, err := b.Add(v.Type)
-			if err != nil {
-				return err
-			}
-		}
-	}
-
-	return nil
-}
diff --git a/vendor/github.com/cilium/ebpf/collection.go b/vendor/github.com/cilium/ebpf/collection.go
deleted file mode 100644
index fb720bebd..000000000
--- a/vendor/github.com/cilium/ebpf/collection.go
+++ /dev/null
@@ -1,841 +0,0 @@
-package ebpf
-
-import (
-	"encoding/binary"
-	"errors"
-	"fmt"
-	"reflect"
-	"strings"
-
-	"github.com/cilium/ebpf/asm"
-	"github.com/cilium/ebpf/btf"
-	"github.com/cilium/ebpf/internal"
-	"github.com/cilium/ebpf/internal/kconfig"
-)
-
-// CollectionOptions control loading a collection into the kernel.
-//
-// Maps and Programs are passed to NewMapWithOptions and NewProgramsWithOptions.
-type CollectionOptions struct {
-	Maps     MapOptions
-	Programs ProgramOptions
-
-	// MapReplacements takes a set of Maps that will be used instead of
-	// creating new ones when loading the CollectionSpec.
-	//
-	// For each given Map, there must be a corresponding MapSpec in
-	// CollectionSpec.Maps, and its type, key/value size, max entries and flags
-	// must match the values of the MapSpec.
-	//
-	// The given Maps are Clone()d before being used in the Collection, so the
-	// caller can Close() them freely when they are no longer needed.
-	MapReplacements map[string]*Map
-}
-
-// CollectionSpec describes a collection.
-type CollectionSpec struct {
-	Maps     map[string]*MapSpec
-	Programs map[string]*ProgramSpec
-
-	// Types holds type information about Maps and Programs.
-	// Modifications to Types are currently undefined behaviour.
-	Types *btf.Spec
-
-	// ByteOrder specifies whether the ELF was compiled for
-	// big-endian or little-endian architectures.
-	ByteOrder binary.ByteOrder
-}
-
-// Copy returns a recursive copy of the spec.
-func (cs *CollectionSpec) Copy() *CollectionSpec {
-	if cs == nil {
-		return nil
-	}
-
-	cpy := CollectionSpec{
-		Maps:      make(map[string]*MapSpec, len(cs.Maps)),
-		Programs:  make(map[string]*ProgramSpec, len(cs.Programs)),
-		ByteOrder: cs.ByteOrder,
-		Types:     cs.Types,
-	}
-
-	for name, spec := range cs.Maps {
-		cpy.Maps[name] = spec.Copy()
-	}
-
-	for name, spec := range cs.Programs {
-		cpy.Programs[name] = spec.Copy()
-	}
-
-	return &cpy
-}
-
-// RewriteMaps replaces all references to specific maps.
-//
-// Use this function to use pre-existing maps instead of creating new ones
-// when calling NewCollection. Any named maps are removed from CollectionSpec.Maps.
-//
-// Returns an error if a named map isn't used in at least one program.
-//
-// Deprecated: Pass CollectionOptions.MapReplacements when loading the Collection
-// instead.
-func (cs *CollectionSpec) RewriteMaps(maps map[string]*Map) error {
-	for symbol, m := range maps {
-		// have we seen a program that uses this symbol / map
-		seen := false
-		for progName, progSpec := range cs.Programs {
-			err := progSpec.Instructions.AssociateMap(symbol, m)
-
-			switch {
-			case err == nil:
-				seen = true
-
-			case errors.Is(err, asm.ErrUnreferencedSymbol):
-				// Not all programs need to use the map
-
-			default:
-				return fmt.Errorf("program %s: %w", progName, err)
-			}
-		}
-
-		if !seen {
-			return fmt.Errorf("map %s not referenced by any programs", symbol)
-		}
-
-		// Prevent NewCollection from creating rewritten maps
-		delete(cs.Maps, symbol)
-	}
-
-	return nil
-}
-
-// MissingConstantsError is returned by [CollectionSpec.RewriteConstants].
-type MissingConstantsError struct {
-	// The constants missing from .rodata.
-	Constants []string
-}
-
-func (m *MissingConstantsError) Error() string {
-	return fmt.Sprintf("some constants are missing from .rodata: %s", strings.Join(m.Constants, ", "))
-}
-
-// RewriteConstants replaces the value of multiple constants.
-//
-// The constant must be defined like so in the C program:
-//
-//	volatile const type foobar;
-//	volatile const type foobar = default;
-//
-// Replacement values must be of the same length as the C sizeof(type).
-// If necessary, they are marshalled according to the same rules as
-// map values.
-//
-// From Linux 5.5 the verifier will use constants to eliminate dead code.
-//
-// Returns an error wrapping [MissingConstantsError] if a constant doesn't exist.
-func (cs *CollectionSpec) RewriteConstants(consts map[string]interface{}) error {
-	replaced := make(map[string]bool)
-
-	for name, spec := range cs.Maps {
-		if !strings.HasPrefix(name, ".rodata") {
-			continue
-		}
-
-		b, ds, err := spec.dataSection()
-		if errors.Is(err, errMapNoBTFValue) {
-			// Data sections without a BTF Datasec are valid, but don't support
-			// constant replacements.
-			continue
-		}
-		if err != nil {
-			return fmt.Errorf("map %s: %w", name, err)
-		}
-
-		// MapSpec.Copy() performs a shallow copy. Fully copy the byte slice
-		// to avoid any changes affecting other copies of the MapSpec.
-		cpy := make([]byte, len(b))
-		copy(cpy, b)
-
-		for _, v := range ds.Vars {
-			vname := v.Type.TypeName()
-			replacement, ok := consts[vname]
-			if !ok {
-				continue
-			}
-
-			if _, ok := v.Type.(*btf.Var); !ok {
-				return fmt.Errorf("section %s: unexpected type %T for variable %s", name, v.Type, vname)
-			}
-
-			if replaced[vname] {
-				return fmt.Errorf("section %s: duplicate variable %s", name, vname)
-			}
-
-			if int(v.Offset+v.Size) > len(cpy) {
-				return fmt.Errorf("section %s: offset %d(+%d) for variable %s is out of bounds", name, v.Offset, v.Size, vname)
-			}
-
-			b, err := marshalBytes(replacement, int(v.Size))
-			if err != nil {
-				return fmt.Errorf("marshaling constant replacement %s: %w", vname, err)
-			}
-
-			copy(cpy[v.Offset:v.Offset+v.Size], b)
-
-			replaced[vname] = true
-		}
-
-		spec.Contents[0] = MapKV{Key: uint32(0), Value: cpy}
-	}
-
-	var missing []string
-	for c := range consts {
-		if !replaced[c] {
-			missing = append(missing, c)
-		}
-	}
-
-	if len(missing) != 0 {
-		return fmt.Errorf("rewrite constants: %w", &MissingConstantsError{Constants: missing})
-	}
-
-	return nil
-}
-
-// Assign the contents of a CollectionSpec to a struct.
-//
-// This function is a shortcut to manually checking the presence
-// of maps and programs in a CollectionSpec. Consider using bpf2go
-// if this sounds useful.
-//
-// 'to' must be a pointer to a struct. A field of the
-// struct is updated with values from Programs or Maps if it
-// has an `ebpf` tag and its type is *ProgramSpec or *MapSpec.
-// The tag's value specifies the name of the program or map as
-// found in the CollectionSpec.
-//
-//	struct {
-//	    Foo     *ebpf.ProgramSpec `ebpf:"xdp_foo"`
-//	    Bar     *ebpf.MapSpec     `ebpf:"bar_map"`
-//	    Ignored int
-//	}
-//
-// Returns an error if any of the eBPF objects can't be found, or
-// if the same MapSpec or ProgramSpec is assigned multiple times.
-func (cs *CollectionSpec) Assign(to interface{}) error {
-	// Assign() only supports assigning ProgramSpecs and MapSpecs,
-	// so doesn't load any resources into the kernel.
-	getValue := func(typ reflect.Type, name string) (interface{}, error) {
-		switch typ {
-
-		case reflect.TypeOf((*ProgramSpec)(nil)):
-			if p := cs.Programs[name]; p != nil {
-				return p, nil
-			}
-			return nil, fmt.Errorf("missing program %q", name)
-
-		case reflect.TypeOf((*MapSpec)(nil)):
-			if m := cs.Maps[name]; m != nil {
-				return m, nil
-			}
-			return nil, fmt.Errorf("missing map %q", name)
-
-		default:
-			return nil, fmt.Errorf("unsupported type %s", typ)
-		}
-	}
-
-	return assignValues(to, getValue)
-}
-
-// LoadAndAssign loads Maps and Programs into the kernel and assigns them
-// to a struct.
-//
-// Omitting Map/Program.Close() during application shutdown is an error.
-// See the package documentation for details around Map and Program lifecycle.
-//
-// This function is a shortcut to manually checking the presence
-// of maps and programs in a CollectionSpec. Consider using bpf2go
-// if this sounds useful.
-//
-// 'to' must be a pointer to a struct. A field of the struct is updated with
-// a Program or Map if it has an `ebpf` tag and its type is *Program or *Map.
-// The tag's value specifies the name of the program or map as found in the
-// CollectionSpec. Before updating the struct, the requested objects and their
-// dependent resources are loaded into the kernel and populated with values if
-// specified.
-//
-//	struct {
-//	    Foo     *ebpf.Program `ebpf:"xdp_foo"`
-//	    Bar     *ebpf.Map     `ebpf:"bar_map"`
-//	    Ignored int
-//	}
-//
-// opts may be nil.
-//
-// Returns an error if any of the fields can't be found, or
-// if the same Map or Program is assigned multiple times.
-func (cs *CollectionSpec) LoadAndAssign(to interface{}, opts *CollectionOptions) error {
-	loader, err := newCollectionLoader(cs, opts)
-	if err != nil {
-		return err
-	}
-	defer loader.close()
-
-	// Support assigning Programs and Maps, lazy-loading the required objects.
-	assignedMaps := make(map[string]bool)
-	assignedProgs := make(map[string]bool)
-
-	getValue := func(typ reflect.Type, name string) (interface{}, error) {
-		switch typ {
-
-		case reflect.TypeOf((*Program)(nil)):
-			assignedProgs[name] = true
-			return loader.loadProgram(name)
-
-		case reflect.TypeOf((*Map)(nil)):
-			assignedMaps[name] = true
-			return loader.loadMap(name)
-
-		default:
-			return nil, fmt.Errorf("unsupported type %s", typ)
-		}
-	}
-
-	// Load the Maps and Programs requested by the annotated struct.
-	if err := assignValues(to, getValue); err != nil {
-		return err
-	}
-
-	// Populate the requested maps. Has a chance of lazy-loading other dependent maps.
-	if err := loader.populateMaps(); err != nil {
-		return err
-	}
-
-	// Evaluate the loader's objects after all (lazy)loading has taken place.
-	for n, m := range loader.maps {
-		switch m.typ {
-		case ProgramArray:
-			// Require all lazy-loaded ProgramArrays to be assigned to the given object.
-			// The kernel empties a ProgramArray once the last user space reference
-			// to it closes, which leads to failed tail calls. Combined with the library
-			// closing map fds via GC finalizers this can lead to surprising behaviour.
-			// Only allow unassigned ProgramArrays when the library hasn't pre-populated
-			// any entries from static value declarations. At this point, we know the map
-			// is empty and there's no way for the caller to interact with the map going
-			// forward.
-			if !assignedMaps[n] && len(cs.Maps[n].Contents) > 0 {
-				return fmt.Errorf("ProgramArray %s must be assigned to prevent missed tail calls", n)
-			}
-		}
-	}
-
-	// Prevent loader.cleanup() from closing assigned Maps and Programs.
-	for m := range assignedMaps {
-		delete(loader.maps, m)
-	}
-	for p := range assignedProgs {
-		delete(loader.programs, p)
-	}
-
-	return nil
-}
-
-// Collection is a collection of Programs and Maps associated
-// with their symbols
-type Collection struct {
-	Programs map[string]*Program
-	Maps     map[string]*Map
-}
-
-// NewCollection creates a Collection from the given spec, creating and
-// loading its declared resources into the kernel.
-//
-// Omitting Collection.Close() during application shutdown is an error.
-// See the package documentation for details around Map and Program lifecycle.
-func NewCollection(spec *CollectionSpec) (*Collection, error) {
-	return NewCollectionWithOptions(spec, CollectionOptions{})
-}
-
-// NewCollectionWithOptions creates a Collection from the given spec using
-// options, creating and loading its declared resources into the kernel.
-//
-// Omitting Collection.Close() during application shutdown is an error.
-// See the package documentation for details around Map and Program lifecycle.
-func NewCollectionWithOptions(spec *CollectionSpec, opts CollectionOptions) (*Collection, error) {
-	loader, err := newCollectionLoader(spec, &opts)
-	if err != nil {
-		return nil, err
-	}
-	defer loader.close()
-
-	// Create maps first, as their fds need to be linked into programs.
-	for mapName := range spec.Maps {
-		if _, err := loader.loadMap(mapName); err != nil {
-			return nil, err
-		}
-	}
-
-	for progName, prog := range spec.Programs {
-		if prog.Type == UnspecifiedProgram {
-			continue
-		}
-
-		if _, err := loader.loadProgram(progName); err != nil {
-			return nil, err
-		}
-	}
-
-	// Maps can contain Program and Map stubs, so populate them after
-	// all Maps and Programs have been successfully loaded.
-	if err := loader.populateMaps(); err != nil {
-		return nil, err
-	}
-
-	// Prevent loader.cleanup from closing maps and programs.
-	maps, progs := loader.maps, loader.programs
-	loader.maps, loader.programs = nil, nil
-
-	return &Collection{
-		progs,
-		maps,
-	}, nil
-}
-
-type collectionLoader struct {
-	coll     *CollectionSpec
-	opts     *CollectionOptions
-	maps     map[string]*Map
-	programs map[string]*Program
-}
-
-func newCollectionLoader(coll *CollectionSpec, opts *CollectionOptions) (*collectionLoader, error) {
-	if opts == nil {
-		opts = &CollectionOptions{}
-	}
-
-	// Check for existing MapSpecs in the CollectionSpec for all provided replacement maps.
-	for name, m := range opts.MapReplacements {
-		spec, ok := coll.Maps[name]
-		if !ok {
-			return nil, fmt.Errorf("replacement map %s not found in CollectionSpec", name)
-		}
-
-		if err := spec.Compatible(m); err != nil {
-			return nil, fmt.Errorf("using replacement map %s: %w", spec.Name, err)
-		}
-	}
-
-	return &collectionLoader{
-		coll,
-		opts,
-		make(map[string]*Map),
-		make(map[string]*Program),
-	}, nil
-}
-
-// close all resources left over in the collectionLoader.
-func (cl *collectionLoader) close() {
-	for _, m := range cl.maps {
-		m.Close()
-	}
-	for _, p := range cl.programs {
-		p.Close()
-	}
-}
-
-func (cl *collectionLoader) loadMap(mapName string) (*Map, error) {
-	if m := cl.maps[mapName]; m != nil {
-		return m, nil
-	}
-
-	mapSpec := cl.coll.Maps[mapName]
-	if mapSpec == nil {
-		return nil, fmt.Errorf("missing map %s", mapName)
-	}
-
-	if replaceMap, ok := cl.opts.MapReplacements[mapName]; ok {
-		// Clone the map to avoid closing user's map later on.
-		m, err := replaceMap.Clone()
-		if err != nil {
-			return nil, err
-		}
-
-		cl.maps[mapName] = m
-		return m, nil
-	}
-
-	m, err := newMapWithOptions(mapSpec, cl.opts.Maps)
-	if err != nil {
-		return nil, fmt.Errorf("map %s: %w", mapName, err)
-	}
-
-	cl.maps[mapName] = m
-	return m, nil
-}
-
-func (cl *collectionLoader) loadProgram(progName string) (*Program, error) {
-	if prog := cl.programs[progName]; prog != nil {
-		return prog, nil
-	}
-
-	progSpec := cl.coll.Programs[progName]
-	if progSpec == nil {
-		return nil, fmt.Errorf("unknown program %s", progName)
-	}
-
-	// Bail out early if we know the kernel is going to reject the program.
-	// This skips loading map dependencies, saving some cleanup work later.
-	if progSpec.Type == UnspecifiedProgram {
-		return nil, fmt.Errorf("cannot load program %s: program type is unspecified", progName)
-	}
-
-	progSpec = progSpec.Copy()
-
-	// Rewrite any reference to a valid map in the program's instructions,
-	// which includes all of its dependencies.
-	for i := range progSpec.Instructions {
-		ins := &progSpec.Instructions[i]
-
-		if !ins.IsLoadFromMap() || ins.Reference() == "" {
-			continue
-		}
-
-		// Don't overwrite map loads containing non-zero map fd's,
-		// they can be manually included by the caller.
-		// Map FDs/IDs are placed in the lower 32 bits of Constant.
-		if int32(ins.Constant) > 0 {
-			continue
-		}
-
-		m, err := cl.loadMap(ins.Reference())
-		if err != nil {
-			return nil, fmt.Errorf("program %s: %w", progName, err)
-		}
-
-		if err := ins.AssociateMap(m); err != nil {
-			return nil, fmt.Errorf("program %s: map %s: %w", progName, ins.Reference(), err)
-		}
-	}
-
-	prog, err := newProgramWithOptions(progSpec, cl.opts.Programs)
-	if err != nil {
-		return nil, fmt.Errorf("program %s: %w", progName, err)
-	}
-
-	cl.programs[progName] = prog
-	return prog, nil
-}
-
-func (cl *collectionLoader) populateMaps() error {
-	for mapName, m := range cl.maps {
-		mapSpec, ok := cl.coll.Maps[mapName]
-		if !ok {
-			return fmt.Errorf("missing map spec %s", mapName)
-		}
-
-		// MapSpecs that refer to inner maps or programs within the same
-		// CollectionSpec do so using strings. These strings are used as the key
-		// to look up the respective object in the Maps or Programs fields.
-		// Resolve those references to actual Map or Program resources that
-		// have been loaded into the kernel.
-		if mapSpec.Type.canStoreMap() || mapSpec.Type.canStoreProgram() {
-			mapSpec = mapSpec.Copy()
-
-			for i, kv := range mapSpec.Contents {
-				objName, ok := kv.Value.(string)
-				if !ok {
-					continue
-				}
-
-				switch t := mapSpec.Type; {
-				case t.canStoreProgram():
-					// loadProgram is idempotent and could return an existing Program.
-					prog, err := cl.loadProgram(objName)
-					if err != nil {
-						return fmt.Errorf("loading program %s, for map %s: %w", objName, mapName, err)
-					}
-					mapSpec.Contents[i] = MapKV{kv.Key, prog}
-
-				case t.canStoreMap():
-					// loadMap is idempotent and could return an existing Map.
-					innerMap, err := cl.loadMap(objName)
-					if err != nil {
-						return fmt.Errorf("loading inner map %s, for map %s: %w", objName, mapName, err)
-					}
-					mapSpec.Contents[i] = MapKV{kv.Key, innerMap}
-				}
-			}
-		}
-
-		// Populate and freeze the map if specified.
-		if err := m.finalize(mapSpec); err != nil {
-			return fmt.Errorf("populating map %s: %w", mapName, err)
-		}
-	}
-
-	return nil
-}
-
-// resolveKconfig resolves all variables declared in .kconfig and populates
-// m.Contents. Does nothing if the given m.Contents is non-empty.
-func resolveKconfig(m *MapSpec) error {
-	ds, ok := m.Value.(*btf.Datasec)
-	if !ok {
-		return errors.New("map value is not a Datasec")
-	}
-
-	type configInfo struct {
-		offset uint32
-		typ    btf.Type
-	}
-
-	configs := make(map[string]configInfo)
-
-	data := make([]byte, ds.Size)
-	for _, vsi := range ds.Vars {
-		v := vsi.Type.(*btf.Var)
-		n := v.TypeName()
-
-		switch n {
-		case "LINUX_KERNEL_VERSION":
-			if integer, ok := v.Type.(*btf.Int); !ok || integer.Size != 4 {
-				return fmt.Errorf("variable %s must be a 32 bits integer, got %s", n, v.Type)
-			}
-
-			kv, err := internal.KernelVersion()
-			if err != nil {
-				return fmt.Errorf("getting kernel version: %w", err)
-			}
-			internal.NativeEndian.PutUint32(data[vsi.Offset:], kv.Kernel())
-
-		case "LINUX_HAS_SYSCALL_WRAPPER":
-			if integer, ok := v.Type.(*btf.Int); !ok || integer.Size != 4 {
-				return fmt.Errorf("variable %s must be a 32 bits integer, got %s", n, v.Type)
-			}
-			var value uint32 = 1
-			if err := haveSyscallWrapper(); errors.Is(err, ErrNotSupported) {
-				value = 0
-			} else if err != nil {
-				return fmt.Errorf("unable to derive a value for LINUX_HAS_SYSCALL_WRAPPER: %w", err)
-			}
-
-			internal.NativeEndian.PutUint32(data[vsi.Offset:], value)
-
-		default: // Catch CONFIG_*.
-			configs[n] = configInfo{
-				offset: vsi.Offset,
-				typ:    v.Type,
-			}
-		}
-	}
-
-	// We only parse kconfig file if a CONFIG_* variable was found.
-	if len(configs) > 0 {
-		f, err := kconfig.Find()
-		if err != nil {
-			return fmt.Errorf("cannot find a kconfig file: %w", err)
-		}
-		defer f.Close()
-
-		filter := make(map[string]struct{}, len(configs))
-		for config := range configs {
-			filter[config] = struct{}{}
-		}
-
-		kernelConfig, err := kconfig.Parse(f, filter)
-		if err != nil {
-			return fmt.Errorf("cannot parse kconfig file: %w", err)
-		}
-
-		for n, info := range configs {
-			value, ok := kernelConfig[n]
-			if !ok {
-				return fmt.Errorf("config option %q does not exists for this kernel", n)
-			}
-
-			err := kconfig.PutValue(data[info.offset:], info.typ, value)
-			if err != nil {
-				return fmt.Errorf("problem adding value for %s: %w", n, err)
-			}
-		}
-	}
-
-	m.Contents = []MapKV{{uint32(0), data}}
-
-	return nil
-}
-
-// LoadCollection reads an object file and creates and loads its declared
-// resources into the kernel.
-//
-// Omitting Collection.Close() during application shutdown is an error.
-// See the package documentation for details around Map and Program lifecycle.
-func LoadCollection(file string) (*Collection, error) {
-	spec, err := LoadCollectionSpec(file)
-	if err != nil {
-		return nil, err
-	}
-	return NewCollection(spec)
-}
-
-// Close frees all maps and programs associated with the collection.
-//
-// The collection mustn't be used afterwards.
-func (coll *Collection) Close() {
-	for _, prog := range coll.Programs {
-		prog.Close()
-	}
-	for _, m := range coll.Maps {
-		m.Close()
-	}
-}
-
-// DetachMap removes the named map from the Collection.
-//
-// This means that a later call to Close() will not affect this map.
-//
-// Returns nil if no map of that name exists.
-func (coll *Collection) DetachMap(name string) *Map {
-	m := coll.Maps[name]
-	delete(coll.Maps, name)
-	return m
-}
-
-// DetachProgram removes the named program from the Collection.
-//
-// This means that a later call to Close() will not affect this program.
-//
-// Returns nil if no program of that name exists.
-func (coll *Collection) DetachProgram(name string) *Program {
-	p := coll.Programs[name]
-	delete(coll.Programs, name)
-	return p
-}
-
-// structField represents a struct field containing the ebpf struct tag.
-type structField struct {
-	reflect.StructField
-	value reflect.Value
-}
-
-// ebpfFields extracts field names tagged with 'ebpf' from a struct type.
-// Keep track of visited types to avoid infinite recursion.
-func ebpfFields(structVal reflect.Value, visited map[reflect.Type]bool) ([]structField, error) {
-	if visited == nil {
-		visited = make(map[reflect.Type]bool)
-	}
-
-	structType := structVal.Type()
-	if structType.Kind() != reflect.Struct {
-		return nil, fmt.Errorf("%s is not a struct", structType)
-	}
-
-	if visited[structType] {
-		return nil, fmt.Errorf("recursion on type %s", structType)
-	}
-
-	fields := make([]structField, 0, structType.NumField())
-	for i := 0; i < structType.NumField(); i++ {
-		field := structField{structType.Field(i), structVal.Field(i)}
-
-		// If the field is tagged, gather it and move on.
-		name := field.Tag.Get("ebpf")
-		if name != "" {
-			fields = append(fields, field)
-			continue
-		}
-
-		// If the field does not have an ebpf tag, but is a struct or a pointer
-		// to a struct, attempt to gather its fields as well.
-		var v reflect.Value
-		switch field.Type.Kind() {
-		case reflect.Ptr:
-			if field.Type.Elem().Kind() != reflect.Struct {
-				continue
-			}
-
-			if field.value.IsNil() {
-				return nil, fmt.Errorf("nil pointer to %s", structType)
-			}
-
-			// Obtain the destination type of the pointer.
-			v = field.value.Elem()
-
-		case reflect.Struct:
-			// Reference the value's type directly.
-			v = field.value
-
-		default:
-			continue
-		}
-
-		inner, err := ebpfFields(v, visited)
-		if err != nil {
-			return nil, fmt.Errorf("field %s: %w", field.Name, err)
-		}
-
-		fields = append(fields, inner...)
-	}
-
-	return fields, nil
-}
-
-// assignValues attempts to populate all fields of 'to' tagged with 'ebpf'.
-//
-// getValue is called for every tagged field of 'to' and must return the value
-// to be assigned to the field with the given typ and name.
-func assignValues(to interface{},
-	getValue func(typ reflect.Type, name string) (interface{}, error)) error {
-
-	toValue := reflect.ValueOf(to)
-	if toValue.Type().Kind() != reflect.Ptr {
-		return fmt.Errorf("%T is not a pointer to struct", to)
-	}
-
-	if toValue.IsNil() {
-		return fmt.Errorf("nil pointer to %T", to)
-	}
-
-	fields, err := ebpfFields(toValue.Elem(), nil)
-	if err != nil {
-		return err
-	}
-
-	type elem struct {
-		// Either *Map or *Program
-		typ  reflect.Type
-		name string
-	}
-
-	assigned := make(map[elem]string)
-	for _, field := range fields {
-		// Get string value the field is tagged with.
-		tag := field.Tag.Get("ebpf")
-		if strings.Contains(tag, ",") {
-			return fmt.Errorf("field %s: ebpf tag contains a comma", field.Name)
-		}
-
-		// Check if the eBPF object with the requested
-		// type and tag was already assigned elsewhere.
-		e := elem{field.Type, tag}
-		if af := assigned[e]; af != "" {
-			return fmt.Errorf("field %s: object %q was already assigned to %s", field.Name, tag, af)
-		}
-
-		// Get the eBPF object referred to by the tag.
-		value, err := getValue(field.Type, tag)
-		if err != nil {
-			return fmt.Errorf("field %s: %w", field.Name, err)
-		}
-
-		if !field.value.CanSet() {
-			return fmt.Errorf("field %s: can't set value", field.Name)
-		}
-		field.value.Set(reflect.ValueOf(value))
-
-		assigned[e] = field.Name
-	}
-
-	return nil
-}
diff --git a/vendor/github.com/cilium/ebpf/doc.go b/vendor/github.com/cilium/ebpf/doc.go
deleted file mode 100644
index 396b3394d..000000000
--- a/vendor/github.com/cilium/ebpf/doc.go
+++ /dev/null
@@ -1,25 +0,0 @@
-// Package ebpf is a toolkit for working with eBPF programs.
-//
-// eBPF programs are small snippets of code which are executed directly
-// in a VM in the Linux kernel, which makes them very fast and flexible.
-// Many Linux subsystems now accept eBPF programs. This makes it possible
-// to implement highly application specific logic inside the kernel,
-// without having to modify the actual kernel itself.
-//
-// This package is designed for long-running processes which
-// want to use eBPF to implement part of their application logic. It has no
-// run-time dependencies outside of the library and the Linux kernel itself.
-// eBPF code should be compiled ahead of time using clang, and shipped with
-// your application as any other resource.
-//
-// Use the link subpackage to attach a loaded program to a hook in the kernel.
-//
-// Note that losing all references to Map and Program resources will cause
-// their underlying file descriptors to be closed, potentially removing those
-// objects from the kernel. Always retain a reference by e.g. deferring a
-// Close() of a Collection or LoadAndAssign object until application exit.
-//
-// Special care needs to be taken when handling maps of type ProgramArray,
-// as the kernel erases its contents when the last userspace or bpffs
-// reference disappears, regardless of the map being in active use.
-package ebpf
diff --git a/vendor/github.com/cilium/ebpf/elf_reader.go b/vendor/github.com/cilium/ebpf/elf_reader.go
deleted file mode 100644
index 8d92672eb..000000000
--- a/vendor/github.com/cilium/ebpf/elf_reader.go
+++ /dev/null
@@ -1,1314 +0,0 @@
-package ebpf
-
-import (
-	"bufio"
-	"bytes"
-	"debug/elf"
-	"encoding/binary"
-	"errors"
-	"fmt"
-	"io"
-	"math"
-	"os"
-	"strings"
-
-	"github.com/cilium/ebpf/asm"
-	"github.com/cilium/ebpf/btf"
-	"github.com/cilium/ebpf/internal"
-	"github.com/cilium/ebpf/internal/unix"
-)
-
-type kconfigMetaKey struct{}
-
-type kconfigMeta struct {
-	Map    *MapSpec
-	Offset uint32
-}
-
-type kfuncMeta struct{}
-
-// elfCode is a convenience to reduce the amount of arguments that have to
-// be passed around explicitly. You should treat its contents as immutable.
-type elfCode struct {
-	*internal.SafeELFFile
-	sections map[elf.SectionIndex]*elfSection
-	license  string
-	version  uint32
-	btf      *btf.Spec
-	extInfo  *btf.ExtInfos
-	maps     map[string]*MapSpec
-	kfuncs   map[string]*btf.Func
-	kconfig  *MapSpec
-}
-
-// LoadCollectionSpec parses an ELF file into a CollectionSpec.
-func LoadCollectionSpec(file string) (*CollectionSpec, error) {
-	f, err := os.Open(file)
-	if err != nil {
-		return nil, err
-	}
-	defer f.Close()
-
-	spec, err := LoadCollectionSpecFromReader(f)
-	if err != nil {
-		return nil, fmt.Errorf("file %s: %w", file, err)
-	}
-	return spec, nil
-}
-
-// LoadCollectionSpecFromReader parses an ELF file into a CollectionSpec.
-func LoadCollectionSpecFromReader(rd io.ReaderAt) (*CollectionSpec, error) {
-	f, err := internal.NewSafeELFFile(rd)
-	if err != nil {
-		return nil, err
-	}
-
-	// Checks if the ELF file is for BPF data.
-	// Old LLVM versions set e_machine to EM_NONE.
-	if f.File.Machine != unix.EM_NONE && f.File.Machine != elf.EM_BPF {
-		return nil, fmt.Errorf("unexpected machine type for BPF ELF: %s", f.File.Machine)
-	}
-
-	var (
-		licenseSection *elf.Section
-		versionSection *elf.Section
-		sections       = make(map[elf.SectionIndex]*elfSection)
-		relSections    = make(map[elf.SectionIndex]*elf.Section)
-	)
-
-	// This is the target of relocations generated by inline assembly.
-	sections[elf.SHN_UNDEF] = newElfSection(new(elf.Section), undefSection)
-
-	// Collect all the sections we're interested in. This includes relocations
-	// which we parse later.
-	for i, sec := range f.Sections {
-		idx := elf.SectionIndex(i)
-
-		switch {
-		case strings.HasPrefix(sec.Name, "license"):
-			licenseSection = sec
-		case strings.HasPrefix(sec.Name, "version"):
-			versionSection = sec
-		case strings.HasPrefix(sec.Name, "maps"):
-			sections[idx] = newElfSection(sec, mapSection)
-		case sec.Name == ".maps":
-			sections[idx] = newElfSection(sec, btfMapSection)
-		case sec.Name == ".bss" || sec.Name == ".data" || strings.HasPrefix(sec.Name, ".rodata"):
-			sections[idx] = newElfSection(sec, dataSection)
-		case sec.Type == elf.SHT_REL:
-			// Store relocations under the section index of the target
-			relSections[elf.SectionIndex(sec.Info)] = sec
-		case sec.Type == elf.SHT_PROGBITS && (sec.Flags&elf.SHF_EXECINSTR) != 0 && sec.Size > 0:
-			sections[idx] = newElfSection(sec, programSection)
-		}
-	}
-
-	license, err := loadLicense(licenseSection)
-	if err != nil {
-		return nil, fmt.Errorf("load license: %w", err)
-	}
-
-	version, err := loadVersion(versionSection, f.ByteOrder)
-	if err != nil {
-		return nil, fmt.Errorf("load version: %w", err)
-	}
-
-	btfSpec, btfExtInfo, err := btf.LoadSpecAndExtInfosFromReader(rd)
-	if err != nil && !errors.Is(err, btf.ErrNotFound) {
-		return nil, fmt.Errorf("load BTF: %w", err)
-	}
-
-	ec := &elfCode{
-		SafeELFFile: f,
-		sections:    sections,
-		license:     license,
-		version:     version,
-		btf:         btfSpec,
-		extInfo:     btfExtInfo,
-		maps:        make(map[string]*MapSpec),
-		kfuncs:      make(map[string]*btf.Func),
-	}
-
-	symbols, err := f.Symbols()
-	if err != nil {
-		return nil, fmt.Errorf("load symbols: %v", err)
-	}
-
-	ec.assignSymbols(symbols)
-
-	if err := ec.loadRelocations(relSections, symbols); err != nil {
-		return nil, fmt.Errorf("load relocations: %w", err)
-	}
-
-	if err := ec.loadMaps(); err != nil {
-		return nil, fmt.Errorf("load maps: %w", err)
-	}
-
-	if err := ec.loadBTFMaps(); err != nil {
-		return nil, fmt.Errorf("load BTF maps: %w", err)
-	}
-
-	if err := ec.loadDataSections(); err != nil {
-		return nil, fmt.Errorf("load data sections: %w", err)
-	}
-
-	if err := ec.loadKconfigSection(); err != nil {
-		return nil, fmt.Errorf("load virtual .kconfig section: %w", err)
-	}
-
-	if err := ec.loadKsymsSection(); err != nil {
-		return nil, fmt.Errorf("load virtual .ksyms section: %w", err)
-	}
-
-	// Finally, collect programs and link them.
-	progs, err := ec.loadProgramSections()
-	if err != nil {
-		return nil, fmt.Errorf("load programs: %w", err)
-	}
-
-	return &CollectionSpec{ec.maps, progs, btfSpec, ec.ByteOrder}, nil
-}
-
-func loadLicense(sec *elf.Section) (string, error) {
-	if sec == nil {
-		return "", nil
-	}
-
-	data, err := sec.Data()
-	if err != nil {
-		return "", fmt.Errorf("section %s: %v", sec.Name, err)
-	}
-	return string(bytes.TrimRight(data, "\000")), nil
-}
-
-func loadVersion(sec *elf.Section, bo binary.ByteOrder) (uint32, error) {
-	if sec == nil {
-		return 0, nil
-	}
-
-	var version uint32
-	if err := binary.Read(sec.Open(), bo, &version); err != nil {
-		return 0, fmt.Errorf("section %s: %v", sec.Name, err)
-	}
-	return version, nil
-}
-
-type elfSectionKind int
-
-const (
-	undefSection elfSectionKind = iota
-	mapSection
-	btfMapSection
-	programSection
-	dataSection
-)
-
-type elfSection struct {
-	*elf.Section
-	kind elfSectionKind
-	// Offset from the start of the section to a symbol
-	symbols map[uint64]elf.Symbol
-	// Offset from the start of the section to a relocation, which points at
-	// a symbol in another section.
-	relocations map[uint64]elf.Symbol
-	// The number of relocations pointing at this section.
-	references int
-}
-
-func newElfSection(section *elf.Section, kind elfSectionKind) *elfSection {
-	return &elfSection{
-		section,
-		kind,
-		make(map[uint64]elf.Symbol),
-		make(map[uint64]elf.Symbol),
-		0,
-	}
-}
-
-// assignSymbols takes a list of symbols and assigns them to their
-// respective sections, indexed by name.
-func (ec *elfCode) assignSymbols(symbols []elf.Symbol) {
-	for _, symbol := range symbols {
-		symType := elf.ST_TYPE(symbol.Info)
-		symSection := ec.sections[symbol.Section]
-		if symSection == nil {
-			continue
-		}
-
-		// Anonymous symbols only occur in debug sections which we don't process
-		// relocations for. Anonymous symbols are not referenced from other sections.
-		if symbol.Name == "" {
-			continue
-		}
-
-		// Older versions of LLVM don't tag symbols correctly, so keep
-		// all NOTYPE ones.
-		switch symSection.kind {
-		case mapSection, btfMapSection, dataSection:
-			if symType != elf.STT_NOTYPE && symType != elf.STT_OBJECT {
-				continue
-			}
-		case programSection:
-			if symType != elf.STT_NOTYPE && symType != elf.STT_FUNC {
-				continue
-			}
-			// LLVM emits LBB_ (Local Basic Block) symbols that seem to be jump
-			// targets within sections, but BPF has no use for them.
-			if symType == elf.STT_NOTYPE && elf.ST_BIND(symbol.Info) == elf.STB_LOCAL &&
-				strings.HasPrefix(symbol.Name, "LBB") {
-				continue
-			}
-		// Only collect symbols that occur in program/maps/data sections.
-		default:
-			continue
-		}
-
-		symSection.symbols[symbol.Value] = symbol
-	}
-}
-
-// loadRelocations iterates .rel* sections and extracts relocation entries for
-// sections of interest. Makes sure relocations point at valid sections.
-func (ec *elfCode) loadRelocations(relSections map[elf.SectionIndex]*elf.Section, symbols []elf.Symbol) error {
-	for idx, relSection := range relSections {
-		section := ec.sections[idx]
-		if section == nil {
-			continue
-		}
-
-		rels, err := ec.loadSectionRelocations(relSection, symbols)
-		if err != nil {
-			return fmt.Errorf("relocation for section %q: %w", section.Name, err)
-		}
-
-		for _, rel := range rels {
-			target := ec.sections[rel.Section]
-			if target == nil {
-				return fmt.Errorf("section %q: reference to %q in section %s: %w", section.Name, rel.Name, rel.Section, ErrNotSupported)
-			}
-
-			target.references++
-		}
-
-		section.relocations = rels
-	}
-
-	return nil
-}
-
-// loadProgramSections iterates ec's sections and emits a ProgramSpec
-// for each function it finds.
-//
-// The resulting map is indexed by function name.
-func (ec *elfCode) loadProgramSections() (map[string]*ProgramSpec, error) {
-
-	progs := make(map[string]*ProgramSpec)
-
-	// Generate a ProgramSpec for each function found in each program section.
-	var export []string
-	for _, sec := range ec.sections {
-		if sec.kind != programSection {
-			continue
-		}
-
-		if len(sec.symbols) == 0 {
-			return nil, fmt.Errorf("section %v: missing symbols", sec.Name)
-		}
-
-		funcs, err := ec.loadFunctions(sec)
-		if err != nil {
-			return nil, fmt.Errorf("section %v: %w", sec.Name, err)
-		}
-
-		progType, attachType, progFlags, attachTo := getProgType(sec.Name)
-
-		for name, insns := range funcs {
-			spec := &ProgramSpec{
-				Name:          name,
-				Type:          progType,
-				Flags:         progFlags,
-				AttachType:    attachType,
-				AttachTo:      attachTo,
-				SectionName:   sec.Name,
-				License:       ec.license,
-				KernelVersion: ec.version,
-				Instructions:  insns,
-				ByteOrder:     ec.ByteOrder,
-			}
-
-			// Function names must be unique within a single ELF blob.
-			if progs[name] != nil {
-				return nil, fmt.Errorf("duplicate program name %s", name)
-			}
-			progs[name] = spec
-
-			if spec.SectionName != ".text" {
-				export = append(export, name)
-			}
-		}
-	}
-
-	flattenPrograms(progs, export)
-
-	// Hide programs (e.g. library functions) that were not explicitly emitted
-	// to an ELF section. These could be exposed in a separate CollectionSpec
-	// field later to allow them to be modified.
-	for n, p := range progs {
-		if p.SectionName == ".text" {
-			delete(progs, n)
-		}
-	}
-
-	return progs, nil
-}
-
-// loadFunctions extracts instruction streams from the given program section
-// starting at each symbol in the section. The section's symbols must already
-// be narrowed down to STT_NOTYPE (emitted by clang <8) or STT_FUNC.
-//
-// The resulting map is indexed by function name.
-func (ec *elfCode) loadFunctions(section *elfSection) (map[string]asm.Instructions, error) {
-	r := bufio.NewReader(section.Open())
-
-	// Decode the section's instruction stream.
-	var insns asm.Instructions
-	if err := insns.Unmarshal(r, ec.ByteOrder); err != nil {
-		return nil, fmt.Errorf("decoding instructions for section %s: %w", section.Name, err)
-	}
-	if len(insns) == 0 {
-		return nil, fmt.Errorf("no instructions found in section %s", section.Name)
-	}
-
-	iter := insns.Iterate()
-	for iter.Next() {
-		ins := iter.Ins
-		offset := iter.Offset.Bytes()
-
-		// Tag Symbol Instructions.
-		if sym, ok := section.symbols[offset]; ok {
-			*ins = ins.WithSymbol(sym.Name)
-		}
-
-		// Apply any relocations for the current instruction.
-		// If no relocation is present, resolve any section-relative function calls.
-		if rel, ok := section.relocations[offset]; ok {
-			if err := ec.relocateInstruction(ins, rel); err != nil {
-				return nil, fmt.Errorf("offset %d: relocating instruction: %w", offset, err)
-			}
-		} else {
-			if err := referenceRelativeJump(ins, offset, section.symbols); err != nil {
-				return nil, fmt.Errorf("offset %d: resolving relative jump: %w", offset, err)
-			}
-		}
-	}
-
-	if ec.extInfo != nil {
-		ec.extInfo.Assign(insns, section.Name)
-	}
-
-	return splitSymbols(insns)
-}
-
-// referenceRelativeJump turns a relative jump to another bpf subprogram within
-// the same ELF section into a Reference Instruction.
-//
-// Up to LLVM 9, calls to subprograms within the same ELF section are sometimes
-// encoded using relative jumps instead of relocation entries. These jumps go
-// out of bounds of the current program, so their targets must be memoized
-// before the section's instruction stream is split.
-//
-// The relative jump Constant is blinded to -1 and the target Symbol is set as
-// the Instruction's Reference so it can be resolved by the linker.
-func referenceRelativeJump(ins *asm.Instruction, offset uint64, symbols map[uint64]elf.Symbol) error {
-	if !ins.IsFunctionReference() || ins.Constant == -1 {
-		return nil
-	}
-
-	tgt := jumpTarget(offset, *ins)
-	sym := symbols[tgt].Name
-	if sym == "" {
-		return fmt.Errorf("no jump target found at offset %d", tgt)
-	}
-
-	*ins = ins.WithReference(sym)
-	ins.Constant = -1
-
-	return nil
-}
-
-// jumpTarget takes ins' offset within an instruction stream (in bytes)
-// and returns its absolute jump destination (in bytes) within the
-// instruction stream.
-func jumpTarget(offset uint64, ins asm.Instruction) uint64 {
-	// A relative jump instruction describes the amount of raw BPF instructions
-	// to jump, convert the offset into bytes.
-	dest := ins.Constant * asm.InstructionSize
-
-	// The starting point of the jump is the end of the current instruction.
-	dest += int64(offset + asm.InstructionSize)
-
-	if dest < 0 {
-		return 0
-	}
-
-	return uint64(dest)
-}
-
-func (ec *elfCode) relocateInstruction(ins *asm.Instruction, rel elf.Symbol) error {
-	var (
-		typ  = elf.ST_TYPE(rel.Info)
-		bind = elf.ST_BIND(rel.Info)
-		name = rel.Name
-	)
-
-	target := ec.sections[rel.Section]
-
-	switch target.kind {
-	case mapSection, btfMapSection:
-		if bind != elf.STB_GLOBAL {
-			return fmt.Errorf("possible erroneous static qualifier on map definition: found reference to %q", name)
-		}
-
-		if typ != elf.STT_OBJECT && typ != elf.STT_NOTYPE {
-			// STT_NOTYPE is generated on clang < 8 which doesn't tag
-			// relocations appropriately.
-			return fmt.Errorf("map load: incorrect relocation type %v", typ)
-		}
-
-		ins.Src = asm.PseudoMapFD
-
-	case dataSection:
-		var offset uint32
-		switch typ {
-		case elf.STT_SECTION:
-			if bind != elf.STB_LOCAL {
-				return fmt.Errorf("direct load: %s: unsupported section relocation %s", name, bind)
-			}
-
-			// This is really a reference to a static symbol, which clang doesn't
-			// emit a symbol table entry for. Instead it encodes the offset in
-			// the instruction itself.
-			offset = uint32(uint64(ins.Constant))
-
-		case elf.STT_OBJECT:
-			// LLVM 9 emits OBJECT-LOCAL symbols for anonymous constants.
-			if bind != elf.STB_GLOBAL && bind != elf.STB_LOCAL {
-				return fmt.Errorf("direct load: %s: unsupported object relocation %s", name, bind)
-			}
-
-			offset = uint32(rel.Value)
-
-		case elf.STT_NOTYPE:
-			// LLVM 7 emits NOTYPE-LOCAL symbols for anonymous constants.
-			if bind != elf.STB_LOCAL {
-				return fmt.Errorf("direct load: %s: unsupported untyped relocation %s", name, bind)
-			}
-
-			offset = uint32(rel.Value)
-
-		default:
-			return fmt.Errorf("incorrect relocation type %v for direct map load", typ)
-		}
-
-		// We rely on using the name of the data section as the reference. It
-		// would be nicer to keep the real name in case of an STT_OBJECT, but
-		// it's not clear how to encode that into Instruction.
-		name = target.Name
-
-		// The kernel expects the offset in the second basic BPF instruction.
-		ins.Constant = int64(uint64(offset) << 32)
-		ins.Src = asm.PseudoMapValue
-
-	case programSection:
-		switch opCode := ins.OpCode; {
-		case opCode.JumpOp() == asm.Call:
-			if ins.Src != asm.PseudoCall {
-				return fmt.Errorf("call: %s: incorrect source register", name)
-			}
-
-			switch typ {
-			case elf.STT_NOTYPE, elf.STT_FUNC:
-				if bind != elf.STB_GLOBAL {
-					return fmt.Errorf("call: %s: unsupported binding: %s", name, bind)
-				}
-
-			case elf.STT_SECTION:
-				if bind != elf.STB_LOCAL {
-					return fmt.Errorf("call: %s: unsupported binding: %s", name, bind)
-				}
-
-				// The function we want to call is in the indicated section,
-				// at the offset encoded in the instruction itself. Reverse
-				// the calculation to find the real function we're looking for.
-				// A value of -1 references the first instruction in the section.
-				offset := int64(int32(ins.Constant)+1) * asm.InstructionSize
-				sym, ok := target.symbols[uint64(offset)]
-				if !ok {
-					return fmt.Errorf("call: no symbol at offset %d", offset)
-				}
-
-				name = sym.Name
-				ins.Constant = -1
-
-			default:
-				return fmt.Errorf("call: %s: invalid symbol type %s", name, typ)
-			}
-		case opCode.IsDWordLoad():
-			switch typ {
-			case elf.STT_FUNC:
-				if bind != elf.STB_GLOBAL {
-					return fmt.Errorf("load: %s: unsupported binding: %s", name, bind)
-				}
-
-			case elf.STT_SECTION:
-				if bind != elf.STB_LOCAL {
-					return fmt.Errorf("load: %s: unsupported binding: %s", name, bind)
-				}
-
-				// ins.Constant already contains the offset in bytes from the
-				// start of the section. This is different than a call to a
-				// static function.
-
-			default:
-				return fmt.Errorf("load: %s: invalid symbol type %s", name, typ)
-			}
-
-			sym, ok := target.symbols[uint64(ins.Constant)]
-			if !ok {
-				return fmt.Errorf("load: no symbol at offset %d", ins.Constant)
-			}
-
-			name = sym.Name
-			ins.Constant = -1
-			ins.Src = asm.PseudoFunc
-
-		default:
-			return fmt.Errorf("neither a call nor a load instruction: %v", ins)
-		}
-
-	// The Undefined section is used for 'virtual' symbols that aren't backed by
-	// an ELF section. This includes symbol references from inline asm, forward
-	// function declarations, as well as extern kfunc declarations using __ksym
-	// and extern kconfig variables declared using __kconfig.
-	case undefSection:
-		if bind != elf.STB_GLOBAL {
-			return fmt.Errorf("asm relocation: %s: unsupported binding: %s", name, bind)
-		}
-
-		if typ != elf.STT_NOTYPE {
-			return fmt.Errorf("asm relocation: %s: unsupported type %s", name, typ)
-		}
-
-		kf := ec.kfuncs[name]
-		switch {
-		// If a Call instruction is found and the datasec has a btf.Func with a Name
-		// that matches the symbol name we mark the instruction as a call to a kfunc.
-		case kf != nil && ins.OpCode.JumpOp() == asm.Call:
-			ins.Metadata.Set(kfuncMeta{}, kf)
-			ins.Src = asm.PseudoKfuncCall
-			ins.Constant = -1
-
-		// If no kconfig map is found, this must be a symbol reference from inline
-		// asm (see testdata/loader.c:asm_relocation()) or a call to a forward
-		// function declaration (see testdata/fwd_decl.c). Don't interfere, These
-		// remain standard symbol references.
-		// extern __kconfig reads are represented as dword loads that need to be
-		// rewritten to pseudo map loads from .kconfig. If the map is present,
-		// require it to contain the symbol to disambiguate between inline asm
-		// relos and kconfigs.
-		case ec.kconfig != nil && ins.OpCode.IsDWordLoad():
-			for _, vsi := range ec.kconfig.Value.(*btf.Datasec).Vars {
-				if vsi.Type.(*btf.Var).Name != rel.Name {
-					continue
-				}
-
-				ins.Src = asm.PseudoMapValue
-				ins.Metadata.Set(kconfigMetaKey{}, &kconfigMeta{ec.kconfig, vsi.Offset})
-				return nil
-			}
-
-			return fmt.Errorf("kconfig %s not found in .kconfig", rel.Name)
-		}
-
-	default:
-		return fmt.Errorf("relocation to %q: %w", target.Name, ErrNotSupported)
-	}
-
-	*ins = ins.WithReference(name)
-	return nil
-}
-
-func (ec *elfCode) loadMaps() error {
-	for _, sec := range ec.sections {
-		if sec.kind != mapSection {
-			continue
-		}
-
-		nSym := len(sec.symbols)
-		if nSym == 0 {
-			return fmt.Errorf("section %v: no symbols", sec.Name)
-		}
-
-		if sec.Size%uint64(nSym) != 0 {
-			return fmt.Errorf("section %v: map descriptors are not of equal size", sec.Name)
-		}
-
-		var (
-			r    = bufio.NewReader(sec.Open())
-			size = sec.Size / uint64(nSym)
-		)
-		for i, offset := 0, uint64(0); i < nSym; i, offset = i+1, offset+size {
-			mapSym, ok := sec.symbols[offset]
-			if !ok {
-				return fmt.Errorf("section %s: missing symbol for map at offset %d", sec.Name, offset)
-			}
-
-			mapName := mapSym.Name
-			if ec.maps[mapName] != nil {
-				return fmt.Errorf("section %v: map %v already exists", sec.Name, mapSym)
-			}
-
-			lr := io.LimitReader(r, int64(size))
-
-			spec := MapSpec{
-				Name: SanitizeName(mapName, -1),
-			}
-			switch {
-			case binary.Read(lr, ec.ByteOrder, &spec.Type) != nil:
-				return fmt.Errorf("map %s: missing type", mapName)
-			case binary.Read(lr, ec.ByteOrder, &spec.KeySize) != nil:
-				return fmt.Errorf("map %s: missing key size", mapName)
-			case binary.Read(lr, ec.ByteOrder, &spec.ValueSize) != nil:
-				return fmt.Errorf("map %s: missing value size", mapName)
-			case binary.Read(lr, ec.ByteOrder, &spec.MaxEntries) != nil:
-				return fmt.Errorf("map %s: missing max entries", mapName)
-			case binary.Read(lr, ec.ByteOrder, &spec.Flags) != nil:
-				return fmt.Errorf("map %s: missing flags", mapName)
-			}
-
-			extra, err := io.ReadAll(lr)
-			if err != nil {
-				return fmt.Errorf("map %s: reading map tail: %w", mapName, err)
-			}
-			if len(extra) > 0 {
-				spec.Extra = bytes.NewReader(extra)
-			}
-
-			if err := spec.clampPerfEventArraySize(); err != nil {
-				return fmt.Errorf("map %s: %w", mapName, err)
-			}
-
-			ec.maps[mapName] = &spec
-		}
-	}
-
-	return nil
-}
-
-// loadBTFMaps iterates over all ELF sections marked as BTF map sections
-// (like .maps) and parses them into MapSpecs. Dump the .maps section and
-// any relocations with `readelf -x .maps -r <elf_file>`.
-func (ec *elfCode) loadBTFMaps() error {
-	for _, sec := range ec.sections {
-		if sec.kind != btfMapSection {
-			continue
-		}
-
-		if ec.btf == nil {
-			return fmt.Errorf("missing BTF")
-		}
-
-		// Each section must appear as a DataSec in the ELF's BTF blob.
-		var ds *btf.Datasec
-		if err := ec.btf.TypeByName(sec.Name, &ds); err != nil {
-			return fmt.Errorf("cannot find section '%s' in BTF: %w", sec.Name, err)
-		}
-
-		// Open a Reader to the ELF's raw section bytes so we can assert that all
-		// of them are zero on a per-map (per-Var) basis. For now, the section's
-		// sole purpose is to receive relocations, so all must be zero.
-		rs := sec.Open()
-
-		for _, vs := range ds.Vars {
-			// BPF maps are declared as and assigned to global variables,
-			// so iterate over each Var in the DataSec and validate their types.
-			v, ok := vs.Type.(*btf.Var)
-			if !ok {
-				return fmt.Errorf("section %v: unexpected type %s", sec.Name, vs.Type)
-			}
-			name := string(v.Name)
-
-			// The BTF metadata for each Var contains the full length of the map
-			// declaration, so read the corresponding amount of bytes from the ELF.
-			// This way, we can pinpoint which map declaration contains unexpected
-			// (and therefore unsupported) data.
-			_, err := io.Copy(internal.DiscardZeroes{}, io.LimitReader(rs, int64(vs.Size)))
-			if err != nil {
-				return fmt.Errorf("section %v: map %s: initializing BTF map definitions: %w", sec.Name, name, internal.ErrNotSupported)
-			}
-
-			if ec.maps[name] != nil {
-				return fmt.Errorf("section %v: map %s already exists", sec.Name, name)
-			}
-
-			// Each Var representing a BTF map definition contains a Struct.
-			mapStruct, ok := v.Type.(*btf.Struct)
-			if !ok {
-				return fmt.Errorf("expected struct, got %s", v.Type)
-			}
-
-			mapSpec, err := mapSpecFromBTF(sec, &vs, mapStruct, ec.btf, name, false)
-			if err != nil {
-				return fmt.Errorf("map %v: %w", name, err)
-			}
-
-			if err := mapSpec.clampPerfEventArraySize(); err != nil {
-				return fmt.Errorf("map %v: %w", name, err)
-			}
-
-			ec.maps[name] = mapSpec
-		}
-
-		// Drain the ELF section reader to make sure all bytes are accounted for
-		// with BTF metadata.
-		i, err := io.Copy(io.Discard, rs)
-		if err != nil {
-			return fmt.Errorf("section %v: unexpected error reading remainder of ELF section: %w", sec.Name, err)
-		}
-		if i > 0 {
-			return fmt.Errorf("section %v: %d unexpected remaining bytes in ELF section, invalid BTF?", sec.Name, i)
-		}
-	}
-
-	return nil
-}
-
-// mapSpecFromBTF produces a MapSpec based on a btf.Struct def representing
-// a BTF map definition. The name and spec arguments will be copied to the
-// resulting MapSpec, and inner must be true on any resursive invocations.
-func mapSpecFromBTF(es *elfSection, vs *btf.VarSecinfo, def *btf.Struct, spec *btf.Spec, name string, inner bool) (*MapSpec, error) {
-	var (
-		key, value         btf.Type
-		keySize, valueSize uint32
-		mapType            MapType
-		flags, maxEntries  uint32
-		pinType            PinType
-		innerMapSpec       *MapSpec
-		contents           []MapKV
-		err                error
-	)
-
-	for i, member := range def.Members {
-		switch member.Name {
-		case "type":
-			mt, err := uintFromBTF(member.Type)
-			if err != nil {
-				return nil, fmt.Errorf("can't get type: %w", err)
-			}
-			mapType = MapType(mt)
-
-		case "map_flags":
-			flags, err = uintFromBTF(member.Type)
-			if err != nil {
-				return nil, fmt.Errorf("can't get BTF map flags: %w", err)
-			}
-
-		case "max_entries":
-			maxEntries, err = uintFromBTF(member.Type)
-			if err != nil {
-				return nil, fmt.Errorf("can't get BTF map max entries: %w", err)
-			}
-
-		case "key":
-			if keySize != 0 {
-				return nil, errors.New("both key and key_size given")
-			}
-
-			pk, ok := member.Type.(*btf.Pointer)
-			if !ok {
-				return nil, fmt.Errorf("key type is not a pointer: %T", member.Type)
-			}
-
-			key = pk.Target
-
-			size, err := btf.Sizeof(pk.Target)
-			if err != nil {
-				return nil, fmt.Errorf("can't get size of BTF key: %w", err)
-			}
-
-			keySize = uint32(size)
-
-		case "value":
-			if valueSize != 0 {
-				return nil, errors.New("both value and value_size given")
-			}
-
-			vk, ok := member.Type.(*btf.Pointer)
-			if !ok {
-				return nil, fmt.Errorf("value type is not a pointer: %T", member.Type)
-			}
-
-			value = vk.Target
-
-			size, err := btf.Sizeof(vk.Target)
-			if err != nil {
-				return nil, fmt.Errorf("can't get size of BTF value: %w", err)
-			}
-
-			valueSize = uint32(size)
-
-		case "key_size":
-			// Key needs to be nil and keySize needs to be 0 for key_size to be
-			// considered a valid member.
-			if key != nil || keySize != 0 {
-				return nil, errors.New("both key and key_size given")
-			}
-
-			keySize, err = uintFromBTF(member.Type)
-			if err != nil {
-				return nil, fmt.Errorf("can't get BTF key size: %w", err)
-			}
-
-		case "value_size":
-			// Value needs to be nil and valueSize needs to be 0 for value_size to be
-			// considered a valid member.
-			if value != nil || valueSize != 0 {
-				return nil, errors.New("both value and value_size given")
-			}
-
-			valueSize, err = uintFromBTF(member.Type)
-			if err != nil {
-				return nil, fmt.Errorf("can't get BTF value size: %w", err)
-			}
-
-		case "pinning":
-			if inner {
-				return nil, errors.New("inner maps can't be pinned")
-			}
-
-			pinning, err := uintFromBTF(member.Type)
-			if err != nil {
-				return nil, fmt.Errorf("can't get pinning: %w", err)
-			}
-
-			pinType = PinType(pinning)
-
-		case "values":
-			// The 'values' field in BTF map definitions is used for declaring map
-			// value types that are references to other BPF objects, like other maps
-			// or programs. It is always expected to be an array of pointers.
-			if i != len(def.Members)-1 {
-				return nil, errors.New("'values' must be the last member in a BTF map definition")
-			}
-
-			if valueSize != 0 && valueSize != 4 {
-				return nil, errors.New("value_size must be 0 or 4")
-			}
-			valueSize = 4
-
-			valueType, err := resolveBTFArrayMacro(member.Type)
-			if err != nil {
-				return nil, fmt.Errorf("can't resolve type of member 'values': %w", err)
-			}
-
-			switch t := valueType.(type) {
-			case *btf.Struct:
-				// The values member pointing to an array of structs means we're expecting
-				// a map-in-map declaration.
-				if mapType != ArrayOfMaps && mapType != HashOfMaps {
-					return nil, errors.New("outer map needs to be an array or a hash of maps")
-				}
-				if inner {
-					return nil, fmt.Errorf("nested inner maps are not supported")
-				}
-
-				// This inner map spec is used as a map template, but it needs to be
-				// created as a traditional map before it can be used to do so.
-				// libbpf names the inner map template '<outer_name>.inner', but we
-				// opted for _inner to simplify validation logic. (dots only supported
-				// on kernels 5.2 and up)
-				// Pass the BTF spec from the parent object, since both parent and
-				// child must be created from the same BTF blob (on kernels that support BTF).
-				innerMapSpec, err = mapSpecFromBTF(es, vs, t, spec, name+"_inner", true)
-				if err != nil {
-					return nil, fmt.Errorf("can't parse BTF map definition of inner map: %w", err)
-				}
-
-			case *btf.FuncProto:
-				// The values member contains an array of function pointers, meaning an
-				// autopopulated PROG_ARRAY.
-				if mapType != ProgramArray {
-					return nil, errors.New("map needs to be a program array")
-				}
-
-			default:
-				return nil, fmt.Errorf("unsupported value type %q in 'values' field", t)
-			}
-
-			contents, err = resolveBTFValuesContents(es, vs, member)
-			if err != nil {
-				return nil, fmt.Errorf("resolving values contents: %w", err)
-			}
-
-		default:
-			return nil, fmt.Errorf("unrecognized field %s in BTF map definition", member.Name)
-		}
-	}
-
-	return &MapSpec{
-		Name:       SanitizeName(name, -1),
-		Type:       MapType(mapType),
-		KeySize:    keySize,
-		ValueSize:  valueSize,
-		MaxEntries: maxEntries,
-		Flags:      flags,
-		Key:        key,
-		Value:      value,
-		Pinning:    pinType,
-		InnerMap:   innerMapSpec,
-		Contents:   contents,
-	}, nil
-}
-
-// uintFromBTF resolves the __uint macro, which is a pointer to a sized
-// array, e.g. for int (*foo)[10], this function will return 10.
-func uintFromBTF(typ btf.Type) (uint32, error) {
-	ptr, ok := typ.(*btf.Pointer)
-	if !ok {
-		return 0, fmt.Errorf("not a pointer: %v", typ)
-	}
-
-	arr, ok := ptr.Target.(*btf.Array)
-	if !ok {
-		return 0, fmt.Errorf("not a pointer to array: %v", typ)
-	}
-
-	return arr.Nelems, nil
-}
-
-// resolveBTFArrayMacro resolves the __array macro, which declares an array
-// of pointers to a given type. This function returns the target Type of
-// the pointers in the array.
-func resolveBTFArrayMacro(typ btf.Type) (btf.Type, error) {
-	arr, ok := typ.(*btf.Array)
-	if !ok {
-		return nil, fmt.Errorf("not an array: %v", typ)
-	}
-
-	ptr, ok := arr.Type.(*btf.Pointer)
-	if !ok {
-		return nil, fmt.Errorf("not an array of pointers: %v", typ)
-	}
-
-	return ptr.Target, nil
-}
-
-// resolveBTFValuesContents resolves relocations into ELF sections belonging
-// to btf.VarSecinfo's. This can be used on the 'values' member in BTF map
-// definitions to extract static declarations of map contents.
-func resolveBTFValuesContents(es *elfSection, vs *btf.VarSecinfo, member btf.Member) ([]MapKV, error) {
-	// The elements of a .values pointer array are not encoded in BTF.
-	// Instead, relocations are generated into each array index.
-	// However, it's possible to leave certain array indices empty, so all
-	// indices' offsets need to be checked for emitted relocations.
-
-	// The offset of the 'values' member within the _struct_ (in bits)
-	// is the starting point of the array. Convert to bytes. Add VarSecinfo
-	// offset to get the absolute position in the ELF blob.
-	start := member.Offset.Bytes() + vs.Offset
-	// 'values' is encoded in BTF as a zero (variable) length struct
-	// member, and its contents run until the end of the VarSecinfo.
-	// Add VarSecinfo offset to get the absolute position in the ELF blob.
-	end := vs.Size + vs.Offset
-	// The size of an address in this section. This determines the width of
-	// an index in the array.
-	align := uint32(es.SectionHeader.Addralign)
-
-	// Check if variable-length section is aligned.
-	if (end-start)%align != 0 {
-		return nil, errors.New("unaligned static values section")
-	}
-	elems := (end - start) / align
-
-	if elems == 0 {
-		return nil, nil
-	}
-
-	contents := make([]MapKV, 0, elems)
-
-	// k is the array index, off is its corresponding ELF section offset.
-	for k, off := uint32(0), start; k < elems; k, off = k+1, off+align {
-		r, ok := es.relocations[uint64(off)]
-		if !ok {
-			continue
-		}
-
-		// Relocation exists for the current offset in the ELF section.
-		// Emit a value stub based on the type of relocation to be replaced by
-		// a real fd later in the pipeline before populating the map.
-		// Map keys are encoded in MapKV entries, so empty array indices are
-		// skipped here.
-		switch t := elf.ST_TYPE(r.Info); t {
-		case elf.STT_FUNC:
-			contents = append(contents, MapKV{uint32(k), r.Name})
-		case elf.STT_OBJECT:
-			contents = append(contents, MapKV{uint32(k), r.Name})
-		default:
-			return nil, fmt.Errorf("unknown relocation type %v for symbol %s", t, r.Name)
-		}
-	}
-
-	return contents, nil
-}
-
-func (ec *elfCode) loadDataSections() error {
-	for _, sec := range ec.sections {
-		if sec.kind != dataSection {
-			continue
-		}
-
-		if sec.references == 0 {
-			// Prune data sections which are not referenced by any
-			// instructions.
-			continue
-		}
-
-		mapSpec := &MapSpec{
-			Name:       SanitizeName(sec.Name, -1),
-			Type:       Array,
-			KeySize:    4,
-			ValueSize:  uint32(sec.Size),
-			MaxEntries: 1,
-		}
-
-		switch sec.Type {
-		// Only open the section if we know there's actual data to be read.
-		case elf.SHT_PROGBITS:
-			data, err := sec.Data()
-			if err != nil {
-				return fmt.Errorf("data section %s: can't get contents: %w", sec.Name, err)
-			}
-
-			if uint64(len(data)) > math.MaxUint32 {
-				return fmt.Errorf("data section %s: contents exceed maximum size", sec.Name)
-			}
-			mapSpec.Contents = []MapKV{{uint32(0), data}}
-
-		case elf.SHT_NOBITS:
-			// NOBITS sections like .bss contain only zeroes, and since data sections
-			// are Arrays, the kernel already preallocates them. Skip reading zeroes
-			// from the ELF.
-		default:
-			return fmt.Errorf("data section %s: unknown section type %s", sec.Name, sec.Type)
-		}
-
-		// It is possible for a data section to exist without a corresponding BTF Datasec
-		// if it only contains anonymous values like macro-defined arrays.
-		if ec.btf != nil {
-			var ds *btf.Datasec
-			if ec.btf.TypeByName(sec.Name, &ds) == nil {
-				// Assign the spec's key and BTF only if the Datasec lookup was successful.
-				mapSpec.Key = &btf.Void{}
-				mapSpec.Value = ds
-			}
-		}
-
-		if strings.HasPrefix(sec.Name, ".rodata") {
-			mapSpec.Flags = unix.BPF_F_RDONLY_PROG
-			mapSpec.Freeze = true
-		}
-
-		ec.maps[sec.Name] = mapSpec
-	}
-
-	return nil
-}
-
-// loadKconfigSection handles the 'virtual' Datasec .kconfig that doesn't
-// have a corresponding ELF section and exist purely in BTF.
-func (ec *elfCode) loadKconfigSection() error {
-	if ec.btf == nil {
-		return nil
-	}
-
-	var ds *btf.Datasec
-	err := ec.btf.TypeByName(".kconfig", &ds)
-	if errors.Is(err, btf.ErrNotFound) {
-		return nil
-	}
-	if err != nil {
-		return err
-	}
-
-	if ds.Size == 0 {
-		return errors.New("zero-length .kconfig")
-	}
-
-	ec.kconfig = &MapSpec{
-		Name:       ".kconfig",
-		Type:       Array,
-		KeySize:    uint32(4),
-		ValueSize:  ds.Size,
-		MaxEntries: 1,
-		Flags:      unix.BPF_F_RDONLY_PROG | unix.BPF_F_MMAPABLE,
-		Freeze:     true,
-		Key:        &btf.Int{Size: 4},
-		Value:      ds,
-	}
-
-	return nil
-}
-
-// loadKsymsSection handles the 'virtual' Datasec .ksyms that doesn't
-// have a corresponding ELF section and exist purely in BTF.
-func (ec *elfCode) loadKsymsSection() error {
-	if ec.btf == nil {
-		return nil
-	}
-
-	var ds *btf.Datasec
-	err := ec.btf.TypeByName(".ksyms", &ds)
-	if errors.Is(err, btf.ErrNotFound) {
-		return nil
-	}
-	if err != nil {
-		return err
-	}
-
-	for _, v := range ds.Vars {
-		// we have already checked the .ksyms Datasec to only contain Func Vars.
-		ec.kfuncs[v.Type.TypeName()] = v.Type.(*btf.Func)
-	}
-
-	return nil
-}
-
-func getProgType(sectionName string) (ProgramType, AttachType, uint32, string) {
-	types := []struct {
-		prefix     string
-		progType   ProgramType
-		attachType AttachType
-		progFlags  uint32
-	}{
-		// Please update the types from libbpf.c and follow the order of it.
-		// https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/tools/lib/bpf/libbpf.c
-		{"socket", SocketFilter, AttachNone, 0},
-		{"sk_reuseport/migrate", SkReuseport, AttachSkReuseportSelectOrMigrate, 0},
-		{"sk_reuseport", SkReuseport, AttachSkReuseportSelect, 0},
-		{"kprobe/", Kprobe, AttachNone, 0},
-		{"uprobe/", Kprobe, AttachNone, 0},
-		{"kretprobe/", Kprobe, AttachNone, 0},
-		{"uretprobe/", Kprobe, AttachNone, 0},
-		{"tc", SchedCLS, AttachNone, 0},
-		{"classifier", SchedCLS, AttachNone, 0},
-		{"action", SchedACT, AttachNone, 0},
-		{"tracepoint/", TracePoint, AttachNone, 0},
-		{"tp/", TracePoint, AttachNone, 0},
-		{"raw_tracepoint/", RawTracepoint, AttachNone, 0},
-		{"raw_tp/", RawTracepoint, AttachNone, 0},
-		{"raw_tracepoint.w/", RawTracepointWritable, AttachNone, 0},
-		{"raw_tp.w/", RawTracepointWritable, AttachNone, 0},
-		{"tp_btf/", Tracing, AttachTraceRawTp, 0},
-		{"fentry/", Tracing, AttachTraceFEntry, 0},
-		{"fmod_ret/", Tracing, AttachModifyReturn, 0},
-		{"fexit/", Tracing, AttachTraceFExit, 0},
-		{"fentry.s/", Tracing, AttachTraceFEntry, unix.BPF_F_SLEEPABLE},
-		{"fmod_ret.s/", Tracing, AttachModifyReturn, unix.BPF_F_SLEEPABLE},
-		{"fexit.s/", Tracing, AttachTraceFExit, unix.BPF_F_SLEEPABLE},
-		{"freplace/", Extension, AttachNone, 0},
-		{"lsm/", LSM, AttachLSMMac, 0},
-		{"lsm.s/", LSM, AttachLSMMac, unix.BPF_F_SLEEPABLE},
-		{"iter/", Tracing, AttachTraceIter, 0},
-		{"iter.s/", Tracing, AttachTraceIter, unix.BPF_F_SLEEPABLE},
-		{"syscall", Syscall, AttachNone, 0},
-		{"xdp.frags_devmap/", XDP, AttachXDPDevMap, unix.BPF_F_XDP_HAS_FRAGS},
-		{"xdp_devmap/", XDP, AttachXDPDevMap, 0},
-		{"xdp.frags_cpumap/", XDP, AttachXDPCPUMap, unix.BPF_F_XDP_HAS_FRAGS},
-		{"xdp_cpumap/", XDP, AttachXDPCPUMap, 0},
-		{"xdp.frags", XDP, AttachNone, unix.BPF_F_XDP_HAS_FRAGS},
-		{"xdp", XDP, AttachNone, 0},
-		{"perf_event", PerfEvent, AttachNone, 0},
-		{"lwt_in", LWTIn, AttachNone, 0},
-		{"lwt_out", LWTOut, AttachNone, 0},
-		{"lwt_xmit", LWTXmit, AttachNone, 0},
-		{"lwt_seg6local", LWTSeg6Local, AttachNone, 0},
-		{"cgroup_skb/ingress", CGroupSKB, AttachCGroupInetIngress, 0},
-		{"cgroup_skb/egress", CGroupSKB, AttachCGroupInetEgress, 0},
-		{"cgroup/skb", CGroupSKB, AttachNone, 0},
-		{"cgroup/sock_create", CGroupSock, AttachCGroupInetSockCreate, 0},
-		{"cgroup/sock_release", CGroupSock, AttachCgroupInetSockRelease, 0},
-		{"cgroup/sock", CGroupSock, AttachCGroupInetSockCreate, 0},
-		{"cgroup/post_bind4", CGroupSock, AttachCGroupInet4PostBind, 0},
-		{"cgroup/post_bind6", CGroupSock, AttachCGroupInet6PostBind, 0},
-		{"cgroup/dev", CGroupDevice, AttachCGroupDevice, 0},
-		{"sockops", SockOps, AttachCGroupSockOps, 0},
-		{"sk_skb/stream_parser", SkSKB, AttachSkSKBStreamParser, 0},
-		{"sk_skb/stream_verdict", SkSKB, AttachSkSKBStreamVerdict, 0},
-		{"sk_skb", SkSKB, AttachNone, 0},
-		{"sk_msg", SkMsg, AttachSkMsgVerdict, 0},
-		{"lirc_mode2", LircMode2, AttachLircMode2, 0},
-		{"flow_dissector", FlowDissector, AttachFlowDissector, 0},
-		{"cgroup/bind4", CGroupSockAddr, AttachCGroupInet4Bind, 0},
-		{"cgroup/bind6", CGroupSockAddr, AttachCGroupInet6Bind, 0},
-		{"cgroup/connect4", CGroupSockAddr, AttachCGroupInet4Connect, 0},
-		{"cgroup/connect6", CGroupSockAddr, AttachCGroupInet6Connect, 0},
-		{"cgroup/sendmsg4", CGroupSockAddr, AttachCGroupUDP4Sendmsg, 0},
-		{"cgroup/sendmsg6", CGroupSockAddr, AttachCGroupUDP6Sendmsg, 0},
-		{"cgroup/recvmsg4", CGroupSockAddr, AttachCGroupUDP4Recvmsg, 0},
-		{"cgroup/recvmsg6", CGroupSockAddr, AttachCGroupUDP6Recvmsg, 0},
-		{"cgroup/getpeername4", CGroupSockAddr, AttachCgroupInet4GetPeername, 0},
-		{"cgroup/getpeername6", CGroupSockAddr, AttachCgroupInet6GetPeername, 0},
-		{"cgroup/getsockname4", CGroupSockAddr, AttachCgroupInet4GetSockname, 0},
-		{"cgroup/getsockname6", CGroupSockAddr, AttachCgroupInet6GetSockname, 0},
-		{"cgroup/sysctl", CGroupSysctl, AttachCGroupSysctl, 0},
-		{"cgroup/getsockopt", CGroupSockopt, AttachCGroupGetsockopt, 0},
-		{"cgroup/setsockopt", CGroupSockopt, AttachCGroupSetsockopt, 0},
-		{"struct_ops+", StructOps, AttachNone, 0},
-		{"sk_lookup/", SkLookup, AttachSkLookup, 0},
-		{"seccomp", SocketFilter, AttachNone, 0},
-		{"kprobe.multi", Kprobe, AttachTraceKprobeMulti, 0},
-		{"kretprobe.multi", Kprobe, AttachTraceKprobeMulti, 0},
-	}
-
-	for _, t := range types {
-		if !strings.HasPrefix(sectionName, t.prefix) {
-			continue
-		}
-
-		if !strings.HasSuffix(t.prefix, "/") {
-			return t.progType, t.attachType, t.progFlags, ""
-		}
-
-		return t.progType, t.attachType, t.progFlags, sectionName[len(t.prefix):]
-	}
-
-	return UnspecifiedProgram, AttachNone, 0, ""
-}
-
-func (ec *elfCode) loadSectionRelocations(sec *elf.Section, symbols []elf.Symbol) (map[uint64]elf.Symbol, error) {
-	rels := make(map[uint64]elf.Symbol)
-
-	if sec.Entsize < 16 {
-		return nil, fmt.Errorf("section %s: relocations are less than 16 bytes", sec.Name)
-	}
-
-	r := bufio.NewReader(sec.Open())
-	for off := uint64(0); off < sec.Size; off += sec.Entsize {
-		ent := io.LimitReader(r, int64(sec.Entsize))
-
-		var rel elf.Rel64
-		if binary.Read(ent, ec.ByteOrder, &rel) != nil {
-			return nil, fmt.Errorf("can't parse relocation at offset %v", off)
-		}
-
-		symNo := int(elf.R_SYM64(rel.Info) - 1)
-		if symNo >= len(symbols) {
-			return nil, fmt.Errorf("offset %d: symbol %d doesn't exist", off, symNo)
-		}
-
-		symbol := symbols[symNo]
-		rels[rel.Off] = symbol
-	}
-
-	return rels, nil
-}
diff --git a/vendor/github.com/cilium/ebpf/info.go b/vendor/github.com/cilium/ebpf/info.go
deleted file mode 100644
index a02e8a416..000000000
--- a/vendor/github.com/cilium/ebpf/info.go
+++ /dev/null
@@ -1,373 +0,0 @@
-package ebpf
-
-import (
-	"bufio"
-	"bytes"
-	"encoding/hex"
-	"errors"
-	"fmt"
-	"io"
-	"os"
-	"strings"
-	"syscall"
-	"time"
-	"unsafe"
-
-	"github.com/cilium/ebpf/asm"
-	"github.com/cilium/ebpf/btf"
-	"github.com/cilium/ebpf/internal"
-	"github.com/cilium/ebpf/internal/sys"
-	"github.com/cilium/ebpf/internal/unix"
-)
-
-// MapInfo describes a map.
-type MapInfo struct {
-	Type       MapType
-	id         MapID
-	KeySize    uint32
-	ValueSize  uint32
-	MaxEntries uint32
-	Flags      uint32
-	// Name as supplied by user space at load time. Available from 4.15.
-	Name string
-}
-
-func newMapInfoFromFd(fd *sys.FD) (*MapInfo, error) {
-	var info sys.MapInfo
-	err := sys.ObjInfo(fd, &info)
-	if errors.Is(err, syscall.EINVAL) {
-		return newMapInfoFromProc(fd)
-	}
-	if err != nil {
-		return nil, err
-	}
-
-	return &MapInfo{
-		MapType(info.Type),
-		MapID(info.Id),
-		info.KeySize,
-		info.ValueSize,
-		info.MaxEntries,
-		uint32(info.MapFlags),
-		unix.ByteSliceToString(info.Name[:]),
-	}, nil
-}
-
-func newMapInfoFromProc(fd *sys.FD) (*MapInfo, error) {
-	var mi MapInfo
-	err := scanFdInfo(fd, map[string]interface{}{
-		"map_type":    &mi.Type,
-		"key_size":    &mi.KeySize,
-		"value_size":  &mi.ValueSize,
-		"max_entries": &mi.MaxEntries,
-		"map_flags":   &mi.Flags,
-	})
-	if err != nil {
-		return nil, err
-	}
-	return &mi, nil
-}
-
-// ID returns the map ID.
-//
-// Available from 4.13.
-//
-// The bool return value indicates whether this optional field is available.
-func (mi *MapInfo) ID() (MapID, bool) {
-	return mi.id, mi.id > 0
-}
-
-// programStats holds statistics of a program.
-type programStats struct {
-	// Total accumulated runtime of the program ins ns.
-	runtime time.Duration
-	// Total number of times the program was called.
-	runCount uint64
-}
-
-// ProgramInfo describes a program.
-type ProgramInfo struct {
-	Type ProgramType
-	id   ProgramID
-	// Truncated hash of the BPF bytecode. Available from 4.13.
-	Tag string
-	// Name as supplied by user space at load time. Available from 4.15.
-	Name string
-
-	createdByUID     uint32
-	haveCreatedByUID bool
-	btf              btf.ID
-	stats            *programStats
-
-	maps  []MapID
-	insns []byte
-}
-
-func newProgramInfoFromFd(fd *sys.FD) (*ProgramInfo, error) {
-	var info sys.ProgInfo
-	err := sys.ObjInfo(fd, &info)
-	if errors.Is(err, syscall.EINVAL) {
-		return newProgramInfoFromProc(fd)
-	}
-	if err != nil {
-		return nil, err
-	}
-
-	pi := ProgramInfo{
-		Type: ProgramType(info.Type),
-		id:   ProgramID(info.Id),
-		Tag:  hex.EncodeToString(info.Tag[:]),
-		Name: unix.ByteSliceToString(info.Name[:]),
-		btf:  btf.ID(info.BtfId),
-		stats: &programStats{
-			runtime:  time.Duration(info.RunTimeNs),
-			runCount: info.RunCnt,
-		},
-	}
-
-	// Start with a clean struct for the second call, otherwise we may get EFAULT.
-	var info2 sys.ProgInfo
-
-	if info.NrMapIds > 0 {
-		pi.maps = make([]MapID, info.NrMapIds)
-		info2.NrMapIds = info.NrMapIds
-		info2.MapIds = sys.NewPointer(unsafe.Pointer(&pi.maps[0]))
-	} else if haveProgramInfoMapIDs() == nil {
-		// This program really has no associated maps.
-		pi.maps = make([]MapID, 0)
-	} else {
-		// The kernel doesn't report associated maps.
-		pi.maps = nil
-	}
-
-	// createdByUID and NrMapIds were introduced in the same kernel version.
-	if pi.maps != nil {
-		pi.createdByUID = info.CreatedByUid
-		pi.haveCreatedByUID = true
-	}
-
-	if info.XlatedProgLen > 0 {
-		pi.insns = make([]byte, info.XlatedProgLen)
-		info2.XlatedProgLen = info.XlatedProgLen
-		info2.XlatedProgInsns = sys.NewSlicePointer(pi.insns)
-	}
-
-	if info.NrMapIds > 0 || info.XlatedProgLen > 0 {
-		if err := sys.ObjInfo(fd, &info2); err != nil {
-			return nil, err
-		}
-	}
-
-	return &pi, nil
-}
-
-func newProgramInfoFromProc(fd *sys.FD) (*ProgramInfo, error) {
-	var info ProgramInfo
-	err := scanFdInfo(fd, map[string]interface{}{
-		"prog_type": &info.Type,
-		"prog_tag":  &info.Tag,
-	})
-	if errors.Is(err, errMissingFields) {
-		return nil, &internal.UnsupportedFeatureError{
-			Name:           "reading program info from /proc/self/fdinfo",
-			MinimumVersion: internal.Version{4, 10, 0},
-		}
-	}
-	if err != nil {
-		return nil, err
-	}
-
-	return &info, nil
-}
-
-// ID returns the program ID.
-//
-// Available from 4.13.
-//
-// The bool return value indicates whether this optional field is available.
-func (pi *ProgramInfo) ID() (ProgramID, bool) {
-	return pi.id, pi.id > 0
-}
-
-// CreatedByUID returns the Uid that created the program.
-//
-// Available from 4.15.
-//
-// The bool return value indicates whether this optional field is available.
-func (pi *ProgramInfo) CreatedByUID() (uint32, bool) {
-	return pi.createdByUID, pi.haveCreatedByUID
-}
-
-// BTFID returns the BTF ID associated with the program.
-//
-// The ID is only valid as long as the associated program is kept alive.
-// Available from 5.0.
-//
-// The bool return value indicates whether this optional field is available and
-// populated. (The field may be available but not populated if the kernel
-// supports the field but the program was loaded without BTF information.)
-func (pi *ProgramInfo) BTFID() (btf.ID, bool) {
-	return pi.btf, pi.btf > 0
-}
-
-// RunCount returns the total number of times the program was called.
-//
-// Can return 0 if the collection of statistics is not enabled. See EnableStats().
-// The bool return value indicates whether this optional field is available.
-func (pi *ProgramInfo) RunCount() (uint64, bool) {
-	if pi.stats != nil {
-		return pi.stats.runCount, true
-	}
-	return 0, false
-}
-
-// Runtime returns the total accumulated runtime of the program.
-//
-// Can return 0 if the collection of statistics is not enabled. See EnableStats().
-// The bool return value indicates whether this optional field is available.
-func (pi *ProgramInfo) Runtime() (time.Duration, bool) {
-	if pi.stats != nil {
-		return pi.stats.runtime, true
-	}
-	return time.Duration(0), false
-}
-
-// Instructions returns the 'xlated' instruction stream of the program
-// after it has been verified and rewritten by the kernel. These instructions
-// cannot be loaded back into the kernel as-is, this is mainly used for
-// inspecting loaded programs for troubleshooting, dumping, etc.
-//
-// For example, map accesses are made to reference their kernel map IDs,
-// not the FDs they had when the program was inserted. Note that before
-// the introduction of bpf_insn_prepare_dump in kernel 4.16, xlated
-// instructions were not sanitized, making the output even less reusable
-// and less likely to round-trip or evaluate to the same program Tag.
-//
-// The first instruction is marked as a symbol using the Program's name.
-//
-// Available from 4.13. Requires CAP_BPF or equivalent.
-func (pi *ProgramInfo) Instructions() (asm.Instructions, error) {
-	// If the calling process is not BPF-capable or if the kernel doesn't
-	// support getting xlated instructions, the field will be zero.
-	if len(pi.insns) == 0 {
-		return nil, fmt.Errorf("insufficient permissions or unsupported kernel: %w", ErrNotSupported)
-	}
-
-	r := bytes.NewReader(pi.insns)
-	var insns asm.Instructions
-	if err := insns.Unmarshal(r, internal.NativeEndian); err != nil {
-		return nil, fmt.Errorf("unmarshaling instructions: %w", err)
-	}
-
-	// Tag the first instruction with the name of the program, if available.
-	insns[0] = insns[0].WithSymbol(pi.Name)
-
-	return insns, nil
-}
-
-// MapIDs returns the maps related to the program.
-//
-// Available from 4.15.
-//
-// The bool return value indicates whether this optional field is available.
-func (pi *ProgramInfo) MapIDs() ([]MapID, bool) {
-	return pi.maps, pi.maps != nil
-}
-
-func scanFdInfo(fd *sys.FD, fields map[string]interface{}) error {
-	fh, err := os.Open(fmt.Sprintf("/proc/self/fdinfo/%d", fd.Int()))
-	if err != nil {
-		return err
-	}
-	defer fh.Close()
-
-	if err := scanFdInfoReader(fh, fields); err != nil {
-		return fmt.Errorf("%s: %w", fh.Name(), err)
-	}
-	return nil
-}
-
-var errMissingFields = errors.New("missing fields")
-
-func scanFdInfoReader(r io.Reader, fields map[string]interface{}) error {
-	var (
-		scanner = bufio.NewScanner(r)
-		scanned int
-	)
-
-	for scanner.Scan() {
-		parts := strings.SplitN(scanner.Text(), "\t", 2)
-		if len(parts) != 2 {
-			continue
-		}
-
-		name := strings.TrimSuffix(parts[0], ":")
-		field, ok := fields[string(name)]
-		if !ok {
-			continue
-		}
-
-		if n, err := fmt.Sscanln(parts[1], field); err != nil || n != 1 {
-			return fmt.Errorf("can't parse field %s: %v", name, err)
-		}
-
-		scanned++
-	}
-
-	if err := scanner.Err(); err != nil {
-		return err
-	}
-
-	if len(fields) > 0 && scanned == 0 {
-		return ErrNotSupported
-	}
-
-	if scanned != len(fields) {
-		return errMissingFields
-	}
-
-	return nil
-}
-
-// EnableStats starts the measuring of the runtime
-// and run counts of eBPF programs.
-//
-// Collecting statistics can have an impact on the performance.
-//
-// Requires at least 5.8.
-func EnableStats(which uint32) (io.Closer, error) {
-	fd, err := sys.EnableStats(&sys.EnableStatsAttr{
-		Type: which,
-	})
-	if err != nil {
-		return nil, err
-	}
-	return fd, nil
-}
-
-var haveProgramInfoMapIDs = internal.NewFeatureTest("map IDs in program info", "4.15", func() error {
-	prog, err := progLoad(asm.Instructions{
-		asm.LoadImm(asm.R0, 0, asm.DWord),
-		asm.Return(),
-	}, SocketFilter, "MIT")
-	if err != nil {
-		return err
-	}
-	defer prog.Close()
-
-	err = sys.ObjInfo(prog, &sys.ProgInfo{
-		// NB: Don't need to allocate MapIds since the program isn't using
-		// any maps.
-		NrMapIds: 1,
-	})
-	if errors.Is(err, unix.EINVAL) {
-		// Most likely the syscall doesn't exist.
-		return internal.ErrNotSupported
-	}
-	if errors.Is(err, unix.E2BIG) {
-		// We've hit check_uarg_tail_zero on older kernels.
-		return internal.ErrNotSupported
-	}
-
-	return err
-})
diff --git a/vendor/github.com/cilium/ebpf/internal/align.go b/vendor/github.com/cilium/ebpf/internal/align.go
deleted file mode 100644
index edc898fa9..000000000
--- a/vendor/github.com/cilium/ebpf/internal/align.go
+++ /dev/null
@@ -1,8 +0,0 @@
-package internal
-
-import "golang.org/x/exp/constraints"
-
-// Align returns 'n' updated to 'alignment' boundary.
-func Align[I constraints.Integer](n, alignment I) I {
-	return (n + alignment - 1) / alignment * alignment
-}
diff --git a/vendor/github.com/cilium/ebpf/internal/buffer.go b/vendor/github.com/cilium/ebpf/internal/buffer.go
deleted file mode 100644
index 81c654433..000000000
--- a/vendor/github.com/cilium/ebpf/internal/buffer.go
+++ /dev/null
@@ -1,31 +0,0 @@
-package internal
-
-import (
-	"bytes"
-	"sync"
-)
-
-var bytesBufferPool = sync.Pool{
-	New: func() interface{} {
-		return new(bytes.Buffer)
-	},
-}
-
-// NewBuffer retrieves a [bytes.Buffer] from a pool an re-initialises it.
-//
-// The returned buffer should be passed to [PutBuffer].
-func NewBuffer(buf []byte) *bytes.Buffer {
-	wr := bytesBufferPool.Get().(*bytes.Buffer)
-	// Reinitialize the Buffer with a new backing slice since it is returned to
-	// the caller by wr.Bytes() below. Pooling is faster despite calling
-	// NewBuffer. The pooled alloc is still reused, it only needs to be zeroed.
-	*wr = *bytes.NewBuffer(buf)
-	return wr
-}
-
-// PutBuffer releases a buffer to the pool.
-func PutBuffer(buf *bytes.Buffer) {
-	// Release reference to the backing buffer.
-	*buf = *bytes.NewBuffer(nil)
-	bytesBufferPool.Put(buf)
-}
diff --git a/vendor/github.com/cilium/ebpf/internal/cpu.go b/vendor/github.com/cilium/ebpf/internal/cpu.go
deleted file mode 100644
index 9e908b610..000000000
--- a/vendor/github.com/cilium/ebpf/internal/cpu.go
+++ /dev/null
@@ -1,51 +0,0 @@
-package internal
-
-import (
-	"fmt"
-	"os"
-	"strings"
-)
-
-// PossibleCPUs returns the max number of CPUs a system may possibly have
-// Logical CPU numbers must be of the form 0-n
-var PossibleCPUs = Memoize(func() (int, error) {
-	return parseCPUsFromFile("/sys/devices/system/cpu/possible")
-})
-
-func parseCPUsFromFile(path string) (int, error) {
-	spec, err := os.ReadFile(path)
-	if err != nil {
-		return 0, err
-	}
-
-	n, err := parseCPUs(string(spec))
-	if err != nil {
-		return 0, fmt.Errorf("can't parse %s: %v", path, err)
-	}
-
-	return n, nil
-}
-
-// parseCPUs parses the number of cpus from a string produced
-// by bitmap_list_string() in the Linux kernel.
-// Multiple ranges are rejected, since they can't be unified
-// into a single number.
-// This is the format of /sys/devices/system/cpu/possible, it
-// is not suitable for /sys/devices/system/cpu/online, etc.
-func parseCPUs(spec string) (int, error) {
-	if strings.Trim(spec, "\n") == "0" {
-		return 1, nil
-	}
-
-	var low, high int
-	n, err := fmt.Sscanf(spec, "%d-%d\n", &low, &high)
-	if n != 2 || err != nil {
-		return 0, fmt.Errorf("invalid format: %s", spec)
-	}
-	if low != 0 {
-		return 0, fmt.Errorf("CPU spec doesn't start at zero: %s", spec)
-	}
-
-	// cpus is 0 indexed
-	return high + 1, nil
-}
diff --git a/vendor/github.com/cilium/ebpf/internal/deque.go b/vendor/github.com/cilium/ebpf/internal/deque.go
deleted file mode 100644
index e3a305021..000000000
--- a/vendor/github.com/cilium/ebpf/internal/deque.go
+++ /dev/null
@@ -1,91 +0,0 @@
-package internal
-
-import "math/bits"
-
-// Deque implements a double ended queue.
-type Deque[T any] struct {
-	elems       []T
-	read, write uint64
-	mask        uint64
-}
-
-// Reset clears the contents of the deque while retaining the backing buffer.
-func (dq *Deque[T]) Reset() {
-	var zero T
-
-	for i := dq.read; i < dq.write; i++ {
-		dq.elems[i&dq.mask] = zero
-	}
-
-	dq.read, dq.write = 0, 0
-}
-
-func (dq *Deque[T]) Empty() bool {
-	return dq.read == dq.write
-}
-
-// Push adds an element to the end.
-func (dq *Deque[T]) Push(e T) {
-	dq.Grow(1)
-	dq.elems[dq.write&dq.mask] = e
-	dq.write++
-}
-
-// Shift returns the first element or the zero value.
-func (dq *Deque[T]) Shift() T {
-	var zero T
-
-	if dq.Empty() {
-		return zero
-	}
-
-	index := dq.read & dq.mask
-	t := dq.elems[index]
-	dq.elems[index] = zero
-	dq.read++
-	return t
-}
-
-// Pop returns the last element or the zero value.
-func (dq *Deque[T]) Pop() T {
-	var zero T
-
-	if dq.Empty() {
-		return zero
-	}
-
-	dq.write--
-	index := dq.write & dq.mask
-	t := dq.elems[index]
-	dq.elems[index] = zero
-	return t
-}
-
-// Grow the deque's capacity, if necessary, to guarantee space for another n
-// elements.
-func (dq *Deque[T]) Grow(n int) {
-	have := dq.write - dq.read
-	need := have + uint64(n)
-	if need < have {
-		panic("overflow")
-	}
-	if uint64(len(dq.elems)) >= need {
-		return
-	}
-
-	// Round up to the new power of two which is at least 8.
-	// See https://jameshfisher.com/2018/03/30/round-up-power-2/
-	capacity := 1 << (64 - bits.LeadingZeros64(need-1))
-	if capacity < 8 {
-		capacity = 8
-	}
-
-	elems := make([]T, have, capacity)
-	pivot := dq.read & dq.mask
-	copied := copy(elems, dq.elems[pivot:])
-	copy(elems[copied:], dq.elems[:pivot])
-
-	dq.elems = elems[:capacity]
-	dq.mask = uint64(capacity) - 1
-	dq.read, dq.write = 0, have
-}
diff --git a/vendor/github.com/cilium/ebpf/internal/elf.go b/vendor/github.com/cilium/ebpf/internal/elf.go
deleted file mode 100644
index 011581938..000000000
--- a/vendor/github.com/cilium/ebpf/internal/elf.go
+++ /dev/null
@@ -1,102 +0,0 @@
-package internal
-
-import (
-	"debug/elf"
-	"fmt"
-	"io"
-)
-
-type SafeELFFile struct {
-	*elf.File
-}
-
-// NewSafeELFFile reads an ELF safely.
-//
-// Any panic during parsing is turned into an error. This is necessary since
-// there are a bunch of unfixed bugs in debug/elf.
-//
-// https://github.com/golang/go/issues?q=is%3Aissue+is%3Aopen+debug%2Felf+in%3Atitle
-func NewSafeELFFile(r io.ReaderAt) (safe *SafeELFFile, err error) {
-	defer func() {
-		r := recover()
-		if r == nil {
-			return
-		}
-
-		safe = nil
-		err = fmt.Errorf("reading ELF file panicked: %s", r)
-	}()
-
-	file, err := elf.NewFile(r)
-	if err != nil {
-		return nil, err
-	}
-
-	return &SafeELFFile{file}, nil
-}
-
-// OpenSafeELFFile reads an ELF from a file.
-//
-// It works like NewSafeELFFile, with the exception that safe.Close will
-// close the underlying file.
-func OpenSafeELFFile(path string) (safe *SafeELFFile, err error) {
-	defer func() {
-		r := recover()
-		if r == nil {
-			return
-		}
-
-		safe = nil
-		err = fmt.Errorf("reading ELF file panicked: %s", r)
-	}()
-
-	file, err := elf.Open(path)
-	if err != nil {
-		return nil, err
-	}
-
-	return &SafeELFFile{file}, nil
-}
-
-// Symbols is the safe version of elf.File.Symbols.
-func (se *SafeELFFile) Symbols() (syms []elf.Symbol, err error) {
-	defer func() {
-		r := recover()
-		if r == nil {
-			return
-		}
-
-		syms = nil
-		err = fmt.Errorf("reading ELF symbols panicked: %s", r)
-	}()
-
-	syms, err = se.File.Symbols()
-	return
-}
-
-// DynamicSymbols is the safe version of elf.File.DynamicSymbols.
-func (se *SafeELFFile) DynamicSymbols() (syms []elf.Symbol, err error) {
-	defer func() {
-		r := recover()
-		if r == nil {
-			return
-		}
-
-		syms = nil
-		err = fmt.Errorf("reading ELF dynamic symbols panicked: %s", r)
-	}()
-
-	syms, err = se.File.DynamicSymbols()
-	return
-}
-
-// SectionsByType returns all sections in the file with the specified section type.
-func (se *SafeELFFile) SectionsByType(typ elf.SectionType) []*elf.Section {
-	sections := make([]*elf.Section, 0, 1)
-	for _, section := range se.Sections {
-		if section.Type == typ {
-			sections = append(sections, section)
-		}
-	}
-	return sections
-}
diff --git a/vendor/github.com/cilium/ebpf/internal/endian_be.go b/vendor/github.com/cilium/ebpf/internal/endian_be.go
deleted file mode 100644
index 96a2ac0de..000000000
--- a/vendor/github.com/cilium/ebpf/internal/endian_be.go
+++ /dev/null
@@ -1,12 +0,0 @@
-//go:build armbe || arm64be || mips || mips64 || mips64p32 || ppc64 || s390 || s390x || sparc || sparc64
-
-package internal
-
-import "encoding/binary"
-
-// NativeEndian is set to either binary.BigEndian or binary.LittleEndian,
-// depending on the host's endianness.
-var NativeEndian binary.ByteOrder = binary.BigEndian
-
-// ClangEndian is set to either "el" or "eb" depending on the host's endianness.
-const ClangEndian = "eb"
diff --git a/vendor/github.com/cilium/ebpf/internal/endian_le.go b/vendor/github.com/cilium/ebpf/internal/endian_le.go
deleted file mode 100644
index fde4c55a6..000000000
--- a/vendor/github.com/cilium/ebpf/internal/endian_le.go
+++ /dev/null
@@ -1,12 +0,0 @@
-//go:build 386 || amd64 || amd64p32 || arm || arm64 || loong64 || mipsle || mips64le || mips64p32le || ppc64le || riscv64
-
-package internal
-
-import "encoding/binary"
-
-// NativeEndian is set to either binary.BigEndian or binary.LittleEndian,
-// depending on the host's endianness.
-var NativeEndian binary.ByteOrder = binary.LittleEndian
-
-// ClangEndian is set to either "el" or "eb" depending on the host's endianness.
-const ClangEndian = "el"
diff --git a/vendor/github.com/cilium/ebpf/internal/errors.go b/vendor/github.com/cilium/ebpf/internal/errors.go
deleted file mode 100644
index bda01e2fd..000000000
--- a/vendor/github.com/cilium/ebpf/internal/errors.go
+++ /dev/null
@@ -1,198 +0,0 @@
-package internal
-
-import (
-	"bytes"
-	"fmt"
-	"io"
-	"strings"
-)
-
-// ErrorWithLog wraps err in a VerifierError that includes the parsed verifier
-// log buffer.
-//
-// The default error output is a summary of the full log. The latter can be
-// accessed via VerifierError.Log or by formatting the error, see Format.
-func ErrorWithLog(source string, err error, log []byte, truncated bool) *VerifierError {
-	const whitespace = "\t\r\v\n "
-
-	// Convert verifier log C string by truncating it on the first 0 byte
-	// and trimming trailing whitespace before interpreting as a Go string.
-	if i := bytes.IndexByte(log, 0); i != -1 {
-		log = log[:i]
-	}
-
-	log = bytes.Trim(log, whitespace)
-	if len(log) == 0 {
-		return &VerifierError{source, err, nil, truncated}
-	}
-
-	logLines := bytes.Split(log, []byte{'\n'})
-	lines := make([]string, 0, len(logLines))
-	for _, line := range logLines {
-		// Don't remove leading white space on individual lines. We rely on it
-		// when outputting logs.
-		lines = append(lines, string(bytes.TrimRight(line, whitespace)))
-	}
-
-	return &VerifierError{source, err, lines, truncated}
-}
-
-// VerifierError includes information from the eBPF verifier.
-//
-// It summarises the log output, see Format if you want to output the full contents.
-type VerifierError struct {
-	source string
-	// The error which caused this error.
-	Cause error
-	// The verifier output split into lines.
-	Log []string
-	// Whether the log output is truncated, based on several heuristics.
-	Truncated bool
-}
-
-func (le *VerifierError) Unwrap() error {
-	return le.Cause
-}
-
-func (le *VerifierError) Error() string {
-	log := le.Log
-	if n := len(log); n > 0 && strings.HasPrefix(log[n-1], "processed ") {
-		// Get rid of "processed 39 insns (limit 1000000) ..." from summary.
-		log = log[:n-1]
-	}
-
-	var b strings.Builder
-	fmt.Fprintf(&b, "%s: %s", le.source, le.Cause.Error())
-
-	n := len(log)
-	if n == 0 {
-		return b.String()
-	}
-
-	lines := log[n-1:]
-	if n >= 2 && (includePreviousLine(log[n-1]) || le.Truncated) {
-		// Add one more line of context if it aids understanding the error.
-		lines = log[n-2:]
-	}
-
-	for _, line := range lines {
-		b.WriteString(": ")
-		b.WriteString(strings.TrimSpace(line))
-	}
-
-	omitted := len(le.Log) - len(lines)
-	if omitted == 0 && !le.Truncated {
-		return b.String()
-	}
-
-	b.WriteString(" (")
-	if le.Truncated {
-		b.WriteString("truncated")
-	}
-
-	if omitted > 0 {
-		if le.Truncated {
-			b.WriteString(", ")
-		}
-		fmt.Fprintf(&b, "%d line(s) omitted", omitted)
-	}
-	b.WriteString(")")
-
-	return b.String()
-}
-
-// includePreviousLine returns true if the given line likely is better
-// understood with additional context from the preceding line.
-func includePreviousLine(line string) bool {
-	// We need to find a good trade off between understandable error messages
-	// and too much complexity here. Checking the string prefix is ok, requiring
-	// regular expressions to do it is probably overkill.
-
-	if strings.HasPrefix(line, "\t") {
-		// [13] STRUCT drm_rect size=16 vlen=4
-		// \tx1 type_id=2
-		return true
-	}
-
-	if len(line) >= 2 && line[0] == 'R' && line[1] >= '0' && line[1] <= '9' {
-		// 0: (95) exit
-		// R0 !read_ok
-		return true
-	}
-
-	if strings.HasPrefix(line, "invalid bpf_context access") {
-		// 0: (79) r6 = *(u64 *)(r1 +0)
-		// func '__x64_sys_recvfrom' arg0 type FWD is not a struct
-		// invalid bpf_context access off=0 size=8
-		return true
-	}
-
-	return false
-}
-
-// Format the error.
-//
-// Understood verbs are %s and %v, which are equivalent to calling Error(). %v
-// allows outputting additional information using the following flags:
-//
-//	%+<width>v: Output the first <width> lines, or all lines if no width is given.
-//	%-<width>v: Output the last <width> lines, or all lines if no width is given.
-//
-// Use width to specify how many lines to output. Use the '-' flag to output
-// lines from the end of the log instead of the beginning.
-func (le *VerifierError) Format(f fmt.State, verb rune) {
-	switch verb {
-	case 's':
-		_, _ = io.WriteString(f, le.Error())
-
-	case 'v':
-		n, haveWidth := f.Width()
-		if !haveWidth || n > len(le.Log) {
-			n = len(le.Log)
-		}
-
-		if !f.Flag('+') && !f.Flag('-') {
-			if haveWidth {
-				_, _ = io.WriteString(f, "%!v(BADWIDTH)")
-				return
-			}
-
-			_, _ = io.WriteString(f, le.Error())
-			return
-		}
-
-		if f.Flag('+') && f.Flag('-') {
-			_, _ = io.WriteString(f, "%!v(BADFLAG)")
-			return
-		}
-
-		fmt.Fprintf(f, "%s: %s:", le.source, le.Cause.Error())
-
-		omitted := len(le.Log) - n
-		lines := le.Log[:n]
-		if f.Flag('-') {
-			// Print last instead of first lines.
-			lines = le.Log[len(le.Log)-n:]
-			if omitted > 0 {
-				fmt.Fprintf(f, "\n\t(%d line(s) omitted)", omitted)
-			}
-		}
-
-		for _, line := range lines {
-			fmt.Fprintf(f, "\n\t%s", line)
-		}
-
-		if !f.Flag('-') {
-			if omitted > 0 {
-				fmt.Fprintf(f, "\n\t(%d line(s) omitted)", omitted)
-			}
-		}
-
-		if le.Truncated {
-			fmt.Fprintf(f, "\n\t(truncated)")
-		}
-
-	default:
-		fmt.Fprintf(f, "%%!%c(BADVERB)", verb)
-	}
-}
diff --git a/vendor/github.com/cilium/ebpf/internal/feature.go b/vendor/github.com/cilium/ebpf/internal/feature.go
deleted file mode 100644
index b1f650751..000000000
--- a/vendor/github.com/cilium/ebpf/internal/feature.go
+++ /dev/null
@@ -1,184 +0,0 @@
-package internal
-
-import (
-	"errors"
-	"fmt"
-	"sync"
-)
-
-// ErrNotSupported indicates that a feature is not supported by the current kernel.
-var ErrNotSupported = errors.New("not supported")
-
-// UnsupportedFeatureError is returned by FeatureTest() functions.
-type UnsupportedFeatureError struct {
-	// The minimum Linux mainline version required for this feature.
-	// Used for the error string, and for sanity checking during testing.
-	MinimumVersion Version
-
-	// The name of the feature that isn't supported.
-	Name string
-}
-
-func (ufe *UnsupportedFeatureError) Error() string {
-	if ufe.MinimumVersion.Unspecified() {
-		return fmt.Sprintf("%s not supported", ufe.Name)
-	}
-	return fmt.Sprintf("%s not supported (requires >= %s)", ufe.Name, ufe.MinimumVersion)
-}
-
-// Is indicates that UnsupportedFeatureError is ErrNotSupported.
-func (ufe *UnsupportedFeatureError) Is(target error) bool {
-	return target == ErrNotSupported
-}
-
-// FeatureTest caches the result of a [FeatureTestFn].
-//
-// Fields should not be modified after creation.
-type FeatureTest struct {
-	// The name of the feature being detected.
-	Name string
-	// Version in in the form Major.Minor[.Patch].
-	Version string
-	// The feature test itself.
-	Fn FeatureTestFn
-
-	mu     sync.RWMutex
-	done   bool
-	result error
-}
-
-// FeatureTestFn is used to determine whether the kernel supports
-// a certain feature.
-//
-// The return values have the following semantics:
-//
-//	err == ErrNotSupported: the feature is not available
-//	err == nil: the feature is available
-//	err != nil: the test couldn't be executed
-type FeatureTestFn func() error
-
-// NewFeatureTest is a convenient way to create a single [FeatureTest].
-func NewFeatureTest(name, version string, fn FeatureTestFn) func() error {
-	ft := &FeatureTest{
-		Name:    name,
-		Version: version,
-		Fn:      fn,
-	}
-
-	return ft.execute
-}
-
-// execute the feature test.
-//
-// The result is cached if the test is conclusive.
-//
-// See [FeatureTestFn] for the meaning of the returned error.
-func (ft *FeatureTest) execute() error {
-	ft.mu.RLock()
-	result, done := ft.result, ft.done
-	ft.mu.RUnlock()
-
-	if done {
-		return result
-	}
-
-	ft.mu.Lock()
-	defer ft.mu.Unlock()
-
-	// The test may have been executed by another caller while we were
-	// waiting to acquire ft.mu.
-	if ft.done {
-		return ft.result
-	}
-
-	err := ft.Fn()
-	if err == nil {
-		ft.done = true
-		return nil
-	}
-
-	if errors.Is(err, ErrNotSupported) {
-		var v Version
-		if ft.Version != "" {
-			v, err = NewVersion(ft.Version)
-			if err != nil {
-				return fmt.Errorf("feature %s: %w", ft.Name, err)
-			}
-		}
-
-		ft.done = true
-		ft.result = &UnsupportedFeatureError{
-			MinimumVersion: v,
-			Name:           ft.Name,
-		}
-
-		return ft.result
-	}
-
-	// We couldn't execute the feature test to a point
-	// where it could make a determination.
-	// Don't cache the result, just return it.
-	return fmt.Errorf("detect support for %s: %w", ft.Name, err)
-}
-
-// FeatureMatrix groups multiple related feature tests into a map.
-//
-// Useful when there is a small number of discrete features which are known
-// at compile time.
-//
-// It must not be modified concurrently with calling [FeatureMatrix.Result].
-type FeatureMatrix[K comparable] map[K]*FeatureTest
-
-// Result returns the outcome of the feature test for the given key.
-//
-// It's safe to call this function concurrently.
-func (fm FeatureMatrix[K]) Result(key K) error {
-	ft, ok := fm[key]
-	if !ok {
-		return fmt.Errorf("no feature probe for %v", key)
-	}
-
-	return ft.execute()
-}
-
-// FeatureCache caches a potentially unlimited number of feature probes.
-//
-// Useful when there is a high cardinality for a feature test.
-type FeatureCache[K comparable] struct {
-	mu       sync.RWMutex
-	newTest  func(K) *FeatureTest
-	features map[K]*FeatureTest
-}
-
-func NewFeatureCache[K comparable](newTest func(K) *FeatureTest) *FeatureCache[K] {
-	return &FeatureCache[K]{
-		newTest:  newTest,
-		features: make(map[K]*FeatureTest),
-	}
-}
-
-func (fc *FeatureCache[K]) Result(key K) error {
-	// NB: Executing the feature test happens without fc.mu taken.
-	return fc.retrieve(key).execute()
-}
-
-func (fc *FeatureCache[K]) retrieve(key K) *FeatureTest {
-	fc.mu.RLock()
-	ft := fc.features[key]
-	fc.mu.RUnlock()
-
-	if ft != nil {
-		return ft
-	}
-
-	fc.mu.Lock()
-	defer fc.mu.Unlock()
-
-	if ft := fc.features[key]; ft != nil {
-		return ft
-	}
-
-	ft = fc.newTest(key)
-	fc.features[key] = ft
-	return ft
-}
diff --git a/vendor/github.com/cilium/ebpf/internal/io.go b/vendor/github.com/cilium/ebpf/internal/io.go
deleted file mode 100644
index 1eaf4775a..000000000
--- a/vendor/github.com/cilium/ebpf/internal/io.go
+++ /dev/null
@@ -1,128 +0,0 @@
-package internal
-
-import (
-	"bufio"
-	"bytes"
-	"compress/gzip"
-	"errors"
-	"fmt"
-	"io"
-	"os"
-	"path/filepath"
-	"sync"
-)
-
-// NewBufferedSectionReader wraps an io.ReaderAt in an appropriately-sized
-// buffered reader. It is a convenience function for reading subsections of
-// ELF sections while minimizing the amount of read() syscalls made.
-//
-// Syscall overhead is non-negligible in continuous integration context
-// where ELFs might be accessed over virtual filesystems with poor random
-// access performance. Buffering reads makes sense because (sub)sections
-// end up being read completely anyway.
-//
-// Use instead of the r.Seek() + io.LimitReader() pattern.
-func NewBufferedSectionReader(ra io.ReaderAt, off, n int64) *bufio.Reader {
-	// Clamp the size of the buffer to one page to avoid slurping large parts
-	// of a file into memory. bufio.NewReader uses a hardcoded default buffer
-	// of 4096. Allow arches with larger pages to allocate more, but don't
-	// allocate a fixed 4k buffer if we only need to read a small segment.
-	buf := n
-	if ps := int64(os.Getpagesize()); n > ps {
-		buf = ps
-	}
-
-	return bufio.NewReaderSize(io.NewSectionReader(ra, off, n), int(buf))
-}
-
-// DiscardZeroes makes sure that all written bytes are zero
-// before discarding them.
-type DiscardZeroes struct{}
-
-func (DiscardZeroes) Write(p []byte) (int, error) {
-	for _, b := range p {
-		if b != 0 {
-			return 0, errors.New("encountered non-zero byte")
-		}
-	}
-	return len(p), nil
-}
-
-// ReadAllCompressed decompresses a gzipped file into memory.
-func ReadAllCompressed(file string) ([]byte, error) {
-	fh, err := os.Open(file)
-	if err != nil {
-		return nil, err
-	}
-	defer fh.Close()
-
-	gz, err := gzip.NewReader(fh)
-	if err != nil {
-		return nil, err
-	}
-	defer gz.Close()
-
-	return io.ReadAll(gz)
-}
-
-// ReadUint64FromFile reads a uint64 from a file.
-//
-// format specifies the contents of the file in fmt.Scanf syntax.
-func ReadUint64FromFile(format string, path ...string) (uint64, error) {
-	filename := filepath.Join(path...)
-	data, err := os.ReadFile(filename)
-	if err != nil {
-		return 0, fmt.Errorf("reading file %q: %w", filename, err)
-	}
-
-	var value uint64
-	n, err := fmt.Fscanf(bytes.NewReader(data), format, &value)
-	if err != nil {
-		return 0, fmt.Errorf("parsing file %q: %w", filename, err)
-	}
-	if n != 1 {
-		return 0, fmt.Errorf("parsing file %q: expected 1 item, got %d", filename, n)
-	}
-
-	return value, nil
-}
-
-type uint64FromFileKey struct {
-	format, path string
-}
-
-var uint64FromFileCache = struct {
-	sync.RWMutex
-	values map[uint64FromFileKey]uint64
-}{
-	values: map[uint64FromFileKey]uint64{},
-}
-
-// ReadUint64FromFileOnce is like readUint64FromFile but memoizes the result.
-func ReadUint64FromFileOnce(format string, path ...string) (uint64, error) {
-	filename := filepath.Join(path...)
-	key := uint64FromFileKey{format, filename}
-
-	uint64FromFileCache.RLock()
-	if value, ok := uint64FromFileCache.values[key]; ok {
-		uint64FromFileCache.RUnlock()
-		return value, nil
-	}
-	uint64FromFileCache.RUnlock()
-
-	value, err := ReadUint64FromFile(format, filename)
-	if err != nil {
-		return 0, err
-	}
-
-	uint64FromFileCache.Lock()
-	defer uint64FromFileCache.Unlock()
-
-	if value, ok := uint64FromFileCache.values[key]; ok {
-		// Someone else got here before us, use what is cached.
-		return value, nil
-	}
-
-	uint64FromFileCache.values[key] = value
-	return value, nil
-}
diff --git a/vendor/github.com/cilium/ebpf/internal/kconfig/kconfig.go b/vendor/github.com/cilium/ebpf/internal/kconfig/kconfig.go
deleted file mode 100644
index d95e7eb0e..000000000
--- a/vendor/github.com/cilium/ebpf/internal/kconfig/kconfig.go
+++ /dev/null
@@ -1,267 +0,0 @@
-package kconfig
-
-import (
-	"bufio"
-	"bytes"
-	"compress/gzip"
-	"fmt"
-	"io"
-	"math"
-	"os"
-	"strconv"
-	"strings"
-
-	"github.com/cilium/ebpf/btf"
-	"github.com/cilium/ebpf/internal"
-)
-
-// Find find a kconfig file on the host.
-// It first reads from /boot/config- of the current running kernel and tries
-// /proc/config.gz if nothing was found in /boot.
-// If none of the file provide a kconfig, it returns an error.
-func Find() (*os.File, error) {
-	kernelRelease, err := internal.KernelRelease()
-	if err != nil {
-		return nil, fmt.Errorf("cannot get kernel release: %w", err)
-	}
-
-	path := "/boot/config-" + kernelRelease
-	f, err := os.Open(path)
-	if err == nil {
-		return f, nil
-	}
-
-	f, err = os.Open("/proc/config.gz")
-	if err == nil {
-		return f, nil
-	}
-
-	return nil, fmt.Errorf("neither %s nor /proc/config.gz provide a kconfig", path)
-}
-
-// Parse parses the kconfig file for which a reader is given.
-// All the CONFIG_* which are in filter and which are set set will be
-// put in the returned map as key with their corresponding value as map value.
-// If filter is nil, no filtering will occur.
-// If the kconfig file is not valid, error will be returned.
-func Parse(source io.ReaderAt, filter map[string]struct{}) (map[string]string, error) {
-	var r io.Reader
-	zr, err := gzip.NewReader(io.NewSectionReader(source, 0, math.MaxInt64))
-	if err != nil {
-		r = io.NewSectionReader(source, 0, math.MaxInt64)
-	} else {
-		// Source is gzip compressed, transparently decompress.
-		r = zr
-	}
-
-	ret := make(map[string]string, len(filter))
-
-	s := bufio.NewScanner(r)
-
-	for s.Scan() {
-		line := s.Bytes()
-		err = processKconfigLine(line, ret, filter)
-		if err != nil {
-			return nil, fmt.Errorf("cannot parse line: %w", err)
-		}
-
-		if filter != nil && len(ret) == len(filter) {
-			break
-		}
-	}
-
-	if err := s.Err(); err != nil {
-		return nil, fmt.Errorf("cannot parse: %w", err)
-	}
-
-	if zr != nil {
-		return ret, zr.Close()
-	}
-
-	return ret, nil
-}
-
-// Golang translation of libbpf bpf_object__process_kconfig_line():
-// https://github.com/libbpf/libbpf/blob/fbd60dbff51c870f5e80a17c4f2fd639eb80af90/src/libbpf.c#L1874
-// It does the same checks but does not put the data inside the BPF map.
-func processKconfigLine(line []byte, m map[string]string, filter map[string]struct{}) error {
-	// Ignore empty lines and "# CONFIG_* is not set".
-	if !bytes.HasPrefix(line, []byte("CONFIG_")) {
-		return nil
-	}
-
-	key, value, found := bytes.Cut(line, []byte{'='})
-	if !found {
-		return fmt.Errorf("line %q does not contain separator '='", line)
-	}
-
-	if len(value) == 0 {
-		return fmt.Errorf("line %q has no value", line)
-	}
-
-	if filter != nil {
-		// NB: map[string(key)] gets special optimisation help from the compiler
-		// and doesn't allocate. Don't turn this into a variable.
-		_, ok := filter[string(key)]
-		if !ok {
-			return nil
-		}
-	}
-
-	// This can seem odd, but libbpf only sets the value the first time the key is
-	// met:
-	// https://github.com/torvalds/linux/blob/0d85b27b0cc6/tools/lib/bpf/libbpf.c#L1906-L1908
-	_, ok := m[string(key)]
-	if !ok {
-		m[string(key)] = string(value)
-	}
-
-	return nil
-}
-
-// PutValue translates the value given as parameter depending on the BTF
-// type, the translated value is then written to the byte array.
-func PutValue(data []byte, typ btf.Type, value string) error {
-	typ = btf.UnderlyingType(typ)
-
-	switch value {
-	case "y", "n", "m":
-		return putValueTri(data, typ, value)
-	default:
-		if strings.HasPrefix(value, `"`) {
-			return putValueString(data, typ, value)
-		}
-		return putValueNumber(data, typ, value)
-	}
-}
-
-// Golang translation of libbpf_tristate enum:
-// https://github.com/libbpf/libbpf/blob/fbd60dbff51c870f5e80a17c4f2fd639eb80af90/src/bpf_helpers.h#L169
-type triState int
-
-const (
-	TriNo     triState = 0
-	TriYes    triState = 1
-	TriModule triState = 2
-)
-
-func putValueTri(data []byte, typ btf.Type, value string) error {
-	switch v := typ.(type) {
-	case *btf.Int:
-		if v.Encoding != btf.Bool {
-			return fmt.Errorf("cannot add tri value, expected btf.Bool, got: %v", v.Encoding)
-		}
-
-		if v.Size != 1 {
-			return fmt.Errorf("cannot add tri value, expected size of 1 byte, got: %d", v.Size)
-		}
-
-		switch value {
-		case "y":
-			data[0] = 1
-		case "n":
-			data[0] = 0
-		default:
-			return fmt.Errorf("cannot use %q for btf.Bool", value)
-		}
-	case *btf.Enum:
-		if v.Name != "libbpf_tristate" {
-			return fmt.Errorf("cannot use enum %q, only libbpf_tristate is supported", v.Name)
-		}
-
-		var tri triState
-		switch value {
-		case "y":
-			tri = TriYes
-		case "m":
-			tri = TriModule
-		case "n":
-			tri = TriNo
-		default:
-			return fmt.Errorf("value %q is not support for libbpf_tristate", value)
-		}
-
-		internal.NativeEndian.PutUint64(data, uint64(tri))
-	default:
-		return fmt.Errorf("cannot add number value, expected btf.Int or btf.Enum, got: %T", v)
-	}
-
-	return nil
-}
-
-func putValueString(data []byte, typ btf.Type, value string) error {
-	array, ok := typ.(*btf.Array)
-	if !ok {
-		return fmt.Errorf("cannot add string value, expected btf.Array, got %T", array)
-	}
-
-	contentType, ok := btf.UnderlyingType(array.Type).(*btf.Int)
-	if !ok {
-		return fmt.Errorf("cannot add string value, expected array of btf.Int, got %T", contentType)
-	}
-
-	// Any Int, which is not bool, of one byte could be used to store char:
-	// https://github.com/torvalds/linux/blob/1a5304fecee5/tools/lib/bpf/libbpf.c#L3637-L3638
-	if contentType.Size != 1 && contentType.Encoding != btf.Bool {
-		return fmt.Errorf("cannot add string value, expected array of btf.Int of size 1, got array of btf.Int of size: %v", contentType.Size)
-	}
-
-	if !strings.HasPrefix(value, `"`) || !strings.HasSuffix(value, `"`) {
-		return fmt.Errorf(`value %q must start and finish with '"'`, value)
-	}
-
-	str := strings.Trim(value, `"`)
-
-	// We need to trim string if the bpf array is smaller.
-	if uint32(len(str)) >= array.Nelems {
-		str = str[:array.Nelems]
-	}
-
-	// Write the string content to .kconfig.
-	copy(data, str)
-
-	return nil
-}
-
-func putValueNumber(data []byte, typ btf.Type, value string) error {
-	integer, ok := typ.(*btf.Int)
-	if !ok {
-		return fmt.Errorf("cannot add number value, expected *btf.Int, got: %T", integer)
-	}
-
-	size := integer.Size
-	sizeInBits := size * 8
-
-	var n uint64
-	var err error
-	if integer.Encoding == btf.Signed {
-		parsed, e := strconv.ParseInt(value, 0, int(sizeInBits))
-
-		n = uint64(parsed)
-		err = e
-	} else {
-		parsed, e := strconv.ParseUint(value, 0, int(sizeInBits))
-
-		n = uint64(parsed)
-		err = e
-	}
-
-	if err != nil {
-		return fmt.Errorf("cannot parse value: %w", err)
-	}
-
-	switch size {
-	case 1:
-		data[0] = byte(n)
-	case 2:
-		internal.NativeEndian.PutUint16(data, uint16(n))
-	case 4:
-		internal.NativeEndian.PutUint32(data, uint32(n))
-	case 8:
-		internal.NativeEndian.PutUint64(data, uint64(n))
-	default:
-		return fmt.Errorf("size (%d) is not valid, expected: 1, 2, 4 or 8", size)
-	}
-
-	return nil
-}
diff --git a/vendor/github.com/cilium/ebpf/internal/memoize.go b/vendor/github.com/cilium/ebpf/internal/memoize.go
deleted file mode 100644
index 3de0a3fb9..000000000
--- a/vendor/github.com/cilium/ebpf/internal/memoize.go
+++ /dev/null
@@ -1,26 +0,0 @@
-package internal
-
-import (
-	"sync"
-)
-
-type memoizedFunc[T any] struct {
-	once   sync.Once
-	fn     func() (T, error)
-	result T
-	err    error
-}
-
-func (mf *memoizedFunc[T]) do() (T, error) {
-	mf.once.Do(func() {
-		mf.result, mf.err = mf.fn()
-	})
-	return mf.result, mf.err
-}
-
-// Memoize the result of a function call.
-//
-// fn is only ever called once, even if it returns an error.
-func Memoize[T any](fn func() (T, error)) func() (T, error) {
-	return (&memoizedFunc[T]{fn: fn}).do
-}
diff --git a/vendor/github.com/cilium/ebpf/internal/output.go b/vendor/github.com/cilium/ebpf/internal/output.go
deleted file mode 100644
index dd6e6cbaf..000000000
--- a/vendor/github.com/cilium/ebpf/internal/output.go
+++ /dev/null
@@ -1,97 +0,0 @@
-package internal
-
-import (
-	"bytes"
-	"errors"
-	"go/format"
-	"go/scanner"
-	"io"
-	"reflect"
-	"strings"
-	"unicode"
-)
-
-// Identifier turns a C style type or field name into an exportable Go equivalent.
-func Identifier(str string) string {
-	prev := rune(-1)
-	return strings.Map(func(r rune) rune {
-		// See https://golang.org/ref/spec#Identifiers
-		switch {
-		case unicode.IsLetter(r):
-			if prev == -1 {
-				r = unicode.ToUpper(r)
-			}
-
-		case r == '_':
-			switch {
-			// The previous rune was deleted, or we are at the
-			// beginning of the string.
-			case prev == -1:
-				fallthrough
-
-			// The previous rune is a lower case letter or a digit.
-			case unicode.IsDigit(prev) || (unicode.IsLetter(prev) && unicode.IsLower(prev)):
-				// delete the current rune, and force the
-				// next character to be uppercased.
-				r = -1
-			}
-
-		case unicode.IsDigit(r):
-
-		default:
-			// Delete the current rune. prev is unchanged.
-			return -1
-		}
-
-		prev = r
-		return r
-	}, str)
-}
-
-// WriteFormatted outputs a formatted src into out.
-//
-// If formatting fails it returns an informative error message.
-func WriteFormatted(src []byte, out io.Writer) error {
-	formatted, err := format.Source(src)
-	if err == nil {
-		_, err = out.Write(formatted)
-		return err
-	}
-
-	var el scanner.ErrorList
-	if !errors.As(err, &el) {
-		return err
-	}
-
-	var nel scanner.ErrorList
-	for _, err := range el {
-		if !err.Pos.IsValid() {
-			nel = append(nel, err)
-			continue
-		}
-
-		buf := src[err.Pos.Offset:]
-		nl := bytes.IndexRune(buf, '\n')
-		if nl == -1 {
-			nel = append(nel, err)
-			continue
-		}
-
-		err.Msg += ": " + string(buf[:nl])
-		nel = append(nel, err)
-	}
-
-	return nel
-}
-
-// GoTypeName is like %T, but elides the package name.
-//
-// Pointers to a type are peeled off.
-func GoTypeName(t any) string {
-	rT := reflect.TypeOf(t)
-	for rT.Kind() == reflect.Pointer {
-		rT = rT.Elem()
-	}
-	// Doesn't return the correct Name for generic types due to https://github.com/golang/go/issues/55924
-	return rT.Name()
-}
diff --git a/vendor/github.com/cilium/ebpf/internal/pinning.go b/vendor/github.com/cilium/ebpf/internal/pinning.go
deleted file mode 100644
index 01d892f93..000000000
--- a/vendor/github.com/cilium/ebpf/internal/pinning.go
+++ /dev/null
@@ -1,65 +0,0 @@
-package internal
-
-import (
-	"errors"
-	"fmt"
-	"os"
-	"path/filepath"
-	"runtime"
-
-	"github.com/cilium/ebpf/internal/sys"
-	"github.com/cilium/ebpf/internal/unix"
-)
-
-func Pin(currentPath, newPath string, fd *sys.FD) error {
-	if newPath == "" {
-		return errors.New("given pinning path cannot be empty")
-	}
-	if currentPath == newPath {
-		return nil
-	}
-
-	fsType, err := FSType(filepath.Dir(newPath))
-	if err != nil {
-		return err
-	}
-	if fsType != unix.BPF_FS_MAGIC {
-		return fmt.Errorf("%s is not on a bpf filesystem", newPath)
-	}
-
-	defer runtime.KeepAlive(fd)
-
-	if currentPath == "" {
-		return sys.ObjPin(&sys.ObjPinAttr{
-			Pathname: sys.NewStringPointer(newPath),
-			BpfFd:    fd.Uint(),
-		})
-	}
-
-	// Renameat2 is used instead of os.Rename to disallow the new path replacing
-	// an existing path.
-	err = unix.Renameat2(unix.AT_FDCWD, currentPath, unix.AT_FDCWD, newPath, unix.RENAME_NOREPLACE)
-	if err == nil {
-		// Object is now moved to the new pinning path.
-		return nil
-	}
-	if !os.IsNotExist(err) {
-		return fmt.Errorf("unable to move pinned object to new path %v: %w", newPath, err)
-	}
-	// Internal state not in sync with the file system so let's fix it.
-	return sys.ObjPin(&sys.ObjPinAttr{
-		Pathname: sys.NewStringPointer(newPath),
-		BpfFd:    fd.Uint(),
-	})
-}
-
-func Unpin(pinnedPath string) error {
-	if pinnedPath == "" {
-		return nil
-	}
-	err := os.Remove(pinnedPath)
-	if err == nil || os.IsNotExist(err) {
-		return nil
-	}
-	return err
-}
diff --git a/vendor/github.com/cilium/ebpf/internal/platform.go b/vendor/github.com/cilium/ebpf/internal/platform.go
deleted file mode 100644
index 6e90f2ef7..000000000
--- a/vendor/github.com/cilium/ebpf/internal/platform.go
+++ /dev/null
@@ -1,43 +0,0 @@
-package internal
-
-import (
-	"runtime"
-)
-
-// PlatformPrefix returns the platform-dependent syscall wrapper prefix used by
-// the linux kernel.
-//
-// Based on https://github.com/golang/go/blob/master/src/go/build/syslist.go
-// and https://github.com/libbpf/libbpf/blob/master/src/libbpf.c#L10047
-func PlatformPrefix() string {
-	switch runtime.GOARCH {
-	case "386":
-		return "__ia32_"
-	case "amd64", "amd64p32":
-		return "__x64_"
-
-	case "arm", "armbe":
-		return "__arm_"
-	case "arm64", "arm64be":
-		return "__arm64_"
-
-	case "mips", "mipsle", "mips64", "mips64le", "mips64p32", "mips64p32le":
-		return "__mips_"
-
-	case "s390":
-		return "__s390_"
-	case "s390x":
-		return "__s390x_"
-
-	case "riscv", "riscv64":
-		return "__riscv_"
-
-	case "ppc":
-		return "__powerpc_"
-	case "ppc64", "ppc64le":
-		return "__powerpc64_"
-
-	default:
-		return ""
-	}
-}
diff --git a/vendor/github.com/cilium/ebpf/internal/prog.go b/vendor/github.com/cilium/ebpf/internal/prog.go
deleted file mode 100644
index d629145b6..000000000
--- a/vendor/github.com/cilium/ebpf/internal/prog.go
+++ /dev/null
@@ -1,11 +0,0 @@
-package internal
-
-// EmptyBPFContext is the smallest-possible BPF input context to be used for
-// invoking `Program.{Run,Benchmark,Test}`.
-//
-// Programs require a context input buffer of at least 15 bytes. Looking in
-// net/bpf/test_run.c, bpf_test_init() requires that the input is at least
-// ETH_HLEN (14) bytes. As of Linux commit fd18942 ("bpf: Don't redirect packets
-// with invalid pkt_len"), it also requires the skb to be non-empty after
-// removing the Layer 2 header.
-var EmptyBPFContext = make([]byte, 15)
diff --git a/vendor/github.com/cilium/ebpf/internal/statfs.go b/vendor/github.com/cilium/ebpf/internal/statfs.go
deleted file mode 100644
index 44c02d676..000000000
--- a/vendor/github.com/cilium/ebpf/internal/statfs.go
+++ /dev/null
@@ -1,23 +0,0 @@
-package internal
-
-import (
-	"unsafe"
-
-	"github.com/cilium/ebpf/internal/unix"
-)
-
-func FSType(path string) (int64, error) {
-	var statfs unix.Statfs_t
-	if err := unix.Statfs(path, &statfs); err != nil {
-		return 0, err
-	}
-
-	fsType := int64(statfs.Type)
-	if unsafe.Sizeof(statfs.Type) == 4 {
-		// We're on a 32 bit arch, where statfs.Type is int32. bpfFSType is a
-		// negative number when interpreted as int32 so we need to cast via
-		// uint32 to avoid sign extension.
-		fsType = int64(uint32(statfs.Type))
-	}
-	return fsType, nil
-}
diff --git a/vendor/github.com/cilium/ebpf/internal/sys/doc.go b/vendor/github.com/cilium/ebpf/internal/sys/doc.go
deleted file mode 100644
index dfe174448..000000000
--- a/vendor/github.com/cilium/ebpf/internal/sys/doc.go
+++ /dev/null
@@ -1,6 +0,0 @@
-// Package sys contains bindings for the BPF syscall.
-package sys
-
-// Regenerate types.go by invoking go generate in the current directory.
-
-//go:generate go run github.com/cilium/ebpf/internal/cmd/gentypes ../../btf/testdata/vmlinux.btf.gz
diff --git a/vendor/github.com/cilium/ebpf/internal/sys/fd.go b/vendor/github.com/cilium/ebpf/internal/sys/fd.go
deleted file mode 100644
index 941a56fb9..000000000
--- a/vendor/github.com/cilium/ebpf/internal/sys/fd.go
+++ /dev/null
@@ -1,133 +0,0 @@
-package sys
-
-import (
-	"fmt"
-	"math"
-	"os"
-	"runtime"
-	"strconv"
-
-	"github.com/cilium/ebpf/internal/unix"
-)
-
-var ErrClosedFd = unix.EBADF
-
-type FD struct {
-	raw int
-}
-
-func newFD(value int) *FD {
-	if onLeakFD != nil {
-		// Attempt to store the caller's stack for the given fd value.
-		// Panic if fds contains an existing stack for the fd.
-		old, exist := fds.LoadOrStore(value, callersFrames())
-		if exist {
-			f := old.(*runtime.Frames)
-			panic(fmt.Sprintf("found existing stack for fd %d:\n%s", value, FormatFrames(f)))
-		}
-	}
-
-	fd := &FD{value}
-	runtime.SetFinalizer(fd, (*FD).finalize)
-	return fd
-}
-
-// finalize is set as the FD's runtime finalizer and
-// sends a leak trace before calling FD.Close().
-func (fd *FD) finalize() {
-	if fd.raw < 0 {
-		return
-	}
-
-	// Invoke the fd leak callback. Calls LoadAndDelete to guarantee the callback
-	// is invoked at most once for one sys.FD allocation, runtime.Frames can only
-	// be unwound once.
-	f, ok := fds.LoadAndDelete(fd.Int())
-	if ok && onLeakFD != nil {
-		onLeakFD(f.(*runtime.Frames))
-	}
-
-	_ = fd.Close()
-}
-
-// NewFD wraps a raw fd with a finalizer.
-//
-// You must not use the raw fd after calling this function, since the underlying
-// file descriptor number may change. This is because the BPF UAPI assumes that
-// zero is not a valid fd value.
-func NewFD(value int) (*FD, error) {
-	if value < 0 {
-		return nil, fmt.Errorf("invalid fd %d", value)
-	}
-
-	fd := newFD(value)
-	if value != 0 {
-		return fd, nil
-	}
-
-	dup, err := fd.Dup()
-	_ = fd.Close()
-	return dup, err
-}
-
-func (fd *FD) String() string {
-	return strconv.FormatInt(int64(fd.raw), 10)
-}
-
-func (fd *FD) Int() int {
-	return fd.raw
-}
-
-func (fd *FD) Uint() uint32 {
-	if fd.raw < 0 || int64(fd.raw) > math.MaxUint32 {
-		// Best effort: this is the number most likely to be an invalid file
-		// descriptor. It is equal to -1 (on two's complement arches).
-		return math.MaxUint32
-	}
-	return uint32(fd.raw)
-}
-
-func (fd *FD) Close() error {
-	if fd.raw < 0 {
-		return nil
-	}
-
-	return unix.Close(fd.disown())
-}
-
-func (fd *FD) disown() int {
-	value := int(fd.raw)
-	fds.Delete(int(value))
-	fd.raw = -1
-
-	runtime.SetFinalizer(fd, nil)
-	return value
-}
-
-func (fd *FD) Dup() (*FD, error) {
-	if fd.raw < 0 {
-		return nil, ErrClosedFd
-	}
-
-	// Always require the fd to be larger than zero: the BPF API treats the value
-	// as "no argument provided".
-	dup, err := unix.FcntlInt(uintptr(fd.raw), unix.F_DUPFD_CLOEXEC, 1)
-	if err != nil {
-		return nil, fmt.Errorf("can't dup fd: %v", err)
-	}
-
-	return newFD(dup), nil
-}
-
-// File takes ownership of FD and turns it into an [*os.File].
-//
-// You must not use the FD after the call returns.
-//
-// Returns nil if the FD is not valid.
-func (fd *FD) File(name string) *os.File {
-	if fd.raw < 0 {
-		return nil
-	}
-
-	return os.NewFile(uintptr(fd.disown()), name)
-}
diff --git a/vendor/github.com/cilium/ebpf/internal/sys/fd_trace.go b/vendor/github.com/cilium/ebpf/internal/sys/fd_trace.go
deleted file mode 100644
index cd50dd1f6..000000000
--- a/vendor/github.com/cilium/ebpf/internal/sys/fd_trace.go
+++ /dev/null
@@ -1,93 +0,0 @@
-package sys
-
-import (
-	"bytes"
-	"fmt"
-	"runtime"
-	"sync"
-)
-
-// OnLeakFD controls tracing [FD] lifetime to detect resources that are not
-// closed by Close().
-//
-// If fn is not nil, tracing is enabled for all FDs created going forward. fn is
-// invoked for all FDs that are closed by the garbage collector instead of an
-// explicit Close() by a caller. Calling OnLeakFD twice with a non-nil fn
-// (without disabling tracing in the meantime) will cause a panic.
-//
-// If fn is nil, tracing will be disabled. Any FDs that have not been closed are
-// considered to be leaked, fn will be invoked for them, and the process will be
-// terminated.
-//
-// fn will be invoked at most once for every unique sys.FD allocation since a
-// runtime.Frames can only be unwound once.
-func OnLeakFD(fn func(*runtime.Frames)) {
-	// Enable leak tracing if new fn is provided.
-	if fn != nil {
-		if onLeakFD != nil {
-			panic("OnLeakFD called twice with non-nil fn")
-		}
-
-		onLeakFD = fn
-		return
-	}
-
-	// fn is nil past this point.
-
-	if onLeakFD == nil {
-		return
-	}
-
-	// Call onLeakFD for all open fds.
-	if fs := flushFrames(); len(fs) != 0 {
-		for _, f := range fs {
-			onLeakFD(f)
-		}
-	}
-
-	onLeakFD = nil
-}
-
-var onLeakFD func(*runtime.Frames)
-
-// fds is a registry of all file descriptors wrapped into sys.fds that were
-// created while an fd tracer was active.
-var fds sync.Map // map[int]*runtime.Frames
-
-// flushFrames removes all elements from fds and returns them as a slice. This
-// deals with the fact that a runtime.Frames can only be unwound once using
-// Next().
-func flushFrames() []*runtime.Frames {
-	var frames []*runtime.Frames
-	fds.Range(func(key, value any) bool {
-		frames = append(frames, value.(*runtime.Frames))
-		fds.Delete(key)
-		return true
-	})
-	return frames
-}
-
-func callersFrames() *runtime.Frames {
-	c := make([]uintptr, 32)
-
-	// Skip runtime.Callers and this function.
-	i := runtime.Callers(2, c)
-	if i == 0 {
-		return nil
-	}
-
-	return runtime.CallersFrames(c)
-}
-
-// FormatFrames formats a runtime.Frames as a human-readable string.
-func FormatFrames(fs *runtime.Frames) string {
-	var b bytes.Buffer
-	for {
-		f, more := fs.Next()
-		b.WriteString(fmt.Sprintf("\t%s+%#x\n\t\t%s:%d\n", f.Function, f.PC-f.Entry, f.File, f.Line))
-		if !more {
-			break
-		}
-	}
-	return b.String()
-}
diff --git a/vendor/github.com/cilium/ebpf/internal/sys/mapflags_string.go b/vendor/github.com/cilium/ebpf/internal/sys/mapflags_string.go
deleted file mode 100644
index c80744ae0..000000000
--- a/vendor/github.com/cilium/ebpf/internal/sys/mapflags_string.go
+++ /dev/null
@@ -1,49 +0,0 @@
-// Code generated by "stringer -type MapFlags"; DO NOT EDIT.
-
-package sys
-
-import "strconv"
-
-func _() {
-	// An "invalid array index" compiler error signifies that the constant values have changed.
-	// Re-run the stringer command to generate them again.
-	var x [1]struct{}
-	_ = x[BPF_F_NO_PREALLOC-1]
-	_ = x[BPF_F_NO_COMMON_LRU-2]
-	_ = x[BPF_F_NUMA_NODE-4]
-	_ = x[BPF_F_RDONLY-8]
-	_ = x[BPF_F_WRONLY-16]
-	_ = x[BPF_F_STACK_BUILD_ID-32]
-	_ = x[BPF_F_ZERO_SEED-64]
-	_ = x[BPF_F_RDONLY_PROG-128]
-	_ = x[BPF_F_WRONLY_PROG-256]
-	_ = x[BPF_F_CLONE-512]
-	_ = x[BPF_F_MMAPABLE-1024]
-	_ = x[BPF_F_PRESERVE_ELEMS-2048]
-	_ = x[BPF_F_INNER_MAP-4096]
-}
-
-const _MapFlags_name = "BPF_F_NO_PREALLOCBPF_F_NO_COMMON_LRUBPF_F_NUMA_NODEBPF_F_RDONLYBPF_F_WRONLYBPF_F_STACK_BUILD_IDBPF_F_ZERO_SEEDBPF_F_RDONLY_PROGBPF_F_WRONLY_PROGBPF_F_CLONEBPF_F_MMAPABLEBPF_F_PRESERVE_ELEMSBPF_F_INNER_MAP"
-
-var _MapFlags_map = map[MapFlags]string{
-	1:    _MapFlags_name[0:17],
-	2:    _MapFlags_name[17:36],
-	4:    _MapFlags_name[36:51],
-	8:    _MapFlags_name[51:63],
-	16:   _MapFlags_name[63:75],
-	32:   _MapFlags_name[75:95],
-	64:   _MapFlags_name[95:110],
-	128:  _MapFlags_name[110:127],
-	256:  _MapFlags_name[127:144],
-	512:  _MapFlags_name[144:155],
-	1024: _MapFlags_name[155:169],
-	2048: _MapFlags_name[169:189],
-	4096: _MapFlags_name[189:204],
-}
-
-func (i MapFlags) String() string {
-	if str, ok := _MapFlags_map[i]; ok {
-		return str
-	}
-	return "MapFlags(" + strconv.FormatInt(int64(i), 10) + ")"
-}
diff --git a/vendor/github.com/cilium/ebpf/internal/sys/ptr.go b/vendor/github.com/cilium/ebpf/internal/sys/ptr.go
deleted file mode 100644
index e9bb59059..000000000
--- a/vendor/github.com/cilium/ebpf/internal/sys/ptr.go
+++ /dev/null
@@ -1,52 +0,0 @@
-package sys
-
-import (
-	"unsafe"
-
-	"github.com/cilium/ebpf/internal/unix"
-)
-
-// NewPointer creates a 64-bit pointer from an unsafe Pointer.
-func NewPointer(ptr unsafe.Pointer) Pointer {
-	return Pointer{ptr: ptr}
-}
-
-// NewSlicePointer creates a 64-bit pointer from a byte slice.
-func NewSlicePointer(buf []byte) Pointer {
-	if len(buf) == 0 {
-		return Pointer{}
-	}
-
-	return Pointer{ptr: unsafe.Pointer(&buf[0])}
-}
-
-// NewSlicePointerLen creates a 64-bit pointer from a byte slice.
-//
-// Useful to assign both the pointer and the length in one go.
-func NewSlicePointerLen(buf []byte) (Pointer, uint32) {
-	return NewSlicePointer(buf), uint32(len(buf))
-}
-
-// NewStringPointer creates a 64-bit pointer from a string.
-func NewStringPointer(str string) Pointer {
-	p, err := unix.BytePtrFromString(str)
-	if err != nil {
-		return Pointer{}
-	}
-
-	return Pointer{ptr: unsafe.Pointer(p)}
-}
-
-// NewStringSlicePointer allocates an array of Pointers to each string in the
-// given slice of strings and returns a 64-bit pointer to the start of the
-// resulting array.
-//
-// Use this function to pass arrays of strings as syscall arguments.
-func NewStringSlicePointer(strings []string) Pointer {
-	sp := make([]Pointer, 0, len(strings))
-	for _, s := range strings {
-		sp = append(sp, NewStringPointer(s))
-	}
-
-	return Pointer{ptr: unsafe.Pointer(&sp[0])}
-}
diff --git a/vendor/github.com/cilium/ebpf/internal/sys/ptr_32_be.go b/vendor/github.com/cilium/ebpf/internal/sys/ptr_32_be.go
deleted file mode 100644
index 6278c79c9..000000000
--- a/vendor/github.com/cilium/ebpf/internal/sys/ptr_32_be.go
+++ /dev/null
@@ -1,14 +0,0 @@
-//go:build armbe || mips || mips64p32
-
-package sys
-
-import (
-	"unsafe"
-)
-
-// Pointer wraps an unsafe.Pointer to be 64bit to
-// conform to the syscall specification.
-type Pointer struct {
-	pad uint32
-	ptr unsafe.Pointer
-}
diff --git a/vendor/github.com/cilium/ebpf/internal/sys/ptr_32_le.go b/vendor/github.com/cilium/ebpf/internal/sys/ptr_32_le.go
deleted file mode 100644
index c27b537e8..000000000
--- a/vendor/github.com/cilium/ebpf/internal/sys/ptr_32_le.go
+++ /dev/null
@@ -1,14 +0,0 @@
-//go:build 386 || amd64p32 || arm || mipsle || mips64p32le
-
-package sys
-
-import (
-	"unsafe"
-)
-
-// Pointer wraps an unsafe.Pointer to be 64bit to
-// conform to the syscall specification.
-type Pointer struct {
-	ptr unsafe.Pointer
-	pad uint32
-}
diff --git a/vendor/github.com/cilium/ebpf/internal/sys/ptr_64.go b/vendor/github.com/cilium/ebpf/internal/sys/ptr_64.go
deleted file mode 100644
index 2d7828230..000000000
--- a/vendor/github.com/cilium/ebpf/internal/sys/ptr_64.go
+++ /dev/null
@@ -1,13 +0,0 @@
-//go:build !386 && !amd64p32 && !arm && !mipsle && !mips64p32le && !armbe && !mips && !mips64p32
-
-package sys
-
-import (
-	"unsafe"
-)
-
-// Pointer wraps an unsafe.Pointer to be 64bit to
-// conform to the syscall specification.
-type Pointer struct {
-	ptr unsafe.Pointer
-}
diff --git a/vendor/github.com/cilium/ebpf/internal/sys/signals.go b/vendor/github.com/cilium/ebpf/internal/sys/signals.go
deleted file mode 100644
index 7494c030c..000000000
--- a/vendor/github.com/cilium/ebpf/internal/sys/signals.go
+++ /dev/null
@@ -1,83 +0,0 @@
-package sys
-
-import (
-	"fmt"
-	"runtime"
-	"unsafe"
-
-	"github.com/cilium/ebpf/internal/unix"
-)
-
-// A sigset containing only SIGPROF.
-var profSet unix.Sigset_t
-
-func init() {
-	// See sigsetAdd for details on the implementation. Open coded here so
-	// that the compiler will check the constant calculations for us.
-	profSet.Val[sigprofBit/wordBits] |= 1 << (sigprofBit % wordBits)
-}
-
-// maskProfilerSignal locks the calling goroutine to its underlying OS thread
-// and adds SIGPROF to the thread's signal mask. This prevents pprof from
-// interrupting expensive syscalls like e.g. BPF_PROG_LOAD.
-//
-// The caller must defer unmaskProfilerSignal() to reverse the operation.
-func maskProfilerSignal() {
-	runtime.LockOSThread()
-
-	if err := unix.PthreadSigmask(unix.SIG_BLOCK, &profSet, nil); err != nil {
-		runtime.UnlockOSThread()
-		panic(fmt.Errorf("masking profiler signal: %w", err))
-	}
-}
-
-// unmaskProfilerSignal removes SIGPROF from the underlying thread's signal
-// mask, allowing it to be interrupted for profiling once again.
-//
-// It also unlocks the current goroutine from its underlying OS thread.
-func unmaskProfilerSignal() {
-	defer runtime.UnlockOSThread()
-
-	if err := unix.PthreadSigmask(unix.SIG_UNBLOCK, &profSet, nil); err != nil {
-		panic(fmt.Errorf("unmasking profiler signal: %w", err))
-	}
-}
-
-const (
-	// Signal is the nth bit in the bitfield.
-	sigprofBit = int(unix.SIGPROF - 1)
-	// The number of bits in one Sigset_t word.
-	wordBits = int(unsafe.Sizeof(unix.Sigset_t{}.Val[0])) * 8
-)
-
-// sigsetAdd adds signal to set.
-//
-// Note: Sigset_t.Val's value type is uint32 or uint64 depending on the arch.
-// This function must be able to deal with both and so must avoid any direct
-// references to u32 or u64 types.
-func sigsetAdd(set *unix.Sigset_t, signal unix.Signal) error {
-	if signal < 1 {
-		return fmt.Errorf("signal %d must be larger than 0", signal)
-	}
-
-	// For amd64, runtime.sigaddset() performs the following operation:
-	// set[(signal-1)/32] |= 1 << ((uint32(signal) - 1) & 31)
-	//
-	// This trick depends on sigset being two u32's, causing a signal in the the
-	// bottom 31 bits to be written to the low word if bit 32 is low, or the high
-	// word if bit 32 is high.
-
-	// Signal is the nth bit in the bitfield.
-	bit := int(signal - 1)
-	// Word within the sigset the bit needs to be written to.
-	word := bit / wordBits
-
-	if word >= len(set.Val) {
-		return fmt.Errorf("signal %d does not fit within unix.Sigset_t", signal)
-	}
-
-	// Write the signal bit into its corresponding word at the corrected offset.
-	set.Val[word] |= 1 << (bit % wordBits)
-
-	return nil
-}
diff --git a/vendor/github.com/cilium/ebpf/internal/sys/syscall.go b/vendor/github.com/cilium/ebpf/internal/sys/syscall.go
deleted file mode 100644
index 4fae04db5..000000000
--- a/vendor/github.com/cilium/ebpf/internal/sys/syscall.go
+++ /dev/null
@@ -1,178 +0,0 @@
-package sys
-
-import (
-	"runtime"
-	"syscall"
-	"unsafe"
-
-	"github.com/cilium/ebpf/internal/unix"
-)
-
-// ENOTSUPP is a Linux internal error code that has leaked into UAPI.
-//
-// It is not the same as ENOTSUP or EOPNOTSUPP.
-var ENOTSUPP = syscall.Errno(524)
-
-// BPF wraps SYS_BPF.
-//
-// Any pointers contained in attr must use the Pointer type from this package.
-func BPF(cmd Cmd, attr unsafe.Pointer, size uintptr) (uintptr, error) {
-	// Prevent the Go profiler from repeatedly interrupting the verifier,
-	// which could otherwise lead to a livelock due to receiving EAGAIN.
-	if cmd == BPF_PROG_LOAD || cmd == BPF_PROG_RUN {
-		maskProfilerSignal()
-		defer unmaskProfilerSignal()
-	}
-
-	for {
-		r1, _, errNo := unix.Syscall(unix.SYS_BPF, uintptr(cmd), uintptr(attr), size)
-		runtime.KeepAlive(attr)
-
-		// As of ~4.20 the verifier can be interrupted by a signal,
-		// and returns EAGAIN in that case.
-		if errNo == unix.EAGAIN && cmd == BPF_PROG_LOAD {
-			continue
-		}
-
-		var err error
-		if errNo != 0 {
-			err = wrappedErrno{errNo}
-		}
-
-		return r1, err
-	}
-}
-
-// Info is implemented by all structs that can be passed to the ObjInfo syscall.
-//
-//	MapInfo
-//	ProgInfo
-//	LinkInfo
-//	BtfInfo
-type Info interface {
-	info() (unsafe.Pointer, uint32)
-}
-
-var _ Info = (*MapInfo)(nil)
-
-func (i *MapInfo) info() (unsafe.Pointer, uint32) {
-	return unsafe.Pointer(i), uint32(unsafe.Sizeof(*i))
-}
-
-var _ Info = (*ProgInfo)(nil)
-
-func (i *ProgInfo) info() (unsafe.Pointer, uint32) {
-	return unsafe.Pointer(i), uint32(unsafe.Sizeof(*i))
-}
-
-var _ Info = (*LinkInfo)(nil)
-
-func (i *LinkInfo) info() (unsafe.Pointer, uint32) {
-	return unsafe.Pointer(i), uint32(unsafe.Sizeof(*i))
-}
-
-var _ Info = (*BtfInfo)(nil)
-
-func (i *BtfInfo) info() (unsafe.Pointer, uint32) {
-	return unsafe.Pointer(i), uint32(unsafe.Sizeof(*i))
-}
-
-// ObjInfo retrieves information about a BPF Fd.
-//
-// info may be one of MapInfo, ProgInfo, LinkInfo and BtfInfo.
-func ObjInfo(fd *FD, info Info) error {
-	ptr, len := info.info()
-	err := ObjGetInfoByFd(&ObjGetInfoByFdAttr{
-		BpfFd:   fd.Uint(),
-		InfoLen: len,
-		Info:    NewPointer(ptr),
-	})
-	runtime.KeepAlive(fd)
-	return err
-}
-
-// BPFObjName is a null-terminated string made up of
-// 'A-Za-z0-9_' characters.
-type ObjName [unix.BPF_OBJ_NAME_LEN]byte
-
-// NewObjName truncates the result if it is too long.
-func NewObjName(name string) ObjName {
-	var result ObjName
-	copy(result[:unix.BPF_OBJ_NAME_LEN-1], name)
-	return result
-}
-
-// LogLevel controls the verbosity of the kernel's eBPF program verifier.
-type LogLevel uint32
-
-const (
-	BPF_LOG_LEVEL1 LogLevel = 1 << iota
-	BPF_LOG_LEVEL2
-	BPF_LOG_STATS
-)
-
-// LinkID uniquely identifies a bpf_link.
-type LinkID uint32
-
-// BTFID uniquely identifies a BTF blob loaded into the kernel.
-type BTFID uint32
-
-// TypeID identifies a type in a BTF blob.
-type TypeID uint32
-
-// MapFlags control map behaviour.
-type MapFlags uint32
-
-//go:generate stringer -type MapFlags
-
-const (
-	BPF_F_NO_PREALLOC MapFlags = 1 << iota
-	BPF_F_NO_COMMON_LRU
-	BPF_F_NUMA_NODE
-	BPF_F_RDONLY
-	BPF_F_WRONLY
-	BPF_F_STACK_BUILD_ID
-	BPF_F_ZERO_SEED
-	BPF_F_RDONLY_PROG
-	BPF_F_WRONLY_PROG
-	BPF_F_CLONE
-	BPF_F_MMAPABLE
-	BPF_F_PRESERVE_ELEMS
-	BPF_F_INNER_MAP
-)
-
-// wrappedErrno wraps syscall.Errno to prevent direct comparisons with
-// syscall.E* or unix.E* constants.
-//
-// You should never export an error of this type.
-type wrappedErrno struct {
-	syscall.Errno
-}
-
-func (we wrappedErrno) Unwrap() error {
-	return we.Errno
-}
-
-func (we wrappedErrno) Error() string {
-	if we.Errno == ENOTSUPP {
-		return "operation not supported"
-	}
-	return we.Errno.Error()
-}
-
-type syscallError struct {
-	error
-	errno syscall.Errno
-}
-
-func Error(err error, errno syscall.Errno) error {
-	return &syscallError{err, errno}
-}
-
-func (se *syscallError) Is(target error) bool {
-	return target == se.error
-}
-
-func (se *syscallError) Unwrap() error {
-	return se.errno
-}
diff --git a/vendor/github.com/cilium/ebpf/internal/sys/types.go b/vendor/github.com/cilium/ebpf/internal/sys/types.go
deleted file mode 100644
index 2af7759e5..000000000
--- a/vendor/github.com/cilium/ebpf/internal/sys/types.go
+++ /dev/null
@@ -1,1117 +0,0 @@
-// Code generated by internal/cmd/gentypes; DO NOT EDIT.
-
-package sys
-
-import (
-	"unsafe"
-)
-
-type AdjRoomMode uint32
-
-const (
-	BPF_ADJ_ROOM_NET AdjRoomMode = 0
-	BPF_ADJ_ROOM_MAC AdjRoomMode = 1
-)
-
-type AttachType uint32
-
-const (
-	BPF_CGROUP_INET_INGRESS            AttachType = 0
-	BPF_CGROUP_INET_EGRESS             AttachType = 1
-	BPF_CGROUP_INET_SOCK_CREATE        AttachType = 2
-	BPF_CGROUP_SOCK_OPS                AttachType = 3
-	BPF_SK_SKB_STREAM_PARSER           AttachType = 4
-	BPF_SK_SKB_STREAM_VERDICT          AttachType = 5
-	BPF_CGROUP_DEVICE                  AttachType = 6
-	BPF_SK_MSG_VERDICT                 AttachType = 7
-	BPF_CGROUP_INET4_BIND              AttachType = 8
-	BPF_CGROUP_INET6_BIND              AttachType = 9
-	BPF_CGROUP_INET4_CONNECT           AttachType = 10
-	BPF_CGROUP_INET6_CONNECT           AttachType = 11
-	BPF_CGROUP_INET4_POST_BIND         AttachType = 12
-	BPF_CGROUP_INET6_POST_BIND         AttachType = 13
-	BPF_CGROUP_UDP4_SENDMSG            AttachType = 14
-	BPF_CGROUP_UDP6_SENDMSG            AttachType = 15
-	BPF_LIRC_MODE2                     AttachType = 16
-	BPF_FLOW_DISSECTOR                 AttachType = 17
-	BPF_CGROUP_SYSCTL                  AttachType = 18
-	BPF_CGROUP_UDP4_RECVMSG            AttachType = 19
-	BPF_CGROUP_UDP6_RECVMSG            AttachType = 20
-	BPF_CGROUP_GETSOCKOPT              AttachType = 21
-	BPF_CGROUP_SETSOCKOPT              AttachType = 22
-	BPF_TRACE_RAW_TP                   AttachType = 23
-	BPF_TRACE_FENTRY                   AttachType = 24
-	BPF_TRACE_FEXIT                    AttachType = 25
-	BPF_MODIFY_RETURN                  AttachType = 26
-	BPF_LSM_MAC                        AttachType = 27
-	BPF_TRACE_ITER                     AttachType = 28
-	BPF_CGROUP_INET4_GETPEERNAME       AttachType = 29
-	BPF_CGROUP_INET6_GETPEERNAME       AttachType = 30
-	BPF_CGROUP_INET4_GETSOCKNAME       AttachType = 31
-	BPF_CGROUP_INET6_GETSOCKNAME       AttachType = 32
-	BPF_XDP_DEVMAP                     AttachType = 33
-	BPF_CGROUP_INET_SOCK_RELEASE       AttachType = 34
-	BPF_XDP_CPUMAP                     AttachType = 35
-	BPF_SK_LOOKUP                      AttachType = 36
-	BPF_XDP                            AttachType = 37
-	BPF_SK_SKB_VERDICT                 AttachType = 38
-	BPF_SK_REUSEPORT_SELECT            AttachType = 39
-	BPF_SK_REUSEPORT_SELECT_OR_MIGRATE AttachType = 40
-	BPF_PERF_EVENT                     AttachType = 41
-	BPF_TRACE_KPROBE_MULTI             AttachType = 42
-	__MAX_BPF_ATTACH_TYPE              AttachType = 43
-)
-
-type Cmd uint32
-
-const (
-	BPF_MAP_CREATE                  Cmd = 0
-	BPF_MAP_LOOKUP_ELEM             Cmd = 1
-	BPF_MAP_UPDATE_ELEM             Cmd = 2
-	BPF_MAP_DELETE_ELEM             Cmd = 3
-	BPF_MAP_GET_NEXT_KEY            Cmd = 4
-	BPF_PROG_LOAD                   Cmd = 5
-	BPF_OBJ_PIN                     Cmd = 6
-	BPF_OBJ_GET                     Cmd = 7
-	BPF_PROG_ATTACH                 Cmd = 8
-	BPF_PROG_DETACH                 Cmd = 9
-	BPF_PROG_TEST_RUN               Cmd = 10
-	BPF_PROG_RUN                    Cmd = 10
-	BPF_PROG_GET_NEXT_ID            Cmd = 11
-	BPF_MAP_GET_NEXT_ID             Cmd = 12
-	BPF_PROG_GET_FD_BY_ID           Cmd = 13
-	BPF_MAP_GET_FD_BY_ID            Cmd = 14
-	BPF_OBJ_GET_INFO_BY_FD          Cmd = 15
-	BPF_PROG_QUERY                  Cmd = 16
-	BPF_RAW_TRACEPOINT_OPEN         Cmd = 17
-	BPF_BTF_LOAD                    Cmd = 18
-	BPF_BTF_GET_FD_BY_ID            Cmd = 19
-	BPF_TASK_FD_QUERY               Cmd = 20
-	BPF_MAP_LOOKUP_AND_DELETE_ELEM  Cmd = 21
-	BPF_MAP_FREEZE                  Cmd = 22
-	BPF_BTF_GET_NEXT_ID             Cmd = 23
-	BPF_MAP_LOOKUP_BATCH            Cmd = 24
-	BPF_MAP_LOOKUP_AND_DELETE_BATCH Cmd = 25
-	BPF_MAP_UPDATE_BATCH            Cmd = 26
-	BPF_MAP_DELETE_BATCH            Cmd = 27
-	BPF_LINK_CREATE                 Cmd = 28
-	BPF_LINK_UPDATE                 Cmd = 29
-	BPF_LINK_GET_FD_BY_ID           Cmd = 30
-	BPF_LINK_GET_NEXT_ID            Cmd = 31
-	BPF_ENABLE_STATS                Cmd = 32
-	BPF_ITER_CREATE                 Cmd = 33
-	BPF_LINK_DETACH                 Cmd = 34
-	BPF_PROG_BIND_MAP               Cmd = 35
-)
-
-type FunctionId uint32
-
-const (
-	BPF_FUNC_unspec                         FunctionId = 0
-	BPF_FUNC_map_lookup_elem                FunctionId = 1
-	BPF_FUNC_map_update_elem                FunctionId = 2
-	BPF_FUNC_map_delete_elem                FunctionId = 3
-	BPF_FUNC_probe_read                     FunctionId = 4
-	BPF_FUNC_ktime_get_ns                   FunctionId = 5
-	BPF_FUNC_trace_printk                   FunctionId = 6
-	BPF_FUNC_get_prandom_u32                FunctionId = 7
-	BPF_FUNC_get_smp_processor_id           FunctionId = 8
-	BPF_FUNC_skb_store_bytes                FunctionId = 9
-	BPF_FUNC_l3_csum_replace                FunctionId = 10
-	BPF_FUNC_l4_csum_replace                FunctionId = 11
-	BPF_FUNC_tail_call                      FunctionId = 12
-	BPF_FUNC_clone_redirect                 FunctionId = 13
-	BPF_FUNC_get_current_pid_tgid           FunctionId = 14
-	BPF_FUNC_get_current_uid_gid            FunctionId = 15
-	BPF_FUNC_get_current_comm               FunctionId = 16
-	BPF_FUNC_get_cgroup_classid             FunctionId = 17
-	BPF_FUNC_skb_vlan_push                  FunctionId = 18
-	BPF_FUNC_skb_vlan_pop                   FunctionId = 19
-	BPF_FUNC_skb_get_tunnel_key             FunctionId = 20
-	BPF_FUNC_skb_set_tunnel_key             FunctionId = 21
-	BPF_FUNC_perf_event_read                FunctionId = 22
-	BPF_FUNC_redirect                       FunctionId = 23
-	BPF_FUNC_get_route_realm                FunctionId = 24
-	BPF_FUNC_perf_event_output              FunctionId = 25
-	BPF_FUNC_skb_load_bytes                 FunctionId = 26
-	BPF_FUNC_get_stackid                    FunctionId = 27
-	BPF_FUNC_csum_diff                      FunctionId = 28
-	BPF_FUNC_skb_get_tunnel_opt             FunctionId = 29
-	BPF_FUNC_skb_set_tunnel_opt             FunctionId = 30
-	BPF_FUNC_skb_change_proto               FunctionId = 31
-	BPF_FUNC_skb_change_type                FunctionId = 32
-	BPF_FUNC_skb_under_cgroup               FunctionId = 33
-	BPF_FUNC_get_hash_recalc                FunctionId = 34
-	BPF_FUNC_get_current_task               FunctionId = 35
-	BPF_FUNC_probe_write_user               FunctionId = 36
-	BPF_FUNC_current_task_under_cgroup      FunctionId = 37
-	BPF_FUNC_skb_change_tail                FunctionId = 38
-	BPF_FUNC_skb_pull_data                  FunctionId = 39
-	BPF_FUNC_csum_update                    FunctionId = 40
-	BPF_FUNC_set_hash_invalid               FunctionId = 41
-	BPF_FUNC_get_numa_node_id               FunctionId = 42
-	BPF_FUNC_skb_change_head                FunctionId = 43
-	BPF_FUNC_xdp_adjust_head                FunctionId = 44
-	BPF_FUNC_probe_read_str                 FunctionId = 45
-	BPF_FUNC_get_socket_cookie              FunctionId = 46
-	BPF_FUNC_get_socket_uid                 FunctionId = 47
-	BPF_FUNC_set_hash                       FunctionId = 48
-	BPF_FUNC_setsockopt                     FunctionId = 49
-	BPF_FUNC_skb_adjust_room                FunctionId = 50
-	BPF_FUNC_redirect_map                   FunctionId = 51
-	BPF_FUNC_sk_redirect_map                FunctionId = 52
-	BPF_FUNC_sock_map_update                FunctionId = 53
-	BPF_FUNC_xdp_adjust_meta                FunctionId = 54
-	BPF_FUNC_perf_event_read_value          FunctionId = 55
-	BPF_FUNC_perf_prog_read_value           FunctionId = 56
-	BPF_FUNC_getsockopt                     FunctionId = 57
-	BPF_FUNC_override_return                FunctionId = 58
-	BPF_FUNC_sock_ops_cb_flags_set          FunctionId = 59
-	BPF_FUNC_msg_redirect_map               FunctionId = 60
-	BPF_FUNC_msg_apply_bytes                FunctionId = 61
-	BPF_FUNC_msg_cork_bytes                 FunctionId = 62
-	BPF_FUNC_msg_pull_data                  FunctionId = 63
-	BPF_FUNC_bind                           FunctionId = 64
-	BPF_FUNC_xdp_adjust_tail                FunctionId = 65
-	BPF_FUNC_skb_get_xfrm_state             FunctionId = 66
-	BPF_FUNC_get_stack                      FunctionId = 67
-	BPF_FUNC_skb_load_bytes_relative        FunctionId = 68
-	BPF_FUNC_fib_lookup                     FunctionId = 69
-	BPF_FUNC_sock_hash_update               FunctionId = 70
-	BPF_FUNC_msg_redirect_hash              FunctionId = 71
-	BPF_FUNC_sk_redirect_hash               FunctionId = 72
-	BPF_FUNC_lwt_push_encap                 FunctionId = 73
-	BPF_FUNC_lwt_seg6_store_bytes           FunctionId = 74
-	BPF_FUNC_lwt_seg6_adjust_srh            FunctionId = 75
-	BPF_FUNC_lwt_seg6_action                FunctionId = 76
-	BPF_FUNC_rc_repeat                      FunctionId = 77
-	BPF_FUNC_rc_keydown                     FunctionId = 78
-	BPF_FUNC_skb_cgroup_id                  FunctionId = 79
-	BPF_FUNC_get_current_cgroup_id          FunctionId = 80
-	BPF_FUNC_get_local_storage              FunctionId = 81
-	BPF_FUNC_sk_select_reuseport            FunctionId = 82
-	BPF_FUNC_skb_ancestor_cgroup_id         FunctionId = 83
-	BPF_FUNC_sk_lookup_tcp                  FunctionId = 84
-	BPF_FUNC_sk_lookup_udp                  FunctionId = 85
-	BPF_FUNC_sk_release                     FunctionId = 86
-	BPF_FUNC_map_push_elem                  FunctionId = 87
-	BPF_FUNC_map_pop_elem                   FunctionId = 88
-	BPF_FUNC_map_peek_elem                  FunctionId = 89
-	BPF_FUNC_msg_push_data                  FunctionId = 90
-	BPF_FUNC_msg_pop_data                   FunctionId = 91
-	BPF_FUNC_rc_pointer_rel                 FunctionId = 92
-	BPF_FUNC_spin_lock                      FunctionId = 93
-	BPF_FUNC_spin_unlock                    FunctionId = 94
-	BPF_FUNC_sk_fullsock                    FunctionId = 95
-	BPF_FUNC_tcp_sock                       FunctionId = 96
-	BPF_FUNC_skb_ecn_set_ce                 FunctionId = 97
-	BPF_FUNC_get_listener_sock              FunctionId = 98
-	BPF_FUNC_skc_lookup_tcp                 FunctionId = 99
-	BPF_FUNC_tcp_check_syncookie            FunctionId = 100
-	BPF_FUNC_sysctl_get_name                FunctionId = 101
-	BPF_FUNC_sysctl_get_current_value       FunctionId = 102
-	BPF_FUNC_sysctl_get_new_value           FunctionId = 103
-	BPF_FUNC_sysctl_set_new_value           FunctionId = 104
-	BPF_FUNC_strtol                         FunctionId = 105
-	BPF_FUNC_strtoul                        FunctionId = 106
-	BPF_FUNC_sk_storage_get                 FunctionId = 107
-	BPF_FUNC_sk_storage_delete              FunctionId = 108
-	BPF_FUNC_send_signal                    FunctionId = 109
-	BPF_FUNC_tcp_gen_syncookie              FunctionId = 110
-	BPF_FUNC_skb_output                     FunctionId = 111
-	BPF_FUNC_probe_read_user                FunctionId = 112
-	BPF_FUNC_probe_read_kernel              FunctionId = 113
-	BPF_FUNC_probe_read_user_str            FunctionId = 114
-	BPF_FUNC_probe_read_kernel_str          FunctionId = 115
-	BPF_FUNC_tcp_send_ack                   FunctionId = 116
-	BPF_FUNC_send_signal_thread             FunctionId = 117
-	BPF_FUNC_jiffies64                      FunctionId = 118
-	BPF_FUNC_read_branch_records            FunctionId = 119
-	BPF_FUNC_get_ns_current_pid_tgid        FunctionId = 120
-	BPF_FUNC_xdp_output                     FunctionId = 121
-	BPF_FUNC_get_netns_cookie               FunctionId = 122
-	BPF_FUNC_get_current_ancestor_cgroup_id FunctionId = 123
-	BPF_FUNC_sk_assign                      FunctionId = 124
-	BPF_FUNC_ktime_get_boot_ns              FunctionId = 125
-	BPF_FUNC_seq_printf                     FunctionId = 126
-	BPF_FUNC_seq_write                      FunctionId = 127
-	BPF_FUNC_sk_cgroup_id                   FunctionId = 128
-	BPF_FUNC_sk_ancestor_cgroup_id          FunctionId = 129
-	BPF_FUNC_ringbuf_output                 FunctionId = 130
-	BPF_FUNC_ringbuf_reserve                FunctionId = 131
-	BPF_FUNC_ringbuf_submit                 FunctionId = 132
-	BPF_FUNC_ringbuf_discard                FunctionId = 133
-	BPF_FUNC_ringbuf_query                  FunctionId = 134
-	BPF_FUNC_csum_level                     FunctionId = 135
-	BPF_FUNC_skc_to_tcp6_sock               FunctionId = 136
-	BPF_FUNC_skc_to_tcp_sock                FunctionId = 137
-	BPF_FUNC_skc_to_tcp_timewait_sock       FunctionId = 138
-	BPF_FUNC_skc_to_tcp_request_sock        FunctionId = 139
-	BPF_FUNC_skc_to_udp6_sock               FunctionId = 140
-	BPF_FUNC_get_task_stack                 FunctionId = 141
-	BPF_FUNC_load_hdr_opt                   FunctionId = 142
-	BPF_FUNC_store_hdr_opt                  FunctionId = 143
-	BPF_FUNC_reserve_hdr_opt                FunctionId = 144
-	BPF_FUNC_inode_storage_get              FunctionId = 145
-	BPF_FUNC_inode_storage_delete           FunctionId = 146
-	BPF_FUNC_d_path                         FunctionId = 147
-	BPF_FUNC_copy_from_user                 FunctionId = 148
-	BPF_FUNC_snprintf_btf                   FunctionId = 149
-	BPF_FUNC_seq_printf_btf                 FunctionId = 150
-	BPF_FUNC_skb_cgroup_classid             FunctionId = 151
-	BPF_FUNC_redirect_neigh                 FunctionId = 152
-	BPF_FUNC_per_cpu_ptr                    FunctionId = 153
-	BPF_FUNC_this_cpu_ptr                   FunctionId = 154
-	BPF_FUNC_redirect_peer                  FunctionId = 155
-	BPF_FUNC_task_storage_get               FunctionId = 156
-	BPF_FUNC_task_storage_delete            FunctionId = 157
-	BPF_FUNC_get_current_task_btf           FunctionId = 158
-	BPF_FUNC_bprm_opts_set                  FunctionId = 159
-	BPF_FUNC_ktime_get_coarse_ns            FunctionId = 160
-	BPF_FUNC_ima_inode_hash                 FunctionId = 161
-	BPF_FUNC_sock_from_file                 FunctionId = 162
-	BPF_FUNC_check_mtu                      FunctionId = 163
-	BPF_FUNC_for_each_map_elem              FunctionId = 164
-	BPF_FUNC_snprintf                       FunctionId = 165
-	BPF_FUNC_sys_bpf                        FunctionId = 166
-	BPF_FUNC_btf_find_by_name_kind          FunctionId = 167
-	BPF_FUNC_sys_close                      FunctionId = 168
-	BPF_FUNC_timer_init                     FunctionId = 169
-	BPF_FUNC_timer_set_callback             FunctionId = 170
-	BPF_FUNC_timer_start                    FunctionId = 171
-	BPF_FUNC_timer_cancel                   FunctionId = 172
-	BPF_FUNC_get_func_ip                    FunctionId = 173
-	BPF_FUNC_get_attach_cookie              FunctionId = 174
-	BPF_FUNC_task_pt_regs                   FunctionId = 175
-	BPF_FUNC_get_branch_snapshot            FunctionId = 176
-	BPF_FUNC_trace_vprintk                  FunctionId = 177
-	BPF_FUNC_skc_to_unix_sock               FunctionId = 178
-	BPF_FUNC_kallsyms_lookup_name           FunctionId = 179
-	BPF_FUNC_find_vma                       FunctionId = 180
-	BPF_FUNC_loop                           FunctionId = 181
-	BPF_FUNC_strncmp                        FunctionId = 182
-	BPF_FUNC_get_func_arg                   FunctionId = 183
-	BPF_FUNC_get_func_ret                   FunctionId = 184
-	BPF_FUNC_get_func_arg_cnt               FunctionId = 185
-	BPF_FUNC_get_retval                     FunctionId = 186
-	BPF_FUNC_set_retval                     FunctionId = 187
-	BPF_FUNC_xdp_get_buff_len               FunctionId = 188
-	BPF_FUNC_xdp_load_bytes                 FunctionId = 189
-	BPF_FUNC_xdp_store_bytes                FunctionId = 190
-	BPF_FUNC_copy_from_user_task            FunctionId = 191
-	BPF_FUNC_skb_set_tstamp                 FunctionId = 192
-	BPF_FUNC_ima_file_hash                  FunctionId = 193
-	BPF_FUNC_kptr_xchg                      FunctionId = 194
-	BPF_FUNC_map_lookup_percpu_elem         FunctionId = 195
-	BPF_FUNC_skc_to_mptcp_sock              FunctionId = 196
-	BPF_FUNC_dynptr_from_mem                FunctionId = 197
-	BPF_FUNC_ringbuf_reserve_dynptr         FunctionId = 198
-	BPF_FUNC_ringbuf_submit_dynptr          FunctionId = 199
-	BPF_FUNC_ringbuf_discard_dynptr         FunctionId = 200
-	BPF_FUNC_dynptr_read                    FunctionId = 201
-	BPF_FUNC_dynptr_write                   FunctionId = 202
-	BPF_FUNC_dynptr_data                    FunctionId = 203
-	__BPF_FUNC_MAX_ID                       FunctionId = 204
-)
-
-type HdrStartOff uint32
-
-const (
-	BPF_HDR_START_MAC HdrStartOff = 0
-	BPF_HDR_START_NET HdrStartOff = 1
-)
-
-type LinkType uint32
-
-const (
-	BPF_LINK_TYPE_UNSPEC         LinkType = 0
-	BPF_LINK_TYPE_RAW_TRACEPOINT LinkType = 1
-	BPF_LINK_TYPE_TRACING        LinkType = 2
-	BPF_LINK_TYPE_CGROUP         LinkType = 3
-	BPF_LINK_TYPE_ITER           LinkType = 4
-	BPF_LINK_TYPE_NETNS          LinkType = 5
-	BPF_LINK_TYPE_XDP            LinkType = 6
-	BPF_LINK_TYPE_PERF_EVENT     LinkType = 7
-	BPF_LINK_TYPE_KPROBE_MULTI   LinkType = 8
-	BPF_LINK_TYPE_STRUCT_OPS     LinkType = 9
-	MAX_BPF_LINK_TYPE            LinkType = 10
-)
-
-type MapType uint32
-
-const (
-	BPF_MAP_TYPE_UNSPEC                MapType = 0
-	BPF_MAP_TYPE_HASH                  MapType = 1
-	BPF_MAP_TYPE_ARRAY                 MapType = 2
-	BPF_MAP_TYPE_PROG_ARRAY            MapType = 3
-	BPF_MAP_TYPE_PERF_EVENT_ARRAY      MapType = 4
-	BPF_MAP_TYPE_PERCPU_HASH           MapType = 5
-	BPF_MAP_TYPE_PERCPU_ARRAY          MapType = 6
-	BPF_MAP_TYPE_STACK_TRACE           MapType = 7
-	BPF_MAP_TYPE_CGROUP_ARRAY          MapType = 8
-	BPF_MAP_TYPE_LRU_HASH              MapType = 9
-	BPF_MAP_TYPE_LRU_PERCPU_HASH       MapType = 10
-	BPF_MAP_TYPE_LPM_TRIE              MapType = 11
-	BPF_MAP_TYPE_ARRAY_OF_MAPS         MapType = 12
-	BPF_MAP_TYPE_HASH_OF_MAPS          MapType = 13
-	BPF_MAP_TYPE_DEVMAP                MapType = 14
-	BPF_MAP_TYPE_SOCKMAP               MapType = 15
-	BPF_MAP_TYPE_CPUMAP                MapType = 16
-	BPF_MAP_TYPE_XSKMAP                MapType = 17
-	BPF_MAP_TYPE_SOCKHASH              MapType = 18
-	BPF_MAP_TYPE_CGROUP_STORAGE        MapType = 19
-	BPF_MAP_TYPE_REUSEPORT_SOCKARRAY   MapType = 20
-	BPF_MAP_TYPE_PERCPU_CGROUP_STORAGE MapType = 21
-	BPF_MAP_TYPE_QUEUE                 MapType = 22
-	BPF_MAP_TYPE_STACK                 MapType = 23
-	BPF_MAP_TYPE_SK_STORAGE            MapType = 24
-	BPF_MAP_TYPE_DEVMAP_HASH           MapType = 25
-	BPF_MAP_TYPE_STRUCT_OPS            MapType = 26
-	BPF_MAP_TYPE_RINGBUF               MapType = 27
-	BPF_MAP_TYPE_INODE_STORAGE         MapType = 28
-	BPF_MAP_TYPE_TASK_STORAGE          MapType = 29
-	BPF_MAP_TYPE_BLOOM_FILTER          MapType = 30
-)
-
-type ProgType uint32
-
-const (
-	BPF_PROG_TYPE_UNSPEC                  ProgType = 0
-	BPF_PROG_TYPE_SOCKET_FILTER           ProgType = 1
-	BPF_PROG_TYPE_KPROBE                  ProgType = 2
-	BPF_PROG_TYPE_SCHED_CLS               ProgType = 3
-	BPF_PROG_TYPE_SCHED_ACT               ProgType = 4
-	BPF_PROG_TYPE_TRACEPOINT              ProgType = 5
-	BPF_PROG_TYPE_XDP                     ProgType = 6
-	BPF_PROG_TYPE_PERF_EVENT              ProgType = 7
-	BPF_PROG_TYPE_CGROUP_SKB              ProgType = 8
-	BPF_PROG_TYPE_CGROUP_SOCK             ProgType = 9
-	BPF_PROG_TYPE_LWT_IN                  ProgType = 10
-	BPF_PROG_TYPE_LWT_OUT                 ProgType = 11
-	BPF_PROG_TYPE_LWT_XMIT                ProgType = 12
-	BPF_PROG_TYPE_SOCK_OPS                ProgType = 13
-	BPF_PROG_TYPE_SK_SKB                  ProgType = 14
-	BPF_PROG_TYPE_CGROUP_DEVICE           ProgType = 15
-	BPF_PROG_TYPE_SK_MSG                  ProgType = 16
-	BPF_PROG_TYPE_RAW_TRACEPOINT          ProgType = 17
-	BPF_PROG_TYPE_CGROUP_SOCK_ADDR        ProgType = 18
-	BPF_PROG_TYPE_LWT_SEG6LOCAL           ProgType = 19
-	BPF_PROG_TYPE_LIRC_MODE2              ProgType = 20
-	BPF_PROG_TYPE_SK_REUSEPORT            ProgType = 21
-	BPF_PROG_TYPE_FLOW_DISSECTOR          ProgType = 22
-	BPF_PROG_TYPE_CGROUP_SYSCTL           ProgType = 23
-	BPF_PROG_TYPE_RAW_TRACEPOINT_WRITABLE ProgType = 24
-	BPF_PROG_TYPE_CGROUP_SOCKOPT          ProgType = 25
-	BPF_PROG_TYPE_TRACING                 ProgType = 26
-	BPF_PROG_TYPE_STRUCT_OPS              ProgType = 27
-	BPF_PROG_TYPE_EXT                     ProgType = 28
-	BPF_PROG_TYPE_LSM                     ProgType = 29
-	BPF_PROG_TYPE_SK_LOOKUP               ProgType = 30
-	BPF_PROG_TYPE_SYSCALL                 ProgType = 31
-)
-
-type RetCode uint32
-
-const (
-	BPF_OK          RetCode = 0
-	BPF_DROP        RetCode = 2
-	BPF_REDIRECT    RetCode = 7
-	BPF_LWT_REROUTE RetCode = 128
-)
-
-type SkAction uint32
-
-const (
-	SK_DROP SkAction = 0
-	SK_PASS SkAction = 1
-)
-
-type StackBuildIdStatus uint32
-
-const (
-	BPF_STACK_BUILD_ID_EMPTY StackBuildIdStatus = 0
-	BPF_STACK_BUILD_ID_VALID StackBuildIdStatus = 1
-	BPF_STACK_BUILD_ID_IP    StackBuildIdStatus = 2
-)
-
-type StatsType uint32
-
-const (
-	BPF_STATS_RUN_TIME StatsType = 0
-)
-
-type XdpAction uint32
-
-const (
-	XDP_ABORTED  XdpAction = 0
-	XDP_DROP     XdpAction = 1
-	XDP_PASS     XdpAction = 2
-	XDP_TX       XdpAction = 3
-	XDP_REDIRECT XdpAction = 4
-)
-
-type BtfInfo struct {
-	Btf       Pointer
-	BtfSize   uint32
-	Id        BTFID
-	Name      Pointer
-	NameLen   uint32
-	KernelBtf uint32
-}
-
-type FuncInfo struct {
-	InsnOff uint32
-	TypeId  uint32
-}
-
-type LineInfo struct {
-	InsnOff     uint32
-	FileNameOff uint32
-	LineOff     uint32
-	LineCol     uint32
-}
-
-type LinkInfo struct {
-	Type   LinkType
-	Id     LinkID
-	ProgId uint32
-	_      [4]byte
-	Extra  [16]uint8
-}
-
-type MapInfo struct {
-	Type                  uint32
-	Id                    uint32
-	KeySize               uint32
-	ValueSize             uint32
-	MaxEntries            uint32
-	MapFlags              MapFlags
-	Name                  ObjName
-	Ifindex               uint32
-	BtfVmlinuxValueTypeId TypeID
-	NetnsDev              uint64
-	NetnsIno              uint64
-	BtfId                 uint32
-	BtfKeyTypeId          TypeID
-	BtfValueTypeId        TypeID
-	_                     [4]byte
-	MapExtra              uint64
-}
-
-type ProgInfo struct {
-	Type                 uint32
-	Id                   uint32
-	Tag                  [8]uint8
-	JitedProgLen         uint32
-	XlatedProgLen        uint32
-	JitedProgInsns       uint64
-	XlatedProgInsns      Pointer
-	LoadTime             uint64
-	CreatedByUid         uint32
-	NrMapIds             uint32
-	MapIds               Pointer
-	Name                 ObjName
-	Ifindex              uint32
-	_                    [4]byte /* unsupported bitfield */
-	NetnsDev             uint64
-	NetnsIno             uint64
-	NrJitedKsyms         uint32
-	NrJitedFuncLens      uint32
-	JitedKsyms           uint64
-	JitedFuncLens        uint64
-	BtfId                BTFID
-	FuncInfoRecSize      uint32
-	FuncInfo             uint64
-	NrFuncInfo           uint32
-	NrLineInfo           uint32
-	LineInfo             uint64
-	JitedLineInfo        uint64
-	NrJitedLineInfo      uint32
-	LineInfoRecSize      uint32
-	JitedLineInfoRecSize uint32
-	NrProgTags           uint32
-	ProgTags             uint64
-	RunTimeNs            uint64
-	RunCnt               uint64
-	RecursionMisses      uint64
-	VerifiedInsns        uint32
-	_                    [4]byte
-}
-
-type SkLookup struct {
-	Cookie         uint64
-	Family         uint32
-	Protocol       uint32
-	RemoteIp4      [4]uint8
-	RemoteIp6      [16]uint8
-	RemotePort     uint16
-	_              [2]byte
-	LocalIp4       [4]uint8
-	LocalIp6       [16]uint8
-	LocalPort      uint32
-	IngressIfindex uint32
-	_              [4]byte
-}
-
-type XdpMd struct {
-	Data           uint32
-	DataEnd        uint32
-	DataMeta       uint32
-	IngressIfindex uint32
-	RxQueueIndex   uint32
-	EgressIfindex  uint32
-}
-
-type BtfGetFdByIdAttr struct{ Id uint32 }
-
-func BtfGetFdById(attr *BtfGetFdByIdAttr) (*FD, error) {
-	fd, err := BPF(BPF_BTF_GET_FD_BY_ID, unsafe.Pointer(attr), unsafe.Sizeof(*attr))
-	if err != nil {
-		return nil, err
-	}
-	return NewFD(int(fd))
-}
-
-type BtfGetNextIdAttr struct {
-	Id     BTFID
-	NextId BTFID
-}
-
-func BtfGetNextId(attr *BtfGetNextIdAttr) error {
-	_, err := BPF(BPF_BTF_GET_NEXT_ID, unsafe.Pointer(attr), unsafe.Sizeof(*attr))
-	return err
-}
-
-type BtfLoadAttr struct {
-	Btf         Pointer
-	BtfLogBuf   Pointer
-	BtfSize     uint32
-	BtfLogSize  uint32
-	BtfLogLevel uint32
-	_           [4]byte
-}
-
-func BtfLoad(attr *BtfLoadAttr) (*FD, error) {
-	fd, err := BPF(BPF_BTF_LOAD, unsafe.Pointer(attr), unsafe.Sizeof(*attr))
-	if err != nil {
-		return nil, err
-	}
-	return NewFD(int(fd))
-}
-
-type EnableStatsAttr struct{ Type uint32 }
-
-func EnableStats(attr *EnableStatsAttr) (*FD, error) {
-	fd, err := BPF(BPF_ENABLE_STATS, unsafe.Pointer(attr), unsafe.Sizeof(*attr))
-	if err != nil {
-		return nil, err
-	}
-	return NewFD(int(fd))
-}
-
-type IterCreateAttr struct {
-	LinkFd uint32
-	Flags  uint32
-}
-
-func IterCreate(attr *IterCreateAttr) (*FD, error) {
-	fd, err := BPF(BPF_ITER_CREATE, unsafe.Pointer(attr), unsafe.Sizeof(*attr))
-	if err != nil {
-		return nil, err
-	}
-	return NewFD(int(fd))
-}
-
-type LinkCreateAttr struct {
-	ProgFd      uint32
-	TargetFd    uint32
-	AttachType  AttachType
-	Flags       uint32
-	TargetBtfId TypeID
-	_           [28]byte
-}
-
-func LinkCreate(attr *LinkCreateAttr) (*FD, error) {
-	fd, err := BPF(BPF_LINK_CREATE, unsafe.Pointer(attr), unsafe.Sizeof(*attr))
-	if err != nil {
-		return nil, err
-	}
-	return NewFD(int(fd))
-}
-
-type LinkCreateIterAttr struct {
-	ProgFd      uint32
-	TargetFd    uint32
-	AttachType  AttachType
-	Flags       uint32
-	IterInfo    Pointer
-	IterInfoLen uint32
-	_           [20]byte
-}
-
-func LinkCreateIter(attr *LinkCreateIterAttr) (*FD, error) {
-	fd, err := BPF(BPF_LINK_CREATE, unsafe.Pointer(attr), unsafe.Sizeof(*attr))
-	if err != nil {
-		return nil, err
-	}
-	return NewFD(int(fd))
-}
-
-type LinkCreateKprobeMultiAttr struct {
-	ProgFd           uint32
-	TargetFd         uint32
-	AttachType       AttachType
-	Flags            uint32
-	KprobeMultiFlags uint32
-	Count            uint32
-	Syms             Pointer
-	Addrs            Pointer
-	Cookies          Pointer
-}
-
-func LinkCreateKprobeMulti(attr *LinkCreateKprobeMultiAttr) (*FD, error) {
-	fd, err := BPF(BPF_LINK_CREATE, unsafe.Pointer(attr), unsafe.Sizeof(*attr))
-	if err != nil {
-		return nil, err
-	}
-	return NewFD(int(fd))
-}
-
-type LinkCreatePerfEventAttr struct {
-	ProgFd     uint32
-	TargetFd   uint32
-	AttachType AttachType
-	Flags      uint32
-	BpfCookie  uint64
-	_          [24]byte
-}
-
-func LinkCreatePerfEvent(attr *LinkCreatePerfEventAttr) (*FD, error) {
-	fd, err := BPF(BPF_LINK_CREATE, unsafe.Pointer(attr), unsafe.Sizeof(*attr))
-	if err != nil {
-		return nil, err
-	}
-	return NewFD(int(fd))
-}
-
-type LinkCreateTracingAttr struct {
-	ProgFd      uint32
-	TargetFd    uint32
-	AttachType  AttachType
-	Flags       uint32
-	TargetBtfId BTFID
-	_           [4]byte
-	Cookie      uint64
-	_           [16]byte
-}
-
-func LinkCreateTracing(attr *LinkCreateTracingAttr) (*FD, error) {
-	fd, err := BPF(BPF_LINK_CREATE, unsafe.Pointer(attr), unsafe.Sizeof(*attr))
-	if err != nil {
-		return nil, err
-	}
-	return NewFD(int(fd))
-}
-
-type LinkUpdateAttr struct {
-	LinkFd    uint32
-	NewProgFd uint32
-	Flags     uint32
-	OldProgFd uint32
-}
-
-func LinkUpdate(attr *LinkUpdateAttr) error {
-	_, err := BPF(BPF_LINK_UPDATE, unsafe.Pointer(attr), unsafe.Sizeof(*attr))
-	return err
-}
-
-type MapCreateAttr struct {
-	MapType               MapType
-	KeySize               uint32
-	ValueSize             uint32
-	MaxEntries            uint32
-	MapFlags              MapFlags
-	InnerMapFd            uint32
-	NumaNode              uint32
-	MapName               ObjName
-	MapIfindex            uint32
-	BtfFd                 uint32
-	BtfKeyTypeId          TypeID
-	BtfValueTypeId        TypeID
-	BtfVmlinuxValueTypeId TypeID
-	MapExtra              uint64
-}
-
-func MapCreate(attr *MapCreateAttr) (*FD, error) {
-	fd, err := BPF(BPF_MAP_CREATE, unsafe.Pointer(attr), unsafe.Sizeof(*attr))
-	if err != nil {
-		return nil, err
-	}
-	return NewFD(int(fd))
-}
-
-type MapDeleteBatchAttr struct {
-	InBatch   Pointer
-	OutBatch  Pointer
-	Keys      Pointer
-	Values    Pointer
-	Count     uint32
-	MapFd     uint32
-	ElemFlags uint64
-	Flags     uint64
-}
-
-func MapDeleteBatch(attr *MapDeleteBatchAttr) error {
-	_, err := BPF(BPF_MAP_DELETE_BATCH, unsafe.Pointer(attr), unsafe.Sizeof(*attr))
-	return err
-}
-
-type MapDeleteElemAttr struct {
-	MapFd uint32
-	_     [4]byte
-	Key   Pointer
-	Value Pointer
-	Flags uint64
-}
-
-func MapDeleteElem(attr *MapDeleteElemAttr) error {
-	_, err := BPF(BPF_MAP_DELETE_ELEM, unsafe.Pointer(attr), unsafe.Sizeof(*attr))
-	return err
-}
-
-type MapFreezeAttr struct{ MapFd uint32 }
-
-func MapFreeze(attr *MapFreezeAttr) error {
-	_, err := BPF(BPF_MAP_FREEZE, unsafe.Pointer(attr), unsafe.Sizeof(*attr))
-	return err
-}
-
-type MapGetFdByIdAttr struct{ Id uint32 }
-
-func MapGetFdById(attr *MapGetFdByIdAttr) (*FD, error) {
-	fd, err := BPF(BPF_MAP_GET_FD_BY_ID, unsafe.Pointer(attr), unsafe.Sizeof(*attr))
-	if err != nil {
-		return nil, err
-	}
-	return NewFD(int(fd))
-}
-
-type MapGetNextIdAttr struct {
-	Id     uint32
-	NextId uint32
-}
-
-func MapGetNextId(attr *MapGetNextIdAttr) error {
-	_, err := BPF(BPF_MAP_GET_NEXT_ID, unsafe.Pointer(attr), unsafe.Sizeof(*attr))
-	return err
-}
-
-type MapGetNextKeyAttr struct {
-	MapFd   uint32
-	_       [4]byte
-	Key     Pointer
-	NextKey Pointer
-}
-
-func MapGetNextKey(attr *MapGetNextKeyAttr) error {
-	_, err := BPF(BPF_MAP_GET_NEXT_KEY, unsafe.Pointer(attr), unsafe.Sizeof(*attr))
-	return err
-}
-
-type MapLookupAndDeleteBatchAttr struct {
-	InBatch   Pointer
-	OutBatch  Pointer
-	Keys      Pointer
-	Values    Pointer
-	Count     uint32
-	MapFd     uint32
-	ElemFlags uint64
-	Flags     uint64
-}
-
-func MapLookupAndDeleteBatch(attr *MapLookupAndDeleteBatchAttr) error {
-	_, err := BPF(BPF_MAP_LOOKUP_AND_DELETE_BATCH, unsafe.Pointer(attr), unsafe.Sizeof(*attr))
-	return err
-}
-
-type MapLookupAndDeleteElemAttr struct {
-	MapFd uint32
-	_     [4]byte
-	Key   Pointer
-	Value Pointer
-	Flags uint64
-}
-
-func MapLookupAndDeleteElem(attr *MapLookupAndDeleteElemAttr) error {
-	_, err := BPF(BPF_MAP_LOOKUP_AND_DELETE_ELEM, unsafe.Pointer(attr), unsafe.Sizeof(*attr))
-	return err
-}
-
-type MapLookupBatchAttr struct {
-	InBatch   Pointer
-	OutBatch  Pointer
-	Keys      Pointer
-	Values    Pointer
-	Count     uint32
-	MapFd     uint32
-	ElemFlags uint64
-	Flags     uint64
-}
-
-func MapLookupBatch(attr *MapLookupBatchAttr) error {
-	_, err := BPF(BPF_MAP_LOOKUP_BATCH, unsafe.Pointer(attr), unsafe.Sizeof(*attr))
-	return err
-}
-
-type MapLookupElemAttr struct {
-	MapFd uint32
-	_     [4]byte
-	Key   Pointer
-	Value Pointer
-	Flags uint64
-}
-
-func MapLookupElem(attr *MapLookupElemAttr) error {
-	_, err := BPF(BPF_MAP_LOOKUP_ELEM, unsafe.Pointer(attr), unsafe.Sizeof(*attr))
-	return err
-}
-
-type MapUpdateBatchAttr struct {
-	InBatch   Pointer
-	OutBatch  Pointer
-	Keys      Pointer
-	Values    Pointer
-	Count     uint32
-	MapFd     uint32
-	ElemFlags uint64
-	Flags     uint64
-}
-
-func MapUpdateBatch(attr *MapUpdateBatchAttr) error {
-	_, err := BPF(BPF_MAP_UPDATE_BATCH, unsafe.Pointer(attr), unsafe.Sizeof(*attr))
-	return err
-}
-
-type MapUpdateElemAttr struct {
-	MapFd uint32
-	_     [4]byte
-	Key   Pointer
-	Value Pointer
-	Flags uint64
-}
-
-func MapUpdateElem(attr *MapUpdateElemAttr) error {
-	_, err := BPF(BPF_MAP_UPDATE_ELEM, unsafe.Pointer(attr), unsafe.Sizeof(*attr))
-	return err
-}
-
-type ObjGetAttr struct {
-	Pathname  Pointer
-	BpfFd     uint32
-	FileFlags uint32
-}
-
-func ObjGet(attr *ObjGetAttr) (*FD, error) {
-	fd, err := BPF(BPF_OBJ_GET, unsafe.Pointer(attr), unsafe.Sizeof(*attr))
-	if err != nil {
-		return nil, err
-	}
-	return NewFD(int(fd))
-}
-
-type ObjGetInfoByFdAttr struct {
-	BpfFd   uint32
-	InfoLen uint32
-	Info    Pointer
-}
-
-func ObjGetInfoByFd(attr *ObjGetInfoByFdAttr) error {
-	_, err := BPF(BPF_OBJ_GET_INFO_BY_FD, unsafe.Pointer(attr), unsafe.Sizeof(*attr))
-	return err
-}
-
-type ObjPinAttr struct {
-	Pathname  Pointer
-	BpfFd     uint32
-	FileFlags uint32
-}
-
-func ObjPin(attr *ObjPinAttr) error {
-	_, err := BPF(BPF_OBJ_PIN, unsafe.Pointer(attr), unsafe.Sizeof(*attr))
-	return err
-}
-
-type ProgAttachAttr struct {
-	TargetFd     uint32
-	AttachBpfFd  uint32
-	AttachType   uint32
-	AttachFlags  uint32
-	ReplaceBpfFd uint32
-}
-
-func ProgAttach(attr *ProgAttachAttr) error {
-	_, err := BPF(BPF_PROG_ATTACH, unsafe.Pointer(attr), unsafe.Sizeof(*attr))
-	return err
-}
-
-type ProgBindMapAttr struct {
-	ProgFd uint32
-	MapFd  uint32
-	Flags  uint32
-}
-
-func ProgBindMap(attr *ProgBindMapAttr) error {
-	_, err := BPF(BPF_PROG_BIND_MAP, unsafe.Pointer(attr), unsafe.Sizeof(*attr))
-	return err
-}
-
-type ProgDetachAttr struct {
-	TargetFd    uint32
-	AttachBpfFd uint32
-	AttachType  uint32
-}
-
-func ProgDetach(attr *ProgDetachAttr) error {
-	_, err := BPF(BPF_PROG_DETACH, unsafe.Pointer(attr), unsafe.Sizeof(*attr))
-	return err
-}
-
-type ProgGetFdByIdAttr struct{ Id uint32 }
-
-func ProgGetFdById(attr *ProgGetFdByIdAttr) (*FD, error) {
-	fd, err := BPF(BPF_PROG_GET_FD_BY_ID, unsafe.Pointer(attr), unsafe.Sizeof(*attr))
-	if err != nil {
-		return nil, err
-	}
-	return NewFD(int(fd))
-}
-
-type ProgGetNextIdAttr struct {
-	Id     uint32
-	NextId uint32
-}
-
-func ProgGetNextId(attr *ProgGetNextIdAttr) error {
-	_, err := BPF(BPF_PROG_GET_NEXT_ID, unsafe.Pointer(attr), unsafe.Sizeof(*attr))
-	return err
-}
-
-type ProgLoadAttr struct {
-	ProgType           ProgType
-	InsnCnt            uint32
-	Insns              Pointer
-	License            Pointer
-	LogLevel           LogLevel
-	LogSize            uint32
-	LogBuf             Pointer
-	KernVersion        uint32
-	ProgFlags          uint32
-	ProgName           ObjName
-	ProgIfindex        uint32
-	ExpectedAttachType AttachType
-	ProgBtfFd          uint32
-	FuncInfoRecSize    uint32
-	FuncInfo           Pointer
-	FuncInfoCnt        uint32
-	LineInfoRecSize    uint32
-	LineInfo           Pointer
-	LineInfoCnt        uint32
-	AttachBtfId        TypeID
-	AttachBtfObjFd     uint32
-	CoreReloCnt        uint32
-	FdArray            Pointer
-	CoreRelos          Pointer
-	CoreReloRecSize    uint32
-	_                  [4]byte
-}
-
-func ProgLoad(attr *ProgLoadAttr) (*FD, error) {
-	fd, err := BPF(BPF_PROG_LOAD, unsafe.Pointer(attr), unsafe.Sizeof(*attr))
-	if err != nil {
-		return nil, err
-	}
-	return NewFD(int(fd))
-}
-
-type ProgQueryAttr struct {
-	TargetFd    uint32
-	AttachType  AttachType
-	QueryFlags  uint32
-	AttachFlags uint32
-	ProgIds     Pointer
-	ProgCount   uint32
-	_           [4]byte
-}
-
-func ProgQuery(attr *ProgQueryAttr) error {
-	_, err := BPF(BPF_PROG_QUERY, unsafe.Pointer(attr), unsafe.Sizeof(*attr))
-	return err
-}
-
-type ProgRunAttr struct {
-	ProgFd      uint32
-	Retval      uint32
-	DataSizeIn  uint32
-	DataSizeOut uint32
-	DataIn      Pointer
-	DataOut     Pointer
-	Repeat      uint32
-	Duration    uint32
-	CtxSizeIn   uint32
-	CtxSizeOut  uint32
-	CtxIn       Pointer
-	CtxOut      Pointer
-	Flags       uint32
-	Cpu         uint32
-	BatchSize   uint32
-	_           [4]byte
-}
-
-func ProgRun(attr *ProgRunAttr) error {
-	_, err := BPF(BPF_PROG_TEST_RUN, unsafe.Pointer(attr), unsafe.Sizeof(*attr))
-	return err
-}
-
-type RawTracepointOpenAttr struct {
-	Name   Pointer
-	ProgFd uint32
-	_      [4]byte
-}
-
-func RawTracepointOpen(attr *RawTracepointOpenAttr) (*FD, error) {
-	fd, err := BPF(BPF_RAW_TRACEPOINT_OPEN, unsafe.Pointer(attr), unsafe.Sizeof(*attr))
-	if err != nil {
-		return nil, err
-	}
-	return NewFD(int(fd))
-}
-
-type CgroupLinkInfo struct {
-	CgroupId   uint64
-	AttachType AttachType
-	_          [4]byte
-}
-
-type IterLinkInfo struct {
-	TargetName    Pointer
-	TargetNameLen uint32
-}
-
-type NetNsLinkInfo struct {
-	NetnsIno   uint32
-	AttachType AttachType
-}
-
-type RawTracepointLinkInfo struct {
-	TpName    Pointer
-	TpNameLen uint32
-	_         [4]byte
-}
-
-type TracingLinkInfo struct {
-	AttachType  AttachType
-	TargetObjId uint32
-	TargetBtfId TypeID
-}
-
-type XDPLinkInfo struct{ Ifindex uint32 }
diff --git a/vendor/github.com/cilium/ebpf/internal/tracefs/kprobe.go b/vendor/github.com/cilium/ebpf/internal/tracefs/kprobe.go
deleted file mode 100644
index 4059a099b..000000000
--- a/vendor/github.com/cilium/ebpf/internal/tracefs/kprobe.go
+++ /dev/null
@@ -1,359 +0,0 @@
-package tracefs
-
-import (
-	"crypto/rand"
-	"errors"
-	"fmt"
-	"os"
-	"path/filepath"
-	"runtime"
-	"strings"
-	"syscall"
-
-	"github.com/cilium/ebpf/internal"
-	"github.com/cilium/ebpf/internal/unix"
-)
-
-var (
-	ErrInvalidInput = errors.New("invalid input")
-
-	ErrInvalidMaxActive = errors.New("can only set maxactive on kretprobes")
-)
-
-//go:generate stringer -type=ProbeType -linecomment
-
-type ProbeType uint8
-
-const (
-	Kprobe ProbeType = iota // kprobe
-	Uprobe                  // uprobe
-)
-
-func (pt ProbeType) eventsFile() (*os.File, error) {
-	path, err := sanitizeTracefsPath(fmt.Sprintf("%s_events", pt.String()))
-	if err != nil {
-		return nil, err
-	}
-
-	return os.OpenFile(path, os.O_APPEND|os.O_WRONLY, 0666)
-}
-
-type ProbeArgs struct {
-	Type                         ProbeType
-	Symbol, Group, Path          string
-	Offset, RefCtrOffset, Cookie uint64
-	Pid, RetprobeMaxActive       int
-	Ret                          bool
-}
-
-// RandomGroup generates a pseudorandom string for use as a tracefs group name.
-// Returns an error when the output string would exceed 63 characters (kernel
-// limitation), when rand.Read() fails or when prefix contains characters not
-// allowed by IsValidTraceID.
-func RandomGroup(prefix string) (string, error) {
-	if !validIdentifier(prefix) {
-		return "", fmt.Errorf("prefix '%s' must be alphanumeric or underscore: %w", prefix, ErrInvalidInput)
-	}
-
-	b := make([]byte, 8)
-	if _, err := rand.Read(b); err != nil {
-		return "", fmt.Errorf("reading random bytes: %w", err)
-	}
-
-	group := fmt.Sprintf("%s_%x", prefix, b)
-	if len(group) > 63 {
-		return "", fmt.Errorf("group name '%s' cannot be longer than 63 characters: %w", group, ErrInvalidInput)
-	}
-
-	return group, nil
-}
-
-// validIdentifier implements the equivalent of a regex match
-// against "^[a-zA-Z_][0-9a-zA-Z_]*$".
-//
-// Trace event groups, names and kernel symbols must adhere to this set
-// of characters. Non-empty, first character must not be a number, all
-// characters must be alphanumeric or underscore.
-func validIdentifier(s string) bool {
-	if len(s) < 1 {
-		return false
-	}
-	for i, c := range []byte(s) {
-		switch {
-		case c >= 'a' && c <= 'z':
-		case c >= 'A' && c <= 'Z':
-		case c == '_':
-		case i > 0 && c >= '0' && c <= '9':
-
-		default:
-			return false
-		}
-	}
-
-	return true
-}
-
-func sanitizeTracefsPath(path ...string) (string, error) {
-	base, err := getTracefsPath()
-	if err != nil {
-		return "", err
-	}
-	l := filepath.Join(path...)
-	p := filepath.Join(base, l)
-	if !strings.HasPrefix(p, base) {
-		return "", fmt.Errorf("path '%s' attempts to escape base path '%s': %w", l, base, ErrInvalidInput)
-	}
-	return p, nil
-}
-
-// getTracefsPath will return a correct path to the tracefs mount point.
-// Since kernel 4.1 tracefs should be mounted by default at /sys/kernel/tracing,
-// but may be also be available at /sys/kernel/debug/tracing if debugfs is mounted.
-// The available tracefs paths will depends on distribution choices.
-var getTracefsPath = internal.Memoize(func() (string, error) {
-	for _, p := range []struct {
-		path   string
-		fsType int64
-	}{
-		{"/sys/kernel/tracing", unix.TRACEFS_MAGIC},
-		{"/sys/kernel/debug/tracing", unix.TRACEFS_MAGIC},
-		// RHEL/CentOS
-		{"/sys/kernel/debug/tracing", unix.DEBUGFS_MAGIC},
-	} {
-		if fsType, err := internal.FSType(p.path); err == nil && fsType == p.fsType {
-			return p.path, nil
-		}
-	}
-
-	return "", errors.New("neither debugfs nor tracefs are mounted")
-})
-
-// sanitizeIdentifier replaces every invalid character for the tracefs api with an underscore.
-//
-// It is equivalent to calling regexp.MustCompile("[^a-zA-Z0-9]+").ReplaceAllString("_").
-func sanitizeIdentifier(s string) string {
-	var skip bool
-	return strings.Map(func(c rune) rune {
-		switch {
-		case c >= 'a' && c <= 'z',
-			c >= 'A' && c <= 'Z',
-			c >= '0' && c <= '9':
-			skip = false
-			return c
-
-		case skip:
-			return -1
-
-		default:
-			skip = true
-			return '_'
-		}
-	}, s)
-}
-
-// EventID reads a trace event's ID from tracefs given its group and name.
-// The kernel requires group and name to be alphanumeric or underscore.
-func EventID(group, name string) (uint64, error) {
-	if !validIdentifier(group) {
-		return 0, fmt.Errorf("invalid tracefs group: %q", group)
-	}
-
-	if !validIdentifier(name) {
-		return 0, fmt.Errorf("invalid tracefs name: %q", name)
-	}
-
-	path, err := sanitizeTracefsPath("events", group, name, "id")
-	if err != nil {
-		return 0, err
-	}
-	tid, err := internal.ReadUint64FromFile("%d\n", path)
-	if errors.Is(err, os.ErrNotExist) {
-		return 0, err
-	}
-	if err != nil {
-		return 0, fmt.Errorf("reading trace event ID of %s/%s: %w", group, name, err)
-	}
-
-	return tid, nil
-}
-
-func probePrefix(ret bool, maxActive int) string {
-	if ret {
-		if maxActive > 0 {
-			return fmt.Sprintf("r%d", maxActive)
-		}
-		return "r"
-	}
-	return "p"
-}
-
-// Event represents an entry in a tracefs probe events file.
-type Event struct {
-	typ         ProbeType
-	group, name string
-	// event id allocated by the kernel. 0 if the event has already been removed.
-	id uint64
-}
-
-// NewEvent creates a new ephemeral trace event.
-//
-// Returns os.ErrNotExist if symbol is not a valid
-// kernel symbol, or if it is not traceable with kprobes. Returns os.ErrExist
-// if a probe with the same group and symbol already exists. Returns an error if
-// args.RetprobeMaxActive is used on non kprobe types. Returns ErrNotSupported if
-// the kernel is too old to support kretprobe maxactive.
-func NewEvent(args ProbeArgs) (*Event, error) {
-	// Before attempting to create a trace event through tracefs,
-	// check if an event with the same group and name already exists.
-	// Kernels 4.x and earlier don't return os.ErrExist on writing a duplicate
-	// entry, so we need to rely on reads for detecting uniqueness.
-	eventName := sanitizeIdentifier(args.Symbol)
-	_, err := EventID(args.Group, eventName)
-	if err == nil {
-		return nil, fmt.Errorf("trace event %s/%s: %w", args.Group, eventName, os.ErrExist)
-	}
-	if err != nil && !errors.Is(err, os.ErrNotExist) {
-		return nil, fmt.Errorf("checking trace event %s/%s: %w", args.Group, eventName, err)
-	}
-
-	// Open the kprobe_events file in tracefs.
-	f, err := args.Type.eventsFile()
-	if err != nil {
-		return nil, err
-	}
-	defer f.Close()
-
-	var pe, token string
-	switch args.Type {
-	case Kprobe:
-		// The kprobe_events syntax is as follows (see Documentation/trace/kprobetrace.txt):
-		// p[:[GRP/]EVENT] [MOD:]SYM[+offs]|MEMADDR [FETCHARGS] : Set a probe
-		// r[MAXACTIVE][:[GRP/]EVENT] [MOD:]SYM[+0] [FETCHARGS] : Set a return probe
-		// -:[GRP/]EVENT                                        : Clear a probe
-		//
-		// Some examples:
-		// r:ebpf_1234/r_my_kretprobe nf_conntrack_destroy
-		// p:ebpf_5678/p_my_kprobe __x64_sys_execve
-		//
-		// Leaving the kretprobe's MAXACTIVE set to 0 (or absent) will make the
-		// kernel default to NR_CPUS. This is desired in most eBPF cases since
-		// subsampling or rate limiting logic can be more accurately implemented in
-		// the eBPF program itself.
-		// See Documentation/kprobes.txt for more details.
-		if args.RetprobeMaxActive != 0 && !args.Ret {
-			return nil, ErrInvalidMaxActive
-		}
-		token = KprobeToken(args)
-		pe = fmt.Sprintf("%s:%s/%s %s", probePrefix(args.Ret, args.RetprobeMaxActive), args.Group, eventName, token)
-	case Uprobe:
-		// The uprobe_events syntax is as follows:
-		// p[:[GRP/]EVENT] PATH:OFFSET [FETCHARGS] : Set a probe
-		// r[:[GRP/]EVENT] PATH:OFFSET [FETCHARGS] : Set a return probe
-		// -:[GRP/]EVENT                           : Clear a probe
-		//
-		// Some examples:
-		// r:ebpf_1234/readline /bin/bash:0x12345
-		// p:ebpf_5678/main_mySymbol /bin/mybin:0x12345(0x123)
-		//
-		// See Documentation/trace/uprobetracer.txt for more details.
-		if args.RetprobeMaxActive != 0 {
-			return nil, ErrInvalidMaxActive
-		}
-		token = UprobeToken(args)
-		pe = fmt.Sprintf("%s:%s/%s %s", probePrefix(args.Ret, 0), args.Group, eventName, token)
-	}
-	_, err = f.WriteString(pe)
-
-	// Since commit 97c753e62e6c, ENOENT is correctly returned instead of EINVAL
-	// when trying to create a retprobe for a missing symbol.
-	if errors.Is(err, os.ErrNotExist) {
-		return nil, fmt.Errorf("token %s: not found: %w", token, err)
-	}
-	// Since commit ab105a4fb894, EILSEQ is returned when a kprobe sym+offset is resolved
-	// to an invalid insn boundary. The exact conditions that trigger this error are
-	// arch specific however.
-	if errors.Is(err, syscall.EILSEQ) {
-		return nil, fmt.Errorf("token %s: bad insn boundary: %w", token, os.ErrNotExist)
-	}
-	// ERANGE is returned when the `SYM[+offs]` token is too big and cannot
-	// be resolved.
-	if errors.Is(err, syscall.ERANGE) {
-		return nil, fmt.Errorf("token %s: offset too big: %w", token, os.ErrNotExist)
-	}
-
-	if err != nil {
-		return nil, fmt.Errorf("token %s: writing '%s': %w", token, pe, err)
-	}
-
-	// Get the newly-created trace event's id.
-	tid, err := EventID(args.Group, eventName)
-	if args.RetprobeMaxActive != 0 && errors.Is(err, os.ErrNotExist) {
-		// Kernels < 4.12 don't support maxactive and therefore auto generate
-		// group and event names from the symbol and offset. The symbol is used
-		// without any sanitization.
-		// See https://elixir.bootlin.com/linux/v4.10/source/kernel/trace/trace_kprobe.c#L712
-		event := fmt.Sprintf("kprobes/r_%s_%d", args.Symbol, args.Offset)
-		if err := removeEvent(args.Type, event); err != nil {
-			return nil, fmt.Errorf("failed to remove spurious maxactive event: %s", err)
-		}
-		return nil, fmt.Errorf("create trace event with non-default maxactive: %w", internal.ErrNotSupported)
-	}
-	if err != nil {
-		return nil, fmt.Errorf("get trace event id: %w", err)
-	}
-
-	evt := &Event{args.Type, args.Group, eventName, tid}
-	runtime.SetFinalizer(evt, (*Event).Close)
-	return evt, nil
-}
-
-// Close removes the event from tracefs.
-//
-// Returns os.ErrClosed if the event has already been closed before.
-func (evt *Event) Close() error {
-	if evt.id == 0 {
-		return os.ErrClosed
-	}
-
-	evt.id = 0
-	runtime.SetFinalizer(evt, nil)
-	pe := fmt.Sprintf("%s/%s", evt.group, evt.name)
-	return removeEvent(evt.typ, pe)
-}
-
-func removeEvent(typ ProbeType, pe string) error {
-	f, err := typ.eventsFile()
-	if err != nil {
-		return err
-	}
-	defer f.Close()
-
-	// See [k,u]probe_events syntax above. The probe type does not need to be specified
-	// for removals.
-	if _, err = f.WriteString("-:" + pe); err != nil {
-		return fmt.Errorf("remove event %q from %s: %w", pe, f.Name(), err)
-	}
-
-	return nil
-}
-
-// ID returns the tracefs ID associated with the event.
-func (evt *Event) ID() uint64 {
-	return evt.id
-}
-
-// Group returns the tracefs group used by the event.
-func (evt *Event) Group() string {
-	return evt.group
-}
-
-// KprobeToken creates the SYM[+offs] token for the tracefs api.
-func KprobeToken(args ProbeArgs) string {
-	po := args.Symbol
-
-	if args.Offset != 0 {
-		po += fmt.Sprintf("+%#x", args.Offset)
-	}
-
-	return po
-}
diff --git a/vendor/github.com/cilium/ebpf/internal/tracefs/probetype_string.go b/vendor/github.com/cilium/ebpf/internal/tracefs/probetype_string.go
deleted file mode 100644
index 87cb0a059..000000000
--- a/vendor/github.com/cilium/ebpf/internal/tracefs/probetype_string.go
+++ /dev/null
@@ -1,24 +0,0 @@
-// Code generated by "stringer -type=ProbeType -linecomment"; DO NOT EDIT.
-
-package tracefs
-
-import "strconv"
-
-func _() {
-	// An "invalid array index" compiler error signifies that the constant values have changed.
-	// Re-run the stringer command to generate them again.
-	var x [1]struct{}
-	_ = x[Kprobe-0]
-	_ = x[Uprobe-1]
-}
-
-const _ProbeType_name = "kprobeuprobe"
-
-var _ProbeType_index = [...]uint8{0, 6, 12}
-
-func (i ProbeType) String() string {
-	if i >= ProbeType(len(_ProbeType_index)-1) {
-		return "ProbeType(" + strconv.FormatInt(int64(i), 10) + ")"
-	}
-	return _ProbeType_name[_ProbeType_index[i]:_ProbeType_index[i+1]]
-}
diff --git a/vendor/github.com/cilium/ebpf/internal/tracefs/uprobe.go b/vendor/github.com/cilium/ebpf/internal/tracefs/uprobe.go
deleted file mode 100644
index 994f31260..000000000
--- a/vendor/github.com/cilium/ebpf/internal/tracefs/uprobe.go
+++ /dev/null
@@ -1,16 +0,0 @@
-package tracefs
-
-import "fmt"
-
-// UprobeToken creates the PATH:OFFSET(REF_CTR_OFFSET) token for the tracefs api.
-func UprobeToken(args ProbeArgs) string {
-	po := fmt.Sprintf("%s:%#x", args.Path, args.Offset)
-
-	if args.RefCtrOffset != 0 {
-		// This is not documented in Documentation/trace/uprobetracer.txt.
-		// elixir.bootlin.com/linux/v5.15-rc7/source/kernel/trace/trace.c#L5564
-		po += fmt.Sprintf("(%#x)", args.RefCtrOffset)
-	}
-
-	return po
-}
diff --git a/vendor/github.com/cilium/ebpf/internal/unix/doc.go b/vendor/github.com/cilium/ebpf/internal/unix/doc.go
deleted file mode 100644
index d168d36f1..000000000
--- a/vendor/github.com/cilium/ebpf/internal/unix/doc.go
+++ /dev/null
@@ -1,11 +0,0 @@
-// Package unix re-exports Linux specific parts of golang.org/x/sys/unix.
-//
-// It avoids breaking compilation on other OS by providing stubs as follows:
-//   - Invoking a function always returns an error.
-//   - Errnos have distinct, non-zero values.
-//   - Constants have distinct but meaningless values.
-//   - Types use the same names for members, but may or may not follow the
-//     Linux layout.
-package unix
-
-// Note: please don't add any custom API to this package. Use internal/sys instead.
diff --git a/vendor/github.com/cilium/ebpf/internal/unix/types_linux.go b/vendor/github.com/cilium/ebpf/internal/unix/types_linux.go
deleted file mode 100644
index 7c9705919..000000000
--- a/vendor/github.com/cilium/ebpf/internal/unix/types_linux.go
+++ /dev/null
@@ -1,202 +0,0 @@
-//go:build linux
-
-package unix
-
-import (
-	"syscall"
-
-	linux "golang.org/x/sys/unix"
-)
-
-const (
-	ENOENT     = linux.ENOENT
-	EEXIST     = linux.EEXIST
-	EAGAIN     = linux.EAGAIN
-	ENOSPC     = linux.ENOSPC
-	EINVAL     = linux.EINVAL
-	EPOLLIN    = linux.EPOLLIN
-	EINTR      = linux.EINTR
-	EPERM      = linux.EPERM
-	ESRCH      = linux.ESRCH
-	ENODEV     = linux.ENODEV
-	EBADF      = linux.EBADF
-	E2BIG      = linux.E2BIG
-	EFAULT     = linux.EFAULT
-	EACCES     = linux.EACCES
-	EILSEQ     = linux.EILSEQ
-	EOPNOTSUPP = linux.EOPNOTSUPP
-)
-
-const (
-	BPF_F_NO_PREALLOC         = linux.BPF_F_NO_PREALLOC
-	BPF_F_NUMA_NODE           = linux.BPF_F_NUMA_NODE
-	BPF_F_RDONLY              = linux.BPF_F_RDONLY
-	BPF_F_WRONLY              = linux.BPF_F_WRONLY
-	BPF_F_RDONLY_PROG         = linux.BPF_F_RDONLY_PROG
-	BPF_F_WRONLY_PROG         = linux.BPF_F_WRONLY_PROG
-	BPF_F_SLEEPABLE           = linux.BPF_F_SLEEPABLE
-	BPF_F_XDP_HAS_FRAGS       = linux.BPF_F_XDP_HAS_FRAGS
-	BPF_F_MMAPABLE            = linux.BPF_F_MMAPABLE
-	BPF_F_INNER_MAP           = linux.BPF_F_INNER_MAP
-	BPF_F_KPROBE_MULTI_RETURN = linux.BPF_F_KPROBE_MULTI_RETURN
-	BPF_OBJ_NAME_LEN          = linux.BPF_OBJ_NAME_LEN
-	BPF_TAG_SIZE              = linux.BPF_TAG_SIZE
-	BPF_RINGBUF_BUSY_BIT      = linux.BPF_RINGBUF_BUSY_BIT
-	BPF_RINGBUF_DISCARD_BIT   = linux.BPF_RINGBUF_DISCARD_BIT
-	BPF_RINGBUF_HDR_SZ        = linux.BPF_RINGBUF_HDR_SZ
-	SYS_BPF                   = linux.SYS_BPF
-	F_DUPFD_CLOEXEC           = linux.F_DUPFD_CLOEXEC
-	EPOLL_CTL_ADD             = linux.EPOLL_CTL_ADD
-	EPOLL_CLOEXEC             = linux.EPOLL_CLOEXEC
-	O_CLOEXEC                 = linux.O_CLOEXEC
-	O_NONBLOCK                = linux.O_NONBLOCK
-	PROT_NONE                 = linux.PROT_NONE
-	PROT_READ                 = linux.PROT_READ
-	PROT_WRITE                = linux.PROT_WRITE
-	MAP_ANON                  = linux.MAP_ANON
-	MAP_SHARED                = linux.MAP_SHARED
-	MAP_PRIVATE               = linux.MAP_PRIVATE
-	PERF_ATTR_SIZE_VER1       = linux.PERF_ATTR_SIZE_VER1
-	PERF_TYPE_SOFTWARE        = linux.PERF_TYPE_SOFTWARE
-	PERF_TYPE_TRACEPOINT      = linux.PERF_TYPE_TRACEPOINT
-	PERF_COUNT_SW_BPF_OUTPUT  = linux.PERF_COUNT_SW_BPF_OUTPUT
-	PERF_EVENT_IOC_DISABLE    = linux.PERF_EVENT_IOC_DISABLE
-	PERF_EVENT_IOC_ENABLE     = linux.PERF_EVENT_IOC_ENABLE
-	PERF_EVENT_IOC_SET_BPF    = linux.PERF_EVENT_IOC_SET_BPF
-	PerfBitWatermark          = linux.PerfBitWatermark
-	PerfBitWriteBackward      = linux.PerfBitWriteBackward
-	PERF_SAMPLE_RAW           = linux.PERF_SAMPLE_RAW
-	PERF_FLAG_FD_CLOEXEC      = linux.PERF_FLAG_FD_CLOEXEC
-	RLIM_INFINITY             = linux.RLIM_INFINITY
-	RLIMIT_MEMLOCK            = linux.RLIMIT_MEMLOCK
-	BPF_STATS_RUN_TIME        = linux.BPF_STATS_RUN_TIME
-	PERF_RECORD_LOST          = linux.PERF_RECORD_LOST
-	PERF_RECORD_SAMPLE        = linux.PERF_RECORD_SAMPLE
-	AT_FDCWD                  = linux.AT_FDCWD
-	RENAME_NOREPLACE          = linux.RENAME_NOREPLACE
-	SO_ATTACH_BPF             = linux.SO_ATTACH_BPF
-	SO_DETACH_BPF             = linux.SO_DETACH_BPF
-	SOL_SOCKET                = linux.SOL_SOCKET
-	SIGPROF                   = linux.SIGPROF
-	SIG_BLOCK                 = linux.SIG_BLOCK
-	SIG_UNBLOCK               = linux.SIG_UNBLOCK
-	EM_NONE                   = linux.EM_NONE
-	EM_BPF                    = linux.EM_BPF
-	BPF_FS_MAGIC              = linux.BPF_FS_MAGIC
-	TRACEFS_MAGIC             = linux.TRACEFS_MAGIC
-	DEBUGFS_MAGIC             = linux.DEBUGFS_MAGIC
-)
-
-type Statfs_t = linux.Statfs_t
-type Stat_t = linux.Stat_t
-type Rlimit = linux.Rlimit
-type Signal = linux.Signal
-type Sigset_t = linux.Sigset_t
-type PerfEventMmapPage = linux.PerfEventMmapPage
-type EpollEvent = linux.EpollEvent
-type PerfEventAttr = linux.PerfEventAttr
-type Utsname = linux.Utsname
-
-func Syscall(trap, a1, a2, a3 uintptr) (r1, r2 uintptr, err syscall.Errno) {
-	return linux.Syscall(trap, a1, a2, a3)
-}
-
-func PthreadSigmask(how int, set, oldset *Sigset_t) error {
-	return linux.PthreadSigmask(how, set, oldset)
-}
-
-func FcntlInt(fd uintptr, cmd, arg int) (int, error) {
-	return linux.FcntlInt(fd, cmd, arg)
-}
-
-func IoctlSetInt(fd int, req uint, value int) error {
-	return linux.IoctlSetInt(fd, req, value)
-}
-
-func Statfs(path string, buf *Statfs_t) (err error) {
-	return linux.Statfs(path, buf)
-}
-
-func Close(fd int) (err error) {
-	return linux.Close(fd)
-}
-
-func EpollWait(epfd int, events []EpollEvent, msec int) (n int, err error) {
-	return linux.EpollWait(epfd, events, msec)
-}
-
-func EpollCtl(epfd int, op int, fd int, event *EpollEvent) (err error) {
-	return linux.EpollCtl(epfd, op, fd, event)
-}
-
-func Eventfd(initval uint, flags int) (fd int, err error) {
-	return linux.Eventfd(initval, flags)
-}
-
-func Write(fd int, p []byte) (n int, err error) {
-	return linux.Write(fd, p)
-}
-
-func EpollCreate1(flag int) (fd int, err error) {
-	return linux.EpollCreate1(flag)
-}
-
-func SetNonblock(fd int, nonblocking bool) (err error) {
-	return linux.SetNonblock(fd, nonblocking)
-}
-
-func Mmap(fd int, offset int64, length int, prot int, flags int) (data []byte, err error) {
-	return linux.Mmap(fd, offset, length, prot, flags)
-}
-
-func Munmap(b []byte) (err error) {
-	return linux.Munmap(b)
-}
-
-func PerfEventOpen(attr *PerfEventAttr, pid int, cpu int, groupFd int, flags int) (fd int, err error) {
-	return linux.PerfEventOpen(attr, pid, cpu, groupFd, flags)
-}
-
-func Uname(buf *Utsname) (err error) {
-	return linux.Uname(buf)
-}
-
-func Getpid() int {
-	return linux.Getpid()
-}
-
-func Gettid() int {
-	return linux.Gettid()
-}
-
-func Tgkill(tgid int, tid int, sig syscall.Signal) (err error) {
-	return linux.Tgkill(tgid, tid, sig)
-}
-
-func BytePtrFromString(s string) (*byte, error) {
-	return linux.BytePtrFromString(s)
-}
-
-func ByteSliceToString(s []byte) string {
-	return linux.ByteSliceToString(s)
-}
-
-func Renameat2(olddirfd int, oldpath string, newdirfd int, newpath string, flags uint) error {
-	return linux.Renameat2(olddirfd, oldpath, newdirfd, newpath, flags)
-}
-
-func Prlimit(pid, resource int, new, old *Rlimit) error {
-	return linux.Prlimit(pid, resource, new, old)
-}
-
-func Open(path string, mode int, perm uint32) (int, error) {
-	return linux.Open(path, mode, perm)
-}
-
-func Fstat(fd int, stat *Stat_t) error {
-	return linux.Fstat(fd, stat)
-}
-
-func SetsockoptInt(fd, level, opt, value int) error {
-	return linux.SetsockoptInt(fd, level, opt, value)
-}
diff --git a/vendor/github.com/cilium/ebpf/internal/unix/types_other.go b/vendor/github.com/cilium/ebpf/internal/unix/types_other.go
deleted file mode 100644
index 5e86b5052..000000000
--- a/vendor/github.com/cilium/ebpf/internal/unix/types_other.go
+++ /dev/null
@@ -1,294 +0,0 @@
-//go:build !linux
-
-package unix
-
-import (
-	"fmt"
-	"runtime"
-	"syscall"
-)
-
-var errNonLinux = fmt.Errorf("unsupported platform %s/%s", runtime.GOOS, runtime.GOARCH)
-
-// Errnos are distinct and non-zero.
-const (
-	ENOENT syscall.Errno = iota + 1
-	EEXIST
-	EAGAIN
-	ENOSPC
-	EINVAL
-	EINTR
-	EPERM
-	ESRCH
-	ENODEV
-	EBADF
-	E2BIG
-	EFAULT
-	EACCES
-	EILSEQ
-	EOPNOTSUPP
-)
-
-// Constants are distinct to avoid breaking switch statements.
-const (
-	BPF_F_NO_PREALLOC = iota
-	BPF_F_NUMA_NODE
-	BPF_F_RDONLY
-	BPF_F_WRONLY
-	BPF_F_RDONLY_PROG
-	BPF_F_WRONLY_PROG
-	BPF_F_SLEEPABLE
-	BPF_F_MMAPABLE
-	BPF_F_INNER_MAP
-	BPF_F_KPROBE_MULTI_RETURN
-	BPF_F_XDP_HAS_FRAGS
-	BPF_OBJ_NAME_LEN
-	BPF_TAG_SIZE
-	BPF_RINGBUF_BUSY_BIT
-	BPF_RINGBUF_DISCARD_BIT
-	BPF_RINGBUF_HDR_SZ
-	SYS_BPF
-	F_DUPFD_CLOEXEC
-	EPOLLIN
-	EPOLL_CTL_ADD
-	EPOLL_CLOEXEC
-	O_CLOEXEC
-	O_NONBLOCK
-	PROT_NONE
-	PROT_READ
-	PROT_WRITE
-	MAP_ANON
-	MAP_SHARED
-	MAP_PRIVATE
-	PERF_ATTR_SIZE_VER1
-	PERF_TYPE_SOFTWARE
-	PERF_TYPE_TRACEPOINT
-	PERF_COUNT_SW_BPF_OUTPUT
-	PERF_EVENT_IOC_DISABLE
-	PERF_EVENT_IOC_ENABLE
-	PERF_EVENT_IOC_SET_BPF
-	PerfBitWatermark
-	PerfBitWriteBackward
-	PERF_SAMPLE_RAW
-	PERF_FLAG_FD_CLOEXEC
-	RLIM_INFINITY
-	RLIMIT_MEMLOCK
-	BPF_STATS_RUN_TIME
-	PERF_RECORD_LOST
-	PERF_RECORD_SAMPLE
-	AT_FDCWD
-	RENAME_NOREPLACE
-	SO_ATTACH_BPF
-	SO_DETACH_BPF
-	SOL_SOCKET
-	SIGPROF
-	SIG_BLOCK
-	SIG_UNBLOCK
-	EM_NONE
-	EM_BPF
-	BPF_FS_MAGIC
-	TRACEFS_MAGIC
-	DEBUGFS_MAGIC
-)
-
-type Statfs_t struct {
-	Type    int64
-	Bsize   int64
-	Blocks  uint64
-	Bfree   uint64
-	Bavail  uint64
-	Files   uint64
-	Ffree   uint64
-	Fsid    [2]int32
-	Namelen int64
-	Frsize  int64
-	Flags   int64
-	Spare   [4]int64
-}
-
-type Stat_t struct {
-	Dev     uint64
-	Ino     uint64
-	Nlink   uint64
-	Mode    uint32
-	Uid     uint32
-	Gid     uint32
-	_       int32
-	Rdev    uint64
-	Size    int64
-	Blksize int64
-	Blocks  int64
-}
-
-type Rlimit struct {
-	Cur uint64
-	Max uint64
-}
-
-type Signal int
-
-type Sigset_t struct {
-	Val [4]uint64
-}
-
-func Syscall(trap, a1, a2, a3 uintptr) (r1, r2 uintptr, err syscall.Errno) {
-	return 0, 0, syscall.ENOTSUP
-}
-
-func PthreadSigmask(how int, set, oldset *Sigset_t) error {
-	return errNonLinux
-}
-
-func FcntlInt(fd uintptr, cmd, arg int) (int, error) {
-	return -1, errNonLinux
-}
-
-func IoctlSetInt(fd int, req uint, value int) error {
-	return errNonLinux
-}
-
-func Statfs(path string, buf *Statfs_t) error {
-	return errNonLinux
-}
-
-func Close(fd int) (err error) {
-	return errNonLinux
-}
-
-type EpollEvent struct {
-	Events uint32
-	Fd     int32
-	Pad    int32
-}
-
-func EpollWait(epfd int, events []EpollEvent, msec int) (n int, err error) {
-	return 0, errNonLinux
-}
-
-func EpollCtl(epfd int, op int, fd int, event *EpollEvent) (err error) {
-	return errNonLinux
-}
-
-func Eventfd(initval uint, flags int) (fd int, err error) {
-	return 0, errNonLinux
-}
-
-func Write(fd int, p []byte) (n int, err error) {
-	return 0, errNonLinux
-}
-
-func EpollCreate1(flag int) (fd int, err error) {
-	return 0, errNonLinux
-}
-
-type PerfEventMmapPage struct {
-	Version        uint32
-	Compat_version uint32
-	Lock           uint32
-	Index          uint32
-	Offset         int64
-	Time_enabled   uint64
-	Time_running   uint64
-	Capabilities   uint64
-	Pmc_width      uint16
-	Time_shift     uint16
-	Time_mult      uint32
-	Time_offset    uint64
-	Time_zero      uint64
-	Size           uint32
-
-	Data_head   uint64
-	Data_tail   uint64
-	Data_offset uint64
-	Data_size   uint64
-	Aux_head    uint64
-	Aux_tail    uint64
-	Aux_offset  uint64
-	Aux_size    uint64
-}
-
-func SetNonblock(fd int, nonblocking bool) (err error) {
-	return errNonLinux
-}
-
-func Mmap(fd int, offset int64, length int, prot int, flags int) (data []byte, err error) {
-	return []byte{}, errNonLinux
-}
-
-func Munmap(b []byte) (err error) {
-	return errNonLinux
-}
-
-type PerfEventAttr struct {
-	Type               uint32
-	Size               uint32
-	Config             uint64
-	Sample             uint64
-	Sample_type        uint64
-	Read_format        uint64
-	Bits               uint64
-	Wakeup             uint32
-	Bp_type            uint32
-	Ext1               uint64
-	Ext2               uint64
-	Branch_sample_type uint64
-	Sample_regs_user   uint64
-	Sample_stack_user  uint32
-	Clockid            int32
-	Sample_regs_intr   uint64
-	Aux_watermark      uint32
-	Sample_max_stack   uint16
-}
-
-func PerfEventOpen(attr *PerfEventAttr, pid int, cpu int, groupFd int, flags int) (fd int, err error) {
-	return 0, errNonLinux
-}
-
-type Utsname struct {
-	Release [65]byte
-	Version [65]byte
-}
-
-func Uname(buf *Utsname) (err error) {
-	return errNonLinux
-}
-
-func Getpid() int {
-	return -1
-}
-
-func Gettid() int {
-	return -1
-}
-
-func Tgkill(tgid int, tid int, sig syscall.Signal) (err error) {
-	return errNonLinux
-}
-
-func BytePtrFromString(s string) (*byte, error) {
-	return nil, errNonLinux
-}
-
-func ByteSliceToString(s []byte) string {
-	return ""
-}
-
-func Renameat2(olddirfd int, oldpath string, newdirfd int, newpath string, flags uint) error {
-	return errNonLinux
-}
-
-func Prlimit(pid, resource int, new, old *Rlimit) error {
-	return errNonLinux
-}
-
-func Open(path string, mode int, perm uint32) (int, error) {
-	return -1, errNonLinux
-}
-
-func Fstat(fd int, stat *Stat_t) error {
-	return errNonLinux
-}
-
-func SetsockoptInt(fd, level, opt, value int) error {
-	return errNonLinux
-}
diff --git a/vendor/github.com/cilium/ebpf/internal/vdso.go b/vendor/github.com/cilium/ebpf/internal/vdso.go
deleted file mode 100644
index 10e639bf0..000000000
--- a/vendor/github.com/cilium/ebpf/internal/vdso.go
+++ /dev/null
@@ -1,153 +0,0 @@
-package internal
-
-import (
-	"debug/elf"
-	"encoding/binary"
-	"errors"
-	"fmt"
-	"io"
-	"math"
-	"os"
-
-	"github.com/cilium/ebpf/internal/unix"
-)
-
-var (
-	errAuxvNoVDSO = errors.New("no vdso address found in auxv")
-)
-
-// vdsoVersion returns the LINUX_VERSION_CODE embedded in the vDSO library
-// linked into the current process image.
-func vdsoVersion() (uint32, error) {
-	// Read data from the auxiliary vector, which is normally passed directly
-	// to the process. Go does not expose that data, so we must read it from procfs.
-	// https://man7.org/linux/man-pages/man3/getauxval.3.html
-	av, err := os.Open("/proc/self/auxv")
-	if errors.Is(err, unix.EACCES) {
-		return 0, fmt.Errorf("opening auxv: %w (process may not be dumpable due to file capabilities)", err)
-	}
-	if err != nil {
-		return 0, fmt.Errorf("opening auxv: %w", err)
-	}
-	defer av.Close()
-
-	vdsoAddr, err := vdsoMemoryAddress(av)
-	if err != nil {
-		return 0, fmt.Errorf("finding vDSO memory address: %w", err)
-	}
-
-	// Use /proc/self/mem rather than unsafe.Pointer tricks.
-	mem, err := os.Open("/proc/self/mem")
-	if err != nil {
-		return 0, fmt.Errorf("opening mem: %w", err)
-	}
-	defer mem.Close()
-
-	// Open ELF at provided memory address, as offset into /proc/self/mem.
-	c, err := vdsoLinuxVersionCode(io.NewSectionReader(mem, int64(vdsoAddr), math.MaxInt64))
-	if err != nil {
-		return 0, fmt.Errorf("reading linux version code: %w", err)
-	}
-
-	return c, nil
-}
-
-// vdsoMemoryAddress returns the memory address of the vDSO library
-// linked into the current process image. r is an io.Reader into an auxv blob.
-func vdsoMemoryAddress(r io.Reader) (uint64, error) {
-	const (
-		_AT_NULL         = 0  // End of vector
-		_AT_SYSINFO_EHDR = 33 // Offset to vDSO blob in process image
-	)
-
-	// Loop through all tag/value pairs in auxv until we find `AT_SYSINFO_EHDR`,
-	// the address of a page containing the virtual Dynamic Shared Object (vDSO).
-	aux := struct{ Tag, Val uint64 }{}
-	for {
-		if err := binary.Read(r, NativeEndian, &aux); err != nil {
-			return 0, fmt.Errorf("reading auxv entry: %w", err)
-		}
-
-		switch aux.Tag {
-		case _AT_SYSINFO_EHDR:
-			if aux.Val != 0 {
-				return aux.Val, nil
-			}
-			return 0, fmt.Errorf("invalid vDSO address in auxv")
-		// _AT_NULL is always the last tag/val pair in the aux vector
-		// and can be treated like EOF.
-		case _AT_NULL:
-			return 0, errAuxvNoVDSO
-		}
-	}
-}
-
-// format described at https://www.man7.org/linux/man-pages/man5/elf.5.html in section 'Notes (Nhdr)'
-type elfNoteHeader struct {
-	NameSize int32
-	DescSize int32
-	Type     int32
-}
-
-// vdsoLinuxVersionCode returns the LINUX_VERSION_CODE embedded in
-// the ELF notes section of the binary provided by the reader.
-func vdsoLinuxVersionCode(r io.ReaderAt) (uint32, error) {
-	hdr, err := NewSafeELFFile(r)
-	if err != nil {
-		return 0, fmt.Errorf("reading vDSO ELF: %w", err)
-	}
-
-	sections := hdr.SectionsByType(elf.SHT_NOTE)
-	if len(sections) == 0 {
-		return 0, fmt.Errorf("no note section found in vDSO ELF")
-	}
-
-	for _, sec := range sections {
-		sr := sec.Open()
-		var n elfNoteHeader
-
-		// Read notes until we find one named 'Linux'.
-		for {
-			if err := binary.Read(sr, hdr.ByteOrder, &n); err != nil {
-				if errors.Is(err, io.EOF) {
-					// We looked at all the notes in this section
-					break
-				}
-				return 0, fmt.Errorf("reading note header: %w", err)
-			}
-
-			// If a note name is defined, it follows the note header.
-			var name string
-			if n.NameSize > 0 {
-				// Read the note name, aligned to 4 bytes.
-				buf := make([]byte, Align(n.NameSize, 4))
-				if err := binary.Read(sr, hdr.ByteOrder, &buf); err != nil {
-					return 0, fmt.Errorf("reading note name: %w", err)
-				}
-
-				// Read nul-terminated string.
-				name = unix.ByteSliceToString(buf[:n.NameSize])
-			}
-
-			// If a note descriptor is defined, it follows the name.
-			// It is possible for a note to have a descriptor but not a name.
-			if n.DescSize > 0 {
-				// LINUX_VERSION_CODE is a uint32 value.
-				if name == "Linux" && n.DescSize == 4 && n.Type == 0 {
-					var version uint32
-					if err := binary.Read(sr, hdr.ByteOrder, &version); err != nil {
-						return 0, fmt.Errorf("reading note descriptor: %w", err)
-					}
-					return version, nil
-				}
-
-				// Discard the note descriptor if it exists but we're not interested in it.
-				if _, err := io.CopyN(io.Discard, sr, int64(Align(n.DescSize, 4))); err != nil {
-					return 0, err
-				}
-			}
-		}
-	}
-
-	return 0, fmt.Errorf("no Linux note in ELF")
-}
diff --git a/vendor/github.com/cilium/ebpf/internal/version.go b/vendor/github.com/cilium/ebpf/internal/version.go
deleted file mode 100644
index 9b17ffb44..000000000
--- a/vendor/github.com/cilium/ebpf/internal/version.go
+++ /dev/null
@@ -1,106 +0,0 @@
-package internal
-
-import (
-	"fmt"
-
-	"github.com/cilium/ebpf/internal/unix"
-)
-
-const (
-	// Version constant used in ELF binaries indicating that the loader needs to
-	// substitute the eBPF program's version with the value of the kernel's
-	// KERNEL_VERSION compile-time macro. Used for compatibility with BCC, gobpf
-	// and RedSift.
-	MagicKernelVersion = 0xFFFFFFFE
-)
-
-// A Version in the form Major.Minor.Patch.
-type Version [3]uint16
-
-// NewVersion creates a version from a string like "Major.Minor.Patch".
-//
-// Patch is optional.
-func NewVersion(ver string) (Version, error) {
-	var major, minor, patch uint16
-	n, _ := fmt.Sscanf(ver, "%d.%d.%d", &major, &minor, &patch)
-	if n < 2 {
-		return Version{}, fmt.Errorf("invalid version: %s", ver)
-	}
-	return Version{major, minor, patch}, nil
-}
-
-// NewVersionFromCode creates a version from a LINUX_VERSION_CODE.
-func NewVersionFromCode(code uint32) Version {
-	return Version{
-		uint16(uint8(code >> 16)),
-		uint16(uint8(code >> 8)),
-		uint16(uint8(code)),
-	}
-}
-
-func (v Version) String() string {
-	if v[2] == 0 {
-		return fmt.Sprintf("v%d.%d", v[0], v[1])
-	}
-	return fmt.Sprintf("v%d.%d.%d", v[0], v[1], v[2])
-}
-
-// Less returns true if the version is less than another version.
-func (v Version) Less(other Version) bool {
-	for i, a := range v {
-		if a == other[i] {
-			continue
-		}
-		return a < other[i]
-	}
-	return false
-}
-
-// Unspecified returns true if the version is all zero.
-func (v Version) Unspecified() bool {
-	return v[0] == 0 && v[1] == 0 && v[2] == 0
-}
-
-// Kernel implements the kernel's KERNEL_VERSION macro from linux/version.h.
-// It represents the kernel version and patch level as a single value.
-func (v Version) Kernel() uint32 {
-
-	// Kernels 4.4 and 4.9 have their SUBLEVEL clamped to 255 to avoid
-	// overflowing into PATCHLEVEL.
-	// See kernel commit 9b82f13e7ef3 ("kbuild: clamp SUBLEVEL to 255").
-	s := v[2]
-	if s > 255 {
-		s = 255
-	}
-
-	// Truncate members to uint8 to prevent them from spilling over into
-	// each other when overflowing 8 bits.
-	return uint32(uint8(v[0]))<<16 | uint32(uint8(v[1]))<<8 | uint32(uint8(s))
-}
-
-// KernelVersion returns the version of the currently running kernel.
-var KernelVersion = Memoize(func() (Version, error) {
-	return detectKernelVersion()
-})
-
-// detectKernelVersion returns the version of the running kernel.
-func detectKernelVersion() (Version, error) {
-	vc, err := vdsoVersion()
-	if err != nil {
-		return Version{}, err
-	}
-	return NewVersionFromCode(vc), nil
-}
-
-// KernelRelease returns the release string of the running kernel.
-// Its format depends on the Linux distribution and corresponds to directory
-// names in /lib/modules by convention. Some examples are 5.15.17-1-lts and
-// 4.19.0-16-amd64.
-func KernelRelease() (string, error) {
-	var uname unix.Utsname
-	if err := unix.Uname(&uname); err != nil {
-		return "", fmt.Errorf("uname failed: %w", err)
-	}
-
-	return unix.ByteSliceToString(uname.Release[:]), nil
-}
diff --git a/vendor/github.com/cilium/ebpf/link/cgroup.go b/vendor/github.com/cilium/ebpf/link/cgroup.go
deleted file mode 100644
index 58e85fe9d..000000000
--- a/vendor/github.com/cilium/ebpf/link/cgroup.go
+++ /dev/null
@@ -1,190 +0,0 @@
-package link
-
-import (
-	"errors"
-	"fmt"
-	"os"
-
-	"github.com/cilium/ebpf"
-)
-
-type cgroupAttachFlags uint32
-
-const (
-	// Allow programs attached to sub-cgroups to override the verdict of this
-	// program.
-	flagAllowOverride cgroupAttachFlags = 1 << iota
-	// Allow attaching multiple programs to the cgroup. Only works if the cgroup
-	// has zero or more programs attached using the Multi flag. Implies override.
-	flagAllowMulti
-	// Set automatically by progAttachCgroup.Update(). Used for updating a
-	// specific given program attached in multi-mode.
-	flagReplace
-)
-
-type CgroupOptions struct {
-	// Path to a cgroupv2 folder.
-	Path string
-	// One of the AttachCgroup* constants
-	Attach ebpf.AttachType
-	// Program must be of type CGroup*, and the attach type must match Attach.
-	Program *ebpf.Program
-}
-
-// AttachCgroup links a BPF program to a cgroup.
-//
-// If the running kernel doesn't support bpf_link, attempts to emulate its
-// semantics using the legacy PROG_ATTACH mechanism. If bpf_link is not
-// available, the returned [Link] will not support pinning to bpffs.
-//
-// If you need more control over attachment flags or the attachment mechanism
-// used, look at [RawAttachProgram] and [AttachRawLink] instead.
-func AttachCgroup(opts CgroupOptions) (cg Link, err error) {
-	cgroup, err := os.Open(opts.Path)
-	if err != nil {
-		return nil, fmt.Errorf("can't open cgroup: %s", err)
-	}
-	defer func() {
-		if _, ok := cg.(*progAttachCgroup); ok {
-			// Skip closing the cgroup handle if we return a valid progAttachCgroup,
-			// where the handle is retained to implement Update().
-			return
-		}
-		cgroup.Close()
-	}()
-
-	cg, err = newLinkCgroup(cgroup, opts.Attach, opts.Program)
-	if err == nil {
-		return cg, nil
-	}
-
-	if errors.Is(err, ErrNotSupported) {
-		cg, err = newProgAttachCgroup(cgroup, opts.Attach, opts.Program, flagAllowMulti)
-	}
-	if errors.Is(err, ErrNotSupported) {
-		cg, err = newProgAttachCgroup(cgroup, opts.Attach, opts.Program, flagAllowOverride)
-	}
-	if err != nil {
-		return nil, err
-	}
-
-	return cg, nil
-}
-
-type progAttachCgroup struct {
-	cgroup     *os.File
-	current    *ebpf.Program
-	attachType ebpf.AttachType
-	flags      cgroupAttachFlags
-}
-
-var _ Link = (*progAttachCgroup)(nil)
-
-func (cg *progAttachCgroup) isLink() {}
-
-// newProgAttachCgroup attaches prog to cgroup using BPF_PROG_ATTACH.
-// cgroup and prog are retained by [progAttachCgroup].
-func newProgAttachCgroup(cgroup *os.File, attach ebpf.AttachType, prog *ebpf.Program, flags cgroupAttachFlags) (*progAttachCgroup, error) {
-	if flags&flagAllowMulti > 0 {
-		if err := haveProgAttachReplace(); err != nil {
-			return nil, fmt.Errorf("can't support multiple programs: %w", err)
-		}
-	}
-
-	// Use a program handle that cannot be closed by the caller.
-	clone, err := prog.Clone()
-	if err != nil {
-		return nil, err
-	}
-
-	err = RawAttachProgram(RawAttachProgramOptions{
-		Target:  int(cgroup.Fd()),
-		Program: clone,
-		Flags:   uint32(flags),
-		Attach:  attach,
-	})
-	if err != nil {
-		clone.Close()
-		return nil, fmt.Errorf("cgroup: %w", err)
-	}
-
-	return &progAttachCgroup{cgroup, clone, attach, flags}, nil
-}
-
-func (cg *progAttachCgroup) Close() error {
-	defer cg.cgroup.Close()
-	defer cg.current.Close()
-
-	err := RawDetachProgram(RawDetachProgramOptions{
-		Target:  int(cg.cgroup.Fd()),
-		Program: cg.current,
-		Attach:  cg.attachType,
-	})
-	if err != nil {
-		return fmt.Errorf("close cgroup: %s", err)
-	}
-	return nil
-}
-
-func (cg *progAttachCgroup) Update(prog *ebpf.Program) error {
-	new, err := prog.Clone()
-	if err != nil {
-		return err
-	}
-
-	args := RawAttachProgramOptions{
-		Target:  int(cg.cgroup.Fd()),
-		Program: prog,
-		Attach:  cg.attachType,
-		Flags:   uint32(cg.flags),
-	}
-
-	if cg.flags&flagAllowMulti > 0 {
-		// Atomically replacing multiple programs requires at least
-		// 5.5 (commit 7dd68b3279f17921 "bpf: Support replacing cgroup-bpf
-		// program in MULTI mode")
-		args.Flags |= uint32(flagReplace)
-		args.Replace = cg.current
-	}
-
-	if err := RawAttachProgram(args); err != nil {
-		new.Close()
-		return fmt.Errorf("can't update cgroup: %s", err)
-	}
-
-	cg.current.Close()
-	cg.current = new
-	return nil
-}
-
-func (cg *progAttachCgroup) Pin(string) error {
-	return fmt.Errorf("can't pin cgroup: %w", ErrNotSupported)
-}
-
-func (cg *progAttachCgroup) Unpin() error {
-	return fmt.Errorf("can't unpin cgroup: %w", ErrNotSupported)
-}
-
-func (cg *progAttachCgroup) Info() (*Info, error) {
-	return nil, fmt.Errorf("can't get cgroup info: %w", ErrNotSupported)
-}
-
-type linkCgroup struct {
-	RawLink
-}
-
-var _ Link = (*linkCgroup)(nil)
-
-// newLinkCgroup attaches prog to cgroup using BPF_LINK_CREATE.
-func newLinkCgroup(cgroup *os.File, attach ebpf.AttachType, prog *ebpf.Program) (*linkCgroup, error) {
-	link, err := AttachRawLink(RawLinkOptions{
-		Target:  int(cgroup.Fd()),
-		Program: prog,
-		Attach:  attach,
-	})
-	if err != nil {
-		return nil, err
-	}
-
-	return &linkCgroup{*link}, err
-}
diff --git a/vendor/github.com/cilium/ebpf/link/doc.go b/vendor/github.com/cilium/ebpf/link/doc.go
deleted file mode 100644
index 2bde35ed7..000000000
--- a/vendor/github.com/cilium/ebpf/link/doc.go
+++ /dev/null
@@ -1,2 +0,0 @@
-// Package link allows attaching eBPF programs to various kernel hooks.
-package link
diff --git a/vendor/github.com/cilium/ebpf/link/iter.go b/vendor/github.com/cilium/ebpf/link/iter.go
deleted file mode 100644
index d2b32ef33..000000000
--- a/vendor/github.com/cilium/ebpf/link/iter.go
+++ /dev/null
@@ -1,85 +0,0 @@
-package link
-
-import (
-	"fmt"
-	"io"
-	"unsafe"
-
-	"github.com/cilium/ebpf"
-	"github.com/cilium/ebpf/internal/sys"
-)
-
-type IterOptions struct {
-	// Program must be of type Tracing with attach type
-	// AttachTraceIter. The kind of iterator to attach to is
-	// determined at load time via the AttachTo field.
-	//
-	// AttachTo requires the kernel to include BTF of itself,
-	// and it to be compiled with a recent pahole (>= 1.16).
-	Program *ebpf.Program
-
-	// Map specifies the target map for bpf_map_elem and sockmap iterators.
-	// It may be nil.
-	Map *ebpf.Map
-}
-
-// AttachIter attaches a BPF seq_file iterator.
-func AttachIter(opts IterOptions) (*Iter, error) {
-	if err := haveBPFLink(); err != nil {
-		return nil, err
-	}
-
-	progFd := opts.Program.FD()
-	if progFd < 0 {
-		return nil, fmt.Errorf("invalid program: %s", sys.ErrClosedFd)
-	}
-
-	var info bpfIterLinkInfoMap
-	if opts.Map != nil {
-		mapFd := opts.Map.FD()
-		if mapFd < 0 {
-			return nil, fmt.Errorf("invalid map: %w", sys.ErrClosedFd)
-		}
-		info.map_fd = uint32(mapFd)
-	}
-
-	attr := sys.LinkCreateIterAttr{
-		ProgFd:      uint32(progFd),
-		AttachType:  sys.AttachType(ebpf.AttachTraceIter),
-		IterInfo:    sys.NewPointer(unsafe.Pointer(&info)),
-		IterInfoLen: uint32(unsafe.Sizeof(info)),
-	}
-
-	fd, err := sys.LinkCreateIter(&attr)
-	if err != nil {
-		return nil, fmt.Errorf("can't link iterator: %w", err)
-	}
-
-	return &Iter{RawLink{fd, ""}}, err
-}
-
-// Iter represents an attached bpf_iter.
-type Iter struct {
-	RawLink
-}
-
-// Open creates a new instance of the iterator.
-//
-// Reading from the returned reader triggers the BPF program.
-func (it *Iter) Open() (io.ReadCloser, error) {
-	attr := &sys.IterCreateAttr{
-		LinkFd: it.fd.Uint(),
-	}
-
-	fd, err := sys.IterCreate(attr)
-	if err != nil {
-		return nil, fmt.Errorf("can't create iterator: %w", err)
-	}
-
-	return fd.File("bpf_iter"), nil
-}
-
-// union bpf_iter_link_info.map
-type bpfIterLinkInfoMap struct {
-	map_fd uint32
-}
diff --git a/vendor/github.com/cilium/ebpf/link/kprobe.go b/vendor/github.com/cilium/ebpf/link/kprobe.go
deleted file mode 100644
index b54ca9085..000000000
--- a/vendor/github.com/cilium/ebpf/link/kprobe.go
+++ /dev/null
@@ -1,357 +0,0 @@
-package link
-
-import (
-	"errors"
-	"fmt"
-	"os"
-	"runtime"
-	"strings"
-	"unsafe"
-
-	"github.com/cilium/ebpf"
-	"github.com/cilium/ebpf/internal"
-	"github.com/cilium/ebpf/internal/sys"
-	"github.com/cilium/ebpf/internal/tracefs"
-	"github.com/cilium/ebpf/internal/unix"
-)
-
-// KprobeOptions defines additional parameters that will be used
-// when loading Kprobes.
-type KprobeOptions struct {
-	// Arbitrary value that can be fetched from an eBPF program
-	// via `bpf_get_attach_cookie()`.
-	//
-	// Needs kernel 5.15+.
-	Cookie uint64
-	// Offset of the kprobe relative to the traced symbol.
-	// Can be used to insert kprobes at arbitrary offsets in kernel functions,
-	// e.g. in places where functions have been inlined.
-	Offset uint64
-	// Increase the maximum number of concurrent invocations of a kretprobe.
-	// Required when tracing some long running functions in the kernel.
-	//
-	// Deprecated: this setting forces the use of an outdated kernel API and is not portable
-	// across kernel versions.
-	RetprobeMaxActive int
-	// Prefix used for the event name if the kprobe must be attached using tracefs.
-	// The group name will be formatted as `<prefix>_<randomstr>`.
-	// The default empty string is equivalent to "ebpf" as the prefix.
-	TraceFSPrefix string
-}
-
-func (ko *KprobeOptions) cookie() uint64 {
-	if ko == nil {
-		return 0
-	}
-	return ko.Cookie
-}
-
-// Kprobe attaches the given eBPF program to a perf event that fires when the
-// given kernel symbol starts executing. See /proc/kallsyms for available
-// symbols. For example, printk():
-//
-//	kp, err := Kprobe("printk", prog, nil)
-//
-// Losing the reference to the resulting Link (kp) will close the Kprobe
-// and prevent further execution of prog. The Link must be Closed during
-// program shutdown to avoid leaking system resources.
-//
-// If attaching to symbol fails, automatically retries with the running
-// platform's syscall prefix (e.g. __x64_) to support attaching to syscalls
-// in a portable fashion.
-func Kprobe(symbol string, prog *ebpf.Program, opts *KprobeOptions) (Link, error) {
-	k, err := kprobe(symbol, prog, opts, false)
-	if err != nil {
-		return nil, err
-	}
-
-	lnk, err := attachPerfEvent(k, prog, opts.cookie())
-	if err != nil {
-		k.Close()
-		return nil, err
-	}
-
-	return lnk, nil
-}
-
-// Kretprobe attaches the given eBPF program to a perf event that fires right
-// before the given kernel symbol exits, with the function stack left intact.
-// See /proc/kallsyms for available symbols. For example, printk():
-//
-//	kp, err := Kretprobe("printk", prog, nil)
-//
-// Losing the reference to the resulting Link (kp) will close the Kretprobe
-// and prevent further execution of prog. The Link must be Closed during
-// program shutdown to avoid leaking system resources.
-//
-// If attaching to symbol fails, automatically retries with the running
-// platform's syscall prefix (e.g. __x64_) to support attaching to syscalls
-// in a portable fashion.
-//
-// On kernels 5.10 and earlier, setting a kretprobe on a nonexistent symbol
-// incorrectly returns unix.EINVAL instead of os.ErrNotExist.
-func Kretprobe(symbol string, prog *ebpf.Program, opts *KprobeOptions) (Link, error) {
-	k, err := kprobe(symbol, prog, opts, true)
-	if err != nil {
-		return nil, err
-	}
-
-	lnk, err := attachPerfEvent(k, prog, opts.cookie())
-	if err != nil {
-		k.Close()
-		return nil, err
-	}
-
-	return lnk, nil
-}
-
-// isValidKprobeSymbol implements the equivalent of a regex match
-// against "^[a-zA-Z_][0-9a-zA-Z_.]*$".
-func isValidKprobeSymbol(s string) bool {
-	if len(s) < 1 {
-		return false
-	}
-
-	for i, c := range []byte(s) {
-		switch {
-		case c >= 'a' && c <= 'z':
-		case c >= 'A' && c <= 'Z':
-		case c == '_':
-		case i > 0 && c >= '0' && c <= '9':
-
-		// Allow `.` in symbol name. GCC-compiled kernel may change symbol name
-		// to have a `.isra.$n` suffix, like `udp_send_skb.isra.52`.
-		// See: https://gcc.gnu.org/gcc-10/changes.html
-		case i > 0 && c == '.':
-
-		default:
-			return false
-		}
-	}
-
-	return true
-}
-
-// kprobe opens a perf event on the given symbol and attaches prog to it.
-// If ret is true, create a kretprobe.
-func kprobe(symbol string, prog *ebpf.Program, opts *KprobeOptions, ret bool) (*perfEvent, error) {
-	if symbol == "" {
-		return nil, fmt.Errorf("symbol name cannot be empty: %w", errInvalidInput)
-	}
-	if prog == nil {
-		return nil, fmt.Errorf("prog cannot be nil: %w", errInvalidInput)
-	}
-	if !isValidKprobeSymbol(symbol) {
-		return nil, fmt.Errorf("symbol '%s' must be a valid symbol in /proc/kallsyms: %w", symbol, errInvalidInput)
-	}
-	if prog.Type() != ebpf.Kprobe {
-		return nil, fmt.Errorf("eBPF program type %s is not a Kprobe: %w", prog.Type(), errInvalidInput)
-	}
-
-	args := tracefs.ProbeArgs{
-		Type:   tracefs.Kprobe,
-		Pid:    perfAllThreads,
-		Symbol: symbol,
-		Ret:    ret,
-	}
-
-	if opts != nil {
-		args.RetprobeMaxActive = opts.RetprobeMaxActive
-		args.Cookie = opts.Cookie
-		args.Offset = opts.Offset
-		args.Group = opts.TraceFSPrefix
-	}
-
-	// Use kprobe PMU if the kernel has it available.
-	tp, err := pmuProbe(args)
-	if errors.Is(err, os.ErrNotExist) || errors.Is(err, unix.EINVAL) {
-		if prefix := internal.PlatformPrefix(); prefix != "" {
-			args.Symbol = prefix + symbol
-			tp, err = pmuProbe(args)
-		}
-	}
-	if err == nil {
-		return tp, nil
-	}
-	if err != nil && !errors.Is(err, ErrNotSupported) {
-		return nil, fmt.Errorf("creating perf_kprobe PMU (arch-specific fallback for %q): %w", symbol, err)
-	}
-
-	// Use tracefs if kprobe PMU is missing.
-	args.Symbol = symbol
-	tp, err = tracefsProbe(args)
-	if errors.Is(err, os.ErrNotExist) || errors.Is(err, unix.EINVAL) {
-		if prefix := internal.PlatformPrefix(); prefix != "" {
-			args.Symbol = prefix + symbol
-			tp, err = tracefsProbe(args)
-		}
-	}
-	if err != nil {
-		return nil, fmt.Errorf("creating tracefs event (arch-specific fallback for %q): %w", symbol, err)
-	}
-
-	return tp, nil
-}
-
-// pmuProbe opens a perf event based on a Performance Monitoring Unit.
-//
-// Requires at least a 4.17 kernel.
-// e12f03d7031a "perf/core: Implement the 'perf_kprobe' PMU"
-// 33ea4b24277b "perf/core: Implement the 'perf_uprobe' PMU"
-//
-// Returns ErrNotSupported if the kernel doesn't support perf_[k,u]probe PMU
-func pmuProbe(args tracefs.ProbeArgs) (*perfEvent, error) {
-	// Getting the PMU type will fail if the kernel doesn't support
-	// the perf_[k,u]probe PMU.
-	eventType, err := internal.ReadUint64FromFileOnce("%d\n", "/sys/bus/event_source/devices", args.Type.String(), "type")
-	if errors.Is(err, os.ErrNotExist) {
-		return nil, fmt.Errorf("%s: %w", args.Type, ErrNotSupported)
-	}
-	if err != nil {
-		return nil, err
-	}
-
-	// Use tracefs if we want to set kretprobe's retprobeMaxActive.
-	if args.RetprobeMaxActive != 0 {
-		return nil, fmt.Errorf("pmu probe: non-zero retprobeMaxActive: %w", ErrNotSupported)
-	}
-
-	var config uint64
-	if args.Ret {
-		bit, err := internal.ReadUint64FromFileOnce("config:%d\n", "/sys/bus/event_source/devices", args.Type.String(), "/format/retprobe")
-		if err != nil {
-			return nil, err
-		}
-		config |= 1 << bit
-	}
-
-	var (
-		attr  unix.PerfEventAttr
-		sp    unsafe.Pointer
-		token string
-	)
-	switch args.Type {
-	case tracefs.Kprobe:
-		// Create a pointer to a NUL-terminated string for the kernel.
-		sp, err = unsafeStringPtr(args.Symbol)
-		if err != nil {
-			return nil, err
-		}
-
-		token = tracefs.KprobeToken(args)
-
-		attr = unix.PerfEventAttr{
-			// The minimum size required for PMU kprobes is PERF_ATTR_SIZE_VER1,
-			// since it added the config2 (Ext2) field. Use Ext2 as probe_offset.
-			Size:   unix.PERF_ATTR_SIZE_VER1,
-			Type:   uint32(eventType),   // PMU event type read from sysfs
-			Ext1:   uint64(uintptr(sp)), // Kernel symbol to trace
-			Ext2:   args.Offset,         // Kernel symbol offset
-			Config: config,              // Retprobe flag
-		}
-	case tracefs.Uprobe:
-		sp, err = unsafeStringPtr(args.Path)
-		if err != nil {
-			return nil, err
-		}
-
-		if args.RefCtrOffset != 0 {
-			config |= args.RefCtrOffset << uprobeRefCtrOffsetShift
-		}
-
-		token = tracefs.UprobeToken(args)
-
-		attr = unix.PerfEventAttr{
-			// The minimum size required for PMU uprobes is PERF_ATTR_SIZE_VER1,
-			// since it added the config2 (Ext2) field. The Size field controls the
-			// size of the internal buffer the kernel allocates for reading the
-			// perf_event_attr argument from userspace.
-			Size:   unix.PERF_ATTR_SIZE_VER1,
-			Type:   uint32(eventType),   // PMU event type read from sysfs
-			Ext1:   uint64(uintptr(sp)), // Uprobe path
-			Ext2:   args.Offset,         // Uprobe offset
-			Config: config,              // RefCtrOffset, Retprobe flag
-		}
-	}
-
-	rawFd, err := unix.PerfEventOpen(&attr, args.Pid, 0, -1, unix.PERF_FLAG_FD_CLOEXEC)
-
-	// On some old kernels, kprobe PMU doesn't allow `.` in symbol names and
-	// return -EINVAL. Return ErrNotSupported to allow falling back to tracefs.
-	// https://github.com/torvalds/linux/blob/94710cac0ef4/kernel/trace/trace_kprobe.c#L340-L343
-	if errors.Is(err, unix.EINVAL) && strings.Contains(args.Symbol, ".") {
-		return nil, fmt.Errorf("token %s: older kernels don't accept dots: %w", token, ErrNotSupported)
-	}
-	// Since commit 97c753e62e6c, ENOENT is correctly returned instead of EINVAL
-	// when trying to create a retprobe for a missing symbol.
-	if errors.Is(err, os.ErrNotExist) {
-		return nil, fmt.Errorf("token %s: not found: %w", token, err)
-	}
-	// Since commit ab105a4fb894, EILSEQ is returned when a kprobe sym+offset is resolved
-	// to an invalid insn boundary. The exact conditions that trigger this error are
-	// arch specific however.
-	if errors.Is(err, unix.EILSEQ) {
-		return nil, fmt.Errorf("token %s: bad insn boundary: %w", token, os.ErrNotExist)
-	}
-	// Since at least commit cb9a19fe4aa51, ENOTSUPP is returned
-	// when attempting to set a uprobe on a trap instruction.
-	if errors.Is(err, sys.ENOTSUPP) {
-		return nil, fmt.Errorf("token %s: failed setting uprobe on offset %#x (possible trap insn): %w", token, args.Offset, err)
-	}
-
-	if err != nil {
-		return nil, fmt.Errorf("token %s: opening perf event: %w", token, err)
-	}
-
-	// Ensure the string pointer is not collected before PerfEventOpen returns.
-	runtime.KeepAlive(sp)
-
-	fd, err := sys.NewFD(rawFd)
-	if err != nil {
-		return nil, err
-	}
-
-	// Kernel has perf_[k,u]probe PMU available, initialize perf event.
-	return newPerfEvent(fd, nil), nil
-}
-
-// tracefsProbe creates a trace event by writing an entry to <tracefs>/[k,u]probe_events.
-// A new trace event group name is generated on every call to support creating
-// multiple trace events for the same kernel or userspace symbol.
-// Path and offset are only set in the case of uprobe(s) and are used to set
-// the executable/library path on the filesystem and the offset where the probe is inserted.
-// A perf event is then opened on the newly-created trace event and returned to the caller.
-func tracefsProbe(args tracefs.ProbeArgs) (*perfEvent, error) {
-	groupPrefix := "ebpf"
-	if args.Group != "" {
-		groupPrefix = args.Group
-	}
-
-	// Generate a random string for each trace event we attempt to create.
-	// This value is used as the 'group' token in tracefs to allow creating
-	// multiple kprobe trace events with the same name.
-	group, err := tracefs.RandomGroup(groupPrefix)
-	if err != nil {
-		return nil, fmt.Errorf("randomizing group name: %w", err)
-	}
-	args.Group = group
-
-	// Create the [k,u]probe trace event using tracefs.
-	evt, err := tracefs.NewEvent(args)
-	if err != nil {
-		return nil, fmt.Errorf("creating probe entry on tracefs: %w", err)
-	}
-
-	// Kprobes are ephemeral tracepoints and share the same perf event type.
-	fd, err := openTracepointPerfEvent(evt.ID(), args.Pid)
-	if err != nil {
-		// Make sure we clean up the created tracefs event when we return error.
-		// If a livepatch handler is already active on the symbol, the write to
-		// tracefs will succeed, a trace event will show up, but creating the
-		// perf event will fail with EBUSY.
-		_ = evt.Close()
-		return nil, err
-	}
-
-	return newPerfEvent(fd, evt), nil
-}
diff --git a/vendor/github.com/cilium/ebpf/link/kprobe_multi.go b/vendor/github.com/cilium/ebpf/link/kprobe_multi.go
deleted file mode 100644
index 697c6d736..000000000
--- a/vendor/github.com/cilium/ebpf/link/kprobe_multi.go
+++ /dev/null
@@ -1,180 +0,0 @@
-package link
-
-import (
-	"errors"
-	"fmt"
-	"os"
-	"unsafe"
-
-	"github.com/cilium/ebpf"
-	"github.com/cilium/ebpf/asm"
-	"github.com/cilium/ebpf/internal"
-	"github.com/cilium/ebpf/internal/sys"
-	"github.com/cilium/ebpf/internal/unix"
-)
-
-// KprobeMultiOptions defines additional parameters that will be used
-// when opening a KprobeMulti Link.
-type KprobeMultiOptions struct {
-	// Symbols takes a list of kernel symbol names to attach an ebpf program to.
-	//
-	// Mutually exclusive with Addresses.
-	Symbols []string
-
-	// Addresses takes a list of kernel symbol addresses in case they can not
-	// be referred to by name.
-	//
-	// Note that only start addresses can be specified, since the fprobe API
-	// limits the attach point to the function entry or return.
-	//
-	// Mutually exclusive with Symbols.
-	Addresses []uintptr
-
-	// Cookies specifies arbitrary values that can be fetched from an eBPF
-	// program via `bpf_get_attach_cookie()`.
-	//
-	// If set, its length should be equal to the length of Symbols or Addresses.
-	// Each Cookie is assigned to the Symbol or Address specified at the
-	// corresponding slice index.
-	Cookies []uint64
-}
-
-// KprobeMulti attaches the given eBPF program to the entry point of a given set
-// of kernel symbols.
-//
-// The difference with Kprobe() is that multi-kprobe accomplishes this in a
-// single system call, making it significantly faster than attaching many
-// probes one at a time.
-//
-// Requires at least Linux 5.18.
-func KprobeMulti(prog *ebpf.Program, opts KprobeMultiOptions) (Link, error) {
-	return kprobeMulti(prog, opts, 0)
-}
-
-// KretprobeMulti attaches the given eBPF program to the return point of a given
-// set of kernel symbols.
-//
-// The difference with Kretprobe() is that multi-kprobe accomplishes this in a
-// single system call, making it significantly faster than attaching many
-// probes one at a time.
-//
-// Requires at least Linux 5.18.
-func KretprobeMulti(prog *ebpf.Program, opts KprobeMultiOptions) (Link, error) {
-	return kprobeMulti(prog, opts, unix.BPF_F_KPROBE_MULTI_RETURN)
-}
-
-func kprobeMulti(prog *ebpf.Program, opts KprobeMultiOptions, flags uint32) (Link, error) {
-	if prog == nil {
-		return nil, errors.New("cannot attach a nil program")
-	}
-
-	syms := uint32(len(opts.Symbols))
-	addrs := uint32(len(opts.Addresses))
-	cookies := uint32(len(opts.Cookies))
-
-	if syms == 0 && addrs == 0 {
-		return nil, fmt.Errorf("one of Symbols or Addresses is required: %w", errInvalidInput)
-	}
-	if syms != 0 && addrs != 0 {
-		return nil, fmt.Errorf("Symbols and Addresses are mutually exclusive: %w", errInvalidInput)
-	}
-	if cookies > 0 && cookies != syms && cookies != addrs {
-		return nil, fmt.Errorf("Cookies must be exactly Symbols or Addresses in length: %w", errInvalidInput)
-	}
-
-	if err := haveBPFLinkKprobeMulti(); err != nil {
-		return nil, err
-	}
-
-	attr := &sys.LinkCreateKprobeMultiAttr{
-		ProgFd:           uint32(prog.FD()),
-		AttachType:       sys.BPF_TRACE_KPROBE_MULTI,
-		KprobeMultiFlags: flags,
-	}
-
-	switch {
-	case syms != 0:
-		attr.Count = syms
-		attr.Syms = sys.NewStringSlicePointer(opts.Symbols)
-
-	case addrs != 0:
-		attr.Count = addrs
-		attr.Addrs = sys.NewPointer(unsafe.Pointer(&opts.Addresses[0]))
-	}
-
-	if cookies != 0 {
-		attr.Cookies = sys.NewPointer(unsafe.Pointer(&opts.Cookies[0]))
-	}
-
-	fd, err := sys.LinkCreateKprobeMulti(attr)
-	if errors.Is(err, unix.ESRCH) {
-		return nil, fmt.Errorf("couldn't find one or more symbols: %w", os.ErrNotExist)
-	}
-	if errors.Is(err, unix.EINVAL) {
-		return nil, fmt.Errorf("%w (missing kernel symbol or prog's AttachType not AttachTraceKprobeMulti?)", err)
-	}
-	if err != nil {
-		return nil, err
-	}
-
-	return &kprobeMultiLink{RawLink{fd, ""}}, nil
-}
-
-type kprobeMultiLink struct {
-	RawLink
-}
-
-var _ Link = (*kprobeMultiLink)(nil)
-
-func (kml *kprobeMultiLink) Update(prog *ebpf.Program) error {
-	return fmt.Errorf("update kprobe_multi: %w", ErrNotSupported)
-}
-
-func (kml *kprobeMultiLink) Pin(string) error {
-	return fmt.Errorf("pin kprobe_multi: %w", ErrNotSupported)
-}
-
-func (kml *kprobeMultiLink) Unpin() error {
-	return fmt.Errorf("unpin kprobe_multi: %w", ErrNotSupported)
-}
-
-var haveBPFLinkKprobeMulti = internal.NewFeatureTest("bpf_link_kprobe_multi", "5.18", func() error {
-	prog, err := ebpf.NewProgram(&ebpf.ProgramSpec{
-		Name: "probe_kpm_link",
-		Type: ebpf.Kprobe,
-		Instructions: asm.Instructions{
-			asm.Mov.Imm(asm.R0, 0),
-			asm.Return(),
-		},
-		AttachType: ebpf.AttachTraceKprobeMulti,
-		License:    "MIT",
-	})
-	if errors.Is(err, unix.E2BIG) {
-		// Kernel doesn't support AttachType field.
-		return internal.ErrNotSupported
-	}
-	if err != nil {
-		return err
-	}
-	defer prog.Close()
-
-	fd, err := sys.LinkCreateKprobeMulti(&sys.LinkCreateKprobeMultiAttr{
-		ProgFd:     uint32(prog.FD()),
-		AttachType: sys.BPF_TRACE_KPROBE_MULTI,
-		Count:      1,
-		Syms:       sys.NewStringSlicePointer([]string{"vprintk"}),
-	})
-	switch {
-	case errors.Is(err, unix.EINVAL):
-		return internal.ErrNotSupported
-	// If CONFIG_FPROBE isn't set.
-	case errors.Is(err, unix.EOPNOTSUPP):
-		return internal.ErrNotSupported
-	case err != nil:
-		return err
-	}
-
-	fd.Close()
-
-	return nil
-})
diff --git a/vendor/github.com/cilium/ebpf/link/link.go b/vendor/github.com/cilium/ebpf/link/link.go
deleted file mode 100644
index 36acd6ee4..000000000
--- a/vendor/github.com/cilium/ebpf/link/link.go
+++ /dev/null
@@ -1,336 +0,0 @@
-package link
-
-import (
-	"bytes"
-	"encoding/binary"
-	"fmt"
-
-	"github.com/cilium/ebpf"
-	"github.com/cilium/ebpf/btf"
-	"github.com/cilium/ebpf/internal"
-	"github.com/cilium/ebpf/internal/sys"
-)
-
-var ErrNotSupported = internal.ErrNotSupported
-
-// Link represents a Program attached to a BPF hook.
-type Link interface {
-	// Replace the current program with a new program.
-	//
-	// Passing a nil program is an error. May return an error wrapping ErrNotSupported.
-	Update(*ebpf.Program) error
-
-	// Persist a link by pinning it into a bpffs.
-	//
-	// May return an error wrapping ErrNotSupported.
-	Pin(string) error
-
-	// Undo a previous call to Pin.
-	//
-	// May return an error wrapping ErrNotSupported.
-	Unpin() error
-
-	// Close frees resources.
-	//
-	// The link will be broken unless it has been successfully pinned.
-	// A link may continue past the lifetime of the process if Close is
-	// not called.
-	Close() error
-
-	// Info returns metadata on a link.
-	//
-	// May return an error wrapping ErrNotSupported.
-	Info() (*Info, error)
-
-	// Prevent external users from implementing this interface.
-	isLink()
-}
-
-// NewLinkFromFD creates a link from a raw fd.
-//
-// You should not use fd after calling this function.
-func NewLinkFromFD(fd int) (Link, error) {
-	sysFD, err := sys.NewFD(fd)
-	if err != nil {
-		return nil, err
-	}
-
-	return wrapRawLink(&RawLink{fd: sysFD})
-}
-
-// LoadPinnedLink loads a link that was persisted into a bpffs.
-func LoadPinnedLink(fileName string, opts *ebpf.LoadPinOptions) (Link, error) {
-	raw, err := loadPinnedRawLink(fileName, opts)
-	if err != nil {
-		return nil, err
-	}
-
-	return wrapRawLink(raw)
-}
-
-// wrap a RawLink in a more specific type if possible.
-//
-// The function takes ownership of raw and closes it on error.
-func wrapRawLink(raw *RawLink) (_ Link, err error) {
-	defer func() {
-		if err != nil {
-			raw.Close()
-		}
-	}()
-
-	info, err := raw.Info()
-	if err != nil {
-		return nil, err
-	}
-
-	switch info.Type {
-	case RawTracepointType:
-		return &rawTracepoint{*raw}, nil
-	case TracingType:
-		return &tracing{*raw}, nil
-	case CgroupType:
-		return &linkCgroup{*raw}, nil
-	case IterType:
-		return &Iter{*raw}, nil
-	case NetNsType:
-		return &NetNsLink{*raw}, nil
-	case KprobeMultiType:
-		return &kprobeMultiLink{*raw}, nil
-	case PerfEventType:
-		return nil, fmt.Errorf("recovering perf event fd: %w", ErrNotSupported)
-	default:
-		return raw, nil
-	}
-}
-
-// ID uniquely identifies a BPF link.
-type ID = sys.LinkID
-
-// RawLinkOptions control the creation of a raw link.
-type RawLinkOptions struct {
-	// File descriptor to attach to. This differs for each attach type.
-	Target int
-	// Program to attach.
-	Program *ebpf.Program
-	// Attach must match the attach type of Program.
-	Attach ebpf.AttachType
-	// BTF is the BTF of the attachment target.
-	BTF btf.TypeID
-	// Flags control the attach behaviour.
-	Flags uint32
-}
-
-// Info contains metadata on a link.
-type Info struct {
-	Type    Type
-	ID      ID
-	Program ebpf.ProgramID
-	extra   interface{}
-}
-
-type TracingInfo sys.TracingLinkInfo
-type CgroupInfo sys.CgroupLinkInfo
-type NetNsInfo sys.NetNsLinkInfo
-type XDPInfo sys.XDPLinkInfo
-
-// Tracing returns tracing type-specific link info.
-//
-// Returns nil if the type-specific link info isn't available.
-func (r Info) Tracing() *TracingInfo {
-	e, _ := r.extra.(*TracingInfo)
-	return e
-}
-
-// Cgroup returns cgroup type-specific link info.
-//
-// Returns nil if the type-specific link info isn't available.
-func (r Info) Cgroup() *CgroupInfo {
-	e, _ := r.extra.(*CgroupInfo)
-	return e
-}
-
-// NetNs returns netns type-specific link info.
-//
-// Returns nil if the type-specific link info isn't available.
-func (r Info) NetNs() *NetNsInfo {
-	e, _ := r.extra.(*NetNsInfo)
-	return e
-}
-
-// ExtraNetNs returns XDP type-specific link info.
-//
-// Returns nil if the type-specific link info isn't available.
-func (r Info) XDP() *XDPInfo {
-	e, _ := r.extra.(*XDPInfo)
-	return e
-}
-
-// RawLink is the low-level API to bpf_link.
-//
-// You should consider using the higher level interfaces in this
-// package instead.
-type RawLink struct {
-	fd         *sys.FD
-	pinnedPath string
-}
-
-// AttachRawLink creates a raw link.
-func AttachRawLink(opts RawLinkOptions) (*RawLink, error) {
-	if err := haveBPFLink(); err != nil {
-		return nil, err
-	}
-
-	if opts.Target < 0 {
-		return nil, fmt.Errorf("invalid target: %s", sys.ErrClosedFd)
-	}
-
-	progFd := opts.Program.FD()
-	if progFd < 0 {
-		return nil, fmt.Errorf("invalid program: %s", sys.ErrClosedFd)
-	}
-
-	attr := sys.LinkCreateAttr{
-		TargetFd:    uint32(opts.Target),
-		ProgFd:      uint32(progFd),
-		AttachType:  sys.AttachType(opts.Attach),
-		TargetBtfId: opts.BTF,
-		Flags:       opts.Flags,
-	}
-	fd, err := sys.LinkCreate(&attr)
-	if err != nil {
-		return nil, fmt.Errorf("create link: %w", err)
-	}
-
-	return &RawLink{fd, ""}, nil
-}
-
-func loadPinnedRawLink(fileName string, opts *ebpf.LoadPinOptions) (*RawLink, error) {
-	fd, err := sys.ObjGet(&sys.ObjGetAttr{
-		Pathname:  sys.NewStringPointer(fileName),
-		FileFlags: opts.Marshal(),
-	})
-	if err != nil {
-		return nil, fmt.Errorf("load pinned link: %w", err)
-	}
-
-	return &RawLink{fd, fileName}, nil
-}
-
-func (l *RawLink) isLink() {}
-
-// FD returns the raw file descriptor.
-func (l *RawLink) FD() int {
-	return l.fd.Int()
-}
-
-// Close breaks the link.
-//
-// Use Pin if you want to make the link persistent.
-func (l *RawLink) Close() error {
-	return l.fd.Close()
-}
-
-// Pin persists a link past the lifetime of the process.
-//
-// Calling Close on a pinned Link will not break the link
-// until the pin is removed.
-func (l *RawLink) Pin(fileName string) error {
-	if err := internal.Pin(l.pinnedPath, fileName, l.fd); err != nil {
-		return err
-	}
-	l.pinnedPath = fileName
-	return nil
-}
-
-// Unpin implements the Link interface.
-func (l *RawLink) Unpin() error {
-	if err := internal.Unpin(l.pinnedPath); err != nil {
-		return err
-	}
-	l.pinnedPath = ""
-	return nil
-}
-
-// IsPinned returns true if the Link has a non-empty pinned path.
-func (l *RawLink) IsPinned() bool {
-	return l.pinnedPath != ""
-}
-
-// Update implements the Link interface.
-func (l *RawLink) Update(new *ebpf.Program) error {
-	return l.UpdateArgs(RawLinkUpdateOptions{
-		New: new,
-	})
-}
-
-// RawLinkUpdateOptions control the behaviour of RawLink.UpdateArgs.
-type RawLinkUpdateOptions struct {
-	New   *ebpf.Program
-	Old   *ebpf.Program
-	Flags uint32
-}
-
-// UpdateArgs updates a link based on args.
-func (l *RawLink) UpdateArgs(opts RawLinkUpdateOptions) error {
-	newFd := opts.New.FD()
-	if newFd < 0 {
-		return fmt.Errorf("invalid program: %s", sys.ErrClosedFd)
-	}
-
-	var oldFd int
-	if opts.Old != nil {
-		oldFd = opts.Old.FD()
-		if oldFd < 0 {
-			return fmt.Errorf("invalid replacement program: %s", sys.ErrClosedFd)
-		}
-	}
-
-	attr := sys.LinkUpdateAttr{
-		LinkFd:    l.fd.Uint(),
-		NewProgFd: uint32(newFd),
-		OldProgFd: uint32(oldFd),
-		Flags:     opts.Flags,
-	}
-	return sys.LinkUpdate(&attr)
-}
-
-// Info returns metadata about the link.
-func (l *RawLink) Info() (*Info, error) {
-	var info sys.LinkInfo
-
-	if err := sys.ObjInfo(l.fd, &info); err != nil {
-		return nil, fmt.Errorf("link info: %s", err)
-	}
-
-	var extra interface{}
-	switch info.Type {
-	case CgroupType:
-		extra = &CgroupInfo{}
-	case NetNsType:
-		extra = &NetNsInfo{}
-	case TracingType:
-		extra = &TracingInfo{}
-	case XDPType:
-		extra = &XDPInfo{}
-	case RawTracepointType, IterType,
-		PerfEventType, KprobeMultiType:
-		// Extra metadata not supported.
-	default:
-		return nil, fmt.Errorf("unknown link info type: %d", info.Type)
-	}
-
-	if extra != nil {
-		buf := bytes.NewReader(info.Extra[:])
-		err := binary.Read(buf, internal.NativeEndian, extra)
-		if err != nil {
-			return nil, fmt.Errorf("cannot read extra link info: %w", err)
-		}
-	}
-
-	return &Info{
-		info.Type,
-		info.Id,
-		ebpf.ProgramID(info.ProgId),
-		extra,
-	}, nil
-}
diff --git a/vendor/github.com/cilium/ebpf/link/netns.go b/vendor/github.com/cilium/ebpf/link/netns.go
deleted file mode 100644
index 344ecced6..000000000
--- a/vendor/github.com/cilium/ebpf/link/netns.go
+++ /dev/null
@@ -1,36 +0,0 @@
-package link
-
-import (
-	"fmt"
-
-	"github.com/cilium/ebpf"
-)
-
-// NetNsLink is a program attached to a network namespace.
-type NetNsLink struct {
-	RawLink
-}
-
-// AttachNetNs attaches a program to a network namespace.
-func AttachNetNs(ns int, prog *ebpf.Program) (*NetNsLink, error) {
-	var attach ebpf.AttachType
-	switch t := prog.Type(); t {
-	case ebpf.FlowDissector:
-		attach = ebpf.AttachFlowDissector
-	case ebpf.SkLookup:
-		attach = ebpf.AttachSkLookup
-	default:
-		return nil, fmt.Errorf("can't attach %v to network namespace", t)
-	}
-
-	link, err := AttachRawLink(RawLinkOptions{
-		Target:  ns,
-		Program: prog,
-		Attach:  attach,
-	})
-	if err != nil {
-		return nil, err
-	}
-
-	return &NetNsLink{*link}, nil
-}
diff --git a/vendor/github.com/cilium/ebpf/link/perf_event.go b/vendor/github.com/cilium/ebpf/link/perf_event.go
deleted file mode 100644
index 5f7a628b3..000000000
--- a/vendor/github.com/cilium/ebpf/link/perf_event.go
+++ /dev/null
@@ -1,270 +0,0 @@
-package link
-
-import (
-	"errors"
-	"fmt"
-	"runtime"
-	"unsafe"
-
-	"github.com/cilium/ebpf"
-	"github.com/cilium/ebpf/asm"
-	"github.com/cilium/ebpf/internal"
-	"github.com/cilium/ebpf/internal/sys"
-	"github.com/cilium/ebpf/internal/tracefs"
-	"github.com/cilium/ebpf/internal/unix"
-)
-
-// Getting the terminology right is usually the hardest part. For posterity and
-// for staying sane during implementation:
-//
-// - trace event: Representation of a kernel runtime hook. Filesystem entries
-//   under <tracefs>/events. Can be tracepoints (static), kprobes or uprobes.
-//   Can be instantiated into perf events (see below).
-// - tracepoint: A predetermined hook point in the kernel. Exposed as trace
-//   events in (sub)directories under <tracefs>/events. Cannot be closed or
-//   removed, they are static.
-// - k(ret)probe: Ephemeral trace events based on entry or exit points of
-//   exported kernel symbols. kprobe-based (tracefs) trace events can be
-//   created system-wide by writing to the <tracefs>/kprobe_events file, or
-//   they can be scoped to the current process by creating PMU perf events.
-// - u(ret)probe: Ephemeral trace events based on user provides ELF binaries
-//   and offsets. uprobe-based (tracefs) trace events can be
-//   created system-wide by writing to the <tracefs>/uprobe_events file, or
-//   they can be scoped to the current process by creating PMU perf events.
-// - perf event: An object instantiated based on an existing trace event or
-//   kernel symbol. Referred to by fd in userspace.
-//   Exactly one eBPF program can be attached to a perf event. Multiple perf
-//   events can be created from a single trace event. Closing a perf event
-//   stops any further invocations of the attached eBPF program.
-
-var (
-	errInvalidInput = tracefs.ErrInvalidInput
-)
-
-const (
-	perfAllThreads = -1
-)
-
-// A perfEvent represents a perf event kernel object. Exactly one eBPF program
-// can be attached to it. It is created based on a tracefs trace event or a
-// Performance Monitoring Unit (PMU).
-type perfEvent struct {
-	// Trace event backing this perfEvent. May be nil.
-	tracefsEvent *tracefs.Event
-
-	// This is the perf event FD.
-	fd *sys.FD
-}
-
-func newPerfEvent(fd *sys.FD, event *tracefs.Event) *perfEvent {
-	pe := &perfEvent{event, fd}
-	// Both event and fd have their own finalizer, but we want to
-	// guarantee that they are closed in a certain order.
-	runtime.SetFinalizer(pe, (*perfEvent).Close)
-	return pe
-}
-
-func (pe *perfEvent) Close() error {
-	runtime.SetFinalizer(pe, nil)
-
-	if err := pe.fd.Close(); err != nil {
-		return fmt.Errorf("closing perf event fd: %w", err)
-	}
-
-	if pe.tracefsEvent != nil {
-		return pe.tracefsEvent.Close()
-	}
-
-	return nil
-}
-
-// perfEventLink represents a bpf perf link.
-type perfEventLink struct {
-	RawLink
-	pe *perfEvent
-}
-
-func (pl *perfEventLink) isLink() {}
-
-// Pinning requires the underlying perf event FD to stay open.
-//
-// | PerfEvent FD | BpfLink FD | Works |
-// |--------------|------------|-------|
-// | Open         | Open       | Yes   |
-// | Closed       | Open       | No    |
-// | Open         | Closed     | No (Pin() -> EINVAL) |
-// | Closed       | Closed     | No (Pin() -> EINVAL) |
-//
-// There is currently no pretty way to recover the perf event FD
-// when loading a pinned link, so leave as not supported for now.
-func (pl *perfEventLink) Pin(string) error {
-	return fmt.Errorf("perf event link pin: %w", ErrNotSupported)
-}
-
-func (pl *perfEventLink) Unpin() error {
-	return fmt.Errorf("perf event link unpin: %w", ErrNotSupported)
-}
-
-func (pl *perfEventLink) Close() error {
-	if err := pl.fd.Close(); err != nil {
-		return fmt.Errorf("perf link close: %w", err)
-	}
-
-	if err := pl.pe.Close(); err != nil {
-		return fmt.Errorf("perf event close: %w", err)
-	}
-	return nil
-}
-
-func (pl *perfEventLink) Update(prog *ebpf.Program) error {
-	return fmt.Errorf("perf event link update: %w", ErrNotSupported)
-}
-
-// perfEventIoctl implements Link and handles the perf event lifecycle
-// via ioctl().
-type perfEventIoctl struct {
-	*perfEvent
-}
-
-func (pi *perfEventIoctl) isLink() {}
-
-// Since 4.15 (e87c6bc3852b "bpf: permit multiple bpf attachments for a single perf event"),
-// calling PERF_EVENT_IOC_SET_BPF appends the given program to a prog_array
-// owned by the perf event, which means multiple programs can be attached
-// simultaneously.
-//
-// Before 4.15, calling PERF_EVENT_IOC_SET_BPF more than once on a perf event
-// returns EEXIST.
-//
-// Detaching a program from a perf event is currently not possible, so a
-// program replacement mechanism cannot be implemented for perf events.
-func (pi *perfEventIoctl) Update(prog *ebpf.Program) error {
-	return fmt.Errorf("perf event ioctl update: %w", ErrNotSupported)
-}
-
-func (pi *perfEventIoctl) Pin(string) error {
-	return fmt.Errorf("perf event ioctl pin: %w", ErrNotSupported)
-}
-
-func (pi *perfEventIoctl) Unpin() error {
-	return fmt.Errorf("perf event ioctl unpin: %w", ErrNotSupported)
-}
-
-func (pi *perfEventIoctl) Info() (*Info, error) {
-	return nil, fmt.Errorf("perf event ioctl info: %w", ErrNotSupported)
-}
-
-// attach the given eBPF prog to the perf event stored in pe.
-// pe must contain a valid perf event fd.
-// prog's type must match the program type stored in pe.
-func attachPerfEvent(pe *perfEvent, prog *ebpf.Program, cookie uint64) (Link, error) {
-	if prog == nil {
-		return nil, errors.New("cannot attach a nil program")
-	}
-	if prog.FD() < 0 {
-		return nil, fmt.Errorf("invalid program: %w", sys.ErrClosedFd)
-	}
-
-	if err := haveBPFLinkPerfEvent(); err == nil {
-		return attachPerfEventLink(pe, prog, cookie)
-	}
-
-	if cookie != 0 {
-		return nil, fmt.Errorf("cookies are not supported: %w", ErrNotSupported)
-	}
-
-	return attachPerfEventIoctl(pe, prog)
-}
-
-func attachPerfEventIoctl(pe *perfEvent, prog *ebpf.Program) (*perfEventIoctl, error) {
-	// Assign the eBPF program to the perf event.
-	err := unix.IoctlSetInt(pe.fd.Int(), unix.PERF_EVENT_IOC_SET_BPF, prog.FD())
-	if err != nil {
-		return nil, fmt.Errorf("setting perf event bpf program: %w", err)
-	}
-
-	// PERF_EVENT_IOC_ENABLE and _DISABLE ignore their given values.
-	if err := unix.IoctlSetInt(pe.fd.Int(), unix.PERF_EVENT_IOC_ENABLE, 0); err != nil {
-		return nil, fmt.Errorf("enable perf event: %s", err)
-	}
-
-	return &perfEventIoctl{pe}, nil
-}
-
-// Use the bpf api to attach the perf event (BPF_LINK_TYPE_PERF_EVENT, 5.15+).
-//
-// https://github.com/torvalds/linux/commit/b89fbfbb854c9afc3047e8273cc3a694650b802e
-func attachPerfEventLink(pe *perfEvent, prog *ebpf.Program, cookie uint64) (*perfEventLink, error) {
-	fd, err := sys.LinkCreatePerfEvent(&sys.LinkCreatePerfEventAttr{
-		ProgFd:     uint32(prog.FD()),
-		TargetFd:   pe.fd.Uint(),
-		AttachType: sys.BPF_PERF_EVENT,
-		BpfCookie:  cookie,
-	})
-	if err != nil {
-		return nil, fmt.Errorf("cannot create bpf perf link: %v", err)
-	}
-
-	return &perfEventLink{RawLink{fd: fd}, pe}, nil
-}
-
-// unsafeStringPtr returns an unsafe.Pointer to a NUL-terminated copy of str.
-func unsafeStringPtr(str string) (unsafe.Pointer, error) {
-	p, err := unix.BytePtrFromString(str)
-	if err != nil {
-		return nil, err
-	}
-	return unsafe.Pointer(p), nil
-}
-
-// openTracepointPerfEvent opens a tracepoint-type perf event. System-wide
-// [k,u]probes created by writing to <tracefs>/[k,u]probe_events are tracepoints
-// behind the scenes, and can be attached to using these perf events.
-func openTracepointPerfEvent(tid uint64, pid int) (*sys.FD, error) {
-	attr := unix.PerfEventAttr{
-		Type:        unix.PERF_TYPE_TRACEPOINT,
-		Config:      tid,
-		Sample_type: unix.PERF_SAMPLE_RAW,
-		Sample:      1,
-		Wakeup:      1,
-	}
-
-	fd, err := unix.PerfEventOpen(&attr, pid, 0, -1, unix.PERF_FLAG_FD_CLOEXEC)
-	if err != nil {
-		return nil, fmt.Errorf("opening tracepoint perf event: %w", err)
-	}
-
-	return sys.NewFD(fd)
-}
-
-// Probe BPF perf link.
-//
-// https://elixir.bootlin.com/linux/v5.16.8/source/kernel/bpf/syscall.c#L4307
-// https://github.com/torvalds/linux/commit/b89fbfbb854c9afc3047e8273cc3a694650b802e
-var haveBPFLinkPerfEvent = internal.NewFeatureTest("bpf_link_perf_event", "5.15", func() error {
-	prog, err := ebpf.NewProgram(&ebpf.ProgramSpec{
-		Name: "probe_bpf_perf_link",
-		Type: ebpf.Kprobe,
-		Instructions: asm.Instructions{
-			asm.Mov.Imm(asm.R0, 0),
-			asm.Return(),
-		},
-		License: "MIT",
-	})
-	if err != nil {
-		return err
-	}
-	defer prog.Close()
-
-	_, err = sys.LinkCreatePerfEvent(&sys.LinkCreatePerfEventAttr{
-		ProgFd:     uint32(prog.FD()),
-		AttachType: sys.BPF_PERF_EVENT,
-	})
-	if errors.Is(err, unix.EINVAL) {
-		return internal.ErrNotSupported
-	}
-	if errors.Is(err, unix.EBADF) {
-		return nil
-	}
-	return err
-})
diff --git a/vendor/github.com/cilium/ebpf/link/program.go b/vendor/github.com/cilium/ebpf/link/program.go
deleted file mode 100644
index ea3181737..000000000
--- a/vendor/github.com/cilium/ebpf/link/program.go
+++ /dev/null
@@ -1,76 +0,0 @@
-package link
-
-import (
-	"fmt"
-
-	"github.com/cilium/ebpf"
-	"github.com/cilium/ebpf/internal/sys"
-)
-
-type RawAttachProgramOptions struct {
-	// File descriptor to attach to. This differs for each attach type.
-	Target int
-	// Program to attach.
-	Program *ebpf.Program
-	// Program to replace (cgroups).
-	Replace *ebpf.Program
-	// Attach must match the attach type of Program (and Replace).
-	Attach ebpf.AttachType
-	// Flags control the attach behaviour. This differs for each attach type.
-	Flags uint32
-}
-
-// RawAttachProgram is a low level wrapper around BPF_PROG_ATTACH.
-//
-// You should use one of the higher level abstractions available in this
-// package if possible.
-func RawAttachProgram(opts RawAttachProgramOptions) error {
-	if err := haveProgAttach(); err != nil {
-		return err
-	}
-
-	var replaceFd uint32
-	if opts.Replace != nil {
-		replaceFd = uint32(opts.Replace.FD())
-	}
-
-	attr := sys.ProgAttachAttr{
-		TargetFd:     uint32(opts.Target),
-		AttachBpfFd:  uint32(opts.Program.FD()),
-		ReplaceBpfFd: replaceFd,
-		AttachType:   uint32(opts.Attach),
-		AttachFlags:  uint32(opts.Flags),
-	}
-
-	if err := sys.ProgAttach(&attr); err != nil {
-		return fmt.Errorf("can't attach program: %w", err)
-	}
-	return nil
-}
-
-type RawDetachProgramOptions struct {
-	Target  int
-	Program *ebpf.Program
-	Attach  ebpf.AttachType
-}
-
-// RawDetachProgram is a low level wrapper around BPF_PROG_DETACH.
-//
-// You should use one of the higher level abstractions available in this
-// package if possible.
-func RawDetachProgram(opts RawDetachProgramOptions) error {
-	if err := haveProgAttach(); err != nil {
-		return err
-	}
-
-	attr := sys.ProgDetachAttr{
-		TargetFd:    uint32(opts.Target),
-		AttachBpfFd: uint32(opts.Program.FD()),
-		AttachType:  uint32(opts.Attach),
-	}
-	if err := sys.ProgDetach(&attr); err != nil {
-		return fmt.Errorf("can't detach program: %w", err)
-	}
-
-	return nil
-}
diff --git a/vendor/github.com/cilium/ebpf/link/query.go b/vendor/github.com/cilium/ebpf/link/query.go
deleted file mode 100644
index c05656512..000000000
--- a/vendor/github.com/cilium/ebpf/link/query.go
+++ /dev/null
@@ -1,63 +0,0 @@
-package link
-
-import (
-	"fmt"
-	"os"
-	"unsafe"
-
-	"github.com/cilium/ebpf"
-	"github.com/cilium/ebpf/internal/sys"
-)
-
-// QueryOptions defines additional parameters when querying for programs.
-type QueryOptions struct {
-	// Path can be a path to a cgroup, netns or LIRC2 device
-	Path string
-	// Attach specifies the AttachType of the programs queried for
-	Attach ebpf.AttachType
-	// QueryFlags are flags for BPF_PROG_QUERY, e.g. BPF_F_QUERY_EFFECTIVE
-	QueryFlags uint32
-}
-
-// QueryPrograms retrieves ProgramIDs associated with the AttachType.
-//
-// Returns (nil, nil) if there are no programs attached to the queried kernel
-// resource. Calling QueryPrograms on a kernel missing PROG_QUERY will result in
-// ErrNotSupported.
-func QueryPrograms(opts QueryOptions) ([]ebpf.ProgramID, error) {
-	if haveProgQuery() != nil {
-		return nil, fmt.Errorf("can't query program IDs: %w", ErrNotSupported)
-	}
-
-	f, err := os.Open(opts.Path)
-	if err != nil {
-		return nil, fmt.Errorf("can't open file: %s", err)
-	}
-	defer f.Close()
-
-	// query the number of programs to allocate correct slice size
-	attr := sys.ProgQueryAttr{
-		TargetFd:   uint32(f.Fd()),
-		AttachType: sys.AttachType(opts.Attach),
-		QueryFlags: opts.QueryFlags,
-	}
-	if err := sys.ProgQuery(&attr); err != nil {
-		return nil, fmt.Errorf("can't query program count: %w", err)
-	}
-
-	// return nil if no progs are attached
-	if attr.ProgCount == 0 {
-		return nil, nil
-	}
-
-	// we have at least one prog, so we query again
-	progIds := make([]ebpf.ProgramID, attr.ProgCount)
-	attr.ProgIds = sys.NewPointer(unsafe.Pointer(&progIds[0]))
-	attr.ProgCount = uint32(len(progIds))
-	if err := sys.ProgQuery(&attr); err != nil {
-		return nil, fmt.Errorf("can't query program IDs: %w", err)
-	}
-
-	return progIds, nil
-
-}
diff --git a/vendor/github.com/cilium/ebpf/link/raw_tracepoint.go b/vendor/github.com/cilium/ebpf/link/raw_tracepoint.go
deleted file mode 100644
index 925e621cb..000000000
--- a/vendor/github.com/cilium/ebpf/link/raw_tracepoint.go
+++ /dev/null
@@ -1,87 +0,0 @@
-package link
-
-import (
-	"errors"
-	"fmt"
-
-	"github.com/cilium/ebpf"
-	"github.com/cilium/ebpf/internal/sys"
-)
-
-type RawTracepointOptions struct {
-	// Tracepoint name.
-	Name string
-	// Program must be of type RawTracepoint*
-	Program *ebpf.Program
-}
-
-// AttachRawTracepoint links a BPF program to a raw_tracepoint.
-//
-// Requires at least Linux 4.17.
-func AttachRawTracepoint(opts RawTracepointOptions) (Link, error) {
-	if t := opts.Program.Type(); t != ebpf.RawTracepoint && t != ebpf.RawTracepointWritable {
-		return nil, fmt.Errorf("invalid program type %s, expected RawTracepoint(Writable)", t)
-	}
-	if opts.Program.FD() < 0 {
-		return nil, fmt.Errorf("invalid program: %w", sys.ErrClosedFd)
-	}
-
-	fd, err := sys.RawTracepointOpen(&sys.RawTracepointOpenAttr{
-		Name:   sys.NewStringPointer(opts.Name),
-		ProgFd: uint32(opts.Program.FD()),
-	})
-	if err != nil {
-		return nil, err
-	}
-
-	err = haveBPFLink()
-	if errors.Is(err, ErrNotSupported) {
-		// Prior to commit 70ed506c3bbc ("bpf: Introduce pinnable bpf_link abstraction")
-		// raw_tracepoints are just a plain fd.
-		return &simpleRawTracepoint{fd}, nil
-	}
-
-	if err != nil {
-		return nil, err
-	}
-
-	return &rawTracepoint{RawLink{fd: fd}}, nil
-}
-
-type simpleRawTracepoint struct {
-	fd *sys.FD
-}
-
-var _ Link = (*simpleRawTracepoint)(nil)
-
-func (frt *simpleRawTracepoint) isLink() {}
-
-func (frt *simpleRawTracepoint) Close() error {
-	return frt.fd.Close()
-}
-
-func (frt *simpleRawTracepoint) Update(_ *ebpf.Program) error {
-	return fmt.Errorf("update raw_tracepoint: %w", ErrNotSupported)
-}
-
-func (frt *simpleRawTracepoint) Pin(string) error {
-	return fmt.Errorf("pin raw_tracepoint: %w", ErrNotSupported)
-}
-
-func (frt *simpleRawTracepoint) Unpin() error {
-	return fmt.Errorf("unpin raw_tracepoint: %w", ErrNotSupported)
-}
-
-func (frt *simpleRawTracepoint) Info() (*Info, error) {
-	return nil, fmt.Errorf("can't get raw_tracepoint info: %w", ErrNotSupported)
-}
-
-type rawTracepoint struct {
-	RawLink
-}
-
-var _ Link = (*rawTracepoint)(nil)
-
-func (rt *rawTracepoint) Update(_ *ebpf.Program) error {
-	return fmt.Errorf("update raw_tracepoint: %w", ErrNotSupported)
-}
diff --git a/vendor/github.com/cilium/ebpf/link/socket_filter.go b/vendor/github.com/cilium/ebpf/link/socket_filter.go
deleted file mode 100644
index 84f0b656f..000000000
--- a/vendor/github.com/cilium/ebpf/link/socket_filter.go
+++ /dev/null
@@ -1,40 +0,0 @@
-package link
-
-import (
-	"syscall"
-
-	"github.com/cilium/ebpf"
-	"github.com/cilium/ebpf/internal/unix"
-)
-
-// AttachSocketFilter attaches a SocketFilter BPF program to a socket.
-func AttachSocketFilter(conn syscall.Conn, program *ebpf.Program) error {
-	rawConn, err := conn.SyscallConn()
-	if err != nil {
-		return err
-	}
-	var ssoErr error
-	err = rawConn.Control(func(fd uintptr) {
-		ssoErr = unix.SetsockoptInt(int(fd), unix.SOL_SOCKET, unix.SO_ATTACH_BPF, program.FD())
-	})
-	if ssoErr != nil {
-		return ssoErr
-	}
-	return err
-}
-
-// DetachSocketFilter detaches a SocketFilter BPF program from a socket.
-func DetachSocketFilter(conn syscall.Conn) error {
-	rawConn, err := conn.SyscallConn()
-	if err != nil {
-		return err
-	}
-	var ssoErr error
-	err = rawConn.Control(func(fd uintptr) {
-		ssoErr = unix.SetsockoptInt(int(fd), unix.SOL_SOCKET, unix.SO_DETACH_BPF, 0)
-	})
-	if ssoErr != nil {
-		return ssoErr
-	}
-	return err
-}
diff --git a/vendor/github.com/cilium/ebpf/link/syscalls.go b/vendor/github.com/cilium/ebpf/link/syscalls.go
deleted file mode 100644
index c9c998c20..000000000
--- a/vendor/github.com/cilium/ebpf/link/syscalls.go
+++ /dev/null
@@ -1,123 +0,0 @@
-package link
-
-import (
-	"errors"
-
-	"github.com/cilium/ebpf"
-	"github.com/cilium/ebpf/asm"
-	"github.com/cilium/ebpf/internal"
-	"github.com/cilium/ebpf/internal/sys"
-	"github.com/cilium/ebpf/internal/unix"
-)
-
-// Type is the kind of link.
-type Type = sys.LinkType
-
-// Valid link types.
-const (
-	UnspecifiedType   = sys.BPF_LINK_TYPE_UNSPEC
-	RawTracepointType = sys.BPF_LINK_TYPE_RAW_TRACEPOINT
-	TracingType       = sys.BPF_LINK_TYPE_TRACING
-	CgroupType        = sys.BPF_LINK_TYPE_CGROUP
-	IterType          = sys.BPF_LINK_TYPE_ITER
-	NetNsType         = sys.BPF_LINK_TYPE_NETNS
-	XDPType           = sys.BPF_LINK_TYPE_XDP
-	PerfEventType     = sys.BPF_LINK_TYPE_PERF_EVENT
-	KprobeMultiType   = sys.BPF_LINK_TYPE_KPROBE_MULTI
-)
-
-var haveProgAttach = internal.NewFeatureTest("BPF_PROG_ATTACH", "4.10", func() error {
-	prog, err := ebpf.NewProgram(&ebpf.ProgramSpec{
-		Type:    ebpf.CGroupSKB,
-		License: "MIT",
-		Instructions: asm.Instructions{
-			asm.Mov.Imm(asm.R0, 0),
-			asm.Return(),
-		},
-	})
-	if err != nil {
-		return internal.ErrNotSupported
-	}
-
-	// BPF_PROG_ATTACH was introduced at the same time as CGgroupSKB,
-	// so being able to load the program is enough to infer that we
-	// have the syscall.
-	prog.Close()
-	return nil
-})
-
-var haveProgAttachReplace = internal.NewFeatureTest("BPF_PROG_ATTACH atomic replacement of MULTI progs", "5.5", func() error {
-	if err := haveProgAttach(); err != nil {
-		return err
-	}
-
-	prog, err := ebpf.NewProgram(&ebpf.ProgramSpec{
-		Type:       ebpf.CGroupSKB,
-		AttachType: ebpf.AttachCGroupInetIngress,
-		License:    "MIT",
-		Instructions: asm.Instructions{
-			asm.Mov.Imm(asm.R0, 0),
-			asm.Return(),
-		},
-	})
-	if err != nil {
-		return internal.ErrNotSupported
-	}
-	defer prog.Close()
-
-	// We know that we have BPF_PROG_ATTACH since we can load CGroupSKB programs.
-	// If passing BPF_F_REPLACE gives us EINVAL we know that the feature isn't
-	// present.
-	attr := sys.ProgAttachAttr{
-		// We rely on this being checked after attachFlags.
-		TargetFd:    ^uint32(0),
-		AttachBpfFd: uint32(prog.FD()),
-		AttachType:  uint32(ebpf.AttachCGroupInetIngress),
-		AttachFlags: uint32(flagReplace),
-	}
-
-	err = sys.ProgAttach(&attr)
-	if errors.Is(err, unix.EINVAL) {
-		return internal.ErrNotSupported
-	}
-	if errors.Is(err, unix.EBADF) {
-		return nil
-	}
-	return err
-})
-
-var haveBPFLink = internal.NewFeatureTest("bpf_link", "5.7", func() error {
-	attr := sys.LinkCreateAttr{
-		// This is a hopefully invalid file descriptor, which triggers EBADF.
-		TargetFd:   ^uint32(0),
-		ProgFd:     ^uint32(0),
-		AttachType: sys.AttachType(ebpf.AttachCGroupInetIngress),
-	}
-	_, err := sys.LinkCreate(&attr)
-	if errors.Is(err, unix.EINVAL) {
-		return internal.ErrNotSupported
-	}
-	if errors.Is(err, unix.EBADF) {
-		return nil
-	}
-	return err
-})
-
-var haveProgQuery = internal.NewFeatureTest("BPF_PROG_QUERY", "4.15", func() error {
-	attr := sys.ProgQueryAttr{
-		// We rely on this being checked during the syscall.
-		// With an otherwise correct payload we expect EBADF here
-		// as an indication that the feature is present.
-		TargetFd:   ^uint32(0),
-		AttachType: sys.AttachType(ebpf.AttachCGroupInetIngress),
-	}
-
-	err := sys.ProgQuery(&attr)
-	if errors.Is(err, unix.EINVAL) {
-		return internal.ErrNotSupported
-	}
-	if errors.Is(err, unix.EBADF) {
-		return nil
-	}
-	return err
-})
diff --git a/vendor/github.com/cilium/ebpf/link/tracepoint.go b/vendor/github.com/cilium/ebpf/link/tracepoint.go
deleted file mode 100644
index 95f5fae3b..000000000
--- a/vendor/github.com/cilium/ebpf/link/tracepoint.go
+++ /dev/null
@@ -1,68 +0,0 @@
-package link
-
-import (
-	"fmt"
-
-	"github.com/cilium/ebpf"
-	"github.com/cilium/ebpf/internal/tracefs"
-)
-
-// TracepointOptions defines additional parameters that will be used
-// when loading Tracepoints.
-type TracepointOptions struct {
-	// Arbitrary value that can be fetched from an eBPF program
-	// via `bpf_get_attach_cookie()`.
-	//
-	// Needs kernel 5.15+.
-	Cookie uint64
-}
-
-// Tracepoint attaches the given eBPF program to the tracepoint with the given
-// group and name. See /sys/kernel/tracing/events to find available
-// tracepoints. The top-level directory is the group, the event's subdirectory
-// is the name. Example:
-//
-//	tp, err := Tracepoint("syscalls", "sys_enter_fork", prog, nil)
-//
-// Losing the reference to the resulting Link (tp) will close the Tracepoint
-// and prevent further execution of prog. The Link must be Closed during
-// program shutdown to avoid leaking system resources.
-//
-// Note that attaching eBPF programs to syscalls (sys_enter_*/sys_exit_*) is
-// only possible as of kernel 4.14 (commit cf5f5ce).
-func Tracepoint(group, name string, prog *ebpf.Program, opts *TracepointOptions) (Link, error) {
-	if group == "" || name == "" {
-		return nil, fmt.Errorf("group and name cannot be empty: %w", errInvalidInput)
-	}
-	if prog == nil {
-		return nil, fmt.Errorf("prog cannot be nil: %w", errInvalidInput)
-	}
-	if prog.Type() != ebpf.TracePoint {
-		return nil, fmt.Errorf("eBPF program type %s is not a Tracepoint: %w", prog.Type(), errInvalidInput)
-	}
-
-	tid, err := tracefs.EventID(group, name)
-	if err != nil {
-		return nil, err
-	}
-
-	fd, err := openTracepointPerfEvent(tid, perfAllThreads)
-	if err != nil {
-		return nil, err
-	}
-
-	var cookie uint64
-	if opts != nil {
-		cookie = opts.Cookie
-	}
-
-	pe := newPerfEvent(fd, nil)
-
-	lnk, err := attachPerfEvent(pe, prog, cookie)
-	if err != nil {
-		pe.Close()
-		return nil, err
-	}
-
-	return lnk, nil
-}
diff --git a/vendor/github.com/cilium/ebpf/link/tracing.go b/vendor/github.com/cilium/ebpf/link/tracing.go
deleted file mode 100644
index 1e1a7834d..000000000
--- a/vendor/github.com/cilium/ebpf/link/tracing.go
+++ /dev/null
@@ -1,199 +0,0 @@
-package link
-
-import (
-	"errors"
-	"fmt"
-
-	"github.com/cilium/ebpf"
-	"github.com/cilium/ebpf/btf"
-	"github.com/cilium/ebpf/internal/sys"
-	"github.com/cilium/ebpf/internal/unix"
-)
-
-type tracing struct {
-	RawLink
-}
-
-func (f *tracing) Update(new *ebpf.Program) error {
-	return fmt.Errorf("tracing update: %w", ErrNotSupported)
-}
-
-// AttachFreplace attaches the given eBPF program to the function it replaces.
-//
-// The program and name can either be provided at link time, or can be provided
-// at program load time. If they were provided at load time, they should be nil
-// and empty respectively here, as they will be ignored by the kernel.
-// Examples:
-//
-//	AttachFreplace(dispatcher, "function", replacement)
-//	AttachFreplace(nil, "", replacement)
-func AttachFreplace(targetProg *ebpf.Program, name string, prog *ebpf.Program) (Link, error) {
-	if (name == "") != (targetProg == nil) {
-		return nil, fmt.Errorf("must provide both or neither of name and targetProg: %w", errInvalidInput)
-	}
-	if prog == nil {
-		return nil, fmt.Errorf("prog cannot be nil: %w", errInvalidInput)
-	}
-	if prog.Type() != ebpf.Extension {
-		return nil, fmt.Errorf("eBPF program type %s is not an Extension: %w", prog.Type(), errInvalidInput)
-	}
-
-	var (
-		target int
-		typeID btf.TypeID
-	)
-	if targetProg != nil {
-		btfHandle, err := targetProg.Handle()
-		if err != nil {
-			return nil, err
-		}
-		defer btfHandle.Close()
-
-		spec, err := btfHandle.Spec(nil)
-		if err != nil {
-			return nil, err
-		}
-
-		var function *btf.Func
-		if err := spec.TypeByName(name, &function); err != nil {
-			return nil, err
-		}
-
-		target = targetProg.FD()
-		typeID, err = spec.TypeID(function)
-		if err != nil {
-			return nil, err
-		}
-	}
-
-	link, err := AttachRawLink(RawLinkOptions{
-		Target:  target,
-		Program: prog,
-		Attach:  ebpf.AttachNone,
-		BTF:     typeID,
-	})
-	if errors.Is(err, sys.ENOTSUPP) {
-		// This may be returned by bpf_tracing_prog_attach via bpf_arch_text_poke.
-		return nil, fmt.Errorf("create raw tracepoint: %w", ErrNotSupported)
-	}
-	if err != nil {
-		return nil, err
-	}
-
-	return &tracing{*link}, nil
-}
-
-type TracingOptions struct {
-	// Program must be of type Tracing with attach type
-	// AttachTraceFEntry/AttachTraceFExit/AttachModifyReturn or
-	// AttachTraceRawTp.
-	Program *ebpf.Program
-	// Program attach type. Can be one of:
-	// 	- AttachTraceFEntry
-	// 	- AttachTraceFExit
-	// 	- AttachModifyReturn
-	// 	- AttachTraceRawTp
-	// This field is optional.
-	AttachType ebpf.AttachType
-	// Arbitrary value that can be fetched from an eBPF program
-	// via `bpf_get_attach_cookie()`.
-	Cookie uint64
-}
-
-type LSMOptions struct {
-	// Program must be of type LSM with attach type
-	// AttachLSMMac.
-	Program *ebpf.Program
-	// Arbitrary value that can be fetched from an eBPF program
-	// via `bpf_get_attach_cookie()`.
-	Cookie uint64
-}
-
-// attachBTFID links all BPF program types (Tracing/LSM) that they attach to a btf_id.
-func attachBTFID(program *ebpf.Program, at ebpf.AttachType, cookie uint64) (Link, error) {
-	if program.FD() < 0 {
-		return nil, fmt.Errorf("invalid program %w", sys.ErrClosedFd)
-	}
-
-	var (
-		fd  *sys.FD
-		err error
-	)
-	switch at {
-	case ebpf.AttachTraceFEntry, ebpf.AttachTraceFExit, ebpf.AttachTraceRawTp,
-		ebpf.AttachModifyReturn, ebpf.AttachLSMMac:
-		// Attach via BPF link
-		fd, err = sys.LinkCreateTracing(&sys.LinkCreateTracingAttr{
-			ProgFd:     uint32(program.FD()),
-			AttachType: sys.AttachType(at),
-			Cookie:     cookie,
-		})
-		if err == nil {
-			break
-		}
-		if !errors.Is(err, unix.EINVAL) && !errors.Is(err, sys.ENOTSUPP) {
-			return nil, fmt.Errorf("create tracing link: %w", err)
-		}
-		fallthrough
-	case ebpf.AttachNone:
-		// Attach via RawTracepointOpen
-		if cookie > 0 {
-			return nil, fmt.Errorf("create raw tracepoint with cookie: %w", ErrNotSupported)
-		}
-
-		fd, err = sys.RawTracepointOpen(&sys.RawTracepointOpenAttr{
-			ProgFd: uint32(program.FD()),
-		})
-		if errors.Is(err, sys.ENOTSUPP) {
-			// This may be returned by bpf_tracing_prog_attach via bpf_arch_text_poke.
-			return nil, fmt.Errorf("create raw tracepoint: %w", ErrNotSupported)
-		}
-		if err != nil {
-			return nil, fmt.Errorf("create raw tracepoint: %w", err)
-		}
-	default:
-		return nil, fmt.Errorf("invalid attach type: %s", at.String())
-	}
-
-	raw := RawLink{fd: fd}
-	info, err := raw.Info()
-	if err != nil {
-		raw.Close()
-		return nil, err
-	}
-
-	if info.Type == RawTracepointType {
-		// Sadness upon sadness: a Tracing program with AttachRawTp returns
-		// a raw_tracepoint link. Other types return a tracing link.
-		return &rawTracepoint{raw}, nil
-	}
-	return &tracing{raw}, nil
-}
-
-// AttachTracing links a tracing (fentry/fexit/fmod_ret) BPF program or
-// a BTF-powered raw tracepoint (tp_btf) BPF Program to a BPF hook defined
-// in kernel modules.
-func AttachTracing(opts TracingOptions) (Link, error) {
-	if t := opts.Program.Type(); t != ebpf.Tracing {
-		return nil, fmt.Errorf("invalid program type %s, expected Tracing", t)
-	}
-
-	switch opts.AttachType {
-	case ebpf.AttachTraceFEntry, ebpf.AttachTraceFExit, ebpf.AttachModifyReturn,
-		ebpf.AttachTraceRawTp, ebpf.AttachNone:
-	default:
-		return nil, fmt.Errorf("invalid attach type: %s", opts.AttachType.String())
-	}
-
-	return attachBTFID(opts.Program, opts.AttachType, opts.Cookie)
-}
-
-// AttachLSM links a Linux security module (LSM) BPF Program to a BPF
-// hook defined in kernel modules.
-func AttachLSM(opts LSMOptions) (Link, error) {
-	if t := opts.Program.Type(); t != ebpf.LSM {
-		return nil, fmt.Errorf("invalid program type %s, expected LSM", t)
-	}
-
-	return attachBTFID(opts.Program, ebpf.AttachLSMMac, opts.Cookie)
-}
diff --git a/vendor/github.com/cilium/ebpf/link/uprobe.go b/vendor/github.com/cilium/ebpf/link/uprobe.go
deleted file mode 100644
index 272bac415..000000000
--- a/vendor/github.com/cilium/ebpf/link/uprobe.go
+++ /dev/null
@@ -1,328 +0,0 @@
-package link
-
-import (
-	"debug/elf"
-	"errors"
-	"fmt"
-	"os"
-	"sync"
-
-	"github.com/cilium/ebpf"
-	"github.com/cilium/ebpf/internal"
-	"github.com/cilium/ebpf/internal/tracefs"
-)
-
-var (
-	uprobeRefCtrOffsetPMUPath = "/sys/bus/event_source/devices/uprobe/format/ref_ctr_offset"
-	// elixir.bootlin.com/linux/v5.15-rc7/source/kernel/events/core.c#L9799
-	uprobeRefCtrOffsetShift = 32
-	haveRefCtrOffsetPMU     = internal.NewFeatureTest("RefCtrOffsetPMU", "4.20", func() error {
-		_, err := os.Stat(uprobeRefCtrOffsetPMUPath)
-		if err != nil {
-			return internal.ErrNotSupported
-		}
-		return nil
-	})
-
-	// ErrNoSymbol indicates that the given symbol was not found
-	// in the ELF symbols table.
-	ErrNoSymbol = errors.New("not found")
-)
-
-// Executable defines an executable program on the filesystem.
-type Executable struct {
-	// Path of the executable on the filesystem.
-	path string
-	// Parsed ELF and dynamic symbols' addresses.
-	addresses map[string]uint64
-	// Keep track of symbol table lazy load.
-	addressesOnce sync.Once
-}
-
-// UprobeOptions defines additional parameters that will be used
-// when loading Uprobes.
-type UprobeOptions struct {
-	// Symbol address. Must be provided in case of external symbols (shared libs).
-	// If set, overrides the address eventually parsed from the executable.
-	Address uint64
-	// The offset relative to given symbol. Useful when tracing an arbitrary point
-	// inside the frame of given symbol.
-	//
-	// Note: this field changed from being an absolute offset to being relative
-	// to Address.
-	Offset uint64
-	// Only set the uprobe on the given process ID. Useful when tracing
-	// shared library calls or programs that have many running instances.
-	PID int
-	// Automatically manage SDT reference counts (semaphores).
-	//
-	// If this field is set, the Kernel will increment/decrement the
-	// semaphore located in the process memory at the provided address on
-	// probe attach/detach.
-	//
-	// See also:
-	// sourceware.org/systemtap/wiki/UserSpaceProbeImplementation (Semaphore Handling)
-	// github.com/torvalds/linux/commit/1cc33161a83d
-	// github.com/torvalds/linux/commit/a6ca88b241d5
-	RefCtrOffset uint64
-	// Arbitrary value that can be fetched from an eBPF program
-	// via `bpf_get_attach_cookie()`.
-	//
-	// Needs kernel 5.15+.
-	Cookie uint64
-	// Prefix used for the event name if the uprobe must be attached using tracefs.
-	// The group name will be formatted as `<prefix>_<randomstr>`.
-	// The default empty string is equivalent to "ebpf" as the prefix.
-	TraceFSPrefix string
-}
-
-func (uo *UprobeOptions) cookie() uint64 {
-	if uo == nil {
-		return 0
-	}
-	return uo.Cookie
-}
-
-// To open a new Executable, use:
-//
-//	OpenExecutable("/bin/bash")
-//
-// The returned value can then be used to open Uprobe(s).
-func OpenExecutable(path string) (*Executable, error) {
-	if path == "" {
-		return nil, fmt.Errorf("path cannot be empty")
-	}
-
-	f, err := internal.OpenSafeELFFile(path)
-	if err != nil {
-		return nil, fmt.Errorf("parse ELF file: %w", err)
-	}
-	defer f.Close()
-
-	if f.Type != elf.ET_EXEC && f.Type != elf.ET_DYN {
-		// ELF is not an executable or a shared object.
-		return nil, errors.New("the given file is not an executable or a shared object")
-	}
-
-	return &Executable{
-		path:      path,
-		addresses: make(map[string]uint64),
-	}, nil
-}
-
-func (ex *Executable) load(f *internal.SafeELFFile) error {
-	syms, err := f.Symbols()
-	if err != nil && !errors.Is(err, elf.ErrNoSymbols) {
-		return err
-	}
-
-	dynsyms, err := f.DynamicSymbols()
-	if err != nil && !errors.Is(err, elf.ErrNoSymbols) {
-		return err
-	}
-
-	syms = append(syms, dynsyms...)
-
-	for _, s := range syms {
-		if elf.ST_TYPE(s.Info) != elf.STT_FUNC {
-			// Symbol not associated with a function or other executable code.
-			continue
-		}
-
-		address := s.Value
-
-		// Loop over ELF segments.
-		for _, prog := range f.Progs {
-			// Skip uninteresting segments.
-			if prog.Type != elf.PT_LOAD || (prog.Flags&elf.PF_X) == 0 {
-				continue
-			}
-
-			if prog.Vaddr <= s.Value && s.Value < (prog.Vaddr+prog.Memsz) {
-				// If the symbol value is contained in the segment, calculate
-				// the symbol offset.
-				//
-				// fn symbol offset = fn symbol VA - .text VA + .text offset
-				//
-				// stackoverflow.com/a/40249502
-				address = s.Value - prog.Vaddr + prog.Off
-				break
-			}
-		}
-
-		ex.addresses[s.Name] = address
-	}
-
-	return nil
-}
-
-// address calculates the address of a symbol in the executable.
-//
-// opts must not be nil.
-func (ex *Executable) address(symbol string, opts *UprobeOptions) (uint64, error) {
-	if opts.Address > 0 {
-		return opts.Address + opts.Offset, nil
-	}
-
-	var err error
-	ex.addressesOnce.Do(func() {
-		var f *internal.SafeELFFile
-		f, err = internal.OpenSafeELFFile(ex.path)
-		if err != nil {
-			err = fmt.Errorf("parse ELF file: %w", err)
-			return
-		}
-		defer f.Close()
-
-		err = ex.load(f)
-	})
-	if err != nil {
-		return 0, fmt.Errorf("lazy load symbols: %w", err)
-	}
-
-	address, ok := ex.addresses[symbol]
-	if !ok {
-		return 0, fmt.Errorf("symbol %s: %w", symbol, ErrNoSymbol)
-	}
-
-	// Symbols with location 0 from section undef are shared library calls and
-	// are relocated before the binary is executed. Dynamic linking is not
-	// implemented by the library, so mark this as unsupported for now.
-	//
-	// Since only offset values are stored and not elf.Symbol, if the value is 0,
-	// assume it's an external symbol.
-	if address == 0 {
-		return 0, fmt.Errorf("cannot resolve %s library call '%s': %w "+
-			"(consider providing UprobeOptions.Address)", ex.path, symbol, ErrNotSupported)
-	}
-
-	return address + opts.Offset, nil
-}
-
-// Uprobe attaches the given eBPF program to a perf event that fires when the
-// given symbol starts executing in the given Executable.
-// For example, /bin/bash::main():
-//
-//	ex, _ = OpenExecutable("/bin/bash")
-//	ex.Uprobe("main", prog, nil)
-//
-// When using symbols which belongs to shared libraries,
-// an offset must be provided via options:
-//
-//	up, err := ex.Uprobe("main", prog, &UprobeOptions{Offset: 0x123})
-//
-// Note: Setting the Offset field in the options supersedes the symbol's offset.
-//
-// Losing the reference to the resulting Link (up) will close the Uprobe
-// and prevent further execution of prog. The Link must be Closed during
-// program shutdown to avoid leaking system resources.
-//
-// Functions provided by shared libraries can currently not be traced and
-// will result in an ErrNotSupported.
-func (ex *Executable) Uprobe(symbol string, prog *ebpf.Program, opts *UprobeOptions) (Link, error) {
-	u, err := ex.uprobe(symbol, prog, opts, false)
-	if err != nil {
-		return nil, err
-	}
-
-	lnk, err := attachPerfEvent(u, prog, opts.cookie())
-	if err != nil {
-		u.Close()
-		return nil, err
-	}
-
-	return lnk, nil
-}
-
-// Uretprobe attaches the given eBPF program to a perf event that fires right
-// before the given symbol exits. For example, /bin/bash::main():
-//
-//	ex, _ = OpenExecutable("/bin/bash")
-//	ex.Uretprobe("main", prog, nil)
-//
-// When using symbols which belongs to shared libraries,
-// an offset must be provided via options:
-//
-//	up, err := ex.Uretprobe("main", prog, &UprobeOptions{Offset: 0x123})
-//
-// Note: Setting the Offset field in the options supersedes the symbol's offset.
-//
-// Losing the reference to the resulting Link (up) will close the Uprobe
-// and prevent further execution of prog. The Link must be Closed during
-// program shutdown to avoid leaking system resources.
-//
-// Functions provided by shared libraries can currently not be traced and
-// will result in an ErrNotSupported.
-func (ex *Executable) Uretprobe(symbol string, prog *ebpf.Program, opts *UprobeOptions) (Link, error) {
-	u, err := ex.uprobe(symbol, prog, opts, true)
-	if err != nil {
-		return nil, err
-	}
-
-	lnk, err := attachPerfEvent(u, prog, opts.cookie())
-	if err != nil {
-		u.Close()
-		return nil, err
-	}
-
-	return lnk, nil
-}
-
-// uprobe opens a perf event for the given binary/symbol and attaches prog to it.
-// If ret is true, create a uretprobe.
-func (ex *Executable) uprobe(symbol string, prog *ebpf.Program, opts *UprobeOptions, ret bool) (*perfEvent, error) {
-	if prog == nil {
-		return nil, fmt.Errorf("prog cannot be nil: %w", errInvalidInput)
-	}
-	if prog.Type() != ebpf.Kprobe {
-		return nil, fmt.Errorf("eBPF program type %s is not Kprobe: %w", prog.Type(), errInvalidInput)
-	}
-	if opts == nil {
-		opts = &UprobeOptions{}
-	}
-
-	offset, err := ex.address(symbol, opts)
-	if err != nil {
-		return nil, err
-	}
-
-	pid := opts.PID
-	if pid == 0 {
-		pid = perfAllThreads
-	}
-
-	if opts.RefCtrOffset != 0 {
-		if err := haveRefCtrOffsetPMU(); err != nil {
-			return nil, fmt.Errorf("uprobe ref_ctr_offset: %w", err)
-		}
-	}
-
-	args := tracefs.ProbeArgs{
-		Type:         tracefs.Uprobe,
-		Symbol:       symbol,
-		Path:         ex.path,
-		Offset:       offset,
-		Pid:          pid,
-		RefCtrOffset: opts.RefCtrOffset,
-		Ret:          ret,
-		Cookie:       opts.Cookie,
-		Group:        opts.TraceFSPrefix,
-	}
-
-	// Use uprobe PMU if the kernel has it available.
-	tp, err := pmuProbe(args)
-	if err == nil {
-		return tp, nil
-	}
-	if err != nil && !errors.Is(err, ErrNotSupported) {
-		return nil, fmt.Errorf("creating perf_uprobe PMU: %w", err)
-	}
-
-	// Use tracefs if uprobe PMU is missing.
-	tp, err = tracefsProbe(args)
-	if err != nil {
-		return nil, fmt.Errorf("creating trace event '%s:%s' in tracefs: %w", ex.path, symbol, err)
-	}
-
-	return tp, nil
-}
diff --git a/vendor/github.com/cilium/ebpf/link/xdp.go b/vendor/github.com/cilium/ebpf/link/xdp.go
deleted file mode 100644
index aa8dd3a4c..000000000
--- a/vendor/github.com/cilium/ebpf/link/xdp.go
+++ /dev/null
@@ -1,54 +0,0 @@
-package link
-
-import (
-	"fmt"
-
-	"github.com/cilium/ebpf"
-)
-
-// XDPAttachFlags represents how XDP program will be attached to interface.
-type XDPAttachFlags uint32
-
-const (
-	// XDPGenericMode (SKB) links XDP BPF program for drivers which do
-	// not yet support native XDP.
-	XDPGenericMode XDPAttachFlags = 1 << (iota + 1)
-	// XDPDriverMode links XDP BPF program into the driver’s receive path.
-	XDPDriverMode
-	// XDPOffloadMode offloads the entire XDP BPF program into hardware.
-	XDPOffloadMode
-)
-
-type XDPOptions struct {
-	// Program must be an XDP BPF program.
-	Program *ebpf.Program
-
-	// Interface is the interface index to attach program to.
-	Interface int
-
-	// Flags is one of XDPAttachFlags (optional).
-	//
-	// Only one XDP mode should be set, without flag defaults
-	// to driver/generic mode (best effort).
-	Flags XDPAttachFlags
-}
-
-// AttachXDP links an XDP BPF program to an XDP hook.
-func AttachXDP(opts XDPOptions) (Link, error) {
-	if t := opts.Program.Type(); t != ebpf.XDP {
-		return nil, fmt.Errorf("invalid program type %s, expected XDP", t)
-	}
-
-	if opts.Interface < 1 {
-		return nil, fmt.Errorf("invalid interface index: %d", opts.Interface)
-	}
-
-	rawLink, err := AttachRawLink(RawLinkOptions{
-		Program: opts.Program,
-		Attach:  ebpf.AttachXDP,
-		Target:  opts.Interface,
-		Flags:   uint32(opts.Flags),
-	})
-
-	return rawLink, err
-}
diff --git a/vendor/github.com/cilium/ebpf/linker.go b/vendor/github.com/cilium/ebpf/linker.go
deleted file mode 100644
index e0dbfcffd..000000000
--- a/vendor/github.com/cilium/ebpf/linker.go
+++ /dev/null
@@ -1,391 +0,0 @@
-package ebpf
-
-import (
-	"encoding/binary"
-	"errors"
-	"fmt"
-	"io"
-	"math"
-
-	"github.com/cilium/ebpf/asm"
-	"github.com/cilium/ebpf/btf"
-	"github.com/cilium/ebpf/internal"
-)
-
-// handles stores handle objects to avoid gc cleanup
-type handles []*btf.Handle
-
-func (hs *handles) add(h *btf.Handle) (int, error) {
-	if h == nil {
-		return 0, nil
-	}
-
-	if len(*hs) == math.MaxInt16 {
-		return 0, fmt.Errorf("can't add more than %d module FDs to fdArray", math.MaxInt16)
-	}
-
-	*hs = append(*hs, h)
-
-	// return length of slice so that indexes start at 1
-	return len(*hs), nil
-}
-
-func (hs handles) fdArray() []int32 {
-	// first element of fda is reserved as no module can be indexed with 0
-	fda := []int32{0}
-	for _, h := range hs {
-		fda = append(fda, int32(h.FD()))
-	}
-
-	return fda
-}
-
-func (hs handles) close() {
-	for _, h := range hs {
-		h.Close()
-	}
-}
-
-// splitSymbols splits insns into subsections delimited by Symbol Instructions.
-// insns cannot be empty and must start with a Symbol Instruction.
-//
-// The resulting map is indexed by Symbol name.
-func splitSymbols(insns asm.Instructions) (map[string]asm.Instructions, error) {
-	if len(insns) == 0 {
-		return nil, errors.New("insns is empty")
-	}
-
-	if insns[0].Symbol() == "" {
-		return nil, errors.New("insns must start with a Symbol")
-	}
-
-	var name string
-	progs := make(map[string]asm.Instructions)
-	for _, ins := range insns {
-		if sym := ins.Symbol(); sym != "" {
-			if progs[sym] != nil {
-				return nil, fmt.Errorf("insns contains duplicate Symbol %s", sym)
-			}
-			name = sym
-		}
-
-		progs[name] = append(progs[name], ins)
-	}
-
-	return progs, nil
-}
-
-// The linker is responsible for resolving bpf-to-bpf calls between programs
-// within an ELF. Each BPF program must be a self-contained binary blob,
-// so when an instruction in one ELF program section wants to jump to
-// a function in another, the linker needs to pull in the bytecode
-// (and BTF info) of the target function and concatenate the instruction
-// streams.
-//
-// Later on in the pipeline, all call sites are fixed up with relative jumps
-// within this newly-created instruction stream to then finally hand off to
-// the kernel with BPF_PROG_LOAD.
-//
-// Each function is denoted by an ELF symbol and the compiler takes care of
-// register setup before each jump instruction.
-
-// hasFunctionReferences returns true if insns contains one or more bpf2bpf
-// function references.
-func hasFunctionReferences(insns asm.Instructions) bool {
-	for _, i := range insns {
-		if i.IsFunctionReference() {
-			return true
-		}
-	}
-	return false
-}
-
-// applyRelocations collects and applies any CO-RE relocations in insns.
-//
-// Passing a nil target will relocate against the running kernel. insns are
-// modified in place.
-func applyRelocations(insns asm.Instructions, target *btf.Spec, bo binary.ByteOrder) error {
-	var relos []*btf.CORERelocation
-	var reloInsns []*asm.Instruction
-	iter := insns.Iterate()
-	for iter.Next() {
-		if relo := btf.CORERelocationMetadata(iter.Ins); relo != nil {
-			relos = append(relos, relo)
-			reloInsns = append(reloInsns, iter.Ins)
-		}
-	}
-
-	if len(relos) == 0 {
-		return nil
-	}
-
-	if bo == nil {
-		bo = internal.NativeEndian
-	}
-
-	fixups, err := btf.CORERelocate(relos, target, bo)
-	if err != nil {
-		return err
-	}
-
-	for i, fixup := range fixups {
-		if err := fixup.Apply(reloInsns[i]); err != nil {
-			return fmt.Errorf("fixup for %s: %w", relos[i], err)
-		}
-	}
-
-	return nil
-}
-
-// flattenPrograms resolves bpf-to-bpf calls for a set of programs.
-//
-// Links all programs in names by modifying their ProgramSpec in progs.
-func flattenPrograms(progs map[string]*ProgramSpec, names []string) {
-	// Pre-calculate all function references.
-	refs := make(map[*ProgramSpec][]string)
-	for _, prog := range progs {
-		refs[prog] = prog.Instructions.FunctionReferences()
-	}
-
-	// Create a flattened instruction stream, but don't modify progs yet to
-	// avoid linking multiple times.
-	flattened := make([]asm.Instructions, 0, len(names))
-	for _, name := range names {
-		flattened = append(flattened, flattenInstructions(name, progs, refs))
-	}
-
-	// Finally, assign the flattened instructions.
-	for i, name := range names {
-		progs[name].Instructions = flattened[i]
-	}
-}
-
-// flattenInstructions resolves bpf-to-bpf calls for a single program.
-//
-// Flattens the instructions of prog by concatenating the instructions of all
-// direct and indirect dependencies.
-//
-// progs contains all referenceable programs, while refs contain the direct
-// dependencies of each program.
-func flattenInstructions(name string, progs map[string]*ProgramSpec, refs map[*ProgramSpec][]string) asm.Instructions {
-	prog := progs[name]
-
-	insns := make(asm.Instructions, len(prog.Instructions))
-	copy(insns, prog.Instructions)
-
-	// Add all direct references of prog to the list of to be linked programs.
-	pending := make([]string, len(refs[prog]))
-	copy(pending, refs[prog])
-
-	// All references for which we've appended instructions.
-	linked := make(map[string]bool)
-
-	// Iterate all pending references. We can't use a range since pending is
-	// modified in the body below.
-	for len(pending) > 0 {
-		var ref string
-		ref, pending = pending[0], pending[1:]
-
-		if linked[ref] {
-			// We've already linked this ref, don't append instructions again.
-			continue
-		}
-
-		progRef := progs[ref]
-		if progRef == nil {
-			// We don't have instructions that go with this reference. This
-			// happens when calling extern functions.
-			continue
-		}
-
-		insns = append(insns, progRef.Instructions...)
-		linked[ref] = true
-
-		// Make sure we link indirect references.
-		pending = append(pending, refs[progRef]...)
-	}
-
-	return insns
-}
-
-// fixupAndValidate is called by the ELF reader right before marshaling the
-// instruction stream. It performs last-minute adjustments to the program and
-// runs some sanity checks before sending it off to the kernel.
-func fixupAndValidate(insns asm.Instructions) error {
-	iter := insns.Iterate()
-	for iter.Next() {
-		ins := iter.Ins
-
-		// Map load was tagged with a Reference, but does not contain a Map pointer.
-		needsMap := ins.Reference() != "" || ins.Metadata.Get(kconfigMetaKey{}) != nil
-		if ins.IsLoadFromMap() && needsMap && ins.Map() == nil {
-			return fmt.Errorf("instruction %d: %w", iter.Index, asm.ErrUnsatisfiedMapReference)
-		}
-
-		fixupProbeReadKernel(ins)
-	}
-
-	return nil
-}
-
-// fixupKfuncs loops over all instructions in search for kfunc calls.
-// If at least one is found, the current kernels BTF and module BTFis are searched to set Instruction.Constant
-// and Instruction.Offset to the correct values.
-func fixupKfuncs(insns asm.Instructions) (handles, error) {
-	iter := insns.Iterate()
-	for iter.Next() {
-		ins := iter.Ins
-		if ins.IsKfuncCall() {
-			goto fixups
-		}
-	}
-
-	return nil, nil
-
-fixups:
-	// only load the kernel spec if we found at least one kfunc call
-	kernelSpec, err := btf.LoadKernelSpec()
-	if err != nil {
-		return nil, err
-	}
-
-	fdArray := make(handles, 0)
-	for {
-		ins := iter.Ins
-
-		if !ins.IsKfuncCall() {
-			if !iter.Next() {
-				// break loop if this was the last instruction in the stream.
-				break
-			}
-			continue
-		}
-
-		// check meta, if no meta return err
-		kfm, _ := ins.Metadata.Get(kfuncMeta{}).(*btf.Func)
-		if kfm == nil {
-			return nil, fmt.Errorf("kfunc call has no kfuncMeta")
-		}
-
-		target := btf.Type((*btf.Func)(nil))
-		spec, module, err := findTargetInKernel(kernelSpec, kfm.Name, &target)
-		if errors.Is(err, btf.ErrNotFound) {
-			return nil, fmt.Errorf("kfunc %q: %w", kfm.Name, ErrNotSupported)
-		}
-		if err != nil {
-			return nil, err
-		}
-
-		if err := btf.CheckTypeCompatibility(kfm.Type, target.(*btf.Func).Type); err != nil {
-			return nil, &incompatibleKfuncError{kfm.Name, err}
-		}
-
-		id, err := spec.TypeID(target)
-		if err != nil {
-			return nil, err
-		}
-
-		idx, err := fdArray.add(module)
-		if err != nil {
-			return nil, err
-		}
-
-		ins.Constant = int64(id)
-		ins.Offset = int16(idx)
-
-		if !iter.Next() {
-			break
-		}
-	}
-
-	return fdArray, nil
-}
-
-type incompatibleKfuncError struct {
-	name string
-	err  error
-}
-
-func (ike *incompatibleKfuncError) Error() string {
-	return fmt.Sprintf("kfunc %q: %s", ike.name, ike.err)
-}
-
-// fixupProbeReadKernel replaces calls to bpf_probe_read_{kernel,user}(_str)
-// with bpf_probe_read(_str) on kernels that don't support it yet.
-func fixupProbeReadKernel(ins *asm.Instruction) {
-	if !ins.IsBuiltinCall() {
-		return
-	}
-
-	// Kernel supports bpf_probe_read_kernel, nothing to do.
-	if haveProbeReadKernel() == nil {
-		return
-	}
-
-	switch asm.BuiltinFunc(ins.Constant) {
-	case asm.FnProbeReadKernel, asm.FnProbeReadUser:
-		ins.Constant = int64(asm.FnProbeRead)
-	case asm.FnProbeReadKernelStr, asm.FnProbeReadUserStr:
-		ins.Constant = int64(asm.FnProbeReadStr)
-	}
-}
-
-// resolveKconfigReferences creates and populates a .kconfig map if necessary.
-//
-// Returns a nil Map and no error if no references exist.
-func resolveKconfigReferences(insns asm.Instructions) (_ *Map, err error) {
-	closeOnError := func(c io.Closer) {
-		if err != nil {
-			c.Close()
-		}
-	}
-
-	var spec *MapSpec
-	iter := insns.Iterate()
-	for iter.Next() {
-		meta, _ := iter.Ins.Metadata.Get(kconfigMetaKey{}).(*kconfigMeta)
-		if meta != nil {
-			spec = meta.Map
-			break
-		}
-	}
-
-	if spec == nil {
-		return nil, nil
-	}
-
-	cpy := spec.Copy()
-	if err := resolveKconfig(cpy); err != nil {
-		return nil, err
-	}
-
-	kconfig, err := NewMap(cpy)
-	if err != nil {
-		return nil, err
-	}
-	defer closeOnError(kconfig)
-
-	// Resolve all instructions which load from .kconfig map with actual map
-	// and offset inside it.
-	iter = insns.Iterate()
-	for iter.Next() {
-		meta, _ := iter.Ins.Metadata.Get(kconfigMetaKey{}).(*kconfigMeta)
-		if meta == nil {
-			continue
-		}
-
-		if meta.Map != spec {
-			return nil, fmt.Errorf("instruction %d: reference to multiple .kconfig maps is not allowed", iter.Index)
-		}
-
-		if err := iter.Ins.AssociateMap(kconfig); err != nil {
-			return nil, fmt.Errorf("instruction %d: %w", iter.Index, err)
-		}
-
-		// Encode a map read at the offset of the var in the datasec.
-		iter.Ins.Constant = int64(uint64(meta.Offset) << 32)
-		iter.Ins.Metadata.Set(kconfigMetaKey{}, nil)
-	}
-
-	return kconfig, nil
-}
diff --git a/vendor/github.com/cilium/ebpf/map.go b/vendor/github.com/cilium/ebpf/map.go
deleted file mode 100644
index a11664cc7..000000000
--- a/vendor/github.com/cilium/ebpf/map.go
+++ /dev/null
@@ -1,1478 +0,0 @@
-package ebpf
-
-import (
-	"bytes"
-	"errors"
-	"fmt"
-	"io"
-	"math/rand"
-	"os"
-	"path/filepath"
-	"reflect"
-	"time"
-	"unsafe"
-
-	"github.com/cilium/ebpf/btf"
-	"github.com/cilium/ebpf/internal"
-	"github.com/cilium/ebpf/internal/sys"
-	"github.com/cilium/ebpf/internal/unix"
-)
-
-// Errors returned by Map and MapIterator methods.
-var (
-	ErrKeyNotExist      = errors.New("key does not exist")
-	ErrKeyExist         = errors.New("key already exists")
-	ErrIterationAborted = errors.New("iteration aborted")
-	ErrMapIncompatible  = errors.New("map spec is incompatible with existing map")
-	errMapNoBTFValue    = errors.New("map spec does not contain a BTF Value")
-)
-
-// MapOptions control loading a map into the kernel.
-type MapOptions struct {
-	// The base path to pin maps in if requested via PinByName.
-	// Existing maps will be re-used if they are compatible, otherwise an
-	// error is returned.
-	PinPath        string
-	LoadPinOptions LoadPinOptions
-}
-
-// MapID represents the unique ID of an eBPF map
-type MapID uint32
-
-// MapSpec defines a Map.
-type MapSpec struct {
-	// Name is passed to the kernel as a debug aid. Must only contain
-	// alpha numeric and '_' characters.
-	Name       string
-	Type       MapType
-	KeySize    uint32
-	ValueSize  uint32
-	MaxEntries uint32
-
-	// Flags is passed to the kernel and specifies additional map
-	// creation attributes.
-	Flags uint32
-
-	// Automatically pin and load a map from MapOptions.PinPath.
-	// Generates an error if an existing pinned map is incompatible with the MapSpec.
-	Pinning PinType
-
-	// Specify numa node during map creation
-	// (effective only if unix.BPF_F_NUMA_NODE flag is set,
-	// which can be imported from golang.org/x/sys/unix)
-	NumaNode uint32
-
-	// The initial contents of the map. May be nil.
-	Contents []MapKV
-
-	// Whether to freeze a map after setting its initial contents.
-	Freeze bool
-
-	// InnerMap is used as a template for ArrayOfMaps and HashOfMaps
-	InnerMap *MapSpec
-
-	// Extra trailing bytes found in the ELF map definition when using structs
-	// larger than libbpf's bpf_map_def. nil if no trailing bytes were present.
-	// Must be nil or empty before instantiating the MapSpec into a Map.
-	Extra *bytes.Reader
-
-	// The key and value type of this map. May be nil.
-	Key, Value btf.Type
-}
-
-func (ms *MapSpec) String() string {
-	return fmt.Sprintf("%s(keySize=%d, valueSize=%d, maxEntries=%d, flags=%d)", ms.Type, ms.KeySize, ms.ValueSize, ms.MaxEntries, ms.Flags)
-}
-
-// Copy returns a copy of the spec.
-//
-// MapSpec.Contents is a shallow copy.
-func (ms *MapSpec) Copy() *MapSpec {
-	if ms == nil {
-		return nil
-	}
-
-	cpy := *ms
-
-	cpy.Contents = make([]MapKV, len(ms.Contents))
-	copy(cpy.Contents, ms.Contents)
-
-	cpy.InnerMap = ms.InnerMap.Copy()
-
-	return &cpy
-}
-
-func (ms *MapSpec) clampPerfEventArraySize() error {
-	if ms.Type != PerfEventArray {
-		return nil
-	}
-
-	n, err := internal.PossibleCPUs()
-	if err != nil {
-		return fmt.Errorf("perf event array: %w", err)
-	}
-
-	if n := uint32(n); ms.MaxEntries > n {
-		ms.MaxEntries = n
-	}
-
-	return nil
-}
-
-// dataSection returns the contents and BTF Datasec descriptor of the spec.
-func (ms *MapSpec) dataSection() ([]byte, *btf.Datasec, error) {
-
-	if ms.Value == nil {
-		return nil, nil, errMapNoBTFValue
-	}
-
-	ds, ok := ms.Value.(*btf.Datasec)
-	if !ok {
-		return nil, nil, fmt.Errorf("map value BTF is a %T, not a *btf.Datasec", ms.Value)
-	}
-
-	if n := len(ms.Contents); n != 1 {
-		return nil, nil, fmt.Errorf("expected one key, found %d", n)
-	}
-
-	kv := ms.Contents[0]
-	value, ok := kv.Value.([]byte)
-	if !ok {
-		return nil, nil, fmt.Errorf("value at first map key is %T, not []byte", kv.Value)
-	}
-
-	return value, ds, nil
-}
-
-// MapKV is used to initialize the contents of a Map.
-type MapKV struct {
-	Key   interface{}
-	Value interface{}
-}
-
-// Compatible returns nil if an existing map may be used instead of creating
-// one from the spec.
-//
-// Returns an error wrapping [ErrMapIncompatible] otherwise.
-func (ms *MapSpec) Compatible(m *Map) error {
-	switch {
-	case m.typ != ms.Type:
-		return fmt.Errorf("expected type %v, got %v: %w", ms.Type, m.typ, ErrMapIncompatible)
-
-	case m.keySize != ms.KeySize:
-		return fmt.Errorf("expected key size %v, got %v: %w", ms.KeySize, m.keySize, ErrMapIncompatible)
-
-	case m.valueSize != ms.ValueSize:
-		return fmt.Errorf("expected value size %v, got %v: %w", ms.ValueSize, m.valueSize, ErrMapIncompatible)
-
-	case !(ms.Type == PerfEventArray && ms.MaxEntries == 0) &&
-		m.maxEntries != ms.MaxEntries:
-		return fmt.Errorf("expected max entries %v, got %v: %w", ms.MaxEntries, m.maxEntries, ErrMapIncompatible)
-
-	// BPF_F_RDONLY_PROG is set unconditionally for devmaps. Explicitly allow
-	// this mismatch.
-	case !((ms.Type == DevMap || ms.Type == DevMapHash) && m.flags^ms.Flags == unix.BPF_F_RDONLY_PROG) &&
-		m.flags != ms.Flags:
-		return fmt.Errorf("expected flags %v, got %v: %w", ms.Flags, m.flags, ErrMapIncompatible)
-	}
-	return nil
-}
-
-// Map represents a Map file descriptor.
-//
-// It is not safe to close a map which is used by other goroutines.
-//
-// Methods which take interface{} arguments by default encode
-// them using binary.Read/Write in the machine's native endianness.
-//
-// Implement encoding.BinaryMarshaler or encoding.BinaryUnmarshaler
-// if you require custom encoding.
-type Map struct {
-	name       string
-	fd         *sys.FD
-	typ        MapType
-	keySize    uint32
-	valueSize  uint32
-	maxEntries uint32
-	flags      uint32
-	pinnedPath string
-	// Per CPU maps return values larger than the size in the spec
-	fullValueSize int
-}
-
-// NewMapFromFD creates a map from a raw fd.
-//
-// You should not use fd after calling this function.
-func NewMapFromFD(fd int) (*Map, error) {
-	f, err := sys.NewFD(fd)
-	if err != nil {
-		return nil, err
-	}
-
-	return newMapFromFD(f)
-}
-
-func newMapFromFD(fd *sys.FD) (*Map, error) {
-	info, err := newMapInfoFromFd(fd)
-	if err != nil {
-		fd.Close()
-		return nil, fmt.Errorf("get map info: %w", err)
-	}
-
-	return newMap(fd, info.Name, info.Type, info.KeySize, info.ValueSize, info.MaxEntries, info.Flags)
-}
-
-// NewMap creates a new Map.
-//
-// It's equivalent to calling NewMapWithOptions with default options.
-func NewMap(spec *MapSpec) (*Map, error) {
-	return NewMapWithOptions(spec, MapOptions{})
-}
-
-// NewMapWithOptions creates a new Map.
-//
-// Creating a map for the first time will perform feature detection
-// by creating small, temporary maps.
-//
-// The caller is responsible for ensuring the process' rlimit is set
-// sufficiently high for locking memory during map creation. This can be done
-// by calling rlimit.RemoveMemlock() prior to calling NewMapWithOptions.
-//
-// May return an error wrapping ErrMapIncompatible.
-func NewMapWithOptions(spec *MapSpec, opts MapOptions) (*Map, error) {
-	m, err := newMapWithOptions(spec, opts)
-	if err != nil {
-		return nil, fmt.Errorf("creating map: %w", err)
-	}
-
-	if err := m.finalize(spec); err != nil {
-		m.Close()
-		return nil, fmt.Errorf("populating map: %w", err)
-	}
-
-	return m, nil
-}
-
-func newMapWithOptions(spec *MapSpec, opts MapOptions) (_ *Map, err error) {
-	closeOnError := func(c io.Closer) {
-		if err != nil {
-			c.Close()
-		}
-	}
-
-	switch spec.Pinning {
-	case PinByName:
-		if spec.Name == "" {
-			return nil, fmt.Errorf("pin by name: missing Name")
-		}
-
-		if opts.PinPath == "" {
-			return nil, fmt.Errorf("pin by name: missing MapOptions.PinPath")
-		}
-
-		path := filepath.Join(opts.PinPath, spec.Name)
-		m, err := LoadPinnedMap(path, &opts.LoadPinOptions)
-		if errors.Is(err, unix.ENOENT) {
-			break
-		}
-		if err != nil {
-			return nil, fmt.Errorf("load pinned map: %w", err)
-		}
-		defer closeOnError(m)
-
-		if err := spec.Compatible(m); err != nil {
-			return nil, fmt.Errorf("use pinned map %s: %w", spec.Name, err)
-		}
-
-		return m, nil
-
-	case PinNone:
-		// Nothing to do here
-
-	default:
-		return nil, fmt.Errorf("pin type %d: %w", int(spec.Pinning), ErrNotSupported)
-	}
-
-	var innerFd *sys.FD
-	if spec.Type == ArrayOfMaps || spec.Type == HashOfMaps {
-		if spec.InnerMap == nil {
-			return nil, fmt.Errorf("%s requires InnerMap", spec.Type)
-		}
-
-		if spec.InnerMap.Pinning != PinNone {
-			return nil, errors.New("inner maps cannot be pinned")
-		}
-
-		template, err := spec.InnerMap.createMap(nil, opts)
-		if err != nil {
-			return nil, fmt.Errorf("inner map: %w", err)
-		}
-		defer template.Close()
-
-		// Intentionally skip populating and freezing (finalizing)
-		// the inner map template since it will be removed shortly.
-
-		innerFd = template.fd
-	}
-
-	m, err := spec.createMap(innerFd, opts)
-	if err != nil {
-		return nil, err
-	}
-	defer closeOnError(m)
-
-	if spec.Pinning == PinByName {
-		path := filepath.Join(opts.PinPath, spec.Name)
-		if err := m.Pin(path); err != nil {
-			return nil, fmt.Errorf("pin map to %s: %w", path, err)
-		}
-	}
-
-	return m, nil
-}
-
-// createMap validates the spec's properties and creates the map in the kernel
-// using the given opts. It does not populate or freeze the map.
-func (spec *MapSpec) createMap(inner *sys.FD, opts MapOptions) (_ *Map, err error) {
-	closeOnError := func(closer io.Closer) {
-		if err != nil {
-			closer.Close()
-		}
-	}
-
-	// Kernels 4.13 through 5.4 used a struct bpf_map_def that contained
-	// additional 'inner_map_idx' and later 'numa_node' fields.
-	// In order to support loading these definitions, tolerate the presence of
-	// extra bytes, but require them to be zeroes.
-	if spec.Extra != nil {
-		if _, err := io.Copy(internal.DiscardZeroes{}, spec.Extra); err != nil {
-			return nil, errors.New("extra contains unhandled non-zero bytes, drain before creating map")
-		}
-	}
-
-	switch spec.Type {
-	case ArrayOfMaps, HashOfMaps:
-		if err := haveNestedMaps(); err != nil {
-			return nil, err
-		}
-
-		if spec.ValueSize != 0 && spec.ValueSize != 4 {
-			return nil, errors.New("ValueSize must be zero or four for map of map")
-		}
-
-		spec = spec.Copy()
-		spec.ValueSize = 4
-
-	case PerfEventArray:
-		if spec.KeySize != 0 && spec.KeySize != 4 {
-			return nil, errors.New("KeySize must be zero or four for perf event array")
-		}
-
-		if spec.ValueSize != 0 && spec.ValueSize != 4 {
-			return nil, errors.New("ValueSize must be zero or four for perf event array")
-		}
-
-		spec = spec.Copy()
-		spec.KeySize = 4
-		spec.ValueSize = 4
-
-		if spec.MaxEntries == 0 {
-			n, err := internal.PossibleCPUs()
-			if err != nil {
-				return nil, fmt.Errorf("perf event array: %w", err)
-			}
-			spec.MaxEntries = uint32(n)
-		}
-	}
-
-	if spec.Flags&(unix.BPF_F_RDONLY_PROG|unix.BPF_F_WRONLY_PROG) > 0 || spec.Freeze {
-		if err := haveMapMutabilityModifiers(); err != nil {
-			return nil, fmt.Errorf("map create: %w", err)
-		}
-	}
-	if spec.Flags&unix.BPF_F_MMAPABLE > 0 {
-		if err := haveMmapableMaps(); err != nil {
-			return nil, fmt.Errorf("map create: %w", err)
-		}
-	}
-	if spec.Flags&unix.BPF_F_INNER_MAP > 0 {
-		if err := haveInnerMaps(); err != nil {
-			return nil, fmt.Errorf("map create: %w", err)
-		}
-	}
-	if spec.Flags&unix.BPF_F_NO_PREALLOC > 0 {
-		if err := haveNoPreallocMaps(); err != nil {
-			return nil, fmt.Errorf("map create: %w", err)
-		}
-	}
-
-	attr := sys.MapCreateAttr{
-		MapType:    sys.MapType(spec.Type),
-		KeySize:    spec.KeySize,
-		ValueSize:  spec.ValueSize,
-		MaxEntries: spec.MaxEntries,
-		MapFlags:   sys.MapFlags(spec.Flags),
-		NumaNode:   spec.NumaNode,
-	}
-
-	if inner != nil {
-		attr.InnerMapFd = inner.Uint()
-	}
-
-	if haveObjName() == nil {
-		attr.MapName = sys.NewObjName(spec.Name)
-	}
-
-	if spec.Key != nil || spec.Value != nil {
-		handle, keyTypeID, valueTypeID, err := btf.MarshalMapKV(spec.Key, spec.Value)
-		if err != nil && !errors.Is(err, btf.ErrNotSupported) {
-			return nil, fmt.Errorf("load BTF: %w", err)
-		}
-
-		if handle != nil {
-			defer handle.Close()
-
-			// Use BTF k/v during map creation.
-			attr.BtfFd = uint32(handle.FD())
-			attr.BtfKeyTypeId = keyTypeID
-			attr.BtfValueTypeId = valueTypeID
-		}
-	}
-
-	fd, err := sys.MapCreate(&attr)
-	// Some map types don't support BTF k/v in earlier kernel versions.
-	// Remove BTF metadata and retry map creation.
-	if (errors.Is(err, sys.ENOTSUPP) || errors.Is(err, unix.EINVAL)) && attr.BtfFd != 0 {
-		attr.BtfFd, attr.BtfKeyTypeId, attr.BtfValueTypeId = 0, 0, 0
-		fd, err = sys.MapCreate(&attr)
-	}
-
-	if err != nil {
-		if errors.Is(err, unix.EPERM) {
-			return nil, fmt.Errorf("map create: %w (MEMLOCK may be too low, consider rlimit.RemoveMemlock)", err)
-		}
-		if errors.Is(err, unix.EINVAL) && attr.MaxEntries == 0 {
-			return nil, fmt.Errorf("map create: %w (MaxEntries may be incorrectly set to zero)", err)
-		}
-		if errors.Is(err, unix.EINVAL) && spec.Type == UnspecifiedMap {
-			return nil, fmt.Errorf("map create: cannot use type %s", UnspecifiedMap)
-		}
-		if attr.BtfFd == 0 {
-			return nil, fmt.Errorf("map create: %w (without BTF k/v)", err)
-		}
-		return nil, fmt.Errorf("map create: %w", err)
-	}
-	defer closeOnError(fd)
-
-	m, err := newMap(fd, spec.Name, spec.Type, spec.KeySize, spec.ValueSize, spec.MaxEntries, spec.Flags)
-	if err != nil {
-		return nil, fmt.Errorf("map create: %w", err)
-	}
-
-	return m, nil
-}
-
-// newMap allocates and returns a new Map structure.
-// Sets the fullValueSize on per-CPU maps.
-func newMap(fd *sys.FD, name string, typ MapType, keySize, valueSize, maxEntries, flags uint32) (*Map, error) {
-	m := &Map{
-		name,
-		fd,
-		typ,
-		keySize,
-		valueSize,
-		maxEntries,
-		flags,
-		"",
-		int(valueSize),
-	}
-
-	if !typ.hasPerCPUValue() {
-		return m, nil
-	}
-
-	possibleCPUs, err := internal.PossibleCPUs()
-	if err != nil {
-		return nil, err
-	}
-
-	m.fullValueSize = int(internal.Align(valueSize, 8)) * possibleCPUs
-	return m, nil
-}
-
-func (m *Map) String() string {
-	if m.name != "" {
-		return fmt.Sprintf("%s(%s)#%v", m.typ, m.name, m.fd)
-	}
-	return fmt.Sprintf("%s#%v", m.typ, m.fd)
-}
-
-// Type returns the underlying type of the map.
-func (m *Map) Type() MapType {
-	return m.typ
-}
-
-// KeySize returns the size of the map key in bytes.
-func (m *Map) KeySize() uint32 {
-	return m.keySize
-}
-
-// ValueSize returns the size of the map value in bytes.
-func (m *Map) ValueSize() uint32 {
-	return m.valueSize
-}
-
-// MaxEntries returns the maximum number of elements the map can hold.
-func (m *Map) MaxEntries() uint32 {
-	return m.maxEntries
-}
-
-// Flags returns the flags of the map.
-func (m *Map) Flags() uint32 {
-	return m.flags
-}
-
-// Info returns metadata about the map.
-func (m *Map) Info() (*MapInfo, error) {
-	return newMapInfoFromFd(m.fd)
-}
-
-// MapLookupFlags controls the behaviour of the map lookup calls.
-type MapLookupFlags uint64
-
-// LookupLock look up the value of a spin-locked map.
-const LookupLock MapLookupFlags = 4
-
-// Lookup retrieves a value from a Map.
-//
-// Calls Close() on valueOut if it is of type **Map or **Program,
-// and *valueOut is not nil.
-//
-// Returns an error if the key doesn't exist, see ErrKeyNotExist.
-func (m *Map) Lookup(key, valueOut interface{}) error {
-	return m.LookupWithFlags(key, valueOut, 0)
-}
-
-// LookupWithFlags retrieves a value from a Map with flags.
-//
-// Passing LookupLock flag will look up the value of a spin-locked
-// map without returning the lock. This must be specified if the
-// elements contain a spinlock.
-//
-// Calls Close() on valueOut if it is of type **Map or **Program,
-// and *valueOut is not nil.
-//
-// Returns an error if the key doesn't exist, see ErrKeyNotExist.
-func (m *Map) LookupWithFlags(key, valueOut interface{}, flags MapLookupFlags) error {
-	if m.typ.hasPerCPUValue() {
-		return m.lookupPerCPU(key, valueOut, flags)
-	}
-
-	valuePtr, valueBytes := makeBuffer(valueOut, m.fullValueSize)
-	if err := m.lookup(key, valuePtr, flags); err != nil {
-		return err
-	}
-
-	return m.unmarshalValue(valueOut, valueBytes)
-}
-
-// LookupAndDelete retrieves and deletes a value from a Map.
-//
-// Returns ErrKeyNotExist if the key doesn't exist.
-func (m *Map) LookupAndDelete(key, valueOut interface{}) error {
-	return m.LookupAndDeleteWithFlags(key, valueOut, 0)
-}
-
-// LookupAndDeleteWithFlags retrieves and deletes a value from a Map.
-//
-// Passing LookupLock flag will look up and delete the value of a spin-locked
-// map without returning the lock. This must be specified if the elements
-// contain a spinlock.
-//
-// Returns ErrKeyNotExist if the key doesn't exist.
-func (m *Map) LookupAndDeleteWithFlags(key, valueOut interface{}, flags MapLookupFlags) error {
-	if m.typ.hasPerCPUValue() {
-		return m.lookupAndDeletePerCPU(key, valueOut, flags)
-	}
-
-	valuePtr, valueBytes := makeBuffer(valueOut, m.fullValueSize)
-	if err := m.lookupAndDelete(key, valuePtr, flags); err != nil {
-		return err
-	}
-	return m.unmarshalValue(valueOut, valueBytes)
-}
-
-// LookupBytes gets a value from Map.
-//
-// Returns a nil value if a key doesn't exist.
-func (m *Map) LookupBytes(key interface{}) ([]byte, error) {
-	valueBytes := make([]byte, m.fullValueSize)
-	valuePtr := sys.NewSlicePointer(valueBytes)
-
-	err := m.lookup(key, valuePtr, 0)
-	if errors.Is(err, ErrKeyNotExist) {
-		return nil, nil
-	}
-
-	return valueBytes, err
-}
-
-func (m *Map) lookupPerCPU(key, valueOut any, flags MapLookupFlags) error {
-	valueBytes := make([]byte, m.fullValueSize)
-	if err := m.lookup(key, sys.NewSlicePointer(valueBytes), flags); err != nil {
-		return err
-	}
-	return unmarshalPerCPUValue(valueOut, int(m.valueSize), valueBytes)
-}
-
-func (m *Map) lookup(key interface{}, valueOut sys.Pointer, flags MapLookupFlags) error {
-	keyPtr, err := m.marshalKey(key)
-	if err != nil {
-		return fmt.Errorf("can't marshal key: %w", err)
-	}
-
-	attr := sys.MapLookupElemAttr{
-		MapFd: m.fd.Uint(),
-		Key:   keyPtr,
-		Value: valueOut,
-		Flags: uint64(flags),
-	}
-
-	if err = sys.MapLookupElem(&attr); err != nil {
-		return fmt.Errorf("lookup: %w", wrapMapError(err))
-	}
-	return nil
-}
-
-func (m *Map) lookupAndDeletePerCPU(key, valueOut any, flags MapLookupFlags) error {
-	valueBytes := make([]byte, m.fullValueSize)
-	if err := m.lookupAndDelete(key, sys.NewSlicePointer(valueBytes), flags); err != nil {
-		return err
-	}
-	return unmarshalPerCPUValue(valueOut, int(m.valueSize), valueBytes)
-}
-
-func (m *Map) lookupAndDelete(key any, valuePtr sys.Pointer, flags MapLookupFlags) error {
-	keyPtr, err := m.marshalKey(key)
-	if err != nil {
-		return fmt.Errorf("can't marshal key: %w", err)
-	}
-
-	attr := sys.MapLookupAndDeleteElemAttr{
-		MapFd: m.fd.Uint(),
-		Key:   keyPtr,
-		Value: valuePtr,
-		Flags: uint64(flags),
-	}
-
-	if err := sys.MapLookupAndDeleteElem(&attr); err != nil {
-		return fmt.Errorf("lookup and delete: %w", wrapMapError(err))
-	}
-
-	return nil
-}
-
-// MapUpdateFlags controls the behaviour of the Map.Update call.
-//
-// The exact semantics depend on the specific MapType.
-type MapUpdateFlags uint64
-
-const (
-	// UpdateAny creates a new element or update an existing one.
-	UpdateAny MapUpdateFlags = iota
-	// UpdateNoExist creates a new element.
-	UpdateNoExist MapUpdateFlags = 1 << (iota - 1)
-	// UpdateExist updates an existing element.
-	UpdateExist
-	// UpdateLock updates elements under bpf_spin_lock.
-	UpdateLock
-)
-
-// Put replaces or creates a value in map.
-//
-// It is equivalent to calling Update with UpdateAny.
-func (m *Map) Put(key, value interface{}) error {
-	return m.Update(key, value, UpdateAny)
-}
-
-// Update changes the value of a key.
-func (m *Map) Update(key, value any, flags MapUpdateFlags) error {
-	if m.typ.hasPerCPUValue() {
-		return m.updatePerCPU(key, value, flags)
-	}
-
-	valuePtr, err := m.marshalValue(value)
-	if err != nil {
-		return fmt.Errorf("marshal value: %w", err)
-	}
-
-	return m.update(key, valuePtr, flags)
-}
-
-func (m *Map) updatePerCPU(key, value any, flags MapUpdateFlags) error {
-	valuePtr, err := marshalPerCPUValue(value, int(m.valueSize))
-	if err != nil {
-		return fmt.Errorf("marshal value: %w", err)
-	}
-
-	return m.update(key, valuePtr, flags)
-}
-
-func (m *Map) update(key any, valuePtr sys.Pointer, flags MapUpdateFlags) error {
-	keyPtr, err := m.marshalKey(key)
-	if err != nil {
-		return fmt.Errorf("marshal key: %w", err)
-	}
-
-	attr := sys.MapUpdateElemAttr{
-		MapFd: m.fd.Uint(),
-		Key:   keyPtr,
-		Value: valuePtr,
-		Flags: uint64(flags),
-	}
-
-	if err = sys.MapUpdateElem(&attr); err != nil {
-		return fmt.Errorf("update: %w", wrapMapError(err))
-	}
-
-	return nil
-}
-
-// Delete removes a value.
-//
-// Returns ErrKeyNotExist if the key does not exist.
-func (m *Map) Delete(key interface{}) error {
-	keyPtr, err := m.marshalKey(key)
-	if err != nil {
-		return fmt.Errorf("can't marshal key: %w", err)
-	}
-
-	attr := sys.MapDeleteElemAttr{
-		MapFd: m.fd.Uint(),
-		Key:   keyPtr,
-	}
-
-	if err = sys.MapDeleteElem(&attr); err != nil {
-		return fmt.Errorf("delete: %w", wrapMapError(err))
-	}
-	return nil
-}
-
-// NextKey finds the key following an initial key.
-//
-// See NextKeyBytes for details.
-//
-// Returns ErrKeyNotExist if there is no next key.
-func (m *Map) NextKey(key, nextKeyOut interface{}) error {
-	nextKeyPtr, nextKeyBytes := makeBuffer(nextKeyOut, int(m.keySize))
-
-	if err := m.nextKey(key, nextKeyPtr); err != nil {
-		return err
-	}
-
-	if err := m.unmarshalKey(nextKeyOut, nextKeyBytes); err != nil {
-		return fmt.Errorf("can't unmarshal next key: %w", err)
-	}
-	return nil
-}
-
-// NextKeyBytes returns the key following an initial key as a byte slice.
-//
-// Passing nil will return the first key.
-//
-// Use Iterate if you want to traverse all entries in the map.
-//
-// Returns nil if there are no more keys.
-func (m *Map) NextKeyBytes(key interface{}) ([]byte, error) {
-	nextKey := make([]byte, m.keySize)
-	nextKeyPtr := sys.NewSlicePointer(nextKey)
-
-	err := m.nextKey(key, nextKeyPtr)
-	if errors.Is(err, ErrKeyNotExist) {
-		return nil, nil
-	}
-
-	return nextKey, err
-}
-
-func (m *Map) nextKey(key interface{}, nextKeyOut sys.Pointer) error {
-	var (
-		keyPtr sys.Pointer
-		err    error
-	)
-
-	if key != nil {
-		keyPtr, err = m.marshalKey(key)
-		if err != nil {
-			return fmt.Errorf("can't marshal key: %w", err)
-		}
-	}
-
-	attr := sys.MapGetNextKeyAttr{
-		MapFd:   m.fd.Uint(),
-		Key:     keyPtr,
-		NextKey: nextKeyOut,
-	}
-
-	if err = sys.MapGetNextKey(&attr); err != nil {
-		// Kernels 4.4.131 and earlier return EFAULT instead of a pointer to the
-		// first map element when a nil key pointer is specified.
-		if key == nil && errors.Is(err, unix.EFAULT) {
-			var guessKey []byte
-			guessKey, err = m.guessNonExistentKey()
-			if err != nil {
-				return err
-			}
-
-			// Retry the syscall with a valid non-existing key.
-			attr.Key = sys.NewSlicePointer(guessKey)
-			if err = sys.MapGetNextKey(&attr); err == nil {
-				return nil
-			}
-		}
-
-		return fmt.Errorf("next key: %w", wrapMapError(err))
-	}
-
-	return nil
-}
-
-var mmapProtectedPage = internal.Memoize(func() ([]byte, error) {
-	return unix.Mmap(-1, 0, os.Getpagesize(), unix.PROT_NONE, unix.MAP_ANON|unix.MAP_SHARED)
-})
-
-// guessNonExistentKey attempts to perform a map lookup that returns ENOENT.
-// This is necessary on kernels before 4.4.132, since those don't support
-// iterating maps from the start by providing an invalid key pointer.
-func (m *Map) guessNonExistentKey() ([]byte, error) {
-	// Map a protected page and use that as the value pointer. This saves some
-	// work copying out the value, which we're not interested in.
-	page, err := mmapProtectedPage()
-	if err != nil {
-		return nil, err
-	}
-	valuePtr := sys.NewSlicePointer(page)
-
-	randKey := make([]byte, int(m.keySize))
-
-	for i := 0; i < 4; i++ {
-		switch i {
-		// For hash maps, the 0 key is less likely to be occupied. They're often
-		// used for storing data related to pointers, and their access pattern is
-		// generally scattered across the keyspace.
-		case 0:
-		// An all-0xff key is guaranteed to be out of bounds of any array, since
-		// those have a fixed key size of 4 bytes. The only corner case being
-		// arrays with 2^32 max entries, but those are prohibitively expensive
-		// in many environments.
-		case 1:
-			for r := range randKey {
-				randKey[r] = 0xff
-			}
-		// Inspired by BCC, 0x55 is an alternating binary pattern (0101), so
-		// is unlikely to be taken.
-		case 2:
-			for r := range randKey {
-				randKey[r] = 0x55
-			}
-		// Last ditch effort, generate a random key.
-		case 3:
-			rand.New(rand.NewSource(time.Now().UnixNano())).Read(randKey)
-		}
-
-		err := m.lookup(randKey, valuePtr, 0)
-		if errors.Is(err, ErrKeyNotExist) {
-			return randKey, nil
-		}
-	}
-
-	return nil, errors.New("couldn't find non-existing key")
-}
-
-// BatchLookup looks up many elements in a map at once.
-//
-// "keysOut" and "valuesOut" must be of type slice, a pointer
-// to a slice or buffer will not work.
-// "prevKey" is the key to start the batch lookup from, it will
-// *not* be included in the results. Use nil to start at the first key.
-//
-// ErrKeyNotExist is returned when the batch lookup has reached
-// the end of all possible results, even when partial results
-// are returned. It should be used to evaluate when lookup is "done".
-func (m *Map) BatchLookup(prevKey, nextKeyOut, keysOut, valuesOut interface{}, opts *BatchOptions) (int, error) {
-	return m.batchLookup(sys.BPF_MAP_LOOKUP_BATCH, prevKey, nextKeyOut, keysOut, valuesOut, opts)
-}
-
-// BatchLookupAndDelete looks up many elements in a map at once,
-//
-// It then deletes all those elements.
-// "keysOut" and "valuesOut" must be of type slice, a pointer
-// to a slice or buffer will not work.
-// "prevKey" is the key to start the batch lookup from, it will
-// *not* be included in the results. Use nil to start at the first key.
-//
-// ErrKeyNotExist is returned when the batch lookup has reached
-// the end of all possible results, even when partial results
-// are returned. It should be used to evaluate when lookup is "done".
-func (m *Map) BatchLookupAndDelete(prevKey, nextKeyOut, keysOut, valuesOut interface{}, opts *BatchOptions) (int, error) {
-	return m.batchLookup(sys.BPF_MAP_LOOKUP_AND_DELETE_BATCH, prevKey, nextKeyOut, keysOut, valuesOut, opts)
-}
-
-func (m *Map) batchLookup(cmd sys.Cmd, startKey, nextKeyOut, keysOut, valuesOut interface{}, opts *BatchOptions) (int, error) {
-	if err := haveBatchAPI(); err != nil {
-		return 0, err
-	}
-	if m.typ.hasPerCPUValue() {
-		return 0, ErrNotSupported
-	}
-	keysValue := reflect.ValueOf(keysOut)
-	if keysValue.Kind() != reflect.Slice {
-		return 0, fmt.Errorf("keys must be a slice")
-	}
-	valuesValue := reflect.ValueOf(valuesOut)
-	if valuesValue.Kind() != reflect.Slice {
-		return 0, fmt.Errorf("valuesOut must be a slice")
-	}
-	count := keysValue.Len()
-	if count != valuesValue.Len() {
-		return 0, fmt.Errorf("keysOut and valuesOut must be the same length")
-	}
-	keyBuf := make([]byte, count*int(m.keySize))
-	keyPtr := sys.NewSlicePointer(keyBuf)
-	valueBuf := make([]byte, count*int(m.fullValueSize))
-	valuePtr := sys.NewSlicePointer(valueBuf)
-	nextPtr, nextBuf := makeBuffer(nextKeyOut, int(m.keySize))
-
-	attr := sys.MapLookupBatchAttr{
-		MapFd:    m.fd.Uint(),
-		Keys:     keyPtr,
-		Values:   valuePtr,
-		Count:    uint32(count),
-		OutBatch: nextPtr,
-	}
-
-	if opts != nil {
-		attr.ElemFlags = opts.ElemFlags
-		attr.Flags = opts.Flags
-	}
-
-	var err error
-	if startKey != nil {
-		attr.InBatch, err = marshalPtr(startKey, int(m.keySize))
-		if err != nil {
-			return 0, err
-		}
-	}
-
-	_, sysErr := sys.BPF(cmd, unsafe.Pointer(&attr), unsafe.Sizeof(attr))
-	sysErr = wrapMapError(sysErr)
-	if sysErr != nil && !errors.Is(sysErr, unix.ENOENT) {
-		return 0, sysErr
-	}
-
-	err = m.unmarshalKey(nextKeyOut, nextBuf)
-	if err != nil {
-		return 0, err
-	}
-	err = unmarshalBytes(keysOut, keyBuf)
-	if err != nil {
-		return 0, err
-	}
-	err = unmarshalBytes(valuesOut, valueBuf)
-	if err != nil {
-		return 0, err
-	}
-
-	return int(attr.Count), sysErr
-}
-
-// BatchUpdate updates the map with multiple keys and values
-// simultaneously.
-// "keys" and "values" must be of type slice, a pointer
-// to a slice or buffer will not work.
-func (m *Map) BatchUpdate(keys, values interface{}, opts *BatchOptions) (int, error) {
-	if err := haveBatchAPI(); err != nil {
-		return 0, err
-	}
-	if m.typ.hasPerCPUValue() {
-		return 0, ErrNotSupported
-	}
-	keysValue := reflect.ValueOf(keys)
-	if keysValue.Kind() != reflect.Slice {
-		return 0, fmt.Errorf("keys must be a slice")
-	}
-	valuesValue := reflect.ValueOf(values)
-	if valuesValue.Kind() != reflect.Slice {
-		return 0, fmt.Errorf("values must be a slice")
-	}
-	var (
-		count    = keysValue.Len()
-		valuePtr sys.Pointer
-		err      error
-	)
-	if count != valuesValue.Len() {
-		return 0, fmt.Errorf("keys and values must be the same length")
-	}
-	keyPtr, err := marshalPtr(keys, count*int(m.keySize))
-	if err != nil {
-		return 0, err
-	}
-	valuePtr, err = marshalPtr(values, count*int(m.valueSize))
-	if err != nil {
-		return 0, err
-	}
-
-	attr := sys.MapUpdateBatchAttr{
-		MapFd:  m.fd.Uint(),
-		Keys:   keyPtr,
-		Values: valuePtr,
-		Count:  uint32(count),
-	}
-	if opts != nil {
-		attr.ElemFlags = opts.ElemFlags
-		attr.Flags = opts.Flags
-	}
-
-	err = sys.MapUpdateBatch(&attr)
-	if err != nil {
-		return int(attr.Count), fmt.Errorf("batch update: %w", wrapMapError(err))
-	}
-
-	return int(attr.Count), nil
-}
-
-// BatchDelete batch deletes entries in the map by keys.
-// "keys" must be of type slice, a pointer to a slice or buffer will not work.
-func (m *Map) BatchDelete(keys interface{}, opts *BatchOptions) (int, error) {
-	if err := haveBatchAPI(); err != nil {
-		return 0, err
-	}
-	if m.typ.hasPerCPUValue() {
-		return 0, ErrNotSupported
-	}
-	keysValue := reflect.ValueOf(keys)
-	if keysValue.Kind() != reflect.Slice {
-		return 0, fmt.Errorf("keys must be a slice")
-	}
-	count := keysValue.Len()
-	keyPtr, err := marshalPtr(keys, count*int(m.keySize))
-	if err != nil {
-		return 0, fmt.Errorf("cannot marshal keys: %v", err)
-	}
-
-	attr := sys.MapDeleteBatchAttr{
-		MapFd: m.fd.Uint(),
-		Keys:  keyPtr,
-		Count: uint32(count),
-	}
-
-	if opts != nil {
-		attr.ElemFlags = opts.ElemFlags
-		attr.Flags = opts.Flags
-	}
-
-	if err = sys.MapDeleteBatch(&attr); err != nil {
-		return int(attr.Count), fmt.Errorf("batch delete: %w", wrapMapError(err))
-	}
-
-	return int(attr.Count), nil
-}
-
-// Iterate traverses a map.
-//
-// It's safe to create multiple iterators at the same time.
-//
-// It's not possible to guarantee that all keys in a map will be
-// returned if there are concurrent modifications to the map.
-func (m *Map) Iterate() *MapIterator {
-	return newMapIterator(m)
-}
-
-// Close the Map's underlying file descriptor, which could unload the
-// Map from the kernel if it is not pinned or in use by a loaded Program.
-func (m *Map) Close() error {
-	if m == nil {
-		// This makes it easier to clean up when iterating maps
-		// of maps / programs.
-		return nil
-	}
-
-	return m.fd.Close()
-}
-
-// FD gets the file descriptor of the Map.
-//
-// Calling this function is invalid after Close has been called.
-func (m *Map) FD() int {
-	return m.fd.Int()
-}
-
-// Clone creates a duplicate of the Map.
-//
-// Closing the duplicate does not affect the original, and vice versa.
-// Changes made to the map are reflected by both instances however.
-// If the original map was pinned, the cloned map will not be pinned by default.
-//
-// Cloning a nil Map returns nil.
-func (m *Map) Clone() (*Map, error) {
-	if m == nil {
-		return nil, nil
-	}
-
-	dup, err := m.fd.Dup()
-	if err != nil {
-		return nil, fmt.Errorf("can't clone map: %w", err)
-	}
-
-	return &Map{
-		m.name,
-		dup,
-		m.typ,
-		m.keySize,
-		m.valueSize,
-		m.maxEntries,
-		m.flags,
-		"",
-		m.fullValueSize,
-	}, nil
-}
-
-// Pin persists the map on the BPF virtual file system past the lifetime of
-// the process that created it .
-//
-// Calling Pin on a previously pinned map will overwrite the path, except when
-// the new path already exists. Re-pinning across filesystems is not supported.
-// You can Clone a map to pin it to a different path.
-//
-// This requires bpffs to be mounted above fileName.
-// See https://docs.cilium.io/en/stable/network/kubernetes/configuration/#mounting-bpffs-with-systemd
-func (m *Map) Pin(fileName string) error {
-	if err := internal.Pin(m.pinnedPath, fileName, m.fd); err != nil {
-		return err
-	}
-	m.pinnedPath = fileName
-	return nil
-}
-
-// Unpin removes the persisted state for the map from the BPF virtual filesystem.
-//
-// Failed calls to Unpin will not alter the state returned by IsPinned.
-//
-// Unpinning an unpinned Map returns nil.
-func (m *Map) Unpin() error {
-	if err := internal.Unpin(m.pinnedPath); err != nil {
-		return err
-	}
-	m.pinnedPath = ""
-	return nil
-}
-
-// IsPinned returns true if the map has a non-empty pinned path.
-func (m *Map) IsPinned() bool {
-	return m.pinnedPath != ""
-}
-
-// Freeze prevents a map to be modified from user space.
-//
-// It makes no changes to kernel-side restrictions.
-func (m *Map) Freeze() error {
-	if err := haveMapMutabilityModifiers(); err != nil {
-		return fmt.Errorf("can't freeze map: %w", err)
-	}
-
-	attr := sys.MapFreezeAttr{
-		MapFd: m.fd.Uint(),
-	}
-
-	if err := sys.MapFreeze(&attr); err != nil {
-		return fmt.Errorf("can't freeze map: %w", err)
-	}
-	return nil
-}
-
-// finalize populates the Map according to the Contents specified
-// in spec and freezes the Map if requested by spec.
-func (m *Map) finalize(spec *MapSpec) error {
-	for _, kv := range spec.Contents {
-		if err := m.Put(kv.Key, kv.Value); err != nil {
-			return fmt.Errorf("putting value: key %v: %w", kv.Key, err)
-		}
-	}
-
-	if spec.Freeze {
-		if err := m.Freeze(); err != nil {
-			return fmt.Errorf("freezing map: %w", err)
-		}
-	}
-
-	return nil
-}
-
-func (m *Map) marshalKey(data interface{}) (sys.Pointer, error) {
-	if data == nil {
-		if m.keySize == 0 {
-			// Queues have a key length of zero, so passing nil here is valid.
-			return sys.NewPointer(nil), nil
-		}
-		return sys.Pointer{}, errors.New("can't use nil as key of map")
-	}
-
-	return marshalPtr(data, int(m.keySize))
-}
-
-func (m *Map) unmarshalKey(data interface{}, buf []byte) error {
-	if buf == nil {
-		// This is from a makeBuffer call, nothing do do here.
-		return nil
-	}
-
-	return unmarshalBytes(data, buf)
-}
-
-func (m *Map) marshalValue(data interface{}) (sys.Pointer, error) {
-	var (
-		buf []byte
-		err error
-	)
-
-	switch value := data.(type) {
-	case *Map:
-		if !m.typ.canStoreMap() {
-			return sys.Pointer{}, fmt.Errorf("can't store map in %s", m.typ)
-		}
-		buf, err = marshalMap(value, int(m.valueSize))
-
-	case *Program:
-		if !m.typ.canStoreProgram() {
-			return sys.Pointer{}, fmt.Errorf("can't store program in %s", m.typ)
-		}
-		buf, err = marshalProgram(value, int(m.valueSize))
-
-	default:
-		return marshalPtr(data, int(m.valueSize))
-	}
-
-	if err != nil {
-		return sys.Pointer{}, err
-	}
-
-	return sys.NewSlicePointer(buf), nil
-}
-
-func (m *Map) unmarshalValue(value interface{}, buf []byte) error {
-	if buf == nil {
-		// This is from a makeBuffer call, nothing do do here.
-		return nil
-	}
-
-	if m.typ.hasPerCPUValue() {
-		return unmarshalPerCPUValue(value, int(m.valueSize), buf)
-	}
-
-	switch value := value.(type) {
-	case **Map:
-		if !m.typ.canStoreMap() {
-			return fmt.Errorf("can't read a map from %s", m.typ)
-		}
-
-		other, err := unmarshalMap(buf)
-		if err != nil {
-			return err
-		}
-
-		// The caller might close the map externally, so ignore errors.
-		_ = (*value).Close()
-
-		*value = other
-		return nil
-
-	case *Map:
-		if !m.typ.canStoreMap() {
-			return fmt.Errorf("can't read a map from %s", m.typ)
-		}
-		return errors.New("require pointer to *Map")
-
-	case **Program:
-		if !m.typ.canStoreProgram() {
-			return fmt.Errorf("can't read a program from %s", m.typ)
-		}
-
-		other, err := unmarshalProgram(buf)
-		if err != nil {
-			return err
-		}
-
-		// The caller might close the program externally, so ignore errors.
-		_ = (*value).Close()
-
-		*value = other
-		return nil
-
-	case *Program:
-		if !m.typ.canStoreProgram() {
-			return fmt.Errorf("can't read a program from %s", m.typ)
-		}
-		return errors.New("require pointer to *Program")
-	}
-
-	return unmarshalBytes(value, buf)
-}
-
-// LoadPinnedMap loads a Map from a BPF file.
-func LoadPinnedMap(fileName string, opts *LoadPinOptions) (*Map, error) {
-	fd, err := sys.ObjGet(&sys.ObjGetAttr{
-		Pathname:  sys.NewStringPointer(fileName),
-		FileFlags: opts.Marshal(),
-	})
-	if err != nil {
-		return nil, err
-	}
-
-	m, err := newMapFromFD(fd)
-	if err == nil {
-		m.pinnedPath = fileName
-	}
-
-	return m, err
-}
-
-// unmarshalMap creates a map from a map ID encoded in host endianness.
-func unmarshalMap(buf []byte) (*Map, error) {
-	if len(buf) != 4 {
-		return nil, errors.New("map id requires 4 byte value")
-	}
-
-	id := internal.NativeEndian.Uint32(buf)
-	return NewMapFromID(MapID(id))
-}
-
-// marshalMap marshals the fd of a map into a buffer in host endianness.
-func marshalMap(m *Map, length int) ([]byte, error) {
-	if length != 4 {
-		return nil, fmt.Errorf("can't marshal map to %d bytes", length)
-	}
-
-	buf := make([]byte, 4)
-	internal.NativeEndian.PutUint32(buf, m.fd.Uint())
-	return buf, nil
-}
-
-// MapIterator iterates a Map.
-//
-// See Map.Iterate.
-type MapIterator struct {
-	target            *Map
-	curKey            []byte
-	count, maxEntries uint32
-	done              bool
-	err               error
-}
-
-func newMapIterator(target *Map) *MapIterator {
-	return &MapIterator{
-		target:     target,
-		maxEntries: target.maxEntries,
-	}
-}
-
-// Next decodes the next key and value.
-//
-// Iterating a hash map from which keys are being deleted is not
-// safe. You may see the same key multiple times. Iteration may
-// also abort with an error, see IsIterationAborted.
-//
-// Returns false if there are no more entries. You must check
-// the result of Err afterwards.
-//
-// See Map.Get for further caveats around valueOut.
-func (mi *MapIterator) Next(keyOut, valueOut interface{}) bool {
-	if mi.err != nil || mi.done {
-		return false
-	}
-
-	// For array-like maps NextKeyBytes returns nil only on after maxEntries
-	// iterations.
-	for mi.count <= mi.maxEntries {
-		var nextKey []byte
-		if mi.curKey == nil {
-			// Pass nil interface to NextKeyBytes to make sure the Map's first key
-			// is returned. If we pass an uninitialized []byte instead, it'll see a
-			// non-nil interface and try to marshal it.
-			nextKey, mi.err = mi.target.NextKeyBytes(nil)
-
-			mi.curKey = make([]byte, mi.target.keySize)
-		} else {
-			nextKey, mi.err = mi.target.NextKeyBytes(mi.curKey)
-		}
-		if mi.err != nil {
-			mi.err = fmt.Errorf("get next key: %w", mi.err)
-			return false
-		}
-
-		if nextKey == nil {
-			mi.done = true
-			return false
-		}
-
-		// The user can get access to nextKey since unmarshalBytes
-		// does not copy when unmarshaling into a []byte.
-		// Make a copy to prevent accidental corruption of
-		// iterator state.
-		copy(mi.curKey, nextKey)
-
-		mi.count++
-		mi.err = mi.target.Lookup(nextKey, valueOut)
-		if errors.Is(mi.err, ErrKeyNotExist) {
-			// Even though the key should be valid, we couldn't look up
-			// its value. If we're iterating a hash map this is probably
-			// because a concurrent delete removed the value before we
-			// could get it. This means that the next call to NextKeyBytes
-			// is very likely to restart iteration.
-			// If we're iterating one of the fd maps like
-			// ProgramArray it means that a given slot doesn't have
-			// a valid fd associated. It's OK to continue to the next slot.
-			continue
-		}
-		if mi.err != nil {
-			mi.err = fmt.Errorf("look up next key: %w", mi.err)
-			return false
-		}
-
-		mi.err = mi.target.unmarshalKey(keyOut, nextKey)
-		return mi.err == nil
-	}
-
-	mi.err = fmt.Errorf("%w", ErrIterationAborted)
-	return false
-}
-
-// Err returns any encountered error.
-//
-// The method must be called after Next returns nil.
-//
-// Returns ErrIterationAborted if it wasn't possible to do a full iteration.
-func (mi *MapIterator) Err() error {
-	return mi.err
-}
-
-// MapGetNextID returns the ID of the next eBPF map.
-//
-// Returns ErrNotExist, if there is no next eBPF map.
-func MapGetNextID(startID MapID) (MapID, error) {
-	attr := &sys.MapGetNextIdAttr{Id: uint32(startID)}
-	return MapID(attr.NextId), sys.MapGetNextId(attr)
-}
-
-// NewMapFromID returns the map for a given id.
-//
-// Returns ErrNotExist, if there is no eBPF map with the given id.
-func NewMapFromID(id MapID) (*Map, error) {
-	fd, err := sys.MapGetFdById(&sys.MapGetFdByIdAttr{
-		Id: uint32(id),
-	})
-	if err != nil {
-		return nil, err
-	}
-
-	return newMapFromFD(fd)
-}
diff --git a/vendor/github.com/cilium/ebpf/marshalers.go b/vendor/github.com/cilium/ebpf/marshalers.go
deleted file mode 100644
index a568bff92..000000000
--- a/vendor/github.com/cilium/ebpf/marshalers.go
+++ /dev/null
@@ -1,249 +0,0 @@
-package ebpf
-
-import (
-	"bytes"
-	"encoding"
-	"encoding/binary"
-	"errors"
-	"fmt"
-	"reflect"
-	"runtime"
-	"sync"
-	"unsafe"
-
-	"github.com/cilium/ebpf/internal"
-	"github.com/cilium/ebpf/internal/sys"
-)
-
-// marshalPtr converts an arbitrary value into a pointer suitable
-// to be passed to the kernel.
-//
-// As an optimization, it returns the original value if it is an
-// unsafe.Pointer.
-func marshalPtr(data interface{}, length int) (sys.Pointer, error) {
-	if ptr, ok := data.(unsafe.Pointer); ok {
-		return sys.NewPointer(ptr), nil
-	}
-
-	buf, err := marshalBytes(data, length)
-	if err != nil {
-		return sys.Pointer{}, err
-	}
-
-	return sys.NewSlicePointer(buf), nil
-}
-
-// marshalBytes converts an arbitrary value into a byte buffer.
-//
-// Prefer using Map.marshalKey and Map.marshalValue if possible, since
-// those have special cases that allow more types to be encoded.
-//
-// Returns an error if the given value isn't representable in exactly
-// length bytes.
-func marshalBytes(data interface{}, length int) (buf []byte, err error) {
-	if data == nil {
-		return nil, errors.New("can't marshal a nil value")
-	}
-
-	switch value := data.(type) {
-	case encoding.BinaryMarshaler:
-		buf, err = value.MarshalBinary()
-	case string:
-		buf = []byte(value)
-	case []byte:
-		buf = value
-	case unsafe.Pointer:
-		err = errors.New("can't marshal from unsafe.Pointer")
-	case Map, *Map, Program, *Program:
-		err = fmt.Errorf("can't marshal %T", value)
-	default:
-		wr := internal.NewBuffer(make([]byte, 0, length))
-		defer internal.PutBuffer(wr)
-
-		err = binary.Write(wr, internal.NativeEndian, value)
-		if err != nil {
-			err = fmt.Errorf("encoding %T: %v", value, err)
-		}
-		buf = wr.Bytes()
-	}
-	if err != nil {
-		return nil, err
-	}
-
-	if len(buf) != length {
-		return nil, fmt.Errorf("%T doesn't marshal to %d bytes", data, length)
-	}
-	return buf, nil
-}
-
-func makeBuffer(dst interface{}, length int) (sys.Pointer, []byte) {
-	if ptr, ok := dst.(unsafe.Pointer); ok {
-		return sys.NewPointer(ptr), nil
-	}
-
-	buf := make([]byte, length)
-	return sys.NewSlicePointer(buf), buf
-}
-
-var bytesReaderPool = sync.Pool{
-	New: func() interface{} {
-		return new(bytes.Reader)
-	},
-}
-
-// unmarshalBytes converts a byte buffer into an arbitrary value.
-//
-// Prefer using Map.unmarshalKey and Map.unmarshalValue if possible, since
-// those have special cases that allow more types to be encoded.
-//
-// The common int32 and int64 types are directly handled to avoid
-// unnecessary heap allocations as happening in the default case.
-func unmarshalBytes(data interface{}, buf []byte) error {
-	switch value := data.(type) {
-	case unsafe.Pointer:
-		dst := unsafe.Slice((*byte)(value), len(buf))
-		copy(dst, buf)
-		runtime.KeepAlive(value)
-		return nil
-	case Map, *Map, Program, *Program:
-		return fmt.Errorf("can't unmarshal into %T", value)
-	case encoding.BinaryUnmarshaler:
-		return value.UnmarshalBinary(buf)
-	case *string:
-		*value = string(buf)
-		return nil
-	case *[]byte:
-		*value = buf
-		return nil
-	case *int32:
-		if len(buf) < 4 {
-			return errors.New("int32 requires 4 bytes")
-		}
-		*value = int32(internal.NativeEndian.Uint32(buf))
-		return nil
-	case *uint32:
-		if len(buf) < 4 {
-			return errors.New("uint32 requires 4 bytes")
-		}
-		*value = internal.NativeEndian.Uint32(buf)
-		return nil
-	case *int64:
-		if len(buf) < 8 {
-			return errors.New("int64 requires 8 bytes")
-		}
-		*value = int64(internal.NativeEndian.Uint64(buf))
-		return nil
-	case *uint64:
-		if len(buf) < 8 {
-			return errors.New("uint64 requires 8 bytes")
-		}
-		*value = internal.NativeEndian.Uint64(buf)
-		return nil
-	case string:
-		return errors.New("require pointer to string")
-	case []byte:
-		return errors.New("require pointer to []byte")
-	default:
-		rd := bytesReaderPool.Get().(*bytes.Reader)
-		rd.Reset(buf)
-		defer bytesReaderPool.Put(rd)
-		if err := binary.Read(rd, internal.NativeEndian, value); err != nil {
-			return fmt.Errorf("decoding %T: %v", value, err)
-		}
-		return nil
-	}
-}
-
-// marshalPerCPUValue encodes a slice containing one value per
-// possible CPU into a buffer of bytes.
-//
-// Values are initialized to zero if the slice has less elements than CPUs.
-//
-// slice must have a type like []elementType.
-func marshalPerCPUValue(slice interface{}, elemLength int) (sys.Pointer, error) {
-	sliceType := reflect.TypeOf(slice)
-	if sliceType.Kind() != reflect.Slice {
-		return sys.Pointer{}, errors.New("per-CPU value requires slice")
-	}
-
-	possibleCPUs, err := internal.PossibleCPUs()
-	if err != nil {
-		return sys.Pointer{}, err
-	}
-
-	sliceValue := reflect.ValueOf(slice)
-	sliceLen := sliceValue.Len()
-	if sliceLen > possibleCPUs {
-		return sys.Pointer{}, fmt.Errorf("per-CPU value exceeds number of CPUs")
-	}
-
-	alignedElemLength := internal.Align(elemLength, 8)
-	buf := make([]byte, alignedElemLength*possibleCPUs)
-
-	for i := 0; i < sliceLen; i++ {
-		elem := sliceValue.Index(i).Interface()
-		elemBytes, err := marshalBytes(elem, elemLength)
-		if err != nil {
-			return sys.Pointer{}, err
-		}
-
-		offset := i * alignedElemLength
-		copy(buf[offset:offset+elemLength], elemBytes)
-	}
-
-	return sys.NewSlicePointer(buf), nil
-}
-
-// unmarshalPerCPUValue decodes a buffer into a slice containing one value per
-// possible CPU.
-//
-// valueOut must have a type like *[]elementType
-func unmarshalPerCPUValue(slicePtr interface{}, elemLength int, buf []byte) error {
-	slicePtrType := reflect.TypeOf(slicePtr)
-	if slicePtrType.Kind() != reflect.Ptr || slicePtrType.Elem().Kind() != reflect.Slice {
-		return fmt.Errorf("per-cpu value requires pointer to slice")
-	}
-
-	possibleCPUs, err := internal.PossibleCPUs()
-	if err != nil {
-		return err
-	}
-
-	sliceType := slicePtrType.Elem()
-	slice := reflect.MakeSlice(sliceType, possibleCPUs, possibleCPUs)
-
-	sliceElemType := sliceType.Elem()
-	sliceElemIsPointer := sliceElemType.Kind() == reflect.Ptr
-	if sliceElemIsPointer {
-		sliceElemType = sliceElemType.Elem()
-	}
-
-	step := len(buf) / possibleCPUs
-	if step < elemLength {
-		return fmt.Errorf("per-cpu element length is larger than available data")
-	}
-	for i := 0; i < possibleCPUs; i++ {
-		var elem interface{}
-		if sliceElemIsPointer {
-			newElem := reflect.New(sliceElemType)
-			slice.Index(i).Set(newElem)
-			elem = newElem.Interface()
-		} else {
-			elem = slice.Index(i).Addr().Interface()
-		}
-
-		// Make a copy, since unmarshal can hold on to itemBytes
-		elemBytes := make([]byte, elemLength)
-		copy(elemBytes, buf[:elemLength])
-
-		err := unmarshalBytes(elem, elemBytes)
-		if err != nil {
-			return fmt.Errorf("cpu %d: %w", i, err)
-		}
-
-		buf = buf[step:]
-	}
-
-	reflect.ValueOf(slicePtr).Elem().Set(slice)
-	return nil
-}
diff --git a/vendor/github.com/cilium/ebpf/prog.go b/vendor/github.com/cilium/ebpf/prog.go
deleted file mode 100644
index 70aaef553..000000000
--- a/vendor/github.com/cilium/ebpf/prog.go
+++ /dev/null
@@ -1,1026 +0,0 @@
-package ebpf
-
-import (
-	"bytes"
-	"encoding/binary"
-	"errors"
-	"fmt"
-	"math"
-	"path/filepath"
-	"runtime"
-	"strings"
-	"time"
-	"unsafe"
-
-	"github.com/cilium/ebpf/asm"
-	"github.com/cilium/ebpf/btf"
-	"github.com/cilium/ebpf/internal"
-	"github.com/cilium/ebpf/internal/sys"
-	"github.com/cilium/ebpf/internal/unix"
-)
-
-// ErrNotSupported is returned whenever the kernel doesn't support a feature.
-var ErrNotSupported = internal.ErrNotSupported
-
-// ProgramID represents the unique ID of an eBPF program.
-type ProgramID uint32
-
-const (
-	// Number of bytes to pad the output buffer for BPF_PROG_TEST_RUN.
-	// This is currently the maximum of spare space allocated for SKB
-	// and XDP programs, and equal to XDP_PACKET_HEADROOM + NET_IP_ALIGN.
-	outputPad = 256 + 2
-)
-
-// DefaultVerifierLogSize is the default number of bytes allocated for the
-// verifier log.
-const DefaultVerifierLogSize = 64 * 1024
-
-// maxVerifierLogSize is the maximum size of verifier log buffer the kernel
-// will accept before returning EINVAL.
-const maxVerifierLogSize = math.MaxUint32 >> 2
-
-// ProgramOptions control loading a program into the kernel.
-type ProgramOptions struct {
-	// Bitmap controlling the detail emitted by the kernel's eBPF verifier log.
-	// LogLevel-type values can be ORed together to request specific kinds of
-	// verifier output. See the documentation on [ebpf.LogLevel] for details.
-	//
-	//  opts.LogLevel = (ebpf.LogLevelBranch | ebpf.LogLevelStats)
-	//
-	// If left to its default value, the program will first be loaded without
-	// verifier output enabled. Upon error, the program load will be repeated
-	// with LogLevelBranch and the given (or default) LogSize value.
-	//
-	// Setting this to a non-zero value will unconditionally enable the verifier
-	// log, populating the [ebpf.Program.VerifierLog] field on successful loads
-	// and including detailed verifier errors if the program is rejected. This
-	// will always allocate an output buffer, but will result in only a single
-	// attempt at loading the program.
-	LogLevel LogLevel
-
-	// Controls the output buffer size for the verifier log, in bytes. See the
-	// documentation on ProgramOptions.LogLevel for details about how this value
-	// is used.
-	//
-	// If this value is set too low to fit the verifier log, the resulting
-	// [ebpf.VerifierError]'s Truncated flag will be true, and the error string
-	// will also contain a hint to that effect.
-	//
-	// Defaults to DefaultVerifierLogSize.
-	LogSize int
-
-	// Disables the verifier log completely, regardless of other options.
-	LogDisabled bool
-
-	// Type information used for CO-RE relocations.
-	//
-	// This is useful in environments where the kernel BTF is not available
-	// (containers) or where it is in a non-standard location. Defaults to
-	// use the kernel BTF from a well-known location if nil.
-	KernelTypes *btf.Spec
-}
-
-// ProgramSpec defines a Program.
-type ProgramSpec struct {
-	// Name is passed to the kernel as a debug aid. Must only contain
-	// alpha numeric and '_' characters.
-	Name string
-
-	// Type determines at which hook in the kernel a program will run.
-	Type ProgramType
-
-	// AttachType of the program, needed to differentiate allowed context
-	// accesses in some newer program types like CGroupSockAddr.
-	//
-	// Available on kernels 4.17 and later.
-	AttachType AttachType
-
-	// Name of a kernel data structure or function to attach to. Its
-	// interpretation depends on Type and AttachType.
-	AttachTo string
-
-	// The program to attach to. Must be provided manually.
-	AttachTarget *Program
-
-	// The name of the ELF section this program originated from.
-	SectionName string
-
-	Instructions asm.Instructions
-
-	// Flags is passed to the kernel and specifies additional program
-	// load attributes.
-	Flags uint32
-
-	// License of the program. Some helpers are only available if
-	// the license is deemed compatible with the GPL.
-	//
-	// See https://www.kernel.org/doc/html/latest/process/license-rules.html#id1
-	License string
-
-	// Version used by Kprobe programs.
-	//
-	// Deprecated on kernels 5.0 and later. Leave empty to let the library
-	// detect this value automatically.
-	KernelVersion uint32
-
-	// The byte order this program was compiled for, may be nil.
-	ByteOrder binary.ByteOrder
-}
-
-// Copy returns a copy of the spec.
-func (ps *ProgramSpec) Copy() *ProgramSpec {
-	if ps == nil {
-		return nil
-	}
-
-	cpy := *ps
-	cpy.Instructions = make(asm.Instructions, len(ps.Instructions))
-	copy(cpy.Instructions, ps.Instructions)
-	return &cpy
-}
-
-// Tag calculates the kernel tag for a series of instructions.
-//
-// Use asm.Instructions.Tag if you need to calculate for non-native endianness.
-func (ps *ProgramSpec) Tag() (string, error) {
-	return ps.Instructions.Tag(internal.NativeEndian)
-}
-
-// VerifierError is returned by [NewProgram] and [NewProgramWithOptions] if a
-// program is rejected by the verifier.
-//
-// Use [errors.As] to access the error.
-type VerifierError = internal.VerifierError
-
-// Program represents BPF program loaded into the kernel.
-//
-// It is not safe to close a Program which is used by other goroutines.
-type Program struct {
-	// Contains the output of the kernel verifier if enabled,
-	// otherwise it is empty.
-	VerifierLog string
-
-	fd         *sys.FD
-	name       string
-	pinnedPath string
-	typ        ProgramType
-}
-
-// NewProgram creates a new Program.
-//
-// See [NewProgramWithOptions] for details.
-//
-// Returns a [VerifierError] containing the full verifier log if the program is
-// rejected by the kernel.
-func NewProgram(spec *ProgramSpec) (*Program, error) {
-	return NewProgramWithOptions(spec, ProgramOptions{})
-}
-
-// NewProgramWithOptions creates a new Program.
-//
-// Loading a program for the first time will perform
-// feature detection by loading small, temporary programs.
-//
-// Returns a [VerifierError] containing the full verifier log if the program is
-// rejected by the kernel.
-func NewProgramWithOptions(spec *ProgramSpec, opts ProgramOptions) (*Program, error) {
-	if spec == nil {
-		return nil, errors.New("can't load a program from a nil spec")
-	}
-
-	prog, err := newProgramWithOptions(spec, opts)
-	if errors.Is(err, asm.ErrUnsatisfiedMapReference) {
-		return nil, fmt.Errorf("cannot load program without loading its whole collection: %w", err)
-	}
-	return prog, err
-}
-
-func newProgramWithOptions(spec *ProgramSpec, opts ProgramOptions) (*Program, error) {
-	if len(spec.Instructions) == 0 {
-		return nil, errors.New("instructions cannot be empty")
-	}
-
-	if spec.Type == UnspecifiedProgram {
-		return nil, errors.New("can't load program of unspecified type")
-	}
-
-	if spec.ByteOrder != nil && spec.ByteOrder != internal.NativeEndian {
-		return nil, fmt.Errorf("can't load %s program on %s", spec.ByteOrder, internal.NativeEndian)
-	}
-
-	if opts.LogSize < 0 {
-		return nil, errors.New("ProgramOptions.LogSize must be a positive value; disable verifier logs using ProgramOptions.LogDisabled")
-	}
-
-	// Kernels before 5.0 (6c4fc209fcf9 "bpf: remove useless version check for prog load")
-	// require the version field to be set to the value of the KERNEL_VERSION
-	// macro for kprobe-type programs.
-	// Overwrite Kprobe program version if set to zero or the magic version constant.
-	kv := spec.KernelVersion
-	if spec.Type == Kprobe && (kv == 0 || kv == internal.MagicKernelVersion) {
-		v, err := internal.KernelVersion()
-		if err != nil {
-			return nil, fmt.Errorf("detecting kernel version: %w", err)
-		}
-		kv = v.Kernel()
-	}
-
-	attr := &sys.ProgLoadAttr{
-		ProgType:           sys.ProgType(spec.Type),
-		ProgFlags:          spec.Flags,
-		ExpectedAttachType: sys.AttachType(spec.AttachType),
-		License:            sys.NewStringPointer(spec.License),
-		KernVersion:        kv,
-	}
-
-	if haveObjName() == nil {
-		attr.ProgName = sys.NewObjName(spec.Name)
-	}
-
-	insns := make(asm.Instructions, len(spec.Instructions))
-	copy(insns, spec.Instructions)
-
-	handle, fib, lib, err := btf.MarshalExtInfos(insns)
-	if err != nil && !errors.Is(err, btf.ErrNotSupported) {
-		return nil, fmt.Errorf("load ext_infos: %w", err)
-	}
-	if handle != nil {
-		defer handle.Close()
-
-		attr.ProgBtfFd = uint32(handle.FD())
-
-		attr.FuncInfoRecSize = btf.FuncInfoSize
-		attr.FuncInfoCnt = uint32(len(fib)) / btf.FuncInfoSize
-		attr.FuncInfo = sys.NewSlicePointer(fib)
-
-		attr.LineInfoRecSize = btf.LineInfoSize
-		attr.LineInfoCnt = uint32(len(lib)) / btf.LineInfoSize
-		attr.LineInfo = sys.NewSlicePointer(lib)
-	}
-
-	if err := applyRelocations(insns, opts.KernelTypes, spec.ByteOrder); err != nil {
-		return nil, fmt.Errorf("apply CO-RE relocations: %w", err)
-	}
-
-	kconfig, err := resolveKconfigReferences(insns)
-	if err != nil {
-		return nil, fmt.Errorf("resolve .kconfig: %w", err)
-	}
-	defer kconfig.Close()
-
-	if err := fixupAndValidate(insns); err != nil {
-		return nil, err
-	}
-
-	handles, err := fixupKfuncs(insns)
-	if err != nil {
-		return nil, fmt.Errorf("fixing up kfuncs: %w", err)
-	}
-	defer handles.close()
-
-	if len(handles) > 0 {
-		fdArray := handles.fdArray()
-		attr.FdArray = sys.NewPointer(unsafe.Pointer(&fdArray[0]))
-	}
-
-	buf := bytes.NewBuffer(make([]byte, 0, insns.Size()))
-	err = insns.Marshal(buf, internal.NativeEndian)
-	if err != nil {
-		return nil, err
-	}
-
-	bytecode := buf.Bytes()
-	attr.Insns = sys.NewSlicePointer(bytecode)
-	attr.InsnCnt = uint32(len(bytecode) / asm.InstructionSize)
-
-	if spec.AttachTarget != nil {
-		targetID, err := findTargetInProgram(spec.AttachTarget, spec.AttachTo, spec.Type, spec.AttachType)
-		if err != nil {
-			return nil, fmt.Errorf("attach %s/%s: %w", spec.Type, spec.AttachType, err)
-		}
-
-		attr.AttachBtfId = targetID
-		attr.AttachBtfObjFd = uint32(spec.AttachTarget.FD())
-		defer runtime.KeepAlive(spec.AttachTarget)
-	} else if spec.AttachTo != "" {
-		module, targetID, err := findProgramTargetInKernel(spec.AttachTo, spec.Type, spec.AttachType)
-		if err != nil && !errors.Is(err, errUnrecognizedAttachType) {
-			// We ignore errUnrecognizedAttachType since AttachTo may be non-empty
-			// for programs that don't attach anywhere.
-			return nil, fmt.Errorf("attach %s/%s: %w", spec.Type, spec.AttachType, err)
-		}
-
-		attr.AttachBtfId = targetID
-		if module != nil {
-			attr.AttachBtfObjFd = uint32(module.FD())
-			defer module.Close()
-		}
-	}
-
-	if opts.LogSize == 0 {
-		opts.LogSize = DefaultVerifierLogSize
-	}
-
-	// The caller requested a specific verifier log level. Set up the log buffer.
-	var logBuf []byte
-	if !opts.LogDisabled && opts.LogLevel != 0 {
-		logBuf = make([]byte, opts.LogSize)
-		attr.LogLevel = opts.LogLevel
-		attr.LogSize = uint32(len(logBuf))
-		attr.LogBuf = sys.NewSlicePointer(logBuf)
-	}
-
-	fd, err := sys.ProgLoad(attr)
-	if err == nil {
-		return &Program{unix.ByteSliceToString(logBuf), fd, spec.Name, "", spec.Type}, nil
-	}
-
-	// An error occurred loading the program, but the caller did not explicitly
-	// enable the verifier log. Re-run with branch-level verifier logs enabled to
-	// obtain more info. Preserve the original error to return it to the caller.
-	// An undersized log buffer will result in ENOSPC regardless of the underlying
-	// cause.
-	var err2 error
-	if !opts.LogDisabled && opts.LogLevel == 0 {
-		logBuf = make([]byte, opts.LogSize)
-		attr.LogLevel = LogLevelBranch
-		attr.LogSize = uint32(len(logBuf))
-		attr.LogBuf = sys.NewSlicePointer(logBuf)
-
-		_, err2 = sys.ProgLoad(attr)
-	}
-
-	switch {
-	case errors.Is(err, unix.EPERM):
-		if len(logBuf) > 0 && logBuf[0] == 0 {
-			// EPERM due to RLIMIT_MEMLOCK happens before the verifier, so we can
-			// check that the log is empty to reduce false positives.
-			return nil, fmt.Errorf("load program: %w (MEMLOCK may be too low, consider rlimit.RemoveMemlock)", err)
-		}
-
-		fallthrough
-
-	case errors.Is(err, unix.EINVAL):
-		if hasFunctionReferences(spec.Instructions) {
-			if err := haveBPFToBPFCalls(); err != nil {
-				return nil, fmt.Errorf("load program: %w", err)
-			}
-		}
-
-		if opts.LogSize > maxVerifierLogSize {
-			return nil, fmt.Errorf("load program: %w (ProgramOptions.LogSize exceeds maximum value of %d)", err, maxVerifierLogSize)
-		}
-	}
-
-	truncated := errors.Is(err, unix.ENOSPC) || errors.Is(err2, unix.ENOSPC)
-	return nil, internal.ErrorWithLog("load program", err, logBuf, truncated)
-}
-
-// NewProgramFromFD creates a program from a raw fd.
-//
-// You should not use fd after calling this function.
-//
-// Requires at least Linux 4.10.
-func NewProgramFromFD(fd int) (*Program, error) {
-	f, err := sys.NewFD(fd)
-	if err != nil {
-		return nil, err
-	}
-
-	return newProgramFromFD(f)
-}
-
-// NewProgramFromID returns the program for a given id.
-//
-// Returns ErrNotExist, if there is no eBPF program with the given id.
-func NewProgramFromID(id ProgramID) (*Program, error) {
-	fd, err := sys.ProgGetFdById(&sys.ProgGetFdByIdAttr{
-		Id: uint32(id),
-	})
-	if err != nil {
-		return nil, fmt.Errorf("get program by id: %w", err)
-	}
-
-	return newProgramFromFD(fd)
-}
-
-func newProgramFromFD(fd *sys.FD) (*Program, error) {
-	info, err := newProgramInfoFromFd(fd)
-	if err != nil {
-		fd.Close()
-		return nil, fmt.Errorf("discover program type: %w", err)
-	}
-
-	return &Program{"", fd, info.Name, "", info.Type}, nil
-}
-
-func (p *Program) String() string {
-	if p.name != "" {
-		return fmt.Sprintf("%s(%s)#%v", p.typ, p.name, p.fd)
-	}
-	return fmt.Sprintf("%s(%v)", p.typ, p.fd)
-}
-
-// Type returns the underlying type of the program.
-func (p *Program) Type() ProgramType {
-	return p.typ
-}
-
-// Info returns metadata about the program.
-//
-// Requires at least 4.10.
-func (p *Program) Info() (*ProgramInfo, error) {
-	return newProgramInfoFromFd(p.fd)
-}
-
-// Handle returns a reference to the program's type information in the kernel.
-//
-// Returns ErrNotSupported if the kernel has no BTF support, or if there is no
-// BTF associated with the program.
-func (p *Program) Handle() (*btf.Handle, error) {
-	info, err := p.Info()
-	if err != nil {
-		return nil, err
-	}
-
-	id, ok := info.BTFID()
-	if !ok {
-		return nil, fmt.Errorf("program %s: retrieve BTF ID: %w", p, ErrNotSupported)
-	}
-
-	return btf.NewHandleFromID(id)
-}
-
-// FD gets the file descriptor of the Program.
-//
-// It is invalid to call this function after Close has been called.
-func (p *Program) FD() int {
-	return p.fd.Int()
-}
-
-// Clone creates a duplicate of the Program.
-//
-// Closing the duplicate does not affect the original, and vice versa.
-//
-// Cloning a nil Program returns nil.
-func (p *Program) Clone() (*Program, error) {
-	if p == nil {
-		return nil, nil
-	}
-
-	dup, err := p.fd.Dup()
-	if err != nil {
-		return nil, fmt.Errorf("can't clone program: %w", err)
-	}
-
-	return &Program{p.VerifierLog, dup, p.name, "", p.typ}, nil
-}
-
-// Pin persists the Program on the BPF virtual file system past the lifetime of
-// the process that created it
-//
-// Calling Pin on a previously pinned program will overwrite the path, except when
-// the new path already exists. Re-pinning across filesystems is not supported.
-//
-// This requires bpffs to be mounted above fileName.
-// See https://docs.cilium.io/en/stable/network/kubernetes/configuration/#mounting-bpffs-with-systemd
-func (p *Program) Pin(fileName string) error {
-	if err := internal.Pin(p.pinnedPath, fileName, p.fd); err != nil {
-		return err
-	}
-	p.pinnedPath = fileName
-	return nil
-}
-
-// Unpin removes the persisted state for the Program from the BPF virtual filesystem.
-//
-// Failed calls to Unpin will not alter the state returned by IsPinned.
-//
-// Unpinning an unpinned Program returns nil.
-func (p *Program) Unpin() error {
-	if err := internal.Unpin(p.pinnedPath); err != nil {
-		return err
-	}
-	p.pinnedPath = ""
-	return nil
-}
-
-// IsPinned returns true if the Program has a non-empty pinned path.
-func (p *Program) IsPinned() bool {
-	return p.pinnedPath != ""
-}
-
-// Close the Program's underlying file descriptor, which could unload
-// the program from the kernel if it is not pinned or attached to a
-// kernel hook.
-func (p *Program) Close() error {
-	if p == nil {
-		return nil
-	}
-
-	return p.fd.Close()
-}
-
-// Various options for Run'ing a Program
-type RunOptions struct {
-	// Program's data input. Required field.
-	//
-	// The kernel expects at least 14 bytes input for an ethernet header for
-	// XDP and SKB programs.
-	Data []byte
-	// Program's data after Program has run. Caller must allocate. Optional field.
-	DataOut []byte
-	// Program's context input. Optional field.
-	Context interface{}
-	// Program's context after Program has run. Must be a pointer or slice. Optional field.
-	ContextOut interface{}
-	// Minimum number of times to run Program. Optional field. Defaults to 1.
-	//
-	// The program may be executed more often than this due to interruptions, e.g.
-	// when runtime.AllThreadsSyscall is invoked.
-	Repeat uint32
-	// Optional flags.
-	Flags uint32
-	// CPU to run Program on. Optional field.
-	// Note not all program types support this field.
-	CPU uint32
-	// Called whenever the syscall is interrupted, and should be set to testing.B.ResetTimer
-	// or similar. Typically used during benchmarking. Optional field.
-	//
-	// Deprecated: use [testing.B.ReportMetric] with unit "ns/op" instead.
-	Reset func()
-}
-
-// Test runs the Program in the kernel with the given input and returns the
-// value returned by the eBPF program. outLen may be zero.
-//
-// Note: the kernel expects at least 14 bytes input for an ethernet header for
-// XDP and SKB programs.
-//
-// This function requires at least Linux 4.12.
-func (p *Program) Test(in []byte) (uint32, []byte, error) {
-	// Older kernels ignore the dataSizeOut argument when copying to user space.
-	// Combined with things like bpf_xdp_adjust_head() we don't really know what the final
-	// size will be. Hence we allocate an output buffer which we hope will always be large
-	// enough, and panic if the kernel wrote past the end of the allocation.
-	// See https://patchwork.ozlabs.org/cover/1006822/
-	var out []byte
-	if len(in) > 0 {
-		out = make([]byte, len(in)+outputPad)
-	}
-
-	opts := RunOptions{
-		Data:    in,
-		DataOut: out,
-		Repeat:  1,
-	}
-
-	ret, _, err := p.run(&opts)
-	if err != nil {
-		return ret, nil, fmt.Errorf("test program: %w", err)
-	}
-	return ret, opts.DataOut, nil
-}
-
-// Run runs the Program in kernel with given RunOptions.
-//
-// Note: the same restrictions from Test apply.
-func (p *Program) Run(opts *RunOptions) (uint32, error) {
-	ret, _, err := p.run(opts)
-	if err != nil {
-		return ret, fmt.Errorf("run program: %w", err)
-	}
-	return ret, nil
-}
-
-// Benchmark runs the Program with the given input for a number of times
-// and returns the time taken per iteration.
-//
-// Returns the result of the last execution of the program and the time per
-// run or an error. reset is called whenever the benchmark syscall is
-// interrupted, and should be set to testing.B.ResetTimer or similar.
-//
-// This function requires at least Linux 4.12.
-func (p *Program) Benchmark(in []byte, repeat int, reset func()) (uint32, time.Duration, error) {
-	if uint(repeat) > math.MaxUint32 {
-		return 0, 0, fmt.Errorf("repeat is too high")
-	}
-
-	opts := RunOptions{
-		Data:   in,
-		Repeat: uint32(repeat),
-		Reset:  reset,
-	}
-
-	ret, total, err := p.run(&opts)
-	if err != nil {
-		return ret, total, fmt.Errorf("benchmark program: %w", err)
-	}
-	return ret, total, nil
-}
-
-var haveProgRun = internal.NewFeatureTest("BPF_PROG_RUN", "4.12", func() error {
-	prog, err := NewProgram(&ProgramSpec{
-		// SocketFilter does not require privileges on newer kernels.
-		Type: SocketFilter,
-		Instructions: asm.Instructions{
-			asm.LoadImm(asm.R0, 0, asm.DWord),
-			asm.Return(),
-		},
-		License: "MIT",
-	})
-	if err != nil {
-		// This may be because we lack sufficient permissions, etc.
-		return err
-	}
-	defer prog.Close()
-
-	in := internal.EmptyBPFContext
-	attr := sys.ProgRunAttr{
-		ProgFd:     uint32(prog.FD()),
-		DataSizeIn: uint32(len(in)),
-		DataIn:     sys.NewSlicePointer(in),
-	}
-
-	err = sys.ProgRun(&attr)
-	switch {
-	case errors.Is(err, unix.EINVAL):
-		// Check for EINVAL specifically, rather than err != nil since we
-		// otherwise misdetect due to insufficient permissions.
-		return internal.ErrNotSupported
-
-	case errors.Is(err, unix.EINTR):
-		// We know that PROG_TEST_RUN is supported if we get EINTR.
-		return nil
-
-	case errors.Is(err, sys.ENOTSUPP):
-		// The first PROG_TEST_RUN patches shipped in 4.12 didn't include
-		// a test runner for SocketFilter. ENOTSUPP means PROG_TEST_RUN is
-		// supported, but not for the program type used in the probe.
-		return nil
-	}
-
-	return err
-})
-
-func (p *Program) run(opts *RunOptions) (uint32, time.Duration, error) {
-	if uint(len(opts.Data)) > math.MaxUint32 {
-		return 0, 0, fmt.Errorf("input is too long")
-	}
-
-	if err := haveProgRun(); err != nil {
-		return 0, 0, err
-	}
-
-	var ctxBytes []byte
-	if opts.Context != nil {
-		ctx := new(bytes.Buffer)
-		if err := binary.Write(ctx, internal.NativeEndian, opts.Context); err != nil {
-			return 0, 0, fmt.Errorf("cannot serialize context: %v", err)
-		}
-		ctxBytes = ctx.Bytes()
-	}
-
-	var ctxOut []byte
-	if opts.ContextOut != nil {
-		ctxOut = make([]byte, binary.Size(opts.ContextOut))
-	}
-
-	attr := sys.ProgRunAttr{
-		ProgFd:      p.fd.Uint(),
-		DataSizeIn:  uint32(len(opts.Data)),
-		DataSizeOut: uint32(len(opts.DataOut)),
-		DataIn:      sys.NewSlicePointer(opts.Data),
-		DataOut:     sys.NewSlicePointer(opts.DataOut),
-		Repeat:      uint32(opts.Repeat),
-		CtxSizeIn:   uint32(len(ctxBytes)),
-		CtxSizeOut:  uint32(len(ctxOut)),
-		CtxIn:       sys.NewSlicePointer(ctxBytes),
-		CtxOut:      sys.NewSlicePointer(ctxOut),
-		Flags:       opts.Flags,
-		Cpu:         opts.CPU,
-	}
-
-	if attr.Repeat == 0 {
-		attr.Repeat = 1
-	}
-
-retry:
-	for {
-		err := sys.ProgRun(&attr)
-		if err == nil {
-			break retry
-		}
-
-		if errors.Is(err, unix.EINTR) {
-			if attr.Repeat == 1 {
-				// Older kernels check whether enough repetitions have been
-				// executed only after checking for pending signals.
-				//
-				//     run signal? done? run ...
-				//
-				// As a result we can get EINTR for repeat==1 even though
-				// the program was run exactly once. Treat this as a
-				// successful run instead.
-				//
-				// Since commit 607b9cc92bd7 ("bpf: Consolidate shared test timing code")
-				// the conditions are reversed:
-				//     run done? signal? ...
-				break retry
-			}
-
-			if opts.Reset != nil {
-				opts.Reset()
-			}
-			continue retry
-		}
-
-		if errors.Is(err, sys.ENOTSUPP) {
-			return 0, 0, fmt.Errorf("kernel doesn't support running %s: %w", p.Type(), ErrNotSupported)
-		}
-
-		return 0, 0, err
-	}
-
-	if opts.DataOut != nil {
-		if int(attr.DataSizeOut) > cap(opts.DataOut) {
-			// Houston, we have a problem. The program created more data than we allocated,
-			// and the kernel wrote past the end of our buffer.
-			panic("kernel wrote past end of output buffer")
-		}
-		opts.DataOut = opts.DataOut[:int(attr.DataSizeOut)]
-	}
-
-	if len(ctxOut) != 0 {
-		b := bytes.NewReader(ctxOut)
-		if err := binary.Read(b, internal.NativeEndian, opts.ContextOut); err != nil {
-			return 0, 0, fmt.Errorf("failed to decode ContextOut: %v", err)
-		}
-	}
-
-	total := time.Duration(attr.Duration) * time.Nanosecond
-	return attr.Retval, total, nil
-}
-
-func unmarshalProgram(buf []byte) (*Program, error) {
-	if len(buf) != 4 {
-		return nil, errors.New("program id requires 4 byte value")
-	}
-
-	// Looking up an entry in a nested map or prog array returns an id,
-	// not an fd.
-	id := internal.NativeEndian.Uint32(buf)
-	return NewProgramFromID(ProgramID(id))
-}
-
-func marshalProgram(p *Program, length int) ([]byte, error) {
-	if length != 4 {
-		return nil, fmt.Errorf("can't marshal program to %d bytes", length)
-	}
-
-	buf := make([]byte, 4)
-	internal.NativeEndian.PutUint32(buf, p.fd.Uint())
-	return buf, nil
-}
-
-// LoadPinnedProgram loads a Program from a BPF file.
-//
-// Requires at least Linux 4.11.
-func LoadPinnedProgram(fileName string, opts *LoadPinOptions) (*Program, error) {
-	fd, err := sys.ObjGet(&sys.ObjGetAttr{
-		Pathname:  sys.NewStringPointer(fileName),
-		FileFlags: opts.Marshal(),
-	})
-	if err != nil {
-		return nil, err
-	}
-
-	info, err := newProgramInfoFromFd(fd)
-	if err != nil {
-		_ = fd.Close()
-		return nil, fmt.Errorf("info for %s: %w", fileName, err)
-	}
-
-	var progName string
-	if haveObjName() == nil {
-		progName = info.Name
-	} else {
-		progName = filepath.Base(fileName)
-	}
-
-	return &Program{"", fd, progName, fileName, info.Type}, nil
-}
-
-// SanitizeName replaces all invalid characters in name with replacement.
-// Passing a negative value for replacement will delete characters instead
-// of replacing them. Use this to automatically generate valid names for maps
-// and programs at runtime.
-//
-// The set of allowed characters depends on the running kernel version.
-// Dots are only allowed as of kernel 5.2.
-func SanitizeName(name string, replacement rune) string {
-	return strings.Map(func(char rune) rune {
-		if invalidBPFObjNameChar(char) {
-			return replacement
-		}
-		return char
-	}, name)
-}
-
-// ProgramGetNextID returns the ID of the next eBPF program.
-//
-// Returns ErrNotExist, if there is no next eBPF program.
-func ProgramGetNextID(startID ProgramID) (ProgramID, error) {
-	attr := &sys.ProgGetNextIdAttr{Id: uint32(startID)}
-	return ProgramID(attr.NextId), sys.ProgGetNextId(attr)
-}
-
-// BindMap binds map to the program and is only released once program is released.
-//
-// This may be used in cases where metadata should be associated with the program
-// which otherwise does not contain any references to the map.
-func (p *Program) BindMap(m *Map) error {
-	attr := &sys.ProgBindMapAttr{
-		ProgFd: uint32(p.FD()),
-		MapFd:  uint32(m.FD()),
-	}
-
-	return sys.ProgBindMap(attr)
-}
-
-var errUnrecognizedAttachType = errors.New("unrecognized attach type")
-
-// find an attach target type in the kernel.
-//
-// name, progType and attachType determine which type we need to attach to.
-//
-// The attach target may be in a loaded kernel module.
-// In that case the returned handle will be non-nil.
-// The caller is responsible for closing the handle.
-//
-// Returns errUnrecognizedAttachType if the combination of progType and attachType
-// is not recognised.
-func findProgramTargetInKernel(name string, progType ProgramType, attachType AttachType) (*btf.Handle, btf.TypeID, error) {
-	type match struct {
-		p ProgramType
-		a AttachType
-	}
-
-	var (
-		typeName, featureName string
-		target                btf.Type
-	)
-
-	switch (match{progType, attachType}) {
-	case match{LSM, AttachLSMMac}:
-		typeName = "bpf_lsm_" + name
-		featureName = name + " LSM hook"
-		target = (*btf.Func)(nil)
-	case match{Tracing, AttachTraceIter}:
-		typeName = "bpf_iter_" + name
-		featureName = name + " iterator"
-		target = (*btf.Func)(nil)
-	case match{Tracing, AttachTraceFEntry}:
-		typeName = name
-		featureName = fmt.Sprintf("fentry %s", name)
-		target = (*btf.Func)(nil)
-	case match{Tracing, AttachTraceFExit}:
-		typeName = name
-		featureName = fmt.Sprintf("fexit %s", name)
-		target = (*btf.Func)(nil)
-	case match{Tracing, AttachModifyReturn}:
-		typeName = name
-		featureName = fmt.Sprintf("fmod_ret %s", name)
-		target = (*btf.Func)(nil)
-	case match{Tracing, AttachTraceRawTp}:
-		typeName = fmt.Sprintf("btf_trace_%s", name)
-		featureName = fmt.Sprintf("raw_tp %s", name)
-		target = (*btf.Typedef)(nil)
-	default:
-		return nil, 0, errUnrecognizedAttachType
-	}
-
-	spec, err := btf.LoadKernelSpec()
-	if err != nil {
-		return nil, 0, fmt.Errorf("load kernel spec: %w", err)
-	}
-
-	spec, module, err := findTargetInKernel(spec, typeName, &target)
-	if errors.Is(err, btf.ErrNotFound) {
-		return nil, 0, &internal.UnsupportedFeatureError{Name: featureName}
-	}
-	// See cilium/ebpf#894. Until we can disambiguate between equally-named kernel
-	// symbols, we should explicitly refuse program loads. They will not reliably
-	// do what the caller intended.
-	if errors.Is(err, btf.ErrMultipleMatches) {
-		return nil, 0, fmt.Errorf("attaching to ambiguous kernel symbol is not supported: %w", err)
-	}
-	if err != nil {
-		return nil, 0, fmt.Errorf("find target for %s: %w", featureName, err)
-	}
-
-	id, err := spec.TypeID(target)
-	return module, id, err
-}
-
-// findTargetInKernel attempts to find a named type in the current kernel.
-//
-// target will point at the found type after a successful call. Searches both
-// vmlinux and any loaded modules.
-//
-// Returns a non-nil handle if the type was found in a module, or btf.ErrNotFound
-// if the type wasn't found at all.
-func findTargetInKernel(kernelSpec *btf.Spec, typeName string, target *btf.Type) (*btf.Spec, *btf.Handle, error) {
-	err := kernelSpec.TypeByName(typeName, target)
-	if errors.Is(err, btf.ErrNotFound) {
-		spec, module, err := findTargetInModule(kernelSpec, typeName, target)
-		if err != nil {
-			return nil, nil, fmt.Errorf("find target in modules: %w", err)
-		}
-		return spec, module, nil
-	}
-	if err != nil {
-		return nil, nil, fmt.Errorf("find target in vmlinux: %w", err)
-	}
-	return kernelSpec, nil, err
-}
-
-// findTargetInModule attempts to find a named type in any loaded module.
-//
-// base must contain the kernel's types and is used to parse kmod BTF. Modules
-// are searched in the order they were loaded.
-//
-// Returns btf.ErrNotFound if the target can't be found in any module.
-func findTargetInModule(base *btf.Spec, typeName string, target *btf.Type) (*btf.Spec, *btf.Handle, error) {
-	it := new(btf.HandleIterator)
-	defer it.Handle.Close()
-
-	for it.Next() {
-		info, err := it.Handle.Info()
-		if err != nil {
-			return nil, nil, fmt.Errorf("get info for BTF ID %d: %w", it.ID, err)
-		}
-
-		if !info.IsModule() {
-			continue
-		}
-
-		spec, err := it.Handle.Spec(base)
-		if err != nil {
-			return nil, nil, fmt.Errorf("parse types for module %s: %w", info.Name, err)
-		}
-
-		err = spec.TypeByName(typeName, target)
-		if errors.Is(err, btf.ErrNotFound) {
-			continue
-		}
-		if err != nil {
-			return nil, nil, fmt.Errorf("lookup type in module %s: %w", info.Name, err)
-		}
-
-		return spec, it.Take(), nil
-	}
-	if err := it.Err(); err != nil {
-		return nil, nil, fmt.Errorf("iterate modules: %w", err)
-	}
-
-	return nil, nil, btf.ErrNotFound
-}
-
-// find an attach target type in a program.
-//
-// Returns errUnrecognizedAttachType.
-func findTargetInProgram(prog *Program, name string, progType ProgramType, attachType AttachType) (btf.TypeID, error) {
-	type match struct {
-		p ProgramType
-		a AttachType
-	}
-
-	var typeName string
-	switch (match{progType, attachType}) {
-	case match{Extension, AttachNone}:
-		typeName = name
-	default:
-		return 0, errUnrecognizedAttachType
-	}
-
-	btfHandle, err := prog.Handle()
-	if err != nil {
-		return 0, fmt.Errorf("load target BTF: %w", err)
-	}
-	defer btfHandle.Close()
-
-	spec, err := btfHandle.Spec(nil)
-	if err != nil {
-		return 0, err
-	}
-
-	var targetFunc *btf.Func
-	err = spec.TypeByName(typeName, &targetFunc)
-	if err != nil {
-		return 0, fmt.Errorf("find target %s: %w", typeName, err)
-	}
-
-	return spec.TypeID(targetFunc)
-}
diff --git a/vendor/github.com/cilium/ebpf/run-tests.sh b/vendor/github.com/cilium/ebpf/run-tests.sh
deleted file mode 100644
index 1d1490ad1..000000000
--- a/vendor/github.com/cilium/ebpf/run-tests.sh
+++ /dev/null
@@ -1,152 +0,0 @@
-#!/usr/bin/env bash
-# Test the current package under a different kernel.
-# Requires virtme and qemu to be installed.
-# Examples:
-#     Run all tests on a 5.4 kernel
-#     $ ./run-tests.sh 5.4
-#     Run a subset of tests:
-#     $ ./run-tests.sh 5.4 ./link
-#     Run using a local kernel image
-#     $ ./run-tests.sh /path/to/bzImage
-
-set -euo pipefail
-
-script="$(realpath "$0")"
-readonly script
-
-# This script is a bit like a Matryoshka doll since it keeps re-executing itself
-# in various different contexts:
-#
-#   1. invoked by the user like run-tests.sh 5.4
-#   2. invoked by go test like run-tests.sh --exec-vm
-#   3. invoked by init in the vm like run-tests.sh --exec-test
-#
-# This allows us to use all available CPU on the host machine to compile our
-# code, and then only use the VM to execute the test. This is because the VM
-# is usually slower at compiling than the host.
-if [[ "${1:-}" = "--exec-vm" ]]; then
-  shift
-
-  input="$1"
-  shift
-
-  # Use sudo if /dev/kvm isn't accessible by the current user.
-  sudo=""
-  if [[ ! -r /dev/kvm || ! -w /dev/kvm ]]; then
-    sudo="sudo"
-  fi
-  readonly sudo
-
-  testdir="$(dirname "$1")"
-  output="$(mktemp -d)"
-  printf -v cmd "%q " "$@"
-
-  if [[ "$(stat -c '%t:%T' -L /proc/$$/fd/0)" == "1:3" ]]; then
-    # stdin is /dev/null, which doesn't play well with qemu. Use a fifo as a
-    # blocking substitute.
-    mkfifo "${output}/fake-stdin"
-    # Open for reading and writing to avoid blocking.
-    exec 0<> "${output}/fake-stdin"
-    rm "${output}/fake-stdin"
-  fi
-
-  for ((i = 0; i < 3; i++)); do
-    if ! $sudo virtme-run --kimg "${input}/bzImage" --memory 768M --pwd \
-      --rwdir="${testdir}=${testdir}" \
-      --rodir=/run/input="${input}" \
-      --rwdir=/run/output="${output}" \
-      --script-sh "PATH=\"$PATH\" CI_MAX_KERNEL_VERSION="${CI_MAX_KERNEL_VERSION:-}" \"$script\" --exec-test $cmd" \
-      --kopt possible_cpus=2; then # need at least two CPUs for some tests
-      exit 23
-    fi
-
-    if [[ -e "${output}/status" ]]; then
-      break
-    fi
-
-    if [[ -v CI ]]; then
-      echo "Retrying test run due to qemu crash"
-      continue
-    fi
-
-    exit 42
-  done
-
-  rc=$(<"${output}/status")
-  $sudo rm -r "$output"
-  exit $rc
-elif [[ "${1:-}" = "--exec-test" ]]; then
-  shift
-
-  mount -t bpf bpf /sys/fs/bpf
-  mount -t tracefs tracefs /sys/kernel/debug/tracing
-
-  if [[ -d "/run/input/bpf" ]]; then
-    export KERNEL_SELFTESTS="/run/input/bpf"
-  fi
-
-  if [[ -f "/run/input/bpf/bpf_testmod/bpf_testmod.ko" ]]; then
-    insmod "/run/input/bpf/bpf_testmod/bpf_testmod.ko"
-  fi
-
-  dmesg --clear
-  rc=0
-  "$@" || rc=$?
-  dmesg
-  echo $rc > "/run/output/status"
-  exit $rc # this return code is "swallowed" by qemu
-fi
-
-if [[ -z "${1:-}" ]]; then
-  echo "Expecting kernel version or path as first argument"
-  exit 1
-fi
-
-readonly input="$(mktemp -d)"
-readonly tmp_dir="${TMPDIR:-/tmp}"
-
-fetch() {
-    echo Fetching "${1}"
-    pushd "${tmp_dir}" > /dev/null
-    curl --no-progress-meter -L -O --fail --etag-compare "${1}.etag" --etag-save "${1}.etag" "https://github.com/cilium/ci-kernels/raw/${BRANCH:-master}/${1}"
-    local ret=$?
-    popd > /dev/null
-    return $ret
-}
-
-if [[ -f "${1}" ]]; then
-  readonly kernel="${1}"
-  cp "${1}" "${input}/bzImage"
-else
-# LINUX_VERSION_CODE test compares this to discovered value.
-  export KERNEL_VERSION="${1}"
-
-  readonly kernel="linux-${1}.bz"
-  readonly selftests="linux-${1}-selftests-bpf.tgz"
-
-  fetch "${kernel}"
-  cp "${tmp_dir}/${kernel}" "${input}/bzImage"
-
-  if fetch "${selftests}"; then
-    echo "Decompressing selftests"
-    mkdir "${input}/bpf"
-    tar --strip-components=4 -xf "${tmp_dir}/${selftests}" -C "${input}/bpf"
-  else
-    echo "No selftests found, disabling"
-  fi
-fi
-shift
-
-args=(-short -coverpkg=./... -coverprofile=coverage.out -count 1 ./...)
-if (( $# > 0 )); then
-  args=("$@")
-fi
-
-export GOFLAGS=-mod=readonly
-export CGO_ENABLED=0
-
-echo Testing on "${kernel}"
-go test -exec "$script --exec-vm $input" "${args[@]}"
-echo "Test successful on ${kernel}"
-
-rm -r "${input}"
diff --git a/vendor/github.com/cilium/ebpf/syscalls.go b/vendor/github.com/cilium/ebpf/syscalls.go
deleted file mode 100644
index fd21dea24..000000000
--- a/vendor/github.com/cilium/ebpf/syscalls.go
+++ /dev/null
@@ -1,305 +0,0 @@
-package ebpf
-
-import (
-	"bytes"
-	"errors"
-	"fmt"
-	"os"
-	"runtime"
-
-	"github.com/cilium/ebpf/asm"
-	"github.com/cilium/ebpf/internal"
-	"github.com/cilium/ebpf/internal/sys"
-	"github.com/cilium/ebpf/internal/tracefs"
-	"github.com/cilium/ebpf/internal/unix"
-)
-
-var (
-	// pre-allocating these here since they may
-	// get called in hot code paths and cause
-	// unnecessary memory allocations
-	sysErrKeyNotExist  = sys.Error(ErrKeyNotExist, unix.ENOENT)
-	sysErrKeyExist     = sys.Error(ErrKeyExist, unix.EEXIST)
-	sysErrNotSupported = sys.Error(ErrNotSupported, sys.ENOTSUPP)
-)
-
-// invalidBPFObjNameChar returns true if char may not appear in
-// a BPF object name.
-func invalidBPFObjNameChar(char rune) bool {
-	dotAllowed := objNameAllowsDot() == nil
-
-	switch {
-	case char >= 'A' && char <= 'Z':
-		return false
-	case char >= 'a' && char <= 'z':
-		return false
-	case char >= '0' && char <= '9':
-		return false
-	case dotAllowed && char == '.':
-		return false
-	case char == '_':
-		return false
-	default:
-		return true
-	}
-}
-
-func progLoad(insns asm.Instructions, typ ProgramType, license string) (*sys.FD, error) {
-	buf := bytes.NewBuffer(make([]byte, 0, insns.Size()))
-	if err := insns.Marshal(buf, internal.NativeEndian); err != nil {
-		return nil, err
-	}
-	bytecode := buf.Bytes()
-
-	return sys.ProgLoad(&sys.ProgLoadAttr{
-		ProgType: sys.ProgType(typ),
-		License:  sys.NewStringPointer(license),
-		Insns:    sys.NewSlicePointer(bytecode),
-		InsnCnt:  uint32(len(bytecode) / asm.InstructionSize),
-	})
-}
-
-var haveNestedMaps = internal.NewFeatureTest("nested maps", "4.12", func() error {
-	_, err := sys.MapCreate(&sys.MapCreateAttr{
-		MapType:    sys.MapType(ArrayOfMaps),
-		KeySize:    4,
-		ValueSize:  4,
-		MaxEntries: 1,
-		// Invalid file descriptor.
-		InnerMapFd: ^uint32(0),
-	})
-	if errors.Is(err, unix.EINVAL) {
-		return internal.ErrNotSupported
-	}
-	if errors.Is(err, unix.EBADF) {
-		return nil
-	}
-	return err
-})
-
-var haveMapMutabilityModifiers = internal.NewFeatureTest("read- and write-only maps", "5.2", func() error {
-	// This checks BPF_F_RDONLY_PROG and BPF_F_WRONLY_PROG. Since
-	// BPF_MAP_FREEZE appeared in 5.2 as well we don't do a separate check.
-	m, err := sys.MapCreate(&sys.MapCreateAttr{
-		MapType:    sys.MapType(Array),
-		KeySize:    4,
-		ValueSize:  4,
-		MaxEntries: 1,
-		MapFlags:   unix.BPF_F_RDONLY_PROG,
-	})
-	if err != nil {
-		return internal.ErrNotSupported
-	}
-	_ = m.Close()
-	return nil
-})
-
-var haveMmapableMaps = internal.NewFeatureTest("mmapable maps", "5.5", func() error {
-	// This checks BPF_F_MMAPABLE, which appeared in 5.5 for array maps.
-	m, err := sys.MapCreate(&sys.MapCreateAttr{
-		MapType:    sys.MapType(Array),
-		KeySize:    4,
-		ValueSize:  4,
-		MaxEntries: 1,
-		MapFlags:   unix.BPF_F_MMAPABLE,
-	})
-	if err != nil {
-		return internal.ErrNotSupported
-	}
-	_ = m.Close()
-	return nil
-})
-
-var haveInnerMaps = internal.NewFeatureTest("inner maps", "5.10", func() error {
-	// This checks BPF_F_INNER_MAP, which appeared in 5.10.
-	m, err := sys.MapCreate(&sys.MapCreateAttr{
-		MapType:    sys.MapType(Array),
-		KeySize:    4,
-		ValueSize:  4,
-		MaxEntries: 1,
-		MapFlags:   unix.BPF_F_INNER_MAP,
-	})
-	if err != nil {
-		return internal.ErrNotSupported
-	}
-	_ = m.Close()
-	return nil
-})
-
-var haveNoPreallocMaps = internal.NewFeatureTest("prealloc maps", "4.6", func() error {
-	// This checks BPF_F_NO_PREALLOC, which appeared in 4.6.
-	m, err := sys.MapCreate(&sys.MapCreateAttr{
-		MapType:    sys.MapType(Hash),
-		KeySize:    4,
-		ValueSize:  4,
-		MaxEntries: 1,
-		MapFlags:   unix.BPF_F_NO_PREALLOC,
-	})
-	if err != nil {
-		return internal.ErrNotSupported
-	}
-	_ = m.Close()
-	return nil
-})
-
-func wrapMapError(err error) error {
-	if err == nil {
-		return nil
-	}
-
-	if errors.Is(err, unix.ENOENT) {
-		return sysErrKeyNotExist
-	}
-
-	if errors.Is(err, unix.EEXIST) {
-		return sysErrKeyExist
-	}
-
-	if errors.Is(err, sys.ENOTSUPP) {
-		return sysErrNotSupported
-	}
-
-	if errors.Is(err, unix.E2BIG) {
-		return fmt.Errorf("key too big for map: %w", err)
-	}
-
-	return err
-}
-
-var haveObjName = internal.NewFeatureTest("object names", "4.15", func() error {
-	attr := sys.MapCreateAttr{
-		MapType:    sys.MapType(Array),
-		KeySize:    4,
-		ValueSize:  4,
-		MaxEntries: 1,
-		MapName:    sys.NewObjName("feature_test"),
-	}
-
-	fd, err := sys.MapCreate(&attr)
-	if err != nil {
-		return internal.ErrNotSupported
-	}
-
-	_ = fd.Close()
-	return nil
-})
-
-var objNameAllowsDot = internal.NewFeatureTest("dot in object names", "5.2", func() error {
-	if err := haveObjName(); err != nil {
-		return err
-	}
-
-	attr := sys.MapCreateAttr{
-		MapType:    sys.MapType(Array),
-		KeySize:    4,
-		ValueSize:  4,
-		MaxEntries: 1,
-		MapName:    sys.NewObjName(".test"),
-	}
-
-	fd, err := sys.MapCreate(&attr)
-	if err != nil {
-		return internal.ErrNotSupported
-	}
-
-	_ = fd.Close()
-	return nil
-})
-
-var haveBatchAPI = internal.NewFeatureTest("map batch api", "5.6", func() error {
-	var maxEntries uint32 = 2
-	attr := sys.MapCreateAttr{
-		MapType:    sys.MapType(Hash),
-		KeySize:    4,
-		ValueSize:  4,
-		MaxEntries: maxEntries,
-	}
-
-	fd, err := sys.MapCreate(&attr)
-	if err != nil {
-		return internal.ErrNotSupported
-	}
-	defer fd.Close()
-
-	keys := []uint32{1, 2}
-	values := []uint32{3, 4}
-	kp, _ := marshalPtr(keys, 8)
-	vp, _ := marshalPtr(values, 8)
-
-	err = sys.MapUpdateBatch(&sys.MapUpdateBatchAttr{
-		MapFd:  fd.Uint(),
-		Keys:   kp,
-		Values: vp,
-		Count:  maxEntries,
-	})
-	if err != nil {
-		return internal.ErrNotSupported
-	}
-	return nil
-})
-
-var haveProbeReadKernel = internal.NewFeatureTest("bpf_probe_read_kernel", "5.5", func() error {
-	insns := asm.Instructions{
-		asm.Mov.Reg(asm.R1, asm.R10),
-		asm.Add.Imm(asm.R1, -8),
-		asm.Mov.Imm(asm.R2, 8),
-		asm.Mov.Imm(asm.R3, 0),
-		asm.FnProbeReadKernel.Call(),
-		asm.Return(),
-	}
-
-	fd, err := progLoad(insns, Kprobe, "GPL")
-	if err != nil {
-		return internal.ErrNotSupported
-	}
-	_ = fd.Close()
-	return nil
-})
-
-var haveBPFToBPFCalls = internal.NewFeatureTest("bpf2bpf calls", "4.16", func() error {
-	insns := asm.Instructions{
-		asm.Call.Label("prog2").WithSymbol("prog1"),
-		asm.Return(),
-		asm.Mov.Imm(asm.R0, 0).WithSymbol("prog2"),
-		asm.Return(),
-	}
-
-	fd, err := progLoad(insns, SocketFilter, "MIT")
-	if errors.Is(err, unix.EINVAL) {
-		return internal.ErrNotSupported
-	}
-	if err != nil {
-		return err
-	}
-	_ = fd.Close()
-	return nil
-})
-
-var haveSyscallWrapper = internal.NewFeatureTest("syscall wrapper", "4.17", func() error {
-	prefix := internal.PlatformPrefix()
-	if prefix == "" {
-		return fmt.Errorf("unable to find the platform prefix for (%s)", runtime.GOARCH)
-	}
-
-	args := tracefs.ProbeArgs{
-		Type:   tracefs.Kprobe,
-		Symbol: prefix + "sys_bpf",
-		Pid:    -1,
-	}
-
-	var err error
-	args.Group, err = tracefs.RandomGroup("ebpf_probe")
-	if err != nil {
-		return err
-	}
-
-	evt, err := tracefs.NewEvent(args)
-	if errors.Is(err, os.ErrNotExist) {
-		return internal.ErrNotSupported
-	}
-	if err != nil {
-		return err
-	}
-
-	return evt.Close()
-})
diff --git a/vendor/github.com/cilium/ebpf/types.go b/vendor/github.com/cilium/ebpf/types.go
deleted file mode 100644
index 35927e2ab..000000000
--- a/vendor/github.com/cilium/ebpf/types.go
+++ /dev/null
@@ -1,279 +0,0 @@
-package ebpf
-
-import (
-	"github.com/cilium/ebpf/internal/sys"
-	"github.com/cilium/ebpf/internal/unix"
-)
-
-//go:generate stringer -output types_string.go -type=MapType,ProgramType,PinType
-
-// MapType indicates the type map structure
-// that will be initialized in the kernel.
-type MapType uint32
-
-// All the various map types that can be created
-const (
-	UnspecifiedMap MapType = iota
-	// Hash is a hash map
-	Hash
-	// Array is an array map
-	Array
-	// ProgramArray - A program array map is a special kind of array map whose map
-	// values contain only file descriptors referring to other eBPF
-	// programs.  Thus, both the key_size and value_size must be
-	// exactly four bytes.  This map is used in conjunction with the
-	// TailCall helper.
-	ProgramArray
-	// PerfEventArray - A perf event array is used in conjunction with PerfEventRead
-	// and PerfEventOutput calls, to read the raw bpf_perf_data from the registers.
-	PerfEventArray
-	// PerCPUHash - This data structure is useful for people who have high performance
-	// network needs and can reconcile adds at the end of some cycle, so that
-	// hashes can be lock free without the use of XAdd, which can be costly.
-	PerCPUHash
-	// PerCPUArray - This data structure is useful for people who have high performance
-	// network needs and can reconcile adds at the end of some cycle, so that
-	// hashes can be lock free without the use of XAdd, which can be costly.
-	// Each CPU gets a copy of this hash, the contents of all of which can be reconciled
-	// later.
-	PerCPUArray
-	// StackTrace - This holds whole user and kernel stack traces, it can be retrieved with
-	// GetStackID
-	StackTrace
-	// CGroupArray - This is a very niche structure used to help SKBInCGroup determine
-	// if an skb is from a socket belonging to a specific cgroup
-	CGroupArray
-	// LRUHash - This allows you to create a small hash structure that will purge the
-	// least recently used items rather than thow an error when you run out of memory
-	LRUHash
-	// LRUCPUHash - This is NOT like PerCPUHash, this structure is shared among the CPUs,
-	// it has more to do with including the CPU id with the LRU calculation so that if a
-	// particular CPU is using a value over-and-over again, then it will be saved, but if
-	// a value is being retrieved a lot but sparsely across CPUs it is not as important, basically
-	// giving weight to CPU locality over overall usage.
-	LRUCPUHash
-	// LPMTrie - This is an implementation of Longest-Prefix-Match Trie structure. It is useful,
-	// for storing things like IP addresses which can be bit masked allowing for keys of differing
-	// values to refer to the same reference based on their masks. See wikipedia for more details.
-	LPMTrie
-	// ArrayOfMaps - Each item in the array is another map. The inner map mustn't be a map of maps
-	// itself.
-	ArrayOfMaps
-	// HashOfMaps - Each item in the hash map is another map. The inner map mustn't be a map of maps
-	// itself.
-	HashOfMaps
-	// DevMap - Specialized map to store references to network devices.
-	DevMap
-	// SockMap - Specialized map to store references to sockets.
-	SockMap
-	// CPUMap - Specialized map to store references to CPUs.
-	CPUMap
-	// XSKMap - Specialized map for XDP programs to store references to open sockets.
-	XSKMap
-	// SockHash - Specialized hash to store references to sockets.
-	SockHash
-	// CGroupStorage - Special map for CGroups.
-	CGroupStorage
-	// ReusePortSockArray - Specialized map to store references to sockets that can be reused.
-	ReusePortSockArray
-	// PerCPUCGroupStorage - Special per CPU map for CGroups.
-	PerCPUCGroupStorage
-	// Queue - FIFO storage for BPF programs.
-	Queue
-	// Stack - LIFO storage for BPF programs.
-	Stack
-	// SkStorage - Specialized map for local storage at SK for BPF programs.
-	SkStorage
-	// DevMapHash - Hash-based indexing scheme for references to network devices.
-	DevMapHash
-	// StructOpsMap - This map holds a kernel struct with its function pointer implemented in a BPF
-	// program.
-	StructOpsMap
-	// RingBuf - Similar to PerfEventArray, but shared across all CPUs.
-	RingBuf
-	// InodeStorage - Specialized local storage map for inodes.
-	InodeStorage
-	// TaskStorage - Specialized local storage map for task_struct.
-	TaskStorage
-)
-
-// hasPerCPUValue returns true if the Map stores a value per CPU.
-func (mt MapType) hasPerCPUValue() bool {
-	return mt == PerCPUHash || mt == PerCPUArray || mt == LRUCPUHash || mt == PerCPUCGroupStorage
-}
-
-// canStoreMap returns true if the map type accepts a map fd
-// for update and returns a map id for lookup.
-func (mt MapType) canStoreMap() bool {
-	return mt == ArrayOfMaps || mt == HashOfMaps
-}
-
-// canStoreProgram returns true if the map type accepts a program fd
-// for update and returns a program id for lookup.
-func (mt MapType) canStoreProgram() bool {
-	return mt == ProgramArray
-}
-
-// ProgramType of the eBPF program
-type ProgramType uint32
-
-// eBPF program types
-const (
-	UnspecifiedProgram ProgramType = iota
-	SocketFilter
-	Kprobe
-	SchedCLS
-	SchedACT
-	TracePoint
-	XDP
-	PerfEvent
-	CGroupSKB
-	CGroupSock
-	LWTIn
-	LWTOut
-	LWTXmit
-	SockOps
-	SkSKB
-	CGroupDevice
-	SkMsg
-	RawTracepoint
-	CGroupSockAddr
-	LWTSeg6Local
-	LircMode2
-	SkReuseport
-	FlowDissector
-	CGroupSysctl
-	RawTracepointWritable
-	CGroupSockopt
-	Tracing
-	StructOps
-	Extension
-	LSM
-	SkLookup
-	Syscall
-)
-
-// AttachType of the eBPF program, needed to differentiate allowed context accesses in
-// some newer program types like CGroupSockAddr. Should be set to AttachNone if not required.
-// Will cause invalid argument (EINVAL) at program load time if set incorrectly.
-type AttachType uint32
-
-//go:generate stringer -type AttachType -trimprefix Attach
-
-// AttachNone is an alias for AttachCGroupInetIngress for readability reasons.
-const AttachNone AttachType = 0
-
-const (
-	AttachCGroupInetIngress AttachType = iota
-	AttachCGroupInetEgress
-	AttachCGroupInetSockCreate
-	AttachCGroupSockOps
-	AttachSkSKBStreamParser
-	AttachSkSKBStreamVerdict
-	AttachCGroupDevice
-	AttachSkMsgVerdict
-	AttachCGroupInet4Bind
-	AttachCGroupInet6Bind
-	AttachCGroupInet4Connect
-	AttachCGroupInet6Connect
-	AttachCGroupInet4PostBind
-	AttachCGroupInet6PostBind
-	AttachCGroupUDP4Sendmsg
-	AttachCGroupUDP6Sendmsg
-	AttachLircMode2
-	AttachFlowDissector
-	AttachCGroupSysctl
-	AttachCGroupUDP4Recvmsg
-	AttachCGroupUDP6Recvmsg
-	AttachCGroupGetsockopt
-	AttachCGroupSetsockopt
-	AttachTraceRawTp
-	AttachTraceFEntry
-	AttachTraceFExit
-	AttachModifyReturn
-	AttachLSMMac
-	AttachTraceIter
-	AttachCgroupInet4GetPeername
-	AttachCgroupInet6GetPeername
-	AttachCgroupInet4GetSockname
-	AttachCgroupInet6GetSockname
-	AttachXDPDevMap
-	AttachCgroupInetSockRelease
-	AttachXDPCPUMap
-	AttachSkLookup
-	AttachXDP
-	AttachSkSKBVerdict
-	AttachSkReuseportSelect
-	AttachSkReuseportSelectOrMigrate
-	AttachPerfEvent
-	AttachTraceKprobeMulti
-)
-
-// AttachFlags of the eBPF program used in BPF_PROG_ATTACH command
-type AttachFlags uint32
-
-// PinType determines whether a map is pinned into a BPFFS.
-type PinType int
-
-// Valid pin types.
-//
-// Mirrors enum libbpf_pin_type.
-const (
-	PinNone PinType = iota
-	// Pin an object by using its name as the filename.
-	PinByName
-)
-
-// LoadPinOptions control how a pinned object is loaded.
-type LoadPinOptions struct {
-	// Request a read-only or write-only object. The default is a read-write
-	// object. Only one of the flags may be set.
-	ReadOnly  bool
-	WriteOnly bool
-
-	// Raw flags for the syscall. Other fields of this struct take precedence.
-	Flags uint32
-}
-
-// Marshal returns a value suitable for BPF_OBJ_GET syscall file_flags parameter.
-func (lpo *LoadPinOptions) Marshal() uint32 {
-	if lpo == nil {
-		return 0
-	}
-
-	flags := lpo.Flags
-	if lpo.ReadOnly {
-		flags |= unix.BPF_F_RDONLY
-	}
-	if lpo.WriteOnly {
-		flags |= unix.BPF_F_WRONLY
-	}
-	return flags
-}
-
-// BatchOptions batch map operations options
-//
-// Mirrors libbpf struct bpf_map_batch_opts
-// Currently BPF_F_FLAG is the only supported
-// flag (for ElemFlags).
-type BatchOptions struct {
-	ElemFlags uint64
-	Flags     uint64
-}
-
-// LogLevel controls the verbosity of the kernel's eBPF program verifier.
-// These constants can be used for the ProgramOptions.LogLevel field.
-type LogLevel = sys.LogLevel
-
-const (
-	// Print verifier state at branch points.
-	LogLevelBranch = sys.BPF_LOG_LEVEL1
-
-	// Print verifier state for every instruction.
-	// Available since Linux v5.2.
-	LogLevelInstruction = sys.BPF_LOG_LEVEL2
-
-	// Print verifier errors and stats at the end of the verification process.
-	// Available since Linux v5.2.
-	LogLevelStats = sys.BPF_LOG_STATS
-)
diff --git a/vendor/github.com/cilium/ebpf/types_string.go b/vendor/github.com/cilium/ebpf/types_string.go
deleted file mode 100644
index 5679f2254..000000000
--- a/vendor/github.com/cilium/ebpf/types_string.go
+++ /dev/null
@@ -1,118 +0,0 @@
-// Code generated by "stringer -output types_string.go -type=MapType,ProgramType,PinType"; DO NOT EDIT.
-
-package ebpf
-
-import "strconv"
-
-func _() {
-	// An "invalid array index" compiler error signifies that the constant values have changed.
-	// Re-run the stringer command to generate them again.
-	var x [1]struct{}
-	_ = x[UnspecifiedMap-0]
-	_ = x[Hash-1]
-	_ = x[Array-2]
-	_ = x[ProgramArray-3]
-	_ = x[PerfEventArray-4]
-	_ = x[PerCPUHash-5]
-	_ = x[PerCPUArray-6]
-	_ = x[StackTrace-7]
-	_ = x[CGroupArray-8]
-	_ = x[LRUHash-9]
-	_ = x[LRUCPUHash-10]
-	_ = x[LPMTrie-11]
-	_ = x[ArrayOfMaps-12]
-	_ = x[HashOfMaps-13]
-	_ = x[DevMap-14]
-	_ = x[SockMap-15]
-	_ = x[CPUMap-16]
-	_ = x[XSKMap-17]
-	_ = x[SockHash-18]
-	_ = x[CGroupStorage-19]
-	_ = x[ReusePortSockArray-20]
-	_ = x[PerCPUCGroupStorage-21]
-	_ = x[Queue-22]
-	_ = x[Stack-23]
-	_ = x[SkStorage-24]
-	_ = x[DevMapHash-25]
-	_ = x[StructOpsMap-26]
-	_ = x[RingBuf-27]
-	_ = x[InodeStorage-28]
-	_ = x[TaskStorage-29]
-}
-
-const _MapType_name = "UnspecifiedMapHashArrayProgramArrayPerfEventArrayPerCPUHashPerCPUArrayStackTraceCGroupArrayLRUHashLRUCPUHashLPMTrieArrayOfMapsHashOfMapsDevMapSockMapCPUMapXSKMapSockHashCGroupStorageReusePortSockArrayPerCPUCGroupStorageQueueStackSkStorageDevMapHashStructOpsMapRingBufInodeStorageTaskStorage"
-
-var _MapType_index = [...]uint16{0, 14, 18, 23, 35, 49, 59, 70, 80, 91, 98, 108, 115, 126, 136, 142, 149, 155, 161, 169, 182, 200, 219, 224, 229, 238, 248, 260, 267, 279, 290}
-
-func (i MapType) String() string {
-	if i >= MapType(len(_MapType_index)-1) {
-		return "MapType(" + strconv.FormatInt(int64(i), 10) + ")"
-	}
-	return _MapType_name[_MapType_index[i]:_MapType_index[i+1]]
-}
-func _() {
-	// An "invalid array index" compiler error signifies that the constant values have changed.
-	// Re-run the stringer command to generate them again.
-	var x [1]struct{}
-	_ = x[UnspecifiedProgram-0]
-	_ = x[SocketFilter-1]
-	_ = x[Kprobe-2]
-	_ = x[SchedCLS-3]
-	_ = x[SchedACT-4]
-	_ = x[TracePoint-5]
-	_ = x[XDP-6]
-	_ = x[PerfEvent-7]
-	_ = x[CGroupSKB-8]
-	_ = x[CGroupSock-9]
-	_ = x[LWTIn-10]
-	_ = x[LWTOut-11]
-	_ = x[LWTXmit-12]
-	_ = x[SockOps-13]
-	_ = x[SkSKB-14]
-	_ = x[CGroupDevice-15]
-	_ = x[SkMsg-16]
-	_ = x[RawTracepoint-17]
-	_ = x[CGroupSockAddr-18]
-	_ = x[LWTSeg6Local-19]
-	_ = x[LircMode2-20]
-	_ = x[SkReuseport-21]
-	_ = x[FlowDissector-22]
-	_ = x[CGroupSysctl-23]
-	_ = x[RawTracepointWritable-24]
-	_ = x[CGroupSockopt-25]
-	_ = x[Tracing-26]
-	_ = x[StructOps-27]
-	_ = x[Extension-28]
-	_ = x[LSM-29]
-	_ = x[SkLookup-30]
-	_ = x[Syscall-31]
-}
-
-const _ProgramType_name = "UnspecifiedProgramSocketFilterKprobeSchedCLSSchedACTTracePointXDPPerfEventCGroupSKBCGroupSockLWTInLWTOutLWTXmitSockOpsSkSKBCGroupDeviceSkMsgRawTracepointCGroupSockAddrLWTSeg6LocalLircMode2SkReuseportFlowDissectorCGroupSysctlRawTracepointWritableCGroupSockoptTracingStructOpsExtensionLSMSkLookupSyscall"
-
-var _ProgramType_index = [...]uint16{0, 18, 30, 36, 44, 52, 62, 65, 74, 83, 93, 98, 104, 111, 118, 123, 135, 140, 153, 167, 179, 188, 199, 212, 224, 245, 258, 265, 274, 283, 286, 294, 301}
-
-func (i ProgramType) String() string {
-	if i >= ProgramType(len(_ProgramType_index)-1) {
-		return "ProgramType(" + strconv.FormatInt(int64(i), 10) + ")"
-	}
-	return _ProgramType_name[_ProgramType_index[i]:_ProgramType_index[i+1]]
-}
-func _() {
-	// An "invalid array index" compiler error signifies that the constant values have changed.
-	// Re-run the stringer command to generate them again.
-	var x [1]struct{}
-	_ = x[PinNone-0]
-	_ = x[PinByName-1]
-}
-
-const _PinType_name = "PinNonePinByName"
-
-var _PinType_index = [...]uint8{0, 7, 16}
-
-func (i PinType) String() string {
-	if i < 0 || i >= PinType(len(_PinType_index)-1) {
-		return "PinType(" + strconv.FormatInt(int64(i), 10) + ")"
-	}
-	return _PinType_name[_PinType_index[i]:_PinType_index[i+1]]
-}
diff --git a/vendor/github.com/containers/image/v5/copy/compression.go b/vendor/github.com/containers/image/v5/copy/compression.go
index 318450a3a..081c49312 100644
--- a/vendor/github.com/containers/image/v5/copy/compression.go
+++ b/vendor/github.com/containers/image/v5/copy/compression.go
@@ -11,6 +11,7 @@ import (
 	"github.com/containers/image/v5/pkg/compression"
 	compressiontypes "github.com/containers/image/v5/pkg/compression/types"
 	"github.com/containers/image/v5/types"
+	chunkedToc "github.com/containers/storage/pkg/chunked/toc"
 	imgspecv1 "github.com/opencontainers/image-spec/specs-go/v1"
 	"github.com/sirupsen/logrus"
 )
@@ -34,10 +35,10 @@ var (
 
 // bpDetectCompressionStepData contains data that the copy pipeline needs about the “detect compression” step.
 type bpDetectCompressionStepData struct {
-	isCompressed      bool
-	format            compressiontypes.Algorithm        // Valid if isCompressed
-	decompressor      compressiontypes.DecompressorFunc // Valid if isCompressed
-	srcCompressorName string                            // Compressor name to possibly record in the blob info cache for the source blob.
+	isCompressed                 bool
+	format                       compressiontypes.Algorithm        // Valid if isCompressed
+	decompressor                 compressiontypes.DecompressorFunc // Valid if isCompressed
+	srcCompressorBaseVariantName string                            // Compressor name to possibly record in the blob info cache for the source blob.
 }
 
 // blobPipelineDetectCompressionStep updates *stream to detect its current compression format.
@@ -57,9 +58,9 @@ func blobPipelineDetectCompressionStep(stream *sourceStream, srcInfo types.BlobI
 		decompressor: decompressor,
 	}
 	if res.isCompressed {
-		res.srcCompressorName = format.Name()
+		res.srcCompressorBaseVariantName = format.BaseVariantName()
 	} else {
-		res.srcCompressorName = internalblobinfocache.Uncompressed
+		res.srcCompressorBaseVariantName = internalblobinfocache.Uncompressed
 	}
 
 	if expectedBaseFormat, known := expectedBaseCompressionFormats[stream.info.MediaType]; known && res.isCompressed && format.BaseVariantName() != expectedBaseFormat.Name() {
@@ -70,13 +71,13 @@ func blobPipelineDetectCompressionStep(stream *sourceStream, srcInfo types.BlobI
 
 // bpCompressionStepData contains data that the copy pipeline needs about the compression step.
 type bpCompressionStepData struct {
-	operation              bpcOperation                // What we are actually doing
-	uploadedOperation      types.LayerCompression      // Operation to use for updating the blob metadata (matching the end state, not necessarily what we do)
-	uploadedAlgorithm      *compressiontypes.Algorithm // An algorithm parameter for the compressionOperation edits.
-	uploadedAnnotations    map[string]string           // Compression-related annotations that should be set on the uploaded blob. WARNING: This is only set after the srcStream.reader is fully consumed.
-	srcCompressorName      string                      // Compressor name to record in the blob info cache for the source blob.
-	uploadedCompressorName string                      // Compressor name to record in the blob info cache for the uploaded blob.
-	closers                []io.Closer                 // Objects to close after the upload is done, if any.
+	operation                    bpcOperation                // What we are actually doing
+	uploadedOperation            types.LayerCompression      // Operation to use for updating the blob metadata (matching the end state, not necessarily what we do)
+	uploadedAlgorithm            *compressiontypes.Algorithm // An algorithm parameter for the compressionOperation edits.
+	uploadedAnnotations          map[string]string           // Compression-related annotations that should be set on the uploaded blob. WARNING: This is only set after the srcStream.reader is fully consumed.
+	srcCompressorBaseVariantName string                      // Compressor base variant name to record in the blob info cache for the source blob.
+	uploadedCompressorName       string                      // Compressor name to record in the blob info cache for the uploaded blob.
+	closers                      []io.Closer                 // Objects to close after the upload is done, if any.
 }
 
 type bpcOperation int
@@ -128,11 +129,11 @@ func (ic *imageCopier) bpcPreserveEncrypted(stream *sourceStream, _ bpDetectComp
 		// We can’t do anything with an encrypted blob unless decrypted.
 		logrus.Debugf("Using original blob without modification for encrypted blob")
 		return &bpCompressionStepData{
-			operation:              bpcOpPreserveOpaque,
-			uploadedOperation:      types.PreserveOriginal,
-			uploadedAlgorithm:      nil,
-			srcCompressorName:      internalblobinfocache.UnknownCompression,
-			uploadedCompressorName: internalblobinfocache.UnknownCompression,
+			operation:                    bpcOpPreserveOpaque,
+			uploadedOperation:            types.PreserveOriginal,
+			uploadedAlgorithm:            nil,
+			srcCompressorBaseVariantName: internalblobinfocache.UnknownCompression,
+			uploadedCompressorName:       internalblobinfocache.UnknownCompression,
 		}, nil
 	}
 	return nil, nil
@@ -157,13 +158,13 @@ func (ic *imageCopier) bpcCompressUncompressed(stream *sourceStream, detected bp
 			Size:   -1,
 		}
 		return &bpCompressionStepData{
-			operation:              bpcOpCompressUncompressed,
-			uploadedOperation:      types.Compress,
-			uploadedAlgorithm:      uploadedAlgorithm,
-			uploadedAnnotations:    annotations,
-			srcCompressorName:      detected.srcCompressorName,
-			uploadedCompressorName: uploadedAlgorithm.Name(),
-			closers:                []io.Closer{reader},
+			operation:                    bpcOpCompressUncompressed,
+			uploadedOperation:            types.Compress,
+			uploadedAlgorithm:            uploadedAlgorithm,
+			uploadedAnnotations:          annotations,
+			srcCompressorBaseVariantName: detected.srcCompressorBaseVariantName,
+			uploadedCompressorName:       uploadedAlgorithm.Name(),
+			closers:                      []io.Closer{reader},
 		}, nil
 	}
 	return nil, nil
@@ -198,13 +199,13 @@ func (ic *imageCopier) bpcRecompressCompressed(stream *sourceStream, detected bp
 		}
 		succeeded = true
 		return &bpCompressionStepData{
-			operation:              bpcOpRecompressCompressed,
-			uploadedOperation:      types.PreserveOriginal,
-			uploadedAlgorithm:      ic.compressionFormat,
-			uploadedAnnotations:    annotations,
-			srcCompressorName:      detected.srcCompressorName,
-			uploadedCompressorName: ic.compressionFormat.Name(),
-			closers:                []io.Closer{decompressed, recompressed},
+			operation:                    bpcOpRecompressCompressed,
+			uploadedOperation:            types.PreserveOriginal,
+			uploadedAlgorithm:            ic.compressionFormat,
+			uploadedAnnotations:          annotations,
+			srcCompressorBaseVariantName: detected.srcCompressorBaseVariantName,
+			uploadedCompressorName:       ic.compressionFormat.Name(),
+			closers:                      []io.Closer{decompressed, recompressed},
 		}, nil
 	}
 	return nil, nil
@@ -225,12 +226,12 @@ func (ic *imageCopier) bpcDecompressCompressed(stream *sourceStream, detected bp
 			Size:   -1,
 		}
 		return &bpCompressionStepData{
-			operation:              bpcOpDecompressCompressed,
-			uploadedOperation:      types.Decompress,
-			uploadedAlgorithm:      nil,
-			srcCompressorName:      detected.srcCompressorName,
-			uploadedCompressorName: internalblobinfocache.Uncompressed,
-			closers:                []io.Closer{s},
+			operation:                    bpcOpDecompressCompressed,
+			uploadedOperation:            types.Decompress,
+			uploadedAlgorithm:            nil,
+			srcCompressorBaseVariantName: detected.srcCompressorBaseVariantName,
+			uploadedCompressorName:       internalblobinfocache.Uncompressed,
+			closers:                      []io.Closer{s},
 		}, nil
 	}
 	return nil, nil
@@ -268,11 +269,14 @@ func (ic *imageCopier) bpcPreserveOriginal(_ *sourceStream, detected bpDetectCom
 		algorithm = nil
 	}
 	return &bpCompressionStepData{
-		operation:              bpcOp,
-		uploadedOperation:      uploadedOp,
-		uploadedAlgorithm:      algorithm,
-		srcCompressorName:      detected.srcCompressorName,
-		uploadedCompressorName: detected.srcCompressorName,
+		operation:                    bpcOp,
+		uploadedOperation:            uploadedOp,
+		uploadedAlgorithm:            algorithm,
+		srcCompressorBaseVariantName: detected.srcCompressorBaseVariantName,
+		// We only record the base variant of the format on upload; we didn’t do anything with
+		// the TOC, we don’t know whether it matches the blob digest, so we don’t want to trigger
+		// reuse of any kind between the blob digest and the TOC digest.
+		uploadedCompressorName: detected.srcCompressorBaseVariantName,
 	}
 }
 
@@ -308,6 +312,15 @@ func (d *bpCompressionStepData) recordValidatedDigestData(c *copier, uploadedInf
 			// No useful information
 		case bpcOpCompressUncompressed:
 			c.blobInfoCache.RecordDigestUncompressedPair(uploadedInfo.Digest, srcInfo.Digest)
+			if d.uploadedAnnotations != nil {
+				tocDigest, err := chunkedToc.GetTOCDigest(d.uploadedAnnotations)
+				if err != nil {
+					return fmt.Errorf("parsing just-created compression annotations: %w", err)
+				}
+				if tocDigest != nil {
+					c.blobInfoCache.RecordTOCUncompressedPair(*tocDigest, srcInfo.Digest)
+				}
+			}
 		case bpcOpDecompressCompressed:
 			c.blobInfoCache.RecordDigestUncompressedPair(srcInfo.Digest, uploadedInfo.Digest)
 		case bpcOpRecompressCompressed, bpcOpPreserveCompressed:
@@ -323,9 +336,9 @@ func (d *bpCompressionStepData) recordValidatedDigestData(c *copier, uploadedInf
 			return fmt.Errorf("Internal error: Unexpected d.operation value %#v", d.operation)
 		}
 	}
-	if d.srcCompressorName == "" || d.uploadedCompressorName == "" {
-		return fmt.Errorf("internal error: missing compressor names (src: %q, uploaded: %q)",
-			d.srcCompressorName, d.uploadedCompressorName)
+	if d.srcCompressorBaseVariantName == "" || d.uploadedCompressorName == "" {
+		return fmt.Errorf("internal error: missing compressor names (src base: %q, uploaded: %q)",
+			d.srcCompressorBaseVariantName, d.uploadedCompressorName)
 	}
 	if d.uploadedCompressorName != internalblobinfocache.UnknownCompression {
 		if d.uploadedCompressorName != compressiontypes.ZstdChunkedAlgorithmName {
@@ -337,15 +350,19 @@ func (d *bpCompressionStepData) recordValidatedDigestData(c *copier, uploadedInf
 			// between zstd and zstd:chunked; so we could, in varying situations over time, call RecordDigestCompressorName
 			// with the same digest and both ZstdAlgorithmName and ZstdChunkedAlgorithmName , which causes warnings about
 			// inconsistent data to be logged.
-			c.blobInfoCache.RecordDigestCompressorName(uploadedInfo.Digest, d.uploadedCompressorName)
+			c.blobInfoCache.RecordDigestCompressorData(uploadedInfo.Digest, internalblobinfocache.DigestCompressorData{
+				BaseVariantCompressor: d.uploadedCompressorName,
+			})
 		}
 	}
 	if srcInfo.Digest != "" && srcInfo.Digest != uploadedInfo.Digest &&
-		d.srcCompressorName != internalblobinfocache.UnknownCompression {
-		if d.srcCompressorName != compressiontypes.ZstdChunkedAlgorithmName {
-			// HACK: Don’t record zstd:chunked algorithms, see above.
-			c.blobInfoCache.RecordDigestCompressorName(srcInfo.Digest, d.srcCompressorName)
-		}
+		d.srcCompressorBaseVariantName != internalblobinfocache.UnknownCompression {
+		// If the source is already using some TOC-dependent variant, we either copied the
+		// blob as is, or perhaps decompressed it; either way we don’t trust the TOC digest,
+		// so record neither the variant name, nor the TOC digest.
+		c.blobInfoCache.RecordDigestCompressorData(srcInfo.Digest, internalblobinfocache.DigestCompressorData{
+			BaseVariantCompressor: d.srcCompressorBaseVariantName,
+		})
 	}
 	return nil
 }
diff --git a/vendor/github.com/containers/image/v5/copy/encryption.go b/vendor/github.com/containers/image/v5/copy/encryption.go
index 4259d355b..b5a88a914 100644
--- a/vendor/github.com/containers/image/v5/copy/encryption.go
+++ b/vendor/github.com/containers/image/v5/copy/encryption.go
@@ -48,7 +48,7 @@ func (ic *imageCopier) blobPipelineDecryptionStep(stream *sourceStream, srcInfo
 		Annotations: stream.info.Annotations,
 	}
 	// DecryptLayer supposedly returns a digest of the decrypted stream.
-	// In pratice, that value is never set in the current implementation.
+	// In practice, that value is never set in the current implementation.
 	// And we shouldn’t use it anyway, because it is not trusted: encryption can be made to a public key,
 	// i.e. it doesn’t authenticate the origin of the metadata in any way.
 	reader, _, err := ocicrypt.DecryptLayer(ic.c.options.OciDecryptConfig, stream.reader, desc, false)
diff --git a/vendor/github.com/containers/image/v5/copy/progress_bars.go b/vendor/github.com/containers/image/v5/copy/progress_bars.go
index 053650b8d..08128ce8d 100644
--- a/vendor/github.com/containers/image/v5/copy/progress_bars.go
+++ b/vendor/github.com/containers/image/v5/copy/progress_bars.go
@@ -121,7 +121,7 @@ func (c *copier) printCopyInfo(kind string, info types.BlobInfo) {
 	}
 }
 
-// mark100PercentComplete marks the progres bars as 100% complete;
+// mark100PercentComplete marks the progress bars as 100% complete;
 // it may do so by possibly advancing the current state if it is below the known total.
 func (bar *progressBar) mark100PercentComplete() {
 	if bar.originalSize > 0 {
diff --git a/vendor/github.com/containers/image/v5/copy/single.go b/vendor/github.com/containers/image/v5/copy/single.go
index 17cc8c833..714dc8136 100644
--- a/vendor/github.com/containers/image/v5/copy/single.go
+++ b/vendor/github.com/containers/image/v5/copy/single.go
@@ -149,6 +149,28 @@ func (c *copier) copySingleImage(ctx context.Context, unparsedImage *image.Unpar
 		ic.compressionFormat = c.options.DestinationCtx.CompressionFormat
 		ic.compressionLevel = c.options.DestinationCtx.CompressionLevel
 	}
+	// HACK: Don’t combine zstd:chunked and encryption.
+	// zstd:chunked can only usefully be consumed using range requests of parts of the layer, which would require the encryption
+	// to support decrypting arbitrary subsets of the stream. That’s plausible but not supported using the encryption API we have.
+	// Also, the chunked metadata is exposed in annotations unencrypted, which reveals the TOC digest = layer identity without
+	// encryption. (That can be determined from the unencrypted config anyway, but, still...)
+	//
+	// Ideally this should query a well-defined property of the compression algorithm (and $somehow determine the right fallback) instead of
+	// hard-coding zstd:chunked / zstd.
+	if ic.c.options.OciEncryptLayers != nil {
+		format := ic.compressionFormat
+		if format == nil {
+			format = defaultCompressionFormat
+		}
+		if format.Name() == compression.ZstdChunked.Name() {
+			if ic.requireCompressionFormatMatch {
+				return copySingleImageResult{}, errors.New("explicitly requested to combine zstd:chunked with encryption, which is not beneficial; use plain zstd instead")
+			}
+			logrus.Warnf("Compression using zstd:chunked is not beneficial for encrypted layers, using plain zstd instead")
+			ic.compressionFormat = &compression.Zstd
+		}
+	}
+
 	// Decide whether we can substitute blobs with semantic equivalents:
 	// - Don’t do that if we can’t modify the manifest at all
 	// - Ensure _this_ copy sees exactly the intended data when either processing a signed image or signing it.
@@ -192,7 +214,7 @@ func (c *copier) copySingleImage(ctx context.Context, unparsedImage *image.Unpar
 		shouldUpdateSigs := len(sigs) > 0 || len(c.signers) != 0 // TODO: Consider allowing signatures updates only and skipping the image's layers/manifest copy if possible
 		noPendingManifestUpdates := ic.noPendingManifestUpdates()
 
-		logrus.Debugf("Checking if we can skip copying: has signatures=%t, OCI encryption=%t, no manifest updates=%t, compression match required for resuing blobs=%t", shouldUpdateSigs, destRequiresOciEncryption, noPendingManifestUpdates, opts.requireCompressionFormatMatch)
+		logrus.Debugf("Checking if we can skip copying: has signatures=%t, OCI encryption=%t, no manifest updates=%t, compression match required for reusing blobs=%t", shouldUpdateSigs, destRequiresOciEncryption, noPendingManifestUpdates, opts.requireCompressionFormatMatch)
 		if !shouldUpdateSigs && !destRequiresOciEncryption && noPendingManifestUpdates && !ic.requireCompressionFormatMatch {
 			matchedResult, err := ic.compareImageDestinationManifestEqual(ctx, targetInstance)
 			if err != nil {
diff --git a/vendor/github.com/containers/image/v5/internal/blobinfocache/blobinfocache.go b/vendor/github.com/containers/image/v5/internal/blobinfocache/blobinfocache.go
index 893aa959d..f31ee3124 100644
--- a/vendor/github.com/containers/image/v5/internal/blobinfocache/blobinfocache.go
+++ b/vendor/github.com/containers/image/v5/internal/blobinfocache/blobinfocache.go
@@ -27,7 +27,14 @@ func (bic *v1OnlyBlobInfoCache) Open() {
 func (bic *v1OnlyBlobInfoCache) Close() {
 }
 
-func (bic *v1OnlyBlobInfoCache) RecordDigestCompressorName(anyDigest digest.Digest, compressorName string) {
+func (bic *v1OnlyBlobInfoCache) UncompressedDigestForTOC(tocDigest digest.Digest) digest.Digest {
+	return ""
+}
+
+func (bic *v1OnlyBlobInfoCache) RecordTOCUncompressedPair(tocDigest digest.Digest, uncompressed digest.Digest) {
+}
+
+func (bic *v1OnlyBlobInfoCache) RecordDigestCompressorData(anyDigest digest.Digest, data DigestCompressorData) {
 }
 
 func (bic *v1OnlyBlobInfoCache) CandidateLocations2(transport types.ImageTransport, scope types.BICTransportScope, digest digest.Digest, options CandidateLocations2Options) []BICReplacementCandidate2 {
diff --git a/vendor/github.com/containers/image/v5/internal/blobinfocache/types.go b/vendor/github.com/containers/image/v5/internal/blobinfocache/types.go
index c9e4aaa48..276c8073e 100644
--- a/vendor/github.com/containers/image/v5/internal/blobinfocache/types.go
+++ b/vendor/github.com/containers/image/v5/internal/blobinfocache/types.go
@@ -26,19 +26,34 @@ type BlobInfoCache2 interface {
 	// Close destroys state created by Open().
 	Close()
 
-	// RecordDigestCompressorName records a compressor for the blob with the specified digest,
-	// or Uncompressed or UnknownCompression.
-	// WARNING: Only call this with LOCALLY VERIFIED data; don’t record a compressor for a
-	// digest just because some remote author claims so (e.g. because a manifest says so);
+	// UncompressedDigestForTOC returns an uncompressed digest corresponding to anyDigest.
+	// Returns "" if the uncompressed digest is unknown.
+	UncompressedDigestForTOC(tocDigest digest.Digest) digest.Digest
+	// RecordTOCUncompressedPair records that the tocDigest corresponds to uncompressed.
+	// WARNING: Only call this for LOCALLY VERIFIED data; don’t record a digest pair just because some remote author claims so (e.g.
+	// because a manifest/config pair exists); otherwise the cache could be poisoned and allow substituting unexpected blobs.
+	// (Eventually, the DiffIDs in image config could detect the substitution, but that may be too late, and not all image formats contain that data.)
+	RecordTOCUncompressedPair(tocDigest digest.Digest, uncompressed digest.Digest)
+
+	// RecordDigestCompressorData records data for the blob with the specified digest.
+	// WARNING: Only call this with LOCALLY VERIFIED data:
+	//   - don’t record a compressor for a digest just because some remote author claims so
+	//     (e.g. because a manifest says so);
 	// otherwise the cache could be poisoned and cause us to make incorrect edits to type
 	// information in a manifest.
-	RecordDigestCompressorName(anyDigest digest.Digest, compressorName string)
+	RecordDigestCompressorData(anyDigest digest.Digest, data DigestCompressorData)
 	// CandidateLocations2 returns a prioritized, limited, number of blobs and their locations (if known)
 	// that could possibly be reused within the specified (transport scope) (if they still
 	// exist, which is not guaranteed).
 	CandidateLocations2(transport types.ImageTransport, scope types.BICTransportScope, digest digest.Digest, options CandidateLocations2Options) []BICReplacementCandidate2
 }
 
+// DigestCompressorData is information known about how a blob is compressed.
+// (This is worded generically, but basically targeted at the zstd / zstd:chunked situation.)
+type DigestCompressorData struct {
+	BaseVariantCompressor string // A compressor’s base variant name, or Uncompressed or UnknownCompression.
+}
+
 // CandidateLocations2Options are used in CandidateLocations2.
 type CandidateLocations2Options struct {
 	// If !CanSubstitute, the returned candidates will match the submitted digest exactly; if
diff --git a/vendor/github.com/containers/image/v5/manifest/docker_schema2.go b/vendor/github.com/containers/image/v5/manifest/docker_schema2.go
index 818166834..7e53f4f54 100644
--- a/vendor/github.com/containers/image/v5/manifest/docker_schema2.go
+++ b/vendor/github.com/containers/image/v5/manifest/docker_schema2.go
@@ -202,7 +202,7 @@ func (m *Schema2) ConfigInfo() types.BlobInfo {
 // The Digest field is guaranteed to be provided; Size may be -1.
 // WARNING: The list may contain duplicates, and they are semantically relevant.
 func (m *Schema2) LayerInfos() []LayerInfo {
-	blobs := []LayerInfo{}
+	blobs := make([]LayerInfo, 0, len(m.LayersDescriptors))
 	for _, layer := range m.LayersDescriptors {
 		blobs = append(blobs, LayerInfo{
 			BlobInfo:   BlobInfoFromSchema2Descriptor(layer),
diff --git a/vendor/github.com/containers/image/v5/manifest/oci.go b/vendor/github.com/containers/image/v5/manifest/oci.go
index 497cf476e..f714574ee 100644
--- a/vendor/github.com/containers/image/v5/manifest/oci.go
+++ b/vendor/github.com/containers/image/v5/manifest/oci.go
@@ -95,7 +95,7 @@ func (m *OCI1) ConfigInfo() types.BlobInfo {
 // The Digest field is guaranteed to be provided; Size may be -1.
 // WARNING: The list may contain duplicates, and they are semantically relevant.
 func (m *OCI1) LayerInfos() []LayerInfo {
-	blobs := []LayerInfo{}
+	blobs := make([]LayerInfo, 0, len(m.Layers))
 	for _, layer := range m.Layers {
 		blobs = append(blobs, LayerInfo{
 			BlobInfo:   BlobInfoFromOCI1Descriptor(layer),
diff --git a/vendor/github.com/containers/image/v5/ostree/ostree_src.go b/vendor/github.com/containers/image/v5/ostree/ostree_src.go
index 85a89f253..0b597ce26 100644
--- a/vendor/github.com/containers/image/v5/ostree/ostree_src.go
+++ b/vendor/github.com/containers/image/v5/ostree/ostree_src.go
@@ -151,9 +151,9 @@ func openRepo(path string) (*C.struct_OstreeRepo, error) {
 	var cerr *C.GError
 	cpath := C.CString(path)
 	defer C.free(unsafe.Pointer(cpath))
-	pathc := C.g_file_new_for_path(cpath)
-	defer C.g_object_unref(C.gpointer(pathc))
-	repo := C.ostree_repo_new(pathc)
+	file := C.g_file_new_for_path(cpath)
+	defer C.g_object_unref(C.gpointer(file))
+	repo := C.ostree_repo_new(file)
 	r := glib.GoBool(glib.GBoolean(C.ostree_repo_open(repo, nil, &cerr)))
 	if !r {
 		C.g_object_unref(C.gpointer(repo))
diff --git a/vendor/github.com/containers/image/v5/pkg/blobinfocache/internal/prioritize/prioritize.go b/vendor/github.com/containers/image/v5/pkg/blobinfocache/internal/prioritize/prioritize.go
index 9cd9c8f7d..03548209f 100644
--- a/vendor/github.com/containers/image/v5/pkg/blobinfocache/internal/prioritize/prioritize.go
+++ b/vendor/github.com/containers/image/v5/pkg/blobinfocache/internal/prioritize/prioritize.go
@@ -25,57 +25,103 @@ const replacementAttempts = 5
 // This is a heuristic/guess, and could well use a different value.
 const replacementUnknownLocationAttempts = 2
 
-// CandidateCompression returns (true, compressionOp, compressionAlgo) if a blob
-// with compressionName (which can be Uncompressed or UnknownCompression) is acceptable for a CandidateLocations* call with v2Options.
+// CandidateTemplate is a subset of BICReplacementCandidate2 with data related to a specific digest,
+// which can be later combined with information about a location.
+type CandidateTemplate struct {
+	digest               digest.Digest
+	compressionOperation types.LayerCompression // Either types.Decompress for uncompressed, or types.Compress for compressed
+	compressionAlgorithm *compression.Algorithm // An algorithm when the candidate is compressed, or nil when it is uncompressed
+}
+
+// CandidateTemplateWithCompression returns a CandidateTemplate if a blob with data is acceptable
+// for a CandidateLocations* call with v2Options.
 //
 // v2Options can be set to nil if the call is CandidateLocations (i.e. compression is not required to be known);
 // if not nil, the call is assumed to be CandidateLocations2.
-//
-// The (compressionOp, compressionAlgo) values are suitable for BICReplacementCandidate2
-func CandidateCompression(v2Options *blobinfocache.CandidateLocations2Options, digest digest.Digest, compressorName string) (bool, types.LayerCompression, *compression.Algorithm) {
+func CandidateTemplateWithCompression(v2Options *blobinfocache.CandidateLocations2Options, digest digest.Digest, data blobinfocache.DigestCompressorData) *CandidateTemplate {
 	if v2Options == nil {
-		return true, types.PreserveOriginal, nil // Anything goes. The (compressionOp, compressionAlgo) values are not used.
+		return &CandidateTemplate{ // Anything goes. The compressionOperation, compressionAlgorithm values are not used.
+			digest: digest,
+		}
 	}
 
-	var op types.LayerCompression
-	var algo *compression.Algorithm
-	switch compressorName {
+	requiredCompression := "nil"
+	if v2Options.RequiredCompression != nil {
+		requiredCompression = v2Options.RequiredCompression.Name()
+	}
+	switch data.BaseVariantCompressor {
 	case blobinfocache.Uncompressed:
-		op = types.Decompress
-		algo = nil
+		if !manifest.CandidateCompressionMatchesReuseConditions(manifest.ReuseConditions{
+			PossibleManifestFormats: v2Options.PossibleManifestFormats,
+			RequiredCompression:     v2Options.RequiredCompression,
+		}, nil) {
+			logrus.Debugf("Ignoring BlobInfoCache record of digest %q, uncompressed format does not match required %s or MIME types %#v",
+				digest.String(), requiredCompression, v2Options.PossibleManifestFormats)
+			return nil
+		}
+		return &CandidateTemplate{
+			digest:               digest,
+			compressionOperation: types.Decompress,
+			compressionAlgorithm: nil,
+		}
 	case blobinfocache.UnknownCompression:
 		logrus.Debugf("Ignoring BlobInfoCache record of digest %q with unknown compression", digest.String())
-		return false, types.PreserveOriginal, nil // Not allowed with CandidateLocations2
+		return nil // Not allowed with CandidateLocations2
 	default:
-		op = types.Compress
-		algo_, err := compression.AlgorithmByName(compressorName)
+		algo, err := compression.AlgorithmByName(data.BaseVariantCompressor)
 		if err != nil {
 			logrus.Debugf("Ignoring BlobInfoCache record of digest %q with unrecognized compression %q: %v",
-				digest.String(), compressorName, err)
-			return false, types.PreserveOriginal, nil // The BICReplacementCandidate2.CompressionAlgorithm field is required
+				digest.String(), data.BaseVariantCompressor, err)
+			return nil // The BICReplacementCandidate2.CompressionAlgorithm field is required
 		}
-		algo = &algo_
-	}
-	if !manifest.CandidateCompressionMatchesReuseConditions(manifest.ReuseConditions{
-		PossibleManifestFormats: v2Options.PossibleManifestFormats,
-		RequiredCompression:     v2Options.RequiredCompression,
-	}, algo) {
-		requiredCompresssion := "nil"
-		if v2Options.RequiredCompression != nil {
-			requiredCompresssion = v2Options.RequiredCompression.Name()
+		if !manifest.CandidateCompressionMatchesReuseConditions(manifest.ReuseConditions{
+			PossibleManifestFormats: v2Options.PossibleManifestFormats,
+			RequiredCompression:     v2Options.RequiredCompression,
+		}, &algo) {
+			logrus.Debugf("Ignoring BlobInfoCache record of digest %q, compression %q does not match required %s or MIME types %#v",
+				digest.String(), data.BaseVariantCompressor, requiredCompression, v2Options.PossibleManifestFormats)
+			return nil
+		}
+		return &CandidateTemplate{
+			digest:               digest,
+			compressionOperation: types.Compress,
+			compressionAlgorithm: &algo,
 		}
-		logrus.Debugf("Ignoring BlobInfoCache record of digest %q, compression %q does not match required %s or MIME types %#v",
-			digest.String(), compressorName, requiredCompresssion, v2Options.PossibleManifestFormats)
-		return false, types.PreserveOriginal, nil
 	}
-
-	return true, op, algo
 }
 
 // CandidateWithTime is the input to types.BICReplacementCandidate prioritization.
 type CandidateWithTime struct {
-	Candidate blobinfocache.BICReplacementCandidate2 // The replacement candidate
-	LastSeen  time.Time                              // Time the candidate was last known to exist (either read or written) (not set for Candidate.UnknownLocation)
+	candidate blobinfocache.BICReplacementCandidate2 // The replacement candidate
+	lastSeen  time.Time                              // Time the candidate was last known to exist (either read or written) (not set for Candidate.UnknownLocation)
+}
+
+// CandidateWithLocation returns a complete CandidateWithTime combining (template from CandidateTemplateWithCompression, location, lastSeen)
+func (template CandidateTemplate) CandidateWithLocation(location types.BICLocationReference, lastSeen time.Time) CandidateWithTime {
+	return CandidateWithTime{
+		candidate: blobinfocache.BICReplacementCandidate2{
+			Digest:               template.digest,
+			CompressionOperation: template.compressionOperation,
+			CompressionAlgorithm: template.compressionAlgorithm,
+			UnknownLocation:      false,
+			Location:             location,
+		},
+		lastSeen: lastSeen,
+	}
+}
+
+// CandidateWithUnknownLocation returns a complete CandidateWithTime for a template from CandidateTemplateWithCompression and an unknown location.
+func (template CandidateTemplate) CandidateWithUnknownLocation() CandidateWithTime {
+	return CandidateWithTime{
+		candidate: blobinfocache.BICReplacementCandidate2{
+			Digest:               template.digest,
+			CompressionOperation: template.compressionOperation,
+			CompressionAlgorithm: template.compressionAlgorithm,
+			UnknownLocation:      true,
+			Location:             types.BICLocationReference{Opaque: ""},
+		},
+		lastSeen: time.Time{},
+	}
 }
 
 // candidateSortState is a closure for a comparison used by slices.SortFunc on candidates to prioritize,
@@ -91,35 +137,35 @@ func (css *candidateSortState) compare(xi, xj CandidateWithTime) int {
 	// Other digest values are primarily sorted by time (more recent first), secondarily by digest (to provide a deterministic order)
 
 	// First, deal with the primaryDigest/uncompressedDigest cases:
-	if xi.Candidate.Digest != xj.Candidate.Digest {
+	if xi.candidate.Digest != xj.candidate.Digest {
 		// - The two digests are different, and one (or both) of the digests is primaryDigest or uncompressedDigest: time does not matter
-		if xi.Candidate.Digest == css.primaryDigest {
+		if xi.candidate.Digest == css.primaryDigest {
 			return -1
 		}
-		if xj.Candidate.Digest == css.primaryDigest {
+		if xj.candidate.Digest == css.primaryDigest {
 			return 1
 		}
 		if css.uncompressedDigest != "" {
-			if xi.Candidate.Digest == css.uncompressedDigest {
+			if xi.candidate.Digest == css.uncompressedDigest {
 				return 1
 			}
-			if xj.Candidate.Digest == css.uncompressedDigest {
+			if xj.candidate.Digest == css.uncompressedDigest {
 				return -1
 			}
 		}
 	} else { // xi.Candidate.Digest == xj.Candidate.Digest
 		// The two digests are the same, and are either primaryDigest or uncompressedDigest: order by time
-		if xi.Candidate.Digest == css.primaryDigest || (css.uncompressedDigest != "" && xi.Candidate.Digest == css.uncompressedDigest) {
-			return -xi.LastSeen.Compare(xj.LastSeen)
+		if xi.candidate.Digest == css.primaryDigest || (css.uncompressedDigest != "" && xi.candidate.Digest == css.uncompressedDigest) {
+			return -xi.lastSeen.Compare(xj.lastSeen)
 		}
 	}
 
 	// Neither of the digests are primaryDigest/uncompressedDigest:
-	if cmp := xi.LastSeen.Compare(xj.LastSeen); cmp != 0 { // Order primarily by time
+	if cmp := xi.lastSeen.Compare(xj.lastSeen); cmp != 0 { // Order primarily by time
 		return -cmp
 	}
 	// Fall back to digest, if timestamps end up _exactly_ the same (how?!)
-	return cmp.Compare(xi.Candidate.Digest, xj.Candidate.Digest)
+	return cmp.Compare(xi.candidate.Digest, xj.candidate.Digest)
 }
 
 // destructivelyPrioritizeReplacementCandidatesWithMax is destructivelyPrioritizeReplacementCandidates with parameters for the
@@ -138,7 +184,7 @@ func destructivelyPrioritizeReplacementCandidatesWithMax(cs []CandidateWithTime,
 		uncompressedDigest: uncompressedDigest,
 	}).compare)
 	for _, candidate := range cs {
-		if candidate.Candidate.UnknownLocation {
+		if candidate.candidate.UnknownLocation {
 			unknownLocationCandidates = append(unknownLocationCandidates, candidate)
 		} else {
 			knownLocationCandidates = append(knownLocationCandidates, candidate)
@@ -150,11 +196,11 @@ func destructivelyPrioritizeReplacementCandidatesWithMax(cs []CandidateWithTime,
 	unknownLocationCandidatesUsed := min(noLocationLimit, remainingCapacity, len(unknownLocationCandidates))
 	res := make([]blobinfocache.BICReplacementCandidate2, knownLocationCandidatesUsed)
 	for i := 0; i < knownLocationCandidatesUsed; i++ {
-		res[i] = knownLocationCandidates[i].Candidate
+		res[i] = knownLocationCandidates[i].candidate
 	}
 	// If candidates with unknown location are found, lets add them to final list
 	for i := 0; i < unknownLocationCandidatesUsed; i++ {
-		res = append(res, unknownLocationCandidates[i].Candidate)
+		res = append(res, unknownLocationCandidates[i].candidate)
 	}
 	return res
 }
diff --git a/vendor/github.com/containers/image/v5/pkg/blobinfocache/memory/memory.go b/vendor/github.com/containers/image/v5/pkg/blobinfocache/memory/memory.go
index 32aaa4d6f..067c6b7e1 100644
--- a/vendor/github.com/containers/image/v5/pkg/blobinfocache/memory/memory.go
+++ b/vendor/github.com/containers/image/v5/pkg/blobinfocache/memory/memory.go
@@ -24,10 +24,11 @@ type locationKey struct {
 type cache struct {
 	mutex sync.Mutex
 	// The following fields can only be accessed with mutex held.
-	uncompressedDigests   map[digest.Digest]digest.Digest
-	digestsByUncompressed map[digest.Digest]*set.Set[digest.Digest]                // stores a set of digests for each uncompressed digest
-	knownLocations        map[locationKey]map[types.BICLocationReference]time.Time // stores last known existence time for each location reference
-	compressors           map[digest.Digest]string                                 // stores a compressor name, or blobinfocache.Uncompressed (not blobinfocache.UnknownCompression), for each digest
+	uncompressedDigests      map[digest.Digest]digest.Digest
+	uncompressedDigestsByTOC map[digest.Digest]digest.Digest
+	digestsByUncompressed    map[digest.Digest]*set.Set[digest.Digest]                // stores a set of digests for each uncompressed digest
+	knownLocations           map[locationKey]map[types.BICLocationReference]time.Time // stores last known existence time for each location reference
+	compressors              map[digest.Digest]string                                 // stores a compressor name, or blobinfocache.Uncompressed (not blobinfocache.UnknownCompression), for each digest
 }
 
 // New returns a BlobInfoCache implementation which is in-memory only.
@@ -44,10 +45,11 @@ func New() types.BlobInfoCache {
 
 func new2() *cache {
 	return &cache{
-		uncompressedDigests:   map[digest.Digest]digest.Digest{},
-		digestsByUncompressed: map[digest.Digest]*set.Set[digest.Digest]{},
-		knownLocations:        map[locationKey]map[types.BICLocationReference]time.Time{},
-		compressors:           map[digest.Digest]string{},
+		uncompressedDigests:      map[digest.Digest]digest.Digest{},
+		uncompressedDigestsByTOC: map[digest.Digest]digest.Digest{},
+		digestsByUncompressed:    map[digest.Digest]*set.Set[digest.Digest]{},
+		knownLocations:           map[locationKey]map[types.BICLocationReference]time.Time{},
+		compressors:              map[digest.Digest]string{},
 	}
 }
 
@@ -104,6 +106,30 @@ func (mem *cache) RecordDigestUncompressedPair(anyDigest digest.Digest, uncompre
 	anyDigestSet.Add(anyDigest)
 }
 
+// UncompressedDigestForTOC returns an uncompressed digest corresponding to anyDigest.
+// Returns "" if the uncompressed digest is unknown.
+func (mem *cache) UncompressedDigestForTOC(tocDigest digest.Digest) digest.Digest {
+	mem.mutex.Lock()
+	defer mem.mutex.Unlock()
+	if d, ok := mem.uncompressedDigestsByTOC[tocDigest]; ok {
+		return d
+	}
+	return ""
+}
+
+// RecordTOCUncompressedPair records that the tocDigest corresponds to uncompressed.
+// WARNING: Only call this for LOCALLY VERIFIED data; don’t record a digest pair just because some remote author claims so (e.g.
+// because a manifest/config pair exists); otherwise the cache could be poisoned and allow substituting unexpected blobs.
+// (Eventually, the DiffIDs in image config could detect the substitution, but that may be too late, and not all image formats contain that data.)
+func (mem *cache) RecordTOCUncompressedPair(tocDigest digest.Digest, uncompressed digest.Digest) {
+	mem.mutex.Lock()
+	defer mem.mutex.Unlock()
+	if previous, ok := mem.uncompressedDigestsByTOC[tocDigest]; ok && previous != uncompressed {
+		logrus.Warnf("Uncompressed digest for blob with TOC %q previously recorded as %q, now %q", tocDigest, previous, uncompressed)
+	}
+	mem.uncompressedDigestsByTOC[tocDigest] = uncompressed
+}
+
 // RecordKnownLocation records that a blob with the specified digest exists within the specified (transport, scope) scope,
 // and can be reused given the opaque location data.
 func (mem *cache) RecordKnownLocation(transport types.ImageTransport, scope types.BICTransportScope, blobDigest digest.Digest, location types.BICLocationReference) {
@@ -118,19 +144,24 @@ func (mem *cache) RecordKnownLocation(transport types.ImageTransport, scope type
 	locationScope[location] = time.Now() // Possibly overwriting an older entry.
 }
 
-// RecordDigestCompressorName records that the blob with the specified digest is either compressed with the specified
-// algorithm, or uncompressed, or that we no longer know.
-func (mem *cache) RecordDigestCompressorName(blobDigest digest.Digest, compressorName string) {
+// RecordDigestCompressorData records data for the blob with the specified digest.
+// WARNING: Only call this with LOCALLY VERIFIED data:
+//   - don’t record a compressor for a digest just because some remote author claims so
+//     (e.g. because a manifest says so);
+//
+// otherwise the cache could be poisoned and cause us to make incorrect edits to type
+// information in a manifest.
+func (mem *cache) RecordDigestCompressorData(anyDigest digest.Digest, data blobinfocache.DigestCompressorData) {
 	mem.mutex.Lock()
 	defer mem.mutex.Unlock()
-	if previous, ok := mem.compressors[blobDigest]; ok && previous != compressorName {
-		logrus.Warnf("Compressor for blob with digest %s previously recorded as %s, now %s", blobDigest, previous, compressorName)
+	if previous, ok := mem.compressors[anyDigest]; ok && previous != data.BaseVariantCompressor {
+		logrus.Warnf("Compressor for blob with digest %s previously recorded as %s, now %s", anyDigest, previous, data.BaseVariantCompressor)
 	}
-	if compressorName == blobinfocache.UnknownCompression {
-		delete(mem.compressors, blobDigest)
+	if data.BaseVariantCompressor == blobinfocache.UnknownCompression {
+		delete(mem.compressors, anyDigest)
 		return
 	}
-	mem.compressors[blobDigest] = compressorName
+	mem.compressors[anyDigest] = data.BaseVariantCompressor
 }
 
 // appendReplacementCandidates creates prioritize.CandidateWithTime values for digest in memory
@@ -144,34 +175,19 @@ func (mem *cache) appendReplacementCandidates(candidates []prioritize.CandidateW
 	if v, ok := mem.compressors[digest]; ok {
 		compressorName = v
 	}
-	ok, compressionOp, compressionAlgo := prioritize.CandidateCompression(v2Options, digest, compressorName)
-	if !ok {
+	template := prioritize.CandidateTemplateWithCompression(v2Options, digest, blobinfocache.DigestCompressorData{
+		BaseVariantCompressor: compressorName,
+	})
+	if template == nil {
 		return candidates
 	}
 	locations := mem.knownLocations[locationKey{transport: transport.Name(), scope: scope, blobDigest: digest}] // nil if not present
 	if len(locations) > 0 {
 		for l, t := range locations {
-			candidates = append(candidates, prioritize.CandidateWithTime{
-				Candidate: blobinfocache.BICReplacementCandidate2{
-					Digest:               digest,
-					CompressionOperation: compressionOp,
-					CompressionAlgorithm: compressionAlgo,
-					Location:             l,
-				},
-				LastSeen: t,
-			})
+			candidates = append(candidates, template.CandidateWithLocation(l, t))
 		}
 	} else if v2Options != nil {
-		candidates = append(candidates, prioritize.CandidateWithTime{
-			Candidate: blobinfocache.BICReplacementCandidate2{
-				Digest:               digest,
-				CompressionOperation: compressionOp,
-				CompressionAlgorithm: compressionAlgo,
-				UnknownLocation:      true,
-				Location:             types.BICLocationReference{Opaque: ""},
-			},
-			LastSeen: time.Time{},
-		})
+		candidates = append(candidates, template.CandidateWithUnknownLocation())
 	}
 	return candidates
 }
diff --git a/vendor/github.com/containers/image/v5/pkg/blobinfocache/none/none.go b/vendor/github.com/containers/image/v5/pkg/blobinfocache/none/none.go
index 4b7122f92..9a2219e79 100644
--- a/vendor/github.com/containers/image/v5/pkg/blobinfocache/none/none.go
+++ b/vendor/github.com/containers/image/v5/pkg/blobinfocache/none/none.go
@@ -34,6 +34,19 @@ func (noCache) UncompressedDigest(anyDigest digest.Digest) digest.Digest {
 func (noCache) RecordDigestUncompressedPair(anyDigest digest.Digest, uncompressed digest.Digest) {
 }
 
+// UncompressedDigestForTOC returns an uncompressed digest corresponding to anyDigest.
+// Returns "" if the uncompressed digest is unknown.
+func (noCache) UncompressedDigestForTOC(tocDigest digest.Digest) digest.Digest {
+	return ""
+}
+
+// RecordTOCUncompressedPair records that the tocDigest corresponds to uncompressed.
+// WARNING: Only call this for LOCALLY VERIFIED data; don’t record a digest pair just because some remote author claims so (e.g.
+// because a manifest/config pair exists); otherwise the cache could be poisoned and allow substituting unexpected blobs.
+// (Eventually, the DiffIDs in image config could detect the substitution, but that may be too late, and not all image formats contain that data.)
+func (noCache) RecordTOCUncompressedPair(tocDigest digest.Digest, uncompressed digest.Digest) {
+}
+
 // RecordKnownLocation records that a blob with the specified digest exists within the specified (transport, scope) scope,
 // and can be reused given the opaque location data.
 func (noCache) RecordKnownLocation(transport types.ImageTransport, scope types.BICTransportScope, blobDigest digest.Digest, location types.BICLocationReference) {
diff --git a/vendor/github.com/containers/image/v5/pkg/blobinfocache/sqlite/sqlite.go b/vendor/github.com/containers/image/v5/pkg/blobinfocache/sqlite/sqlite.go
index a5be85a65..8d2bf7289 100644
--- a/vendor/github.com/containers/image/v5/pkg/blobinfocache/sqlite/sqlite.go
+++ b/vendor/github.com/containers/image/v5/pkg/blobinfocache/sqlite/sqlite.go
@@ -295,6 +295,14 @@ func ensureDBHasCurrentSchema(db *sql.DB) error {
 				`PRIMARY KEY (transport, scope, digest, location)
 			)`,
 		},
+		{
+			"DigestTOCUncompressedPairs",
+			`CREATE TABLE IF NOT EXISTS DigestTOCUncompressedPairs(` +
+				// index implied by PRIMARY KEY
+				`tocDigest			TEXT PRIMARY KEY NOT NULL,` +
+				`uncompressedDigest	TEXT NOT NULL
+			)`,
+		},
 	}
 
 	_, err := dbTransaction(db, func(tx *sql.Tx) (void, error) {
@@ -385,6 +393,57 @@ func (sqc *cache) RecordDigestUncompressedPair(anyDigest digest.Digest, uncompre
 	}) // FIXME? Log error (but throttle the log volume on repeated accesses)?
 }
 
+// UncompressedDigestForTOC returns an uncompressed digest corresponding to anyDigest.
+// Returns "" if the uncompressed digest is unknown.
+func (sqc *cache) UncompressedDigestForTOC(tocDigest digest.Digest) digest.Digest {
+	res, err := transaction(sqc, func(tx *sql.Tx) (digest.Digest, error) {
+		uncompressedString, found, err := querySingleValue[string](tx, "SELECT uncompressedDigest FROM DigestTOCUncompressedPairs WHERE tocDigest = ?", tocDigest.String())
+		if err != nil {
+			return "", err
+		}
+		if found {
+			d, err := digest.Parse(uncompressedString)
+			if err != nil {
+				return "", err
+			}
+			return d, nil
+
+		}
+		return "", nil
+	})
+	if err != nil {
+		return "" // FIXME? Log err (but throttle the log volume on repeated accesses)?
+	}
+	return res
+}
+
+// RecordTOCUncompressedPair records that the tocDigest corresponds to uncompressed.
+// WARNING: Only call this for LOCALLY VERIFIED data; don’t record a digest pair just because some remote author claims so (e.g.
+// because a manifest/config pair exists); otherwise the cache could be poisoned and allow substituting unexpected blobs.
+// (Eventually, the DiffIDs in image config could detect the substitution, but that may be too late, and not all image formats contain that data.)
+func (sqc *cache) RecordTOCUncompressedPair(tocDigest digest.Digest, uncompressed digest.Digest) {
+	_, _ = transaction(sqc, func(tx *sql.Tx) (void, error) {
+		previousString, gotPrevious, err := querySingleValue[string](tx, "SELECT uncompressedDigest FROM DigestTOCUncompressedPairs WHERE tocDigest = ?", tocDigest.String())
+		if err != nil {
+			return void{}, fmt.Errorf("looking for uncompressed digest for blob with TOC %q", tocDigest)
+		}
+		if gotPrevious {
+			previous, err := digest.Parse(previousString)
+			if err != nil {
+				return void{}, err
+			}
+			if previous != uncompressed {
+				logrus.Warnf("Uncompressed digest for blob with TOC %q previously recorded as %q, now %q", tocDigest, previous, uncompressed)
+			}
+		}
+		if _, err := tx.Exec("INSERT OR REPLACE INTO DigestTOCUncompressedPairs(tocDigest, uncompressedDigest) VALUES (?, ?)",
+			tocDigest.String(), uncompressed.String()); err != nil {
+			return void{}, fmt.Errorf("recording uncompressed digest %q for blob with TOC %q: %w", uncompressed, tocDigest, err)
+		}
+		return void{}, nil
+	}) // FIXME? Log error (but throttle the log volume on repeated accesses)?
+}
+
 // RecordKnownLocation records that a blob with the specified digest exists within the specified (transport, scope) scope,
 // and can be reused given the opaque location data.
 func (sqc *cache) RecordKnownLocation(transport types.ImageTransport, scope types.BICTransportScope, digest digest.Digest, location types.BICLocationReference) {
@@ -398,29 +457,30 @@ func (sqc *cache) RecordKnownLocation(transport types.ImageTransport, scope type
 	}) // FIXME? Log error (but throttle the log volume on repeated accesses)?
 }
 
-// RecordDigestCompressorName records a compressor for the blob with the specified digest,
-// or Uncompressed or UnknownCompression.
-// WARNING: Only call this with LOCALLY VERIFIED data; don’t record a compressor for a
-// digest just because some remote author claims so (e.g. because a manifest says so);
+// RecordDigestCompressorData records data for the blob with the specified digest.
+// WARNING: Only call this with LOCALLY VERIFIED data:
+//   - don’t record a compressor for a digest just because some remote author claims so
+//     (e.g. because a manifest says so);
+//
 // otherwise the cache could be poisoned and cause us to make incorrect edits to type
 // information in a manifest.
-func (sqc *cache) RecordDigestCompressorName(anyDigest digest.Digest, compressorName string) {
+func (sqc *cache) RecordDigestCompressorData(anyDigest digest.Digest, data blobinfocache.DigestCompressorData) {
 	_, _ = transaction(sqc, func(tx *sql.Tx) (void, error) {
 		previous, gotPrevious, err := querySingleValue[string](tx, "SELECT compressor FROM DigestCompressors WHERE digest = ?", anyDigest.String())
 		if err != nil {
 			return void{}, fmt.Errorf("looking for compressor of for %q", anyDigest)
 		}
-		if gotPrevious && previous != compressorName {
-			logrus.Warnf("Compressor for blob with digest %s previously recorded as %s, now %s", anyDigest, previous, compressorName)
+		if gotPrevious && previous != data.BaseVariantCompressor {
+			logrus.Warnf("Compressor for blob with digest %s previously recorded as %s, now %s", anyDigest, previous, data.BaseVariantCompressor)
 		}
-		if compressorName == blobinfocache.UnknownCompression {
+		if data.BaseVariantCompressor == blobinfocache.UnknownCompression {
 			if _, err := tx.Exec("DELETE FROM DigestCompressors WHERE digest = ?", anyDigest.String()); err != nil {
 				return void{}, fmt.Errorf("deleting compressor for digest %q: %w", anyDigest, err)
 			}
 		} else {
 			if _, err := tx.Exec("INSERT OR REPLACE INTO DigestCompressors(digest, compressor) VALUES (?, ?)",
-				anyDigest.String(), compressorName); err != nil {
-				return void{}, fmt.Errorf("recording compressor %q for %q: %w", compressorName, anyDigest, err)
+				anyDigest.String(), data.BaseVariantCompressor); err != nil {
+				return void{}, fmt.Errorf("recording compressor %q for %q: %w", data.BaseVariantCompressor, anyDigest, err)
 			}
 		}
 		return void{}, nil
@@ -443,8 +503,10 @@ func (sqc *cache) appendReplacementCandidates(candidates []prioritize.CandidateW
 			compressorName = compressor
 		}
 	}
-	ok, compressionOp, compressionAlgo := prioritize.CandidateCompression(v2Options, digest, compressorName)
-	if !ok {
+	template := prioritize.CandidateTemplateWithCompression(v2Options, digest, blobinfocache.DigestCompressorData{
+		BaseVariantCompressor: compressorName,
+	})
+	if template == nil {
 		return candidates, nil
 	}
 
@@ -463,15 +525,7 @@ func (sqc *cache) appendReplacementCandidates(candidates []prioritize.CandidateW
 		if err := rows.Scan(&location, &time); err != nil {
 			return nil, fmt.Errorf("scanning candidate: %w", err)
 		}
-		candidates = append(candidates, prioritize.CandidateWithTime{
-			Candidate: blobinfocache.BICReplacementCandidate2{
-				Digest:               digest,
-				CompressionOperation: compressionOp,
-				CompressionAlgorithm: compressionAlgo,
-				Location:             types.BICLocationReference{Opaque: location},
-			},
-			LastSeen: time,
-		})
+		candidates = append(candidates, template.CandidateWithLocation(types.BICLocationReference{Opaque: location}, time))
 		rowAdded = true
 	}
 	if err := rows.Err(); err != nil {
@@ -479,16 +533,7 @@ func (sqc *cache) appendReplacementCandidates(candidates []prioritize.CandidateW
 	}
 
 	if !rowAdded && v2Options != nil {
-		candidates = append(candidates, prioritize.CandidateWithTime{
-			Candidate: blobinfocache.BICReplacementCandidate2{
-				Digest:               digest,
-				CompressionOperation: compressionOp,
-				CompressionAlgorithm: compressionAlgo,
-				UnknownLocation:      true,
-				Location:             types.BICLocationReference{Opaque: ""},
-			},
-			LastSeen: time.Time{},
-		})
+		candidates = append(candidates, template.CandidateWithUnknownLocation())
 	}
 	return candidates, nil
 }
diff --git a/vendor/github.com/containers/image/v5/pkg/shortnames/shortnames.go b/vendor/github.com/containers/image/v5/pkg/shortnames/shortnames.go
index 61490932e..9317600e5 100644
--- a/vendor/github.com/containers/image/v5/pkg/shortnames/shortnames.go
+++ b/vendor/github.com/containers/image/v5/pkg/shortnames/shortnames.go
@@ -61,14 +61,12 @@ func parseUnnormalizedShortName(input string) (bool, reference.Named, error) {
 // the tag or digest and stores it in the return values so that both can be
 // re-added to a possible resolved alias' or USRs at a later point.
 func splitUserInput(named reference.Named) (isTagged bool, isDigested bool, normalized reference.Named, tag string, digest digest.Digest) {
-	tagged, isT := named.(reference.NamedTagged)
-	if isT {
+	if tagged, ok := named.(reference.NamedTagged); ok {
 		isTagged = true
 		tag = tagged.Tag()
 	}
 
-	digested, isD := named.(reference.Digested)
-	if isD {
+	if digested, ok := named.(reference.Digested); ok {
 		isDigested = true
 		digest = digested.Digest()
 	}
diff --git a/vendor/github.com/containers/image/v5/storage/storage_dest.go b/vendor/github.com/containers/image/v5/storage/storage_dest.go
index 92dfebd33..842a3ab06 100644
--- a/vendor/github.com/containers/image/v5/storage/storage_dest.go
+++ b/vendor/github.com/containers/image/v5/storage/storage_dest.go
@@ -84,18 +84,36 @@ type storageImageDestinationLockProtected struct {
 	currentIndex          int                    // The index of the layer to be committed (i.e., lower indices have already been committed)
 	indexToAddedLayerInfo map[int]addedLayerInfo // Mapping from layer (by index) to blob to add to the image
 
-	// In general, a layer is identified either by (compressed) digest, or by TOC digest.
+	// Externally, a layer is identified either by (compressed) digest, or by TOC digest
+	// (and we assume the TOC digest also uniquely identifies the contents, i.e. there aren’t two
+	// different formats/ways to parse a single TOC); internally, we use uncompressed digest (“DiffID”) or a TOC digest.
+	// We may or may not know the relationships between these three values.
+	//
 	// When creating a layer, the c/storage layer metadata and image IDs must _only_ be based on trusted values
 	// we have computed ourselves. (Layer reuse can then look up against such trusted values, but it might not
-	// recompute those values for incomding layers — the point of the reuse is that we don’t need to consume the incoming layer.)
-
-	// Layer identification: For a layer, at least one of indexToTOCDigest and blobDiffIDs must be available before commitLayer is called.
-	// The presence of an indexToTOCDigest is what decides how the layer is identified, i.e. which fields must be trusted.
-	blobDiffIDs      map[digest.Digest]digest.Digest // Mapping from layer blobsums to their corresponding DiffIDs
-	indexToTOCDigest map[int]digest.Digest           // Mapping from layer index to a TOC Digest, IFF the layer was created/found/reused by TOC digest
+	// recompute those values for incoming layers — the point of the reuse is that we don’t need to consume the incoming layer.)
+	//
+	// Layer identification: For a layer, at least one of (indexToDiffID, indexToTOCDigest, blobDiffIDs) must be available
+	// before commitLayer is called.
+	// The layer is identified by the first of the three fields which exists, in that order (and the value must be trusted).
+	//
+	// WARNING: All values in indexToDiffID, indexToTOCDigest, and blobDiffIDs are _individually_ trusted, but blobDiffIDs is more subtle.
+	// The values in indexTo* are all consistent, because the code writing them processed them all at once, and consistently.
+	// But it is possible for a layer’s indexToDiffID an indexToTOCDigest to be based on a TOC, without setting blobDiffIDs
+	// for the compressed digest of that index, and for blobDiffIDs[compressedDigest] to be set _separately_ while processing some
+	// other layer entry. In particular it is possible for indexToDiffID[index] and blobDiffIDs[compressedDigestAtIndex]] to refer
+	// to mismatching contents.
+	// Users of these fields should use trustedLayerIdentityDataLocked, which centralizes the validity logic,
+	// instead of interpreting these fields, especially blobDiffIDs, directly.
+	//
+	// Ideally we wouldn’t have blobDiffIDs, and we would just keep records by index, but the public API does not require the caller
+	// to provide layer indices; and configs don’t have layer indices. blobDiffIDs needs to exist for those cases.
+	indexToDiffID    map[int]digest.Digest           // Mapping from layer index to DiffID
+	indexToTOCDigest map[int]digest.Digest           // Mapping from layer index to a TOC Digest
+	blobDiffIDs      map[digest.Digest]digest.Digest // Mapping from layer blobsums to their corresponding DiffIDs. CAREFUL: See the WARNING above.
 
 	// Layer data: Before commitLayer is called, either at least one of (diffOutputs, indexToAdditionalLayer, filenames)
-	// should be available; or indexToTOCDigest/blobDiffIDs should be enough to locate an existing c/storage layer.
+	// should be available; or indexToDiffID/indexToTOCDigest/blobDiffIDs should be enough to locate an existing c/storage layer.
 	// They are looked up in the order they are mentioned above.
 	diffOutputs            map[int]*graphdriver.DriverWithDifferOutput // Mapping from layer index to a partially-pulled layer intermediate data
 	indexToAdditionalLayer map[int]storage.AdditionalLayer             // Mapping from layer index to their corresponding additional layer
@@ -145,9 +163,12 @@ func newImageDestination(sys *types.SystemContext, imageRef storageReference) (*
 		},
 		indexToStorageID: make(map[int]string),
 		lockProtected: storageImageDestinationLockProtected{
-			indexToAddedLayerInfo:  make(map[int]addedLayerInfo),
-			blobDiffIDs:            make(map[digest.Digest]digest.Digest),
-			indexToTOCDigest:       make(map[int]digest.Digest),
+			indexToAddedLayerInfo: make(map[int]addedLayerInfo),
+
+			indexToDiffID:    make(map[int]digest.Digest),
+			indexToTOCDigest: make(map[int]digest.Digest),
+			blobDiffIDs:      make(map[digest.Digest]digest.Digest),
+
 			diffOutputs:            make(map[int]*graphdriver.DriverWithDifferOutput),
 			indexToAdditionalLayer: make(map[int]storage.AdditionalLayer),
 			filenames:              make(map[digest.Digest]string),
@@ -323,20 +344,30 @@ func (s *storageImageDestination) PutBlobPartial(ctx context.Context, chunkAcces
 
 	s.lock.Lock()
 	if out.UncompressedDigest != "" {
+		s.lockProtected.indexToDiffID[options.LayerIndex] = out.UncompressedDigest
+		if out.TOCDigest != "" {
+			options.Cache.RecordTOCUncompressedPair(out.TOCDigest, out.UncompressedDigest)
+		}
+		// Don’t set indexToTOCDigest on this path:
+		// - Using UncompressedDigest allows image reuse with non-partially-pulled layers, so we want to set indexToDiffID.
+		// - If UncompressedDigest has been computed, that means the layer was read completely, and the TOC has been created from scratch.
+		//   That TOC is quite unlikely to match any other TOC value.
+
 		// The computation of UncompressedDigest means the whole layer has been consumed; while doing that, chunked.GetDiffer is
 		// responsible for ensuring blobDigest has been validated.
 		if out.CompressedDigest != blobDigest {
 			return private.UploadedBlob{}, fmt.Errorf("internal error: ApplyDiffWithDiffer returned CompressedDigest %q not matching expected %q",
 				out.CompressedDigest, blobDigest)
 		}
-		s.lockProtected.blobDiffIDs[blobDigest] = out.UncompressedDigest
+		// So, record also information about blobDigest, that might benefit reuse.
 		// We trust ApplyDiffWithDiffer to validate or create both values correctly.
+		s.lockProtected.blobDiffIDs[blobDigest] = out.UncompressedDigest
 		options.Cache.RecordDigestUncompressedPair(out.CompressedDigest, out.UncompressedDigest)
 	} else {
-		// Don’t identify layers by TOC if UncompressedDigest is available.
-		// - Using UncompressedDigest allows image reuse with non-partially-pulled layers
-		// - If UncompressedDigest has been computed, that means the layer was read completely, and the TOC has been created from scratch.
-		//   That TOC is quite unlikely to match with any other TOC value.
+		// Use diffID for layer identity if it is known.
+		if uncompressedDigest := options.Cache.UncompressedDigestForTOC(out.TOCDigest); uncompressedDigest != "" {
+			s.lockProtected.indexToDiffID[options.LayerIndex] = uncompressedDigest
+		}
 		s.lockProtected.indexToTOCDigest[options.LayerIndex] = out.TOCDigest
 	}
 	s.lockProtected.diffOutputs[options.LayerIndex] = out
@@ -465,49 +496,40 @@ func (s *storageImageDestination) tryReusingBlobAsPending(blobDigest digest.Dige
 			if err != nil && !errors.Is(err, storage.ErrLayerUnknown) {
 				return false, private.ReusedBlob{}, fmt.Errorf(`looking for layers with digest %q: %w`, uncompressedDigest, err)
 			}
-			if len(layers) > 0 {
-				if size != -1 {
-					s.lockProtected.blobDiffIDs[blobDigest] = uncompressedDigest
-					return true, private.ReusedBlob{
-						Digest: blobDigest,
-						Size:   size,
-					}, nil
-				}
-				if !options.CanSubstitute {
-					return false, private.ReusedBlob{}, fmt.Errorf("Internal error: options.CanSubstitute was expected to be true for blob with digest %s", blobDigest)
-				}
-				s.lockProtected.blobDiffIDs[uncompressedDigest] = uncompressedDigest
-				return true, private.ReusedBlob{
-					Digest: uncompressedDigest,
-					Size:   layers[0].UncompressedSize,
-				}, nil
+			if found, reused := reusedBlobFromLayerLookup(layers, blobDigest, size, options); found {
+				s.lockProtected.blobDiffIDs[blobDigest] = uncompressedDigest
+				return true, reused, nil
 			}
 		}
 	}
 
 	if options.TOCDigest != "" && options.LayerIndex != nil {
+		// Check if we know which which UncompressedDigest the TOC digest resolves to, and we have a match for that.
+		// Prefer this over LayersByTOCDigest because we can identify the layer using UncompressedDigest, maximizing reuse.
+		uncompressedDigest := options.Cache.UncompressedDigestForTOC(options.TOCDigest)
+		if uncompressedDigest != "" {
+			layers, err = s.imageRef.transport.store.LayersByUncompressedDigest(uncompressedDigest)
+			if err != nil && !errors.Is(err, storage.ErrLayerUnknown) {
+				return false, private.ReusedBlob{}, fmt.Errorf(`looking for layers with digest %q: %w`, uncompressedDigest, err)
+			}
+			if found, reused := reusedBlobFromLayerLookup(layers, blobDigest, size, options); found {
+				s.lockProtected.indexToDiffID[*options.LayerIndex] = uncompressedDigest
+				reused.MatchedByTOCDigest = true
+				return true, reused, nil
+			}
+		}
 		// Check if we have a chunked layer in storage with the same TOC digest.
 		layers, err := s.imageRef.transport.store.LayersByTOCDigest(options.TOCDigest)
-
 		if err != nil && !errors.Is(err, storage.ErrLayerUnknown) {
 			return false, private.ReusedBlob{}, fmt.Errorf(`looking for layers with TOC digest %q: %w`, options.TOCDigest, err)
 		}
-		if len(layers) > 0 {
-			if size != -1 {
-				s.lockProtected.indexToTOCDigest[*options.LayerIndex] = options.TOCDigest
-				return true, private.ReusedBlob{
-					Digest:             blobDigest,
-					Size:               size,
-					MatchedByTOCDigest: true,
-				}, nil
-			} else if options.CanSubstitute && layers[0].UncompressedDigest != "" {
-				s.lockProtected.indexToTOCDigest[*options.LayerIndex] = options.TOCDigest
-				return true, private.ReusedBlob{
-					Digest:             layers[0].UncompressedDigest,
-					Size:               layers[0].UncompressedSize,
-					MatchedByTOCDigest: true,
-				}, nil
+		if found, reused := reusedBlobFromLayerLookup(layers, blobDigest, size, options); found {
+			if uncompressedDigest != "" {
+				s.lockProtected.indexToDiffID[*options.LayerIndex] = uncompressedDigest
 			}
+			s.lockProtected.indexToTOCDigest[*options.LayerIndex] = options.TOCDigest
+			reused.MatchedByTOCDigest = true
+			return true, reused, nil
 		}
 	}
 
@@ -515,49 +537,137 @@ func (s *storageImageDestination) tryReusingBlobAsPending(blobDigest digest.Dige
 	return false, private.ReusedBlob{}, nil
 }
 
+// reusedBlobFromLayerLookup returns (true, ReusedBlob) if layers contain a usable match; or (false, ...) if not.
+// The caller is still responsible for setting the layer identification fields, to allow the layer to be found again.
+func reusedBlobFromLayerLookup(layers []storage.Layer, blobDigest digest.Digest, blobSize int64, options *private.TryReusingBlobOptions) (bool, private.ReusedBlob) {
+	if len(layers) > 0 {
+		if blobSize != -1 {
+			return true, private.ReusedBlob{
+				Digest: blobDigest,
+				Size:   blobSize,
+			}
+		} else if options.CanSubstitute && layers[0].UncompressedDigest != "" {
+			return true, private.ReusedBlob{
+				Digest:               layers[0].UncompressedDigest,
+				Size:                 layers[0].UncompressedSize,
+				CompressionOperation: types.Decompress,
+				CompressionAlgorithm: nil,
+			}
+		}
+	}
+	return false, private.ReusedBlob{}
+}
+
+// trustedLayerIdentityData is a _consistent_ set of information known about a single layer.
+type trustedLayerIdentityData struct {
+	layerIdentifiedByTOC bool // true if we decided the layer should be identified by tocDigest, false if by diffID
+
+	diffID     digest.Digest // A digest of the uncompressed full contents of the layer, or "" if unknown; must be set if !layerIdentifiedByTOC
+	tocDigest  digest.Digest // A digest of the TOC digest, or "" if unknown; must be set if layerIdentifiedByTOC
+	blobDigest digest.Digest // A digest of the (possibly-compressed) layer as presented, or "" if unknown/untrusted.
+}
+
+// trustedLayerIdentityDataLocked returns a _consistent_ set of information for a layer with (layerIndex, blobDigest).
+// blobDigest is the (possibly-compressed) layer digest referenced in the manifest.
+// It returns (trusted, true) if the layer was found, or (_, false) if insufficient data is available.
+//
+// The caller must hold s.lock.
+func (s *storageImageDestination) trustedLayerIdentityDataLocked(layerIndex int, blobDigest digest.Digest) (trustedLayerIdentityData, bool) {
+	// The decision about layerIdentifiedByTOC must be _stable_ once the data for layerIndex is set,
+	// even if s.lockProtected.blobDiffIDs changes later and we can subsequently find an entry that wasn’t originally available.
+	//
+	// If we previously didn't have a blobDigest match and decided to use the TOC, but _later_ we happen to find
+	// a blobDigest match, we might in principle want to reconsider, set layerIdentifiedByTOC to false, and use the file:
+	// but the layer in question, and possibly child layers, might already have been committed to storage.
+	// A late-arriving addition to s.lockProtected.blobDiffIDs would mean that we would want to set
+	// new layer IDs for potentially the whole parent chain = throw away the just-created layers and create them all again.
+	//
+	// Such a within-image layer reuse is expected to be pretty rare; instead, ignore the unexpected file match
+	// and proceed to the originally-planned TOC match.
+
+	res := trustedLayerIdentityData{}
+	diffID, layerIdentifiedByDiffID := s.lockProtected.indexToDiffID[layerIndex]
+	if layerIdentifiedByDiffID {
+		res.layerIdentifiedByTOC = false
+		res.diffID = diffID
+	}
+	if tocDigest, ok := s.lockProtected.indexToTOCDigest[layerIndex]; ok {
+		res.tocDigest = tocDigest
+		if !layerIdentifiedByDiffID {
+			res.layerIdentifiedByTOC = true
+		}
+	}
+	if otherDiffID, ok := s.lockProtected.blobDiffIDs[blobDigest]; ok {
+		if !layerIdentifiedByDiffID && !res.layerIdentifiedByTOC {
+			// This is the only data we have, so it is clearly self-consistent.
+			res.layerIdentifiedByTOC = false
+			res.diffID = otherDiffID
+			res.blobDigest = blobDigest
+			layerIdentifiedByDiffID = true
+		} else {
+			// We have set up the layer identity without referring to blobDigest:
+			// an attacker might have used a manifest with non-matching tocDigest and blobDigest.
+			// But, if we know a trusted diffID value from other sources, and it matches the one for blobDigest,
+			// we know blobDigest is fine as well.
+			if res.diffID != "" && otherDiffID == res.diffID {
+				res.blobDigest = blobDigest
+			}
+		}
+	}
+	if !layerIdentifiedByDiffID && !res.layerIdentifiedByTOC {
+		return trustedLayerIdentityData{}, false // We found nothing at all
+	}
+	return res, true
+}
+
 // computeID computes a recommended image ID based on information we have so far.  If
 // the manifest is not of a type that we recognize, we return an empty value, indicating
 // that since we don't have a recommendation, a random ID should be used if one needs
 // to be allocated.
-func (s *storageImageDestination) computeID(m manifest.Manifest) string {
+func (s *storageImageDestination) computeID(m manifest.Manifest) (string, error) {
 	// This is outside of the scope of HasThreadSafePutBlob, so we don’t need to hold s.lock.
 
+	layerInfos := m.LayerInfos()
+
 	// Build the diffID list.  We need the decompressed sums that we've been calculating to
 	// fill in the DiffIDs.  It's expected (but not enforced by us) that the number of
 	// diffIDs corresponds to the number of non-EmptyLayer entries in the history.
 	var diffIDs []digest.Digest
-	switch m := m.(type) {
+	switch m.(type) {
 	case *manifest.Schema1:
-		// Build a list of the diffIDs we've generated for the non-throwaway FS layers,
-		// in reverse of the order in which they were originally listed.
-		for i, compat := range m.ExtractedV1Compatibility {
-			if compat.ThrowAway {
+		// Build a list of the diffIDs we've generated for the non-throwaway FS layers
+		for i, li := range layerInfos {
+			if li.EmptyLayer {
 				continue
 			}
-			blobSum := m.FSLayers[i].BlobSum
-			diffID, ok := s.lockProtected.blobDiffIDs[blobSum]
-			if !ok {
-				// this can, in principle, legitimately happen when a layer is reused by TOC.
-				logrus.Infof("error looking up diffID for layer %q", blobSum.String())
-				return ""
+			trusted, ok := s.trustedLayerIdentityDataLocked(i, li.Digest)
+			if !ok { // We have already committed all layers if we get to this point, so the data must have been available.
+				return "", fmt.Errorf("internal inconsistency: layer (%d, %q) not found", i, li.Digest)
 			}
-			diffIDs = append([]digest.Digest{diffID}, diffIDs...)
+			if trusted.diffID == "" {
+				if trusted.layerIdentifiedByTOC {
+					logrus.Infof("v2s1 image uses a layer identified by TOC with unknown diffID; choosing a random image ID")
+					return "", nil
+				}
+				return "", fmt.Errorf("internal inconsistency: layer (%d, %q) is not identified by TOC and has no diffID", i, li.Digest)
+			}
+			diffIDs = append(diffIDs, trusted.diffID)
 		}
 	case *manifest.Schema2, *manifest.OCI1:
 		// We know the ID calculation doesn't actually use the diffIDs, so we don't need to populate
 		// the diffID list.
 	default:
-		return ""
+		return "", nil
 	}
 
 	// We want to use the same ID for “the same” images, but without risking unwanted sharing / malicious image corruption.
 	//
 	// Traditionally that means the same ~config digest, as computed by m.ImageID;
-	// but if we pull a layer by TOC, we verify the layer against neither the (compressed) blob digest in the manifest,
+	// but if we identify a layer by TOC, we verify the layer against neither the (compressed) blob digest in the manifest,
 	// nor against the config’s RootFS.DiffIDs. We don’t really want to do either, to allow partial layer pulls where we never see
 	// most of the data.
 	//
-	// So, if a layer is pulled by TOC (and we do validate against the TOC), the fact that we used the TOC, and the value of the TOC,
+	// So, if a layer is identified by TOC (and we do validate against the TOC), the fact that we used the TOC, and the value of the TOC,
 	// must enter into the image ID computation.
 	// But for images where no TOC was used, continue to use IDs computed the traditional way, to maximize image reuse on upgrades,
 	// and to introduce the changed behavior only when partial pulls are used.
@@ -566,28 +676,31 @@ func (s *storageImageDestination) computeID(m manifest.Manifest) string {
 	// (skopeo copy --format v2s2 docker://…/zstd-chunked-image containers-storage:… ). So this is not happening only in the OCI case above.
 	ordinaryImageID, err := m.ImageID(diffIDs)
 	if err != nil {
-		return ""
+		return "", err
 	}
 	tocIDInput := ""
 	hasLayerPulledByTOC := false
-	for i := range m.LayerInfos() {
-		layerValue := ""                                     // An empty string is not a valid digest, so this is unambiguous with the TOC case.
-		tocDigest, ok := s.lockProtected.indexToTOCDigest[i] // "" if not a TOC
-		if ok {
+	for i, li := range layerInfos {
+		trusted, ok := s.trustedLayerIdentityDataLocked(i, li.Digest)
+		if !ok { // We have already committed all layers if we get to this point, so the data must have been available.
+			return "", fmt.Errorf("internal inconsistency: layer (%d, %q) not found", i, li.Digest)
+		}
+		layerValue := "" // An empty string is not a valid digest, so this is unambiguous with the TOC case.
+		if trusted.layerIdentifiedByTOC {
 			hasLayerPulledByTOC = true
-			layerValue = tocDigest.String()
+			layerValue = trusted.tocDigest.String()
 		}
 		tocIDInput += layerValue + "|" // "|" can not be present in a TOC digest, so this is an unambiguous separator.
 	}
 
 	if !hasLayerPulledByTOC {
-		return ordinaryImageID
+		return ordinaryImageID, nil
 	}
 	// ordinaryImageID is a digest of a config, which is a JSON value.
 	// To avoid the risk of collisions, start the input with @ so that the input is not a valid JSON.
 	tocImageID := digest.FromString("@With TOC:" + tocIDInput).Encoded()
 	logrus.Debugf("Ordinary storage image ID %s; a layer was looked up by TOC, so using image ID %s", ordinaryImageID, tocImageID)
-	return tocImageID
+	return tocImageID, nil
 }
 
 // getConfigBlob exists only to let us retrieve the configuration blob so that the manifest package can dig
@@ -671,14 +784,14 @@ func (s *storageImageDestination) singleLayerIDComponent(layerIndex int, blobDig
 	s.lock.Lock()
 	defer s.lock.Unlock()
 
-	if d, found := s.lockProtected.indexToTOCDigest[layerIndex]; found {
-		return "@TOC=" + d.Encoded(), false // "@" is not a valid start of a digest.Digest, so this is unambiguous.
+	trusted, ok := s.trustedLayerIdentityDataLocked(layerIndex, blobDigest)
+	if !ok {
+		return "", false
 	}
-
-	if d, found := s.lockProtected.blobDiffIDs[blobDigest]; found {
-		return d.Encoded(), true // This looks like chain IDs, and it uses the traditional value.
+	if trusted.layerIdentifiedByTOC {
+		return "@TOC=" + trusted.tocDigest.Encoded(), false // "@" is not a valid start of a digest.Digest, so this is unambiguous.
 	}
-	return "", false
+	return trusted.diffID.Encoded(), true // This looks like chain IDs, and it uses the traditional value.
 }
 
 // commitLayer commits the specified layer with the given index to the storage.
@@ -778,6 +891,16 @@ func (s *storageImageDestination) createNewLayer(index int, layerDigest digest.D
 	diffOutput, ok := s.lockProtected.diffOutputs[index]
 	s.lock.Unlock()
 	if ok {
+		// If we know a trusted DiffID value (e.g. from a BlobInfoCache), set it in diffOutput.
+		// That way it will be persisted in storage even if the cache is deleted; also
+		// we can use the value below to avoid the untrustedUncompressedDigest logic (and notably
+		// the costly commit delay until a manifest is available).
+		s.lock.Lock()
+		if d, ok := s.lockProtected.indexToDiffID[index]; ok {
+			diffOutput.UncompressedDigest = d
+		}
+		s.lock.Unlock()
+
 		var untrustedUncompressedDigest digest.Digest
 		if diffOutput.UncompressedDigest == "" {
 			d, err := s.untrustedLayerDiffID(index)
@@ -832,47 +955,43 @@ func (s *storageImageDestination) createNewLayer(index int, layerDigest digest.D
 
 	// Check if we previously cached a file with that blob's contents.  If we didn't,
 	// then we need to read the desired contents from a layer.
-	var trustedUncompressedDigest, trustedOriginalDigest digest.Digest // For storage.LayerOptions
+	var filename string
+	var gotFilename bool
 	s.lock.Lock()
-	tocDigest := s.lockProtected.indexToTOCDigest[index]       // "" if not set
-	optionalDiffID := s.lockProtected.blobDiffIDs[layerDigest] // "" if not set
-	filename, gotFilename := s.lockProtected.filenames[layerDigest]
+	trusted, ok := s.trustedLayerIdentityDataLocked(index, layerDigest)
+	if ok && trusted.blobDigest != "" {
+		filename, gotFilename = s.lockProtected.filenames[trusted.blobDigest]
+	}
 	s.lock.Unlock()
-	if gotFilename && tocDigest == "" {
-		// If tocDigest != "", if we now happen to find a layerDigest match, the newLayerID has already been computed as TOC-based,
-		// and we don't know the relationship of the layerDigest and TOC digest.
-		// We could recompute newLayerID to be DiffID-based and use the file, but such a within-image layer
-		// reuse is expected to be pretty rare; instead, ignore the unexpected file match and proceed to the
-		// originally-planned TOC match.
-
-		// Because tocDigest == "", optionaldiffID must have been set; and even if it weren’t, PutLayer will recompute the digest from the stream.
-		trustedUncompressedDigest = optionalDiffID
-		trustedOriginalDigest = layerDigest // The code setting .filenames[layerDigest] is responsible for the contents matching.
+	if !ok { // We have already determined newLayerID, so the data must have been available.
+		return nil, fmt.Errorf("internal inconsistency: layer (%d, %q) not found", index, layerDigest)
+	}
+	var trustedOriginalDigest digest.Digest // For storage.LayerOptions
+	if gotFilename {
+		// The code setting .filenames[trusted.blobDigest] is responsible for ensuring that the file contents match trusted.blobDigest.
+		trustedOriginalDigest = trusted.blobDigest
 	} else {
 		// Try to find the layer with contents matching the data we use.
 		var layer *storage.Layer // = nil
-		if tocDigest != "" {
-			layers, err2 := s.imageRef.transport.store.LayersByTOCDigest(tocDigest)
-			if err2 == nil && len(layers) > 0 {
+		if trusted.diffID != "" {
+			if layers, err2 := s.imageRef.transport.store.LayersByUncompressedDigest(trusted.diffID); err2 == nil && len(layers) > 0 {
 				layer = &layers[0]
-			} else {
-				return nil, fmt.Errorf("locating layer for TOC digest %q: %w", tocDigest, err2)
 			}
-		} else {
-			// Because tocDigest == "", optionaldiffID must have been set
-			layers, err2 := s.imageRef.transport.store.LayersByUncompressedDigest(optionalDiffID)
-			if err2 == nil && len(layers) > 0 {
+		}
+		if layer == nil && trusted.tocDigest != "" {
+			if layers, err2 := s.imageRef.transport.store.LayersByTOCDigest(trusted.tocDigest); err2 == nil && len(layers) > 0 {
 				layer = &layers[0]
-			} else {
-				layers, err2 = s.imageRef.transport.store.LayersByCompressedDigest(layerDigest)
-				if err2 == nil && len(layers) > 0 {
-					layer = &layers[0]
-				}
 			}
-			if layer == nil {
-				return nil, fmt.Errorf("locating layer for blob %q: %w", layerDigest, err2)
+		}
+		if layer == nil && trusted.blobDigest != "" {
+			if layers, err2 := s.imageRef.transport.store.LayersByCompressedDigest(trusted.blobDigest); err2 == nil && len(layers) > 0 {
+				layer = &layers[0]
 			}
 		}
+		if layer == nil {
+			return nil, fmt.Errorf("layer for blob %q/%q/%q not found", trusted.blobDigest, trusted.tocDigest, trusted.diffID)
+		}
+
 		// Read the layer's contents.
 		noCompression := archive.Uncompressed
 		diffOptions := &storage.DiffOptions{
@@ -880,7 +999,7 @@ func (s *storageImageDestination) createNewLayer(index int, layerDigest digest.D
 		}
 		diff, err2 := s.imageRef.transport.store.Diff("", layer.ID, diffOptions)
 		if err2 != nil {
-			return nil, fmt.Errorf("reading layer %q for blob %q: %w", layer.ID, layerDigest, err2)
+			return nil, fmt.Errorf("reading layer %q for blob %q/%q/%q: %w", layer.ID, trusted.blobDigest, trusted.tocDigest, trusted.diffID, err2)
 		}
 		// Copy the layer diff to a file.  Diff() takes a lock that it holds
 		// until the ReadCloser that it returns is closed, and PutLayer() wants
@@ -902,20 +1021,19 @@ func (s *storageImageDestination) createNewLayer(index int, layerDigest digest.D
 			return nil, fmt.Errorf("storing blob to file %q: %w", filename, err)
 		}
 
-		if optionalDiffID == "" && layer.UncompressedDigest != "" {
-			optionalDiffID = layer.UncompressedDigest
+		if trusted.diffID == "" && layer.UncompressedDigest != "" {
+			trusted.diffID = layer.UncompressedDigest // This data might have been unavailable in tryReusingBlobAsPending, and is only known now.
 		}
-		// The stream we have is uncompressed, this matches contents of the stream.
-		// If tocDigest != "", trustedUncompressedDigest might still be ""; in that case PutLayer will compute the value from the stream.
-		trustedUncompressedDigest = optionalDiffID
-		// FIXME? trustedOriginalDigest could be set to layerDigest IF tocDigest == "" (otherwise layerDigest is untrusted).
+		// The stream we have is uncompressed, and it matches trusted.diffID (if known).
+		//
+		// FIXME? trustedOriginalDigest could be set to trusted.blobDigest if known, to allow more layer reuse.
 		// But for c/storage to reasonably use it (as a CompressedDigest value), we should also ensure the CompressedSize of the created
 		// layer is correct, and the API does not currently make it possible (.CompressedSize is set from the input stream).
 		//
 		// We can legitimately set storage.LayerOptions.OriginalDigest to "",
-		// but that would just result in PutLayer computing the digest of the input stream == optionalDiffID.
+		// but that would just result in PutLayer computing the digest of the input stream == trusted.diffID.
 		// So, instead, set .OriginalDigest to the value we know already, to avoid that digest computation.
-		trustedOriginalDigest = optionalDiffID
+		trustedOriginalDigest = trusted.diffID
 
 		// Allow using the already-collected layer contents without extracting the layer again.
 		//
@@ -923,11 +1041,11 @@ func (s *storageImageDestination) createNewLayer(index int, layerDigest digest.D
 		// We don’t have the original compressed data here to trivially set filenames[layerDigest].
 		// In particular we can’t achieve the correct Layer.CompressedSize value with the current c/storage API.
 		// Within-image layer reuse is probably very rare, for now we prefer to avoid that complexity.
-		if trustedUncompressedDigest != "" {
+		if trusted.diffID != "" {
 			s.lock.Lock()
-			s.lockProtected.blobDiffIDs[trustedUncompressedDigest] = trustedUncompressedDigest
-			s.lockProtected.filenames[trustedUncompressedDigest] = filename
-			s.lockProtected.fileSizes[trustedUncompressedDigest] = fileSize
+			s.lockProtected.blobDiffIDs[trusted.diffID] = trusted.diffID
+			s.lockProtected.filenames[trusted.diffID] = filename
+			s.lockProtected.fileSizes[trusted.diffID] = fileSize
 			s.lock.Unlock()
 		}
 	}
@@ -940,11 +1058,12 @@ func (s *storageImageDestination) createNewLayer(index int, layerDigest digest.D
 	// Build the new layer using the diff, regardless of where it came from.
 	// TODO: This can take quite some time, and should ideally be cancellable using ctx.Done().
 	layer, _, err := s.imageRef.transport.store.PutLayer(newLayerID, parentLayer, nil, "", false, &storage.LayerOptions{
-		OriginalDigest:     trustedOriginalDigest,
-		UncompressedDigest: trustedUncompressedDigest,
+		OriginalDigest: trustedOriginalDigest,
+		// This might be "" if trusted.layerIdentifiedByTOC; in that case PutLayer will compute the value from the stream.
+		UncompressedDigest: trusted.diffID,
 	}, file)
 	if err != nil && !errors.Is(err, storage.ErrDuplicateID) {
-		return nil, fmt.Errorf("adding layer with blob %q: %w", layerDigest, err)
+		return nil, fmt.Errorf("adding layer with blob %q/%q/%q: %w", trusted.blobDigest, trusted.tocDigest, trusted.diffID, err)
 	}
 	return layer, nil
 }
@@ -1155,7 +1274,10 @@ func (s *storageImageDestination) Commit(ctx context.Context, unparsedToplevel t
 	// Create the image record, pointing to the most-recently added layer.
 	intendedID := s.imageRef.id
 	if intendedID == "" {
-		intendedID = s.computeID(man)
+		intendedID, err = s.computeID(man)
+		if err != nil {
+			return err
+		}
 	}
 	oldNames := []string{}
 	img, err := s.imageRef.transport.store.CreateImage(intendedID, nil, lastLayer, "", options)
diff --git a/vendor/github.com/containers/image/v5/version/version.go b/vendor/github.com/containers/image/v5/version/version.go
index 4d889f809..d98e04b9a 100644
--- a/vendor/github.com/containers/image/v5/version/version.go
+++ b/vendor/github.com/containers/image/v5/version/version.go
@@ -6,12 +6,12 @@ const (
 	// VersionMajor is for an API incompatible changes
 	VersionMajor = 5
 	// VersionMinor is for functionality in a backwards-compatible manner
-	VersionMinor = 32
+	VersionMinor = 33
 	// VersionPatch is for backwards-compatible bug fixes
 	VersionPatch = 0
 
 	// VersionDev indicates development branch. Releases will be empty string.
-	VersionDev = ""
+	VersionDev = "-dev"
 )
 
 // Version is the specification version that the package types support.
diff --git a/vendor/github.com/containers/storage/VERSION b/vendor/github.com/containers/storage/VERSION
index 094d6ad00..31907770a 100644
--- a/vendor/github.com/containers/storage/VERSION
+++ b/vendor/github.com/containers/storage/VERSION
@@ -1 +1 @@
-1.55.0
+1.56.0-dev
diff --git a/vendor/github.com/containers/storage/drivers/overlay/composefs.go b/vendor/github.com/containers/storage/drivers/overlay/composefs.go
index 973cd786c..23baa7f1a 100644
--- a/vendor/github.com/containers/storage/drivers/overlay/composefs.go
+++ b/vendor/github.com/containers/storage/drivers/overlay/composefs.go
@@ -8,7 +8,6 @@ import (
 	"encoding/binary"
 	"errors"
 	"fmt"
-	"io/fs"
 	"os"
 	"os/exec"
 	"path/filepath"
@@ -55,29 +54,26 @@ func generateComposeFsBlob(verityDigests map[string]string, toc interface{}, com
 		return fmt.Errorf("failed to find mkcomposefs: %w", err)
 	}
 
-	fd, err := unix.Openat(unix.AT_FDCWD, destFile, unix.O_WRONLY|unix.O_CREAT|unix.O_TRUNC|unix.O_EXCL|unix.O_CLOEXEC, 0o644)
+	outFile, err := os.OpenFile(destFile, os.O_WRONLY|os.O_CREATE|os.O_EXCL, 0o644)
 	if err != nil {
-		return &fs.PathError{Op: "openat", Path: destFile, Err: err}
+		return err
 	}
-	outFd := os.NewFile(uintptr(fd), "outFd")
 
-	fd, err = unix.Open(fmt.Sprintf("/proc/self/fd/%d", outFd.Fd()), unix.O_RDONLY|unix.O_CLOEXEC, 0)
+	roFile, err := os.Open(fmt.Sprintf("/proc/self/fd/%d", outFile.Fd()))
 	if err != nil {
-		outFd.Close()
-		return fmt.Errorf("failed to dup output file: %w", err)
+		outFile.Close()
+		return fmt.Errorf("failed to reopen %s as read-only: %w", destFile, err)
 	}
-	newFd := os.NewFile(uintptr(fd), "newFd")
-	defer newFd.Close()
 
 	err = func() error {
-		// a scope to close outFd before setting fsverity on the read-only fd.
-		defer outFd.Close()
+		// a scope to close outFile before setting fsverity on the read-only fd.
+		defer outFile.Close()
 
 		errBuf := &bytes.Buffer{}
-		cmd := exec.Command(writerJson, "--from-file", "-", "/proc/self/fd/3")
-		cmd.ExtraFiles = []*os.File{outFd}
+		cmd := exec.Command(writerJson, "--from-file", "-", "-")
 		cmd.Stderr = errBuf
 		cmd.Stdin = dumpReader
+		cmd.Stdout = outFile
 		if err := cmd.Run(); err != nil {
 			rErr := fmt.Errorf("failed to convert json to erofs: %w", err)
 			exitErr := &exec.ExitError{}
@@ -92,7 +88,7 @@ func generateComposeFsBlob(verityDigests map[string]string, toc interface{}, com
 		return err
 	}
 
-	if err := fsverity.EnableVerity("manifest file", int(newFd.Fd())); err != nil && !errors.Is(err, unix.ENOTSUP) && !errors.Is(err, unix.ENOTTY) {
+	if err := fsverity.EnableVerity("manifest file", int(roFile.Fd())); err != nil && !errors.Is(err, unix.ENOTSUP) && !errors.Is(err, unix.ENOTTY) {
 		logrus.Warningf("%s", err)
 	}
 
@@ -114,23 +110,30 @@ struct lcfs_erofs_header_s {
 
 // hasACL returns true if the erofs blob has ACLs enabled
 func hasACL(path string) (bool, error) {
-	const LCFS_EROFS_FLAGS_HAS_ACL = (1 << 0)
-
-	fd, err := unix.Openat(unix.AT_FDCWD, path, unix.O_RDONLY|unix.O_CLOEXEC, 0)
+	const (
+		LCFS_EROFS_FLAGS_HAS_ACL = (1 << 0)
+		versionNumberSize        = 4
+		magicNumberSize          = 4
+		flagsSize                = 4
+	)
+
+	file, err := os.Open(path)
 	if err != nil {
-		return false, &fs.PathError{Op: "openat", Path: path, Err: err}
+		return false, err
 	}
-	defer unix.Close(fd)
+	defer file.Close()
+
 	// do not worry about checking the magic number, if the file is invalid
 	// we will fail to mount it anyway
-	flags := make([]byte, 4)
-	nread, err := unix.Pread(fd, flags, 8)
+	buffer := make([]byte, versionNumberSize+magicNumberSize+flagsSize)
+	nread, err := file.Read(buffer)
 	if err != nil {
-		return false, fmt.Errorf("pread %q: %w", path, err)
+		return false, err
 	}
-	if nread != 4 {
+	if nread != len(buffer) {
 		return false, fmt.Errorf("failed to read flags from %q", path)
 	}
+	flags := buffer[versionNumberSize+magicNumberSize:]
 	return binary.LittleEndian.Uint32(flags)&LCFS_EROFS_FLAGS_HAS_ACL != 0, nil
 }
 
@@ -146,9 +149,9 @@ func mountComposefsBlob(dataDir, mountPoint string) error {
 	if err != nil {
 		return err
 	}
-	mountOpts := "ro"
+	mountOpts := ""
 	if !hasACL {
-		mountOpts += ",noacl"
+		mountOpts += "noacl"
 	}
 
 	if err := unix.Mount(loop.Name(), mountPoint, "erofs", unix.MS_RDONLY, mountOpts); err != nil {
diff --git a/vendor/github.com/containers/storage/drivers/overlay/overlay.go b/vendor/github.com/containers/storage/drivers/overlay/overlay.go
index 8ed35745f..b95af8a0c 100644
--- a/vendor/github.com/containers/storage/drivers/overlay/overlay.go
+++ b/vendor/github.com/containers/storage/drivers/overlay/overlay.go
@@ -1934,7 +1934,7 @@ func (d *Driver) Put(id string) error {
 		// If fusermount|fusermount3 failed to unmount the FUSE file system, make sure all
 		// pending changes are propagated to the file system
 		if !unmounted {
-			fd, err := unix.Open(mountpoint, unix.O_DIRECTORY, 0)
+			fd, err := unix.Open(mountpoint, unix.O_DIRECTORY|unix.O_CLOEXEC, 0)
 			if err == nil {
 				if err := unix.Syncfs(fd); err != nil {
 					logrus.Debugf("Error Syncfs(%s) - %v", mountpoint, err)
diff --git a/vendor/github.com/containers/storage/pkg/chunked/filesystem_linux.go b/vendor/github.com/containers/storage/pkg/chunked/filesystem_linux.go
index 4fc4864a2..e26e5e5c5 100644
--- a/vendor/github.com/containers/storage/pkg/chunked/filesystem_linux.go
+++ b/vendor/github.com/containers/storage/pkg/chunked/filesystem_linux.go
@@ -174,7 +174,7 @@ func setFileAttrs(dirfd int, file *os.File, mode os.FileMode, metadata *fileMeta
 	if usePath {
 		dirName := filepath.Dir(metadata.Name)
 		if dirName != "" {
-			parentFd, err := openFileUnderRoot(dirfd, dirName, unix.O_PATH|unix.O_DIRECTORY, 0)
+			parentFd, err := openFileUnderRoot(dirfd, dirName, unix.O_PATH|unix.O_DIRECTORY|unix.O_CLOEXEC, 0)
 			if err != nil {
 				return err
 			}
@@ -402,7 +402,7 @@ func openFileUnderRoot(dirfd int, name string, flags uint64, mode os.FileMode) (
 // name is the path to open relative to dirfd.
 // mode specifies the mode to use for newly created files.
 func openOrCreateDirUnderRoot(dirfd int, name string, mode os.FileMode) (*os.File, error) {
-	fd, err := openFileUnderRootRaw(dirfd, name, unix.O_DIRECTORY|unix.O_RDONLY, 0)
+	fd, err := openFileUnderRootRaw(dirfd, name, unix.O_DIRECTORY|unix.O_RDONLY|unix.O_CLOEXEC, 0)
 	if err == nil {
 		return os.NewFile(uintptr(fd), name), nil
 	}
@@ -422,7 +422,7 @@ func openOrCreateDirUnderRoot(dirfd int, name string, mode os.FileMode) (*os.Fil
 				return nil, &fs.PathError{Op: "mkdirat", Path: name, Err: err2}
 			}
 
-			fd, err = openFileUnderRootRaw(int(pDir.Fd()), baseName, unix.O_DIRECTORY|unix.O_RDONLY, 0)
+			fd, err = openFileUnderRootRaw(int(pDir.Fd()), baseName, unix.O_DIRECTORY|unix.O_RDONLY|unix.O_CLOEXEC, 0)
 			if err == nil {
 				return os.NewFile(uintptr(fd), name), nil
 			}
@@ -465,7 +465,7 @@ func safeMkdir(dirfd int, mode os.FileMode, name string, metadata *fileMetadata,
 		}
 	}
 
-	file, err := openFileUnderRoot(parentFd, base, unix.O_DIRECTORY|unix.O_RDONLY, 0)
+	file, err := openFileUnderRoot(parentFd, base, unix.O_DIRECTORY|unix.O_RDONLY|unix.O_CLOEXEC, 0)
 	if err != nil {
 		return err
 	}
@@ -475,7 +475,7 @@ func safeMkdir(dirfd int, mode os.FileMode, name string, metadata *fileMetadata,
 }
 
 func safeLink(dirfd int, mode os.FileMode, metadata *fileMetadata, options *archive.TarOptions) error {
-	sourceFile, err := openFileUnderRoot(dirfd, metadata.Linkname, unix.O_PATH|unix.O_RDONLY|unix.O_NOFOLLOW, 0)
+	sourceFile, err := openFileUnderRoot(dirfd, metadata.Linkname, unix.O_PATH|unix.O_RDONLY|unix.O_NOFOLLOW|unix.O_CLOEXEC, 0)
 	if err != nil {
 		return err
 	}
diff --git a/vendor/github.com/containers/storage/pkg/idmap/idmapped_utils.go b/vendor/github.com/containers/storage/pkg/idmap/idmapped_utils.go
index 35b93e626..21590a4e6 100644
--- a/vendor/github.com/containers/storage/pkg/idmap/idmapped_utils.go
+++ b/vendor/github.com/containers/storage/pkg/idmap/idmapped_utils.go
@@ -4,7 +4,9 @@
 package idmap
 
 import (
+	"errors"
 	"fmt"
+	"io/fs"
 	"os"
 	"runtime"
 	"syscall"
@@ -26,7 +28,7 @@ func CreateIDMappedMount(source, target string, pid int) error {
 
 	targetDirFd, err := unix.OpenTree(0, source, unix.OPEN_TREE_CLONE)
 	if err != nil {
-		return err
+		return &os.PathError{Op: "open_tree", Path: source, Err: err}
 	}
 	defer unix.Close(targetDirFd)
 
@@ -35,13 +37,16 @@ func CreateIDMappedMount(source, target string, pid int) error {
 			Attr_set:  unix.MOUNT_ATTR_IDMAP,
 			Userns_fd: uint64(userNsFile.Fd()),
 		}); err != nil {
-		return err
+		return &os.PathError{Op: "mount_setattr", Path: source, Err: err}
 	}
-	if err := os.Mkdir(target, 0o700); err != nil && !os.IsExist(err) {
+	if err := os.Mkdir(target, 0o700); err != nil && !errors.Is(err, fs.ErrExist) {
 		return err
 	}
 
-	return unix.MoveMount(targetDirFd, "", 0, target, unix.MOVE_MOUNT_F_EMPTY_PATH)
+	if err := unix.MoveMount(targetDirFd, "", 0, target, unix.MOVE_MOUNT_F_EMPTY_PATH); err != nil {
+		return &os.PathError{Op: "move_mount", Path: target, Err: err}
+	}
+	return nil
 }
 
 // CreateUsernsProcess forks the current process and creates a user namespace using the specified
diff --git a/vendor/github.com/mattn/go-runewidth/runewidth_table.go b/vendor/github.com/mattn/go-runewidth/runewidth_table.go
index e5d890c26..ad025ad52 100644
--- a/vendor/github.com/mattn/go-runewidth/runewidth_table.go
+++ b/vendor/github.com/mattn/go-runewidth/runewidth_table.go
@@ -4,20 +4,21 @@ package runewidth
 
 var combining = table{
 	{0x0300, 0x036F}, {0x0483, 0x0489}, {0x07EB, 0x07F3},
-	{0x0C00, 0x0C00}, {0x0C04, 0x0C04}, {0x0D00, 0x0D01},
-	{0x135D, 0x135F}, {0x1A7F, 0x1A7F}, {0x1AB0, 0x1AC0},
-	{0x1B6B, 0x1B73}, {0x1DC0, 0x1DF9}, {0x1DFB, 0x1DFF},
+	{0x0C00, 0x0C00}, {0x0C04, 0x0C04}, {0x0CF3, 0x0CF3},
+	{0x0D00, 0x0D01}, {0x135D, 0x135F}, {0x1A7F, 0x1A7F},
+	{0x1AB0, 0x1ACE}, {0x1B6B, 0x1B73}, {0x1DC0, 0x1DFF},
 	{0x20D0, 0x20F0}, {0x2CEF, 0x2CF1}, {0x2DE0, 0x2DFF},
 	{0x3099, 0x309A}, {0xA66F, 0xA672}, {0xA674, 0xA67D},
 	{0xA69E, 0xA69F}, {0xA6F0, 0xA6F1}, {0xA8E0, 0xA8F1},
 	{0xFE20, 0xFE2F}, {0x101FD, 0x101FD}, {0x10376, 0x1037A},
-	{0x10EAB, 0x10EAC}, {0x10F46, 0x10F50}, {0x11300, 0x11301},
-	{0x1133B, 0x1133C}, {0x11366, 0x1136C}, {0x11370, 0x11374},
-	{0x16AF0, 0x16AF4}, {0x1D165, 0x1D169}, {0x1D16D, 0x1D172},
+	{0x10EAB, 0x10EAC}, {0x10F46, 0x10F50}, {0x10F82, 0x10F85},
+	{0x11300, 0x11301}, {0x1133B, 0x1133C}, {0x11366, 0x1136C},
+	{0x11370, 0x11374}, {0x16AF0, 0x16AF4}, {0x1CF00, 0x1CF2D},
+	{0x1CF30, 0x1CF46}, {0x1D165, 0x1D169}, {0x1D16D, 0x1D172},
 	{0x1D17B, 0x1D182}, {0x1D185, 0x1D18B}, {0x1D1AA, 0x1D1AD},
 	{0x1D242, 0x1D244}, {0x1E000, 0x1E006}, {0x1E008, 0x1E018},
 	{0x1E01B, 0x1E021}, {0x1E023, 0x1E024}, {0x1E026, 0x1E02A},
-	{0x1E8D0, 0x1E8D6},
+	{0x1E08F, 0x1E08F}, {0x1E8D0, 0x1E8D6},
 }
 
 var doublewidth = table{
@@ -33,33 +34,34 @@ var doublewidth = table{
 	{0x2753, 0x2755}, {0x2757, 0x2757}, {0x2795, 0x2797},
 	{0x27B0, 0x27B0}, {0x27BF, 0x27BF}, {0x2B1B, 0x2B1C},
 	{0x2B50, 0x2B50}, {0x2B55, 0x2B55}, {0x2E80, 0x2E99},
-	{0x2E9B, 0x2EF3}, {0x2F00, 0x2FD5}, {0x2FF0, 0x2FFB},
-	{0x3000, 0x303E}, {0x3041, 0x3096}, {0x3099, 0x30FF},
-	{0x3105, 0x312F}, {0x3131, 0x318E}, {0x3190, 0x31E3},
-	{0x31F0, 0x321E}, {0x3220, 0x3247}, {0x3250, 0x4DBF},
-	{0x4E00, 0xA48C}, {0xA490, 0xA4C6}, {0xA960, 0xA97C},
-	{0xAC00, 0xD7A3}, {0xF900, 0xFAFF}, {0xFE10, 0xFE19},
-	{0xFE30, 0xFE52}, {0xFE54, 0xFE66}, {0xFE68, 0xFE6B},
-	{0xFF01, 0xFF60}, {0xFFE0, 0xFFE6}, {0x16FE0, 0x16FE4},
-	{0x16FF0, 0x16FF1}, {0x17000, 0x187F7}, {0x18800, 0x18CD5},
-	{0x18D00, 0x18D08}, {0x1B000, 0x1B11E}, {0x1B150, 0x1B152},
-	{0x1B164, 0x1B167}, {0x1B170, 0x1B2FB}, {0x1F004, 0x1F004},
-	{0x1F0CF, 0x1F0CF}, {0x1F18E, 0x1F18E}, {0x1F191, 0x1F19A},
-	{0x1F200, 0x1F202}, {0x1F210, 0x1F23B}, {0x1F240, 0x1F248},
-	{0x1F250, 0x1F251}, {0x1F260, 0x1F265}, {0x1F300, 0x1F320},
-	{0x1F32D, 0x1F335}, {0x1F337, 0x1F37C}, {0x1F37E, 0x1F393},
-	{0x1F3A0, 0x1F3CA}, {0x1F3CF, 0x1F3D3}, {0x1F3E0, 0x1F3F0},
-	{0x1F3F4, 0x1F3F4}, {0x1F3F8, 0x1F43E}, {0x1F440, 0x1F440},
-	{0x1F442, 0x1F4FC}, {0x1F4FF, 0x1F53D}, {0x1F54B, 0x1F54E},
-	{0x1F550, 0x1F567}, {0x1F57A, 0x1F57A}, {0x1F595, 0x1F596},
-	{0x1F5A4, 0x1F5A4}, {0x1F5FB, 0x1F64F}, {0x1F680, 0x1F6C5},
-	{0x1F6CC, 0x1F6CC}, {0x1F6D0, 0x1F6D2}, {0x1F6D5, 0x1F6D7},
-	{0x1F6EB, 0x1F6EC}, {0x1F6F4, 0x1F6FC}, {0x1F7E0, 0x1F7EB},
-	{0x1F90C, 0x1F93A}, {0x1F93C, 0x1F945}, {0x1F947, 0x1F978},
-	{0x1F97A, 0x1F9CB}, {0x1F9CD, 0x1F9FF}, {0x1FA70, 0x1FA74},
-	{0x1FA78, 0x1FA7A}, {0x1FA80, 0x1FA86}, {0x1FA90, 0x1FAA8},
-	{0x1FAB0, 0x1FAB6}, {0x1FAC0, 0x1FAC2}, {0x1FAD0, 0x1FAD6},
-	{0x20000, 0x2FFFD}, {0x30000, 0x3FFFD},
+	{0x2E9B, 0x2EF3}, {0x2F00, 0x2FD5}, {0x2FF0, 0x303E},
+	{0x3041, 0x3096}, {0x3099, 0x30FF}, {0x3105, 0x312F},
+	{0x3131, 0x318E}, {0x3190, 0x31E3}, {0x31EF, 0x321E},
+	{0x3220, 0x3247}, {0x3250, 0x4DBF}, {0x4E00, 0xA48C},
+	{0xA490, 0xA4C6}, {0xA960, 0xA97C}, {0xAC00, 0xD7A3},
+	{0xF900, 0xFAFF}, {0xFE10, 0xFE19}, {0xFE30, 0xFE52},
+	{0xFE54, 0xFE66}, {0xFE68, 0xFE6B}, {0xFF01, 0xFF60},
+	{0xFFE0, 0xFFE6}, {0x16FE0, 0x16FE4}, {0x16FF0, 0x16FF1},
+	{0x17000, 0x187F7}, {0x18800, 0x18CD5}, {0x18D00, 0x18D08},
+	{0x1AFF0, 0x1AFF3}, {0x1AFF5, 0x1AFFB}, {0x1AFFD, 0x1AFFE},
+	{0x1B000, 0x1B122}, {0x1B132, 0x1B132}, {0x1B150, 0x1B152},
+	{0x1B155, 0x1B155}, {0x1B164, 0x1B167}, {0x1B170, 0x1B2FB},
+	{0x1F004, 0x1F004}, {0x1F0CF, 0x1F0CF}, {0x1F18E, 0x1F18E},
+	{0x1F191, 0x1F19A}, {0x1F200, 0x1F202}, {0x1F210, 0x1F23B},
+	{0x1F240, 0x1F248}, {0x1F250, 0x1F251}, {0x1F260, 0x1F265},
+	{0x1F300, 0x1F320}, {0x1F32D, 0x1F335}, {0x1F337, 0x1F37C},
+	{0x1F37E, 0x1F393}, {0x1F3A0, 0x1F3CA}, {0x1F3CF, 0x1F3D3},
+	{0x1F3E0, 0x1F3F0}, {0x1F3F4, 0x1F3F4}, {0x1F3F8, 0x1F43E},
+	{0x1F440, 0x1F440}, {0x1F442, 0x1F4FC}, {0x1F4FF, 0x1F53D},
+	{0x1F54B, 0x1F54E}, {0x1F550, 0x1F567}, {0x1F57A, 0x1F57A},
+	{0x1F595, 0x1F596}, {0x1F5A4, 0x1F5A4}, {0x1F5FB, 0x1F64F},
+	{0x1F680, 0x1F6C5}, {0x1F6CC, 0x1F6CC}, {0x1F6D0, 0x1F6D2},
+	{0x1F6D5, 0x1F6D7}, {0x1F6DC, 0x1F6DF}, {0x1F6EB, 0x1F6EC},
+	{0x1F6F4, 0x1F6FC}, {0x1F7E0, 0x1F7EB}, {0x1F7F0, 0x1F7F0},
+	{0x1F90C, 0x1F93A}, {0x1F93C, 0x1F945}, {0x1F947, 0x1F9FF},
+	{0x1FA70, 0x1FA7C}, {0x1FA80, 0x1FA88}, {0x1FA90, 0x1FABD},
+	{0x1FABF, 0x1FAC5}, {0x1FACE, 0x1FADB}, {0x1FAE0, 0x1FAE8},
+	{0x1FAF0, 0x1FAF8}, {0x20000, 0x2FFFD}, {0x30000, 0x3FFFD},
 }
 
 var ambiguous = table{
@@ -154,43 +156,43 @@ var neutral = table{
 	{0x0402, 0x040F}, {0x0450, 0x0450}, {0x0452, 0x052F},
 	{0x0531, 0x0556}, {0x0559, 0x058A}, {0x058D, 0x058F},
 	{0x0591, 0x05C7}, {0x05D0, 0x05EA}, {0x05EF, 0x05F4},
-	{0x0600, 0x061C}, {0x061E, 0x070D}, {0x070F, 0x074A},
-	{0x074D, 0x07B1}, {0x07C0, 0x07FA}, {0x07FD, 0x082D},
-	{0x0830, 0x083E}, {0x0840, 0x085B}, {0x085E, 0x085E},
-	{0x0860, 0x086A}, {0x08A0, 0x08B4}, {0x08B6, 0x08C7},
-	{0x08D3, 0x0983}, {0x0985, 0x098C}, {0x098F, 0x0990},
-	{0x0993, 0x09A8}, {0x09AA, 0x09B0}, {0x09B2, 0x09B2},
-	{0x09B6, 0x09B9}, {0x09BC, 0x09C4}, {0x09C7, 0x09C8},
-	{0x09CB, 0x09CE}, {0x09D7, 0x09D7}, {0x09DC, 0x09DD},
-	{0x09DF, 0x09E3}, {0x09E6, 0x09FE}, {0x0A01, 0x0A03},
-	{0x0A05, 0x0A0A}, {0x0A0F, 0x0A10}, {0x0A13, 0x0A28},
-	{0x0A2A, 0x0A30}, {0x0A32, 0x0A33}, {0x0A35, 0x0A36},
-	{0x0A38, 0x0A39}, {0x0A3C, 0x0A3C}, {0x0A3E, 0x0A42},
-	{0x0A47, 0x0A48}, {0x0A4B, 0x0A4D}, {0x0A51, 0x0A51},
-	{0x0A59, 0x0A5C}, {0x0A5E, 0x0A5E}, {0x0A66, 0x0A76},
-	{0x0A81, 0x0A83}, {0x0A85, 0x0A8D}, {0x0A8F, 0x0A91},
-	{0x0A93, 0x0AA8}, {0x0AAA, 0x0AB0}, {0x0AB2, 0x0AB3},
-	{0x0AB5, 0x0AB9}, {0x0ABC, 0x0AC5}, {0x0AC7, 0x0AC9},
-	{0x0ACB, 0x0ACD}, {0x0AD0, 0x0AD0}, {0x0AE0, 0x0AE3},
-	{0x0AE6, 0x0AF1}, {0x0AF9, 0x0AFF}, {0x0B01, 0x0B03},
-	{0x0B05, 0x0B0C}, {0x0B0F, 0x0B10}, {0x0B13, 0x0B28},
-	{0x0B2A, 0x0B30}, {0x0B32, 0x0B33}, {0x0B35, 0x0B39},
-	{0x0B3C, 0x0B44}, {0x0B47, 0x0B48}, {0x0B4B, 0x0B4D},
-	{0x0B55, 0x0B57}, {0x0B5C, 0x0B5D}, {0x0B5F, 0x0B63},
-	{0x0B66, 0x0B77}, {0x0B82, 0x0B83}, {0x0B85, 0x0B8A},
-	{0x0B8E, 0x0B90}, {0x0B92, 0x0B95}, {0x0B99, 0x0B9A},
-	{0x0B9C, 0x0B9C}, {0x0B9E, 0x0B9F}, {0x0BA3, 0x0BA4},
-	{0x0BA8, 0x0BAA}, {0x0BAE, 0x0BB9}, {0x0BBE, 0x0BC2},
-	{0x0BC6, 0x0BC8}, {0x0BCA, 0x0BCD}, {0x0BD0, 0x0BD0},
-	{0x0BD7, 0x0BD7}, {0x0BE6, 0x0BFA}, {0x0C00, 0x0C0C},
-	{0x0C0E, 0x0C10}, {0x0C12, 0x0C28}, {0x0C2A, 0x0C39},
-	{0x0C3D, 0x0C44}, {0x0C46, 0x0C48}, {0x0C4A, 0x0C4D},
-	{0x0C55, 0x0C56}, {0x0C58, 0x0C5A}, {0x0C60, 0x0C63},
+	{0x0600, 0x070D}, {0x070F, 0x074A}, {0x074D, 0x07B1},
+	{0x07C0, 0x07FA}, {0x07FD, 0x082D}, {0x0830, 0x083E},
+	{0x0840, 0x085B}, {0x085E, 0x085E}, {0x0860, 0x086A},
+	{0x0870, 0x088E}, {0x0890, 0x0891}, {0x0898, 0x0983},
+	{0x0985, 0x098C}, {0x098F, 0x0990}, {0x0993, 0x09A8},
+	{0x09AA, 0x09B0}, {0x09B2, 0x09B2}, {0x09B6, 0x09B9},
+	{0x09BC, 0x09C4}, {0x09C7, 0x09C8}, {0x09CB, 0x09CE},
+	{0x09D7, 0x09D7}, {0x09DC, 0x09DD}, {0x09DF, 0x09E3},
+	{0x09E6, 0x09FE}, {0x0A01, 0x0A03}, {0x0A05, 0x0A0A},
+	{0x0A0F, 0x0A10}, {0x0A13, 0x0A28}, {0x0A2A, 0x0A30},
+	{0x0A32, 0x0A33}, {0x0A35, 0x0A36}, {0x0A38, 0x0A39},
+	{0x0A3C, 0x0A3C}, {0x0A3E, 0x0A42}, {0x0A47, 0x0A48},
+	{0x0A4B, 0x0A4D}, {0x0A51, 0x0A51}, {0x0A59, 0x0A5C},
+	{0x0A5E, 0x0A5E}, {0x0A66, 0x0A76}, {0x0A81, 0x0A83},
+	{0x0A85, 0x0A8D}, {0x0A8F, 0x0A91}, {0x0A93, 0x0AA8},
+	{0x0AAA, 0x0AB0}, {0x0AB2, 0x0AB3}, {0x0AB5, 0x0AB9},
+	{0x0ABC, 0x0AC5}, {0x0AC7, 0x0AC9}, {0x0ACB, 0x0ACD},
+	{0x0AD0, 0x0AD0}, {0x0AE0, 0x0AE3}, {0x0AE6, 0x0AF1},
+	{0x0AF9, 0x0AFF}, {0x0B01, 0x0B03}, {0x0B05, 0x0B0C},
+	{0x0B0F, 0x0B10}, {0x0B13, 0x0B28}, {0x0B2A, 0x0B30},
+	{0x0B32, 0x0B33}, {0x0B35, 0x0B39}, {0x0B3C, 0x0B44},
+	{0x0B47, 0x0B48}, {0x0B4B, 0x0B4D}, {0x0B55, 0x0B57},
+	{0x0B5C, 0x0B5D}, {0x0B5F, 0x0B63}, {0x0B66, 0x0B77},
+	{0x0B82, 0x0B83}, {0x0B85, 0x0B8A}, {0x0B8E, 0x0B90},
+	{0x0B92, 0x0B95}, {0x0B99, 0x0B9A}, {0x0B9C, 0x0B9C},
+	{0x0B9E, 0x0B9F}, {0x0BA3, 0x0BA4}, {0x0BA8, 0x0BAA},
+	{0x0BAE, 0x0BB9}, {0x0BBE, 0x0BC2}, {0x0BC6, 0x0BC8},
+	{0x0BCA, 0x0BCD}, {0x0BD0, 0x0BD0}, {0x0BD7, 0x0BD7},
+	{0x0BE6, 0x0BFA}, {0x0C00, 0x0C0C}, {0x0C0E, 0x0C10},
+	{0x0C12, 0x0C28}, {0x0C2A, 0x0C39}, {0x0C3C, 0x0C44},
+	{0x0C46, 0x0C48}, {0x0C4A, 0x0C4D}, {0x0C55, 0x0C56},
+	{0x0C58, 0x0C5A}, {0x0C5D, 0x0C5D}, {0x0C60, 0x0C63},
 	{0x0C66, 0x0C6F}, {0x0C77, 0x0C8C}, {0x0C8E, 0x0C90},
 	{0x0C92, 0x0CA8}, {0x0CAA, 0x0CB3}, {0x0CB5, 0x0CB9},
 	{0x0CBC, 0x0CC4}, {0x0CC6, 0x0CC8}, {0x0CCA, 0x0CCD},
-	{0x0CD5, 0x0CD6}, {0x0CDE, 0x0CDE}, {0x0CE0, 0x0CE3},
-	{0x0CE6, 0x0CEF}, {0x0CF1, 0x0CF2}, {0x0D00, 0x0D0C},
+	{0x0CD5, 0x0CD6}, {0x0CDD, 0x0CDE}, {0x0CE0, 0x0CE3},
+	{0x0CE6, 0x0CEF}, {0x0CF1, 0x0CF3}, {0x0D00, 0x0D0C},
 	{0x0D0E, 0x0D10}, {0x0D12, 0x0D44}, {0x0D46, 0x0D48},
 	{0x0D4A, 0x0D4F}, {0x0D54, 0x0D63}, {0x0D66, 0x0D7F},
 	{0x0D81, 0x0D83}, {0x0D85, 0x0D96}, {0x0D9A, 0x0DB1},
@@ -200,7 +202,7 @@ var neutral = table{
 	{0x0E01, 0x0E3A}, {0x0E3F, 0x0E5B}, {0x0E81, 0x0E82},
 	{0x0E84, 0x0E84}, {0x0E86, 0x0E8A}, {0x0E8C, 0x0EA3},
 	{0x0EA5, 0x0EA5}, {0x0EA7, 0x0EBD}, {0x0EC0, 0x0EC4},
-	{0x0EC6, 0x0EC6}, {0x0EC8, 0x0ECD}, {0x0ED0, 0x0ED9},
+	{0x0EC6, 0x0EC6}, {0x0EC8, 0x0ECE}, {0x0ED0, 0x0ED9},
 	{0x0EDC, 0x0EDF}, {0x0F00, 0x0F47}, {0x0F49, 0x0F6C},
 	{0x0F71, 0x0F97}, {0x0F99, 0x0FBC}, {0x0FBE, 0x0FCC},
 	{0x0FCE, 0x0FDA}, {0x1000, 0x10C5}, {0x10C7, 0x10C7},
@@ -212,20 +214,19 @@ var neutral = table{
 	{0x12D8, 0x1310}, {0x1312, 0x1315}, {0x1318, 0x135A},
 	{0x135D, 0x137C}, {0x1380, 0x1399}, {0x13A0, 0x13F5},
 	{0x13F8, 0x13FD}, {0x1400, 0x169C}, {0x16A0, 0x16F8},
-	{0x1700, 0x170C}, {0x170E, 0x1714}, {0x1720, 0x1736},
-	{0x1740, 0x1753}, {0x1760, 0x176C}, {0x176E, 0x1770},
-	{0x1772, 0x1773}, {0x1780, 0x17DD}, {0x17E0, 0x17E9},
-	{0x17F0, 0x17F9}, {0x1800, 0x180E}, {0x1810, 0x1819},
-	{0x1820, 0x1878}, {0x1880, 0x18AA}, {0x18B0, 0x18F5},
-	{0x1900, 0x191E}, {0x1920, 0x192B}, {0x1930, 0x193B},
-	{0x1940, 0x1940}, {0x1944, 0x196D}, {0x1970, 0x1974},
-	{0x1980, 0x19AB}, {0x19B0, 0x19C9}, {0x19D0, 0x19DA},
-	{0x19DE, 0x1A1B}, {0x1A1E, 0x1A5E}, {0x1A60, 0x1A7C},
-	{0x1A7F, 0x1A89}, {0x1A90, 0x1A99}, {0x1AA0, 0x1AAD},
-	{0x1AB0, 0x1AC0}, {0x1B00, 0x1B4B}, {0x1B50, 0x1B7C},
-	{0x1B80, 0x1BF3}, {0x1BFC, 0x1C37}, {0x1C3B, 0x1C49},
-	{0x1C4D, 0x1C88}, {0x1C90, 0x1CBA}, {0x1CBD, 0x1CC7},
-	{0x1CD0, 0x1CFA}, {0x1D00, 0x1DF9}, {0x1DFB, 0x1F15},
+	{0x1700, 0x1715}, {0x171F, 0x1736}, {0x1740, 0x1753},
+	{0x1760, 0x176C}, {0x176E, 0x1770}, {0x1772, 0x1773},
+	{0x1780, 0x17DD}, {0x17E0, 0x17E9}, {0x17F0, 0x17F9},
+	{0x1800, 0x1819}, {0x1820, 0x1878}, {0x1880, 0x18AA},
+	{0x18B0, 0x18F5}, {0x1900, 0x191E}, {0x1920, 0x192B},
+	{0x1930, 0x193B}, {0x1940, 0x1940}, {0x1944, 0x196D},
+	{0x1970, 0x1974}, {0x1980, 0x19AB}, {0x19B0, 0x19C9},
+	{0x19D0, 0x19DA}, {0x19DE, 0x1A1B}, {0x1A1E, 0x1A5E},
+	{0x1A60, 0x1A7C}, {0x1A7F, 0x1A89}, {0x1A90, 0x1A99},
+	{0x1AA0, 0x1AAD}, {0x1AB0, 0x1ACE}, {0x1B00, 0x1B4C},
+	{0x1B50, 0x1B7E}, {0x1B80, 0x1BF3}, {0x1BFC, 0x1C37},
+	{0x1C3B, 0x1C49}, {0x1C4D, 0x1C88}, {0x1C90, 0x1CBA},
+	{0x1CBD, 0x1CC7}, {0x1CD0, 0x1CFA}, {0x1D00, 0x1F15},
 	{0x1F18, 0x1F1D}, {0x1F20, 0x1F45}, {0x1F48, 0x1F4D},
 	{0x1F50, 0x1F57}, {0x1F59, 0x1F59}, {0x1F5B, 0x1F5B},
 	{0x1F5D, 0x1F5D}, {0x1F5F, 0x1F7D}, {0x1F80, 0x1FB4},
@@ -237,7 +238,7 @@ var neutral = table{
 	{0x2036, 0x203A}, {0x203C, 0x203D}, {0x203F, 0x2064},
 	{0x2066, 0x2071}, {0x2075, 0x207E}, {0x2080, 0x2080},
 	{0x2085, 0x208E}, {0x2090, 0x209C}, {0x20A0, 0x20A8},
-	{0x20AA, 0x20AB}, {0x20AD, 0x20BF}, {0x20D0, 0x20F0},
+	{0x20AA, 0x20AB}, {0x20AD, 0x20C0}, {0x20D0, 0x20F0},
 	{0x2100, 0x2102}, {0x2104, 0x2104}, {0x2106, 0x2108},
 	{0x210A, 0x2112}, {0x2114, 0x2115}, {0x2117, 0x2120},
 	{0x2123, 0x2125}, {0x2127, 0x212A}, {0x212C, 0x2152},
@@ -275,15 +276,15 @@ var neutral = table{
 	{0x2780, 0x2794}, {0x2798, 0x27AF}, {0x27B1, 0x27BE},
 	{0x27C0, 0x27E5}, {0x27EE, 0x2984}, {0x2987, 0x2B1A},
 	{0x2B1D, 0x2B4F}, {0x2B51, 0x2B54}, {0x2B5A, 0x2B73},
-	{0x2B76, 0x2B95}, {0x2B97, 0x2C2E}, {0x2C30, 0x2C5E},
-	{0x2C60, 0x2CF3}, {0x2CF9, 0x2D25}, {0x2D27, 0x2D27},
-	{0x2D2D, 0x2D2D}, {0x2D30, 0x2D67}, {0x2D6F, 0x2D70},
-	{0x2D7F, 0x2D96}, {0x2DA0, 0x2DA6}, {0x2DA8, 0x2DAE},
-	{0x2DB0, 0x2DB6}, {0x2DB8, 0x2DBE}, {0x2DC0, 0x2DC6},
-	{0x2DC8, 0x2DCE}, {0x2DD0, 0x2DD6}, {0x2DD8, 0x2DDE},
-	{0x2DE0, 0x2E52}, {0x303F, 0x303F}, {0x4DC0, 0x4DFF},
-	{0xA4D0, 0xA62B}, {0xA640, 0xA6F7}, {0xA700, 0xA7BF},
-	{0xA7C2, 0xA7CA}, {0xA7F5, 0xA82C}, {0xA830, 0xA839},
+	{0x2B76, 0x2B95}, {0x2B97, 0x2CF3}, {0x2CF9, 0x2D25},
+	{0x2D27, 0x2D27}, {0x2D2D, 0x2D2D}, {0x2D30, 0x2D67},
+	{0x2D6F, 0x2D70}, {0x2D7F, 0x2D96}, {0x2DA0, 0x2DA6},
+	{0x2DA8, 0x2DAE}, {0x2DB0, 0x2DB6}, {0x2DB8, 0x2DBE},
+	{0x2DC0, 0x2DC6}, {0x2DC8, 0x2DCE}, {0x2DD0, 0x2DD6},
+	{0x2DD8, 0x2DDE}, {0x2DE0, 0x2E5D}, {0x303F, 0x303F},
+	{0x4DC0, 0x4DFF}, {0xA4D0, 0xA62B}, {0xA640, 0xA6F7},
+	{0xA700, 0xA7CA}, {0xA7D0, 0xA7D1}, {0xA7D3, 0xA7D3},
+	{0xA7D5, 0xA7D9}, {0xA7F2, 0xA82C}, {0xA830, 0xA839},
 	{0xA840, 0xA877}, {0xA880, 0xA8C5}, {0xA8CE, 0xA8D9},
 	{0xA8E0, 0xA953}, {0xA95F, 0xA95F}, {0xA980, 0xA9CD},
 	{0xA9CF, 0xA9D9}, {0xA9DE, 0xA9FE}, {0xAA00, 0xAA36},
@@ -294,8 +295,8 @@ var neutral = table{
 	{0xD7B0, 0xD7C6}, {0xD7CB, 0xD7FB}, {0xD800, 0xDFFF},
 	{0xFB00, 0xFB06}, {0xFB13, 0xFB17}, {0xFB1D, 0xFB36},
 	{0xFB38, 0xFB3C}, {0xFB3E, 0xFB3E}, {0xFB40, 0xFB41},
-	{0xFB43, 0xFB44}, {0xFB46, 0xFBC1}, {0xFBD3, 0xFD3F},
-	{0xFD50, 0xFD8F}, {0xFD92, 0xFDC7}, {0xFDF0, 0xFDFD},
+	{0xFB43, 0xFB44}, {0xFB46, 0xFBC2}, {0xFBD3, 0xFD8F},
+	{0xFD92, 0xFDC7}, {0xFDCF, 0xFDCF}, {0xFDF0, 0xFDFF},
 	{0xFE20, 0xFE2F}, {0xFE70, 0xFE74}, {0xFE76, 0xFEFC},
 	{0xFEFF, 0xFEFF}, {0xFFF9, 0xFFFC}, {0x10000, 0x1000B},
 	{0x1000D, 0x10026}, {0x10028, 0x1003A}, {0x1003C, 0x1003D},
@@ -307,44 +308,48 @@ var neutral = table{
 	{0x10380, 0x1039D}, {0x1039F, 0x103C3}, {0x103C8, 0x103D5},
 	{0x10400, 0x1049D}, {0x104A0, 0x104A9}, {0x104B0, 0x104D3},
 	{0x104D8, 0x104FB}, {0x10500, 0x10527}, {0x10530, 0x10563},
-	{0x1056F, 0x1056F}, {0x10600, 0x10736}, {0x10740, 0x10755},
-	{0x10760, 0x10767}, {0x10800, 0x10805}, {0x10808, 0x10808},
-	{0x1080A, 0x10835}, {0x10837, 0x10838}, {0x1083C, 0x1083C},
-	{0x1083F, 0x10855}, {0x10857, 0x1089E}, {0x108A7, 0x108AF},
-	{0x108E0, 0x108F2}, {0x108F4, 0x108F5}, {0x108FB, 0x1091B},
-	{0x1091F, 0x10939}, {0x1093F, 0x1093F}, {0x10980, 0x109B7},
-	{0x109BC, 0x109CF}, {0x109D2, 0x10A03}, {0x10A05, 0x10A06},
-	{0x10A0C, 0x10A13}, {0x10A15, 0x10A17}, {0x10A19, 0x10A35},
-	{0x10A38, 0x10A3A}, {0x10A3F, 0x10A48}, {0x10A50, 0x10A58},
-	{0x10A60, 0x10A9F}, {0x10AC0, 0x10AE6}, {0x10AEB, 0x10AF6},
-	{0x10B00, 0x10B35}, {0x10B39, 0x10B55}, {0x10B58, 0x10B72},
-	{0x10B78, 0x10B91}, {0x10B99, 0x10B9C}, {0x10BA9, 0x10BAF},
-	{0x10C00, 0x10C48}, {0x10C80, 0x10CB2}, {0x10CC0, 0x10CF2},
-	{0x10CFA, 0x10D27}, {0x10D30, 0x10D39}, {0x10E60, 0x10E7E},
-	{0x10E80, 0x10EA9}, {0x10EAB, 0x10EAD}, {0x10EB0, 0x10EB1},
-	{0x10F00, 0x10F27}, {0x10F30, 0x10F59}, {0x10FB0, 0x10FCB},
-	{0x10FE0, 0x10FF6}, {0x11000, 0x1104D}, {0x11052, 0x1106F},
-	{0x1107F, 0x110C1}, {0x110CD, 0x110CD}, {0x110D0, 0x110E8},
-	{0x110F0, 0x110F9}, {0x11100, 0x11134}, {0x11136, 0x11147},
-	{0x11150, 0x11176}, {0x11180, 0x111DF}, {0x111E1, 0x111F4},
-	{0x11200, 0x11211}, {0x11213, 0x1123E}, {0x11280, 0x11286},
-	{0x11288, 0x11288}, {0x1128A, 0x1128D}, {0x1128F, 0x1129D},
-	{0x1129F, 0x112A9}, {0x112B0, 0x112EA}, {0x112F0, 0x112F9},
-	{0x11300, 0x11303}, {0x11305, 0x1130C}, {0x1130F, 0x11310},
-	{0x11313, 0x11328}, {0x1132A, 0x11330}, {0x11332, 0x11333},
-	{0x11335, 0x11339}, {0x1133B, 0x11344}, {0x11347, 0x11348},
-	{0x1134B, 0x1134D}, {0x11350, 0x11350}, {0x11357, 0x11357},
-	{0x1135D, 0x11363}, {0x11366, 0x1136C}, {0x11370, 0x11374},
-	{0x11400, 0x1145B}, {0x1145D, 0x11461}, {0x11480, 0x114C7},
-	{0x114D0, 0x114D9}, {0x11580, 0x115B5}, {0x115B8, 0x115DD},
-	{0x11600, 0x11644}, {0x11650, 0x11659}, {0x11660, 0x1166C},
-	{0x11680, 0x116B8}, {0x116C0, 0x116C9}, {0x11700, 0x1171A},
-	{0x1171D, 0x1172B}, {0x11730, 0x1173F}, {0x11800, 0x1183B},
-	{0x118A0, 0x118F2}, {0x118FF, 0x11906}, {0x11909, 0x11909},
-	{0x1190C, 0x11913}, {0x11915, 0x11916}, {0x11918, 0x11935},
-	{0x11937, 0x11938}, {0x1193B, 0x11946}, {0x11950, 0x11959},
-	{0x119A0, 0x119A7}, {0x119AA, 0x119D7}, {0x119DA, 0x119E4},
-	{0x11A00, 0x11A47}, {0x11A50, 0x11AA2}, {0x11AC0, 0x11AF8},
+	{0x1056F, 0x1057A}, {0x1057C, 0x1058A}, {0x1058C, 0x10592},
+	{0x10594, 0x10595}, {0x10597, 0x105A1}, {0x105A3, 0x105B1},
+	{0x105B3, 0x105B9}, {0x105BB, 0x105BC}, {0x10600, 0x10736},
+	{0x10740, 0x10755}, {0x10760, 0x10767}, {0x10780, 0x10785},
+	{0x10787, 0x107B0}, {0x107B2, 0x107BA}, {0x10800, 0x10805},
+	{0x10808, 0x10808}, {0x1080A, 0x10835}, {0x10837, 0x10838},
+	{0x1083C, 0x1083C}, {0x1083F, 0x10855}, {0x10857, 0x1089E},
+	{0x108A7, 0x108AF}, {0x108E0, 0x108F2}, {0x108F4, 0x108F5},
+	{0x108FB, 0x1091B}, {0x1091F, 0x10939}, {0x1093F, 0x1093F},
+	{0x10980, 0x109B7}, {0x109BC, 0x109CF}, {0x109D2, 0x10A03},
+	{0x10A05, 0x10A06}, {0x10A0C, 0x10A13}, {0x10A15, 0x10A17},
+	{0x10A19, 0x10A35}, {0x10A38, 0x10A3A}, {0x10A3F, 0x10A48},
+	{0x10A50, 0x10A58}, {0x10A60, 0x10A9F}, {0x10AC0, 0x10AE6},
+	{0x10AEB, 0x10AF6}, {0x10B00, 0x10B35}, {0x10B39, 0x10B55},
+	{0x10B58, 0x10B72}, {0x10B78, 0x10B91}, {0x10B99, 0x10B9C},
+	{0x10BA9, 0x10BAF}, {0x10C00, 0x10C48}, {0x10C80, 0x10CB2},
+	{0x10CC0, 0x10CF2}, {0x10CFA, 0x10D27}, {0x10D30, 0x10D39},
+	{0x10E60, 0x10E7E}, {0x10E80, 0x10EA9}, {0x10EAB, 0x10EAD},
+	{0x10EB0, 0x10EB1}, {0x10EFD, 0x10F27}, {0x10F30, 0x10F59},
+	{0x10F70, 0x10F89}, {0x10FB0, 0x10FCB}, {0x10FE0, 0x10FF6},
+	{0x11000, 0x1104D}, {0x11052, 0x11075}, {0x1107F, 0x110C2},
+	{0x110CD, 0x110CD}, {0x110D0, 0x110E8}, {0x110F0, 0x110F9},
+	{0x11100, 0x11134}, {0x11136, 0x11147}, {0x11150, 0x11176},
+	{0x11180, 0x111DF}, {0x111E1, 0x111F4}, {0x11200, 0x11211},
+	{0x11213, 0x11241}, {0x11280, 0x11286}, {0x11288, 0x11288},
+	{0x1128A, 0x1128D}, {0x1128F, 0x1129D}, {0x1129F, 0x112A9},
+	{0x112B0, 0x112EA}, {0x112F0, 0x112F9}, {0x11300, 0x11303},
+	{0x11305, 0x1130C}, {0x1130F, 0x11310}, {0x11313, 0x11328},
+	{0x1132A, 0x11330}, {0x11332, 0x11333}, {0x11335, 0x11339},
+	{0x1133B, 0x11344}, {0x11347, 0x11348}, {0x1134B, 0x1134D},
+	{0x11350, 0x11350}, {0x11357, 0x11357}, {0x1135D, 0x11363},
+	{0x11366, 0x1136C}, {0x11370, 0x11374}, {0x11400, 0x1145B},
+	{0x1145D, 0x11461}, {0x11480, 0x114C7}, {0x114D0, 0x114D9},
+	{0x11580, 0x115B5}, {0x115B8, 0x115DD}, {0x11600, 0x11644},
+	{0x11650, 0x11659}, {0x11660, 0x1166C}, {0x11680, 0x116B9},
+	{0x116C0, 0x116C9}, {0x11700, 0x1171A}, {0x1171D, 0x1172B},
+	{0x11730, 0x11746}, {0x11800, 0x1183B}, {0x118A0, 0x118F2},
+	{0x118FF, 0x11906}, {0x11909, 0x11909}, {0x1190C, 0x11913},
+	{0x11915, 0x11916}, {0x11918, 0x11935}, {0x11937, 0x11938},
+	{0x1193B, 0x11946}, {0x11950, 0x11959}, {0x119A0, 0x119A7},
+	{0x119AA, 0x119D7}, {0x119DA, 0x119E4}, {0x11A00, 0x11A47},
+	{0x11A50, 0x11AA2}, {0x11AB0, 0x11AF8}, {0x11B00, 0x11B09},
 	{0x11C00, 0x11C08}, {0x11C0A, 0x11C36}, {0x11C38, 0x11C45},
 	{0x11C50, 0x11C6C}, {0x11C70, 0x11C8F}, {0x11C92, 0x11CA7},
 	{0x11CA9, 0x11CB6}, {0x11D00, 0x11D06}, {0x11D08, 0x11D09},
@@ -352,30 +357,36 @@ var neutral = table{
 	{0x11D3F, 0x11D47}, {0x11D50, 0x11D59}, {0x11D60, 0x11D65},
 	{0x11D67, 0x11D68}, {0x11D6A, 0x11D8E}, {0x11D90, 0x11D91},
 	{0x11D93, 0x11D98}, {0x11DA0, 0x11DA9}, {0x11EE0, 0x11EF8},
+	{0x11F00, 0x11F10}, {0x11F12, 0x11F3A}, {0x11F3E, 0x11F59},
 	{0x11FB0, 0x11FB0}, {0x11FC0, 0x11FF1}, {0x11FFF, 0x12399},
 	{0x12400, 0x1246E}, {0x12470, 0x12474}, {0x12480, 0x12543},
-	{0x13000, 0x1342E}, {0x13430, 0x13438}, {0x14400, 0x14646},
+	{0x12F90, 0x12FF2}, {0x13000, 0x13455}, {0x14400, 0x14646},
 	{0x16800, 0x16A38}, {0x16A40, 0x16A5E}, {0x16A60, 0x16A69},
-	{0x16A6E, 0x16A6F}, {0x16AD0, 0x16AED}, {0x16AF0, 0x16AF5},
-	{0x16B00, 0x16B45}, {0x16B50, 0x16B59}, {0x16B5B, 0x16B61},
-	{0x16B63, 0x16B77}, {0x16B7D, 0x16B8F}, {0x16E40, 0x16E9A},
-	{0x16F00, 0x16F4A}, {0x16F4F, 0x16F87}, {0x16F8F, 0x16F9F},
-	{0x1BC00, 0x1BC6A}, {0x1BC70, 0x1BC7C}, {0x1BC80, 0x1BC88},
-	{0x1BC90, 0x1BC99}, {0x1BC9C, 0x1BCA3}, {0x1D000, 0x1D0F5},
-	{0x1D100, 0x1D126}, {0x1D129, 0x1D1E8}, {0x1D200, 0x1D245},
-	{0x1D2E0, 0x1D2F3}, {0x1D300, 0x1D356}, {0x1D360, 0x1D378},
-	{0x1D400, 0x1D454}, {0x1D456, 0x1D49C}, {0x1D49E, 0x1D49F},
-	{0x1D4A2, 0x1D4A2}, {0x1D4A5, 0x1D4A6}, {0x1D4A9, 0x1D4AC},
-	{0x1D4AE, 0x1D4B9}, {0x1D4BB, 0x1D4BB}, {0x1D4BD, 0x1D4C3},
-	{0x1D4C5, 0x1D505}, {0x1D507, 0x1D50A}, {0x1D50D, 0x1D514},
-	{0x1D516, 0x1D51C}, {0x1D51E, 0x1D539}, {0x1D53B, 0x1D53E},
-	{0x1D540, 0x1D544}, {0x1D546, 0x1D546}, {0x1D54A, 0x1D550},
-	{0x1D552, 0x1D6A5}, {0x1D6A8, 0x1D7CB}, {0x1D7CE, 0x1DA8B},
-	{0x1DA9B, 0x1DA9F}, {0x1DAA1, 0x1DAAF}, {0x1E000, 0x1E006},
-	{0x1E008, 0x1E018}, {0x1E01B, 0x1E021}, {0x1E023, 0x1E024},
-	{0x1E026, 0x1E02A}, {0x1E100, 0x1E12C}, {0x1E130, 0x1E13D},
-	{0x1E140, 0x1E149}, {0x1E14E, 0x1E14F}, {0x1E2C0, 0x1E2F9},
-	{0x1E2FF, 0x1E2FF}, {0x1E800, 0x1E8C4}, {0x1E8C7, 0x1E8D6},
+	{0x16A6E, 0x16ABE}, {0x16AC0, 0x16AC9}, {0x16AD0, 0x16AED},
+	{0x16AF0, 0x16AF5}, {0x16B00, 0x16B45}, {0x16B50, 0x16B59},
+	{0x16B5B, 0x16B61}, {0x16B63, 0x16B77}, {0x16B7D, 0x16B8F},
+	{0x16E40, 0x16E9A}, {0x16F00, 0x16F4A}, {0x16F4F, 0x16F87},
+	{0x16F8F, 0x16F9F}, {0x1BC00, 0x1BC6A}, {0x1BC70, 0x1BC7C},
+	{0x1BC80, 0x1BC88}, {0x1BC90, 0x1BC99}, {0x1BC9C, 0x1BCA3},
+	{0x1CF00, 0x1CF2D}, {0x1CF30, 0x1CF46}, {0x1CF50, 0x1CFC3},
+	{0x1D000, 0x1D0F5}, {0x1D100, 0x1D126}, {0x1D129, 0x1D1EA},
+	{0x1D200, 0x1D245}, {0x1D2C0, 0x1D2D3}, {0x1D2E0, 0x1D2F3},
+	{0x1D300, 0x1D356}, {0x1D360, 0x1D378}, {0x1D400, 0x1D454},
+	{0x1D456, 0x1D49C}, {0x1D49E, 0x1D49F}, {0x1D4A2, 0x1D4A2},
+	{0x1D4A5, 0x1D4A6}, {0x1D4A9, 0x1D4AC}, {0x1D4AE, 0x1D4B9},
+	{0x1D4BB, 0x1D4BB}, {0x1D4BD, 0x1D4C3}, {0x1D4C5, 0x1D505},
+	{0x1D507, 0x1D50A}, {0x1D50D, 0x1D514}, {0x1D516, 0x1D51C},
+	{0x1D51E, 0x1D539}, {0x1D53B, 0x1D53E}, {0x1D540, 0x1D544},
+	{0x1D546, 0x1D546}, {0x1D54A, 0x1D550}, {0x1D552, 0x1D6A5},
+	{0x1D6A8, 0x1D7CB}, {0x1D7CE, 0x1DA8B}, {0x1DA9B, 0x1DA9F},
+	{0x1DAA1, 0x1DAAF}, {0x1DF00, 0x1DF1E}, {0x1DF25, 0x1DF2A},
+	{0x1E000, 0x1E006}, {0x1E008, 0x1E018}, {0x1E01B, 0x1E021},
+	{0x1E023, 0x1E024}, {0x1E026, 0x1E02A}, {0x1E030, 0x1E06D},
+	{0x1E08F, 0x1E08F}, {0x1E100, 0x1E12C}, {0x1E130, 0x1E13D},
+	{0x1E140, 0x1E149}, {0x1E14E, 0x1E14F}, {0x1E290, 0x1E2AE},
+	{0x1E2C0, 0x1E2F9}, {0x1E2FF, 0x1E2FF}, {0x1E4D0, 0x1E4F9},
+	{0x1E7E0, 0x1E7E6}, {0x1E7E8, 0x1E7EB}, {0x1E7ED, 0x1E7EE},
+	{0x1E7F0, 0x1E7FE}, {0x1E800, 0x1E8C4}, {0x1E8C7, 0x1E8D6},
 	{0x1E900, 0x1E94B}, {0x1E950, 0x1E959}, {0x1E95E, 0x1E95F},
 	{0x1EC71, 0x1ECB4}, {0x1ED01, 0x1ED3D}, {0x1EE00, 0x1EE03},
 	{0x1EE05, 0x1EE1F}, {0x1EE21, 0x1EE22}, {0x1EE24, 0x1EE24},
@@ -400,8 +411,8 @@ var neutral = table{
 	{0x1F54F, 0x1F54F}, {0x1F568, 0x1F579}, {0x1F57B, 0x1F594},
 	{0x1F597, 0x1F5A3}, {0x1F5A5, 0x1F5FA}, {0x1F650, 0x1F67F},
 	{0x1F6C6, 0x1F6CB}, {0x1F6CD, 0x1F6CF}, {0x1F6D3, 0x1F6D4},
-	{0x1F6E0, 0x1F6EA}, {0x1F6F0, 0x1F6F3}, {0x1F700, 0x1F773},
-	{0x1F780, 0x1F7D8}, {0x1F800, 0x1F80B}, {0x1F810, 0x1F847},
+	{0x1F6E0, 0x1F6EA}, {0x1F6F0, 0x1F6F3}, {0x1F700, 0x1F776},
+	{0x1F77B, 0x1F7D9}, {0x1F800, 0x1F80B}, {0x1F810, 0x1F847},
 	{0x1F850, 0x1F859}, {0x1F860, 0x1F887}, {0x1F890, 0x1F8AD},
 	{0x1F8B0, 0x1F8B1}, {0x1F900, 0x1F90B}, {0x1F93B, 0x1F93B},
 	{0x1F946, 0x1F946}, {0x1FA00, 0x1FA53}, {0x1FA60, 0x1FA6D},
diff --git a/vendor/github.com/opencontainers/runc/NOTICE b/vendor/github.com/opencontainers/runc/NOTICE
index 5c97abce4..c29775c0d 100644
--- a/vendor/github.com/opencontainers/runc/NOTICE
+++ b/vendor/github.com/opencontainers/runc/NOTICE
@@ -8,9 +8,9 @@ The following is courtesy of our legal counsel:
 
 
 Use and transfer of Docker may be subject to certain restrictions by the
-United States and other governments.  
+United States and other governments.
 It is your responsibility to ensure that your use and/or transfer does not
-violate applicable laws. 
+violate applicable laws.
 
 For more information, please see http://www.bis.doc.gov
 
diff --git a/vendor/github.com/opencontainers/runc/libcontainer/apparmor/apparmor_linux.go b/vendor/github.com/opencontainers/runc/libcontainer/apparmor/apparmor_linux.go
index 8b1483c7d..17d36ed15 100644
--- a/vendor/github.com/opencontainers/runc/libcontainer/apparmor/apparmor_linux.go
+++ b/vendor/github.com/opencontainers/runc/libcontainer/apparmor/apparmor_linux.go
@@ -26,14 +26,19 @@ func isEnabled() bool {
 }
 
 func setProcAttr(attr, value string) error {
-	// Under AppArmor you can only change your own attr, so use /proc/self/
-	// instead of /proc/<tid>/ like libapparmor does
-	attrPath := "/proc/self/attr/apparmor/" + attr
-	if _, err := os.Stat(attrPath); errors.Is(err, os.ErrNotExist) {
+	attr = utils.CleanPath(attr)
+	attrSubPath := "attr/apparmor/" + attr
+	if _, err := os.Stat("/proc/self/" + attrSubPath); errors.Is(err, os.ErrNotExist) {
 		// fall back to the old convention
-		attrPath = "/proc/self/attr/" + attr
+		attrSubPath = "attr/" + attr
 	}
 
+	// Under AppArmor you can only change your own attr, so there's no reason
+	// to not use /proc/thread-self/ (instead of /proc/<tid>/, like libapparmor
+	// does).
+	attrPath, closer := utils.ProcThreadSelf(attrSubPath)
+	defer closer()
+
 	f, err := os.OpenFile(attrPath, os.O_WRONLY, 0)
 	if err != nil {
 		return err
diff --git a/vendor/github.com/opencontainers/runc/libcontainer/apparmor/apparmor_unsupported.go b/vendor/github.com/opencontainers/runc/libcontainer/apparmor/apparmor_unsupported.go
index 684248f25..4484cd239 100644
--- a/vendor/github.com/opencontainers/runc/libcontainer/apparmor/apparmor_unsupported.go
+++ b/vendor/github.com/opencontainers/runc/libcontainer/apparmor/apparmor_unsupported.go
@@ -1,5 +1,4 @@
 //go:build !linux
-// +build !linux
 
 package apparmor
 
diff --git a/vendor/github.com/opencontainers/runc/libcontainer/cgroups/cgroups.go b/vendor/github.com/opencontainers/runc/libcontainer/cgroups/cgroups.go
index ba2b2266c..811f2d26e 100644
--- a/vendor/github.com/opencontainers/runc/libcontainer/cgroups/cgroups.go
+++ b/vendor/github.com/opencontainers/runc/libcontainer/cgroups/cgroups.go
@@ -1,9 +1,25 @@
 package cgroups
 
 import (
+	"errors"
+
 	"github.com/opencontainers/runc/libcontainer/configs"
 )
 
+var (
+	// ErrDevicesUnsupported is an error returned when a cgroup manager
+	// is not configured to set device rules.
+	ErrDevicesUnsupported = errors.New("cgroup manager is not configured to set device rules")
+
+	// DevicesSetV1 and DevicesSetV2 are functions to set devices for
+	// cgroup v1 and v2, respectively. Unless
+	// [github.com/opencontainers/runc/libcontainer/cgroups/devices]
+	// package is imported, it is set to nil, so cgroup managers can't
+	// manage devices.
+	DevicesSetV1 func(path string, r *configs.Resources) error
+	DevicesSetV2 func(path string, r *configs.Resources) error
+)
+
 type Manager interface {
 	// Apply creates a cgroup, if not yet created, and adds a process
 	// with the specified pid into that cgroup.  A special value of -1
diff --git a/vendor/github.com/opencontainers/runc/libcontainer/cgroups/devices/devices_emulator.go b/vendor/github.com/opencontainers/runc/libcontainer/cgroups/devices/devices_emulator.go
deleted file mode 100644
index 6c61ee4c0..000000000
--- a/vendor/github.com/opencontainers/runc/libcontainer/cgroups/devices/devices_emulator.go
+++ /dev/null
@@ -1,386 +0,0 @@
-// SPDX-License-Identifier: Apache-2.0
-/*
- * Copyright (C) 2020 Aleksa Sarai <cyphar@cyphar.com>
- * Copyright (C) 2020 SUSE LLC
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package devices
-
-import (
-	"bufio"
-	"fmt"
-	"io"
-	"sort"
-	"strconv"
-	"strings"
-
-	"github.com/opencontainers/runc/libcontainer/devices"
-)
-
-// deviceMeta is a Rule without the Allow or Permissions fields, and no
-// wildcard-type support. It's effectively the "match" portion of a metadata
-// rule, for the purposes of our emulation.
-type deviceMeta struct {
-	node  devices.Type
-	major int64
-	minor int64
-}
-
-// deviceRule is effectively the tuple (deviceMeta, Permissions).
-type deviceRule struct {
-	meta  deviceMeta
-	perms devices.Permissions
-}
-
-// deviceRules is a mapping of device metadata rules to the associated
-// permissions in the ruleset.
-type deviceRules map[deviceMeta]devices.Permissions
-
-func (r deviceRules) orderedEntries() []deviceRule {
-	var rules []deviceRule
-	for meta, perms := range r {
-		rules = append(rules, deviceRule{meta: meta, perms: perms})
-	}
-	sort.Slice(rules, func(i, j int) bool {
-		// Sort by (major, minor, type).
-		a, b := rules[i].meta, rules[j].meta
-		return a.major < b.major ||
-			(a.major == b.major && a.minor < b.minor) ||
-			(a.major == b.major && a.minor == b.minor && a.node < b.node)
-	})
-	return rules
-}
-
-type Emulator struct {
-	defaultAllow bool
-	rules        deviceRules
-}
-
-func (e *Emulator) IsBlacklist() bool {
-	return e.defaultAllow
-}
-
-func (e *Emulator) IsAllowAll() bool {
-	return e.IsBlacklist() && len(e.rules) == 0
-}
-
-func parseLine(line string) (*deviceRule, error) {
-	// Input: node major:minor perms.
-	fields := strings.FieldsFunc(line, func(r rune) bool {
-		return r == ' ' || r == ':'
-	})
-	if len(fields) != 4 {
-		return nil, fmt.Errorf("malformed devices.list rule %s", line)
-	}
-
-	var (
-		rule  deviceRule
-		node  = fields[0]
-		major = fields[1]
-		minor = fields[2]
-		perms = fields[3]
-	)
-
-	// Parse the node type.
-	switch node {
-	case "a":
-		// Super-special case -- "a" always means every device with every
-		// access mode. In fact, for devices.list this actually indicates that
-		// the cgroup is in black-list mode.
-		// TODO: Double-check that the entire file is "a *:* rwm".
-		return nil, nil
-	case "b":
-		rule.meta.node = devices.BlockDevice
-	case "c":
-		rule.meta.node = devices.CharDevice
-	default:
-		return nil, fmt.Errorf("unknown device type %q", node)
-	}
-
-	// Parse the major number.
-	if major == "*" {
-		rule.meta.major = devices.Wildcard
-	} else {
-		val, err := strconv.ParseUint(major, 10, 32)
-		if err != nil {
-			return nil, fmt.Errorf("invalid major number: %w", err)
-		}
-		rule.meta.major = int64(val)
-	}
-
-	// Parse the minor number.
-	if minor == "*" {
-		rule.meta.minor = devices.Wildcard
-	} else {
-		val, err := strconv.ParseUint(minor, 10, 32)
-		if err != nil {
-			return nil, fmt.Errorf("invalid minor number: %w", err)
-		}
-		rule.meta.minor = int64(val)
-	}
-
-	// Parse the access permissions.
-	rule.perms = devices.Permissions(perms)
-	if !rule.perms.IsValid() || rule.perms.IsEmpty() {
-		return nil, fmt.Errorf("parse access mode: contained unknown modes or is empty: %q", perms)
-	}
-	return &rule, nil
-}
-
-func (e *Emulator) addRule(rule deviceRule) error { //nolint:unparam
-	if e.rules == nil {
-		e.rules = make(map[deviceMeta]devices.Permissions)
-	}
-
-	// Merge with any pre-existing permissions.
-	oldPerms := e.rules[rule.meta]
-	newPerms := rule.perms.Union(oldPerms)
-	e.rules[rule.meta] = newPerms
-	return nil
-}
-
-func (e *Emulator) rmRule(rule deviceRule) error {
-	// Give an error if any of the permissions requested to be removed are
-	// present in a partially-matching wildcard rule, because such rules will
-	// be ignored by cgroupv1.
-	//
-	// This is a diversion from cgroupv1, but is necessary to avoid leading
-	// users into a false sense of security. cgroupv1 will silently(!) ignore
-	// requests to remove partial exceptions, but we really shouldn't do that.
-	//
-	// It may seem like we could just "split" wildcard rules which hit this
-	// issue, but unfortunately there are 2^32 possible major and minor
-	// numbers, which would exhaust kernel memory quickly if we did this. Not
-	// to mention it'd be really slow (the kernel side is implemented as a
-	// linked-list of exceptions).
-	for _, partialMeta := range []deviceMeta{
-		{node: rule.meta.node, major: devices.Wildcard, minor: rule.meta.minor},
-		{node: rule.meta.node, major: rule.meta.major, minor: devices.Wildcard},
-		{node: rule.meta.node, major: devices.Wildcard, minor: devices.Wildcard},
-	} {
-		// This wildcard rule is equivalent to the requested rule, so skip it.
-		if rule.meta == partialMeta {
-			continue
-		}
-		// Only give an error if the set of permissions overlap.
-		partialPerms := e.rules[partialMeta]
-		if !partialPerms.Intersection(rule.perms).IsEmpty() {
-			return fmt.Errorf("requested rule [%v %v] not supported by devices cgroupv1 (cannot punch hole in existing wildcard rule [%v %v])", rule.meta, rule.perms, partialMeta, partialPerms)
-		}
-	}
-
-	// Subtract all of the permissions listed from the full match rule. If the
-	// rule didn't exist, all of this is a no-op.
-	newPerms := e.rules[rule.meta].Difference(rule.perms)
-	if newPerms.IsEmpty() {
-		delete(e.rules, rule.meta)
-	} else {
-		e.rules[rule.meta] = newPerms
-	}
-	// TODO: The actual cgroup code doesn't care if an exception didn't exist
-	//       during removal, so not erroring out here is /accurate/ but quite
-	//       worrying. Maybe we should do additional validation, but again we
-	//       have to worry about backwards-compatibility.
-	return nil
-}
-
-func (e *Emulator) allow(rule *deviceRule) error {
-	// This cgroup is configured as a black-list. Reset the entire emulator,
-	// and put is into black-list mode.
-	if rule == nil || rule.meta.node == devices.WildcardDevice {
-		*e = Emulator{
-			defaultAllow: true,
-			rules:        nil,
-		}
-		return nil
-	}
-
-	var err error
-	if e.defaultAllow {
-		err = wrapErr(e.rmRule(*rule), "unable to remove 'deny' exception")
-	} else {
-		err = wrapErr(e.addRule(*rule), "unable to add 'allow' exception")
-	}
-	return err
-}
-
-func (e *Emulator) deny(rule *deviceRule) error {
-	// This cgroup is configured as a white-list. Reset the entire emulator,
-	// and put is into white-list mode.
-	if rule == nil || rule.meta.node == devices.WildcardDevice {
-		*e = Emulator{
-			defaultAllow: false,
-			rules:        nil,
-		}
-		return nil
-	}
-
-	var err error
-	if e.defaultAllow {
-		err = wrapErr(e.addRule(*rule), "unable to add 'deny' exception")
-	} else {
-		err = wrapErr(e.rmRule(*rule), "unable to remove 'allow' exception")
-	}
-	return err
-}
-
-func (e *Emulator) Apply(rule devices.Rule) error {
-	if !rule.Type.CanCgroup() {
-		return fmt.Errorf("cannot add rule [%#v] with non-cgroup type %q", rule, rule.Type)
-	}
-
-	innerRule := &deviceRule{
-		meta: deviceMeta{
-			node:  rule.Type,
-			major: rule.Major,
-			minor: rule.Minor,
-		},
-		perms: rule.Permissions,
-	}
-	if innerRule.meta.node == devices.WildcardDevice {
-		innerRule = nil
-	}
-
-	if rule.Allow {
-		return e.allow(innerRule)
-	}
-
-	return e.deny(innerRule)
-}
-
-// EmulatorFromList takes a reader to a "devices.list"-like source, and returns
-// a new Emulator that represents the state of the devices cgroup. Note that
-// black-list devices cgroups cannot be fully reconstructed, due to limitations
-// in the devices cgroup API. Instead, such cgroups are always treated as
-// "allow all" cgroups.
-func EmulatorFromList(list io.Reader) (*Emulator, error) {
-	// Normally cgroups are in black-list mode by default, but the way we
-	// figure out the current mode is whether or not devices.list has an
-	// allow-all rule. So we default to a white-list, and the existence of an
-	// "a *:* rwm" entry will tell us otherwise.
-	e := &Emulator{
-		defaultAllow: false,
-	}
-
-	// Parse the "devices.list".
-	s := bufio.NewScanner(list)
-	for s.Scan() {
-		line := s.Text()
-		deviceRule, err := parseLine(line)
-		if err != nil {
-			return nil, fmt.Errorf("error parsing line %q: %w", line, err)
-		}
-		// "devices.list" is an allow list. Note that this means that in
-		// black-list mode, we have no idea what rules are in play. As a
-		// result, we need to be very careful in Transition().
-		if err := e.allow(deviceRule); err != nil {
-			return nil, fmt.Errorf("error adding devices.list rule: %w", err)
-		}
-	}
-	if err := s.Err(); err != nil {
-		return nil, fmt.Errorf("error reading devices.list lines: %w", err)
-	}
-	return e, nil
-}
-
-// Transition calculates what is the minimally-disruptive set of rules need to
-// be applied to a devices cgroup in order to transition to the given target.
-// This means that any already-existing rules will not be applied, and
-// disruptive rules (like denying all device access) will only be applied if
-// necessary.
-//
-// This function is the sole reason for all of Emulator -- to allow us
-// to figure out how to update a containers' cgroups without causing spurious
-// device errors (if possible).
-func (source *Emulator) Transition(target *Emulator) ([]*devices.Rule, error) {
-	var transitionRules []*devices.Rule
-	oldRules := source.rules
-
-	// If the default policy doesn't match, we need to include a "disruptive"
-	// rule (either allow-all or deny-all) in order to switch the cgroup to the
-	// correct default policy.
-	//
-	// However, due to a limitation in "devices.list" we cannot be sure what
-	// deny rules are in place in a black-list cgroup. Thus if the source is a
-	// black-list we also have to include a disruptive rule.
-	if source.IsBlacklist() || source.defaultAllow != target.defaultAllow {
-		transitionRules = append(transitionRules, &devices.Rule{
-			Type:        'a',
-			Major:       -1,
-			Minor:       -1,
-			Permissions: devices.Permissions("rwm"),
-			Allow:       target.defaultAllow,
-		})
-		// The old rules are only relevant if we aren't starting out with a
-		// disruptive rule.
-		oldRules = nil
-	}
-
-	// NOTE: We traverse through the rules in a sorted order so we always write
-	//       the same set of rules (this is to aid testing).
-
-	// First, we create inverse rules for any old rules not in the new set.
-	// This includes partial-inverse rules for specific permissions. This is a
-	// no-op if we added a disruptive rule, since oldRules will be empty.
-	for _, rule := range oldRules.orderedEntries() {
-		meta, oldPerms := rule.meta, rule.perms
-		newPerms := target.rules[meta]
-		droppedPerms := oldPerms.Difference(newPerms)
-		if !droppedPerms.IsEmpty() {
-			transitionRules = append(transitionRules, &devices.Rule{
-				Type:        meta.node,
-				Major:       meta.major,
-				Minor:       meta.minor,
-				Permissions: droppedPerms,
-				Allow:       target.defaultAllow,
-			})
-		}
-	}
-
-	// Add any additional rules which weren't in the old set. We happen to
-	// filter out rules which are present in both sets, though this isn't
-	// strictly necessary.
-	for _, rule := range target.rules.orderedEntries() {
-		meta, newPerms := rule.meta, rule.perms
-		oldPerms := oldRules[meta]
-		gainedPerms := newPerms.Difference(oldPerms)
-		if !gainedPerms.IsEmpty() {
-			transitionRules = append(transitionRules, &devices.Rule{
-				Type:        meta.node,
-				Major:       meta.major,
-				Minor:       meta.minor,
-				Permissions: gainedPerms,
-				Allow:       !target.defaultAllow,
-			})
-		}
-	}
-	return transitionRules, nil
-}
-
-// Rules returns the minimum set of rules necessary to convert a *deny-all*
-// cgroup to the emulated filter state (note that this is not the same as a
-// default cgroupv1 cgroup -- which is allow-all). This is effectively just a
-// wrapper around Transition() with the source emulator being an empty cgroup.
-func (e *Emulator) Rules() ([]*devices.Rule, error) {
-	defaultCgroup := &Emulator{defaultAllow: false}
-	return defaultCgroup.Transition(e)
-}
-
-func wrapErr(err error, text string) error {
-	if err == nil {
-		return nil
-	}
-	return fmt.Errorf(text+": %w", err)
-}
diff --git a/vendor/github.com/opencontainers/runc/libcontainer/cgroups/ebpf/devicefilter/devicefilter.go b/vendor/github.com/opencontainers/runc/libcontainer/cgroups/ebpf/devicefilter/devicefilter.go
deleted file mode 100644
index 4e69b35bc..000000000
--- a/vendor/github.com/opencontainers/runc/libcontainer/cgroups/ebpf/devicefilter/devicefilter.go
+++ /dev/null
@@ -1,208 +0,0 @@
-// Package devicefilter contains eBPF device filter program
-//
-// The implementation is based on https://github.com/containers/crun/blob/0.10.2/src/libcrun/ebpf.c
-//
-// Although ebpf.c is originally licensed under LGPL-3.0-or-later, the author (Giuseppe Scrivano)
-// agreed to relicense the file in Apache License 2.0: https://github.com/opencontainers/runc/issues/2144#issuecomment-543116397
-package devicefilter
-
-import (
-	"errors"
-	"fmt"
-	"math"
-	"strconv"
-
-	"github.com/cilium/ebpf/asm"
-	devicesemulator "github.com/opencontainers/runc/libcontainer/cgroups/devices"
-	"github.com/opencontainers/runc/libcontainer/devices"
-	"golang.org/x/sys/unix"
-)
-
-const (
-	// license string format is same as kernel MODULE_LICENSE macro
-	license = "Apache"
-)
-
-// DeviceFilter returns eBPF device filter program and its license string
-func DeviceFilter(rules []*devices.Rule) (asm.Instructions, string, error) {
-	// Generate the minimum ruleset for the device rules we are given. While we
-	// don't care about minimum transitions in cgroupv2, using the emulator
-	// gives us a guarantee that the behaviour of devices filtering is the same
-	// as cgroupv1, including security hardenings to avoid misconfiguration
-	// (such as punching holes in wildcard rules).
-	emu := new(devicesemulator.Emulator)
-	for _, rule := range rules {
-		if err := emu.Apply(*rule); err != nil {
-			return nil, "", err
-		}
-	}
-	cleanRules, err := emu.Rules()
-	if err != nil {
-		return nil, "", err
-	}
-
-	p := &program{
-		defaultAllow: emu.IsBlacklist(),
-	}
-	p.init()
-
-	for idx, rule := range cleanRules {
-		if rule.Type == devices.WildcardDevice {
-			// We can safely skip over wildcard entries because there should
-			// only be one (at most) at the very start to instruct cgroupv1 to
-			// go into allow-list mode. However we do double-check this here.
-			if idx != 0 || rule.Allow != emu.IsBlacklist() {
-				return nil, "", fmt.Errorf("[internal error] emulated cgroupv2 devices ruleset had bad wildcard at idx %v (%s)", idx, rule.CgroupString())
-			}
-			continue
-		}
-		if rule.Allow == p.defaultAllow {
-			// There should be no rules which have an action equal to the
-			// default action, the emulator removes those.
-			return nil, "", fmt.Errorf("[internal error] emulated cgroupv2 devices ruleset had no-op rule at idx %v (%s)", idx, rule.CgroupString())
-		}
-		if err := p.appendRule(rule); err != nil {
-			return nil, "", err
-		}
-	}
-	return p.finalize(), license, nil
-}
-
-type program struct {
-	insts        asm.Instructions
-	defaultAllow bool
-	blockID      int
-}
-
-func (p *program) init() {
-	// struct bpf_cgroup_dev_ctx: https://elixir.bootlin.com/linux/v5.3.6/source/include/uapi/linux/bpf.h#L3423
-	/*
-		u32 access_type
-		u32 major
-		u32 minor
-	*/
-	// R2 <- type (lower 16 bit of u32 access_type at R1[0])
-	p.insts = append(p.insts,
-		asm.LoadMem(asm.R2, asm.R1, 0, asm.Word),
-		asm.And.Imm32(asm.R2, 0xFFFF))
-
-	// R3 <- access (upper 16 bit of u32 access_type at R1[0])
-	p.insts = append(p.insts,
-		asm.LoadMem(asm.R3, asm.R1, 0, asm.Word),
-		// RSh: bitwise shift right
-		asm.RSh.Imm32(asm.R3, 16))
-
-	// R4 <- major (u32 major at R1[4])
-	p.insts = append(p.insts,
-		asm.LoadMem(asm.R4, asm.R1, 4, asm.Word))
-
-	// R5 <- minor (u32 minor at R1[8])
-	p.insts = append(p.insts,
-		asm.LoadMem(asm.R5, asm.R1, 8, asm.Word))
-}
-
-// appendRule rule converts an OCI rule to the relevant eBPF block and adds it
-// to the in-progress filter program. In order to operate properly, it must be
-// called with a "clean" rule list (generated by devices.Emulator.Rules() --
-// with any "a" rules removed).
-func (p *program) appendRule(rule *devices.Rule) error {
-	if p.blockID < 0 {
-		return errors.New("the program is finalized")
-	}
-
-	var bpfType int32
-	switch rule.Type {
-	case devices.CharDevice:
-		bpfType = int32(unix.BPF_DEVCG_DEV_CHAR)
-	case devices.BlockDevice:
-		bpfType = int32(unix.BPF_DEVCG_DEV_BLOCK)
-	default:
-		// We do not permit 'a', nor any other types we don't know about.
-		return fmt.Errorf("invalid type %q", string(rule.Type))
-	}
-	if rule.Major > math.MaxUint32 {
-		return fmt.Errorf("invalid major %d", rule.Major)
-	}
-	if rule.Minor > math.MaxUint32 {
-		return fmt.Errorf("invalid minor %d", rule.Major)
-	}
-	hasMajor := rule.Major >= 0 // if not specified in OCI json, major is set to -1
-	hasMinor := rule.Minor >= 0
-	bpfAccess := int32(0)
-	for _, r := range rule.Permissions {
-		switch r {
-		case 'r':
-			bpfAccess |= unix.BPF_DEVCG_ACC_READ
-		case 'w':
-			bpfAccess |= unix.BPF_DEVCG_ACC_WRITE
-		case 'm':
-			bpfAccess |= unix.BPF_DEVCG_ACC_MKNOD
-		default:
-			return fmt.Errorf("unknown device access %v", r)
-		}
-	}
-	// If the access is rwm, skip the check.
-	hasAccess := bpfAccess != (unix.BPF_DEVCG_ACC_READ | unix.BPF_DEVCG_ACC_WRITE | unix.BPF_DEVCG_ACC_MKNOD)
-
-	var (
-		blockSym         = "block-" + strconv.Itoa(p.blockID)
-		nextBlockSym     = "block-" + strconv.Itoa(p.blockID+1)
-		prevBlockLastIdx = len(p.insts) - 1
-	)
-	p.insts = append(p.insts,
-		// if (R2 != bpfType) goto next
-		asm.JNE.Imm(asm.R2, bpfType, nextBlockSym),
-	)
-	if hasAccess {
-		p.insts = append(p.insts,
-			// if (R3 & bpfAccess != R3 /* use R1 as a temp var */) goto next
-			asm.Mov.Reg32(asm.R1, asm.R3),
-			asm.And.Imm32(asm.R1, bpfAccess),
-			asm.JNE.Reg(asm.R1, asm.R3, nextBlockSym),
-		)
-	}
-	if hasMajor {
-		p.insts = append(p.insts,
-			// if (R4 != major) goto next
-			asm.JNE.Imm(asm.R4, int32(rule.Major), nextBlockSym),
-		)
-	}
-	if hasMinor {
-		p.insts = append(p.insts,
-			// if (R5 != minor) goto next
-			asm.JNE.Imm(asm.R5, int32(rule.Minor), nextBlockSym),
-		)
-	}
-	p.insts = append(p.insts, acceptBlock(rule.Allow)...)
-	// set blockSym to the first instruction we added in this iteration
-	p.insts[prevBlockLastIdx+1] = p.insts[prevBlockLastIdx+1].Sym(blockSym)
-	p.blockID++
-	return nil
-}
-
-func (p *program) finalize() asm.Instructions {
-	var v int32
-	if p.defaultAllow {
-		v = 1
-	}
-	blockSym := "block-" + strconv.Itoa(p.blockID)
-	p.insts = append(p.insts,
-		// R0 <- v
-		asm.Mov.Imm32(asm.R0, v).Sym(blockSym),
-		asm.Return(),
-	)
-	p.blockID = -1
-	return p.insts
-}
-
-func acceptBlock(accept bool) asm.Instructions {
-	var v int32
-	if accept {
-		v = 1
-	}
-	return []asm.Instruction{
-		// R0 <- v
-		asm.Mov.Imm32(asm.R0, v),
-		asm.Return(),
-	}
-}
diff --git a/vendor/github.com/opencontainers/runc/libcontainer/cgroups/ebpf/ebpf_linux.go b/vendor/github.com/opencontainers/runc/libcontainer/cgroups/ebpf/ebpf_linux.go
deleted file mode 100644
index 35b00aaf0..000000000
--- a/vendor/github.com/opencontainers/runc/libcontainer/cgroups/ebpf/ebpf_linux.go
+++ /dev/null
@@ -1,253 +0,0 @@
-package ebpf
-
-import (
-	"errors"
-	"fmt"
-	"os"
-	"runtime"
-	"sync"
-	"unsafe"
-
-	"github.com/cilium/ebpf"
-	"github.com/cilium/ebpf/asm"
-	"github.com/cilium/ebpf/link"
-	"github.com/sirupsen/logrus"
-	"golang.org/x/sys/unix"
-)
-
-func nilCloser() error {
-	return nil
-}
-
-func findAttachedCgroupDeviceFilters(dirFd int) ([]*ebpf.Program, error) {
-	type bpfAttrQuery struct {
-		TargetFd    uint32
-		AttachType  uint32
-		QueryType   uint32
-		AttachFlags uint32
-		ProgIds     uint64 // __aligned_u64
-		ProgCnt     uint32
-	}
-
-	// Currently you can only have 64 eBPF programs attached to a cgroup.
-	size := 64
-	retries := 0
-	for retries < 10 {
-		progIds := make([]uint32, size)
-		query := bpfAttrQuery{
-			TargetFd:   uint32(dirFd),
-			AttachType: uint32(unix.BPF_CGROUP_DEVICE),
-			ProgIds:    uint64(uintptr(unsafe.Pointer(&progIds[0]))),
-			ProgCnt:    uint32(len(progIds)),
-		}
-
-		// Fetch the list of program ids.
-		_, _, errno := unix.Syscall(unix.SYS_BPF,
-			uintptr(unix.BPF_PROG_QUERY),
-			uintptr(unsafe.Pointer(&query)),
-			unsafe.Sizeof(query))
-		size = int(query.ProgCnt)
-		runtime.KeepAlive(query)
-		if errno != 0 {
-			// On ENOSPC we get the correct number of programs.
-			if errno == unix.ENOSPC {
-				retries++
-				continue
-			}
-			return nil, fmt.Errorf("bpf_prog_query(BPF_CGROUP_DEVICE) failed: %w", errno)
-		}
-
-		// Convert the ids to program handles.
-		progIds = progIds[:size]
-		programs := make([]*ebpf.Program, 0, len(progIds))
-		for _, progId := range progIds {
-			program, err := ebpf.NewProgramFromID(ebpf.ProgramID(progId))
-			if err != nil {
-				// We skip over programs that give us -EACCES or -EPERM. This
-				// is necessary because there may be BPF programs that have
-				// been attached (such as with --systemd-cgroup) which have an
-				// LSM label that blocks us from interacting with the program.
-				//
-				// Because additional BPF_CGROUP_DEVICE programs only can add
-				// restrictions, there's no real issue with just ignoring these
-				// programs (and stops runc from breaking on distributions with
-				// very strict SELinux policies).
-				if errors.Is(err, os.ErrPermission) {
-					logrus.Debugf("ignoring existing CGROUP_DEVICE program (prog_id=%v) which cannot be accessed by runc -- likely due to LSM policy: %v", progId, err)
-					continue
-				}
-				return nil, fmt.Errorf("cannot fetch program from id: %w", err)
-			}
-			programs = append(programs, program)
-		}
-		runtime.KeepAlive(progIds)
-		return programs, nil
-	}
-
-	return nil, errors.New("could not get complete list of CGROUP_DEVICE programs")
-}
-
-var (
-	haveBpfProgReplaceBool bool
-	haveBpfProgReplaceOnce sync.Once
-)
-
-// Loosely based on the BPF_F_REPLACE support check in
-// https://github.com/cilium/ebpf/blob/v0.6.0/link/syscalls.go.
-//
-// TODO: move this logic to cilium/ebpf
-func haveBpfProgReplace() bool {
-	haveBpfProgReplaceOnce.Do(func() {
-		prog, err := ebpf.NewProgram(&ebpf.ProgramSpec{
-			Type:    ebpf.CGroupDevice,
-			License: "MIT",
-			Instructions: asm.Instructions{
-				asm.Mov.Imm(asm.R0, 0),
-				asm.Return(),
-			},
-		})
-		if err != nil {
-			logrus.Debugf("checking for BPF_F_REPLACE support: ebpf.NewProgram failed: %v", err)
-			return
-		}
-		defer prog.Close()
-
-		devnull, err := os.Open("/dev/null")
-		if err != nil {
-			logrus.Debugf("checking for BPF_F_REPLACE support: open dummy target fd: %v", err)
-			return
-		}
-		defer devnull.Close()
-
-		// We know that we have BPF_PROG_ATTACH since we can load
-		// BPF_CGROUP_DEVICE programs. If passing BPF_F_REPLACE gives us EINVAL
-		// we know that the feature isn't present.
-		err = link.RawAttachProgram(link.RawAttachProgramOptions{
-			// We rely on this fd being checked after attachFlags.
-			Target: int(devnull.Fd()),
-			// Attempt to "replace" bad fds with this program.
-			Program: prog,
-			Attach:  ebpf.AttachCGroupDevice,
-			Flags:   unix.BPF_F_ALLOW_MULTI | unix.BPF_F_REPLACE,
-		})
-		if errors.Is(err, unix.EINVAL) {
-			// not supported
-			return
-		}
-		// attach_flags test succeeded.
-		if !errors.Is(err, unix.EBADF) {
-			logrus.Debugf("checking for BPF_F_REPLACE: got unexpected (not EBADF or EINVAL) error: %v", err)
-		}
-		haveBpfProgReplaceBool = true
-	})
-	return haveBpfProgReplaceBool
-}
-
-// LoadAttachCgroupDeviceFilter installs eBPF device filter program to /sys/fs/cgroup/<foo> directory.
-//
-// Requires the system to be running in cgroup2 unified-mode with kernel >= 4.15 .
-//
-// https://github.com/torvalds/linux/commit/ebc614f687369f9df99828572b1d85a7c2de3d92
-func LoadAttachCgroupDeviceFilter(insts asm.Instructions, license string, dirFd int) (func() error, error) {
-	// Increase `ulimit -l` limit to avoid BPF_PROG_LOAD error (#2167).
-	// This limit is not inherited into the container.
-	memlockLimit := &unix.Rlimit{
-		Cur: unix.RLIM_INFINITY,
-		Max: unix.RLIM_INFINITY,
-	}
-	_ = unix.Setrlimit(unix.RLIMIT_MEMLOCK, memlockLimit)
-
-	// Get the list of existing programs.
-	oldProgs, err := findAttachedCgroupDeviceFilters(dirFd)
-	if err != nil {
-		return nilCloser, err
-	}
-	useReplaceProg := haveBpfProgReplace() && len(oldProgs) == 1
-
-	// Generate new program.
-	spec := &ebpf.ProgramSpec{
-		Type:         ebpf.CGroupDevice,
-		Instructions: insts,
-		License:      license,
-	}
-	prog, err := ebpf.NewProgram(spec)
-	if err != nil {
-		return nilCloser, err
-	}
-
-	// If there is only one old program, we can just replace it directly.
-	var (
-		replaceProg *ebpf.Program
-		attachFlags uint32 = unix.BPF_F_ALLOW_MULTI
-	)
-	if useReplaceProg {
-		replaceProg = oldProgs[0]
-		attachFlags |= unix.BPF_F_REPLACE
-	}
-	err = link.RawAttachProgram(link.RawAttachProgramOptions{
-		Target:  dirFd,
-		Program: prog,
-		Replace: replaceProg,
-		Attach:  ebpf.AttachCGroupDevice,
-		Flags:   attachFlags,
-	})
-	if err != nil {
-		return nilCloser, fmt.Errorf("failed to call BPF_PROG_ATTACH (BPF_CGROUP_DEVICE, BPF_F_ALLOW_MULTI): %w", err)
-	}
-	closer := func() error {
-		err = link.RawDetachProgram(link.RawDetachProgramOptions{
-			Target:  dirFd,
-			Program: prog,
-			Attach:  ebpf.AttachCGroupDevice,
-		})
-		if err != nil {
-			return fmt.Errorf("failed to call BPF_PROG_DETACH (BPF_CGROUP_DEVICE): %w", err)
-		}
-		// TODO: Should we attach the old filters back in this case? Otherwise
-		//       we fail-open on a security feature, which is a bit scary.
-		return nil
-	}
-	if !useReplaceProg {
-		logLevel := logrus.DebugLevel
-		// If there was more than one old program, give a warning (since this
-		// really shouldn't happen with runc-managed cgroups) and then detach
-		// all the old programs.
-		if len(oldProgs) > 1 {
-			// NOTE: Ideally this should be a warning but it turns out that
-			//       systemd-managed cgroups trigger this warning (apparently
-			//       systemd doesn't delete old non-systemd programs when
-			//       setting properties).
-			logrus.Infof("found more than one filter (%d) attached to a cgroup -- removing extra filters!", len(oldProgs))
-			logLevel = logrus.InfoLevel
-		}
-		for idx, oldProg := range oldProgs {
-			// Output some extra debug info.
-			if info, err := oldProg.Info(); err == nil {
-				fields := logrus.Fields{
-					"type": info.Type.String(),
-					"tag":  info.Tag,
-					"name": info.Name,
-				}
-				if id, ok := info.ID(); ok {
-					fields["id"] = id
-				}
-				if runCount, ok := info.RunCount(); ok {
-					fields["run_count"] = runCount
-				}
-				if runtime, ok := info.Runtime(); ok {
-					fields["runtime"] = runtime.String()
-				}
-				logrus.WithFields(fields).Logf(logLevel, "removing old filter %d from cgroup", idx)
-			}
-			err = link.RawDetachProgram(link.RawDetachProgramOptions{
-				Target:  dirFd,
-				Program: oldProg,
-				Attach:  ebpf.AttachCGroupDevice,
-			})
-			if err != nil {
-				return closer, fmt.Errorf("failed to call BPF_PROG_DETACH (BPF_CGROUP_DEVICE) on old filter program: %w", err)
-			}
-		}
-	}
-	return closer, nil
-}
diff --git a/vendor/github.com/opencontainers/runc/libcontainer/cgroups/file.go b/vendor/github.com/opencontainers/runc/libcontainer/cgroups/file.go
index f6e1b73bd..78c5bcf0d 100644
--- a/vendor/github.com/opencontainers/runc/libcontainer/cgroups/file.go
+++ b/vendor/github.com/opencontainers/runc/libcontainer/cgroups/file.go
@@ -50,22 +50,45 @@ func WriteFile(dir, file, data string) error {
 		return err
 	}
 	defer fd.Close()
-	if err := retryingWriteFile(fd, data); err != nil {
+	if _, err := fd.WriteString(data); err != nil {
 		// Having data in the error message helps in debugging.
 		return fmt.Errorf("failed to write %q: %w", data, err)
 	}
 	return nil
 }
 
-func retryingWriteFile(fd *os.File, data string) error {
+// WriteFileByLine is the same as WriteFile, except if data contains newlines,
+// it is written line by line.
+func WriteFileByLine(dir, file, data string) error {
+	i := strings.Index(data, "\n")
+	if i == -1 {
+		return WriteFile(dir, file, data)
+	}
+
+	fd, err := OpenFile(dir, file, unix.O_WRONLY)
+	if err != nil {
+		return err
+	}
+	defer fd.Close()
+	start := 0
 	for {
-		_, err := fd.Write([]byte(data))
-		if errors.Is(err, unix.EINTR) {
-			logrus.Infof("interrupted while writing %s to %s", data, fd.Name())
-			continue
+		var line string
+		if i == -1 {
+			line = data[start:]
+		} else {
+			line = data[start : start+i+1]
 		}
-		return err
+		_, err := fd.WriteString(line)
+		if err != nil {
+			return fmt.Errorf("failed to write %q: %w", line, err)
+		}
+		if i == -1 {
+			break
+		}
+		start += i + 1
+		i = strings.Index(data[start:], "\n")
 	}
+	return nil
 }
 
 const (
@@ -90,7 +113,7 @@ func prepareOpenat2() error {
 		})
 		if err != nil {
 			prepErr = &os.PathError{Op: "openat2", Path: cgroupfsDir, Err: err}
-			if err != unix.ENOSYS { //nolint:errorlint // unix errors are bare
+			if err != unix.ENOSYS {
 				logrus.Warnf("falling back to securejoin: %s", prepErr)
 			} else {
 				logrus.Debug("openat2 not available, falling back to securejoin")
@@ -148,8 +171,9 @@ func openFile(dir, file string, flags int) (*os.File, error) {
 		//
 		// TODO: if such usage will ever be common, amend this
 		// to reopen cgroupRootHandle and retry openat2.
-		fdStr := strconv.Itoa(int(cgroupRootHandle.Fd()))
-		fdDest, _ := os.Readlink("/proc/self/fd/" + fdStr)
+		fdPath, closer := utils.ProcThreadSelf("fd/" + strconv.Itoa(int(cgroupRootHandle.Fd())))
+		defer closer()
+		fdDest, _ := os.Readlink(fdPath)
 		if fdDest != cgroupfsDir {
 			// Wrap the error so it is clear that cgroupRootHandle
 			// is opened to an unexpected/wrong directory.
diff --git a/vendor/github.com/opencontainers/runc/libcontainer/cgroups/fs/cpu.go b/vendor/github.com/opencontainers/runc/libcontainer/cgroups/fs/cpu.go
index 72c9cd70b..62574b53c 100644
--- a/vendor/github.com/opencontainers/runc/libcontainer/cgroups/fs/cpu.go
+++ b/vendor/github.com/opencontainers/runc/libcontainer/cgroups/fs/cpu.go
@@ -100,6 +100,30 @@ func (s *CpuGroup) Set(path string, r *configs.Resources) error {
 			period = ""
 		}
 	}
+
+	var burst string
+	if r.CpuBurst != nil {
+		burst = strconv.FormatUint(*r.CpuBurst, 10)
+		if err := cgroups.WriteFile(path, "cpu.cfs_burst_us", burst); err != nil {
+			if errors.Is(err, unix.ENOENT) {
+				// If CPU burst knob is not available (e.g.
+				// older kernel), ignore it.
+				burst = ""
+			} else {
+				// Sometimes when the burst to be set is larger
+				// than the current one, it is rejected by the kernel
+				// (EINVAL) as old_quota/new_burst exceeds the parent
+				// cgroup quota limit. If this happens and the quota is
+				// going to be set, ignore the error for now and retry
+				// after setting the quota.
+				if !errors.Is(err, unix.EINVAL) || r.CpuQuota == 0 {
+					return err
+				}
+			}
+		} else {
+			burst = ""
+		}
+	}
 	if r.CpuQuota != 0 {
 		if err := cgroups.WriteFile(path, "cpu.cfs_quota_us", strconv.FormatInt(r.CpuQuota, 10)); err != nil {
 			return err
@@ -109,7 +133,20 @@ func (s *CpuGroup) Set(path string, r *configs.Resources) error {
 				return err
 			}
 		}
+		if burst != "" {
+			if err := cgroups.WriteFile(path, "cpu.cfs_burst_us", burst); err != nil {
+				return err
+			}
+		}
+	}
+
+	if r.CPUIdle != nil {
+		idle := strconv.FormatInt(*r.CPUIdle, 10)
+		if err := cgroups.WriteFile(path, "cpu.idle", idle); err != nil {
+			return err
+		}
 	}
+
 	return s.SetRtSched(path, r)
 }
 
diff --git a/vendor/github.com/opencontainers/runc/libcontainer/cgroups/fs/cpuset.go b/vendor/github.com/opencontainers/runc/libcontainer/cgroups/fs/cpuset.go
index 550baa427..fe01ba984 100644
--- a/vendor/github.com/opencontainers/runc/libcontainer/cgroups/fs/cpuset.go
+++ b/vendor/github.com/opencontainers/runc/libcontainer/cgroups/fs/cpuset.go
@@ -195,7 +195,7 @@ func cpusetEnsureParent(current string) error {
 	}
 	// Treat non-existing directory as cgroupfs as it will be created,
 	// and the root cpuset directory obviously exists.
-	if err != nil && err != unix.ENOENT { //nolint:errorlint // unix errors are bare
+	if err != nil && err != unix.ENOENT {
 		return &os.PathError{Op: "statfs", Path: parent, Err: err}
 	}
 
diff --git a/vendor/github.com/opencontainers/runc/libcontainer/cgroups/fs/devices.go b/vendor/github.com/opencontainers/runc/libcontainer/cgroups/fs/devices.go
index 4527a70eb..0bf3d9deb 100644
--- a/vendor/github.com/opencontainers/runc/libcontainer/cgroups/fs/devices.go
+++ b/vendor/github.com/opencontainers/runc/libcontainer/cgroups/fs/devices.go
@@ -1,20 +1,11 @@
 package fs
 
 import (
-	"bytes"
-	"errors"
-	"reflect"
-
 	"github.com/opencontainers/runc/libcontainer/cgroups"
-	cgroupdevices "github.com/opencontainers/runc/libcontainer/cgroups/devices"
 	"github.com/opencontainers/runc/libcontainer/configs"
-	"github.com/opencontainers/runc/libcontainer/devices"
-	"github.com/opencontainers/runc/libcontainer/userns"
 )
 
-type DevicesGroup struct {
-	TestingSkipFinalCheck bool
-}
+type DevicesGroup struct{}
 
 func (s *DevicesGroup) Name() string {
 	return "devices"
@@ -33,75 +24,14 @@ func (s *DevicesGroup) Apply(path string, r *configs.Resources, pid int) error {
 	return apply(path, pid)
 }
 
-func loadEmulator(path string) (*cgroupdevices.Emulator, error) {
-	list, err := cgroups.ReadFile(path, "devices.list")
-	if err != nil {
-		return nil, err
-	}
-	return cgroupdevices.EmulatorFromList(bytes.NewBufferString(list))
-}
-
-func buildEmulator(rules []*devices.Rule) (*cgroupdevices.Emulator, error) {
-	// This defaults to a white-list -- which is what we want!
-	emu := &cgroupdevices.Emulator{}
-	for _, rule := range rules {
-		if err := emu.Apply(*rule); err != nil {
-			return nil, err
-		}
-	}
-	return emu, nil
-}
-
 func (s *DevicesGroup) Set(path string, r *configs.Resources) error {
-	if userns.RunningInUserNS() || r.SkipDevices {
-		return nil
-	}
-
-	// Generate two emulators, one for the current state of the cgroup and one
-	// for the requested state by the user.
-	current, err := loadEmulator(path)
-	if err != nil {
-		return err
-	}
-	target, err := buildEmulator(r.Devices)
-	if err != nil {
-		return err
-	}
-
-	// Compute the minimal set of transition rules needed to achieve the
-	// requested state.
-	transitionRules, err := current.Transition(target)
-	if err != nil {
-		return err
-	}
-	for _, rule := range transitionRules {
-		file := "devices.deny"
-		if rule.Allow {
-			file = "devices.allow"
-		}
-		if err := cgroups.WriteFile(path, file, rule.CgroupString()); err != nil {
-			return err
+	if cgroups.DevicesSetV1 == nil {
+		if len(r.Devices) == 0 {
+			return nil
 		}
+		return cgroups.ErrDevicesUnsupported
 	}
-
-	// Final safety check -- ensure that the resulting state is what was
-	// requested. This is only really correct for white-lists, but for
-	// black-lists we can at least check that the cgroup is in the right mode.
-	//
-	// This safety-check is skipped for the unit tests because we cannot
-	// currently mock devices.list correctly.
-	if !s.TestingSkipFinalCheck {
-		currentAfter, err := loadEmulator(path)
-		if err != nil {
-			return err
-		}
-		if !target.IsBlacklist() && !reflect.DeepEqual(currentAfter, target) {
-			return errors.New("resulting devices cgroup doesn't precisely match target")
-		} else if target.IsBlacklist() != currentAfter.IsBlacklist() {
-			return errors.New("resulting devices cgroup doesn't match target mode")
-		}
-	}
-	return nil
+	return cgroups.DevicesSetV1(path, r)
 }
 
 func (s *DevicesGroup) GetStats(path string, stats *cgroups.Stats) error {
diff --git a/vendor/github.com/opencontainers/runc/libcontainer/cgroups/fs/fs.go b/vendor/github.com/opencontainers/runc/libcontainer/cgroups/fs/fs.go
index 9e2f0ec04..d2decb127 100644
--- a/vendor/github.com/opencontainers/runc/libcontainer/cgroups/fs/fs.go
+++ b/vendor/github.com/opencontainers/runc/libcontainer/cgroups/fs/fs.go
@@ -54,13 +54,13 @@ type subsystem interface {
 	Set(path string, r *configs.Resources) error
 }
 
-type manager struct {
+type Manager struct {
 	mu      sync.Mutex
 	cgroups *configs.Cgroup
 	paths   map[string]string
 }
 
-func NewManager(cg *configs.Cgroup, paths map[string]string) (cgroups.Manager, error) {
+func NewManager(cg *configs.Cgroup, paths map[string]string) (*Manager, error) {
 	// Some v1 controllers (cpu, cpuset, and devices) expect
 	// cgroups.Resources to not be nil in Apply.
 	if cg.Resources == nil {
@@ -78,7 +78,7 @@ func NewManager(cg *configs.Cgroup, paths map[string]string) (cgroups.Manager, e
 		}
 	}
 
-	return &manager{
+	return &Manager{
 		cgroups: cg,
 		paths:   paths,
 	}, nil
@@ -105,7 +105,7 @@ func isIgnorableError(rootless bool, err error) bool {
 	return false
 }
 
-func (m *manager) Apply(pid int) (err error) {
+func (m *Manager) Apply(pid int) (err error) {
 	m.mu.Lock()
 	defer m.mu.Unlock()
 
@@ -139,19 +139,19 @@ func (m *manager) Apply(pid int) (err error) {
 	return nil
 }
 
-func (m *manager) Destroy() error {
+func (m *Manager) Destroy() error {
 	m.mu.Lock()
 	defer m.mu.Unlock()
 	return cgroups.RemovePaths(m.paths)
 }
 
-func (m *manager) Path(subsys string) string {
+func (m *Manager) Path(subsys string) string {
 	m.mu.Lock()
 	defer m.mu.Unlock()
 	return m.paths[subsys]
 }
 
-func (m *manager) GetStats() (*cgroups.Stats, error) {
+func (m *Manager) GetStats() (*cgroups.Stats, error) {
 	m.mu.Lock()
 	defer m.mu.Unlock()
 	stats := cgroups.NewStats()
@@ -167,7 +167,7 @@ func (m *manager) GetStats() (*cgroups.Stats, error) {
 	return stats, nil
 }
 
-func (m *manager) Set(r *configs.Resources) error {
+func (m *Manager) Set(r *configs.Resources) error {
 	if r == nil {
 		return nil
 	}
@@ -183,7 +183,7 @@ func (m *manager) Set(r *configs.Resources) error {
 		if err := sys.Set(path, r); err != nil {
 			// When rootless is true, errors from the device subsystem
 			// are ignored, as it is really not expected to work.
-			if m.cgroups.Rootless && sys.Name() == "devices" {
+			if m.cgroups.Rootless && sys.Name() == "devices" && !errors.Is(err, cgroups.ErrDevicesUnsupported) {
 				continue
 			}
 			// However, errors from other subsystems are not ignored.
@@ -202,7 +202,7 @@ func (m *manager) Set(r *configs.Resources) error {
 
 // Freeze toggles the container's freezer cgroup depending on the state
 // provided
-func (m *manager) Freeze(state configs.FreezerState) error {
+func (m *Manager) Freeze(state configs.FreezerState) error {
 	path := m.Path("freezer")
 	if path == "" {
 		return errors.New("cannot toggle freezer: cgroups not configured for container")
@@ -218,25 +218,25 @@ func (m *manager) Freeze(state configs.FreezerState) error {
 	return nil
 }
 
-func (m *manager) GetPids() ([]int, error) {
+func (m *Manager) GetPids() ([]int, error) {
 	return cgroups.GetPids(m.Path("devices"))
 }
 
-func (m *manager) GetAllPids() ([]int, error) {
+func (m *Manager) GetAllPids() ([]int, error) {
 	return cgroups.GetAllPids(m.Path("devices"))
 }
 
-func (m *manager) GetPaths() map[string]string {
+func (m *Manager) GetPaths() map[string]string {
 	m.mu.Lock()
 	defer m.mu.Unlock()
 	return m.paths
 }
 
-func (m *manager) GetCgroups() (*configs.Cgroup, error) {
+func (m *Manager) GetCgroups() (*configs.Cgroup, error) {
 	return m.cgroups, nil
 }
 
-func (m *manager) GetFreezerState() (configs.FreezerState, error) {
+func (m *Manager) GetFreezerState() (configs.FreezerState, error) {
 	dir := m.Path("freezer")
 	// If the container doesn't have the freezer cgroup, say it's undefined.
 	if dir == "" {
@@ -246,7 +246,7 @@ func (m *manager) GetFreezerState() (configs.FreezerState, error) {
 	return freezer.GetState(dir)
 }
 
-func (m *manager) Exists() bool {
+func (m *Manager) Exists() bool {
 	return cgroups.PathExists(m.Path("devices"))
 }
 
@@ -254,7 +254,7 @@ func OOMKillCount(path string) (uint64, error) {
 	return fscommon.GetValueByKey(path, "memory.oom_control", "oom_kill")
 }
 
-func (m *manager) OOMKillCount() (uint64, error) {
+func (m *Manager) OOMKillCount() (uint64, error) {
 	c, err := OOMKillCount(m.Path("memory"))
 	// Ignore ENOENT when rootless as it couldn't create cgroup.
 	if err != nil && m.cgroups.Rootless && os.IsNotExist(err) {
diff --git a/vendor/github.com/opencontainers/runc/libcontainer/cgroups/fs/paths.go b/vendor/github.com/opencontainers/runc/libcontainer/cgroups/fs/paths.go
index 2cb970a3d..5f119bac3 100644
--- a/vendor/github.com/opencontainers/runc/libcontainer/cgroups/fs/paths.go
+++ b/vendor/github.com/opencontainers/runc/libcontainer/cgroups/fs/paths.go
@@ -165,9 +165,8 @@ func subsysPath(root, inner, subsystem string) (string, error) {
 		return filepath.Join(root, filepath.Base(mnt), inner), nil
 	}
 
-	// Use GetOwnCgroupPath instead of GetInitCgroupPath, because the creating
-	// process could in container and shared pid namespace with host, and
-	// /proc/1/cgroup could point to whole other world of cgroups.
+	// Use GetOwnCgroupPath for dind-like cases, when cgroupns is not
+	// available. This is ugly.
 	parentPath, err := cgroups.GetOwnCgroupPath(subsystem)
 	if err != nil {
 		return "", err
diff --git a/vendor/github.com/opencontainers/runc/libcontainer/cgroups/fs2/cpu.go b/vendor/github.com/opencontainers/runc/libcontainer/cgroups/fs2/cpu.go
index bbbae4d58..8ee49d499 100644
--- a/vendor/github.com/opencontainers/runc/libcontainer/cgroups/fs2/cpu.go
+++ b/vendor/github.com/opencontainers/runc/libcontainer/cgroups/fs2/cpu.go
@@ -2,16 +2,19 @@ package fs2
 
 import (
 	"bufio"
+	"errors"
 	"os"
 	"strconv"
 
+	"golang.org/x/sys/unix"
+
 	"github.com/opencontainers/runc/libcontainer/cgroups"
 	"github.com/opencontainers/runc/libcontainer/cgroups/fscommon"
 	"github.com/opencontainers/runc/libcontainer/configs"
 )
 
 func isCpuSet(r *configs.Resources) bool {
-	return r.CpuWeight != 0 || r.CpuQuota != 0 || r.CpuPeriod != 0
+	return r.CpuWeight != 0 || r.CpuQuota != 0 || r.CpuPeriod != 0 || r.CPUIdle != nil || r.CpuBurst != nil
 }
 
 func setCpu(dirPath string, r *configs.Resources) error {
@@ -19,6 +22,12 @@ func setCpu(dirPath string, r *configs.Resources) error {
 		return nil
 	}
 
+	if r.CPUIdle != nil {
+		if err := cgroups.WriteFile(dirPath, "cpu.idle", strconv.FormatInt(*r.CPUIdle, 10)); err != nil {
+			return err
+		}
+	}
+
 	// NOTE: .CpuShares is not used here. Conversion is the caller's responsibility.
 	if r.CpuWeight != 0 {
 		if err := cgroups.WriteFile(dirPath, "cpu.weight", strconv.FormatUint(r.CpuWeight, 10)); err != nil {
@@ -26,6 +35,23 @@ func setCpu(dirPath string, r *configs.Resources) error {
 		}
 	}
 
+	var burst string
+	if r.CpuBurst != nil {
+		burst = strconv.FormatUint(*r.CpuBurst, 10)
+		if err := cgroups.WriteFile(dirPath, "cpu.max.burst", burst); err != nil {
+			// Sometimes when the burst to be set is larger
+			// than the current one, it is rejected by the kernel
+			// (EINVAL) as old_quota/new_burst exceeds the parent
+			// cgroup quota limit. If this happens and the quota is
+			// going to be set, ignore the error for now and retry
+			// after setting the quota.
+			if !errors.Is(err, unix.EINVAL) || r.CpuQuota == 0 {
+				return err
+			}
+		} else {
+			burst = ""
+		}
+	}
 	if r.CpuQuota != 0 || r.CpuPeriod != 0 {
 		str := "max"
 		if r.CpuQuota > 0 {
@@ -41,6 +67,11 @@ func setCpu(dirPath string, r *configs.Resources) error {
 		if err := cgroups.WriteFile(dirPath, "cpu.max", str); err != nil {
 			return err
 		}
+		if burst != "" {
+			if err := cgroups.WriteFile(dirPath, "cpu.max.burst", burst); err != nil {
+				return err
+			}
+		}
 	}
 
 	return nil
diff --git a/vendor/github.com/opencontainers/runc/libcontainer/cgroups/fs2/defaultpath.go b/vendor/github.com/opencontainers/runc/libcontainer/cgroups/fs2/defaultpath.go
index 9c949c91f..8ac831201 100644
--- a/vendor/github.com/opencontainers/runc/libcontainer/cgroups/fs2/defaultpath.go
+++ b/vendor/github.com/opencontainers/runc/libcontainer/cgroups/fs2/defaultpath.go
@@ -55,6 +55,9 @@ func _defaultDirPath(root, cgPath, cgParent, cgName string) (string, error) {
 		return filepath.Join(root, innerPath), nil
 	}
 
+	// we don't need to use /proc/thread-self here because runc always runs
+	// with every thread in the same cgroup. This lets us avoid having to do
+	// runtime.LockOSThread.
 	ownCgroup, err := parseCgroupFile("/proc/self/cgroup")
 	if err != nil {
 		return "", err
diff --git a/vendor/github.com/opencontainers/runc/libcontainer/cgroups/fs2/devices.go b/vendor/github.com/opencontainers/runc/libcontainer/cgroups/fs2/devices.go
deleted file mode 100644
index 0d2345607..000000000
--- a/vendor/github.com/opencontainers/runc/libcontainer/cgroups/fs2/devices.go
+++ /dev/null
@@ -1,75 +0,0 @@
-package fs2
-
-import (
-	"fmt"
-
-	"golang.org/x/sys/unix"
-
-	"github.com/opencontainers/runc/libcontainer/cgroups/ebpf"
-	"github.com/opencontainers/runc/libcontainer/cgroups/ebpf/devicefilter"
-	"github.com/opencontainers/runc/libcontainer/configs"
-	"github.com/opencontainers/runc/libcontainer/devices"
-	"github.com/opencontainers/runc/libcontainer/userns"
-)
-
-func isRWM(perms devices.Permissions) bool {
-	var r, w, m bool
-	for _, perm := range perms {
-		switch perm {
-		case 'r':
-			r = true
-		case 'w':
-			w = true
-		case 'm':
-			m = true
-		}
-	}
-	return r && w && m
-}
-
-// This is similar to the logic applied in crun for handling errors from bpf(2)
-// <https://github.com/containers/crun/blob/0.17/src/libcrun/cgroup.c#L2438-L2470>.
-func canSkipEBPFError(r *configs.Resources) bool {
-	// If we're running in a user namespace we can ignore eBPF rules because we
-	// usually cannot use bpf(2), as well as rootless containers usually don't
-	// have the necessary privileges to mknod(2) device inodes or access
-	// host-level instances (though ideally we would be blocking device access
-	// for rootless containers anyway).
-	if userns.RunningInUserNS() {
-		return true
-	}
-
-	// We cannot ignore an eBPF load error if any rule if is a block rule or it
-	// doesn't permit all access modes.
-	//
-	// NOTE: This will sometimes trigger in cases where access modes are split
-	//       between different rules but to handle this correctly would require
-	//       using ".../libcontainer/cgroup/devices".Emulator.
-	for _, dev := range r.Devices {
-		if !dev.Allow || !isRWM(dev.Permissions) {
-			return false
-		}
-	}
-	return true
-}
-
-func setDevices(dirPath string, r *configs.Resources) error {
-	if r.SkipDevices {
-		return nil
-	}
-	insts, license, err := devicefilter.DeviceFilter(r.Devices)
-	if err != nil {
-		return err
-	}
-	dirFD, err := unix.Open(dirPath, unix.O_DIRECTORY|unix.O_RDONLY, 0o600)
-	if err != nil {
-		return fmt.Errorf("cannot get dir FD for %s", dirPath)
-	}
-	defer unix.Close(dirFD)
-	if _, err := ebpf.LoadAttachCgroupDeviceFilter(insts, license, dirFD); err != nil {
-		if !canSkipEBPFError(r) {
-			return err
-		}
-	}
-	return nil
-}
diff --git a/vendor/github.com/opencontainers/runc/libcontainer/cgroups/fs2/fs2.go b/vendor/github.com/opencontainers/runc/libcontainer/cgroups/fs2/fs2.go
index 492778e31..b1be7df5c 100644
--- a/vendor/github.com/opencontainers/runc/libcontainer/cgroups/fs2/fs2.go
+++ b/vendor/github.com/opencontainers/runc/libcontainer/cgroups/fs2/fs2.go
@@ -13,7 +13,7 @@ import (
 
 type parseError = fscommon.ParseError
 
-type manager struct {
+type Manager struct {
 	config *configs.Cgroup
 	// dirPath is like "/sys/fs/cgroup/user.slice/user-1001.slice/session-1.scope"
 	dirPath string
@@ -25,7 +25,7 @@ type manager struct {
 // NewManager creates a manager for cgroup v2 unified hierarchy.
 // dirPath is like "/sys/fs/cgroup/user.slice/user-1001.slice/session-1.scope".
 // If dirPath is empty, it is automatically set using config.
-func NewManager(config *configs.Cgroup, dirPath string) (cgroups.Manager, error) {
+func NewManager(config *configs.Cgroup, dirPath string) (*Manager, error) {
 	if dirPath == "" {
 		var err error
 		dirPath, err = defaultDirPath(config)
@@ -34,14 +34,14 @@ func NewManager(config *configs.Cgroup, dirPath string) (cgroups.Manager, error)
 		}
 	}
 
-	m := &manager{
+	m := &Manager{
 		config:  config,
 		dirPath: dirPath,
 	}
 	return m, nil
 }
 
-func (m *manager) getControllers() error {
+func (m *Manager) getControllers() error {
 	if m.controllers != nil {
 		return nil
 	}
@@ -62,7 +62,7 @@ func (m *manager) getControllers() error {
 	return nil
 }
 
-func (m *manager) Apply(pid int) error {
+func (m *Manager) Apply(pid int) error {
 	if err := CreateCgroupPath(m.dirPath, m.config); err != nil {
 		// Related tests:
 		// - "runc create (no limits + no cgrouppath + no permission) succeeds"
@@ -84,15 +84,15 @@ func (m *manager) Apply(pid int) error {
 	return nil
 }
 
-func (m *manager) GetPids() ([]int, error) {
+func (m *Manager) GetPids() ([]int, error) {
 	return cgroups.GetPids(m.dirPath)
 }
 
-func (m *manager) GetAllPids() ([]int, error) {
+func (m *Manager) GetAllPids() ([]int, error) {
 	return cgroups.GetAllPids(m.dirPath)
 }
 
-func (m *manager) GetStats() (*cgroups.Stats, error) {
+func (m *Manager) GetStats() (*cgroups.Stats, error) {
 	var errs []error
 
 	st := cgroups.NewStats()
@@ -114,6 +114,17 @@ func (m *manager) GetStats() (*cgroups.Stats, error) {
 	if err := statCpu(m.dirPath, st); err != nil && !os.IsNotExist(err) {
 		errs = append(errs, err)
 	}
+	// PSI (since kernel 4.20).
+	var err error
+	if st.CpuStats.PSI, err = statPSI(m.dirPath, "cpu.pressure"); err != nil {
+		errs = append(errs, err)
+	}
+	if st.MemoryStats.PSI, err = statPSI(m.dirPath, "memory.pressure"); err != nil {
+		errs = append(errs, err)
+	}
+	if st.BlkioStats.PSI, err = statPSI(m.dirPath, "io.pressure"); err != nil {
+		errs = append(errs, err)
+	}
 	// hugetlb (since kernel 5.6)
 	if err := statHugeTlb(m.dirPath, st); err != nil && !os.IsNotExist(err) {
 		errs = append(errs, err)
@@ -122,13 +133,17 @@ func (m *manager) GetStats() (*cgroups.Stats, error) {
 	if err := fscommon.RdmaGetStats(m.dirPath, st); err != nil && !os.IsNotExist(err) {
 		errs = append(errs, err)
 	}
+	// misc (since kernel 5.13)
+	if err := statMisc(m.dirPath, st); err != nil && !os.IsNotExist(err) {
+		errs = append(errs, err)
+	}
 	if len(errs) > 0 && !m.config.Rootless {
 		return st, fmt.Errorf("error while statting cgroup v2: %+v", errs)
 	}
 	return st, nil
 }
 
-func (m *manager) Freeze(state configs.FreezerState) error {
+func (m *Manager) Freeze(state configs.FreezerState) error {
 	if m.config.Resources == nil {
 		return errors.New("cannot toggle freezer: cgroups not configured for container")
 	}
@@ -139,15 +154,15 @@ func (m *manager) Freeze(state configs.FreezerState) error {
 	return nil
 }
 
-func (m *manager) Destroy() error {
+func (m *Manager) Destroy() error {
 	return cgroups.RemovePath(m.dirPath)
 }
 
-func (m *manager) Path(_ string) string {
+func (m *Manager) Path(_ string) string {
 	return m.dirPath
 }
 
-func (m *manager) Set(r *configs.Resources) error {
+func (m *Manager) Set(r *configs.Resources) error {
 	if r == nil {
 		return nil
 	}
@@ -175,8 +190,10 @@ func (m *manager) Set(r *configs.Resources) error {
 	// When rootless is true, errors from the device subsystem are ignored because it is really not expected to work.
 	// However, errors from other subsystems are not ignored.
 	// see @test "runc create (rootless + limits + no cgrouppath + no permission) fails with informative error"
-	if err := setDevices(m.dirPath, r); err != nil && !m.config.Rootless {
-		return err
+	if err := setDevices(m.dirPath, r); err != nil {
+		if !m.config.Rootless || errors.Is(err, cgroups.ErrDevicesUnsupported) {
+			return err
+		}
 	}
 	// cpuset (since kernel 5.0)
 	if err := setCpuset(m.dirPath, r); err != nil {
@@ -201,12 +218,22 @@ func (m *manager) Set(r *configs.Resources) error {
 	return nil
 }
 
-func (m *manager) setUnified(res map[string]string) error {
+func setDevices(dirPath string, r *configs.Resources) error {
+	if cgroups.DevicesSetV2 == nil {
+		if len(r.Devices) > 0 {
+			return cgroups.ErrDevicesUnsupported
+		}
+		return nil
+	}
+	return cgroups.DevicesSetV2(dirPath, r)
+}
+
+func (m *Manager) setUnified(res map[string]string) error {
 	for k, v := range res {
 		if strings.Contains(k, "/") {
 			return fmt.Errorf("unified resource %q must be a file name (no slashes)", k)
 		}
-		if err := cgroups.WriteFile(m.dirPath, k, v); err != nil {
+		if err := cgroups.WriteFileByLine(m.dirPath, k, v); err != nil {
 			// Check for both EPERM and ENOENT since O_CREAT is used by WriteFile.
 			if errors.Is(err, os.ErrPermission) || errors.Is(err, os.ErrNotExist) {
 				// Check if a controller is available,
@@ -227,21 +254,21 @@ func (m *manager) setUnified(res map[string]string) error {
 	return nil
 }
 
-func (m *manager) GetPaths() map[string]string {
+func (m *Manager) GetPaths() map[string]string {
 	paths := make(map[string]string, 1)
 	paths[""] = m.dirPath
 	return paths
 }
 
-func (m *manager) GetCgroups() (*configs.Cgroup, error) {
+func (m *Manager) GetCgroups() (*configs.Cgroup, error) {
 	return m.config, nil
 }
 
-func (m *manager) GetFreezerState() (configs.FreezerState, error) {
+func (m *Manager) GetFreezerState() (configs.FreezerState, error) {
 	return getFreezer(m.dirPath)
 }
 
-func (m *manager) Exists() bool {
+func (m *Manager) Exists() bool {
 	return cgroups.PathExists(m.dirPath)
 }
 
@@ -249,7 +276,7 @@ func OOMKillCount(path string) (uint64, error) {
 	return fscommon.GetValueByKey(path, "memory.events", "oom_kill")
 }
 
-func (m *manager) OOMKillCount() (uint64, error) {
+func (m *Manager) OOMKillCount() (uint64, error) {
 	c, err := OOMKillCount(m.dirPath)
 	if err != nil && m.config.Rootless && os.IsNotExist(err) {
 		err = nil
@@ -257,3 +284,35 @@ func (m *manager) OOMKillCount() (uint64, error) {
 
 	return c, err
 }
+
+func CheckMemoryUsage(dirPath string, r *configs.Resources) error {
+	if !r.MemoryCheckBeforeUpdate {
+		return nil
+	}
+
+	if r.Memory <= 0 && r.MemorySwap <= 0 {
+		return nil
+	}
+
+	usage, err := fscommon.GetCgroupParamUint(dirPath, "memory.current")
+	if err != nil {
+		// This check is on best-effort basis, so if we can't read the
+		// current usage (cgroup not yet created, or any other error),
+		// we should not fail.
+		return nil
+	}
+
+	if r.MemorySwap > 0 {
+		if uint64(r.MemorySwap) <= usage {
+			return fmt.Errorf("rejecting memory+swap limit %d <= usage %d", r.MemorySwap, usage)
+		}
+	}
+
+	if r.Memory > 0 {
+		if uint64(r.Memory) <= usage {
+			return fmt.Errorf("rejecting memory limit %d <= usage %d", r.Memory, usage)
+		}
+	}
+
+	return nil
+}
diff --git a/vendor/github.com/opencontainers/runc/libcontainer/cgroups/fs2/memory.go b/vendor/github.com/opencontainers/runc/libcontainer/cgroups/fs2/memory.go
index 01fe7d8e1..df8336ba0 100644
--- a/vendor/github.com/opencontainers/runc/libcontainer/cgroups/fs2/memory.go
+++ b/vendor/github.com/opencontainers/runc/libcontainer/cgroups/fs2/memory.go
@@ -40,6 +40,11 @@ func setMemory(dirPath string, r *configs.Resources) error {
 	if !isMemorySet(r) {
 		return nil
 	}
+
+	if err := CheckMemoryUsage(dirPath, r); err != nil {
+		return err
+	}
+
 	swap, err := cgroups.ConvertMemorySwapToCgroupV2Value(r.MemorySwap, r.Memory)
 	if err != nil {
 		return err
@@ -52,7 +57,10 @@ func setMemory(dirPath string, r *configs.Resources) error {
 	// never write empty string to `memory.swap.max`, it means set to 0.
 	if swapStr != "" {
 		if err := cgroups.WriteFile(dirPath, "memory.swap.max", swapStr); err != nil {
-			return err
+			// If swap is not enabled, silently ignore setting to max or disabling it.
+			if !(errors.Is(err, os.ErrNotExist) && (swapStr == "max" || swapStr == "0")) {
+				return err
+			}
 		}
 	}
 
diff --git a/vendor/github.com/opencontainers/runc/libcontainer/cgroups/fs2/misc.go b/vendor/github.com/opencontainers/runc/libcontainer/cgroups/fs2/misc.go
new file mode 100644
index 000000000..f0b292aa0
--- /dev/null
+++ b/vendor/github.com/opencontainers/runc/libcontainer/cgroups/fs2/misc.go
@@ -0,0 +1,52 @@
+package fs2
+
+import (
+	"bufio"
+	"os"
+	"strings"
+
+	"github.com/opencontainers/runc/libcontainer/cgroups"
+	"github.com/opencontainers/runc/libcontainer/cgroups/fscommon"
+)
+
+func statMisc(dirPath string, stats *cgroups.Stats) error {
+	for _, file := range []string{"current", "events"} {
+		fd, err := cgroups.OpenFile(dirPath, "misc."+file, os.O_RDONLY)
+		if err != nil {
+			return err
+		}
+
+		s := bufio.NewScanner(fd)
+		for s.Scan() {
+			key, value, err := fscommon.ParseKeyValue(s.Text())
+			if err != nil {
+				fd.Close()
+				return err
+			}
+
+			key = strings.TrimSuffix(key, ".max")
+
+			if _, ok := stats.MiscStats[key]; !ok {
+				stats.MiscStats[key] = cgroups.MiscStats{}
+			}
+
+			tmp := stats.MiscStats[key]
+
+			switch file {
+			case "current":
+				tmp.Usage = value
+			case "events":
+				tmp.Events = value
+			}
+
+			stats.MiscStats[key] = tmp
+		}
+		fd.Close()
+
+		if err := s.Err(); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
diff --git a/vendor/github.com/opencontainers/runc/libcontainer/cgroups/fs2/psi.go b/vendor/github.com/opencontainers/runc/libcontainer/cgroups/fs2/psi.go
new file mode 100644
index 000000000..09f348885
--- /dev/null
+++ b/vendor/github.com/opencontainers/runc/libcontainer/cgroups/fs2/psi.go
@@ -0,0 +1,89 @@
+package fs2
+
+import (
+	"bufio"
+	"errors"
+	"fmt"
+	"os"
+	"strconv"
+	"strings"
+
+	"golang.org/x/sys/unix"
+
+	"github.com/opencontainers/runc/libcontainer/cgroups"
+)
+
+func statPSI(dirPath string, file string) (*cgroups.PSIStats, error) {
+	f, err := cgroups.OpenFile(dirPath, file, os.O_RDONLY)
+	if err != nil {
+		if errors.Is(err, os.ErrNotExist) {
+			// Kernel < 4.20, or CONFIG_PSI is not set,
+			// or PSI stats are turned off for the cgroup
+			// ("echo 0 > cgroup.pressure", kernel >= 6.1).
+			return nil, nil
+		}
+		return nil, err
+	}
+	defer f.Close()
+
+	var psistats cgroups.PSIStats
+	sc := bufio.NewScanner(f)
+	for sc.Scan() {
+		parts := strings.Fields(sc.Text())
+		var pv *cgroups.PSIData
+		switch parts[0] {
+		case "some":
+			pv = &psistats.Some
+		case "full":
+			pv = &psistats.Full
+		}
+		if pv != nil {
+			*pv, err = parsePSIData(parts[1:])
+			if err != nil {
+				return nil, &parseError{Path: dirPath, File: file, Err: err}
+			}
+		}
+	}
+	if err := sc.Err(); err != nil {
+		if errors.Is(err, unix.ENOTSUP) {
+			// Some kernels (e.g. CS9) may return ENOTSUP on read
+			// if psi=1 kernel cmdline parameter is required.
+			return nil, nil
+		}
+		return nil, &parseError{Path: dirPath, File: file, Err: err}
+	}
+	return &psistats, nil
+}
+
+func parsePSIData(psi []string) (cgroups.PSIData, error) {
+	data := cgroups.PSIData{}
+	for _, f := range psi {
+		kv := strings.SplitN(f, "=", 2)
+		if len(kv) != 2 {
+			return data, fmt.Errorf("invalid psi data: %q", f)
+		}
+		var pv *float64
+		switch kv[0] {
+		case "avg10":
+			pv = &data.Avg10
+		case "avg60":
+			pv = &data.Avg60
+		case "avg300":
+			pv = &data.Avg300
+		case "total":
+			v, err := strconv.ParseUint(kv[1], 10, 64)
+			if err != nil {
+				return data, fmt.Errorf("invalid %s PSI value: %w", kv[0], err)
+			}
+			data.Total = v
+		}
+		if pv != nil {
+			v, err := strconv.ParseFloat(kv[1], 64)
+			if err != nil {
+				return data, fmt.Errorf("invalid %s PSI value: %w", kv[0], err)
+			}
+			*pv = v
+		}
+	}
+	return data, nil
+}
diff --git a/vendor/github.com/opencontainers/runc/libcontainer/cgroups/stats.go b/vendor/github.com/opencontainers/runc/libcontainer/cgroups/stats.go
index 0d8371b05..b475567d8 100644
--- a/vendor/github.com/opencontainers/runc/libcontainer/cgroups/stats.go
+++ b/vendor/github.com/opencontainers/runc/libcontainer/cgroups/stats.go
@@ -32,9 +32,22 @@ type CpuUsage struct {
 	UsageInUsermode uint64 `json:"usage_in_usermode"`
 }
 
+type PSIData struct {
+	Avg10  float64 `json:"avg10"`
+	Avg60  float64 `json:"avg60"`
+	Avg300 float64 `json:"avg300"`
+	Total  uint64  `json:"total"`
+}
+
+type PSIStats struct {
+	Some PSIData `json:"some,omitempty"`
+	Full PSIData `json:"full,omitempty"`
+}
+
 type CpuStats struct {
 	CpuUsage       CpuUsage       `json:"cpu_usage,omitempty"`
 	ThrottlingData ThrottlingData `json:"throttling_data,omitempty"`
+	PSI            *PSIStats      `json:"psi,omitempty"`
 }
 
 type CPUSetStats struct {
@@ -91,6 +104,7 @@ type MemoryStats struct {
 	UseHierarchy bool `json:"use_hierarchy"`
 
 	Stats map[string]uint64 `json:"stats,omitempty"`
+	PSI   *PSIStats         `json:"psi,omitempty"`
 }
 
 type PageUsageByNUMA struct {
@@ -135,6 +149,7 @@ type BlkioStats struct {
 	IoMergedRecursive       []BlkioStatEntry `json:"io_merged_recursive,omitempty"`
 	IoTimeRecursive         []BlkioStatEntry `json:"io_time_recursive,omitempty"`
 	SectorsRecursive        []BlkioStatEntry `json:"sectors_recursive,omitempty"`
+	PSI                     *PSIStats        `json:"psi,omitempty"`
 }
 
 type HugetlbStats struct {
@@ -157,6 +172,13 @@ type RdmaStats struct {
 	RdmaCurrent []RdmaEntry `json:"rdma_current,omitempty"`
 }
 
+type MiscStats struct {
+	// current resource usage for a key in misc
+	Usage uint64 `json:"usage,omitempty"`
+	// number of times the resource usage was about to go over the max boundary
+	Events uint64 `json:"events,omitempty"`
+}
+
 type Stats struct {
 	CpuStats    CpuStats    `json:"cpu_stats,omitempty"`
 	CPUSetStats CPUSetStats `json:"cpuset_stats,omitempty"`
@@ -166,10 +188,13 @@ type Stats struct {
 	// the map is in the format "size of hugepage: stats of the hugepage"
 	HugetlbStats map[string]HugetlbStats `json:"hugetlb_stats,omitempty"`
 	RdmaStats    RdmaStats               `json:"rdma_stats,omitempty"`
+	// the map is in the format "misc resource name: stats of the key"
+	MiscStats map[string]MiscStats `json:"misc_stats,omitempty"`
 }
 
 func NewStats() *Stats {
 	memoryStats := MemoryStats{Stats: make(map[string]uint64)}
 	hugetlbStats := make(map[string]HugetlbStats)
-	return &Stats{MemoryStats: memoryStats, HugetlbStats: hugetlbStats}
+	miscStats := make(map[string]MiscStats)
+	return &Stats{MemoryStats: memoryStats, HugetlbStats: hugetlbStats, MiscStats: miscStats}
 }
diff --git a/vendor/github.com/opencontainers/runc/libcontainer/cgroups/utils.go b/vendor/github.com/opencontainers/runc/libcontainer/cgroups/utils.go
index fc4ae44a4..d303cf204 100644
--- a/vendor/github.com/opencontainers/runc/libcontainer/cgroups/utils.go
+++ b/vendor/github.com/opencontainers/runc/libcontainer/cgroups/utils.go
@@ -36,13 +36,13 @@ func IsCgroup2UnifiedMode() bool {
 		var st unix.Statfs_t
 		err := unix.Statfs(unifiedMountpoint, &st)
 		if err != nil {
+			level := logrus.WarnLevel
 			if os.IsNotExist(err) && userns.RunningInUserNS() {
-				// ignore the "not found" error if running in userns
-				logrus.WithError(err).Debugf("%s missing, assuming cgroup v1", unifiedMountpoint)
-				isUnified = false
-				return
+				// For rootless containers, sweep it under the rug.
+				level = logrus.DebugLevel
 			}
-			panic(fmt.Sprintf("cannot statfs cgroup root: %s", err))
+			logrus.StandardLogger().Logf(level,
+				"statfs %s: %v; assuming cgroup v1", unifiedMountpoint, err)
 		}
 		isUnified = st.Type == unix.CGROUP2_SUPER_MAGIC
 	})
@@ -136,18 +136,18 @@ func GetAllSubsystems() ([]string, error) {
 	return subsystems, nil
 }
 
-func readProcsFile(dir string) ([]int, error) {
-	f, err := OpenFile(dir, CgroupProcesses, os.O_RDONLY)
+func readProcsFile(dir string) (out []int, _ error) {
+	file := CgroupProcesses
+	retry := true
+
+again:
+	f, err := OpenFile(dir, file, os.O_RDONLY)
 	if err != nil {
 		return nil, err
 	}
 	defer f.Close()
 
-	var (
-		s   = bufio.NewScanner(f)
-		out = []int{}
-	)
-
+	s := bufio.NewScanner(f)
 	for s.Scan() {
 		if t := s.Text(); t != "" {
 			pid, err := strconv.Atoi(t)
@@ -157,6 +157,13 @@ func readProcsFile(dir string) ([]int, error) {
 			out = append(out, pid)
 		}
 	}
+	if errors.Is(s.Err(), unix.ENOTSUP) && retry {
+		// For a threaded cgroup, read returns ENOTSUP, and we should
+		// read from cgroup.threads instead.
+		file = "cgroup.threads"
+		retry = false
+		goto again
+	}
 	return out, s.Err()
 }
 
@@ -217,21 +224,26 @@ func PathExists(path string) bool {
 	return true
 }
 
-func EnterPid(cgroupPaths map[string]string, pid int) error {
-	for _, path := range cgroupPaths {
-		if PathExists(path) {
-			if err := WriteCgroupProc(path, pid); err != nil {
-				return err
-			}
-		}
-	}
-	return nil
-}
+// rmdir tries to remove a directory, optionally retrying on EBUSY.
+func rmdir(path string, retry bool) error {
+	delay := time.Millisecond
+	tries := 10
 
-func rmdir(path string) error {
+again:
 	err := unix.Rmdir(path)
-	if err == nil || err == unix.ENOENT { //nolint:errorlint // unix errors are bare
+	switch err { // nolint:errorlint // unix errors are bare
+	case nil, unix.ENOENT:
 		return nil
+	case unix.EINTR:
+		goto again
+	case unix.EBUSY:
+		if retry && tries > 0 {
+			time.Sleep(delay)
+			delay *= 2
+			tries--
+			goto again
+
+		}
 	}
 	return &os.PathError{Op: "rmdir", Path: path, Err: err}
 }
@@ -239,68 +251,40 @@ func rmdir(path string) error {
 // RemovePath aims to remove cgroup path. It does so recursively,
 // by removing any subdirectories (sub-cgroups) first.
 func RemovePath(path string) error {
-	// try the fast path first
-	if err := rmdir(path); err == nil {
+	// Try the fast path first.
+	if err := rmdir(path, false); err == nil {
 		return nil
 	}
 
 	infos, err := os.ReadDir(path)
-	if err != nil {
-		if os.IsNotExist(err) {
-			err = nil
-		}
+	if err != nil && !os.IsNotExist(err) {
 		return err
 	}
 	for _, info := range infos {
 		if info.IsDir() {
-			// We should remove subcgroups dir first
+			// We should remove subcgroup first.
 			if err = RemovePath(filepath.Join(path, info.Name())); err != nil {
 				break
 			}
 		}
 	}
 	if err == nil {
-		err = rmdir(path)
+		err = rmdir(path, true)
 	}
 	return err
 }
 
 // RemovePaths iterates over the provided paths removing them.
-// We trying to remove all paths five times with increasing delay between tries.
-// If after all there are not removed cgroups - appropriate error will be
-// returned.
 func RemovePaths(paths map[string]string) (err error) {
-	const retries = 5
-	delay := 10 * time.Millisecond
-	for i := 0; i < retries; i++ {
-		if i != 0 {
-			time.Sleep(delay)
-			delay *= 2
-		}
-		for s, p := range paths {
-			if err := RemovePath(p); err != nil {
-				// do not log intermediate iterations
-				switch i {
-				case 0:
-					logrus.WithError(err).Warnf("Failed to remove cgroup (will retry)")
-				case retries - 1:
-					logrus.WithError(err).Error("Failed to remove cgroup")
-				}
-			}
-			_, err := os.Stat(p)
-			// We need this strange way of checking cgroups existence because
-			// RemoveAll almost always returns error, even on already removed
-			// cgroups
-			if os.IsNotExist(err) {
-				delete(paths, s)
-			}
-		}
-		if len(paths) == 0 {
-			//nolint:ineffassign,staticcheck // done to help garbage collecting: opencontainers/runc#2506
-			paths = make(map[string]string)
-			return nil
+	for s, p := range paths {
+		if err := RemovePath(p); err == nil {
+			delete(paths, s)
 		}
 	}
+	if len(paths) == 0 {
+		clear(paths)
+		return nil
+	}
 	return fmt.Errorf("Failed to remove paths: %v", paths)
 }
 
diff --git a/vendor/github.com/opencontainers/runc/libcontainer/cgroups/v1_utils.go b/vendor/github.com/opencontainers/runc/libcontainer/cgroups/v1_utils.go
index 47c75f22b..81193e209 100644
--- a/vendor/github.com/opencontainers/runc/libcontainer/cgroups/v1_utils.go
+++ b/vendor/github.com/opencontainers/runc/libcontainer/cgroups/v1_utils.go
@@ -99,11 +99,12 @@ func tryDefaultPath(cgroupPath, subsystem string) string {
 // expensive), so it is assumed that cgroup mounts are not being changed.
 func readCgroupMountinfo() ([]*mountinfo.Info, error) {
 	readMountinfoOnce.Do(func() {
+		// mountinfo.GetMounts uses /proc/thread-self, so we can use it without
+		// issues.
 		cgroupMountinfo, readMountinfoErr = mountinfo.GetMounts(
 			mountinfo.FSTypeFilter("cgroup"),
 		)
 	})
-
 	return cgroupMountinfo, readMountinfoErr
 }
 
@@ -196,6 +197,9 @@ func getCgroupMountsV1(all bool) ([]Mount, error) {
 		return nil, err
 	}
 
+	// We don't need to use /proc/thread-self here because runc always runs
+	// with every thread in the same cgroup. This lets us avoid having to do
+	// runtime.LockOSThread.
 	allSubsystems, err := ParseCgroupFile("/proc/self/cgroup")
 	if err != nil {
 		return nil, err
@@ -214,6 +218,10 @@ func GetOwnCgroup(subsystem string) (string, error) {
 	if IsCgroup2UnifiedMode() {
 		return "", errUnified
 	}
+
+	// We don't need to use /proc/thread-self here because runc always runs
+	// with every thread in the same cgroup. This lets us avoid having to do
+	// runtime.LockOSThread.
 	cgroups, err := ParseCgroupFile("/proc/self/cgroup")
 	if err != nil {
 		return "", err
@@ -236,27 +244,6 @@ func GetOwnCgroupPath(subsystem string) (string, error) {
 	return getCgroupPathHelper(subsystem, cgroup)
 }
 
-func GetInitCgroup(subsystem string) (string, error) {
-	if IsCgroup2UnifiedMode() {
-		return "", errUnified
-	}
-	cgroups, err := ParseCgroupFile("/proc/1/cgroup")
-	if err != nil {
-		return "", err
-	}
-
-	return getControllerPath(subsystem, cgroups)
-}
-
-func GetInitCgroupPath(subsystem string) (string, error) {
-	cgroup, err := GetInitCgroup(subsystem)
-	if err != nil {
-		return "", err
-	}
-
-	return getCgroupPathHelper(subsystem, cgroup)
-}
-
 func getCgroupPathHelper(subsystem, cgroup string) (string, error) {
 	mnt, root, err := FindCgroupMountpointAndRoot("", subsystem)
 	if err != nil {
diff --git a/vendor/github.com/opencontainers/runc/libcontainer/configs/blkio_device.go b/vendor/github.com/opencontainers/runc/libcontainer/configs/blkio_device.go
index fa195bf90..865344f99 100644
--- a/vendor/github.com/opencontainers/runc/libcontainer/configs/blkio_device.go
+++ b/vendor/github.com/opencontainers/runc/libcontainer/configs/blkio_device.go
@@ -2,8 +2,8 @@ package configs
 
 import "fmt"
 
-// blockIODevice holds major:minor format supported in blkio cgroup
-type blockIODevice struct {
+// BlockIODevice holds major:minor format supported in blkio cgroup.
+type BlockIODevice struct {
 	// Major is the device's major number
 	Major int64 `json:"major"`
 	// Minor is the device's minor number
@@ -12,7 +12,7 @@ type blockIODevice struct {
 
 // WeightDevice struct holds a `major:minor weight`|`major:minor leaf_weight` pair
 type WeightDevice struct {
-	blockIODevice
+	BlockIODevice
 	// Weight is the bandwidth rate for the device, range is from 10 to 1000
 	Weight uint16 `json:"weight"`
 	// LeafWeight is the bandwidth rate for the device while competing with the cgroup's child cgroups, range is from 10 to 1000, cfq scheduler only
@@ -41,7 +41,7 @@ func (wd *WeightDevice) LeafWeightString() string {
 
 // ThrottleDevice struct holds a `major:minor rate_per_second` pair
 type ThrottleDevice struct {
-	blockIODevice
+	BlockIODevice
 	// Rate is the IO rate limit per cgroup per device
 	Rate uint64 `json:"rate"`
 }
diff --git a/vendor/github.com/opencontainers/runc/libcontainer/configs/cgroup_linux.go b/vendor/github.com/opencontainers/runc/libcontainer/configs/cgroup_linux.go
index 2d4a89871..4a34cf76f 100644
--- a/vendor/github.com/opencontainers/runc/libcontainer/configs/cgroup_linux.go
+++ b/vendor/github.com/opencontainers/runc/libcontainer/configs/cgroup_linux.go
@@ -69,6 +69,9 @@ type Resources struct {
 	// CPU hardcap limit (in usecs). Allowed cpu time in a given period.
 	CpuQuota int64 `json:"cpu_quota"`
 
+	// CPU hardcap burst limit (in usecs). Allowed accumulated cpu time additionally for burst in a given period.
+	CpuBurst *uint64 `json:"cpu_burst"` //nolint:revive
+
 	// CPU period to be used for hardcapping (in usecs). 0 to use system default.
 	CpuPeriod uint64 `json:"cpu_period"`
 
@@ -84,6 +87,9 @@ type Resources struct {
 	// MEM to use
 	CpusetMems string `json:"cpuset_mems"`
 
+	// cgroup SCHED_IDLE
+	CPUIdle *int64 `json:"cpu_idle,omitempty"`
+
 	// Process limit; set <= `0' to disable limit.
 	PidsLimit int64 `json:"pids_limit"`
 
@@ -155,4 +161,9 @@ type Resources struct {
 	// during Set() to figure out whether the freeze is required. Those
 	// methods may be relatively slow, thus this flag.
 	SkipFreezeOnSet bool `json:"-"`
+
+	// MemoryCheckBeforeUpdate is a flag for cgroup v2 managers to check
+	// if the new memory limits (Memory and MemorySwap) being set are lower
+	// than the current memory usage, and reject if so.
+	MemoryCheckBeforeUpdate bool `json:"memory_check_before_update"`
 }
diff --git a/vendor/github.com/opencontainers/runc/libcontainer/configs/cgroup_unsupported.go b/vendor/github.com/opencontainers/runc/libcontainer/configs/cgroup_unsupported.go
index 7e383020f..53f5ec5a0 100644
--- a/vendor/github.com/opencontainers/runc/libcontainer/configs/cgroup_unsupported.go
+++ b/vendor/github.com/opencontainers/runc/libcontainer/configs/cgroup_unsupported.go
@@ -1,5 +1,4 @@
 //go:build !linux
-// +build !linux
 
 package configs
 
diff --git a/vendor/github.com/opencontainers/runc/libcontainer/configs/config.go b/vendor/github.com/opencontainers/runc/libcontainer/configs/config.go
index 6ebf5ec7b..22fe0f9b4 100644
--- a/vendor/github.com/opencontainers/runc/libcontainer/configs/config.go
+++ b/vendor/github.com/opencontainers/runc/libcontainer/configs/config.go
@@ -8,6 +8,7 @@ import (
 	"time"
 
 	"github.com/sirupsen/logrus"
+	"golang.org/x/sys/unix"
 
 	"github.com/opencontainers/runc/libcontainer/devices"
 	"github.com/opencontainers/runtime-spec/specs-go"
@@ -31,12 +32,13 @@ type IDMap struct {
 // for syscalls. Additional architectures can be added by specifying them in
 // Architectures.
 type Seccomp struct {
-	DefaultAction    Action     `json:"default_action"`
-	Architectures    []string   `json:"architectures"`
-	Syscalls         []*Syscall `json:"syscalls"`
-	DefaultErrnoRet  *uint      `json:"default_errno_ret"`
-	ListenerPath     string     `json:"listener_path,omitempty"`
-	ListenerMetadata string     `json:"listener_metadata,omitempty"`
+	DefaultAction    Action                   `json:"default_action"`
+	Architectures    []string                 `json:"architectures"`
+	Flags            []specs.LinuxSeccompFlag `json:"flags"`
+	Syscalls         []*Syscall               `json:"syscalls"`
+	DefaultErrnoRet  *uint                    `json:"default_errno_ret"`
+	ListenerPath     string                   `json:"listener_path,omitempty"`
+	ListenerMetadata string                   `json:"listener_metadata,omitempty"`
 }
 
 // Action is taken upon rule match in Seccomp
@@ -83,9 +85,6 @@ type Syscall struct {
 	Args     []*Arg `json:"args"`
 }
 
-// TODO Windows. Many of these fields should be factored out into those parts
-// which are common across platforms, and those which are platform specific.
-
 // Config defines configuration options for executing a process inside a contained environment.
 type Config struct {
 	// NoPivotRoot will use MS_MOVE and a chroot to jail the process into the container's rootfs
@@ -121,6 +120,9 @@ type Config struct {
 	// Hostname optionally sets the container's hostname if provided
 	Hostname string `json:"hostname"`
 
+	// Domainname optionally sets the container's domainname if provided
+	Domainname string `json:"domainname"`
+
 	// Namespaces specifies the container's namespaces that it should setup when cloning the init process
 	// If a namespace is not provided that namespace is shared from the container's parent process
 	Namespaces Namespaces `json:"namespaces"`
@@ -158,11 +160,11 @@ type Config struct {
 	// More information about kernel oom score calculation here: https://lwn.net/Articles/317814/
 	OomScoreAdj *int `json:"oom_score_adj,omitempty"`
 
-	// UidMappings is an array of User ID mappings for User Namespaces
-	UidMappings []IDMap `json:"uid_mappings"`
+	// UIDMappings is an array of User ID mappings for User Namespaces
+	UIDMappings []IDMap `json:"uid_mappings"`
 
-	// GidMappings is an array of Group ID mappings for User Namespaces
-	GidMappings []IDMap `json:"gid_mappings"`
+	// GIDMappings is an array of Group ID mappings for User Namespaces
+	GIDMappings []IDMap `json:"gid_mappings"`
 
 	// MaskPaths specifies paths within the container's rootfs to mask over with a bind
 	// mount pointing to /dev/null as to prevent reads of the file.
@@ -211,8 +213,87 @@ type Config struct {
 	// RootlessCgroups is set when unlikely to have the full access to cgroups.
 	// When RootlessCgroups is set, cgroups errors are ignored.
 	RootlessCgroups bool `json:"rootless_cgroups,omitempty"`
+
+	// TimeOffsets specifies the offset for supporting time namespaces.
+	TimeOffsets map[string]specs.LinuxTimeOffset `json:"time_offsets,omitempty"`
+
+	// Scheduler represents the scheduling attributes for a process.
+	Scheduler *Scheduler `json:"scheduler,omitempty"`
+
+	// Personality contains configuration for the Linux personality syscall.
+	Personality *LinuxPersonality `json:"personality,omitempty"`
+
+	// IOPriority is the container's I/O priority.
+	IOPriority *IOPriority `json:"io_priority,omitempty"`
 }
 
+// Scheduler is based on the Linux sched_setattr(2) syscall.
+type Scheduler = specs.Scheduler
+
+// ToSchedAttr is to convert *configs.Scheduler to *unix.SchedAttr.
+func ToSchedAttr(scheduler *Scheduler) (*unix.SchedAttr, error) {
+	var policy uint32
+	switch scheduler.Policy {
+	case specs.SchedOther:
+		policy = 0
+	case specs.SchedFIFO:
+		policy = 1
+	case specs.SchedRR:
+		policy = 2
+	case specs.SchedBatch:
+		policy = 3
+	case specs.SchedISO:
+		policy = 4
+	case specs.SchedIdle:
+		policy = 5
+	case specs.SchedDeadline:
+		policy = 6
+	default:
+		return nil, fmt.Errorf("invalid scheduler policy: %s", scheduler.Policy)
+	}
+
+	var flags uint64
+	for _, flag := range scheduler.Flags {
+		switch flag {
+		case specs.SchedFlagResetOnFork:
+			flags |= 0x01
+		case specs.SchedFlagReclaim:
+			flags |= 0x02
+		case specs.SchedFlagDLOverrun:
+			flags |= 0x04
+		case specs.SchedFlagKeepPolicy:
+			flags |= 0x08
+		case specs.SchedFlagKeepParams:
+			flags |= 0x10
+		case specs.SchedFlagUtilClampMin:
+			flags |= 0x20
+		case specs.SchedFlagUtilClampMax:
+			flags |= 0x40
+		default:
+			return nil, fmt.Errorf("invalid scheduler flag: %s", flag)
+		}
+	}
+
+	return &unix.SchedAttr{
+		Size:     unix.SizeofSchedAttr,
+		Policy:   policy,
+		Flags:    flags,
+		Nice:     scheduler.Nice,
+		Priority: uint32(scheduler.Priority),
+		Runtime:  scheduler.Runtime,
+		Deadline: scheduler.Deadline,
+		Period:   scheduler.Period,
+	}, nil
+}
+
+var IOPrioClassMapping = map[specs.IOPriorityClass]int{
+	specs.IOPRIO_CLASS_RT:   1,
+	specs.IOPRIO_CLASS_BE:   2,
+	specs.IOPRIO_CLASS_IDLE: 3,
+}
+
+type IOPriority = specs.LinuxIOPriority
+
 type (
 	HookName string
 	HookList []Hook
@@ -277,6 +358,7 @@ type Capabilities struct {
 	Ambient []string
 }
 
+// Deprecated: use (Hooks).Run instead.
 func (hooks HookList) RunHooks(state *specs.State) error {
 	for i, h := range hooks {
 		if err := h.Run(state); err != nil {
@@ -333,6 +415,18 @@ func (hooks *Hooks) MarshalJSON() ([]byte, error) {
 	})
 }
 
+// Run executes all hooks for the given hook name.
+func (hooks Hooks) Run(name HookName, state *specs.State) error {
+	list := hooks[name]
+	for i, h := range list {
+		if err := h.Run(state); err != nil {
+			return fmt.Errorf("error running %s hook #%d: %w", name, i, err)
+		}
+	}
+
+	return nil
+}
+
 type Hook interface {
 	// Run executes the hook with the provided state.
 	Run(*specs.State) error
@@ -393,7 +487,7 @@ func (c Command) Run(s *specs.State) error {
 	go func() {
 		err := cmd.Wait()
 		if err != nil {
-			err = fmt.Errorf("error running hook: %w, stdout: %s, stderr: %s", err, stdout.String(), stderr.String())
+			err = fmt.Errorf("%w, stdout: %s, stderr: %s", err, stdout.String(), stderr.String())
 		}
 		errC <- err
 	}()
diff --git a/vendor/github.com/opencontainers/runc/libcontainer/configs/config_linux.go b/vendor/github.com/opencontainers/runc/libcontainer/configs/config_linux.go
index 51fe94074..e401f5331 100644
--- a/vendor/github.com/opencontainers/runc/libcontainer/configs/config_linux.go
+++ b/vendor/github.com/opencontainers/runc/libcontainer/configs/config_linux.go
@@ -7,22 +7,33 @@ import (
 )
 
 var (
-	errNoUIDMap   = errors.New("User namespaces enabled, but no uid mappings found.")
-	errNoUserMap  = errors.New("User namespaces enabled, but no user mapping found.")
-	errNoGIDMap   = errors.New("User namespaces enabled, but no gid mappings found.")
-	errNoGroupMap = errors.New("User namespaces enabled, but no group mapping found.")
+	errNoUIDMap = errors.New("user namespaces enabled, but no uid mappings found")
+	errNoGIDMap = errors.New("user namespaces enabled, but no gid mappings found")
 )
 
+// Please check https://man7.org/linux/man-pages/man2/personality.2.html for const details.
+// https://raw.githubusercontent.com/torvalds/linux/master/include/uapi/linux/personality.h
+const (
+	PerLinux   = 0x0000
+	PerLinux32 = 0x0008
+)
+
+type LinuxPersonality struct {
+	// Domain for the personality
+	// can only contain values "LINUX" and "LINUX32"
+	Domain int `json:"domain"`
+}
+
 // HostUID gets the translated uid for the process on host which could be
 // different when user namespaces are enabled.
 func (c Config) HostUID(containerId int) (int, error) {
 	if c.Namespaces.Contains(NEWUSER) {
-		if c.UidMappings == nil {
+		if len(c.UIDMappings) == 0 {
 			return -1, errNoUIDMap
 		}
-		id, found := c.hostIDFromMapping(int64(containerId), c.UidMappings)
+		id, found := c.hostIDFromMapping(int64(containerId), c.UIDMappings)
 		if !found {
-			return -1, errNoUserMap
+			return -1, fmt.Errorf("user namespaces enabled, but no mapping found for uid %d", containerId)
 		}
 		// If we are a 32-bit binary running on a 64-bit system, it's possible
 		// the mapped user is too large to store in an int, which means we
@@ -47,12 +58,12 @@ func (c Config) HostRootUID() (int, error) {
 // different when user namespaces are enabled.
 func (c Config) HostGID(containerId int) (int, error) {
 	if c.Namespaces.Contains(NEWUSER) {
-		if c.GidMappings == nil {
+		if len(c.GIDMappings) == 0 {
 			return -1, errNoGIDMap
 		}
-		id, found := c.hostIDFromMapping(int64(containerId), c.GidMappings)
+		id, found := c.hostIDFromMapping(int64(containerId), c.GIDMappings)
 		if !found {
-			return -1, errNoGroupMap
+			return -1, fmt.Errorf("user namespaces enabled, but no mapping found for gid %d", containerId)
 		}
 		// If we are a 32-bit binary running on a 64-bit system, it's possible
 		// the mapped user is too large to store in an int, which means we
diff --git a/vendor/github.com/opencontainers/runc/libcontainer/configs/configs_fuzzer.go b/vendor/github.com/opencontainers/runc/libcontainer/configs/configs_fuzzer.go
index bce829e29..1fd87ce6a 100644
--- a/vendor/github.com/opencontainers/runc/libcontainer/configs/configs_fuzzer.go
+++ b/vendor/github.com/opencontainers/runc/libcontainer/configs/configs_fuzzer.go
@@ -1,5 +1,4 @@
 //go:build gofuzz
-// +build gofuzz
 
 package configs
 
diff --git a/vendor/github.com/opencontainers/runc/libcontainer/configs/mount.go b/vendor/github.com/opencontainers/runc/libcontainer/configs/mount.go
index 784c61820..bfd356e49 100644
--- a/vendor/github.com/opencontainers/runc/libcontainer/configs/mount.go
+++ b/vendor/github.com/opencontainers/runc/libcontainer/configs/mount.go
@@ -1,48 +1,7 @@
 package configs
 
-import "golang.org/x/sys/unix"
-
 const (
 	// EXT_COPYUP is a directive to copy up the contents of a directory when
 	// a tmpfs is mounted over it.
-	EXT_COPYUP = 1 << iota //nolint:golint // ignore "don't use ALL_CAPS" warning
+	EXT_COPYUP = 1 << iota //nolint:golint,revive // ignore "don't use ALL_CAPS" warning
 )
-
-type Mount struct {
-	// Source path for the mount.
-	Source string `json:"source"`
-
-	// Destination path for the mount inside the container.
-	Destination string `json:"destination"`
-
-	// Device the mount is for.
-	Device string `json:"device"`
-
-	// Mount flags.
-	Flags int `json:"flags"`
-
-	// Propagation Flags
-	PropagationFlags []int `json:"propagation_flags"`
-
-	// Mount data applied to the mount.
-	Data string `json:"data"`
-
-	// Relabel source if set, "z" indicates shared, "Z" indicates unshared.
-	Relabel string `json:"relabel"`
-
-	// RecAttr represents mount properties to be applied recursively (AT_RECURSIVE), see mount_setattr(2).
-	RecAttr *unix.MountAttr `json:"rec_attr"`
-
-	// Extensions are additional flags that are specific to runc.
-	Extensions int `json:"extensions"`
-
-	// Optional Command to be run before Source is mounted.
-	PremountCmds []Command `json:"premount_cmds"`
-
-	// Optional Command to be run after Source is mounted.
-	PostmountCmds []Command `json:"postmount_cmds"`
-}
-
-func (m *Mount) IsBind() bool {
-	return m.Flags&unix.MS_BIND != 0
-}
diff --git a/vendor/github.com/opencontainers/runc/libcontainer/configs/mount_linux.go b/vendor/github.com/opencontainers/runc/libcontainer/configs/mount_linux.go
new file mode 100644
index 000000000..b69e9ab23
--- /dev/null
+++ b/vendor/github.com/opencontainers/runc/libcontainer/configs/mount_linux.go
@@ -0,0 +1,66 @@
+package configs
+
+import "golang.org/x/sys/unix"
+
+type MountIDMapping struct {
+	// Recursive indicates if the mapping needs to be recursive.
+	Recursive bool `json:"recursive"`
+
+	// UserNSPath is a path to a user namespace that indicates the necessary
+	// id-mappings for MOUNT_ATTR_IDMAP. If set to non-"", UIDMappings and
+	// GIDMappings must be set to nil.
+	UserNSPath string `json:"userns_path,omitempty"`
+
+	// UIDMappings is the uid mapping set for this mount, to be used with
+	// MOUNT_ATTR_IDMAP.
+	UIDMappings []IDMap `json:"uid_mappings,omitempty"`
+
+	// GIDMappings is the gid mapping set for this mount, to be used with
+	// MOUNT_ATTR_IDMAP.
+	GIDMappings []IDMap `json:"gid_mappings,omitempty"`
+}
+
+type Mount struct {
+	// Source path for the mount.
+	Source string `json:"source"`
+
+	// Destination path for the mount inside the container.
+	Destination string `json:"destination"`
+
+	// Device the mount is for.
+	Device string `json:"device"`
+
+	// Mount flags.
+	Flags int `json:"flags"`
+
+	// Mount flags that were explicitly cleared in the configuration (meaning
+	// the user explicitly requested that these flags *not* be set).
+	ClearedFlags int `json:"cleared_flags"`
+
+	// Propagation Flags
+	PropagationFlags []int `json:"propagation_flags"`
+
+	// Mount data applied to the mount.
+	Data string `json:"data"`
+
+	// Relabel source if set, "z" indicates shared, "Z" indicates unshared.
+	Relabel string `json:"relabel"`
+
+	// RecAttr represents mount properties to be applied recursively (AT_RECURSIVE), see mount_setattr(2).
+	RecAttr *unix.MountAttr `json:"rec_attr"`
+
+	// Extensions are additional flags that are specific to runc.
+	Extensions int `json:"extensions"`
+
+	// Mapping is the MOUNT_ATTR_IDMAP configuration for the mount. If non-nil,
+	// the mount is configured to use MOUNT_ATTR_IDMAP-style id mappings.
+	IDMapping *MountIDMapping `json:"id_mapping,omitempty"`
+}
+
+func (m *Mount) IsBind() bool {
+	return m.Flags&unix.MS_BIND != 0
+}
+
+func (m *Mount) IsIDMapped() bool {
+	return m.IDMapping != nil
+}
diff --git a/vendor/github.com/opencontainers/runc/libcontainer/configs/mount_unsupported.go b/vendor/github.com/opencontainers/runc/libcontainer/configs/mount_unsupported.go
new file mode 100644
index 000000000..1d4d9fe52
--- /dev/null
+++ b/vendor/github.com/opencontainers/runc/libcontainer/configs/mount_unsupported.go
@@ -0,0 +1,9 @@
+//go:build !linux
+
+package configs
+
+type Mount struct{}
+
+func (m *Mount) IsBind() bool {
+	return false
+}
diff --git a/vendor/github.com/opencontainers/runc/libcontainer/configs/namespaces_linux.go b/vendor/github.com/opencontainers/runc/libcontainer/configs/namespaces_linux.go
index d52d6fcd1..898f96fd0 100644
--- a/vendor/github.com/opencontainers/runc/libcontainer/configs/namespaces_linux.go
+++ b/vendor/github.com/opencontainers/runc/libcontainer/configs/namespaces_linux.go
@@ -14,6 +14,7 @@ const (
 	NEWIPC    NamespaceType = "NEWIPC"
 	NEWUSER   NamespaceType = "NEWUSER"
 	NEWCGROUP NamespaceType = "NEWCGROUP"
+	NEWTIME   NamespaceType = "NEWTIME"
 )
 
 var (
@@ -38,6 +39,8 @@ func NsName(ns NamespaceType) string {
 		return "uts"
 	case NEWCGROUP:
 		return "cgroup"
+	case NEWTIME:
+		return "time"
 	}
 	return ""
 }
@@ -56,6 +59,9 @@ func IsNamespaceSupported(ns NamespaceType) bool {
 	if nsFile == "" {
 		return false
 	}
+	// We don't need to use /proc/thread-self here because the list of
+	// namespace types is unrelated to the thread. This lets us avoid having to
+	// do runtime.LockOSThread.
 	_, err := os.Stat("/proc/self/ns/" + nsFile)
 	// a namespace is supported if it exists and we have permissions to read it
 	supported = err == nil
@@ -72,6 +78,7 @@ func NamespaceTypes() []NamespaceType {
 		NEWPID,
 		NEWNS,
 		NEWCGROUP,
+		NEWTIME,
 	}
 }
 
diff --git a/vendor/github.com/opencontainers/runc/libcontainer/configs/namespaces_syscall.go b/vendor/github.com/opencontainers/runc/libcontainer/configs/namespaces_syscall.go
index 0516dba8d..26b70b26f 100644
--- a/vendor/github.com/opencontainers/runc/libcontainer/configs/namespaces_syscall.go
+++ b/vendor/github.com/opencontainers/runc/libcontainer/configs/namespaces_syscall.go
@@ -1,5 +1,4 @@
 //go:build linux
-// +build linux
 
 package configs
 
@@ -17,6 +16,7 @@ var namespaceInfo = map[NamespaceType]int{
 	NEWUTS:    unix.CLONE_NEWUTS,
 	NEWPID:    unix.CLONE_NEWPID,
 	NEWCGROUP: unix.CLONE_NEWCGROUP,
+	NEWTIME:   unix.CLONE_NEWTIME,
 }
 
 // CloneFlags parses the container's Namespaces options to set the correct
@@ -31,3 +31,15 @@ func (n *Namespaces) CloneFlags() uintptr {
 	}
 	return uintptr(flag)
 }
+
+// IsPrivate tells whether the namespace of type t is configured as private
+// (i.e. it exists and is not shared).
+func (n Namespaces) IsPrivate(t NamespaceType) bool {
+	for _, v := range n {
+		if v.Type == t {
+			return v.Path == ""
+		}
+	}
+	// Not found, so implicitly sharing a parent namespace.
+	return false
+}
diff --git a/vendor/github.com/opencontainers/runc/libcontainer/configs/namespaces_syscall_unsupported.go b/vendor/github.com/opencontainers/runc/libcontainer/configs/namespaces_syscall_unsupported.go
index fbb0d4907..10bf24365 100644
--- a/vendor/github.com/opencontainers/runc/libcontainer/configs/namespaces_syscall_unsupported.go
+++ b/vendor/github.com/opencontainers/runc/libcontainer/configs/namespaces_syscall_unsupported.go
@@ -1,5 +1,4 @@
 //go:build !linux && !windows
-// +build !linux,!windows
 
 package configs
 
diff --git a/vendor/github.com/opencontainers/runc/libcontainer/configs/namespaces_unsupported.go b/vendor/github.com/opencontainers/runc/libcontainer/configs/namespaces_unsupported.go
index 946db30a5..914684993 100644
--- a/vendor/github.com/opencontainers/runc/libcontainer/configs/namespaces_unsupported.go
+++ b/vendor/github.com/opencontainers/runc/libcontainer/configs/namespaces_unsupported.go
@@ -1,5 +1,4 @@
 //go:build !linux
-// +build !linux
 
 package configs
 
diff --git a/vendor/github.com/opencontainers/runc/libcontainer/devices/device_unix.go b/vendor/github.com/opencontainers/runc/libcontainer/devices/device_unix.go
index 7d8e9fc31..d00775f51 100644
--- a/vendor/github.com/opencontainers/runc/libcontainer/devices/device_unix.go
+++ b/vendor/github.com/opencontainers/runc/libcontainer/devices/device_unix.go
@@ -1,5 +1,4 @@
 //go:build !windows
-// +build !windows
 
 package devices
 
diff --git a/vendor/github.com/opencontainers/runc/libcontainer/user/lookup_unix.go b/vendor/github.com/opencontainers/runc/libcontainer/user/lookup_unix.go
deleted file mode 100644
index f95c1409f..000000000
--- a/vendor/github.com/opencontainers/runc/libcontainer/user/lookup_unix.go
+++ /dev/null
@@ -1,157 +0,0 @@
-//go:build darwin || dragonfly || freebsd || linux || netbsd || openbsd || solaris
-// +build darwin dragonfly freebsd linux netbsd openbsd solaris
-
-package user
-
-import (
-	"io"
-	"os"
-	"strconv"
-
-	"golang.org/x/sys/unix"
-)
-
-// Unix-specific path to the passwd and group formatted files.
-const (
-	unixPasswdPath = "/etc/passwd"
-	unixGroupPath  = "/etc/group"
-)
-
-// LookupUser looks up a user by their username in /etc/passwd. If the user
-// cannot be found (or there is no /etc/passwd file on the filesystem), then
-// LookupUser returns an error.
-func LookupUser(username string) (User, error) {
-	return lookupUserFunc(func(u User) bool {
-		return u.Name == username
-	})
-}
-
-// LookupUid looks up a user by their user id in /etc/passwd. If the user cannot
-// be found (or there is no /etc/passwd file on the filesystem), then LookupId
-// returns an error.
-func LookupUid(uid int) (User, error) {
-	return lookupUserFunc(func(u User) bool {
-		return u.Uid == uid
-	})
-}
-
-func lookupUserFunc(filter func(u User) bool) (User, error) {
-	// Get operating system-specific passwd reader-closer.
-	passwd, err := GetPasswd()
-	if err != nil {
-		return User{}, err
-	}
-	defer passwd.Close()
-
-	// Get the users.
-	users, err := ParsePasswdFilter(passwd, filter)
-	if err != nil {
-		return User{}, err
-	}
-
-	// No user entries found.
-	if len(users) == 0 {
-		return User{}, ErrNoPasswdEntries
-	}
-
-	// Assume the first entry is the "correct" one.
-	return users[0], nil
-}
-
-// LookupGroup looks up a group by its name in /etc/group. If the group cannot
-// be found (or there is no /etc/group file on the filesystem), then LookupGroup
-// returns an error.
-func LookupGroup(groupname string) (Group, error) {
-	return lookupGroupFunc(func(g Group) bool {
-		return g.Name == groupname
-	})
-}
-
-// LookupGid looks up a group by its group id in /etc/group. If the group cannot
-// be found (or there is no /etc/group file on the filesystem), then LookupGid
-// returns an error.
-func LookupGid(gid int) (Group, error) {
-	return lookupGroupFunc(func(g Group) bool {
-		return g.Gid == gid
-	})
-}
-
-func lookupGroupFunc(filter func(g Group) bool) (Group, error) {
-	// Get operating system-specific group reader-closer.
-	group, err := GetGroup()
-	if err != nil {
-		return Group{}, err
-	}
-	defer group.Close()
-
-	// Get the users.
-	groups, err := ParseGroupFilter(group, filter)
-	if err != nil {
-		return Group{}, err
-	}
-
-	// No user entries found.
-	if len(groups) == 0 {
-		return Group{}, ErrNoGroupEntries
-	}
-
-	// Assume the first entry is the "correct" one.
-	return groups[0], nil
-}
-
-func GetPasswdPath() (string, error) {
-	return unixPasswdPath, nil
-}
-
-func GetPasswd() (io.ReadCloser, error) {
-	return os.Open(unixPasswdPath)
-}
-
-func GetGroupPath() (string, error) {
-	return unixGroupPath, nil
-}
-
-func GetGroup() (io.ReadCloser, error) {
-	return os.Open(unixGroupPath)
-}
-
-// CurrentUser looks up the current user by their user id in /etc/passwd. If the
-// user cannot be found (or there is no /etc/passwd file on the filesystem),
-// then CurrentUser returns an error.
-func CurrentUser() (User, error) {
-	return LookupUid(unix.Getuid())
-}
-
-// CurrentGroup looks up the current user's group by their primary group id's
-// entry in /etc/passwd. If the group cannot be found (or there is no
-// /etc/group file on the filesystem), then CurrentGroup returns an error.
-func CurrentGroup() (Group, error) {
-	return LookupGid(unix.Getgid())
-}
-
-func currentUserSubIDs(fileName string) ([]SubID, error) {
-	u, err := CurrentUser()
-	if err != nil {
-		return nil, err
-	}
-	filter := func(entry SubID) bool {
-		return entry.Name == u.Name || entry.Name == strconv.Itoa(u.Uid)
-	}
-	return ParseSubIDFileFilter(fileName, filter)
-}
-
-func CurrentUserSubUIDs() ([]SubID, error) {
-	return currentUserSubIDs("/etc/subuid")
-}
-
-func CurrentUserSubGIDs() ([]SubID, error) {
-	return currentUserSubIDs("/etc/subgid")
-}
-
-func CurrentProcessUIDMap() ([]IDMap, error) {
-	return ParseIDMapFile("/proc/self/uid_map")
-}
-
-func CurrentProcessGIDMap() ([]IDMap, error) {
-	return ParseIDMapFile("/proc/self/gid_map")
-}
diff --git a/vendor/github.com/opencontainers/runc/libcontainer/user/user.go b/vendor/github.com/opencontainers/runc/libcontainer/user/user.go
deleted file mode 100644
index 198c49367..000000000
--- a/vendor/github.com/opencontainers/runc/libcontainer/user/user.go
+++ /dev/null
@@ -1,604 +0,0 @@
-package user
-
-import (
-	"bufio"
-	"bytes"
-	"errors"
-	"fmt"
-	"io"
-	"os"
-	"strconv"
-	"strings"
-)
-
-const (
-	minID = 0
-	maxID = 1<<31 - 1 // for 32-bit systems compatibility
-)
-
-var (
-	// ErrNoPasswdEntries is returned if no matching entries were found in /etc/group.
-	ErrNoPasswdEntries = errors.New("no matching entries in passwd file")
-	// ErrNoGroupEntries is returned if no matching entries were found in /etc/passwd.
-	ErrNoGroupEntries = errors.New("no matching entries in group file")
-	// ErrRange is returned if a UID or GID is outside of the valid range.
-	ErrRange = fmt.Errorf("uids and gids must be in range %d-%d", minID, maxID)
-)
-
-type User struct {
-	Name  string
-	Pass  string
-	Uid   int
-	Gid   int
-	Gecos string
-	Home  string
-	Shell string
-}
-
-type Group struct {
-	Name string
-	Pass string
-	Gid  int
-	List []string
-}
-
-// SubID represents an entry in /etc/sub{u,g}id
-type SubID struct {
-	Name  string
-	SubID int64
-	Count int64
-}
-
-// IDMap represents an entry in /proc/PID/{u,g}id_map
-type IDMap struct {
-	ID       int64
-	ParentID int64
-	Count    int64
-}
-
-func parseLine(line []byte, v ...interface{}) {
-	parseParts(bytes.Split(line, []byte(":")), v...)
-}
-
-func parseParts(parts [][]byte, v ...interface{}) {
-	if len(parts) == 0 {
-		return
-	}
-
-	for i, p := range parts {
-		// Ignore cases where we don't have enough fields to populate the arguments.
-		// Some configuration files like to misbehave.
-		if len(v) <= i {
-			break
-		}
-
-		// Use the type of the argument to figure out how to parse it, scanf() style.
-		// This is legit.
-		switch e := v[i].(type) {
-		case *string:
-			*e = string(p)
-		case *int:
-			// "numbers", with conversion errors ignored because of some misbehaving configuration files.
-			*e, _ = strconv.Atoi(string(p))
-		case *int64:
-			*e, _ = strconv.ParseInt(string(p), 10, 64)
-		case *[]string:
-			// Comma-separated lists.
-			if len(p) != 0 {
-				*e = strings.Split(string(p), ",")
-			} else {
-				*e = []string{}
-			}
-		default:
-			// Someone goof'd when writing code using this function. Scream so they can hear us.
-			panic(fmt.Sprintf("parseLine only accepts {*string, *int, *int64, *[]string} as arguments! %#v is not a pointer!", e))
-		}
-	}
-}
-
-func ParsePasswdFile(path string) ([]User, error) {
-	passwd, err := os.Open(path)
-	if err != nil {
-		return nil, err
-	}
-	defer passwd.Close()
-	return ParsePasswd(passwd)
-}
-
-func ParsePasswd(passwd io.Reader) ([]User, error) {
-	return ParsePasswdFilter(passwd, nil)
-}
-
-func ParsePasswdFileFilter(path string, filter func(User) bool) ([]User, error) {
-	passwd, err := os.Open(path)
-	if err != nil {
-		return nil, err
-	}
-	defer passwd.Close()
-	return ParsePasswdFilter(passwd, filter)
-}
-
-func ParsePasswdFilter(r io.Reader, filter func(User) bool) ([]User, error) {
-	if r == nil {
-		return nil, errors.New("nil source for passwd-formatted data")
-	}
-
-	var (
-		s   = bufio.NewScanner(r)
-		out = []User{}
-	)
-
-	for s.Scan() {
-		line := bytes.TrimSpace(s.Bytes())
-		if len(line) == 0 {
-			continue
-		}
-
-		// see: man 5 passwd
-		//  name:password:UID:GID:GECOS:directory:shell
-		// Name:Pass:Uid:Gid:Gecos:Home:Shell
-		//  root:x:0:0:root:/root:/bin/bash
-		//  adm:x:3:4:adm:/var/adm:/bin/false
-		p := User{}
-		parseLine(line, &p.Name, &p.Pass, &p.Uid, &p.Gid, &p.Gecos, &p.Home, &p.Shell)
-
-		if filter == nil || filter(p) {
-			out = append(out, p)
-		}
-	}
-	if err := s.Err(); err != nil {
-		return nil, err
-	}
-
-	return out, nil
-}
-
-func ParseGroupFile(path string) ([]Group, error) {
-	group, err := os.Open(path)
-	if err != nil {
-		return nil, err
-	}
-
-	defer group.Close()
-	return ParseGroup(group)
-}
-
-func ParseGroup(group io.Reader) ([]Group, error) {
-	return ParseGroupFilter(group, nil)
-}
-
-func ParseGroupFileFilter(path string, filter func(Group) bool) ([]Group, error) {
-	group, err := os.Open(path)
-	if err != nil {
-		return nil, err
-	}
-	defer group.Close()
-	return ParseGroupFilter(group, filter)
-}
-
-func ParseGroupFilter(r io.Reader, filter func(Group) bool) ([]Group, error) {
-	if r == nil {
-		return nil, errors.New("nil source for group-formatted data")
-	}
-	rd := bufio.NewReader(r)
-	out := []Group{}
-
-	// Read the file line-by-line.
-	for {
-		var (
-			isPrefix  bool
-			wholeLine []byte
-			err       error
-		)
-
-		// Read the next line. We do so in chunks (as much as reader's
-		// buffer is able to keep), check if we read enough columns
-		// already on each step and store final result in wholeLine.
-		for {
-			var line []byte
-			line, isPrefix, err = rd.ReadLine()
-			if err != nil {
-				// We should return no error if EOF is reached
-				// without a match.
-				if err == io.EOF {
-					err = nil
-				}
-				return out, err
-			}
-
-			// Simple common case: line is short enough to fit in a
-			// single reader's buffer.
-			if !isPrefix && len(wholeLine) == 0 {
-				wholeLine = line
-				break
-			}
-
-			wholeLine = append(wholeLine, line...)
-
-			// Check if we read the whole line already.
-			if !isPrefix {
-				break
-			}
-		}
-
-		// There's no spec for /etc/passwd or /etc/group, but we try to follow
-		// the same rules as the glibc parser, which allows comments and blank
-		// space at the beginning of a line.
-		wholeLine = bytes.TrimSpace(wholeLine)
-		if len(wholeLine) == 0 || wholeLine[0] == '#' {
-			continue
-		}
-
-		// see: man 5 group
-		//  group_name:password:GID:user_list
-		// Name:Pass:Gid:List
-		//  root:x:0:root
-		//  adm:x:4:root,adm,daemon
-		p := Group{}
-		parseLine(wholeLine, &p.Name, &p.Pass, &p.Gid, &p.List)
-
-		if filter == nil || filter(p) {
-			out = append(out, p)
-		}
-	}
-}
-
-type ExecUser struct {
-	Uid   int
-	Gid   int
-	Sgids []int
-	Home  string
-}
-
-// GetExecUserPath is a wrapper for GetExecUser. It reads data from each of the
-// given file paths and uses that data as the arguments to GetExecUser. If the
-// files cannot be opened for any reason, the error is ignored and a nil
-// io.Reader is passed instead.
-func GetExecUserPath(userSpec string, defaults *ExecUser, passwdPath, groupPath string) (*ExecUser, error) {
-	var passwd, group io.Reader
-
-	if passwdFile, err := os.Open(passwdPath); err == nil {
-		passwd = passwdFile
-		defer passwdFile.Close()
-	}
-
-	if groupFile, err := os.Open(groupPath); err == nil {
-		group = groupFile
-		defer groupFile.Close()
-	}
-
-	return GetExecUser(userSpec, defaults, passwd, group)
-}
-
-// GetExecUser parses a user specification string (using the passwd and group
-// readers as sources for /etc/passwd and /etc/group data, respectively). In
-// the case of blank fields or missing data from the sources, the values in
-// defaults is used.
-//
-// GetExecUser will return an error if a user or group literal could not be
-// found in any entry in passwd and group respectively.
-//
-// Examples of valid user specifications are:
-//   - ""
-//   - "user"
-//   - "uid"
-//   - "user:group"
-//   - "uid:gid
-//   - "user:gid"
-//   - "uid:group"
-//
-// It should be noted that if you specify a numeric user or group id, they will
-// not be evaluated as usernames (only the metadata will be filled). So attempting
-// to parse a user with user.Name = "1337" will produce the user with a UID of
-// 1337.
-func GetExecUser(userSpec string, defaults *ExecUser, passwd, group io.Reader) (*ExecUser, error) {
-	if defaults == nil {
-		defaults = new(ExecUser)
-	}
-
-	// Copy over defaults.
-	user := &ExecUser{
-		Uid:   defaults.Uid,
-		Gid:   defaults.Gid,
-		Sgids: defaults.Sgids,
-		Home:  defaults.Home,
-	}
-
-	// Sgids slice *cannot* be nil.
-	if user.Sgids == nil {
-		user.Sgids = []int{}
-	}
-
-	// Allow for userArg to have either "user" syntax, or optionally "user:group" syntax
-	var userArg, groupArg string
-	parseLine([]byte(userSpec), &userArg, &groupArg)
-
-	// Convert userArg and groupArg to be numeric, so we don't have to execute
-	// Atoi *twice* for each iteration over lines.
-	uidArg, uidErr := strconv.Atoi(userArg)
-	gidArg, gidErr := strconv.Atoi(groupArg)
-
-	// Find the matching user.
-	users, err := ParsePasswdFilter(passwd, func(u User) bool {
-		if userArg == "" {
-			// Default to current state of the user.
-			return u.Uid == user.Uid
-		}
-
-		if uidErr == nil {
-			// If the userArg is numeric, always treat it as a UID.
-			return uidArg == u.Uid
-		}
-
-		return u.Name == userArg
-	})
-
-	// If we can't find the user, we have to bail.
-	if err != nil && passwd != nil {
-		if userArg == "" {
-			userArg = strconv.Itoa(user.Uid)
-		}
-		return nil, fmt.Errorf("unable to find user %s: %w", userArg, err)
-	}
-
-	var matchedUserName string
-	if len(users) > 0 {
-		// First match wins, even if there's more than one matching entry.
-		matchedUserName = users[0].Name
-		user.Uid = users[0].Uid
-		user.Gid = users[0].Gid
-		user.Home = users[0].Home
-	} else if userArg != "" {
-		// If we can't find a user with the given username, the only other valid
-		// option is if it's a numeric username with no associated entry in passwd.
-
-		if uidErr != nil {
-			// Not numeric.
-			return nil, fmt.Errorf("unable to find user %s: %w", userArg, ErrNoPasswdEntries)
-		}
-		user.Uid = uidArg
-
-		// Must be inside valid uid range.
-		if user.Uid < minID || user.Uid > maxID {
-			return nil, ErrRange
-		}
-
-		// Okay, so it's numeric. We can just roll with this.
-	}
-
-	// On to the groups. If we matched a username, we need to do this because of
-	// the supplementary group IDs.
-	if groupArg != "" || matchedUserName != "" {
-		groups, err := ParseGroupFilter(group, func(g Group) bool {
-			// If the group argument isn't explicit, we'll just search for it.
-			if groupArg == "" {
-				// Check if user is a member of this group.
-				for _, u := range g.List {
-					if u == matchedUserName {
-						return true
-					}
-				}
-				return false
-			}
-
-			if gidErr == nil {
-				// If the groupArg is numeric, always treat it as a GID.
-				return gidArg == g.Gid
-			}
-
-			return g.Name == groupArg
-		})
-		if err != nil && group != nil {
-			return nil, fmt.Errorf("unable to find groups for spec %v: %w", matchedUserName, err)
-		}
-
-		// Only start modifying user.Gid if it is in explicit form.
-		if groupArg != "" {
-			if len(groups) > 0 {
-				// First match wins, even if there's more than one matching entry.
-				user.Gid = groups[0].Gid
-			} else {
-				// If we can't find a group with the given name, the only other valid
-				// option is if it's a numeric group name with no associated entry in group.
-
-				if gidErr != nil {
-					// Not numeric.
-					return nil, fmt.Errorf("unable to find group %s: %w", groupArg, ErrNoGroupEntries)
-				}
-				user.Gid = gidArg
-
-				// Must be inside valid gid range.
-				if user.Gid < minID || user.Gid > maxID {
-					return nil, ErrRange
-				}
-
-				// Okay, so it's numeric. We can just roll with this.
-			}
-		} else if len(groups) > 0 {
-			// Supplementary group ids only make sense if in the implicit form.
-			user.Sgids = make([]int, len(groups))
-			for i, group := range groups {
-				user.Sgids[i] = group.Gid
-			}
-		}
-	}
-
-	return user, nil
-}
-
-// GetAdditionalGroups looks up a list of groups by name or group id
-// against the given /etc/group formatted data. If a group name cannot
-// be found, an error will be returned. If a group id cannot be found,
-// or the given group data is nil, the id will be returned as-is
-// provided it is in the legal range.
-func GetAdditionalGroups(additionalGroups []string, group io.Reader) ([]int, error) {
-	groups := []Group{}
-	if group != nil {
-		var err error
-		groups, err = ParseGroupFilter(group, func(g Group) bool {
-			for _, ag := range additionalGroups {
-				if g.Name == ag || strconv.Itoa(g.Gid) == ag {
-					return true
-				}
-			}
-			return false
-		})
-		if err != nil {
-			return nil, fmt.Errorf("Unable to find additional groups %v: %w", additionalGroups, err)
-		}
-	}
-
-	gidMap := make(map[int]struct{})
-	for _, ag := range additionalGroups {
-		var found bool
-		for _, g := range groups {
-			// if we found a matched group either by name or gid, take the
-			// first matched as correct
-			if g.Name == ag || strconv.Itoa(g.Gid) == ag {
-				if _, ok := gidMap[g.Gid]; !ok {
-					gidMap[g.Gid] = struct{}{}
-					found = true
-					break
-				}
-			}
-		}
-		// we asked for a group but didn't find it. let's check to see
-		// if we wanted a numeric group
-		if !found {
-			gid, err := strconv.ParseInt(ag, 10, 64)
-			if err != nil {
-				// Not a numeric ID either.
-				return nil, fmt.Errorf("Unable to find group %s: %w", ag, ErrNoGroupEntries)
-			}
-			// Ensure gid is inside gid range.
-			if gid < minID || gid > maxID {
-				return nil, ErrRange
-			}
-			gidMap[int(gid)] = struct{}{}
-		}
-	}
-	gids := []int{}
-	for gid := range gidMap {
-		gids = append(gids, gid)
-	}
-	return gids, nil
-}
-
-// GetAdditionalGroupsPath is a wrapper around GetAdditionalGroups
-// that opens the groupPath given and gives it as an argument to
-// GetAdditionalGroups.
-func GetAdditionalGroupsPath(additionalGroups []string, groupPath string) ([]int, error) {
-	var group io.Reader
-
-	if groupFile, err := os.Open(groupPath); err == nil {
-		group = groupFile
-		defer groupFile.Close()
-	}
-	return GetAdditionalGroups(additionalGroups, group)
-}
-
-func ParseSubIDFile(path string) ([]SubID, error) {
-	subid, err := os.Open(path)
-	if err != nil {
-		return nil, err
-	}
-	defer subid.Close()
-	return ParseSubID(subid)
-}
-
-func ParseSubID(subid io.Reader) ([]SubID, error) {
-	return ParseSubIDFilter(subid, nil)
-}
-
-func ParseSubIDFileFilter(path string, filter func(SubID) bool) ([]SubID, error) {
-	subid, err := os.Open(path)
-	if err != nil {
-		return nil, err
-	}
-	defer subid.Close()
-	return ParseSubIDFilter(subid, filter)
-}
-
-func ParseSubIDFilter(r io.Reader, filter func(SubID) bool) ([]SubID, error) {
-	if r == nil {
-		return nil, errors.New("nil source for subid-formatted data")
-	}
-
-	var (
-		s   = bufio.NewScanner(r)
-		out = []SubID{}
-	)
-
-	for s.Scan() {
-		line := bytes.TrimSpace(s.Bytes())
-		if len(line) == 0 {
-			continue
-		}
-
-		// see: man 5 subuid
-		p := SubID{}
-		parseLine(line, &p.Name, &p.SubID, &p.Count)
-
-		if filter == nil || filter(p) {
-			out = append(out, p)
-		}
-	}
-	if err := s.Err(); err != nil {
-		return nil, err
-	}
-
-	return out, nil
-}
-
-func ParseIDMapFile(path string) ([]IDMap, error) {
-	r, err := os.Open(path)
-	if err != nil {
-		return nil, err
-	}
-	defer r.Close()
-	return ParseIDMap(r)
-}
-
-func ParseIDMap(r io.Reader) ([]IDMap, error) {
-	return ParseIDMapFilter(r, nil)
-}
-
-func ParseIDMapFileFilter(path string, filter func(IDMap) bool) ([]IDMap, error) {
-	r, err := os.Open(path)
-	if err != nil {
-		return nil, err
-	}
-	defer r.Close()
-	return ParseIDMapFilter(r, filter)
-}
-
-func ParseIDMapFilter(r io.Reader, filter func(IDMap) bool) ([]IDMap, error) {
-	if r == nil {
-		return nil, errors.New("nil source for idmap-formatted data")
-	}
-
-	var (
-		s   = bufio.NewScanner(r)
-		out = []IDMap{}
-	)
-
-	for s.Scan() {
-		line := bytes.TrimSpace(s.Bytes())
-		if len(line) == 0 {
-			continue
-		}
-
-		// see: man 7 user_namespaces
-		p := IDMap{}
-		parseParts(bytes.Fields(line), &p.ID, &p.ParentID, &p.Count)
-
-		if filter == nil || filter(p) {
-			out = append(out, p)
-		}
-	}
-	if err := s.Err(); err != nil {
-		return nil, err
-	}
-
-	return out, nil
-}
diff --git a/vendor/github.com/opencontainers/runc/libcontainer/user/user_fuzzer.go b/vendor/github.com/opencontainers/runc/libcontainer/user/user_fuzzer.go
deleted file mode 100644
index e018eae61..000000000
--- a/vendor/github.com/opencontainers/runc/libcontainer/user/user_fuzzer.go
+++ /dev/null
@@ -1,43 +0,0 @@
-//go:build gofuzz
-// +build gofuzz
-
-package user
-
-import (
-	"io"
-	"strings"
-)
-
-func IsDivisbleBy(n int, divisibleby int) bool {
-	return (n % divisibleby) == 0
-}
-
-func FuzzUser(data []byte) int {
-	if len(data) == 0 {
-		return -1
-	}
-	if !IsDivisbleBy(len(data), 5) {
-		return -1
-	}
-
-	var divided [][]byte
-
-	chunkSize := len(data) / 5
-
-	for i := 0; i < len(data); i += chunkSize {
-		end := i + chunkSize
-
-		divided = append(divided, data[i:end])
-	}
-
-	_, _ = ParsePasswdFilter(strings.NewReader(string(divided[0])), nil)
-
-	var passwd, group io.Reader
-
-	group = strings.NewReader(string(divided[1]))
-	_, _ = GetAdditionalGroups([]string{string(divided[2])}, group)
-
-	passwd = strings.NewReader(string(divided[3]))
-	_, _ = GetExecUser(string(divided[4]), nil, passwd, group)
-	return 1
-}
diff --git a/vendor/github.com/opencontainers/runc/libcontainer/userns/userns.go b/vendor/github.com/opencontainers/runc/libcontainer/userns/userns.go
index f6cb98e5e..a07afe07b 100644
--- a/vendor/github.com/opencontainers/runc/libcontainer/userns/userns.go
+++ b/vendor/github.com/opencontainers/runc/libcontainer/userns/userns.go
@@ -1,5 +1,8 @@
 package userns
 
-// RunningInUserNS detects whether we are currently running in a user namespace.
-// Originally copied from github.com/lxc/lxd/shared/util.go
-var RunningInUserNS = runningInUserNS
+// RunningInUserNS detects whether we are currently running in a Linux
+// user namespace and memoizes the result. It returns false on non-Linux
+// platforms.
+func RunningInUserNS() bool {
+	return inUserNS()
+}
diff --git a/vendor/github.com/opencontainers/runc/libcontainer/userns/userns_fuzzer.go b/vendor/github.com/opencontainers/runc/libcontainer/userns/userns_fuzzer.go
deleted file mode 100644
index 1e00ab8b5..000000000
--- a/vendor/github.com/opencontainers/runc/libcontainer/userns/userns_fuzzer.go
+++ /dev/null
@@ -1,16 +0,0 @@
-//go:build gofuzz
-// +build gofuzz
-
-package userns
-
-import (
-	"strings"
-
-	"github.com/opencontainers/runc/libcontainer/user"
-)
-
-func FuzzUIDMap(data []byte) int {
-	uidmap, _ := user.ParseIDMap(strings.NewReader(string(data)))
-	_ = uidMapInUserNS(uidmap)
-	return 1
-}
diff --git a/vendor/github.com/opencontainers/runc/libcontainer/userns/userns_linux.go b/vendor/github.com/opencontainers/runc/libcontainer/userns/userns_linux.go
index 724e6df01..a1462e13b 100644
--- a/vendor/github.com/opencontainers/runc/libcontainer/userns/userns_linux.go
+++ b/vendor/github.com/opencontainers/runc/libcontainer/userns/userns_linux.go
@@ -1,37 +1,49 @@
 package userns
 
 import (
+	"bufio"
+	"fmt"
+	"os"
 	"sync"
-
-	"github.com/opencontainers/runc/libcontainer/user"
 )
 
-var (
-	inUserNS bool
-	nsOnce   sync.Once
-)
+var inUserNS = sync.OnceValue(runningInUserNS)
 
 // runningInUserNS detects whether we are currently running in a user namespace.
-// Originally copied from github.com/lxc/lxd/shared/util.go
+//
+// Originally copied from https://github.com/lxc/incus/blob/e45085dd42f826b3c8c3228e9733c0b6f998eafe/shared/util.go#L678-L700.
 func runningInUserNS() bool {
-	nsOnce.Do(func() {
-		uidmap, err := user.CurrentProcessUIDMap()
-		if err != nil {
-			// This kernel-provided file only exists if user namespaces are supported
-			return
-		}
-		inUserNS = uidMapInUserNS(uidmap)
-	})
-	return inUserNS
+	file, err := os.Open("/proc/self/uid_map")
+	if err != nil {
+		// This kernel-provided file only exists if user namespaces are supported.
+		return false
+	}
+	defer file.Close()
+
+	buf := bufio.NewReader(file)
+	l, _, err := buf.ReadLine()
+	if err != nil {
+		return false
+	}
+
+	return uidMapInUserNS(string(l))
 }
 
-func uidMapInUserNS(uidmap []user.IDMap) bool {
-	/*
-	 * We assume we are in the initial user namespace if we have a full
-	 * range - 4294967295 uids starting at uid 0.
-	 */
-	if len(uidmap) == 1 && uidmap[0].ID == 0 && uidmap[0].ParentID == 0 && uidmap[0].Count == 4294967295 {
+func uidMapInUserNS(uidMap string) bool {
+	if uidMap == "" {
+		// File exist but empty (the initial state when userns is created,
+		// see user_namespaces(7)).
+		return true
+	}
+
+	var a, b, c int64
+	if _, err := fmt.Sscanf(uidMap, "%d %d %d", &a, &b, &c); err != nil {
+		// Assume we are in a regular, non user namespace.
 		return false
 	}
-	return true
+
+	// As per user_namespaces(7), /proc/self/uid_map of
+	// the initial user namespace shows 0 0 4294967295.
+	initNS := a == 0 && b == 0 && c == 4294967295
+	return !initNS
 }
diff --git a/vendor/github.com/opencontainers/runc/libcontainer/userns/userns_linux_fuzzer.go b/vendor/github.com/opencontainers/runc/libcontainer/userns/userns_linux_fuzzer.go
new file mode 100644
index 000000000..26ba2e16e
--- /dev/null
+++ b/vendor/github.com/opencontainers/runc/libcontainer/userns/userns_linux_fuzzer.go
@@ -0,0 +1,8 @@
+//go:build linux && gofuzz
+
+package userns
+
+func FuzzUIDMap(uidmap []byte) int {
+	_ = uidMapInUserNS(string(uidmap))
+	return 1
+}
diff --git a/vendor/github.com/opencontainers/runc/libcontainer/userns/userns_maps.c b/vendor/github.com/opencontainers/runc/libcontainer/userns/userns_maps.c
deleted file mode 100644
index 84f2c6188..000000000
--- a/vendor/github.com/opencontainers/runc/libcontainer/userns/userns_maps.c
+++ /dev/null
@@ -1,79 +0,0 @@
-#define _GNU_SOURCE
-#include <fcntl.h>
-#include <sched.h>
-#include <stdio.h>
-#include <unistd.h>
-#include <stdarg.h>
-#include <stdlib.h>
-
-/*
- * All of the code here is run inside an aync-signal-safe context, so we need
- * to be careful to not call any functions that could cause issues. In theory,
- * since we are a Go program, there are fewer restrictions in practice, it's
- * better to be safe than sorry.
- *
- * The only exception is exit, which we need to call to make sure we don't
- * return into runc.
- */
-
-void bail(int pipefd, const char *fmt, ...)
-{
-	va_list args;
-
-	va_start(args, fmt);
-	vdprintf(pipefd, fmt, args);
-	va_end(args);
-
-	exit(1);
-}
-
-int spawn_userns_cat(char *userns_path, char *path, int outfd, int errfd)
-{
-	char buffer[4096] = { 0 };
-
-	pid_t child = fork();
-	if (child != 0)
-		return child;
-	/* in child */
-
-	/* Join the target userns. */
-	int nsfd = open(userns_path, O_RDONLY);
-	if (nsfd < 0)
-		bail(errfd, "open userns path %s failed: %m", userns_path);
-
-	int err = setns(nsfd, CLONE_NEWUSER);
-	if (err < 0)
-		bail(errfd, "setns %s failed: %m", userns_path);
-
-	close(nsfd);
-
-	/* Pipe the requested file contents. */
-	int fd = open(path, O_RDONLY);
-	if (fd < 0)
-		bail(errfd, "open %s in userns %s failed: %m", path, userns_path);
-
-	int nread, ntotal = 0;
-	while ((nread = read(fd, buffer, sizeof(buffer))) != 0) {
-		if (nread < 0)
-			bail(errfd, "read bytes from %s failed (after %d total bytes read): %m", path, ntotal);
-		ntotal += nread;
-
-		int nwritten = 0;
-		while (nwritten < nread) {
-			int n = write(outfd, buffer, nread - nwritten);
-			if (n < 0)
-				bail(errfd, "write %d bytes from %s failed (after %d bytes written): %m",
-				     nread - nwritten, path, nwritten);
-			nwritten += n;
-		}
-		if (nread != nwritten)
-			bail(errfd, "mismatch for bytes read and written: %d read != %d written", nread, nwritten);
-	}
-
-	close(fd);
-	close(outfd);
-	close(errfd);
-
-	/* We must exit here, otherwise we would return into a forked runc. */
-	exit(0);
-}
diff --git a/vendor/github.com/opencontainers/runc/libcontainer/userns/userns_maps_linux.go b/vendor/github.com/opencontainers/runc/libcontainer/userns/userns_maps_linux.go
deleted file mode 100644
index 7a8c2b023..000000000
--- a/vendor/github.com/opencontainers/runc/libcontainer/userns/userns_maps_linux.go
+++ /dev/null
@@ -1,186 +0,0 @@
-//go:build linux
-
-package userns
-
-import (
-	"bufio"
-	"bytes"
-	"fmt"
-	"io"
-	"os"
-	"unsafe"
-
-	"github.com/opencontainers/runc/libcontainer/configs"
-	"github.com/sirupsen/logrus"
-)
-
-/*
-#include <stdlib.h>
-extern int spawn_userns_cat(char *userns_path, char *path, int outfd, int errfd);
-*/
-import "C"
-
-func parseIdmapData(data []byte) (ms []configs.IDMap, err error) {
-	scanner := bufio.NewScanner(bytes.NewReader(data))
-	for scanner.Scan() {
-		var m configs.IDMap
-		line := scanner.Text()
-		if _, err := fmt.Sscanf(line, "%d %d %d", &m.ContainerID, &m.HostID, &m.Size); err != nil {
-			return nil, fmt.Errorf("parsing id map failed: invalid format in line %q: %w", line, err)
-		}
-		ms = append(ms, m)
-	}
-	if err := scanner.Err(); err != nil {
-		return nil, fmt.Errorf("parsing id map failed: %w", err)
-	}
-	return ms, nil
-}
-
-// Do something equivalent to nsenter --user=<nsPath> cat <path>, but more
-// efficiently. Returns the contents of the requested file from within the user
-// namespace.
-func spawnUserNamespaceCat(nsPath string, path string) ([]byte, error) {
-	rdr, wtr, err := os.Pipe()
-	if err != nil {
-		return nil, fmt.Errorf("create pipe for userns spawn failed: %w", err)
-	}
-	defer rdr.Close()
-	defer wtr.Close()
-
-	errRdr, errWtr, err := os.Pipe()
-	if err != nil {
-		return nil, fmt.Errorf("create error pipe for userns spawn failed: %w", err)
-	}
-	defer errRdr.Close()
-	defer errWtr.Close()
-
-	cNsPath := C.CString(nsPath)
-	defer C.free(unsafe.Pointer(cNsPath))
-	cPath := C.CString(path)
-	defer C.free(unsafe.Pointer(cPath))
-
-	childPid := C.spawn_userns_cat(cNsPath, cPath, C.int(wtr.Fd()), C.int(errWtr.Fd()))
-
-	if childPid < 0 {
-		return nil, fmt.Errorf("failed to spawn fork for userns")
-	} else if childPid == 0 {
-		// this should never happen
-		panic("runc executing inside fork child -- unsafe state!")
-	}
-
-	// We are in the parent -- close the write end of the pipe before reading.
-	wtr.Close()
-	output, err := io.ReadAll(rdr)
-	rdr.Close()
-	if err != nil {
-		return nil, fmt.Errorf("reading from userns spawn failed: %w", err)
-	}
-
-	// Ditto for the error pipe.
-	errWtr.Close()
-	errOutput, err := io.ReadAll(errRdr)
-	errRdr.Close()
-	if err != nil {
-		return nil, fmt.Errorf("reading from userns spawn error pipe failed: %w", err)
-	}
-	errOutput = bytes.TrimSpace(errOutput)
-
-	// Clean up the child.
-	child, err := os.FindProcess(int(childPid))
-	if err != nil {
-		return nil, fmt.Errorf("could not find userns spawn process: %w", err)
-	}
-	state, err := child.Wait()
-	if err != nil {
-		return nil, fmt.Errorf("failed to wait for userns spawn process: %w", err)
-	}
-	if !state.Success() {
-		errStr := string(errOutput)
-		if errStr == "" {
-			errStr = fmt.Sprintf("unknown error (status code %d)", state.ExitCode())
-		}
-		return nil, fmt.Errorf("userns spawn: %s", errStr)
-	} else if len(errOutput) > 0 {
-		// We can just ignore weird output in the error pipe if the process
-		// didn't bail(), but for completeness output for debugging.
-		logrus.Debugf("userns spawn succeeded but unexpected error message found: %s", string(errOutput))
-	}
-	// The subprocess succeeded, return whatever it wrote to the pipe.
-	return output, nil
-}
-
-func GetUserNamespaceMappings(nsPath string) (uidMap, gidMap []configs.IDMap, err error) {
-	var (
-		pid         int
-		extra       rune
-		tryFastPath bool
-	)
-
-	// nsPath is usually of the form /proc/<pid>/ns/user, which means that we
-	// already have a pid that is part of the user namespace and thus we can
-	// just use the pid to read from /proc/<pid>/*id_map.
-	//
-	// Note that Sscanf doesn't consume the whole input, so we check for any
-	// trailing data with %c. That way, we can be sure the pattern matched
-	// /proc/$pid/ns/user _exactly_ iff n === 1.
-	if n, _ := fmt.Sscanf(nsPath, "/proc/%d/ns/user%c", &pid, &extra); n == 1 {
-		tryFastPath = pid > 0
-	}
-
-	for _, mapType := range []struct {
-		name  string
-		idMap *[]configs.IDMap
-	}{
-		{"uid_map", &uidMap},
-		{"gid_map", &gidMap},
-	} {
-		var mapData []byte
-
-		if tryFastPath {
-			path := fmt.Sprintf("/proc/%d/%s", pid, mapType.name)
-			data, err := os.ReadFile(path)
-			if err != nil {
-				// Do not error out here -- we need to try the slow path if the
-				// fast path failed.
-				logrus.Debugf("failed to use fast path to read %s from userns %s (error: %s), falling back to slow userns-join path", mapType.name, nsPath, err)
-			} else {
-				mapData = data
-			}
-		} else {
-			logrus.Debugf("cannot use fast path to read %s from userns %s, falling back to slow userns-join path", mapType.name, nsPath)
-		}
-
-		if mapData == nil {
-			// We have to actually join the namespace if we cannot take the
-			// fast path. The path is resolved with respect to the child
-			// process, so just use /proc/self.
-			data, err := spawnUserNamespaceCat(nsPath, "/proc/self/"+mapType.name)
-			if err != nil {
-				return nil, nil, err
-			}
-			mapData = data
-		}
-		idMap, err := parseIdmapData(mapData)
-		if err != nil {
-			return nil, nil, fmt.Errorf("failed to parse %s of userns %s: %w", mapType.name, nsPath, err)
-		}
-		*mapType.idMap = idMap
-	}
-
-	return uidMap, gidMap, nil
-}
-
-// IsSameMapping returns whether or not the two id mappings are the same. Note
-// that if the order of the mappings is different, or a mapping has been split,
-// the mappings will be considered different.
-func IsSameMapping(a, b []configs.IDMap) bool {
-	if len(a) != len(b) {
-		return false
-	}
-	for idx := range a {
-		if a[idx] != b[idx] {
-			return false
-		}
-	}
-	return true
-}
diff --git a/vendor/github.com/opencontainers/runc/libcontainer/userns/userns_unsupported.go b/vendor/github.com/opencontainers/runc/libcontainer/userns/userns_unsupported.go
index f35c13a10..8ed83072c 100644
--- a/vendor/github.com/opencontainers/runc/libcontainer/userns/userns_unsupported.go
+++ b/vendor/github.com/opencontainers/runc/libcontainer/userns/userns_unsupported.go
@@ -1,18 +1,6 @@
 //go:build !linux
-// +build !linux
 
 package userns
 
-import "github.com/opencontainers/runc/libcontainer/user"
-
-// runningInUserNS is a stub for non-Linux systems
-// Always returns false
-func runningInUserNS() bool {
-	return false
-}
-
-// uidMapInUserNS is a stub for non-Linux systems
-// Always returns false
-func uidMapInUserNS(uidmap []user.IDMap) bool {
-	return false
-}
+// inUserNS is a stub for non-Linux systems. Always returns false.
+func inUserNS() bool { return false }
diff --git a/vendor/github.com/opencontainers/runc/libcontainer/utils/cmsg.go b/vendor/github.com/opencontainers/runc/libcontainer/utils/cmsg.go
index 7ef9da21f..2edd1417a 100644
--- a/vendor/github.com/opencontainers/runc/libcontainer/utils/cmsg.go
+++ b/vendor/github.com/opencontainers/runc/libcontainer/utils/cmsg.go
@@ -19,13 +19,14 @@ package utils
 import (
 	"fmt"
 	"os"
+	"runtime"
 
 	"golang.org/x/sys/unix"
 )
 
-// MaxSendfdLen is the maximum length of the name of a file descriptor being
-// sent using SendFd. The name of the file handle returned by RecvFd will never
-// be larger than this value.
+// MaxNameLen is the maximum length of the name of a file descriptor being sent
+// using SendFile. The name of the file handle returned by RecvFile will never be
+// larger than this value.
 const MaxNameLen = 4096
 
 // oobSpace is the size of the oob slice required to store a single FD. Note
@@ -33,26 +34,21 @@ const MaxNameLen = 4096
 // so sizeof(fd) = 4.
 var oobSpace = unix.CmsgSpace(4)
 
-// RecvFd waits for a file descriptor to be sent over the given AF_UNIX
+// RecvFile waits for a file descriptor to be sent over the given AF_UNIX
 // socket. The file name of the remote file descriptor will be recreated
 // locally (it is sent as non-auxiliary data in the same payload).
-func RecvFd(socket *os.File) (*os.File, error) {
-	// For some reason, unix.Recvmsg uses the length rather than the capacity
-	// when passing the msg_controllen and other attributes to recvmsg.  So we
-	// have to actually set the length.
+func RecvFile(socket *os.File) (_ *os.File, Err error) {
 	name := make([]byte, MaxNameLen)
 	oob := make([]byte, oobSpace)
 
 	sockfd := socket.Fd()
-	n, oobn, _, _, err := unix.Recvmsg(int(sockfd), name, oob, 0)
+	n, oobn, _, _, err := unix.Recvmsg(int(sockfd), name, oob, unix.MSG_CMSG_CLOEXEC)
 	if err != nil {
 		return nil, err
 	}
-
 	if n >= MaxNameLen || oobn != oobSpace {
-		return nil, fmt.Errorf("recvfd: incorrect number of bytes read (n=%d oobn=%d)", n, oobn)
+		return nil, fmt.Errorf("recvfile: incorrect number of bytes read (n=%d oobn=%d)", n, oobn)
 	}
-
 	// Truncate.
 	name = name[:n]
 	oob = oob[:oobn]
@@ -61,36 +57,63 @@ func RecvFd(socket *os.File) (*os.File, error) {
 	if err != nil {
 		return nil, err
 	}
-	if len(scms) != 1 {
-		return nil, fmt.Errorf("recvfd: number of SCMs is not 1: %d", len(scms))
+
+	// We cannot control how many SCM_RIGHTS we receive, and upon receiving
+	// them all of the descriptors are installed in our fd table, so we need to
+	// parse all of the SCM_RIGHTS we received in order to close all of the
+	// descriptors on error.
+	var fds []int
+	defer func() {
+		for i, fd := range fds {
+			if i == 0 && Err == nil {
+				// Only close the first one on error.
+				continue
+			}
+			// Always close extra ones.
+			_ = unix.Close(fd)
+		}
+	}()
+	var lastErr error
+	for _, scm := range scms {
+		if scm.Header.Type == unix.SCM_RIGHTS {
+			scmFds, err := unix.ParseUnixRights(&scm)
+			if err != nil {
+				lastErr = err
+			} else {
+				fds = append(fds, scmFds...)
+			}
+		}
+	}
+	if lastErr != nil {
+		return nil, lastErr
 	}
-	scm := scms[0]
 
-	fds, err := unix.ParseUnixRights(&scm)
-	if err != nil {
-		return nil, err
+	// We do this after collecting the fds to make sure we close them all when
+	// returning an error here.
+	if len(scms) != 1 {
+		return nil, fmt.Errorf("recvfd: number of SCMs is not 1: %d", len(scms))
 	}
 	if len(fds) != 1 {
 		return nil, fmt.Errorf("recvfd: number of fds is not 1: %d", len(fds))
 	}
-	fd := uintptr(fds[0])
-
-	return os.NewFile(fd, string(name)), nil
+	return os.NewFile(uintptr(fds[0]), string(name)), nil
 }
 
-// SendFd sends a file descriptor over the given AF_UNIX socket. In
-// addition, the file.Name() of the given file will also be sent as
-// non-auxiliary data in the same payload (allowing to send contextual
-// information for a file descriptor).
-func SendFd(socket *os.File, name string, fd uintptr) error {
+// SendFile sends a file over the given AF_UNIX socket. file.Name() is also
+// included so that if the other end uses RecvFile, the file will have the same
+// name information.
+func SendFile(socket *os.File, file *os.File) error {
+	name := file.Name()
 	if len(name) >= MaxNameLen {
 		return fmt.Errorf("sendfd: filename too long: %s", name)
 	}
-	return SendFds(socket, []byte(name), int(fd))
+	err := SendRawFd(socket, name, file.Fd())
+	runtime.KeepAlive(file)
+	return err
 }
 
-// SendFds sends a list of files descriptor and msg over the given AF_UNIX socket.
-func SendFds(socket *os.File, msg []byte, fds ...int) error {
-	oob := unix.UnixRights(fds...)
-	return unix.Sendmsg(int(socket.Fd()), msg, oob, nil, 0)
+// SendRawFd sends a specific file descriptor over the given AF_UNIX socket.
+func SendRawFd(socket *os.File, msg string, fd uintptr) error {
+	oob := unix.UnixRights(int(fd))
+	return unix.Sendmsg(int(socket.Fd()), []byte(msg), oob, nil, 0)
 }
diff --git a/vendor/github.com/opencontainers/runc/libcontainer/utils/utils.go b/vendor/github.com/opencontainers/runc/libcontainer/utils/utils.go
index 6b9fc3435..1b523d8ac 100644
--- a/vendor/github.com/opencontainers/runc/libcontainer/utils/utils.go
+++ b/vendor/github.com/opencontainers/runc/libcontainer/utils/utils.go
@@ -3,15 +3,12 @@ package utils
 import (
 	"encoding/binary"
 	"encoding/json"
-	"fmt"
 	"io"
 	"os"
 	"path/filepath"
-	"strconv"
 	"strings"
 	"unsafe"
 
-	securejoin "github.com/cyphar/filepath-securejoin"
 	"golang.org/x/sys/unix"
 )
 
@@ -43,6 +40,9 @@ func ExitStatus(status unix.WaitStatus) int {
 }
 
 // WriteJSON writes the provided struct v to w using standard json marshaling
+// without a trailing newline. This is used instead of json.Encoder because
+// there might be a problem in json decoder in some cases, see:
+// https://github.com/docker/docker/issues/14203#issuecomment-174177790
 func WriteJSON(w io.Writer, v interface{}) error {
 	data, err := json.Marshal(v)
 	if err != nil {
@@ -99,52 +99,16 @@ func stripRoot(root, path string) string {
 	return CleanPath("/" + path)
 }
 
-// WithProcfd runs the passed closure with a procfd path (/proc/self/fd/...)
-// corresponding to the unsafePath resolved within the root. Before passing the
-// fd, this path is verified to have been inside the root -- so operating on it
-// through the passed fdpath should be safe. Do not access this path through
-// the original path strings, and do not attempt to use the pathname outside of
-// the passed closure (the file handle will be freed once the closure returns).
-func WithProcfd(root, unsafePath string, fn func(procfd string) error) error {
-	// Remove the root then forcefully resolve inside the root.
-	unsafePath = stripRoot(root, unsafePath)
-	path, err := securejoin.SecureJoin(root, unsafePath)
-	if err != nil {
-		return fmt.Errorf("resolving path inside rootfs failed: %w", err)
-	}
-
-	// Open the target path.
-	fh, err := os.OpenFile(path, unix.O_PATH|unix.O_CLOEXEC, 0)
-	if err != nil {
-		return fmt.Errorf("open o_path procfd: %w", err)
-	}
-	defer fh.Close()
-
-	// Double-check the path is the one we expected.
-	procfd := "/proc/self/fd/" + strconv.Itoa(int(fh.Fd()))
-	if realpath, err := os.Readlink(procfd); err != nil {
-		return fmt.Errorf("procfd verification failed: %w", err)
-	} else if realpath != path {
-		return fmt.Errorf("possibly malicious path detected -- refusing to operate on %s", realpath)
-	}
-
-	// Run the closure.
-	return fn(procfd)
-}
-
-// SearchLabels searches a list of key-value pairs for the provided key and
-// returns the corresponding value. The pairs must be separated with '='.
-func SearchLabels(labels []string, query string) string {
-	for _, l := range labels {
-		parts := strings.SplitN(l, "=", 2)
-		if len(parts) < 2 {
-			continue
-		}
-		if parts[0] == query {
-			return parts[1]
+// SearchLabels searches through a list of key=value pairs for a given key,
+// returning its value, and the binary flag telling whether the key exist.
+func SearchLabels(labels []string, key string) (string, bool) {
+	key += "="
+	for _, s := range labels {
+		if strings.HasPrefix(s, key) {
+			return s[len(key):], true
 		}
 	}
-	return ""
+	return "", false
 }
 
 // Annotations returns the bundle path and user defined annotations from the
diff --git a/vendor/github.com/opencontainers/runc/libcontainer/utils/utils_unix.go b/vendor/github.com/opencontainers/runc/libcontainer/utils/utils_unix.go
index bf3237a29..6bf9102f4 100644
--- a/vendor/github.com/opencontainers/runc/libcontainer/utils/utils_unix.go
+++ b/vendor/github.com/opencontainers/runc/libcontainer/utils/utils_unix.go
@@ -1,14 +1,20 @@
 //go:build !windows
-// +build !windows
 
 package utils
 
 import (
 	"fmt"
+	"math"
 	"os"
+	"path/filepath"
+	"runtime"
 	"strconv"
+	"strings"
+	"sync"
 	_ "unsafe" // for go:linkname
 
+	securejoin "github.com/cyphar/filepath-securejoin"
+	"github.com/sirupsen/logrus"
 	"golang.org/x/sys/unix"
 )
 
@@ -24,12 +30,39 @@ func EnsureProcHandle(fh *os.File) error {
 	return nil
 }
 
+var (
+	haveCloseRangeCloexecBool bool
+	haveCloseRangeCloexecOnce sync.Once
+)
+
+func haveCloseRangeCloexec() bool {
+	haveCloseRangeCloexecOnce.Do(func() {
+		// Make sure we're not closing a random file descriptor.
+		tmpFd, err := unix.FcntlInt(0, unix.F_DUPFD_CLOEXEC, 0)
+		if err != nil {
+			return
+		}
+		defer unix.Close(tmpFd)
+
+		err = unix.CloseRange(uint(tmpFd), uint(tmpFd), unix.CLOSE_RANGE_CLOEXEC)
+		// Any error means we cannot use close_range(CLOSE_RANGE_CLOEXEC).
+		// -ENOSYS and -EINVAL ultimately mean we don't have support, but any
+		// other potential error would imply that even the most basic close
+		// operation wouldn't work.
+		haveCloseRangeCloexecBool = err == nil
+	})
+	return haveCloseRangeCloexecBool
+}
+
 type fdFunc func(fd int)
 
 // fdRangeFrom calls the passed fdFunc for each file descriptor that is open in
 // the current process.
 func fdRangeFrom(minFd int, fn fdFunc) error {
-	fdDir, err := os.Open("/proc/self/fd")
+	procSelfFd, closer := ProcThreadSelf("fd")
+	defer closer()
+
+	fdDir, err := os.Open(procSelfFd)
 	if err != nil {
 		return err
 	}
@@ -67,6 +100,12 @@ func fdRangeFrom(minFd int, fn fdFunc) error {
 // CloseExecFrom sets the O_CLOEXEC flag on all file descriptors greater or
 // equal to minFd in the current process.
 func CloseExecFrom(minFd int) error {
+	// Use close_range(CLOSE_RANGE_CLOEXEC) if possible.
+	if haveCloseRangeCloexec() {
+		err := unix.CloseRange(uint(minFd), math.MaxUint, unix.CLOSE_RANGE_CLOEXEC)
+		return os.NewSyscallError("close_range", err)
+	}
+	// Otherwise, fall back to the standard loop.
 	return fdRangeFrom(minFd, unix.CloseOnExec)
 }
 
@@ -89,7 +128,8 @@ func runtime_IsPollDescriptor(fd uintptr) bool //nolint:revive
 // *os.File operations would apply to the wrong file). This function is only
 // intended to be called from the last stage of runc init.
 func UnsafeCloseFrom(minFd int) error {
-	// We must not close some file descriptors.
+	// We cannot use close_range(2) even if it is available, because we must
+	// not close some file descriptors.
 	return fdRangeFrom(minFd, func(fd int) {
 		if runtime_IsPollDescriptor(uintptr(fd)) {
 			// These are the Go runtimes internal netpoll file descriptors.
@@ -107,11 +147,131 @@ func UnsafeCloseFrom(minFd int) error {
 	})
 }
 
-// NewSockPair returns a new unix socket pair
-func NewSockPair(name string) (parent *os.File, child *os.File, err error) {
+// NewSockPair returns a new SOCK_STREAM unix socket pair.
+func NewSockPair(name string) (parent, child *os.File, err error) {
 	fds, err := unix.Socketpair(unix.AF_LOCAL, unix.SOCK_STREAM|unix.SOCK_CLOEXEC, 0)
 	if err != nil {
 		return nil, nil, err
 	}
 	return os.NewFile(uintptr(fds[1]), name+"-p"), os.NewFile(uintptr(fds[0]), name+"-c"), nil
 }
+
+// WithProcfd runs the passed closure with a procfd path (/proc/self/fd/...)
+// corresponding to the unsafePath resolved within the root. Before passing the
+// fd, this path is verified to have been inside the root -- so operating on it
+// through the passed fdpath should be safe. Do not access this path through
+// the original path strings, and do not attempt to use the pathname outside of
+// the passed closure (the file handle will be freed once the closure returns).
+func WithProcfd(root, unsafePath string, fn func(procfd string) error) error {
+	// Remove the root then forcefully resolve inside the root.
+	unsafePath = stripRoot(root, unsafePath)
+	path, err := securejoin.SecureJoin(root, unsafePath)
+	if err != nil {
+		return fmt.Errorf("resolving path inside rootfs failed: %w", err)
+	}
+
+	procSelfFd, closer := ProcThreadSelf("fd/")
+	defer closer()
+
+	// Open the target path.
+	fh, err := os.OpenFile(path, unix.O_PATH|unix.O_CLOEXEC, 0)
+	if err != nil {
+		return fmt.Errorf("open o_path procfd: %w", err)
+	}
+	defer fh.Close()
+
+	procfd := filepath.Join(procSelfFd, strconv.Itoa(int(fh.Fd())))
+	// Double-check the path is the one we expected.
+	if realpath, err := os.Readlink(procfd); err != nil {
+		return fmt.Errorf("procfd verification failed: %w", err)
+	} else if realpath != path {
+		return fmt.Errorf("possibly malicious path detected -- refusing to operate on %s", realpath)
+	}
+
+	return fn(procfd)
+}
+
+type ProcThreadSelfCloser func()
+
+var (
+	haveProcThreadSelf     bool
+	haveProcThreadSelfOnce sync.Once
+)
+
+// ProcThreadSelf returns a string that is equivalent to
+// /proc/thread-self/<subpath>, with a graceful fallback on older kernels where
+// /proc/thread-self doesn't exist. This method DOES NOT use SecureJoin,
+// meaning that the passed string needs to be trusted. The caller _must_ call
+// the returned procThreadSelfCloser function (which is runtime.UnlockOSThread)
+// *only once* after it has finished using the returned path string.
+func ProcThreadSelf(subpath string) (string, ProcThreadSelfCloser) {
+	haveProcThreadSelfOnce.Do(func() {
+		if _, err := os.Stat("/proc/thread-self/"); err == nil {
+			haveProcThreadSelf = true
+		} else {
+			logrus.Debugf("cannot stat /proc/thread-self (%v), falling back to /proc/self/task/<tid>", err)
+		}
+	})
+
+	// We need to lock our thread until the caller is done with the path string
+	// because any non-atomic operation on the path (such as opening a file,
+	// then reading it) could be interrupted by the Go runtime where the
+	// underlying thread is swapped out and the original thread is killed,
+	// resulting in pull-your-hair-out-hard-to-debug issues in the caller. In
+	// addition, the pre-3.17 fallback makes everything non-atomic because the
+	// same thing could happen between unix.Gettid() and the path operations.
+	//
+	// In theory, we don't need to lock in the atomic user case when using
+	// /proc/thread-self/, but it's better to be safe than sorry (and there are
+	// only one or two truly atomic users of /proc/thread-self/).
+	runtime.LockOSThread()
+
+	threadSelf := "/proc/thread-self/"
+	if !haveProcThreadSelf {
+		// Pre-3.17 kernels did not have /proc/thread-self, so do it manually.
+		threadSelf = "/proc/self/task/" + strconv.Itoa(unix.Gettid()) + "/"
+		if _, err := os.Stat(threadSelf); err != nil {
+			// Unfortunately, this code is called from rootfs_linux.go where we
+			// are running inside the pid namespace of the container but /proc
+			// is the host's procfs. Unfortunately there is no real way to get
+			// the correct tid to use here (the kernel age means we cannot do
+			// things like set up a private fsopen("proc") -- even scanning
+			// NSpid in all of the tasks in /proc/self/task/*/status requires
+			// Linux 4.1).
+			//
+			// So, we just have to assume that /proc/self is acceptable in this
+			// one specific case.
+			if os.Getpid() == 1 {
+				logrus.Debugf("/proc/thread-self (tid=%d) cannot be emulated inside the initial container setup -- using /proc/self instead: %v", unix.Gettid(), err)
+			} else {
+				// This should never happen, but the fallback should work in most cases...
+				logrus.Warnf("/proc/thread-self could not be emulated for pid=%d (tid=%d) -- using more buggy /proc/self fallback instead: %v", os.Getpid(), unix.Gettid(), err)
+			}
+			threadSelf = "/proc/self/"
+		}
+	}
+	return threadSelf + subpath, runtime.UnlockOSThread
+}
+
+// ProcThreadSelfFd is small wrapper around ProcThreadSelf to make it easier to
+// create a /proc/thread-self handle for given file descriptor.
+//
+// It is basically equivalent to ProcThreadSelf(fmt.Sprintf("fd/%d", fd)), but
+// without using fmt.Sprintf to avoid unneeded overhead.
+func ProcThreadSelfFd(fd uintptr) (string, ProcThreadSelfCloser) {
+	return ProcThreadSelf("fd/" + strconv.FormatUint(uint64(fd), 10))
+}
+
+// IsLexicallyInRoot is shorthand for strings.HasPrefix(path+"/", root+"/"),
+// but properly handling the case where path or root are "/".
+//
+// NOTE: The return value only make sense if the path doesn't contain "..".
+func IsLexicallyInRoot(root, path string) bool {
+	if root != "/" {
+		root += "/"
+	}
+	if path != "/" {
+		path += "/"
+	}
+	return strings.HasPrefix(path, root)
+}
diff --git a/vendor/github.com/vbauerster/mpb/v8/bar.go b/vendor/github.com/vbauerster/mpb/v8/bar.go
index b78fa47d1..2ccd82afd 100644
--- a/vendor/github.com/vbauerster/mpb/v8/bar.go
+++ b/vendor/github.com/vbauerster/mpb/v8/bar.go
@@ -173,13 +173,12 @@ func (b *Bar) TraverseDecorators(cb func(decor.Decorator)) {
 }
 
 // EnableTriggerComplete enables triggering complete event. It's effective
-// only for bars which were constructed with `total <= 0` and after total
-// has been set with `(*Bar).SetTotal(int64, false)`. If `curren >= total`
+// only for bars which were constructed with `total <= 0`. If `curren >= total`
 // at the moment of call, complete event is triggered right away.
 func (b *Bar) EnableTriggerComplete() {
 	select {
 	case b.operateState <- func(s *bState) {
-		if s.triggerComplete || s.total <= 0 {
+		if s.triggerComplete {
 			return
 		}
 		if s.current >= s.total {
@@ -196,10 +195,10 @@ func (b *Bar) EnableTriggerComplete() {
 
 // SetTotal sets total to an arbitrary value. It's effective only for bar
 // which was constructed with `total <= 0`. Setting total to negative value
-// is equivalent to `(*Bar).SetTotal((*Bar).Current(), bool)` but faster. If
-// triggerCompletion is true, total value is set to current and complete
-// event is triggered right away.
-func (b *Bar) SetTotal(total int64, triggerCompletion bool) {
+// is equivalent to `(*Bar).SetTotal((*Bar).Current(), bool)` but faster.
+// If `complete` is true complete event is triggered right away.
+// Calling `(*Bar).EnableTriggerComplete` makes this one no operational.
+func (b *Bar) SetTotal(total int64, complete bool) {
 	select {
 	case b.operateState <- func(s *bState) {
 		if s.triggerComplete {
@@ -210,7 +209,7 @@ func (b *Bar) SetTotal(total int64, triggerCompletion bool) {
 		} else {
 			s.total = total
 		}
-		if triggerCompletion {
+		if complete {
 			s.current = s.total
 			s.completed = true
 			b.triggerCompletion(s)
diff --git a/vendor/modules.txt b/vendor/modules.txt
index 08d76aa65..c96038569 100644
--- a/vendor/modules.txt
+++ b/vendor/modules.txt
@@ -61,17 +61,6 @@ github.com/checkpoint-restore/go-criu/v7/stats
 # github.com/chzyer/readline v1.5.1
 ## explicit; go 1.15
 github.com/chzyer/readline
-# github.com/cilium/ebpf v0.11.0
-## explicit; go 1.19
-github.com/cilium/ebpf
-github.com/cilium/ebpf/asm
-github.com/cilium/ebpf/btf
-github.com/cilium/ebpf/internal
-github.com/cilium/ebpf/internal/kconfig
-github.com/cilium/ebpf/internal/sys
-github.com/cilium/ebpf/internal/tracefs
-github.com/cilium/ebpf/internal/unix
-github.com/cilium/ebpf/link
 # github.com/containerd/cgroups/v3 v3.0.3
 ## explicit; go 1.18
 github.com/containerd/cgroups/v3/cgroup1/stats
@@ -103,7 +92,7 @@ github.com/containernetworking/cni/pkg/version
 # github.com/containernetworking/plugins v1.5.1
 ## explicit; go 1.20
 github.com/containernetworking/plugins/pkg/ns
-# github.com/containers/image/v5 v5.32.0
+# github.com/containers/image/v5 v5.32.1-0.20240806084436-e3e9287ca8e6
 ## explicit; go 1.21.0
 github.com/containers/image/v5/copy
 github.com/containers/image/v5/directory
@@ -189,7 +178,7 @@ github.com/containers/ocicrypt/keywrap/pkcs7
 github.com/containers/ocicrypt/spec
 github.com/containers/ocicrypt/utils
 github.com/containers/ocicrypt/utils/keyprovider
-# github.com/containers/storage v1.55.0
+# github.com/containers/storage v1.55.1-0.20240805140222-b8f828d4a2dc
 ## explicit; go 1.21
 github.com/containers/storage
 github.com/containers/storage/drivers
@@ -441,7 +430,7 @@ github.com/mailru/easyjson/jwriter
 github.com/manifoldco/promptui
 github.com/manifoldco/promptui/list
 github.com/manifoldco/promptui/screenbuf
-# github.com/mattn/go-runewidth v0.0.15
+# github.com/mattn/go-runewidth v0.0.16
 ## explicit; go 1.9
 github.com/mattn/go-runewidth
 # github.com/mattn/go-sqlite3 v1.14.22
@@ -515,19 +504,15 @@ github.com/opencontainers/go-digest
 ## explicit; go 1.18
 github.com/opencontainers/image-spec/specs-go
 github.com/opencontainers/image-spec/specs-go/v1
-# github.com/opencontainers/runc v1.1.13
-## explicit; go 1.18
+# github.com/opencontainers/runc v1.2.0-rc.2.0.20240801140032-ad5b481dace5
+## explicit; go 1.21
 github.com/opencontainers/runc/libcontainer/apparmor
 github.com/opencontainers/runc/libcontainer/cgroups
-github.com/opencontainers/runc/libcontainer/cgroups/devices
-github.com/opencontainers/runc/libcontainer/cgroups/ebpf
-github.com/opencontainers/runc/libcontainer/cgroups/ebpf/devicefilter
 github.com/opencontainers/runc/libcontainer/cgroups/fs
 github.com/opencontainers/runc/libcontainer/cgroups/fs2
 github.com/opencontainers/runc/libcontainer/cgroups/fscommon
 github.com/opencontainers/runc/libcontainer/configs
 github.com/opencontainers/runc/libcontainer/devices
-github.com/opencontainers/runc/libcontainer/user
 github.com/opencontainers/runc/libcontainer/userns
 github.com/opencontainers/runc/libcontainer/utils
 # github.com/opencontainers/runtime-spec v1.2.0
@@ -620,7 +605,7 @@ github.com/ulikunitz/xz/lzma
 github.com/vbatts/tar-split/archive/tar
 github.com/vbatts/tar-split/tar/asm
 github.com/vbatts/tar-split/tar/storage
-# github.com/vbauerster/mpb/v8 v8.7.4
+# github.com/vbauerster/mpb/v8 v8.7.5
 ## explicit; go 1.17
 github.com/vbauerster/mpb/v8
 github.com/vbauerster/mpb/v8/cwriter