diff --git a/Makefile b/Makefile
index a715544ac4edc2fa7476e830b3966da8eb5e9e72..f1469b3424526eb0de82fdd444a623b3ff8074ae 100644
--- a/Makefile
+++ b/Makefile
@@ -30,7 +30,7 @@ ifneq ($(CLEAN_BUILD),)
 endif
 
 LOCAL_GENERATOR_IMAGE ?= ebpf-generator:latest
-CILIUM_EBPF_VERSION := v0.17.2
+CILIUM_EBPF_VERSION := v0.17.3
 GOLANGCI_LINT_VERSION = v1.61.0
 GO_VERSION = "1.23.4"
 PROTOC_VERSION = "3.19.4"
diff --git a/go.mod b/go.mod
index 3ee13e703f34284f2f945e862e334fcaa948d784..83d147a61da7db79a5df9f96ab9f6bf513313029 100644
--- a/go.mod
+++ b/go.mod
@@ -6,7 +6,7 @@ toolchain go1.23.5
 
 require (
 	github.com/caarlos0/env/v6 v6.10.1
-	github.com/cilium/ebpf v0.17.2
+	github.com/cilium/ebpf v0.17.3
 	github.com/fsnotify/fsnotify v1.8.0
 	github.com/gavv/monotime v0.0.0-20190418164738-30dba4353424
 	github.com/gopacket/gopacket v1.3.1
diff --git a/go.sum b/go.sum
index 39d1537e86c835549ef6456528711796da323d67..be6453e594e2a9918f38aab722c0df31e14f9f40 100644
--- a/go.sum
+++ b/go.sum
@@ -142,8 +142,8 @@ github.com/cespare/xxhash/v2 v2.3.0/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XL
 github.com/chzyer/logex v1.1.10/go.mod h1:+Ywpsq7O8HXn0nuIou7OrIPyXbp3wmkHB+jjWRnGsAI=
 github.com/chzyer/readline v0.0.0-20180603132655-2972be24d48e/go.mod h1:nSuG5e5PlCu98SY8svDHJxuZscDgtXS6KTTbou5AhLI=
 github.com/chzyer/test v0.0.0-20180213035817-a1ea475d72b1/go.mod h1:Q3SI9o4m/ZMnBNeIyt5eFwwo7qiLfzFZmjNmxjkiQlU=
-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/circonus-labs/circonus-gometrics v2.3.1+incompatible/go.mod h1:nmEj6Dob7S7YxXgwXpfOuvO54S+tGdZdw9fuRZt25Ag=
 github.com/circonus-labs/circonusllhist v0.1.3/go.mod h1:kMXHVDlOchFAehlya5ePtbp5jckzBHf4XRpQvBOLI+I=
 github.com/clbanning/x2j v0.0.0-20191024224557-825249438eec/go.mod h1:jMjuTZXRI4dUb/I5gc9Hdhagfvm9+RyrPryS/auMzxE=
diff --git a/vendor/github.com/cilium/ebpf/btf/btf.go b/vendor/github.com/cilium/ebpf/btf/btf.go
index 880c5ade0c16a8a6d2017043013d3c8ab7cfd112..e8f80c1399776a39c29e544a395d8781e64b068f 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 2c684fe2a79a7c3a8c54a72a788433504dce6bf9..71dbba8061b79a5edff34a469e98824949e69321 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 56a1f1e9a318680d3ec3950bcb971f5ef3a2df5c..676e8fa6e74f192e7c7545b106555ee835dbe270 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 07d5efee0277e8e429af0d0b35318baf50fdaff7..10508fd8fcde4eb679511d21b43c91564cc78b54 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 e37f4cf671094bd81600e831dfb9b9e1a553130a..4fdb74c57ada1440eb947ea95f816bad75eec2fa 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 0000000000000000000000000000000000000000..0c4886bd13a79954e6aea6b5b0e4471a3ce8293e
--- /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 0000000000000000000000000000000000000000..fc2b042b5471b3585fa44944e2cba9a428b8b147
--- /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 0000000000000000000000000000000000000000..6077e983f3f1f727cf51573efa8d01e1b9529865
--- /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 0000000000000000000000000000000000000000..7500cd6d4ee1d33025c45f5896315da61350dd6c
--- /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 144e608d1c79ec92e9e31f661afb136d4f5fccb8..385adf08b86bcf1f68f29cc230a48e7ca89f96b8 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 806c6e567c970e617dbd53ff8d7146c9df1a8589..323f7ff34ed4d12bd488e63ee35fffb66d8cd76e 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 67c83f3b307f55a6b050093c81089878934dd589..764c3b447b5f78b79b5de68473f3561259f5c36d 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 5f37821ed888952ce2fd5c04b0a66c48e2f20c0d..507cc3e00c4574fda49250a415171fccbfefa721 100644
--- a/vendor/modules.txt
+++ b/vendor/modules.txt
@@ -42,7 +42,7 @@ github.com/cenkalti/rpc2/jsonrpc
 # github.com/cespare/xxhash/v2 v2.3.0
 ## explicit; go 1.11
 github.com/cespare/xxhash/v2
-# 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