Shift lines up instead of clearing the screen when full

This allows us to trigger a branch build from the master branch on schedule.

.cargo/config

@@ -1,5 +0,0 @@
-[build]
-target = "x86_64-blog_os.json"
-
-[target.'cfg(target_os = "none")']
-runner = "bootimage runner"

.cargo/config.toml

@@ -0,0 +1,14 @@
+[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"

.github/workflows/build-code.yml

@@ -10,11 +10,11 @@ on:
   schedule:
     - cron: '40 3 * * *'   # every day at 3:40
   pull_request:
+  workflow_dispatch:
 
 jobs:
-  test:
+  check:
-    name: "Test"
+    name: Check
-
     strategy:
       matrix:
         platform: [
@@ -22,75 +22,111 @@ jobs:
           macos-latest,
           windows-latest
         ]
-
     runs-on: ${{ matrix.platform }}
-    timeout-minutes: 15
-
     steps:
-    - name: "Checkout Repository"
+      - name: Checkout Repository
-      uses: actions/checkout@v1
+        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
 
-    - name: Install Rustup
+  test:
-      run: |
+    name: Test
-        curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh -s -- -y --default-toolchain nightly
+    strategy:
-        echo ::add-path::$HOME/.cargo/bin
+      matrix:
-      if: runner.os == 'macOS'
+        platform: [
+          ubuntu-latest,
+          macos-latest,
+          windows-latest
+        ]
+    runs-on: ${{ matrix.platform }}
+    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: "Print Rust Version"
+      # install QEMU
-      run: |
+      - name: Install QEMU (Linux)
-        rustc -Vv
+        run: sudo apt update && sudo apt install qemu-system-x86
-        cargo -Vv
+        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 Components"
+      - name: Run `cargo test`
-      run: rustup component add rust-src llvm-tools-preview
+        uses: actions-rs/cargo@v1
-    - name: "Install cargo-xbuild"
+        with:
-      run: cargo install cargo-xbuild --debug
+          command: test
-    - 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:
-    - uses: actions/checkout@v1
+      - name: Checkout Repository
-    - name: "Use the latest Rust nightly with rustfmt"
+        uses: actions/checkout@v2
-      uses: actions-rs/toolchain@v1
+      - name: Install Rust Toolchain
-      with:
+        uses: actions-rs/toolchain@v1
-          toolchain: nightly
+        with:
           profile: minimal
+          toolchain: nightly
           components: rustfmt
           override: true
-    - run: cargo fmt -- --check
+      - 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

Cargo.lock

@@ -1,5 +1,17 @@
 # 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"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8aac770f1885fd7e387acedd76065302551364496e46b3dd00860b2f8359b9d"
+
 [[package]]
 name = "bit_field"
 version = "0.9.0"
@@ -17,10 +29,15 @@ name = "blog_os"
 version = "0.1.0"
 dependencies = [
  "bootloader",
+ "conquer-once",
+ "crossbeam-queue",
+ "font8x8",
+ "futures-util",
  "lazy_static",
  "linked_list_allocator",
  "pc-keyboard",
  "pic8259_simple",
+ "rlibc",
  "spin",
  "uart_16550",
  "volatile",
@@ -29,15 +46,108 @@ dependencies = [
 
 [[package]]
 name = "bootloader"
-version = "0.8.8"
+version = "0.9.8"
+
+[[package]]
+name = "bootloader-locator"
+version = "0.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c3ed4f735c4e455ba86a3d2939b1c0729414153642106c9d035693355630a42c"
+checksum = "aaaa9db3339d32c2622f2e5d0731eb82a468d3439797c9d4fe426744fe2bd551"
+dependencies = [
+ "json",
+]
+
+[[package]]
+name = "cfg-if"
+version = "0.1.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4785bdd1c96b2a846b2bd7cc02e86b6b3dbf14e7e53446c4f54c92a361040822"
+
+[[package]]
+name = "conquer-once"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "96eb12fb69466716fbae9009d389e6a30830ae8975e170eff2d2cff579f9efa3"
+dependencies = [
+ "conquer-util",
+]
+
+[[package]]
+name = "conquer-util"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "654fb2472cc369d311c547103a1fa81d467bef370ae7a0680f65939895b1182a"
 
 [[package]]
 name = "cpuio"
-version = "0.2.0"
+version = "0.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "22b8e308ccfc5acf3b82f79c0eac444cf6114cb2ac67a230ca6c177210068daa"
+checksum = "d531514efb06912141fa65967447de805691b685a7565c87d1765afe34a98aa7"
+
+[[package]]
+name = "crossbeam-queue"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c695eeca1e7173472a32221542ae469b3e9aac3a4fc81f7696bcad82029493db"
+dependencies = [
+ "cfg-if",
+ "crossbeam-utils",
+]
+
+[[package]]
+name = "crossbeam-utils"
+version = "0.7.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c3c7c73a2d1e9fc0886a08b93e98eb643461230d5f1925e4036204d5f2e261a8"
+dependencies = [
+ "autocfg",
+ "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"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f25592f769825e89b92358db00d26f965761e094951ac44d3663ef25b7ac464a"
+
+[[package]]
+name = "futures-task"
+version = "0.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7b0a34e53cf6cdcd0178aa573aed466b646eb3db769570841fda0c7ede375a27"
+
+[[package]]
+name = "futures-util"
+version = "0.3.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "22766cf25d64306bedf0384da004d05c9974ab104fcc4528f1236181c18004c5"
+dependencies = [
+ "futures-core",
+ "futures-task",
+ "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"
@@ -48,6 +158,12 @@ 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"
@@ -57,6 +173,15 @@ 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"
@@ -74,13 +199,53 @@ checksum = "c48392db76c4e9a69e0b3be356c5f97ebb7b14413c5e4fd0af4755dbf86e2fce"
 
 [[package]]
 name = "pic8259_simple"
-version = "0.1.1"
+version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dc64b2fd10828da8521b6cdabe0679385d7d2a3a6d4c336b819d1fa31ba35c72"
+checksum = "af2a5497fb8e59bf8015f67b7dff238d75ef445e03f23edac24ac3a8f09be952"
 dependencies = [
  "cpuio",
 ]
 
+[[package]]
+name = "pin-utils"
+version = "0.1.0-alpha.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5894c618ce612a3fa23881b152b608bafb8c56cfc22f434a3ba3120b40f7b587"
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.20"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "175c513d55719db99da20232b06cda8bab6b83ec2d04e3283edf0213c37c1a29"
+dependencies = [
+ "unicode-xid",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "aa563d17ecb180e500da1cfd2b028310ac758de548efdd203e18f283af693f37"
+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"
@@ -103,26 +268,70 @@ dependencies = [
 ]
 
 [[package]]
-name = "uart_16550"
+name = "syn"
-version = "0.2.4"
+version = "1.0.40"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d44b0f30cb82b0fbc15b78ade1064226529ad52028bc8cb8accb98ff6f3d7131"
+checksum = "963f7d3cc59b59b9325165add223142bbf1df27655d07789f109896d353d8350"
+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"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e58fc40dc1712664fc9b0a7bd8ca2f21ab49960924fb245a80a05e1e92f3dfe9"
 dependencies = [
  "bitflags",
  "x86_64",
 ]
 
 [[package]]
-name = "volatile"
+name = "unicode-xid"
-version = "0.2.6"
+version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6af0edf5b4faacc31fc51159244d78d65ec580f021afcef7bd53c04aeabc7f29"
+checksum = "f7fe0bb3479651439c9112f72b6c505038574c9fbb575ed1bf3b797fa39dd564"
+
+[[package]]
+name = "volatile"
+version = "0.3.0"
+
+[[package]]
+name = "wait-timeout"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9f200f5b12eb75f8c1ed65abd4b2db8a6e1b138a20de009dacee265a2498f3f6"
+dependencies = [
+ "libc",
+]
 
 [[package]]
 name = "x86_64"
-version = "0.9.6"
+version = "0.11.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4206b60c9f99766329b66962aa8ddc01df6c7edd02edc046b7a69d5df9fcdbcf"
+checksum = "7c6e9604d08cf91ba0e5cc2175e8cbbdeeb2b8230b818fd9052604c4c5ffd620"
 dependencies = [
  "bit_field",
  "bitflags",

Cargo.toml

@@ -4,6 +4,11 @@ version = "0.1.0"
 authors = ["Philipp Oppermann <dev@phil-opp.com>"]
 edition = "2018"
 
+[workspace]
+members = [
+    "disk_image",
+]
+
 [[test]]
 name = "should_panic"
 harness = false
@@ -13,23 +18,34 @@ name = "stack_overflow"
 harness = false
 
 [dependencies]
-bootloader = { version = "0.8.0", features = ["map_physical_memory"]}
+bootloader = { path = "../../uefi-test"}
-volatile = "0.2.6"
+rlibc = "1.0.0"
 spin = "0.5.2"
-x86_64 = "0.9.6"
+x86_64 = "0.11.0"
 uart_16550 = "0.2.0"
-pic8259_simple = "0.1.1"
+pic8259_simple = "0.2.0"
 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"]}
 
 [dependencies.lazy_static]
 version = "1.0"
 features = ["spin_no_std"]
 
+[dependencies.crossbeam-queue]
+version = "0.2.1"
+default-features = false
+features = ["alloc"]
 
-[package.metadata.bootimage]
+[dependencies.conquer-once]
-test-args = [
+version = "0.2.1"
-    "-device", "isa-debug-exit,iobase=0xf4,iosize=0x04", "-serial", "stdio",
+default-features = false
-    "-display", "none"
+
-]
+[dependencies.futures-util]
-test-success-exit-code = 33         # (0x10 << 1) | 1
+version = "0.3.4"
+default-features = false
+features = ["alloc"]
+
+[package.metadata.bootloader]
+map-physical-memory = true

README.md

@@ -1,28 +1,32 @@
-# Blog OS (Heap Allocation)
+# Blog OS (Async/Await)
 
-[![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)
+[![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)
 
-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.
+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.
 
-[post]: https://os.phil-opp.com/heap-allocation/
+[post]: https://os.phil-opp.com/async-await/
 
 **Check out the [master branch](https://github.com/phil-opp/blog_os) for more information.**
 
 ## Building
 
-You need a nightly Rust compiler. First you need to install the `cargo-xbuild` and `bootimage` tools:
+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:
 
 ```
-cargo install cargo-xbuild bootimage
+cargo build
 ```
 
-Then you can build the project by running:
+To create a bootable disk image from the compiled kernel, you need to install the [`bootimage`] tool:
+
+[`bootimage`]: https://github.com/rust-osdev/bootimage
 
 ```
-cargo xbuild
+cargo install bootimage
 ```
 
-To create a bootable disk image, run:
+After installing, you can create the bootable disk image by running:
 
 ```
 cargo bootimage
@@ -39,10 +43,10 @@ You can run the disk image in [QEMU] through:
 [QEMU]: https://www.qemu.org/
 
 ```
-cargo xrun
+cargo run
 ```
 
-Of course [QEMU] needs to be installed for this.
+[QEMU] and the [`bootimage`] tool need 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:
 

disk_image/Cargo.toml

@@ -0,0 +1,13 @@
+[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"

disk_image/src/bin/runner.rs

@@ -0,0 +1,57 @@
+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)
+}

disk_image/src/lib.rs

@@ -0,0 +1,45 @@
+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)
+}

disk_image/src/main.rs

@@ -0,0 +1,40 @@
+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(())
+}

src/allocator.rs

@@ -35,7 +35,7 @@ pub fn init_heap(
             .allocate_frame()
             .ok_or(MapToError::FrameAllocationFailed)?;
         let flags = PageTableFlags::PRESENT | PageTableFlags::WRITABLE;
-        mapper.map_to(page, frame, flags, frame_allocator)?.flush();
+        unsafe { mapper.map_to(page, frame, flags, frame_allocator)?.flush() };
     }
 
     unsafe {

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!(align_up(addr, mem::align_of::<ListNode>()) == addr);
+        assert_eq!(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

src/framebuffer.rs

@@ -0,0 +1,179 @@
+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);
+        }
+    });
+}

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;
+            const STACK_SIZE: usize = 4096 * 5;
             static mut STACK: [u8; STACK_SIZE] = [0; STACK_SIZE];
 
             let stack_start = VirtAddr::from_ptr(unsafe { &STACK });

src/interrupts.rs

@@ -80,28 +80,11 @@ extern "x86-interrupt" fn timer_interrupt_handler(_stack_frame: &mut InterruptSt
 }
 
 extern "x86-interrupt" fn keyboard_interrupt_handler(_stack_frame: &mut InterruptStackFrame) {
-    use pc_keyboard::{layouts, DecodedKey, HandleControl, Keyboard, ScancodeSet1};
-    use spin::Mutex;
     use x86_64::instructions::port::Port;
 
-    lazy_static! {
-        static ref KEYBOARD: Mutex<Keyboard<layouts::Us104Key, ScancodeSet1>> = Mutex::new(
-            Keyboard::new(layouts::Us104Key, ScancodeSet1, HandleControl::Ignore)
-        );
-    }
-
-    let mut keyboard = KEYBOARD.lock();
     let mut port = Port::new(0x60);
-
     let scancode: u8 = unsafe { port.read() };
-    if let Ok(Some(key_event)) = keyboard.add_byte(scancode) {
+    crate::task::keyboard::add_scancode(scancode);
-        if let Some(key) = keyboard.process_keyevent(key_event) {
-            match key {
-                DecodedKey::Unicode(character) => print!("{}", character),
-                DecodedKey::RawKey(key) => print!("{:?}", key),
-            }
-        }
-    }
 
     unsafe {
         PICS.lock()
@@ -109,13 +92,8 @@ 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]");
 }

src/lib.rs

@@ -4,21 +4,23 @@
 #![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 vga_buffer;
+pub mod task;
 
 pub fn init() {
     gdt::init();
@@ -26,11 +28,25 @@ pub fn init() {
     unsafe { interrupts::PICS.lock().initialize() };
     x86_64::instructions::interrupts::enable();
 }
+pub trait Testable {
+    fn run(&self) -> ();
+}
 
-pub fn test_runner(tests: &[&dyn Fn()]) {
+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]) {
     serial_println!("Running {} tests", tests.len());
     for test in tests {
-        test();
+        test.run();
     }
     exit_qemu(QemuExitCode::Success);
 }

src/main.rs

@@ -6,62 +6,45 @@
 
 extern crate alloc;
 
-use alloc::{boxed::Box, rc::Rc, vec, vec::Vec};
 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 BootInfo) -> ! {
+fn kernel_main(boot_info: &'static mut BootInfo) -> ! {
     use blog_os::allocator;
     use blog_os::memory::{self, BootInfoFrameAllocator};
     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);
+    let phys_mem_offset = VirtAddr::new(boot_info.physical_memory_offset.unwrap());
     let mut mapper = unsafe { memory::init(phys_mem_offset) };
-    let mut frame_allocator = unsafe { BootInfoFrameAllocator::init(&boot_info.memory_map) };
+    let mut frame_allocator = unsafe { BootInfoFrameAllocator::init(&boot_info.memory_regions) };
 
     allocator::init_heap(&mut mapper, &mut frame_allocator).expect("heap initialization failed");
 
-    // allocate a number on the heap
-    let heap_value = Box::new(41);
-    println!("heap_value at {:p}", heap_value);
-
-    // 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();
 
-    println!("It did not crash!");
+    let mut executor = Executor::new();
-    blog_os::hlt_loop();
+    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);
     blog_os::hlt_loop();
 }
@@ -71,3 +54,17 @@ fn panic(info: &PanicInfo) -> ! {
 fn panic(info: &PanicInfo) -> ! {
     blog_os::test_panic_handler(info)
 }
+
+async fn async_number() -> u32 {
+    42
+}
+
+async fn example_task() {
+    let number = async_number().await;
+    println!("async number: {}", number);
+}
+
+#[test_case]
+fn trivial_assertion() {
+    assert_eq!(1, 1);
+}

src/memory.rs

@@ -1,8 +1,7 @@
-use bootloader::bootinfo::{MemoryMap, MemoryRegionType};
+use bootloader::memory_map::{MemoryRegion, MemoryRegionKind};
 use x86_64::{
     structures::paging::{
         FrameAllocator, Mapper, OffsetPageTable, Page, PageTable, PhysFrame, Size4KiB,
-        UnusedPhysFrame,
     },
     PhysAddr, VirtAddr,
 };
@@ -45,11 +44,12 @@ 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 = mapper.map_to(page, unused_frame, flags, frame_allocator);
+    let map_to_result = unsafe {
+        // FIXME: this is not safe, we do it only for testing
+        mapper.map_to(page, 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<UnusedPhysFrame> {
+    fn allocate_frame(&mut self) -> Option<PhysFrame> {
         None
     }
 }
 
 /// A FrameAllocator that returns usable frames from the bootloader's memory map.
 pub struct BootInfoFrameAllocator {
-    memory_map: &'static MemoryMap,
+    memory_map: &'static [MemoryRegion],
     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 MemoryMap) -> Self {
+    pub unsafe fn init(memory_map: &'static [MemoryRegion]) -> Self {
         BootInfoFrameAllocator {
             memory_map,
             next: 0,
@@ -82,23 +82,21 @@ impl BootInfoFrameAllocator {
     }
 
     /// Returns an iterator over the usable frames specified in the memory map.
-    fn usable_frames(&self) -> impl Iterator<Item = UnusedPhysFrame> {
+    fn usable_frames(&self) -> impl Iterator<Item = PhysFrame> {
         // get usable regions from memory map
         let regions = self.memory_map.iter();
-        let usable_regions = regions.filter(|r| r.region_type == MemoryRegionType::Usable);
+        let usable_regions = regions.filter(|r| r.kind == MemoryRegionKind::Usable);
         // map each region to its address range
-        let addr_ranges = usable_regions.map(|r| r.range.start_addr()..r.range.end_addr());
+        let addr_ranges = usable_regions.map(|r| r.start..r.end);
         // 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)));
+        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> {
+    fn allocate_frame(&mut self) -> Option<PhysFrame> {
         let frame = self.usable_frames().nth(self.next);
         self.next += 1;
         frame

src/task/executor.rs

@@ -0,0 +1,102 @@
+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();
+    }
+}

src/task/keyboard.rs

@@ -0,0 +1,83 @@
+use crate::{print, 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 pc_keyboard::{layouts, DecodedKey, HandleControl, Keyboard, ScancodeSet1};
+
+static SCANCODE_QUEUE: OnceCell<ArrayQueue<u8>> = OnceCell::uninit();
+static WAKER: AtomicWaker = AtomicWaker::new();
+
+/// Called by the keyboard interrupt handler
+///
+/// Must not block or allocate.
+pub(crate) fn add_scancode(scancode: u8) {
+    if let Ok(queue) = SCANCODE_QUEUE.try_get() {
+        if let Err(_) = queue.push(scancode) {
+            println!("WARNING: scancode queue full; dropping keyboard input");
+        } else {
+            WAKER.wake();
+        }
+    } else {
+        println!("WARNING: scancode queue uninitialized");
+    }
+}
+
+pub struct ScancodeStream {
+    _private: (),
+}
+
+impl ScancodeStream {
+    pub fn new() -> Self {
+        SCANCODE_QUEUE
+            .try_init_once(|| ArrayQueue::new(100))
+            .expect("ScancodeStream::new should only be called once");
+        ScancodeStream { _private: () }
+    }
+}
+
+impl Stream for ScancodeStream {
+    type Item = u8;
+
+    fn poll_next(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Option<u8>> {
+        let queue = SCANCODE_QUEUE
+            .try_get()
+            .expect("scancode queue not initialized");
+
+        // fast path
+        if let Ok(scancode) = queue.pop() {
+            return Poll::Ready(Some(scancode));
+        }
+
+        WAKER.register(&cx.waker());
+        match queue.pop() {
+            Ok(scancode) => {
+                WAKER.take();
+                Poll::Ready(Some(scancode))
+            }
+            Err(crossbeam_queue::PopError) => Poll::Pending,
+        }
+    }
+}
+
+pub async fn print_keypresses() {
+    let mut scancodes = ScancodeStream::new();
+    let mut keyboard = Keyboard::new(layouts::Us104Key, ScancodeSet1, HandleControl::Ignore);
+
+    while let Some(scancode) = scancodes.next().await {
+        if let Ok(Some(key_event)) = keyboard.add_byte(scancode) {
+            if let Some(key) = keyboard.process_keyevent(key_event) {
+                match key {
+                    DecodedKey::Unicode(character) => print!("{}", character),
+                    DecodedKey::RawKey(key) => print!("{:?}", key),
+                }
+            }
+        }
+    }
+}

src/task/mod.rs

@@ -0,0 +1,39 @@
+use alloc::boxed::Box;
+use core::{
+    future::Future,
+    pin::Pin,
+    sync::atomic::{AtomicU64, Ordering},
+    task::{Context, Poll},
+};
+
+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),
+        }
+    }
+
+    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))
+    }
+}

src/task/simple_executor.rs

@@ -0,0 +1,44 @@
+use super::Task;
+use alloc::collections::VecDeque;
+use core::task::{Context, Poll, RawWaker, RawWakerVTable, Waker};
+
+pub struct SimpleExecutor {
+    task_queue: VecDeque<Task>,
+}
+
+impl SimpleExecutor {
+    pub fn new() -> SimpleExecutor {
+        SimpleExecutor {
+            task_queue: VecDeque::new(),
+        }
+    }
+
+    pub fn spawn(&mut self, task: Task) {
+        self.task_queue.push_back(task)
+    }
+
+    pub fn run(&mut self) {
+        while let Some(mut task) = self.task_queue.pop_front() {
+            let waker = dummy_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),
+            }
+        }
+    }
+}
+
+fn dummy_raw_waker() -> RawWaker {
+    fn no_op(_: *const ()) {}
+    fn clone(_: *const ()) -> RawWaker {
+        dummy_raw_waker()
+    }
+
+    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()) }
+}

src/vga_buffer.rs

@@ -1,215 +0,0 @@
-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]");
-}

tests/basic_boot.rs

@@ -4,7 +4,7 @@
 #![test_runner(blog_os::test_runner)]
 #![reexport_test_harness_main = "test_main"]
 
-use blog_os::{println, serial_print, serial_println};
+use blog_os::println;
 use core::panic::PanicInfo;
 
 #[no_mangle] // don't mangle the name of this function
@@ -21,7 +21,5 @@ fn panic(info: &PanicInfo) -> ! {
 
 #[test_case]
 fn test_println() {
-    serial_print!("test_println... ");
     println!("test_println output");
-    serial_println!("[ok]");
 }

tests/heap_allocation.rs

@@ -7,7 +7,7 @@
 extern crate alloc;
 
 use alloc::{boxed::Box, vec::Vec};
-use blog_os::{allocator::HEAP_SIZE, serial_print, serial_println};
+use blog_os::allocator::HEAP_SIZE;
 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);
+    let phys_mem_offset = VirtAddr::new(boot_info.physical_memory_offset.unwrap());
     let mut mapper = unsafe { memory::init(phys_mem_offset) };
-    let mut frame_allocator = unsafe { BootInfoFrameAllocator::init(&boot_info.memory_map) };
+    let mut frame_allocator = unsafe { BootInfoFrameAllocator::init(&boot_info.memory_regions) };
     allocator::init_heap(&mut mapper, &mut frame_allocator).expect("heap initialization failed");
 
     test_main();
@@ -30,44 +30,38 @@ fn main(boot_info: &'static BootInfo) -> ! {
 
 #[test_case]
 fn simple_allocation() {
-    serial_print!("simple_allocation... ");
+    let heap_value_1 = Box::new(41);
-    let heap_value = Box::new(41);
+    let heap_value_2 = Box::new(13);
-    assert_eq!(*heap_value, 41);
+    assert_eq!(*heap_value_1, 41);
-    serial_println!("[ok]");
+    assert_eq!(*heap_value_2, 13);
 }
 
 #[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]

tests/should_panic.rs

@@ -13,7 +13,7 @@ pub extern "C" fn _start() -> ! {
 }
 
 fn should_fail() {
-    serial_print!("should_fail... ");
+    serial_print!("should_panic::should_fail...\t");
     assert_eq!(0, 1);
 }
 

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... ");
+    serial_print!("stack_overflow::stack_overflow...\t");
 
     blog_os::gdt::init();
     init_test_idt();
@@ -23,6 +23,7 @@ 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! {