Move FS things to PosixThread

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)?

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()
         };

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<Dentry> {
-        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)?

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;

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::<FileDesc>()
                 .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::<ProcDir<FdDirOps>>().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())

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

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<Vec<u8>> {
         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();

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<Vec<u8>> {
         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!(
+        writeln!(status_output, "FDSize:\t{}", file_table.lock().len()).unwrap();
-            status_output,
-            "FDSize:\t{}",
-            process.file_table().lock().len()
-        )
-        .unwrap();
         writeln!(status_output, "Threads:\t{}", process.tasks().lock().len()).unwrap();
         Ok(status_output.into_bytes())
     }

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<FsResolver>,
+    umask: RwLock<FileCreationMask>,
+}
+
+impl ThreadFsInfo {
+    /// Returns the associated `FsResolver`.
+    pub fn resolver(&self) -> &RwMutex<FsResolver> {
+        &self.resolver
+    }
+
+    /// Returns the associated `FileCreationMask`.
+    pub fn umask(&self) -> &RwLock<FileCreationMask> {
+        &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())),
+        }
+    }
+}

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<Dentry> {
     let dentry = {
-        let current = current!();
+        let current = current_thread!();
-        let fs = current.fs().read();
+        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<Dentry> {
     let (parent_pathname, file_name) = split_path(path);
 
     let parent = {
-        let current = current!();
+        let current = current_thread!();
-        let fs = current.fs().read();
+        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)?
     };

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);
+    let child_fs = clone_fs(posix_thread.fs(), clone_flags);
-
-    // clone umask
-    let child_umask = {
-        let parent_umask = process.umask().read().get();
-        Arc::new(RwLock::new(FileCreationMask::new(parent_umask)))
-    };
 
     // 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(
+fn clone_fs(parent_fs: &Arc<ThreadFsInfo>, clone_flags: CloneFlags) -> Arc<ThreadFsInfo> {
-    parent_fs: &Arc<RwMutex<FsResolver>>,
-    clone_flags: CloneFlags,
-) -> Arc<RwMutex<FsResolver>> {
     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())
     }
 }
 

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
+    // Close all files then exit the process.
-    let files = current.file_table().lock().close_all();
+    //
+    // 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

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<ThreadName>,
     set_child_tid: Vaddr,
     clear_child_tid: Vaddr,
+    file_table: Option<Arc<SpinLock<FileTable>>>,
+    fs: Option<Arc<ThreadFsInfo>>,
     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<SpinLock<FileTable>>) -> Self {
+        self.file_table = Some(file_table);
+        self
+    }
+
+    pub fn fs(mut self, fs: Arc<ThreadFsInfo>) -> 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),

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<SpinLock<FileTable>>,
+    /// File system
+    fs: Arc<ThreadFsInfo>,
+
     // Signal
     /// Blocked signals
     sig_mask: AtomicSigMask,
@@ -107,6 +114,14 @@ impl PosixThread {
         &self.clear_child_tid
     }
 
+    pub fn file_table(&self) -> &Arc<SpinLock<FileTable>> {
+        &self.file_table
+    }
+
+    pub fn fs(&self) -> &Arc<ThreadFsInfo> {
+        &self.fs
+    }
+
     /// Get the reference to the signal mask of the thread.
     ///
     /// Note that while this function offers mutable access to the signal mask,

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<Process>,
     argv: Vec<CString>,
     envp: Vec<CString>,
 ) -> Result<Arc<Task>> {
-    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())
 }

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<Vec<CString>>,
     envp: Option<Vec<CString>>,
     process_vm: Option<ProcessVm>,
-    file_table: Option<Arc<SpinLock<FileTable>>>,
-    fs: Option<Arc<RwMutex<FsResolver>>>,
-    umask: Option<Arc<RwLock<FileCreationMask>>>,
     resource_limits: Option<ResourceLimits>,
     sig_dispositions: Option<Arc<Mutex<SigDispositions>>>,
     credentials: Option<Credentials>,
@@ -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<SpinLock<FileTable>>) -> &mut Self {
-        self.file_table = Some(file_table);
-        self
-    }
-
-    pub fn fs(&mut self, fs: Arc<RwMutex<FsResolver>>) -> &mut Self {
-        self.fs = Some(fs);
-        self
-    }
-
-    pub fn umask(&mut self, umask: Arc<RwLock<FileCreationMask>>) -> &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(),

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<BTreeMap<Pid, Arc<Process>>>,
     /// Process group
     pub(super) process_group: Mutex<Weak<ProcessGroup>>,
-    /// File table
-    file_table: Arc<SpinLock<FileTable>>,
-    /// FsResolver
-    fs: Arc<RwMutex<FsResolver>>,
-    /// umask
-    umask: Arc<RwLock<FileCreationMask>>,
     /// resource limits
     resource_limits: Mutex<ResourceLimits>,
     /// Scheduling priority nice value
@@ -185,10 +178,6 @@ impl Process {
         executable_path: String,
         process_vm: ProcessVm,
 
-        fs: Arc<RwMutex<FsResolver>>,
-        file_table: Arc<SpinLock<FileTable>>,
-
-        umask: Arc<RwLock<FileCreationMask>>,
         resource_limits: ResourceLimits,
         nice: Nice,
         sig_dispositions: Arc<Mutex<SigDispositions>>,
@@ -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<SpinLock<FileTable>> {
-        &self.file_table
-    }
-
-    pub fn fs(&self) -> &Arc<RwMutex<FsResolver>> {
-        &self.fs
-    }
-
-    pub fn umask(&self) -> &Arc<RwLock<FileCreationMask>> {
-        &self.umask
-    }
-
     // ****************** Signal ******************
 
     pub fn sig_dispositions(&self) -> &Arc<Mutex<SigDispositions>> {
@@ -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())),

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)
     };
 

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 {

kernel/src/syscall/chdir.rs

@@ -11,7 +11,7 @@ pub fn sys_chdir(path_ptr: Vaddr, ctx: &Context) -> Result<SyscallReturn> {
     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<SyscallReturn> {
     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::<InodeHandle>()
@@ -41,6 +41,6 @@ pub fn sys_fchdir(fd: FileDesc, ctx: &Context) -> Result<SyscallReturn> {
     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))
 }

kernel/src/syscall/chmod.rs

@@ -14,7 +14,7 @@ pub fn sys_fchmod(fd: FileDesc, mode: u16, ctx: &Context) -> Result<SyscallRetur
     debug!("fd = {}, mode = 0o{:o}", fd, mode);
 
     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()
     };
     file.set_mode(InodeMode::from_bits_truncate(mode))?;
@@ -42,7 +42,7 @@ pub fn sys_fchmodat(
             return_errno_with_message!(Errno::ENOENT, "path is empty");
         }
         let fs_path = FsPath::new(dirfd, path.as_ref())?;
-        ctx.process.fs().read().lookup(&fs_path)?
+        ctx.posix_thread.fs().resolver().read().lookup(&fs_path)?
     };
     dentry.set_mode(InodeMode::from_bits_truncate(mode))?;
     Ok(SyscallReturn::Return(0))

kernel/src/syscall/chown.rs

@@ -21,7 +21,7 @@ pub fn sys_fchown(fd: FileDesc, uid: i32, gid: i32, ctx: &Context) -> Result<Sys
     }
 
     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()
     };
     if let Some(uid) = uid {
@@ -80,7 +80,7 @@ pub fn sys_fchownat(
     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(ChownFlags::AT_SYMLINK_NOFOLLOW) {
             fs.lookup_no_follow(&fs_path)?
         } else {

kernel/src/syscall/chroot.rs

@@ -11,7 +11,7 @@ pub fn sys_chroot(path_ptr: Vaddr, ctx: &Context) -> Result<SyscallReturn> {
     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() {

kernel/src/syscall/close.rs

@@ -7,7 +7,7 @@ pub fn sys_close(fd: FileDesc, ctx: &Context) -> Result<SyscallReturn> {
     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()
     };

kernel/src/syscall/dup.rs

@@ -10,7 +10,7 @@ use crate::{
 pub fn sys_dup(old_fd: FileDesc, ctx: &Context) -> Result<SyscallReturn> {
     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<Sys
     debug!("old_fd = {}, new_fd = {}", old_fd, new_fd);
 
     if old_fd == new_fd {
-        let file_table = ctx.process.file_table().lock();
+        let file_table = ctx.posix_thread.file_table().lock();
         let _ = file_table.get_file(old_fd)?;
         return Ok(SyscallReturn::Return(new_fd as _));
     }
@@ -55,9 +55,9 @@ fn do_dup3(
         return_errno!(Errno::EINVAL);
     }
 
-    let current = ctx.process;
     if new_fd
-        >= 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)?;
 

kernel/src/syscall/epoll.rs

@@ -41,7 +41,7 @@ pub fn sys_epoll_create1(flags: u32, ctx: &Context) -> Result<SyscallReturn> {
     };
 
     let epoll_file: Arc<EpollFile> = 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

kernel/src/syscall/eventfd.rs

@@ -54,7 +54,7 @@ pub fn sys_eventfd2(init_val: u64, flags: u32, ctx: &Context) -> Result<SyscallR
 fn do_sys_eventfd2(init_val: u64, flags: Flags, ctx: &Context) -> 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 {

kernel/src/syscall/execve.rs

@@ -62,7 +62,7 @@ fn lookup_executable_file(
     flags: OpenFlags,
     ctx: &Context,
 ) -> Result<Dentry> {
-    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)?
     };

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()
     };
 

kernel/src/syscall/fcntl.rs

@@ -33,13 +33,13 @@ pub fn sys_fcntl(fd: FileDesc, cmd: i32, arg: u64, ctx: &Context) -> Result<Sysc
 }
 
 fn handle_dupfd(fd: FileDesc, arg: u64, flags: FdFlags, ctx: &Context) -> Result<SyscallReturn> {
-    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<SyscallReturn> {
-    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<SyscallReturn>
     } 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<SyscallReturn>
 
 fn handle_getfl(fd: FileDesc, ctx: &Context) -> Result<SyscallReturn> {
     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<SyscallReturn> {
 
 fn handle_setfl(fd: FileDesc, arg: u64, ctx: &Context) -> Result<SyscallReturn> {
     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<SyscallReturn>
 
 fn handle_getlk(fd: FileDesc, arg: u64, ctx: &Context) -> Result<SyscallReturn> {
     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<SyscallReturn> {
     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<SyscallReturn> {
-    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<SyscallReturn>
         ))?)
     };
 
-    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))

kernel/src/syscall/flock.rs

@@ -14,7 +14,7 @@ pub fn sys_flock(fd: FileDesc, ops: i32, ctx: &Context) -> Result<SyscallReturn>
     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()
     };

kernel/src/syscall/fsync.rs

@@ -10,7 +10,7 @@ pub fn sys_fsync(fd: FileDesc, ctx: &Context) -> Result<SyscallReturn> {
     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::<InodeHandle>()
@@ -25,7 +25,7 @@ pub fn sys_fdatasync(fd: FileDesc, ctx: &Context) -> Result<SyscallReturn> {
     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::<InodeHandle>()

kernel/src/syscall/getcwd.rs

@@ -7,9 +7,10 @@ use crate::{
 };
 
 pub fn sys_getcwd(buf: Vaddr, len: usize, ctx: &Context) -> Result<SyscallReturn> {
-    let current = ctx.process;
+    let current = ctx.posix_thread;
     let dirent = current
         .fs()
+        .resolver()
         .read()
         .lookup(&FsPath::new(AT_FDCWD, "").unwrap())
         .unwrap();

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

kernel/src/syscall/ioctl.rs

@@ -17,7 +17,7 @@ pub fn sys_ioctl(fd: FileDesc, cmd: u32, arg: Vaddr, ctx: &Context) -> Result<Sy
     );
 
     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 res = match ioctl_cmd {
@@ -44,14 +44,14 @@ pub fn sys_ioctl(fd: FileDesc, cmd: u32, arg: Vaddr, ctx: &Context) -> Result<Sy
             // Follow the implementation of fcntl()
 
             let flags = FdFlags::CLOEXEC;
-            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);
             0
         }
         IoctlCmd::FIONCLEX => {
             // 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

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 {

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()
     };
 

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)?;

kernel/src/syscall/mknod.rs

@@ -20,9 +20,9 @@ pub fn sys_mknodat(
     ctx: &Context,
 ) -> Result<SyscallReturn> {
     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)?
     };

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::<InodeHandle>()

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() {

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 mask_mode = mode & !current.fs().umask().read().get();
-        let inode_handle = current.fs().read().open(&fs_path, flags, mask_mode)?;
+        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();

kernel/src/syscall/pipe.rs

@@ -21,7 +21,7 @@ pub fn sys_pipe2(fds: Vaddr, flags: u32, ctx: &Context) -> Result<SyscallReturn>
         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),

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<Option<Arc<dyn FileLike>>>) {
-    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;

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

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()
     };
 

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

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;

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()
     };
 

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();

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();

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))

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();

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 {

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 {

kernel/src/syscall/stat.rs

@@ -16,7 +16,7 @@ pub fn sys_fstat(fd: FileDesc, stat_buf_ptr: Vaddr, ctx: &Context) -> Result<Sys
     debug!("fd = {}, stat_buf_addr = 0x{:x}", fd, stat_buf_ptr);
 
     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()
     };
 
@@ -66,7 +66,7 @@ pub fn sys_fstatat(
     let dentry = {
         let filename = filename.to_string_lossy();
         let fs_path = FsPath::new(dirfd, filename.as_ref())?;
-        let fs = ctx.process.fs().read();
+        let fs = ctx.posix_thread.fs().resolver().read();
         if flags.contains(StatFlags::AT_SYMLINK_NOFOLLOW) {
             fs.lookup_no_follow(&fs_path)?
         } else {

kernel/src/syscall/statfs.rs

@@ -19,7 +19,7 @@ pub fn sys_statfs(path_ptr: Vaddr, statfs_buf_ptr: Vaddr, ctx: &Context) -> 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::<InodeHandle>()

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)?
     };

kernel/src/syscall/truncate.rs

@@ -17,7 +17,7 @@ pub fn sys_ftruncate(fd: FileDesc, len: isize, ctx: &Context) -> Result<SyscallR
     check_length(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()
     };
 
@@ -37,7 +37,7 @@ pub fn sys_truncate(path_ptr: Vaddr, len: isize, ctx: &Context) -> Result<Syscal
             return_errno_with_message!(Errno::ENOENT, "path is empty");
         }
         let fs_path = FsPath::new(AT_FDCWD, path.as_ref())?;
-        ctx.process.fs().read().lookup(&fs_path)?
+        ctx.posix_thread.fs().resolver().read().lookup(&fs_path)?
     };
     dir_dentry.resize(len as usize)?;
     Ok(SyscallReturn::Return(0))

kernel/src/syscall/umask.rs

@@ -5,6 +5,6 @@ use crate::prelude::*;
 
 pub fn sys_umask(mask: u16, ctx: &Context) -> Result<SyscallReturn> {
     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 _))
 }

kernel/src/syscall/umount.rs

@@ -21,9 +21,13 @@ pub fn sys_umount(path_addr: Vaddr, flags: u64, ctx: &Context) -> Result<Syscall
     let fs_path = FsPath::new(AT_FDCWD, path.as_ref())?;
 
     let target_dentry = if umount_flags.contains(UmountFlags::UMOUNT_NOFOLLOW) {
-        ctx.process.fs().read().lookup_no_follow(&fs_path)?
+        ctx.posix_thread
+            .fs()
+            .resolver()
+            .read()
+            .lookup_no_follow(&fs_path)?
     } else {
-        ctx.process.fs().read().lookup(&fs_path)?
+        ctx.posix_thread.fs().resolver().read().lookup(&fs_path)?
     };
 
     target_dentry.unmount()?;

kernel/src/syscall/unlink.rs

@@ -34,7 +34,11 @@ pub fn sys_unlinkat(
             return_errno_with_message!(Errno::EISDIR, "unlink on directory");
         }
         let fs_path = FsPath::new(dirfd, path.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.unlink(&name)?;
     Ok(SyscallReturn::Return(0))

kernel/src/syscall/utimens.rs

@@ -168,7 +168,7 @@ fn do_utimes(
     let dentry = {
         // Determine the file system path and the corresponding entry
         let fs_path = FsPath::new(dirfd, pathname.as_ref())?;
-        let fs = ctx.process.fs().read();
+        let fs = ctx.posix_thread.fs().resolver().read();
         if flags.contains(UtimensFlags::AT_SYMLINK_NOFOLLOW) {
             fs.lookup_no_follow(&fs_path)?
         } else {

kernel/src/syscall/write.rs

@@ -15,7 +15,7 @@ pub fn sys_write(
     );
 
     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()
     };
 

kernel/src/util/net/mod.rs

@@ -11,10 +11,13 @@ pub use addr::{
 pub use options::{new_raw_socket_option, CSocketOptionLevel};
 pub use socket::{CUserMsgHdr, Protocol, SockFlags, SockType, SOCK_TYPE_MASK};
 
-use crate::{fs::file_table::FileDesc, net::socket::Socket, prelude::*};
+use crate::{
+    fs::file_table::FileDesc, net::socket::Socket, prelude::*, process::posix_thread::AsPosixThread,
+};
 
 pub fn get_socket_from_fd(sockfd: FileDesc) -> Result<Arc<dyn Socket>> {
-    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)
 }