Refactor tutorial 03

03_hacky_hello_world/Makefile

@@ -14,7 +14,7 @@ ifeq ($(BSP),rpi3)
 	QEMU_BINARY       = qemu-system-aarch64
 	QEMU_MACHINE_TYPE = raspi3
 	QEMU_RELEASE_ARGS = -serial stdio -display none
-	LINKER_FILE       = src/bsp/rpi/link.ld
+	LINKER_FILE       = src/bsp/raspberrypi/link.ld
 	RUSTC_MISC_ARGS   = -C target-cpu=cortex-a53
 else ifeq ($(BSP),rpi4)
 	TARGET            = aarch64-unknown-none-softfloat
@@ -22,7 +22,7 @@ else ifeq ($(BSP),rpi4)
 	# QEMU_BINARY       = qemu-system-aarch64
 	# QEMU_MACHINE_TYPE =
 	# QEMU_RELEASE_ARGS = -serial stdio -display none
-	LINKER_FILE       = src/bsp/rpi/link.ld
+	LINKER_FILE       = src/bsp/raspberrypi/link.ld
 	RUSTC_MISC_ARGS   = -C target-cpu=cortex-a72
 endif
 
@@ -60,8 +60,7 @@ $(OUTPUT): $(CARGO_OUTPUT)
 	$(OBJCOPY_CMD) $< $(OUTPUT)
 
 doc:
-	cargo xdoc --target=$(TARGET) --features bsp_$(BSP) --document-private-items
-	xdg-open target/$(TARGET)/doc/kernel/index.html
+	cargo xdoc --target=$(TARGET) --features bsp_$(BSP) --document-private-items --open
 
 ifeq ($(QEMU_MACHINE_TYPE),)
 qemu:

03_hacky_hello_world/README.md

@@ -2,222 +2,27 @@
 
 ## tl;dr
 
-Introducing global `print!()` macros to enable "printf debugging" at the
-earliest; To keep tutorial length reasonable, printing functions for now "abuse" a
-QEMU property that lets us use the RPi's `UART` without setting it up properly;
-Using  the real hardware `UART` is enabled step-by-step in following tutorials.
+Introducing global `print!()` macros to enable "printf debugging" at the earliest; To keep tutorial
+length reasonable, printing functions for now "abuse" a QEMU property that lets us use the RPi's
+`UART` without setting it up properly; Using  the real hardware `UART` is enabled step-by-step in
+following tutorials.
 
-- `interface.rs` is introduced:
-	- Provides `Traits` for abstracting `kernel` from `BSP` and `arch` code.
-- Panic handler `print!()`s supplied error messages.
-    - This is showcased in `main()`.
+## Notable additions
 
-### Test it
+- `src/console.rs` introduces interface `Traits` for console commands.
+- `src/bsp/rpi.rs` implements the interface for QEMU's emulated UART.
+- The panic handler makes use of the new `print!()` to display user error messages.
 
-QEMU is no longer running in assembly mode. It will from now on show the output
-of the `console`.
+## Test it
+
+QEMU is no longer running in assembly mode. It will from now on show the output of the `console`.
 
 ```console
-» make qemu
+$ make qemu
 [...]
 Hello from Rust!
+
 Kernel panic: Stopping here.
 ```
 
 ## Diff to previous
-```diff
-
-diff -uNr 02_runtime_init/src/bsp/rpi.rs 03_hacky_hello_world/src/bsp/rpi.rs
---- 02_runtime_init/src/bsp/rpi.rs
-+++ 03_hacky_hello_world/src/bsp/rpi.rs
-@@ -4,4 +4,35 @@
-
- //! Board Support Package for the Raspberry Pi.
-
--// Coming soon.
-+use crate::interface;
-+use core::fmt;
-+
-+/// 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 interface::console::Write for QEMUOutput {
-+    fn write_str(&mut self, s: &str) -> fmt::Result {
-+        for c in s.chars() {
-+            unsafe {
-+                core::ptr::write_volatile(0x3F20_1000 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 interface::console::Write {
-+    QEMUOutput {}
-+}
-
-diff -uNr 02_runtime_init/src/interface.rs 03_hacky_hello_world/src/interface.rs
---- 02_runtime_init/src/interface.rs
-+++ 03_hacky_hello_world/src/interface.rs
-@@ -0,0 +1,37 @@
-+// SPDX-License-Identifier: MIT OR Apache-2.0
-+//
-+// Copyright (c) 2018-2020 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 for now. 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 {
-+        /// Read a single character.
-+        fn read_char(&self) -> char {
-+            ' '
-+        }
-+    }
-+}
-
-diff -uNr 02_runtime_init/src/main.rs 03_hacky_hello_world/src/main.rs
---- 02_runtime_init/src/main.rs
-+++ 03_hacky_hello_world/src/main.rs
-@@ -6,9 +6,23 @@
- #![doc(html_logo_url = "https://git.io/JeGIp")]
-
- //! The `kernel`
-+//!
-+//! The `kernel` is composed by glueing together code from
-+//!
-+//!   - [Hardware-specific Board Support Packages] (`BSPs`).
-+//!   - [Architecture-specific code].
-+//!   - HW- and architecture-agnostic `kernel` code.
-+//!
-+//! using the [`kernel::interface`] traits.
-+//!
-+//! [Hardware-specific Board Support Packages]: bsp/index.html
-+//! [Architecture-specific code]: arch/index.html
-+//! [`kernel::interface`]: interface/index.html
-
- #![feature(asm)]
-+#![feature(format_args_nl)]
- #![feature(global_asm)]
-+#![feature(panic_info_message)]
- #![no_main]
- #![no_std]
-
-@@ -22,8 +36,10 @@
- // Conditionally includes the selected `BSP` code.
- mod bsp;
-
-+mod interface;
- mod memory;
- mod panic_wait;
-+mod print;
-
- /// Early init code.
- ///
-@@ -31,5 +47,7 @@
- ///
- /// - Only a single core must be active and running this function.
- unsafe fn kernel_init() -> ! {
--    panic!()
-+    println!("Hello from Rust!");
-+
-+    panic!("Stopping here.")
- }
-
-diff -uNr 02_runtime_init/src/panic_wait.rs 03_hacky_hello_world/src/panic_wait.rs
---- 02_runtime_init/src/panic_wait.rs
-+++ 03_hacky_hello_world/src/panic_wait.rs
-@@ -4,9 +4,16 @@
-
- //! A panic handler that infinitely waits.
-
-+use crate::{arch, println};
- use core::panic::PanicInfo;
-
- #[panic_handler]
--fn panic(_info: &PanicInfo) -> ! {
--    crate::arch::wait_forever()
-+fn panic(info: &PanicInfo) -> ! {
-+    if let Some(args) = info.message() {
-+        println!("\nKernel panic: {}", args);
-+    } else {
-+        println!("\nKernel panic!");
-+    }
-+
-+    arch::wait_forever()
- }
-
-diff -uNr 02_runtime_init/src/print.rs 03_hacky_hello_world/src/print.rs
---- 02_runtime_init/src/print.rs
-+++ 03_hacky_hello_world/src/print.rs
-@@ -0,0 +1,34 @@
-+// SPDX-License-Identifier: MIT OR Apache-2.0
-+//
-+// Copyright (c) 2018-2020 Andre Richter <andre.o.richter@gmail.com>
-+
-+//! Printing facilities.
-+
-+use crate::{bsp, interface};
-+use core::fmt;
-+
-+#[doc(hidden)]
-+pub fn _print(args: fmt::Arguments) {
-+    use interface::console::Write;
-+
-+    bsp::console().write_fmt(args).unwrap();
-+}
-+
-+/// 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)*));
-+    })
-+}
-
-```

03_hacky_hello_world/src/_arch/aarch64/cpu.rs

@@ -2,15 +2,16 @@
 //
 // Copyright (c) 2018-2020 Andre Richter <andre.o.richter@gmail.com>
 
-//! AArch64.
+//! Architectural processor code.
 
-global_asm!(include_str!("aarch64/start.S"));
+// Assembly counterpart to this file.
+global_asm!(include_str!("cpu.S"));
 
 //--------------------------------------------------------------------------------------------------
-// Implementation of the kernel's architecture abstraction code
+// Public Code
 //--------------------------------------------------------------------------------------------------
 
-/// Pause execution on the calling CPU core.
+/// Pause execution on the core.
 #[inline(always)]
 pub fn wait_forever() -> ! {
     unsafe {

03_hacky_hello_world/src/arch.rs

@@ -1,11 +0,0 @@
-// SPDX-License-Identifier: MIT OR Apache-2.0
-//
-// Copyright (c) 2018-2020 Andre Richter <andre.o.richter@gmail.com>
-
-//! Conditional exporting of processor architecture code.
-
-#[cfg(any(feature = "bsp_rpi3", feature = "bsp_rpi4"))]
-mod aarch64;
-
-#[cfg(any(feature = "bsp_rpi3", feature = "bsp_rpi4"))]
-pub use aarch64::*;

03_hacky_hello_world/src/bsp.rs

@@ -2,10 +2,10 @@
 //
 // Copyright (c) 2018-2020 Andre Richter <andre.o.richter@gmail.com>
 
-//! Conditional exporting of Board Support Packages.
+//! Conditional re-exporting of Board Support Packages.
 
 #[cfg(any(feature = "bsp_rpi3", feature = "bsp_rpi4"))]
-mod rpi;
+mod raspberrypi;
 
 #[cfg(any(feature = "bsp_rpi3", feature = "bsp_rpi4"))]
-pub use rpi::*;
+pub use raspberrypi::*;

03_hacky_hello_world/src/bsp/raspberrypi.rs

@@ -0,0 +1,7 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+//
+// Copyright (c) 2018-2020 Andre Richter <andre.o.richter@gmail.com>
+
+//! Top-level BSP file for the Raspberry Pi 3 and 4.
+
+pub mod console;

03_hacky_hello_world/src/bsp/raspberrypi/console.rs

@@ -0,0 +1,47 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+//
+// Copyright (c) 2018-2020 Andre Richter <andre.o.richter@gmail.com>
+
+//! BSP console facilities.
+
+use crate::console;
+use core::fmt;
+
+//--------------------------------------------------------------------------------------------------
+// Private Definitions
+//--------------------------------------------------------------------------------------------------
+
+/// A mystical, magical device for generating QEMU output out of the void.
+struct QEMUOutput;
+
+//--------------------------------------------------------------------------------------------------
+// Private Code
+//--------------------------------------------------------------------------------------------------
+
+/// Implementing `core::fmt::Write` enables usage of the `format_args!` macros, which in turn are
+/// used to implement the `kernel`'s `print!` and `println!` macros. By implementing `write_str()`,
+/// we get `write_fmt()` automatically.
+///
+/// See [`src/print.rs`].
+///
+/// [`src/print.rs`]: ../../print/index.html
+impl fmt::Write for QEMUOutput {
+    fn write_str(&mut self, s: &str) -> fmt::Result {
+        for c in s.chars() {
+            unsafe {
+                core::ptr::write_volatile(0x3F20_1000 as *mut u8, c as u8);
+            }
+        }
+
+        Ok(())
+    }
+}
+
+//--------------------------------------------------------------------------------------------------
+// Public Code
+//--------------------------------------------------------------------------------------------------
+
+/// Return a reference to the console.
+pub fn console() -> impl console::interface::Write {
+    QEMUOutput {}
+}

03_hacky_hello_world/src/bsp/rpi.rs

@@ -1,38 +0,0 @@
-// SPDX-License-Identifier: MIT OR Apache-2.0
-//
-// Copyright (c) 2018-2020 Andre Richter <andre.o.richter@gmail.com>
-
-//! Board Support Package for the Raspberry Pi.
-
-use crate::interface;
-use core::fmt;
-
-/// 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 interface::console::Write for QEMUOutput {
-    fn write_str(&mut self, s: &str) -> fmt::Result {
-        for c in s.chars() {
-            unsafe {
-                core::ptr::write_volatile(0x3F20_1000 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 interface::console::Write {
-    QEMUOutput {}
-}

03_hacky_hello_world/src/console.rs

@@ -0,0 +1,19 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+//
+// Copyright (c) 2018-2020 Andre Richter <andre.o.richter@gmail.com>
+
+//! System console.
+
+//--------------------------------------------------------------------------------------------------
+// Public Definitions
+//--------------------------------------------------------------------------------------------------
+
+/// Console interfaces.
+pub mod interface {
+    /// Console write functions.
+    ///
+    /// `core::fmt::Write` is exactly what we need for now. Re-export it here because
+    /// implementing `console::Write` gives a better hint to the reader about the
+    /// intention.
+    pub use core::fmt::Write;
+}

03_hacky_hello_world/src/cpu.rs

@@ -0,0 +1,10 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+//
+// Copyright (c) 2020 Andre Richter <andre.o.richter@gmail.com>
+
+//! Processor code.
+
+#[cfg(target_arch = "aarch64")]
+#[path = "_arch/aarch64/cpu.rs"]
+mod arch_cpu;
+pub use arch_cpu::*;

03_hacky_hello_world/src/interface.rs

@@ -1,37 +0,0 @@
-// SPDX-License-Identifier: MIT OR Apache-2.0
-//
-// Copyright (c) 2018-2020 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 for now. 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 {
-        /// Read a single character.
-        fn read_char(&self) -> char {
-            ' '
-        }
-    }
-}

03_hacky_hello_world/src/main.rs

@@ -5,19 +5,92 @@
 // Rust embedded logo for `make doc`.
 #![doc(html_logo_url = "https://git.io/JeGIp")]
 
-//! The `kernel`
+//! The `kernel` binary.
 //!
-//! The `kernel` is composed by glueing together code from
+//! # Code organization and architecture
 //!
-//!   - [Hardware-specific Board Support Packages] (`BSPs`).
-//!   - [Architecture-specific code].
-//!   - HW- and architecture-agnostic `kernel` code.
+//! The code is divided into different *modules*, each representing a typical **subsystem** of the
+//! `kernel`. Top-level module files of subsystems reside directly in the `src` folder. For example,
+//! `src/memory.rs` contains code that is concerned with all things memory management.
 //!
-//! using the [`kernel::interface`] traits.
+//! ## Visibility of processor architecture code
 //!
-//! [Hardware-specific Board Support Packages]: bsp/index.html
-//! [Architecture-specific code]: arch/index.html
-//! [`kernel::interface`]: interface/index.html
+//! Some of the `kernel`'s subsystems depend on low-level code that is specific to the target
+//! processor architecture. For each supported processor architecture, there exists a subfolder in
+//! `src/_arch`, for example, `src/_arch/aarch64`.
+//!
+//! The architecture folders mirror the subsystem modules laid out in `src`. For example,
+//! architectural code that belongs to the `kernel`'s memory subsystem (`src/memory.rs`) would go
+//! into `src/_arch/aarch64/memory.rs`. The latter file is directly included and re-exported in
+//! `src/memory.rs`, so that the architectural code parts are transparent with respect to the code's
+//! module organization. That means a public function `foo()` defined in
+//! `src/_arch/aarch64/memory.rs` would be reachable as `crate::memory::foo()` only.
+//!
+//! The `_` in `_arch` denotes that this folder is not part of the standard module hierarchy.
+//! Rather, it's contents are conditionally pulled into respective files using the `#[path =
+//! "_arch/xxx/yyy.rs"]` attribute.
+//!
+//! ## BSP code
+//!
+//! `BSP` stands for Board Support Package. `BSP` code is organized under `src/bsp.rs` and contains
+//! target board specific definitions and functions. These are things such as the board's memory map
+//! or instances of drivers for devices that are featured on the respective board.
+//!
+//! Just like processor architecture code, the `BSP` code's module structure tries to mirror the
+//! `kernel`'s subsystem modules, but there is no transparent re-exporting this time. That means
+//! whatever is provided must be called starting from the `bsp` namespace, e.g.
+//! `bsp::driver::driver_manager()`.
+//!
+//! ## Kernel interfaces
+//!
+//! Both `arch` and `bsp` contain code that is conditionally compiled depending on the actual target
+//! and board for which the kernel is compiled. For example, the `interrupt controller` hardware of
+//! the `Raspberry Pi 3` and the `Raspberry Pi 4` is different, but we want the rest of the `kernel`
+//! code to play nicely with any of the two without much hassle.
+//!
+//! In order to provide a clean abstraction between `arch`, `bsp` and `generic kernel code`,
+//! `interface` traits are provided *whenever possible* and *where it makes sense*. They are defined
+//! in the respective subsystem module and help to enforce the idiom of *program to an interface,
+//! not an implementation*. For example, there will be a common IRQ handling interface which the two
+//! different interrupt controller `drivers` of both Raspberrys will implement, and only export the
+//! interface to the rest of the `kernel`.
+//!
+//! ```
+//!         +-------------------+
+//!         | Interface (Trait) |
+//!         |                   |
+//!         +--+-------------+--+
+//!            ^             ^
+//!            |             |
+//!            |             |
+//! +----------+--+       +--+----------+
+//! | kernel code |       |  bsp code   |
+//! |             |       |  arch code  |
+//! +-------------+       +-------------+
+//! ```
+//!
+//! # Summary
+//!
+//! For a logical `kernel` subsystem, corresponding code can be distributed over several physical
+//! locations. Here is an example for the **memory** subsystem:
+//!
+//! - `src/memory.rs` and `src/memory/**/*`
+//!   - Common code that is agnostic of target processor architecture and `BSP` characteristics.
+//!     - Example: A function to zero a chunk of memory.
+//!   - Interfaces for the memory subsystem that are implemented by `arch` or `BSP` code.
+//!     - Example: An `MMU` interface that defines `MMU` function prototypes.
+//! - `src/bsp/__board_name__/memory.rs` and `src/bsp/__board_name__/memory/**/*`
+//!   - `BSP` specific code.
+//!   - Example: The board's memory map (physical addresses of DRAM and MMIO devices).
+//! - `src/_arch/__arch_name__/memory.rs` and `src/_arch/__arch_name__/memory/**/*`
+//!   - Processor architecture specific code.
+//!   - Example: Implementation of the `MMU` interface for the `__arch_name__` processor
+//!     architecture.
+//!
+//! From a namespace perspective, **memory** subsystem code lives in:
+//!
+//! - `crate::memory::*`
+//! - `crate::bsp::memory::*`
 
 #![feature(asm)]
 #![feature(format_args_nl)]
@@ -26,20 +99,16 @@
 #![no_main]
 #![no_std]
 
-// Conditionally includes the selected `architecture` code, which provides the `_start()` function,
-// the first function to run.
-mod arch;
+// `mod cpu` provides the `_start()` function, the first function to run. `_start()` then calls
+// `runtime_init()`, which jumps to `kernel_init()`.
 
-// `_start()` then calls `runtime_init()`, which on completion, jumps to `kernel_init()`.
-mod runtime_init;
-
-// Conditionally includes the selected `BSP` code.
 mod bsp;
-
-mod interface;
+mod console;
+mod cpu;
 mod memory;
 mod panic_wait;
 mod print;
+mod runtime_init;
 
 /// Early init code.
 ///
@@ -47,7 +116,7 @@ mod print;
 ///
 /// - Only a single core must be active and running this function.
 unsafe fn kernel_init() -> ! {
-    println!("Hello from Rust!");
+    println!("[0] Hello from Rust!");
 
     panic!("Stopping here.")
 }

03_hacky_hello_world/src/memory.rs

@@ -6,6 +6,10 @@
 
 use core::ops::Range;
 
+//--------------------------------------------------------------------------------------------------
+// Public Code
+//--------------------------------------------------------------------------------------------------
+
 /// Zero out a memory region.
 ///
 /// # Safety

03_hacky_hello_world/src/panic_wait.rs

@@ -4,7 +4,7 @@
 
 //! A panic handler that infinitely waits.
 
-use crate::{arch, println};
+use crate::{cpu, println};
 use core::panic::PanicInfo;
 
 #[panic_handler]
@@ -15,5 +15,5 @@ fn panic(info: &PanicInfo) -> ! {
         println!("\nKernel panic!");
     }
 
-    arch::wait_forever()
+    cpu::wait_forever()
 }

03_hacky_hello_world/src/print.rs

@@ -4,16 +4,24 @@
 
 //! Printing facilities.
 
-use crate::{bsp, interface};
+use crate::{bsp, console};
 use core::fmt;
 
+//--------------------------------------------------------------------------------------------------
+// Private Code
+//--------------------------------------------------------------------------------------------------
+
 #[doc(hidden)]
 pub fn _print(args: fmt::Arguments) {
-    use interface::console::Write;
+    use console::interface::Write;
 
-    bsp::console().write_fmt(args).unwrap();
+    bsp::console::console().write_fmt(args).unwrap();
 }
 
+//--------------------------------------------------------------------------------------------------
+// Public Code
+//--------------------------------------------------------------------------------------------------
+
 /// Prints without a newline.
 ///
 /// Carbon copy from https://doc.rust-lang.org/src/std/macros.rs.html

03_hacky_hello_world/src/runtime_init.rs

@@ -7,6 +7,10 @@
 use crate::memory;
 use core::ops::Range;
 
+//--------------------------------------------------------------------------------------------------
+// Private Code
+//--------------------------------------------------------------------------------------------------
+
 /// Return the range spanning the .bss section.
 ///
 /// # Safety
@@ -36,6 +40,10 @@ unsafe fn zero_bss() {
     memory::zero_volatile(bss_range());
 }
 
+//--------------------------------------------------------------------------------------------------
+// Public Code
+//--------------------------------------------------------------------------------------------------
+
 /// Equivalent to `crt0` or `c0` code in C/C++ world. Clears the `bss` section, then jumps to kernel
 /// init code.
 ///