Struct SecureHeapProperties

pub struct SecureHeapProperties {
    pub heap: Option<Heap>,
    pub dynamic_protection_ranges: Option<bool>,
    pub protected_range_granularity: Option<u32>,
    pub max_protected_range_count: Option<u64>,
    pub is_mod_protected_range_available: Option<bool>,
    /* private fields */
}

Fields

heap: Option<Heap>

The Heap is repeated here for convenience.

dynamic_protection_ranges: Option<bool>

If true, more than one call to SetPhysicalSecureHeap() for the same heap is allowed. If false, only one SetPhyscialSecureHeap() call is allowed, and no calls to DeleteSecureHeapPhysicalRange() or ModifySecureHeapPhysicalRange() are allowed. Even when this is false, the SecureMem server (driver) is still responsible for de-protecting just before warm reboot if protected ranges would not otherwise be cleaned up during a warm reboot.

protected_range_granularity: Option<u32>

The granularity of protection ranges. If the granularity of start is different than granularity of end or length, then this is the max granularity value among those values.

This must be a power of 2. The client must not request ranges that specify smaller granularity.

This must be at least zx_system_page_size() even if the HW can do smaller granularity.

max_protected_range_count: Option<u64>

The SecureMem server should not count reserved ranges that the SecureMem server uses internally to get from range set A to range set B, if the SecureMem server needs to do any emulation of that sort. Normally such emulation by the SecureMem server is unnecessary. If any ranges are reserved by the SecureMem server, those reserved ranges are not available for use by the SecureMem client.

If the number of ranges is limited only by available memory, it’s ok for the SecureMem server to report 0xFFFFFFFFFFFFFFFF for this value. The field must still be set. As usual, the SecureMem server should ensure that SetPhysicalSecureHeapRanges() succeeds or fails atomically (either fully updates or rolls back before completing).

is_mod_protected_range_available: Option<bool>

Iff true, ModifySecureHeapPhysicalRange() is implemented. Calling ModifySecureHeapPhysicalRange() when is_mod_protected_range_available is false is prohibited. Don’t attempt to detect availability of ModifySecureHeapPhysicalRange() by calling it to see if it fails; it may ZX_PANIC().

Trait Implementations

impl Clone for SecureHeapProperties

fn clone(&self) -> SecureHeapProperties

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for SecureHeapProperties

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

Formats the value using the given formatter.

impl<D> Decode<SecureHeapProperties, D> for SecureHeapProperties

where D: ResourceDialect,

fn new_empty() -> SecureHeapProperties

Creates a valid instance of Self. The specific value does not matter, since it will be overwritten by decode.

unsafe fn decode( &mut self, decoder: &mut Decoder<'_, D>, offset: usize, depth: Depth, ) -> Result<(), Error>

Decodes an object of type T from the decoder’s buffers into self.

impl Default for SecureHeapProperties

fn default() -> SecureHeapProperties

Returns the “default value” for a type.

impl<D> Encode<SecureHeapProperties, D> for &SecureHeapProperties

where D: ResourceDialect,

unsafe fn encode( self, encoder: &mut Encoder<'_, D>, offset: usize, depth: Depth, ) -> Result<(), Error>

Encodes the object into the encoder’s buffers. Any handles stored in the object are swapped for Handle::INVALID.

impl PartialEq for SecureHeapProperties

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

type Owned = SecureHeapProperties

The owned Rust type which this FIDL type decodes into.

fn inline_align(_context: Context) -> usize

Returns the minimum required alignment of the inline portion of the encoded object. It must be a (nonzero) power of two.

fn inline_size(_context: Context) -> usize

Returns the size of the inline portion of the encoded object, including padding for alignment. Must be a multiple of inline_align.

fn encode_is_copy() -> bool

Returns true if the memory layout of Self::Owned matches the FIDL wire format and encoding requires no validation. When true, we can optimize encoding arrays and vectors of Self::Owned to a single memcpy.

fn decode_is_copy() -> bool

Returns true if the memory layout of Self::Owned matches the FIDL wire format and decoding requires no validation. When true, we can optimize decoding arrays and vectors of Self::Owned to a single memcpy.

impl ValueTypeMarker for SecureHeapProperties

type Borrowed<'a> = &'a SecureHeapProperties

The Rust type to use for encoding. This is a particular Encode<Self> type cheaply obtainable from &Self::Owned. There are three cases:

fn borrow( value: &<SecureHeapProperties as TypeMarker>::Owned, ) -> <SecureHeapProperties as ValueTypeMarker>::Borrowed<'_>

Cheaply converts from &Self::Owned to Self::Borrowed.

impl Persistable for SecureHeapProperties

impl StructuralPartialEq for SecureHeapProperties