diff --git a/go.mod b/go.mod
index a0f3e4eb..65354087 100644
--- a/go.mod
+++ b/go.mod
@@ -4,7 +4,7 @@ go 1.23.1
 
 require (
 	github.com/cheggaaa/pb/v3 v3.1.6
-	github.com/cilium/ebpf v0.17.2
+	github.com/cilium/ebpf v0.17.3
 	github.com/cloudflare/cbpfc v0.0.0-20221017140110-11acb56438a2
 	github.com/jsimonetti/rtnetlink v1.4.2
 	github.com/spf13/pflag v1.0.6
diff --git a/go.sum b/go.sum
index 1ef99977..2fe2c6e1 100644
--- a/go.sum
+++ b/go.sum
@@ -3,8 +3,8 @@ github.com/VividCortex/ewma v1.2.0/go.mod h1:nz4BbCtbLyFDeC9SUHbtcT5644juEuWfUAU
 github.com/cheggaaa/pb/v3 v3.1.6 h1:h0x+vd7EiUohAJ29DJtJy+SNAc55t/elW3jCD086EXk=
 github.com/cheggaaa/pb/v3 v3.1.6/go.mod h1:urxmfVtaxT+9aWk92DbsvXFZtNSWQSO5TRAp+MJ3l1s=
 github.com/cilium/ebpf v0.9.0/go.mod h1:+OhNOIXx/Fnu1IE8bJz2dzOA+VSfyTfdNUVdlQnxUFY=
-github.com/cilium/ebpf v0.17.2 h1:IQTaTVu0vKA8WTemFuBnxW9YbAwMkJVKHsNHW4lHv/g=
-github.com/cilium/ebpf v0.17.2/go.mod h1:9X5VAsIOck/nCAp0+nCSVzub1Q7x+zKXXItTMYfNE+E=
+github.com/cilium/ebpf v0.17.3 h1:FnP4r16PWYSE4ux6zN+//jMcW4nMVRvuTLVTvCjyyjg=
+github.com/cilium/ebpf v0.17.3/go.mod h1:G5EDHij8yiLzaqn0WjyfJHvRa+3aDlReIaLVRMvOyJk=
 github.com/cloudflare/cbpfc v0.0.0-20221017140110-11acb56438a2 h1:tR13nc9+yx04rglzDJGQLoz3bTsh0os9tXpis6qwSVk=
 github.com/cloudflare/cbpfc v0.0.0-20221017140110-11acb56438a2/go.mod h1:KV9WSdjdUOxRC4RdsvoV1W5JTdMe7IjMgSUwcBrs860=
 github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E=
diff --git a/vendor/github.com/cilium/ebpf/btf/btf.go b/vendor/github.com/cilium/ebpf/btf/btf.go
index 880c5ade..e8f80c13 100644
--- a/vendor/github.com/cilium/ebpf/btf/btf.go
+++ b/vendor/github.com/cilium/ebpf/btf/btf.go
@@ -99,6 +99,10 @@ func (mt *mutableTypes) copy() *mutableTypes {
 		return nil
 	}
 
+	// Prevent concurrent modification of mt.copiedTypeIDs.
+	mt.mu.RLock()
+	defer mt.mu.RUnlock()
+
 	mtCopy := &mutableTypes{
 		mt.imm,
 		sync.RWMutex{},
@@ -106,10 +110,6 @@ func (mt *mutableTypes) copy() *mutableTypes {
 		make(map[Type]TypeID, len(mt.copiedTypeIDs)),
 	}
 
-	// Prevent concurrent modification of mt.copiedTypeIDs.
-	mt.mu.RLock()
-	defer mt.mu.RUnlock()
-
 	copiesOfCopies := make(map[Type]Type, len(mt.copies))
 	for orig, copy := range mt.copies {
 		// NB: We make a copy of copy, not orig, so that changes to mutable types
diff --git a/vendor/github.com/cilium/ebpf/btf/ext_info.go b/vendor/github.com/cilium/ebpf/btf/ext_info.go
index 2c684fe2..71dbba80 100644
--- a/vendor/github.com/cilium/ebpf/btf/ext_info.go
+++ b/vendor/github.com/cilium/ebpf/btf/ext_info.go
@@ -666,20 +666,19 @@ func parseLineInfos(r io.Reader, bo binary.ByteOrder, strings *stringTable) (map
 // 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, offsetInBytes bool) ([]bpfLineInfo, error) {
-	var li bpfLineInfo
-
-	if exp, got := uint32(binary.Size(li)), recordSize; exp != got {
+	if exp, got := uint32(binary.Size(bpfLineInfo{})), 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)
 	}
 
-	out := make([]bpfLineInfo, 0, recordNum)
-	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)
-		}
+	out := make([]bpfLineInfo, recordNum)
+	if err := binary.Read(r, bo, out); err != nil {
+		return nil, fmt.Errorf("can't read line info: %v", err)
+	}
 
-		if offsetInBytes {
+	if offsetInBytes {
+		for i := range out {
+			li := &out[i]
 			if li.InsnOff%asm.InstructionSize != 0 {
 				return nil, fmt.Errorf("offset %v is not aligned with instruction size", li.InsnOff)
 			}
@@ -688,8 +687,6 @@ func parseLineInfoRecords(r io.Reader, bo binary.ByteOrder, recordSize uint32, r
 			// Convert as early as possible.
 			li.InsnOff /= asm.InstructionSize
 		}
-
-		out = append(out, li)
 	}
 
 	return out, nil
diff --git a/vendor/github.com/cilium/ebpf/info.go b/vendor/github.com/cilium/ebpf/info.go
index 56a1f1e9..676e8fa6 100644
--- a/vendor/github.com/cilium/ebpf/info.go
+++ b/vendor/github.com/cilium/ebpf/info.go
@@ -185,7 +185,7 @@ type programJitedInfo struct {
 	// subprograms.
 	//
 	// Available from 4.18.
-	ksyms    []uintptr
+	ksyms    []uint64
 	numKsyms uint32
 
 	// insns holds the JITed machine native instructions of the program,
@@ -344,7 +344,7 @@ func newProgramInfoFromFd(fd *sys.FD) (*ProgramInfo, error) {
 
 	if info.NrJitedKsyms > 0 {
 		pi.jitedInfo.numKsyms = info.NrJitedKsyms
-		pi.jitedInfo.ksyms = make([]uintptr, info.NrJitedKsyms)
+		pi.jitedInfo.ksyms = make([]uint64, info.NrJitedKsyms)
 		info2.JitedKsyms = sys.NewSlicePointer(pi.jitedInfo.ksyms)
 		info2.NrJitedKsyms = info.NrJitedKsyms
 		makeSecondCall = true
@@ -630,8 +630,25 @@ func (pi *ProgramInfo) VerifiedInstructions() (uint32, bool) {
 // programs without subprograms (bpf2bpf calls).
 //
 // The bool return value indicates whether this optional field is available.
+//
+// When a kernel address can't fit into uintptr (which is usually the case when
+// running 32 bit program on a 64 bit kernel), this returns an empty slice and
+// a false.
 func (pi *ProgramInfo) JitedKsymAddrs() ([]uintptr, bool) {
-	return pi.jitedInfo.ksyms, len(pi.jitedInfo.ksyms) > 0
+	ksyms := make([]uintptr, 0, len(pi.jitedInfo.ksyms))
+	if cap(ksyms) == 0 {
+		return ksyms, false
+	}
+	// Check if a kernel address fits into uintptr (it might not when
+	// using a 32 bit binary on a 64 bit kernel). This check should work
+	// with any kernel address, since they have 1s at the highest bits.
+	if a := pi.jitedInfo.ksyms[0]; uint64(uintptr(a)) != a {
+		return nil, false
+	}
+	for _, ksym := range pi.jitedInfo.ksyms {
+		ksyms = append(ksyms, uintptr(ksym))
+	}
+	return ksyms, true
 }
 
 // JitedInsns returns the JITed machine native instructions of the program.
diff --git a/vendor/github.com/cilium/ebpf/internal/linux/auxv.go b/vendor/github.com/cilium/ebpf/internal/linux/auxv.go
index 07d5efee..10508fd8 100644
--- a/vendor/github.com/cilium/ebpf/internal/linux/auxv.go
+++ b/vendor/github.com/cilium/ebpf/internal/linux/auxv.go
@@ -1,12 +1,11 @@
 package linux
 
 import (
-	"errors"
 	"fmt"
 	"io"
-	_ "unsafe"
 
 	"github.com/cilium/ebpf/internal"
+	"github.com/cilium/ebpf/internal/unix"
 )
 
 type auxvPairReader interface {
@@ -20,11 +19,8 @@ const (
 	_AT_SYSINFO_EHDR = 33 // Offset to vDSO blob in process image
 )
 
-//go:linkname runtime_getAuxv runtime.getAuxv
-func runtime_getAuxv() []uintptr
-
 type auxvRuntimeReader struct {
-	data  []uintptr
+	data  [][2]uintptr
 	index int
 }
 
@@ -40,12 +36,12 @@ func (r *auxvRuntimeReader) ReadAuxvPair() (uint64, uint64, error) {
 	// we manually add the (_AT_NULL, _AT_NULL) pair at the end
 	// that is not provided by the go runtime
 	var tag, value uintptr
-	if r.index+1 < len(r.data) {
-		tag, value = r.data[r.index], r.data[r.index+1]
+	if r.index < len(r.data) {
+		tag, value = r.data[r.index][0], r.data[r.index][1]
 	} else {
 		tag, value = _AT_NULL, _AT_NULL
 	}
-	r.index += 2
+	r.index += 1
 	return uint64(tag), uint64(value), nil
 }
 
@@ -54,10 +50,9 @@ func newAuxvRuntimeReader() (auxvPairReader, error) {
 		return nil, fmt.Errorf("read auxv from runtime: %w", internal.ErrNotSupportedOnOS)
 	}
 
-	data := runtime_getAuxv()
-
-	if len(data)%2 != 0 {
-		return nil, errors.New("malformed auxv passed from runtime")
+	data, err := unix.Auxv()
+	if err != nil {
+		return nil, fmt.Errorf("read auxv from runtime: %w", err)
 	}
 
 	return &auxvRuntimeReader{
diff --git a/vendor/github.com/cilium/ebpf/internal/sys/syscall.go b/vendor/github.com/cilium/ebpf/internal/sys/syscall.go
index e37f4cf6..4fdb74c5 100644
--- a/vendor/github.com/cilium/ebpf/internal/sys/syscall.go
+++ b/vendor/github.com/cilium/ebpf/internal/sys/syscall.go
@@ -2,7 +2,6 @@ package sys
 
 import (
 	"runtime"
-	"syscall"
 	"unsafe"
 
 	"github.com/cilium/ebpf/internal/unix"
@@ -11,7 +10,7 @@ import (
 // ENOTSUPP is a Linux internal error code that has leaked into UAPI.
 //
 // It is not the same as ENOTSUP or EOPNOTSUPP.
-const ENOTSUPP = syscall.Errno(524)
+const ENOTSUPP = unix.Errno(524)
 
 // BPF wraps SYS_BPF.
 //
@@ -179,12 +178,12 @@ const (
 const BPF_TAG_SIZE = 8
 const BPF_OBJ_NAME_LEN = 16
 
-// wrappedErrno wraps syscall.Errno to prevent direct comparisons with
+// wrappedErrno wraps [unix.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
+	unix.Errno
 }
 
 func (we wrappedErrno) Unwrap() error {
@@ -200,10 +199,10 @@ func (we wrappedErrno) Error() string {
 
 type syscallError struct {
 	error
-	errno syscall.Errno
+	errno unix.Errno
 }
 
-func Error(err error, errno syscall.Errno) error {
+func Error(err error, errno unix.Errno) error {
 	return &syscallError{err, errno}
 }
 
diff --git a/vendor/github.com/cilium/ebpf/internal/unix/errno_linux.go b/vendor/github.com/cilium/ebpf/internal/unix/errno_linux.go
new file mode 100644
index 00000000..0c4886bd
--- /dev/null
+++ b/vendor/github.com/cilium/ebpf/internal/unix/errno_linux.go
@@ -0,0 +1,29 @@
+package unix
+
+import (
+	"syscall"
+
+	linux "golang.org/x/sys/unix"
+)
+
+type Errno = syscall.Errno
+
+const (
+	E2BIG      = linux.E2BIG
+	EACCES     = linux.EACCES
+	EAGAIN     = linux.EAGAIN
+	EBADF      = linux.EBADF
+	EEXIST     = linux.EEXIST
+	EFAULT     = linux.EFAULT
+	EILSEQ     = linux.EILSEQ
+	EINTR      = linux.EINTR
+	EINVAL     = linux.EINVAL
+	ENODEV     = linux.ENODEV
+	ENOENT     = linux.ENOENT
+	ENOSPC     = linux.ENOSPC
+	EOPNOTSUPP = linux.EOPNOTSUPP
+	EPERM      = linux.EPERM
+	EPOLLIN    = linux.EPOLLIN
+	ESRCH      = linux.ESRCH
+	ESTALE     = linux.ESTALE
+)
diff --git a/vendor/github.com/cilium/ebpf/internal/unix/errno_other.go b/vendor/github.com/cilium/ebpf/internal/unix/errno_other.go
new file mode 100644
index 00000000..fc2b042b
--- /dev/null
+++ b/vendor/github.com/cilium/ebpf/internal/unix/errno_other.go
@@ -0,0 +1,29 @@
+//go:build !linux && !windows
+
+package unix
+
+import "syscall"
+
+type Errno = syscall.Errno
+
+// Errnos are distinct and non-zero.
+const (
+	E2BIG Errno = iota + 1
+	EACCES
+	EAGAIN
+	EBADF
+	EEXIST
+	EFAULT
+	EILSEQ
+	EINTR
+	EINVAL
+	ENODEV
+	ENOENT
+	ENOSPC
+	ENOTSUP
+	ENOTSUPP
+	EOPNOTSUPP
+	EPERM
+	ESRCH
+	ESTALE
+)
diff --git a/vendor/github.com/cilium/ebpf/internal/unix/errno_string_windows.go b/vendor/github.com/cilium/ebpf/internal/unix/errno_string_windows.go
new file mode 100644
index 00000000..6077e983
--- /dev/null
+++ b/vendor/github.com/cilium/ebpf/internal/unix/errno_string_windows.go
@@ -0,0 +1,59 @@
+// Code generated by "stringer -type=Errno -tags=windows -output=errno_string_windows.go"; DO NOT EDIT.
+
+package unix
+
+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[EPERM-1]
+	_ = x[ENOENT-2]
+	_ = x[ESRCH-3]
+	_ = x[EINTR-4]
+	_ = x[E2BIG-7]
+	_ = x[EBADF-9]
+	_ = x[EAGAIN-11]
+	_ = x[EACCES-13]
+	_ = x[EFAULT-14]
+	_ = x[EEXIST-17]
+	_ = x[ENODEV-19]
+	_ = x[EINVAL-22]
+	_ = x[ENOSPC-28]
+	_ = x[EILSEQ-42]
+	_ = x[ENOTSUP-129]
+	_ = x[EOPNOTSUPP-130]
+	_ = x[ENOTSUPP-536870912]
+	_ = x[ESTALE-536870913]
+}
+
+const _Errno_name = "EPERMENOENTESRCHEINTRE2BIGEBADFEAGAINEACCESEFAULTEEXISTENODEVEINVALENOSPCEILSEQENOTSUPEOPNOTSUPPENOTSUPPESTALE"
+
+var _Errno_map = map[Errno]string{
+	1:         _Errno_name[0:5],
+	2:         _Errno_name[5:11],
+	3:         _Errno_name[11:16],
+	4:         _Errno_name[16:21],
+	7:         _Errno_name[21:26],
+	9:         _Errno_name[26:31],
+	11:        _Errno_name[31:37],
+	13:        _Errno_name[37:43],
+	14:        _Errno_name[43:49],
+	17:        _Errno_name[49:55],
+	19:        _Errno_name[55:61],
+	22:        _Errno_name[61:67],
+	28:        _Errno_name[67:73],
+	42:        _Errno_name[73:79],
+	129:       _Errno_name[79:86],
+	130:       _Errno_name[86:96],
+	536870912: _Errno_name[96:104],
+	536870913: _Errno_name[104:110],
+}
+
+func (i Errno) String() string {
+	if str, ok := _Errno_map[i]; ok {
+		return str
+	}
+	return "Errno(" + strconv.FormatInt(int64(i), 10) + ")"
+}
diff --git a/vendor/github.com/cilium/ebpf/internal/unix/errno_windows.go b/vendor/github.com/cilium/ebpf/internal/unix/errno_windows.go
new file mode 100644
index 00000000..7500cd6d
--- /dev/null
+++ b/vendor/github.com/cilium/ebpf/internal/unix/errno_windows.go
@@ -0,0 +1,78 @@
+package unix
+
+// The code in this file is derived from syscall_unix.go in the Go source code,
+// licensed under the MIT license.
+
+import (
+	"errors"
+	"os"
+	"syscall"
+)
+
+//go:generate go run golang.org/x/tools/cmd/stringer@latest -type=Errno -tags=windows -output=errno_string_windows.go
+
+// Windows specific constants for Unix errnos.
+//
+// The values do not always match Linux, for example EILSEQ and EOPNOTSUPP.
+//
+// See https://learn.microsoft.com/en-us/cpp/c-runtime-library/errno-constants?view=msvc-170
+const (
+	EPERM       Errno = 1
+	ENOENT      Errno = 2
+	ESRCH       Errno = 3
+	EINTR       Errno = 4
+	E2BIG       Errno = 7
+	EBADF       Errno = 9
+	EAGAIN      Errno = 11
+	EACCES      Errno = 13
+	EFAULT      Errno = 14
+	EEXIST      Errno = 17
+	ENODEV      Errno = 19
+	EINVAL      Errno = 22
+	ENFILE      Errno = 23
+	EMFILE      Errno = 24
+	ENOSPC      Errno = 28
+	ENOSYS      Errno = 40
+	ENOTEMPTY   Errno = 41
+	EILSEQ      Errno = 42
+	ENOTSUP     Errno = 129
+	EOPNOTSUPP  Errno = 130
+	ETIMEDOUT   Errno = 138
+	EWOULDBLOCK Errno = 140
+)
+
+// These constants do not exist on Windows and therefore have a non-zero
+// dummy value.
+const (
+	ENOTSUPP Errno = Errno(syscall.APPLICATION_ERROR) + iota
+	ESTALE
+)
+
+// Errno is a Windows compatibility shim for Unix errnos.
+type Errno uintptr
+
+func (e Errno) Error() string {
+	return e.String()
+}
+
+func (e Errno) Is(target error) bool {
+	switch target {
+	case os.ErrPermission:
+		return e == EACCES || e == EPERM
+	case os.ErrExist:
+		return e == EEXIST || e == ENOTEMPTY
+	case os.ErrNotExist:
+		return e == ENOENT
+	case errors.ErrUnsupported:
+		return e == ENOSYS || e == ENOTSUP || e == EOPNOTSUPP
+	}
+	return false
+}
+
+func (e Errno) Temporary() bool {
+	return e == EINTR || e == EMFILE || e == ENFILE || e.Timeout()
+}
+
+func (e Errno) Timeout() bool {
+	return e == EAGAIN || e == EWOULDBLOCK || e == ETIMEDOUT
+}
diff --git a/vendor/github.com/cilium/ebpf/internal/unix/types_linux.go b/vendor/github.com/cilium/ebpf/internal/unix/types_linux.go
index 144e608d..385adf08 100644
--- a/vendor/github.com/cilium/ebpf/internal/unix/types_linux.go
+++ b/vendor/github.com/cilium/ebpf/internal/unix/types_linux.go
@@ -8,26 +8,6 @@ import (
 	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
-	ESTALE     = linux.ESTALE
-)
-
 const (
 	BPF_F_NO_PREALLOC         = linux.BPF_F_NO_PREALLOC
 	BPF_F_NUMA_NODE           = linux.BPF_F_NUMA_NODE
@@ -215,3 +195,7 @@ func SchedSetaffinity(pid int, set *CPUSet) error {
 func SchedGetaffinity(pid int, set *CPUSet) error {
 	return linux.SchedGetaffinity(pid, set)
 }
+
+func Auxv() ([][2]uintptr, error) {
+	return linux.Auxv()
+}
diff --git a/vendor/github.com/cilium/ebpf/internal/unix/types_other.go b/vendor/github.com/cilium/ebpf/internal/unix/types_other.go
index 806c6e56..323f7ff3 100644
--- a/vendor/github.com/cilium/ebpf/internal/unix/types_other.go
+++ b/vendor/github.com/cilium/ebpf/internal/unix/types_other.go
@@ -6,26 +6,6 @@ import (
 	"syscall"
 )
 
-// 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
-	ESTALE
-)
-
 // Constants are distinct to avoid breaking switch statements.
 const (
 	BPF_F_NO_PREALLOC = iota
@@ -133,8 +113,8 @@ 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 Syscall(trap, a1, a2, a3 uintptr) (r1, r2 uintptr, err Errno) {
+	return 0, 0, ENOTSUP
 }
 
 func PthreadSigmask(how int, set, oldset *Sigset_t) error {
@@ -298,3 +278,7 @@ func SchedSetaffinity(pid int, set *CPUSet) error {
 func SchedGetaffinity(pid int, set *CPUSet) error {
 	return errNonLinux()
 }
+
+func Auxv() ([][2]uintptr, error) {
+	return nil, errNonLinux()
+}
diff --git a/vendor/github.com/cilium/ebpf/netlify.toml b/vendor/github.com/cilium/ebpf/netlify.toml
index 67c83f3b..764c3b44 100644
--- a/vendor/github.com/cilium/ebpf/netlify.toml
+++ b/vendor/github.com/cilium/ebpf/netlify.toml
@@ -2,3 +2,4 @@
   base = "docs/"
   publish = "site/"
   command = "mkdocs build"
+  environment = { PYTHON_VERSION = "3.13" }
diff --git a/vendor/modules.txt b/vendor/modules.txt
index a23601df..b34d8bf7 100644
--- a/vendor/modules.txt
+++ b/vendor/modules.txt
@@ -5,7 +5,7 @@ github.com/VividCortex/ewma
 ## explicit; go 1.17
 github.com/cheggaaa/pb/v3
 github.com/cheggaaa/pb/v3/termutil
-# github.com/cilium/ebpf v0.17.2
+# github.com/cilium/ebpf v0.17.3
 ## explicit; go 1.22
 github.com/cilium/ebpf
 github.com/cilium/ebpf/asm