Update to rustix 0.38.35 and the new futex API. (#130)

Author: sunfishcode

Cargo.toml

@@ -15,7 +15,7 @@ include = ["src", "Cargo.toml", "COPYRIGHT", "LICENSE*", "/*.md"]
 
 [dependencies]
 linux-raw-sys = { version = "0.4.9", default-features = false, features = ["general", "no_std", "elf"] }
-rustix = { version = "0.38.34", default-features = false }
+rustix = { version = "0.38.35", default-features = false }
 bitflags = { version = "2.4.0", default-features = false }
 log = { version = "0.4.14", default-features = false, optional = true }
 rustix-futex-sync = { version = "0.2.1", optional = true }

src/arch/x86_64.rs

@@ -104,9 +104,10 @@ pub(super) unsafe fn relocation_load(ptr: usize) -> usize {
 /// Perform a single store operation, outside the Rust memory model.
 ///
 /// This function conceptually casts `ptr` to a `*mut *mut c_void` and stores
-/// a `*mut c_void` value to it. However, it does this using `asm`, and `usize`
-/// types which don't carry provenance, as it's used by `relocate` to perform
-/// relocations which cannot be expressed in the Rust memory model.
+/// `value` casted to `*mut c_void` through it. However, it does this using
+/// `asm`, and `usize` types which don't carry provenance, as it's used by
+/// `relocate` to perform relocations which cannot be expressed in the Rust
+/// memory model.
 ///
 /// # Safety
 ///

src/relocate.rs

@@ -284,7 +284,7 @@ pub(super) unsafe fn relocate(envp: *mut *mut u8) {
     #[cfg(debug_assertions)]
     {
         // Check that the page size is a power of two.
-        assert_eq!(auxv_page_size.count_ones(), 1);
+        assert!(auxv_page_size.is_power_of_two());
 
         // This code doesn't rely on the offset being page aligned, but it is
         // useful to check to make sure we computed it correctly.

src/thread/linux_raw.rs

@@ -20,7 +20,7 @@ use core::mem::{align_of, offset_of, size_of};
 use core::ptr::{copy_nonoverlapping, drop_in_place, null, null_mut, NonNull};
 use core::slice;
 use core::sync::atomic::Ordering::SeqCst;
-use core::sync::atomic::{AtomicI32, AtomicPtr, AtomicU8};
+use core::sync::atomic::{AtomicI32, AtomicPtr, AtomicU32, AtomicU8};
 use linux_raw_sys::elf::*;
 use rustix::io;
 use rustix::mm::{mmap_anonymous, mprotect, MapFlags, MprotectFlags, ProtFlags};
@@ -457,7 +457,7 @@ unsafe fn initialize_tls(
     )
     .fill(0);
 
-    let thread_id_ptr = (*metadata).thread.thread_id.as_ptr();
+    let thread_id_ptr = (*metadata).thread.thread_id.as_ptr().cast::<i32>();
 
     (newtls, thread_id_ptr)
 }
@@ -719,6 +719,13 @@ unsafe fn exit(return_value: Option<NonNull<c_void>>) -> ! {
             // no signals for the process are delivered to this thread.
             #[cfg(feature = "signal")]
             {
+                #[cfg(any(target_arch = "arm", target_arch = "x86"))]
+                let all = Sigset { sig: [!0, !0] };
+                #[cfg(any(
+                    target_arch = "aarch64",
+                    target_arch = "riscv64",
+                    target_arch = "x86_64"
+                ))]
                 let all = Sigset { sig: [!0] };
                 sigprocmask(How::BLOCK, Some(&all)).ok();
             }
@@ -857,7 +864,7 @@ pub unsafe fn join(thread: Thread) -> Option<NonNull<c_void>> {
 /// `thread` must point to a valid thread record that has not already been
 /// detached or joined.
 unsafe fn wait_for_exit(thread: Thread) {
-    use rustix::thread::{futex, FutexFlags, FutexOperation};
+    use rustix::thread::futex;
 
     // Check whether the thread has exited already; we set the
     // `CloneFlags::CHILD_CLEARTID` flag on the clone syscall, so we can test
@@ -869,14 +876,11 @@ unsafe fn wait_for_exit(thread: Thread) {
         // `FutexFlags::PRIVATE` because the wake comes from Linux
         // as arranged by the `CloneFlags::CHILD_CLEARTID` flag,
         // and Linux doesn't use the private flag for the wake.
-        match futex(
-            thread_id.as_ptr().cast::<u32>(),
-            FutexOperation::Wait,
-            FutexFlags::empty(),
+        match futex::wait(
+            AtomicU32::from_ptr(thread_id.as_ptr().cast()),
+            futex::Flags::empty(),
             id_value.as_raw_nonzero().get() as u32,
-            null(),
-            null_mut(),
-            0,
+            None,
         ) {
             Ok(_) => break,
             Err(io::Errno::INTR) => continue,