summaryrefslogtreecommitdiff
path: root/src/host/control.zig
diff options
context:
space:
mode:
Diffstat (limited to 'src/host/control.zig')
-rw-r--r--src/host/control.zig707
1 files changed, 707 insertions, 0 deletions
diff --git a/src/host/control.zig b/src/host/control.zig
new file mode 100644
index 0000000..943316c
--- /dev/null
+++ b/src/host/control.zig
@@ -0,0 +1,707 @@
+//! Local 9P controls, serviced on the frame thread: no SDL or state races.
+const std = @import("std");
+const c9 = @import("cloud9");
+const c = @import("c");
+const abi = @import("abi");
+const Host = @import("Host.zig");
+const Presentation = @import("Presentation.zig");
+const state_files = @import("state_files.zig");
+const script = @import("script.zig");
+const Console = @import("Console.zig");
+const fs = c9.fs;
+const transport = c9.transport;
+const Backend = struct {
+ pub const Req = fs.Req;
+ pub const Reply = fs.Reply;
+};
+const Server = fs.Server(Backend, .{ .fid_capacity = 32, .slot_capacity = 4, .name_capacity = 64 });
+const msize = 16384;
+/// The files, a row each: what lookup, readdir and getattr answer. A
+/// file's node is its number here.
+const File = enum(u64) { @"/" = 1, ctl, status, log, @"screen.png", profile, @"profile-trace", @"timing-trace", @"presentation-trace", README, commands, sketch = 1 << 63, state = @bitCast(state_files.root) };
+const files = std.enums.EnumArray(File, struct { mode: u16 = 0o400, doc: []const u8 }).init(.{
+ .@"/" = .{ .mode = 0o700, .doc = "" },
+ .ctl = .{ .mode = 0o600, .doc = "write a verb a line, of those below: ctl's own, the input a script plays (live, no frame of its own), the console's; any other line goes to the sketch (commands lists its words)" },
+ .status = .{ .doc = "name, canvas size, playback mode, gpu, and the screenshot's state" },
+ .log = .{ .doc = "the console's last five lines" },
+ .@"screen.png" = .{ .doc = "the next frame, as PNG: an open waits for it to be drawn, and pins its own copy" },
+ .profile = .{ .doc = "with --profile-gpu: label, count, mean, worst, p95 and p99 ms, tab-separated" },
+ .@"profile-trace" = .{ .doc = "with --profile-gpu: label,sample,ns, the samples kept, as CSV" },
+ .@"timing-trace" = .{ .doc = "index,frame_ns,work_ns,outside_work_ns, the frames kept, as CSV" },
+ .@"presentation-trace" = .{ .doc = "on Wayland: presentation feedback per frame, as CSV" },
+ .README = .{ .doc = "this: a line a file, ctl's verbs under it, a line a State file under state/" },
+ .commands = .{ .doc = "every verb ctl takes, a line each, the sketch's words last" },
+ .sketch = .{ .mode = 0o700, .doc = "the sketch's own files, which the host never serves: reserved, empty" },
+ .state = .{ .mode = 0o700, .doc = "the sketch's State: a directory per struct and array, a file per value; a read is the value, a write what set does (a jump); an array of numbers is one file of its values, blank-separated" },
+});
+
+/// The verbs `ctl` takes beside the console's lines.
+const Verb = enum { screenshot, @"profile-reset" };
+const verbs = std.enums.EnumArray(Verb, []const u8).init(.{
+ .screenshot = "captures the next frame (status says when); screen.png's open does it itself",
+ .@"profile-reset" = "clears profile's counters and frame count, keeping its labels",
+});
+
+const Connection = struct {
+ fd: c_int = -1,
+ server: Server = undefined,
+ input: [msize]u8 = undefined,
+ output: [msize * 2]u8 = undefined,
+ incoming: [msize]u8 = undefined,
+ used: usize = 0,
+ snapshots: [32]?[]u8 = @splat(null),
+
+ fn close(self: *Connection, a: std.mem.Allocator) void {
+ if (self.fd < 0) return;
+ transport.close(self.fd);
+ for (&self.snapshots) |*snapshot| if (snapshot.*) |bytes| {
+ a.free(bytes);
+ snapshot.* = null;
+ };
+ self.fd = -1;
+ }
+};
+
+pub const Control = struct {
+ allocator: std.mem.Allocator,
+ path: [:0]u8,
+ listener: c_int,
+ /// Serving with no sketch running (`fs` with it closed): the State to
+ /// show and where it came from; the host is not touched.
+ offline: ?Offline = null,
+ connections: [4]Connection = @splat(.{}),
+ png: []u8 = &.{},
+ capture_pending: bool = false,
+ generation: u64 = 0,
+ capture_error: ?anyerror = null,
+
+ pub fn init(a: std.mem.Allocator, path: []const u8) !*Control {
+ const self = try a.create(Control);
+ errdefer a.destroy(self);
+ const z = try a.dupeSentinel(u8, path, 0);
+ errdefer a.free(z);
+ // Refuse an existing path; never unlink another process's socket.
+ const fd = try transport.listenFd(.{ .unix = z }, 4);
+ errdefer {
+ transport.close(fd);
+ _ = std.c.unlink(z);
+ }
+ if (std.c.chmod(z, 0o600) != 0) return error.SocketPermissions;
+ self.* = .{ .allocator = a, .path = z, .listener = fd };
+ return self;
+ }
+
+ /// Listens at `where`: a socket path, or a name posted as
+ /// `$XDG_RUNTIME_DIR/9p/sketchbook/<where>` (a stale entry replaced, a
+ /// live one refused).
+ pub fn open(a: std.mem.Allocator, environ: *const std.process.Environ.Map, where: []const u8) !*Control {
+ if (std.mem.startsWith(u8, where, "/")) return init(a, where);
+ var buf: [c9.post.sun_path_len]u8 = undefined;
+ const path = try registered(environ, where, &buf);
+ const dir = path[0..std.mem.lastIndexOfScalar(u8, path, '/').?];
+ var dir_buf: [c9.post.sun_path_len]u8 = undefined;
+ for ([_]usize{ dir.len - "/sketchbook".len, dir.len }) |n| _ = std.c.mkdir(std.fmt.bufPrintSentinel(&dir_buf, "{s}", .{dir[0..n]}, 0) catch unreachable, 0o700);
+ switch (c9.post.probe(path)) {
+ .live => return error.AlreadyPosted,
+ .stale => _ = std.c.unlink(path),
+ .none => {},
+ }
+ return init(a, path);
+ }
+
+ /// Serves one client on `fd` until it hangs up: `fs` with no sketch
+ /// running, on a thread of its own.
+ pub fn serveOffline(self: *Control, fd: c_int) void {
+ const conn = self.allocator.create(Connection) catch return transport.close(fd);
+ defer self.allocator.destroy(conn);
+ conn.* = .{ .fd = fd };
+ conn.server = .init(.{ .in = &conn.input, .out = &conn.output, .root = 1 });
+ var host: Host = undefined; // Offline, nothing reads it.
+ while (true) self.service(&host, conn) catch break;
+ conn.close(self.allocator);
+ }
+
+ pub fn deinit(self: *Control) void {
+ for (&self.connections) |*conn| conn.close(self.allocator);
+ transport.close(self.listener);
+ _ = std.c.unlink(self.path);
+ self.allocator.free(self.path);
+ self.allocator.free(self.png);
+ self.allocator.destroy(self);
+ }
+
+ pub fn poll(self: *Control, host: *Host) void {
+ if (transport.acceptFd(self.listener, false) catch null) |fd| {
+ var accepted = false;
+ for (&self.connections) |*conn| if (conn.fd < 0) {
+ conn.fd = fd;
+ conn.used = 0;
+ conn.server = .init(.{ .in = &conn.input, .out = &conn.output, .root = 1 });
+ accepted = true;
+ break;
+ };
+ if (!accepted) transport.close(fd);
+ }
+ for (&self.connections) |*conn| {
+ if (conn.fd < 0) continue;
+ self.service(host, conn) catch conn.close(self.allocator);
+ }
+ }
+
+ fn service(self: *Control, host: *Host, conn: *Connection) !void {
+ // Bound work per frame, including clients which continually write.
+ for (0..32) |_| {
+ var progressed = false;
+ if (conn.used != 0) {
+ const consumed = conn.server.push(conn.incoming[0..conn.used]);
+ std.mem.copyForwards(u8, &conn.incoming, conn.incoming[consumed..conn.used]);
+ conn.used -= consumed;
+ progressed = consumed != 0;
+ }
+ while (conn.server.retry()) |req| self.answer(host, conn, req, true);
+ while (conn.server.next()) |req| self.answer(host, conn, req, false);
+ if (conn.server.protocol.dead) return error.Closed;
+ if (conn.server.output().len > 0) {
+ if (try transport.write(conn.fd, conn.server.output())) |n| {
+ if (n == 0) return error.Closed;
+ conn.server.wrote(n);
+ progressed = true;
+ }
+ }
+ if (conn.used < conn.incoming.len) {
+ if (try transport.read(conn.fd, conn.incoming[conn.used..])) |n| {
+ if (n == 0) return error.Closed;
+ conn.used += n;
+ progressed = true;
+ }
+ }
+ if (!progressed) break;
+ }
+ }
+
+ /// Answers a request, or parks it: an open of screen.png asks for the
+ /// next frame and waits for it, asked again (`retried`) each frame
+ /// until the capture has landed.
+ fn answer(self: *Control, host: *Host, conn: *Connection, req: fs.Req, retried: bool) void {
+ var reply: fs.Reply = .{ .tag = req.tag };
+ var buffer: [msize]u8 = undefined;
+ if (!retried and req.op == .open and req.node == @backingInt(File.@"screen.png")) {
+ self.capture_pending = true;
+ self.capture_error = null;
+ }
+ const bytes = self.respond(host, conn, req, &reply, &buffer) catch |err| blk: {
+ reply = if (err == error.CapturePending) .{ .tag = req.tag, .status = .again } else .{ .tag = req.tag, .status = .err, .errno = fs.E.INVAL, .ename = if (err == error.SketchNotRunning) self.offline.?.from else @errorName(err) };
+ break :blk &.{};
+ };
+ conn.server.reply(&reply, bytes);
+ }
+
+ fn respond(self: *Control, host: *Host, conn: *Connection, req: fs.Req, reply: *fs.Reply, buffer: []u8) ![]const u8 {
+ // Nodes from 2^63 are the sketch's: none is served but sketch/.
+ if (req.node > @backingInt(File.sketch)) return error.UnknownFile;
+ if (req.node & @as(u64, @bitCast(state_files.root)) != 0) return stateRespond(self, host, conn, req, reply, buffer);
+ const file = std.enums.fromInt(File, req.node) orelse return error.UnknownFile;
+ if (self.offline != null and (req.op == .write or (req.op == .open or req.op == .read) and file != .README and file != .commands and file != .ctl and file != .@"/" and file != .sketch)) return error.SketchNotRunning;
+ switch (req.op) {
+ .lookup => {
+ if (file == .sketch) return error.UnknownFile;
+ if (file != .@"/") return error.NotDirectory;
+ const found = std.meta.stringToEnum(File, req.data) orelse return error.UnknownFile;
+ if (found == .@"/") return error.UnknownFile;
+ reply.attr = self.attr(@backingInt(found));
+ },
+ .getattr => reply.attr = self.attr(req.node),
+ .open => {
+ if (file == .@"screen.png" or file == .@"profile-trace" or file == .@"timing-trace" or file == .@"presentation-trace" or file == .README or file == .commands) {
+ if (file == .@"screen.png") {
+ if (self.capture_pending) return error.CapturePending;
+ if (self.capture_error) |err| return err;
+ if (self.png.len == 0) return error.CaptureScreenshotFirst;
+ }
+ for (&conn.snapshots, 1..) |*slot, handle| if (slot.* == null) {
+ slot.* = switch (file) {
+ .@"screen.png" => try self.allocator.dupe(u8, self.png),
+ .@"profile-trace" => try self.trace(host),
+ .@"timing-trace" => try self.timingTrace(host),
+ .README, .commands => blk: {
+ var text: std.Io.Writer.Allocating = .init(self.allocator);
+ defer text.deinit();
+ const layout = if (self.offline) |o| o.layout else host.state.layout;
+ if (file == .README) try readme(layout, &text.writer) else try verbLines(&text.writer, "", if (self.offline) |o| o.completions else host.completions);
+ break :blk try text.toOwnedSlice();
+ },
+ else => try self.presentationTrace(host),
+ };
+ reply.handle = @intCast(handle);
+ return &.{};
+ };
+ return error.TooManySnapshots;
+ }
+ },
+ .release => if (req.opened and req.handle > 0 and req.handle <= conn.snapshots.len) {
+ const slot = &conn.snapshots[req.handle - 1];
+ if (slot.*) |bytes| self.allocator.free(bytes);
+ slot.* = null;
+ },
+ .readdir => {
+ if (file == .sketch) return &.{};
+ if (file != .@"/") return error.NotDirectory;
+ var used: usize = 0;
+ for (std.enums.values(File)[1..], 0..) |f, index| {
+ if (index < req.off) continue;
+ const name = @tagName(f);
+ std.mem.writeInt(u64, buffer[used..][0..8], @backingInt(f), .little);
+ buffer[used + 8] = @intFromBool(f == .state or f == .sketch);
+ buffer[used + 9] = @intCast(name.len);
+ @memcpy(buffer[used + 10 ..][0..name.len], name);
+ used += 10 + name.len;
+ }
+ return buffer[0..used];
+ },
+ .read => {
+ var writer: std.Io.Writer = .fixed(buffer);
+ const bytes: []const u8 = switch (file) {
+ .ctl => "Write a verb a line: commands lists them, README says what each does.\n",
+ .status => blk: {
+ try writer.print("name {s}\nsize {d} {d}\nmode {t}\ngpu {s}\nscreenshot_pending {}\nscreenshot_generation {d}\nscreenshot_error {s}\n", .{ host.name, host.canvas[0], host.canvas[1], host.timeline.mode, if (host.gpu != null) "yes" else "no", self.capture_pending, self.generation, if (self.capture_error) |err| @errorName(err) else "none" });
+ break :blk writer.buffered();
+ },
+ .log => blk: {
+ for (host.console.lines) |line| {
+ try writer.writeAll(line.bytes[0..line.len]);
+ try writer.writeByte('\n');
+ }
+ break :blk writer.buffered();
+ },
+ .@"screen.png", .@"profile-trace", .@"timing-trace", .@"presentation-trace", .README, .commands => if (req.handle > 0 and req.handle <= conn.snapshots.len) conn.snapshots[req.handle - 1] orelse return error.InvalidHandle else return error.InvalidHandle,
+ .profile => blk: {
+ const gpu = if (host.passes) |*gpu| gpu else return error.ProfilingDisabled;
+ const profile = if (gpu.profile) |*profile| profile else return error.ProfilingDisabled;
+ try writer.print("# CPU wall milliseconds including GPU submission and fence wait; not hardware timestamps\n# frames {d}\nlabel\tcount\tmean_ms\tworst_ms\tp95_ms\tp99_ms\n", .{gpu.frame - profile.start_frame});
+ var entries = profile.entries.iterator();
+ while (entries.next()) |entry| {
+ const value = entry.value_ptr;
+ const percentiles = value.percentiles();
+ const count: f64 = @floatFromInt(@max(value.count, 1));
+ try writer.print("{s}\t{d}\t{d:.6}\t{d:.6}\t{d:.6}\t{d:.6}\n", .{ entry.key_ptr.*, value.count, @as(f64, @floatFromInt(value.total)) / count / std.time.ns_per_ms, @as(f64, @floatFromInt(value.worst)) / std.time.ns_per_ms, @as(f64, @floatFromInt(percentiles[0])) / std.time.ns_per_ms, @as(f64, @floatFromInt(percentiles[1])) / std.time.ns_per_ms });
+ }
+ break :blk writer.buffered();
+ },
+ .@"/", .state, .sketch => return error.NotFile,
+ };
+ return window(bytes, req.off, req.size);
+ },
+ .write => {
+ if (file != .ctl) return error.ReadOnly;
+ if (req.data.len > 4096 or std.mem.indexOfScalar(u8, req.data, 0) != null) return error.InvalidCommand;
+ var lines = std.mem.tokenizeScalar(u8, req.data, '\n');
+ while (lines.next()) |raw| {
+ const line = std.mem.trim(u8, raw, " \t\r");
+ const verb = std.meta.stringToEnum(Verb, line) orelse {
+ var words = std.mem.tokenizeAny(u8, line, " \t");
+ const input = std.meta.stringToEnum(script.Verb, words.next() orelse "");
+ if (input != null and script.verbs.get(input.?).input) {
+ try script.input(host, input.?, &words, c.SDL_GetTicksNS());
+ } else try host.runLine(line, c.SDL_GetTicksNS());
+ continue;
+ };
+ switch (verb) {
+ .screenshot => {
+ self.capture_pending = true;
+ self.capture_error = null;
+ },
+ .@"profile-reset" => {
+ const gpu = if (host.passes) |*gpu| gpu else return error.ProfilingDisabled;
+ const profile = if (gpu.profile) |*profile| profile else return error.ProfilingDisabled;
+ for (profile.entries.values()) |*entry| entry.* = .{};
+ profile.start_frame = gpu.frame;
+ },
+ }
+ }
+ reply.written = @intCast(req.data.len);
+ },
+ .setattr => {
+ if (file != .ctl or !req.truncate) return error.ReadOnly;
+ reply.attr = self.attr(req.node);
+ },
+ }
+ return &.{};
+ }
+
+ fn trace(self: *Control, host: *Host) ![]u8 {
+ const gpu = if (host.passes) |*gpu| gpu else return error.ProfilingDisabled;
+ const profile = if (gpu.profile) |*profile| profile else return error.ProfilingDisabled;
+ const buffer = try self.allocator.alloc(u8, 256 << 10);
+ defer self.allocator.free(buffer);
+ var writer: std.Io.Writer = .fixed(buffer);
+ try writer.writeAll("label,sample,ns\n");
+ var entries = profile.entries.iterator();
+ while (entries.next()) |entry| {
+ const value = entry.value_ptr;
+ for (0..value.retained()) |i| {
+ try writer.writeByte('"');
+ for (entry.key_ptr.*) |ch| {
+ if (ch == '"') try writer.writeByte('"');
+ try writer.writeByte(ch);
+ }
+ try writer.print("\",{d},{d}\n", .{ value.count - value.retained() + i + 1, value.sample(i) });
+ }
+ }
+ return self.allocator.dupe(u8, writer.buffered());
+ }
+
+ fn timingTrace(self: *Control, host: *const Host) ![]u8 {
+ var csv: std.ArrayList(u8) = .empty;
+ errdefer csv.deinit(self.allocator);
+ try csv.appendSlice(self.allocator, "index,frame_ns,work_ns,outside_work_ns\n");
+ for (0..host.timing.count) |i| {
+ const sample = host.timing.sampleAt(i);
+ try csv.print(self.allocator, "{d},{d},{d},{d}\n", .{ i, sample.frame, sample.work, sample.frame -| sample.work });
+ }
+ return csv.toOwnedSlice(self.allocator);
+ }
+
+ fn presentationTrace(self: *Control, host: *const Host) ![]u8 {
+ var csv: std.Io.Writer.Allocating = .init(self.allocator);
+ defer csv.deinit();
+ try Presentation.csv(host.presentation, &csv.writer);
+ if (csv.written().len > 2 << 20) return error.TraceTooLarge;
+ return csv.toOwnedSlice();
+ }
+
+ fn attr(self: *Control, node: u64) fs.Attr {
+ const file: File = @fromBackingInt(@intCast(node));
+ return .{ .name = @tagName(file), .node = node, .dir = file == .@"/" or file == .state or file == .sketch, .mode = files.get(file).mode, .size = if (file == .@"screen.png") self.png.len else 0, .version = if (file == .@"screen.png") @truncate(self.generation) else 0 };
+ }
+
+ pub fn capture(self: *Control, surface: *c.SDL_Surface) void {
+ self.capture_pending = false;
+ self.save(surface) catch |err| {
+ self.capture_error = err;
+ };
+ }
+
+ fn save(self: *Control, surface: *c.SDL_Surface) !void {
+ const stream = c.SDL_IOFromDynamicMem() orelse return error.CaptureStream;
+ defer _ = c.SDL_CloseIO(stream);
+ if (!c.SDL_SavePNG_IO(surface, stream, false)) return error.EncodePng;
+ const size = c.SDL_GetIOSize(stream);
+ if (size <= 0) return error.EncodePng;
+ const pointer = c.SDL_GetPointerProperty(c.SDL_GetIOProperties(stream), c.SDL_PROP_IOSTREAM_DYNAMIC_MEMORY_POINTER, null) orelse return error.EncodePng;
+ const png = try self.allocator.dupe(u8, @as([*]const u8, @ptrCast(pointer))[0..@intCast(size)]);
+ self.allocator.free(self.png);
+ self.png = png;
+ self.generation += 1;
+ }
+};
+
+/// The README: a line a file, ctl's verbs indented under it and the
+/// State's files under state/, in the shape cloud9's `help` reads.
+fn readme(layout: @import("memory.zig").Layout, w: *std.Io.Writer) !void {
+ for (std.enums.values(File)[1..]) |f| {
+ const name = @tagName(f);
+ const dir = f == .state or f == .sketch;
+ try w.print("{s}{s}", .{ name, if (dir) "/" else "" });
+ try w.splatByteAll(' ', @max(1, 41 -| (name.len + @intFromBool(dir))));
+ try w.print("{s}\n", .{files.get(f).doc});
+ if (f == .ctl) try verbLines(w, " ", &.{});
+ if (f == .state) try state_files.readme(layout, w);
+ }
+}
+
+/// A line a verb ctl takes: ctl's own, the input verbs, the console's,
+/// then `sketch`'s words.
+fn verbLines(w: *std.Io.Writer, indent: []const u8, sketch: []const []const u8) !void {
+ for (std.enums.values(Verb)) |v| try verbLine(w, indent, @tagName(v), "", verbs.get(v));
+ for (std.enums.values(script.Verb)) |v| if (script.verbs.get(v).input) try verbLine(w, indent, @tagName(v), script.verbs.get(v).args, script.verbs.get(v).doc);
+ for (std.enums.values(Console.Verb)) |v| try verbLine(w, indent, @tagName(v), Console.verbs.get(v).args, Console.verbs.get(v).doc);
+ for (sketch) |word| try w.print("{s}{s}\n", .{ indent, word });
+}
+
+fn verbLine(w: *std.Io.Writer, indent: []const u8, name: []const u8, args: []const u8, doc: []const u8) !void {
+ try w.print("{s}{s}{s}{s}", .{ indent, name, if (args.len > 0) " " else "", args });
+ try w.splatByteAll(' ', @max(1, 37 -| (name.len + args.len + @intFromBool(args.len > 0))));
+ try w.print("{s}\n", .{doc});
+}
+
+/// Under `state/`: the live State as files (state_files.zig), a write
+/// run as the console's `set`.
+fn stateRespond(self: *Control, host: *Host, conn: *Connection, req: fs.Req, reply: *fs.Reply, buffer: []u8) ![]const u8 {
+ const layout = if (self.offline) |o| o.layout else host.state.layout;
+ const node: state_files.Node = @bitCast(req.node);
+ if (!state_files.valid(layout, node)) return error.StateLayoutChangedWalkAgain;
+ const dir = state_files.isDir(layout, node);
+ const mode: u16 = if (dir) 0o700 else if (state_files.writable(layout, node)) 0o600 else 0o400;
+ switch (req.op) {
+ .lookup => {
+ if (!dir) return error.NotDirectory;
+ const child = state_files.lookup(layout, node, req.data) orelse return error.UnknownField;
+ const child_dir = state_files.isDir(layout, child);
+ reply.attr = .{ .node = @bitCast(child), .dir = child_dir, .mode = if (child_dir) 0o700 else if (state_files.writable(layout, child)) 0o600 else 0o400 };
+ },
+ .getattr => reply.attr = .{ .node = req.node, .dir = dir, .mode = mode },
+ .setattr => {
+ if (mode != 0o600 or !req.truncate) return error.ReadOnly;
+ reply.attr = .{ .node = req.node, .mode = mode };
+ },
+ // A value is read as it was at the open: it changes every frame,
+ // and its length with it.
+ .open => if (!dir) for (&conn.snapshots, 1..) |*slot, handle| if (slot.* == null) {
+ var text: std.Io.Writer.Allocating = .init(self.allocator);
+ defer text.deinit();
+ try state_files.read(layout, if (self.offline) |o| o.bytes else host.live(), node, &text.writer);
+ slot.* = try text.toOwnedSlice();
+ reply.handle = @intCast(handle);
+ break;
+ } else return error.TooManySnapshots,
+ .release => if (req.opened and req.handle > 0 and req.handle <= conn.snapshots.len) {
+ const slot = &conn.snapshots[req.handle - 1];
+ if (slot.*) |bytes| self.allocator.free(bytes);
+ slot.* = null;
+ },
+ .readdir => {
+ if (!dir) return error.NotDirectory;
+ return buffer[0..state_files.readdir(layout, node, req.off, buffer)];
+ },
+ .read => {
+ if (dir) return error.NotFile;
+ const bytes = if (req.handle > 0 and req.handle <= conn.snapshots.len) conn.snapshots[req.handle - 1] orelse return error.InvalidHandle else return error.InvalidHandle;
+ return window(bytes, req.off, req.size);
+ },
+ .write => {
+ if (mode != 0o600) return error.ReadOnly;
+ if (self.offline != null) return error.SketchNotRunning;
+ var w: std.Io.Writer = .fixed(buffer);
+ w.writeAll("set ") catch unreachable;
+ state_files.path(layout, node, &w) catch return error.ValueTooLong;
+ w.writeByte(' ') catch return error.ValueTooLong;
+ for (std.mem.trim(u8, req.data, " \t\r\n")) |byte| w.writeByte(if (byte == '\n') ' ' else byte) catch return error.ValueTooLong;
+ try host.runLine(w.buffered(), c.SDL_GetTicksNS());
+ reply.written = @intCast(req.data.len);
+ },
+ }
+ return &.{};
+}
+
+/// The State `fs` shows with no sketch running, and its words for what a
+/// running one would answer.
+pub const Offline = struct {
+ layout: @import("memory.zig").Layout,
+ bytes: []const u8,
+ completions: []const []const u8,
+ /// "drat-meout is not running: ..."
+ from: []const u8,
+};
+
+/// `$XDG_RUNTIME_DIR/9p/sketchbook/<name>`, where a sketch posts its tree.
+pub fn registered(environ: *const std.process.Environ.Map, name: []const u8, buf: []u8) ![:0]u8 {
+ if (!c9.post.legalName(name)) return error.IllegalName;
+ const runtime = environ.get("XDG_RUNTIME_DIR") orelse return error.NotRuntimeDir;
+ return std.fmt.bufPrintSentinel(buf, "{s}/9p/sketchbook/{s}", .{ runtime, name }, 0) catch error.NameTooLong;
+}
+
+fn window(bytes: []const u8, offset: u64, count: u32) []const u8 {
+ if (offset >= bytes.len) return &.{};
+ const start: usize = @intCast(offset);
+ return bytes[start..][0..@min(count, bytes.len - start)];
+}
+
+test "9P reads respect offsets, counts and EOF" {
+ try std.testing.expectEqualStrings("cd", window("abcdef", 2, 2));
+ try std.testing.expectEqualStrings("ef", window("abcdef", 4, 200));
+ try std.testing.expectEqualStrings("", window("abcdef", std.math.maxInt(u64), 10));
+}
+
+test "control writes validate and screenshot opens pin an immutable snapshot" {
+ const a = std.testing.allocator;
+ var control: Control = .{ .allocator = a, .path = undefined, .listener = -1 };
+ var host: Host = undefined; // These backend operations do not access the host.
+ var conn: Connection = .{};
+ var reply: fs.Reply = .{ .tag = 1 };
+ var buf: [256]u8 = undefined;
+ _ = try control.respond(&host, &conn, .{ .tag = 1, .op = .setattr, .node = 2, .truncate = true }, &reply, &buf);
+ try std.testing.expectError(error.ReadOnly, control.respond(&host, &conn, .{ .tag = 1, .op = .write, .node = 3, .data = "screenshot" }, &reply, &buf));
+ try std.testing.expectError(error.InvalidCommand, control.respond(&host, &conn, .{ .tag = 1, .op = .write, .node = 2, .data = "screenshot\x00" }, &reply, &buf));
+ _ = try control.respond(&host, &conn, .{ .tag = 1, .op = .write, .node = 2, .data = "screenshot\n" }, &reply, &buf);
+ try std.testing.expect(control.capture_pending);
+ try std.testing.expectError(error.CapturePending, control.respond(&host, &conn, .{ .tag = 1, .op = .open, .node = 5 }, &reply, &buf));
+ control.capture_pending = false;
+ control.png = try a.dupe(u8, "first image");
+ _ = try control.respond(&host, &conn, .{ .tag = 1, .op = .open, .node = 5 }, &reply, &buf);
+ const handle = reply.handle;
+ a.free(control.png);
+ control.png = try a.dupe(u8, "second image");
+ defer a.free(control.png);
+ const bytes = try control.respond(&host, &conn, .{ .tag = 1, .op = .read, .node = 5, .handle = handle, .size = 100 }, &reply, &buf);
+ try std.testing.expectEqualStrings("first image", bytes);
+ _ = try control.respond(&host, &conn, .{ .tag = 1, .op = .release, .node = 5, .handle = handle, .opened = true }, &reply, &buf);
+ try std.testing.expect(conn.snapshots[handle - 1] == null);
+}
+
+test "control writes reset profiling counters while retaining labels" {
+ const a = std.testing.allocator;
+ var control: Control = .{ .allocator = a, .path = undefined, .listener = -1 };
+ var host: Host = undefined;
+ host.passes = null;
+ var conn: Connection = .{};
+ var reply: fs.Reply = .{ .tag = 1 };
+ var buf: [512]u8 = undefined;
+ const reset: fs.Req = .{ .tag = 1, .op = .write, .node = 2, .data = "profile-reset\n" };
+ try std.testing.expectError(error.ProfilingDisabled, control.respond(&host, &conn, reset, &reply, &buf));
+ host.passes = @as(@import("gpu"), undefined);
+ const gpu = &host.passes.?;
+ gpu.profile = .init(a);
+ defer gpu.profile.?.deinit();
+ const profile = &gpu.profile.?;
+ try profile.entries.put(profile.arena.allocator(), "scene", .{});
+ profile.entries.values()[0].add(400_000);
+ profile.entries.values()[0].add(600_000);
+ gpu.frame = 420;
+ const read: fs.Req = .{ .tag = 1, .op = .read, .node = 6, .size = buf.len };
+ const before = try control.respond(&host, &conn, read, &reply, &buf);
+ try std.testing.expect(std.mem.indexOf(u8, before, "scene\t2\t0.500000\t0.600000") != null);
+ _ = try control.respond(&host, &conn, .{ .tag = 1, .op = .open, .node = 7 }, &reply, &buf);
+ const trace_handle = reply.handle;
+ _ = try control.respond(&host, &conn, reset, &reply, &buf);
+ const trace = try control.respond(&host, &conn, .{ .tag = 1, .op = .read, .node = 7, .handle = trace_handle, .size = 100 }, &reply, &buf);
+ try std.testing.expectEqualStrings("label,sample,ns\n\"scene\",1,400000\n\"scene\",2,600000\n", trace);
+ _ = try control.respond(&host, &conn, .{ .tag = 1, .op = .release, .node = 7, .handle = trace_handle, .opened = true }, &reply, &buf);
+ try std.testing.expect(conn.snapshots[trace_handle - 1] == null);
+ try std.testing.expectEqual(@as(usize, 1), profile.entries.count());
+ try std.testing.expectEqual(@as(u64, 0), profile.entries.values()[0].total);
+ try std.testing.expectEqual(@as(u64, 420), profile.start_frame);
+ const after = try control.respond(&host, &conn, read, &reply, &buf);
+ try std.testing.expect(std.mem.indexOf(u8, after, "# frames 0") != null);
+ try std.testing.expect(std.mem.indexOf(u8, after, "scene\t0\t0.000000\t0.000000") != null);
+}
+
+test "control writes profiling ring retains latest samples and nearest rank percentiles" {
+ var entry: @import("gpu").Profile.Entry = .{};
+ for (1..4100) |ns| entry.add(ns);
+ try std.testing.expectEqual(@as(u64, 4099), entry.count);
+ try std.testing.expectEqual(@as(usize, 2048), entry.retained());
+ try std.testing.expectEqual(@as(u64, 2052), entry.sample(0));
+ try std.testing.expectEqual(@as(u64, 4099), entry.sample(2047));
+ try std.testing.expectEqual([2]u64{ 3997, 4079 }, entry.percentiles());
+ entry = .{};
+ try std.testing.expectEqual(@as(usize, 0), entry.retained());
+ try std.testing.expectEqual([2]u64{ 0, 0 }, entry.percentiles());
+ entry.add(20);
+ try std.testing.expectEqual([2]u64{ 20, 20 }, entry.percentiles());
+}
+
+test "control writes reject timing trace mutations and opens pin chronological samples" {
+ const a = std.testing.allocator;
+ var control: Control = .{ .allocator = a, .path = undefined, .listener = -1 };
+ var host: Host = undefined;
+ host.timing = .{};
+ for (0..@import("Timing.zig").capacity + 2) |i| host.timing.add(.{ .frame = i + 1, .work = i });
+ var conn: Connection = .{};
+ var reply: fs.Reply = .{ .tag = 1 };
+ var buf: [256]u8 = undefined;
+ _ = try control.respond(&host, &conn, .{ .tag = 1, .op = .lookup, .node = 1, .data = "timing-trace" }, &reply, &buf);
+ try std.testing.expectEqual(@as(u64, 8), reply.attr.node);
+ try std.testing.expectEqual(@as(u16, 0o400), reply.attr.mode);
+ try std.testing.expectError(error.ReadOnly, control.respond(&host, &conn, .{ .tag = 1, .op = .write, .node = 8, .data = "reset" }, &reply, &buf));
+ _ = try control.respond(&host, &conn, .{ .tag = 1, .op = .open, .node = 8 }, &reply, &buf);
+ const first = reply.handle;
+ host.timing = .{};
+ host.timing.add(.{ .frame = 4, .work = 7 });
+ const original = try control.respond(&host, &conn, .{ .tag = 1, .op = .read, .node = 8, .handle = first, .size = 100 }, &reply, &buf);
+ try std.testing.expect(std.mem.startsWith(u8, original, "index,frame_ns,work_ns,outside_work_ns\n0,3,2,1\n1,4,3,1\n"));
+ _ = try control.respond(&host, &conn, .{ .tag = 1, .op = .open, .node = 8 }, &reply, &buf);
+ const second = reply.handle;
+ const latest = try control.respond(&host, &conn, .{ .tag = 1, .op = .read, .node = 8, .handle = second, .size = 100 }, &reply, &buf);
+ try std.testing.expectEqualStrings("index,frame_ns,work_ns,outside_work_ns\n0,4,7,0\n", latest);
+ for ([_]u32{ first, second }) |handle| {
+ _ = try control.respond(&host, &conn, .{ .tag = 1, .op = .release, .node = 8, .handle = handle, .opened = true }, &reply, &buf);
+ try std.testing.expect(conn.snapshots[handle - 1] == null);
+ }
+}
+
+test "control writes reject presentation trace mutations and opens own independent snapshots" {
+ const a = std.testing.allocator;
+ var control: Control = .{ .allocator = a, .path = undefined, .listener = -1 };
+ var host: Host = undefined;
+ host.presentation = null;
+ var conn: Connection = .{};
+ var reply: fs.Reply = .{ .tag = 1 };
+ var buf: [512]u8 = undefined;
+ _ = try control.respond(&host, &conn, .{ .tag = 1, .op = .lookup, .node = 1, .data = "presentation-trace" }, &reply, &buf);
+ try std.testing.expectEqual(@as(u64, 9), reply.attr.node);
+ try std.testing.expectEqual(@as(u16, 0o400), reply.attr.mode);
+ try std.testing.expectError(error.ReadOnly, control.respond(&host, &conn, .{ .tag = 1, .op = .write, .node = 9, .data = "reset" }, &reply, &buf));
+ _ = try control.respond(&host, &conn, .{ .tag = 1, .op = .open, .node = 9 }, &reply, &buf);
+ const first = reply.handle;
+ _ = try control.respond(&host, &conn, .{ .tag = 1, .op = .open, .node = 9 }, &reply, &buf);
+ const second = reply.handle;
+ try std.testing.expect(conn.snapshots[first - 1].?.ptr != conn.snapshots[second - 1].?.ptr);
+ const original = try control.respond(&host, &conn, .{ .tag = 1, .op = .read, .node = 9, .handle = first, .size = 4096 }, &reply, &buf);
+ try std.testing.expect(std.mem.startsWith(u8, original, "# status "));
+ try std.testing.expect(std.mem.indexOf(u8, original, "disabled_or_allocation_failed") != null);
+ try std.testing.expect(std.mem.endsWith(u8, original, "frame_id,sample_ms,commit_ns,result,presented_ns,refresh_ns,sequence,flags\n"));
+ try std.testing.expect(std.mem.indexOfScalar(u8, original, 0) == null);
+ const expected = try a.dupe(u8, original);
+ defer a.free(expected);
+ _ = try control.respond(&host, &conn, .{ .tag = 1, .op = .release, .node = 9, .handle = first, .opened = true }, &reply, &buf);
+ const retained = try control.respond(&host, &conn, .{ .tag = 1, .op = .read, .node = 9, .handle = second, .size = 4096 }, &reply, &buf);
+ try std.testing.expectEqualStrings(expected, retained);
+ _ = try control.respond(&host, &conn, .{ .tag = 1, .op = .release, .node = 9, .handle = second, .opened = true }, &reply, &buf);
+ try std.testing.expect(conn.snapshots[first - 1] == null and conn.snapshots[second - 1] == null);
+}
+
+test "control writes take input verbs live, and the README and commands read the tables" {
+ const a = std.testing.allocator;
+ var control: Control = .{ .allocator = a, .path = undefined, .listener = -1 };
+ var host: Host = undefined;
+ host.gpa = a;
+ host.console = .{};
+ host.input = .{};
+ host.pending = .empty;
+ defer host.pending.deinit(a);
+ const S = struct { scene: enum(u8) { room, street } = .room, talk: struct { text: [3]u8 = @splat(0) } = .{} };
+ var arena: std.heap.ArenaAllocator = .init(a);
+ defer arena.deinit();
+ host.state.layout = try @import("memory.zig").Layout.copy(arena.allocator(), @import("abi").layout.of(S, .state));
+ host.completions = &.{ "scene room", "scene street" };
+ var conn: Connection = .{};
+ var reply: fs.Reply = .{ .tag = 1 };
+ var buf: [512]u8 = undefined;
+ _ = try control.respond(&host, &conn, .{ .tag = 1, .op = .write, .node = 2, .data = "click 10 20\nhold left_shift\n" }, &reply, &buf);
+ try std.testing.expectEqual(@as(usize, 4), host.pending.items.len);
+ try std.testing.expectEqual(abi.Event.Kind.mouse_up, host.pending.items[2].kind);
+ try std.testing.expectEqual(@as(f32, 20), host.pending.items[2].y);
+ try std.testing.expectEqual(abi.Event.Kind.key_down, host.pending.items[3].kind);
+ try std.testing.expectError(error.ExpectedPoint, control.respond(&host, &conn, .{ .tag = 1, .op = .write, .node = 2, .data = "click 10" }, &reply, &buf));
+ for ([_]File{ .README, .commands }) |f| {
+ _ = try control.respond(&host, &conn, .{ .tag = 1, .op = .open, .node = @backingInt(f) }, &reply, &buf);
+ const handle = reply.handle;
+ const text = conn.snapshots[handle - 1].?;
+ if (f == .README) {
+ try std.testing.expect(std.mem.startsWith(u8, text, "ctl write a verb a line"));
+ try std.testing.expect(std.mem.indexOf(u8, text, "\n screenshot captures the next frame") != null);
+ try std.testing.expect(std.mem.indexOf(u8, text, "\n click X Y move there") != null);
+ try std.testing.expect(std.mem.indexOf(u8, text, "\n set FIELD VALUE... a field to a value") != null);
+ try std.testing.expect(std.mem.indexOf(u8, text, "\nstate/ the sketch's State") != null);
+ try std.testing.expect(std.mem.indexOf(u8, text, "\nsketch/ the sketch's own files") != null);
+ try std.testing.expect(std.mem.endsWith(u8, text, "\nstate/scene .room .street\nstate/talk/text 3 u8, blank-separated\n"));
+ } else {
+ try std.testing.expect(std.mem.startsWith(u8, text, "screenshot captures"));
+ try std.testing.expect(std.mem.endsWith(u8, text, "\nscene room\nscene street\n"));
+ }
+ _ = try control.respond(&host, &conn, .{ .tag = 1, .op = .release, .node = @backingInt(f), .handle = handle, .opened = true }, &reply, &buf);
+ }
+}
+
+test "control writes leave the sketch's directory and nodes alone" {
+ var control: Control = .{ .allocator = std.testing.allocator, .path = undefined, .listener = -1 };
+ var host: Host = undefined;
+ var conn: Connection = .{};
+ var reply: fs.Reply = .{ .tag = 1 };
+ var buf: [256]u8 = undefined;
+ _ = try control.respond(&host, &conn, .{ .tag = 1, .op = .lookup, .node = 1, .data = "sketch" }, &reply, &buf);
+ try std.testing.expect(reply.attr.dir and reply.attr.node == 1 << 63);
+ try std.testing.expectEqual(@as(usize, 0), (try control.respond(&host, &conn, .{ .tag = 1, .op = .readdir, .node = 1 << 63 }, &reply, &buf)).len);
+ try std.testing.expectError(error.UnknownFile, control.respond(&host, &conn, .{ .tag = 1, .op = .lookup, .node = 1 << 63, .data = "buffer" }, &reply, &buf));
+ for ([_]u64{ (1 << 63) + 1, (1 << 63) | (1 << 62), std.math.maxInt(u64) }) |node| try std.testing.expectError(error.UnknownFile, control.respond(&host, &conn, .{ .tag = 1, .op = .getattr, .node = node }, &reply, &buf));
+}