std/thread/
current.rs

1use super::{Thread, ThreadId, imp};
2use crate::mem::ManuallyDrop;
3use crate::ptr;
4use crate::sys::thread_local::local_pointer;
5
6const NONE: *mut () = ptr::null_mut();
7const BUSY: *mut () = ptr::without_provenance_mut(1);
8const DESTROYED: *mut () = ptr::without_provenance_mut(2);
9
10local_pointer! {
11    static CURRENT;
12}
13
14/// Persistent storage for the thread ID.
15///
16/// We store the thread ID so that it never gets destroyed during the lifetime
17/// of a thread, either using `#[thread_local]` or multiple `local_pointer!`s.
18pub(super) mod id {
19    use super::*;
20
21    cfg_if::cfg_if! {
22        if #[cfg(target_thread_local)] {
23            use crate::cell::Cell;
24
25            #[thread_local]
26            static ID: Cell<Option<ThreadId>> = Cell::new(None);
27
28            pub(super) const CHEAP: bool = true;
29
30            pub(crate) fn get() -> Option<ThreadId> {
31                ID.get()
32            }
33
34            pub(super) fn set(id: ThreadId) {
35                ID.set(Some(id))
36            }
37        } else if #[cfg(target_pointer_width = "16")] {
38            local_pointer! {
39                static ID0;
40                static ID16;
41                static ID32;
42                static ID48;
43            }
44
45            pub(super) const CHEAP: bool = false;
46
47            pub(crate) fn get() -> Option<ThreadId> {
48                let id0 = ID0.get().addr() as u64;
49                let id16 = ID16.get().addr() as u64;
50                let id32 = ID32.get().addr() as u64;
51                let id48 = ID48.get().addr() as u64;
52                ThreadId::from_u64((id48 << 48) + (id32 << 32) + (id16 << 16) + id0)
53            }
54
55            pub(super) fn set(id: ThreadId) {
56                let val = id.as_u64().get();
57                ID0.set(ptr::without_provenance_mut(val as usize));
58                ID16.set(ptr::without_provenance_mut((val >> 16) as usize));
59                ID32.set(ptr::without_provenance_mut((val >> 32) as usize));
60                ID48.set(ptr::without_provenance_mut((val >> 48) as usize));
61            }
62        } else if #[cfg(target_pointer_width = "32")] {
63            local_pointer! {
64                static ID0;
65                static ID32;
66            }
67
68            pub(super) const CHEAP: bool = false;
69
70            pub(crate) fn get() -> Option<ThreadId> {
71                let id0 = ID0.get().addr() as u64;
72                let id32 = ID32.get().addr() as u64;
73                ThreadId::from_u64((id32 << 32) + id0)
74            }
75
76            pub(super) fn set(id: ThreadId) {
77                let val = id.as_u64().get();
78                ID0.set(ptr::without_provenance_mut(val as usize));
79                ID32.set(ptr::without_provenance_mut((val >> 32) as usize));
80            }
81        } else {
82            local_pointer! {
83                static ID;
84            }
85
86            pub(super) const CHEAP: bool = true;
87
88            pub(crate) fn get() -> Option<ThreadId> {
89                let id = ID.get().addr() as u64;
90                ThreadId::from_u64(id)
91            }
92
93            pub(super) fn set(id: ThreadId) {
94                let val = id.as_u64().get();
95                ID.set(ptr::without_provenance_mut(val as usize));
96            }
97        }
98    }
99
100    #[inline]
101    pub(super) fn get_or_init() -> ThreadId {
102        get().unwrap_or_else(
103            #[cold]
104            || {
105                let id = ThreadId::new();
106                id::set(id);
107                id
108            },
109        )
110    }
111}
112
113/// Tries to set the thread handle for the current thread. Fails if a handle was
114/// already set or if the thread ID of `thread` would change an already-set ID.
115pub(super) fn set_current(thread: Thread) -> Result<(), Thread> {
116    if CURRENT.get() != NONE {
117        return Err(thread);
118    }
119
120    match id::get() {
121        Some(id) if id == thread.id() => {}
122        None => id::set(thread.id()),
123        _ => return Err(thread),
124    }
125
126    // Make sure that `crate::rt::thread_cleanup` will be run, which will
127    // call `drop_current`.
128    crate::sys::thread_local::guard::enable();
129    CURRENT.set(thread.into_raw().cast_mut());
130    Ok(())
131}
132
133/// Gets the id of the thread that invokes it.
134///
135/// This function will always succeed, will always return the same value for
136/// one thread and is guaranteed not to call the global allocator.
137#[inline]
138pub(crate) fn current_id() -> ThreadId {
139    // If accessing the persistent thread ID takes multiple TLS accesses, try
140    // to retrieve it from the current thread handle, which will only take one
141    // TLS access.
142    if !id::CHEAP {
143        if let Some(id) = try_with_current(|t| t.map(|t| t.id())) {
144            return id;
145        }
146    }
147
148    id::get_or_init()
149}
150
151/// Gets the OS thread ID of the thread that invokes it, if available. If not, return the Rust
152/// thread ID.
153///
154/// We use a `u64` to all possible platform IDs without excess `cfg`; most use `int`, some use a
155/// pointer, and Apple uses `uint64_t`. This is a "best effort" approach for diagnostics and is
156/// allowed to fall back to a non-OS ID (such as the Rust thread ID) or a non-unique ID (such as a
157/// PID) if the thread ID cannot be retrieved.
158pub(crate) fn current_os_id() -> u64 {
159    imp::current_os_id().unwrap_or_else(|| current_id().as_u64().get())
160}
161
162/// Gets a reference to the handle of the thread that invokes it, if the handle
163/// has been initialized.
164pub(super) fn try_with_current<F, R>(f: F) -> R
165where
166    F: FnOnce(Option<&Thread>) -> R,
167{
168    let current = CURRENT.get();
169    if current > DESTROYED {
170        // SAFETY: `Arc` does not contain interior mutability, so it does not
171        // matter that the address of the handle might be different depending
172        // on where this is called.
173        unsafe {
174            let current = ManuallyDrop::new(Thread::from_raw(current));
175            f(Some(&current))
176        }
177    } else {
178        f(None)
179    }
180}
181
182/// Gets a handle to the thread that invokes it. If the handle stored in thread-
183/// local storage was already destroyed, this creates a new unnamed temporary
184/// handle to allow thread parking in nearly all situations.
185pub(crate) fn current_or_unnamed() -> Thread {
186    let current = CURRENT.get();
187    if current > DESTROYED {
188        unsafe {
189            let current = ManuallyDrop::new(Thread::from_raw(current));
190            (*current).clone()
191        }
192    } else if current == DESTROYED {
193        Thread::new(id::get_or_init(), None)
194    } else {
195        init_current(current)
196    }
197}
198
199/// Gets a handle to the thread that invokes it.
200///
201/// # Examples
202///
203/// Getting a handle to the current thread with `thread::current()`:
204///
205/// ```
206/// use std::thread;
207///
208/// let handler = thread::Builder::new()
209///     .name("named thread".into())
210///     .spawn(|| {
211///         let handle = thread::current();
212///         assert_eq!(handle.name(), Some("named thread"));
213///     })
214///     .unwrap();
215///
216/// handler.join().unwrap();
217/// ```
218#[must_use]
219#[stable(feature = "rust1", since = "1.0.0")]
220pub fn current() -> Thread {
221    let current = CURRENT.get();
222    if current > DESTROYED {
223        unsafe {
224            let current = ManuallyDrop::new(Thread::from_raw(current));
225            (*current).clone()
226        }
227    } else {
228        init_current(current)
229    }
230}
231
232#[cold]
233fn init_current(current: *mut ()) -> Thread {
234    if current == NONE {
235        CURRENT.set(BUSY);
236        // If the thread ID was initialized already, use it.
237        let id = id::get_or_init();
238        let thread = Thread::new(id, None);
239
240        // Make sure that `crate::rt::thread_cleanup` will be run, which will
241        // call `drop_current`.
242        crate::sys::thread_local::guard::enable();
243        CURRENT.set(thread.clone().into_raw().cast_mut());
244        thread
245    } else if current == BUSY {
246        // BUSY exists solely for this check, but as it is in the slow path, the
247        // extra TLS write above shouldn't matter. The alternative is nearly always
248        // a stack overflow.
249
250        // If you came across this message, contact the author of your allocator.
251        // If you are said author: A surprising amount of functions inside the
252        // standard library (e.g. `Mutex`, `thread_local!`, `File` when using long
253        // paths, even `panic!` when using unwinding), need memory allocation, so
254        // you'll get circular dependencies all over the place when using them.
255        // I (joboet) highly recommend using only APIs from core in your allocator
256        // and implementing your own system abstractions. Still, if you feel that
257        // a particular API should be entirely allocation-free, feel free to open
258        // an issue on the Rust repository, we'll see what we can do.
259        rtabort!(
260            "\n\
261            Attempted to access thread-local data while allocating said data.\n\
262            Do not access functions that allocate in the global allocator!\n\
263            This is a bug in the global allocator.\n\
264            "
265        )
266    } else {
267        debug_assert_eq!(current, DESTROYED);
268        panic!(
269            "use of std::thread::current() is not possible after the thread's \
270            local data has been destroyed"
271        )
272    }
273}
274
275/// This should be run in [`crate::rt::thread_cleanup`] to reset the thread
276/// handle.
277pub(crate) fn drop_current() {
278    let current = CURRENT.get();
279    if current > DESTROYED {
280        unsafe {
281            CURRENT.set(DESTROYED);
282            drop(Thread::from_raw(current));
283        }
284    }
285}
std/thread/current.rs

std/thread/
current.rs
