Daniel Samson
65244e3103
Programs can now subscribe to keyboard events (key_down/key_up/key_press) and drivers can broadcast them, through a new user-space input service. The delivery model is forced by danos IPC: a synchronous rendezvous holds one pending reply, so a server cannot park N subscribers blocked in a "wait for next event" call — delivery must be push. But a synchronous push has no timeout and the kernel never wakes a sender parked on a dead peer's endpoint, so one dying subscriber would hang all input. So this lands the roadmap's planned asynchronous buffered send and builds the service on it: - ipc_send (syscall 26): non-blocking post to an endpoint's bounded payload ring, delivered through reply_wait as a buffered message (notify_message_bit). A full ring drops the oldest. It can never hang on a dead/slow peer. - input-protocol + runtime.input helpers (subscribe/next, connectSource/ publish) — the first real consumer of M13 capability passing: a subscriber hands the service its own endpoint as a capability. - input service (fan-out via ipc_send, dead-subscriber pruning), a synthetic input-source, and input-test; the ps2-bus keyboard driver publishes to it. Real IRQ1 scancode decoding (which must live in the bus, the PNP0303 owner) is a documented follow-up; the source is synthetic for now. - build/init wiring, an `input` QEMU case, and docs/input.md. Full QEMU suite 48/48, including the new input case and every IPC/endpoint regression (ipc, ipc-call, ipc-cap, vfs, hpet, bus, irqfree).
54 lines
2.6 KiB
Zig
54 lines
2.6 KiB
Zig
//! /system/services/init — the first user-space program, PID 1. Built as its own
|
|
//! freestanding binary (see build.zig), shipped on the boot volume at /system/services/init,
|
|
//! loaded by the bootloader, and started in ring 3 as a scheduled process by the
|
|
//! kernel (system/kernel/process.zig). It links against the shared user runtime
|
|
//! library `runtime` and talks to the kernel only through `runtime`'s system_call wrappers.
|
|
//!
|
|
//! It proves the C-convention heap works, then — as PID 1 — acts as the system's
|
|
//! **service supervisor**: it spawns the user-space services danos brings up at boot
|
|
//! (the VFS server, the device manager), and settles into a heartbeat so it stays
|
|
//! alive as the root of user space. Drivers are *not* its job: the device manager
|
|
//! discovers the hardware and spawns those. This is the service half of the
|
|
//! service/driver spawn split (docs/driver-model.md).
|
|
|
|
const runtime = @import("runtime");
|
|
|
|
/// The system services init brings up at boot, in order. This is init's policy — the
|
|
/// microkernel keeps such choices in user space, not the kernel. Drivers are absent
|
|
/// on purpose: the device manager owns those. (A future init reads this from a
|
|
/// manifest under /system/services instead of a hardcoded list.)
|
|
const boot_services = [_][]const u8{ "vfs", "input", "device-manager" };
|
|
|
|
pub fn main() void {
|
|
// Prove the heap end to end: allocate through the runtime allocator (which
|
|
// mmaps pages from the kernel and carves them with the free list), write into
|
|
// that heap buffer (exercising the widened debug_write bounds check), and
|
|
// free it. A fault here would kill init before it heartbeats — so the init
|
|
// test doubles as the heap regression test. (C code links the same heap via
|
|
// the extern malloc/free symbols; Zig code uses this allocator.)
|
|
const gpa = runtime.allocator();
|
|
if (gpa.alloc(u8, 64)) |buffer| {
|
|
const message = "init: heap ok\n";
|
|
@memcpy(buffer[0..message.len], message);
|
|
_ = runtime.system.write(buffer[0..message.len]);
|
|
gpa.free(buffer);
|
|
} else |_| {}
|
|
|
|
// Bring up the boot services. Best-effort and silent: each service announces its
|
|
// own readiness (`vfs: ready`, ...), and in an isolation test that runs init with
|
|
// no initial-ramdisk the spawns simply no-op rather than deranging the heartbeat.
|
|
for (boot_services) |service| {
|
|
_ = runtime.system.spawn(service);
|
|
}
|
|
|
|
while (true) {
|
|
_ = runtime.system.write("init: heartbeat\n");
|
|
runtime.system.sleep(1000);
|
|
}
|
|
}
|
|
|
|
pub const panic = runtime.panic;
|
|
comptime {
|
|
_ = &runtime.start._start; // pull the runtime entry shim into the image
|
|
}
|