Add support for TLS templates

Author: phil-opp

src/binary/load_kernel.rs

@@ -1,4 +1,7 @@
-use crate::binary::{level_4_entries::UsedLevel4Entries, PAGE_SIZE};
+use crate::{
+    binary::{level_4_entries::UsedLevel4Entries, PAGE_SIZE},
+    boot_info::TlsTemplate,
+};
 use x86_64::{
     align_up,
     structures::paging::{
@@ -54,12 +57,19 @@ where
         Ok(loader)
     }
 
-    fn load_segments(&mut self) -> Result<(), &'static str> {
+    fn load_segments(&mut self) -> Result<Option<TlsTemplate>, &'static str> {
+        let mut tls_template = None;
         for program_header in self.elf_file.program_iter() {
             program::sanity_check(program_header, &self.elf_file)?;
             match program_header.get_type()? {
                 Type::Load => self.inner.handle_load_segment(program_header)?,
-                Type::Tls => self.inner.handle_tls_segment(program_header)?,
+                Type::Tls => {
+                    if tls_template.is_none() {
+                        tls_template = Some(self.inner.handle_tls_segment(program_header)?);
+                    } else {
+                        return Err("multiple TLS segments not supported");
+                    }
+                }
                 Type::Null
                 | Type::Dynamic
                 | Type::Interp
@@ -71,7 +81,7 @@ where
                 | Type::ProcessorSpecific(_) => {}
             }
         }
-        Ok(())
+        Ok(tls_template)
     }
 
     fn entry_point(&self) -> VirtAddr {
@@ -250,19 +260,23 @@ where
         Ok(())
     }
 
-    fn handle_tls_segment(&mut self, segment: ProgramHeader) -> Result<(), &'static str> {
-        todo!()
+    fn handle_tls_segment(&mut self, segment: ProgramHeader) -> Result<TlsTemplate, &'static str> {
+        Ok(TlsTemplate {
+            start_addr: segment.virtual_addr(),
+            mem_size: segment.mem_size(),
+            file_size: segment.file_size(),
+        })
     }
 }
 
 pub fn load_kernel(
     bytes: &[u8],
     page_table: &mut impl MapperAllSizes,
     frame_allocator: &mut impl FrameAllocator<Size4KiB>,
-) -> Result<(VirtAddr, UsedLevel4Entries), &'static str> {
+) -> Result<(VirtAddr, Option<TlsTemplate>, UsedLevel4Entries), &'static str> {
     let mut loader = Loader::new(bytes, page_table, frame_allocator)?;
-    loader.load_segments()?;
+    let tls_template = loader.load_segments()?;
     let used_entries = loader.used_level_4_entries();
 
-    Ok((loader.entry_point(), used_entries))
+    Ok((loader.entry_point(), tls_template, used_entries))
 }

src/binary/mod.rs

@@ -1,5 +1,5 @@
 use crate::binary::legacy_memory_region::{LegacyFrameAllocator, LegacyMemoryRegion};
-use crate::boot_info::{BootInfo, FrameBuffer, FrameBufferInfo};
+use crate::boot_info::{BootInfo, FrameBuffer, FrameBufferInfo, TlsTemplate};
 use crate::memory_map::MemoryRegion;
 use core::{
     mem::{self, MaybeUninit},
@@ -100,7 +100,7 @@ where
     // Make the kernel respect the write-protection bits even when in ring 0 by default
     enable_write_protect_bit();
 
-    let (entry_point, mut used_entries) =
+    let (entry_point, tls_template, mut used_entries) =
         load_kernel::load_kernel(kernel_bytes, kernel_page_table, frame_allocator)
             .expect("no entry point");
     log::info!("Entry point at: {:#x}", entry_point.as_u64());
@@ -197,6 +197,7 @@ where
         used_entries,
         physical_memory_offset,
         recursive_index,
+        tls_template,
     }
 }
 
@@ -207,6 +208,7 @@ pub struct Mappings {
     pub framebuffer: Option<VirtAddr>,
     pub physical_memory_offset: Option<VirtAddr>,
     pub recursive_index: Option<PageTableIndex>,
+    pub tls_template: Option<TlsTemplate>,
 }
 
 /// Allocates and initializes the boot info struct and the memory map
@@ -284,6 +286,7 @@ where
         physical_memory_offset: mappings.physical_memory_offset.map(VirtAddr::as_u64),
         recursive_index: mappings.recursive_index.map(Into::into),
         rsdp_addr: system_info.rsdp_addr.map(|addr| addr.as_u64()),
+        tls_template: mappings.tls_template,
         _non_exhaustive: (),
     });
 

src/boot_info.rs

@@ -8,6 +8,7 @@ pub struct BootInfo {
     pub physical_memory_offset: Option<u64>,
     pub recursive_index: Option<u16>,
     pub rsdp_addr: Option<u64>,
+    pub tls_template: Option<TlsTemplate>,
     pub(crate) _non_exhaustive: (),
 }
 
@@ -50,6 +51,27 @@ pub enum PixelFormat {
     U8,
 }
 
+/// Information about the thread local storage (TLS) template.
+///
+/// This template can be used to set up thread local storage for threads. For
+/// each thread, a new memory ___location of size `mem_size` must be initialized.
+/// Then the first `file_size` bytes of this template needs to be copied to the
+/// ___location. The additional `mem_size - file_size` bytes must be initialized with
+/// zero.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct TlsTemplate {
+    /// The virtual start address of the thread local storage template.
+    pub start_addr: u64,
+    /// The number of data bytes in the template.
+    ///
+    /// Corresponds to the length of the `.tdata` section.
+    pub file_size: u64,
+    /// The total number of bytes that the TLS segment should have in memory.
+    ///
+    /// Corresponds to the combined length of the `.tdata` and `.tbss` sections.
+    pub mem_size: u64,
+}
+
 /// Check that the _pointer_ is FFI-safe.
 ///
 /// Note that the `BootInfo` struct is not FFI-safe, so it needs to be compiled by the same Rust