use nix::sys::statvfs::FsFlags;
use nix::sys::statvfs::statvfs;
use reverie::Errno;
use reverie::Pid;
pub const READONLY_WARNING: &str =
"hermit: warning: /proc is mounted read-only; guest writes to procfs may fail with EROFS.\n";
fn write_warning(warning: &str) {
let (blocked, original, pending) = unsafe {
let mut blocked = std::mem::zeroed::<libc::sigset_t>();
let mut original = std::mem::zeroed::<libc::sigset_t>();
let mut pending = std::mem::zeroed::<libc::sigset_t>();
libc::sigemptyset(&mut blocked);
libc::sigaddset(&mut blocked, libc::SIGPIPE);
if libc::sigprocmask(libc::SIG_BLOCK, &blocked, &mut original) == -1 {
return;
}
if libc::sigpending(&mut pending) == -1 {
libc::sigprocmask(libc::SIG_SETMASK, &original, std::ptr::null_mut());
return;
}
(blocked, original, pending)
};
let mut broken_pipe = false;
let mut remaining = warning.as_bytes();
while !remaining.is_empty() {
let written = unsafe {
libc::write(
libc::STDERR_FILENO,
remaining.as_ptr().cast(),
remaining.len(),
)
};
if written > 0 {
remaining = &remaining[written as usize..];
} else if written == -1 && Errno::last() == Errno::EINTR {
continue;
} else {
broken_pipe = written == -1 && Errno::last() == Errno::EPIPE;
break;
}
}
unsafe {
if broken_pipe && libc::sigismember(&pending, libc::SIGPIPE) == 0 {
let timeout = libc::timespec {
tv_sec: 0,
tv_nsec: 0,
};
while libc::sigtimedwait(&blocked, std::ptr::null_mut(), &timeout) == -1
&& Errno::last() == Errno::EINTR
{}
}
libc::sigprocmask(libc::SIG_SETMASK, &original, std::ptr::null_mut());
}
}
pub fn warn_if_readonly_proc() {
let mut stats = std::mem::MaybeUninit::<libc::statfs64>::uninit();
if unsafe { libc::statfs64(c"/proc".as_ptr(), stats.as_mut_ptr()) } == -1 {
write_warning("hermit: warning: could not determine the /proc mount mode.\n");
} else if unsafe { stats.assume_init().f_flags } & libc::ST_RDONLY as libc::c_long != 0 {
write_warning(READONLY_WARNING);
}
}
pub(crate) fn guest_proc_readonly(pid: Pid) -> Option<bool> {
match statvfs(format!("/proc/{pid}/root/proc").as_str()) {
Ok(stats) => Some(stats.flags().contains(FsFlags::ST_RDONLY)),
Err(error) => {
write_warning(&format!(
"hermit: warning: could not determine the guest /proc mount mode: {error}\n"
));
None
}
}
}
pub(crate) fn report_proc_mode(recorded: Option<bool>, actual: Option<bool>) {
if let (Some(recorded), Some(actual)) = (recorded, actual)
&& recorded != actual
{
let mode = |readonly| if readonly { "read-only" } else { "read-write" };
write_warning(&format!(
"hermit: warning: /proc mount mode differs: recording was {}, replay is {}; \
guest procfs writes may behave differently.\n",
mode(recorded),
mode(actual)
));
} else if actual == Some(true) {
write_warning(READONLY_WARNING);
}
}
#[cfg(test)]
mod tests {
use std::os::fd::AsRawFd;
use std::os::fd::FromRawFd;
use std::os::fd::OwnedFd;
use reverie::process::Container;
#[test]
fn readonly_proc_warning_survives_closed_stderr() {
let mut descriptors = [-1; 2];
assert_eq!(
unsafe { libc::pipe2(descriptors.as_mut_ptr(), libc::O_CLOEXEC) },
0,
"create stderr pipe: {}",
std::io::Error::last_os_error()
);
let (reader, writer) = unsafe {
(
OwnedFd::from_raw_fd(descriptors[0]),
OwnedFd::from_raw_fd(descriptors[1]),
)
};
drop(reader);
let observation = Container::new()
.run(|| {
unsafe {
let mut action = std::mem::zeroed::<libc::sigaction>();
action.sa_sigaction = libc::SIG_DFL;
libc::sigemptyset(&mut action.sa_mask);
let mut signals = std::mem::zeroed::<libc::sigset_t>();
libc::sigemptyset(&mut signals);
libc::sigaddset(&mut signals, libc::SIGPIPE);
if libc::dup2(writer.as_raw_fd(), libc::STDERR_FILENO) == -1
|| libc::sigaction(libc::SIGPIPE, &action, std::ptr::null_mut()) == -1
|| libc::sigprocmask(libc::SIG_UNBLOCK, &signals, std::ptr::null_mut())
== -1
{
return Err(*libc::__errno_location());
}
super::report_proc_mode(None, Some(true));
let mut mask = std::mem::zeroed::<libc::sigset_t>();
let mut pending = std::mem::zeroed::<libc::sigset_t>();
if libc::sigprocmask(libc::SIG_BLOCK, std::ptr::null(), &mut mask) == -1
|| libc::sigpending(&mut pending) == -1
|| libc::sigaction(libc::SIGPIPE, std::ptr::null(), &mut action) == -1
{
return Err(*libc::__errno_location());
}
Ok((
libc::getpid(),
action.sa_sigaction == libc::SIG_DFL,
libc::sigismember(&mask, libc::SIGPIPE) == 0,
libc::sigismember(&pending, libc::SIGPIPE) == 0,
))
}
})
.expect("the warning must not terminate the child with SIGPIPE")
.expect("configure and inspect child stderr and signal state");
assert!(
observation.0 > 1,
"the child must not be PID namespace init"
);
assert_eq!(
(observation.1, observation.2, observation.3),
(true, true, true),
"the warning must preserve default/unblocked SIGPIPE and consume its own pending signal"
);
}
}