Auto merge of #115746 - tgross35:unnamed-threads-panic-message, r=<try>

Print thread ID in panic message

`panic!` does not print any identifying information for threads that are
unnamed. However, in many cases, the thread ID can be determined.

This changes the panic message from something like this:

    thread '<unnamed>' panicked at src/main.rs:3:5:
    explicit panic

To something like this:

    thread '<unnamed>' (0xff9bf) panicked at src/main.rs:3:5:
    explicit panic

Stack overflow messages are updated as well.

This change applies to both named and unnamed threads. The ID printed is
the OS integer thread ID rather than the Rust thread ID, which should
also be what debuggers print.

try-job: `dist-various-*`
try-job: `test-various-*`
try-job: `x86_64-msvc-*`

Author: rust-bors[bot]

library/std/src/panicking.rs

@@ -269,6 +269,7 @@ fn default_hook(info: &PanicHookInfo<'_>) {
 
         thread::with_current_name(|name| {
             let name = name.unwrap_or("<unnamed>");
+            let tid = thread::current_os_id().unwrap_or_default();
 
             // Try to write the panic message to a buffer first to prevent other concurrent outputs
             // interleaving with it.
@@ -277,7 +278,7 @@ fn default_hook(info: &PanicHookInfo<'_>) {
 
             let write_msg = |dst: &mut dyn crate::io::Write| {
                 // We add a newline to ensure the panic message appears at the start of a line.
-                writeln!(dst, "\nthread '{name}' panicked at {location}:\n{msg}")
+                writeln!(dst, "\nthread '{name}' ({tid:#x}) panicked at {location}:\n{msg}")
             };
 
             if write_msg(&mut cursor).is_ok() {

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

@@ -103,6 +103,10 @@ impl Thread {
     }
 }
 
+pub(crate) fn current_os_id() -> Option<u64> {
+    None
+}
+
 pub fn available_parallelism() -> io::Result<NonZero<usize>> {
     unsafe { Ok(NonZero::new_unchecked(hermit_abi::available_parallelism())) }
 }

library/std/src/sys/pal/itron/thread.rs

@@ -349,6 +349,10 @@ unsafe fn terminate_and_delete_current_task() -> ! {
     unsafe { crate::hint::unreachable_unchecked() };
 }
 
+pub(crate) fn current_os_id() -> Option<u64> {
+    None
+}
+
 pub fn available_parallelism() -> io::Result<NonZero<usize>> {
     super::unsupported()
 }

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

@@ -132,6 +132,10 @@ impl Drop for Thread {
     }
 }
 
+pub(crate) fn current_os_id() -> Option<u64> {
+    None
+}
+
 // Note: Both `sched_getaffinity` and `sysconf` are available but not functional on
 // teeos, so this function always returns an Error!
 pub fn available_parallelism() -> io::Result<NonZero<usize>> {

library/std/src/sys/pal/uefi/thread.rs

@@ -44,6 +44,10 @@ impl Thread {
     }
 }
 
+pub(crate) fn current_os_id() -> Option<u64> {
+    None
+}
+
 pub fn available_parallelism() -> io::Result<NonZero<usize>> {
     // UEFI is single threaded
     Ok(NonZero::new(1).unwrap())

library/std/src/sys/pal/unix/stack_overflow.rs

@@ -120,7 +120,8 @@ mod imp {
                     && thread_info.guard_page_range.contains(&fault_addr)
                 {
                     let name = thread_info.thread_name.as_deref().unwrap_or("<unknown>");
-                    rtprintpanic!("\nthread '{name}' has overflowed its stack\n");
+                    let tid = crate::thread::current_os_id().unwrap_or_default();
+                    rtprintpanic!("\nthread '{name}' ({tid:#x}) has overflowed its stack\n");
                     rtabort!("stack overflow");
                 }
             })
@@ -696,7 +697,8 @@ mod imp {
             if code == c::EXCEPTION_STACK_OVERFLOW {
                 crate::thread::with_current_name(|name| {
                     let name = name.unwrap_or("<unknown>");
-                    rtprintpanic!("\nthread '{name}' has overflowed its stack\n");
+                    let tid = crate::thread::current_os_id().unwrap_or_default();
+                    rtprintpanic!("\nthread '{name}' ({tid:#x}) has overflowed its stack\n");
                 });
             }
             c::EXCEPTION_CONTINUE_SEARCH

library/std/src/sys/pal/unix/thread.rs

@@ -318,6 +318,55 @@ impl Drop for Thread {
     }
 }
 
+pub(crate) fn current_os_id() -> Option<u64> {
+    // Most Unix platforms have a way to query an integer ID of the current thread, all with
+    // slightly different spellings.
+    cfg_if::cfg_if! {
+        // Linux-like and some BSDs have methods to get the current `pid_t`, which is an `i32` on
+        // these platforms.
+        if #[cfg(any(target_os = "android", target_os = "linux", target_os = "nto"))] {
+            // SAFETY: FFI call with no preconditions.
+            let id: libc::pid_t = unsafe { libc::gettid() };
+            Some(id as u64)
+        } else if #[cfg(target_os = "openbsd")] {
+            // SAFETY: FFI call with no preconditions.
+            let id: libc::pid_t = unsafe { libc::getthrid() };
+            Some(id as u64)
+        } else if #[cfg(target_os = "freebsd")] {
+            // SAFETY: FFI call with no preconditions.
+            let id: libc::c_int = unsafe { libc::pthread_getthreadid_np() };
+            Some(id as u64)
+        }
+
+        // Solaris, Illumos, and NetBSD are similar but their functions return a `u32`.
+        else if #[cfg(any(target_os = "illumos", target_os = "solaris"))] {
+            // SAFETY: FFI call with no preconditions.
+            let id: libc::thread_t = unsafe { libc::thr_self() };
+            Some(id.into())
+        } else if #[cfg(target_os = "netbsd")] {
+            let id: libc::lwpid_t = unsafe { libc::_lwp_self() };
+            Some(id.into())
+        }
+
+        // Apple allows querying arbitrary thread IDs, `thread=NULL` queries the current thread.
+        else if #[cfg(target_vendor = "apple")] {
+            let mut id = 0u64;
+            // SAFETY: `thread_id` is a valid pointer, no other preconditions.
+            let status: libc::c_int = unsafe { libc::pthread_threadid_np(0, &mut id) };
+            if status == 0 {
+                Some(id)
+            } else {
+                None
+            }
+        }
+
+        // As a fallback, return the pid which can be used to help identify a crashing process.
+        else {
+            Some(super::os::getpid().into())
+        }
+    }
+}
+
 #[cfg(any(
     target_os = "linux",
     target_os = "nto",

library/std/src/sys/pal/unsupported/thread.rs

@@ -31,6 +31,10 @@ impl Thread {
     }
 }
 
+pub(crate) fn current_os_id() -> Option<u64> {
+    None
+}
+
 pub fn available_parallelism() -> io::Result<NonZero<usize>> {
     unsupported()
 }

library/std/src/sys/pal/wasi/thread.rs

@@ -186,6 +186,10 @@ impl Thread {
     }
 }
 
+pub(crate) fn current_os_id() -> Option<u64> {
+    None
+}
+
 pub fn available_parallelism() -> io::Result<NonZero<usize>> {
     cfg_if::cfg_if! {
         if #[cfg(target_feature = "atomics")] {

library/std/src/sys/pal/windows/c/bindings.txt

@@ -2177,6 +2177,7 @@ GetSystemInfo
 GetSystemTimeAsFileTime
 GetSystemTimePreciseAsFileTime
 GetTempPathW
+GetThreadId
 GetUserProfileDirectoryW
 GetWindowsDirectoryW
 HANDLE