How do I free memory?

[rlidwka]

Lets say I have a function:

#[ffi_export]
pub fn hello_world() -> str_boxed {
    String::from("hello world").into()
}

// converts to:
// slice_boxed_uint8_t hello_world();

And I'm calling it from C code.

It's caller's responsibility to free returned string now, but how to do so?

Can C code free(result.ptr) hoping that allocator is the same across FFI boundary?

Or do I have to provide explicit free_* in Rust FFI for every owned type I return?

[danielhenrymantilla]

1. Can C code free(result.ptr) hoping that allocator is the same across FFI boundary?

   The short answer is no: the allocator machinery/implementation that Rust uses for things such as Boxes, Vecs, etc. (i.e., the registered impl GlobalAlloc), can be fully independent of libc/posix malloc/free, and thus free() may not be the appropriate memory-releasing operation (and UB could ensue!).

   The longer, and more hopeful answer, is that, when compiling a Rust binary, be it a [bin]ary standalone executable, or a "cdylib", "staticlib" "C" library, you can override the default behavior of Rust allocations via the #[global_allocator] directive. By doing so, you can then specify that all allocations go through libc::free()-compatible APIs, such as posix_memalign().

   For instance, you should be able to just copy-paste the following naïve-ish snippet somewhere in your crate's code:

   struct PosixMemAlign;
   #[global_allocator]
   static __: PosixMemAlign = {
       extern crate alloc;
       use {
           alloc::alloc::{GlobalAlloc, Layout},
           core::{mem, ptr},
       };
       unsafe impl GlobalAlloc for PosixMemAlign {
           #[inline]
           unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
               use ::core::ffi::{c_void, c_int};
               use usize as size_t;
               extern "C" {
                   fn posix_memalign(memptr: *mut *mut c_void, align: size_t, size: size_t) -> c_int;
               }
               let mut out = mem::MaybeUninit::uninit();
               // posix_memalign requires that the alignment be a multiple of `sizeof(void*)`.
               // Since these are all powers of 2, we can just use max.
               let align = layout.align().max(mem::size_of::<usize>());
               let ret = posix_memalign(out.as_mut_ptr(), align, layout.size());
               if ret != 0 { ptr::null_mut() } else { out.assume_init().cast() }
           }
   
           #[inline]
           unsafe fn dealloc(&self, ptr: *mut u8, _: Layout) {
               libc::free(ptr.cast());
           }
       }
       PosixMemAlign
   };

   • Godbolt

---

2. Or do I have to provide explicit free_* in Rust FFI for every owned type I return?

   That would indeed be the more generally cautious approach to take when doing these FFI shenanigans: for every owned type returned / which the caller/user of your C API may end up with, strive to provide a fn that_type_free(…) function. That way, you don't have to mess with a unified/compatible allocator implementation, with Rust being allowed to use potentially faster allocator implementations.

[rlidwka]

Thanks for the reply.

Or do I have to provide explicit free_* in Rust FFI for every owned type I return?

Is there a way to automatically generate FFI wrappers for Drop (and maybe other common traits, e.g. Clone, Default, PartialEq)?