Set the stack index of the double fault IDT entry

Cargo.toml

@@ -7,6 +7,16 @@ authors = ["Philipp Oppermann <dev@phil-opp.com>"]
 crate-type = ["staticlib"]
 
 [dependencies]
+bit_field = "0.7.0"
 rlibc = "1.0"
 volatile = "0.1.0"
 spin = "0.4.5"
+multiboot2 = "0.1.0"
+bitflags = "0.7.0"
+x86_64 = "0.1.2"
+once = "0.3.3"
+linked_list_allocator = "0.4.2"
+
+[dependencies.lazy_static]
+version = "0.2.4"
+features = ["spin_no_std"]

README.md

@@ -1,12 +1,14 @@
-# Blog OS (Printing To Screen)
-[![Build Status](https://travis-ci.org/phil-opp/blog_os.svg?branch=post_4)](https://travis-ci.org/phil-opp/blog_os/branches)
+# Blog OS (Double Faults)
+[![Build Status](https://travis-ci.org/phil-opp/blog_os.svg?branch=post_10)](https://travis-ci.org/phil-opp/blog_os/branches)
 
-This repository contains the source code for the [Printing To Screen](http://os.phil-opp.com/printing-to-screen.html) post of the [Writing an OS in Rust](http://os.phil-opp.com) series.
+This repository contains the source code for the [Double Faults](http://os.phil-opp.com/double-faults.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]
+alloc = {}

src/arch/x86_64/boot.asm

@@ -5,6 +5,7 @@ section .text
 bits 32
 start:
     mov esp, stack_top
+    mov edi, ebx       ; move Multiboot info pointer to edi
 
     call check_multiboot
     call check_cpuid
@@ -84,6 +85,11 @@ check_long_mode:
     jmp error
 
 set_up_page_tables:
+    ; map P4 table recursively
+    mov eax, p4_table
+    or eax, 0b11 ; present + writable
+    mov [p4_table + 511 * 8], eax
+
     ; map first P4 entry to P3 table
     mov eax, p3_table
     or eax, 0b11 ; present + writable
@@ -151,7 +157,7 @@ p3_table:
 p2_table:
     resb 4096
 stack_bottom:
-    resb 64
+    resb 4096 * 4
 stack_top:
 
 section .rodata

src/arch/x86_64/linker.ld

@@ -1,16 +1,53 @@
 ENTRY(start)
 
 SECTIONS {
-    . = 1M;
+  . = 1M;
 
-    .boot :
-    {
-        /* ensure that the multiboot header is at the beginning */
-        KEEP(*(.multiboot_header))
-    }
+  .rodata :
+  {
+    /* ensure that the multiboot header is at the beginning */
+    KEEP(*(.multiboot_header))
+    *(.rodata .rodata.*)
+    . = ALIGN(4K);
+  }
 
-    .text :
-    {
-        *(.text)
-    }
+  .text :
+  {
+    *(.text .text.*)
+    . = ALIGN(4K);
+  }
+
+  .data :
+  {
+    *(.data .data.*)
+    . = ALIGN(4K);
+  }
+
+  .bss :
+  {
+    *(.bss .bss.*)
+    . = ALIGN(4K);
+  }
+
+  .got :
+  {
+    *(.got)
+    . = ALIGN(4K);
+  }
+
+  .got.plt :
+  {
+    *(.got.plt)
+    . = ALIGN(4K);
+  }
+
+  .data.rel.ro : ALIGN(4K) {
+    *(.data.rel.ro.local*) *(.data.rel.ro .data.rel.ro.*)
+    . = ALIGN(4K);
+  }
+
+  .gcc_except_table : ALIGN(4K) {
+    *(.gcc_except_table)
+    . = ALIGN(4K);
+  }
 }

src/interrupts/gdt.rs

@@ -0,0 +1,95 @@
+use x86_64::structures::tss::TaskStateSegment;
+use x86_64::structures::gdt::SegmentSelector;
+use x86_64::PrivilegeLevel;
+
+pub struct Gdt {
+    table: [u64; 8],
+    next_free: usize,
+}
+
+impl Gdt {
+    pub fn new() -> Gdt {
+        Gdt {
+            table: [0; 8],
+            next_free: 1,
+        }
+    }
+
+    pub fn add_entry(&mut self, entry: Descriptor) -> SegmentSelector {
+        let index = match entry {
+            Descriptor::UserSegment(value) => self.push(value),
+            Descriptor::SystemSegment(value_low, value_high) => {
+                let index = self.push(value_low);
+                self.push(value_high);
+                index
+            }
+        };
+        SegmentSelector::new(index as u16, PrivilegeLevel::Ring0)
+    }
+
+    pub fn load(&'static self) {
+        use x86_64::instructions::tables::{DescriptorTablePointer, lgdt};
+        use core::mem::size_of;
+
+        let ptr = DescriptorTablePointer {
+            base: self.table.as_ptr() as u64,
+            limit: (self.table.len() * size_of::<u64>() - 1) as u16,
+        };
+
+        unsafe { lgdt(&ptr) };
+    }
+
+    fn push(&mut self, value: u64) -> usize {
+        if self.next_free < self.table.len() {
+            let index = self.next_free;
+            self.table[index] = value;
+            self.next_free += 1;
+            index
+        } else {
+            panic!("GDT full");
+        }
+    }
+}
+
+pub enum Descriptor {
+    UserSegment(u64),
+    SystemSegment(u64, u64),
+}
+
+impl Descriptor {
+    pub fn kernel_code_segment() -> Descriptor {
+        let flags = USER_SEGMENT | PRESENT | EXECUTABLE | LONG_MODE;
+        Descriptor::UserSegment(flags.bits())
+    }
+
+    pub fn tss_segment(tss: &'static TaskStateSegment) -> Descriptor {
+        use core::mem::size_of;
+        use bit_field::BitField;
+
+        let ptr = tss as *const _ as u64;
+
+        let mut low = PRESENT.bits();
+        // base
+        low.set_bits(16..40, ptr.get_bits(0..24));
+        low.set_bits(56..64, ptr.get_bits(24..32));
+        // limit (the `-1` in needed since the bound is inclusive)
+        low.set_bits(0..16, (size_of::<TaskStateSegment>() - 1) as u64);
+        // type (0b1001 = available 64-bit tss)
+        low.set_bits(40..44, 0b1001);
+
+        let mut high = 0;
+        high.set_bits(0..32, ptr.get_bits(32..64));
+
+        Descriptor::SystemSegment(low, high)
+    }
+}
+
+bitflags! {
+    flags DescriptorFlags: u64 {
+        const CONFORMING        = 1 << 42,
+        const EXECUTABLE        = 1 << 43,
+        const USER_SEGMENT      = 1 << 44,
+        const PRESENT           = 1 << 47,
+        const LONG_MODE         = 1 << 53,
+    }
+}

src/interrupts/mod.rs

@@ -0,0 +1,72 @@
+use x86_64::VirtualAddress;
+use x86_64::structures::idt::{Idt, ExceptionStackFrame};
+use x86_64::structures::tss::TaskStateSegment;
+use memory::MemoryController;
+use spin::Once;
+
+mod gdt;
+
+lazy_static! {
+    static ref IDT: Idt = {
+        let mut idt = Idt::new();
+        idt.breakpoint.set_handler_fn(breakpoint_handler);
+        unsafe {
+            idt.double_fault.set_handler_fn(double_fault_handler)
+                .set_stack_index(DOUBLE_FAULT_IST_INDEX as u16);
+        }
+        idt
+    };
+}
+
+static TSS: Once<TaskStateSegment> = Once::new();
+static GDT: Once<gdt::Gdt> = Once::new();
+
+const DOUBLE_FAULT_IST_INDEX: usize = 0;
+
+pub fn init(memory_controller: &mut MemoryController) {
+    use x86_64::structures::gdt::SegmentSelector;
+    use x86_64::instructions::segmentation::set_cs;
+    use x86_64::instructions::tables::load_tss;
+
+    let double_fault_stack = memory_controller.alloc_stack(1)
+        .expect("could not allocate double fault stack");
+
+    let tss = TSS.call_once(|| {
+        let mut tss = TaskStateSegment::new();
+        tss.interrupt_stack_table[DOUBLE_FAULT_IST_INDEX] = VirtualAddress(
+            double_fault_stack.top());
+        tss
+    });
+
+    let mut code_selector = SegmentSelector(0);
+    let mut tss_selector = SegmentSelector(0);
+    let gdt = GDT.call_once(|| {
+        let mut gdt = gdt::Gdt::new();
+        code_selector = gdt.add_entry(gdt::Descriptor::kernel_code_segment());
+        tss_selector = gdt.add_entry(gdt::Descriptor::tss_segment(&tss));
+        gdt
+    });
+    gdt.load();
+
+     unsafe {
+        // reload code segment register
+        set_cs(code_selector);
+        // load TSS
+        load_tss(tss_selector);
+    }
+
+    IDT.load();
+}
+
+extern "x86-interrupt" fn breakpoint_handler(
+    stack_frame: &mut ExceptionStackFrame)
+{
+    println!("EXCEPTION: BREAKPOINT\n{:#?}", stack_frame);
+}
+
+extern "x86-interrupt" fn double_fault_handler(
+    stack_frame: &mut ExceptionStackFrame, _error_code: u64)
+{
+    println!("\nEXCEPTION: DOUBLE FAULT\n{:#?}", stack_frame);
+    loop {}
+}

src/lib.rs

@@ -1,25 +1,106 @@
 #![feature(lang_items)]
 #![feature(const_fn)]
-#![feature(const_unique_new)]
+#![feature(alloc)]
+#![feature(const_unique_new, const_atomic_usize_new)]
 #![feature(unique)]
+#![feature(allocator_api)]
+#![feature(global_allocator)]
+#![feature(abi_x86_interrupt)]
 #![no_std]
 
+
+#[macro_use]
+extern crate alloc;
+
 extern crate rlibc;
 extern crate volatile;
 extern crate spin;
-
+extern crate multiboot2;
+#[macro_use]
+extern crate bitflags;
+extern crate x86_64;
+#[macro_use]
+extern crate once;
+extern crate linked_list_allocator;
+#[macro_use]
+extern crate lazy_static;
+extern crate bit_field;
 #[macro_use]
 mod vga_buffer;
+mod memory;
+mod interrupts;
 
 #[no_mangle]
-pub extern fn rust_main() {
+pub extern "C" fn rust_main(multiboot_information_address: usize) {
     // ATTENTION: we have a very small stack and no guard page
-
     vga_buffer::clear_screen();
     println!("Hello World{}", "!");
 
-    loop{}
+    let boot_info = unsafe {
+        multiboot2::load(multiboot_information_address)
+    };
+    enable_nxe_bit();
+    enable_write_protect_bit();
+
+    // set up guard page and map the heap pages
+    let mut memory_controller = memory::init(boot_info);
+
+    unsafe {
+        HEAP_ALLOCATOR.lock().init(HEAP_START, HEAP_START + HEAP_SIZE);
+    }
+
+    // initialize our IDT
+    interrupts::init(&mut memory_controller);
+
+    for i in 0..10000 {
+        format!("Some String");
+    }
+
+    // invoke a breakpoint exception
+    x86_64::instructions::interrupts::int3();
+
+    fn stack_overflow() {
+        stack_overflow(); // for each recursion, the return address is pushed
+    }
+
+    // trigger a stack overflow
+    stack_overflow();
+
+
+    println!("It did not crash!");
+    loop {}
+}
+
+fn enable_nxe_bit() {
+    use x86_64::registers::msr::{IA32_EFER, rdmsr, wrmsr};
+
+    let nxe_bit = 1 << 11;
+    unsafe {
+        let efer = rdmsr(IA32_EFER);
+        wrmsr(IA32_EFER, efer | nxe_bit);
+    }
+}
+
+fn enable_write_protect_bit() {
+    use x86_64::registers::control_regs::{cr0, cr0_write, Cr0};
+
+    unsafe { cr0_write(cr0() | Cr0::WRITE_PROTECT) };
 }
 
 #[lang = "eh_personality"] extern fn eh_personality() {}
-#[lang = "panic_fmt"] #[no_mangle] pub extern fn panic_fmt() -> ! {loop{}}
+
+#[lang = "panic_fmt"]
+#[no_mangle]
+pub extern fn panic_fmt(fmt: core::fmt::Arguments, file: &'static str, line: u32) -> ! {
+    println!("\n\nPANIC in {} at line {}:", file, line);
+    println!("    {}", fmt);
+    loop{}
+}
+
+use linked_list_allocator::LockedHeap;
+
+pub const HEAP_START: usize = 0o_000_001_000_000_0000;
+pub const HEAP_SIZE: usize = 100 * 1024; // 100 KiB
+
+#[global_allocator]
+static HEAP_ALLOCATOR: LockedHeap = LockedHeap::empty();

src/memory/area_frame_allocator.rs

@@ -0,0 +1,88 @@
+use memory::{Frame, FrameAllocator};
+use multiboot2::{MemoryAreaIter, MemoryArea};
+
+pub struct AreaFrameAllocator {
+    next_free_frame: Frame,
+    current_area: Option<&'static MemoryArea>,
+    areas: MemoryAreaIter,
+    kernel_start: Frame,
+    kernel_end: Frame,
+    multiboot_start: Frame,
+    multiboot_end: Frame,
+}
+
+impl FrameAllocator for AreaFrameAllocator {
+    fn allocate_frame(&mut self) -> Option<Frame> {
+        if let Some(area) = self.current_area {
+            // "Clone" the frame to return it if it's free. Frame doesn't
+            // implement Clone, but we can construct an identical frame.
+            let frame = Frame{ number: self.next_free_frame.number };
+
+            // the last frame of the current area
+            let current_area_last_frame = {
+                let address = area.base_addr + area.length - 1;
+                Frame::containing_address(address as usize)
+            };
+
+            if frame > current_area_last_frame {
+                // all frames of current area are used, switch to next area
+                self.choose_next_area();
+            } else if frame >= self.kernel_start && frame <= self.kernel_end {
+                // `frame` is used by the kernel
+                self.next_free_frame = Frame {
+                    number: self.kernel_end.number + 1
+                };
+            } else if frame >= self.multiboot_start && frame <= self.multiboot_end {
+                // `frame` is used by the multiboot information structure
+                self.next_free_frame = Frame {
+                    number: self.multiboot_end.number + 1
+                };
+            } else {
+                // frame is unused, increment `next_free_frame` and return it
+                self.next_free_frame.number += 1;
+                return Some(frame);
+            }
+            // `frame` was not valid, try it again with the updated `next_free_frame`
+            self.allocate_frame()
+        } else {
+            None // no free frames left
+        }
+    }
+
+    fn deallocate_frame(&mut self, _frame: Frame) {
+        unimplemented!()
+    }
+}
+
+impl AreaFrameAllocator {
+    pub fn new(kernel_start: usize, kernel_end: usize,
+        multiboot_start: usize, multiboot_end: usize,
+        memory_areas: MemoryAreaIter) -> AreaFrameAllocator
+    {
+        let mut allocator = AreaFrameAllocator {
+            next_free_frame: Frame::containing_address(0),
+            current_area: None,
+            areas: memory_areas,
+            kernel_start: Frame::containing_address(kernel_start),
+            kernel_end: Frame::containing_address(kernel_end),
+            multiboot_start: Frame::containing_address(multiboot_start),
+            multiboot_end: Frame::containing_address(multiboot_end),
+        };
+        allocator.choose_next_area();
+        allocator
+    }
+
+    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);
+
+        if let Some(area) = self.current_area {
+            let start_frame = Frame::containing_address(area.base_addr as usize);
+            if self.next_free_frame < start_frame {
+                self.next_free_frame = start_frame;
+            }
+        }
+    }
+}

src/memory/heap_allocator.rs

@@ -0,0 +1,62 @@
+use alloc::heap::{Alloc, AllocErr, Layout};
+
+use core::sync::atomic::{AtomicUsize, Ordering};
+
+/// A simple allocator that allocates memory linearly and ignores freed memory.
+#[derive(Debug)]
+pub struct BumpAllocator {
+    heap_start: usize,
+    heap_end: usize,
+    next: AtomicUsize,
+}
+
+impl BumpAllocator {
+    pub const fn new(heap_start: usize, heap_end: usize) -> Self {
+        Self { heap_start, heap_end, next: AtomicUsize::new(heap_start) }
+    }
+}
+
+unsafe impl<'a> Alloc for &'a BumpAllocator {
+    unsafe fn alloc(&mut self, layout: Layout) -> Result<*mut u8, AllocErr> {
+        loop {
+            // load current state of the `next` field
+            let current_next = self.next.load(Ordering::Relaxed);
+            let alloc_start = align_up(current_next, layout.align());
+            let alloc_end = alloc_start.saturating_add(layout.size());
+
+            if alloc_end <= self.heap_end {
+                // update the `next` pointer if it still has the value `current_next`
+                let next_now = self.next.compare_and_swap(current_next, alloc_end,
+                    Ordering::Relaxed);
+                if next_now == current_next {
+                    // next address was successfully updated, allocation succeeded
+                    return Ok(alloc_start as *mut u8);
+                }
+            } else {
+                return Err(AllocErr::Exhausted{ request: layout })
+            }
+        }
+    }
+
+    unsafe fn dealloc(&mut self, ptr: *mut u8, layout: Layout) {
+        // do nothing, leak memory
+    }
+}
+
+/// Align downwards. Returns the greatest x with alignment `align`
+/// so that x <= addr. The alignment must be a power of 2.
+pub fn align_down(addr: usize, align: usize) -> usize {
+    if align.is_power_of_two() {
+        addr & !(align - 1)
+    } else if align == 0 {
+        addr
+    } else {
+        panic!("`align` must be a power of 2");
+    }
+}
+
+/// Align upwards. Returns the smallest x with alignment `align`
+/// so that x >= addr. The alignment must be a power of 2.
+pub fn align_up(addr: usize, align: usize) -> usize {
+    align_down(addr + align - 1, align)
+}

src/memory/mod.rs

@@ -0,0 +1,132 @@
+pub use self::area_frame_allocator::AreaFrameAllocator;
+pub use self::paging::remap_the_kernel;
+pub use self::stack_allocator::Stack;
+use self::paging::PhysicalAddress;
+use multiboot2::BootInformation;
+
+mod area_frame_allocator;
+pub mod heap_allocator;
+mod paging;
+mod stack_allocator;
+
+pub const PAGE_SIZE: usize = 4096;
+
+pub fn init(boot_info: &BootInformation) -> MemoryController {
+    assert_has_not_been_called!("memory::init must be called only once");
+
+    let memory_map_tag = boot_info.memory_map_tag().expect(
+        "Memory map tag required");
+    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();
+    let kernel_end = elf_sections_tag.sections()
+        .filter(|s| s.is_allocated()).map(|s| s.addr + s.size).max()
+        .unwrap();
+
+    println!("kernel start: {:#x}, kernel end: {:#x}",
+             kernel_start,
+             kernel_end);
+    println!("multiboot start: {:#x}, multiboot end: {:#x}",
+             boot_info.start_address(),
+             boot_info.end_address());
+
+    let mut frame_allocator = AreaFrameAllocator::new(
+        kernel_start as usize, kernel_end as usize,
+        boot_info.start_address(), boot_info.end_address(),
+        memory_map_tag.memory_areas());
+
+    let mut active_table = paging::remap_the_kernel(&mut frame_allocator,
+        boot_info);
+
+    use self::paging::Page;
+    use {HEAP_START, HEAP_SIZE};
+
+    let heap_start_page = Page::containing_address(HEAP_START);
+    let heap_end_page = Page::containing_address(HEAP_START + HEAP_SIZE-1);
+
+    for page in Page::range_inclusive(heap_start_page, heap_end_page) {
+        active_table.map(page, paging::WRITABLE, &mut frame_allocator);
+    }
+
+    let stack_allocator = {
+        let stack_alloc_start = heap_end_page + 1;
+        let stack_alloc_end = stack_alloc_start + 100;
+        let stack_alloc_range = Page::range_inclusive(stack_alloc_start,
+                                                      stack_alloc_end);
+        stack_allocator::StackAllocator::new(stack_alloc_range)
+    };
+
+    MemoryController {
+        active_table: active_table,
+        frame_allocator: frame_allocator,
+        stack_allocator: stack_allocator,
+    }
+}
+
+#[derive(Debug, PartialEq, Eq, PartialOrd, Ord)]
+pub struct Frame {
+    number: usize,
+}
+
+impl Frame {
+    fn containing_address(address: usize) -> Frame {
+        Frame{ number: address / PAGE_SIZE }
+    }
+
+    fn start_address(&self) -> PhysicalAddress {
+        self.number * PAGE_SIZE
+    }
+
+    fn clone(&self) -> Frame {
+        Frame { number: self.number }
+    }
+
+    fn range_inclusive(start: Frame, end: Frame) -> FrameIter {
+        FrameIter {
+            start: start,
+            end: end,
+        }
+    }
+}
+
+struct FrameIter {
+    start: Frame,
+    end: Frame,
+}
+
+impl Iterator for FrameIter {
+    type Item = Frame;
+
+    fn next(&mut self) -> Option<Frame> {
+        if self.start <= self.end {
+            let frame = self.start.clone();
+            self.start.number += 1;
+            Some(frame)
+        } else {
+            None
+        }
+    }
+ }
+
+pub trait FrameAllocator {
+    fn allocate_frame(&mut self) -> Option<Frame>;
+    fn deallocate_frame(&mut self, frame: Frame);
+}
+
+pub struct MemoryController {
+    active_table: paging::ActivePageTable,
+    frame_allocator: AreaFrameAllocator,
+    stack_allocator: stack_allocator::StackAllocator,
+}
+
+impl MemoryController {
+    pub fn alloc_stack(&mut self, size_in_pages: usize) -> Option<Stack> {
+        let &mut MemoryController { ref mut active_table,
+                                    ref mut frame_allocator,
+                                    ref mut stack_allocator } = self;
+        stack_allocator.alloc_stack(active_table, frame_allocator,
+                                    size_in_pages)
+    }
+}

src/memory/paging/entry.rs

@@ -0,0 +1,71 @@
+use memory::Frame;
+use multiboot2::ElfSection;
+
+pub struct Entry(u64);
+
+impl Entry {
+    pub fn is_unused(&self) -> bool {
+        self.0 == 0
+    }
+
+    pub fn set_unused(&mut self) {
+        self.0 = 0;
+    }
+
+    pub fn flags(&self) -> EntryFlags {
+        EntryFlags::from_bits_truncate(self.0)
+    }
+
+    pub fn pointed_frame(&self) -> Option<Frame> {
+        if self.flags().contains(PRESENT) {
+            Some(Frame::containing_address(
+                self.0 as usize & 0x000fffff_fffff000
+            ))
+        } else {
+            None
+        }
+    }
+
+    pub fn set(&mut self, frame: Frame, flags: EntryFlags) {
+        assert!(frame.start_address() & !0x000fffff_fffff000 == 0);
+        self.0 = (frame.start_address() as u64) | flags.bits();
+    }
+}
+
+bitflags! {
+    pub flags EntryFlags: u64 {
+        const PRESENT =         1 << 0,
+        const WRITABLE =        1 << 1,
+        const USER_ACCESSIBLE = 1 << 2,
+        const WRITE_THROUGH =   1 << 3,
+        const NO_CACHE =        1 << 4,
+        const ACCESSED =        1 << 5,
+        const DIRTY =           1 << 6,
+        const HUGE_PAGE =       1 << 7,
+        const GLOBAL =          1 << 8,
+        const NO_EXECUTE =      1 << 63,
+    }
+}
+
+
+impl EntryFlags {
+    pub fn from_elf_section_flags(section: &ElfSection) -> EntryFlags {
+        use multiboot2::{ELF_SECTION_ALLOCATED, ELF_SECTION_WRITABLE,
+            ELF_SECTION_EXECUTABLE};
+
+        let mut flags = EntryFlags::empty();
+
+        if section.flags().contains(ELF_SECTION_ALLOCATED) {
+            // section is loaded to memory
+            flags = flags | PRESENT;
+        }
+        if section.flags().contains(ELF_SECTION_WRITABLE) {
+            flags = flags | WRITABLE;
+        }
+        if !section.flags().contains(ELF_SECTION_EXECUTABLE) {
+            flags = flags | NO_EXECUTE;
+        }
+
+        flags
+    }
+}

src/memory/paging/mapper.rs

@@ -0,0 +1,118 @@
+use super::{VirtualAddress, PhysicalAddress, Page, ENTRY_COUNT};
+use super::entry::*;
+use super::table::{self, Table, Level4, Level1};
+use memory::{PAGE_SIZE, Frame, FrameAllocator};
+use core::ptr::Unique;
+
+pub struct Mapper {
+    p4: Unique<Table<Level4>>,
+}
+
+impl Mapper {
+    pub unsafe fn new() -> Mapper {
+        Mapper {
+            p4: Unique::new_unchecked(table::P4),
+        }
+    }
+
+    pub fn p4(&self) -> &Table<Level4> {
+        unsafe { self.p4.as_ref() }
+    }
+
+    pub fn p4_mut(&mut self) -> &mut Table<Level4> {
+        unsafe { self.p4.as_mut() }
+    }
+
+    pub fn translate(&self, virtual_address: VirtualAddress) -> Option<PhysicalAddress> {
+        let offset = virtual_address % PAGE_SIZE;
+        self.translate_page(Page::containing_address(virtual_address))
+            .map(|frame| frame.number * PAGE_SIZE + offset)
+    }
+
+    pub fn translate_page(&self, page: Page) -> Option<Frame> {
+        let p3 = self.p4().next_table(page.p4_index());
+
+        let huge_page = || {
+            p3.and_then(|p3| {
+                let p3_entry = &p3[page.p3_index()];
+                // 1GiB page?
+                if let Some(start_frame) = p3_entry.pointed_frame() {
+                    if p3_entry.flags().contains(HUGE_PAGE) {
+                        // address must be 1GiB aligned
+                        assert!(start_frame.number % (ENTRY_COUNT * ENTRY_COUNT) == 0);
+                        return Some(Frame {
+                            number: start_frame.number + page.p2_index() *
+                                    ENTRY_COUNT + page.p1_index(),
+                        });
+                    }
+                }
+                if let Some(p2) = p3.next_table(page.p3_index()) {
+                    let p2_entry = &p2[page.p2_index()];
+                    // 2MiB page?
+                    if let Some(start_frame) = p2_entry.pointed_frame() {
+                        if p2_entry.flags().contains(HUGE_PAGE) {
+                            // address must be 2MiB aligned
+                            assert!(start_frame.number % ENTRY_COUNT == 0);
+                            return Some(Frame {
+                                number: start_frame.number + page.p1_index()
+                            });
+                        }
+                    }
+                }
+                None
+            })
+        };
+
+        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)
+    }
+
+    pub fn map_to<A>(&mut self, page: Page, frame: Frame, flags: EntryFlags,
+                    allocator: &mut A)
+        where A: FrameAllocator
+    {
+        let p4 = self.p4_mut();
+        let mut p3 = p4.next_table_create(page.p4_index(), allocator);
+        let mut p2 = p3.next_table_create(page.p3_index(), allocator);
+        let mut p1 = p2.next_table_create(page.p2_index(), allocator);
+
+        assert!(p1[page.p1_index()].is_unused());
+        p1[page.p1_index()].set(frame, flags | PRESENT);
+    }
+
+    pub fn map<A>(&mut self, page: Page, flags: EntryFlags, allocator: &mut A)
+        where A: FrameAllocator
+    {
+        let frame = allocator.allocate_frame().expect("out of memory");
+        self.map_to(page, frame, flags, allocator)
+    }
+
+    pub fn identity_map<A>(&mut self, frame: Frame, flags: EntryFlags, allocator: &mut A)
+        where A: FrameAllocator
+    {
+        let page = Page::containing_address(frame.start_address());
+        self.map_to(page, frame, flags, allocator)
+    }
+
+    pub fn unmap<A>(&mut self, page: Page, allocator: &mut A)
+        where A: FrameAllocator
+    {
+        use x86_64::instructions::tlb;
+        use x86_64::VirtualAddress;
+
+        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");
+        let frame = p1[page.p1_index()].pointed_frame().unwrap();
+        p1[page.p1_index()].set_unused();
+        tlb::flush(VirtualAddress(page.start_address()));
+        // TODO free p(1,2,3) table if empty
+        //allocator.deallocate_frame(frame);
+    }
+}

src/memory/paging/mod.rs

@@ -0,0 +1,245 @@
+pub use self::entry::*;
+pub use self::mapper::Mapper;
+use core::ops::{Deref, DerefMut, Add};
+use core::ptr::Unique;
+use memory::{PAGE_SIZE, Frame, FrameAllocator};
+use multiboot2::BootInformation;
+use self::table::{Table, Level4};
+use self::temporary_page::TemporaryPage;
+
+mod entry;
+mod table;
+mod temporary_page;
+mod mapper;
+
+const ENTRY_COUNT: usize = 512;
+
+pub type PhysicalAddress = usize;
+pub type VirtualAddress = usize;
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
+pub struct Page {
+   number: usize,
+}
+
+impl Page {
+    pub fn containing_address(address: VirtualAddress) -> Page {
+        assert!(address < 0x0000_8000_0000_0000 ||
+            address >= 0xffff_8000_0000_0000,
+            "invalid address: 0x{:x}", address);
+        Page { number: address / PAGE_SIZE }
+    }
+
+    pub fn start_address(&self) -> usize {
+        self.number * PAGE_SIZE
+    }
+
+    fn p4_index(&self) -> usize {
+        (self.number >> 27) & 0o777
+    }
+    fn p3_index(&self) -> usize {
+        (self.number >> 18) & 0o777
+    }
+    fn p2_index(&self) -> usize {
+        (self.number >> 9) & 0o777
+    }
+    fn p1_index(&self) -> usize {
+        (self.number >> 0) & 0o777
+    }
+
+    pub fn range_inclusive(start: Page, end: Page) -> PageIter {
+        PageIter {
+            start: start,
+            end: end,
+        }
+    }
+}
+
+impl Add<usize> for Page {
+    type Output = Page;
+
+    fn add(self, rhs: usize) -> Page {
+        Page { number: self.number + rhs }
+    }
+}
+
+
+#[derive(Clone)]
+pub struct PageIter {
+    start: Page,
+    end: Page,
+}
+
+impl Iterator for PageIter {
+    type Item = Page;
+
+    fn next(&mut self) -> Option<Page> {
+        if self.start <= self.end {
+            let page = self.start;
+            self.start.number += 1;
+            Some(page)
+        } else {
+            None
+        }
+    }
+}
+
+pub struct ActivePageTable {
+    mapper: Mapper,
+}
+
+impl Deref for ActivePageTable {
+    type Target = Mapper;
+
+    fn deref(&self) -> &Mapper {
+        &self.mapper
+    }
+}
+
+impl DerefMut for ActivePageTable {
+    fn deref_mut(&mut self) -> &mut Mapper {
+        &mut self.mapper
+    }
+}
+
+impl ActivePageTable {
+    unsafe fn new() -> ActivePageTable {
+        ActivePageTable {
+            mapper: Mapper::new(),
+        }
+    }
+
+    pub fn with<F>(&mut self,
+                   table: &mut InactivePageTable,
+                   temporary_page: &mut temporary_page::TemporaryPage, // new
+                   f: F)
+        where F: FnOnce(&mut Mapper)
+    {
+        use x86_64::instructions::tlb;
+        use x86_64::registers::control_regs;
+
+        {
+            let backup = Frame::containing_address(
+                control_regs::cr3().0 as usize);
+
+            // map temporary_page to current p4 table
+            let p4_table = temporary_page.map_table_frame(backup.clone(), self);
+
+            // overwrite recursive mapping
+            self.p4_mut()[511].set(table.p4_frame.clone(), PRESENT | WRITABLE);
+            tlb::flush_all();
+
+            // execute f in the new context
+            f(self);
+
+            // restore recursive mapping to original p4 table
+            p4_table[511].set(backup, PRESENT | WRITABLE);
+            tlb::flush_all();
+        }
+
+        temporary_page.unmap(self);
+    }
+
+    pub fn switch(&mut self, new_table: InactivePageTable) -> InactivePageTable {
+        use x86_64::PhysicalAddress;
+        use x86_64::registers::control_regs;
+
+        let old_table = InactivePageTable {
+            p4_frame: Frame::containing_address(
+                control_regs::cr3().0 as usize
+            ),
+        };
+        unsafe {
+            control_regs::cr3_write(PhysicalAddress(
+                new_table.p4_frame.start_address() as u64));
+        }
+        old_table
+    }
+}
+
+pub struct InactivePageTable {
+    p4_frame: Frame,
+}
+
+impl InactivePageTable {
+    pub fn new(frame: Frame,
+               active_table: &mut ActivePageTable,
+               temporary_page: &mut TemporaryPage)
+               -> InactivePageTable {
+        {
+            let table = temporary_page.map_table_frame(frame.clone(),
+                active_table);
+            // now we are able to zero the table
+            table.zero();
+            // set up recursive mapping for the table
+            table[511].set(frame.clone(), PRESENT | WRITABLE);
+        }
+        temporary_page.unmap(active_table);
+
+        InactivePageTable { p4_frame: frame }
+    }
+}
+
+pub fn remap_the_kernel<A>(allocator: &mut A, boot_info: &BootInformation)
+    -> ActivePageTable
+    where A: FrameAllocator
+{
+    let mut temporary_page = TemporaryPage::new(Page { number: 0xcafebabe },
+        allocator);
+
+    let mut active_table = unsafe { ActivePageTable::new() };
+    let mut new_table = {
+        let frame = allocator.allocate_frame().expect("no more frames");
+        InactivePageTable::new(frame, &mut active_table, &mut temporary_page)
+    };
+
+    active_table.with(&mut new_table, &mut temporary_page, |mapper| {
+        let elf_sections_tag = boot_info.elf_sections_tag()
+            .expect("Memory map tag required");
+
+        for section in elf_sections_tag.sections() {
+            use self::entry::WRITABLE;
+
+            if !section.is_allocated() {
+                // section is not loaded to memory
+                continue;
+            }
+            assert!(section.start_address() % PAGE_SIZE == 0,
+                    "sections need to be page aligned");
+
+            println!("mapping section at addr: {:#x}, size: {:#x}",
+                section.addr, section.size);
+
+            let flags = EntryFlags::from_elf_section_flags(section);
+
+            let start_frame = Frame::containing_address(section.start_address());
+            let end_frame = Frame::containing_address(section.end_address() - 1);
+            for frame in Frame::range_inclusive(start_frame, end_frame) {
+                mapper.identity_map(frame, flags, allocator);
+            }
+        }
+
+        // identity map the VGA text buffer
+        let vga_buffer_frame = Frame::containing_address(0xb8000);
+        mapper.identity_map(vga_buffer_frame, WRITABLE, allocator);
+
+        // identity map the multiboot info structure
+        let multiboot_start = Frame::containing_address(boot_info.start_address());
+        let multiboot_end = Frame::containing_address(boot_info.end_address() - 1);
+        for frame in Frame::range_inclusive(multiboot_start, multiboot_end) {
+            mapper.identity_map(frame, PRESENT, allocator);
+        }
+    });
+
+    let old_table = active_table.switch(new_table);
+    println!("NEW TABLE!!!");
+
+    // turn the old p4 page into a guard page
+    let old_p4_page = Page::containing_address(
+      old_table.p4_frame.start_address()
+    );
+    active_table.unmap(old_p4_page, allocator);
+    println!("guard page at {:#x}", old_p4_page.start_address());
+
+    active_table
+}

src/memory/paging/table.rs

@@ -0,0 +1,100 @@
+use core::marker::PhantomData;
+use core::ops::{Index, IndexMut};
+use memory::FrameAllocator;
+use memory::paging::entry::*;
+use memory::paging::ENTRY_COUNT;
+
+pub const P4: *mut Table<Level4> = 0xffffffff_fffff000 as *mut _;
+
+pub struct Table<L: TableLevel> {
+    entries: [Entry; ENTRY_COUNT],
+    level: PhantomData<L>,
+}
+
+impl<L> Table<L> where L: TableLevel {
+    pub fn zero(&mut self) {
+        for entry in self.entries.iter_mut() {
+            entry.set_unused();
+        }
+    }
+}
+
+impl<L> Table<L> where L: HierarchicalLevel {
+    fn next_table_address(&self, index: usize) -> Option<usize> {
+        let entry_flags = self[index].flags();
+        if entry_flags.contains(PRESENT) && !entry_flags.contains(HUGE_PAGE) {
+            let table_address = self as *const _ as usize;
+            Some((table_address << 9) | (index << 12))
+        } else {
+            None
+        }
+    }
+
+    pub fn next_table(&self, index: usize) -> Option<&Table<L::NextLevel>> {
+        self.next_table_address(index)
+            .map(|address| unsafe { &*(address as *const _) })
+    }
+
+    pub fn next_table_mut(&mut self, index: usize) -> Option<&mut Table<L::NextLevel>> {
+        self.next_table_address(index)
+            .map(|address| unsafe { &mut *(address as *mut _) })
+    }
+
+    pub fn next_table_create<A>(&mut self,
+                                index: usize,
+                                allocator: &mut A)
+                                -> &mut Table<L::NextLevel>
+        where A: FrameAllocator
+    {
+        if self.next_table(index).is_none() {
+            assert!(!self.entries[index].flags().contains(HUGE_PAGE),
+                    "mapping code does not support huge pages");
+            let frame = allocator.allocate_frame().expect("no frames available");
+            self.entries[index].set(frame, PRESENT | WRITABLE);
+            self.next_table_mut(index).unwrap().zero();
+        }
+        self.next_table_mut(index).unwrap()
+    }
+}
+
+impl<L> Index<usize> for Table<L> where L: TableLevel {
+    type Output = Entry;
+
+    fn index(&self, index: usize) -> &Entry {
+        &self.entries[index]
+    }
+}
+
+impl<L> IndexMut<usize> for Table<L> where L: TableLevel {
+    fn index_mut(&mut self, index: usize) -> &mut Entry {
+        &mut self.entries[index]
+    }
+}
+
+pub trait TableLevel {}
+
+pub enum Level4 {}
+pub enum Level3 {}
+pub enum Level2 {}
+pub enum Level1 {}
+
+impl TableLevel for Level4 {}
+impl TableLevel for Level3 {}
+impl TableLevel for Level2 {}
+impl TableLevel for Level1 {}
+
+pub trait HierarchicalLevel: TableLevel {
+    type NextLevel: TableLevel;
+}
+
+impl HierarchicalLevel for Level4 {
+    type NextLevel = Level3;
+}
+
+impl HierarchicalLevel for Level3 {
+    type NextLevel = Level2;
+}
+
+impl HierarchicalLevel for Level2 {
+    type NextLevel = Level1;
+}

src/memory/paging/temporary_page.rs

@@ -0,0 +1,79 @@
+use super::{Page, ActivePageTable, VirtualAddress};
+use super::table::{Table, Level1};
+use memory::{Frame, FrameAllocator};
+
+pub struct TemporaryPage {
+    page: Page,
+    allocator: TinyAllocator,
+}
+
+impl TemporaryPage {
+    pub fn new<A>(page: Page, allocator: &mut A) -> TemporaryPage
+        where A: FrameAllocator
+    {
+        TemporaryPage {
+            page: page,
+            allocator: TinyAllocator::new(allocator),
+        }
+    }
+
+    /// Maps the temporary page to the given frame in the active table.
+    /// Returns the start address of the temporary page.
+    pub fn map(&mut self, frame: Frame, active_table: &mut ActivePageTable)
+        -> VirtualAddress
+    {
+        use super::entry::WRITABLE;
+
+        assert!(active_table.translate_page(self.page).is_none(),
+                "temporary page is already mapped");
+        active_table.map_to(self.page, frame, WRITABLE, &mut self.allocator);
+        self.page.start_address()
+    }
+
+    /// Unmaps the temporary page in the active table.
+    pub fn unmap(&mut self, active_table: &mut ActivePageTable) {
+        active_table.unmap(self.page, &mut self.allocator)
+    }
+
+    /// Maps the temporary page to the given page table frame in the active
+    /// table. Returns a reference to the now mapped table.
+    pub fn map_table_frame(&mut self,
+                        frame: Frame,
+                        active_table: &mut ActivePageTable)
+                        -> &mut Table<Level1> {
+        unsafe { &mut *(self.map(frame, active_table) as *mut Table<Level1>) }
+    }
+}
+
+struct TinyAllocator([Option<Frame>; 3]);
+
+impl TinyAllocator {
+    fn new<A>(allocator: &mut A) -> TinyAllocator
+        where A: FrameAllocator
+    {
+        let mut f = || allocator.allocate_frame();
+        let frames = [f(), f(), f()];
+        TinyAllocator(frames)
+    }
+}
+
+impl FrameAllocator for TinyAllocator {
+    fn allocate_frame(&mut self) -> Option<Frame> {
+        for frame_option in &mut self.0 {
+            if frame_option.is_some() {
+                return frame_option.take();
+            }
+        }
+        None
+    }
+
+    fn deallocate_frame(&mut self, frame: Frame) {
+        for frame_option in &mut self.0 {
+            if frame_option.is_none() {
+                *frame_option = Some(frame);
+                return;
+            }
+        }
+        panic!("Tiny allocator can hold only 3 frames.");
+    }
+}

src/memory/stack_allocator.rs

@@ -0,0 +1,79 @@
+use memory::paging::{self, Page, PageIter, ActivePageTable};
+use memory::{PAGE_SIZE, FrameAllocator};
+
+pub struct StackAllocator {
+    range: PageIter,
+}
+
+impl StackAllocator {
+    pub fn new(page_range: PageIter) -> StackAllocator {
+        StackAllocator { range: page_range }
+    }
+}
+
+impl StackAllocator {
+    pub fn alloc_stack<FA: FrameAllocator>(&mut self,
+                                           active_table: &mut ActivePageTable,
+                                           frame_allocator: &mut FA,
+                                           size_in_pages: usize)
+                                           -> Option<Stack> {
+        if size_in_pages == 0 {
+            return None; /* a zero sized stack makes no sense */
+        }
+
+        // clone the range, since we only want to change it on success
+        let mut range = self.range.clone();
+
+        // try to allocate the stack pages and a guard page
+        let guard_page = range.next();
+        let stack_start = range.next();
+        let stack_end = if size_in_pages == 1 {
+            stack_start
+        } else {
+            // choose the (size_in_pages-2)th element, since index
+            // starts at 0 and we already allocated the start page
+            range.nth(size_in_pages - 2)
+        };
+
+        match (guard_page, stack_start, stack_end) {
+            (Some(_), Some(start), Some(end)) => {
+                // success! write back updated range
+                self.range = range;
+
+                // map stack pages to physical frames
+                for page in Page::range_inclusive(start, end) {
+                    active_table.map(page, paging::WRITABLE, frame_allocator);
+                }
+
+                // create a new stack
+                let top_of_stack = end.start_address() + PAGE_SIZE;
+                Some(Stack::new(top_of_stack, start.start_address()))
+            }
+            _ => None, /* not enough pages */
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct Stack {
+    top: usize,
+    bottom: usize,
+}
+
+impl Stack {
+    fn new(top: usize, bottom: usize) -> Stack {
+        assert!(top > bottom);
+        Stack {
+            top: top,
+            bottom: bottom,
+        }
+    }
+
+    pub fn top(&self) -> usize {
+        self.top
+    }
+
+    pub fn bottom(&self) -> usize {
+        self.bottom
+    }
+}