std: split up the thread module

Author: joboet

library/std/src/thread/builder.rs

@@ -1,6 +1,9 @@
-use super::{Thread, ThreadId, imp};
+use super::id::ThreadId;
+use super::main_thread;
+use super::thread::Thread;
 use crate::mem::ManuallyDrop;
 use crate::ptr;
+use crate::sys::thread as imp;
 use crate::sys::thread_local::local_pointer;
 
 const NONE: *mut () = ptr::null_mut();
@@ -184,7 +187,7 @@ pub(crate) fn current_os_id() -> u64 {
 
 /// Gets a reference to the handle of the thread that invokes it, if the handle
 /// has been initialized.
-pub(super) fn try_with_current<F, R>(f: F) -> R
+fn try_with_current<F, R>(f: F) -> R
 where
     F: FnOnce(Option<&Thread>) -> R,
 {
@@ -202,6 +205,36 @@ where
     }
 }
 
+/// Run a function with the current thread's name.
+///
+/// Modulo thread local accesses, this function is safe to call from signal
+/// handlers and in similar circumstances where allocations are not possible.
+pub(crate) fn with_current_name<F, R>(f: F) -> R
+where
+    F: FnOnce(Option<&str>) -> R,
+{
+    try_with_current(|thread| {
+        let name = if let Some(thread) = thread {
+            // If there is a current thread handle, try to use the name stored
+            // there.
+            thread.name()
+        } else if let Some(main) = main_thread::get()
+            && let Some(id) = id::get()
+            && id == main
+        {
+            // The main thread doesn't always have a thread handle, we must
+            // identify it through its ID instead. The checks are ordered so
+            // that the current ID is only loaded if it is actually needed,
+            // since loading it from TLS might need multiple expensive accesses.
+            Some("main")
+        } else {
+            None
+        };
+
+        f(name)
+    })
+}
+
 /// Gets a handle to the thread that invokes it. If the handle stored in thread-
 /// local storage was already destroyed, this creates a new unnamed temporary
 /// handle to allow thread parking in nearly all situations.