Refactor VmReader&VmWriter as given fallibility marker

kernel/aster-nix/src/context.rs

@@ -5,7 +5,7 @@
 use core::mem;
 
 use ostd::{
-    mm::{UserSpace, VmReader, VmSpace, VmWriter},
+    mm::{Fallible, Infallible, VmReader, VmSpace, VmWriter},
     task::Task,
 };
 
@@ -56,14 +56,14 @@ impl CurrentUserSpace {
     /// Creates a reader to read data from the user space of the current task.
     ///
     /// Returns `Err` if the `vaddr` and `len` do not represent a user space memory range.
-    pub fn reader(&self, vaddr: Vaddr, len: usize) -> Result<VmReader<'_, UserSpace>> {
+    pub fn reader(&self, vaddr: Vaddr, len: usize) -> Result<VmReader<'_, Fallible>> {
         Ok(self.0.reader(vaddr, len)?)
     }
 
     /// Creates a writer to write data into the user space.
     ///
     /// Returns `Err` if the `vaddr` and `len` do not represent a user space memory range.
-    pub fn writer(&self, vaddr: Vaddr, len: usize) -> Result<VmWriter<'_, UserSpace>> {
+    pub fn writer(&self, vaddr: Vaddr, len: usize) -> Result<VmWriter<'_, Fallible>> {
         Ok(self.0.writer(vaddr, len)?)
     }
 
@@ -76,7 +76,7 @@ impl CurrentUserSpace {
     /// If the destination `VmWriter` (`dest`) is empty, this function still
     /// checks if the current task and user space are available. If they are,
     /// it returns `Ok`.
-    pub fn read_bytes(&self, src: Vaddr, dest: &mut VmWriter<'_>) -> Result<()> {
+    pub fn read_bytes(&self, src: Vaddr, dest: &mut VmWriter<'_, Infallible>) -> Result<()> {
         let copy_len = dest.avail();
 
         if copy_len > 0 {
@@ -107,7 +107,7 @@ impl CurrentUserSpace {
     /// If the source `VmReader` (`src`) is empty, this function still checks if
     /// the current task and user space are available. If they are, it returns
     /// `Ok`.
-    pub fn write_bytes(&self, dest: Vaddr, src: &mut VmReader<'_>) -> Result<()> {
+    pub fn write_bytes(&self, dest: Vaddr, src: &mut VmReader<'_, Infallible>) -> Result<()> {
         let copy_len = src.remain();
 
         if copy_len > 0 {
@@ -150,7 +150,7 @@ pub trait ReadCString {
     fn read_cstring(&mut self) -> Result<CString>;
 }
 
-impl<'a> ReadCString for VmReader<'a, UserSpace> {
+impl<'a> ReadCString for VmReader<'a, Fallible> {
     /// This implementation is inspired by
     /// the `do_strncpy_from_user` function in Linux kernel.
     /// The original Linux implementation can be found at:

kernel/aster-nix/src/device/tty/driver.rs

@@ -2,7 +2,7 @@
 
 #![allow(dead_code)]
 
-use ostd::mm::VmReader;
+use ostd::mm::{Infallible, VmReader};
 use spin::Once;
 
 use crate::{
@@ -78,7 +78,7 @@ impl Default for TtyDriver {
     }
 }
 
-fn console_input_callback(mut reader: VmReader) {
+fn console_input_callback(mut reader: VmReader<Infallible>) {
     let tty_driver = get_tty_driver();
     while reader.remain() > 0 {
         let ch = reader.read_val().unwrap();

kernel/aster-nix/src/prelude.rs

@@ -17,7 +17,7 @@ pub(crate) use bitflags::bitflags;
 pub(crate) use int_to_c_enum::TryFromInt;
 pub(crate) use log::{debug, error, info, log_enabled, trace, warn};
 pub(crate) use ostd::{
-    mm::{Vaddr, VmReader, VmWriter, PAGE_SIZE},
+    mm::{FallibleVmRead, FallibleVmWrite, Vaddr, VmReader, VmWriter, PAGE_SIZE},
     sync::{Mutex, MutexGuard, RwLock, RwMutex, SpinLock, SpinLockGuard},
     Pod,
 };

kernel/aster-nix/src/vm/vmo/mod.rs

@@ -11,7 +11,7 @@ use align_ext::AlignExt;
 use aster_rights::Rights;
 use ostd::{
     collections::xarray::{CursorMut, XArray},
-    mm::{Frame, FrameAllocOptions, VmReader, VmWriter},
+    mm::{Frame, FrameAllocOptions, Infallible, VmReader, VmWriter},
 };
 
 use crate::prelude::*;
@@ -304,7 +304,7 @@ impl Vmo_ {
         let read_len = buf.len();
         let read_range = offset..(offset + read_len);
         let mut read_offset = offset % PAGE_SIZE;
-        let mut buf_writer: VmWriter = buf.into();
+        let mut buf_writer: VmWriter<Infallible> = buf.into();
 
         let read = move |page: Frame| {
             page.reader().skip(read_offset).read(&mut buf_writer);
@@ -319,7 +319,7 @@ impl Vmo_ {
         let write_len = buf.len();
         let write_range = offset..(offset + write_len);
         let mut write_offset = offset % PAGE_SIZE;
-        let mut buf_reader: VmReader = buf.into();
+        let mut buf_reader: VmReader<Infallible> = buf.into();
 
         let mut write = move |page: Frame| {
             page.writer().skip(write_offset).write(&mut buf_reader);