From 217844a1805fdb2009fe0d3bc7fa4acc4be49749 Mon Sep 17 00:00:00 2001 From: vandechat96 Date: Tue, 23 May 2023 20:05:20 +0200 Subject: [PATCH] add print for debug/info --- src/arch/x86_64/interrupt/exception.rs | 87 ++++++++--------- src/arch/x86_64/interrupt/handler.rs | 125 ++++++++++++++++--------- 2 files changed, 126 insertions(+), 86 deletions(-) diff --git a/src/arch/x86_64/interrupt/exception.rs b/src/arch/x86_64/interrupt/exception.rs index ef1346d..40916a0 100644 --- a/src/arch/x86_64/interrupt/exception.rs +++ b/src/arch/x86_64/interrupt/exception.rs @@ -1,4 +1,3 @@ -use syscall::Scheme; use crate::{ interrupt::stack_trace, ptrace, @@ -7,7 +6,6 @@ use crate::{ interrupt_stack, interrupt_error, }; -use crate::scheme::memory::MemoryScheme; extern { fn ksignal(signal: usize); @@ -45,29 +43,28 @@ interrupt_stack!(debug, @paranoid, |stack| { nmi_handler!(non_maskable, |stack| { println!("Non-maskable interrupt"); - stack.dump(); - // let rsp: usize; - // core::arch::asm!("mov {}, rsp", out(reg) rsp); - // println!("RSP: {:>016X}", rsp); - use crate::info; + // stack.dump(); + println!(" CS: {}", stack.iret.cs); + println!("CPU ID: {}",crate::cpu_id()); + use crate::time::realtime; let time = realtime(); - info!("{} : Entering NMI", time); + println!("Entering NMI inner: {} ", time); // Page Fault - let addr = 0xDEADC0DE as *const u8; + let addr = 0xDEADC0DE as *mut u8; let n = core::ptr::read(addr); - println!("{}",n); - //loop{} + println!("Value is {}", n); // core::arch::asm!( // " // mov rdx, [0xDEADC0DE] // "); - let time = realtime(); - info!("{} : Exiting NMI", time); + //loop{} + let time = realtime(); + println!("Exiting NMI inner: {}", time); }); interrupt_stack!(breakpoint, |stack| { @@ -158,46 +155,52 @@ interrupt_error!(page, |stack| { let cr2: usize; core::arch::asm!("mov {}, cr2", out(reg) cr2); println!("Page fault: {:>016X}", cr2); - println!(" Present: {}", stack.code & 1 << 0 != 0); - println!(" Write: {}", stack.code & 1 << 1 != 0); - println!(" User: {}", stack.code & 1 << 2 != 0); - println!(" Reserved write: {}", stack.code & 1 << 3 != 0); - println!(" Instruction fetch: {}", stack.code & 1 << 4 != 0); + // println!(" Present: {}", stack.code & 1 << 0 != 0); + // println!(" Write: {}", stack.code & 1 << 1 != 0); + // 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.inner.iret.cs - // stack.inner.iret.rip - stack_trace(); + //stack_trace(); // ksignal(SIGSEGV); + println!(" CS: {}", stack.inner.iret.cs); + println!(" RIP: {:>016X}", stack.inner.iret.rip); + + use crate::arch::paging::PAGE_SIZE; + use crate::rmm::KernelMapper; + use rmm::PageFlags; + use rmm::VirtualAddress; + + let aligned_addr: usize = cr2 / PAGE_SIZE * PAGE_SIZE; + println!("Aligned address: {:x?}", aligned_addr); + + + let mut km = KernelMapper::lock(); + let km = km.get_mut().expect("pls"); + let mut flags = PageFlags::new(); + flags = flags.write(true); + println!("{:?}", flags); + let _ = km.map(VirtualAddress::new(aligned_addr), flags); + + + let mut tmp = 0_u16; + core::arch::x86_64::_rdrand16_step(&mut tmp); + + let addr = cr2 as *mut u8; + core::ptr::write(addr, tmp as u8); + + println!("Writen {} to {:016X}", tmp as u8, cr2); + // use crate::paging::entry::Entry; // use crate::paging::Page; - use crate::arch::paging::PAGE_SIZE; - // 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); + // use crate::syscall::data::Map; // 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); diff --git a/src/arch/x86_64/interrupt/handler.rs b/src/arch/x86_64/interrupt/handler.rs index c9451bd..bd58218 100644 --- a/src/arch/x86_64/interrupt/handler.rs +++ b/src/arch/x86_64/interrupt/handler.rs @@ -406,21 +406,12 @@ macro_rules! interrupt_stack { $code } } - fn function_name(){ - println!("hello"); - } - fn function_name2(){ - println!("hello 2"); - } core::arch::asm!(concat!( // Backup all userspace registers to stack $save1!(), "push rax\n", push_scratch!(), push_preserved!(), - " - // call {p} - ", $save2!(), @@ -443,15 +434,9 @@ macro_rules! interrupt_stack { pop_scratch!(), $rstor1!(), - " - //call {p2} - ", "iretq\n", ), - p = sym function_name, - p2 = sym function_name2, - inner = sym inner, IA32_GS_BASE = const(x86::msr::IA32_GS_BASE), KERNEL_PERCPU_SHIFT = const(crate::KERNEL_PERCPU_SHIFT), @@ -480,23 +465,72 @@ macro_rules! nmi_handler { $ code } } - fn frsp(){ - unsafe { - let rsp: usize; - core::arch::asm!("mov {}, rsp", out(reg) rsp); - println!("FRSP: {:>016X}", rsp); + fn hnmi(){ + println!("-> Handler NMI"); + } + fn pstack(){ + unsafe{ + + let mut var: usize; + core::arch::asm!("mov {}, [rsp + 6*8]", out(reg) var); + println!("rsp 6*8: {:016x}",var); + core::arch::asm!("mov {}, [rsp + 5*8]", out(reg) var); + println!("rsp 5*8: {:016x}",var); + core::arch::asm!("mov {}, [rsp + 4*8]", out(reg) var); + println!("rsp 4*8: {:016x}",var); + core::arch::asm!("mov {}, [rsp + 3*8]", out(reg) var); + println!("rsp 3*8: {:016x}",var); + core::arch::asm!("mov {}, [rsp + 2*8]", out(reg) var); + println!("rsp 2*8: {:016x}",var); + core::arch::asm!("mov {}, [rsp + 1*8]", out(reg) var); + println!("rsp 1*8: {:016x}",var); + core::arch::asm!("mov {}, [rsp]", out(reg) var); + println!("rsp 0*8: {:016x}",var); + core::arch::asm!("mov {}, [rsp - 1*8]", out(reg) var); + println!("rsp -1*8: {:016x}",var); + core::arch::asm!("mov {}, [rsp - 2*8]", out(reg) var); + println!("rsp -2*8: {:016x}",var); + core::arch::asm!("mov {}, [rsp - 3*8]", out(reg) var); + println!("rsp -3*8: {:016x}",var); + core::arch::asm!("mov {}, [rsp - 4*8]", out(reg) var); + println!("rsp -4*8: {:016x}",var); + core::arch::asm!("mov {}, [rsp - 5*8]", out(reg) var); + println!("rsp -5*8: {:016x}",var); + core::arch::asm!("mov {}, rdx", out(reg) var); + println!("rdx {:016x}",var); + + + } + } + fn vnmi(){ + unsafe{ + let var: usize; + core::arch::asm!("mov {}, [rsp - 1*8]", out(reg) var); + println!("-> Var NMI: {:016x}",var); } + } + fn fnmi(){ + println!("-> First NMI"); + } + fn nnmi(){ + println!("-> Nested NMI"); + } + fn onmi(){ + println!("-> Out NMI"); } core::arch::asm!(concat!( " - //call {frsp} push rdx + call {hnmi} + call {pstack} + call {vnmi} cmp QWORD PTR [rsp + 8*2], {GDT_KERNEL_CODE} jne first_nmi ", // not from user space " - cmp QWORD PTR [rsp -8], $1 + call {vnmi} + cmp QWORD PTR [rsp - 8], $1 je nested_nmi ", // if nmi stack @@ -508,15 +542,16 @@ macro_rules! nmi_handler { // nested nmi " nested_nmi: + call {nnmi} /// ! repalce with address of repeat nmi and end repeat nmi - mov rdx, 0x0806f292 - cmp rdx, 8[rsp] + mov rdx, 0x080beb1c + cmp rdx, [rsp + 8] ja 1f - mov rdx, 0x0806f2b7 - cmp rdx, 8[rsp] + mov rdx, 0x080beb41 + cmp rdx, [rsp + 8] ja nested_nmi_out ", - // prepare + // prepare for return " 1: lea rdx, [rsp - 8] @@ -527,7 +562,7 @@ macro_rules! nmi_handler { pushf push {GDT_KERNEL_CODE} //replace address repeat nmi - push 0x0806f292 + push 0x080beb1c ", // nested nmi out " @@ -535,31 +570,30 @@ macro_rules! nmi_handler { pop rdx iretq ", - - // first nmi " first_nmi: mov rdx, [rsp] push $1 + call {fnmi} ", - // first copy + // first copy (saved) " sub rsp, $(5*8) .rept 5 - push 11*8[rsp] + push [rsp + 11*8] .endr ", //second copy " repeat_nmi: - mov QWORD PTR 10*8[rsp], $1 + mov QWORD PTR [rsp + 10*8], $1 add rsp, $(10*8) .rept 5 - push -6*8[rsp] + push [rsp - 6*8] .endr sub rsp, $(5*8) ", @@ -584,20 +618,28 @@ macro_rules! nmi_handler { swapgs_iff_ring3_fast!(), // remove extra frames and reset nmi exec var " - //call {frsp} 7: - add rsp,$(5*8) + add rsp,$(5*8) - mov QWORD PTR [rsp + 5 * 8], $0 + mov QWORD PTR [rsp + 5*8], $0 + + call {onmi} + call {pstack} - //call {frsp} iretq ", ), inner = sym inner, - frsp = sym frsp, + + hnmi = sym hnmi, + vnmi = sym vnmi, + fnmi = sym fnmi, + nnmi = sym nnmi, + onmi = sym onmi, + pstack = sym pstack, + GDT_KERNEL_CODE = const(crate::gdt::GDT_KERNEL_CODE), GDT_KERNEL_DATA = const(crate::gdt::GDT_KERNEL_DATA), @@ -678,9 +720,6 @@ macro_rules! interrupt_error { unsafe { $code } - } - fn hello(){ - println!("hello int"); } core::arch::asm!(concat!( swapgs_iff_ring3_fast_errorcode!(), @@ -694,7 +733,6 @@ 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(); @@ -720,7 +758,6 @@ macro_rules! interrupt_error { ), inner = sym inner, - // hello = sym hello, options(noreturn)); }