Enum Access 

pub enum Access {
    Fd {
        slot: FdSlot,
        open_file: Option<OpenFileId>,
        op: FdOp,
    },
    OpenFile {
        open_file: OpenFileId,
        op: CursorOp,
    },
    FileContents {
        inode: DetInode,
        range: Option<ByteRange>,
        op: DataOp,
    },
    Channel {
        open_file: OpenFileId,
        id: Option<ChannelId>,
        channel: ChannelKind,
        op: ChannelOp,
    },
    Futex {
        futex: FutexID,
        op: FutexOp,
    },
    Memory {
        mm: MmId,
        range: ByteRange,
        op: MemoryOp,
    },
    Timer {
        timer: TimerId,
        op: TimerOp,
    },
    Lifetime {
        target: Task,
        op: LifetimeOp,
    },
}

One resource access of a syscall. Section 4 of the M5 design names the identities; Access::conflicts_with states which pairs conflict.

Variants

Fd

A descriptor number in one descriptor table.

Fields

slot: FdSlot

The table and the number.

open_file: Option<OpenFileId>

For use and close, the open file the number reached before the call; for open and dup, the open file it holds after. None when the number held nothing Detcore models.

op: FdOp

What the call did to the slot.

OpenFile

The cursor of an open file description, shared by dup and fork aliases.

Fields

open_file: OpenFileId

The open file description.

op: CursorOp

How the call used the cursor.

FileContents

File contents.

Fields

inode: DetInode

The file.

range: Option<ByteRange>

Bytes the call read or wrote; None when Detcore does not know the offset (a cursor-relative read or write).

op: DataOp

Read or write.

Channel

Data through a pipe, FIFO, socket or eventfd.

Fields

open_file: OpenFileId

The open file the call used.

id: Option<ChannelId>

An identity shared by both ends of the channel when Hermit knows both ends (a pipe, a socketpair, a FIFO by its inode); otherwise None, and the open file is the only identity. Sockets connected with connect and accept, inside the container or to a network peer outside it, are None in this version.

channel: ChannelKind

What kind of channel.

op: ChannelOp

Direction of the data, or a change of the end’s state.

Futex

A futex word.

Fields

futex: FutexID

The word’s key; process-shared futexes match across processes.

op: FutexOp

The futex operation on this word.

Memory

A range of one address space.

Fields

mm: MmId

The address space.

range: ByteRange

The bytes.

op: MemoryOp

What the call did to them.

Timer

A timer.

Fields

timer: TimerId

The timer.

op: TimerOp

What the call did to it.

Lifetime

A thread or process as a whole.

Fields

target: Task

The target.

op: LifetimeOp

What the call did to it.

Implementations

impl Access

pub fn conflicts_with(&self, other: &Access) -> bool

Whether two accesses touch the same resource in a way whose order can change a result. The two accesses are assumed to come from different threads; the caller checks that.

This is the per-resource rule of the design’s section 4, applied to syscall data alone. It is deliberately conservative where Detcore does not know an extent: an unknown file range overlaps any range.

Trait Implementations

impl Clone for Access

fn clone(&self) -> Access

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Access

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Access

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for Access

impl PartialEq for Access

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for Access

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Access