Compiler Explorer

Source code

#![feature(read_buf, maybe_uninit_slice)]
use std::mem::MaybeUninit;
use std::num::NonZeroU32;
use std::io::ReadBuf;

// Some underlying OS implementation that will only write to [ptr, ptr+len)
extern "Rust" {
    fn getrandom_inner(ptr: *mut u8, len: usize) -> Result<(), NonZeroU32>;
}

// Existing interface
fn getrandom(b: &mut [u8]) -> Result<(), NonZeroU32> {
    if b.len() == 0 {
        return Ok(());
    }
    unsafe { getrandom_inner(b.as_mut_ptr(), b.len()) }
}

// Proposed new interface
fn getrandom_read_buf(rb: &mut ReadBuf) -> Result<(), NonZeroU32> {
    let b = unsafe { rb.unfilled_mut() };
    if b.len() == 0 {
        return Ok(());
    }
    let n = b.len();
    unsafe { getrandom_inner(b.as_mut_ptr() as *mut u8, n) }?;
    unsafe { rb.assume_init(n) };
    rb.add_filled(n);
    Ok(())
}

// All three of these functions take an unitialized buffer,
// initialize it with random data, and return the initialized buffer.

// First impl: Use our existing API and manually initialize the buffer.
pub fn impl1(b: &mut [MaybeUninit<u8>]) -> Option<&mut [u8]> {
    for byte in b.iter_mut() {
        byte.write(0);
    }
    let ib = unsafe { MaybeUninit::slice_assume_init_mut(b) };
    getrandom(ib).ok()?;
    Some(ib)
}

// Second impl: Use our existing API with ReadBuf
pub fn impl2(b: &mut [MaybeUninit<u8>]) -> Option<&mut [u8]> {
    let mut rb = ReadBuf::uninit(b);
    let ib = rb.initialize_unfilled();
    getrandom(ib).ok()?;
    let n = rb.filled_len();
    Some(unsafe { MaybeUninit::slice_assume_init_mut(&mut b[0..n]) })
}

// Third impl: Use our new API with ReadBuf
pub fn impl3(b: &mut [MaybeUninit<u8>]) -> Option<&mut [u8]> {
    let mut rb = ReadBuf::uninit(b);
    getrandom_read_buf(&mut rb).ok()?;
    let n = rb.filled_len();
    Some(unsafe { MaybeUninit::slice_assume_init_mut(&mut b[0..n]) })
}

// Fourth impl: Directly calling the underlying raw implementation.
// This isn't a serious contender, but exists for comparison purposes.
pub fn impl4(b: &mut [MaybeUninit<u8>]) -> Option<&mut [u8]> {
    if b.len() == 0 {
        return Some(&mut []);
    }
    unsafe { getrandom_inner(b.as_mut_ptr() as *mut u8, b.len()) }.ok()?;
    Some(unsafe { MaybeUninit::slice_assume_init_mut(b) })
}