Struct Forward

pub struct Forward;

Forwards SBI calls onto current supervisor environment.

If crate feature forward is enabled, this structure implements all RustSBI extensions by forwarding the calls into the current supervisor environment. This is done by sbi-rt crate; thus Forward is only available when it’s running in RISC-V SBI environments.

Forward implements all RustSBI traits, but is only effective if #[cfg(feature = "forward")] is enabled. Otherwise, struct Forward is unimplemented!() on SBI calls.

Examples

This structure can be used as a structure field in #[derive(RustSBI)], with helper macro #[rustsbi(extension_1, extension_2, ...)] annotating what extensions should be forwarded to sbi-rt in the structure.

use rustsbi::{Forward, RustSBI};

// Forwards fence, timer and console extensions, but the hsm extension
// is still handled by the `hsm` field variable.
#[derive(RustSBI)]
struct VmSBI {
    hsm: VmHsm,
    #[rustsbi(fence, timer, console, info)]
    forward: Forward,
}

Trait Implementations

impl Clone for Forward

fn clone(&self) -> Forward

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Console for Forward

fn write(&self, bytes: Physical<&[u8]>) -> SbiRet

Write bytes to the debug console from input memory.

fn read(&self, bytes: Physical<&mut [u8]>) -> SbiRet

Read bytes from the debug console into an output memory.

fn write_byte(&self, byte: u8) -> SbiRet

Write a single byte to the debug console.

impl Cppc for Forward

fn probe(&self, reg_id: u32) -> SbiRet

Probe whether the CPPC register as specified by the reg_id parameter is implemented or not by the platform.

fn read(&self, reg_id: u32) -> SbiRet

Reads the register as specified in the reg_id parameter.

fn read_hi(&self, reg_id: u32) -> SbiRet

Reads the upper 32-bit value of the register specified in the reg_id parameter.

fn write(&self, reg_id: u32, val: u64) -> SbiRet

Writes the value passed in the val parameter to the register as specified in the reg_id parameter.

impl Debug for Forward

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

Formats the value using the given formatter.

impl EnvInfo for Forward

fn mvendorid(&self) -> usize

Vendor ID for the supervisor environment.

fn marchid(&self) -> usize

Architecture ID for the supervisor environment.

fn mimpid(&self) -> usize

Implementation ID for the supervisor environment.

impl Hsm for Forward

fn hart_start(&self, hartid: usize, start_addr: usize, opaque: usize) -> SbiRet

Request the SBI implementation to start executing the given hart at specified address in supervisor-mode.

fn hart_stop(&self) -> SbiRet

Request the SBI implementation to stop executing the calling hart in supervisor-mode and return its ownership to the SBI implementation.

fn hart_get_status(&self, hartid: usize) -> SbiRet

Get the current status (or HSM state id) of the given hart.

fn hart_suspend( &self, suspend_type: u32, resume_addr: usize, opaque: usize, ) -> SbiRet

Request the SBI implementation to put the calling hart in a platform specific suspend (or low-power) state specified by the suspend_type parameter.

impl Ipi for Forward

fn send_ipi(&self, hart_mask: HartMask) -> SbiRet

Send an inter-processor interrupt to all the harts defined in hart_mask.

impl Nacl for Forward

fn probe_feature(&self, feature_id: u32) -> SbiRet

Probe nested acceleration feature.

fn set_shmem(&self, shmem: SharedPtr<[u8; 8192]>, flags: usize) -> SbiRet

Set nested acceleration shared memory.

fn sync_csr(&self, csr_num: usize) -> SbiRet

Synchronize shared memory CSRs.

fn sync_hfence(&self, entry_index: usize) -> SbiRet

Synchronize shared memory HFENCEs.

fn sync_sret(&self) -> SbiRet

Synchronize shared memory and emulate SRET.

impl Pmu for Forward

fn num_counters(&self) -> usize

Returns the number of counters (both hardware and firmware).

fn counter_get_info(&self, counter_idx: usize) -> SbiRet

Get details about the specified counter such as underlying CSR number, width of the counter, type of counter (hardware/firmware, etc.).

fn counter_config_matching( &self, counter_idx_base: usize, counter_idx_mask: usize, config_flags: usize, event_idx: usize, event_data: u64, ) -> SbiRet

Find and configure a counter from a set of counters which is not started (or enabled) and can monitor the specified event.

fn counter_start( &self, counter_idx_base: usize, counter_idx_mask: usize, start_flags: usize, initial_value: u64, ) -> SbiRet

Start or enable a set of counters on the calling HART with the specified initial value.

fn counter_stop( &self, counter_idx_base: usize, counter_idx_mask: usize, stop_flags: usize, ) -> SbiRet

Stop or disable a set of counters on the calling HART.

fn counter_fw_read(&self, counter_idx: usize) -> SbiRet

Provide the current value of a firmware counter in SbiRet.value.

fn counter_fw_read_hi(&self, counter_idx: usize) -> SbiRet

Provide the upper 32 bits from the current value of firmware counter in SbiRet.value.

impl Reset for Forward

fn system_reset(&self, reset_type: u32, reset_reason: u32) -> SbiRet

Reset the system based on provided reset_type and reset_reason.

impl Rfence for Forward

fn remote_fence_i(&self, hart_mask: HartMask) -> SbiRet

Instructs remote harts to execute FENCE.I instruction.

fn remote_sfence_vma( &self, hart_mask: HartMask, start_addr: usize, size: usize, ) -> SbiRet

Instructs the remote harts to execute one or more SFENCE.VMA instructions, covering the range of virtual addresses between start_addr and size.

fn remote_sfence_vma_asid( &self, hart_mask: HartMask, start_addr: usize, size: usize, asid: usize, ) -> SbiRet

Instruct the remote harts to execute one or more SFENCE.VMA instructions, covering the range of virtual addresses between start_addr and size. This covers only the given address space by asid.

fn remote_hfence_gvma_vmid( &self, hart_mask: HartMask, start_addr: usize, size: usize, vmid: usize, ) -> SbiRet

Instruct the remote harts to execute one or more HFENCE.GVMA instructions, covering the range of guest physical addresses between start_addr and size only for the given virtual machine by vmid.

fn remote_hfence_gvma( &self, hart_mask: HartMask, start_addr: usize, size: usize, ) -> SbiRet

Instruct the remote harts to execute one or more HFENCE.GVMA instructions, covering the range of guest physical addresses between start_addr and size for all the guests.

fn remote_hfence_vvma_asid( &self, hart_mask: HartMask, start_addr: usize, size: usize, asid: usize, ) -> SbiRet

Instruct the remote harts to execute one or more HFENCE.VVMA instructions, covering the range of guest virtual addresses between start_addr and size for the given address space by asid and current virtual machine (by vmid in hgatp CSR) of calling hart.

fn remote_hfence_vvma( &self, hart_mask: HartMask, start_addr: usize, size: usize, ) -> SbiRet

Instruct the remote harts to execute one or more HFENCE.VVMA instructions, covering the range of guest virtual addresses between start_addr and size for current virtual machine (by vmid in hgatp CSR) of calling hart.

impl Sta for Forward

fn set_shmem(&self, shmem: SharedPtr<[u8; 64]>, flags: usize) -> SbiRet

Set Steal-time Shared Memory Address.

impl Susp for Forward

fn system_suspend( &self, sleep_type: u32, resume_addr: usize, opaque: usize, ) -> SbiRet

Request the SBI implementation to put the system transitions to a sleep state.

impl Timer for Forward

fn set_timer(&self, stime_value: u64)

Programs the clock for the next event after stime_value time.