Struct LocalState 

pub struct LocalState<'a> { /* private fields */ }

A local state for vDSO-based getrandom operations.

This state is rented from a shared Pool and used to fill buffers with random bytes.

use vdso_rng::{Pool, LocalState};

let pool = Pool::new().expect("Failed to create shared pool");
let mut local_state = LocalState::new(&pool).expect("Failed to create local state");

let mut buf = [0u8; 64];
local_state.fill(&mut buf, 0).expect("Failed to fill buffer");

assert!(buf.iter().any(|&x| x != 0), "Buffer should not be empty");

Typically, LocalState is intended to be used in a thread-local fashion. A thread rents a state once and reuses it for multiple getrandom calls. Since acquiring a new state incurs synchronization overhead, reusing the state within the same thread is strongly recommended.

On drop, the state is returned to the pool for reuse.

Safety

• Not async-signal-safe: LocalState is not safe to use within signal handlers. Reentrant usage (e.g., invoking LocalState::fill from a signal handler that interrupts a LocalState::fill) can lead to secret leakage or corruption.
• Reentrancy detection: While Rust’s borrowing rules typically prevent such misuse, it may occur in the presence of undefined behavior. Under debug builds, reentrancy is explicitly checked and will panic if detected.

Implementations

impl<'a> LocalState<'a>

pub fn new(pool: &'a Pool) -> Result<Self, Error>

Create a new local state from the given pool. The pool must outlive the local state.

pub fn try_fill(&mut self, buf: &mut [u8], flag: c_uint) -> Result<usize, Error>

Fill the provided buffer with random bytes. This method may not fill the entire buffer due to interrupts or low entropy conditions.

pub fn fill(&mut self, buf: &mut [u8], flag: c_uint) -> Result<(), Error>

Fill the provided buffer with random bytes. This method will block until the buffer is filled. It is implemented as a loop wrapping around LocalState::try_fill.

Trait Implementations

impl<'a> Drop for LocalState<'a>

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.