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

Merge pull request #116 from SamTebbs33/zig-update

Browse source 
Update code to work with zig master
This commit is contained in:
Sam Tebbs 2020-01-06 14:31:00 +00:00
commit 33a9e517ce
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
run: |
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
tar -xvf zig*
- 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 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.setBuildMode(build_mode);
exec.addBuildOption(bool, "rt_test", rt_test);
exec.setLinkerScriptPath("link.ld");
exec.setTheTarget(target);
const iso_path = try fs.path.join(b.allocator, [_][]const u8{ b.exe_dir, "pluto.iso" });
const grub_build_path = try fs.path.join(b.allocator, [_][]const u8{ b.exe_dir, "iso", "boot" });
const iso_dir_path = try fs.path.join(b.allocator, [_][]const u8{ b.exe_dir, "iso" });
const iso_path = try fs.path.join(b.allocator, &[_][]const u8{ b.exe_dir, "pluto.iso" });
const grub_build_path = try fs.path.join(b.allocator, &[_][]const u8{ b.exe_dir, "iso", "boot" });
const iso_dir_path = try fs.path.join(b.allocator, &[_][]const u8{ b.exe_dir, "iso" });
const 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);
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 cp_elf_cmd = b.addSystemCommand(&[_][]const u8{"cp"});
const elf_path = try fs.path.join(b.allocator, &[_][]const u8{ grub_build_path, "pluto.elf" });
cp_elf_cmd.addArtifactArg(exec);
cp_elf_cmd.addArg(elf_path);
cp_elf_cmd.step.dependOn(&grub_cmd.step);
cp_elf_cmd.step.dependOn(&exec.step);
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 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 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_path = try fs.path.join(b.allocator, &[_][]const u8{ modules_path, "kernel.map" });
const map_file_cmd = b.addSystemCommand(&[_][]const u8{ "./make_map.sh", elf_path, map_file_path });
map_file_cmd.step.dependOn(&cp_elf_cmd.step);
map_file_cmd.step.dependOn(&mkdir_modules_cmd.step);
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);
b.default_step.dependOn(&iso_cmd.step);
@ -69,7 +69,7 @@ pub fn build(b: *Builder) !void {
.i386 => "qemu-system-i386",
else => unreachable,
};
const qemu_args = [_][]const u8{
const qemu_args = &[_][]const u8{
qemu_bin,
"-cdrom",
iso_path,
@ -80,10 +80,10 @@ pub fn build(b: *Builder) !void {
};
const qemu_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) {
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_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");
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);
} else {
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 symbol_file_arg = try std.mem.join(b.allocator, " ", [_][]const u8{ "symbol-file", elf_path });
const debug_cmd = b.addSystemCommand([_][]const u8{
const symbol_file_arg = try std.mem.join(b.allocator, " ", &[_][]const u8{ "symbol-file", elf_path });
const debug_cmd = b.addSystemCommand(&[_][]const u8{
"gdb",
"-ex",
symbol_file_arg,
});
debug_cmd.addArgs([_][]const u8{
debug_cmd.addArgs(&[_][]const u8{
"-ex",
"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.
///
pub fn init() void {
log.logInfo("Init gdt\n");
log.logInfo("Init gdt\n", .{});
// Initiate TSS
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
arch.ltr(TSS_OFFSET);
log.logInfo("Done\n");
log.logInfo("Done\n", .{});
if (build_options.rt_test) runtimeTests();
}
@ -639,7 +639,7 @@ test "init" {
arch.initTest();
defer arch.freeTest();
arch.addTestParams("ltr", TSS_OFFSET);
arch.addTestParams("ltr", .{TSS_OFFSET});
arch.addConsumeFunction("lgdt", mock_lgdt);
@ -681,5 +681,5 @@ fn rt_loadedGDTSuccess() void {
///
fn runtimeTests() void {
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
///
pub fn init() void {
log.logInfo("Init idt\n");
log.logInfo("Init idt\n", .{});
idt_ptr.base = @intCast(u32, @ptrToInt(&idt_entries));
arch.lidt(&idt_ptr);
log.logInfo("Done\n");
log.logInfo("Done\n", .{});
if (build_options.rt_test) runtimeTests();
}
@ -327,7 +327,7 @@ fn rt_loadedIDTSuccess() void {
const loaded_idt = arch.sidt();
expect(idt_ptr.limit == loaded_idt.limit);
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 {
// Get the IRQ index, by getting the interrupt number and subtracting the 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;
@ -59,10 +59,10 @@ export fn irqHandler(ctx: *arch.InterruptContext) void {
pic.sendEndOfInterrupt(irq_num);
}
} else {
panic(@errorReturnTrace(), "IRQ not registered: {}", irq_num);
panic(@errorReturnTrace(), "IRQ not registered: {}", .{irq_num});
}
} 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 {
idt.openInterruptGate(index, handler) catch |err| switch (err) {
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.
///
pub fn init() void {
log.logInfo("Init irq\n");
log.logInfo("Init irq\n", .{});
comptime var i = IRQ_OFFSET;
inline while (i < IRQ_OFFSET + 16) : (i += 1) {
openIrq(i, interrupts.getInterruptStub(i));
}
log.logInfo("Done\n");
log.logInfo("Done\n", .{});
if (build_options.rt_test) runtimeTests();
}
@ -152,7 +152,7 @@ test "openIrq" {
const handler = testFunction0;
const ret: idt.IdtError!void = {};
idt.addTestParams("openInterruptGate", index, handler, ret);
idt.addTestParams("openInterruptGate", .{ index, handler, ret });
openIrq(index, handler);
}
@ -171,7 +171,7 @@ test "registerIrq re-register irq handler" {
pic.initTest();
defer pic.freeTest();
pic.addTestParams("clearMask", @as(u16, 0));
pic.addTestParams("clearMask", .{@as(u16, 0)});
// Pre testing
for (irq_handlers) |h| {
@ -200,7 +200,7 @@ test "registerIrq register irq handler" {
pic.initTest();
defer pic.freeTest();
pic.addTestParams("clearMask", @as(u16, 0));
pic.addTestParams("clearMask", .{@as(u16, 0)});
// Pre testing
for (irq_handlers) |h| {
@ -234,11 +234,11 @@ fn rt_unregisteredHandlers() void {
// Ensure all ISR are not registered yet
for (irq_handlers) |h, i| {
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| {
if (i >= IRQ_OFFSET and isValidIrq(i - IRQ_OFFSET)) {
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| {
handler(ctx);
} else {
panic(@errorReturnTrace(), "Syscall handler not registered\n");
panic(@errorReturnTrace(), "Syscall handler not registered\n", .{});
}
} else {
if (isr_handlers[isr_num]) |handler| {
// Regular ISR exception, if there is one registered.
handler(ctx);
} 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 {
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 {
idt.openInterruptGate(index, handler) catch |err| switch (err) {
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.
///
pub fn init() void {
log.logInfo("Init isr\n");
log.logInfo("Init isr\n", .{});
comptime var i = 0;
inline while (i < 32) : (i += 1) {
@ -243,7 +243,7 @@ pub fn init() void {
openIsr(syscalls.INTERRUPT, interrupts.getInterruptStub(syscalls.INTERRUPT));
log.logInfo("Done\n");
log.logInfo("Done\n", .{});
if (build_options.rt_test) runtimeTests();
}
@ -262,7 +262,7 @@ test "openIsr" {
const handler = testFunction0;
const ret: idt.IdtError!void = {};
idt.addTestParams("openInterruptGate", index, handler, ret);
idt.addTestParams("openInterruptGate", .{ index, handler, ret });
openIsr(index, handler);
}
@ -363,15 +363,15 @@ fn rt_unregisteredHandlers() void {
// Ensure all ISR are not registered yet
for (isr_handlers) |h, i| {
if (h) |_| {
panic(@errorReturnTrace(), "Handler found for ISR: {}-{}\n", i, h);
panic(@errorReturnTrace(), "Handler found for ISR: {}-{}\n", .{ i, 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| {
if (isValidIsr(i)) {
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
///
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
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);
@ -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);
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);
@memset(@ptrCast([*]u8, kernel_directory), 0, @sizeOf(Directory));
// Map in kernel
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();
// 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_buff_size = 32 * 1024;
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) {
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| {
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_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| {
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_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| {
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)
);
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);
}
@ -482,7 +482,7 @@ fn rt_accessUnmappedMem(v_end: u32) void {
\\rt_fault_callback:
);
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 {
@ -496,7 +496,7 @@ fn rt_accessMappedMem(v_end: u32) void {
\\rt_fault_callback2:
);
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 {

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.
///
pub fn init() void {
log.logInfo("Init pic\n");
log.logInfo("Init pic\n", .{});
// Initiate
sendCommandMaster(ICW1_INITIALISATION | ICW1_EXPECT_ICW4);
@ -454,7 +454,7 @@ pub fn init() void {
sendDataMaster(0xFF);
sendDataSlave(0xFF);
log.logInfo("Done\n");
log.logInfo("Done\n", .{});
if (build_options.rt_test) runtimeTests();
}
@ -466,7 +466,7 @@ test "sendCommandMaster" {
const cmd: u8 = 10;
arch.addTestParams("outb", MASTER_COMMAND_REG, cmd);
arch.addTestParams("outb", .{ MASTER_COMMAND_REG, cmd });
sendCommandMaster(cmd);
}
@ -478,7 +478,7 @@ test "sendCommandSlave" {
const cmd: u8 = 10;
arch.addTestParams("outb", SLAVE_COMMAND_REG, cmd);
arch.addTestParams("outb", .{ SLAVE_COMMAND_REG, cmd });
sendCommandSlave(cmd);
}
@ -490,7 +490,7 @@ test "sendDataMaster" {
const data: u8 = 10;
arch.addTestParams("outb", MASTER_DATA_REG, data);
arch.addTestParams("outb", .{ MASTER_DATA_REG, data });
sendDataMaster(data);
}
@ -502,7 +502,7 @@ test "sendDataSlave" {
const data: u8 = 10;
arch.addTestParams("outb", SLAVE_DATA_REG, data);
arch.addTestParams("outb", .{ SLAVE_DATA_REG, data });
sendDataSlave(data);
}
@ -512,7 +512,7 @@ test "readDataMaster" {
arch.initTest();
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());
}
@ -522,7 +522,7 @@ test "readDataSlave" {
arch.initTest();
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());
}
@ -532,8 +532,8 @@ test "readMasterIrr" {
arch.initTest();
defer arch.freeTest();
arch.addTestParams("outb", MASTER_COMMAND_REG, @as(u8, 0x0A));
arch.addTestParams("inb", MASTER_STATUS_REG, @as(u8, 10));
arch.addTestParams("outb", .{ MASTER_COMMAND_REG, @as(u8, 0x0A) });
arch.addTestParams("inb", .{ MASTER_STATUS_REG, @as(u8, 10) });
expectEqual(@as(u8, 10), readMasterIrr());
}
@ -543,8 +543,8 @@ test "readSlaveIrr" {
arch.initTest();
defer arch.freeTest();
arch.addTestParams("outb", SLAVE_COMMAND_REG, @as(u8, 0x0A));
arch.addTestParams("inb", SLAVE_STATUS_REG, @as(u8, 10));
arch.addTestParams("outb", .{ SLAVE_COMMAND_REG, @as(u8, 0x0A) });
arch.addTestParams("inb", .{ SLAVE_STATUS_REG, @as(u8, 10) });
expectEqual(@as(u8, 10), readSlaveIrr());
}
@ -554,8 +554,8 @@ test "readMasterIsr" {
arch.initTest();
defer arch.freeTest();
arch.addTestParams("outb", MASTER_COMMAND_REG, @as(u8, 0x0B));
arch.addTestParams("inb", MASTER_STATUS_REG, @as(u8, 10));
arch.addTestParams("outb", .{ MASTER_COMMAND_REG, @as(u8, 0x0B) });
arch.addTestParams("inb", .{ MASTER_STATUS_REG, @as(u8, 10) });
expectEqual(@as(u8, 10), readMasterIsr());
}
@ -565,8 +565,8 @@ test "readSlaveIsr" {
arch.initTest();
defer arch.freeTest();
arch.addTestParams("outb", SLAVE_COMMAND_REG, @as(u8, 0x0B));
arch.addTestParams("inb", SLAVE_STATUS_REG, @as(u8, 10));
arch.addTestParams("outb", .{ SLAVE_COMMAND_REG, @as(u8, 0x0B) });
arch.addTestParams("inb", .{ SLAVE_STATUS_REG, @as(u8, 10) });
expectEqual(@as(u8, 10), readSlaveIsr());
}
@ -578,7 +578,7 @@ test "sendEndOfInterrupt master only" {
var i: u8 = 0;
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);
}
@ -591,8 +591,8 @@ test "sendEndOfInterrupt master and slave" {
var i: u8 = 8;
while (i < 16) : (i += 1) {
arch.addTestParams("outb", SLAVE_COMMAND_REG, OCW2_END_OF_INTERRUPT);
arch.addTestParams("outb", MASTER_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 });
sendEndOfInterrupt(i);
}
@ -621,9 +621,9 @@ test "spuriousIrq spurious master IRQ number not spurious" {
arch.initTest();
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
arch.addTestParams("inb", MASTER_STATUS_REG, @as(u8, 0x80));
arch.addTestParams("inb", .{ MASTER_STATUS_REG, @as(u8, 0x80) });
// Pre testing
expectEqual(@as(u32, 0), spurious_irq_counter);
@ -643,9 +643,9 @@ test "spuriousIrq spurious master IRQ number spurious" {
arch.initTest();
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
arch.addTestParams("inb", MASTER_STATUS_REG, @as(u8, 0x0));
arch.addTestParams("inb", .{ MASTER_STATUS_REG, @as(u8, 0x0) });
// Pre testing
expectEqual(@as(u32, 0), spurious_irq_counter);
@ -665,9 +665,9 @@ test "spuriousIrq spurious slave IRQ number not spurious" {
arch.initTest();
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
arch.addTestParams("inb", SLAVE_STATUS_REG, @as(u8, 0x80));
arch.addTestParams("inb", .{ SLAVE_STATUS_REG, @as(u8, 0x80) });
// Pre testing
expectEqual(@as(u32, 0), spurious_irq_counter);
@ -687,11 +687,11 @@ test "spuriousIrq spurious slave IRQ number spurious" {
arch.initTest();
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
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
arch.addTestParams("outb", MASTER_COMMAND_REG, OCW2_END_OF_INTERRUPT);
arch.addTestParams("outb", .{ MASTER_COMMAND_REG, OCW2_END_OF_INTERRUPT });
// Pre testing
expectEqual(@as(u32, 0), spurious_irq_counter);
@ -712,9 +712,9 @@ test "setMask master IRQ masked" {
defer arch.freeTest();
// 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
arch.addTestParams("outb", MASTER_DATA_REG, @as(u8, 0xFF));
arch.addTestParams("outb", .{ MASTER_DATA_REG, @as(u8, 0xFF) });
setMask(1);
}
@ -725,9 +725,9 @@ test "setMask master IRQ unmasked" {
defer arch.freeTest();
// 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
arch.addTestParams("outb", MASTER_DATA_REG, @as(u8, 0xFF));
arch.addTestParams("outb", .{ MASTER_DATA_REG, @as(u8, 0xFF) });
setMask(1);
}
@ -738,9 +738,9 @@ test "clearMask master IRQ masked" {
defer arch.freeTest();
// 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
arch.addTestParams("outb", MASTER_DATA_REG, @as(u8, 0xFD));
arch.addTestParams("outb", .{ MASTER_DATA_REG, @as(u8, 0xFD) });
clearMask(1);
}
@ -751,9 +751,9 @@ test "clearMask master IRQ unmasked" {
defer arch.freeTest();
// 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
arch.addTestParams("outb", MASTER_DATA_REG, @as(u8, 0xFD));
arch.addTestParams("outb", .{ MASTER_DATA_REG, @as(u8, 0xFD) });
clearMask(1);
}
@ -764,8 +764,7 @@ test "init" {
defer arch.freeTest();
// Just a long list of OUT instructions setting up the PIC
arch.addTestParams(
"outb",
arch.addTestParams("outb", .{
MASTER_COMMAND_REG,
ICW1_INITIALISATION | ICW1_EXPECT_ICW4,
SLAVE_COMMAND_REG,
@ -786,7 +785,7 @@ test "init" {
@as(u8, 0xFF),
SLAVE_DATA_REG,
@as(u8, 0xFF),
);
});
init();
}
@ -796,14 +795,14 @@ test "init" {
///
fn rt_picAllMasked() void {
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) {
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.
///
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
const freq: u32 = 10000;
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)
irq.registerIrq(pic.IRQ_PIT, pitHandler) catch |err| switch (err) {
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 => {
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();
}
@ -400,7 +400,7 @@ test "sendCommand" {
const cmd: u8 = 10;
arch.addTestParams("outb", COMMAND_REGISTER, cmd);
arch.addTestParams("outb", .{ COMMAND_REGISTER, cmd });
sendCommand(cmd);
}
@ -411,8 +411,8 @@ test "readBackCommand" {
const cmd: u8 = 0xC2;
arch.addTestParams("outb", COMMAND_REGISTER, cmd);
arch.addTestParams("inb", COUNTER_0_REGISTER, @as(u8, 0x20));
arch.addTestParams("outb", .{ COMMAND_REGISTER, cmd });
arch.addTestParams("inb", .{ COUNTER_0_REGISTER, @as(u8, 0x20) });
const actual = readBackCommand(CounterSelect.Counter0);
@ -425,7 +425,7 @@ test "sendDataToCounter" {
const data: u8 = 10;
arch.addTestParams("outb", COUNTER_0_REGISTER, data);
arch.addTestParams("outb", .{ COUNTER_0_REGISTER, 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 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;
@ -551,10 +551,10 @@ fn rt_waitTicks() void {
const difference = getTicks() - waiting;
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;
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
ticks = 0;
@ -593,16 +593,14 @@ fn rt_initCounter_0() void {
const expected_hz: u32 = 10027;
if (time_ns != expected_ns or time_under_1_ns != expected_ps or getFrequency() != expected_hz) {
panic(
@errorReturnTrace(),
"Frequency not set properly. Hz: {}!={}, ns: {}!={}, ps: {}!= {}\n",
panic(@errorReturnTrace(), "Frequency not set properly. Hz: {}!={}, ns: {}!={}, ps: {}!= {}\n", .{
getFrequency(),
expected_hz,
time_ns,
expected_ns,
time_under_1_ns,
expected_ps,
);
});
}
var irq_exists = false;
@ -613,22 +611,22 @@ fn rt_initCounter_0() void {
irq_exists = true;
},
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) {
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 actual_mode = readBackCommand(CounterSelect.Counter0);
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| {
ctx.eax = handler(ctx, syscallArg(ctx, 0), syscallArg(ctx, 1), syscallArg(ctx, 2), syscallArg(ctx, 3), syscallArg(ctx, 4));
} else {
log.logWarning("Syscall {} triggered but not registered\n", syscall);
log.logWarning("Syscall {} triggered but not registered\n", .{syscall});
}
} 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.
///
pub fn init() void {
log.logInfo("Init syscalls\n");
log.logInfo("Init syscalls\n", .{});
isr.registerIsr(INTERRUPT, handle) catch unreachable;
log.logInfo("Done\n");
log.logInfo("Done\n", .{});
if (options.rt_test) runtimeTests();
}
@ -294,20 +294,20 @@ fn runtimeTests() void {
assert(testInt == 0);
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)
log.logInfo("Syscalls: Tested 1 arg\n");
log.logInfo("Syscalls: Tested 1 arg\n", .{});
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)
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)
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)
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
pub fn panic(msg: []const u8, error_return_trace: ?*builtin.StackTrace) noreturn {
@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 {
if (mb_magic == multiboot.MULTIBOOT_BOOTLOADER_MAGIC) {
// Booted with compatible bootloader
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)
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 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);
log.logInfo("Arch init done\n");
log.logInfo("Arch init done\n", .{});
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();
tty.init();
log.logInfo("Init done\n");
tty.print("Hello Pluto from kernel :)\n");
log.logInfo("Init done\n", .{});
tty.print("Hello Pluto from kernel :)\n", .{});
// The panic runtime tests must run last as they never return
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);
}
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;
}
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);
}
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);
}
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);
}
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);
}
pub fn runtimeTests() void {
inline for (@typeInfo(Level).Enum.fields) |field| {
const level = @field(Level, field.name);
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\n", .{});
log(level, "Test " ++ field.name ++ " level with args {}, {}\n", .{ "a", @as(u32, 1) });
const logFn = switch (level) {
.INFO => logInfo,
.DEBUG => logDebug,
.WARNING => logWarning,
.ERROR => logError,
};
logFn("Test " ++ field.name ++ " function\n");
logFn("Test " ++ field.name ++ " function with args {}, {}\n", "a", @as(u32, 1));
logFn("Test " ++ field.name ++ " function\n", .{});
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.
///
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;
ADDR_OFFSET = @ptrToInt(&KERNEL_ADDR_OFFSET);
const mem_profile = MemProfile{
@ -59,7 +59,7 @@ pub fn init(mb_info: *multiboot.multiboot_info_t) MemProfile {
.fixed_alloc_size = FIXED_ALLOC_SIZE,
.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;
}
@ -69,11 +69,11 @@ pub fn init(mb_info: *multiboot.multiboot_info_t) MemProfile {
/// Arguments:
/// IN virt: var - The virtual address to covert. Either an integer or pointer.
///
/// Return: @typeOf(virt)
/// Return: @TypeOf(virt)
/// The physical address.
///
pub inline fn virtToPhys(virt: var) @typeOf(virt) {
const T = @typeOf(virt);
pub inline fn virtToPhys(virt: var) @TypeOf(virt) {
const T = @TypeOf(virt);
return switch (@typeId(T)) {
.Pointer => @intToPtr(T, @ptrToInt(virt) - ADDR_OFFSET),
.Int => virt - ADDR_OFFSET,
@ -87,11 +87,11 @@ pub inline fn virtToPhys(virt: var) @typeOf(virt) {
/// Arguments:
/// IN phys: var - The physical address to covert. Either an integer or pointer.
///
/// Return: @typeOf(virt)
/// Return: @TypeOf(virt)
/// The virtual address.
///
pub inline fn physToVirt(phys: var) @typeOf(phys) {
const T = @typeOf(phys);
pub inline fn physToVirt(phys: var) @TypeOf(phys) {
const T = @TypeOf(phys);
return switch (@typeId(T)) {
.Pointer => @intToPtr(T, @ptrToInt(phys) + ADDR_OFFSET),
.Int => phys + ADDR_OFFSET,
@ -104,7 +104,7 @@ test "physToVirt" {
const offset: usize = ADDR_OFFSET;
expectEqual(physToVirt(@as(usize, 0)), offset + 0);
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" {
@ -112,5 +112,5 @@ test "virtToPhys" {
const offset: usize = ADDR_OFFSET;
expectEqual(virtToPhys(offset + 0), 0);
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_uint16_t = c_ushort;
pub const multiboot_uint32_t = c_uint;
@ -109,72 +108,75 @@ pub const struct_multiboot_apm_info = extern struct {
dseg_len: multiboot_uint16_t,
};
pub const __GCC_ATOMIC_TEST_AND_SET_TRUEVAL = 1;
pub const __FLT16_MAX_EXP__ = 15;
pub const __BIGGEST_ALIGNMENT__ = 16;
pub const __SIZEOF_FLOAT__ = 4;
pub const __INT64_FMTd__ = c"ld";
pub const __STDC_VERSION__ = c_long(201112);
pub const __INT_LEAST32_FMTi__ = c"i";
pub const __INT_LEAST8_FMTi__ = c"hhi";
pub const __LDBL_EPSILON__ = -nan;
pub const __INT64_FMTd__ = "ld";
pub const __STDC_VERSION__ = @as(c_long, 201112);
pub const __INT_LEAST32_FMTi__ = "i";
pub const __tune_znver1__ = 1;
pub const __INT_LEAST8_FMTi__ = "hhi";
pub const __LDBL_EPSILON__ = 0.000000;
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 __INVPCID__ = 1;
pub const __SIG_ATOMIC_WIDTH__ = 32;
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 __clang_version__ = c"8.0.0 (tags/RELEASE_800/rc5)";
pub const __UINT_LEAST8_FMTo__ = c"hho";
pub const __SEG_FS = 1;
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 __INTMAX_FMTd__ = c"ld";
pub const __INTMAX_FMTd__ = "ld";
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 __FMA__ = 1;
pub const __MMX__ = 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 __FSGSBASE__ = 1;
pub const __PTRDIFF_FMTd__ = c"ld";
pub const __PTRDIFF_FMTd__ = "ld";
pub const __DBL_MIN_EXP__ = -1021;
pub const __FLT_EVAL_METHOD__ = 0;
pub const __SSE_MATH__ = 1;
pub const __UINT_FAST8_FMTo__ = c"hho";
pub const __UINT_LEAST64_MAX__ = c_ulong(18446744073709551615);
pub const __UINT_FAST8_FMTo__ = "hho";
pub const __UINT_LEAST64_MAX__ = @as(c_ulong, 18446744073709551615);
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 __znver1 = 1;
pub const MULTIBOOT_MEMORY_AVAILABLE = 1;
pub const __DBL_HAS_DENORM__ = 1;
pub const __FLOAT128__ = 1;
pub const __FLT16_HAS_QUIET_NAN__ = 1;
pub const __ATOMIC_RELAXED = 0;
pub const __DBL_DECIMAL_DIG__ = 17;
pub const __XSAVEC__ = 1;
pub const MULTIBOOT_SEARCH = 8192;
pub const __SIZEOF_SHORT__ = 2;
pub const __UINT16_FMTX__ = c"hX";
pub const __UINT_FAST16_MAX__ = 65535;
pub const __UINT16_FMTX__ = "hX";
pub const __CLANG_ATOMIC_SHORT_LOCK_FREE = 2;
pub const __SSSE3__ = 1;
pub const __CONSTANT_CFSTRINGS__ = 1;
pub const __AVX2__ = 1;
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 __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 MULTIBOOT_FRAMEBUFFER_TYPE_EGA_TEXT = 2;
pub const __INT_FAST16_FMTi__ = c"hi";
pub const __PTRDIFF_WIDTH__ = 64;
pub const __INT_FAST16_FMTi__ = "hi";
pub const __INT_LEAST32_TYPE__ = int;
pub const __SCHAR_MAX__ = 127;
pub const __LDBL_DENORM_MIN__ = -nan;
pub const __FLT16_MIN_EXP__ = -14;
pub const __LDBL_DENORM_MIN__ = 0.000000;
pub const MULTIBOOT_INFO_AOUT_SYMS = 16;
pub const __PRFCHW__ = 1;
pub const __INT64_C_SUFFIX__ = L;
pub const __ELF__ = 1;
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 __SIZEOF_PTRDIFF_T__ = 8;
pub const __SIG_ATOMIC_MAX__ = 2147483647;
pub const __UINT64_FMTX__ = c"lX";
pub const __UINT64_MAX__ = c_ulong(18446744073709551615);
pub const __UINT64_FMTX__ = "lX";
pub const __UINT64_MAX__ = @as(c_ulong, 18446744073709551615);
pub const __DBL_MANT_DIG__ = 53;
pub const __FLT_DECIMAL_DIG__ = 9;
pub const __INT_LEAST32_MAX__ = 2147483647;
pub const __DBL_DIG__ = 15;
pub const __ATOMIC_ACQUIRE = 2;
pub const __OPENCL_MEMORY_SCOPE_WORK_GROUP = 1;
pub const __FLT16_HAS_DENORM__ = 1;
pub const __UINT_FAST16_FMTu__ = c"hu";
pub const __INTPTR_FMTi__ = c"li";
pub const __UINT_FAST16_FMTu__ = "hu";
pub const __INTPTR_FMTi__ = "li";
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 __SSE__ = 1;
pub const __FLT_HAS_QUIET_NAN__ = 1;
pub const __SIZEOF_SIZE_T__ = 8;
pub const __UINT_LEAST16_FMTo__ = c"ho";
pub const __UINT8_FMTo__ = c"hho";
pub const __UINT_LEAST16_FMTx__ = c"hx";
pub const __SEG_GS = 1;
pub const __UINT_LEAST16_FMTo__ = "ho";
pub const __UINT8_FMTo__ = "hho";
pub const __UINT_LEAST16_FMTx__ = "hx";
pub const __CLANG_ATOMIC_WCHAR_T_LOCK_FREE = 2;
pub const __UINT_FAST16_FMTX__ = c"hX";
pub const __VERSION__ = c"4.2.1 Compatible Clang 8.0.0 (tags/RELEASE_800/rc5)";
pub const __UINT_FAST32_FMTx__ = c"x";
pub const __UINTPTR_MAX__ = c_ulong(18446744073709551615);
pub const __UINT_FAST16_FMTX__ = "hX";
pub const __VERSION__ = "Clang 9.0.0 (tags/RELEASE_900/final)";
pub const __UINT_FAST32_FMTx__ = "x";
pub const __UINTPTR_MAX__ = @as(c_ulong, 18446744073709551615);
pub const MULTIBOOT_INFO_ALIGN = 4;
pub const __UINT_FAST8_FMTu__ = c"hhu";
pub const __UINT_LEAST8_FMTu__ = c"hhu";
pub const __UINT_LEAST64_FMTo__ = c"lo";
pub const __UINT_FAST8_FMTu__ = "hhu";
pub const __UINT_LEAST8_FMTu__ = "hhu";
pub const __UINT_LEAST64_FMTo__ = "lo";
pub const __UINT_LEAST8_MAX__ = 255;
pub const __RDRND__ = 1;
pub const __SIZEOF_WCHAR_T__ = 4;
pub const __MOVBE__ = 1;
pub const __LDBL_MAX__ = -nan;
pub const __LDBL_MAX__ = inf;
pub const __UINT16_MAX__ = 65535;
pub const _LP64 = 1;
pub const __x86_64 = 1;
@ -224,168 +226,165 @@ pub const __code_model_small_ = 1;
pub const linux = 1;
pub const __SIZEOF_WINT_T__ = 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 __UINT_LEAST8_FMTX__ = c"hhX";
pub const __UINT_LEAST8_FMTX__ = "hhX";
pub const __INT16_MAX__ = 32767;
pub const __WINT_UNSIGNED__ = 1;
pub const __FLT_MAX_10_EXP__ = 38;
pub const __UINTPTR_FMTX__ = c"lX";
pub const __UINT_LEAST16_FMTu__ = c"hu";
pub const __UINTPTR_FMTX__ = "lX";
pub const __UINT_LEAST16_FMTu__ = "hu";
pub const __CLANG_ATOMIC_POINTER_LOCK_FREE = 2;
pub const __WINT_WIDTH__ = 32;
pub const __F16C__ = 1;
pub const __SHRT_MAX__ = 32767;
pub const __znver1__ = 1;
pub const __GCC_ATOMIC_BOOL_LOCK_FREE = 2;
pub const __POINTER_WIDTH__ = 64;
pub const __PTRDIFF_MAX__ = c_long(9223372036854775807);
pub const __tune_corei7__ = 1;
pub const __FLT16_DIG__ = 3;
pub const __INT32_FMTd__ = c"d";
pub const __DBL_MIN__ = -nan;
pub const __PTRDIFF_MAX__ = @as(c_long, 9223372036854775807);
pub const __INT32_FMTd__ = "d";
pub const __DBL_MIN__ = 0.000000;
pub const __SIZEOF_LONG__ = 8;
pub const __INTPTR_WIDTH__ = 64;
pub const MULTIBOOT_INFO_VBE_INFO = 2048;
pub const __FLT16_MAX_10_EXP__ = 4;
pub const __INT_FAST32_TYPE__ = int;
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 __gnu_linux__ = 1;
pub const __INT_FAST32_MAX__ = 2147483647;
pub const __corei7__ = 1;
pub const __UINTMAX_FMTu__ = c"lu";
pub const __UINTMAX_FMTu__ = "lu";
pub const MULTIBOOT_FRAMEBUFFER_TYPE_INDEXED = 0;
pub const __BMI__ = 1;
pub const MULTIBOOT_INFO_BOOTDEV = 2;
pub const __FLT_RADIX__ = 2;
pub const MULTIBOOT_INFO_MEMORY = 1;
pub const __FLT16_HAS_INFINITY__ = 1;
pub const __GCC_HAVE_SYNC_COMPARE_AND_SWAP_1 = 1;
pub const MULTIBOOT_FRAMEBUFFER_TYPE_RGB = 1;
pub const __GCC_ATOMIC_INT_LOCK_FREE = 2;
pub const __OPENCL_MEMORY_SCOPE_ALL_SVM_DEVICES = 3;
pub const __FLT16_DECIMAL_DIG__ = 5;
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 MULTIBOOT_BOOTLOADER_MAGIC = 732803074;
pub const __UINTMAX_WIDTH__ = 64;
pub const __FLT_MIN__ = -nan;
pub const __INT64_FMTi__ = c"li";
pub const __UINT_FAST64_FMTu__ = c"lu";
pub const __INT8_FMTd__ = c"hhd";
pub const __FLT_MIN__ = 0.000000;
pub const __INT64_FMTi__ = "li";
pub const __UINT_FAST64_FMTu__ = "lu";
pub const __INT8_FMTd__ = "hhd";
pub const __INT_FAST16_TYPE__ = short;
pub const __FLT_MAX_EXP__ = 128;
pub const __XSAVE__ = 1;
pub const __DBL_MAX_10_EXP__ = 308;
pub const __LDBL_MIN__ = -nan;
pub const __INT_FAST64_FMTi__ = c"li";
pub const __INT_LEAST8_FMTd__ = c"hhd";
pub const __LDBL_MIN__ = 0.000000;
pub const __INT_FAST64_FMTi__ = "li";
pub const __INT_LEAST8_FMTd__ = "hhd";
pub const __CLANG_ATOMIC_LLONG_LOCK_FREE = 2;
pub const __UINT_LEAST32_FMTX__ = c"X";
pub const __UINTMAX_MAX__ = c_ulong(18446744073709551615);
pub const __UINT_FAST16_FMTo__ = c"ho";
pub const __UINT_LEAST32_FMTX__ = "X";
pub const __UINTMAX_MAX__ = @as(c_ulong, 18446744073709551615);
pub const __UINT_FAST16_FMTo__ = "ho";
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 __SIZEOF_FLOAT128__ = 16;
pub const __UINT_FAST64_FMTo__ = c"lo";
pub const __SIZE_FMTx__ = c"lx";
pub const __DBL_MAX__ = -nan;
pub const __DBL_EPSILON__ = -nan;
pub const __UINT64_FMTx__ = c"lx";
pub const __UINT_FAST64_FMTo__ = "lo";
pub const __SIZE_FMTx__ = "lx";
pub const __DBL_MAX__ = 179769313486231570814527423731704356798070567525844996598917476803157260780028538760589558632766878;
pub const __DBL_EPSILON__ = 0.000000;
pub const __UINT64_FMTx__ = "lx";
pub const MULTIBOOT_HEADER = 1;
pub const __CLWB__ = 1;
pub const __CHAR_BIT__ = 8;
pub const __INT16_FMTi__ = c"hi";
pub const __INT16_FMTi__ = "hi";
pub const _DEBUG = 1;
pub const __GNUC_MINOR__ = 2;
pub const __UINT_FAST32_MAX__ = c_uint(4294967295);
pub const __UINT8_FMTX__ = c"hhX";
pub const __FLT_EPSILON__ = -nan;
pub const __UINT_FAST32_MAX__ = @as(c_uint, 4294967295);
pub const __UINT8_FMTX__ = "hhX";
pub const __FLT_EPSILON__ = 0.000000;
pub const __UINTPTR_WIDTH__ = 64;
pub const __llvm__ = 1;
pub const __UINT_FAST64_MAX__ = c_ulong(18446744073709551615);
pub const __INT_FAST32_FMTi__ = c"i";
pub const __UINT_FAST64_MAX__ = @as(c_ulong, 18446744073709551615);
pub const __INT_FAST32_FMTi__ = "i";
pub const __FLT_HAS_INFINITY__ = 1;
pub const __AES__ = 1;
pub const __UINT8_FMTx__ = c"hhx";
pub const __UINT8_FMTx__ = "hhx";
pub const __INTMAX_C_SUFFIX__ = L;
pub const __ORDER_LITTLE_ENDIAN__ = 1234;
pub const __GCC_ATOMIC_CHAR16_T_LOCK_FREE = 2;
pub const __INT16_FMTd__ = c"hd";
pub const __UINT32_FMTX__ = c"X";
pub const __INT16_FMTd__ = "hd";
pub const __UINT32_FMTX__ = "X";
pub const __GCC_HAVE_SYNC_COMPARE_AND_SWAP_4 = 1;
pub const __UINT32_C_SUFFIX__ = U;
pub const __INT32_MAX__ = 2147483647;
pub const __GCC_ATOMIC_CHAR_LOCK_FREE = 2;
pub const __INTMAX_WIDTH__ = 64;
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 __INT_FAST8_FMTi__ = c"hhi";
pub const __UINT_LEAST32_FMTo__ = c"o";
pub const __INT_FAST8_FMTi__ = "hhi";
pub const __UINT_LEAST32_FMTo__ = "o";
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 __UINT_FAST16_FMTx__ = c"hx";
pub const __UINT_FAST16_FMTx__ = "hx";
pub const __UINTMAX_C_SUFFIX__ = UL;
pub const __FLT_MIN_EXP__ = -125;
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 __GCC_ATOMIC_LONG_LOCK_FREE = 2;
pub const __ORDER_PDP_ENDIAN__ = 3412;
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 __GXX_ABI_VERSION = 1002;
pub const __INT16_TYPE__ = short;
pub const __MWAITX__ = 1;
pub const __SSE2_MATH__ = 1;
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 __INT_FAST8_MAX__ = 127;
pub const __INTPTR_FMTd__ = c"ld";
pub const __INTPTR_FMTd__ = "ld";
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 __INT_LEAST64_FMTi__ = c"li";
pub const __INT_LEAST64_FMTi__ = "li";
pub const __SSE4_2__ = 1;
pub const __AVX__ = 1;
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 __UINT64_FMTu__ = c"lu";
pub const __UINT64_FMTu__ = "lu";
pub const __BYTE_ORDER__ = __ORDER_LITTLE_ENDIAN__;
pub const __SSE2__ = 1;
pub const MULTIBOOT_INFO_FRAMEBUFFER_INFO = 4096;
pub const __INT_MAX__ = 2147483647;
pub const __INTMAX_FMTi__ = c"li";
pub const __DBL_DENORM_MIN__ = -nan;
pub const __INTMAX_FMTi__ = "li";
pub const __DBL_DENORM_MIN__ = 0.000000;
pub const MULTIBOOT_INFO_APM_TABLE = 1024;
pub const __clang_major__ = 8;
pub const __FLT16_MANT_DIG__ = 11;
pub const __clang_major__ = 9;
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 __FLT_DENORM_MIN__ = -nan;
pub const __FLT_DENORM_MIN__ = 0.000000;
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 __XSAVES__ = 1;
pub const __LDBL_HAS_DENORM__ = 1;
pub const __FLT16_MIN_10_EXP__ = -13;
pub const __LDBL_HAS_QUIET_NAN__ = 1;
pub const __UINT_FAST8_MAX__ = 255;
pub const __DBL_MIN_10_EXP__ = -307;
pub const __UINT8_FMTu__ = c"hhu";
pub const __INT_FAST64_MAX__ = c_long(9223372036854775807);
pub const __UINT8_FMTu__ = "hhu";
pub const __SSE4A__ = 1;
pub const __INT_FAST64_MAX__ = @as(c_long, 9223372036854775807);
pub const __SSE3__ = 1;
pub const __UINT16_FMTu__ = c"hu";
pub const __UINT16_FMTu__ = "hu";
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 __UINT_FAST32_FMTu__ = c"u";
pub const __UINT_FAST32_FMTu__ = "u";
pub const __clang_patchlevel__ = 0;
pub const __SIZEOF_LONG_LONG__ = 8;
pub const __BMI2__ = 1;
@ -395,35 +394,34 @@ pub const __PCLMUL__ = 1;
pub const __FXSR__ = 1;
pub const __UINT8_MAX__ = 255;
pub const __GCC_HAVE_SYNC_COMPARE_AND_SWAP_2 = 1;
pub const __UINT32_FMTx__ = c"x";
pub const __UINT16_FMTo__ = c"ho";
pub const __UINT32_FMTx__ = "x";
pub const __UINT16_FMTo__ = "ho";
pub const __POPCNT__ = 1;
pub const __OPENCL_MEMORY_SCOPE_DEVICE = 2;
pub const MULTIBOOT_VIDEO_MODE = 4;
pub const __UINT32_FMTu__ = c"u";
pub const __UINT32_FMTu__ = "u";
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 __INT_FAST16_FMTd__ = c"hd";
pub const __INT_FAST16_FMTd__ = "hd";
pub const unix = 1;
pub const __UINT_LEAST32_FMTu__ = c"u";
pub const __FLT_MAX__ = -nan;
pub const __corei7 = 1;
pub const __UINT_LEAST32_FMTu__ = "u";
pub const __FLT_MAX__ = 340282346999999984391321947108527833088.000000;
pub const __GCC_ATOMIC_WCHAR_T_LOCK_FREE = 2;
pub const __ATOMIC_CONSUME = 1;
pub const __unix__ = 1;
pub const __x86_64__ = 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 __INT_LEAST16_MAX__ = 32767;
pub const __FLT_MIN_10_EXP__ = -37;
pub const __UINT32_FMTo__ = c"o";
pub const __UINTPTR_FMTo__ = c"lo";
pub const __INT_LEAST16_FMTd__ = c"hd";
pub const __UINTPTR_FMTx__ = c"lx";
pub const __INT_LEAST16_MAX__ = 32767;
pub const __UINT32_FMTo__ = "o";
pub const __UINTPTR_FMTo__ = "lo";
pub const __INT_LEAST16_FMTd__ = "hd";
pub const __UINTPTR_FMTx__ = "lx";
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 MULTIBOOT_HEADER_MAGIC = 464367618;
pub const __ORDER_BIG_ENDIAN__ = 4321;
@ -432,45 +430,51 @@ pub const __INT_LEAST8_MAX__ = 127;
pub const __SIZEOF_INT__ = 4;
pub const __GCC_ATOMIC_POINTER_LOCK_FREE = 2;
pub const MULTIBOOT_INFO_DRIVE_INFO = 128;
pub const __SHA__ = 1;
pub const MULTIBOOT_MEMORY_INFO = 2;
pub const __amd64 = 1;
pub const __OBJC_BOOL_IS_BOOL = 0;
pub const __ADX__ = 1;
pub const __LDBL_MAX_10_EXP__ = 4932;
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 __UINT16_FMTx__ = c"hx";
pub const __UINTPTR_FMTu__ = c"lu";
pub const __UINT_LEAST16_FMTX__ = c"hX";
pub const __UINT16_FMTx__ = "hx";
pub const __UINTPTR_FMTu__ = "lu";
pub const __UINT_LEAST16_FMTX__ = "hX";
pub const __CLFLUSHOPT__ = 1;
pub const __amd64__ = 1;
pub const __UINT_FAST32_FMTo__ = c"o";
pub const __UINT_FAST32_FMTo__ = "o";
pub const __linux__ = 1;
pub const __clang__ = 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 __LDBL_DIG__ = 18;
pub const __GCC_ATOMIC_CHAR32_T_LOCK_FREE = 2;
pub const __XSAVEOPT__ = 1;
pub const __UINT64_FMTo__ = c"lo";
pub const __INT_FAST32_FMTd__ = c"d";
pub const __UINT64_FMTo__ = "lo";
pub const __INT_FAST32_FMTd__ = "d";
pub const __ATOMIC_ACQ_REL = 4;
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 MULTIBOOT_MEMORY_NVS = 4;
pub const __RDPID__ = 1;
pub const MULTIBOOT_INFO_MEM_MAP = 64;
pub const __INTMAX_MAX__ = c_long(9223372036854775807);
pub const __UINT_LEAST32_FMTx__ = c"x";
pub const __INTMAX_MAX__ = @as(c_long, 9223372036854775807);
pub const __UINT_LEAST32_FMTx__ = "x";
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 __INT_LEAST64_MAX__ = c_long(9223372036854775807);
pub const __UINTMAX_FMTX__ = c"lX";
pub const __INT_LEAST64_MAX__ = @as(c_long, 9223372036854775807);
pub const __UINTMAX_FMTX__ = "lX";
pub const __OPENCL_MEMORY_SCOPE_WORK_ITEM = 0;
pub const __FLT_HAS_DENORM__ = 1;
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 __FINITE_MATH_ONLY__ = 0;
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.
///
pub fn search(self: *const SymbolMap, addr: usize) ?[]const u8 {
if (self.symbols.count() == 0)
if (self.symbols.len == 0)
return null;
// Find the first element whose address is greater than addr
var previous_name: ?[]const u8 = null;
var it = self.symbols.iterator();
while (it.next()) |entry| {
for (self.symbols.toSliceConst()) |entry| {
if (entry.addr > addr)
return previous_name;
previous_name = entry.func_name;
@ -102,10 +101,10 @@ var symbol_map: ?SymbolMap = null;
///
fn logTraceAddress(addr: usize) void {
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);
log.logError("Kernel panic: " ++ format ++ "\n", args);
if (trace) |trc| {
@ -278,8 +277,8 @@ fn parseMapEntry(start: *[*]const u8, end: *const u8) !MapEntry {
/// std.fmt.ParseUnsignedError: See parseMapEntry.
///
pub fn init(mem_profile: *const mem.MemProfile, allocator: *std.mem.Allocator) !void {
log.logInfo("Init panic\n");
defer log.logInfo("Done\n");
log.logInfo("Init panic\n", .{});
defer log.logInfo("Done\n", .{});
// Exit if we haven't loaded all debug modules
if (mem_profile.boot_modules.len < 1)
return;
@ -288,7 +287,7 @@ pub fn init(mem_profile: *const mem.MemProfile, allocator: *std.mem.Allocator) !
for (mem_profile.boot_modules) |module| {
const mod_start = mem.physToVirt(module.mod_start);
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")) {
kmap_start = mod_start;
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);
// Send a byte to start setting the baudrate
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
arch.outb(port_int, @truncate(u8, divisor));
// Send the divisor's msb
arch.outb(port_int + 1, @truncate(u8, divisor >> 8));
// 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
arch.outb(port_int + 1, 0);
@ -212,5 +212,5 @@ fn rt_writeByte() void {
/// Test writing a series of bytes
///
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;
// 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| {
log.logError("TTY: Unable to print page number, buffer too small. Error: {}\n", 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});
return;
};
@ -194,7 +194,7 @@ fn displayPageNumber() void {
row = ROW_MIN - 1;
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.
// 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| {
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
@ -413,7 +413,7 @@ fn printLogo() void {
row = 0;
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:
/// 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
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;
// 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| {
log.logError("TTY: Error moving page up. Error: {}\n", e);
log.logError("TTY: Error moving page up. Error: {}\n", .{e});
};
displayPageNumber();
vga.disableCursor();
@ -473,7 +473,7 @@ pub fn pageDown() void {
page_index -= 1;
// 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| {
log.logError("TTY: Error moving page down. Error: {}\n", e);
log.logError("TTY: Error moving page down. Error: {}\n", .{e});
};
displayPageNumber();
@ -494,7 +494,7 @@ pub fn clearScreen() void {
// Move all the rows up
// This is within bounds, so shouldn't error
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
@ -569,7 +569,7 @@ pub fn getVideoBufferAddress() usize {
/// entry, print the logo and display the 0'th page.
///
pub fn init() void {
log.logInfo("Init tty\n");
log.logInfo("Init tty\n", .{});
// Video buffer in higher half
if (is_test) {
@ -615,13 +615,13 @@ pub fn init() void {
// Set the top 7 rows blank
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);
} else {
// Clear the screen
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
row = ROW_MIN;
@ -631,7 +631,7 @@ pub fn init() void {
displayPageNumber();
updateCursor();
log.logInfo("Done\n");
log.logInfo("Done\n", .{});
if (build_options.rt_test) runtimeTests();
}
@ -756,7 +756,7 @@ test "updateCursor" {
vga.initTest();
defer vga.freeTest();
vga.addTestParams("updateCursor", @as(u16, 0), @as(u16, 0));
vga.addTestParams("updateCursor", .{ @as(u16, 0), @as(u16, 0) });
// Pre testing
defaultAllTesting(0, 0, 0);
@ -779,7 +779,7 @@ test "getCursor zero" {
vga.initTest();
defer vga.freeTest();
vga.addTestParams("getCursor", @as(u16, 0));
vga.addTestParams("getCursor", .{@as(u16, 0)});
// Pre testing
defaultAllTesting(0, 0, 0);
@ -802,7 +802,7 @@ test "getCursor EEF" {
vga.initTest();
defer vga.freeTest();
vga.addTestParams("getCursor", @as(u16, 0x0EEF));
vga.addTestParams("getCursor", .{@as(u16, 0x0EEF)});
// Pre testing
defaultAllTesting(0, 0, 0);
@ -2036,7 +2036,7 @@ test "init 0,0" {
vga.initTest();
defer vga.freeTest();
vga.addTestParams("getCursor", @as(u16, 0));
vga.addTestParams("getCursor", .{@as(u16, 0)});
vga.addRepeatFunction("entryColour", vga.orig_entryColour);
vga.addRepeatFunction("entry", vga.orig_entry);
@ -2075,7 +2075,7 @@ test "init not 0,0" {
vga.initTest();
defer vga.freeTest();
vga.addTestParams("getCursor", vga.WIDTH);
vga.addTestParams("getCursor", .{vga.WIDTH});
vga.addRepeatFunction("entryColour", vga.orig_entryColour);
vga.addRepeatFunction("entry", vga.orig_entry);
@ -2111,19 +2111,19 @@ test "init not 0,0" {
///
fn rt_initialisedGlobals() void {
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) {
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)) {
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)) {
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
@ -2136,10 +2136,10 @@ fn rt_initialisedGlobals() void {
}
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 clear_text = "\x08" ** text.len;
print(text);
print(text, .{});
// Check the video memory
var counter: u32 = 0;
@ -2166,7 +2166,7 @@ fn rt_printString() void {
}
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
@ -2183,13 +2183,13 @@ fn rt_printString() void {
}
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
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.
///
pub fn init() void {
log.logInfo("Init vga\n");
log.logInfo("Init vga\n", .{});
// Set the maximum scan line to 0x0F
sendPortData(REG_MAXIMUM_SCAN_LINE, CURSOR_SCANLINE_END);
@ -294,7 +294,7 @@ pub fn init() void {
// Set by default the underline cursor
setCursorShape(CursorShape.UNDERLINE);
log.logInfo("Done\n");
log.logInfo("Done\n", .{});
if (build_options.rt_test) runtimeTests();
}
@ -345,7 +345,7 @@ test "updateCursor width out of bounds" {
defer arch.freeTest();
// 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);
}
@ -362,7 +362,7 @@ test "updateCursor height out of bounds" {
defer arch.freeTest();
// 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);
}
@ -379,7 +379,7 @@ test "updateCursor width and height out of bounds" {
defer arch.freeTest();
// 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);
}
@ -396,7 +396,7 @@ test "updateCursor width-1 and height out of bounds" {
defer arch.freeTest();
// 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);
}
@ -413,7 +413,7 @@ test "updateCursor width and height-1 out of bounds" {
defer arch.freeTest();
// 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);
}
@ -430,7 +430,7 @@ test "updateCursor in bounds" {
defer arch.freeTest();
// 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);
}
@ -441,10 +441,10 @@ test "getCursor 1: 10" {
arch.initTest();
defer arch.freeTest();
arch.addTestParams("outb", PORT_ADDRESS, REG_CURSOR_LOCATION_LOW);
arch.addTestParams("inb", PORT_DATA, @as(u8, 10));
arch.addTestParams("outb", PORT_ADDRESS, REG_CURSOR_LOCATION_HIGH);
arch.addTestParams("inb", PORT_DATA, @as(u8, 0));
arch.addTestParams("outb", .{ PORT_ADDRESS, REG_CURSOR_LOCATION_LOW });
arch.addTestParams("inb", .{ PORT_DATA, @as(u8, 10) });
arch.addTestParams("outb", .{ PORT_ADDRESS, REG_CURSOR_LOCATION_HIGH });
arch.addTestParams("inb", .{ PORT_DATA, @as(u8, 0) });
const actual = getCursor();
expectEqual(expect, actual);
@ -457,10 +457,10 @@ test "getCursor 2: 0xBEEF" {
arch.initTest();
defer arch.freeTest();
arch.addTestParams("outb", PORT_ADDRESS, REG_CURSOR_LOCATION_LOW);
arch.addTestParams("inb", PORT_DATA, @as(u8, 0xEF));
arch.addTestParams("outb", PORT_ADDRESS, REG_CURSOR_LOCATION_HIGH);
arch.addTestParams("inb", PORT_DATA, @as(u8, 0xBE));
arch.addTestParams("outb", .{ PORT_ADDRESS, REG_CURSOR_LOCATION_LOW });
arch.addTestParams("inb", .{ PORT_DATA, @as(u8, 0xEF) });
arch.addTestParams("outb", .{ PORT_ADDRESS, REG_CURSOR_LOCATION_HIGH });
arch.addTestParams("inb", .{ PORT_DATA, @as(u8, 0xBE) });
const actual = getCursor();
expectEqual(expect, actual);
@ -471,10 +471,12 @@ test "enableCursor" {
defer arch.freeTest();
// 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,
// Mocking out the arch.outb calls for enabling the cursor:
// 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);
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,
// Mocking out the arch.outb calls for enabling the cursor:
// 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();
enableCursor();
@ -485,7 +487,7 @@ test "disableCursor" {
defer arch.freeTest();
// 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();
}
@ -496,7 +498,7 @@ test "setCursorShape 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
// 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);
}
@ -508,7 +510,7 @@ test "setCursorShape 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
// 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);
}
@ -520,7 +522,7 @@ test "init" {
// 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
// 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();
}
@ -532,10 +534,10 @@ fn rt_correctMaxScanLine() void {
const max_scan_line = getPortData(REG_MAXIMUM_SCAN_LINE);
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 {
// Check the global variables are correct
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_end = getPortData(REG_CURSOR_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);
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
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 {
return mock_framework.performAction("outb", void, port, data);
return mock_framework.performAction("outb", void, .{ port, data });
}
pub fn inb(port: u16) u8 {
return mock_framework.performAction("inb", u8, port);
return mock_framework.performAction("inb", u8, .{port});
}
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 {
return mock_framework.performAction("lgdt", void, gdt_ptr);
return mock_framework.performAction("lgdt", void, .{gdt_ptr});
}
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 {
return mock_framework.performAction("ltr", void, offset);
return mock_framework.performAction("ltr", void, .{offset});
}
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 {
return mock_framework.performAction("sidt", idt.IdtPtr);
return mock_framework.performAction("sidt", idt.IdtPtr, .{});
}
pub fn enableInterrupts() void {
return mock_framework.performAction("enableInterrupts", void);
return mock_framework.performAction("enableInterrupts", void, .{});
}
pub fn disableInterrupts() void {
return mock_framework.performAction("disableInterrupts", void);
return mock_framework.performAction("disableInterrupts", void, .{});
}
pub fn halt() void {
return mock_framework.performAction("halt", void);
return mock_framework.performAction("halt", void, .{});
}
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;
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 {

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

@ -12,22 +12,22 @@ pub const Level = enum {
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);
}
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);
}
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);
}
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);
}
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);
}

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

@ -6,7 +6,7 @@ pub const MemProfile = struct {
physaddr_end: [*]u8,
physaddr_start: [*]u8,
mem_kb: u32,
fixed_alloc_size: u32
fixed_alloc_size: u32,
};
// 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),
// Total memory available including the initial 1MiB that grub doesn't include
.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.
///
fn createDataElement(arg: var) DataElement {
return switch (@typeOf(arg)) {
return switch (@TypeOf(arg)) {
bool => DataElement{ .BOOL = arg },
u4 => DataElement{ .U4 = arg },
u8 => DataElement{ .U8 = arg },
@ -171,7 +171,7 @@ fn Mock() type {
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, 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
/// 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) {
0 => fn () RetType,
1 => fn (@typeOf(params[0])) RetType,
2 => fn (@typeOf(params[0]), @typeOf(params[1])) RetType,
1 => fn (@TypeOf(params[0])) RetType,
2 => fn (@TypeOf(params[0]), @TypeOf(params[1])) RetType,
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 {
if (ExpectedType == void) {
// 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
@ -330,7 +330,7 @@ fn Mock() type {
return ret;
} 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 {
// Shouldn't get here as we would have just added a new mapping
// 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
/// 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| {
var action_list = kv_actions_list.value;
// Peak the first action to test the action type
@ -397,7 +397,7 @@ fn Mock() type {
const test_node = action_list.popFirst().?;
const test_action = test_node.data;
const param = params[i];
const param_type = @typeOf(params[i]);
const param_type = @TypeOf(params[i]);
expectTest(param_type, param, test_action.data);
@ -420,8 +420,8 @@ fn Mock() type {
// to be resolved
const expected_function = switch (params.len) {
0 => fn () RetType,
1 => fn (@typeOf(params[0])) RetType,
2 => fn (@typeOf(params[0]), @typeOf(params[1])) RetType,
1 => fn (@TypeOf(params[0])) RetType,
2 => fn (@TypeOf(params[0]), @TypeOf(params[1])) RetType,
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);
// The data element will contain the function to call
const r = switch (params.len) {
0 => @noInlineCall(actual_function),
1 => @noInlineCall(actual_function, params[0]),
2 => @noInlineCall(actual_function, params[0], params[1]),
var r = switch (params.len) {
0 => actual_function(),
1 => actual_function(params[0]),
2 => actual_function(params[0], params[1]),
else => @compileError(params.len ++ " or more parameters not supported"),
};
@ -453,8 +453,8 @@ fn Mock() type {
const test_element = action.data;
const expected_function = switch (params.len) {
0 => fn () RetType,
1 => fn (@typeOf(params[0])) RetType,
2 => fn (@typeOf(params[0]), @typeOf(params[1])) RetType,
1 => fn (@TypeOf(params[0])) RetType,
2 => fn (@TypeOf(params[0]), @TypeOf(params[1])) RetType,
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
const r = switch (params.len) {
0 => @noInlineCall(actual_function),
1 => @noInlineCall(actual_function, params[0]),
2 => @noInlineCall(actual_function, params[0], params[1]),
0 => actual_function(),
1 => actual_function(params[0]),
2 => actual_function(params[0], params[1]),
else => @compileError(params.len ++ " or more parameters not supported"),
};
@ -483,10 +483,10 @@ fn Mock() type {
kv_actions_list.value = action_list;
return ret;
} 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 {
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) {
ActionType.TestValue, ActionType.ConsumeFunctionCall => {
// 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 => {
// As this is a repeat action, the function will still be here
@ -553,7 +553,7 @@ fn getMockObject() *Mock() {
if (mock) |*m| {
return m;
} 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);
unreachable;
}
@ -565,7 +565,7 @@ fn getMockObject() *Mock() {
pub fn initTest() void {
// Make sure there isn't a mock object
if (mock) |_| {
warn("MOCK object already exists, please free previous test\n");
warn("MOCK object already exists, please free previous test\n", .{});
expect(false);
unreachable;
} else {
@ -596,7 +596,7 @@ pub fn freeTest() void {
/// IN fun_name: []const u8 - The function name to add the test parameters to.
/// 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();
comptime var i = 0;
inline while (i < params.len) : (i += 1) {
@ -639,6 +639,6 @@ pub fn addRepeatFunction(comptime fun_name: []const u8, function: var) void {
/// Return: RetType
/// 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);
}

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

@ -2,7 +2,7 @@ const builtin = @import("builtin");
const std = @import("std");
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);
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 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 {
return mock_framework.performAction("spuriousIrq", bool, irq_num);
return mock_framework.performAction("spuriousIrq", bool, .{irq_num});
}
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 {
return mock_framework.performAction("clearMask", void, irq_num);
return mock_framework.performAction("clearMask", void, .{irq_num});
}
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 {
return mock_framework.performAction("entryColour", u8, fg, bg);
return mock_framework.performAction("entryColour", u8, .{ fg, bg });
}
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 {
return mock_framework.performAction("updateCursor", void, x, y);
return mock_framework.performAction("updateCursor", void, .{ x, y });
}
pub fn getCursor() u16 {
return mock_framework.performAction("getCursor", u16);
return mock_framework.performAction("getCursor", u16, .{});
}
pub fn enableCursor() void {
return mock_framework.performAction("enableCursor", void);
return mock_framework.performAction("enableCursor", void, .{});
}
pub fn disableCursor() void {
return mock_framework.performAction("disableCursor", void);
return mock_framework.performAction("disableCursor", 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 {
return mock_framework.performAction("init", void);
return mock_framework.performAction("init", void, .{});
}
// User defined mocked functions