#[cfg(unix)]
use std::cell::RefCell;
#[cfg(unix)]
use std::ffi::{OsStr, OsString};
#[cfg(unix)]
use std::io::{self, Read, Write};
#[cfg(unix)]
use std::os::unix::ffi::{OsStrExt, OsStringExt};
#[cfg(unix)]
use std::os::unix::process::{CommandExt, ExitStatusExt};
#[cfg(unix)]
use std::path::PathBuf;
#[cfg(unix)]
use std::process::{Child, ChildStderr, ChildStdin, Command, ExitStatus, Stdio};
#[cfg(unix)]
use std::sync::atomic::{AtomicBool, Ordering};
#[cfg(unix)]
use serde::{Deserialize, Serialize};
#[cfg(unix)]
use super::{OutputCapture, ProcessError, SpawnSpec};
#[cfg(unix)]
mod completion_receipt;
#[cfg(unix)]
mod journal_cleanup;
#[cfg(unix)]
use journal_cleanup::OwnerJournalCleanup;
#[cfg(unix)]
mod output_relay;
#[cfg(unix)]
mod owner_pipe;
#[doc(hidden)]
pub mod test_reexec;
#[cfg(unix)]
pub(crate) use completion_receipt::ReceiptReader;
#[cfg(unix)]
use owner_pipe::wait_for_owner_pipe_close;
#[cfg(target_os = "linux")]
pub(super) mod cancel_request;
#[cfg(target_os = "linux")]
#[path = "owner_death/adopted_children.rs"]
mod adopted_children;
#[cfg(all(test, target_os = "linux"))]
#[path = "owner_death/adopted_children_tests.rs"]
mod adopted_children_tests;
pub const GUARDIAN_ARG: &str = "__harn-process-owner-guardian";
#[cfg(unix)]
fn reexec_executable() -> io::Result<PathBuf> {
#[cfg(target_os = "linux")]
{
Ok(PathBuf::from("/proc/self/exe"))
}
#[cfg(not(target_os = "linux"))]
{
std::env::current_exe()
}
}
#[cfg(unix)]
const MODE_ENV: &str = "HARN_INTERNAL_PROCESS_GUARDIAN_MODE";
#[cfg(unix)]
const PIPE_MODE: &str = "request-pipe-v1";
#[cfg(unix)]
static DISPATCHER_READY: AtomicBool = AtomicBool::new(false);
#[cfg(unix)]
const REAPER_ENV: &str = "HARN_INTERNAL_PROCESS_GUARDIAN_REAPER";
#[cfg(unix)]
const OWNER_PID_ENV: &str = "HARN_INTERNAL_PROCESS_GUARDIAN_OWNER_PID";
#[cfg(unix)]
const OWNER_POLL_INTERVAL_MS: libc::c_int = 200;
#[cfg(unix)]
const MAX_REQUEST_BYTES: usize = 16 * 1024 * 1024;
#[cfg(unix)]
thread_local! {
static REEXEC_ARGS: RefCell<Option<Vec<OsString>>> = const { RefCell::new(None) };
}
#[cfg(unix)]
#[doc(hidden)]
pub struct GuardianReexecArgsGuard {
previous: Option<Vec<OsString>>,
}
#[cfg(unix)]
impl Drop for GuardianReexecArgsGuard {
fn drop(&mut self) {
REEXEC_ARGS.with(|slot| {
*slot.borrow_mut() = self.previous.take();
});
}
}
#[cfg(unix)]
#[doc(hidden)]
pub fn install_guardian_reexec_args<I, S>(args: I) -> GuardianReexecArgsGuard
where
I: IntoIterator<Item = S>,
S: Into<OsString>,
{
let args = args.into_iter().map(Into::into).collect();
let previous = REEXEC_ARGS.with(|slot| slot.replace(Some(args)));
GuardianReexecArgsGuard { previous }
}
#[cfg(all(unix, target_os = "linux"))]
const RULESET_FD: std::os::fd::RawFd = 3;
#[cfg(unix)]
#[derive(Deserialize, Serialize)]
enum GuardianConfinement {
BeforeExec { seccomp: Vec<u8>, ruleset: bool },
AfterNamespace { ruleset: bool },
Bubblewrap { descriptors: Vec<i32> },
}
#[cfg(unix)]
#[derive(Default, Deserialize, Serialize)]
enum GuardianOutputCapture {
#[default]
Pipe,
File {
stdout_path: Vec<u8>,
stderr_path: Vec<u8>,
},
}
#[cfg(unix)]
#[derive(Deserialize, Serialize)]
struct GuardianCommandRequest {
#[serde(default)]
test_reexec: bool,
#[serde(default)]
output_capture: GuardianOutputCapture,
#[serde(default)]
cleanup_receipt_fd: Option<i32>,
#[cfg(target_os = "linux")]
#[serde(default)]
cancel_request_fd: Option<i32>,
#[serde(default)]
payload_stdin: bool,
program: Vec<u8>,
args: Vec<Vec<u8>>,
cwd: Option<Vec<u8>>,
env_clear: bool,
env: Vec<(Vec<u8>, Option<Vec<u8>>)>,
cleanup_token: String,
#[serde(default, skip_serializing_if = "Vec::is_empty")]
pinned_verifier_descriptors: Vec<i32>,
#[serde(default)]
confinement: Option<GuardianConfinement>,
}
#[cfg(unix)]
struct PreparedCommand {
request: GuardianCommandRequest,
#[cfg(target_os = "linux")]
inherited_descriptors: harn_vm::process_sandbox::DescriptorTransfer,
}
#[cfg(unix)]
#[derive(Deserialize, Serialize)]
struct StartupMessage {
ok: bool,
#[serde(default)]
spawn_not_found: bool,
error: Option<String>,
guardian_pid: Option<u32>,
pid: Option<u32>,
}
#[cfg(unix)]
pub(crate) struct PreparedGuardian {
pub(crate) test_reexec: bool,
pub(crate) cleanup_receipt: ReceiptReader,
#[cfg(target_os = "linux")]
pub(crate) cancel_request: cancel_request::CancelRequest,
pub(crate) command: Command,
pub(crate) request: Vec<u8>,
pub(crate) missing_program: Option<String>,
pub(crate) verifier_witness: Option<harn_vm::verifier_provenance::VerifierExecutionWitness>,
}
#[cfg(unix)]
pub(crate) fn prepare_guardian(
spec: &SpawnSpec,
cleanup_token: String,
) -> Result<PreparedGuardian, ProcessError> {
super::real::validate_program(spec)?;
let output_capture = match &spec.output_capture {
OutputCapture::Pipe => GuardianOutputCapture::Pipe,
OutputCapture::File {
stdout_path,
stderr_path,
} => GuardianOutputCapture::File {
stdout_path: os_bytes(stdout_path.as_os_str()),
stderr_path: os_bytes(stderr_path.as_os_str()),
},
OutputCapture::Inherit => {
return Err(ProcessError::InvalidArgv(
"owner-death containment requires captured output".to_string(),
));
}
};
let reexec_args = match REEXEC_ARGS.with(|slot| slot.borrow().clone()) {
Some(args) => Some(args),
None => test_reexec::arguments()?,
};
if reexec_args.is_none() && !DISPATCHER_READY.load(Ordering::Acquire) {
return Err(ProcessError::GuardianNotInitialized);
}
let mut payload_spec = spec.clone();
payload_spec.configure_process_group = false;
payload_spec.owner_death = super::OwnerDeathPolicy::None;
payload_spec.output_capture = OutputCapture::Pipe;
#[cfg(target_os = "linux")]
let pinned = super::program_lookup::pinned_verifier(&payload_spec, &[RULESET_FD])?;
#[cfg(target_os = "linux")]
let (prepared, confinement) = {
let (command, env_closed, confinement) = harn_vm::process_sandbox::command_for_reexec(
pinned
.as_ref()
.map_or(payload_spec.program.as_str(), |value| {
value.program.as_str()
}),
pinned
.as_ref()
.map_or(payload_spec.args.as_slice(), |value| value.args.as_slice()),
RULESET_FD,
)
.map_err(ProcessError::sandbox_setup)?;
let prepared = super::real::prepare_command_from(
&payload_spec,
Some(cleanup_token.clone()),
(command, env_closed),
)?;
(prepared, confinement.map(TransferredConfinement))
};
#[cfg(not(target_os = "linux"))]
let (prepared, confinement) = (
super::real::prepare_command(&payload_spec, Some(cleanup_token.clone()))?,
build_confinement(&payload_spec.program)?,
);
#[cfg(target_os = "linux")]
let source_verifier_bound = pinned.is_some();
#[cfg(not(target_os = "linux"))]
let source_verifier_bound = false;
let missing_program = if source_verifier_bound {
None
} else {
super::program_lookup::missing_program(
&payload_spec,
&prepared.command,
prepared.env_cleared,
)
};
let mut payload = prepared.command;
payload.env(
harn_vm::op_interrupt::PROCESS_OWNER_TOKEN_ENV,
&cleanup_token,
);
let mut request = GuardianCommandRequest::from_command(
&payload,
prepared.env_cleared,
cleanup_token.clone(),
confinement.as_ref().map(TransferredConfinement::request),
spec.use_stdin,
);
request.output_capture = output_capture;
request.test_reexec = reexec_args.is_some();
#[cfg(target_os = "linux")]
if let Some(pinned) = pinned.as_ref() {
if payload.get_program() != std::ffi::OsStr::new(&pinned.program) {
return Err(ProcessError::Spawn(
"isolated source verifier guardian wrapping is unmeasured".to_string(),
));
}
harn_vm::verifier_provenance::validate_pinned_environment(&payload, prepared.env_cleared)
.map_err(ProcessError::Spawn)?;
request.pinned_verifier_descriptors = pinned.descriptors.numbers();
}
let executable = reexec_executable()
.map_err(|error| ProcessError::Spawn(format!("resolve guardian executable: {error}")))?;
let mut guardian = Command::new(executable);
match reexec_args {
Some(args) => {
guardian.args(args);
}
None => {
guardian.arg(GUARDIAN_ARG);
}
}
strip_sensitive_parent_env(&mut guardian, std::env::vars_os());
guardian
.env(MODE_ENV, PIPE_MODE)
.env(REAPER_ENV, "1")
.env(OWNER_PID_ENV, std::process::id().to_string())
.env_remove(harn_vm::op_interrupt::PROCESS_CLEANUP_TOKEN_ENV)
.stdin(Stdio::piped())
.stdout(Stdio::piped())
.stderr(Stdio::piped())
.process_group(0);
if let Some(confinement) = confinement {
confinement.hand_to(&mut guardian);
}
#[cfg(target_os = "linux")]
let witness = if let Some(pinned) = pinned {
pinned.descriptors.attach(&mut guardian);
Some(pinned.witness)
} else {
None
};
#[cfg(not(target_os = "linux"))]
let witness = None;
let (cleanup_receipt, receipt_fd) =
completion_receipt::prepare(&mut guardian).map_err(|error| {
ProcessError::Spawn(format!("create guardian cleanup receipt: {error}"))
})?;
request.cleanup_receipt_fd = Some(receipt_fd);
#[cfg(target_os = "linux")]
let cancel_request = {
let (cancel_request, fd) = cancel_request::prepare(&mut guardian).map_err(|error| {
ProcessError::Spawn(format!("create guardian cancellation pipe: {error}"))
})?;
request.cancel_request_fd = Some(fd);
cancel_request
};
let test_reexec = request.test_reexec;
let request = serde_json::to_vec(&request)
.map_err(|error| ProcessError::Spawn(format!("encode guardian request: {error}")))?;
harn_vm::op_interrupt::initialize_process_owner_group_journal(&cleanup_token)
.map_err(|error| ProcessError::Spawn(format!("create owner process journal: {error}")))?;
Ok(PreparedGuardian {
test_reexec,
cleanup_receipt,
#[cfg(target_os = "linux")]
cancel_request,
command: guardian,
request,
missing_program,
verifier_witness: witness,
})
}
#[cfg(target_os = "linux")]
struct TransferredConfinement(harn_vm::process_sandbox::ReexecConfinement);
#[cfg(target_os = "linux")]
impl TransferredConfinement {
fn request(&self) -> GuardianConfinement {
use harn_vm::process_sandbox::ReexecConfinement;
match &self.0 {
ReexecConfinement::BeforeExec(inner) => GuardianConfinement::BeforeExec {
seccomp: inner.seccomp_bytes(),
ruleset: inner.ruleset_fd().is_some(),
},
ReexecConfinement::AfterNamespace(inner) => GuardianConfinement::AfterNamespace {
ruleset: inner.ruleset_fd().is_some(),
},
ReexecConfinement::Bubblewrap(descriptors) => GuardianConfinement::Bubblewrap {
descriptors: descriptors.numbers(),
},
}
}
fn hand_to(self, guardian: &mut Command) {
use harn_vm::process_sandbox::ReexecConfinement;
let inner = match self.0 {
ReexecConfinement::BeforeExec(inner) | ReexecConfinement::AfterNamespace(inner) => {
inner
}
ReexecConfinement::Bubblewrap(descriptors) => {
descriptors.attach(guardian);
return;
}
};
let Some(ruleset) = inner.into_ruleset_fd() else {
return;
};
let guard = RulesetDescriptor(ruleset);
unsafe {
guardian.pre_exec(move || {
let held = guard.raw();
if held == RULESET_FD {
if libc::fcntl(held, libc::F_SETFD, 0) < 0 {
return Err(io::Error::last_os_error());
}
} else if libc::dup2(held, RULESET_FD) < 0 {
return Err(io::Error::last_os_error());
}
Ok(())
});
}
}
}
#[cfg(target_os = "linux")]
struct RulesetDescriptor(std::os::fd::RawFd);
#[cfg(target_os = "linux")]
impl RulesetDescriptor {
fn raw(&self) -> std::os::fd::RawFd {
self.0
}
}
#[cfg(target_os = "linux")]
impl Drop for RulesetDescriptor {
fn drop(&mut self) {
unsafe {
libc::close(self.0);
}
}
}
#[cfg(all(unix, not(target_os = "linux")))]
fn build_confinement(_program: &str) -> Result<Option<TransferredConfinement>, ProcessError> {
Ok(None)
}
#[cfg(all(unix, not(target_os = "linux")))]
struct TransferredConfinement;
#[cfg(all(unix, not(target_os = "linux")))]
impl TransferredConfinement {
fn request(&self) -> GuardianConfinement {
unreachable!("no platform but Linux builds a transferred confinement")
}
fn hand_to(self, _guardian: &mut Command) {}
}
#[cfg(unix)]
fn strip_sensitive_parent_env<I>(guardian: &mut Command, parent_env: I)
where
I: IntoIterator<Item = (OsString, OsString)>,
{
for (key, _) in parent_env {
if key
.to_str()
.is_some_and(super::handle::is_sensitive_env_name)
|| harn_vm::security::is_trusted_setup_control(&key)
{
guardian.env_remove(key);
}
}
}
#[cfg(unix)]
pub(crate) fn write_request(pipe: &mut ChildStdin, request: &[u8]) -> Result<(), ProcessError> {
if request.len() > MAX_REQUEST_BYTES {
return Err(ProcessError::Spawn(format!(
"guardian request exceeded {MAX_REQUEST_BYTES} bytes"
)));
}
pipe.write_all(request)
.and_then(|()| pipe.write_all(b"\n"))
.and_then(|()| pipe.flush())
.map_err(|error| ProcessError::Spawn(format!("write guardian request: {error}")))
}
#[cfg(unix)]
impl GuardianCommandRequest {
fn from_command(
command: &Command,
env_clear: bool,
cleanup_token: String,
confinement: Option<GuardianConfinement>,
payload_stdin: bool,
) -> Self {
Self {
test_reexec: false,
output_capture: GuardianOutputCapture::Pipe,
cleanup_receipt_fd: None,
#[cfg(target_os = "linux")]
cancel_request_fd: None,
payload_stdin,
pinned_verifier_descriptors: Vec::new(),
confinement,
program: os_bytes(command.get_program()),
args: command.get_args().map(os_bytes).collect(),
cwd: command
.get_current_dir()
.map(|path| os_bytes(path.as_os_str())),
env_clear,
env: payload_environment(command, env_clear, std::env::vars_os()),
cleanup_token,
}
}
}
#[cfg(unix)]
#[path = "owner_death/prepared_command.rs"]
mod prepared_command;
#[cfg(unix)]
fn payload_environment(
command: &Command,
env_clear: bool,
inherited: impl IntoIterator<Item = (OsString, OsString)>,
) -> Vec<(Vec<u8>, Option<Vec<u8>>)> {
inherited
.into_iter()
.filter(|(key, _)| !env_clear && harn_vm::security::is_trusted_setup_control(key))
.map(|(key, value)| (os_bytes(&key), Some(os_bytes(&value))))
.chain(
command
.get_envs()
.map(|(key, value)| (os_bytes(key), value.map(os_bytes))),
)
.collect()
}
#[cfg(target_os = "linux")]
fn apply_confinement(
command: &mut Command,
confinement: Option<GuardianConfinement>,
) -> io::Result<()> {
let Some(confinement) = confinement else {
return Ok(());
};
let (seccomp, ruleset) = match confinement {
GuardianConfinement::Bubblewrap { .. } => {
return Ok(());
}
GuardianConfinement::BeforeExec { seccomp, ruleset } => (seccomp, ruleset),
GuardianConfinement::AfterNamespace { ruleset } => {
let transferable = harn_vm::process_sandbox::TransferableConfinement::from_parts(
ruleset.then_some(RULESET_FD),
&[],
)?;
harn_vm::process_sandbox::keep_ruleset_across_exec(command, transferable);
return Ok(());
}
};
let ruleset = ruleset.then_some(RULESET_FD);
let transferable =
harn_vm::process_sandbox::TransferableConfinement::from_parts(ruleset, &seccomp)?;
unsafe {
command.pre_exec(move || transferable.enter());
}
Ok(())
}
#[cfg(all(unix, not(target_os = "linux")))]
fn apply_confinement(
_command: &mut Command,
confinement: Option<GuardianConfinement>,
) -> io::Result<()> {
if confinement.is_some() {
return Err(io::Error::other(
"guardian was handed a transferred confinement on a platform whose backend carries its own",
));
}
Ok(())
}
#[cfg(unix)]
fn os_bytes(value: &OsStr) -> Vec<u8> {
value.as_bytes().to_vec()
}
#[cfg(unix)]
pub(crate) fn await_startup(
child: &mut Child,
test_output_token: Option<&str>,
) -> Result<(ChildStderr, u32, u32), ProcessError> {
let mut stderr = child
.stderr
.take()
.ok_or_else(|| ProcessError::Spawn("guardian stderr pipe missing".to_string()))?;
let mut line = Vec::new();
loop {
let mut byte = [0_u8; 1];
match stderr.read_exact(&mut byte) {
Ok(()) if byte[0] == b'\n' => break,
Ok(()) => {
line.push(byte[0]);
if line.len() > 64 * 1024 {
return Err(ProcessError::Spawn(
"guardian startup response exceeded 64 KiB".to_string(),
));
}
}
Err(error) => {
let _ = child.wait();
return Err(ProcessError::Spawn(format!(
"guardian exited before payload startup: {error}"
)));
}
}
}
let message: StartupMessage = serde_json::from_slice(&line)
.map_err(|error| ProcessError::Spawn(format!("decode guardian startup: {error}")))?;
if message.ok {
let guardian_pid = message.guardian_pid.ok_or_else(|| {
ProcessError::Spawn("guardian startup response omitted guardian pid".to_string())
})?;
let pid = message.pid.ok_or_else(|| {
ProcessError::Spawn("guardian startup response omitted payload pid".to_string())
})?;
if let Some(token) = test_output_token {
let stdout = child
.stdout
.as_mut()
.ok_or_else(|| ProcessError::Spawn("test guardian stdout pipe missing".into()))?;
test_reexec::consume_boundary(stdout, token).map_err(|error| {
ProcessError::Spawn(format!("test guardian stdout startup: {error}"))
})?;
}
Ok((stderr, guardian_pid, pid))
} else {
let _ = child.wait();
let error = message
.error
.unwrap_or_else(|| "guardian could not launch payload".to_string());
if message.spawn_not_found {
Err(ProcessError::SpawnIo {
kind: "not_found",
message: error,
})
} else {
Err(ProcessError::Spawn(error))
}
}
}
#[cfg(unix)]
#[doc(hidden)]
pub fn run_guardian_from_pipe() -> io::Result<()> {
if std::env::var_os(REAPER_ENV).is_some() {
run_guardian_reaper();
}
if std::env::var(MODE_ENV).as_deref() != Ok(PIPE_MODE) {
return Err(io::Error::other("guardian request pipe is not active"));
}
let raw = read_request()?;
let request: GuardianCommandRequest = serde_json::from_slice(&raw)
.map_err(|error| io::Error::new(io::ErrorKind::InvalidData, error))?;
let separate_test_output = request.test_reexec;
let receipt_fd = request.cleanup_receipt_fd;
#[cfg(target_os = "linux")]
let cancel_fd = request.cancel_request_fd;
let prepared = unsafe { PreparedCommand::from_inherited_request(request) }
.and_then(PreparedCommand::into_command);
let (mut payload_command, cleanup_token) = match prepared {
Ok(prepared) => prepared,
Err(error) => {
write_startup(StartupMessage {
ok: false,
spawn_not_found: false,
error: Some(format!("guardian could not confine the payload: {error}")),
guardian_pid: None,
pid: None,
})?;
return Err(error);
}
};
let mut cleanup_receipt = completion_receipt::inherited_writer(receipt_fd)?;
#[cfg(target_os = "linux")]
let cancellation = cancel_request::inherited_reader(cancel_fd)?;
let _journal_cleanup = OwnerJournalCleanup(cleanup_token.clone());
configure_child_reaper()?;
let mut payload = match payload_command.spawn() {
Ok(payload) => payload,
Err(error) => {
write_startup(StartupMessage {
ok: false,
spawn_not_found: error.kind() == io::ErrorKind::NotFound,
error: Some(error.to_string()),
guardian_pid: None,
pid: None,
})?;
return Err(error);
}
};
let payload_pid = payload.id();
#[cfg(target_os = "linux")]
let payload_identity = cancel_request::ChildIdentity::open(payload_pid).ok();
write_startup(StartupMessage {
ok: true,
spawn_not_found: false,
error: None,
guardian_pid: Some(std::process::id()),
pid: Some(payload_pid),
})?;
if separate_test_output {
test_reexec::write_boundary(&cleanup_token)?;
}
let stdout = payload.stdout.take();
let stderr = payload.stderr.take();
let mut open_outputs = u8::from(stdout.is_some()) + u8::from(stderr.is_some());
let payload_stdin = payload.stdin.take();
let (event_tx, event_rx) = std::sync::mpsc::channel();
#[cfg(target_os = "linux")]
cancel_request::watch(cancellation, event_tx.clone());
if payload_stdin.is_some() {
let event_tx = event_tx.clone();
harn_parser::runtime_stack::spawn(move || {
let event = match wait_for_owner_pipe_close() {
Ok(()) => GuardianEvent::OwnerClosed,
Err(error) => GuardianEvent::InputFailed(error),
};
let _ = event_tx.send(event);
});
}
if let Some(mut stdout) = stdout {
let event_tx = event_tx.clone();
harn_parser::runtime_stack::spawn(move || {
let _ = output_relay::copy(&mut stdout, io::stdout());
let _ = event_tx.send(GuardianEvent::OutputClosed);
});
}
if let Some(mut stderr) = stderr {
let event_tx = event_tx.clone();
harn_parser::runtime_stack::spawn(move || {
let _ = output_relay::copy(&mut stderr, io::stderr());
let _ = event_tx.send(GuardianEvent::OutputClosed);
});
}
{
let event_tx = event_tx.clone();
harn_parser::runtime_stack::spawn(move || {
let status = wait_for_payload_while_reaping_adopted(payload);
let _ = event_tx.send(GuardianEvent::PayloadExited(status));
});
}
{
let event_tx = event_tx.clone();
harn_parser::runtime_stack::spawn(move || {
let mut stdin = io::stdin();
let event = match relay_payload_stdin(&mut stdin, payload_stdin) {
Ok(()) => GuardianEvent::OwnerClosed,
Err(error) if error.kind() == io::ErrorKind::UnexpectedEof => {
GuardianEvent::OwnerClosed
}
Err(error) => GuardianEvent::InputFailed(error),
};
let _ = event_tx.send(event);
});
}
drop(event_tx);
let mut payload_status = None;
#[cfg(target_os = "linux")]
let mut cancellation_cleanup = None;
while let Ok(event) = event_rx.recv() {
match event {
#[cfg(target_os = "linux")]
GuardianEvent::CancelRequested => {
cancellation_cleanup =
cancel_request::terminate(payload_identity.clone(), payload_pid);
}
event @ (GuardianEvent::OwnerClosed | GuardianEvent::InputFailed(_)) => {
if let GuardianEvent::InputFailed(error) = event {
eprintln!("guardian input failed: {error}");
}
let _ =
harn_vm::op_interrupt::signal_pid_tree_and_token_preserving_group_with_report(
payload_pid,
Some(&cleanup_token),
unsafe { libc::getpgrp() as u32 },
libc::SIGKILL,
);
wait_for_payload_exit(&event_rx, &mut payload_status)?;
reap_adopted_children()?;
harn_vm::op_interrupt::remove_process_owner_group_journal(&cleanup_token);
unsafe {
libc::kill(-libc::getpgrp(), libc::SIGKILL);
}
return Err(io::Error::other("guardian process group survived SIGKILL"));
}
GuardianEvent::PayloadExited(status) => {
payload_status = Some(status?);
let mut cleanup =
harn_vm::op_interrupt::signal_pid_tree_and_token_preserving_group_with_report(
payload_pid,
Some(&cleanup_token),
unsafe { libc::getpgrp() as u32 },
libc::SIGKILL,
);
#[cfg(target_os = "linux")]
if let Some(cancelled) = cancellation_cleanup.take() {
cleanup.merge(cancelled);
}
reap_adopted_children()?;
harn_vm::op_interrupt::finish_process_owner_cleanup(&mut cleanup, &cleanup_token);
#[cfg(target_os = "linux")]
{
cleanup.guardian_custody_complete = true;
}
completion_receipt::write(&mut cleanup_receipt, &cleanup)?;
completion_receipt::refuse_survivors(&cleanup)?;
}
GuardianEvent::OutputClosed => open_outputs = open_outputs.saturating_sub(1),
}
if let Some(status) = payload_status.filter(|_| open_outputs == 0) {
harn_vm::op_interrupt::remove_process_owner_group_journal(&cleanup_token);
propagate_exit(status);
}
}
harn_vm::op_interrupt::remove_process_owner_group_journal(&cleanup_token);
Err(io::Error::other(
"guardian event channels closed unexpectedly",
))
}
#[cfg(unix)]
#[doc(hidden)]
#[deprecated(note = "use run_guardian_from_pipe")]
pub fn run_guardian_from_env() -> io::Result<()> {
run_guardian_from_pipe()
}
#[cfg(unix)]
const MAX_INPUT_FRAME_BYTES: usize = 64 * 1024;
#[cfg(unix)]
pub(crate) struct PayloadStdin(std::fs::File);
#[cfg(unix)]
pub(crate) fn payload_stdin(liveness: &ChildStdin) -> io::Result<PayloadStdin> {
use std::os::fd::AsFd;
Ok(PayloadStdin(std::fs::File::from(
liveness.as_fd().try_clone_to_owned()?,
)))
}
#[cfg(unix)]
impl Write for PayloadStdin {
fn write(&mut self, bytes: &[u8]) -> io::Result<usize> {
let count = bytes.len().min(MAX_INPUT_FRAME_BYTES);
if count == 0 {
return Ok(0);
}
self.0.write_all(&(count as u32).to_be_bytes())?;
self.0.write_all(&bytes[..count])?;
Ok(count)
}
fn flush(&mut self) -> io::Result<()> {
self.0.flush()
}
}
#[cfg(unix)]
impl Drop for PayloadStdin {
fn drop(&mut self) {
let _ = self.0.write_all(&0_u32.to_be_bytes());
}
}
#[cfg(unix)]
fn relay_payload_stdin(owner: &mut impl Read, mut payload: Option<impl Write>) -> io::Result<()> {
let mut buffer = [0_u8; 4096];
if payload.is_none() {
while owner.read(&mut buffer)? != 0 {}
return Ok(());
}
let mut closed_by_owner = false;
loop {
let mut header = [0_u8; 4];
owner.read_exact(&mut header)?;
let count = u32::from_be_bytes(header) as usize;
if count == 0 {
drop(payload.take());
closed_by_owner = true;
continue;
}
if count > MAX_INPUT_FRAME_BYTES || closed_by_owner {
return Err(io::Error::new(
io::ErrorKind::InvalidData,
"invalid guardian payload input frame",
));
}
let mut remaining = count;
while remaining != 0 {
let count = remaining.min(buffer.len());
let result = owner.read_exact(&mut buffer[..count]).and_then(|()| {
if let Some(payload) = payload.as_mut() {
payload.write_all(&buffer[..count])
} else {
Ok(())
}
});
buffer[..count].fill(0);
match result {
Err(error) if error.kind() == io::ErrorKind::BrokenPipe => {
drop(payload.take());
}
result => result?,
}
remaining -= count;
}
}
}
#[cfg(unix)]
fn read_request() -> io::Result<Vec<u8>> {
let mut stdin = io::stdin();
let mut request = Vec::new();
loop {
let mut byte = [0_u8; 1];
stdin.read_exact(&mut byte)?;
if byte[0] == b'\n' {
return Ok(request);
}
request.push(byte[0]);
if request.len() > MAX_REQUEST_BYTES {
return Err(io::Error::new(
io::ErrorKind::InvalidData,
format!("guardian request exceeded {MAX_REQUEST_BYTES} bytes"),
));
}
}
}
#[cfg(unix)]
fn run_guardian_reaper() -> ! {
let owner = std::env::var(OWNER_PID_ENV)
.ok()
.and_then(|pid| pid.parse::<libc::pid_t>().ok())
.unwrap_or_else(|| unsafe { libc::getppid() });
let executable = reexec_executable().unwrap_or_else(|error| {
eprintln!("resolve guardian executable: {error}");
std::process::exit(1);
});
let (relay_reader, relay_writer) = io::pipe().unwrap_or_else(|error| {
eprintln!("create guardian liveness relay: {error}");
std::process::exit(1);
});
let mut guardian = {
let mut guardian = Command::new(executable);
guardian
.args(std::env::args_os().skip(1))
.env_remove(REAPER_ENV)
.env_remove(OWNER_PID_ENV)
.stdin(Stdio::from(relay_reader))
.stdout(Stdio::inherit())
.stderr(Stdio::inherit());
super::real::configure_background_process_group(&mut guardian);
guardian.spawn().unwrap_or_else(|error| {
eprintln!("spawn process guardian: {error}");
std::process::exit(1);
})
};
harn_parser::runtime_stack::spawn(move || relay_owner_liveness(owner, relay_writer));
match guardian.wait() {
Ok(status) => propagate_exit(status),
Err(error) => {
eprintln!("reap process guardian: {error}");
std::process::exit(1);
}
}
}
#[cfg(unix)]
fn relay_owner_liveness(owner: libc::pid_t, mut guardian: io::PipeWriter) {
use std::os::fd::AsRawFd;
let fd = guardian.as_raw_fd();
let flags = unsafe { libc::fcntl(fd, libc::F_GETFL) };
if flags < 0 || unsafe { libc::fcntl(fd, libc::F_SETFL, flags | libc::O_NONBLOCK) } < 0 {
return;
}
let mut buffer = [0_u8; 4096];
while unsafe { libc::getppid() } == owner {
let mut poll_fd = libc::pollfd {
fd: libc::STDIN_FILENO,
events: libc::POLLIN,
revents: 0,
};
match unsafe { libc::poll(&raw mut poll_fd, 1, OWNER_POLL_INTERVAL_MS) } {
0 => continue,
ready if ready < 0 => {
if io::Error::last_os_error().kind() == io::ErrorKind::Interrupted {
continue;
}
return;
}
_ => {}
}
let read =
unsafe { libc::read(libc::STDIN_FILENO, buffer.as_mut_ptr().cast(), buffer.len()) };
match read {
0 => return,
read if read > 0 => {
let copied =
write_relay_while_owner_alive(owner, &mut guardian, &buffer[..read as usize]);
buffer.fill(0);
if !matches!(copied, Ok(true)) {
return;
}
}
_ => {
if io::Error::last_os_error().kind() == io::ErrorKind::Interrupted {
continue;
}
return;
}
}
}
}
#[cfg(unix)]
fn write_relay_while_owner_alive(
owner: libc::pid_t,
guardian: &mut io::PipeWriter,
mut bytes: &[u8],
) -> io::Result<bool> {
use std::os::fd::AsRawFd;
while !bytes.is_empty() {
if unsafe { libc::getppid() } != owner {
return Ok(false);
}
let mut pipe = libc::pollfd {
fd: guardian.as_raw_fd(),
events: libc::POLLOUT,
revents: 0,
};
match unsafe { libc::poll(&raw mut pipe, 1, OWNER_POLL_INTERVAL_MS) } {
0 => continue,
ready if ready < 0 => {
let error = io::Error::last_os_error();
if error.kind() == io::ErrorKind::Interrupted {
continue;
}
return Err(error);
}
_ => {}
}
if pipe.revents & (libc::POLLHUP | libc::POLLERR | libc::POLLNVAL) != 0 {
return Err(io::Error::new(
io::ErrorKind::BrokenPipe,
"guardian relay closed",
));
}
match guardian.write(bytes) {
Ok(0) => {
return Err(io::Error::new(
io::ErrorKind::WriteZero,
"guardian relay stopped",
))
}
Ok(written) => bytes = &bytes[written..],
Err(error)
if matches!(
error.kind(),
io::ErrorKind::Interrupted | io::ErrorKind::WouldBlock
) => {}
Err(error) => return Err(error),
}
}
Ok(true)
}
#[cfg(target_os = "linux")]
fn configure_child_reaper() -> io::Result<()> {
if unsafe { libc::prctl(libc::PR_SET_CHILD_SUBREAPER, 1, 0, 0, 0) } == 0 {
Ok(())
} else {
Err(io::Error::last_os_error())
}
}
#[cfg(all(unix, not(target_os = "linux")))]
fn configure_child_reaper() -> io::Result<()> {
Ok(())
}
#[cfg(unix)]
fn wait_for_payload_while_reaping_adopted(payload: Child) -> io::Result<ExitStatus> {
let payload_pid = payload.id() as libc::pid_t;
let _payload = payload;
loop {
let mut status = 0;
let waited = unsafe { libc::waitpid(-1, &raw mut status, 0) };
if waited == payload_pid {
return Ok(ExitStatus::from_raw(status));
}
if waited > 0 {
continue;
}
let error = io::Error::last_os_error();
match error.raw_os_error() {
Some(libc::EINTR) => continue,
_ => return Err(error),
}
}
}
#[cfg(unix)]
fn wait_for_payload_exit(
events: &std::sync::mpsc::Receiver<GuardianEvent>,
payload_status: &mut Option<ExitStatus>,
) -> io::Result<()> {
while payload_status.is_none() {
match events.recv() {
Ok(GuardianEvent::PayloadExited(status)) => *payload_status = Some(status?),
Ok(
GuardianEvent::OutputClosed
| GuardianEvent::OwnerClosed
| GuardianEvent::InputFailed(_),
) => {}
#[cfg(target_os = "linux")]
Ok(GuardianEvent::CancelRequested) => {}
Err(_) => {
return Err(io::Error::other(
"guardian events closed before payload exit",
));
}
}
}
Ok(())
}
#[cfg(target_os = "linux")]
fn reap_adopted_children() -> io::Result<()> {
let error =
match adopted_children::terminate_and_reap(harn_vm::op_interrupt::SUBPROCESS_TERM_GRACE) {
Ok(()) => return Ok(()),
Err(error) => error,
};
retain_adopted_children(error)
}
#[cfg(target_os = "linux")]
fn retain_adopted_children(error: io::Error) -> io::Result<()> {
eprintln!("guardian cleanup incomplete; retaining child custody: {error}");
loop {
let result = unsafe { libc::waitpid(-1, std::ptr::null_mut(), 0) };
if result > 0 {
continue;
}
match io::Error::last_os_error().raw_os_error() {
Some(libc::EINTR) => continue,
Some(libc::ECHILD) => return Err(error),
_ => return Err(io::Error::last_os_error()),
}
}
}
#[cfg(all(unix, not(target_os = "linux")))]
fn reap_adopted_children() -> io::Result<()> {
Ok(())
}
#[cfg(unix)]
#[doc(hidden)]
pub fn guardian_requested() -> bool {
std::env::var(MODE_ENV).as_deref() == Ok(PIPE_MODE)
}
#[cfg(unix)]
enum GuardianEvent {
#[cfg(target_os = "linux")]
CancelRequested,
OwnerClosed,
InputFailed(io::Error),
PayloadExited(io::Result<ExitStatus>),
OutputClosed,
}
#[cfg(unix)]
fn write_startup(message: StartupMessage) -> io::Result<()> {
let mut stderr = io::stderr();
serde_json::to_writer(&mut stderr, &message)?;
stderr.write_all(b"\n")?;
stderr.flush()
}
#[cfg(unix)]
fn propagate_exit(status: ExitStatus) -> ! {
if let Some(code) = status.code() {
std::process::exit(code);
}
if let Some(signal) = status.signal() {
unsafe {
libc::signal(signal, libc::SIG_DFL);
libc::raise(signal);
}
std::process::exit(128 + signal);
}
std::process::exit(1);
}
#[cfg(unix)]
pub fn run_if_requested() -> bool {
DISPATCHER_READY.store(true, Ordering::Release);
if std::env::args_os().nth(1).as_deref() != Some(OsStr::new(GUARDIAN_ARG)) {
return false;
}
if let Err(error) = run_guardian_from_pipe() {
eprintln!("harn process guardian failed: {error}");
std::process::exit(1);
}
unreachable!("guardian execution always exits")
}
#[cfg(all(test, unix))]
#[path = "owner_death_tests.rs"]
mod tests;
#[cfg(not(unix))]
pub fn run_if_requested() -> bool {
false
}