Merge #206 into next

Author: phil-opp

Diff for: Cargo.lock

@@ -18,6 +18,7 @@ members = [
     "tests/test_kernels/default_settings",
     "tests/test_kernels/map_phys_mem",
     "tests/test_kernels/higher_half",
+    "tests/test_kernels/pie",
 ]
 exclude = ["examples/basic", "examples/test_framework"]
 

Diff for: Cargo.toml

@@ -16,17 +16,22 @@ impl UsedLevel4Entries {
     /// Initializes a new instance from the given ELF program segments.
     ///
     /// Marks the virtual address range of all segments as used.
-    pub fn new<'a>(segments: impl Iterator<Item = ProgramHeader<'a>>) -> Self {
+    pub fn new<'a>(
+        segments: impl Iterator<Item = ProgramHeader<'a>>,
+        virtual_address_offset: u64,
+    ) -> Self {
         let mut used = UsedLevel4Entries {
             entry_state: [false; 512],
         };
 
         used.entry_state[0] = true; // TODO: Can we do this dynamically?
 
         for segment in segments {
-            let start_page: Page = Page::containing_address(VirtAddr::new(segment.virtual_addr()));
+            let start_page: Page = Page::containing_address(VirtAddr::new(
+                segment.virtual_addr() + virtual_address_offset,
+            ));
             let end_page: Page = Page::containing_address(VirtAddr::new(
-                segment.virtual_addr() + segment.mem_size(),
+                segment.virtual_addr() + virtual_address_offset + segment.mem_size(),
             ));
 
             for p4_index in u64::from(start_page.p4_index())..=u64::from(end_page.p4_index()) {

Diff for: common/src/level_4_entries.rs

@@ -0,0 +1,32 @@
+use std::process::Command;
+
+#[test]
+fn basic_boot() {
+    run_test_binary("basic_boot");
+}
+
+#[test]
+fn should_panic() {
+    run_test_binary("should_panic");
+}
+
+#[test]
+fn check_boot_info() {
+    run_test_binary("check_boot_info");
+}
+
+#[test]
+fn global_variable() {
+    run_test_binary("global_variable");
+}
+
+fn run_test_binary(bin_name: &str) {
+    let mut cmd = Command::new(env!("CARGO"));
+    cmd.current_dir("tests/test_kernels/pie");
+    cmd.arg("run");
+    cmd.arg("--bin").arg(bin_name);
+    cmd.arg("--target").arg("x86_64-pie.json");
+    cmd.arg("-Zbuild-std=core");
+    cmd.arg("-Zbuild-std-features=compiler-builtins-mem");
+    assert!(cmd.status().unwrap().success());
+}

Diff for: common/src/load_kernel.rs

@@ -0,0 +1,10 @@
+[unstable]
+# TODO: Uncomment once https://github.com/rust-lang/cargo/issues/8643 is merged
+# build-std = ["core"]
+
+[build]
+# TODO: Uncomment once https://github.com/rust-lang/cargo/issues/8643 is merged
+# target = "x86_64-example-kernel.json"
+
+[target.'cfg(target_os = "none")']
+runner = "cargo run --manifest-path ../../runner/Cargo.toml"

Diff for: tests/pie.rs

@@ -0,0 +1 @@
+target

Diff for: tests/test_kernels/pie/.cargo/config.toml

@@ -0,0 +1,10 @@
+[package]
+name = "test_kernel_pie"
+version = "0.1.0"
+authors = ["Tom Dohrmann <erbse.13@gmx.de>"]
+edition = "2018"
+
+[dependencies]
+bootloader = { path = "../../.." }
+x86_64 = { version = "0.14.7", default-features = false, features = ["instructions", "inline_asm"] }
+uart_16550 = "0.2.10"

Diff for: tests/test_kernels/pie/.gitignore

@@ -0,0 +1,21 @@
+#![no_std] // don't link the Rust standard library
+#![no_main] // disable all Rust-level entry points
+
+use bootloader::{entry_point, BootInfo};
+use core::panic::PanicInfo;
+use test_kernel_pie::{exit_qemu, QemuExitCode};
+
+entry_point!(kernel_main);
+
+fn kernel_main(_boot_info: &'static mut BootInfo) -> ! {
+    exit_qemu(QemuExitCode::Success);
+}
+
+/// This function is called on panic.
+#[panic_handler]
+fn panic(info: &PanicInfo) -> ! {
+    use core::fmt::Write;
+
+    let _ = writeln!(test_kernel_pie::serial(), "PANIC: {}", info);
+    exit_qemu(QemuExitCode::Failed);
+}

Diff for: tests/test_kernels/pie/Cargo.toml

@@ -0,0 +1,68 @@
+#![no_std] // don't link the Rust standard library
+#![no_main] // disable all Rust-level entry points
+
+use bootloader::{boot_info::PixelFormat, entry_point, BootInfo};
+use core::panic::PanicInfo;
+use test_kernel_pie::{exit_qemu, QemuExitCode};
+
+entry_point!(kernel_main);
+
+fn kernel_main(boot_info: &'static mut BootInfo) -> ! {
+    // check memory regions
+    assert!(boot_info.memory_regions.len() > 4);
+
+    // check framebuffer
+    let framebuffer = boot_info.framebuffer.as_ref().unwrap();
+    assert_eq!(framebuffer.info().byte_len, framebuffer.buffer().len());
+    if ![640, 1024].contains(&framebuffer.info().horizontal_resolution) {
+        panic!(
+            "unexpected horizontal_resolution `{}`",
+            framebuffer.info().horizontal_resolution
+        );
+    }
+    if ![480, 768].contains(&framebuffer.info().vertical_resolution) {
+        panic!(
+            "unexpected vertical_resolution `{}`",
+            framebuffer.info().vertical_resolution
+        );
+    }
+    if ![3, 4].contains(&framebuffer.info().bytes_per_pixel) {
+        panic!(
+            "unexpected bytes_per_pixel `{}`",
+            framebuffer.info().bytes_per_pixel
+        );
+    }
+    if ![640, 1024].contains(&framebuffer.info().stride) {
+        panic!("unexpected stride `{}`", framebuffer.info().stride);
+    }
+    assert_eq!(framebuffer.info().pixel_format, PixelFormat::BGR);
+    assert_eq!(
+        framebuffer.buffer().len(),
+        framebuffer.info().stride
+            * framebuffer.info().vertical_resolution
+            * framebuffer.info().bytes_per_pixel
+    );
+
+    // check defaults for optional features
+    assert_eq!(boot_info.physical_memory_offset.into_option(), None);
+    assert_eq!(boot_info.recursive_index.into_option(), None);
+
+    // check rsdp_addr
+    let rsdp = boot_info.rsdp_addr.into_option().unwrap();
+    assert!(rsdp > 0x000E0000);
+    assert!(rsdp < 0x000FFFFF);
+
+    // the test kernel has no TLS template
+    assert_eq!(boot_info.tls_template.into_option(), None);
+
+    exit_qemu(QemuExitCode::Success);
+}
+
+/// This function is called on panic.
+#[panic_handler]
+fn panic(info: &PanicInfo) -> ! {
+    use core::fmt::Write;
+
+    let _ = writeln!(test_kernel_pie::serial(), "PANIC: {}", info);
+    exit_qemu(QemuExitCode::Failed);
+}

Diff for: tests/test_kernels/pie/src/bin/basic_boot.rs

@@ -0,0 +1,38 @@
+#![no_std] // don't link the Rust standard library
+#![no_main] // disable all Rust-level entry points
+
+use bootloader::{entry_point, BootInfo};
+use core::{
+    panic::PanicInfo,
+    sync::atomic::{AtomicU64, Ordering},
+};
+use test_kernel_pie::{exit_qemu, QemuExitCode};
+
+entry_point!(kernel_main);
+
+fn kernel_main(_boot_info: &'static mut BootInfo) -> ! {
+    // Initialize with a value that is unlikely to be anywhere in memory.
+    // If we can later read out this exact value, we can be sure that we actually
+    // read from this global variable and not some other location in memory.
+    static FOO: AtomicU64 = AtomicU64::new(0xdeadbeef);
+
+    // Make sure that relocations are actually applied by referencing a `FOO`
+    // in `FOO_REF`. `FOO`'s address will be calculated and put into `FOO_REF`
+    // at load time using a relocation.
+    static FOO_REF: &AtomicU64 = &FOO;
+
+    // Verify that the memory address pointed to by `FOO_REF` contains our value.
+    let val = FOO_REF.load(Ordering::Relaxed);
+    assert_eq!(val, 0xdeadbeef);
+
+    exit_qemu(QemuExitCode::Success);
+}
+
+/// This function is called on panic.
+#[panic_handler]
+fn panic(info: &PanicInfo) -> ! {
+    use core::fmt::Write;
+
+    let _ = writeln!(test_kernel_pie::serial(), "PANIC: {}", info);
+    exit_qemu(QemuExitCode::Failed);
+}

Diff for: tests/test_kernels/pie/src/bin/check_boot_info.rs

@@ -0,0 +1,18 @@
+#![no_std] // don't link the Rust standard library
+#![no_main] // disable all Rust-level entry points
+
+use bootloader::{entry_point, BootInfo};
+use core::panic::PanicInfo;
+use test_kernel_pie::{exit_qemu, QemuExitCode};
+
+entry_point!(kernel_main);
+
+fn kernel_main(_boot_info: &'static mut BootInfo) -> ! {
+    panic!();
+}
+
+/// This function is called on panic.
+#[panic_handler]
+fn panic(_info: &PanicInfo) -> ! {
+    exit_qemu(QemuExitCode::Success);
+}

Diff for: tests/test_kernels/pie/src/bin/global_variable.rs

@@ -0,0 +1,27 @@
+#![no_std]
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[repr(u32)]
+pub enum QemuExitCode {
+    Success = 0x10,
+    Failed = 0x11,
+}
+
+pub fn exit_qemu(exit_code: QemuExitCode) -> ! {
+    use x86_64::instructions::{nop, port::Port};
+
+    unsafe {
+        let mut port = Port::new(0xf4);
+        port.write(exit_code as u32);
+    }
+
+    loop {
+        nop();
+    }
+}
+
+pub fn serial() -> uart_16550::SerialPort {
+    let mut port = unsafe { uart_16550::SerialPort::new(0x3F8) };
+    port.init();
+    port
+}

Diff for: tests/test_kernels/pie/src/bin/should_panic.rs

@@ -0,0 +1,16 @@
+{
+    "llvm-target": "x86_64-unknown-none",
+    "data-layout": "e-m:e-i64:64-f80:128-n8:16:32:64-S128",
+    "arch": "x86_64",
+    "target-endian": "little",
+    "target-pointer-width": "64",
+    "target-c-int-width": "32",
+    "os": "none",
+    "executables": true,
+    "linker-flavor": "ld.lld",
+    "linker": "rust-lld",
+    "panic-strategy": "abort",
+    "disable-redzone": true,
+    "features": "-mmx,-sse,+soft-float",
+    "position-independent-executables": true  
+  }