Struct Executor 

pub struct Executor<B, C> { /* private fields */ }

Read-path and sequence executor shared by all sessions. Each call takes the calling session’s validated AccessPolicy.

Implementations

impl<B: ResourceBackend, C: Clock> Executor<B, C>

pub fn new( backends: BTreeMap<ResourceId, B>, clock: C, limits: ExecLimits, ) -> Self

Creates an executor over the instance’s backends.

pub fn limits(&self) -> ExecLimits

The execution limits, for capability reporting.

pub fn backend(&self, resource: ResourceId) -> Option<&B>

The backend for resource, for diagnostics and tests.

pub fn poll_read_once( &mut self, resource: ResourceId, offset: u64, ) -> Result<u32, BackendError>

Reads a register once directly from the backend without policy or audit.

pub fn barrier(&mut self)

Invokes hardware MMIO barriers across all backends.

pub fn read32( &mut self, policy: &AccessPolicy, audit: &mut AuditRing, session: u64, resource: ResourceId, offset: u64, ) -> Result<ReadOutcome, ReadError>

Performs one policy-checked, audited 32-bit read.

pub fn read32_internal( &mut self, policy: &AccessPolicy, audit: &mut AuditRing, session: u64, resource: ResourceId, offset: u64, item_index: Option<u32>, ) -> Result<ReadOutcome, ReadError>

Internal 32-bit read implementation supporting sequence item indexing.

pub fn write32( &mut self, policy: &AccessPolicy, audit: &mut AuditRing, session: u64, resource: ResourceId, offset: u64, value: u32, write_mask: u32, precondition: Option<WritePrecondition>, readback: bool, ) -> Result<WriteOutcome, WriteError>

Performs one policy-checked, audited 32-bit masked write.

pub fn write32_internal( &mut self, policy: &AccessPolicy, audit: &mut AuditRing, session: u64, resource: ResourceId, offset: u64, value: u32, write_mask: u32, precondition: Option<WritePrecondition>, readback: bool, item_index: Option<u32>, ) -> Result<WriteOutcome, WriteError>

Internal 32-bit write implementation supporting sequence item indexing.

pub fn poll32_read_step( &mut self, audit: &mut AuditRing, session: u64, resource: ResourceId, offset: u64, expected: u32, mask: u32, item_index: Option<u32>, ) -> Result<Result<PollOutcome, u32>, PollError>

Evaluates one polling read step against expected value and mask.

pub fn poll32_timeout( &mut self, audit: &mut AuditRing, session: u64, resource: ResourceId, offset: u64, last_val: Option<u32>, item_index: Option<u32>, ) -> PollError

Records an audit rejection when polling times out.

pub fn prevalidate_sequence( &self, policy: &AccessPolicy, items: &[SequenceItem], ) -> Result<(), (usize, Denial)>

Validates whole sequence before any hardware execution.

pub fn snapshot( &mut self, policy: &AccessPolicy, audit: &mut AuditRing, session: u64, items: &[SnapshotItem], ) -> Result<SnapshotOutcome, SnapshotError>

Performs a bounded snapshot: every item is validated before the first read, then items execute in order, stopping at the first backend failure.

pub fn gpio_read( &mut self, policy: &AccessPolicy, audit: &mut AuditRing, session: u64, resource: ResourceId, ) -> Result<GpioReadOutcome, GpioReadError>

Performs one policy-checked, audited GPIO read.

pub fn gpio_read_internal( &mut self, policy: &AccessPolicy, audit: &mut AuditRing, session: u64, resource: ResourceId, item_index: Option<u32>, ) -> Result<GpioReadOutcome, GpioReadError>

Internal GPIO read implementation supporting sequence item indexing.

pub fn gpio_write( &mut self, policy: &AccessPolicy, audit: &mut AuditRing, session: u64, resource: ResourceId, value: bool, ) -> Result<GpioWriteOutcome, GpioWriteError>

Performs one policy-checked, audited GPIO write.

pub fn gpio_write_internal( &mut self, policy: &AccessPolicy, audit: &mut AuditRing, session: u64, resource: ResourceId, value: bool, item_index: Option<u32>, ) -> Result<GpioWriteOutcome, GpioWriteError>

Internal GPIO write implementation supporting sequence item indexing.

pub fn i2c_transfer( &mut self, policy: &AccessPolicy, audit: &mut AuditRing, session: u64, resource: ResourceId, write_data: &[u8], read_length: u32, ) -> Result<I2cTransferOutcome, I2cTransferError>

Performs one policy-checked, audited I2C transfer.

pub fn i2c_transfer_internal( &mut self, policy: &AccessPolicy, audit: &mut AuditRing, session: u64, resource: ResourceId, write_data: &[u8], read_length: u32, item_index: Option<u32>, ) -> Result<I2cTransferOutcome, I2cTransferError>

Internal I2C transfer implementation supporting sequence item indexing.

pub fn spi_transmit( &mut self, policy: &AccessPolicy, audit: &mut AuditRing, session: u64, resource: ResourceId, tx_data: &[u8], ) -> Result<SpiTransmitOutcome, SpiTransmitError>

Performs one policy-checked, audited SPI transmit.

pub fn spi_transmit_internal( &mut self, policy: &AccessPolicy, audit: &mut AuditRing, session: u64, resource: ResourceId, tx_data: &[u8], item_index: Option<u32>, ) -> Result<SpiTransmitOutcome, SpiTransmitError>

Internal SPI transmit implementation supporting sequence item indexing.

pub fn clock_enable( &mut self, policy: &AccessPolicy, audit: &mut AuditRing, session: u64, resource: ResourceId, ) -> Result<ClockEnableOutcome, ClockOpError>

pub fn clock_disable( &mut self, policy: &AccessPolicy, audit: &mut AuditRing, session: u64, resource: ResourceId, ) -> Result<ClockDisableOutcome, ClockOpError>

pub fn clock_is_enabled( &mut self, policy: &AccessPolicy, audit: &mut AuditRing, session: u64, resource: ResourceId, ) -> Result<ClockIsEnabledOutcome, ClockOpError>

pub fn clock_set_rate( &mut self, policy: &AccessPolicy, audit: &mut AuditRing, session: u64, resource: ResourceId, hz: u64, ) -> Result<ClockSetRateOutcome, ClockOpError>

pub fn clock_query_rate( &mut self, policy: &AccessPolicy, audit: &mut AuditRing, session: u64, resource: ResourceId, hz_in: u64, ) -> Result<ClockQueryRateOutcome, ClockOpError>

pub fn clock_get_rate( &mut self, policy: &AccessPolicy, audit: &mut AuditRing, session: u64, resource: ResourceId, ) -> Result<ClockGetRateOutcome, ClockOpError>

pub fn reset_assert( &mut self, policy: &AccessPolicy, audit: &mut AuditRing, session: u64, resource: ResourceId, ) -> Result<ResetAssertOutcome, ResetOpError>

pub fn reset_deassert( &mut self, policy: &AccessPolicy, audit: &mut AuditRing, session: u64, resource: ResourceId, ) -> Result<ResetDeassertOutcome, ResetOpError>

pub fn reset_toggle( &mut self, policy: &AccessPolicy, audit: &mut AuditRing, session: u64, resource: ResourceId, ) -> Result<ResetToggleOutcome, ResetOpError>

pub fn reset_status( &mut self, policy: &AccessPolicy, audit: &mut AuditRing, session: u64, resource: ResourceId, ) -> Result<ResetStatusOutcome, ResetOpError>

pub fn serial_read( &mut self, policy: &AccessPolicy, audit: &mut AuditRing, session: u64, resource: ResourceId, ) -> Result<SerialReadOutcome, SerialOpError>

pub fn serial_write( &mut self, policy: &AccessPolicy, audit: &mut AuditRing, session: u64, resource: ResourceId, data: &[u8], ) -> Result<SerialWriteOutcome, SerialOpError>

impl<B: ResourceBackend, C: Timer> Executor<B, C>

pub async fn poll32_with_abort( &mut self, policy: &AccessPolicy, audit: &mut AuditRing, session: u64, resource: ResourceId, offset: u64, expected: u32, mask: u32, interval_ns: i64, timeout_ns: i64, abort: Option<&AtomicBool>, ) -> Result<PollOutcome, PollError>

Performs an asynchronous 32-bit poll with an optional abort token.

pub async fn poll32( &mut self, policy: &AccessPolicy, audit: &mut AuditRing, session: u64, resource: ResourceId, offset: u64, expected: u32, mask: u32, interval_ns: i64, timeout_ns: i64, ) -> Result<PollOutcome, PollError>

Performs an asynchronous 32-bit poll.

pub async fn poll32_internal( &mut self, policy: &AccessPolicy, audit: &mut AuditRing, session: u64, resource: ResourceId, offset: u64, expected: u32, mask: u32, interval_ns: i64, timeout_ns: i64, item_index: Option<u32>, abort: Option<&AtomicBool>, ) -> Result<PollOutcome, PollError>

Internal 32-bit poll implementation supporting sequence item indexing.

pub async fn execute_sequence( &mut self, policy: &AccessPolicy, audit: &mut AuditRing, session: u64, items: &[SequenceItem], ) -> Result<SequenceOutcome, SequenceError>

Executes a bounded ordered sequence.

pub async fn execute_sequence_with_abort( &mut self, policy: &AccessPolicy, audit: &mut AuditRing, session: u64, items: &[SequenceItem], abort: Option<&AtomicBool>, ) -> Result<SequenceOutcome, SequenceError>

Executes a bounded ordered sequence with an optional abort token.

Trait Implementations

impl<B: Debug, C: Debug> Debug for Executor<B, C>

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

Formats the value using the given formatter.