Enum rust_cheri_compressed_cap::Cc128

pub enum Cc128 {}

[−] Expand description

Defines the CC128 capability profile as an implementation of the CompressedCapability trait.

Empty enum, so it cannot be itself constructed. If you want a CC128 capability, instantiate Cc128Cap.

Derives Debug, Copy, Clone so that CcxCap can derive them too.

Trait Implementations

impl Clone for Cc128

[+] Show hidden undocumented items

fn clone(&self) -> Cc128[−]

Returns a copy of the value.

pub fn clone_from(&mut self, source: &Self)[−]

Performs copy-assignment from source.

impl CompressedCapability for Cc128

[+] Show hidden undocumented items

type Length = u128

ccx_length_t Rust-land equivalent - should be a superset of Addr

type Offset = i128

ccx_offset_t Rust-land equivalent - should be a superset of Addr

type Addr = u64

ccx_addr_t equivalent

type FfiLength = u128

ccx_length_t C-land equivalent - should have a memory layout identical to the C ccx_length_t. This is separate from Length because for 128-bit types the Rust and C versions may not look the same. In practice, we just assume they are the same (see crate::c_funcs documentation).

type FfiOffset = i128

ccx_offset_t C-land equivalent - should have a memory layout identical to the C ccx_offset_t. See Self::FfiLength for an explanation.

const MAX_REPRESENTABLE_OTYPE: u32[−][−]

The OTYPE field is 18 bits (108:91) in CC128

const OTYPE_UNSEALED: u32[−][−]

CCX_OTYPE_UNSEALED equivalent

const OTYPE_SENTRY: u32

const OTYPE_RESERVED2: u32

const OTYPE_RESERVED3: u32

const MAX_UNRESERVED_OTYPE: u32

fn compress_raw(cap: &CcxCap<Cc128>) -> u64[−]

Generate the pesbt bits for a capability (the top bits, which encode permissions, object type, compressed bounds, etc.) This transformation can be undone with Self::decompress_raw.

fn decompress_raw(pesbt: u64, cursor: u64, tag: bool) -> CcxCap<Cc128>[−]

Decompress a (pesbt, cursor) pair into a capability. This transformation can be undone with Self::compress_raw.

fn compress_mem(cap: &CcxCap<Cc128>) -> u64[−]

Generate the pesbt bits for a capability (the top bits, which encode permissions, object type, compressed bounds, etc.) This transformation can be undone with Self::decompress_mem.

fn decompress_mem(pesbt: u64, cursor: u64, tag: bool) -> CcxCap<Cc128>[−]

Decompress a (pesbt, cursor) pair into a capability. This transformation can be undone with Self::compress_mem.

fn get_uperms(cap: &CcxCap<Cc128>) -> u32[−]

Gets the user/software-defined permissions from the CcxCap::cr_pesbt field

fn get_perms(cap: &CcxCap<Cc128>) -> u32[−]

Gets the hardware-defined permissions from the CcxCap::cr_pesbt field

fn get_otype(cap: &CcxCap<Cc128>) -> u32[−]

Gets the object type from the CcxCap::cr_pesbt field

fn get_reserved(cap: &CcxCap<Cc128>) -> u8[−]

Gets the reserved bits from the CcxCap::cr_pesbt field

fn get_flags(cap: &CcxCap<Cc128>) -> u8[−]

Gets the flags from the CcxCap::cr_pesbt field

fn update_uperms(cap: &mut CcxCap<Cc128>, value: u32)[−]

Updates the user/software-defined permissions field in CcxCap::cr_pesbt

fn update_perms(cap: &mut CcxCap<Cc128>, value: u32)[−]

Updates the hardware-defined permissions field in CcxCap::cr_pesbt

fn update_otype(cap: &mut CcxCap<Cc128>, value: u32)[−]

Updates the object type field in CcxCap::cr_pesbt

fn update_reserved(cap: &mut CcxCap<Cc128>, value: u8)[−]

Updates the reserved field in CcxCap::cr_pesbt

fn update_flags(cap: &mut CcxCap<Cc128>, value: u8)[−]

Updates the flags field in CcxCap::cr_pesbt

fn extract_bounds_bits(pesbt: Self::Addr) -> CcxBoundsBits[−]

Extracts the floating-point encoded bounds from CcxCap::cr_pesbt

fn set_bounds(
    cap: &mut CcxCap<Cc128>,
    req_base: Self::Addr,
    req_top: Self::Length
) -> bool[−]

Sets the capability bounds to bounds that encompass (req_base, req_top). Because a floating-point representation is used for bounds, it may not be able to set (req_base, req_top) exactly. In this case it will return False.

fn is_representable_cap_exact(cap: &CcxCap<Cc128>) -> bool[−]

Check if the range (CcxCap::cr_base, CcxCap::_cr_top) can be encoded exactly with the floating-point encoding

fn is_representable_new_addr(
    sealed: bool,
    base: Self::Addr,
    length: Self::Length,
    cursor: Self::Addr,
    new_cursor: Self::Addr
) -> bool[−]

Check if a capability with the parameters sealed, base, length, cursor would be representable if the cursor were updated to new_cursor.

fn make_max_perms_cap(
    base: Self::Addr,
    cursor: Self::Addr,
    top: Self::Length
) -> CcxCap<Cc128>[−]

Generate a capability for base, top, cursor with the maximum available permissions

fn get_representable_length(length: Self::Length) -> Self::Length[−]

Get the minimum representable length greater than or equal to length.

fn get_required_alignment(length: Self::Length) -> Self::Length[−]

Get the alignment required for bounds of some length to be exactly represented.

fn get_alignment_mask(length: Self::Length) -> Self::Length[−]

Get a mask which aligns a bounds of some length to be exactly representable.

const PERM_GLOBAL: u32[−][−]

CCX_PERM_GLOBAL equivalent These are the same for 64 and 128bit, but should be overridden for Morello-128

const PERM_EXECUTE: u32

const PERM_LOAD: u32

const PERM_STORE: u32

const PERM_LOAD_CAP: u32

const PERM_STORE_CAP: u32

const PERM_STORE_LOCAL: u32

const PERM_SEAL: u32

const PERM_CINVOKE: u32

const PERM_UNSEAL: u32

const PERM_ACCESS_SYS_REGS: u32

const PERM_SETCID: u32

impl Debug for Cc128

[+] Show hidden undocumented items

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

Formats the value using the given formatter.

impl Copy for Cc128