fix(mm): balance page cache membership accounting (#2131)

* fix(mm): balance page cache membership accounting

Track immutable file and shmem membership on each page-cache entry so removal and final cache teardown can update VM counters exactly once without upgrading an owner that is already being destroyed.

Keep dirty, writeback, and unevictable accounting tied to the currently mapped entry. Revalidate entry identity across truncate and writeback completion, and require the legacy reclaimer to claim the expected physical page before submitting stale snapshots.

Preserve the existing PageEntry layout, use vacant-only insertion, and align tmpfs construction with immutable shmem classification. Add a debugfs accounting selftest and dunitest coverage for membership, inflight teardown, late completion, aggregate VM wiring, and layout stability.

Validated with make fmt, make kernel, the page-cache accounting dunitest, FUSE core and extended suites, repeated non-DAX VirtioFS mount/read/unmount beyond guest RAM, and CubeSandbox master/candidate performance checks.

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

Author: fslongjin

kernel/src/debug/page_cache.rs

@@ -14,6 +14,9 @@ use crate::{
 #[derive(Debug)]
 struct PageCacheCompletionSelftestCallback;
 
+#[derive(Debug)]
+struct PageCacheAccountingSelftestCallback;
+
 impl KernFSCallback for PageCacheCompletionSelftestCallback {
     fn open(&self, mut data: KernCallbackData) -> Result<(), SystemError> {
         let report = crate::filesystem::page_cache::run_completion_domain_debug_selftest()?;
@@ -55,6 +58,47 @@ impl KernFSCallback for PageCacheCompletionSelftestCallback {
     }
 }
 
+impl KernFSCallback for PageCacheAccountingSelftestCallback {
+    fn open(&self, mut data: KernCallbackData) -> Result<(), SystemError> {
+        let report = crate::filesystem::page_cache::run_accounting_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)?;
@@ -71,5 +115,12 @@ pub fn init_debugfs_page_cache() -> Result<(), SystemError> {
         None,
         Some(&PageCacheCompletionSelftestCallback),
     )?;
+    page_cache.add_file(
+        "accounting_selftest".to_string(),
+        InodeMode::S_IRUSR,
+        Some(4096),
+        None,
+        Some(&PageCacheAccountingSelftestCallback),
+    )?;
     Ok(())
 }