Some page fault handling / NMI nesting procedure

src/arch/x86_64/interrupt/exception.rs

@@ -15,8 +15,6 @@ extern {
 
 interrupt_stack!(divide_by_zero, |stack| {
     println!("Divide by zero");
-    const ADDR: usize = 0xDEADC0DE;
-    println!("value {}", unsafe { (ADDR as *const u8).read_volatile() });
     stack.dump();
     stack_trace();
     ksignal(SIGFPE);
@@ -47,10 +45,38 @@ interrupt_stack!(debug, @paranoid, |stack| {
 
 nmi_handler!(non_maskable, |stack| {
     println!("Non-maskable interrupt");
-    let rsp: usize;
-    core::arch::asm!("mov {}, rsp", out(reg) rsp);
-    println!("RSP: {:>016X}", rsp);
     stack.dump();
+    // let rsp: usize;
+    // core::arch::asm!("mov {}, rsp", out(reg) rsp);
+    // println!("RSP: {:>016X}", rsp);
+    use crate::info;
+    use crate::time::realtime;
+
+     let req = syscall::TimeSpec {
+        tv_sec: 0,
+        tv_nsec: 0,
+    };
+
+    let time = realtime();
+    info!("{} : Entering NMI", time);
+
+    // let mut rem = syscall::TimeSpec::default();
+    // let _ =  crate::syscall::time::nanosleep(&req, Some(&mut rem));
+
+    // Page Fault
+    let addr = 0xDEADC0DE as *const u8;
+    let n = core::ptr::read(addr);
+    println!("{}",n);
+    // core::arch::asm!(
+    // "
+    //    mov rdx, [0xDEADC0DE]
+    // ");
+
+    // let mut rem = syscall::TimeSpec::default();
+    // let _ = crate::syscall::time::nanosleep(&req, Some(&mut rem));
+    let time = realtime();
+    info!("{} : Exiting NMI", time);
+
 });
 
 interrupt_stack!(breakpoint, |stack| {
@@ -146,19 +172,57 @@ interrupt_error!(page, |stack| {
     println!("  User: {}", stack.code & 1 << 2 != 0);
     println!("  Reserved write: {}", stack.code & 1 << 3 != 0);
     println!("  Instruction fetch: {}", stack.code & 1 << 4 != 0);
-    stack.dump();
+    // stack.dump();
     stack_trace();
     // ksignal(SIGSEGV);
 
+    // use crate::paging::entry::Entry;
+    // use crate::paging::Page;
     use crate::arch::paging::PAGE_SIZE;
-    use crate::syscall::data::Map;
+    // use crate::syscall::data::Map;
+    use crate::rmm::KernelMapper;
+    // use crate::context::memory::Grant;
+    use rmm::{PageEntry, VirtualAddress};
+    // use bitfield::Bit;
+    use rmm::PageFlags;
 
     let aligned_addr: usize = cr2 / PAGE_SIZE * PAGE_SIZE;
     println!("{:x?}",aligned_addr);
-    let map = Map { offset: 0, address: aligned_addr, size: PAGE_SIZE, flags: MapFlags::MAP_FIXED_NOREPLACE | MapFlags::MAP_PRIVATE | MapFlags::PROT_READ | MapFlags::PROT_WRITE };
-    // let _ = syscall::fmap(!0, &map).expect("failed to re-map address");
-    let _ = MemoryScheme.fmap(!0,  &map ).expect("IDK") ;
-    //loop{}
+
+    // let page = Page::containing_address(VirtualAddress::new(aligned_addr));
+    // println!("{:x?}",page);
+
+    let mut km = KernelMapper::lock();
+    let mut km = km.get_mut().expect("pls");
+    // let mut pt = km.table();
+    let mut flags = PageFlags::new();
+    //flags = flags.custom_flag(MapFlags::MAP_FIXED_NOREPLACE.bits(),true);
+    //flags = flags.custom_flag(MapFlags::MAP_PRIVATE.bits(),true);
+    //flags = flags.custom_flag(MapFlags::PROT_READ.bits(),true);
+    //flags = flags.custom_flag(MapFlags::PROT_WRITE.bits(),true);
+    //flags.set_bit(0,true);
+    println!("{:?}",flags);
+    let r = km.map(VirtualAddress::new(aligned_addr),flags);
+    //println!("{:?}",r);
+
+    // let mut entry = PageEntry::new(0);
+    // entry.set_flags(flags);
+    // println!("{:?}",entry);
+    // let i = pt.index_of(addr).expect("qqch");
+    // println!("{:?}",pt.entry_base(0));
+    // println!("{:?}",pt.entry_virt(0));
+    // println!("{:?}",pt.entry(0));
+    //let a = pt.set_entry(aligned_addr>>12,entry);
+
+    // let map = Map { offset: 0, address: aligned_addr, size: PAGE_SIZE, flags: MapFlags::MAP_FIXED_NOREPLACE | MapFlags::MAP_PRIVATE | MapFlags::PROT_READ | MapFlags::PROT_WRITE };
+    // let page = Page::containing_address(VirtualAddress::new(map.address));
+    // let page_count = map.size/PAGE_SIZE;
+    // let p = context::current().expect("ha").read().addr_space().expect("hb").write()
+    // .mmap((map.address != 0).then_some(page), page_count, map.flags, |page, flags, mapper, flusher| {
+    //             Ok(Grant::zeroed(page, page_count, flags, mapper, flusher)?)
+    //         }).expect("hc");
+
+    //let _ = MemoryScheme.fmap(!0,  &map ).expect("IDK") ;
 });
 
 interrupt_stack!(fpu_fault, |stack| {

src/arch/x86_64/interrupt/handler.rs

@@ -419,7 +419,7 @@ macro_rules! interrupt_stack {
                 push_scratch!(),
                 push_preserved!(),
                 "
-                //call {p}
+                // call {p}
                 ",
 
                 $save2!(),
@@ -567,7 +567,7 @@ macro_rules! nmi_handler {
                 "
                 end_repeat_nmi:
                 ",
-                 swapgs_iff_ring3_fast!(),
+                swapgs_iff_ring3_fast!(),
                 "
                 push rax
                 ",
@@ -683,7 +683,6 @@ macro_rules! interrupt_error {
                 println!("hello int");
             }
             core::arch::asm!(concat!(
-                //"call {hello}\n",
                 swapgs_iff_ring3_fast_errorcode!(),
                 // Move rax into code's place, put code in last instead (to be
                 // compatible with InterruptStack)
@@ -695,7 +694,7 @@ macro_rules! interrupt_error {
 
                 // Put code in, it's now in rax
                 "push rax\n",
-
+                //"call {hello}\n",
                 // TODO: Map PTI
                 // $crate::arch::x86_64::pti::map();
 
@@ -721,7 +720,7 @@ macro_rules! interrupt_error {
             ),
 
             inner = sym inner,
-            hello = sym hello,
+            // hello = sym hello,
 
             options(noreturn));
         }