fix: Fixed several errors in the file system (#1249)

* fix: Fixed several errors in the file system

1. Adjust the initialization order of the file system
2. Complete missing interfaces for special files
3. Fix file system remount error
4. Fix other bugs

Signed-off-by: Godones <chenlinfeng25@outlook.com>
---------

Signed-off-by: Godones <chenlinfeng25@outlook.com>
Co-authored-by: longjin <longjin@DragonOS.org>

kernel/src/bpf/map/mod.rs

@@ -182,6 +182,10 @@ impl IndexNode for BpfMap {
     fn list(&self) -> Result<Vec<String>> {
         Err(SystemError::ENOSYS)
     }
+
+    fn absolute_path(&self) -> core::result::Result<String, SystemError> {
+        Ok(String::from("BpfMap"))
+    }
 }
 
 /// Create a map and return a file descriptor that refers to

kernel/src/bpf/prog/mod.rs

@@ -95,6 +95,10 @@ impl IndexNode for BpfProg {
     fn list(&self) -> Result<Vec<String>> {
         Err(SystemError::ENOSYS)
     }
+
+    fn absolute_path(&self) -> core::result::Result<String, SystemError> {
+        Ok(String::from("BPF Program"))
+    }
 }
 
 impl Drop for BpfProg {

kernel/src/driver/base/block/gendisk/mod.rs

@@ -13,7 +13,7 @@ use system_error::SystemError;
 use crate::{
     driver::base::device::device_number::DeviceNumber,
     filesystem::{
-        devfs::{DevFS, DeviceINode},
+        devfs::{DevFS, DeviceINode, LockedDevFSInode},
         vfs::{syscall::ModeType, utils::DName, IndexNode, Metadata},
     },
     libs::{rwlock::RwLock, spinlock::SpinLockGuard},
@@ -32,6 +32,7 @@ pub struct GenDisk {
 
     device_num: DeviceNumber,
 
+    parent: RwLock<Weak<LockedDevFSInode>>,
     fs: RwLock<Weak<DevFS>>,
     metadata: Metadata,
     /// 对应/dev/下的设备名
@@ -69,6 +70,7 @@ impl GenDisk {
             block_size_log2: bsizelog2,
             idx,
             device_num,
+            parent: RwLock::new(Weak::default()),
             fs: RwLock::new(Weak::default()),
             metadata: Metadata::new(
                 crate::filesystem::vfs::FileType::BlockDevice,
@@ -212,9 +214,11 @@ impl IndexNode for GenDisk {
     fn fs(&self) -> Arc<dyn crate::filesystem::vfs::FileSystem> {
         self.fs.read().upgrade().unwrap()
     }
+
     fn as_any_ref(&self) -> &dyn core::any::Any {
         self
     }
+
     fn read_at(
         &self,
         _offset: usize,
@@ -224,6 +228,7 @@ impl IndexNode for GenDisk {
     ) -> Result<usize, SystemError> {
         Err(SystemError::EPERM)
     }
+
     fn write_at(
         &self,
         _offset: usize,
@@ -233,21 +238,51 @@ impl IndexNode for GenDisk {
     ) -> Result<usize, SystemError> {
         Err(SystemError::EPERM)
     }
+
     fn list(&self) -> Result<alloc::vec::Vec<alloc::string::String>, system_error::SystemError> {
         Err(SystemError::ENOSYS)
     }
+
     fn metadata(&self) -> Result<crate::filesystem::vfs::Metadata, SystemError> {
         Ok(self.metadata.clone())
     }
+
     fn dname(&self) -> Result<DName, SystemError> {
         Ok(self.name.clone())
     }
+
+    fn parent(&self) -> Result<Arc<dyn IndexNode>, SystemError> {
+        let parent = self.parent.read();
+        if let Some(parent) = parent.upgrade() {
+            return Ok(parent as Arc<dyn IndexNode>);
+        }
+        Err(SystemError::ENOENT)
+    }
+
+    fn close(
+        &self,
+        _data: SpinLockGuard<crate::filesystem::vfs::FilePrivateData>,
+    ) -> Result<(), SystemError> {
+        Ok(())
+    }
+
+    fn open(
+        &self,
+        _data: SpinLockGuard<crate::filesystem::vfs::FilePrivateData>,
+        _mode: &crate::filesystem::vfs::file::FileMode,
+    ) -> Result<(), SystemError> {
+        Ok(())
+    }
 }
 
 impl DeviceINode for GenDisk {
     fn set_fs(&self, fs: alloc::sync::Weak<crate::filesystem::devfs::DevFS>) {
         *self.fs.write() = fs;
     }
+
+    fn set_parent(&self, parent: Weak<LockedDevFSInode>) {
+        *self.parent.write() = parent;
+    }
 }
 
 #[derive(Default)]

kernel/src/driver/block/virtio_blk.rs

@@ -42,10 +42,10 @@ use crate::{
     },
     exception::{irqdesc::IrqReturn, IrqNumber},
     filesystem::{
-        devfs::{DevFS, DeviceINode},
+        devfs::{DevFS, DeviceINode, LockedDevFSInode},
         kernfs::KernFSInode,
         mbr::MbrDiskPartionTable,
-        vfs::{syscall::ModeType, IndexNode, Metadata},
+        vfs::{syscall::ModeType, utils::DName, IndexNode, Metadata},
     },
     init::initcall::INITCALL_POSTCORE,
     libs::{
@@ -164,7 +164,7 @@ pub struct VirtIOBlkDevice {
     inner: SpinLock<InnerVirtIOBlkDevice>,
     locked_kobj_state: LockedKObjectState,
     self_ref: Weak<Self>,
-
+    parent: RwLock<Weak<LockedDevFSInode>>,
     fs: RwLock<Weak<DevFS>>,
     metadata: Metadata,
 }
@@ -212,6 +212,7 @@ impl VirtIOBlkDevice {
                 kobject_common: KObjectCommonData::default(),
                 irq,
             }),
+            parent: RwLock::new(Weak::default()),
             fs: RwLock::new(Weak::default()),
             metadata: Metadata::new(
                 crate::filesystem::vfs::FileType::BlockDevice,
@@ -229,7 +230,10 @@ impl VirtIOBlkDevice {
 
 impl IndexNode for VirtIOBlkDevice {
     fn fs(&self) -> Arc<dyn crate::filesystem::vfs::FileSystem> {
-        todo!()
+        self.fs
+            .read()
+            .upgrade()
+            .expect("VirtIOBlkDevice fs is not set")
     }
     fn as_any_ref(&self) -> &dyn core::any::Any {
         self
@@ -258,12 +262,44 @@ impl IndexNode for VirtIOBlkDevice {
     fn metadata(&self) -> Result<crate::filesystem::vfs::Metadata, SystemError> {
         Ok(self.metadata.clone())
     }
+
+    fn parent(&self) -> Result<Arc<dyn IndexNode>, SystemError> {
+        let parent = self.parent.read();
+        if let Some(parent) = parent.upgrade() {
+            return Ok(parent as Arc<dyn IndexNode>);
+        }
+        Err(SystemError::ENOENT)
+    }
+
+    fn close(
+        &self,
+        _data: SpinLockGuard<crate::filesystem::vfs::FilePrivateData>,
+    ) -> Result<(), SystemError> {
+        Ok(())
+    }
+
+    fn dname(&self) -> Result<DName, SystemError> {
+        let dname = DName::from(self.blkdev_meta.devname.clone().as_ref());
+        Ok(dname)
+    }
+
+    fn open(
+        &self,
+        _data: SpinLockGuard<crate::filesystem::vfs::FilePrivateData>,
+        _mode: &crate::filesystem::vfs::file::FileMode,
+    ) -> Result<(), SystemError> {
+        Ok(())
+    }
 }
 
 impl DeviceINode for VirtIOBlkDevice {
     fn set_fs(&self, fs: alloc::sync::Weak<crate::filesystem::devfs::DevFS>) {
         *self.fs.write() = fs;
     }
+
+    fn set_parent(&self, parent: Weak<crate::filesystem::devfs::LockedDevFSInode>) {
+        *self.parent.write() = parent;
+    }
 }
 
 impl BlockDevice for VirtIOBlkDevice {

kernel/src/driver/clocksource/acpi_pm.rs

@@ -227,7 +227,6 @@ fn find_acpi_pm_clock() -> Result<(), SystemError> {
 }
 
 /// # 初始化ACPI PM Timer作为系统时钟源
-// #[unified_init(INITCALL_FS)]
 #[inline(never)]
 #[allow(dead_code)]
 pub fn init_acpi_pm_clocksource() -> Result<(), SystemError> {

kernel/src/driver/input/ps2_mouse/ps_mouse_device.rs

@@ -28,7 +28,7 @@ use crate::{
     },
     exception::InterruptArch,
     filesystem::{
-        devfs::{devfs_register, DevFS, DeviceINode},
+        devfs::{devfs_register, DevFS, DeviceINode, LockedDevFSInode},
         kernfs::KernFSInode,
         vfs::{
             syscall::ModeType, utils::DName, vcore::generate_inode_id, FilePrivateData, FileSystem,
@@ -207,6 +207,7 @@ impl Ps2MouseDevice {
                     raw_dev: DeviceNumber::default(), // 这里用来作为device number
                 },
                 device_inode_fs: None,
+                parent: Weak::new(),
             }),
             kobj_state: LockedKObjectState::new(None),
         };
@@ -424,6 +425,7 @@ struct InnerPs2MouseDevice {
 
     /// device inode要求的字段
     device_inode_fs: Option<Weak<DevFS>>,
+    parent: Weak<LockedDevFSInode>,
     devfs_metadata: Metadata,
 }
 
@@ -587,6 +589,10 @@ impl DeviceINode for Ps2MouseDevice {
     fn set_fs(&self, fs: Weak<DevFS>) {
         self.inner.lock_irqsave().device_inode_fs = Some(fs);
     }
+
+    fn set_parent(&self, parent: Weak<crate::filesystem::devfs::LockedDevFSInode>) {
+        self.inner.lock_irqsave().parent = parent;
+    }
 }
 
 impl IndexNode for Ps2MouseDevice {
@@ -664,6 +670,14 @@ impl IndexNode for Ps2MouseDevice {
     fn dname(&self) -> Result<DName, SystemError> {
         Ok(DName::from(self.name()))
     }
+
+    fn parent(&self) -> Result<Arc<dyn IndexNode>, SystemError> {
+        let guard = self.inner.lock_irqsave();
+        if let Some(parent) = guard.parent.upgrade() {
+            return Ok(parent);
+        }
+        Err(SystemError::ENOENT)
+    }
 }
 
 impl Ps2Device for Ps2MouseDevice {}

kernel/src/driver/keyboard/ps2_keyboard.rs

@@ -20,7 +20,7 @@ use crate::{
         InterruptArch, IrqNumber,
     },
     filesystem::{
-        devfs::{devfs_register, DevFS, DeviceINode},
+        devfs::{devfs_register, DevFS, DeviceINode, LockedDevFSInode},
         vfs::{
             file::FileMode, syscall::ModeType, vcore::generate_inode_id, FilePrivateData,
             FileSystem, FileType, IndexNode, Metadata,
@@ -66,6 +66,7 @@ pub struct PS2KeyBoardInode {
     /// 指向自身的弱引用
     self_ref: Weak<LockedPS2KeyBoardInode>,
     /// 指向inode所在的文件系统对象的指针
+    parent: Weak<LockedDevFSInode>,
     fs: Weak<DevFS>,
     /// INode 元数据
     metadata: Metadata,
@@ -76,6 +77,7 @@ impl LockedPS2KeyBoardInode {
         let inode = PS2KeyBoardInode {
             // uuid: Uuid::new_v5(),
             self_ref: Weak::default(),
+            parent: Weak::default(),
             fs: Weak::default(),
             metadata: Metadata {
                 dev_id: 1,
@@ -107,6 +109,11 @@ impl DeviceINode for LockedPS2KeyBoardInode {
     fn set_fs(&self, fs: Weak<DevFS>) {
         self.0.write().fs = fs;
     }
+
+    fn set_parent(&self, parent: Weak<LockedDevFSInode>) {
+        let mut inode = self.0.write();
+        inode.parent = parent;
+    }
 }
 
 fn ps2_keyboard_register() {
@@ -175,6 +182,14 @@ impl IndexNode for LockedPS2KeyBoardInode {
     fn list(&self) -> Result<alloc::vec::Vec<alloc::string::String>, SystemError> {
         return Err(SystemError::ENOSYS);
     }
+
+    fn parent(&self) -> Result<Arc<dyn IndexNode>, SystemError> {
+        let parent = self.0.read().parent.upgrade();
+        if let Some(parent) = parent {
+            return Ok(parent as Arc<dyn IndexNode>);
+        }
+        Err(SystemError::ENOENT)
+    }
 }
 
 #[derive(Debug)]

kernel/src/driver/tty/tty_device.rs

@@ -26,12 +26,13 @@ use crate::{
         serial::serial_init,
     },
     filesystem::{
-        devfs::{devfs_register, DevFS, DeviceINode},
+        devfs::{devfs_register, DevFS, DeviceINode, LockedDevFSInode},
+        devpts::{DevPtsFs, LockedDevPtsFSInode},
         epoll::EPollItem,
         kernfs::KernFSInode,
         vfs::{
-            file::FileMode, syscall::ModeType, FilePrivateData, FileType, IndexNode, Metadata,
-            PollableInode,
+            file::FileMode, syscall::ModeType, utils::DName, FilePrivateData, FileType, IndexNode,
+            Metadata, PollableInode,
         },
     },
     init::initcall::INITCALL_DEVICE,
@@ -107,7 +108,19 @@ pub struct TtyDevice {
     inner: RwLock<InnerTtyDevice>,
     kobj_state: LockedKObjectState,
     /// TTY所属的文件系统
-    fs: RwLock<Weak<DevFS>>,
+    fs: RwLock<TtyDeviceFs>,
+    parent: RwLock<TtyDeviceParent>,
+}
+
+pub enum TtyDeviceFs {
+    DevFs(Weak<DevFS>),
+    DevPtsFs(Weak<DevPtsFs>),
+    None,
+}
+pub enum TtyDeviceParent {
+    DevFS(Weak<LockedDevFSInode>),
+    DevPts(Weak<LockedDevPtsFSInode>),
+    None,
 }
 
 impl TtyDevice {
@@ -118,7 +131,8 @@ impl TtyDevice {
             id_table,
             inner: RwLock::new(InnerTtyDevice::new()),
             kobj_state: LockedKObjectState::new(None),
-            fs: RwLock::new(Weak::default()),
+            fs: RwLock::new(TtyDeviceFs::None),
+            parent: RwLock::new(TtyDeviceParent::None),
             tty_type,
         };
 
@@ -361,7 +375,17 @@ impl IndexNode for TtyDevice {
     }
 
     fn fs(&self) -> Arc<dyn crate::filesystem::vfs::FileSystem> {
-        todo!()
+        match &*self.fs.read() {
+            TtyDeviceFs::DevFs(fs) => fs.upgrade().unwrap(),
+            TtyDeviceFs::DevPtsFs(fs) => fs.upgrade().unwrap(),
+            TtyDeviceFs::None => {
+                panic!("TtyDevice has no filesystem set");
+            }
+        }
+    }
+
+    fn dname(&self) -> Result<DName, SystemError> {
+        Ok(self.name.clone().into())
     }
 
     fn as_any_ref(&self) -> &dyn core::any::Any {
@@ -483,11 +507,32 @@ impl IndexNode for TtyDevice {
     fn as_pollable_inode(&self) -> Result<&dyn PollableInode, SystemError> {
         Ok(self)
     }
+
+    fn parent(&self) -> Result<Arc<dyn IndexNode>, SystemError> {
+        let parent = self.parent.read();
+        match &*parent {
+            TtyDeviceParent::DevFS(devfs) => Ok(devfs.upgrade().unwrap()),
+            TtyDeviceParent::DevPts(devpts) => Ok(devpts.upgrade().unwrap()),
+            TtyDeviceParent::None => panic!("TtyDevice has no filesystem set"),
+        }
+    }
 }
 
 impl DeviceINode for TtyDevice {
     fn set_fs(&self, fs: alloc::sync::Weak<crate::filesystem::devfs::DevFS>) {
-        *self.fs.write() = fs;
+        *self.fs.write() = TtyDeviceFs::DevFs(fs);
+    }
+
+    fn set_parent(&self, parent: Weak<crate::filesystem::devfs::LockedDevFSInode>) {
+        *self.parent.write() = TtyDeviceParent::DevFS(parent);
+    }
+
+    fn set_devpts_fs(&self, devpts: Weak<crate::filesystem::devpts::DevPtsFs>) {
+        *self.fs.write() = TtyDeviceFs::DevPtsFs(devpts);
+    }
+
+    fn set_devpts_parent(&self, parent: Weak<LockedDevPtsFSInode>) {
+        *self.parent.write() = TtyDeviceParent::DevPts(parent);
     }
 }
 

kernel/src/driver/video/fbdev/base/fbmem.rs

@@ -25,7 +25,7 @@ use crate::{
         subsys::SubSysPrivate,
     },
     filesystem::{
-        devfs::{devfs_register, DevFS, DeviceINode},
+        devfs::{devfs_register, DevFS, DeviceINode, LockedDevFSInode},
         kernfs::KernFSInode,
         sysfs::AttributeGroup,
         vfs::{
@@ -223,6 +223,7 @@ impl FbDevice {
                 device_common: DeviceCommonData::default(),
                 fb_id: id,
                 device_inode_fs: None,
+                parent: Weak::default(),
                 devfs_metadata: Metadata::new(
                     FileType::FramebufferDevice,
                     ModeType::from_bits_truncate(0o666),
@@ -268,6 +269,7 @@ struct InnerFbDevice {
 
     /// device inode要求的字段
     device_inode_fs: Option<Weak<DevFS>>,
+    parent: Weak<LockedDevFSInode>,
     devfs_metadata: Metadata,
 }
 
@@ -390,6 +392,10 @@ impl DeviceINode for FbDevice {
     fn set_fs(&self, fs: Weak<DevFS>) {
         self.inner.lock().device_inode_fs = Some(fs);
     }
+
+    fn set_parent(&self, parent: Weak<crate::filesystem::devfs::LockedDevFSInode>) {
+        self.inner.lock().parent = parent;
+    }
 }
 
 impl IndexNode for FbDevice {
@@ -451,4 +457,12 @@ impl IndexNode for FbDevice {
     fn resize(&self, _len: usize) -> Result<(), SystemError> {
         return Ok(());
     }
+
+    fn parent(&self) -> Result<Arc<dyn IndexNode>, SystemError> {
+        let parent = self.inner.lock().parent.upgrade();
+        if let Some(parent) = parent {
+            return Ok(parent as Arc<dyn IndexNode>);
+        }
+        Err(SystemError::ENOENT)
+    }
 }

kernel/src/filesystem/devfs/mod.rs

@@ -8,7 +8,9 @@ use super::vfs::{
 };
 use crate::{
     driver::base::{block::gendisk::GenDisk, device::device_number::DeviceNumber},
+    filesystem::devpts::{DevPtsFs, LockedDevPtsFSInode},
     libs::{
+        casting::DowncastArc,
         once::Once,
         spinlock::{SpinLock, SpinLockGuard},
     },
@@ -73,6 +75,8 @@ impl DevFS {
             DevFSInode::new(FileType::Dir, ModeType::from_bits_truncate(0o755), 0),
         )));
 
+        // panic!("devfs root inode id: {:?}", root.0.lock().metadata.inode_id);
+
         let devfs: Arc<DevFS> = Arc::new(DevFS {
             root_inode: root,
             super_block,
@@ -121,7 +125,7 @@ impl DevFS {
         name: &str,
         device: Arc<T>,
     ) -> Result<(), SystemError> {
-        let dev_root_inode: Arc<LockedDevFSInode> = self.root_inode.clone();
+        let dev_root_inode = self.root_inode.clone();
         let metadata = device.metadata()?;
         match metadata.file_type {
             // 字节设备挂载在 /dev/char
@@ -135,11 +139,10 @@ impl DevFS {
                 }
 
                 let any_char_inode = dev_root_inode.find("char")?;
-                let dev_char_inode: &LockedDevFSInode = any_char_inode
-                    .as_any_ref()
-                    .downcast_ref::<LockedDevFSInode>()
-                    .unwrap();
+                let dev_char_inode = any_char_inode.downcast_arc::<LockedDevFSInode>().unwrap();
 
+                device.set_fs(dev_root_inode.0.lock().fs.clone());
+                device.set_parent(Arc::downgrade(&dev_root_inode));
                 // 特殊处理 tty 设备，挂载在 /dev 下
                 if name.starts_with("tty") && name.len() >= 3 {
                     dev_root_inode.add_dev(name, device.clone())?;
@@ -154,8 +157,8 @@ impl DevFS {
                 } else {
                     // 在 /dev/char 下创建设备节点
                     dev_char_inode.add_dev(name, device.clone())?;
+                    device.set_parent(Arc::downgrade(&dev_char_inode));
                 }
-                device.set_fs(dev_char_inode.0.lock().fs.clone());
             }
             FileType::BlockDevice => {
                 if dev_root_inode.find("block").is_err() {
@@ -167,10 +170,11 @@ impl DevFS {
                 }
 
                 let any_block_inode = dev_root_inode.find("block")?;
-                let dev_block_inode: &LockedDevFSInode = any_block_inode
-                    .as_any_ref()
-                    .downcast_ref::<LockedDevFSInode>()
-                    .unwrap();
+                let dev_block_inode = any_block_inode.downcast_arc::<LockedDevFSInode>().unwrap();
+
+                // default parent is dev_root_inode
+                device.set_parent(Arc::downgrade(&dev_root_inode));
+                device.set_fs(dev_root_inode.0.lock().fs.clone());
 
                 if name.starts_with("vd") && name.len() > 2 {
                     // 虚拟磁盘设备挂载在 /dev 下
@@ -188,24 +192,22 @@ impl DevFS {
                     dev_root_inode.add_dev(name, device.clone())?;
                 } else {
                     dev_block_inode.add_dev(name, device.clone())?;
+                    device.set_parent(Arc::downgrade(&dev_block_inode));
                 }
-                device.set_fs(dev_block_inode.0.lock().fs.clone());
-            }
-            FileType::KvmDevice => {
-                dev_root_inode
-                    .add_dev(name, device.clone())
-                    .expect("DevFS: Failed to register /dev/kvm");
             }
-            FileType::FramebufferDevice => {
+            FileType::KvmDevice | FileType::FramebufferDevice => {
                 dev_root_inode
                     .add_dev(name, device.clone())
-                    .expect("DevFS: Failed to register /dev/fb");
+                    .unwrap_or_else(|_| panic!("DevFS: Failed to register /dev/{}", name));
+
+                // default parent is dev_root_inode
+                device.set_parent(Arc::downgrade(&dev_root_inode));
+                device.set_fs(dev_root_inode.0.lock().fs.clone());
             }
             _ => {
                 return Err(SystemError::ENOSYS);
             }
         }
-
         return Ok(());
     }
 
@@ -677,6 +679,13 @@ impl IndexNode for LockedDevFSInode {
 /// @brief 所有的设备INode都需要额外实现这个trait
 pub trait DeviceINode: IndexNode {
     fn set_fs(&self, fs: Weak<DevFS>);
+    fn set_parent(&self, parent: Weak<LockedDevFSInode>);
+    fn set_devpts_fs(&self, _devpts: Weak<DevPtsFs>) {
+        panic!("DeviceINode: set_devpts_fs is not implemented!");
+    }
+    fn set_devpts_parent(&self, _parent: Weak<LockedDevPtsFSInode>) {
+        panic!("DeviceINode: set_devpts_parent is not implemented!");
+    }
     // TODO: 增加 unregister 方法
 }
 

kernel/src/filesystem/devfs/null_dev.rs

@@ -1,4 +1,5 @@
 use crate::driver::base::device::device_number::DeviceNumber;
+use crate::filesystem::devfs::LockedDevFSInode;
 use crate::filesystem::vfs::file::FileMode;
 use crate::filesystem::vfs::syscall::ModeType;
 use crate::filesystem::vfs::{
@@ -25,6 +26,7 @@ pub struct NullInode {
     fs: Weak<DevFS>,
     /// INode 元数据
     metadata: Metadata,
+    parent: Weak<LockedDevFSInode>,
 }
 
 #[derive(Debug)]
@@ -36,6 +38,7 @@ impl LockedNullInode {
             // uuid: Uuid::new_v5(),
             self_ref: Weak::default(),
             fs: Weak::default(),
+            parent: Weak::default(),
             metadata: Metadata {
                 dev_id: 1,
                 inode_id: generate_inode_id(),
@@ -66,6 +69,10 @@ impl DeviceINode for LockedNullInode {
     fn set_fs(&self, fs: Weak<DevFS>) {
         self.0.lock().fs = fs;
     }
+
+    fn set_parent(&self, parent: Weak<super::LockedDevFSInode>) {
+        self.0.lock().parent = parent;
+    }
 }
 
 impl IndexNode for LockedNullInode {
@@ -135,4 +142,12 @@ impl IndexNode for LockedNullInode {
 
         Ok(len)
     }
+
+    fn parent(&self) -> Result<Arc<dyn IndexNode>, SystemError> {
+        let parent = self.0.lock().parent.upgrade();
+        if let Some(parent) = parent {
+            return Ok(parent);
+        }
+        Err(SystemError::ENOENT)
+    }
 }

kernel/src/filesystem/devfs/zero_dev.rs

@@ -1,4 +1,5 @@
 use crate::driver::base::device::device_number::DeviceNumber;
+use crate::filesystem::devfs::LockedDevFSInode;
 use crate::filesystem::vfs::file::FileMode;
 use crate::filesystem::vfs::syscall::ModeType;
 use crate::filesystem::vfs::{
@@ -23,6 +24,7 @@ pub struct ZeroInode {
     self_ref: Weak<LockedZeroInode>,
     /// 指向inode所在的文件系统对象的指针
     fs: Weak<DevFS>,
+    parent: Weak<LockedDevFSInode>,
     /// INode 元数据
     metadata: Metadata,
 }
@@ -35,6 +37,7 @@ impl LockedZeroInode {
         let inode = ZeroInode {
             // uuid: Uuid::new_v5(),
             self_ref: Weak::default(),
+            parent: Weak::default(),
             fs: Weak::default(),
             metadata: Metadata {
                 dev_id: 1,
@@ -66,6 +69,10 @@ impl DeviceINode for LockedZeroInode {
     fn set_fs(&self, fs: Weak<DevFS>) {
         self.0.lock().fs = fs;
     }
+
+    fn set_parent(&self, parent: Weak<LockedDevFSInode>) {
+        self.0.lock().parent = parent;
+    }
 }
 
 impl IndexNode for LockedZeroInode {
@@ -143,4 +150,12 @@ impl IndexNode for LockedZeroInode {
 
         Ok(len)
     }
+
+    fn parent(&self) -> Result<Arc<dyn IndexNode>, SystemError> {
+        let parent = self.0.lock().parent.upgrade();
+        if let Some(parent) = parent {
+            return Ok(parent as Arc<dyn IndexNode>);
+        }
+        Err(SystemError::ENOENT)
+    }
 }

kernel/src/filesystem/devpts/mod.rs

@@ -1,16 +1,5 @@
 use core::sync::atomic::{AtomicU32, Ordering};
 
-use alloc::{
-    collections::BTreeMap,
-    string::{String, ToString},
-    sync::{Arc, Weak},
-    vec::Vec,
-};
-use ida::IdAllocator;
-use log::info;
-use system_error::SystemError;
-use unified_init::macros::unified_init;
-
 use crate::{
     driver::{
         base::device::{
@@ -22,11 +11,22 @@ use crate::{
             tty_device::{PtyType, TtyDevice, TtyType},
         },
     },
-    filesystem::vfs::{mount::do_mount_mkdir, syscall::ModeType, FileType},
-    init::initcall::INITCALL_FS,
+    filesystem::{
+        devfs::DeviceINode,
+        vfs::{mount::do_mount_mkdir, syscall::ModeType, FileType},
+    },
     libs::spinlock::{SpinLock, SpinLockGuard},
     time::PosixTimeSpec,
 };
+use alloc::{
+    collections::BTreeMap,
+    string::{String, ToString},
+    sync::{Arc, Weak},
+    vec::Vec,
+};
+use ida::IdAllocator;
+use log::info;
+use system_error::SystemError;
 
 use super::vfs::{
     vcore::generate_inode_id, FilePrivateData, FileSystem, FsInfo, IndexNode, Metadata,
@@ -48,6 +48,8 @@ pub struct DevPtsFs {
 impl DevPtsFs {
     pub fn new() -> Arc<Self> {
         let root_inode = Arc::new(LockedDevPtsFSInode::new());
+        root_inode.inner.lock().parent = Arc::downgrade(&root_inode);
+        root_inode.inner.lock().self_ref = Arc::downgrade(&root_inode);
         let ret = Arc::new(Self {
             root_inode,
             pts_ida: SpinLock::new(IdAllocator::new(0, NR_UNIX98_PTY_MAX as usize).unwrap()),
@@ -100,6 +102,8 @@ impl LockedDevPtsFSInode {
             inner: SpinLock::new(PtsDevInode {
                 fs: Weak::new(),
                 children: Some(BTreeMap::new()),
+                parent: Weak::new(),
+                self_ref: Weak::new(),
                 metadata: Metadata {
                     dev_id: 0,
                     inode_id: generate_inode_id(),
@@ -131,6 +135,8 @@ pub struct PtsDevInode {
     fs: Weak<DevPtsFs>,
     children: Option<BTreeMap<String, Arc<TtyDevice>>>,
     metadata: Metadata,
+    parent: Weak<LockedDevPtsFSInode>,
+    self_ref: Weak<LockedDevPtsFSInode>,
 }
 
 impl PtsDevInode {
@@ -247,6 +253,9 @@ impl IndexNode for LockedDevPtsFSInode {
 
         result.set_metadata(&metadata)?;
 
+        result.set_devpts_fs(Arc::downgrade(&fs));
+        result.set_devpts_parent(guard.self_ref.clone());
+
         guard
             .children_unchecked_mut()
             .insert(name.to_string(), result.clone());
@@ -273,8 +282,6 @@ impl IndexNode for LockedDevPtsFSInode {
     }
 }
 
-#[unified_init(INITCALL_FS)]
-#[inline(never)]
 pub fn devpts_init() -> Result<(), SystemError> {
     // 创建 devptsfs 实例
     let ptsfs: Arc<DevPtsFs> = DevPtsFs::new();

kernel/src/filesystem/epoll/fs.rs

@@ -1,3 +1,5 @@
+use alloc::string::String;
+
 use crate::{
     filesystem::vfs::{file::FileMode, FilePrivateData, IndexNode, Metadata},
     libs::spinlock::SpinLockGuard,
@@ -74,4 +76,8 @@ impl IndexNode for EPollInode {
     ) -> Result<(), SystemError> {
         Ok(())
     }
+
+    fn absolute_path(&self) -> Result<String, SystemError> {
+        Ok(String::from("epoll"))
+    }
 }

kernel/src/filesystem/eventfd.rs

@@ -274,6 +274,10 @@ impl IndexNode for EventFdInode {
     fn as_pollable_inode(&self) -> Result<&dyn PollableInode, SystemError> {
         Ok(self)
     }
+
+    fn absolute_path(&self) -> Result<String, SystemError> {
+        Ok(String::from("eventfd"))
+    }
 }
 
 impl Syscall {

kernel/src/filesystem/procfs/mod.rs

@@ -38,7 +38,7 @@ mod syscall;
 
 /// @brief 进程文件类型
 /// @usage 用于定义进程文件夹下的各类文件类型
-#[derive(Debug)]
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
 #[repr(u8)]
 pub enum ProcFileType {
     ///展示进程状态信息
@@ -49,6 +49,9 @@ pub enum ProcFileType {
     ProcKmsg = 2,
     /// 可执行路径
     ProcExe = 3,
+    ProcSelf = 4,
+    ProcFdDir = 5,
+    ProcFdFile = 6,
     //todo: 其他文件类型
     ///默认文件类型
     Default,
@@ -61,6 +64,9 @@ impl From<u8> for ProcFileType {
             1 => ProcFileType::ProcMeminfo,
             2 => ProcFileType::ProcKmsg,
             3 => ProcFileType::ProcExe,
+            4 => ProcFileType::ProcSelf,
+            5 => ProcFileType::ProcFdDir,
+            6 => ProcFileType::ProcFdFile,
             _ => ProcFileType::Default,
         }
     }
@@ -73,7 +79,9 @@ pub struct InodeInfo {
     pid: RawPid,
     ///文件类型
     ftype: ProcFileType,
-    //其他需要传入的信息在此定义
+    /// 文件描述符
+    fd: i32,
+    // 其他需要传入的信息在此定义
 }
 
 /// @brief procfs的inode名称的最大长度
@@ -304,8 +312,13 @@ impl ProcFSInode {
         return Ok(0);
     }
 
+    fn open_self(&self, _pdata: &mut ProcfsFilePrivateData) -> Result<i64, SystemError> {
+        let pid = ProcessManager::current_pid().data();
+        return Ok(pid.to_string().as_bytes().len() as _);
+    }
+
     // 读取exe文件
-    fn read_link(&self, buf: &mut [u8]) -> Result<usize, SystemError> {
+    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) {
@@ -320,6 +333,31 @@ impl ProcFSInode {
         Ok(len)
     }
 
+    /// read current task pid dynamically
+    fn read_self_link(&self, buf: &mut [u8]) -> Result<usize, SystemError> {
+        let pid = ProcessManager::current_pid().data();
+        let pid_bytes = pid.to_string();
+        let len = pid_bytes.len().min(buf.len());
+        buf[..len].copy_from_slice(&pid_bytes.as_bytes()[..len]);
+        Ok(len)
+    }
+
+    fn read_fd_link(&self, buf: &mut [u8]) -> Result<usize, SystemError> {
+        let fd = self.fdata.fd;
+        let fd_table = ProcessManager::current_pcb().fd_table();
+        let fd_table = fd_table.read();
+        let file = fd_table.get_file_by_fd(fd);
+        if let Some(file) = file {
+            let inode = file.inode();
+            let path = inode.absolute_path().unwrap();
+            let len = path.len().min(buf.len());
+            buf[..len].copy_from_slice(&path.as_bytes()[..len]);
+            Ok(len)
+        } else {
+            return Err(SystemError::EBADF);
+        }
+    }
+
     /// proc文件系统读取函数
     fn proc_read(
         &self,
@@ -402,6 +440,7 @@ impl ProcFS {
                 fdata: InodeInfo {
                     pid: RawPid::new(0),
                     ftype: ProcFileType::Default,
+                    fd: -1,
                 },
                 dname: DName::default(),
             })));
@@ -421,34 +460,31 @@ impl ProcFS {
 
         // 创建meminfo文件
         let inode = result.root_inode();
-        let binding = inode.create(
-            "meminfo",
-            FileType::File,
-            ModeType::from_bits_truncate(0o444),
-        );
-        if let Ok(meminfo) = binding {
-            let meminfo_file = meminfo
-                .as_any_ref()
-                .downcast_ref::<LockedProcFSInode>()
-                .unwrap();
-            meminfo_file.0.lock().fdata.pid = RawPid::new(0);
-            meminfo_file.0.lock().fdata.ftype = ProcFileType::ProcMeminfo;
-        } else {
-            panic!("create meminfo error");
-        }
+        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>()
+            .unwrap();
+        meminfo_file.0.lock().fdata.pid = RawPid::new(0);
+        meminfo_file.0.lock().fdata.ftype = ProcFileType::ProcMeminfo;
 
         // 创建kmsg文件
-        let binding = inode.create("kmsg", FileType::File, ModeType::from_bits_truncate(0o444));
-        if let Ok(kmsg) = binding {
-            let kmsg_file = kmsg
-                .as_any_ref()
-                .downcast_ref::<LockedProcFSInode>()
-                .unwrap();
-            kmsg_file.0.lock().fdata.pid = RawPid::new(1);
-            kmsg_file.0.lock().fdata.ftype = ProcFileType::ProcKmsg;
-        } else {
-            panic!("create ksmg error");
-        }
+        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>()
+            .unwrap();
+        kmsg_file.0.lock().fdata.pid = RawPid::new(1);
+        kmsg_file.0.lock().fdata.ftype = ProcFileType::ProcKmsg;
+
         // 这个文件是用来欺骗Aya框架识别内核版本
         /* On Ubuntu LINUX_VERSION_CODE doesn't correspond to info.release,
          * but Ubuntu provides /proc/version_signature file, as described at
@@ -460,36 +496,30 @@ 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 binding = inode.create("version_signature", FileType::File, ModeType::S_IRUGO);
-        if let Ok(version_signature) = binding {
-            let version_signature = version_signature
-                .as_any_ref()
-                .downcast_ref::<LockedProcFSInode>()
-                .unwrap();
-            version_signature.0.lock().fdata.ftype = ProcFileType::Default;
-            version_signature.0.lock().data = "DragonOS 6.0.0-generic 6.0.0\n"
-                .to_string()
-                .as_bytes()
-                .to_vec();
-        } else {
-            panic!("create version_signature error");
-        }
-
-        let self_dir = inode
-            .create("self", FileType::Dir, ModeType::from_bits_truncate(0o555))
+        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>()
             .unwrap();
-
-        let binding = self_dir.create("exe", FileType::SymLink, ModeType::S_IRUGO);
-        if let Ok(exe) = binding {
-            let exe_file = exe
-                .as_any_ref()
-                .downcast_ref::<LockedProcFSInode>()
-                .unwrap();
-            exe_file.0.lock().fdata.pid = RawPid::new(0);
-            exe_file.0.lock().fdata.ftype = ProcFileType::ProcExe;
-        } else {
-            panic!("create exe error");
-        }
+        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();
+
+        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>()
+            .unwrap();
+        self_file.0.lock().fdata.pid = RawPid::new(2);
+        self_file.0.lock().fdata.ftype = ProcFileType::ProcSelf;
 
         return result;
     }
@@ -498,16 +528,16 @@ impl ProcFS {
     /// @usage 在进程中调用并创建进程对应文件
     pub fn register_pid(&self, pid: RawPid) -> Result<(), SystemError> {
         // 获取当前inode
-        let inode: Arc<dyn IndexNode> = self.root_inode();
+        let inode = self.root_inode();
         // 创建对应进程文件夹
-        let pid_dir: Arc<dyn IndexNode> = inode.create(
+        let pid_dir = inode.create(
             &pid.to_string(),
             FileType::Dir,
             ModeType::from_bits_truncate(0o555),
         )?;
         // 创建相关文件
         // status文件
-        let status_binding: Arc<dyn IndexNode> = pid_dir.create(
+        let status_binding = pid_dir.create(
             "status",
             FileType::File,
             ModeType::from_bits_truncate(0o444),
@@ -520,7 +550,7 @@ impl ProcFS {
         status_file.0.lock().fdata.ftype = ProcFileType::ProcStatus;
 
         // exe文件
-        let exe_binding: Arc<dyn IndexNode> = pid_dir.create_with_data(
+        let exe_binding = pid_dir.create_with_data(
             "exe",
             FileType::SymLink,
             ModeType::from_bits_truncate(0o444),
@@ -533,6 +563,10 @@ impl ProcFS {
         exe_file.0.lock().fdata.pid = pid;
         exe_file.0.lock().fdata.ftype = ProcFileType::ProcExe;
 
+        // fd dir
+        let fd = pid_dir.create("fd", FileType::Dir, ModeType::from_bits_truncate(0o555))?;
+        let fd = fd.as_any_ref().downcast_ref::<LockedProcFSInode>().unwrap();
+        fd.0.lock().fdata.ftype = ProcFileType::ProcFdDir;
         //todo: 创建其他文件
 
         return Ok(());
@@ -548,6 +582,7 @@ impl ProcFS {
         // 删除进程文件夹下文件
         pid_dir.unlink("status")?;
         pid_dir.unlink("exe")?;
+        pid_dir.rmdir("fd")?;
 
         // 查看进程文件是否还存在
         // let pf= pid_dir.find("status").expect("Cannot find status");
@@ -559,6 +594,43 @@ impl ProcFS {
     }
 }
 
+impl LockedProcFSInode {
+    fn dynamical_find_fd(&self, fd: &str) -> Result<Arc<dyn IndexNode>, SystemError> {
+        // ::log::info!("ProcFS: Dynamically opening fd files for current process.");
+        let fd = fd.parse::<i32>().map_err(|_| SystemError::EINVAL)?;
+        let pcb = ProcessManager::current_pcb();
+        let fd_table = pcb.fd_table();
+        let fd_table = fd_table.read();
+        let file = fd_table.get_file_by_fd(fd);
+        if file.is_some() {
+            let _ = self.unlink(&fd.to_string());
+            let fd_file = self.create(
+                &fd.to_string(),
+                FileType::SymLink,
+                ModeType::from_bits_truncate(0o444),
+            )?;
+            let fd_file_proc = fd_file
+                .as_any_ref()
+                .downcast_ref::<LockedProcFSInode>()
+                .unwrap();
+            fd_file_proc.0.lock().fdata.fd = fd;
+            fd_file_proc.0.lock().fdata.ftype = ProcFileType::ProcFdFile;
+            return Ok(fd_file);
+        } else {
+            return Err(SystemError::ENOENT);
+        }
+    }
+
+    fn dynamical_list_fd(&self) -> Result<Vec<String>, SystemError> {
+        // ::log::info!("ProcFS: Dynamically listing fd files for current process");
+        let pcb = ProcessManager::current_pcb();
+        let fd_table = pcb.fd_table();
+        let fd_table = fd_table.read();
+        let res = fd_table.iter().map(|(fd, _)| fd.to_string()).collect();
+        return Ok(res);
+    }
+}
+
 impl IndexNode for LockedProcFSInode {
     fn open(
         &self,
@@ -567,6 +639,7 @@ impl IndexNode for LockedProcFSInode {
     ) -> Result<(), SystemError> {
         // 加锁
         let mut inode: SpinLockGuard<ProcFSInode> = self.0.lock();
+        let proc_ty = inode.fdata.ftype;
 
         // 如果inode类型为文件夹，则直接返回成功
         if let FileType::Dir = inode.metadata.file_type {
@@ -574,22 +647,36 @@ impl IndexNode for LockedProcFSInode {
         }
         let mut private_data = ProcfsFilePrivateData::new();
         // 根据文件类型获取相应数据
-        let file_size = match inode.fdata.ftype {
+        let file_size = match proc_ty {
             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::Default => inode.data.len() as i64,
-            _ => {
-                todo!()
-            }
+            ProcFileType::ProcSelf => inode.open_self(&mut private_data)?,
+            _ => 0,
         };
         *data = FilePrivateData::Procfs(private_data);
         // 更新metadata里面的文件大小数值
         inode.metadata.size = file_size;
+        drop(inode);
+        return Ok(());
+    }
 
+    fn rmdir(&self, name: &str) -> Result<(), SystemError> {
+        let mut guard = self.0.lock();
+        if guard.metadata.file_type != FileType::Dir {
+            return Err(SystemError::ENOTDIR);
+        }
+        let name = DName::from(name);
+        guard.children.remove(&name);
         return Ok(());
     }
 
+    fn parent(&self) -> Result<Arc<dyn IndexNode>, SystemError> {
+        let parent = self.0.lock().parent.upgrade().ok_or(SystemError::ENOENT)?;
+        return Ok(parent as Arc<dyn IndexNode>);
+    }
+
     fn close(&self, mut data: SpinLockGuard<FilePrivateData>) -> Result<(), SystemError> {
         let guard: SpinLockGuard<ProcFSInode> = self.0.lock();
         // 如果inode类型为文件夹，则直接返回成功
@@ -613,32 +700,29 @@ impl IndexNode for LockedProcFSInode {
             return Err(SystemError::EINVAL);
         }
         // 加锁
-        let inode: SpinLockGuard<ProcFSInode> = self.0.lock();
+        let inode = self.0.lock();
 
         // 检查当前inode是否为一个文件夹，如果是的话，就返回错误
         if inode.metadata.file_type == FileType::Dir {
             return Err(SystemError::EISDIR);
         }
 
-        // 获取数据信息
-        let mut private_data = match &*data {
-            FilePrivateData::Procfs(p) => p.clone(),
-            _ => {
-                panic!("ProcFS: FilePrivateData mismatch!");
-            }
-        };
-
         // 根据文件类型读取相应数据
         match inode.fdata.ftype {
-            ProcFileType::ProcStatus => {
-                return inode.proc_read(offset, len, buf, &mut private_data)
-            }
-            ProcFileType::ProcMeminfo => {
-                return inode.proc_read(offset, len, buf, &mut private_data)
+            ProcFileType::ProcStatus | ProcFileType::ProcMeminfo => {
+                // 获取数据信息
+                let mut private_data = match &*data {
+                    FilePrivateData::Procfs(p) => p.clone(),
+                    _ => {
+                        panic!("ProcFS: FilePrivateData mismatch!");
+                    }
+                };
+                return inode.proc_read(offset, len, buf, &mut private_data);
             }
-            ProcFileType::ProcExe => return inode.read_link(buf),
-            ProcFileType::ProcKmsg => (),
-            ProcFileType::Default => (),
+            ProcFileType::ProcExe => return inode.read_exe_link(buf),
+            ProcFileType::ProcSelf => return inode.read_self_link(buf),
+            ProcFileType::ProcFdFile => return inode.read_fd_link(buf),
+            _ => (),
         };
 
         // 默认读取
@@ -677,7 +761,6 @@ impl IndexNode for LockedProcFSInode {
     fn metadata(&self) -> Result<Metadata, SystemError> {
         let inode = self.0.lock();
         let metadata = inode.metadata.clone();
-
         return Ok(metadata);
     }
 
@@ -751,6 +834,7 @@ impl IndexNode for LockedProcFSInode {
                 fdata: InodeInfo {
                     pid: RawPid::new(0),
                     ftype: ProcFileType::Default,
+                    fd: -1,
                 },
                 dname: name.clone(),
             })));
@@ -829,23 +913,32 @@ impl IndexNode for LockedProcFSInode {
     }
 
     fn find(&self, name: &str) -> Result<Arc<dyn IndexNode>, SystemError> {
-        let inode = self.0.lock();
-
-        if inode.metadata.file_type != FileType::Dir {
+        if self.0.lock().metadata.file_type != FileType::Dir {
             return Err(SystemError::ENOTDIR);
         }
 
         match name {
             "" | "." => {
-                return Ok(inode.self_ref.upgrade().ok_or(SystemError::ENOENT)?);
+                return Ok(self
+                    .0
+                    .lock()
+                    .self_ref
+                    .upgrade()
+                    .ok_or(SystemError::ENOENT)?);
             }
 
             ".." => {
-                return Ok(inode.parent.upgrade().ok_or(SystemError::ENOENT)?);
+                return Ok(self.0.lock().parent.upgrade().ok_or(SystemError::ENOENT)?);
             }
+
             name => {
+                if self.0.lock().fdata.ftype == ProcFileType::ProcFdDir {
+                    return self.dynamical_find_fd(name);
+                }
                 // 在子目录项中查找
-                return Ok(inode
+                return Ok(self
+                    .0
+                    .lock()
                     .children
                     .get(&DName::from(name))
                     .ok_or(SystemError::ENOENT)?
@@ -897,9 +990,14 @@ impl IndexNode for LockedProcFSInode {
             return Err(SystemError::ENOTDIR);
         }
 
-        let mut keys: Vec<String> = Vec::new();
+        let mut keys = Vec::new();
         keys.push(String::from("."));
         keys.push(String::from(".."));
+
+        if self.0.lock().fdata.ftype == ProcFileType::ProcFdDir {
+            return self.dynamical_list_fd();
+        }
+
         keys.append(
             &mut self
                 .0

kernel/src/filesystem/vfs/file.rs

@@ -145,16 +145,18 @@ impl File {
             }
         }
 
+        let private_data = SpinLock::new(FilePrivateData::default());
+        inode.open(private_data.lock(), &mode)?;
+
         let f = File {
             inode,
             offset: AtomicUsize::new(0),
             mode: RwLock::new(mode),
             file_type,
             readdir_subdirs_name: SpinLock::new(Vec::default()),
-            private_data: SpinLock::new(FilePrivateData::default()),
+            private_data,
             cred: ProcessManager::current_pcb().cred(),
         };
-        f.inode.open(f.private_data.lock(), &mode)?;
 
         return Ok(f);
     }

kernel/src/filesystem/vfs/mod.rs

@@ -529,25 +529,17 @@ pub trait IndexNode: Any + Sync + Send + Debug + CastFromSync {
         return Err(SystemError::ENOSYS);
     }
 
-    /// # absolute_path 获取目录项绝对路径
+    /// Returns the absolute path of the inode.
     ///
-    /// ## 参数
-    ///
-    /// 无
-    ///
-    /// ## 返回值
-    ///
-    /// - Ok(String): 路径
-    /// - Err(SystemError): 文件系统不支持dname parent api
+    /// This function only works for `MountFS` and should not be implemented by other file systems.
+    /// The performance of this function is O(n) for path queries, and it is extremely
+    /// inefficient in file systems that do not implement DName caching.
     ///
-    /// ## Behavior
+    /// **WARNING**
     ///
-    /// 该函数只能被MountFS实现，其他文件系统不应实现这个函数
+    /// For special inodes(e.g., sockets,pipes, etc.), this function will
+    /// return an special name according to the inode type directly.
     ///
-    /// # Performance
-    ///
-    /// 这是一个O(n)的路径查询，并且在未实现DName缓存的文件系统中，性能极差；
-    /// 即使实现了DName也尽量不要用。
     fn absolute_path(&self) -> Result<String, SystemError> {
         return Err(SystemError::ENOSYS);
     }
@@ -774,7 +766,7 @@ impl dyn IndexNode {
             if file_type == FileType::SymLink && max_follow_times > 0 {
                 let mut content = [0u8; 256];
                 // 读取符号链接
-
+                // TODO:We need to clarify which interfaces require private data and which do not
                 let len = inode.read_at(
                     0,
                     256,

kernel/src/filesystem/vfs/mount.rs

@@ -66,7 +66,7 @@ pub struct MountFS {
     /// 用来存储InodeID->挂载点的MountFS的B树
     mountpoints: SpinLock<BTreeMap<InodeId, Arc<MountFS>>>,
     /// 当前文件系统挂载到的那个挂载点的Inode
-    self_mountpoint: Option<Arc<MountFSInode>>,
+    self_mountpoint: RwLock<Option<Arc<MountFSInode>>>,
     /// 指向当前MountFS的弱引用
     self_ref: Weak<MountFS>,
 
@@ -105,7 +105,7 @@ impl MountFS {
         let result = Arc::new_cyclic(|self_ref| MountFS {
             inner_filesystem,
             mountpoints: SpinLock::new(BTreeMap::new()),
-            self_mountpoint,
+            self_mountpoint: RwLock::new(self_mountpoint),
             self_ref: self_ref.clone(),
             namespace: Lazy::new(),
             propagation,
@@ -127,6 +127,11 @@ impl MountFS {
         self.namespace.init(namespace);
     }
 
+    #[inline(never)]
+    pub fn self_mountpoint(&self) -> Option<Arc<MountFSInode>> {
+        self.self_mountpoint.read().as_ref().cloned()
+    }
+
     /// @brief 用Arc指针包裹MountFS对象。
     /// 本函数的主要功能为，初始化MountFS对象中的自引用Weak指针
     /// 本函数只应在构造器中被调用
@@ -168,10 +173,14 @@ impl MountFS {
     /// # Errors
     /// 如果当前文件系统是根文件系统，那么将会返回`EINVAL`
     pub fn umount(&self) -> Result<Arc<MountFS>, SystemError> {
-        self.self_mountpoint
-            .as_ref()
+        let r = self
+            .self_mountpoint()
             .ok_or(SystemError::EINVAL)?
-            .do_umount()
+            .do_umount();
+
+        self.self_mountpoint.write().take();
+
+        return r;
     }
 }
 
@@ -244,7 +253,7 @@ impl MountFSInode {
     pub(super) fn do_parent(&self) -> Result<Arc<MountFSInode>, SystemError> {
         if self.is_mountpoint_root()? {
             // 当前inode是它所在的文件系统的root inode
-            match &self.mount_fs.self_mountpoint {
+            match self.mount_fs.self_mountpoint() {
                 Some(inode) => {
                     let inner_inode = inode.parent()?;
                     return Ok(Arc::new_cyclic(|self_ref| MountFSInode {
@@ -282,8 +291,14 @@ impl MountFSInode {
     }
 
     fn do_absolute_path(&self) -> Result<String, SystemError> {
-        let mut path_parts = Vec::new();
         let mut current = self.self_ref.upgrade().unwrap();
+
+        // For special inode, we can directly get the absolute path
+        if let Ok(p) = current.inner_inode.absolute_path() {
+            return Ok(p);
+        }
+
+        let mut path_parts = Vec::new();
         let root_inode = ProcessManager::current_mntns().root_inode();
         let inode_id = root_inode.metadata()?.inode_id;
         while current.metadata()?.inode_id != inode_id {
@@ -318,7 +333,7 @@ impl IndexNode for MountFSInode {
     }
 
     fn close(&self, data: SpinLockGuard<FilePrivateData>) -> Result<(), SystemError> {
-        return self.inner_inode.close(data);
+        self.inner_inode.close(data)
     }
 
     fn create_with_data(
@@ -559,9 +574,11 @@ impl IndexNode for MountFSInode {
             .mountpoints
             .lock()
             .insert(metadata.inode_id, new_mount_fs.clone());
-
-        // MOUNT_LIST().remove(from.absolute_path()?);
-        // MOUNT_LIST().insert(self.absolute_path()?, new_mount_fs.clone());
+        // 更新当前挂载点的self_mountpoint
+        new_mount_fs
+            .self_mountpoint
+            .write()
+            .replace(self.self_ref.upgrade().unwrap());
         return Ok(new_mount_fs);
     }
 
@@ -602,7 +619,7 @@ impl IndexNode for MountFSInode {
     /// 在默认情况下，性能非常差！！！
     fn dname(&self) -> Result<DName, SystemError> {
         if self.is_mountpoint_root()? {
-            if let Some(inode) = &self.mount_fs.self_mountpoint {
+            if let Some(inode) = self.mount_fs.self_mountpoint() {
                 return inode.inner_inode.dname();
             }
         }
@@ -632,7 +649,7 @@ impl IndexNode for MountFSInode {
 
 impl FileSystem for MountFS {
     fn root_inode(&self) -> Arc<dyn IndexNode> {
-        match &self.self_mountpoint {
+        match self.self_mountpoint() {
             Some(inode) => return inode.mount_fs.root_inode(),
             // 当前文件系统是rootfs
             None => self.mountpoint_root_inode(),

kernel/src/filesystem/vfs/open.rs

@@ -171,14 +171,8 @@ fn do_sys_openat2(
     let path = path.trim();
 
     let (inode_begin, path) = user_path_at(&ProcessManager::current_pcb(), dirfd, path)?;
-    let inode: Result<Arc<dyn IndexNode>, SystemError> = inode_begin.lookup_follow_symlink(
-        &path,
-        if follow_symlink {
-            VFS_MAX_FOLLOW_SYMLINK_TIMES
-        } else {
-            0
-        },
-    );
+    let inode =
+        inode_begin.lookup_follow_symlink2(&path, VFS_MAX_FOLLOW_SYMLINK_TIMES, follow_symlink);
 
     let root_inode = ProcessManager::current_mntns().root_inode();
     let inode: Arc<dyn IndexNode> = match inode {

kernel/src/filesystem/vfs/vcore.rs

@@ -9,6 +9,7 @@ use crate::{
     driver::base::block::{gendisk::GenDisk, manager::block_dev_manager},
     filesystem::{
         devfs::devfs_init,
+        devpts::devpts_init,
         fat::fs::FATFileSystem,
         procfs::procfs_init,
         sysfs::sysfs_init,
@@ -95,6 +96,9 @@ fn migrate_virtual_filesystem(new_fs: Arc<dyn FileSystem>) -> Result<(), SystemE
         current_mntns.force_change_root_mountfs(new_fs);
     }
 
+    // WARNING: mount devpts after devfs has been mounted,
+    devpts_init().expect("Failed to initialize devpts");
+
     info!("VFS: Migrate filesystems done!");
 
     return Ok(());

kernel/src/init/initial_kthread.rs

@@ -45,6 +45,11 @@ fn kernel_init() -> Result<(), SystemError> {
         .ok();
 
     mount_root_fs().expect("Failed to mount root fs");
+
+    // WARNING: We must keep `mount_root_fs` before stdio_init,
+    // because `migrate_virtual_filesystem` will change the root directory of the file system.
+    stdio_init().expect("Failed to initialize stdio");
+
     e1000e_init();
     net_init().unwrap_or_else(|err| {
         error!("Failed to initialize network: {:?}", err);
@@ -60,9 +65,7 @@ fn kenrel_init_freeable() -> Result<(), SystemError> {
     do_initcalls().unwrap_or_else(|err| {
         panic!("Failed to initialize subsystems: {:?}", err);
     });
-    stdio_init().expect("Failed to initialize stdio");
     smp_init();
-
     return Ok(());
 }
 

kernel/src/ipc/pipe.rs

@@ -1,5 +1,3 @@
-use core::sync::atomic::compiler_fence;
-
 use crate::{
     arch::ipc::signal::{SigCode, Signal},
     filesystem::{
@@ -17,6 +15,8 @@ use crate::{
     sched::SchedMode,
     time::PosixTimeSpec,
 };
+use alloc::string::String;
+use core::sync::atomic::compiler_fence;
 
 use alloc::{
     collections::LinkedList,
@@ -513,4 +513,8 @@ impl IndexNode for LockedPipeInode {
     fn as_pollable_inode(&self) -> Result<&dyn PollableInode, SystemError> {
         Ok(self)
     }
+
+    fn absolute_path(&self) -> Result<String, SystemError> {
+        Ok(String::from("pipe"))
+    }
 }

kernel/src/net/socket/mod.rs

@@ -405,6 +405,10 @@ impl IndexNode for SocketInode {
     fn as_pollable_inode(&self) -> Result<&dyn PollableInode, SystemError> {
         Ok(self)
     }
+
+    fn absolute_path(&self) -> Result<String, SystemError> {
+        Ok(String::from("socket"))
+    }
 }
 
 #[derive(Debug)]

kernel/src/perf/bpf.rs

@@ -322,6 +322,10 @@ impl IndexNode for BpfPerfEvent {
     fn page_cache(&self) -> Option<Arc<PageCache>> {
         Some(self.data.lock().page_cache.clone())
     }
+
+    fn absolute_path(&self) -> core::result::Result<String, SystemError> {
+        Ok(String::from("bpf_perf_event"))
+    }
 }
 
 impl PerfEventOps for BpfPerfEvent {

kernel/src/perf/kprobe.rs

@@ -134,6 +134,10 @@ impl IndexNode for KprobePerfEvent {
     fn page_cache(&self) -> Option<Arc<PageCache>> {
         None
     }
+
+    fn absolute_path(&self) -> core::result::Result<String, SystemError> {
+        Ok(String::from("kprobe_perf_event"))
+    }
 }
 
 impl PerfEventOps for KprobePerfEvent {

kernel/src/perf/mod.rs

@@ -282,6 +282,10 @@ impl IndexNode for PerfEventInode {
     fn as_pollable_inode(&self) -> Result<&dyn PollableInode> {
         Ok(self)
     }
+
+    fn absolute_path(&self) -> core::result::Result<String, SystemError> {
+        Ok(String::from("perf_event"))
+    }
 }
 
 impl PollableInode for PerfEventInode {

kernel/src/perf/tracepoint.rs

@@ -73,6 +73,14 @@ impl IndexNode for TracepointPerfEvent {
     fn page_cache(&self) -> Option<Arc<PageCache>> {
         None
     }
+
+    fn absolute_path(&self) -> core::result::Result<String, SystemError> {
+        Ok(format!(
+            "tracepoint: {}:{}",
+            self.tp.system(),
+            self.tp.name()
+        ))
+    }
 }
 
 pub struct TracePointPerfCallBack(BasicPerfEbpfCallBack);

kernel/src/virt/vm/kvm_dev.rs

@@ -35,6 +35,7 @@ pub struct KvmInode {
     self_ref: Weak<LockedKvmInode>,
     /// 指向inode所在的文件系统对象的指针
     fs: Weak<DevFS>,
+    parent: Weak<crate::filesystem::devfs::LockedDevFSInode>,
     /// INode 元数据
     metadata: Metadata,
 }
@@ -52,6 +53,7 @@ impl LockedKvmInode {
         let inode = KvmInode {
             self_ref: Weak::default(),
             fs: Weak::default(),
+            parent: Weak::default(),
             metadata: Metadata {
                 dev_id: 1,
                 inode_id: generate_inode_id(),
@@ -96,6 +98,10 @@ impl DeviceINode for LockedKvmInode {
     fn set_fs(&self, fs: Weak<DevFS>) {
         self.inner.lock().fs = fs;
     }
+
+    fn set_parent(&self, parent: Weak<crate::filesystem::devfs::LockedDevFSInode>) {
+        self.inner.lock().parent = parent;
+    }
 }
 
 impl IndexNode for LockedKvmInode {
@@ -179,6 +185,14 @@ impl IndexNode for LockedKvmInode {
     ) -> Result<(), SystemError> {
         Ok(())
     }
+
+    fn parent(&self) -> Result<Arc<dyn IndexNode>, SystemError> {
+        let parent = self.inner.lock().parent.upgrade();
+        if let Some(parent) = parent {
+            return Ok(parent);
+        }
+        Err(SystemError::ENOENT)
+    }
 }
 
 #[derive(Debug)]