Imbus/pluto
1
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Update code to work with zig master

Browse source
This commit is contained in:
Sam Tebbs 2020-01-01 19:12:36 +00:00
parent 4b870d3a65
commit 91b2a61acf
26 changed files with 476 additions and 438 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
.github/workflows/main.yml vendored
View file

@ -16,7 +16,7 @@ jobs:
- name: Download zig - name: Download zig
run: | run: |
export PYTHONIOENCODING=utf8 export PYTHONIOENCODING=utf8
wget https://ziglang.org/builds/zig-linux-x86_64-0.5.0+ae0a219d1.tar.xz 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 sudo apt-get install mtools
tar -xvf zig* tar -xvf zig*
- name: Build kernel - name: Build kernel

40
build.zig
View file

@ -27,38 +27,38 @@ pub fn build(b: *Builder) !void {
const main_src = "src/kernel/kmain.zig"; const main_src = "src/kernel/kmain.zig";
const exec = b.addExecutable("pluto", main_src); 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 constants_path = try fs.path.join(b.allocator, &[_][]const u8{ "src/kernel/arch", target_str, "constants.zig" });
exec.addPackagePath("constants", constants_path); exec.addPackagePath("constants", constants_path);
exec.setBuildMode(build_mode); exec.setBuildMode(build_mode);
exec.addBuildOption(bool, "rt_test", rt_test); exec.addBuildOption(bool, "rt_test", rt_test);
exec.setLinkerScriptPath("link.ld"); exec.setLinkerScriptPath("link.ld");
exec.setTheTarget(target); exec.setTheTarget(target);
const iso_path = try fs.path.join(b.allocator, [_][]const u8{ b.exe_dir, "pluto.iso" }); 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 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 iso_dir_path = try fs.path.join(b.allocator, &[_][]const u8{ b.exe_dir, "iso" });
const mkdir_cmd = b.addSystemCommand([_][]const u8{ "mkdir", "-p", fs.path.dirname(grub_build_path).? }); const mkdir_cmd = b.addSystemCommand(&[_][]const u8{ "mkdir", "-p", fs.path.dirname(grub_build_path).? });
const grub_cmd = b.addSystemCommand([_][]const u8{ "cp", "-r", "grub", grub_build_path }); const grub_cmd = b.addSystemCommand(&[_][]const u8{ "cp", "-r", "grub", grub_build_path });
grub_cmd.step.dependOn(&mkdir_cmd.step); grub_cmd.step.dependOn(&mkdir_cmd.step);
const cp_elf_cmd = b.addSystemCommand([_][]const u8{"cp"}); 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" }); const elf_path = try fs.path.join(b.allocator, &[_][]const u8{ grub_build_path, "pluto.elf" });
cp_elf_cmd.addArtifactArg(exec); cp_elf_cmd.addArtifactArg(exec);
cp_elf_cmd.addArg(elf_path); cp_elf_cmd.addArg(elf_path);
cp_elf_cmd.step.dependOn(&grub_cmd.step); cp_elf_cmd.step.dependOn(&grub_cmd.step);
cp_elf_cmd.step.dependOn(&exec.step); cp_elf_cmd.step.dependOn(&exec.step);
const modules_path = try fs.path.join(b.allocator, [_][]const u8{ b.exe_dir, "iso", "modules" }); 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 mkdir_modules_cmd = b.addSystemCommand(&[_][]const u8{ "mkdir", "-p", modules_path });
const map_file_path = try fs.path.join(b.allocator, [_][]const u8{ modules_path, "kernel.map" }); 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 }); 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(&cp_elf_cmd.step);
map_file_cmd.step.dependOn(&mkdir_modules_cmd.step); map_file_cmd.step.dependOn(&mkdir_modules_cmd.step);
const iso_cmd = b.addSystemCommand([_][]const u8{ "grub-mkrescue", "-o", iso_path, iso_dir_path }); const iso_cmd = b.addSystemCommand(&[_][]const u8{ "grub-mkrescue", "-o", iso_path, iso_dir_path });
iso_cmd.step.dependOn(&map_file_cmd.step); iso_cmd.step.dependOn(&map_file_cmd.step);
b.default_step.dependOn(&iso_cmd.step); b.default_step.dependOn(&iso_cmd.step);
@ -69,7 +69,7 @@ pub fn build(b: *Builder) !void {
.i386 => "qemu-system-i386", .i386 => "qemu-system-i386",
else => unreachable, else => unreachable,
}; };
const qemu_args = [_][]const u8{ const qemu_args = &[_][]const u8{
qemu_bin, qemu_bin,
"-cdrom", "-cdrom",
iso_path, iso_path,
@ -80,10 +80,10 @@ pub fn build(b: *Builder) !void {
}; };
const qemu_cmd = b.addSystemCommand(qemu_args); const qemu_cmd = b.addSystemCommand(qemu_args);
const qemu_debug_cmd = b.addSystemCommand(qemu_args); const qemu_debug_cmd = b.addSystemCommand(qemu_args);
qemu_debug_cmd.addArgs([_][]const u8{ "-s", "-S" }); qemu_debug_cmd.addArgs(&[_][]const u8{ "-s", "-S" });
if (rt_test) { if (rt_test) {
const qemu_rt_test_args = [_][]const u8{ "-display", "none" }; const qemu_rt_test_args = &[_][]const u8{ "-display", "none" };
qemu_cmd.addArgs(qemu_rt_test_args); qemu_cmd.addArgs(qemu_rt_test_args);
qemu_debug_cmd.addArgs(qemu_rt_test_args); qemu_debug_cmd.addArgs(qemu_rt_test_args);
} }
@ -96,7 +96,7 @@ pub fn build(b: *Builder) !void {
const test_step = b.step("test", "Run tests"); const test_step = b.step("test", "Run tests");
if (rt_test) { if (rt_test) {
const script = b.addSystemCommand([_][]const u8{ "python3", "test/rt-test.py", "x86", b.zig_exe }); const script = b.addSystemCommand(&[_][]const u8{ "python3", "test/rt-test.py", "x86", b.zig_exe });
test_step.dependOn(&script.step); test_step.dependOn(&script.step);
} else { } else {
const mock_path = "\"../../test/mock/kernel/\""; const mock_path = "\"../../test/mock/kernel/\"";
@ -112,13 +112,13 @@ pub fn build(b: *Builder) !void {
} }
const debug_step = b.step("debug", "Debug with gdb and connect to a running qemu instance"); 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", elf_path });
const debug_cmd = b.addSystemCommand([_][]const u8{ const debug_cmd = b.addSystemCommand(&[_][]const u8{
"gdb", "gdb",
"-ex", "-ex",
symbol_file_arg, symbol_file_arg,
}); });
debug_cmd.addArgs([_][]const u8{ debug_cmd.addArgs(&[_][]const u8{
"-ex", "-ex",
"target remote localhost:1234", "target remote localhost:1234",
}); });

8
src/kernel/arch/x86/gdt.zig
View file

@ -424,7 +424,7 @@ pub fn setTssStack(esp0: u32) void {
/// Initialise the Global Descriptor table. /// Initialise the Global Descriptor table.
/// ///
pub fn init() void { pub fn init() void {
log.logInfo("Init gdt\n"); log.logInfo("Init gdt\n", .{});
// Initiate TSS // Initiate TSS
gdt_entries[TSS_INDEX] = makeEntry(@intCast(u32, @ptrToInt(&tss)), @sizeOf(TtsEntry) - 1, TSS_SEGMENT, NULL_FLAGS); gdt_entries[TSS_INDEX] = makeEntry(@intCast(u32, @ptrToInt(&tss)), @sizeOf(TtsEntry) - 1, TSS_SEGMENT, NULL_FLAGS);
@ -437,7 +437,7 @@ pub fn init() void {
// Load the TSS // Load the TSS
arch.ltr(TSS_OFFSET); arch.ltr(TSS_OFFSET);
log.logInfo("Done\n"); log.logInfo("Done\n", .{});
if (build_options.rt_test) runtimeTests(); if (build_options.rt_test) runtimeTests();
} }
@ -639,7 +639,7 @@ test "init" {
arch.initTest(); arch.initTest();
defer arch.freeTest(); defer arch.freeTest();
arch.addTestParams("ltr", TSS_OFFSET); arch.addTestParams("ltr", .{TSS_OFFSET});
arch.addConsumeFunction("lgdt", mock_lgdt); arch.addConsumeFunction("lgdt", mock_lgdt);
@ -681,5 +681,5 @@ fn rt_loadedGDTSuccess() void {
/// ///
fn runtimeTests() void { fn runtimeTests() void {
rt_loadedGDTSuccess(); rt_loadedGDTSuccess();
log.logInfo("GDT: Tested loading GDT\n"); log.logInfo("GDT: Tested loading GDT\n", .{});
} }

6
src/kernel/arch/x86/idt.zig
View file

@ -179,12 +179,12 @@ pub fn openInterruptGate(index: u8, handler: InterruptHandler) IdtError!void {
/// Initialise the Interrupt descriptor table /// Initialise the Interrupt descriptor table
/// ///
pub fn init() void { pub fn init() void {
log.logInfo("Init idt\n"); log.logInfo("Init idt\n", .{});
idt_ptr.base = @intCast(u32, @ptrToInt(&idt_entries)); idt_ptr.base = @intCast(u32, @ptrToInt(&idt_entries));
arch.lidt(&idt_ptr); arch.lidt(&idt_ptr);
log.logInfo("Done\n"); log.logInfo("Done\n", .{});
if (build_options.rt_test) runtimeTests(); if (build_options.rt_test) runtimeTests();
} }
@ -327,7 +327,7 @@ fn rt_loadedIDTSuccess() void {
const loaded_idt = arch.sidt(); const loaded_idt = arch.sidt();
expect(idt_ptr.limit == loaded_idt.limit); expect(idt_ptr.limit == loaded_idt.limit);
expect(idt_ptr.base == loaded_idt.base); expect(idt_ptr.base == loaded_idt.base);
log.logInfo("IDT: Tested loading IDT\n"); log.logInfo("IDT: Tested loading IDT\n", .{});
} }
/// ///

26
src/kernel/arch/x86/irq.zig
View file

@ -44,7 +44,7 @@ var irq_handlers: [NUMBER_OF_ENTRIES]?IrqHandler = [_]?IrqHandler{null} ** NUMBE
export fn irqHandler(ctx: *arch.InterruptContext) void { export fn irqHandler(ctx: *arch.InterruptContext) void {
// Get the IRQ index, by getting the interrupt number and subtracting the offset. // Get the IRQ index, by getting the interrupt number and subtracting the offset.
if (ctx.int_num < IRQ_OFFSET) { if (ctx.int_num < IRQ_OFFSET) {
panic(@errorReturnTrace(), "Not an IRQ number: {}\n", ctx.int_num); panic(@errorReturnTrace(), "Not an IRQ number: {}\n", .{ctx.int_num});
} }
const irq_offset = ctx.int_num - IRQ_OFFSET; const irq_offset = ctx.int_num - IRQ_OFFSET;
@ -59,10 +59,10 @@ export fn irqHandler(ctx: *arch.InterruptContext) void {
pic.sendEndOfInterrupt(irq_num); pic.sendEndOfInterrupt(irq_num);
} }
} else { } else {
panic(@errorReturnTrace(), "IRQ not registered: {}", irq_num); panic(@errorReturnTrace(), "IRQ not registered: {}", .{irq_num});
} }
} else { } else {
panic(@errorReturnTrace(), "Invalid IRQ index: {}", irq_offset); panic(@errorReturnTrace(), "Invalid IRQ index: {}", .{irq_offset});
} }
} }
@ -76,7 +76,7 @@ export fn irqHandler(ctx: *arch.InterruptContext) void {
fn openIrq(index: u8, handler: idt.InterruptHandler) void { fn openIrq(index: u8, handler: idt.InterruptHandler) void {
idt.openInterruptGate(index, handler) catch |err| switch (err) { idt.openInterruptGate(index, handler) catch |err| switch (err) {
error.IdtEntryExists => { error.IdtEntryExists => {
panic(@errorReturnTrace(), "Error opening IRQ number: {} exists", index); panic(@errorReturnTrace(), "Error opening IRQ number: {} exists", .{index});
}, },
}; };
} }
@ -128,14 +128,14 @@ pub fn registerIrq(irq_num: u8, handler: IrqHandler) IrqError!void {
/// the IDT interrupt gates for each IRQ. /// the IDT interrupt gates for each IRQ.
/// ///
pub fn init() void { pub fn init() void {
log.logInfo("Init irq\n"); log.logInfo("Init irq\n", .{});
comptime var i = IRQ_OFFSET; comptime var i = IRQ_OFFSET;
inline while (i < IRQ_OFFSET + 16) : (i += 1) { inline while (i < IRQ_OFFSET + 16) : (i += 1) {
openIrq(i, interrupts.getInterruptStub(i)); openIrq(i, interrupts.getInterruptStub(i));
} }
log.logInfo("Done\n"); log.logInfo("Done\n", .{});
if (build_options.rt_test) runtimeTests(); if (build_options.rt_test) runtimeTests();
} }
@ -152,7 +152,7 @@ test "openIrq" {
const handler = testFunction0; const handler = testFunction0;
const ret: idt.IdtError!void = {}; const ret: idt.IdtError!void = {};
idt.addTestParams("openInterruptGate", index, handler, ret); idt.addTestParams("openInterruptGate", .{ index, handler, ret });
openIrq(index, handler); openIrq(index, handler);
} }
@ -171,7 +171,7 @@ test "registerIrq re-register irq handler" {
pic.initTest(); pic.initTest();
defer pic.freeTest(); defer pic.freeTest();
pic.addTestParams("clearMask", @as(u16, 0)); pic.addTestParams("clearMask", .{@as(u16, 0)});
// Pre testing // Pre testing
for (irq_handlers) |h| { for (irq_handlers) |h| {
@ -200,7 +200,7 @@ test "registerIrq register irq handler" {
pic.initTest(); pic.initTest();
defer pic.freeTest(); defer pic.freeTest();
pic.addTestParams("clearMask", @as(u16, 0)); pic.addTestParams("clearMask", .{@as(u16, 0)});
// Pre testing // Pre testing
for (irq_handlers) |h| { for (irq_handlers) |h| {
@ -234,11 +234,11 @@ fn rt_unregisteredHandlers() void {
// Ensure all ISR are not registered yet // Ensure all ISR are not registered yet
for (irq_handlers) |h, i| { for (irq_handlers) |h, i| {
if (h) |_| { if (h) |_| {
panic(@errorReturnTrace(), "Handler found for IRQ: {}-{}\n", i, h); panic(@errorReturnTrace(), "Handler found for IRQ: {}-{}\n", .{ i, h });
} }
} }
log.logInfo("IRQ: Tested registered handlers\n"); log.logInfo("IRQ: Tested registered handlers\n", .{});
} }
/// ///
@ -251,12 +251,12 @@ fn rt_openedIdtEntries() void {
for (idt_entries) |entry, i| { for (idt_entries) |entry, i| {
if (i >= IRQ_OFFSET and isValidIrq(i - IRQ_OFFSET)) { if (i >= IRQ_OFFSET and isValidIrq(i - IRQ_OFFSET)) {
if (!idt.isIdtOpen(entry)) { if (!idt.isIdtOpen(entry)) {
panic(@errorReturnTrace(), "IDT entry for {} is not open\n", i); panic(@errorReturnTrace(), "IDT entry for {} is not open\n", .{i});
} }
} }
} }
log.logInfo("IRQ: Tested opened IDT entries\n"); log.logInfo("IRQ: Tested opened IDT entries\n", .{});
} }
/// ///

24
src/kernel/arch/x86/isr.zig
View file

@ -150,18 +150,18 @@ export fn isrHandler(ctx: *arch.InterruptContext) void {
if (syscall_handler) |handler| { if (syscall_handler) |handler| {
handler(ctx); handler(ctx);
} else { } else {
panic(@errorReturnTrace(), "Syscall handler not registered\n"); panic(@errorReturnTrace(), "Syscall handler not registered\n", .{});
} }
} else { } else {
if (isr_handlers[isr_num]) |handler| { if (isr_handlers[isr_num]) |handler| {
// Regular ISR exception, if there is one registered. // Regular ISR exception, if there is one registered.
handler(ctx); handler(ctx);
} else { } else {
panic(@errorReturnTrace(), "ISR not registered to: {}-{}\n", isr_num, exception_msg[isr_num]); panic(@errorReturnTrace(), "ISR not registered to: {}-{}\n", .{ isr_num, exception_msg[isr_num] });
} }
} }
} else { } else {
panic(@errorReturnTrace(), "Invalid ISR index: {}\n", isr_num); panic(@errorReturnTrace(), "Invalid ISR index: {}\n", .{isr_num});
} }
} }
@ -175,7 +175,7 @@ export fn isrHandler(ctx: *arch.InterruptContext) void {
fn openIsr(index: u8, handler: idt.InterruptHandler) void { fn openIsr(index: u8, handler: idt.InterruptHandler) void {
idt.openInterruptGate(index, handler) catch |err| switch (err) { idt.openInterruptGate(index, handler) catch |err| switch (err) {
error.IdtEntryExists => { error.IdtEntryExists => {
panic(@errorReturnTrace(), "Error opening ISR number: {} exists\n", index); panic(@errorReturnTrace(), "Error opening ISR number: {} exists\n", .{index});
}, },
}; };
} }
@ -234,7 +234,7 @@ pub fn registerIsr(isr_num: u16, handler: IsrHandler) IsrError!void {
/// Initialise the exception and opening up all the IDT interrupt gates for each exception. /// Initialise the exception and opening up all the IDT interrupt gates for each exception.
/// ///
pub fn init() void { pub fn init() void {
log.logInfo("Init isr\n"); log.logInfo("Init isr\n", .{});
comptime var i = 0; comptime var i = 0;
inline while (i < 32) : (i += 1) { inline while (i < 32) : (i += 1) {
@ -243,7 +243,7 @@ pub fn init() void {
openIsr(syscalls.INTERRUPT, interrupts.getInterruptStub(syscalls.INTERRUPT)); openIsr(syscalls.INTERRUPT, interrupts.getInterruptStub(syscalls.INTERRUPT));
log.logInfo("Done\n"); log.logInfo("Done\n", .{});
if (build_options.rt_test) runtimeTests(); if (build_options.rt_test) runtimeTests();
} }
@ -262,7 +262,7 @@ test "openIsr" {
const handler = testFunction0; const handler = testFunction0;
const ret: idt.IdtError!void = {}; const ret: idt.IdtError!void = {};
idt.addTestParams("openInterruptGate", index, handler, ret); idt.addTestParams("openInterruptGate", .{ index, handler, ret });
openIsr(index, handler); openIsr(index, handler);
} }
@ -363,15 +363,15 @@ fn rt_unregisteredHandlers() void {
// Ensure all ISR are not registered yet // Ensure all ISR are not registered yet
for (isr_handlers) |h, i| { for (isr_handlers) |h, i| {
if (h) |_| { if (h) |_| {
panic(@errorReturnTrace(), "Handler found for ISR: {}-{}\n", i, h); panic(@errorReturnTrace(), "Handler found for ISR: {}-{}\n", .{ i, h });
} }
} }
if (syscall_handler) |h| { if (syscall_handler) |h| {
panic(@errorReturnTrace(), "Pre-testing failed for syscall: {}\n", h); panic(@errorReturnTrace(), "Pre-testing failed for syscall: {}\n", .{h});
} }
log.logInfo("ISR: Tested registered handlers\n"); log.logInfo("ISR: Tested registered handlers\n", .{});
} }
/// ///
@ -384,12 +384,12 @@ fn rt_openedIdtEntries() void {
for (idt_entries) |entry, i| { for (idt_entries) |entry, i| {
if (isValidIsr(i)) { if (isValidIsr(i)) {
if (!idt.isIdtOpen(entry)) { if (!idt.isIdtOpen(entry)) {
panic(@errorReturnTrace(), "IDT entry for {} is not open\n", i); panic(@errorReturnTrace(), "IDT entry for {} is not open\n", .{i});
} }
} }
} }
log.logInfo("ISR: Tested opened IDT entries\n"); log.logInfo("ISR: Tested opened IDT entries\n", .{});
} }
/// ///

22
src/kernel/arch/x86/paging.zig
View file

@ -292,7 +292,7 @@ fn pageFault(state: *arch.InterruptContext) void {
/// IN allocator: *std.mem.Allocator - The allocator to use /// IN allocator: *std.mem.Allocator - The allocator to use
/// ///
pub fn init(mb_info: *multiboot.multiboot_info_t, mem_profile: *const MemProfile, allocator: *std.mem.Allocator) void { pub fn init(mb_info: *multiboot.multiboot_info_t, mem_profile: *const MemProfile, allocator: *std.mem.Allocator) void {
log.logInfo("Init paging\n"); log.logInfo("Init paging\n", .{});
// Calculate start and end of mapping // Calculate start and end of mapping
const v_start = std.mem.alignBackward(@ptrToInt(mem_profile.vaddr_start), PAGE_SIZE_4KB); const v_start = std.mem.alignBackward(@ptrToInt(mem_profile.vaddr_start), PAGE_SIZE_4KB);
const v_end = std.mem.alignForward(@ptrToInt(mem_profile.vaddr_end) + mem_profile.fixed_alloc_size, PAGE_SIZE_4KB); const v_end = std.mem.alignForward(@ptrToInt(mem_profile.vaddr_end) + mem_profile.fixed_alloc_size, PAGE_SIZE_4KB);
@ -300,14 +300,14 @@ pub fn init(mb_info: *multiboot.multiboot_info_t, mem_profile: *const MemProfile
const p_end = std.mem.alignForward(@ptrToInt(mem_profile.physaddr_end) + mem_profile.fixed_alloc_size, PAGE_SIZE_4KB); const p_end = std.mem.alignForward(@ptrToInt(mem_profile.physaddr_end) + mem_profile.fixed_alloc_size, PAGE_SIZE_4KB);
var tmp = allocator.alignedAlloc(Directory, @truncate(u29, PAGE_SIZE_4KB), 1) catch |e| { var tmp = allocator.alignedAlloc(Directory, @truncate(u29, PAGE_SIZE_4KB), 1) catch |e| {
panic(@errorReturnTrace(), "Failed to allocate page directory: {}\n", e); panic(@errorReturnTrace(), "Failed to allocate page directory: {}\n", .{e});
}; };
var kernel_directory = @ptrCast(*Directory, tmp.ptr); var kernel_directory = @ptrCast(*Directory, tmp.ptr);
@memset(@ptrCast([*]u8, kernel_directory), 0, @sizeOf(Directory)); @memset(@ptrCast([*]u8, kernel_directory), 0, @sizeOf(Directory));
// Map in kernel // Map in kernel
mapDir(kernel_directory, v_start, v_end, p_start, p_end, allocator) catch |e| { mapDir(kernel_directory, v_start, v_end, p_start, p_end, allocator) catch |e| {
panic(@errorReturnTrace(), "Failed to map kernel directory: {}\n", e); panic(@errorReturnTrace(), "Failed to map kernel directory: {}\n", .{e});
}; };
const tty_addr = tty.getVideoBufferAddress(); const tty_addr = tty.getVideoBufferAddress();
// If the previous mapping space didn't cover the tty buffer, do so now // If the previous mapping space didn't cover the tty buffer, do so now
@ -315,7 +315,7 @@ pub fn init(mb_info: *multiboot.multiboot_info_t, mem_profile: *const MemProfile
const tty_phys = mem.virtToPhys(tty_addr); const tty_phys = mem.virtToPhys(tty_addr);
const tty_buff_size = 32 * 1024; const tty_buff_size = 32 * 1024;
mapDir(kernel_directory, tty_addr, tty_addr + tty_buff_size, tty_phys, tty_phys + tty_buff_size, allocator) catch |e| { mapDir(kernel_directory, tty_addr, tty_addr + tty_buff_size, tty_phys, tty_phys + tty_buff_size, allocator) catch |e| {
panic(@errorReturnTrace(), "Failed to map vga buffer in kernel directory: {}\n", e); panic(@errorReturnTrace(), "Failed to map vga buffer in kernel directory: {}\n", .{e});
}; };
} }
@ -325,7 +325,7 @@ pub fn init(mb_info: *multiboot.multiboot_info_t, mem_profile: *const MemProfile
if (v_start > mb_info_addr) { if (v_start > mb_info_addr) {
const mb_info_end = mb_info_addr + PAGE_SIZE_4MB / 2; const mb_info_end = mb_info_addr + PAGE_SIZE_4MB / 2;
mapDir(kernel_directory, mb_info_addr, mb_info_end, mem.virtToPhys(mb_info_addr), mem.virtToPhys(mb_info_end), allocator) catch |e| { mapDir(kernel_directory, mb_info_addr, mb_info_end, mem.virtToPhys(mb_info_addr), mem.virtToPhys(mb_info_end), allocator) catch |e| {
panic(@errorReturnTrace(), "Failed to map mb_info in kernel directory: {}\n", e); panic(@errorReturnTrace(), "Failed to map mb_info in kernel directory: {}\n", .{e});
}; };
} }
@ -334,12 +334,12 @@ pub fn init(mb_info: *multiboot.multiboot_info_t, mem_profile: *const MemProfile
const mod_v_struct_start = std.mem.alignBackward(@ptrToInt(module), PAGE_SIZE_4KB); const mod_v_struct_start = std.mem.alignBackward(@ptrToInt(module), PAGE_SIZE_4KB);
const mod_v_struct_end = std.mem.alignForward(mod_v_struct_start + @sizeOf(multiboot.multiboot_module_t), PAGE_SIZE_4KB); const mod_v_struct_end = std.mem.alignForward(mod_v_struct_start + @sizeOf(multiboot.multiboot_module_t), PAGE_SIZE_4KB);
mapDir(kernel_directory, mod_v_struct_start, mod_v_struct_end, mem.virtToPhys(mod_v_struct_start), mem.virtToPhys(mod_v_struct_end), allocator) catch |e| { mapDir(kernel_directory, mod_v_struct_start, mod_v_struct_end, mem.virtToPhys(mod_v_struct_start), mem.virtToPhys(mod_v_struct_end), allocator) catch |e| {
panic(@errorReturnTrace(), "Failed to map module struct: {}\n", e); panic(@errorReturnTrace(), "Failed to map module struct: {}\n", .{e});
}; };
const mod_p_start = std.mem.alignBackward(module.mod_start, PAGE_SIZE_4KB); const mod_p_start = std.mem.alignBackward(module.mod_start, PAGE_SIZE_4KB);
const mod_p_end = std.mem.alignForward(module.mod_end, PAGE_SIZE_4KB); const mod_p_end = std.mem.alignForward(module.mod_end, PAGE_SIZE_4KB);
mapDir(kernel_directory, mem.physToVirt(mod_p_start), mem.physToVirt(mod_p_end), mod_p_start, mod_p_end, allocator) catch |e| { mapDir(kernel_directory, mem.physToVirt(mod_p_start), mem.physToVirt(mod_p_end), mod_p_start, mod_p_end, allocator) catch |e| {
panic(@errorReturnTrace(), "Failed to map boot module in kernel directory: {}\n", e); panic(@errorReturnTrace(), "Failed to map boot module in kernel directory: {}\n", .{e});
}; };
} }
@ -349,9 +349,9 @@ pub fn init(mb_info: *multiboot.multiboot_info_t, mem_profile: *const MemProfile
: [addr] "{eax}" (dir_physaddr) : [addr] "{eax}" (dir_physaddr)
); );
isr.registerIsr(isr.PAGE_FAULT, if (options.rt_test) rt_pageFault else pageFault) catch |e| { isr.registerIsr(isr.PAGE_FAULT, if (options.rt_test) rt_pageFault else pageFault) catch |e| {
panic(@errorReturnTrace(), "Failed to register page fault ISR: {}\n", e); panic(@errorReturnTrace(), "Failed to register page fault ISR: {}\n", .{e});
}; };
log.logInfo("Done\n"); log.logInfo("Done\n", .{});
if (options.rt_test) runtimeTests(v_end); if (options.rt_test) runtimeTests(v_end);
} }
@ -482,7 +482,7 @@ fn rt_accessUnmappedMem(v_end: u32) void {
\\rt_fault_callback: \\rt_fault_callback:
); );
testing.expect(faulted); testing.expect(faulted);
log.logInfo("Paging: Tested accessing unmapped memory\n"); log.logInfo("Paging: Tested accessing unmapped memory\n", .{});
} }
fn rt_accessMappedMem(v_end: u32) void { fn rt_accessMappedMem(v_end: u32) void {
@ -496,7 +496,7 @@ fn rt_accessMappedMem(v_end: u32) void {
\\rt_fault_callback2: \\rt_fault_callback2:
); );
testing.expect(!faulted); testing.expect(!faulted);
log.logInfo("Paging: Tested accessing mapped memory\n"); log.logInfo("Paging: Tested accessing mapped memory\n", .{});
} }
fn runtimeTests(v_end: u32) void { fn runtimeTests(v_end: u32) void {

83
src/kernel/arch/x86/pic.zig
View file

@ -432,7 +432,7 @@ pub fn clearMask(irq_num: u8) void {
/// by Intel up to 0x1F. So this will move the IRQs from 0x00-0x0F to 0x20-0x2F. /// by Intel up to 0x1F. So this will move the IRQs from 0x00-0x0F to 0x20-0x2F.
/// ///
pub fn init() void { pub fn init() void {
log.logInfo("Init pic\n"); log.logInfo("Init pic\n", .{});
// Initiate // Initiate
sendCommandMaster(ICW1_INITIALISATION | ICW1_EXPECT_ICW4); sendCommandMaster(ICW1_INITIALISATION | ICW1_EXPECT_ICW4);
@ -454,7 +454,7 @@ pub fn init() void {
sendDataMaster(0xFF); sendDataMaster(0xFF);
sendDataSlave(0xFF); sendDataSlave(0xFF);
log.logInfo("Done\n"); log.logInfo("Done\n", .{});
if (build_options.rt_test) runtimeTests(); if (build_options.rt_test) runtimeTests();
} }
@ -466,7 +466,7 @@ test "sendCommandMaster" {
const cmd: u8 = 10; const cmd: u8 = 10;
arch.addTestParams("outb", MASTER_COMMAND_REG, cmd); arch.addTestParams("outb", .{ MASTER_COMMAND_REG, cmd });
sendCommandMaster(cmd); sendCommandMaster(cmd);
} }
@ -478,7 +478,7 @@ test "sendCommandSlave" {
const cmd: u8 = 10; const cmd: u8 = 10;
arch.addTestParams("outb", SLAVE_COMMAND_REG, cmd); arch.addTestParams("outb", .{ SLAVE_COMMAND_REG, cmd });
sendCommandSlave(cmd); sendCommandSlave(cmd);
} }
@ -490,7 +490,7 @@ test "sendDataMaster" {
const data: u8 = 10; const data: u8 = 10;
arch.addTestParams("outb", MASTER_DATA_REG, data); arch.addTestParams("outb", .{ MASTER_DATA_REG, data });
sendDataMaster(data); sendDataMaster(data);
} }
@ -502,7 +502,7 @@ test "sendDataSlave" {
const data: u8 = 10; const data: u8 = 10;
arch.addTestParams("outb", SLAVE_DATA_REG, data); arch.addTestParams("outb", .{ SLAVE_DATA_REG, data });
sendDataSlave(data); sendDataSlave(data);
} }
@ -512,7 +512,7 @@ test "readDataMaster" {
arch.initTest(); arch.initTest();
defer arch.freeTest(); defer arch.freeTest();
arch.addTestParams("inb", MASTER_DATA_REG, @as(u8, 10)); arch.addTestParams("inb", .{ MASTER_DATA_REG, @as(u8, 10) });
expectEqual(@as(u8, 10), readDataMaster()); expectEqual(@as(u8, 10), readDataMaster());
} }
@ -522,7 +522,7 @@ test "readDataSlave" {
arch.initTest(); arch.initTest();
defer arch.freeTest(); defer arch.freeTest();
arch.addTestParams("inb", SLAVE_DATA_REG, @as(u8, 10)); arch.addTestParams("inb", .{ SLAVE_DATA_REG, @as(u8, 10) });
expectEqual(@as(u8, 10), readDataSlave()); expectEqual(@as(u8, 10), readDataSlave());
} }
@ -532,8 +532,8 @@ test "readMasterIrr" {
arch.initTest(); arch.initTest();
defer arch.freeTest(); defer arch.freeTest();
arch.addTestParams("outb", MASTER_COMMAND_REG, @as(u8, 0x0A)); arch.addTestParams("outb", .{ MASTER_COMMAND_REG, @as(u8, 0x0A) });
arch.addTestParams("inb", MASTER_STATUS_REG, @as(u8, 10)); arch.addTestParams("inb", .{ MASTER_STATUS_REG, @as(u8, 10) });
expectEqual(@as(u8, 10), readMasterIrr()); expectEqual(@as(u8, 10), readMasterIrr());
} }
@ -543,8 +543,8 @@ test "readSlaveIrr" {
arch.initTest(); arch.initTest();
defer arch.freeTest(); defer arch.freeTest();
arch.addTestParams("outb", SLAVE_COMMAND_REG, @as(u8, 0x0A)); arch.addTestParams("outb", .{ SLAVE_COMMAND_REG, @as(u8, 0x0A) });
arch.addTestParams("inb", SLAVE_STATUS_REG, @as(u8, 10)); arch.addTestParams("inb", .{ SLAVE_STATUS_REG, @as(u8, 10) });
expectEqual(@as(u8, 10), readSlaveIrr()); expectEqual(@as(u8, 10), readSlaveIrr());
} }
@ -554,8 +554,8 @@ test "readMasterIsr" {
arch.initTest(); arch.initTest();
defer arch.freeTest(); defer arch.freeTest();
arch.addTestParams("outb", MASTER_COMMAND_REG, @as(u8, 0x0B)); arch.addTestParams("outb", .{ MASTER_COMMAND_REG, @as(u8, 0x0B) });
arch.addTestParams("inb", MASTER_STATUS_REG, @as(u8, 10)); arch.addTestParams("inb", .{ MASTER_STATUS_REG, @as(u8, 10) });
expectEqual(@as(u8, 10), readMasterIsr()); expectEqual(@as(u8, 10), readMasterIsr());
} }
@ -565,8 +565,8 @@ test "readSlaveIsr" {
arch.initTest(); arch.initTest();
defer arch.freeTest(); defer arch.freeTest();
arch.addTestParams("outb", SLAVE_COMMAND_REG, @as(u8, 0x0B)); arch.addTestParams("outb", .{ SLAVE_COMMAND_REG, @as(u8, 0x0B) });
arch.addTestParams("inb", SLAVE_STATUS_REG, @as(u8, 10)); arch.addTestParams("inb", .{ SLAVE_STATUS_REG, @as(u8, 10) });
expectEqual(@as(u8, 10), readSlaveIsr()); expectEqual(@as(u8, 10), readSlaveIsr());
} }
@ -578,7 +578,7 @@ test "sendEndOfInterrupt master only" {
var i: u8 = 0; var i: u8 = 0;
while (i < 8) : (i += 1) { while (i < 8) : (i += 1) {
arch.addTestParams("outb", MASTER_COMMAND_REG, OCW2_END_OF_INTERRUPT); arch.addTestParams("outb", .{ MASTER_COMMAND_REG, OCW2_END_OF_INTERRUPT });
sendEndOfInterrupt(i); sendEndOfInterrupt(i);
} }
@ -591,8 +591,8 @@ test "sendEndOfInterrupt master and slave" {
var i: u8 = 8; var i: u8 = 8;
while (i < 16) : (i += 1) { while (i < 16) : (i += 1) {
arch.addTestParams("outb", SLAVE_COMMAND_REG, OCW2_END_OF_INTERRUPT); arch.addTestParams("outb", .{ SLAVE_COMMAND_REG, OCW2_END_OF_INTERRUPT });
arch.addTestParams("outb", MASTER_COMMAND_REG, OCW2_END_OF_INTERRUPT); arch.addTestParams("outb", .{ MASTER_COMMAND_REG, OCW2_END_OF_INTERRUPT });
sendEndOfInterrupt(i); sendEndOfInterrupt(i);
} }
@ -621,9 +621,9 @@ test "spuriousIrq spurious master IRQ number not spurious" {
arch.initTest(); arch.initTest();
defer arch.freeTest(); defer arch.freeTest();
arch.addTestParams("outb", MASTER_COMMAND_REG, @as(u8, 0x0B)); arch.addTestParams("outb", .{ MASTER_COMMAND_REG, @as(u8, 0x0B) });
// Return 0x80 from readMasterIsr() which will mean this was a real IRQ // Return 0x80 from readMasterIsr() which will mean this was a real IRQ
arch.addTestParams("inb", MASTER_STATUS_REG, @as(u8, 0x80)); arch.addTestParams("inb", .{ MASTER_STATUS_REG, @as(u8, 0x80) });
// Pre testing // Pre testing
expectEqual(@as(u32, 0), spurious_irq_counter); expectEqual(@as(u32, 0), spurious_irq_counter);
@ -643,9 +643,9 @@ test "spuriousIrq spurious master IRQ number spurious" {
arch.initTest(); arch.initTest();
defer arch.freeTest(); defer arch.freeTest();
arch.addTestParams("outb", MASTER_COMMAND_REG, @as(u8, 0x0B)); arch.addTestParams("outb", .{ MASTER_COMMAND_REG, @as(u8, 0x0B) });
// Return 0x0 from readMasterIsr() which will mean this was a spurious IRQ // Return 0x0 from readMasterIsr() which will mean this was a spurious IRQ
arch.addTestParams("inb", MASTER_STATUS_REG, @as(u8, 0x0)); arch.addTestParams("inb", .{ MASTER_STATUS_REG, @as(u8, 0x0) });
// Pre testing // Pre testing
expectEqual(@as(u32, 0), spurious_irq_counter); expectEqual(@as(u32, 0), spurious_irq_counter);
@ -665,9 +665,9 @@ test "spuriousIrq spurious slave IRQ number not spurious" {
arch.initTest(); arch.initTest();
defer arch.freeTest(); defer arch.freeTest();
arch.addTestParams("outb", SLAVE_COMMAND_REG, @as(u8, 0x0B)); arch.addTestParams("outb", .{ SLAVE_COMMAND_REG, @as(u8, 0x0B) });
// Return 0x80 from readSlaveIsr() which will mean this was a real IRQ // Return 0x80 from readSlaveIsr() which will mean this was a real IRQ
arch.addTestParams("inb", SLAVE_STATUS_REG, @as(u8, 0x80)); arch.addTestParams("inb", .{ SLAVE_STATUS_REG, @as(u8, 0x80) });
// Pre testing // Pre testing
expectEqual(@as(u32, 0), spurious_irq_counter); expectEqual(@as(u32, 0), spurious_irq_counter);
@ -687,11 +687,11 @@ test "spuriousIrq spurious slave IRQ number spurious" {
arch.initTest(); arch.initTest();
defer arch.freeTest(); defer arch.freeTest();
arch.addTestParams("outb", SLAVE_COMMAND_REG, @as(u8, 0x0B)); arch.addTestParams("outb", .{ SLAVE_COMMAND_REG, @as(u8, 0x0B) });
// Return 0x0 from readSlaveIsr() which will mean this was a spurious IRQ // Return 0x0 from readSlaveIsr() which will mean this was a spurious IRQ
arch.addTestParams("inb", SLAVE_STATUS_REG, @as(u8, 0x0)); arch.addTestParams("inb", .{ SLAVE_STATUS_REG, @as(u8, 0x0) });
// A EOI will be sent for a spurious IRQ 15 // A EOI will be sent for a spurious IRQ 15
arch.addTestParams("outb", MASTER_COMMAND_REG, OCW2_END_OF_INTERRUPT); arch.addTestParams("outb", .{ MASTER_COMMAND_REG, OCW2_END_OF_INTERRUPT });
// Pre testing // Pre testing
expectEqual(@as(u32, 0), spurious_irq_counter); expectEqual(@as(u32, 0), spurious_irq_counter);
@ -712,9 +712,9 @@ test "setMask master IRQ masked" {
defer arch.freeTest(); defer arch.freeTest();
// Going to assume all bits are masked out // Going to assume all bits are masked out
arch.addTestParams("inb", MASTER_DATA_REG, @as(u8, 0xFF)); arch.addTestParams("inb", .{ MASTER_DATA_REG, @as(u8, 0xFF) });
// Expect the 2nd bit to be set // Expect the 2nd bit to be set
arch.addTestParams("outb", MASTER_DATA_REG, @as(u8, 0xFF)); arch.addTestParams("outb", .{ MASTER_DATA_REG, @as(u8, 0xFF) });
setMask(1); setMask(1);
} }
@ -725,9 +725,9 @@ test "setMask master IRQ unmasked" {
defer arch.freeTest(); defer arch.freeTest();
// IRQ already unmasked // IRQ already unmasked
arch.addTestParams("inb", MASTER_DATA_REG, @as(u8, 0xFD)); arch.addTestParams("inb", .{ MASTER_DATA_REG, @as(u8, 0xFD) });
// Expect the 2nd bit to be set // Expect the 2nd bit to be set
arch.addTestParams("outb", MASTER_DATA_REG, @as(u8, 0xFF)); arch.addTestParams("outb", .{ MASTER_DATA_REG, @as(u8, 0xFF) });
setMask(1); setMask(1);
} }
@ -738,9 +738,9 @@ test "clearMask master IRQ masked" {
defer arch.freeTest(); defer arch.freeTest();
// Going to assume all bits are masked out // Going to assume all bits are masked out
arch.addTestParams("inb", MASTER_DATA_REG, @as(u8, 0xFF)); arch.addTestParams("inb", .{ MASTER_DATA_REG, @as(u8, 0xFF) });
// Expect the 2nd bit to be clear // Expect the 2nd bit to be clear
arch.addTestParams("outb", MASTER_DATA_REG, @as(u8, 0xFD)); arch.addTestParams("outb", .{ MASTER_DATA_REG, @as(u8, 0xFD) });
clearMask(1); clearMask(1);
} }
@ -751,9 +751,9 @@ test "clearMask master IRQ unmasked" {
defer arch.freeTest(); defer arch.freeTest();
// IRQ already unmasked // IRQ already unmasked
arch.addTestParams("inb", MASTER_DATA_REG, @as(u8, 0xFD)); arch.addTestParams("inb", .{ MASTER_DATA_REG, @as(u8, 0xFD) });
// Expect the 2nd bit to still be clear // Expect the 2nd bit to still be clear
arch.addTestParams("outb", MASTER_DATA_REG, @as(u8, 0xFD)); arch.addTestParams("outb", .{ MASTER_DATA_REG, @as(u8, 0xFD) });
clearMask(1); clearMask(1);
} }
@ -764,8 +764,7 @@ test "init" {
defer arch.freeTest(); defer arch.freeTest();
// Just a long list of OUT instructions setting up the PIC // Just a long list of OUT instructions setting up the PIC
arch.addTestParams( arch.addTestParams("outb", .{
"outb",
MASTER_COMMAND_REG, MASTER_COMMAND_REG,
ICW1_INITIALISATION | ICW1_EXPECT_ICW4, ICW1_INITIALISATION | ICW1_EXPECT_ICW4,
SLAVE_COMMAND_REG, SLAVE_COMMAND_REG,
@ -786,7 +785,7 @@ test "init" {
@as(u8, 0xFF), @as(u8, 0xFF),
SLAVE_DATA_REG, SLAVE_DATA_REG,
@as(u8, 0xFF), @as(u8, 0xFF),
); });
init(); init();
} }
@ -796,14 +795,14 @@ test "init" {
/// ///
fn rt_picAllMasked() void { fn rt_picAllMasked() void {
if (readDataMaster() != 0xFF) { if (readDataMaster() != 0xFF) {
panic(@errorReturnTrace(), "Master masks are not set, found: {}\n", readDataMaster()); panic(@errorReturnTrace(), "Master masks are not set, found: {}\n", .{readDataMaster()});
} }
if (readDataSlave() != 0xFF) { if (readDataSlave() != 0xFF) {
panic(@errorReturnTrace(), "Slave masks are not set, found: {}\n", readDataSlave()); panic(@errorReturnTrace(), "Slave masks are not set, found: {}\n", .{readDataSlave()});
} }
log.logInfo("PIC: Tested masking\n"); log.logInfo("PIC: Tested masking\n", .{});
} }
/// ///

44
src/kernel/arch/x86/pit.zig
View file

@ -370,26 +370,26 @@ pub fn getFrequency() u32 {
/// Initialise the PIT with a handler to IRQ 0. /// Initialise the PIT with a handler to IRQ 0.
/// ///
pub fn init() void { pub fn init() void {
log.logInfo("Init pit\n"); log.logInfo("Init pit\n", .{});
// Set up counter 0 at 10000hz in a square wave mode counting in binary // Set up counter 0 at 10000hz in a square wave mode counting in binary
const freq: u32 = 10000; const freq: u32 = 10000;
setupCounter(CounterSelect.Counter0, freq, OCW_MODE_SQUARE_WAVE_GENERATOR | OCW_BINARY_COUNT_BINARY) catch |e| { setupCounter(CounterSelect.Counter0, freq, OCW_MODE_SQUARE_WAVE_GENERATOR | OCW_BINARY_COUNT_BINARY) catch |e| {
panic(@errorReturnTrace(), "Invalid frequency: {}\n", freq); panic(@errorReturnTrace(), "Invalid frequency: {}\n", .{freq});
}; };
log.logDebug("Set frequency at: {}Hz, real frequency: {}Hz\n", freq, getFrequency()); log.logDebug("Set frequency at: {}Hz, real frequency: {}Hz\n", .{ freq, getFrequency() });
// Installs 'pitHandler' to IRQ0 (pic.IRQ_PIT) // Installs 'pitHandler' to IRQ0 (pic.IRQ_PIT)
irq.registerIrq(pic.IRQ_PIT, pitHandler) catch |err| switch (err) { irq.registerIrq(pic.IRQ_PIT, pitHandler) catch |err| switch (err) {
error.IrqExists => { error.IrqExists => {
panic(@errorReturnTrace(), "IRQ for PIT, IRQ number: {} exists", pic.IRQ_PIT); panic(@errorReturnTrace(), "IRQ for PIT, IRQ number: {} exists", .{pic.IRQ_PIT});
}, },
error.InvalidIrq => { error.InvalidIrq => {
panic(@errorReturnTrace(), "IRQ for PIT, IRQ number: {} is invalid", pic.IRQ_PIT); panic(@errorReturnTrace(), "IRQ for PIT, IRQ number: {} is invalid", .{pic.IRQ_PIT});
}, },
}; };
log.logInfo("Done\n"); log.logInfo("Done\n", .{});
if (build_options.rt_test) runtimeTests(); if (build_options.rt_test) runtimeTests();
} }
@ -400,7 +400,7 @@ test "sendCommand" {
const cmd: u8 = 10; const cmd: u8 = 10;
arch.addTestParams("outb", COMMAND_REGISTER, cmd); arch.addTestParams("outb", .{ COMMAND_REGISTER, cmd });
sendCommand(cmd); sendCommand(cmd);
} }
@ -411,8 +411,8 @@ test "readBackCommand" {
const cmd: u8 = 0xC2; const cmd: u8 = 0xC2;
arch.addTestParams("outb", COMMAND_REGISTER, cmd); arch.addTestParams("outb", .{ COMMAND_REGISTER, cmd });
arch.addTestParams("inb", COUNTER_0_REGISTER, @as(u8, 0x20)); arch.addTestParams("inb", .{ COUNTER_0_REGISTER, @as(u8, 0x20) });
const actual = readBackCommand(CounterSelect.Counter0); const actual = readBackCommand(CounterSelect.Counter0);
@ -425,7 +425,7 @@ test "sendDataToCounter" {
const data: u8 = 10; const data: u8 = 10;
arch.addTestParams("outb", COUNTER_0_REGISTER, data); arch.addTestParams("outb", .{ COUNTER_0_REGISTER, data });
sendDataToCounter(CounterSelect.Counter0, data); sendDataToCounter(CounterSelect.Counter0, data);
} }
@ -519,7 +519,7 @@ test "setupCounter normal frequency" {
const mode = OCW_MODE_SQUARE_WAVE_GENERATOR | OCW_BINARY_COUNT_BINARY; const mode = OCW_MODE_SQUARE_WAVE_GENERATOR | OCW_BINARY_COUNT_BINARY;
const command = mode | OCW_READ_LOAD_DATA | counter.getCounterOCW(); const command = mode | OCW_READ_LOAD_DATA | counter.getCounterOCW();
arch.addTestParams("outb", COMMAND_REGISTER, command, port, @truncate(u8, expected_reload_value), port, @truncate(u8, expected_reload_value >> 8)); arch.addTestParams("outb", .{ COMMAND_REGISTER, command, port, @truncate(u8, expected_reload_value), port, @truncate(u8, expected_reload_value >> 8) });
setupCounter(counter, freq, mode) catch unreachable; setupCounter(counter, freq, mode) catch unreachable;
@ -551,10 +551,10 @@ fn rt_waitTicks() void {
const difference = getTicks() - waiting; const difference = getTicks() - waiting;
if (previous_count + epsilon < difference or previous_count > difference + epsilon) { if (previous_count + epsilon < difference or previous_count > difference + epsilon) {
panic(@errorReturnTrace(), "Waiting failed. difference: {}, previous_count: {}. Epsilon: {}\n", difference, previous_count, epsilon); panic(@errorReturnTrace(), "Waiting failed. difference: {}, previous_count: {}. Epsilon: {}\n", .{ difference, previous_count, epsilon });
} }
log.logInfo("PIT: Tested wait ticks\n"); log.logInfo("PIT: Tested wait ticks\n", .{});
} }
/// ///
@ -575,10 +575,10 @@ fn rt_waitTicks2() void {
const difference = getTicks() + 15 - waiting; const difference = getTicks() + 15 - waiting;
if (previous_count + epsilon < difference or previous_count > difference + epsilon) { if (previous_count + epsilon < difference or previous_count > difference + epsilon) {
panic(@errorReturnTrace(), "Waiting failed. difference: {}, previous_count: {}. Epsilon: {}\n", difference, previous_count, epsilon); panic(@errorReturnTrace(), "Waiting failed. difference: {}, previous_count: {}. Epsilon: {}\n", .{ difference, previous_count, epsilon });
} }
log.logInfo("PIT: Tested wait ticks 2\n"); log.logInfo("PIT: Tested wait ticks 2\n", .{});
// Reset ticks // Reset ticks
ticks = 0; ticks = 0;
@ -593,16 +593,14 @@ fn rt_initCounter_0() void {
const expected_hz: u32 = 10027; const expected_hz: u32 = 10027;
if (time_ns != expected_ns or time_under_1_ns != expected_ps or getFrequency() != expected_hz) { if (time_ns != expected_ns or time_under_1_ns != expected_ps or getFrequency() != expected_hz) {
panic( panic(@errorReturnTrace(), "Frequency not set properly. Hz: {}!={}, ns: {}!={}, ps: {}!= {}\n", .{
@errorReturnTrace(),
"Frequency not set properly. Hz: {}!={}, ns: {}!={}, ps: {}!= {}\n",
getFrequency(), getFrequency(),
expected_hz, expected_hz,
time_ns, time_ns,
expected_ns, expected_ns,
time_under_1_ns, time_under_1_ns,
expected_ps, expected_ps,
); });
} }
var irq_exists = false; var irq_exists = false;
@ -613,22 +611,22 @@ fn rt_initCounter_0() void {
irq_exists = true; irq_exists = true;
}, },
error.InvalidIrq => { error.InvalidIrq => {
panic(@errorReturnTrace(), "IRQ for PIT, IRQ number: {} is invalid", pic.IRQ_PIT); panic(@errorReturnTrace(), "IRQ for PIT, IRQ number: {} is invalid", .{pic.IRQ_PIT});
}, },
}; };
if (!irq_exists) { if (!irq_exists) {
panic(@errorReturnTrace(), "IRQ for PIT doesn't exists\n"); panic(@errorReturnTrace(), "IRQ for PIT doesn't exists\n", .{});
} }
const expected_mode = OCW_READ_LOAD_DATA | OCW_MODE_SQUARE_WAVE_GENERATOR | OCW_SELECT_COUNTER_0 | OCW_BINARY_COUNT_BINARY; const expected_mode = OCW_READ_LOAD_DATA | OCW_MODE_SQUARE_WAVE_GENERATOR | OCW_SELECT_COUNTER_0 | OCW_BINARY_COUNT_BINARY;
const actual_mode = readBackCommand(CounterSelect.Counter0); const actual_mode = readBackCommand(CounterSelect.Counter0);
if (expected_mode != actual_mode) { if (expected_mode != actual_mode) {
panic(@errorReturnTrace(), "Operating mode don't not set properly. Found: {}, expecting: {}\n", actual_mode, expected_mode); panic(@errorReturnTrace(), "Operating mode don't not set properly. Found: {}, expecting: {}\n", .{ actual_mode, expected_mode });
} }
log.logInfo("PIT: Tested init\n"); log.logInfo("PIT: Tested init\n", .{});
} }
/// ///

20
src/kernel/arch/x86/syscalls.zig
View file

@ -53,10 +53,10 @@ fn handle(ctx: *arch.InterruptContext) void {
if (handlers[syscall]) |handler| { if (handlers[syscall]) |handler| {
ctx.eax = handler(ctx, syscallArg(ctx, 0), syscallArg(ctx, 1), syscallArg(ctx, 2), syscallArg(ctx, 3), syscallArg(ctx, 4)); ctx.eax = handler(ctx, syscallArg(ctx, 0), syscallArg(ctx, 1), syscallArg(ctx, 2), syscallArg(ctx, 3), syscallArg(ctx, 4));
} else { } else {
log.logWarning("Syscall {} triggered but not registered\n", syscall); log.logWarning("Syscall {} triggered but not registered\n", .{syscall});
} }
} else { } else {
log.logWarning("Syscall {} is invalid\n", syscall); log.logWarning("Syscall {} is invalid\n", .{syscall});
} }
} }
@ -237,9 +237,9 @@ inline fn syscallArg(ctx: *arch.InterruptContext, comptime arg_idx: u32) u32 {
/// Initialise syscalls. Registers the isr associated with INTERRUPT. /// Initialise syscalls. Registers the isr associated with INTERRUPT.
/// ///
pub fn init() void { pub fn init() void {
log.logInfo("Init syscalls\n"); log.logInfo("Init syscalls\n", .{});
isr.registerIsr(INTERRUPT, handle) catch unreachable; isr.registerIsr(INTERRUPT, handle) catch unreachable;
log.logInfo("Done\n"); log.logInfo("Done\n", .{});
if (options.rt_test) runtimeTests(); if (options.rt_test) runtimeTests();
} }
@ -294,20 +294,20 @@ fn runtimeTests() void {
assert(testInt == 0); assert(testInt == 0);
if (syscall0(123) == 0 and testInt == 1) if (syscall0(123) == 0 and testInt == 1)
log.logInfo("Syscalls: Tested no args\n"); log.logInfo("Syscalls: Tested no args\n", .{});
if (syscall1(124, 2) == 1 and testInt == 3) if (syscall1(124, 2) == 1 and testInt == 3)
log.logInfo("Syscalls: Tested 1 arg\n"); log.logInfo("Syscalls: Tested 1 arg\n", .{});
if (syscall2(125, 2, 3) == 2 and testInt == 8) if (syscall2(125, 2, 3) == 2 and testInt == 8)
log.logInfo("Syscalls: Tested 2 args\n"); log.logInfo("Syscalls: Tested 2 args\n", .{});
if (syscall3(126, 2, 3, 4) == 3 and testInt == 17) if (syscall3(126, 2, 3, 4) == 3 and testInt == 17)
log.logInfo("Syscalls: Tested 3 args\n"); log.logInfo("Syscalls: Tested 3 args\n", .{});
if (syscall4(127, 2, 3, 4, 5) == 4 and testInt == 31) if (syscall4(127, 2, 3, 4, 5) == 4 and testInt == 31)
log.logInfo("Syscalls: Tested 4 args\n"); log.logInfo("Syscalls: Tested 4 args\n", .{});
if (syscall5(128, 2, 3, 4, 5, 6) == 5 and testInt == 51) if (syscall5(128, 2, 3, 4, 5, 6) == 5 and testInt == 51)
log.logInfo("Syscalls: Tested 5 args\n"); log.logInfo("Syscalls: Tested 5 args\n", .{});
} }

14
src/kernel/kmain.zig
View file

@ -27,14 +27,14 @@ export var KERNEL_ADDR_OFFSET: u32 = if (builtin.is_test) 0xC0000000 else undefi
// Just call the panic function, as this need to be in the root source file // Just call the panic function, as this need to be in the root source file
pub fn panic(msg: []const u8, error_return_trace: ?*builtin.StackTrace) noreturn { pub fn panic(msg: []const u8, error_return_trace: ?*builtin.StackTrace) noreturn {
@setCold(true); @setCold(true);
panic_root.panic(error_return_trace, "{}", msg); panic_root.panic(error_return_trace, "{}", .{msg});
} }
export fn kmain(mb_info: *multiboot.multiboot_info_t, mb_magic: u32) void { export fn kmain(mb_info: *multiboot.multiboot_info_t, mb_magic: u32) void {
if (mb_magic == multiboot.MULTIBOOT_BOOTLOADER_MAGIC) { if (mb_magic == multiboot.MULTIBOOT_BOOTLOADER_MAGIC) {
// Booted with compatible bootloader // Booted with compatible bootloader
serial.init(serial.DEFAULT_BAUDRATE, serial.Port.COM1) catch |e| { serial.init(serial.DEFAULT_BAUDRATE, serial.Port.COM1) catch |e| {
panic_root.panic(@errorReturnTrace(), "Failed to initialise serial: {}", e); panic_root.panic(@errorReturnTrace(), "Failed to initialise serial: {}", .{e});
}; };
if (build_options.rt_test) if (build_options.rt_test)
log.runtimeTests(); log.runtimeTests();
@ -42,17 +42,17 @@ export fn kmain(mb_info: *multiboot.multiboot_info_t, mb_magic: u32) void {
var buffer = mem_profile.vaddr_end[0..mem_profile.fixed_alloc_size]; var buffer = mem_profile.vaddr_end[0..mem_profile.fixed_alloc_size];
var fixed_allocator = std.heap.FixedBufferAllocator.init(buffer); var fixed_allocator = std.heap.FixedBufferAllocator.init(buffer);
log.logInfo("Init arch " ++ @tagName(builtin.arch) ++ "\n"); log.logInfo("Init arch " ++ @tagName(builtin.arch) ++ "\n", .{});
arch.init(mb_info, &mem_profile, &fixed_allocator.allocator); arch.init(mb_info, &mem_profile, &fixed_allocator.allocator);
log.logInfo("Arch init done\n"); log.logInfo("Arch init done\n", .{});
panic_root.init(&mem_profile, &fixed_allocator.allocator) catch |e| { panic_root.init(&mem_profile, &fixed_allocator.allocator) catch |e| {
panic_root.panic(@errorReturnTrace(), "Failed to initialise panic: {}", e); panic_root.panic(@errorReturnTrace(), "Failed to initialise panic: {}", .{e});
}; };
vga.init(); vga.init();
tty.init(); tty.init();
log.logInfo("Init done\n"); log.logInfo("Init done\n", .{});
tty.print("Hello Pluto from kernel :)\n"); tty.print("Hello Pluto from kernel :)\n", .{});
// The panic runtime tests must run last as they never return // The panic runtime tests must run last as they never return
if (options.rt_test) panic_root.runtimeTests(); if (options.rt_test) panic_root.runtimeTests();
} }

54
src/kernel/log.zig
View file

@ -12,38 +12,74 @@ fn logCallback(context: void, str: []const u8) anyerror!void {
serial.writeBytes(str, serial.Port.COM1); serial.writeBytes(str, serial.Port.COM1);
} }
pub fn log(comptime level: Level, comptime format: []const u8, args: ...) void { ///
/// Write a message to the log output stream with a certain logging level.
///
/// Arguments:
/// IN comptime level: Level - The logging level to use. Determines the message prefix and whether it is filtered.
/// IN comptime format: []const u8 - The message format. Uses the standard format specification options.
/// IN args: var - A struct of the parameters for the format string.
///
pub fn log(comptime level: Level, comptime format: []const u8, args: var) void {
fmt.format({}, anyerror, logCallback, "[" ++ @tagName(level) ++ "] " ++ format, args) catch unreachable; fmt.format({}, anyerror, logCallback, "[" ++ @tagName(level) ++ "] " ++ format, args) catch unreachable;
} }
pub fn logInfo(comptime format: []const u8, args: ...) void { ///
/// Write a message to the log output stream with the INFO level.
///
/// Arguments:
/// IN comptime format: []const u8 - The message format. Uses the standard format specification options.
/// IN args: var - A struct of the parameters for the format string.
///
pub fn logInfo(comptime format: []const u8, args: var) void {
log(Level.INFO, format, args); log(Level.INFO, format, args);
} }
pub fn logDebug(comptime format: []const u8, args: ...) void { ///
/// Write a message to the log output stream with the DEBUG level.
///
/// Arguments:
/// IN comptime format: []const u8 - The message format. Uses the standard format specification options.
/// IN args: var - A struct of the parameters for the format string.
///
pub fn logDebug(comptime format: []const u8, args: var) void {
log(Level.DEBUG, format, args); log(Level.DEBUG, format, args);
} }
pub fn logWarning(comptime format: []const u8, args: ...) void { ///
/// Write a message to the log output stream with the WARNING level.
///
/// Arguments:
/// IN comptime format: []const u8 - The message format. Uses the standard format specification options.
/// IN args: var - A struct of the parameters for the format string.
///
pub fn logWarning(comptime format: []const u8, args: var) void {
log(Level.WARNING, format, args); log(Level.WARNING, format, args);
} }
pub fn logError(comptime format: []const u8, args: ...) void { ///
/// Write a message to the log output stream with the ERROR level.
///
/// Arguments:
/// IN comptime format: []const u8 - The message format. Uses the standard format specification options.
/// IN args: var - A struct of the parameters for the format string.
///
pub fn logError(comptime format: []const u8, args: var) void {
log(Level.ERROR, format, args); log(Level.ERROR, format, args);
} }
pub fn runtimeTests() void { pub fn runtimeTests() void {
inline for (@typeInfo(Level).Enum.fields) |field| { inline for (@typeInfo(Level).Enum.fields) |field| {
const level = @field(Level, field.name); const level = @field(Level, field.name);
log(level, "Test " ++ field.name ++ " level\n"); log(level, "Test " ++ field.name ++ " level\n", .{});
log(level, "Test " ++ field.name ++ " level with args {}, {}\n", "a", @as(u32, 1)); log(level, "Test " ++ field.name ++ " level with args {}, {}\n", .{ "a", @as(u32, 1) });
const logFn = switch (level) { const logFn = switch (level) {
.INFO => logInfo, .INFO => logInfo,
.DEBUG => logDebug, .DEBUG => logDebug,
.WARNING => logWarning, .WARNING => logWarning,
.ERROR => logError, .ERROR => logError,
}; };
logFn("Test " ++ field.name ++ " function\n"); logFn("Test " ++ field.name ++ " function\n", .{});
logFn("Test " ++ field.name ++ " function with args {}, {}\n", "a", @as(u32, 1)); logFn("Test " ++ field.name ++ " function with args {}, {}\n", .{ "a", @as(u32, 1) });
} }
} }

20
src/kernel/mem.zig
View file

@ -46,7 +46,7 @@ var ADDR_OFFSET: usize = undefined;
/// The memory profile constructed from the exported linker symbols and the relevant multiboot info. /// The memory profile constructed from the exported linker symbols and the relevant multiboot info.
/// ///
pub fn init(mb_info: *multiboot.multiboot_info_t) MemProfile { pub fn init(mb_info: *multiboot.multiboot_info_t) MemProfile {
log.logInfo("Init mem\n"); log.logInfo("Init mem\n", .{});
const mods_count = mb_info.mods_count; const mods_count = mb_info.mods_count;
ADDR_OFFSET = @ptrToInt(&KERNEL_ADDR_OFFSET); ADDR_OFFSET = @ptrToInt(&KERNEL_ADDR_OFFSET);
const mem_profile = MemProfile{ const mem_profile = MemProfile{
@ -59,7 +59,7 @@ pub fn init(mb_info: *multiboot.multiboot_info_t) MemProfile {
.fixed_alloc_size = FIXED_ALLOC_SIZE, .fixed_alloc_size = FIXED_ALLOC_SIZE,
.boot_modules = @intToPtr([*]multiboot.multiboot_mod_list, physToVirt(mb_info.mods_addr))[0..mods_count], .boot_modules = @intToPtr([*]multiboot.multiboot_mod_list, physToVirt(mb_info.mods_addr))[0..mods_count],
}; };
log.logInfo("Done\n"); log.logInfo("Done\n", .{});
return mem_profile; return mem_profile;
} }
@ -69,11 +69,11 @@ pub fn init(mb_info: *multiboot.multiboot_info_t) MemProfile {
/// Arguments: /// Arguments:
/// IN virt: var - The virtual address to covert. Either an integer or pointer. /// IN virt: var - The virtual address to covert. Either an integer or pointer.
/// ///
/// Return: @typeOf(virt) /// Return: @TypeOf(virt)
/// The physical address. /// The physical address.
/// ///
pub inline fn virtToPhys(virt: var) @typeOf(virt) { pub inline fn virtToPhys(virt: var) @TypeOf(virt) {
const T = @typeOf(virt); const T = @TypeOf(virt);
return switch (@typeId(T)) { return switch (@typeId(T)) {
.Pointer => @intToPtr(T, @ptrToInt(virt) - ADDR_OFFSET), .Pointer => @intToPtr(T, @ptrToInt(virt) - ADDR_OFFSET),
.Int => virt - ADDR_OFFSET, .Int => virt - ADDR_OFFSET,
@ -87,11 +87,11 @@ pub inline fn virtToPhys(virt: var) @typeOf(virt) {
/// Arguments: /// Arguments:
/// IN phys: var - The physical address to covert. Either an integer or pointer. /// IN phys: var - The physical address to covert. Either an integer or pointer.
/// ///
/// Return: @typeOf(virt) /// Return: @TypeOf(virt)
/// The virtual address. /// The virtual address.
/// ///
pub inline fn physToVirt(phys: var) @typeOf(phys) { pub inline fn physToVirt(phys: var) @TypeOf(phys) {
const T = @typeOf(phys); const T = @TypeOf(phys);
return switch (@typeId(T)) { return switch (@typeId(T)) {
.Pointer => @intToPtr(T, @ptrToInt(phys) + ADDR_OFFSET), .Pointer => @intToPtr(T, @ptrToInt(phys) + ADDR_OFFSET),
.Int => phys + ADDR_OFFSET, .Int => phys + ADDR_OFFSET,
@ -104,7 +104,7 @@ test "physToVirt" {
const offset: usize = ADDR_OFFSET; const offset: usize = ADDR_OFFSET;
expectEqual(physToVirt(@as(usize, 0)), offset + 0); expectEqual(physToVirt(@as(usize, 0)), offset + 0);
expectEqual(physToVirt(@as(usize, 123)), offset + 123); expectEqual(physToVirt(@as(usize, 123)), offset + 123);
expectEqual(@ptrToInt(physToVirt(@intToPtr(*usize, 123))), offset + 123); expectEqual(@ptrToInt(physToVirt(@intToPtr(*align(1) usize, 123))), offset + 123);
} }
test "virtToPhys" { test "virtToPhys" {
@ -112,5 +112,5 @@ test "virtToPhys" {
const offset: usize = ADDR_OFFSET; const offset: usize = ADDR_OFFSET;
expectEqual(virtToPhys(offset + 0), 0); expectEqual(virtToPhys(offset + 0), 0);
expectEqual(virtToPhys(offset + 123), 123); expectEqual(virtToPhys(offset + 123), 123);
expectEqual(@ptrToInt(virtToPhys(@intToPtr(*usize, offset + 123))), 123); expectEqual(@ptrToInt(virtToPhys(@intToPtr(*align(1) usize, offset + 123))), 123);
} }

284
src/kernel/multiboot.zig
View file

@ -1,4 +1,3 @@
// Autogenerated by zig translate-c
pub const multiboot_uint8_t = u8; pub const multiboot_uint8_t = u8;
pub const multiboot_uint16_t = c_ushort; pub const multiboot_uint16_t = c_ushort;
pub const multiboot_uint32_t = c_uint; pub const multiboot_uint32_t = c_uint;
@ -109,72 +108,75 @@ pub const struct_multiboot_apm_info = extern struct {
dseg_len: multiboot_uint16_t, dseg_len: multiboot_uint16_t,
}; };
pub const __GCC_ATOMIC_TEST_AND_SET_TRUEVAL = 1; pub const __GCC_ATOMIC_TEST_AND_SET_TRUEVAL = 1;
pub const __FLT16_MAX_EXP__ = 15;
pub const __BIGGEST_ALIGNMENT__ = 16; pub const __BIGGEST_ALIGNMENT__ = 16;
pub const __SIZEOF_FLOAT__ = 4; pub const __SIZEOF_FLOAT__ = 4;
pub const __INT64_FMTd__ = c"ld"; pub const __INT64_FMTd__ = "ld";
pub const __STDC_VERSION__ = c_long(201112); pub const __STDC_VERSION__ = @as(c_long, 201112);
pub const __INT_LEAST32_FMTi__ = c"i"; pub const __INT_LEAST32_FMTi__ = "i";
pub const __INT_LEAST8_FMTi__ = c"hhi"; pub const __tune_znver1__ = 1;
pub const __LDBL_EPSILON__ = -nan; pub const __INT_LEAST8_FMTi__ = "hhi";
pub const __LDBL_EPSILON__ = 0.000000;
pub const __LZCNT__ = 1; pub const __LZCNT__ = 1;
pub const __INT_LEAST32_FMTd__ = c"d"; pub const __INT_LEAST32_FMTd__ = "d";
pub const __STDC_UTF_32__ = 1; pub const __STDC_UTF_32__ = 1;
pub const __INVPCID__ = 1;
pub const __SIG_ATOMIC_WIDTH__ = 32; pub const __SIG_ATOMIC_WIDTH__ = 32;
pub const MULTIBOOT_MEMORY_BADRAM = 5; pub const MULTIBOOT_MEMORY_BADRAM = 5;
pub const __UINT_FAST64_FMTX__ = c"lX"; pub const __UINT_FAST64_FMTX__ = "lX";
pub const __GCC_ATOMIC_LLONG_LOCK_FREE = 2; pub const __GCC_ATOMIC_LLONG_LOCK_FREE = 2;
pub const __clang_version__ = c"8.0.0 (tags/RELEASE_800/rc5)"; pub const __SEG_FS = 1;
pub const __UINT_LEAST8_FMTo__ = c"hho"; pub const __clang_version__ = "9.0.0 (tags/RELEASE_900/final)";
pub const __UINT_LEAST8_FMTo__ = "hho";
pub const __GCC_ASM_FLAG_OUTPUTS__ = 1;
pub const __SIZEOF_DOUBLE__ = 8; pub const __SIZEOF_DOUBLE__ = 8;
pub const __INTMAX_FMTd__ = c"ld"; pub const __INTMAX_FMTd__ = "ld";
pub const __CLANG_ATOMIC_CHAR_LOCK_FREE = 2; pub const __CLANG_ATOMIC_CHAR_LOCK_FREE = 2;
pub const __INT_LEAST16_FMTi__ = c"hi"; pub const __INT_LEAST16_FMTi__ = "hi";
pub const __GCC_ATOMIC_SHORT_LOCK_FREE = 2; pub const __GCC_ATOMIC_SHORT_LOCK_FREE = 2;
pub const __FMA__ = 1; pub const __FMA__ = 1;
pub const __MMX__ = 1; pub const __MMX__ = 1;
pub const __GCC_HAVE_SYNC_COMPARE_AND_SWAP_16 = 1; pub const __GCC_HAVE_SYNC_COMPARE_AND_SWAP_16 = 1;
pub const __SIZE_FMTX__ = c"lX"; pub const __SIZE_FMTX__ = "lX";
pub const __RDSEED__ = 1;
pub const __WCHAR_WIDTH__ = 32; pub const __WCHAR_WIDTH__ = 32;
pub const __FSGSBASE__ = 1; pub const __FSGSBASE__ = 1;
pub const __PTRDIFF_FMTd__ = c"ld"; pub const __PTRDIFF_FMTd__ = "ld";
pub const __DBL_MIN_EXP__ = -1021; pub const __DBL_MIN_EXP__ = -1021;
pub const __FLT_EVAL_METHOD__ = 0; pub const __FLT_EVAL_METHOD__ = 0;
pub const __SSE_MATH__ = 1; pub const __SSE_MATH__ = 1;
pub const __UINT_FAST8_FMTo__ = c"hho"; pub const __UINT_FAST8_FMTo__ = "hho";
pub const __UINT_LEAST64_MAX__ = c_ulong(18446744073709551615); pub const __UINT_LEAST64_MAX__ = @as(c_ulong, 18446744073709551615);
pub const MULTIBOOT_INFO_BOOT_LOADER_NAME = 512; pub const MULTIBOOT_INFO_BOOT_LOADER_NAME = 512;
pub const __UINT_LEAST64_FMTx__ = c"lx"; pub const __UINT_LEAST64_FMTx__ = "lx";
pub const __INT8_MAX__ = 127; pub const __INT8_MAX__ = 127;
pub const __znver1 = 1;
pub const MULTIBOOT_MEMORY_AVAILABLE = 1; pub const MULTIBOOT_MEMORY_AVAILABLE = 1;
pub const __DBL_HAS_DENORM__ = 1; pub const __DBL_HAS_DENORM__ = 1;
pub const __FLOAT128__ = 1; pub const __FLOAT128__ = 1;
pub const __FLT16_HAS_QUIET_NAN__ = 1;
pub const __ATOMIC_RELAXED = 0; pub const __ATOMIC_RELAXED = 0;
pub const __DBL_DECIMAL_DIG__ = 17; pub const __DBL_DECIMAL_DIG__ = 17;
pub const __XSAVEC__ = 1;
pub const MULTIBOOT_SEARCH = 8192; pub const MULTIBOOT_SEARCH = 8192;
pub const __SIZEOF_SHORT__ = 2; pub const __SIZEOF_SHORT__ = 2;
pub const __UINT16_FMTX__ = c"hX";
pub const __UINT_FAST16_MAX__ = 65535; pub const __UINT_FAST16_MAX__ = 65535;
pub const __UINT16_FMTX__ = "hX";
pub const __CLANG_ATOMIC_SHORT_LOCK_FREE = 2; pub const __CLANG_ATOMIC_SHORT_LOCK_FREE = 2;
pub const __SSSE3__ = 1; pub const __SSSE3__ = 1;
pub const __CONSTANT_CFSTRINGS__ = 1; pub const __CONSTANT_CFSTRINGS__ = 1;
pub const __AVX2__ = 1; pub const __AVX2__ = 1;
pub const __LDBL_MAX_EXP__ = 16384; pub const __LDBL_MAX_EXP__ = 16384;
pub const __WINT_MAX__ = c_uint(4294967295); pub const __WINT_MAX__ = @as(c_uint, 4294967295);
pub const __NO_MATH_INLINES = 1; pub const __NO_MATH_INLINES = 1;
pub const __WCHAR_TYPE__ = int; pub const __WCHAR_TYPE__ = int;
pub const __LONG_MAX__ = c_long(9223372036854775807); pub const __LONG_MAX__ = @as(c_long, 9223372036854775807);
pub const __STDC_HOSTED__ = 1; pub const __STDC_HOSTED__ = 1;
pub const MULTIBOOT_FRAMEBUFFER_TYPE_EGA_TEXT = 2; pub const MULTIBOOT_FRAMEBUFFER_TYPE_EGA_TEXT = 2;
pub const __INT_FAST16_FMTi__ = c"hi";
pub const __PTRDIFF_WIDTH__ = 64; pub const __PTRDIFF_WIDTH__ = 64;
pub const __INT_FAST16_FMTi__ = "hi";
pub const __INT_LEAST32_TYPE__ = int; pub const __INT_LEAST32_TYPE__ = int;
pub const __SCHAR_MAX__ = 127; pub const __SCHAR_MAX__ = 127;
pub const __LDBL_DENORM_MIN__ = -nan; pub const __LDBL_DENORM_MIN__ = 0.000000;
pub const __FLT16_MIN_EXP__ = -14;
pub const MULTIBOOT_INFO_AOUT_SYMS = 16; pub const MULTIBOOT_INFO_AOUT_SYMS = 16;
pub const __PRFCHW__ = 1;
pub const __INT64_C_SUFFIX__ = L; pub const __INT64_C_SUFFIX__ = L;
pub const __ELF__ = 1; pub const __ELF__ = 1;
pub const __LDBL_MANT_DIG__ = 64; pub const __LDBL_MANT_DIG__ = 64;
@ -183,40 +185,40 @@ pub const MULTIBOOT_INFO_CONFIG_TABLE = 256;
pub const __CLANG_ATOMIC_INT_LOCK_FREE = 2; pub const __CLANG_ATOMIC_INT_LOCK_FREE = 2;
pub const __SIZEOF_PTRDIFF_T__ = 8; pub const __SIZEOF_PTRDIFF_T__ = 8;
pub const __SIG_ATOMIC_MAX__ = 2147483647; pub const __SIG_ATOMIC_MAX__ = 2147483647;
pub const __UINT64_FMTX__ = c"lX"; pub const __UINT64_FMTX__ = "lX";
pub const __UINT64_MAX__ = c_ulong(18446744073709551615); pub const __UINT64_MAX__ = @as(c_ulong, 18446744073709551615);
pub const __DBL_MANT_DIG__ = 53; pub const __DBL_MANT_DIG__ = 53;
pub const __FLT_DECIMAL_DIG__ = 9; pub const __FLT_DECIMAL_DIG__ = 9;
pub const __INT_LEAST32_MAX__ = 2147483647; pub const __INT_LEAST32_MAX__ = 2147483647;
pub const __DBL_DIG__ = 15; pub const __DBL_DIG__ = 15;
pub const __ATOMIC_ACQUIRE = 2; pub const __ATOMIC_ACQUIRE = 2;
pub const __OPENCL_MEMORY_SCOPE_WORK_GROUP = 1; pub const __OPENCL_MEMORY_SCOPE_WORK_GROUP = 1;
pub const __FLT16_HAS_DENORM__ = 1; pub const __UINT_FAST16_FMTu__ = "hu";
pub const __UINT_FAST16_FMTu__ = c"hu"; pub const __INTPTR_FMTi__ = "li";
pub const __INTPTR_FMTi__ = c"li";
pub const MULTIBOOT_INFO_MODS = 8; pub const MULTIBOOT_INFO_MODS = 8;
pub const __UINT_FAST8_FMTX__ = c"hhX"; pub const __UINT_FAST8_FMTX__ = "hhX";
pub const __LITTLE_ENDIAN__ = 1; pub const __LITTLE_ENDIAN__ = 1;
pub const __SSE__ = 1; pub const __SSE__ = 1;
pub const __FLT_HAS_QUIET_NAN__ = 1; pub const __FLT_HAS_QUIET_NAN__ = 1;
pub const __SIZEOF_SIZE_T__ = 8; pub const __SIZEOF_SIZE_T__ = 8;
pub const __UINT_LEAST16_FMTo__ = c"ho"; pub const __SEG_GS = 1;
pub const __UINT8_FMTo__ = c"hho"; pub const __UINT_LEAST16_FMTo__ = "ho";
pub const __UINT_LEAST16_FMTx__ = c"hx"; pub const __UINT8_FMTo__ = "hho";
pub const __UINT_LEAST16_FMTx__ = "hx";
pub const __CLANG_ATOMIC_WCHAR_T_LOCK_FREE = 2; pub const __CLANG_ATOMIC_WCHAR_T_LOCK_FREE = 2;
pub const __UINT_FAST16_FMTX__ = c"hX"; pub const __UINT_FAST16_FMTX__ = "hX";
pub const __VERSION__ = c"4.2.1 Compatible Clang 8.0.0 (tags/RELEASE_800/rc5)"; pub const __VERSION__ = "Clang 9.0.0 (tags/RELEASE_900/final)";
pub const __UINT_FAST32_FMTx__ = c"x"; pub const __UINT_FAST32_FMTx__ = "x";
pub const __UINTPTR_MAX__ = c_ulong(18446744073709551615); pub const __UINTPTR_MAX__ = @as(c_ulong, 18446744073709551615);
pub const MULTIBOOT_INFO_ALIGN = 4; pub const MULTIBOOT_INFO_ALIGN = 4;
pub const __UINT_FAST8_FMTu__ = c"hhu"; pub const __UINT_FAST8_FMTu__ = "hhu";
pub const __UINT_LEAST8_FMTu__ = c"hhu"; pub const __UINT_LEAST8_FMTu__ = "hhu";
pub const __UINT_LEAST64_FMTo__ = c"lo"; pub const __UINT_LEAST64_FMTo__ = "lo";
pub const __UINT_LEAST8_MAX__ = 255; pub const __UINT_LEAST8_MAX__ = 255;
pub const __RDRND__ = 1; pub const __RDRND__ = 1;
pub const __SIZEOF_WCHAR_T__ = 4; pub const __SIZEOF_WCHAR_T__ = 4;
pub const __MOVBE__ = 1; pub const __MOVBE__ = 1;
pub const __LDBL_MAX__ = -nan; pub const __LDBL_MAX__ = inf;
pub const __UINT16_MAX__ = 65535; pub const __UINT16_MAX__ = 65535;
pub const _LP64 = 1; pub const _LP64 = 1;
pub const __x86_64 = 1; pub const __x86_64 = 1;
@ -224,168 +226,165 @@ pub const __code_model_small_ = 1;
pub const linux = 1; pub const linux = 1;
pub const __SIZEOF_WINT_T__ = 4; pub const __SIZEOF_WINT_T__ = 4;
pub const MULTIBOOT_INFO_CMDLINE = 4; pub const MULTIBOOT_INFO_CMDLINE = 4;
pub const __UINTMAX_FMTo__ = c"lo"; pub const __UINTMAX_FMTo__ = "lo";
pub const __FLT_DIG__ = 6; pub const __FLT_DIG__ = 6;
pub const __UINT_LEAST8_FMTX__ = c"hhX"; pub const __UINT_LEAST8_FMTX__ = "hhX";
pub const __INT16_MAX__ = 32767; pub const __INT16_MAX__ = 32767;
pub const __WINT_UNSIGNED__ = 1; pub const __WINT_UNSIGNED__ = 1;
pub const __FLT_MAX_10_EXP__ = 38; pub const __FLT_MAX_10_EXP__ = 38;
pub const __UINTPTR_FMTX__ = c"lX"; pub const __UINTPTR_FMTX__ = "lX";
pub const __UINT_LEAST16_FMTu__ = c"hu"; pub const __UINT_LEAST16_FMTu__ = "hu";
pub const __CLANG_ATOMIC_POINTER_LOCK_FREE = 2; pub const __CLANG_ATOMIC_POINTER_LOCK_FREE = 2;
pub const __WINT_WIDTH__ = 32; pub const __WINT_WIDTH__ = 32;
pub const __F16C__ = 1; pub const __F16C__ = 1;
pub const __SHRT_MAX__ = 32767; pub const __SHRT_MAX__ = 32767;
pub const __znver1__ = 1;
pub const __GCC_ATOMIC_BOOL_LOCK_FREE = 2; pub const __GCC_ATOMIC_BOOL_LOCK_FREE = 2;
pub const __POINTER_WIDTH__ = 64; pub const __POINTER_WIDTH__ = 64;
pub const __PTRDIFF_MAX__ = c_long(9223372036854775807); pub const __PTRDIFF_MAX__ = @as(c_long, 9223372036854775807);
pub const __tune_corei7__ = 1; pub const __INT32_FMTd__ = "d";
pub const __FLT16_DIG__ = 3; pub const __DBL_MIN__ = 0.000000;
pub const __INT32_FMTd__ = c"d";
pub const __DBL_MIN__ = -nan;
pub const __SIZEOF_LONG__ = 8; pub const __SIZEOF_LONG__ = 8;
pub const __INTPTR_WIDTH__ = 64; pub const __INTPTR_WIDTH__ = 64;
pub const MULTIBOOT_INFO_VBE_INFO = 2048; pub const MULTIBOOT_INFO_VBE_INFO = 2048;
pub const __FLT16_MAX_10_EXP__ = 4;
pub const __INT_FAST32_TYPE__ = int; pub const __INT_FAST32_TYPE__ = int;
pub const __NO_INLINE__ = 1; pub const __NO_INLINE__ = 1;
pub const __UINT_FAST32_FMTX__ = c"X"; pub const __UINT_FAST32_FMTX__ = "X";
pub const MULTIBOOT_AOUT_KLUDGE = 65536; pub const MULTIBOOT_AOUT_KLUDGE = 65536;
pub const __gnu_linux__ = 1; pub const __gnu_linux__ = 1;
pub const __INT_FAST32_MAX__ = 2147483647; pub const __INT_FAST32_MAX__ = 2147483647;
pub const __corei7__ = 1; pub const __UINTMAX_FMTu__ = "lu";
pub const __UINTMAX_FMTu__ = c"lu";
pub const MULTIBOOT_FRAMEBUFFER_TYPE_INDEXED = 0; pub const MULTIBOOT_FRAMEBUFFER_TYPE_INDEXED = 0;
pub const __BMI__ = 1; pub const __BMI__ = 1;
pub const MULTIBOOT_INFO_BOOTDEV = 2; pub const MULTIBOOT_INFO_BOOTDEV = 2;
pub const __FLT_RADIX__ = 2; pub const __FLT_RADIX__ = 2;
pub const MULTIBOOT_INFO_MEMORY = 1; pub const MULTIBOOT_INFO_MEMORY = 1;
pub const __FLT16_HAS_INFINITY__ = 1;
pub const __GCC_HAVE_SYNC_COMPARE_AND_SWAP_1 = 1; pub const __GCC_HAVE_SYNC_COMPARE_AND_SWAP_1 = 1;
pub const MULTIBOOT_FRAMEBUFFER_TYPE_RGB = 1; pub const MULTIBOOT_FRAMEBUFFER_TYPE_RGB = 1;
pub const __GCC_ATOMIC_INT_LOCK_FREE = 2; pub const __GCC_ATOMIC_INT_LOCK_FREE = 2;
pub const __OPENCL_MEMORY_SCOPE_ALL_SVM_DEVICES = 3; pub const __OPENCL_MEMORY_SCOPE_ALL_SVM_DEVICES = 3;
pub const __FLT16_DECIMAL_DIG__ = 5;
pub const __PRAGMA_REDEFINE_EXTNAME = 1; pub const __PRAGMA_REDEFINE_EXTNAME = 1;
pub const __INT_FAST8_FMTd__ = c"hhd"; pub const __INT_FAST8_FMTd__ = "hhd";
pub const __INT32_TYPE__ = int; pub const __INT32_TYPE__ = int;
pub const MULTIBOOT_BOOTLOADER_MAGIC = 732803074; pub const MULTIBOOT_BOOTLOADER_MAGIC = 732803074;
pub const __UINTMAX_WIDTH__ = 64; pub const __UINTMAX_WIDTH__ = 64;
pub const __FLT_MIN__ = -nan; pub const __FLT_MIN__ = 0.000000;
pub const __INT64_FMTi__ = c"li"; pub const __INT64_FMTi__ = "li";
pub const __UINT_FAST64_FMTu__ = c"lu"; pub const __UINT_FAST64_FMTu__ = "lu";
pub const __INT8_FMTd__ = c"hhd"; pub const __INT8_FMTd__ = "hhd";
pub const __INT_FAST16_TYPE__ = short; pub const __INT_FAST16_TYPE__ = short;
pub const __FLT_MAX_EXP__ = 128; pub const __FLT_MAX_EXP__ = 128;
pub const __XSAVE__ = 1; pub const __XSAVE__ = 1;
pub const __DBL_MAX_10_EXP__ = 308; pub const __DBL_MAX_10_EXP__ = 308;
pub const __LDBL_MIN__ = -nan; pub const __LDBL_MIN__ = 0.000000;
pub const __INT_FAST64_FMTi__ = c"li"; pub const __INT_FAST64_FMTi__ = "li";
pub const __INT_LEAST8_FMTd__ = c"hhd"; pub const __INT_LEAST8_FMTd__ = "hhd";
pub const __CLANG_ATOMIC_LLONG_LOCK_FREE = 2; pub const __CLANG_ATOMIC_LLONG_LOCK_FREE = 2;
pub const __UINT_LEAST32_FMTX__ = c"X"; pub const __UINT_LEAST32_FMTX__ = "X";
pub const __UINTMAX_MAX__ = c_ulong(18446744073709551615); pub const __UINTMAX_MAX__ = @as(c_ulong, 18446744073709551615);
pub const __UINT_FAST16_FMTo__ = c"ho"; pub const __UINT_FAST16_FMTo__ = "ho";
pub const __LDBL_DECIMAL_DIG__ = 21; pub const __LDBL_DECIMAL_DIG__ = 21;
pub const __UINT_LEAST64_FMTX__ = c"lX"; pub const __UINT_LEAST64_FMTX__ = "lX";
pub const __clang_minor__ = 0; pub const __clang_minor__ = 0;
pub const __SIZEOF_FLOAT128__ = 16; pub const __SIZEOF_FLOAT128__ = 16;
pub const __UINT_FAST64_FMTo__ = c"lo"; pub const __UINT_FAST64_FMTo__ = "lo";
pub const __SIZE_FMTx__ = c"lx"; pub const __SIZE_FMTx__ = "lx";
pub const __DBL_MAX__ = -nan; pub const __DBL_MAX__ = 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878;
pub const __DBL_EPSILON__ = -nan; pub const __DBL_EPSILON__ = 0.000000;
pub const __UINT64_FMTx__ = c"lx"; pub const __UINT64_FMTx__ = "lx";
pub const MULTIBOOT_HEADER = 1; pub const MULTIBOOT_HEADER = 1;
pub const __CLWB__ = 1;
pub const __CHAR_BIT__ = 8; pub const __CHAR_BIT__ = 8;
pub const __INT16_FMTi__ = c"hi"; pub const __INT16_FMTi__ = "hi";
pub const _DEBUG = 1; pub const _DEBUG = 1;
pub const __GNUC_MINOR__ = 2; pub const __GNUC_MINOR__ = 2;
pub const __UINT_FAST32_MAX__ = c_uint(4294967295); pub const __UINT_FAST32_MAX__ = @as(c_uint, 4294967295);
pub const __UINT8_FMTX__ = c"hhX"; pub const __UINT8_FMTX__ = "hhX";
pub const __FLT_EPSILON__ = -nan; pub const __FLT_EPSILON__ = 0.000000;
pub const __UINTPTR_WIDTH__ = 64; pub const __UINTPTR_WIDTH__ = 64;
pub const __llvm__ = 1; pub const __llvm__ = 1;
pub const __UINT_FAST64_MAX__ = c_ulong(18446744073709551615); pub const __UINT_FAST64_MAX__ = @as(c_ulong, 18446744073709551615);
pub const __INT_FAST32_FMTi__ = c"i"; pub const __INT_FAST32_FMTi__ = "i";
pub const __FLT_HAS_INFINITY__ = 1; pub const __FLT_HAS_INFINITY__ = 1;
pub const __AES__ = 1; pub const __AES__ = 1;
pub const __UINT8_FMTx__ = c"hhx"; pub const __UINT8_FMTx__ = "hhx";
pub const __INTMAX_C_SUFFIX__ = L; pub const __INTMAX_C_SUFFIX__ = L;
pub const __ORDER_LITTLE_ENDIAN__ = 1234; pub const __ORDER_LITTLE_ENDIAN__ = 1234;
pub const __GCC_ATOMIC_CHAR16_T_LOCK_FREE = 2; pub const __GCC_ATOMIC_CHAR16_T_LOCK_FREE = 2;
pub const __INT16_FMTd__ = c"hd"; pub const __INT16_FMTd__ = "hd";
pub const __UINT32_FMTX__ = c"X"; pub const __UINT32_FMTX__ = "X";
pub const __GCC_HAVE_SYNC_COMPARE_AND_SWAP_4 = 1; pub const __GCC_HAVE_SYNC_COMPARE_AND_SWAP_4 = 1;
pub const __UINT32_C_SUFFIX__ = U; pub const __UINT32_C_SUFFIX__ = U;
pub const __INT32_MAX__ = 2147483647; pub const __INT32_MAX__ = 2147483647;
pub const __GCC_ATOMIC_CHAR_LOCK_FREE = 2; pub const __GCC_ATOMIC_CHAR_LOCK_FREE = 2;
pub const __INTMAX_WIDTH__ = 64; pub const __INTMAX_WIDTH__ = 64;
pub const __CLANG_ATOMIC_BOOL_LOCK_FREE = 2; pub const __CLANG_ATOMIC_BOOL_LOCK_FREE = 2;
pub const __SIZE_FMTo__ = c"lo"; pub const __SIZE_FMTo__ = "lo";
pub const __DBL_HAS_QUIET_NAN__ = 1; pub const __DBL_HAS_QUIET_NAN__ = 1;
pub const __INT_FAST8_FMTi__ = c"hhi"; pub const __INT_FAST8_FMTi__ = "hhi";
pub const __UINT_LEAST32_FMTo__ = c"o"; pub const __UINT_LEAST32_FMTo__ = "o";
pub const __STDC_UTF_16__ = 1; pub const __STDC_UTF_16__ = 1;
pub const __UINT_LEAST32_MAX__ = c_uint(4294967295); pub const __UINT_LEAST32_MAX__ = @as(c_uint, 4294967295);
pub const __ATOMIC_RELEASE = 3; pub const __ATOMIC_RELEASE = 3;
pub const __UINT_FAST16_FMTx__ = c"hx"; pub const __UINT_FAST16_FMTx__ = "hx";
pub const __UINTMAX_C_SUFFIX__ = UL; pub const __UINTMAX_C_SUFFIX__ = UL;
pub const __FLT_MIN_EXP__ = -125; pub const __FLT_MIN_EXP__ = -125;
pub const __SIZEOF_LONG_DOUBLE__ = 16; pub const __SIZEOF_LONG_DOUBLE__ = 16;
pub const __UINT_LEAST64_FMTu__ = c"lu"; pub const __UINT_LEAST64_FMTu__ = "lu";
pub const MULTIBOOT_MOD_ALIGN = 4096; pub const MULTIBOOT_MOD_ALIGN = 4096;
pub const __GCC_ATOMIC_LONG_LOCK_FREE = 2; pub const __GCC_ATOMIC_LONG_LOCK_FREE = 2;
pub const __ORDER_PDP_ENDIAN__ = 3412; pub const __ORDER_PDP_ENDIAN__ = 3412;
pub const MULTIBOOT_PAGE_ALIGN = 1; pub const MULTIBOOT_PAGE_ALIGN = 1;
pub const __INT_FAST64_FMTd__ = c"ld"; pub const __INT_FAST64_FMTd__ = "ld";
pub const __CLANG_ATOMIC_LONG_LOCK_FREE = 2; pub const __CLANG_ATOMIC_LONG_LOCK_FREE = 2;
pub const __GXX_ABI_VERSION = 1002; pub const __GXX_ABI_VERSION = 1002;
pub const __INT16_TYPE__ = short; pub const __INT16_TYPE__ = short;
pub const __MWAITX__ = 1;
pub const __SSE2_MATH__ = 1; pub const __SSE2_MATH__ = 1;
pub const __FLT_MANT_DIG__ = 24; pub const __FLT_MANT_DIG__ = 24;
pub const __UINT_FAST64_FMTx__ = c"lx"; pub const __UINT_FAST64_FMTx__ = "lx";
pub const __STDC__ = 1; pub const __STDC__ = 1;
pub const __INT_FAST8_MAX__ = 127; pub const __INT_FAST8_MAX__ = 127;
pub const __INTPTR_FMTd__ = c"ld"; pub const __INTPTR_FMTd__ = "ld";
pub const __GNUC_PATCHLEVEL__ = 1; pub const __GNUC_PATCHLEVEL__ = 1;
pub const __UINT_LEAST8_FMTx__ = c"hhx"; pub const __UINT_LEAST8_FMTx__ = "hhx";
pub const __SIZE_WIDTH__ = 64; pub const __SIZE_WIDTH__ = 64;
pub const __INT_LEAST64_FMTi__ = c"li"; pub const __INT_LEAST64_FMTi__ = "li";
pub const __SSE4_2__ = 1; pub const __SSE4_2__ = 1;
pub const __AVX__ = 1; pub const __AVX__ = 1;
pub const __INT_FAST16_MAX__ = 32767; pub const __INT_FAST16_MAX__ = 32767;
pub const __INTPTR_MAX__ = c_long(9223372036854775807); pub const __INTPTR_MAX__ = @as(c_long, 9223372036854775807);
pub const __CLANG_ATOMIC_CHAR16_T_LOCK_FREE = 2; pub const __CLANG_ATOMIC_CHAR16_T_LOCK_FREE = 2;
pub const __UINT64_FMTu__ = c"lu"; pub const __UINT64_FMTu__ = "lu";
pub const __BYTE_ORDER__ = __ORDER_LITTLE_ENDIAN__; pub const __BYTE_ORDER__ = __ORDER_LITTLE_ENDIAN__;
pub const __SSE2__ = 1; pub const __SSE2__ = 1;
pub const MULTIBOOT_INFO_FRAMEBUFFER_INFO = 4096; pub const MULTIBOOT_INFO_FRAMEBUFFER_INFO = 4096;
pub const __INT_MAX__ = 2147483647; pub const __INT_MAX__ = 2147483647;
pub const __INTMAX_FMTi__ = c"li"; pub const __INTMAX_FMTi__ = "li";
pub const __DBL_DENORM_MIN__ = -nan; pub const __DBL_DENORM_MIN__ = 0.000000;
pub const MULTIBOOT_INFO_APM_TABLE = 1024; pub const MULTIBOOT_INFO_APM_TABLE = 1024;
pub const __clang_major__ = 8; pub const __clang_major__ = 9;
pub const __FLT16_MANT_DIG__ = 11;
pub const __GNUC__ = 4; pub const __GNUC__ = 4;
pub const __UINT32_MAX__ = c_uint(4294967295); pub const __UINT32_MAX__ = @as(c_uint, 4294967295);
pub const MULTIBOOT_MEMORY_RESERVED = 2; pub const MULTIBOOT_MEMORY_RESERVED = 2;
pub const __FLT_DENORM_MIN__ = -nan; pub const __FLT_DENORM_MIN__ = 0.000000;
pub const __DBL_MAX_EXP__ = 1024; pub const __DBL_MAX_EXP__ = 1024;
pub const __INT8_FMTi__ = c"hhi"; pub const __INT8_FMTi__ = "hhi";
pub const __UINT_LEAST16_MAX__ = 65535; pub const __UINT_LEAST16_MAX__ = 65535;
pub const __XSAVES__ = 1;
pub const __LDBL_HAS_DENORM__ = 1; pub const __LDBL_HAS_DENORM__ = 1;
pub const __FLT16_MIN_10_EXP__ = -13;
pub const __LDBL_HAS_QUIET_NAN__ = 1; pub const __LDBL_HAS_QUIET_NAN__ = 1;
pub const __UINT_FAST8_MAX__ = 255; pub const __UINT_FAST8_MAX__ = 255;
pub const __DBL_MIN_10_EXP__ = -307; pub const __DBL_MIN_10_EXP__ = -307;
pub const __UINT8_FMTu__ = c"hhu"; pub const __UINT8_FMTu__ = "hhu";
pub const __INT_FAST64_MAX__ = c_long(9223372036854775807); pub const __SSE4A__ = 1;
pub const __INT_FAST64_MAX__ = @as(c_long, 9223372036854775807);
pub const __SSE3__ = 1; pub const __SSE3__ = 1;
pub const __UINT16_FMTu__ = c"hu"; pub const __UINT16_FMTu__ = "hu";
pub const __ATOMIC_SEQ_CST = 5; pub const __ATOMIC_SEQ_CST = 5;
pub const __SIZE_FMTu__ = c"lu"; pub const __SIZE_FMTu__ = "lu";
pub const __LDBL_MIN_EXP__ = -16381; pub const __LDBL_MIN_EXP__ = -16381;
pub const __UINT_FAST32_FMTu__ = c"u"; pub const __UINT_FAST32_FMTu__ = "u";
pub const __clang_patchlevel__ = 0; pub const __clang_patchlevel__ = 0;
pub const __SIZEOF_LONG_LONG__ = 8; pub const __SIZEOF_LONG_LONG__ = 8;
pub const __BMI2__ = 1; pub const __BMI2__ = 1;
@ -395,35 +394,34 @@ pub const __PCLMUL__ = 1;
pub const __FXSR__ = 1; pub const __FXSR__ = 1;
pub const __UINT8_MAX__ = 255; pub const __UINT8_MAX__ = 255;
pub const __GCC_HAVE_SYNC_COMPARE_AND_SWAP_2 = 1; pub const __GCC_HAVE_SYNC_COMPARE_AND_SWAP_2 = 1;
pub const __UINT32_FMTx__ = c"x"; pub const __UINT32_FMTx__ = "x";
pub const __UINT16_FMTo__ = c"ho"; pub const __UINT16_FMTo__ = "ho";
pub const __POPCNT__ = 1; pub const __POPCNT__ = 1;
pub const __OPENCL_MEMORY_SCOPE_DEVICE = 2; pub const __OPENCL_MEMORY_SCOPE_DEVICE = 2;
pub const MULTIBOOT_VIDEO_MODE = 4; pub const MULTIBOOT_VIDEO_MODE = 4;
pub const __UINT32_FMTu__ = c"u"; pub const __UINT32_FMTu__ = "u";
pub const __SIZEOF_POINTER__ = 8; pub const __SIZEOF_POINTER__ = 8;
pub const __SIZE_MAX__ = c_ulong(18446744073709551615); pub const __SIZE_MAX__ = @as(c_ulong, 18446744073709551615);
pub const __unix = 1; pub const __unix = 1;
pub const __INT_FAST16_FMTd__ = c"hd"; pub const __INT_FAST16_FMTd__ = "hd";
pub const unix = 1; pub const unix = 1;
pub const __UINT_LEAST32_FMTu__ = c"u"; pub const __UINT_LEAST32_FMTu__ = "u";
pub const __FLT_MAX__ = -nan; pub const __FLT_MAX__ = 340282346999999984391321947108527833088.000000;
pub const __corei7 = 1;
pub const __GCC_ATOMIC_WCHAR_T_LOCK_FREE = 2; pub const __GCC_ATOMIC_WCHAR_T_LOCK_FREE = 2;
pub const __ATOMIC_CONSUME = 1; pub const __ATOMIC_CONSUME = 1;
pub const __unix__ = 1; pub const __unix__ = 1;
pub const __x86_64__ = 1; pub const __x86_64__ = 1;
pub const __LDBL_HAS_INFINITY__ = 1; pub const __LDBL_HAS_INFINITY__ = 1;
pub const __UINTMAX_FMTx__ = c"lx"; pub const __UINTMAX_FMTx__ = "lx";
pub const __UINT64_C_SUFFIX__ = UL; pub const __UINT64_C_SUFFIX__ = UL;
pub const __INT_LEAST16_MAX__ = 32767;
pub const __FLT_MIN_10_EXP__ = -37; pub const __FLT_MIN_10_EXP__ = -37;
pub const __UINT32_FMTo__ = c"o"; pub const __INT_LEAST16_MAX__ = 32767;
pub const __UINTPTR_FMTo__ = c"lo"; pub const __UINT32_FMTo__ = "o";
pub const __INT_LEAST16_FMTd__ = c"hd"; pub const __UINTPTR_FMTo__ = "lo";
pub const __UINTPTR_FMTx__ = c"lx"; pub const __INT_LEAST16_FMTd__ = "hd";
pub const __UINTPTR_FMTx__ = "lx";
pub const __GCC_HAVE_SYNC_COMPARE_AND_SWAP_8 = 1; pub const __GCC_HAVE_SYNC_COMPARE_AND_SWAP_8 = 1;
pub const __INT_LEAST64_FMTd__ = c"ld"; pub const __INT_LEAST64_FMTd__ = "ld";
pub const __INT_LEAST16_TYPE__ = short; pub const __INT_LEAST16_TYPE__ = short;
pub const MULTIBOOT_HEADER_MAGIC = 464367618; pub const MULTIBOOT_HEADER_MAGIC = 464367618;
pub const __ORDER_BIG_ENDIAN__ = 4321; pub const __ORDER_BIG_ENDIAN__ = 4321;
@ -432,45 +430,51 @@ pub const __INT_LEAST8_MAX__ = 127;
pub const __SIZEOF_INT__ = 4; pub const __SIZEOF_INT__ = 4;
pub const __GCC_ATOMIC_POINTER_LOCK_FREE = 2; pub const __GCC_ATOMIC_POINTER_LOCK_FREE = 2;
pub const MULTIBOOT_INFO_DRIVE_INFO = 128; pub const MULTIBOOT_INFO_DRIVE_INFO = 128;
pub const __SHA__ = 1;
pub const MULTIBOOT_MEMORY_INFO = 2; pub const MULTIBOOT_MEMORY_INFO = 2;
pub const __amd64 = 1; pub const __amd64 = 1;
pub const __OBJC_BOOL_IS_BOOL = 0; pub const __OBJC_BOOL_IS_BOOL = 0;
pub const __ADX__ = 1;
pub const __LDBL_MAX_10_EXP__ = 4932; pub const __LDBL_MAX_10_EXP__ = 4932;
pub const __SIZEOF_INT128__ = 16; pub const __SIZEOF_INT128__ = 16;
pub const __UINT_FAST8_FMTx__ = c"hhx"; pub const __UINT_FAST8_FMTx__ = "hhx";
pub const __CLZERO__ = 1;
pub const __linux = 1; pub const __linux = 1;
pub const __UINT16_FMTx__ = c"hx"; pub const __UINT16_FMTx__ = "hx";
pub const __UINTPTR_FMTu__ = c"lu"; pub const __UINTPTR_FMTu__ = "lu";
pub const __UINT_LEAST16_FMTX__ = c"hX"; pub const __UINT_LEAST16_FMTX__ = "hX";
pub const __CLFLUSHOPT__ = 1;
pub const __amd64__ = 1; pub const __amd64__ = 1;
pub const __UINT_FAST32_FMTo__ = c"o"; pub const __UINT_FAST32_FMTo__ = "o";
pub const __linux__ = 1; pub const __linux__ = 1;
pub const __clang__ = 1; pub const __clang__ = 1;
pub const __LP64__ = 1; pub const __LP64__ = 1;
pub const __PTRDIFF_FMTi__ = c"li"; pub const __PTRDIFF_FMTi__ = "li";
pub const __WBNOINVD__ = 1;
pub const __SSE4_1__ = 1; pub const __SSE4_1__ = 1;
pub const __LDBL_DIG__ = 18; pub const __LDBL_DIG__ = 18;
pub const __GCC_ATOMIC_CHAR32_T_LOCK_FREE = 2; pub const __GCC_ATOMIC_CHAR32_T_LOCK_FREE = 2;
pub const __XSAVEOPT__ = 1; pub const __XSAVEOPT__ = 1;
pub const __UINT64_FMTo__ = c"lo"; pub const __UINT64_FMTo__ = "lo";
pub const __INT_FAST32_FMTd__ = c"d"; pub const __INT_FAST32_FMTd__ = "d";
pub const __ATOMIC_ACQ_REL = 4; pub const __ATOMIC_ACQ_REL = 4;
pub const MULTIBOOT_MEMORY_ACPI_RECLAIMABLE = 3; pub const MULTIBOOT_MEMORY_ACPI_RECLAIMABLE = 3;
pub const __LONG_LONG_MAX__ = c_longlong(9223372036854775807); pub const __LONG_LONG_MAX__ = @as(c_longlong, 9223372036854775807);
pub const __OPENCL_MEMORY_SCOPE_SUB_GROUP = 4; pub const __OPENCL_MEMORY_SCOPE_SUB_GROUP = 4;
pub const MULTIBOOT_MEMORY_NVS = 4; pub const MULTIBOOT_MEMORY_NVS = 4;
pub const __RDPID__ = 1;
pub const MULTIBOOT_INFO_MEM_MAP = 64; pub const MULTIBOOT_INFO_MEM_MAP = 64;
pub const __INTMAX_MAX__ = c_long(9223372036854775807); pub const __INTMAX_MAX__ = @as(c_long, 9223372036854775807);
pub const __UINT_LEAST32_FMTx__ = c"x"; pub const __UINT_LEAST32_FMTx__ = "x";
pub const __WCHAR_MAX__ = 2147483647; pub const __WCHAR_MAX__ = 2147483647;
pub const __INT64_MAX__ = c_long(9223372036854775807); pub const __INT64_MAX__ = @as(c_long, 9223372036854775807);
pub const __CLANG_ATOMIC_CHAR32_T_LOCK_FREE = 2; pub const __CLANG_ATOMIC_CHAR32_T_LOCK_FREE = 2;
pub const __INT_LEAST64_MAX__ = c_long(9223372036854775807); pub const __INT_LEAST64_MAX__ = @as(c_long, 9223372036854775807);
pub const __UINTMAX_FMTX__ = c"lX"; pub const __UINTMAX_FMTX__ = "lX";
pub const __OPENCL_MEMORY_SCOPE_WORK_ITEM = 0; pub const __OPENCL_MEMORY_SCOPE_WORK_ITEM = 0;
pub const __FLT_HAS_DENORM__ = 1; pub const __FLT_HAS_DENORM__ = 1;
pub const __DECIMAL_DIG__ = __LDBL_DECIMAL_DIG__; pub const __DECIMAL_DIG__ = __LDBL_DECIMAL_DIG__;
pub const __INT32_FMTi__ = c"i"; pub const __INT32_FMTi__ = "i";
pub const __DBL_HAS_INFINITY__ = 1; pub const __DBL_HAS_INFINITY__ = 1;
pub const __FINITE_MATH_ONLY__ = 0; pub const __FINITE_MATH_ONLY__ = 0;
pub const multiboot_header = struct_multiboot_header; pub const multiboot_header = struct_multiboot_header;

15
src/kernel/panic.zig
View file

@ -77,12 +77,11 @@ const SymbolMap = struct {
/// The function name associated with that program address, or null if one wasn't found. /// The function name associated with that program address, or null if one wasn't found.
/// ///
pub fn search(self: *const SymbolMap, addr: usize) ?[]const u8 { pub fn search(self: *const SymbolMap, addr: usize) ?[]const u8 {
if (self.symbols.count() == 0) if (self.symbols.len == 0)
return null; return null;
// Find the first element whose address is greater than addr // Find the first element whose address is greater than addr
var previous_name: ?[]const u8 = null; var previous_name: ?[]const u8 = null;
var it = self.symbols.iterator(); for (self.symbols.toSliceConst()) |entry| {
while (it.next()) |entry| {
if (entry.addr > addr) if (entry.addr > addr)
return previous_name; return previous_name;
previous_name = entry.func_name; previous_name = entry.func_name;
@ -102,10 +101,10 @@ var symbol_map: ?SymbolMap = null;
/// ///
fn logTraceAddress(addr: usize) void { fn logTraceAddress(addr: usize) void {
const str = if (symbol_map) |syms| syms.search(addr) orelse "?????" else "(no symbols available)"; const str = if (symbol_map) |syms| syms.search(addr) orelse "?????" else "(no symbols available)";
log.logError("{x}: {}\n", addr, str); log.logError("{x}: {}\n", .{ addr, str });
} }
pub fn panic(trace: ?*builtin.StackTrace, comptime format: []const u8, args: ...) noreturn { pub fn panic(trace: ?*builtin.StackTrace, comptime format: []const u8, args: var) noreturn {
@setCold(true); @setCold(true);
log.logError("Kernel panic: " ++ format ++ "\n", args); log.logError("Kernel panic: " ++ format ++ "\n", args);
if (trace) |trc| { if (trace) |trc| {
@ -278,8 +277,8 @@ fn parseMapEntry(start: *[*]const u8, end: *const u8) !MapEntry {
/// std.fmt.ParseUnsignedError: See parseMapEntry. /// std.fmt.ParseUnsignedError: See parseMapEntry.
/// ///
pub fn init(mem_profile: *const mem.MemProfile, allocator: *std.mem.Allocator) !void { pub fn init(mem_profile: *const mem.MemProfile, allocator: *std.mem.Allocator) !void {
log.logInfo("Init panic\n"); log.logInfo("Init panic\n", .{});
defer log.logInfo("Done\n"); defer log.logInfo("Done\n", .{});
// Exit if we haven't loaded all debug modules // Exit if we haven't loaded all debug modules
if (mem_profile.boot_modules.len < 1) if (mem_profile.boot_modules.len < 1)
return; return;
@ -288,7 +287,7 @@ pub fn init(mem_profile: *const mem.MemProfile, allocator: *std.mem.Allocator) !
for (mem_profile.boot_modules) |module| { for (mem_profile.boot_modules) |module| {
const mod_start = mem.physToVirt(module.mod_start); const mod_start = mem.physToVirt(module.mod_start);
const mod_end = mem.physToVirt(module.mod_end) - 1; const mod_end = mem.physToVirt(module.mod_end) - 1;
const mod_str_ptr = mem.physToVirt(@intToPtr([*]u8, module.cmdline)); const mod_str_ptr = mem.physToVirt(@intToPtr([*:0]u8, module.cmdline));
if (std.mem.eql(u8, std.mem.toSlice(u8, mod_str_ptr), "kernel.map")) { if (std.mem.eql(u8, std.mem.toSlice(u8, mod_str_ptr), "kernel.map")) {
kmap_start = mod_start; kmap_start = mod_start;
kmap_end = mod_end; kmap_end = mod_end;

6
src/kernel/serial.zig
View file

@ -140,14 +140,14 @@ pub fn init(baud: u32, port: Port) SerialError!void {
const port_int = @enumToInt(port); const port_int = @enumToInt(port);
// Send a byte to start setting the baudrate // Send a byte to start setting the baudrate
arch.outb(port_int + LCR, lcrValue(0, false, false, 1) catch |e| { arch.outb(port_int + LCR, lcrValue(0, false, false, 1) catch |e| {
panic(@errorReturnTrace(), "Failed to initialise serial output setup: {}", e); panic(@errorReturnTrace(), "Failed to initialise serial output setup: {}", .{e});
}); });
// Send the divisor's lsb // Send the divisor's lsb
arch.outb(port_int, @truncate(u8, divisor)); arch.outb(port_int, @truncate(u8, divisor));
// Send the divisor's msb // Send the divisor's msb
arch.outb(port_int + 1, @truncate(u8, divisor >> 8)); arch.outb(port_int + 1, @truncate(u8, divisor >> 8));
// Send the properties to use // Send the properties to use
arch.outb(port_int + LCR, lcrValue(CHAR_LEN, SINGLE_STOP_BIT, PARITY_BIT, 0) catch |e| panic(@errorReturnTrace(), "Failed to setup serial properties: {}", e)); arch.outb(port_int + LCR, lcrValue(CHAR_LEN, SINGLE_STOP_BIT, PARITY_BIT, 0) catch |e| panic(@errorReturnTrace(), "Failed to setup serial properties: {}", .{e}));
// Stop initialisation // Stop initialisation
arch.outb(port_int + 1, 0); arch.outb(port_int + 1, 0);
@ -212,5 +212,5 @@ fn rt_writeByte() void {
/// Test writing a series of bytes /// Test writing a series of bytes
/// ///
fn rt_writeBytes() void { fn rt_writeBytes() void {
writeBytes([_]u8{ '1', '2', '3', '\n' }, Port.COM1); writeBytes(&[_]u8{ '1', '2', '3', '\n' }, Port.COM1);
} }

62
src/kernel/tty.zig
View file

@ -182,8 +182,8 @@ fn displayPageNumber() void {
var text_buf = [_]u8{0} ** vga.WIDTH; var text_buf = [_]u8{0} ** vga.WIDTH;
// Formate the page number string so can work out the right alignment. // Formate the page number string so can work out the right alignment.
const fmt_text = fmt.bufPrint(text_buf[0..], "Page {} of {}", page_index, TOTAL_NUM_PAGES - 1) catch |e| { const fmt_text = fmt.bufPrint(text_buf[0..], "Page {} of {}", .{ page_index, TOTAL_NUM_PAGES - 1 }) catch |e| {
log.logError("TTY: Unable to print page number, buffer too small. Error: {}\n", e); log.logError("TTY: Unable to print page number, buffer too small. Error: {}\n", .{e});
return; return;
}; };
@ -194,7 +194,7 @@ fn displayPageNumber() void {
row = ROW_MIN - 1; row = ROW_MIN - 1;
writeString(fmt_text) catch |e| { writeString(fmt_text) catch |e| {
log.logError("TTY: Unable to print page number, printing out of bounds. Error: {}\n", e); log.logError("TTY: Unable to print page number, printing out of bounds. Error: {}\n", .{e});
}; };
} }
@ -292,7 +292,7 @@ fn scroll() void {
// Move rows up pages by temp, will usually be one. // Move rows up pages by temp, will usually be one.
// TODO: Maybe panic here as we have the check above, so if this fails, then is a big problem // TODO: Maybe panic here as we have the check above, so if this fails, then is a big problem
pagesMoveRowsUp(rows_to_move) catch |e| { pagesMoveRowsUp(rows_to_move) catch |e| {
panic(@errorReturnTrace(), "Can't move {} rows up. Must be less than {}\n", rows_to_move, ROW_TOTAL); panic(@errorReturnTrace(), "Can't move {} rows up. Must be less than {}\n", .{ rows_to_move, ROW_TOTAL });
}; };
// Move all rows up by rows_to_move // Move all rows up by rows_to_move
@ -413,7 +413,7 @@ fn printLogo() void {
row = 0; row = 0;
writeString(logo) catch |e| { writeString(logo) catch |e| {
log.logError("TTY: Error print logo. Error {}\n", e); log.logError("TTY: Error print logo. Error {}\n", .{e});
}; };
} }
@ -437,12 +437,12 @@ fn printCallback(ctx: void, str: []const u8) TtyError!void {
/// ///
/// Arguments: /// Arguments:
/// IN comptime format: []const u8 - The format string to print /// IN comptime format: []const u8 - The format string to print
/// IN args: ... - The arguments to be used in the formatted string /// IN args: var - The arguments to be used in the formatted string
/// ///
pub fn print(comptime format: []const u8, args: ...) void { pub fn print(comptime format: []const u8, args: var) void {
// Printing can't error because of the scrolling, if it does, we have a big problem // Printing can't error because of the scrolling, if it does, we have a big problem
fmt.format({}, TtyError, printCallback, format, args) catch |e| { fmt.format({}, TtyError, printCallback, format, args) catch |e| {
log.logError("TTY: Error printing. Error: {}\n", e); log.logError("TTY: Error printing. Error: {}\n", .{e});
}; };
} }
@ -456,7 +456,7 @@ pub fn pageUp() void {
page_index += 1; page_index += 1;
// Bounds have been checked, so shouldn't error // Bounds have been checked, so shouldn't error
videoCopy(START_OF_DISPLAYABLE_REGION, pages[page_index][0..TOTAL_CHAR_ON_PAGE], TOTAL_CHAR_ON_PAGE) catch |e| { videoCopy(START_OF_DISPLAYABLE_REGION, pages[page_index][0..TOTAL_CHAR_ON_PAGE], TOTAL_CHAR_ON_PAGE) catch |e| {
log.logError("TTY: Error moving page up. Error: {}\n", e); log.logError("TTY: Error moving page up. Error: {}\n", .{e});
}; };
displayPageNumber(); displayPageNumber();
vga.disableCursor(); vga.disableCursor();
@ -473,7 +473,7 @@ pub fn pageDown() void {
page_index -= 1; page_index -= 1;
// Bounds have been checked, so shouldn't error // Bounds have been checked, so shouldn't error
videoCopy(START_OF_DISPLAYABLE_REGION, pages[page_index][0..TOTAL_CHAR_ON_PAGE], TOTAL_CHAR_ON_PAGE) catch |e| { videoCopy(START_OF_DISPLAYABLE_REGION, pages[page_index][0..TOTAL_CHAR_ON_PAGE], TOTAL_CHAR_ON_PAGE) catch |e| {
log.logError("TTY: Error moving page down. Error: {}\n", e); log.logError("TTY: Error moving page down. Error: {}\n", .{e});
}; };
displayPageNumber(); displayPageNumber();
@ -494,7 +494,7 @@ pub fn clearScreen() void {
// Move all the rows up // Move all the rows up
// This is within bounds, so shouldn't error // This is within bounds, so shouldn't error
pagesMoveRowsUp(ROW_TOTAL) catch |e| { pagesMoveRowsUp(ROW_TOTAL) catch |e| {
log.logError("TTY: Error moving all pages up. Error: {}\n", e); log.logError("TTY: Error moving all pages up. Error: {}\n", .{e});
}; };
// Clear the screen // Clear the screen
@ -569,7 +569,7 @@ pub fn getVideoBufferAddress() usize {
/// entry, print the logo and display the 0'th page. /// entry, print the logo and display the 0'th page.
/// ///
pub fn init() void { pub fn init() void {
log.logInfo("Init tty\n"); log.logInfo("Init tty\n", .{});
// Video buffer in higher half // Video buffer in higher half
if (is_test) { if (is_test) {
@ -615,13 +615,13 @@ pub fn init() void {
// Set the top 7 rows blank // Set the top 7 rows blank
setVideoBuffer(blank, START_OF_DISPLAYABLE_REGION) catch |e| { setVideoBuffer(blank, START_OF_DISPLAYABLE_REGION) catch |e| {
log.logError("TTY: Error clearing the top 7 rows. Error: {}\n", e); log.logError("TTY: Error clearing the top 7 rows. Error: {}\n", .{e});
}; };
row += @truncate(u8, row_offset + ROW_MIN); row += @truncate(u8, row_offset + ROW_MIN);
} else { } else {
// Clear the screen // Clear the screen
setVideoBuffer(blank, VIDEO_BUFFER_SIZE) catch |e| { setVideoBuffer(blank, VIDEO_BUFFER_SIZE) catch |e| {
log.logError("TTY: Error clearing the screen. Error: {}\n", e); log.logError("TTY: Error clearing the screen. Error: {}\n", .{e});
}; };
// Set the row to below the logo // Set the row to below the logo
row = ROW_MIN; row = ROW_MIN;
@ -631,7 +631,7 @@ pub fn init() void {
displayPageNumber(); displayPageNumber();
updateCursor(); updateCursor();
log.logInfo("Done\n"); log.logInfo("Done\n", .{});
if (build_options.rt_test) runtimeTests(); if (build_options.rt_test) runtimeTests();
} }
@ -756,7 +756,7 @@ test "updateCursor" {
vga.initTest(); vga.initTest();
defer vga.freeTest(); defer vga.freeTest();
vga.addTestParams("updateCursor", @as(u16, 0), @as(u16, 0)); vga.addTestParams("updateCursor", .{ @as(u16, 0), @as(u16, 0) });
// Pre testing // Pre testing
defaultAllTesting(0, 0, 0); defaultAllTesting(0, 0, 0);
@ -779,7 +779,7 @@ test "getCursor zero" {
vga.initTest(); vga.initTest();
defer vga.freeTest(); defer vga.freeTest();
vga.addTestParams("getCursor", @as(u16, 0)); vga.addTestParams("getCursor", .{@as(u16, 0)});
// Pre testing // Pre testing
defaultAllTesting(0, 0, 0); defaultAllTesting(0, 0, 0);
@ -802,7 +802,7 @@ test "getCursor EEF" {
vga.initTest(); vga.initTest();
defer vga.freeTest(); defer vga.freeTest();
vga.addTestParams("getCursor", @as(u16, 0x0EEF)); vga.addTestParams("getCursor", .{@as(u16, 0x0EEF)});
// Pre testing // Pre testing
defaultAllTesting(0, 0, 0); defaultAllTesting(0, 0, 0);
@ -2036,7 +2036,7 @@ test "init 0,0" {
vga.initTest(); vga.initTest();
defer vga.freeTest(); defer vga.freeTest();
vga.addTestParams("getCursor", @as(u16, 0)); vga.addTestParams("getCursor", .{@as(u16, 0)});
vga.addRepeatFunction("entryColour", vga.orig_entryColour); vga.addRepeatFunction("entryColour", vga.orig_entryColour);
vga.addRepeatFunction("entry", vga.orig_entry); vga.addRepeatFunction("entry", vga.orig_entry);
@ -2075,7 +2075,7 @@ test "init not 0,0" {
vga.initTest(); vga.initTest();
defer vga.freeTest(); defer vga.freeTest();
vga.addTestParams("getCursor", vga.WIDTH); vga.addTestParams("getCursor", .{vga.WIDTH});
vga.addRepeatFunction("entryColour", vga.orig_entryColour); vga.addRepeatFunction("entryColour", vga.orig_entryColour);
vga.addRepeatFunction("entry", vga.orig_entry); vga.addRepeatFunction("entry", vga.orig_entry);
@ -2111,19 +2111,19 @@ test "init not 0,0" {
/// ///
fn rt_initialisedGlobals() void { fn rt_initialisedGlobals() void {
if (@ptrToInt(video_buffer.ptr) != @ptrToInt(&KERNEL_ADDR_OFFSET) + 0xB8000) { if (@ptrToInt(video_buffer.ptr) != @ptrToInt(&KERNEL_ADDR_OFFSET) + 0xB8000) {
panic(@errorReturnTrace(), "Video buffer not at correct virtual address, found: {}\n", @ptrToInt(video_buffer.ptr)); panic(@errorReturnTrace(), "Video buffer not at correct virtual address, found: {}\n", .{@ptrToInt(video_buffer.ptr)});
} }
if (page_index != 0) { if (page_index != 0) {
panic(@errorReturnTrace(), "Page index not at zero, found: {}\n", page_index); panic(@errorReturnTrace(), "Page index not at zero, found: {}\n", .{page_index});
} }
if (colour != vga.entryColour(vga.COLOUR_LIGHT_GREY, vga.COLOUR_BLACK)) { if (colour != vga.entryColour(vga.COLOUR_LIGHT_GREY, vga.COLOUR_BLACK)) {
panic(@errorReturnTrace(), "Colour not set up properly, found: {}\n", colour); panic(@errorReturnTrace(), "Colour not set up properly, found: {}\n", .{colour});
} }
if (blank != vga.entry(0, colour)) { if (blank != vga.entry(0, colour)) {
panic(@errorReturnTrace(), "Blank not set up properly, found: {}\n", blank); panic(@errorReturnTrace(), "Blank not set up properly, found: {}\n", .{blank});
} }
// Make sure the screen isn't all blank // Make sure the screen isn't all blank
@ -2136,10 +2136,10 @@ fn rt_initialisedGlobals() void {
} }
if (all_blank) { if (all_blank) {
panic(@errorReturnTrace(), "Screen all blank, should have logo and page number\n"); panic(@errorReturnTrace(), "Screen all blank, should have logo and page number\n", .{});
} }
log.logInfo("TTY: Tested globals\n"); log.logInfo("TTY: Tested globals\n", .{});
} }
/// ///
@ -2150,7 +2150,7 @@ fn rt_printString() void {
const text = "abcdefg"; const text = "abcdefg";
const clear_text = "\x08" ** text.len; const clear_text = "\x08" ** text.len;
print(text); print(text, .{});
// Check the video memory // Check the video memory
var counter: u32 = 0; var counter: u32 = 0;
@ -2166,7 +2166,7 @@ fn rt_printString() void {
} }
if (counter != text.len) { if (counter != text.len) {
panic(@errorReturnTrace(), "Didn't find the printed text in video memory\n"); panic(@errorReturnTrace(), "Didn't find the printed text in video memory\n", .{});
} }
// Check the pages // Check the pages
@ -2183,13 +2183,13 @@ fn rt_printString() void {
} }
if (counter != text.len) { if (counter != text.len) {
panic(@errorReturnTrace(), "Didn't find the printed text in pages\n"); panic(@errorReturnTrace(), "Didn't find the printed text in pages\n", .{});
} }
// Clear the text // Clear the text
print(clear_text); print(clear_text, .{});
log.logInfo("TTY: Tested printing\n"); log.logInfo("TTY: Tested printing\n", .{});
} }
/// ///

64
src/kernel/vga.zig
View file

@ -286,7 +286,7 @@ pub fn setCursorShape(shape: CursorShape) void {
/// Initialise the VGA text mode. This sets the cursor and underline shape. /// Initialise the VGA text mode. This sets the cursor and underline shape.
/// ///
pub fn init() void { pub fn init() void {
log.logInfo("Init vga\n"); log.logInfo("Init vga\n", .{});
// Set the maximum scan line to 0x0F // Set the maximum scan line to 0x0F
sendPortData(REG_MAXIMUM_SCAN_LINE, CURSOR_SCANLINE_END); sendPortData(REG_MAXIMUM_SCAN_LINE, CURSOR_SCANLINE_END);
@ -294,7 +294,7 @@ pub fn init() void {
// Set by default the underline cursor // Set by default the underline cursor
setCursorShape(CursorShape.UNDERLINE); setCursorShape(CursorShape.UNDERLINE);
log.logInfo("Done\n"); log.logInfo("Done\n", .{});
if (build_options.rt_test) runtimeTests(); if (build_options.rt_test) runtimeTests();
} }
@ -345,7 +345,7 @@ test "updateCursor width out of bounds" {
defer arch.freeTest(); defer arch.freeTest();
// Mocking out the arch.outb calls for changing the hardware cursor: // Mocking out the arch.outb calls for changing the hardware cursor:
arch.addTestParams("outb", PORT_ADDRESS, REG_CURSOR_LOCATION_LOW, PORT_DATA, expected_lower, PORT_ADDRESS, REG_CURSOR_LOCATION_HIGH, PORT_DATA, expected_upper); arch.addTestParams("outb", .{ PORT_ADDRESS, REG_CURSOR_LOCATION_LOW, PORT_DATA, expected_lower, PORT_ADDRESS, REG_CURSOR_LOCATION_HIGH, PORT_DATA, expected_upper });
updateCursor(x, y); updateCursor(x, y);
} }
@ -362,7 +362,7 @@ test "updateCursor height out of bounds" {
defer arch.freeTest(); defer arch.freeTest();
// Mocking out the arch.outb calls for changing the hardware cursor: // Mocking out the arch.outb calls for changing the hardware cursor:
arch.addTestParams("outb", PORT_ADDRESS, REG_CURSOR_LOCATION_LOW, PORT_DATA, expected_lower, PORT_ADDRESS, REG_CURSOR_LOCATION_HIGH, PORT_DATA, expected_upper); arch.addTestParams("outb", .{ PORT_ADDRESS, REG_CURSOR_LOCATION_LOW, PORT_DATA, expected_lower, PORT_ADDRESS, REG_CURSOR_LOCATION_HIGH, PORT_DATA, expected_upper });
updateCursor(x, y); updateCursor(x, y);
} }
@ -379,7 +379,7 @@ test "updateCursor width and height out of bounds" {
defer arch.freeTest(); defer arch.freeTest();
// Mocking out the arch.outb calls for changing the hardware cursor: // Mocking out the arch.outb calls for changing the hardware cursor:
arch.addTestParams("outb", PORT_ADDRESS, REG_CURSOR_LOCATION_LOW, PORT_DATA, expected_lower, PORT_ADDRESS, REG_CURSOR_LOCATION_HIGH, PORT_DATA, expected_upper); arch.addTestParams("outb", .{ PORT_ADDRESS, REG_CURSOR_LOCATION_LOW, PORT_DATA, expected_lower, PORT_ADDRESS, REG_CURSOR_LOCATION_HIGH, PORT_DATA, expected_upper });
updateCursor(x, y); updateCursor(x, y);
} }
@ -396,7 +396,7 @@ test "updateCursor width-1 and height out of bounds" {
defer arch.freeTest(); defer arch.freeTest();
// Mocking out the arch.outb calls for changing the hardware cursor: // Mocking out the arch.outb calls for changing the hardware cursor:
arch.addTestParams("outb", PORT_ADDRESS, REG_CURSOR_LOCATION_LOW, PORT_DATA, expected_lower, PORT_ADDRESS, REG_CURSOR_LOCATION_HIGH, PORT_DATA, expected_upper); arch.addTestParams("outb", .{ PORT_ADDRESS, REG_CURSOR_LOCATION_LOW, PORT_DATA, expected_lower, PORT_ADDRESS, REG_CURSOR_LOCATION_HIGH, PORT_DATA, expected_upper });
updateCursor(x, y); updateCursor(x, y);
} }
@ -413,7 +413,7 @@ test "updateCursor width and height-1 out of bounds" {
defer arch.freeTest(); defer arch.freeTest();
// Mocking out the arch.outb calls for changing the hardware cursor: // Mocking out the arch.outb calls for changing the hardware cursor:
arch.addTestParams("outb", PORT_ADDRESS, REG_CURSOR_LOCATION_LOW, PORT_DATA, expected_lower, PORT_ADDRESS, REG_CURSOR_LOCATION_HIGH, PORT_DATA, expected_upper); arch.addTestParams("outb", .{ PORT_ADDRESS, REG_CURSOR_LOCATION_LOW, PORT_DATA, expected_lower, PORT_ADDRESS, REG_CURSOR_LOCATION_HIGH, PORT_DATA, expected_upper });
updateCursor(x, y); updateCursor(x, y);
} }
@ -430,7 +430,7 @@ test "updateCursor in bounds" {
defer arch.freeTest(); defer arch.freeTest();
// Mocking out the arch.outb calls for changing the hardware cursor: // Mocking out the arch.outb calls for changing the hardware cursor:
arch.addTestParams("outb", PORT_ADDRESS, REG_CURSOR_LOCATION_LOW, PORT_DATA, expected_lower, PORT_ADDRESS, REG_CURSOR_LOCATION_HIGH, PORT_DATA, expected_upper); arch.addTestParams("outb", .{ PORT_ADDRESS, REG_CURSOR_LOCATION_LOW, PORT_DATA, expected_lower, PORT_ADDRESS, REG_CURSOR_LOCATION_HIGH, PORT_DATA, expected_upper });
updateCursor(x, y); updateCursor(x, y);
} }
@ -441,10 +441,10 @@ test "getCursor 1: 10" {
arch.initTest(); arch.initTest();
defer arch.freeTest(); defer arch.freeTest();
arch.addTestParams("outb", PORT_ADDRESS, REG_CURSOR_LOCATION_LOW); arch.addTestParams("outb", .{ PORT_ADDRESS, REG_CURSOR_LOCATION_LOW });
arch.addTestParams("inb", PORT_DATA, @as(u8, 10)); arch.addTestParams("inb", .{ PORT_DATA, @as(u8, 10) });
arch.addTestParams("outb", PORT_ADDRESS, REG_CURSOR_LOCATION_HIGH); arch.addTestParams("outb", .{ PORT_ADDRESS, REG_CURSOR_LOCATION_HIGH });
arch.addTestParams("inb", PORT_DATA, @as(u8, 0)); arch.addTestParams("inb", .{ PORT_DATA, @as(u8, 0) });
const actual = getCursor(); const actual = getCursor();
expectEqual(expect, actual); expectEqual(expect, actual);
@ -457,10 +457,10 @@ test "getCursor 2: 0xBEEF" {
arch.initTest(); arch.initTest();
defer arch.freeTest(); defer arch.freeTest();
arch.addTestParams("outb", PORT_ADDRESS, REG_CURSOR_LOCATION_LOW); arch.addTestParams("outb", .{ PORT_ADDRESS, REG_CURSOR_LOCATION_LOW });
arch.addTestParams("inb", PORT_DATA, @as(u8, 0xEF)); arch.addTestParams("inb", .{ PORT_DATA, @as(u8, 0xEF) });
arch.addTestParams("outb", PORT_ADDRESS, REG_CURSOR_LOCATION_HIGH); arch.addTestParams("outb", .{ PORT_ADDRESS, REG_CURSOR_LOCATION_HIGH });
arch.addTestParams("inb", PORT_DATA, @as(u8, 0xBE)); arch.addTestParams("inb", .{ PORT_DATA, @as(u8, 0xBE) });
const actual = getCursor(); const actual = getCursor();
expectEqual(expect, actual); expectEqual(expect, actual);
@ -471,10 +471,12 @@ test "enableCursor" {
defer arch.freeTest(); defer arch.freeTest();
// Need to init the cursor start and end positions, so call the init() to set this up // Need to init the cursor start and end positions, so call the init() to set this up
arch.addTestParams("outb", PORT_ADDRESS, REG_MAXIMUM_SCAN_LINE, PORT_DATA, CURSOR_SCANLINE_END, PORT_ADDRESS, REG_CURSOR_START, PORT_DATA, CURSOR_SCANLINE_MIDDLE, PORT_ADDRESS, REG_CURSOR_END, PORT_DATA, CURSOR_SCANLINE_END, arch.addTestParams("outb", .{
// Mocking out the arch.outb calls for enabling the cursor: PORT_ADDRESS, REG_MAXIMUM_SCAN_LINE, PORT_DATA, CURSOR_SCANLINE_END, PORT_ADDRESS, REG_CURSOR_START, PORT_DATA, CURSOR_SCANLINE_MIDDLE, PORT_ADDRESS, REG_CURSOR_END, PORT_DATA, CURSOR_SCANLINE_END,
// These are the default cursor positions from init() // Mocking out the arch.outb calls for enabling the cursor:
PORT_ADDRESS, REG_CURSOR_START, PORT_DATA, CURSOR_SCANLINE_MIDDLE, PORT_ADDRESS, REG_CURSOR_END, PORT_DATA, CURSOR_SCANLINE_END); // These are the default cursor positions from init()
PORT_ADDRESS, REG_CURSOR_START, PORT_DATA, CURSOR_SCANLINE_MIDDLE, PORT_ADDRESS, REG_CURSOR_END, PORT_DATA, CURSOR_SCANLINE_END,
});
init(); init();
enableCursor(); enableCursor();
@ -485,7 +487,7 @@ test "disableCursor" {
defer arch.freeTest(); defer arch.freeTest();
// Mocking out the arch.outb calls for disabling the cursor: // Mocking out the arch.outb calls for disabling the cursor:
arch.addTestParams("outb", PORT_ADDRESS, REG_CURSOR_START, PORT_DATA, CURSOR_DISABLE); arch.addTestParams("outb", .{ PORT_ADDRESS, REG_CURSOR_START, PORT_DATA, CURSOR_DISABLE });
disableCursor(); disableCursor();
} }
@ -496,7 +498,7 @@ test "setCursorShape UNDERLINE" {
// Mocking out the arch.outb calls for setting the cursor shape to underline: // Mocking out the arch.outb calls for setting the cursor shape to underline:
// This will also check that the scan line variables were set properly as these are using in // This will also check that the scan line variables were set properly as these are using in
// the arch.outb call // the arch.outb call
arch.addTestParams("outb", PORT_ADDRESS, REG_CURSOR_START, PORT_DATA, CURSOR_SCANLINE_MIDDLE, PORT_ADDRESS, REG_CURSOR_END, PORT_DATA, CURSOR_SCANLINE_END); arch.addTestParams("outb", .{ PORT_ADDRESS, REG_CURSOR_START, PORT_DATA, CURSOR_SCANLINE_MIDDLE, PORT_ADDRESS, REG_CURSOR_END, PORT_DATA, CURSOR_SCANLINE_END });
setCursorShape(CursorShape.UNDERLINE); setCursorShape(CursorShape.UNDERLINE);
} }
@ -508,7 +510,7 @@ test "setCursorShape BLOCK" {
// Mocking out the arch.outb calls for setting the cursor shape to block: // Mocking out the arch.outb calls for setting the cursor shape to block:
// This will also check that the scan line variables were set properly as these are using in // This will also check that the scan line variables were set properly as these are using in
// the arch.outb call // the arch.outb call
arch.addTestParams("outb", PORT_ADDRESS, REG_CURSOR_START, PORT_DATA, CURSOR_SCANLINE_START, PORT_ADDRESS, REG_CURSOR_END, PORT_DATA, CURSOR_SCANLINE_END); arch.addTestParams("outb", .{ PORT_ADDRESS, REG_CURSOR_START, PORT_DATA, CURSOR_SCANLINE_START, PORT_ADDRESS, REG_CURSOR_END, PORT_DATA, CURSOR_SCANLINE_END });
setCursorShape(CursorShape.BLOCK); setCursorShape(CursorShape.BLOCK);
} }
@ -520,7 +522,7 @@ test "init" {
// Mocking out the arch.outb calls for setting the cursor max scan line and the shape to block: // Mocking out the arch.outb calls for setting the cursor max scan line and the shape to block:
// This will also check that the scan line variables were set properly as these are using in // This will also check that the scan line variables were set properly as these are using in
// the arch.outb call for setting the cursor shape. // the arch.outb call for setting the cursor shape.
arch.addTestParams("outb", PORT_ADDRESS, REG_MAXIMUM_SCAN_LINE, PORT_DATA, CURSOR_SCANLINE_END, PORT_ADDRESS, REG_CURSOR_START, PORT_DATA, CURSOR_SCANLINE_MIDDLE, PORT_ADDRESS, REG_CURSOR_END, PORT_DATA, CURSOR_SCANLINE_END); arch.addTestParams("outb", .{ PORT_ADDRESS, REG_MAXIMUM_SCAN_LINE, PORT_DATA, CURSOR_SCANLINE_END, PORT_ADDRESS, REG_CURSOR_START, PORT_DATA, CURSOR_SCANLINE_MIDDLE, PORT_ADDRESS, REG_CURSOR_END, PORT_DATA, CURSOR_SCANLINE_END });
init(); init();
} }
@ -532,10 +534,10 @@ fn rt_correctMaxScanLine() void {
const max_scan_line = getPortData(REG_MAXIMUM_SCAN_LINE); const max_scan_line = getPortData(REG_MAXIMUM_SCAN_LINE);
if (max_scan_line != CURSOR_SCANLINE_END) { if (max_scan_line != CURSOR_SCANLINE_END) {
panic(@errorReturnTrace(), "Max scan line not {}, found {}\n", CURSOR_SCANLINE_END, max_scan_line); panic(@errorReturnTrace(), "Max scan line not {}, found {}\n", .{ CURSOR_SCANLINE_END, max_scan_line });
} }
log.logInfo("VGA: Tested max scan line\n"); log.logInfo("VGA: Tested max scan line\n", .{});
} }
/// ///
@ -544,17 +546,17 @@ fn rt_correctMaxScanLine() void {
fn rt_correctCursorShape() void { fn rt_correctCursorShape() void {
// Check the global variables are correct // Check the global variables are correct
if (cursor_scanline_start != CURSOR_SCANLINE_MIDDLE or cursor_scanline_end != CURSOR_SCANLINE_END) { if (cursor_scanline_start != CURSOR_SCANLINE_MIDDLE or cursor_scanline_end != CURSOR_SCANLINE_END) {
panic(@errorReturnTrace(), "Global cursor scanline incorrect. Start: {}, end: {}\n", cursor_scanline_start, cursor_scanline_end); panic(@errorReturnTrace(), "Global cursor scanline incorrect. Start: {}, end: {}\n", .{ cursor_scanline_start, cursor_scanline_end });
} }
const cursor_start = getPortData(REG_CURSOR_START); const cursor_start = getPortData(REG_CURSOR_START);
const cursor_end = getPortData(REG_CURSOR_END); const cursor_end = getPortData(REG_CURSOR_END);
if (cursor_start != CURSOR_SCANLINE_MIDDLE or cursor_end != CURSOR_SCANLINE_END) { if (cursor_start != CURSOR_SCANLINE_MIDDLE or cursor_end != CURSOR_SCANLINE_END) {
panic(@errorReturnTrace(), "Cursor scanline are incorrect. Start: {}, end: {}\n", cursor_start, cursor_end); panic(@errorReturnTrace(), "Cursor scanline are incorrect. Start: {}, end: {}\n", .{ cursor_start, cursor_end });
} }
log.logInfo("VGA: Tested cursor shape\n"); log.logInfo("VGA: Tested cursor shape\n", .{});
} }
/// ///
@ -580,13 +582,13 @@ fn rt_setCursorGetCursor() void {
const actual_y_loc = @truncate(u8, actual_linear_loc / WIDTH); const actual_y_loc = @truncate(u8, actual_linear_loc / WIDTH);
if (x != actual_x_loc or y != actual_y_loc) { if (x != actual_x_loc or y != actual_y_loc) {
panic(@errorReturnTrace(), "VGA cursor not the same: a_x: {}, a_y: {}, e_x: {}, e_y: {}\n", x, y, actual_x_loc, actual_y_loc); panic(@errorReturnTrace(), "VGA cursor not the same: a_x: {}, a_y: {}, e_x: {}, e_y: {}\n", .{ x, y, actual_x_loc, actual_y_loc });
} }
// Restore the previous x and y // Restore the previous x and y
updateCursor(prev_x_loc, prev_y_loc); updateCursor(prev_x_loc, prev_y_loc);
log.logInfo("VGA: Tested updating cursor\n"); log.logInfo("VGA: Tested updating cursor\n", .{});
} }
/// ///

22
test/mock/kernel/arch_mock.zig
View file

@ -36,47 +36,47 @@ pub const InterruptContext = struct {
}; };
pub fn outb(port: u16, data: u8) void { pub fn outb(port: u16, data: u8) void {
return mock_framework.performAction("outb", void, port, data); return mock_framework.performAction("outb", void, .{ port, data });
} }
pub fn inb(port: u16) u8 { pub fn inb(port: u16) u8 {
return mock_framework.performAction("inb", u8, port); return mock_framework.performAction("inb", u8, .{port});
} }
pub fn ioWait() void { pub fn ioWait() void {
return mock_framework.performAction("ioWait", void); return mock_framework.performAction("ioWait", void, .{});
} }
pub fn lgdt(gdt_ptr: *const gdt.GdtPtr) void { pub fn lgdt(gdt_ptr: *const gdt.GdtPtr) void {
return mock_framework.performAction("lgdt", void, gdt_ptr); return mock_framework.performAction("lgdt", void, .{gdt_ptr});
} }
pub fn sgdt() gdt.GdtPtr { pub fn sgdt() gdt.GdtPtr {
return mock_framework.performAction("sgdt", gdt.GdtPtr); return mock_framework.performAction("sgdt", gdt.GdtPtr, .{});
} }
pub fn ltr(offset: u16) void { pub fn ltr(offset: u16) void {
return mock_framework.performAction("ltr", void, offset); return mock_framework.performAction("ltr", void, .{offset});
} }
pub fn lidt(idt_ptr: *const idt.IdtPtr) void { pub fn lidt(idt_ptr: *const idt.IdtPtr) void {
return mock_framework.performAction("lidt", void, idt_ptr); return mock_framework.performAction("lidt", void, .{idt_ptr});
} }
pub fn sidt() idt.IdtPtr { pub fn sidt() idt.IdtPtr {
return mock_framework.performAction("sidt", idt.IdtPtr); return mock_framework.performAction("sidt", idt.IdtPtr, .{});
} }
pub fn enableInterrupts() void { pub fn enableInterrupts() void {
return mock_framework.performAction("enableInterrupts", void); return mock_framework.performAction("enableInterrupts", void, .{});
} }
pub fn disableInterrupts() void { pub fn disableInterrupts() void {
return mock_framework.performAction("disableInterrupts", void); return mock_framework.performAction("disableInterrupts", void, .{});
} }
pub fn halt() void { pub fn halt() void {
return mock_framework.performAction("halt", void); return mock_framework.performAction("halt", void, .{});
} }
pub fn spinWait() noreturn { pub fn spinWait() noreturn {

2
test/mock/kernel/idt_mock.zig
View file

@ -39,7 +39,7 @@ const NUMBER_OF_ENTRIES: u16 = 256;
const TABLE_SIZE: u16 = @sizeOf(IdtEntry) * NUMBER_OF_ENTRIES - 1; const TABLE_SIZE: u16 = @sizeOf(IdtEntry) * NUMBER_OF_ENTRIES - 1;
pub fn openInterruptGate(index: u8, handler: InterruptHandler) IdtError!void { pub fn openInterruptGate(index: u8, handler: InterruptHandler) IdtError!void {
return mock_framework.performAction("openInterruptGate", IdtError!void, index, handler); return mock_framework.performAction("openInterruptGate", IdtError!void, .{ index, handler });
} }
pub fn init() void { pub fn init() void {

10
test/mock/kernel/log_mock.zig
View file

@ -12,22 +12,22 @@ pub const Level = enum {
ERROR, ERROR,
}; };
pub fn log(comptime level: Level, comptime format: []const u8, args: ...) void { pub fn log(comptime level: Level, comptime format: []const u8, args: var) void {
//return mock_framework.performAction("log", void, level, format, args); //return mock_framework.performAction("log", void, level, format, args);
} }
pub fn logInfo(comptime format: []const u8, args: ...) void { pub fn logInfo(comptime format: []const u8, args: var) void {
//return mock_framework.performAction("logInfo", void, format, args); //return mock_framework.performAction("logInfo", void, format, args);
} }
pub fn logDebug(comptime format: []const u8, args: ...) void { pub fn logDebug(comptime format: []const u8, args: var) void {
//return mock_framework.performAction("logDebug", void, format, args); //return mock_framework.performAction("logDebug", void, format, args);
} }
pub fn logWarning(comptime format: []const u8, args: ...) void { pub fn logWarning(comptime format: []const u8, args: var) void {
//return mock_framework.performAction("logWarning", void, format, args); //return mock_framework.performAction("logWarning", void, format, args);
} }
pub fn logError(comptime format: []const u8, args: ...) void { pub fn logError(comptime format: []const u8, args: var) void {
//return mock_framework.performAction("logError", void, format, args); //return mock_framework.performAction("logError", void, format, args);
} }

4
test/mock/kernel/mem_mock.zig
View file

@ -6,7 +6,7 @@ pub const MemProfile = struct {
physaddr_end: [*]u8, physaddr_end: [*]u8,
physaddr_start: [*]u8, physaddr_start: [*]u8,
mem_kb: u32, mem_kb: u32,
fixed_alloc_size: u32 fixed_alloc_size: u32,
}; };
// The virtual/physical start/end of the kernel code // The virtual/physical start/end of the kernel code
@ -27,6 +27,6 @@ pub fn init(mb_info: *multiboot.multiboot_info_t) MemProfile {
.physaddr_start = @ptrCast([*]u8, &KERNEL_PHYSADDR_START), .physaddr_start = @ptrCast([*]u8, &KERNEL_PHYSADDR_START),
// Total memory available including the initial 1MiB that grub doesn't include // Total memory available including the initial 1MiB that grub doesn't include
.mem_kb = mb_info.mem_upper + mb_info.mem_lower + 1024, .mem_kb = mb_info.mem_upper + mb_info.mem_lower + 1024,
.fixed_alloc_size = FIXED_ALLOC_SIZE .fixed_alloc_size = FIXED_ALLOC_SIZE,
}; };
} }

56
test/mock/kernel/mock_framework.zig
View file

@ -145,7 +145,7 @@ fn Mock() type {
/// A DataElement with the data wrapped. /// A DataElement with the data wrapped.
/// ///
fn createDataElement(arg: var) DataElement { fn createDataElement(arg: var) DataElement {
return switch (@typeOf(arg)) { return switch (@TypeOf(arg)) {
bool => DataElement{ .BOOL = arg }, bool => DataElement{ .BOOL = arg },
u4 => DataElement{ .U4 = arg }, u4 => DataElement{ .U4 = arg },
u8 => DataElement{ .U8 = arg }, u8 => DataElement{ .U8 = arg },
@ -171,7 +171,7 @@ fn Mock() type {
fn (*const idt.IdtPtr) void => DataElement{ .FN_IPTRCONSTIDTPTR_OVOID = arg }, fn (*const idt.IdtPtr) void => DataElement{ .FN_IPTRCONSTIDTPTR_OVOID = arg },
fn (u8, extern fn () void) idt.IdtError!void => DataElement{ .FN_IU8_IEFNOVOID_OERRORIDTERRORVOID = arg }, fn (u8, extern fn () void) idt.IdtError!void => DataElement{ .FN_IU8_IEFNOVOID_OERRORIDTERRORVOID = arg },
fn (u8, nakedcc fn () void) idt.IdtError!void => DataElement{ .FN_IU8_INFNOVOID_OERRORIDTERRORVOID = arg }, fn (u8, nakedcc fn () void) idt.IdtError!void => DataElement{ .FN_IU8_INFNOVOID_OERRORIDTERRORVOID = arg },
else => @compileError("Type not supported: " ++ @typeName(@typeOf(arg))), else => @compileError("Type not supported: " ++ @typeName(@TypeOf(arg))),
}; };
} }
@ -266,11 +266,11 @@ fn Mock() type {
/// Return: type /// Return: type
/// A function type that represents the return type and its arguments. /// A function type that represents the return type and its arguments.
/// ///
fn getFunctionType(comptime RetType: type, params: ...) type { fn getFunctionType(comptime RetType: type, params: var) type {
return switch (params.len) { return switch (params.len) {
0 => fn () RetType, 0 => fn () RetType,
1 => fn (@typeOf(params[0])) RetType, 1 => fn (@TypeOf(params[0])) RetType,
2 => fn (@typeOf(params[0]), @typeOf(params[1])) RetType, 2 => fn (@TypeOf(params[0]), @TypeOf(params[1])) RetType,
else => @compileError("Couldn't generate function type for " ++ params.len ++ "parameters\n"), else => @compileError("Couldn't generate function type for " ++ params.len ++ "parameters\n"),
}; };
} }
@ -288,7 +288,7 @@ fn Mock() type {
fn expectTest(comptime ExpectedType: type, expected_value: ExpectedType, elem: DataElement) void { fn expectTest(comptime ExpectedType: type, expected_value: ExpectedType, elem: DataElement) void {
if (ExpectedType == void) { if (ExpectedType == void) {
// Can't test void as it has no value // Can't test void as it has no value
std.debug.panic("Can not test a value for void\n"); std.debug.panic("Can not test a value for void\n", .{});
} }
// Test that the types match // Test that the types match
@ -330,7 +330,7 @@ fn Mock() type {
return ret; return ret;
} else { } else {
std.debug.panic("No more test values for the return of function: " ++ fun_name ++ "\n"); std.debug.panic("No more test values for the return of function: " ++ fun_name ++ "\n", .{});
} }
} }
@ -365,7 +365,7 @@ fn Mock() type {
} else { } else {
// Shouldn't get here as we would have just added a new mapping // Shouldn't get here as we would have just added a new mapping
// But just in case ;) // But just in case ;)
std.debug.panic("No function name: " ++ fun_name ++ "\n"); std.debug.panic("No function name: " ++ fun_name ++ "\n", .{});
} }
} }
@ -382,7 +382,7 @@ fn Mock() type {
/// Return: RetType /// Return: RetType
/// The return value of the mocked function. This can be void. /// The return value of the mocked function. This can be void.
/// ///
pub fn performAction(self: *Self, comptime fun_name: []const u8, comptime RetType: type, params: ...) RetType { pub fn performAction(self: *Self, comptime fun_name: []const u8, comptime RetType: type, params: var) RetType {
if (self.named_actions.get(fun_name)) |kv_actions_list| { if (self.named_actions.get(fun_name)) |kv_actions_list| {
var action_list = kv_actions_list.value; var action_list = kv_actions_list.value;
// Peak the first action to test the action type // Peak the first action to test the action type
@ -397,7 +397,7 @@ fn Mock() type {
const test_node = action_list.popFirst().?; const test_node = action_list.popFirst().?;
const test_action = test_node.data; const test_action = test_node.data;
const param = params[i]; const param = params[i];
const param_type = @typeOf(params[i]); const param_type = @TypeOf(params[i]);
expectTest(param_type, param, test_action.data); expectTest(param_type, param, test_action.data);
@ -420,8 +420,8 @@ fn Mock() type {
// to be resolved // to be resolved
const expected_function = switch (params.len) { const expected_function = switch (params.len) {
0 => fn () RetType, 0 => fn () RetType,
1 => fn (@typeOf(params[0])) RetType, 1 => fn (@TypeOf(params[0])) RetType,
2 => fn (@typeOf(params[0]), @typeOf(params[1])) RetType, 2 => fn (@TypeOf(params[0]), @TypeOf(params[1])) RetType,
else => @compileError("Couldn't generate function type for " ++ params.len ++ "parameters\n"), else => @compileError("Couldn't generate function type for " ++ params.len ++ "parameters\n"),
}; };
@ -438,10 +438,10 @@ fn Mock() type {
action_list.destroyNode(test_node, GlobalAllocator); action_list.destroyNode(test_node, GlobalAllocator);
// The data element will contain the function to call // The data element will contain the function to call
const r = switch (params.len) { var r = switch (params.len) {
0 => @noInlineCall(actual_function), 0 => actual_function(),
1 => @noInlineCall(actual_function, params[0]), 1 => actual_function(params[0]),
2 => @noInlineCall(actual_function, params[0], params[1]), 2 => actual_function(params[0], params[1]),
else => @compileError(params.len ++ " or more parameters not supported"), else => @compileError(params.len ++ " or more parameters not supported"),
}; };
@ -453,8 +453,8 @@ fn Mock() type {
const test_element = action.data; const test_element = action.data;
const expected_function = switch (params.len) { const expected_function = switch (params.len) {
0 => fn () RetType, 0 => fn () RetType,
1 => fn (@typeOf(params[0])) RetType, 1 => fn (@TypeOf(params[0])) RetType,
2 => fn (@typeOf(params[0]), @typeOf(params[1])) RetType, 2 => fn (@TypeOf(params[0]), @TypeOf(params[1])) RetType,
else => @compileError("Couldn't generate function type for " ++ params.len ++ "parameters\n"), else => @compileError("Couldn't generate function type for " ++ params.len ++ "parameters\n"),
}; };
@ -469,9 +469,9 @@ fn Mock() type {
// The data element will contain the function to call // The data element will contain the function to call
const r = switch (params.len) { const r = switch (params.len) {
0 => @noInlineCall(actual_function), 0 => actual_function(),
1 => @noInlineCall(actual_function, params[0]), 1 => actual_function(params[0]),
2 => @noInlineCall(actual_function, params[0], params[1]), 2 => actual_function(params[0], params[1]),
else => @compileError(params.len ++ " or more parameters not supported"), else => @compileError(params.len ++ " or more parameters not supported"),
}; };
@ -483,10 +483,10 @@ fn Mock() type {
kv_actions_list.value = action_list; kv_actions_list.value = action_list;
return ret; return ret;
} else { } else {
std.debug.panic("No action list elements for function: " ++ fun_name ++ "\n"); std.debug.panic("No action list elements for function: " ++ fun_name ++ "\n", .{});
} }
} else { } else {
std.debug.panic("No function name: " ++ fun_name ++ "\n"); std.debug.panic("No function name: " ++ fun_name ++ "\n", .{});
} }
} }
@ -520,7 +520,7 @@ fn Mock() type {
switch (action.action) { switch (action.action) {
ActionType.TestValue, ActionType.ConsumeFunctionCall => { ActionType.TestValue, ActionType.ConsumeFunctionCall => {
// These need to be all consumed // These need to be all consumed
std.debug.panic("Unused testing value: Type: {}, value: {} for function '{}'\n", action.action, @as(DataElementType, action.data), next.key); std.debug.panic("Unused testing value: Type: {}, value: {} for function '{}'\n", .{ action.action, @as(DataElementType, action.data), next.key });
}, },
ActionType.RepeatFunctionCall => { ActionType.RepeatFunctionCall => {
// As this is a repeat action, the function will still be here // As this is a repeat action, the function will still be here
@ -553,7 +553,7 @@ fn getMockObject() *Mock() {
if (mock) |*m| { if (mock) |*m| {
return m; return m;
} else { } else {
warn("MOCK object doesn't exists, please initiate this test\n"); warn("MOCK object doesn't exists, please initiate this test\n", .{});
expect(false); expect(false);
unreachable; unreachable;
} }
@ -565,7 +565,7 @@ fn getMockObject() *Mock() {
pub fn initTest() void { pub fn initTest() void {
// Make sure there isn't a mock object // Make sure there isn't a mock object
if (mock) |_| { if (mock) |_| {
warn("MOCK object already exists, please free previous test\n"); warn("MOCK object already exists, please free previous test\n", .{});
expect(false); expect(false);
unreachable; unreachable;
} else { } else {
@ -596,7 +596,7 @@ pub fn freeTest() void {
/// IN fun_name: []const u8 - The function name to add the test parameters to. /// IN fun_name: []const u8 - The function name to add the test parameters to.
/// IN params: arglist - The parameters to add. /// IN params: arglist - The parameters to add.
/// ///
pub fn addTestParams(comptime fun_name: []const u8, params: ...) void { pub fn addTestParams(comptime fun_name: []const u8, params: var) void {
var mock_obj = getMockObject(); var mock_obj = getMockObject();
comptime var i = 0; comptime var i = 0;
inline while (i < params.len) : (i += 1) { inline while (i < params.len) : (i += 1) {
@ -639,6 +639,6 @@ pub fn addRepeatFunction(comptime fun_name: []const u8, function: var) void {
/// Return: RetType /// Return: RetType
/// The return value of the mocked function. This can be void. /// The return value of the mocked function. This can be void.
/// ///
pub fn performAction(comptime fun_name: []const u8, comptime RetType: type, params: ...) RetType { pub fn performAction(comptime fun_name: []const u8, comptime RetType: type, params: var) RetType {
return getMockObject().performAction(fun_name, RetType, params); return getMockObject().performAction(fun_name, RetType, params);
} }

2
test/mock/kernel/panic_mock.zig
View file

@ -2,7 +2,7 @@ const builtin = @import("builtin");
const std = @import("std"); const std = @import("std");
const MemProfile = @import("mem_mock.zig").MemProfile; const MemProfile = @import("mem_mock.zig").MemProfile;
pub fn panic(trace: ?*builtin.StackTrace, comptime format: []const u8, args: ...) noreturn { pub fn panic(trace: ?*builtin.StackTrace, comptime format: []const u8, args: var) noreturn {
@setCold(true); @setCold(true);
std.debug.panic(format, args); std.debug.panic(format, args);
} }

8
test/mock/kernel/pic_mock.zig
View file

@ -72,19 +72,19 @@ pub const IRQ_FLOATING_POINT_UNIT: u8 = 0x0D;
pub const IRQ_HARD_DISK_CONTROLLER: u8 = 0x0E; pub const IRQ_HARD_DISK_CONTROLLER: u8 = 0x0E;
pub fn sendEndOfInterrupt(irq_num: u8) void { pub fn sendEndOfInterrupt(irq_num: u8) void {
return mock_framework.performAction("sendEndOfInterrupt", void, irq_num); return mock_framework.performAction("sendEndOfInterrupt", void, .{irq_num});
} }
pub fn spuriousIrq(irq_num: u8) bool { pub fn spuriousIrq(irq_num: u8) bool {
return mock_framework.performAction("spuriousIrq", bool, irq_num); return mock_framework.performAction("spuriousIrq", bool, .{irq_num});
} }
pub fn setMask(irq_num: u16) void { pub fn setMask(irq_num: u16) void {
return mock_framework.performAction("setMask", void, irq_num); return mock_framework.performAction("setMask", void, .{irq_num});
} }
pub fn clearMask(irq_num: u16) void { pub fn clearMask(irq_num: u16) void {
return mock_framework.performAction("clearMask", void, irq_num); return mock_framework.performAction("clearMask", void, .{irq_num});
} }
pub fn remapIrq() void { pub fn remapIrq() void {

16
test/mock/kernel/vga_mock.zig
View file

@ -36,35 +36,35 @@ pub const CursorShape = enum {
}; };
pub fn entryColour(fg: u4, bg: u4) u8 { pub fn entryColour(fg: u4, bg: u4) u8 {
return mock_framework.performAction("entryColour", u8, fg, bg); return mock_framework.performAction("entryColour", u8, .{ fg, bg });
} }
pub fn entry(uc: u8, colour: u8) u16 { pub fn entry(uc: u8, colour: u8) u16 {
return mock_framework.performAction("entry", u16, uc, colour); return mock_framework.performAction("entry", u16, .{ uc, colour });
} }
pub fn updateCursor(x: u16, y: u16) void { pub fn updateCursor(x: u16, y: u16) void {
return mock_framework.performAction("updateCursor", void, x, y); return mock_framework.performAction("updateCursor", void, .{ x, y });
} }
pub fn getCursor() u16 { pub fn getCursor() u16 {
return mock_framework.performAction("getCursor", u16); return mock_framework.performAction("getCursor", u16, .{});
} }
pub fn enableCursor() void { pub fn enableCursor() void {
return mock_framework.performAction("enableCursor", void); return mock_framework.performAction("enableCursor", void, .{});
} }
pub fn disableCursor() void { pub fn disableCursor() void {
return mock_framework.performAction("disableCursor", void); return mock_framework.performAction("disableCursor", void, .{});
} }
pub fn setCursorShape(shape: CursorShape) void { pub fn setCursorShape(shape: CursorShape) void {
return mock_framework.performAction("setCursorShape", void, shape); return mock_framework.performAction("setCursorShape", void, .{shape});
} }
pub fn init() void { pub fn init() void {
return mock_framework.performAction("init", void); return mock_framework.performAction("init", void, .{});
} }
// User defined mocked functions // User defined mocked functions