Fix register typo: rpb -> rbp

Fixes #746
Add a yield_now function and use it in idle thread
2025-12-16 14:27:49 +00:00 · 2020-02-16 18:02:24 +01:00 · 2020-01-28 12:28:50 +01:00 · 2020-01-28 12:22:37 +01:00 · 2020-01-28 11:29:21 +01:00 · 2020-01-23 14:24:13 +01:00
32 changed files with 931 additions and 1074 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,16 +1,13 @@
 # This file is automatically @generated by Cargo.
 # It is not intended for manual editing.
 [[package]]
-name = "anyhow"
-version = "1.0.32"
+name = "array-init"
+version = "0.0.4"
 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"
+checksum = "23589ecb866b460d3a0f1278834750268c607e8e28a1b982c907219f3178cd72"
+dependencies = [
+ "nodrop",
+]

 [[package]]
 name = "bit_field"
@@ -29,125 +26,36 @@ 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",
- "x86_64",
+ "x86_64 0.8.1",
 ]

 [[package]]
 name = "bootloader"
-version = "0.9.8"
+version = "0.8.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d596849a47f28abdea62d7a6a25c4f6e69c3d9b09b0a2877db6e9cda004ca993"

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

-[[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.3.0"
+version = "0.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-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"
+checksum = "22b8e308ccfc5acf3b82f79c0eac444cf6114cb2ac67a230ca6c177210068daa"

 [[package]]
 name = "lazy_static"
@@ -158,99 +66,59 @@ 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"
+version = "0.6.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "18c618c431dfe4419afbe22852f6aceffbc17bd82ba0a18b982def291000824c"
+checksum = "47314ec1d29aa869ee7cb5a5be57be9b1055c56567d59c3fb6689926743e0bea"
 dependencies = [
- "spinning_top",
+ "spin",
 ]

 [[package]]
-name = "locate-cargo-manifest"
-version = "0.2.2"
+name = "nodrop"
+version = "0.1.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "db985b63431fe09e8d71f50aeceffcc31e720cb86be8dad2f38d084c5a328466"
-dependencies = [
- "json",
-]
-
-[[package]]
-name = "lock_api"
-version = "0.3.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "79b2de95ecb4691949fea4716ca53cdbcfccb2c612e19644a8bad05edcf9f47b"
-dependencies = [
- "scopeguard",
-]
+checksum = "72ef4a56884ca558e5ddb05a1d1e7e1bfd9a68d9ed024c21704cc98872dae1bb"

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

 [[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",
 ]

 [[package]]
-name = "pin-utils"
-version = "0.1.0-alpha.4"
+name = "rustc_version"
+version = "0.2.3"
 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"
+checksum = "138e3e0acb6c9fb258b19b67cb8abd63c00679d2851805ea151465464fe9030a"
 dependencies = [
- "unicode-xid",
+ "semver",
 ]

 [[package]]
-name = "quote"
-version = "1.0.7"
+name = "semver"
+version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "aa563d17ecb180e500da1cfd2b028310ac758de548efdd203e18f283af693f37"
+checksum = "1d7eb9ef2c18661902cc47e535f9bc51b78acd254da71d375c2f6720d9a40403"
 dependencies = [
- "proc-macro2",
+ "semver-parser",
 ]

 [[package]]
-name = "rlibc"
-version = "1.0.0"
+name = "semver-parser"
+version = "0.7.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"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d29ab0c6d3fc0ee92fe66e2d99f700eab17a8d57d1c1d3b748380fb20baa78cd"
+checksum = "388a1df253eca08550bef6c72392cfe7c30914bf41df5269b68cbd6ff8f570a3"

 [[package]]
 name = "spin"
@@ -258,81 +126,49 @@ version = "0.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6e63cff320ae2c57904679ba7cb63280a3dc4613885beafb148ee7bf9aa9042d"

-[[package]]
-name = "spinning_top"
-version = "0.1.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "32d801a3a53bcf5071f85fef8d5cab9e5f638fc5580a37e6eb7aba4b37438d24"
-dependencies = [
- "lock_api",
-]
-
-[[package]]
-name = "syn"
-version = "1.0.40"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-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 = "unicode-xid"
 version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f7fe0bb3479651439c9112f72b6c505038574c9fbb575ed1bf3b797fa39dd564"
+checksum = "803ea8cb602dbb32c1a657a866d2dd79fe7dbeab0fb2ac667cb4dcc7de12a58b"
+dependencies = [
+ "bitflags",
+ "x86_64 0.7.7",
+]
+
+[[package]]
+name = "ux"
+version = "0.1.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "88dfeb711b61ce620c0cb6fd9f8e3e678622f0c971da2a63c4b3e25e88ed012f"

 [[package]]
 name = "volatile"
-version = "0.3.0"
+version = "0.2.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6af0edf5b4faacc31fc51159244d78d65ec580f021afcef7bd53c04aeabc7f29"

 [[package]]
-name = "wait-timeout"
-version = "0.2.0"
+name = "x86_64"
+version = "0.7.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9f200f5b12eb75f8c1ed65abd4b2db8a6e1b138a20de009dacee265a2498f3f6"
+checksum = "1f27d9168654aee1b0c1b73746caeb4aa33248f8b8c8f6e100e697fcc2a794b2"
 dependencies = [
- "libc",
+ "array-init",
+ "bit_field",
+ "bitflags",
+ "cast",
+ "ux",
 ]

 [[package]]
 name = "x86_64"
-version = "0.11.5"
+version = "0.8.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7c6e9604d08cf91ba0e5cc2175e8cbbdeeb2b8230b818fd9052604c4c5ffd620"
+checksum = "f21672dcbed52bc09eea030d189600c0189c66c97bc5b31779eb780e064a201f"
 dependencies = [
+ "array-init",
 "bit_field",
 "bitflags",
+ "cast",
 ]
--- 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,34 +13,26 @@ name = "stack_overflow"
 harness = false

 [dependencies]
-bootloader = { path = "../../uefi-test"}
-rlibc = "1.0.0"
+bootloader = { version = "0.8.0", features = ["map_physical_memory"]}
+volatile = "0.2.6"
 spin = "0.5.2"
-x86_64 = "0.11.0"
+x86_64 = "0.8.1"
 uart_16550 = "0.2.0"
-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"]}
+pic8259_simple = "0.1.1"
+pc-keyboard = "0.3.1"
+linked_list_allocator = "0.6.4"

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

-[dependencies.crossbeam-queue]
-version = "0.2.1"
-default-features = false
-features = ["alloc"]

-[dependencies.conquer-once]
-version = "0.2.1"
-default-features = false
+[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

-[dependencies.futures-util]
-version = "0.3.4"
-default-features = false
-features = ["alloc"]
-
-[package.metadata.bootloader]
-map-physical-memory = true
+[profile.release]
+lto = true
--- 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/bump.rs
+++ b/src/allocator/bump.rs
@@ -26,7 +26,7 @@ impl BumpAllocator {
    /// memory range is unused. Also, this method must be called only once.
    pub unsafe fn init(&mut self, heap_start: usize, heap_size: usize) {
        self.heap_start = heap_start;
-        self.heap_end = heap_start.saturating_add(heap_size);
+        self.heap_end = heap_start + heap_size;
        self.next = heap_start;
    }
 }
@@ -36,10 +36,7 @@ unsafe impl GlobalAlloc for Locked<BumpAllocator> {
        let mut bump = self.lock(); // get a mutable reference

        let alloc_start = align_up(bump.next, layout.align());
-        let alloc_end = match alloc_start.checked_add(layout.size()) {
-            Some(end) => end,
-            None => return ptr::null_mut(),
-        };
+        let alloc_end = alloc_start + layout.size();

        if alloc_end > bump.heap_end {
            ptr::null_mut() // out of memory
--- 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
@@ -86,7 +86,7 @@ impl LinkedListAllocator {
    /// Returns the allocation start address on success.
    fn alloc_from_region(region: &ListNode, size: usize, align: usize) -> Result<usize, ()> {
        let alloc_start = align_up(region.start_addr(), align);
-        let alloc_end = alloc_start.checked_add(size).ok_or(())?;
+        let alloc_end = alloc_start + size;

        if alloc_end > region.end_addr() {
            // region too small
@@ -122,10 +122,10 @@ unsafe impl GlobalAlloc for Locked<LinkedListAllocator> {
    unsafe fn alloc(&self, layout: Layout) -> *mut u8 {
        // perform layout adjustments
        let (size, align) = LinkedListAllocator::size_align(layout);
-        let mut allocator = self.lock();
+        let mut allocator = self.inner.lock();

        if let Some((region, alloc_start)) = allocator.find_region(size, align) {
-            let alloc_end = alloc_start.checked_add(size).expect("overflow");
+            let alloc_end = alloc_start + size;
            let excess_size = region.end_addr() - alloc_end;
            if excess_size > 0 {
                allocator.add_free_region(alloc_end, excess_size);
@@ -140,6 +140,6 @@ unsafe impl GlobalAlloc for Locked<LinkedListAllocator> {
        // perform layout adjustments
        let (size, _) = LinkedListAllocator::size_align(layout);

-        self.lock().add_free_region(ptr as usize, size)
+        self.inner.lock().add_free_region(ptr as usize, size)
    }
 }
--- a/src/allocator/mod.rs
+++ b/src/allocator/mod.rs
@@ -21,7 +21,7 @@ static ALLOCATOR: Locked<FixedSizeBlockAllocator> = Locked::new(FixedSizeBlockAl
 pub fn init_heap(
    mapper: &mut impl Mapper<Size4KiB>,
    frame_allocator: &mut impl FrameAllocator<Size4KiB>,
-) -> Result<(), MapToError<Size4KiB>> {
+) -> Result<(), MapToError> {
    let page_range = {
        let heap_start = VirtAddr::new(HEAP_START as u64);
        let heap_end = heap_start + HEAP_SIZE - 1u64;
@@ -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 {
@@ -74,9 +74,11 @@ impl<A> Locked<A> {
    }
 }

-/// Align the given address `addr` upwards to alignment `align`.
-///
-/// Requires that `align` is a power of two.
 fn align_up(addr: usize, align: usize) -> usize {
-    (addr + align - 1) & !(align - 1)
+    let remainder = addr % align;
+    if remainder == 0 {
+        addr // addr already aligned
+    } else {
+        addr - remainder + align
+    }
 }
--- 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
@@ -77,14 +77,31 @@ extern "x86-interrupt" fn timer_interrupt_handler(_stack_frame: &mut InterruptSt
        PICS.lock()
            .notify_end_of_interrupt(InterruptIndex::Timer.as_u8());
    }
+    crate::multitasking::invoke_scheduler();
 }

 extern "x86-interrupt" fn keyboard_interrupt_handler(_stack_frame: &mut InterruptStackFrame) {
+    use pc_keyboard::{layouts, DecodedKey, 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));
+    }
+
+    let mut keyboard = KEYBOARD.lock();
    let mut port = Port::new(0x60);
+
    let scancode: u8 = unsafe { port.read() };
-    crate::task::keyboard::add_scancode(scancode);
+    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),
+            }
+        }
+    }

    unsafe {
        PICS.lock()
@@ -92,8 +109,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,28 @@
 #![feature(abi_x86_interrupt)]
 #![feature(alloc_error_handler)]
 #![feature(const_fn)]
+#![feature(alloc_layout_extra)]
 #![feature(const_in_array_repeat_expressions)]
-#![feature(wake_trait)]
+#![feature(global_asm)]
+#![feature(asm)]
+#![feature(raw)]
+#![feature(never_type)]
+#![feature(naked_functions)]
+#![feature(option_expect_none)]
 #![test_runner(crate::test_runner)]
 #![reexport_test_harness_main = "test_main"]

 extern crate alloc;
-extern crate rlibc;

 use core::panic::PanicInfo;

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

 pub fn init() {
    gdt::init();
@@ -28,25 +33,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
@@ -6,36 +6,85 @@

 extern crate alloc;

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

 entry_point!(kernel_main);

-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 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");

+    // 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();

-    let mut executor = Executor::new();
-    executor.spawn(Task::new(example_task()));
-    executor.spawn(Task::new(keyboard::print_keypresses()));
-    executor.run();
+    let idle_thread = Thread::create(idle_thread, 2, &mut mapper, &mut frame_allocator).unwrap();
+    with_scheduler(|s| s.set_idle_thread(idle_thread));
+
+    for _ in 0..10 {
+        let thread = Thread::create(thread_entry, 2, &mut mapper, &mut frame_allocator).unwrap();
+        with_scheduler(|s| s.add_new_thread(thread));
+    }
+    let thread =
+        Thread::create_from_closure(|| thread_entry(), 2, &mut mapper, &mut frame_allocator)
+            .unwrap();
+    with_scheduler(|s| s.add_new_thread(thread));
+
+    println!("It did not crash!");
+    thread_entry();
+}
+
+fn idle_thread() -> ! {
+    loop {
+        x86_64::instructions::hlt();
+        multitasking::yield_now();
+    }
+}
+
+fn thread_entry() -> ! {
+    let thread_id = with_scheduler(|s| s.current_thread_id()).as_u64();
+    for _ in 0..=thread_id {
+        print!("{}", thread_id);
+        x86_64::instructions::hlt();
+    }
+    multitasking::exit_thread();
 }

 /// This function is called on panic.
@@ -43,8 +92,8 @@ fn kernel_main(boot_info: &'static mut BootInfo) -> ! {
 #[panic_handler]
 fn panic(info: &PanicInfo) -> ! {
    unsafe {
-        blog_os::framebuffer::WRITER.force_unlock();
-    };
+        blog_os::vga_buffer::WRITER.force_unlock();
+    }
    println!("{}", info);
    blog_os::hlt_loop();
 }
@@ -54,17 +103,3 @@ 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);
-}
--- 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,
+        mapper, FrameAllocator, Mapper, OffsetPageTable, Page, PageTable, PhysFrame, Size4KiB,
+        UnusedPhysFrame,
    },
    PhysAddr, VirtAddr,
 };
@@ -35,6 +36,54 @@ unsafe fn active_level_4_table(physical_memory_offset: VirtAddr) -> &'static mut
    &mut *page_table_ptr // unsafe
 }

+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct StackBounds {
+    start: VirtAddr,
+    end: VirtAddr,
+}
+
+impl StackBounds {
+    pub fn start(&self) -> VirtAddr {
+        self.start
+    }
+
+    pub fn end(&self) -> VirtAddr {
+        self.end
+    }
+}
+
+pub fn alloc_stack(
+    size_in_pages: u64,
+    mapper: &mut impl Mapper<Size4KiB>,
+    frame_allocator: &mut impl FrameAllocator<Size4KiB>,
+) -> Result<StackBounds, mapper::MapToError> {
+    use core::sync::atomic::{AtomicU64, Ordering};
+    use x86_64::structures::paging::PageTableFlags as Flags;
+
+    static STACK_ALLOC_NEXT: AtomicU64 = AtomicU64::new(0x_5555_5555_0000);
+
+    let guard_page_start = STACK_ALLOC_NEXT.fetch_add(
+        (size_in_pages + 1) * Page::<Size4KiB>::SIZE,
+        Ordering::SeqCst,
+    );
+    let guard_page = Page::from_start_address(VirtAddr::new(guard_page_start))
+        .expect("`STACK_ALLOC_NEXT` not page aligned");
+
+    let stack_start = guard_page + 1;
+    let stack_end = stack_start + size_in_pages;
+    let flags = Flags::PRESENT | Flags::WRITABLE;
+    for page in Page::range(stack_start, stack_end) {
+        let frame = frame_allocator
+            .allocate_frame()
+            .ok_or(mapper::MapToError::FrameAllocationFailed)?;
+        mapper.map_to(page, frame, flags, frame_allocator)?.flush();
+    }
+    Ok(StackBounds {
+        start: stack_start.start_address(),
+        end: stack_end.start_address(),
+    })
+}
+
 /// Creates an example mapping for the given page to frame `0xb8000`.
 pub fn create_example_mapping(
    page: Page,
@@ -44,12 +93,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 +105,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 +122,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 +130,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/multitasking/context_switch.rs
+++ b/src/multitasking/context_switch.rs
@@ -0,0 +1,105 @@
+use super::{with_scheduler, SwitchReason};
+use crate::multitasking::thread::ThreadId;
+use alloc::boxed::Box;
+use core::mem;
+use core::raw::TraitObject;
+use x86_64::VirtAddr;
+
+pub struct Stack {
+    pointer: VirtAddr,
+}
+
+impl Stack {
+    pub unsafe fn new(stack_pointer: VirtAddr) -> Self {
+        Stack {
+            pointer: stack_pointer,
+        }
+    }
+
+    pub fn get_stack_pointer(self) -> VirtAddr {
+        self.pointer
+    }
+
+    pub fn set_up_for_closure(&mut self, closure: Box<dyn FnOnce() -> !>) {
+        let trait_object: TraitObject = unsafe { mem::transmute(closure) };
+        unsafe { self.push(trait_object.data) };
+        unsafe { self.push(trait_object.vtable) };
+
+        self.set_up_for_entry_point(call_closure_entry);
+    }
+
+    pub fn set_up_for_entry_point(&mut self, entry_point: fn() -> !) {
+        unsafe { self.push(entry_point) };
+        let rflags: u64 = 0x200;
+        unsafe { self.push(rflags) };
+    }
+
+    unsafe fn push<T>(&mut self, value: T) {
+        self.pointer -= core::mem::size_of::<T>();
+        let ptr: *mut T = self.pointer.as_mut_ptr();
+        ptr.write(value);
+    }
+}
+
+pub unsafe fn context_switch_to(
+    new_stack_pointer: VirtAddr,
+    prev_thread_id: ThreadId,
+    switch_reason: SwitchReason,
+) {
+    asm!(
+        "call asm_context_switch"
+        :
+        : "{rdi}"(new_stack_pointer), "{rsi}"(prev_thread_id), "{rdx}"(switch_reason as u64)
+        : "rax", "rbx", "rcx", "rdx", "rsi", "rdi", "rbp", "r8", "r9", "r10",
+        "r11", "r12", "r13", "r14", "r15", "rflags", "memory"
+        : "intel", "volatile"
+    );
+}
+
+global_asm!(
+    "
+    .intel_syntax noprefix
+
+    // asm_context_switch(stack_pointer: u64, thread_id: u64)
+    asm_context_switch:
+        pushfq
+
+        mov rax, rsp
+        mov rsp, rdi
+
+        mov rdi, rax
+        call add_paused_thread
+
+        popfq
+        ret
+"
+);
+
+#[no_mangle]
+pub extern "C" fn add_paused_thread(
+    paused_stack_pointer: VirtAddr,
+    paused_thread_id: ThreadId,
+    switch_reason: SwitchReason,
+) {
+    with_scheduler(|s| s.add_paused_thread(paused_stack_pointer, paused_thread_id, switch_reason));
+}
+
+#[naked]
+fn call_closure_entry() -> ! {
+    unsafe {
+        asm!("
+        pop rsi
+        pop rdi
+        call call_closure
+    " ::: "mem" : "intel", "volatile")
+    };
+    unreachable!();
+}
+
+// no_mangle required because of https://github.com/rust-lang/rust/issues/68136
+#[no_mangle]
+extern "C" fn call_closure(data: *mut (), vtable: *mut ()) -> ! {
+    let trait_object = TraitObject { data, vtable };
+    let f: Box<dyn FnOnce() -> !> = unsafe { mem::transmute(trait_object) };
+    f()
+}
--- a/src/multitasking/mod.rs
+++ b/src/multitasking/mod.rs
@@ -0,0 +1,57 @@
+use scheduler::Scheduler;
+
+pub mod context_switch;
+pub mod scheduler;
+pub mod thread;
+
+static SCHEDULER: spin::Mutex<Option<Scheduler>> = spin::Mutex::new(None);
+
+#[repr(u64)]
+pub enum SwitchReason {
+    Paused,
+    Yield,
+    Blocked,
+    Exit,
+}
+
+pub fn invoke_scheduler() {
+    let next = SCHEDULER
+        .try_lock()
+        .and_then(|mut scheduler| scheduler.as_mut().and_then(|s| s.schedule()));
+    if let Some((next_stack_pointer, prev_thread_id)) = next {
+        unsafe {
+            context_switch::context_switch_to(
+                next_stack_pointer,
+                prev_thread_id,
+                SwitchReason::Paused,
+            )
+        };
+    }
+}
+
+pub fn exit_thread() -> ! {
+    synchronous_context_switch(SwitchReason::Exit).expect("can't exit last thread");
+    unreachable!("finished thread continued");
+}
+
+pub fn yield_now() {
+    let _ = synchronous_context_switch(SwitchReason::Yield);
+}
+
+fn synchronous_context_switch(reason: SwitchReason) -> Result<(), ()> {
+    let next = with_scheduler(|s| s.schedule());
+    match next {
+        Some((next_stack_pointer, prev_thread_id)) => unsafe {
+            context_switch::context_switch_to(next_stack_pointer, prev_thread_id, reason);
+            Ok(())
+        },
+        None => Err(()),
+    }
+}
+
+pub fn with_scheduler<F, T>(f: F) -> T
+where
+    F: FnOnce(&mut Scheduler) -> T,
+{
+    f(SCHEDULER.lock().get_or_insert_with(Scheduler::new))
+}
--- a/src/multitasking/scheduler.rs
+++ b/src/multitasking/scheduler.rs
@@ -0,0 +1,122 @@
+use super::SwitchReason;
+use crate::multitasking::thread::{Thread, ThreadId};
+use alloc::collections::{BTreeMap, BTreeSet, VecDeque};
+use core::mem;
+use x86_64::VirtAddr;
+
+pub struct Scheduler {
+    threads: BTreeMap<ThreadId, Thread>,
+    idle_thread_id: Option<ThreadId>,
+    current_thread_id: ThreadId,
+    paused_threads: VecDeque<ThreadId>,
+    blocked_threads: BTreeSet<ThreadId>,
+    wakeups: BTreeSet<ThreadId>,
+}
+
+impl Scheduler {
+    pub fn new() -> Self {
+        let root_thread = Thread::create_root_thread();
+        let root_id = root_thread.id();
+        let mut threads = BTreeMap::new();
+        threads
+            .insert(root_id, root_thread)
+            .expect_none("map is not empty after creation");
+        Scheduler {
+            threads,
+            current_thread_id: root_id,
+            paused_threads: VecDeque::new(),
+            blocked_threads: BTreeSet::new(),
+            wakeups: BTreeSet::new(),
+            idle_thread_id: None,
+        }
+    }
+
+    fn next_thread(&mut self) -> Option<ThreadId> {
+        self.paused_threads.pop_front()
+    }
+
+    pub fn schedule(&mut self) -> Option<(VirtAddr, ThreadId)> {
+        let mut next_thread_id = self.next_thread();
+        if next_thread_id.is_none() && Some(self.current_thread_id) != self.idle_thread_id {
+            next_thread_id = self.idle_thread_id
+        }
+        if let Some(next_id) = next_thread_id {
+            let next_thread = self
+                .threads
+                .get_mut(&next_id)
+                .expect("next thread does not exist");
+            let next_stack_pointer = next_thread
+                .stack_pointer()
+                .take()
+                .expect("paused thread has no stack pointer");
+            let prev_thread_id = mem::replace(&mut self.current_thread_id, next_thread.id());
+            Some((next_stack_pointer, prev_thread_id))
+        } else {
+            None
+        }
+    }
+
+    pub(super) fn add_paused_thread(
+        &mut self,
+        paused_stack_pointer: VirtAddr,
+        paused_thread_id: ThreadId,
+        switch_reason: SwitchReason,
+    ) {
+        let paused_thread = self
+            .threads
+            .get_mut(&paused_thread_id)
+            .expect("paused thread does not exist");
+        paused_thread
+            .stack_pointer()
+            .replace(paused_stack_pointer)
+            .expect_none("running thread should have stack pointer set to None");
+        if Some(paused_thread_id) == self.idle_thread_id {
+            return; // do nothing
+        }
+        match switch_reason {
+            SwitchReason::Paused | SwitchReason::Yield => {
+                self.paused_threads.push_back(paused_thread_id)
+            }
+            SwitchReason::Blocked => {
+                self.blocked_threads.insert(paused_thread_id);
+                self.check_for_wakeup(paused_thread_id);
+            }
+            SwitchReason::Exit => {
+                let thread = self
+                    .threads
+                    .remove(&paused_thread_id)
+                    .expect("thread not found");
+                // TODO: free stack memory again
+            }
+        }
+    }
+
+    pub fn add_new_thread(&mut self, thread: Thread) {
+        let thread_id = thread.id();
+        self.threads
+            .insert(thread_id, thread)
+            .expect_none("thread already exists");
+        self.paused_threads.push_back(thread_id);
+    }
+
+    pub fn set_idle_thread(&mut self, thread: Thread) {
+        let thread_id = thread.id();
+        self.threads
+            .insert(thread_id, thread)
+            .expect_none("thread already exists");
+        self.idle_thread_id
+            .replace(thread_id)
+            .expect_none("idle thread should be set only once");
+    }
+
+    pub fn current_thread_id(&self) -> ThreadId {
+        self.current_thread_id
+    }
+
+    fn check_for_wakeup(&mut self, thread_id: ThreadId) {
+        if self.wakeups.remove(&thread_id) {
+            assert!(self.blocked_threads.remove(&thread_id));
+            self.paused_threads.push_back(thread_id);
+        }
+    }
+}
--- a/src/multitasking/thread.rs
+++ b/src/multitasking/thread.rs
@@ -0,0 +1,82 @@
+use crate::memory::{alloc_stack, StackBounds};
+use crate::multitasking::context_switch::Stack;
+use alloc::boxed::Box;
+use x86_64::{
+    structures::paging::{mapper, FrameAllocator, Mapper, Size4KiB},
+    VirtAddr,
+};
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
+pub struct ThreadId(u64);
+
+impl ThreadId {
+    pub fn as_u64(&self) -> u64 {
+        self.0
+    }
+
+    fn new() -> Self {
+        use core::sync::atomic::{AtomicU64, Ordering};
+        static NEXT_THREAD_ID: AtomicU64 = AtomicU64::new(1);
+        ThreadId(NEXT_THREAD_ID.fetch_add(1, Ordering::SeqCst))
+    }
+}
+
+#[derive(Debug)]
+pub struct Thread {
+    id: ThreadId,
+    stack_pointer: Option<VirtAddr>,
+    stack_bounds: Option<StackBounds>,
+}
+
+impl Thread {
+    pub fn create(
+        entry_point: fn() -> !,
+        stack_size: u64,
+        mapper: &mut impl Mapper<Size4KiB>,
+        frame_allocator: &mut impl FrameAllocator<Size4KiB>,
+    ) -> Result<Self, mapper::MapToError> {
+        let stack_bounds = alloc_stack(stack_size, mapper, frame_allocator)?;
+        let mut stack = unsafe { Stack::new(stack_bounds.end()) };
+        stack.set_up_for_entry_point(entry_point);
+        Ok(Self::new(stack.get_stack_pointer(), stack_bounds))
+    }
+
+    pub fn create_from_closure<F>(
+        closure: F,
+        stack_size: u64,
+        mapper: &mut impl Mapper<Size4KiB>,
+        frame_allocator: &mut impl FrameAllocator<Size4KiB>,
+    ) -> Result<Self, mapper::MapToError>
+    where
+        F: FnOnce() -> ! + 'static + Send + Sync,
+    {
+        let stack_bounds = alloc_stack(stack_size, mapper, frame_allocator)?;
+        let mut stack = unsafe { Stack::new(stack_bounds.end()) };
+        stack.set_up_for_closure(Box::new(closure));
+        Ok(Self::new(stack.get_stack_pointer(), stack_bounds))
+    }
+
+    fn new(stack_pointer: VirtAddr, stack_bounds: StackBounds) -> Self {
+        Thread {
+            id: ThreadId::new(),
+            stack_pointer: Some(stack_pointer),
+            stack_bounds: Some(stack_bounds),
+        }
+    }
+
+    pub(super) fn create_root_thread() -> Self {
+        Thread {
+            id: ThreadId(0),
+            stack_pointer: None,
+            stack_bounds: None,
+        }
+    }
+
+    pub fn id(&self) -> ThreadId {
+        self.id
+    }
+
+    pub(super) fn stack_pointer(&mut self) -> &mut Option<VirtAddr> {
+        &mut self.stack_pointer
+    }
+}
--- a/src/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,83 +0,0 @@
-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),
-                }
-            }
-        }
-    }
-}
--- a/src/task/mod.rs
+++ b/src/task/mod.rs
@@ -1,39 +0,0 @@
-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))
-    }
-}
--- a/src/task/simple_executor.rs
+++ b/src/task/simple_executor.rs
@@ -1,44 +0,0 @@
-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()) }
-}
--- 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	3fc7bf6aa1	Fix register typo: rpb -> rbp Fixes #746	2020-02-16 18:02:24 +01:00
Philipp Oppermann	b337f65abb	Add a yield_now function and use it in idle thread	2020-01-28 12:28:50 +01:00
Philipp Oppermann	22c6bd5aa7	Add idle thread and begin support for blocking	2020-01-28 12:22:37 +01:00
Philipp Oppermann	87719f2260	Switch current_thread_id before context switch	2020-01-28 11:29:21 +01:00
Philipp Oppermann	0caf5c351e	Run cargo fmt	2020-01-23 14:24:13 +01:00
Philipp Oppermann	cb7bb0ddef	Refactor and rewrite	2020-01-23 14:22:29 +01:00
Philipp Oppermann	7ad30651fb	Rename allocator.rs to allocator/mod.rs	2020-01-23 11:46:45 +01:00
Philipp Oppermann	49923acb3f	Print thread id instead of hardcoding numbers	2020-01-23 11:03:15 +01:00
Philipp Oppermann	f2b1f3a593	Fix handling of current thread id	2020-01-23 10:49:51 +01:00
Philipp Oppermann	5e2e0b629e	Refactor threading code	2020-01-23 10:42:37 +01:00
Philipp Oppermann	35379c90e6	Force unlock writer on panic to avoid deadlocks	2020-01-23 10:42:19 +01:00
Philipp Oppermann	e5d10fcaec	Increase stack size to avoid stack overflow	2020-01-23 10:41:59 +01:00
Philipp Oppermann	e1242a867f	Move global_asm inline in threads module	2020-01-23 09:20:17 +01:00
Philipp Oppermann	cd138a3a1b	Rename multitasking module to `threads`	2020-01-23 09:19:38 +01:00
Philipp Oppermann	11a0eb679c	Fix race condition The first timer interrupt might occur before the heap is initialized. With lazy_static, this causes an allocation failure since the VecDeque is allocated when it's accessed the first time. This commit fixes this by only initializing VecDeque in `add_thread`.	2020-01-23 08:50:35 +01:00
Philipp Oppermann	241c1ab2c9	Add support for closures	2020-01-23 08:24:48 +01:00
Philipp Oppermann	b75406b37e	Add new modules	2020-01-22 17:24:17 +01:00
Philipp Oppermann	c3450b6df7	Refactor a bit	2020-01-22 16:33:23 +01:00
Philipp Oppermann	ce1fdcf768	Wip	2020-01-22 16:15:23 +01:00