Struct mmap_rs::MmapNone

pub struct MmapNone { /* private fields */ }

Represents an inaccessible memory mapping.

Implementations

impl MmapNone

pub fn file(&self) -> Option<&File>

Yields the file backing this mapping, if this mapping is backed by a file.

pub fn as_ptr(&self) -> *const u8

Yields a raw immutable pointer of this mapping.

pub fn size(&self) -> usize

Yields the size of this mapping.

pub fn lock(&mut self) -> Result<(), Error>

Locks the physical pages in memory such that accessing the mapping causes no page faults.

pub fn unlock(&mut self) -> Result<(), Error>

Unlocks the physical pages in memory, allowing the operating system to swap out the pages backing this memory mapping.

pub fn flush(&self, range: Range<usize>) -> Result<(), Error>

Flushes the memory mapping synchronously, i.e. this function waits for the flush to complete.

pub fn flush_async(&self, range: Range<usize>) -> Result<(), Error>

Flushes the memory mapping asynchronously.

pub fn flush_icache(&self) -> Result<(), Error>

This function can be used to flush the instruction cache on architectures where this is required.

While the x86 and x86-64 architectures guarantee cache coherency between the L1 instruction and the L1 data cache, other architectures such as Arm and AArch64 do not. If the user modified the pages, then executing the code may result in undefined behavior. To ensure correct behavior a user has to flush the instruction cache after modifying and before executing the page.

pub fn make_none(self) -> Result<MmapNone, (Self, Error)>

Remaps this memory mapping as inaccessible.

In case of failure, this returns the ownership of self.

pub fn make_read_only(self) -> Result<Mmap, (Self, Error)>

Remaps this memory mapping as immutable.

In case of failure, this returns the ownership of self.

pub fn make_exec(self) -> Result<Mmap, (Self, Error)>

Remaps this memory mapping as executable.

In case of failure, this returns the ownership of self.

pub unsafe fn make_exec_no_flush(self) -> Result<Mmap, (Self, Error)>

Remaps this memory mapping as executable, but does not flush the instruction cache. Note that this is unsafe.

While the x86 and x86-64 architectures guarantee cache coherency between the L1 instruction and the L1 data cache, other architectures such as Arm and AArch64 do not. If the user modified the pages, then executing the code may result in undefined behavior. To ensure correct behavior a user has to flush the instruction cache after modifying and before executing the page.

In case of failure, this returns the ownership of self.

pub fn make_mut(self) -> Result<MmapMut, (Self, Error)>

Remaps this mapping to be mutable.

In case of failure, this returns the ownership of self.

pub unsafe fn make_exec_mut(self) -> Result<MmapMut, (Self, Error)>

Remaps this mapping to be executable and mutable.

While this may seem useful for self-modifying code and JIT engines, it is instead recommended to convert between mutable and executable mappings using Mmap::make_mut() and MmapMut::make_exec() instead.

As it may be tempting to use this function, this function has been marked as unsafe. Make sure to read the text below to understand the complications of this function before using it. The UnsafeMmapFlags::JIT flag must be set for this function to succeed.

RWX pages are an interesting targets to attackers, e.g. for buffer overflow attacks, as RWX mappings can potentially simplify such attacks. Without RWX mappings, attackers instead have to resort to return-oriented programming (ROP) gadgets. To prevent buffer overflow attacks, contemporary CPUs allow pages to be marked as non-executable which is then used by the operating system to ensure that pages are either marked as writeable or as executable, but not both. This is also known as W^X.

While the x86 and x86-64 architectures guarantee cache coherency between the L1 instruction and the L1 data cache, other architectures such as Arm and AArch64 do not. If the user modified the pages, then executing the code may result in undefined behavior. To ensure correct behavior a user has to flush the instruction cache after modifying and before executing the page.

In case of failure, this returns the ownership of self.