Rework error evaluation

This change starts a rework of the way we check for potential errors
reported from libbpf functions. Instead of relying on the weird
create_bpf_entity_checked() helper which works on a closure, introduce
validate_bpf_ret(). Having an explicit call means that we can
contextualize errors. So on top of getting rid of various hard-to-parse
(for humans) closures and potentially nested error mapping, we will
report better error chains.
As a first step, get rid of usage of create_bpf_entity_checked_opt()
from btf/mod.rs.

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

Author: d-e-s-o

libbpf-rs/src/btf/mod.rs

@@ -38,10 +38,11 @@ use std::ptr;
 use std::ptr::NonNull;
 
 use crate::util::create_bpf_entity_checked;
-use crate::util::create_bpf_entity_checked_opt;
 use crate::util::parse_ret_i32;
+use crate::util::validate_bpf_ret;
 use crate::AsRawLibbpf;
 use crate::Error;
+use crate::ErrorExt as _;
 use crate::Result;
 
 use self::types::Composite;
@@ -230,17 +231,22 @@ impl<'btf> Btf<'btf> {
     }
 
     fn from_bpf_object_raw(obj: *const libbpf_sys::bpf_object) -> Result<Option<Self>> {
-        create_bpf_entity_checked_opt(|| unsafe {
+        let ptr = unsafe {
             // SAFETY: the obj pointer is valid since it's behind a reference.
             libbpf_sys::bpf_object__btf(obj)
-        })
-        .map(|opt| {
-            opt.map(|ptr| Self {
-                ptr,
-                drop_policy: DropPolicy::Nothing,
-                _marker: PhantomData,
-            })
-        })
+        };
+        // Contrary to general `libbpf` contract, `bpf_object__btf` may
+        // return `NULL` without setting `errno`.
+        if ptr.is_null() {
+            return Ok(None)
+        }
+        let ptr = validate_bpf_ret(ptr).context("failed to create BTF from BPF object")?;
+        let slf = Self {
+            ptr,
+            drop_policy: DropPolicy::Nothing,
+            _marker: PhantomData,
+        };
+        Ok(Some(slf))
     }
 
     /// From raw bytes coming from an object file.

libbpf-rs/src/util.rs

@@ -76,6 +76,25 @@ pub fn parse_ret_i32(ret: i32) -> Result<i32> {
     parse_ret(ret).map(|()| ret)
 }
 
+
+/// Check the returned pointer of a `libbpf` call, extracting any
+/// reported errors and converting them.
+pub fn validate_bpf_ret<T>(ptr: *mut T) -> Result<NonNull<T>> {
+    // SAFETY: `libbpf_get_error` is always safe to call.
+    match unsafe { libbpf_sys::libbpf_get_error(ptr as *const _) } {
+        0 => {
+            debug_assert!(!ptr.is_null());
+            // SAFETY: libbpf guarantees that if NULL is returned an
+            //         error it set, so we will always end up with a
+            //         valid pointer when `libbpf_get_error` returned 0.
+            let ptr = unsafe { NonNull::new_unchecked(ptr) };
+            Ok(ptr)
+        }
+        err => Err(Error::from_raw_os_error(-err as i32)),
+    }
+}
+
+
 pub fn create_bpf_entity_checked<B: 'static, F: FnOnce() -> *mut B>(f: F) -> Result<NonNull<B>> {
     create_bpf_entity_checked_opt(f).and_then(|ptr| {
         ptr.ok_or_else(|| {
@@ -95,7 +114,7 @@ pub fn create_bpf_entity_checked<B: 'static, F: FnOnce() -> *mut B>(f: F) -> Res
     })
 }
 
-pub fn create_bpf_entity_checked_opt<B: 'static, F: FnOnce() -> *mut B>(
+fn create_bpf_entity_checked_opt<B: 'static, F: FnOnce() -> *mut B>(
     f: F,
 ) -> Result<Option<NonNull<B>>> {
     let ptr = f();