Daniel Samson
23bcd77c58
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).
51 lines
2.4 KiB
Zig
51 lines
2.4 KiB
Zig
//! system/services/input-test — the input service's client and test oracle, the input
|
|
//! counterpart of vfs-test. It subscribes to *all* device classes and loops receiving the
|
|
//! events a source broadcasts, logging each with its class. It emits the success marker
|
|
//! `"input-test: ok"` only **after it has received at least one of each class** (keyboard,
|
|
//! mouse, and joystick), then heartbeats it. So the in-kernel `input` test case seeing that
|
|
//! marker proves not just that IPC delivery works but that the service *routed* all three
|
|
//! device classes to one subscription — source -> service -> subscriber, per device.
|
|
|
|
const std = @import("std");
|
|
const input = @import("input");
|
|
const logging = @import("logging");
|
|
|
|
fn writeLine(comptime fmt: []const u8, arguments: anytype) void {
|
|
var line: [128]u8 = undefined;
|
|
_ = logging.write(std.fmt.bufPrint(&line, fmt, arguments) catch return);
|
|
}
|
|
|
|
pub fn main() void {
|
|
var listener = input.subscribeAll() orelse {
|
|
_ = logging.write("input-test: could not subscribe\n");
|
|
return;
|
|
};
|
|
_ = logging.write("input-test: subscribed\n");
|
|
|
|
var seen_keyboard = false;
|
|
var seen_mouse = false;
|
|
var seen_joystick = false;
|
|
while (true) {
|
|
const event = listener.next() orelse continue;
|
|
// Decode the class-specific payload from the tagged envelope and note the class.
|
|
if (event.asKeyboard()) |key| {
|
|
seen_keyboard = true;
|
|
writeLine("input-test: got keyboard code={d} char={d}\n", .{ key.keycode, key.character });
|
|
} else if (event.asMouse()) |mouse| {
|
|
seen_mouse = true;
|
|
writeLine("input-test: got mouse dx={d} dy={d} buttons={d}\n", .{ mouse.dx, mouse.dy, mouse.buttons });
|
|
} else if (event.asJoystick()) |joystick| {
|
|
seen_joystick = true;
|
|
writeLine("input-test: got joystick control={d} value={d}\n", .{ joystick.control, joystick.value });
|
|
} else {
|
|
writeLine("input-test: got device={d}\n", .{event.device});
|
|
}
|
|
|
|
// The success marker: only once every class has been routed here does this appear,
|
|
// and then it heartbeats. Seeing "input-test: ok" proves per-device fan-out works.
|
|
if (seen_keyboard and seen_mouse and seen_joystick) {
|
|
_ = logging.write("input-test: ok all classes received (keyboard, mouse, joystick)\n");
|
|
}
|
|
}
|
|
}
|