feat: Linux syscall ABI alignment + ARM64 SMP stability

.gitignore

@@ -77,3 +77,6 @@ ovmf/
 
 **/target/*
 scripts/__pycache__
+
+# Third-party sources and build artifacts (cloned/built locally)
+third-party/

kernel/src/arch_impl/aarch64/context_switch.rs

@@ -1288,7 +1288,22 @@ fn set_next_ttbr0_for_thread(thread_id: u64) -> TtbrResult {
                 .map(|pt| pt.level_4_frame().start_address().as_u64())
                 .or(process.inherited_cr3)
         } else {
-            // Thread's process not found — orphaned thread
+            // Thread's process not found — orphaned thread.
+            // Diagnostic: dump all process thread IDs to identify the mismatch.
+            raw_uart_str("\n[TTBR_DIAG] wanted_tid=");
+            raw_uart_dec(thread_id);
+            raw_uart_str(" nproc=");
+            raw_uart_dec(manager.process_count() as u64);
+            for (pid, proc) in manager.iter_processes() {
+                raw_uart_str(" p");
+                raw_uart_dec(pid.as_u64());
+                raw_uart_str(":t");
+                match proc.main_thread.as_ref() {
+                    Some(t) => raw_uart_dec(t.id),
+                    None => raw_uart_str("X"),
+                }
+            }
+            raw_uart_str("\n");
             drop(manager_guard);
             return TtbrResult::ProcessGone;
         }

kernel/src/arch_impl/aarch64/elf.rs

@@ -88,6 +88,12 @@ pub struct LoadedElf {
     pub segments_end: u64,
     /// Lowest loaded address
     pub load_base: u64,
+    /// Virtual address of program headers (from PT_PHDR or load_base + phoff)
+    pub phdr_vaddr: u64,
+    /// Number of program headers
+    pub phnum: u16,
+    /// Size of each program header entry
+    pub phentsize: u16,
 }
 
 /// Validate an ELF header for ARM64
@@ -146,6 +152,7 @@ pub unsafe fn load_elf_kernel_space(data: &[u8]) -> Result<LoadedElf, &'static s
 
     let mut max_segment_end: u64 = 0;
     let mut min_load_addr: u64 = u64::MAX;
+    let mut phdr_vaddr: Option<u64> = None;
 
     // Process program headers
     let ph_offset = header.phoff as usize;
@@ -160,6 +167,11 @@ pub unsafe fn load_elf_kernel_space(data: &[u8]) -> Result<LoadedElf, &'static s
 
         let ph = &*(data.as_ptr().add(ph_start) as *const Elf64ProgramHeader);
 
+        // Check for PT_PHDR segment
+        if ph.p_type == SegmentType::Phdr as u32 {
+            phdr_vaddr = Some(ph.p_vaddr);
+        }
+
         if ph.p_type == SegmentType::Load as u32 {
             load_segment(data, ph)?;
 
@@ -177,6 +189,10 @@ pub unsafe fn load_elf_kernel_space(data: &[u8]) -> Result<LoadedElf, &'static s
     // Page-align the heap start
     let heap_start = (max_segment_end + 0xfff) & !0xfff;
 
+    let load_base = if min_load_addr == u64::MAX { 0 } else { min_load_addr };
+    // If no PT_PHDR was found, compute from load_base + phoff
+    let phdr_vaddr = phdr_vaddr.unwrap_or(load_base + header.phoff);
+
     crate::serial_println!(
         "[elf] Loaded: base={:#x}, end={:#x}, entry={:#x}",
         min_load_addr,
@@ -187,7 +203,10 @@ pub unsafe fn load_elf_kernel_space(data: &[u8]) -> Result<LoadedElf, &'static s
     Ok(LoadedElf {
         entry_point: header.entry,
         segments_end: heap_start,
-        load_base: if min_load_addr == u64::MAX { 0 } else { min_load_addr },
+        load_base,
+        phdr_vaddr,
+        phnum: header.phnum,
+        phentsize: header.phentsize,
     })
 }
 
@@ -289,6 +308,7 @@ pub fn load_elf_into_page_table(
 
     let mut max_segment_end: u64 = 0;
     let mut min_load_addr: u64 = u64::MAX;
+    let mut phdr_vaddr: Option<u64> = None;
 
     // Process program headers
     let ph_offset = header.phoff as usize;
@@ -306,6 +326,11 @@ pub fn load_elf_into_page_table(
         ph_bytes.copy_from_slice(&data[ph_start..ph_start + mem::size_of::<Elf64ProgramHeader>()]);
         let ph: &Elf64ProgramHeader = unsafe { &*(ph_bytes.as_ptr() as *const Elf64ProgramHeader) };
 
+        // Check for PT_PHDR segment
+        if ph.p_type == SegmentType::Phdr as u32 {
+            phdr_vaddr = Some(ph.p_vaddr);
+        }
+
         if ph.p_type == SegmentType::Load as u32 {
             load_segment_into_page_table(data, ph, page_table)?;
 
@@ -323,17 +348,24 @@ pub fn load_elf_into_page_table(
     // Page-align the heap start (4KB alignment)
     let heap_start = (max_segment_end + 0xfff) & !0xfff;
 
+    let load_base = if min_load_addr == u64::MAX { 0 } else { min_load_addr };
+    // If no PT_PHDR was found, compute from load_base + phoff
+    let phdr_vaddr = phdr_vaddr.unwrap_or(load_base + header.phoff);
+
     log::debug!(
         "[elf-arm64] Loaded: base={:#x}, end={:#x}, entry={:#x}",
-        if min_load_addr == u64::MAX { 0 } else { min_load_addr },
+        load_base,
         heap_start,
         header.entry
     );
 
     Ok(LoadedElf {
         entry_point: header.entry,
         segments_end: heap_start,
-        load_base: if min_load_addr == u64::MAX { 0 } else { min_load_addr },
+        load_base,
+        phdr_vaddr,
+        phnum: header.phnum,
+        phentsize: header.phentsize,
     })
 }