Trait sallyport::guest::call::enarxcall::Alloc

pub trait Alloc<'a> {
    type Argv: Into<[usize; 4]>;
    type Ret;
    type Staged: Commit<Item = Self::Committed>;
    type Committed;
    type Collected;

    const NUM: Number;

    fn stage(
        self,
        alloc: &mut impl Allocator
    ) -> Result<(Self::Argv, Self::Staged)>;
    fn collect(
        committed: Self::Committed,
        ret: Result<Self::Ret>,
        col: &impl Collector
    ) -> Self::Collected;
}

A generic Enarx call, which can be allocated within the block.

Required Associated Types

type Argv: Into<[usize; 4]>

The Enarx call argument vector.

For example, guest::call::types::Argv<2>.

type Ret

Enarx call return value.

For example, usize.

type Staged: Commit<Item = Self::Committed>

Opaque staged value, which returns Self::Committed when committed via Commit::commit.

This is designed to serve as a container for dynamic data allocated within stage.

For example, Input<'a, [u8], &'a [u8]>.

type Committed

Opaque committed value returned by guest::alloc::Commit::commit called upon Self::Staged, which returns Self::Collected when collected via guest::alloc::Collect::collect.

type Collected

Value Enarx call collects as, which corresponds to its return value.

For example, Option<Result<usize>>.

Required Associated Constants

const NUM: Number

Enarx call number.

For example, item::enarxcall::Number::Cpuid.

Required Methods

fn stage(self, alloc: &mut impl Allocator) -> Result<(Self::Argv, Self::Staged)>

Allocate dynamic data, if necessary and return resulting argument vector registers and opaque staged value on success.

fn collect(
    committed: Self::Committed,
    ret: Result<Self::Ret>,
    col: &impl Collector
) -> Self::Collected

Collect the return registers, opaque committed value and return a Self::Collected.

Implementors

impl<'a> Alloc<'a> for Cpuid<'a>

const NUM: Number = Number::Cpuid

type Argv = Argv<3>

type Ret = ()

type Staged = Output<'a, CpuidResult, &'a mut CpuidResult>

type Committed = <Cpuid<'a> as Alloc<'a>>::Staged

type Collected = Result<(), i32>

impl<'a> Alloc<'a> for GetSgxQuote<'a>

const NUM: Number = Number::GetSgxQuote

type Argv = Argv<3>

type Ret = usize

type Staged = StagedGetSgxQuote<'a>

type Committed = Output<'a, [u8], &'a mut [u8]>

type Collected = Option<Result<usize, i32>>

impl<'a> Alloc<'a> for GetSgxTargetInfo<'a>

const NUM: Number = Number::GetSgxTargetInfo

type Argv = Argv<1>

type Ret = ()

type Staged = Output<'a, [u8; 512], &'a mut [u8; 512]>

type Committed = <GetSgxTargetInfo<'a> as Alloc<'a>>::Staged

type Collected = Result<(), i32>

impl<'a> Alloc<'a> for GetSnpVcek<'a>

const NUM: Number = Number::GetSnpVcek

type Argv = Argv<2>

type Ret = usize

type Staged = Output<'a, [u8], &'a mut [u8]>

type Committed = <GetSnpVcek<'a> as Alloc<'a>>::Staged

type Collected = Option<Result<usize, i32>>

impl<'a, T: PassthroughAlloc> Alloc<'a> for T

const NUM: Number = T::NUM

type Argv = <T as PassthroughAlloc>::Argv

type Ret = <T as PassthroughAlloc>::Ret

type Staged = ()

type Committed = ()

type Collected = Result<<T as PassthroughAlloc>::Ret, i32>