Release/v0.2

.github/workflows/main.yml

@@ -1,14 +1,18 @@
 name: CI
 
-on: [push]
+on:
+  push:
+    branches: "*"
+  pull_request:
+    branches: "*"
 
 jobs:
   test:
     name: Build mode ${{ matrix.build_mode }}
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        build_mode: ["", -Drelease-fast=true, -Drelease-safe=true, -Drelease-small=true]
+        build_mode: ["", -Drelease-fast, -Drelease-safe, -Drelease-small]
 
     steps:
     - uses: actions/checkout@v1
@@ -19,15 +23,19 @@ jobs:
         wget $(curl -s 'https://ziglang.org/download/index.json' | python3 -c "import sys, json; print(json.load(sys.stdin)['master']['x86_64-linux']['tarball'])")
         sudo apt-get install mtools
         tar -xvf zig*
-    - name: Build kernel
-      run: zig*/zig build ${{ matrix.build_mode }}
-    - name: Run unit tests
-      run: zig*/zig build test ${{ matrix.build_mode }}
     - name: Install qemu
       run: |
         sudo apt-get update
         sudo apt-get install qemu qemu-system --fix-missing
-    - name: Run runtime tests
-      run: zig*/zig build test -Drt-test=true ${{ matrix.build_mode }}
     - name: Check formatting
       run: zig*/zig fmt --check src
+    - name: Build kernel
+      run: zig*/zig build ${{ matrix.build_mode }}
+    - name: Run unit tests
+      run: zig*/zig build test ${{ matrix.build_mode }}
+    - name: Run runtime test - Initialisation
+      run: zig*/zig build rt-test -Ddisable-display -Dtest-mode=Initialisation ${{ matrix.build_mode }}
+    - name: Run runtime test - Panic
+      run: zig*/zig build rt-test -Ddisable-display -Dtest-mode=Panic ${{ matrix.build_mode }}
+    - name: Run runtime test - Scheduler
+      run: zig*/zig build rt-test -Ddisable-display -Dtest-mode=Scheduler ${{ matrix.build_mode }}

.gitignore

@@ -38,6 +38,9 @@
 # Intellij
 .idea/
 
+# VSCode
+.vscode/
+
 # Zig
 zig-cache
 

README.md

@@ -28,35 +28,52 @@ zig build
 ```Shell
 zig build run
 ```
+
 or if you want to wait for a gdb connection:
+
 ```Shell
 zig build debug-run
 ```
 
 ## Debug
 
-Launch a gdb instance and connect to qemu.
+Launch a gdb-multiarch instance and connect to qemu.
 
 ```Shell
 zig build debug
 ```
 
-## Test
+## Unit testing
 
-Run the unit tests or runtime tests.
+Run the unit tests.
 
 ```Shell
 zig build test
 ```
 
+## Runtime testing
+
+Run the runtime tests.
+
+```Shell
+zig build rt-test -Dtest-mode=<MODE>
+```
+
+Available test modes:
+
+* `None`: This is the default, this will run the OS normally.
+* `Initialisation`: Run the OS's initialisation runtime tests to ensure the OS is properly set up.
+* `Panic`: Run the panic runtime test.
+
 ## Options
 
-* `-Drt-test=`: Boolean (default `false`).
-  * **build**: Build with runtime testing enabled. Makes the kernel bigger and slower but tests important functionality.
-  * **test**: Run the runtime testing script instead of the unittests. Checks for the expected log statements and fails if any are missing.
 * `-D[build-mode]=`: Boolean (default `false`).
   * **build**: Build a certain build mode (*release-safe*, *release-fast*, *release-small*). Don't set in order to use the *debug* build mode.
   * **test**: Test a certain build mode (*release-safe*, *release-fast*, *release-small*). Don't set in order to use the *debug* build mode.
+* `-Dtarget=`: String (default `i386-freestanding`). The standard target options for building with zig. Currently supported targets:
+  * `i386-freestanding`
+* `-Ddisable-display`: Boolean (default `false`)
+  * This disables the display output of QEMU.
 
 ## Contribution
 

build.zig

@@ -1,122 +1,147 @@
 const std = @import("std");
 const builtin = @import("builtin");
+const rt = @import("test/runtime_test.zig");
+const RuntimeStep = rt.RuntimeStep;
 const Builder = std.build.Builder;
-const LibExeObjStep = std.build.LibExeObjStep;
-const Step = std.build.Step;
-const Target = std.build.Target;
+const Target = std.Target;
+const CrossTarget = std.zig.CrossTarget;
 const fs = std.fs;
 const Mode = builtin.Mode;
+const TestMode = rt.TestMode;
+const ArrayList = std.ArrayList;
 
-pub fn build(b: *Builder) !void {
-    const target = Target{
-        .Cross = std.build.CrossTarget{
-            .arch = .i386,
-            .os = .freestanding,
-            .abi = .gnu,
-        },
-    };
+const x86_i686 = CrossTarget{
+    .cpu_arch = .i386,
+    .os_tag = .freestanding,
+    .cpu_model = .{ .explicit = &Target.x86.cpu._i686 },
+};
 
-    const target_str = switch (target.getArch()) {
+pub fn build(b: *Builder) !void {
+    const target = b.standardTargetOptions(.{ .whitelist = &[_]CrossTarget{x86_i686}, .default_target = x86_i686 });
+    const arch = switch (target.getCpuArch()) {
         .i386 => "x86",
         else => unreachable,
     };
 
-    const build_mode = b.standardReleaseOptions();
-    const rt_test = b.option(bool, "rt-test", "enable/disable runtime testing") orelse false;
+    const fmt_step = b.addFmt(&[_][]const u8{
+        "build.zig",
+        "src",
+        "test",
+    });
+    b.default_step.dependOn(&fmt_step.step);
 
     const main_src = "src/kernel/kmain.zig";
+    const arch_root = "src/kernel/arch";
+    const constants_path = try fs.path.join(b.allocator, &[_][]const u8{ arch_root, arch, "constants.zig" });
+    const linker_script_path = try fs.path.join(b.allocator, &[_][]const u8{ arch_root, arch, "link.ld" });
+    const output_iso = try fs.path.join(b.allocator, &[_][]const u8{ b.exe_dir, "pluto.iso" });
+    const iso_dir_path = try fs.path.join(b.allocator, &[_][]const u8{ b.exe_dir, "iso" });
+    const boot_path = try fs.path.join(b.allocator, &[_][]const u8{ b.exe_dir, "iso", "boot" });
+    const modules_path = try fs.path.join(b.allocator, &[_][]const u8{ b.exe_dir, "iso", "modules" });
+
+    const build_mode = b.standardReleaseOptions();
+    comptime var test_mode_desc: []const u8 = "\n                         ";
+    inline for (@typeInfo(TestMode).Enum.fields) |field| {
+        const tm = @field(TestMode, field.name);
+        test_mode_desc = test_mode_desc ++ field.name ++ " (" ++ TestMode.getDescription(tm) ++ ")";
+        test_mode_desc = test_mode_desc ++ "\n                         ";
+    }
+
+    const test_mode = b.option(TestMode, "test-mode", "Run a specific runtime test. This option is for the rt-test step. Available options: " ++ test_mode_desc) orelse .None;
+    const disable_display = b.option(bool, "disable-display", "Disable the qemu window") orelse false;
 
-    const exec = b.addExecutable("pluto", main_src);
-    const constants_path = try fs.path.join(b.allocator, &[_][]const u8{ "src/kernel/arch", target_str, "constants.zig" });
+    const exec = b.addExecutable("pluto.elf", main_src);
     exec.addPackagePath("constants", constants_path);
+    exec.setOutputDir(b.cache_root);
+    exec.addBuildOption(TestMode, "test_mode", test_mode);
     exec.setBuildMode(build_mode);
-    exec.addBuildOption(bool, "rt_test", rt_test);
-    exec.setLinkerScriptPath("link.ld");
-    exec.setTheTarget(target);
+    exec.setLinkerScriptPath(linker_script_path);
+    exec.setTarget(target);
 
-    const iso_path = try fs.path.join(b.allocator, &[_][]const u8{ b.exe_dir, "pluto.iso" });
-    const grub_build_path = try fs.path.join(b.allocator, &[_][]const u8{ b.exe_dir, "iso", "boot" });
-    const iso_dir_path = try fs.path.join(b.allocator, &[_][]const u8{ b.exe_dir, "iso" });
+    const make_iso = switch (target.getCpuArch()) {
+        .i386 => b.addSystemCommand(&[_][]const u8{ "./makeiso.sh", boot_path, modules_path, iso_dir_path, exec.getOutputPath(), output_iso }),
+        else => unreachable,
+    };
+    make_iso.step.dependOn(&exec.step);
 
-    const mkdir_cmd = b.addSystemCommand(&[_][]const u8{ "mkdir", "-p", fs.path.dirname(grub_build_path).? });
+    b.default_step.dependOn(&make_iso.step);
 
-    const grub_cmd = b.addSystemCommand(&[_][]const u8{ "cp", "-r", "grub", grub_build_path });
-    grub_cmd.step.dependOn(&mkdir_cmd.step);
+    const test_step = b.step("test", "Run tests");
+    const mock_path = "\"../../test/mock/kernel/\"";
+    const arch_mock_path = "\"../../../../test/mock/kernel/\"";
+    const unit_tests = b.addTest(main_src);
+    unit_tests.setBuildMode(build_mode);
+    unit_tests.setMainPkgPath(".");
+    unit_tests.addPackagePath("constants", constants_path);
+    unit_tests.addBuildOption(TestMode, "test_mode", test_mode);
+    unit_tests.addBuildOption([]const u8, "mock_path", mock_path);
+    unit_tests.addBuildOption([]const u8, "arch_mock_path", arch_mock_path);
+
+    if (builtin.os.tag != .windows) {
+        unit_tests.enable_qemu = true;
+    }
 
-    const cp_elf_cmd = b.addSystemCommand(&[_][]const u8{"cp"});
-    const elf_path = try fs.path.join(b.allocator, &[_][]const u8{ grub_build_path, "pluto.elf" });
-    cp_elf_cmd.addArtifactArg(exec);
-    cp_elf_cmd.addArg(elf_path);
-    cp_elf_cmd.step.dependOn(&grub_cmd.step);
-    cp_elf_cmd.step.dependOn(&exec.step);
+    unit_tests.setTarget(.{ .cpu_arch = target.cpu_arch });
+    test_step.dependOn(&unit_tests.step);
 
-    const modules_path = try fs.path.join(b.allocator, &[_][]const u8{ b.exe_dir, "iso", "modules" });
-    const mkdir_modules_cmd = b.addSystemCommand(&[_][]const u8{ "mkdir", "-p", modules_path });
+    const rt_test_step = b.step("rt-test", "Run runtime tests");
+    const build_mode_str = switch (build_mode) {
+        .Debug => "",
+        .ReleaseSafe => "-Drelease-safe",
+        .ReleaseFast => "-Drelease-fast",
+        .ReleaseSmall => "-Drelease-small",
+    };
+
+    var qemu_args_al = ArrayList([]const u8).init(b.allocator);
+    defer qemu_args_al.deinit();
+
+    switch (target.getCpuArch()) {
+        .i386 => try qemu_args_al.append("qemu-system-i386"),
+        else => unreachable,
+    }
+    try qemu_args_al.append("-serial");
+    try qemu_args_al.append("stdio");
+    switch (target.getCpuArch()) {
+        .i386 => {
+            try qemu_args_al.append("-boot");
+            try qemu_args_al.append("d");
+            try qemu_args_al.append("-cdrom");
+            try qemu_args_al.append(output_iso);
+        },
+        else => unreachable,
+    }
+    if (disable_display) {
+        try qemu_args_al.append("-display");
+        try qemu_args_al.append("none");
+    }
 
-    const map_file_path = try fs.path.join(b.allocator, &[_][]const u8{ modules_path, "kernel.map" });
-    const map_file_cmd = b.addSystemCommand(&[_][]const u8{ "./make_map.sh", elf_path, map_file_path });
-    map_file_cmd.step.dependOn(&cp_elf_cmd.step);
-    map_file_cmd.step.dependOn(&mkdir_modules_cmd.step);
+    var qemu_args = qemu_args_al.toOwnedSlice();
 
-    const iso_cmd = b.addSystemCommand(&[_][]const u8{ "grub-mkrescue", "-o", iso_path, iso_dir_path });
-    iso_cmd.step.dependOn(&map_file_cmd.step);
-    b.default_step.dependOn(&iso_cmd.step);
+    const rt_step = RuntimeStep.create(b, test_mode, qemu_args);
+    rt_step.step.dependOn(&make_iso.step);
+    rt_test_step.dependOn(&rt_step.step);
 
     const run_step = b.step("run", "Run with qemu");
     const run_debug_step = b.step("debug-run", "Run with qemu and wait for a gdb connection");
 
-    const qemu_bin = switch (target.getArch()) {
-        .i386 => "qemu-system-i386",
-        else => unreachable,
-    };
-    const qemu_args = &[_][]const u8{
-        qemu_bin,
-        "-cdrom",
-        iso_path,
-        "-boot",
-        "d",
-        "-serial",
-        "stdio",
-    };
     const qemu_cmd = b.addSystemCommand(qemu_args);
     const qemu_debug_cmd = b.addSystemCommand(qemu_args);
     qemu_debug_cmd.addArgs(&[_][]const u8{ "-s", "-S" });
 
-    if (rt_test) {
-        const qemu_rt_test_args = &[_][]const u8{ "-display", "none" };
-        qemu_cmd.addArgs(qemu_rt_test_args);
-        qemu_debug_cmd.addArgs(qemu_rt_test_args);
-    }
-
-    qemu_cmd.step.dependOn(&iso_cmd.step);
-    qemu_debug_cmd.step.dependOn(&iso_cmd.step);
+    qemu_cmd.step.dependOn(&make_iso.step);
+    qemu_debug_cmd.step.dependOn(&make_iso.step);
 
     run_step.dependOn(&qemu_cmd.step);
     run_debug_step.dependOn(&qemu_debug_cmd.step);
 
-    const test_step = b.step("test", "Run tests");
-    if (rt_test) {
-        const script = b.addSystemCommand(&[_][]const u8{ "python3", "test/rt-test.py", "x86", b.zig_exe });
-        test_step.dependOn(&script.step);
-    } else {
-        const mock_path = "\"../../test/mock/kernel/\"";
-        const arch_mock_path = "\"../../../../test/mock/kernel/\"";
-        const unit_tests = b.addTest(main_src);
-        unit_tests.setBuildMode(build_mode);
-        unit_tests.setMainPkgPath(".");
-        unit_tests.addPackagePath("constants", constants_path);
-        unit_tests.addBuildOption(bool, "rt_test", rt_test);
-        unit_tests.addBuildOption([]const u8, "mock_path", mock_path);
-        unit_tests.addBuildOption([]const u8, "arch_mock_path", arch_mock_path);
-        test_step.dependOn(&unit_tests.step);
-    }
-
     const debug_step = b.step("debug", "Debug with gdb and connect to a running qemu instance");
-    const symbol_file_arg = try std.mem.join(b.allocator, " ", &[_][]const u8{ "symbol-file", elf_path });
+    const symbol_file_arg = try std.mem.join(b.allocator, " ", &[_][]const u8{ "symbol-file", exec.getOutputPath() });
     const debug_cmd = b.addSystemCommand(&[_][]const u8{
-        "gdb",
+        "gdb-multiarch",
         "-ex",
         symbol_file_arg,
+        "-ex",
+        "set architecture auto",
     });
     debug_cmd.addArgs(&[_][]const u8{
         "-ex",

makeiso.sh

@@ -0,0 +1,31 @@
+#!/usr/bin/env bash
+
+BOOT_DIR=$1
+MODULES_DIR=$2
+ISO_DIR=$3
+PLUTO_ELF=$4
+OUTPUT_FILE=$5
+
+MAP_FILE=$MODULES_DIR/'kernel.map'
+
+exit_missing() {
+    printf "$_ must be installed\n";
+    exit 1;
+}
+
+# Check dependencies
+which xorriso > /dev/null || exit_missing
+which grub-mkrescue > /dev/null || exit_missing
+which readelf > /dev/null || exit_missing
+
+mkdir -p $BOOT_DIR
+mkdir -p $MODULES_DIR
+
+cp -r grub $BOOT_DIR
+cp $PLUTO_ELF $BOOT_DIR/"pluto.elf"
+
+# Read the symbols from the binary, remove all the unnecessary columns with awk and emit to a map file
+readelf -s --wide $PLUTO_ELF | grep -F "FUNC" | awk '{$1=$3=$4=$5=$6=$7=""; print $0}' | sort -k 1 > $MAP_FILE
+echo "" >> $MAP_FILE
+
+grub-mkrescue -o $OUTPUT_FILE $ISO_DIR

src/kernel/arch.zig

@@ -1,8 +1,10 @@
+const std = @import("std");
 const builtin = @import("builtin");
 const is_test = builtin.is_test;
 const build_options = @import("build_options");
+const mock_path = build_options.mock_path;
 
-pub const internals = if (is_test) @import(build_options.mock_path ++ "arch_mock.zig") else switch (builtin.arch) {
+pub const internals = if (is_test) @import(mock_path ++ "arch_mock.zig") else switch (builtin.arch) {
     .i386 => @import("arch/x86/arch.zig"),
     else => unreachable,
 };