sel4_initialize_tls/
lib.rs

Help
1//
2// Copyright 2023, Colias Group, LLC
3//
4// SPDX-License-Identifier: BSD-2-Clause
5//
6
7// NOTE
8//
9// - aarch64 and arm use variant 1 defined in [1][2].
10// - x86_64 uses variant 2 defined in [1][2].
11// - riscv uses variant 1 with a twist: the thread pointer points to the first address _past_ the
12//   TCB [3].
13//
14// [1] https://akkadia.org/drepper/tls.pdf
15// [2] https://fuchsia.dev/fuchsia-src/development/kernel/threads/tls#implementation
16// [3] https://github.com/riscv-non-isa/riscv-elf-psabi-doc/blob/master/riscv-elf.adoc#thread-local-storage
17
18#![no_std]
19
20use core::alloc::Layout;
21use core::mem;
22use core::ptr;
23use core::slice;
24
25#[cfg(feature = "alloc")]
26extern crate alloc;
27
28#[cfg(not(any(
29    target_arch = "aarch64",
30    target_arch = "arm",
31    target_arch = "riscv32",
32    target_arch = "riscv64",
33    target_arch = "x86_64",
34)))]
35compile_error!("unsupported architecture");
36
37mod set_thread_pointer;
38
39pub use set_thread_pointer::{SetThreadPointerFn, DEFAULT_SET_THREAD_POINTER_FN};
40
41mod static_allocation;
42pub use static_allocation::*;
43
44#[cfg(feature = "on-stack")]
45mod on_stack;
46
47#[cfg(feature = "on-heap")]
48mod on_heap;
49
50#[cfg(feature = "on-heap")]
51pub use on_heap::*;
52
53#[derive(Debug, Copy, Clone, PartialEq, Eq)]
54pub struct UncheckedTlsImage {
55    pub vaddr: usize,
56    pub filesz: usize,
57    pub memsz: usize,
58    pub align: usize,
59}
60
61impl UncheckedTlsImage {
62    pub fn check(&self) -> Result<TlsImage, InvalidTlsImageError> {
63        if self.memsz >= self.filesz && self.align.is_power_of_two() && self.align > 0 {
64            Ok(TlsImage { checked: *self })
65        } else {
66            Err(InvalidTlsImageError::new())
67        }
68    }
69}
70
71#[derive(Debug, Copy, Clone, PartialEq, Eq)]
72pub struct InvalidTlsImageError(());
73
74impl InvalidTlsImageError {
75    fn new() -> Self {
76        Self(())
77    }
78}
79
80#[repr(C)]
81#[derive(Debug, Copy, Clone, PartialEq, Eq)]
82pub struct TlsImage {
83    checked: UncheckedTlsImage,
84}
85
86impl TlsImage {
87    pub fn reservation_layout(&self) -> TlsReservationLayout {
88        TlsReservationLayout::from_segment_layout(self.segment_layout())
89    }
90
91    fn segment_layout(&self) -> Layout {
92        Layout::from_size_align(self.checked.memsz, self.checked.align).unwrap()
93    }
94
95    fn image_data(&self) -> *const [u8] {
96        ptr::slice_from_raw_parts(self.checked.vaddr as *mut u8, self.checked.filesz)
97    }
98
99    #[allow(clippy::missing_safety_doc)]
100    pub unsafe fn initialize_reservation(&self, reservation_start: *mut u8) -> usize {
101        let reservation_layout = self.reservation_layout();
102        let reservation =
103            slice::from_raw_parts_mut(reservation_start, reservation_layout.footprint().size());
104        let (tdata, tbss) = reservation[reservation_layout.segment_offset()..]
105            [..self.checked.memsz]
106            .split_at_mut(self.checked.filesz);
107        tdata.copy_from_slice(self.image_data().as_ref().unwrap());
108        tbss.fill(0);
109        let thread_pointer = (reservation_start as usize)
110            .checked_add(reservation_layout.thread_pointer_offset())
111            .unwrap(); // TODO return error
112        if cfg!(target_arch = "x86_64") {
113            let thread_pointer_slice = &mut reservation
114                [reservation_layout.thread_pointer_offset()..][..mem::size_of::<usize>()];
115            thread_pointer_slice.copy_from_slice(&thread_pointer.to_ne_bytes());
116        }
117        thread_pointer
118    }
119
120    #[allow(clippy::missing_safety_doc)]
121    pub unsafe fn initialize_exact_reservation_region(
122        &self,
123        exact_reservation: &Region,
124    ) -> Result<usize, RegionLayoutError> {
125        if exact_reservation.fits_exactly(self.reservation_layout().footprint()) {
126            Ok(self.initialize_reservation(exact_reservation.start()))
127        } else {
128            Err(RegionLayoutError::new())
129        }
130    }
131
132    #[allow(clippy::missing_safety_doc)]
133    pub unsafe fn initialize_inexact_reservation_region(
134        &self,
135        inexact_reservation: &Region,
136    ) -> Result<usize, RegionLayoutError> {
137        if let Ok(TrimmedRegion { trimmed, .. }) =
138            inexact_reservation.trim(self.reservation_layout().footprint())
139        {
140            Ok(self.initialize_exact_reservation_region(&trimmed).unwrap())
141        } else {
142            Err(RegionLayoutError::new())
143        }
144    }
145}
146
147#[derive(Debug, Copy, Clone, PartialEq, Eq)]
148pub struct RegionLayoutError(());
149
150impl RegionLayoutError {
151    fn new() -> Self {
152        Self(())
153    }
154}
155
156#[derive(Debug, Copy, Clone, PartialEq, Eq)]
157pub struct TlsReservationLayout {
158    footprint: Layout,
159    segment_offset: usize,
160    thread_pointer_offset: usize,
161}
162
163impl TlsReservationLayout {
164    fn from_segment_layout(segment_layout: Layout) -> Self {
165        if cfg!(any(target_arch = "arm", target_arch = "aarch64")) {
166            let tcb_size = 2 * mem::size_of::<usize>();
167            let tcb_layout = Layout::from_size_align(tcb_size, tcb_size).unwrap();
168            let (footprint, segment_offset) = tcb_layout.extend(segment_layout).unwrap();
169            Self {
170                footprint,
171                segment_offset,
172                thread_pointer_offset: 0,
173            }
174        } else if cfg!(any(target_arch = "riscv32", target_arch = "riscv64")) {
175            Self {
176                footprint: segment_layout,
177                segment_offset: 0,
178                thread_pointer_offset: 0,
179            }
180        } else if cfg!(target_arch = "x86_64") {
181            let tcb_layout =
182                Layout::from_size_align(2 * mem::size_of::<usize>(), mem::size_of::<usize>())
183                    .unwrap(); // could probably get away with just 1x word size for size (keeping 2x word size alignment)
184            let (footprint, thread_pointer_offset) = segment_layout.extend(tcb_layout).unwrap();
185            Self {
186                footprint,
187                segment_offset: 0,
188                thread_pointer_offset,
189            }
190        } else {
191            unreachable!();
192        }
193    }
194
195    pub fn footprint(&self) -> Layout {
196        self.footprint
197    }
198
199    pub fn segment_offset(&self) -> usize {
200        self.segment_offset
201    }
202
203    pub fn thread_pointer_offset(&self) -> usize {
204        self.thread_pointer_offset
205    }
206}
207
208#[derive(Debug, Copy, Clone, PartialEq, Eq)]
209pub struct Region {
210    start: *mut u8,
211    size: usize,
212}
213
214impl Region {
215    pub const fn new(start: *mut u8, size: usize) -> Self {
216        Self { start, size }
217    }
218
219    pub const fn start(&self) -> *mut u8 {
220        self.start
221    }
222
223    pub const fn size(&self) -> usize {
224        self.size
225    }
226
227    fn fits_exactly(&self, layout: Layout) -> bool {
228        self.size() == layout.size() && self.start().align_offset(layout.align()) == 0
229    }
230
231    fn trim(&self, layout: Layout) -> Result<TrimmedRegion, TrimRegionError> {
232        let start_addr = self.start() as usize;
233        let trimmed_start_addr = start_addr
234            .checked_next_multiple_of(layout.align())
235            .ok_or(TrimRegionError::new())?;
236        let remainder_start_addr = trimmed_start_addr
237            .checked_add(layout.size())
238            .ok_or(TrimRegionError::new())?;
239        let remainder_end_addr = start_addr
240            .checked_add(self.size())
241            .ok_or(TrimRegionError::new())?;
242        if remainder_start_addr > remainder_end_addr {
243            return Err(TrimRegionError::new());
244        }
245        Ok(TrimmedRegion {
246            padding: Region::new(start_addr as *mut u8, trimmed_start_addr - start_addr),
247            trimmed: Region::new(
248                trimmed_start_addr as *mut u8,
249                remainder_start_addr - trimmed_start_addr,
250            ),
251            remainder: Region::new(
252                remainder_start_addr as *mut u8,
253                remainder_end_addr - remainder_start_addr,
254            ),
255        })
256    }
257}
258
259struct TrimmedRegion {
260    #[allow(dead_code)]
261    padding: Region,
262    trimmed: Region,
263    #[allow(dead_code)]
264    remainder: Region,
265}
266
267#[derive(Debug, Copy, Clone, PartialEq, Eq)]
268struct TrimRegionError(());
269
270impl TrimRegionError {
271    fn new() -> Self {
272        Self(())
273    }
274}
sel4_initialize_tls/lib.rs

sel4_initialize_tls/
lib.rs
