Update to latest bit_field version

(cherry picked from commit 46100ba24b)

.travis.yml

@@ -3,6 +3,15 @@ language: rust
 rust:
     - nightly
 
+cache: cargo
+
+before_script:
+  - curl https://sh.rustup.rs -sSf | sh -s -- --default-toolchain=$TRAVIS_RUST_VERSION -y
+  - source ~/.cargo/env
+  - rustup component add rust-src
+  - (test -x $HOME/.cargo/bin/rustfmt || cargo install rustfmt)
+  - (test -x $HOME/.cargo/bin/xargo || cargo install xargo)
+
 sudo: false
 
 notifications:
@@ -15,5 +24,4 @@ addons:
     packages:
       - nasm
 
-script:
-    - make
+script: make

Cargo.toml

@@ -7,7 +7,7 @@ version = "0.1.0"
 bit_field = "0.7.0"
 bitflags = "0.7.0"
 multiboot2 = "0.1.0"
-once = "0.2.1"
+once = "0.3.2"
 rlibc = "0.1.4"
 spin = "0.3.4"
 volatile = "0.1.0"
@@ -19,6 +19,10 @@ path = "libs/hole_list_allocator"
 default-features = false
 version = "0.8.0"
 
+[dependencies.lazy_static]
+version = "0.2.1"
+features = ["spin_no_std"]
+
 [lib]
 crate-type = ["staticlib"]
 

Makefile

@@ -8,7 +8,7 @@
 # except according to those terms.
 
 arch ?= x86_64
-target ?= $(arch)-unknown-linux-gnu
+target ?= $(arch)-blog_os
 kernel := build/kernel-$(arch).bin
 iso := build/os-$(arch).iso
 
@@ -49,7 +49,7 @@ $(kernel): cargo $(rust_os) $(assembly_object_files) $(linker_script)
 	@ld -n --gc-sections -T $(linker_script) -o $(kernel) $(assembly_object_files) $(rust_os)
 
 cargo:
-	@cargo build --target $(target)
+	@xargo build --target $(target)
 
 # compile assembly files
 build/arch/$(arch)/%.o: src/arch/$(arch)/%.asm

README.md

@@ -1,12 +1,14 @@
-# Blog OS (Catching Exceptions)
-[![Build Status](https://travis-ci.org/phil-opp/blog_os.svg?branch=catching_exceptions)](https://travis-ci.org/phil-opp/blog_os/branches)
+# Blog OS (Returning from Exceptions)
+[![Build Status](https://travis-ci.org/phil-opp/blog_os.svg?branch=returning_from_exceptions)](https://travis-ci.org/phil-opp/blog_os/branches)
 
-This repository contains the source code for the [Catching Exceptions](http://os.phil-opp.com/catching-exceptions.html) post of the [Writing an OS in Rust](http://os.phil-opp.com) series.
+This repository contains the source code for the [Returning from Exceptions](http://os.phil-opp.com/returning-from-exceptions.html) post of the [Writing an OS in Rust](http://os.phil-opp.com) series.
 
 **Check out the [master branch](https://github.com/phil-opp/blog_os) for more information.**
 
 ## Building
-You need to have `nasm`, `grub-mkrescue`, `xorriso`, `qemu`, and a nightly Rust compiler installed. Then you can run it using `make run`.
+You need to have `nasm`, `grub-mkrescue`, `xorriso`, `qemu`, a nightly Rust compiler, and [xargo] installed. Then you can run it using `make run`.
+
+[xargo]: https://github.com/japaric/xargo
 
 Please file an issue if you have any problems.
 

Xargo.toml

@@ -0,0 +1,2 @@
+[target.x86_64-blog_os.dependencies]
+collections = {}

src/interrupts/idt.rs

@@ -101,11 +101,13 @@ impl EntryOptions {
         self
     }
 
+    #[allow(dead_code)]
     pub fn set_privilege_level(&mut self, dpl: u16) -> &mut Self {
         self.0.set_bits(13..15, dpl);
         self
     }
 
+    #[allow(dead_code)]
     pub fn set_stack_index(&mut self, index: u16) -> &mut Self {
         self.0.set_bits(0..3, index);
         self

src/interrupts/mod.rs

@@ -9,11 +9,91 @@
 
 mod idt;
 
+macro_rules! save_scratch_registers {
+    () => {
+        asm!("push rax
+              push rcx
+              push rdx
+              push rsi
+              push rdi
+              push r8
+              push r9
+              push r10
+              push r11
+        " :::: "intel", "volatile");
+    }
+}
+
+macro_rules! restore_scratch_registers {
+    () => {
+        asm!("pop r11
+              pop r10
+              pop r9
+              pop r8
+              pop rdi
+              pop rsi
+              pop rdx
+              pop rcx
+              pop rax
+            " :::: "intel", "volatile");
+    }
+}
+
+macro_rules! handler {
+    ($name: ident) => {{
+        #[naked]
+        extern "C" fn wrapper() -> ! {
+            unsafe {
+                save_scratch_registers!();
+                asm!("mov rdi, rsp
+                      add rdi, 9*8 // calculate exception stack frame pointer
+                      call $0"
+                      :: "i"($name as extern "C" fn(
+                          &ExceptionStackFrame))
+                      : "rdi" : "intel");
+
+                restore_scratch_registers!();
+                asm!("iretq" :::: "intel", "volatile");
+                ::core::intrinsics::unreachable();
+            }
+        }
+        wrapper
+    }}
+}
+
+macro_rules! handler_with_error_code {
+    ($name: ident) => {{
+        #[naked]
+        extern "C" fn wrapper() -> ! {
+            unsafe {
+                save_scratch_registers!();
+                asm!("mov rsi, [rsp + 9*8] // load error code into rsi
+                      mov rdi, rsp
+                      add rdi, 10*8 // calculate exception stack frame pointer
+                      sub rsp, 8 // align the stack pointer
+                      call $0
+                      add rsp, 8 // undo stack pointer alignment
+                      " :: "i"($name as extern "C" fn(
+                          &ExceptionStackFrame, u64))
+                      : "rdi","rsi" : "intel");
+                restore_scratch_registers!();
+                asm!("add rsp, 8 // pop error code
+                      iretq" :::: "intel", "volatile");
+                ::core::intrinsics::unreachable();
+            }
+        }
+        wrapper
+    }}
+}
+
 lazy_static! {
     static ref IDT: idt::Idt = {
         let mut idt = idt::Idt::new();
 
-        idt.set_handler(0, divide_by_zero_handler);
+        idt.set_handler(0, handler!(divide_by_zero_handler));
+        idt.set_handler(3, handler!(breakpoint_handler));
+        idt.set_handler(6, handler!(invalid_opcode_handler));
+        idt.set_handler(14, handler_with_error_code!(page_fault_handler));
 
         idt
     };
@@ -23,7 +103,50 @@ pub fn init() {
     IDT.load();
 }
 
-extern "C" fn divide_by_zero_handler() -> ! {
-    println!("EXCEPTION: DIVIDE BY ZERO");
+#[derive(Debug)]
+#[repr(C)]
+struct ExceptionStackFrame {
+    instruction_pointer: u64,
+    code_segment: u64,
+    cpu_flags: u64,
+    stack_pointer: u64,
+    stack_segment: u64,
+}
+
+extern "C" fn divide_by_zero_handler(stack_frame: &ExceptionStackFrame) {
+    println!("\nEXCEPTION: DIVIDE BY ZERO\n{:#?}", stack_frame);
+    loop {}
+}
+
+extern "C" fn breakpoint_handler(stack_frame: &ExceptionStackFrame) {
+    println!("\nEXCEPTION: BREAKPOINT at {:#x}\n{:#?}",
+             stack_frame.instruction_pointer,
+             stack_frame);
+}
+
+extern "C" fn invalid_opcode_handler(stack_frame: &ExceptionStackFrame) {
+    println!("\nEXCEPTION: INVALID OPCODE at {:#x}\n{:#?}",
+             stack_frame.instruction_pointer,
+             stack_frame);
+    loop {}
+}
+
+bitflags! {
+    flags PageFaultErrorCode: u64 {
+        const PROTECTION_VIOLATION = 1 << 0,
+        const CAUSED_BY_WRITE = 1 << 1,
+        const USER_MODE = 1 << 2,
+        const MALFORMED_TABLE = 1 << 3,
+        const INSTRUCTION_FETCH = 1 << 4,
+    }
+}
+
+extern "C" fn page_fault_handler(stack_frame: &ExceptionStackFrame, error_code: u64) {
+    use x86::shared::control_regs;
+    println!("\nEXCEPTION: PAGE FAULT while accessing {:#x}\nerror code: \
+                                  {:?}\n{:#?}",
+             unsafe { control_regs::cr2() },
+             PageFaultErrorCode::from_bits(error_code).unwrap(),
+             stack_frame);
     loop {}
 }

src/lib.rs

@@ -11,6 +11,8 @@
 #![feature(const_fn, unique)]
 #![feature(alloc, collections)]
 #![feature(asm)]
+#![feature(naked_functions)]
+#![feature(core_intrinsics)]
 #![no_std]
 
 extern crate rlibc;
@@ -19,10 +21,13 @@ extern crate spin;
 extern crate multiboot2;
 #[macro_use]
 extern crate bitflags;
+#[macro_use]
 extern crate x86;
 #[macro_use]
 extern crate once;
 extern crate bit_field;
+#[macro_use]
+extern crate lazy_static;
 
 extern crate hole_list_allocator;
 extern crate alloc;
@@ -51,12 +56,8 @@ pub extern "C" fn rust_main(multiboot_information_address: usize) {
     // initialize our IDT
     interrupts::init();
 
-    fn divide_by_zero() {
-        unsafe { asm!("mov dx, 0; div dx" ::: "ax", "dx" : "volatile", "intel") }
-    }
-
-    // provoke a divide by zero fault inside println
-    println!("{:?}", divide_by_zero());
+    // trigger a breakpoint exception
+    unsafe { int!(3) };
 
     println!("It did not crash!");
     loop {}

src/memory/area_frame_allocator.rs

@@ -47,13 +47,12 @@ impl AreaFrameAllocator {
 
     fn choose_next_area(&mut self) {
         self.current_area = self.areas
-                                .clone()
-                                .filter(|area| {
-                                    let address = area.base_addr + area.length - 1;
-                                    Frame::containing_address(address as usize) >=
-                                    self.next_free_frame
-                                })
-                                .min_by_key(|area| area.base_addr);
+            .clone()
+            .filter(|area| {
+                let address = area.base_addr + area.length - 1;
+                Frame::containing_address(address as usize) >= self.next_free_frame
+            })
+            .min_by_key(|area| area.base_addr);
 
         if let Some(area) = self.current_area {
             let start_frame = Frame::containing_address(area.base_addr as usize);

src/memory/mod.rs

@@ -24,15 +24,15 @@ pub fn init(boot_info: &BootInformation) {
     let elf_sections_tag = boot_info.elf_sections_tag().expect("Elf sections tag required");
 
     let kernel_start = elf_sections_tag.sections()
-                                       .filter(|s| s.is_allocated())
-                                       .map(|s| s.addr)
-                                       .min()
-                                       .unwrap();
+        .filter(|s| s.is_allocated())
+        .map(|s| s.addr)
+        .min()
+        .unwrap();
     let kernel_end = elf_sections_tag.sections()
-                                     .filter(|s| s.is_allocated())
-                                     .map(|s| s.addr + s.size)
-                                     .max()
-                                     .unwrap();
+        .filter(|s| s.is_allocated())
+        .map(|s| s.addr + s.size)
+        .max()
+        .unwrap();
 
     println!("kernel start: {:#x}, kernel end: {:#x}",
              kernel_start,

src/memory/paging/mapper.rs

@@ -69,9 +69,9 @@ impl Mapper {
         };
 
         p3.and_then(|p3| p3.next_table(page.p3_index()))
-          .and_then(|p2| p2.next_table(page.p2_index()))
-          .and_then(|p1| p1[page.p1_index()].pointed_frame())
-          .or_else(huge_page)
+            .and_then(|p2| p2.next_table(page.p2_index()))
+            .and_then(|p1| p1[page.p1_index()].pointed_frame())
+            .or_else(huge_page)
     }
 
     pub fn map_to<A>(&mut self, page: Page, frame: Frame, flags: EntryFlags, allocator: &mut A)
@@ -105,10 +105,10 @@ impl Mapper {
         assert!(self.translate(page.start_address()).is_some());
 
         let p1 = self.p4_mut()
-                     .next_table_mut(page.p4_index())
-                     .and_then(|p3| p3.next_table_mut(page.p3_index()))
-                     .and_then(|p2| p2.next_table_mut(page.p2_index()))
-                     .expect("mapping code does not support huge pages");
+            .next_table_mut(page.p4_index())
+            .and_then(|p3| p3.next_table_mut(page.p3_index()))
+            .and_then(|p2| p2.next_table_mut(page.p2_index()))
+            .expect("mapping code does not support huge pages");
         let frame = p1[page.p1_index()].pointed_frame().unwrap();
         p1[page.p1_index()].set_unused();
         unsafe { ::x86::shared::tlb::flush(page.start_address()) };

src/memory/paging/mod.rs

@@ -180,7 +180,7 @@ pub fn remap_the_kernel<A>(allocator: &mut A, boot_info: &BootInformation) -> Ac
 
     active_table.with(&mut new_table, &mut temporary_page, |mapper| {
         let elf_sections_tag = boot_info.elf_sections_tag()
-                                        .expect("Memory map tag required");
+            .expect("Memory map tag required");
 
         // identity map the allocated kernel sections
         for section in elf_sections_tag.sections() {

x86_64-blog_os.json

@@ -0,0 +1,10 @@
+{
+  "llvm-target": "x86_64-unknown-linux-gnu",
+  "data-layout": "e-m:e-i64:64-f80:128-n8:16:32:64-S128",
+  "target-endian": "little",
+  "target-pointer-width": "64",
+  "arch": "x86_64",
+  "os": "none",
+  "features": "-mmx,-sse,+soft-float",
+  "disable-redzone": true
+}