Struct Mapping 

pub struct Mapping { /* private fields */ }

Describes a single memory mapping entry.

The size of this type heavily influences Starnix’s heap usage in common scenarios, please think twice about increasing its size. Compiling in “release” mode includes a compile time check for size increase.

Implementations

impl Mapping

pub fn name(&self) -> MappingNameRef<'_>

pub fn set_name(&mut self, new: MappingName)

impl Mapping

pub fn new( backing: MappingBacking, flags: MappingFlags, mode: MappingMode, ) -> Mapping

pub fn with_name( backing: MappingBacking, flags: MappingFlags, name: MappingName, mode: MappingMode, ) -> Mapping

pub fn flags(&self) -> MappingFlags

pub fn mapping_mode(&self) -> MappingMode

pub fn set_mapping_mode(&mut self, mode: MappingMode)

pub fn set_flags(&mut self, new_flags: MappingFlags)

pub fn get_backing_internal(&self) -> &MappingBacking

pub fn set_backing_internal(&mut self, backing: MappingBacking)

pub fn set_uffd(&mut self, mode: FaultRegisterMode)

pub fn clear_uffd(&mut self)

pub fn set_mlock(&mut self)

pub fn clear_mlock(&mut self)

pub fn new_private_anonymous( flags: MappingFlags, name: MappingName, mode: MappingMode, ) -> Mapping

pub fn inflate_to_include_guard_pages( &self, range: &Range<UserAddress>, ) -> Range<UserAddress>

pub fn address_to_offset(&self, addr: UserAddress) -> u64

Converts a UserAddress to an offset in this mapping’s memory object.

pub fn can_read(&self) -> bool

pub fn can_write(&self) -> bool

pub fn can_exec(&self) -> bool

pub fn may_exec(&self) -> bool

Returns whether this mapping is allowed to be executable, as reported by me in /proc/[pid]/smaps. For file mappings, this is false if the file is on a noexec mount or is sealed against execution. Security checks (see security::file_mprotect()) may still deny making the mapping executable.

pub fn has_cow_modifications(&self) -> Result<bool, Errno>

Returns whether this is a private file mapping with pages that were modified via copy-on-write, and are therefore no longer shared with the mapped file.

Writable private file mappings created by default_mmap() are backed by a copy-on-write child of the file’s memory, created for each mmap() call. This over-approximates the modified pages to the whole region that was mapped, rather than just the pages of this mapping. Read-only ones (MappingFlags::LAZY_PRIVATE_FILE) are backed by the file’s memory until they are written, so they have no modified pages.

Zircon only reports the number of pages that a memory object holds, not which ones, so the whole memory object is considered.

TODO(https://fxbug.dev/409256444): This also reports pages that were committed without being written (e.g. with MAP_POPULATE), and, for files whose memory isn’t pager-backed (e.g. tmpfs), pages that the file stopped sharing because the file was modified.

Errors

Fails if the information about the memory object can’t be retrieved (e.g. if its handle lacks Rights::INSPECT), in which case whether it holds modified pages is unknown.

pub fn set_cow_modified(&mut self)

Records that the memory of this mapping holds pages modified via copy-on-write. See Mapping::has_cow_modifications.

pub fn is_known_cow_modified(&self) -> bool

Returns whether the memory of this mapping is already known to hold pages modified via copy-on-write.

pub fn private_anonymous(&self) -> bool

pub fn vm_flags(&self) -> String

Trait Implementations

impl Clone for Mapping

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Mapping

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

Formats the value using the given formatter.

impl Drop for Mapping

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

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

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.

impl Eq for Mapping

impl PartialEq for Mapping

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.