Struct MemoryFlags 

#[repr(transparent)]
pub struct MemoryFlags(pub u32);

Tuple Fields

0: u32

Implementations

impl MemoryFlags

pub const NONE: u32 = 0

No flags

pub const ACCESS_READ: u32 = 0x00000001

Memory is readable.

pub const ACCESS_WRITE: u32 = 0x00000002

Memory is writable.

pub const ACCESS_EXECUTE: u32 = 0x00000004

Memory is executable.

pub const ACCESS_RW: u32

Memory is readable and writable.

pub const ACCESS_RX: u32

Memory is readable and executable.

pub const ACCESS_RWX: u32

Memory is readable, writable and executable.

pub const MMAP_ENABLE_JIT: u32 = 0x00000010

Use a MAP_JIT flag available on Apple platforms (introduced by Mojave), which allows JIT code to be executed in a MAC bundle.

This flag may be turned on by the allocator if there is no other way of allocating executable memory.

Note

This flag can only be used with alloc(), MAP_JIT only works on OSX and not on iOS. When a process uses fork() the child process has no access to the pages mapped with MAP_JIT.

pub const MMAP_MAX_ACCESS_READ: u32 = 0x00000020

Pass PROT_MAX(PROT_READ) or PROT_MPROTECT(PROT_READ) to mmap() on platforms that support it.

This flag allows to set a “maximum access” that the memory page can get during its lifetime. Use protect to change the access flags.

Note

This flag can only be used with alloc() and alloc_dual_mapping. However alloc_dual_mapping may automatically use this if AccessRead is used.

pub const MMAP_MAX_ACCESS_WRITE: u32 = 0x00000040

Pass PROT_MAX(PROT_WRITE) or PROT_MPROTECT(PROT_WRITE) to mmap() on platforms that support it.

This flag allows to set a “maximum access” that the memory page can get during its lifetime. Use protect to change the access flags.

Note

This flag can only be used with alloc() and alloc_dual_mapping. However alloc_dual_mapping may automatically use this if AccessWrite is used.

pub const MMAP_MAX_ACCESS_EXECUTE: u32 = 0x00000080

Pass PROT_MAX(PROT_EXEC) or PROT_MPROTECT(PROT_EXEC) to mmap() on platforms that support it.

This flag allows to set a “maximum access” that the memory page can get during its lifetime. Use protect to change the access flags.

Note

This flag can only be used with alloc() and alloc_dual_mapping. However alloc_dual_mapping may automatically use this if AccessExecute is used.

pub const MMAP_MAX_ACCESS_RW: u32

pub const MMAP_MAX_ACCESS_RX: u32

pub const MMAP_MAX_ACCESS_RWX: u32

pub const MAP_SHARED: u32 = 0x00000100

Use MAP_SHARED when calling mmap().

Note

In some cases MAP_SHARED may be set automatically. For example, some dual mapping implementations must use MAP_SHARED instead of MAP_PRIVATE to ensure that the OS would not apply copy on write on RW page, which would cause RX page not having the updated content.

pub const MAPPING_PREFER_TMP: u32 = 0x80000000

Not an access flag, only used by alloc_dual_mapping() to override the default allocation strategy to always use a ‘tmp’ directory instead of “/dev/shm” (on POSIX platforms). Please note that this flag will be ignored if the operating system allows to allocate an executable memory by a different API than open() or shm_open(). For example on Linux memfd_create() is preferred and on BSDs shm_open(SHM_ANON, ...) is used if SHM_ANON is defined.

Note

This flag can only be used with alloc().

impl MemoryFlags

pub fn contains(self, other: u32) -> bool

Trait Implementations

impl BitAnd<u32> for MemoryFlags

type Output = MemoryFlags

The resulting type after applying the & operator.

fn bitand(self, rhs: u32) -> Self::Output

Performs the & operation.

impl BitAnd for MemoryFlags

type Output = MemoryFlags

The resulting type after applying the & operator.

fn bitand(self, rhs: Self) -> Self::Output

Performs the & operation.

impl BitAndAssign<u32> for MemoryFlags

fn bitand_assign(&mut self, rhs: u32)

Performs the &= operation.

impl BitAndAssign for MemoryFlags

fn bitand_assign(&mut self, rhs: Self)

Performs the &= operation.

impl BitOr<u32> for MemoryFlags

type Output = MemoryFlags

The resulting type after applying the | operator.

fn bitor(self, rhs: u32) -> Self::Output

Performs the | operation.

impl BitOr for MemoryFlags

type Output = MemoryFlags

The resulting type after applying the | operator.

fn bitor(self, rhs: Self) -> Self::Output

Performs the | operation.

impl BitOrAssign<u32> for MemoryFlags

fn bitor_assign(&mut self, rhs: u32)

Performs the |= operation.

impl BitOrAssign for MemoryFlags

fn bitor_assign(&mut self, rhs: Self)

Performs the |= operation.

impl Clone for MemoryFlags

fn clone(&self) -> MemoryFlags

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for MemoryFlags

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

Formats the value using the given formatter.

impl From<MemoryFlags> for u32

fn from(val: MemoryFlags) -> Self

Converts to this type from the input type.

impl From<u32> for MemoryFlags

fn from(value: u32) -> Self

Converts to this type from the input type.

impl Hash for MemoryFlags

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for MemoryFlags

fn cmp(&self, other: &MemoryFlags) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq<u32> for MemoryFlags

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialEq for MemoryFlags

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for MemoryFlags

fn partial_cmp(&self, other: &MemoryFlags) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Copy for MemoryFlags

impl Eq for MemoryFlags

impl StructuralPartialEq for MemoryFlags