feat: scheduler + cleanup

1 files changed, 186 insertions, 104 deletions

diff --git a/bridge/bridge.zig b/bridge/bridge.zig
index a8a2243..2c4da6a 100644
--- a/bridge/bridge.zig
+++ b/bridge/bridge.zig
@@ -1,22 +1,22 @@
-// so the thing is right, revo isn't really that low level and we need to have a
-// thin bridge to translate shit over. Its just to setup the VM, serial ports,
-// heap shit like that.
+// so the thing is right, revo isnt really that low level and we need to have a
+// thin bridge to translate shit over. its just to setup the vm, serial ports,
+// heap shit like that
 
 const std = @import("std");
 const revo = @import("revo");
 
-// all the VM's output goes here, boot injects this at runtime so the
-// bridge doesn't need to pull a serial port from its ass
+// all the vms output goes here, boot injects this at runtime so the
+// bridge doesnt need to pull a serial port from its ass
 pub const Sink = *const fn ([]const u8) void;
 fn noopSink(_: []const u8) void {}
 var sink: Sink = noopSink;
 
-// fan a multi-slice write payload out to the sink.
-// mirrors the shape of std.Io's file_write_streaming request so
-// an optional header, then the data whose LAST slice is repeated
-// splat times.
-// idk why zig chose these names, they are funny af.
-// NOTE: returns the total byte count written.
+// fan a multi slice write payload out to the sink
+// mirrors the shape of std.ios file_write_streaming request so
+// an optional header, then the data whose last slice is repeated
+// splat times
+// idk why zig chose these names, they are funny af
+// note: returns the total byte count written
 fn writeToSink(
     header: []const u8,
     data: []const []const u8,
@@ -39,7 +39,7 @@ fn writeToSink(
 }
 
 // every file write (stdout, stderr, whatever) routes to the serial port but we
-// don't have a filesystem or multiple sinks yet, so there's nowhere else to go
+// dont have a filesystem or multiple sinks yet, so theres nowhere else to go
 fn ioOperate(_: ?*anyopaque, operation: std.Io.Operation) std.Io.Cancelable!std.Io.Operation.Result {
     return switch (operation) {
         .file_write_streaming => |req| .{
@@ -53,7 +53,7 @@ fn ioOperate(_: ?*anyopaque, operation: std.Io.Operation) std.Io.Cancelable!std.
 
 // no timer wired up yet, so time stands still,
 // call me the time bender the way i fuck shit up
-// TODO: fine until we have the PIT/TSC
+// todo: fine until we have the pit/tsc
 fn ioNow(_: ?*anyopaque, _: std.Io.Clock) std.Io.Timestamp {
     return .{ .nanoseconds = 0 };
 }
@@ -68,40 +68,40 @@ fn ioSleep(_: ?*anyopaque, _: std.Io.Timeout) std.Io.Cancelable!void {}
 fn ioCrashHandler(_: ?*anyopaque) void {}
 
 // eval captures its own errors into a buffer, so this is never reached lol
-//  return Canceled rather than recursing into a stderr lock we can't provide
+//  return canceled rather than recursing into a stderr lock we cant provide
 fn ioLockStderr(_: ?*anyopaque, _: ?std.Io.Terminal.Mode) std.Io.Cancelable!std.Io.LockedStderr {
     return error.Canceled;
 }
 
 fn ioUnlockStderr(_: ?*anyopaque) void {}
 
-// start from std's all-failing vtable and override only what the VM touches.
+// start from stds all failing vtable and override only what the vm touches
 const io_vtable: std.Io.VTable = blk: {
-    var v = std.Io.failing.vtable.*;
-    v.operate = ioOperate;
-    v.now = ioNow;
-    v.clockResolution = ioClockResolution;
-    v.sleep = ioSleep;
-    v.crashHandler = ioCrashHandler;
-    v.lockStderr = ioLockStderr;
-    v.unlockStderr = ioUnlockStderr;
-    break :blk v;
+    var vtable = std.Io.failing.vtable.*;
+    vtable.operate = ioOperate;
+    vtable.now = ioNow;
+    vtable.clockResolution = ioClockResolution;
+    vtable.sleep = ioSleep;
+    vtable.crashHandler = ioCrashHandler;
+    vtable.lockStderr = ioLockStderr;
+    vtable.unlockStderr = ioUnlockStderr;
+    break :blk vtable;
 };
 
 const serial_io: std.Io = .{ .userdata = null, .vtable = &io_vtable };
 
-// A second IO used only as std's debug IO (for std.debug.print, which revo hits
-// on a few error paths). std's default debug IO is a threaded stderr writer that
-// doesn't exist on freestandin, and std.Io.failing's stderr path is literally
-// unreachable, so we give std a real one that drains to the same sink. Unlike
-// serial_io above, its lockStderr must return an actual File.Writer (std turns a
-// Canceled lock into a panic), and swapCancelProtection must not be unreachable.
+// a second io used only as stds debug io (for std.debug.print, which revo hits
+// on a few error paths). stds default debug io is a threaded stderr writer that
+// doesnt exist on freestandin, and std.io.failings stderr path is literally
+// unreachable, so we give std a real one that drains to the same sink. unlike
+// serial_io above, its lockstderr must return an actual file.writer (std turns a
+// canceled lock into a panic), and swapcancelprotection must not be unreachable
 var dbg_fw: std.Io.File.Writer = undefined;
 var dbg_fw_buf: [256]u8 = undefined;
 
 fn dbgLockStderr(_: ?*anyopaque, _: ?std.Io.Terminal.Mode) std.Io.Cancelable!std.Io.LockedStderr {
-    // File.stderr() reads posix.STDERR_FILENO, which doesn't exist on
-    // freestanding so we build the file by hand instead. ioOperate ignores
+    // file.stderr() reads posix.stderr_fileno, which doesnt exist on
+    // freestanding so we build the file by hand instead. iooperate ignores
     // the handle and routes every write to the sink regardless
     const stderr_file: std.Io.File = .{ .handle = undefined, .flags = .{ .nonblocking = false } };
     dbg_fw = stderr_file.writerStreaming(debug_io, &dbg_fw_buf);
@@ -115,22 +115,22 @@ fn dbgSwapCancel(_: ?*anyopaque, new: std.Io.CancelProtection) std.Io.CancelProt
 }
 
 const debug_io_vtable: std.Io.VTable = blk: {
-    var v = std.Io.failing.vtable.*;
-    v.operate = ioOperate;
-    v.now = ioNow;
-    v.clockResolution = ioClockResolution;
-    v.sleep = ioSleep;
-    v.crashHandler = ioCrashHandler;
-    v.lockStderr = dbgLockStderr;
-    v.unlockStderr = dbgUnlockStderr;
-    v.swapCancelProtection = dbgSwapCancel;
-    break :blk v;
+    var vtable = std.Io.failing.vtable.*;
+    vtable.operate = ioOperate;
+    vtable.now = ioNow;
+    vtable.clockResolution = ioClockResolution;
+    vtable.sleep = ioSleep;
+    vtable.crashHandler = ioCrashHandler;
+    vtable.lockStderr = dbgLockStderr;
+    vtable.unlockStderr = dbgUnlockStderr;
+    vtable.swapCancelProtection = dbgSwapCancel;
+    break :blk vtable;
 };
 
 pub const debug_io: std.Io = .{ .userdata = null, .vtable = &debug_io_vtable };
 
-// an unbuffered std.Io.Writer that drains straight to the sink, so we can render
-// revo's own error reports (which write to a std.Io.Writer) onto the console
+// an unbuffered std.io.writer that drains straight to the sink, so we can render
+// revos own error reports (which write to a std.io.writer) onto the console
 const SinkWriter = struct {
     interface: std.Io.Writer,
 
@@ -141,9 +141,9 @@ const SinkWriter = struct {
     fn drain(w: *std.Io.Writer, data: []const []const u8, splat: usize) std.Io.Writer.Error!usize {
         _ = w;
         var total: usize = 0;
-        for (data[0..data.len -| 1]) |s| {
-            if (s.len > 0) emit(s);
-            total += s.len;
+        for (data[0..data.len -| 1]) |slice| {
+            if (slice.len > 0) emit(slice);
+            total += slice.len;
         }
         const last = data[data.len -| 1];
         var i: usize = 0;
@@ -160,11 +160,11 @@ const SinkWriter = struct {
 const HostResult = revo.baselib.host.HostResult;
 const Data = revo.Value;
 
-// revo's only number type is f64 which is really fucking annoying
+// revos only number type is f64 which is really fucking annoying
 fn f64ToInt(comptime T: type, n: f64) ?T {
     if (!std.math.isFinite(n)) return null;
-    // go through @floatFromInt for the bounds: maxInt(u64) isn't representable
-    // as an f64 literal, so comparing against the comptime_int directly won't
+    // go through @floatfromint for the bounds: maxint(u64) isnt representable
+    // as an f64 literal, so comparing against the comptime_int directly wont
     // even compile bruh
     const min_f: f64 = @floatFromInt(std.math.minInt(T));
     const max_f: f64 = @floatFromInt(std.math.maxInt(T));
@@ -172,10 +172,17 @@ fn f64ToInt(comptime T: type, n: f64) ?T {
     return @intFromFloat(n);
 }
 
+// pull argument i as an integer of type t. args are already type checked to be
+// numbers by define(&.{.number,...}), so asnumopt cant be null, the result is
+// null only when the value is out of ts range (the host fn maps that to an error)
+fn argInt(comptime T: type, args: []const revo.Value, i: usize) ?T {
+    return f64ToInt(T, args[i].asNumOpt().?);
+}
+
 // pass shit to revo
 fn hostOutb(args: []const revo.Value, _: *revo.VM) anyerror!HostResult {
-    const port = f64ToInt(u16, args[0].asNumOpt().?) orelse return HostResult.other("outb: port out of range");
-    const val = f64ToInt(u8, args[1].asNumOpt().?) orelse return HostResult.other("outb: value out of range");
+    const port = argInt(u16, args, 0) orelse return HostResult.other("outb: port out of range");
+    const val = argInt(u8, args, 1) orelse return HostResult.other("outb: value out of range");
     asm volatile ("outb %[v], %[p]"
         :
         : [v] "{al}" (val),
@@ -186,7 +193,7 @@ fn hostOutb(args: []const revo.Value, _: *revo.VM) anyerror!HostResult {
 
 // pass shit to revo
 fn hostInb(args: []const revo.Value, _: *revo.VM) anyerror!HostResult {
-    const port = f64ToInt(u16, args[0].asNumOpt().?) orelse return HostResult.other("inb: port out of range");
+    const port = argInt(u16, args, 0) orelse return HostResult.other("inb: port out of range");
     const val = asm volatile ("inb %[p], %[r]"
         : [r] "={al}" (-> u8),
         : [p] "N{dx}" (port),
@@ -196,8 +203,8 @@ fn hostInb(args: []const revo.Value, _: *revo.VM) anyerror!HostResult {
 
 // pass shit to revo
 fn hostPuts(args: []const revo.Value, vm: *revo.VM) anyerror!HostResult {
-    const s = args[0].asString() orelse return HostResult.other("puts: not a string");
-    emit(vm.stringValue(s));
+    const string_id = args[0].asString() orelse return HostResult.other("puts: not a string");
+    emit(vm.stringValue(string_id));
     return HostResult.data(Data.new.nil());
 }
 
@@ -218,14 +225,14 @@ fn hostFbHeight(_: []const revo.Value, _: *revo.VM) anyerror!HostResult {
     return HostResult.data(Data.new.num(if (g_fb) |fb| fb.height else 0));
 }
 
-// color is 0xRRGGBB in the usual Limine 32-bpp layout
+// color is 0xrrggbb in the usual limine 32 bpp layout
 fn hostFillRect(args: []const revo.Value, _: *revo.VM) anyerror!HostResult {
-    const fb = g_fb orelse return HostResult.data(Data.new.nil()); // no screen, no-op
-    const x = f64ToInt(usize, args[0].asNumOpt().?) orelse return HostResult.other("fill_rect: bad x");
-    const y = f64ToInt(usize, args[1].asNumOpt().?) orelse return HostResult.other("fill_rect: bad y");
-    const w = f64ToInt(usize, args[2].asNumOpt().?) orelse return HostResult.other("fill_rect: bad w");
-    const h = f64ToInt(usize, args[3].asNumOpt().?) orelse return HostResult.other("fill_rect: bad h");
-    const color = f64ToInt(u32, args[4].asNumOpt().?) orelse return HostResult.other("fill_rect: bad color");
+    const fb = g_fb orelse return HostResult.data(Data.new.nil()); // no screen, no op
+    const x = argInt(usize, args, 0) orelse return HostResult.other("fill_rect: bad x");
+    const y = argInt(usize, args, 1) orelse return HostResult.other("fill_rect: bad y");
+    const w = argInt(usize, args, 2) orelse return HostResult.other("fill_rect: bad w");
+    const h = argInt(usize, args, 3) orelse return HostResult.other("fill_rect: bad h");
+    const color = argInt(u32, args, 4) orelse return HostResult.other("fill_rect: bad color");
 
     var yy = y;
     const y_end = @min(y + h, fb.height);
@@ -249,8 +256,8 @@ fn emit(bytes: []const u8) void {
 // shift the whole framebuffer up dy pixels and clear the freed rows
 fn hostFbScroll(args: []const revo.Value, _: *revo.VM) anyerror!HostResult {
     const fb = g_fb orelse return HostResult.data(Data.new.nil());
-    const dy = f64ToInt(usize, args[0].asNumOpt().?) orelse return HostResult.other("fb_scroll: bad dy");
-    const color = f64ToInt(u32, args[1].asNumOpt().?) orelse return HostResult.other("fb_scroll: bad color");
+    const dy = argInt(usize, args, 0) orelse return HostResult.other("fb_scroll: bad dy");
+    const color = argInt(u32, args, 1) orelse return HostResult.other("fb_scroll: bad color");
     if (dy == 0 or dy >= fb.height) return HostResult.data(Data.new.nil());
     const move_bytes = dy * fb.pitch;
     const total = fb.height * fb.pitch;
@@ -270,9 +277,20 @@ fn hostFbScroll(args: []const revo.Value, _: *revo.VM) anyerror!HostResult {
 pub const KernelOps = struct {
     phys_to_virt: *const fn (u64) u64,
     alloc_frame: *const fn () u64, // 0 on failure
-    create_addrspace: *const fn () u64, // pml4 phys, 0 on failure (raw 64-bit entry copy incl. possible NX bit -> not f64-representable)
-    run_process: *const fn (u64, u64, u64) void, // pml4, entry, ustack
+    create_addrspace: *const fn () u64, // pml4 phys, 0 on failure (raw 64 bit entry copy incl. possible nx bit -> not f64 representable)
+    spawn: *const fn (u64, u64, u64) void, // pml4, entry, ustack -> queue a ring 3 task
+    deliver_input: *const fn (u8) bool, // hand a byte to a read()-blocked task, false if none
+    proc_exited: *const fn () bool, // true once after a process exits (consumed)
     serial_next: *const fn () i64, // next mirrored serial byte, or -1 if empty
+    // read only state for revo to present (mem/uptime/ps/dump_memmap):
+    memmap_count: *const fn () u64,
+    memmap_base: *const fn (u64) u64,
+    memmap_len: *const fn (u64) u64,
+    memmap_kind: *const fn (u64) u64,
+    mem_free: *const fn () u64,
+    mem_total: *const fn () u64,
+    uptime: *const fn () u64,
+    proc_count: *const fn () u64,
     elf_phys: u64,
     elf_size: u64,
 };
@@ -281,14 +299,14 @@ var g_kops: ?KernelOps = null;
 // mem_read(phys, size) -> value: read 1/2/4/8 bytes of physical memory
 fn hostMemRead(args: []const revo.Value, _: *revo.VM) anyerror!HostResult {
     const ops = g_kops orelse return HostResult.other("no kernel ops");
-    const phys = f64ToInt(u64, args[0].asNumOpt().?) orelse return HostResult.other("mem_read: bad addr");
-    const size = f64ToInt(u64, args[1].asNumOpt().?) orelse return HostResult.other("mem_read: bad size");
-    const v = ops.phys_to_virt(phys);
+    const phys = argInt(u64, args, 0) orelse return HostResult.other("mem_read: bad addr");
+    const size = argInt(u64, args, 1) orelse return HostResult.other("mem_read: bad size");
+    const virt = ops.phys_to_virt(phys);
     const val: u64 = switch (size) {
-        1 => @as(*const u8, @ptrFromInt(v)).*,
-        2 => @as(*align(1) const u16, @ptrFromInt(v)).*,
-        4 => @as(*align(1) const u32, @ptrFromInt(v)).*,
-        8 => @as(*align(1) const u64, @ptrFromInt(v)).*,
+        1 => @as(*const u8, @ptrFromInt(virt)).*,
+        2 => @as(*align(1) const u16, @ptrFromInt(virt)).*,
+        4 => @as(*align(1) const u32, @ptrFromInt(virt)).*,
+        8 => @as(*align(1) const u64, @ptrFromInt(virt)).*,
         else => return HostResult.other("mem_read: size must be 1/2/4/8"),
     };
     return HostResult.data(Data.new.num(val));
@@ -297,9 +315,9 @@ fn hostMemRead(args: []const revo.Value, _: *revo.VM) anyerror!HostResult {
 // mem_copy(dst_phys, src_phys, len): raw copy between physical regions
 fn hostMemCopy(args: []const revo.Value, _: *revo.VM) anyerror!HostResult {
     const ops = g_kops orelse return HostResult.other("no kernel ops");
-    const dst = ops.phys_to_virt(f64ToInt(u64, args[0].asNumOpt().?) orelse return HostResult.other("mem_copy: bad dst"));
-    const src = ops.phys_to_virt(f64ToInt(u64, args[1].asNumOpt().?) orelse return HostResult.other("mem_copy: bad src"));
-    const len = f64ToInt(usize, args[2].asNumOpt().?) orelse return HostResult.other("mem_copy: bad len");
+    const dst = ops.phys_to_virt(argInt(u64, args, 0) orelse return HostResult.other("mem_copy: bad dst"));
+    const src = ops.phys_to_virt(argInt(u64, args, 1) orelse return HostResult.other("mem_copy: bad src"));
+    const len = argInt(usize, args, 2) orelse return HostResult.other("mem_copy: bad len");
     @memcpy(@as([*]u8, @ptrFromInt(dst))[0..len], @as([*]const u8, @ptrFromInt(src))[0..len]);
     return HostResult.data(Data.new.nil());
 }
@@ -307,8 +325,8 @@ fn hostMemCopy(args: []const revo.Value, _: *revo.VM) anyerror!HostResult {
 // mem_zero(phys, len)
 fn hostMemZero(args: []const revo.Value, _: *revo.VM) anyerror!HostResult {
     const ops = g_kops orelse return HostResult.other("no kernel ops");
-    const dst = ops.phys_to_virt(f64ToInt(u64, args[0].asNumOpt().?) orelse return HostResult.other("mem_zero: bad addr"));
-    const len = f64ToInt(usize, args[1].asNumOpt().?) orelse return HostResult.other("mem_zero: bad len");
+    const dst = ops.phys_to_virt(argInt(u64, args, 0) orelse return HostResult.other("mem_zero: bad addr"));
+    const len = argInt(usize, args, 1) orelse return HostResult.other("mem_zero: bad len");
     @memset(@as([*]u8, @ptrFromInt(dst))[0..len], 0);
     return HostResult.data(Data.new.nil());
 }
@@ -316,23 +334,23 @@ fn hostMemZero(args: []const revo.Value, _: *revo.VM) anyerror!HostResult {
 // mem_write(phys, val, size): write 1/2/4/8 bytes of physical memory
 fn hostMemWrite(args: []const revo.Value, _: *revo.VM) anyerror!HostResult {
     const ops = g_kops orelse return HostResult.other("no kernel ops");
-    const phys = f64ToInt(u64, args[0].asNumOpt().?) orelse return HostResult.other("mem_write: bad addr");
-    const val = f64ToInt(u64, args[1].asNumOpt().?) orelse return HostResult.other("mem_write: bad val");
-    const size = f64ToInt(u64, args[2].asNumOpt().?) orelse return HostResult.other("mem_write: bad size");
-    const v = ops.phys_to_virt(phys);
+    const phys = argInt(u64, args, 0) orelse return HostResult.other("mem_write: bad addr");
+    const val = argInt(u64, args, 1) orelse return HostResult.other("mem_write: bad val");
+    const size = argInt(u64, args, 2) orelse return HostResult.other("mem_write: bad size");
+    const virt = ops.phys_to_virt(phys);
     switch (size) {
-        1 => @as(*u8, @ptrFromInt(v)).* = @truncate(val),
-        2 => @as(*align(1) u16, @ptrFromInt(v)).* = @truncate(val),
-        4 => @as(*align(1) u32, @ptrFromInt(v)).* = @truncate(val),
-        8 => @as(*align(1) u64, @ptrFromInt(v)).* = val,
+        1 => @as(*u8, @ptrFromInt(virt)).* = @truncate(val),
+        2 => @as(*align(1) u16, @ptrFromInt(virt)).* = @truncate(val),
+        4 => @as(*align(1) u32, @ptrFromInt(virt)).* = @truncate(val),
+        8 => @as(*align(1) u64, @ptrFromInt(virt)).* = val,
         else => return HostResult.other("mem_write: size must be 1/2/4/8"),
     }
     return HostResult.data(Data.new.nil());
 }
 
-// invlpg(virt): flush one page from the TLB after remapping it
+// invlpg(virt): flush one page from the tlb after remapping it
 fn hostInvlpg(args: []const revo.Value, _: *revo.VM) anyerror!HostResult {
-    const virt = f64ToInt(u64, args[0].asNumOpt().?) orelse return HostResult.other("invlpg: bad addr");
+    const virt = argInt(u64, args, 0) orelse return HostResult.other("invlpg: bad addr");
     asm volatile ("invlpg (%[v])"
         :
         : [v] "r" (virt),
@@ -352,13 +370,28 @@ fn hostAsCreate(_: []const revo.Value, _: *revo.VM) anyerror!HostResult {
 
 fn hostProcRun(args: []const revo.Value, _: *revo.VM) anyerror!HostResult {
     const ops = g_kops orelse return HostResult.other("no kernel ops");
-    const as = f64ToInt(u64, args[0].asNumOpt().?) orelse return HostResult.other("proc_run: bad as");
-    const entry = f64ToInt(u64, args[1].asNumOpt().?) orelse return HostResult.other("proc_run: bad entry");
-    const ustack = f64ToInt(u64, args[2].asNumOpt().?) orelse return HostResult.other("proc_run: bad ustack");
-    ops.run_process(as, entry, ustack);
+    const as = argInt(u64, args, 0) orelse return HostResult.other("proc_run: bad as");
+    const entry = argInt(u64, args, 1) orelse return HostResult.other("proc_run: bad entry");
+    const ustack = argInt(u64, args, 2) orelse return HostResult.other("proc_run: bad ustack");
+    ops.spawn(as, entry, ustack); // queues the task, the scheduler runs it
     return HostResult.data(Data.new.nil());
 }
 
+// stdin_deliver(charcode) -> 1 if a read()-blocked process took it, else 0. the
+// revo key handler calls this before feeding its own line editor
+fn hostStdinDeliver(args: []const revo.Value, _: *revo.VM) anyerror!HostResult {
+    const ops = g_kops orelse return HostResult.other("no kernel ops");
+    const ch = argInt(u8, args, 0) orelse return HostResult.other("stdin_deliver: bad char");
+    return HostResult.data(Data.new.num(if (ops.deliver_input(ch)) @as(f64, 1) else 0));
+}
+
+// proc_exited() -> 1 once after a process exits, so the shell can reprint its
+// prompt below the programs output
+fn hostProcExited(_: []const revo.Value, _: *revo.VM) anyerror!HostResult {
+    const ops = g_kops orelse return HostResult.other("no kernel ops");
+    return HostResult.data(Data.new.num(if (ops.proc_exited()) @as(f64, 1) else 0));
+}
+
 // serial_next() -> byte or -1
 fn hostSerialNext(_: []const revo.Value, _: *revo.VM) anyerror!HostResult {
     const ops = g_kops orelse return HostResult.other("no kernel ops");
@@ -375,6 +408,43 @@ fn hostElfSize(_: []const revo.Value, _: *revo.VM) anyerror!HostResult {
     return HostResult.data(Data.new.num(ops.elf_size));
 }
 
+// read only state getters revo uses for mem/uptime/ps and dump_memmap
+fn hostMemmapCount(_: []const revo.Value, _: *revo.VM) anyerror!HostResult {
+    const ops = g_kops orelse return HostResult.other("no kernel ops");
+    return HostResult.data(Data.new.num(ops.memmap_count()));
+}
+fn hostMemmapBase(args: []const revo.Value, _: *revo.VM) anyerror!HostResult {
+    const ops = g_kops orelse return HostResult.other("no kernel ops");
+    const index = argInt(u64, args, 0) orelse return HostResult.other("memmap_base: bad index");
+    return HostResult.data(Data.new.num(ops.memmap_base(index)));
+}
+fn hostMemmapLen(args: []const revo.Value, _: *revo.VM) anyerror!HostResult {
+    const ops = g_kops orelse return HostResult.other("no kernel ops");
+    const index = argInt(u64, args, 0) orelse return HostResult.other("memmap_len: bad index");
+    return HostResult.data(Data.new.num(ops.memmap_len(index)));
+}
+fn hostMemmapKind(args: []const revo.Value, _: *revo.VM) anyerror!HostResult {
+    const ops = g_kops orelse return HostResult.other("no kernel ops");
+    const index = argInt(u64, args, 0) orelse return HostResult.other("memmap_kind: bad index");
+    return HostResult.data(Data.new.num(ops.memmap_kind(index)));
+}
+fn hostMemFree(_: []const revo.Value, _: *revo.VM) anyerror!HostResult {
+    const ops = g_kops orelse return HostResult.other("no kernel ops");
+    return HostResult.data(Data.new.num(ops.mem_free()));
+}
+fn hostMemTotal(_: []const revo.Value, _: *revo.VM) anyerror!HostResult {
+    const ops = g_kops orelse return HostResult.other("no kernel ops");
+    return HostResult.data(Data.new.num(ops.mem_total()));
+}
+fn hostUptime(_: []const revo.Value, _: *revo.VM) anyerror!HostResult {
+    const ops = g_kops orelse return HostResult.other("no kernel ops");
+    return HostResult.data(Data.new.num(ops.uptime()));
+}
+fn hostProcCount(_: []const revo.Value, _: *revo.VM) anyerror!HostResult {
+    const ops = g_kops orelse return HostResult.other("no kernel ops");
+    return HostResult.data(Data.new.num(ops.proc_count()));
+}
+
 fn registerPrimitives(vm: *revo.VM) !void {
     const define = revo.baselib.host.define;
     const T = revo.baselib.host.ParamType;
@@ -385,7 +455,7 @@ fn registerPrimitives(vm: *revo.VM) !void {
     try vm.registerGlobal("fb_height", try vm.installHost("fb_height", define(&[_]T{}, hostFbHeight)));
     try vm.registerGlobal("fill_rect", try vm.installHost("fill_rect", define(&[_]T{ .number, .number, .number, .number, .number }, hostFillRect)));
     try vm.registerGlobal("fb_scroll", try vm.installHost("fb_scroll", define(&[_]T{ .number, .number }, hostFbScroll)));
-    // low-level: memory + address spaces + process launch (revo's ELF loader)
+    // low level: memory + address spaces + process launch (revos elf loader)
     try vm.registerGlobal("mem_read", try vm.installHost("mem_read", define(&[_]T{ .number, .number }, hostMemRead)));
     try vm.registerGlobal("mem_copy", try vm.installHost("mem_copy", define(&[_]T{ .number, .number, .number }, hostMemCopy)));
     try vm.registerGlobal("mem_zero", try vm.installHost("mem_zero", define(&[_]T{ .number, .number }, hostMemZero)));
@@ -394,12 +464,22 @@ fn registerPrimitives(vm: *revo.VM) !void {
     try vm.registerGlobal("frame_alloc", try vm.installHost("frame_alloc", define(&[_]T{}, hostFrameAlloc)));
     try vm.registerGlobal("as_create", try vm.installHost("as_create", define(&[_]T{}, hostAsCreate)));
     try vm.registerGlobal("proc_run", try vm.installHost("proc_run", define(&[_]T{ .number, .number, .number }, hostProcRun)));
+    try vm.registerGlobal("stdin_deliver", try vm.installHost("stdin_deliver", define(&[_]T{.number}, hostStdinDeliver)));
+    try vm.registerGlobal("proc_exited", try vm.installHost("proc_exited", define(&[_]T{}, hostProcExited)));
     try vm.registerGlobal("serial_next", try vm.installHost("serial_next", define(&[_]T{}, hostSerialNext)));
     try vm.registerGlobal("elf_phys", try vm.installHost("elf_phys", define(&[_]T{}, hostElfPhys)));
     try vm.registerGlobal("elf_size", try vm.installHost("elf_size", define(&[_]T{}, hostElfSize)));
+    try vm.registerGlobal("memmap_count", try vm.installHost("memmap_count", define(&[_]T{}, hostMemmapCount)));
+    try vm.registerGlobal("memmap_base", try vm.installHost("memmap_base", define(&[_]T{.number}, hostMemmapBase)));
+    try vm.registerGlobal("memmap_len", try vm.installHost("memmap_len", define(&[_]T{.number}, hostMemmapLen)));
+    try vm.registerGlobal("memmap_kind", try vm.installHost("memmap_kind", define(&[_]T{.number}, hostMemmapKind)));
+    try vm.registerGlobal("mem_free", try vm.installHost("mem_free", define(&[_]T{}, hostMemFree)));
+    try vm.registerGlobal("mem_total", try vm.installHost("mem_total", define(&[_]T{}, hostMemTotal)));
+    try vm.registerGlobal("uptime", try vm.installHost("uptime", define(&[_]T{}, hostUptime)));
+    try vm.registerGlobal("proc_count", try vm.installHost("proc_count", define(&[_]T{}, hostProcCount)));
 }
 
-// the VM outlives boot() now, so we juts make this hoe static
+// the vm outlives boot() now, so we juts make this hoe static
 var g_vm: ?*revo.VM = null;
 
 const init_program = @embedFile("k_font") ++ "\n" ++
@@ -415,9 +495,9 @@ pub fn boot(alloc: std.mem.Allocator, out: Sink, fb: ?Fb, ops: ?KernelOps) void
     g_fb = fb;
     g_kops = ops;
 
-    // NOTE: we drive the VM directly (compile -> run) instead of the high-level
-    // Runtime.eval wrapper, which has a latent type error in revo that only
-    // trips when analyzed. same low-level path revo's own wasm entry uses.
+    // note: we drive the vm directly (compile -> run) instead of the high level
+    // runtime.eval wrapper, which has a latent type error in revo that only
+    // trips when analyzed. same low level path revos own wasm entry uses
     const VM = revo.VM;
     const vm = alloc.create(VM) catch {
         out("bridge: OOM creating VM\r\n");
@@ -454,7 +534,7 @@ pub fn boot(alloc: std.mem.Allocator, out: Sink, fb: ?Fb, ops: ?KernelOps) void
         },
     };
 
-    // NOTE: on purpose we don't free artifact.instructions/spans cause on_key's
+    // note: on purpose we dont free artifact.instructions/spans cause on_keys
     //       bytecode lives in there and we call it for the life of the kernel
     vm.setProgramDebugInfo(artifact.spans, "", "kernel") catch {
         out("bridge: setProgramDebugInfo failed\r\n");
@@ -466,7 +546,7 @@ pub fn boot(alloc: std.mem.Allocator, out: Sink, fb: ?Fb, ops: ?KernelOps) void
         return;
     };
     switch (eval_result) {
-        .ok => g_vm = vm, // handler is defined so hand the VM to the event loop
+        .ok => g_vm = vm, // handler is defined so hand the vm to the event loop
         .err => |failure| {
             out("\r\nbridge: runtime error: ");
             var sw = SinkWriter.init();
@@ -477,8 +557,8 @@ pub fn boot(alloc: std.mem.Allocator, out: Sink, fb: ?Fb, ops: ?KernelOps) void
 }
 
 // called from the boot event loop for each raw scancode
-// hand it to revo's on_key
-// runs in normal context (not the ISR), so allocation is fine here
+// hand it to revos on_key
+// runs in normal context (not the isr), so allocation is fine here
 // i think
 pub fn onKey(scancode: u8) void {
     const vm = g_vm orelse return;
@@ -492,11 +572,13 @@ pub fn onKey(scancode: u8) void {
 
 // render any serial output produced while handling the key
 fn flushConsole(vm: *revo.VM) void {
-    const f = vm.getGlobal("flush_console") orelse return;
-    if (f.asFunction() == null) return;
-    _ = vm.callFunctionParts(f, null, &.{}, null) catch {};
+    const func = vm.getGlobal("flush_console") orelse return;
+    if (func.asFunction() == null) return;
+    _ = vm.callFunctionParts(func, null, &.{}, null) catch {};
 }
 
+// called each pit tick from the event loop, hands it to revos on_tick, which
+// renders any process output and blinks the cursor
 pub fn onTick(ticks: u64) void {
     const vm = g_vm orelse return;
     const cb = vm.getGlobal("on_tick") orelse return;