refactor: simplify

Author: morrisonlevi

Cargo.lock

@@ -8,8 +8,6 @@ version.workspace = true
 rust-version.workspace = true
 license.workspace = true
 
-[features]
-
 [dependencies]
 allocator-api2 = { version = "0.2", default-features = false }
 

datadog-alloc/Cargo.toml

@@ -215,10 +215,9 @@ mod tests {
 
     #[test]
     fn test_zero_sized() {
-        let alloc = VirtualAllocator;
         assert_eq!(0, core::mem::size_of::<VirtualAllocator>());
         let zero_sized_layout = Layout::new::<VirtualAllocator>();
-        _ = alloc.allocate(zero_sized_layout).unwrap_err();
+        _ = VirtualAllocator.allocate(zero_sized_layout).unwrap_err();
     }
 
     #[test]
@@ -228,8 +227,7 @@ mod tests {
         let too_large_layout = Layout::from_size_align(1, too_large)
             .unwrap()
             .pad_to_align();
-        let alloc = VirtualAllocator;
-        _ = alloc.allocate(too_large_layout).unwrap_err();
+        _ = VirtualAllocator.allocate(too_large_layout).unwrap_err();
     }
 
     #[test]
@@ -266,9 +264,8 @@ mod tests {
     #[track_caller]
     fn realistic_size(size: usize) {
         let page_size = os::page_size().unwrap();
-        let alloc = VirtualAllocator;
         let layout = Layout::from_size_align(size, page_size).unwrap();
-        let wide_ptr = alloc.allocate(layout).unwrap();
+        let wide_ptr = VirtualAllocator.allocate(layout).unwrap();
         let actual_size = wide_ptr.len();
 
         // Should be a multiple of page size.
@@ -277,7 +274,7 @@ mod tests {
         // Shouldn't ever be smaller than what was asked for.
         assert!(actual_size >= size);
 
-        unsafe { alloc.deallocate(wide_ptr.cast(), layout) };
+        unsafe { VirtualAllocator.deallocate(wide_ptr.cast(), layout) };
     }
 
     #[test]

datadog-alloc/src/virtual_alloc.rs

@@ -187,7 +187,10 @@ where
             buffer,
             endpoints_stats: Default::default(),
         };
-        unsafe { out_profile.write(Handle::from(encoded)) };
+        let h = Handle::try_new(encoded).ok_or(ProfileError::other(
+            "out of memory: failed to allocate handle for the EncodedProfile",
+        ))?;
+        unsafe { out_profile.write(h) };
         Ok(())
     }())
 }

datadog-profiling-ffi/src/profiles/pprof_builder/mod.rs

@@ -26,7 +26,6 @@ crossbeam-queue = "0.3.11"
 ddcommon = { path = "../ddcommon" }
 hyper = { version = "1.6", features = ["http1", "client"] }
 serde = "1.0"
-thiserror = "1"
 
 [dev-dependencies]
 bolero = "0.13"

ddcommon-ffi/Cargo.toml

@@ -1,6 +1,9 @@
 // Copyright 2024-Present Datadog, Inc. https://www.datadoghq.com/
 // SPDX-License-Identifier: Apache-2.0
 
+use ddcommon::error::FfiSafeErrorMessage;
+use std::ffi::CStr;
+use std::fmt::{Display, Formatter};
 use std::ptr::null_mut;
 
 /// Represents an object that should only be referred to by its handle.
@@ -11,6 +14,13 @@ pub struct Handle<T> {
     inner: *mut T,
 }
 
+#[repr(C)]
+#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
+pub enum HandleError {
+    OuterNullPtr,
+    InnerNullPtr,
+}
+
 impl<T> Handle<T> {
     pub fn empty() -> Self {
         Self { inner: null_mut() }
@@ -23,22 +33,29 @@ impl<T> Handle<T> {
         let inner = allocator_api2::boxed::Box::into_raw(uninit).cast();
         Some(Self { inner })
     }
+}
 
-    pub fn as_inner(&self) -> Result<&T, HandleError> {
-        // SAFETY: the Handle owns the data.
-        unsafe { self.inner.as_ref() }.ok_or(HandleError::InnerNullPtr)
+/// # Safety
+/// All cases use c-str literals to satisfy conditions.
+unsafe impl FfiSafeErrorMessage for HandleError {
+    fn as_ffi_str(&self) -> &'static CStr {
+        match self {
+            HandleError::OuterNullPtr => c"handle is null",
+            HandleError::InnerNullPtr => {
+                c"handle's interior pointer is null, indicates use-after-free"
+            }
+        }
     }
 }
 
-#[repr(C)]
-#[derive(Debug, thiserror::Error)]
-pub enum HandleError {
-    #[error("handle is null")]
-    OuterNullPtr,
-    #[error("handle's interior pointer is null, indicates use-after-free")]
-    InnerNullPtr,
+impl Display for HandleError {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        self.as_rust_str().fmt(f)
+    }
 }
 
+impl core::error::Error for HandleError {}
+
 pub trait ToInner<T> {
     /// # Safety
     /// The Handle must hold a valid `inner` which has been allocated and not freed.