refactor(naming): A1 — ente→arje, vista→revista, pluma→fana
Rename batch de la Fase A del PLAN_MACRO: - 25 crates ente-* → arje-* (protocol/init/runtime/compat). El linaje arje (init Linux) queda con prefijo coherente. - vista → revista (revista-core + revista-web). - pluma → fana (fana-md + fana-md-reader-web). fana absorbe el linaje markdown de pluma; será el writer DAG editor (prioridad alta). Cambios: - git mv de 29 crate dirs + 2 SDDs - package/lib/bin names + path refs + imports .rs reescritos - workspace Cargo.toml + comentarios de sección - SDDs de init/runtime/compat/protocol actualizados a arje- - SDD de revista + SDD de fana (reescrito: writer DAG editor) - docs/STATUS.md, ROADMAP.md, PLAN_MACRO.md, arje-boot.md, arje-replace-systemd.md actualizados - docs/changelog/akasha.md → chasqui.md scripts/rename-fase-a.py idempotente (--dry-run soportado). cargo check --workspace verde. Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
This commit is contained in:
sergio
@@ -0,0 +1,313 @@
|
||||
//! Path namespaced: clone(2) + sync pipe + setup post-clone en padre + finalize en hijo.
|
||||
//!
|
||||
//! ## Protocolo padre↔hijo
|
||||
//!
|
||||
//! ```text
|
||||
//! parent child
|
||||
//! | |
|
||||
//! |--- clone() ------->| (child empieza dentro de los nuevos NS)
|
||||
//! | |
|
||||
//! | |---- read(sync_r, 1) ---- (bloquea)
|
||||
//! | |
|
||||
//! | write uid_map |
|
||||
//! | write gid_map |
|
||||
//! | cgroup move |
|
||||
//! | cpu affinity |
|
||||
//! | |
|
||||
//! |--- write(sync_w) ->|
|
||||
//! | |---- setrlimit
|
||||
//! | |---- mount(/, MS_PRIVATE | MS_REC)
|
||||
//! | |---- execve()
|
||||
//! ```
|
||||
|
||||
use crate::child::{apply_rlimits, make_root_private};
|
||||
use crate::cgroup::{ensure_cgroup, move_to_cgroup};
|
||||
use crate::env::{build_env, EnvSpec};
|
||||
use crate::error::{Degradation, IncarnateError};
|
||||
use crate::pre_exec::{apply_unchecked, ChildSetup};
|
||||
use crate::ChildStdio;
|
||||
use brahman_card::{Card, NamespaceSet, Payload};
|
||||
use nix::fcntl::OFlag;
|
||||
use nix::sched::CloneFlags;
|
||||
use nix::unistd::{pipe2, Pid};
|
||||
use std::ffi::CString;
|
||||
use std::os::fd::{IntoRawFd, RawFd};
|
||||
use tracing::{info, warn};
|
||||
|
||||
pub fn needs_namespacing(ns: &NamespaceSet) -> bool {
|
||||
ns.mount || ns.pid || ns.net || ns.uts || ns.ipc || ns.user || ns.cgroup
|
||||
}
|
||||
|
||||
pub fn build_clone_flags(ns: &NamespaceSet) -> CloneFlags {
|
||||
let mut f = CloneFlags::empty();
|
||||
if ns.mount { f |= CloneFlags::CLONE_NEWNS; }
|
||||
if ns.pid { f |= CloneFlags::CLONE_NEWPID; }
|
||||
if ns.net { f |= CloneFlags::CLONE_NEWNET; }
|
||||
if ns.uts { f |= CloneFlags::CLONE_NEWUTS; }
|
||||
if ns.ipc { f |= CloneFlags::CLONE_NEWIPC; }
|
||||
if ns.user { f |= CloneFlags::CLONE_NEWUSER; }
|
||||
if ns.cgroup { f |= CloneFlags::CLONE_NEWCGROUP; }
|
||||
f
|
||||
}
|
||||
|
||||
pub fn incarnate_namespaced(
|
||||
card: &Card,
|
||||
env_spec: &EnvSpec,
|
||||
stdio: &ChildStdio,
|
||||
setup: &ChildSetup,
|
||||
degradations: &mut Vec<Degradation>,
|
||||
) -> Result<Pid, IncarnateError> {
|
||||
let flags = build_clone_flags(&card.soma.namespaces);
|
||||
info!(label = %card.label, ?flags, "namespaced incarnation");
|
||||
|
||||
let (exec, argv, base_envp) = match &card.payload {
|
||||
Payload::Native { exec, argv, envp } => (exec.clone(), argv.clone(), envp.clone()),
|
||||
Payload::Legacy { exec, argv, .. } => (exec.clone(), argv.clone(), Vec::new()),
|
||||
_ => return Err(IncarnateError::NonExecutablePayload),
|
||||
};
|
||||
|
||||
// Pipe O_CLOEXEC: el read del lado hijo es lo que hace race-free el setup.
|
||||
// O_CLOEXEC garantiza cierre automático en execve.
|
||||
let (sync_r, sync_w) = pipe2(OFlag::O_CLOEXEC).map_err(IncarnateError::Pipe)?;
|
||||
let sync_r_raw: RawFd = sync_r.into_raw_fd();
|
||||
let sync_w_raw: RawFd = sync_w.into_raw_fd();
|
||||
|
||||
let exec_c = CString::new(exec.clone()).map_err(|_| IncarnateError::InvalidArgv)?;
|
||||
let argv_c: Vec<CString> = std::iter::once(exec_c.clone())
|
||||
.chain(argv.iter().filter_map(|s| CString::new(s.as_str()).ok()))
|
||||
.collect();
|
||||
let argv_ptrs: Vec<*const libc::c_char> = argv_c
|
||||
.iter()
|
||||
.map(|c| c.as_ptr())
|
||||
.chain(std::iter::once(std::ptr::null()))
|
||||
.collect();
|
||||
|
||||
let env_pairs = build_env(card, &base_envp, env_spec);
|
||||
let envp_c: Vec<CString> = env_pairs
|
||||
.iter()
|
||||
.filter_map(|(k, v)| CString::new(format!("{k}={v}")).ok())
|
||||
.collect();
|
||||
let envp_ptrs: Vec<*const libc::c_char> = envp_c
|
||||
.iter()
|
||||
.map(|c| c.as_ptr())
|
||||
.chain(std::iter::once(std::ptr::null()))
|
||||
.collect();
|
||||
|
||||
let rlimits = card.soma.rlimits.clone();
|
||||
let mount_ns_enabled = card.soma.namespaces.mount;
|
||||
let stdin_fd = stdio.stdin_fd;
|
||||
let stdout_fd = stdio.stdout_fd;
|
||||
let stderr_fd = stdio.stderr_fd;
|
||||
let setup_ops = setup.ops.clone();
|
||||
|
||||
// SAFETY: la clausura corre en stack nuevo dentro de un proceso recién
|
||||
// clonado, COW del padre. Sólo syscalls async-signal-safe; sin allocator,
|
||||
// sin Drop con efectos.
|
||||
let cb = Box::new(move || -> isize {
|
||||
unsafe { libc::close(sync_w_raw); }
|
||||
|
||||
let mut byte = [0u8; 1];
|
||||
let n = unsafe { libc::read(sync_r_raw, byte.as_mut_ptr() as *mut _, 1) };
|
||||
if n != 1 {
|
||||
unsafe { libc::_exit(101); }
|
||||
}
|
||||
unsafe { libc::close(sync_r_raw); }
|
||||
|
||||
unsafe { apply_rlimits(&rlimits); }
|
||||
|
||||
if mount_ns_enabled {
|
||||
unsafe { make_root_private(); }
|
||||
}
|
||||
|
||||
// dup2 declarativo: caller pasó fds que queremos como stdin/out/err.
|
||||
// dup2 es async-signal-safe (POSIX) y cierra el fd target si estaba
|
||||
// abierto. El fd source NO se cierra automáticamente — el padre
|
||||
// tiene su propia copia.
|
||||
if let Some(fd) = stdin_fd {
|
||||
unsafe {
|
||||
if libc::dup2(fd, 0) < 0 {
|
||||
libc::_exit(103);
|
||||
}
|
||||
}
|
||||
}
|
||||
if let Some(fd) = stdout_fd {
|
||||
unsafe {
|
||||
if libc::dup2(fd, 1) < 0 {
|
||||
libc::_exit(104);
|
||||
}
|
||||
}
|
||||
}
|
||||
if let Some(fd) = stderr_fd {
|
||||
unsafe {
|
||||
if libc::dup2(fd, 2) < 0 {
|
||||
libc::_exit(105);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Aplica las ops declarativas pre-execve (NoNewPrivs, chdir, etc.).
|
||||
if !setup_ops.is_empty() {
|
||||
let r = unsafe { apply_unchecked(&setup_ops) };
|
||||
if r != 0 {
|
||||
unsafe { libc::_exit(r) };
|
||||
}
|
||||
}
|
||||
|
||||
unsafe {
|
||||
libc::execve(exec_c.as_ptr(), argv_ptrs.as_ptr(), envp_ptrs.as_ptr());
|
||||
libc::_exit(102);
|
||||
}
|
||||
});
|
||||
|
||||
let mut stack = vec![0u8; 1024 * 1024];
|
||||
|
||||
#[allow(deprecated)]
|
||||
let pid = unsafe { nix::sched::clone(cb, &mut stack, flags, Some(libc::SIGCHLD)) }
|
||||
.map_err(|e| {
|
||||
unsafe {
|
||||
libc::close(sync_r_raw);
|
||||
libc::close(sync_w_raw);
|
||||
}
|
||||
IncarnateError::Clone(e)
|
||||
})?;
|
||||
|
||||
// Padre: cerrar el extremo de lectura.
|
||||
unsafe { libc::close(sync_r_raw); }
|
||||
|
||||
// Setup post-clone. Errores aquí los registramos como degradations y
|
||||
// continuamos (la decisión strict_caps la toma el wrapper).
|
||||
if let Err(e) = configure_child(pid, card, degradations) {
|
||||
warn!(?e, ?pid, "configure_child errores");
|
||||
}
|
||||
|
||||
// Despertar al hijo.
|
||||
let signal_byte = [b'x'];
|
||||
let written = unsafe { libc::write(sync_w_raw, signal_byte.as_ptr() as *const _, 1) };
|
||||
unsafe { libc::close(sync_w_raw); }
|
||||
if written != 1 {
|
||||
warn!(?pid, "write sync pipe devolvió {}", written);
|
||||
}
|
||||
|
||||
// El hijo ya dup2-eó los fds del ChildStdio. La copia del padre no
|
||||
// sirve más y la cerramos para que el otro extremo del pipe reciba
|
||||
// EOF cuando corresponda.
|
||||
if let Some(fd) = stdio.stdin_fd {
|
||||
unsafe { libc::close(fd); }
|
||||
}
|
||||
if let Some(fd) = stdio.stdout_fd {
|
||||
unsafe { libc::close(fd); }
|
||||
}
|
||||
if let Some(fd) = stdio.stderr_fd {
|
||||
unsafe { libc::close(fd); }
|
||||
}
|
||||
|
||||
Ok(pid)
|
||||
}
|
||||
|
||||
/// Setup que requiere capacidades del padre: uid_map, gid_map, cgroup move.
|
||||
/// Estos archivos en `/proc/<pid>/*` tienen reglas de propiedad que sólo el
|
||||
/// padre puede satisfacer mientras el hijo está suspendido en el sync pipe.
|
||||
fn configure_child(
|
||||
pid: Pid,
|
||||
card: &Card,
|
||||
degradations: &mut Vec<Degradation>,
|
||||
) -> Result<(), IncarnateError> {
|
||||
if card.soma.namespaces.user {
|
||||
// Desde kernel 3.19 hay que escribir "deny" a setgroups antes de
|
||||
// poder escribir gid_map sin CAP_SETGID. Ignorar errores aquí: en
|
||||
// kernels antiguos el archivo no existe.
|
||||
let _ = std::fs::write(format!("/proc/{}/setgroups", pid.as_raw()), "deny");
|
||||
|
||||
let uid = nix::unistd::getuid().as_raw();
|
||||
let gid = nix::unistd::getgid().as_raw();
|
||||
if let Err(e) = std::fs::write(
|
||||
format!("/proc/{}/uid_map", pid.as_raw()),
|
||||
format!("0 {uid} 1"),
|
||||
) {
|
||||
degradations.push(Degradation::UidMapFailed {
|
||||
reason: format!("uid_map: {e}"),
|
||||
});
|
||||
}
|
||||
if let Err(e) = std::fs::write(
|
||||
format!("/proc/{}/gid_map", pid.as_raw()),
|
||||
format!("0 {gid} 1"),
|
||||
) {
|
||||
degradations.push(Degradation::UidMapFailed {
|
||||
reason: format!("gid_map: {e}"),
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
if !card.soma.cgroup.path.is_empty() {
|
||||
match ensure_cgroup(&card.soma.cgroup) {
|
||||
Ok(abs) => {
|
||||
if let Err(e) = move_to_cgroup(&abs, pid) {
|
||||
degradations.push(Degradation::CgroupSkipped {
|
||||
path: abs,
|
||||
reason: format!("{e}"),
|
||||
});
|
||||
}
|
||||
}
|
||||
Err(e) => degradations.push(Degradation::CgroupSkipped {
|
||||
path: std::path::PathBuf::from(&card.soma.cgroup.path),
|
||||
reason: format!("{e}"),
|
||||
}),
|
||||
}
|
||||
}
|
||||
|
||||
if let Some(cpus) = &card.soma.cpu_affinity {
|
||||
if let Err(e) = set_cpu_affinity(pid, cpus) {
|
||||
degradations.push(Degradation::CpuAffinitySkipped {
|
||||
reason: format!("{e}"),
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn set_cpu_affinity(pid: Pid, cpus: &[u32]) -> Result<(), std::io::Error> {
|
||||
let mut set: libc::cpu_set_t = unsafe { std::mem::zeroed() };
|
||||
unsafe { libc::CPU_ZERO(&mut set); }
|
||||
for &c in cpus {
|
||||
unsafe { libc::CPU_SET(c as usize, &mut set); }
|
||||
}
|
||||
let r = unsafe {
|
||||
libc::sched_setaffinity(pid.as_raw(), std::mem::size_of::<libc::cpu_set_t>(), &set)
|
||||
};
|
||||
if r != 0 {
|
||||
Err(std::io::Error::last_os_error())
|
||||
} else {
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use brahman_card::NamespaceSet;
|
||||
|
||||
#[test]
|
||||
fn empty_ns_does_not_need_namespacing() {
|
||||
let ns = NamespaceSet::default();
|
||||
assert!(!needs_namespacing(&ns));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn any_ns_triggers_namespacing() {
|
||||
let mut ns = NamespaceSet::default();
|
||||
ns.user = true;
|
||||
assert!(needs_namespacing(&ns));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn flags_match_namespace_bools() {
|
||||
let mut ns = NamespaceSet::default();
|
||||
ns.user = true;
|
||||
ns.pid = true;
|
||||
let f = build_clone_flags(&ns);
|
||||
assert!(f.contains(CloneFlags::CLONE_NEWUSER));
|
||||
assert!(f.contains(CloneFlags::CLONE_NEWPID));
|
||||
assert!(!f.contains(CloneFlags::CLONE_NEWNET));
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user