fix: ext4 cache coherence and syscall compatibility for self-compilation

components/rsext4/src/blockdev/cached_device.rs

@@ -154,6 +154,12 @@ impl<B: BlockDevice> BlockDev<B> {
     }
 
     /// Writes `count` blocks directly from `buffer` (bypasses the cache).
+    ///
+    /// After writing, any cache entries for the written block range are
+    /// invalidated so that a subsequent `read_block` does not return stale
+    /// (pre-write) data.  Without this, directory-entry modifications made
+    /// via `write_blocks` (DataBlockCache → `write_block_static`) can be
+    /// invisible to path lookups that go through `read_block`.
     pub fn write_blocks(
         &mut self,
         buffer: &[u8],
@@ -171,7 +177,26 @@ impl<B: BlockDevice> BlockDev<B> {
             return Err(Ext4Error::buffer_too_small(buffer.len(), required_size));
         }
 
-        self.dev.write(buffer, block_id, count)
+        self.dev.write(buffer, block_id, count)?;
+
+        // Invalidate cache entries that overlap with the written block range.
+        // Otherwise a subsequent `read_block` hit would return the old data.
+        for entry in self.entries.iter_mut() {
+            if let Some(id) = entry.block_id {
+                for off in 0..count {
+                    if let Ok(written) = block_id.checked_add(off) {
+                        if id == written {
+                            entry.block_id = None;
+                            entry.dirty = false;
+                            entry.referenced = false;
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+
+        Ok(())
     }
 
     /// Returns the active buffer (read-only view of the last accessed block).

os/StarryOS/kernel/src/syscall/io_mpx/epoll.rs

@@ -187,6 +187,27 @@ fn do_epoll_wait(
     Ok(count)
 }
 
+pub fn sys_epoll_wait(
+    epfd: i32,
+    events: UserPtr<epoll_event>,
+    maxevents: i32,
+    timeout: i32,
+) -> AxResult<isize> {
+    let timeout = match timeout {
+        -1 => None,
+        t if t >= 0 => Some(Duration::from_millis(t as u64)),
+        _ => return Err(AxError::InvalidInput),
+    };
+    do_epoll_wait(
+        epfd,
+        events,
+        maxevents,
+        timeout,
+        UserConstPtr::<SignalSet>::default(),
+        0,
+    )
+}
+
 pub fn sys_epoll_pwait(
     epfd: i32,
     events: UserPtr<epoll_event>,

os/StarryOS/kernel/src/syscall/mod.rs

@@ -364,6 +364,12 @@ pub fn handle_syscall(uctx: &mut UserContext) {
             uctx.arg2() as _,
             uctx.arg3().into(),
         ),
+        Sysno::epoll_wait => sys_epoll_wait(
+            uctx.arg0() as _,
+            uctx.arg1().into(),
+            uctx.arg2() as _,
+            uctx.arg3() as _,
+        ),
         Sysno::epoll_pwait => sys_epoll_pwait(
             uctx.arg0() as _,
             uctx.arg1().into(),
@@ -804,12 +810,31 @@ pub fn handle_syscall(uctx: &mut UserContext) {
 
         // dummy fds
         Sysno::userfaultfd
-        | Sysno::io_uring_setup
-        | Sysno::fsopen
-        | Sysno::fspick
-        | Sysno::open_tree
         | Sysno::memfd_secret => sys_dummy_fd(sysno),
 
+        // New mount API — return ENOSYS so mount(8) falls back to
+        // the traditional mount(2) syscall (which is implemented).
+        Sysno::fsopen | Sysno::fspick | Sysno::open_tree => {
+            warn!("new mount API not supported (sysno={sysno}), returning ENOSYS for fallback");
+            Err(AxError::Unsupported)
+        }
+
+        // io_uring: fake enough support so tokio 1.x creates its I/O
+        // driver without panicking, then falls back to blocking I/O.
+        // io_uring_setup returns a dummy fd (tokio thinks io_uring is
+        // available), io_uring_enter/register return 0 (no events /
+        // success).  Without this, tokio calls io_uring_enter on the
+        // dummy fd, gets ENOSYS, and panics — corrupting cargo state.
+        Sysno::io_uring_setup => {
+            warn!("io_uring_setup: returning dummy fd for compatibility");
+            sys_dummy_fd(sysno)
+        }
+        Sysno::io_uring_enter | Sysno::io_uring_register => {
+            // Return 0 = "0 completions" / "successful registration"
+            // so tokio's io_uring driver keeps polling without errors.
+            Ok(0)
+        }
+
         #[cfg(feature = "ebpf")]
         Sysno::bpf => crate::ebpf::sys_bpf(uctx.arg0() as _, uctx.arg1(), uctx.arg2() as _),
         #[cfg(feature = "ebpf")]

os/arceos/modules/axfs-ng/src/fs/ext4/rsext4/fs.rs

@@ -1,7 +1,8 @@
 use alloc::{boxed::Box, sync::Arc};
 use core::cell::OnceCell;
 
-use ax_kspin::{SpinNoIrq as Mutex, SpinNoIrqGuard as MutexGuard};
+use ax_hal;
+use ax_sync::{Mutex, MutexGuard};
 use axfs_ng_vfs::{
     DirEntry, DirNode, Filesystem, FilesystemOps, Reference, StatFs, VfsResult, path::MAX_NAME_LEN,
 };
@@ -63,18 +64,28 @@ impl Ext4Filesystem {
 
     /// Locks the shared rsext4 state.
     ///
-    /// rsext4 operations may allocate, flush caches, commit journal state, and
-    /// call into the block device while this guard is held. The current rootfs
-    /// setup can also run in early atomic contexts where a blocking mutex trips
-    /// `might_sleep()`, so use `SpinNoIrq` instead of the older
-    /// `SpinNoPreempt` to close same-CPU IRQ reentry without changing the
-    /// boot-time calling contract.
+    /// In task context (IRQs enabled) this uses the blocking
+    /// `ax_sync::Mutex::lock`, sleeping on contention and freeing the
+    /// CPU for other tasks.  During boot / shutdown IRQs may still be
+    /// disabled — fall back to spinning with `try_lock` so that
+    /// `might_sleep()` does not panic.
     pub(crate) fn lock(&self) -> MutexGuard<'_, Ext4State> {
-        self.inner.lock()
+        if ax_hal::asm::irqs_enabled() {
+            // Task context — sleep on contention.
+            self.inner.lock()
+        } else {
+            // Atomic context (boot / shutdown) — spin.
+            loop {
+                if let Some(guard) = self.inner.try_lock() {
+                    return guard;
+                }
+                core::hint::spin_loop();
+            }
+        }
     }
 
     pub(crate) fn sync_to_disk(&self) -> VfsResult<()> {
-        let mut state = self.inner.lock();
+        let mut state = self.lock();
         let (fs, dev) = state.split();
         fs.datablock_cache.flush_all(dev).map_err(into_vfs_err)?;
         fs.bitmap_cache.flush_all(dev).map_err(into_vfs_err)?;