add device platform module with ACPI support

build.zig

@@ -28,6 +28,26 @@ fn firstExisting(io: std.Io, candidates: []const []const u8) []const u8 {
     return candidates[0];
 }
 
+/// A UTC timestamp like "20260708-153045", for naming a per-run artifact so
+/// repeated runs don't clobber each other's logs. Resolved when `build.zig` runs
+/// (i.e. at `zig build` invocation), which is moments before QEMU launches.
+fn timestamp(b: *std.Build) []const u8 {
+    const ns = std.Io.Clock.now(.real, b.graph.io).nanoseconds;
+    const secs: u64 = @intCast(@divFloor(ns, std.time.ns_per_s));
+    const es = std.time.epoch.EpochSeconds{ .secs = secs };
+    const yd = es.getEpochDay().calculateYearDay();
+    const md = yd.calculateMonthDay();
+    const ds = es.getDaySeconds();
+    return b.fmt("{d:0>4}{d:0>2}{d:0>2}-{d:0>2}{d:0>2}{d:0>2}", .{
+        yd.year,
+        md.month.numeric(),
+        @as(u32, md.day_index) + 1,
+        ds.getHoursIntoDay(),
+        ds.getMinutesIntoHour(),
+        ds.getSecondsIntoMinute(),
+    });
+}
+
 pub fn build(b: *std.Build) void {
     ensureZigVersion();
 
@@ -54,6 +74,18 @@ pub fn build(b: *std.Build) void {
     // jumps/calls that Zig inline asm can't express (see the file's header).
     arch_mod.addAssemblyFile(b.path("src/kernel/arch/x86_64/isr.s"));
 
+    // Firmware-agnostic device discovery. The generic kernel imports this as
+    // "platform" and asks it to enumerate hardware into a backend-neutral device
+    // tree, never naming ACPI (or, later, device-tree) — the same discipline the
+    // arch module applies to CPU code. The backend is selected at runtime from
+    // the boot handoff (see src/device/platform.zig).
+    const platform_mod = b.addModule("platform", .{
+        .root_source_file = b.path("src/device/platform.zig"),
+        .imports = &.{
+            .{ .name = "danos", .module = mod }, // BootInfo (carries the ACPI RSDP)
+        },
+    });
+
     // Compile-time config the kernel reads as `@import("build_options")`. The
     // QEMU test harness sets -Dtest-case=<name> to run one self-test at boot.
     const test_case = b.option([]const u8, "test-case", "Kernel self-test case to run at boot (see src/kernel/tests.zig)");
@@ -86,6 +118,7 @@ pub fn build(b: *std.Build) void {
             .imports = &.{
                 .{ .name = "danos", .module = mod },
                 .{ .name = "arch", .module = arch_mod },
+                .{ .name = "platform", .module = platform_mod },
                 .{ .name = "build_options", .module = build_options_mod },
             },
         }),
@@ -187,10 +220,14 @@ pub fn build(b: *std.Build) void {
         "-device",
         "VGA,edid=on,xres=1280,yres=720",
     });
+    // Always capture the guest's serial0 (the kernel's machine-readable log) to a
+    // timestamped file under zig-out, so each run leaves its own log behind.
+    const serial_log = b.fmt("{s}/run-x86-64-serial0-{s}.log", .{ b.install_path, timestamp(b) });
+    run_efi.addArgs(&.{ "-serial", b.fmt("file:{s}", .{serial_log}) });
     run_efi.step.dependOn(&efi_install.step);
     run_efi.step.dependOn(&kernel_install.step);
 
-    const run_efi_step = b.step("run-x86-64", "Boot the x86-64 kernel in QEMU (UEFI/OVMF)");
+    const run_efi_step = b.step("run-x86-64", "Boot the x86-64 kernel in QEMU (UEFI/OVMF); serial0 is logged to zig-out/run-x86-64-serial0-<timestamp>.log");
     run_efi_step.dependOn(&run_efi.step);
 
     // const run_cmd = b.addRunArtifact(exe);