fixing RSPD getter

sources/drivers/index.zig

@@ -7,11 +7,11 @@ const kernel = @import("kernel");
 pub fn initDrivers() void
 {
     @setCold(true);
-    kernel.logs.klog("[Drivers Manager] loading drivers...");
+    kernel.logs.klogln("[Drivers Manager] loading drivers...");
     kb.init();
     vga.init("RatiOS 0.1 : 42", vga.computeColor(vga.Color.BLACK, vga.Color.LIGHT_GREY), vga.computeColor(vga.Color.WHITE, vga.Color.DARK_GREY), vga.computeColor(vga.Color.RED, vga.Color.DARK_GREY));
     power.init();
-    kernel.logs.klog("[Drivers Manager] loaded all drivers");
+    kernel.logs.klogln("[Drivers Manager] loaded all drivers");
 }
 
 pub fn shutdownDrivers() void

sources/drivers/keyboard/keyboard.zig

@@ -123,8 +123,8 @@ pub fn keyboardHandler(regs: *kernel.arch.idt.IDTRegister) void
 pub fn init() void
 {
     @setCold(true);
-    kernel.logs.klog("[PS/2 Keyboard Driver] loading...");
+    kernel.logs.klogln("[PS/2 Keyboard Driver] loading...");
     kernel.arch.idt.irqInstallHandler(1, &keyboardHandler);
-    kernel.logs.klog("[PS/2 Keyboard Driver] loaded");
+    kernel.logs.klogln("[PS/2 Keyboard Driver] loaded");
 }
 

sources/drivers/power/acpi.zig

@@ -11,7 +11,7 @@ var SLP_EN: u16 = 0;
 var SCI_EN: u16 = 0;
 var PM1_CNT_LEN: u8 = 0;
 
-const RSDPtr = struct
+const RSDP = struct
 {
     signature: [8]u8,
     checksum: u8,
@@ -37,48 +37,44 @@ const FACP = struct
     PM1_CNT_LEN: u8,
 };
 
-const RSDPtrError = error
+fn checkRSDP(ptr: *u32) !*u32
 {
-    RSDPNotFound,
-};
-
-fn checkRSDPtr(ptr: *u32) !*u32
-{
-    const rsdp: *RSDPtr = @as(*RSDPtr, @ptrCast(ptr));
+    const rsdp: *RSDP = @as(*RSDP, @ptrCast(ptr));
     const sig = "RSD PTR ";
-    var check: u8 = 0;
+    var check: u32 = 0;
 
     if(kernel.memory.memcmp(sig, @as([*]u8, @ptrCast(rsdp)), 8) == 0)
     {
         // Check checksum of rsdp
-        var bptr: [*]u8 = @ptrCast(ptr);
-        for(0..@sizeOf(RSDPtr)) |i|
-        {
+        const bptr: [*]u8 = @ptrCast(ptr);
+        for(0..@sizeOf(RSDP)) |i|
             check += bptr[i];
-            bptr += 1;
-        }
         // Found valid rsdp
-        if(check == 0)
+        if(@as(u8, @truncate(check)) == 0)
             return rsdp.rsdt_address;
     }
-    return RSDPtrError.RSDPNotFound;
+    return error.RSDPNotFound;
 }
 
-fn getRSDPtr() !*usize
+fn getRSDP() !*u32
 {
-    var addr: usize = 0x000E0000;
+    var addr: u32 = 0x000E0000;
     // Search below the 1MB mark for RSDP signature
     while(addr < 0x00100000)
     {
-        if(checkRSDPtr(&addr)) |rsdp|
-            return rsdp
+        if(checkRSDP(@ptrFromInt(addr))) |rsdp|
+        {
+            kernel.logs.klogln("[ACPI] found RSDP");
+            return rsdp;
+        }
         else |err|
         {
-            if(err == RSDPtrError.RSDPNotFound)
-                addr += 0x10 / @sizeOf(@TypeOf(addr));
+            if(err == error.RSDPNotFound)
+                addr += 0x10 / @sizeOf(u32);
         }
     }
 
+    kernel.logs.klogln("2nd loop");
     // Calculate linear address from EBDA segment
     const ebda_segment = @as(usize, ((@as(*const u16, @ptrFromInt(0x40E))).*));
     const ebda_linear_address = ebda_segment * 0x10 & 0x000FFFFF;
@@ -87,16 +83,19 @@ fn getRSDPtr() !*usize
     addr = ebda_linear_address;
     while(addr < ebda_linear_address + 1024)
     {
-        if(checkRSDPtr(&addr)) |rsdp|
-            return rsdp
+        if(checkRSDP(&addr)) |rsdp|
+        {
+            kernel.logs.klogln("[ACPI] found RSDP");
+            return rsdp;
+        }
         else |err|
         {
-            if(err == RSDPtrError.RSDPNotFound)
+            if(err == error.RSDPNotFound)
                 addr += 0x10 / @sizeOf(@TypeOf(addr));
         }
     }
 
-    return RSDPtrError.RSDPNotFound;
+    return error.RSDPNotFound;
 }
 
 fn checkHeader(ptr: [*]u8, sig: []const u8) bool
@@ -146,18 +145,18 @@ fn enable() i32
             }
             if(i < 300)
             {
-                kernel.logs.klog("Enabled ACPI");
+                kernel.logs.klogln("[ACPI] Enabled");
                 return 0;
             }
             else
             {
-                kernel.logs.klog("Couldn't enable ACPI");
+                kernel.logs.klogln("[ACPI] Couldn't enable");
                 return -1;
             }
         }
         else
         {
-            kernel.logs.klog("Impossible to enable ACPI");
+            kernel.logs.klogln("[ACPI] Impossible to enable");
             return -1;
         }
     }
@@ -169,11 +168,11 @@ pub fn init() bool
 {
     @setRuntimeSafety(false);
 
-    kernel.logs.klog("[ACPI] loading...");
-    var ptr: *usize = getRSDPtr() catch |err|
+    kernel.logs.klogln("[ACPI] loading...");
+    var ptr: *u32 = getRSDP() catch |err|
     {
-        if(err == RSDPtrError.RSDPNotFound)
-            kernel.logs.klog("[ACPI] could not find RSDP address");
+        if(err == error.RSDPNotFound)
+            kernel.logs.klogln("[ACPI] could not find RSDP address");
         return false;
     };
 
@@ -228,24 +227,24 @@ pub fn init() bool
                             SLP_EN = 1 << 13;
                             SCI_EN = 1;
 
-                            kernel.logs.klog("[ACPI] loaded");
+                            kernel.logs.klogln("[ACPI] loaded");
                             return true;
                         }
                         else
-                            kernel.logs.klog("[ACPI] \\_S5 parse error");
+                            kernel.logs.klogln("[ACPI] \\_S5 parse error");
                     }
                     else
-                        kernel.logs.klog("[ACPI] \\_S5 not present");
+                        kernel.logs.klogln("[ACPI] \\_S5 not present");
                 }
                 else
-                    kernel.logs.klog("[ACPI] DSDT invalid");
+                    kernel.logs.klogln("[ACPI] DSDT invalid");
             }
             ptr = @ptrFromInt(@intFromPtr(ptr) + 1);
         }
-        kernel.logs.klog("[ACPI] no valid FACP present");
+        kernel.logs.klogln("[ACPI] no valid FACP present");
     }
     else
-        kernel.logs.klog("No ACPI");
+        kernel.logs.klogln("[ACPO] No ACPI found");
     return false;
 }
 
@@ -258,5 +257,5 @@ pub fn powerOff() void
     kernel.arch.ports.out(u16, @as(u32, PM1a_CNT.*), SLP_TYPa | SLP_EN);
     if(PM1b_CNT != null)
         kernel.arch.ports.out(@as(u32, PM1b_CNT.*), SLP_TYPb | SLP_EN);
-    kernel.logs.klog("[ACPI] PowerOFF failed");
+    kernel.logs.klogln("[ACPI] PowerOFF failed");
 }

sources/drivers/power/power.zig

@@ -4,11 +4,11 @@ const acpi = @import("acpi.zig");
 pub fn init() void
 {
     @setCold(true);
-    kernel.logs.klog("[Power Driver] loading...");
+    kernel.logs.klogln("[Power Driver] loading...");
     if(!acpi.init())
-        kernel.logs.klog("[Power Driver] couldn't load")
+        kernel.logs.klogln("[Power Driver] couldn't load")
     else
-        kernel.logs.klog("[Power Driver] loaded");
+        kernel.logs.klogln("[Power Driver] loaded");
 }
 
 pub fn shutdown() void

sources/drivers/vga/vga.zig

@@ -124,7 +124,7 @@ fn updateNavbar() void
 
 pub fn init(title : []const u8, title_color : u8, navbar_color : u8, triggered_color : u8) void
 {
-    kernel.logs.klog("[VGA Driver] loading...");
+    kernel.logs.klogln("[VGA Driver] loading...");
     if(title.len >= 48)
         return;
     vga.color = title_color;
@@ -155,7 +155,7 @@ pub fn init(title : []const u8, title_color : u8, navbar_color : u8, triggered_c
     vga.column = 1;
     updateCursor();
     updateNavbar();
-    kernel.logs.klog("[VGA Driver] loaded");
+    kernel.logs.klogln("[VGA Driver] loaded");
 }
 
 fn putEntry(c: u8, color: u8, x: usize, y: usize) void

sources/kernel/arch/x86/idt.zig

@@ -194,9 +194,8 @@ pub fn idtInit() void
 
 export fn isrHandler(regs: *IDTRegister) void
 {
-    const tmp: u32 = regs.int_nb;
     if(regs.int_nb < 32 and regs.int_nb >= 0)
-        kpanic(error_messages[tmp]);
+        kpanic(error_messages[regs.int_nb]);
 }
 
 var irq_routines: [16]?*const fn(*IDTRegister) void = undefined;

sources/kernel/kmain.zig

@@ -31,5 +31,6 @@ export fn kmain() void
     @setCold(true);
     arch.init();
     drivers.initDrivers();
+    console.kputs(logs.getLogBuffer());
     drivers.shutdownDrivers();
 }

sources/kernel/log.zig

@@ -32,8 +32,36 @@ pub fn klog(message: []const u8) void
         logger.buffer[logger.current_index] = c;
         logger.current_index += 1;
     }
-    logger.buffer[logger.current_index] = '\n';
-    logger.current_index += 1;
+}
+
+pub fn klogln(message: []const u8) void
+{
+    klog(message);
+    klog("\n");
+}
+
+pub fn klogNb(nbr: i64) void
+{
+    if(nbr <= -2147483648)
+        klog("-2147483648")
+    else if(nbr >= 2147483647)
+        klog("2147483647")
+    else if(nbr < 0)
+    {
+        klog("-");
+        klogNb(-nbr);
+    }
+    else if(nbr >= 10)
+    {
+        klogNb(@divFloor(nbr, 10));
+        const c: [1]u8 = .{ @intCast(@mod(nbr, 10) + @as(u8, 48)) };
+        klog(&c);
+    }
+    else
+    {
+        const c: [1]u8 = .{ @intCast(nbr + 48) };
+        klog(&c);
+    }
 }
 
 pub fn getLogBuffer() *[BUFFER_SIZE]u8

sources/kernel/memory/memory.zig

@@ -27,10 +27,26 @@ pub fn memcmp(lhs: [*]const u8, rhs: [*]const u8, sz: usize) i32
     var i: usize = 0;
     while(i < sz) : (i += 1)
     {
-        const comp = lhs[i] -% rhs[i];
+        const comp = @as(c_int, lhs[i]) -% @as(c_int, rhs[i]);
         if(comp != 0)
             return comp;
     }
     return 0;
 }
 
+test "memcmp"
+{
+    const expect = @import("std").testing.expect;
+    const arr0 = [_]u8{ 1, 1, 1 };
+    const arr1 = [_]u8{ 1, 1, 1 };
+    const arr2 = [_]u8{ 1, 0, 1 };
+    const arr3 = [_]u8{ 1, 2, 1 };
+    const arr4 = [_]u8{ 1, 0xff, 1 };
+
+    try expect(memcmp(&arr0, &arr1, 3) == 0);
+    try expect(memcmp(&arr0, &arr2, 3) > 0);
+    try expect(memcmp(&arr0, &arr3, 3) < 0);
+
+    try expect(memcmp(&arr0, &arr4, 3) < 0);
+    try expect(memcmp(&arr4, &arr0, 3) > 0);
+}