fix: ruxruntime fs test

api/ruxos_posix_api/src/imp/fs.rs

@@ -441,6 +441,9 @@ pub fn sys_rmdir(pathname: *const c_char) -> c_int {
                 if !attr.is_dir() {
                     return Err(LinuxError::ENOTDIR);
                 }
+                if fops::is_mount_point(&path)? {
+                    return Err(LinuxError::EPERM);
+                }
                 if !attr.perm().owner_writable() {
                     return Err(LinuxError::EPERM);
                 }
@@ -493,6 +496,9 @@ pub fn sys_unlinkat(fd: c_int, pathname: *const c_char, flags: c_int) -> c_int {
                     if !attr.is_dir() {
                         return Err(LinuxError::ENOTDIR);
                     }
+                    if fops::is_mount_point(&path)? {
+                        return Err(LinuxError::EPERM);
+                    }
                     if !attr.perm().owner_writable() {
                         return Err(LinuxError::EPERM);
                     }

crates/axfs_vfs/src/path.rs

@@ -65,12 +65,13 @@ impl<'a> AbsPath<'a> {
         AbsPath::new_owned(self.0.to_string())
     }
 
-    /// Transform this `AbsPath` into a raw str slice.
+    /// Convert this `AbsPath` into a raw str slice.
     pub fn as_str(&self) -> &str {
         self.0.as_ref()
     }
 
-    /// Transform this `AbsPath` into a raw string.
+    /// Convert this `AbsPath` into a raw string.
+    #[allow(clippy::inherent_to_string_shadow_display)]
     pub fn to_string(&self) -> String {
         self.0.to_string()
     }

modules/ruxfs/src/api/dir.rs

@@ -7,48 +7,56 @@
  *   See the Mulan PSL v2 for more details.
  */
 
-use alloc::{borrow::ToOwned, string::String, vec};
+use alloc::{borrow::ToOwned, string::String};
 use axerrno::ax_err;
-use axfs_vfs::{AbsPath, VfsError};
+use axfs_vfs::{AbsPath, VfsDirEntry, VfsError};
 use axio::Result;
-use core::{fmt, str};
+use core::{fmt, iter::Iterator, str};
 
-use super::FileType;
+use super::{FileAttr, FileType};
 use crate::fops;
 
-/// Iterator over the entries in a directory.
+/// A wrapped directory type.
+///
+/// Provides a way to open a directory and iterate over its contents.
 pub struct Directory {
     inner: fops::Directory,
 }
 
 impl Directory {
     /// Opens a directory for reading entries.
-    pub fn open(path: AbsPath<'static>) -> Result<Self> {
+    pub fn open(path: &AbsPath) -> Result<Self> {
         let node = fops::lookup(&path)?;
         let inner = fops::open_dir(&path, node, &fops::OpenOptions::new())?;
         Ok(Self { inner })
     }
 
-    /// Reads directory entries starts from the current position into the
-    /// given buffer, returns the number of entries read.
-    ///
-    /// After the read, the cursor of the directory will be advanced by the
-    /// number of entries read.
-    pub fn read_dir(&mut self, buf: &mut [DirEntry]) -> Result<usize> {
-        let mut buffer = vec![fops::DirEntry::default(); buf.len()];
-        let len = self.inner.read_dir(&mut buffer)?;
-        for (i, entry) in buffer.iter().enumerate().take(len) {
-            buf[i] = DirEntry {
-                entry_name: unsafe { str::from_utf8_unchecked(entry.name_as_bytes()).to_owned() },
-                entry_type: entry.entry_type(),
-            };
+    /// Get attributes of the directory.
+    pub fn get_attr(&self) -> Result<FileAttr> {
+        self.inner.get_attr()
+    }
+}
+
+/// Implements the iterator trait for the directory.
+impl Iterator for Directory {
+    type Item = Result<DirEntry>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        let mut buf = [VfsDirEntry::default()];
+        match self.inner.read_dir(buf.as_mut_slice()) {
+            Ok(0) => None,
+            Ok(1) => Some(Ok(DirEntry {
+                entry_name: unsafe { str::from_utf8_unchecked(buf[0].name_as_bytes()).to_owned() },
+                entry_type: buf[0].entry_type(),
+            })),
+            Ok(_) => unreachable!(),
+            Err(e) => Some(Err(e)),
         }
-        Ok(len)
     }
 }
 
 /// Entry type used by `Directory::read_dir`.
-#[derive(Default)]
+#[derive(Default, Clone)]
 pub struct DirEntry {
     entry_name: String,
     entry_type: FileType,

modules/ruxfs/src/api/file.rs

@@ -77,7 +77,7 @@ impl OpenOptions {
             return ax_err!(InvalidInput);
         }
         // Find node, check flag and attr
-        let node = match fops::lookup(&path) {
+        let node = match fops::lookup(path) {
             Ok(node) => {
                 if self.0.create_new {
                     return ax_err!(AlreadyExists);
@@ -88,8 +88,8 @@ impl OpenOptions {
                 if !self.0.create && !self.0.create_new {
                     return ax_err!(NotFound);
                 }
-                fops::create_file(&path)?;
-                fops::lookup(&path)?
+                fops::create_file(path)?;
+                fops::lookup(path)?
             }
             Err(e) => return Err(e),
         };
@@ -101,7 +101,32 @@ impl OpenOptions {
             node.truncate(0)?;
         }
         // Open
-        fops::open_file(&path, node, &self.0).map(|inner| File { inner })
+        fops::open_file(path, node, &self.0).map(|inner| File { inner })
+    }
+}
+
+impl fmt::Debug for OpenOptions {
+    #[allow(unused_assignments)]
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        let mut written = false;
+        macro_rules! fmt_opt {
+            ($field: ident, $label: literal) => {
+                if self.0.$field {
+                    if written {
+                        write!(f, " | ")?;
+                    }
+                    write!(f, $label)?;
+                    written = true;
+                }
+            };
+        }
+        fmt_opt!(read, "READ");
+        fmt_opt!(write, "WRITE");
+        fmt_opt!(append, "APPEND");
+        fmt_opt!(truncate, "TRUNC");
+        fmt_opt!(create, "CREATE");
+        fmt_opt!(create_new, "CREATE_NEW");
+        Ok(())
     }
 }
 
@@ -182,28 +207,3 @@ impl Seek for File {
         self.inner.seek(pos)
     }
 }
-
-impl fmt::Debug for OpenOptions {
-    #[allow(unused_assignments)]
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let mut written = false;
-        macro_rules! fmt_opt {
-            ($field: ident, $label: literal) => {
-                if self.0.$field {
-                    if written {
-                        write!(f, " | ")?;
-                    }
-                    write!(f, $label)?;
-                    written = true;
-                }
-            };
-        }
-        fmt_opt!(read, "READ");
-        fmt_opt!(write, "WRITE");
-        fmt_opt!(append, "APPEND");
-        fmt_opt!(truncate, "TRUNC");
-        fmt_opt!(create, "CREATE");
-        fmt_opt!(create_new, "CREATE_NEW");
-        Ok(())
-    }
-}

modules/ruxfs/src/api/mod.rs

@@ -37,6 +37,11 @@ pub fn set_current_dir(path: AbsPath<'static>) -> io::Result<()> {
     fops::set_current_dir(path)
 }
 
+/// Return the canonicalized and absolute path of the specified path.
+pub fn absolute_path(path: &str) -> io::Result<AbsPath<'static>> {
+    fops::absolute_path(path)
+}
+
 /// Get the attibutes of a file or directory.
 pub fn get_attr(path: &AbsPath) -> io::Result<FileAttr> {
     fops::lookup(path)?.get_attr()
@@ -83,6 +88,9 @@ pub fn remove_dir(path: &AbsPath) -> io::Result<()> {
     if !attr.is_dir() {
         return ax_err!(NotADirectory);
     }
+    if fops::is_mount_point(path) {
+        return ax_err!(PermissionDenied);
+    }
     if !attr.perm().owner_writable() {
         return ax_err!(PermissionDenied);
     }
@@ -112,8 +120,8 @@ pub fn remove_file(path: &AbsPath) -> io::Result<()> {
 pub fn rename(old: &AbsPath, new: &AbsPath) -> io::Result<()> {
     fops::lookup(old)?;
     match fops::lookup(new) {
-        Ok(_) => return ax_err!(AlreadyExists),
+        Ok(_) => ax_err!(AlreadyExists),
         Err(VfsError::NotFound) => fops::rename(old, new),
-        Err(e) => return ax_err!(e),
+        Err(e) => ax_err!(e),
     }
 }

modules/ruxfs/src/fops.rs

@@ -344,6 +344,9 @@ pub fn get_attr(path: &AbsPath) -> AxResult<FileAttr> {
 /// Open a node as a file, with permission checked.
 pub fn open_file(path: &AbsPath, node: VfsNodeRef, opt: &OpenOptions) -> AxResult<File> {
     let attr = node.get_attr()?;
+    if attr.is_dir() {
+        return ax_err!(IsADirectory);
+    }
     if !perm_to_cap(attr.perm()).contains(opt.to_cap()) {
         return ax_err!(PermissionDenied);
     }
@@ -354,6 +357,9 @@ pub fn open_file(path: &AbsPath, node: VfsNodeRef, opt: &OpenOptions) -> AxResul
 /// Open a node as a directory, with permission checked.
 pub fn open_dir(path: &AbsPath, node: VfsNodeRef, opt: &OpenOptions) -> AxResult<Directory> {
     let attr = node.get_attr()?;
+    if !attr.is_dir() {
+        return ax_err!(NotADirectory);
+    }
     if !perm_to_cap(attr.perm()).contains(opt.to_cap()) {
         return ax_err!(PermissionDenied);
     }
@@ -409,12 +415,14 @@ pub fn remove_file(path: &AbsPath) -> AxResult {
 /// This function will not check if the directory exists or is empty,
 /// check it with [`lookup`] first.
 pub fn remove_dir(path: &AbsPath) -> AxResult {
-    if root_dir().contains(path) {
-        return ax_err!(PermissionDenied);
-    }
     root_dir().unlink(&path.to_rel())
 }
 
+/// Check if a directory is a mount point.
+pub fn is_mount_point(path: &AbsPath) -> bool {
+    root_dir().contains(path)
+}
+
 /// Rename a file given an old and a new absolute path.
 ///
 /// This function will not check if the old path or new path exists, check it with

modules/ruxfs/src/root.rs

@@ -115,7 +115,7 @@ impl RootDirectory {
                 idx = i;
             }
         }
-        return (idx, max_len);
+        (idx, max_len)
     }
 
     /// Check if path matches a mountpoint, dispatch the operation to the matched filesystem