perf(virtiofs): batch non-DAX writeback (#2122)

* perf(virtiofs): batch non-DAX writeback

Buffer writes in the generic page cache only after FUSE_WRITEBACK_CACHE is negotiated, then claim and submit bounded contiguous batches according to the negotiated write and page limits.

Preserve Linux-compatible fsync, close, truncate, mmap, invalidation, stable EOF, redirty, short-write, and errseq behavior. Separate terminal writeback completion from generic page-cache workers so host invalidation cannot strand published Writeback pages behind its own waiters.

Harden kernel-thread creation and wakeup ordering required by the new worker pools. Add exact FUSE/page-cache counters, benchmark phase reporting, focused FUSE regressions, and root-only kthread and completion-domain selftests.

Validated with make kernel -j2, kernel formatting and diff checks, the completion-domain selftest, targeted close/flush coverage, and FuseExtended 69/69 in a DragonOS guest.

Signed-off-by: longjin <longjin@dragonos.org>

* refactor(fuse): group negotiated io limits

Pass negotiated read, write, page, capability, and effective payload limits through a dedicated stats value object.

This keeps the INIT statistics update cohesive and satisfies the project-wide Clippy argument-count lint enforced by make fmt without changing the negotiated values or publication ordering.

Signed-off-by: longjin <longjin@dragonos.org>

---------

Signed-off-by: longjin <longjin@dragonos.org>

Author: fslongjin

kernel/src/arch/riscv64/process/kthread.rs

@@ -58,10 +58,6 @@ impl KernelThreadMechanism {
             e
         })?;
 
-        let pcb = ProcessManager::find(pid).unwrap();
-        pcb.set_name(info.name().clone());
-        info.setup_pcb(&pcb);
-
         return Ok(pid);
     }
 }

kernel/src/arch/x86_64/process/kthread.rs

@@ -59,10 +59,6 @@ impl KernelThreadMechanism {
             unsafe { KernelThreadCreateInfo::parse_unsafe_arc_ptr(create_info) };
         })?;
 
-        let pcb = ProcessManager::find_task_by_vpid(pid).unwrap();
-        pcb.set_name(info.name().clone());
-        info.setup_pcb(&pcb);
-
         return Ok(pid);
     }
 }

kernel/src/debug/kthread.rs

@@ -0,0 +1,75 @@
+use alloc::{string::String, string::ToString};
+
+use system_error::SystemError;
+
+use crate::{
+    debug::sysfs::debugfs_kobj,
+    driver::base::kobject::KObject,
+    filesystem::{
+        kernfs::callback::{KernCallbackData, KernFSCallback, KernFilePrivateData},
+        vfs::{InodeMode, PollStatus},
+    },
+};
+
+#[derive(Debug)]
+struct KthreadSelftestCallback;
+
+impl KernFSCallback for KthreadSelftestCallback {
+    fn open(&self, mut data: KernCallbackData) -> Result<(), SystemError> {
+        let report = crate::process::kthread::run_debug_selftests()?;
+        data.file_private_data_mut()
+            .replace(KernFilePrivateData::DebugTextSnapshot(report));
+        Ok(())
+    }
+
+    fn read(
+        &self,
+        data: KernCallbackData,
+        buf: &mut [u8],
+        offset: usize,
+    ) -> Result<usize, SystemError> {
+        let report: &String = match data.file_private_data() {
+            Some(KernFilePrivateData::DebugTextSnapshot(report)) => report,
+            _ => return Err(SystemError::EINVAL),
+        };
+        let bytes = report.as_bytes();
+        if offset >= bytes.len() {
+            return Ok(0);
+        }
+        let len = buf.len().min(bytes.len() - offset);
+        buf[..len].copy_from_slice(&bytes[offset..offset + len]);
+        Ok(len)
+    }
+
+    fn write(
+        &self,
+        _data: KernCallbackData,
+        _buf: &[u8],
+        _offset: usize,
+    ) -> Result<usize, SystemError> {
+        Err(SystemError::EPERM)
+    }
+
+    fn poll(&self, _data: KernCallbackData) -> Result<PollStatus, SystemError> {
+        Ok(PollStatus::READ)
+    }
+}
+
+pub fn init_debugfs_kthread() -> Result<(), SystemError> {
+    let debugfs = debugfs_kobj();
+    let root = debugfs.inode().ok_or(SystemError::ENOENT)?;
+    let kthread = root.add_dir(
+        "kthread".to_string(),
+        InodeMode::from_bits_truncate(0o555),
+        None,
+        None,
+    )?;
+    kthread.add_file(
+        "selftest".to_string(),
+        InodeMode::S_IRUSR,
+        Some(4096),
+        None,
+        Some(&KthreadSelftestCallback),
+    )?;
+    Ok(())
+}

kernel/src/debug/mod.rs

@@ -4,6 +4,8 @@ pub mod fuse;
 pub mod jump_label;
 pub mod klog;
 pub mod kprobe;
+pub mod kthread;
+pub mod page_cache;
 pub mod panic;
 pub mod rcu;
 pub mod sysfs;

kernel/src/debug/page_cache.rs

@@ -0,0 +1,75 @@
+use alloc::{string::String, string::ToString};
+
+use system_error::SystemError;
+
+use crate::{
+    debug::sysfs::debugfs_kobj,
+    driver::base::kobject::KObject,
+    filesystem::{
+        kernfs::callback::{KernCallbackData, KernFSCallback, KernFilePrivateData},
+        vfs::{InodeMode, PollStatus},
+    },
+};
+
+#[derive(Debug)]
+struct PageCacheCompletionSelftestCallback;
+
+impl KernFSCallback for PageCacheCompletionSelftestCallback {
+    fn open(&self, mut data: KernCallbackData) -> Result<(), SystemError> {
+        let report = crate::filesystem::page_cache::run_completion_domain_debug_selftest()?;
+        data.file_private_data_mut()
+            .replace(KernFilePrivateData::DebugTextSnapshot(report));
+        Ok(())
+    }
+
+    fn read(
+        &self,
+        data: KernCallbackData,
+        buf: &mut [u8],
+        offset: usize,
+    ) -> Result<usize, SystemError> {
+        let report: &String = match data.file_private_data() {
+            Some(KernFilePrivateData::DebugTextSnapshot(report)) => report,
+            _ => return Err(SystemError::EINVAL),
+        };
+        let bytes = report.as_bytes();
+        if offset >= bytes.len() {
+            return Ok(0);
+        }
+        let len = buf.len().min(bytes.len() - offset);
+        buf[..len].copy_from_slice(&bytes[offset..offset + len]);
+        Ok(len)
+    }
+
+    fn write(
+        &self,
+        _data: KernCallbackData,
+        _buf: &[u8],
+        _offset: usize,
+    ) -> Result<usize, SystemError> {
+        Err(SystemError::EPERM)
+    }
+
+    fn poll(&self, _data: KernCallbackData) -> Result<PollStatus, SystemError> {
+        Ok(PollStatus::READ)
+    }
+}
+
+pub fn init_debugfs_page_cache() -> Result<(), SystemError> {
+    let debugfs = debugfs_kobj();
+    let root = debugfs.inode().ok_or(SystemError::ENOENT)?;
+    let page_cache = root.add_dir(
+        "page_cache".to_string(),
+        InodeMode::from_bits_truncate(0o555),
+        None,
+        None,
+    )?;
+    page_cache.add_file(
+        "completion_domain_selftest".to_string(),
+        InodeMode::S_IRUSR,
+        Some(4096),
+        None,
+        Some(&PageCacheCompletionSelftestCallback),
+    )?;
+    Ok(())
+}

kernel/src/debug/sysfs/mod.rs

@@ -25,6 +25,8 @@ fn debugfs_init() -> Result<(), SystemError> {
     super::errseq::init_debugfs_errseq()?;
     super::ext4::init_debugfs_ext4()?;
     super::fuse::init_debugfs_fuse()?;
+    super::kthread::init_debugfs_kthread()?;
+    super::page_cache::init_debugfs_page_cache()?;
     return Ok(());
 }
 

kernel/src/filesystem/fuse/conn/daemon.rs

@@ -4,7 +4,11 @@ use core::{mem::size_of, sync::atomic::Ordering};
 use num_traits::FromPrimitive;
 use system_error::SystemError;
 
-use crate::filesystem::epoll::{EPollEventType, EPollItem};
+use crate::{
+    arch::MMArch,
+    filesystem::epoll::{EPollEventType, EPollItem},
+    mm::MemoryManagementArch,
+};
 
 use super::super::protocol::{
     fuse_read_struct, FuseAttrOut, FuseEntryOut, FuseInHeader, FuseInitOut, FuseNotifyDeleteOut,
@@ -15,7 +19,7 @@ use super::super::protocol::{
     FUSE_MAP_ALIGNMENT, FUSE_MAX_PAGES, FUSE_MIN_READ_BUFFER, FUSE_MKDIR, FUSE_MKNOD,
     FUSE_NOTIFY_DELETE, FUSE_NOTIFY_INVAL_ENTRY, FUSE_NOTIFY_INVAL_INODE, FUSE_NOTIFY_POLL,
     FUSE_NOTIFY_RETRIEVE, FUSE_NOTIFY_STORE, FUSE_READ, FUSE_REMOVEXATTR, FUSE_SETATTR,
-    FUSE_SETXATTR, FUSE_STATFS, FUSE_SYMLINK,
+    FUSE_SETXATTR, FUSE_STATFS, FUSE_SYMLINK, FUSE_WRITEBACK_CACHE,
 };
 use super::{
     stats, trace, wait_with_recheck, FuseConn, FuseConnInner, FuseInitNegotiated, FuseRequest,
@@ -615,13 +619,23 @@ impl FuseConn {
             })?;
             self.background
                 .configure(max_background, congestion_threshold);
-            stats::on_fuse_read_limits_negotiated(
-                self.max_read(),
-                negotiated_max_pages as usize,
-                init_out.max_readahead as usize,
-                (enabled_flags & FUSE_ASYNC_READ) != 0,
-                self.effective_read_payload_limit(),
-            );
+            stats::on_fuse_io_limits_negotiated(stats::NegotiatedFuseIoLimits {
+                max_read: self.max_read(),
+                max_write: self.max_write(),
+                max_pages: negotiated_max_pages as usize,
+                max_readahead: init_out.max_readahead as usize,
+                async_read: (enabled_flags & FUSE_ASYNC_READ) != 0,
+                writeback_cache: (enabled_flags & FUSE_WRITEBACK_CACHE) != 0,
+                effective_read_payload_limit: self.effective_read_payload_limit(),
+                effective_write_payload_limit: core::cmp::min(
+                    core::cmp::min(
+                        negotiated_max_pages as usize,
+                        self.max_write() / MMArch::PAGE_SIZE,
+                    ),
+                    64,
+                )
+                .saturating_mul(MMArch::PAGE_SIZE),
+            });
             self.init_wait.wakeup(None);
         } else {
             self.claim_pending_reply(out_hdr.unique, &pending, |_| {})?;

kernel/src/filesystem/fuse/fs.rs

@@ -31,6 +31,7 @@ use super::{
         fuse_read_struct, FuseStatfsOut, FOPEN_DIRECT_IO, FUSE_ATTR_SUBMOUNT, FUSE_ROOT_ID,
         FUSE_STATFS,
     },
+    stats,
 };
 
 #[derive(Debug)]
@@ -843,20 +844,40 @@ impl FileSystem for FuseFS {
             p.node.clone()
         };
 
-        node.with_writeback_admission(|| {
+        let mut result = VmFaultReason::VM_FAULT_SIGBUS;
+        let admitted = node.try_with_writeback_admission(&mut || {
             let Ok(_pin) = node.pin_writeback_handle() else {
-                return VmFaultReason::VM_FAULT_SIGBUS;
+                return Ok(());
+            };
+            let Some(metadata) = node.cached_metadata_snapshot() else {
+                return Ok(());
             };
-            let result = PageFaultHandler::filemap_page_mkwrite(pfm);
+            result = PageFaultHandler::filemap_page_mkwrite_with_stable_size(
+                pfm,
+                metadata.size.max(0) as usize,
+            );
             if !result.intersects(
                 VmFaultReason::VM_FAULT_SIGBUS
                     | VmFaultReason::VM_FAULT_OOM
                     | VmFaultReason::VM_FAULT_RETRY,
             ) {
                 node.note_mmap_write();
             }
-            result
-        })
+            Ok(())
+        });
+        match admitted {
+            Ok(true) => result,
+            Ok(false) => {
+                // Never block on a writer-preferred admission semaphore while
+                // the architecture fault path owns AddressSpace::write(). The
+                // retry waiter acquires/releases it only after the MM guard is
+                // dropped, closing the barrier<->mkclean cycle.
+                stats::on_mmap_writeback_admission_retry();
+                pfm.set_retry_wait(node.writeback_admission_retry_wait());
+                VmFaultReason::VM_FAULT_RETRY
+            }
+            Err(_) => VmFaultReason::VM_FAULT_SIGBUS,
+        }
     }
 
     fn mprotect(&self, _old_vm_flags: VmFlags, new_vm_flags: VmFlags) -> Result<(), SystemError> {