Struct vm_memory::mmap::GuestRegionMmap
source · [−]pub struct GuestRegionMmap<B = ()> { /* private fields */ }
Expand description
GuestMemoryRegion
implementation that mmaps the guest’s
memory region in the current process.
Represents a continuous region of the guest’s physical memory that is backed by a mapping in the virtual address space of the calling process.
Implementations
sourceimpl<B: Bitmap> GuestRegionMmap<B>
impl<B: Bitmap> GuestRegionMmap<B>
sourcepub fn new(
mapping: MmapRegion<B>,
guest_base: GuestAddress
) -> Result<Self, Error>
pub fn new(
mapping: MmapRegion<B>,
guest_base: GuestAddress
) -> Result<Self, Error>
Create a new memory-mapped memory region for the guest’s physical memory.
Methods from Deref<Target = MmapRegion<B>>
sourcepub fn as_ptr(&self) -> *mut u8
pub fn as_ptr(&self) -> *mut u8
Returns a pointer to the beginning of the memory region. Mutable accesses performed using the resulting pointer are not automatically accounted for by the dirty bitmap tracking functionality.
Should only be used for passing this region to ioctls for setting guest memory.
sourcepub fn file_offset(&self) -> Option<&FileOffset>
pub fn file_offset(&self) -> Option<&FileOffset>
Returns information regarding the offset into the file backing this region (if any).
sourcepub fn prot(&self) -> i32
pub fn prot(&self) -> i32
Returns the value of the prot
parameter passed to mmap
when mapping this region.
sourcepub fn flags(&self) -> i32
pub fn flags(&self) -> i32
Returns the value of the flags
parameter passed to mmap
when mapping this region.
sourcepub fn fds_overlap<T: Bitmap>(&self, other: &MmapRegion<T>) -> bool
pub fn fds_overlap<T: Bitmap>(&self, other: &MmapRegion<T>) -> bool
Checks whether this region and other
are backed by overlapping
FileOffset
objects.
This is mostly a sanity check available for convenience, as different file descriptors can alias the same file.
sourcepub fn is_hugetlbfs(&self) -> Option<bool>
pub fn is_hugetlbfs(&self) -> Option<bool>
Returns true
if the region is hugetlbfs
Trait Implementations
sourceimpl<B: Bitmap> Bytes<MemoryRegionAddress> for GuestRegionMmap<B>
impl<B: Bitmap> Bytes<MemoryRegionAddress> for GuestRegionMmap<B>
sourcefn write(&self, buf: &[u8], addr: MemoryRegionAddress) -> Result<usize>
fn write(&self, buf: &[u8], addr: MemoryRegionAddress) -> Result<usize>
Examples
- Write a slice at guest address 0x1200.
let res = gm
.write(&[1, 2, 3, 4, 5], GuestAddress(0x1200))
.expect("Could not write to guest memory");
assert_eq!(5, res);
sourcefn read(&self, buf: &mut [u8], addr: MemoryRegionAddress) -> Result<usize>
fn read(&self, buf: &mut [u8], addr: MemoryRegionAddress) -> Result<usize>
Examples
- Read a slice of length 16 at guestaddress 0x1200.
let buf = &mut [0u8; 16];
let res = gm
.read(buf, GuestAddress(0x1200))
.expect("Could not read from guest memory");
assert_eq!(16, res);
sourcefn read_from<F>(
&self,
addr: MemoryRegionAddress,
src: &mut F,
count: usize
) -> Result<usize> where
F: Read,
fn read_from<F>(
&self,
addr: MemoryRegionAddress,
src: &mut F,
count: usize
) -> Result<usize> where
F: Read,
Examples
- Read bytes from /dev/urandom
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");
sourcefn read_exact_from<F>(
&self,
addr: MemoryRegionAddress,
src: &mut F,
count: usize
) -> Result<()> where
F: Read,
fn read_exact_from<F>(
&self,
addr: MemoryRegionAddress,
src: &mut F,
count: usize
) -> Result<()> where
F: Read,
Examples
- Read bytes from /dev/urandom
let mut file = File::open(Path::new("/dev/urandom")).expect("Could not open /dev/urandom");
gm.read_exact_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");
sourcefn write_to<F>(
&self,
addr: MemoryRegionAddress,
dst: &mut F,
count: usize
) -> Result<usize> where
F: Write,
fn write_to<F>(
&self,
addr: MemoryRegionAddress,
dst: &mut F,
count: usize
) -> Result<usize> where
F: Write,
Writes data from the region to a writable object.
Examples
- Write 128 bytes to a /dev/null file
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 to file from guest memory");
sourcefn write_all_to<F>(
&self,
addr: MemoryRegionAddress,
dst: &mut F,
count: usize
) -> Result<()> where
F: Write,
fn write_all_to<F>(
&self,
addr: MemoryRegionAddress,
dst: &mut F,
count: usize
) -> Result<()> where
F: Write,
Writes data from the region to a writable object.
Examples
- Write 128 bytes to a /dev/null file
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 to file from guest memory");
sourcefn write_slice(&self, buf: &[u8], addr: MemoryRegionAddress) -> Result<()>
fn write_slice(&self, buf: &[u8], addr: MemoryRegionAddress) -> Result<()>
Writes the entire content of a slice into the container at addr
. Read more
sourcefn read_slice(&self, buf: &mut [u8], addr: MemoryRegionAddress) -> Result<()>
fn read_slice(&self, buf: &mut [u8], addr: MemoryRegionAddress) -> Result<()>
Reads data from the container at addr
to fill an entire slice. Read more
sourcefn store<T: AtomicAccess>(
&self,
val: T,
addr: MemoryRegionAddress,
order: Ordering
) -> Result<()>
fn store<T: AtomicAccess>(
&self,
val: T,
addr: MemoryRegionAddress,
order: Ordering
) -> Result<()>
Atomically store a value at the specified address.
sourcefn load<T: AtomicAccess>(
&self,
addr: MemoryRegionAddress,
order: Ordering
) -> Result<T>
fn load<T: AtomicAccess>(
&self,
addr: MemoryRegionAddress,
order: Ordering
) -> Result<T>
Atomically load a value from the specified address.
sourceimpl<B: Debug> Debug for GuestRegionMmap<B>
impl<B: Debug> Debug for GuestRegionMmap<B>
sourceimpl<B> Deref for GuestRegionMmap<B>
impl<B> Deref for GuestRegionMmap<B>
type Target = MmapRegion<B>
type Target = MmapRegion<B>
The resulting type after dereferencing.
sourcefn deref(&self) -> &MmapRegion<B>
fn deref(&self) -> &MmapRegion<B>
Dereferences the value.
sourceimpl<'a, B: 'a> GuestMemoryIterator<'a, GuestRegionMmap<B>> for GuestMemoryMmap<B>
impl<'a, B: 'a> GuestMemoryIterator<'a, GuestRegionMmap<B>> for GuestMemoryMmap<B>
sourceimpl<B: Bitmap> GuestMemoryRegion for GuestRegionMmap<B>
impl<B: Bitmap> GuestMemoryRegion for GuestRegionMmap<B>
type B = B
type B = B
Type used for dirty memory tracking.
sourcefn len(&self) -> GuestUsize
fn len(&self) -> GuestUsize
Returns the size of the region.
sourcefn start_addr(&self) -> GuestAddress
fn start_addr(&self) -> GuestAddress
Returns the minimum (inclusive) address managed by the region.
sourcefn get_host_address(&self, addr: MemoryRegionAddress) -> Result<*mut u8>
fn get_host_address(&self, addr: MemoryRegionAddress) -> Result<*mut u8>
Returns the host virtual address corresponding to the region address. Read more
sourcefn file_offset(&self) -> Option<&FileOffset>
fn file_offset(&self) -> Option<&FileOffset>
Returns information regarding the file and offset backing this memory region.
sourceunsafe fn as_slice(&self) -> Option<&[u8]>
unsafe fn as_slice(&self) -> Option<&[u8]>
Returns a slice corresponding to the data in the region. Read more
sourceunsafe fn as_mut_slice(&self) -> Option<&mut [u8]>
unsafe fn as_mut_slice(&self) -> Option<&mut [u8]>
Returns a mutable slice corresponding to the data in the region. Read more
sourcefn get_slice(
&self,
offset: MemoryRegionAddress,
count: usize
) -> Result<VolatileSlice<'_, BS<'_, B>>>
fn get_slice(
&self,
offset: MemoryRegionAddress,
count: usize
) -> Result<VolatileSlice<'_, BS<'_, B>>>
Returns a VolatileSlice
of count
bytes starting at
offset
. Read more
sourcefn is_hugetlbfs(&self) -> Option<bool>
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. Read more
sourcefn last_addr(&self) -> GuestAddress
fn last_addr(&self) -> GuestAddress
Returns the maximum (inclusive) address managed by the region.
sourcefn check_address(&self, addr: MemoryRegionAddress) -> Option<MemoryRegionAddress>
fn check_address(&self, addr: MemoryRegionAddress) -> Option<MemoryRegionAddress>
Returns the given address if it is within this region.
sourcefn address_in_range(&self, addr: MemoryRegionAddress) -> bool
fn address_in_range(&self, addr: MemoryRegionAddress) -> bool
Returns true
if the given address is within this region.
sourcefn checked_offset(
&self,
base: MemoryRegionAddress,
offset: usize
) -> Option<MemoryRegionAddress>
fn checked_offset(
&self,
base: MemoryRegionAddress,
offset: usize
) -> Option<MemoryRegionAddress>
Returns the address plus the offset if it is in this region.
sourcefn to_region_addr(&self, addr: GuestAddress) -> Option<MemoryRegionAddress>
fn to_region_addr(&self, addr: GuestAddress) -> Option<MemoryRegionAddress>
Tries to convert an absolute address to a relative address within this region. Read more
sourcefn as_volatile_slice(&self) -> Result<VolatileSlice<'_, BS<'_, Self::B>>>
fn as_volatile_slice(&self) -> Result<VolatileSlice<'_, BS<'_, Self::B>>>
Gets a slice of memory for the entire region that supports volatile access. Read more
Auto Trait Implementations
impl<B> RefUnwindSafe for GuestRegionMmap<B> where
B: RefUnwindSafe,
impl<B> Send for GuestRegionMmap<B> where
B: Send,
impl<B> Sync for GuestRegionMmap<B> where
B: Sync,
impl<B> Unpin for GuestRegionMmap<B> where
B: Unpin,
impl<B> UnwindSafe for GuestRegionMmap<B> where
B: UnwindSafe,
Blanket Implementations
sourceimpl<T> BorrowMut<T> for T where
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
const: unstable · sourcefn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more