Switch back to official nightly

Use cooked-waker crate for creating wakers
Implement proper wakeups using RawWaker
2025-12-16 14:27:49 +00:00 · 2020-03-22 17:30:00 +01:00 · 2020-03-22 17:24:58 +01:00 · 2020-03-22 16:54:47 +01:00 · 2020-03-22 16:11:25 +01:00 · 2020-03-22 12:45:24 +01:00
27 changed files with 489 additions and 811 deletions
--- 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/.cargo/config.toml
+++ b/.cargo/config.toml
@@ -1,14 +0,0 @@
-[unstable]
-# TODO: uncomment once https://github.com/rust-lang/cargo/issues/8687 is resolved
-# build-std = ["core", "alloc"]
-
-[build]
-# TODO: uncomment once https://github.com/rust-lang/cargo/issues/8687 is resolved
-# target = "x86_64-blog_os.json"
-
-[target.'cfg(target_os = "none")']
-runner = "cargo run --package disk_image --bin runner --quiet"
-
-[alias]
-xrun = "run --target x86_64-blog_os.json -Zbuild-std=core,alloc"
-bootimage = "run --package disk_image --bin disk_image --quiet"
--- a/.github/workflows/build-code.yml
+++ b/.github/workflows/build-code.yml
@@ -10,36 +10,11 @@ on:
  schedule:
    - cron: '40 3 * * *'   # every day at 3:40
  pull_request:
-  workflow_dispatch:

 jobs:
-  check:
-    name: Check
-    strategy:
-      matrix:
-        platform: [
-          ubuntu-latest,
-          macos-latest,
-          windows-latest
-        ]
-    runs-on: ${{ matrix.platform }}
-    steps:
-      - name: Checkout Repository
-        uses: actions/checkout@v2
-      - name: Install Rust Toolchain
-        uses: actions-rs/toolchain@v1
-        with:
-          profile: minimal
-          toolchain: nightly
-      - name: Install `rust-src` Rustup Component
-        run: rustup component add rust-src
-      - name: Run `cargo check`
-        uses: actions-rs/cargo@v1
-        with:
-          command: check
-
  test:
-    name: Test
+    name: "Test"
+
    strategy:
      matrix:
        platform: [
@@ -47,86 +22,75 @@ jobs:
          macos-latest,
          windows-latest
        ]
+
    runs-on: ${{ matrix.platform }}
+    timeout-minutes: 15
+
    steps:
-      - name: Install Rust Toolchain
-        uses: actions-rs/toolchain@v1
-        with:
-          profile: minimal
-          toolchain: nightly
-      - name: Install bootimage
-        run: cargo install bootimage --debug
-      - name: Checkout Repository
-        uses: actions/checkout@v2
-      - name: Install Rustup Components
-        run: rustup component add rust-src llvm-tools-preview
-      - name: Run `cargo bootimage`
-        uses: actions-rs/cargo@v1
-        with:
-          command: bootimage
+    - name: "Checkout Repository"
+      uses: actions/checkout@v1

-      # 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: 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: Run `cargo test`
-        uses: actions-rs/cargo@v1
-        with:
-          command: test
+    - 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
+    name: "Check Formatting"
    runs-on: ubuntu-latest
+    timeout-minutes: 2
    steps:
-      - name: Checkout Repository
-        uses: actions/checkout@v2
-      - name: Install Rust Toolchain
-        uses: actions-rs/toolchain@v1
-        with:
-          profile: minimal
+    - 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
-      - name: Run `cargo fmt`
-        uses: actions-rs/cargo@v1
-        with:
-          command: fmt
-          args: --all -- --check
-
-  clippy:
-    name: Clippy
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout Repository
-        uses: actions/checkout@v2
-      - name: Install Rust Toolchain
-        uses: actions-rs/toolchain@v1
-        with:
-          profile: minimal
-          toolchain: nightly
-          components: clippy, rust-src
-          override: true
-      - name: Run `cargo clippy`
-        uses: actions-rs/cargo@v1
-        with:
-          command: clippy
+    - run: cargo fmt -- --check
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1,11 +1,5 @@
 # This file is automatically @generated by Cargo.
 # It is not intended for manual editing.
-[[package]]
-name = "anyhow"
-version = "1.0.32"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6b602bfe940d21c130f3895acd65221e8a61270debe89d628b9cb4e3ccb8569b"
-
 [[package]]
 name = "autocfg"
 version = "1.0.0"
@@ -30,14 +24,13 @@ version = "0.1.0"
 dependencies = [
 "bootloader",
 "conquer-once",
+ "cooked-waker",
 "crossbeam-queue",
- "font8x8",
 "futures-util",
 "lazy_static",
 "linked_list_allocator",
 "pc-keyboard",
 "pic8259_simple",
- "rlibc",
 "spin",
 "uart_16550",
 "volatile",
@@ -46,16 +39,9 @@ dependencies = [

 [[package]]
 name = "bootloader"
-version = "0.9.8"
-
-[[package]]
-name = "bootloader-locator"
-version = "0.0.4"
+version = "0.8.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "aaaa9db3339d32c2622f2e5d0731eb82a468d3439797c9d4fe426744fe2bd551"
-dependencies = [
- "json",
-]
+checksum = "152a28c753e229e037e910b4cd4cd16a90c53dd9a67fd751fa304b4b4a03970c"

 [[package]]
 name = "cfg-if"
@@ -65,9 +51,9 @@ checksum = "4785bdd1c96b2a846b2bd7cc02e86b6b3dbf14e7e53446c4f54c92a361040822"

 [[package]]
 name = "conquer-once"
-version = "0.2.1"
+version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "96eb12fb69466716fbae9009d389e6a30830ae8975e170eff2d2cff579f9efa3"
+checksum = "6f7644600a548ecad74e4a918392af1798f7dd045be610be3203b9e129b4f98f"
 dependencies = [
 "conquer-util",
 ]
@@ -79,10 +65,31 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "654fb2472cc369d311c547103a1fa81d467bef370ae7a0680f65939895b1182a"

 [[package]]
-name = "cpuio"
-version = "0.3.0"
+name = "cooked-waker"
+version = "1.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d531514efb06912141fa65967447de805691b685a7565c87d1765afe34a98aa7"
+checksum = "b0032e8be0680b63daf14b0fd7fd57f85fd6897951e110b041d32e839a831914"
+dependencies = [
+ "cooked-waker-derive",
+ "stowaway",
+]
+
+[[package]]
+name = "cooked-waker-derive"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "74ded02b04a8ff53ea7328cd71297cde598bee70d165ad92512bdb7e20be9d74"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "cpuio"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "22b8e308ccfc5acf3b82f79c0eac444cf6114cb2ac67a230ca6c177210068daa"

 [[package]]
 name = "crossbeam-queue"
@@ -104,22 +111,6 @@ dependencies = [
 "cfg-if",
 ]

-[[package]]
-name = "disk_image"
-version = "0.1.0"
-dependencies = [
- "anyhow",
- "bootloader-locator",
- "locate-cargo-manifest",
- "runner-utils",
-]
-
-[[package]]
-name = "font8x8"
-version = "0.2.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "44226c40489fb1d602344a1d8f1b544570c3435e396dda1eda7b5ef010d8f1be"
-
 [[package]]
 name = "futures-core"
 version = "0.3.4"
@@ -143,12 +134,6 @@ dependencies = [
 "pin-utils",
 ]

-[[package]]
-name = "json"
-version = "0.12.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "078e285eafdfb6c4b434e0d31e8cfcb5115b651496faca5749b88fafd4f23bfd"
-
 [[package]]
 name = "lazy_static"
 version = "1.4.0"
@@ -158,12 +143,6 @@ dependencies = [
 "spin",
 ]

-[[package]]
-name = "libc"
-version = "0.2.76"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "755456fae044e6fa1ebbbd1b3e902ae19e73097ed4ed87bb79934a867c007bc3"
-
 [[package]]
 name = "linked_list_allocator"
 version = "0.8.0"
@@ -173,15 +152,6 @@ dependencies = [
 "spinning_top",
 ]

-[[package]]
-name = "locate-cargo-manifest"
-version = "0.2.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "db985b63431fe09e8d71f50aeceffcc31e720cb86be8dad2f38d084c5a328466"
-dependencies = [
- "json",
-]
-
 [[package]]
 name = "lock_api"
 version = "0.3.3"
@@ -199,9 +169,9 @@ checksum = "c48392db76c4e9a69e0b3be356c5f97ebb7b14413c5e4fd0af4755dbf86e2fce"

 [[package]]
 name = "pic8259_simple"
-version = "0.2.0"
+version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "af2a5497fb8e59bf8015f67b7dff238d75ef445e03f23edac24ac3a8f09be952"
+checksum = "dc64b2fd10828da8521b6cdabe0679385d7d2a3a6d4c336b819d1fa31ba35c72"
 dependencies = [
 "cpuio",
 ]
@@ -214,38 +184,22 @@ checksum = "5894c618ce612a3fa23881b152b608bafb8c56cfc22f434a3ba3120b40f7b587"

 [[package]]
 name = "proc-macro2"
-version = "1.0.20"
+version = "1.0.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "175c513d55719db99da20232b06cda8bab6b83ec2d04e3283edf0213c37c1a29"
+checksum = "6c09721c6781493a2a492a96b5a5bf19b65917fe6728884e7c44dd0c60ca3435"
 dependencies = [
 "unicode-xid",
 ]

 [[package]]
 name = "quote"
-version = "1.0.7"
+version = "1.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "aa563d17ecb180e500da1cfd2b028310ac758de548efdd203e18f283af693f37"
+checksum = "2bdc6c187c65bca4260c9011c9e3132efe4909da44726bad24cf7572ae338d7f"
 dependencies = [
 "proc-macro2",
 ]

-[[package]]
-name = "rlibc"
-version = "1.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fc874b127765f014d792f16763a81245ab80500e2ad921ed4ee9e82481ee08fe"
-
-[[package]]
-name = "runner-utils"
-version = "0.0.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c9dc6848b056990cd51e72aa5556bdbea4a96013e8b18635d183c84159c2988f"
-dependencies = [
- "thiserror",
- "wait-timeout",
-]
-
 [[package]]
 name = "scopeguard"
 version = "1.1.0"
@@ -268,41 +222,27 @@ dependencies = [
 ]

 [[package]]
-name = "syn"
-version = "1.0.40"
+name = "stowaway"
+version = "1.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "963f7d3cc59b59b9325165add223142bbf1df27655d07789f109896d353d8350"
+checksum = "32b13d61e782863c0eaeeaf7e8e580dc956a625851fd2fb73e5e92db9601c891"
+
+[[package]]
+name = "syn"
+version = "1.0.17"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0df0eb663f387145cab623dea85b09c2c5b4b0aef44e945d928e682fce71bb03"
 dependencies = [
 "proc-macro2",
 "quote",
 "unicode-xid",
 ]

-[[package]]
-name = "thiserror"
-version = "1.0.20"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7dfdd070ccd8ccb78f4ad66bf1982dc37f620ef696c6b5028fe2ed83dd3d0d08"
-dependencies = [
- "thiserror-impl",
-]
-
-[[package]]
-name = "thiserror-impl"
-version = "1.0.20"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bd80fc12f73063ac132ac92aceea36734f04a1d93c1240c6944e23a3b8841793"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
-]
-
 [[package]]
 name = "uart_16550"
-version = "0.2.7"
+version = "0.2.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e58fc40dc1712664fc9b0a7bd8ca2f21ab49960924fb245a80a05e1e92f3dfe9"
+checksum = "d44b0f30cb82b0fbc15b78ade1064226529ad52028bc8cb8accb98ff6f3d7131"
 dependencies = [
 "bitflags",
 "x86_64",
@@ -310,28 +250,21 @@ dependencies = [

 [[package]]
 name = "unicode-xid"
-version = "0.2.1"
+version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f7fe0bb3479651439c9112f72b6c505038574c9fbb575ed1bf3b797fa39dd564"
+checksum = "826e7639553986605ec5979c7dd957c7895e93eabed50ab2ffa7f6128a75097c"

 [[package]]
 name = "volatile"
-version = "0.3.0"
-
-[[package]]
-name = "wait-timeout"
-version = "0.2.0"
+version = "0.2.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9f200f5b12eb75f8c1ed65abd4b2db8a6e1b138a20de009dacee265a2498f3f6"
-dependencies = [
- "libc",
-]
+checksum = "6af0edf5b4faacc31fc51159244d78d65ec580f021afcef7bd53c04aeabc7f29"

 [[package]]
 name = "x86_64"
-version = "0.11.5"
+version = "0.9.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7c6e9604d08cf91ba0e5cc2175e8cbbdeeb2b8230b818fd9052604c4c5ffd620"
+checksum = "4206b60c9f99766329b66962aa8ddc01df6c7edd02edc046b7a69d5df9fcdbcf"
 dependencies = [
 "bit_field",
 "bitflags",
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -4,11 +4,6 @@ version = "0.1.0"
 authors = ["Philipp Oppermann <dev@phil-opp.com>"]
 edition = "2018"

-[workspace]
-members = [
-    "disk_image",
-]
-
 [[test]]
 name = "should_panic"
 harness = false
@@ -18,16 +13,15 @@ name = "stack_overflow"
 harness = false

 [dependencies]
-bootloader = { path = "../../uefi-test"}
-rlibc = "1.0.0"
+bootloader = { version = "0.8.8", features = ["map_physical_memory"]}
+volatile = "0.2.6"
 spin = "0.5.2"
-x86_64 = "0.11.0"
+x86_64 = "0.9.6"
 uart_16550 = "0.2.0"
-pic8259_simple = "0.2.0"
+pic8259_simple = "0.1.1"
 pc-keyboard = "0.5.0"
 linked_list_allocator = "0.8.0"
-volatile = { path= "../../volatile", features = ["unstable"] }
-font8x8 = { version = "0.2.5", default-features = false, features = ["unicode"]}
+cooked-waker = "1.0.2"

 [dependencies.lazy_static]
 version = "1.0"
@@ -39,7 +33,7 @@ default-features = false
 features = ["alloc"]

 [dependencies.conquer-once]
-version = "0.2.1"
+version = "0.2.0"
 default-features = false

 [dependencies.futures-util]
@@ -47,5 +41,9 @@ version = "0.3.4"
 default-features = false
 features = ["alloc"]

-[package.metadata.bootloader]
-map-physical-memory = true
+[package.metadata.bootimage]
+test-args = [
+    "-device", "isa-debug-exit,iobase=0xf4,iosize=0x04", "-serial", "stdio",
+    "-display", "none"
+]
+test-success-exit-code = 33         # (0x10 << 1) | 1
--- a/README.md
+++ b/README.md
@@ -1,32 +1,28 @@
-# Blog OS (Async/Await)
+# Blog OS (Heap Allocation)

-[![Build Status](https://github.com/phil-opp/blog_os/workflows/Build%20Code/badge.svg?branch=post-12)](https://github.com/phil-opp/blog_os/actions?query=workflow%3A%22Build+Code%22+branch%3Apost-12)
+[![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 [Async/Await][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/async-await/
+[post]: https://os.phil-opp.com/heap-allocation/

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

 ## Building

-This project requires a nightly version of Rust because it uses some unstable features. At least nightly _2020-07-15_ is required for building. You might need to run `rustup update nightly --force` to update to the latest nightly even if some components such as `rustfmt` are missing it.
-
-You can build the project by running:
+You need a nightly Rust compiler. First you need to install the `cargo-xbuild` and `bootimage` tools:

 ```
-cargo build
+cargo install cargo-xbuild bootimage
 ```

-To create a bootable disk image from the compiled kernel, you need to install the [`bootimage`] tool:
-
-[`bootimage`]: https://github.com/rust-osdev/bootimage
+Then you can build the project by running:

 ```
-cargo install bootimage
+cargo xbuild
 ```

-After installing, you can create the bootable disk image by running:
+To create a bootable disk image, run:

 ```
 cargo bootimage
@@ -43,10 +39,10 @@ You can run the disk image in [QEMU] through:
 [QEMU]: https://www.qemu.org/

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

-[QEMU] and the [`bootimage`] tool need to be installed for this.
+Of course [QEMU] needs to be installed for this.

 You can also write the image to an USB stick for booting it on a real machine. On Linux, the command for this is:

--- a/disk_image/Cargo.toml
+++ b/disk_image/Cargo.toml
@@ -1,13 +0,0 @@
-[package]
-name = "disk_image"
-version = "0.1.0"
-authors = ["Philipp Oppermann <dev@phil-opp.com>"]
-edition = "2018"
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
-[dependencies]
-anyhow = "1.0.32"
-bootloader-locator = "0.0.4"
-runner-utils = "0.0.2"
-locate-cargo-manifest = "0.2.0"
--- a/disk_image/src/bin/runner.rs
+++ b/disk_image/src/bin/runner.rs
@@ -1,57 +0,0 @@
-use anyhow::anyhow;
-use std::{
-    path::PathBuf,
-    process::{Command, ExitStatus},
-    time::Duration,
-};
-
-const RUN_ARGS: &[&str] = &["-d", "int", "--no-reboot", "-s"];
-const TEST_ARGS: &[&str] = &[
-    "-device",
-    "isa-debug-exit,iobase=0xf4,iosize=0x04",
-    "-serial",
-    "stdio",
-    "-display",
-    "none",
-    "--no-reboot",
-];
-const TEST_TIMEOUT_SECS: u64 = 10;
-
-fn main() -> anyhow::Result<()> {
-    let kernel_binary_path = {
-        let path = PathBuf::from(std::env::args().nth(1).unwrap());
-        path.canonicalize()?
-    };
-
-    let disk_image = disk_image::create_disk_image(&kernel_binary_path, true)?;
-
-    let mut run_cmd = Command::new("qemu-system-x86_64");
-    run_cmd
-        .arg("-drive")
-        .arg(format!("format=raw,file={}", disk_image.display()));
-
-    let binary_kind = runner_utils::binary_kind(&kernel_binary_path);
-    if binary_kind.is_test() {
-        run_cmd.args(TEST_ARGS);
-
-        let exit_status = run_test_command(run_cmd)?;
-        match exit_status.code() {
-            Some(33) => {} // success
-            other => return Err(anyhow!("Test failed (exit code: {:?})", other)),
-        }
-    } else {
-        run_cmd.args(RUN_ARGS);
-
-        let exit_status = run_cmd.status()?;
-        if !exit_status.success() {
-            std::process::exit(exit_status.code().unwrap_or(1));
-        }
-    }
-
-    Ok(())
-}
-
-fn run_test_command(mut cmd: Command) -> anyhow::Result<ExitStatus> {
-    let status = runner_utils::run_with_timeout(&mut cmd, Duration::from_secs(TEST_TIMEOUT_SECS))?;
-    Ok(status)
-}
--- a/disk_image/src/lib.rs
+++ b/disk_image/src/lib.rs
@@ -1,45 +0,0 @@
-use anyhow::anyhow;
-use std::{
-    path::{Path, PathBuf},
-    process::Command,
-};
-
-pub fn create_disk_image(kernel_binary_path: &Path, bios_only: bool) -> anyhow::Result<PathBuf> {
-    let bootloader_manifest_path = bootloader_locator::locate_bootloader("bootloader")?;
-    let kernel_manifest_path = locate_cargo_manifest::locate_manifest()?;
-
-    let mut build_cmd = Command::new(env!("CARGO"));
-    build_cmd.current_dir(bootloader_manifest_path.parent().unwrap());
-    build_cmd.arg("builder");
-    build_cmd
-        .arg("--kernel-manifest")
-        .arg(&kernel_manifest_path);
-    build_cmd.arg("--kernel-binary").arg(&kernel_binary_path);
-    build_cmd
-        .arg("--target-dir")
-        .arg(kernel_manifest_path.parent().unwrap().join("target"));
-    build_cmd
-        .arg("--out-dir")
-        .arg(kernel_binary_path.parent().unwrap());
-    build_cmd.arg("--quiet");
-    if bios_only {
-        build_cmd.arg("--firmware").arg("bios");
-    }
-
-    if !build_cmd.status()?.success() {
-        return Err(anyhow!("build failed"));
-    }
-
-    let kernel_binary_name = kernel_binary_path.file_name().unwrap().to_str().unwrap();
-    let disk_image = kernel_binary_path
-        .parent()
-        .unwrap()
-        .join(format!("bootimage-bios-{}.bin", kernel_binary_name));
-    if !disk_image.exists() {
-        return Err(anyhow!(
-            "Disk image does not exist at {} after bootloader build",
-            disk_image.display()
-        ));
-    }
-    Ok(disk_image)
-}
--- a/disk_image/src/main.rs
+++ b/disk_image/src/main.rs
@@ -1,40 +0,0 @@
-use anyhow::anyhow;
-use std::process::Command;
-
-const TARGET_NAME: &str = "x86_64-blog_os";
-const KERNEL_BINARIES: &[&str] = &["blog_os"];
-
-fn main() -> anyhow::Result<()> {
-    // build all binaries
-    let mut build_cmd = Command::new(env!("CARGO"));
-    build_cmd.arg("build");
-    build_cmd.arg("--release");
-    build_cmd.arg("-Zbuild-std=core");
-    build_cmd
-        .arg("--target")
-        .arg(format!("{}.json", TARGET_NAME));
-    if !build_cmd.status()?.success() {
-        return Err(anyhow!("build failed"));
-    };
-
-    let kernel_manifest = locate_cargo_manifest::locate_manifest()?;
-    let target_dir_root = kernel_manifest.parent().unwrap().join("target");
-    let target_dir = target_dir_root.join(TARGET_NAME).join("release");
-
-    for binary_name in KERNEL_BINARIES {
-        let binary_path = {
-            let path = target_dir.join(binary_name);
-            path.canonicalize()?
-        };
-
-        let disk_image = disk_image::create_disk_image(&binary_path, false)?;
-
-        println!(
-            "Created disk image for binary {} at {}",
-            binary_name,
-            disk_image.display()
-        );
-    }
-
-    Ok(())
-}
--- a/src/allocator.rs
+++ b/src/allocator.rs
@@ -35,7 +35,7 @@ pub fn init_heap(
            .allocate_frame()
            .ok_or(MapToError::FrameAllocationFailed)?;
        let flags = PageTableFlags::PRESENT | PageTableFlags::WRITABLE;
-        unsafe { mapper.map_to(page, frame, flags, frame_allocator)?.flush() };
+        mapper.map_to(page, frame, flags, frame_allocator)?.flush();
    }

    unsafe {
--- a/src/allocator/linked_list.rs
+++ b/src/allocator/linked_list.rs
@@ -45,7 +45,7 @@ impl LinkedListAllocator {
    /// 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_eq!(align_up(addr, mem::align_of::<ListNode>()), addr);
+        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
--- a/src/framebuffer.rs
+++ b/src/framebuffer.rs
@@ -1,179 +0,0 @@
-use bootloader::boot_info::PixelFormat;
-use core::{fmt, slice};
-use font8x8::UnicodeFonts;
-use spin::Mutex;
-use volatile::Volatile;
-
-pub static WRITER: Mutex<Option<Writer>> = Mutex::new(None);
-
-pub fn init(framebuffer: &'static mut bootloader::boot_info::FrameBuffer) {
-    let mut writer = Writer {
-        info: framebuffer.info(),
-        buffer: Volatile::new(framebuffer.buffer()),
-        x_pos: 0,
-        y_pos: 0,
-    };
-    writer.clear();
-
-    // global writer should not be locked here
-    let mut global_writer = WRITER.try_lock().unwrap();
-    assert!(global_writer.is_none(), "Global writer already initialized");
-    *global_writer = Some(writer);
-}
-
-pub struct Writer {
-    buffer: Volatile<&'static mut [u8]>,
-    info: bootloader::boot_info::FrameBufferInfo,
-    x_pos: usize,
-    y_pos: usize,
-}
-
-impl Writer {
-    fn newline(&mut self) {
-        self.y_pos += 8;
-        self.carriage_return();
-    }
-
-    fn carriage_return(&mut self) {
-        self.x_pos = 0;
-    }
-
-    /// Erases all text on the screen
-    pub fn clear(&mut self) {
-        self.x_pos = 0;
-        self.y_pos = 0;
-        self.buffer.fill(0);
-    }
-
-    fn shift_lines_up(&mut self) {
-        let offset = self.info.stride * self.info.bytes_per_pixel * 8;
-        self.buffer.copy_within(offset.., 0);
-        self.y_pos -= 8;
-    }
-
-    fn width(&self) -> usize {
-        self.info.horizontal_resolution
-    }
-
-    fn height(&self) -> usize {
-        self.info.vertical_resolution
-    }
-
-    fn write_char(&mut self, c: char) {
-        match c {
-            '\n' => self.newline(),
-            '\r' => self.carriage_return(),
-            c => {
-                if self.x_pos >= self.width() {
-                    self.newline();
-                }
-                while self.y_pos >= (self.height() - 8) {
-                    self.shift_lines_up();
-                }
-                let rendered = font8x8::BASIC_FONTS
-                    .get(c)
-                    .expect("character not found in basic font");
-                self.write_rendered_char(rendered);
-            }
-        }
-    }
-
-    fn write_rendered_char(&mut self, rendered_char: [u8; 8]) {
-        for (y, byte) in rendered_char.iter().enumerate() {
-            for (x, bit) in (0..8).enumerate() {
-                let on = *byte & (1 << bit) != 0;
-                self.write_pixel(self.x_pos + x, self.y_pos + y, on);
-            }
-        }
-        self.x_pos += 8;
-    }
-
-    fn write_pixel(&mut self, x: usize, y: usize, on: bool) {
-        let pixel_offset = y * self.info.stride + x;
-        let color = if on {
-            match self.info.pixel_format {
-                PixelFormat::RGB => [0x33, 0xff, 0x66, 0],
-                PixelFormat::BGR => [0x66, 0xff, 0x33, 0],
-                _other => [0xff, 0xff, 0xff, 0],
-            }
-        } else {
-            [0, 0, 0, 0]
-        };
-        let bytes_per_pixel = self.info.bytes_per_pixel;
-        let byte_offset = pixel_offset * bytes_per_pixel;
-        self.buffer
-            .index_mut(byte_offset..(byte_offset + bytes_per_pixel))
-            .copy_from_slice(&color[..bytes_per_pixel]);
-    }
-
-    /// Writes the given ASCII string to the buffer.
-    ///
-    /// Wraps lines at `BUFFER_WIDTH`. Supports the `\n` newline character. Does **not**
-    /// support strings with non-ASCII characters, since they can't be printed in the VGA text
-    /// mode.
-    fn write_string(&mut self, s: &str) {
-        for char in s.chars() {
-            self.write_char(char);
-        }
-    }
-}
-
-impl fmt::Write for Writer {
-    fn write_str(&mut self, s: &str) -> fmt::Result {
-        self.write_string(s);
-        Ok(())
-    }
-}
-
-/// Like the `print!` macro in the standard library, but prints to the VGA text buffer.
-#[macro_export]
-macro_rules! print {
-    ($($arg:tt)*) => ($crate::framebuffer::_print(format_args!($($arg)*)));
-}
-
-/// Like the `println!` macro in the standard library, but prints to the VGA text buffer.
-#[macro_export]
-macro_rules! println {
-    () => ($crate::print!("\n"));
-    ($($arg:tt)*) => ($crate::print!("{}\n", format_args!($($arg)*)));
-}
-
-/// Prints the given formatted string to the VGA text buffer
-/// through the global `WRITER` instance.
-#[doc(hidden)]
-pub fn _print(args: fmt::Arguments) {
-    use core::fmt::Write;
-    use x86_64::instructions::interrupts;
-
-    interrupts::without_interrupts(|| {
-        WRITER.lock().as_mut().unwrap().write_fmt(args).unwrap();
-    });
-}
-
-#[test_case]
-fn test_println_simple() {
-    println!("test_println_simple output");
-}
-
-#[test_case]
-fn test_println_many() {
-    for _ in 0..200 {
-        println!("test_println_many output");
-    }
-}
-
-#[test_case]
-fn test_println_output() {
-    use core::fmt::Write;
-    use x86_64::instructions::interrupts;
-
-    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);
-        }
-    });
-}
--- a/src/gdt.rs
+++ b/src/gdt.rs
@@ -9,7 +9,7 @@ lazy_static! {
    static ref TSS: TaskStateSegment = {
        let mut tss = TaskStateSegment::new();
        tss.interrupt_stack_table[DOUBLE_FAULT_IST_INDEX as usize] = {
-            const STACK_SIZE: usize = 4096 * 5;
+            const STACK_SIZE: usize = 4096;
            static mut STACK: [u8; STACK_SIZE] = [0; STACK_SIZE];

            let stack_start = VirtAddr::from_ptr(unsafe { &STACK });
--- a/src/interrupts.rs
+++ b/src/interrupts.rs
@@ -92,8 +92,13 @@ extern "x86-interrupt" fn keyboard_interrupt_handler(_stack_frame: &mut Interrup
    }
 }

+#[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
@@ -4,23 +4,22 @@
 #![feature(abi_x86_interrupt)]
 #![feature(alloc_error_handler)]
 #![feature(const_fn)]
+#![feature(alloc_layout_extra)]
 #![feature(const_in_array_repeat_expressions)]
-#![feature(wake_trait)]
 #![test_runner(crate::test_runner)]
 #![reexport_test_harness_main = "test_main"]

 extern crate alloc;
-extern crate rlibc;

 use core::panic::PanicInfo;

 pub mod allocator;
-pub mod framebuffer;
 pub mod gdt;
 pub mod interrupts;
 pub mod memory;
 pub mod serial;
 pub mod task;
+pub mod vga_buffer;

 pub fn init() {
    gdt::init();
@@ -28,25 +27,11 @@ pub fn init() {
    unsafe { interrupts::PICS.lock().initialize() };
    x86_64::instructions::interrupts::enable();
 }
-pub trait Testable {
-    fn run(&self) -> ();
-}

-impl<T> Testable for T
-where
-    T: Fn(),
-{
-    fn run(&self) {
-        serial_print!("{}...\t", core::any::type_name::<T>());
-        self();
-        serial_println!("[ok]");
-    }
-}
-
-pub fn test_runner(tests: &[&dyn Testable]) {
+pub fn test_runner(tests: &[&dyn Fn()]) {
    serial_println!("Running {} tests", tests.len());
    for test in tests {
-        test.run();
+        test();
    }
    exit_qemu(QemuExitCode::Success);
 }
--- a/src/main.rs
+++ b/src/main.rs
@@ -7,54 +7,38 @@
 extern crate alloc;

 use blog_os::println;
-use blog_os::task::{executor::Executor, keyboard, Task};
 use bootloader::{entry_point, BootInfo};
 use core::panic::PanicInfo;

 entry_point!(kernel_main);

-fn kernel_main(boot_info: &'static mut BootInfo) -> ! {
+fn kernel_main(boot_info: &'static BootInfo) -> ! {
    use blog_os::allocator;
    use blog_os::memory::{self, BootInfoFrameAllocator};
+    use blog_os::task::{keyboard, simple_executor::SimpleExecutor, Task};
    use x86_64::VirtAddr;

-    blog_os::framebuffer::init(boot_info.framebuffer.as_mut().unwrap());
-
    println!("Hello World{}", "!");
    blog_os::init();

-    let phys_mem_offset = VirtAddr::new(boot_info.physical_memory_offset.unwrap());
+    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_regions) };
+    let mut frame_allocator = unsafe { BootInfoFrameAllocator::init(&boot_info.memory_map) };

    allocator::init_heap(&mut mapper, &mut frame_allocator).expect("heap initialization failed");

+    let mut executor = SimpleExecutor::new();
+    executor.spawn(Task::new(example_task()));
+    executor.spawn(Task::new(keyboard::print_keypresses()));
+    executor.run();
+
    #[cfg(test)]
    test_main();

-    let mut executor = Executor::new();
-    executor.spawn(Task::new(example_task()));
-    executor.spawn(Task::new(keyboard::print_keypresses()));
-    executor.run();
-}
-
-/// This function is called on panic.
-#[cfg(not(test))]
-#[panic_handler]
-fn panic(info: &PanicInfo) -> ! {
-    unsafe {
-        blog_os::framebuffer::WRITER.force_unlock();
-    };
-    println!("{}", info);
+    println!("It did not crash!");
    blog_os::hlt_loop();
 }

-#[cfg(test)]
-#[panic_handler]
-fn panic(info: &PanicInfo) -> ! {
-    blog_os::test_panic_handler(info)
-}
-
 async fn async_number() -> u32 {
    42
 }
@@ -64,7 +48,16 @@ async fn example_task() {
    println!("async number: {}", number);
 }

-#[test_case]
-fn trivial_assertion() {
-    assert_eq!(1, 1);
+/// This function is called on panic.
+#[cfg(not(test))]
+#[panic_handler]
+fn panic(info: &PanicInfo) -> ! {
+    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,7 +1,8 @@
-use bootloader::memory_map::{MemoryRegion, MemoryRegionKind};
+use bootloader::bootinfo::{MemoryMap, MemoryRegionType};
 use x86_64::{
    structures::paging::{
        FrameAllocator, Mapper, OffsetPageTable, Page, PageTable, PhysFrame, Size4KiB,
+        UnusedPhysFrame,
    },
    PhysAddr, VirtAddr,
 };
@@ -44,12 +45,11 @@ pub fn create_example_mapping(
    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 {
-        // FIXME: this is not safe, we do it only for testing
-        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();
 }

@@ -57,14 +57,14 @@ pub fn create_example_mapping(
 pub struct EmptyFrameAllocator;

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

 /// A FrameAllocator that returns usable frames from the bootloader's memory map.
 pub struct BootInfoFrameAllocator {
-    memory_map: &'static [MemoryRegion],
+    memory_map: &'static MemoryMap,
    next: usize,
 }

@@ -74,7 +74,7 @@ impl BootInfoFrameAllocator {
    /// 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 [MemoryRegion]) -> Self {
+    pub unsafe fn init(memory_map: &'static MemoryMap) -> Self {
        BootInfoFrameAllocator {
            memory_map,
            next: 0,
@@ -82,21 +82,23 @@ impl BootInfoFrameAllocator {
    }

    /// Returns an iterator over the usable frames specified in the memory map.
-    fn usable_frames(&self) -> impl Iterator<Item = PhysFrame> {
+    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.kind == MemoryRegionKind::Usable);
+        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.start..r.end);
+        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
-        frame_addresses.map(|addr| PhysFrame::containing_address(PhysAddr::new(addr)))
+        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<PhysFrame> {
+    fn allocate_frame(&mut self) -> Option<UnusedPhysFrame> {
        let frame = self.usable_frames().nth(self.next);
        self.next += 1;
        frame
--- a/src/task/executor.rs
+++ b/src/task/executor.rs
@@ -1,102 +0,0 @@
-use super::{Task, TaskId};
-use alloc::{collections::BTreeMap, sync::Arc, task::Wake};
-use core::task::{Context, Poll, Waker};
-use crossbeam_queue::ArrayQueue;
-
-pub struct Executor {
-    tasks: BTreeMap<TaskId, Task>,
-    task_queue: Arc<ArrayQueue<TaskId>>,
-    waker_cache: BTreeMap<TaskId, Waker>,
-}
-
-impl Executor {
-    pub fn new() -> Self {
-        Executor {
-            tasks: BTreeMap::new(),
-            task_queue: Arc::new(ArrayQueue::new(100)),
-            waker_cache: BTreeMap::new(),
-        }
-    }
-
-    pub fn spawn(&mut self, task: Task) {
-        let task_id = task.id;
-        if self.tasks.insert(task.id, task).is_some() {
-            panic!("task with same ID already in tasks");
-        }
-        self.task_queue.push(task_id).expect("queue full");
-    }
-
-    pub fn run(&mut self) -> ! {
-        loop {
-            self.run_ready_tasks();
-            self.sleep_if_idle();
-        }
-    }
-
-    fn run_ready_tasks(&mut self) {
-        // destructure `self` to avoid borrow checker errors
-        let Self {
-            tasks,
-            task_queue,
-            waker_cache,
-        } = self;
-
-        while let Ok(task_id) = task_queue.pop() {
-            let task = match tasks.get_mut(&task_id) {
-                Some(task) => task,
-                None => continue, // task no longer exists
-            };
-            let waker = waker_cache
-                .entry(task_id)
-                .or_insert_with(|| TaskWaker::new(task_id, task_queue.clone()));
-            let mut context = Context::from_waker(waker);
-            match task.poll(&mut context) {
-                Poll::Ready(()) => {
-                    // task done -> remove it and its cached waker
-                    tasks.remove(&task_id);
-                    waker_cache.remove(&task_id);
-                }
-                Poll::Pending => {}
-            }
-        }
-    }
-
-    fn sleep_if_idle(&self) {
-        use x86_64::instructions::interrupts::{self, enable_interrupts_and_hlt};
-
-        interrupts::disable();
-        if self.task_queue.is_empty() {
-            enable_interrupts_and_hlt();
-        } else {
-            interrupts::enable();
-        }
-    }
-}
-
-struct TaskWaker {
-    task_id: TaskId,
-    task_queue: Arc<ArrayQueue<TaskId>>,
-}
-
-impl TaskWaker {
-    fn new(task_id: TaskId, task_queue: Arc<ArrayQueue<TaskId>>) -> Waker {
-        Waker::from(Arc::new(TaskWaker {
-            task_id,
-            task_queue,
-        }))
-    }
-
-    fn wake_task(&self) {
-        self.task_queue.push(self.task_id).expect("task_queue full");
-    }
-}
-
-impl Wake for TaskWaker {
-    fn wake(self: Arc<Self>) {
-        self.wake_task();
-    }
-
-    fn wake_by_ref(self: &Arc<Self>) {
-        self.wake_task();
-    }
-}
--- a/src/task/keyboard.rs
+++ b/src/task/keyboard.rs
@@ -1,14 +1,13 @@
-use crate::{print, println};
+use crate::print;
+use crate::println;
 use conquer_once::spin::OnceCell;
 use core::{
    pin::Pin,
    task::{Context, Poll},
 };
 use crossbeam_queue::ArrayQueue;
-use futures_util::{
-    stream::{Stream, StreamExt},
-    task::AtomicWaker,
-};
+use futures_util::stream::StreamExt;
+use futures_util::{stream::Stream, task::AtomicWaker};
 use pc_keyboard::{layouts, DecodedKey, HandleControl, Keyboard, ScancodeSet1};

 static SCANCODE_QUEUE: OnceCell<ArrayQueue<u8>> = OnceCell::uninit();
@@ -57,10 +56,7 @@ impl Stream for ScancodeStream {

        WAKER.register(&cx.waker());
        match queue.pop() {
-            Ok(scancode) => {
-                WAKER.take();
-                Poll::Ready(Some(scancode))
-            }
+            Ok(scancode) => Poll::Ready(Some(scancode)),
            Err(crossbeam_queue::PopError) => Poll::Pending,
        }
    }
--- a/src/task/mod.rs
+++ b/src/task/mod.rs
@@ -1,24 +1,17 @@
 use alloc::boxed::Box;
-use core::{
-    future::Future,
-    pin::Pin,
-    sync::atomic::{AtomicU64, Ordering},
-    task::{Context, Poll},
-};
+use core::task::{Context, Poll};
+use core::{future::Future, pin::Pin};

-pub mod executor;
 pub mod keyboard;
 pub mod simple_executor;

 pub struct Task {
-    id: TaskId,
    future: Pin<Box<dyn Future<Output = ()>>>,
 }

 impl Task {
    pub fn new(future: impl Future<Output = ()> + 'static) -> Task {
        Task {
-            id: TaskId::new(),
            future: Box::pin(future),
        }
    }
@@ -26,14 +19,8 @@ impl Task {
    fn poll(&mut self, context: &mut Context) -> Poll<()> {
        self.future.as_mut().poll(context)
    }
-}

-#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
-struct TaskId(u64);
-
-impl TaskId {
-    fn new() -> Self {
-        static NEXT_ID: AtomicU64 = AtomicU64::new(0);
-        TaskId(NEXT_ID.fetch_add(1, Ordering::Relaxed))
+    fn id(&self) -> usize {
+        &*self.future as *const _ as *const () as usize
    }
 }
--- a/src/task/simple_executor.rs
+++ b/src/task/simple_executor.rs
@@ -1,15 +1,24 @@
 use super::Task;
-use alloc::collections::VecDeque;
-use core::task::{Context, Poll, RawWaker, RawWakerVTable, Waker};
+use alloc::{
+    collections::{BTreeMap, VecDeque},
+    sync::Arc,
+};
+use cooked_waker::IntoWaker;
+use core::task::{Context, Poll};
+use crossbeam_queue::ArrayQueue;

 pub struct SimpleExecutor {
    task_queue: VecDeque<Task>,
+    waiting_tasks: BTreeMap<usize, Task>,
+    wake_queue: Arc<ArrayQueue<usize>>,
 }

 impl SimpleExecutor {
    pub fn new() -> SimpleExecutor {
        SimpleExecutor {
            task_queue: VecDeque::new(),
+            waiting_tasks: BTreeMap::new(),
+            wake_queue: Arc::new(ArrayQueue::new(100)),
        }
    }

@@ -18,27 +27,60 @@ impl SimpleExecutor {
    }

    pub fn run(&mut self) {
+        loop {
+            self.handle_wakeups();
+            self.run_ready_tasks();
+        }
+    }
+
+    fn handle_wakeups(&mut self) {
+        while let Ok(task_id) = self.wake_queue.pop() {
+            if let Some(task) = self.waiting_tasks.remove(&task_id) {
+                self.task_queue.push_back(task);
+            }
+        }
+    }
+
+    fn run_ready_tasks(&mut self) {
        while let Some(mut task) = self.task_queue.pop_front() {
-            let waker = dummy_waker();
+            let waker = TaskWaker {
+                task_id: task.id(),
+                wake_queue: self.wake_queue.clone(),
+            }
+            .into_waker();
            let mut context = Context::from_waker(&waker);
            match task.poll(&mut context) {
                Poll::Ready(()) => {} // task done
-                Poll::Pending => self.task_queue.push_back(task),
+                Poll::Pending => {
+                    if self.waiting_tasks.insert(task.id(), task).is_some() {
+                        panic!("Same task inserted into waiting_tasks twice");
+                    }
+                }
            }
        }
    }
 }

-fn dummy_raw_waker() -> RawWaker {
-    fn no_op(_: *const ()) {}
-    fn clone(_: *const ()) -> RawWaker {
-        dummy_raw_waker()
+#[derive(Debug, Clone, IntoWaker)]
+struct TaskWaker {
+    task_id: usize,
+    wake_queue: Arc<ArrayQueue<usize>>,
+}
+
+impl TaskWaker {
+    fn wake_task(&self) {
+        self.wake_queue.push(self.task_id).expect("wake queue full");
    }
-
-    let vtable = &RawWakerVTable::new(clone, no_op, no_op, no_op);
-    RawWaker::new(0 as *const (), vtable)
 }

-fn dummy_waker() -> Waker {
-    unsafe { Waker::from_raw(dummy_raw_waker()) }
+impl cooked_waker::WakeRef for TaskWaker {
+    fn wake_by_ref(&self) {
+        self.wake_task();
+    }
+}
+
+impl cooked_waker::Wake for TaskWaker {
+    fn wake(self) {
+        self.wake_task();
+    }
 }
--- a/src/vga_buffer.rs
+++ b/src/vga_buffer.rs
@@ -0,0 +1,215 @@
+use core::fmt;
+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.
+    ///
+    /// Used by the `print!` and `println!` macros.
+    pub static ref WRITER: Mutex<Writer> = Mutex::new(Writer {
+        column_position: 0,
+        color_code: ColorCode::new(Color::Yellow, Color::Black),
+        buffer: unsafe { &mut *(0xb8000 as *mut Buffer) },
+    });
+}
+
+/// The standard color palette in VGA text mode.
+#[allow(dead_code)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[repr(u8)]
+pub enum Color {
+    Black = 0,
+    Blue = 1,
+    Green = 2,
+    Cyan = 3,
+    Red = 4,
+    Magenta = 5,
+    Brown = 6,
+    LightGray = 7,
+    DarkGray = 8,
+    LightBlue = 9,
+    LightGreen = 10,
+    LightCyan = 11,
+    LightRed = 12,
+    Pink = 13,
+    Yellow = 14,
+    White = 15,
+}
+
+/// A combination of a foreground and a background color.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[repr(transparent)]
+struct ColorCode(u8);
+
+impl ColorCode {
+    /// Create a new `ColorCode` with the given foreground and background colors.
+    fn new(foreground: Color, background: Color) -> ColorCode {
+        ColorCode((background as u8) << 4 | (foreground as u8))
+    }
+}
+
+/// A screen character in the VGA text buffer, consisting of an ASCII character and a `ColorCode`.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[repr(C)]
+struct ScreenChar {
+    ascii_character: u8,
+    color_code: ColorCode,
+}
+
+/// The height of the text buffer (normally 25 lines).
+const BUFFER_HEIGHT: usize = 25;
+/// The width of the text buffer (normally 80 columns).
+const BUFFER_WIDTH: usize = 80;
+
+/// A structure representing the VGA text buffer.
+#[repr(transparent)]
+struct Buffer {
+    chars: [[Volatile<ScreenChar>; BUFFER_WIDTH]; BUFFER_HEIGHT],
+}
+
+/// A writer type that allows writing ASCII bytes and strings to an underlying `Buffer`.
+///
+/// Wraps lines at `BUFFER_WIDTH`. Supports newline characters and implements the
+/// `core::fmt::Write` trait.
+pub struct Writer {
+    column_position: usize,
+    color_code: ColorCode,
+    buffer: &'static mut Buffer,
+}
+
+impl Writer {
+    /// Writes an ASCII byte to the buffer.
+    ///
+    /// Wraps lines at `BUFFER_WIDTH`. Supports the `\n` newline character.
+    pub fn write_byte(&mut self, byte: u8) {
+        match byte {
+            b'\n' => self.new_line(),
+            byte => {
+                if self.column_position >= BUFFER_WIDTH {
+                    self.new_line();
+                }
+
+                let row = BUFFER_HEIGHT - 1;
+                let col = self.column_position;
+
+                let color_code = self.color_code;
+                self.buffer.chars[row][col].write(ScreenChar {
+                    ascii_character: byte,
+                    color_code,
+                });
+                self.column_position += 1;
+            }
+        }
+    }
+
+    /// Writes the given ASCII string to the buffer.
+    ///
+    /// Wraps lines at `BUFFER_WIDTH`. Supports the `\n` newline character. Does **not**
+    /// support strings with non-ASCII characters, since they can't be printed in the VGA text
+    /// mode.
+    fn write_string(&mut self, s: &str) {
+        for byte in s.bytes() {
+            match byte {
+                // printable ASCII byte or newline
+                0x20..=0x7e | b'\n' => self.write_byte(byte),
+                // not part of printable ASCII range
+                _ => self.write_byte(0xfe),
+            }
+        }
+    }
+
+    /// Shifts all lines one line up and clears the last row.
+    fn new_line(&mut self) {
+        for row in 1..BUFFER_HEIGHT {
+            for col in 0..BUFFER_WIDTH {
+                let character = self.buffer.chars[row][col].read();
+                self.buffer.chars[row - 1][col].write(character);
+            }
+        }
+        self.clear_row(BUFFER_HEIGHT - 1);
+        self.column_position = 0;
+    }
+
+    /// Clears a row by overwriting it with blank characters.
+    fn clear_row(&mut self, row: usize) {
+        let blank = ScreenChar {
+            ascii_character: b' ',
+            color_code: self.color_code,
+        };
+        for col in 0..BUFFER_WIDTH {
+            self.buffer.chars[row][col].write(blank);
+        }
+    }
+}
+
+impl fmt::Write for Writer {
+    fn write_str(&mut self, s: &str) -> fmt::Result {
+        self.write_string(s);
+        Ok(())
+    }
+}
+
+/// Like the `print!` macro in the standard library, but prints to the VGA text buffer.
+#[macro_export]
+macro_rules! print {
+    ($($arg:tt)*) => ($crate::vga_buffer::_print(format_args!($($arg)*)));
+}
+
+/// Like the `println!` macro in the standard library, but prints to the VGA text buffer.
+#[macro_export]
+macro_rules! println {
+    () => ($crate::print!("\n"));
+    ($($arg:tt)*) => ($crate::print!("{}\n", format_args!($($arg)*)));
+}
+
+/// Prints the given formatted string to the VGA text buffer
+/// through the global `WRITER` instance.
+#[doc(hidden)]
+pub fn _print(args: fmt::Arguments) {
+    use core::fmt::Write;
+    use x86_64::instructions::interrupts;
+
+    interrupts::without_interrupts(|| {
+        WRITER.lock().write_fmt(args).unwrap();
+    });
+}
+
+#[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
@@ -4,7 +4,7 @@
 #![test_runner(blog_os::test_runner)]
 #![reexport_test_harness_main = "test_main"]

-use blog_os::println;
+use blog_os::{println, serial_print, serial_println};
 use core::panic::PanicInfo;

 #[no_mangle] // don't mangle the name of this function
@@ -21,5 +21,7 @@ fn panic(info: &PanicInfo) -> ! {

 #[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
@@ -7,7 +7,7 @@
 extern crate alloc;

 use alloc::{boxed::Box, vec::Vec};
-use blog_os::allocator::HEAP_SIZE;
+use blog_os::{allocator::HEAP_SIZE, serial_print, serial_println};
 use bootloader::{entry_point, BootInfo};
 use core::panic::PanicInfo;

@@ -19,9 +19,9 @@ fn main(boot_info: &'static BootInfo) -> ! {
    use x86_64::VirtAddr;

    blog_os::init();
-    let phys_mem_offset = VirtAddr::new(boot_info.physical_memory_offset.unwrap());
+    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_regions) };
+    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();
@@ -30,38 +30,44 @@ fn main(boot_info: &'static BootInfo) -> ! {

 #[test_case]
 fn simple_allocation() {
-    let heap_value_1 = Box::new(41);
-    let heap_value_2 = Box::new(13);
-    assert_eq!(*heap_value_1, 41);
-    assert_eq!(*heap_value_2, 13);
+    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]
--- a/tests/should_panic.rs
+++ b/tests/should_panic.rs
@@ -13,7 +13,7 @@ pub extern "C" fn _start() -> ! {
 }

 fn should_fail() {
-    serial_print!("should_panic::should_fail...\t");
+    serial_print!("should_fail... ");
    assert_eq!(0, 1);
 }

--- a/tests/stack_overflow.rs
+++ b/tests/stack_overflow.rs
@@ -9,7 +9,7 @@ use x86_64::structures::idt::{InterruptDescriptorTable, InterruptStackFrame};

 #[no_mangle]
 pub extern "C" fn _start() -> ! {
-    serial_print!("stack_overflow::stack_overflow...\t");
+    serial_print!("stack_overflow... ");

    blog_os::gdt::init();
    init_test_idt();
@@ -23,7 +23,6 @@ pub extern "C" fn _start() -> ! {
 #[allow(unconditional_recursion)]
 fn stack_overflow() {
    stack_overflow(); // for each recursion, the return address is pushed
-    volatile::Volatile::new(0).read(); // prevent tail recursion optimizations
 }

 lazy_static! {
Author	SHA1	Message	Date
Philipp Oppermann	d21a78dc0b	Switch back to official nightly	2020-03-22 17:30:00 +01:00
Philipp Oppermann	0186f65ece	Use cooked-waker crate for creating wakers	2020-03-22 17:24:58 +01:00
Philipp Oppermann	2772abc8eb	Implement proper wakeups using RawWaker	2020-03-22 16:54:47 +01:00
Philipp Oppermann	51f90236a5	Base dummy waker on RawWaker to avoid allocations The Wake trait is based on Arc, which leads to deallocation on wakes. Since interrupts should not (de)allocate, this can lead to a deadlock.	2020-03-22 16:11:25 +01:00
Philipp Oppermann	90abd5c8c5	Add a keyboard task that prints keypresses	2020-03-22 12:45:24 +01:00
Philipp Oppermann	a6273614e4	Add waker support to ScancodeStream	2020-03-22 12:16:17 +01:00
Philipp Oppermann	3a2a468a0b	Add a ScancodeStream based on the SCANCODE_QUEUE	2020-03-22 12:12:11 +01:00
Philipp Oppermann	05f6abd261	Fill the scancode queue on keyboard interrupts	2020-03-22 12:11:09 +01:00
Philipp Oppermann	255982a8b7	Implement scancode queue	2020-03-20 13:03:41 +01:00
Philipp Oppermann	f885f17b70	Implement a simple poll-loop executor	2020-03-19 16:46:37 +01:00