//! The process runner of docs/next-tests.md: a real `pardes`, detached or //! in a pty (test/e2e_harness.zig's Harness), and what a 9P client sees of //! it over its socket, with T1's Session method names (test/session.zig), so //! a test reads alike at either tier. The snap scripts, the process tests //! (test/process/) and the window's run on it. const std = @import("std"); const libc = std.c; const eh = @import("e2e_harness.zig"); const Client = @import("9p_io").Client; const c9 = @import("cloud9"); extern "c" fn setenv(name: [*:0]const u8, value: [*:0]const u8, overwrite: c_int) c_int; extern "c" fn unsetenv(name: [*:0]const u8) c_int; extern "c" fn execvp(file: [*:0]const u8, argv: [*:null]const ?[*:0]const u8) c_int; extern "c" fn _exit(status: c_int) noreturn; extern "c" fn mkdtemp(template: [*:0]u8) ?[*:0]u8; extern "c" fn system(cmd: [*:0]const u8) c_int; extern "c" fn realpath(path: [*:0]const u8, resolved: [*]u8) ?[*:0]u8; /// One 9P2000 connection to a socket, blocking, as a client program holds /// one: fids walked, opened, read, written, clunked and removed by path, /// for the tests that need more than a file read or written whole (an open /// held while others write, a directory's entries, a stat, a remove). /// The last refusal's words are in `said`. pub const Conn = struct { fd: c_int, cl: c9.Client, in: [msize]u8 = undefined, out: [msize]u8 = undefined, next_fid: u32 = 1, said_buf: [256]u8 = undefined, said: []const u8 = "", const msize = 64 * 1024; pub const Fid = u32; /// Connected to the unix socket at `path`, versioned and attached as /// fid 0. Heap-held: its buffers are big and the client points into them. pub fn dial(gpa: std.mem.Allocator, path: []const u8) !*Conn { const c = try gpa.create(Conn); errdefer gpa.destroy(c); c.* = .{ .fd = -1, .cl = undefined }; c.cl = c9.Client.init(.{ .in = &c.in, .out = &c.out }); c.fd = libc.socket(libc.AF.UNIX, libc.SOCK.STREAM | libc.SOCK.CLOEXEC, 0); if (c.fd < 0) return error.NoSocket; errdefer _ = libc.close(c.fd); var addr: libc.sockaddr.un = .{ .path = undefined }; if (path.len >= addr.path.len) return error.NameTooLong; @memset(&addr.path, 0); @memcpy(addr.path[0..path.len], path); if (libc.connect(c.fd, @ptrCast(&addr), @sizeOf(libc.sockaddr.un)) != 0) return error.ConnectFailed; _ = try c.call(.{ .version = .{ .msize = msize } }); _ = try c.call(.{ .attach = .{ .fid = 0, .uname = "test" } }); return c; } pub fn deinit(c: *Conn, gpa: std.mem.Allocator) void { _ = libc.close(c.fd); gpa.destroy(c); } fn call(c: *Conn, req: c9.Client.Request) !c9.Client.Result { _ = c.cl.submit(req) catch return error.Protocol; while (c.cl.output().len > 0) { const out = c.cl.output(); const n = libc.write(c.fd, out.ptr, out.len); if (n <= 0) return error.Hangup; c.cl.wrote(@intCast(n)); } while (true) { if (c.cl.take()) |done| { if (done.result == .fail) { const words = done.result.fail; const n = @min(words.len, c.said_buf.len); @memcpy(c.said_buf[0..n], words[0..n]); c.said = c.said_buf[0..n]; return error.Refused; } return done.result; } var buf: [msize]u8 = undefined; const n = libc.read(c.fd, &buf, buf.len); if (n <= 0) return error.Hangup; var at: usize = 0; while (at < n) at += c.cl.push(buf[at..@intCast(n)]); } } /// A new fid walked to `path` from the root. pub fn walk(c: *Conn, path: []const u8) !Fid { var names: [c9.max_welem][]const u8 = undefined; var n: usize = 0; var it = std.mem.tokenizeScalar(u8, path, '/'); while (it.next()) |name| : (n += 1) { if (n == names.len) return error.PathTooDeep; names[n] = name; } const fid = c.next_fid; c.next_fid += 1; const r = try c.call(.{ .walk = .{ .fid = 0, .newfid = fid, .names = names[0..n] } }); if (r.walk.nwqid != n) return error.NotFound; return fid; } /// `path` walked and opened (0 read, 1 write, 2 both; 16 truncates). pub fn hold(c: *Conn, path: []const u8, mode: u8) !Fid { const fid = try c.walk(path); errdefer c.clunk(fid); _ = try c.call(.{ .open = .{ .fid = fid, .mode = mode } }); return fid; } /// One read on an open fid; valid until the next call. pub fn readFid(c: *Conn, fid: Fid, offset: u64, count: u32) ![]const u8 { return (try c.call(.{ .read = .{ .fid = fid, .offset = offset, .count = @min(count, c.cl.maxRead()) } })).read; } /// One write on an open fid: the count the server took. pub fn writeFid(c: *Conn, fid: Fid, offset: u64, data: []const u8) !u32 { return (try c.call(.{ .write = .{ .fid = fid, .offset = offset, .data = data } })).write; } /// A fid let go; a refusal there (an Edit block left open) is in `said`. pub fn clunk(c: *Conn, fid: Fid) void { _ = c.call(.{ .clunk = .{ .fid = fid } }) catch {}; } /// The whole file at `path`, read on an open of its own. pub fn read(c: *Conn, gpa: std.mem.Allocator, path: []const u8) ![]u8 { const fid = try c.hold(path, 0); defer c.clunk(fid); var out: std.ArrayList(u8) = .empty; errdefer out.deinit(gpa); while (true) { const got = try c.readFid(fid, out.items.len, msize); if (got.len == 0) break; try out.appendSlice(gpa, got); } return out.toOwnedSlice(gpa); } /// `data` written to `path` in one write, the open clunked after; a /// refusal by the write or by the clunk is `error.Refused`. pub fn write(c: *Conn, path: []const u8, data: []const u8) !void { const fid = try c.hold(path, 1); _ = c.writeFid(fid, 0, data) catch |err| { c.clunk(fid); return err; }; _ = c.call(.{ .clunk = .{ .fid = fid } }) catch |err| return err; } pub fn remove(c: *Conn, path: []const u8) !void { const fid = try c.walk(path); _ = try c.call(.{ .remove = .{ .fid = fid } }); } /// What a stat of `path` answers; its strings valid until the next call. pub fn stat(c: *Conn, path: []const u8) !c9.Stat { const fid = try c.walk(path); defer c.clunk(fid); return (try c.call(.{ .stat = .{ .fid = fid } })).stat; } /// The names of a directory's entries. pub fn list(c: *Conn, gpa: std.mem.Allocator, path: []const u8) ![]const []const u8 { const fid = try c.hold(path, 0); defer c.clunk(fid); var names: std.ArrayList([]const u8) = .empty; var off: u64 = 0; while (true) { const got = try c.readFid(fid, off, msize); if (got.len == 0) break; off += got.len; var at: usize = 0; while (at + 2 <= got.len) { const len = @as(usize, std.mem.readInt(u16, got[at..][0..2], .little)) + 2; const st = try c9.Stat.decode(got[at..][0..len]); try names.append(gpa, try gpa.dupe(u8, st.name)); at += len; } } return names.toOwnedSlice(gpa); } // fsa: /// `data` written to `path` opened OTRUNC (a shell's `>`), the open /// clunked after; a refusal by a write or the clunk is `error.Refused`. pub fn replace(c: *Conn, path: []const u8, data: []const u8) !void { try c.writeCut(path, 1 | 16, data, msize - 24); } /// `data` written to `path` (opened `mode`) in writes of at most `cut` /// bytes, as a client with a smaller msize cuts them. pub fn writeCut(c: *Conn, path: []const u8, mode: u8, data: []const u8, cut: usize) !void { const fid = try c.hold(path, mode); var at: usize = 0; while (at < data.len) { const n = c.writeFid(fid, at, data[at..@min(data.len, at + cut)]) catch |err| { c.clunk(fid); return err; }; if (n == 0) { c.clunk(fid); return error.ShortWrite; } at += n; } _ = try c.call(.{ .clunk = .{ .fid = fid } }); } /// A file or directory (`perm` with c9.dmdir) made in `dir`. pub fn create(c: *Conn, dir: []const u8, name: []const u8, perm: u32) !void { const fid = try c.walk(dir); defer c.clunk(fid); _ = try c.call(.{ .create = .{ .fid = fid, .name = name, .perm = perm, .mode = 0 } }); } /// A new pane, made by an open of /pane/new; its serial. pub fn newPane(c: *Conn) !u32 { const fid = try c.hold("/pane/new", 0); defer c.clunk(fid); return std.fmt.parseInt(u32, std.mem.trim(u8, try c.readFid(fid, 0, 64), "\n"), 10); } /// The newest pane's serial: /index is ordered by serial. pub fn newest(c: *Conn, gpa: std.mem.Allocator) !u32 { const index = try c.read(gpa, "/index"); defer gpa.free(index); var rows = std.mem.splitBackwardsScalar(u8, std.mem.trimEnd(u8, index, "\n"), '\n'); const last = rows.first(); return std.fmt.parseInt(u32, last[0 .. std.mem.indexOfScalar(u8, last, ' ') orelse last.len], 10); } /// A right click on `path` from a fresh scratch, which goes after: the /// one pane /look names, never the scratch. pub fn look(c: *Conn, gpa: std.mem.Allocator, path: []const u8) !u32 { const scratch = try c.newPane(); var buf: [4200]u8 = undefined; try c.write(try std.fmt.bufPrint(&buf, "/pane/{d}/look", .{scratch}), try std.fmt.bufPrint(buf[64..], "{s}\n", .{path})); const got = try c.read(gpa, "/look"); defer gpa.free(got); var rows = std.mem.tokenizeAny(u8, got, " \n"); const opened = try std.fmt.parseInt(u32, rows.next() orelse return error.NothingOpened, 10); if (rows.next() != null or opened == scratch) return error.NotOnePane; try c.remove(try std.fmt.bufPrint(&buf, "/pane/{d}", .{scratch})); return opened; } /// The words a server refuses a new connection's Tversion with (its /// slots all taken), copied into `buf`; error.NotRefused when it took it. pub fn dialRefusal(gpa: std.mem.Allocator, path: []const u8, buf: []u8) ![]const u8 { const c = try gpa.create(Conn); defer gpa.destroy(c); c.* = .{ .fd = libc.socket(libc.AF.UNIX, libc.SOCK.STREAM | libc.SOCK.CLOEXEC, 0), .cl = undefined }; c.cl = c9.Client.init(.{ .in = &c.in, .out = &c.out }); if (c.fd < 0) return error.NoSocket; defer _ = libc.close(c.fd); var addr: libc.sockaddr.un = .{ .path = @splat(0) }; if (path.len >= addr.path.len) return error.NameTooLong; @memcpy(addr.path[0..path.len], path); if (libc.connect(c.fd, @ptrCast(&addr), @sizeOf(libc.sockaddr.un)) != 0) return error.ConnectFailed; _ = c.call(.{ .version = .{ .msize = msize } }) catch |err| { if (err != error.Refused) return err; const n = @min(buf.len, c.said.len); @memcpy(buf[0..n], c.said[0..n]); return buf[0..n]; }; return error.NotRefused; } /// A request sent without waiting for its answer (several in flight on /// one connection); its tag. pub fn send(c: *Conn, req: c9.Client.Request) !u16 { const tag = c.cl.submit(req) catch return error.Protocol; while (c.cl.output().len > 0) { const out = c.cl.output(); const n = libc.write(c.fd, out.ptr, out.len); if (n <= 0) return error.Hangup; c.cl.wrote(@intCast(n)); } return tag; } /// The next answer to come, to whichever request `send` sent; a read's /// bytes valid until the next call. pub fn answer(c: *Conn) !c9.Client.Done { while (true) { if (c.cl.take()) |done| return done; var buf: [msize]u8 = undefined; const n = libc.read(c.fd, &buf, buf.len); if (n <= 0) return error.Hangup; var at: usize = 0; while (at < n) at += c.cl.push(buf[at..@intCast(n)]); } } }; /// A running pardes's file tree, dialled by its pid or socket path. pub const Files = struct { arena: std.heap.ArenaAllocator, dial_buf: [4096]u8 = undefined, dial_len: usize = 0, pub fn init(gpa: std.mem.Allocator, to: []const u8) Files { var f: Files = .{ .arena = .init(gpa) }; @memcpy(f.dial_buf[0..to.len], to); f.dial_len = to.len; return f; } pub fn deinit(f: *Files) void { f.arena.deinit(); } fn dial(f: *const Files) []const u8 { return f.dial_buf[0..f.dial_len]; } /// The whole file at `path`, kept until deinit. pub fn read(f: *Files, path: []const u8) ![]const u8 { const gpa = f.arena.child_allocator; const bytes = try Client.read(gpa, f.dial(), path, path); defer gpa.free(bytes); return f.arena.allocator().dupe(u8, bytes); } pub fn write(f: *Files, path: []const u8, data: []const u8) !void { try Client.write(f.arena.child_allocator, f.dial(), path, data); } pub fn expect(f: *Files, path: []const u8, want: []const u8) !void { try std.testing.expectEqualStrings(want, try f.read(path)); } /// Keys typed at the pane with the keyboard (`/kbdin`'s runes). pub fn keys(f: *Files, runes: []const u8) !void { try f.write("/kbdin", runes); } /// A click (1 left, 2 middle, 4 right) `into` cells into the first place /// `text` is drawn. pub fn click(f: *Files, text: []const u8, into: usize, buttons: u8) !void { const col, const row = try f.where(text); var line: [64]u8 = undefined; const x = col + into; try f.write("/mousein", try std.fmt.bufPrint(&line, "m {d} {d} {d}\nm {d} {d} 0\n", .{ x, row, buttons, x, row })); } /// The screen a frame draws, a line a row. // shortcut: Session.screen's twin (test/session.zig, another module); // share them when a third copy would be wanted. pub fn screen(f: *Files) ![]const u8 { const a = f.arena.allocator(); const json = try std.json.parseFromSliceLeaky(std.json.Value, a, try f.read("/screen"), .{}); const cols: usize = @intCast(json.object.get("cols").?.integer); var out: std.ArrayList(u8) = .empty; for (json.object.get("cells").?.array.items, 0..) |cell, i| { if (i > 0 and i % cols == 0) try out.append(a, '\n'); const g = cell.array.items[0].string; try out.appendSlice(a, if (g.len == 0) " " else g); } return out.items; } /// Where `text` is first drawn, its column and row. pub fn where(f: *Files, text: []const u8) !struct { usize, usize } { var rows = std.mem.splitScalar(u8, try f.screen(), '\n'); var row: usize = 0; while (rows.next()) |line| : (row += 1) { if (std.mem.indexOf(u8, line, text)) |i| return .{ try std.unicode.utf8CountCodepoints(line[0..i]), row }; } std.debug.print("not on the screen: {s}\n", .{text}); return error.NotOnScreen; } /// The serial of the pane with the keyboard. pub fn focused(f: *Files) !u32 { return std.fmt.parseInt(u32, std.mem.trim(u8, try f.read("/focus"), "\n"), 10); } /// A new pane, made by opening /pane/new; its serial. pub fn newPane(f: *Files) !u32 { return std.fmt.parseInt(u32, std.mem.trim(u8, try f.read("/pane/new"), "\n"), 10); } /// A path built from `args`, kept until deinit. pub fn at(f: *Files, comptime fmt: []const u8, args: anytype) []const u8 { return std.fmt.allocPrint(f.arena.allocator(), fmt, args) catch @panic("out of memory"); } }; /// The files of the app a pty harness started. pub fn of(gpa: std.mem.Allocator, h: *const eh.Harness) Files { var digits: [24]u8 = undefined; return .init(gpa, std.fmt.bufPrint(&digits, "{d}", .{h.pid}) catch unreachable); } /// `pardes --detach=` in a throwaway root that is its HOME, runtime /// and config directory, as test/fs.py's session started one: no session /// of the user's is reached. No daemon (PARDES_DAEMON=off, as the pty /// harness starts one): the process is the session, and nothing outlives it. pub const Detached = struct { pid: libc.pid_t, root_buf: [4096]u8 = undefined, root_len: usize = 0, socket_buf: [4096]u8 = undefined, socket_len: usize = 0, /// Whether deinit removes the root (one passed in is its owner's). owns_root: bool = true, /// The exit status, once it has exited (`exited`). status: ?c_int = null, files: Files, pub const Options = struct { /// Arguments before the file (`--mount=...`, `--9p=`). args: []const [:0]const u8 = &.{}, /// The file it opens; null: `/.txt`, holding "initial\n". file: ?[]const u8 = null, /// More environment, set after the root's. env: []const [2][:0]const u8 = &.{}, /// Another session's root to run in, which both then share (its /// store, its runtime directory); it is not removed. root: ?[]const u8 = null, /// The name its socket is linked as, when `--9p=` names one. socket: ?[]const u8 = null, }; pub fn start(gpa: std.mem.Allocator, exe: [:0]const u8, name: []const u8, opts: Options) !Detached { var d: Detached = .{ .pid = 0, .files = undefined }; if (opts.root) |shared| { @memcpy(d.root_buf[0..shared.len], shared); d.root_len = shared.len; d.owns_root = false; } else { const template = "/tmp/pardes-process-XXXXXX"; @memcpy(d.root_buf[0..template.len], template); d.root_buf[template.len] = 0; _ = mkdtemp(d.root_buf[0..template.len :0]) orelse return error.NoTempDir; d.root_len = template.len; } errdefer if (d.owns_root) d.removeRoot(); const dir = d.root(); var buf: [4096]u8 = undefined; const fixture = if (opts.file) |f| try std.fmt.bufPrintSentinel(&buf, "{s}", .{f}, 0) else blk: { const path = try std.fmt.bufPrintSentinel(&buf, "{s}/{s}.txt", .{ dir, name }, 0); try eh.writeFile(path, "initial\n"); break :blk path; }; // The session's socket, as its 9P service links it (src/9p_io.zig). const sock_path = try std.fmt.bufPrint(&d.socket_buf, "{s}/9p/pardes/{s}", .{ dir, opts.socket orelse name }); d.socket_len = sock_path.len; var arg_buf: [256]u8 = undefined; const detach = try std.fmt.bufPrintSentinel(&arg_buf, "--detach={s}", .{name}, 0); var env_buf: [3][4096]u8 = undefined; const root_z = try std.fmt.bufPrintSentinel(&env_buf[0], "{s}", .{dir}, 0); const config = try std.fmt.bufPrintSentinel(&env_buf[1], "{s}/config", .{dir}, 0); const dump = try std.fmt.bufPrintSentinel(&env_buf[2], "{s}/{s}.dump.zon", .{ dir, name }, 0); var err_buf: [4096]u8 = undefined; const err_log = try std.fmt.bufPrintSentinel(&err_buf, "{s}/{s}.stderr", .{ dir, name }, 0); // The build hands the binary over by a relative path, and the child // runs in the root. var exe_buf: [4096]u8 = undefined; const exe_abs = realpath(exe, &exe_buf) orelse return error.NoBinary; var argv: [24:null]?[*:0]const u8 = @splat(null); if (opts.args.len + 3 > argv.len) return error.TooManyArgs; argv[0] = exe_abs; argv[1] = detach; for (opts.args, 0..) |a, k| argv[2 + k] = a; argv[2 + opts.args.len] = fixture; const pid = libc.fork(); if (pid < 0) return error.ForkFailed; if (pid == 0) { // What a session of the caller's left in the environment, and a // pager of theirs, are not the session under test's. for ([_][*:0]const u8{ "PARDES_PID", "PARDES_9P", "PARDES_PANE", "PARDES_MOUNT", "PAGER" }) |v| _ = unsetenv(v); for ([_][2][*:0]const u8{ .{ "HOME", root_z }, .{ "XDG_RUNTIME_DIR", root_z }, .{ "XDG_CONFIG_HOME", config }, .{ "PARDES_NOTIME", "1" }, .{ "PARDES_DUMP", dump }, .{ "PARDES_LSP_RS", "" }, .{ "PARDES_LSP_C", "" }, .{ "PARDES_LSP_GO", "" }, .{ "PARDES_LSP_TS", "" }, .{ "PARDES_LSP_PY", "" }, .{ "PARDES_DAEMON", "off" }, }) |kv| if (setenv(kv[0], kv[1], 1) != 0) _exit(126); for (opts.env) |kv| if (setenv(kv[0], kv[1], 1) != 0) _exit(126); if (libc.chdir(root_z) != 0) _exit(126); const fd = libc.open(err_log, .{ .ACCMODE = .WRONLY, .CREAT = true, .TRUNC = true }, @as(libc.mode_t, 0o644)); if (fd >= 0) _ = libc.dup2(fd, 2); _ = execvp(exe_abs, &argv); _exit(127); } d.pid = pid; errdefer d.stop(); const deadline = eh.nowMs() + 10_000; var sock_z: [4096]u8 = undefined; const socket_z = try std.fmt.bufPrintSentinel(&sock_z, "{s}", .{sock_path}, 0); while (libc.access(socket_z, 0) != 0) { if (d.exited(0)) |status| { var said: [4096]u8 = undefined; const fd = libc.open(err_log, .{}, @as(libc.mode_t, 0)); const n = if (fd >= 0) libc.read(fd, &said, said.len) else 0; if (fd >= 0) _ = libc.close(fd); std.debug.print("the session exited, status {d}: {s}\n", .{ status, said[0..@intCast(@max(n, 0))] }); return error.SessionExited; } if (eh.nowMs() > deadline) return error.NoSocket; sleepMs(5); } d.files = .init(gpa, sock_path); return d; } pub fn root(d: *const Detached) []const u8 { return d.root_buf[0..d.root_len]; } /// The socket's path, which a held connection dials (`Conn.dial`). pub fn socket(d: *const Detached) []const u8 { return d.socket_buf[0..d.socket_len]; } /// `data` written to `rel` under the root. pub fn put(d: *const Detached, rel: []const u8, data: []const u8) !void { var buf: [4096]u8 = undefined; try eh.writeFile(try std.fmt.bufPrintSentinel(&buf, "{s}/{s}", .{ d.root(), rel }, 0), data); } /// The file `rel` under the root, whole. pub fn get(d: *const Detached, gpa: std.mem.Allocator, rel: []const u8) ![]u8 { var buf: [4096]u8 = undefined; const path = try std.fmt.bufPrintSentinel(&buf, "{s}/{s}", .{ d.root(), rel }, 0); const fd = libc.open(path, .{}, @as(libc.mode_t, 0)); if (fd < 0) return error.FileNotFound; defer _ = libc.close(fd); var out: std.ArrayList(u8) = .empty; errdefer out.deinit(gpa); var chunk: [16 * 1024]u8 = undefined; while (true) { const n = libc.read(fd, &chunk, chunk.len); if (n < 0) return error.ReadFailed; if (n == 0) break; try out.appendSlice(gpa, chunk[0..@intCast(n)]); } return out.toOwnedSlice(gpa); } pub fn signal(d: *const Detached, sig: c_int) void { if (d.pid > 0) _ = libc.kill(d.pid, @intCast(sig)); } /// Its exit status once it has exited, waiting up to `ms`; null while /// it runs. A status is the wait(2) word (WEXITSTATUS is `>> 8`). pub fn exited(d: *Detached, ms: i64) ?c_int { if (d.status) |s| return s; if (d.pid <= 0) return null; const deadline = eh.nowMs() + ms; while (true) { var status: c_int = 0; if (libc.waitpid(d.pid, &status, std.c.W.NOHANG) == d.pid) { d.status = status; d.pid = 0; return status; } if (eh.nowMs() >= deadline) return null; sleepMs(10); } } /// Ended (SIGTERM, then SIGKILL after 5 s), its root removed if it is /// its own. pub fn deinit(d: *Detached) void { d.files.deinit(); d.stop(); if (d.owns_root) d.removeRoot(); } fn removeRoot(d: *Detached) void { var cmd: [4200]u8 = undefined; if (std.fmt.bufPrintSentinel(&cmd, "rm -rf -- '{s}'", .{d.root()}, 0)) |c| { _ = system(c); } else |_| {} } fn stop(d: *Detached) void { if (d.pid <= 0) return; _ = libc.kill(d.pid, libc.SIG.TERM); if (d.exited(5_000) == null) { _ = libc.kill(d.pid, libc.SIG.KILL); _ = d.exited(5_000); } d.pid = 0; } }; fn sleepMs(ms: u32) void { var ts: libc.timespec = .{ .sec = 0, .nsec = @as(isize, ms) * std.time.ns_per_ms }; _ = libc.nanosleep(&ts, null); } // fsa: /// A wait of `ms` milliseconds, for what a test gives a session time to do. pub fn sleep(ms: u32) void { var ts: libc.timespec = .{ .sec = @intCast(ms / 1000), .nsec = @as(isize, ms % 1000) * std.time.ns_per_ms }; _ = libc.nanosleep(&ts, null); }