Stop using create_bpf_entity_checked() everywhere else

Get rid of all remaining call sites of create_bpf_entity_checked() in
the crate. Favor more explicit error checking via validate_bpf_ret() (as
introduced earlier) and make sure to add proper context.

Signed-off-by: Daniel Müller <[email protected]>

Author: d-e-s-o

libbpf-rs/src/link.rs

@@ -6,7 +6,9 @@ use std::path::PathBuf;
 use std::ptr::NonNull;
 
 use crate::util;
+use crate::util::validate_bpf_ret;
 use crate::AsRawLibbpf;
+use crate::ErrorExt as _;
 use crate::Program;
 use crate::Result;
 
@@ -33,8 +35,10 @@ impl Link {
     pub fn open<P: AsRef<Path>>(path: P) -> Result<Self> {
         let path_c = util::path_to_cstring(path)?;
         let path_ptr = path_c.as_ptr();
-        util::create_bpf_entity_checked(|| unsafe { libbpf_sys::bpf_link__open(path_ptr) })
-            .map(|ptr| unsafe { Self::new(ptr) })
+        let ptr = unsafe { libbpf_sys::bpf_link__open(path_ptr) };
+        let ptr = validate_bpf_ret(ptr).context("failed to open link")?;
+        let slf = unsafe { Self::new(ptr) };
+        Ok(slf)
     }
 
     /// Takes ownership from pointer.

libbpf-rs/src/linker.rs

@@ -2,8 +2,8 @@ use std::path::Path;
 use std::ptr::null_mut;
 use std::ptr::NonNull;
 
-use crate::util;
 use crate::util::path_to_cstring;
+use crate::util::validate_bpf_ret;
 use crate::AsRawLibbpf;
 use crate::Error;
 use crate::ErrorExt as _;
@@ -27,12 +27,12 @@ impl Linker {
         P: AsRef<Path>,
     {
         let output = path_to_cstring(output)?;
-        util::create_bpf_entity_checked(|| {
-            let opts = null_mut();
-            // SAFETY: `output` is a valid pointer and `opts` is accepted as NULL.
-            unsafe { libbpf_sys::bpf_linker__new(output.as_ptr(), opts) }
-        })
-        .map(|linker| Self { linker })
+        let opts = null_mut();
+        // SAFETY: `output` is a valid pointer and `opts` is accepted as NULL.
+        let ptr = unsafe { libbpf_sys::bpf_linker__new(output.as_ptr(), opts) };
+        let ptr = validate_bpf_ret(ptr).context("failed to attach iterator")?;
+        let slf = Self { linker: ptr };
+        Ok(slf)
     }
 
     /// Add a file to the set of files to link.

libbpf-rs/src/map.rs

@@ -29,6 +29,7 @@ use libbpf_sys::bpf_obj_get_info_by_fd;
 
 use crate::util;
 use crate::util::parse_ret_i32;
+use crate::util::validate_bpf_ret;
 use crate::AsRawLibbpf;
 use crate::Error;
 use crate::ErrorExt as _;
@@ -791,13 +792,11 @@ impl<'obj> MapMut<'obj> {
             )));
         }
 
-        util::create_bpf_entity_checked(|| unsafe {
-            libbpf_sys::bpf_map__attach_struct_ops(self.ptr.as_ptr())
-        })
-        .map(|ptr| unsafe {
-            // SAFETY: the pointer came from libbpf and has been checked for errors
-            Link::new(ptr)
-        })
+        let ptr = unsafe { libbpf_sys::bpf_map__attach_struct_ops(self.ptr.as_ptr()) };
+        let ptr = validate_bpf_ret(ptr).context("failed to attach struct_ops")?;
+        // SAFETY: the pointer came from libbpf and has been checked for errors.
+        let link = unsafe { Link::new(ptr) };
+        Ok(link)
     }
 }
 

libbpf-rs/src/object.rs

@@ -12,7 +12,9 @@ use std::ptr::NonNull;
 use crate::map::map_fd;
 use crate::set_print;
 use crate::util;
+use crate::util::validate_bpf_ret;
 use crate::Btf;
+use crate::ErrorExt as _;
 use crate::Map;
 use crate::MapMut;
 use crate::OpenMap;
@@ -171,27 +173,30 @@ impl ObjectBuilder {
 
     /// Open an object using the provided path on the file system.
     pub fn open_file<P: AsRef<Path>>(&mut self, path: P) -> Result<OpenObject> {
+        let path = path.as_ref();
         let path_c = util::path_to_cstring(path)?;
         let path_ptr = path_c.as_ptr();
         let opts_ptr = self.as_libbpf_object().as_ptr();
 
-        let ptr = util::create_bpf_entity_checked(|| unsafe {
-            libbpf_sys::bpf_object__open_file(path_ptr, opts_ptr)
-        })?;
+        let ptr = unsafe { libbpf_sys::bpf_object__open_file(path_ptr, opts_ptr) };
+        let ptr = validate_bpf_ret(ptr)
+            .with_context(|| format!("failed to open object from `{}`", path.display()))?;
+
         let obj = unsafe { OpenObject::from_ptr(ptr) };
         Ok(obj)
     }
 
     /// Open an object from memory.
     pub fn open_memory(&mut self, mem: &[u8]) -> Result<OpenObject> {
         let opts_ptr = self.as_libbpf_object().as_ptr();
-        let ptr = util::create_bpf_entity_checked(|| unsafe {
+        let ptr = unsafe {
             libbpf_sys::bpf_object__open_mem(
                 mem.as_ptr() as *const c_void,
                 mem.len() as libbpf_sys::size_t,
                 opts_ptr,
             )
-        })?;
+        };
+        let ptr = validate_bpf_ret(ptr).context("failed to open object from memory")?;
         let obj = unsafe { OpenObject::from_ptr(ptr) };
         Ok(obj)
     }

libbpf-rs/src/perf_buffer.rs

@@ -10,8 +10,10 @@ use std::slice;
 use std::time::Duration;
 
 use crate::util;
+use crate::util::validate_bpf_ret;
 use crate::AsRawLibbpf;
 use crate::Error;
+use crate::ErrorExt as _;
 use crate::Map;
 use crate::MapCore as _;
 use crate::MapType;
@@ -126,7 +128,7 @@ impl<'a, 'b> PerfBufferBuilder<'a, 'b> {
             lost_cb: self.lost_cb,
         }));
 
-        util::create_bpf_entity_checked(|| unsafe {
+        let ptr = unsafe {
             libbpf_sys::perf_buffer__new(
                 self.map.as_fd().as_raw_fd(),
                 self.pages as libbpf_sys::size_t,
@@ -135,11 +137,13 @@ impl<'a, 'b> PerfBufferBuilder<'a, 'b> {
                 callback_struct_ptr as *mut _,
                 ptr::null(),
             )
-        })
-        .map(|ptr| PerfBuffer {
+        };
+        let ptr = validate_bpf_ret(ptr).context("failed to create perf buffer")?;
+        let pb = PerfBuffer {
             ptr,
             _cb_struct: unsafe { Box::from_raw(callback_struct_ptr) },
-        })
+        };
+        Ok(pb)
     }
 
     unsafe extern "C" fn call_sample_cb(ctx: *mut c_void, cpu: i32, data: *mut c_void, size: u32) {

libbpf-rs/src/ringbuf.rs

@@ -12,8 +12,10 @@ use std::slice;
 use std::time::Duration;
 
 use crate::util;
+use crate::util::validate_bpf_ret;
 use crate::AsRawLibbpf;
 use crate::Error;
+use crate::ErrorExt as _;
 use crate::MapCore;
 use crate::MapType;
 use crate::Result;
@@ -83,22 +85,24 @@ impl<'slf, 'cb: 'slf> RingBufferBuilder<'slf, 'cb> {
     /// Build a new [`RingBuffer`]. Must have added at least one ringbuf.
     pub fn build(self) -> Result<RingBuffer<'cb>> {
         let mut cbs = vec![];
-        let mut ptr: Option<NonNull<libbpf_sys::ring_buffer>> = None;
+        let mut rb_ptr: Option<NonNull<libbpf_sys::ring_buffer>> = None;
         let c_sample_cb: libbpf_sys::ring_buffer_sample_fn = Some(Self::call_sample_cb);
 
         for (fd, callback) in self.fd_callbacks {
             let sample_cb_ptr = Box::into_raw(Box::new(callback));
-            match ptr {
+            match rb_ptr {
                 None => {
                     // Allocate a new ringbuf manager and add a ringbuf to it
-                    ptr = Some(util::create_bpf_entity_checked(|| unsafe {
+                    let ptr = unsafe {
                         libbpf_sys::ring_buffer__new(
                             fd.as_raw_fd(),
                             c_sample_cb,
                             sample_cb_ptr as *mut _,
                             null_mut(),
                         )
-                    })?);
+                    };
+                    let ptr = validate_bpf_ret(ptr).context("failed to create new ring buffer")?;
+                    rb_ptr = Some(ptr)
                 }
                 Some(ptr) => {
                     // Add a ringbuf to the existing ringbuf manager
@@ -121,7 +125,7 @@ impl<'slf, 'cb: 'slf> RingBufferBuilder<'slf, 'cb> {
             unsafe { cbs.push(Box::from_raw(sample_cb_ptr)) };
         }
 
-        match ptr {
+        match rb_ptr {
             Some(ptr) => Ok(RingBuffer { ptr, _cbs: cbs }),
             None => Err(Error::with_invalid_data(
                 "You must add at least one ring buffer map and callback before building",