std: pass the Thread for the newly spawned thread to the platform

Author: joboet

library/std/src/rt.rs

@@ -109,14 +109,16 @@ fn handle_rt_panic<T>(e: Box<dyn Any + Send>) -> T {
 // `compiler/rustc_session/src/config/sigpipe.rs`.
 #[cfg_attr(test, allow(dead_code))]
 unsafe fn init(argc: isize, argv: *const *const u8, sigpipe: u8) {
+    // Remember the main thread ID to give it the correct name. Do this
+    // immediately to make sure the correct name available to the platform
+    // functions.
+    // SAFETY: this is the only time and place where we call this function.
+    unsafe { main_thread::set(thread::current_id()) };
+
     #[cfg_attr(target_os = "teeos", allow(unused_unsafe))]
     unsafe {
         sys::init(argc, argv, sigpipe)
     };
-
-    // Remember the main thread ID to give it the correct name.
-    // SAFETY: this is the only time and place where we call this function.
-    unsafe { main_thread::set(thread::current_id()) };
 }
 
 /// Clean up the thread-local runtime state. This *should* be run after all other

library/std/src/sys/thread/hermit.rs

@@ -13,53 +13,62 @@ unsafe impl Sync for Thread {}
 
 pub const DEFAULT_MIN_STACK_SIZE: usize = 1 << 20;
 
+struct ThreadData {
+    handle: crate::thread::Thread,
+    main: Box<dyn FnOnce()>,
+}
+
 impl Thread {
     pub unsafe fn new_with_coreid(
         stack: usize,
-        p: Box<dyn FnOnce()>,
+        handle: crate::thread::Thread,
+        main: Box<dyn FnOnce()>,
         core_id: isize,
     ) -> io::Result<Thread> {
-        let p = Box::into_raw(Box::new(p));
+        let data = Box::into_raw(Box::new(ThreadData { handle, main }));
         let tid = unsafe {
             hermit_abi::spawn2(
                 thread_start,
-                p.expose_provenance(),
+                data.expose_provenance(),
                 hermit_abi::Priority::into(hermit_abi::NORMAL_PRIO),
                 stack,
                 core_id,
             )
         };
 
         return if tid == 0 {
-            // The thread failed to start and as a result p was not consumed. Therefore, it is
-            // safe to reconstruct the box so that it gets deallocated.
+            // The thread failed to start and as a result data was not consumed.
+            // Therefore, it is safe to reconstruct the box so that it gets
+            // deallocated.
             unsafe {
-                drop(Box::from_raw(p));
+                drop(Box::from_raw(data));
             }
             Err(io::const_error!(io::ErrorKind::Uncategorized, "unable to create thread!"))
         } else {
             Ok(Thread { tid })
         };
 
         extern "C" fn thread_start(main: usize) {
-            unsafe {
-                // Finally, let's run some code.
-                Box::from_raw(ptr::with_exposed_provenance::<Box<dyn FnOnce()>>(main).cast_mut())();
+            let data = unsafe {
+                Box::from_raw(ptr::with_exposed_provenance::<ThreadData>(main).cast_mut())
+            };
 
-                // run all destructors
-                crate::sys::thread_local::destructors::run();
-                crate::rt::thread_cleanup();
-            }
+            crate::thread::set_current(data.handle);
+            (data.main)();
+
+            // run all destructors
+            unsafe { crate::sys::thread_local::destructors::run() };
+            crate::rt::thread_cleanup();
         }
     }
 
     pub unsafe fn new(
         stack: usize,
-        _name: Option<&str>,
-        p: Box<dyn FnOnce()>,
+        handle: crate::thread::Thread,
+        main: Box<dyn FnOnce()>,
     ) -> io::Result<Thread> {
         unsafe {
-            Thread::new_with_coreid(stack, p, -1 /* = no specific core */)
+            Thread::new_with_coreid(stack, handle, main, -1 /* = no specific core */)
         }
     }
 

library/std/src/sys/thread/mod.rs

@@ -4,7 +4,7 @@ cfg_select! {
         pub use hermit::{Thread, available_parallelism, sleep, yield_now, DEFAULT_MIN_STACK_SIZE};
         #[expect(dead_code)]
         mod unsupported;
-        pub use unsupported::{current_os_id, set_name};
+        pub use unsupported::current_os_id;
     }
     all(target_vendor = "fortanix", target_env = "sgx") => {
         mod sgx;
@@ -21,41 +21,32 @@ cfg_select! {
         // as-is with the SGX target.
         #[expect(dead_code)]
         mod unsupported;
-        pub use unsupported::{available_parallelism, set_name};
+        pub use unsupported::available_parallelism;
     }
     target_os = "solid_asp3" => {
         mod solid;
         pub use solid::{Thread, sleep, yield_now, DEFAULT_MIN_STACK_SIZE};
         #[expect(dead_code)]
         mod unsupported;
-        pub use unsupported::{available_parallelism, current_os_id, set_name};
+        pub use unsupported::{available_parallelism, current_os_id};
     }
     target_os = "teeos" => {
         mod teeos;
         pub use teeos::{Thread, sleep, yield_now, DEFAULT_MIN_STACK_SIZE};
         #[expect(dead_code)]
         mod unsupported;
-        pub use unsupported::{available_parallelism, current_os_id, set_name};
+        pub use unsupported::{available_parallelism, current_os_id};
     }
     target_os = "uefi" => {
         mod uefi;
         pub use uefi::{available_parallelism, sleep};
         #[expect(dead_code)]
         mod unsupported;
-        pub use unsupported::{Thread, current_os_id, set_name, yield_now, DEFAULT_MIN_STACK_SIZE};
+        pub use unsupported::{Thread, current_os_id, yield_now, DEFAULT_MIN_STACK_SIZE};
     }
     target_family = "unix" => {
         mod unix;
         pub use unix::{Thread, available_parallelism, current_os_id, sleep, yield_now, DEFAULT_MIN_STACK_SIZE};
-        #[cfg(not(any(
-            target_env = "newlib",
-            target_os = "l4re",
-            target_os = "emscripten",
-            target_os = "redox",
-            target_os = "hurd",
-            target_os = "aix",
-        )))]
-        pub use unix::set_name;
         #[cfg(any(
             target_os = "freebsd",
             target_os = "netbsd",
@@ -69,17 +60,8 @@ cfg_select! {
             target_os = "vxworks",
         ))]
         pub use unix::sleep_until;
-        #[expect(dead_code)]
-        mod unsupported;
-        #[cfg(any(
-            target_env = "newlib",
-            target_os = "l4re",
-            target_os = "emscripten",
-            target_os = "redox",
-            target_os = "hurd",
-            target_os = "aix",
-        ))]
-        pub use unsupported::set_name;
+        // This is used to name the main thread in the platform init function.
+        pub(super) use unix::set_name;
     }
     all(target_os = "wasi", target_env = "p1") => {
         mod wasip1;
@@ -88,7 +70,7 @@ cfg_select! {
         pub use wasip1::{Thread, available_parallelism};
         #[expect(dead_code)]
         mod unsupported;
-        pub use unsupported::{current_os_id, set_name};
+        pub use unsupported::current_os_id;
         #[cfg(not(target_feature = "atomics"))]
         pub use unsupported::{Thread, available_parallelism};
     }
@@ -100,31 +82,31 @@ cfg_select! {
         // Note that unlike WASIp1 even if the wasm `atomics` feature is enabled
         // there is no support for threads, not even experimentally, not even in
         // wasi-libc. Thus this is unconditionally unsupported.
-        pub use unsupported::{Thread, available_parallelism, current_os_id, set_name, yield_now, DEFAULT_MIN_STACK_SIZE};
+        pub use unsupported::{Thread, available_parallelism, current_os_id, yield_now, DEFAULT_MIN_STACK_SIZE};
     }
     all(target_family = "wasm", target_feature = "atomics") => {
         mod wasm;
         pub use wasm::sleep;
 
         #[expect(dead_code)]
         mod unsupported;
-        pub use unsupported::{Thread, available_parallelism, current_os_id, set_name, yield_now, DEFAULT_MIN_STACK_SIZE};
+        pub use unsupported::{Thread, available_parallelism, current_os_id, yield_now, DEFAULT_MIN_STACK_SIZE};
     }
     target_os = "windows" => {
         mod windows;
-        pub use windows::{Thread, available_parallelism, current_os_id, set_name, set_name_wide, sleep, yield_now, DEFAULT_MIN_STACK_SIZE};
+        pub use windows::{Thread, available_parallelism, current_os_id, set_name_wide, sleep, yield_now, DEFAULT_MIN_STACK_SIZE};
     }
     target_os = "xous" => {
         mod xous;
         pub use xous::{Thread, available_parallelism, sleep, yield_now, DEFAULT_MIN_STACK_SIZE};
 
         #[expect(dead_code)]
         mod unsupported;
-        pub use unsupported::{current_os_id, set_name};
+        pub use unsupported::current_os_id;
     }
     _ => {
         mod unsupported;
-        pub use unsupported::{Thread, available_parallelism, current_os_id, set_name, sleep, yield_now, DEFAULT_MIN_STACK_SIZE};
+        pub use unsupported::{Thread, available_parallelism, current_os_id, sleep, yield_now, DEFAULT_MIN_STACK_SIZE};
     }
 }
 

library/std/src/sys/thread/sgx.rs

@@ -25,19 +25,24 @@ mod task_queue {
     }
 
     pub(super) struct Task {
-        p: Box<dyn FnOnce() + Send>,
+        handle: crate::thread::Thread,
+        main: Box<dyn FnOnce() + Send>,
         done: JoinNotifier,
     }
 
     impl Task {
-        pub(super) fn new(p: Box<dyn FnOnce() + Send>) -> (Task, JoinHandle) {
+        pub(super) fn new(
+            handle: crate::thread::Thread,
+            main: Box<dyn FnOnce() + Send>,
+        ) -> (Task, JoinHandle) {
             let (done, recv) = wait_notify::new();
             let done = JoinNotifier(Some(done));
-            (Task { p, done }, recv)
+            (Task { handle, main, done }, recv)
         }
 
         pub(super) fn run(self) -> JoinNotifier {
-            (self.p)();
+            crate::thread::set_current(self.handle);
+            (self.main)();
             self.done
         }
     }
@@ -95,12 +100,12 @@ impl Thread {
     // unsafe: see thread::Builder::spawn_unchecked for safety requirements
     pub unsafe fn new(
         _stack: usize,
-        _name: Option<&str>,
-        p: Box<dyn FnOnce() + Send>,
+        handle: crate::thread::Thread,
+        main: Box<dyn FnOnce() + Send>,
     ) -> io::Result<Thread> {
         let mut queue_lock = task_queue::lock();
         unsafe { usercalls::launch_thread()? };
-        let (task, handle) = task_queue::Task::new(p);
+        let (task, handle) = task_queue::Task::new(handle, main);
         queue_lock.push(task);
         Ok(Thread(handle))
     }

library/std/src/sys/thread/solid.rs

@@ -27,9 +27,9 @@ unsafe impl Sync for Thread {}
 /// State data shared between a parent thread and child thread. It's dropped on
 /// a transition to one of the final states.
 struct ThreadInner {
-    /// This field is used on thread creation to pass a closure from
-    /// `Thread::new` to the created task.
-    start: UnsafeCell<ManuallyDrop<Box<dyn FnOnce()>>>,
+    /// This field is used on thread creation to pass the thread handle and closure
+    /// to the newly created thread.
+    data: UnsafeCell<ManuallyDrop<(crate::thread::Thread, Box<dyn FnOnce()>)>>,
 
     /// A state machine. Each transition is annotated with `[...]` in the
     /// source code.
@@ -65,7 +65,7 @@ struct ThreadInner {
     lifecycle: Atomic<usize>,
 }
 
-// Safety: The only `!Sync` field, `ThreadInner::start`, is only touched by
+// Safety: The only `!Sync` field, `ThreadInner::data`, is only touched by
 //         the task represented by `ThreadInner`.
 unsafe impl Sync for ThreadInner {}
 
@@ -86,11 +86,11 @@ impl Thread {
     /// See `thread::Builder::spawn_unchecked` for safety requirements.
     pub unsafe fn new(
         stack: usize,
-        _name: Option<&str>,
-        p: Box<dyn FnOnce()>,
+        handle: crate::thread::Thread,
+        main: Box<dyn FnOnce()>,
     ) -> io::Result<Thread> {
         let inner = Box::new(ThreadInner {
-            start: UnsafeCell::new(ManuallyDrop::new(p)),
+            data: UnsafeCell::new(ManuallyDrop::new((handle, main))),
             lifecycle: AtomicUsize::new(LIFECYCLE_INIT),
         });
 
@@ -100,10 +100,11 @@ impl Thread {
             let inner = unsafe { &*p_inner };
 
             // Safety: Since `trampoline` is called only once for each
-            //         `ThreadInner` and only `trampoline` touches `start`,
-            //         `start` contains contents and is safe to mutably borrow.
-            let p = unsafe { ManuallyDrop::take(&mut *inner.start.get()) };
-            p();
+            //         `ThreadInner` and only `trampoline` touches `data`,
+            //         `data` contains contents and is safe to mutably borrow.
+            let (handle, main) = unsafe { ManuallyDrop::take(&mut *inner.data.get()) };
+            crate::thread::set_current(handle);
+            main();
 
             // Fix the current thread's state just in case, so that the
             // destructors won't abort

library/std/src/sys/thread/teeos.rs

@@ -22,14 +22,19 @@ pub struct Thread {
 unsafe impl Send for Thread {}
 unsafe impl Sync for Thread {}
 
+struct ThreadData {
+    handle: crate::thread::Thread,
+    main: Box<dyn FnOnce()>,
+}
+
 impl Thread {
     // unsafe: see thread::Builder::spawn_unchecked for safety requirements
     pub unsafe fn new(
         stack: usize,
-        _name: Option<&str>,
-        p: Box<dyn FnOnce()>,
+        handle: crate::thread::Thread,
+        main: Box<dyn FnOnce()>,
     ) -> io::Result<Thread> {
-        let p = Box::into_raw(Box::new(p));
+        let data = Box::into_raw(Box::new(ThreadData { handle, main }));
         let mut native: libc::pthread_t = unsafe { mem::zeroed() };
         let mut attr: libc::pthread_attr_t = unsafe { mem::zeroed() };
         assert_eq!(unsafe { libc::pthread_attr_init(&mut attr) }, 0);
@@ -62,16 +67,17 @@ impl Thread {
             }
         };
 
-        let ret = unsafe { libc::pthread_create(&mut native, &attr, thread_start, p as *mut _) };
-        // Note: if the thread creation fails and this assert fails, then p will
-        // be leaked. However, an alternative design could cause double-free
+        let ret = unsafe { libc::pthread_create(&mut native, &attr, thread_start, data as *mut _) };
+        // Note: if the thread creation fails and this assert fails, then data
+        // will be leaked. However, an alternative design could cause double-free
         // which is clearly worse.
         assert_eq!(unsafe { libc::pthread_attr_destroy(&mut attr) }, 0);
 
         return if ret != 0 {
-            // The thread failed to start and as a result p was not consumed. Therefore, it is
-            // safe to reconstruct the box so that it gets deallocated.
-            drop(unsafe { Box::from_raw(p) });
+            // The thread failed to start and as a result data was not consumed.
+            // Therefore, it is safe to reconstruct the box so that it gets
+            // deallocated.
+            drop(unsafe { Box::from_raw(data) });
             Err(io::Error::from_raw_os_error(ret))
         } else {
             // The new thread will start running earliest after the next yield.
@@ -80,15 +86,10 @@ impl Thread {
             Ok(Thread { id: native })
         };
 
-        extern "C" fn thread_start(main: *mut libc::c_void) -> *mut libc::c_void {
-            unsafe {
-                // Next, set up our stack overflow handler which may get triggered if we run
-                // out of stack.
-                // this is not necessary in TEE.
-                //let _handler = stack_overflow::Handler::new();
-                // Finally, let's run some code.
-                Box::from_raw(main as *mut Box<dyn FnOnce()>)();
-            }
+        extern "C" fn thread_start(data: *mut libc::c_void) -> *mut libc::c_void {
+            let data = unsafe { Box::from_raw(data as *mut ThreadData) };
+            crate::thread::set_current(data.handle);
+            (data.main)();
             ptr::null_mut()
         }
     }