fix: rework TLS, fix alignments

mkroening · mkroening · commit 6efb49e3eb14 · 2025-10-16T12:22:58.000+02:00
diff --git a/src/arch/aarch64/kernel/scheduler.rs b/src/arch/aarch64/kernel/scheduler.rs
@@ -1,12 +1,6 @@
 //! Architecture dependent interface to initialize a task
 
-#[cfg(not(feature = "common-os"))]
-use alloc::alloc::{Layout, alloc_zeroed};
-#[cfg(not(feature = "common-os"))]
-use alloc::boxed::Box;
 use core::arch::naked_asm;
-#[cfg(not(feature = "common-os"))]
-use core::slice;
 use core::sync::atomic::Ordering;
 use core::{mem, ptr};
 
@@ -17,8 +11,6 @@ use memory_addresses::arch::aarch64::{PhysAddr, VirtAddr};
 use crate::arch::aarch64::kernel::CURRENT_STACK_ADDRESS;
 use crate::arch::aarch64::kernel::core_local::core_scheduler;
 use crate::arch::aarch64::mm::paging::{BasePageSize, PageSize, PageTableEntryFlags};
-#[cfg(not(feature = "common-os"))]
-use crate::env;
 use crate::mm::physicalmem::PHYSICAL_FREE_LIST;
 use crate::mm::virtualmem::KERNEL_FREE_LIST;
 #[cfg(target_os = "none")]
@@ -266,77 +258,6 @@ impl Drop for TaskStacks {
  * of the TLS implementations.
  */
 
-#[cfg(not(feature = "common-os"))]
-#[derive(Copy, Clone)]
-#[repr(C)]
-struct DtvPointer {
-	val: *const (),
-	to_free: *const (),
-}
-
-#[cfg(not(feature = "common-os"))]
-#[repr(C)]
-union Dtv {
-	counter: usize,
-	pointer: DtvPointer,
-}
-
-#[cfg(not(feature = "common-os"))]
-#[repr(C)]
-pub struct TaskTLS {
-	dtv: Box<[Dtv; 2]>,
-	_private: usize,
-	block: [u8],
-}
-
-#[cfg(not(feature = "common-os"))]
-impl TaskTLS {
-	fn from_environment() -> Option<Box<Self>> {
-		let tls_info = env::boot_info().load_info.tls_info?;
-		assert_ne!(tls_info.memsz, 0);
-
-		// Get TLS initialization image
-		let tls_init_image = {
-			let tls_init_data = ptr::with_exposed_provenance(tls_info.start.try_into().unwrap());
-			let tls_init_len = tls_info.filesz.try_into().unwrap();
-
-			// SAFETY: We will have to trust the environment here.
-			unsafe { slice::from_raw_parts(tls_init_data, tls_init_len) }
-		};
-
-		let off = core::cmp::max(16, usize::try_from(tls_info.align).unwrap()) - 16;
-		let block_len = usize::try_from(tls_info.memsz).unwrap() + off;
-		let len = mem::size_of::<Box<[Dtv; 2]>>() + mem::size_of::<usize>() + block_len;
-
-		let layout = Layout::from_size_align(len, 16).unwrap();
-		let mut this = unsafe {
-			let data = alloc_zeroed(layout);
-			let raw = ptr::slice_from_raw_parts_mut(data, block_len) as *mut TaskTLS;
-
-			let addr = (*raw).block.as_ptr().add(off).cast::<()>();
-			(&raw mut (*raw).dtv).write(Box::new([
-				Dtv { counter: 1 },
-				Dtv {
-					pointer: DtvPointer {
-						val: addr,
-						to_free: ptr::null(),
-					},
-				},
-			]));
-
-			Box::from_raw(raw)
-		};
-
-		this.block[off..off + tls_init_image.len()].copy_from_slice(tls_init_image);
-
-		Some(this)
-	}
-
-	fn thread_ptr(&self) -> *const Box<[Dtv; 2]> {
-		&raw const self.dtv
-	}
-}
-
 #[cfg(not(target_os = "none"))]
 extern "C" fn task_start(_f: extern "C" fn(usize), _arg: usize, _user_stack: u64) -> ! {
 	unimplemented!()
@@ -373,7 +294,9 @@ impl TaskFrame for Task {
 		// Check if TLS is allocated already and if the task uses thread-local storage.
 		#[cfg(not(feature = "common-os"))]
 		if self.tls.is_none() {
-			self.tls = TaskTLS::from_environment();
+			use crate::scheduler::task::tls::Tls;
+
+			self.tls = Tls::from_env();
 		}
 
 		unsafe {
diff --git a/src/arch/riscv64/kernel/scheduler.rs b/src/arch/riscv64/kernel/scheduler.rs
@@ -1,9 +1,3 @@
-#[cfg(not(feature = "common-os"))]
-use alloc::alloc::{Layout, alloc, dealloc};
-#[cfg(not(feature = "common-os"))]
-use alloc::boxed::Box;
-#[cfg(not(feature = "common-os"))]
-use core::convert::TryInto;
 use core::{mem, ptr};
 
 use align_address::Align;
@@ -13,8 +7,6 @@ use memory_addresses::{PhysAddr, VirtAddr};
 use crate::arch::riscv64::kernel::core_local::core_scheduler;
 use crate::arch::riscv64::kernel::processor::set_oneshot_timer;
 use crate::arch::riscv64::mm::paging::{BasePageSize, PageSize, PageTableEntryFlags};
-#[cfg(not(feature = "common-os"))]
-use crate::env;
 use crate::mm::physicalmem::PHYSICAL_FREE_LIST;
 use crate::mm::virtualmem::KERNEL_FREE_LIST;
 use crate::scheduler::task::{Task, TaskFrame};
@@ -277,84 +269,6 @@ impl Drop for TaskStacks {
 	}
 }
 
-#[cfg(not(feature = "common-os"))]
-pub struct TaskTLS {
-	address: VirtAddr,
-	tp: VirtAddr,
-	layout: Layout,
-}
-
-#[cfg(not(feature = "common-os"))]
-impl TaskTLS {
-	pub fn from_environment() -> Option<Box<Self>> {
-		let tls_info = env::boot_info().load_info.tls_info?;
-		assert_ne!(tls_info.memsz, 0);
-
-		let tls_size = tls_info.memsz as usize;
-		// determine the size of tdata (tls without tbss)
-		let tdata_size = tls_info.filesz as usize;
-		let tls_start = VirtAddr::new(tls_info.start);
-		// Yes, it does, so we have to allocate TLS memory.
-		// Allocate enough space for the given size and one more variable of type usize, which holds the tls_pointer.
-		let tls_allocation_size = tls_size.align_up(32usize); // + mem::size_of::<usize>();
-		// We allocate in 128 byte granularity (= cache line size) to avoid false sharing
-		let memory_size = tls_allocation_size.align_up(128usize);
-		let layout =
-			Layout::from_size_align(memory_size, 128).expect("TLS has an invalid size / alignment");
-		let ptr = VirtAddr::new(unsafe { alloc(layout) as u64 });
-
-		// The tls_pointer is the address to the end of the TLS area requested by the task.
-		let tls_pointer = ptr; // + tls_size.align_up(32);
-
-		unsafe {
-			// Copy over TLS variables with their initial values.
-			ptr::copy_nonoverlapping(tls_start.as_ptr::<u8>(), ptr.as_mut_ptr::<u8>(), tdata_size);
-
-			ptr::write_bytes(
-				ptr.as_mut_ptr::<u8>()
-					.offset(tdata_size.try_into().unwrap()),
-				0,
-				tls_size.align_up(32usize) - tdata_size,
-			);
-
-			// The x86-64 TLS specification also requires that the tls_pointer can be accessed at fs:0.
-			// This allows TLS variable values to be accessed by "mov rax, fs:0" and a later "lea rdx, [rax+VARIABLE_OFFSET]".
-			// See "ELF Handling For Thread-Local Storage", version 0.20 by Ulrich Drepper, page 12 for details.
-			//
-			// fs:0 is where tls_pointer points to and we have reserved space for a usize value above.
-			//*(tls_pointer.as_mut_ptr::<u64>()) = tls_pointer.as_u64();
-		}
-
-		debug!(
-			"Set up TLS at {tls_pointer:#x}, tdata_size {tdata_size:#x}, tls_size {tls_size:#x}"
-		);
-
-		Some(Box::new(Self {
-			address: ptr,
-			tp: tls_pointer,
-			layout,
-		}))
-	}
-
-	pub fn tp(&self) -> VirtAddr {
-		self.tp
-	}
-}
-
-#[cfg(not(feature = "common-os"))]
-impl Drop for TaskTLS {
-	fn drop(&mut self) {
-		debug!(
-			"Deallocate TLS at 0x{:x} (layout {:?})",
-			self.address, self.layout,
-		);
-
-		unsafe {
-			dealloc(self.address.as_mut_ptr::<u8>(), self.layout);
-		}
-	}
-}
-
 #[unsafe(no_mangle)]
 extern "C" fn task_entry(func: extern "C" fn(usize), arg: usize) {
 	use crate::scheduler::PerCoreSchedulerExt;
@@ -401,7 +315,9 @@ impl TaskFrame for Task {
 		// check is TLS is already allocated
 		#[cfg(not(feature = "common-os"))]
 		if self.tls.is_none() {
-			self.tls = TaskTLS::from_environment();
+			use crate::scheduler::task::tls::Tls;
+
+			self.tls = Tls::from_env();
 		}
 
 		unsafe {
@@ -416,7 +332,7 @@ impl TaskFrame for Task {
 			let state = stack.as_mut_ptr::<State>();
 			#[cfg(not(feature = "common-os"))]
 			if let Some(tls) = &self.tls {
-				(*state).tp = tls.tp().as_usize();
+				(*state).tp = tls.thread_ptr() as usize;
 			}
 			(*state).ra = task_start as usize;
 			(*state).a0 = func as usize;
diff --git a/src/arch/x86_64/kernel/scheduler.rs b/src/arch/x86_64/kernel/scheduler.rs
@@ -1,12 +1,6 @@
 //! Architecture dependent interface to initialize a task
 
-#[cfg(not(feature = "common-os"))]
-use alloc::boxed::Box;
 use core::arch::naked_asm;
-#[cfg(not(feature = "common-os"))]
-use core::mem::MaybeUninit;
-#[cfg(not(feature = "common-os"))]
-use core::slice;
 use core::{mem, ptr};
 
 use align_address::Align;
@@ -259,71 +253,6 @@ impl Drop for TaskStacks {
 	}
 }
 
-#[cfg(not(feature = "common-os"))]
-pub struct TaskTLS {
-	_block: Box<[MaybeUninit<u8>]>,
-	thread_ptr: *mut (),
-}
-
-#[cfg(not(feature = "common-os"))]
-impl TaskTLS {
-	// For details on thread-local storage data structures see
-	//
-	// “ELF Handling For Thread-Local Storage” Section 3.4.6: x86-64 Specific Definitions for Run-Time Handling of TLS
-	// https://akkadia.org/drepper/tls.pdf
-	fn from_environment() -> Option<Box<Self>> {
-		let tls_info = env::boot_info().load_info.tls_info?;
-		assert_ne!(tls_info.memsz, 0);
-
-		// Get TLS initialization image
-		let tls_init_image = {
-			let tls_init_data = ptr::with_exposed_provenance(tls_info.start.try_into().unwrap());
-			let tls_init_len = tls_info.filesz.try_into().unwrap();
-
-			// SAFETY: We will have to trust the environment here.
-			unsafe { slice::from_raw_parts(tls_init_data, tls_init_len) }
-		};
-
-		// As described in “ELF Handling For Thread-Local Storage”
-		let tls_offset = usize::try_from(tls_info.memsz)
-			.unwrap()
-			.align_up(usize::try_from(tls_info.align).unwrap());
-
-		// Allocate TLS block
-		let mut block = {
-			// To access TLS blocks on x86-64, TLS offsets are *subtracted* from the thread register value.
-			// So the thread pointer needs to be `block_ptr + tls_offset`.
-			// GNU style TLS requires `fs:0` to represent the same address as the thread pointer.
-			// Since the thread pointer points to the end of the TLS blocks, we need to store it there.
-			let tcb_size = mem::size_of::<*mut ()>();
-
-			vec![MaybeUninit::<u8>::uninit(); tls_offset + tcb_size].into_boxed_slice()
-		};
-
-		// Initialize beginning of the TLS block with TLS initialization image
-		block[..tls_init_image.len()].copy_from_slice(tls_init_image);
-
-		// Fill the rest of the block with zeros
-		block[tls_init_image.len()..tls_offset].fill(MaybeUninit::new(0));
-
-		// thread_ptr = block_ptr + tls_offset
-		let thread_ptr = block[tls_offset..].as_mut_ptr().cast::<()>();
-		unsafe {
-			thread_ptr.cast::<*mut ()>().write_unaligned(thread_ptr);
-		}
-
-		let this = Self {
-			_block: block,
-			thread_ptr,
-		};
-		Some(Box::new(this))
-	}
-
-	fn thread_ptr(&self) -> *mut () {
-		self.thread_ptr
-	}
-}
-
 #[cfg(not(target_os = "none"))]
 extern "C" fn task_start(_f: extern "C" fn(usize), _arg: usize, _user_stack: u64) -> ! {
 	unimplemented!()
@@ -358,7 +287,9 @@ impl TaskFrame for Task {
 		// Check if TLS is allocated already and if the task uses thread-local storage.
 		#[cfg(not(feature = "common-os"))]
 		if self.tls.is_none() {
-			self.tls = TaskTLS::from_environment();
+			use crate::scheduler::task::tls::Tls;
+
+			self.tls = Tls::from_env();
 		}
 
 		unsafe {
diff --git a/src/scheduler/task/mod.rs b/src/scheduler/task/mod.rs
@@ -1,7 +1,8 @@
 #![allow(clippy::type_complexity)]
 
 #[cfg(not(feature = "common-os"))]
-use alloc::boxed::Box;
+pub(crate) mod tls;
+
 use alloc::collections::{LinkedList, VecDeque};
 use alloc::rc::Rc;
 use alloc::sync::Arc;
@@ -15,10 +16,10 @@ use hashbrown::HashMap;
 use hermit_sync::{OnceCell, RwSpinLock};
 use memory_addresses::VirtAddr;
 
+#[cfg(not(feature = "common-os"))]
+use self::tls::Tls;
 use crate::arch::core_local::*;
 use crate::arch::scheduler::TaskStacks;
-#[cfg(not(feature = "common-os"))]
-use crate::arch::scheduler::TaskTLS;
 use crate::errno::Errno;
 use crate::executor::poll_on;
 use crate::fd::stdio::*;
@@ -397,7 +398,7 @@ pub(crate) struct Task {
 	>,
 	/// Task Thread-Local-Storage (TLS)
 	#[cfg(not(feature = "common-os"))]
-	pub tls: Option<Box<TaskTLS>>,
+	pub tls: Option<Tls>,
 	// Physical address of the 1st level page table
 	#[cfg(all(target_arch = "x86_64", feature = "common-os"))]
 	pub root_page_table: usize,
diff --git a/src/scheduler/task/tls.rs b/src/scheduler/task/tls.rs
