From 9ef61a084416daa1a8d57b88d5af3e15eeda1949 Mon Sep 17 00:00:00 2001 From: Daniel Samson <12231216+daniel-samson@users.noreply.github.com> Date: Mon, 13 Jul 2026 05:32:26 +0100 Subject: [PATCH] fix kernel: debug prefix --- system/kernel/kernel.zig | 38 +++++++++++++++++++------------------- 1 file changed, 19 insertions(+), 19 deletions(-) diff --git a/system/kernel/kernel.zig b/system/kernel/kernel.zig index 8c1e3e5..f4bd9e8 100644 --- a/system/kernel/kernel.zig +++ b/system/kernel/kernel.zig @@ -77,12 +77,12 @@ fn kmain(boot_information: *const BootInformation) noreturn { architecture.setFaultHandler(onException); architecture.init(); - status("kernel: initialising kernel...\n"); + status("/system/kernel: initialising kernel...\n"); log.write(if (console.present()) - "kernel: framebuffer console online (bootstrap; graphics driver later)\n" + "/system/kernel: framebuffer console online (bootstrap; graphics driver later)\n" else - "kernel: no framebuffer (headless) -> logging to serial/debugcon only\n"); - log.write("kernel: cpu tables online (GDT, IDT, TSS)\n"); + "/system/kernel: no framebuffer (headless) -> logging to serial/debugcon only\n"); + log.write("/system/kernel: cpu tables online (GDT, IDT, TSS)\n"); log.print(" resolution : {d}x{d}\n", .{ fb.width, fb.height }); log.print(" pitch : {d} bytes\n", .{fb.pitch}); log.print(" format : {s}\n", .{@tagName(fb.format)}); @@ -105,7 +105,7 @@ fn kmain(boot_information: *const BootInformation) noreturn { const total_bytes = total_pages * abi.page_size; const gib = 1 << 30; - log.write("\nkernel: physical memory\n"); + log.write("\n/system/kernel: physical memory\n"); log.print(" total RAM : {d}.{d:0>2} GiB ({d} MiB) - RAM the firmware reported\n", .{ total_bytes / gib, (total_bytes % gib) * 100 / gib, mib(total_pages) }); log.print(" usable : {d} MiB - free RAM (incl. reclaimed boot-services memory)\n", .{mib(usable_pages)}); log.print(" reserved : {d} MiB - kernel image, boot stack, ACPI, runtime services\n", .{mib(reserved_pages)}); @@ -119,7 +119,7 @@ fn kmain(boot_information: *const BootInformation) noreturn { // until SMP bring-up; 0 means none was available (we stay uniprocessor). ap_trampoline_page = pmm.allocBelow(0x100000) orelse 0; const s1 = pmm.stats(); - log.print("\nkernel: frame allocator online\n", .{}); + log.print("\n/system/kernel: frame allocator online\n", .{}); log.print(" free frames: {d} ({d} MiB)\n", .{ s1.free_frames, mib(s1.free_frames) }); const f0 = pmm.alloc(); const f1 = pmm.alloc(); @@ -133,14 +133,14 @@ fn kmain(boot_information: *const BootInformation) noreturn { // Switch off the firmware's page tables onto our own (with real permissions). architecture.enablePaging(pmm.alloc, pmm.free, boot_information); log.checkpoint(cp_paging); - log.print("\nkernel: paging enabled\n", .{}); + log.print("\n/system/kernel: paging enabled\n", .{}); log.print(" page tables: root = 0x{x:0>16}\n", .{architecture.activePageTable()}); log.print(" kernel segs: {d} (mapped with W^X permissions)\n", .{boot_information.kernel_segment_count}); // Bring up the kernel heap (dynamic allocation), built on the VMM. heap.init(); log.checkpoint(cp_heap); - log.write("\nkernel: kernel heap online\n"); + log.write("\n/system/kernel: kernel heap online\n"); // Measure the amount of resources the kernel is actually using const s2 = pmm.stats(); log.print(" Kernel footprint: {d} KiB\n", .{kib(s1.free_frames - s2.free_frames)}); @@ -156,7 +156,7 @@ fn kmain(boot_information: *const BootInformation) noreturn { }; if (platform.discover(boot_information, heap.allocator(), hal)) |devtree| { var device_tree = devtree; - log.write("\nkernel: device discovery online\n"); + log.write("\n/system/kernel: device discovery online\n"); device_tree.dump(log.write); // Snapshot the device tree for user-space drivers (device_enumerate/claim/ @@ -164,7 +164,7 @@ fn kmain(boot_information: *const BootInformation) noreturn { devices_broker.init(&device_tree); if (devices_broker.dropped > 0) { // Otherwise entirely silent: drivers would just never see that hardware. - log.print("kernel: WARNING {d} device(s) dropped — table full\n", .{devices_broker.dropped}); + log.print("/system/kernel: WARNING {d} device(s) dropped — table full\n", .{devices_broker.dropped}); } // Install the device-IRQ trampolines, so a driver's irq_bind has vectors to @@ -173,7 +173,7 @@ fn kmain(boot_information: *const BootInformation) noreturn { // Power register map extracted from the FADT + AML, for confidence it parsed. const pw = platform.powerInformation(); - log.write("kernel: power\n"); + log.write("/system/kernel: power\n"); log.print(" pm1a_cnt : {s} 0x{x} (width {d})\n", .{ if (pw.pm1a_cnt.mmio) "mmio" else "io", pw.pm1a_cnt.address, pw.pm1a_cnt.width }); if (pw.s5) |s| { log.print(" S5 slp_typ : a={d} b={d}\n", .{ s.slp_typ_a, s.slp_typ_b }); @@ -221,7 +221,7 @@ fn kmain(boot_information: *const BootInformation) noreturn { }); if (pinfo.spcr_uart) |u| architecture.serialReconfigure(u.mmio, u.address); - log.write("kernel: platform\n"); + log.write("/system/kernel: platform\n"); log.print(" 8259 PIC : {s}\n", .{if (pinfo.pic_present) "present" else "absent"}); log.print(" lapic base : 0x{x}\n", .{pinfo.lapic_base}); log.print(" hpet base : 0x{x}\n", .{hpet_base}); @@ -237,7 +237,7 @@ fn kmain(boot_information: *const BootInformation) noreturn { if (platform.cpusDropped() > 0) log.print(" cpus : WARNING {d} core(s) beyond pool cap dropped\n", .{platform.cpusDropped()}); } else |err| { - log.print("\nkernel: device discovery failed: {s}\n", .{@errorName(err)}); + log.print("\n/system/kernel: device discovery failed: {s}\n", .{@errorName(err)}); } log.checkpoint(cp_discovery); @@ -248,14 +248,14 @@ fn kmain(boot_information: *const BootInformation) noreturn { // Register the current context as the first task before enabling preemption. scheduler.init(4); log.checkpoint(cp_scheduler); - log.write("\nkernel: scheduler online\n"); + log.write("\n/system/kernel: scheduler online\n"); // Start the timer and unmask interrupts — the kernel now has a heartbeat, and // the timer preempts among tasks. architecture.startTimer(); architecture.enableInterrupts(); log.checkpoint(cp_timer); - log.print("kernel: timer online ({d} Hz tick; timer clock {d} MHz, clock {d} MHz; calibrated via {s})\n", .{ architecture.timer_hz, architecture.timerClockHz() / 1_000_000, architecture.clockHz() / 1_000_000, architecture.timerCalibrationSource() }); + log.print("/system/kernel: timer online ({d} Hz tick; timer clock {d} MHz, clock {d} MHz; calibrated via {s})\n", .{ architecture.timer_hz, architecture.timerClockHz() / 1_000_000, architecture.clockHz() / 1_000_000, architecture.timerCalibrationSource() }); // Wake the other cores (application processors). A no-op on a single-core // machine; on SMP each AP climbs to long mode and reports in (docs/smp.md). @@ -321,7 +321,7 @@ fn bringUpSecondaries() void { // vector addresses it). It's kept for the system's life — armed only during a // wake, inert (zeroed, non-executable) otherwise — so cores can be re-woken later. if (ap_trampoline_page == 0) { - log.write("kernel: smp: no low page for the AP trampoline; staying uniprocessor\n"); + log.write("/system/kernel: smp: no low page for the AP trampoline; staying uniprocessor\n"); return; } architecture.setTrampolinePage(ap_trampoline_page); @@ -333,7 +333,7 @@ fn bringUpSecondaries() void { if (std.mem.eql(u8, tc, "smp-retry")) architecture.testFailNextWakes(1); } - log.print("\nkernel: bringing up {d} application processor(s)\n", .{cores.len - 1}); + log.print("\n/system/kernel: bringing up {d} application processor(s)\n", .{cores.len - 1}); const maximum_wake_attempts = 3; // a core that misses the first INIT-SIPI-SIPI gets retried for (cores[1..], 1..) |core, index| { const stack = heap.allocator().alloc(u8, parameters.kernel_stack_size) catch { @@ -360,7 +360,7 @@ fn bringUpSecondaries() void { log.print(" cpu apic_id {d}: no response after {d} attempts (parked)\n", .{ core.apic_id, maximum_wake_attempts }); } } - log.print("kernel: {d}/{d} cores online\n", .{ scheduler.onlineCount(), cores.len }); + log.print("/system/kernel: {d}/{d} cores online\n", .{ scheduler.onlineCount(), cores.len }); } /// A user-facing status line: to the diagnostic `log` *and* the on-screen console @@ -427,7 +427,7 @@ fn exitReasonForVector(vector: u64) abi.ExitReason { fn onException(state: *const architecture.CpuState) noreturn { if (architecture.fromUser(state) and scheduler.currentIsUserProcess() and recoverableFault(state.vector)) { - statusPrint("\nkernel: process {d} ({s}) killed by {s} (vector {d}) on core {d}\n", .{ scheduler.currentId(), scheduler.current().name(), architecture.exceptionName(state.vector), state.vector, scheduler.currentCpuIndex() }); + statusPrint("\n/system/kernel: process {d} ({s}) killed by {s} (vector {d}) on core {d}\n", .{ scheduler.currentId(), scheduler.current().name(), architecture.exceptionName(state.vector), state.vector, scheduler.currentCpuIndex() }); statusPrint(" error code : 0x{x}\n", .{state.error_code}); statusPrint(" IP : 0x{x:0>16}\n", .{architecture.instructionPointer(state)}); if (architecture.faultAddress(state)) |address| statusPrint(" fault addr : 0x{x:0>16}\n", .{address});