feat: add inode number in vfsattr

crates/axfs_devfs/src/dir.rs

@@ -13,20 +13,30 @@ use axfs_vfs::{RelPath, VfsDirEntry, VfsNodeAttr, VfsNodeOps, VfsNodeRef, VfsNod
 use axfs_vfs::{VfsError, VfsResult};
 use spin::RwLock;
 
+use crate::InoAllocator;
+
 /// The directory node in the device filesystem.
 ///
 /// It implements [`axfs_vfs::VfsNodeOps`].
 pub struct DirNode {
+    ino: u64,
     parent: RwLock<Weak<dyn VfsNodeOps>>,
     children: RwLock<BTreeMap<&'static str, VfsNodeRef>>,
+    ialloc: Weak<InoAllocator>,
 }
 
 impl DirNode {
-    pub(super) fn new(parent: Option<&VfsNodeRef>) -> Arc<Self> {
+    pub(super) fn new(
+        ino: u64,
+        parent: Option<&VfsNodeRef>,
+        ialloc: Weak<InoAllocator>,
+    ) -> Arc<Self> {
         let parent = parent.map_or(Weak::<Self>::new() as _, Arc::downgrade);
         Arc::new(Self {
+            ino,
             parent: RwLock::new(parent),
             children: RwLock::new(BTreeMap::new()),
+            ialloc,
         })
     }
 
@@ -37,7 +47,11 @@ impl DirNode {
     /// Create a subdirectory at this directory.
     pub fn mkdir(self: &Arc<Self>, name: &'static str) -> Arc<Self> {
         let parent = self.clone() as VfsNodeRef;
-        let node = Self::new(Some(&parent));
+        let node = Self::new(
+            self.ialloc.upgrade().unwrap().alloc(),
+            Some(&parent),
+            self.ialloc.clone(),
+        );
         self.children.write().insert(name, node.clone());
         node
     }
@@ -50,7 +64,7 @@ impl DirNode {
 
 impl VfsNodeOps for DirNode {
     fn get_attr(&self) -> VfsResult<VfsNodeAttr> {
-        Ok(VfsNodeAttr::new_dir(4096, 0))
+        Ok(VfsNodeAttr::new_dir(self.ino, 4096, 0))
     }
 
     fn parent(&self) -> Option<VfsNodeRef> {

crates/axfs_devfs/src/lib.rs

@@ -30,20 +30,44 @@ pub use self::zero::ZeroDev;
 
 use alloc::sync::Arc;
 use axfs_vfs::{AbsPath, VfsNodeRef, VfsOps, VfsResult};
+use core::sync::atomic::AtomicU64;
 use spin::once::Once;
 
+/// An auto-increasing inode number allocator.
+pub struct InoAllocator {
+    current: AtomicU64,
+}
+
+impl InoAllocator {
+    /// Create a new allocator instance.
+    pub fn new(start: u64) -> Self {
+        Self {
+            current: AtomicU64::new(start),
+        }
+    }
+
+    /// Allocate a new inode number.
+    pub fn alloc(&self) -> u64 {
+        self.current
+            .fetch_add(1, core::sync::atomic::Ordering::SeqCst)
+    }
+}
+
 /// A device filesystem that implements [`axfs_vfs::VfsOps`].
 pub struct DeviceFileSystem {
     parent: Once<VfsNodeRef>,
     root: Arc<DirNode>,
+    _ialloc: Arc<InoAllocator>,
 }
 
 impl DeviceFileSystem {
     /// Create a new instance.
     pub fn new() -> Self {
+        let ialloc = Arc::new(InoAllocator::new(10));
         Self {
             parent: Once::new(),
-            root: DirNode::new(None),
+            root: DirNode::new(2, None, Arc::downgrade(&ialloc)),
+            _ialloc: ialloc,
         }
     }
 

crates/axfs_devfs/src/null.rs

@@ -17,6 +17,7 @@ pub struct NullDev;
 impl VfsNodeOps for NullDev {
     fn get_attr(&self) -> VfsResult<VfsNodeAttr> {
         Ok(VfsNodeAttr::new(
+            3,
             VfsNodePerm::default_file(),
             VfsNodeType::CharDevice,
             0,

crates/axfs_devfs/src/random.rs

@@ -30,6 +30,7 @@ fn rand_lcg32() -> u32 {
 impl VfsNodeOps for RandomDev {
     fn get_attr(&self) -> VfsResult<VfsNodeAttr> {
         Ok(VfsNodeAttr::new(
+            6,
             VfsNodePerm::default_file(),
             VfsNodeType::CharDevice,
             0,

crates/axfs_devfs/src/zero.rs

@@ -17,6 +17,7 @@ pub struct ZeroDev;
 impl VfsNodeOps for ZeroDev {
     fn get_attr(&self) -> VfsResult<VfsNodeAttr> {
         Ok(VfsNodeAttr::new(
+            4,
             VfsNodePerm::default_file(),
             VfsNodeType::CharDevice,
             0,

crates/axfs_ramfs/src/dir.rs

@@ -16,22 +16,31 @@ use axfs_vfs::{VfsError, VfsResult};
 use spin::rwlock::RwLock;
 
 use crate::file::FileNode;
+use crate::InoAllocator;
 
 /// The directory node in the RAM filesystem.
 ///
 /// It implements [`axfs_vfs::VfsNodeOps`].
 pub struct DirNode {
+    ino: u64,
     this: Weak<DirNode>,
     parent: RwLock<Weak<dyn VfsNodeOps>>,
     children: RwLock<BTreeMap<String, VfsNodeRef>>,
+    ialloc: Weak<InoAllocator>,
 }
 
 impl DirNode {
-    pub(super) fn new(parent: Option<Weak<dyn VfsNodeOps>>) -> Arc<Self> {
+    pub(super) fn new(
+        ino: u64,
+        parent: Option<Weak<dyn VfsNodeOps>>,
+        ialloc: Weak<InoAllocator>,
+    ) -> Arc<Self> {
         Arc::new_cyclic(|this| Self {
+            ino,
             this: this.clone(),
             parent: RwLock::new(parent.unwrap_or_else(|| Weak::<Self>::new())),
             children: RwLock::new(BTreeMap::new()),
+            ialloc,
         })
     }
 
@@ -56,8 +65,12 @@ impl DirNode {
             return Err(VfsError::AlreadyExists);
         }
         let node: VfsNodeRef = match ty {
-            VfsNodeType::File => Arc::new(FileNode::new()),
-            VfsNodeType::Dir => Self::new(Some(self.this.clone())),
+            VfsNodeType::File => Arc::new(FileNode::new(self.ialloc.upgrade().unwrap().alloc())),
+            VfsNodeType::Dir => Self::new(
+                self.ialloc.upgrade().unwrap().alloc(),
+                Some(self.this.clone()),
+                self.ialloc.clone(),
+            ),
             _ => return Err(VfsError::Unsupported),
         };
         self.children.write().insert(name.into(), node);
@@ -80,7 +93,7 @@ impl DirNode {
 
 impl VfsNodeOps for DirNode {
     fn get_attr(&self) -> VfsResult<VfsNodeAttr> {
-        Ok(VfsNodeAttr::new_dir(4096, 0))
+        Ok(VfsNodeAttr::new_dir(self.ino, 4096, 0))
     }
 
     fn parent(&self) -> Option<VfsNodeRef> {

crates/axfs_ramfs/src/file.rs

@@ -15,20 +15,26 @@ use spin::rwlock::RwLock;
 ///
 /// It implements [`axfs_vfs::VfsNodeOps`].
 pub struct FileNode {
+    ino: u64,
     content: RwLock<Vec<u8>>,
 }
 
 impl FileNode {
-    pub(super) const fn new() -> Self {
+    pub(super) const fn new(ino: u64) -> Self {
         Self {
+            ino,
             content: RwLock::new(Vec::new()),
         }
     }
 }
 
 impl VfsNodeOps for FileNode {
     fn get_attr(&self) -> VfsResult<VfsNodeAttr> {
-        Ok(VfsNodeAttr::new_file(self.content.read().len() as _, 0))
+        Ok(VfsNodeAttr::new_file(
+            self.ino,
+            self.content.read().len() as _,
+            0,
+        ))
     }
 
     fn truncate(&self, size: u64) -> VfsResult {

crates/axfs_ramfs/src/lib.rs

@@ -26,20 +26,44 @@ pub use self::file::FileNode;
 
 use alloc::sync::Arc;
 use axfs_vfs::{AbsPath, VfsNodeRef, VfsOps, VfsResult};
+use core::sync::atomic::AtomicU64;
 use spin::once::Once;
 
+/// An auto-increasing inode number allocator.
+pub struct InoAllocator {
+    current: AtomicU64,
+}
+
+impl InoAllocator {
+    /// Create a new allocator instance.
+    pub fn new(start: u64) -> Self {
+        Self {
+            current: AtomicU64::new(start),
+        }
+    }
+
+    /// Allocate a new inode number.
+    pub fn alloc(&self) -> u64 {
+        self.current
+            .fetch_add(1, core::sync::atomic::Ordering::SeqCst)
+    }
+}
+
 /// A RAM filesystem that implements [`axfs_vfs::VfsOps`].
 pub struct RamFileSystem {
     parent: Once<VfsNodeRef>,
     root: Arc<DirNode>,
+    _ialloc: Arc<InoAllocator>,
 }
 
 impl RamFileSystem {
     /// Create a new instance.
     pub fn new() -> Self {
+        let ialloc = Arc::new(InoAllocator::new(0));
         Self {
             parent: Once::new(),
-            root: DirNode::new(None),
+            root: DirNode::new(ialloc.alloc(), None, Arc::downgrade(&ialloc)),
+            _ialloc: ialloc,
         }
     }
 

crates/axfs_vfs/src/structs.rs

@@ -17,6 +17,8 @@ pub struct FileSystemInfo;
 #[allow(dead_code)]
 #[derive(Debug, Clone, Copy)]
 pub struct VfsNodeAttr {
+    /// Inode number.
+    ino: u64,
     /// File permission mode.
     mode: VfsNodePerm,
     /// File type.
@@ -206,11 +208,11 @@ impl VfsNodeType {
 }
 
 impl VfsNodeAttr {
-    /// Creates a new `VfsNodeAttr` with the given permission mode, type, size
-    /// inode number and number of blocks.
-    /// if node number is none, means fs do not have inode then vfs will allocate it
-    pub fn new(mode: VfsNodePerm, ty: VfsNodeType, size: u64, blocks: u64) -> Self {
+    /// Creates a new `VfsNodeAttr` with the given inode number, permission mode, type, size
+    /// and number of blocks.
+    pub const fn new(ino: u64, mode: VfsNodePerm, ty: VfsNodeType, size: u64, blocks: u64) -> Self {
         Self {
+            ino,
             mode,
             ty,
             size,
@@ -219,8 +221,9 @@ impl VfsNodeAttr {
     }
 
     /// Creates a new `VfsNodeAttr` for a file, with the default file permission.
-    pub fn new_file(size: u64, blocks: u64) -> Self {
+    pub const fn new_file(ino: u64, size: u64, blocks: u64) -> Self {
         Self {
+            ino,
             mode: VfsNodePerm::default_file(),
             ty: VfsNodeType::File,
             size,
@@ -230,15 +233,20 @@ impl VfsNodeAttr {
 
     /// Creates a new `VfsNodeAttr` for a directory, with the default directory
     /// permission.
-    pub fn new_dir(size: u64, blocks: u64) -> Self {
+    pub const fn new_dir(ino: u64, size: u64, blocks: u64) -> Self {
         Self {
+            ino,
             mode: VfsNodePerm::default_dir(),
             ty: VfsNodeType::Dir,
             size,
             blocks,
         }
     }
 
+    /// Returns the inode number of the node.
+    pub const fn ino(&self) -> u64 {
+        self.ino
+    }
     /// Returns the size of the node.
     pub const fn size(&self) -> u64 {
         self.size