Struct vm_memory :: mmap :: GuestMemoryMmap Copy item path

impl<B: NewBitmap> GuestMemoryMmap

pub fn new() -> Self

Creates an empty GuestMemoryMmap instance.

pub fn from_ranges(ranges: &[(GuestAddress, usize)]) -> Result<Self, Error>

Creates a container and allocates anonymous memory for guest memory regions.

Valid memory regions are specified as a slice of (Address, Size) tuples sorted by Address.

pub fn from_ranges_with_files<A, T>(ranges: T) -> Result<Self, Error>
where A: Borrow<(GuestAddress, usize, Option<FileOffset>)>, T: IntoIterator<Item = A>,

Creates a container and allocates anonymous memory for guest memory regions.

Valid memory regions are specified as a sequence of (Address, Size, Option) tuples sorted by Address.

impl<B: Bitmap> GuestMemoryMmap

pub fn from_regions(regions: Vec<GuestRegionMmap>) -> Result<Self, Error>

Creates a new GuestMemoryMmap from a vector of regions.

§Arguments

regions - The vector of regions. The regions shouldn’t overlap and they should be sorted by the starting address.

pub fn from_arc_regions( regions: Vec<Arc<GuestRegionMmap>>, ) -> Result<Self, Error>

Creates a new GuestMemoryMmap from a vector of Arc regions.

Similar to the constructor from_regions() as it returns a GuestMemoryMmap. The need for this constructor is to provide a way for consumer of this API to create a new GuestMemoryMmap based on existing regions coming from an existing GuestMemoryMmap instance.

§Arguments

regions - The vector of Arc regions. The regions shouldn’t overlap and they should be sorted by the starting address.

pub fn insert_region( &self, region: Arc<GuestRegionMmap>, ) -> Result<GuestMemoryMmap, Error>

Insert a region into the GuestMemoryMmap object and return a new GuestMemoryMmap.

§Arguments

region: the memory region to insert into the guest memory object.

pub fn remove_region( &self, base: GuestAddress, size: GuestUsize, ) -> Result<(GuestMemoryMmap, Arc<GuestRegionMmap>), Error>

Remove a region into the GuestMemoryMmap object and return a new GuestMemoryMmap on success, together with the removed region.

§Arguments

base: base address of the region to be removed
size: size of the region to be removed

Trait Implementations§

impl<B: Clone> Clone for GuestMemoryMmap

fn clone(&self) -> GuestMemoryMmap

Returns a copy of the value. Read more

1.0.0 · source§

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source. Read more

impl<B: Debug> Debug for GuestMemoryMmap

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

Formats the value using the given formatter. Read more

impl<B: Default> Default for GuestMemoryMmap

fn default() -> GuestMemoryMmap

Returns the “default value” for a type. Read more

impl<B: Bitmap + 'static> GuestMemory for GuestMemoryMmap

type R = GuestRegionMmap

Type of objects hosted by the address space.

type I = GuestMemoryMmap

Lifetime generic associated iterators. Usually this is just Self.

fn num_regions(&self) -> usize

Returns the number of regions in the collection.

fn find_region(&self, addr: GuestAddress) -> Option<&GuestRegionMmap>

Returns the region containing the specified address or None.

fn iter(&self) -> Iter<'_, B> ⓘ

Gets an iterator over the entries in the collection. Read more

fn with_regions<F, E>(&self, cb: F) -> Result<(), E>
where F: Fn(usize, &Self::R) -> Result<(), E>,

👎Deprecated since 0.6.0: Use .iter() instead

Perform the specified action on each region. Read more

fn with_regions_mut<F, E>(&self, cb: F) -> Result<(), E>
where F: FnMut(usize, &Self::R) -> Result<(), E>,

👎Deprecated since 0.6.0: Use .iter() instead

Perform the specified action on each region mutably. Read more

fn map_and_fold<F, G, T>(&self, init: T, mapf: F, foldf: G) -> T
where F: Fn((usize, &Self::R)) -> T, G: Fn(T, T) -> T,

👎Deprecated since 0.6.0: Use .iter() instead

Applies two functions, specified as callbacks, on the inner memory regions. Read more

fn last_addr(&self) -> GuestAddress

Returns the maximum (inclusive) address managed by the GuestMemory. Read more

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

Tries to convert an absolute address to a relative address within the corresponding region. Read more

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

Returns true if the given address is present within the memory of the guest.

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

Returns the given address if it is present within the memory of the guest.

fn check_range(&self, base: GuestAddress, len: usize) -> bool

Check whether the range [base, base + len) is valid.

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

Returns the address plus the offset if it is present within the memory of the guest.

fn try_access<F>(&self, count: usize, addr: GuestAddress, f: F) -> Result<usize>
where F: FnMut(usize, usize, MemoryRegionAddress, &Self::R) -> Result<usize>,

Invokes callback f to handle data in the address range [addr, addr + count). Read more

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

Get the host virtual address corresponding to the guest address. Read more

fn get_slice( &self, addr: GuestAddress, count: usize, ) -> Result<VolatileSlice<'_, MS<'_, Self>>>

Returns a VolatileSlice of count bytes starting at addr.

impl<'a, B: 'a> GuestMemoryIterator<'a, GuestRegionMmap> for GuestMemoryMmap

type Iter = Iter<'a, B>

Type of the iter method’s return value.

Auto Trait Implementations§

impl UnwindSafe for GuestMemoryMmap
where B: RefUnwindSafe,

Blanket Implementations§

impl<T> Any for T
where T: 'static + ?Sized,

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more

impl<T> Borrow<T> for T
where T: ?Sized,

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

impl<T> BorrowMut<T> for T
where T: ?Sized,

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more

impl<T> Bytes<GuestAddress> for T
where T: GuestMemory + ?Sized,

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

§Examples

Write a slice at guestaddress 0x1000. (uses the backend-mmap feature)

gm.write_slice(&[1, 2, 3, 4, 5], start_addr)
    .expect("Could not write slice to guest memory");

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

§Examples

Read a slice of length 16 at guestaddress 0x1000. (uses the backend-mmap feature)

let start_addr = GuestAddress(0x1000);
let mut gm = GuestMemoryMmap::<()>::from_ranges(&vec![(start_addr, 0x400)])
    .expect("Could not create guest memory");
let buf = &mut [0u8; 16];

gm.read_slice(buf, start_addr)
    .expect("Could not read slice from guest memory");

fn read_from<F>( &self, addr: GuestAddress, src: &mut F, count: usize, ) -> Result<usize, Error>
where F: Read,

§Examples

Read bytes from /dev/urandom (uses the backend-mmap feature)

let mut file = File::open(Path::new("/dev/urandom")).expect("Could not open /dev/urandom");

gm.read_from(addr, &mut file, 128)
    .expect("Could not read from /dev/urandom into guest memory");

let read_addr = addr.checked_add(8).expect("Could not compute read address");
let rand_val: u32 = gm
    .read_obj(read_addr)
    .expect("Could not read u32 val from /dev/urandom");

fn write_to<F>( &self, addr: GuestAddress, dst: &mut F, count: usize, ) -> Result<usize, Error>
where F: Write,

§Examples

Write 128 bytes to /dev/null (uses the backend-mmap feature)

let mut file = OpenOptions::new()
    .write(true)
    .open("/dev/null")
    .expect("Could not open /dev/null");

gm.write_to(start_addr, &mut file, 128)
    .expect("Could not write 128 bytes to the provided address");

fn write_all_to<F>( &self, addr: GuestAddress, dst: &mut F, count: usize, ) -> Result<(), Error>
where F: Write,

§Examples

Write 128 bytes to /dev/null (uses the backend-mmap feature)

let mut file = OpenOptions::new()
    .write(true)
    .open("/dev/null")
    .expect("Could not open /dev/null");

gm.write_all_to(start_addr, &mut file, 128)
    .expect("Could not write 128 bytes to the provided address");

type E = Error

Associated error codes

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

Writes a slice into the container at addr. Read more

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

Reads data from the container at addr into a slice. Read more

fn read_exact_from<F>( &self, addr: GuestAddress, src: &mut F, count: usize, ) -> Result<(), Error>
where F: Read,

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

fn store<O>( &self, val: O, addr: GuestAddress, order: Ordering, ) -> Result<(), Error>
where O: AtomicAccess,

Atomically store a value at the specified address.

fn load<O>(&self, addr: GuestAddress, order: Ordering) -> Result<O, Error>
where O: AtomicAccess,

Atomically load a value from the specified address.

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

Writes an object into the container at addr. Read more

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

Reads an object from the container at addr. Read more

impl<T> CloneToUninit for T
where T: Clone,

default unsafe fn clone_to_uninit(&self, dst: *mut T)

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

Performs copy-assignment from self to dst. Read more

impl<T> From<T> for T

fn from(t: T) -> T

Returns the argument unchanged.

impl<T, U> Into for T
where U: From<T>,

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

impl<T> ToOwned for T
where T: Clone,

type Owned = T

The resulting type after obtaining ownership.

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more

impl<T, U> TryFrom for T
where U: Into<T>,

type Error = Infallible

The type returned in the event of a conversion error.

fn try_from(value: U) -> Result<T, <T as TryFrom>::Error>

Performs the conversion.

impl<T, U> TryInto for T
where U: TryFrom<T>,

type Error = >::Error

The type returned in the event of a conversion error.