use std::ffi::OsStr;
use std::os::unix::ffi::OsStrExt;
use std::path::Component;
use std::path::Path;
use detcore_model::config::ProcLevel;
const MINIMAL: &[&str] = &[
"cmdline",
"cpuinfo",
"filesystems",
"loadavg",
"meminfo",
"modules",
"mounts",
"net",
"stat",
"sys/kernel/cap_last_cap",
"sys/kernel/domainname",
"sys/kernel/hostname",
"sys/kernel/osrelease",
"sys/kernel/ostype",
"sys/kernel/overflowgid",
"sys/kernel/overflowuid",
"sys/kernel/pid_max",
"sys/kernel/random/boot_id",
"sys/kernel/random/uuid",
"sys/kernel/version",
"sys/vm/max_map_count",
"sys/vm/mmap_min_addr",
"sys/vm/overcommit_memory",
"uptime",
"version",
];
const STANDARD: &[&str] = &[
"buddyinfo",
"cgroups",
"diskstats",
"driver/rtc",
"interrupts",
"key-users",
"locks",
"pressure/cpu",
"pressure/io",
"pressure/memory",
"schedstat",
"softirqs",
"swaps",
"sys/fs/aio-max-nr",
"sys/fs/aio-nr",
"sys/fs/dentry-state",
"sys/fs/file-max",
"sys/fs/file-nr",
"sys/fs/inode-nr",
"sys/fs/inode-state",
"sys/fs/pipe-max-size",
"sys/kernel/pty/nr",
"sys/kernel/random/entropy_avail",
"sys/net/core/somaxconn",
"sys/net/ipv4/ip_local_port_range",
"tty/drivers",
"vmstat",
"zoneinfo",
];
const PROCESS_MINIMAL: &[&str] = &[
"auxv",
"cgroup",
"cmdline",
"comm",
"cwd",
"environ",
"exe",
"fd",
"fdinfo",
"maps",
"mountinfo",
"mounts",
"net",
"ns",
"root",
"smaps",
"stat",
"statm",
"status",
"task",
];
const PROCESS_STANDARD: &[&str] = &[
"arch_status",
"children",
"io",
"numa_maps",
"sched",
"schedstat",
"smaps_rollup",
"timerslack_ns",
];
const PROCESS_UNDECIDED_BELOW: &[&str] = &["cwd", "exe", "fd", "fdinfo", "net", "ns", "root"];
const PROCESS_KERNEL: &[&str] = &["gid_map", "mem", "setgroups", "uid_map"];
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) enum ProcfsName {
Undecided,
From(ProcLevel),
Omitted,
}
impl ProcfsName {
pub(crate) fn absent_at(self, level: ProcLevel) -> bool {
match self {
Self::Undecided => false,
Self::From(from) => from > level,
Self::Omitted => true,
}
}
}
pub(crate) fn procfs_name(path: &Path) -> Option<ProcfsName> {
let mut components = path.components().filter(|c| *c != Component::CurDir);
if components.next() != Some(Component::RootDir) {
return None;
}
match components.next() {
Some(Component::Normal(name)) if name == "proc" => {}
_ => return None,
}
let mut names = Vec::new();
for component in components {
match component {
Component::Normal(name) => names.push(name.as_bytes()),
_ => return Some(ProcfsName::Undecided),
}
}
let Some(first) = names.first() else {
return Some(ProcfsName::From(ProcLevel::Minimal));
};
if *first == b"self" || *first == b"thread-self" || first.iter().all(u8::is_ascii_digit) {
return Some(process_name(&names[1..]));
}
if names.len() > 1 && (*first == b"net" || *first == b"mounts") {
return Some(ProcfsName::Undecided);
}
let listed = |table: &[&str]| {
table.iter().any(|entry| {
names
.iter()
.zip(entry.split('/'))
.all(|(name, part)| *name == part.as_bytes())
})
};
Some(if listed(MINIMAL) {
ProcfsName::From(ProcLevel::Minimal)
} else if listed(STANDARD) {
ProcfsName::From(ProcLevel::Standard)
} else {
ProcfsName::Omitted
})
}
fn process_name(names: &[&[u8]]) -> ProcfsName {
let Some((first, rest)) = names.split_first() else {
return ProcfsName::Undecided;
};
let is = |table: &[&str]| table.iter().any(|entry| entry.as_bytes() == *first);
if *first == b"task" {
return match rest.split_first() {
None => ProcfsName::From(ProcLevel::Minimal),
Some((tid, below)) if tid.iter().all(u8::is_ascii_digit) => process_name(below),
Some(_) => ProcfsName::Omitted,
};
}
if (!rest.is_empty() && is(PROCESS_UNDECIDED_BELOW)) || is(PROCESS_KERNEL) {
return ProcfsName::Undecided;
}
if is(PROCESS_MINIMAL) {
ProcfsName::From(ProcLevel::Minimal)
} else if is(PROCESS_STANDARD) {
ProcfsName::From(ProcLevel::Standard)
} else {
ProcfsName::Omitted
}
}
pub(crate) fn system_entries(names: &[&[u8]], level: ProcLevel) -> Option<Vec<(Vec<u8>, u8)>> {
let tables: &[&[&str]] = match level {
ProcLevel::Minimal => &[MINIMAL],
ProcLevel::Standard => &[MINIMAL, STANDARD],
};
let mut entries: Vec<(Vec<u8>, u8)> = Vec::new();
let mut found = names.is_empty();
for entry in tables.iter().flat_map(|table| table.iter()) {
let mut parts = entry.split('/');
if !names
.iter()
.all(|name| parts.next().is_some_and(|part| part.as_bytes() == *name))
{
continue;
}
let Some(child) = parts.next() else {
return None;
};
found = true;
let ty = if parts.next().is_some() {
libc::DT_DIR
} else if names.is_empty() && (child == "mounts" || child == "net") {
libc::DT_LNK
} else {
libc::DT_REG
};
match entries
.iter_mut()
.find(|(name, _)| name == child.as_bytes())
{
Some(existing) if ty == libc::DT_DIR => existing.1 = ty,
Some(_) => {}
None => entries.push((child.as_bytes().to_vec(), ty)),
}
}
found.then_some(entries)
}
pub(crate) fn process_entries(thread: bool, level: ProcLevel) -> Vec<(&'static str, u8)> {
let mut names: Vec<&'static str> = PROCESS_MINIMAL.to_vec();
if level >= ProcLevel::Standard {
names.extend_from_slice(PROCESS_STANDARD);
}
names.extend_from_slice(PROCESS_KERNEL);
names
.into_iter()
.filter(|name| match *name {
"task" | "timerslack_ns" => !thread,
"children" => thread,
_ => true,
})
.map(|name| {
let ty = match name {
"fd" | "fdinfo" | "net" | "ns" | "task" => libc::DT_DIR,
"cwd" | "exe" | "root" => libc::DT_LNK,
_ => libc::DT_REG,
};
(name, ty)
})
.collect()
}
pub(crate) fn absent_entry(directory: &Path, name: &[u8], level: ProcLevel) -> bool {
if name == b"." || name == b".." {
return false;
}
procfs_name(&directory.join(OsStr::from_bytes(name)))
.is_some_and(|entry| entry.absent_at(level))
}
#[cfg(test)]
mod tests {
use super::*;
fn name(path: &str) -> Option<ProcfsName> {
procfs_name(Path::new(path))
}
#[test]
fn levels_follow_the_checklist() {
use ProcLevel::*;
use ProcfsName::*;
for (path, expected) in [
("/proc", From(Minimal)),
("/proc/", From(Minimal)),
("/proc/version", From(Minimal)),
("/proc/./version", From(Minimal)),
("/proc/sys", From(Minimal)),
("/proc/sys/kernel", From(Minimal)),
("/proc/sys/kernel/random", From(Minimal)),
("/proc/sys/kernel/random/uuid", From(Minimal)),
("/proc/sys/fs", From(Standard)),
("/proc/sys/fs/file-nr", From(Standard)),
("/proc/sys/kernel/random/entropy_avail", From(Standard)),
("/proc/sys/net", From(Standard)),
("/proc/interrupts", From(Standard)),
("/proc/tty", From(Standard)),
("/proc/tty/drivers", From(Standard)),
("/proc/version/x", From(Minimal)),
("/proc/kallsyms", Omitted),
("/proc/kcore", Omitted),
("/proc/sysvipc", Omitted),
("/proc/sysvipc/shm", Omitted),
("/proc/slabinfo", Omitted),
("/proc/bus/pci/devices", Omitted),
("/proc/tty/ldiscs", Omitted),
("/proc/sys/kernel/core_pattern", Omitted),
("/proc/sys/kernel/ngroups_max", Omitted),
("/proc/sys/kernel/random/poolsize", Omitted),
("/proc/sys/fs/binfmt_misc", Omitted),
("/proc/sys/crypto/fips_enabled", Omitted),
("/proc/sys/net/ipv4/tcp_rmem", Omitted),
("/proc/versionx", Omitted),
("/proc/self", Undecided),
("/proc/thread-self", Undecided),
("/proc/1", Undecided),
("/proc/1/stat", From(Minimal)),
("/proc/self/status", From(Minimal)),
("/proc/thread-self/status", From(Minimal)),
("/proc/self/task", From(Minimal)),
("/proc/self/task/7", Undecided),
("/proc/self/task/7/comm", From(Minimal)),
("/proc/self/task/7/children", From(Standard)),
("/proc/self/task/x", Omitted),
("/proc/self/io", From(Standard)),
("/proc/1/timerslack_ns", From(Standard)),
("/proc/self/limits", Omitted),
("/proc/self/mem", Undecided),
("/proc/1/task/1/mem", Undecided),
("/proc/thread-self/wchan", Omitted),
("/proc/self/uid_map", Undecided),
("/proc/self/setgroups", Undecided),
("/proc/self/oom_score_adj", Omitted),
("/proc/self/loginuid", Omitted),
("/proc/1/task/1/attr/current", Omitted),
("/proc/self/map_files", Omitted),
("/proc/self/status/x", From(Minimal)),
("/proc/self/fd", From(Minimal)),
("/proc/self/fd/3", Undecided),
("/proc/self/fdinfo/3", Undecided),
("/proc/self/ns/pid", Undecided),
("/proc/self/net/tcp", Undecided),
("/proc/self/root/proc/kallsyms", Undecided),
("/proc/self/cwd/x", Undecided),
("/proc/net/tcp", Undecided),
("/proc/mounts/x", Undecided),
("/proc/self/../kallsyms", Undecided),
] {
assert_eq!(name(path), Some(expected), "{path}");
}
for path in [
"/",
"/procx/version",
"/sys/kernel",
"proc/version",
"/tmp/proc/kcore",
] {
assert_eq!(name(path), None, "{path}");
}
assert_eq!(
procfs_name(Path::new(OsStr::from_bytes(b"/proc/\xff"))),
Some(Omitted)
);
}
#[test]
fn each_level_contains_the_one_before() {
let interrupts = name("/proc/interrupts").unwrap();
assert!(interrupts.absent_at(ProcLevel::Minimal));
assert!(!interrupts.absent_at(ProcLevel::Standard));
let version = name("/proc/version").unwrap();
assert!(!version.absent_at(ProcLevel::Minimal));
assert!(!version.absent_at(ProcLevel::Standard));
let kallsyms = name("/proc/kallsyms").unwrap();
assert!(kallsyms.absent_at(ProcLevel::Minimal));
assert!(kallsyms.absent_at(ProcLevel::Standard));
for path in super::super::fixed::FixedProcfsFile::ALL
.iter()
.map(|file| file.path())
{
assert!(
!procfs_name(path).unwrap().absent_at(ProcLevel::Standard),
"{path:?}"
);
}
}
#[test]
fn listings_leave_out_what_lookups_refuse() {
let proc = Path::new("/proc");
let level = ProcLevel::Standard;
assert!(absent_entry(proc, b"kallsyms", level));
assert!(!absent_entry(proc, b"interrupts", level));
assert!(absent_entry(proc, b"interrupts", ProcLevel::Minimal));
assert!(!absent_entry(proc, b"self", level));
assert!(!absent_entry(proc, b"42", level));
assert!(!absent_entry(proc, b".", level));
assert!(!absent_entry(proc, b"..", level));
assert!(absent_entry(Path::new("/proc/sys"), b"crypto", level));
assert!(!absent_entry(Path::new("/proc/sys"), b"fs", level));
assert!(absent_entry(
Path::new("/proc/sys"),
b"fs",
ProcLevel::Minimal
));
assert!(absent_entry(
Path::new("/proc/sys/kernel"),
b"core_pattern",
level
));
assert!(absent_entry(Path::new("/proc/self"), b"limits", level));
assert!(!absent_entry(Path::new("/proc/42"), b"status", level));
assert!(absent_entry(
Path::new("/proc/42"),
b"io",
ProcLevel::Minimal
));
assert!(!absent_entry(Path::new("/proc/42/task"), b"43", level));
assert!(!absent_entry(Path::new("/proc/42/fd"), b"3", level));
assert!(!absent_entry(Path::new("/tmp"), b"kallsyms", level));
assert!(absent_entry(proc, b"\xff", level));
}
}