Struct VirtioRngDevice 

pub struct VirtioRngDevice {
    base_addr: usize,
    virtqueues: Mutex<[VirtQueue<'static>; 1]>,
    buffer: Mutex<VecDeque<u8>>,
    features: RwLock<u32>,
    initialized: RwLock<bool>,
}

VirtIO RNG Device

This device provides access to a hardware random number generator through the VirtIO interface, acting as an entropy source for the kernel RNG.

Fields

base_addr: usize

Base memory address for MMIO access

virtqueues: Mutex<[VirtQueue<'static>; 1]>

VirtIO queue for random number requests

buffer: Mutex<VecDeque<u8>>

Internal buffer for random data

features: RwLock<u32>

Negotiated features

initialized: RwLock<bool>

Device initialization status

Implementations

impl VirtioRngDevice

pub fn new(base_addr: usize) -> Self

Create a new VirtIO RNG device

Arguments

• base_addr - Base memory address for the device’s MMIO region

Returns

A new VirtioRngDevice instance

fn fill_buffer(&self) -> Result<usize, &'static str>

Fill the internal buffer with random data from the device

This method requests random data from the VirtIO RNG device and stores it in the internal buffer for later reads.

Returns

The number of bytes added to the buffer, or an error message

fn read_byte_internal(&self) -> Option<u8>

Read a byte from the internal buffer, filling it if necessary

Returns

A byte from the buffer, or None if unable to get random data

Trait Implementations

impl EntropySource for VirtioRngDevice

fn name(&self) -> &'static str

Get a name for this entropy source

fn read_entropy(&self, buffer: &mut [u8]) -> usize

Read random bytes from this source

fn is_available(&self) -> bool

Check if this source is available and ready

impl VirtioDevice for VirtioRngDevice

fn get_base_addr(&self) -> usize

fn get_virtqueue_count(&self) -> usize

fn get_virtqueue_size(&self, queue_idx: usize) -> usize

fn get_queue_desc_addr(&self, queue_idx: usize) -> Option<u64>

Get the descriptor address for a virtqueue

fn get_queue_driver_addr(&self, queue_idx: usize) -> Option<u64>

Get the driver area address for a virtqueue

fn get_queue_device_addr(&self, queue_idx: usize) -> Option<u64>

Get the device area address for a virtqueue

fn get_supported_features(&self, _device_features: u32) -> u32

Get device features supported by this driver

fn debug_dump_mmio_state(&self, tag: &'static str)

fn debug_log_status_transition( &self, tag: &'static str, old: u32, new: u32, readback: u32, )

fn wait_for_status_zero( &self, tag: &'static str, max_iters: usize, ) -> Result<(), &'static str>

fn init(&mut self) -> Result<u32, &'static str>

Initialize the device

fn is_modern_device(&self) -> bool

fn supports_feature(&self, feature: u32) -> bool

fn reset(&mut self) -> Result<(), &'static str>

Reset the device by writing 0 to the Status register

fn acknowledge(&mut self)

Set ACKNOWLEDGE status bit

fn driver(&mut self)

Set DRIVER status bit

fn driver_ok(&mut self)

Set DRIVER_OK status bit

fn set_failed(&mut self)

Set FAILED status bit

fn negotiate_features(&mut self) -> Result<u32, &'static str>

Negotiate device features

fn allow_ring_features(&self) -> bool

fn setup_queue(&mut self, queue_idx: usize, queue_size: usize) -> bool

Set up a virtqueue

fn read_config<T: Sized>(&self, offset: usize) -> T

Read device-specific configuration

fn write_config<T: Sized>(&self, offset: usize, value: T)

Write device-specific configuration

fn get_device_info(&self) -> (u32, u32)

Get device and vendor IDs

fn get_interrupt_status(&self) -> u32

Get interrupt status

fn process_interrupts(&mut self) -> u32

Process interrupts (polling method)

fn memory_barrier(&self)

Memory barrier for ensuring memory operations ordering

fn notify(&self, virtqueue_idx: usize)

Notify the device about new buffers in a specified virtqueue

fn read32_register(&self, register: Register) -> u32

Read a 32-bit value from a device register

fn write32_register(&self, register: Register, value: u32)

Write a 32-bit value to a device register

fn read64_register(&self, register: Register) -> u64

Read a 64-bit value from a device register

fn write64_register(&self, register: Register, value: u64)

Write a 64-bit value to a device register