feat(filesystem): 添加MountFlags支持并实现`/proc/mounts`文件 (#1253)

* feat(filesystem): 添加MountFlags支持并完善procfs功能

- 为所有文件系统挂载操作添加MountFlags参数
- 在procfs中新增/proc/mounts文件支持
- 重构procfs文件创建逻辑使用Builder模式
- 优化KernFS初始化流程
- 添加MountFlags到字符串的转换功能

Signed-off-by: longjin <longjin@DragonOS.org>

* refactor(procfs): 将pid字段改为Option类型并优化相关逻辑

- 修改ProcFileCreationParams和InodeInfo中的pid字段为Option<RawPid>
- 为ProcFileCreationParamsBuilder添加默认mode值
- 优化read_exe_link和open_status方法处理None pid的情况
- 移除不必要的pid参数设置
- 为procfs_register_pid和procfs_unregister_pid添加#[inline(never)]

Signed-off-by: longjin <longjin@DragonOS.org>

---------

Signed-off-by: longjin <longjin@DragonOS.org>

kernel/src/filesystem/devfs/mod.rs

@@ -2,13 +2,16 @@
 pub mod null_dev;
 pub mod zero_dev;
 
-use super::vfs::{
-    file::FileMode, syscall::ModeType, utils::DName, vcore::generate_inode_id, FilePrivateData,
-    FileSystem, FileType, FsInfo, IndexNode, Magic, Metadata, SuperBlock,
+use super::{
+    devpts::{DevPtsFs, LockedDevPtsFSInode},
+    vfs::{
+        file::FileMode, syscall::ModeType, utils::DName, vcore::generate_inode_id, FilePrivateData,
+        FileSystem, FileType, FsInfo, IndexNode, Magic, Metadata, SuperBlock,
+    },
 };
 use crate::{
     driver::base::{block::gendisk::GenDisk, device::device_number::DeviceNumber},
-    filesystem::devpts::{DevPtsFs, LockedDevPtsFSInode},
+    filesystem::vfs::mount::MountFlags,
     libs::{
         casting::DowncastArc,
         once::Once,
@@ -736,7 +739,7 @@ pub fn devfs_init() -> Result<(), SystemError> {
         root_inode
             .mkdir("dev", ModeType::from_bits_truncate(0o755))
             .expect("Unabled to find /dev")
-            .mount(devfs)
+            .mount(devfs, MountFlags::empty())
             .expect("Failed to mount at /dev");
         info!("DevFS mounted.");
         result = Some(Ok(()));

kernel/src/filesystem/devpts/mod.rs

@@ -11,9 +11,10 @@ use crate::{
             tty_device::{PtyType, TtyDevice, TtyType},
         },
     },
-    filesystem::{
-        devfs::DeviceINode,
-        vfs::{mount::do_mount_mkdir, syscall::ModeType, FileType},
+    filesystem::vfs::{
+        mount::{do_mount_mkdir, MountFlags},
+        syscall::ModeType,
+        FileType,
     },
     libs::spinlock::{SpinLock, SpinLockGuard},
     time::PosixTimeSpec,
@@ -28,8 +29,9 @@ use ida::IdAllocator;
 use log::info;
 use system_error::SystemError;
 
-use super::vfs::{
-    vcore::generate_inode_id, FilePrivateData, FileSystem, FsInfo, IndexNode, Metadata,
+use super::{
+    devfs::DeviceINode,
+    vfs::{vcore::generate_inode_id, FilePrivateData, FileSystem, FsInfo, IndexNode, Metadata},
 };
 
 const DEV_PTYFS_MAX_NAMELEN: usize = 16;
@@ -286,7 +288,7 @@ pub fn devpts_init() -> Result<(), SystemError> {
     // 创建 devptsfs 实例
     let ptsfs: Arc<DevPtsFs> = DevPtsFs::new();
 
-    do_mount_mkdir(ptsfs, "/dev/pts").expect("Failed to mount DevPtsFS");
+    do_mount_mkdir(ptsfs, "/dev/pts", MountFlags::empty()).expect("Failed to mount DevPtsFS");
     info!("DevPtsFs mounted.");
 
     Ok(())

kernel/src/filesystem/kernfs/mod.rs

@@ -32,6 +32,7 @@ pub mod callback;
 #[derive(Debug)]
 pub struct KernFS {
     root_inode: Arc<KernFSInode>,
+    fsname: &'static str,
 }
 
 impl FileSystem for KernFS {
@@ -51,7 +52,7 @@ impl FileSystem for KernFS {
     }
 
     fn name(&self) -> &str {
-        "kernfs"
+        self.fsname
     }
 
     fn super_block(&self) -> SuperBlock {
@@ -66,19 +67,15 @@ impl FileSystem for KernFS {
 impl KernFS {
     pub const MAX_NAMELEN: usize = 4096;
     pub const KERNFS_BLOCK_SIZE: u64 = 512;
-    #[allow(dead_code)]
-    pub fn new() -> Arc<Self> {
+
+    #[inline(never)]
+    pub fn new(fsname: &'static str) -> Arc<Self> {
         let root_inode = Self::create_root_inode();
         let fs = Arc::new(Self {
             root_inode: root_inode.clone(),
+            fsname,
         });
 
-        {
-            let ptr = root_inode.as_ref() as *const KernFSInode as *mut KernFSInode;
-            unsafe {
-                (*ptr).self_ref = Arc::downgrade(&root_inode);
-            }
-        }
         root_inode.inner.write().parent = Arc::downgrade(&root_inode);
         *root_inode.fs.write() = Arc::downgrade(&fs);
         return fs;
@@ -102,7 +99,7 @@ impl KernFS {
             nlinks: 1,
             raw_dev: DeviceNumber::default(),
         };
-        let root_inode = Arc::new(KernFSInode {
+        let root_inode = Arc::new_cyclic(|self_ref| KernFSInode {
             name: String::from(""),
             inner: RwLock::new(InnerKernFSInode {
                 parent: Weak::new(),
@@ -110,7 +107,7 @@ impl KernFS {
                 symlink_target: None,
                 symlink_target_absolute_path: None,
             }),
-            self_ref: Weak::new(),
+            self_ref: self_ref.clone(),
             fs: RwLock::new(Weak::new()),
             private_data: SpinLock::new(None),
             callback: None,

kernel/src/filesystem/procfs/mod.rs

@@ -14,7 +14,7 @@ use system_error::SystemError;
 use crate::{
     arch::mm::LockedFrameAllocator,
     driver::base::device::device_number::DeviceNumber,
-    filesystem::vfs::{vcore::generate_inode_id, FileType},
+    filesystem::vfs::{mount::MountFlags, vcore::generate_inode_id, FileType},
     libs::{
         once::Once,
         rwlock::RwLock,
@@ -34,6 +34,7 @@ use super::vfs::{
 
 pub mod kmsg;
 pub mod log;
+mod proc_mounts;
 mod syscall;
 
 /// @brief 进程文件类型
@@ -49,9 +50,11 @@ pub enum ProcFileType {
     ProcKmsg = 2,
     /// 可执行路径
     ProcExe = 3,
+    /// /proc/mounts
     ProcSelf = 4,
     ProcFdDir = 5,
     ProcFdFile = 6,
+    ProcMounts = 7,
     //todo: 其他文件类型
     ///默认文件类型
     Default,
@@ -67,16 +70,97 @@ impl From<u8> for ProcFileType {
             4 => ProcFileType::ProcSelf,
             5 => ProcFileType::ProcFdDir,
             6 => ProcFileType::ProcFdFile,
+            7 => ProcFileType::ProcMounts,
             _ => ProcFileType::Default,
         }
     }
 }
+/// @brief 创建 ProcFS 文件的参数结构体
+#[derive(Debug, Clone)]
+pub struct ProcFileCreationParams<'a> {
+    pub parent: Arc<dyn IndexNode>,
+    pub name: &'a str,
+    pub file_type: FileType,
+    pub mode: ModeType,
+    pub pid: Option<RawPid>,
+    pub ftype: ProcFileType,
+    pub data: Option<&'a str>,
+}
+
+impl<'a> ProcFileCreationParams<'a> {
+    pub fn builder() -> ProcFileCreationParamsBuilder<'a> {
+        ProcFileCreationParamsBuilder::default()
+    }
+}
+
+/// @brief ProcFileCreationParams 的 Builder 模式实现
+#[derive(Debug, Clone, Default)]
+pub struct ProcFileCreationParamsBuilder<'a> {
+    parent: Option<Arc<dyn IndexNode>>,
+    name: Option<&'a str>,
+    file_type: Option<FileType>,
+    mode: Option<ModeType>,
+    pid: Option<RawPid>,
+    ftype: Option<ProcFileType>,
+    data: Option<&'a str>,
+}
+
+#[allow(dead_code)]
+impl<'a> ProcFileCreationParamsBuilder<'a> {
+    pub fn parent(mut self, parent: Arc<dyn IndexNode>) -> Self {
+        self.parent = Some(parent);
+        self
+    }
+
+    pub fn name(mut self, name: &'a str) -> Self {
+        self.name = Some(name);
+        self
+    }
+
+    pub fn file_type(mut self, file_type: FileType) -> Self {
+        self.file_type = Some(file_type);
+        self
+    }
+
+    pub fn mode(mut self, mode: ModeType) -> Self {
+        self.mode = Some(mode);
+        self
+    }
+
+    pub fn pid(mut self, pid: RawPid) -> Self {
+        self.pid = Some(pid);
+        self
+    }
+
+    pub fn ftype(mut self, ftype: ProcFileType) -> Self {
+        self.ftype = Some(ftype);
+        self
+    }
+
+    pub fn data(mut self, data: &'a str) -> Self {
+        self.data = Some(data);
+        self
+    }
+
+    pub fn build(self) -> Result<ProcFileCreationParams<'a>, SystemError> {
+        Ok(ProcFileCreationParams {
+            parent: self.parent.ok_or(SystemError::EINVAL)?,
+            name: self.name.ok_or(SystemError::EINVAL)?,
+            file_type: self.file_type.ok_or(SystemError::EINVAL)?,
+            mode: self.mode.unwrap_or(ModeType::S_IRUGO),
+            pid: self.pid,
+            ftype: self.ftype.ok_or(SystemError::EINVAL)?,
+            data: self.data,
+        })
+    }
+}
+
 /// @brief 节点私有信息结构体
 /// @usage 用于传入各类文件所需的信息
 #[derive(Debug)]
 pub struct InodeInfo {
     ///进程的pid
-    pid: RawPid,
+    pid: Option<RawPid>,
     ///文件类型
     ftype: ProcFileType,
     /// 文件描述符
@@ -152,7 +236,10 @@ impl ProcFSInode {
     ///
     fn open_status(&self, pdata: &mut ProcfsFilePrivateData) -> Result<i64, SystemError> {
         // 获取该pid对应的pcb结构体
-        let pid = self.fdata.pid;
+        let pid = self
+            .fdata
+            .pid
+            .expect("ProcFS: pid is None when opening 'status' file.");
         let pcb = ProcessManager::find_task_by_vpid(pid);
         let pcb = if let Some(pcb) = pcb {
             pcb
@@ -324,12 +411,13 @@ impl ProcFSInode {
     // 读取exe文件
     fn read_exe_link(&self, buf: &mut [u8]) -> Result<usize, SystemError> {
         // 判断是否有记录pid信息，有的话就是当前进程的exe文件，没有则是当前进程的exe文件
-        let pid = self.fdata.pid;
-        let pcb = if pid == RawPid::from(0) {
-            ProcessManager::current_pcb()
-        } else {
+        let pcb = if let Some(pid) = self.fdata.pid {
             ProcessManager::find_task_by_vpid(pid).ok_or(SystemError::ESRCH)?
+        } else {
+            // 如果没有pid信息，则读取当前进程的exe文件
+            ProcessManager::current_pcb()
         };
+
         let exe = pcb.execute_path();
         let exe_bytes = exe.as_bytes();
         let len = exe_bytes.len().min(buf.len());
@@ -410,6 +498,26 @@ impl FileSystem for ProcFS {
 }
 
 impl ProcFS {
+    #[inline(never)]
+    fn create_proc_file(&self, params: ProcFileCreationParams) -> Result<(), SystemError> {
+        let binding = params
+            .parent
+            .create(params.name, params.file_type, params.mode)?;
+        let proc_file = binding
+            .as_any_ref()
+            .downcast_ref::<LockedProcFSInode>()
+            .unwrap();
+        let mut proc_file_guard = proc_file.0.lock();
+        proc_file_guard.fdata.pid = params.pid;
+        proc_file_guard.fdata.ftype = params.ftype;
+        if let Some(data_content) = params.data {
+            proc_file_guard.data = data_content.to_string().as_bytes().to_vec();
+        }
+        drop(proc_file_guard);
+        Ok(())
+    }
+
+    #[inline(never)]
     pub fn new() -> Arc<Self> {
         let super_block = SuperBlock::new(
             Magic::PROC_MAGIC,
@@ -442,7 +550,7 @@ impl ProcFS {
                 },
                 fs: Weak::default(),
                 fdata: InodeInfo {
-                    pid: RawPid::new(0),
+                    pid: None,
                     ftype: ProcFileType::Default,
                     fd: -1,
                 },
@@ -463,32 +571,30 @@ impl ProcFS {
         drop(root_guard);
 
         // 创建meminfo文件
-        let inode = result.root_inode();
-        let meminfo = inode
-            .create(
-                "meminfo",
-                FileType::File,
-                ModeType::from_bits_truncate(0o444),
-            )
-            .expect("create meminfo error");
-        let meminfo_file = meminfo
-            .as_any_ref()
-            .downcast_ref::<LockedProcFSInode>()
+        let meminfo_params = ProcFileCreationParams::builder()
+            .parent(result.root_inode())
+            .name("meminfo")
+            .file_type(FileType::File)
+            .mode(ModeType::from_bits_truncate(0o444))
+            .ftype(ProcFileType::ProcMeminfo)
+            .build()
             .unwrap();
-        meminfo_file.0.lock().fdata.pid = RawPid::new(0);
-        meminfo_file.0.lock().fdata.ftype = ProcFileType::ProcMeminfo;
+        result
+            .create_proc_file(meminfo_params)
+            .unwrap_or_else(|_| panic!("create meminfo error"));
 
         // 创建kmsg文件
-        let kmsg = inode
-            .create("kmsg", FileType::File, ModeType::from_bits_truncate(0o444))
-            .expect("create kmsg error");
-        let kmsg_file = kmsg
-            .as_any_ref()
-            .downcast_ref::<LockedProcFSInode>()
+        let kmsg_params = ProcFileCreationParams::builder()
+            .parent(result.root_inode())
+            .name("kmsg")
+            .file_type(FileType::File)
+            .mode(ModeType::from_bits_truncate(0o444))
+            .ftype(ProcFileType::ProcKmsg)
+            .build()
             .unwrap();
-        kmsg_file.0.lock().fdata.pid = RawPid::new(1);
-        kmsg_file.0.lock().fdata.ftype = ProcFileType::ProcKmsg;
-
+        result
+            .create_proc_file(kmsg_params)
+            .unwrap_or_else(|_| panic!("create kmsg error"));
         // 这个文件是用来欺骗Aya框架识别内核版本
         /* On Ubuntu LINUX_VERSION_CODE doesn't correspond to info.release,
          * but Ubuntu provides /proc/version_signature file, as described at
@@ -500,30 +606,44 @@ impl ProcFS {
          * In the above, 5.4.8 is what kernel is actually expecting, while
          * uname() call will return 5.4.0 in info.release.
          */
-        let version_signature = inode
-            .create("version_signature", FileType::File, ModeType::S_IRUGO)
-            .expect("create version_signature error");
-        let version_signature = version_signature
-            .as_any_ref()
-            .downcast_ref::<LockedProcFSInode>()
+        let version_signature_params = ProcFileCreationParams::builder()
+            .parent(result.root_inode())
+            .name("version_signature")
+            .file_type(FileType::File)
+            .ftype(ProcFileType::Default)
+            .data("DragonOS 6.0.0-generic 6.0.0\n")
+            .build()
+            .unwrap();
+        result
+            .create_proc_file(version_signature_params)
+            .unwrap_or_else(|_| panic!("create version_signature error"));
+
+        let mounts_params = ProcFileCreationParams::builder()
+            .parent(result.root_inode())
+            .name("mounts")
+            .file_type(FileType::File)
+            .ftype(ProcFileType::ProcMounts)
+            .build()
             .unwrap();
-        version_signature.0.lock().fdata.ftype = ProcFileType::Default;
-        version_signature.0.lock().data = b"DragonOS 6.0.0-generic 6.0.0\n".to_vec();
+        result
+            .create_proc_file(mounts_params)
+            .unwrap_or_else(|_| panic!("create mounts error"));
 
-        let self_file = inode
-            .create_with_data(
-                "self",
-                FileType::SymLink,
-                ModeType::from_bits_truncate(0o555),
-                0,
-            )
-            .expect("create self error");
-        let self_file = self_file
-            .as_any_ref()
-            .downcast_ref::<LockedProcFSInode>()
+        let self_dir = result
+            .root_inode()
+            .create("self", FileType::Dir, ModeType::from_bits_truncate(0o555))
             .unwrap();
-        self_file.0.lock().fdata.pid = RawPid::new(2);
-        self_file.0.lock().fdata.ftype = ProcFileType::ProcSelf;
+
+        let exe_params = ProcFileCreationParams::builder()
+            .parent(self_dir)
+            .name("exe")
+            .file_type(FileType::SymLink)
+            .ftype(ProcFileType::ProcExe)
+            .build()
+            .unwrap();
+        result
+            .create_proc_file(exe_params)
+            .unwrap_or_else(|_| panic!("create exe error"));
 
         return result;
     }
@@ -550,7 +670,7 @@ impl ProcFS {
             .as_any_ref()
             .downcast_ref::<LockedProcFSInode>()
             .unwrap();
-        status_file.0.lock().fdata.pid = pid;
+        status_file.0.lock().fdata.pid = Some(pid);
         status_file.0.lock().fdata.ftype = ProcFileType::ProcStatus;
 
         // exe文件
@@ -564,7 +684,7 @@ impl ProcFS {
             .as_any_ref()
             .downcast_ref::<LockedProcFSInode>()
             .unwrap();
-        exe_file.0.lock().fdata.pid = pid;
+        exe_file.0.lock().fdata.pid = Some(pid);
         exe_file.0.lock().fdata.ftype = ProcFileType::ProcExe;
 
         // fd dir
@@ -655,6 +775,7 @@ impl IndexNode for LockedProcFSInode {
             ProcFileType::ProcStatus => inode.open_status(&mut private_data)?,
             ProcFileType::ProcMeminfo => inode.open_meminfo(&mut private_data)?,
             ProcFileType::ProcExe => inode.open_exe(&mut private_data)?,
+            ProcFileType::ProcMounts => inode.open_mounts(&mut private_data)?,
             ProcFileType::Default => inode.data.len() as i64,
             ProcFileType::ProcSelf => inode.open_self(&mut private_data)?,
             _ => 0,
@@ -713,7 +834,7 @@ impl IndexNode for LockedProcFSInode {
 
         // 根据文件类型读取相应数据
         match inode.fdata.ftype {
-            ProcFileType::ProcStatus | ProcFileType::ProcMeminfo => {
+            ProcFileType::ProcStatus | ProcFileType::ProcMeminfo | ProcFileType::ProcMounts => {
                 // 获取数据信息
                 let mut private_data = match &*data {
                     FilePrivateData::Procfs(p) => p.clone(),
@@ -726,6 +847,7 @@ impl IndexNode for LockedProcFSInode {
             ProcFileType::ProcExe => return inode.read_exe_link(buf),
             ProcFileType::ProcSelf => return inode.read_self_link(buf),
             ProcFileType::ProcFdFile => return inode.read_fd_link(buf),
+
             _ => (),
         };
 
@@ -836,7 +958,7 @@ impl IndexNode for LockedProcFSInode {
                 },
                 fs: inode.fs.clone(),
                 fdata: InodeInfo {
-                    pid: RawPid::new(0),
+                    pid: None,
                     ftype: ProcFileType::Default,
                     fd: -1,
                 },
@@ -1021,6 +1143,7 @@ impl IndexNode for LockedProcFSInode {
 }
 
 /// @brief 向procfs注册进程
+#[inline(never)]
 pub fn procfs_register_pid(pid: RawPid) -> Result<(), SystemError> {
     let root_inode = ProcessManager::current_mntns().root_inode();
     let procfs_inode = root_inode.find("proc")?;
@@ -1038,6 +1161,7 @@ pub fn procfs_register_pid(pid: RawPid) -> Result<(), SystemError> {
 }
 
 /// @brief 在ProcFS中,解除进程的注册
+#[inline(never)]
 pub fn procfs_unregister_pid(pid: RawPid) -> Result<(), SystemError> {
     let root_inode = ProcessManager::current_mntns().root_inode();
     // 获取procfs实例
@@ -1065,7 +1189,7 @@ pub fn procfs_init() -> Result<(), SystemError> {
         root_inode
             .mkdir("proc", ModeType::from_bits_truncate(0o755))
             .expect("Unabled to find /proc")
-            .mount(procfs)
+            .mount(procfs, MountFlags::empty())
             .expect("Failed to mount at /proc");
         info!("ProcFS mounted.");
         result = Some(Ok(()));

kernel/src/filesystem/procfs/proc_mounts.rs

@@ -0,0 +1,73 @@
+use alloc::vec::Vec;
+
+use alloc::string::{String, ToString};
+
+use system_error::SystemError;
+
+use crate::{filesystem::vfs::IndexNode, process::ProcessManager};
+
+use super::{ProcFSInode, ProcfsFilePrivateData};
+
+impl ProcFSInode {
+    /// 打开 meminfo 文件
+    #[inline(never)]
+    pub(super) fn open_mounts(
+        &self,
+        pdata: &mut ProcfsFilePrivateData,
+    ) -> Result<i64, SystemError> {
+        // 生成mount信息
+        let mount_content = Self::generate_mounts_content();
+
+        pdata.data = mount_content.into_bytes();
+        return Ok(pdata.data.len() as i64);
+    }
+
+    #[inline(never)]
+    fn generate_mounts_content() -> String {
+        let mntns = ProcessManager::current_mntns();
+        let mounts = mntns.mount_list().clone_inner();
+
+        let mut lines = Vec::with_capacity(mounts.len());
+        let mut cap = 0;
+        for (mp, mfs) in mounts {
+            let mut line = String::new();
+            let fs_type = mfs.fs_type();
+            let source = match fs_type {
+                // 特殊文件系统，直接显示文件系统名称
+                "devfs" | "devpts" | "sysfs" | "procfs" | "tmpfs" | "ramfs" | "rootfs"
+                | "debugfs" | "configfs" => fs_type.to_string(),
+                // 其他文件系统，尝试显示挂载设备名称
+                _ => {
+                    if let Some(s) = mfs.self_mountpoint() {
+                        // 尝试从挂载点获取设备名称
+                        if let Some(device_name) = s.dname().ok().map(|d| d.to_string()) {
+                            device_name
+                        } else {
+                            // 如果获取不到设备名称，使用绝对路径
+                            s.absolute_path().unwrap_or("unknown".to_string())
+                        }
+                    } else {
+                        // 没有挂载点信息，使用文件系统类型
+                        fs_type.to_string()
+                    }
+                }
+            };
+
+            line.push_str(&format!("{source} {m} {fs_type}", m = mp.as_str()));
+
+            line.push(' ');
+            line.push_str(&mfs.mount_flags().options_string());
+
+            line.push_str(" 0 0\n");
+            cap += line.len();
+            lines.push(line);
+        }
+
+        let mut content = String::with_capacity(cap);
+        for line in lines {
+            content.push_str(&line);
+        }
+
+        return content;
+    }
+}

kernel/src/filesystem/sysfs/mod.rs

@@ -8,6 +8,7 @@ use super::{
 };
 use crate::{
     driver::base::kobject::KObject,
+    filesystem::vfs::mount::MountFlags,
     libs::{casting::DowncastArc, once::Once},
     process::ProcessManager,
 };
@@ -45,7 +46,7 @@ pub fn sysfs_init() -> Result<(), SystemError> {
         root_inode
             .mkdir("sys", ModeType::from_bits_truncate(0o755))
             .expect("Unabled to find /sys")
-            .mount(sysfs_instance().fs().clone())
+            .mount(sysfs_instance().fs().clone(), MountFlags::empty())
             .expect("Failed to mount at /sys");
         info!("SysFS mounted.");
 
@@ -207,7 +208,7 @@ pub struct SysFS {
 
 impl SysFS {
     pub fn new() -> Self {
-        let kernfs: Arc<KernFS> = KernFS::new();
+        let kernfs: Arc<KernFS> = KernFS::new("sysfs");
 
         let root_inode: Arc<KernFSInode> = kernfs.root_inode().downcast_arc().unwrap();
 

kernel/src/filesystem/vfs/mod.rs

@@ -12,6 +12,7 @@ use ::core::{any::Any, fmt::Debug, sync::atomic::AtomicUsize};
 use alloc::{string::String, sync::Arc, vec::Vec};
 use derive_builder::Builder;
 use intertrait::CastFromSync;
+use mount::MountFlags;
 use system_error::SystemError;
 
 use crate::{
@@ -476,7 +477,11 @@ pub trait IndexNode: Any + Sync + Send + Debug + CastFromSync {
     ///
     /// - 该函数会在`MountFS`实例上创建一个新的挂载点。
     /// - 该函数会在全局的挂载列表中记录新的挂载关系。
-    fn mount(&self, _fs: Arc<dyn FileSystem>) -> Result<Arc<MountFS>, SystemError> {
+    fn mount(
+        &self,
+        _fs: Arc<dyn FileSystem>,
+        _mount_flags: MountFlags,
+    ) -> Result<Arc<MountFS>, SystemError> {
         return Err(SystemError::ENOSYS);
     }
 

kernel/src/filesystem/vfs/mount.rs

@@ -38,6 +38,164 @@ use super::{
     IndexNode, InodeId, Magic, PollableInode, SuperBlock,
 };
 
+bitflags! {
+    /// Mount flags for filesystem independent mount options
+    /// These flags correspond to the MS_* constants in Linux
+    ///
+    /// Reference: https://code.dragonos.org.cn/xref/linux-6.6.21/include/uapi/linux/mount.h#13
+    pub struct MountFlags: u32 {
+        /// Mount read-only (MS_RDONLY)
+        const RDONLY = 1;
+        /// Ignore suid and sgid bits (MS_NOSUID)
+        const NOSUID = 2;
+        /// Disallow access to device special files (MS_NODEV)
+        const NODEV = 4;
+        /// Disallow program execution (MS_NOEXEC)
+        const NOEXEC = 8;
+        /// Writes are synced at once (MS_SYNCHRONOUS)
+        const SYNCHRONOUS = 16;
+        /// Alter flags of a mounted FS (MS_REMOUNT)
+        const REMOUNT = 32;
+        /// Allow mandatory locks on an FS (MS_MANDLOCK)
+        const MANDLOCK = 64;
+        /// Directory modifications are synchronous (MS_DIRSYNC)
+        const DIRSYNC = 128;
+        /// Do not follow symlinks (MS_NOSYMFOLLOW)
+        const NOSYMFOLLOW = 256;
+        /// Do not update access times (MS_NOATIME)
+        const NOATIME = 1024;
+        /// Do not update directory access times (MS_NODIRATIME)
+        const NODIRATIME = 2048;
+        /// Bind mount (MS_BIND)
+        const BIND = 4096;
+        /// Move mount (MS_MOVE)
+        const MOVE = 8192;
+        /// Recursive mount (MS_REC)
+        const REC = 16384;
+        /// Silent mount (MS_SILENT, deprecated MS_VERBOSE)
+        const SILENT = 32768;
+        /// VFS does not apply the umask (MS_POSIXACL)
+        const POSIXACL = 1 << 16;
+        /// Change to unbindable (MS_UNBINDABLE)
+        const UNBINDABLE = 1 << 17;
+        /// Change to private (MS_PRIVATE)
+        const PRIVATE = 1 << 18;
+        /// Change to slave (MS_SLAVE)
+        const SLAVE = 1 << 19;
+        /// Change to shared (MS_SHARED)
+        const SHARED = 1 << 20;
+        /// Update atime relative to mtime/ctime (MS_RELATIME)
+        const RELATIME = 1 << 21;
+        /// This is a kern_mount call (MS_KERNMOUNT)
+        const KERNMOUNT = 1 << 22;
+        /// Update inode I_version field (MS_I_VERSION)
+        const I_VERSION = 1 << 23;
+        /// Always perform atime updates (MS_STRICTATIME)
+        const STRICTATIME = 1 << 24;
+        /// Update the on-disk [acm]times lazily (MS_LAZYTIME)
+        const LAZYTIME = 1 << 25;
+        /// This is a submount (MS_SUBMOUNT)
+        const SUBMOUNT = 1 << 26;
+        /// Do not allow remote locking (MS_NOREMOTELOCK)
+        const NOREMOTELOCK = 1 << 27;
+        /// Do not perform security checks (MS_NOSEC)
+        const NOSEC = 1 << 28;
+        /// This mount has been created by the kernel (MS_BORN)
+        const BORN = 1 << 29;
+        /// This mount is active (MS_ACTIVE)
+        const ACTIVE = 1 << 30;
+        /// Mount flags not allowed from userspace (MS_NOUSER)
+        const NOUSER = 1 << 31;
+
+        /// Superblock flags that can be altered by MS_REMOUNT
+        const RMT_MASK = MountFlags::RDONLY.bits() |
+            MountFlags::SYNCHRONOUS.bits() |
+            MountFlags::MANDLOCK.bits() |
+            MountFlags::I_VERSION.bits() |
+            MountFlags::LAZYTIME.bits();
+    }
+}
+
+impl MountFlags {
+    /// Convert mount flags to a comma-separated string representation
+    ///
+    /// This function converts MountFlags to a string format similar to /proc/mounts,
+    /// such as "rw,nosuid,nodev,noexec,relatime".
+    ///
+    /// # Returns
+    ///
+    /// A String containing the mount options in comma-separated format.
+    #[inline(never)]
+    pub fn options_string(&self) -> String {
+        let mut options = Vec::new();
+
+        // Check read/write flag
+        if self.contains(MountFlags::RDONLY) {
+            options.push("ro");
+        } else {
+            options.push("rw");
+        }
+
+        // Check other flags
+        if self.contains(MountFlags::NOSUID) {
+            options.push("nosuid");
+        }
+        if self.contains(MountFlags::NODEV) {
+            options.push("nodev");
+        }
+        if self.contains(MountFlags::NOEXEC) {
+            options.push("noexec");
+        }
+        if self.contains(MountFlags::SYNCHRONOUS) {
+            options.push("sync");
+        }
+        if self.contains(MountFlags::MANDLOCK) {
+            options.push("mand");
+        }
+        if self.contains(MountFlags::DIRSYNC) {
+            options.push("dirsync");
+        }
+        if self.contains(MountFlags::NOSYMFOLLOW) {
+            options.push("nosymfollow");
+        }
+        if self.contains(MountFlags::NOATIME) {
+            options.push("noatime");
+        }
+        if self.contains(MountFlags::NODIRATIME) {
+            options.push("nodiratime");
+        }
+        if self.contains(MountFlags::RELATIME) {
+            options.push("relatime");
+        }
+        if self.contains(MountFlags::STRICTATIME) {
+            options.push("strictatime");
+        }
+        if self.contains(MountFlags::LAZYTIME) {
+            options.push("lazytime");
+        }
+
+        // Mount propagation flags
+        if self.contains(MountFlags::UNBINDABLE) {
+            options.push("unbindable");
+        }
+        if self.contains(MountFlags::PRIVATE) {
+            options.push("private");
+        }
+        if self.contains(MountFlags::SLAVE) {
+            options.push("slave");
+        }
+        if self.contains(MountFlags::SHARED) {
+            options.push("shared");
+        }
+
+        // Internal flags (typically not shown in /proc/mounts)
+        // We'll skip flags like BIND, MOVE, REC, REMOUNT, etc. as they're
+        // not typically displayed in mount options
+
+        options.join(",")
+    }
+}
+
 // MountId类型
 int_like!(MountId, usize);
 
@@ -73,6 +231,8 @@ pub struct MountFS {
     namespace: Lazy<Weak<MntNamespace>>,
     propagation: Arc<MountPropagation>,
     mount_id: MountId,
+
+    mount_flags: MountFlags,
 }
 
 impl Debug for MountFS {
@@ -101,6 +261,7 @@ impl MountFS {
         self_mountpoint: Option<Arc<MountFSInode>>,
         propagation: Arc<MountPropagation>,
         mnt_ns: Option<&Arc<MntNamespace>>,
+        mount_flags: MountFlags,
     ) -> Arc<Self> {
         let result = Arc::new_cyclic(|self_ref| MountFS {
             inner_filesystem,
@@ -110,6 +271,7 @@ impl MountFS {
             namespace: Lazy::new(),
             propagation,
             mount_id: MountId::alloc(),
+            mount_flags,
         });
 
         if let Some(mnt_ns) = mnt_ns {
@@ -119,6 +281,10 @@ impl MountFS {
         result
     }
 
+    pub fn mount_flags(&self) -> MountFlags {
+        self.mount_flags
+    }
+
     pub fn propagation(&self) -> Arc<MountPropagation> {
         self.propagation.clone()
     }
@@ -127,6 +293,10 @@ impl MountFS {
         self.namespace.init(namespace);
     }
 
+    pub fn fs_type(&self) -> &str {
+        self.inner_filesystem.name()
+    }
+
     #[inline(never)]
     pub fn self_mountpoint(&self) -> Option<Arc<MountFSInode>> {
         self.self_mountpoint.read().as_ref().cloned()
@@ -290,6 +460,7 @@ impl MountFSInode {
             .ok_or(SystemError::ENOENT);
     }
 
+    #[inline(never)]
     fn do_absolute_path(&self) -> Result<String, SystemError> {
         let mut current = self.self_ref.upgrade().unwrap();
 
@@ -304,6 +475,21 @@ impl MountFSInode {
         while current.metadata()?.inode_id != inode_id {
             let name = current.dname()?;
             path_parts.push(name.0);
+
+            // 防循环检查：如果路径深度超过1024，抛出警告
+            if path_parts.len() > 1024 {
+                #[inline(never)]
+                fn __log_warn(root: usize, cur: usize) {
+                    log::warn!(
+                        "Path depth exceeds 1024, possible infinite loop. root: {}, cur: {}",
+                        root,
+                        cur
+                    );
+                }
+                __log_warn(inode_id.data(), current.metadata().unwrap().inode_id.data());
+                return Err(SystemError::ELOOP);
+            }
+
             current = current.do_parent()?;
         }
 
@@ -523,7 +709,11 @@ impl IndexNode for MountFSInode {
         return self.inner_inode.list();
     }
 
-    fn mount(&self, fs: Arc<dyn FileSystem>) -> Result<Arc<MountFS>, SystemError> {
+    fn mount(
+        &self,
+        fs: Arc<dyn FileSystem>,
+        mount_flags: MountFlags,
+    ) -> Result<Arc<MountFS>, SystemError> {
         let metadata = self.inner_inode.metadata()?;
         if metadata.file_type != FileType::Dir {
             return Err(SystemError::ENOTDIR);
@@ -545,6 +735,7 @@ impl IndexNode for MountFSInode {
             Some(self.self_ref.upgrade().unwrap()),
             MountPropagation::new_private(), // 暂时不支持传播，后续会补充完善挂载传播性
             Some(&ProcessManager::current_mntns()),
+            mount_flags,
         );
 
         self.mount_fs
@@ -797,14 +988,14 @@ impl MountList {
     pub fn get_mount_point<T: AsRef<str>>(
         &self,
         path: T,
-    ) -> Option<(String, String, Arc<MountFS>)> {
+    ) -> Option<(Arc<MountPath>, String, Arc<MountFS>)> {
         self.mounts
             .upgradeable_read()
             .iter()
             .filter_map(|(key, fs)| {
                 let strkey = key.as_str();
                 if let Some(rest) = path.as_ref().strip_prefix(strkey) {
-                    return Some((strkey.to_string(), rest.to_string(), fs.clone()));
+                    return Some((key.clone(), rest.to_string(), fs.clone()));
                 }
                 None
             })
@@ -828,6 +1019,11 @@ impl MountList {
     pub fn remove<T: Into<MountPath>>(&self, path: T) -> Option<Arc<MountFS>> {
         self.mounts.write().remove(&path.into())
     }
+
+    /// # clone_inner - 克隆内部挂载点列表
+    pub fn clone_inner(&self) -> HashMap<Arc<MountPath>, Arc<MountFS>> {
+        self.mounts.read().clone()
+    }
 }
 
 impl Debug for MountList {
@@ -868,6 +1064,7 @@ pub fn is_mountpoint_root(inode: &Arc<dyn IndexNode>) -> bool {
 pub fn do_mount_mkdir(
     fs: Arc<dyn FileSystem>,
     mount_point: &str,
+    mount_flags: MountFlags,
 ) -> Result<Arc<MountFS>, SystemError> {
     let inode = do_mkdir_at(
         AtFlags::AT_FDCWD.bits(),
@@ -880,5 +1077,5 @@ pub fn do_mount_mkdir(
             return Err(SystemError::EBUSY);
         }
     }
-    return inode.mount(fs);
+    return inode.mount(fs, mount_flags);
 }

kernel/src/filesystem/vfs/syscall/sys_mount.rs

@@ -3,8 +3,8 @@
 use crate::{
     arch::{interrupt::TrapFrame, syscall::nr::SYS_MOUNT},
     filesystem::vfs::{
-        fcntl::AtFlags, produce_fs, utils::user_path_at, FileSystem, MountFS, MAX_PATHLEN,
-        VFS_MAX_FOLLOW_SYMLINK_TIMES,
+        fcntl::AtFlags, mount::MountFlags, produce_fs, utils::user_path_at, FileSystem, MountFS,
+        MAX_PATHLEN, VFS_MAX_FOLLOW_SYMLINK_TIMES,
     },
     process::ProcessManager,
     syscall::{
@@ -25,7 +25,7 @@ use system_error::SystemError;
 /// - source       挂载设备(目前只支持ext4格式的硬盘)
 /// - target       挂载目录
 /// - filesystemtype   文件系统
-/// - mountflags     挂载选项（暂未实现）
+/// - mountflags     挂载选项
 /// - data        带数据挂载
 ///
 /// ## 返回值
@@ -43,6 +43,9 @@ impl Syscall for SysMountHandle {
         let filesystemtype = Self::filesystemtype(args);
         let data = Self::raw_data(args);
         let source = Self::source(args);
+        let mount_flags = Self::mountflags(args);
+
+        let mount_flags = MountFlags::from_bits_truncate(mount_flags);
 
         let target = user_access::check_and_clone_cstr(target, Some(MAX_PATHLEN))?
             .into_string()
@@ -57,12 +60,14 @@ impl Syscall for SysMountHandle {
 
         let fs = produce_fs(fstype_str, data, source)?;
 
-        do_mount(fs, &target)?;
+        do_mount(fs, &target, mount_flags)?;
 
         return Ok(0);
     }
 
     fn entry_format(&self, args: &[usize]) -> Vec<FormattedSyscallParam> {
+        let flags = MountFlags::from_bits(Self::mountflags(args)).unwrap_or(MountFlags::empty());
+
         vec![
             FormattedSyscallParam::new("source", format!("{:#x}", Self::source(args) as usize)),
             FormattedSyscallParam::new("target", format!("{:#x}", Self::target(args) as usize)),
@@ -70,7 +75,10 @@ impl Syscall for SysMountHandle {
                 "filesystem type",
                 format!("{:#x}", Self::filesystemtype(args) as usize),
             ),
-            FormattedSyscallParam::new("mountflags", format!("{:#x}", Self::mountflags(args))),
+            FormattedSyscallParam::new(
+                "mountflags",
+                format!("{:?} ({:#x})", flags, Self::mountflags(args)),
+            ),
             FormattedSyscallParam::new("data", format!("{:?}", Self::raw_data(args))),
         ]
     }
@@ -86,8 +94,8 @@ impl SysMountHandle {
     fn filesystemtype(args: &[usize]) -> *const u8 {
         args[2] as *const u8
     }
-    fn mountflags(args: &[usize]) -> usize {
-        args[3]
+    fn mountflags(args: &[usize]) -> u32 {
+        args[3] as u32
     }
     fn raw_data(args: &[usize]) -> Option<&'static str> {
         let raw = args[4] as *const u8;
@@ -120,7 +128,11 @@ syscall_table_macros::declare_syscall!(SYS_MOUNT, SysMountHandle);
 ///
 /// - `Ok(Arc<MountFS>)`: 挂载成功后返回挂载的文件系统。
 /// - `Err(SystemError)`: 挂载失败时返回错误。
-pub fn do_mount(fs: Arc<dyn FileSystem>, mount_point: &str) -> Result<Arc<MountFS>, SystemError> {
+pub fn do_mount(
+    fs: Arc<dyn FileSystem>,
+    mount_point: &str,
+    mount_flags: MountFlags,
+) -> Result<Arc<MountFS>, SystemError> {
     let (current_node, rest_path) = user_path_at(
         &ProcessManager::current_pcb(),
         AtFlags::AT_FDCWD.bits(),
@@ -134,5 +146,5 @@ pub fn do_mount(fs: Arc<dyn FileSystem>, mount_point: &str) -> Result<Arc<MountF
         }
     }
     // 移至IndexNode.mount()来记录
-    return inode.mount(fs);
+    return inode.mount(fs, mount_flags);
 }

kernel/src/filesystem/vfs/vcore.rs

@@ -69,7 +69,13 @@ fn migrate_virtual_filesystem(new_fs: Arc<dyn FileSystem>) -> Result<(), SystemE
     let current_mntns = ProcessManager::current_mntns();
     let old_root_inode = current_mntns.root_inode();
     let old_mntfs = current_mntns.root_mntfs().clone();
-    let new_fs = MountFS::new(new_fs, None, old_mntfs.propagation(), Some(&current_mntns));
+    let new_fs = MountFS::new(
+        new_fs,
+        None,
+        old_mntfs.propagation(),
+        Some(&current_mntns),
+        old_mntfs.mount_flags(),
+    );
 
     // 获取新的根文件系统的根节点的引用
     let new_root_inode = new_fs.root_inode();

kernel/src/process/namespace/mnt.rs

@@ -1,6 +1,6 @@
 use crate::{
     filesystem::vfs::{
-        mount::{MountList, MountPath},
+        mount::{MountFlags, MountList, MountPath},
         FileSystem, IndexNode, MountFS,
     },
     libs::{once::Once, spinlock::SpinLock},
@@ -62,7 +62,13 @@ impl MntNamespace {
         let mount_list = MountList::new();
 
         let ramfs = crate::filesystem::ramfs::RamFS::new();
-        let ramfs = MountFS::new(ramfs, None, MountPropagation::new_private(), None);
+        let ramfs = MountFS::new(
+            ramfs,
+            None,
+            MountPropagation::new_private(),
+            None,
+            MountFlags::empty(),
+        );
 
         let result = Arc::new_cyclic(|self_ref| Self {
             ns_common: NsCommon::new(0, NamespaceType::Mount),
@@ -75,7 +81,11 @@ impl MntNamespace {
                 _dead: false,
             }),
         });
+
         ramfs.set_namespace(Arc::downgrade(&result));
+        result
+            .add_mount(Arc::new(MountPath::from("/")), ramfs)
+            .expect("Failed to add root mount");
 
         return result;
     }
@@ -84,9 +94,13 @@ impl MntNamespace {
     ///
     /// 本方法仅供dragonos初始化时使用
     pub unsafe fn force_change_root_mountfs(&self, new_root: Arc<MountFS>) {
+        let inner_guard = self.inner.lock();
         let ptr = self as *const Self as *mut Self;
         let self_mut = (ptr).as_mut().unwrap();
-        self_mut.root_mountfs = new_root;
+        self_mut.root_mountfs = new_root.clone();
+        let (path, _, _) = inner_guard.mount_list.get_mount_point("/").unwrap();
+
+        inner_guard.mount_list.insert(path, new_root);
     }
 
     /// Creates a copy of the mount namespace for process cloning.
@@ -136,11 +150,18 @@ impl MntNamespace {
         return Ok(());
     }
 
+    pub fn mount_list(&self) -> Arc<MountList> {
+        self.inner.lock().mount_list.clone()
+    }
+
     pub fn remove_mount(&self, mount_path: &str) -> Option<Arc<MountFS>> {
         return self.inner.lock().mount_list.remove(mount_path);
     }
 
-    pub fn get_mount_point(&self, mount_point: &str) -> Option<(String, String, Arc<MountFS>)> {
+    pub fn get_mount_point(
+        &self,
+        mount_point: &str,
+    ) -> Option<(Arc<MountPath>, String, Arc<MountFS>)> {
         self.inner.lock().mount_list.get_mount_point(mount_point)
     }
 }