Struct MmioRegion

pub struct MmioRegion<Impl, Owner = Impl> { /* private fields */ }

An MmioRegion provides a safe implementation of Mmio and MmioSplit on top of an UnsafeMmio implementation.

The safety constraints of UnsafeMmio require callers to ensure that stores are not performed concurrently with loads for any overlapping range.

This type meets these requirements while supporting being split into independently owned due to the following:

1. An MmioRegion has exclusive ownership of a sub-region from the wrapped UnsafeMmio implementation (required by MmioRegion::new).
2. An MmioRegion only performs operations that are fully contained within the region it owns.
3. All stores are performed through a mutable reference (ensuring stores are exclusive with all other operations to the owned region).
4. When splitting off MmioRegions, the split_off region owns a range that was owned by region it was split off from prior to the split, and that it has exclusive ownership of after the split.

Type Parameters

An MmioRegion is parameterized by two types:

• Impl: the UnsafeMmio implementation wrapped by this region.
• Owner: an object with shared ownership of the Impl instance.

An MmioRegion is splittable if Owner can be cloned.

Implementations

impl<U: UnsafeMmio> MmioRegion<U>

pub fn new(inner: U) -> Self

Create a new MmioRegion that has exclusive ownership of the entire range.

The returned object is guaranteed to be the only one capable of referencing any value in the range. It can be converted into one that can be split

pub fn into_split(self) -> MmioRegion<U, Rc<U>>

Converts this region into one which can be split.

impl<U: UnsafeMmio + Send + Sync> MmioRegion<U>

pub fn into_split_send(self) -> MmioRegion<U, Arc<U>>

Converts this region into one which can be split and sent.

Trait Implementations

impl<Impl: UnsafeMmio, Owner: Borrow<Impl>> Mmio for MmioRegion<Impl, Owner>

fn len(&self) -> usize

Returns the size in bytes of this MMIO region.

fn align_offset(&self, align: usize) -> usize

Computes the first offset within this region that is aligned to align.

fn try_load8(&self, offset: usize) -> Result<u8, MmioError>

Loads one byte from this MMIO region at the given offset.

fn try_load16(&self, offset: usize) -> Result<u16, MmioError>

Loads two bytes from this MMIO region at the given offset.

fn try_load32(&self, offset: usize) -> Result<u32, MmioError>

Loads four bytes from this MMIO region at the given offset.

fn try_load64(&self, offset: usize) -> Result<u64, MmioError>

Loads eight bytes from this MMIO region at the given offset.

fn try_store8(&mut self, offset: usize, v: u8) -> Result<(), MmioError>

Stores one byte to this MMIO region at the given offset.

fn try_store16(&mut self, offset: usize, v: u16) -> Result<(), MmioError>

Stores two bytes to this MMIO region at the given offset.

fn try_store32(&mut self, offset: usize, v: u32) -> Result<(), MmioError>

Stores four bytes to this MMIO region at the given offset.

fn try_store64(&mut self, offset: usize, v: u64) -> Result<(), MmioError>

Stores eight bytes to this MMIO region at the given offset.

fn load8(&self, offset: usize) -> u8

Loads one byte from this MMIO region at the given offset.

fn load16(&self, offset: usize) -> u16

Loads two bytes from this MMIO region at the given offset.

fn load32(&self, offset: usize) -> u32

Loads four bytes from this MMIO region at the given offset.

fn load64(&self, offset: usize) -> u64

Loads eight bytes from this MMIO region at the given offset.

fn store8(&mut self, offset: usize, value: u8)

Stores one byte to this MMIO region at the given offset.

fn store16(&mut self, offset: usize, value: u16)

Stores two bytes to this MMIO region at the given offset.

fn store32(&mut self, offset: usize, value: u32)

Stores four bytes to this MMIO region at the given offset.

fn store64(&mut self, offset: usize, value: u64)

Stores eight bytes to this MMIO region at the given offset.

impl<Impl: UnsafeMmio, Owner: Borrow<Impl> + Clone> MmioSplit for MmioRegion<Impl, Owner>

fn try_split_off(&mut self, mid: usize) -> Result<Self, MmioError>

Splits this Mmio region into two at the given mid-point and returns the left-hand-side. This MMIO region’s bounds are updated to contain only the right-hand-side.

fn split_off(&mut self, mid: usize) -> Self

Splits this MMIO region into two at the given mid-point and returns the left-hand-side. This MMIO region’s bounds are updated to contain only the right-hand-side.