Enum GuestRegionHybrid 

pub enum GuestRegionHybrid<B = ()> {
    Mmap(GuestRegionMmap<B>),
    Raw(GuestRegionRaw<B>),
}

An adapter for different concrete implementations of GuestMemoryRegion.

Variants

Mmap(GuestRegionMmap<B>)

Region of type GuestRegionMmap.

Raw(GuestRegionRaw<B>)

Region of type GuestRegionRaw.

Implementations

impl<B: Bitmap> GuestRegionHybrid<B>

pub fn from_mmap_region(region: GuestRegionMmap<B>) -> Self

Create a GuestRegionHybrid object from GuestRegionMmap object.

pub fn from_raw_region(region: GuestRegionRaw<B>) -> Self

Create a GuestRegionHybrid object from GuestRegionRaw object.

Trait Implementations

impl<B: Bitmap> Bytes<MemoryRegionAddress> for GuestRegionHybrid<B>

type E = Error

Associated error codes

fn write(&self, buf: &[u8], addr: MemoryRegionAddress) -> Result<usize>

Writes a slice into the container at addr.

fn read(&self, buf: &mut [u8], addr: MemoryRegionAddress) -> Result<usize>

Reads data from the container at addr into a slice.

fn write_slice(&self, buf: &[u8], addr: MemoryRegionAddress) -> Result<()>

Writes the entire content of a slice into the container at addr.

fn read_slice(&self, buf: &mut [u8], addr: MemoryRegionAddress) -> Result<()>

Reads data from the container at addr to fill an entire slice.

fn read_from<F>( &self, addr: MemoryRegionAddress, src: &mut F, count: usize, ) -> Result<usize>

where F: Read,

Reads up to count bytes from an object and writes them into the container at addr.

fn read_exact_from<F>( &self, addr: MemoryRegionAddress, src: &mut F, count: usize, ) -> Result<()>

where F: Read,

Reads exactly count bytes from an object and writes them into the container at addr.

fn write_to<F>( &self, addr: MemoryRegionAddress, dst: &mut F, count: usize, ) -> Result<usize>

where F: Write,

Reads up to count bytes from the container at addr and writes them it into an object.

fn write_all_to<F>( &self, addr: MemoryRegionAddress, dst: &mut F, count: usize, ) -> Result<()>

where F: Write,

Reads exactly count bytes from the container at addr and writes them into an object.

fn store<T: AtomicAccess>( &self, val: T, addr: MemoryRegionAddress, order: Ordering, ) -> Result<()>

Atomically store a value at the specified address.

fn load<T: AtomicAccess>( &self, addr: MemoryRegionAddress, order: Ordering, ) -> Result<T>

Atomically load a value from the specified address.

fn write_obj<T>(&self, val: T, addr: A) -> Result<(), Self::E>

where T: ByteValued,

Writes an object into the container at addr.

fn read_obj<T>(&self, addr: A) -> Result<T, Self::E>

where T: ByteValued,

Reads an object from the container at addr.

impl<B: Debug> Debug for GuestRegionHybrid<B>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'a, B: 'a> GuestMemoryIterator<'a, GuestRegionHybrid<B>> for GuestMemoryHybrid<B>

type Iter = Iter<'a, B>

Type of the iter method’s return value.

impl<B: Bitmap> GuestMemoryRegion for GuestRegionHybrid<B>

type B = B

Type used for dirty memory tracking.

fn len(&self) -> GuestUsize

Returns the size of the region.

fn start_addr(&self) -> GuestAddress

Returns the minimum (inclusive) address managed by the region.

fn bitmap(&self) -> &Self::B

Borrow the associated Bitmap object.

fn get_host_address(&self, addr: MemoryRegionAddress) -> Result<*mut u8>

Returns the host virtual address corresponding to the region address.

fn file_offset(&self) -> Option<&FileOffset>

Returns information regarding the file and offset backing this memory region.

unsafe fn as_slice(&self) -> Option<&[u8]>

Returns a slice corresponding to the data in the region.

unsafe fn as_mut_slice(&self) -> Option<&mut [u8]>

Returns a mutable slice corresponding to the data in the region.

fn get_slice( &self, offset: MemoryRegionAddress, count: usize, ) -> Result<VolatileSlice<'_, BS<'_, B>>>

Returns a VolatileSlice of count bytes starting at offset.

fn is_hugetlbfs(&self) -> Option<bool>

Show if the region is based on the HugeTLBFS. Returns Some(true) if the region is backed by hugetlbfs. None represents that no information is available.

fn last_addr(&self) -> GuestAddress

Returns the maximum (inclusive) address managed by the region.

fn check_address( &self, addr: MemoryRegionAddress, ) -> Option<MemoryRegionAddress>

Returns the given address if it is within this region.

fn address_in_range(&self, addr: MemoryRegionAddress) -> bool

Returns true if the given address is within this region.

fn checked_offset( &self, base: MemoryRegionAddress, offset: usize, ) -> Option<MemoryRegionAddress>

Returns the address plus the offset if it is in this region.

fn to_region_addr(&self, addr: GuestAddress) -> Option<MemoryRegionAddress>

Tries to convert an absolute address to a relative address within this region.

fn as_volatile_slice( &self, ) -> Result<VolatileSlice<'_, <Self::B as WithBitmapSlice<'_>>::S>, Error>

Gets a slice of memory for the entire region that supports volatile access.