style: ruxos_posix_api fs syscalls

api/ruxos_posix_api/src/imp/fs.rs

@@ -40,7 +40,7 @@ impl ruxtask::fs::InitFs for InitFsImpl {
 }
 
 /// Convert open flags to [`OpenOptions`].
-pub fn flags_to_options(flags: c_int, _mode: ctypes::mode_t) -> OpenOptions {
+fn flags_to_options(flags: c_int, _mode: ctypes::mode_t) -> OpenOptions {
     let flags = flags as u32;
     let mut options = OpenOptions::new();
     match flags & 0b11 {
@@ -77,18 +77,17 @@ pub fn sys_open(filename: *const c_char, flags: c_int, mode: ctypes::mode_t) ->
     syscall_body!(sys_open, {
         let path = parse_path(filename)?;
         let opts = flags_to_options(flags, mode);
-        let flags = flags as u32;
         debug!("sys_open <= {:?} {:#o} {:#o}", path, flags, mode);
         // Check flag and attr
         let node = match fops::lookup(&path) {
             Ok(node) => {
-                if flags & ctypes::O_EXCL != 0 {
+                if opts.create_new {
                     return Err(LinuxError::EEXIST);
                 }
                 node
             }
             Err(Error::NotFound) => {
-                if !(flags & ctypes::O_CREAT != 0) {
+                if !opts.create {
                     return Err(LinuxError::ENOENT);
                 }
                 fops::create_file(&path)?;
@@ -100,7 +99,7 @@ pub fn sys_open(filename: *const c_char, flags: c_int, mode: ctypes::mode_t) ->
             return Err(LinuxError::EISDIR);
         }
         // Truncate
-        if flags & ctypes::O_TRUNC != 0 {
+        if opts.truncate {
             node.truncate(0)?;
         }
         // Open
@@ -114,7 +113,8 @@ pub fn sys_openat(fd: c_int, path: *const c_char, flags: c_int, mode: ctypes::mo
     syscall_body!(sys_openat, {
         let path = parse_path_at(fd, path)?;
         let opts = flags_to_options(flags, mode);
-        let flags = flags as u32;
+        let open_dir = flags as u32 & ctypes::O_DIRECTORY != 0;
+        let searchable = flags as u32 & ctypes::O_SEARCH != 0;
         debug!(
             "sys_openat <= {}, {:?}, {:#o}, {:#o}",
             fd, path, flags, mode
@@ -124,23 +124,22 @@ pub fn sys_openat(fd: c_int, path: *const c_char, flags: c_int, mode: ctypes::mo
             Ok(node) => {
                 let attr = node.get_attr()?;
                 // Node exists but O_EXCL is set
-                if flags & ctypes::O_EXCL != 0 {
-                    debug!("exist {} {}", flags, ctypes::O_EXCL);
+                if opts.create_new {
                     return Err(LinuxError::EEXIST);
                 }
                 // Node is not a directory but O_DIRECTORY is set
-                if !attr.is_dir() && (flags & ctypes::O_DIRECTORY != 0) {
+                if !attr.is_dir() && open_dir {
                     return Err(LinuxError::ENOTDIR);
                 }
                 // Truncate
-                if attr.is_file() && (flags & ctypes::O_TRUNC != 0) {
+                if attr.is_file() && opts.truncate {
                     node.truncate(0)?;
                 }
                 node
             }
             Err(Error::NotFound) => {
                 // O_CREAT is not set or O_DIRECTORY is set
-                if (flags & ctypes::O_DIRECTORY != 0) || (flags & ctypes::O_CREAT == 0) {
+                if open_dir || !opts.create {
                     return Err(LinuxError::ENOENT);
                 }
                 // Create file
@@ -152,7 +151,7 @@ pub fn sys_openat(fd: c_int, path: *const c_char, flags: c_int, mode: ctypes::mo
         // Open file or directory
         if node.get_attr()?.is_dir() {
             let dir = fops::open_dir(&path, node, &opts)?;
-            Directory::new(dir, flags & ctypes::O_SEARCH != 0).add_to_fd_table(opts)
+            Directory::new(dir, searchable).add_to_fd_table(opts)
         } else {
             let file = fops::open_file(&path, node, &opts)?;
             File::new(file).add_to_fd_table(opts)

modules/ruxfs/src/fops.rs

@@ -7,7 +7,7 @@
  *   See the Mulan PSL v2 for more details.
  */
 
-//! Low-level filesystem operations. Provided for [ruxfs::api] and [ruxos_posix_api::fs] modules.
+//! Low-level filesystem operations. Provided for [`ruxfs::api`] and [`ruxos_posix_api::fs`] modules.
 //!
 //! - File: open, read, write, seek, truncate
 //! - Directory: open, read, create, remove
@@ -37,6 +37,8 @@ pub type FileAttr = axfs_vfs::VfsNodeAttr;
 pub type FilePerm = axfs_vfs::VfsNodePerm;
 
 /// An opened file object, with open permissions and a cursor.
+///
+/// Providing basic file operations.
 pub struct File {
     path: AbsPath<'static>,
     node: WithCap<VfsNodeRef>,
@@ -137,6 +139,8 @@ impl Drop for File {
 }
 
 /// An opened directory object, with open permissions and a cursor for entry reading.
+///
+/// Providing entry reading operations.
 pub struct Directory {
     path: AbsPath<'static>,
     node: WithCap<VfsNodeRef>,
@@ -325,7 +329,7 @@ pub(crate) fn root_dir() -> Arc<RootDirectory> {
     crate_interface::call_interface!(CurrentWorkingDirectoryOps::root_dir)
 }
 
-// File operations with absolute path.
+/* File operations with absolute path. */
 
 /// Look up a file given an absolute path.
 pub fn lookup(path: &AbsPath) -> AxResult<VfsNodeRef> {
@@ -354,12 +358,17 @@ pub fn open_dir(path: &AbsPath, node: VfsNodeRef, opt: &OpenOptions) -> AxResult
         return ax_err!(PermissionDenied);
     }
     node.open()?;
-    Ok(Directory::new(path.to_owned(), node, opt.to_cap() | Cap::EXECUTE))
+    Ok(Directory::new(
+        path.to_owned(),
+        node,
+        opt.to_cap() | Cap::EXECUTE,
+    ))
 }
 
 /// Lookup and open a file at an arbitrary path.
-/// 
+///
 /// If `path` is relative, it will be resolved against the current working directory.
+/// If `path` is absolute, it will be used as is.
 pub fn open(path: &str, opt: &OpenOptions) -> AxResult<File> {
     let path = absolute_path(path)?;
     let node = lookup(&path)?;
@@ -414,7 +423,7 @@ pub fn rename(old: &AbsPath, new: &AbsPath) -> AxResult {
     root_dir().rename(&old.to_rel(), &new.to_rel())
 }
 
-pub fn perm_to_cap(perm: FilePerm) -> Cap {
+fn perm_to_cap(perm: FilePerm) -> Cap {
     let mut cap = Cap::empty();
     if perm.owner_readable() {
         cap |= Cap::READ;

modules/ruxfs/src/lib.rs

@@ -35,17 +35,19 @@
 extern crate log;
 extern crate alloc;
 
-mod dev;
 mod fs;
 mod mounts;
 
+#[cfg(feature = "blkfs")]
+mod dev;
 #[cfg(feature = "alloc")]
 mod arch;
 
 pub mod api;
 pub mod fops;
 pub mod root;
 
+// Re-export `axfs_vfs` path types.
 pub type AbsPath<'a> = axfs_vfs::AbsPath<'a>;
 pub type RelPath<'a> = axfs_vfs::RelPath<'a>;
 

modules/ruxfs/src/root.rs

@@ -7,7 +7,7 @@
  *   See the Mulan PSL v2 for more details.
  */
 
-//! Root directory of the filesystem. Filesystem operations are distributed to the
+//! Root directory of the filesystem, where filesystem operations are distributed to the
 //! appropriate filesystem based on the mount points.
 //!
 //! `RootDirectory::lookup_mounted_fs()` performs the distribution of operations.