Struct xous::definitions::messages::MemoryMessage

#[repr(C)]
pub struct MemoryMessage {
    pub id: MessageId,
    pub buf: MemoryRange,
    pub offset: Option<MemoryAddress>,
    pub valid: Option<MemorySize>,
}

A struct describing memory that is passed between processes. The buf value will get translated as necessary.

Fields

id: MessageId

A user-assignable message ID.

buf: MemoryRange

The offset of the buffer. This address will get transformed when the message is moved between processes.

offset: Option<MemoryAddress>

The offset within the buffer where the interesting stuff starts. The usage of this field is purely advisory, is not checked by the kernel, should not be trusted by the receiver. It is perfectly legal for this to be larger than the buffer size.

As a result, this field may be repurposed for other uses. For example, you can store a usize in this field by setting message.offset = MemoryAddress::new(val), and get a usize back by reading message.offset.map(|v| v.get()).unwrap_or_default().

For MutableBorrow messages this value will be returned to the sender and the field will be updated when the Message is returned. Therefore you may also use this field to communicate additional information to the message sender.

valid: Option<MemorySize>

How many bytes in the buffer are valid. This field is advisory, and is not checked by the kernel. It is legal for the sender to specify a valid range that is larger than buf.len(), so this value should not be blindly trusted.

As a result, this field may be repurposed for other uses. For example, you can store a usize in this field by setting message.valid = MemoryAddress::new(val), and get a usize back by reading message.valid.map(|v| v.get()).unwrap_or_default().

For MutableBorrow messages this value will be returned to the sender and the field will be updated when the Message is returned. Therefore you may also use this field to communicate additional information to the message sender.

Implementations

impl MemoryMessage

pub fn from_usize(
    id: usize,
    addr: usize,
    size: usize,
    offset: usize,
    valid: usize
) -> Option<MemoryMessage>

pub fn to_usize(&self) -> [usize; 5]

Trait Implementations

impl Debug for MemoryMessage

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

Formats the value using the given formatter.

impl PartialEq<MemoryMessage> for MemoryMessage

fn eq(&self, other: &MemoryMessage) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for MemoryMessage