1use std::collections::HashMap;
12use std::marker::PhantomData;
13use std::sync::Arc;
14use std::sync::Mutex;
15use std::time::Duration;
16
17use detcore_model::bundled_signal_facts;
18use procfs::process::Process;
19use rand::Rng;
20use reverie::BackendCapabilities;
21use reverie::Error;
22use reverie::Guest;
23use reverie::Pid;
24use reverie::Stack;
25use reverie::syscalls;
26use reverie::syscalls::Addr;
27use reverie::syscalls::AddrMut;
28use reverie::syscalls::CloneFlags;
29use reverie::syscalls::Errno;
30use reverie::syscalls::MemoryAccess;
31use reverie::syscalls::ReadAddr;
32use reverie::syscalls::Syscall;
33use reverie::syscalls::SyscallInfo;
34use reverie::syscalls::Timespec;
35use reverie::syscalls::WaitPidFlag;
36use tracing::debug;
37use tracing::error;
38use tracing::info;
39use tracing::trace;
40
41use crate::SharedMemoryObjectId;
42use crate::config::BlockingMode;
43use crate::config::Config;
44use crate::config::SchedHeuristic;
45use crate::memory::MemoryMetadata;
46use crate::record_or_replay::RecordOrReplay;
47use crate::resources::ExternalOpId;
48use crate::resources::Permission;
49use crate::resources::ResourceID;
50use crate::resources::Resources;
51use crate::scheduler::FutexSignalWatch;
52use crate::scheduler::HostTimedSignalScope;
53use crate::scheduler::SchedValue;
54use crate::scheduler::pid_namespaces::GuestPidAnswer;
55use crate::syscalls::helpers::NonblockableSyscall;
56use crate::syscalls::helpers::RestartCall;
57use crate::syscalls::helpers::keep_restart_block;
58use crate::syscalls::helpers::record_retry_event;
59use crate::syscalls::helpers::retry_nonblocking_syscall;
60use crate::syscalls::helpers::retry_nonblocking_syscall_with_timeout;
61use crate::syscalls::robust_list;
62use crate::tool_global::FutexAction;
63use crate::tool_global::ResumeStatus;
64use crate::tool_global::await_exact_child_physical_exit;
65use crate::tool_global::cancel_exec;
66use crate::tool_global::child_tid_clear_address;
67use crate::tool_global::consume_child_wait;
68use crate::tool_global::create_child_thread;
69use crate::tool_global::futex_action;
70use crate::tool_global::hold_turn_for_group_exit;
71use crate::tool_global::host_timed_signals;
72use crate::tool_global::prepare_exec;
73use crate::tool_global::process_group;
74use crate::tool_global::ready_child_wait;
75use crate::tool_global::record_host_timed_signals;
76use crate::tool_global::resource_request;
77use crate::tool_global::set_child_tid_address;
78use crate::tool_global::thread_is_live;
79use crate::tool_global::thread_observe_time;
80use crate::tool_global::wait_for_child_lifecycle;
81use crate::tool_global::yield_once;
82use crate::tool_local::Detcore;
83use crate::tool_local::PendingVfork;
84use crate::tool_local::RobustListExit;
85use crate::tool_local::RobustListOwner;
86use crate::tool_local::RobustListWake;
87use crate::types::ChildWaitExitClass;
88use crate::types::ChildWaitSelector;
89use crate::types::ChildWaitSpec;
90use crate::types::DetPid;
91use crate::types::DetTid;
92use crate::types::ExactChildWaitState;
93use crate::types::FutexID;
94use crate::types::LogicalTime;
95use crate::types::SigWrapper;
96
97#[path = "emulated_waitid.rs"]
98mod emulated_waitid;
99
100pub(crate) const VIRTUAL_CPUSET_BYTES: usize = 16;
103
104const IOPRIO_WHO_PROCESS: libc::c_int = 1;
105const IOPRIO_WHO_PGRP: libc::c_int = 2;
106const IOPRIO_WHO_USER: libc::c_int = 3;
107const IOPRIO_CLASS_SHIFT: libc::c_int = 13;
108const IOPRIO_CLASS_BE: libc::c_int = 2;
109const IOPRIO_BE_NORM: libc::c_int = 4;
110const IOPRIO_DEFAULT_EFFECTIVE: libc::c_int =
111 (IOPRIO_CLASS_BE << IOPRIO_CLASS_SHIFT) | IOPRIO_BE_NORM;
112
113const SCHED_ATTR_SIZE_VER0: u32 = 48; const SCHED_ATTR_SIZE_VER1: u32 = 56; const SCHED_ATTR_KERNEL_SIZE: u32 = SCHED_ATTR_SIZE_VER1;
125const SCHED_ATTR_MAX_SIZE: u32 = 4096;
128
129const VIRTUAL_CURRENT_POLICY: u32 = libc::SCHED_OTHER as u32;
135
136#[derive(Debug, Eq, PartialEq)]
138enum TailVerdict {
139 AllZero,
140 NotZeroed,
143 Faulted,
145}
146
147const MIN_PROTECTION_RESPECTING_READ: usize = std::mem::size_of::<u64>() + 1;
154
155fn scan_tail_is_zeroed<M: MemoryAccess>(
171 memory: &M,
172 base: AddrMut<u8>,
173 tail_off: usize,
174 tail_len: usize,
175) -> TailVerdict {
176 const CHUNK: usize = 256;
177 let mut done = 0usize;
178 let mut buf = [0u8; CHUNK];
179 while done < tail_len {
180 let remaining = tail_len - done;
181 let want = remaining.min(CHUNK);
182 let back = MIN_PROTECTION_RESPECTING_READ
189 .saturating_sub(want)
190 .min(done + tail_off);
191 let read_len = want + back;
192 let start = tail_off + done - back;
193 let Some(addr) = base
194 .as_raw()
195 .checked_add(start)
196 .and_then(AddrMut::<u8>::from_raw)
197 else {
198 return TailVerdict::Faulted;
199 };
200 let got = memory.read(addr, &mut buf[..read_len]).unwrap_or(0);
204 let new_from = back.min(got);
206 if buf[new_from..got].iter().any(|byte| *byte != 0) {
207 return TailVerdict::NotZeroed;
208 }
209 if got < read_len {
210 return TailVerdict::Faulted;
213 }
214 done += want;
215 }
216 TailVerdict::AllZero
217}
218
219const SCHED_FIFO: u32 = 1;
221const SCHED_RR: u32 = 2;
222const SCHED_DEADLINE: u32 = 6;
223const SCHED_EXT: u32 = 7;
224const MAX_RT_PRIO: u32 = 100;
226
227const SCHED_ATTR_OFF_POLICY: usize = 4;
230const SCHED_ATTR_OFF_FLAGS: usize = 8;
231const SCHED_ATTR_OFF_PRIORITY: usize = 20;
232const SCHED_ATTR_OFF_RUNTIME: usize = 24;
233const SCHED_ATTR_OFF_DEADLINE: usize = 32;
234const SCHED_ATTR_OFF_PERIOD: usize = 40;
235
236const SCHED_FLAG_RESET_ON_FORK: u64 = 0x01;
238const SCHED_FLAG_RECLAIM: u64 = 0x02;
239const SCHED_FLAG_DL_OVERRUN: u64 = 0x04;
240const SCHED_FLAG_KEEP_POLICY: u64 = 0x08;
241const SCHED_FLAG_KEEP_PARAMS: u64 = 0x10;
242const SCHED_FLAG_UTIL_CLAMP_MIN: u64 = 0x20;
243const SCHED_FLAG_UTIL_CLAMP_MAX: u64 = 0x40;
244const SCHED_FLAG_UTIL_CLAMP: u64 = SCHED_FLAG_UTIL_CLAMP_MIN | SCHED_FLAG_UTIL_CLAMP_MAX;
245const SCHED_FLAG_ALL: u64 = SCHED_FLAG_RESET_ON_FORK
246 | SCHED_FLAG_RECLAIM
247 | SCHED_FLAG_DL_OVERRUN
248 | SCHED_FLAG_KEEP_POLICY
249 | SCHED_FLAG_KEEP_PARAMS
250 | SCHED_FLAG_UTIL_CLAMP;
251
252fn is_valid_sched_policy(policy: u32) -> bool {
258 matches!(
259 policy,
260 0 | 1 | 2 | 3
262 | 5
264 | SCHED_DEADLINE
265 | SCHED_EXT
266 )
267}
268
269fn is_rt_policy(policy: u32) -> bool {
271 policy == SCHED_FIFO || policy == SCHED_RR
272}
273
274fn deadline_params_are_valid(runtime: u64, deadline: u64, period: u64) -> bool {
282 if deadline == 0 {
284 return false;
285 }
286 if runtime < (1u64 << 10) {
289 return false;
290 }
291 if deadline & (1u64 << 63) != 0 || period & (1u64 << 63) != 0 {
293 return false;
294 }
295 let period = if period == 0 { deadline } else { period };
297 runtime <= deadline && deadline <= period
299}
300
301fn sched_attr_effective_size(declared: u32) -> Result<u32, ()> {
311 let size = if declared == 0 {
312 SCHED_ATTR_SIZE_VER0
313 } else {
314 declared
315 };
316 if !(SCHED_ATTR_SIZE_VER0..=SCHED_ATTR_MAX_SIZE).contains(&size) {
317 return Err(());
318 }
319 Ok(size)
320}
321
322#[derive(Clone, Copy, Debug)]
324struct SchedAttrFields {
325 policy: u32,
326 sched_flags: u64,
327 priority: u32,
328 runtime: u64,
329 deadline: u64,
330 period: u64,
331}
332
333fn validate_sched_attr_before_lookup(size: u32, attr: &SchedAttrFields) -> Result<(), Errno> {
343 if attr.sched_flags & SCHED_FLAG_UTIL_CLAMP != 0 && size < SCHED_ATTR_SIZE_VER1 {
346 return Err(Errno::EINVAL);
347 }
348 if (attr.policy as i32) < 0 {
352 return Err(Errno::EINVAL);
353 }
354 Ok(())
355}
356
357fn validate_sched_attr_after_lookup(attr: &SchedAttrFields) -> Result<(), Errno> {
363 let policy = if attr.sched_flags & SCHED_FLAG_KEEP_POLICY != 0 {
381 Some(VIRTUAL_CURRENT_POLICY)
382 } else {
383 if !is_valid_sched_policy(attr.policy) {
384 return Err(Errno::EINVAL);
385 }
386 Some(attr.policy)
387 };
388 if attr.sched_flags & !SCHED_FLAG_ALL != 0 {
390 return Err(Errno::EINVAL);
391 }
392 if attr.priority > MAX_RT_PRIO - 1 {
396 return Err(Errno::EINVAL);
397 }
398 if let Some(policy) = policy {
399 if is_rt_policy(policy) != (attr.priority != 0) {
400 return Err(Errno::EINVAL);
401 }
402 if policy == SCHED_DEADLINE
403 && !deadline_params_are_valid(attr.runtime, attr.deadline, attr.period)
404 {
405 return Err(Errno::EINVAL);
406 }
407 }
408 Ok(())
409}
410
411fn virtual_ioprio(which: libc::c_int) -> Result<i64, Errno> {
414 match which {
415 IOPRIO_WHO_PROCESS => Ok(0),
416 IOPRIO_WHO_PGRP | IOPRIO_WHO_USER => Ok(i64::from(IOPRIO_DEFAULT_EFFECTIVE)),
417 _ => Err(Errno::EINVAL),
418 }
419}
420
421#[repr(C)]
422#[derive(Clone, Copy)]
423struct WaitidSigchldFields {
424 pid: libc::pid_t,
425 uid: libc::uid_t,
426 status: libc::c_int,
427 utime: libc::c_long,
428 stime: libc::c_long,
429}
430
431#[repr(C)]
432union WaitidSiginfoFields {
433 _alignment: *mut libc::c_void,
434 sigchld: WaitidSigchldFields,
435}
436
437#[repr(C)]
438struct WaitidSiginfoHead {
439 _base: [libc::c_int; 3],
440 fields: WaitidSiginfoFields,
441}
442
443fn wait_status_is_termination(status: libc::c_int) -> bool {
444 libc::WIFEXITED(status) || libc::WIFSIGNALED(status)
445}
446
447fn waitid_code_is_termination(code: libc::c_int) -> bool {
448 matches!(code, libc::CLD_EXITED | libc::CLD_KILLED | libc::CLD_DUMPED)
449}
450
451fn canonicalize_waitid_siginfo(info: &mut libc::siginfo_t) {
452 debug_assert!(
453 std::mem::size_of::<WaitidSiginfoHead>() <= std::mem::size_of::<libc::siginfo_t>()
454 );
455 let sigchld = unsafe {
460 &mut (*(info as *mut libc::siginfo_t).cast::<WaitidSiginfoHead>())
461 .fields
462 .sigchld
463 };
464 sigchld.utime = 0;
465 sigchld.stime = 0;
466}
467
468fn finish_waitid_result<T, G>(
470 guest: &mut G,
471 call: syscalls::Waitid,
472 value: i64,
473 mut info_value: libc::siginfo_t,
474 child: DetPid,
475) -> Result<i64, Error>
476where
477 T: RecordOrReplay,
478 G: Guest<Detcore<T>>,
479{
480 let child_pid = unsafe { info_value.si_pid() };
483 if child_pid != 0 {
484 canonicalize_waitid_siginfo(&mut info_value);
485 guest.memory().write_value(
486 call.info().expect("waitid infop checked before execution"),
487 &info_value,
488 )?;
489 if call.options() & libc::WNOWAIT == 0 && waitid_code_is_termination(info_value.si_code) {
490 guest.thread_state_mut().reap_child_process_cpu_time(child);
491 }
492 if let Some(rusage) = call.rusage() {
493 let usage: libc::rusage = unsafe { std::mem::zeroed() };
495 guest.memory().write_value(rusage, &usage)?;
496 }
497 }
498 Ok(value)
499}
500
501#[derive(Debug, Eq, PartialEq)]
502enum ExactWaitPollDecision {
503 ChildReady,
504 AwaitPhysicalExit,
505 ReapAfterLogicalExit,
506 Interrupted,
507 Retry,
508}
509
510fn exact_wait_poll_decision(
511 child_ready: bool,
512 signaled: bool,
513 lifecycle: Option<ExactChildWaitState>,
514) -> ExactWaitPollDecision {
515 if child_ready {
516 ExactWaitPollDecision::ChildReady
517 } else if lifecycle == Some(ExactChildWaitState::PhysicalExitPending) {
518 ExactWaitPollDecision::AwaitPhysicalExit
519 } else if matches!(
520 lifecycle,
521 Some(ExactChildWaitState::LogicallyExited | ExactChildWaitState::PhysicallyExited)
522 ) {
523 ExactWaitPollDecision::ReapAfterLogicalExit
524 } else if signaled {
525 ExactWaitPollDecision::Interrupted
526 } else {
527 ExactWaitPollDecision::Retry
528 }
529}
530
531fn stale_any_wait_must_interrupt(signaled: bool, next_ready: Option<DetPid>) -> bool {
532 signaled && next_ready.is_none()
533}
534
535fn terminal_child_wait_spec(
536 selector: ChildWaitSelector,
537 caller: DetTid,
538 options: libc::c_int,
539) -> ChildWaitSpec {
540 let exit_class = if options & libc::__WALL != 0 {
541 ChildWaitExitClass::Any
542 } else if options & libc::__WCLONE != 0 {
543 ChildWaitExitClass::Clone
544 } else {
545 ChildWaitExitClass::Sigchld
546 };
547 ChildWaitSpec {
548 selector,
549 owner: (options & libc::__WNOTHREAD != 0).then_some(caller),
550 exit_class,
551 }
552}
553
554fn validate_wait4_arguments(pid: libc::pid_t, options: WaitPidFlag) -> Result<(), Errno> {
555 let allowed_options = WaitPidFlag::WNOHANG
556 | WaitPidFlag::WUNTRACED
557 | WaitPidFlag::WCONTINUED
558 | WaitPidFlag::__WNOTHREAD
559 | WaitPidFlag::__WCLONE
560 | WaitPidFlag::__WALL;
561
562 if options.bits() & !allowed_options.bits() != 0 {
565 return Err(Errno::EINVAL);
566 }
567 if pid == libc::pid_t::MIN {
570 return Err(Errno::ESRCH);
571 }
572 Ok(())
573}
574
575pub(super) fn wait4_uses_terminal_selector(
582 options: WaitPidFlag,
583 serial_emulated_wait: bool,
584) -> bool {
585 if serial_emulated_wait {
586 options.bits() & !(libc::WNOHANG | libc::WUNTRACED | libc::__WNOTHREAD) == 0
587 } else {
588 !options.intersects(
589 WaitPidFlag::WUNTRACED
590 | WaitPidFlag::WCONTINUED
591 | WaitPidFlag::__WCLONE
592 | WaitPidFlag::__WALL,
593 )
594 }
595}
596
597pub(super) async fn await_selected_child_cpu_publication<G, T>(
606 guest: &mut G,
607 child: DetPid,
608 call: &str,
609) -> Result<(), Error>
610where
611 G: Guest<Detcore<T>>,
612 T: RecordOrReplay,
613{
614 if guest
615 .thread_state()
616 .wait_for_child_cpu_publication(child)
617 .await
618 {
619 Ok(())
620 } else {
621 Err(Error::Tool(anyhow::anyhow!(
622 "emulated {call} selected child has no owned final CPU publication"
623 )))
624 }
625}
626
627pub(super) async fn retire_selected_child<G, T>(
631 guest: &mut G,
632 child: DetPid,
633 call: &str,
634) -> Result<(), Error>
635where
636 G: Guest<Detcore<T>>,
637 T: RecordOrReplay,
638{
639 guest.thread_state_mut().reap_child_process_cpu_time(child);
640 if consume_child_wait(guest, child).await {
641 Ok(())
642 } else {
643 Err(Error::Tool(anyhow::anyhow!(
644 "emulated {call} selected child was not logically consumed"
645 )))
646 }
647}
648
649pub(super) async fn complete_selected_emulated_wait4<G, T>(
650 guest: &mut G,
651 call: syscalls::Wait4,
652 child: DetPid,
653) -> Result<i64, Error>
654where
655 G: Guest<Detcore<T>>,
656 T: RecordOrReplay,
657{
658 await_selected_child_cpu_publication(guest, child, "wait4").await?;
659 let exact = call
663 .with_pid(child.as_raw())
664 .with_options(WaitPidFlag::from_bits_retain(
665 call.options().bits() & (libc::WNOHANG | libc::WUNTRACED),
666 ));
667 let result = guest.inject(exact).await;
668 match result {
669 Ok(pid) if pid == i64::from(child.as_raw()) => {}
670 Err(Errno::EFAULT) => {}
673 unexpected => {
674 return Err(Error::Tool(anyhow::anyhow!(
675 "emulated wait4 selected-child invariant failed: {unexpected:?} for {child}"
676 )));
677 }
678 }
679 retire_selected_child(guest, child, "wait4").await?;
680 result.map_err(Error::from)
681}
682
683fn child_wait_can_retry_after_stale(spec: ChildWaitSpec) -> bool {
684 !matches!(spec.selector, ChildWaitSelector::Exact(_))
685}
686
687pub(super) type KernelSigset = u64;
688pub(super) const KERNEL_SIGSET_SIZE: usize = std::mem::size_of::<KernelSigset>();
689
690fn signal_is_blocked(mask: &KernelSigset, signal: SigWrapper) -> bool {
691 let raw_signal = signal.raw();
692 (1..=KernelSigset::BITS as i32).contains(&raw_signal)
693 && mask & (1_u64 << (raw_signal as u32 - 1)) != 0
694}
695
696#[repr(C)]
697#[derive(Clone, Copy)]
698pub(super) struct KernelSigaction {
699 pub(super) handler: u64,
700 pub(super) flags: u64,
701 pub(super) restorer: u64,
702 pub(super) mask: KernelSigset,
703}
704
705#[derive(Clone, Copy, Debug, Eq, PartialEq)]
706pub(super) enum WaitSignalDisposition {
707 Interrupt,
708 Restart,
709}
710
711fn signal_default_disposition_does_not_interrupt_child_wait(signal: SigWrapper) -> bool {
712 matches!(
713 signal.raw(),
714 libc::SIGCHLD | libc::SIGCONT | libc::SIGURG | libc::SIGWINCH
715 )
716}
717
718fn signal_default_action_ends_the_process(signal: SigWrapper) -> bool {
724 !matches!(
725 signal.raw(),
726 libc::SIGCHLD
727 | libc::SIGCONT
728 | libc::SIGURG
729 | libc::SIGWINCH
730 | libc::SIGSTOP
731 | libc::SIGTSTP
732 | libc::SIGTTIN
733 | libc::SIGTTOU
734 | libc::SIGKILL
735 )
736}
737
738fn signal_has_uncatchable_default_disposition(signal: SigWrapper) -> bool {
739 matches!(signal.raw(), libc::SIGKILL | libc::SIGSTOP)
740}
741
742pub(super) async fn wait_signal_disposition<G, T>(
743 guest: &mut G,
744 status: ResumeStatus,
745 guest_signal_mask: &KernelSigset,
746 action_addr: AddrMut<'_, KernelSigaction>,
747 inspect_action: bool,
748) -> Result<Option<WaitSignalDisposition>, Error>
749where
750 G: Guest<Detcore<T>>,
751 T: RecordOrReplay,
752{
753 let ResumeStatus::Signaled(signals) = status else {
754 return Ok(None);
755 };
756 let Some(mut signals) = signals else {
757 return Ok(Some(WaitSignalDisposition::Interrupt));
758 };
759 signals.sort_by_key(|signal| signal.raw());
760 for signal in signals {
761 if signal_is_blocked(guest_signal_mask, signal) {
762 continue;
763 }
764 if signal_has_uncatchable_default_disposition(signal) {
765 return Ok(Some(WaitSignalDisposition::Interrupt));
766 }
767 if !inspect_action {
768 return Ok(Some(WaitSignalDisposition::Interrupt));
769 }
770 let call = syscalls::RtSigaction::new()
771 .with_signum(signal.raw())
772 .with_action(None)
773 .with_old_action(Some(action_addr.cast()))
774 .with_sigsetsize(std::mem::size_of::<u64>());
775 guest.inject_with_retry(call).await?;
776 let action: KernelSigaction = guest.memory().read_value(action_addr)?;
777 if action.handler == libc::SIG_IGN as u64
778 || action.handler == libc::SIG_DFL as u64
779 && signal_default_disposition_does_not_interrupt_child_wait(signal)
780 {
781 continue;
782 }
783 return Ok(Some(
784 if action.handler != libc::SIG_DFL as u64 && action.flags & libc::SA_RESTART as u64 != 0
785 {
786 WaitSignalDisposition::Restart
787 } else {
788 WaitSignalDisposition::Interrupt
789 },
790 ));
791 }
792 Ok(None)
793}
794
795pub(crate) fn futex_wait_held_after_wake(
801 host_timed: KernelSigset,
802 committed: KernelSigset,
803) -> KernelSigset {
804 (kernel_sigset_bit(libc::SIGCHLD) | host_timed) & !(committed & !host_timed)
805}
806
807pub(crate) async fn futex_wait_pending_signals<G, T>(
822 guest: &mut G,
823 state: &KernelSignalState,
824 interrupting: KernelSigset,
825 held: KernelSigset,
826 host_timed: KernelSigset,
827 committed: KernelSigset,
828) -> KernelSigset
829where
830 G: Guest<Detcore<T>>,
831 T: RecordOrReplay,
832{
833 let pending = without_discarded(guest, state, interrupting & !held, committed).await;
834 let sigchld = kernel_sigset_bit(libc::SIGCHLD) & !host_timed;
835 if pending == 0
836 && interrupting & state.thread_pending & held & sigchld != 0
837 && matches!(
838 crate::tool_global::child_exit_sigchld(
839 guest,
840 crate::scheduler::child_exit_sigchld::ChildExitSigchldControl::PrivatePending,
841 )
842 .await,
843 crate::scheduler::child_exit_sigchld::ChildExitSigchldAnswer::Placed(true)
844 )
845 {
846 return sigchld;
847 }
848 pending
849}
850
851pub(crate) async fn without_discarded<G, T>(
864 guest: &mut G,
865 state: &KernelSignalState,
866 pending: KernelSigset,
867 committed: KernelSigset,
868) -> KernelSigset
869where
870 G: Guest<Detcore<T>>,
871 T: RecordOrReplay,
872{
873 use crate::scheduler::discarded_at_send::DiscardedSignalAnswer;
874 use crate::scheduler::discarded_at_send::DiscardedSignalControl;
875 use crate::scheduler::discarded_at_send::STANDARD_SIGNALS;
876 if pending & STANDARD_SIGNALS == 0
877 || !crate::scheduler::discarded_at_send::records(guest.config())
878 {
879 return pending;
880 }
881 let DiscardedSignalAnswer::Bits { thread, process } =
882 crate::tool_global::discarded_signal(guest, DiscardedSignalControl::Bits).await
883 else {
884 return pending;
885 };
886 with_kept_copies(state, thread, process, pending, committed)
887}
888
889pub(crate) fn with_kept_copies(
897 state: &KernelSignalState,
898 thread: u64,
899 process: u64,
900 pending: KernelSigset,
901 committed: KernelSigset,
902) -> KernelSigset {
903 let _ = committed;
904 let kept = (state.thread_pending & !thread) | (state.shared_pending & !process);
905 pending & kept
906}
907
908pub(crate) fn kernel_sigset_bit(raw_signal: i32) -> KernelSigset {
910 if (1..=KernelSigset::BITS as i32).contains(&raw_signal) {
911 1_u64 << (raw_signal as u32 - 1)
912 } else {
913 0
914 }
915}
916
917pub(crate) fn clone_host_timed_signals(
926 flags: CloneFlags,
927 exit_signal: libc::c_int,
928) -> KernelSigset {
929 if flags.intersects(CloneFlags::CLONE_THREAD | CloneFlags::CLONE_PARENT)
930 || exit_signal == libc::SIGCHLD
931 {
932 0
933 } else {
934 kernel_sigset_bit(exit_signal)
935 }
936}
937
938#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
947pub(crate) struct KernelSignalState {
948 pub(crate) pending: KernelSigset,
950 pub(crate) thread_pending: KernelSigset,
952 pub(crate) shared_pending: KernelSigset,
954 pub(crate) blocked: KernelSigset,
956 pub(crate) ignored: KernelSigset,
958 pub(crate) caught: KernelSigset,
960}
961
962pub(crate) fn default_action_ends_process(
966 ignored: KernelSigset,
967 caught: KernelSigset,
968 signal: i32,
969) -> bool {
970 let bit = kernel_sigset_bit(signal);
971 let stops_or_continues = [
972 libc::SIGSTOP,
973 libc::SIGTSTP,
974 libc::SIGTTIN,
975 libc::SIGTTOU,
976 libc::SIGCONT,
977 ]
978 .into_iter()
979 .fold(0, |set, signal| set | kernel_sigset_bit(signal));
980 signal == libc::SIGKILL
981 || ((ignored | caught | default_ignored_signals() | stops_or_continues) & bit) == 0
982}
983
984pub(crate) fn ignored_at_generation(ignored: KernelSigset, caught: KernelSigset) -> KernelSigset {
988 ignored | (default_ignored_signals() & !caught)
989}
990
991impl KernelSignalState {
992 pub(crate) fn parse(status: &str) -> Option<Self> {
994 let mut thread_pending = None;
995 let mut shared_pending = None;
996 let mut state = KernelSignalState::default();
997 let mut blocked = None;
998 let mut ignored = None;
999 let mut caught = None;
1000 for line in status.lines() {
1001 let Some((key, value)) = line.split_once(':') else {
1002 continue;
1003 };
1004 let slot = match key {
1005 "SigPnd" => &mut thread_pending,
1006 "ShdPnd" => &mut shared_pending,
1007 "SigBlk" => &mut blocked,
1008 "SigIgn" => &mut ignored,
1009 "SigCgt" => &mut caught,
1010 _ => continue,
1011 };
1012 *slot = Some(KernelSigset::from_str_radix(value.trim(), 16).ok()?);
1013 }
1014 state.thread_pending = thread_pending?;
1015 state.shared_pending = shared_pending?;
1016 state.pending = state.thread_pending | state.shared_pending;
1017 state.blocked = blocked?;
1018 state.ignored = ignored?;
1019 state.caught = caught?;
1020 Some(state)
1021 }
1022
1023 pub(crate) fn interrupting(&self, mask: KernelSigset) -> KernelSigset {
1029 let default_action = !(self.ignored | self.caught);
1030 (self.caught | (default_action & !default_ignored_signals()))
1031 & !mask
1032 & !kernel_sigset_bit(reverie::PERF_EVENT_SIGNAL as i32)
1033 }
1034
1035 pub(crate) fn discarded_at_generation(&self) -> KernelSigset {
1042 self.ignored_at_generation() & !self.blocked
1043 }
1044
1045 pub(crate) fn ignored_at_generation(&self) -> KernelSigset {
1050 ignored_at_generation(self.ignored, self.caught)
1051 }
1052
1053 pub(crate) fn default_action_ends_process(&self, signal: i32) -> bool {
1057 default_action_ends_process(self.ignored, self.caught, signal)
1058 }
1059
1060 pub(crate) fn default_job_control_stops(&self) -> KernelSigset {
1069 [libc::SIGTSTP, libc::SIGTTIN, libc::SIGTTOU]
1070 .into_iter()
1071 .fold(0, |set, signal| set | kernel_sigset_bit(signal))
1072 & !(self.ignored | self.caught)
1073 }
1074
1075 pub(crate) fn interrupting_wait(
1092 &self,
1093 mask: KernelSigset,
1094 defers_default_stops: bool,
1095 ) -> KernelSigset {
1096 let interrupting = self.interrupting(mask);
1097 if defers_default_stops {
1098 interrupting & !self.default_job_control_stops()
1099 } else {
1100 interrupting
1101 }
1102 }
1103
1104 pub(crate) fn pending_interrupting(
1107 &self,
1108 mask: KernelSigset,
1109 defers_default_stops: bool,
1110 ) -> KernelSigset {
1111 self.pending & self.interrupting_wait(mask, defers_default_stops)
1112 }
1113
1114 pub(crate) fn next_dequeued(&self, mask: KernelSigset) -> Option<(i32, SignalQueue)> {
1123 let synchronous = SYNCHRONOUS_SIGNALS
1124 .into_iter()
1125 .fold(0, |set, signal| set | kernel_sigset_bit(signal));
1126 let first = |queued: KernelSigset| {
1127 let deliverable = queued & !mask;
1128 let preferred = if deliverable & synchronous != 0 {
1129 deliverable & synchronous
1130 } else {
1131 deliverable
1132 };
1133 (preferred != 0).then(|| preferred.trailing_zeros() as i32 + 1)
1134 };
1135 first(self.thread_pending)
1136 .map(|signal| (signal, SignalQueue::Thread))
1137 .or_else(|| first(self.shared_pending).map(|signal| (signal, SignalQueue::Shared)))
1138 }
1139
1140 pub(crate) fn queued(&self, queue: SignalQueue) -> KernelSigset {
1142 match queue {
1143 SignalQueue::Thread => self.thread_pending,
1144 SignalQueue::Shared => self.shared_pending,
1145 }
1146 }
1147}
1148
1149fn default_ignored_signals() -> KernelSigset {
1151 [libc::SIGCHLD, libc::SIGCONT, libc::SIGURG, libc::SIGWINCH]
1152 .into_iter()
1153 .fold(0, |set, signal| set | kernel_sigset_bit(signal))
1154}
1155
1156const SYNCHRONOUS_SIGNALS: [i32; 6] = [
1159 libc::SIGSEGV,
1160 libc::SIGBUS,
1161 libc::SIGILL,
1162 libc::SIGTRAP,
1163 libc::SIGFPE,
1164 libc::SIGSYS,
1165];
1166
1167#[derive(Clone, Copy, Debug, Eq, PartialEq)]
1169pub(crate) enum SignalQueue {
1170 Thread,
1172 Shared,
1174}
1175
1176#[cfg(not(test))]
1188static HOST_SIGNAL_STATE_READS_REFUSED: std::sync::atomic::AtomicBool =
1189 std::sync::atomic::AtomicBool::new(false);
1190
1191#[cfg(test)]
1192thread_local! {
1193 static HOST_SIGNAL_STATE_READS_REFUSED_FOR_TEST: std::cell::Cell<bool> =
1196 const { std::cell::Cell::new(false) };
1197}
1198
1199pub(crate) fn refuses_host_signal_state_reads(backend: &BackendCapabilities) -> bool {
1203 !crate::procfs_inode::guest_tids_name_host_tasks(backend, None)
1204}
1205
1206pub(crate) fn refuse_host_signal_state_reads(backend: &BackendCapabilities) {
1210 if !refuses_host_signal_state_reads(backend) {
1211 return;
1212 }
1213 #[cfg(not(test))]
1214 HOST_SIGNAL_STATE_READS_REFUSED.store(true, std::sync::atomic::Ordering::Relaxed);
1215 #[cfg(test)]
1216 HOST_SIGNAL_STATE_READS_REFUSED_FOR_TEST.with(|refused| refused.set(true));
1217}
1218
1219pub(crate) fn host_signal_state_reads_refused() -> bool {
1222 #[cfg(not(test))]
1223 {
1224 HOST_SIGNAL_STATE_READS_REFUSED.load(std::sync::atomic::Ordering::Relaxed)
1225 }
1226 #[cfg(test)]
1227 {
1228 HOST_SIGNAL_STATE_READS_REFUSED_FOR_TEST.with(|refused| refused.get())
1229 }
1230}
1231
1232pub(crate) fn read_kernel_signal_state(pid: Pid, tid: Pid) -> Result<KernelSignalState, Errno> {
1241 #[cfg(test)]
1242 if let Some(result) = signal_state_read_seam::scripted(pid, tid) {
1243 return result;
1244 }
1245 if host_signal_state_reads_refused() {
1246 static REPORTED: std::sync::Once = std::sync::Once::new();
1247 REPORTED.call_once(|| {
1248 error!(
1249 "refused a host /proc signal state read of guest thread {} (process {}): this \
1250 backend's guest thread IDs do not name host tasks",
1251 tid.as_raw(),
1252 pid.as_raw()
1253 );
1254 });
1255 return Err(Errno::ENOSYS);
1256 }
1257 let path = format!("/proc/{}/task/{}/status", pid.as_raw(), tid.as_raw());
1258 let status = std::fs::read_to_string(path).map_err(|_| Errno::ESRCH)?;
1259 KernelSignalState::parse(&status).ok_or(Errno::EIO)
1260}
1261
1262#[derive(Debug, Clone, Copy, PartialEq, Eq)]
1267pub(crate) enum BlockedWaitSignalError {
1268 StateUnreadable { pid: Pid, tid: Pid, errno: Errno },
1272 MaskNotRestored {
1275 pid: Pid,
1276 tid: Pid,
1277 attempts: usize,
1278 last_error: Option<Errno>,
1279 },
1280}
1281
1282impl std::fmt::Display for BlockedWaitSignalError {
1283 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1284 match self {
1285 Self::StateUnreadable { pid, tid, errno } => write!(
1286 f,
1287 "cannot read the signal state of guest thread {tid} (process {pid}) from \
1288 /proc while it waits: {errno}"
1289 ),
1290 Self::MaskNotRestored {
1291 pid,
1292 tid,
1293 attempts,
1294 last_error,
1295 } => {
1296 write!(
1297 f,
1298 "cannot restore the signal mask of guest thread {tid} (process {pid}) \
1299 after a blocked wait ({attempts} attempts"
1300 )?;
1301 if let Some(errno) = last_error {
1302 write!(f, ", last error {errno}")?;
1303 }
1304 f.write_str("); it would resume with every signal blocked")
1305 }
1306 }
1307 }
1308}
1309
1310impl std::error::Error for BlockedWaitSignalError {}
1311
1312pub(crate) fn guest_thread_is_gone(pid: Pid, tid: Pid) -> bool {
1314 let result = unsafe { libc::syscall(libc::SYS_tgkill, pid.as_raw(), tid.as_raw(), 0) };
1316 result == -1 && std::io::Error::last_os_error().raw_os_error() == Some(libc::ESRCH)
1317}
1318
1319pub(crate) fn read_thread_signal_state(pid: Pid, tid: Pid) -> Result<KernelSignalState, Errno> {
1327 read_kernel_signal_state(pid, tid).or_else(|error| {
1328 if pid == tid {
1329 Err(error)
1330 } else {
1331 read_kernel_signal_state(tid, tid)
1332 }
1333 })
1334}
1335
1336pub(crate) fn thread_is_gone(pid: Pid, tid: Pid) -> bool {
1340 if !guest_thread_is_gone(pid, tid) {
1341 return false;
1342 }
1343 let result = unsafe { libc::syscall(libc::SYS_tkill, tid.as_raw(), 0) };
1345 result == -1 && std::io::Error::last_os_error().raw_os_error() == Some(libc::ESRCH)
1346}
1347
1348pub(crate) fn read_thread_wait_signal_state(
1351 pid: Pid,
1352 tid: Pid,
1353) -> Result<KernelSignalState, Error> {
1354 match read_thread_signal_state(pid, tid) {
1355 Ok(state) => Ok(state),
1356 Err(_) if thread_is_gone(pid, tid) => Err(Errno::ERESTARTNOINTR.into()),
1357 Err(errno) => Err(Error::Tool(anyhow::Error::new(
1358 BlockedWaitSignalError::StateUnreadable { pid, tid, errno },
1359 ))),
1360 }
1361}
1362
1363pub(crate) fn read_wait_signal_state(pid: Pid, tid: Pid) -> Result<KernelSignalState, Error> {
1370 match read_kernel_signal_state(pid, tid) {
1371 Ok(state) => Ok(state),
1372 Err(_) if guest_thread_is_gone(pid, tid) => Err(Errno::ERESTARTNOINTR.into()),
1373 Err(errno) => Err(Error::Tool(anyhow::Error::new(
1374 BlockedWaitSignalError::StateUnreadable { pid, tid, errno },
1375 ))),
1376 }
1377}
1378
1379#[cfg(test)]
1381pub(crate) mod signal_state_read_seam {
1382 use std::cell::RefCell;
1383
1384 use reverie::Pid;
1385 use reverie::syscalls::Errno;
1386
1387 use super::KernelSignalState;
1388
1389 type Script = Box<dyn FnMut(Pid, Pid) -> Option<Result<KernelSignalState, Errno>>>;
1390
1391 thread_local! {
1392 static SCRIPT: RefCell<Option<Script>> = const { RefCell::new(None) };
1393 }
1394
1395 pub(crate) struct Installed(());
1397
1398 impl Drop for Installed {
1399 fn drop(&mut self) {
1400 SCRIPT.with(|script| script.borrow_mut().take());
1401 }
1402 }
1403
1404 pub(crate) fn install(
1406 script: impl FnMut(Pid, Pid) -> Option<Result<KernelSignalState, Errno>> + 'static,
1407 ) -> Installed {
1408 SCRIPT.with(|slot| *slot.borrow_mut() = Some(Box::new(script)));
1409 Installed(())
1410 }
1411
1412 pub(super) fn scripted(pid: Pid, tid: Pid) -> Option<Result<KernelSignalState, Errno>> {
1413 SCRIPT.with(|slot| {
1414 slot.borrow_mut()
1415 .as_mut()
1416 .and_then(|script| script(pid, tid))
1417 })
1418 }
1419}
1420
1421pub(super) fn blocked_signal_mask() -> KernelSigset {
1422 let mut libc_mask: libc::sigset_t = unsafe { std::mem::zeroed() };
1425 unsafe {
1426 libc::sigfillset(&mut libc_mask);
1427 libc::sigdelset(&mut libc_mask, reverie::PERF_EVENT_SIGNAL as i32);
1428 }
1429 (1..=KernelSigset::BITS as i32).fold(0, |mask, raw_signal| {
1430 if unsafe { libc::sigismember(&libc_mask, raw_signal) } == 1 {
1431 mask | (1_u64 << (raw_signal as u32 - 1))
1432 } else {
1433 mask
1434 }
1435 })
1436}
1437
1438pub(super) async fn block_signals_for_disposition<G, T>(
1439 guest: &mut G,
1440 blocked_mask_addr: Addr<'_, KernelSigset>,
1441 old_mask_addr: AddrMut<'_, KernelSigset>,
1442) -> Result<KernelSigset, Error>
1443where
1444 G: Guest<Detcore<T>>,
1445 T: RecordOrReplay,
1446{
1447 let block_signals = syscalls::RtSigprocmask::new()
1448 .with_how(libc::SIG_SETMASK)
1449 .with_set(
1450 (!guest
1451 .config()
1452 .backend
1453 .requires_thread_directed_process_signals)
1454 .then_some(blocked_mask_addr.cast()),
1455 )
1456 .with_oldset(Some(old_mask_addr.cast()))
1457 .with_sigsetsize(KERNEL_SIGSET_SIZE);
1458 guest.inject_with_retry(block_signals).await?;
1459 let guest_mask: KernelSigset = guest.memory().read_value(old_mask_addr)?;
1460 if guest.config().backend.reports_child_exit_publication
1461 || crate::scheduler::discarded_at_send::records(guest.config())
1462 {
1463 crate::tool_global::set_saved_guest_sigmask(guest, Some(guest_mask)).await;
1468 }
1469 Ok(guest_mask)
1470}
1471
1472pub(super) async fn restore_signals_after_disposition<G, T>(
1473 guest: &mut G,
1474 old_mask_addr: AddrMut<'_, KernelSigset>,
1475) -> Result<(), Error>
1476where
1477 G: Guest<Detcore<T>>,
1478 T: RecordOrReplay,
1479{
1480 if !guest
1481 .config()
1482 .backend
1483 .requires_thread_directed_process_signals
1484 {
1485 let old_mask: Addr<'_, KernelSigset> = old_mask_addr.into();
1486 let restore_signals = syscalls::RtSigprocmask::new()
1487 .with_how(libc::SIG_SETMASK)
1488 .with_set(Some(old_mask.cast()))
1489 .with_oldset(None)
1490 .with_sigsetsize(KERNEL_SIGSET_SIZE);
1491 guest.inject_with_retry(restore_signals).await?;
1492 }
1493 if guest.config().backend.reports_child_exit_publication
1494 || crate::scheduler::discarded_at_send::records(guest.config())
1495 {
1496 crate::tool_global::set_saved_guest_sigmask(guest, None).await;
1497 }
1498 Ok(())
1499}
1500
1501async fn interrupted_child_wait_result<G, T, S>(
1502 guest: &mut G,
1503 call: S,
1504 disposition: WaitSignalDisposition,
1505) -> Result<i64, Error>
1506where
1507 G: Guest<Detcore<T>>,
1508 T: RecordOrReplay,
1509 S: SyscallInfo,
1510{
1511 if !guest
1512 .config()
1513 .backend
1514 .requires_thread_directed_process_signals
1515 {
1516 return Err(Errno::ERESTARTSYS.into());
1517 }
1518 if disposition == WaitSignalDisposition::Interrupt {
1519 return Err(Errno::EINTR.into());
1520 }
1521
1522 guest.tail_inject(call).await
1523}
1524
1525fn snapshot_process_group(pid: Pid) -> Result<libc::pid_t, Errno> {
1526 let pgrp = Process::new(pid.as_raw())
1527 .and_then(|process| process.stat())
1528 .map(|stat| stat.pgrp)
1529 .map_err(|_| Errno::ESRCH)?;
1530 if pgrp == 0 {
1531 Err(Errno::EOPNOTSUPP)
1532 } else {
1533 Ok(pgrp)
1534 }
1535}
1536
1537fn guest_fd_status_flags(pid: Pid, fd: libc::c_int) -> Result<libc::c_int, Errno> {
1538 let path = format!("/proc/{}/fdinfo/{}", pid.as_raw(), fd);
1539 let contents = std::fs::read_to_string(path).map_err(|_| Errno::EBADF)?;
1540 let flags = contents
1541 .lines()
1542 .find_map(|line| line.strip_prefix("flags:"))
1543 .map(str::trim)
1544 .ok_or(Errno::EINVAL)?;
1545 libc::c_int::from_str_radix(flags, 8).map_err(|_| Errno::EINVAL)
1546}
1547
1548#[derive(Debug, Clone, Copy, PartialEq, Eq)]
1549enum FutexTimeout {
1550 Relative(u64),
1551 Absolute(LogicalTime),
1552}
1553
1554fn futex_timespec_is_valid(timeout: Timespec) -> bool {
1558 timeout.tv_sec >= 0 && (0..1_000_000_000).contains(&timeout.tv_nsec)
1559}
1560
1561const FUTEX_KTIME_MAX_NANOS: u64 = i64::MAX as u64;
1564
1565fn parse_futex_timeout(futex_op: i32, timeout: Timespec) -> Result<FutexTimeout, Errno> {
1566 if !futex_timespec_is_valid(timeout) {
1567 return Err(Errno::EINVAL);
1568 }
1569 let seconds = timeout.tv_sec as u64;
1570 let nanoseconds = timeout.tv_nsec as u64;
1571 let timeout_nanos = if seconds >= FUTEX_KTIME_MAX_NANOS / 1_000_000_000 {
1573 FUTEX_KTIME_MAX_NANOS
1574 } else {
1575 seconds * 1_000_000_000 + nanoseconds
1576 };
1577 if futex_op & libc::FUTEX_CMD_MASK == libc::FUTEX_WAIT_BITSET {
1584 Ok(FutexTimeout::Absolute(LogicalTime::from_nanos(
1585 timeout_nanos,
1586 )))
1587 } else {
1588 Ok(FutexTimeout::Relative(timeout_nanos))
1589 }
1590}
1591
1592fn rebase_absolute_timeout(
1593 deadline: LogicalTime,
1594 clock_now: LogicalTime,
1595 logical_now: LogicalTime,
1596) -> LogicalTime {
1597 logical_now + Duration::from_nanos(deadline.as_nanos().saturating_sub(clock_now.as_nanos()))
1598}
1599
1600fn absolute_timeout_uses_host_clock(
1601 deadline: LogicalTime,
1602 host_clock_now: LogicalTime,
1603 logical_now: LogicalTime,
1604) -> bool {
1605 deadline.as_nanos().abs_diff(host_clock_now.as_nanos())
1606 < deadline.as_nanos().abs_diff(logical_now.as_nanos())
1607}
1608
1609#[derive(Clone, Copy, Debug, Eq, PartialEq)]
1611pub(crate) enum FutexDeadline {
1612 FromCall,
1614 Restart(Option<LogicalTime>),
1617}
1618
1619#[derive(Debug, Clone, Copy, PartialEq, Eq)]
1622enum SchedYieldRoute {
1623 ChaosReprioritize,
1625 ReplayStrongYield,
1627 ChaosYieldEpoch,
1629 WeakYield,
1631 EndTimeslice,
1633}
1634
1635fn sched_yield_route(cfg: &Config) -> SchedYieldRoute {
1667 if cfg.chaos && cfg.max_timeslice.is_none() {
1668 SchedYieldRoute::ChaosReprioritize
1669 } else if !cfg.chaos && cfg.replay_preemptions_from.is_some() {
1670 SchedYieldRoute::ReplayStrongYield
1671 } else if cfg.chaos
1672 && cfg.replay_schedule_from.is_none()
1673 && cfg.backend.delivers_preemption_timer_events
1674 && cfg.sched_heuristic != SchedHeuristic::Random
1675 {
1676 SchedYieldRoute::ChaosYieldEpoch
1677 } else if cfg.chaos || cfg.replay_schedule_from.is_some() {
1678 SchedYieldRoute::WeakYield
1679 } else {
1680 SchedYieldRoute::EndTimeslice
1681 }
1682}
1683
1684impl<T: RecordOrReplay> Detcore<T> {
1685 async fn futex_timeout_deadline<G: Guest<Self>>(
1686 &self,
1687 guest: &mut G,
1688 futex_flags: i32,
1689 timeout: Option<Addr<'_, Timespec>>,
1690 ) -> Result<Option<LogicalTime>, Error> {
1691 let Some(timeout) = timeout else {
1692 return Ok(None);
1693 };
1694 let timeout = parse_futex_timeout(futex_flags, guest.memory().read_value(timeout)?)?;
1695 match timeout {
1696 FutexTimeout::Relative(nanos) => {
1697 let now = thread_observe_time(guest).await;
1698 Ok(Some(now + Duration::from_nanos(nanos)))
1699 }
1700 FutexTimeout::Absolute(deadline)
1701 if self.cfg.virtualize_time
1702 && !self.cfg.backend.guest_clock_reads_bypass_backend =>
1703 {
1704 Ok(Some(deadline))
1705 }
1706 FutexTimeout::Absolute(deadline) => {
1707 let clockid = if futex_flags & libc::FUTEX_CLOCK_REALTIME != 0 {
1708 syscalls::ClockId::CLOCK_REALTIME
1709 } else {
1710 syscalls::ClockId::CLOCK_MONOTONIC
1711 };
1712
1713 let mut stack = guest.stack().await;
1714 let clock_output = syscalls::TimespecMutPtr(stack.reserve());
1715 let _stack_guard = stack.commit()?;
1716 let clock_call = syscalls::ClockGettime::new()
1717 .with_clockid(clockid)
1718 .with_tp(Some(clock_output));
1719 if self.cfg.virtualize_time && self.cfg.backend.guest_clock_reads_bypass_backend {
1720 guest.inject(Syscall::from(clock_call)).await?;
1724 } else {
1725 self.record_or_replay(guest, clock_call).await?;
1726 }
1727 let clock_now = match parse_futex_timeout(
1728 libc::FUTEX_WAIT_BITSET,
1729 guest.memory().read_value(clock_output.0)?,
1730 )? {
1731 FutexTimeout::Absolute(time) => time,
1732 FutexTimeout::Relative(_) => unreachable!(),
1733 };
1734 let logical_now = thread_observe_time(guest).await;
1735 if self.cfg.virtualize_time
1736 && !absolute_timeout_uses_host_clock(deadline, clock_now, logical_now)
1737 {
1738 return Ok(Some(deadline));
1739 }
1740 Ok(Some(rebase_absolute_timeout(
1741 deadline,
1742 clock_now,
1743 logical_now,
1744 )))
1745 }
1746 }
1747 }
1748
1749 async fn futex_deadline<G: Guest<Self>>(
1752 &self,
1753 guest: &mut G,
1754 call: syscalls::Futex,
1755 deadline: FutexDeadline,
1756 ) -> Result<Option<LogicalTime>, Error> {
1757 match deadline {
1758 FutexDeadline::FromCall => {
1759 self.futex_timeout_deadline(guest, call.futex_op(), call.timeout())
1760 .await
1761 }
1762 FutexDeadline::Restart(deadline) => Ok(deadline),
1763 }
1764 }
1765
1766 fn promote_before_native_lifecycle<G: Guest<Self>>(&self, guest: &G) {
1776 let backend = &guest.config().backend;
1777 if self.cfg.sequentialize_threads
1778 && backend.promotes_open_files_before_native_lifecycle
1779 && !crate::syscalls::timerfd::detcore_runs_outside_the_guest(backend)
1780 {
1781 guest.thread_state().promote_shared_open_files().expect(
1782 "could not publish shared open file descriptions before a native fork or exec",
1783 );
1784 }
1785 }
1786
1787 pub async fn handle_clone_family<G: Guest<Self>>(
1789 &self,
1790 guest: &mut G,
1791 clone_family: syscalls::family::CloneFamily,
1792 ) -> Result<i64, Error> {
1793 if let syscalls::family::CloneFamily::Clone3(clone) = &clone_family
1794 && let Some(refusal) = self.clone3_set_tid_refusal(guest, clone).await
1795 {
1796 return refusal;
1797 }
1798 let (flags, exit_signal, child_tid) = match &clone_family {
1803 syscalls::family::CloneFamily::Clone3(clone) => {
1804 let memory = guest.memory();
1805 (
1806 clone3_field(&memory, clone, 0)
1807 .map_or_else(CloneFlags::empty, CloneFlags::from_bits_truncate),
1808 clone3_field(&memory, clone, 32).map_or(0, |signal| signal as libc::c_int),
1809 clone3_field(&memory, clone, 16).map_or(0, |address| address as usize),
1810 )
1811 }
1812 syscalls::family::CloneFamily::Clone(clone) => (
1813 clone_family.flags(&guest.memory()),
1814 (clone.flags().bits() & 0xff) as libc::c_int,
1815 clone_family.child_tid(&guest.memory()),
1816 ),
1817 #[cfg(not(target_arch = "aarch64"))]
1818 _ => (
1819 clone_family.flags(&guest.memory()),
1820 libc::SIGCHLD,
1821 clone_family.child_tid(&guest.memory()),
1822 ),
1823 };
1824 let ctid = child_tid_clear_address(flags, child_tid);
1825 let pidfd_address = guest
1829 .config()
1830 .sequentialize_threads
1831 .then(|| clone_pidfd_address(&clone_family, &guest.memory(), flags))
1832 .flatten();
1833 let is_vfork = flags.contains(CloneFlags::CLONE_VFORK);
1837
1838 let ts = guest.thread_state_mut();
1839 assert_eq!(ts.clone_flags, None);
1840 assert!(ts.pending_vfork.is_none());
1841 ts.clone_flags = Some(flags);
1842
1843 let parent_dettid = ts.dettid;
1844 let child_priority_entropy = if is_vfork
1845 && self.cfg.chaos
1846 && self.cfg.replay_preemptions_from.is_none()
1847 && self.cfg.replay_schedule_from.is_none()
1848 {
1849 let mut parent_chaos_prng = ts.chaos_prng.clone();
1850 Some(parent_chaos_prng.next_u64())
1851 } else {
1852 None
1853 };
1854 if is_vfork {
1855 ts.pending_vfork = Some(PendingVfork {
1856 parent_dettid,
1857 parent_detpid: ts.detpid.expect("detpid unset"),
1858 child_tid_addr: ctid,
1859 flags,
1860 exit_signal,
1861 child_priority_entropy,
1862 });
1863 }
1864
1865 let exit_signals = clone_host_timed_signals(flags, exit_signal);
1870 if exit_signals != 0
1871 && bundled_signal_facts::host_timed_signal_sources_are_physical(&guest.config().backend)
1872 {
1873 record_host_timed_signals(guest, HostTimedSignalScope::Caller, exit_signals).await;
1874 }
1875
1876 if !flags.contains(CloneFlags::CLONE_THREAD) {
1877 self.promote_before_native_lifecycle(guest);
1878 }
1879
1880 super::signal_shadow::before_clone(guest, flags.bits()).await;
1883
1884 trace!("[detcore, dtid {}] parent invoking clone.", parent_dettid);
1885 let blocking_child_op_id =
1886 ExternalOpId::new(parent_dettid, guest.thread_state().stats.syscall_count);
1887
1888 if is_vfork && self.cfg.sequentialize_threads {
1892 let mut resources = Resources::new(parent_dettid);
1893 resources.insert(
1894 ResourceID::BlockingVfork(blocking_child_op_id),
1895 Permission::RW,
1896 );
1897 resources.fyi("clone_vfork");
1898 resource_request(guest, resources).await;
1899 }
1900
1901 let call = Syscall::from(clone_family);
1902 let sysno = call.number();
1903 let maybe_res = guest.inject(call).await;
1904 let refusal = if maybe_res.is_err() {
1907 guest.take_unsupported_refusal()
1908 } else {
1909 None
1910 };
1911
1912 if is_vfork && self.cfg.sequentialize_threads {
1913 let mut resources = Resources::new(parent_dettid);
1914 if maybe_res.is_err() {
1915 resources.insert(
1921 ResourceID::VforkFailed(blocking_child_op_id),
1922 Permission::RW,
1923 );
1924 resources.fyi("clone_vfork_failed");
1925 } else {
1926 resources.insert(
1927 ResourceID::BlockedExternalContinue(blocking_child_op_id),
1928 Permission::RW,
1929 );
1930 resources.fyi("clone_vfork");
1931 }
1932 resource_request(guest, resources).await;
1933 }
1934
1935 let ts = guest.thread_state_mut();
1936 ts.clone_flags = None; ts.pending_vfork = None;
1938
1939 if let (Some(refusal), Err(errno)) = (refusal, &maybe_res) {
1945 tracing::error!(
1946 "[detcore, dtid {parent_dettid}] {}; no child was created",
1947 refusal.diagnostic
1948 );
1949 if !self.cfg.panic_on_unsupported_syscalls {
1950 crate::tool_global::report_unsupported_syscall(guest, sysno).await;
1951 }
1952 return self
1953 .refuse_unserviceable_operation_because(guest, sysno, *errno, refusal.diagnostic)
1954 .await;
1955 }
1956
1957 let res = maybe_res?;
1958
1959 if !flags.contains(CloneFlags::CLONE_THREAD) {
1960 guest.thread_state().forget_flock_modes();
1964 }
1965
1966 if is_vfork
1969 && self.cfg.chaos
1970 && self.cfg.replay_preemptions_from.is_none()
1971 && self.cfg.replay_schedule_from.is_none()
1972 {
1973 let _ = guest
1974 .thread_state_mut()
1975 .chaos_prng_next_u64("child_priority");
1976 }
1977
1978 let child_tid = Pid::from_raw(res as i32);
1979 let child_dettid = DetTid::from_raw(child_tid.into()); trace!(
1981 "[detcore] dtid {} cloned, continuing parent + register new thread.",
1982 child_dettid
1983 );
1984
1985 if !is_vfork {
1986 create_child_thread(guest, child_dettid, ctid, Some(flags), exit_signal, None).await;
1987 }
1988
1989 if let Some(address) = pidfd_address {
1990 self.register_clone_pidfd(guest, address, child_dettid)
1991 .await;
1992 }
1993
1994 {
1995 let parent_pedigree = &mut guest.thread_state_mut().pedigree;
1997 let child_pedigree = parent_pedigree.fork_mut();
1998 debug!(
1999 "[dtid {}] after creating child thread (tid {}, pedigree {}) parents pedigree becomes {}",
2000 parent_dettid, child_dettid, child_pedigree, parent_pedigree,
2001 );
2002 }
2003
2004 if guest.thread_state().nested_pid_namespace {
2008 let refusal = match crate::tool_global::local_pid(guest, child_dettid).await {
2009 Ok(Some(local)) => return Ok(local as i64),
2010 Ok(None) => {
2011 format!("child {child_dettid} has no pid recorded in its creator's namespace")
2012 }
2013 Err(reason) => reason,
2014 };
2015 tracing::error!(
2016 "[detcore, dtid {}] the pid a clone in a nested PID namespace returns cannot be translated: {} (https://github.com/rrnewton/hermit/issues/4090)",
2017 parent_dettid,
2018 refusal,
2019 );
2020 return self
2021 .refuse_unserviceable_operation(
2022 guest,
2023 reverie::syscalls::Sysno::clone,
2024 Errno::ENOSYS,
2025 )
2026 .await;
2027 }
2028 Ok(child_dettid.as_raw() as i64)
2029 }
2030
2031 pub async fn handle_set_tid_address<G: Guest<Self>>(
2038 &self,
2039 guest: &mut G,
2040 call: syscalls::SetTidAddress,
2041 ) -> Result<i64, Error> {
2042 let address = call.tidptr().map_or(0, |pointer| pointer.as_raw());
2043 let result = self
2044 .record_or_replay(guest, Syscall::SetTidAddress(call))
2045 .await?;
2046 if guest.config().sequentialize_threads {
2047 set_child_tid_address(guest, address).await;
2048 }
2049 trace!(
2050 "[detcore, dtid {}] child TID clear address registered: {address:#x}",
2051 guest.thread_state().dettid,
2052 );
2053 Ok(result)
2054 }
2055
2056 pub async fn handle_set_robust_list<G: Guest<Self>>(
2072 &self,
2073 guest: &mut G,
2074 call: syscalls::SetRobustList,
2075 ) -> Result<i64, Error> {
2076 let head = call.head().map(AddrMut::as_raw);
2077 let len = call.len();
2078 let res = self
2079 .record_or_replay(guest, Syscall::SetRobustList(call))
2080 .await?;
2081 let recorded = match head {
2084 None => None,
2086 Some(_) if len != robust_list::ROBUST_LIST_HEAD_LEN => None,
2092 Some(addr) => Some(addr),
2093 };
2094 guest.thread_state_mut().record_robust_list_head(recorded);
2095 trace!(
2096 "[detcore, dtid {}] robust-list head registered: {:?}",
2097 guest.thread_state().dettid,
2098 recorded,
2099 );
2100 Ok(res)
2101 }
2102
2103 async fn run_robust_list_owner_death<G: Guest<Self>>(&self, guest: &mut G) {
2122 let Some(path) = self.robust_owner_death_path() else {
2123 return;
2124 };
2125 let Some(head) = guest.thread_state().robust_list_head else {
2126 return;
2127 };
2128 let dettid = guest.thread_state().dettid;
2129 let owner_tid = dettid.as_raw() as u32;
2142
2143 let mut marked = HashMap::new();
2144 let mut effects = GuestRobustEffects::<'_, G, T> {
2145 guest,
2146 dettid,
2147 staged_wakes: None,
2148 marked: &mut marked,
2149 tool: PhantomData,
2150 };
2151 let outcome = robust_list::exit_robust_list(&mut effects, head, owner_tid).await;
2152 if path == OwnerDeathPath::Barrier {
2153 guest.thread_state().mark_robust_list_walked_by_tool();
2154 }
2155 if outcome.head_unreadable {
2156 trace!(
2157 "[detcore, dtid {}] unreadable robust-list head at {:#x}; no owner-death wakeups",
2158 dettid, head,
2159 );
2160 } else if outcome.aborted || outcome.next_faulted || outcome.truncated {
2161 trace!(
2162 "[detcore, dtid {}] robust-list walk stopped early after {} entr(ies): {:?}",
2163 dettid, outcome.entries_visited, outcome,
2164 );
2165 }
2166 }
2167
2168 pub(crate) async fn stage_thread_group_robust_list_wakes<G: Guest<Self>>(
2181 &self,
2182 guest: &mut G,
2183 reason: RobustListExit,
2184 ) {
2185 match self.robust_owner_death_path() {
2186 None | Some(OwnerDeathPath::Barrier) => {}
2187 Some(OwnerDeathPath::Kernel) => {
2188 let staged = self
2189 .read_thread_group_robust_list_wakes(guest, OwnerDeath::Exit)
2190 .await;
2191 guest.thread_state().stage_robust_list_wakes(reason, staged);
2192 }
2193 }
2194 }
2195
2196 async fn run_thread_group_robust_list_owner_death<G: Guest<Self>>(
2202 &self,
2203 guest: &mut G,
2204 heads: Vec<RobustListOwner>,
2205 ) {
2206 let mut marked = HashMap::new();
2209 for RobustListOwner {
2210 dettid: owner,
2211 head,
2212 } in heads
2213 {
2214 let mut effects = GuestRobustEffects::<'_, G, T> {
2215 guest,
2216 dettid: owner,
2217 staged_wakes: None,
2218 marked: &mut marked,
2219 tool: PhantomData,
2220 };
2221 let outcome =
2222 robust_list::exit_robust_list(&mut effects, head, owner.as_raw() as u32).await;
2223 if outcome.head_unreadable || outcome.aborted {
2224 trace!(
2225 "[detcore, dtid {}] robust-list owner death stopped early: {:?}",
2226 owner, outcome,
2227 );
2228 }
2229 }
2230 }
2231
2232 fn robust_owner_death_path(&self) -> Option<OwnerDeathPath> {
2240 owner_death_path(&self.cfg)
2241 }
2242
2243 pub async fn exec_robust_list_wakes<G: Guest<Self>>(
2250 &self,
2251 guest: &mut G,
2252 ) -> Vec<(DetTid, FutexID)> {
2253 if self.robust_owner_death_path().is_none() {
2254 return Vec::new();
2255 }
2256 let wakes = self
2257 .read_thread_group_robust_list_wakes(guest, OwnerDeath::Exec)
2258 .await;
2259 crate::tool_local::flatten_exec_robust_list_wakes(wakes)
2260 .into_iter()
2261 .map(|(owner, wake)| (owner, wake.futex))
2262 .collect()
2263 }
2264
2265 async fn read_thread_group_robust_list_wakes<G: Guest<Self>>(
2278 &self,
2279 guest: &mut G,
2280 death: OwnerDeath,
2281 ) -> Vec<(DetTid, Vec<RobustListWake>)> {
2282 let caller = guest.thread_state().dettid;
2283 let tgid = guest.thread_state().detpid.expect("detpid unset");
2284 let mut heads: Vec<(DetTid, usize)> = guest
2289 .thread_state()
2290 .robust_list_owners_for_exit_group()
2291 .into_iter()
2292 .map(|owner| (owner.dettid, owner.head))
2293 .collect();
2294 if death == OwnerDeath::Exec {
2295 heads.sort_by_key(|(owner, _)| *owner == caller);
2301 }
2302 let mut staged = Vec::with_capacity(heads.len());
2303 let mut marked = HashMap::new();
2304 for (owner, head) in heads {
2305 let walked_as = if death == OwnerDeath::Exec && owner == caller {
2306 tgid.as_raw()
2307 } else {
2308 owner.as_raw()
2309 };
2310 let mut wakes = Vec::new();
2311 let mut effects = GuestRobustEffects::<'_, G, T> {
2312 guest,
2313 dettid: owner,
2314 staged_wakes: Some(&mut wakes),
2315 marked: &mut marked,
2316 tool: PhantomData,
2317 };
2318 let outcome = robust_list::exit_robust_list(&mut effects, head, walked_as as u32).await;
2319 if outcome.head_unreadable || outcome.aborted {
2320 trace!(
2321 "[detcore, dtid {}] could not stage complete robust-list owner-death effects: {:?}",
2322 owner, outcome,
2323 );
2324 }
2325 staged.push((owner, wakes));
2326 }
2327 staged
2328 }
2329
2330 pub async fn handle_exit<G: Guest<Self>>(
2332 &self,
2333 guest: &mut G,
2334 call: syscalls::Exit,
2335 ) -> Result<i64, Error> {
2336 crate::guest_log::flush_unsent();
2338 if self.cfg.backend.reports_kernel_child_exit_signals {
2344 let uid = real_uid(guest.tid().as_raw()).unwrap_or_else(|| unsafe { libc::getuid() });
2345 crate::tool_global::child_exit_sigchld(
2346 guest,
2347 crate::scheduler::child_exit_sigchld::ChildExitSigchldControl::RawExitStatus {
2348 code: libc::CLD_EXITED,
2349 status: call.status() & 0xff,
2350 uid,
2351 },
2352 )
2353 .await;
2354 }
2355 let request = guest.thread_state().mk_request(
2356 ResourceID::Exit {
2357 group: false,
2358 process: guest.thread_state().detpid.expect("detpid unset"),
2359 mm: guest.thread_state().mm_id,
2360 },
2361 Permission::RW,
2362 );
2363 resource_request(guest, request).await;
2364 self.run_robust_list_owner_death(guest).await;
2365 let state = guest.thread_state();
2370 if self.cfg.sequentialize_threads
2371 && state
2372 .detpid
2373 .is_some_and(|pid| pid.as_raw() == state.dettid.as_raw())
2374 && crate::tool_global::retire_exited_leader(guest).await
2375 && self.cfg.replay_data.is_some()
2376 {
2377 let message = format!(
2382 "hermit: thread-group leader {} exited while its threads run on, which record \
2383 and replay cannot yet capture, so the run is refused \
2384 (https://github.com/rrnewton/hermit/issues/4244)",
2385 guest.thread_state().dettid
2386 );
2387 tracing::error!("{message}");
2388 let _ = std::io::Write::write_fmt(
2389 &mut crate::util::RetryingStderr,
2390 format_args!("{message}\n"),
2391 );
2392 crate::tool_global::unrecoverable_shutdown(
2393 guest,
2394 detcore_model::HERMIT_POLICY_REFUSAL_EXIT,
2395 )
2396 .await;
2397 }
2398 guest.tail_inject(call).await
2400 }
2401
2402 pub async fn handle_exit_group<G: Guest<Self>>(
2404 &self,
2405 guest: &mut G,
2406 call: syscalls::ExitGroup,
2407 ) -> Result<i64, Error> {
2408 crate::guest_log::flush_unsent();
2411 if self.cfg.backend.reports_kernel_child_exit_signals {
2415 let uid = real_uid(guest.tid().as_raw()).unwrap_or_else(|| unsafe { libc::getuid() });
2416 crate::tool_global::child_exit_sigchld(
2417 guest,
2418 crate::scheduler::child_exit_sigchld::ChildExitSigchldControl::ExitStatus {
2419 code: libc::CLD_EXITED,
2420 status: call.status() & 0xff,
2421 uid,
2422 },
2423 )
2424 .await;
2425 }
2426 let barrier = self.robust_owner_death_path() == Some(OwnerDeathPath::Barrier);
2444 if barrier {
2445 guest.thread_state().file_exit_group_for_robust_lists();
2446 }
2447 let request = guest.thread_state().mk_request(
2448 ResourceID::Exit {
2449 group: true,
2450 process: guest.thread_state().detpid.expect("detpid unset"),
2451 mm: guest.thread_state().mm_id,
2452 },
2453 Permission::RW,
2454 );
2455 resource_request(guest, request).await;
2456 if barrier {
2457 guest.thread_state().begin_exit_group_robust_walk();
2458 let owners = guest.thread_state().robust_list_owners_for_exit_group();
2459 self.run_thread_group_robust_list_owner_death(guest, owners)
2460 .await;
2461 guest.thread_state().finish_exit_group_robust_walk();
2462 } else {
2463 self.stage_thread_group_robust_list_wakes(guest, RobustListExit::ExitGroup)
2464 .await
2465 }
2466 guest.tail_inject(call).await
2468 }
2469
2470 pub(crate) async fn end_thread_group_before_fatal_delivery<G: Guest<Self>>(
2507 &self,
2508 guest: &mut G,
2509 signal: SigWrapper,
2510 ) -> bool {
2511 if !(self.cfg.sequentialize_threads
2512 && self.cfg.backend.requires_thread_directed_process_signals)
2513 || !signal_default_action_ends_the_process(signal)
2514 {
2515 return false;
2516 }
2517 match self.signal_is_left_at_default(guest, signal).await {
2518 Ok(true) => {}
2519 Ok(false) => return false,
2520 Err(error) => {
2521 tracing::warn!(
2522 "[detcore, dtid {}] cannot read the disposition of {}: {}",
2523 guest.thread_state().dettid,
2524 signal,
2525 error
2526 );
2527 return false;
2528 }
2529 }
2530 info!(
2531 "[detcore, dtid {}] {} ends its thread group by default",
2532 guest.thread_state().dettid,
2533 signal
2534 );
2535 let barrier = self.robust_owner_death_path() == Some(OwnerDeathPath::Barrier);
2536 if barrier {
2537 guest.thread_state().file_exit_group_for_robust_lists();
2538 }
2539 let dettid = guest.thread_state().dettid;
2540 if !hold_turn_for_group_exit(guest, dettid).await {
2541 tracing::warn!(
2542 "[detcore, dtid {}] the scheduler did not hold the turn for the group exit of {}",
2543 dettid,
2544 signal
2545 );
2546 }
2547 let request = guest.thread_state().mk_request(
2548 ResourceID::Exit {
2549 group: true,
2550 process: guest.thread_state().detpid.expect("detpid unset"),
2551 mm: guest.thread_state().mm_id,
2552 },
2553 Permission::RW,
2554 );
2555 resource_request(guest, request).await;
2556 match self.signal_is_left_at_default(guest, signal).await {
2557 Ok(true) => {}
2558 changed => {
2559 info!(
2560 "[detcore, dtid {}] the action for {} changed after the delivery decision \
2561 ({:?}); restoring SIG_DFL in the dying process",
2562 guest.thread_state().dettid,
2563 signal,
2564 changed.map(|default| !default)
2565 );
2566 if let Err(error) = self.restore_default_action(guest, signal).await {
2567 tracing::warn!(
2568 "[detcore, dtid {}] cannot restore SIG_DFL for {}: {}",
2569 guest.thread_state().dettid,
2570 signal,
2571 error
2572 );
2573 }
2574 }
2575 }
2576 if barrier {
2577 guest.thread_state().begin_exit_group_robust_walk();
2578 let owners = guest.thread_state().robust_list_owners_for_exit_group();
2579 self.run_thread_group_robust_list_owner_death(guest, owners)
2580 .await;
2581 guest.thread_state().finish_exit_group_robust_walk();
2582 }
2583 true
2584 }
2585
2586 async fn restore_default_action<G: Guest<Self>>(
2588 &self,
2589 guest: &mut G,
2590 signal: SigWrapper,
2591 ) -> Result<(), Error> {
2592 let default = KernelSigaction {
2593 handler: libc::SIG_DFL as u64,
2594 flags: 0,
2595 restorer: 0,
2596 mask: 0,
2597 };
2598 let mut stack = guest.stack().await;
2599 let action_addr = stack.push(default);
2600 let _guard = stack.commit()?;
2601 let call = syscalls::RtSigaction::new()
2602 .with_signum(signal.raw())
2603 .with_action(Some(action_addr.cast()))
2604 .with_old_action(None)
2605 .with_sigsetsize(std::mem::size_of::<u64>());
2606 guest.inject_with_retry(call).await?;
2607 super::signal_shadow::give_up(
2610 guest,
2611 "Detcore reset an action to the default before a fatal delivery",
2612 );
2613 Ok(())
2614 }
2615
2616 async fn signal_is_left_at_default<G: Guest<Self>>(
2619 &self,
2620 guest: &mut G,
2621 signal: SigWrapper,
2622 ) -> Result<bool, Error> {
2623 let mut stack = guest.stack().await;
2624 let action_addr = stack.reserve::<KernelSigaction>();
2625 let _guard = stack.commit()?;
2626 let call = syscalls::RtSigaction::new()
2627 .with_signum(signal.raw())
2628 .with_action(None)
2629 .with_old_action(Some(action_addr.cast()))
2630 .with_sigsetsize(std::mem::size_of::<u64>());
2631 guest.inject_with_retry(call).await?;
2632 let action: KernelSigaction = guest.memory().read_value(action_addr)?;
2633 Ok(action.handler == libc::SIG_DFL as u64)
2634 }
2635
2636 pub async fn handle_futex<G: Guest<Self>>(
2638 &self,
2639 guest: &mut G,
2640 call: syscalls::Futex,
2641 ) -> Result<i64, Error> {
2642 self.handle_futex_from(guest, call, FutexDeadline::FromCall)
2643 .await
2644 }
2645
2646 pub(crate) async fn handle_futex_from<G: Guest<Self>>(
2651 &self,
2652 guest: &mut G,
2653 call: syscalls::Futex,
2654 deadline: FutexDeadline,
2655 ) -> Result<i64, Error> {
2656 let dettid = guest.thread_state().dettid;
2657 if self.cfg.sequentialize_threads
2661 && !matches!(self.cfg.debug_futex_mode, BlockingMode::External)
2662 {
2663 match classify_futex_command(call.futex_op()) {
2664 FutexCommand::Served => {}
2665 FutexCommand::NoSys => return Err(Error::Errno(Errno::ENOSYS)),
2666 FutexCommand::PriorityInheritance(name) => {
2667 return self
2668 .refuse_futex_command(
2669 guest,
2670 name,
2671 "Detcore does not emulate priority-inheritance futexes",
2672 )
2673 .await;
2674 }
2675 }
2676 }
2677 if self.cfg.sequentialize_threads
2682 && !matches!(self.cfg.debug_futex_mode, BlockingMode::External)
2683 {
2684 let command = call.futex_op() & libc::FUTEX_CMD_MASK;
2685 if matches!(command, libc::FUTEX_WAKE | libc::FUTEX_WAKE_BITSET)
2689 && matches!(self.cfg.debug_futex_mode, BlockingMode::Precise)
2690 {
2691 return self.handle_futex_wake(guest, call, command).await;
2692 }
2693 let name = match command {
2694 libc::FUTEX_REQUEUE => Some("FUTEX_REQUEUE"),
2695 libc::FUTEX_CMP_REQUEUE => Some("FUTEX_CMP_REQUEUE"),
2696 libc::FUTEX_WAKE_OP => Some("FUTEX_WAKE_OP"),
2697 _ => None,
2698 };
2699 if let Some(name) = name {
2700 if matches!(self.cfg.debug_futex_mode, BlockingMode::Polling) {
2703 return self
2704 .refuse_futex_command(guest, name, POLLING_REFUSAL)
2705 .await;
2706 }
2707 return if command == libc::FUTEX_WAKE_OP {
2708 self.handle_futex_wake_op(guest, call).await
2710 } else {
2711 self.handle_futex_requeue(guest, call, command).await
2713 };
2714 }
2715 }
2716 let ptr = match call.uaddr() {
2717 None => {
2718 return Ok(guest.inject(call).await?);
2720 }
2721 Some(x) => x,
2722 };
2723 if self.cfg.sequentialize_threads
2724 && !matches!(self.cfg.debug_futex_mode, BlockingMode::External)
2725 && !AddrMut::as_raw(ptr).is_multiple_of(std::mem::size_of::<u32>())
2726 {
2727 return Err(Error::Errno(Errno::EINVAL));
2729 }
2730 if !self.cfg.sequentialize_threads {
2731 return Ok(guest.inject(call).await?);
2732 }
2733 let polling = match self.cfg.debug_futex_mode {
2734 BlockingMode::External => {
2735 return self.record_or_replay_blocking(guest, call.into()).await;
2736 }
2737 BlockingMode::Precise => false,
2738 BlockingMode::Polling => true,
2739 };
2740 let init_val = match call.futex_op() & libc::FUTEX_CMD_MASK {
2751 command @ (libc::FUTEX_WAIT | libc::FUTEX_WAIT_BITSET) => {
2752 if matches!(deadline, FutexDeadline::FromCall)
2753 && let Some(timeout) = call.timeout()
2754 {
2755 let timeout = read_user_timespec(guest, timeout.as_raw())?;
2756 if !futex_timespec_is_valid(timeout) {
2757 return Err(Error::Errno(Errno::EINVAL));
2758 }
2759 }
2760 if command == libc::FUTEX_WAIT_BITSET && call.val3() == 0 {
2761 return Err(Error::Errno(Errno::EINVAL));
2762 }
2763 read_futex_word(guest, AddrMut::as_raw(ptr))?
2764 }
2765 _ => 0,
2766 };
2767 trace!(
2768 "[detcore, dtid {}] futex op with memory address containing value {}",
2769 &dettid, init_val
2770 );
2771 if polling {
2772 self.handle_futex_polling(guest, call, init_val, deadline)
2773 .await
2774 } else {
2775 self.handle_futex_blocking(guest, call, init_val, deadline)
2776 .await
2777 }
2778 }
2779
2780 pub(crate) async fn handle_futex_blocking<G: Guest<Self>>(
2784 &self,
2785 guest: &mut G,
2786 call: syscalls::Futex,
2787 init_val: i32,
2788 deadline: FutexDeadline,
2789 ) -> Result<i64, Error> {
2790 let ptr = call.uaddr().unwrap();
2791 let futexid = guest.thread_state().futex_id(
2792 AddrMut::as_raw(ptr),
2793 call.futex_op() & libc::FUTEX_PRIVATE_FLAG != 0,
2794 );
2795 let futex_op = call.futex_op() & libc::FUTEX_CMD_MASK;
2796 let bitset = match futex_op {
2797 libc::FUTEX_WAKE_BITSET | libc::FUTEX_WAIT_BITSET => call.val3() as u32,
2798 _ => u32::MAX,
2799 };
2800 if bitset == 0 {
2801 return Err(Error::Errno(Errno::EINVAL));
2802 }
2803 let dettid = guest.thread_state().dettid;
2804 match futex_op {
2805 libc::FUTEX_WAIT | libc::FUTEX_WAIT_BITSET => {
2806 if init_val != call.val() {
2807 info!(
2808 "[detcore, dtid {}] Futex wait running immediately because it will fizzle ({} != {}).",
2809 &dettid,
2810 init_val,
2811 call.val()
2812 );
2813 Err(Error::Errno(Errno::EAGAIN))
2814 } else {
2815 let maybe_timeout_lt = self.futex_deadline(guest, call, deadline).await?;
2816 let signal_interruption = guest
2817 .config()
2818 .backend
2819 .supports_blocked_wait_signal_interruption;
2820 let mut rewait = false;
2822 let mut committed_wake: KernelSigset = 0;
2826 let mut requested = false;
2830 let res = loop {
2831 let signal_watch = if signal_interruption {
2873 let state = match read_wait_signal_state(guest.pid(), guest.tid()) {
2876 Ok(state) => state,
2877 Err(error) => break Err(error),
2878 };
2879 let defers_default_stops = call.restart_keeps_deadline();
2882 let host_timed = host_timed_signals(guest).await;
2883 let committed = std::mem::take(&mut committed_wake);
2884 let held = futex_wait_held_after_wake(host_timed, committed);
2885 let pending = futex_wait_pending_signals(
2886 guest,
2887 &state,
2888 state.pending_interrupting(state.blocked, defers_default_stops),
2889 held,
2890 host_timed,
2891 committed,
2892 )
2893 .await;
2894 if pending != 0 {
2895 let errno = call.kernel_restart_errno();
2896 trace!(
2897 "[detcore, dtid {}] futex wait interrupted by pending signals {:#x}: {:?}",
2898 &dettid, pending, errno
2899 );
2900 break Err(Error::Errno(errno));
2901 }
2902 Some(FutexSignalWatch {
2903 unblocked: !state.blocked
2904 & !kernel_sigset_bit(reverie::PERF_EVENT_SIGNAL as i32),
2905 defers_default_stops,
2906 pid: guest.pid().as_raw(),
2907 tid: guest.tid().as_raw(),
2908 })
2909 } else {
2910 None
2911 };
2912 if rewait {
2913 let observed = match read_futex_word(guest, AddrMut::as_raw(ptr)) {
2922 Ok(observed) => observed,
2923 Err(error) => break Err(error),
2924 };
2925 if observed != call.val() {
2926 trace!(
2927 "[detcore, dtid {}] futex value changed while its wait was woken for a signal ({} != {}); EAGAIN",
2928 &dettid,
2929 observed,
2930 call.val()
2931 );
2932 break Err(Error::Errno(Errno::EAGAIN));
2933 }
2934 debug!(
2935 "[detcore, dtid {}] futex wait woken for a signal that is not pending for it; waiting again until {:?}",
2936 &dettid, maybe_timeout_lt
2937 );
2938 }
2939 requested = true;
2940 let ans = futex_action(
2941 guest,
2942 FutexAction::WaitRequest(maybe_timeout_lt, signal_watch),
2943 &futexid,
2944 init_val,
2945 bitset,
2946 )
2947 .await;
2948 if signal_interruption && let Some(SchedValue::Signaled(committed)) = ans {
2949 committed_wake = committed;
2950 rewait = true;
2956 continue;
2957 }
2958 break if ans != Some(SchedValue::TimeOut) {
2959 let expected = call.val();
2960 match guest.memory().read_value(ptr) {
2963 Ok(observed) => {
2964 trace!(
2965 "[detcore, dtid {}] after (emulated) futex wait, memory value is {}, expected {}",
2966 &dettid, observed, expected,
2967 );
2968 if expected == observed {
2969 debug!(
2970 "WARNING: fishy that the futex value did not change before wakeup. Weird application-level protocol.\n"
2971 );
2972 }
2973 }
2974 Err(error) => trace!(
2975 "[detcore, dtid {}] skipped post-wait futex memory diagnostic: {}",
2976 &dettid, error,
2977 ),
2978 }
2979 Ok(0)
2980 } else {
2981 trace!("[detcore, dtid {}] futex wait timed out", &dettid);
2982 Err(Error::Errno(Errno::ETIMEDOUT))
2983 };
2984 };
2985 if requested {
2986 futex_action(guest, FutexAction::WaitFinished, &futexid, init_val, bitset)
2987 .await;
2988 }
2989 keep_restart_block(guest, &res, RestartCall::Futex(call), maybe_timeout_lt)
2990 .await;
2991 res
2992 }
2993 }
2994 _ => Err(Error::Errno(Errno::ENOSYS)),
2996 }
2997 }
2998
2999 async fn handle_futex_wake<G: Guest<Self>>(
3004 &self,
3005 guest: &mut G,
3006 call: syscalls::Futex,
3007 command: i32,
3008 ) -> Result<i64, Error> {
3009 let bitset = if command == libc::FUTEX_WAKE_BITSET {
3010 call.val3() as u32
3011 } else {
3012 u32::MAX
3013 };
3014 if bitset == 0 {
3015 return Err(Error::Errno(Errno::EINVAL));
3016 }
3017 let private = call.futex_op() & libc::FUTEX_PRIVATE_FLAG != 0;
3018 let futexid = futex_key(guest, futex_uaddr(&call), private, KeyAccess::Read).await?;
3019 let num = match futex_action(
3020 guest,
3021 FutexAction::WakeRequest(call.val()),
3022 &futexid,
3023 0,
3024 bitset,
3025 )
3026 .await
3027 .expect("futex wake must return value")
3028 {
3029 SchedValue::Value(num) => num,
3030 other => panic!("impossible answer to a futex wake: {:?}", other),
3031 };
3032 let _ = futex_action(guest, FutexAction::WakeFinished(0), &futexid, 0, bitset).await;
3033 if self.cfg.yields_after_futex_wake(num) {
3034 guest.thread_state_mut().yield_after_futex_wake = true;
3035 }
3036 Ok(num as i64)
3037 }
3038
3039 async fn handle_futex_requeue<G: Guest<Self>>(
3055 &self,
3056 guest: &mut G,
3057 call: syscalls::Futex,
3058 command: i32,
3059 ) -> Result<i64, Error> {
3060 let nr_wake = call.val();
3061 let nr_requeue = futex_val2(&call) as i32;
3062 if nr_wake < 0 || nr_requeue < 0 {
3063 return Err(Error::Errno(Errno::EINVAL));
3064 }
3065 let private = call.futex_op() & libc::FUTEX_PRIVATE_FLAG != 0;
3066 let uaddr = futex_uaddr(&call);
3067 let futexid = futex_key(guest, uaddr, private, KeyAccess::Read).await?;
3068 let futexid2 = futex_key(guest, futex_uaddr2(&call), private, KeyAccess::Read).await?;
3069 let mut current = 0;
3070 if command == libc::FUTEX_CMP_REQUEUE {
3071 current = read_futex_word(guest, uaddr)?;
3072 if current != call.val3() {
3073 return Err(Error::Errno(Errno::EAGAIN));
3074 }
3075 }
3076 let woken_and_moved = match futex_action(
3077 guest,
3078 FutexAction::RequeueRequest(futexid2, nr_wake as u32, nr_requeue as u32),
3079 &futexid,
3080 current,
3081 u32::MAX,
3082 )
3083 .await
3084 {
3085 Some(SchedValue::Requeued { woken, moved }) => {
3086 if self.cfg.yields_after_futex_wake(woken) {
3087 guest.thread_state_mut().yield_after_futex_wake = true;
3088 }
3089 woken + moved
3090 }
3091 Some(SchedValue::Value(num)) => num,
3094 other => panic!("impossible answer to a futex requeue: {:?}", other),
3095 };
3096 let _ = futex_action(
3097 guest,
3098 FutexAction::WakeFinished(0),
3099 &futexid,
3100 current,
3101 u32::MAX,
3102 )
3103 .await;
3104 Ok(woken_and_moved as i64)
3105 }
3106
3107 async fn handle_futex_wake_op<G: Guest<Self>>(
3133 &self,
3134 guest: &mut G,
3135 call: syscalls::Futex,
3136 ) -> Result<i64, Error> {
3137 let nr_wake = call.val();
3138 let nr_wake2 = futex_val2(&call) as i32;
3139 let private = call.futex_op() & libc::FUTEX_PRIVATE_FLAG != 0;
3140 let uaddr2 = futex_uaddr2(&call);
3141 let futexid = futex_key(guest, futex_uaddr(&call), private, KeyAccess::Read).await?;
3142 let futexid2 = futex_key(guest, uaddr2, private, KeyAccess::Write).await?;
3143 let op = FutexWakeOp::decode(call.val3() as u32);
3144 if !op.has_known_operation() {
3145 return Err(Error::Errno(Errno::ENOSYS));
3146 }
3147 if matches!(
3148 guest.thread_state().futex_id(uaddr2, false),
3149 FutexID::Shared {
3150 object: SharedMemoryObjectId::File { .. } | SharedMemoryObjectId::OpenFile { .. },
3151 ..
3152 }
3153 ) {
3154 return self
3155 .refuse_futex_command(
3156 guest,
3157 "FUTEX_WAKE_OP",
3158 "its word is in a file-backed shared mapping that a process outside Hermit \
3159 could update concurrently, and Detcore cannot apply the operation atomically",
3160 )
3161 .await;
3162 }
3163 let old = read_futex_word(guest, uaddr2)?;
3164 let new = op.apply(old).expect("operation was checked to be known");
3165 let word2 = AddrMut::<libc::c_int>::from_raw(uaddr2).ok_or(Errno::EFAULT)?;
3166 guest
3167 .memory()
3168 .write_value(word2, &new)
3169 .map_err(|_| Error::Errno(Errno::EFAULT))?;
3170 let Some(wake2) = op.compare(old) else {
3171 return Err(Error::Errno(Errno::ENOSYS));
3172 };
3173 let mut woken = 0;
3174 for (futex, count, wake) in [(futexid, nr_wake, true), (futexid2, nr_wake2, wake2)] {
3175 if !wake {
3176 continue;
3177 }
3178 woken += match futex_action(guest, FutexAction::WakeRequest(count), &futex, 0, u32::MAX)
3179 .await
3180 {
3181 Some(SchedValue::Value(num)) => num,
3182 other => panic!("impossible answer to a futex wake: {:?}", other),
3183 };
3184 let _ = futex_action(guest, FutexAction::WakeFinished(0), &futex, 0, u32::MAX).await;
3185 }
3186 if self.cfg.yields_after_futex_wake(woken) {
3187 guest.thread_state_mut().yield_after_futex_wake = true;
3188 }
3189 Ok(woken as i64)
3190 }
3191
3192 async fn refuse_futex_command<G: Guest<Self>>(
3198 &self,
3199 guest: &mut G,
3200 name: &'static str,
3201 reason: &'static str,
3202 ) -> Result<i64, Error> {
3203 tracing::error!(
3204 "[detcore, dtid {}] futex command {} is not supported: {}",
3205 guest.thread_state().dettid,
3206 name,
3207 reason,
3208 );
3209 self.refuse_unserviceable_operation(guest, reverie::syscalls::Sysno::futex, Errno::ENOSYS)
3210 .await
3211 }
3212
3213 pub(crate) async fn handle_futex_polling<G: Guest<Self>>(
3216 &self,
3217 guest: &mut G,
3218 call: syscalls::Futex,
3219 init_val: i32,
3220 deadline: FutexDeadline,
3221 ) -> Result<i64, Error> {
3222 fn make_futex_wake_request(dettid: DetTid) -> Resources {
3223 let mut rsrc = Resources::new(dettid);
3224 rsrc.fyi("futex_wake");
3225 rsrc
3226 }
3227
3228 fn make_futex_wait_request(dettid: DetTid) -> Resources {
3229 let mut rsrc = Resources::new(dettid);
3230 rsrc.insert(ResourceID::InternalIOPolling, Permission::W);
3231 rsrc.fyi("futex_wait");
3232 rsrc
3233 }
3234
3235 let dettid = guest.thread_state().dettid;
3236 let futex_op = call.futex_op() & libc::FUTEX_CMD_MASK;
3237 match futex_op {
3238 libc::FUTEX_WAKE | libc::FUTEX_WAKE_BITSET => {
3239 let rsrc = make_futex_wake_request(dettid);
3240 resource_request(guest, rsrc.clone()).await; let res = guest.inject(call).await;
3242 Ok(res?)
3246 }
3247 libc::FUTEX_WAIT | libc::FUTEX_WAIT_BITSET => {
3248 if init_val != call.val() {
3249 info!(
3250 "[detcore, dtid {}] Futex wait running immediately because it will fizzle ({} != {}).",
3251 dettid,
3252 init_val,
3253 call.val()
3254 );
3255 let res = guest.inject(call).await;
3256 Ok(res?)
3257 } else {
3258 let rsrc = make_futex_wait_request(dettid);
3259 let deadline = self.futex_deadline(guest, call, deadline).await?;
3260 let res =
3261 retry_nonblocking_syscall_with_timeout(guest, call, rsrc, deadline).await;
3262 keep_restart_block(guest, &res, RestartCall::Futex(call), deadline).await;
3263 let res = res?;
3264 trace!(
3265 "[detcore, dtid {}] after futex wait, memory value is {}",
3266 &dettid,
3267 guest.memory().read_value(call.uaddr().unwrap()).unwrap()
3268 );
3269 Ok(res)
3270 }
3271 }
3272 _ => Err(Error::Errno(Errno::ENOSYS)),
3274 }
3275 }
3276
3277 fn exec_image<G: Guest<Self>>(
3286 &self,
3287 guest: &G,
3288 call: &syscalls::Execveat,
3289 ) -> Option<crate::exec_record::ExecRecord> {
3290 let path: std::path::PathBuf = call.path()?.read(&guest.memory()).ok()?;
3291 self.exec_image_at(guest, call.dirfd(), &path)
3292 }
3293
3294 pub(crate) fn exec_image_from_execfn<G: Guest<Self>>(
3301 &self,
3302 guest: &G,
3303 ) -> Option<crate::exec_record::ExecRecord> {
3304 use reverie::syscalls::FromToRaw;
3305 let address = guest.auxv().at_execfn()?.as_raw();
3306 let path: std::path::PathBuf = Option::<syscalls::PathPtr>::from_raw(address)?
3307 .read(&guest.memory())
3308 .ok()?;
3309 self.exec_image_at(guest, libc::AT_FDCWD, &path)
3310 }
3311
3312 pub fn exec_image_at<G: Guest<Self>>(
3317 &self,
3318 guest: &G,
3319 dirfd: i32,
3320 path: &std::path::Path,
3321 ) -> Option<crate::exec_record::ExecRecord> {
3322 let task = self.guest_task_directory(guest)?;
3323 let root = std::fs::read_link(task.join("root")).ok()?;
3324 let inside = |link: std::path::PathBuf| {
3325 Some(std::path::Path::new("/").join(link.strip_prefix(&root).ok()?))
3326 };
3327 let cwd = inside(std::fs::read_link(task.join("cwd")).ok()?)?;
3328 let spelled = if path.is_absolute() || dirfd == libc::AT_FDCWD {
3329 cwd.join(path)
3330 } else {
3331 let descriptor = task.join("fd").join(dirfd.to_string());
3332 let directory = inside(std::fs::read_link(descriptor).ok()?)?;
3333 if path.as_os_str().is_empty() {
3336 directory
3337 } else {
3338 directory.join(path)
3339 }
3340 };
3341 match self.resolve_exe_subject(guest, &spelled, true) {
3345 Some(crate::syscalls::namespace::ExeLinkSubject::Own) => {
3346 return guest.thread_state().exe.as_deref().cloned();
3347 }
3348 Some(crate::syscalls::namespace::ExeLinkSubject::Other(_)) => return None,
3350 None => {}
3351 }
3352 crate::exec_record::ExecRecord::resolve(&root, &cwd, &spelled)
3353 }
3354
3355 pub async fn handle_execveat<G: Guest<Self>>(
3357 &self,
3358 guest: &mut G,
3359 call: syscalls::Execveat,
3360 ) -> Result<i64, Error> {
3361 self.promote_before_native_lifecycle(guest);
3362 let (old_metadata, old_memory_metadata, table_is_shared, dettid, detpid, old_mm_id) = {
3363 let thread_state = guest.thread_state();
3364 (
3365 Arc::clone(&thread_state.file_metadata),
3366 Arc::clone(&thread_state.memory_metadata),
3367 Arc::strong_count(&thread_state.file_metadata) > 1,
3368 thread_state.dettid,
3369 thread_state.detpid.expect("detpid unset"),
3370 thread_state.mm_id,
3371 )
3372 };
3373 let (new_metadata, closed_open_files, exec_fd_blocking) = {
3374 let metadata = old_metadata.lock().unwrap();
3375 let new_metadata = metadata.for_exec(dettid);
3376 (
3377 new_metadata.clone(),
3378 metadata.open_files_closed_on_exec(table_is_shared),
3379 new_metadata.exec_blocking_overrides(),
3380 )
3381 };
3382 let preserve_exec_fd_status = guest.config().backend.rediscovers_descriptors_after_exec;
3383 let exe = self.exec_image(guest, &call);
3384
3385 prepare_exec(
3386 guest,
3387 old_mm_id,
3388 if preserve_exec_fd_status {
3389 exec_fd_blocking
3390 } else {
3391 Default::default()
3392 },
3393 Vec::new(),
3395 exe,
3396 )
3397 .await;
3398
3399 let mut released_ports = Vec::new();
3400 for open_file_id in closed_open_files {
3401 if let Some(port) = self.release_port_for_open_file(guest, open_file_id).await {
3402 released_ports.push((open_file_id, port));
3403 }
3404 }
3405
3406 let exec_robust_wakes = match self.robust_owner_death_path() {
3418 Some(OwnerDeathPath::Kernel) => Some(
3419 self.read_thread_group_robust_list_wakes(guest, OwnerDeath::Exec)
3420 .await,
3421 ),
3422 Some(OwnerDeathPath::Barrier) | None => None,
3423 };
3424 let old_robust_list_head;
3425 let old_process_files = guest.thread_state().process_files;
3429
3430 {
3431 let thread_state = guest.thread_state_mut();
3432 thread_state.file_metadata = Arc::new(Mutex::new(new_metadata));
3433 thread_state.adopt_process_files();
3434 thread_state.memory_metadata = Arc::new(Mutex::new(MemoryMetadata::new()));
3435 thread_state.mm_id = old_mm_id.for_exec(detpid);
3436 old_robust_list_head = thread_state.take_robust_list_for_exec();
3437 if let Some(wakes) = exec_robust_wakes {
3438 thread_state.stage_robust_list_wakes_for_exec(wakes);
3439 }
3440 }
3441
3442 let errno = self.record_or_replay(guest, call).await.unwrap_err();
3444 let refusal = guest.take_unsupported_refusal();
3447
3448 {
3449 let thread_state = guest.thread_state_mut();
3450 thread_state.file_metadata = old_metadata;
3451 thread_state.process_files = old_process_files;
3452 thread_state.memory_metadata = old_memory_metadata;
3453 thread_state.mm_id = old_mm_id;
3454 thread_state.restore_robust_list_after_failed_exec(old_robust_list_head);
3455 thread_state.take_robust_list_wakes_for_exec();
3457 }
3458
3459 cancel_exec(guest).await;
3460 for (open_file_id, port) in released_ports {
3461 self.restore_port_for_open_file(guest, open_file_id, port)
3462 .await;
3463 }
3464
3465 if let Some(refusal) = refusal {
3474 tracing::error!(
3475 "[detcore, dtid {dettid}] {}; the replacement image did not run",
3476 refusal.diagnostic
3477 );
3478 if !self.cfg.panic_on_unsupported_syscalls {
3479 crate::tool_global::report_unsupported_syscall(guest, call.number()).await;
3480 }
3481 return self
3482 .refuse_unserviceable_operation_because(
3483 guest,
3484 call.number(),
3485 errno,
3486 refusal.diagnostic,
3487 )
3488 .await;
3489 }
3490
3491 Err(errno.into())
3492 }
3493
3494 pub async fn handle_sched_yield<G: Guest<Self>>(
3498 &self,
3499 guest: &mut G,
3500 call: syscalls::SchedYield,
3501 ) -> Result<i64, Error> {
3502 if self.cfg.sequentialize_threads {
3503 match sched_yield_route(&self.cfg) {
3504 SchedYieldRoute::ChaosReprioritize => {
3505 let change_time = guest.thread_state().thread_logical_time.as_nanos();
3506 let request = Self::random_priority_changepoint_request(guest, change_time);
3507 resource_request(guest, request).await;
3508 }
3509 SchedYieldRoute::ReplayStrongYield => {
3510 if self.cfg.max_timeslice.is_some() {
3511 guest
3512 .thread_state_mut()
3513 .reset_timeslice_for_explicit_yield();
3514 }
3515 let request = Self::sched_yield_request(guest);
3516 resource_request(guest, request).await;
3517 }
3518 SchedYieldRoute::ChaosYieldEpoch => {
3519 let request = Self::sched_yield_request(guest);
3520 resource_request(guest, request).await;
3521 }
3522 SchedYieldRoute::WeakYield => {
3523 let request = Self::yield_request(guest);
3524 resource_request(guest, request).await;
3525 }
3526 SchedYieldRoute::EndTimeslice => self.end_timeslice_for_sched_yield(guest).await,
3527 }
3528 trace!("sched_yield yielded to the scheduler; NOT performing actual syscall");
3529 Ok(0)
3530 } else {
3531 Ok(self.record_or_replay(guest, call).await?)
3532 }
3533 }
3534
3535 async fn guest_visible_pid<G: Guest<Self>>(
3541 &self,
3542 guest: &mut G,
3543 sysno: reverie::syscalls::Sysno,
3544 child: DetPid,
3545 ) -> Result<i32, Error> {
3546 if !guest.thread_state().nested_pid_namespace {
3547 return Ok(child.as_raw());
3548 }
3549 let refusal = match crate::tool_global::local_pid(guest, child).await {
3550 Ok(Some(local)) => return Ok(local),
3551 Ok(None) => format!("child {child} is not visible in the caller's namespace"),
3552 Err(reason) => reason,
3553 };
3554 Err(self.refuse_nested_pid(guest, sysno, &refusal).await)
3555 }
3556
3557 async fn task_of_guest_pid<G: Guest<Self>>(
3562 &self,
3563 guest: &mut G,
3564 sysno: reverie::syscalls::Sysno,
3565 pid: i32,
3566 ) -> Result<DetPid, Error> {
3567 if !guest.thread_state().nested_pid_namespace || pid <= 0 {
3568 return Ok(DetPid::from_raw(pid));
3569 }
3570 let refusal = match crate::tool_global::guest_pid(guest, pid).await {
3571 GuestPidAnswer::Task { task, .. } => return Ok(task),
3572 GuestPidAnswer::NoSuchPid => {
3573 format!("the kernel answered pid {pid}, which no recorded task has")
3574 }
3575 GuestPidAnswer::Untranslatable(reason) => reason,
3576 };
3577 Err(self.refuse_nested_pid(guest, sysno, &refusal).await)
3578 }
3579
3580 async fn register_clone_pidfd<G: Guest<Self>>(
3600 &self,
3601 guest: &mut G,
3602 address: usize,
3603 child: DetTid,
3604 ) {
3605 let dettid = guest.thread_state().dettid;
3606 let skip = |reason: String| {
3607 tracing::error!(
3608 "[detcore, dtid {}] the pidfd of CLONE_PIDFD child {} is not tracked: {}; pidfd \
3609 calls through it answer EBADF (https://github.com/rrnewton/hermit/issues/4430)",
3610 dettid,
3611 child,
3612 reason,
3613 );
3614 };
3615 let fd: libc::c_int = match Addr::<libc::c_int>::from_raw(address)
3616 .map(|address| guest.memory().read_value(address))
3617 {
3618 Some(Ok(fd)) => fd,
3619 _ => return skip(format!("its word at {address:#x} cannot be read back")),
3622 };
3623 if guest.thread_state().with_detfd(fd, |_| ()).is_ok() {
3626 return skip(format!(
3627 "its word names descriptor {fd}, which Detcore already tracks"
3628 ));
3629 }
3630 if let Err(errno) = self
3631 .track_held_fd(
3632 guest,
3633 fd,
3634 nix::fcntl::OFlag::O_CLOEXEC,
3635 crate::fd::FdType::Pidfd,
3636 )
3637 .await
3638 {
3639 return skip(format!("tracking descriptor {fd} failed with {errno}"));
3640 }
3641 if let Err(error) = guest.thread_state().with_detfd(fd, |detfd| {
3642 detfd.set_pidfd_target(DetPid::from_raw(child.as_raw()))
3643 }) {
3644 skip(format!("descriptor {fd} has no Detcore entry: {error}"));
3645 }
3646 }
3647
3648 async fn clone3_set_tid_refusal<G: Guest<Self>>(
3676 &self,
3677 guest: &mut G,
3678 clone: &syscalls::Clone3,
3679 ) -> Option<Result<i64, Error>> {
3680 const CLONE_ARGS_SIZE_VER1: usize = 80;
3687 const MAX_SET_TID: u64 = 32;
3689 let size = clone.size();
3690 let page = usize::try_from(unsafe { libc::sysconf(libc::_SC_PAGESIZE) }).ok()?;
3691 if size < CLONE_ARGS_SIZE_VER1 || size > page {
3692 return None;
3693 }
3694 let mut raw = vec![0u8; size];
3699 let memory = guest.memory();
3700 memory
3701 .read_exact(Addr::<u8>::from_raw(clone.args()?.as_raw())?, &mut raw)
3702 .ok()?;
3703 let field = |offset: usize| u64::from_ne_bytes(raw[offset..offset + 8].try_into().unwrap());
3704 let flags = field(0);
3705 let exit_signal = field(32);
3706 let set_tid = field(64);
3707 let set_tid_size = field(72);
3708 if exit_signal > 64 || flags & 0xff != 0 {
3710 return None;
3711 }
3712 if set_tid_size == 0 || set_tid_size > MAX_SET_TID {
3713 return None;
3714 }
3715 let mut tids = vec![0 as libc::pid_t; set_tid_size as usize];
3718 memory
3719 .read_values(Addr::<libc::pid_t>::from_raw(set_tid as usize)?, &mut tids)
3720 .ok()?;
3721 let newpid = flags & libc::CLONE_NEWPID as u64 != 0;
3724 if tids.iter().any(|tid| *tid < 1) || (newpid && tids[0] != 1) {
3725 return None;
3726 }
3727 const CAP_SYS_ADMIN: u32 = 21;
3732 const CAP_CHECKPOINT_RESTORE: u32 = 40;
3733 let thread = guest.thread_state();
3734 let status = format!(
3735 "/proc/{}/task/{}/status",
3736 thread.detpid.expect("detpid unset"),
3737 thread.dettid
3738 );
3739 let capabilities = std::fs::read_to_string(status).ok().and_then(|status| {
3740 status
3741 .lines()
3742 .find_map(|line| line.strip_prefix("CapEff:"))
3743 .and_then(|mask| u64::from_str_radix(mask.trim(), 16).ok())
3744 });
3745 let pid_capabilities = (1u64 << CAP_SYS_ADMIN) | (1u64 << CAP_CHECKPOINT_RESTORE);
3746 if capabilities.is_some_and(|mask| mask & pid_capabilities == 0) {
3747 return None;
3748 }
3749 if guest.thread_state().nested_pid_namespace {
3752 return Some(Err(self
3753 .refuse_nested_pid(
3754 guest,
3755 reverie::syscalls::Sysno::clone3,
3756 "clone3 set_tid names pids in a namespace Detcore does not translate",
3757 )
3758 .await));
3759 }
3760 if set_tid_size <= u64::from(newpid) {
3765 return None;
3766 }
3767 let tid = tids[usize::from(newpid)];
3768 if !crate::tool_global::thread_id_refused(guest, DetTid::from_raw(tid)).await {
3769 return None;
3770 }
3771 let message = format!(
3772 "hermit: clone3 set_tid asks for id {tid}, which an earlier task of this run had; \
3773 Detcore keeps per-task state by that id and cannot give it to a new task \
3774 (https://github.com/rrnewton/hermit/issues/4370)"
3775 );
3776 tracing::error!(
3777 "[detcore, dtid {}] {}",
3778 guest.thread_state().dettid,
3779 message
3780 );
3781 if guest.config().panic_on_unsupported_syscalls {
3782 use std::io::Write as _;
3783 let _ = writeln!(crate::util::RetryingStderr, "{message}");
3784 }
3785 Some(
3786 self.refuse_unserviceable_operation(
3787 guest,
3788 reverie::syscalls::Sysno::clone3,
3789 Errno::EEXIST,
3790 )
3791 .await,
3792 )
3793 }
3794
3795 async fn refuse_nested_pid<G: Guest<Self>>(
3798 &self,
3799 guest: &mut G,
3800 sysno: reverie::syscalls::Sysno,
3801 reason: &str,
3802 ) -> Error {
3803 tracing::error!(
3804 "[detcore, dtid {}] {} from a nested PID namespace is not supported: {} (https://github.com/rrnewton/hermit/issues/4155)",
3805 guest.thread_state().dettid,
3806 sysno,
3807 reason,
3808 );
3809 match self
3810 .refuse_unserviceable_operation(guest, sysno, Errno::ENOSYS)
3811 .await
3812 {
3813 Err(error) => error,
3814 Ok(_) => Errno::ENOSYS.into(),
3815 }
3816 }
3817
3818 pub async fn handle_wait4<G: Guest<Self>>(
3822 &self,
3823 guest: &mut G,
3824 call: syscalls::Wait4,
3825 ) -> Result<i64, Error> {
3826 let serial_emulated_wait =
3827 guest.config().backend.emulates_child_waits && guest.config().sequentialize_threads;
3828 let mut emulated_wait_consumed = false;
3829 let dettid = guest.thread_state().dettid;
3830 let mut rsrc = Resources::new(dettid);
3831 rsrc.insert(ResourceID::InternalIOPolling, Permission::W);
3832 rsrc.fyi("wait4");
3833
3834 validate_wait4_arguments(call.pid(), call.options())?;
3835
3836 let parent = guest.thread_state().detpid.expect("detpid unset");
3837 let nested = guest.thread_state().nested_pid_namespace;
3841 if nested && (call.pid() == 0 || call.pid() < -1 || serial_emulated_wait) {
3842 return Err(self
3843 .refuse_nested_pid(
3844 guest,
3845 reverie::syscalls::Sysno::wait4,
3846 "a process-group wait, or a wait on a backend that emulates child waits",
3847 )
3848 .await);
3849 }
3850 let named_child = if call.pid() > 0 && nested {
3851 match crate::tool_global::guest_pid(guest, call.pid()).await {
3852 GuestPidAnswer::Task { task, .. } => task,
3853 GuestPidAnswer::NoSuchPid => return Err(Errno::ECHILD.into()),
3856 GuestPidAnswer::Untranslatable(reason) => {
3857 return Err(self
3858 .refuse_nested_pid(guest, reverie::syscalls::Sysno::wait4, &reason)
3859 .await);
3860 }
3861 }
3862 } else {
3863 DetPid::from_raw(call.pid())
3864 };
3865 let selector = if !wait4_uses_terminal_selector(call.options(), serial_emulated_wait) {
3870 None
3871 } else {
3872 match call.pid() {
3873 pid if pid > 0 => Some(ChildWaitSelector::Exact(named_child)),
3874 -1 => Some(ChildWaitSelector::Any),
3875 0 => process_group(guest, parent)
3876 .await
3877 .map(ChildWaitSelector::ProcessGroup),
3878 pid if pid < -1 => Some(ChildWaitSelector::ProcessGroup(DetPid::from_raw(-pid))),
3879 _ => unreachable!(),
3880 }
3881 };
3882 let spec = selector
3883 .map(|selector| terminal_child_wait_spec(selector, dettid, call.options().bits()));
3884 let complete_lineage = guest.config().backend.tracks_process_children;
3885 let managed_spec = if let Some(spec) = spec {
3886 let (_, has_child) = ready_child_wait(guest, spec).await;
3887 (has_child || complete_lineage).then_some(spec)
3888 } else {
3889 None
3890 };
3891
3892 let value = if call.options().contains(WaitPidFlag::WNOHANG) {
3893 resource_request(guest, rsrc.clone()).await;
3894 info!(
3895 "[dtid {}] Executing non-blocking wait4 in one shot.",
3896 dettid
3897 );
3898 if let Some(spec) = spec {
3899 'select_child: loop {
3900 let (ready, has_child) = ready_child_wait(guest, spec).await;
3901 let Some(child) = ready else {
3902 break if has_child {
3903 0
3904 } else if complete_lineage {
3905 return Err(Errno::ECHILD.into());
3906 } else {
3907 guest.inject_with_retry(call).await?
3908 };
3909 };
3910 let _ = await_exact_child_physical_exit(guest, child).await;
3911 let exact_call = call.with_pid(
3912 self.guest_visible_pid(guest, reverie::syscalls::Sysno::wait4, child)
3913 .await?,
3914 );
3915 loop {
3916 let result = if serial_emulated_wait {
3917 complete_selected_emulated_wait4(guest, exact_call, child).await
3918 } else {
3919 guest
3920 .inject_with_retry(exact_call)
3921 .await
3922 .map_err(Error::from)
3923 };
3924 emulated_wait_consumed =
3925 serial_emulated_wait && matches!(result, Ok(value) if value > 0);
3926 match result {
3927 Ok(value) if value != 0 => break 'select_child value,
3928 Ok(_) => yield_once().await,
3929 Err(Error::Errno(Errno::ECHILD)) => {
3930 let _ = consume_child_wait(guest, child).await;
3931 if child_wait_can_retry_after_stale(spec) {
3932 continue 'select_child;
3933 }
3934 return Err(Errno::ECHILD.into());
3935 }
3936 Err(error) => return Err(error),
3937 }
3938 }
3939 }
3940 } else {
3941 guest.inject_with_retry(call).await?
3942 }
3943 } else if let Some(spec) = managed_spec {
3944 {
3945 let blocked_mask = blocked_signal_mask();
3951 let mut stack = guest.stack().await;
3952 let blocked_mask_addr = stack.push(blocked_mask);
3953 let old_mask_addr = stack.reserve::<KernelSigset>();
3954 let action_addr = stack.reserve::<KernelSigaction>();
3955 let _mask_guard = stack.commit()?;
3956 let guest_signal_mask =
3957 block_signals_for_disposition(guest, blocked_mask_addr, old_mask_addr).await?;
3958 let inspect_signal_action = guest
3959 .config()
3960 .backend
3961 .requires_thread_directed_process_signals;
3962
3963 let poll_call = call.with_options(call.options() | WaitPidFlag::WNOHANG);
3964 let mut pending_signal = None;
3965 let result: Result<i64, Error> = loop {
3966 let status = wait_for_child_lifecycle(guest, spec).await;
3967 if pending_signal.is_none() {
3968 pending_signal = wait_signal_disposition(
3969 guest,
3970 status,
3971 &guest_signal_mask,
3972 action_addr,
3973 inspect_signal_action,
3974 )
3975 .await?;
3976 }
3977 let (ready, has_child) = ready_child_wait(guest, spec).await;
3978 if let Some(child) = ready {
3979 let _ = await_exact_child_physical_exit(guest, child).await;
3980 let result = if serial_emulated_wait {
3981 complete_selected_emulated_wait4(guest, call, child).await
3982 } else {
3983 match self
3984 .guest_visible_pid(guest, reverie::syscalls::Sysno::wait4, child)
3985 .await
3986 {
3987 Ok(pid) => guest
3988 .inject_with_retry(call.with_pid(pid))
3989 .await
3990 .map_err(Error::from),
3991 Err(error) => Err(error),
3992 }
3993 };
3994 emulated_wait_consumed =
3995 serial_emulated_wait && matches!(result, Ok(value) if value > 0);
3996 match result {
3997 Ok(value) => break Ok(value),
3998 Err(Error::Errno(Errno::ECHILD)) => {
3999 let _ = consume_child_wait(guest, child).await;
4000 if child_wait_can_retry_after_stale(spec) {
4001 let (next_ready, _) = ready_child_wait(guest, spec).await;
4002 if stale_any_wait_must_interrupt(
4003 pending_signal.is_some(),
4004 next_ready,
4005 ) {
4006 break interrupted_child_wait_result(
4007 guest,
4008 call,
4009 pending_signal.expect("signal checked above"),
4010 )
4011 .await;
4012 }
4013 continue;
4014 }
4015 break Err(Errno::ECHILD.into());
4016 }
4017 Err(error) => break Err(error),
4018 }
4019 }
4020 if !has_child {
4021 break Err(Errno::ECHILD.into());
4022 }
4023 if serial_emulated_wait {
4024 if let Some(disposition) = pending_signal {
4028 break interrupted_child_wait_result(guest, call, disposition).await;
4029 }
4030 continue;
4031 }
4032 match guest.inject(poll_call).await {
4033 Ok(value) => {
4034 if value > 0 {
4035 break Ok(value);
4036 }
4037 if let Some(disposition) = pending_signal {
4038 break interrupted_child_wait_result(guest, call, disposition)
4039 .await;
4040 }
4041 }
4042 Err(errno) => break Err(errno.into()),
4043 }
4044 };
4045
4046 restore_signals_after_disposition(guest, old_mask_addr).await?;
4047 result?
4048 }
4049 } else {
4050 retry_nonblocking_syscall(guest, call, rsrc, None).await?
4053 };
4054 let reaped = if value > 0 {
4057 self.task_of_guest_pid(guest, reverie::syscalls::Sysno::wait4, value as i32)
4058 .await?
4059 } else {
4060 DetPid::from_raw(value as i32)
4061 };
4062 let consumed_termination = if emulated_wait_consumed || value <= 0 {
4063 false
4064 } else if let Some(status) = call.wstatus() {
4065 wait_status_is_termination(guest.memory().read_value(status)?)
4066 } else if !call
4067 .options()
4068 .intersects(WaitPidFlag::WUNTRACED | WaitPidFlag::WCONTINUED)
4069 {
4070 true
4075 } else {
4076 guest
4079 .thread_state()
4080 .has_exited_child_process_cpu_time(reaped)
4081 || matches!(
4082 crate::tool_global::exact_child_wait_state(guest, reaped).await,
4083 ExactChildWaitState::LogicallyExited
4084 | ExactChildWaitState::PhysicalExitPending
4085 | ExactChildWaitState::PhysicallyExited
4086 )
4087 };
4088 if consumed_termination {
4089 guest.thread_state_mut().reap_child_process_cpu_time(reaped);
4090 let _ = consume_child_wait(guest, reaped).await;
4091 }
4092 if value > 0
4093 && let Some(rusage) = call.rusage()
4094 {
4095 let usage: libc::rusage = unsafe { std::mem::zeroed() };
4097 guest.memory().write_value(rusage, &usage)?;
4098 }
4099 Ok(value)
4100 }
4101
4102 pub async fn handle_waitid<G: Guest<Self>>(
4108 &self,
4109 guest: &mut G,
4110 mut call: syscalls::Waitid,
4111 ) -> Result<i64, Error> {
4112 if guest.config().backend.emulates_child_waits && guest.config().sequentialize_threads {
4117 if guest.thread_state().nested_pid_namespace {
4121 return Err(self
4122 .refuse_nested_pid(
4123 guest,
4124 reverie::syscalls::Sysno::waitid,
4125 "a wait on a backend that emulates child waits",
4126 )
4127 .await);
4128 }
4129 return emulated_waitid::handle(guest, call).await;
4130 }
4131 let nested = guest.thread_state().nested_pid_namespace;
4135 if nested && call.which() == libc::P_PGID as i32 {
4136 return Err(self
4137 .refuse_nested_pid(
4138 guest,
4139 reverie::syscalls::Sysno::waitid,
4140 "a process-group wait",
4141 )
4142 .await);
4143 }
4144 let named_child = if nested && call.which() == libc::P_PID as i32 && call.pid() > 0 {
4145 match crate::tool_global::guest_pid(guest, call.pid()).await {
4146 GuestPidAnswer::Task { task, .. } => task,
4147 GuestPidAnswer::NoSuchPid => return Err(Errno::ECHILD.into()),
4148 GuestPidAnswer::Untranslatable(reason) => {
4149 return Err(self
4150 .refuse_nested_pid(guest, reverie::syscalls::Sysno::waitid, &reason)
4151 .await);
4152 }
4153 }
4154 } else {
4155 DetPid::from_raw(call.pid())
4156 };
4157 let dettid = guest.thread_state().dettid;
4158 let mut rsrc = Resources::new(dettid);
4159 rsrc.insert(ResourceID::InternalIOPolling, Permission::W);
4160 rsrc.fyi("waitid");
4161
4162 let event_options = libc::WEXITED | libc::WSTOPPED | libc::WCONTINUED;
4163 let allowed_options = event_options
4164 | libc::WNOHANG
4165 | libc::WNOWAIT
4166 | libc::__WNOTHREAD
4167 | libc::__WALL
4168 | libc::__WCLONE;
4169 if call.options() & event_options == 0 || call.options() & !allowed_options != 0 {
4170 return Err(Errno::EINVAL.into());
4171 }
4172
4173 if call.info().is_none() {
4178 return Err(Errno::EFAULT.into());
4179 }
4180
4181 let terminal_events_only = call.options() & libc::WEXITED != 0
4184 && call.options() & (libc::WSTOPPED | libc::WCONTINUED | libc::__WCLONE | libc::__WALL)
4185 == 0;
4186
4187 if !terminal_events_only && call.which() == libc::P_PGID as i32 && call.pid() == 0 {
4190 call = call.with_pid(snapshot_process_group(guest.pid())?);
4191 }
4192
4193 let pidfd_nonblocking =
4197 if call.which() == libc::P_PIDFD as i32 && call.options() & libc::WNOHANG == 0 {
4198 resource_request(guest, rsrc.clone()).await;
4199 guest_fd_status_flags(guest.pid(), call.pid())? & libc::O_NONBLOCK != 0
4200 } else {
4201 false
4202 };
4203 if call.which() == libc::P_PIDFD as i32
4204 && call.options() & libc::WNOHANG == 0
4205 && !pidfd_nonblocking
4206 {
4207 return Err(Errno::EOPNOTSUPP.into());
4211 }
4212 let info = call.info().expect("waitid infop checked above");
4213
4214 let empty_info: libc::siginfo_t = unsafe { std::mem::zeroed() };
4223
4224 let terminal_spec = if terminal_events_only {
4228 let selector = match call.which() {
4229 which if which == libc::P_PID as i32 => Some(ChildWaitSelector::Exact(named_child)),
4230 which if which == libc::P_ALL as i32 => Some(ChildWaitSelector::Any),
4231 which if which == libc::P_PGID as i32 => {
4232 let group = if call.pid() == 0 {
4233 process_group(guest, guest.thread_state().detpid.expect("detpid unset"))
4234 .await
4235 } else {
4236 Some(DetPid::from_raw(call.pid()))
4237 };
4238 group.map(ChildWaitSelector::ProcessGroup)
4239 }
4240 _ => None,
4241 };
4242 selector.map(|selector| terminal_child_wait_spec(selector, dettid, call.options()))
4243 } else {
4244 None
4245 };
4246 let complete_lineage = guest.config().backend.tracks_process_children;
4247 let managed_terminal_spec = if let Some(spec) = terminal_spec {
4248 let (_, has_child) = ready_child_wait(guest, spec).await;
4249 (has_child || complete_lineage).then_some(spec)
4250 } else {
4251 None
4252 };
4253
4254 if call.options() & libc::WNOHANG != 0 || pidfd_nonblocking {
4255 if !pidfd_nonblocking {
4256 resource_request(guest, rsrc).await;
4257 }
4258 info!(
4259 "[dtid {}] Executing non-blocking waitid in one shot.",
4260 dettid
4261 );
4262 'select_child: loop {
4263 let selected = if let Some(spec) = terminal_spec {
4264 let (ready, has_child) = ready_child_wait(guest, spec).await;
4265 if ready.is_none() && has_child {
4266 guest.memory().write_value(info, &empty_info)?;
4267 return Ok(0);
4268 }
4269 if ready.is_none() && complete_lineage {
4270 return Err(Errno::ECHILD.into());
4271 }
4272 ready
4273 } else {
4274 None
4275 };
4276 if let Some(child) = selected {
4277 let _ = await_exact_child_physical_exit(guest, child).await;
4278 }
4279 let effective_call = match selected {
4280 Some(child) => call.with_which(libc::P_PID as i32).with_pid(
4281 self.guest_visible_pid(guest, reverie::syscalls::Sysno::waitid, child)
4282 .await?,
4283 ),
4284 None => call,
4285 };
4286 loop {
4287 guest.memory().write_value(info, &empty_info)?;
4288 let value = match guest.inject_with_retry(effective_call).await {
4289 Ok(value) => value,
4290 Err(Errno::ECHILD) if selected.is_some() => {
4291 let child = selected.expect("selected child checked above");
4292 let _ = consume_child_wait(guest, child).await;
4293 if terminal_spec.is_some_and(child_wait_can_retry_after_stale) {
4294 continue 'select_child;
4295 }
4296 return Err(Errno::ECHILD.into());
4297 }
4298 Err(errno) => return Err(errno.into()),
4299 };
4300 let info_value: libc::siginfo_t = guest.memory().read_value(info)?;
4301 let child_pid = unsafe { info_value.si_pid() };
4302 if child_pid == 0 && selected.is_some() {
4303 yield_once().await;
4304 continue;
4305 }
4306 let consumed = child_pid != 0
4307 && call.options() & libc::WNOWAIT == 0
4308 && waitid_code_is_termination(info_value.si_code);
4309 let child = self
4310 .task_of_guest_pid(guest, reverie::syscalls::Sysno::waitid, child_pid)
4311 .await?;
4312 let result = finish_waitid_result(guest, call, value, info_value, child)?;
4313 if consumed {
4314 let _ = consume_child_wait(guest, child).await;
4315 }
4316 return Ok(result);
4317 }
4318 }
4319 }
4320
4321 {
4322 let blocked_mask = blocked_signal_mask();
4330 let mut stack = guest.stack().await;
4331 let blocked_mask_addr = stack.push(blocked_mask);
4332 let old_mask_addr = stack.reserve::<KernelSigset>();
4333 let action_addr = stack.reserve::<KernelSigaction>();
4334 let _mask_guard = stack.commit()?;
4335 let guest_signal_mask =
4336 block_signals_for_disposition(guest, blocked_mask_addr, old_mask_addr).await?;
4337 let inspect_signal_action = guest
4338 .config()
4339 .backend
4340 .requires_thread_directed_process_signals;
4341
4342 let poll_call = call.with_options(call.options() | libc::WNOHANG);
4343 let mut pending_signal = None;
4344 let result: Result<i64, Error> = loop {
4345 let managed_spec = managed_terminal_spec;
4356 let status = if let Some(spec) = managed_spec {
4360 wait_for_child_lifecycle(guest, spec).await
4361 } else {
4362 resource_request(guest, rsrc.clone()).await
4363 };
4364 if pending_signal.is_none() {
4365 pending_signal = wait_signal_disposition(
4366 guest,
4367 status,
4368 &guest_signal_mask,
4369 action_addr,
4370 inspect_signal_action,
4371 )
4372 .await?;
4373 }
4374 let (ready, has_child) = if let Some(spec) = managed_spec {
4375 ready_child_wait(guest, spec).await
4376 } else {
4377 (None, true)
4378 };
4379 if let Some(child) = ready {
4380 let _ = await_exact_child_physical_exit(guest, child).await;
4381 if let Err(error) = guest.memory().write_value(info, &empty_info) {
4382 break Err(error.into());
4383 }
4384 let pid = match self
4385 .guest_visible_pid(guest, reverie::syscalls::Sysno::waitid, child)
4386 .await
4387 {
4388 Ok(pid) => pid,
4389 Err(error) => break Err(error),
4390 };
4391 let exact_call = call.with_which(libc::P_PID as i32).with_pid(pid);
4392 match guest.inject_with_retry(exact_call).await {
4393 Ok(value) => {
4394 let info_value: libc::siginfo_t = match guest.memory().read_value(info)
4395 {
4396 Ok(value) => value,
4397 Err(error) => break Err(error.into()),
4398 };
4399 let reported = match self
4400 .task_of_guest_pid(
4401 guest,
4402 reverie::syscalls::Sysno::waitid,
4403 unsafe { info_value.si_pid() },
4404 )
4405 .await
4406 {
4407 Ok(task) => task,
4408 Err(error) => break Err(error),
4409 };
4410 break finish_waitid_result(guest, call, value, info_value, reported);
4411 }
4412 Err(Errno::ECHILD) => {
4413 let _ = consume_child_wait(guest, child).await;
4414 if managed_spec.is_some_and(child_wait_can_retry_after_stale) {
4415 let (next_ready, _) =
4416 ready_child_wait(guest, managed_spec.expect("managed spec"))
4417 .await;
4418 if stale_any_wait_must_interrupt(
4419 pending_signal.is_some(),
4420 next_ready,
4421 ) {
4422 break interrupted_child_wait_result(
4423 guest,
4424 call,
4425 pending_signal.expect("signal checked above"),
4426 )
4427 .await;
4428 }
4429 continue;
4430 }
4431 break Err(Errno::ECHILD.into());
4432 }
4433 Err(errno) => break Err(errno.into()),
4434 }
4435 }
4436 if managed_spec.is_some() && !has_child {
4437 break Err(Errno::ECHILD.into());
4438 }
4439
4440 if let Err(error) = guest.memory().write_value(info, &empty_info) {
4441 break Err(error.into());
4442 }
4443 let result = guest.inject(poll_call).await;
4444 match result {
4445 Ok(value) => {
4446 let info_value: libc::siginfo_t = match guest.memory().read_value(info) {
4447 Ok(value) => value,
4448 Err(error) => break Err(error.into()),
4449 };
4450 let child_pid = unsafe { info_value.si_pid() };
4453 match exact_wait_poll_decision(
4454 child_pid != 0,
4455 pending_signal.is_some(),
4456 None,
4457 ) {
4458 ExactWaitPollDecision::ChildReady => {
4459 let reported = match self
4460 .task_of_guest_pid(
4461 guest,
4462 reverie::syscalls::Sysno::waitid,
4463 child_pid,
4464 )
4465 .await
4466 {
4467 Ok(task) => task,
4468 Err(error) => break Err(error),
4469 };
4470 break finish_waitid_result(
4471 guest, call, value, info_value, reported,
4472 );
4473 }
4474 ExactWaitPollDecision::Interrupted => {
4475 break interrupted_child_wait_result(
4476 guest,
4477 call,
4478 pending_signal.expect("signal checked above"),
4479 )
4480 .await;
4481 }
4482 ExactWaitPollDecision::Retry => {}
4483 ExactWaitPollDecision::AwaitPhysicalExit
4484 | ExactWaitPollDecision::ReapAfterLogicalExit => unreachable!(),
4485 }
4486 if managed_spec.is_some() {
4487 if !has_child {
4488 break Ok(value);
4489 }
4490 continue;
4491 }
4492 rsrc.poll_attempt += 1;
4493 trace!(
4494 "Retry #{} for waitid because no child state is ready",
4495 rsrc.poll_attempt
4496 );
4497 record_retry_event(guest, poll_call).await;
4498 }
4499 Err(Errno::ERESTARTSYS) if pending_signal.is_some() => {
4500 break Err(Errno::EINTR.into());
4501 }
4502 Err(errno) => break Err(errno.into()),
4503 }
4504 };
4505
4506 restore_signals_after_disposition(guest, old_mask_addr).await?;
4507 if result.is_ok() && call.options() & libc::WNOWAIT == 0 {
4508 let info_value: libc::siginfo_t = guest.memory().read_value(info)?;
4509 let child_pid = unsafe { info_value.si_pid() };
4510 if child_pid != 0 && waitid_code_is_termination(info_value.si_code) {
4511 let child = self
4512 .task_of_guest_pid(guest, reverie::syscalls::Sysno::waitid, child_pid)
4513 .await?;
4514 let _ = consume_child_wait(guest, child).await;
4515 }
4516 }
4517 result
4518 }
4519 }
4520
4521 pub async fn handle_sched_setaffinity<G: Guest<Self>>(
4525 &self,
4526 guest: &mut G,
4527 call: syscalls::SchedSetaffinity,
4528 ) -> Result<i64, Error> {
4529 let size_bytes = call.len() as usize;
4530 if size_bytes == 0 {
4531 return Err(Errno::EINVAL.into());
4532 }
4533
4534 let mask = call.mask().ok_or(Errno::EFAULT)?;
4535 let mask: Addr<u8> = mask.cast();
4536 let mut requested = [0u8; VIRTUAL_CPUSET_BYTES];
4537 let bytes_to_read = size_bytes.min(VIRTUAL_CPUSET_BYTES);
4538 guest
4539 .memory()
4540 .read_exact(mask, &mut requested[..bytes_to_read])?;
4541 info!(
4542 "Suppressing sched_setaffinity mask {:?}; affinity remains virtual CPU 0",
4543 requested
4544 );
4545 Ok(0)
4546 }
4547
4548 pub async fn handle_sched_getaffinity<G: Guest<Self>>(
4560 &self,
4561 guest: &mut G,
4562 call: syscalls::SchedGetaffinity,
4563 ) -> Result<i64, Error> {
4564 let size_bytes: usize = call.len() as usize;
4565 if size_bytes == 0 || !size_bytes.is_multiple_of(std::mem::size_of::<libc::c_ulong>()) {
4566 return Err(Errno::EINVAL.into());
4567 }
4568 let copied = size_bytes.min(VIRTUAL_CPUSET_BYTES);
4569
4570 let mut cpu_set = [0u8; VIRTUAL_CPUSET_BYTES];
4574 cpu_set[0] = 1;
4575
4576 info!(
4577 "Suppressing sched_getaffinity and returning {}-byte virtualized result, {:?}",
4578 copied,
4579 &cpu_set[..copied]
4580 );
4581 if let Some(mask) = call.mask() {
4582 let mask: AddrMut<u8> = mask.cast();
4583 guest.memory().write_exact(mask, &cpu_set[..copied])?;
4584 Ok(copied as i64)
4590 } else {
4591 Err(Error::Errno(Errno::EFAULT))
4592 }
4593 }
4594
4595 pub async fn handle_sched_getparam<G: Guest<Self>>(
4603 &self,
4604 guest: &mut G,
4605 call: syscalls::SchedGetparam,
4606 ) -> Result<i64, Error> {
4607 if let Some(param) = call.param() {
4608 let p = libc::sched_param { sched_priority: 0 };
4609 guest.memory().write_value(param, &p)?;
4610 }
4611 Ok(0)
4612 }
4613
4614 pub async fn handle_sched_rr_get_interval<G: Guest<Self>>(
4621 &self,
4622 guest: &mut G,
4623 call: syscalls::SchedRrGetInterval,
4624 ) -> Result<i64, Error> {
4625 if let Some(tp) = call.tp() {
4626 let t = Timespec {
4627 tv_sec: 0,
4628 tv_nsec: 0,
4629 };
4630 guest.memory().write_value(tp, &t)?;
4631 }
4632 Ok(0)
4633 }
4634
4635 pub async fn handle_sched_getattr<G: Guest<Self>>(
4643 &self,
4644 guest: &mut G,
4645 call: syscalls::SchedGetattr,
4646 ) -> Result<i64, Error> {
4647 if call.flags() != 0 {
4649 return Err(Errno::EINVAL.into());
4650 }
4651 let attr_size = std::mem::size_of::<libc::sched_attr>();
4653 if (call.size() as usize) < attr_size {
4654 return Err(Errno::EINVAL.into());
4655 }
4656 let attr = call.attr().ok_or(Errno::EINVAL)?;
4657 let mut sa: libc::sched_attr = unsafe { std::mem::zeroed() };
4660 sa.size = attr_size as u32;
4661 sa.sched_policy = libc::SCHED_OTHER as u32;
4662 let bytes = unsafe {
4665 std::slice::from_raw_parts(&sa as *const libc::sched_attr as *const u8, attr_size)
4666 };
4667 let dst: AddrMut<u8> = attr.cast();
4668 guest.memory().write_exact(dst, bytes)?;
4669 info!(
4670 "Emulating sched_getattr(pid={}): fixed SCHED_OTHER, nice 0, priority 0",
4671 call.pid()
4672 );
4673 Ok(0)
4674 }
4675
4676 pub async fn handle_sched_setattr<G: Guest<Self>>(
4738 &self,
4739 guest: &mut G,
4740 call: syscalls::SchedSetattr,
4741 ) -> Result<i64, Error> {
4742 if call.flags() != 0 || call.pid() < 0 {
4747 return Err(Errno::EINVAL.into());
4748 }
4749 let attr = call.attr().ok_or(Errno::EINVAL)?;
4750
4751 let declared: u32 = guest
4760 .memory()
4761 .read_value(attr.cast())
4762 .map_err(|_| Errno::EFAULT)?;
4763
4764 fn refuse_too_big<S: MemoryAccess>(mut memory: S, attr: AddrMut<libc::c_void>) -> Error {
4770 let _ = memory.write_value(attr.cast::<u32>(), &SCHED_ATTR_KERNEL_SIZE);
4771 Errno::E2BIG.into()
4772 }
4773
4774 let size = match sched_attr_effective_size(declared) {
4775 Ok(size) => size,
4776 Err(()) => {
4777 let back = call.attr().ok_or(Errno::EINVAL)?;
4778 return Err(refuse_too_big(guest.memory(), back));
4779 }
4780 };
4781
4782 if size > SCHED_ATTR_KERNEL_SIZE {
4788 let base: AddrMut<u8> = call.attr().ok_or(Errno::EINVAL)?.cast();
4789 match scan_tail_is_zeroed(
4790 &guest.memory(),
4791 base,
4792 SCHED_ATTR_KERNEL_SIZE as usize,
4793 (size - SCHED_ATTR_KERNEL_SIZE) as usize,
4794 ) {
4795 TailVerdict::AllZero => {}
4796 TailVerdict::NotZeroed => {
4797 let back = call.attr().ok_or(Errno::EINVAL)?;
4798 return Err(refuse_too_big(guest.memory(), back));
4799 }
4800 TailVerdict::Faulted => return Err(Errno::EFAULT.into()),
4801 }
4802 }
4803
4804 let copied = std::cmp::min(size, SCHED_ATTR_KERNEL_SIZE) as usize;
4808 let mut raw = [0u8; SCHED_ATTR_KERNEL_SIZE as usize];
4809 let base: AddrMut<u8> = call.attr().ok_or(Errno::EINVAL)?.cast();
4810 guest
4811 .memory()
4812 .read_exact(base, &mut raw[..copied])
4813 .map_err(|_| Errno::EFAULT)?;
4814 let field32 = |offset: usize| -> u32 {
4815 u32::from_ne_bytes(raw[offset..offset + 4].try_into().expect("4 bytes"))
4816 };
4817 let field64 = |offset: usize| -> u64 {
4818 u64::from_ne_bytes(raw[offset..offset + 8].try_into().expect("8 bytes"))
4819 };
4820 let fields = SchedAttrFields {
4821 policy: field32(SCHED_ATTR_OFF_POLICY),
4822 sched_flags: field64(SCHED_ATTR_OFF_FLAGS),
4823 priority: field32(SCHED_ATTR_OFF_PRIORITY),
4824 runtime: field64(SCHED_ATTR_OFF_RUNTIME),
4825 deadline: field64(SCHED_ATTR_OFF_DEADLINE),
4826 period: field64(SCHED_ATTR_OFF_PERIOD),
4827 };
4828
4829 validate_sched_attr_before_lookup(size, &fields)?;
4831
4832 let named = if call.pid() > 0 && guest.thread_state().nested_pid_namespace {
4845 match crate::tool_global::guest_pid(guest, call.pid()).await {
4846 GuestPidAnswer::Task { task, .. } => Some(task),
4847 GuestPidAnswer::NoSuchPid => None,
4848 GuestPidAnswer::Untranslatable(reason) => {
4849 return Err(self
4850 .refuse_nested_pid(guest, reverie::syscalls::Sysno::sched_setattr, &reason)
4851 .await);
4852 }
4853 }
4854 } else {
4855 Some(DetTid::from_raw(call.pid()))
4856 };
4857 if call.pid() != 0 {
4858 match named {
4859 Some(task) if thread_is_live(guest, task).await => {}
4860 _ => return Err(Errno::ESRCH.into()),
4861 }
4862 }
4863
4864 validate_sched_attr_after_lookup(&fields)?;
4866
4867 info!(
4868 "Suppressing sched_setattr(pid={}, flags={}); Linux scheduler attributes are virtual",
4869 call.pid(),
4870 call.flags()
4871 );
4872 Ok(0)
4873 }
4874
4875 pub async fn handle_ioprio_set<G: Guest<Self>>(
4883 &self,
4884 _guest: &mut G,
4885 call: syscalls::IoprioSet,
4886 ) -> Result<i64, Error> {
4887 info!(
4888 "Suppressing ioprio_set(which={}, who={}, priority={}); I/O priority is virtual",
4889 call.which(),
4890 call.who(),
4891 call.priority()
4892 );
4893 Ok(0)
4894 }
4895
4896 pub async fn handle_ioprio_get<G: Guest<Self>>(
4903 &self,
4904 _guest: &mut G,
4905 call: syscalls::IoprioGet,
4906 ) -> Result<i64, Error> {
4907 let priority = virtual_ioprio(call.which())?;
4908
4909 info!(
4910 "Emulating ioprio_get(which={}, who={}): fixed priority {}",
4911 call.which(),
4912 call.who(),
4913 priority
4914 );
4915 Ok(priority)
4916 }
4917}
4918
4919struct GuestRobustEffects<'a, G, T> {
4925 guest: &'a mut G,
4926 dettid: DetTid,
4927 staged_wakes: Option<&'a mut Vec<RobustListWake>>,
4928 marked: &'a mut HashMap<FutexID, u32>,
4935 tool: PhantomData<T>,
4936}
4937
4938impl<G, T> robust_list::RobustDeathEffects for GuestRobustEffects<'_, G, T>
4939where
4940 G: Guest<Detcore<T>>,
4941 T: RecordOrReplay,
4942{
4943 fn read_u64(&mut self, address: usize) -> Option<u64> {
4944 let at = Addr::<u64>::from_raw(address)?;
4945 self.guest.memory().read_value::<_, u64>(at).ok()
4946 }
4947
4948 fn read_u32(&mut self, address: usize) -> Option<u32> {
4949 let at = Addr::<u32>::from_raw(address)?;
4950 let value = self.guest.memory().read_value::<_, u32>(at).ok()?;
4951 let futexid = self.guest.thread_state().futex_id(address, false);
4952 Some(self.marked.get(&futexid).copied().unwrap_or(value))
4953 }
4954
4955 fn compare_and_swap(
4956 &mut self,
4957 address: usize,
4958 expected: u32,
4959 desired: u32,
4960 ) -> robust_list::FutexCasOutcome {
4961 use robust_list::FutexCasOutcome;
4962
4963 let Some(read_at) = Addr::<u32>::from_raw(address) else {
4964 return FutexCasOutcome::Faulted;
4965 };
4966 let observed = match self.guest.memory().read_value::<_, u32>(read_at) {
4971 Ok(value) => value,
4972 Err(_) => return FutexCasOutcome::Faulted,
4973 };
4974 let futexid = self.guest.thread_state().futex_id(address, false);
4975 let observed = self.marked.get(&futexid).copied().unwrap_or(observed);
4976 if observed != expected {
4977 return FutexCasOutcome::Changed(observed);
4978 }
4979 self.marked.insert(futexid, desired);
4980 debug!(
4987 "[detcore, dtid {}] robust-list owner death: leaving futex word {:#x} for backend exit cleanup",
4988 self.dettid, address,
4989 );
4990 FutexCasOutcome::Matched
4991 }
4992
4993 async fn wake_one(&mut self, address: usize, observed: u32) {
4994 let futexid = self.guest.thread_state().futex_id(address, false);
4997 if let Some(wakes) = self.staged_wakes.as_mut() {
4998 wakes.push(RobustListWake { futex: futexid });
4999 debug!(
5000 "[detcore, dtid {}] staged robust-list owner-death wake until physical exit",
5001 self.dettid,
5002 );
5003 return;
5004 }
5005 let woken = match futex_action(
5006 self.guest,
5007 FutexAction::WakeRequest(1),
5008 &futexid,
5009 observed as i32,
5010 u32::MAX,
5011 )
5012 .await
5013 {
5014 Some(SchedValue::Value(count)) => count,
5015 Some(SchedValue::TimeOut)
5017 | Some(SchedValue::Signaled(_))
5018 | Some(SchedValue::Requeued { .. })
5019 | None => 0,
5020 };
5021 info!(
5025 "[detcore, dtid {}] robust-list owner death woke {} waiter(s) on futex {:?}",
5026 self.dettid, woken, futexid,
5027 );
5028 let _ = futex_action(
5029 self.guest,
5030 FutexAction::WakeFinished(0),
5031 &futexid,
5032 observed as i32,
5033 u32::MAX,
5034 )
5035 .await;
5036 }
5037}
5038
5039#[derive(Debug, Clone, Copy, PartialEq, Eq)]
5042enum OwnerDeath {
5043 Exit,
5045 Exec,
5048}
5049
5050fn owner_death_path(cfg: &Config) -> Option<OwnerDeathPath> {
5062 if !cfg.sequentialize_threads || cfg.debug_futex_mode != BlockingMode::Precise {
5063 return None;
5064 }
5065 if cfg.backend.runs_exit_robust_list {
5066 Some(OwnerDeathPath::Kernel)
5067 } else if cfg.backend.requires_thread_directed_process_signals {
5068 Some(OwnerDeathPath::Barrier)
5069 } else {
5070 None
5071 }
5072}
5073
5074#[derive(Debug, Clone, Copy, PartialEq, Eq)]
5078enum OwnerDeathPath {
5079 Kernel,
5083 Barrier,
5093}
5094
5095#[derive(Debug, Clone, Copy, PartialEq, Eq)]
5099pub(crate) enum FutexCommand {
5100 Served,
5103 NoSys,
5107 PriorityInheritance(&'static str),
5110}
5111
5112pub(crate) fn classify_futex_command(futex_op: i32) -> FutexCommand {
5115 let cmd = futex_op & libc::FUTEX_CMD_MASK;
5116 if futex_op & libc::FUTEX_CLOCK_REALTIME != 0
5117 && !matches!(
5118 cmd,
5119 libc::FUTEX_WAIT_BITSET | libc::FUTEX_WAIT_REQUEUE_PI | libc::FUTEX_LOCK_PI2
5120 )
5121 {
5122 return FutexCommand::NoSys;
5123 }
5124 match cmd {
5125 libc::FUTEX_WAIT
5126 | libc::FUTEX_WAIT_BITSET
5127 | libc::FUTEX_WAKE
5128 | libc::FUTEX_WAKE_BITSET
5129 | libc::FUTEX_REQUEUE
5130 | libc::FUTEX_CMP_REQUEUE
5131 | libc::FUTEX_WAKE_OP => FutexCommand::Served,
5132 libc::FUTEX_LOCK_PI => FutexCommand::PriorityInheritance("FUTEX_LOCK_PI"),
5133 libc::FUTEX_LOCK_PI2 => FutexCommand::PriorityInheritance("FUTEX_LOCK_PI2"),
5134 libc::FUTEX_UNLOCK_PI => FutexCommand::PriorityInheritance("FUTEX_UNLOCK_PI"),
5135 libc::FUTEX_TRYLOCK_PI => FutexCommand::PriorityInheritance("FUTEX_TRYLOCK_PI"),
5136 libc::FUTEX_WAIT_REQUEUE_PI => FutexCommand::PriorityInheritance("FUTEX_WAIT_REQUEUE_PI"),
5137 libc::FUTEX_CMP_REQUEUE_PI => FutexCommand::PriorityInheritance("FUTEX_CMP_REQUEUE_PI"),
5138 _ => FutexCommand::NoSys,
5139 }
5140}
5141
5142const POLLING_REFUSAL: &str = "--debug-futex-mode polling does not model futex waiter lists";
5145
5146fn futex_val2(call: &syscalls::Futex) -> u32 {
5151 call.timeout().map_or(0, Addr::as_raw) as u32
5152}
5153
5154fn futex_uaddr2(call: &syscalls::Futex) -> usize {
5156 call.uaddr2().map_or(0, AddrMut::as_raw)
5157}
5158
5159fn futex_uaddr(call: &syscalls::Futex) -> usize {
5162 call.uaddr().map_or(0, AddrMut::as_raw)
5163}
5164
5165#[derive(Clone, Copy, Debug, PartialEq, Eq)]
5167enum KeyAccess {
5168 Read,
5170 Write,
5172}
5173
5174fn user_ptr_max() -> usize {
5181 static MAX: std::sync::OnceLock<usize> = std::sync::OnceLock::new();
5182 *MAX.get_or_init(|| {
5183 let accepted = |address: usize| {
5184 let ret = unsafe {
5186 libc::syscall(
5187 libc::SYS_futex,
5188 address,
5189 libc::FUTEX_WAKE | libc::FUTEX_PRIVATE_FLAG,
5190 0,
5191 0,
5192 0,
5193 0,
5194 )
5195 };
5196 ret >= 0
5197 };
5198 let (mut ok, mut bad) = (0usize, 1usize << 63);
5201 while bad - ok > 4 {
5202 let mid = (ok + (bad - ok) / 2) & !3;
5203 if accepted(mid) { ok = mid } else { bad = mid }
5204 }
5205 ok
5206 })
5207}
5208
5209async fn futex_key<G: Guest<Detcore<T>>, T: RecordOrReplay>(
5220 guest: &mut G,
5221 address: usize,
5222 private: bool,
5223 access: KeyAccess,
5224) -> Result<FutexID, Error> {
5225 if !address.is_multiple_of(std::mem::size_of::<u32>()) {
5226 return Err(Error::Errno(Errno::EINVAL));
5227 }
5228 if address > user_ptr_max() {
5229 return Err(Error::Errno(Errno::EFAULT));
5230 }
5231 if !private {
5232 probe_shared_futex_key(guest, address, access).await?;
5233 }
5234 Ok(guest.thread_state().futex_id(address, private))
5235}
5236
5237async fn probe_shared_futex_key<G: Guest<Detcore<T>>, T: RecordOrReplay>(
5251 guest: &mut G,
5252 address: usize,
5253 access: KeyAccess,
5254) -> Result<(), Error> {
5255 let probe = shared_futex_key_probe(address, access);
5256 match run_shared_futex_key_probe(guest, probe, access, |guest, probe| guest.inject(probe)).await
5257 {
5258 SharedKeyProbe::Admitted => Ok(()),
5259 SharedKeyProbe::Refused(errno) => Err(Error::Errno(errno)),
5260 SharedKeyProbe::Interrupted(errno) => {
5261 refuse_interrupted_shared_key_probe(guest, address, errno).await
5262 }
5263 }
5264}
5265
5266fn shared_futex_key_probe(address: usize, access: KeyAccess) -> syscalls::Futex {
5269 let word = AddrMut::<libc::c_int>::from_raw(address);
5270 match access {
5271 KeyAccess::Read => syscalls::Futex::new()
5272 .with_uaddr(word)
5273 .with_futex_op(libc::FUTEX_REQUEUE)
5274 .with_val(0)
5275 .with_uaddr2(word),
5276 KeyAccess::Write => syscalls::Futex::new()
5277 .with_uaddr(word)
5278 .with_futex_op(libc::FUTEX_WAKE_OP)
5279 .with_val(0)
5280 .with_uaddr2(word)
5281 .with_val3((7 << 28) | (1 << 12)),
5282 }
5283}
5284
5285type KeyProbeAnswer<'a> =
5287 std::pin::Pin<Box<dyn std::future::Future<Output = Result<i64, Errno>> + Send + 'a>>;
5288
5289#[derive(Clone, Copy, Debug, PartialEq, Eq)]
5291enum SharedKeyProbe {
5292 Admitted,
5295 Refused(Errno),
5297 Interrupted(Errno),
5301}
5302
5303async fn run_shared_futex_key_probe<C>(
5311 context: &mut C,
5312 probe: syscalls::Futex,
5313 access: KeyAccess,
5314 inject: for<'a> fn(&'a mut C, syscalls::Futex) -> KeyProbeAnswer<'a>,
5315) -> SharedKeyProbe {
5316 match inject(context, probe).await {
5317 Ok(_) => SharedKeyProbe::Admitted,
5318 Err(errno @ (Errno::ERESTARTSYS | Errno::EINTR)) => SharedKeyProbe::Interrupted(errno),
5319 Err(Errno::ENOSYS) if access == KeyAccess::Write => SharedKeyProbe::Admitted,
5320 Err(errno) => SharedKeyProbe::Refused(errno),
5321 }
5322}
5323
5324async fn refuse_interrupted_shared_key_probe<G: Guest<Detcore<T>>, T: RecordOrReplay>(
5335 guest: &mut G,
5336 address: usize,
5337 errno: Errno,
5338) -> ! {
5339 {
5340 use std::io::Write;
5341 let _ = writeln!(
5342 crate::util::RetryingStderr,
5343 "hermit: a signal interrupted Detcore's shared futex key check for word {:#x} in thread {} ({}); \
5344 refusing the run rather than retrying it, which could lose that signal \
5345 (https://github.com/rrnewton/hermit/pull/4020)",
5346 address,
5347 guest.thread_state().dettid,
5348 errno,
5349 );
5350 }
5351 crate::tool_global::unrecoverable_shutdown(guest, detcore_model::HERMIT_POLICY_REFUSAL_EXIT)
5352 .await
5353}
5354
5355fn read_futex_word<G: Guest<Detcore<T>>, T: RecordOrReplay>(
5366 guest: &mut G,
5367 address: usize,
5368) -> Result<i32, Error> {
5369 let word = Addr::<u8>::from_raw(address).ok_or(Errno::EFAULT)?;
5370 let mut bytes = [0u8; 4];
5371 if guest
5372 .memory()
5373 .read_exact_with_user_access(word, &mut bytes)
5374 .is_ok()
5375 {
5376 return Ok(i32::from_ne_bytes(bytes));
5377 }
5378 if !bundled_signal_facts::host_task_reads_enabled(&guest.config().backend)
5382 || !mapping_is_writable(guest.pid().as_raw(), address)
5383 {
5384 return Err(Error::Errno(Errno::EFAULT));
5385 }
5386 let aligned = address & !(std::mem::size_of::<u64>() - 1);
5387 let pair: u64 = guest
5388 .memory()
5389 .read_value(Addr::<u64>::from_raw(aligned).ok_or(Errno::EFAULT)?)
5390 .map_err(|_| Error::Errno(Errno::EFAULT))?;
5391 let offset = address - aligned;
5392 let pair = pair.to_ne_bytes();
5393 bytes.copy_from_slice(&pair[offset..offset + 4]);
5394 Ok(i32::from_ne_bytes(bytes))
5395}
5396
5397fn mapping_is_writable(pid: i32, address: usize) -> bool {
5401 mapping_permissions(pid, address).is_some_and(|perms| perms[1] == b'w')
5402}
5403
5404fn mapping_permissions(pid: i32, address: usize) -> Option<[u8; 4]> {
5408 let maps = std::fs::read_to_string(format!("/proc/{pid}/maps")).ok()?;
5409 maps.lines().find_map(|line| {
5410 let mut fields = line.split_whitespace();
5411 let (Some(range), Some(perms)) = (fields.next(), fields.next()) else {
5412 return None;
5413 };
5414 let (start, end) = range.split_once('-')?;
5415 let (Ok(start), Ok(end)) = (
5416 usize::from_str_radix(start, 16),
5417 usize::from_str_radix(end, 16),
5418 ) else {
5419 return None;
5420 };
5421 if !(start..end).contains(&address) {
5422 return None;
5423 }
5424 perms.as_bytes().get(..4)?.try_into().ok()
5425 })
5426}
5427
5428fn read_user_timespec<G: Guest<Detcore<T>>, T: RecordOrReplay>(
5436 guest: &mut G,
5437 address: usize,
5438) -> Result<Timespec, Error> {
5439 let size = std::mem::size_of::<Timespec>();
5440 let last = address.checked_add(size - 1).ok_or(Errno::EFAULT)?;
5441 if last > user_ptr_max() {
5442 return Err(Error::Errno(Errno::EFAULT));
5443 }
5444 if !bundled_signal_facts::host_task_reads_enabled(&guest.config().backend) {
5445 let mut bytes = [0u8; std::mem::size_of::<Timespec>()];
5448 guest
5449 .memory()
5450 .read_exact_with_user_access(
5451 Addr::<u8>::from_raw(address).ok_or(Errno::EFAULT)?,
5452 &mut bytes,
5453 )
5454 .map_err(|_| Error::Errno(Errno::EFAULT))?;
5455 let field = |at: usize| -> i64 {
5456 let mut raw = [0u8; 8];
5457 raw.copy_from_slice(&bytes[at..at + 8]);
5458 i64::from_ne_bytes(raw)
5459 };
5460 return Ok(Timespec {
5461 tv_sec: field(0) as libc::time_t,
5462 tv_nsec: field(8) as libc::c_long,
5463 });
5464 }
5465 let page = 4096;
5467 let pid = guest.pid().as_raw();
5468 let mut cursor = address & !(page - 1);
5469 while cursor <= last {
5470 let probe = cursor.max(address);
5471 let readable = mapping_permissions(pid, probe)
5472 .is_some_and(|perms| perms[0] == b'r' || perms[1] == b'w');
5473 if !readable {
5474 return Err(Error::Errno(Errno::EFAULT));
5475 }
5476 cursor += page;
5477 }
5478 let start = address & !7;
5482 let mut bytes = Vec::with_capacity(last + 1 - start);
5483 let mut word = start;
5484 while word <= last {
5485 let value: u64 = guest
5486 .memory()
5487 .read_value(Addr::<u64>::from_raw(word).ok_or(Errno::EFAULT)?)
5488 .map_err(|_| Error::Errno(Errno::EFAULT))?;
5489 bytes.extend_from_slice(&value.to_ne_bytes());
5490 word += 8;
5491 }
5492 let field = |at: usize| -> i64 {
5493 let mut raw = [0u8; 8];
5494 raw.copy_from_slice(&bytes[address - start + at..address - start + at + 8]);
5495 i64::from_ne_bytes(raw)
5496 };
5497 Ok(Timespec {
5498 tv_sec: field(0) as libc::time_t,
5499 tv_nsec: field(8) as libc::c_long,
5500 })
5501}
5502
5503const FUTEX_OP_SET: u32 = 0;
5505const FUTEX_OP_ADD: u32 = 1;
5506const FUTEX_OP_OR: u32 = 2;
5507const FUTEX_OP_ANDN: u32 = 3;
5508const FUTEX_OP_XOR: u32 = 4;
5509const FUTEX_OP_OPARG_SHIFT: u32 = 8;
5510const FUTEX_OP_CMP_EQ: u32 = 0;
5511const FUTEX_OP_CMP_NE: u32 = 1;
5512const FUTEX_OP_CMP_LT: u32 = 2;
5513const FUTEX_OP_CMP_GE: u32 = 3;
5514const FUTEX_OP_CMP_LE: u32 = 4;
5515const FUTEX_OP_CMP_GT: u32 = 5;
5516
5517#[derive(Debug, Clone, Copy, PartialEq, Eq)]
5520pub(crate) struct FutexWakeOp {
5521 op: u32,
5522 cmp: u32,
5523 oparg: i32,
5524 cmparg: i32,
5525}
5526
5527impl FutexWakeOp {
5528 pub(crate) fn decode(encoded: u32) -> Self {
5529 let sign_extend_12 = |v: u32| ((v << 20) as i32) >> 20;
5530 let op = (encoded & 0x7000_0000) >> 28;
5531 let cmp = (encoded & 0x0f00_0000) >> 24;
5532 let mut oparg = sign_extend_12((encoded & 0x00ff_f000) >> 12);
5533 let cmparg = sign_extend_12(encoded & 0x0000_0fff);
5534 if encoded & (FUTEX_OP_OPARG_SHIFT << 28) != 0 {
5535 if !(0..=31).contains(&oparg) {
5537 oparg &= 31;
5538 }
5539 oparg = 1i32.wrapping_shl(oparg as u32);
5540 }
5541 FutexWakeOp {
5542 op,
5543 cmp,
5544 oparg,
5545 cmparg,
5546 }
5547 }
5548
5549 pub(crate) fn has_known_operation(&self) -> bool {
5552 self.apply(0).is_some()
5553 }
5554
5555 pub(crate) fn apply(&self, old: i32) -> Option<i32> {
5557 Some(match self.op {
5558 FUTEX_OP_SET => self.oparg,
5559 FUTEX_OP_ADD => old.wrapping_add(self.oparg),
5560 FUTEX_OP_OR => old | self.oparg,
5561 FUTEX_OP_ANDN => old & !self.oparg,
5562 FUTEX_OP_XOR => old ^ self.oparg,
5563 _ => return None,
5564 })
5565 }
5566
5567 pub(crate) fn compare(&self, old: i32) -> Option<bool> {
5570 Some(match self.cmp {
5571 FUTEX_OP_CMP_EQ => old == self.cmparg,
5572 FUTEX_OP_CMP_NE => old != self.cmparg,
5573 FUTEX_OP_CMP_LT => old < self.cmparg,
5574 FUTEX_OP_CMP_GE => old >= self.cmparg,
5575 FUTEX_OP_CMP_LE => old <= self.cmparg,
5576 FUTEX_OP_CMP_GT => old > self.cmparg,
5577 _ => return None,
5578 })
5579 }
5580}
5581
5582#[cfg(test)]
5583mod tests {
5584
5585 #[test]
5591 fn a_discarded_copy_is_left_out_even_when_committed() {
5592 let chld = kernel_sigset_bit(libc::SIGCHLD);
5593 let usr1 = kernel_sigset_bit(libc::SIGUSR1);
5594 let state = KernelSignalState {
5595 pending: chld | usr1,
5596 thread_pending: chld,
5597 shared_pending: usr1,
5598 ..Default::default()
5599 };
5600 assert_eq!(with_kept_copies(&state, chld, 0, chld | usr1, chld), usr1);
5601 assert_eq!(with_kept_copies(&state, 0, usr1, chld | usr1, usr1), chld);
5602 assert_eq!(with_kept_copies(&state, 0, 0, chld | usr1, 0), chld | usr1);
5603 }
5604 use std::io::Read;
5605 use std::io::Seek;
5606 use std::os::fd::AsRawFd;
5607
5608 use reverie::GlobalRPC;
5609 use reverie::GlobalTool;
5610 use reverie::Tid;
5611 use reverie::Tool;
5612
5613 use super::*;
5614
5615 #[test]
5619 fn owner_death_path_is_tied_to_the_backends_that_have_its_properties() {
5620 let path = |backend: reverie::BackendCapabilities| {
5621 let mut cfg = Config::default().with_backend(|capabilities| *capabilities = backend);
5622 cfg.sequentialize_threads = true;
5623 cfg.debug_futex_mode = BlockingMode::Precise;
5624 owner_death_path(&cfg)
5625 };
5626 assert_eq!(
5627 path(reverie::BackendCapabilities::PTRACE),
5628 Some(OwnerDeathPath::Kernel)
5629 );
5630 assert_eq!(
5631 path(reverie::BackendCapabilities::DBT),
5632 Some(OwnerDeathPath::Barrier)
5633 );
5634 for backend in [
5635 reverie::BackendCapabilities::KVM,
5636 reverie::BackendCapabilities::SABRE,
5637 reverie::BackendCapabilities::LITEINST_IN_GUEST,
5638 ] {
5639 assert_eq!(path(backend), None, "{backend:?}");
5640 }
5641 }
5642
5643 #[test]
5649 fn each_configuration_takes_its_sched_yield_route() {
5650 let path = || Some(std::path::PathBuf::from("record.json"));
5651 let cases = [
5652 (Config::default(), SchedYieldRoute::EndTimeslice),
5653 (
5655 Config {
5656 ..Config::default()
5657 }
5658 .with_backend(|backend| {
5659 backend.delivers_preemption_timer_events = true;
5660 backend.runs_guest_code_between_injections = false;
5661 }),
5662 SchedYieldRoute::EndTimeslice,
5663 ),
5664 (
5665 Config {
5666 chaos: true,
5667 replay_schedule_from: path(),
5668 ..Config::default()
5669 }
5670 .with_backend(|backend| {
5671 backend.delivers_preemption_timer_events = true;
5672 backend.runs_guest_code_between_injections = false;
5673 }),
5674 SchedYieldRoute::WeakYield,
5675 ),
5676 (
5677 Config {
5678 chaos: true,
5679 ..Config::default()
5680 }
5681 .with_backend(|backend| {
5682 backend.delivers_preemption_timer_events = true;
5683 backend.runs_guest_code_between_injections = false;
5684 }),
5685 SchedYieldRoute::ChaosYieldEpoch,
5686 ),
5687 (
5688 Config {
5689 chaos: true,
5690 sched_heuristic: SchedHeuristic::Random,
5691 ..Config::default()
5692 }
5693 .with_backend(|backend| {
5694 backend.delivers_preemption_timer_events = true;
5695 backend.runs_guest_code_between_injections = false;
5696 }),
5697 SchedYieldRoute::WeakYield,
5698 ),
5699 (
5700 Config {
5701 chaos: true,
5702 sched_heuristic: SchedHeuristic::StickyRandom,
5703 ..Config::default()
5704 }
5705 .with_backend(|backend| {
5706 backend.delivers_preemption_timer_events = true;
5707 backend.runs_guest_code_between_injections = false;
5708 }),
5709 SchedYieldRoute::ChaosYieldEpoch,
5710 ),
5711 (
5712 Config {
5713 chaos: true,
5714 sched_heuristic: SchedHeuristic::ConnectBind,
5715 ..Config::default()
5716 }
5717 .with_backend(|backend| {
5718 backend.delivers_preemption_timer_events = true;
5719 backend.runs_guest_code_between_injections = false;
5720 }),
5721 SchedYieldRoute::ChaosYieldEpoch,
5722 ),
5723 (
5724 Config {
5725 chaos: true,
5726 max_timeslice: None,
5727 sched_heuristic: SchedHeuristic::Random,
5728 ..Config::default()
5729 },
5730 SchedYieldRoute::ChaosReprioritize,
5731 ),
5732 (
5734 Config {
5735 chaos: true,
5736 ..Config::default()
5737 }
5738 .with_backend(|backend| backend.delivers_preemption_timer_events = false),
5739 SchedYieldRoute::WeakYield,
5740 ),
5741 (
5742 Config {
5743 chaos: true,
5744 max_timeslice: None,
5745 ..Config::default()
5746 },
5747 SchedYieldRoute::ChaosReprioritize,
5748 ),
5749 (
5750 Config {
5751 chaos: true,
5752 replay_preemptions_from: path(),
5753 ..Config::default()
5754 }
5755 .with_backend(|backend| {
5756 backend.delivers_preemption_timer_events = true;
5757 backend.runs_guest_code_between_injections = false;
5758 }),
5759 SchedYieldRoute::ChaosYieldEpoch,
5760 ),
5761 (
5762 Config {
5763 chaos: true,
5764 replay_schedule_from: path(),
5765 ..Config::default()
5766 },
5767 SchedYieldRoute::WeakYield,
5768 ),
5769 (
5770 Config {
5771 replay_schedule_from: path(),
5772 ..Config::default()
5773 },
5774 SchedYieldRoute::WeakYield,
5775 ),
5776 (
5777 Config {
5778 replay_preemptions_from: path(),
5779 ..Config::default()
5780 },
5781 SchedYieldRoute::ReplayStrongYield,
5782 ),
5783 ];
5784 for (cfg, route) in cases {
5785 assert_eq!(
5786 sched_yield_route(&cfg),
5787 route,
5788 "chaos={} timer delivered={} heuristic={:?} max_timeslice={:?} preemptions={:?} schedule={:?}",
5789 cfg.chaos,
5790 cfg.backend.delivers_preemption_timer_events,
5791 cfg.sched_heuristic,
5792 cfg.max_timeslice,
5793 cfg.replay_preemptions_from,
5794 cfg.replay_schedule_from
5795 );
5796 }
5797 }
5798
5799 #[test]
5805 fn a_thread_reported_under_another_pid_is_read_and_alive() {
5806 let tid = Pid::from_raw(unsafe { libc::syscall(libc::SYS_gettid) } as i32);
5807 let wrong = Pid::from_raw(unsafe { libc::getppid() });
5808 assert_ne!(wrong, tid);
5809 assert!(read_kernel_signal_state(wrong, tid).is_err());
5810 assert!(read_thread_signal_state(wrong, tid).is_ok());
5811 assert!(!thread_is_gone(wrong, tid));
5812 assert!(read_thread_wait_signal_state(wrong, tid).is_ok());
5813 }
5814
5815 #[test]
5818 fn host_signal_state_reads_are_refused_only_where_guest_tids_are_not_host_tasks() {
5819 assert!(refuses_host_signal_state_reads(&BackendCapabilities::KVM));
5820 for backend in [
5821 BackendCapabilities::PTRACE,
5822 BackendCapabilities::E9PATCH,
5823 BackendCapabilities::SABRE,
5824 BackendCapabilities::DBT,
5825 BackendCapabilities::LITEINST_IN_GUEST,
5826 ] {
5827 assert!(!refuses_host_signal_state_reads(&backend));
5828 }
5829 }
5830
5831 #[test]
5835 fn a_latched_refusal_never_reads_a_host_task_signal_state() {
5836 let pid = Pid::from_raw(unsafe { libc::getpid() });
5837 let tid = Pid::from_raw(unsafe { libc::syscall(libc::SYS_gettid) } as i32);
5838 refuse_host_signal_state_reads(&BackendCapabilities::PTRACE);
5839 assert!(!host_signal_state_reads_refused());
5840 assert!(read_kernel_signal_state(pid, tid).is_ok());
5841 refuse_host_signal_state_reads(&BackendCapabilities::KVM);
5842 assert!(host_signal_state_reads_refused());
5843 assert_eq!(read_kernel_signal_state(pid, tid), Err(Errno::ENOSYS));
5844 assert_eq!(read_thread_signal_state(pid, tid), Err(Errno::ENOSYS));
5845 }
5846 use crate::config::Config;
5847 use crate::tool_global::GlobalRequest;
5848 use crate::tool_global::GlobalState;
5849 use crate::types::MmId;
5850
5851 #[test]
5856 fn a_child_exit_signal_other_than_sigchld_is_host_timed_for_its_creator() {
5857 let usr1 = 1_u64 << (libc::SIGUSR1 - 1);
5858 let none = CloneFlags::empty();
5859 assert_eq!(clone_host_timed_signals(none, libc::SIGUSR1), usr1);
5860 assert_eq!(
5861 clone_host_timed_signals(CloneFlags::CLONE_VFORK, libc::SIGUSR1),
5862 usr1
5863 );
5864 assert_eq!(clone_host_timed_signals(none, libc::SIGCHLD), 0);
5865 assert_eq!(clone_host_timed_signals(none, 0), 0);
5866 assert_eq!(clone_host_timed_signals(none, 65), 0);
5867 let thread = CloneFlags::CLONE_THREAD | CloneFlags::CLONE_SIGHAND | CloneFlags::CLONE_VM;
5868 assert_eq!(clone_host_timed_signals(thread, libc::SIGUSR1), 0);
5869 assert_eq!(
5870 clone_host_timed_signals(CloneFlags::CLONE_PARENT, libc::SIGUSR1),
5871 0
5872 );
5873 }
5874
5875 struct FailedExecStack;
5876 struct FailedExecStackGuard;
5877
5878 impl Drop for FailedExecStackGuard {
5879 fn drop(&mut self) {}
5880 }
5881
5882 impl reverie::Stack for FailedExecStack {
5883 type StackGuard = FailedExecStackGuard;
5884
5885 fn size(&self) -> usize {
5886 panic!("failed exec must not use the guest stack")
5887 }
5888 fn capacity(&self) -> usize {
5889 panic!("failed exec must not use the guest stack")
5890 }
5891 fn push<'stack, T>(&mut self, _: T) -> Addr<'stack, T> {
5892 panic!("failed exec must not use the guest stack")
5893 }
5894 fn reserve<'stack, T>(&mut self) -> AddrMut<'stack, T> {
5895 panic!("failed exec must not use the guest stack")
5896 }
5897 fn commit(self) -> Result<Self::StackGuard, Errno> {
5898 panic!("failed exec must not use the guest stack")
5899 }
5900 }
5901
5902 struct FailedExecGuest<'a> {
5906 config: &'a Config,
5907 global: &'a GlobalState,
5908 thread: crate::ThreadState<()>,
5909 sender: Tid,
5910 process: Tid,
5911 old_mm: MmId,
5912 errno: Errno,
5913 backend_refuses: bool,
5914 refusal: Option<reverie::UnsupportedRefusal>,
5915 refusal_takes: usize,
5916 injections: usize,
5917 requests: Mutex<Vec<GlobalRequest>>,
5918 }
5919
5920 #[reverie::tool]
5921 impl GlobalRPC<GlobalState> for FailedExecGuest<'_> {
5922 async fn send_rpc(
5923 &self,
5924 message: <GlobalState as GlobalTool>::Request,
5925 ) -> <GlobalState as GlobalTool>::Response {
5926 assert_eq!(message.1, self.old_mm, "RPC follows restored exec identity");
5927 self.requests.lock().unwrap().push(message.2.clone());
5928 self.global.receive_rpc(self.sender, message).await
5929 }
5930 fn config(&self) -> &Config {
5931 self.config
5932 }
5933 }
5934
5935 #[reverie::tool]
5936 impl Guest<Detcore> for FailedExecGuest<'_> {
5937 type Memory = reverie::syscalls::LocalMemory;
5938 type Stack = FailedExecStack;
5939
5940 fn tid(&self) -> Tid {
5941 self.sender
5942 }
5943 fn pid(&self) -> Tid {
5944 self.process
5945 }
5946 fn ppid(&self) -> Option<Tid> {
5947 None
5948 }
5949 fn memory(&self) -> Self::Memory {
5950 panic!("failed exec rollback must not read guest memory")
5951 }
5952 fn thread_state(&self) -> &crate::ThreadState<()> {
5953 &self.thread
5954 }
5955 fn thread_state_mut(&mut self) -> &mut crate::ThreadState<()> {
5956 &mut self.thread
5957 }
5958 async fn regs(&mut self) -> libc::user_regs_struct {
5959 panic!("failed exec rollback must not read registers")
5960 }
5961 async fn stack(&mut self) -> Self::Stack {
5962 panic!("failed exec rollback must not use a guest stack")
5963 }
5964 async fn daemonize(&mut self) {
5965 panic!("failed exec rollback must not daemonize")
5966 }
5967 async fn inject<S: SyscallInfo>(&mut self, call: S) -> Result<i64, Errno> {
5968 assert_eq!(call.number(), syscalls::Sysno::execveat);
5969 assert_eq!(
5970 self.thread.mm_id,
5971 self.old_mm.for_exec(self.thread.detpid.unwrap())
5972 );
5973 assert_eq!(self.thread.robust_list_head, None);
5974 self.injections += 1;
5975 self.refusal = self.backend_refuses.then(|| {
5977 reverie::UnsupportedRefusal::new(
5978 reverie::UnsupportedOperation::NonLeaderExec,
5979 self.errno,
5980 "KVM nonleader exec is unsupported",
5981 )
5982 });
5983 Err(self.errno)
5984 }
5985 fn take_unsupported_refusal(&mut self) -> Option<reverie::UnsupportedRefusal> {
5986 assert_eq!(
5987 self.thread.mm_id,
5988 self.old_mm.for_exec(self.thread.detpid.unwrap()),
5989 "the refusal is taken before the failed exec is rolled back"
5990 );
5991 self.refusal_takes += 1;
5992 self.refusal.take()
5993 }
5994 async fn tail_inject<S: SyscallInfo>(&mut self, _: S) -> reverie::Never {
5995 panic!("failed exec must not retire a live guest")
5996 }
5997 fn set_timer(&mut self, _: reverie::TimerSchedule) -> Result<(), Error> {
5998 panic!("failed exec rollback must not replace the timer")
5999 }
6000 fn set_timer_precise(&mut self, _: reverie::TimerSchedule) -> Result<(), Error> {
6001 panic!("failed exec rollback must not replace the timer")
6002 }
6003 fn read_clock(&mut self) -> Result<u64, Error> {
6004 panic!("failed exec rollback must not sample the clock")
6005 }
6006 }
6007
6008 #[tokio::test]
6009 async fn backend_exec_refusal_preserves_failed_exec_rollback_and_policy() {
6010 let process = DetPid::from_raw(17);
6011 let worker = DetTid::from_raw(18);
6012 for (kvm_behaviours, caller, errno, backend_refuses, fail_closed, refused, reported) in [
6021 (true, worker, Errno::ENOSYS, true, true, true, false),
6022 (true, worker, Errno::ENOSYS, true, false, false, true),
6023 (true, worker, Errno::ENOENT, false, true, false, false),
6024 (true, worker, Errno::ENOEXEC, false, true, false, false),
6025 (true, worker, Errno::EFAULT, false, true, false, false),
6026 (true, worker, Errno::EACCES, false, true, false, false),
6027 (true, worker, Errno::EOPNOTSUPP, false, true, false, false),
6028 (true, process, Errno::ENOSYS, false, true, false, false),
6029 (false, worker, Errno::ENOSYS, false, true, false, false),
6030 (true, worker, Errno::ENOSYS, false, true, false, false),
6031 ] {
6032 let mut report = tempfile::tempfile().unwrap();
6033 let config = Config {
6034 sequentialize_threads: false,
6035 panic_on_unsupported_syscalls: fail_closed,
6036 exit_on_unsupported_syscall: true,
6037 shutdown_on_unsupported_syscall: false,
6038 unsupported_syscall_report_fd: Some(report.as_raw_fd()),
6039 ..Config::default().with_backend(|backend| {
6040 if kvm_behaviours {
6041 backend.provides_process_signal_control = true;
6046 backend.emulates_child_waits = true;
6047 }
6048 })
6049 };
6050 let global = GlobalState::init_global_state(&config).await;
6051 let tool = Detcore::new(Tid::from_raw(process.as_raw()), &config);
6052 let mut thread = crate::ThreadState::new(caller, &config, ());
6053 thread.detpid = Some(process);
6054 thread.mm_id = MmId::initial(process);
6055 thread.record_robust_list_head(Some(0x12340));
6056 thread.thread_logical_time.add_syscall_with_cost(123);
6057 let old_time = thread.thread_logical_time.as_nanos();
6058 let old_files = Arc::clone(&thread.file_metadata);
6059 let old_memory = Arc::clone(&thread.memory_metadata);
6060 let old_mm = thread.mm_id;
6061 let mut guest = FailedExecGuest {
6062 config: &config,
6063 global: &global,
6064 thread,
6065 sender: Tid::from_raw(caller.as_raw()),
6066 process: Tid::from_raw(process.as_raw()),
6067 old_mm,
6068 errno,
6069 backend_refuses,
6070 refusal: None,
6071 refusal_takes: 0,
6072 injections: 0,
6073 requests: Mutex::new(Vec::new()),
6074 };
6075 let result = tool
6076 .handle_execveat(&mut guest, syscalls::Execveat::new())
6077 .await;
6078 match result {
6079 Err(Error::Tool(error)) if refused => assert_eq!(
6080 error
6081 .downcast_ref::<crate::UnsupportedSyscallError>()
6082 .unwrap()
6083 .0,
6084 syscalls::Sysno::execveat
6085 ),
6086 Err(Error::Errno(actual)) if !refused => assert_eq!(actual, errno),
6087 result => panic!("wrong failed-exec policy: {result:?}"),
6088 }
6089 assert_eq!(guest.injections, 1, "backend preflight must run first");
6090 assert_eq!(guest.refusal_takes, 1, "the refusal must be asked for once");
6091 assert_eq!(guest.refusal, None, "a reported refusal must be taken");
6092 assert_eq!(guest.thread.dettid, caller);
6093 assert_eq!(guest.thread.detpid, Some(process));
6094 assert_eq!(guest.thread.mm_id, old_mm);
6095 assert_eq!(guest.thread.robust_list_head, Some(0x12340));
6096 assert_eq!(guest.thread.thread_logical_time.as_nanos(), old_time);
6097 assert!(Arc::ptr_eq(&guest.thread.file_metadata, &old_files));
6098 assert!(Arc::ptr_eq(&guest.thread.memory_metadata, &old_memory));
6099 let requests = guest.requests.lock().unwrap();
6100 assert!(matches!(requests[0], GlobalRequest::PrepareExec(..)));
6101 assert!(matches!(requests[1], GlobalRequest::CancelExec(..)));
6102 assert_eq!(requests.len(), if reported { 3 } else { 2 });
6103 if reported {
6104 assert!(
6105 matches!(&requests[2], GlobalRequest::ReportUnsupportedSyscall(name) if name == "execveat")
6106 );
6107 }
6108 report.rewind().unwrap();
6109 let mut aggregate = String::new();
6110 report.read_to_string(&mut aggregate).unwrap();
6111 assert_eq!(aggregate, if reported { "execveat\n" } else { "" });
6112 }
6113 }
6114
6115 struct FailedCloneGuest<'a> {
6119 config: &'a Config,
6120 global: &'a GlobalState,
6121 thread: crate::ThreadState<()>,
6122 sender: Tid,
6123 errno: Errno,
6124 backend_refuses: bool,
6125 refusal: Option<reverie::UnsupportedRefusal>,
6126 refusal_takes: usize,
6127 injections: usize,
6128 requests: Mutex<Vec<GlobalRequest>>,
6129 }
6130
6131 #[reverie::tool]
6132 impl GlobalRPC<GlobalState> for FailedCloneGuest<'_> {
6133 async fn send_rpc(
6134 &self,
6135 message: <GlobalState as GlobalTool>::Request,
6136 ) -> <GlobalState as GlobalTool>::Response {
6137 self.requests.lock().unwrap().push(message.2.clone());
6138 self.global.receive_rpc(self.sender, message).await
6139 }
6140 fn config(&self) -> &Config {
6141 self.config
6142 }
6143 }
6144
6145 #[reverie::tool]
6146 impl Guest<Detcore> for FailedCloneGuest<'_> {
6147 type Memory = reverie::syscalls::LocalMemory;
6148 type Stack = FailedExecStack;
6149
6150 fn tid(&self) -> Tid {
6151 self.sender
6152 }
6153 fn pid(&self) -> Tid {
6154 self.sender
6155 }
6156 fn ppid(&self) -> Option<Tid> {
6157 None
6158 }
6159 fn memory(&self) -> Self::Memory {
6160 reverie::syscalls::LocalMemory::new()
6161 }
6162 fn thread_state(&self) -> &crate::ThreadState<()> {
6163 &self.thread
6164 }
6165 fn thread_state_mut(&mut self) -> &mut crate::ThreadState<()> {
6166 &mut self.thread
6167 }
6168 async fn regs(&mut self) -> libc::user_regs_struct {
6169 panic!("a failed clone must not read registers")
6170 }
6171 async fn stack(&mut self) -> Self::Stack {
6172 panic!("a failed clone must not use a guest stack")
6173 }
6174 async fn daemonize(&mut self) {
6175 panic!("a failed clone must not daemonize")
6176 }
6177 async fn inject<S: SyscallInfo>(&mut self, call: S) -> Result<i64, Errno> {
6178 assert_eq!(call.number(), syscalls::Sysno::clone);
6179 self.injections += 1;
6180 self.refusal = self.backend_refuses.then(|| {
6181 reverie::UnsupportedRefusal::new(
6182 reverie::UnsupportedOperation::NativeExec,
6183 self.errno,
6184 "this backend cannot create a thread",
6185 )
6186 });
6187 Err(self.errno)
6188 }
6189 fn take_unsupported_refusal(&mut self) -> Option<reverie::UnsupportedRefusal> {
6190 self.refusal_takes += 1;
6191 self.refusal.take()
6192 }
6193 async fn tail_inject<S: SyscallInfo>(&mut self, _: S) -> reverie::Never {
6194 panic!("a failed clone must not retire a live guest")
6195 }
6196 fn set_timer(&mut self, _: reverie::TimerSchedule) -> Result<(), Error> {
6197 panic!("a failed clone must not replace the timer")
6198 }
6199 fn set_timer_precise(&mut self, _: reverie::TimerSchedule) -> Result<(), Error> {
6200 panic!("a failed clone must not replace the timer")
6201 }
6202 fn read_clock(&mut self) -> Result<u64, Error> {
6203 panic!("a failed clone must not sample the clock")
6204 }
6205 }
6206
6207 #[tokio::test]
6211 async fn backend_clone_refusal_follows_the_unsupported_operation_policy() {
6212 let process = DetPid::from_raw(23);
6213 for (errno, backend_refuses, fail_closed, refused, reported) in [
6214 (Errno::EOPNOTSUPP, true, true, true, false),
6215 (Errno::EOPNOTSUPP, true, false, false, true),
6216 (Errno::EAGAIN, false, true, false, false),
6217 (Errno::EOPNOTSUPP, false, true, false, false),
6218 ] {
6219 let mut report = tempfile::tempfile().unwrap();
6220 let config = Config {
6221 sequentialize_threads: false,
6222 panic_on_unsupported_syscalls: fail_closed,
6223 exit_on_unsupported_syscall: true,
6224 shutdown_on_unsupported_syscall: false,
6225 unsupported_syscall_report_fd: Some(report.as_raw_fd()),
6226 ..Config::default()
6227 };
6228 let global = GlobalState::init_global_state(&config).await;
6229 let tool = Detcore::new(Tid::from_raw(process.as_raw()), &config);
6230 let mut thread = crate::ThreadState::new(process, &config, ());
6231 thread.detpid = Some(process);
6232 let mut guest = FailedCloneGuest {
6233 config: &config,
6234 global: &global,
6235 thread,
6236 sender: Tid::from_raw(process.as_raw()),
6237 errno,
6238 backend_refuses,
6239 refusal: None,
6240 refusal_takes: 0,
6241 injections: 0,
6242 requests: Mutex::new(Vec::new()),
6243 };
6244 let flags = (libc::CLONE_VM
6245 | libc::CLONE_FS
6246 | libc::CLONE_FILES
6247 | libc::CLONE_SIGHAND
6248 | libc::CLONE_THREAD
6249 | libc::CLONE_SYSVSEM) as u64;
6250 let clone = syscalls::Clone::new()
6251 .with_flags(nix::sched::CloneFlags::from_bits_truncate(flags as _));
6252 let result = tool
6253 .handle_clone_family(&mut guest, syscalls::family::CloneFamily::Clone(clone))
6254 .await;
6255 match result {
6256 Err(Error::Tool(error)) if refused => assert_eq!(
6257 error
6258 .downcast_ref::<crate::UnsupportedSyscallError>()
6259 .unwrap()
6260 .0,
6261 syscalls::Sysno::clone
6262 ),
6263 Err(Error::Errno(actual)) if !refused => assert_eq!(actual, errno),
6264 result => panic!("wrong failed-clone policy: {result:?}"),
6265 }
6266 assert_eq!(guest.injections, 1);
6267 assert_eq!(guest.refusal_takes, 1, "the refusal must be asked for once");
6268 assert_eq!(guest.refusal, None, "a reported refusal must be taken");
6269 assert_eq!(guest.thread.clone_flags, None);
6270 let requests = guest.requests.lock().unwrap();
6271 assert_eq!(
6272 requests
6273 .iter()
6274 .filter(|request| matches!(request, GlobalRequest::ReportUnsupportedSyscall(name) if name == "clone"))
6275 .count(),
6276 usize::from(reported)
6277 );
6278 report.rewind().unwrap();
6279 let mut aggregate = String::new();
6280 report.read_to_string(&mut aggregate).unwrap();
6281 assert_eq!(aggregate, if reported { "clone\n" } else { "" });
6282 }
6283 }
6284
6285 fn bits(signals: &[i32]) -> KernelSigset {
6286 signals
6287 .iter()
6288 .fold(0, |set, &signal| set | kernel_sigset_bit(signal))
6289 }
6290
6291 #[test]
6292 fn a_precise_futex_wait_holds_a_committed_signal_only_if_a_host_timed_source_can_post_it() {
6293 let chld = kernel_sigset_bit(libc::SIGCHLD);
6294 let usr1 = kernel_sigset_bit(libc::SIGUSR1);
6295 assert_eq!(futex_wait_held_after_wake(0, 0), chld);
6297 assert_eq!(futex_wait_held_after_wake(usr1, 0), chld | usr1);
6298 assert_eq!(futex_wait_held_after_wake(0, chld), 0);
6300 assert_eq!(futex_wait_held_after_wake(usr1, chld), usr1);
6301 assert_eq!(futex_wait_held_after_wake(chld, chld), chld);
6304 assert_eq!(futex_wait_held_after_wake(usr1, usr1 | chld), usr1);
6305 }
6306
6307 #[test]
6308 fn kernel_signal_state_parses_proc_status() {
6309 let status = "Name:\tguest\nSigQ:\t1/1024\nSigPnd:\t0000000000000200\n\
6310 ShdPnd:\t0000000000000400\nSigBlk:\t0000000000000800\n\
6311 SigIgn:\t0000000000001000\nSigCgt:\t0000000000000400\n";
6312 assert_eq!(
6313 KernelSignalState::parse(status),
6314 Some(KernelSignalState {
6315 pending: bits(&[libc::SIGUSR1, libc::SIGSEGV]),
6316 thread_pending: bits(&[libc::SIGUSR1]),
6317 shared_pending: bits(&[libc::SIGSEGV]),
6318 blocked: bits(&[libc::SIGUSR2]),
6319 ignored: bits(&[libc::SIGPIPE]),
6320 caught: bits(&[libc::SIGSEGV]),
6321 })
6322 );
6323 assert_eq!(
6325 KernelSignalState::parse("SigPnd:\t0\nShdPnd:\t0\nSigBlk:\t0\nSigIgn:\t0\n"),
6326 None
6327 );
6328 assert_eq!(
6329 KernelSignalState::parse(
6330 "SigPnd:\tzz\nShdPnd:\t0\nSigBlk:\t0\nSigIgn:\t0\nSigCgt:\t0\n"
6331 ),
6332 None
6333 );
6334 }
6335
6336 #[test]
6337 fn only_unblocked_caught_or_fatal_signals_interrupt_a_wait() {
6338 let state = KernelSignalState {
6339 pending: bits(&[
6340 libc::SIGUSR1,
6341 libc::SIGUSR2,
6342 libc::SIGPIPE,
6343 libc::SIGTERM,
6344 libc::SIGCHLD,
6345 libc::SIGWINCH,
6346 libc::SIGURG,
6347 libc::SIGCONT,
6348 ]),
6349 blocked: bits(&[libc::SIGUSR2]),
6350 ignored: bits(&[libc::SIGPIPE]),
6351 caught: bits(&[libc::SIGUSR1, libc::SIGUSR2, libc::SIGWINCH]),
6352 ..Default::default()
6353 };
6354 assert_eq!(
6357 state.pending_interrupting(state.blocked, false),
6358 bits(&[libc::SIGUSR1, libc::SIGWINCH, libc::SIGTERM])
6359 );
6360 assert_eq!(
6362 state.pending_interrupting(0, false),
6363 bits(&[libc::SIGUSR1, libc::SIGUSR2, libc::SIGWINCH, libc::SIGTERM])
6364 );
6365 let interrupting = state.interrupting(state.blocked);
6366 assert_ne!(interrupting & kernel_sigset_bit(libc::SIGKILL), 0);
6367 assert_ne!(interrupting & kernel_sigset_bit(libc::SIGSTOP), 0);
6368 assert_eq!(
6369 interrupting & kernel_sigset_bit(reverie::PERF_EVENT_SIGNAL as i32),
6370 0
6371 );
6372 assert_eq!(kernel_sigset_bit(0), 0);
6373 assert_eq!(kernel_sigset_bit(65), 0);
6374 }
6375
6376 #[test]
6383 fn a_rearming_wait_is_not_ended_by_a_default_job_control_stop() {
6384 let stops = bits(&[libc::SIGTSTP, libc::SIGTTIN, libc::SIGTTOU]);
6385 let state = KernelSignalState {
6386 pending: stops | bits(&[libc::SIGSTOP, libc::SIGTERM]),
6387 ..Default::default()
6388 };
6389 assert_eq!(state.default_job_control_stops(), stops);
6390 assert_eq!(state.pending_interrupting(0, false), state.pending);
6391 assert_eq!(
6392 state.pending_interrupting(0, true),
6393 bits(&[libc::SIGSTOP, libc::SIGTERM])
6394 );
6395 let rearming = state.interrupting_wait(0, true);
6396 assert_eq!(rearming & stops, 0);
6397 assert_eq!(rearming, state.interrupting(0) & !stops);
6398
6399 let state = KernelSignalState {
6402 pending: stops,
6403 caught: bits(&[libc::SIGTSTP]),
6404 ignored: bits(&[libc::SIGTTIN]),
6405 ..Default::default()
6406 };
6407 assert_eq!(state.default_job_control_stops(), bits(&[libc::SIGTTOU]));
6408 assert_eq!(state.pending_interrupting(0, true), bits(&[libc::SIGTSTP]));
6409 assert_eq!(
6410 state.pending_interrupting(0, false),
6411 bits(&[libc::SIGTSTP, libc::SIGTTOU])
6412 );
6413 assert_eq!(state.pending_interrupting(bits(&[libc::SIGTSTP]), true), 0);
6415 }
6416
6417 #[test]
6418 fn kernel_blocked_mask_preserves_libc_signal_membership() {
6419 let mask = blocked_signal_mask();
6420 let mut libc_mask: libc::sigset_t = unsafe { std::mem::zeroed() };
6421 unsafe {
6422 libc::sigfillset(&mut libc_mask);
6423 libc::sigdelset(&mut libc_mask, reverie::PERF_EVENT_SIGNAL as i32);
6424 }
6425 for raw_signal in 1..=KernelSigset::BITS as i32 {
6426 assert_eq!(
6427 signal_is_blocked(&mask, SigWrapper(raw_signal)),
6428 unsafe { libc::sigismember(&libc_mask, raw_signal) == 1 },
6429 "signal {raw_signal} membership changed while converting to the kernel ABI"
6430 );
6431 }
6432 }
6433
6434 #[test]
6435 fn clone_without_child_cleartid_does_not_register_the_pointer() {
6436 assert_eq!(
6437 child_tid_clear_address(CloneFlags::CLONE_CHILD_SETTID, 0x1234),
6438 0
6439 );
6440 }
6441
6442 #[test]
6443 fn clone_with_child_cleartid_registers_the_pointer() {
6444 assert_eq!(
6445 child_tid_clear_address(CloneFlags::CLONE_CHILD_CLEARTID, 0x1234),
6446 0x1234
6447 );
6448 }
6449
6450 #[test]
6451 fn linux_default_dispositions_that_do_not_interrupt_child_waits() {
6452 for signal in [libc::SIGCHLD, libc::SIGCONT, libc::SIGURG, libc::SIGWINCH] {
6453 assert!(signal_default_disposition_does_not_interrupt_child_wait(
6454 SigWrapper(signal)
6455 ));
6456 }
6457 for signal in [libc::SIGALRM, libc::SIGSTOP, libc::SIGUSR1] {
6458 assert!(!signal_default_disposition_does_not_interrupt_child_wait(
6459 SigWrapper(signal)
6460 ));
6461 }
6462 }
6463
6464 #[test]
6469 fn default_actions_that_end_the_process() {
6470 for signal in [
6471 libc::SIGTERM,
6472 libc::SIGINT,
6473 libc::SIGHUP,
6474 libc::SIGQUIT,
6475 libc::SIGABRT,
6476 libc::SIGSEGV,
6477 libc::SIGBUS,
6478 libc::SIGFPE,
6479 libc::SIGILL,
6480 libc::SIGPIPE,
6481 libc::SIGALRM,
6482 libc::SIGUSR1,
6483 libc::SIGUSR2,
6484 libc::SIGRTMIN(),
6485 libc::SIGRTMAX(),
6486 ] {
6487 assert!(
6488 signal_default_action_ends_the_process(SigWrapper(signal)),
6489 "{signal}"
6490 );
6491 }
6492 for signal in [
6493 libc::SIGCHLD,
6494 libc::SIGCONT,
6495 libc::SIGURG,
6496 libc::SIGWINCH,
6497 libc::SIGSTOP,
6498 libc::SIGTSTP,
6499 libc::SIGTTIN,
6500 libc::SIGTTOU,
6501 libc::SIGKILL,
6502 ] {
6503 assert!(
6504 !signal_default_action_ends_the_process(SigWrapper(signal)),
6505 "{signal}"
6506 );
6507 }
6508 }
6509
6510 #[test]
6511 fn uncatchable_signals_do_not_require_a_sigaction_query() {
6512 assert!(signal_has_uncatchable_default_disposition(SigWrapper(
6513 libc::SIGKILL
6514 )));
6515 assert!(signal_has_uncatchable_default_disposition(SigWrapper(
6516 libc::SIGSTOP
6517 )));
6518 assert!(!signal_has_uncatchable_default_disposition(SigWrapper(
6519 libc::SIGUSR1
6520 )));
6521 }
6522
6523 #[test]
6524 fn waitid_ready_child_wins_when_scheduler_also_reports_a_signal() {
6525 assert_eq!(
6526 exact_wait_poll_decision(true, true, Some(ExactChildWaitState::Running)),
6527 ExactWaitPollDecision::ChildReady
6528 );
6529 assert_eq!(
6530 exact_wait_poll_decision(false, true, Some(ExactChildWaitState::LogicallyExited)),
6531 ExactWaitPollDecision::ReapAfterLogicalExit
6532 );
6533 assert_eq!(
6534 exact_wait_poll_decision(false, true, Some(ExactChildWaitState::PhysicalExitPending)),
6535 ExactWaitPollDecision::AwaitPhysicalExit
6536 );
6537 assert_eq!(
6538 exact_wait_poll_decision(false, true, Some(ExactChildWaitState::Running)),
6539 ExactWaitPollDecision::Interrupted
6540 );
6541 assert_eq!(
6542 exact_wait_poll_decision(false, false, Some(ExactChildWaitState::Running)),
6543 ExactWaitPollDecision::Retry
6544 );
6545 }
6546
6547 #[test]
6548 fn wait4_argument_validation_follows_linux_precedence() {
6549 let valid_bits = [0, 1, 3, 29, 30, 31];
6550 for bit in valid_bits {
6551 let options = WaitPidFlag::from_bits_retain((1_u32 << bit) as libc::c_int);
6552 assert_eq!(validate_wait4_arguments(-1, options), Ok(()), "bit {bit}");
6553 }
6554
6555 for bit in (0..u32::BITS).filter(|bit| !valid_bits.contains(bit)) {
6556 let options = WaitPidFlag::from_bits_retain((1_u32 << bit) as libc::c_int);
6557 assert_eq!(
6558 validate_wait4_arguments(-1, options),
6559 Err(Errno::EINVAL),
6560 "bit {bit}"
6561 );
6562 }
6563
6564 for pid in [libc::pid_t::MIN + 1, -2, 0, 1, libc::pid_t::MAX] {
6567 assert_eq!(
6568 validate_wait4_arguments(pid, WaitPidFlag::empty()),
6569 Ok(()),
6570 "pid {pid}"
6571 );
6572 }
6573 assert_eq!(
6574 validate_wait4_arguments(libc::pid_t::MIN, WaitPidFlag::empty()),
6575 Err(Errno::ESRCH)
6576 );
6577 assert_eq!(
6578 validate_wait4_arguments(libc::pid_t::MIN, WaitPidFlag::from_bits_retain(0x10)),
6579 Err(Errno::EINVAL),
6580 "invalid options must win over the INT_MIN selector"
6581 );
6582 }
6583
6584 #[test]
6585 fn stale_any_child_preserves_interrupt_until_no_ready_child_remains() {
6586 let next_child = DetPid::from_raw(200);
6587
6588 assert!(
6589 !stale_any_wait_must_interrupt(true, Some(next_child)),
6590 "another ready child must retain child-ready precedence"
6591 );
6592 assert!(
6593 stale_any_wait_must_interrupt(true, None),
6594 "a pending signal must interrupt before the wait parks again"
6595 );
6596 assert!(!stale_any_wait_must_interrupt(false, None));
6597 }
6598
6599 #[test]
6600 fn ioprio_query_reports_fixed_raw_and_effective_defaults() {
6601 assert_eq!(virtual_ioprio(IOPRIO_WHO_PROCESS), Ok(0));
6602 assert_eq!(
6603 virtual_ioprio(IOPRIO_WHO_PGRP),
6604 Ok(i64::from(IOPRIO_DEFAULT_EFFECTIVE))
6605 );
6606 assert_eq!(
6607 virtual_ioprio(IOPRIO_WHO_USER),
6608 Ok(i64::from(IOPRIO_DEFAULT_EFFECTIVE))
6609 );
6610 assert_eq!(virtual_ioprio(0), Err(Errno::EINVAL));
6611 assert_eq!(virtual_ioprio(4), Err(Errno::EINVAL));
6612 }
6613
6614 #[test]
6615 fn waitid_siginfo_canonicalization_clears_only_cpu_accounting() {
6616 let mut info: libc::siginfo_t = unsafe { std::mem::zeroed() };
6617 info.si_signo = libc::SIGCHLD;
6618 info.si_code = libc::CLD_EXITED;
6619 let fields = unsafe {
6622 &mut (*(std::ptr::addr_of_mut!(info)).cast::<WaitidSiginfoHead>())
6623 .fields
6624 .sigchld
6625 };
6626 fields.pid = 123;
6627 fields.uid = 456;
6628 fields.status = 7;
6629 fields.utime = 8;
6630 fields.stime = 9;
6631
6632 canonicalize_waitid_siginfo(&mut info);
6633
6634 assert_eq!(info.si_signo, libc::SIGCHLD);
6635 assert_eq!(info.si_code, libc::CLD_EXITED);
6636 assert_eq!(unsafe { info.si_pid() }, 123);
6637 assert_eq!(unsafe { info.si_uid() }, 456);
6638 assert_eq!(unsafe { info.si_status() }, 7);
6639 assert_eq!(unsafe { info.si_utime() }, 0);
6640 assert_eq!(unsafe { info.si_stime() }, 0);
6641 }
6642
6643 #[test]
6644 fn wait_status_rollup_only_accepts_process_termination() {
6645 assert!(wait_status_is_termination(0));
6646 assert!(wait_status_is_termination(libc::SIGTERM));
6647 assert!(!wait_status_is_termination((libc::SIGSTOP << 8) | 0x7f));
6648 assert!(!wait_status_is_termination(0xffff));
6649
6650 assert!(waitid_code_is_termination(libc::CLD_EXITED));
6651 assert!(waitid_code_is_termination(libc::CLD_KILLED));
6652 assert!(waitid_code_is_termination(libc::CLD_DUMPED));
6653 assert!(!waitid_code_is_termination(libc::CLD_STOPPED));
6654 assert!(!waitid_code_is_termination(libc::CLD_CONTINUED));
6655 assert!(!waitid_code_is_termination(libc::CLD_TRAPPED));
6656 }
6657
6658 #[test]
6664 fn futex_commands_are_classified_as_linux_dispatches_them() {
6665 use FutexCommand::*;
6666 let private = libc::FUTEX_PRIVATE_FLAG;
6667 let realtime = libc::FUTEX_CLOCK_REALTIME;
6668 for cmd in [
6669 libc::FUTEX_WAIT,
6670 libc::FUTEX_WAIT_BITSET,
6671 libc::FUTEX_WAKE,
6672 libc::FUTEX_WAKE_BITSET,
6673 libc::FUTEX_REQUEUE,
6674 libc::FUTEX_CMP_REQUEUE,
6675 libc::FUTEX_WAKE_OP,
6676 ] {
6677 assert_eq!(classify_futex_command(cmd), Served, "cmd {cmd}");
6678 assert_eq!(classify_futex_command(cmd | private), Served, "cmd {cmd}");
6679 }
6680 assert_eq!(
6681 classify_futex_command(libc::FUTEX_WAIT_BITSET | realtime),
6682 Served
6683 );
6684 for cmd in [
6685 libc::FUTEX_WAIT,
6686 libc::FUTEX_WAKE,
6687 libc::FUTEX_REQUEUE,
6688 libc::FUTEX_WAKE_OP,
6689 ] {
6690 assert_eq!(classify_futex_command(cmd | realtime), NoSys, "cmd {cmd}");
6691 }
6692 for cmd in [libc::FUTEX_FD, 14, 99, libc::FUTEX_CMD_MASK] {
6693 assert_eq!(classify_futex_command(cmd), NoSys, "cmd {cmd}");
6694 }
6695 assert_eq!(
6696 classify_futex_command(libc::FUTEX_LOCK_PI | private),
6697 PriorityInheritance("FUTEX_LOCK_PI")
6698 );
6699 assert_eq!(
6700 classify_futex_command(libc::FUTEX_LOCK_PI2 | realtime),
6701 PriorityInheritance("FUTEX_LOCK_PI2")
6702 );
6703 assert_eq!(
6704 classify_futex_command(libc::FUTEX_LOCK_PI | realtime),
6705 NoSys
6706 );
6707 for (cmd, name) in [
6708 (libc::FUTEX_UNLOCK_PI, "FUTEX_UNLOCK_PI"),
6709 (libc::FUTEX_TRYLOCK_PI, "FUTEX_TRYLOCK_PI"),
6710 (libc::FUTEX_WAIT_REQUEUE_PI, "FUTEX_WAIT_REQUEUE_PI"),
6711 (libc::FUTEX_CMP_REQUEUE_PI, "FUTEX_CMP_REQUEUE_PI"),
6712 ] {
6713 assert_eq!(classify_futex_command(cmd), PriorityInheritance(name));
6714 }
6715 }
6716
6717 type ProbeArgs = (i32, usize, usize, i32, i32);
6722
6723 struct ScriptedProbes {
6726 answers: std::collections::VecDeque<Result<i64, Errno>>,
6727 probes: Vec<ProbeArgs>,
6728 }
6729
6730 impl ScriptedProbes {
6731 fn inject(&mut self, probe: syscalls::Futex) -> KeyProbeAnswer<'_> {
6732 self.probes.push((
6733 probe.futex_op(),
6734 probe.uaddr().map_or(0, AddrMut::as_raw),
6735 probe.uaddr2().map_or(0, AddrMut::as_raw),
6736 probe.val(),
6737 probe.val3(),
6738 ));
6739 let answer = self
6740 .answers
6741 .pop_front()
6742 .expect("the probe was injected more often than scripted");
6743 Box::pin(async move { answer })
6744 }
6745 }
6746
6747 fn run_scripted(
6748 access: KeyAccess,
6749 answer: Result<i64, Errno>,
6750 ) -> (SharedKeyProbe, Vec<ProbeArgs>) {
6751 let mut guest = ScriptedProbes {
6752 answers: [answer].into_iter().collect(),
6753 probes: Vec::new(),
6754 };
6755 let result = futures::executor::block_on(run_shared_futex_key_probe(
6756 &mut guest,
6757 shared_futex_key_probe(0x1000, access),
6758 access,
6759 |guest, probe| guest.inject(probe),
6760 ));
6761 (result, guest.probes)
6762 }
6763
6764 #[test]
6774 fn an_interrupted_shared_key_probe_is_never_retried_or_taken_as_an_answer() {
6775 let read = (libc::FUTEX_REQUEUE, 0x1000, 0x1000, 0, 0);
6776 let write = (
6777 libc::FUTEX_WAKE_OP,
6778 0x1000,
6779 0x1000,
6780 0,
6781 (7 << 28) | (1 << 12),
6782 );
6783 for (access, args) in [(KeyAccess::Read, read), (KeyAccess::Write, write)] {
6784 for errno in [Errno::ERESTARTSYS, Errno::EINTR] {
6785 assert_eq!(
6786 run_scripted(access, Err(errno)),
6787 (SharedKeyProbe::Interrupted(errno), vec![args]),
6788 "{access:?} {errno}"
6789 );
6790 }
6791 assert_eq!(
6792 run_scripted(access, Ok(0)),
6793 (SharedKeyProbe::Admitted, vec![args])
6794 );
6795 assert_eq!(
6796 run_scripted(access, Err(Errno::EFAULT)),
6797 (SharedKeyProbe::Refused(Errno::EFAULT), vec![args])
6798 );
6799 }
6800 assert_eq!(
6801 run_scripted(KeyAccess::Read, Err(Errno::ENOSYS)),
6802 (SharedKeyProbe::Refused(Errno::ENOSYS), vec![read])
6803 );
6804 assert_eq!(
6805 run_scripted(KeyAccess::Write, Err(Errno::ENOSYS)),
6806 (SharedKeyProbe::Admitted, vec![write])
6807 );
6808 }
6809
6810 #[test]
6811 fn futex_wake_op_decodes_and_applies_as_linux() {
6812 let encode = |op: u32, cmp: u32, oparg: u32, cmparg: u32| {
6813 ((op & 0xf) << 28) | ((cmp & 0xf) << 24) | ((oparg & 0xfff) << 12) | (cmparg & 0xfff)
6814 };
6815 let set5_eq0 = FutexWakeOp::decode(encode(FUTEX_OP_SET, FUTEX_OP_CMP_EQ, 5, 0));
6816 assert_eq!(set5_eq0.apply(0), Some(5));
6817 assert_eq!(set5_eq0.compare(0), Some(true));
6818 assert_eq!(set5_eq0.compare(1), Some(false));
6819 let add_minus1 = FutexWakeOp::decode(encode(FUTEX_OP_ADD, FUTEX_OP_CMP_LT, 0xfff, 0x800));
6820 assert_eq!(add_minus1.apply(10), Some(9));
6821 assert_eq!(add_minus1.apply(i32::MIN), Some(i32::MAX));
6822 assert_eq!(add_minus1.compare(-2048), Some(false));
6823 assert_eq!(add_minus1.compare(-2049), Some(true));
6824 let or = FutexWakeOp::decode(encode(FUTEX_OP_OR, FUTEX_OP_CMP_NE, 0b100, 7));
6825 assert_eq!(or.apply(0b011), Some(0b111));
6826 assert_eq!(or.compare(7), Some(false));
6827 let andn = FutexWakeOp::decode(encode(FUTEX_OP_ANDN, FUTEX_OP_CMP_GE, 0b110, 3));
6828 assert_eq!(andn.apply(0b111), Some(0b001));
6829 assert_eq!(andn.compare(3), Some(true));
6830 let xor = FutexWakeOp::decode(encode(FUTEX_OP_XOR, FUTEX_OP_CMP_LE, 0xff, 0));
6831 assert_eq!(xor.apply(0x0f), Some(0xf0));
6832 assert_eq!(xor.compare(1), Some(false));
6833 let shift = FutexWakeOp::decode(encode(
6834 FUTEX_OP_OPARG_SHIFT | FUTEX_OP_OR,
6835 FUTEX_OP_CMP_GT,
6836 3,
6837 0,
6838 ));
6839 assert_eq!(shift.apply(0), Some(8));
6840 assert_eq!(shift.compare(1), Some(true));
6841 let masked = FutexWakeOp::decode(encode(FUTEX_OP_OPARG_SHIFT | FUTEX_OP_SET, 0, 0xfff, 0));
6843 assert_eq!(masked.apply(0), Some(i32::MIN));
6844 let unknown_op = FutexWakeOp::decode(encode(7, FUTEX_OP_CMP_EQ, 1, 0));
6845 assert!(!unknown_op.has_known_operation());
6846 assert_eq!(unknown_op.apply(0), None);
6847 let unknown_cmp = FutexWakeOp::decode(encode(FUTEX_OP_SET, 6, 1, 0));
6848 assert!(unknown_cmp.has_known_operation());
6849 assert_eq!(unknown_cmp.compare(0), None);
6850 }
6851
6852 #[test]
6853 fn futex_timeout_units_and_modes_match_linux() {
6854 let timeout = Timespec {
6855 tv_sec: 2,
6856 tv_nsec: 3,
6857 };
6858 assert_eq!(
6859 parse_futex_timeout(libc::FUTEX_WAIT, timeout),
6860 Ok(FutexTimeout::Relative(2_000_000_003))
6861 );
6862 assert_eq!(
6863 parse_futex_timeout(libc::FUTEX_WAIT_BITSET, timeout),
6864 Ok(FutexTimeout::Absolute(LogicalTime::from_nanos(
6865 2_000_000_003
6866 )))
6867 );
6868 assert_eq!(
6872 parse_futex_timeout(libc::FUTEX_WAIT_BITSET | libc::FUTEX_PRIVATE_FLAG, timeout),
6873 Ok(FutexTimeout::Absolute(LogicalTime::from_nanos(
6874 2_000_000_003
6875 )))
6876 );
6877 assert_eq!(
6878 parse_futex_timeout(libc::FUTEX_WAIT | libc::FUTEX_PRIVATE_FLAG, timeout),
6879 Ok(FutexTimeout::Relative(2_000_000_003))
6880 );
6881 }
6882
6883 #[test]
6884 fn absolute_futex_timeout_is_rebased_to_logical_time() {
6885 let logical_now = LogicalTime::from_secs(100);
6886 let clock_now = LogicalTime::from_secs(5_000);
6887 let deadline = clock_now + Duration::from_millis(100);
6888 assert_eq!(
6889 rebase_absolute_timeout(deadline, clock_now, logical_now),
6890 logical_now + Duration::from_millis(100)
6891 );
6892 assert_eq!(
6893 rebase_absolute_timeout(
6894 clock_now - LogicalTime::from_nanos(1),
6895 clock_now,
6896 logical_now
6897 ),
6898 logical_now
6899 );
6900 }
6901
6902 #[test]
6903 fn absolute_futex_timeout_detects_host_and_logical_clock_domains() {
6904 let host_monotonic_now = LogicalTime::from_secs(374_766);
6905 let logical_now = LogicalTime::from_secs(1_640_995_199);
6906 let delta = Duration::from_millis(100);
6907
6908 assert!(absolute_timeout_uses_host_clock(
6909 host_monotonic_now + delta,
6910 host_monotonic_now,
6911 logical_now
6912 ));
6913 assert!(!absolute_timeout_uses_host_clock(
6914 logical_now + delta,
6915 host_monotonic_now,
6916 logical_now
6917 ));
6918
6919 let host_realtime_now = LogicalTime::from_secs(1_785_142_800);
6920 assert!(absolute_timeout_uses_host_clock(
6921 host_realtime_now + delta,
6922 host_realtime_now,
6923 logical_now
6924 ));
6925 }
6926
6927 #[test]
6931 fn futex_timeout_clamps_a_huge_valid_timespec_like_ktime() {
6932 let huge = Timespec {
6933 tv_sec: libc::time_t::MAX,
6934 tv_nsec: 0,
6935 };
6936 assert!(futex_timespec_is_valid(huge));
6937 assert_eq!(
6938 parse_futex_timeout(libc::FUTEX_WAIT, huge),
6939 Ok(FutexTimeout::Relative(FUTEX_KTIME_MAX_NANOS))
6940 );
6941 assert_eq!(
6942 parse_futex_timeout(libc::FUTEX_WAIT_BITSET, huge),
6943 Ok(FutexTimeout::Absolute(LogicalTime::from_nanos(
6944 FUTEX_KTIME_MAX_NANOS
6945 )))
6946 );
6947 let at_ktime_sec_max = Timespec {
6948 tv_sec: (FUTEX_KTIME_MAX_NANOS / 1_000_000_000) as libc::time_t,
6949 tv_nsec: 0,
6950 };
6951 assert_eq!(
6952 parse_futex_timeout(libc::FUTEX_WAIT, at_ktime_sec_max),
6953 Ok(FutexTimeout::Relative(FUTEX_KTIME_MAX_NANOS))
6954 );
6955 let just_below = Timespec {
6956 tv_sec: (FUTEX_KTIME_MAX_NANOS / 1_000_000_000 - 1) as libc::time_t,
6957 tv_nsec: 999_999_999,
6958 };
6959 assert_eq!(
6960 parse_futex_timeout(libc::FUTEX_WAIT, just_below),
6961 Ok(FutexTimeout::Relative(
6962 (FUTEX_KTIME_MAX_NANOS / 1_000_000_000) * 1_000_000_000 - 1
6963 ))
6964 );
6965 for invalid in [(-1, 0), (0, -1), (0, 1_000_000_000)] {
6966 assert!(!futex_timespec_is_valid(Timespec {
6967 tv_sec: invalid.0,
6968 tv_nsec: invalid.1,
6969 }));
6970 }
6971 }
6972
6973 #[test]
6974 fn futex_timeout_rejects_invalid_timespecs() {
6975 assert_eq!(
6976 parse_futex_timeout(
6977 libc::FUTEX_WAIT,
6978 Timespec {
6979 tv_sec: -1,
6980 tv_nsec: 0,
6981 },
6982 ),
6983 Err(Errno::EINVAL)
6984 );
6985 assert_eq!(
6986 parse_futex_timeout(
6987 libc::FUTEX_WAIT_BITSET,
6988 Timespec {
6989 tv_sec: 0,
6990 tv_nsec: 1_000_000_000,
6991 },
6992 ),
6993 Err(Errno::EINVAL)
6994 );
6995 }
6996
6997 fn plain_attr() -> SchedAttrFields {
7004 SchedAttrFields {
7005 policy: 0,
7006 sched_flags: 0,
7007 priority: 0,
7008 runtime: 0,
7009 deadline: 0,
7010 period: 0,
7011 }
7012 }
7013
7014 #[test]
7015 fn size_zero_is_a_well_formed_ver0_request() {
7016 assert_eq!(sched_attr_effective_size(0), Ok(SCHED_ATTR_SIZE_VER0));
7019 }
7020
7021 #[test]
7022 fn size_below_ver0_or_past_a_page_is_too_big() {
7023 assert_eq!(sched_attr_effective_size(1), Err(()));
7025 assert_eq!(sched_attr_effective_size(SCHED_ATTR_SIZE_VER0 - 1), Err(()));
7026 assert_eq!(sched_attr_effective_size(SCHED_ATTR_MAX_SIZE + 1), Err(()));
7027 }
7028
7029 #[test]
7030 fn size_from_ver0_through_one_page_is_accepted_unchanged() {
7031 for size in [
7033 SCHED_ATTR_SIZE_VER0,
7034 SCHED_ATTR_SIZE_VER1,
7035 SCHED_ATTR_SIZE_VER1 + 1,
7036 SCHED_ATTR_MAX_SIZE,
7037 ] {
7038 assert_eq!(sched_attr_effective_size(size), Ok(size), "size {}", size);
7039 }
7040 }
7041
7042 #[test]
7043 fn sched_ext_is_a_valid_policy_and_sched_iso_is_not() {
7044 assert!(is_valid_sched_policy(SCHED_EXT), "SCHED_EXT is accepted");
7047 assert!(!is_valid_sched_policy(4), "SCHED_ISO is reserved");
7048 for policy in [0, 1, 2, 3, 5, 6] {
7049 assert!(is_valid_sched_policy(policy), "policy {}", policy);
7050 }
7051 for policy in [8, 99] {
7053 assert!(!is_valid_sched_policy(policy), "policy {}", policy);
7054 }
7055 }
7056
7057 #[test]
7069 fn util_clamp_size_rule_is_decided_before_the_pid_lookup() {
7070 let mut attr = plain_attr();
7072 attr.sched_flags = SCHED_FLAG_UTIL_CLAMP_MIN;
7073 assert_eq!(
7074 validate_sched_attr_before_lookup(SCHED_ATTR_SIZE_VER0, &attr),
7075 Err(Errno::EINVAL)
7076 );
7077 assert_eq!(
7078 validate_sched_attr_before_lookup(SCHED_ATTR_SIZE_VER1, &attr),
7079 Ok(())
7080 );
7081 assert_eq!(validate_sched_attr_after_lookup(&attr), Ok(()));
7083 }
7084
7085 #[test]
7086 fn a_negative_policy_is_decided_before_the_pid_lookup() {
7087 let mut attr = plain_attr();
7090 attr.policy = 0x8000_0000;
7091 assert_eq!(
7092 validate_sched_attr_before_lookup(SCHED_ATTR_SIZE_VER0, &attr),
7093 Err(Errno::EINVAL)
7094 );
7095 attr.sched_flags = SCHED_FLAG_KEEP_POLICY;
7096 assert_eq!(
7097 validate_sched_attr_before_lookup(SCHED_ATTR_SIZE_VER0, &attr),
7098 Err(Errno::EINVAL),
7099 "KEEP_POLICY must not hide a negative policy"
7100 );
7101 }
7102
7103 #[test]
7104 fn policy_and_flag_rules_are_decided_after_the_pid_lookup() {
7105 let mut bad_policy = plain_attr();
7108 bad_policy.policy = 99;
7109 assert_eq!(
7110 validate_sched_attr_before_lookup(SCHED_ATTR_SIZE_VER0, &bad_policy),
7111 Ok(()),
7112 "an undefined policy must survive the near side so ESRCH can win"
7113 );
7114 assert_eq!(
7115 validate_sched_attr_after_lookup(&bad_policy),
7116 Err(Errno::EINVAL)
7117 );
7118
7119 let mut bad_flag = plain_attr();
7120 bad_flag.sched_flags = 0x80;
7121 assert_eq!(
7122 validate_sched_attr_before_lookup(SCHED_ATTR_SIZE_VER0, &bad_flag),
7123 Ok(()),
7124 "an undefined sched_flags bit must survive the near side"
7125 );
7126 assert_eq!(
7127 validate_sched_attr_after_lookup(&bad_flag),
7128 Err(Errno::EINVAL)
7129 );
7130 }
7131
7132 #[test]
7133 fn keep_policy_makes_the_policy_field_irrelevant() {
7134 let mut attr = plain_attr();
7139 attr.policy = 99;
7140 assert_eq!(validate_sched_attr_after_lookup(&attr), Err(Errno::EINVAL));
7141 attr.sched_flags = SCHED_FLAG_KEEP_POLICY;
7142 assert_eq!(validate_sched_attr_after_lookup(&attr), Ok(()));
7143 }
7144
7145 #[test]
7146 fn defined_sched_flags_bits_are_accepted_and_undefined_ones_are_not() {
7147 let mut attr = plain_attr();
7151 attr.sched_flags = 0x80;
7152 assert_eq!(validate_sched_attr_after_lookup(&attr), Err(Errno::EINVAL));
7153 for flag in [
7154 SCHED_FLAG_RESET_ON_FORK,
7155 SCHED_FLAG_RECLAIM,
7156 SCHED_FLAG_DL_OVERRUN,
7157 SCHED_FLAG_KEEP_PARAMS,
7158 SCHED_FLAG_KEEP_POLICY,
7159 ] {
7160 let mut ok = plain_attr();
7161 ok.sched_flags = flag;
7162 assert_eq!(
7163 validate_sched_attr_after_lookup(&ok),
7164 Ok(()),
7165 "flag {:#x}",
7166 flag
7167 );
7168 }
7169 let mut all = plain_attr();
7173 all.sched_flags = SCHED_FLAG_ALL;
7174 assert_eq!(
7175 validate_sched_attr_before_lookup(SCHED_ATTR_SIZE_VER0, &all),
7176 Err(Errno::EINVAL)
7177 );
7178 assert_eq!(
7179 validate_sched_attr_before_lookup(SCHED_ATTR_SIZE_VER1, &all),
7180 Ok(())
7181 );
7182 assert_eq!(validate_sched_attr_after_lookup(&all), Ok(()));
7183 }
7184
7185 #[test]
7186 fn priority_must_agree_with_the_policy() {
7187 for policy in [0u32, 3, 5] {
7191 let mut attr = plain_attr();
7192 attr.policy = policy;
7193 attr.priority = 1;
7194 assert_eq!(
7195 validate_sched_attr_after_lookup(&attr),
7196 Err(Errno::EINVAL),
7197 "policy {} with priority 1",
7198 policy
7199 );
7200 attr.priority = 0;
7201 assert_eq!(
7202 validate_sched_attr_after_lookup(&attr),
7203 Ok(()),
7204 "policy {} with priority 0",
7205 policy
7206 );
7207 }
7208 for policy in [SCHED_FIFO, SCHED_RR] {
7209 let mut attr = plain_attr();
7210 attr.policy = policy;
7211 attr.priority = 0;
7212 assert_eq!(
7213 validate_sched_attr_after_lookup(&attr),
7214 Err(Errno::EINVAL),
7215 "rt policy {} with priority 0",
7216 policy
7217 );
7218 attr.priority = 1;
7222 assert_eq!(validate_sched_attr_after_lookup(&attr), Ok(()));
7223 }
7224 }
7225
7226 #[test]
7227 fn a_priority_past_max_rt_prio_is_refused() {
7228 let mut attr = plain_attr();
7231 attr.policy = SCHED_FIFO;
7232 attr.priority = MAX_RT_PRIO;
7233 assert_eq!(validate_sched_attr_after_lookup(&attr), Err(Errno::EINVAL));
7234 attr.priority = MAX_RT_PRIO - 1;
7235 assert_eq!(validate_sched_attr_after_lookup(&attr), Ok(()));
7236 }
7237
7238 #[test]
7239 fn deadline_parameters_are_checked() {
7240 let mut zeroed = plain_attr();
7243 zeroed.policy = SCHED_DEADLINE;
7244 assert_eq!(
7245 validate_sched_attr_after_lookup(&zeroed),
7246 Err(Errno::EINVAL),
7247 "all-zero deadline parameters"
7248 );
7249
7250 let mut inverted = plain_attr();
7251 inverted.policy = SCHED_DEADLINE;
7252 inverted.runtime = 90_000_000;
7253 inverted.deadline = 30_000_000;
7254 inverted.period = 30_000_000;
7255 assert_eq!(
7256 validate_sched_attr_after_lookup(&inverted),
7257 Err(Errno::EINVAL),
7258 "runtime > deadline"
7259 );
7260
7261 let mut sane = plain_attr();
7264 sane.policy = SCHED_DEADLINE;
7265 sane.runtime = 10_000_000;
7266 sane.deadline = 30_000_000;
7267 sane.period = 30_000_000;
7268 assert_eq!(validate_sched_attr_after_lookup(&sane), Ok(()));
7269 }
7270
7271 #[test]
7272 fn deadline_parameter_edges_follow_checkparam_dl() {
7273 assert!(!deadline_params_are_valid(1 << 20, 0, 0));
7275 assert!(!deadline_params_are_valid((1 << 10) - 1, 1 << 20, 1 << 20));
7277 assert!(deadline_params_are_valid(1 << 10, 1 << 20, 1 << 20));
7278 assert!(!deadline_params_are_valid(1 << 20, 1 << 63, 0));
7280 assert!(!deadline_params_are_valid(1 << 20, 1 << 20, 1 << 63));
7281 assert!(deadline_params_are_valid(1 << 20, 1 << 21, 0));
7284 assert!(!deadline_params_are_valid(1 << 20, 1 << 22, 1 << 21));
7286 }
7287
7288 #[test]
7289 fn the_size_written_back_on_refusal_is_the_kernel_struct_not_the_libc_mirror() {
7290 assert_eq!(SCHED_ATTR_KERNEL_SIZE, 56);
7294 assert_eq!(std::mem::size_of::<libc::sched_attr>(), 48);
7295 assert_ne!(
7296 SCHED_ATTR_KERNEL_SIZE as usize,
7297 std::mem::size_of::<libc::sched_attr>()
7298 );
7299 }
7300
7301 struct BoundedMemory {
7304 bytes: Vec<u8>,
7305 readable_len: usize,
7306 reads: std::cell::RefCell<Vec<usize>>,
7307 }
7308
7309 impl reverie::syscalls::MemoryAccess for BoundedMemory {
7310 fn read_vectored(
7311 &self,
7312 read_from: &[std::io::IoSlice<'_>],
7313 write_to: &mut [std::io::IoSliceMut<'_>],
7314 ) -> Result<usize, Errno> {
7315 let start = read_from[0].as_ptr() as usize;
7316 let want = read_from.iter().map(|slice| slice.len()).sum::<usize>();
7317 self.reads.borrow_mut().push(want);
7318 if start >= self.readable_len {
7319 return Err(Errno::EFAULT);
7320 }
7321 let avail = (self.readable_len - start).min(want);
7322 let mut copied = 0;
7323 for out in write_to.iter_mut() {
7324 if copied == avail {
7325 break;
7326 }
7327 let take = out.len().min(avail - copied);
7328 out[..take].copy_from_slice(&self.bytes[start + copied..start + copied + take]);
7329 copied += take;
7330 }
7331 Ok(copied)
7332 }
7333
7334 fn write_vectored(
7335 &mut self,
7336 _read_from: &[std::io::IoSlice<'_>],
7337 _write_to: &mut [std::io::IoSliceMut<'_>],
7338 ) -> Result<usize, Errno> {
7339 unimplemented!("this fixture never writes")
7340 }
7341 }
7342
7343 fn bounded(bytes: Vec<u8>, readable_len: usize) -> BoundedMemory {
7344 BoundedMemory {
7345 bytes,
7346 readable_len,
7347 reads: std::cell::RefCell::new(Vec::new()),
7348 }
7349 }
7350
7351 fn tail_base() -> AddrMut<'static, u8> {
7352 AddrMut::<u8>::from_raw(1).expect("nonzero base")
7353 }
7354
7355 #[test]
7363 fn a_nonzero_byte_before_a_fault_is_e2big_not_efault() {
7364 let off = SCHED_ATTR_KERNEL_SIZE as usize;
7365 let mut bytes = vec![0u8; off + 4096];
7366 bytes[off + 1] = 0xAA; let readable = off + 512; let memory = bounded(bytes, readable);
7369 assert_eq!(
7370 scan_tail_is_zeroed(&memory, tail_base(), off, 4096),
7371 TailVerdict::NotZeroed,
7372 "a non-zero byte the scan reaches first must win over a later fault"
7373 );
7374 }
7375
7376 #[test]
7379 fn a_fault_before_any_nonzero_byte_is_efault() {
7380 let off = SCHED_ATTR_KERNEL_SIZE as usize;
7381 let bytes = vec![0u8; off + 4096];
7382 let memory = bounded(bytes, off + 512);
7383 assert_eq!(
7384 scan_tail_is_zeroed(&memory, tail_base(), off, 4096),
7385 TailVerdict::Faulted,
7386 "an unreadable byte reached before anything non-zero must be EFAULT"
7387 );
7388 }
7389
7390 #[test]
7399 fn tail_reads_are_never_small_enough_to_bypass_guest_protection() {
7400 let off = SCHED_ATTR_KERNEL_SIZE as usize;
7401 for tail_len in 1..=16usize {
7402 let bytes = vec![0u8; off + tail_len + 64];
7403 let memory = bounded(bytes, off + tail_len + 64);
7404 assert_eq!(
7405 scan_tail_is_zeroed(&memory, tail_base(), off, tail_len),
7406 TailVerdict::AllZero
7407 );
7408 let reads = memory.reads.borrow().clone();
7409 assert!(!reads.is_empty(), "tail_len {tail_len} issued no read");
7410 for length in reads {
7411 assert!(
7412 length > std::mem::size_of::<u64>(),
7413 "tail_len {tail_len} issued a {length}-byte read, which safeptrace \
7414 serves with PTRACE_PEEKDATA and which therefore bypasses guest \
7415 page protections"
7416 );
7417 }
7418 }
7419 }
7420
7421 #[test]
7428 fn keep_policy_validates_against_the_virtual_current_policy() {
7429 let attr = SchedAttrFields {
7430 policy: 99, sched_flags: SCHED_FLAG_KEEP_POLICY,
7432 priority: 1,
7433 runtime: 0,
7434 deadline: 0,
7435 period: 0,
7436 };
7437 assert_eq!(
7438 validate_sched_attr_after_lookup(&attr),
7439 Err(Errno::EINVAL),
7440 "priority 1 under the virtual SCHED_OTHER current policy must be refused"
7441 );
7442
7443 let ok = SchedAttrFields {
7446 priority: 0,
7447 ..attr
7448 };
7449 assert_eq!(
7450 validate_sched_attr_after_lookup(&ok),
7451 Ok(()),
7452 "KEEP_POLICY must still ignore the policy field itself"
7453 );
7454 }
7455
7456 #[test]
7459 fn the_virtual_current_policy_is_what_sched_getattr_reports() {
7460 assert_eq!(
7461 VIRTUAL_CURRENT_POLICY,
7462 libc::SCHED_OTHER as u32,
7463 "handle_sched_getattr writes SCHED_OTHER into sched_policy for every thread; \
7464 KEEP_POLICY must substitute that same value"
7465 );
7466 }
7467}
7468
7469pub(crate) fn real_uid(tid: i32) -> Option<u32> {
7471 let status = std::fs::read_to_string(format!("/proc/{tid}/status")).ok()?;
7472 status
7473 .lines()
7474 .find_map(|line| line.strip_prefix("Uid:"))?
7475 .split_whitespace()
7476 .next()?
7477 .parse()
7478 .ok()
7479}
7480
7481fn clone3_field<M: MemoryAccess>(
7487 memory: &M,
7488 clone: &syscalls::Clone3,
7489 offset: usize,
7490) -> Option<u64> {
7491 const CLONE_ARGS_SIZE_VER0: usize = 64;
7492 if clone.size() < CLONE_ARGS_SIZE_VER0 || offset + 8 > clone.size() {
7493 return None;
7494 }
7495 let base = clone.args()?.as_raw();
7496 memory
7497 .read_value(Addr::<u64>::from_raw(base + offset)?)
7498 .ok()
7499}
7500
7501fn clone_pidfd_address<M: MemoryAccess>(
7512 clone_family: &syscalls::family::CloneFamily,
7513 memory: &M,
7514 flags: CloneFlags,
7515) -> Option<usize> {
7516 let (flags, address) = match clone_family {
7517 syscalls::family::CloneFamily::Clone(clone) => {
7518 (flags, clone.ptid().map(|ptid| ptid.as_raw()))
7519 }
7520 syscalls::family::CloneFamily::Clone3(clone) => (
7521 flags,
7522 Some(usize::try_from(clone3_field(memory, clone, 8)?).ok()?),
7523 ),
7524 #[cfg(not(target_arch = "aarch64"))]
7525 _ => return None,
7526 };
7527 if !flags.contains(CloneFlags::CLONE_PIDFD)
7528 || flags
7529 .intersects(CloneFlags::CLONE_VM | CloneFlags::CLONE_FILES | CloneFlags::CLONE_VFORK)
7530 {
7531 return None;
7532 }
7533 address
7534}