Struct CursorMut

pub struct CursorMut<'a> { /* private fields */ }

The cursor for modifying the mappings in VM space.

It exclusively owns a sub-tree of the page table, preventing others from reading or modifying the same sub-tree.

Implementations

impl<'a> CursorMut<'a>

pub fn query(&mut self) -> Result<(Range<Vaddr>, Option<VmQueriedItem>)>

Queries the mapping at the current virtual address.

This is the same as Cursor::query.

If the cursor is pointing to a valid virtual address that is locked, it will return the virtual address range and the mapped item.

pub fn find_next(&mut self, len: usize) -> Option<Vaddr>

Moves the cursor forward to the next mapped virtual address.

This is the same as Cursor::find_next.

pub fn jump(&mut self, va: Vaddr) -> Result<()>

Jump to the virtual address.

This is the same as Cursor::jump.

pub fn virt_addr(&self) -> Vaddr

Get the virtual address of the current slot.

pub fn flusher(&mut self) -> &mut TlbFlusher<'a, DisabledPreemptGuard>

Get the dedicated TLB flusher for this cursor.

pub fn map(&mut self, frame: UFrame, prop: PageProperty)

Maps a frame into the current slot.

This method will bring the cursor to the next slot after the modification.

pub fn map_iomem( &mut self, io_mem: IoMem, prop: PageProperty, len: usize, offset: usize, )

Maps a range of IoMem into the current slot.

The memory region to be mapped is the IoMem range starting at offset and extending to offset + len, or to the end of IoMem, whichever comes first. This method will bring the cursor to the next slot after the modification.

Limitations

Once an instance of IoMem is mapped to a VmSpace, then the IoMem instance will only be dropped when the VmSpace is dropped, not when all the mappings backed by the IoMem are destroyed with the unmap method.

Panics

Panics if len or offset is not aligned to the page size.

pub fn find_iomem_by_paddr(&self, paddr: Paddr) -> Option<(IoMem, usize)>

Finds an IoMem that was previously mapped to by Self::map_iomem and contains the physical address.

This method can recover the originally mapped IoMem from the physical address returned by Self::query. If the query returns a VmQueriedItem::MappedIoMem, this method is guaranteed to succeed with the specific physical address. However, if the corresponding mapping is subsequently unmapped, it is unspecified whether this method will still succeed or not.

On success, this method returns the IoMem and the offset from the IoMem start to the given physical address. Otherwise, this method returns None.

pub fn unmap(&mut self, len: usize) -> usize

Clears the mapping starting from the current slot, and returns the number of unmapped pages.

This method will bring the cursor forward by len bytes in the virtual address space after the modification.

Already-absent mappings encountered by the cursor will be skipped. It is valid to unmap a range that is not mapped.

It must issue and dispatch a TLB flush after the operation. Otherwise, the memory safety will be compromised. Please call this function less to avoid the overhead of TLB flush. Using a large len is wiser than splitting the operation into multiple small ones.

Panics

Panics if:

• the length is longer than the remaining range of the cursor;
• the length is not page-aligned.

pub fn protect_next( &mut self, len: usize, op: impl FnMut(&mut PageFlags, &mut CachePolicy), ) -> Option<Range<Vaddr>>

Applies the operation to the next slot of mapping within the range.

The range to be found in is the current virtual address with the provided length.

The function stops and yields the actually protected range if it has actually protected a page, no matter if the following pages are also required to be protected.

It also makes the cursor moves forward to the next page after the protected one. If no mapped pages exist in the following range, the cursor will stop at the end of the range and return [None].

Note that it will NOT flush the TLB after the operation. Please make the decision yourself on when and how to flush the TLB using Self::flusher.

Panics

Panics if the length is longer than the remaining range of the cursor.