daniel/danos
1
0
Fork 0
Code Issues 4 Pull Requests Actions Packages Projects 1 Releases Wiki Activity

C2: migrate consumers off the runtime shim to direct concern-module imports

Browse Source 
Every user binary and the two device-logic library modules (pci, usb) now
`@import` the concern modules directly instead of aliasing through `runtime`:

  runtime.ipc/process/time/service/input/block/display  -> @import("<module>")
  runtime.device / runtime.device_manager               -> @import("driver")
  runtime.fs                                             -> @import("file-system")
  runtime.Thread                                         -> @import("thread").Thread
  runtime.system.{write,writeRecord,klog*}              -> logging.*
  runtime.system.{sleep,timerOnce,wallClock,clock}     -> time.*
  runtime.system.{spawn*,kill,exit,yield,processes,...}-> process.*
  runtime.system.{mmap,munmap,PROT_*}                  -> memory.*
  runtime.dma.* / runtime.shared_memory.* / runtime.allocator -> memory.*

Each consumer keeps its own alias name (e.g. `const device = @import("driver")`),
so call sites are unchanged and there are no collisions with local `driver`
variables. build.zig now injects the concern modules into every user binary via
`default_imports`; pci/usb module import lists were updated to match.

The `runtime` and `system` shims remain for one more step (root.zig still uses
runtime); they are deleted in C5. Nothing but root.zig imports `runtime` now.

Verified: zig build, zig build test, and 17 QEMU cases (smoke, device-manager,
logger, fat-mount, fat-mutations, usb-storage, usb-hid, display-native,
virtio-gpu, input, thread-spawn, thread-mutex, process-kill, shared-memory,
driver-restart, acpi-ps2, pci-scan).
This commit is contained in:
Daniel Samson
2026-07-22 23:28:34 +01:00
parent dded46726b
commit 23bcd77c58
37 changed files with 783 additions and 692 deletions
Download Patch File Download Diff File Expand all files Collapse all files
system/drivers/virtio-gpu/virtio-gpu.zig
+21 -19
View File
@@ -14,14 +14,16 @@
//! restart/re-attach are V4–V6. See docs/display-v2.md.
const std = @import("std");
const runtime = @import("runtime");
const device = @import("driver");
const ipc = @import("ipc");
const process = @import("process");
const service = @import("service");
const time = @import("time");
const device_manager = @import("driver");
const memory = @import("memory");
const logging = @import("logging");
const mmio = @import("mmio");
const pci = @import("pci");
const device = runtime.device;
const dma = runtime.dma;
const shared_memory = runtime.shared_memory;
const system = runtime.system;
const ipc = runtime.ipc;
const display_protocol = @import("display-protocol");
const scanout_protocol = @import("scanout-protocol");
const vp = @import("virtio-pci.zig");
@@ -86,14 +88,14 @@ var notify_multiplier: u32 = 0;
var notify_addr: usize = 0;
// DMA memory: the virtqueue rings and the command scratch.
var ring: dma.Region = undefined;
var command: dma.Region = undefined;
var ring: memory.DmaRegion = undefined;
var command: memory.DmaRegion = undefined;
// The scanout backing is a **shared** (shared-memory) region, not DMA: cacheable so the compositor
// composites into it cheaply (x86 DMA is coherent, so the device still sees the writes), and
// shareable so the same physical pages the device scans out of are the ones the compositor
// paints. The driver keeps the capability to hand to the compositor in the announce.
var surface: shared_memory.Region = undefined;
var surface: memory.SharedRegion = undefined;
// Split-virtqueue producer/consumer shadows.
var avail_shadow: u16 = 0;
@@ -161,7 +163,7 @@ fn waitUsed() bool {
used_shadow = idx;
return true;
}
if (tries > 8) system.sleep(1);
if (tries > 8) time.sleepMillis(1);
}
return false;
}
@@ -282,11 +284,11 @@ fn initialise(endpoint: ipc.Handle) bool {
std.log.info("control queue too small ({d})", .{device_qsize});
return false;
}
ring = dma.alloc(4096, dma.coherent) orelse {
ring = memory.dmaAlloc(4096, memory.dma_coherent) orelse {
std.log.info("virtqueue allocation failed", .{});
return false;
};
command = dma.alloc(4096, dma.coherent) orelse {
command = memory.dmaAlloc(4096, memory.dma_coherent) orelse {
std.log.info("command-buffer allocation failed", .{});
return false;
};
@@ -322,11 +324,11 @@ fn initialise(endpoint: ipc.Handle) bool {
// Back the resource with a shared (shared-memory) surface, so the compositor and the device work
// the same physical pages. The device needs the guest-physical base for attach_backing.
surface = shared_memory.create(scanout_bytes) orelse {
surface = memory.sharedCreate(scanout_bytes) orelse {
std.log.info("scanout surface allocation failed", .{});
return false;
};
const surface_physical = shared_memory.physical(surface.handle) orelse {
const surface_physical = memory.sharedPhysical(surface.handle) orelse {
std.log.info("could not resolve the scanout surface physical address", .{});
return false;
};
@@ -354,7 +356,7 @@ fn initialise(endpoint: ipc.Handle) bool {
// deadline). Role: device — we claim one PCI function and serve its scanout; we report
// no children. A restarted instance re-hellos here and re-announces below — the compositor
// re-attaches to the fresh scanout (V6). Best-effort: standalone bring-up has no manager.
_ = runtime.device_manager.hello(.device, device_id);
_ = device_manager.hello(.device, device_id);
// Read the monitor's EDID (best-effort, when the device offers it) — the mode list a real
// driver derives from it; we log the preferred mode and keep our fixed offered list.
@@ -474,7 +476,7 @@ fn announce() void {
var tries: u32 = 0;
const display = while (tries < 50) : (tries += 1) {
if (ipc.lookup(.display)) |h| break h;
system.sleep(20);
time.sleepMillis(20);
} else {
std.log.info("no display service to announce to (scanout-only)", .{});
return;
@@ -535,16 +537,16 @@ fn onMessage(message: []const u8, reply: []u8, sender: u32, capability: ?ipc.Han
}
}
pub fn main(init: runtime.process.Init) void {
pub fn main(init: process.Init) void {
const argument = init.arguments.get(1) orelse {
_ = system.write("virtio-gpu: missing device id (argv[1])\n");
_ = logging.write("virtio-gpu: missing device id (argv[1])\n");
return;
};
device_id = std.fmt.parseInt(u64, argument, 10) catch {
std.log.info("malformed device id '{s}'", .{argument});
return;
};
runtime.service.run(256, .{
service.run(256, .{
.service = .scanout,
.init = initialise,
.on_message = onMessage,