1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
|
use crate::cell::{Cell, UnsafeCell};
use crate::ptr::{self, drop_in_place};
use crate::sys::thread_local::{abort_on_dtor_unwind, destructors};
#[derive(Clone, Copy)]
enum State {
Initial,
Alive,
Destroyed,
}
#[allow(missing_debug_implementations)]
pub struct Storage<T> {
state: Cell<State>,
val: UnsafeCell<T>,
}
impl<T> Storage<T> {
pub const fn new(val: T) -> Storage<T> {
Storage { state: Cell::new(State::Initial), val: UnsafeCell::new(val) }
}
/// Gets a pointer to the TLS value. If the TLS variable has been destroyed,
/// a null pointer is returned.
///
/// The resulting pointer may not be used after thread destruction has
/// occurred.
///
/// # Safety
/// The `self` reference must remain valid until the TLS destructor is run.
#[inline]
pub unsafe fn get(&self) -> *const T {
match self.state.get() {
State::Alive => self.val.get(),
State::Destroyed => ptr::null(),
State::Initial => unsafe { self.initialize() },
}
}
#[cold]
unsafe fn initialize(&self) -> *const T {
// Register the destructor
// SAFETY:
// The caller guarantees that `self` will be valid until thread destruction.
unsafe {
destructors::register(ptr::from_ref(self).cast_mut().cast(), destroy::<T>);
}
self.state.set(State::Alive);
self.val.get()
}
}
/// Transition an `Alive` TLS variable into the `Destroyed` state, dropping its
/// value.
///
/// # Safety
/// * Must only be called at thread destruction.
/// * `ptr` must point to an instance of `Storage` with `Alive` state and be
/// valid for accessing that instance.
unsafe extern "C" fn destroy<T>(ptr: *mut u8) {
// Print a nice abort message if a panic occurs.
abort_on_dtor_unwind(|| {
let storage = unsafe { &*(ptr as *const Storage<T>) };
// Update the state before running the destructor as it may attempt to
// access the variable.
storage.state.set(State::Destroyed);
unsafe {
drop_in_place(storage.val.get());
}
})
}
|
