Enum RamdiskClient

pub enum RamdiskClient {
    V1 {
        block_dir: Option<DirectoryProxy>,
        block_controller: Option<ControllerProxy>,
        ramdisk_controller: Option<ControllerProxy>,
    },
    V2 {
        outgoing: DirectoryProxy,
        _event: EventPair,
    },
}

A client for managing a ramdisk. This can be created with the RamdiskClient::create function or through the type returned by RamdiskClient::builder to specify additional options.

Variants

V1

V1

Fields

block_dir: Option<DirectoryProxy>

The directory backing the block driver.

block_controller: Option<ControllerProxy>

The device controller for the block device.

ramdisk_controller: Option<ControllerProxy>

The device controller for the ramdisk.

V2

V2

Fields

outgoing: DirectoryProxy

The outgoing directory for the ram-disk.

_event: EventPair

The event that keeps the ramdisk alive.

Implementations

impl RamdiskClient

pub fn builder(block_size: u64, block_count: u64) -> RamdiskClientBuilder

Create a new ramdisk builder with the given block_size and block_count.

pub async fn create(block_size: u64, block_count: u64) -> Result<Self, Error>

Create a new ramdisk.

pub fn as_controller(&self) -> Option<&ControllerProxy>

Get a reference to the block controller.

pub fn take_controller(&mut self) -> Option<ControllerProxy>

Take the block controller.

pub fn as_dir(&self) -> Option<&DirectoryProxy>

Get a reference to the block directory proxy.

pub fn take_dir(&mut self) -> Option<DirectoryProxy>

Take the block directory proxy.

pub fn open(&self) -> Result<ClientEnd<BlockMarker>, Error>

Get an open channel to the underlying ramdevice.

pub fn connector(&self) -> Result<Box<dyn BlockConnector>, Error>

Gets a connector for the Block protocol of the ramdisk.

pub fn connect(&self, server_end: ServerEnd<BlockMarker>) -> Result<(), Error>

Get an open channel to the underlying ramdevice.

pub fn open_controller(&self) -> Result<ClientEnd<ControllerMarker>, Error>

Get an open channel to the underlying ramdevice’s controller.

pub async fn destroy(self) -> Result<(), Error>

Starts unbinding the underlying ramdisk and returns before the device is removed. This deallocates all resources for this ramdisk, which will remove all data written to the associated ramdisk.

pub async fn destroy_and_wait_for_removal(self) -> Result<(), Error>

Unbinds the underlying ramdisk and waits for the device and all child devices to be removed. This deallocates all resources for this ramdisk, which will remove all data written to the associated ramdisk.

pub fn forget(self) -> Result<(), Error>

Consume the RamdiskClient without destroying the underlying ramdisk. The caller must manually destroy the ramdisk device after calling this function.

This should be used instead of std::mem::forget, as the latter will leak memory.

Trait Implementations

impl BlockConnector for RamdiskClient

fn connect_channel_to_volume( &self, server_end: ServerEnd<VolumeMarker>, ) -> Result<(), Error>

fn connect_volume(&self) -> Result<ClientEnd<VolumeMarker>, Error>

fn connect_partition(&self) -> Result<ClientEnd<PartitionMarker>, Error>

fn connect_block(&self) -> Result<ClientEnd<BlockMarker>, Error>

impl Drop for RamdiskClient

fn drop(&mut self)

Executes the destructor for this type.