This is a tutorial series for hobby OS developers who are new to ARM's 64 bit ARMv8-A
architecture. The tutorials will give a guided, step-by-step tour of how to write a monolithic
kernel for an
embedded system from scratch. They cover implementation of common
Operating Systems tasks, like writing to the serial console, setting up virtual memory and handling
HW exceptions. All while leveraging
Rust's unique features to provide for safety and speed.
READMEwill have a short
tl;drsection giving a brief overview of the additions, and show the source code
diffto the previous tutorial, so that you can conveniently inspect the changes/additions.
tl;drsection. The long-term plan is that all tutorials get a full text, but for now this is exclusive to tutorials where I think that
diffare not enough to get the idea.
make doccommand in each tutorial. It lets you browse the extensively documented code in a convenient way.
The tutorials are primarily targeted at Linux-based distributions. Most stuff will also work on other Unix flavors such as macOS, but this is only experimental.
Ensure your user account is in the docker group.
Rust toolchain. Most of it will be handled on first use through the
rust-toolchain file. What's left for us to do is:
If you already have a version of Rust installed:
cargo install cargo-binutils rustfilt
If you need to install Rust from scratch:
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh source $HOME/.cargo/env cargo install cargo-binutils rustfilt
In case you use
Visual Studio Code, I strongly recommend installing the Rust Analyzer extension.
If you are NOT running Linux, some
Ruby gems are needed as well:
sudo gem install bundler bundle config set path '.vendor/bundle' bundle install
This series tries to put a strong focus on user friendliness. Therefore, efforts were made to
eliminate the biggest painpoint in embedded development as much as possible:
Rust itself is already helping a lot in that regard, because it has built-in support for
cross-compilation. All that we need for cross-compiling from an
x86 host to the Raspberry Pi's
AArch64 architecture will be automatically installed by
rustup. However, besides the Rust
compiler, we will use some more tools. Among others:
QEMUto emulate our kernel on the host system.
Minipushto load a kernel onto the Raspberry Pi on-demand over
GDBfor debugging on the target.
There is a lot that can go wrong while installing and/or compiling the correct version of each tool on your host machine. For example, your distribution might not provide the latest version that is needed. Or you are missing some hard-to-get dependencies for the compilation of one of these tools.
This is why we will make use of Docker whenever possible. We are providing an accompanying container that has all the needed tools or dependencies pre-installed, and it gets pulled in automagically once it is needed. If you want to know more about Docker and peek at the provided container, please refer to the repository's docker folder.
Since the kernel developed in the tutorials runs on the real hardware, it is highly recommended to get a USB serial cable to get the full experience.
GNDand GPIO pins
14/15as shown below.
chainloaderis developed, which will be the last file you need to manually copy on the SD card for a while. It will enable you to load the tutorial kernels during boot on demand over
Licensed under either of
at your option.
Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in the work by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions.