diff --git a/kernel/aster-nix/src/device/pty/pty.rs b/kernel/aster-nix/src/device/pty/pty.rs index 2c66e4376..44dbe3121 100644 --- a/kernel/aster-nix/src/device/pty/pty.rs +++ b/kernel/aster-nix/src/device/pty/pty.rs @@ -20,7 +20,6 @@ use crate::{ signal::{Pollee, Poller}, JobControl, Terminal, }, - util::{read_val_from_user, write_val_to_user}, }; const BUFFER_CAPACITY: usize = 4096; @@ -150,11 +149,11 @@ impl FileIo for PtyMaster { match cmd { IoctlCmd::TCGETS => { let termios = self.output.termios(); - write_val_to_user(arg, &termios)?; + CurrentUserSpace::get().write_val(arg, &termios)?; Ok(0) } IoctlCmd::TCSETS => { - let termios = read_val_from_user(arg)?; + let termios = CurrentUserSpace::get().read_val(arg)?; self.output.set_termios(termios); Ok(0) } @@ -164,7 +163,7 @@ impl FileIo for PtyMaster { } IoctlCmd::TIOCGPTN => { let idx = self.index(); - write_val_to_user(arg, &idx)?; + CurrentUserSpace::get().write_val(arg, &idx)?; Ok(0) } IoctlCmd::TIOCGPTPEER => { @@ -197,11 +196,11 @@ impl FileIo for PtyMaster { } IoctlCmd::TIOCGWINSZ => { let winsize = self.output.window_size(); - write_val_to_user(arg, &winsize)?; + CurrentUserSpace::get().write_val(arg, &winsize)?; Ok(0) } IoctlCmd::TIOCSWINSZ => { - let winsize = read_val_from_user(arg)?; + let winsize = CurrentUserSpace::get().read_val(arg)?; self.output.set_window_size(winsize); Ok(0) } @@ -213,12 +212,12 @@ impl FileIo for PtyMaster { ); }; let fg_pgid = foreground.pgid(); - write_val_to_user(arg, &fg_pgid)?; + CurrentUserSpace::get().write_val(arg, &fg_pgid)?; Ok(0) } IoctlCmd::TIOCSPGRP => { let pgid = { - let pgid: i32 = read_val_from_user(arg)?; + let pgid: i32 = CurrentUserSpace::get().read_val(arg)?; if pgid < 0 { return_errno_with_message!(Errno::EINVAL, "negative pgid"); } @@ -238,7 +237,7 @@ impl FileIo for PtyMaster { } IoctlCmd::FIONREAD => { let len = self.input.lock().len() as i32; - write_val_to_user(arg, &len)?; + CurrentUserSpace::get().write_val(arg, &len)?; Ok(0) } _ => Ok(0), @@ -372,12 +371,12 @@ impl FileIo for PtySlave { }; let fg_pgid = foreground.pgid(); - write_val_to_user(arg, &fg_pgid)?; + CurrentUserSpace::get().write_val(arg, &fg_pgid)?; Ok(0) } IoctlCmd::TIOCSPGRP => { let pgid = { - let pgid: i32 = read_val_from_user(arg)?; + let pgid: i32 = CurrentUserSpace::get().read_val(arg)?; if pgid < 0 { return_errno_with_message!(Errno::EINVAL, "negative pgid"); } @@ -397,7 +396,7 @@ impl FileIo for PtySlave { } IoctlCmd::FIONREAD => { let buffer_len = self.master().slave_buf_len() as i32; - write_val_to_user(arg, &buffer_len)?; + CurrentUserSpace::get().write_val(arg, &buffer_len)?; Ok(0) } _ => Ok(0), diff --git a/kernel/aster-nix/src/device/tdxguest/mod.rs b/kernel/aster-nix/src/device/tdxguest/mod.rs index 959ddf325..4902a3111 100644 --- a/kernel/aster-nix/src/device/tdxguest/mod.rs +++ b/kernel/aster-nix/src/device/tdxguest/mod.rs @@ -8,8 +8,8 @@ use crate::{ error::Error, events::IoEvents, fs::{inode_handle::FileIo, utils::IoctlCmd}, + prelude::*, process::signal::Poller, - util::{read_val_from_user, write_bytes_to_user}, }; const TDX_REPORTDATA_LEN: usize = 64; @@ -83,7 +83,8 @@ impl FileIo for TdxGuest { fn handle_get_report(arg: usize) -> Result { const SHARED_BIT: u8 = 51; const SHARED_MASK: u64 = 1u64 << SHARED_BIT; - let user_request: TdxReportRequest = read_val_from_user(arg)?; + let user_space = CurrentUserSpace::get(); + let user_request: TdxReportRequest = user_space.read_val(arg)?; let vm_segment = FrameAllocOptions::new(2) .is_contiguous(true) @@ -112,6 +113,6 @@ fn handle_get_report(arg: usize) -> Result { .read_bytes(1024, &mut generated_report) .unwrap(); let report_slice: &[u8] = &generated_report; - write_bytes_to_user(tdx_report_vaddr, &mut VmReader::from(report_slice))?; + user_space.write_bytes(tdx_report_vaddr, &mut VmReader::from(report_slice))?; Ok(0) } diff --git a/kernel/aster-nix/src/device/tty/mod.rs b/kernel/aster-nix/src/device/tty/mod.rs index 6db59b68c..22b772f38 100644 --- a/kernel/aster-nix/src/device/tty/mod.rs +++ b/kernel/aster-nix/src/device/tty/mod.rs @@ -18,7 +18,6 @@ use crate::{ signal::{signals::kernel::KernelSignal, Poller}, JobControl, Process, Terminal, }, - util::{read_val_from_user, write_val_to_user}, }; mod device; @@ -97,7 +96,7 @@ impl FileIo for Tty { // Get terminal attributes let termios = self.ldisc.termios(); trace!("get termios = {:?}", termios); - write_val_to_user(arg, &termios)?; + CurrentUserSpace::get().write_val(arg, &termios)?; Ok(0) } IoctlCmd::TIOCGPGRP => { @@ -106,13 +105,13 @@ impl FileIo for Tty { }; let fg_pgid = foreground.pgid(); debug!("fg_pgid = {}", fg_pgid); - write_val_to_user(arg, &fg_pgid)?; + CurrentUserSpace::get().write_val(arg, &fg_pgid)?; Ok(0) } IoctlCmd::TIOCSPGRP => { // Set the process group id of fg progress group let pgid = { - let pgid: i32 = read_val_from_user(arg)?; + let pgid: i32 = CurrentUserSpace::get().read_val(arg)?; if pgid < 0 { return_errno_with_message!(Errno::EINVAL, "negative pgid"); } @@ -127,20 +126,20 @@ impl FileIo for Tty { } IoctlCmd::TCSETS => { // Set terminal attributes - let termios = read_val_from_user(arg)?; + let termios = CurrentUserSpace::get().read_val(arg)?; debug!("set termios = {:?}", termios); self.ldisc.set_termios(termios); Ok(0) } IoctlCmd::TCSETSW => { - let termios = read_val_from_user(arg)?; + let termios = CurrentUserSpace::get().read_val(arg)?; debug!("set termios = {:?}", termios); self.ldisc.set_termios(termios); // TODO: drain output buffer Ok(0) } IoctlCmd::TCSETSF => { - let termios = read_val_from_user(arg)?; + let termios = CurrentUserSpace::get().read_val(arg)?; debug!("set termios = {:?}", termios); self.ldisc.set_termios(termios); self.ldisc.drain_input(); @@ -149,11 +148,11 @@ impl FileIo for Tty { } IoctlCmd::TIOCGWINSZ => { let winsize = self.ldisc.window_size(); - write_val_to_user(arg, &winsize)?; + CurrentUserSpace::get().write_val(arg, &winsize)?; Ok(0) } IoctlCmd::TIOCSWINSZ => { - let winsize = read_val_from_user(arg)?; + let winsize = CurrentUserSpace::get().read_val(arg)?; self.ldisc.set_window_size(winsize); Ok(0) } diff --git a/kernel/aster-nix/src/prelude.rs b/kernel/aster-nix/src/prelude.rs index 44357e6dd..316173652 100644 --- a/kernel/aster-nix/src/prelude.rs +++ b/kernel/aster-nix/src/prelude.rs @@ -54,6 +54,7 @@ pub(crate) use crate::{ error::{Errno, Error}, print, println, time::{wait::WaitTimeout, Clock}, + util::{CurrentUserSpace, ReadCString}, }; pub(crate) type Result = core::result::Result; pub(crate) use crate::{return_errno, return_errno_with_message}; diff --git a/kernel/aster-nix/src/process/posix_thread/exit.rs b/kernel/aster-nix/src/process/posix_thread/exit.rs index 9a006860c..64a1d9d85 100644 --- a/kernel/aster-nix/src/process/posix_thread/exit.rs +++ b/kernel/aster-nix/src/process/posix_thread/exit.rs @@ -5,7 +5,6 @@ use crate::{ prelude::*, process::{do_exit_group, TermStatus}, thread::{thread_table, Thread, Tid}, - util::write_val_to_user, }; /// Exits the thread if the thread is a POSIX thread. @@ -28,7 +27,9 @@ pub fn do_exit(thread: Arc, term_status: TermStatus) -> Result<()> { if *clear_ctid != 0 { futex_wake(*clear_ctid, 1)?; // FIXME: the correct write length? - write_val_to_user(*clear_ctid, &0u32).unwrap(); + CurrentUserSpace::get() + .write_val(*clear_ctid, &0u32) + .unwrap(); *clear_ctid = 0; } // exit the robust list: walk the robust list; mark futex words as dead and do futex wake diff --git a/kernel/aster-nix/src/process/posix_thread/futex.rs b/kernel/aster-nix/src/process/posix_thread/futex.rs index 1a3f258c0..e1b75c28c 100644 --- a/kernel/aster-nix/src/process/posix_thread/futex.rs +++ b/kernel/aster-nix/src/process/posix_thread/futex.rs @@ -9,7 +9,7 @@ use ostd::{ }; use spin::Once; -use crate::{prelude::*, util::read_val_from_user}; +use crate::prelude::*; type FutexBitSet = u32; type FutexBucketRef = Arc>; @@ -330,7 +330,7 @@ impl FutexKey { pub fn load_val(&self) -> i32 { // FIXME: how to implement a atomic load? warn!("implement an atomic load"); - read_val_from_user(self.addr).unwrap() + CurrentUserSpace::get().read_val(self.addr).unwrap() } pub fn addr(&self) -> Vaddr { diff --git a/kernel/aster-nix/src/process/posix_thread/robust_list.rs b/kernel/aster-nix/src/process/posix_thread/robust_list.rs index b360d82db..497e828ab 100644 --- a/kernel/aster-nix/src/process/posix_thread/robust_list.rs +++ b/kernel/aster-nix/src/process/posix_thread/robust_list.rs @@ -5,7 +5,6 @@ use crate::{ prelude::*, process::{posix_thread::futex::futex_wake, Pid}, - util::{read_val_from_user, write_val_to_user}, }; #[repr(C)] @@ -105,7 +104,8 @@ impl<'a> Iterator for FutexIter<'a> { } else { None }; - let Ok(robust_list) = read_val_from_user::(self.entry_ptr) else { + let Ok(robust_list) = CurrentUserSpace::get().read_val::(self.entry_ptr) + else { return None; }; self.entry_ptr = robust_list.next; @@ -126,11 +126,12 @@ const FUTEX_TID_MASK: u32 = 0x3FFF_FFFF; /// Wakeup one robust futex owned by the thread /// FIXME: requires atomic operations here pub fn wake_robust_futex(futex_addr: Vaddr, tid: Pid) -> Result<()> { + let user_space = CurrentUserSpace::get(); let futex_val = { if futex_addr == 0 { return_errno_with_message!(Errno::EINVAL, "invalid futext addr"); } - read_val_from_user::(futex_addr)? + user_space.read_val::(futex_addr)? }; let mut old_val = futex_val; loop { @@ -139,11 +140,11 @@ pub fn wake_robust_futex(futex_addr: Vaddr, tid: Pid) -> Result<()> { break; } let new_val = (old_val & FUTEX_WAITERS) | FUTEX_OWNER_DIED; - let cur_val = read_val_from_user(futex_addr)?; + let cur_val = user_space.read_val(futex_addr)?; if cur_val != new_val { // The futex value has changed, let's retry with current value old_val = cur_val; - write_val_to_user(futex_addr, &new_val)?; + user_space.write_val(futex_addr, &new_val)?; continue; } // Wakeup one waiter diff --git a/kernel/aster-nix/src/process/signal/mod.rs b/kernel/aster-nix/src/process/signal/mod.rs index f1407a28e..40406b1fe 100644 --- a/kernel/aster-nix/src/process/signal/mod.rs +++ b/kernel/aster-nix/src/process/signal/mod.rs @@ -31,7 +31,6 @@ use crate::{ prelude::*, process::{do_exit_group, TermStatus}, thread::{status::ThreadStatus, Thread}, - util::{write_bytes_to_user, write_val_to_user}, }; pub trait SignalContext { @@ -173,9 +172,10 @@ pub fn handle_user_signal( // To avoid corrupting signal stack, we minus 128 first. stack_pointer -= 128; + let user_space = CurrentUserSpace::get(); // 1. write siginfo_t stack_pointer -= mem::size_of::() as u64; - write_val_to_user(stack_pointer as _, &sig_info)?; + user_space.write_val(stack_pointer as _, &sig_info)?; let siginfo_addr = stack_pointer; // 2. write ucontext_t. @@ -196,7 +196,7 @@ pub fn handle_user_signal( ucontext.uc_link = 0; } // TODO: store fp regs in ucontext - write_val_to_user(stack_pointer as _, &ucontext)?; + user_space.write_val(stack_pointer as _, &ucontext)?; let ucontext_addr = stack_pointer; // Store the ucontext addr in sig context of current thread. *sig_context = Some(ucontext_addr as Vaddr); @@ -217,7 +217,7 @@ pub fn handle_user_signal( ]; stack_pointer -= TRAMPOLINE.len() as u64; let trampoline_rip = stack_pointer; - write_bytes_to_user(stack_pointer as Vaddr, &mut VmReader::from(TRAMPOLINE))?; + user_space.write_bytes(stack_pointer as Vaddr, &mut VmReader::from(TRAMPOLINE))?; stack_pointer = write_u64_to_user_stack(stack_pointer, trampoline_rip)?; } @@ -261,7 +261,7 @@ fn use_alternate_signal_stack(posix_thread: &PosixThread) -> Option { fn write_u64_to_user_stack(rsp: u64, value: u64) -> Result { let rsp = rsp - 8; - write_val_to_user(rsp as Vaddr, &value)?; + CurrentUserSpace::get().write_val(rsp as Vaddr, &value)?; Ok(rsp) } diff --git a/kernel/aster-nix/src/syscall/access.rs b/kernel/aster-nix/src/syscall/access.rs index 16c8b713c..a3153bc14 100644 --- a/kernel/aster-nix/src/syscall/access.rs +++ b/kernel/aster-nix/src/syscall/access.rs @@ -8,7 +8,6 @@ use crate::{ utils::PATH_MAX, }, prelude::*, - util::read_cstring_from_user, }; pub fn sys_faccessat(dirfd: FileDesc, path_ptr: Vaddr, mode: u16) -> Result { @@ -55,7 +54,7 @@ pub fn do_faccessat( let flags = FaccessatFlags::from_bits(flags) .ok_or_else(|| Error::with_message(Errno::EINVAL, "Invalid flags"))?; - let path = read_cstring_from_user(path_ptr, PATH_MAX)?; + let path = CurrentUserSpace::get().read_cstring(path_ptr, PATH_MAX)?; debug!( "dirfd = {}, path = {:?}, mode = {:o}, flags = {:?}", dirfd, path, mode, flags diff --git a/kernel/aster-nix/src/syscall/capget.rs b/kernel/aster-nix/src/syscall/capget.rs index 2c4a99aae..beaf578d0 100644 --- a/kernel/aster-nix/src/syscall/capget.rs +++ b/kernel/aster-nix/src/syscall/capget.rs @@ -7,12 +7,12 @@ use crate::{ credentials, credentials::c_types::{cap_user_data_t, cap_user_header_t, LINUX_CAPABILITY_VERSION_3}, }, - util::{read_val_from_user, write_val_to_user}, }; pub fn sys_capget(cap_user_header_addr: Vaddr, cap_user_data_addr: Vaddr) -> Result { + let user_space = CurrentUserSpace::get(); let cap_user_header: cap_user_header_t = - read_val_from_user::(cap_user_header_addr)?; + user_space.read_val::(cap_user_header_addr)?; if cap_user_header.version != LINUX_CAPABILITY_VERSION_3 { return_errno_with_message!(Errno::EINVAL, "not supported (capability version is not 3)"); @@ -42,6 +42,6 @@ pub fn sys_capget(cap_user_header_addr: Vaddr, cap_user_data_addr: Vaddr) -> Res inheritable: inheritable_capset.as_u32(), }; - write_val_to_user(cap_user_data_addr, &result)?; + user_space.write_val(cap_user_data_addr, &result)?; Ok(SyscallReturn::Return(0)) } diff --git a/kernel/aster-nix/src/syscall/capset.rs b/kernel/aster-nix/src/syscall/capset.rs index c7a308dd3..b307d7a44 100644 --- a/kernel/aster-nix/src/syscall/capset.rs +++ b/kernel/aster-nix/src/syscall/capset.rs @@ -10,7 +10,6 @@ use crate::{ }, credentials_mut, }, - util::read_val_from_user, }; fn make_kernel_cap(low: u32, high: u32) -> u64 { @@ -18,8 +17,9 @@ fn make_kernel_cap(low: u32, high: u32) -> u64 { } pub fn sys_capset(cap_user_header_addr: Vaddr, cap_user_data_addr: Vaddr) -> Result { + let user_space = CurrentUserSpace::get(); let cap_user_header: cap_user_header_t = - read_val_from_user::(cap_user_header_addr)?; + user_space.read_val::(cap_user_header_addr)?; if cap_user_header.version != LINUX_CAPABILITY_VERSION_3 { return_errno_with_message!(Errno::EINVAL, "not supported (capability version is not 3)"); @@ -33,7 +33,8 @@ pub fn sys_capset(cap_user_header_addr: Vaddr, cap_user_data_addr: Vaddr) -> Res } // Convert the cap(u32) to u64 - let cap_user_data: cap_user_data_t = read_val_from_user::(cap_user_data_addr)?; + let cap_user_data: cap_user_data_t = + user_space.read_val::(cap_user_data_addr)?; let inheritable = make_kernel_cap(cap_user_data.inheritable, 0); let permitted = make_kernel_cap(cap_user_data.permitted, 0); let effective = make_kernel_cap(cap_user_data.effective, 0); diff --git a/kernel/aster-nix/src/syscall/chdir.rs b/kernel/aster-nix/src/syscall/chdir.rs index 68a191685..37b96ed0f 100644 --- a/kernel/aster-nix/src/syscall/chdir.rs +++ b/kernel/aster-nix/src/syscall/chdir.rs @@ -5,11 +5,10 @@ use crate::{ fs::{file_table::FileDesc, fs_resolver::FsPath, inode_handle::InodeHandle, utils::InodeType}, prelude::*, syscall::constants::MAX_FILENAME_LEN, - util::read_cstring_from_user, }; pub fn sys_chdir(path_ptr: Vaddr) -> Result { - let path = read_cstring_from_user(path_ptr, MAX_FILENAME_LEN)?; + let path = CurrentUserSpace::get().read_cstring(path_ptr, MAX_FILENAME_LEN)?; debug!("path = {:?}", path); let current = current!(); diff --git a/kernel/aster-nix/src/syscall/chmod.rs b/kernel/aster-nix/src/syscall/chmod.rs index 6a3ab53f8..7e1a4e714 100644 --- a/kernel/aster-nix/src/syscall/chmod.rs +++ b/kernel/aster-nix/src/syscall/chmod.rs @@ -8,7 +8,6 @@ use crate::{ utils::{InodeMode, PATH_MAX}, }, prelude::*, - util::read_cstring_from_user, }; pub fn sys_fchmod(fd: FileDesc, mode: u16) -> Result { @@ -32,7 +31,7 @@ pub fn sys_fchmodat( mode: u16, /* flags: u32, */ ) -> Result { - let path = read_cstring_from_user(path_ptr, PATH_MAX)?; + let path = CurrentUserSpace::get().read_cstring(path_ptr, PATH_MAX)?; debug!("dirfd = {}, path = {:?}, mode = 0o{:o}", dirfd, path, mode,); let current = current!(); diff --git a/kernel/aster-nix/src/syscall/chown.rs b/kernel/aster-nix/src/syscall/chown.rs index bf2a2fcf1..27029a65a 100644 --- a/kernel/aster-nix/src/syscall/chown.rs +++ b/kernel/aster-nix/src/syscall/chown.rs @@ -9,7 +9,6 @@ use crate::{ }, prelude::*, process::{Gid, Uid}, - util::read_cstring_from_user, }; pub fn sys_fchown(fd: FileDesc, uid: i32, gid: i32) -> Result { @@ -54,7 +53,7 @@ pub fn sys_fchownat( gid: i32, flags: u32, ) -> Result { - let path = read_cstring_from_user(path_ptr, PATH_MAX)?; + let path = CurrentUserSpace::get().read_cstring(path_ptr, PATH_MAX)?; let flags = ChownFlags::from_bits(flags) .ok_or_else(|| Error::with_message(Errno::EINVAL, "invalid flags"))?; debug!( diff --git a/kernel/aster-nix/src/syscall/chroot.rs b/kernel/aster-nix/src/syscall/chroot.rs index 3ffaef3d0..8d5c20b98 100644 --- a/kernel/aster-nix/src/syscall/chroot.rs +++ b/kernel/aster-nix/src/syscall/chroot.rs @@ -5,11 +5,10 @@ use crate::{ fs::{fs_resolver::FsPath, utils::InodeType}, prelude::*, syscall::constants::MAX_FILENAME_LEN, - util::read_cstring_from_user, }; pub fn sys_chroot(path_ptr: Vaddr) -> Result { - let path = read_cstring_from_user(path_ptr, MAX_FILENAME_LEN)?; + let path = CurrentUserSpace::get().read_cstring(path_ptr, MAX_FILENAME_LEN)?; debug!("path = {:?}", path); let current = current!(); diff --git a/kernel/aster-nix/src/syscall/clock_gettime.rs b/kernel/aster-nix/src/syscall/clock_gettime.rs index 536149d06..86cd6ccd4 100644 --- a/kernel/aster-nix/src/syscall/clock_gettime.rs +++ b/kernel/aster-nix/src/syscall/clock_gettime.rs @@ -18,7 +18,6 @@ use crate::{ }, timespec_t, Clock, }, - util::write_val_to_user, }; pub fn sys_clock_gettime(clockid: clockid_t, timespec_addr: Vaddr) -> Result { @@ -27,7 +26,7 @@ pub fn sys_clock_gettime(clockid: clockid_t, timespec_addr: Vaddr) -> Result Result { @@ -62,14 +61,14 @@ pub fn sys_epoll_ctl( let cmd = match op { EPOLL_CTL_ADD => { - let c_epoll_event = read_val_from_user::(event_addr)?; + let c_epoll_event = CurrentUserSpace::get().read_val::(event_addr)?; let event = EpollEvent::from(&c_epoll_event); let flags = EpollFlags::from_bits_truncate(c_epoll_event.events); EpollCtl::Add(fd, event, flags) } EPOLL_CTL_DEL => EpollCtl::Del(fd), EPOLL_CTL_MOD => { - let c_epoll_event = read_val_from_user::(event_addr)?; + let c_epoll_event = CurrentUserSpace::get().read_val::(event_addr)?; let event = EpollEvent::from(&c_epoll_event); let flags = EpollFlags::from_bits_truncate(c_epoll_event.events); EpollCtl::Mod(fd, event, flags) @@ -139,9 +138,10 @@ pub fn sys_epoll_wait( // Write back let mut write_addr = events_addr; + let user_space = CurrentUserSpace::get(); for epoll_event in epoll_events.iter() { let c_epoll_event = c_epoll_event::from(epoll_event); - write_val_to_user(write_addr, &c_epoll_event)?; + user_space.write_val(write_addr, &c_epoll_event)?; write_addr += core::mem::size_of::(); } @@ -150,7 +150,7 @@ pub fn sys_epoll_wait( fn set_signal_mask(set_ptr: Vaddr) -> Result { let new_mask: Option = if set_ptr != 0 { - Some(read_val_from_user::(set_ptr)?.into()) + Some(CurrentUserSpace::get().read_val::(set_ptr)?.into()) } else { None }; @@ -208,9 +208,10 @@ pub fn sys_epoll_pwait( // Write back let mut write_addr = events_addr; + let user_space = CurrentUserSpace::get(); for event in ready_events.iter() { let c_event = c_epoll_event::from(event); - write_val_to_user(write_addr, &c_event)?; + user_space.write_val(write_addr, &c_event)?; write_addr += core::mem::size_of::(); } diff --git a/kernel/aster-nix/src/syscall/execve.rs b/kernel/aster-nix/src/syscall/execve.rs index 5eecab1c8..06f50975b 100644 --- a/kernel/aster-nix/src/syscall/execve.rs +++ b/kernel/aster-nix/src/syscall/execve.rs @@ -18,7 +18,6 @@ use crate::{ posix_thread::{PosixThreadExt, ThreadName}, Credentials, Process, MAX_ARGV_NUMBER, MAX_ARG_LEN, MAX_ENVP_NUMBER, MAX_ENV_LEN, }, - util::{read_cstring_from_user, read_val_from_user}, }; pub fn sys_execve( @@ -149,7 +148,7 @@ bitflags::bitflags! { } fn read_filename(filename_ptr: Vaddr) -> Result { - let filename = read_cstring_from_user(filename_ptr, MAX_FILENAME_LEN)?; + let filename = CurrentUserSpace::get().read_cstring(filename_ptr, MAX_FILENAME_LEN)?; Ok(filename.into_string().unwrap()) } @@ -165,15 +164,16 @@ fn read_cstring_vec( } let mut read_addr = array_ptr; let mut find_null = false; + let user_space = CurrentUserSpace::get(); for _ in 0..max_string_number { - let cstring_ptr = read_val_from_user::(read_addr)?; + let cstring_ptr = user_space.read_val::(read_addr)?; read_addr += 8; // read a null pointer if cstring_ptr == 0 { find_null = true; break; } - let cstring = read_cstring_from_user(cstring_ptr, max_string_len)?; + let cstring = user_space.read_cstring(cstring_ptr, max_string_len)?; res.push(cstring); } if !find_null { diff --git a/kernel/aster-nix/src/syscall/getcwd.rs b/kernel/aster-nix/src/syscall/getcwd.rs index 2ee5ab03e..a21ef00d5 100644 --- a/kernel/aster-nix/src/syscall/getcwd.rs +++ b/kernel/aster-nix/src/syscall/getcwd.rs @@ -1,13 +1,13 @@ // SPDX-License-Identifier: MPL-2.0 use super::SyscallReturn; -use crate::{prelude::*, util::write_bytes_to_user}; +use crate::prelude::*; pub fn sys_getcwd(buf: Vaddr, len: usize) -> Result { // TODO: getcwd only return a fake result now let fake_cwd = CString::new("/")?; let bytes = fake_cwd.as_bytes_with_nul(); let write_len = len.min(bytes.len()); - write_bytes_to_user(buf, &mut VmReader::from(&bytes[..write_len]))?; + CurrentUserSpace::get().write_bytes(buf, &mut VmReader::from(&bytes[..write_len]))?; Ok(SyscallReturn::Return(write_len as _)) } diff --git a/kernel/aster-nix/src/syscall/getdents64.rs b/kernel/aster-nix/src/syscall/getdents64.rs index 3b87d2d5d..929bef272 100644 --- a/kernel/aster-nix/src/syscall/getdents64.rs +++ b/kernel/aster-nix/src/syscall/getdents64.rs @@ -12,7 +12,6 @@ use crate::{ utils::{DirentVisitor, InodeType}, }, prelude::*, - util::write_bytes_to_user, }; pub fn sys_getdents(fd: FileDesc, buf_addr: Vaddr, buf_len: usize) -> Result { @@ -36,7 +35,7 @@ pub fn sys_getdents(fd: FileDesc, buf_addr: Vaddr, buf_len: usize) -> Result::new(&mut buffer); // Use the non-64-bit reader let _ = inode_handle.readdir(&mut reader)?; let read_len = reader.read_len(); - write_bytes_to_user(buf_addr, &mut VmReader::from(&buffer[..read_len]))?; + CurrentUserSpace::get().write_bytes(buf_addr, &mut VmReader::from(&buffer[..read_len]))?; Ok(SyscallReturn::Return(read_len as _)) } @@ -61,7 +60,7 @@ pub fn sys_getdents64(fd: FileDesc, buf_addr: Vaddr, buf_len: usize) -> Result::new(&mut buffer); let _ = inode_handle.readdir(&mut reader)?; let read_len = reader.read_len(); - write_bytes_to_user(buf_addr, &mut VmReader::from(&buffer[..read_len]))?; + CurrentUserSpace::get().write_bytes(buf_addr, &mut VmReader::from(&buffer[..read_len]))?; Ok(SyscallReturn::Return(read_len as _)) } diff --git a/kernel/aster-nix/src/syscall/getgroups.rs b/kernel/aster-nix/src/syscall/getgroups.rs index e39d1e01e..fb571ccf0 100644 --- a/kernel/aster-nix/src/syscall/getgroups.rs +++ b/kernel/aster-nix/src/syscall/getgroups.rs @@ -1,7 +1,7 @@ // SPDX-License-Identifier: MPL-2.0 use super::SyscallReturn; -use crate::{prelude::*, process::credentials, util::write_val_to_user}; +use crate::{prelude::*, process::credentials}; pub fn sys_getgroups(size: i32, group_list_addr: Vaddr) -> Result { debug!("size = {}, group_list_addr = 0x{:x}", size, group_list_addr); @@ -24,9 +24,10 @@ pub fn sys_getgroups(size: i32, group_list_addr: Vaddr) -> Result ); } + let user_space = CurrentUserSpace::get(); for (idx, gid) in groups.iter().enumerate() { let addr = group_list_addr + idx * core::mem::size_of_val(gid); - write_val_to_user(addr, gid)?; + user_space.write_val(addr, gid)?; } Ok(SyscallReturn::Return(groups.len() as _)) diff --git a/kernel/aster-nix/src/syscall/getrandom.rs b/kernel/aster-nix/src/syscall/getrandom.rs index ece25df24..b5e946e03 100644 --- a/kernel/aster-nix/src/syscall/getrandom.rs +++ b/kernel/aster-nix/src/syscall/getrandom.rs @@ -1,7 +1,7 @@ // SPDX-License-Identifier: MPL-2.0 use super::SyscallReturn; -use crate::{device, prelude::*, util::write_bytes_to_user}; +use crate::{device, prelude::*}; pub fn sys_getrandom(buf: Vaddr, count: usize, flags: u32) -> Result { let flags = GetRandomFlags::from_bits_truncate(flags); @@ -17,7 +17,7 @@ pub fn sys_getrandom(buf: Vaddr, count: usize, flags: u32) -> Result Result { debug!("rgid_ptr = 0x{rgid_ptr:x}, egid_ptr = 0x{egid_ptr:x}, sgid_ptr = 0x{sgid_ptr:x}"); let credentials = credentials(); + let user_space = CurrentUserSpace::get(); let rgid = credentials.rgid(); - write_val_to_user(rgid_ptr, &rgid)?; + user_space.write_val(rgid_ptr, &rgid)?; let egid = credentials.egid(); - write_val_to_user(egid_ptr, &egid)?; + user_space.write_val(egid_ptr, &egid)?; let sgid = credentials.sgid(); - write_val_to_user(sgid_ptr, &sgid)?; + user_space.write_val(sgid_ptr, &sgid)?; Ok(SyscallReturn::Return(0)) } diff --git a/kernel/aster-nix/src/syscall/getresuid.rs b/kernel/aster-nix/src/syscall/getresuid.rs index 18fc40893..3aa8c8ee5 100644 --- a/kernel/aster-nix/src/syscall/getresuid.rs +++ b/kernel/aster-nix/src/syscall/getresuid.rs @@ -1,21 +1,22 @@ // SPDX-License-Identifier: MPL-2.0 use super::SyscallReturn; -use crate::{prelude::*, process::credentials, util::write_val_to_user}; +use crate::{prelude::*, process::credentials}; pub fn sys_getresuid(ruid_ptr: Vaddr, euid_ptr: Vaddr, suid_ptr: Vaddr) -> Result { debug!("ruid_ptr = 0x{ruid_ptr:x}, euid_ptr = 0x{euid_ptr:x}, suid_ptr = 0x{suid_ptr:x}"); let credentials = credentials(); + let user_space = CurrentUserSpace::get(); let ruid = credentials.ruid(); - write_val_to_user(ruid_ptr, &ruid)?; + user_space.write_val(ruid_ptr, &ruid)?; let euid = credentials.euid(); - write_val_to_user(euid_ptr, &euid)?; + user_space.write_val(euid_ptr, &euid)?; let suid = credentials.suid(); - write_val_to_user(suid_ptr, &suid)?; + user_space.write_val(suid_ptr, &suid)?; Ok(SyscallReturn::Return(0)) } diff --git a/kernel/aster-nix/src/syscall/getrusage.rs b/kernel/aster-nix/src/syscall/getrusage.rs index fb542f3d8..45840abd9 100644 --- a/kernel/aster-nix/src/syscall/getrusage.rs +++ b/kernel/aster-nix/src/syscall/getrusage.rs @@ -5,9 +5,7 @@ use int_to_c_enum::TryFromInt; use super::SyscallReturn; -use crate::{ - prelude::*, process::posix_thread::PosixThreadExt, time::timeval_t, util::write_val_to_user, -}; +use crate::{prelude::*, process::posix_thread::PosixThreadExt, time::timeval_t}; #[derive(Debug, Copy, Clone, TryFromInt, PartialEq)] #[repr(i32)] @@ -53,7 +51,7 @@ pub fn sys_getrusage(target: i32, rusage_addr: Vaddr) -> Result { } }; - write_val_to_user(rusage_addr, &rusage)?; + CurrentUserSpace::get().write_val(rusage_addr, &rusage)?; } Ok(SyscallReturn::Return(0)) diff --git a/kernel/aster-nix/src/syscall/getsockopt.rs b/kernel/aster-nix/src/syscall/getsockopt.rs index fa271eae9..73e97b929 100644 --- a/kernel/aster-nix/src/syscall/getsockopt.rs +++ b/kernel/aster-nix/src/syscall/getsockopt.rs @@ -4,10 +4,7 @@ use super::SyscallReturn; use crate::{ fs::file_table::FileDesc, prelude::*, - util::{ - net::{get_socket_from_fd, new_raw_socket_option, CSocketOptionLevel}, - read_val_from_user, write_val_to_user, - }, + util::net::{get_socket_from_fd, new_raw_socket_option, CSocketOptionLevel}, }; pub fn sys_getsockopt( @@ -21,7 +18,9 @@ pub fn sys_getsockopt( if optval == 0 || optlen_addr == 0 { return_errno_with_message!(Errno::EINVAL, "optval or optlen_addr is null pointer"); } - let optlen: u32 = read_val_from_user(optlen_addr)?; + let user_space = CurrentUserSpace::get(); + + let optlen: u32 = user_space.read_val(optlen_addr)?; debug!("level = {level:?}, sockfd = {sockfd}, optname = {optname:?}, optlen = {optlen}"); let socket = get_socket_from_fd(sockfd)?; @@ -32,13 +31,9 @@ pub fn sys_getsockopt( socket.get_option(raw_option.as_sock_option_mut())?; - let write_len = { - let current = current!(); - let vmar = current.root_vmar(); - raw_option.write_to_user(vmar, optval, optlen)? - }; + let write_len = raw_option.write_to_user(optval, optlen)?; - write_val_to_user(optlen_addr, &(write_len as u32))?; + user_space.write_val(optlen_addr, &(write_len as u32))?; Ok(SyscallReturn::Return(0)) } diff --git a/kernel/aster-nix/src/syscall/gettimeofday.rs b/kernel/aster-nix/src/syscall/gettimeofday.rs index de28a5fac..cf7986cff 100644 --- a/kernel/aster-nix/src/syscall/gettimeofday.rs +++ b/kernel/aster-nix/src/syscall/gettimeofday.rs @@ -4,7 +4,6 @@ use super::SyscallReturn; use crate::{ prelude::*, time::{timeval_t, SystemTime}, - util::write_val_to_user, }; // The use of the timezone structure is obsolete. @@ -19,7 +18,7 @@ pub fn sys_gettimeofday(timeval_addr: Vaddr, /* timezone_addr: Vaddr */) -> Resu let time_duration = now.duration_since(&SystemTime::UNIX_EPOCH)?; timeval_t::from(time_duration) }; - write_val_to_user(timeval_addr, &time_val)?; + CurrentUserSpace::get().write_val(timeval_addr, &time_val)?; Ok(SyscallReturn::Return(0)) } diff --git a/kernel/aster-nix/src/syscall/ioctl.rs b/kernel/aster-nix/src/syscall/ioctl.rs index 14e860c9b..0ada065e0 100644 --- a/kernel/aster-nix/src/syscall/ioctl.rs +++ b/kernel/aster-nix/src/syscall/ioctl.rs @@ -7,7 +7,6 @@ use crate::{ utils::{IoctlCmd, StatusFlags}, }, prelude::*, - util::read_val_from_user, }; pub fn sys_ioctl(fd: FileDesc, cmd: u32, arg: Vaddr) -> Result { @@ -21,14 +20,14 @@ pub fn sys_ioctl(fd: FileDesc, cmd: u32, arg: Vaddr) -> Result { let file = file_table.get_file(fd)?; let res = match ioctl_cmd { IoctlCmd::FIONBIO => { - let is_nonblocking = read_val_from_user::(arg)? != 0; + let is_nonblocking = CurrentUserSpace::get().read_val::(arg)? != 0; let mut flags = file.status_flags(); flags.set(StatusFlags::O_NONBLOCK, is_nonblocking); file.set_status_flags(flags)?; 0 } IoctlCmd::FIOASYNC => { - let is_async = read_val_from_user::(arg)? != 0; + let is_async = CurrentUserSpace::get().read_val::(arg)? != 0; let mut flags = file.status_flags(); // Set `O_ASYNC` flags will send `SIGIO` signal to a process when diff --git a/kernel/aster-nix/src/syscall/link.rs b/kernel/aster-nix/src/syscall/link.rs index 53bcc2aee..3374de091 100644 --- a/kernel/aster-nix/src/syscall/link.rs +++ b/kernel/aster-nix/src/syscall/link.rs @@ -8,7 +8,6 @@ use crate::{ }, prelude::*, syscall::constants::MAX_FILENAME_LEN, - util::read_cstring_from_user, }; pub fn sys_linkat( @@ -18,8 +17,10 @@ pub fn sys_linkat( new_path_addr: Vaddr, flags: u32, ) -> Result { - let old_path = read_cstring_from_user(old_path_addr, MAX_FILENAME_LEN)?; - let new_path = read_cstring_from_user(new_path_addr, MAX_FILENAME_LEN)?; + let user_space = CurrentUserSpace::get(); + + let old_path = user_space.read_cstring(old_path_addr, MAX_FILENAME_LEN)?; + let new_path = user_space.read_cstring(new_path_addr, MAX_FILENAME_LEN)?; let flags = LinkFlags::from_bits(flags).ok_or(Error::with_message(Errno::EINVAL, "invalid flags"))?; debug!( diff --git a/kernel/aster-nix/src/syscall/madvise.rs b/kernel/aster-nix/src/syscall/madvise.rs index 28666a00b..28b9566d9 100644 --- a/kernel/aster-nix/src/syscall/madvise.rs +++ b/kernel/aster-nix/src/syscall/madvise.rs @@ -1,7 +1,7 @@ // SPDX-License-Identifier: MPL-2.0 use super::SyscallReturn; -use crate::{prelude::*, util::read_bytes_from_user}; +use crate::prelude::*; pub fn sys_madvise(start: Vaddr, len: usize, behavior: i32) -> Result { let behavior = MadviseBehavior::try_from(behavior)?; @@ -15,7 +15,8 @@ pub fn sys_madvise(start: Vaddr, len: usize, behavior: i32) -> Result { // perform a read at first let mut buffer = vec![0u8; len]; - read_bytes_from_user(start, &mut VmWriter::from(buffer.as_mut_slice()))?; + CurrentUserSpace::get() + .read_bytes(start, &mut VmWriter::from(buffer.as_mut_slice()))?; } MadviseBehavior::MADV_DONTNEED => { warn!("MADV_DONTNEED isn't implemented, do nothing for now."); diff --git a/kernel/aster-nix/src/syscall/mkdir.rs b/kernel/aster-nix/src/syscall/mkdir.rs index 0ce77ba6d..9f6873a64 100644 --- a/kernel/aster-nix/src/syscall/mkdir.rs +++ b/kernel/aster-nix/src/syscall/mkdir.rs @@ -9,11 +9,10 @@ use crate::{ }, prelude::*, syscall::constants::MAX_FILENAME_LEN, - util::read_cstring_from_user, }; pub fn sys_mkdirat(dirfd: FileDesc, path_addr: Vaddr, mode: u16) -> Result { - let path = read_cstring_from_user(path_addr, MAX_FILENAME_LEN)?; + let path = CurrentUserSpace::get().read_cstring(path_addr, MAX_FILENAME_LEN)?; debug!("dirfd = {}, path = {:?}, mode = {}", dirfd, path, mode); let current = current!(); diff --git a/kernel/aster-nix/src/syscall/mknod.rs b/kernel/aster-nix/src/syscall/mknod.rs index 1dc2ae4a2..9009f4696 100644 --- a/kernel/aster-nix/src/syscall/mknod.rs +++ b/kernel/aster-nix/src/syscall/mknod.rs @@ -10,7 +10,6 @@ use crate::{ }, prelude::*, syscall::{constants::MAX_FILENAME_LEN, stat::FileType}, - util::read_cstring_from_user, }; pub fn sys_mknodat( @@ -19,7 +18,7 @@ pub fn sys_mknodat( mode: u16, dev: usize, ) -> Result { - let path = read_cstring_from_user(path_addr, MAX_FILENAME_LEN)?; + let path = CurrentUserSpace::get().read_cstring(path_addr, MAX_FILENAME_LEN)?; let current = current!(); let inode_mode = { let mask_mode = mode & !current.umask().read().get(); diff --git a/kernel/aster-nix/src/syscall/mount.rs b/kernel/aster-nix/src/syscall/mount.rs index 2b9dad552..45966d016 100644 --- a/kernel/aster-nix/src/syscall/mount.rs +++ b/kernel/aster-nix/src/syscall/mount.rs @@ -11,7 +11,6 @@ use crate::{ }, prelude::*, syscall::constants::MAX_FILENAME_LEN, - util::read_cstring_from_user, }; /// The `data` argument is interpreted by the different filesystems. @@ -25,8 +24,9 @@ pub fn sys_mount( flags: u64, data: Vaddr, ) -> Result { - let devname = read_cstring_from_user(devname_addr, MAX_FILENAME_LEN)?; - let dirname = read_cstring_from_user(dirname_addr, MAX_FILENAME_LEN)?; + let user_space = CurrentUserSpace::get(); + let devname = user_space.read_cstring(devname_addr, MAX_FILENAME_LEN)?; + let dirname = user_space.read_cstring(dirname_addr, MAX_FILENAME_LEN)?; let mount_flags = MountFlags::from_bits_truncate(flags as u32); debug!( "devname = {:?}, dirname = {:?}, fstype = 0x{:x}, flags = {:?}, data = 0x{:x}", @@ -133,7 +133,7 @@ fn do_new_mount(devname: CString, fs_type: Vaddr, target_dentry: Arc) -> return_errno_with_message!(Errno::ENOTDIR, "mountpoint must be directory"); }; - let fs_type = read_cstring_from_user(fs_type, MAX_FILENAME_LEN)?; + let fs_type = CurrentUserSpace::get().read_cstring(fs_type, MAX_FILENAME_LEN)?; if fs_type.is_empty() { return_errno_with_message!(Errno::EINVAL, "fs_type is empty"); } diff --git a/kernel/aster-nix/src/syscall/nanosleep.rs b/kernel/aster-nix/src/syscall/nanosleep.rs index 68749c204..ed880a4e3 100644 --- a/kernel/aster-nix/src/syscall/nanosleep.rs +++ b/kernel/aster-nix/src/syscall/nanosleep.rs @@ -7,7 +7,6 @@ use crate::{ prelude::*, process::signal::Pauser, time::{clockid_t, timespec_t, TIMER_ABSTIME}, - util::{read_val_from_user, write_val_to_user}, }; pub fn sys_nanosleep( @@ -53,7 +52,7 @@ fn do_clock_nanosleep( remain_timespec_addr: Vaddr, ) -> Result { let request_time = { - let timespec = read_val_from_user::(request_timespec_addr)?; + let timespec = CurrentUserSpace::get().read_val::(request_timespec_addr)?; Duration::try_from(timespec)? }; @@ -90,7 +89,7 @@ fn do_clock_nanosleep( if remain_timespec_addr != 0 && !is_abs_time { let remaining_duration = (start_time + timeout) - end_time; let remaining_timespec = timespec_t::from(remaining_duration); - write_val_to_user(remain_timespec_addr, &remaining_timespec)?; + CurrentUserSpace::get().write_val(remain_timespec_addr, &remaining_timespec)?; } return_errno_with_message!(Errno::EINTR, "sleep was interrupted"); diff --git a/kernel/aster-nix/src/syscall/open.rs b/kernel/aster-nix/src/syscall/open.rs index fab9da4c9..9d262a029 100644 --- a/kernel/aster-nix/src/syscall/open.rs +++ b/kernel/aster-nix/src/syscall/open.rs @@ -9,7 +9,6 @@ use crate::{ }, prelude::*, syscall::constants::MAX_FILENAME_LEN, - util::read_cstring_from_user, }; pub fn sys_openat( @@ -18,7 +17,7 @@ pub fn sys_openat( flags: u32, mode: u16, ) -> Result { - let path = read_cstring_from_user(path_addr, MAX_FILENAME_LEN)?; + let path = CurrentUserSpace::get().read_cstring(path_addr, MAX_FILENAME_LEN)?; debug!( "dirfd = {}, path = {:?}, flags = {}, mode = {}", dirfd, path, flags, mode diff --git a/kernel/aster-nix/src/syscall/pipe.rs b/kernel/aster-nix/src/syscall/pipe.rs index 56a60533a..50ba8d260 100644 --- a/kernel/aster-nix/src/syscall/pipe.rs +++ b/kernel/aster-nix/src/syscall/pipe.rs @@ -8,7 +8,6 @@ use crate::{ utils::{Channel, CreationFlags, StatusFlags}, }, prelude::*, - util::write_val_to_user, }; pub fn sys_pipe2(fds: Vaddr, flags: u32) -> Result { @@ -40,7 +39,7 @@ pub fn sys_pipe2(fds: Vaddr, flags: u32) -> Result { }; debug!("pipe_fds: {:?}", pipe_fds); - if let Err(err) = write_val_to_user(fds, &pipe_fds) { + if let Err(err) = CurrentUserSpace::get().write_val(fds, &pipe_fds) { file_table.close_file(pipe_fds.reader_fd).unwrap(); file_table.close_file(pipe_fds.writer_fd).unwrap(); return Err(err); diff --git a/kernel/aster-nix/src/syscall/poll.rs b/kernel/aster-nix/src/syscall/poll.rs index 266f6c652..392540572 100644 --- a/kernel/aster-nix/src/syscall/poll.rs +++ b/kernel/aster-nix/src/syscall/poll.rs @@ -3,20 +3,15 @@ use core::{cell::Cell, time::Duration}; use super::SyscallReturn; -use crate::{ - events::IoEvents, - fs::file_table::FileDesc, - prelude::*, - process::signal::Poller, - util::{read_val_from_user, write_val_to_user}, -}; +use crate::{events::IoEvents, fs::file_table::FileDesc, prelude::*, process::signal::Poller}; pub fn sys_poll(fds: Vaddr, nfds: u64, timeout: i32) -> Result { + let user_space = CurrentUserSpace::get(); let poll_fds = { let mut read_addr = fds; let mut poll_fds = Vec::with_capacity(nfds as _); for _ in 0..nfds { - let c_poll_fd = read_val_from_user::(read_addr)?; + let c_poll_fd = user_space.read_val::(read_addr)?; let poll_fd = PollFd::from(c_poll_fd); // Always clear the revents fields first poll_fd.revents().set(IoEvents::empty()); @@ -42,7 +37,7 @@ pub fn sys_poll(fds: Vaddr, nfds: u64, timeout: i32) -> Result { let mut write_addr = fds; for pollfd in poll_fds { let c_poll_fd = c_pollfd::from(pollfd); - write_val_to_user(write_addr, &c_poll_fd)?; + user_space.write_val(write_addr, &c_poll_fd)?; // FIXME: do we need to respect align of c_pollfd here? write_addr += core::mem::size_of::(); } diff --git a/kernel/aster-nix/src/syscall/prctl.rs b/kernel/aster-nix/src/syscall/prctl.rs index 6b854cbd2..c0e2a3253 100644 --- a/kernel/aster-nix/src/syscall/prctl.rs +++ b/kernel/aster-nix/src/syscall/prctl.rs @@ -10,7 +10,6 @@ use crate::{ posix_thread::{PosixThreadExt, MAX_THREAD_NAME_LEN}, signal::sig_num::SigNum, }, - util::{read_cstring_from_user, write_bytes_to_user, write_val_to_user}, }; pub fn sys_prctl(option: i32, arg2: u64, arg3: u64, arg4: u64, arg5: u64) -> Result { @@ -33,7 +32,7 @@ pub fn sys_prctl(option: i32, arg2: u64, arg3: u64, arg4: u64, arg5: u64) -> Res } }; - write_val_to_user(write_to_addr, &write_val)?; + CurrentUserSpace::get().write_val(write_to_addr, &write_val)?; } PrctlCmd::PR_GET_DUMPABLE => { // TODO: when coredump is supported, return the actual value @@ -50,7 +49,7 @@ pub fn sys_prctl(option: i32, arg2: u64, arg3: u64, arg4: u64, arg5: u64) -> Res let thread_name = posix_thread.thread_name().lock(); if let Some(thread_name) = &*thread_name { if let Some(thread_name) = thread_name.name()? { - write_bytes_to_user( + CurrentUserSpace::get().write_bytes( write_to_addr, &mut VmReader::from(thread_name.to_bytes_with_nul()), )?; @@ -60,7 +59,8 @@ pub fn sys_prctl(option: i32, arg2: u64, arg3: u64, arg4: u64, arg5: u64) -> Res PrctlCmd::PR_SET_NAME(read_addr) => { let mut thread_name = posix_thread.thread_name().lock(); if let Some(thread_name) = &mut *thread_name { - let new_thread_name = read_cstring_from_user(read_addr, MAX_THREAD_NAME_LEN)?; + let new_thread_name = + CurrentUserSpace::get().read_cstring(read_addr, MAX_THREAD_NAME_LEN)?; thread_name.set_name(&new_thread_name)?; } } diff --git a/kernel/aster-nix/src/syscall/pread64.rs b/kernel/aster-nix/src/syscall/pread64.rs index 31490a86b..a92e11cf9 100644 --- a/kernel/aster-nix/src/syscall/pread64.rs +++ b/kernel/aster-nix/src/syscall/pread64.rs @@ -1,7 +1,7 @@ // SPDX-License-Identifier: MPL-2.0 use super::SyscallReturn; -use crate::{fs::file_table::FileDesc, prelude::*, util::write_bytes_to_user}; +use crate::{fs::file_table::FileDesc, prelude::*}; pub fn sys_pread64( fd: FileDesc, @@ -33,7 +33,8 @@ pub fn sys_pread64( let read_len = { let mut buffer = vec![0u8; user_buf_len]; let read_len = file.read_at(offset as usize, &mut buffer)?; - write_bytes_to_user(user_buf_ptr, &mut VmReader::from(buffer.as_slice()))?; + CurrentUserSpace::get() + .write_bytes(user_buf_ptr, &mut VmReader::from(buffer.as_slice()))?; read_len }; diff --git a/kernel/aster-nix/src/syscall/prlimit64.rs b/kernel/aster-nix/src/syscall/prlimit64.rs index d626a9b85..a2b3b3467 100644 --- a/kernel/aster-nix/src/syscall/prlimit64.rs +++ b/kernel/aster-nix/src/syscall/prlimit64.rs @@ -4,7 +4,6 @@ use super::SyscallReturn; use crate::{ prelude::*, process::{Pid, ResourceType}, - util::{read_val_from_user, write_val_to_user}, }; pub fn sys_prlimit64( @@ -22,10 +21,10 @@ pub fn sys_prlimit64( let mut resource_limits = current.resource_limits().lock(); if old_rlim_addr != 0 { let rlimit = resource_limits.get_rlimit(resource); - write_val_to_user(old_rlim_addr, rlimit)?; + CurrentUserSpace::get().write_val(old_rlim_addr, rlimit)?; } if new_rlim_addr != 0 { - let new_rlimit = read_val_from_user(new_rlim_addr)?; + let new_rlimit = CurrentUserSpace::get().read_val(new_rlim_addr)?; *resource_limits.get_rlimit_mut(resource) = new_rlimit; } Ok(SyscallReturn::Return(0)) diff --git a/kernel/aster-nix/src/syscall/pselect6.rs b/kernel/aster-nix/src/syscall/pselect6.rs index 618e71ff4..67eff5da3 100644 --- a/kernel/aster-nix/src/syscall/pselect6.rs +++ b/kernel/aster-nix/src/syscall/pselect6.rs @@ -8,7 +8,6 @@ use crate::{ prelude::*, process::{posix_thread::PosixThreadExt, signal::sig_mask::SigMask}, time::timespec_t, - util::read_val_from_user, }; pub fn sys_pselect6( @@ -22,8 +21,9 @@ pub fn sys_pselect6( let current_thread = current_thread!(); let posix_thread = current_thread.as_posix_thread().unwrap(); + let user_space = CurrentUserSpace::get(); let old_simask = if sigmask_addr != 0 { - let sigmask_with_size: SigMaskWithSize = read_val_from_user(sigmask_addr)?; + let sigmask_with_size: SigMaskWithSize = user_space.read_val(sigmask_addr)?; if !sigmask_with_size.is_valid() { return_errno_with_message!(Errno::EINVAL, "sigmask size is invalid") @@ -38,7 +38,7 @@ pub fn sys_pselect6( }; let timeout = if timespec_addr != 0 { - let time_spec: timespec_t = read_val_from_user(timespec_addr)?; + let time_spec: timespec_t = user_space.read_val(timespec_addr)?; Some(Duration::try_from(time_spec)?) } else { None diff --git a/kernel/aster-nix/src/syscall/pwrite64.rs b/kernel/aster-nix/src/syscall/pwrite64.rs index bf795ebf4..898dc3039 100644 --- a/kernel/aster-nix/src/syscall/pwrite64.rs +++ b/kernel/aster-nix/src/syscall/pwrite64.rs @@ -1,7 +1,7 @@ // SPDX-License-Identifier: MPL-2.0 use super::SyscallReturn; -use crate::{fs::file_table::FileDesc, prelude::*, util::read_bytes_from_user}; +use crate::{fs::file_table::FileDesc, prelude::*}; pub fn sys_pwrite64( fd: FileDesc, @@ -30,7 +30,7 @@ pub fn sys_pwrite64( } let mut buffer = vec![0u8; user_buf_len]; - read_bytes_from_user(user_buf_ptr, &mut VmWriter::from(buffer.as_mut_slice()))?; + CurrentUserSpace::get().read_bytes(user_buf_ptr, &mut VmWriter::from(buffer.as_mut_slice()))?; let write_len = file.write_at(offset as _, &buffer)?; Ok(SyscallReturn::Return(write_len as _)) } diff --git a/kernel/aster-nix/src/syscall/read.rs b/kernel/aster-nix/src/syscall/read.rs index 062d536e7..8aee12210 100644 --- a/kernel/aster-nix/src/syscall/read.rs +++ b/kernel/aster-nix/src/syscall/read.rs @@ -3,7 +3,7 @@ use core::cmp::min; use super::SyscallReturn; -use crate::{fs::file_table::FileDesc, prelude::*, util::write_bytes_to_user}; +use crate::{fs::file_table::FileDesc, prelude::*}; pub fn sys_read(fd: FileDesc, user_buf_addr: Vaddr, buf_len: usize) -> Result { debug!( @@ -23,7 +23,7 @@ pub fn sys_read(fd: FileDesc, user_buf_addr: Vaddr, buf_len: usize) -> Result Result { - let path = read_cstring_from_user(path_addr, MAX_FILENAME_LEN)?; + let user_space = CurrentUserSpace::get(); + let path = user_space.read_cstring(path_addr, MAX_FILENAME_LEN)?; debug!( "dirfd = {}, path = {:?}, usr_buf_addr = 0x{:x}, usr_buf_len = 0x{:x}", dirfd, path, usr_buf_addr, usr_buf_len @@ -35,7 +35,7 @@ pub fn sys_readlinkat( let linkpath = dentry.inode().read_link()?; let bytes = linkpath.as_bytes(); let write_len = bytes.len().min(usr_buf_len); - write_bytes_to_user(usr_buf_addr, &mut VmReader::from(&bytes[..write_len]))?; + user_space.write_bytes(usr_buf_addr, &mut VmReader::from(&bytes[..write_len]))?; Ok(SyscallReturn::Return(write_len as _)) } diff --git a/kernel/aster-nix/src/syscall/recvmsg.rs b/kernel/aster-nix/src/syscall/recvmsg.rs index 21b1f8feb..8592d7d34 100644 --- a/kernel/aster-nix/src/syscall/recvmsg.rs +++ b/kernel/aster-nix/src/syscall/recvmsg.rs @@ -5,14 +5,11 @@ use crate::{ fs::file_table::FileDesc, net::socket::SendRecvFlags, prelude::*, - util::{ - net::{get_socket_from_fd, CUserMsgHdr}, - read_val_from_user, - }, + util::net::{get_socket_from_fd, CUserMsgHdr}, }; pub fn sys_recvmsg(sockfd: FileDesc, user_msghdr_ptr: Vaddr, flags: i32) -> Result { - let c_user_msghdr: CUserMsgHdr = read_val_from_user(user_msghdr_ptr)?; + let c_user_msghdr: CUserMsgHdr = CurrentUserSpace::get().read_val(user_msghdr_ptr)?; let flags = SendRecvFlags::from_bits_truncate(flags); debug!( diff --git a/kernel/aster-nix/src/syscall/rename.rs b/kernel/aster-nix/src/syscall/rename.rs index 0271e8c73..7f7905d33 100644 --- a/kernel/aster-nix/src/syscall/rename.rs +++ b/kernel/aster-nix/src/syscall/rename.rs @@ -9,7 +9,6 @@ use crate::{ }, prelude::*, syscall::constants::MAX_FILENAME_LEN, - util::read_cstring_from_user, }; pub fn sys_renameat( @@ -18,8 +17,9 @@ pub fn sys_renameat( new_dirfd: FileDesc, new_path_addr: Vaddr, ) -> Result { - let old_path = read_cstring_from_user(old_path_addr, MAX_FILENAME_LEN)?; - let new_path = read_cstring_from_user(new_path_addr, MAX_FILENAME_LEN)?; + let user_space = CurrentUserSpace::get(); + let old_path = user_space.read_cstring(old_path_addr, MAX_FILENAME_LEN)?; + let new_path = user_space.read_cstring(new_path_addr, MAX_FILENAME_LEN)?; debug!( "old_dirfd = {}, old_path = {:?}, new_dirfd = {}, new_path = {:?}", old_dirfd, old_path, new_dirfd, new_path diff --git a/kernel/aster-nix/src/syscall/rmdir.rs b/kernel/aster-nix/src/syscall/rmdir.rs index c2faba2fa..204e7a62b 100644 --- a/kernel/aster-nix/src/syscall/rmdir.rs +++ b/kernel/aster-nix/src/syscall/rmdir.rs @@ -8,7 +8,6 @@ use crate::{ }, prelude::*, syscall::constants::MAX_FILENAME_LEN, - util::read_cstring_from_user, }; pub fn sys_rmdir(path_addr: Vaddr) -> Result { @@ -16,7 +15,7 @@ pub fn sys_rmdir(path_addr: Vaddr) -> Result { } pub(super) fn sys_rmdirat(dirfd: FileDesc, path_addr: Vaddr) -> Result { - let path_addr = read_cstring_from_user(path_addr, MAX_FILENAME_LEN)?; + let path_addr = CurrentUserSpace::get().read_cstring(path_addr, MAX_FILENAME_LEN)?; debug!("dirfd = {}, path_addr = {:?}", dirfd, path_addr); let current = current!(); diff --git a/kernel/aster-nix/src/syscall/rt_sigaction.rs b/kernel/aster-nix/src/syscall/rt_sigaction.rs index 4fcf83fd4..0dfed7e58 100644 --- a/kernel/aster-nix/src/syscall/rt_sigaction.rs +++ b/kernel/aster-nix/src/syscall/rt_sigaction.rs @@ -4,7 +4,6 @@ use super::SyscallReturn; use crate::{ prelude::*, process::signal::{c_types::sigaction_t, sig_action::SigAction, sig_num::SigNum}, - util::{read_val_from_user, write_val_to_user}, }; pub fn sys_rt_sigaction( @@ -26,10 +25,10 @@ pub fn sys_rt_sigaction( let old_action = sig_dispositions.get(sig_num); let old_action_c = old_action.as_c_type(); if old_sig_action_addr != 0 { - write_val_to_user(old_sig_action_addr, &old_action_c)?; + CurrentUserSpace::get().write_val(old_sig_action_addr, &old_action_c)?; } if sig_action_addr != 0 { - let sig_action_c = read_val_from_user::(sig_action_addr)?; + let sig_action_c = CurrentUserSpace::get().read_val::(sig_action_addr)?; let sig_action = SigAction::try_from(sig_action_c).unwrap(); trace!("sig action = {:?}", sig_action); sig_dispositions.set(sig_num, sig_action); diff --git a/kernel/aster-nix/src/syscall/rt_sigpending.rs b/kernel/aster-nix/src/syscall/rt_sigpending.rs index d6f2f929e..d017a434f 100644 --- a/kernel/aster-nix/src/syscall/rt_sigpending.rs +++ b/kernel/aster-nix/src/syscall/rt_sigpending.rs @@ -3,7 +3,7 @@ use core::sync::atomic::Ordering; use super::SyscallReturn; -use crate::{prelude::*, process::posix_thread::PosixThreadExt, util::write_val_to_user}; +use crate::{prelude::*, process::posix_thread::PosixThreadExt}; pub fn sys_rt_sigpending(u_set_ptr: Vaddr, sigset_size: usize) -> Result { debug!( @@ -27,6 +27,6 @@ fn do_rt_sigpending(set_ptr: Vaddr) -> Result<()> { sig_mask_value & sig_pending_value }; - write_val_to_user(set_ptr, &u64::from(combined_signals))?; + CurrentUserSpace::get().write_val(set_ptr, &u64::from(combined_signals))?; Ok(()) } diff --git a/kernel/aster-nix/src/syscall/rt_sigprocmask.rs b/kernel/aster-nix/src/syscall/rt_sigprocmask.rs index 81f429940..dd21e4051 100644 --- a/kernel/aster-nix/src/syscall/rt_sigprocmask.rs +++ b/kernel/aster-nix/src/syscall/rt_sigprocmask.rs @@ -12,7 +12,6 @@ use crate::{ sig_mask::SigMask, }, }, - util::{read_val_from_user, write_val_to_user}, }; pub fn sys_rt_sigprocmask( @@ -40,12 +39,12 @@ fn do_rt_sigprocmask(mask_op: MaskOp, set_ptr: Vaddr, oldset_ptr: Vaddr) -> Resu let old_sig_mask_value = posix_thread.sig_mask().load(Ordering::Relaxed); debug!("old sig mask value: 0x{:x}", old_sig_mask_value); if oldset_ptr != 0 { - write_val_to_user(oldset_ptr, &old_sig_mask_value)?; + CurrentUserSpace::get().write_val(oldset_ptr, &old_sig_mask_value)?; } let sig_mask_ref = posix_thread.sig_mask(); if set_ptr != 0 { - let mut read_mask = read_val_from_user::(set_ptr)?; + let mut read_mask = CurrentUserSpace::get().read_val::(set_ptr)?; match mask_op { MaskOp::Block => { // According to man pages, "it is not possible to block SIGKILL or SIGSTOP. diff --git a/kernel/aster-nix/src/syscall/rt_sigreturn.rs b/kernel/aster-nix/src/syscall/rt_sigreturn.rs index a4233826e..bd3701571 100644 --- a/kernel/aster-nix/src/syscall/rt_sigreturn.rs +++ b/kernel/aster-nix/src/syscall/rt_sigreturn.rs @@ -8,7 +8,6 @@ use super::SyscallReturn; use crate::{ prelude::*, process::{posix_thread::PosixThreadExt, signal::c_types::ucontext_t}, - util::read_val_from_user, }; pub fn sys_rt_sigreturn(context: &mut UserContext) -> Result { @@ -24,7 +23,7 @@ pub fn sys_rt_sigreturn(context: &mut UserContext) -> Result { // However, for most glibc applications, the restorer codes is provided by glibc and RESTORER flag is set. debug_assert!(sig_context_addr == context.stack_pointer() as Vaddr); - let ucontext = read_val_from_user::(sig_context_addr)?; + let ucontext = CurrentUserSpace::get().read_val::(sig_context_addr)?; // If the sig stack is active and used by current handler, decrease handler counter. if let Some(sig_stack) = posix_thread.sig_stack().lock().as_mut() { diff --git a/kernel/aster-nix/src/syscall/rt_sigsuspend.rs b/kernel/aster-nix/src/syscall/rt_sigsuspend.rs index 5804d74a4..273593f99 100644 --- a/kernel/aster-nix/src/syscall/rt_sigsuspend.rs +++ b/kernel/aster-nix/src/syscall/rt_sigsuspend.rs @@ -8,7 +8,6 @@ use crate::{ sig_mask::SigMask, Pauser, }, - util::read_val_from_user, }; pub fn sys_rt_sigsuspend(sigmask_addr: Vaddr, sigmask_size: usize) -> Result { @@ -23,7 +22,7 @@ pub fn sys_rt_sigsuspend(sigmask_addr: Vaddr, sigmask_size: usize) -> Result usize { @@ -41,7 +40,7 @@ pub fn sys_sched_getaffinity( let dummy_cpu_set = cpu_set_t::new(num_cpus); - write_val_to_user(cpu_set_ptr, &dummy_cpu_set)?; + CurrentUserSpace::get().write_val(cpu_set_ptr, &dummy_cpu_set)?; Ok(SyscallReturn::Return(0)) } diff --git a/kernel/aster-nix/src/syscall/select.rs b/kernel/aster-nix/src/syscall/select.rs index 4b16e0652..85cdf1573 100644 --- a/kernel/aster-nix/src/syscall/select.rs +++ b/kernel/aster-nix/src/syscall/select.rs @@ -8,13 +8,7 @@ use super::{ poll::{do_poll, PollFd}, SyscallReturn, }; -use crate::{ - events::IoEvents, - fs::file_table::FileDesc, - prelude::*, - time::timeval_t, - util::{read_val_from_user, write_val_to_user}, -}; +use crate::{events::IoEvents, fs::file_table::FileDesc, prelude::*, time::timeval_t}; pub fn sys_select( nfds: FileDesc, @@ -26,7 +20,7 @@ pub fn sys_select( let timeout = if timeval_addr == 0 { None } else { - let timeval = read_val_from_user::(timeval_addr)?; + let timeval = CurrentUserSpace::get().read_val::(timeval_addr)?; Some(Duration::from(timeval)) }; @@ -44,11 +38,12 @@ pub fn do_sys_select( return_errno_with_message!(Errno::EINVAL, "nfds is negative or exceeds the FD_SETSIZE"); } + let user_space = CurrentUserSpace::get(); let get_fdset = |fdset_addr: Vaddr| -> Result> { let fdset = if fdset_addr == 0 { None } else { - let fdset = read_val_from_user::(fdset_addr)?; + let fdset = user_space.read_val::(fdset_addr)?; Some(fdset) }; Ok(fdset) @@ -78,7 +73,7 @@ pub fn do_sys_select( let set_fdset = |fdset_addr: Vaddr, fdset: Option| -> Result<()> { if let Some(fdset) = fdset { debug_assert!(fdset_addr != 0); - write_val_to_user(fdset_addr, &fdset)?; + user_space.write_val(fdset_addr, &fdset)?; } Ok(()) }; diff --git a/kernel/aster-nix/src/syscall/sendfile.rs b/kernel/aster-nix/src/syscall/sendfile.rs index 0ab0a03af..8f2a2bce8 100644 --- a/kernel/aster-nix/src/syscall/sendfile.rs +++ b/kernel/aster-nix/src/syscall/sendfile.rs @@ -1,11 +1,7 @@ // SPDX-License-Identifier: MPL-2.0 use super::SyscallReturn; -use crate::{ - fs::file_table::FileDesc, - prelude::*, - util::{read_val_from_user, write_val_to_user}, -}; +use crate::{fs::file_table::FileDesc, prelude::*}; pub fn sys_sendfile( out_fd: FileDesc, @@ -18,7 +14,7 @@ pub fn sys_sendfile( let offset = if offset_ptr == 0 { None } else { - let offset: isize = read_val_from_user(offset_ptr)?; + let offset: isize = CurrentUserSpace::get().read_val(offset_ptr)?; if offset < 0 { return_errno_with_message!(Errno::EINVAL, "offset cannot be negative"); } @@ -113,7 +109,7 @@ pub fn sys_sendfile( } if let Some(offset) = offset { - write_val_to_user(offset_ptr, &(offset as isize))?; + CurrentUserSpace::get().write_val(offset_ptr, &(offset as isize))?; } Ok(SyscallReturn::Return(total_len as _)) diff --git a/kernel/aster-nix/src/syscall/sendmsg.rs b/kernel/aster-nix/src/syscall/sendmsg.rs index 47276b472..11f71a2d7 100644 --- a/kernel/aster-nix/src/syscall/sendmsg.rs +++ b/kernel/aster-nix/src/syscall/sendmsg.rs @@ -5,14 +5,11 @@ use crate::{ fs::file_table::FileDesc, net::socket::{MessageHeader, SendRecvFlags}, prelude::*, - util::{ - net::{get_socket_from_fd, CUserMsgHdr}, - read_val_from_user, - }, + util::net::{get_socket_from_fd, CUserMsgHdr}, }; pub fn sys_sendmsg(sockfd: FileDesc, user_msghdr_ptr: Vaddr, flags: i32) -> Result { - let c_user_msghdr: CUserMsgHdr = read_val_from_user(user_msghdr_ptr)?; + let c_user_msghdr: CUserMsgHdr = CurrentUserSpace::get().read_val(user_msghdr_ptr)?; let flags = SendRecvFlags::from_bits_truncate(flags); debug!( diff --git a/kernel/aster-nix/src/syscall/set_robust_list.rs b/kernel/aster-nix/src/syscall/set_robust_list.rs index 0137e8ff0..1e1ba33f6 100644 --- a/kernel/aster-nix/src/syscall/set_robust_list.rs +++ b/kernel/aster-nix/src/syscall/set_robust_list.rs @@ -4,7 +4,6 @@ use super::SyscallReturn; use crate::{ prelude::*, process::posix_thread::{PosixThreadExt, RobustListHead}, - util::read_val_from_user, }; pub fn sys_set_robust_list(robust_list_head_ptr: Vaddr, len: usize) -> Result { @@ -18,7 +17,8 @@ pub fn sys_set_robust_list(robust_list_head_ptr: Vaddr, len: usize) -> Result Result { @@ -19,7 +18,7 @@ pub fn sys_setgroups(size: usize, group_list_addr: Vaddr) -> Result(); - let gid = read_val_from_user(addr)?; + let gid = CurrentUserSpace::get().read_val(addr)?; new_groups.insert(gid); } diff --git a/kernel/aster-nix/src/syscall/setitimer.rs b/kernel/aster-nix/src/syscall/setitimer.rs index 2c2351008..08ff63bbe 100644 --- a/kernel/aster-nix/src/syscall/setitimer.rs +++ b/kernel/aster-nix/src/syscall/setitimer.rs @@ -7,7 +7,6 @@ use super::SyscallReturn; use crate::{ prelude::*, time::{itimerval_t, timer::Timeout, timeval_t}, - util::{read_val_from_user, write_val_to_user}, }; /// `ItimerType` is used to differ the target timer for some timer-related syscalls. @@ -33,7 +32,8 @@ pub fn sys_setitimer( return_errno_with_message!(Errno::EINVAL, "invalid pointer to new value"); } let current = current!(); - let new_itimerval = read_val_from_user::(new_itimerval_addr)?; + let user_space = CurrentUserSpace::get(); + let new_itimerval = user_space.read_val::(new_itimerval_addr)?; let interval = Duration::from(new_itimerval.it_interval); let expire_time = Duration::from(new_itimerval.it_value); @@ -51,7 +51,7 @@ pub fn sys_setitimer( it_interval: old_interval, it_value: remain, }; - write_val_to_user(old_itimerval_addr, &old_itimerval)?; + user_space.write_val(old_itimerval_addr, &old_itimerval)?; } timer.set_interval(interval); @@ -89,7 +89,7 @@ pub fn sys_getitimer(itimer_type: i32, itimerval_addr: Vaddr) -> Result Result { @@ -43,7 +42,7 @@ fn get_old_stack(old_sig_stack_addr: Vaddr, old_stack: Option<&SigStack>) -> Res debug!("old stack = {:?}", old_stack); let stack = stack_t::from(old_stack.clone()); - write_val_to_user(old_sig_stack_addr, &stack) + CurrentUserSpace::get().write_val(old_sig_stack_addr, &stack) } fn set_new_stack(sig_stack_addr: Vaddr, old_stack: Option<&SigStack>) -> Result<()> { @@ -58,7 +57,7 @@ fn set_new_stack(sig_stack_addr: Vaddr, old_stack: Option<&SigStack>) -> Result< } let new_stack = { - let stack = read_val_from_user::(sig_stack_addr)?; + let stack = CurrentUserSpace::get().read_val::(sig_stack_addr)?; SigStack::try_from(stack)? }; diff --git a/kernel/aster-nix/src/syscall/socketpair.rs b/kernel/aster-nix/src/syscall/socketpair.rs index 8bbb8dba2..0a92ea6f1 100644 --- a/kernel/aster-nix/src/syscall/socketpair.rs +++ b/kernel/aster-nix/src/syscall/socketpair.rs @@ -5,10 +5,7 @@ use crate::{ fs::file_table::{FdFlags, FileDesc}, net::socket::unix::UnixStreamSocket, prelude::*, - util::{ - net::{CSocketAddrFamily, Protocol, SockFlags, SockType, SOCK_TYPE_MASK}, - write_val_to_user, - }, + util::net::{CSocketAddrFamily, Protocol, SockFlags, SockType, SOCK_TYPE_MASK}, }; pub fn sys_socketpair(domain: i32, type_: i32, protocol: i32, sv: Vaddr) -> Result { @@ -46,7 +43,7 @@ pub fn sys_socketpair(domain: i32, type_: i32, protocol: i32, sv: Vaddr) -> Resu SocketFds(fd_a, fd_b) }; - write_val_to_user(sv, &socket_fds)?; + CurrentUserSpace::get().write_val(sv, &socket_fds)?; Ok(SyscallReturn::Return(0)) } diff --git a/kernel/aster-nix/src/syscall/stat.rs b/kernel/aster-nix/src/syscall/stat.rs index a7b9c1b50..5c7a817b3 100644 --- a/kernel/aster-nix/src/syscall/stat.rs +++ b/kernel/aster-nix/src/syscall/stat.rs @@ -12,7 +12,6 @@ use crate::{ prelude::*, syscall::constants::MAX_FILENAME_LEN, time::timespec_t, - util::{read_cstring_from_user, write_val_to_user}, }; pub fn sys_fstat(fd: FileDesc, stat_buf_ptr: Vaddr) -> Result { @@ -22,7 +21,7 @@ pub fn sys_fstat(fd: FileDesc, stat_buf_ptr: Vaddr) -> Result { let file_table = current.file_table().lock(); let file = file_table.get_file(fd)?; let stat = Stat::from(file.metadata()); - write_val_to_user(stat_buf_ptr, &stat)?; + CurrentUserSpace::get().write_val(stat_buf_ptr, &stat)?; Ok(SyscallReturn::Return(0)) } @@ -45,7 +44,8 @@ pub fn sys_fstatat( stat_buf_ptr: Vaddr, flags: u32, ) -> Result { - let filename = read_cstring_from_user(filename_ptr, MAX_FILENAME_LEN)?; + let user_space = CurrentUserSpace::get(); + let filename = user_space.read_cstring(filename_ptr, MAX_FILENAME_LEN)?; let flags = StatFlags::from_bits(flags).ok_or(Error::with_message(Errno::EINVAL, "invalid flags"))?; debug!( @@ -73,7 +73,7 @@ pub fn sys_fstatat( } }; let stat = Stat::from(dentry.metadata()); - write_val_to_user(stat_buf_ptr, &stat)?; + user_space.write_val(stat_buf_ptr, &stat)?; Ok(SyscallReturn::Return(0)) } diff --git a/kernel/aster-nix/src/syscall/statfs.rs b/kernel/aster-nix/src/syscall/statfs.rs index c2a6952b3..1a6b1a6d2 100644 --- a/kernel/aster-nix/src/syscall/statfs.rs +++ b/kernel/aster-nix/src/syscall/statfs.rs @@ -9,11 +9,11 @@ use crate::{ utils::{SuperBlock, PATH_MAX}, }, prelude::*, - util::{read_cstring_from_user, write_val_to_user}, }; pub fn sys_statfs(path_ptr: Vaddr, statfs_buf_ptr: Vaddr) -> Result { - let path = read_cstring_from_user(path_ptr, PATH_MAX)?; + let user_space = CurrentUserSpace::get(); + let path = user_space.read_cstring(path_ptr, PATH_MAX)?; debug!("path = {:?}, statfs_buf_ptr = 0x{:x}", path, statfs_buf_ptr,); let current = current!(); @@ -23,7 +23,7 @@ pub fn sys_statfs(path_ptr: Vaddr, statfs_buf_ptr: Vaddr) -> Result Result .ok_or(Error::with_message(Errno::EBADF, "not inode"))?; let dentry = inode_handle.dentry(); let statfs = Statfs::from(dentry.fs().sb()); - write_val_to_user(statfs_buf_ptr, &statfs)?; + CurrentUserSpace::get().write_val(statfs_buf_ptr, &statfs)?; Ok(SyscallReturn::Return(0)) } diff --git a/kernel/aster-nix/src/syscall/symlink.rs b/kernel/aster-nix/src/syscall/symlink.rs index b483ef1d5..3f9357271 100644 --- a/kernel/aster-nix/src/syscall/symlink.rs +++ b/kernel/aster-nix/src/syscall/symlink.rs @@ -9,7 +9,6 @@ use crate::{ }, prelude::*, syscall::constants::MAX_FILENAME_LEN, - util::read_cstring_from_user, }; pub fn sys_symlinkat( @@ -17,8 +16,9 @@ pub fn sys_symlinkat( dirfd: FileDesc, linkpath_addr: Vaddr, ) -> Result { - let target = read_cstring_from_user(target_addr, MAX_FILENAME_LEN)?; - let linkpath = read_cstring_from_user(linkpath_addr, MAX_FILENAME_LEN)?; + let user_space = CurrentUserSpace::get(); + let target = user_space.read_cstring(target_addr, MAX_FILENAME_LEN)?; + let linkpath = user_space.read_cstring(linkpath_addr, MAX_FILENAME_LEN)?; debug!( "target = {:?}, dirfd = {}, linkpath = {:?}", target, dirfd, linkpath diff --git a/kernel/aster-nix/src/syscall/time.rs b/kernel/aster-nix/src/syscall/time.rs index fa5567fcb..1c10b0d60 100644 --- a/kernel/aster-nix/src/syscall/time.rs +++ b/kernel/aster-nix/src/syscall/time.rs @@ -1,7 +1,7 @@ // SPDX-License-Identifier: MPL-2.0 use super::SyscallReturn; -use crate::{prelude::*, time::SystemTime, util::write_val_to_user}; +use crate::{prelude::*, time::SystemTime}; pub fn sys_time(tloc: Vaddr) -> Result { debug!("tloc = 0x{tloc:x}"); @@ -12,7 +12,7 @@ pub fn sys_time(tloc: Vaddr) -> Result { }; if tloc != 0 { - write_val_to_user(tloc, &now_as_secs)?; + CurrentUserSpace::get().write_val(tloc, &now_as_secs)?; } Ok(SyscallReturn::Return(now_as_secs as _)) diff --git a/kernel/aster-nix/src/syscall/timer_create.rs b/kernel/aster-nix/src/syscall/timer_create.rs index da03146c3..38be5c7bb 100644 --- a/kernel/aster-nix/src/syscall/timer_create.rs +++ b/kernel/aster-nix/src/syscall/timer_create.rs @@ -25,7 +25,6 @@ use crate::{ clockid_t, clocks::{BootTimeClock, MonotonicClock, RealTimeClock}, }, - util::{read_val_from_user, write_val_to_user}, }; pub fn sys_timer_create( @@ -51,7 +50,7 @@ pub fn sys_timer_create( }) // Determine the timeout action through `sigevent`. } else { - let sig_event = read_val_from_user::(sigevent_addr)?; + let sig_event = CurrentUserSpace::get().read_val::(sigevent_addr)?; let sigev_notify = SigNotify::try_from(sig_event.sigev_notify)?; let signo = sig_event.sigev_signo; match sigev_notify { @@ -152,7 +151,7 @@ pub fn sys_timer_create( }; let timer_id = process_timer_manager.add_posix_timer(timer); - write_val_to_user(timer_id_addr, &timer_id)?; + CurrentUserSpace::get().write_val(timer_id_addr, &timer_id)?; Ok(SyscallReturn::Return(0)) } diff --git a/kernel/aster-nix/src/syscall/timer_settime.rs b/kernel/aster-nix/src/syscall/timer_settime.rs index 2932e97b3..468c54277 100644 --- a/kernel/aster-nix/src/syscall/timer_settime.rs +++ b/kernel/aster-nix/src/syscall/timer_settime.rs @@ -6,7 +6,6 @@ use super::SyscallReturn; use crate::{ prelude::*, time::{itimerspec_t, timer::Timeout, timespec_t, TIMER_ABSTIME}, - util::{read_val_from_user, write_val_to_user}, }; pub fn sys_timer_settime( @@ -19,7 +18,8 @@ pub fn sys_timer_settime( return_errno_with_message!(Errno::EINVAL, "invalid pointer to new value"); } - let new_itimerspec = read_val_from_user::(new_itimerspec_addr)?; + let user_space = CurrentUserSpace::get(); + let new_itimerspec = user_space.read_val::(new_itimerspec_addr)?; let interval = Duration::try_from(new_itimerspec.it_interval)?; let expire_time = Duration::try_from(new_itimerspec.it_value)?; @@ -35,7 +35,7 @@ pub fn sys_timer_settime( it_interval: old_interval, it_value: remain, }; - write_val_to_user(old_itimerspec_addr, &old_itimerspec)?; + user_space.write_val(old_itimerspec_addr, &old_itimerspec)?; } timer.set_interval(interval); @@ -71,7 +71,7 @@ pub fn sys_timer_gettime(timer_id: usize, itimerspec_addr: Vaddr) -> Result Result { @@ -25,7 +24,7 @@ pub fn sys_ftruncate(fd: FileDesc, len: isize) -> Result { } pub fn sys_truncate(path_ptr: Vaddr, len: isize) -> Result { - let path = read_cstring_from_user(path_ptr, PATH_MAX)?; + let path = CurrentUserSpace::get().read_cstring(path_ptr, PATH_MAX)?; debug!("path = {:?}, length = {}", path, len); check_length(len)?; diff --git a/kernel/aster-nix/src/syscall/umount.rs b/kernel/aster-nix/src/syscall/umount.rs index 089e4467f..7f65fc61f 100644 --- a/kernel/aster-nix/src/syscall/umount.rs +++ b/kernel/aster-nix/src/syscall/umount.rs @@ -5,11 +5,10 @@ use crate::{ fs::fs_resolver::{FsPath, AT_FDCWD}, prelude::*, syscall::constants::MAX_FILENAME_LEN, - util::read_cstring_from_user, }; pub fn sys_umount(path_addr: Vaddr, flags: u64) -> Result { - let path = read_cstring_from_user(path_addr, MAX_FILENAME_LEN)?; + let path = CurrentUserSpace::get().read_cstring(path_addr, MAX_FILENAME_LEN)?; let umount_flags = UmountFlags::from_bits_truncate(flags as u32); debug!("path = {:?}, flags = {:?}", path, umount_flags); diff --git a/kernel/aster-nix/src/syscall/uname.rs b/kernel/aster-nix/src/syscall/uname.rs index 863d94529..41e2dbd75 100644 --- a/kernel/aster-nix/src/syscall/uname.rs +++ b/kernel/aster-nix/src/syscall/uname.rs @@ -1,7 +1,7 @@ // SPDX-License-Identifier: MPL-2.0 use super::SyscallReturn; -use crate::{prelude::*, util::write_val_to_user}; +use crate::prelude::*; // We don't use the real name and version of our os here. Instead, we pick up fake values witch is the same as the ones of linux. // The values are used to fool glibc since glibc will check the version and os name. @@ -59,6 +59,6 @@ fn copy_cstring_to_u8_slice(src: &CStr, dst: &mut [u8]) { pub fn sys_uname(old_uname_addr: Vaddr) -> Result { debug!("old uname addr = 0x{:x}", old_uname_addr); - write_val_to_user(old_uname_addr, &*UTS_NAME)?; + CurrentUserSpace::get().write_val(old_uname_addr, &*UTS_NAME)?; Ok(SyscallReturn::Return(0)) } diff --git a/kernel/aster-nix/src/syscall/unlink.rs b/kernel/aster-nix/src/syscall/unlink.rs index 7d6a14813..b40428768 100644 --- a/kernel/aster-nix/src/syscall/unlink.rs +++ b/kernel/aster-nix/src/syscall/unlink.rs @@ -8,7 +8,6 @@ use crate::{ }, prelude::*, syscall::constants::MAX_FILENAME_LEN, - util::read_cstring_from_user, }; pub fn sys_unlinkat(dirfd: FileDesc, path_addr: Vaddr, flags: u32) -> Result { @@ -18,7 +17,7 @@ pub fn sys_unlinkat(dirfd: FileDesc, path_addr: Vaddr, flags: u32) -> Result Result(utimbuf_ptr)?; + let utimbuf = CurrentUserSpace::get().read_val::(utimbuf_ptr)?; let atime = timespec_t { sec: utimbuf.actime, nsec: 0, @@ -158,7 +157,7 @@ fn do_utimes( let pathname = if pathname_ptr == 0 { String::new() } else { - let cstring = read_cstring_from_user(pathname_ptr, MAX_FILENAME_LEN)?; + let cstring = CurrentUserSpace::get().read_cstring(pathname_ptr, MAX_FILENAME_LEN)?; cstring.to_string_lossy().into_owned() }; let current = current!(); @@ -197,9 +196,10 @@ fn do_futimesat(dirfd: FileDesc, pathname_ptr: Vaddr, timeval_ptr: Vaddr) -> Res fn read_time_from_user(time_ptr: Vaddr) -> Result<(T, T)> { let mut time_addr = time_ptr; - let autime = read_val_from_user::(time_addr)?; + let user_space = CurrentUserSpace::get(); + let autime = user_space.read_val::(time_addr)?; time_addr += core::mem::size_of::(); - let mutime = read_val_from_user::(time_addr)?; + let mutime = user_space.read_val::(time_addr)?; Ok((autime, mutime)) } diff --git a/kernel/aster-nix/src/syscall/wait4.rs b/kernel/aster-nix/src/syscall/wait4.rs index ba5fde989..f823756a8 100644 --- a/kernel/aster-nix/src/syscall/wait4.rs +++ b/kernel/aster-nix/src/syscall/wait4.rs @@ -4,7 +4,6 @@ use super::{getrusage::rusage_t, SyscallReturn}; use crate::{ prelude::*, process::{wait_child_exit, ProcessFilter, WaitOptions}, - util::write_val_to_user, }; pub fn sys_wait4( @@ -29,7 +28,7 @@ pub fn sys_wait4( let (return_pid, exit_code) = (process.pid(), process.exit_code().unwrap()); if exit_status_ptr != 0 { - write_val_to_user(exit_status_ptr as _, &exit_code)?; + CurrentUserSpace::get().write_val(exit_status_ptr as _, &exit_code)?; } if rusage_addr != 0 { @@ -39,7 +38,7 @@ pub fn sys_wait4( ..Default::default() }; - write_val_to_user(rusage_addr, &rusage)?; + CurrentUserSpace::get().write_val(rusage_addr, &rusage)?; } Ok(SyscallReturn::Return(return_pid as _)) diff --git a/kernel/aster-nix/src/syscall/write.rs b/kernel/aster-nix/src/syscall/write.rs index bcb5fb17f..c7f1722d8 100644 --- a/kernel/aster-nix/src/syscall/write.rs +++ b/kernel/aster-nix/src/syscall/write.rs @@ -3,7 +3,7 @@ #![allow(dead_code)] use super::SyscallReturn; -use crate::{fs::file_table::FileDesc, prelude::*, util::read_bytes_from_user}; +use crate::{fs::file_table::FileDesc, prelude::*}; const STDOUT: u64 = 1; const STDERR: u64 = 2; @@ -25,7 +25,8 @@ pub fn sys_write(fd: FileDesc, user_buf_ptr: Vaddr, user_buf_len: usize) -> Resu // the file discriptor. If no errors detected, return 0 successfully. let write_len = if user_buf_len != 0 { let mut buffer = vec![0u8; user_buf_len]; - read_bytes_from_user(user_buf_ptr, &mut VmWriter::from(buffer.as_mut_slice()))?; + CurrentUserSpace::get() + .read_bytes(user_buf_ptr, &mut VmWriter::from(buffer.as_mut_slice()))?; debug!("write content = {:?}", buffer); file.write(&buffer)? } else { diff --git a/kernel/aster-nix/src/util/iovec.rs b/kernel/aster-nix/src/util/iovec.rs index 3b3d90b4e..f4db857a5 100644 --- a/kernel/aster-nix/src/util/iovec.rs +++ b/kernel/aster-nix/src/util/iovec.rs @@ -1,10 +1,6 @@ // SPDX-License-Identifier: MPL-2.0 -use super::read_val_from_user; -use crate::{ - prelude::*, - util::{read_bytes_from_user, write_bytes_to_user}, -}; +use crate::prelude::*; /// A kernel space IO vector. #[derive(Debug, Clone, Copy)] @@ -75,7 +71,7 @@ impl IoVec { assert_eq!(dst.len(), self.len); assert!(!self.is_empty()); - read_bytes_from_user(self.base, &mut VmWriter::from(dst)) + CurrentUserSpace::get().read_bytes(self.base, &mut VmWriter::from(dst)) } /// Writes bytes from the `src` buffer @@ -92,7 +88,7 @@ impl IoVec { assert_eq!(src.len(), self.len); assert!(!self.is_empty()); - write_bytes_to_user(self.base, &mut VmReader::from(src)) + CurrentUserSpace::get().write_bytes(self.base, &mut VmReader::from(src)) } /// Reads bytes to the `dst` buffer @@ -101,7 +97,7 @@ impl IoVec { /// If successful, returns the length of actually read bytes. pub fn read_from_user(&self, dst: &mut [u8]) -> Result { let len = self.len.min(dst.len()); - read_bytes_from_user(self.base, &mut VmWriter::from(&mut dst[..len]))?; + CurrentUserSpace::get().read_bytes(self.base, &mut VmWriter::from(&mut dst[..len]))?; Ok(len) } @@ -111,7 +107,7 @@ impl IoVec { /// If successful, returns the length of actually written bytes. pub fn write_to_user(&self, src: &[u8]) -> Result { let len = self.len.min(src.len()); - write_bytes_to_user(self.base, &mut VmReader::from(&src[..len]))?; + CurrentUserSpace::get().write_bytes(self.base, &mut VmReader::from(&src[..len]))?; Ok(len) } } @@ -120,9 +116,10 @@ impl IoVec { pub fn copy_iovs_from_user(start_addr: Vaddr, count: usize) -> Result> { let mut io_vecs = Vec::with_capacity(count); + let user_space = CurrentUserSpace::get(); for idx in 0..count { let addr = start_addr + idx * core::mem::size_of::(); - let uiov = read_val_from_user::(addr)?; + let uiov = user_space.read_val::(addr)?; let iov = IoVec::try_from(uiov)?; io_vecs.push(iov); } diff --git a/kernel/aster-nix/src/util/net/addr/family.rs b/kernel/aster-nix/src/util/net/addr/family.rs index f3455ac67..92a2fc0fe 100644 --- a/kernel/aster-nix/src/util/net/addr/family.rs +++ b/kernel/aster-nix/src/util/net/addr/family.rs @@ -3,11 +3,7 @@ use core::cmp::min; use super::{ip::CSocketAddrInet, unix, vsock::CSocketAddrVm}; -use crate::{ - net::socket::SocketAddr, - prelude::*, - util::{read_bytes_from_user, read_val_from_user, write_bytes_to_user, write_val_to_user}, -}; +use crate::{net::socket::SocketAddr, prelude::*}; /// Address family. /// @@ -148,7 +144,7 @@ pub fn read_socket_addr_from_user(addr: Vaddr, addr_len: usize) -> Result Result<()> { - let max_len = read_val_from_user::(max_len_ptr)?; + let user_space = CurrentUserSpace::get(); + let max_len = user_space.read_val::(max_len_ptr)?; let actual_len = write_socket_addr_with_max_len(socket_addr, dest, max_len)?; - write_val_to_user(max_len_ptr, &actual_len) + user_space.write_val(max_len_ptr, &actual_len) } /// Writes a socket address to the user space. @@ -238,12 +235,13 @@ pub fn write_socket_addr_with_max_len( ); } + let user_space = CurrentUserSpace::get(); let actual_len = match socket_addr { SocketAddr::IPv4(addr, port) => { let socket_addr = CSocketAddrInet::from((*addr, *port)); let actual_len = size_of::(); let written_len = min(actual_len, max_len as _); - write_bytes_to_user( + user_space.write_bytes( dest, &mut VmReader::from(&socket_addr.as_bytes()[..written_len]), )?; @@ -251,14 +249,14 @@ pub fn write_socket_addr_with_max_len( } SocketAddr::Unix(addr) => unix::into_c_bytes_and(addr, |bytes| { let written_len = min(bytes.len(), max_len as _); - write_bytes_to_user(dest, &mut VmReader::from(&bytes[..written_len]))?; + user_space.write_bytes(dest, &mut VmReader::from(&bytes[..written_len]))?; Ok::(bytes.len()) })?, SocketAddr::Vsock(addr) => { let socket_addr = CSocketAddrVm::from(*addr); let actual_len = size_of::(); let written_len = min(actual_len, max_len as _); - write_bytes_to_user( + user_space.write_bytes( dest, &mut VmReader::from(&socket_addr.as_bytes()[..written_len]), )?; diff --git a/kernel/aster-nix/src/util/net/options/mod.rs b/kernel/aster-nix/src/util/net/options/mod.rs index bb515425f..f5741f009 100644 --- a/kernel/aster-nix/src/util/net/options/mod.rs +++ b/kernel/aster-nix/src/util/net/options/mod.rs @@ -51,9 +51,7 @@ //! At the syscall level, the interface is unified for all options and does not need to be modified. //! -use aster_rights::Full; - -use crate::{net::socket::options::SocketOption, prelude::*, vm::vmar::Vmar}; +use crate::{net::socket::options::SocketOption, prelude::*}; mod socket; mod tcp; @@ -62,9 +60,9 @@ mod utils; use self::{socket::new_socket_option, tcp::new_tcp_option}; pub trait RawSocketOption: SocketOption { - fn read_from_user(&mut self, vmar: &Vmar, addr: Vaddr, max_len: u32) -> Result<()>; + fn read_from_user(&mut self, addr: Vaddr, max_len: u32) -> Result<()>; - fn write_to_user(&self, vmar: &Vmar, addr: Vaddr, max_len: u32) -> Result; + fn write_to_user(&self, addr: Vaddr, max_len: u32) -> Result; fn as_sock_option_mut(&mut self) -> &mut dyn SocketOption; @@ -76,24 +74,19 @@ pub trait RawSocketOption: SocketOption { macro_rules! impl_raw_socket_option { ($option:ty) => { impl RawSocketOption for $option { - fn read_from_user( - &mut self, - vmar: &Vmar, - addr: Vaddr, - max_len: u32, - ) -> Result<()> { + fn read_from_user(&mut self, addr: Vaddr, max_len: u32) -> Result<()> { use $crate::util::net::options::utils::ReadFromUser; - let input = ReadFromUser::read_from_user(vmar, addr, max_len)?; + let input = ReadFromUser::read_from_user(addr, max_len)?; self.set(input); Ok(()) } - fn write_to_user(&self, vmar: &Vmar, addr: Vaddr, max_len: u32) -> Result { + fn write_to_user(&self, addr: Vaddr, max_len: u32) -> Result { use $crate::util::net::options::utils::WriteToUser; let output = self.get().unwrap(); - output.write_to_user(vmar, addr, max_len) + output.write_to_user(addr, max_len) } fn as_sock_option_mut(&mut self) -> &mut dyn SocketOption { @@ -112,20 +105,15 @@ macro_rules! impl_raw_socket_option { macro_rules! impl_raw_sock_option_get_only { ($option:ty) => { impl RawSocketOption for $option { - fn read_from_user( - &mut self, - _vmar: &Vmar, - _addr: Vaddr, - _max_len: u32, - ) -> Result<()> { + fn read_from_user(&mut self, _addr: Vaddr, _max_len: u32) -> Result<()> { return_errno_with_message!(Errno::ENOPROTOOPT, "the option is getter-only"); } - fn write_to_user(&self, vmar: &Vmar, addr: Vaddr, max_len: u32) -> Result { + fn write_to_user(&self, addr: Vaddr, max_len: u32) -> Result { use $crate::util::net::options::utils::WriteToUser; let output = self.get().unwrap(); - output.write_to_user(vmar, addr, max_len) + output.write_to_user(addr, max_len) } fn as_sock_option_mut(&mut self) -> &mut dyn SocketOption { diff --git a/kernel/aster-nix/src/util/net/options/socket.rs b/kernel/aster-nix/src/util/net/options/socket.rs index 7c1ac1b8d..06084a832 100644 --- a/kernel/aster-nix/src/util/net/options/socket.rs +++ b/kernel/aster-nix/src/util/net/options/socket.rs @@ -1,7 +1,5 @@ // SPDX-License-Identifier: MPL-2.0 -use aster_rights::Full; - use super::RawSocketOption; use crate::{ impl_raw_sock_option_get_only, impl_raw_socket_option, @@ -9,7 +7,6 @@ use crate::{ Error, KeepAlive, Linger, RecvBuf, ReuseAddr, ReusePort, SendBuf, SocketOption, }, prelude::*, - vm::vmar::Vmar, }; /// Socket level options. diff --git a/kernel/aster-nix/src/util/net/options/tcp.rs b/kernel/aster-nix/src/util/net/options/tcp.rs index 020aadfed..2ab0c9899 100644 --- a/kernel/aster-nix/src/util/net/options/tcp.rs +++ b/kernel/aster-nix/src/util/net/options/tcp.rs @@ -1,14 +1,11 @@ // SPDX-License-Identifier: MPL-2.0 -use aster_rights::Full; - use super::RawSocketOption; use crate::{ impl_raw_socket_option, net::socket::ip::stream::options::{Congestion, MaxSegment, NoDelay, WindowClamp}, prelude::*, util::net::options::SocketOption, - vm::vmar::Vmar, }; /// Sock options for tcp socket. diff --git a/kernel/aster-nix/src/util/net/options/utils.rs b/kernel/aster-nix/src/util/net/options/utils.rs index 574ec3cf5..a5d94cf43 100644 --- a/kernel/aster-nix/src/util/net/options/utils.rs +++ b/kernel/aster-nix/src/util/net/options/utils.rs @@ -2,13 +2,9 @@ use core::time::Duration; -use aster_rights::Full; -use ostd::mm::VmIo; - use crate::{ net::socket::{ip::stream::CongestionControl, LingerOption}, prelude::*, - vm::vmar::Vmar, }; /// Create an object by reading its C counterpart from the user space. @@ -21,7 +17,7 @@ use crate::{ /// from the user space must be validated by the kernel. pub trait ReadFromUser: Sized { /// Read a struct from user space by reading its C counterpart. - fn read_from_user(vmar: &Vmar, addr: Vaddr, max_len: u32) -> Result; + fn read_from_user(addr: Vaddr, max_len: u32) -> Result; } /// Write an object to user space by writing its C counterpart. @@ -32,7 +28,7 @@ pub trait ReadFromUser: Sized { /// and write value in user space should be of same type. pub trait WriteToUser { // Write a struct to user space by writing its C counterpart. - fn write_to_user(&self, vmar: &Vmar, addr: Vaddr, max_len: u32) -> Result; + fn write_to_user(&self, addr: Vaddr, max_len: u32) -> Result; } /// This macro is used to implement `ReadFromUser` and `WriteToUser` for types that @@ -46,23 +42,23 @@ pub trait WriteToUser { macro_rules! impl_read_write_for_pod_type { ($pod_ty: ty) => { impl ReadFromUser for $pod_ty { - fn read_from_user(vmar: &Vmar, addr: Vaddr, max_len: u32) -> Result { + fn read_from_user(addr: Vaddr, max_len: u32) -> Result { if (max_len as usize) < core::mem::size_of::<$pod_ty>() { return_errno_with_message!(Errno::EINVAL, "max_len is too short"); } - Ok(vmar.read_val::<$pod_ty>(addr)?) + crate::util::CurrentUserSpace::get().read_val::<$pod_ty>(addr) } } impl WriteToUser for $pod_ty { - fn write_to_user(&self, vmar: &Vmar, addr: Vaddr, max_len: u32) -> Result { + fn write_to_user(&self, addr: Vaddr, max_len: u32) -> Result { let write_len = core::mem::size_of::<$pod_ty>(); if (max_len as usize) < write_len { return_errno_with_message!(Errno::EINVAL, "max_len is too short"); } - vmar.write_val(addr, self)?; + crate::util::CurrentUserSpace::get().write_val(addr, self)?; Ok(write_len) } } @@ -72,19 +68,19 @@ macro_rules! impl_read_write_for_pod_type { impl_read_write_for_pod_type!(u32); impl ReadFromUser for bool { - fn read_from_user(vmar: &Vmar, addr: Vaddr, max_len: u32) -> Result { + fn read_from_user(addr: Vaddr, max_len: u32) -> Result { if (max_len as usize) < core::mem::size_of::() { return_errno_with_message!(Errno::EINVAL, "max_len is too short"); } - let val = vmar.read_val::(addr)?; + let val = CurrentUserSpace::get().read_val::(addr)?; Ok(val != 0) } } impl WriteToUser for bool { - fn write_to_user(&self, vmar: &Vmar, addr: Vaddr, max_len: u32) -> Result { + fn write_to_user(&self, addr: Vaddr, max_len: u32) -> Result { let write_len = core::mem::size_of::(); if (max_len as usize) < write_len { @@ -92,13 +88,13 @@ impl WriteToUser for bool { } let val = if *self { 1i32 } else { 0i32 }; - vmar.write_val(addr, &val)?; + CurrentUserSpace::get().write_val(addr, &val)?; Ok(write_len) } } impl WriteToUser for Option { - fn write_to_user(&self, vmar: &Vmar, addr: Vaddr, max_len: u32) -> Result { + fn write_to_user(&self, addr: Vaddr, max_len: u32) -> Result { let write_len = core::mem::size_of::(); if (max_len as usize) < write_len { @@ -110,25 +106,25 @@ impl WriteToUser for Option { Some(error) => error.error() as i32, }; - vmar.write_val(addr, &val)?; + CurrentUserSpace::get().write_val(addr, &val)?; Ok(write_len) } } impl ReadFromUser for LingerOption { - fn read_from_user(vmar: &Vmar, addr: Vaddr, max_len: u32) -> Result { + fn read_from_user(addr: Vaddr, max_len: u32) -> Result { if (max_len as usize) < core::mem::size_of::() { return_errno_with_message!(Errno::EINVAL, "max_len is too short"); } - let c_linger = vmar.read_val::(addr)?; + let c_linger = CurrentUserSpace::get().read_val::(addr)?; Ok(LingerOption::from(c_linger)) } } impl WriteToUser for LingerOption { - fn write_to_user(&self, vmar: &Vmar, addr: Vaddr, max_len: u32) -> Result { + fn write_to_user(&self, addr: Vaddr, max_len: u32) -> Result { let write_len = core::mem::size_of::(); if (max_len as usize) < write_len { @@ -136,22 +132,22 @@ impl WriteToUser for LingerOption { } let linger = CLinger::from(*self); - vmar.write_val(addr, &linger)?; + CurrentUserSpace::get().write_val(addr, &linger)?; Ok(write_len) } } impl ReadFromUser for CongestionControl { - fn read_from_user(vmar: &Vmar, addr: Vaddr, max_len: u32) -> Result { + fn read_from_user(addr: Vaddr, max_len: u32) -> Result { let mut bytes = vec![0; max_len as usize]; - vmar.read_bytes(addr, &mut bytes)?; + CurrentUserSpace::get().read_bytes(addr, &mut VmWriter::from(bytes.as_mut_slice()))?; let name = String::from_utf8(bytes).unwrap(); CongestionControl::new(&name) } } impl WriteToUser for CongestionControl { - fn write_to_user(&self, vmar: &Vmar, addr: Vaddr, max_len: u32) -> Result { + fn write_to_user(&self, addr: Vaddr, max_len: u32) -> Result { let name = self.name().as_bytes(); let write_len = name.len(); @@ -159,7 +155,7 @@ impl WriteToUser for CongestionControl { return_errno_with_message!(Errno::EINVAL, "max_len is too short"); } - vmar.write_bytes(addr, name)?; + CurrentUserSpace::get().write_bytes(addr, &mut VmReader::from(name))?; Ok(write_len) }