79 lines
3.4 KiB
Zig
79 lines
3.4 KiB
Zig
//! Process-level runtime types: what a user program receives at entry (`Init`,
|
|
//! the argv contract) and the process end of the lifecycle
|
|
//! (docs/process-lifecycle.md) — today the exit reason a supervisor reads to
|
|
//! decide restart; signals and the stop sequence land here with M17.4. Mirrors
|
|
//! the spirit of `std.process.Init.Minimal` in danos terms — std's `Args` holds
|
|
//! no data on freestanding targets, so the type is danos's own.
|
|
|
|
const std = @import("std");
|
|
const abi = @import("abi");
|
|
const sc = @import("system-call.zig");
|
|
|
|
/// Everything a program receives at entry. Passed to
|
|
/// `pub fn main(init: runtime.process.Init)`; programs that need nothing keep
|
|
/// `pub fn main() void`. An `environment` field is added here once the kernel
|
|
/// passes a non-empty envp (today it is always empty — see docs/sysv.md).
|
|
pub const Init = struct {
|
|
arguments: Arguments,
|
|
};
|
|
|
|
/// The process arguments (argc/argv), parsed from the kernel-built System V
|
|
/// entry block. The bytes live in the entry block at the top of the stack page,
|
|
/// NUL-terminated, valid for the process's lifetime.
|
|
pub const Arguments = struct {
|
|
/// argc — at least 1: argument 0 is the path or name this binary was
|
|
/// spawned as.
|
|
count: usize,
|
|
/// The argv pointers in the entry block (NULL-terminated after `count`
|
|
/// entries).
|
|
vector: [*]const [*:0]const u8,
|
|
|
|
/// Argument `index` (0 = the program's own path/name), or null if out of
|
|
/// range.
|
|
pub fn get(arguments: Arguments, index: usize) ?[:0]const u8 {
|
|
if (index >= arguments.count) return null;
|
|
return std.mem.span(arguments.vector[index]);
|
|
}
|
|
|
|
pub fn iterate(arguments: Arguments) Iterator {
|
|
return .{ .arguments = arguments };
|
|
}
|
|
|
|
pub const Iterator = struct {
|
|
arguments: Arguments,
|
|
index: usize = 0,
|
|
|
|
pub fn next(iterator: *Iterator) ?[:0]const u8 {
|
|
const argument = iterator.arguments.get(iterator.index) orelse return null;
|
|
iterator.index += 1;
|
|
return argument;
|
|
}
|
|
};
|
|
};
|
|
|
|
/// How a process ended — what a supervisor's restart policy reads: a clean exit
|
|
/// meant to stop, a fault wants a restart with backoff, killed means the
|
|
/// supervisor did it itself (docs/process-lifecycle.md).
|
|
pub const ExitReason = abi.ExitReason;
|
|
|
|
/// How dead child `id` ended. Ask after the exit notification arrives — the
|
|
/// kernel records the reason before it posts the notification, so this never
|
|
/// races it. Returns null for an id that never lived, is still alive, was
|
|
/// evicted from the kernel's bounded record, or is not this process's child
|
|
/// (the same authority gate as `kill`).
|
|
pub fn exitReason(id: u32) ?ExitReason {
|
|
const r = sc.systemCall1(.process_exit_reason, id);
|
|
if (r > ~@as(usize, 0) - 4095) return null; // a wrapped -errno
|
|
return @enumFromInt(r);
|
|
}
|
|
|
|
/// Subscribe `endpoint` to published exit events: every process death posts an
|
|
/// asynchronous notification with the same badge encoding as a supervisor's exit
|
|
/// notice (decode with `ipc.Received.isChildExit`/`childProcessId`). For stateful
|
|
/// services: release what the dead client held — file handles, subscriptions —
|
|
/// because a service must never depend on clients cleaning up after themselves
|
|
/// (docs/process-lifecycle.md). Ungated, like `system.processes`.
|
|
pub fn subscribeExits(endpoint: usize) bool {
|
|
return sc.systemCall1(.process_subscribe, endpoint) == 0;
|
|
}
|