fs: allow to define custom filesystem in apps

equation314 · equation314 · commit 234171cfe8f7 · 2023-04-23T00:31:53.000+08:00
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
@@ -8,8 +8,8 @@ members = [
     "apps/fs/shell",
     "apps/net/echoserver",
     "apps/net/httpclient",
-    "apps/net/udpserver",
     "apps/net/httpserver",
+    "apps/net/udpserver",
     "apps/task/parallel",
     "apps/task/sleep",
     "apps/task/yield",
diff --git a/apps/fs/shell/Cargo.toml b/apps/fs/shell/Cargo.toml
@@ -6,5 +6,13 @@ authors = ["Yuekai Jia <equation618@gmail.com>"]
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
+[features]
+use_ramfs = ["axfs/myfs", "dep:axfs_vfs", "dep:axfs_ramfs", "dep:crate_interface"]
+default = []
+
 [dependencies]
+axfs = { path = "../../../modules/axfs", optional = true }
+axfs_vfs = { path = "../../../crates/axfs_vfs", optional = true }
+axfs_ramfs = { path = "../../../crates/axfs_ramfs", optional = true }
+crate_interface = { path = "../../../crates/crate_interface", optional = true }
 libax = { path = "../../../ulib/libax", features = ["fs"] }
diff --git a/apps/fs/shell/src/main.rs b/apps/fs/shell/src/main.rs
@@ -3,6 +3,9 @@
 
 mod cmd;
 
+#[cfg(feature = "use_ramfs")]
+mod ramfs;
+
 use libax::io::prelude::*;
 
 #[macro_use]
diff --git a/apps/fs/shell/src/ramfs.rs b/apps/fs/shell/src/ramfs.rs
@@ -0,0 +1,15 @@
+extern crate alloc;
+
+use alloc::sync::Arc;
+use axfs::fops::{Disk, MyFileSystemIf};
+use axfs_ramfs::RamFileSystem;
+use axfs_vfs::VfsOps;
+
+struct MyFileSystemIfImpl;
+
+#[crate_interface::impl_interface]
+impl MyFileSystemIf for MyFileSystemIfImpl {
+    fn new_myfs(_disk: Disk) -> Arc<dyn VfsOps> {
+        Arc::new(RamFileSystem::new())
+    }
+}
diff --git a/modules/axfs/Cargo.toml b/modules/axfs/Cargo.toml
@@ -16,6 +16,7 @@ use-virtio-blk = ["axdriver/virtio-blk"]
 devfs = ["dep:axfs_devfs"]
 ramfs = ["dep:axfs_ramfs"]
 fatfs = ["dep:fatfs"]
+myfs = ["dep:crate_interface"]
 
 default = ["use-ramdisk", "devfs", "ramfs", "fatfs"]
 
@@ -32,6 +33,7 @@ axfs_devfs = { path = "../../crates/axfs_devfs", optional = true }
 axfs_ramfs = { path = "../../crates/axfs_ramfs", optional = true }
 axdriver = { path = "../axdriver", optional = true }
 axsync = { path = "../axsync", default-features = false }
+crate_interface = { path = "../../crates/crate_interface", optional = true }
 
 [dependencies.fatfs]
 git = "https://github.com/rafalh/rust-fatfs"
diff --git a/modules/axfs/src/fops.rs b/modules/axfs/src/fops.rs
@@ -6,6 +6,11 @@ use axio::SeekFrom;
 use capability::{Cap, WithCap};
 use core::fmt;
 
+#[cfg(feature = "myfs")]
+pub use crate::dev::Disk;
+#[cfg(feature = "myfs")]
+pub use crate::fs::myfs::MyFileSystemIf;
+
 /// Alias of [`axfs_vfs::VfsNodeType`].
 pub type FileType = axfs_vfs::VfsNodeType;
 /// Alias of [`axfs_vfs::VfsDirEntry`].
diff --git a/modules/axfs/src/fs/mod.rs b/modules/axfs/src/fs/mod.rs
@@ -1,5 +1,10 @@
-#[cfg(feature = "fatfs")]
-pub mod fatfs;
+cfg_if::cfg_if! {
+    if #[cfg(feature = "myfs")] {
+        pub mod myfs;
+    } else if #[cfg(feature = "fatfs")] {
+        pub mod fatfs;
+    }
+}
 
 #[cfg(feature = "devfs")]
 pub use axfs_devfs as devfs;
diff --git a/modules/axfs/src/fs/myfs.rs b/modules/axfs/src/fs/myfs.rs
@@ -0,0 +1,16 @@
+use crate::dev::Disk;
+use alloc::sync::Arc;
+use axfs_vfs::VfsOps;
+
+/// The interface to define custom filesystems in user apps.
+#[crate_interface::def_interface]
+pub trait MyFileSystemIf {
+    /// Creates a new instance of the filesystem with initialization.
+    ///
+    /// TODO: use generic disk type
+    fn new_myfs(disk: Disk) -> Arc<dyn VfsOps>;
+}
+
+pub(crate) fn new_myfs(disk: Disk) -> Arc<dyn VfsOps> {
+    crate_interface::call_interface!(MyFileSystemIf::new_myfs(disk))
+}
diff --git a/modules/axfs/src/lib.rs b/modules/axfs/src/lib.rs
@@ -5,20 +5,27 @@
 //! # Cargo Features
 //!
 //! - `use-ramdisk`: Use [`driver_block::ramdisk::RamDisk`] as the block device.
-//!    This feature is enabled by default.
+//!    This feature is **enabled** by default.
 //! - `use-virtio-blk`: Use [`axdriver::VirtIoBlockDev`] as the block device.
-//!    This feature is disabled by default, but it will override `use-ramdisk`
+//!    This feature is **disabled** by default, but it will override `use-ramdisk`
 //!    if both are enabled.
 //! - `fatfs`: Use [FAT] as the main filesystem and mount it on `/`. This feature
-//!    is enabled by default.
+//!    is **enabled** by default.
 //! - `devfs`: Mount [`axfs_devfs::DeviceFileSystem`] on `/dev`. This feature is
-//!    enabled by default.
+//!    **enabled** by default.
 //! - `ramfs`: Mount [`axfs_ramfs::RamFileSystem`] on `/tmp`. This feature is
-//!    enabled by default.
+//!    **enabled** by default.
+//! - `myfs`: Allow users to define their custom filesystems to override the
+//!   default. In this case, [`MyFileSystemIf`] is required to be implemented
+//!   to create and initialize other filesystems. This feature is **disabled** by
+//!    by default, but it will override
+//!   other filesystem selection features if both are enabled.
 //!
 //! [FAT]: https://en.wikipedia.org/wiki/File_Allocation_Table
+//! [`MyFileSystemIf`]: fops::MyFileSystemIf
 
 #![cfg_attr(all(not(test), not(doc)), no_std)]
+#![feature(doc_auto_cfg)]
 
 #[macro_use]
 extern crate log;
diff --git a/modules/axfs/src/root.rs b/modules/axfs/src/root.rs
@@ -13,9 +13,6 @@ use crate::{api::FileType, fs};
 static CURRENT_DIR_PATH: Mutex<String> = Mutex::new(String::new());
 static CURRENT_DIR: LazyInit<Mutex<VfsNodeRef>> = LazyInit::new();
 
-#[cfg(feature = "fatfs")]
-type MainFileSystem = fs::fatfs::FatFileSystem;
-
 struct MountPoint {
     path: &'static str,
     fs: Arc<dyn VfsOps>,
@@ -26,7 +23,6 @@ struct RootDirectory {
     mounts: Vec<MountPoint>,
 }
 
-static MAIN_FS: LazyInit<Arc<MainFileSystem>> = LazyInit::new();
 static ROOT_DIR: LazyInit<Arc<RootDirectory>> = LazyInit::new();
 
 impl MountPoint {
@@ -60,8 +56,8 @@ impl RootDirectory {
             return ax_err!(InvalidInput, "mount point already exists");
         }
         // create the mount point in the main filesystem if it does not exist
-        MAIN_FS.root_dir().create(path, FileType::Dir)?;
-        fs.mount(path, MAIN_FS.root_dir().lookup(path)?)?;
+        self.main_fs.root_dir().create(path, FileType::Dir)?;
+        fs.mount(path, self.main_fs.root_dir().lookup(path)?)?;
         self.mounts.push(MountPoint::new(path, fs));
         Ok(())
     }
@@ -138,13 +134,18 @@ impl VfsNodeOps for RootDirectory {
 }
 
 pub(crate) fn init_rootfs(disk: crate::dev::Disk) {
-    #[cfg(feature = "fatfs")]
-    let main_fs = fs::fatfs::FatFileSystem::new(disk);
-
-    MAIN_FS.init_by(Arc::new(main_fs));
-    MAIN_FS.init();
+    cfg_if::cfg_if! {
+        if #[cfg(feature = "myfs")] { // override the default filesystem
+            let main_fs = fs::myfs::new_myfs(disk);
+        } else if #[cfg(feature = "fatfs")] {
+            static FAT_FS: LazyInit<Arc<fs::fatfs::FatFileSystem>> = LazyInit::new();
+            FAT_FS.init_by(Arc::new(fs::fatfs::FatFileSystem::new(disk)));
+            FAT_FS.init();
+            let main_fs = FAT_FS.clone();
+        }
+    }
 
-    let mut root_dir = RootDirectory::new(MAIN_FS.clone());
+    let mut root_dir = RootDirectory::new(main_fs);
 
     #[cfg(feature = "devfs")]
     {
diff --git a/modules/axfs/tests/test_common/mod.rs b/modules/axfs/tests/test_common/mod.rs
@@ -1,14 +1,9 @@
-#![cfg(not(feature = "use-virtio-blk"))]
-
 use axfs::api as fs;
 use axio as io;
 
-use driver_block::ramdisk::RamDisk;
 use fs::{File, FileType, OpenOptions};
 use io::{prelude::*, Error, Result};
 
-const IMG_PATH: &str = "resources/fat16.img";
-
 macro_rules! assert_err {
     ($expr: expr) => {
         assert!(($expr).is_err())
@@ -18,14 +13,6 @@ macro_rules! assert_err {
     };
 }
 
-fn make_disk() -> std::io::Result<RamDisk> {
-    let path = std::env::current_dir()?.join(IMG_PATH);
-    println!("Loading disk image from {:?} ...", path);
-    let data = std::fs::read(path)?;
-    println!("size = {} bytes", data.len());
-    Ok(RamDisk::from(&data))
-}
-
 fn test_read_write_file() -> Result<()> {
     let fname = "///very/long//.././long//./path/./test.txt";
     println!("read and write file {:?}:", fname);
@@ -80,7 +67,7 @@ fn test_file_permission() -> Result<()> {
     let mut buf = [0; 256];
     let mut file = File::open(fname)?;
     let n = file.read(&mut buf)?;
-    assert_err!(file.write(&mut buf), PermissionDenied);
+    assert_err!(file.write(&buf), PermissionDenied);
     drop(file);
 
     // read a file that open with write-only mode
@@ -261,17 +248,11 @@ fn test_devfs_ramfs() -> Result<()> {
     assert_eq!(fs::remove_dir("tmp/dir/.././dir///"), Ok(()));
     assert_eq!(fs::read_dir("tmp").unwrap().count(), 0);
 
-    println!("test_devfs() OK!");
+    println!("test_devfs_ramfs() OK!");
     Ok(())
 }
 
-#[test]
-fn test_axfs() {
-    axtask::init_scheduler(); // call this to use `axsync::Mutex`.
-
-    let disk = make_disk().expect("failed to load disk image");
-    axfs::init_filesystems(disk);
-
+pub fn test_all() {
     test_read_write_file().expect("test_read_write_file() failed");
     test_read_dir().expect("test_read_dir() failed");
     test_file_permission().expect("test_file_permission() failed");
diff --git a/modules/axfs/tests/test_fatfs.rs b/modules/axfs/tests/test_fatfs.rs
@@ -0,0 +1,26 @@
+#![cfg(all(not(feature = "use-virtio-blk"), not(feature = "myfs")))]
+
+mod test_common;
+
+use driver_block::ramdisk::RamDisk;
+
+const IMG_PATH: &str = "resources/fat16.img";
+
+fn make_disk() -> std::io::Result<RamDisk> {
+    let path = std::env::current_dir()?.join(IMG_PATH);
+    println!("Loading disk image from {:?} ...", path);
+    let data = std::fs::read(path)?;
+    println!("size = {} bytes", data.len());
+    Ok(RamDisk::from(&data))
+}
+
+#[test]
+fn test_fatfs() {
+    println!("Testing fatfs with ramdisk ...");
+
+    let disk = make_disk().expect("failed to load disk image");
+    axtask::init_scheduler(); // call this to use `axsync::Mutex`.
+    axfs::init_filesystems(disk);
+
+    test_common::test_all();
+}
diff --git a/modules/axfs/tests/test_ramfs.rs b/modules/axfs/tests/test_ramfs.rs
@@ -0,0 +1,55 @@
+#![cfg(all(not(feature = "use-virtio-blk"), feature = "myfs"))]
+
+mod test_common;
+
+use std::sync::Arc;
+
+use axfs::api::{self as fs, File};
+use axfs::fops::{Disk, MyFileSystemIf};
+use axfs_ramfs::RamFileSystem;
+use axfs_vfs::VfsOps;
+use axio::{Result, Write};
+use driver_block::ramdisk::RamDisk;
+
+struct MyFileSystemIfImpl;
+
+#[crate_interface::impl_interface]
+impl MyFileSystemIf for MyFileSystemIfImpl {
+    fn new_myfs(_disk: Disk) -> Arc<dyn VfsOps> {
+        Arc::new(RamFileSystem::new())
+    }
+}
+
+fn create_init_files() -> Result<()> {
+    fs::write("./short.txt", "Rust is cool!\n")?;
+    let mut file = File::create_new("/long.txt")?;
+    for _ in 0..100 {
+        file.write_fmt(format_args!("Rust is cool!\n"))?;
+    }
+
+    fs::create_dir("very-long-dir-name")?;
+    fs::write(
+        "very-long-dir-name/very-long-file-name.txt",
+        "Rust is cool!\n",
+    )?;
+
+    fs::create_dir("very")?;
+    fs::create_dir("//very/long")?;
+    fs::create_dir("/./very/long/path")?;
+    fs::write(".//very/long/path/test.txt", "Rust is cool!\n")?;
+    Ok(())
+}
+
+#[test]
+fn test_ramfs() {
+    println!("Testing ramfs ...");
+
+    axtask::init_scheduler(); // call this to use `axsync::Mutex`.
+    axfs::init_filesystems(RamDisk::new(0)); // dummy disk, actually not used.
+
+    if let Err(e) = create_init_files() {
+        log::warn!("failed to create init files: {:?}", e);
+    }
+
+    test_common::test_all();
+}
diff --git a/scripts/make/test.mk b/scripts/make/test.mk
@@ -2,6 +2,7 @@
 
 define unit_test
   cargo test -p percpu $(1) -- --nocapture
+  cargo test -p axfs $(1) --features "myfs" -- --nocapture
   cargo test --workspace --exclude "arceos-*" $(1) -- --nocapture
 endef
 
