Modify the getting-VMAR usages in other syscalls

kernel/src/process/process_vm/heap.rs

@@ -65,9 +65,9 @@ impl Heap {
         Ok(())
     }
 
-    pub fn brk(&self, new_heap_end: Option<Vaddr>) -> Result<Vaddr> {
-        let current = current!();
-        let root_vmar = current.root_vmar();
+    pub fn brk(&self, new_heap_end: Option<Vaddr>, ctx: &Context) -> Result<Vaddr> {
+        let user_space = ctx.user_space();
+        let root_vmar = user_space.root_vmar();
         match new_heap_end {
             None => Ok(self.current_heap_end.load(Ordering::Relaxed)),
             Some(new_heap_end) => {

kernel/src/syscall/brk.rs

@@ -11,7 +11,7 @@ pub fn sys_brk(heap_end: u64, ctx: &Context) -> Result<SyscallReturn> {
     };
     debug!("new heap end = {:x?}", heap_end);
     let user_heap = ctx.process.heap();
-    let new_heap_end = user_heap.brk(new_heap_end)?;
+    let new_heap_end = user_heap.brk(new_heap_end, ctx)?;
 
     Ok(SyscallReturn::Return(new_heap_end as _))
 }

kernel/src/syscall/madvise.rs

@@ -51,7 +51,8 @@ pub fn sys_madvise(
 }
 
 fn madv_free(start: Vaddr, end: Vaddr, ctx: &Context) -> Result<()> {
-    let root_vmar = ctx.process.root_vmar();
+    let user_space = ctx.user_space();
+    let root_vmar = user_space.root_vmar();
     let advised_range = start..end;
     let _ = root_vmar.remove_mapping(advised_range);
 

kernel/src/syscall/mmap.rs

@@ -91,7 +91,8 @@ fn do_sys_mmap(
         vm_perms
     };
 
-    let root_vmar = ctx.process.root_vmar();
+    let user_space = ctx.user_space();
+    let root_vmar = user_space.root_vmar();
     let vm_map_options = {
         let mut options = root_vmar.new_map(len, vm_perms)?;
         let flags = option.flags;

kernel/src/syscall/mprotect.rs

@@ -11,7 +11,8 @@ pub fn sys_mprotect(addr: Vaddr, len: usize, perms: u64, ctx: &Context) -> Resul
         "addr = 0x{:x}, len = 0x{:x}, perms = {:?}",
         addr, len, vm_perms
     );
-    let root_vmar = ctx.process.root_vmar();
+    let user_space = ctx.user_space();
+    let root_vmar = user_space.root_vmar();
 
     // According to linux behavior,
     // <https://elixir.bootlin.com/linux/v6.0.9/source/mm/mprotect.c#L681>,

kernel/src/syscall/munmap.rs

@@ -18,7 +18,8 @@ pub fn sys_munmap(addr: Vaddr, len: usize, ctx: &Context) -> Result<SyscallRetur
         return_errno_with_message!(Errno::ENOMEM, "munmap len align overflow");
     }
 
-    let root_vmar = ctx.process.root_vmar();
+    let user_space = ctx.user_space();
+    let root_vmar = user_space.root_vmar();
     let len = len.align_up(PAGE_SIZE);
     let end = addr.checked_add(len).ok_or(Error::with_message(
         Errno::EINVAL,

kernel/src/syscall/pread64.rs

@@ -34,11 +34,8 @@ pub fn sys_pread64(
     }
 
     let read_len = {
-        let mut writer = ctx
-            .process
-            .root_vmar()
-            .vm_space()
-            .writer(user_buf_ptr, user_buf_len)?;
+        let user_space = ctx.user_space();
+        let mut writer = user_space.writer(user_buf_ptr, user_buf_len)?;
         file.read_at(offset as usize, &mut writer)?
     };
 

kernel/src/syscall/preadv.rs

@@ -75,7 +75,8 @@ fn do_sys_preadv(
     let mut total_len: usize = 0;
     let mut cur_offset = offset as usize;
 
-    let mut writer_array = VmWriterArray::from_user_io_vecs(ctx, io_vec_ptr, io_vec_count)?;
+    let user_space = ctx.user_space();
+    let mut writer_array = VmWriterArray::from_user_io_vecs(&user_space, io_vec_ptr, io_vec_count)?;
     for writer in writer_array.writers_mut() {
         if !writer.has_avail() {
             continue;
@@ -134,7 +135,8 @@ fn do_sys_readv(
 
     let mut total_len = 0;
 
-    let mut writer_array = VmWriterArray::from_user_io_vecs(ctx, io_vec_ptr, io_vec_count)?;
+    let user_space = ctx.user_space();
+    let mut writer_array = VmWriterArray::from_user_io_vecs(&user_space, io_vec_ptr, io_vec_count)?;
     for writer in writer_array.writers_mut() {
         if !writer.has_avail() {
             continue;

kernel/src/syscall/pwrite64.rs

@@ -33,11 +33,8 @@ pub fn sys_pwrite64(
         return_errno_with_message!(Errno::EINVAL, "offset + user_buf_len overflow");
     }
 
-    let mut reader = ctx
-        .process
-        .root_vmar()
-        .vm_space()
-        .reader(user_buf_ptr, user_buf_len)?;
+    let user_space = ctx.user_space();
+    let mut reader = user_space.reader(user_buf_ptr, user_buf_len)?;
     let write_len = file.write_at(offset as _, &mut reader)?;
     Ok(SyscallReturn::Return(write_len as _))
 }

kernel/src/syscall/pwritev.rs

@@ -77,7 +77,8 @@ fn do_sys_pwritev(
     let mut total_len: usize = 0;
     let mut cur_offset = offset as usize;
 
-    let mut reader_array = VmReaderArray::from_user_io_vecs(ctx, io_vec_ptr, io_vec_count)?;
+    let user_space = ctx.user_space();
+    let mut reader_array = VmReaderArray::from_user_io_vecs(&user_space, io_vec_ptr, io_vec_count)?;
     for reader in reader_array.readers_mut() {
         if !reader.has_remain() {
             continue;
@@ -127,7 +128,8 @@ fn do_sys_writev(
 
     let mut total_len = 0;
 
-    let mut reader_array = VmReaderArray::from_user_io_vecs(ctx, io_vec_ptr, io_vec_count)?;
+    let user_space = ctx.user_space();
+    let mut reader_array = VmReaderArray::from_user_io_vecs(&user_space, io_vec_ptr, io_vec_count)?;
     for reader in reader_array.readers_mut() {
         if !reader.has_remain() {
             continue;

kernel/src/syscall/read.rs

@@ -25,11 +25,8 @@ pub fn sys_read(
     // the file descriptor. If no errors detected, return 0 successfully.
     let read_len = {
         if buf_len != 0 {
-            let mut writer = ctx
-                .process
-                .root_vmar()
-                .vm_space()
-                .writer(user_buf_addr, buf_len)?;
+            let user_space = ctx.user_space();
+            let mut writer = user_space.writer(user_buf_addr, buf_len)?;
             file.read(&mut writer)
         } else {
             file.read_bytes(&mut [])

kernel/src/syscall/recvfrom.rs

@@ -24,10 +24,8 @@ pub fn sys_recvfrom(
     let file = get_file_fast!(&mut file_table, sockfd);
     let socket = file.as_socket_or_err()?;
 
-    let mut writers = {
-        let vm_space = ctx.process.root_vmar().vm_space();
-        vm_space.writer(buf, len)?
-    };
+    let user_space = ctx.user_space();
+    let mut writers = user_space.writer(buf, len)?;
 
     let (recv_size, message_header) =
         socket

kernel/src/syscall/recvmsg.rs

@@ -27,7 +27,8 @@ pub fn sys_recvmsg(
     let socket = file.as_socket_or_err()?;
 
     let (total_bytes, message_header) = {
-        let mut io_vec_writer = c_user_msghdr.copy_writer_array_from_user(ctx)?;
+        let user_space = ctx.user_space();
+        let mut io_vec_writer = c_user_msghdr.copy_writer_array_from_user(&user_space)?;
         socket
             .recvmsg(&mut io_vec_writer, flags)
             .map_err(|err| match err.error() {

kernel/src/syscall/sendmsg.rs

@@ -26,9 +26,10 @@ pub fn sys_sendmsg(
     let file = get_file_fast!(&mut file_table, sockfd);
     let socket = file.as_socket_or_err()?;
 
+    let user_space = ctx.user_space();
     let (mut io_vec_reader, message_header) = {
         let addr = c_user_msghdr.read_socket_addr_from_user()?;
-        let io_vec_reader = c_user_msghdr.copy_reader_array_from_user(ctx)?;
+        let io_vec_reader = c_user_msghdr.copy_reader_array_from_user(&user_space)?;
 
         let control_message = {
             if c_user_msghdr.msg_control != 0 {

kernel/src/syscall/sendto.rs

@@ -32,10 +32,8 @@ pub fn sys_sendto(
 
     let message_header = MessageHeader::new(socket_addr, None);
 
-    let mut reader = {
-        let vm_space = ctx.process.root_vmar().vm_space();
-        vm_space.reader(buf, len)?
-    };
+    let user_space = ctx.user_space();
+    let mut reader = user_space.reader(buf, len)?;
     let send_size = socket
         .sendmsg(&mut reader, message_header, flags)
         .map_err(|err| match err.error() {

kernel/src/syscall/write.rs

@@ -25,11 +25,8 @@ pub fn sys_write(
     // the file descriptor. If no errors detected, return 0 successfully.
     let write_len = {
         if user_buf_len != 0 {
-            let mut reader = ctx
-                .process
-                .root_vmar()
-                .vm_space()
-                .reader(user_buf_ptr, user_buf_len)?;
+            let user_space = ctx.user_space();
+            let mut reader = user_space.reader(user_buf_ptr, user_buf_len)?;
             file.write(&mut reader)
         } else {
             file.write_bytes(&[])

kernel/src/util/iovec.rs

@@ -55,12 +55,12 @@ impl IoVec {
 
 /// The util function for create [`VmReader`]/[`VmWriter`]s.
 fn copy_iovs_and_convert<'a, T: 'a>(
-    ctx: &'a Context,
+    user_space: &'a CurrentUserSpace<'a>,
     start_addr: Vaddr,
     count: usize,
     convert_iovec: impl Fn(&IoVec, &'a VmSpace) -> Result<T>,
 ) -> Result<Box<[T]>> {
-    let vm_space = ctx.process.root_vmar().vm_space();
+    let vm_space = user_space.root_vmar().vm_space();
 
     let mut v = Vec::with_capacity(count);
     for idx in 0..count {
@@ -96,11 +96,11 @@ pub struct VmWriterArray<'a>(Box<[VmWriter<'a>]>);
 impl<'a> VmReaderArray<'a> {
     /// Creates a new `IoVecReader` from user-provided io vec buffer.
     pub fn from_user_io_vecs(
-        ctx: &'a Context<'a>,
+        user_space: &'a CurrentUserSpace<'a>,
         start_addr: Vaddr,
         count: usize,
     ) -> Result<Self> {
-        let readers = copy_iovs_and_convert(ctx, start_addr, count, IoVec::reader)?;
+        let readers = copy_iovs_and_convert(user_space, start_addr, count, IoVec::reader)?;
         Ok(Self(readers))
     }
 
@@ -113,11 +113,11 @@ impl<'a> VmReaderArray<'a> {
 impl<'a> VmWriterArray<'a> {
     /// Creates a new `IoVecWriter` from user-provided io vec buffer.
     pub fn from_user_io_vecs(
-        ctx: &'a Context<'a>,
+        user_space: &'a CurrentUserSpace<'a>,
         start_addr: Vaddr,
         count: usize,
     ) -> Result<Self> {
-        let writers = copy_iovs_and_convert(ctx, start_addr, count, IoVec::writer)?;
+        let writers = copy_iovs_and_convert(user_space, start_addr, count, IoVec::writer)?;
         Ok(Self(writers))
     }
 

kernel/src/util/net/socket.rs

@@ -112,11 +112,17 @@ impl CUserMsgHdr {
         Ok(())
     }
 
-    pub fn copy_reader_array_from_user<'a>(&self, ctx: &'a Context) -> Result<VmReaderArray<'a>> {
-        VmReaderArray::from_user_io_vecs(ctx, self.msg_iov, self.msg_iovlen as usize)
+    pub fn copy_reader_array_from_user<'a>(
+        &self,
+        user_space: &'a CurrentUserSpace<'a>,
+    ) -> Result<VmReaderArray<'a>> {
+        VmReaderArray::from_user_io_vecs(user_space, self.msg_iov, self.msg_iovlen as usize)
     }
 
-    pub fn copy_writer_array_from_user<'a>(&self, ctx: &'a Context) -> Result<VmWriterArray<'a>> {
-        VmWriterArray::from_user_io_vecs(ctx, self.msg_iov, self.msg_iovlen as usize)
+    pub fn copy_writer_array_from_user<'a>(
+        &self,
+        user_space: &'a CurrentUserSpace<'a>,
+    ) -> Result<VmWriterArray<'a>> {
+        VmWriterArray::from_user_io_vecs(user_space, self.msg_iov, self.msg_iovlen as usize)
     }
 }