From 9f5b20599369a58409e62a564737241257d3e6ab Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Andr=C3=A9s=20Medina?= <andresnrx@gmail.com>
Date: Sun, 28 May 2023 02:58:49 -0700
Subject: [PATCH] fixing easy TODOs

---
 aya/src/bpf.rs                              | 27 ++++---
 aya/src/maps/array/array.rs                 | 24 +++----
 aya/src/maps/array/per_cpu_array.rs         | 19 +++--
 aya/src/maps/array/program_array.rs         | 12 ++--
 aya/src/maps/bloom_filter.rs                |  8 +--
 aya/src/maps/hash_map/hash_map.rs           |  4 +-
 aya/src/maps/hash_map/mod.rs                |  8 +--
 aya/src/maps/hash_map/per_cpu_hash_map.rs   | 18 ++---
 aya/src/maps/lpm_trie.rs                    | 16 ++---
 aya/src/maps/mod.rs                         | 20 ++----
 aya/src/maps/perf/perf_event_array.rs       |  3 +-
 aya/src/maps/queue.rs                       |  7 +-
 aya/src/maps/sock/sock_hash.rs              |  3 +-
 aya/src/maps/sock/sock_map.rs               |  6 +-
 aya/src/maps/stack.rs                       | 13 ++--
 aya/src/maps/stack_trace.rs                 |  7 +-
 aya/src/programs/cgroup_device.rs           | 22 +++---
 aya/src/programs/cgroup_skb.rs              | 17 +++--
 aya/src/programs/cgroup_sock.rs             | 17 +++--
 aya/src/programs/cgroup_sock_addr.rs        | 17 +++--
 aya/src/programs/cgroup_sockopt.rs          | 17 +++--
 aya/src/programs/cgroup_sysctl.rs           | 22 +++---
 aya/src/programs/extension.rs               | 34 +++------
 aya/src/programs/links.rs                   |  5 +-
 aya/src/programs/lirc_mode2.rs              |  9 ++-
 aya/src/programs/mod.rs                     |  9 +--
 aya/src/programs/perf_attach.rs             | 22 +++---
 aya/src/programs/perf_event.rs              |  5 +-
 aya/src/programs/probe.rs                   |  7 +-
 aya/src/programs/sk_lookup.rs               |  8 +--
 aya/src/programs/sk_msg.rs                  |  9 ++-
 aya/src/programs/sk_skb.rs                  |  3 +-
 aya/src/programs/sock_ops.rs                |  9 ++-
 aya/src/programs/trace_point.rs             |  5 +-
 aya/src/programs/utils.rs                   | 16 ++---
 aya/src/programs/xdp.rs                     | 26 +++----
 aya/src/sys/bpf.rs                          | 80 +++++++++++----------
 test/integration-ebpf/src/bpf_probe_read.rs |  4 +-
 38 files changed, 243 insertions(+), 315 deletions(-)

diff --git a/aya/src/bpf.rs b/aya/src/bpf.rs
index ab6773f9..154ce6d6 100644
--- a/aya/src/bpf.rs
+++ b/aya/src/bpf.rs
@@ -3,7 +3,11 @@ use std::{
     collections::{HashMap, HashSet},
     ffi::CString,
     fs, io,
-    os::{fd::AsRawFd, raw::c_int, unix::io::RawFd},
+    os::{
+        fd::{AsFd, AsRawFd},
+        raw::c_int,
+        unix::io::RawFd,
+    },
     path::{Path, PathBuf},
 };
 
@@ -421,23 +425,16 @@ impl<'a> BpfLoader<'a> {
                 PinningType::None => map.create(&name)?,
             };
             // OK: we just loaded the map
-            let fd = map.fd.as_ref().unwrap();
+            let fd = map.fd.as_ref().unwrap().as_fd();
             if !map.obj.data().is_empty() && map.obj.section_kind() != BpfSectionKind::Bss {
-                // TODO (AM)
-                bpf_map_update_elem_ptr(
-                    fd.as_raw_fd(),
-                    &0 as *const _,
-                    map.obj.data_mut().as_mut_ptr(),
-                    0,
-                )
-                .map_err(|(_, io_error)| MapError::SyscallError {
-                    call: "bpf_map_update_elem".to_owned(),
-                    io_error,
-                })?;
+                bpf_map_update_elem_ptr(fd, &0 as *const _, map.obj.data_mut().as_mut_ptr(), 0)
+                    .map_err(|(_, io_error)| MapError::SyscallError {
+                        call: "bpf_map_update_elem".to_owned(),
+                        io_error,
+                    })?;
             }
             if map.obj.section_kind() == BpfSectionKind::Rodata {
-                // TODO (AM)
-                bpf_map_freeze(fd.as_raw_fd()).map_err(|(_, io_error)| MapError::SyscallError {
+                bpf_map_freeze(fd).map_err(|(_, io_error)| MapError::SyscallError {
                     call: "bpf_map_freeze".to_owned(),
                     io_error,
                 })?;
diff --git a/aya/src/maps/array/array.rs b/aya/src/maps/array/array.rs
index 07b55cc9..71ac1223 100644
--- a/aya/src/maps/array/array.rs
+++ b/aya/src/maps/array/array.rs
@@ -1,7 +1,6 @@
 use std::{
     borrow::{Borrow, BorrowMut},
     marker::PhantomData,
-    os::fd::AsRawFd,
 };
 
 use crate::{
@@ -66,14 +65,12 @@ impl<T: Borrow<MapData>, V: Pod> Array<T, V> {
         check_bounds(data, *index)?;
         let fd = data.fd_or_err()?;
 
-        // TODO (AM)
-        let value =
-            bpf_map_lookup_elem(fd.as_raw_fd(), index, flags).map_err(|(_, io_error)| {
-                MapError::SyscallError {
-                    call: "bpf_map_lookup_elem".to_owned(),
-                    io_error,
-                }
-            })?;
+        let value = bpf_map_lookup_elem(fd, index, flags).map_err(|(_, io_error)| {
+            MapError::SyscallError {
+                call: "bpf_map_lookup_elem".to_owned(),
+                io_error,
+            }
+        })?;
         value.ok_or(MapError::KeyNotFound)
     }
 
@@ -95,13 +92,12 @@ impl<T: BorrowMut<MapData>, V: Pod> Array<T, V> {
         let data = self.inner.borrow_mut();
         check_bounds(data, index)?;
         let fd = data.fd_or_err()?;
-        // TODO (AM)
-        bpf_map_update_elem(fd.as_raw_fd(), Some(&index), value.borrow(), flags).map_err(
-            |(_, io_error)| MapError::SyscallError {
+        bpf_map_update_elem(fd, Some(&index), value.borrow(), flags).map_err(|(_, io_error)| {
+            MapError::SyscallError {
                 call: "bpf_map_update_elem".to_owned(),
                 io_error,
-            },
-        )?;
+            }
+        })?;
         Ok(())
     }
 }
diff --git a/aya/src/maps/array/per_cpu_array.rs b/aya/src/maps/array/per_cpu_array.rs
index fcfc8090..e83f59e5 100644
--- a/aya/src/maps/array/per_cpu_array.rs
+++ b/aya/src/maps/array/per_cpu_array.rs
@@ -1,7 +1,6 @@
 use std::{
     borrow::{Borrow, BorrowMut},
     marker::PhantomData,
-    os::fd::AsRawFd,
 };
 
 use crate::{
@@ -85,13 +84,12 @@ impl<T: Borrow<MapData>, V: Pod> PerCpuArray<T, V> {
         check_bounds(data, *index)?;
         let fd = data.fd_or_err()?;
 
-        // TODO (AM)
-        let value = bpf_map_lookup_elem_per_cpu(fd.as_raw_fd(), index, flags).map_err(
-            |(_, io_error)| MapError::SyscallError {
+        let value = bpf_map_lookup_elem_per_cpu(fd, index, flags).map_err(|(_, io_error)| {
+            MapError::SyscallError {
                 call: "bpf_map_lookup_elem".to_owned(),
                 io_error,
-            },
-        )?;
+            }
+        })?;
         value.ok_or(MapError::KeyNotFound)
     }
 
@@ -114,13 +112,12 @@ impl<T: BorrowMut<MapData>, V: Pod> PerCpuArray<T, V> {
         check_bounds(data, index)?;
         let fd = data.fd_or_err()?;
 
-        // TODO (AM)
-        bpf_map_update_elem_per_cpu(fd.as_raw_fd(), &index, &values, flags).map_err(
-            |(_, io_error)| MapError::SyscallError {
+        bpf_map_update_elem_per_cpu(fd, &index, &values, flags).map_err(|(_, io_error)| {
+            MapError::SyscallError {
                 call: "bpf_map_update_elem".to_owned(),
                 io_error,
-            },
-        )?;
+            }
+        })?;
         Ok(())
     }
 }
diff --git a/aya/src/maps/array/program_array.rs b/aya/src/maps/array/program_array.rs
index fb19cf26..8418b1cd 100644
--- a/aya/src/maps/array/program_array.rs
+++ b/aya/src/maps/array/program_array.rs
@@ -79,13 +79,12 @@ impl<T: BorrowMut<MapData>> ProgramArray<T> {
         let fd = data.fd_or_err()?;
         let prog_fd = program.as_raw_fd();
 
-        // TODO (AM)
-        bpf_map_update_elem(fd.as_raw_fd(), Some(&index), &prog_fd, flags).map_err(
-            |(_, io_error)| MapError::SyscallError {
+        bpf_map_update_elem(fd, Some(&index), &prog_fd, flags).map_err(|(_, io_error)| {
+            MapError::SyscallError {
                 call: "bpf_map_update_elem".to_owned(),
                 io_error,
-            },
-        )?;
+            }
+        })?;
         Ok(())
     }
 
@@ -98,8 +97,7 @@ impl<T: BorrowMut<MapData>> ProgramArray<T> {
         check_bounds(data, *index)?;
         let fd = self.inner.borrow_mut().fd_or_err()?;
 
-        // TODO (AM)
-        bpf_map_delete_elem(fd.as_raw_fd(), index)
+        bpf_map_delete_elem(fd, index)
             .map(|_| ())
             .map_err(|(_, io_error)| MapError::SyscallError {
                 call: "bpf_map_delete_elem".to_owned(),
diff --git a/aya/src/maps/bloom_filter.rs b/aya/src/maps/bloom_filter.rs
index afc9c5b5..deb2c053 100644
--- a/aya/src/maps/bloom_filter.rs
+++ b/aya/src/maps/bloom_filter.rs
@@ -1,5 +1,5 @@
 //! A Bloom Filter.
-use std::{borrow::Borrow, marker::PhantomData, os::fd::AsRawFd};
+use std::{borrow::Borrow, marker::PhantomData};
 
 use crate::{
     maps::{check_v_size, MapData, MapError},
@@ -52,8 +52,7 @@ impl<T: Borrow<MapData>, V: Pod> BloomFilter<T, V> {
     pub fn contains(&self, mut value: &V, flags: u64) -> Result<(), MapError> {
         let fd = self.inner.borrow().fd_or_err()?;
 
-        // TODO (AM)
-        bpf_map_lookup_elem_ptr::<u32, _>(fd.as_raw_fd(), None, &mut value, flags)
+        bpf_map_lookup_elem_ptr::<u32, _>(fd, None, &mut value, flags)
             .map_err(|(_, io_error)| MapError::SyscallError {
                 call: "bpf_map_lookup_elem".to_owned(),
                 io_error,
@@ -65,8 +64,7 @@ impl<T: Borrow<MapData>, V: Pod> BloomFilter<T, V> {
     /// Inserts a value into the map.
     pub fn insert(&self, value: impl Borrow<V>, flags: u64) -> Result<(), MapError> {
         let fd = self.inner.borrow().fd_or_err()?;
-        // TODO (AM)
-        bpf_map_push_elem(fd.as_raw_fd(), value.borrow(), flags).map_err(|(_, io_error)| {
+        bpf_map_push_elem(fd, value.borrow(), flags).map_err(|(_, io_error)| {
             MapError::SyscallError {
                 call: "bpf_map_push_elem".to_owned(),
                 io_error,
diff --git a/aya/src/maps/hash_map/hash_map.rs b/aya/src/maps/hash_map/hash_map.rs
index bfe3dc71..d70ec1bb 100644
--- a/aya/src/maps/hash_map/hash_map.rs
+++ b/aya/src/maps/hash_map/hash_map.rs
@@ -1,7 +1,6 @@
 use std::{
     borrow::{Borrow, BorrowMut},
     marker::PhantomData,
-    os::fd::AsRawFd,
 };
 
 use crate::{
@@ -55,8 +54,7 @@ impl<T: Borrow<MapData>, K: Pod, V: Pod> HashMap<T, K, V> {
     /// Returns a copy of the value associated with the key.
     pub fn get(&self, key: &K, flags: u64) -> Result<V, MapError> {
         let fd = self.inner.borrow().fd_or_err()?;
-        // TODO (AM)
-        let value = bpf_map_lookup_elem(fd.as_raw_fd(), key, flags).map_err(|(_, io_error)| {
+        let value = bpf_map_lookup_elem(fd, key, flags).map_err(|(_, io_error)| {
             MapError::SyscallError {
                 call: "bpf_map_lookup_elem".to_owned(),
                 io_error,
diff --git a/aya/src/maps/hash_map/mod.rs b/aya/src/maps/hash_map/mod.rs
index a816ff97..f1e1837f 100644
--- a/aya/src/maps/hash_map/mod.rs
+++ b/aya/src/maps/hash_map/mod.rs
@@ -1,6 +1,4 @@
 //! Hash map types.
-use std::os::fd::AsRawFd;
-
 use crate::{
     maps::MapError,
     sys::{bpf_map_delete_elem, bpf_map_update_elem},
@@ -23,8 +21,7 @@ pub(crate) fn insert<K: Pod, V: Pod>(
     flags: u64,
 ) -> Result<(), MapError> {
     let fd = map.fd_or_err()?;
-    // TODO (AM)
-    bpf_map_update_elem(fd.as_raw_fd(), Some(key), value, flags).map_err(|(_, io_error)| {
+    bpf_map_update_elem(fd, Some(key), value, flags).map_err(|(_, io_error)| {
         MapError::SyscallError {
             call: "bpf_map_update_elem".to_owned(),
             io_error,
@@ -36,8 +33,7 @@ pub(crate) fn insert<K: Pod, V: Pod>(
 
 pub(crate) fn remove<K: Pod>(map: &mut MapData, key: &K) -> Result<(), MapError> {
     let fd = map.fd_or_err()?;
-    // TODO (AM)
-    bpf_map_delete_elem(fd.as_raw_fd(), key)
+    bpf_map_delete_elem(fd, key)
         .map(|_| ())
         .map_err(|(_, io_error)| MapError::SyscallError {
             call: "bpf_map_delete_elem".to_owned(),
diff --git a/aya/src/maps/hash_map/per_cpu_hash_map.rs b/aya/src/maps/hash_map/per_cpu_hash_map.rs
index 34d60689..aaa48838 100644
--- a/aya/src/maps/hash_map/per_cpu_hash_map.rs
+++ b/aya/src/maps/hash_map/per_cpu_hash_map.rs
@@ -2,7 +2,6 @@
 use std::{
     borrow::{Borrow, BorrowMut},
     marker::PhantomData,
-    os::fd::AsRawFd,
 };
 
 use crate::{
@@ -65,14 +64,12 @@ impl<T: Borrow<MapData>, K: Pod, V: Pod> PerCpuHashMap<T, K, V> {
     /// Returns a slice of values - one for each CPU - associated with the key.
     pub fn get(&self, key: &K, flags: u64) -> Result<PerCpuValues<V>, MapError> {
         let fd = self.inner.borrow().fd_or_err()?;
-        let values =
-            // TODO (AM)
-            bpf_map_lookup_elem_per_cpu(fd.as_raw_fd(), key, flags).map_err(|(_, io_error)| {
-                MapError::SyscallError {
-                    call: "bpf_map_lookup_elem".to_owned(),
-                    io_error,
-                }
-            })?;
+        let values = bpf_map_lookup_elem_per_cpu(fd, key, flags).map_err(|(_, io_error)| {
+            MapError::SyscallError {
+                call: "bpf_map_lookup_elem".to_owned(),
+                io_error,
+            }
+        })?;
         values.ok_or(MapError::KeyNotFound)
     }
 
@@ -125,8 +122,7 @@ impl<T: BorrowMut<MapData>, K: Pod, V: Pod> PerCpuHashMap<T, K, V> {
         flags: u64,
     ) -> Result<(), MapError> {
         let fd = self.inner.borrow_mut().fd_or_err()?;
-        // TODO (AM)
-        bpf_map_update_elem_per_cpu(fd.as_raw_fd(), key.borrow(), &values, flags).map_err(
+        bpf_map_update_elem_per_cpu(fd, key.borrow(), &values, flags).map_err(
             |(_, io_error)| MapError::SyscallError {
                 call: "bpf_map_update_elem".to_owned(),
                 io_error,
diff --git a/aya/src/maps/lpm_trie.rs b/aya/src/maps/lpm_trie.rs
index 177fa213..e5c5cf53 100644
--- a/aya/src/maps/lpm_trie.rs
+++ b/aya/src/maps/lpm_trie.rs
@@ -2,7 +2,6 @@
 use std::{
     borrow::{Borrow, BorrowMut},
     marker::PhantomData,
-    os::fd::AsRawFd,
 };
 
 use crate::{
@@ -129,8 +128,7 @@ impl<T: Borrow<MapData>, K: Pod, V: Pod> LpmTrie<T, K, V> {
     /// Returns a copy of the value associated with the longest prefix matching key in the LpmTrie.
     pub fn get(&self, key: &Key<K>, flags: u64) -> Result<V, MapError> {
         let fd = self.inner.borrow().fd_or_err()?;
-        // TODO (AM)
-        let value = bpf_map_lookup_elem(fd.as_raw_fd(), key, flags).map_err(|(_, io_error)| {
+        let value = bpf_map_lookup_elem(fd, key, flags).map_err(|(_, io_error)| {
             MapError::SyscallError {
                 call: "bpf_map_lookup_elem".to_owned(),
                 io_error,
@@ -161,13 +159,12 @@ impl<T: BorrowMut<MapData>, K: Pod, V: Pod> LpmTrie<T, K, V> {
         flags: u64,
     ) -> Result<(), MapError> {
         let fd = self.inner.borrow().fd_or_err()?;
-        // TODO (AM)
-        bpf_map_update_elem(fd.as_raw_fd(), Some(key), value.borrow(), flags).map_err(
-            |(_, io_error)| MapError::SyscallError {
+        bpf_map_update_elem(fd, Some(key), value.borrow(), flags).map_err(|(_, io_error)| {
+            MapError::SyscallError {
                 call: "bpf_map_update_elem".to_owned(),
                 io_error,
-            },
-        )?;
+            }
+        })?;
 
         Ok(())
     }
@@ -177,8 +174,7 @@ impl<T: BorrowMut<MapData>, K: Pod, V: Pod> LpmTrie<T, K, V> {
     /// Both the prefix and data must match exactly - this method does not do a longest prefix match.
     pub fn remove(&mut self, key: &Key<K>) -> Result<(), MapError> {
         let fd = self.inner.borrow().fd_or_err()?;
-        // TODO (AM)
-        bpf_map_delete_elem(fd.as_raw_fd(), key)
+        bpf_map_delete_elem(fd, key)
             .map(|_| ())
             .map_err(|(_, io_error)| MapError::SyscallError {
                 call: "bpf_map_delete_elem".to_owned(),
diff --git a/aya/src/maps/mod.rs b/aya/src/maps/mod.rs
index 68ad72d2..e3dc4f99 100644
--- a/aya/src/maps/mod.rs
+++ b/aya/src/maps/mod.rs
@@ -549,9 +549,8 @@ impl MapData {
             io_error,
         })?;
 
-        // TODO (AM)
         let info =
-            bpf_map_get_info_by_fd(fd.as_raw_fd()).map_err(|io_error| MapError::SyscallError {
+            bpf_map_get_info_by_fd(fd.as_fd()).map_err(|io_error| MapError::SyscallError {
                 call: "BPF_MAP_GET_INFO_BY_FD".to_owned(),
                 io_error,
             })?;
@@ -570,9 +569,8 @@ impl MapData {
     /// This API is intended for cases where you have received a valid BPF FD from some other means.
     /// For example, you received an FD over Unix Domain Socket.
     pub fn from_fd(fd: OwnedFd) -> Result<MapData, MapError> {
-        // TODO (AM)
         let info =
-            bpf_map_get_info_by_fd(fd.as_raw_fd()).map_err(|io_error| MapError::SyscallError {
+            bpf_map_get_info_by_fd(fd.as_fd()).map_err(|io_error| MapError::SyscallError {
                 call: "BPF_OBJ_GET".to_owned(),
                 io_error,
             })?;
@@ -597,7 +595,7 @@ impl MapData {
             return Err(PinError::AlreadyPinned { name: name.into() });
         }
         let map_path = path.as_ref().join(name);
-        let fd = self.fd.as_ref().ok_or(PinError::NoFd {
+        let fd = self.fd.as_ref().map(|f| f.as_fd()).ok_or(PinError::NoFd {
             name: name.to_string(),
         })?;
         let path_string = CString::new(map_path.to_string_lossy().into_owned()).map_err(|e| {
@@ -605,12 +603,9 @@ impl MapData {
                 error: e.to_string(),
             }
         })?;
-        // TODO (AM): switch to BorrowedFd
-        bpf_pin_object(fd.as_raw_fd(), &path_string).map_err(|(_, io_error)| {
-            PinError::SyscallError {
-                name: "BPF_OBJ_PIN".to_string(),
-                io_error,
-            }
+        bpf_pin_object(fd, &path_string).map_err(|(_, io_error)| PinError::SyscallError {
+            name: "BPF_OBJ_PIN".to_string(),
+            io_error,
         })?;
         self.pinned = true;
         Ok(())
@@ -690,8 +685,7 @@ impl<K: Pod> Iterator for MapKeys<'_, K> {
             }
         };
 
-        // TODO (AM)
-        match bpf_map_get_next_key(fd.as_raw_fd(), self.key.as_ref()) {
+        match bpf_map_get_next_key(fd, self.key.as_ref()) {
             Ok(Some(key)) => {
                 self.key = Some(key);
                 Some(Ok(key))
diff --git a/aya/src/maps/perf/perf_event_array.rs b/aya/src/maps/perf/perf_event_array.rs
index 17f408f0..7a24bf28 100644
--- a/aya/src/maps/perf/perf_event_array.rs
+++ b/aya/src/maps/perf/perf_event_array.rs
@@ -186,8 +186,7 @@ impl<T: BorrowMut<MapData> + Borrow<MapData>> PerfEventArray<T> {
         let map_data: &MapData = self.map.deref().borrow();
         let map_fd = map_data.fd_or_err().unwrap();
         let buf = PerfBuffer::open(index, self.page_size, page_count.unwrap_or(2))?;
-        // TODO (AM)
-        bpf_map_update_elem(map_fd.as_raw_fd(), Some(&index), &buf.as_raw_fd(), 0)
+        bpf_map_update_elem(map_fd, Some(&index), &buf.as_raw_fd(), 0)
             .map_err(|(_, io_error)| io_error)?;
 
         Ok(PerfEventArrayBuffer {
diff --git a/aya/src/maps/queue.rs b/aya/src/maps/queue.rs
index a5589674..c6810546 100644
--- a/aya/src/maps/queue.rs
+++ b/aya/src/maps/queue.rs
@@ -2,7 +2,6 @@
 use std::{
     borrow::{Borrow, BorrowMut},
     marker::PhantomData,
-    os::fd::AsRawFd,
 };
 
 use crate::{
@@ -65,8 +64,7 @@ impl<T: BorrowMut<MapData>, V: Pod> Queue<T, V> {
     pub fn pop(&mut self, flags: u64) -> Result<V, MapError> {
         let fd = self.inner.borrow().fd_or_err()?;
 
-        // TODO (AM)
-        let value = bpf_map_lookup_and_delete_elem::<u32, _>(fd.as_raw_fd(), None, flags).map_err(
+        let value = bpf_map_lookup_and_delete_elem::<u32, _>(fd, None, flags).map_err(
             |(_, io_error)| MapError::SyscallError {
                 call: "bpf_map_lookup_and_delete_elem".to_owned(),
                 io_error,
@@ -82,8 +80,7 @@ impl<T: BorrowMut<MapData>, V: Pod> Queue<T, V> {
     /// [`MapError::SyscallError`] if `bpf_map_update_elem` fails.
     pub fn push(&mut self, value: impl Borrow<V>, flags: u64) -> Result<(), MapError> {
         let fd = self.inner.borrow().fd_or_err()?;
-        // TODO (AM)
-        bpf_map_push_elem(fd.as_raw_fd(), value.borrow(), flags).map_err(|(_, io_error)| {
+        bpf_map_push_elem(fd, value.borrow(), flags).map_err(|(_, io_error)| {
             MapError::SyscallError {
                 call: "bpf_map_push_elem".to_owned(),
                 io_error,
diff --git a/aya/src/maps/sock/sock_hash.rs b/aya/src/maps/sock/sock_hash.rs
index cbe0ddf8..89a49e9a 100644
--- a/aya/src/maps/sock/sock_hash.rs
+++ b/aya/src/maps/sock/sock_hash.rs
@@ -83,8 +83,7 @@ impl<T: Borrow<MapData>, K: Pod> SockHash<T, K> {
     /// Returns the fd of the socket stored at the given key.
     pub fn get(&self, key: &K, flags: u64) -> Result<RawFd, MapError> {
         let fd = self.inner.borrow().fd_or_err()?;
-        // TODO (AM)
-        let value = bpf_map_lookup_elem(fd.as_raw_fd(), key, flags).map_err(|(_, io_error)| {
+        let value = bpf_map_lookup_elem(fd, key, flags).map_err(|(_, io_error)| {
             MapError::SyscallError {
                 call: "bpf_map_lookup_elem".to_owned(),
                 io_error,
diff --git a/aya/src/maps/sock/sock_map.rs b/aya/src/maps/sock/sock_map.rs
index b76fe2af..ccc9e777 100644
--- a/aya/src/maps/sock/sock_map.rs
+++ b/aya/src/maps/sock/sock_map.rs
@@ -76,8 +76,7 @@ impl<T: BorrowMut<MapData>> SockMap<T> {
         let data = self.inner.borrow_mut();
         let fd = data.fd_or_err()?;
         check_bounds(data, index)?;
-        // TODO (AM)
-        bpf_map_update_elem(fd.as_raw_fd(), Some(&index), &socket.as_raw_fd(), flags).map_err(
+        bpf_map_update_elem(fd, Some(&index), &socket.as_raw_fd(), flags).map_err(
             |(_, io_error)| MapError::SyscallError {
                 call: "bpf_map_update_elem".to_owned(),
                 io_error,
@@ -91,8 +90,7 @@ impl<T: BorrowMut<MapData>> SockMap<T> {
         let data = self.inner.borrow_mut();
         let fd = data.fd_or_err()?;
         check_bounds(data, *index)?;
-        // TODO (AM)
-        bpf_map_delete_elem(fd.as_raw_fd(), index)
+        bpf_map_delete_elem(fd, index)
             .map(|_| ())
             .map_err(|(_, io_error)| MapError::SyscallError {
                 call: "bpf_map_delete_elem".to_owned(),
diff --git a/aya/src/maps/stack.rs b/aya/src/maps/stack.rs
index 124b2d5e..db428ddf 100644
--- a/aya/src/maps/stack.rs
+++ b/aya/src/maps/stack.rs
@@ -2,7 +2,6 @@
 use std::{
     borrow::{Borrow, BorrowMut},
     marker::PhantomData,
-    os::fd::AsRawFd,
 };
 
 use crate::{
@@ -65,8 +64,7 @@ impl<T: BorrowMut<MapData>, V: Pod> Stack<T, V> {
     pub fn pop(&mut self, flags: u64) -> Result<V, MapError> {
         let fd = self.inner.borrow().fd_or_err()?;
 
-        // TODO (AM)
-        let value = bpf_map_lookup_and_delete_elem::<u32, _>(fd.as_raw_fd(), None, flags).map_err(
+        let value = bpf_map_lookup_and_delete_elem::<u32, _>(fd, None, flags).map_err(
             |(_, io_error)| MapError::SyscallError {
                 call: "bpf_map_lookup_and_delete_elem".to_owned(),
                 io_error,
@@ -82,13 +80,12 @@ impl<T: BorrowMut<MapData>, V: Pod> Stack<T, V> {
     /// [`MapError::SyscallError`] if `bpf_map_update_elem` fails.
     pub fn push(&mut self, value: impl Borrow<V>, flags: u64) -> Result<(), MapError> {
         let fd = self.inner.borrow().fd_or_err()?;
-        // TODO (AM)
-        bpf_map_update_elem(fd.as_raw_fd(), None::<&u32>, value.borrow(), flags).map_err(
-            |(_, io_error)| MapError::SyscallError {
+        bpf_map_update_elem(fd, None::<&u32>, value.borrow(), flags).map_err(|(_, io_error)| {
+            MapError::SyscallError {
                 call: "bpf_map_update_elem".to_owned(),
                 io_error,
-            },
-        )?;
+            }
+        })?;
         Ok(())
     }
 }
diff --git a/aya/src/maps/stack_trace.rs b/aya/src/maps/stack_trace.rs
index 90121336..894fd36a 100644
--- a/aya/src/maps/stack_trace.rs
+++ b/aya/src/maps/stack_trace.rs
@@ -1,9 +1,7 @@
 //! A hash map of kernel or user space stack traces.
 //!
 //! See [`StackTraceMap`] for documentation and examples.
-use std::{
-    borrow::Borrow, collections::BTreeMap, fs, io, mem, os::fd::AsRawFd, path::Path, str::FromStr,
-};
+use std::{borrow::Borrow, collections::BTreeMap, fs, io, mem, path::Path, str::FromStr};
 
 use crate::{
     maps::{IterableMap, MapData, MapError, MapIter, MapKeys},
@@ -107,8 +105,7 @@ impl<T: Borrow<MapData>> StackTraceMap<T> {
         let fd = self.inner.borrow().fd_or_err()?;
 
         let mut frames = vec![0; self.max_stack_depth];
-        // TODO (AM)
-        bpf_map_lookup_elem_ptr(fd.as_raw_fd(), Some(stack_id), frames.as_mut_ptr(), flags)
+        bpf_map_lookup_elem_ptr(fd, Some(stack_id), frames.as_mut_ptr(), flags)
             .map_err(|(_, io_error)| MapError::SyscallError {
                 call: "bpf_map_lookup_elem".to_owned(),
                 io_error,
diff --git a/aya/src/programs/cgroup_device.rs b/aya/src/programs/cgroup_device.rs
index 143b9547..8b7d433f 100644
--- a/aya/src/programs/cgroup_device.rs
+++ b/aya/src/programs/cgroup_device.rs
@@ -64,26 +64,24 @@ impl CgroupDevice {
 
         let k_ver = kernel_version().unwrap();
         if k_ver >= (5, 7, 0) {
-            // TODO (AM)
-            let link_fd =
-                bpf_link_create(prog_fd.as_raw_fd(), cgroup_fd, BPF_CGROUP_DEVICE, None, 0)
-                    .map_err(|(_, io_error)| ProgramError::SyscallError {
-                        call: "bpf_link_create".to_owned(),
-                        io_error,
-                    })?;
+            let link_fd = bpf_link_create(prog_fd, cgroup_fd, BPF_CGROUP_DEVICE, None, 0).map_err(
+                |(_, io_error)| ProgramError::SyscallError {
+                    call: "bpf_link_create".to_owned(),
+                    io_error,
+                },
+            )?;
             self.data
                 .links
                 .insert(CgroupDeviceLink::new(CgroupDeviceLinkInner::Fd(
                     FdLink::new(link_fd),
                 )))
         } else {
-            // TODO (AM)
-            bpf_prog_attach(prog_fd.as_raw_fd(), cgroup_fd, BPF_CGROUP_DEVICE).map_err(
-                |(_, io_error)| ProgramError::SyscallError {
+            bpf_prog_attach(prog_fd, cgroup_fd, BPF_CGROUP_DEVICE).map_err(|(_, io_error)| {
+                ProgramError::SyscallError {
                     call: "bpf_prog_attach".to_owned(),
                     io_error,
-                },
-            )?;
+                }
+            })?;
             self.data
                 .links
                 .insert(CgroupDeviceLink::new(CgroupDeviceLinkInner::ProgAttach(
diff --git a/aya/src/programs/cgroup_skb.rs b/aya/src/programs/cgroup_skb.rs
index 77e49307..d59f252d 100644
--- a/aya/src/programs/cgroup_skb.rs
+++ b/aya/src/programs/cgroup_skb.rs
@@ -94,25 +94,24 @@ impl CgroupSkb {
         };
         let k_ver = kernel_version().unwrap();
         if k_ver >= (5, 7, 0) {
-            // TODO (AM)
-            let link_fd = bpf_link_create(prog_fd.as_raw_fd(), cgroup_fd, attach_type, None, 0)
-                .map_err(|(_, io_error)| ProgramError::SyscallError {
+            let link_fd = bpf_link_create(prog_fd, cgroup_fd, attach_type, None, 0).map_err(
+                |(_, io_error)| ProgramError::SyscallError {
                     call: "bpf_link_create".to_owned(),
                     io_error,
-                })?;
+                },
+            )?;
             self.data
                 .links
                 .insert(CgroupSkbLink::new(CgroupSkbLinkInner::Fd(FdLink::new(
                     link_fd,
                 ))))
         } else {
-            // TODO (AM)
-            bpf_prog_attach(prog_fd.as_raw_fd(), cgroup_fd, attach_type).map_err(
-                |(_, io_error)| ProgramError::SyscallError {
+            bpf_prog_attach(prog_fd, cgroup_fd, attach_type).map_err(|(_, io_error)| {
+                ProgramError::SyscallError {
                     call: "bpf_prog_attach".to_owned(),
                     io_error,
-                },
-            )?;
+                }
+            })?;
 
             self.data
                 .links
diff --git a/aya/src/programs/cgroup_sock.rs b/aya/src/programs/cgroup_sock.rs
index 16fdb3c9..24c72847 100644
--- a/aya/src/programs/cgroup_sock.rs
+++ b/aya/src/programs/cgroup_sock.rs
@@ -69,25 +69,24 @@ impl CgroupSock {
         let attach_type = self.data.expected_attach_type.unwrap();
         let k_ver = kernel_version().unwrap();
         if k_ver >= (5, 7, 0) {
-            // TODO (AM)
-            let link_fd = bpf_link_create(prog_fd.as_raw_fd(), cgroup_fd, attach_type, None, 0)
-                .map_err(|(_, io_error)| ProgramError::SyscallError {
+            let link_fd = bpf_link_create(prog_fd, cgroup_fd, attach_type, None, 0).map_err(
+                |(_, io_error)| ProgramError::SyscallError {
                     call: "bpf_link_create".to_owned(),
                     io_error,
-                })?;
+                },
+            )?;
             self.data
                 .links
                 .insert(CgroupSockLink::new(CgroupSockLinkInner::Fd(FdLink::new(
                     link_fd,
                 ))))
         } else {
-            // TODO (AM)
-            bpf_prog_attach(prog_fd.as_raw_fd(), cgroup_fd, attach_type).map_err(
-                |(_, io_error)| ProgramError::SyscallError {
+            bpf_prog_attach(prog_fd, cgroup_fd, attach_type).map_err(|(_, io_error)| {
+                ProgramError::SyscallError {
                     call: "bpf_prog_attach".to_owned(),
                     io_error,
-                },
-            )?;
+                }
+            })?;
 
             self.data
                 .links
diff --git a/aya/src/programs/cgroup_sock_addr.rs b/aya/src/programs/cgroup_sock_addr.rs
index 2116a041..07169300 100644
--- a/aya/src/programs/cgroup_sock_addr.rs
+++ b/aya/src/programs/cgroup_sock_addr.rs
@@ -70,25 +70,24 @@ impl CgroupSockAddr {
         let attach_type = self.data.expected_attach_type.unwrap();
         let k_ver = kernel_version().unwrap();
         if k_ver >= (5, 7, 0) {
-            // TODO (AM)
-            let link_fd = bpf_link_create(prog_fd.as_raw_fd(), cgroup_fd, attach_type, None, 0)
-                .map_err(|(_, io_error)| ProgramError::SyscallError {
+            let link_fd = bpf_link_create(prog_fd, cgroup_fd, attach_type, None, 0).map_err(
+                |(_, io_error)| ProgramError::SyscallError {
                     call: "bpf_link_create".to_owned(),
                     io_error,
-                })?;
+                },
+            )?;
             self.data
                 .links
                 .insert(CgroupSockAddrLink::new(CgroupSockAddrLinkInner::Fd(
                     FdLink::new(link_fd),
                 )))
         } else {
-            // TODO (AM)
-            bpf_prog_attach(prog_fd.as_raw_fd(), cgroup_fd, attach_type).map_err(
-                |(_, io_error)| ProgramError::SyscallError {
+            bpf_prog_attach(prog_fd, cgroup_fd, attach_type).map_err(|(_, io_error)| {
+                ProgramError::SyscallError {
                     call: "bpf_prog_attach".to_owned(),
                     io_error,
-                },
-            )?;
+                }
+            })?;
 
             self.data.links.insert(CgroupSockAddrLink::new(
                 CgroupSockAddrLinkInner::ProgAttach(ProgAttachLink::new(
diff --git a/aya/src/programs/cgroup_sockopt.rs b/aya/src/programs/cgroup_sockopt.rs
index 3ca526ad..dcb7f3c2 100644
--- a/aya/src/programs/cgroup_sockopt.rs
+++ b/aya/src/programs/cgroup_sockopt.rs
@@ -67,25 +67,24 @@ impl CgroupSockopt {
         let attach_type = self.data.expected_attach_type.unwrap();
         let k_ver = kernel_version().unwrap();
         if k_ver >= (5, 7, 0) {
-            // TODO (AM)
-            let link_fd = bpf_link_create(prog_fd.as_raw_fd(), cgroup_fd, attach_type, None, 0)
-                .map_err(|(_, io_error)| ProgramError::SyscallError {
+            let link_fd = bpf_link_create(prog_fd, cgroup_fd, attach_type, None, 0).map_err(
+                |(_, io_error)| ProgramError::SyscallError {
                     call: "bpf_link_create".to_owned(),
                     io_error,
-                })?;
+                },
+            )?;
             self.data
                 .links
                 .insert(CgroupSockoptLink::new(CgroupSockoptLinkInner::Fd(
                     FdLink::new(link_fd),
                 )))
         } else {
-            // TODO (AM)
-            bpf_prog_attach(prog_fd.as_raw_fd(), cgroup_fd, attach_type).map_err(
-                |(_, io_error)| ProgramError::SyscallError {
+            bpf_prog_attach(prog_fd, cgroup_fd, attach_type).map_err(|(_, io_error)| {
+                ProgramError::SyscallError {
                     call: "bpf_prog_attach".to_owned(),
                     io_error,
-                },
-            )?;
+                }
+            })?;
 
             self.data
                 .links
diff --git a/aya/src/programs/cgroup_sysctl.rs b/aya/src/programs/cgroup_sysctl.rs
index ebc85df4..e2f5d2e3 100644
--- a/aya/src/programs/cgroup_sysctl.rs
+++ b/aya/src/programs/cgroup_sysctl.rs
@@ -63,26 +63,24 @@ impl CgroupSysctl {
 
         let k_ver = kernel_version().unwrap();
         if k_ver >= (5, 7, 0) {
-            // TODO (AM)
-            let link_fd =
-                bpf_link_create(prog_fd.as_raw_fd(), cgroup_fd, BPF_CGROUP_SYSCTL, None, 0)
-                    .map_err(|(_, io_error)| ProgramError::SyscallError {
-                        call: "bpf_link_create".to_owned(),
-                        io_error,
-                    })?;
+            let link_fd = bpf_link_create(prog_fd, cgroup_fd, BPF_CGROUP_SYSCTL, None, 0).map_err(
+                |(_, io_error)| ProgramError::SyscallError {
+                    call: "bpf_link_create".to_owned(),
+                    io_error,
+                },
+            )?;
             self.data
                 .links
                 .insert(CgroupSysctlLink::new(CgroupSysctlLinkInner::Fd(
                     FdLink::new(link_fd),
                 )))
         } else {
-            // TODO (AM)
-            bpf_prog_attach(prog_fd.as_raw_fd(), cgroup_fd, BPF_CGROUP_SYSCTL).map_err(
-                |(_, io_error)| ProgramError::SyscallError {
+            bpf_prog_attach(prog_fd, cgroup_fd, BPF_CGROUP_SYSCTL).map_err(|(_, io_error)| {
+                ProgramError::SyscallError {
                     call: "bpf_prog_attach".to_owned(),
                     io_error,
-                },
-            )?;
+                }
+            })?;
 
             self.data
                 .links
diff --git a/aya/src/programs/extension.rs b/aya/src/programs/extension.rs
index 25862466..32a51042 100644
--- a/aya/src/programs/extension.rs
+++ b/aya/src/programs/extension.rs
@@ -92,18 +92,11 @@ impl Extension {
         let target_fd = self.data.attach_prog_fd.ok_or(ProgramError::NotLoaded)?;
         let btf_id = self.data.attach_btf_id.ok_or(ProgramError::NotLoaded)?;
         // the attach type must be set as 0, which is bpf_attach_type::BPF_CGROUP_INET_INGRESS
-        // TODO (AM)
-        let link_fd = bpf_link_create(
-            prog_fd.as_raw_fd(),
-            target_fd,
-            BPF_CGROUP_INET_INGRESS,
-            Some(btf_id),
-            0,
-        )
-        .map_err(|(_, io_error)| ProgramError::SyscallError {
-            call: "bpf_link_create".to_owned(),
-            io_error,
-        })?;
+        let link_fd = bpf_link_create(prog_fd, target_fd, BPF_CGROUP_INET_INGRESS, Some(btf_id), 0)
+            .map_err(|(_, io_error)| ProgramError::SyscallError {
+                call: "bpf_link_create".to_owned(),
+                io_error,
+            })?;
         self.data
             .links
             .insert(ExtensionLink::new(FdLink::new(link_fd)))
@@ -129,18 +122,11 @@ impl Extension {
         let (_, btf_id) = get_btf_info(target_fd, func_name)?;
         let prog_fd = self.data.fd_or_err()?;
         // the attach type must be set as 0, which is bpf_attach_type::BPF_CGROUP_INET_INGRESS
-        // TODO (AM)
-        let link_fd = bpf_link_create(
-            prog_fd.as_raw_fd(),
-            target_fd,
-            BPF_CGROUP_INET_INGRESS,
-            Some(btf_id),
-            0,
-        )
-        .map_err(|(_, io_error)| ProgramError::SyscallError {
-            call: "bpf_link_create".to_owned(),
-            io_error,
-        })?;
+        let link_fd = bpf_link_create(prog_fd, target_fd, BPF_CGROUP_INET_INGRESS, Some(btf_id), 0)
+            .map_err(|(_, io_error)| ProgramError::SyscallError {
+                call: "bpf_link_create".to_owned(),
+                io_error,
+            })?;
         self.data
             .links
             .insert(ExtensionLink::new(FdLink::new(link_fd)))
diff --git a/aya/src/programs/links.rs b/aya/src/programs/links.rs
index bd6a72ea..88149205 100644
--- a/aya/src/programs/links.rs
+++ b/aya/src/programs/links.rs
@@ -6,7 +6,7 @@ use std::{
     collections::{hash_map::Entry, HashMap},
     ffi::CString,
     io,
-    os::fd::{AsRawFd, OwnedFd, RawFd},
+    os::fd::{AsFd, AsRawFd, OwnedFd, RawFd},
     path::{Path, PathBuf},
 };
 
@@ -128,8 +128,7 @@ impl FdLink {
                     error: e.to_string(),
                 }
             })?;
-        // TODO (AM)
-        bpf_pin_object(self.fd.as_raw_fd(), &path_string).map_err(|(_, io_error)| {
+        bpf_pin_object(self.fd.as_fd(), &path_string).map_err(|(_, io_error)| {
             PinError::SyscallError {
                 name: "BPF_OBJ_PIN".to_string(),
                 io_error,
diff --git a/aya/src/programs/lirc_mode2.rs b/aya/src/programs/lirc_mode2.rs
index 60b3829b..960f3f93 100644
--- a/aya/src/programs/lirc_mode2.rs
+++ b/aya/src/programs/lirc_mode2.rs
@@ -64,13 +64,12 @@ impl LircMode2 {
         let prog_fd = self.data.fd_or_err()?;
         let lircdev_fd = lircdev.as_raw_fd();
 
-        // TODO (AM)
-        bpf_prog_attach(prog_fd.as_raw_fd(), lircdev_fd, BPF_LIRC_MODE2).map_err(
-            |(_, io_error)| ProgramError::SyscallError {
+        bpf_prog_attach(prog_fd, lircdev_fd, BPF_LIRC_MODE2).map_err(|(_, io_error)| {
+            ProgramError::SyscallError {
                 call: "bpf_prog_attach".to_owned(),
                 io_error,
-            },
-        )?;
+            }
+        })?;
 
         // TODO (AM)
         self.data
diff --git a/aya/src/programs/mod.rs b/aya/src/programs/mod.rs
index 6419ce76..eb6bfbc2 100644
--- a/aya/src/programs/mod.rs
+++ b/aya/src/programs/mod.rs
@@ -549,12 +549,9 @@ fn pin_program<T: Link, P: AsRef<Path>>(
             error: e.to_string(),
         }
     })?;
-    // TODO (AM)
-    bpf_pin_object(fd.as_raw_fd(), &path_string).map_err(|(_, io_error)| {
-        PinError::SyscallError {
-            name: "BPF_OBJ_PIN".to_string(),
-            io_error,
-        }
+    bpf_pin_object(fd, &path_string).map_err(|(_, io_error)| PinError::SyscallError {
+        name: "BPF_OBJ_PIN".to_string(),
+        io_error,
     })?;
     Ok(())
 }
diff --git a/aya/src/programs/perf_attach.rs b/aya/src/programs/perf_attach.rs
index 3fb1861e..0746b12a 100644
--- a/aya/src/programs/perf_attach.rs
+++ b/aya/src/programs/perf_attach.rs
@@ -1,6 +1,9 @@
 //! Perf attach links.
 use libc::close;
-use std::os::unix::io::RawFd;
+use std::os::{
+    fd::{AsRawFd, BorrowedFd},
+    unix::io::RawFd,
+};
 
 use crate::{
     generated::bpf_attach_type::BPF_PERF_EVENT,
@@ -72,7 +75,10 @@ impl Link for PerfLink {
     }
 }
 
-pub(crate) fn perf_attach(prog_fd: RawFd, fd: RawFd) -> Result<PerfLinkInner, ProgramError> {
+pub(crate) fn perf_attach(
+    prog_fd: BorrowedFd<'_>,
+    fd: RawFd,
+) -> Result<PerfLinkInner, ProgramError> {
     if FEATURES.bpf_perf_link() {
         let link_fd =
             bpf_link_create(prog_fd, fd, BPF_PERF_EVENT, None, 0).map_err(|(_, io_error)| {
@@ -88,7 +94,7 @@ pub(crate) fn perf_attach(prog_fd: RawFd, fd: RawFd) -> Result<PerfLinkInner, Pr
 }
 
 pub(crate) fn perf_attach_debugfs(
-    prog_fd: RawFd,
+    prog_fd: BorrowedFd<'_>,
     fd: RawFd,
     probe_kind: ProbeKind,
     event_alias: String,
@@ -97,17 +103,17 @@ pub(crate) fn perf_attach_debugfs(
 }
 
 fn perf_attach_either(
-    prog_fd: RawFd,
+    prog_fd: BorrowedFd<'_>,
     fd: RawFd,
     probe_kind: Option<ProbeKind>,
     event_alias: Option<String>,
 ) -> Result<PerfLinkInner, ProgramError> {
-    perf_event_ioctl(fd, PERF_EVENT_IOC_SET_BPF, prog_fd).map_err(|(_, io_error)| {
-        ProgramError::SyscallError {
+    perf_event_ioctl(fd, PERF_EVENT_IOC_SET_BPF, prog_fd.as_raw_fd()).map_err(
+        |(_, io_error)| ProgramError::SyscallError {
             call: "PERF_EVENT_IOC_SET_BPF".to_owned(),
             io_error,
-        }
-    })?;
+        },
+    )?;
     perf_event_ioctl(fd, PERF_EVENT_IOC_ENABLE, 0).map_err(|(_, io_error)| {
         ProgramError::SyscallError {
             call: "PERF_EVENT_IOC_ENABLE".to_owned(),
diff --git a/aya/src/programs/perf_event.rs b/aya/src/programs/perf_event.rs
index ab0bc800..177b3544 100644
--- a/aya/src/programs/perf_event.rs
+++ b/aya/src/programs/perf_event.rs
@@ -1,7 +1,5 @@
 //! Perf event programs.
 
-use std::os::fd::AsRawFd;
-
 pub use crate::generated::{
     perf_hw_cache_id, perf_hw_cache_op_id, perf_hw_cache_op_result_id, perf_hw_id, perf_sw_ids,
 };
@@ -171,8 +169,7 @@ impl PerfEvent {
             io_error,
         })? as i32;
 
-        // TODO (AM)
-        let link = perf_attach(self.data.fd_or_err()?.as_raw_fd(), fd)?;
+        let link = perf_attach(self.data.fd_or_err()?, fd)?;
         self.data.links.insert(PerfEventLink::new(link))
     }
 
diff --git a/aya/src/programs/probe.rs b/aya/src/programs/probe.rs
index f5ef835d..4ecf80a5 100644
--- a/aya/src/programs/probe.rs
+++ b/aya/src/programs/probe.rs
@@ -2,7 +2,6 @@ use libc::pid_t;
 use std::{
     fs::{self, OpenOptions},
     io::{self, Write},
-    os::fd::AsRawFd,
     path::Path,
     process,
     sync::atomic::{AtomicUsize, Ordering},
@@ -54,8 +53,7 @@ pub(crate) fn attach<T: Link + From<PerfLinkInner>>(
     if k_ver < (4, 17, 0) {
         let (fd, event_alias) = create_as_trace_point(kind, fn_name, offset, pid)?;
         let link = T::from(perf_attach_debugfs(
-            // TODO (AM)
-            program_data.fd_or_err()?.as_raw_fd(),
+            program_data.fd_or_err()?,
             fd,
             kind,
             event_alias,
@@ -64,8 +62,7 @@ pub(crate) fn attach<T: Link + From<PerfLinkInner>>(
     };
 
     let fd = create_as_probe(kind, fn_name, offset, pid)?;
-    // TODO (AM)
-    let link = T::from(perf_attach(program_data.fd_or_err()?.as_raw_fd(), fd)?);
+    let link = T::from(perf_attach(program_data.fd_or_err()?, fd)?);
     program_data.links.insert(link)
 }
 
diff --git a/aya/src/programs/sk_lookup.rs b/aya/src/programs/sk_lookup.rs
index 7031ccc6..809d9549 100644
--- a/aya/src/programs/sk_lookup.rs
+++ b/aya/src/programs/sk_lookup.rs
@@ -64,12 +64,12 @@ impl SkLookup {
         let prog_fd = self.data.fd_or_err()?;
         let netns_fd = netns.as_raw_fd();
 
-        // TODO (AM)
-        let link_fd = bpf_link_create(prog_fd.as_raw_fd(), netns_fd, BPF_SK_LOOKUP, None, 0)
-            .map_err(|(_, io_error)| ProgramError::SyscallError {
+        let link_fd = bpf_link_create(prog_fd, netns_fd, BPF_SK_LOOKUP, None, 0).map_err(
+            |(_, io_error)| ProgramError::SyscallError {
                 call: "bpf_link_create".to_owned(),
                 io_error,
-            })?;
+            },
+        )?;
         self.data
             .links
             .insert(SkLookupLink::new(FdLink::new(link_fd)))
diff --git a/aya/src/programs/sk_msg.rs b/aya/src/programs/sk_msg.rs
index 6bc57406..4c18c93e 100644
--- a/aya/src/programs/sk_msg.rs
+++ b/aya/src/programs/sk_msg.rs
@@ -82,13 +82,12 @@ impl SkMsg {
         let prog_fd = self.data.fd_or_err()?;
         let map_fd = map.as_raw_fd();
 
-        // TODO (AM)
-        bpf_prog_attach(prog_fd.as_raw_fd(), map_fd, BPF_SK_MSG_VERDICT).map_err(
-            |(_, io_error)| ProgramError::SyscallError {
+        bpf_prog_attach(prog_fd, map_fd, BPF_SK_MSG_VERDICT).map_err(|(_, io_error)| {
+            ProgramError::SyscallError {
                 call: "bpf_prog_attach".to_owned(),
                 io_error,
-            },
-        )?;
+            }
+        })?;
         self.data.links.insert(SkMsgLink::new(ProgAttachLink::new(
             // TODO (AM)
             prog_fd.as_raw_fd(),
diff --git a/aya/src/programs/sk_skb.rs b/aya/src/programs/sk_skb.rs
index 5e271b80..fd354fca 100644
--- a/aya/src/programs/sk_skb.rs
+++ b/aya/src/programs/sk_skb.rs
@@ -78,8 +78,7 @@ impl SkSkb {
             SkSkbKind::StreamParser => BPF_SK_SKB_STREAM_PARSER,
             SkSkbKind::StreamVerdict => BPF_SK_SKB_STREAM_VERDICT,
         };
-        // TODO (AM)
-        bpf_prog_attach(prog_fd.as_raw_fd(), map_fd, attach_type).map_err(|(_, io_error)| {
+        bpf_prog_attach(prog_fd, map_fd, attach_type).map_err(|(_, io_error)| {
             ProgramError::SyscallError {
                 call: "bpf_prog_attach".to_owned(),
                 io_error,
diff --git a/aya/src/programs/sock_ops.rs b/aya/src/programs/sock_ops.rs
index ca34daf0..db4f7f30 100644
--- a/aya/src/programs/sock_ops.rs
+++ b/aya/src/programs/sock_ops.rs
@@ -62,13 +62,12 @@ impl SockOps {
         let prog_fd = self.data.fd_or_err()?;
         let cgroup_fd = cgroup.as_raw_fd();
 
-        // TODO (AM)
-        bpf_prog_attach(prog_fd.as_raw_fd(), cgroup_fd, BPF_CGROUP_SOCK_OPS).map_err(
-            |(_, io_error)| ProgramError::SyscallError {
+        bpf_prog_attach(prog_fd, cgroup_fd, BPF_CGROUP_SOCK_OPS).map_err(|(_, io_error)| {
+            ProgramError::SyscallError {
                 call: "bpf_prog_attach".to_owned(),
                 io_error,
-            },
-        )?;
+            }
+        })?;
         // TODO (AM)
         self.data.links.insert(SockOpsLink::new(ProgAttachLink::new(
             prog_fd.as_raw_fd(),
diff --git a/aya/src/programs/trace_point.rs b/aya/src/programs/trace_point.rs
index ff112122..f43cd77e 100644
--- a/aya/src/programs/trace_point.rs
+++ b/aya/src/programs/trace_point.rs
@@ -1,5 +1,5 @@
 //! Tracepoint programs.
-use std::{fs, io, os::fd::AsRawFd, path::Path};
+use std::{fs, io, path::Path};
 use thiserror::Error;
 
 use crate::{
@@ -87,8 +87,7 @@ impl TracePoint {
             }
         })? as i32;
 
-        // TODO (AM)
-        let link = perf_attach(self.data.fd_or_err()?.as_raw_fd(), fd)?;
+        let link = perf_attach(self.data.fd_or_err()?, fd)?;
         self.data.links.insert(TracePointLink::new(link))
     }
 
diff --git a/aya/src/programs/utils.rs b/aya/src/programs/utils.rs
index 3d7befd7..f3ba36ef 100644
--- a/aya/src/programs/utils.rs
+++ b/aya/src/programs/utils.rs
@@ -1,5 +1,5 @@
 //! Common functions shared between multiple eBPF program types.
-use std::{ffi::CStr, io, os::fd::AsRawFd, path::Path};
+use std::{ffi::CStr, io, path::Path};
 
 use crate::{
     programs::{FdLink, Link, ProgramData, ProgramError},
@@ -13,14 +13,12 @@ pub(crate) fn attach_raw_tracepoint<T: Link + From<FdLink>>(
 ) -> Result<T::Id, ProgramError> {
     let prog_fd = program_data.fd_or_err()?;
 
-    // TODO (AM)
-    let pfd =
-        bpf_raw_tracepoint_open(tp_name, prog_fd.as_raw_fd()).map_err(|(_code, io_error)| {
-            ProgramError::SyscallError {
-                call: "bpf_raw_tracepoint_open".to_owned(),
-                io_error,
-            }
-        })?;
+    let pfd = bpf_raw_tracepoint_open(tp_name, prog_fd).map_err(|(_code, io_error)| {
+        ProgramError::SyscallError {
+            call: "bpf_raw_tracepoint_open".to_owned(),
+            io_error,
+        }
+    })?;
 
     program_data.links.insert(FdLink::new(pfd).into())
 }
diff --git a/aya/src/programs/xdp.rs b/aya/src/programs/xdp.rs
index e2177cdb..844f2208 100644
--- a/aya/src/programs/xdp.rs
+++ b/aya/src/programs/xdp.rs
@@ -6,7 +6,10 @@ use std::{
     ffi::CString,
     hash::Hash,
     io,
-    os::{fd::AsRawFd, unix::io::RawFd},
+    os::{
+        fd::{AsFd, AsRawFd},
+        unix::io::RawFd,
+    },
 };
 use thiserror::Error;
 
@@ -134,13 +137,12 @@ impl Xdp {
 
         let k_ver = kernel_version().unwrap();
         if k_ver >= (5, 9, 0) {
-            // TODO (AM)
-            let link_fd =
-                bpf_link_create(prog_fd.as_raw_fd(), if_index, BPF_XDP, None, flags.bits())
-                    .map_err(|(_, io_error)| ProgramError::SyscallError {
-                        call: "bpf_link_create".to_owned(),
-                        io_error,
-                    })?;
+            let link_fd = bpf_link_create(prog_fd, if_index, BPF_XDP, None, flags.bits()).map_err(
+                |(_, io_error)| ProgramError::SyscallError {
+                    call: "bpf_link_create".to_owned(),
+                    io_error,
+                },
+            )?;
             self.data
                 .links
                 .insert(XdpLink::new(XdpLinkInner::FdLink(FdLink::new(link_fd))))
@@ -298,13 +300,13 @@ impl TryFrom<FdLink> for XdpLink {
 
     fn try_from(fd_link: FdLink) -> Result<Self, Self::Error> {
         // unwrap of fd_link.fd will not panic since it's only None when being dropped.
-        let info =
-            // TODO (AM)
-            bpf_link_get_info_by_fd(fd_link.fd.as_raw_fd()).map_err(|io_error| LinkError::SyscallError {
+        let info = bpf_link_get_info_by_fd(fd_link.fd.as_fd()).map_err(|io_error| {
+            LinkError::SyscallError {
                 call: "BPF_OBJ_GET_INFO_BY_FD".to_string(),
                 code: 0,
                 io_error,
-            })?;
+            }
+        })?;
         if info.type_ == (bpf_link_type::BPF_LINK_TYPE_XDP as u32) {
             return Ok(XdpLink::new(XdpLinkInner::FdLink(fd_link)));
         }
diff --git a/aya/src/sys/bpf.rs b/aya/src/sys/bpf.rs
index 20ed10a4..48ba4578 100644
--- a/aya/src/sys/bpf.rs
+++ b/aya/src/sys/bpf.rs
@@ -4,7 +4,7 @@ use std::{
     io,
     mem::{self, MaybeUninit},
     os::{
-        fd::{AsRawFd, FromRawFd, OwnedFd},
+        fd::{AsFd, AsRawFd, BorrowedFd, FromRawFd, OwnedFd},
         unix::io::RawFd,
     },
     slice,
@@ -100,10 +100,10 @@ pub(crate) fn bpf_create_map(
     Ok(unsafe { OwnedFd::from_raw_fd(fd) })
 }
 
-pub(crate) fn bpf_pin_object(fd: RawFd, path: &CStr) -> SysResult {
+pub(crate) fn bpf_pin_object(fd: BorrowedFd<'_>, path: &CStr) -> SysResult {
     let mut attr = unsafe { mem::zeroed::<bpf_attr>() };
     let u = unsafe { &mut attr.__bindgen_anon_4 };
-    u.bpf_fd = fd as u32;
+    u.bpf_fd = fd.as_raw_fd() as u32;
     u.pathname = path.as_ptr() as u64;
     sys_bpf(bpf_cmd::BPF_OBJ_PIN, &attr)
 }
@@ -204,7 +204,7 @@ pub(crate) fn bpf_load_program(
 }
 
 fn lookup<K: Pod, V: Pod>(
-    fd: RawFd,
+    fd: BorrowedFd<'_>,
     key: Option<&K>,
     flags: u64,
     cmd: bpf_cmd,
@@ -213,7 +213,7 @@ fn lookup<K: Pod, V: Pod>(
     let mut value = MaybeUninit::zeroed();
 
     let u = unsafe { &mut attr.__bindgen_anon_2 };
-    u.map_fd = fd as u32;
+    u.map_fd = fd.as_raw_fd() as u32;
     if let Some(key) = key {
         u.key = key as *const _ as u64;
     }
@@ -228,7 +228,7 @@ fn lookup<K: Pod, V: Pod>(
 }
 
 pub(crate) fn bpf_map_lookup_elem<K: Pod, V: Pod>(
-    fd: RawFd,
+    fd: BorrowedFd<'_>,
     key: &K,
     flags: u64,
 ) -> Result<Option<V>> {
@@ -236,7 +236,7 @@ pub(crate) fn bpf_map_lookup_elem<K: Pod, V: Pod>(
 }
 
 pub(crate) fn bpf_map_lookup_and_delete_elem<K: Pod, V: Pod>(
-    fd: RawFd,
+    fd: BorrowedFd<'_>,
     key: Option<&K>,
     flags: u64,
 ) -> Result<Option<V>> {
@@ -244,7 +244,7 @@ pub(crate) fn bpf_map_lookup_and_delete_elem<K: Pod, V: Pod>(
 }
 
 pub(crate) fn bpf_map_lookup_elem_per_cpu<K: Pod, V: Pod>(
-    fd: RawFd,
+    fd: BorrowedFd<'_>,
     key: &K,
     flags: u64,
 ) -> Result<Option<PerCpuValues<V>>> {
@@ -257,7 +257,7 @@ pub(crate) fn bpf_map_lookup_elem_per_cpu<K: Pod, V: Pod>(
 }
 
 pub(crate) fn bpf_map_lookup_elem_ptr<K: Pod, V>(
-    fd: RawFd,
+    fd: BorrowedFd<'_>,
     key: Option<&K>,
     value: *mut V,
     flags: u64,
@@ -265,7 +265,7 @@ pub(crate) fn bpf_map_lookup_elem_ptr<K: Pod, V>(
     let mut attr = unsafe { mem::zeroed::<bpf_attr>() };
 
     let u = unsafe { &mut attr.__bindgen_anon_2 };
-    u.map_fd = fd as u32;
+    u.map_fd = fd.as_raw_fd() as u32;
     if let Some(key) = key {
         u.key = key as *const _ as u64;
     }
@@ -280,7 +280,7 @@ pub(crate) fn bpf_map_lookup_elem_ptr<K: Pod, V>(
 }
 
 pub(crate) fn bpf_map_update_elem<K: Pod, V: Pod>(
-    fd: RawFd,
+    fd: BorrowedFd<'_>,
     key: Option<&K>,
     value: &V,
     flags: u64,
@@ -288,7 +288,7 @@ pub(crate) fn bpf_map_update_elem<K: Pod, V: Pod>(
     let mut attr = unsafe { mem::zeroed::<bpf_attr>() };
 
     let u = unsafe { &mut attr.__bindgen_anon_2 };
-    u.map_fd = fd as u32;
+    u.map_fd = fd.as_raw_fd() as u32;
     if let Some(key) = key {
         u.key = key as *const _ as u64;
     }
@@ -298,11 +298,11 @@ pub(crate) fn bpf_map_update_elem<K: Pod, V: Pod>(
     sys_bpf(bpf_cmd::BPF_MAP_UPDATE_ELEM, &attr)
 }
 
-pub(crate) fn bpf_map_push_elem<V: Pod>(fd: RawFd, value: &V, flags: u64) -> SysResult {
+pub(crate) fn bpf_map_push_elem<V: Pod>(fd: BorrowedFd<'_>, value: &V, flags: u64) -> SysResult {
     let mut attr = unsafe { mem::zeroed::<bpf_attr>() };
 
     let u = unsafe { &mut attr.__bindgen_anon_2 };
-    u.map_fd = fd as u32;
+    u.map_fd = fd.as_raw_fd() as u32;
     u.__bindgen_anon_1.value = value as *const _ as u64;
     u.flags = flags;
 
@@ -310,7 +310,7 @@ pub(crate) fn bpf_map_push_elem<V: Pod>(fd: RawFd, value: &V, flags: u64) -> Sys
 }
 
 pub(crate) fn bpf_map_update_elem_ptr<K, V>(
-    fd: RawFd,
+    fd: BorrowedFd<'_>,
     key: *const K,
     value: *mut V,
     flags: u64,
@@ -318,7 +318,7 @@ pub(crate) fn bpf_map_update_elem_ptr<K, V>(
     let mut attr = unsafe { mem::zeroed::<bpf_attr>() };
 
     let u = unsafe { &mut attr.__bindgen_anon_2 };
-    u.map_fd = fd as u32;
+    u.map_fd = fd.as_raw_fd() as u32;
     u.key = key as u64;
     u.__bindgen_anon_1.value = value as u64;
     u.flags = flags;
@@ -327,7 +327,7 @@ pub(crate) fn bpf_map_update_elem_ptr<K, V>(
 }
 
 pub(crate) fn bpf_map_update_elem_per_cpu<K: Pod, V: Pod>(
-    fd: RawFd,
+    fd: BorrowedFd<'_>,
     key: &K,
     values: &PerCpuValues<V>,
     flags: u64,
@@ -336,22 +336,25 @@ pub(crate) fn bpf_map_update_elem_per_cpu<K: Pod, V: Pod>(
     bpf_map_update_elem_ptr(fd, key, mem.as_mut_ptr(), flags)
 }
 
-pub(crate) fn bpf_map_delete_elem<K: Pod>(fd: RawFd, key: &K) -> SysResult {
+pub(crate) fn bpf_map_delete_elem<K: Pod>(fd: BorrowedFd<'_>, key: &K) -> SysResult {
     let mut attr = unsafe { mem::zeroed::<bpf_attr>() };
 
     let u = unsafe { &mut attr.__bindgen_anon_2 };
-    u.map_fd = fd as u32;
+    u.map_fd = fd.as_raw_fd() as u32;
     u.key = key as *const _ as u64;
 
     sys_bpf(bpf_cmd::BPF_MAP_DELETE_ELEM, &attr)
 }
 
-pub(crate) fn bpf_map_get_next_key<K: Pod>(fd: RawFd, key: Option<&K>) -> Result<Option<K>> {
+pub(crate) fn bpf_map_get_next_key<K: Pod>(
+    fd: BorrowedFd<'_>,
+    key: Option<&K>,
+) -> Result<Option<K>> {
     let mut attr = unsafe { mem::zeroed::<bpf_attr>() };
     let mut next_key = MaybeUninit::uninit();
 
     let u = unsafe { &mut attr.__bindgen_anon_2 };
-    u.map_fd = fd as u32;
+    u.map_fd = fd.as_raw_fd() as u32;
     if let Some(key) = key {
         u.key = key as *const _ as u64;
     }
@@ -365,16 +368,16 @@ pub(crate) fn bpf_map_get_next_key<K: Pod>(fd: RawFd, key: Option<&K>) -> Result
 }
 
 // since kernel 5.2
-pub(crate) fn bpf_map_freeze(fd: RawFd) -> SysResult {
+pub(crate) fn bpf_map_freeze(fd: BorrowedFd<'_>) -> SysResult {
     let mut attr = unsafe { mem::zeroed::<bpf_attr>() };
     let u = unsafe { &mut attr.__bindgen_anon_2 };
-    u.map_fd = fd as u32;
+    u.map_fd = fd.as_raw_fd() as u32;
     sys_bpf(bpf_cmd::BPF_MAP_FREEZE, &attr)
 }
 
 // since kernel 5.7
 pub(crate) fn bpf_link_create(
-    prog_fd: RawFd,
+    prog_fd: BorrowedFd<'_>,
     target_fd: RawFd,
     attach_type: bpf_attach_type,
     btf_id: Option<u32>,
@@ -382,7 +385,7 @@ pub(crate) fn bpf_link_create(
 ) -> Result<OwnedFd> {
     let mut attr = unsafe { mem::zeroed::<bpf_attr>() };
 
-    attr.link_create.__bindgen_anon_1.prog_fd = prog_fd as u32;
+    attr.link_create.__bindgen_anon_1.prog_fd = prog_fd.as_raw_fd() as u32;
     attr.link_create.__bindgen_anon_2.target_fd = target_fd as u32;
     attr.link_create.attach_type = attach_type as u32;
     attr.link_create.flags = flags;
@@ -417,13 +420,13 @@ pub(crate) fn bpf_link_update(
 }
 
 pub(crate) fn bpf_prog_attach(
-    prog_fd: RawFd,
+    prog_fd: BorrowedFd<'_>,
     target_fd: RawFd,
     attach_type: bpf_attach_type,
 ) -> SysResult {
     let mut attr = unsafe { mem::zeroed::<bpf_attr>() };
 
-    attr.__bindgen_anon_5.attach_bpf_fd = prog_fd as u32;
+    attr.__bindgen_anon_5.attach_bpf_fd = prog_fd.as_raw_fd() as u32;
     attr.__bindgen_anon_5.target_fd = target_fd as u32;
     attr.__bindgen_anon_5.attach_type = attach_type as u32;
 
@@ -497,12 +500,12 @@ pub(crate) fn bpf_prog_get_info_by_fd(prog_fd: RawFd) -> io::Result<bpf_prog_inf
     }
 }
 
-pub(crate) fn bpf_map_get_info_by_fd(prog_fd: RawFd) -> io::Result<bpf_map_info> {
+pub(crate) fn bpf_map_get_info_by_fd(prog_fd: BorrowedFd<'_>) -> io::Result<bpf_map_info> {
     let mut attr = unsafe { mem::zeroed::<bpf_attr>() };
     // info gets entirely populated by the kernel
     let info = MaybeUninit::zeroed();
 
-    attr.info.bpf_fd = prog_fd as u32;
+    attr.info.bpf_fd = prog_fd.as_raw_fd() as u32;
     attr.info.info = info.as_ptr() as *const _ as u64;
     attr.info.info_len = mem::size_of::<bpf_map_info>() as u32;
 
@@ -512,12 +515,12 @@ pub(crate) fn bpf_map_get_info_by_fd(prog_fd: RawFd) -> io::Result<bpf_map_info>
     }
 }
 
-pub(crate) fn bpf_link_get_info_by_fd(link_fd: RawFd) -> io::Result<bpf_link_info> {
+pub(crate) fn bpf_link_get_info_by_fd(link_fd: BorrowedFd<'_>) -> io::Result<bpf_link_info> {
     let mut attr = unsafe { mem::zeroed::<bpf_attr>() };
     // info gets entirely populated by the kernel
     let info = unsafe { MaybeUninit::zeroed().assume_init() };
 
-    attr.info.bpf_fd = link_fd as u32;
+    attr.info.bpf_fd = link_fd.as_raw_fd() as u32;
     attr.info.info = &info as *const _ as u64;
     attr.info.info_len = mem::size_of::<bpf_link_info>() as u32;
 
@@ -543,14 +546,17 @@ pub(crate) fn btf_obj_get_info_by_fd(prog_fd: RawFd, buf: &mut [u8]) -> io::Resu
     }
 }
 
-pub(crate) fn bpf_raw_tracepoint_open(name: Option<&CStr>, prog_fd: RawFd) -> Result<OwnedFd> {
+pub(crate) fn bpf_raw_tracepoint_open(
+    name: Option<&CStr>,
+    prog_fd: BorrowedFd<'_>,
+) -> Result<OwnedFd> {
     let mut attr = unsafe { mem::zeroed::<bpf_attr>() };
 
     attr.raw_tracepoint.name = match name {
         Some(n) => n.as_ptr() as u64,
         None => 0,
     };
-    attr.raw_tracepoint.prog_fd = prog_fd as u32;
+    attr.raw_tracepoint.prog_fd = prog_fd.as_raw_fd() as u32;
 
     let fd = sys_bpf(bpf_cmd::BPF_RAW_TRACEPOINT_OPEN, &attr)? as RawFd;
     // Safety: BPF_RAW_TRACEPOINT_OPEN returns a new fd
@@ -665,14 +671,14 @@ pub(crate) fn is_perf_link_supported() -> bool {
     u.prog_type = bpf_prog_type::BPF_PROG_TYPE_TRACEPOINT as u32;
 
     if let Ok(fd) = sys_bpf(bpf_cmd::BPF_PROG_LOAD, &attr) {
+        // SAFETY: BPF_PROG_LOAD creates a new fd
+        let fd = unsafe { OwnedFd::from_raw_fd(fd as RawFd) };
         if let Err((_, e)) =
             // Uses an invalid target FD so we get EBADF if supported.
-            bpf_link_create(fd as i32, -1, bpf_attach_type::BPF_PERF_EVENT, None, 0)
+            bpf_link_create(fd.as_fd(), -1, bpf_attach_type::BPF_PERF_EVENT, None, 0)
         {
             // Returns EINVAL if unsupported. EBADF if supported.
-            let res = e.raw_os_error() == Some(libc::EBADF);
-            unsafe { libc::close(fd as i32) };
-            return res;
+            return e.raw_os_error() == Some(libc::EBADF);
         }
     }
     false
diff --git a/test/integration-ebpf/src/bpf_probe_read.rs b/test/integration-ebpf/src/bpf_probe_read.rs
index 013c8b96..fcabede0 100644
--- a/test/integration-ebpf/src/bpf_probe_read.rs
+++ b/test/integration-ebpf/src/bpf_probe_read.rs
@@ -14,8 +14,8 @@ macro_rules! read_str_bytes {
     ($fun:ident, $ptr:expr, $len:expr $(,)?) => {
         let r = unsafe {
             let Some(ptr) = RESULT.get_ptr_mut(0) else {
-                return;
-            };
+                                return;
+                            };
             &mut *ptr
         };