strat9_kernel/vfs/

procfs.rs

//! Procfs - process filesystem (similar to Linux & BSD /proc)
//!
//! Provides information about running processes and system state.
//!
//! # Structure
//!
//! ```text
//! /proc/
//!   self/       -> symlink to current process
//!   <pid>/      -> process directory
//!     status    -> process status
//!     cmdline   -> command line
//!     fd/       -> file descriptors
//!   cpuinfo     -> CPU information
//!   meminfo     -> memory information
//!   version     -> kernel version
//! ```

use crate::{
    process::{current_pid, get_all_tasks, get_parent_pid},
    silo,
    syscall::error::SyscallError,
    vfs::scheme::{
        finalize_pseudo_stat, DirEntry, FileFlags, FileStat, OpenFlags, OpenResult, Scheme,
        DEV_PROCFS, DT_DIR, DT_REG,
    },
};
use alloc::{format, string::String, sync::Arc, vec::Vec};
use core::fmt::Write;

/// Procfs scheme
pub struct ProcScheme {
    // Empty for now - stateless
}

impl ProcScheme {
    /// Creates a new instance.
    pub fn new() -> Self {
        ProcScheme {}
    }

    /// Get procfs entry content
    fn get_entry(&self, path: &str) -> Result<ProcEntry, SyscallError> {
        // Handle /proc/self
        if path == "self" || path == "self/" {
            if let Some(pid) = current_pid() {
                return Ok(ProcEntry::File(format!("{}\n", pid)));
            }
            return Err(SyscallError::NotFound);
        }

        // Handle /proc/self/status
        if path.starts_with("self/") {
            let subpath = &path[5..];
            if let Some(pid) = current_pid() {
                return self.get_process_entry(pid as u64, subpath);
            }
            return Err(SyscallError::NotFound);
        }

        // Handle /proc/<pid>/...
        if let Some(pid_end) = path.find('/') {
            let pid_str = &path[..pid_end];
            let subpath = &path[pid_end + 1..];
            if let Ok(pid) = pid_str.parse::<u64>() {
                return self.get_process_entry(pid, subpath);
            }
        }

        // Handle /proc/<pid> (directory listing)
        if path.parse::<u64>().is_ok() {
            return Ok(ProcEntry::Directory);
        }

        // Handle root entries
        match path {
            "" | "/" => Ok(ProcEntry::Directory),
            "cpuinfo" => Ok(ProcEntry::File(self.get_cpuinfo())),
            "meminfo" => Ok(ProcEntry::File(self.get_meminfo())),
            "version" => Ok(ProcEntry::File(self.get_version())),
            "silos" => Ok(ProcEntry::File(self.get_silos())),
            _ => Err(SyscallError::NotFound),
        }
    }

    /// Get process-specific entry
    fn get_process_entry(&self, pid: u64, subpath: &str) -> Result<ProcEntry, SyscallError> {
        let tasks = get_all_tasks().ok_or(SyscallError::NotFound)?;
        let task = tasks
            .iter()
            .find(|t| t.pid as u64 == pid)
            .ok_or(SyscallError::NotFound)?;

        match subpath {
            "" | "/" => Ok(ProcEntry::Directory),
            "status" => Ok(ProcEntry::File(self.get_process_status(task))),
            "cmdline" => Ok(ProcEntry::File(format!("{}\n", task.name))),
            _ => Err(SyscallError::NotFound),
        }
    }

    /// Generate /proc/cpuinfo content from actual CPUID data.
    fn get_cpuinfo(&self) -> String {
        let mut output = String::new();
        let cpu_count = crate::arch::x86_64::percpu::get_cpu_count();
        let host = crate::arch::x86_64::cpuid::host();
        let flags = crate::arch::x86_64::cpuid::features_to_flags_string(host.features);
        let has_fpu = host
            .features
            .contains(crate::arch::x86_64::cpuid::CpuFeatures::FPU);

        for i in 0..cpu_count {
            let _ = writeln!(output, "processor\t: {}", i);
            let _ = writeln!(output, "vendor_id\t: {}", host.vendor_string());
            let _ = writeln!(output, "cpu family\t: {}", host.family);
            let _ = writeln!(output, "model\t\t: {}", host.model);
            let _ = writeln!(output, "model name\t: {}", host.model_name_str());
            let _ = writeln!(output, "stepping\t: {}", host.stepping);
            let _ = writeln!(output, "cpu MHz\t\t: 2400.000");
            let _ = writeln!(output, "cache size\t: 4096 KB");
            let _ = writeln!(output, "physical id\t: {}", i);
            let _ = writeln!(output, "siblings\t: 1");
            let _ = writeln!(output, "core id\t\t: {}", i);
            let _ = writeln!(output, "cpu cores\t: 1");
            let _ = writeln!(output, "apicid\t\t: {}", i);
            let _ = writeln!(output, "fpu\t\t: {}", if has_fpu { "yes" } else { "no" });
            let _ = writeln!(
                output,
                "fpu_exception\t: {}",
                if has_fpu { "yes" } else { "no" }
            );
            let _ = writeln!(output, "cpuid level\t: 13");
            let _ = writeln!(output, "wp\t\t: yes");
            let _ = writeln!(output, "flags\t\t: {}", flags);
            let _ = writeln!(output, "bogomips\t: 4800.00");
            let _ = writeln!(output, "clflush size\t: 64");
            let _ = writeln!(output, "cache_alignment\t: 64");
            let _ = writeln!(output, "address sizes\t: 40 bits physical, 48 bits virtual");
            let _ = writeln!(output, "power management:\n");
            let _ = writeln!(output, "");
        }

        output
    }

    /// Generate /proc/meminfo content
    fn get_meminfo(&self) -> String {
        // Simplified meminfo for now
        let mut output = String::new();
        let _ = writeln!(output, "MemTotal:       {:>10} kB", 262144); // 256 MB default
        let _ = writeln!(output, "MemFree:        {:>10} kB", 131072);
        let _ = writeln!(output, "MemUsed:        {:>10} kB", 131072);
        let _ = writeln!(output, "Buffers:               0 kB");
        let _ = writeln!(output, "Cached:                0 kB");
        let _ = writeln!(output, "SwapTotal:             0 kB");
        let _ = writeln!(output, "SwapFree:              0 kB");
        output
    }

    /// Generate /proc/version content
    fn get_version(&self) -> String {
        format!("Strat9-OS version 0.1.0 (Bedrock) #1 SMP x86_64 Strat9\n")
    }

    /// Generate /proc/silos content
    fn get_silos(&self) -> String {
        let mut output = String::new();
        let mut silos = silo::list_silos_snapshot();
        silos.sort_by_key(|s| s.id);
        let _ = writeln!(
            output,
            "id\tstate\ttasks\tmem_used\tmem_min\tmem_max\tgfx_flags\tgfx_sessions\tgfx_ttl\tlabel\tname"
        );
        for s in silos {
            let label = s.strate_label.unwrap_or_else(|| String::from("-"));
            let max = if s.mem_max_bytes == 0 {
                String::from("unlimited")
            } else {
                format!("{}", s.mem_max_bytes)
            };
            let _ = writeln!(
                output,
                "{}\t{:?}\t{}\t{}\t{}\t{}\t{}\t{}\t{}\t{}\t{}",
                s.id,
                s.state,
                s.task_count,
                s.mem_usage_bytes,
                s.mem_min_bytes,
                max,
                s.graphics_flags,
                s.graphics_max_sessions,
                s.graphics_session_ttl_sec,
                label,
                s.name
            );
        }
        output
    }

    /// Generate process status
    fn get_process_status(&self, task: &Arc<crate::process::task::Task>) -> String {
        let mut output = String::new();

        let _ = writeln!(output, "Name:\t{}", task.name);
        let _ = writeln!(output, "State:\tR (running)");
        let _ = writeln!(output, "Tgid:\t{}", task.tgid);
        let _ = writeln!(output, "Pid:\t{}", task.pid);
        let _ = writeln!(
            output,
            "PPid:\t{}",
            get_parent_pid(task.id).map(|p| p as u64).unwrap_or(0)
        );
        let _ = writeln!(
            output,
            "Pgid:\t{}",
            task.pgid.load(core::sync::atomic::Ordering::Relaxed)
        );
        let _ = writeln!(
            output,
            "Sid:\t{}",
            task.sid.load(core::sync::atomic::Ordering::Relaxed)
        );
        let uid = task.uid.load(core::sync::atomic::Ordering::Relaxed);
        let euid = task.euid.load(core::sync::atomic::Ordering::Relaxed);
        let gid = task.gid.load(core::sync::atomic::Ordering::Relaxed);
        let egid = task.egid.load(core::sync::atomic::Ordering::Relaxed);
        let _ = writeln!(output, "Uid:\t{}\t{}\t{}\t{}", uid, euid, euid, euid);
        let _ = writeln!(output, "Gid:\t{}\t{}\t{}\t{}", gid, egid, egid, egid);
        let _ = writeln!(output, "Threads:\t1");
        if let Some((silo_id, label, mem_used, mem_min, mem_max)) =
            silo::silo_info_for_task(task.id)
        {
            let label = label.unwrap_or_else(|| String::from("-"));
            let _ = writeln!(output, "SiloId:\t{}", silo_id);
            let _ = writeln!(output, "SiloLabel:\t{}", label);
            let _ = writeln!(output, "SiloMemUsed:\t{}", mem_used);
            let _ = writeln!(output, "SiloMemMin:\t{}", mem_min);
            if mem_max == 0 {
                let _ = writeln!(output, "SiloMemMax:\tunlimited");
            } else {
                let _ = writeln!(output, "SiloMemMax:\t{}", mem_max);
            }
        }

        output
    }
}

/// Procfs entry type
#[allow(dead_code)]
enum ProcEntry {
    File(String),
    Directory,
}

/// Kind constants for procfs file-id encoding.
/// Fixed IDs (0, 1, 10, 11, 12) use kind = 0 and are stored as-is.
const KIND_PROC_DIR: u64 = 1; // /proc/<pid>  directory
const KIND_PROC_STATUS: u64 = 2; // /proc/<pid>/status
const KIND_PROC_CMDLINE: u64 = 3; // /proc/<pid>/cmdline

impl ProcScheme {
    /// Encode a (kind, pid) pair into a file_id.
    ///
    /// The high 32 bits hold the kind; the low 32 bits hold the pid.
    /// This guarantees no collision between entries regardless of PID value.
    fn encode_id(kind: u64, pid: u64) -> u64 {
        (kind << 32) | (pid & 0xFFFF_FFFF)
    }

    /// Decode a file_id back into (kind, pid).
    fn decode_id(id: u64) -> (u64, u64) {
        (id >> 32, id & 0xFFFF_FFFF)
    }
}

impl Scheme for ProcScheme {
    /// Performs the open operation.
    fn open(&self, path: &str, _flags: OpenFlags) -> Result<OpenResult, SyscallError> {
        let entry = self.get_entry(path)?;

        let (flags, file_id) = match entry {
            ProcEntry::File(_) => {
                let id = match path {
                    "cpuinfo" => 10,
                    "meminfo" => 11,
                    "version" => 12,
                    "silos" => 13,
                    "self/status" => Self::encode_id(
                        KIND_PROC_STATUS,
                        current_pid().map(|p| p as u64).unwrap_or(0),
                    ),
                    "self/cmdline" => Self::encode_id(
                        KIND_PROC_CMDLINE,
                        current_pid().map(|p| p as u64).unwrap_or(0),
                    ),
                    _ if path.starts_with("self") => 1,
                    _ => {
                        if let Some(slash_idx) = path.find('/') {
                            let pid_str = &path[..slash_idx];
                            let sub = &path[slash_idx + 1..];
                            if let Ok(pid) = pid_str.parse::<u64>() {
                                match sub {
                                    "status" => Self::encode_id(KIND_PROC_STATUS, pid),
                                    "cmdline" => Self::encode_id(KIND_PROC_CMDLINE, pid),
                                    _ => 0xFFFF,
                                }
                            } else {
                                0xFFFF
                            }
                        } else {
                            0xFFFF
                        }
                    }
                };
                (FileFlags::empty(), id)
            }
            ProcEntry::Directory => {
                let id = if path.is_empty() || path == "/" {
                    0
                } else if path == "self" || path == "self/" {
                    1
                } else if let Ok(pid) = path.parse::<u64>() {
                    Self::encode_id(KIND_PROC_DIR, pid)
                } else {
                    2
                };
                (FileFlags::DIRECTORY, id)
            }
        };

        if file_id == 0xFFFF {
            return Err(SyscallError::NotFound);
        }

        Ok(OpenResult {
            file_id,
            size: None,
            flags,
        })
    }

    /// Performs the read operation.
    fn read(&self, file_id: u64, offset: u64, buf: &mut [u8]) -> Result<usize, SyscallError> {
        let (kind, pid) = Self::decode_id(file_id);
        let content = if file_id == 0 {
            // Root directory listing
            let mut list = String::from("self\ncpuinfo\nmeminfo\nversion\n");
            if let Some(tasks) = get_all_tasks() {
                for task in tasks {
                    let _ = writeln!(list, "{}", task.pid);
                }
            }
            list
        } else if file_id == 1 || kind == KIND_PROC_DIR {
            // Process directory listing (self dir or /proc/<pid>)
            String::from("status\ncmdline\n")
        } else {
            // File content — distinguish by kind (high 32 bits) for process files,
            // or by the literal file_id for well-known fixed files.
            match (kind, file_id) {
                (0, 10) => self.get_cpuinfo(),
                (0, 11) => self.get_meminfo(),
                (0, 12) => self.get_version(),
                (0, 13) => self.get_silos(),
                (KIND_PROC_STATUS, _) => {
                    let tasks = get_all_tasks().ok_or(SyscallError::NotFound)?;
                    let task = tasks
                        .iter()
                        .find(|t| t.pid as u64 == pid)
                        .ok_or(SyscallError::NotFound)?;
                    self.get_process_status(task)
                }
                (KIND_PROC_CMDLINE, _) => {
                    let tasks = get_all_tasks().ok_or(SyscallError::NotFound)?;
                    let task = tasks
                        .iter()
                        .find(|t| t.pid as u64 == pid)
                        .ok_or(SyscallError::NotFound)?;
                    format!("{}\n", task.name)
                }
                _ => return Err(SyscallError::IoError),
            }
        };

        if offset >= content.len() as u64 {
            return Ok(0);
        }

        let start = offset as usize;
        let end = core::cmp::min(start + buf.len(), content.len());
        let to_copy = end - start;

        buf[..to_copy].copy_from_slice(&content.as_bytes()[start..end]);
        Ok(to_copy)
    }

    /// Performs the write operation.
    fn write(&self, _file_id: u64, _offset: u64, _buf: &[u8]) -> Result<usize, SyscallError> {
        Err(SyscallError::PermissionDenied)
    }

    /// Performs the close operation.
    fn close(&self, _file_id: u64) -> Result<(), SyscallError> {
        Ok(())
    }

    /// Performs the stat operation.
    fn stat(&self, file_id: u64) -> Result<FileStat, SyscallError> {
        let (kind, _pid) = Self::decode_id(file_id);
        let is_dir = file_id == 0 || file_id == 1 || kind == KIND_PROC_DIR;
        let mut st = if is_dir {
            FileStat {
                st_ino: file_id,
                st_mode: 0o040555,
                st_nlink: 2,
                st_size: 0,
                st_blksize: 512,
                st_blocks: 0,
                ..FileStat::zeroed()
            }
        } else {
            FileStat {
                st_ino: file_id,
                st_mode: 0o100444,
                st_nlink: 1,
                st_size: 0,
                st_blksize: 512,
                st_blocks: 0,
                ..FileStat::zeroed()
            }
        };

        let (kind, pid) = Self::decode_id(file_id);
        let per_process_node =
            kind == KIND_PROC_DIR || kind == KIND_PROC_STATUS || kind == KIND_PROC_CMDLINE;
        if per_process_node && pid != 0 {
            if let Some(tasks) = get_all_tasks() {
                if let Some(task) = tasks.iter().find(|t| t.pid as u64 == pid) {
                    st.st_uid = task.uid.load(core::sync::atomic::Ordering::Relaxed);
                    st.st_gid = task.gid.load(core::sync::atomic::Ordering::Relaxed);
                }
            }
        }
        Ok(finalize_pseudo_stat(st, DEV_PROCFS, 0))
    }

    /// Performs the readdir operation.
    fn readdir(&self, file_id: u64) -> Result<Vec<DirEntry>, SyscallError> {
        let (kind, pid) = Self::decode_id(file_id);
        if file_id == 0 {
            let mut entries = Vec::new();
            entries.push(DirEntry {
                ino: 1,
                file_type: DT_DIR,
                name: String::from("self"),
            });
            entries.push(DirEntry {
                ino: 10,
                file_type: DT_REG,
                name: String::from("cpuinfo"),
            });
            entries.push(DirEntry {
                ino: 11,
                file_type: DT_REG,
                name: String::from("meminfo"),
            });
            entries.push(DirEntry {
                ino: 12,
                file_type: DT_REG,
                name: String::from("version"),
            });
            entries.push(DirEntry {
                ino: 13,
                file_type: DT_REG,
                name: String::from("silos"),
            });
            if let Some(tasks) = get_all_tasks() {
                for task in tasks {
                    entries.push(DirEntry {
                        ino: Self::encode_id(KIND_PROC_DIR, task.pid as u64),
                        file_type: DT_DIR,
                        name: format!("{}", task.pid),
                    });
                }
            }
            Ok(entries)
        } else if file_id == 1 || kind == KIND_PROC_DIR {
            let effective_pid = if file_id == 1 {
                current_pid().map(|p| p as u64).unwrap_or(0)
            } else {
                pid
            };
            Ok(alloc::vec![
                DirEntry {
                    ino: Self::encode_id(KIND_PROC_STATUS, effective_pid),
                    file_type: DT_REG,
                    name: String::from("status"),
                },
                DirEntry {
                    ino: Self::encode_id(KIND_PROC_CMDLINE, effective_pid),
                    file_type: DT_REG,
                    name: String::from("cmdline"),
                },
            ])
        } else {
            Err(SyscallError::InvalidArgument)
        }
    }
}