core: add timestamped klog logger on VGA console

kernel/core/klog.c

@@ -0,0 +1,117 @@
+/* Nadir boot logger (see klog.h).
+ *
+ * The only backends are console_putchar (VGA polling)
+ * and pit_ticks (monotonic u64) — no hardware addresses, no port I/O, no
+ * serial dependency live here. Serial mirroring stays in kmain, which
+ * prints the same text without the timestamp prefix (kept simple).
+ *
+ * Timestamp math: secs = ticks / PIT_HZ, frac = (ticks % PIT_HZ) * 10000
+ * (1000000us/s divided by 100Hz). The field is 12 wide, space-padded on
+ * the left (`[    0.000000]`); past 99999s it overflows the
+ * pad and just prints long.
+ */
+
+#include <stdint.h>
+
+#include "console.h"
+#include "klog.h"
+#include "pit.h"
+
+/* Width of the `secs.frac` field between `[` and `]`. */
+#define KLOG_TIME_WIDTH 12U
+
+/* Print the `[    0.000000] subsystem: ` prefix. Reads pit_ticks() live
+ * so piecewise lines and one-shot lines share one code path. */
+static void klog_prefix(const char *subsystem)
+{
+    uint64_t ticks = pit_ticks();
+    uint64_t secs = ticks / (uint64_t)PIT_HZ;
+    uint64_t frac = (ticks % (uint64_t)PIT_HZ) * 10000ULL;
+    char num[22];
+    int n = 0;
+    uint64_t v;
+    uint64_t div;
+    int digits;
+    uint64_t len;
+
+    /* Decimal seconds into num (reversed then flipped below). */
+    v = secs;
+    if (v == 0U) {
+        num[n++] = '0';
+    } else {
+        while (v != 0U && n < 20) {
+            num[n++] = (char)('0' + (v % 10U));
+            v /= 10U;
+        }
+    }
+    /* Field length is digits + '.' + 6 frac digits; pad left with spaces
+     * to KLOG_TIME_WIDTH so short uptimes align */
+    digits = n;
+    len = (uint64_t)digits + 7U;
+    console_putchar('[');
+    while (len < (uint64_t)KLOG_TIME_WIDTH) {
+        console_putchar(' ');
+        len++;
+    }
+    while (n > 0) {
+        n--;
+        console_putchar(num[n]);
+    }
+    console_putchar('.');
+    /* Exactly 6 fraction digits, zero-padded (10ms ticks leave the last
+     * 4 as zeros — resolution limit, not a bug). */
+    div = 100000ULL;
+    while (div > 0U) {
+        console_putchar((char)('0' + ((frac / div) % 10U)));
+        div /= 10U;
+    }
+    console_puts("] ");
+    console_puts(subsystem);
+    console_puts(": ");
+}
+
+void klog(const char *subsystem, const char *msg)
+{
+    klog_begin(subsystem);
+    klog_str(msg);
+    klog_end();
+}
+
+void klog_begin(const char *subsystem)
+{
+    klog_prefix(subsystem);
+}
+
+void klog_str(const char *s)
+{
+    console_puts(s);
+}
+
+void klog_dec(uint64_t v)
+{
+    char buf[20];
+    int n = 0;
+
+    if (v == 0U) {
+        console_putchar('0');
+        return;
+    }
+    while (v != 0U && n < (int)sizeof(buf)) {
+        buf[n++] = (char)('0' + (v % 10U));
+        v /= 10U;
+    }
+    while (n > 0) {
+        n--;
+        console_putchar(buf[n]);
+    }
+}
+
+void klog_hex64(uint64_t v)
+{
+    console_puthex64(v);
+}
+
+void klog_end(void)
+{
+    console_putchar('\n');
+}