adding nesting in logs

sources/drivers/index.zig

@@ -8,10 +8,12 @@ pub fn initDrivers() void
 {
     @setCold(true);
     kernel.logs.klogln("[Drivers Manager] loading drivers...");
+    kernel.logs.beginSection();
     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.klogln("[Drivers Manager] loaded all drivers");
+    kernel.logs.endSection();
+    kernel.logs.klogln("[Drivers Manager] loaded drivers");
 }
 
 pub fn shutdownDrivers() void

sources/drivers/power/acpi.zig

@@ -11,6 +11,10 @@ var SLP_EN: u16 = 0;
 var SCI_EN: u16 = 0;
 var PM1_CNT_LEN: u8 = 0;
 
+var ACPI_version: u8 = 0;
+
+var ACPI_init: bool = false;
+
 const RSDP = struct
 {
     signature: [8]u8,
@@ -48,10 +52,15 @@ fn checkRSDP(ptr: *u32) !*u32
         // Check checksum of rsdp
         const bptr: [*]u8 = @ptrCast(ptr);
         for(0..@sizeOf(RSDP)) |i|
-            check += bptr[i];
-        // Found valid rsdp
+            check += bptr[i]; // Possible kernel panic if overflow here
         if(@as(u8, @truncate(check)) == 0)
+        {
+            if(rsdp.revision == 0)
+                ACPI_version = 1
+            else
+                ACPI_version = 2;
             return rsdp.rsdt_address;
+        }
     }
     return error.RSDPNotFound;
 }
@@ -64,7 +73,9 @@ fn getRSDP() !*u32
     {
         if(checkRSDP(@ptrFromInt(addr))) |rsdp|
         {
-            kernel.logs.klogln("[ACPI] found RSDP");
+            kernel.logs.klog("[ACPI] found RSDP at address 0x");
+            kernel.logs.klogNb(addr);
+            kernel.logs.klog("\n");
             return rsdp;
         }
         else |err|
@@ -74,9 +85,8 @@ fn getRSDP() !*u32
         }
     }
 
-    kernel.logs.klogln("2nd loop");
     // Calculate linear address from EBDA segment
-    const ebda_segment = @as(usize, ((@as(*const u16, @ptrFromInt(0x40E))).*));
+    const ebda_segment = @as(usize, @as(*const u16, @ptrFromInt(0x40E)).*);
     const ebda_linear_address = ebda_segment * 0x10 & 0x000FFFFF;
 
     // Search Extended BIOS Data Area for the Root System Description Pointer signature
@@ -85,7 +95,9 @@ fn getRSDP() !*u32
     {
         if(checkRSDP(&addr)) |rsdp|
         {
-            kernel.logs.klogln("[ACPI] found RSDP");
+            kernel.logs.klog("[ACPI] found RSDP in EBDA at address 0x");
+            kernel.logs.klogNb(addr);
+            kernel.logs.klog("\n");
             return rsdp;
         }
         else |err|
@@ -98,23 +110,20 @@ fn getRSDP() !*u32
     return error.RSDPNotFound;
 }
 
-fn checkHeader(ptr: [*]u8, sig: []const u8) bool
+fn checkHeader(ptr: *u32, sig: []const u8) bool
 {
-    if(kernel.memory.memcmp(ptr, @as([*]u8, @ptrCast(@constCast(sig))), 4) == 0)
+    if(kernel.memory.memcmp(@as([*]u8, @ptrCast(ptr)), @as([*]u8, @ptrCast(@constCast(sig))), 4) != 0)
+        return false;
+    var check_ptr: [*]u8 = @ptrCast(ptr);
+    var len: usize = @as(*usize, @ptrFromInt(@intFromPtr(ptr) + 1)).*;
+    var check: u32 = 0;
+    while(len > 0)
     {
-        var check_ptr: [*]u8 = ptr;
-        var len: u16 = @intCast(@as(*const u16, @ptrFromInt(@intFromPtr(ptr) + 1)).*);
-        var check: u8 = 0;
-        while(len > 0)
-        {
-            check += check_ptr[0];
-            check_ptr += 1;
-            len -= 1;
-        }
-        if(check == 0)
-            return true;
+        check += check_ptr[0];
+        check_ptr += 1;
+        len -= 1;
     }
-    return false;
+    return (@as(u8, @truncate(check)) == 0);
 }
 
 fn enable() i32
@@ -166,56 +175,58 @@ fn enable() i32
 
 pub fn init() bool
 {
-    @setRuntimeSafety(false);
-
     kernel.logs.klogln("[ACPI] loading...");
     var ptr: *u32 = getRSDP() catch |err|
     {
         if(err == error.RSDPNotFound)
-            kernel.logs.klogln("[ACPI] could not find RSDP address");
+            kernel.logs.klogln("[ACPI] no RSDP found");
         return false;
     };
 
-    if(checkHeader(@ptrCast(ptr), "RSDT"))
+    kernel.logs.klog("[ACPI] version ");
+    kernel.logs.klogNb(ACPI_version);
+    kernel.logs.klog("\n");
+
+    if(checkHeader(ptr, "RSDT"))
     {
         var entries: i32 = @intCast((@as(*const u32, @ptrFromInt(@intFromPtr(ptr) + 1))).*);
         entries = @divFloor((entries - 36), 4);
         ptr = @ptrFromInt(@intFromPtr(ptr) + (36 / 4)); // Skip header information
 
         while(entries > 0)
         {
-            if(checkHeader(@as([*]u8, @ptrCast(ptr)), "FACP"))
+            if(checkHeader(ptr, "FACP"))
             {
                 entries = -2;
                 const facp: FACP = @as(*FACP, @ptrCast(ptr)).*;
-                if(checkHeader(@as([*]u8, @ptrCast(facp.DSDT)), "DSDT"))
+                if(checkHeader(facp.DSDT, "DSDT"))
                 {
-                    var S5Addr: [*]u8 = @ptrFromInt(@intFromPtr(facp.DSDT) + 36); // Skip header
-                    var dsdtLength: u32 = (@as(*const u32, @ptrFromInt(@intFromPtr(facp.DSDT) + 1))).* - 36;
-                    while(dsdtLength > 0)
+                    var S5_addr: [*]u8 = @ptrFromInt(@intFromPtr(facp.DSDT) + 36); // Skip header
+                    var dsdt_length: u32 = (@as(*const u32, @ptrFromInt(@intFromPtr(facp.DSDT) + 1))).* - 36;
+                    while(dsdt_length > 0)
                     {
-                        if(kernel.memory.memcmp(S5Addr, "_S5_", 4) == 0)
+                        if(kernel.memory.memcmp(S5_addr, "_S5_", 4) == 0)
                             break;
-                        S5Addr += 1;
-                        dsdtLength -= 1;
+                        S5_addr += 1;
+                        dsdt_length -= 1;
                     }
-                    if(dsdtLength > 0)
+                    if(dsdt_length > 0)
                     {
-                        if((@as(*u8, @ptrFromInt(@intFromPtr(S5Addr) - 1)).* == 0x08 or
-                                (@as(*u8, @ptrFromInt(@intFromPtr(S5Addr) - 2)).* == 0x08 and @as(*u8, @ptrFromInt(@intFromPtr(S5Addr) - 1)).* == '\\'))
-                            and @as(*u8, @ptrFromInt(@intFromPtr(S5Addr) + 4)).* == 0x12)
+                        if((@as(*u8, @ptrFromInt(@intFromPtr(S5_addr) - 1)).* == 0x08 or
+                                (@as(*u8, @ptrFromInt(@intFromPtr(S5_addr) - 2)).* == 0x08 and @as(*u8, @ptrFromInt(@intFromPtr(S5_addr) - 1)).* == '\\'))
+                            and @as(*u8, @ptrFromInt(@intFromPtr(S5_addr) + 4)).* == 0x12)
                         {
-                            S5Addr += 5;
-                            S5Addr += (((S5Addr[0] & 0xC0) >> 6) + 2); // Calculate PkgLength size
+                            S5_addr += 5;
+                            S5_addr += (((S5_addr[0] & 0xC0) >> 6) + 2); // Calculate PkgLength size
 
-                            if(S5Addr[0] == 0x0A)
-                                S5Addr += 1; // Skip byte prefix
-                            SLP_TYPa = @as(u16, S5Addr[0]) << 10;
-                            S5Addr += 1;
+                            if(S5_addr[0] == 0x0A)
+                                S5_addr += 1; // Skip byte prefix
+                            SLP_TYPa = @as(u16, S5_addr[0]) << 10;
+                            S5_addr += 1;
 
-                            if(S5Addr[0] == 0x0A)
-                                S5Addr += 1; // Skip byte prefix
-                            SLP_TYPb = @as(u16, S5Addr[0]) << 10;
+                            if(S5_addr[0] == 0x0A)
+                                S5_addr += 1; // Skip byte prefix
+                            SLP_TYPb = @as(u16, S5_addr[0]) << 10;
 
                             SMI_CMD = facp.SMI_CMD;
                             ACPI_ENABLE = facp.ACPI_DISABLE;
@@ -228,6 +239,7 @@ pub fn init() bool
                             SCI_EN = 1;
 
                             kernel.logs.klogln("[ACPI] loaded");
+                            ACPI_init = true;
                             return true;
                         }
                         else
@@ -244,15 +256,14 @@ pub fn init() bool
         kernel.logs.klogln("[ACPI] no valid FACP present");
     }
     else
-        kernel.logs.klogln("[ACPO] No ACPI found");
+        kernel.logs.klogln("[ACPI] No RSDT found");
     return false;
 }
 
 pub fn powerOff() void
 {
-    if(SCI_EN == 0)
+    if(!ACPI_init || SCI_EN == 0)
         return;
-
     enable();
     kernel.arch.ports.out(u16, @as(u32, PM1a_CNT.*), SLP_TYPa | SLP_EN);
     if(PM1b_CNT != null)

sources/drivers/power/power.zig

@@ -5,10 +5,17 @@ pub fn init() void
 {
     @setCold(true);
     kernel.logs.klogln("[Power Driver] loading...");
+    kernel.logs.beginSection();
     if(!acpi.init())
-        kernel.logs.klogln("[Power Driver] couldn't load")
+    {
+        kernel.logs.endSection();
+        kernel.logs.klogln("[Power Driver] couldn't load");
+    }
     else
+    {
+        kernel.logs.endSection();
         kernel.logs.klogln("[Power Driver] loaded");
+    }
 }
 
 pub fn shutdown() void

sources/drivers/vga/vga.zig

@@ -236,6 +236,7 @@ pub fn putStringAt(string : []const u8, x: usize, y: usize) void
         putCharAt(c, x + i, y);
     return;
 }
+
 pub fn putString(string: []const u8) void
 {
     for(string) |c|

sources/kernel/kmain.zig

@@ -31,6 +31,7 @@ export fn kmain() void
     @setCold(true);
     arch.init();
     drivers.initDrivers();
+    logs.klogln("Welcome to RatiOS !");
     console.kputs(logs.getLogBuffer());
     drivers.shutdownDrivers();
 }

sources/kernel/log.zig

@@ -1,9 +1,10 @@
-const BUFFER_SIZE: usize = 4096;
+const BUFFER_SIZE: usize = 16384;
 
 const Logger = struct
 {
     buffer: [BUFFER_SIZE]u8 = .{0} ** BUFFER_SIZE,
     current_index: usize = 0,
+    sections_nesting: u8 = 0,
 
     fn shiftBuffer(self: *Logger, size: usize) void
     {
@@ -19,14 +20,30 @@ const Logger = struct
 
 var logger = Logger{};
 
+pub fn beginSection() void
+{
+    logger.sections_nesting += 1;
+}
+
+pub fn endSection() void
+{
+    logger.sections_nesting -= 1;
+}
+
 pub fn klog(message: []const u8) void
 {
-    if(message.len + logger.current_index >= BUFFER_SIZE)
+    const nesting: u8 = if(logger.current_index > 0 and logger.buffer[logger.current_index - 1] == '\n') logger.sections_nesting else 0;
+    const total_len: usize = message.len + nesting * 4;
+    if(total_len + logger.current_index >= BUFFER_SIZE)
     {
-        logger.shiftBuffer(message.len + 1);
-        logger.current_index -= message.len + 1;
+        logger.shiftBuffer(total_len + 1);
+        logger.current_index -= total_len + 1;
+    }
+    for(0..nesting * 4) |_|
+    {
+        logger.buffer[logger.current_index] = ' ';
+        logger.current_index += 1;
     }
-
     for(message) |c|
     {
         logger.buffer[logger.current_index] = c;

sources/kernel/memory/memory.zig

@@ -27,7 +27,7 @@ pub fn memcmp(lhs: [*]const u8, rhs: [*]const u8, sz: usize) i32
     var i: usize = 0;
     while(i < sz) : (i += 1)
     {
-        const comp = @as(c_int, lhs[i]) -% @as(c_int, rhs[i]);
+        const comp = @as(i32, lhs[i]) -% @as(i32, rhs[i]);
         if(comp != 0)
             return comp;
     }

sources/kernel/panic.zig

@@ -10,6 +10,7 @@ pub fn kpanic(message: []const u8) noreturn
     vga.putString(logs.getLogBuffer());
     vga.putString("\nkernel panic : ");
     vga.putString(message);
+    vga.putString("\n[cannot recover, freezing the system]");
     while(true)
     {
         arch.disableInts();