Rename some runtime functions to kernel_*. (#1342)

To help avoid confusion with functions that have the same name as libc
functions but have behavior that differs from similarly-named libc functions,
rename `runtime::fork` and similar to `runtime::kernel_fork` and similar.
Also rename types such as `Sigaction` and similar to `KernelSigaction` and
similar. And rename `SIGRTMIN`/`SIGRTMAX` to
`KERNEL_SIGRTMIN`/`KERNEL_SIGRTMAX`.

These make it easier to keep these are the kernel items straight from the
similarly-named libc structures.

Author: sunfishcode

src/backend/linux_raw/runtime/syscalls.rs

@@ -21,20 +21,19 @@ use crate::ffi::CStr;
 use crate::fs::AtFlags;
 use crate::io;
 use crate::pid::{Pid, RawPid};
-use crate::runtime::{Fork, How, Sigaction, Siginfo, Sigset, Stack};
+use crate::runtime::{Fork, How, KernelSigSet, KernelSigaction, SigSet, Siginfo, Stack};
 use crate::signal::Signal;
 use crate::timespec::Timespec;
 use crate::utils::option_as_ptr;
 use core::ffi::c_void;
 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;
 #[cfg(target_arch = "x86_64")]
 use linux_raw_sys::general::ARCH_SET_FS;
 
 #[inline]
-pub(crate) unsafe fn fork() -> io::Result<Fork> {
+pub(crate) unsafe fn kernel_fork() -> io::Result<Fork> {
     let mut child_pid = MaybeUninit::<RawPid>::uninit();
 
     // Unix `fork` only returns the child PID in the parent; we'd like it in
@@ -148,15 +147,18 @@ pub(crate) mod tls {
 }
 
 #[inline]
-pub(crate) unsafe fn sigaction(signal: Signal, new: Option<Sigaction>) -> io::Result<Sigaction> {
-    let mut old = MaybeUninit::<Sigaction>::uninit();
+pub(crate) unsafe fn kernel_sigaction(
+    signal: Signal,
+    new: Option<KernelSigaction>,
+) -> io::Result<KernelSigaction> {
+    let mut old = MaybeUninit::<KernelSigaction>::uninit();
     let new = option_as_ptr(new.as_ref());
     ret(syscall!(
         __NR_rt_sigaction,
         signal,
         new,
         &mut old,
-        size_of::<kernel_sigset_t, _>()
+        size_of::<KernelSigSet, _>()
     ))?;
     Ok(old.assume_init())
 }
@@ -175,73 +177,76 @@ pub(crate) unsafe fn tkill(tid: Pid, sig: Signal) -> io::Result<()> {
 }
 
 #[inline]
-pub(crate) unsafe fn sigprocmask(how: How, new: Option<&Sigset>) -> io::Result<Sigset> {
-    let mut old = MaybeUninit::<Sigset>::uninit();
+pub(crate) unsafe fn kernel_sigprocmask(
+    how: How,
+    new: Option<&KernelSigSet>,
+) -> io::Result<KernelSigSet> {
+    let mut old = MaybeUninit::<KernelSigSet>::uninit();
     let new = option_as_ptr(new);
     ret(syscall!(
         __NR_rt_sigprocmask,
         how,
         new,
         &mut old,
-        size_of::<kernel_sigset_t, _>()
+        size_of::<KernelSigSet, _>()
     ))?;
     Ok(old.assume_init())
 }
 
 #[inline]
-pub(crate) fn sigpending() -> Sigset {
-    let mut pending = MaybeUninit::<Sigset>::uninit();
+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, _>()
+            size_of::<SigSet, _>()
         ));
         pending.assume_init()
     }
 }
 
 #[inline]
-pub(crate) fn sigsuspend(set: &Sigset) -> io::Result<()> {
+pub(crate) fn sigsuspend(set: &SigSet) -> io::Result<()> {
     unsafe {
         ret(syscall_readonly!(
             __NR_rt_sigsuspend,
             by_ref(set),
-            size_of::<kernel_sigset_t, _>()
+            size_of::<SigSet, _>()
         ))
     }
 }
 
 #[inline]
-pub(crate) fn sigwait(set: &Sigset) -> io::Result<Signal> {
+pub(crate) fn sigwait(set: &SigSet) -> io::Result<Signal> {
     unsafe {
         Ok(Signal::from_raw_unchecked(ret_c_int(syscall_readonly!(
             __NR_rt_sigtimedwait,
             by_ref(set),
             zero(),
             zero(),
-            size_of::<kernel_sigset_t, _>()
+            size_of::<SigSet, _>()
         ))?))
     }
 }
 
 #[inline]
-pub(crate) fn sigwaitinfo(set: &Sigset) -> io::Result<Siginfo> {
+pub(crate) fn sigwaitinfo(set: &SigSet) -> io::Result<Siginfo> {
     let mut info = MaybeUninit::<Siginfo>::uninit();
     unsafe {
         let _signum = ret_c_int(syscall!(
             __NR_rt_sigtimedwait,
             by_ref(set),
             &mut info,
             zero(),
-            size_of::<kernel_sigset_t, _>()
+            size_of::<SigSet, _>()
         ))?;
         Ok(info.assume_init())
     }
 }
 
 #[inline]
-pub(crate) fn sigtimedwait(set: &Sigset, timeout: Option<Timespec>) -> io::Result<Siginfo> {
+pub(crate) fn sigtimedwait(set: &SigSet, timeout: Option<Timespec>) -> io::Result<Siginfo> {
     let mut info = MaybeUninit::<Siginfo>::uninit();
     let timeout_ptr = option_as_ptr(timeout.as_ref());
 
@@ -255,7 +260,7 @@ pub(crate) fn sigtimedwait(set: &Sigset, timeout: Option<Timespec>) -> io::Resul
             by_ref(set),
             &mut info,
             timeout_ptr,
-            size_of::<kernel_sigset_t, _>()
+            size_of::<SigSet, _>()
         )) {
             Ok(_signum) => (),
             Err(io::Errno::NOSYS) => sigtimedwait_old(set, timeout, &mut info)?,
@@ -271,15 +276,15 @@ pub(crate) fn sigtimedwait(set: &Sigset, timeout: Option<Timespec>) -> io::Resul
             by_ref(set),
             &mut info,
             timeout_ptr,
-            size_of::<kernel_sigset_t, _>()
+            size_of::<SigSet, _>()
         ))?;
         Ok(info.assume_init())
     }
 }
 
 #[cfg(target_pointer_width = "32")]
 unsafe fn sigtimedwait_old(
-    set: &Sigset,
+    set: &SigSet,
     timeout: Option<Timespec>,
     info: &mut MaybeUninit<Siginfo>,
 ) -> io::Result<()> {
@@ -298,7 +303,7 @@ unsafe fn sigtimedwait_old(
         by_ref(set),
         info,
         old_timeout_ptr,
-        size_of::<kernel_sigset_t, _>()
+        size_of::<SigSet, _>()
     ))?;
 
     Ok(())
@@ -310,7 +315,7 @@ pub(crate) fn exit_group(code: c::c_int) -> ! {
 }
 
 #[inline]
-pub(crate) unsafe fn brk(addr: *mut c::c_void) -> io::Result<*mut c_void> {
+pub(crate) unsafe fn kernel_brk(addr: *mut c::c_void) -> io::Result<*mut c_void> {
     // This is non-`readonly`, to prevent loads from being reordered past it.
     ret_void_star(syscall!(__NR_brk, addr))
 }

src/runtime.rs

@@ -62,38 +62,49 @@ pub use crate::signal::Signal;
 /// If we want to expose this in public APIs, we should encapsulate the
 /// `linux_raw_sys` type.
 #[cfg(linux_raw)]
-pub type Sigaction = linux_raw_sys::general::kernel_sigaction;
+pub use linux_raw_sys::general::kernel_sigaction as KernelSigaction;
 
 /// `stack_t`
 ///
 /// If we want to expose this in public APIs, we should encapsulate the
 /// `linux_raw_sys` type.
 #[cfg(linux_raw)]
-pub type Stack = linux_raw_sys::general::stack_t;
+pub use linux_raw_sys::general::stack_t as Stack;
 
-/// `sigset_t`.
+/// `sigset_t`
 ///
-/// Undefined behavior could happen in some functions if `Sigset` ever
-/// contains signal numbers in the range from
-/// `linux_raw_sys::general::SIGRTMIN` to what the libc thinks `SIGRTMIN` is.
-/// Unless you are implementing the libc. Which you may indeed be doing, if
-/// you're reading this.
+/// Undefined behavior could happen in some functions if `SigSet` ever
+/// contains signal numbers in the range from `KERNEL_SIGRTMIN` to the libc
+/// `SIGRTMIN`. Unless you are implementing the libc. Which you may indeed be
+/// doing, if you're reading this.
 ///
 /// If we want to expose this in public APIs, we should encapsulate the
 /// `linux_raw_sys` type.
 #[cfg(linux_raw)]
-pub type Sigset = linux_raw_sys::general::kernel_sigset_t;
+pub use linux_raw_sys::general::sigset_t as SigSet;
+
+/// `kernel_sigset_t`.
+///
+/// Undefined behavior could happen in some functions if `KernelSigSet` ever
+/// contains signal numbers in the range from `KERNEL_SIGRTMIN` to the libc
+/// `SIGRTMIN`. Unless you are implementing the libc. Which you may indeed be
+/// doing, if you're reading this.
+///
+/// If we want to expose this in public APIs, we should encapsulate the
+/// `linux_raw_sys` type.
+#[cfg(linux_raw)]
+pub use linux_raw_sys::general::kernel_sigset_t as KernelSigSet;
 
 /// `siginfo_t`
 ///
 /// If we want to expose this in public APIs, we should encapsulate the
 /// `linux_raw_sys` type.
 #[cfg(linux_raw)]
-pub type Siginfo = linux_raw_sys::general::siginfo_t;
+pub use linux_raw_sys::general::siginfo_t as Siginfo;
 
 pub use crate::timespec::{Nsecs, Secs, Timespec};
 
-/// `SIG_*` constants for use with [`sigprocmask`].
+/// `SIG_*` constants for use with [`kernel_sigprocmask`].
 #[cfg(linux_raw)]
 #[repr(u32)]
 pub enum How {
@@ -341,8 +352,8 @@ pub use backend::runtime::tls::StartupTlsInfo;
 /// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/fork.html
 /// [Linux]: https://man7.org/linux/man-pages/man2/fork.2.html
 /// [async-signal-safe]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/V2_chap02.html#tag_15_04_03
-pub unsafe fn fork() -> io::Result<Fork> {
-    backend::runtime::syscalls::fork()
+pub unsafe fn kernel_fork() -> io::Result<Fork> {
+    backend::runtime::syscalls::kernel_fork()
 }
 
 /// Regular Unix `fork` doesn't tell the child its own PID because it assumes
@@ -423,8 +434,11 @@ pub unsafe fn execve(path: &CStr, argv: *const *const u8, envp: *const *const u8
 /// [POSIX]: https://pubs.opengroup.org/onlinepubs/9799919799/functions/sigaction.html
 /// [Linux]: https://man7.org/linux/man-pages/man2/sigaction.2.html
 #[inline]
-pub unsafe fn sigaction(signal: Signal, new: Option<Sigaction>) -> io::Result<Sigaction> {
-    backend::runtime::syscalls::sigaction(signal, new)
+pub unsafe fn kernel_sigaction(
+    signal: Signal,
+    new: Option<KernelSigaction>,
+) -> io::Result<KernelSigaction> {
+    backend::runtime::syscalls::kernel_sigaction(signal, new)
 }
 
 /// `sigaltstack(new, old)`—Modify or query a signal stack.
@@ -479,8 +493,8 @@ pub unsafe fn tkill(tid: Pid, sig: Signal) -> io::Result<()> {
 #[inline]
 #[doc(alias = "pthread_sigmask")]
 #[doc(alias = "rt_sigprocmask")]
-pub unsafe fn sigprocmask(how: How, set: Option<&Sigset>) -> io::Result<Sigset> {
-    backend::runtime::syscalls::sigprocmask(how, set)
+pub unsafe fn kernel_sigprocmask(how: How, set: Option<&KernelSigSet>) -> io::Result<KernelSigSet> {
+    backend::runtime::syscalls::kernel_sigprocmask(how, set)
 }
 
 /// `sigpending()`—Query the pending signals.
@@ -493,7 +507,7 @@ pub unsafe fn sigprocmask(how: How, set: Option<&Sigset>) -> io::Result<Sigset>
 ///
 /// [Linux `sigpending`]: https://man7.org/linux/man-pages/man2/sigpending.2.html
 #[inline]
-pub fn sigpending() -> Sigset {
+pub fn sigpending() -> SigSet {
     backend::runtime::syscalls::sigpending()
 }
 
@@ -507,7 +521,7 @@ pub fn sigpending() -> Sigset {
 ///
 /// [Linux `sigsuspend`]: https://man7.org/linux/man-pages/man2/sigsuspend.2.html
 #[inline]
-pub fn sigsuspend(set: &Sigset) -> io::Result<()> {
+pub fn sigsuspend(set: &SigSet) -> io::Result<()> {
     backend::runtime::syscalls::sigsuspend(set)
 }
 
@@ -524,7 +538,7 @@ pub fn sigsuspend(set: &Sigset) -> io::Result<()> {
 ///
 /// [Linux]: https://man7.org/linux/man-pages/man3/sigwait.3.html
 #[inline]
-pub unsafe fn sigwait(set: &Sigset) -> io::Result<Signal> {
+pub unsafe fn sigwait(set: &SigSet) -> io::Result<Signal> {
     backend::runtime::syscalls::sigwait(set)
 }
 
@@ -541,7 +555,7 @@ pub unsafe fn sigwait(set: &Sigset) -> io::Result<Signal> {
 ///
 /// [Linux]: https://man7.org/linux/man-pages/man2/sigwaitinfo.2.html
 #[inline]
-pub unsafe fn sigwaitinfo(set: &Sigset) -> io::Result<Siginfo> {
+pub unsafe fn sigwaitinfo(set: &SigSet) -> io::Result<Siginfo> {
     backend::runtime::syscalls::sigwaitinfo(set)
 }
 
@@ -558,7 +572,7 @@ pub unsafe fn sigwaitinfo(set: &Sigset) -> io::Result<Siginfo> {
 ///
 /// [Linux]: https://man7.org/linux/man-pages/man2/sigtimedwait.2.html
 #[inline]
-pub unsafe fn sigtimedwait(set: &Sigset, timeout: Option<Timespec>) -> io::Result<Siginfo> {
+pub unsafe fn sigtimedwait(set: &SigSet, timeout: Option<Timespec>) -> io::Result<Siginfo> {
     backend::runtime::syscalls::sigtimedwait(set, timeout)
 }
 
@@ -598,8 +612,8 @@ pub fn linux_secure() -> bool {
 /// (perhaps because you yourself are implementing a libc).
 #[cfg(linux_raw)]
 #[inline]
-pub unsafe fn brk(addr: *mut c_void) -> io::Result<*mut c_void> {
-    backend::runtime::syscalls::brk(addr)
+pub unsafe fn kernel_brk(addr: *mut c_void) -> io::Result<*mut c_void> {
+    backend::runtime::syscalls::kernel_brk(addr)
 }
 
 /// `SIGRTMIN`—The start of the raw OS “real-time” signal range.
@@ -609,9 +623,9 @@ pub unsafe fn brk(addr: *mut c_void) -> io::Result<*mut c_void> {
 /// won't share a process with a libc (perhaps because you yourself are
 /// implementing a libc).
 ///
-/// See [`sigrt`] for a convenient way to construct `SIGRTMIN + n` values.
+/// See [`sigrt`] for a convenient way to construct `KERNEL_SIGRTMIN + n` values.
 #[cfg(linux_raw)]
-pub const SIGRTMIN: i32 = linux_raw_sys::general::SIGRTMIN as i32;
+pub const KERNEL_SIGRTMIN: i32 = linux_raw_sys::general::SIGRTMIN as i32;
 
 /// `SIGRTMAX`—The last of the raw OS “real-time” signal range.
 ///
@@ -620,7 +634,7 @@ pub const SIGRTMIN: i32 = linux_raw_sys::general::SIGRTMIN as i32;
 /// won't share a process with a libc (perhaps because you yourself are
 /// implementing a libc).
 #[cfg(linux_raw)]
-pub const SIGRTMAX: i32 = {
+pub const KERNEL_SIGRTMAX: i32 = {
     // Use the actual `SIGRTMAX` value on platforms which define it.
     #[cfg(not(any(
         target_arch = "arm",
@@ -644,17 +658,17 @@ pub const SIGRTMAX: i32 = {
     }
 };
 
-/// Return a [`Signal`] corresponding to `SIGRTMIN + n`.
+/// Return a [`Signal`] corresponding to `KERNEL_SIGRTMIN + n`.
 ///
-/// This is similar to [`Signal::rt`], but uses the raw OS `SIGRTMIN` value
+/// This is similar to [`Signal::rt`], but uses the `KERNEL_SIGRTMIN` value
 /// instead of the libc `SIGRTMIN` value. Don't use this unless you know your
 /// code won't share a process with a libc (perhaps because you yourself are
 /// implementing a libc).
 #[cfg(linux_raw)]
 #[doc(alias = "SIGRTMIN")]
-pub const fn sigrt(n: i32) -> Option<Signal> {
-    let sig = SIGRTMIN.wrapping_add(n);
-    if sig >= SIGRTMIN && sig <= SIGRTMAX {
+pub const fn kernel_sigrt(n: i32) -> Option<Signal> {
+    let sig = KERNEL_SIGRTMIN.wrapping_add(n);
+    if sig >= KERNEL_SIGRTMIN && sig <= KERNEL_SIGRTMAX {
         // SAFETY: We've checked that `sig` is in the expected range. It could
         // still conflict with libc's reserved values, however users of the
         // `runtime` module here must already know that there's no other libc