1use std::net::Ipv4Addr;
14use std::net::Ipv6Addr;
15use std::os::unix::io::RawFd;
16use std::time::Duration;
17
18use nix::fcntl::OFlag;
19use reverie::Errno;
20use reverie::Error;
21use reverie::Guest;
22use reverie::Stack;
23use reverie::syscalls;
24use reverie::syscalls::Addr;
25use reverie::syscalls::AddrMut;
26use reverie::syscalls::Displayable;
27use reverie::syscalls::MemoryAccess;
28use reverie::syscalls::Syscall;
29use reverie::syscalls::SyscallArgs;
30use reverie::syscalls::SyscallInfo;
31use reverie::syscalls::Sysno;
32use reverie::syscalls::Timespec;
33use tracing::debug;
34use tracing::trace;
35
36use crate::config::SchedHeuristic;
37use crate::fd::FdType;
38use crate::record_or_replay::RecordOrReplay;
39use crate::resources::LOOPBACK_POLL_YIELD_FYI;
40use crate::resources::Permission;
41use crate::resources::ResourceID;
42use crate::resources::Resources;
43use crate::scheduler::runqueue::FIRST_PRIORITY;
44use crate::syscalls::helpers::KernelSignalWait;
45use crate::syscalls::helpers::NonblockableSyscall;
46use crate::syscalls::helpers::PublishedWaitMask;
47use crate::syscalls::helpers::REAL_TIME_SIGNALS;
48use crate::syscalls::helpers::RestartCall;
49use crate::syscalls::helpers::act_on_pending_real_time;
50use crate::syscalls::helpers::is_accepted_connection;
51use crate::syscalls::helpers::keep_restart_block;
52use crate::syscalls::helpers::millis_duration_to_absolute_timeout;
53use crate::syscalls::helpers::observe_under_mask;
54use crate::syscalls::helpers::pending_real_time_among;
55use crate::syscalls::helpers::poll_deadline_for;
56use crate::syscalls::helpers::publish_wait_mask;
57use crate::syscalls::helpers::record_retry_event;
58use crate::syscalls::helpers::refuse_held_signal_loss;
59use crate::syscalls::helpers::result_after_restore;
60use crate::syscalls::helpers::retry_blocking_wait_under_mask;
61use crate::syscalls::helpers::retry_nonblocking_syscall_with_timeout;
62use crate::syscalls::helpers::unblocked_by;
63use crate::syscalls::network_trace::received_descriptors;
64use crate::syscalls::signal::STACK_RED_ZONE;
65use crate::syscalls::signal::kernel_installed_signal_mask;
66use crate::syscalls::signal::read_kernel_sigset;
67use crate::syscalls::threads::KernelSigset;
68use crate::syscalls::threads::read_thread_signal_state;
69use crate::syscalls::threads::read_thread_wait_signal_state;
70use crate::tool_global::*;
71use crate::tool_local::Detcore;
72use crate::types::DetTid;
73use crate::types::LogicalTime;
74
75fn print_poll(call: &syscalls::Poll) {
78 let len = call.nfds();
79 debug!("POLL: on {} fds, timeout {}", len, call.timeout());
80 unsafe {
82 for i in 0..len {
83 debug!(
84 "POLL: fd {} = {}",
85 i,
86 call.fds().unwrap().offset(i as isize)
87 );
88 }
89 }
90}
91
92fn zero_timeout_poll_request(dettid: DetTid, yield_to_peer: bool) -> Resources {
102 let mut request = Resources::new(dettid);
103 if yield_to_peer {
104 request.insert(ResourceID::SchedYield, Permission::W);
105 request.fyi(LOOPBACK_POLL_YIELD_FYI);
106 }
107 request
108}
109
110fn connect_result_allows_peer_classification(result: &Result<i64, Error>) -> bool {
111 match result {
112 Ok(_) => true,
113 Err(Error::Errno(errno)) => *errno == Errno::EINPROGRESS,
114 Err(_) => false,
115 }
116}
117
118const KERNEL_SIGSET_SIZE: usize = std::mem::size_of::<u64>();
119pub(super) const PSELECT6_INTERNAL_MAX_NFDS: i32 =
120 (std::mem::size_of::<libc::c_ulong>() * 8) as i32;
121
122#[derive(Clone, Copy)]
123#[repr(C)]
124pub(super) struct Pselect6SigmaskArg {
125 pub(super) sigmask: usize,
126 pub(super) sigsetsize: usize,
127}
128
129enum StagedCellsStorage<Guard> {
132 Stack(Guard),
134 RedZone {
137 at: usize,
138 len: usize,
139 saved: [u8; MAX_PRIVATE_CELLS_LEN],
140 },
141}
142
143#[derive(Clone, Copy)]
153enum PrivateCells {
154 Pselect6Mask(KernelSigset),
157 Mask(KernelSigset),
160 MaskAndZeroTimeout(KernelSigset),
163 ZeroTimeout,
165}
166
167const MASK_LEN: usize = std::mem::size_of::<KernelSigset>();
168
169const MAX_PRIVATE_CELLS_LEN: usize = MASK_LEN + std::mem::size_of::<Timespec>();
171
172const _: () = assert!(std::mem::size_of::<Pselect6SigmaskArg>() == std::mem::size_of::<Timespec>());
174
175impl PrivateCells {
176 fn len(self) -> usize {
177 match self {
178 Self::Pselect6Mask(_) | Self::Mask(_) | Self::MaskAndZeroTimeout(_) => {
179 MAX_PRIVATE_CELLS_LEN
180 }
181 Self::ZeroTimeout => std::mem::size_of::<Timespec>(),
182 }
183 }
184
185 fn bytes(self, at: usize) -> [u8; MAX_PRIVATE_CELLS_LEN] {
188 let mut cells = [0u8; MAX_PRIVATE_CELLS_LEN];
189 match self {
190 Self::Pselect6Mask(mask) => {
191 cells[..MASK_LEN].copy_from_slice(&mask.to_ne_bytes());
192 cells[MASK_LEN..MASK_LEN + 8].copy_from_slice(&at.to_ne_bytes());
193 cells[MASK_LEN + 8..].copy_from_slice(&KERNEL_SIGSET_SIZE.to_ne_bytes());
194 }
195 Self::Mask(mask) | Self::MaskAndZeroTimeout(mask) => {
196 cells[..MASK_LEN].copy_from_slice(&mask.to_ne_bytes());
197 }
198 Self::ZeroTimeout => {}
199 }
200 cells
201 }
202}
203
204struct StagedCells<Guard> {
206 at: usize,
209 storage: StagedCellsStorage<Guard>,
210 timerfd_scratch: Option<crate::syscalls::timerfd::Scratch>,
214}
215
216impl<Guard> StagedCells<Guard> {
217 fn mask(&self) -> usize {
219 self.at
220 }
221
222 fn after_mask(&self) -> usize {
224 self.at + MASK_LEN
225 }
226
227 fn release<G, T>(self, guest: &mut G)
232 where
233 G: Guest<Detcore<T>>,
234 T: RecordOrReplay,
235 {
236 if let StagedCellsStorage::RedZone { at, len, saved } = self.storage
237 && let Err(errno) = AddrMut::<u8>::from_raw(at)
238 .ok_or(Errno::EFAULT)
239 .and_then(|bytes| guest.memory().write_exact(bytes, &saved[..len]))
240 {
241 tracing::warn!("[detcore] could not restore the red zone after a syscall: {errno}");
243 }
244 }
245}
246
247async fn stage_private_cells<G, T>(
272 guest: &mut G,
273 cells: PrivateCells,
274 live: &[std::ops::Range<usize>],
275) -> Result<Option<StagedCells<<G::Stack as Stack>::StackGuard>>, Errno>
276where
277 G: Guest<Detcore<T>>,
278 T: RecordOrReplay,
279{
280 let len = cells.len();
281 let mut stack = guest.stack().await;
282 let at = match cells {
283 PrivateCells::ZeroTimeout => stack.reserve::<Timespec>().as_raw(),
284 _ => stack.reserve::<[u64; 3]>().as_raw(),
285 };
286 let timerfd_scratch = crate::syscalls::timerfd::holds_armed_virtual_timerfd(guest)
290 .then(|| crate::syscalls::timerfd::reserve_scratch(&mut stack));
291 match stack.commit() {
292 Ok(guard) => {
293 let bytes = AddrMut::<u8>::from_raw(at).ok_or(Errno::EFAULT)?;
294 guest.memory().write_exact(bytes, &cells.bytes(at)[..len])?;
296 return Ok(Some(StagedCells {
297 at,
298 storage: StagedCellsStorage::Stack(guard),
299 timerfd_scratch,
300 }));
301 }
302 Err(Errno::EFAULT) => {}
303 Err(errno) => return Err(errno),
304 }
305 let rsp = guest.regs().await.rsp as usize;
306 let Some(top) = rsp.checked_sub(len).map(|top| top & !7) else {
307 return Ok(None);
308 };
309 let bottom = rsp.saturating_sub(STACK_RED_ZONE);
310 let mut saved = [0u8; MAX_PRIVATE_CELLS_LEN];
311 let mut found = None;
312 for at in (bottom..=top).rev().step_by(8) {
313 let window = at..at + len;
314 if live
315 .iter()
316 .any(|range| range.start < window.end && window.start < range.end)
317 {
318 continue;
319 }
320 let Some(bytes) = AddrMut::<u8>::from_raw(at) else {
321 continue;
322 };
323 if guest.memory().read_exact(bytes, &mut saved[..len]).is_ok() {
324 found = Some((at, bytes));
325 break;
326 }
327 }
328 let Some((at, bytes)) = found else {
329 return Ok(None);
330 };
331 let staged = StagedCells {
332 at,
333 storage: StagedCellsStorage::RedZone { at, len, saved },
334 timerfd_scratch: None,
335 };
336 if guest
337 .memory()
338 .write_exact(bytes, &cells.bytes(at)[..len])
339 .is_err()
340 {
341 staged.release(guest);
344 return Ok(None);
345 }
346 Ok(Some(staged))
347}
348
349async fn entry_pselect6_temporary_mask<G, T>(
359 guest: &mut G,
360 call: syscalls::Pselect6,
361) -> Option<KernelSigset>
362where
363 G: Guest<Detcore<T>>,
364 T: RecordOrReplay,
365{
366 let wrapper = call.sigmask()?;
367 let argument: Pselect6SigmaskArg = guest.memory().read_value(wrapper.cast()).ok()?;
368 if argument.sigsetsize != KERNEL_SIGSET_SIZE {
369 return None;
370 }
371 let mask_addr = Addr::<libc::sigset_t>::from_raw(argument.sigmask)?;
372 let mask = read_kernel_sigset(guest, mask_addr).await.ok()?;
373 super::signal_shadow::note_wait_mask(guest, mask);
374 Some(mask)
375}
376
377fn replayed_pselect6_temporary_mask<G, T>(
382 guest: &mut G,
383 call: syscalls::Pselect6,
384) -> Option<KernelSigset>
385where
386 G: Guest<Detcore<T>>,
387 T: RecordOrReplay,
388{
389 let wrapper = call.sigmask()?;
390 let argument: Pselect6SigmaskArg = guest.memory().read_value(wrapper.cast()).ok()?;
391 if argument.sigsetsize != KERNEL_SIGSET_SIZE {
392 return None;
393 }
394 let mask_addr = Addr::<KernelSigset>::from_raw(argument.sigmask)?;
395 let mask = guest.memory().read_value(mask_addr).ok()?;
396 super::signal_shadow::note_wait_mask(guest, mask);
397 Some(mask)
398}
399
400async fn replayed_pselect6_delivery_fits<G, T>(guest: &mut G, call: syscalls::Pselect6) -> bool
414where
415 G: Guest<Detcore<T>>,
416 T: RecordOrReplay,
417{
418 let Some(wrapper) = call.sigmask() else {
419 return true;
420 };
421 let argument: Result<Pselect6SigmaskArg, _> = guest.memory().read_value(wrapper.cast());
422 match argument {
423 Ok(argument) if argument.sigmask != 0 => {}
424 _ => return true,
425 }
426 let rsp = guest.regs().await.rsp as usize;
427 let mut cells = [0u8; MAX_PRIVATE_CELLS_LEN];
428 rsp.checked_sub(MAX_PRIVATE_CELLS_LEN)
429 .and_then(|top| AddrMut::<u8>::from_raw(top & !7))
430 .is_some_and(|top| guest.memory().read_exact(top, &mut cells).is_ok())
431}
432
433async fn end_replayed_pselect6_under_its_temporary_mask<G, T>(
463 guest: &mut G,
464 temporary_mask: KernelSigset,
465) where
466 G: Guest<Detcore<T>>,
467 T: RecordOrReplay,
468{
469 let Ok(state) = read_thread_signal_state(guest.pid(), guest.tid()) else {
470 return;
471 };
472 if state.pending
473 & state.blocked
474 & state.interrupting(kernel_installed_signal_mask(temporary_mask))
475 == 0
476 {
477 return;
478 }
479 let Ok(Some(staged)) =
490 stage_private_cells(guest, PrivateCells::MaskAndZeroTimeout(temporary_mask), &[]).await
491 else {
492 return;
493 };
494 inject_signal_delivery(guest, staged.mask(), staged.after_mask()).await;
495 staged.release(guest);
496}
497
498async fn inject_signal_delivery<G, T>(guest: &mut G, mask: usize, zero_timeout: usize)
506where
507 G: Guest<Detcore<T>>,
508 T: RecordOrReplay,
509{
510 let _ = guest
511 .inject(
512 syscalls::Ppoll::new()
513 .with_fds(None)
514 .with_nfds(0)
515 .with_timeout(AddrMut::from_raw(zero_timeout))
516 .with_sigmask(Addr::from_raw(mask))
517 .with_sigsetsize(KERNEL_SIGSET_SIZE),
518 )
519 .await;
520}
521
522pub(super) fn pselect6_fd_set_len(nfds: i32) -> Result<usize, Errno> {
523 let nfds = usize::try_from(nfds).map_err(|_| Errno::EINVAL)?;
524 let bits_per_word = std::mem::size_of::<libc::c_ulong>() * 8;
525 Ok(nfds.div_ceil(bits_per_word) * std::mem::size_of::<libc::c_ulong>())
526}
527
528fn pselect6_probe_result(result: Result<i64, Errno>) -> Result<i64, Errno> {
529 match result {
530 Err(Errno::ERESTARTSYS) => Err(Errno::EINTR),
534 result => result,
535 }
536}
537
538pub(super) fn read_pselect6_fd_set<T, G>(
539 guest: &mut G,
540 address: Option<AddrMut<'_, libc::fd_set>>,
541 len: usize,
542) -> Result<Option<Vec<u8>>, Error>
543where
544 T: RecordOrReplay,
545 G: Guest<Detcore<T>>,
546{
547 let Some(address) = address else {
548 return Ok(None);
549 };
550 let mut bytes = vec![0; len];
551 if len != 0 {
552 guest
553 .memory()
554 .read_exact(address.cast(), &mut bytes)
555 .map_err(|_| Errno::EFAULT)?;
556 }
557 Ok(Some(bytes))
558}
559
560pub(super) fn write_pselect6_fd_set<T, G>(
561 guest: &mut G,
562 address: Option<AddrMut<'_, libc::fd_set>>,
563 bytes: &Option<Vec<u8>>,
564) -> Result<(), Error>
565where
566 T: RecordOrReplay,
567 G: Guest<Detcore<T>>,
568{
569 if let (Some(address), Some(bytes)) = (address, bytes)
570 && !bytes.is_empty()
571 {
572 guest
573 .memory()
574 .write_exact(address.cast(), bytes)
575 .map_err(|_| Errno::EFAULT)?;
576 }
577 Ok(())
578}
579
580fn copy_pselect6_fd_set<T, G>(
581 guest: &mut G,
582 source: Option<AddrMut<'_, libc::fd_set>>,
583 destination: Option<AddrMut<'_, libc::fd_set>>,
584 len: usize,
585) -> Result<(), Error>
586where
587 T: RecordOrReplay,
588 G: Guest<Detcore<T>>,
589{
590 if let (Some(source), Some(destination)) = (source, destination)
591 && len != 0
592 {
593 let mut bytes = vec![0; len];
594 guest
595 .memory()
596 .read_exact(source.cast(), &mut bytes)
597 .map_err(|_| Errno::EFAULT)?;
598 guest
599 .memory()
600 .write_exact(destination.cast(), &bytes)
601 .map_err(|_| Errno::EFAULT)?;
602 }
603 Ok(())
604}
605
606pub(super) fn ppoll_timeout_duration(timeout: Timespec) -> Result<Duration, Errno> {
607 let seconds = u64::try_from(timeout.tv_sec).map_err(|_| Errno::EINVAL)?;
608 let nanoseconds = u32::try_from(timeout.tv_nsec).map_err(|_| Errno::EINVAL)?;
609 if nanoseconds >= 1_000_000_000 {
610 return Err(Errno::EINVAL);
611 }
612 Ok(Duration::new(seconds, nanoseconds))
613}
614
615pub(super) fn select_timeout_duration(timeout: libc::timeval) -> Result<Duration, Errno> {
627 if timeout.tv_sec < 0 || timeout.tv_usec < 0 {
628 return Err(Errno::EINVAL);
629 }
630 let seconds = timeout
631 .tv_sec
632 .checked_add(timeout.tv_usec / 1_000_000)
633 .ok_or(Errno::EINVAL)?;
634 let nanoseconds = (timeout.tv_usec % 1_000_000) * 1_000;
635 Ok(Duration::new(seconds as u64, nanoseconds as u32))
636}
637
638fn timespec_from_duration(duration: Duration) -> Timespec {
639 Timespec {
640 tv_sec: duration.as_secs() as libc::time_t,
641 tv_nsec: duration.subsec_nanos() as libc::c_long,
642 }
643}
644
645const SCM_TIMESTAMP_OLD: libc::c_int = 29;
646const SCM_TIMESTAMPNS_OLD: libc::c_int = 35;
647const SCM_TIMESTAMPING_OLD: libc::c_int = 37;
648const SCM_TIMESTAMP_NEW: libc::c_int = 63;
649const SCM_TIMESTAMPNS_NEW: libc::c_int = 64;
650const SCM_TIMESTAMPING_NEW: libc::c_int = 65;
651const MAX_CONTROL_BYTES: usize = 64 * 1024;
652
653#[derive(Clone, Copy)]
654enum SocketTimestampKind {
655 Timeval,
656 Timespec,
657 Timestamping,
658}
659
660#[derive(Clone, Copy)]
661struct SocketTimestampMessage {
662 data_offset: usize,
663 available_data_len: usize,
664 kind: SocketTimestampKind,
665}
666
667fn cmsg_align(length: usize) -> usize {
668 let alignment = std::mem::size_of::<usize>();
669 (length + alignment - 1) & !(alignment - 1)
670}
671
672fn read_control_value<T: Copy>(bytes: &[u8]) -> Option<T> {
673 if bytes.len() < std::mem::size_of::<T>() {
674 return None;
675 }
676 Some(unsafe { bytes.as_ptr().cast::<T>().read_unaligned() })
679}
680
681fn write_control_value<T: Copy>(bytes: &mut [u8], value: T) -> bool {
682 if bytes.len() < std::mem::size_of::<T>() {
683 return false;
684 }
685 unsafe { bytes.as_mut_ptr().cast::<T>().write_unaligned(value) };
688 true
689}
690
691fn write_control_prefix<T: Copy>(bytes: &mut [u8], value: T) -> usize {
692 let value_len = std::mem::size_of::<T>();
693 let write_len = bytes.len().min(value_len);
694 let value_bytes =
697 unsafe { std::slice::from_raw_parts((&value as *const T).cast::<u8>(), value_len) };
698 bytes[..write_len].copy_from_slice(&value_bytes[..write_len]);
699 write_len
700}
701
702fn socket_timestamp_messages(control: &[u8]) -> Vec<SocketTimestampMessage> {
703 let header_len = cmsg_align(std::mem::size_of::<libc::cmsghdr>());
704 let mut messages = Vec::new();
705 let mut offset = 0usize;
706
707 while let Some(header_bytes) = control.get(offset..) {
708 let Some(header) = read_control_value::<libc::cmsghdr>(header_bytes) else {
709 break;
710 };
711 if header.cmsg_len < header_len {
712 break;
713 }
714 let Some(end) = offset.checked_add(header.cmsg_len) else {
715 break;
716 };
717
718 if header.cmsg_level == libc::SOL_SOCKET {
719 let data_offset = offset + header_len;
720 let declared_data_len = header.cmsg_len - header_len;
721 let available_data_len = control
722 .len()
723 .saturating_sub(data_offset)
724 .min(declared_data_len);
725 let kind = match header.cmsg_type {
726 SCM_TIMESTAMP_OLD | SCM_TIMESTAMP_NEW => Some(SocketTimestampKind::Timeval),
727 SCM_TIMESTAMPNS_OLD | SCM_TIMESTAMPNS_NEW => Some(SocketTimestampKind::Timespec),
728 SCM_TIMESTAMPING_OLD | SCM_TIMESTAMPING_NEW => {
729 Some(SocketTimestampKind::Timestamping)
730 }
731 _ => None,
732 };
733 if let Some(kind) = kind {
734 messages.push(SocketTimestampMessage {
735 data_offset,
736 available_data_len,
737 kind,
738 });
739 }
740 }
741
742 if end > control.len() {
743 break;
744 }
745
746 let step = cmsg_align(header.cmsg_len);
747 let Some(next) = offset.checked_add(step) else {
748 break;
749 };
750 if next <= offset {
751 break;
752 }
753 offset = next;
754 }
755 messages
756}
757
758fn canonicalize_socket_timestamps(control: &mut [u8], now: LogicalTime) -> usize {
761 let messages = socket_timestamp_messages(control);
762 let timespec = libc::timespec {
763 tv_sec: now.as_secs() as libc::time_t,
764 tv_nsec: now.subsec_nanos() as libc::c_long,
765 };
766 let timeval = libc::timeval {
767 tv_sec: timespec.tv_sec,
768 tv_usec: (timespec.tv_nsec / 1_000) as libc::suseconds_t,
769 };
770
771 for message in &messages {
772 let available_end = message
773 .data_offset
774 .saturating_add(message.available_data_len)
775 .min(control.len());
776 let data = &mut control[message.data_offset..available_end];
777 match message.kind {
778 SocketTimestampKind::Timeval => {
779 write_control_prefix(data, timeval);
780 }
781 SocketTimestampKind::Timespec => {
782 write_control_prefix(data, timespec);
783 }
784 SocketTimestampKind::Timestamping => {
785 let size = std::mem::size_of::<libc::timespec>();
786 let zero = libc::timespec {
787 tv_sec: 0,
788 tv_nsec: 0,
789 };
790 for slot in 0..3 {
791 let start = slot * size;
792 if start >= data.len() {
793 break;
794 }
795 let end = (start + size).min(data.len());
796 let slot_bytes = &mut data[start..end];
797 if slot_bytes.len() != size {
798 slot_bytes.fill(0);
799 continue;
800 }
801 let original = read_control_value::<libc::timespec>(slot_bytes)
802 .expect("complete timestamping slot");
803 let replacement = if original.tv_sec == 0 && original.tv_nsec == 0 {
804 zero
805 } else {
806 timespec
807 };
808 let _ = write_control_value(slot_bytes, replacement);
809 }
810 }
811 }
812 }
813 messages.len()
814}
815
816fn sanitize_ppoll_signal_mask(mask: u64) -> u64 {
817 let signal_bit = (reverie::PERF_EVENT_SIGNAL as usize) - 1;
818 mask & !(1_u64 << signal_bit)
819}
820
821fn ppoll_fds_range(call: syscalls::Ppoll) -> Option<std::ops::Range<usize>> {
823 call.fds().map(|fds| {
824 let start = fds.as_raw();
825 let len = usize::try_from(call.nfds())
826 .unwrap_or(usize::MAX)
827 .saturating_mul(std::mem::size_of::<libc::pollfd>());
828 start..start.saturating_add(len)
829 })
830}
831
832fn ppoll_uses_kernel_wait(sequentialize_threads: bool, recordreplay_modes: bool) -> bool {
837 !sequentialize_threads || recordreplay_modes
838}
839
840impl<T: RecordOrReplay> Detcore<T> {
841 pub async fn handle_poll<G: Guest<Self>>(
844 &self,
845 guest: &mut G,
846
847 call: syscalls::Poll,
848 ) -> Result<i64, Error> {
849 if self.cfg.sequentialize_threads && call.timeout() == 0 {
850 let yield_to_peer = self.cfg.backend.loopback_pollers_yield_to_peers
853 && guest.thread_state().has_loopback_peer();
854 resource_request(
855 guest,
856 zero_timeout_poll_request(guest.thread_state().dettid, yield_to_peer),
857 )
858 .await;
859 if self.cfg.recordreplay_modes {
860 Ok(self.record_or_replay(guest, call).await?)
861 } else {
862 crate::syscalls::timerfd::publish_expired(guest).await;
865 Ok(guest.inject(call).await?)
866 }
867 } else if !self.cfg.sequentialize_threads || self.cfg.recordreplay_modes {
868 Ok(self.handle_external_poll(guest, call).await?)
871 } else {
872 self.handle_internal_poll(guest, call).await
875 }
876 }
877
878 async fn record_or_replay_select_family<G: Guest<Self>>(
884 &self,
885 guest: &mut G,
886 call: Syscall,
887 zero_timeout: bool,
888 ) -> Result<i64, Error> {
889 if zero_timeout {
890 resource_request(guest, Resources::new(guest.thread_state().dettid)).await;
891 Ok(self.record_or_replay(guest, call).await?)
892 } else {
893 self.record_or_replay_blocking(guest, call).await
894 }
895 }
896
897 async fn refuse_unstageable_pselect6_mask<G: Guest<Self>>(
913 &self,
914 guest: &mut G,
915 call: syscalls::Pselect6,
916 ) -> Result<i64, Error> {
917 use std::io::Write as _;
918 let message = "unsupported: pselect6 with a temporary signal mask, on a stack with \
919 no room below its red zone whose red zone the call's own buffers fill: Hermit \
920 has nowhere to put the private copy of the mask the kernel must install \
921 (https://github.com/rrnewton/hermit/pull/4053)";
922 tracing::error!("[tid {}] {message}", guest.tid());
923 if self.cfg.panic_on_unsupported_syscalls {
924 let _ = writeln!(crate::util::RetryingStderr, "{message}");
925 return self
926 .refuse_unserviceable_operation(guest, Sysno::pselect6, Errno::EFAULT)
927 .await;
928 }
929 self.record_or_replay_blocking_with_unknown_mask(guest, Syscall::Pselect6(call))
930 .await
931 }
932
933 async fn refuse_undeliverable_pselect6_mask<G: Guest<Self>>(
942 &self,
943 guest: &mut G,
944 ) -> Option<Result<i64, Error>> {
945 use std::io::Write as _;
946 let message = "unsupported: pselect6 with a temporary signal mask on a stack less than \
947 24 bytes above unwritable memory: replay has nowhere to deliver a signal that \
948 interrupts it (https://github.com/rrnewton/hermit/issues/4112)";
949 tracing::error!("[tid {}] {message}", guest.tid());
950 if !self.cfg.panic_on_unsupported_syscalls {
951 return None;
952 }
953 let _ = writeln!(crate::util::RetryingStderr, "{message}");
954 Some(
955 self.refuse_unserviceable_operation(guest, Sysno::pselect6, Errno::EFAULT)
956 .await,
957 )
958 }
959
960 async fn record_or_replay_pselect6_under_a_private_mask<G: Guest<Self>>(
966 &self,
967 guest: &mut G,
968 call: syscalls::Pselect6,
969 mask: KernelSigset,
970 ) -> Result<Result<i64, Error>, Error> {
971 let set_len = pselect6_fd_set_len(call.nfds()).unwrap_or(0);
972 let live: Vec<std::ops::Range<usize>> = [
973 call.readfds().map(|set| (set.as_raw(), set_len)),
974 call.writefds().map(|set| (set.as_raw(), set_len)),
975 call.exceptfds().map(|set| (set.as_raw(), set_len)),
976 call.timeout()
977 .map(|timeout| (timeout.as_raw(), std::mem::size_of::<Timespec>())),
978 ]
979 .into_iter()
980 .flatten()
981 .map(|(start, len)| start..start.saturating_add(len))
982 .collect();
983 let Some(staged) =
984 stage_private_cells(guest, PrivateCells::Pselect6Mask(mask), &live).await?
985 else {
986 return Ok(self.refuse_unstageable_pselect6_mask(guest, call).await);
987 };
988 let result = self
989 .record_or_replay_blocking_with_unknown_mask(
990 guest,
991 Syscall::Pselect6(call.with_sigmask(Addr::from_raw(staged.after_mask()))),
992 )
993 .await;
994 staged.release(guest);
995 Ok(result)
996 }
997
998 pub async fn handle_pselect6<G: Guest<Self>>(
1002 &self,
1003 guest: &mut G,
1004 call: syscalls::Pselect6,
1005 ) -> Result<i64, Error> {
1006 if self.cfg.recordreplay_modes {
1007 let zero_timeout = call.timeout().is_some_and(|timeout| {
1008 guest
1009 .memory()
1010 .read_value(timeout)
1011 .is_ok_and(|timeout: Timespec| timeout.tv_sec == 0 && timeout.tv_nsec == 0)
1012 });
1013 if !replayed_pselect6_delivery_fits(guest, call).await
1038 && let Some(refused) = self.refuse_undeliverable_pselect6_mask(guest).await
1039 {
1040 return refused;
1041 }
1042 let read_mask = self.cfg.replaying && call.sigmask().is_some();
1043 let mut temporary_mask = None;
1044 let result = if call.sigmask().is_some() && !zero_timeout {
1045 let entry_mask = entry_pselect6_temporary_mask(guest, call).await;
1049 if read_mask {
1050 temporary_mask = entry_mask;
1051 }
1052 match entry_mask {
1053 Some(mask) => {
1054 self.record_or_replay_pselect6_under_a_private_mask(guest, call, mask)
1055 .await?
1056 }
1057 None => {
1058 self.record_or_replay_blocking_with_unknown_mask(
1059 guest,
1060 Syscall::Pselect6(call),
1061 )
1062 .await
1063 }
1064 }
1065 } else if zero_timeout {
1066 resource_request(guest, Resources::new(guest.thread_state().dettid)).await;
1067 if read_mask {
1068 temporary_mask = replayed_pselect6_temporary_mask(guest, call);
1069 }
1070 self.record_or_replay(guest, Syscall::Pselect6(call))
1071 .await
1072 .map_err(Into::into)
1073 } else {
1074 self.record_or_replay_blocking(guest, Syscall::Pselect6(call))
1075 .await
1076 };
1077 if let Some(mask) = temporary_mask
1078 && matches!(result, Err(Error::Errno(Errno::ERESTARTNOHAND)))
1079 {
1080 end_replayed_pselect6_under_its_temporary_mask(guest, mask).await;
1081 }
1082 return result;
1083 }
1084 if !self.cfg.sequentialize_threads {
1085 return Ok(guest.inject(call).await?);
1086 }
1087
1088 if call.nfds() < 0 {
1089 return Ok(guest.inject(call).await?);
1090 }
1091
1092 let sigmask_argument = match call.sigmask() {
1096 Some(argument) => {
1097 let mut stack = guest.stack().await;
1103 let validation_timeout = stack.reserve::<Timespec>();
1104 let _guard = stack.commit()?;
1105 guest.memory().write_value(
1106 validation_timeout,
1107 &Timespec {
1108 tv_sec: 0,
1109 tv_nsec: 1_000_000_000,
1110 },
1111 )?;
1112 let validation = syscalls::Pselect6::new()
1113 .with_nfds(0)
1114 .with_readfds(None)
1115 .with_writefds(None)
1116 .with_exceptfds(None)
1117 .with_timeout(Some(validation_timeout))
1118 .with_sigmask(Some(argument));
1119 match guest.inject(validation).await {
1120 Err(Errno::EINVAL) => {}
1121 Err(errno) => {
1124 return crate::syscalls::signal::restart_if_first_probe_not_run(Err(
1125 errno.into()
1126 ));
1127 }
1128 Ok(_) => return Err(Errno::EIO.into()),
1130 }
1131 let argument: Pselect6SigmaskArg = guest.memory().read_value(argument.cast())?;
1132 Some(argument)
1133 }
1134 None => None,
1135 };
1136 let raw_timeout = match call.timeout() {
1137 Some(timeout) => {
1138 let timeout: Timespec = guest.memory().read_value(timeout)?;
1139 Some(timeout)
1140 }
1141 None => None,
1142 };
1143 let timeout = raw_timeout.map(ppoll_timeout_duration).transpose()?;
1144 if let Some(argument) = sigmask_argument
1145 && argument.sigmask != 0
1146 {
1147 self.observe_under_temporary_mask(
1148 guest,
1149 Addr::<libc::sigset_t>::from_raw(argument.sigmask),
1150 argument.sigsetsize,
1151 )
1152 .await?;
1153 }
1154 if timeout == Some(Duration::ZERO) {
1155 crate::syscalls::timerfd::publish_expired(guest).await;
1158 return Ok(guest.inject(call).await?);
1159 }
1160
1161 if call.nfds() > PSELECT6_INTERNAL_MAX_NFDS {
1166 let snapshot = match sigmask_argument {
1172 Some(argument)
1173 if argument.sigmask != 0 && argument.sigsetsize == KERNEL_SIGSET_SIZE =>
1174 {
1175 match Addr::<libc::sigset_t>::from_raw(argument.sigmask) {
1176 Some(mask_addr) => {
1177 let mask = read_kernel_sigset(guest, mask_addr).await.ok();
1178 if let Some(mask) = mask {
1179 super::signal_shadow::note_wait_mask(guest, mask);
1180 }
1181 mask
1182 }
1183 None => None,
1184 }
1185 }
1186 _ => None,
1187 };
1188 let Some(mask) = snapshot else {
1189 return self
1190 .record_or_replay_blocking_with_mask(guest, Syscall::Pselect6(call), None)
1191 .await;
1192 };
1193 let set_len = pselect6_fd_set_len(call.nfds())?;
1204 let live: Vec<std::ops::Range<usize>> = [
1205 call.readfds().map(|set| (set.as_raw(), set_len)),
1206 call.writefds().map(|set| (set.as_raw(), set_len)),
1207 call.exceptfds().map(|set| (set.as_raw(), set_len)),
1208 call.timeout()
1209 .map(|timeout| (timeout.as_raw(), std::mem::size_of::<Timespec>())),
1210 ]
1211 .into_iter()
1212 .flatten()
1213 .map(|(start, len)| start..start.saturating_add(len))
1214 .collect();
1215 let Some(staged) =
1216 stage_private_cells(guest, PrivateCells::Pselect6Mask(mask), &live).await?
1217 else {
1218 return self.refuse_unstageable_pselect6_mask(guest, call).await;
1219 };
1220 let result = self
1221 .record_or_replay_blocking_with_mask(
1222 guest,
1223 Syscall::Pselect6(call.with_sigmask(Addr::from_raw(staged.after_mask()))),
1224 Some(kernel_installed_signal_mask(mask)),
1225 )
1226 .await;
1227 staged.release(guest);
1228 return result;
1229 }
1230
1231 let sigmask = if let Some(argument) = sigmask_argument {
1241 if argument.sigmask != 0 {
1242 if argument.sigsetsize != KERNEL_SIGSET_SIZE {
1243 return Err(Errno::EINVAL.into());
1244 }
1245 let mask_addr =
1246 Addr::<libc::sigset_t>::from_raw(argument.sigmask).ok_or(Errno::EFAULT)?;
1247 let mask = read_kernel_sigset(guest, mask_addr).await?;
1248 super::signal_shadow::note_wait_mask(guest, mask);
1249 Some(sanitize_ppoll_signal_mask(mask))
1250 } else {
1251 None
1252 }
1253 } else {
1254 None
1255 };
1256 let call = call.with_sigmask(None);
1259
1260 self.handle_internal_pselect6(guest, call, timeout, sigmask)
1261 .await
1262 }
1263
1264 async fn handle_internal_pselect6<G: Guest<Self>>(
1265 &self,
1266 guest: &mut G,
1267 call: syscalls::Pselect6,
1268 timeout: Option<Duration>,
1269 sigmask: Option<u64>,
1270 ) -> Result<i64, Error> {
1271 let len = pselect6_fd_set_len(call.nfds())?;
1272 let deadline = match timeout {
1273 Some(timeout) => Some(thread_observe_time(guest).await + timeout),
1274 None => None,
1275 };
1276 let original_readfds = match read_pselect6_fd_set(guest, call.readfds(), len) {
1277 Ok(value) => value,
1278 Err(error) => {
1279 self.write_pselect6_remaining(guest, call, deadline).await?;
1280 return Err(error);
1281 }
1282 };
1283 let original_writefds = match read_pselect6_fd_set(guest, call.writefds(), len) {
1284 Ok(value) => value,
1285 Err(error) => {
1286 self.write_pselect6_remaining(guest, call, deadline).await?;
1287 return Err(error);
1288 }
1289 };
1290 let original_exceptfds = match read_pselect6_fd_set(guest, call.exceptfds(), len) {
1291 Ok(value) => value,
1292 Err(error) => {
1293 self.write_pselect6_remaining(guest, call, deadline).await?;
1294 return Err(error);
1295 }
1296 };
1297
1298 let mut stack = guest.stack().await;
1299 let readfds = call.readfds().map(|_| stack.reserve::<libc::fd_set>());
1300 let writefds = call.writefds().map(|_| stack.reserve::<libc::fd_set>());
1301 let exceptfds = call.exceptfds().map(|_| stack.reserve::<libc::fd_set>());
1302 let probe_timeout = stack.reserve::<Timespec>();
1306 let kernel_signal_wait = self.cfg.backend.supports_blocked_wait_signal_interruption;
1314 let probe_sigmask = sigmask.filter(|_| !kernel_signal_wait).map(|mask| {
1315 let sigset = stack.push(mask);
1316 stack
1317 .push(Pselect6SigmaskArg {
1318 sigmask: sigset.as_raw(),
1319 sigsetsize: KERNEL_SIGSET_SIZE,
1320 })
1321 .cast()
1322 });
1323 let mut signals = kernel_signal_wait.then(|| {
1337 KernelSignalWait::for_select(guest)
1338 .with_wait_mask(sigmask.map(crate::syscalls::signal::kernel_installed_signal_mask))
1339 });
1340 let mut deliver_under_temporary_mask = false;
1344 let mask_cell = signals.as_ref().map(|_| stack.reserve::<KernelSigset>());
1345 let timerfd_scratch = crate::syscalls::timerfd::reserve_scratch(&mut stack);
1349 let _guard = stack.commit()?;
1350 let mut published = PublishedWaitMask::default();
1353 if let Some(signals) = signals.as_ref() {
1354 publish_wait_mask(guest, signals.effective_mask(), &mut published).await;
1355 }
1356 let probe = call
1357 .with_readfds(readfds)
1358 .with_writefds(writefds)
1359 .with_exceptfds(exceptfds)
1360 .with_timeout(Some(probe_timeout))
1361 .with_sigmask(probe_sigmask);
1362
1363 let mut resources = Resources::new(guest.thread_state().dettid);
1364 resources.insert(ResourceID::InternalIOPolling, Permission::W);
1365 resources.fyi("pselect6");
1366 resources.poll_deadline = poll_deadline_for(guest, deadline);
1367 resources.set_signal_interrupt_errno(Errno::EINTR);
1371
1372 let result: Result<i64, Error> = {
1375 let guest = &mut *guest;
1378 let signals = &mut signals;
1379 let resources = &mut resources;
1380 let published = &mut published;
1381 let deliver_under_temporary_mask = &mut deliver_under_temporary_mask;
1382 async move {
1383 loop {
1384 let signaled = matches!(
1385 resource_request(guest, resources.clone()).await,
1386 ResumeStatus::Signaled(_)
1387 );
1388 let next_timerfd =
1390 crate::syscalls::timerfd::publish_expired_in(guest, Some(timerfd_scratch))
1391 .await;
1392 resources.poll_deadline =
1393 crate::syscalls::timerfd::poll_deadline_with(guest, deadline, next_timerfd);
1394 let pending = pending_real_time_among(guest, REAL_TIME_SIGNALS).await;
1398 if pending != 0 {
1399 let (observable, discarded) = match (signals.as_ref(), sigmask) {
1400 (Some(signals), _) => (signals.observable_now()?, 0),
1401 (None, Some(mask)) => unblocked_by(
1402 &read_thread_wait_signal_state(guest.pid(), guest.tid())?,
1403 mask,
1404 ),
1405 (None, None) => (0, 0),
1406 };
1407 act_on_pending_real_time(guest, pending, observable, discarded).await;
1408 }
1409 if signals.is_none() && signaled {
1421 self.write_pselect6_remaining(guest, call, deadline).await?;
1422 return Err(Errno::EINTR.into());
1423 }
1424 guest.memory().write_value(
1425 probe_timeout,
1426 &Timespec {
1427 tv_sec: 0,
1428 tv_nsec: 0,
1429 },
1430 )?;
1431 write_pselect6_fd_set(guest, probe.readfds(), &original_readfds)?;
1432 write_pselect6_fd_set(guest, probe.writefds(), &original_writefds)?;
1433 write_pselect6_fd_set(guest, probe.exceptfds(), &original_exceptfds)?;
1434
1435 let raw_result = match signals.as_mut() {
1436 Some(signals) => match signals.inject_first_probe(guest, probe).await {
1443 Ok(result) => result,
1444 Err(error) => {
1445 self.write_pselect6_remaining(guest, call, deadline).await?;
1446 break Err(error);
1447 }
1448 },
1449 None => guest.inject(probe).await,
1450 };
1451 let result = pselect6_probe_result(raw_result);
1452 if result != Ok(0) {
1453 let copy_result = if result.is_ok() {
1454 self.copy_pselect6_results(guest, probe, call, len)
1455 } else {
1456 Ok(())
1457 };
1458 self.write_pselect6_remaining(guest, call, deadline).await?;
1459 copy_result?;
1460 break result.map_err(Into::into);
1461 }
1462 if let Some(signals) = signals.as_ref() {
1468 match signals.interrupted_with_state() {
1469 Ok((false, _)) => {}
1470 Ok((true, state)) => {
1471 self.write_pselect6_remaining(guest, call, deadline).await?;
1472 *deliver_under_temporary_mask = !signals.holds_signal()
1478 && signals.interrupts_only_under_wait_mask(&state);
1479 break Err(Errno::ERESTARTNOHAND.into());
1480 }
1481 Err(error) => break Err(error),
1482 }
1483 }
1484 if let Some(signals) = signals.as_mut()
1485 && signals.needs_block()
1486 && let Err(error) = signals.block(guest, mask_cell).await
1487 {
1488 self.write_pselect6_remaining(guest, call, deadline).await?;
1489 break Err(error);
1490 }
1491 if let Some(signals) = signals.as_ref() {
1492 publish_wait_mask(guest, signals.effective_mask(), published).await;
1493 }
1494
1495 resources.poll_attempt += 1;
1496 if let Some(deadline) = deadline
1497 && thread_observe_time(guest).await >= deadline
1498 {
1499 let copy_result = self.copy_pselect6_results(guest, probe, call, len);
1500 self.write_pselect6_remaining(guest, call, Some(deadline))
1501 .await?;
1502 copy_result?;
1503 break Ok(0);
1504 }
1505 trace!(
1506 "Retry #{} for syscall due to result Ok(0): {}",
1507 resources.poll_attempt,
1508 probe.display(&guest.memory())
1509 );
1510 record_retry_event(guest, probe).await;
1511 }
1512 }
1513 .await
1514 };
1515 let result = match &mut signals {
1516 Some(signals) => {
1517 let restored = signals.restore(guest, mask_cell).await;
1518 publish_wait_mask(guest, None, &mut published).await;
1519 result_after_restore(restored, result)?
1520 }
1521 None => result,
1522 };
1523 if deliver_under_temporary_mask
1526 && !signals.as_ref().is_some_and(KernelSignalWait::holds_signal)
1527 && let Some(mask) = sigmask
1528 && matches!(result, Err(Error::Errno(Errno::ERESTARTNOHAND)))
1529 {
1530 drop(_guard);
1549 match stage_private_cells(guest, PrivateCells::MaskAndZeroTimeout(mask), &[]).await? {
1555 Some(staged) => {
1556 inject_signal_delivery(guest, staged.mask(), staged.after_mask()).await;
1557 staged.release(guest);
1558 }
1559 None => tracing::warn!(
1560 "[tid {}] no room to deliver a pselect6 signal under its temporary mask; \
1561 its handler runs only once the guest unblocks it",
1562 guest.tid()
1563 ),
1564 }
1565 }
1566 refuse_held_signal_loss(guest, Sysno::pselect6, result).await
1567 }
1568
1569 fn copy_pselect6_results<G: Guest<Self>>(
1570 &self,
1571 guest: &mut G,
1572 probe: syscalls::Pselect6,
1573 call: syscalls::Pselect6,
1574 len: usize,
1575 ) -> Result<(), Error> {
1576 copy_pselect6_fd_set(guest, probe.readfds(), call.readfds(), len)?;
1577 copy_pselect6_fd_set(guest, probe.writefds(), call.writefds(), len)?;
1578 copy_pselect6_fd_set(guest, probe.exceptfds(), call.exceptfds(), len)
1579 }
1580
1581 pub(super) async fn write_pselect6_remaining<G: Guest<Self>>(
1582 &self,
1583 guest: &mut G,
1584 call: syscalls::Pselect6,
1585 deadline: Option<LogicalTime>,
1586 ) -> Result<(), Error> {
1587 if let (Some(timeout), Some(deadline)) = (call.timeout(), deadline) {
1588 let now = thread_observe_time(guest).await;
1589 let remaining = deadline.as_nanos().saturating_sub(now.as_nanos());
1590 let remaining = Timespec {
1591 tv_sec: (remaining / 1_000_000_000) as libc::time_t,
1592 tv_nsec: (remaining % 1_000_000_000) as libc::c_long,
1593 };
1594 if let Err(error) = guest.memory().write_value(timeout, &remaining) {
1598 trace!(?error, "ignoring pselect6 timeout writeback failure");
1600 }
1601 }
1602 Ok(())
1603 }
1604
1605 pub async fn handle_select<G: Guest<Self>>(
1614 &self,
1615 guest: &mut G,
1616 call: syscalls::Select,
1617 ) -> Result<i64, Error> {
1618 if self.cfg.recordreplay_modes {
1619 let zero_timeout = call.timeout().is_some_and(|timeout| {
1620 guest
1621 .memory()
1622 .read_value(timeout)
1623 .is_ok_and(|timeout: libc::timeval| timeout.tv_sec == 0 && timeout.tv_usec == 0)
1624 });
1625 return self
1626 .record_or_replay_select_family(guest, Syscall::Select(call), zero_timeout)
1627 .await;
1628 }
1629 if !self.cfg.sequentialize_threads {
1630 return Ok(guest.inject(call).await?);
1631 }
1632
1633 if call.nfds() < 0 {
1634 return Ok(guest.inject(call).await?);
1635 }
1636
1637 let raw_timeout = match call.timeout() {
1638 Some(timeout) => {
1639 let timeout: libc::timeval = guest.memory().read_value(timeout)?;
1640 Some(timeout)
1641 }
1642 None => None,
1643 };
1644 if matches!(raw_timeout, Some(timeout) if timeout.tv_sec == 0 && timeout.tv_usec == 0) {
1645 crate::syscalls::timerfd::publish_expired(guest).await;
1649 return Ok(guest.inject(call).await?);
1650 }
1651
1652 if call.nfds() > PSELECT6_INTERNAL_MAX_NFDS {
1655 return self
1656 .record_or_replay_blocking(guest, Syscall::Select(call))
1657 .await;
1658 }
1659
1660 let timeout = raw_timeout.map(select_timeout_duration).transpose()?;
1661 self.handle_internal_select(guest, call, timeout).await
1662 }
1663
1664 async fn handle_internal_select<G: Guest<Self>>(
1665 &self,
1666 guest: &mut G,
1667 call: syscalls::Select,
1668 timeout: Option<Duration>,
1669 ) -> Result<i64, Error> {
1670 let len = pselect6_fd_set_len(call.nfds())?;
1671 let deadline = match timeout {
1672 Some(timeout) => Some(thread_observe_time(guest).await + timeout),
1673 None => None,
1674 };
1675 let original_readfds = match read_pselect6_fd_set(guest, call.readfds(), len) {
1676 Ok(value) => value,
1677 Err(error) => {
1678 self.write_select_remaining(guest, call, deadline).await?;
1679 return Err(error);
1680 }
1681 };
1682 let original_writefds = match read_pselect6_fd_set(guest, call.writefds(), len) {
1683 Ok(value) => value,
1684 Err(error) => {
1685 self.write_select_remaining(guest, call, deadline).await?;
1686 return Err(error);
1687 }
1688 };
1689 let original_exceptfds = match read_pselect6_fd_set(guest, call.exceptfds(), len) {
1690 Ok(value) => value,
1691 Err(error) => {
1692 self.write_select_remaining(guest, call, deadline).await?;
1693 return Err(error);
1694 }
1695 };
1696
1697 let mut stack = guest.stack().await;
1698 let readfds = call.readfds().map(|_| stack.reserve::<libc::fd_set>());
1699 let writefds = call.writefds().map(|_| stack.reserve::<libc::fd_set>());
1700 let exceptfds = call.exceptfds().map(|_| stack.reserve::<libc::fd_set>());
1701 let probe_timeout = stack.reserve::<libc::timeval>();
1705 let mut signals = self
1715 .cfg
1716 .backend
1717 .supports_blocked_wait_signal_interruption
1718 .then(|| KernelSignalWait::for_select(guest));
1719 let mask_cell = signals.as_ref().map(|_| stack.reserve::<KernelSigset>());
1720 let timerfd_scratch = crate::syscalls::timerfd::reserve_scratch(&mut stack);
1724 let _guard = stack.commit()?;
1725 let mut published = PublishedWaitMask::default();
1728 if let Some(signals) = signals.as_ref() {
1729 publish_wait_mask(guest, signals.effective_mask(), &mut published).await;
1730 }
1731 let probe = call
1732 .with_readfds(readfds)
1733 .with_writefds(writefds)
1734 .with_exceptfds(exceptfds)
1735 .with_timeout(Some(probe_timeout));
1736
1737 let mut resources = Resources::new(guest.thread_state().dettid);
1738 resources.insert(ResourceID::InternalIOPolling, Permission::W);
1739 resources.fyi("select");
1740 resources.poll_deadline = poll_deadline_for(guest, deadline);
1741 resources.set_signal_interrupt_errno(Errno::EINTR);
1745
1746 let result: Result<i64, Error> = {
1749 let guest = &mut *guest;
1752 let signals = &mut signals;
1753 let resources = &mut resources;
1754 let published = &mut published;
1755 async move {
1756 loop {
1757 let signaled = matches!(
1758 resource_request(guest, resources.clone()).await,
1759 ResumeStatus::Signaled(_)
1760 );
1761 let next_timerfd =
1763 crate::syscalls::timerfd::publish_expired_in(guest, Some(timerfd_scratch))
1764 .await;
1765 resources.poll_deadline =
1766 crate::syscalls::timerfd::poll_deadline_with(guest, deadline, next_timerfd);
1767 let pending = pending_real_time_among(guest, REAL_TIME_SIGNALS).await;
1770 if pending != 0
1771 && let Some(signals) = signals.as_ref()
1772 {
1773 let observable = signals.observable_now()?;
1774 act_on_pending_real_time(guest, pending, observable, 0).await;
1775 }
1776 if signals.is_none() && signaled {
1788 self.write_select_remaining(guest, call, deadline).await?;
1789 return Err(Errno::EINTR.into());
1790 }
1791 guest.memory().write_value(
1792 probe_timeout,
1793 &libc::timeval {
1794 tv_sec: 0,
1795 tv_usec: 0,
1796 },
1797 )?;
1798 write_pselect6_fd_set(guest, probe.readfds(), &original_readfds)?;
1799 write_pselect6_fd_set(guest, probe.writefds(), &original_writefds)?;
1800 write_pselect6_fd_set(guest, probe.exceptfds(), &original_exceptfds)?;
1801
1802 let result = match signals.as_mut() {
1803 Some(signals) => match signals.inject_first_probe(guest, probe).await {
1810 Ok(result) => result,
1811 Err(error) => {
1812 self.write_select_remaining(guest, call, deadline).await?;
1813 break Err(error);
1814 }
1815 },
1816 None => guest.inject(probe).await,
1817 };
1818 if result != Ok(0) {
1819 let copy_result = if result.is_ok() {
1820 self.copy_select_results(guest, probe, call, len)
1821 } else {
1822 Ok(())
1823 };
1824 self.write_select_remaining(guest, call, deadline).await?;
1825 copy_result?;
1826 break result.map_err(Into::into);
1827 }
1828 if let Some(signals) = signals.as_ref() {
1834 match signals.interrupted_with_state() {
1835 Ok((false, _)) => {}
1836 Ok((true, _)) => {
1837 self.write_select_remaining(guest, call, deadline).await?;
1838 break Err(Errno::ERESTARTNOHAND.into());
1839 }
1840 Err(error) => break Err(error),
1841 }
1842 }
1843 if let Some(signals) = signals.as_mut()
1844 && signals.needs_block()
1845 && let Err(error) = signals.block(guest, mask_cell).await
1846 {
1847 self.write_select_remaining(guest, call, deadline).await?;
1848 break Err(error);
1849 }
1850 if let Some(signals) = signals.as_ref() {
1851 publish_wait_mask(guest, signals.effective_mask(), published).await;
1852 }
1853
1854 resources.poll_attempt += 1;
1855 if let Some(deadline) = deadline
1856 && thread_observe_time(guest).await >= deadline
1857 {
1858 let copy_result = self.copy_select_results(guest, probe, call, len);
1859 self.write_select_remaining(guest, call, Some(deadline))
1860 .await?;
1861 copy_result?;
1862 break Ok(0);
1863 }
1864 trace!(
1865 "Retry #{} for syscall due to result Ok(0): {}",
1866 resources.poll_attempt,
1867 probe.display(&guest.memory())
1868 );
1869 record_retry_event(guest, probe).await;
1870 }
1871 }
1872 .await
1873 };
1874 let result = match &mut signals {
1875 Some(signals) => {
1876 let restored = signals.restore(guest, mask_cell).await;
1877 publish_wait_mask(guest, None, &mut published).await;
1878 result_after_restore(restored, result)?
1879 }
1880 None => result,
1881 };
1882 refuse_held_signal_loss(guest, Sysno::select, result).await
1883 }
1884
1885 fn copy_select_results<G: Guest<Self>>(
1886 &self,
1887 guest: &mut G,
1888 probe: syscalls::Select,
1889 call: syscalls::Select,
1890 len: usize,
1891 ) -> Result<(), Error> {
1892 copy_pselect6_fd_set(guest, probe.readfds(), call.readfds(), len)?;
1893 copy_pselect6_fd_set(guest, probe.writefds(), call.writefds(), len)?;
1894 copy_pselect6_fd_set(guest, probe.exceptfds(), call.exceptfds(), len)
1895 }
1896
1897 pub(super) async fn write_select_remaining<G: Guest<Self>>(
1898 &self,
1899 guest: &mut G,
1900 call: syscalls::Select,
1901 deadline: Option<LogicalTime>,
1902 ) -> Result<(), Error> {
1903 if let (Some(timeout), Some(deadline)) = (call.timeout(), deadline) {
1904 let now = thread_observe_time(guest).await;
1905 let remaining = deadline.as_nanos().saturating_sub(now.as_nanos());
1906 let remaining = libc::timeval {
1907 tv_sec: (remaining / 1_000_000_000) as libc::time_t,
1908 tv_usec: ((remaining % 1_000_000_000) / 1_000) as libc::suseconds_t,
1909 };
1910 if let Err(error) = guest.memory().write_value(timeout, &remaining) {
1913 trace!(?error, "ignoring select timeout writeback failure");
1915 }
1916 }
1917 Ok(())
1918 }
1919
1920 pub async fn handle_ppoll<G: Guest<Self>>(
1923 &self,
1924 guest: &mut G,
1925 call: syscalls::Ppoll,
1926 ) -> Result<i64, Error> {
1927 let timeout_address = call.timeout();
1928 let timeout = match timeout_address {
1929 Some(timeout) => Some(ppoll_timeout_duration(guest.memory().read_value(timeout)?)?),
1930 None => None,
1931 };
1932
1933 let result: Result<i64, Error> = if timeout == Some(Duration::ZERO) {
1934 if self.cfg.recordreplay_modes {
1935 resource_request(guest, Resources::new(guest.thread_state().dettid)).await;
1936 } else {
1937 crate::syscalls::timerfd::publish_expired(guest).await;
1941 }
1942 let (probe, staged) = match self.prepare_ppoll_probe(guest, call, false).await? {
1945 Some((probe, staged)) => (probe, Some(staged)),
1946 None => {
1947 if let Some(refused) = self.refuse_unstageable_ppoll_copy(guest).await {
1948 return refused;
1949 }
1950 (call, None)
1952 }
1953 };
1954 let temporary_mask = if self.cfg.replaying {
1957 match call.sigmask() {
1958 Some(signal_mask) => read_kernel_sigset(guest, signal_mask)
1959 .await
1960 .ok()
1961 .map(sanitize_ppoll_signal_mask),
1962 None => None,
1963 }
1964 } else {
1965 None
1966 };
1967 if let Some(mask) = temporary_mask {
1968 super::signal_shadow::note_wait_mask(guest, mask);
1969 }
1970 let result: Result<i64, Error> = if self.cfg.recordreplay_modes {
1973 self.record_or_replay(guest, probe)
1974 .await
1975 .map_err(Into::into)
1976 } else {
1977 guest.inject_with_retry(probe).await.map_err(Into::into)
1978 };
1979 if let Some(staged) = staged {
1980 staged.release(guest);
1981 }
1982 if let Some(mask) = temporary_mask
1986 && matches!(result, Err(Error::Errno(Errno::ERESTARTNOHAND)))
1987 {
1988 end_replayed_pselect6_under_its_temporary_mask(guest, mask).await;
1989 }
1990 result
1994 } else if ppoll_uses_kernel_wait(
1995 self.cfg.sequentialize_threads,
1996 self.cfg.recordreplay_modes,
1997 ) {
1998 let mut staged = None;
2002 let mut blocked_signal_mask = None;
2005 let mut temporary_mask = None;
2007 let call = if let Some(signal_mask) = call.sigmask() {
2008 if call.sigsetsize() != KERNEL_SIGSET_SIZE {
2009 return Err(Errno::EINVAL.into());
2010 }
2011 let signal_mask = crate::syscalls::signal::restart_if_first_probe_not_run(
2012 read_kernel_sigset(guest, signal_mask).await,
2013 )?;
2014 super::signal_shadow::note_wait_mask(guest, signal_mask);
2015 let signal_mask = sanitize_ppoll_signal_mask(signal_mask);
2016 blocked_signal_mask = Some(kernel_installed_signal_mask(signal_mask));
2017 temporary_mask = Some(signal_mask);
2018 let live: Vec<std::ops::Range<usize>> = ppoll_fds_range(call)
2021 .into_iter()
2022 .chain(call.timeout().map(|timeout| {
2023 let start = timeout.as_raw();
2024 start..start.saturating_add(std::mem::size_of::<Timespec>())
2025 }))
2026 .collect();
2027 match stage_private_cells(guest, PrivateCells::Mask(signal_mask), &live).await? {
2028 Some(cells) => {
2029 let mask = cells.mask();
2030 staged = Some(cells);
2031 call.with_sigmask(Addr::from_raw(mask))
2032 }
2033 None => {
2034 if let Some(refused) = self.refuse_unstageable_ppoll_copy(guest).await {
2035 return refused;
2036 }
2037 call
2042 }
2043 }
2044 } else {
2045 call
2046 };
2047 let result: Result<i64, Error> =
2056 if self.cfg.recordreplay_modes && temporary_mask.is_some() {
2057 self.record_or_replay_blocking_with_unknown_mask(guest, Syscall::Ppoll(call))
2058 .await
2059 } else {
2060 self.record_or_replay_blocking_with_mask(
2061 guest,
2062 Syscall::Ppoll(call),
2063 blocked_signal_mask,
2064 )
2065 .await
2066 };
2067 if let Some(staged) = staged {
2068 staged.release(guest);
2069 }
2070 if self.cfg.replaying
2074 && let Some(mask) = temporary_mask
2075 && matches!(result, Err(Error::Errno(Errno::ERESTARTNOHAND)))
2076 {
2077 end_replayed_pselect6_under_its_temporary_mask(guest, mask).await;
2078 }
2079 result
2080 } else {
2081 self.handle_internal_ppoll(guest, call, timeout).await
2082 };
2083
2084 result
2085 }
2086
2087 async fn prepare_ppoll_probe<G: Guest<Self>>(
2096 &self,
2097 guest: &mut G,
2098 call: syscalls::Ppoll,
2099 first: bool,
2100 ) -> Result<
2101 Option<(
2102 syscalls::Ppoll,
2103 StagedCells<<G::Stack as Stack>::StackGuard>,
2104 )>,
2105 Error,
2106 > {
2107 let signal_mask = match call.sigmask() {
2108 Some(signal_mask) => {
2109 if call.sigsetsize() != KERNEL_SIGSET_SIZE {
2110 return Err(Errno::EINVAL.into());
2111 }
2112 let read = read_kernel_sigset(guest, signal_mask).await;
2113 let signal_mask = if first {
2114 crate::syscalls::signal::restart_if_first_probe_not_run(read)?
2115 } else {
2116 read?
2117 };
2118 super::signal_shadow::note_wait_mask(guest, signal_mask);
2119 observe_under_mask(guest, signal_mask).await?;
2123 Some(sanitize_ppoll_signal_mask(signal_mask))
2124 }
2125 None => None,
2126 };
2127 let cells = match signal_mask {
2128 Some(signal_mask) => PrivateCells::MaskAndZeroTimeout(signal_mask),
2129 None => PrivateCells::ZeroTimeout,
2130 };
2131 let live: Vec<std::ops::Range<usize>> = ppoll_fds_range(call).into_iter().collect();
2132 let Some(staged) = stage_private_cells(guest, cells, &live).await? else {
2133 return Ok(None);
2134 };
2135 let probe = match signal_mask {
2136 Some(_) => call
2137 .with_timeout(AddrMut::from_raw(staged.after_mask()))
2138 .with_sigmask(Addr::from_raw(staged.mask())),
2139 None => call.with_timeout(AddrMut::from_raw(staged.at)),
2140 };
2141 Ok(Some((probe, staged)))
2142 }
2143
2144 async fn refuse_unstageable_ppoll_copy<G: Guest<Self>>(
2154 &self,
2155 guest: &mut G,
2156 ) -> Option<Result<i64, Error>> {
2157 use std::io::Write as _;
2158 let message = "unsupported: ppoll on a stack with no room below its red zone whose \
2159 red zone the call's pollfd array and timeout fill: Hermit has nowhere to put its \
2160 private copy of the timeout and the signal mask \
2161 (https://github.com/rrnewton/hermit/issues/4113)";
2162 tracing::error!("[tid {}] {message}", guest.tid());
2163 if !self.cfg.panic_on_unsupported_syscalls {
2164 return None;
2165 }
2166 let _ = writeln!(crate::util::RetryingStderr, "{message}");
2167 Some(
2168 self.refuse_unserviceable_operation(guest, Sysno::ppoll, Errno::EFAULT)
2169 .await,
2170 )
2171 }
2172
2173 async fn handle_internal_ppoll<G: Guest<Self>>(
2175 &self,
2176 guest: &mut G,
2177 call: syscalls::Ppoll,
2178 timeout: Option<Duration>,
2179 ) -> Result<i64, Error> {
2180 debug_assert_ne!(timeout, Some(Duration::ZERO));
2181 let timeout_address = call.timeout();
2182 let started_at = if timeout.is_some() {
2183 Some(thread_observe_time(guest).await)
2184 } else {
2185 None
2186 };
2187 let deadline = match (timeout, started_at) {
2188 (Some(duration), Some(started_at)) => Some(started_at + duration),
2189 (None, None) => None,
2190 _ => unreachable!(),
2191 };
2192
2193 if call.sigmask().is_some() {
2205 let Some((probe, staged)) = self.prepare_ppoll_probe(guest, call, true).await? else {
2208 return match self.refuse_unstageable_ppoll_copy(guest).await {
2212 Some(refused) => refused,
2213 None => Err(Errno::ENOSYS.into()),
2214 };
2215 };
2216 let result = if self.cfg.backend.supports_blocked_wait_signal_interruption {
2217 self.wait_on_masked_ppoll_probe(
2218 guest,
2219 probe,
2220 staged.mask(),
2221 staged.timerfd_scratch,
2222 deadline,
2223 )
2224 .await
2225 } else {
2226 crate::syscalls::timerfd::publish_expired_in(guest, staged.timerfd_scratch).await;
2232 let result = guest.inject_with_retry(probe).await;
2233 if probe.syscall_would_have_blocked(result) {
2234 Err(Errno::ENOSYS.into())
2235 } else {
2236 result.map_err(Into::into)
2237 }
2238 };
2239 staged.release(guest);
2242 if let (Some(timeout_address), Some(timeout), Some(started_at)) =
2243 (timeout_address, timeout, started_at)
2244 {
2245 self.write_ppoll_remaining(guest, timeout_address, timeout, started_at)
2246 .await?;
2247 }
2248 return result;
2249 }
2250
2251 let mut rsrc = Resources::new(guest.thread_state().dettid);
2252 rsrc.insert(ResourceID::InternalIOPolling, Permission::W);
2253 rsrc.fyi("ppoll");
2254 let result = retry_nonblocking_syscall_with_timeout(guest, call, rsrc, deadline).await;
2255 if let (Some(timeout_address), Some(timeout), Some(started_at)) =
2256 (timeout_address, timeout, started_at)
2257 {
2258 self.write_ppoll_remaining(guest, timeout_address, timeout, started_at)
2259 .await?;
2260 }
2261 result
2262 }
2263
2264 async fn wait_on_masked_ppoll_probe<G: Guest<Self>>(
2294 &self,
2295 guest: &mut G,
2296 probe: syscalls::Ppoll,
2297 mask: usize,
2298 timerfd_scratch: Option<crate::syscalls::timerfd::Scratch>,
2299 deadline: Option<LogicalTime>,
2300 ) -> Result<i64, Error> {
2301 let temporary_mask: KernelSigset = guest
2302 .memory()
2303 .read_value(Addr::<KernelSigset>::from_raw(mask).ok_or(Errno::EFAULT)?)?;
2304 let mut signals = KernelSignalWait::for_select(guest)
2305 .with_wait_mask(Some(crate::syscalls::signal::kernel_installed_signal_mask(
2306 temporary_mask,
2307 )))
2308 .with_deadline(deadline.is_some());
2309 let mut rsrc = Resources::new(guest.thread_state().dettid);
2310 rsrc.insert(ResourceID::InternalIOPolling, Permission::W);
2311 rsrc.fyi("ppoll");
2312 rsrc.poll_deadline = poll_deadline_for(guest, deadline);
2313 rsrc.set_signal_interrupt_errno(Errno::EINTR);
2316 let mut published = PublishedWaitMask::default();
2319 publish_wait_mask(guest, signals.effective_mask(), &mut published).await;
2320 let result = loop {
2321 resource_request(guest, rsrc.clone()).await;
2322 let next_timerfd =
2325 crate::syscalls::timerfd::publish_expired_in(guest, timerfd_scratch).await;
2326 rsrc.poll_deadline =
2327 crate::syscalls::timerfd::poll_deadline_with(guest, deadline, next_timerfd);
2328 if let Err(error) = observe_under_mask(guest, temporary_mask).await {
2332 break Err(error);
2333 }
2334 let injected = match signals.inject_first_probe(guest, probe).await {
2335 Ok(result) => result,
2336 Err(error) => break Err(error),
2337 };
2338 if !probe.syscall_would_have_blocked(injected) {
2339 break injected.map_err(Into::into);
2340 }
2341 match signals.interrupted_with_state() {
2342 Ok((false, _)) => {}
2343 Ok((true, state))
2345 if !signals.holds_signal()
2346 && signals.interrupts_only_under_wait_mask(&state) =>
2347 {
2348 continue;
2349 }
2350 Ok((true, _)) => break Err(Errno::ERESTARTNOHAND.into()),
2351 Err(error) => break Err(error),
2352 }
2353 rsrc.poll_attempt += 1;
2354 if let Some(deadline) = deadline
2355 && thread_observe_time(guest).await >= deadline
2356 {
2357 break Ok(0);
2358 }
2359 record_retry_event(guest, probe).await;
2360 };
2361 publish_wait_mask(guest, None, &mut published).await;
2362 refuse_held_signal_loss(guest, Sysno::ppoll, result).await
2363 }
2364
2365 pub(super) async fn write_ppoll_remaining<G: Guest<Self>>(
2366 &self,
2367 guest: &mut G,
2368 timeout_address: AddrMut<'_, Timespec>,
2369 timeout: Duration,
2370 started_at: LogicalTime,
2371 ) -> Result<(), Error> {
2372 let now = thread_observe_time(guest).await;
2373 let elapsed = Duration::from_nanos(now.as_nanos().saturating_sub(started_at.as_nanos()));
2374 let remaining = timeout.saturating_sub(elapsed);
2375 if let Err(error) = guest
2376 .memory()
2377 .write_value(timeout_address, ×pec_from_duration(remaining))
2378 {
2379 trace!(?error, "ignoring ppoll timeout writeback failure");
2381 }
2382 Ok(())
2383 }
2384
2385 pub async fn handle_internal_poll<G: Guest<Self>>(
2388 &self,
2389 guest: &mut G,
2390 call: syscalls::Poll,
2391 ) -> Result<i64, Error> {
2392 let timeout_millis = call.timeout();
2393 if timeout_millis == 0 {
2394 let yield_to_peer = self.cfg.backend.loopback_pollers_yield_to_peers
2398 && guest.thread_state().has_loopback_peer();
2399 resource_request(
2400 guest,
2401 zero_timeout_poll_request(guest.thread_state().dettid, yield_to_peer),
2402 )
2403 .await;
2404 crate::syscalls::timerfd::publish_expired(guest).await;
2405 Ok(guest.inject(call).await?) } else {
2407 let maybe_timeout_ns = millis_duration_to_absolute_timeout(guest, timeout_millis).await;
2408 self.handle_internal_poll_until(guest, call, maybe_timeout_ns)
2409 .await
2410 }
2411 }
2412
2413 pub(crate) async fn handle_internal_poll_until<G: Guest<Self>>(
2418 &self,
2419 guest: &mut G,
2420 call: syscalls::Poll,
2421 deadline: Option<LogicalTime>,
2422 ) -> Result<i64, Error> {
2423 let mut rsrc = Resources::new(guest.thread_state().dettid);
2424 rsrc.insert(ResourceID::InternalIOPolling, Permission::W);
2425 rsrc.fyi("poll");
2426 let result = retry_nonblocking_syscall_with_timeout(guest, call, rsrc, deadline).await;
2427 keep_restart_block(guest, &result, RestartCall::Poll(call), deadline).await;
2428 result
2429 }
2430
2431 pub async fn handle_external_poll<G: Guest<Self>>(
2433 &self,
2434 guest: &mut G,
2435 call: syscalls::Poll,
2436 ) -> Result<i64, Error> {
2437 let len = call.nfds();
2438 let time_delta = Duration::from_millis(call.timeout() as u64);
2439
2440 if len == 0 && time_delta.is_zero() {
2441 let request = Self::sleep_request(guest, time_delta).await;
2442 resource_request(guest, request).await;
2443 Ok(0)
2444 } else {
2445 print_poll(&call);
2446 Ok(self
2447 .record_or_replay_blocking(guest, Syscall::Poll(call))
2448 .await?)
2449 }
2450 }
2451
2452 pub async fn handle_epoll_create1<G: Guest<Self>>(
2454 &self,
2455 guest: &mut G,
2456 call: syscalls::EpollCreate1,
2457 ) -> Result<i64, Error> {
2458 let dettid = guest.thread_state().dettid;
2459 resource_request(guest, Resources::new(dettid)).await; let fd = self.record_or_replay(guest, call).await? as RawFd;
2461 self.add_fd(
2472 guest,
2473 fd,
2474 OFlag::from_bits_truncate(call.flags().bits()),
2475 FdType::Epoll,
2476 )
2477 .await?;
2478 Ok(fd as i64)
2479 }
2480
2481 pub async fn handle_epoll_ctl<G: Guest<Self>>(
2489 &self,
2490 guest: &mut G,
2491 call: syscalls::EpollCtl,
2492 ) -> Result<i64, Error> {
2493 let dettid = guest.thread_state().dettid;
2494 resource_request(guest, Resources::new(dettid)).await; Ok(self.record_or_replay(guest, call).await?)
2496 }
2497
2498 pub async fn handle_epoll_pwait<G: Guest<Self>>(
2500 &self,
2501 guest: &mut G,
2502 call: syscalls::EpollPwait,
2503 ) -> Result<i64, Error> {
2504 if call.sigmask().is_some() && self.cfg.recordreplay_modes && call.timeout() != 0 {
2536 return self.record_or_replay_masked_epoll_pwait(guest, call).await;
2537 }
2538 if call.sigmask().is_some()
2539 && call.timeout() != 0
2540 && self.cfg.sequentialize_threads
2541 && self.cfg.backend.supports_blocked_wait_signal_interruption
2542 {
2543 return self.handle_internal_masked_epoll_pwait(guest, call).await;
2544 }
2545 if call.sigmask().is_some() {
2546 self.observe_under_temporary_mask(guest, call.sigmask(), call.sigsetsize())
2547 .await?;
2548 let dettid = guest.thread_state().dettid;
2549 resource_request(guest, Resources::new(dettid)).await; if call.timeout() == 0 {
2554 crate::syscalls::timerfd::publish_expired(guest).await;
2555 } else {
2556 crate::syscalls::timerfd::refuse_host_wait(guest, "epoll_pwait with a signal mask");
2557 }
2558 return Ok(self.record_or_replay(guest, call).await?);
2559 }
2560 if self.cfg.recordreplay_modes && call.timeout() == 0 {
2561 resource_request(guest, Resources::new(guest.thread_state().dettid)).await;
2564 Ok(self.record_or_replay(guest, call).await?)
2565 } else if !self.cfg.sequentialize_threads || self.cfg.recordreplay_modes {
2566 Ok(self
2567 .record_or_replay_blocking(guest, Syscall::EpollPwait(call))
2568 .await?)
2569 } else {
2570 self.handle_internal_epoll_pwait(guest, call).await
2571 }
2572 }
2573
2574 async fn handle_internal_masked_epoll_pwait<G: Guest<Self>>(
2591 &self,
2592 guest: &mut G,
2593 call: syscalls::EpollPwait,
2594 ) -> Result<i64, Error> {
2595 if call.sigsetsize() != KERNEL_SIGSET_SIZE {
2596 return Err(Errno::EINVAL.into());
2597 }
2598 let mask_address = call.sigmask().ok_or(Errno::EFAULT)?;
2599 let mask = crate::syscalls::signal::restart_if_first_probe_not_run(
2600 read_kernel_sigset(guest, mask_address.cast()).await,
2601 )?;
2602 super::signal_shadow::note_wait_mask(guest, mask);
2603 observe_under_mask(guest, mask).await?;
2606 let mask = sanitize_ppoll_signal_mask(mask);
2607 let deadline = millis_duration_to_absolute_timeout(guest, call.timeout()).await;
2608 self.wait_on_masked_epoll(
2609 guest,
2610 call.with_sigmask(None),
2611 mask,
2612 deadline,
2613 "epoll_pwait",
2614 )
2615 .await
2616 }
2617
2618 async fn wait_on_masked_epoll<G: Guest<Self>>(
2624 &self,
2625 guest: &mut G,
2626 probe: syscalls::EpollPwait,
2627 mask: KernelSigset,
2628 deadline: Option<LogicalTime>,
2629 fyi: &'static str,
2630 ) -> Result<i64, Error> {
2631 let mut rsrc = Resources::new(guest.thread_state().dettid);
2632 rsrc.insert(ResourceID::InternalIOPolling, Permission::W);
2633 rsrc.fyi(fyi);
2634 let (result, deliver) = retry_blocking_wait_under_mask(
2635 guest,
2636 probe,
2637 rsrc,
2638 deadline.map(|deadline| (deadline, Ok(0))),
2640 Some(crate::syscalls::signal::kernel_installed_signal_mask(mask)),
2641 )
2642 .await;
2643 if deliver && matches!(result, Err(Error::Errno(Errno::EINTR))) {
2644 match stage_private_cells(guest, PrivateCells::MaskAndZeroTimeout(mask), &[]).await? {
2653 Some(staged) => {
2654 inject_signal_delivery(guest, staged.mask(), staged.after_mask()).await;
2655 staged.release(guest);
2656 }
2657 None => tracing::warn!(
2658 "[tid {}] no room to deliver an {fyi} signal under its temporary mask; its \
2659 handler runs only once the guest unblocks it",
2660 guest.tid()
2661 ),
2662 }
2663 }
2664 result
2665 }
2666
2667 async fn record_or_replay_masked_epoll_pwait<G: Guest<Self>>(
2678 &self,
2679 guest: &mut G,
2680 call: syscalls::EpollPwait,
2681 ) -> Result<i64, Error> {
2682 if call.sigsetsize() != KERNEL_SIGSET_SIZE {
2683 return Err(Errno::EINVAL.into());
2684 }
2685 let mask_address = call.sigmask().ok_or(Errno::EFAULT)?;
2686 let mask = crate::syscalls::signal::restart_if_first_probe_not_run(
2687 read_kernel_sigset(guest, mask_address.cast()).await,
2688 )?;
2689 super::signal_shadow::note_wait_mask(guest, mask);
2690 let live: Vec<std::ops::Range<usize>> = call
2694 .events()
2695 .map(|events| {
2696 let start = events.as_raw();
2697 let len = usize::try_from(call.maxevents().max(0)).unwrap_or(0)
2698 * std::mem::size_of::<libc::epoll_event>();
2699 start..start.saturating_add(len)
2700 })
2701 .into_iter()
2702 .collect();
2703 let Some(staged) = stage_private_cells(guest, PrivateCells::Mask(mask), &live).await?
2704 else {
2705 return self.refuse_unstageable_epoll_pwait_mask(guest, call).await;
2706 };
2707 let result = self
2708 .record_or_replay_blocking_with_unknown_mask(
2709 guest,
2710 Syscall::EpollPwait(call.with_sigmask(Addr::from_raw(staged.mask()))),
2711 )
2712 .await;
2713 staged.release(guest);
2714 if self.cfg.replaying && matches!(result, Err(Error::Errno(Errno::EINTR))) {
2715 end_replayed_pselect6_under_its_temporary_mask(guest, mask).await;
2716 }
2717 result
2718 }
2719
2720 async fn refuse_unstageable_epoll_pwait_mask<G: Guest<Self>>(
2726 &self,
2727 guest: &mut G,
2728 call: syscalls::EpollPwait,
2729 ) -> Result<i64, Error> {
2730 use std::io::Write as _;
2731 let message = "unsupported: epoll_pwait with a temporary signal mask, on a stack \
2732 with no room below its red zone whose red zone the call's events buffer fills: \
2733 Hermit has nowhere to put the private copy of the mask \
2734 (https://github.com/rrnewton/hermit/pull/4087)";
2735 tracing::error!("[tid {}] {message}", guest.tid());
2736 if self.cfg.panic_on_unsupported_syscalls {
2737 let _ = writeln!(crate::util::RetryingStderr, "{message}");
2738 return self
2739 .refuse_unserviceable_operation(guest, Sysno::epoll_pwait, Errno::EFAULT)
2740 .await;
2741 }
2742 self.record_or_replay_blocking_with_unknown_mask(guest, Syscall::EpollPwait(call))
2743 .await
2744 }
2745
2746 pub async fn handle_internal_epoll_pwait<G: Guest<Self>>(
2749 &self,
2750 guest: &mut G,
2751 call: syscalls::EpollPwait,
2752 ) -> Result<i64, Error> {
2753 let timeout_millis = call.timeout();
2754 if timeout_millis == 0 {
2755 if self.cfg.sequentialize_threads {
2765 let yield_to_peer = self.cfg.backend.loopback_pollers_yield_to_peers
2766 && guest.thread_state().has_loopback_peer();
2767 resource_request(
2768 guest,
2769 zero_timeout_poll_request(guest.thread_state().dettid, yield_to_peer),
2770 )
2771 .await;
2772 }
2773 crate::syscalls::timerfd::publish_expired(guest).await;
2774 Ok(guest.inject(call).await?) } else {
2776 let maybe_timeout_ns = millis_duration_to_absolute_timeout(guest, timeout_millis).await;
2777 let mut rsrc = Resources::new(guest.thread_state().dettid);
2778 rsrc.insert(ResourceID::InternalIOPolling, Permission::W);
2779 rsrc.fyi("epoll_pwait");
2780 retry_nonblocking_syscall_with_timeout(guest, call, rsrc, maybe_timeout_ns).await
2781 }
2782 }
2783
2784 pub async fn handle_epoll_pwait2<G: Guest<Self>>(
2798 &self,
2799 guest: &mut G,
2800 call: Syscall,
2801 ) -> Result<i64, Error> {
2802 let (_, args) = call.into_parts();
2804 self.observe_under_temporary_mask(
2805 guest,
2806 Addr::<libc::sigset_t>::from_raw(args.arg4),
2807 args.arg5,
2808 )
2809 .await?;
2810 let zero_timeout = args.arg3 != 0
2813 && Addr::<Timespec>::from_raw(args.arg3)
2814 .and_then(|timeout| guest.memory().read_value(timeout).ok())
2815 .is_some_and(|timeout: Timespec| timeout.tv_sec == 0 && timeout.tv_nsec == 0);
2816 if self.cfg.recordreplay_modes {
2821 if !zero_timeout {
2822 return if args.arg4 != 0 {
2823 self.record_or_replay_masked_epoll_pwait2(guest, args).await
2824 } else {
2825 self.record_or_replay_blocking(guest, call).await
2826 };
2827 }
2828 } else if self.cfg.sequentialize_threads
2829 && !zero_timeout
2830 && (args.arg4 == 0 || self.cfg.backend.supports_blocked_wait_signal_interruption)
2831 {
2832 return self.handle_internal_epoll_pwait2(guest, args).await;
2839 }
2840 let dettid = guest.thread_state().dettid;
2841 resource_request(guest, Resources::new(dettid)).await; if zero_timeout {
2846 crate::syscalls::timerfd::publish_expired(guest).await;
2847 } else {
2848 crate::syscalls::timerfd::refuse_host_wait(guest, "epoll_pwait2 with a signal mask");
2849 }
2850 Ok(self.record_or_replay(guest, call).await?)
2851 }
2852
2853 async fn handle_internal_epoll_pwait2<G: Guest<Self>>(
2866 &self,
2867 guest: &mut G,
2868 args: SyscallArgs,
2869 ) -> Result<i64, Error> {
2870 let deadline = match Addr::<Timespec>::from_raw(args.arg3) {
2871 Some(timeout) => {
2872 let timeout: Timespec = guest.memory().read_value(timeout)?;
2873 let timeout = ppoll_timeout_duration(timeout)?;
2874 Some(thread_observe_time(guest).await + timeout)
2879 }
2880 None => None,
2881 };
2882 let probe = syscalls::EpollPwait::new()
2883 .with_epfd(args.arg0 as i32)
2884 .with_events(AddrMut::from_raw(args.arg1))
2885 .with_maxevents(args.arg2 as i32)
2886 .with_timeout(0)
2887 .with_sigmask(None)
2888 .with_sigsetsize(args.arg5);
2889 if args.arg4 == 0 {
2890 let mut rsrc = Resources::new(guest.thread_state().dettid);
2891 rsrc.insert(ResourceID::InternalIOPolling, Permission::W);
2892 rsrc.fyi("epoll_pwait2");
2893 return retry_nonblocking_syscall_with_timeout(guest, probe, rsrc, deadline).await;
2894 }
2895 if args.arg5 != KERNEL_SIGSET_SIZE {
2896 return Err(Errno::EINVAL.into());
2897 }
2898 let mask_address = Addr::<libc::sigset_t>::from_raw(args.arg4).ok_or(Errno::EFAULT)?;
2899 let mask = read_kernel_sigset(guest, mask_address).await?;
2900 super::signal_shadow::note_wait_mask(guest, mask);
2901 observe_under_mask(guest, mask).await?;
2904 let mask = sanitize_ppoll_signal_mask(mask);
2905 self.wait_on_masked_epoll(guest, probe, mask, deadline, "epoll_pwait2")
2906 .await
2907 }
2908
2909 async fn observe_under_temporary_mask<G: Guest<Self>>(
2916 &self,
2917 guest: &mut G,
2918 mask: Option<Addr<'_, libc::sigset_t>>,
2919 sigsetsize: usize,
2920 ) -> Result<(), Error> {
2921 let Some(mask) = mask else {
2922 return Ok(());
2923 };
2924 if sigsetsize != KERNEL_SIGSET_SIZE
2925 || !crate::scheduler::real_time_expiration_kept_pending()
2926 {
2927 return Ok(());
2928 }
2929 let Ok(mask) = read_kernel_sigset(guest, mask).await else {
2930 return Ok(());
2931 };
2932 observe_under_mask(guest, mask).await
2933 }
2934
2935 async fn record_or_replay_masked_epoll_pwait2<G: Guest<Self>>(
2938 &self,
2939 guest: &mut G,
2940 args: SyscallArgs,
2941 ) -> Result<i64, Error> {
2942 if let Some(timeout) = Addr::<Timespec>::from_raw(args.arg3) {
2947 let timeout: Timespec = guest.memory().read_value(timeout)?;
2948 ppoll_timeout_duration(timeout)?;
2949 }
2950 if args.arg5 != KERNEL_SIGSET_SIZE {
2951 return Err(Errno::EINVAL.into());
2952 }
2953 let mask_address = Addr::<libc::sigset_t>::from_raw(args.arg4).ok_or(Errno::EFAULT)?;
2954 let mask = read_kernel_sigset(guest, mask_address).await?;
2955 super::signal_shadow::note_wait_mask(guest, mask);
2956 let events_len = usize::try_from((args.arg2 as i32).max(0)).unwrap_or(0)
2960 * std::mem::size_of::<libc::epoll_event>();
2961 let live: Vec<std::ops::Range<usize>> = [
2962 (args.arg1, events_len),
2963 (args.arg3, std::mem::size_of::<Timespec>()),
2964 ]
2965 .into_iter()
2966 .filter(|&(start, _)| start != 0)
2967 .map(|(start, len)| start..start.saturating_add(len))
2968 .collect();
2969 let Some(staged) = stage_private_cells(guest, PrivateCells::Mask(mask), &live).await?
2970 else {
2971 return self.refuse_unstageable_epoll_pwait2_mask(guest, args).await;
2972 };
2973 let mut private = args;
2974 private.arg4 = staged.mask();
2975 let result = self
2976 .record_or_replay_blocking_with_unknown_mask(
2977 guest,
2978 Syscall::Other(Sysno::epoll_pwait2, private),
2979 )
2980 .await;
2981 staged.release(guest);
2982 if self.cfg.replaying && matches!(result, Err(Error::Errno(Errno::EINTR))) {
2983 end_replayed_pselect6_under_its_temporary_mask(guest, mask).await;
2984 }
2985 result
2986 }
2987
2988 async fn refuse_unstageable_epoll_pwait2_mask<G: Guest<Self>>(
2991 &self,
2992 guest: &mut G,
2993 args: SyscallArgs,
2994 ) -> Result<i64, Error> {
2995 use std::io::Write as _;
2996 let message = "unsupported: epoll_pwait2 with a temporary signal mask, on a stack \
2997 with no room below its red zone whose red zone the call's events buffer and \
2998 timeout fill: Hermit has nowhere to put the private copy of the mask \
2999 (https://github.com/rrnewton/hermit/issues/4088)";
3000 tracing::error!("[tid {}] {message}", guest.tid());
3001 if self.cfg.panic_on_unsupported_syscalls {
3002 let _ = writeln!(crate::util::RetryingStderr, "{message}");
3003 return self
3004 .refuse_unserviceable_operation(guest, Sysno::epoll_pwait2, Errno::EFAULT)
3005 .await;
3006 }
3007 self.record_or_replay_blocking_with_unknown_mask(
3008 guest,
3009 Syscall::Other(Sysno::epoll_pwait2, args),
3010 )
3011 .await
3012 }
3013
3014 pub async fn handle_epoll_wait<G: Guest<Self>>(
3016 &self,
3017 guest: &mut G,
3018 call: syscalls::EpollWait,
3019 ) -> Result<i64, Error> {
3020 if self.cfg.recordreplay_modes && call.timeout() == 0 {
3021 resource_request(guest, Resources::new(guest.thread_state().dettid)).await;
3024 Ok(self.record_or_replay(guest, call).await?)
3025 } else if !self.cfg.sequentialize_threads || self.cfg.recordreplay_modes {
3026 Ok(self
3027 .record_or_replay_blocking(guest, Syscall::EpollWait(call))
3028 .await?)
3029 } else {
3030 self.handle_internal_epoll_wait(guest, call).await
3031 }
3032 }
3033
3034 pub async fn handle_internal_epoll_wait<G: Guest<Self>>(
3036 &self,
3037 guest: &mut G,
3038 call: syscalls::EpollWait,
3039 ) -> Result<i64, Error> {
3040 let timeout_millis = call.timeout();
3041 if timeout_millis == 0 {
3042 crate::syscalls::timerfd::publish_expired(guest).await;
3043 Ok(guest.inject(call).await?) } else {
3045 let maybe_timeout_ns = millis_duration_to_absolute_timeout(guest, timeout_millis).await;
3046 let mut rsrc = Resources::new(guest.thread_state().dettid);
3047 rsrc.insert(ResourceID::InternalIOPolling, Permission::W);
3048 rsrc.fyi("epoll_wait");
3049 retry_nonblocking_syscall_with_timeout(guest, call, rsrc, maybe_timeout_ns).await
3050 }
3051 }
3052
3053 pub async fn handle_connect<G: Guest<Self>>(
3058 &self,
3059 guest: &mut G,
3060 call: syscalls::Connect,
3061 ) -> Result<i64, Error> {
3062 let fd = call.fd();
3063 let uservaddr = call.uservaddr();
3064 let addrlen = call.addrlen();
3065
3066 if guest.config().sched_heuristic == SchedHeuristic::ConnectBind {
3067 trace!("Scheduling heuristic: reprioritizing connect");
3068 let resource = ResourceID::PriorityChangePoint(
3069 FIRST_PRIORITY,
3070 guest.thread_state().thread_logical_time.as_nanos(),
3071 guest.thread_state().committed_clock_value,
3072 Vec::new(),
3073 );
3074 let req = guest.thread_state().mk_request(resource, Permission::W);
3075 resource_request(guest, req).await;
3076 }
3077
3078 let result = self.execute_nonblockable_fd_syscall(guest, call).await;
3079 if self.cfg.backend.loopback_pollers_yield_to_peers
3080 && connect_result_allows_peer_classification(&result)
3081 {
3082 let loopback_peer = (|| -> Result<Option<bool>, Error> {
3087 let Some(address) = uservaddr else {
3088 return Ok(None);
3089 };
3090 let addrlen = usize::try_from(addrlen).unwrap_or(0);
3091 if addrlen < std::mem::size_of::<u16>() {
3092 return Ok(None);
3093 }
3094 let family: u16 = guest.memory().read_value(address.cast())?;
3095 if family == libc::AF_INET as u16 {
3096 if addrlen < std::mem::size_of::<libc::sockaddr_in>() {
3097 return Ok(None);
3098 }
3099 let address: libc::sockaddr_in = guest.memory().read_value(address.cast())?;
3100 Ok(Some(
3101 Ipv4Addr::from(address.sin_addr.s_addr.to_ne_bytes()).is_loopback(),
3102 ))
3103 } else if family == libc::AF_INET6 as u16 {
3104 if addrlen < std::mem::size_of::<libc::sockaddr_in6>() {
3105 return Ok(None);
3106 }
3107 let address: libc::sockaddr_in6 = guest.memory().read_value(address.cast())?;
3108 Ok(Some(
3109 Ipv6Addr::from(address.sin6_addr.s6_addr).is_loopback(),
3110 ))
3111 } else {
3112 Ok(Some(false))
3115 }
3116 })()
3117 .ok()
3118 .flatten();
3119 if let Some(loopback_peer) = loopback_peer {
3120 let _ = guest
3121 .thread_state()
3122 .with_detfd(fd, |detfd| detfd.set_loopback_peer(loopback_peer));
3123 }
3124 }
3125
3126 result
3127 }
3128
3129 pub async fn handle_sendrecv<
3131 G: Guest<Self>,
3132 C: SyscallInfo + NonblockableSyscall + Into<Syscall>,
3133 >(
3134 &self,
3135 guest: &mut G,
3136 call: C,
3137 ) -> Result<i64, Error> {
3138 self.execute_nonblockable_fd_syscall(guest, call).await
3139 }
3140
3141 pub async fn handle_sendmsg<G: Guest<Self>>(
3148 &self,
3149 guest: &mut G,
3150 call: syscalls::Sendmsg,
3151 ) -> Result<i64, Error> {
3152 if self.accept_in_turn_enabled() {
3153 let headers: Vec<usize> = call
3154 .msg()
3155 .map(|header| header.as_raw())
3156 .into_iter()
3157 .collect();
3158 self.mark_exported_listeners(guest, &headers);
3159 }
3160 let headers: Vec<usize> = call
3161 .msg()
3162 .map(|header| header.as_raw())
3163 .into_iter()
3164 .collect();
3165 self.refuse_sending_virtual_timerfds(guest, &headers);
3166 let result = self.execute_nonblockable_fd_syscall(guest, call).await?;
3167 guest.thread_state().forget_flock_modes();
3168 Ok(result)
3169 }
3170
3171 fn mark_exported_listeners<G: Guest<Self>>(&self, guest: &mut G, headers: &[usize]) {
3190 let (sent, unread) = sent_descriptors(guest, headers);
3191 if unread {
3192 guest
3196 .thread_state()
3197 .mark_accept_in_turn_listeners_exported();
3198 return;
3199 }
3200 for fd in sent {
3201 let _ = guest.thread_state().with_detfd(fd, |detfd| {
3202 if detfd.is_accept_in_turn_eligible() {
3203 detfd.set_exported();
3204 }
3205 });
3206 }
3207 }
3208
3209 fn refuse_sending_virtual_timerfds<G: Guest<Self>>(&self, guest: &mut G, headers: &[usize]) {
3219 if !crate::syscalls::timerfd::enabled(guest) {
3220 return;
3221 }
3222 let holds_armed = crate::syscalls::timerfd::has_virtual_timerfds(guest);
3223 let (sent, unread) = sent_descriptors(guest, headers);
3224 if unread && holds_armed {
3225 crate::syscalls::timerfd::refuse(format_args!(
3226 "a message whose SCM_RIGHTS control data Detcore cannot read may pass a timerfd to another process"
3227 ));
3228 }
3229 for fd in sent {
3230 match guest.thread_state().with_detfd(fd, |detfd| detfd.ty()) {
3231 Ok(FdType::Timerfd) => crate::syscalls::timerfd::refuse(format_args!(
3232 "a message passes timerfd {fd} over SCM_RIGHTS, and its receiver keeps no model of the timer"
3233 )),
3234 Ok(FdType::Epoll) if holds_armed => crate::syscalls::timerfd::refuse(format_args!(
3235 "a message passes epoll descriptor {fd} over SCM_RIGHTS while this process holds a timerfd its set may include"
3236 )),
3237 _ => {}
3238 }
3239 }
3240 }
3241}
3242
3243fn sent_descriptors<T, G>(guest: &G, headers: &[usize]) -> (Vec<RawFd>, bool)
3247where
3248 T: RecordOrReplay,
3249 G: Guest<Detcore<T>>,
3250{
3251 let mut sent: Vec<RawFd> = Vec::new();
3252 let mut unread = false;
3253 for header in headers {
3254 let Some(header) = Addr::<libc::msghdr>::from_raw(*header) else {
3257 continue;
3258 };
3259 let Ok(header) = guest.memory().read_value::<_, libc::msghdr>(header) else {
3260 unread = true;
3261 continue;
3262 };
3263 let Some(control_address) = Addr::<u8>::from_raw(header.msg_control as usize) else {
3264 continue;
3265 };
3266 if header.msg_controllen > MAX_CONTROL_BYTES {
3267 unread = true;
3268 continue;
3269 }
3270 let mut control = vec![0; header.msg_controllen];
3271 if guest
3272 .memory()
3273 .read_exact(control_address, &mut control)
3274 .is_err()
3275 {
3276 unread = true;
3277 continue;
3278 }
3279 sent.extend(received_descriptors(&control));
3280 }
3281 (sent, unread)
3282}
3283
3284impl<T: RecordOrReplay> Detcore<T> {
3285 pub async fn handle_sendmmsg<G: Guest<Self>>(
3290 &self,
3291 guest: &mut G,
3292 call: syscalls::Sendmmsg,
3293 ) -> Result<i64, Error> {
3294 if self.cfg.recordreplay_modes && is_accepted_connection(guest, call.sockfd()) {
3295 return self.refuse_log_served_mmsg(guest, Sysno::sendmmsg).await;
3296 }
3297 if self.accept_in_turn_enabled() {
3298 let headers: Vec<usize> = call.msgvec().map_or_else(Vec::new, |vector| {
3303 (0..call.vlen().min(libc::UIO_MAXIOV as u32) as usize)
3304 .map(|index| vector.as_raw() + index * std::mem::size_of::<libc::mmsghdr>())
3305 .collect()
3306 });
3307 self.mark_exported_listeners(guest, &headers);
3308 }
3309 let headers: Vec<usize> = call.msgvec().map_or_else(Vec::new, |vector| {
3311 (0..call.vlen().min(libc::UIO_MAXIOV as u32) as usize)
3312 .map(|index| vector.as_raw() + index * std::mem::size_of::<libc::mmsghdr>())
3313 .collect()
3314 });
3315 self.refuse_sending_virtual_timerfds(guest, &headers);
3316 let result = self.execute_nonblockable_fd_syscall(guest, call).await?;
3317 if result > 0 {
3318 guest.thread_state().forget_flock_modes();
3319 }
3320 Ok(result)
3321 }
3322
3323 async fn refuse_log_served_mmsg<G: Guest<Self>>(
3332 &self,
3333 guest: &mut G,
3334 sysno: Sysno,
3335 ) -> Result<i64, Error> {
3336 self.refuse_unserviceable_operation(guest, sysno, Errno::EOPNOTSUPP)
3337 .await
3338 }
3339
3340 async fn observe_socket_receive<G: Guest<Self>>(
3342 &self,
3343 guest: &mut G,
3344 fd: i32,
3345 ) -> Result<LogicalTime, Error> {
3346 let timestamp = thread_observe_time(guest).await;
3347 guest.thread_state().with_detfd(fd, |detfd| {
3348 detfd.set_socket_receive_timestamp(timestamp);
3349 })?;
3350 Ok(timestamp)
3351 }
3352
3353 pub async fn handle_recvmsg<G: Guest<Self>>(
3357 &self,
3358 guest: &mut G,
3359 call: syscalls::Recvmsg,
3360 ) -> Result<i64, Error> {
3361 if self.sock_diag_reply_fd(guest, call.sockfd()) {
3367 return self.handle_sock_diag_recvmsg(guest, call).await;
3368 }
3369
3370 if !self.cfg.virtualize_time {
3371 return self.execute_nonblockable_fd_syscall(guest, call).await;
3372 }
3373
3374 let Some(message_address) = call.msg() else {
3375 return self
3376 .handle_socket_receive(guest, call, call.sockfd(), true)
3377 .await;
3378 };
3379 let message: libc::msghdr = guest.memory().read_value(message_address)?;
3383 if message.msg_control.is_null() || message.msg_controllen == 0 {
3384 return self
3385 .handle_socket_receive(guest, call, call.sockfd(), true)
3386 .await;
3387 }
3388 let control_len = message.msg_controllen.min(MAX_CONTROL_BYTES);
3389 let control_address: AddrMut<'_, u8> =
3390 AddrMut::from_raw(message.msg_control as usize).ok_or(Errno::EFAULT)?;
3391 let mut control = vec![0; control_len];
3392 guest.memory().read_exact(control_address, &mut control)?;
3394
3395 let result = self.execute_nonblockable_fd_syscall(guest, call).await?;
3396 let now = self.observe_socket_receive(guest, call.sockfd()).await?;
3397 let mut control = vec![0; control_len];
3398 guest.memory().read_exact(control_address, &mut control)?;
3399 for fd in received_descriptors(&control) {
3406 self.refresh_description_locks(guest, fd, super::files::LockCall::Recvmsg)
3407 .await?;
3408 }
3409 if socket_timestamp_messages(&control).is_empty() {
3410 return Ok(result);
3411 }
3412
3413 canonicalize_socket_timestamps(&mut control, now);
3414 guest.memory().write_exact(control_address, &control)?;
3415 Ok(result)
3416 }
3417
3418 pub(crate) fn sock_diag_reply_fd<G: Guest<Self>>(&self, guest: &mut G, fd: RawFd) -> bool {
3428 self.cfg.virtualize_metadata
3429 && guest
3430 .thread_state()
3431 .with_detfd(fd, |detfd| detfd.is_sock_diag() || detfd.is_netlink_route())
3432 .unwrap_or(false)
3433 }
3434
3435 fn netlink_route_reply_fd<G: Guest<Self>>(&self, guest: &mut G, fd: RawFd) -> bool {
3438 guest
3439 .thread_state()
3440 .with_detfd(fd, |detfd| detfd.is_netlink_route())
3441 .unwrap_or(false)
3442 }
3443
3444 fn read_iov_segments<G: Guest<Self>>(
3447 guest: &mut G,
3448 iov: usize,
3449 iovlen: usize,
3450 ) -> Result<Vec<(usize, usize)>, Error> {
3451 if iov == 0 || iovlen == 0 {
3452 return Ok(Vec::new());
3453 }
3454 let count = iovlen.min(libc::UIO_MAXIOV as usize);
3455 let address: AddrMut<'_, libc::iovec> = AddrMut::from_raw(iov).ok_or(Errno::EFAULT)?;
3456 let mut iovecs: Vec<libc::iovec> =
3459 (0..count).map(|_| unsafe { std::mem::zeroed() }).collect();
3460 guest.memory().read_values(address.into(), &mut iovecs)?;
3461 Ok(iovecs
3462 .iter()
3463 .map(|iov| (iov.iov_base as usize, iov.iov_len))
3464 .collect())
3465 }
3466
3467 fn sanitize_sock_diag_segments<G: Guest<Self>>(
3481 &self,
3482 guest: &mut G,
3483 fd: RawFd,
3484 segments: &[(usize, usize)],
3485 received: usize,
3486 ) -> Result<(), Error> {
3487 if received == 0 || segments.is_empty() {
3488 return Ok(());
3489 }
3490 let mut filled: Vec<(AddrMut<'_, u8>, usize)> = Vec::new();
3491 let mut buffer: Vec<u8> = Vec::with_capacity(received);
3492 let mut remaining = received;
3493 for &(base, capacity) in segments {
3494 if remaining == 0 {
3495 break;
3496 }
3497 if base == 0 || capacity == 0 {
3498 continue;
3499 }
3500 let take = capacity.min(remaining);
3501 let address: AddrMut<'_, u8> = AddrMut::from_raw(base).ok_or(Errno::EFAULT)?;
3502 let mut segment = vec![0u8; take];
3503 guest.memory().read_exact(address, &mut segment)?;
3504 buffer.extend_from_slice(&segment);
3505 filled.push((address, take));
3506 remaining -= take;
3507 }
3508
3509 let modified = if self.netlink_route_reply_fd(guest, fd) {
3514 crate::netlink_route::sanitize_route_link_stats(&mut buffer)
3515 } else {
3516 crate::sock_diag::sanitize_sock_diag_identities(&mut buffer)
3517 };
3518 if !modified {
3519 return Ok(());
3520 }
3521
3522 let mut offset = 0;
3523 for (address, len) in filled {
3524 guest
3525 .memory()
3526 .write_exact(address, &buffer[offset..offset + len])?;
3527 offset += len;
3528 }
3529 Ok(())
3530 }
3531
3532 pub async fn handle_sock_diag_recvfrom<G: Guest<Self>>(
3538 &self,
3539 guest: &mut G,
3540 call: syscalls::Recvfrom,
3541 ) -> Result<i64, Error> {
3542 let fd = call.fd();
3543 let base = call.buf().map(|address| address.as_raw()).unwrap_or(0);
3544 let len = call.len();
3545 let result = self.handle_socket_receive(guest, call, fd, true).await?;
3546 let received = usize::try_from(result).unwrap_or(0);
3547 self.sanitize_sock_diag_segments(guest, fd, &[(base, len)], received)?;
3548 Ok(result)
3549 }
3550
3551 pub async fn handle_sock_diag_read<G: Guest<Self>>(
3553 &self,
3554 guest: &mut G,
3555 call: syscalls::Read,
3556 ) -> Result<i64, Error> {
3557 let fd = call.fd();
3558 let base = call.buf().map(|address| address.as_raw()).unwrap_or(0);
3559 let len = call.len();
3560 let result = self.handle_read(guest, call).await?;
3561 let received = usize::try_from(result).unwrap_or(0);
3562 self.sanitize_sock_diag_segments(guest, fd, &[(base, len)], received)?;
3563 Ok(result)
3564 }
3565
3566 async fn handle_sock_diag_recvmsg<G: Guest<Self>>(
3572 &self,
3573 guest: &mut G,
3574 call: syscalls::Recvmsg,
3575 ) -> Result<i64, Error> {
3576 let fd = call.sockfd();
3577 let Some(message_address) = call.msg() else {
3578 return self.handle_socket_receive(guest, call, fd, true).await;
3579 };
3580 let segments = {
3585 let message: libc::msghdr = guest.memory().read_value(message_address)?;
3586 Self::read_iov_segments(guest, message.msg_iov as usize, message.msg_iovlen)?
3587 };
3588
3589 let result = self.handle_socket_receive(guest, call, fd, true).await?;
3590 let received = usize::try_from(result).unwrap_or(0);
3591 self.sanitize_sock_diag_segments(guest, fd, &segments, received)?;
3592 Ok(result)
3593 }
3594
3595 pub async fn handle_sock_diag_readv<G: Guest<Self>>(
3597 &self,
3598 guest: &mut G,
3599 call: syscalls::Readv,
3600 ) -> Result<i64, Error> {
3601 let fd = call.fd();
3602 let iov = call.iov().map(|address| address.as_raw()).unwrap_or(0);
3603 let segments = Self::read_iov_segments(guest, iov, call.len())?;
3604 let result = self.handle_readv(guest, call).await?;
3605 let received = usize::try_from(result).unwrap_or(0);
3606 self.sanitize_sock_diag_segments(guest, fd, &segments, received)?;
3607 Ok(result)
3608 }
3609
3610 pub async fn handle_sock_diag_recvmmsg<G: Guest<Self>>(
3617 &self,
3618 guest: &mut G,
3619 call: syscalls::Recvmmsg,
3620 ) -> Result<i64, Error> {
3621 let fd = call.fd();
3622 let Some(messages_address) = call.mmsg() else {
3623 return self.handle_recvmmsg(guest, call).await;
3624 };
3625 let vlen = call.vlen();
3626 if vlen == 0 || vlen > libc::UIO_MAXIOV as u32 {
3627 return self.handle_recvmmsg(guest, call).await;
3628 }
3629 let base = messages_address.as_raw();
3630
3631 let geometry: Vec<Vec<(usize, usize)>> = {
3637 let mut headers: Vec<libc::mmsghdr> = (0..vlen as usize)
3640 .map(|_| unsafe { std::mem::zeroed() })
3641 .collect();
3642 guest
3643 .memory()
3644 .read_values(messages_address.into(), &mut headers)?;
3645 let mut geometry = Vec::with_capacity(headers.len());
3646 for header in &headers {
3647 geometry.push(Self::read_iov_segments(
3648 guest,
3649 header.msg_hdr.msg_iov as usize,
3650 header.msg_hdr.msg_iovlen,
3651 )?);
3652 }
3653 geometry
3654 };
3655
3656 let result = self.handle_recvmmsg(guest, call).await?;
3657 let delivered = usize::try_from(result).unwrap_or(0).min(geometry.len());
3658 if delivered == 0 {
3659 return Ok(result);
3660 }
3661
3662 let counts: Vec<usize> = {
3666 let address: AddrMut<'_, libc::mmsghdr> =
3667 AddrMut::from_raw(base).ok_or(Errno::EFAULT)?;
3668 let mut headers: Vec<libc::mmsghdr> = (0..vlen as usize)
3670 .map(|_| unsafe { std::mem::zeroed() })
3671 .collect();
3672 guest.memory().read_values(address.into(), &mut headers)?;
3673 headers.iter().map(|h| h.msg_len as usize).collect()
3674 };
3675 for (index, segments) in geometry.iter().enumerate().take(delivered) {
3676 self.sanitize_sock_diag_segments(guest, fd, segments, counts[index])?;
3677 }
3678 Ok(result)
3679 }
3680
3681 pub async fn handle_socket_receive<
3684 G: Guest<Self>,
3685 C: SyscallInfo + NonblockableSyscall + Into<Syscall>,
3686 >(
3687 &self,
3688 guest: &mut G,
3689 call: C,
3690 fd: i32,
3691 zero_delivers_packet: bool,
3692 ) -> Result<i64, Error> {
3693 let result = self.execute_nonblockable_fd_syscall(guest, call).await?;
3694 if self.cfg.virtualize_time && (result > 0 || (result == 0 && zero_delivers_packet)) {
3695 self.observe_socket_receive(guest, fd).await?;
3696 }
3697 Ok(result)
3698 }
3699
3700 pub async fn handle_recvmmsg<G: Guest<Self>>(
3704 &self,
3705 guest: &mut G,
3706 call: syscalls::Recvmmsg,
3707 ) -> Result<i64, Error> {
3708 if self.cfg.recordreplay_modes && is_accepted_connection(guest, call.fd()) {
3709 return self.refuse_log_served_mmsg(guest, Sysno::recvmmsg).await;
3710 }
3711 if !self.cfg.virtualize_time || call.vlen() > libc::UIO_MAXIOV as u32 {
3712 return self.execute_nonblockable_fd_syscall(guest, call).await;
3713 }
3714
3715 let Some(messages_address) = call.mmsg() else {
3716 return self.execute_nonblockable_fd_syscall(guest, call).await;
3717 };
3718 let controls = {
3719 let mut messages: Vec<libc::mmsghdr> = (0..call.vlen())
3722 .map(|_| unsafe { std::mem::zeroed() })
3723 .collect();
3724 guest
3725 .memory()
3726 .read_values(messages_address.into(), &mut messages)?;
3727
3728 let mut controls = Vec::with_capacity(messages.len());
3729 for message in &messages {
3730 let header = &message.msg_hdr;
3731 if header.msg_control.is_null() || header.msg_controllen == 0 {
3732 controls.push(None);
3733 continue;
3734 }
3735 controls.push(Some((
3736 header.msg_control as usize,
3737 header.msg_controllen.min(MAX_CONTROL_BYTES),
3738 )));
3739 }
3740 controls
3741 };
3742
3743 let result = self.execute_nonblockable_fd_syscall(guest, call).await?;
3744 let delivered = usize::try_from(result).unwrap_or(0).min(controls.len());
3745 if delivered == 0 {
3746 return Ok(result);
3747 }
3748 let now = self.observe_socket_receive(guest, call.fd()).await?;
3749 let mut timestamped = Vec::new();
3750 for (address, length) in controls.into_iter().take(delivered).flatten() {
3751 let address: AddrMut<'_, u8> = AddrMut::from_raw(address).ok_or(Errno::EFAULT)?;
3752 let mut bytes = vec![0; length];
3753 guest.memory().read_exact(address, &mut bytes)?;
3754 if !socket_timestamp_messages(&bytes).is_empty() {
3755 timestamped.push((address, bytes));
3756 }
3757 }
3758 if timestamped.is_empty() {
3759 return Ok(result);
3760 }
3761
3762 for (address, mut bytes) in timestamped {
3763 canonicalize_socket_timestamps(&mut bytes, now);
3764 guest.memory().write_exact(address, &bytes)?;
3765 }
3766 Ok(result)
3767 }
3768}
3769
3770#[cfg(test)]
3771mod tests {
3772 use super::*;
3773
3774 #[test]
3775 fn zero_timeout_socket_poll_requests_a_strong_one_turn_yield() {
3776 let request = zero_timeout_poll_request(DetTid::from_raw(17), true);
3777
3778 assert_eq!(request.resources.len(), 1);
3779 assert_eq!(
3780 request.resources.get(&ResourceID::SchedYield),
3781 Some(&Permission::W)
3782 );
3783 assert_eq!(request.fyi, LOOPBACK_POLL_YIELD_FYI);
3784 }
3785
3786 #[test]
3787 fn zero_timeout_non_socket_poll_keeps_the_existing_empty_turn() {
3788 let request = zero_timeout_poll_request(DetTid::from_raw(17), false);
3789
3790 assert!(request.resources.is_empty());
3791 assert!(request.fyi.is_empty());
3792 }
3793
3794 #[test]
3795 fn connect_peer_classification_never_overrides_kernel_errors() {
3796 assert!(connect_result_allows_peer_classification(&Ok(0)));
3797 assert!(connect_result_allows_peer_classification(&Err(
3798 Error::Errno(Errno::EINPROGRESS)
3799 )));
3800 assert!(!connect_result_allows_peer_classification(&Err(
3801 Error::Errno(Errno::EALREADY)
3802 )));
3803 assert!(!connect_result_allows_peer_classification(&Err(
3804 Error::Errno(Errno::EBADF)
3805 )));
3806 assert!(!connect_result_allows_peer_classification(&Err(
3807 Error::Errno(Errno::EFAULT)
3808 )));
3809 }
3810
3811 #[test]
3812 fn ppoll_timeout_uses_timespec_units() {
3813 assert_eq!(
3814 ppoll_timeout_duration(Timespec {
3815 tv_sec: 2,
3816 tv_nsec: 345_678_901,
3817 }),
3818 Ok(Duration::new(2, 345_678_901))
3819 );
3820 assert_eq!(
3821 timespec_from_duration(Duration::new(2, 345_678_901)),
3822 Timespec {
3823 tv_sec: 2,
3824 tv_nsec: 345_678_901,
3825 }
3826 );
3827 }
3828
3829 #[test]
3830 fn pselect6_fd_set_lengths_follow_the_raw_linux_abi() {
3831 assert_eq!(PSELECT6_INTERNAL_MAX_NFDS, 64);
3832 assert_eq!(pselect6_fd_set_len(-1), Err(Errno::EINVAL));
3833 assert_eq!(pselect6_fd_set_len(0), Ok(0));
3834 assert_eq!(pselect6_fd_set_len(1), Ok(8));
3835 assert_eq!(pselect6_fd_set_len(65), Ok(16));
3836 assert_eq!(pselect6_fd_set_len(libc::FD_SETSIZE as i32), Ok(128));
3837 }
3838
3839 #[test]
3840 fn pselect6_probe_result_maps_only_erestartsys_to_eintr() {
3841 assert_eq!(
3842 pselect6_probe_result(Err(Errno::ERESTARTSYS)),
3843 Err(Errno::EINTR)
3844 );
3845
3846 assert_eq!(pselect6_probe_result(Ok(0)), Ok(0));
3847 assert_eq!(pselect6_probe_result(Ok(1)), Ok(1));
3848 assert_eq!(pselect6_probe_result(Err(Errno::EBADF)), Err(Errno::EBADF));
3849 assert_eq!(
3850 pselect6_probe_result(Err(Errno::EINVAL)),
3851 Err(Errno::EINVAL)
3852 );
3853 assert_eq!(pselect6_probe_result(Err(Errno::EINTR)), Err(Errno::EINTR));
3854 }
3855
3856 #[test]
3857 fn select_timeout_folds_whole_seconds_out_of_microseconds() {
3858 let timeval = |tv_sec, tv_usec| libc::timeval { tv_sec, tv_usec };
3859 assert_eq!(
3860 select_timeout_duration(timeval(0, 1_500_000)),
3861 Ok(Duration::new(1, 500_000_000))
3862 );
3863 assert_eq!(
3864 select_timeout_duration(timeval(2, 3_000_001)),
3865 Ok(Duration::new(5, 1_000))
3866 );
3867 assert_eq!(
3868 select_timeout_duration(timeval(0, 999_999)),
3869 Ok(Duration::new(0, 999_999_000))
3870 );
3871 assert_eq!(select_timeout_duration(timeval(0, -1)), Err(Errno::EINVAL));
3872 assert_eq!(select_timeout_duration(timeval(-1, 0)), Err(Errno::EINVAL));
3873 assert_eq!(
3876 select_timeout_duration(timeval(2, -1_000_000)),
3877 Err(Errno::EINVAL)
3878 );
3879 assert_eq!(
3880 select_timeout_duration(timeval(-1, 2_000_000)),
3881 Err(Errno::EINVAL)
3882 );
3883 assert_eq!(select_timeout_duration(timeval(1, -1)), Err(Errno::EINVAL));
3884 assert_eq!(
3885 select_timeout_duration(timeval(libc::time_t::MAX, 1_000_000)),
3886 Err(Errno::EINVAL)
3887 );
3888 }
3889
3890 #[test]
3891 fn ppoll_signal_mask_keeps_reverie_preemption_unblocked() {
3892 let preemption_bit = 1_u64 << ((reverie::PERF_EVENT_SIGNAL as usize) - 1);
3893 assert_eq!(sanitize_ppoll_signal_mask(u64::MAX), !preemption_bit);
3894 }
3895
3896 #[test]
3897 fn ppoll_record_replay_waits_are_kernel_waits_and_run_mode_masked_waits_probe() {
3898 assert!(ppoll_uses_kernel_wait(true, true));
3900 assert!(!ppoll_uses_kernel_wait(true, false));
3902 assert!(ppoll_uses_kernel_wait(false, false));
3904 assert!(ppoll_uses_kernel_wait(false, true));
3905 }
3906
3907 #[test]
3908 fn ppoll_timeout_rejects_invalid_timespecs() {
3909 assert_eq!(
3910 ppoll_timeout_duration(Timespec {
3911 tv_sec: -1,
3912 tv_nsec: 0,
3913 }),
3914 Err(Errno::EINVAL)
3915 );
3916 assert_eq!(
3917 ppoll_timeout_duration(Timespec {
3918 tv_sec: 0,
3919 tv_nsec: 1_000_000_000,
3920 }),
3921 Err(Errno::EINVAL)
3922 );
3923 }
3924
3925 #[test]
3926 fn socket_timestamp_control_messages_use_logical_time() {
3927 let header_len = cmsg_align(std::mem::size_of::<libc::cmsghdr>());
3928 let timeval_len = std::mem::size_of::<libc::timeval>();
3929 let timespec_len = std::mem::size_of::<libc::timespec>();
3930 let first_len = header_len + timeval_len;
3931 let second_offset = cmsg_align(first_len);
3932 let second_len = header_len + timespec_len;
3933 let third_offset = second_offset + cmsg_align(second_len);
3934 let third_len = header_len + std::mem::size_of::<i32>();
3935 let mut control = vec![0; third_offset + cmsg_align(third_len)];
3936
3937 assert!(write_control_value(
3938 &mut control,
3939 libc::cmsghdr {
3940 cmsg_len: first_len,
3941 cmsg_level: libc::SOL_SOCKET,
3942 cmsg_type: SCM_TIMESTAMP_OLD,
3943 }
3944 ));
3945 assert!(write_control_value(
3946 &mut control[header_len..],
3947 libc::timeval {
3948 tv_sec: 99,
3949 tv_usec: 88,
3950 }
3951 ));
3952 assert!(write_control_value(
3953 &mut control[second_offset..],
3954 libc::cmsghdr {
3955 cmsg_len: second_len,
3956 cmsg_level: libc::SOL_SOCKET,
3957 cmsg_type: SCM_TIMESTAMPNS_OLD,
3958 }
3959 ));
3960 assert!(write_control_value(
3961 &mut control[second_offset + header_len..],
3962 libc::timespec {
3963 tv_sec: 77,
3964 tv_nsec: 66,
3965 }
3966 ));
3967 assert!(write_control_value(
3968 &mut control[third_offset..],
3969 libc::cmsghdr {
3970 cmsg_len: third_len,
3971 cmsg_level: libc::SOL_SOCKET,
3972 cmsg_type: libc::SCM_RIGHTS,
3973 }
3974 ));
3975 assert!(write_control_value(
3976 &mut control[third_offset + header_len..],
3977 42_i32
3978 ));
3979 let unrelated_message = control[third_offset..].to_vec();
3980
3981 assert_eq!(
3982 canonicalize_socket_timestamps(&mut control, LogicalTime::from_nanos(2_345_678_901)),
3983 2
3984 );
3985 let timeval = read_control_value::<libc::timeval>(&control[header_len..]).unwrap();
3986 assert_eq!(timeval.tv_sec, 2);
3987 assert_eq!(timeval.tv_usec, 345_678);
3988 let timespec =
3989 read_control_value::<libc::timespec>(&control[second_offset + header_len..]).unwrap();
3990 assert_eq!(timespec.tv_sec, 2);
3991 assert_eq!(timespec.tv_nsec, 345_678_901);
3992 assert_eq!(control[third_offset..], unrelated_message);
3993 }
3994
3995 #[test]
3996 fn truncated_timestamp_payload_prefix_is_rewritten() {
3997 let header_len = cmsg_align(std::mem::size_of::<libc::cmsghdr>());
3998 let full_len = header_len + std::mem::size_of::<libc::timeval>();
3999 let mut control = vec![0xaa; header_len + std::mem::size_of::<i32>()];
4000 assert!(write_control_value(
4001 &mut control,
4002 libc::cmsghdr {
4003 cmsg_len: full_len,
4004 cmsg_level: libc::SOL_SOCKET,
4005 cmsg_type: SCM_TIMESTAMP_OLD,
4006 }
4007 ));
4008
4009 assert_eq!(
4010 canonicalize_socket_timestamps(&mut control, LogicalTime::from_nanos(2_345_678_901)),
4011 1
4012 );
4013 assert_eq!(
4014 read_control_value::<i32>(&control[header_len..]),
4015 Some(2),
4016 "the visible timeval prefix must not retain host seconds"
4017 );
4018 }
4019
4020 #[test]
4021 fn timestamping_preserves_populated_source_slots() {
4022 let header_len = cmsg_align(std::mem::size_of::<libc::cmsghdr>());
4023 let timespec_len = std::mem::size_of::<libc::timespec>();
4024 let message_len = header_len + 3 * timespec_len;
4025 let mut control = vec![0; cmsg_align(message_len)];
4026 assert!(write_control_value(
4027 &mut control,
4028 libc::cmsghdr {
4029 cmsg_len: message_len,
4030 cmsg_level: libc::SOL_SOCKET,
4031 cmsg_type: SCM_TIMESTAMPING_OLD,
4032 }
4033 ));
4034 let zero = libc::timespec {
4035 tv_sec: 0,
4036 tv_nsec: 0,
4037 };
4038 let populated = libc::timespec {
4039 tv_sec: 99,
4040 tv_nsec: 88,
4041 };
4042 assert!(write_control_value(&mut control[header_len..], zero));
4043 assert!(write_control_value(
4044 &mut control[header_len + timespec_len..],
4045 populated
4046 ));
4047 assert!(write_control_value(
4048 &mut control[header_len + 2 * timespec_len..],
4049 populated
4050 ));
4051
4052 assert_eq!(
4053 canonicalize_socket_timestamps(&mut control, LogicalTime::from_nanos(2_345_678_901)),
4054 1
4055 );
4056 let first = read_control_value::<libc::timespec>(&control[header_len..]).unwrap();
4057 let second =
4058 read_control_value::<libc::timespec>(&control[header_len + timespec_len..]).unwrap();
4059 let third = read_control_value::<libc::timespec>(&control[header_len + 2 * timespec_len..])
4060 .unwrap();
4061 assert_eq!((first.tv_sec, first.tv_nsec), (0, 0));
4062 assert_eq!((second.tv_sec, second.tv_nsec), (2, 345_678_901));
4063 assert_eq!((third.tv_sec, third.tv_nsec), (2, 345_678_901));
4064 }
4065}