Function kernel_sigtimedwait

src/backend/linux_raw/runtime/syscalls.rs:245–335

(
    set: &KernelSigSet,
    timeout: Option<&Timespec>,
)

#[inline]
pub(crate) unsafe fn kernel_sigtimedwait(
    set: &KernelSigSet,
    timeout: Option<&Timespec>,
) -> io::Result<Siginfo> {
    let mut info = MaybeUninit::<Siginfo>::uninit();

    // `rt_sigtimedwait_time64` was introduced in Linux 5.1. The old
    // `rt_sigtimedwait` syscall is not y2038-compatible on 32-bit
    // architectures.
    #[cfg(target_pointer_width = "32")]
    {
        // If we don't have Linux 5.1, and the timeout fits in a
        // `__kernel_old_timespec`, use plain `rt_sigtimedwait`.
        //
        // We do this unconditionally, rather than trying
        // `rt_sigtimedwait_time64` and falling back on `Errno::NOSYS`, because
        // seccomp configurations will sometimes abort the process on syscalls
        // they don't recognize.
        #[cfg(not(feature = "linux_5_1"))]
        {
            // If we don't have a timeout, or if we can convert the timeout to
            // a `__kernel_old_timespec`, the use `__NR_futex`.
            fn convert(timeout: &Timespec) -> Option<__kernel_old_timespec> {
                Some(__kernel_old_timespec {
                    tv_sec: timeout.tv_sec.try_into().ok()?,
                    tv_nsec: timeout.tv_nsec.try_into().ok()?,
                })
            }
            let old_timeout = if let Some(timeout) = timeout {
                match convert(timeout) {
                    // Could not convert timeout.
                    None => None,
                    // Could convert timeout. Ok!
                    Some(old_timeout) => Some(Some(old_timeout)),
                }
            } else {
                // No timeout. Ok!
                Some(None)
            };
            if let Some(old_timeout) = old_timeout {
                return ret_c_int(syscall!(
                    __NR_rt_sigtimedwait,
                    by_ref(set),
                    &mut info,
                    opt_ref(old_timeout.as_ref()),
                    size_of::<KernelSigSet, _>()
                ))
                .map(|sig| {
                    debug_assert_eq!(
                        sig,
                        info.assume_init_ref()
                            .__bindgen_anon_1
                            .__bindgen_anon_1
                            .si_signo
                    );
                    info.assume_init()
                });
            }