style: cargo format all

api/ruxos_posix_api/src/imp/io_mpx/epoll.rs

@@ -22,8 +22,8 @@ use ruxfdtable::{FileLike, RuxStat};
 use ruxhal::time::current_time;
 
 use crate::{ctypes, imp::fs::flags_to_options};
-use ruxtask::fs::{add_file_like, get_file_like};
 use ruxfs::AbsPath;
+use ruxtask::fs::{add_file_like, get_file_like};
 
 pub struct EpollInstance {
     events: Mutex<BTreeMap<usize, ctypes::epoll_event>>,

api/ruxos_posix_api/src/imp/net.rs

@@ -11,7 +11,7 @@ use alloc::{sync::Arc, vec, vec::Vec};
 use core::ffi::{c_char, c_int, c_void};
 use core::mem::size_of;
 use core::net::{IpAddr, Ipv4Addr, SocketAddr, SocketAddrV4};
-use ruxfs::{AbsPath, fops};
+use ruxfs::{fops, AbsPath};
 
 use axerrno::{LinuxError, LinuxResult};
 use axio::PollState;

crates/axfs_devfs/src/tests.rs

@@ -21,7 +21,9 @@ fn test_devfs_ops(devfs: &DeviceFileSystem) -> VfsResult {
     assert!(root.get_attr()?.is_dir());
     assert_eq!(root.get_attr()?.file_type(), VfsNodeType::Dir);
     assert_eq!(
-        root.clone().lookup(&RelPath::new_canonicalized("urandom")).err(),
+        root.clone()
+            .lookup(&RelPath::new_canonicalized("urandom"))
+            .err(),
         Some(VfsError::NotFound)
     );
 
@@ -32,32 +34,46 @@ fn test_devfs_ops(devfs: &DeviceFileSystem) -> VfsResult {
     assert_eq!(node.read_at(0, &mut buf)?, 0);
     assert_eq!(buf, [1; N]);
     assert_eq!(node.write_at(N as _, &buf)?, N);
-    assert_eq!(node.lookup(&RelPath::new_canonicalized("/")).err(), Some(VfsError::NotADirectory));
+    assert_eq!(
+        node.lookup(&RelPath::new_canonicalized("/")).err(),
+        Some(VfsError::NotADirectory)
+    );
 
-    let node = devfs.root_dir().lookup(&RelPath::new_canonicalized(".///.//././/.////zero"))?;
+    let node = devfs
+        .root_dir()
+        .lookup(&RelPath::new_canonicalized(".///.//././/.////zero"))?;
     assert_eq!(node.get_attr()?.file_type(), VfsNodeType::CharDevice);
     assert!(!node.get_attr()?.is_dir());
     assert_eq!(node.get_attr()?.size(), 0);
     assert_eq!(node.read_at(10, &mut buf)?, N);
     assert_eq!(buf, [0; N]);
     assert_eq!(node.write_at(0, &buf)?, N);
 
-    let foo = devfs.root_dir().lookup(&RelPath::new_canonicalized(".///.//././/.////foo"))?;
+    let foo = devfs
+        .root_dir()
+        .lookup(&RelPath::new_canonicalized(".///.//././/.////foo"))?;
     assert!(foo.get_attr()?.is_dir());
     assert_eq!(
         foo.read_at(10, &mut buf).err(),
         Some(VfsError::IsADirectory)
     );
     assert!(Arc::ptr_eq(
         &foo.clone().lookup(&RelPath::new_canonicalized("/f2"))?,
-        &devfs.root_dir().lookup(&RelPath::new_canonicalized(".//./foo///f2"))?,
+        &devfs
+            .root_dir()
+            .lookup(&RelPath::new_canonicalized(".//./foo///f2"))?,
     ));
     assert_eq!(
-        foo.clone().lookup(&RelPath::new_canonicalized("/bar//f1"))?.get_attr()?.file_type(),
+        foo.clone()
+            .lookup(&RelPath::new_canonicalized("/bar//f1"))?
+            .get_attr()?
+            .file_type(),
         VfsNodeType::CharDevice
     );
     assert_eq!(
-        foo.lookup(&RelPath::new_canonicalized("/bar///"))?.get_attr()?.file_type(),
+        foo.lookup(&RelPath::new_canonicalized("/bar///"))?
+            .get_attr()?
+            .file_type(),
         VfsNodeType::Dir
     );
 
@@ -71,25 +87,43 @@ fn test_get_parent(devfs: &DeviceFileSystem) -> VfsResult {
     let node = root.clone().lookup(&RelPath::new_canonicalized("null"))?;
     assert!(node.parent().is_none());
 
-    let node = root.clone().lookup(&RelPath::new_canonicalized(".//foo/bar"))?;
+    let node = root
+        .clone()
+        .lookup(&RelPath::new_canonicalized(".//foo/bar"))?;
     assert!(node.parent().is_some());
     let parent = node.parent().unwrap();
-    assert!(Arc::ptr_eq(&parent, &root.clone().lookup(&RelPath::new_canonicalized("foo"))?));
+    assert!(Arc::ptr_eq(
+        &parent,
+        &root.clone().lookup(&RelPath::new_canonicalized("foo"))?
+    ));
     assert!(parent.lookup(&RelPath::new_canonicalized("bar")).is_ok());
 
     let node = root.clone().lookup(&RelPath::new_canonicalized("foo/.."))?;
-    assert!(Arc::ptr_eq(&node, &root.clone().lookup(&RelPath::new_canonicalized("."))?));
+    assert!(Arc::ptr_eq(
+        &node,
+        &root.clone().lookup(&RelPath::new_canonicalized("."))?
+    ));
 
     assert!(Arc::ptr_eq(
-        &root.clone().lookup(&RelPath::new_canonicalized("/foo/.."))?,
-        &devfs.root_dir().lookup(&RelPath::new_canonicalized(".//./foo/././bar/../.."))?,
+        &root
+            .clone()
+            .lookup(&RelPath::new_canonicalized("/foo/.."))?,
+        &devfs
+            .root_dir()
+            .lookup(&RelPath::new_canonicalized(".//./foo/././bar/../.."))?,
     ));
     assert!(Arc::ptr_eq(
-        &root.clone().lookup(&RelPath::new_canonicalized("././/foo//./../foo//bar///..//././"))?,
-        &devfs.root_dir().lookup(&RelPath::new_canonicalized(".//./foo/"))?,
+        &root.clone().lookup(&RelPath::new_canonicalized(
+            "././/foo//./../foo//bar///..//././"
+        ))?,
+        &devfs
+            .root_dir()
+            .lookup(&RelPath::new_canonicalized(".//./foo/"))?,
     ));
     assert!(Arc::ptr_eq(
-        &root.clone().lookup(&RelPath::new_canonicalized("///foo//bar///../f2"))?,
+        &root
+            .clone()
+            .lookup(&RelPath::new_canonicalized("///foo//bar///../f2"))?,
         &root.lookup(&RelPath::new_canonicalized("foo/.//f2"))?,
     ));
 

crates/axfs_ramfs/src/tests.rs

@@ -22,7 +22,9 @@ fn test_ramfs_ops(devfs: &RamFileSystem) -> VfsResult {
     assert!(root.get_attr()?.is_dir());
     assert_eq!(root.get_attr()?.file_type(), VfsNodeType::Dir);
     assert_eq!(
-        root.clone().lookup(&RelPath::new_canonicalized("urandom")).err(),
+        root.clone()
+            .lookup(&RelPath::new_canonicalized("urandom"))
+            .err(),
         Some(VfsError::NotFound)
     );
 
@@ -37,24 +39,36 @@ fn test_ramfs_ops(devfs: &RamFileSystem) -> VfsResult {
     assert_eq!(node.read_at(0, &mut buf)?, N);
     assert_eq!(buf[..N_HALF], [0; N_HALF]);
     assert_eq!(buf[N_HALF..], [1; N_HALF]);
-    assert_eq!(node.lookup(&RelPath::new_canonicalized("/")).err(), Some(VfsError::NotADirectory));
+    assert_eq!(
+        node.lookup(&RelPath::new_canonicalized("/")).err(),
+        Some(VfsError::NotADirectory)
+    );
 
-    let foo = devfs.root_dir().lookup(&RelPath::new_canonicalized(".///.//././/.////foo"))?;
+    let foo = devfs
+        .root_dir()
+        .lookup(&RelPath::new_canonicalized(".///.//././/.////foo"))?;
     assert!(foo.get_attr()?.is_dir());
     assert_eq!(
         foo.read_at(10, &mut buf).err(),
         Some(VfsError::IsADirectory)
     );
     assert!(Arc::ptr_eq(
         &foo.clone().lookup(&RelPath::new_canonicalized("/f3"))?,
-        &devfs.root_dir().lookup(&RelPath::new_canonicalized(".//./foo///f3"))?,
+        &devfs
+            .root_dir()
+            .lookup(&RelPath::new_canonicalized(".//./foo///f3"))?,
     ));
     assert_eq!(
-        foo.clone().lookup(&RelPath::new_canonicalized("/bar//f4"))?.get_attr()?.file_type(),
+        foo.clone()
+            .lookup(&RelPath::new_canonicalized("/bar//f4"))?
+            .get_attr()?
+            .file_type(),
         VfsNodeType::File
     );
     assert_eq!(
-        foo.lookup(&RelPath::new_canonicalized("/bar///"))?.get_attr()?.file_type(),
+        foo.lookup(&RelPath::new_canonicalized("/bar///"))?
+            .get_attr()?
+            .file_type(),
         VfsNodeType::Dir
     );
 
@@ -68,25 +82,43 @@ fn test_get_parent(devfs: &RamFileSystem) -> VfsResult {
     let node = root.clone().lookup(&RelPath::new_canonicalized("f1"))?;
     assert!(node.parent().is_none());
 
-    let node = root.clone().lookup(&RelPath::new_canonicalized(".//foo/bar"))?;
+    let node = root
+        .clone()
+        .lookup(&RelPath::new_canonicalized(".//foo/bar"))?;
     assert!(node.parent().is_some());
     let parent = node.parent().unwrap();
-    assert!(Arc::ptr_eq(&parent, &root.clone().lookup(&RelPath::new_canonicalized("foo"))?));
+    assert!(Arc::ptr_eq(
+        &parent,
+        &root.clone().lookup(&RelPath::new_canonicalized("foo"))?
+    ));
     assert!(parent.lookup(&RelPath::new_canonicalized("bar")).is_ok());
 
     let node = root.clone().lookup(&RelPath::new_canonicalized("foo/.."))?;
-    assert!(Arc::ptr_eq(&node, &root.clone().lookup(&RelPath::new_canonicalized("."))?));
+    assert!(Arc::ptr_eq(
+        &node,
+        &root.clone().lookup(&RelPath::new_canonicalized("."))?
+    ));
 
     assert!(Arc::ptr_eq(
-        &root.clone().lookup(&RelPath::new_canonicalized("/foo/.."))?,
-        &devfs.root_dir().lookup(&RelPath::new_canonicalized(".//./foo/././bar/../.."))?,
+        &root
+            .clone()
+            .lookup(&RelPath::new_canonicalized("/foo/.."))?,
+        &devfs
+            .root_dir()
+            .lookup(&RelPath::new_canonicalized(".//./foo/././bar/../.."))?,
     ));
     assert!(Arc::ptr_eq(
-        &root.clone().lookup(&RelPath::new_canonicalized("././/foo//./../foo//bar///..//././"))?,
-        &devfs.root_dir().lookup(&RelPath::new_canonicalized(".//./foo/"))?,
+        &root.clone().lookup(&RelPath::new_canonicalized(
+            "././/foo//./../foo//bar///..//././"
+        ))?,
+        &devfs
+            .root_dir()
+            .lookup(&RelPath::new_canonicalized(".//./foo/"))?,
     ));
     assert!(Arc::ptr_eq(
-        &root.clone().lookup(&RelPath::new_canonicalized("///foo//bar///../f3"))?,
+        &root
+            .clone()
+            .lookup(&RelPath::new_canonicalized("///foo//bar///../f3"))?,
         &root.lookup(&RelPath::new_canonicalized("foo/.//f3"))?,
     ));
 
@@ -105,16 +137,25 @@ fn test_ramfs() {
 
     let ramfs = RamFileSystem::new();
     let root = ramfs.root_dir();
-    root.create(&RelPath::new_canonicalized("f1"), VfsNodeType::File).unwrap();
-    root.create(&RelPath::new_canonicalized("f2"), VfsNodeType::File).unwrap();
-    root.create(&RelPath::new_canonicalized("foo"), VfsNodeType::Dir).unwrap();
+    root.create(&RelPath::new_canonicalized("f1"), VfsNodeType::File)
+        .unwrap();
+    root.create(&RelPath::new_canonicalized("f2"), VfsNodeType::File)
+        .unwrap();
+    root.create(&RelPath::new_canonicalized("foo"), VfsNodeType::Dir)
+        .unwrap();
 
     let dir_foo = root.lookup(&RelPath::new_canonicalized("foo")).unwrap();
-    dir_foo.create(&RelPath::new_canonicalized("f3"), VfsNodeType::File).unwrap();
-    dir_foo.create(&RelPath::new_canonicalized("bar"), VfsNodeType::Dir).unwrap();
+    dir_foo
+        .create(&RelPath::new_canonicalized("f3"), VfsNodeType::File)
+        .unwrap();
+    dir_foo
+        .create(&RelPath::new_canonicalized("bar"), VfsNodeType::Dir)
+        .unwrap();
 
     let dir_bar = dir_foo.lookup(&RelPath::new_canonicalized("bar")).unwrap();
-    dir_bar.create(&RelPath::new_canonicalized("f4"), VfsNodeType::File).unwrap();
+    dir_bar
+        .create(&RelPath::new_canonicalized("f4"), VfsNodeType::File)
+        .unwrap();
 
     let mut entries = ramfs.root_dir_node().get_entries();
     entries.sort();
@@ -126,16 +167,31 @@ fn test_ramfs() {
     let root = ramfs.root_dir();
     assert_eq!(root.unlink(&RelPath::new_canonicalized("f1")), Ok(()));
     assert_eq!(root.unlink(&RelPath::new_canonicalized("//f2")), Ok(()));
-    assert_eq!(root.unlink(&RelPath::new_canonicalized("f3")).err(), Some(VfsError::NotFound));
-    assert_eq!(root.unlink(&RelPath::new_canonicalized("foo")).err(), Some(VfsError::DirectoryNotEmpty));
-    assert_eq!(root.unlink(&RelPath::new_canonicalized("foo/..")).err(), Some(VfsError::InvalidInput));
+    assert_eq!(
+        root.unlink(&RelPath::new_canonicalized("f3")).err(),
+        Some(VfsError::NotFound)
+    );
+    assert_eq!(
+        root.unlink(&RelPath::new_canonicalized("foo")).err(),
+        Some(VfsError::DirectoryNotEmpty)
+    );
+    assert_eq!(
+        root.unlink(&RelPath::new_canonicalized("foo/..")).err(),
+        Some(VfsError::InvalidInput)
+    );
     assert_eq!(
         root.unlink(&RelPath::new_canonicalized("foo/./bar")).err(),
         Some(VfsError::DirectoryNotEmpty)
     );
-    assert_eq!(root.unlink(&RelPath::new_canonicalized("foo/bar/f4")), Ok(()));
+    assert_eq!(
+        root.unlink(&RelPath::new_canonicalized("foo/bar/f4")),
+        Ok(())
+    );
     assert_eq!(root.unlink(&RelPath::new_canonicalized("foo/bar")), Ok(()));
-    assert_eq!(root.unlink(&RelPath::new_canonicalized("./foo//.//f3")), Ok(()));
+    assert_eq!(
+        root.unlink(&RelPath::new_canonicalized("./foo//.//f3")),
+        Ok(())
+    );
     assert_eq!(root.unlink(&RelPath::new_canonicalized("./foo")), Ok(()));
     assert!(ramfs.root_dir_node().get_entries().is_empty());
 }

modules/rux9p/src/fs.rs

@@ -13,8 +13,8 @@
 use crate::drv::{self, Drv9pOps};
 use alloc::{string::String, string::ToString, sync::Arc, sync::Weak, vec::Vec};
 use axfs_vfs::{
-    VfsDirEntry, VfsError, VfsNodeAttr, VfsNodeOps, VfsNodePerm, VfsNodeRef, VfsNodeType, VfsOps,
-    VfsResult, AbsPath, RelPath
+    AbsPath, RelPath, VfsDirEntry, VfsError, VfsNodeAttr, VfsNodeOps, VfsNodePerm, VfsNodeRef,
+    VfsNodeType, VfsOps, VfsResult,
 };
 use log::*;
 use spin::{once::Once, RwLock};

modules/rux9p/src/lib.rs

@@ -27,9 +27,9 @@ mod fs;
 #[cfg(feature = "net-9p")]
 mod netdev;
 
-use alloc::{sync::Arc, borrow::ToOwned};
+use alloc::{borrow::ToOwned, sync::Arc};
 use log::*;
-use ruxfs::{AbsPath, root::MountPoint};
+use ruxfs::{root::MountPoint, AbsPath};
 use spin::RwLock;
 
 #[cfg(feature = "virtio-9p")]

modules/ruxfs/src/fs/another_ext4.rs

@@ -1,4 +1,4 @@
-//! Reference: 
+//! Reference:
 //! - another_ext4: https://github.com/LJxTHUCS/another_ext4
 //! - axfs: https://github.com/Starry-OS/axfs
 
@@ -8,7 +8,7 @@ use another_ext4::{
     Block, BlockDevice, ErrCode as Ext4ErrorCode, Ext4, Ext4Error, FileType as EXt4FileType,
     InodeMode as Ext4InodeMode, BLOCK_SIZE as EXT4_BLOCK_SIZE, EXT4_ROOT_INO,
 };
-use axfs_vfs::{VfsDirEntry, VfsError, VfsNodePerm, VfsResult, RelPath};
+use axfs_vfs::{RelPath, VfsDirEntry, VfsError, VfsNodePerm, VfsResult};
 use axfs_vfs::{VfsNodeAttr, VfsNodeOps, VfsNodeRef, VfsNodeType, VfsOps};
 use axsync::Mutex;
 
@@ -282,4 +282,4 @@ fn map_perm(perm: Ext4InodeMode) -> VfsNodePerm {
         vfs_perm |= VfsNodePerm::OTHER_EXEC;
     }
     vfs_perm
-}
+}

modules/ruxfs/src/fs/ext4_rs.rs

@@ -1,12 +1,12 @@
-//! Reference: 
+//! Reference:
 //! - ext4_rs: https://github.com/yuoo655/ext4_rs
 //! - axfs: https://github.com/Starry-OS/axfs
 
 use crate::dev::Disk;
 use alloc::sync::Arc;
 use alloc::vec;
 use alloc::vec::*;
-use axfs_vfs::{VfsDirEntry, VfsError, VfsNodePerm, VfsResult, RelPath};
+use axfs_vfs::{RelPath, VfsDirEntry, VfsError, VfsNodePerm, VfsResult};
 use axfs_vfs::{VfsNodeAttr, VfsNodeOps, VfsNodeRef, VfsNodeType, VfsOps};
 use axsync::Mutex;
 use core::cell::RefCell;
@@ -411,4 +411,4 @@ fn map_imode(imode: u16) -> (VfsNodeType, VfsNodePerm) {
     }
 
     (ty, vfs_perm)
-}
+}

modules/ruxfs/src/fs/fatfs.rs

@@ -190,7 +190,7 @@ impl VfsNodeOps for DirWrapper<'static> {
     fn unlink(&self, path: &RelPath) -> VfsResult {
         debug!("remove at fatfs: {}", path);
         if path.is_empty() {
-            return ax_err!(PermissionDenied)
+            return ax_err!(PermissionDenied);
         }
         self.0.remove(path).map_err(as_vfs_err)
     }