Implement Thread::os_id

library/std/src/thread/current.rs

@@ -246,7 +246,9 @@ pub(crate) fn current_or_unnamed() -> Thread {
             (*current).clone()
         }
     } else if current == DESTROYED {
-        Thread::new(id::get_or_init(), None)
+        let thread = Thread::new(id::get_or_init(), None);
+        thread.set_os_id_to_current();
+        thread
     } else {
         init_current(current)
     }
@@ -292,6 +294,7 @@ fn init_current(current: *mut ()) -> Thread {
         // If the thread ID was initialized already, use it.
         let id = id::get_or_init();
         let thread = Thread::new(id, None);
+        thread.set_os_id_to_current();
 
         // Make sure that `crate::rt::thread_cleanup` will be run, which will
         // call `drop_current`.

library/std/src/thread/lifecycle.rs

@@ -141,6 +141,10 @@ impl ThreadInit {
             rtabort!("current thread handle already set during thread spawn");
         }
 
+        // The handle was created by the spawning thread, so only now that we are
+        // running can the OS id be filled in.
+        self.handle.set_os_id_to_current();
+
         if let Some(name) = self.handle.cname() {
             imp::set_name(name);
         }

library/std/src/thread/tests.rs

@@ -356,6 +356,19 @@ fn test_thread_os_id_not_equal() {
     assert!(current_id != spawned_id);
 }
 
+#[test]
+fn test_thread_os_id_matches_current() {
+    assert_eq!(thread::current().os_id(), crate::sys::thread::current_os_id());
+}
+
+#[test]
+fn test_thread_os_id_of_spawned_thread() {
+    let spawned = thread::spawn(|| thread::current().os_id());
+    let handle = spawned.thread().clone();
+    let seen_by_the_thread_itself = spawned.join().unwrap();
+    assert_eq!(handle.os_id(), seen_by_the_thread_itself);
+}
+
 #[test]
 fn test_scoped_threads_drop_result_before_join() {
     let actually_finished = &AtomicBool::new(false);

library/std/src/thread/thread.rs

@@ -6,6 +6,7 @@ use crate::fmt;
 use crate::pin::Pin;
 use crate::sync::Arc;
 use crate::sys::sync::Parker;
+use crate::sys::thread as imp;
 use crate::time::Duration;
 
 // This module ensures private fields are kept private, which is necessary to enforce the safety requirements.
@@ -40,6 +41,59 @@ mod thread_name_string {
 
 use thread_name_string::ThreadNameString;
 
+// The handle of a spawned thread exists before the thread does, so the thread
+// stores its own id once it starts running, hence the atomic. 0 means "not known".
+//
+// Of the platform calls behind `current_os_id`, only Apple's yields a `uint64_t`,
+// and every Apple target has 64-bit atomics, so `usize` loses nothing on the
+// second arm.
+cfg_select! {
+    target_has_atomic = "64" => {
+        use crate::sync::atomic::{Atomic, AtomicU64, Ordering::Relaxed};
+
+        struct OsId(Atomic<u64>);
+
+        impl OsId {
+            const fn unknown() -> Self {
+                Self(AtomicU64::new(0))
+            }
+
+            fn get(&self) -> Option<u64> {
+                match self.0.load(Relaxed) {
+                    0 => None,
+                    id => Some(id),
+                }
+            }
+
+            fn set(&self, id: u64) {
+                self.0.store(id, Relaxed);
+            }
+        }
+    }
+    _ => {
+        use crate::sync::atomic::{Atomic, AtomicUsize, Ordering::Relaxed};
+
+        struct OsId(Atomic<usize>);
+
+        impl OsId {
+            const fn unknown() -> Self {
+                Self(AtomicUsize::new(0))
+            }
+
+            fn get(&self) -> Option<u64> {
+                match self.0.load(Relaxed) {
+                    0 => None,
+                    id => Some(id as u64),
+                }
+            }
+
+            fn set(&self, id: u64) {
+                self.0.store(id as usize, Relaxed);
+            }
+        }
+    }
+}
+
 /// The internal representation of a `Thread` handle
 ///
 /// We explicitly set the alignment for our guarantee in Thread::into_raw. This
@@ -49,6 +103,7 @@ use thread_name_string::ThreadNameString;
 struct Inner {
     name: Option<ThreadNameString>,
     id: ThreadId,
+    os_id: OsId,
     parker: Parker,
 }
 
@@ -103,13 +158,25 @@ impl Thread {
             let ptr = Arc::get_mut_unchecked(&mut arc).as_mut_ptr();
             (&raw mut (*ptr).name).write(name);
             (&raw mut (*ptr).id).write(id);
+            (&raw mut (*ptr).os_id).write(OsId::unknown());
             Parker::new_in_place(&raw mut (*ptr).parker);
             Pin::new_unchecked(arc.assume_init())
         };
 
         Thread { inner }
     }
 
+    /// Records the OS id of the calling thread in this handle.
+    ///
+    /// May only be called from the thread to which this handle belongs. A
+    /// spawned thread does this itself once it starts running, since its handle
+    /// already exists by then.
+    pub(crate) fn set_os_id_to_current(&self) {
+        if let Some(os_id) = imp::current_os_id() {
+            self.inner.os_id.set(os_id);
+        }
+    }
+
     /// Like the public [`park`], but callable on any handle. This is used to
     /// allow parking in TLS destructors.
     ///
@@ -204,6 +271,35 @@ impl Thread {
         self.inner.id
     }
 
+    /// Gets the id the operating system gave this thread, if it has one that can
+    /// be read.
+    ///
+    /// This is the id `ps`, `top`, a debugger or a crash log shows, unlike
+    /// [`ThreadId`], which is internal to Rust and unrelated to it. `None` means
+    /// the platform has no such id or offers no way to read it, or that the
+    /// thread has not started running yet.
+    ///
+    /// The operating system may hand the same id to a later thread once this one
+    /// exits, so it does not name a thread uniquely over the life of the
+    /// process. It may also no longer refer to this thread at all, since any
+    /// thread but the current one can exit at any point. For anything other than
+    /// the current thread, logging is the only safe use.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// #![feature(thread_os_id)]
+    /// use std::thread;
+    ///
+    /// let spawned = thread::spawn(|| thread::current().os_id());
+    /// println!("spawned thread ran as {:?}", spawned.join().unwrap());
+    /// ```
+    #[unstable(feature = "thread_os_id", issue = "160215")]
+    #[must_use]
+    pub fn os_id(&self) -> Option<u64> {
+        self.inner.os_id.get()
+    }
+
     /// Gets the thread's name.
     ///
     /// For more information about named threads, see