From 36fc1d37573f6809980aee652f4209c64979b209 Mon Sep 17 00:00:00 2001 From: Ruihan Li Date: Sun, 1 Dec 2024 11:41:23 +0800 Subject: [PATCH] Move FS things to `PosixThread` --- kernel/src/device/pty/pty.rs | 6 ++- kernel/src/fs/epoll/file.rs | 8 +++- kernel/src/fs/fs_resolver.rs | 5 ++- kernel/src/fs/mod.rs | 1 + kernel/src/fs/procfs/pid/fd.rs | 10 +++-- kernel/src/fs/procfs/pid/mod.rs | 5 ++- kernel/src/fs/procfs/pid/stat.rs | 6 ++- kernel/src/fs/procfs/pid/status.rs | 11 +++-- kernel/src/fs/thread_info.rs | 41 ++++++++++++++++++ kernel/src/net/socket/unix/ns/path.rs | 11 +++-- kernel/src/process/clone.rs | 43 +++++++------------ kernel/src/process/exit.rs | 9 +++- kernel/src/process/posix_thread/builder.rs | 24 +++++++++++ kernel/src/process/posix_thread/mod.rs | 15 +++++++ .../process/posix_thread/posix_thread_ext.rs | 18 +++++--- kernel/src/process/process/builder.rs | 41 ------------------ kernel/src/process/process/mod.rs | 31 ------------- kernel/src/syscall/accept.rs | 2 +- kernel/src/syscall/access.rs | 2 +- kernel/src/syscall/chdir.rs | 6 +-- kernel/src/syscall/chmod.rs | 4 +- kernel/src/syscall/chown.rs | 4 +- kernel/src/syscall/chroot.rs | 2 +- kernel/src/syscall/close.rs | 2 +- kernel/src/syscall/dup.rs | 10 ++--- kernel/src/syscall/epoll.rs | 6 +-- kernel/src/syscall/eventfd.rs | 2 +- kernel/src/syscall/execve.rs | 7 +-- kernel/src/syscall/fallocate.rs | 2 +- kernel/src/syscall/fcntl.rs | 18 ++++---- kernel/src/syscall/flock.rs | 2 +- kernel/src/syscall/fsync.rs | 4 +- kernel/src/syscall/getcwd.rs | 3 +- kernel/src/syscall/getdents64.rs | 4 +- kernel/src/syscall/ioctl.rs | 6 +-- kernel/src/syscall/link.rs | 2 +- kernel/src/syscall/lseek.rs | 2 +- kernel/src/syscall/mkdir.rs | 5 ++- kernel/src/syscall/mknod.rs | 5 ++- kernel/src/syscall/mmap.rs | 2 +- kernel/src/syscall/mount.rs | 6 +-- kernel/src/syscall/open.rs | 10 +++-- kernel/src/syscall/pipe.rs | 2 +- kernel/src/syscall/poll.rs | 2 +- kernel/src/syscall/pread64.rs | 2 +- kernel/src/syscall/preadv.rs | 4 +- kernel/src/syscall/pwrite64.rs | 2 +- kernel/src/syscall/pwritev.rs | 4 +- kernel/src/syscall/read.rs | 2 +- kernel/src/syscall/readlink.rs | 6 ++- kernel/src/syscall/rename.rs | 2 +- kernel/src/syscall/rmdir.rs | 6 ++- kernel/src/syscall/sendfile.rs | 2 +- kernel/src/syscall/socket.rs | 2 +- kernel/src/syscall/socketpair.rs | 2 +- kernel/src/syscall/stat.rs | 4 +- kernel/src/syscall/statfs.rs | 4 +- kernel/src/syscall/symlink.rs | 3 +- kernel/src/syscall/truncate.rs | 4 +- kernel/src/syscall/umask.rs | 2 +- kernel/src/syscall/umount.rs | 8 +++- kernel/src/syscall/unlink.rs | 6 ++- kernel/src/syscall/utimens.rs | 2 +- kernel/src/syscall/write.rs | 2 +- kernel/src/util/net/mod.rs | 7 ++- 65 files changed, 268 insertions(+), 215 deletions(-) create mode 100644 kernel/src/fs/thread_info.rs diff --git a/kernel/src/device/pty/pty.rs b/kernel/src/device/pty/pty.rs index d500b647f..47e1abc6a 100644 --- a/kernel/src/device/pty/pty.rs +++ b/kernel/src/device/pty/pty.rs @@ -16,6 +16,7 @@ use crate::{ }, prelude::*, process::{ + posix_thread::AsPosixThread, signal::{PollHandle, Pollable, Pollee}, JobControl, Terminal, }, @@ -191,7 +192,8 @@ impl FileIo for PtyMaster { Ok(0) } IoctlCmd::TIOCGPTPEER => { - let current = current!(); + let current = current_thread!(); + let current = current.as_posix_thread().unwrap(); // TODO: deal with open options let slave = { @@ -203,7 +205,7 @@ impl FileIo for PtyMaster { let fs_path = FsPath::try_from(slave_name.as_str())?; let inode_handle = { - let fs = current.fs().read(); + let fs = current.fs().resolver().read(); let flags = AccessMode::O_RDWR as u32; let mode = (InodeMode::S_IRUSR | InodeMode::S_IWUSR).bits(); fs.open(&fs_path, flags, mode)? diff --git a/kernel/src/fs/epoll/file.rs b/kernel/src/fs/epoll/file.rs index f11845309..5c0ec64ea 100644 --- a/kernel/src/fs/epoll/file.rs +++ b/kernel/src/fs/epoll/file.rs @@ -18,7 +18,10 @@ use crate::{ utils::{InodeMode, IoctlCmd, Metadata}, }, prelude::*, - process::signal::{PollHandle, Pollable}, + process::{ + posix_thread::AsPosixThread, + signal::{PollHandle, Pollable}, + }, }; /// A file-like object that provides epoll API. @@ -61,7 +64,8 @@ impl EpollFile { }; let file = { - let current = current!(); + let current = current_thread!(); + let current = current.as_posix_thread().unwrap(); let file_table = current.file_table().lock(); file_table.get_file(fd)?.clone() }; diff --git a/kernel/src/fs/fs_resolver.rs b/kernel/src/fs/fs_resolver.rs index c835e3762..3dc2f278c 100644 --- a/kernel/src/fs/fs_resolver.rs +++ b/kernel/src/fs/fs_resolver.rs @@ -9,7 +9,7 @@ use super::{ rootfs::root_mount, utils::{AccessMode, CreationFlags, InodeMode, InodeType, StatusFlags, PATH_MAX, SYMLINKS_MAX}, }; -use crate::prelude::*; +use crate::{prelude::*, process::posix_thread::AsPosixThread}; /// The file descriptor of the current working directory. pub const AT_FDCWD: FileDesc = -100; @@ -285,7 +285,8 @@ impl FsResolver { /// Lookups the target dentry according to the given `fd`. pub fn lookup_from_fd(&self, fd: FileDesc) -> Result { - let current = current!(); + let current = current_thread!(); + let current = current.as_posix_thread().unwrap(); let file_table = current.file_table().lock(); let inode_handle = file_table .get_file(fd)? diff --git a/kernel/src/fs/mod.rs b/kernel/src/fs/mod.rs index 01b223fa0..99e2caeb2 100644 --- a/kernel/src/fs/mod.rs +++ b/kernel/src/fs/mod.rs @@ -14,6 +14,7 @@ pub mod pipe; pub mod procfs; pub mod ramfs; pub mod rootfs; +pub mod thread_info; pub mod utils; use aster_block::BlockDevice; diff --git a/kernel/src/fs/procfs/pid/fd.rs b/kernel/src/fs/procfs/pid/fd.rs index 8773a7810..d0dd2c489 100644 --- a/kernel/src/fs/procfs/pid/fd.rs +++ b/kernel/src/fs/procfs/pid/fd.rs @@ -11,6 +11,7 @@ use crate::{ utils::{DirEntryVecExt, Inode}, }, prelude::*, + process::posix_thread::AsPosixThread, Process, }; @@ -23,7 +24,8 @@ impl FdDirOps { .parent(parent) .build() .unwrap(); - let file_table = process_ref.file_table().lock(); + let main_thread = process_ref.main_thread().unwrap(); + let file_table = main_thread.as_posix_thread().unwrap().file_table().lock(); let weak_ptr = Arc::downgrade(&fd_inode); file_table.register_observer(weak_ptr); fd_inode @@ -49,7 +51,8 @@ impl DirOps for FdDirOps { let fd = name .parse::() .map_err(|_| Error::new(Errno::ENOENT))?; - let file_table = self.0.file_table().lock(); + let main_thread = self.0.main_thread().unwrap(); + let file_table = main_thread.as_posix_thread().unwrap().file_table().lock(); file_table .get_file(fd) .map_err(|_| Error::new(Errno::ENOENT))? @@ -63,8 +66,9 @@ impl DirOps for FdDirOps { let this = this_ptr.upgrade().unwrap(); this.downcast_ref::>().unwrap().this() }; - let file_table = self.0.file_table().lock(); let mut cached_children = this.cached_children().write(); + let main_thread = self.0.main_thread().unwrap(); + let file_table = main_thread.as_posix_thread().unwrap().file_table().lock(); for (fd, file) in file_table.fds_and_files() { cached_children.put_entry_if_not_found(&fd.to_string(), || { FileSymOps::new_inode(file.clone(), this_ptr.clone()) diff --git a/kernel/src/fs/procfs/pid/mod.rs b/kernel/src/fs/procfs/pid/mod.rs index c8f563138..f6f3d3c63 100644 --- a/kernel/src/fs/procfs/pid/mod.rs +++ b/kernel/src/fs/procfs/pid/mod.rs @@ -9,7 +9,7 @@ use crate::{ utils::{DirEntryVecExt, Inode}, }, prelude::*, - process::Process, + process::{posix_thread::AsPosixThread, Process}, }; mod cmdline; @@ -30,7 +30,8 @@ impl PidDirOps { .volatile() .build() .unwrap(); - let file_table = process_ref.file_table().lock(); + let main_thread = process_ref.main_thread().unwrap(); + let file_table = main_thread.as_posix_thread().unwrap().file_table().lock(); let weak_ptr = Arc::downgrade(&pid_inode); file_table.register_observer(weak_ptr); pid_inode diff --git a/kernel/src/fs/procfs/pid/stat.rs b/kernel/src/fs/procfs/pid/stat.rs index a2a601b8d..b4dfacd61 100644 --- a/kernel/src/fs/procfs/pid/stat.rs +++ b/kernel/src/fs/procfs/pid/stat.rs @@ -8,6 +8,7 @@ use crate::{ utils::Inode, }, prelude::*, + process::posix_thread::AsPosixThread, Process, }; @@ -29,6 +30,9 @@ impl StatFileOps { impl FileOps for StatFileOps { fn data(&self) -> Result> { let process = &self.0; + let main_thread = process.main_thread().unwrap(); + let file_table = main_thread.as_posix_thread().unwrap().file_table(); + let mut stat_output = String::new(); writeln!( stat_output, @@ -38,7 +42,7 @@ impl FileOps for StatFileOps { process.pid(), process.parent().pid(), process.parent().pid(), - process.file_table().lock().len(), + file_table.lock().len(), process.tasks().lock().len() ) .unwrap(); diff --git a/kernel/src/fs/procfs/pid/status.rs b/kernel/src/fs/procfs/pid/status.rs index 072434ac3..940a83aba 100644 --- a/kernel/src/fs/procfs/pid/status.rs +++ b/kernel/src/fs/procfs/pid/status.rs @@ -8,6 +8,7 @@ use crate::{ utils::Inode, }, prelude::*, + process::posix_thread::AsPosixThread, Process, }; @@ -71,18 +72,16 @@ impl StatusFileOps { impl FileOps for StatusFileOps { fn data(&self) -> Result> { let process = &self.0; + let main_thread = process.main_thread().unwrap(); + let file_table = main_thread.as_posix_thread().unwrap().file_table(); + let mut status_output = String::new(); writeln!(status_output, "Name:\t{}", process.executable_path()).unwrap(); writeln!(status_output, "Tgid:\t{}", process.pid()).unwrap(); writeln!(status_output, "Pid:\t{}", process.pid()).unwrap(); writeln!(status_output, "PPid:\t{}", process.parent().pid()).unwrap(); writeln!(status_output, "TracerPid:\t{}", process.parent().pid()).unwrap(); // Assuming TracerPid is the same as PPid - writeln!( - status_output, - "FDSize:\t{}", - process.file_table().lock().len() - ) - .unwrap(); + writeln!(status_output, "FDSize:\t{}", file_table.lock().len()).unwrap(); writeln!(status_output, "Threads:\t{}", process.tasks().lock().len()).unwrap(); Ok(status_output.into_bytes()) } diff --git a/kernel/src/fs/thread_info.rs b/kernel/src/fs/thread_info.rs new file mode 100644 index 000000000..c636f3966 --- /dev/null +++ b/kernel/src/fs/thread_info.rs @@ -0,0 +1,41 @@ +// SPDX-License-Identifier: MPL-2.0 + +use ostd::sync::{RwLock, RwMutex}; + +use super::{fs_resolver::FsResolver, utils::FileCreationMask}; + +/// FS information for a POSIX thread. +pub struct ThreadFsInfo { + resolver: RwMutex, + umask: RwLock, +} + +impl ThreadFsInfo { + /// Returns the associated `FsResolver`. + pub fn resolver(&self) -> &RwMutex { + &self.resolver + } + + /// Returns the associated `FileCreationMask`. + pub fn umask(&self) -> &RwLock { + &self.umask + } +} + +impl Default for ThreadFsInfo { + fn default() -> Self { + Self { + resolver: RwMutex::new(FsResolver::default()), + umask: RwLock::new(FileCreationMask::default()), + } + } +} + +impl Clone for ThreadFsInfo { + fn clone(&self) -> Self { + Self { + resolver: RwMutex::new(self.resolver.read().clone()), + umask: RwLock::new(FileCreationMask::new(self.umask.read().get())), + } + } +} diff --git a/kernel/src/net/socket/unix/ns/path.rs b/kernel/src/net/socket/unix/ns/path.rs index 86098c9c3..8ad730ada 100644 --- a/kernel/src/net/socket/unix/ns/path.rs +++ b/kernel/src/net/socket/unix/ns/path.rs @@ -7,12 +7,14 @@ use crate::{ utils::{InodeMode, InodeType}, }, prelude::*, + process::posix_thread::AsPosixThread, }; pub fn lookup_socket_file(path: &str) -> Result { let dentry = { - let current = current!(); - let fs = current.fs().read(); + let current = current_thread!(); + let current = current.as_posix_thread().unwrap(); + let fs = current.fs().resolver().read(); let fs_path = FsPath::try_from(path)?; fs.lookup(&fs_path)? }; @@ -35,8 +37,9 @@ pub fn create_socket_file(path: &str) -> Result { let (parent_pathname, file_name) = split_path(path); let parent = { - let current = current!(); - let fs = current.fs().read(); + let current = current_thread!(); + let current = current.as_posix_thread().unwrap(); + let fs = current.fs().resolver().read(); let parent_path = FsPath::try_from(parent_pathname)?; fs.lookup(&parent_path)? }; diff --git a/kernel/src/process/clone.rs b/kernel/src/process/clone.rs index e93b27830..09e4a2f7c 100644 --- a/kernel/src/process/clone.rs +++ b/kernel/src/process/clone.rs @@ -18,7 +18,7 @@ use super::{ use crate::{ cpu::LinuxAbi, current_userspace, - fs::{file_table::FileTable, fs_resolver::FsResolver, utils::FileCreationMask}, + fs::{file_table::FileTable, thread_info::ThreadFsInfo}, prelude::*, process::posix_thread::allocate_posix_tid, thread::{AsThread, Tid}, @@ -213,15 +213,6 @@ fn clone_child_task( ); } - // This is valid combination in Linux. But we do not support it yet. - if !clone_flags.contains(CloneFlags::CLONE_FILES) || !clone_flags.contains(CloneFlags::CLONE_FS) - { - return_errno_with_message!( - Errno::EINVAL, - "`CLONE_THREAD` without `CLONE_FILES` or `CLONE_FS` is not supported" - ); - } - let Context { process, posix_thread, @@ -232,6 +223,12 @@ fn clone_child_task( // clone system V semaphore clone_sysvsem(clone_flags)?; + // clone file table + let child_file_table = clone_files(posix_thread.file_table(), clone_flags); + + // clone fs + let child_fs = clone_fs(posix_thread.fs(), clone_flags); + let child_root_vmar = process.root_vmar(); let child_user_space = { let child_vm_space = child_root_vmar.vm_space().clone(); @@ -257,7 +254,9 @@ fn clone_child_task( let thread_builder = PosixThreadBuilder::new(child_tid, child_user_space, credentials) .process(posix_thread.weak_process()) - .sig_mask(sig_mask); + .sig_mask(sig_mask) + .file_table(child_file_table) + .fs(child_fs); thread_builder.build() }; @@ -307,16 +306,10 @@ fn clone_child_process( }; // clone file table - let child_file_table = clone_files(process.file_table(), clone_flags); + let child_file_table = clone_files(posix_thread.file_table(), clone_flags); // clone fs - let child_fs = clone_fs(process.fs(), clone_flags); - - // clone umask - let child_umask = { - let parent_umask = process.umask().read().get(); - Arc::new(RwLock::new(FileCreationMask::new(parent_umask))) - }; + let child_fs = clone_fs(posix_thread.fs(), clone_flags); // clone sig dispositions let child_sig_dispositions = clone_sighand(process.sig_dispositions(), clone_flags); @@ -345,6 +338,8 @@ fn clone_child_process( PosixThreadBuilder::new(child_tid, child_user_space, credentials) .thread_name(Some(child_thread_name)) .sig_mask(child_sig_mask) + .file_table(child_file_table) + .fs(child_fs) }; let mut process_builder = @@ -353,9 +348,6 @@ fn clone_child_process( process_builder .main_thread_builder(child_thread_builder) .process_vm(child_process_vm) - .file_table(child_file_table) - .fs(child_fs) - .umask(child_umask) .sig_dispositions(child_sig_dispositions) .nice(child_nice); @@ -460,14 +452,11 @@ fn clone_cpu_context( child_context } -fn clone_fs( - parent_fs: &Arc>, - clone_flags: CloneFlags, -) -> Arc> { +fn clone_fs(parent_fs: &Arc, clone_flags: CloneFlags) -> Arc { if clone_flags.contains(CloneFlags::CLONE_FS) { parent_fs.clone() } else { - Arc::new(RwMutex::new(parent_fs.read().clone())) + Arc::new(parent_fs.as_ref().clone()) } } diff --git a/kernel/src/process/exit.rs b/kernel/src/process/exit.rs index 81ca661cb..7e605dff0 100644 --- a/kernel/src/process/exit.rs +++ b/kernel/src/process/exit.rs @@ -41,8 +41,13 @@ pub fn do_exit_group(term_status: TermStatus) { child.enqueue_signal(signal); } - // Close all files then exit the process - let files = current.file_table().lock().close_all(); + // Close all files then exit the process. + // + // FIXME: This is obviously wrong in a number of ways, since different threads can have + // different file tables, and different processes can share the same file table. + let main_thread = current.main_thread().unwrap(); + let mut files = main_thread.as_posix_thread().unwrap().file_table().lock(); + files.close_all(); drop(files); // Move children to the init process diff --git a/kernel/src/process/posix_thread/builder.rs b/kernel/src/process/posix_thread/builder.rs index adb7502bf..e5cd864ff 100644 --- a/kernel/src/process/posix_thread/builder.rs +++ b/kernel/src/process/posix_thread/builder.rs @@ -6,6 +6,7 @@ use ostd::{cpu::CpuSet, task::Task, user::UserSpace}; use super::{thread_table, PosixThread}; use crate::{ + fs::{file_table::FileTable, thread_info::ThreadFsInfo}, prelude::*, process::{ posix_thread::name::ThreadName, @@ -29,6 +30,8 @@ pub struct PosixThreadBuilder { thread_name: Option, set_child_tid: Vaddr, clear_child_tid: Vaddr, + file_table: Option>>, + fs: Option>, sig_mask: AtomicSigMask, sig_queues: SigQueues, priority: Priority, @@ -44,6 +47,8 @@ impl PosixThreadBuilder { thread_name: None, set_child_tid: 0, clear_child_tid: 0, + file_table: None, + fs: None, sig_mask: AtomicSigMask::new_empty(), sig_queues: SigQueues::new(), priority: Priority::default(), @@ -70,6 +75,16 @@ impl PosixThreadBuilder { self } + pub fn file_table(mut self, file_table: Arc>) -> Self { + self.file_table = Some(file_table); + self + } + + pub fn fs(mut self, fs: Arc) -> Self { + self.fs = Some(fs); + self + } + pub fn sig_mask(mut self, sig_mask: AtomicSigMask) -> Self { self.sig_mask = sig_mask; self @@ -89,11 +104,18 @@ impl PosixThreadBuilder { thread_name, set_child_tid, clear_child_tid, + file_table, + fs, sig_mask, sig_queues, priority, } = self; + let file_table = + file_table.unwrap_or_else(|| Arc::new(SpinLock::new(FileTable::new_with_stdio()))); + + let fs = fs.unwrap_or_else(|| Arc::new(ThreadFsInfo::default())); + Arc::new_cyclic(|weak_task| { let posix_thread = { let prof_clock = ProfClock::new(); @@ -107,6 +129,8 @@ impl PosixThreadBuilder { set_child_tid: Mutex::new(set_child_tid), clear_child_tid: Mutex::new(clear_child_tid), credentials, + file_table, + fs, sig_mask, sig_queues, sig_context: Mutex::new(None), diff --git a/kernel/src/process/posix_thread/mod.rs b/kernel/src/process/posix_thread/mod.rs index adf9c20d0..dfcfb758e 100644 --- a/kernel/src/process/posix_thread/mod.rs +++ b/kernel/src/process/posix_thread/mod.rs @@ -20,6 +20,7 @@ use super::{ }; use crate::{ events::Observer, + fs::{file_table::FileTable, thread_info::ThreadFsInfo}, prelude::*, process::signal::constants::SIGCONT, thread::{AsThread, Thread, Tid}, @@ -58,6 +59,12 @@ pub struct PosixThread { /// Process credentials. At the kernel level, credentials are a per-thread attribute. credentials: Credentials, + // Files + /// File table + file_table: Arc>, + /// File system + fs: Arc, + // Signal /// Blocked signals sig_mask: AtomicSigMask, @@ -107,6 +114,14 @@ impl PosixThread { &self.clear_child_tid } + pub fn file_table(&self) -> &Arc> { + &self.file_table + } + + pub fn fs(&self) -> &Arc { + &self.fs + } + /// Get the reference to the signal mask of the thread. /// /// Note that while this function offers mutable access to the signal mask, diff --git a/kernel/src/process/posix_thread/posix_thread_ext.rs b/kernel/src/process/posix_thread/posix_thread_ext.rs index 80198d866..f358e5882 100644 --- a/kernel/src/process/posix_thread/posix_thread_ext.rs +++ b/kernel/src/process/posix_thread/posix_thread_ext.rs @@ -8,7 +8,10 @@ use ostd::{ use super::{builder::PosixThreadBuilder, name::ThreadName, PosixThread}; use crate::{ - fs::fs_resolver::{FsPath, FsResolver, AT_FDCWD}, + fs::{ + fs_resolver::{FsPath, AT_FDCWD}, + thread_info::ThreadFsInfo, + }, prelude::*, process::{process_vm::ProcessVm, program_loader::load_program_to_vm, Credentials, Process}, thread::{AsThread, Thread, Tid}, @@ -35,22 +38,22 @@ impl AsPosixThread for Task { /// Creates a task for running an executable file. /// /// This function should _only_ be used to create the init user task. -#[allow(clippy::too_many_arguments)] pub fn create_posix_task_from_executable( tid: Tid, credentials: Credentials, process_vm: &ProcessVm, - fs_resolver: &FsResolver, executable_path: &str, process: Weak, argv: Vec, envp: Vec, ) -> Result> { - let elf_file = { + let fs = ThreadFsInfo::default(); + let (_, elf_load_info) = { + let fs_resolver = fs.resolver().read(); let fs_path = FsPath::new(AT_FDCWD, executable_path)?; - fs_resolver.lookup(&fs_path)? + let elf_file = fs.resolver().read().lookup(&fs_path)?; + load_program_to_vm(process_vm, elf_file, argv, envp, &fs_resolver, 1)? }; - let (_, elf_load_info) = load_program_to_vm(process_vm, elf_file, argv, envp, fs_resolver, 1)?; let vm_space = process_vm.root_vmar().vm_space().clone(); let mut cpu_ctx = UserContext::default(); @@ -60,6 +63,7 @@ pub fn create_posix_task_from_executable( let thread_name = Some(ThreadName::new_from_executable_path(executable_path)?); let thread_builder = PosixThreadBuilder::new(tid, user_space, credentials) .thread_name(thread_name) - .process(process); + .process(process) + .fs(Arc::new(fs)); Ok(thread_builder.build()) } diff --git a/kernel/src/process/process/builder.rs b/kernel/src/process/process/builder.rs index c02a3324c..103cab7d5 100644 --- a/kernel/src/process/process/builder.rs +++ b/kernel/src/process/process/builder.rs @@ -4,7 +4,6 @@ use super::{Pid, Process}; use crate::{ - fs::{file_table::FileTable, fs_resolver::FsResolver, utils::FileCreationMask}, prelude::*, process::{ posix_thread::{create_posix_task_from_executable, PosixThreadBuilder}, @@ -27,9 +26,6 @@ pub struct ProcessBuilder<'a> { argv: Option>, envp: Option>, process_vm: Option, - file_table: Option>>, - fs: Option>>, - umask: Option>>, resource_limits: Option, sig_dispositions: Option>>, credentials: Option, @@ -46,9 +42,6 @@ impl<'a> ProcessBuilder<'a> { argv: None, envp: None, process_vm: None, - file_table: None, - fs: None, - umask: None, resource_limits: None, sig_dispositions: None, credentials: None, @@ -66,21 +59,6 @@ impl<'a> ProcessBuilder<'a> { self } - pub fn file_table(&mut self, file_table: Arc>) -> &mut Self { - self.file_table = Some(file_table); - self - } - - pub fn fs(&mut self, fs: Arc>) -> &mut Self { - self.fs = Some(fs); - self - } - - pub fn umask(&mut self, umask: Arc>) -> &mut Self { - self.umask = Some(umask); - self - } - pub fn resource_limits(&mut self, resource_limits: ResourceLimits) -> &mut Self { self.resource_limits = Some(resource_limits); self @@ -139,9 +117,6 @@ impl<'a> ProcessBuilder<'a> { argv, envp, process_vm, - file_table, - fs, - umask, resource_limits, sig_dispositions, credentials, @@ -150,18 +125,6 @@ impl<'a> ProcessBuilder<'a> { let process_vm = process_vm.or_else(|| Some(ProcessVm::alloc())).unwrap(); - let file_table = file_table - .or_else(|| Some(Arc::new(SpinLock::new(FileTable::new_with_stdio())))) - .unwrap(); - - let fs = fs - .or_else(|| Some(Arc::new(RwMutex::new(FsResolver::new())))) - .unwrap(); - - let umask = umask - .or_else(|| Some(Arc::new(RwLock::new(FileCreationMask::default())))) - .unwrap(); - let resource_limits = resource_limits .or_else(|| Some(ResourceLimits::default())) .unwrap(); @@ -180,9 +143,6 @@ impl<'a> ProcessBuilder<'a> { threads, executable_path.to_string(), process_vm, - fs, - file_table, - umask, resource_limits, nice, sig_dispositions, @@ -197,7 +157,6 @@ impl<'a> ProcessBuilder<'a> { pid, credentials.unwrap(), process.vm(), - &process.fs().read(), executable_path, Arc::downgrade(&process), argv.unwrap(), diff --git a/kernel/src/process/process/mod.rs b/kernel/src/process/process/mod.rs index ff976c519..00e744c52 100644 --- a/kernel/src/process/process/mod.rs +++ b/kernel/src/process/process/mod.rs @@ -18,7 +18,6 @@ use super::{ }; use crate::{ device::tty::open_ntty_as_controlling_terminal, - fs::{file_table::FileTable, fs_resolver::FsResolver, utils::FileCreationMask}, prelude::*, sched::priority::{AtomicNice, Nice}, thread::{AsThread, Thread}, @@ -81,12 +80,6 @@ pub struct Process { children: Mutex>>, /// Process group pub(super) process_group: Mutex>, - /// File table - file_table: Arc>, - /// FsResolver - fs: Arc>, - /// umask - umask: Arc>, /// resource limits resource_limits: Mutex, /// Scheduling priority nice value @@ -185,10 +178,6 @@ impl Process { executable_path: String, process_vm: ProcessVm, - fs: Arc>, - file_table: Arc>, - - umask: Arc>, resource_limits: ResourceLimits, nice: Nice, sig_dispositions: Arc>, @@ -209,9 +198,6 @@ impl Process { parent: ParentProcess::new(parent), children: Mutex::new(BTreeMap::new()), process_group: Mutex::new(Weak::new()), - file_table, - fs, - umask, sig_dispositions, parent_death_signal: AtomicSigNum::new_empty(), exit_signal: AtomicSigNum::new_empty(), @@ -620,20 +606,6 @@ impl Process { self.process_vm.init_stack_reader() } - // ************** File system **************** - - pub fn file_table(&self) -> &Arc> { - &self.file_table - } - - pub fn fs(&self) -> &Arc> { - &self.fs - } - - pub fn umask(&self) -> &Arc> { - &self.umask - } - // ****************** Signal ****************** pub fn sig_dispositions(&self) -> &Arc> { @@ -742,9 +714,6 @@ mod test { vec![], String::new(), ProcessVm::alloc(), - Arc::new(RwMutex::new(FsResolver::new())), - Arc::new(SpinLock::new(FileTable::new())), - Arc::new(RwLock::new(FileCreationMask::default())), ResourceLimits::default(), Nice::default(), Arc::new(Mutex::new(SigDispositions::default())), diff --git a/kernel/src/syscall/accept.rs b/kernel/src/syscall/accept.rs index 9c3734cd1..a52751bb2 100644 --- a/kernel/src/syscall/accept.rs +++ b/kernel/src/syscall/accept.rs @@ -67,7 +67,7 @@ fn do_accept( } let fd = { - let mut file_table = ctx.process.file_table().lock(); + let mut file_table = ctx.posix_thread.file_table().lock(); file_table.insert(connected_socket, fd_flags) }; diff --git a/kernel/src/syscall/access.rs b/kernel/src/syscall/access.rs index 8a87a0310..f33a344c8 100644 --- a/kernel/src/syscall/access.rs +++ b/kernel/src/syscall/access.rs @@ -69,7 +69,7 @@ pub fn do_faccessat( let dentry = { let path = path.to_string_lossy(); let fs_path = FsPath::new(dirfd, path.as_ref())?; - let fs = ctx.process.fs().read(); + let fs = ctx.posix_thread.fs().resolver().read(); if flags.contains(FaccessatFlags::AT_SYMLINK_NOFOLLOW) { fs.lookup_no_follow(&fs_path)? } else { diff --git a/kernel/src/syscall/chdir.rs b/kernel/src/syscall/chdir.rs index 1fe870682..b61a0e475 100644 --- a/kernel/src/syscall/chdir.rs +++ b/kernel/src/syscall/chdir.rs @@ -11,7 +11,7 @@ pub fn sys_chdir(path_ptr: Vaddr, ctx: &Context) -> Result { let path = ctx.user_space().read_cstring(path_ptr, MAX_FILENAME_LEN)?; debug!("path = {:?}", path); - let mut fs = ctx.process.fs().write(); + let mut fs = ctx.posix_thread.fs().resolver().write(); let dentry = { let path = path.to_string_lossy(); if path.is_empty() { @@ -31,7 +31,7 @@ pub fn sys_fchdir(fd: FileDesc, ctx: &Context) -> Result { debug!("fd = {}", fd); let dentry = { - let file_table = ctx.process.file_table().lock(); + let file_table = ctx.posix_thread.file_table().lock(); let file = file_table.get_file(fd)?; let inode_handle = file .downcast_ref::() @@ -41,6 +41,6 @@ pub fn sys_fchdir(fd: FileDesc, ctx: &Context) -> Result { if dentry.type_() != InodeType::Dir { return_errno_with_message!(Errno::ENOTDIR, "must be directory"); } - ctx.process.fs().write().set_cwd(dentry); + ctx.posix_thread.fs().resolver().write().set_cwd(dentry); Ok(SyscallReturn::Return(0)) } diff --git a/kernel/src/syscall/chmod.rs b/kernel/src/syscall/chmod.rs index 66fa72416..8e5fdc257 100644 --- a/kernel/src/syscall/chmod.rs +++ b/kernel/src/syscall/chmod.rs @@ -14,7 +14,7 @@ pub fn sys_fchmod(fd: FileDesc, mode: u16, ctx: &Context) -> Result Result Result { let path = ctx.user_space().read_cstring(path_ptr, MAX_FILENAME_LEN)?; debug!("path = {:?}", path); - let mut fs = ctx.process.fs().write(); + let mut fs = ctx.posix_thread.fs().resolver().write(); let dentry = { let path = path.to_string_lossy(); if path.is_empty() { diff --git a/kernel/src/syscall/close.rs b/kernel/src/syscall/close.rs index 6ce27f93e..ae2a2b228 100644 --- a/kernel/src/syscall/close.rs +++ b/kernel/src/syscall/close.rs @@ -7,7 +7,7 @@ pub fn sys_close(fd: FileDesc, ctx: &Context) -> Result { debug!("fd = {}", fd); let file = { - let mut file_table = ctx.process.file_table().lock(); + let mut file_table = ctx.posix_thread.file_table().lock(); let _ = file_table.get_file(fd)?; file_table.close_file(fd).unwrap() }; diff --git a/kernel/src/syscall/dup.rs b/kernel/src/syscall/dup.rs index 4b3765b1d..3fc40f3a3 100644 --- a/kernel/src/syscall/dup.rs +++ b/kernel/src/syscall/dup.rs @@ -10,7 +10,7 @@ use crate::{ pub fn sys_dup(old_fd: FileDesc, ctx: &Context) -> Result { debug!("old_fd = {}", old_fd); - let mut file_table = ctx.process.file_table().lock(); + let mut file_table = ctx.posix_thread.file_table().lock(); let new_fd = file_table.dup(old_fd, 0, FdFlags::empty())?; Ok(SyscallReturn::Return(new_fd as _)) @@ -20,7 +20,7 @@ pub fn sys_dup2(old_fd: FileDesc, new_fd: FileDesc, ctx: &Context) -> Result= current + >= ctx + .process .resource_limits() .lock() .get_rlimit(ResourceType::RLIMIT_NOFILE) @@ -66,7 +66,7 @@ fn do_dup3( return_errno!(Errno::EBADF); } - let mut file_table = current.file_table().lock(); + let mut file_table = ctx.posix_thread.file_table().lock(); let _ = file_table.close_file(new_fd); let new_fd = file_table.dup(old_fd, new_fd, flags)?; diff --git a/kernel/src/syscall/epoll.rs b/kernel/src/syscall/epoll.rs index b4b41fa92..14d26ca86 100644 --- a/kernel/src/syscall/epoll.rs +++ b/kernel/src/syscall/epoll.rs @@ -41,7 +41,7 @@ pub fn sys_epoll_create1(flags: u32, ctx: &Context) -> Result { }; let epoll_file: Arc = EpollFile::new(); - let mut file_table = ctx.process.file_table().lock(); + let mut file_table = ctx.posix_thread.file_table().lock(); let fd = file_table.insert(epoll_file, fd_flags); Ok(SyscallReturn::Return(fd as _)) } @@ -80,7 +80,7 @@ pub fn sys_epoll_ctl( }; let file = { - let file_table = ctx.process.file_table().lock(); + let file_table = ctx.posix_thread.file_table().lock(); file_table.get_file(epfd)?.clone() }; let epoll_file = file @@ -110,7 +110,7 @@ fn do_epoll_wait( }; let epoll_file_arc = { - let file_table = ctx.process.file_table().lock(); + let file_table = ctx.posix_thread.file_table().lock(); file_table.get_file(epfd)?.clone() }; let epoll_file = epoll_file_arc diff --git a/kernel/src/syscall/eventfd.rs b/kernel/src/syscall/eventfd.rs index e282e51d8..af2584377 100644 --- a/kernel/src/syscall/eventfd.rs +++ b/kernel/src/syscall/eventfd.rs @@ -54,7 +54,7 @@ pub fn sys_eventfd2(init_val: u64, flags: u32, ctx: &Context) -> Result FileDesc { let event_file = EventFile::new(init_val, flags); let fd = { - let mut file_table = ctx.process.file_table().lock(); + let mut file_table = ctx.posix_thread.file_table().lock(); let fd_flags = if flags.contains(Flags::EFD_CLOEXEC) { FdFlags::CLOEXEC } else { diff --git a/kernel/src/syscall/execve.rs b/kernel/src/syscall/execve.rs index a91896f55..f6367d378 100644 --- a/kernel/src/syscall/execve.rs +++ b/kernel/src/syscall/execve.rs @@ -62,7 +62,7 @@ fn lookup_executable_file( flags: OpenFlags, ctx: &Context, ) -> Result { - let fs_resolver = ctx.process.fs().read(); + let fs_resolver = ctx.posix_thread.fs().resolver().read(); let dentry = if flags.contains(OpenFlags::AT_EMPTY_PATH) && filename.is_empty() { fs_resolver.lookup_from_fd(dfd) } else { @@ -110,12 +110,13 @@ fn do_execve( *posix_thread.clear_child_tid().lock() = 0; // Ensure that the file descriptors with the close-on-exec flag are closed. - let closed_files = process.file_table().lock().close_files_on_exec(); + // FIXME: This is just wrong if the file table is shared with other processes. + let closed_files = posix_thread.file_table().lock().close_files_on_exec(); drop(closed_files); debug!("load program to root vmar"); let (new_executable_path, elf_load_info) = { - let fs_resolver = &*process.fs().read(); + let fs_resolver = &*posix_thread.fs().resolver().read(); let process_vm = process.vm(); load_program_to_vm(process_vm, elf_file.clone(), argv, envp, fs_resolver, 1)? }; diff --git a/kernel/src/syscall/fallocate.rs b/kernel/src/syscall/fallocate.rs index 00fe30b37..91206a7cd 100644 --- a/kernel/src/syscall/fallocate.rs +++ b/kernel/src/syscall/fallocate.rs @@ -22,7 +22,7 @@ pub fn sys_fallocate( check_offset_and_len(offset, len, ctx)?; let file = { - let file_table = ctx.process.file_table().lock(); + let file_table = ctx.posix_thread.file_table().lock(); file_table.get_file(fd)?.clone() }; diff --git a/kernel/src/syscall/fcntl.rs b/kernel/src/syscall/fcntl.rs index 77b6f5ec2..29a3059cc 100644 --- a/kernel/src/syscall/fcntl.rs +++ b/kernel/src/syscall/fcntl.rs @@ -33,13 +33,13 @@ pub fn sys_fcntl(fd: FileDesc, cmd: i32, arg: u64, ctx: &Context) -> Result Result { - let mut file_table = ctx.process.file_table().lock(); + let mut file_table = ctx.posix_thread.file_table().lock(); let new_fd = file_table.dup(fd, arg as FileDesc, flags)?; Ok(SyscallReturn::Return(new_fd as _)) } fn handle_getfd(fd: FileDesc, ctx: &Context) -> Result { - let file_table = ctx.process.file_table().lock(); + let file_table = ctx.posix_thread.file_table().lock(); let entry = file_table.get_entry(fd)?; let fd_flags = entry.flags(); Ok(SyscallReturn::Return(fd_flags.bits() as _)) @@ -51,7 +51,7 @@ fn handle_setfd(fd: FileDesc, arg: u64, ctx: &Context) -> Result } else { FdFlags::from_bits(arg as u8).ok_or(Error::with_message(Errno::EINVAL, "invalid flags"))? }; - let file_table = ctx.process.file_table().lock(); + let file_table = ctx.posix_thread.file_table().lock(); let entry = file_table.get_entry(fd)?; entry.set_flags(flags); Ok(SyscallReturn::Return(0)) @@ -59,7 +59,7 @@ fn handle_setfd(fd: FileDesc, arg: u64, ctx: &Context) -> Result fn handle_getfl(fd: FileDesc, ctx: &Context) -> Result { let file = { - let file_table = ctx.process.file_table().lock(); + let file_table = ctx.posix_thread.file_table().lock(); file_table.get_file(fd)?.clone() }; let status_flags = file.status_flags(); @@ -71,7 +71,7 @@ fn handle_getfl(fd: FileDesc, ctx: &Context) -> Result { fn handle_setfl(fd: FileDesc, arg: u64, ctx: &Context) -> Result { let file = { - let file_table = ctx.process.file_table().lock(); + let file_table = ctx.posix_thread.file_table().lock(); file_table.get_file(fd)?.clone() }; let valid_flags_mask = StatusFlags::O_APPEND @@ -88,7 +88,7 @@ fn handle_setfl(fd: FileDesc, arg: u64, ctx: &Context) -> Result fn handle_getlk(fd: FileDesc, arg: u64, ctx: &Context) -> Result { let file = { - let file_table = ctx.process.file_table().lock(); + let file_table = ctx.posix_thread.file_table().lock(); file_table.get_file(fd)?.clone() }; let lock_mut_ptr = arg as Vaddr; @@ -117,7 +117,7 @@ fn handle_setlk( ctx: &Context, ) -> Result { let file = { - let file_table = ctx.process.file_table().lock(); + let file_table = ctx.posix_thread.file_table().lock(); file_table.get_file(fd)?.clone() }; let lock_mut_ptr = arg as Vaddr; @@ -135,7 +135,7 @@ fn handle_setlk( } fn handle_getown(fd: FileDesc, ctx: &Context) -> Result { - let file_table = ctx.process.file_table().lock(); + let file_table = ctx.posix_thread.file_table().lock(); let file_entry = file_table.get_entry(fd)?; let pid = file_entry.owner().unwrap_or(0); Ok(SyscallReturn::Return(pid as _)) @@ -159,7 +159,7 @@ fn handle_setown(fd: FileDesc, arg: u64, ctx: &Context) -> Result ))?) }; - let mut file_table = ctx.process.file_table().lock(); + let mut file_table = ctx.posix_thread.file_table().lock(); let file_entry = file_table.get_entry_mut(fd)?; file_entry.set_owner(owner_process.as_ref())?; Ok(SyscallReturn::Return(0)) diff --git a/kernel/src/syscall/flock.rs b/kernel/src/syscall/flock.rs index ab0d3c59d..877367fec 100644 --- a/kernel/src/syscall/flock.rs +++ b/kernel/src/syscall/flock.rs @@ -14,7 +14,7 @@ pub fn sys_flock(fd: FileDesc, ops: i32, ctx: &Context) -> Result debug!("flock: fd: {}, ops: {:?}", fd, ops); let file = { - let current = ctx.process; + let current = ctx.posix_thread; let file_table = current.file_table().lock(); file_table.get_file(fd)?.clone() }; diff --git a/kernel/src/syscall/fsync.rs b/kernel/src/syscall/fsync.rs index 4c3135c4d..aad82d108 100644 --- a/kernel/src/syscall/fsync.rs +++ b/kernel/src/syscall/fsync.rs @@ -10,7 +10,7 @@ pub fn sys_fsync(fd: FileDesc, ctx: &Context) -> Result { debug!("fd = {}", fd); let dentry = { - let file_table = ctx.process.file_table().lock(); + let file_table = ctx.posix_thread.file_table().lock(); let file = file_table.get_file(fd)?; let inode_handle = file .downcast_ref::() @@ -25,7 +25,7 @@ pub fn sys_fdatasync(fd: FileDesc, ctx: &Context) -> Result { debug!("fd = {}", fd); let dentry = { - let file_table = ctx.process.file_table().lock(); + let file_table = ctx.posix_thread.file_table().lock(); let file = file_table.get_file(fd)?; let inode_handle = file .downcast_ref::() diff --git a/kernel/src/syscall/getcwd.rs b/kernel/src/syscall/getcwd.rs index 8c19b0a20..76cdc2f24 100644 --- a/kernel/src/syscall/getcwd.rs +++ b/kernel/src/syscall/getcwd.rs @@ -7,9 +7,10 @@ use crate::{ }; pub fn sys_getcwd(buf: Vaddr, len: usize, ctx: &Context) -> Result { - let current = ctx.process; + let current = ctx.posix_thread; let dirent = current .fs() + .resolver() .read() .lookup(&FsPath::new(AT_FDCWD, "").unwrap()) .unwrap(); diff --git a/kernel/src/syscall/getdents64.rs b/kernel/src/syscall/getdents64.rs index b99794f8f..cc3cc188d 100644 --- a/kernel/src/syscall/getdents64.rs +++ b/kernel/src/syscall/getdents64.rs @@ -24,7 +24,7 @@ pub fn sys_getdents( ); let file = { - let file_table = ctx.process.file_table().lock(); + let file_table = ctx.posix_thread.file_table().lock(); file_table.get_file(fd)?.clone() }; let inode_handle = file @@ -54,7 +54,7 @@ pub fn sys_getdents64( ); let file = { - let file_table = ctx.process.file_table().lock(); + let file_table = ctx.posix_thread.file_table().lock(); file_table.get_file(fd)?.clone() }; let inode_handle = file diff --git a/kernel/src/syscall/ioctl.rs b/kernel/src/syscall/ioctl.rs index cd25558ba..6ce785370 100644 --- a/kernel/src/syscall/ioctl.rs +++ b/kernel/src/syscall/ioctl.rs @@ -17,7 +17,7 @@ pub fn sys_ioctl(fd: FileDesc, cmd: u32, arg: Vaddr, ctx: &Context) -> Result Result { // Clears the close-on-exec flag of the file. - let file_table = ctx.process.file_table().lock(); + let file_table = ctx.posix_thread.file_table().lock(); let entry = file_table.get_entry(fd)?; entry.set_flags(entry.flags() & (!FdFlags::CLOEXEC)); 0 diff --git a/kernel/src/syscall/link.rs b/kernel/src/syscall/link.rs index d68846656..0e33cf02c 100644 --- a/kernel/src/syscall/link.rs +++ b/kernel/src/syscall/link.rs @@ -44,7 +44,7 @@ pub fn sys_linkat( let old_fs_path = FsPath::new(old_dirfd, old_path.as_ref())?; let new_fs_path = FsPath::new(new_dirfd, new_path.as_ref())?; - let fs = ctx.process.fs().read(); + let fs = ctx.posix_thread.fs().resolver().read(); let old_dentry = if flags.contains(LinkFlags::AT_SYMLINK_FOLLOW) { fs.lookup(&old_fs_path)? } else { diff --git a/kernel/src/syscall/lseek.rs b/kernel/src/syscall/lseek.rs index 6ad9c0919..a487e6216 100644 --- a/kernel/src/syscall/lseek.rs +++ b/kernel/src/syscall/lseek.rs @@ -21,7 +21,7 @@ pub fn sys_lseek(fd: FileDesc, offset: isize, whence: u32, ctx: &Context) -> Res _ => return_errno!(Errno::EINVAL), }; let file = { - let file_table = ctx.process.file_table().lock(); + let file_table = ctx.posix_thread.file_table().lock(); file_table.get_file(fd)?.clone() }; diff --git a/kernel/src/syscall/mkdir.rs b/kernel/src/syscall/mkdir.rs index f14859042..8242b1050 100644 --- a/kernel/src/syscall/mkdir.rs +++ b/kernel/src/syscall/mkdir.rs @@ -20,7 +20,7 @@ pub fn sys_mkdirat( let path = ctx.user_space().read_cstring(path_addr, MAX_FILENAME_LEN)?; debug!("dirfd = {}, path = {:?}, mode = {}", dirfd, path, mode); - let current = ctx.process; + let current = ctx.posix_thread; let (dir_dentry, name) = { let path = path.to_string_lossy(); if path.is_empty() { @@ -29,12 +29,13 @@ pub fn sys_mkdirat( let fs_path = FsPath::new(dirfd, path.as_ref())?; current .fs() + .resolver() .read() .lookup_dir_and_new_basename(&fs_path, true)? }; let inode_mode = { - let mask_mode = mode & !current.umask().read().get(); + let mask_mode = mode & !current.fs().umask().read().get(); InodeMode::from_bits_truncate(mask_mode) }; let _ = dir_dentry.new_fs_child(name.trim_end_matches('/'), InodeType::Dir, inode_mode)?; diff --git a/kernel/src/syscall/mknod.rs b/kernel/src/syscall/mknod.rs index 182271a98..05683f8b5 100644 --- a/kernel/src/syscall/mknod.rs +++ b/kernel/src/syscall/mknod.rs @@ -20,9 +20,9 @@ pub fn sys_mknodat( ctx: &Context, ) -> Result { let path = ctx.user_space().read_cstring(path_addr, MAX_FILENAME_LEN)?; - let current = ctx.process; + let current = ctx.posix_thread; let inode_mode = { - let mask_mode = mode & !current.umask().read().get(); + let mask_mode = mode & !current.fs().umask().read().get(); InodeMode::from_bits_truncate(mask_mode) }; let inode_type = InodeType::from_raw_mode(mode)?; @@ -39,6 +39,7 @@ pub fn sys_mknodat( let fs_path = FsPath::new(dirfd, path.as_ref())?; current .fs() + .resolver() .read() .lookup_dir_and_new_basename(&fs_path, false)? }; diff --git a/kernel/src/syscall/mmap.rs b/kernel/src/syscall/mmap.rs index 93bc277ab..fc22030b2 100644 --- a/kernel/src/syscall/mmap.rs +++ b/kernel/src/syscall/mmap.rs @@ -116,7 +116,7 @@ fn do_sys_mmap( } } else { let vmo = { - let file_table = ctx.process.file_table().lock(); + let file_table = ctx.posix_thread.file_table().lock(); let file = file_table.get_file(fd)?; let inode_handle = file .downcast_ref::() diff --git a/kernel/src/syscall/mount.rs b/kernel/src/syscall/mount.rs index 418ebac7e..9b1315e87 100644 --- a/kernel/src/syscall/mount.rs +++ b/kernel/src/syscall/mount.rs @@ -40,7 +40,7 @@ pub fn sys_mount( return_errno_with_message!(Errno::ENOENT, "dirname is empty"); } let fs_path = FsPath::new(AT_FDCWD, dirname.as_ref())?; - ctx.process.fs().read().lookup(&fs_path)? + ctx.posix_thread.fs().resolver().read().lookup(&fs_path)? }; if mount_flags.contains(MountFlags::MS_REMOUNT) && mount_flags.contains(MountFlags::MS_BIND) { @@ -93,7 +93,7 @@ fn do_bind_mount( return_errno_with_message!(Errno::ENOENT, "src_name is empty"); } let fs_path = FsPath::new(AT_FDCWD, src_name.as_ref())?; - ctx.process.fs().read().lookup(&fs_path)? + ctx.posix_thread.fs().resolver().read().lookup(&fs_path)? }; if src_dentry.type_() != InodeType::Dir { @@ -116,7 +116,7 @@ fn do_move_mount_old(src_name: CString, dst_dentry: Dentry, ctx: &Context) -> Re return_errno_with_message!(Errno::ENOENT, "src_name is empty"); } let fs_path = FsPath::new(AT_FDCWD, src_name.as_ref())?; - ctx.process.fs().read().lookup(&fs_path)? + ctx.posix_thread.fs().resolver().read().lookup(&fs_path)? }; if !src_dentry.is_root_of_mount() { diff --git a/kernel/src/syscall/open.rs b/kernel/src/syscall/open.rs index 08e54d6dd..6cee6c2a3 100644 --- a/kernel/src/syscall/open.rs +++ b/kernel/src/syscall/open.rs @@ -24,12 +24,16 @@ pub fn sys_openat( dirfd, path, flags, mode ); - let current = ctx.process; + let current = ctx.posix_thread; let file_handle = { let path = path.to_string_lossy(); let fs_path = FsPath::new(dirfd, path.as_ref())?; - let mask_mode = mode & !current.umask().read().get(); - let inode_handle = current.fs().read().open(&fs_path, flags, mask_mode)?; + let mask_mode = mode & !current.fs().umask().read().get(); + let inode_handle = current + .fs() + .resolver() + .read() + .open(&fs_path, flags, mask_mode)?; Arc::new(inode_handle) }; let mut file_table = current.file_table().lock(); diff --git a/kernel/src/syscall/pipe.rs b/kernel/src/syscall/pipe.rs index 5c1046ed0..650075e94 100644 --- a/kernel/src/syscall/pipe.rs +++ b/kernel/src/syscall/pipe.rs @@ -21,7 +21,7 @@ pub fn sys_pipe2(fds: Vaddr, flags: u32, ctx: &Context) -> Result FdFlags::empty() }; - let mut file_table = ctx.process.file_table().lock(); + let mut file_table = ctx.posix_thread.file_table().lock(); let pipe_fds = PipeFds { reader_fd: file_table.insert(pipe_reader, fd_flags), diff --git a/kernel/src/syscall/poll.rs b/kernel/src/syscall/poll.rs index c05cfd451..55e528ea2 100644 --- a/kernel/src/syscall/poll.rs +++ b/kernel/src/syscall/poll.rs @@ -100,7 +100,7 @@ enum FileResult { /// Holds all the files we're going to poll. fn hold_files(poll_fds: &[PollFd], ctx: &Context) -> (FileResult, Vec>>) { - let file_table = ctx.process.file_table().lock(); + let file_table = ctx.posix_thread.file_table().lock(); let mut files = Vec::with_capacity(poll_fds.len()); let mut result = FileResult::AllValid; diff --git a/kernel/src/syscall/pread64.rs b/kernel/src/syscall/pread64.rs index ff7f38432..a20adcb27 100644 --- a/kernel/src/syscall/pread64.rs +++ b/kernel/src/syscall/pread64.rs @@ -19,7 +19,7 @@ pub fn sys_pread64( return_errno_with_message!(Errno::EINVAL, "offset cannot be negative"); } let file = { - let filetable = ctx.process.file_table().lock(); + let filetable = ctx.posix_thread.file_table().lock(); filetable.get_file(fd)?.clone() }; // TODO: Check (f.file->f_mode & FMODE_PREAD); We don't have f_mode in our FileLike trait diff --git a/kernel/src/syscall/preadv.rs b/kernel/src/syscall/preadv.rs index a87cfc94f..5a62b90c3 100644 --- a/kernel/src/syscall/preadv.rs +++ b/kernel/src/syscall/preadv.rs @@ -66,7 +66,7 @@ fn do_sys_preadv( } let file = { - let filetable = ctx.process.file_table().lock(); + let filetable = ctx.posix_thread.file_table().lock(); filetable.get_file(fd)?.clone() }; @@ -128,7 +128,7 @@ fn do_sys_readv( ); let file = { - let filetable = ctx.process.file_table().lock(); + let filetable = ctx.posix_thread.file_table().lock(); filetable.get_file(fd)?.clone() }; diff --git a/kernel/src/syscall/pwrite64.rs b/kernel/src/syscall/pwrite64.rs index c3b2a0909..69fb333f6 100644 --- a/kernel/src/syscall/pwrite64.rs +++ b/kernel/src/syscall/pwrite64.rs @@ -18,7 +18,7 @@ pub fn sys_pwrite64( return_errno_with_message!(Errno::EINVAL, "offset cannot be negative"); } let file = { - let filetable = ctx.process.file_table().lock(); + let filetable = ctx.posix_thread.file_table().lock(); filetable.get_file(fd)?.clone() }; // TODO: Check (f.file->f_mode & FMODE_PWRITE); We don't have f_mode in our FileLike trait diff --git a/kernel/src/syscall/pwritev.rs b/kernel/src/syscall/pwritev.rs index 939c048cc..c2975cddd 100644 --- a/kernel/src/syscall/pwritev.rs +++ b/kernel/src/syscall/pwritev.rs @@ -61,7 +61,7 @@ fn do_sys_pwritev( return_errno_with_message!(Errno::EINVAL, "offset cannot be negative"); } let file = { - let filetable = ctx.process.file_table().lock(); + let filetable = ctx.posix_thread.file_table().lock(); filetable.get_file(fd)?.clone() }; // TODO: Check (f.file->f_mode & FMODE_PREAD); We don't have f_mode in our FileLike trait @@ -117,7 +117,7 @@ fn do_sys_writev( fd, io_vec_ptr, io_vec_count ); let file = { - let filetable = ctx.process.file_table().lock(); + let filetable = ctx.posix_thread.file_table().lock(); filetable.get_file(fd)?.clone() }; let mut total_len = 0; diff --git a/kernel/src/syscall/read.rs b/kernel/src/syscall/read.rs index 4d92b7df0..182ec87a7 100644 --- a/kernel/src/syscall/read.rs +++ b/kernel/src/syscall/read.rs @@ -15,7 +15,7 @@ pub fn sys_read( ); let file = { - let file_table = ctx.process.file_table().lock(); + let file_table = ctx.posix_thread.file_table().lock(); file_table.get_file(fd)?.clone() }; diff --git a/kernel/src/syscall/readlink.rs b/kernel/src/syscall/readlink.rs index 89db43d88..45d8729c7 100644 --- a/kernel/src/syscall/readlink.rs +++ b/kernel/src/syscall/readlink.rs @@ -30,7 +30,11 @@ pub fn sys_readlinkat( return_errno_with_message!(Errno::ENOENT, "path is empty"); } let fs_path = FsPath::new(dirfd, path.as_ref())?; - ctx.process.fs().read().lookup_no_follow(&fs_path)? + ctx.posix_thread + .fs() + .resolver() + .read() + .lookup_no_follow(&fs_path)? }; let linkpath = dentry.inode().read_link()?; let bytes = linkpath.as_bytes(); diff --git a/kernel/src/syscall/rename.rs b/kernel/src/syscall/rename.rs index 02bb3b2bb..ba754263a 100644 --- a/kernel/src/syscall/rename.rs +++ b/kernel/src/syscall/rename.rs @@ -26,7 +26,7 @@ pub fn sys_renameat( old_dirfd, old_path, new_dirfd, new_path ); - let fs = ctx.process.fs().read(); + let fs = ctx.posix_thread.fs().resolver().read(); let (old_dir_dentry, old_name) = { let old_path = old_path.to_string_lossy(); diff --git a/kernel/src/syscall/rmdir.rs b/kernel/src/syscall/rmdir.rs index e75847739..c278b5182 100644 --- a/kernel/src/syscall/rmdir.rs +++ b/kernel/src/syscall/rmdir.rs @@ -28,7 +28,11 @@ pub(super) fn sys_rmdirat( return_errno_with_message!(Errno::EBUSY, "is root directory"); } let fs_path = FsPath::new(dirfd, path_addr.as_ref())?; - ctx.process.fs().read().lookup_dir_and_base_name(&fs_path)? + ctx.posix_thread + .fs() + .resolver() + .read() + .lookup_dir_and_base_name(&fs_path)? }; dir_dentry.rmdir(name.trim_end_matches('/'))?; Ok(SyscallReturn::Return(0)) diff --git a/kernel/src/syscall/sendfile.rs b/kernel/src/syscall/sendfile.rs index 40d348af1..6891fc742 100644 --- a/kernel/src/syscall/sendfile.rs +++ b/kernel/src/syscall/sendfile.rs @@ -34,7 +34,7 @@ pub fn sys_sendfile( }; let (out_file, in_file) = { - let file_table = ctx.process.file_table().lock(); + let file_table = ctx.posix_thread.file_table().lock(); let out_file = file_table.get_file(out_fd)?.clone(); // FIXME: the in_file must support mmap-like operations (i.e., it cannot be a socket). let in_file = file_table.get_file(in_fd)?.clone(); diff --git a/kernel/src/syscall/socket.rs b/kernel/src/syscall/socket.rs index 9bc51756c..fa87294f7 100644 --- a/kernel/src/syscall/socket.rs +++ b/kernel/src/syscall/socket.rs @@ -43,7 +43,7 @@ pub fn sys_socket(domain: i32, type_: i32, protocol: i32, ctx: &Context) -> Resu _ => return_errno_with_message!(Errno::EAFNOSUPPORT, "unsupported domain"), }; let fd = { - let mut file_table = ctx.process.file_table().lock(); + let mut file_table = ctx.posix_thread.file_table().lock(); let fd_flags = if sock_flags.contains(SockFlags::SOCK_CLOEXEC) { FdFlags::CLOEXEC } else { diff --git a/kernel/src/syscall/socketpair.rs b/kernel/src/syscall/socketpair.rs index f3c623194..285c176a3 100644 --- a/kernel/src/syscall/socketpair.rs +++ b/kernel/src/syscall/socketpair.rs @@ -37,7 +37,7 @@ pub fn sys_socketpair( }; let socket_fds = { - let mut file_table = ctx.process.file_table().lock(); + let mut file_table = ctx.posix_thread.file_table().lock(); let fd_flags = if sock_flags.contains(SockFlags::SOCK_CLOEXEC) { FdFlags::CLOEXEC } else { diff --git a/kernel/src/syscall/stat.rs b/kernel/src/syscall/stat.rs index b08c76ad3..6667338c5 100644 --- a/kernel/src/syscall/stat.rs +++ b/kernel/src/syscall/stat.rs @@ -16,7 +16,7 @@ pub fn sys_fstat(fd: FileDesc, stat_buf_ptr: Vaddr, ctx: &Context) -> Result Resu let dentry = { let path = path.to_string_lossy(); let fs_path = FsPath::try_from(path.as_ref())?; - ctx.process.fs().read().lookup(&fs_path)? + ctx.posix_thread.fs().resolver().read().lookup(&fs_path)? }; let statfs = Statfs::from(dentry.fs().sb()); user_space.write_val(statfs_buf_ptr, &statfs)?; @@ -30,7 +30,7 @@ pub fn sys_fstatfs(fd: FileDesc, statfs_buf_ptr: Vaddr, ctx: &Context) -> Result debug!("fd = {}, statfs_buf_addr = 0x{:x}", fd, statfs_buf_ptr); let fs = { - let file_table = ctx.process.file_table().lock(); + let file_table = ctx.posix_thread.file_table().lock(); let file = file_table.get_file(fd)?; let inode_handle = file .downcast_ref::() diff --git a/kernel/src/syscall/symlink.rs b/kernel/src/syscall/symlink.rs index bb273c374..0e9864453 100644 --- a/kernel/src/syscall/symlink.rs +++ b/kernel/src/syscall/symlink.rs @@ -35,8 +35,9 @@ pub fn sys_symlinkat( return_errno_with_message!(Errno::ENOENT, "linkpath is empty"); } let fs_path = FsPath::new(dirfd, linkpath.as_ref())?; - ctx.process + ctx.posix_thread .fs() + .resolver() .read() .lookup_dir_and_new_basename(&fs_path, false)? }; diff --git a/kernel/src/syscall/truncate.rs b/kernel/src/syscall/truncate.rs index 3ff59b3c0..acafade14 100644 --- a/kernel/src/syscall/truncate.rs +++ b/kernel/src/syscall/truncate.rs @@ -17,7 +17,7 @@ pub fn sys_ftruncate(fd: FileDesc, len: isize, ctx: &Context) -> Result Result Result { debug!("mask = 0o{:o}", mask); - let old_mask = ctx.process.umask().write().set(mask); + let old_mask = ctx.posix_thread.fs().umask().write().set(mask); Ok(SyscallReturn::Return(old_mask as _)) } diff --git a/kernel/src/syscall/umount.rs b/kernel/src/syscall/umount.rs index a5d6a33de..f64ab1695 100644 --- a/kernel/src/syscall/umount.rs +++ b/kernel/src/syscall/umount.rs @@ -21,9 +21,13 @@ pub fn sys_umount(path_addr: Vaddr, flags: u64, ctx: &Context) -> Result Result> { - let current = current!(); + let current = current_thread!(); + let current = current.as_posix_thread().unwrap(); let file_table = current.file_table().lock(); file_table.get_socket(sockfd) }