fs: add crates/axfs_ramfs and mount to /tmp

Author: equation314

.github/workflows/docs.yml

@@ -1,8 +1,6 @@
 name: Deploy docs
 
-on:
-  push:
-    branches: [main]
+on: [push, pull_request]
 
 jobs:
   doc:
@@ -20,6 +18,7 @@ jobs:
     - name: Build docs
       run: make doc_check_missing
     - name: Deploy to Github Pages
+      if: ${{ github.ref == 'refs/heads/main' }}
       uses: JamesIves/github-pages-deploy-action@v4
       with:
         single-commit: true

.github/workflows/test.yml

@@ -16,7 +16,7 @@ jobs:
         toolchain: nightly
         components: rust-src, llvm-tools-preview
     - name: Run unit tests
-      run: make unit_test_no_fail_fast
+      run: make unittest_no_fail_fast
 
   app-test:
     runs-on: ${{ matrix.os }}

Cargo.lock

@@ -18,6 +18,7 @@ members = [
     "crates/arm_gic",
     "crates/axerrno",
     "crates/axfs_devfs",
+    "crates/axfs_ramfs",
     "crates/axfs_vfs",
     "crates/axio",
     "crates/capability",

Cargo.toml

@@ -102,10 +102,10 @@ fmt_c:
 test:
 	$(call app_test)
 
-unit_test:
+unittest:
 	$(call unit_test)
 
-unit_test_no_fail_fast:
+unittest_no_fail_fast:
 	$(call unit_test,--no-fail-fast)
 
 disk_img:

Makefile

@@ -0,0 +1,15 @@
+[package]
+name = "axfs_ramfs"
+version = "0.1.0"
+edition = "2021"
+authors = ["Yuekai Jia <[email protected]>"]
+description = "RAM filesystem used by ArceOS"
+license = "GPL-3.0-or-later OR Apache-2.0"
+homepage = "https://github.com/rcore-os/arceos"
+repository = "https://github.com/rcore-os/arceos/tree/main/crates/axfs_ramfs"
+documentation = "https://rcore-os.github.io/arceos/axfs_ramfs/index.html"
+
+[dependencies]
+axfs_vfs = { path = "../axfs_vfs" }
+spin = "0.9"
+log = "0.4"

crates/axfs_ramfs/Cargo.toml

@@ -0,0 +1,176 @@
+use alloc::collections::BTreeMap;
+use alloc::sync::{Arc, Weak};
+use alloc::{string::String, vec::Vec};
+
+use axfs_vfs::{VfsDirEntry, VfsNodeAttr, VfsNodeOps, VfsNodeRef, VfsNodeType};
+use axfs_vfs::{VfsError, VfsResult};
+use spin::RwLock;
+
+use crate::file::FileNode;
+
+/// The directory node in the RAM filesystem.
+///
+/// It implements [`axfs_vfs::VfsNodeOps`].
+pub struct DirNode {
+    this: Weak<DirNode>,
+    parent: RwLock<Weak<dyn VfsNodeOps>>,
+    children: RwLock<BTreeMap<String, VfsNodeRef>>,
+}
+
+impl DirNode {
+    pub(super) fn new(parent: Option<Weak<dyn VfsNodeOps>>) -> Arc<Self> {
+        Arc::new_cyclic(|this| Self {
+            this: this.clone(),
+            parent: RwLock::new(parent.unwrap_or_else(|| Weak::<Self>::new())),
+            children: RwLock::new(BTreeMap::new()),
+        })
+    }
+
+    pub(super) fn set_parent(&self, parent: Option<&VfsNodeRef>) {
+        *self.parent.write() = parent.map_or(Weak::<Self>::new() as _, Arc::downgrade);
+    }
+
+    /// Returns a string list of all entries in this directory.
+    pub fn get_entries(&self) -> Vec<String> {
+        self.children.read().keys().cloned().collect()
+    }
+
+    /// Checks whether a node with the given name exists in this directory.
+    pub fn exist(&self, name: &str) -> bool {
+        self.children.read().contains_key(name)
+    }
+
+    /// Creates a new node with the given name and type in this directory.
+    pub fn create_node(&self, name: &str, ty: VfsNodeType) -> VfsResult {
+        if self.exist(name) {
+            log::error!("AlreadyExists {}", name);
+            return Err(VfsError::AlreadyExists);
+        }
+        let node: VfsNodeRef = match ty {
+            VfsNodeType::File => Arc::new(FileNode::new()),
+            VfsNodeType::Dir => Self::new(Some(self.this.clone())),
+            _ => return Err(VfsError::Unsupported),
+        };
+        self.children.write().insert(name.into(), node);
+        Ok(())
+    }
+
+    /// Removes a node by the given name in this directory.
+    pub fn remove_node(&self, name: &str) -> VfsResult {
+        let mut children = self.children.write();
+        let node = children.get(name).ok_or(VfsError::NotFound)?;
+        if let Some(dir) = node.as_any().downcast_ref::<DirNode>() {
+            if !dir.children.read().is_empty() {
+                return Err(VfsError::DirectoryNotEmpty);
+            }
+        }
+        children.remove(name);
+        Ok(())
+    }
+}
+
+impl VfsNodeOps for DirNode {
+    fn get_attr(&self) -> VfsResult<VfsNodeAttr> {
+        Ok(VfsNodeAttr::new_dir(4096, 0))
+    }
+
+    fn parent(&self) -> Option<VfsNodeRef> {
+        self.parent.read().upgrade()
+    }
+
+    fn lookup(self: Arc<Self>, path: &str) -> VfsResult<VfsNodeRef> {
+        let (name, rest) = split_path(path);
+        let node = match name {
+            "" | "." => Ok(self.clone() as VfsNodeRef),
+            ".." => self.parent().ok_or(VfsError::NotFound),
+            _ => self
+                .children
+                .read()
+                .get(name)
+                .cloned()
+                .ok_or(VfsError::NotFound),
+        }?;
+
+        if let Some(rest) = rest {
+            node.lookup(rest)
+        } else {
+            Ok(node)
+        }
+    }
+
+    fn read_dir(&self, start_idx: usize, dirents: &mut [VfsDirEntry]) -> VfsResult<usize> {
+        let children = self.children.read();
+        let mut children = children.iter().skip(start_idx.max(2) - 2);
+        for (i, ent) in dirents.iter_mut().enumerate() {
+            match i + start_idx {
+                0 => *ent = VfsDirEntry::new(".", VfsNodeType::Dir),
+                1 => *ent = VfsDirEntry::new("..", VfsNodeType::Dir),
+                _ => {
+                    if let Some((name, node)) = children.next() {
+                        *ent = VfsDirEntry::new(name, node.get_attr().unwrap().file_type());
+                    } else {
+                        return Ok(i);
+                    }
+                }
+            }
+        }
+        Ok(dirents.len())
+    }
+
+    fn create(&self, path: &str, ty: VfsNodeType) -> VfsResult {
+        log::debug!("create {:?} at ramfs: {}", ty, path);
+        let (name, rest) = split_path(path);
+        if let Some(rest) = rest {
+            match name {
+                "" | "." => self.create(rest, ty),
+                ".." => self.parent().ok_or(VfsError::NotFound)?.create(rest, ty),
+                _ => {
+                    let subdir = self
+                        .children
+                        .read()
+                        .get(name)
+                        .ok_or(VfsError::NotFound)?
+                        .clone();
+                    subdir.create(rest, ty)
+                }
+            }
+        } else if name.is_empty() || name == "." || name == ".." {
+            Ok(()) // already exists
+        } else {
+            self.create_node(name, ty)
+        }
+    }
+
+    fn remove(&self, path: &str) -> VfsResult {
+        log::debug!("remove at ramfs: {}", path);
+        let (name, rest) = split_path(path);
+        if let Some(rest) = rest {
+            match name {
+                "" | "." => self.remove(rest),
+                ".." => self.parent().ok_or(VfsError::NotFound)?.remove(rest),
+                _ => {
+                    let subdir = self
+                        .children
+                        .read()
+                        .get(name)
+                        .ok_or(VfsError::NotFound)?
+                        .clone();
+                    subdir.remove(rest)
+                }
+            }
+        } else if name.is_empty() || name == "." || name == ".." {
+            Err(VfsError::InvalidInput) // remove '.' or '..
+        } else {
+            self.remove_node(name)
+        }
+    }
+
+    axfs_vfs::impl_vfs_dir_default! {}
+}
+
+fn split_path(path: &str) -> (&str, Option<&str>) {
+    let trimmed_path = path.trim_start_matches('/');
+    trimmed_path.find('/').map_or((trimmed_path, None), |n| {
+        (&trimmed_path[..n], Some(&trimmed_path[n + 1..]))
+    })
+}

crates/axfs_ramfs/src/dir.rs

@@ -0,0 +1,56 @@
+use alloc::vec::Vec;
+use axfs_vfs::{impl_vfs_non_dir_default, VfsNodeAttr, VfsNodeOps, VfsResult};
+use spin::RwLock;
+
+/// The file node in the RAM filesystem.
+///
+/// It implements [`axfs_vfs::VfsNodeOps`].
+pub struct FileNode {
+    content: RwLock<Vec<u8>>,
+}
+
+impl FileNode {
+    pub(super) const fn new() -> Self {
+        Self {
+            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))
+    }
+
+    fn truncate(&self, size: u64) -> VfsResult {
+        let mut content = self.content.write();
+        if size < content.len() as u64 {
+            content.truncate(size as _);
+        } else {
+            content.resize(size as _, 0);
+        }
+        Ok(())
+    }
+
+    fn read_at(&self, offset: u64, buf: &mut [u8]) -> VfsResult<usize> {
+        let content = self.content.read();
+        let start = content.len().min(offset as usize);
+        let end = content.len().min(offset as usize + buf.len());
+        let src = &content[start..end];
+        buf[..src.len()].copy_from_slice(src);
+        Ok(src.len())
+    }
+
+    fn write_at(&self, offset: u64, buf: &[u8]) -> VfsResult<usize> {
+        let offset = offset as usize;
+        let mut content = self.content.write();
+        if offset + buf.len() > content.len() {
+            content.resize(offset + buf.len(), 0);
+        }
+        let dst = &mut content[offset..offset + buf.len()];
+        dst.copy_from_slice(&buf[..dst.len()]);
+        Ok(buf.len())
+    }
+
+    impl_vfs_non_dir_default! {}
+}

crates/axfs_ramfs/src/file.rs

@@ -0,0 +1,62 @@
+//! RAM filesystem used by [ArceOS](https://github.com/rcore-os/arceos).
+//!
+//! The implementation is based on [`axfs_vfs`].
+
+#![cfg_attr(not(test), no_std)]
+
+extern crate alloc;
+
+mod dir;
+mod file;
+
+#[cfg(test)]
+mod tests;
+
+pub use self::dir::DirNode;
+pub use self::file::FileNode;
+
+use alloc::sync::Arc;
+use axfs_vfs::{VfsNodeRef, VfsOps, VfsResult};
+use spin::once::Once;
+
+/// A RAM filesystem that implements [`axfs_vfs::VfsOps`].
+pub struct RamFileSystem {
+    parent: Once<VfsNodeRef>,
+    root: Arc<DirNode>,
+}
+
+impl RamFileSystem {
+    /// Create a new instance.
+    pub fn new() -> Self {
+        Self {
+            parent: Once::new(),
+            root: DirNode::new(None),
+        }
+    }
+
+    /// Returns the root directory node in [`Arc<DirNode>`](DirNode).
+    pub fn root_dir_node(&self) -> Arc<DirNode> {
+        self.root.clone()
+    }
+}
+
+impl VfsOps for RamFileSystem {
+    fn mount(&self, _path: &str, mount_point: VfsNodeRef) -> VfsResult {
+        if let Some(parent) = mount_point.parent() {
+            self.root.set_parent(Some(self.parent.call_once(|| parent)));
+        } else {
+            self.root.set_parent(None);
+        }
+        Ok(())
+    }
+
+    fn root_dir(&self) -> VfsNodeRef {
+        self.root.clone()
+    }
+}
+
+impl Default for RamFileSystem {
+    fn default() -> Self {
+        Self::new()
+    }
+}