Update

Author: nuta

kernel/src/loader.rs

@@ -1,7 +1,14 @@
+use core::mem::size_of;
 use core::slice;
 
+use ftl_elf::DT_NULL;
+use ftl_elf::DT_RELA;
+use ftl_elf::DT_RELASZ;
+use ftl_elf::Dyn;
 use ftl_elf::Elf;
 use ftl_elf::PhdrType;
+use ftl_elf::R_X86_64_RELATIVE;
+use ftl_elf::Rela;
 use ftl_server::start::StartInfo;
 use ftl_utils::alignment::align_up;
 
@@ -22,8 +29,7 @@ fn load_elf(elf_file: &[u8]) {
     let elf = match Elf::parse(elf_file, ftl_elf::ET_DYN) {
         Ok(elf) => elf,
         Err(e) => {
-            error!("failed to parse ELF file: {:?}", e);
-            return;
+            panic!("failed to parse ELF file: {:?}", e);
         }
     };
 
@@ -39,8 +45,7 @@ fn load_elf(elf_file: &[u8]) {
     let image_paddr = match PAGE_ALLOCATOR.alloc(image_size, PageType::Zeroed) {
         Some(paddr) => paddr,
         None => {
-            error!("out of memory: {} bytes", image_size);
-            return;
+            panic!("out of memory: {} bytes", image_size);
         }
     };
 
@@ -66,7 +71,66 @@ fn load_elf(elf_file: &[u8]) {
         let zeroed_len = phdr.p_memsz as usize - copy_len;
         if zeroed_len > 0 {
             let zeroed_range = (zeroed_off)..(zeroed_off + zeroed_len);
-            dst[zeroed_range].fill(0);
+            image[zeroed_range].fill(0);
+        }
+    }
+
+    // Find the relocation table.
+    let mut rela_addr = 0;
+    let mut rela_size = 0;
+    for phdr in elf.phdrs {
+        if phdr.p_type != PhdrType::Dynamic as u32 {
+            continue;
+        }
+
+        if phdr.p_memsz as usize % size_of::<Dyn>() != 0 {
+            panic!("invalid dynamic segment size");
+        }
+
+        let dynamic = unsafe {
+            slice::from_raw_parts(
+                image.as_ptr().add(phdr.p_vaddr as usize) as *const Dyn,
+                phdr.p_memsz as usize / size_of::<Dyn>(),
+            )
+        };
+
+        for entry in dynamic {
+            match entry.d_tag {
+                DT_NULL => break,
+                DT_RELA => rela_addr = entry.d_val as usize,
+                DT_RELASZ => rela_size = entry.d_val as usize,
+                _ => {}
+            }
+        }
+    }
+
+    // Apply relocations.
+    if rela_addr != 0 && rela_size > 0 {
+        if rela_size % size_of::<Rela>() != 0 {
+            panic!("invalid relocation table size: {} bytes", rela_size);
+        }
+
+        let relocations = unsafe {
+            slice::from_raw_parts(
+                image.as_ptr().add(rela_addr) as *const Rela,
+                rela_size / size_of::<Rela>(),
+            )
+        };
+
+        for rela in relocations {
+            let target_off = rela.r_offset as usize;
+            if rela.r_sym() != 0 || rela.r_type() != R_X86_64_RELATIVE {
+                panic!("unexpected relocation type: {}", rela.r_type());
+            }
+
+            let target_end = match target_off.checked_add(size_of::<u64>()) {
+                Some(end) if end <= image.len() => end,
+                _ => panic!("invalid relocation target offset: {}", target_off),
+            };
+
+            let base = image.as_ptr() as u64;
+            let value = base.wrapping_add(rela.r_addend as u64);
+            image[target_off..target_end].copy_from_slice(&value.to_le_bytes());
         }
     }
 

libs/rust/ftl_elf/src/lib.rs

@@ -58,6 +58,44 @@ pub const PF_W: u32 = 0x2;
 /// Readable segment.
 pub const PF_R: u32 = 0x4;
 
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct Dyn64 {
+    pub d_tag: i64,
+    pub d_val: u64,
+}
+
+#[cfg(target_pointer_width = "64")]
+pub type Dyn = Dyn64;
+
+pub const DT_NULL: i64 = 0;
+pub const DT_RELA: i64 = 7;
+pub const DT_RELASZ: i64 = 8;
+
+#[derive(Debug, Clone, Copy)]
+#[repr(C)]
+pub struct Rela64 {
+    pub r_offset: u64,
+    pub r_info: u64,
+    pub r_addend: i64,
+}
+
+#[cfg(target_pointer_width = "64")]
+pub type Rela = Rela64;
+
+impl Rela {
+    pub fn r_sym(&self) -> u32 {
+        (self.r_info >> 32) as u32
+    }
+
+    pub fn r_type(&self) -> u32 {
+        self.r_info as u32
+    }
+}
+
+#[cfg(target_arch = "x86_64")]
+pub const R_X86_64_RELATIVE: u32 = 8;
+
 #[derive(Debug)]
 #[repr(C)]
 pub struct Phdr64 {

libs/rust/ftl_server/src/arch/x64/server.ld

@@ -9,6 +9,7 @@ PHDRS {
     rodata PT_LOAD;
     data PT_LOAD;
     bss PT_LOAD;
+    dynamic PT_DYNAMIC;
 }
 
 SECTIONS {
@@ -28,8 +29,7 @@ SECTIONS {
         *(.bss .bss.*)
     } : bss
 
-    ASSERT(SIZEOF(.rel.dyn) == 0, "server image must not contain REL relocations")
-    ASSERT(SIZEOF(.rela.dyn) == 0, "server image must not contain RELA relocations")
-    ASSERT(SIZEOF(.rel.plt) == 0, "server image must not contain REL relocations")
-    ASSERT(SIZEOF(.rela.plt) == 0, "server image must not contain RELA relocations")
+    .dynamic : {
+        *(.dynamic)
+    } : bss : dynamic
 }