Struct devices::virtio::block::asynchronous::BlockAsync

pub struct BlockAsync {

    boot_index: Option<usize>,
    disk_image: Option<Box<dyn DiskFile>>,
    disk_size: Arc<AtomicU64>,
    avail_features: u64,
    read_only: bool,
    sparse: bool,
    seg_max: u32,
    block_size: u32,
    id: Option<[u8; 20]>,
    control_tube: Option<Tube>,
    queue_sizes: Vec<u16>,
    pub(super) executor_kind: ExecutorKind,
    worker_threads: BTreeMap<usize, (WorkerThread<()>, UnboundedSender<WorkerCmd>)>,
    shared_state: Arc<RwLock<WorkerSharedState>>,
    worker_per_queue: bool,
    activated_queues: BTreeSet<usize>,
    pci_address: Option<PciAddress>,
}

Virtio device for exposing block level read/write operations on a host file.

Fields

boot_index: Option<usize>

disk_image: Option<Box<dyn DiskFile>>

disk_size: Arc<AtomicU64>

avail_features: u64

read_only: bool

sparse: bool

seg_max: u32

block_size: u32

id: Option<[u8; 20]>

control_tube: Option<Tube>

queue_sizes: Vec<u16>

executor_kind: ExecutorKind

worker_threads: BTreeMap<usize, (WorkerThread<()>, UnboundedSender<WorkerCmd>)>

shared_state: Arc<RwLock<WorkerSharedState>>

worker_per_queue: bool

activated_queues: BTreeSet<usize>

pci_address: Option<PciAddress>

Implementations

impl BlockAsync

pub fn new( base_features: u64, disk_image: Box<dyn DiskFile>, disk_option: &DiskOption, control_tube: Option<Tube>, queue_size: Option<u16>, num_queues: Option<u16> ) -> SysResult<BlockAsync>

Create a new virtio block device that operates on the given AsyncDisk.

fn build_avail_features( base_features: u64, read_only: bool, sparse: bool, multi_queue: bool, packed_queue: bool ) -> u64

Returns the feature flags given the specified attributes.

async fn execute_request( reader: &mut Reader, writer: &mut Writer, disk_state: &AsyncRwLock<DiskState>, flush_timer: &RefCell<TimerAsync<Timer>>, flush_timer_armed: &RefCell<bool> ) -> Result<(), ExecuteError>

fn build_config_space( disk_size: u64, seg_max: u32, block_size: u32, num_queues: u16 ) -> virtio_blk_config

Builds and returns the config structure used to specify block features.

fn start_worker( &mut self, idx: usize ) -> Result<&(WorkerThread<()>, UnboundedSender<WorkerCmd>)>

Get the worker for a queue, starting it if necessary.

pub fn start_queue( &mut self, idx: usize, queue: Queue, _mem: GuestMemory ) -> Result<()>

pub fn stop_queue(&mut self, idx: usize) -> Result<Queue>

impl BlockAsync

pub fn create_executor(&self) -> Executor

Trait Implementations

impl VhostUserDeviceBuilder for BlockAsync

fn build(self: Box<Self>, _ex: &Executor) -> Result<Box<dyn Backend>>

Create the vhost-user device.

impl VirtioDevice for BlockAsync

fn keep_rds(&self) -> Vec<RawDescriptor>

A vector of device-specific file descriptors that must be kept open after jailing. Must be called before the process is jailed.

fn features(&self) -> u64

The set of feature bits that this device supports in addition to the base features.

fn device_type(&self) -> DeviceType

The virtio device type.

fn queue_max_sizes(&self) -> &[u16]

The maximum size of each queue that this device supports.

fn read_config(&self, offset: u64, data: &mut [u8])

Reads this device configuration space at offset.

fn activate( &mut self, mem: GuestMemory, _interrupt: Interrupt, queues: BTreeMap<usize, Queue> ) -> Result<()>

Activates this device for real usage.

fn reset(&mut self) -> Result<()>

Optionally deactivates this device. If the reset method is not able to reset the virtio device, or the virtio device model doesn’t implement the reset method, an Err value is returned to indicate the reset is not successful. Otherwise Ok(()) should be returned.

fn virtio_sleep(&mut self) -> Result<Option<BTreeMap<usize, Queue>>>

Pause all processing.

fn virtio_wake( &mut self, queues_state: Option<(GuestMemory, Interrupt, BTreeMap<usize, Queue>)> ) -> Result<()>

Resume all processing.

fn virtio_snapshot(&mut self) -> Result<Value>

Snapshot current state. Device must be asleep.

fn virtio_restore(&mut self, data: Value) -> Result<()>

Restore device state from a snapshot. TODO(b/280607404): Vhost user will need fds passed to the device process.

fn pci_address(&self) -> Option<PciAddress>

Returns the PCI address where the device will be allocated. Returns None if any address is good for the device.

fn bootorder_fw_cfg(&self, pci_slot: u8) -> Option<(Vec<u8>, usize)>

fn debug_label(&self) -> String

Returns a label suitable for debug output.

fn num_interrupts(&self) -> usize

The number of interrupts used by this device.

fn ack_features(&mut self, value: u64)

Acknowledges that this set of features should be enabled.

fn write_config(&mut self, offset: u64, data: &[u8])

Writes to this device configuration space at offset.

fn get_device_bars(&mut self, _address: PciAddress) -> Vec<PciBarConfiguration>

Returns any additional BAR configuration required by the device.

fn get_device_caps(&self) -> Vec<Box<dyn PciCapability>>

Returns any additional capabiltiies required by the device.

fn on_device_sandboxed(&mut self)

Invoked when the device is sandboxed.

fn control_notify(&self, _behavior: MsixStatus)

fn generate_acpi( &mut self, _pci_address: &Option<PciAddress>, sdts: Vec<SDT> ) -> Option<Vec<SDT>>

fn transport_type(&self) -> VirtioTransportType

Returns the Virtio transport type: PCI (default for crosvm) or MMIO.

fn get_shared_memory_region(&self) -> Option<SharedMemoryRegion>

Returns the device’s shared memory region if present.

fn expose_shmem_descriptors_with_viommu(&self) -> bool

If true, VFIO passthrough devices can access descriptors mapped into this region by mapping the corresponding addresses from this device’s PCI bar into their IO address space with virtio-iommu.

fn set_shared_memory_mapper(&mut self, _mapper: Box<dyn SharedMemoryMapper>)

Provides the trait object used to map files into the device’s shared memory region.

fn set_shared_memory_region(&mut self, shmem_region: AddressRange)

Provides the guest address range of the shared memory region, if one is present. Will be called before activate.

fn get_shared_memory_prepare_type(&mut self) -> SharedMemoryPrepareType

Queries the implementation whether a single prepared hypervisor memory mapping with explicit caching type should be setup lazily on first mapping request, or whether to dynamically setup a hypervisor mapping with every request’s caching type.