Enum MemoryObject 

pub enum MemoryObject {
    Vmo(Vmo),
    RingBuf(Vmo),
    MemoryMappedClock {
        koid: Koid,
        utc_clock: UtcClock,
    },
}

Variants

Vmo(Vmo)

RingBuf(Vmo)

The memory object is a bpf ring buffer. The layout it represents is: |Page1 - Page2 - Page3 .. PageN - Page3 .. PageN| where the vmo is |Page1 - Page2 - Page3 .. PageN|

MemoryMappedClock

A memory mapped clock is backed by kernel memory, not by a VMO. So it is handled specially. The lifecycle of this clock is:

• starts off as an empty unmapped thing.
• a MappedClock is created on map_in_vmar.
• a name is added on set_zx_name.
• most clone/resize operations return errors.
• unmapped at the end of the process lifetime.

Fields

koid: Koid

utc_clock: UtcClock

Implementations

impl MemoryObject

pub fn as_vmo(&self) -> Option<&Vmo>

pub fn is_clock(&self) -> bool

Returns true if this MemoryObject is a memory mapped clock.

pub fn into_vmo(self) -> Option<Vmo>

pub fn get_content_size(&self) -> u64

pub fn set_content_size(&self, size: u64) -> Result<(), Status>

pub fn get_size(&self) -> u64

pub fn set_size(&self, size: u64) -> Result<(), Status>

pub fn create_child( &self, option: VmoChildOptions, offset: u64, size: u64, ) -> Result<Self, Status>

pub fn duplicate_handle(&self, rights: Rights) -> Result<Self, Status>

pub fn read(&self, data: &mut [u8], offset: u64) -> Result<(), Status>

pub fn read_to_array<T: Copy + FromBytes, const N: usize>( &self, offset: u64, ) -> Result<[T; N], Status>

pub fn read_to_vec(&self, offset: u64, length: u64) -> Result<Vec<u8>, Status>

pub fn read_uninit<'a>( &self, data: &'a mut [MaybeUninit<u8>], offset: u64, ) -> Result<&'a mut [u8], Status>

pub unsafe fn read_raw( &self, buffer: *mut u8, buffer_length: usize, offset: u64, ) -> Result<(), Status>

Reads from the memory.

Safety

Callers must guarantee that the buffer is valid to write to.

Errors

Returns zx::Status::NOT_SUPPORTED where unsupported.

pub fn write(&self, data: &[u8], offset: u64) -> Result<(), Status>

Write to memory.

Errors

Returns zx::Status::NOT_SUPPORTED for read-only memory.

pub fn basic_info(&self) -> HandleBasicInfo

Returns the generic basic handle info.

pub fn get_koid(&self) -> Koid

Returns the koid of the underlying memory-like object.

Should be cheap to call frequently.

pub fn info(&self) -> Result<VmoInfo, Errno>

Returns zx::VmoInfo for a memory object that supports it.

Panics

Calling info on a MemoryObject that is not represented by a VMO will panic. To avoid this in code, call is_clock before attempting.

pub fn set_zx_name(&self, name: &[u8])

pub fn with_zx_name(self, name: &[u8]) -> Self

pub fn op_range(&self, op: VmoOp, offset: u64, size: u64) -> Result<(), Status>

pub fn replace_as_executable(self, vmex: &Resource) -> Result<Self, Status>

pub fn map_in_vmar( &self, vmar: &Vmar, vmar_offset: usize, memory_offset: u64, len: usize, flags: VmarFlags, ) -> Result<usize, Status>

pub fn memmove( &self, options: TransferDataOptions, dst_offset: u64, src_offset: u64, size: u64, ) -> Result<(), Status>

pub fn clone_memory( self: &Arc<Self>, rights: Rights, ) -> Result<Arc<Self>, Errno>

Trait Implementations

impl Debug for MemoryObject

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

Formats the value using the given formatter.

impl From<Clock<BootTimeline, UtcTimeline>> for MemoryObject

fn from(utc_clock: UtcClock) -> MemoryObject

Converts to this type from the input type.

impl From<Vmo> for MemoryObject

fn from(vmo: Vmo) -> Self

Converts to this type from the input type.

impl PartialEq for MemoryObject

fn eq(&self, other: &MemoryObject) -> 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 Eq for MemoryObject