Add code for tutorial 03

03_hacky_hello_world/Cargo.lock

@@ -0,0 +1,16 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+[[package]]
+name = "kernel"
+version = "0.1.0"
+dependencies = [
+ "r0 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)",
+]
+
+[[package]]
+name = "r0"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+
+[metadata]
+"checksum r0 0.2.2 (registry+https://github.com/rust-lang/crates.io-index)" = "e2a38df5b15c8d5c7e8654189744d8e396bddc18ad48041a500ce52d6948941f"

03_hacky_hello_world/Cargo.toml

@@ -0,0 +1,16 @@
+[package]
+name = "kernel"
+version = "0.1.0"
+authors = ["Andre Richter <andre.o.richter@gmail.com>"]
+edition = "2018"
+
+[package.metadata.cargo-xbuild]
+sysroot_path = "../xbuild_sysroot"
+
+# The features section is used to select the target board.
+[features]
+default = []
+bsp_rpi3 = []
+
+[dependencies]
+r0 = "0.2.2"

03_hacky_hello_world/Makefile

@@ -0,0 +1,76 @@
+## SPDX-License-Identifier: MIT
+##
+## Copyright (c) 2018-2019 Andre Richter <andre.o.richter@gmail.com>
+
+# Default to the RPi3
+ifndef BSP
+	BSP = bsp_rpi3
+endif
+
+# BSP-specific arguments
+ifeq ($(BSP),bsp_rpi3)
+	TARGET = aarch64-unknown-none
+	OUTPUT = kernel8.img
+	QEMU_BINARY = qemu-system-aarch64
+	QEMU_MACHINE_TYPE = raspi3
+	QEMU_MISC_ARGS = -serial null -serial stdio
+	LINKER_FILE = src/bsp/rpi3/link.ld
+	RUSTC_MISC_ARGS = -C target-feature=-fp-armv8 -C target-cpu=cortex-a53
+endif
+
+SOURCES = $(wildcard **/*.rs) $(wildcard **/*.S) $(wildcard **/*.ld)
+
+XRUSTC_CMD = cargo xrustc \
+		--target=$(TARGET) \
+		--features $(BSP) \
+		--release \
+		-- \
+		-C link-arg=-T$(LINKER_FILE) \
+		$(RUSTC_MISC_ARGS)
+
+CARGO_OUTPUT = target/$(TARGET)/release/kernel
+
+OBJCOPY_CMD = cargo objcopy \
+		-- \
+		--strip-all \
+		-O binary
+
+CONTAINER_UTILS   = rustembedded/osdev-utils
+
+DOCKER_CMD        = docker run -it --rm
+DOCKER_ARG_CURDIR = -v $(shell pwd):/work -w /work
+DOCKER_EXEC_QEMU  = $(QEMU_BINARY) -M $(QEMU_MACHINE_TYPE) -kernel $(OUTPUT)
+
+.PHONY: all qemu clippy clean readelf objdump nm
+
+all: clean $(OUTPUT)
+
+$(CARGO_OUTPUT): $(SOURCES)
+	RUSTFLAGS="-D warnings -D missing_docs" $(XRUSTC_CMD)
+
+$(OUTPUT): $(CARGO_OUTPUT)
+	cp $< .
+	$(OBJCOPY_CMD) $< $(OUTPUT)
+
+doc:
+	cargo xdoc --target=$(TARGET) --features $(BSP) --document-private-items
+	xdg-open target/$(TARGET)/doc/kernel/index.html
+
+qemu: all
+	$(DOCKER_CMD) $(DOCKER_ARG_CURDIR) $(CONTAINER_UTILS) \
+	$(DOCKER_EXEC_QEMU) $(QEMU_MISC_ARGS)
+
+clippy:
+	cargo xclippy --target=$(TARGET) --features $(BSP)
+
+clean:
+	cargo clean
+
+readelf:
+	readelf -a kernel
+
+objdump:
+	cargo objdump --target $(TARGET) -- -disassemble -print-imm-hex kernel
+
+nm:
+	cargo nm --target $(TARGET) -- kernel | sort

03_hacky_hello_world/src/bsp.rs

@@ -0,0 +1,11 @@
+// SPDX-License-Identifier: MIT
+//
+// Copyright (c) 2018-2019 Andre Richter <andre.o.richter@gmail.com>
+
+//! Conditional exporting of Board Support Packages.
+
+#[cfg(feature = "bsp_rpi3")]
+pub mod rpi3;
+
+#[cfg(feature = "bsp_rpi3")]
+pub use rpi3::*;

03_hacky_hello_world/src/bsp/rpi3.rs

@@ -0,0 +1,43 @@
+// SPDX-License-Identifier: MIT
+//
+// Copyright (c) 2018-2019 Andre Richter <andre.o.richter@gmail.com>
+
+//! Board Support Package for the Raspberry Pi 3.
+
+mod panic_wait;
+
+use crate::interface::console;
+use core::fmt;
+
+global_asm!(include_str!("rpi3/start.S"));
+
+/// A mystical, magical device for generating QEMU output out of the void.
+struct QEMUOutput;
+
+/// Implementing `console::Write` enables usage of the `format_args!` macros,
+/// which in turn are used to implement the `kernel`'s `print!` and `println!`
+/// macros.
+///
+/// See [`src/print.rs`].
+///
+/// [`src/print.rs`]: ../../print/index.html
+impl console::Write for QEMUOutput {
+    fn write_str(&mut self, s: &str) -> fmt::Result {
+        for c in s.chars() {
+            unsafe {
+                core::ptr::write_volatile(0x3F21_5040 as *mut u8, c as u8);
+            }
+        }
+
+        Ok(())
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+// Implementation of the kernel's BSP calls
+////////////////////////////////////////////////////////////////////////////////
+
+/// Returns a ready-to-use `console::Write` implementation.
+pub fn console() -> impl console::Write {
+    QEMUOutput {}
+}

03_hacky_hello_world/src/bsp/rpi3/link.ld

@@ -0,0 +1,35 @@
+/* SPDX-License-Identifier: MIT
+ *
+ * Copyright (c) 2018-2019 Andre Richter <andre.o.richter@gmail.com>
+ */
+
+SECTIONS
+{
+    /* Set current address to the value from which the RPi3 starts execution */
+    . = 0x80000;
+
+    .text :
+    {
+        *(.text)
+    }
+
+    .rodata :
+    {
+        *(.rodata)
+    }
+
+    .data :
+    {
+        *(.data)
+    }
+
+    /* Align to 8 byte boundary */
+    .bss ALIGN(8):
+    {
+        __bss_start = .;
+        *(.bss);
+        __bss_end = .;
+    }
+
+    /DISCARD/ : { *(.comment) }
+}

03_hacky_hello_world/src/bsp/rpi3/panic_wait.rs

@@ -0,0 +1,23 @@
+// SPDX-License-Identifier: MIT
+//
+// Copyright (c) 2018-2019 Andre Richter <andre.o.richter@gmail.com>
+
+//! A panic handler that infinitely waits.
+
+use crate::println;
+use core::panic::PanicInfo;
+
+#[panic_handler]
+fn panic(info: &PanicInfo) -> ! {
+    if let Some(args) = info.message() {
+        println!("{}", args);
+    } else {
+        println!("Kernel panic!");
+    }
+
+    unsafe {
+        loop {
+            asm!("wfe" :::: "volatile")
+        }
+    }
+}

03_hacky_hello_world/src/bsp/rpi3/start.S

@@ -0,0 +1,19 @@
+// SPDX-License-Identifier: MIT
+//
+// Copyright (c) 2018-2019 Andre Richter <andre.o.richter@gmail.com>
+
+.global _start
+
+_start:
+    mrs     x1, mpidr_el1   // Read Multiprocessor Affinity Register
+    and     x1, x1, #3      // Clear all bits except [1:0], which hold core id
+    cbz     x1, 2f          // Jump to label 2 if we are core 0
+1:  wfe                     // Wait for event
+    b       1b              // In case an event happend, jump back to 1
+2:                          // If we are here, we are core0
+    ldr     x1, =_start     // Load address of function "_start()"
+    mov     sp, x1          // Set start of stack to before our code, aka first
+                            // address before "_start()"
+    bl      init            // Jump to the "init()" kernel function
+    b       1b              // We should never reach here. But just in case,
+                            // park this core aswell

03_hacky_hello_world/src/interface.rs

@@ -0,0 +1,36 @@
+// SPDX-License-Identifier: MIT
+//
+// Copyright (c) 2018-2019 Andre Richter <andre.o.richter@gmail.com>
+
+//! Trait definitions for coupling `kernel` and `BSP` code.
+//!
+//! ```
+//!         +-------------------+
+//!         | Interface (Trait) |
+//!         |                   |
+//!         +--+-------------+--+
+//!            ^             ^
+//!            |             |
+//!            |             |
+//! +----------+--+       +--+----------+
+//! | Kernel code |       |  BSP Code   |
+//! |             |       |             |
+//! +-------------+       +-------------+
+//! ```
+
+/// System console operations.
+pub mod console {
+    /// Console write functions.
+    ///
+    /// `core::fmt::Write` is exactly what we need. Re-export it here because
+    /// implementing `console::Write` gives a better hint to the reader about
+    /// the intention.
+    pub use core::fmt::Write;
+
+    /// Console read functions.
+    pub trait Read {
+        fn read_char(&mut self) -> char {
+            ' '
+        }
+    }
+}

03_hacky_hello_world/src/main.rs

@@ -0,0 +1,36 @@
+// SPDX-License-Identifier: MIT
+//
+// Copyright (c) 2018-2019 Andre Richter <andre.o.richter@gmail.com>
+
+//! The `kernel`
+//!
+//! The `kernel` is composed by glueing together hardware-specific Board Support
+//! Package (`BSP`) code and hardware-agnostic `kernel` code through the
+//! [`kernel::interface`] traits.
+//!
+//! [`kernel::interface`]: interface/index.html
+
+#![feature(asm)]
+#![feature(format_args_nl)]
+#![feature(global_asm)]
+#![feature(panic_info_message)]
+#![no_main]
+#![no_std]
+
+// This module conditionally includes the correct `BSP` which provides the
+// `_start()` function, the first function to run.
+mod bsp;
+
+// Afterwards, `BSP`'s early init code calls `runtime_init::init()` of this
+// module, which on completion, jumps to `kernel_entry()`.
+mod runtime_init;
+
+mod interface;
+mod print;
+
+/// Entrypoint of the `kernel`.
+fn kernel_entry() -> ! {
+    println!("Hello from Rust!");
+
+    panic!("Stopping here.")
+}

03_hacky_hello_world/src/print.rs

@@ -0,0 +1,32 @@
+// SPDX-License-Identifier: MIT
+//
+// Copyright (c) 2018-2019 Andre Richter <andre.o.richter@gmail.com>
+
+//! Printing facilities.
+
+use crate::bsp;
+use crate::interface::console::Write;
+use core::fmt;
+
+/// Prints without a newline.
+///
+/// Carbon copy from https://doc.rust-lang.org/src/std/macros.rs.html
+#[macro_export]
+macro_rules! print {
+    ($($arg:tt)*) => ($crate::print::_print(format_args!($($arg)*)));
+}
+
+/// Prints with a newline.
+///
+/// Carbon copy from https://doc.rust-lang.org/src/std/macros.rs.html
+#[macro_export]
+macro_rules! println {
+    () => ($crate::print!("\n"));
+    ($($arg:tt)*) => ({
+        $crate::print::_print(format_args_nl!($($arg)*));
+    })
+}
+
+pub fn _print(args: fmt::Arguments) {
+    bsp::console().write_fmt(args).unwrap();
+}

03_hacky_hello_world/src/runtime_init.rs

@@ -0,0 +1,27 @@
+// SPDX-License-Identifier: MIT
+//
+// Copyright (c) 2018-2019 Andre Richter <andre.o.richter@gmail.com>
+
+//! Rust runtime initialization code.
+
+/// Equivalent to `crt0` or `c0` code in C/C++ world. Clears the `bss` section,
+/// then calls the kernel entry.
+///
+/// Called from BSP code.
+///
+/// # Safety
+///
+/// - Only a single core must be active and running this function.
+#[no_mangle]
+pub unsafe extern "C" fn init() -> ! {
+    extern "C" {
+        // Boundaries of the .bss section, provided by the linker script
+        static mut __bss_start: u64;
+        static mut __bss_end: u64;
+    }
+
+    // Zero out the .bss section
+    r0::zero_bss(&mut __bss_start, &mut __bss_end);
+
+    crate::kernel_entry()
+}