WIP do not merge -- bunch of debugging.

Author: gz

Cargo.lock

@@ -387,7 +387,7 @@ pub extern "C" fn uefi_start(handle: uefi::Handle, mut st: SystemTable<Boot>) ->
 
     // On big machines with the init stack tends to put big structures
     // on the stack so we reserve a fair amount of space:
-    let stack_pages: usize = 768;
+    let stack_pages: usize = 1024;
     let stack_region: PAddr = allocate_pages(&st, stack_pages, MemoryType(KERNEL_STACK));
     let stack_protector: PAddr = stack_region;
     let stack_base: PAddr = stack_region + BASE_PAGE_SIZE;

bootloader/src/main.rs

@@ -272,7 +272,7 @@ pub unsafe fn setup_early_idt() {
 ///
 /// # See also
 /// Described in Intel SDM 3a, Figure 6-8. IA-32e Mode Stack Usage After Privilege Level Change
-#[repr(C)]
+#[repr(C, packed)]
 pub struct ExceptionArguments {
     _reserved: u64,
     vector: u64,
@@ -286,10 +286,17 @@ pub struct ExceptionArguments {
 
 impl fmt::Debug for ExceptionArguments {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        let vector = self.vector;
+        let exception = self.exception;
+        let rip = self.rip;
+        let cs = self.cs;
+        let rflags = self.rflags;
+        let rsp = self.rsp;
+        let ss = self.ss;
         write!(
                 f,
                 "ExceptionArguments {{ vec = 0x{:x} exception = 0x{:x} rip = 0x{:x}, cs = 0x{:x} rflags = 0x{:x} rsp = 0x{:x} ss = 0x{:x} }}",
-                self.vector, self.exception, self.rip, self.cs, self.rflags, self.rsp, self.ss
+                vector, exception, rip, cs, rflags, rsp, ss
             )
     }
 }
@@ -304,7 +311,8 @@ unsafe fn unhandled_irq(a: &ExceptionArguments) {
         let desc = &EXCEPTIONS[a.vector as usize];
         sprintln!(" {}", desc);
     } else {
-        sprintln!(" dev vector {}", a.vector);
+        let vector = a.vector;
+        sprintln!(" dev vector {}", vector);
     }
     sprintln!("{:?}", a);
     backtrace();
@@ -374,7 +382,8 @@ unsafe fn pf_handler(a: &ExceptionArguments) {
     // Print where the fault happend in the address-space:
     let faulting_address = x86::controlregs::cr2();
     sprint!("Faulting address: {:#x}", faulting_address);
-    sprint!(" Instruction Pointer: {:#x}", a.rip);
+    let rip = a.rip;
+    sprint!(" Instruction Pointer: {:#x}", rip);
 
     /*
     if !err.contains(PageFaultError::US) {
@@ -390,7 +399,7 @@ unsafe fn pf_handler(a: &ExceptionArguments) {
     */
 
     // Print the RIP that triggered the fault:
-    sprint!("Instruction Pointer: {:#x}", a.rip);
+    sprint!("Instruction Pointer: {:#x}", rip);
     if !err.contains(PageFaultError::US) {
         crate::KERNEL_ARGS
             .get()
@@ -596,7 +605,8 @@ unsafe fn gp_handler(a: &ExceptionArguments) {
 
     // Print the RIP that triggered the fault:
     //use crate::arch::kcb;
-    sprint!("Instruction Pointer: {:#x}", a.rip);
+    let rip = a.rip;
+    sprint!("Instruction Pointer: {:#x}", rip);
     /*kcb::try_get_kcb::<Arch86Kcb>().map(|k| {
         sprintln!(
             " (in ELF: {:#x})",

kernel/src/arch/x86_64/irq.rs

@@ -294,7 +294,7 @@ fn _start(argc: isize, _argv: *const *const u8) -> isize {
     let mut dyn_mem = PerCoreMemory::new(emanager, 0);
     // Make `dyn_mem` a static reference:
     let static_dyn_mem =
-        // Safety: 
+        // Safety:
         // - The initial stack of the core will never get deallocated (hence
         //   'static is fine)
         // - TODO(safety): aliasing rules is broken here (we have mut dyn_mem
@@ -305,7 +305,7 @@ fn _start(argc: isize, _argv: *const *const u8) -> isize {
     let mut arch = kcb::Arch86Kcb::new(static_dyn_mem);
     // Make `arch` a static reference:
     let static_kcb =
-        // Safety: 
+        // Safety:
         // - The initial stack of the core will never get deallocated (hence
         //   'static is fine)
         // - TODO(safety): aliasing rules is broken here (we have mut dyn_mem
@@ -363,7 +363,7 @@ fn _start(argc: isize, _argv: *const *const u8) -> isize {
     // `global_memory` to every core) that's fine since it is allocated on our
     // BSP init stack (which isn't reclaimed):
     let global_memory_static =
-        // Safety: 
+        // Safety:
         // -'static: Lives on init stack (not deallocated)
         // - No mut alias to it
         unsafe { core::mem::transmute::<&GlobalMemory, &'static GlobalMemory>(&global_memory) };
@@ -384,13 +384,15 @@ fn _start(argc: isize, _argv: *const *const u8) -> isize {
     crate::nr::NR_REPLICA.call_once(|| (bsp_replica.clone(), local_ridx));
 
     // Starting to initialize file-system
+    info!("before alloc logs");
     let fs_logs = crate::fs::cnrfs::allocate_logs();
+    info!("after alloc logs {}", fs_logs.len());
+    let fs_logs_cloned = fs_logs
+        .try_clone()
+        .expect("Not enough memory to initialize system");
+    info!("after fs logs cloned");
     // Construct the first replica
-    let fs_replica = MlnrReplica::<MlnrKernelNode>::new(
-        fs_logs
-            .try_clone()
-            .expect("Not enough memory to initialize system"),
-    );
+    let fs_replica = MlnrReplica::<MlnrKernelNode>::new(fs_logs_cloned);
     crate::fs::cnrfs::init_cnrfs_on_thread(fs_replica.clone());
 
     // Intialize PCI

kernel/src/arch/x86_64/mod.rs

@@ -960,6 +960,7 @@ impl elfloader::ElfLoader for Ring3Process {
                 .expect("Refill didn't work");
 
             let pcm = crate::arch::kcb::per_core_mem();
+            info!("1");
 
             // TODO(correctness): Will this work (we round-up and map large-pages?)
             // TODO(efficiency): What about wasted memory
@@ -991,20 +992,22 @@ impl elfloader::ElfLoader for Ring3Process {
                         .allocate_large_page()
                         .expect("We refilled so allocation should work.")
                 };
+                info!("2");
 
                 trace!(
                     "process load vspace from {:#x} with {:?}",
                     self.offset + page_base + i * LARGE_PAGE_SIZE,
                     frame
                 );
-
+                info!("3");
                 self.vspace
                     .map_frame(
                         self.offset + page_base + i * LARGE_PAGE_SIZE,
                         frame,
                         map_action,
                     )
                     .expect("Can't map ELF region");
+                info!("4");
             }
         }
 

kernel/src/arch/x86_64/process.rs

@@ -8,6 +8,7 @@ use fallible_collections::btree::BTreeMap;
 use lazy_static::lazy_static;
 use spin::Mutex;
 use x86::current::paging::{PDFlags, PDPTFlags, PTFlags};
+use log::info;
 
 mod debug;
 pub mod page_table; /* TODO(encapsulation): This should be a private module but we break encapsulation in a few places */
@@ -90,6 +91,7 @@ pub(crate) struct VSpace {
 
 impl AddressSpace for VSpace {
     fn map_frame(&mut self, base: VAddr, frame: Frame, action: MapAction) -> Result<(), KError> {
+        info!("map_frame 1");
         if frame.size() == 0 {
             return Err(KError::InvalidFrame);
         }
@@ -101,6 +103,7 @@ impl AddressSpace for VSpace {
             // virtual addr should be aligned to page-size
             return Err(KError::InvalidBase);
         }
+        info!("map_frame 2");
 
         let tomap_range = base.as_usize()..base.as_usize() + frame.size;
 
@@ -111,11 +114,13 @@ impl AddressSpace for VSpace {
             .range((Unbounded, Excluded(VAddr::from(tomap_range.end))))
             .rev()
         {
+            info!("map_frame 3");
             let existing_map_range = existing_mapping.vrange(existing_base);
             if existing_map_range.end <= tomap_range.start {
                 // We reached the end of relevant mappings
                 break;
             }
+            info!("map_frame 4");
 
             if existing_base == base
                 && existing_mapping.frame.base == frame.base
@@ -129,10 +134,13 @@ impl AddressSpace for VSpace {
                 });
             }
         }
-
+        info!("map_frame 5");
         self.mappings
             .try_insert(base, MappingInfo::new(frame, action))?;
-        self.page_table.map_frame(base, frame, action)
+        info!("map_frame 6");
+        let r = self.page_table.map_frame(base, frame, action);
+        info!("map_frame 6");
+        r
     }
 
     fn map_memory_requirements(_base: VAddr, _frames: &[Frame]) -> usize {