pub enum Op {
Show 37 variants
NewVmSpace,
DropVmSpace {
vs: VmSpaceId,
},
OpenCursor {
vs: VmSpaceId,
va: Range<Vaddr>,
},
OpenCursorMut {
vs: VmSpaceId,
va: Range<Vaddr>,
},
DropCursor {
c: CursorId,
},
Query {
c: CursorId,
},
FindNext {
c: CursorId,
len: usize,
},
Jump {
c: CursorId,
va: Vaddr,
},
VirtAddr {
c: CursorId,
},
Map {
c: CursorId,
fid: FrameId,
prop: PageProperty,
},
Unmap {
c: CursorId,
len: usize,
},
ProtectNext {
c: CursorId,
len: usize,
},
NewReader {
vs: VmSpaceId,
vaddr: Vaddr,
len: usize,
},
NewWriter {
vs: VmSpaceId,
vaddr: Vaddr,
len: usize,
},
NewKernelReader {
vaddr: Vaddr,
len: usize,
},
NewKernelWriter {
vaddr: Vaddr,
len: usize,
},
DropReader {
vio: VmIoId,
},
DropWriter {
vio: VmIoId,
},
ReaderReadVal {
source: VmIoId,
},
ReaderCollect {
source: VmIoId,
},
ReaderLimit {
vio: VmIoId,
max: usize,
},
ReaderSkip {
vio: VmIoId,
n: usize,
},
ReaderQuery {
vio: VmIoId,
},
WriterWriteVal {
writer: VmIoId,
},
WriterFillZeros {
vio: VmIoId,
len: usize,
},
WriterLimit {
vio: VmIoId,
max: usize,
},
WriterSkip {
vio: VmIoId,
n: usize,
},
WriterQuery {
vio: VmIoId,
},
Read {
source: VmIoId,
dest: VmIoId,
},
Write {
source: VmIoId,
dest: VmIoId,
},
FrameFromUnused {
paddr: Paddr,
},
FrameFromInUse {
paddr: Paddr,
},
FrameDrop {
fid: FrameId,
},
SegmentFromUnused {
range: Range<Paddr>,
},
SegmentDrop {
sid: SegmentId,
},
SegmentSplit {
sid: SegmentId,
offset: usize,
},
SegmentNext {
sid: SegmentId,
},
}Expand description
Public exec API of ostd::mm::vm_space and ostd::mm::io, lifted
to data.
Variants§
NewVmSpace
DropVmSpace
OpenCursor
OpenCursorMut
DropCursor
Query
FindNext
Jump
VirtAddr
Map
Unmap
ProtectNext
NewReader
NewWriter
NewKernelReader
NewKernelWriter
DropReader
DropWriter
ReaderReadVal
Fallible VmReader::read_val<T>. The exec spec carries no
tracked owner params (handle MODEL GAP); the embedding step
is consequently a no-op on VmStore.
ReaderCollect
Fallible VmReader::collect. Same shape as ReaderReadVal.
ReaderLimit
ReaderSkip
ReaderQuery
WriterWriteVal
Fallible VmWriter::write_val<T>. Same shape as ReaderReadVal.
WriterFillZeros
WriterLimit
WriterSkip
WriterQuery
Read
Infallible VmReader::read. Produces a consumed_w val_owner
(registered as a fresh activated Writer entry).
Write
Infallible VmWriter::write. The exec no longer surfaces
consumed_w; the embedding does NOT create a fresh entry.
FrameFromUnused
Frame::from_unused: try to allocate a fresh handle on a
previously-unused slot. Registers a FrameEntry on success.
FrameFromInUse
Frame::from_in_use: try to acquire a new handle on an
in-use slot. Registers a FrameEntry on success
(refcount of the slot increments by one).
FrameDrop
Drop one outstanding Frame handle. There is exactly one drop;
the step branches internally on the live refcount (mirroring
exec drop): >= 2 decrements (slot stays SHARED), == 1
tears down to UNUSED (requires the slot detached from the page
table — paths_in_pt.is_empty()). See frame::drop_pre.
SegmentFromUnused
Segment::from_unused: allocate a fresh segment over a range
of previously-unused slots. Each frame in range transitions
usage == Unused → Frame, rc 0 → 1, raw_count 0 → 1.
Registers a SegmentEntry on success.
SegmentDrop
Drop a Segment handle. Releases the segment’s forgotten
reference at each frame in the range; frames whose rc
reaches 1 transition to UNUSED.
SegmentSplit
Segment::split: split a segment at a page-aligned byte
offset from its start, producing two segments covering the
disjoint halves. regions is unchanged (per-paddr
cover_count is invariant — each covered paddr lands in
exactly one half). Removes sid from s.segments, inserts
two fresh SegmentEntrys.
SegmentNext
Segment::next: pop the front frame off sid’s range,
producing a fresh Frame<M> handle (a new FrameEntry
registered in s.frames). The segment’s range shrinks by one
page from the front; if it becomes empty, sid is removed
from s.segments. The conversion bridge between segment-held
forgotten references and user-held Frame handles: at the
popped paddr raw_count -= 1, cover_count -= 1, H += 1,
rc unchanged.