implement unmount

arihant2math · arihant2math · commit d658428d200c · 2026-05-13T14:19:14.000-07:00
diff --git a/etc/syscalls_linux_aarch64.md b/etc/syscalls_linux_aarch64.md
@@ -40,7 +40,7 @@
 | 0x24 (36)   | symlinkat               | (const char *oldname, int newdfd, const char *newname)                                                                                     | __arm64_sys_symlinkat               | true        |
 | 0x25 (37)   | linkat                  | (int olddfd, const char *oldname, int newdfd, const char *newname, int flags)                                                              | __arm64_sys_linkat                  | true        |
 | 0x26 (38)   | renameat                | (int olddfd, const char *oldname, int newdfd, const char *newname)                                                                         | __arm64_sys_renameat                | true        |
-| 0x27 (39)   | umount                  | (char *name, int flags)                                                                                                                    | __arm64_sys_umount                  | false       |
+| 0x27 (39)   | umount                  | (char *name, int flags)                                                                                                                    | __arm64_sys_umount                  | true        |
 | 0x28 (40)   | mount                   | (char *dev_name, char *dir_name, char *type, unsigned long flags, void *data)                                                              | __arm64_sys_mount                   | partial     |
 | 0x29 (41)   | pivot_root              | (const char *new_root, const char *put_old)                                                                                                | __arm64_sys_pivot_root              | partial     |
 | 0x2b (43)   | statfs                  | (const char *pathname, struct statfs *buf)                                                                                                 | __arm64_sys_statfs                  | partial     |
diff --git a/src/arch/arm64/exceptions/syscall.rs b/src/arch/arm64/exceptions/syscall.rs
@@ -46,6 +46,7 @@ use crate::{
             statfs::{sys_fstatfs, sys_statfs},
             sync::{sys_fdatasync, sys_fsync, sys_sync, sys_syncfs},
             trunc::{sys_ftruncate, sys_truncate},
+            umount::sys_umount2,
         },
     },
     kernel::{
@@ -285,6 +286,7 @@ pub async fn handle_syscall(mut ctx: ProcessCtx) {
             )
             .await
         }
+        0x27 => sys_umount2(&ctx, TUA::from_value(arg1 as _), arg2 as _).await,
         0x28 => {
             sys_mount(
                 &ctx,
diff --git a/src/fs/mod.rs b/src/fs/mod.rs
@@ -1,7 +1,7 @@
 use crate::clock::realtime::date;
 use crate::{
     drivers::{DM, Driver, block::get_block_device_by_descriptor},
-    process::Task,
+    process::{TASK_LIST, Task},
     sync::SpinLock,
 };
 use alloc::{borrow::ToOwned, boxed::Box, collections::btree_map::BTreeMap, sync::Arc, vec::Vec};
@@ -45,6 +45,7 @@ impl Inode for DummyInode {
 }
 
 /// Represents a mounted filesystem.
+#[derive(Clone)]
 struct Mount {
     fs: Arc<dyn Filesystem>,
     root_inode: Arc<dyn Inode>,
@@ -88,10 +89,40 @@ impl VfsState {
     }
 
     /// Removes a mount point by its inode ID.
-    fn remove_mount(&mut self, mount_point_id: &InodeId) -> Option<()> {
+    fn remove_mount(&mut self, mount_point_id: &InodeId) -> Option<Mount> {
         let mount = self.mounts.remove(mount_point_id)?;
         self.filesystems.remove(&mount.fs.id())?;
-        Some(())
+        Some(mount)
+    }
+
+    /// Collects the mount identified by `mount_point_id` and every nested mount
+    /// reachable beneath it.
+    fn collect_mount_subtree(&self, mount_point_id: InodeId) -> Option<Vec<(InodeId, Mount)>> {
+        let mut pending = Vec::new();
+        let mut subtree = Vec::new();
+
+        pending.push(mount_point_id);
+
+        while let Some(current_mount_point_id) = pending.pop() {
+            let mount = self.mounts.get(&current_mount_point_id)?.clone();
+            let current_fs_id = mount.fs.id();
+
+            subtree.push((current_mount_point_id, mount));
+
+            for child_mount_point_id in self.mounts.keys().copied() {
+                if child_mount_point_id != current_mount_point_id
+                    && child_mount_point_id.fs_id() == current_fs_id
+                    && !subtree
+                        .iter()
+                        .any(|(seen, _)| *seen == child_mount_point_id)
+                    && !pending.contains(&child_mount_point_id)
+                {
+                    pending.push(child_mount_point_id);
+                }
+            }
+        }
+
+        Some(subtree)
     }
 
     /// Checks if an inode is a mount point and returns the root inode of the
@@ -192,15 +223,68 @@ impl VFS {
         Ok(())
     }
 
-    #[expect(unused)]
-    pub async fn umount(&self, mount_point: Arc<dyn Inode>) -> Result<()> {
-        let mount_point_id = mount_point.id();
+    pub async fn umount(&self, mount_point: Arc<dyn Inode>, detach: bool) -> Result<()> {
+        let mount_point_id = self
+            .mount_point_for_root(mount_point.id())
+            .unwrap_or(mount_point.id());
 
-        // Lock the state and remove the mount.
-        self.state
-            .lock_save_irq()
-            .remove_mount(&mount_point_id)
-            .ok_or(FsError::NotFound)?;
+        if mount_point_id
+            == self
+                .root_inode
+                .lock_save_irq()
+                .as_ref()
+                .ok_or(FsError::NotFound)?
+                .id()
+        {
+            return Err(KernelError::InUse);
+        }
+
+        let subtree = {
+            let state = self.state.lock_save_irq();
+            state
+                .collect_mount_subtree(mount_point_id)
+                .ok_or(KernelError::InvalidValue)?
+        };
+
+        if !detach && subtree.len() > 1 {
+            return Err(KernelError::InUse);
+        }
+
+        let target_fs_id = subtree
+            .first()
+            .map(|(_, mount)| mount.fs.id())
+            .ok_or(KernelError::InvalidValue)?;
+
+        if !detach {
+            let tasks: Vec<_> = TASK_LIST
+                .lock_save_irq()
+                .values()
+                .filter_map(|work| work.upgrade())
+                .collect();
+
+            for work in tasks {
+                let task = work.task.t_shared.clone();
+
+                if task.root.lock_save_irq().0.id().fs_id() == target_fs_id
+                    || task.cwd.lock_save_irq().0.id().fs_id() == target_fs_id
+                    || task.fd_table.lock_save_irq().any_inode_on_fs(target_fs_id)
+                {
+                    return Err(KernelError::InUse);
+                }
+            }
+        }
+
+        let filesystems: Vec<_> = subtree.iter().map(|(_, mount)| mount.fs.clone()).collect();
+        for fs in filesystems {
+            fs.sync().await?;
+        }
+
+        let mut state = self.state.lock_save_irq();
+        for (mount_point_id, _) in subtree {
+            state
+                .remove_mount(&mount_point_id)
+                .ok_or(KernelError::InvalidValue)?;
+        }
 
         Ok(())
     }
diff --git a/src/fs/syscalls/mod.rs b/src/fs/syscalls/mod.rs
@@ -20,3 +20,4 @@ pub mod stat;
 pub mod statfs;
 pub mod sync;
 pub mod trunc;
+pub mod umount;
diff --git a/src/fs/syscalls/umount.rs b/src/fs/syscalls/umount.rs
@@ -0,0 +1,62 @@
+use crate::{fs::VFS, memory::uaccess::cstr::UserCStr, sched::syscall_ctx::ProcessCtx};
+use bitflags::bitflags;
+use core::ffi::c_char;
+use libkernel::{
+    error::{FsError, KernelError, Result},
+    fs::path::Path,
+    memory::address::TUA,
+    proc::caps::CapabilitiesFlags,
+};
+
+bitflags! {
+    #[derive(Debug, Clone, Copy, PartialEq, Eq)]
+    struct UmountFlags: u32 {
+        const MNT_FORCE = 0x1;
+        const MNT_DETACH = 0x2;
+        const MNT_EXPIRE = 0x4;
+        const UMOUNT_NOFOLLOW = 0x8;
+    }
+}
+
+pub async fn sys_umount2(ctx: &ProcessCtx, target: TUA<c_char>, flags: i64) -> Result<usize> {
+    let flags = u32::try_from(flags)
+        .ok()
+        .and_then(UmountFlags::from_bits)
+        .ok_or(KernelError::InvalidValue)?;
+
+    if flags.contains(UmountFlags::MNT_EXPIRE)
+        && flags.intersects(UmountFlags::MNT_FORCE | UmountFlags::MNT_DETACH)
+    {
+        return Err(KernelError::InvalidValue);
+    }
+
+    if flags.contains(UmountFlags::MNT_EXPIRE) {
+        // TODO: Implement two-phase expiry semantics.
+        return Err(KernelError::TryAgain);
+    }
+
+    let task = ctx.shared().clone();
+    task.creds
+        .lock_save_irq()
+        .caps()
+        .check_capable(CapabilitiesFlags::CAP_SYS_ADMIN)?;
+
+    let mut buf = [0u8; 1024];
+    let target = UserCStr::from_ptr(target).copy_from_user(&mut buf).await?;
+    if target.is_empty() {
+        return Err(FsError::NotFound.into());
+    }
+
+    let cwd = task.cwd.lock_save_irq().0.clone();
+    let target_path = Path::new(target);
+    let target = if flags.contains(UmountFlags::UMOUNT_NOFOLLOW) {
+        VFS.resolve_path_nofollow(target_path, cwd, &task).await?
+    } else {
+        VFS.resolve_path(target_path, cwd, &task).await?
+    };
+
+    VFS.umount(target, flags.contains(UmountFlags::MNT_DETACH))
+        .await?;
+
+    Ok(0)
+}
diff --git a/src/process/fd_table.rs b/src/process/fd_table.rs
@@ -201,6 +201,17 @@ impl FileDescriptorTable {
         }
     }
 
+    /// Returns `true` if any open file descriptor refers to an inode on the
+    /// given filesystem.
+    pub fn any_inode_on_fs(&self, fs_id: u64) -> bool {
+        self.entries.iter().flatten().any(|entry| {
+            entry
+                .file
+                .inode()
+                .is_some_and(|inode| inode.id().fs_id() == fs_id)
+        })
+    }
+
     /// Number of file descriptors in use.
     pub fn len(&self) -> usize {
         self.entries.iter().filter(|e| e.is_some()).count()
diff --git a/usertest/src/fs.rs b/usertest/src/fs.rs
@@ -109,6 +109,48 @@ fn test_chroot() {
 
 register_test!(test_chroot);
 
+fn test_mount_umount() {
+    use std::path::Path;
+
+    let pid = unsafe { libc::getpid() };
+    let mount_point = format!("/tmp/mount_umount_test_{pid}");
+    let test_file = format!("{mount_point}/hello.txt");
+    let c_mount_point = CString::new(mount_point.clone()).unwrap();
+    let c_source = CString::new("tmpfs").unwrap();
+    let c_type = CString::new("tmpfs").unwrap();
+
+    fs::create_dir(&mount_point).expect("Failed to create mount point");
+
+    unsafe {
+        if libc::mount(
+            c_source.as_ptr(),
+            c_mount_point.as_ptr(),
+            c_type.as_ptr(),
+            0,
+            std::ptr::null(),
+        ) != 0
+        {
+            panic!("mount failed: {}", std::io::Error::last_os_error());
+        }
+    }
+
+    fs::write(&test_file, b"hello").expect("Failed to write file on mounted fs");
+    assert!(Path::new(&test_file).exists());
+
+    unsafe {
+        if libc::umount(c_mount_point.as_ptr()) != 0 {
+            panic!("umount failed: {}", std::io::Error::last_os_error());
+        }
+    }
+
+    assert!(!Path::new(&test_file).exists());
+    assert_eq!(fs::read_dir(&mount_point).unwrap().count(), 0);
+
+    fs::remove_dir(&mount_point).expect("Failed to remove mount point");
+}
+
+register_test!(test_mount_umount);
+
 fn test_chmod() {
     let dir_path = "/tmp/chmod_test";
     let c_dir_path = CString::new(dir_path).unwrap();
