Upgrade to latext x86_64 crate (with our LockedIdt changes intact)

Author: kevinaboos

Cargo.lock

@@ -28,6 +28,9 @@ git = "https://github.com/theseus-os/irq_safety"
 [dependencies.atomic_linked_list]
 path = "../../libs/atomic_linked_list"
 
+[dependencies.msr]
+path = "../../libs/msr"
+
 [dependencies.pit_clock]
 path = "../pit_clock"
 

kernel/apic/Cargo.toml

@@ -19,14 +19,15 @@ extern crate x86_64;
 extern crate pit_clock;
 extern crate crossbeam_utils;
 extern crate bit_field;
+extern crate msr;
 
 use volatile::{Volatile, ReadOnly, WriteOnly};
 use zerocopy::FromBytes;
 use alloc::boxed::Box;
 use owning_ref::BoxRefMut;
 use spin::Once;
 use raw_cpuid::CpuId;
-use x86_64::registers::msr::*;
+use msr::*;
 use irq_safety::RwLockIrqSafe;
 use memory::{PageTable, PhysicalAddress, EntryFlags, MappedPages, allocate_pages, allocate_frames_at};
 use kernel_config::time::CONFIG_TIMESLICE_PERIOD_MICROSECONDS;
@@ -707,3 +708,13 @@ impl LocalApic {
         }
     }
 }
+
+// Below: temporary functions for reading MSRs that aren't yet in the `x86_64` crate.
+
+fn rdmsr(msr: u32) -> u64 {
+    unsafe { x86_64::registers::model_specific::Msr::new(msr).read() }
+}
+
+unsafe fn wrmsr(msr: u32, value: u64) {
+    x86_64::registers::model_specific::Msr::new(msr).write(value)
+}

kernel/apic/src/lib.rs

@@ -39,8 +39,8 @@ use memory::{PhysicalAddress, MappedPages};
 use pci::{PciDevice, PCI_INTERRUPT_LINE, PciConfigSpaceAccessMechanism};
 use kernel_config::memory::PAGE_SIZE;
 use owning_ref::BoxRefMut;
-use interrupts::{eoi,register_interrupt};
-use x86_64::structures::idt::{ExceptionStackFrame};
+use interrupts::{eoi, register_interrupt};
+use x86_64::structures::idt::InterruptStackFrame;
 use network_interface_card:: NetworkInterfaceCard;
 use nic_initialization::{allocate_memory, init_rx_buf_pool, init_rx_queue, init_tx_queue};
 use intel_ethernet::descriptors::{LegacyRxDescriptor, LegacyTxDescriptor};
@@ -422,7 +422,7 @@ impl E1000Nic {
     }
 }
 
-extern "x86-interrupt" fn e1000_handler(_stack_frame: &mut ExceptionStackFrame) {
+extern "x86-interrupt" fn e1000_handler(_stack_frame: InterruptStackFrame) {
     if let Some(ref e1000_nic_ref) = E1000_NIC.get() {
         let mut e1000_nic = e1000_nic_ref.lock();
         if let Err(e) = e1000_nic.handle_interrupt() {

kernel/e1000/src/lib.rs

@@ -13,7 +13,7 @@ extern crate gdt;
 
 use spin::Mutex;
 use x86_64::structures::{
-    idt::{LockedIdt, ExceptionStackFrame, PageFaultErrorCode},
+    idt::{LockedIdt, InterruptStackFrame, PageFaultErrorCode},
     tss::TaskStateSegment,
 };
 use gdt::{Gdt, create_gdt};
@@ -43,7 +43,7 @@ pub fn init(double_fault_stack_top_unusable: Option<memory::VirtualAddress>) {
     if let Some(df_stack_top) = double_fault_stack_top_unusable {
         // Create and load an initial TSS and GDT so we can handle early exceptions such as double faults. 
         let mut tss = TaskStateSegment::new();
-        tss.interrupt_stack_table[tss::DOUBLE_FAULT_IST_INDEX] = x86_64::VirtualAddress(df_stack_top.value());
+        tss.interrupt_stack_table[tss::DOUBLE_FAULT_IST_INDEX] = x86_64::VirtAddr::new(df_stack_top.value() as u64);
         println_raw!("exceptions_early(): Created TSS: {:?}", tss);
         *EARLY_TSS.lock() = tss;
 
@@ -69,7 +69,7 @@ pub fn init(double_fault_stack_top_unusable: Option<memory::VirtualAddress>) {
         let mut idt = EARLY_IDT.lock(); // withholds interrupts
 
         // SET UP FIXED EXCEPTION HANDLERS
-        idt.divide_by_zero.set_handler_fn(divide_by_zero_handler);
+        idt.divide_error.set_handler_fn(divide_error_handler);
         // missing: 0x01 debug exception
         idt.non_maskable_interrupt.set_handler_fn(nmi_handler);
         idt.breakpoint.set_handler_fn(breakpoint_handler);
@@ -109,16 +109,16 @@ pub fn init(double_fault_stack_top_unusable: Option<memory::VirtualAddress>) {
 
 
 /// exception 0x00
-pub extern "x86-interrupt" fn divide_by_zero_handler(stack_frame: &mut ExceptionStackFrame) {
-    println_raw!("\nEXCEPTION (early): DIVIDE BY ZERO\n{:#?}", stack_frame);
+pub extern "x86-interrupt" fn divide_error_handler(stack_frame: InterruptStackFrame) {
+    println_raw!("\nEXCEPTION (early): DIVIDE ERROR\n{:#?}", stack_frame);
 
     loop {}
 }
 
 
 
 /// exception 0x02
-pub extern "x86-interrupt" fn nmi_handler(stack_frame: &mut ExceptionStackFrame) {
+pub extern "x86-interrupt" fn nmi_handler(stack_frame: InterruptStackFrame) {
     println_raw!("\nEXCEPTION (early): NON-MASKABLE INTERRUPT at {:#x}\n{:#?}",
              stack_frame.instruction_pointer,
              stack_frame);
@@ -128,7 +128,7 @@ pub extern "x86-interrupt" fn nmi_handler(stack_frame: &mut ExceptionStackFrame)
 
 
 /// exception 0x03
-pub extern "x86-interrupt" fn breakpoint_handler(stack_frame: &mut ExceptionStackFrame) {
+pub extern "x86-interrupt" fn breakpoint_handler(stack_frame: InterruptStackFrame) {
     println_raw!("\nEXCEPTION (early): BREAKPOINT at {:#x}\n{:#?}",
              stack_frame.instruction_pointer,
              stack_frame);
@@ -137,7 +137,7 @@ pub extern "x86-interrupt" fn breakpoint_handler(stack_frame: &mut ExceptionStac
 }
 
 /// exception 0x06
-pub extern "x86-interrupt" fn invalid_opcode_handler(stack_frame: &mut ExceptionStackFrame) {
+pub extern "x86-interrupt" fn invalid_opcode_handler(stack_frame: InterruptStackFrame) {
     println_raw!("\nEXCEPTION (early): INVALID OPCODE at {:#x}\n{:#?}",
              stack_frame.instruction_pointer,
              stack_frame);
@@ -149,7 +149,7 @@ pub extern "x86-interrupt" fn invalid_opcode_handler(stack_frame: &mut Exception
 /// 
 /// For more information about "spurious interrupts", 
 /// see [here](http://wiki.osdev.org/I_Cant_Get_Interrupts_Working#I_keep_getting_an_IRQ7_for_no_apparent_reason).
-pub extern "x86-interrupt" fn device_not_available_handler(stack_frame: &mut ExceptionStackFrame) {
+pub extern "x86-interrupt" fn device_not_available_handler(stack_frame: InterruptStackFrame) {
     println_raw!("\nEXCEPTION (early): DEVICE_NOT_AVAILABLE at {:#x}\n{:#?}",
              stack_frame.instruction_pointer,
              stack_frame);
@@ -158,15 +158,15 @@ pub extern "x86-interrupt" fn device_not_available_handler(stack_frame: &mut Exc
 }
 
 
-pub extern "x86-interrupt" fn double_fault_handler(stack_frame: &mut ExceptionStackFrame, _error_code: u64) {
+pub extern "x86-interrupt" fn double_fault_handler(stack_frame: InterruptStackFrame, _error_code: u64) -> ! {
     println_raw!("\nEXCEPTION (early): DOUBLE FAULT\n{:#?}", stack_frame);
     println_raw!("\nNote: this may be caused by stack overflow. Is the size of the initial_bsp_stack is too small?");
 
     loop {}
 }
 
 
-pub extern "x86-interrupt" fn segment_not_present_handler(stack_frame: &mut ExceptionStackFrame, error_code: u64) {
+pub extern "x86-interrupt" fn segment_not_present_handler(stack_frame: InterruptStackFrame, error_code: u64) {
     println_raw!("\nEXCEPTION (early): SEGMENT_NOT_PRESENT FAULT\nerror code: \
                                   {:#b}\n{:#?}",
              error_code,
@@ -176,7 +176,7 @@ pub extern "x86-interrupt" fn segment_not_present_handler(stack_frame: &mut Exce
 }
 
 
-pub extern "x86-interrupt" fn general_protection_fault_handler(stack_frame: &mut ExceptionStackFrame, error_code: u64) {
+pub extern "x86-interrupt" fn general_protection_fault_handler(stack_frame: InterruptStackFrame, error_code: u64) {
     println_raw!("\nEXCEPTION (early): GENERAL PROTECTION FAULT \nerror code: \
                                   {:#X}\n{:#?}",
              error_code,
@@ -186,9 +186,8 @@ pub extern "x86-interrupt" fn general_protection_fault_handler(stack_frame: &mut
 }
 
 
-pub extern "x86-interrupt" fn early_page_fault_handler(stack_frame: &mut ExceptionStackFrame, error_code: PageFaultErrorCode) {
-    use x86_64::registers::control_regs;
-    let accessed_address = control_regs::cr2();
+pub extern "x86-interrupt" fn early_page_fault_handler(stack_frame: InterruptStackFrame, error_code: PageFaultErrorCode) {
+    let accessed_address = x86_64::registers::control::Cr2::read_raw();
     println_raw!("\nEXCEPTION (early): PAGE FAULT (early handler) while accessing {:#x}\nerror code: \
         {:?}\n{:#?}",
         accessed_address,
@@ -199,14 +198,14 @@ pub extern "x86-interrupt" fn early_page_fault_handler(stack_frame: &mut Excepti
     println_raw!("Exception IP {:#X} is at {:?}", 
         stack_frame.instruction_pointer, 
         mod_mgmt::get_initial_kernel_namespace().and_then(|ns| ns.get_section_containing_address(
-            memory::VirtualAddress::new_canonical(stack_frame.instruction_pointer.0 as usize),
+            memory::VirtualAddress::new_canonical(stack_frame.instruction_pointer.as_u64() as usize),
             false // only look at .text sections, not all other types
         )),
     );
     println_raw!("Faulted access address {:#X} is at {:?}",
         accessed_address,
         mod_mgmt::get_initial_kernel_namespace().and_then(|ns| ns.get_section_containing_address(
-            memory::VirtualAddress::new_canonical(accessed_address.0 as usize),
+            memory::VirtualAddress::new_canonical(accessed_address as usize),
             true, // look at all sections (.data/.bss/.rodata), not just .text
         )),
     );