Updated dependencies

Signed-off-by: SlyMarbo <[email protected]>

Author: SlyMarbo

kernel/.cargo/config

@@ -1,3 +1,7 @@
+[unstable]
+build-std = ["core", "compiler_builtins", "alloc"]
+build-std-features = ["compiler-builtins-mem"]
+
 [build]
 target = "x86_64-firefly.json"
 

kernel/Cargo.lock

@@ -5,18 +5,15 @@ authors = ["Jamie Hall <[email protected]>"]
 edition = "2018"
 
 [dependencies]
-bootloader = { version = "0.9.5", features = ["map_physical_memory"]}
-linked_list_allocator = "0.8.4"
-pc-keyboard = "0.5.0"
-pic8259_simple = "0.2.0"
-spin = "0.5.2"
-uart_16550 = "0.2.7"
-volatile = "0.2.6"
-x86_64 = "0.11.1"
-
-[dependencies.lazy_static]
-version = "1.0"
-features = ["spin_no_std"]
+bootloader = { version = "=0.9.19", features = ["map_physical_memory"]}
+lazy_static = { version = "=1.4.0", features = ["spin_no_std"]}
+linked_list_allocator = "=0.9.0"
+pc-keyboard = "=0.5.0"
+pic8259 = "=0.10.1"
+spin = "=0.5.2"
+uart_16550 = "=0.2.15"
+volatile = "=0.2.6"
+x86_64 = "=0.14.6"
 
 [profile.dev]
 panic = "abort"

kernel/Cargo.toml

@@ -2,4 +2,4 @@
 
 set -e
 
-cargo bootimage --target ../x86_64-firefly.json --release
+cargo bootimage --target x86_64-firefly.json --release

kernel/build

@@ -34,8 +34,9 @@ impl FixedSizeBlockAllocator {
     /// new creates an empty FixedSizeBlockAllocator.
     ///
     pub const fn new() -> Self {
+        const EMPTY: Option<&'static mut ListNode> = None;
         FixedSizeBlockAllocator {
-            list_heads: [None; BLOCK_SIZES.len()],
+            list_heads: [EMPTY; BLOCK_SIZES.len()],
             fallback_allocator: linked_list_allocator::Heap::empty(),
         }
     }

kernel/src/allocator/fixed_size_block.rs

@@ -1,15 +1,14 @@
 use lazy_static::lazy_static;
+use x86_64::instructions::segmentation::{CS, Segment};
+use x86_64::instructions::tables::load_tss;
 use x86_64::structures::gdt::{Descriptor, GlobalDescriptorTable, SegmentSelector};
 use x86_64::structures::tss::TaskStateSegment;
 use x86_64::VirtAddr;
 
 pub fn init() {
-    use x86_64::instructions::segmentation::set_cs;
-    use x86_64::instructions::tables::load_tss;
-
     GDT.0.load();
     unsafe {
-        set_cs(GDT.1.code_selector);
+        CS::set_reg(GDT.1.code_selector);
         load_tss(GDT.1.tss_selector);
     }
 }
@@ -40,11 +39,12 @@ lazy_static! {
     static ref TSS: TaskStateSegment = {
         let mut tss = TaskStateSegment::new();
         tss.interrupt_stack_table[DOUBLE_FAULT_IST_INDEX as usize] = {
-            const STACK_SIZE: usize = 4096;
+            const STACK_SIZE: usize = 4096 * 5;
             static mut STACK: [u8; STACK_SIZE] = [0; STACK_SIZE];
 
             let stack_start = VirtAddr::from_ptr(unsafe { &STACK });
-            stack_start + STACK_SIZE
+            let stack_end = stack_start + STACK_SIZE;
+            stack_end
         };
         tss
     };

kernel/src/gdt.rs

@@ -1,6 +1,6 @@
 use crate::{gdt, halt_loop, print, println, time};
 use lazy_static::lazy_static;
-use pic8259_simple::ChainedPics;
+use pic8259::ChainedPics;
 use x86_64::structures::idt::{InterruptDescriptorTable, InterruptStackFrame, PageFaultErrorCode};
 
 pub fn init() {
@@ -11,12 +11,12 @@ lazy_static! {
     static ref IDT: InterruptDescriptorTable = {
         let mut idt = InterruptDescriptorTable::new();
         idt.breakpoint.set_handler_fn(breakpoint_handler);
+        idt.page_fault.set_handler_fn(page_fault_handler);
         unsafe {
             idt.double_fault
                 .set_handler_fn(double_fault_handler)
                 .set_stack_index(gdt::DOUBLE_FAULT_IST_INDEX);
         }
-        idt.page_fault.set_handler_fn(page_fault_handler);
         idt[InterruptIndex::Timer.as_usize()].set_handler_fn(timer_interrupt_handler);
         idt[InterruptIndex::Keyboard.as_usize()].set_handler_fn(keyboard_interrupt_handler);
 
@@ -26,18 +26,31 @@ lazy_static! {
 
 // Interrupt handlers.
 
-extern "x86-interrupt" fn breakpoint_handler(stack_frame: &mut InterruptStackFrame) {
+extern "x86-interrupt" fn breakpoint_handler(stack_frame: InterruptStackFrame) {
     println!("EXCEPTION: BREAKPOINT\n{:#?}", stack_frame);
 }
 
+extern "x86-interrupt" fn page_fault_handler(
+    stack_frame: InterruptStackFrame,
+    error_code: PageFaultErrorCode,
+) {
+    use x86_64::registers::control::Cr2;
+
+    println!("EXCEPTION: PAGE FAULT");
+    println!("Accessed Address: {:?}", Cr2::read());
+    println!("Error Code: {:?}", error_code);
+    println!("{:#?}", stack_frame);
+    halt_loop();
+}
+
 extern "x86-interrupt" fn double_fault_handler(
-    stack_frame: &mut InterruptStackFrame,
+    stack_frame: InterruptStackFrame,
     _error_code: u64,
 ) -> ! {
     panic!("EXCEPTION: DOUBLE FAULT\n{:#?}", stack_frame);
 }
 
-extern "x86-interrupt" fn keyboard_interrupt_handler(_stack_frame: &mut InterruptStackFrame) {
+extern "x86-interrupt" fn keyboard_interrupt_handler(_stack_frame: InterruptStackFrame) {
     use pc_keyboard::{layouts, DecodedKey, HandleControl, Keyboard, ScancodeSet1};
     use spin::Mutex;
     use x86_64::instructions::port::Port;
@@ -67,20 +80,7 @@ extern "x86-interrupt" fn keyboard_interrupt_handler(_stack_frame: &mut Interrup
     }
 }
 
-extern "x86-interrupt" fn page_fault_handler(
-    stack_frame: &mut InterruptStackFrame,
-    error_code: PageFaultErrorCode,
-) {
-    use x86_64::registers::control::Cr2;
-
-    println!("EXCEPTION: PAGE FAULT");
-    println!("Accessed Address: {:?}", Cr2::read());
-    println!("Error Code: {:?}", error_code);
-    println!("{:#?}", stack_frame);
-    halt_loop();
-}
-
-extern "x86-interrupt" fn timer_interrupt_handler(_stack_frame: &mut InterruptStackFrame) {
+extern "x86-interrupt" fn timer_interrupt_handler(_stack_frame: InterruptStackFrame) {
     time::TICKER.tick();
 
     unsafe {

kernel/src/interrupts.rs

@@ -3,8 +3,7 @@
 #![feature(custom_test_frameworks)]
 #![feature(abi_x86_interrupt)]
 #![feature(alloc_error_handler)]
-#![feature(const_fn)]
-#![feature(const_in_array_repeat_expressions)]
+#![feature(const_mut_refs)]
 #![test_runner(crate::test_runner)]
 #![reexport_test_harness_main = "test_main"]
 
@@ -64,7 +63,7 @@ impl<A> Locked<A> {
 /// Testable represents a test function.
 ///
 pub trait Testable {
-    fn run(&self);
+    fn run(&self) -> ();
 }
 
 /// Wrap tests with debug statements.