Fix register typo: rpb -> rbp

Fixes #746
Add a yield_now function and use it in idle thread
2025-12-16 14:27:49 +00:00 · 2020-02-16 18:02:24 +01:00 · 2020-01-28 12:28:50 +01:00 · 2020-01-28 12:22:37 +01:00 · 2020-01-28 11:29:21 +01:00 · 2020-01-23 14:24:13 +01:00
33 changed files with 1649 additions and 835 deletions
--- a/.appveyor.yml
+++ b/.appveyor.yml
@@ -1,91 +0,0 @@
-branches:
-  only:
-    - staging
-    - trying
-    - master
-    - /post-.*/
-
-# Appveyor configuration template for Rust using rustup for Rust installation
-# https://github.com/starkat99/appveyor-rust
-
-## Operating System (VM environment) ##
-
-# Rust needs at least Visual Studio 2013 Appveyor OS for MSVC targets.
-os: Visual Studio 2015
-
-## Build Matrix ##
-environment:
-  matrix:
-
-### MSVC Toolchains ###
-  # Nightly 64-bit MSVC
-    - channel: nightly
-      target: x86_64-pc-windows-msvc
-      MSYS_BITS: 64
-  # Nightly 32-bit MSVC
-    - channel: nightly
-      target: i686-pc-windows-msvc
-      MSYS_BITS: 32
-
-### GNU Toolchains ###
-  # Nightly 64-bit GNU
-    - channel: nightly
-      target: x86_64-pc-windows-gnu
-      MSYS_BITS: 64
-  # Nightly 32-bit GNU
-    - channel: nightly
-      target: i686-pc-windows-gnu
-      MSYS_BITS: 32
-
-cache:
-  - '%USERPROFILE%\.cargo\bin'
-  - '%USERPROFILE%\.cargo\.crates.toml'
-
-## Install Script ##
-
-# This is the most important part of the Appveyor configuration. This installs the version of Rust
-# specified by the 'channel' and 'target' environment variables from the build matrix. This uses
-# rustup to install Rust.
-#
-# For simple configurations, instead of using the build matrix, you can simply set the
-# default-toolchain and default-host manually here.
-install:
-  - appveyor-retry appveyor DownloadFile https://win.rustup.rs/ -FileName rustup-init.exe
-  - rustup-init -yv --default-toolchain %channel% --default-host %target%
-  - set PATH=%PATH%;%USERPROFILE%\.cargo\bin
-  - rustc -vV
-  - cargo -vV
-
-  # Install qemu
-  - echo %cd%
-  - mkdir "C:\Program Files\qemu"
-  - cd "C:\Program Files\qemu"
-  - if %target%==i686-pc-windows-msvc appveyor DownloadFile "https://qemu.weilnetz.de/w32/2018/qemu-w32-setup-20180801.exe" -FileName "qemu-setup.exe"
-  - if %target%==i686-pc-windows-gnu appveyor DownloadFile "https://qemu.weilnetz.de/w32/2018/qemu-w32-setup-20180801.exe" -FileName "qemu-setup.exe"
-  - if %target%==x86_64-pc-windows-msvc appveyor DownloadFile "https://qemu.weilnetz.de/w64/2018/qemu-w64-setup-20180801.exe" -FileName "qemu-setup.exe"
-  - if %target%==x86_64-pc-windows-gnu appveyor DownloadFile "https://qemu.weilnetz.de/w64/2018/qemu-w64-setup-20180801.exe" -FileName "qemu-setup.exe"
-  - 7z x qemu-setup.exe
-  - set PATH=%PATH%;C:\Program Files\qemu
-  - cd "C:\projects\blog-os"
-
-## Build Script ##
-
-# 'cargo test' takes care of building for us, so disable Appveyor's build stage. This prevents
-# the "directory does not contain a project or solution file" error.
-build: false
-
-before_test:
-  - set PATH=C:\msys64\mingw%MSYS_BITS%\bin;C:\msys64\usr\bin;%PATH%
-  # Fix undefined references to __acrt_iob_func()
-  - sed -rie "s/#define std([[:alpha:]]+)[[:space:]]+\(__acrt_iob_func\(([[:digit:]]+)\)\)/#define std\1 (\&__iob_func()[\2])/" "C:\msys64\mingw64\x86_64-w64-mingw32\include\stdio.h"
-  - sed -rie "s/#define std([[:alpha:]]+)[[:space:]]+\(__acrt_iob_func\(([[:digit:]]+)\)\)/#define std\1 (\&__iob_func()[\2])/" "C:\msys64\mingw32\i686-w64-mingw32\include\stdio.h"
-  - rustup component add rust-src
-  - set RUST_BACKTRACE=1
-  - if not exist %USERPROFILE%\.cargo\bin\cargo-install-latest.exe cargo install cargo-install-latest
-  - cargo install-latest cargo-xbuild bootimage
-
-test_script:
-  - bootimage build
-  - if %target%==x86_64-pc-windows-gnu cargo test
-  - if %target%==x86_64-pc-windows-msvc cargo test
-  - bootimage test
--- a/.cargo/config
+++ b/.cargo/config
@@ -0,0 +1,5 @@
+[build]
+target = "x86_64-blog_os.json"
+
+[target.'cfg(target_os = "none")']
+runner = "bootimage runner"
--- a/.github/workflows/build-code.yml
+++ b/.github/workflows/build-code.yml
@@ -0,0 +1,96 @@
+name: Build Code
+
+on:
+  push:
+    branches:
+      - '*'
+      - '!staging.tmp'
+    tags:
+      - '*'
+  schedule:
+    - cron: '40 3 * * *'   # every day at 3:40
+  pull_request:
+
+jobs:
+  test:
+    name: "Test"
+
+    strategy:
+      matrix:
+        platform: [
+          ubuntu-latest,
+          macos-latest,
+          windows-latest
+        ]
+
+    runs-on: ${{ matrix.platform }}
+    timeout-minutes: 15
+
+    steps:
+    - name: "Checkout Repository"
+      uses: actions/checkout@v1
+
+    - name: Install Rustup
+      run: |
+        curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y --default-toolchain nightly
+        echo ::add-path::$HOME/.cargo/bin
+      if: runner.os == 'macOS'
+
+    - name: "Print Rust Version"
+      run: |
+        rustc -Vv
+        cargo -Vv
+
+    - name: "Install Rustup Components"
+      run: rustup component add rust-src llvm-tools-preview
+    - name: "Install cargo-xbuild"
+      run: cargo install cargo-xbuild --debug
+    - name: "Install bootimage"
+      run: cargo install bootimage --debug
+
+    - name: "Run cargo xbuild"
+      run: cargo xbuild
+    - name: "Create Bootimage"
+      run: cargo bootimage
+
+     # install QEMU
+    - name: Install QEMU (Linux)
+      run: sudo apt update && sudo apt install qemu-system-x86
+      if: runner.os == 'Linux'
+    - name: Install QEMU (macOS)
+      run: brew install qemu
+      if: runner.os == 'macOS'
+      env:
+        HOMEBREW_NO_AUTO_UPDATE: 1
+        HOMEBREW_NO_BOTTLE_SOURCE_FALLBACK: 1
+        HOMEBREW_NO_INSTALL_CLEANUP: 1
+    - name: Install Scoop (Windows)
+      run: |
+        Invoke-Expression (New-Object System.Net.WebClient).DownloadString('https://get.scoop.sh')
+        echo ::add-path::$HOME\scoop\shims
+      if: runner.os == 'Windows'
+      shell: pwsh
+    - name: Install QEMU (Windows)
+      run: scoop install qemu
+      if: runner.os == 'Windows'
+      shell: pwsh
+    - name: "Print QEMU Version"
+      run: qemu-system-x86_64 --version
+
+    - name: "Run cargo xtest"
+      run: cargo xtest
+
+  check_formatting:
+    name: "Check Formatting"
+    runs-on: ubuntu-latest
+    timeout-minutes: 2
+    steps:
+    - uses: actions/checkout@v1
+    - name: "Use the latest Rust nightly with rustfmt"
+      uses: actions-rs/toolchain@v1
+      with:
+          toolchain: nightly
+          profile: minimal
+          components: rustfmt
+          override: true
+    - run: cargo fmt -- --check
--- a/.gitignore
+++ b/.gitignore
@@ -1,2 +1,4 @@
 /target
 **/*.rs.bk
+
+.vscode
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,52 +0,0 @@
-language: rust
-
-rust:
-    - nightly
-
-os:
-  - linux
-  - osx
-  - windows
-
-notifications:
-    email:
-        on_success: never
-        on_failure: always
-
-branches:
-  only:
-    # This is where pull requests from "bors r+" are built.
-    - staging
-    # This is where pull requests from "bors try" are built.
-    - trying
-    # Build pull requests.
-    - master
-    # Build post braches
-    - /^post-.*$/
-
-cache:
-  directories:
-    - $HOME/.cargo
-    - $HOME/Library/Caches/Homebrew
-
-addons:
-  apt:
-    packages:
-      - qemu-system-x86
-  homebrew:
-    packages:
-      - qemu
-
-install:
-  - if [ $TRAVIS_OS_NAME = windows ]; then choco install qemu; export PATH="/c/Program Files/qemu:$PATH"; fi
-
-before_script:
-  - rustup component add rust-src
-  - (test -x $HOME/.cargo/bin/cargo-install-latest || cargo install cargo-install-latest)
-  - cargo install-latest cargo-xbuild bootimage cargo-cache
-
-script:
-  - bootimage build
-  - cargo test
-  - bootimage test
-  - cargo cache --autoclean
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1,383 +1,174 @@
 # This file is automatically @generated by Cargo.
 # It is not intended for manual editing.
-[[package]]
-name = "array-init"
-version = "0.0.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "nodrop 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
 [[package]]
 name = "array-init"
 version = "0.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "23589ecb866b460d3a0f1278834750268c607e8e28a1b982c907219f3178cd72"
 dependencies = [
- "nodrop 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)",
+ "nodrop",
 ]

 [[package]]
 name = "bit_field"
 version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ed8765909f9009617974ab6b7d332625b320b33c326b1e9321382ef1999b5d56"

 [[package]]
 name = "bitflags"
-version = "1.0.4"
+version = "1.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cf1de2fe8c75bc145a2f577add951f8134889b4795d47466a54a5c846d691693"

 [[package]]
 name = "blog_os"
 version = "0.1.0"
 dependencies = [
- "array-init 0.0.3 (registry+https://github.com/rust-lang/crates.io-index)",
- "bootloader 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
- "lazy_static 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
- "pc-keyboard 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
- "pic8259_simple 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)",
- "spin 0.4.10 (registry+https://github.com/rust-lang/crates.io-index)",
- "uart_16550 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
- "volatile 0.2.6 (registry+https://github.com/rust-lang/crates.io-index)",
- "x86_64 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)",
+ "bootloader",
+ "lazy_static",
+ "linked_list_allocator",
+ "pc-keyboard",
+ "pic8259_simple",
+ "spin",
+ "uart_16550",
+ "volatile",
+ "x86_64 0.8.1",
 ]

 [[package]]
 name = "bootloader"
-version = "0.4.0"
+version = "0.8.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "fixedvec 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
- "font8x8 0.2.4 (registry+https://github.com/rust-lang/crates.io-index)",
- "usize_conversions 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
- "x86_64 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
- "xmas-elf 0.6.2 (registry+https://github.com/rust-lang/crates.io-index)",
-]
+checksum = "d596849a47f28abdea62d7a6a25c4f6e69c3d9b09b0a2877db6e9cda004ca993"

 [[package]]
-name = "cc"
-version = "1.0.30"
+name = "cast"
+version = "0.2.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4b9434b9a5aa1450faa3f9cb14ea0e8c53bb5d2b3c1bfd1ab4fc03e9f33fbfb0"
+dependencies = [
+ "rustc_version",
+]

 [[package]]
 name = "cpuio"
 version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-
-[[package]]
-name = "fixedvec"
-version = "0.2.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "skeptic 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "font8x8"
-version = "0.2.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-
-[[package]]
-name = "fuchsia-zircon"
-version = "0.3.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "bitflags 1.0.4 (registry+https://github.com/rust-lang/crates.io-index)",
- "fuchsia-zircon-sys 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "fuchsia-zircon-sys"
-version = "0.3.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-
-[[package]]
-name = "getopts"
-version = "0.2.18"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "unicode-width 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)",
-]
+checksum = "22b8e308ccfc5acf3b82f79c0eac444cf6114cb2ac67a230ca6c177210068daa"

 [[package]]
 name = "lazy_static"
-version = "1.2.0"
+version = "1.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e2abad23fbc42b3700f2f279844dc832adb2b2eb069b2df918f455c4e18cc646"
 dependencies = [
- "spin 0.4.10 (registry+https://github.com/rust-lang/crates.io-index)",
+ "spin",
 ]

 [[package]]
-name = "libc"
-version = "0.2.48"
+name = "linked_list_allocator"
+version = "0.6.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "47314ec1d29aa869ee7cb5a5be57be9b1055c56567d59c3fb6689926743e0bea"
+dependencies = [
+ "spin",
+]

 [[package]]
 name = "nodrop"
-version = "0.1.13"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-
-[[package]]
-name = "os_bootinfo"
-version = "0.2.1"
+version = "0.1.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72ef4a56884ca558e5ddb05a1d1e7e1bfd9a68d9ed024c21704cc98872dae1bb"

 [[package]]
 name = "pc-keyboard"
 version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fff50ab09ba31bcebc0669f4e64c0952fae1acdca9e6e0587e68e4e8443808ac"

 [[package]]
 name = "pic8259_simple"
 version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc64b2fd10828da8521b6cdabe0679385d7d2a3a6d4c336b819d1fa31ba35c72"
 dependencies = [
- "cpuio 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "pulldown-cmark"
-version = "0.0.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "getopts 0.2.18 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "rand"
-version = "0.4.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "fuchsia-zircon 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)",
- "libc 0.2.48 (registry+https://github.com/rust-lang/crates.io-index)",
- "rand_core 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
- "rdrand 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
- "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "rand_core"
-version = "0.3.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "rand_core 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "rand_core"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-
-[[package]]
-name = "raw-cpuid"
-version = "6.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "bitflags 1.0.4 (registry+https://github.com/rust-lang/crates.io-index)",
- "cc 1.0.30 (registry+https://github.com/rust-lang/crates.io-index)",
- "rustc_version 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "rdrand"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "rand_core 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "remove_dir_all"
-version = "0.5.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)",
+ "cpuio",
 ]

 [[package]]
 name = "rustc_version"
 version = "0.2.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "138e3e0acb6c9fb258b19b67cb8abd63c00679d2851805ea151465464fe9030a"
 dependencies = [
- "semver 0.9.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "semver",
 ]

 [[package]]
 name = "semver"
 version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1d7eb9ef2c18661902cc47e535f9bc51b78acd254da71d375c2f6720d9a40403"
 dependencies = [
- "semver-parser 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)",
+ "semver-parser",
 ]

 [[package]]
 name = "semver-parser"
 version = "0.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-
-[[package]]
-name = "skeptic"
-version = "0.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "pulldown-cmark 0.0.3 (registry+https://github.com/rust-lang/crates.io-index)",
- "tempdir 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)",
-]
+checksum = "388a1df253eca08550bef6c72392cfe7c30914bf41df5269b68cbd6ff8f570a3"

 [[package]]
 name = "spin"
-version = "0.4.10"
+version = "0.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-
-[[package]]
-name = "tempdir"
-version = "0.3.7"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "rand 0.4.5 (registry+https://github.com/rust-lang/crates.io-index)",
- "remove_dir_all 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)",
-]
+checksum = "6e63cff320ae2c57904679ba7cb63280a3dc4613885beafb148ee7bf9aa9042d"

 [[package]]
 name = "uart_16550"
-version = "0.1.0"
+version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "803ea8cb602dbb32c1a657a866d2dd79fe7dbeab0fb2ac667cb4dcc7de12a58b"
 dependencies = [
- "bitflags 1.0.4 (registry+https://github.com/rust-lang/crates.io-index)",
- "x86_64 0.2.14 (registry+https://github.com/rust-lang/crates.io-index)",
+ "bitflags",
+ "x86_64 0.7.7",
 ]

-[[package]]
-name = "unicode-width"
-version = "0.1.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-
-[[package]]
-name = "usize_conversions"
-version = "0.2.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-
 [[package]]
 name = "ux"
 version = "0.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "88dfeb711b61ce620c0cb6fd9f8e3e678622f0c971da2a63c4b3e25e88ed012f"

 [[package]]
 name = "volatile"
 version = "0.2.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-
-[[package]]
-name = "winapi"
-version = "0.3.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "winapi-i686-pc-windows-gnu 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
- "winapi-x86_64-pc-windows-gnu 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "winapi-i686-pc-windows-gnu"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-
-[[package]]
-name = "winapi-x86_64-pc-windows-gnu"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6af0edf5b4faacc31fc51159244d78d65ec580f021afcef7bd53c04aeabc7f29"

 [[package]]
 name = "x86_64"
-version = "0.2.14"
+version = "0.7.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1f27d9168654aee1b0c1b73746caeb4aa33248f8b8c8f6e100e697fcc2a794b2"
 dependencies = [
- "bit_field 0.9.0 (registry+https://github.com/rust-lang/crates.io-index)",
- "bitflags 1.0.4 (registry+https://github.com/rust-lang/crates.io-index)",
- "os_bootinfo 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
- "usize_conversions 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
- "ux 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
+ "array-init",
+ "bit_field",
+ "bitflags",
+ "cast",
+ "ux",
 ]

 [[package]]
 name = "x86_64"
-version = "0.3.6"
+version = "0.8.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f21672dcbed52bc09eea030d189600c0189c66c97bc5b31779eb780e064a201f"
 dependencies = [
- "array-init 0.0.4 (registry+https://github.com/rust-lang/crates.io-index)",
- "bit_field 0.9.0 (registry+https://github.com/rust-lang/crates.io-index)",
- "bitflags 1.0.4 (registry+https://github.com/rust-lang/crates.io-index)",
- "os_bootinfo 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)",
- "usize_conversions 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
- "ux 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
+ "array-init",
+ "bit_field",
+ "bitflags",
+ "cast",
 ]
-
-[[package]]
-name = "x86_64"
-version = "0.5.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "array-init 0.0.4 (registry+https://github.com/rust-lang/crates.io-index)",
- "bit_field 0.9.0 (registry+https://github.com/rust-lang/crates.io-index)",
- "bitflags 1.0.4 (registry+https://github.com/rust-lang/crates.io-index)",
- "raw-cpuid 6.1.0 (registry+https://github.com/rust-lang/crates.io-index)",
- "usize_conversions 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)",
- "ux 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "xmas-elf"
-version = "0.6.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-dependencies = [
- "zero 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)",
-]
-
-[[package]]
-name = "zero"
-version = "0.1.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-
-[metadata]
-"checksum array-init 0.0.3 (registry+https://github.com/rust-lang/crates.io-index)" = "c3cc8456d0ae81a8c76f59e384683a601548c38949a4bfcb65dd31ded5c75ff3"
-"checksum array-init 0.0.4 (registry+https://github.com/rust-lang/crates.io-index)" = "23589ecb866b460d3a0f1278834750268c607e8e28a1b982c907219f3178cd72"
-"checksum bit_field 0.9.0 (registry+https://github.com/rust-lang/crates.io-index)" = "ed8765909f9009617974ab6b7d332625b320b33c326b1e9321382ef1999b5d56"
-"checksum bitflags 1.0.4 (registry+https://github.com/rust-lang/crates.io-index)" = "228047a76f468627ca71776ecdebd732a3423081fcf5125585bcd7c49886ce12"
-"checksum bootloader 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "a0808c55da932b82d3ababdaa0caa3f18522c5d2d06309b98f73adda849a3f03"
-"checksum cc 1.0.30 (registry+https://github.com/rust-lang/crates.io-index)" = "d01c69d08ff207f231f07196e30f84c70f1c815b04f980f8b7b01ff01f05eb92"
-"checksum cpuio 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "22b8e308ccfc5acf3b82f79c0eac444cf6114cb2ac67a230ca6c177210068daa"
-"checksum fixedvec 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)" = "7c6c16d316ccdac21a4dd648e314e76facbbaf316e83ca137d0857a9c07419d0"
-"checksum font8x8 0.2.4 (registry+https://github.com/rust-lang/crates.io-index)" = "b81d84c3c978af7d05d31a2198af4b9ba956d819d15d8f6d58fc150e33f8dc1f"
-"checksum fuchsia-zircon 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)" = "2e9763c69ebaae630ba35f74888db465e49e259ba1bc0eda7d06f4a067615d82"
-"checksum fuchsia-zircon-sys 0.3.3 (registry+https://github.com/rust-lang/crates.io-index)" = "3dcaa9ae7725d12cdb85b3ad99a434db70b468c09ded17e012d86b5c1010f7a7"
-"checksum getopts 0.2.18 (registry+https://github.com/rust-lang/crates.io-index)" = "0a7292d30132fb5424b354f5dc02512a86e4c516fe544bb7a25e7f266951b797"
-"checksum lazy_static 1.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "a374c89b9db55895453a74c1e38861d9deec0b01b405a82516e9d5de4820dea1"
-"checksum libc 0.2.48 (registry+https://github.com/rust-lang/crates.io-index)" = "e962c7641008ac010fa60a7dfdc1712449f29c44ef2d4702394aea943ee75047"
-"checksum nodrop 0.1.13 (registry+https://github.com/rust-lang/crates.io-index)" = "2f9667ddcc6cc8a43afc9b7917599d7216aa09c463919ea32c59ed6cac8bc945"
-"checksum os_bootinfo 0.2.1 (registry+https://github.com/rust-lang/crates.io-index)" = "66481dbeb5e773e7bd85b63cd6042c30786f834338288c5ec4f3742673db360a"
-"checksum pc-keyboard 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)" = "fff50ab09ba31bcebc0669f4e64c0952fae1acdca9e6e0587e68e4e8443808ac"
-"checksum pic8259_simple 0.1.1 (registry+https://github.com/rust-lang/crates.io-index)" = "dc64b2fd10828da8521b6cdabe0679385d7d2a3a6d4c336b819d1fa31ba35c72"
-"checksum pulldown-cmark 0.0.3 (registry+https://github.com/rust-lang/crates.io-index)" = "8361e81576d2e02643b04950e487ec172b687180da65c731c03cf336784e6c07"
-"checksum rand 0.4.5 (registry+https://github.com/rust-lang/crates.io-index)" = "dee497e66d8d76bf08ce20c8d36e16f93749ab0bf89975b4f8ae5cee660c2da2"
-"checksum rand_core 0.3.1 (registry+https://github.com/rust-lang/crates.io-index)" = "7a6fdeb83b075e8266dcc8762c22776f6877a63111121f5f8c7411e5be7eed4b"
-"checksum rand_core 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "d0e7a549d590831370895ab7ba4ea0c1b6b011d106b5ff2da6eee112615e6dc0"
-"checksum raw-cpuid 6.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "30a9d219c32c9132f7be513c18be77c9881c7107d2ab5569d205a6a0f0e6dc7d"
-"checksum rdrand 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "678054eb77286b51581ba43620cc911abf02758c91f93f479767aed0f90458b2"
-"checksum remove_dir_all 0.5.1 (registry+https://github.com/rust-lang/crates.io-index)" = "3488ba1b9a2084d38645c4c08276a1752dcbf2c7130d74f1569681ad5d2799c5"
-"checksum rustc_version 0.2.3 (registry+https://github.com/rust-lang/crates.io-index)" = "138e3e0acb6c9fb258b19b67cb8abd63c00679d2851805ea151465464fe9030a"
-"checksum semver 0.9.0 (registry+https://github.com/rust-lang/crates.io-index)" = "1d7eb9ef2c18661902cc47e535f9bc51b78acd254da71d375c2f6720d9a40403"
-"checksum semver-parser 0.7.0 (registry+https://github.com/rust-lang/crates.io-index)" = "388a1df253eca08550bef6c72392cfe7c30914bf41df5269b68cbd6ff8f570a3"
-"checksum skeptic 0.5.0 (registry+https://github.com/rust-lang/crates.io-index)" = "061203a849117b0f7090baf8157aa91dac30545208fbb85166ac58b4ca33d89c"
-"checksum spin 0.4.10 (registry+https://github.com/rust-lang/crates.io-index)" = "ceac490aa12c567115b40b7b7fceca03a6c9d53d5defea066123debc83c5dc1f"
-"checksum tempdir 0.3.7 (registry+https://github.com/rust-lang/crates.io-index)" = "15f2b5fb00ccdf689e0149d1b1b3c03fead81c2b37735d812fa8bddbbf41b6d8"
-"checksum uart_16550 0.1.0 (registry+https://github.com/rust-lang/crates.io-index)" = "269f953d8de3226f7c065c589c7b4a3e83d10a419c7c3b5e2e0f197e6acc966e"
-"checksum unicode-width 0.1.5 (registry+https://github.com/rust-lang/crates.io-index)" = "882386231c45df4700b275c7ff55b6f3698780a650026380e72dabe76fa46526"
-"checksum usize_conversions 0.2.0 (registry+https://github.com/rust-lang/crates.io-index)" = "f70329e2cbe45d6c97a5112daad40c34cd9a4e18edb5a2a18fefeb584d8d25e5"
-"checksum ux 0.1.3 (registry+https://github.com/rust-lang/crates.io-index)" = "88dfeb711b61ce620c0cb6fd9f8e3e678622f0c971da2a63c4b3e25e88ed012f"
-"checksum volatile 0.2.6 (registry+https://github.com/rust-lang/crates.io-index)" = "6af0edf5b4faacc31fc51159244d78d65ec580f021afcef7bd53c04aeabc7f29"
-"checksum winapi 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)" = "92c1eb33641e276cfa214a0522acad57be5c56b10cb348b3c5117db75f3ac4b0"
-"checksum winapi-i686-pc-windows-gnu 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "ac3b87c63620426dd9b991e5ce0329eff545bccbbb34f3be09ff6fb6ab51b7b6"
-"checksum winapi-x86_64-pc-windows-gnu 0.4.0 (registry+https://github.com/rust-lang/crates.io-index)" = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
-"checksum x86_64 0.2.14 (registry+https://github.com/rust-lang/crates.io-index)" = "2bd647af1614659e1febec1d681231aea4ebda4818bf55a578aff02f3e4db4b4"
-"checksum x86_64 0.3.6 (registry+https://github.com/rust-lang/crates.io-index)" = "f9258d7e2dd25008d69e8c9e9ee37865887a5e1e3d06a62f1cb3f6c209e6f177"
-"checksum x86_64 0.5.2 (registry+https://github.com/rust-lang/crates.io-index)" = "de155d368de1d32afc8f90838bf81986e4bd43a0cd5fcd7f7e9c85cb8f51dc7c"
-"checksum xmas-elf 0.6.2 (registry+https://github.com/rust-lang/crates.io-index)" = "22678df5df766e8d1e5d609da69f0c3132d794edf6ab5e75e7abcd2270d4cf58"
-"checksum zero 0.1.2 (registry+https://github.com/rust-lang/crates.io-index)" = "5f1bc8a6b2005884962297587045002d8cfb8dcec9db332f4ca216ddc5de82c5"
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -4,27 +4,35 @@ version = "0.1.0"
 authors = ["Philipp Oppermann <dev@phil-opp.com>"]
 edition = "2018"

+[[test]]
+name = "should_panic"
+harness = false
+
+[[test]]
+name = "stack_overflow"
+harness = false
+
 [dependencies]
-bootloader = { version = "0.4.0", features = ["map_physical_memory"]}
-volatile = "0.2.3"
-spin = "0.4.9"
-uart_16550 = "0.1.0"
-x86_64 = "0.5.2"
+bootloader = { version = "0.8.0", features = ["map_physical_memory"]}
+volatile = "0.2.6"
+spin = "0.5.2"
+x86_64 = "0.8.1"
+uart_16550 = "0.2.0"
 pic8259_simple = "0.1.1"
 pc-keyboard = "0.3.1"
+linked_list_allocator = "0.6.4"

 [dependencies.lazy_static]
 version = "1.0"
 features = ["spin_no_std"]

-[dev-dependencies]
-array-init = "0.0.3"
-
-[profile.dev]
-panic = "abort"
-
-[profile.release]
-panic = "abort"

 [package.metadata.bootimage]
-default-target = "x86_64-blog_os.json"
+test-args = [
+    "-device", "isa-debug-exit,iobase=0xf4,iosize=0x04", "-serial", "stdio",
+    "-display", "none"
+]
+test-success-exit-code = 33         # (0x10 << 1) | 1
+
+[profile.release]
+lto = true
--- a/201
+++ b/201
@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "{}"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright {yyyy} {name of copyright owner}
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
--- a/9
+++ b/9
@@ -0,0 +1,9 @@
+The MIT License (MIT)
+
+Copyright (c) 2019 Philipp Oppermann
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
--- a/README.md
+++ b/README.md
@@ -1,10 +1,10 @@
-# Blog OS (Paging Implementation)
+# Blog OS (Heap Allocation)

-[![Build Status](https://travis-ci.org/phil-opp/blog_os.svg?branch=post-10)](https://travis-ci.org/phil-opp/blog_os/branches)
+[![Build Status](https://github.com/phil-opp/blog_os/workflows/Build%20Code/badge.svg?branch=post-10)](https://github.com/phil-opp/blog_os/actions?query=workflow%3A%22Build+Code%22+branch%3Apost-10)

-This repository contains the source code for the [Paging Implementation][post] post of the [Writing an OS in Rust](https://os.phil-opp.com) series.
+This repository contains the source code for the [Heap Allocation][post] post of the [Writing an OS in Rust](https://os.phil-opp.com) series.

-[post]: https://os.phil-opp.com/paging-implementation/
+[post]: https://os.phil-opp.com/heap-allocation/

 **Check out the [master branch](https://github.com/phil-opp/blog_os) for more information.**

@@ -19,7 +19,13 @@ cargo install cargo-xbuild bootimage
 Then you can build the project by running:

 ```
-bootimage build
+cargo xbuild
+```
+
+To create a bootable disk image, run:
+
+```
+cargo bootimage
 ```

 This creates a bootable disk image in the `target/x86_64-blog_os/debug` directory.
@@ -33,7 +39,7 @@ You can run the disk image in [QEMU] through:
 [QEMU]: https://www.qemu.org/

 ```
-bootimage run
+cargo xrun
 ```

 Of course [QEMU] needs to be installed for this.
@@ -48,7 +54,20 @@ Where `sdX` is the device name of your USB stick. **Be careful** to choose the c

 ## Testing

-To run the unit tests on the host system, execute `cargo test`. To run the integration tests in [QEMU], run `bootimage test`.
+To run the unit and integration tests, execute `cargo xtest`.

 ## License
-The source code is dual-licensed under MIT or the Apache License (Version 2.0).
+
+Licensed under either of
+
+- Apache License, Version 2.0 ([LICENSE-APACHE](LICENSE-APACHE) or
+  http://www.apache.org/licenses/LICENSE-2.0)
+- MIT license ([LICENSE-MIT](LICENSE-MIT) or http://opensource.org/licenses/MIT)
+
+at your option.
+
+Note that this only applies to this git branch, other branches might be licensed differently.
+
+### Contribution
+
+Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in the work by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions.
--- a/azure-pipelines.yml
+++ b/azure-pipelines.yml
@@ -1,99 +0,0 @@
-# Documentation: https://aka.ms/yaml
-
-trigger:
-  batch: true
-  branches:
-    include:
-    # This is where pull requests from "bors r+" are built.
-    - staging
-    # This is where pull requests from "bors try" are built.
-    - trying
-    # Build pull requests.
-    - master
-    # Build post braches
-    - post-*
-
-strategy:
-  matrix:
-    linux:
-      image_name: 'ubuntu-16.04'
-      rustup_toolchain: nightly
-    mac:
-      image_name: 'macos-10.13'
-      rustup_toolchain: nightly
-    windows:
-      image_name: 'vs2017-win2016'
-      rustup_toolchain: nightly
-
-pool:
-  vmImage: $(image_name)
-
-steps:
- bash: |
-    echo "Hello world from $AGENT_NAME running on $AGENT_OS"
-    echo "Reason: $BUILD_REASON"
-    echo "Requested for: $BUILD_REQUESTEDFOR"
-  displayName: 'Build Info'
-  continueOnError: true
-
- script: |
-    curl https://sh.rustup.rs -sSf | sh -s -- -y --default-toolchain $RUSTUP_TOOLCHAIN
-    echo "##vso[task.setvariable variable=PATH;]$PATH:$HOME/.cargo/bin"
-  condition: or(eq( variables['Agent.OS'], 'Linux' ),  eq( variables['Agent.OS'], 'Darwin' ))
-  displayName: 'Install Rust (Linux/macOS)'
-
- script: |
-    curl -sSf -o rustup-init.exe https://win.rustup.rs
-    rustup-init.exe -y --default-toolchain %RUSTUP_TOOLCHAIN%
-    echo ##vso[task.setvariable variable=PATH;]%PATH%;%USERPROFILE%\.cargo\bin
-  condition: eq( variables['Agent.OS'], 'Windows_NT' )
-  displayName: 'Install Rust (Windows)'
-
- script: |
-    rustc -Vv
-    cargo -V
-  displayName: 'Print Rust Version'
-  continueOnError: true
-
- script: rustup component add rust-src
-  displayName: 'Install Rustup Src Component'
-
- script: |
-    cargo install cargo-xbuild --debug
-    cargo install bootimage --debug
-  displayName: 'Install cargo-xbuild and bootimage'
-
- script: bootimage build
-  displayName: 'Build'
-
- script: cargo test
-  displayName: 'Unit Tests'
-
- script: sudo apt install qemu-system-x86
-  condition: eq( variables['Agent.OS'], 'Linux' )
-  displayName: 'Install QEMU (Linux)'
-
- script: |
-    export HOMEBREW_NO_AUTO_UPDATE=1
-    export HOMEBREW_NO_BOTTLE_SOURCE_FALLBACK=1
-    export HOMEBREW_NO_INSTALL_CLEANUP=1
-    brew install qemu
-  condition: eq( variables['Agent.OS'], 'Darwin' )
-  displayName: 'Install QEMU (macOS)'
-
- script: |
-    choco install qemu --limit-output --no-progress
-    echo ##vso[task.setvariable variable=PATH;]%PATH%;C:\Program Files\qemu
-    set PATH=%PATH%;C:\Program Files\qemu
-    qemu-system-x86_64 --version
-  condition: eq( variables['Agent.OS'], 'Windows_NT' )
-  displayName: 'Install QEMU (Windows)'
-
- script: bootimage test
-  displayName: 'Integration Tests'
-
- script: rustup component add rustfmt
-  displayName: 'Install Rustfmt'
-
- script: cargo fmt -- --check
-  displayName: 'Check Formatting'
--- a/bors.toml
+++ b/bors.toml
@@ -1,4 +1,4 @@
 status = [
-  "phil-opp.blog_os",
+  "Test",
 ]
 delete_merged_branches = true
--- a/src/allocator/bump.rs
+++ b/src/allocator/bump.rs
@@ -0,0 +1,58 @@
+use super::{align_up, Locked};
+use alloc::alloc::{GlobalAlloc, Layout};
+use core::ptr;
+
+pub struct BumpAllocator {
+    heap_start: usize,
+    heap_end: usize,
+    next: usize,
+    allocations: usize,
+}
+
+impl BumpAllocator {
+    /// Creates a new empty bump allocator.
+    pub const fn new() -> Self {
+        BumpAllocator {
+            heap_start: 0,
+            heap_end: 0,
+            next: 0,
+            allocations: 0,
+        }
+    }
+
+    /// Initializes the bump allocator with the given heap bounds.
+    ///
+    /// This method is unsafe because the caller must ensure that the given
+    /// memory range is unused. Also, this method must be called only once.
+    pub unsafe fn init(&mut self, heap_start: usize, heap_size: usize) {
+        self.heap_start = heap_start;
+        self.heap_end = heap_start + heap_size;
+        self.next = heap_start;
+    }
+}
+
+unsafe impl GlobalAlloc for Locked<BumpAllocator> {
+    unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
+        let mut bump = self.lock(); // get a mutable reference
+
+        let alloc_start = align_up(bump.next, layout.align());
+        let alloc_end = alloc_start + layout.size();
+
+        if alloc_end > bump.heap_end {
+            ptr::null_mut() // out of memory
+        } else {
+            bump.next = alloc_end;
+            bump.allocations += 1;
+            alloc_start as *mut u8
+        }
+    }
+
+    unsafe fn dealloc(&self, _ptr: *mut u8, _layout: Layout) {
+        let mut bump = self.lock(); // get a mutable reference
+
+        bump.allocations -= 1;
+        if bump.allocations == 0 {
+            bump.next = bump.heap_start;
+        }
+    }
+}
--- a/src/allocator/fixed_size_block.rs
+++ b/src/allocator/fixed_size_block.rs
@@ -0,0 +1,102 @@
+use super::Locked;
+use alloc::alloc::{GlobalAlloc, Layout};
+use core::{
+    mem,
+    ptr::{self, NonNull},
+};
+
+/// The block sizes to use.
+///
+/// The sizes must each be power of 2 because they are also used as
+/// the block alignment (alignments must be always powers of 2).
+const BLOCK_SIZES: &[usize] = &[8, 16, 32, 64, 128, 256, 512, 1024, 2048];
+
+/// Choose an appropriate block size for the given layout.
+///
+/// Returns an index into the `BLOCK_SIZES` array.
+fn list_index(layout: &Layout) -> Option<usize> {
+    let required_block_size = layout.size().max(layout.align());
+    BLOCK_SIZES.iter().position(|&s| s >= required_block_size)
+}
+
+struct ListNode {
+    next: Option<&'static mut ListNode>,
+}
+
+pub struct FixedSizeBlockAllocator {
+    list_heads: [Option<&'static mut ListNode>; BLOCK_SIZES.len()],
+    fallback_allocator: linked_list_allocator::Heap,
+}
+
+impl FixedSizeBlockAllocator {
+    /// Creates an empty FixedSizeBlockAllocator.
+    pub const fn new() -> Self {
+        FixedSizeBlockAllocator {
+            list_heads: [None; BLOCK_SIZES.len()],
+            fallback_allocator: linked_list_allocator::Heap::empty(),
+        }
+    }
+
+    /// Initialize the allocator with the given heap bounds.
+    ///
+    /// This function is unsafe because the caller must guarantee that the given
+    /// heap bounds are valid and that the heap is unused. This method must be
+    /// called only once.
+    pub unsafe fn init(&mut self, heap_start: usize, heap_size: usize) {
+        self.fallback_allocator.init(heap_start, heap_size);
+    }
+
+    /// Allocates using the fallback allocator.
+    fn fallback_alloc(&mut self, layout: Layout) -> *mut u8 {
+        match self.fallback_allocator.allocate_first_fit(layout) {
+            Ok(ptr) => ptr.as_ptr(),
+            Err(_) => ptr::null_mut(),
+        }
+    }
+}
+
+unsafe impl GlobalAlloc for Locked<FixedSizeBlockAllocator> {
+    unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
+        let mut allocator = self.lock();
+        match list_index(&layout) {
+            Some(index) => {
+                match allocator.list_heads[index].take() {
+                    Some(node) => {
+                        allocator.list_heads[index] = node.next.take();
+                        node as *mut ListNode as *mut u8
+                    }
+                    None => {
+                        // no block exists in list => allocate new block
+                        let block_size = BLOCK_SIZES[index];
+                        // only works if all block sizes are a power of 2
+                        let block_align = block_size;
+                        let layout = Layout::from_size_align(block_size, block_align).unwrap();
+                        allocator.fallback_alloc(layout)
+                    }
+                }
+            }
+            None => allocator.fallback_alloc(layout),
+        }
+    }
+
+    unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) {
+        let mut allocator = self.lock();
+        match list_index(&layout) {
+            Some(index) => {
+                let new_node = ListNode {
+                    next: allocator.list_heads[index].take(),
+                };
+                // verify that block has size and alignment required for storing node
+                assert!(mem::size_of::<ListNode>() <= BLOCK_SIZES[index]);
+                assert!(mem::align_of::<ListNode>() <= BLOCK_SIZES[index]);
+                let new_node_ptr = ptr as *mut ListNode;
+                new_node_ptr.write(new_node);
+                allocator.list_heads[index] = Some(&mut *new_node_ptr);
+            }
+            None => {
+                let ptr = NonNull::new(ptr).unwrap();
+                allocator.fallback_allocator.deallocate(ptr, layout);
+            }
+        }
+    }
+}
--- a/src/allocator/linked_list.rs
+++ b/src/allocator/linked_list.rs
@@ -0,0 +1,145 @@
+use super::{align_up, Locked};
+use alloc::alloc::{GlobalAlloc, Layout};
+use core::{mem, ptr};
+
+struct ListNode {
+    size: usize,
+    next: Option<&'static mut ListNode>,
+}
+
+impl ListNode {
+    const fn new(size: usize) -> Self {
+        ListNode { size, next: None }
+    }
+
+    fn start_addr(&self) -> usize {
+        self as *const Self as usize
+    }
+
+    fn end_addr(&self) -> usize {
+        self.start_addr() + self.size
+    }
+}
+
+pub struct LinkedListAllocator {
+    head: ListNode,
+}
+
+impl LinkedListAllocator {
+    /// Creates an empty LinkedListAllocator.
+    pub const fn new() -> Self {
+        Self {
+            head: ListNode::new(0),
+        }
+    }
+
+    /// Initialize the allocator with the given heap bounds.
+    ///
+    /// This function is unsafe because the caller must guarantee that the given
+    /// heap bounds are valid and that the heap is unused. This method must be
+    /// called only once.
+    pub unsafe fn init(&mut self, heap_start: usize, heap_size: usize) {
+        self.add_free_region(heap_start, heap_size);
+    }
+
+    /// Adds the given memory region to the front of the list.
+    unsafe fn add_free_region(&mut self, addr: usize, size: usize) {
+        // ensure that the freed region is capable of holding ListNode
+        assert!(align_up(addr, mem::align_of::<ListNode>()) == addr);
+        assert!(size >= mem::size_of::<ListNode>());
+
+        // create a new list node and append it at the start of the list
+        let mut node = ListNode::new(size);
+        node.next = self.head.next.take();
+        let node_ptr = addr as *mut ListNode;
+        node_ptr.write(node);
+        self.head.next = Some(&mut *node_ptr)
+    }
+
+    /// Looks for a free region with the given size and alignment and removes
+    /// it from the list.
+    ///
+    /// Returns a tuple of the list node and the start address of the allocation.
+    fn find_region(&mut self, size: usize, align: usize) -> Option<(&'static mut ListNode, usize)> {
+        // reference to current list node, updated for each iteration
+        let mut current = &mut self.head;
+        // look for a large enough memory region in linked list
+        while let Some(ref mut region) = current.next {
+            if let Ok(alloc_start) = Self::alloc_from_region(&region, size, align) {
+                // region suitable for allocation -> remove node from list
+                let next = region.next.take();
+                let ret = Some((current.next.take().unwrap(), alloc_start));
+                current.next = next;
+                return ret;
+            } else {
+                // region not suitable -> continue with next region
+                current = current.next.as_mut().unwrap();
+            }
+        }
+
+        // no suitable region found
+        None
+    }
+
+    /// Try to use the given region for an allocation with given size and alignment.
+    ///
+    /// Returns the allocation start address on success.
+    fn alloc_from_region(region: &ListNode, size: usize, align: usize) -> Result<usize, ()> {
+        let alloc_start = align_up(region.start_addr(), align);
+        let alloc_end = alloc_start + size;
+
+        if alloc_end > region.end_addr() {
+            // region too small
+            return Err(());
+        }
+
+        let excess_size = region.end_addr() - alloc_end;
+        if excess_size > 0 && excess_size < mem::size_of::<ListNode>() {
+            // rest of region too small to hold a ListNode (required because the
+            // allocation splits the region in a used and a free part)
+            return Err(());
+        }
+
+        // region suitable for allocation
+        Ok(alloc_start)
+    }
+
+    /// Adjust the given layout so that the resulting allocated memory
+    /// region is also capable of storing a `ListNode`.
+    ///
+    /// Returns the adjusted size and alignment as a (size, align) tuple.
+    fn size_align(layout: Layout) -> (usize, usize) {
+        let layout = layout
+            .align_to(mem::align_of::<ListNode>())
+            .expect("adjusting alignment failed")
+            .pad_to_align();
+        let size = layout.size().max(mem::size_of::<ListNode>());
+        (size, layout.align())
+    }
+}
+
+unsafe impl GlobalAlloc for Locked<LinkedListAllocator> {
+    unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
+        // perform layout adjustments
+        let (size, align) = LinkedListAllocator::size_align(layout);
+        let mut allocator = self.inner.lock();
+
+        if let Some((region, alloc_start)) = allocator.find_region(size, align) {
+            let alloc_end = alloc_start + size;
+            let excess_size = region.end_addr() - alloc_end;
+            if excess_size > 0 {
+                allocator.add_free_region(alloc_end, excess_size);
+            }
+            alloc_start as *mut u8
+        } else {
+            ptr::null_mut()
+        }
+    }
+
+    unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) {
+        // perform layout adjustments
+        let (size, _) = LinkedListAllocator::size_align(layout);
+
+        self.inner.lock().add_free_region(ptr as usize, size)
+    }
+}
--- a/src/allocator/mod.rs
+++ b/src/allocator/mod.rs
@@ -0,0 +1,84 @@
+use alloc::alloc::{GlobalAlloc, Layout};
+use core::ptr::null_mut;
+use fixed_size_block::FixedSizeBlockAllocator;
+use x86_64::{
+    structures::paging::{
+        mapper::MapToError, FrameAllocator, Mapper, Page, PageTableFlags, Size4KiB,
+    },
+    VirtAddr,
+};
+
+pub mod bump;
+pub mod fixed_size_block;
+pub mod linked_list;
+
+pub const HEAP_START: usize = 0x_4444_4444_0000;
+pub const HEAP_SIZE: usize = 100 * 1024; // 100 KiB
+
+#[global_allocator]
+static ALLOCATOR: Locked<FixedSizeBlockAllocator> = Locked::new(FixedSizeBlockAllocator::new());
+
+pub fn init_heap(
+    mapper: &mut impl Mapper<Size4KiB>,
+    frame_allocator: &mut impl FrameAllocator<Size4KiB>,
+) -> Result<(), MapToError> {
+    let page_range = {
+        let heap_start = VirtAddr::new(HEAP_START as u64);
+        let heap_end = heap_start + HEAP_SIZE - 1u64;
+        let heap_start_page = Page::containing_address(heap_start);
+        let heap_end_page = Page::containing_address(heap_end);
+        Page::range_inclusive(heap_start_page, heap_end_page)
+    };
+
+    for page in page_range {
+        let frame = frame_allocator
+            .allocate_frame()
+            .ok_or(MapToError::FrameAllocationFailed)?;
+        let flags = PageTableFlags::PRESENT | PageTableFlags::WRITABLE;
+        mapper.map_to(page, frame, flags, frame_allocator)?.flush();
+    }
+
+    unsafe {
+        ALLOCATOR.lock().init(HEAP_START, HEAP_SIZE);
+    }
+
+    Ok(())
+}
+
+pub struct Dummy;
+
+unsafe impl GlobalAlloc for Dummy {
+    unsafe fn alloc(&self, _layout: Layout) -> *mut u8 {
+        null_mut()
+    }
+
+    unsafe fn dealloc(&self, _ptr: *mut u8, _layout: Layout) {
+        panic!("dealloc should be never called")
+    }
+}
+
+/// A wrapper around spin::Mutex to permit trait implementations.
+pub struct Locked<A> {
+    inner: spin::Mutex<A>,
+}
+
+impl<A> Locked<A> {
+    pub const fn new(inner: A) -> Self {
+        Locked {
+            inner: spin::Mutex::new(inner),
+        }
+    }
+
+    pub fn lock(&self) -> spin::MutexGuard<A> {
+        self.inner.lock()
+    }
+}
+
+fn align_up(addr: usize, align: usize) -> usize {
+    let remainder = addr % align;
+    if remainder == 0 {
+        addr // addr already aligned
+    } else {
+        addr - remainder + align
+    }
+}
--- a/src/bin/test-basic-boot.rs
+++ b/src/bin/test-basic-boot.rs
@@ -1,33 +0,0 @@
-#![cfg_attr(not(test), no_std)]
-#![cfg_attr(not(test), no_main)] // disable all Rust-level entry points
-#![cfg_attr(test, allow(unused_imports))]
-
-use blog_os::{exit_qemu, serial_println};
-use core::panic::PanicInfo;
-
-/// This function is the entry point, since the linker looks for a function
-/// named `_start` by default.
-#[cfg(not(test))]
-#[no_mangle] // don't mangle the name of this function
-pub extern "C" fn _start() -> ! {
-    serial_println!("ok");
-
-    unsafe {
-        exit_qemu();
-    }
-    loop {}
-}
-
-/// This function is called on panic.
-#[cfg(not(test))]
-#[panic_handler]
-fn panic(info: &PanicInfo) -> ! {
-    serial_println!("failed");
-
-    serial_println!("{}", info);
-
-    unsafe {
-        exit_qemu();
-    }
-    loop {}
-}
--- a/src/bin/test-exception-breakpoint.rs
+++ b/src/bin/test-exception-breakpoint.rs
@@ -1,34 +0,0 @@
-#![no_std]
-#![cfg_attr(not(test), no_main)]
-#![cfg_attr(test, allow(dead_code, unused_macros, unused_imports))]
-
-use blog_os::{exit_qemu, serial_println};
-use core::panic::PanicInfo;
-
-#[cfg(not(test))]
-#[no_mangle]
-pub extern "C" fn _start() -> ! {
-    blog_os::interrupts::init_idt();
-
-    x86_64::instructions::interrupts::int3();
-
-    serial_println!("ok");
-
-    unsafe {
-        exit_qemu();
-    }
-    loop {}
-}
-
-#[cfg(not(test))]
-#[panic_handler]
-fn panic(info: &PanicInfo) -> ! {
-    serial_println!("failed");
-
-    serial_println!("{}", info);
-
-    unsafe {
-        exit_qemu();
-    }
-    loop {}
-}
--- a/src/bin/test-panic.rs
+++ b/src/bin/test-panic.rs
@@ -1,23 +0,0 @@
-#![cfg_attr(not(test), no_std)]
-#![cfg_attr(not(test), no_main)]
-#![cfg_attr(test, allow(unused_imports))]
-
-use blog_os::{exit_qemu, serial_println};
-use core::panic::PanicInfo;
-
-#[cfg(not(test))]
-#[no_mangle]
-pub extern "C" fn _start() -> ! {
-    panic!();
-}
-
-#[cfg(not(test))]
-#[panic_handler]
-fn panic(_info: &PanicInfo) -> ! {
-    serial_println!("ok");
-
-    unsafe {
-        exit_qemu();
-    }
-    loop {}
-}
--- a/src/interrupts.rs
+++ b/src/interrupts.rs
@@ -1,9 +1,3 @@
-// The x86-interrupt calling convention leads to the following LLVM error
-// when compiled for a Windows target: "offset is not a multiple of 16". This
-// happens for example when running `cargo test` on Windows. To avoid this
-// problem we skip compilation of this module on Windows.
-#![cfg(not(windows))]
-
 use crate::{gdt, hlt_loop, print, println};
 use lazy_static::lazy_static;
 use pic8259_simple::ChainedPics;
@@ -59,13 +53,13 @@ extern "x86-interrupt" fn breakpoint_handler(stack_frame: &mut InterruptStackFra

 extern "x86-interrupt" fn page_fault_handler(
    stack_frame: &mut InterruptStackFrame,
-    _error_code: PageFaultErrorCode,
+    error_code: PageFaultErrorCode,
 ) {
-    use crate::hlt_loop;
    use x86_64::registers::control::Cr2;

    println!("EXCEPTION: PAGE FAULT");
    println!("Accessed Address: {:?}", Cr2::read());
+    println!("Error Code: {:?}", error_code);
    println!("{:#?}", stack_frame);
    hlt_loop();
 }
@@ -73,9 +67,8 @@ extern "x86-interrupt" fn page_fault_handler(
 extern "x86-interrupt" fn double_fault_handler(
    stack_frame: &mut InterruptStackFrame,
    _error_code: u64,
-) {
-    println!("EXCEPTION: DOUBLE FAULT\n{:#?}", stack_frame);
-    hlt_loop();
+) -> ! {
+    panic!("EXCEPTION: DOUBLE FAULT\n{:#?}", stack_frame);
 }

 extern "x86-interrupt" fn timer_interrupt_handler(_stack_frame: &mut InterruptStackFrame) {
@@ -84,6 +77,7 @@ extern "x86-interrupt" fn timer_interrupt_handler(_stack_frame: &mut InterruptSt
        PICS.lock()
            .notify_end_of_interrupt(InterruptIndex::Timer.as_u8());
    }
+    crate::multitasking::invoke_scheduler();
 }

 extern "x86-interrupt" fn keyboard_interrupt_handler(_stack_frame: &mut InterruptStackFrame) {
@@ -97,7 +91,7 @@ extern "x86-interrupt" fn keyboard_interrupt_handler(_stack_frame: &mut Interrup
    }

    let mut keyboard = KEYBOARD.lock();
-    let port = Port::new(0x60);
+    let mut port = Port::new(0x60);

    let scancode: u8 = unsafe { port.read() };
    if let Ok(Some(key_event)) = keyboard.add_byte(scancode) {
@@ -114,3 +108,14 @@ extern "x86-interrupt" fn keyboard_interrupt_handler(_stack_frame: &mut Interrup
            .notify_end_of_interrupt(InterruptIndex::Keyboard.as_u8());
    }
 }
+
+#[cfg(test)]
+use crate::{serial_print, serial_println};
+
+#[test_case]
+fn test_breakpoint_exception() {
+    serial_print!("test_breakpoint_exception...");
+    // invoke a breakpoint exception
+    x86_64::instructions::interrupts::int3();
+    serial_println!("[ok]");
+}
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,17 +1,68 @@
-#![cfg_attr(not(test), no_std)]
+#![no_std]
+#![cfg_attr(test, no_main)]
+#![feature(custom_test_frameworks)]
 #![feature(abi_x86_interrupt)]
+#![feature(alloc_error_handler)]
+#![feature(const_fn)]
+#![feature(alloc_layout_extra)]
+#![feature(const_in_array_repeat_expressions)]
+#![feature(global_asm)]
+#![feature(asm)]
+#![feature(raw)]
+#![feature(never_type)]
+#![feature(naked_functions)]
+#![feature(option_expect_none)]
+#![test_runner(crate::test_runner)]
+#![reexport_test_harness_main = "test_main"]

+extern crate alloc;
+
+use core::panic::PanicInfo;
+
+pub mod allocator;
 pub mod gdt;
 pub mod interrupts;
 pub mod memory;
+pub mod multitasking;
 pub mod serial;
 pub mod vga_buffer;

-pub unsafe fn exit_qemu() {
+pub fn init() {
+    gdt::init();
+    interrupts::init_idt();
+    unsafe { interrupts::PICS.lock().initialize() };
+    x86_64::instructions::interrupts::enable();
+}
+
+pub fn test_runner(tests: &[&dyn Fn()]) {
+    serial_println!("Running {} tests", tests.len());
+    for test in tests {
+        test();
+    }
+    exit_qemu(QemuExitCode::Success);
+}
+
+pub fn test_panic_handler(info: &PanicInfo) -> ! {
+    serial_println!("[failed]\n");
+    serial_println!("Error: {}\n", info);
+    exit_qemu(QemuExitCode::Failed);
+    hlt_loop();
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[repr(u32)]
+pub enum QemuExitCode {
+    Success = 0x10,
+    Failed = 0x11,
+}
+
+pub fn exit_qemu(exit_code: QemuExitCode) {
    use x86_64::instructions::port::Port;

-    let mut port = Port::<u32>::new(0xf4);
-    port.write(0);
+    unsafe {
+        let mut port = Port::new(0xf4);
+        port.write(exit_code as u32);
+    }
 }

 pub fn hlt_loop() -> ! {
@@ -19,3 +70,28 @@ pub fn hlt_loop() -> ! {
        x86_64::instructions::hlt();
    }
 }
+
+#[cfg(test)]
+use bootloader::{entry_point, BootInfo};
+
+#[cfg(test)]
+entry_point!(test_kernel_main);
+
+/// Entry point for `cargo xtest`
+#[cfg(test)]
+fn test_kernel_main(_boot_info: &'static BootInfo) -> ! {
+    init();
+    test_main();
+    hlt_loop();
+}
+
+#[cfg(test)]
+#[panic_handler]
+fn panic(info: &PanicInfo) -> ! {
+    test_panic_handler(info)
+}
+
+#[alloc_error_handler]
+fn alloc_error_handler(layout: alloc::alloc::Layout) -> ! {
+    panic!("allocation error: {:?}", layout)
+}
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,45 +1,105 @@
-#![cfg_attr(not(test), no_std)]
-#![cfg_attr(not(test), no_main)]
-#![cfg_attr(test, allow(unused_imports))]
+#![no_std]
+#![no_main]
+#![feature(custom_test_frameworks)]
+#![test_runner(blog_os::test_runner)]
+#![reexport_test_harness_main = "test_main"]

-use blog_os::println;
+extern crate alloc;
+
+use alloc::{boxed::Box, rc::Rc, vec, vec::Vec};
+use blog_os::multitasking::{self, thread::Thread, with_scheduler};
+use blog_os::{print, println};
 use bootloader::{entry_point, BootInfo};
 use core::panic::PanicInfo;

 entry_point!(kernel_main);

-#[cfg(not(test))]
 fn kernel_main(boot_info: &'static BootInfo) -> ! {
-    use blog_os::interrupts::PICS;
-    use blog_os::memory;
-    use x86_64::{structures::paging::Page, VirtAddr};
+    use blog_os::allocator;
+    use blog_os::memory::{self, BootInfoFrameAllocator};
+    use x86_64::VirtAddr;

    println!("Hello World{}", "!");
+    blog_os::init();

-    blog_os::gdt::init();
-    blog_os::interrupts::init_idt();
-    unsafe { PICS.lock().initialize() };
-    x86_64::instructions::interrupts::enable();
+    let phys_mem_offset = VirtAddr::new(boot_info.physical_memory_offset);
+    let mut mapper = unsafe { memory::init(phys_mem_offset) };
+    let mut frame_allocator = unsafe { BootInfoFrameAllocator::init(&boot_info.memory_map) };

-    let mut mapper = unsafe { memory::init(boot_info.physical_memory_offset) };
-    let mut frame_allocator = memory::init_frame_allocator(&boot_info.memory_map);
+    allocator::init_heap(&mut mapper, &mut frame_allocator).expect("heap initialization failed");

-    // map a previously unmapped page
-    let page = Page::containing_address(VirtAddr::new(0xdeadbeaf000));
-    memory::create_example_mapping(page, &mut mapper, &mut frame_allocator);
+    // allocate a number on the heap
+    let heap_value = Box::new(41);
+    println!("heap_value at {:p}", heap_value);

-    // write the string `New!` to the screen through the new mapping
-    let page_ptr: *mut u64 = page.start_address().as_mut_ptr();
-    unsafe { page_ptr.offset(400).write_volatile(0x_f021_f077_f065_f04e) };
+    // create a dynamically sized vector
+    let mut vec = Vec::new();
+    for i in 0..500 {
+        vec.push(i);
+    }
+    println!("vec at {:p}", vec.as_slice());
+
+    // create a reference counted vector -> will be freed when count reaches 0
+    let reference_counted = Rc::new(vec![1, 2, 3]);
+    let cloned_reference = reference_counted.clone();
+    println!(
+        "current reference count is {}",
+        Rc::strong_count(&cloned_reference)
+    );
+    core::mem::drop(reference_counted);
+    println!(
+        "reference count is {} now",
+        Rc::strong_count(&cloned_reference)
+    );
+
+    #[cfg(test)]
+    test_main();
+
+    let idle_thread = Thread::create(idle_thread, 2, &mut mapper, &mut frame_allocator).unwrap();
+    with_scheduler(|s| s.set_idle_thread(idle_thread));
+
+    for _ in 0..10 {
+        let thread = Thread::create(thread_entry, 2, &mut mapper, &mut frame_allocator).unwrap();
+        with_scheduler(|s| s.add_new_thread(thread));
+    }
+    let thread =
+        Thread::create_from_closure(|| thread_entry(), 2, &mut mapper, &mut frame_allocator)
+            .unwrap();
+    with_scheduler(|s| s.add_new_thread(thread));

    println!("It did not crash!");
-    blog_os::hlt_loop();
+    thread_entry();
+}
+
+fn idle_thread() -> ! {
+    loop {
+        x86_64::instructions::hlt();
+        multitasking::yield_now();
+    }
+}
+
+fn thread_entry() -> ! {
+    let thread_id = with_scheduler(|s| s.current_thread_id()).as_u64();
+    for _ in 0..=thread_id {
+        print!("{}", thread_id);
+        x86_64::instructions::hlt();
+    }
+    multitasking::exit_thread();
 }

 /// This function is called on panic.
 #[cfg(not(test))]
 #[panic_handler]
 fn panic(info: &PanicInfo) -> ! {
+    unsafe {
+        blog_os::vga_buffer::WRITER.force_unlock();
+    }
    println!("{}", info);
    blog_os::hlt_loop();
 }
+
+#[cfg(test)]
+#[panic_handler]
+fn panic(info: &PanicInfo) -> ! {
+    blog_os::test_panic_handler(info)
+}
--- a/src/memory.rs
+++ b/src/memory.rs
@@ -1,44 +1,21 @@
 use bootloader::bootinfo::{MemoryMap, MemoryRegionType};
 use x86_64::{
    structures::paging::{
-        FrameAllocator, MappedPageTable, Mapper, MapperAllSizes, Page, PageTable, PhysFrame,
-        Size4KiB,
+        mapper, FrameAllocator, Mapper, OffsetPageTable, Page, PageTable, PhysFrame, Size4KiB,
+        UnusedPhysFrame,
    },
    PhysAddr, VirtAddr,
 };

-/// Initialize a new MappedPageTable.
+/// Initialize a new OffsetPageTable.
 ///
 /// This function is unsafe because the caller must guarantee that the
 /// complete physical memory is mapped to virtual memory at the passed
 /// `physical_memory_offset`. Also, this function must be only called once
 /// to avoid aliasing `&mut` references (which is undefined behavior).
-pub unsafe fn init(physical_memory_offset: u64) -> impl MapperAllSizes {
+pub unsafe fn init(physical_memory_offset: VirtAddr) -> OffsetPageTable<'static> {
    let level_4_table = active_level_4_table(physical_memory_offset);
-    let phys_to_virt = move |frame: PhysFrame| -> *mut PageTable {
-        let phys = frame.start_address().as_u64();
-        let virt = VirtAddr::new(phys + physical_memory_offset);
-        virt.as_mut_ptr()
-    };
-    MappedPageTable::new(level_4_table, phys_to_virt)
-}
-
-/// Create a FrameAllocator from the passed memory map
-pub fn init_frame_allocator(
-    memory_map: &'static MemoryMap,
-) -> BootInfoFrameAllocator<impl Iterator<Item = PhysFrame>> {
-    // get usable regions from memory map
-    let regions = memory_map
-        .iter()
-        .filter(|r| r.region_type == MemoryRegionType::Usable);
-    // map each region to its address range
-    let addr_ranges = regions.map(|r| r.range.start_addr()..r.range.end_addr());
-    // transform to an iterator of frame start addresses
-    let frame_addresses = addr_ranges.flat_map(|r| r.into_iter().step_by(4096));
-    // create `PhysFrame` types from the start addresses
-    let frames = frame_addresses.map(|addr| PhysFrame::containing_address(PhysAddr::new(addr)));
-
-    BootInfoFrameAllocator { frames }
+    OffsetPageTable::new(level_4_table, physical_memory_offset)
 }

 /// Returns a mutable reference to the active level 4 table.
@@ -47,54 +24,131 @@ pub fn init_frame_allocator(
 /// complete physical memory is mapped to virtual memory at the passed
 /// `physical_memory_offset`. Also, this function must be only called once
 /// to avoid aliasing `&mut` references (which is undefined behavior).
-unsafe fn active_level_4_table(physical_memory_offset: u64) -> &'static mut PageTable {
-    use x86_64::{registers::control::Cr3, VirtAddr};
+unsafe fn active_level_4_table(physical_memory_offset: VirtAddr) -> &'static mut PageTable {
+    use x86_64::registers::control::Cr3;

    let (level_4_table_frame, _) = Cr3::read();

    let phys = level_4_table_frame.start_address();
-    let virt = VirtAddr::new(phys.as_u64() + physical_memory_offset);
+    let virt = physical_memory_offset + phys.as_u64();
    let page_table_ptr: *mut PageTable = virt.as_mut_ptr();

    &mut *page_table_ptr // unsafe
 }

+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct StackBounds {
+    start: VirtAddr,
+    end: VirtAddr,
+}
+
+impl StackBounds {
+    pub fn start(&self) -> VirtAddr {
+        self.start
+    }
+
+    pub fn end(&self) -> VirtAddr {
+        self.end
+    }
+}
+
+pub fn alloc_stack(
+    size_in_pages: u64,
+    mapper: &mut impl Mapper<Size4KiB>,
+    frame_allocator: &mut impl FrameAllocator<Size4KiB>,
+) -> Result<StackBounds, mapper::MapToError> {
+    use core::sync::atomic::{AtomicU64, Ordering};
+    use x86_64::structures::paging::PageTableFlags as Flags;
+
+    static STACK_ALLOC_NEXT: AtomicU64 = AtomicU64::new(0x_5555_5555_0000);
+
+    let guard_page_start = STACK_ALLOC_NEXT.fetch_add(
+        (size_in_pages + 1) * Page::<Size4KiB>::SIZE,
+        Ordering::SeqCst,
+    );
+    let guard_page = Page::from_start_address(VirtAddr::new(guard_page_start))
+        .expect("`STACK_ALLOC_NEXT` not page aligned");
+
+    let stack_start = guard_page + 1;
+    let stack_end = stack_start + size_in_pages;
+    let flags = Flags::PRESENT | Flags::WRITABLE;
+    for page in Page::range(stack_start, stack_end) {
+        let frame = frame_allocator
+            .allocate_frame()
+            .ok_or(mapper::MapToError::FrameAllocationFailed)?;
+        mapper.map_to(page, frame, flags, frame_allocator)?.flush();
+    }
+    Ok(StackBounds {
+        start: stack_start.start_address(),
+        end: stack_end.start_address(),
+    })
+}
+
 /// Creates an example mapping for the given page to frame `0xb8000`.
 pub fn create_example_mapping(
    page: Page,
-    mapper: &mut impl Mapper<Size4KiB>,
+    mapper: &mut OffsetPageTable,
    frame_allocator: &mut impl FrameAllocator<Size4KiB>,
 ) {
    use x86_64::structures::paging::PageTableFlags as Flags;

    let frame = PhysFrame::containing_address(PhysAddr::new(0xb8000));
+    // FIXME: ONLY FOR TEMPORARY TESTING
+    let unused_frame = unsafe { UnusedPhysFrame::new(frame) };
    let flags = Flags::PRESENT | Flags::WRITABLE;

-    let map_to_result = unsafe { mapper.map_to(page, frame, flags, frame_allocator) };
+    let map_to_result = mapper.map_to(page, unused_frame, flags, frame_allocator);
    map_to_result.expect("map_to failed").flush();
 }

 /// A FrameAllocator that always returns `None`.
 pub struct EmptyFrameAllocator;

-impl FrameAllocator<Size4KiB> for EmptyFrameAllocator {
-    fn allocate_frame(&mut self) -> Option<PhysFrame> {
+unsafe impl FrameAllocator<Size4KiB> for EmptyFrameAllocator {
+    fn allocate_frame(&mut self) -> Option<UnusedPhysFrame> {
        None
    }
 }

-pub struct BootInfoFrameAllocator<I>
-where
-    I: Iterator<Item = PhysFrame>,
-{
-    frames: I,
+/// A FrameAllocator that returns usable frames from the bootloader's memory map.
+pub struct BootInfoFrameAllocator {
+    memory_map: &'static MemoryMap,
+    next: usize,
 }

-impl<I> FrameAllocator<Size4KiB> for BootInfoFrameAllocator<I>
-where
-    I: Iterator<Item = PhysFrame>,
-{
-    fn allocate_frame(&mut self) -> Option<PhysFrame> {
-        self.frames.next()
+impl BootInfoFrameAllocator {
+    /// Create a FrameAllocator from the passed memory map.
+    ///
+    /// This function is unsafe because the caller must guarantee that the passed
+    /// memory map is valid. The main requirement is that all frames that are marked
+    /// as `USABLE` in it are really unused.
+    pub unsafe fn init(memory_map: &'static MemoryMap) -> Self {
+        BootInfoFrameAllocator {
+            memory_map,
+            next: 0,
+        }
+    }
+
+    /// Returns an iterator over the usable frames specified in the memory map.
+    fn usable_frames(&self) -> impl Iterator<Item = UnusedPhysFrame> {
+        // get usable regions from memory map
+        let regions = self.memory_map.iter();
+        let usable_regions = regions.filter(|r| r.region_type == MemoryRegionType::Usable);
+        // map each region to its address range
+        let addr_ranges = usable_regions.map(|r| r.range.start_addr()..r.range.end_addr());
+        // transform to an iterator of frame start addresses
+        let frame_addresses = addr_ranges.flat_map(|r| r.step_by(4096));
+        // create `PhysFrame` types from the start addresses
+        let frames = frame_addresses.map(|addr| PhysFrame::containing_address(PhysAddr::new(addr)));
+        // we know that the frames are really unused
+        frames.map(|f| unsafe { UnusedPhysFrame::new(f) })
+    }
+}
+
+unsafe impl FrameAllocator<Size4KiB> for BootInfoFrameAllocator {
+    fn allocate_frame(&mut self) -> Option<UnusedPhysFrame> {
+        let frame = self.usable_frames().nth(self.next);
+        self.next += 1;
+        frame
    }
 }
--- a/src/multitasking/context_switch.rs
+++ b/src/multitasking/context_switch.rs
@@ -0,0 +1,105 @@
+use super::{with_scheduler, SwitchReason};
+use crate::multitasking::thread::ThreadId;
+use alloc::boxed::Box;
+use core::mem;
+use core::raw::TraitObject;
+use x86_64::VirtAddr;
+
+pub struct Stack {
+    pointer: VirtAddr,
+}
+
+impl Stack {
+    pub unsafe fn new(stack_pointer: VirtAddr) -> Self {
+        Stack {
+            pointer: stack_pointer,
+        }
+    }
+
+    pub fn get_stack_pointer(self) -> VirtAddr {
+        self.pointer
+    }
+
+    pub fn set_up_for_closure(&mut self, closure: Box<dyn FnOnce() -> !>) {
+        let trait_object: TraitObject = unsafe { mem::transmute(closure) };
+        unsafe { self.push(trait_object.data) };
+        unsafe { self.push(trait_object.vtable) };
+
+        self.set_up_for_entry_point(call_closure_entry);
+    }
+
+    pub fn set_up_for_entry_point(&mut self, entry_point: fn() -> !) {
+        unsafe { self.push(entry_point) };
+        let rflags: u64 = 0x200;
+        unsafe { self.push(rflags) };
+    }
+
+    unsafe fn push<T>(&mut self, value: T) {
+        self.pointer -= core::mem::size_of::<T>();
+        let ptr: *mut T = self.pointer.as_mut_ptr();
+        ptr.write(value);
+    }
+}
+
+pub unsafe fn context_switch_to(
+    new_stack_pointer: VirtAddr,
+    prev_thread_id: ThreadId,
+    switch_reason: SwitchReason,
+) {
+    asm!(
+        "call asm_context_switch"
+        :
+        : "{rdi}"(new_stack_pointer), "{rsi}"(prev_thread_id), "{rdx}"(switch_reason as u64)
+        : "rax", "rbx", "rcx", "rdx", "rsi", "rdi", "rbp", "r8", "r9", "r10",
+        "r11", "r12", "r13", "r14", "r15", "rflags", "memory"
+        : "intel", "volatile"
+    );
+}
+
+global_asm!(
+    "
+    .intel_syntax noprefix
+
+    // asm_context_switch(stack_pointer: u64, thread_id: u64)
+    asm_context_switch:
+        pushfq
+
+        mov rax, rsp
+        mov rsp, rdi
+
+        mov rdi, rax
+        call add_paused_thread
+
+        popfq
+        ret
+"
+);
+
+#[no_mangle]
+pub extern "C" fn add_paused_thread(
+    paused_stack_pointer: VirtAddr,
+    paused_thread_id: ThreadId,
+    switch_reason: SwitchReason,
+) {
+    with_scheduler(|s| s.add_paused_thread(paused_stack_pointer, paused_thread_id, switch_reason));
+}
+
+#[naked]
+fn call_closure_entry() -> ! {
+    unsafe {
+        asm!("
+        pop rsi
+        pop rdi
+        call call_closure
+    " ::: "mem" : "intel", "volatile")
+    };
+    unreachable!();
+}
+
+// no_mangle required because of https://github.com/rust-lang/rust/issues/68136
+#[no_mangle]
+extern "C" fn call_closure(data: *mut (), vtable: *mut ()) -> ! {
+    let trait_object = TraitObject { data, vtable };
+    let f: Box<dyn FnOnce() -> !> = unsafe { mem::transmute(trait_object) };
+    f()
+}
--- a/src/multitasking/mod.rs
+++ b/src/multitasking/mod.rs
@@ -0,0 +1,57 @@
+use scheduler::Scheduler;
+
+pub mod context_switch;
+pub mod scheduler;
+pub mod thread;
+
+static SCHEDULER: spin::Mutex<Option<Scheduler>> = spin::Mutex::new(None);
+
+#[repr(u64)]
+pub enum SwitchReason {
+    Paused,
+    Yield,
+    Blocked,
+    Exit,
+}
+
+pub fn invoke_scheduler() {
+    let next = SCHEDULER
+        .try_lock()
+        .and_then(|mut scheduler| scheduler.as_mut().and_then(|s| s.schedule()));
+    if let Some((next_stack_pointer, prev_thread_id)) = next {
+        unsafe {
+            context_switch::context_switch_to(
+                next_stack_pointer,
+                prev_thread_id,
+                SwitchReason::Paused,
+            )
+        };
+    }
+}
+
+pub fn exit_thread() -> ! {
+    synchronous_context_switch(SwitchReason::Exit).expect("can't exit last thread");
+    unreachable!("finished thread continued");
+}
+
+pub fn yield_now() {
+    let _ = synchronous_context_switch(SwitchReason::Yield);
+}
+
+fn synchronous_context_switch(reason: SwitchReason) -> Result<(), ()> {
+    let next = with_scheduler(|s| s.schedule());
+    match next {
+        Some((next_stack_pointer, prev_thread_id)) => unsafe {
+            context_switch::context_switch_to(next_stack_pointer, prev_thread_id, reason);
+            Ok(())
+        },
+        None => Err(()),
+    }
+}
+
+pub fn with_scheduler<F, T>(f: F) -> T
+where
+    F: FnOnce(&mut Scheduler) -> T,
+{
+    f(SCHEDULER.lock().get_or_insert_with(Scheduler::new))
+}
--- a/src/multitasking/scheduler.rs
+++ b/src/multitasking/scheduler.rs
@@ -0,0 +1,122 @@
+use super::SwitchReason;
+use crate::multitasking::thread::{Thread, ThreadId};
+use alloc::collections::{BTreeMap, BTreeSet, VecDeque};
+use core::mem;
+use x86_64::VirtAddr;
+
+pub struct Scheduler {
+    threads: BTreeMap<ThreadId, Thread>,
+    idle_thread_id: Option<ThreadId>,
+    current_thread_id: ThreadId,
+    paused_threads: VecDeque<ThreadId>,
+    blocked_threads: BTreeSet<ThreadId>,
+    wakeups: BTreeSet<ThreadId>,
+}
+
+impl Scheduler {
+    pub fn new() -> Self {
+        let root_thread = Thread::create_root_thread();
+        let root_id = root_thread.id();
+        let mut threads = BTreeMap::new();
+        threads
+            .insert(root_id, root_thread)
+            .expect_none("map is not empty after creation");
+        Scheduler {
+            threads,
+            current_thread_id: root_id,
+            paused_threads: VecDeque::new(),
+            blocked_threads: BTreeSet::new(),
+            wakeups: BTreeSet::new(),
+            idle_thread_id: None,
+        }
+    }
+
+    fn next_thread(&mut self) -> Option<ThreadId> {
+        self.paused_threads.pop_front()
+    }
+
+    pub fn schedule(&mut self) -> Option<(VirtAddr, ThreadId)> {
+        let mut next_thread_id = self.next_thread();
+        if next_thread_id.is_none() && Some(self.current_thread_id) != self.idle_thread_id {
+            next_thread_id = self.idle_thread_id
+        }
+        if let Some(next_id) = next_thread_id {
+            let next_thread = self
+                .threads
+                .get_mut(&next_id)
+                .expect("next thread does not exist");
+            let next_stack_pointer = next_thread
+                .stack_pointer()
+                .take()
+                .expect("paused thread has no stack pointer");
+            let prev_thread_id = mem::replace(&mut self.current_thread_id, next_thread.id());
+            Some((next_stack_pointer, prev_thread_id))
+        } else {
+            None
+        }
+    }
+
+    pub(super) fn add_paused_thread(
+        &mut self,
+        paused_stack_pointer: VirtAddr,
+        paused_thread_id: ThreadId,
+        switch_reason: SwitchReason,
+    ) {
+        let paused_thread = self
+            .threads
+            .get_mut(&paused_thread_id)
+            .expect("paused thread does not exist");
+        paused_thread
+            .stack_pointer()
+            .replace(paused_stack_pointer)
+            .expect_none("running thread should have stack pointer set to None");
+        if Some(paused_thread_id) == self.idle_thread_id {
+            return; // do nothing
+        }
+        match switch_reason {
+            SwitchReason::Paused | SwitchReason::Yield => {
+                self.paused_threads.push_back(paused_thread_id)
+            }
+            SwitchReason::Blocked => {
+                self.blocked_threads.insert(paused_thread_id);
+                self.check_for_wakeup(paused_thread_id);
+            }
+            SwitchReason::Exit => {
+                let thread = self
+                    .threads
+                    .remove(&paused_thread_id)
+                    .expect("thread not found");
+                // TODO: free stack memory again
+            }
+        }
+    }
+
+    pub fn add_new_thread(&mut self, thread: Thread) {
+        let thread_id = thread.id();
+        self.threads
+            .insert(thread_id, thread)
+            .expect_none("thread already exists");
+        self.paused_threads.push_back(thread_id);
+    }
+
+    pub fn set_idle_thread(&mut self, thread: Thread) {
+        let thread_id = thread.id();
+        self.threads
+            .insert(thread_id, thread)
+            .expect_none("thread already exists");
+        self.idle_thread_id
+            .replace(thread_id)
+            .expect_none("idle thread should be set only once");
+    }
+
+    pub fn current_thread_id(&self) -> ThreadId {
+        self.current_thread_id
+    }
+
+    fn check_for_wakeup(&mut self, thread_id: ThreadId) {
+        if self.wakeups.remove(&thread_id) {
+            assert!(self.blocked_threads.remove(&thread_id));
+            self.paused_threads.push_back(thread_id);
+        }
+    }
+}
--- a/src/multitasking/thread.rs
+++ b/src/multitasking/thread.rs
@@ -0,0 +1,82 @@
+use crate::memory::{alloc_stack, StackBounds};
+use crate::multitasking::context_switch::Stack;
+use alloc::boxed::Box;
+use x86_64::{
+    structures::paging::{mapper, FrameAllocator, Mapper, Size4KiB},
+    VirtAddr,
+};
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
+pub struct ThreadId(u64);
+
+impl ThreadId {
+    pub fn as_u64(&self) -> u64 {
+        self.0
+    }
+
+    fn new() -> Self {
+        use core::sync::atomic::{AtomicU64, Ordering};
+        static NEXT_THREAD_ID: AtomicU64 = AtomicU64::new(1);
+        ThreadId(NEXT_THREAD_ID.fetch_add(1, Ordering::SeqCst))
+    }
+}
+
+#[derive(Debug)]
+pub struct Thread {
+    id: ThreadId,
+    stack_pointer: Option<VirtAddr>,
+    stack_bounds: Option<StackBounds>,
+}
+
+impl Thread {
+    pub fn create(
+        entry_point: fn() -> !,
+        stack_size: u64,
+        mapper: &mut impl Mapper<Size4KiB>,
+        frame_allocator: &mut impl FrameAllocator<Size4KiB>,
+    ) -> Result<Self, mapper::MapToError> {
+        let stack_bounds = alloc_stack(stack_size, mapper, frame_allocator)?;
+        let mut stack = unsafe { Stack::new(stack_bounds.end()) };
+        stack.set_up_for_entry_point(entry_point);
+        Ok(Self::new(stack.get_stack_pointer(), stack_bounds))
+    }
+
+    pub fn create_from_closure<F>(
+        closure: F,
+        stack_size: u64,
+        mapper: &mut impl Mapper<Size4KiB>,
+        frame_allocator: &mut impl FrameAllocator<Size4KiB>,
+    ) -> Result<Self, mapper::MapToError>
+    where
+        F: FnOnce() -> ! + 'static + Send + Sync,
+    {
+        let stack_bounds = alloc_stack(stack_size, mapper, frame_allocator)?;
+        let mut stack = unsafe { Stack::new(stack_bounds.end()) };
+        stack.set_up_for_closure(Box::new(closure));
+        Ok(Self::new(stack.get_stack_pointer(), stack_bounds))
+    }
+
+    fn new(stack_pointer: VirtAddr, stack_bounds: StackBounds) -> Self {
+        Thread {
+            id: ThreadId::new(),
+            stack_pointer: Some(stack_pointer),
+            stack_bounds: Some(stack_bounds),
+        }
+    }
+
+    pub(super) fn create_root_thread() -> Self {
+        Thread {
+            id: ThreadId(0),
+            stack_pointer: None,
+            stack_bounds: None,
+        }
+    }
+
+    pub fn id(&self) -> ThreadId {
+        self.id
+    }
+
+    pub(super) fn stack_pointer(&mut self) -> &mut Option<VirtAddr> {
+        &mut self.stack_pointer
+    }
+}
--- a/src/serial.rs
+++ b/src/serial.rs
@@ -4,7 +4,7 @@ use uart_16550::SerialPort;

 lazy_static! {
    pub static ref SERIAL1: Mutex<SerialPort> = {
-        let mut serial_port = SerialPort::new(0x3F8);
+        let mut serial_port = unsafe { SerialPort::new(0x3F8) };
        serial_port.init();
        Mutex::new(serial_port)
    };
@@ -36,5 +36,6 @@ macro_rules! serial_print {
 macro_rules! serial_println {
    () => ($crate::serial_print!("\n"));
    ($fmt:expr) => ($crate::serial_print!(concat!($fmt, "\n")));
-    ($fmt:expr, $($arg:tt)*) => ($crate::serial_print!(concat!($fmt, "\n"), $($arg)*));
+    ($fmt:expr, $($arg:tt)*) => ($crate::serial_print!(
+        concat!($fmt, "\n"), $($arg)*));
 }
--- a/src/vga_buffer.rs
+++ b/src/vga_buffer.rs
@@ -3,6 +3,9 @@ use lazy_static::lazy_static;
 use spin::Mutex;
 use volatile::Volatile;

+#[cfg(test)]
+use crate::{serial_print, serial_println};
+
 lazy_static! {
    /// A global `Writer` instance that can be used for printing to the VGA text buffer.
    ///
@@ -112,7 +115,7 @@ impl Writer {
        for byte in s.bytes() {
            match byte {
                // printable ASCII byte or newline
-                0x20...0x7e | b'\n' => self.write_byte(byte),
+                0x20..=0x7e | b'\n' => self.write_byte(byte),
                // not part of printable ASCII range
                _ => self.write_byte(0xfe),
            }
@@ -175,85 +178,38 @@ pub fn _print(args: fmt::Arguments) {
    });
 }

-#[cfg(test)]
-mod test {
-    use super::*;
-
-    fn construct_writer() -> Writer {
-        use std::boxed::Box;
-
-        let buffer = construct_buffer();
-        Writer {
-            column_position: 0,
-            color_code: ColorCode::new(Color::Blue, Color::Magenta),
-            buffer: Box::leak(Box::new(buffer)),
-        }
-    }
-
-    fn construct_buffer() -> Buffer {
-        use array_init::array_init;
-
-        Buffer {
-            chars: array_init(|_| array_init(|_| Volatile::new(empty_char()))),
-        }
-    }
-
-    fn empty_char() -> ScreenChar {
-        ScreenChar {
-            ascii_character: b' ',
-            color_code: ColorCode::new(Color::Green, Color::Brown),
-        }
-    }
-
-    #[test]
-    fn write_byte() {
-        let mut writer = construct_writer();
-        writer.write_byte(b'X');
-        writer.write_byte(b'Y');
-
-        for (i, row) in writer.buffer.chars.iter().enumerate() {
-            for (j, screen_char) in row.iter().enumerate() {
-                let screen_char = screen_char.read();
-                if i == BUFFER_HEIGHT - 1 && j == 0 {
-                    assert_eq!(screen_char.ascii_character, b'X');
-                    assert_eq!(screen_char.color_code, writer.color_code);
-                } else if i == BUFFER_HEIGHT - 1 && j == 1 {
-                    assert_eq!(screen_char.ascii_character, b'Y');
-                    assert_eq!(screen_char.color_code, writer.color_code);
-                } else {
-                    assert_eq!(screen_char, empty_char());
-                }
-            }
-        }
-    }
-
-    #[test]
-    fn write_formatted() {
-        use core::fmt::Write;
-
-        let mut writer = construct_writer();
-        writeln!(&mut writer, "a").unwrap();
-        writeln!(&mut writer, "b{}", "c").unwrap();
-
-        for (i, row) in writer.buffer.chars.iter().enumerate() {
-            for (j, screen_char) in row.iter().enumerate() {
-                let screen_char = screen_char.read();
-                if i == BUFFER_HEIGHT - 3 && j == 0 {
-                    assert_eq!(screen_char.ascii_character, b'a');
-                    assert_eq!(screen_char.color_code, writer.color_code);
-                } else if i == BUFFER_HEIGHT - 2 && j == 0 {
-                    assert_eq!(screen_char.ascii_character, b'b');
-                    assert_eq!(screen_char.color_code, writer.color_code);
-                } else if i == BUFFER_HEIGHT - 2 && j == 1 {
-                    assert_eq!(screen_char.ascii_character, b'c');
-                    assert_eq!(screen_char.color_code, writer.color_code);
-                } else if i >= BUFFER_HEIGHT - 2 {
-                    assert_eq!(screen_char.ascii_character, b' ');
-                    assert_eq!(screen_char.color_code, writer.color_code);
-                } else {
-                    assert_eq!(screen_char, empty_char());
-                }
-            }
-        }
-    }
+#[test_case]
+fn test_println_simple() {
+    serial_print!("test_println... ");
+    println!("test_println_simple output");
+    serial_println!("[ok]");
+}
+
+#[test_case]
+fn test_println_many() {
+    serial_print!("test_println_many... ");
+    for _ in 0..200 {
+        println!("test_println_many output");
+    }
+    serial_println!("[ok]");
+}
+
+#[test_case]
+fn test_println_output() {
+    use core::fmt::Write;
+    use x86_64::instructions::interrupts;
+
+    serial_print!("test_println_output... ");
+
+    let s = "Some test string that fits on a single line";
+    interrupts::without_interrupts(|| {
+        let mut writer = WRITER.lock();
+        writeln!(writer, "\n{}", s).expect("writeln failed");
+        for (i, c) in s.chars().enumerate() {
+            let screen_char = writer.buffer.chars[BUFFER_HEIGHT - 2][i].read();
+            assert_eq!(char::from(screen_char.ascii_character), c);
+        }
+    });
+
+    serial_println!("[ok]");
 }
--- a/tests/basic_boot.rs
+++ b/tests/basic_boot.rs
@@ -0,0 +1,27 @@
+#![no_std]
+#![no_main]
+#![feature(custom_test_frameworks)]
+#![test_runner(blog_os::test_runner)]
+#![reexport_test_harness_main = "test_main"]
+
+use blog_os::{println, serial_print, serial_println};
+use core::panic::PanicInfo;
+
+#[no_mangle] // don't mangle the name of this function
+pub extern "C" fn _start() -> ! {
+    test_main();
+
+    loop {}
+}
+
+#[panic_handler]
+fn panic(info: &PanicInfo) -> ! {
+    blog_os::test_panic_handler(info)
+}
+
+#[test_case]
+fn test_println() {
+    serial_print!("test_println... ");
+    println!("test_println output");
+    serial_println!("[ok]");
+}
--- a/tests/heap_allocation.rs
+++ b/tests/heap_allocation.rs
@@ -0,0 +1,76 @@
+#![no_std]
+#![no_main]
+#![feature(custom_test_frameworks)]
+#![test_runner(blog_os::test_runner)]
+#![reexport_test_harness_main = "test_main"]
+
+extern crate alloc;
+
+use alloc::{boxed::Box, vec::Vec};
+use blog_os::{allocator::HEAP_SIZE, serial_print, serial_println};
+use bootloader::{entry_point, BootInfo};
+use core::panic::PanicInfo;
+
+entry_point!(main);
+
+fn main(boot_info: &'static BootInfo) -> ! {
+    use blog_os::allocator;
+    use blog_os::memory::{self, BootInfoFrameAllocator};
+    use x86_64::VirtAddr;
+
+    blog_os::init();
+    let phys_mem_offset = VirtAddr::new(boot_info.physical_memory_offset);
+    let mut mapper = unsafe { memory::init(phys_mem_offset) };
+    let mut frame_allocator = unsafe { BootInfoFrameAllocator::init(&boot_info.memory_map) };
+    allocator::init_heap(&mut mapper, &mut frame_allocator).expect("heap initialization failed");
+
+    test_main();
+    loop {}
+}
+
+#[test_case]
+fn simple_allocation() {
+    serial_print!("simple_allocation... ");
+    let heap_value = Box::new(41);
+    assert_eq!(*heap_value, 41);
+    serial_println!("[ok]");
+}
+
+#[test_case]
+fn large_vec() {
+    serial_print!("large_vec... ");
+    let n = 1000;
+    let mut vec = Vec::new();
+    for i in 0..n {
+        vec.push(i);
+    }
+    assert_eq!(vec.iter().sum::<u64>(), (n - 1) * n / 2);
+    serial_println!("[ok]");
+}
+
+#[test_case]
+fn many_boxes() {
+    serial_print!("many_boxes... ");
+    for i in 0..HEAP_SIZE {
+        let x = Box::new(i);
+        assert_eq!(*x, i);
+    }
+    serial_println!("[ok]");
+}
+
+#[test_case]
+fn many_boxes_long_lived() {
+    serial_print!("many_boxes_long_lived... ");
+    let long_lived = Box::new(1); // new
+    for i in 0..HEAP_SIZE {
+        let x = Box::new(i);
+        assert_eq!(*x, i);
+    }
+    assert_eq!(*long_lived, 1); // new
+    serial_println!("[ok]");
+}
+
+#[panic_handler]
+fn panic(info: &PanicInfo) -> ! {
+    blog_os::test_panic_handler(info)
+}
--- a/tests/should_panic.rs
+++ b/tests/should_panic.rs
@@ -0,0 +1,25 @@
+#![no_std]
+#![no_main]
+
+use blog_os::{exit_qemu, serial_print, serial_println, QemuExitCode};
+use core::panic::PanicInfo;
+
+#[no_mangle]
+pub extern "C" fn _start() -> ! {
+    should_fail();
+    serial_println!("[test did not panic]");
+    exit_qemu(QemuExitCode::Failed);
+    loop {}
+}
+
+fn should_fail() {
+    serial_print!("should_fail... ");
+    assert_eq!(0, 1);
+}
+
+#[panic_handler]
+fn panic(_info: &PanicInfo) -> ! {
+    serial_println!("[ok]");
+    exit_qemu(QemuExitCode::Success);
+    loop {}
+}
--- a/src/bin/test-exception-double-fault-stack-overflow.rs
+++ b/src/bin/test-exception-double-fault-stack-overflow.rs
@@ -1,58 +1,36 @@
-#![feature(abi_x86_interrupt)]
 #![no_std]
-#![cfg_attr(not(test), no_main)]
-#![cfg_attr(test, allow(dead_code, unused_macros, unused_imports))]
+#![no_main]
+#![feature(abi_x86_interrupt)]

-use blog_os::{exit_qemu, serial_println};
+use blog_os::{exit_qemu, serial_print, serial_println, QemuExitCode};
 use core::panic::PanicInfo;
 use lazy_static::lazy_static;
+use x86_64::structures::idt::{InterruptDescriptorTable, InterruptStackFrame};

-#[cfg(not(test))]
 #[no_mangle]
-#[allow(unconditional_recursion)]
 pub extern "C" fn _start() -> ! {
+    serial_print!("stack_overflow... ");
+
    blog_os::gdt::init();
    init_test_idt();

-    fn stack_overflow() {
-        stack_overflow(); // for each recursion, the return address is pushed
-    }
-
    // trigger a stack overflow
    stack_overflow();

-    serial_println!("failed");
-    serial_println!("No exception occured");
-
-    unsafe {
-        exit_qemu();
-    }
-
-    loop {}
+    panic!("Execution continued after stack overflow");
 }

-/// This function is called on panic.
-#[cfg(not(test))]
-#[panic_handler]
-fn panic(info: &PanicInfo) -> ! {
-    serial_println!("failed");
-    serial_println!("{}", info);
-
-    unsafe {
-        exit_qemu();
-    }
-
-    loop {}
+#[allow(unconditional_recursion)]
+fn stack_overflow() {
+    stack_overflow(); // for each recursion, the return address is pushed
 }

-use x86_64::structures::idt::{InterruptDescriptorTable, InterruptStackFrame};
-
 lazy_static! {
    static ref TEST_IDT: InterruptDescriptorTable = {
        let mut idt = InterruptDescriptorTable::new();
        unsafe {
            idt.double_fault
-                .set_handler_fn(double_fault_handler)
+                .set_handler_fn(test_double_fault_handler)
                .set_stack_index(blog_os::gdt::DOUBLE_FAULT_IST_INDEX);
        }

@@ -64,14 +42,16 @@ pub fn init_test_idt() {
    TEST_IDT.load();
 }

-extern "x86-interrupt" fn double_fault_handler(
+extern "x86-interrupt" fn test_double_fault_handler(
    _stack_frame: &mut InterruptStackFrame,
    _error_code: u64,
-) {
-    serial_println!("ok");
-
-    unsafe {
-        exit_qemu();
-    }
+) -> ! {
+    serial_println!("[ok]");
+    exit_qemu(QemuExitCode::Success);
    loop {}
 }
+
+#[panic_handler]
+fn panic(info: &PanicInfo) -> ! {
+    blog_os::test_panic_handler(info)
+}