Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
2 changes: 2 additions & 0 deletions litebox_common_linux/src/lib.rs
Original file line number Diff line number Diff line change
Expand Up @@ -1972,6 +1972,8 @@ pub struct TaskParams {
pub blocked_signals: SigSet,
/// The signals initially ignored; all other dispositions start as default.
pub ignored_signals: SigSet,
/// Queued signals pending at start for the process or its main thread, with their `siginfo`.
pub pending_signals: program_startup::PendingSignalQueues,
/// Descriptors inherited from the parent, or `None` to start with the standard streams.
pub inherited_fds: Option<alloc::vec::Vec<program_startup::InheritedFd>>,
/// The absolute working directory inherited from the parent, or `None` to start at `/`.
Expand Down
198 changes: 176 additions & 22 deletions litebox_common_linux/src/program_startup.rs
Original file line number Diff line number Diff line change
Expand Up @@ -17,14 +17,14 @@ use litebox_broker_protocol::socket::SocketType;
use zerocopy::{FromBytes, IntoBytes};

use crate::GuestVectorState;
use crate::signal::{NSIG, SigAction, SigAltStack, SigSet};
use crate::signal::{NSIG, SigAction, SigAltStack, SigSet, Siginfo, Signal};
use crate::vmem::VmFlags;
use crate::{PtRegs, ResourceLimitValues, TASK_COMM_LEN};
#[cfg(target_arch = "aarch64")]
use litebox::arch::aarch64::vector::SveVectorLength;

const HEADER_SIZE: usize = size_of::<u8>()
+ size_of::<[u32; 11]>()
+ size_of::<[u32; 13]>()
+ size_of::<[u64; 2]>()
+ size_of::<ResourceLimitValues>()
+ size_of::<u8>()
Expand Down Expand Up @@ -89,6 +89,8 @@ pub struct LinuxProgramStartup {
pub blocked_signals: SigSet,
/// Signals whose ignored disposition survives `execve`.
pub ignored_signals: SigSet,
/// Signals pending at `execve`, which survive it.
pub pending_signals: PendingSignalQueues,
/// File mode creation mask, with only permission bits set.
pub umask: u32,
/// Resource limits, which survive `execve`.
Expand All @@ -115,6 +117,18 @@ pub struct LinuxProgramStartup {
pub inherited_fds: Vec<InheritedFd>,
}

/// Queued signals pending for a process that starts a program, with each instance's `siginfo`.
///
/// Each queue keeps the order of real-time instances and contains at most one instance of each
/// standard signal. Signal numbers must be valid Linux signals.
#[derive(Clone, Debug, Default, PartialEq, Eq)]
pub struct PendingSignalQueues {
/// Signals pending for the process, which any of its threads may take.
pub process: Vec<Siginfo>,
/// Signals pending for the thread that starts the program, which becomes its main thread.
pub thread: Vec<Siginfo>,
}

/// A descriptor inherited across `execve`, as Linux keeps every descriptor not marked
/// close-on-exec.
///
Expand Down Expand Up @@ -349,6 +363,12 @@ impl LinuxProgramStartup {
u32::try_from(self.inherited_fds.len())
.map_err(|_| LinuxProgramStartupError::TooLarge)?,
);
for queue in [&self.pending_signals.process, &self.pending_signals.thread] {
push_u32(
&mut output,
u32::try_from(queue.len()).map_err(|_| LinuxProgramStartupError::TooLarge)?,
);
}
output.extend_from_slice(self.path.as_bytes());
output.extend_from_slice(self.execfn.as_bytes());
output.extend_from_slice(self.cwd.as_bytes());
Expand All @@ -360,6 +380,14 @@ impl LinuxProgramStartup {
);
output.extend_from_slice(value);
}
for siginfo in self
.pending_signals
.process
.iter()
.chain(&self.pending_signals.thread)
{
output.extend_from_slice(siginfo.as_bytes());
}
for inherited in &self.inherited_fds {
inherited.encode(&mut output);
}
Expand Down Expand Up @@ -399,6 +427,10 @@ impl LinuxProgramStartup {
.map_err(|_| LinuxProgramStartupError::Malformed)?;
let inherited_fd_count = usize::try_from(read_u32(&mut input)?)
.map_err(|_| LinuxProgramStartupError::Malformed)?;
let process_signal_count = usize::try_from(read_u32(&mut input)?)
.map_err(|_| LinuxProgramStartupError::Malformed)?;
let thread_signal_count = usize::try_from(read_u32(&mut input)?)
.map_err(|_| LinuxProgramStartupError::Malformed)?;
let path_bytes = take_bytes(&mut input, path_length)?;
let path = core::str::from_utf8(path_bytes)
.map_err(|_| LinuxProgramStartupError::InvalidPath)?
Expand Down Expand Up @@ -428,6 +460,10 @@ impl LinuxProgramStartup {
.map_err(|_| LinuxProgramStartupError::InvalidString)?,
);
}
let pending_signals = PendingSignalQueues {
process: read_signals(&mut input, process_signal_count)?,
thread: read_signals(&mut input, thread_signal_count)?,
};
if inherited_fd_count > input.len() / INHERITED_FD_HEADER_SIZE {
return Err(LinuxProgramStartupError::Malformed);
}
Expand All @@ -449,6 +485,7 @@ impl LinuxProgramStartup {
egid: effective_group_id,
blocked_signals,
ignored_signals,
pending_signals,
umask,
resource_limits,
no_new_privs,
Expand Down Expand Up @@ -748,6 +785,20 @@ fn validate(startup: &LinuxProgramStartup) -> Result<(), LinuxProgramStartupErro
if startup.umask & !0o777 != 0 {
return Err(LinuxProgramStartupError::InvalidUmask);
}
for queue in [
&startup.pending_signals.process,
&startup.pending_signals.thread,
] {
let mut seen = SigSet::empty();
for info in queue {
let signal =
Signal::try_from(info.signo).map_err(|_| LinuxProgramStartupError::Malformed)?;
if !signal.is_rt_signal() && seen.contains(signal) {
return Err(LinuxProgramStartupError::Malformed);
}
seen.add(signal);
}
}
validate_resource_limits(&startup.resource_limits)
}

Expand Down Expand Up @@ -792,6 +843,19 @@ fn encoded_len(startup: &LinuxProgramStartup) -> Result<usize, LinuxProgramStart
if length > MAX_PROCESS_BOOTSTRAP_SIZE as usize {
return Err(LinuxProgramStartupError::TooLarge);
}
for queue in [
&startup.pending_signals.process,
&startup.pending_signals.thread,
] {
length = queue
.len()
.checked_mul(size_of::<Siginfo>())
.and_then(|queue_length| length.checked_add(queue_length))
.ok_or(LinuxProgramStartupError::TooLarge)?;
if length > MAX_PROCESS_BOOTSTRAP_SIZE as usize {
return Err(LinuxProgramStartupError::TooLarge);
}
}
for value in startup.argv.iter().chain(&startup.envp) {
length = length
.checked_add(size_of::<u32>())
Expand All @@ -816,6 +880,21 @@ fn push_u32(output: &mut Vec<u8>, value: u32) {
output.extend_from_slice(&value.to_le_bytes());
}

fn read_signals(input: &mut &[u8], count: usize) -> Result<Vec<Siginfo>, LinuxProgramStartupError> {
let length = count
.checked_mul(size_of::<Siginfo>())
.ok_or(LinuxProgramStartupError::Malformed)?;
let mut bytes = take_bytes(input, length)?;
let mut signals = Vec::new();
signals
.try_reserve_exact(count)
.map_err(|_| LinuxProgramStartupError::TooLarge)?;
for _ in 0..count {
signals.push(read_value(&mut bytes)?);
}
Ok(signals)
}

fn push_u64(output: &mut Vec<u8>, value: u64) {
output.extend_from_slice(&value.to_le_bytes());
}
Expand Down Expand Up @@ -936,7 +1015,7 @@ fn take_bytes<'a>(
#[cfg(test)]
mod tests {
use super::*;
use crate::signal::Signal;
use crate::signal::{SI_USER, SiginfoData};
use alloc::vec;

fn resource_limits() -> ResourceLimitValues {
Expand All @@ -946,15 +1025,98 @@ mod tests {
})
}

fn siginfo(signal: Signal, pid: i32) -> Siginfo {
Siginfo {
signo: signal.as_i32(),
errno: 0,
code: SI_USER,
#[cfg(target_pointer_width = "64")]
__pad: 0,
data: SiginfoData::new_kill(pid, 1000),
}
}

fn program_startup() -> LinuxProgramStartup {
LinuxProgramStartup {
uid: 0,
euid: 0,
gid: 0,
egid: 0,
blocked_signals: SigSet::empty(),
ignored_signals: SigSet::empty(),
pending_signals: PendingSignalQueues::default(),
umask: 0o022,
resource_limits: resource_limits(),
no_new_privs: false,
#[cfg(target_arch = "aarch64")]
sve_vl_inherit: false,
path: "/child".into(),
execfn: "/child".into(),
cwd: "/".into(),
argv: vec![CString::new("child").unwrap()],
envp: Vec::new(),
inherited_fds: Vec::new(),
}
}

#[test]
fn program_startup_rejects_invalid_pending_signal_queues() {
let realtime = Signal::try_from(crate::signal::SIGRTMIN).unwrap();
let mut startup = program_startup();
startup.argv.clear();
startup.pending_signals.process = vec![siginfo(realtime, 7), siginfo(realtime, 8)];
let encoded = startup.encode().unwrap();
let first_signal =
HEADER_SIZE + startup.path.len() + startup.execfn.len() + startup.cwd.len();
for invalid_signal in [0_i32, 65] {
let mut invalid = encoded.clone();
invalid[first_signal..first_signal + size_of::<i32>()]
.copy_from_slice(&invalid_signal.to_ne_bytes());
assert_eq!(
LinuxProgramStartup::decode(&invalid),
Err(LinuxProgramStartupError::Malformed)
);
}
let mut duplicates = encoded.clone();
for offset in [first_signal, first_signal + size_of::<Siginfo>()] {
duplicates[offset..offset + size_of::<i32>()]
.copy_from_slice(&Signal::SIGUSR1.as_i32().to_ne_bytes());
}
assert_eq!(
LinuxProgramStartup::decode(&duplicates),
Err(LinuxProgramStartupError::Malformed)
);
assert_eq!(
LinuxProgramStartup::decode(&encoded[..encoded.len() - 1]),
Err(LinuxProgramStartupError::Malformed)
);

startup.pending_signals.process = vec![siginfo(Signal::SIGUSR1, 7); 2];
assert_eq!(startup.encode(), Err(LinuxProgramStartupError::Malformed));
startup.pending_signals.process =
vec![siginfo(realtime, 7); MAX_PROCESS_BOOTSTRAP_SIZE as usize / size_of::<Siginfo>()];
assert_eq!(startup.encode(), Err(LinuxProgramStartupError::TooLarge));
}

#[test]
fn program_startup_round_trips() {
let real_time = Signal::try_from(crate::signal::SIGRTMIN).unwrap();
let startup = LinuxProgramStartup {
uid: 1000,
euid: 1001,
gid: 1002,
egid: 1003,
blocked_signals: SigSet::empty().with(Signal::SIGUSR1),
ignored_signals: SigSet::empty().with(Signal::SIGPIPE),
pending_signals: PendingSignalQueues {
process: vec![
siginfo(Signal::SIGUSR1, 7),
siginfo(real_time, 0),
siginfo(real_time, 7),
siginfo(real_time, 8),
],
thread: vec![siginfo(Signal::SIGPIPE, 7), siginfo(real_time, 9)],
},
umask: 0o027,
resource_limits: resource_limits(),
no_new_privs: true,
Expand Down Expand Up @@ -1054,6 +1216,7 @@ mod tests {
egid: 0,
blocked_signals: SigSet::empty(),
ignored_signals: SigSet::empty(),
pending_signals: PendingSignalQueues::default(),
umask: 0o022,
resource_limits: resource_limits(),
no_new_privs: false,
Expand Down Expand Up @@ -1336,25 +1499,7 @@ mod tests {

#[test]
fn program_startup_rejects_trailing_and_invalid_strings() {
let startup = LinuxProgramStartup {
uid: 0,
euid: 0,
gid: 0,
egid: 0,
blocked_signals: SigSet::empty(),
ignored_signals: SigSet::empty(),
umask: 0o022,
resource_limits: resource_limits(),
no_new_privs: false,
#[cfg(target_arch = "aarch64")]
sve_vl_inherit: false,
path: "/child".into(),
execfn: "/child".into(),
cwd: "/".into(),
argv: vec![CString::new("child").unwrap()],
envp: Vec::new(),
inherited_fds: Vec::new(),
};
let startup = program_startup();
let mut encoded = startup.encode().unwrap();
encoded.push(0);
assert_eq!(
Expand Down Expand Up @@ -1383,6 +1528,15 @@ mod tests {
Err(LinuxProgramStartupError::InvalidString)
);

// A signal count must fit within the remaining payload.
let mut oversized_signal_count = startup.encode().unwrap();
oversized_signal_count[HEADER_SIZE - 2 * size_of::<u32>()..HEADER_SIZE - size_of::<u32>()]
.copy_from_slice(&u32::MAX.to_le_bytes());
assert_eq!(
LinuxProgramStartup::decode(&oversized_signal_count),
Err(LinuxProgramStartupError::Malformed)
);

// Raise the soft limit of resource 1 above its hard limit of 1.
let mut soft_above_hard = startup.encode().unwrap();
let limits = 1 + 4 * size_of::<u32>() + 2 * size_of::<u64>() + size_of::<u32>();
Expand Down
6 changes: 3 additions & 3 deletions litebox_common_linux/src/signal/mod.rs
Original file line number Diff line number Diff line change
Expand Up @@ -119,7 +119,7 @@ pub enum SignalDisposition {
Continue,
}

#[derive(Clone, Copy, Debug, PartialEq, Eq, FromBytes, IntoBytes, Immutable)]
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, FromBytes, IntoBytes, Immutable)]
#[repr(transparent)]
pub struct SigSet(u64);

Expand Down Expand Up @@ -357,7 +357,7 @@ pub struct Ucontext {
}

#[repr(C)]
#[derive(Clone, FromBytes, IntoBytes, Immutable)]
#[derive(Clone, Debug, PartialEq, Eq, FromBytes, IntoBytes, Immutable)]
pub struct Siginfo {
pub signo: i32,
pub errno: i32,
Expand All @@ -369,7 +369,7 @@ pub struct Siginfo {
}

#[repr(C, packed)]
#[derive(Clone, Copy, FromBytes, IntoBytes, Immutable)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, FromBytes, IntoBytes, Immutable)]
pub struct SiginfoData {
pub pad: [u32; 28],
}
Expand Down
2 changes: 2 additions & 0 deletions litebox_runner_linux_on_macos_userland/src/lib.rs
Original file line number Diff line number Diff line change
Expand Up @@ -104,6 +104,8 @@ pub fn run(cli_args: CliArgs) -> Result<i32> {
egid: 1000,
blocked_signals: litebox_common_linux::signal::SigSet::empty(),
ignored_signals: litebox_common_linux::signal::SigSet::empty(),
pending_signals:
litebox_common_linux::program_startup::PendingSignalQueues::default(),
inherited_fds: None,
cwd: None,
umask: None,
Expand Down
3 changes: 3 additions & 0 deletions litebox_runner_linux_on_vm_userland/src/linux.rs
Original file line number Diff line number Diff line change
Expand Up @@ -143,6 +143,7 @@ fn serve_requests(
egid: GUEST_GID,
blocked_signals: litebox_common_linux::signal::SigSet::empty(),
ignored_signals: litebox_common_linux::signal::SigSet::empty(),
pending_signals: litebox_common_linux::program_startup::PendingSignalQueues::default(),
inherited_fds: None,
cwd: None,
umask: None,
Expand Down Expand Up @@ -237,6 +238,7 @@ fn run_launched(
egid,
blocked_signals,
ignored_signals,
pending_signals,
umask,
resource_limits,
no_new_privs,
Expand All @@ -260,6 +262,7 @@ fn run_launched(
egid,
blocked_signals,
ignored_signals,
pending_signals,
inherited_fds: Some(inherited_fds),
cwd: Some(cwd),
umask: Some(umask),
Expand Down
Loading
Loading