WIP: Laying the groundwork for per-node/CPU segments

Signed-off-by: Dan Cross <[email protected]>

Author: Dan Cross

Cargo.lock

@@ -45,10 +45,10 @@
 //! execution.  Theon will locate them, and load them into
 //! physical memory.
 //!
-//! Each binary is allocated a 16MiB region of physical RAM for
-//! its various pages; these regions begin at 64MiB and are
-//! aligned on 32MiB boundaries, giving us room for loading new
-//! images into the second 16MiBs of each binary's region for
+//! Each binary is allocated an 8MiB region of physical RAM for
+//! its various pages; these regions begin at 16MiB and are
+//! aligned on 16MiB boundaries, giving us room for loading new
+//! images into the second 8MiBs of each binary's region for
 //! hitless update.
 //!
 //! Binaries represent either tasks or segments; see HDP 0002
@@ -104,13 +104,13 @@ enum BinaryType {
 /// or a task).
 type BinaryMeta = (&'static str, HPA, BinaryType);
 
-/// Binaries are loaded in 16MiB regions of physical memory
-/// that are aligned on 32MiB boundaries, starting at 64MiB.
+/// Binaries are loaded in 8MiB regions of physical memory
+/// that are aligned on 16MiB boundaries, starting at 16MiB.
 const fn load_addr(offset: usize) -> HPA {
-    let addr = (64 + offset * 32) * MIB;
+    let addr = (16 + offset * 16) * MIB;
     HPA::new(addr as u64)
 }
-const BINARY_IMAGE_MEMORY_SIZE: usize = 16 * MIB;
+const BINARY_IMAGE_MEMORY_SIZE: usize = 8 * MIB;
 
 /// A table description all the binaries that are loaded by
 /// theon, where to load them in physical memory, and their
@@ -157,10 +157,12 @@ pub extern "C" fn main(mbinfo_phys: u64) -> ! {
     let archive = goblin::archive::Archive::parse(bins.bytes).expect("cannot parse bin.a");
     uart::panic_println!("Binary archive: {:#x?}", archive);
     clear_binary_load_region();
+    let mut roots = alloc::vec::Vec::with_capacity(BINARY_TABLE.len());
     for &(name, addr, typ) in BINARY_TABLE {
         let bytes = archive.extract(name, bins.bytes).expect("cannot extract elf");
         let region_end = addr.offset(BINARY_IMAGE_MEMORY_SIZE);
-        load(name, typ, bytes, addr..region_end).expect("loaded binary");
+        let root = load(name, typ, bytes, addr..region_end).expect("loaded binary");
+        roots.push((name, root));
     }
     unsafe { core::arch::asm!("int3") };
     // Start other CPUs.

theon/src/main.rs

@@ -17,5 +17,6 @@ bitflags = "*"
 bit_field = "*"
 bitstruct = "*"
 seq-macro = "*"
+static_assertions = "*"
 x86 = "*"
 zerocopy = "*"

x86_64/Cargo.toml

@@ -12,12 +12,13 @@
 use crate::segment;
 use crate::tss::TSS;
 use core::arch::asm;
+use static_assertions::const_assert_eq;
 
 /// Support the x86_64 64-bit Global Descriptor Table.
 ///
 /// We waste a few bytes per CPU by allocating a 4KiB page for
 /// the GDT, then we map that at the known GDT location in the
-/// per-CPU virtual memory segment, but we pad that out to 64KiB
+/// per-node virtual memory segment.  We pad that out to 64KiB
 /// by mapping the zero page repeatedly beyond the end of the
 /// GDT proper.
 ///
@@ -34,7 +35,9 @@ pub struct GDT {
     _usertext: segment::Descriptor,
     _unused: segment::Descriptor, // For alignment.
     task: segment::TaskStateDescriptor,
+    _empty: [u64; 512 - 8],
 }
+const_assert_eq!(core::mem::size_of::<GDT>(), 4096);
 
 impl GDT {
     pub const fn empty() -> GDT {
@@ -46,6 +49,7 @@ impl GDT {
             _usertext: segment::Descriptor::empty(),
             _unused: segment::Descriptor::empty(),
             task: segment::TaskStateDescriptor::empty(),
+            _empty: [0; 512 - 8],
         }
     }
 
@@ -71,12 +75,11 @@ impl GDT {
     /// descriptor.
     ///
     /// # Safety
-    ///
     /// Called on a valid GDT.
     unsafe fn lgdt(&self) {
         let ptr: *const Self = self;
         let base = u64::try_from(ptr.addr()).unwrap();
-        const LIMIT: u16 = core::mem::size_of::<GDT>() as u16 - 1;
+        const LIMIT: u16 = 65535;
         unsafe {
             asm!(r#"
                 subq $16, %rsp;

x86_64/src/gdt.rs

@@ -117,7 +117,7 @@ pub trait Page {
 
     fn frame(&self) -> Self::FrameType {
         let addr = self.vaddr().addr();
-        let pfa = vm::translate(addr);
+        let pfa = vm::translate(addr).expect("Page is mapped");
         Self::FrameType::new(pfa)
     }
 }