feat(procfs): 新增/proc/<pid>/stat和/proc/<pid>/task支持 (#1490)

- 添加/proc/<pid>/stat文件生成，支持BusyBox ps/pstree/top等工具
- 实现/proc/<pid>/task目录结构，支持主线程tid=pid的展示
- 新增proc_pid_stat和proc_pid_task模块处理相关逻辑
- 扩展ProcFileType枚举，添加ProcPidStat、ProcPidTaskDir等类型
- 在InodeInfo中新增tid字段以支持线程信息

Signed-off-by: longjin <[email protected]>

Author: fslongjin

kernel/src/filesystem/procfs/mod.rs

@@ -53,6 +53,8 @@ mod proc_cpuinfo;
 mod proc_maps;
 mod proc_mounts;
 mod proc_pid_cmdline;
+mod proc_pid_stat;
+mod proc_pid_task;
 mod proc_thread_self_ns;
 mod proc_version;
 mod procfs_setup;
@@ -92,6 +94,14 @@ pub enum ProcFileType {
     ProcCmdline,
     /// /proc/<pid>/cmdline（也覆盖 /proc/self/cmdline）
     ProcPidCmdline,
+    /// /proc/<pid>/stat
+    ProcPidStat,
+    /// /proc/<pid>/task 目录
+    ProcPidTaskDir,
+    /// /proc/<pid>/task/<tid> 目录
+    ProcPidTaskTidDir,
+    /// /proc/<pid>/task/<tid>/stat 文件
+    ProcPidTaskTidStat,
     /// /proc/thread-self/ns itself
     ProcThreadSelfNsRoot,
     /// /proc/thread-self/ns/* namespace files
@@ -190,6 +200,8 @@ impl<'a> ProcFileCreationParamsBuilder<'a> {
 pub struct InodeInfo {
     ///进程的pid
     pid: Option<RawPid>,
+    /// 线程的 tid（用于 /proc/<pid>/task/<tid>）
+    tid: Option<RawPid>,
     ///文件类型
     ftype: ProcFileType,
     /// 文件描述符
@@ -203,6 +215,7 @@ impl core::fmt::Debug for InodeInfo {
     fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         f.debug_struct("InodeInfo")
             .field("pid", &self.pid)
+            .field("tid", &self.tid)
             .field("ftype", &self.ftype)
             .field("fd", &self.fd)
             .field("target_inode", &self.target_inode.is_some())
@@ -660,6 +673,7 @@ impl ProcFS {
                 fs: Weak::default(),
                 fdata: InodeInfo {
                     pid: None,
+                    tid: None,
                     ftype: ProcFileType::Default,
                     fd: -1,
                     target_inode: None,
@@ -729,6 +743,15 @@ impl ProcFS {
         statm_file.0.lock().fdata.pid = Some(pid);
         statm_file.0.lock().fdata.ftype = ProcFileType::ProcStatm;
 
+        // stat 文件: /proc/<pid>/stat
+        let stat_binding = pid_dir.create("stat", FileType::File, InodeMode::S_IRUGO)?;
+        let stat_file = stat_binding
+            .as_any_ref()
+            .downcast_ref::<LockedProcFSInode>()
+            .unwrap();
+        stat_file.0.lock().fdata.pid = Some(pid);
+        stat_file.0.lock().fdata.ftype = ProcFileType::ProcPidStat;
+
         // maps 文件
         let maps_binding = pid_dir.create("maps", FileType::File, InodeMode::S_IRUGO)?;
         let maps_file = maps_binding
@@ -747,6 +770,16 @@ impl ProcFS {
         cmdline_file.0.lock().fdata.pid = Some(pid);
         cmdline_file.0.lock().fdata.ftype = ProcFileType::ProcPidCmdline;
 
+        // task dir: /proc/<pid>/task
+        let task_dir =
+            pid_dir.create("task", FileType::Dir, InodeMode::from_bits_truncate(0o555))?;
+        let task_dir = task_dir
+            .as_any_ref()
+            .downcast_ref::<LockedProcFSInode>()
+            .unwrap();
+        task_dir.0.lock().fdata.pid = Some(pid);
+        task_dir.0.lock().fdata.ftype = ProcFileType::ProcPidTaskDir;
+
         // fd dir
         let fd = pid_dir.create("fd", FileType::Dir, InodeMode::from_bits_truncate(0o555))?;
         let fd = fd.as_any_ref().downcast_ref::<LockedProcFSInode>().unwrap();
@@ -797,6 +830,8 @@ impl ProcFS {
         // 删除进程文件夹下文件
         pid_dir.unlink("status")?;
         pid_dir.unlink("exe")?;
+        let _ = pid_dir.unlink("stat");
+        let _ = pid_dir.rmdir("task");
         pid_dir.rmdir("fd")?;
         pid_dir.rmdir("fdinfo")?;
         let _ = pid_dir.unlink("mounts");
@@ -985,6 +1020,8 @@ impl IndexNode for LockedProcFSInode {
             ProcFileType::ProcMaps => inode.open_maps(&mut proc_private)?,
             ProcFileType::ProcCmdline => inode.open_cmdline(&mut proc_private)?,
             ProcFileType::ProcPidCmdline => inode.open_pid_cmdline(&mut proc_private)?,
+            ProcFileType::ProcPidStat => inode.open_pid_stat(&mut proc_private)?,
+            ProcFileType::ProcPidTaskTidStat => inode.open_pid_task_tid_stat(&mut proc_private)?,
             ProcFileType::ProcExe => inode.open_exe(&mut proc_private)?,
             ProcFileType::ProcMounts => inode.open_mounts(&mut proc_private)?,
             ProcFileType::ProcMountInfo => {
@@ -1002,6 +1039,8 @@ impl IndexNode for LockedProcFSInode {
             }
             ProcFileType::Default => inode.data.len() as i64,
             ProcFileType::ProcKmsg
+            | ProcFileType::ProcPidTaskDir
+            | ProcFileType::ProcPidTaskTidDir
             | ProcFileType::ProcFdDir
             | ProcFileType::ProcFdFile
             | ProcFileType::ProcFdInfoDir
@@ -1076,6 +1115,8 @@ impl IndexNode for LockedProcFSInode {
             | ProcFileType::ProcMaps
             | ProcFileType::ProcCmdline
             | ProcFileType::ProcPidCmdline
+            | ProcFileType::ProcPidStat
+            | ProcFileType::ProcPidTaskTidStat
             | ProcFileType::ProcMounts
             | ProcFileType::ProcMountInfo
             | ProcFileType::ProcVersion
@@ -1243,6 +1284,7 @@ impl IndexNode for LockedProcFSInode {
                 fs: inode.fs.clone(),
                 fdata: InodeInfo {
                     pid: None,
+                    tid: None,
                     ftype: ProcFileType::Default,
                     fd: -1,
                     target_inode: None,
@@ -1369,6 +1411,12 @@ impl IndexNode for LockedProcFSInode {
                     ProcFileType::ProcThreadSelfNsRoot => {
                         return self.dynamical_find_thread_self_ns(name);
                     }
+                    ProcFileType::ProcPidTaskDir => {
+                        return self.dynamical_find_task_tid(name);
+                    }
+                    ProcFileType::ProcPidTaskTidDir => {
+                        return self.dynamical_find_task_tid_child(name);
+                    }
                     _ => {}
                 }
 
@@ -1457,6 +1505,11 @@ impl IndexNode for LockedProcFSInode {
 
                 return Ok(keys);
             }
+            ProcFileType::ProcPidTaskDir => {
+                let mut tids = self.dynamical_list_task_tids()?;
+                keys.append(&mut tids);
+                return Ok(keys);
+            }
             _ => {}
         }
 

kernel/src/filesystem/procfs/proc_pid_stat.rs

@@ -0,0 +1,146 @@
+use alloc::{
+    format,
+    string::{String, ToString},
+    sync::Arc,
+};
+use system_error::SystemError;
+
+use crate::{
+    arch::MMArch,
+    mm::MemoryManagementArch,
+    process::{pid::PidType, ProcessControlBlock, ProcessManager, ProcessState, RawPid},
+};
+
+use super::{ProcFSInode, ProcfsFilePrivateData};
+
+fn state_to_linux_char(state: ProcessState) -> char {
+    match state {
+        ProcessState::Runnable => 'R',
+        ProcessState::Blocked(interruptable) => {
+            if interruptable {
+                'S'
+            } else {
+                'D'
+            }
+        }
+        ProcessState::Stopped => 'T',
+        ProcessState::Exited(_) => 'Z',
+    }
+}
+
+fn sanitize_comm_for_proc_stat(comm: &str) -> String {
+    // BusyBox/procps 使用 strrchr(')') 定位 comm 结束位置。
+    // 若 comm 中包含 ')' 会破坏解析，先做最小替换。
+    comm.chars()
+        .map(|c| if c == ')' { '_' } else { c })
+        .collect()
+}
+
+fn generate_linux_proc_stat_line(
+    pid: RawPid,
+    comm: &str,
+    state: ProcessState,
+    ppid: RawPid,
+    pcb: &Arc<ProcessControlBlock>,
+) -> String {
+    // Linux /proc/[pid]/stat 字段：
+    // pid (comm) state ppid pgrp session tty_nr tpgid flags minflt cminflt majflt cmajflt
+    // utime stime cutime cstime priority nice num_threads itrealvalue starttime vsize rss ...
+    //
+    // BusyBox 1.35.0 只强依赖到 rss 字段位置，且字段顺序必须对齐。
+    let comm = sanitize_comm_for_proc_stat(comm);
+    let state_ch = state_to_linux_char(state);
+
+    // 尽量填真实值；拿不到的先填 0，不影响 BusyBox 解析，只影响输出质量。
+    let pgrp: usize = 0;
+    let session: usize = 0;
+    let tty_nr: i32 = 0;
+    let tpgid: i32 = 0;
+    let flags: u64 = 0;
+    let minflt: u64 = 0;
+    let cminflt: u64 = 0;
+    let majflt: u64 = 0;
+    let cmajflt: u64 = 0;
+    let utime: u64 = 0;
+    let stime: u64 = 0;
+    let cutime: i64 = 0;
+    let cstime: i64 = 0;
+    let priority: i64 = 0;
+    let nice: i64 = 0;
+    // Linux 语义：进程线程组中的线程数量（包含主线程）。
+    // 线程组成员由 Pid(TGID)->tasks[PidType::TGID] 维护；用它计数比本地缓存更可靠。
+    let num_threads: i64 = pcb
+        .task_pid_ptr(PidType::TGID)
+        .map(|tgid_pid| tgid_pid.tasks_iter(PidType::TGID).count() as i64)
+        .unwrap_or(1);
+    let itrealvalue: i64 = 0;
+    let starttime: u64 = 0;
+
+    // vsize: bytes, rss: pages
+    // 使用传入的 pcb，避免重复查找
+    let (vsize_bytes, rss_pages) = pcb
+        .basic()
+        .user_vm()
+        .map(|vm| {
+            let guard = vm.read();
+            let bytes = guard.vma_usage_bytes();
+            let pages = (bytes.saturating_add(MMArch::PAGE_SIZE - 1)) >> MMArch::PAGE_SHIFT;
+            (bytes as u64, pages as u64)
+        })
+        .unwrap_or((0, 0));
+
+    // rsslim 及后续字段给足占位，避免对方 parser 依赖更多字段时出问题
+    format!(
+        "{pid} ({comm}) {state_ch} {ppid} {pgrp} {session} {tty_nr} {tpgid} {flags} \
+{minflt} {cminflt} {majflt} {cmajflt} {utime} {stime} {cutime} {cstime} {priority} {nice} \
+{num_threads} {itrealvalue} {starttime} {vsize_bytes} {rss_pages} 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0\n",
+        pid = pid.data(),
+        ppid = ppid.data(),
+    )
+}
+
+impl ProcFSInode {
+    /// 生成进程 stat 信息的公共逻辑
+    fn generate_pid_stat_data(pid: RawPid) -> Result<String, SystemError> {
+        let pcb = ProcessManager::find_task_by_vpid(pid).ok_or(SystemError::ESRCH)?;
+
+        let comm = pcb.basic().name().to_string();
+        let sched = pcb.sched_info();
+        let state = sched.inner_lock_read_irqsave().state();
+
+        let ppid = pcb
+            .parent_pcb()
+            .map(|p| p.raw_pid())
+            .unwrap_or(RawPid::new(0));
+
+        Ok(generate_linux_proc_stat_line(pid, &comm, state, ppid, &pcb))
+    }
+
+    /// /proc/<pid>/stat
+    #[inline(never)]
+    pub(super) fn open_pid_stat(
+        &self,
+        pdata: &mut ProcfsFilePrivateData,
+    ) -> Result<i64, SystemError> {
+        let pid = self.fdata.pid.ok_or(SystemError::EINVAL)?;
+
+        let s = Self::generate_pid_stat_data(pid)?;
+        pdata.data = s.into_bytes();
+        Ok(pdata.data.len() as i64)
+    }
+
+    /// /proc/<pid>/task/<tid>/stat（最小实现：先按进程视图输出）
+    #[inline(never)]
+    pub(super) fn open_pid_task_tid_stat(
+        &self,
+        pdata: &mut ProcfsFilePrivateData,
+    ) -> Result<i64, SystemError> {
+        let pid = self.fdata.pid.ok_or(SystemError::EINVAL)?;
+        // 目前内核线程/用户线程还没有独立的 tid 视图，这里先占位：tid 仅用于路径匹配。
+        let _tid = self.fdata.tid.ok_or(SystemError::EINVAL)?;
+
+        let s = Self::generate_pid_stat_data(pid)?;
+        pdata.data = s.into_bytes();
+        Ok(pdata.data.len() as i64)
+    }
+}