feat: replace ext4 driver ext4_rs with ext4plus

.cargo/config.toml

@@ -6,15 +6,5 @@ git = "https://github.com/arceos-org/axdriver_crates.git"
 tag = "v0.1.2"
 replace-with = "vendored-sources"
 
-[source."git+https://github.com/arceos-org/slab_allocator.git?tag=v0.3.1"]
-git = "https://github.com/arceos-org/slab_allocator.git"
-tag = "v0.3.1"
-replace-with = "vendored-sources"
-
-[source."git+https://github.com/rcore-os/smoltcp.git?rev=8bf9a9a"]
-git = "https://github.com/rcore-os/smoltcp.git"
-rev = "8bf9a9a"
-replace-with = "vendored-sources"
-
 [source.vendored-sources]
-directory = "vendor"
+directory = "vendor"

Cargo.toml

@@ -1,6 +1,6 @@
 [workspace]
 
-exclude = ["arceos", "crates/axconfig-gen"]
+exclude = ["arceos", "crates/axconfig-gen", "crates/ext4plus"]
 members = ["pulse_core", "pulse_syscalls"]
 
 [workspace.package]
@@ -71,7 +71,6 @@ axsched = { path = "crates/axsched" }
 memory_set = { path = "crates/memory_set" }
 memory_addr = { path = "crates/memory_addr" }
 axfs-ng-vfs = { path = "crates/axfs-ng-vfs" }
-ext4_rs = { path = "crates/ext4_rs" }
 axcpu = { path = "crates/axcpu" }
 axplat-loongarch64-qemu-virt = { path = "crates/axplat-loongarch64-qemu-virt" }
 axplat-riscv64-qemu-virt = { path = "crates/axplat-riscv64-qemu-virt" }

arceos/Cargo.toml

@@ -85,7 +85,6 @@ axsched = { path = "../crates/axsched" }
 memory_set = { path = "../crates/memory_set" }
 memory_addr = { path = "../crates/memory_addr" }
 axfs-ng-vfs = { path = "../crates/axfs-ng-vfs" }
-ext4_rs = { path = "../crates/ext4_rs" }
 axcpu = { path = "../crates/axcpu" }
 axplat-loongarch64-qemu-virt = { path = "../crates/axplat-loongarch64-qemu-virt" }
 axplat-riscv64-qemu-virt = { path = "../crates/axplat-riscv64-qemu-virt" }

arceos/modules/axfs/Cargo.toml

@@ -11,7 +11,7 @@ homepage.workspace = true
 default = ["ext4"]
 use-ramdisk = []       # TODO: init ramdisk
 fat = ["dep:fatfs"]
-ext4 = ["dep:ext4_rs"]
+ext4 = ["dep:ext4plus"]
 times = []
 std = []
 
@@ -38,9 +38,10 @@ scope-local = { workspace = true }
 slab = { version = "0.4.9", default-features = false }
 spin = { workspace = true }
 
-[dependencies.ext4_rs]
-version = "1.3.3"
+[dependencies.ext4plus]
+path = "../../../crates/ext4plus"
 default-features = false
+features = ["sync", "multi-threaded"]
 optional = true
 
 [dependencies.fatfs]

arceos/modules/axfs/src/disk.rs

@@ -124,16 +124,27 @@ pub static DISK_FLUSHERS: spin::Lazy<Mutex<alloc::vec::Vec<alloc::sync::Weak<dyn
 
 /// Flushes all registered disks.
 pub fn flush_all_disks() -> DevResult<()> {
-    let mut flushers = DISK_FLUSHERS.lock();
-    flushers.retain(|weak| {
-        if let Some(flusher) = weak.upgrade() {
-            let _ = flusher.flush_disk();
-            true
-        } else {
-            false
+    let flushers: alloc::vec::Vec<Arc<dyn DiskFlushable>> = {
+        let mut guard = DISK_FLUSHERS.lock();
+        let mut active = alloc::vec::Vec::new();
+        guard.retain(|weak| {
+            if let Some(strong) = weak.upgrade() {
+                active.push(strong);
+                true
+            } else {
+                false
+            }
+        });
+        active
+    };
+    let mut ret = Ok(());
+    for flusher in flushers {
+        if let Err(e) = flusher.flush_disk() {
+            log::error!("Failed to flush disk: {:?}", e);
+            ret = Err(e);
         }
-    });
-    Ok(())
+    }
+    ret
 }
 
 /// A disk device with a cursor.
@@ -233,9 +244,8 @@ impl<D: BlockDriverOps + 'static> SeekableDisk<D> {
             let length = blocks << self.block_size_log2;
             let mut inner = self.inner.lock();
             self.dev.lock().read_block(inner.block_id, take_mut(&mut buf, length))?;
-            read += length;
-
             inner.block_id += blocks as u64;
+            read += length;
         }
         if !buf.is_empty() {
             read += self.read_partial(&mut buf)?;
@@ -278,11 +288,10 @@ impl<D: BlockDriverOps + 'static> SeekableDisk<D> {
         if buf.len() >= self.block_size() {
             let blocks = buf.len() >> self.block_size_log2;
             let length = blocks << self.block_size_log2;
-            self.dev.lock().write_block(self.inner.lock().block_id, take(&mut buf, length))?;
-            written += length;
-
             let mut inner = self.inner.lock();
+            self.dev.lock().write_block(inner.block_id, take(&mut buf, length))?;
             inner.block_id += blocks as u64;
+            written += length;
         }
         if !buf.is_empty() {
             written += self.write_partial(&mut buf)?;