Implement more runtime signal-handling functions. (#949)

Implement `sigpending`, `sigsuspend`, `sigrtmin`, and `sigrtmax`. These
are not currently evaluated for use outside of libc implementations, so
they're in the `runtime` module.

Author: sunfishcode

src/backend/linux_raw/runtime/syscalls.rs

@@ -9,8 +9,8 @@ use crate::backend::c;
 #[cfg(target_arch = "x86")]
 use crate::backend::conv::by_mut;
 use crate::backend::conv::{
-    by_ref, c_int, c_uint, ret, ret_c_int, ret_c_int_infallible, ret_error, ret_void_star, size_of,
-    zero,
+    by_ref, c_int, c_uint, ret, ret_c_int, ret_c_int_infallible, ret_error, ret_infallible,
+    ret_void_star, size_of, zero,
 };
 #[cfg(feature = "fs")]
 use crate::fd::BorrowedFd;
@@ -28,9 +28,9 @@ use core::mem::MaybeUninit;
 #[cfg(target_pointer_width = "32")]
 use linux_raw_sys::general::__kernel_old_timespec;
 use linux_raw_sys::general::kernel_sigset_t;
-use linux_raw_sys::prctl::PR_SET_NAME;
 #[cfg(target_arch = "x86_64")]
-use {crate::backend::conv::ret_infallible, linux_raw_sys::general::ARCH_SET_FS};
+use linux_raw_sys::general::ARCH_SET_FS;
+use linux_raw_sys::prctl::PR_SET_NAME;
 
 #[inline]
 pub(crate) unsafe fn fork() -> io::Result<Fork> {
@@ -198,6 +198,30 @@ pub(crate) unsafe fn sigprocmask(how: How, new: Option<&Sigset>) -> io::Result<S
     Ok(old.assume_init())
 }
 
+#[inline]
+pub(crate) fn sigpending() -> Sigset {
+    let mut pending = MaybeUninit::<Sigset>::uninit();
+    unsafe {
+        ret_infallible(syscall!(
+            __NR_rt_sigpending,
+            &mut pending,
+            size_of::<kernel_sigset_t, _>()
+        ));
+        pending.assume_init()
+    }
+}
+
+#[inline]
+pub(crate) fn sigsuspend(set: &Sigset) -> io::Result<()> {
+    unsafe {
+        ret(syscall_readonly!(
+            __NR_rt_sigsuspend,
+            by_ref(set),
+            size_of::<kernel_sigset_t, _>()
+        ))
+    }
+}
+
 #[inline]
 pub(crate) fn sigwait(set: &Sigset) -> io::Result<Signal> {
     unsafe {

src/runtime.rs

@@ -443,6 +443,28 @@ pub unsafe fn sigprocmask(how: How, set: Option<&Sigset>) -> io::Result<Sigset>
     backend::runtime::syscalls::sigprocmask(how, set)
 }
 
+/// `sigpending()`—Query the pending signals.
+///
+/// # References
+///  - [Linux `sigpending`]
+///
+/// [Linux `sigpending`]: https://man7.org/linux/man-pages/man2/sigpending.2.html
+#[inline]
+pub fn sigpending() -> Sigset {
+    backend::runtime::syscalls::sigpending()
+}
+
+/// `sigsuspend(set)`—Suspend the calling thread and wait for signals.
+///
+/// # References
+///  - [Linux `sigsuspend`]
+///
+/// [Linux `sigsuspend`]: https://man7.org/linux/man-pages/man2/sigsuspend.2.html
+#[inline]
+pub fn sigsuspend(set: &Sigset) -> io::Result<()> {
+    backend::runtime::syscalls::sigsuspend(set)
+}
+
 /// `sigwait(set)`—Wait for signals.
 ///
 /// # Safety
@@ -531,3 +553,31 @@ pub fn linux_secure() -> bool {
 pub unsafe fn brk(addr: *mut c_void) -> io::Result<*mut c_void> {
     backend::runtime::syscalls::brk(addr)
 }
+
+/// `__SIGRTMIN`—The start of the realtime signal range.
+///
+/// This is the raw `SIGRTMIN` value from the OS, which is not the same as
+/// the `SIGRTMIN` macro provided by libc. Don't use this unless you are
+/// implementing libc.
+#[cfg(linux_raw)]
+pub const SIGRTMIN: u32 = linux_raw_sys::general::SIGRTMIN;
+
+/// `__SIGRTMAX`—The last of the realtime signal range.
+///
+/// This is the raw `SIGRTMAX` value from the OS, which is not the same as
+/// the `SIGRTMAX` macro provided by libc. Don't use this unless you are
+/// implementing libc.
+#[cfg(linux_raw)]
+pub const SIGRTMAX: u32 = {
+    // Use the actual `SIGRTMAX` value on platforms which define it.
+    #[cfg(not(any(target_arch = "arm", target_arch = "x86", target_arch = "x86_64")))]
+    {
+        linux_raw_sys::general::SIGRTMAX
+    }
+
+    // On platfoms that don't, derive it from `_NSIG`.
+    #[cfg(any(target_arch = "arm", target_arch = "x86", target_arch = "x86_64"))]
+    {
+        linux_raw_sys::general::_NSIG - 1
+    }
+};