summaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/9p_io.zig33
-rw-r--r--src/builtins.zig13
-rw-r--r--src/config.zig1
-rw-r--r--src/daemon.zig145
-rw-r--r--src/dump.zig71
-rw-r--r--src/gui/gui.zig120
-rw-r--r--src/host_io.zig3
-rw-r--r--src/main.zig42
-rw-r--r--src/pardes.zig8
-rw-r--r--src/tty/tty.zig220
-rw-r--r--src/upgrade.zig389
11 files changed, 981 insertions, 64 deletions
diff --git a/src/9p_io.zig b/src/9p_io.zig
index 9bcb2827..ef6385fc 100644
--- a/src/9p_io.zig
+++ b/src/9p_io.zig
@@ -902,6 +902,25 @@ pub const Listener = struct {
l.posted_len = 0;
}
+ /// What the connections have still to send let go, 200 ms at most,
+ /// before they are cut (a quit, an Upgrade's exec: its write's answer).
+ pub fn flushOut(l: *Listener) void {
+ if (comptime !supported) return;
+ const deadline = nowMs() +| 200;
+ while (nowMs() < deadline) {
+ const pending = for (&l.runner.conns) |*conn| {
+ if (!conn.live()) continue;
+ conn.lock();
+ const n = conn.engine.output().len;
+ conn.unlock();
+ if (n != 0) break true;
+ } else false;
+ if (!pending) break;
+ Client.nap(1);
+ }
+ Client.nap(1); // the last bytes leave the stream's own buffer
+ }
+
pub fn deinit(l: *Listener, gpa: std.mem.Allocator) void {
l.stopping.store(true, .release);
l.unpostFromRegistry();
@@ -922,19 +941,7 @@ pub const Listener = struct {
l.edit_watchers.cancel(l.io);
// An answer given as the editor quit (a Kill written to /ctl)
// may still be on its way out: let it go before the cut.
- const deadline = nowMs() +| 200;
- while (nowMs() < deadline) {
- const pending = for (&l.runner.conns) |*conn| {
- if (!conn.live()) continue;
- conn.lock();
- const n = conn.engine.output().len;
- conn.unlock();
- if (n != 0) break true;
- } else false;
- if (!pending) break;
- Client.nap(1);
- }
- Client.nap(1); // the last bytes leave the stream's own buffer
+ l.flushOut();
l.runner.stop();
pardes.turn.wake();
}
diff --git a/src/builtins.zig b/src/builtins.zig
index 0ad59fd4..1dc428da 100644
--- a/src/builtins.zig
+++ b/src/builtins.zig
@@ -762,6 +762,19 @@ pub const Adopt = struct {
}
};
+/// Move this session onto the pardes installed since it started, in place:
+/// its text, undo, views, terminals with their running shells, and its
+/// terminals and windows come along. The pardes daemon moves too.
+pub const Upgrade = struct {
+ pub const scope: Scope = .session;
+ pub const enabled = pardes.can_attach;
+ pub fn run(c: Ctx) void {
+ if (comptime !enabled) unreachable;
+ const upgrade = c.p.host.vtable.upgrade orelse return c.p.reportFailure(c.id, "Upgrade: this pardes cannot move to another build in place");
+ upgrade(c.p.host.ctx, @intCast(c.id));
+ }
+};
+
/// Mount another pardes's 9P tree under /n/<name>, given its dial address.
pub const Mount = struct {
pub const scope: Scope = .session;
diff --git a/src/config.zig b/src/config.zig
index 13404461..742e9010 100644
--- a/src/config.zig
+++ b/src/config.zig
@@ -219,6 +219,7 @@ pub const leader_path = paths: {
if (pardes.can_attach) {
table.set(.Detach, "sD");
table.set(.Adopt, null);
+ table.set(.Upgrade, "sU");
}
if (builtins.Peek.enabled) {
table.set(.Peek, null);
diff --git a/src/daemon.zig b/src/daemon.zig
index 702d11b1..43f15c6c 100644
--- a/src/daemon.zig
+++ b/src/daemon.zig
@@ -27,6 +27,7 @@ const libc = std.c;
const posix = std.posix;
const ninep_io = @import("9p_io.zig");
const wire = @import("detached/wire.zig");
+const upgrade = @import("upgrade.zig");
const log = std.log.scoped(.replica);
pub const supported = builtin.os.tag == .linux or builtin.os.tag == .freebsd;
@@ -355,6 +356,33 @@ pub fn adopt() void {
tell("adopt", &.{});
}
+/// This session is about to exec another build (upgrade.zig): the daemon
+/// is asked to move too, and every replica told why it is let go.
+/// ponytail: a pong its thread writes at the same moment may split the
+/// words; the client reconnects either way.
+pub fn upgraded() void {
+ tell("upgrade", &.{});
+ var out: [600]u8 = undefined;
+ const said = wire.encodeServer(&out, .{ .refused = "the session is upgrading to another build of pardes: connect again with that build" }) catch return;
+ for (&replica_fds) |*slot| {
+ const fd = slot.load(.acquire);
+ if (fd < 0) continue;
+ _ = writeAll(fd, said);
+ _ = libc.shutdown(fd, 2);
+ }
+}
+
+/// An upgraded session's link and stub as its old process left them: its
+/// build's hello said again on the link (the daemon keeps its masters as
+/// they were), and the stub's death a HUP again.
+pub fn resumeLink(fd: c_int, stub_fd: c_int, k: Kind, named: []const u8, detached: bool) void {
+ if (comptime !supported) return;
+ stub = stub_fd;
+ if (stub >= 0) hupOnStubDeath(true);
+ setName(named);
+ if (fd >= 0 and hello(fd, k, libc.getpid(), name(), detached)) link = fd else if (fd >= 0) _ = libc.close(fd);
+}
+
pub const Note = union(enum) {
/// A terminal for a detached tty session (`pardes --attach`), and the
/// stub's pipe; for a window session, both -1: open a window.
@@ -422,6 +450,8 @@ fn writeAll(fd: c_int, bytes: []const u8) bool {
return true;
}
+var replica_fds: [max_replicas]std.atomic.Value(c_int) = @splat(.init(-1));
+
/// A replica the daemon handed over, its hello accepted: welcomed, its pings
/// answered, until it says bye or hangs up. ponytail: phase 5 proper makes it
/// a replica (the log, the dump, terminal state); this stub is what times a
@@ -429,6 +459,11 @@ fn writeAll(fd: c_int, bytes: []const u8) bool {
/// than its buffer ends it.
fn serveReplica(fd: c_int) void {
defer _ = libc.close(fd);
+ // Where an upgrade finds it to say why it ends (`upgraded`).
+ const slot = for (&replica_fds) |*r| {
+ if (r.cmpxchgStrong(-1, fd, .acq_rel, .acquire) == null) break r;
+ } else null;
+ defer if (slot) |r| r.store(-1, .release);
log.info("a replica connected to '{s}'", .{name()});
defer log.info("a replica of '{s}' left", .{name()});
var out: [wire.hello_max]u8 = undefined;
@@ -698,6 +733,8 @@ const Daemon = struct {
conns: [max_conns]Conn = @splat(.{}),
held: [max_held]Held = @splat(.{}),
replicas: [max_replicas]Replica = @splat(.{}),
+ /// A session asked it to move onto the build installed since (`reexec`).
+ upgrade_asked: bool = false,
fn idle(d: *const Daemon) bool {
for (d.conns) |c| if (c.fd >= 0) return false;
@@ -776,6 +813,10 @@ const Daemon = struct {
for (&d.held) |*h| if (h.fd >= 0 and h.owner == i) d.drop(h);
return;
}
+ if (std.mem.eql(u8, verb, "upgrade")) {
+ d.upgrade_asked = true;
+ return;
+ }
if (std.mem.eql(u8, verb, "adopt")) {
var line: [msg_max]u8 = undefined;
var w: std.Io.Writer = .fixed(&line);
@@ -920,6 +961,93 @@ const Daemon = struct {
_ = libc.close(fd);
}
+ /// Upgrade: this daemon exec'd as the pardes now at the path it was
+ /// started from, on the same listeners and lock, every session's link
+ /// and every master kept open, its registry on the new command line
+ /// (`restore`). A replica whose hello is still on its way is let go: it
+ /// dials again. Returns when it cannot be done, as it was.
+ fn reexec(d: *Daemon, replicas: c_int) void {
+ const path = upgrade.exe() orelse return;
+ var why: [700]u8 = undefined;
+ switch (upgrade.check(path, &why)) {
+ .no => |w| return log.warn("{s}", .{w}),
+ .ok => {},
+ }
+ var text: [flag_room]u8 = undefined;
+ var w: std.Io.Writer = .fixed(&text);
+ w.print("{s}replicas {d}\n", .{ upgrade.flag, replicas }) catch return;
+ for (&d.conns, 0..) |*c, i| if (c.fd >= 0) {
+ const k: []const u8 = if (c.kind) |k| @tagName(k) else "-";
+ w.print("c {d} {d} {s} {d} {d} {x} {s}\n", .{ i, c.fd, k, c.pid, @intFromBool(c.detached), c.semantics, c.named() }) catch return;
+ };
+ for (&d.held) |*h| if (h.fd >= 0) {
+ w.print("h {d} {d} {d}\n", .{ h.fd, h.pid, h.owner orelse 255 }) catch return;
+ };
+ w.writeByte(0) catch return;
+ for (&d.replicas) |*r| if (r.fd >= 0) {
+ _ = libc.close(r.fd);
+ r.* = .{};
+ };
+ const keep = struct {
+ fn all(dd: *Daemon, rep: c_int, on: bool) void {
+ const v: c_int = if (on) 0 else 1;
+ for ([_]c_int{ 3, 4, rep }) |fd| if (fd >= 0) {
+ _ = libc.fcntl(fd, libc.F.SETFD, v);
+ };
+ for (&dd.conns) |*c| if (c.fd >= 0) {
+ _ = libc.fcntl(c.fd, libc.F.SETFD, v);
+ };
+ for (&dd.held) |*h| if (h.fd >= 0) {
+ _ = libc.fcntl(h.fd, libc.F.SETFD, v);
+ };
+ }
+ }.all;
+ const argv = [_:null]?[*:0]const u8{ path, "--daemon", @ptrCast(&text), null };
+ keep(d, replicas, true);
+ _ = libc.execve(path, &argv, @ptrCast(libc.environ));
+ keep(d, replicas, false);
+ log.warn("upgrade: {s} would not start", .{path});
+ }
+
+ /// The registry an upgraded daemon was exec'd with (`reexec`); the
+ /// replicas' listener, its fd, or -1.
+ fn restore(d: *Daemon, text: []const u8) c_int {
+ var replicas: c_int = -1;
+ var lines = std.mem.splitScalar(u8, text, '\n');
+ while (lines.next()) |line| {
+ var words = std.mem.tokenizeScalar(u8, line, ' ');
+ const what = words.next() orelse continue;
+ if (std.mem.eql(u8, what, "replicas")) {
+ replicas = std.fmt.parseInt(c_int, words.next() orelse "", 10) catch -1;
+ if (replicas >= 0) ninep_io.setCloexec(replicas);
+ } else if (std.mem.eql(u8, what, "c")) {
+ const i = std.fmt.parseInt(u8, words.next() orelse "", 10) catch continue;
+ const fd = std.fmt.parseInt(c_int, words.next() orelse "", 10) catch continue;
+ if (i >= max_conns) continue;
+ const k = std.meta.stringToEnum(Kind, words.next() orelse "");
+ const pid = std.fmt.parseInt(libc.pid_t, words.next() orelse "", 10) catch 0;
+ const detached = std.mem.eql(u8, words.next() orelse "", "1");
+ const semantics = std.fmt.parseInt(u64, words.next() orelse "", 16) catch 0;
+ const rest = std.mem.trim(u8, words.rest(), " ");
+ ninep_io.setCloexec(fd);
+ const c = &d.conns[i];
+ c.* = .{ .fd = fd, .kind = k, .pid = pid, .detached = detached, .semantics = semantics };
+ c.name_len = @min(rest.len, c.name.len);
+ @memcpy(c.name[0..c.name_len], rest[0..c.name_len]);
+ } else if (std.mem.eql(u8, what, "h")) {
+ const fd = std.fmt.parseInt(c_int, words.next() orelse "", 10) catch continue;
+ const pid = std.fmt.parseInt(libc.pid_t, words.next() orelse "", 10) catch 0;
+ const owner = std.fmt.parseInt(u8, words.next() orelse "", 10) catch 255;
+ ninep_io.setCloexec(fd);
+ for (&d.held) |*h| if (h.fd < 0) {
+ h.* = .{ .fd = fd, .pid = pid, .owner = if (owner < max_conns) owner else null };
+ break;
+ };
+ }
+ }
+ return replicas;
+ }
+
fn accept(d: *Daemon, listener: c_int) void {
const fd = libc.accept4(listener, null, null, libc.SOCK.CLOEXEC);
if (fd < 0) return;
@@ -946,16 +1074,23 @@ fn listenReplicas() c_int {
return -1;
}
+/// Room for an upgrade's registry on a command line (`reexec`): every
+/// connection and master, each a line.
+const flag_room = 64 * 1024;
+
/// `pardes --daemon`: what `spawn` started, on the listener (fd 3) and the
-/// lock (fd 4). Returns only to exit, idle.
-pub fn serve() noreturn {
+/// lock (fd 4), or (`state`) an upgrade of one, its registry. Returns only
+/// to exit, idle.
+pub fn serve(state: ?[]const u8) noreturn {
const listener: c_int = 3;
ninep_io.setCloexec(3);
ninep_io.setCloexec(4);
const ignore: posix.Sigaction = .{ .handler = .{ .handler = posix.SIG.IGN }, .mask = posix.sigemptyset(), .flags = 0 };
for ([_]posix.SIG{ .PIPE, .HUP, .INT }) |sig| posix.sigaction(sig, &ignore, null);
- const replicas = listenReplicas();
+ upgrade.remember(&.{});
var d: Daemon = .{};
+ const given = if (state) |text| d.restore(text) else -1;
+ const replicas = if (given >= 0) given else listenReplicas();
const slots = 2 + max_conns + max_replicas + max_held;
var fds: [slots]libc.pollfd = undefined;
var conn_of: [slots]u8 = undefined;
@@ -1025,6 +1160,10 @@ pub fn serve() noreturn {
if (pfd.revents == 0 or d.held[i].fd != pfd.fd) continue;
d.drop(&d.held[i]);
}
+ if (d.upgrade_asked) {
+ d.upgrade_asked = false;
+ d.reexec(replicas);
+ }
}
var sock_buf: [sun_path_len:0]u8 = undefined;
_ = libc.close(listener);
diff --git a/src/dump.zig b/src/dump.zig
index 2cef46e2..cb639568 100644
--- a/src/dump.zig
+++ b/src/dump.zig
@@ -321,7 +321,7 @@ pub fn restore(p: *Pardes, bytes: []const u8, from: []const u8) !*Pardes {
var opts = p.opts;
opts.cols = p.screen_w;
opts.rows = p.screen_h;
- const replacement = try loadAndRevive(p.gpa, opts, bytes, p);
+ const replacement = try loadAndRevive(p.gpa, opts, bytes, p, null);
replacement.pointRestoreAt(from);
// The tape follows the replacement from here (it is the session).
pardes.tape.adopt(replacement);
@@ -332,7 +332,7 @@ pub fn restore(p: *Pardes, bytes: []const u8, from: []const u8) !*Pardes {
pub fn initFromDump(gpa: std.mem.Allocator, opts: Options, bytes: []const u8) !*Pardes {
pardes.tape.startFromEnv();
const taped = pardes.tape.enter(null, .{ .init_from_dump = .{ .opts = opts, .bytes = bytes } });
- const p = (if (std.mem.startsWith(u8, bytes, Handover.carried_magic)) carriedWindow(gpa, opts, bytes) else loadAndRevive(gpa, opts, bytes, null)) catch |err| {
+ const p = (if (std.mem.startsWith(u8, bytes, Handover.carried_magic)) carriedWindow(gpa, opts, bytes) else loadAndRevive(gpa, opts, bytes, null, null)) catch |err| {
pardes.tape.leave(null, taped);
return err;
};
@@ -346,18 +346,39 @@ fn carriedWindow(gpa: std.mem.Allocator, opts: Options, bytes: []const u8) !*Par
const p = try Pardes.create(gpa, opts);
errdefer p.deinit();
_ = try Handover.adopt(p, bytes);
- try reviveSession(p, null);
+ try reviveSession(p, null, false);
return p;
}
-fn loadAndRevive(gpa: std.mem.Allocator, opts: Options, bytes: []const u8, previous: ?*const Pardes) !*Pardes {
+/// An upgraded session's dump, loaded as the session it was (upgrade.zig):
+/// every view kept, its settings the dump's (the startup config is not run
+/// again), and the terminals whose shells run on (`kept`) not revived: the
+/// host gives each its pty back. Untaped: a recording ends at an upgrade.
+pub fn resumeFromDump(gpa: std.mem.Allocator, opts: Options, bytes: []const u8, kept: *const [MAX_PANES]bool) !*Pardes {
+ return loadAndRevive(gpa, opts, bytes, null, kept);
+}
+
+/// Where an upgrade leaves its dump: the DumpDir (a relative Restore finds
+/// it there by name), as `pardes-upgrade-<pid>.dump`; never $PARDES_DUMP,
+/// which is a Dump's.
+pub fn upgradePath(buf: *[1024:0]u8, dir_setting: []const u8) ?[:0]const u8 {
+ var dir_buf: [900]u8 = undefined;
+ const dir = directory(&dir_buf, dir_setting) orelse return null;
+ _ = std.Io.Dir.cwd().createDirPathStatus(std.Io.Threaded.global_single_threaded.io(), dir, .fromMode(0o755)) catch {};
+ return std.fmt.bufPrintSentinel(buf, "{s}/pardes-upgrade-{d}.dump", .{ dir, std.c.getpid() }, 0) catch null;
+}
+
+fn loadAndRevive(gpa: std.mem.Allocator, opts: Options, bytes: []const u8, previous: ?*const Pardes, kept: ?*const [MAX_PANES]bool) !*Pardes {
var notes: std.ArrayList(u8) = .empty;
defer notes.deinit(gpa);
var on_disk: OnDisk = @splat(false);
const p = try loadKnowing(gpa, opts, bytes, &notes, &on_disk);
errdefer p.deinit();
- for (p.panes, on_disk, 0..) |slot, was_on_disk, i| if (slot) |pane| revivePane(p, i, pane, was_on_disk);
- try reviveSession(p, previous);
+ for (p.panes, on_disk, 0..) |slot, was_on_disk, i| if (slot) |pane| {
+ if (kept) |k| if (k[i] and pane.terminal != null) continue;
+ revivePane(p, i, pane, was_on_disk);
+ };
+ try reviveSession(p, previous, kept != null);
// What another build's dump could not give, said where the user looks
// (stderr is a tty session's screen).
if (notes.items.len > 0) {
@@ -370,11 +391,12 @@ fn loadAndRevive(gpa: std.mem.Allocator, opts: Options, bytes: []const u8, previ
/// A loaded core given to this host (with `revivePane` for each of its
/// panes): the store and Recent read (a Restore's carried from the session
-/// it replaces) and its ThemeFile asked for again.
-fn reviveSession(p: *Pardes, previous: ?*const Pardes) !void {
+/// it replaces) and its ThemeFile asked for again. An upgrade's (`resumed`)
+/// keeps its views, whose clients come back with it, and its settings.
+fn reviveSession(p: *Pardes, previous: ?*const Pardes, resumed: bool) !void {
// ponytail: one client loads it, so it is one view, the live one's; a
// replica joining (phase 5) takes `load`'s, every view.
- views.only(p);
+ if (!resumed) views.only(p);
if (previous) |old| {
// Never a serial or a request number the old session gave out.
p.next_serial = @max(p.next_serial, old.next_serial);
@@ -403,7 +425,7 @@ fn reviveSession(p: *Pardes, previous: ?*const Pardes) !void {
// The dump's screen until this host says its own (a resize): two
// reflows would lose where a terminal's view was.
p.sync();
- exec.applyStartupConfig(p);
+ if (!resumed) exec.applyStartupConfig(p);
colors.finishThemeInitialization(p);
p.sync();
p.presentation.enabled = true;
@@ -640,6 +662,35 @@ test "a loaded terminal's history stays above its banner, the cursor where it wa
try std.testing.expect(std.mem.indexOf(u8, text, "two") .? < std.mem.indexOf(u8, text, "restored history").?);
}
+test "an upgraded session's dump keeps its views and its running terminal as they were, and settings the startup config would change" {
+ if (comptime !pardes.panes.terminal.enabled or isolated) return error.SkipZigTest;
+ const gpa = std.testing.allocator;
+ const term = pardes.panes.terminal;
+ const p = try Pardes.init(gpa, .{ .tty_only = true, .cols = 40, .rows = 12, .startup_config = "Verbose off\n" });
+ defer p.deinit();
+ while (p.nextEffect()) |_| {}
+ term.feedOutput(p, p.panes[0].?, "one\r\n\x1b[?1049h$ vim");
+ try std.testing.expect(p.executeBuiltinLine(p.active, "Verbose on"));
+ _ = p.openView().?;
+ const bytes = try dumpBytes(p);
+ defer gpa.free(bytes);
+ var kept: [MAX_PANES]bool = @splat(false);
+ kept[0] = true;
+ const q = try resumeFromDump(gpa, .{ .tty_only = true, .cols = 40, .rows = 12, .startup_config = "Verbose off\n" }, bytes, &kept);
+ defer q.deinit();
+ try std.testing.expectEqual(@as(usize, 2), views.count(q));
+ try std.testing.expect(q.settings.verbose);
+ // The program's own screen, no banner, and no shell asked for.
+ try std.testing.expectEqual(term.gridCursor(p.panes[0].?), term.gridCursor(q.panes[0].?));
+ try std.testing.expect(q.panes[0].?.terminal.?.vt.screens.active_key == .alternate);
+ while (q.nextEffect()) |e| try std.testing.expect(e != .spawn);
+ // Not kept, the same terminal is a new shell's under its history.
+ kept[0] = false;
+ const r = try resumeFromDump(gpa, .{ .tty_only = true, .cols = 40, .rows = 12 }, bytes, &kept);
+ defer r.deinit();
+ try std.testing.expect(r.panes[0].?.terminal.?.vt.screens.active_key == .primary);
+}
+
test "a session read by name, field by field as another build reads it, is the same session" {
const gpa = std.testing.allocator;
const p = try Pardes.init(gpa, .{ .tty_only = true });
diff --git a/src/gui/gui.zig b/src/gui/gui.zig
index c550aa4c..24061251 100644
--- a/src/gui/gui.zig
+++ b/src/gui/gui.zig
@@ -23,6 +23,7 @@ const c_heap = @import("c_heap");
const ninep_io = @import("../9p_io.zig");
const daemon = @import("../daemon.zig");
+const upgrade = @import("../upgrade.zig");
const tracy = @import("../tracy.zig");
pub const c = @import("gui_c"); // SDL3 and font.h, translated by build.zig
@@ -2376,7 +2377,9 @@ fn localSession(
opts.cols = @intCast(@max(1, @divTrunc(@as(u32, @intCast(@max(pw, 1))), g.cell_w)));
opts.rows = @intCast(@max(1, @divTrunc(@as(u32, @intCast(@max(ph, 1))), g.cell_h)));
}
- var core = if (opts.load_path) |lp| blk: {
+ var core = if (upgrade.resumed) |*rec|
+ try upgrade.load(gpa, allocs.pardes, opts, rec)
+ else if (opts.load_path) |lp| blk: {
const bytes = try @import("../fs.zig").readFile(gpa, lp);
defer gpa.free(bytes);
break :blk try pardes.dump.initFromDump(allocs.pardes, opts, bytes);
@@ -2457,6 +2460,12 @@ fn localSession(
core.host = host;
while (core.nextEffect()) |e| core.perform(e);
+ // An upgraded session's shells, once a fresh session's own has a
+ // directory to adopt them in.
+ if (upgrade.resumed) |*rec| {
+ shell.resumePtys(rec);
+ while (core.nextEffect()) |e| core.perform(e);
+ }
for (&ptys, 0..) |*slot, id| if (slot.*) |*pt| {
pt.reader = try queue.startReader(.{ .handle = pt.fd, .flags = .{ .nonblocking = false } }, @intCast(id), gens[id]);
};
@@ -2467,10 +2476,12 @@ fn localSession(
if (fs) |f| try f.watch(&queue, wakeFs);
_ = c.SDL_StartTextInput(g.window);
+ // An upgraded session's views, a window each again.
+ if (upgrade.resumed) |*rec| if (!rec.fresh and !headless) shell.resumeWindows();
// PARDES_TEST_VIEWS=N: N more windows from the start, each a view of the
// session (views.zig), captured under view-<k>; view 0 live after.
- if (test_mode) if (std.c.getenv("PARDES_TEST_VIEWS")) |n| {
- for (0..std.fmt.parseInt(u8, std.mem.span(n), 10) catch 0) |_| shell.openAnotherWindow();
+ if (test_mode and upgrade.resumed == null) if (std.c.getenv("PARDES_TEST_VIEWS")) |n| {
+ for (0..std.fmt.parseInt(u8, std.mem.span(n), 10) catch 0) |_| shell.openAnotherWindow(null);
core.toView(0);
shell.follow();
};
@@ -2491,6 +2502,8 @@ fn localSession(
while (!core.quit) {
pardes.turn.bump(&pardes.turn.restores);
try core.pump(host);
+ // Asked in the step (the word), done between steps: the session whole.
+ if (shell.upgrade_asked) |pane| shell.upgradeNow(pane);
// A window asked for again, or an adopted shell, from the daemon's
// thread through the queue; started after the first frame.
daemon.watch(&queue, deliverNote);
@@ -3787,6 +3800,8 @@ const Shell = struct {
/// and the view whose window the Gui holds (`follow`).
windows: [pardes.views.max]GuiWindow = undefined,
gview: u8 = 0,
+ /// Upgrade was asked from this pane, to be done between steps (`upgradeNow`).
+ upgrade_asked: ?u8 = null,
fn reap(s: *Shell) void {
const now = std.Io.Clock.awake.now(s.queue.io).toMilliseconds();
@@ -3905,11 +3920,12 @@ const Shell = struct {
}
/// `pardes-gui --attach` while a window is open: another window, a view
- /// of its own (views.zig), opened as the first was.
- fn openAnotherWindow(s: *Shell) void {
+ /// of its own (views.zig), opened as the first was; or (`existing`) an
+ /// upgraded session's view's window again.
+ fn openAnotherWindow(s: *Shell, existing: ?u8) void {
const g = s.gui orelse return;
s.follow();
- const k = s.core.openView() orelse return log.err("--attach: this session has as many windows as it takes", .{});
+ const k = existing orelse s.core.openView() orelse return log.err("--attach: this session has as many windows as it takes", .{});
const live = s.gview;
copyWindow(&s.windows[live], g);
freshWindow(g);
@@ -3998,6 +4014,94 @@ const Shell = struct {
daemon.adopt();
}
+ fn upgradeAsked(ctx: ?*anyopaque, pane: u8) void {
+ const s = shellOf(ctx);
+ if (comptime !upgrade.supported) return s.core.reportFailure(pane, "Upgrade: this system cannot move a session to another build in place");
+ s.upgrade_asked = pane;
+ }
+
+ /// Upgrade, between steps: this process exec'd as the pardes now at the
+ /// path it was started from, the session in its dump and its ptys and
+ /// daemon link kept open across (upgrade.zig); the new process opens
+ /// its windows again. Returns only when it could not be, as it was.
+ fn upgradeNow(s: *Shell, pane: u8) void {
+ s.upgrade_asked = null;
+ const core = s.core;
+ var why: [800]u8 = undefined;
+ const path = upgrade.exe() orelse return core.reportFailure(pane, "Upgrade: this process does not know the path it was started from");
+ // 9P is served while the new binary is asked, and not after.
+ pardes.turn.rest();
+ const checked = upgrade.check(path, &why);
+ pardes.turn.wake();
+ switch (checked) {
+ .no => |w| return core.reportFailure(pane, w),
+ .ok => {},
+ }
+ // Nothing more read from a pty, and what was read goes in: drained,
+ // the readers stopped (a reader waiting for room has it then), and
+ // what they pushed meanwhile drained.
+ s.drainQueue();
+ for (s.ptys) |*slot| if (slot.*) |*pt| if (pt.reader) |*r| {
+ r.cancel(s.queue.io);
+ pt.reader = null;
+ };
+ s.drainQueue();
+ core.settle();
+ var rec: upgrade.Record = .{ .link = daemon.link, .window = s.gui != null, .exe = path };
+ for (s.ptys, 0..) |slot, id| if (slot) |pt| if (pt.fd >= 0) rec.addPty(id, pt.pid, pt.fd);
+ var at_buf: [1024:0]u8 = undefined;
+ const failed: []const u8 = failed: {
+ const at = pardes.dump.upgradePath(&at_buf, core.settings.dump_dir.get()) orelse break :failed "Upgrade: no directory for the session's dump; this session stays as it is";
+ const bytes = pardes.dump.dumpBytes(core) catch |err| {
+ var words: [128]u8 = undefined;
+ break :failed std.fmt.bufPrint(&why, "Upgrade: the session would not dump: {s}; it stays as it is", .{pardes.Messages.errorWords(err, &words)}) catch "Upgrade: the session would not dump";
+ };
+ defer s.gpa.free(bytes);
+ if (!upgrade.writeDump(at, bytes)) break :failed std.fmt.bufPrint(&why, "Upgrade: the session's dump could not be written to {s}; it stays as it is", .{at[0..@min(at.len, 600)]}) catch "Upgrade: its dump could not be written";
+ rec.dump = at;
+ rec.old = upgrade.openSelf();
+ host_io.Shell.unlinkOwnedRcs();
+ daemon.upgraded();
+ if (s.fs) |f| f.flushOut();
+ const err_words = upgrade.exec(s.gpa, path, -1, &rec);
+ // Still here: the exec failed.
+ _ = libc.unlink(at);
+ if (rec.old >= 0) _ = libc.close(rec.old);
+ break :failed std.fmt.bufPrint(&why, "Upgrade: {s} would not start: {s}; this session stays as it is", .{ path[0..@min(path.len, 600)], err_words }) catch "Upgrade: the new pardes would not start";
+ };
+ // As it was: its ptys read on.
+ for (s.ptys, 0..) |*slot, id| if (slot.*) |*pt| if (pt.fd >= 0 and pt.reader == null) {
+ pt.reader = s.queue.startReader(.{ .handle = pt.fd, .flags = .{ .nonblocking = false } }, @intCast(id), s.gens[id]) catch null;
+ };
+ core.reportFailure(pane, failed);
+ }
+
+ /// An upgraded session's shells, running on: each its pane's pty again,
+ /// or, when its dump would not load (`fresh`), adopted as new panes.
+ fn resumePtys(s: *Shell, rec: *const upgrade.Record) void {
+ for (rec.ptys[0..rec.nptys]) |k| {
+ const pane = if (rec.fresh) null else s.core.panes[k.pane];
+ if (pane == null or !pane.?.isTerminal()) {
+ s.adoptShell(k.pid, k.fd);
+ continue;
+ }
+ s.ptys[k.pane] = .{ .fd = k.fd, .pid = k.pid, .serial = pane.?.serial, .cmd = .{ .watched = pane.?.command != null and host_io.watchExit(k.pid), .fd = k.fd } };
+ }
+ }
+
+ /// An upgraded session's views, a window each again: the Gui's is the
+ /// live view's, the others open as `--attach` opens one.
+ fn resumeWindows(s: *Shell) void {
+ const live = s.core.view;
+ s.gview = live;
+ for (0..pardes.views.max) |i| {
+ const k: u8 = @intCast(i);
+ if (k != live and pardes.views.isOpen(s.core, k)) s.openAnotherWindow(k);
+ }
+ s.core.toView(live);
+ s.follow();
+ }
+
/// One shell of a dead session (`pid` 0: the last of them was told):
/// a terminal pane made for it, as the Tty word makes one, whose spawn
/// takes this pty (spawnPane).
@@ -4038,6 +4142,7 @@ const Shell = struct {
.watched = watched,
.detach = detachWindow,
.adopt = adopt,
+ .upgrade = upgradeAsked,
.spawn = spawnPane,
.pty_write = ptyWrite,
.pty_resize = ptyResize,
@@ -4072,6 +4177,7 @@ const Shell = struct {
v.watched = null;
v.detach = null;
v.adopt = null;
+ v.upgrade = null;
break :vt v;
};
@@ -4167,7 +4273,7 @@ const Shell = struct {
.files_changed => check_files = true,
.fs_ready => {},
.window => {
- if (s.gui != null) s.openAnotherWindow() else s.openTheWindow();
+ if (s.gui != null) s.openAnotherWindow(null) else s.openTheWindow();
s.saw_event = true;
},
.adopted => |a| {
diff --git a/src/host_io.zig b/src/host_io.zig
index 7b0fe9a2..46ee9afc 100644
--- a/src/host_io.zig
+++ b/src/host_io.zig
@@ -29,6 +29,9 @@ pub const Host = struct {
detach: ?*const fn (ctx: ?*anyopaque) void = null,
/// Adopt: the shells a dead session left, asked of the daemon.
adopt: ?*const fn (ctx: ?*anyopaque, pane: u8) void = null,
+ /// Upgrade: this process exec'd as the pardes installed since, at
+ /// the step's end (upgrade.zig); `pane` hears why if it cannot be.
+ upgrade: ?*const fn (ctx: ?*anyopaque, pane: u8) void = null,
spawn: ?*const fn (ctx: ?*anyopaque, pane: u8, cwd: []const u8) void = null,
pty_write: ?*const fn (ctx: ?*anyopaque, pane: u8, bytes: []const u8) void = null,
pty_resize: ?*const fn (ctx: ?*anyopaque, pane: u8, cols: u16, rows: u16) void = null,
diff --git a/src/main.zig b/src/main.zig
index ac2226ae..a6144475 100644
--- a/src/main.zig
+++ b/src/main.zig
@@ -3,6 +3,7 @@ const builtin = @import("builtin");
const pardes = @import("pardes.zig");
const ninep_io = @import("9p_io.zig");
const daemon = @import("daemon.zig");
+const upgrade = @import("upgrade.zig");
const is_emscripten = builtin.os.tag == .emscripten;
@@ -346,8 +347,18 @@ fn nativeMain(std_init: std.process.Init) !void {
var mounts_len: usize = 0;
const arena = init.arena.allocator();
const args = try init.minimal.args.toSlice(arena);
- // The per-user daemon a session started (daemon.zig): nothing else.
- if (comptime daemon.supported) if (args.len == 2 and std.mem.eql(u8, args[1], "--daemon")) daemon.serve();
+ // The per-user daemon a session started (daemon.zig), or an upgrade of
+ // one with its registry: nothing else.
+ if (comptime daemon.supported) if (args.len >= 2 and args.len <= 3 and std.mem.eql(u8, args[1], "--daemon"))
+ daemon.serve(if (args.len == 3 and std.mem.startsWith(u8, args[2], upgrade.flag)) args[2][upgrade.flag.len..] else null);
+ // An upgraded session's new process (upgrade.zig): its record, then the
+ // arguments it was started with, which configure it as before; its
+ // file, stdin, directory and daemon come from the record instead.
+ const upgraded = comptime upgrade.supported and (pardes.platform == .tty or pardes.platform == .gui);
+ if (upgraded) if (args.len > 1 and std.mem.startsWith(u8, args[1], upgrade.flag)) {
+ upgrade.resumed = upgrade.Record.decode(args[1][upgrade.flag.len..]) catch badArgs(init.io, "--upgraded: a record this build cannot read", .{});
+ };
+ const resuming = upgrade.resumed != null;
var session_only = true;
var new_session = false;
var explicit_tty = false;
@@ -355,7 +366,7 @@ fn nativeMain(std_init: std.process.Init) !void {
var attach: ?[]const u8 = null;
var positional: ?[:0]const u8 = null;
var wait = false;
- var i: usize = 1;
+ var i: usize = if (resuming) 2 else 1;
while (i < args.len) : (i += 1) {
const a = args[i];
if (std.mem.eql(u8, a, "--tty")) {
@@ -496,7 +507,7 @@ fn nativeMain(std_init: std.process.Init) !void {
badArgs(init.io, "--9p-quic opens a session's own listener, and --attach has none of its own", .{});
if (opts.mounts.len != 0 and attach != null)
badArgs(init.io, "--mount configures a session's own core, and --attach has none of its own", .{});
- if (!new_session and !opts.nested and detach == null and attach == null) forwarding: {
+ if (!new_session and !opts.nested and detach == null and attach == null and !resuming) forwarding: {
// Am I inside a pardes at all? That is $PARDES_PID and nothing else —
// one variable, exported by every session that means to take its
// children's Looks, so a session that could not open a socket is still
@@ -677,6 +688,7 @@ fn nativeMain(std_init: std.process.Init) !void {
if (wait) waitForDel(init.io, arena, parent.dial, path, made_serial);
return;
}
+ if (resuming) positional = null;
// `pardes -` outside a session: an editor whose first pane holds stdin,
// as `vim -` does; the terminal is /dev/tty, never stdin.
if (positional) |a| if (std.mem.eql(u8, a, "-")) {
@@ -726,11 +738,11 @@ fn nativeMain(std_init: std.process.Init) !void {
opts.config_dir = found.dir;
opts.store_path = storePath(init.io, arena, init.environ_map);
if (found.dir) |d| @import("crash.zig").setDir(d);
- if (attach) |name| attachTo(init.io, name);
+ if (attach) |name| if (!resuming) attachTo(init.io, name);
if (detach) |name| {
// Said plainly, never a Zig error trace: a name a live session's
// socket holds already (a plain session is named by its pid too).
- if (name.len != 0 and ninep_io.taken(name)) {
+ if (name.len != 0 and !resuming and ninep_io.taken(name)) {
var said: [512]u8 = undefined;
std.Io.File.stderr().writeStreamingAll(init.io, std.fmt.bufPrint(&said, "pardes: a session named {s} is already running\n", .{name}) catch "pardes: a session of that name is already running\n") catch {};
std.process.exit(1);
@@ -743,7 +755,19 @@ fn nativeMain(std_init: std.process.Init) !void {
}
const kind: daemon.Kind = if (pardes.platform == .gui) .gui else .tty;
var term: @import("tty/tty.zig").Term = if (detach != null) .none else .open;
- if (daemon.wanted()) {
+ var headless = detach != null;
+ upgrade.remember(args);
+ if (upgrade.resumed) |*rec| {
+ // Close-on-exec again: a shell forked from here inherits none.
+ rec.closeOnExec(true);
+ opts.load_path = rec.dump;
+ term = .none;
+ for (rec.ttys[0..rec.nttys]) |t| if (t.primary) {
+ term = .{ .fd = .{ .fd = t.fd, .termios = t.termios } };
+ };
+ headless = if (pardes.platform == .gui) !rec.window else rec.nttys == 0;
+ daemon.resumeLink(rec.link, rec.stub, kind, opts.ninep_name, headless);
+ } else if (daemon.wanted()) {
if (detach != null or pardes.platform == .gui) {
_ = daemon.register(null, kind, opts.ninep_name, detach != null);
} else if (pardes.platform == .tty) fork: {
@@ -770,7 +794,7 @@ fn nativeMain(std_init: std.process.Init) !void {
break :fork;
};
_ = daemon.register(conn, .tty, opts.ninep_name, false);
- term = .{ .fd = fd };
+ term = .{ .fd = .{ .fd = fd } };
}
}
defer daemon.quit();
@@ -785,7 +809,7 @@ fn nativeMain(std_init: std.process.Init) !void {
},
else => return err,
},
- .gui => try @import("gui/gui.zig").run(init, opts, detach != null),
+ .gui => try @import("gui/gui.zig").run(init, opts, headless),
.web, .macos, .esp32p4 => unreachable,
}
daemon.tellStubExit(0);
diff --git a/src/pardes.zig b/src/pardes.zig
index 0806cc78..081861ac 100644
--- a/src/pardes.zig
+++ b/src/pardes.zig
@@ -501,6 +501,7 @@ test {
_ = @import("body_layer.zig");
_ = @import("draw.zig");
_ = @import("dump.zig"); // its tests ran nowhere before
+ _ = @import("upgrade.zig");
_ = @import("recent.zig");
_ = @import("Store.zig");
_ = @import("Presentation.zig");
@@ -6048,6 +6049,13 @@ pub const Pardes = struct {
}
}
+ /// What a step leaves queued, its inputs and its effects, taken now:
+ /// the session at a step boundary (an Upgrade's dump, upgrade.zig).
+ pub fn settle(p: *Pardes) void {
+ while (p.nextQueued()) |ev| p.update(ev);
+ while (p.nextEffect()) |e| p.perform(e);
+ }
+
pub fn pump(p: *Pardes, host: Host) !void {
p.host = host;
const taped = tape.enter(p, .pump);
diff --git a/src/tty/tty.zig b/src/tty/tty.zig
index a7048645..ef7688bc 100644
--- a/src/tty/tty.zig
+++ b/src/tty/tty.zig
@@ -16,6 +16,7 @@ const ninep_io = @import("../9p_io.zig");
const panel_compositor = @import("panel_compositor.zig");
const daemon = @import("../daemon.zig");
const host_io = @import("../host_io.zig");
+const upgrade = @import("../upgrade.zig");
extern "c" fn setenv(name: [*:0]const u8, value: [*:0]const u8, overwrite: c_int) c_int;
@@ -69,6 +70,16 @@ fn kittyShmName(buf: []u8, n: u32) ![:0]const u8 {
return std.fmt.bufPrintSentinel(buf, "/pardes-{d}-{d}", .{ libc.getpid(), n }, 0);
}
+/// A terminal unlinks what it reads; whatever it never read (the probe
+/// unanswered, a transmission lost with the terminal) is ours to remove.
+fn unlinkKittyShm() void {
+ var name_buf: [64]u8 = undefined;
+ var n: u32 = 0;
+ while (n <= kitty_shm_serial) : (n += 1) {
+ if (kittyShmName(&name_buf, n)) |name| _ = libc.shm_unlink(name) else |_| {}
+ }
+}
+
/// Write `bytes` to a fresh shm object; the terminal unlinks it after reading.
fn kittyShmWrite(name: [:0]const u8, bytes: []const u8) bool {
const fd = libc.shm_open(name, @bitCast(libc.O{ .ACCMODE = .RDWR, .CREAT = true, .EXCL = true }), @as(c_uint, 0o600));
@@ -1208,7 +1219,9 @@ fn nativePdfWheelTarget(core: *const pardes.Pardes, mouse: vaxis.Mouse) ?PdfWhee
/// Where a session's terminal comes from: /dev/tty, as a plain `pardes`
/// opens it; one open already (a session forked off its stub,
/// daemon.forkSession); or none, until one is attached (`--detach`).
-pub const Term = union(enum) { open, fd: posix.fd_t, none };
+/// The terminal a session starts on: /dev/tty, one its stub opened (an
+/// upgraded session's is raw already, `termios` the cooked one), or none.
+pub const Term = union(enum) { open, fd: struct { fd: posix.fd_t, termios: ?posix.termios = null }, none };
pub fn run(init: std.process.Init, opts: pardes.Options, term: Term) !void {
const io = init.io;
@@ -1230,7 +1243,7 @@ pub fn run(init: std.process.Init, opts: pardes.Options, term: Term) !void {
defer screen.kitty.deinit();
switch (term) {
.open => try screen.enter(try vaxis.Tty.init(io, &tty_buf)),
- .fd => |fd| try screen.enter(try Screen.ttyOn(io, &tty_buf, fd)),
+ .fd => |t| try screen.enter(try Screen.ttyOn(io, &tty_buf, t.fd, t.termios)),
.none => {},
}
defer screen.leave();
@@ -1277,9 +1290,10 @@ const Screen = struct {
/// `fd` made raw, as vaxis.Tty.init makes /dev/tty: the terminal of a
/// forked session is no controlling terminal of its, which /dev/tty is.
- fn ttyOn(io: std.Io, buf: []u8, fd: posix.fd_t) !vaxis.Tty {
+ /// An upgraded session's is raw already, `cooked` what it goes back to.
+ fn ttyOn(io: std.Io, buf: []u8, fd: posix.fd_t, cooked: ?posix.termios) !vaxis.Tty {
if (comptime builtin.is_test) unreachable; // vaxis.Tty is its TestTty
- const termios = try vaxis.Tty.makeRaw(fd);
+ const termios = cooked orelse try vaxis.Tty.makeRaw(fd);
const file: std.Io.File = .{ .handle = fd, .flags = .{ .nonblocking = false } };
return .{ .io = io, .fd = file, .termios = termios, .tty_writer = file.writerStreaming(io, buf) };
}
@@ -1416,7 +1430,9 @@ fn localSession(
pardes.syntax.stop();
}
- var core = if (options.load_path) |lp| blk: {
+ var core = if (upgrade.resumed) |*rec|
+ try upgrade.load(gpa, allocs.pardes, options, rec)
+ else if (options.load_path) |lp| blk: {
const bytes = try filesystem.readFile(gpa, lp);
defer gpa.free(bytes);
break :blk try pardes.dump.initFromDump(allocs.pardes, options, bytes);
@@ -1505,9 +1521,17 @@ fn localSession(
const host = sh.host();
core.host = host;
+ // An upgraded session's terminals, its own again.
+ if (comptime !builtin.is_test) if (upgrade.resumed) |*rec| sh.resumeTerminals(rec, screen);
// Nobody to see it, and nobody to size it: `size` sets it (ctl.zig).
- core.unattended = !screen.on;
+ core.unattended = !sh.attached();
while (core.nextEffect()) |effect| core.perform(effect);
+ // ...and its shells, once a fresh session's own has a directory to
+ // adopt them in.
+ if (upgrade.resumed) |*rec| {
+ sh.resumePtys(rec);
+ while (core.nextEffect()) |effect| core.perform(effect);
+ }
if (screen.on) try startInput(loop, screen);
defer stopInput(io, &screen.thread);
@@ -1520,15 +1544,15 @@ fn localSession(
// PARDES_TEST_VIEWS: the terminals at these paths are views of the
// session too, from its start, as `pardes --attach`ed ones are (the
// snapshot harness's `start ... views=N`).
- if (init.environ_map.get("PARDES_TEST_VIEWS")) |paths| {
+ if (upgrade.resumed == null) if (init.environ_map.get("PARDES_TEST_VIEWS")) |paths| {
var it = std.mem.tokenizeScalar(u8, paths, ' ');
while (it.next()) |path| {
var path_buf: [256]u8 = undefined;
const z = std.fmt.bufPrintSentinel(&path_buf, "{s}", .{path}, 0) catch continue;
const fd = libc.open(z, .{ .ACCMODE = .RDWR, .NOCTTY = true, .CLOEXEC = true }, @as(libc.mode_t, 0));
- if (fd >= 0) sh.attachTerminal(fd, -1);
+ if (fd >= 0) sh.attachTerminal(fd, -1, null);
}
- }
+ };
sh.threads_ok = true;
for (&sh.ptys, 0..) |*slot, id| if (slot.*) |*pt| {
@@ -1536,18 +1560,12 @@ fn localSession(
};
if (sh.inotify_fd >= 0) sh.watch_task = io.concurrent(watchFiles, .{ io, sh.inotify_fd, loop }) catch null;
- // A terminal unlinks what it reads; whatever it never read (the probe
- // unanswered, a transmission lost with the terminal) is ours to remove.
- defer {
- var name_buf: [64]u8 = undefined;
- var n: u32 = 0;
- while (n <= kitty_shm_serial) : (n += 1) {
- if (kittyShmName(&name_buf, n)) |name| _ = libc.shm_unlink(name) else |_| {}
- }
- }
+ defer unlinkKittyShm();
while (!core.quit) {
pardes.turn.bump(&pardes.turn.restores);
try core.pump(host);
+ // Asked in the step (the word), done between steps: the session whole.
+ if (sh.upgrade_asked) |pane| sh.upgradeNow(pane);
// A terminal (`pardes --attach`) or an adopted shell, handed on by
// the daemon's thread to this loop; started after the first frame,
// off a startup's way.
@@ -1695,6 +1713,10 @@ const Shell = struct {
drawn_ns: u64 = 0,
input_ns: u64 = 0,
focused_ns: u64 = 0,
+ /// Upgrade was asked from this pane, to be done between steps (`upgradeNow`).
+ upgrade_asked: ?u8 = null,
+ /// Its pty readers stopped for it: their end of file is not a shell's.
+ upgrading: bool = false,
const Leaving = enum { detach, exit };
@@ -1723,6 +1745,7 @@ const Shell = struct {
.watched = watched,
.detach = detach,
.adopt = adopt,
+ .upgrade = upgradeAsked,
.spawn = spawn,
.pty_write = ptyWrite,
.pty_resize = ptyResize,
@@ -1825,7 +1848,7 @@ const Shell = struct {
/// `pardes --attach`'s terminal: for a detached session its own again,
/// entered as the first one was; for one attached already, a view of
/// its own (views.zig). Sized, asked what it can do, and drawn whole.
- fn attachTerminal(s: *Shell, fd: posix.fd_t, stub: posix.fd_t) void {
+ fn attachTerminal(s: *Shell, fd: posix.fd_t, stub: posix.fd_t, cooked: ?posix.termios) void {
const live = s.term() orelse return;
const screen = if (!live.on) live else extra: {
const sc = s.gpa.create(Screen) catch break :extra null;
@@ -1840,7 +1863,7 @@ const Shell = struct {
return refuse(stub, "that session has no room for another terminal");
};
const extra = screen != live;
- const tty = Screen.ttyOn(s.io, screen.buf, fd) catch {
+ const tty = Screen.ttyOn(s.io, screen.buf, fd, cooked) catch {
_ = libc.close(fd);
if (extra) s.freeScreen(screen) else daemon.setState(true);
return refuse(stub, "that terminal would not go raw");
@@ -1886,6 +1909,159 @@ const Shell = struct {
daemon.adopt();
}
+ fn upgradeAsked(ctx: ?*anyopaque, pane: u8) void {
+ const s = of(ctx);
+ if (comptime !upgrade.supported) return s.core.reportFailure(pane, "Upgrade: this system cannot move a session to another build in place");
+ s.upgrade_asked = pane;
+ }
+
+ /// Upgrade, between steps: this process exec'd as the pardes now at the
+ /// path it was started from, the session in its dump, and its ptys,
+ /// terminals, stubs and daemon link kept open across (upgrade.zig).
+ /// Returns only when it could not be, the session going on as it was.
+ fn upgradeNow(s: *Shell, pane: u8) void {
+ if (comptime builtin.is_test) unreachable; // vaxis.Tty is its TestTty
+ s.upgrade_asked = null;
+ const core = s.core;
+ var why: [800]u8 = undefined;
+ const path = upgrade.exe() orelse return core.reportFailure(pane, "Upgrade: this process does not know the path it was started from");
+ // 9P is served while the new binary is asked (its clients' clunks
+ // and reads after the word are answered), and not after.
+ pardes.turn.rest();
+ const checked = upgrade.check(path, &why);
+ pardes.turn.wake();
+ switch (checked) {
+ .no => |w| return core.reportFailure(pane, w),
+ .ok => {},
+ }
+ // Nothing more read from a pty or a terminal, and what was read
+ // goes in; a reader's cancel posts an end of file, passed over.
+ s.upgrading = true;
+ defer s.upgrading = false;
+ for (&s.ptys) |*slot| if (slot.*) |*pt| pt.reader.cancel(s.io) catch {};
+ for (s.terms) |slot| if (slot) |sc| stopInput(s.io, &sc.thread);
+ while (s.loop.tryEvent() catch null) |ev| _ = s.apply(ev);
+ core.settle();
+ var rec: upgrade.Record = .{ .link = daemon.link, .stub = daemon.stub, .exe = path };
+ for (s.ptys, 0..) |slot, id| if (slot) |pt| rec.addPty(id, pt.pid, pt.file.handle);
+ for (s.terms, 0..) |slot, k| if (slot) |sc| if (sc.on) rec.addTty(.{
+ .view = @intCast(k),
+ .fd = sc.tty.fd.handle,
+ .stub = if (sc.primary) daemon.stub else sc.stub,
+ .primary = sc.primary,
+ .termios = sc.tty.termios,
+ });
+ var popped = false;
+ var at_buf: [1024:0]u8 = undefined;
+ const failed: []const u8 = failed: {
+ const at = pardes.dump.upgradePath(&at_buf, core.settings.dump_dir.get()) orelse break :failed "Upgrade: no directory for the session's dump; this session stays as it is";
+ const bytes = pardes.dump.dumpBytes(core) catch |err| {
+ var words: [128]u8 = undefined;
+ break :failed std.fmt.bufPrint(&why, "Upgrade: the session would not dump: {s}; it stays as it is", .{pardes.Messages.errorWords(err, &words)}) catch "Upgrade: the session would not dump";
+ };
+ defer s.gpa.free(bytes);
+ if (!upgrade.writeDump(at, bytes)) break :failed std.fmt.bufPrint(&why, "Upgrade: the session's dump could not be written to {s}; it stays as it is", .{at[0..@min(at.len, 600)]}) catch "Upgrade: its dump could not be written";
+ rec.dump = at;
+ rec.old = upgrade.openSelf();
+ // What this process put in its terminals that the next puts in
+ // again: its images, and its keyboard mode, a stack.
+ for (s.terms) |slot| if (slot) |sc| if (sc.on) {
+ clearNativeImages(&sc.kitty, &sc.vx, &sc.tty);
+ if (sc.vx.state.kitty_keyboard) sc.tty.writer().writeAll("\x1b[<u") catch {};
+ sc.vx.state.kitty_keyboard = false;
+ sc.tty.writer().flush() catch {};
+ };
+ popped = true;
+ unlinkKittyShm();
+ host_io.Shell.unlinkOwnedRcs();
+ daemon.upgraded();
+ if (s.fs) |f| f.flushOut();
+ const err_words = upgrade.exec(s.gpa, path, -1, &rec);
+ // Still here: the exec failed.
+ _ = libc.unlink(at);
+ if (rec.old >= 0) _ = libc.close(rec.old);
+ break :failed std.fmt.bufPrint(&why, "Upgrade: {s} would not start: {s}; this session stays as it is", .{ path[0..@min(path.len, 600)], err_words }) catch "Upgrade: the new pardes would not start";
+ };
+ // As it was: its ptys read on, its terminals' keys as they were.
+ for (&s.ptys, 0..) |*slot, id| if (slot.*) |*pt| {
+ pt.reader = s.io.concurrent(readPty, .{ s.io, s.gpa, pt.file, id, s.gens[id], s.loop }) catch pt.reader;
+ };
+ for (s.terms) |slot| if (slot) |sc| if (sc.on) {
+ if (popped) sc.vx.enableDetectedFeatures(sc.tty.writer()) catch {};
+ startInput(s.loop, sc) catch {};
+ };
+ core.reportFailure(pane, failed);
+ }
+
+ /// An upgraded session's shells, running on: each its pane's pty again,
+ /// or, when its dump would not load (`fresh`), adopted as new panes.
+ fn resumePtys(s: *Shell, rec: *const upgrade.Record) void {
+ for (rec.ptys[0..rec.nptys]) |k| {
+ const pane = if (rec.fresh) null else s.core.panes[k.pane];
+ if (pane == null or !pane.?.isTerminal()) {
+ s.adoptShell(k.pid, k.fd);
+ continue;
+ }
+ const file: std.Io.File = .{ .handle = k.fd, .flags = .{ .nonblocking = false } };
+ s.ptys[k.pane] = .{ .file = file, .pid = k.pid, .reader = .{ .any_future = null, .result = {} }, .cmd = .{ .watched = pane.?.command != null and host_io.watchExit(k.pid), .fd = k.fd } };
+ }
+ }
+
+ /// An upgraded session's terminals, each its view's again (`primary`,
+ /// run's, entered already); in a fresh session each but the primary a
+ /// view of its own, as `--attach` makes one. A view left with none
+ /// closes.
+ fn resumeTerminals(s: *Shell, rec: *const upgrade.Record, primary: *Screen) void {
+ if (comptime builtin.is_test) unreachable;
+ const core = s.core;
+ if (rec.fresh) {
+ for (rec.ttys[0..rec.nttys]) |t| if (!t.primary) s.attachTerminal(t.fd, t.stub, t.termios);
+ return;
+ }
+ s.terms = @splat(null);
+ if (rec.nttys == 0) {
+ pardes.views.only(core);
+ s.terms[core.view] = primary;
+ return;
+ }
+ for (rec.ttys[0..rec.nttys]) |t| {
+ if (!pardes.views.isOpen(core, t.view) or s.terms[t.view] != null) {
+ if (t.primary) continue;
+ _ = libc.close(t.fd);
+ if (t.stub >= 0) daemon.tellDetached(t.stub);
+ continue;
+ }
+ const sc = if (t.primary) primary else extra: {
+ const sc = s.gpa.create(Screen) catch break :extra null;
+ const buf = s.gpa.alloc(u8, 0x10000) catch {
+ s.gpa.destroy(sc);
+ break :extra null;
+ };
+ sc.* = .{ .io = s.io, .gpa = s.gpa, .env = primary.env, .buf = buf, .kitty = .init(s.gpa) };
+ const tty = Screen.ttyOn(s.io, sc.buf, t.fd, t.termios) catch {
+ s.freeScreen(sc);
+ break :extra null;
+ };
+ sc.enter(tty) catch {
+ s.freeScreen(sc);
+ break :extra null;
+ };
+ sc.setStub(t.stub);
+ startInput(s.loop, sc) catch {};
+ sc.vx.queryTerminalSend(sc.tty.writer()) catch {};
+ break :extra sc;
+ } orelse {
+ _ = libc.close(t.fd);
+ if (t.stub >= 0) daemon.tellDetached(t.stub);
+ continue;
+ };
+ sc.feed.view = t.view;
+ s.terms[t.view] = sc;
+ }
+ for (0..pardes.views.max) |k| if (pardes.views.isOpen(core, @intCast(k)) and s.terms[k] == null) core.closeView(@intCast(k));
+ if (s.terms[core.view] == null) s.terms[core.view] = primary;
+ }
+
/// One shell of a dead session (`pid` 0: the last of them was told).
fn adoptShell(s: *Shell, pid: posix.pid_t, fd: posix.fd_t) void {
const core = s.core;
@@ -2083,7 +2259,7 @@ const Shell = struct {
core.quit = true;
return true;
},
- .attach => |a| s.attachTerminal(a.tty, a.stub),
+ .attach => |a| s.attachTerminal(a.tty, a.stub, null),
.adopted => |a| s.adoptShell(a.pid, a.fd),
.focus_in => core.update(.{ .focus = true }),
.focus_out => {
@@ -2102,7 +2278,7 @@ const Shell = struct {
s.takeExits();
return true;
},
- .pty_eof => |e| if (s.gens[e.id] == e.gen) {
+ .pty_eof => |e| if (s.gens[e.id] == e.gen and !s.upgrading) {
if (s.ptys[e.id]) |*pt| {
pt.reader.await(s.io) catch {}; // reader just finished; join it or its future leaks
// A command's pty stays open until its child has exited:
diff --git a/src/upgrade.zig b/src/upgrade.zig
new file mode 100644
index 00000000..c49d2370
--- /dev/null
+++ b/src/upgrade.zig
@@ -0,0 +1,389 @@
+//! Upgrade (docs/next-daemon.md, "Phase 6: upgrade notes"): a running
+//! session, and the daemon, moved onto the pardes installed since they
+//! started, in place.
+//!
+//! At a step boundary a session writes its dump (phase 2) and execs the
+//! path it was started from. Its pty masters, terminals, stubs and daemon
+//! link stay open across the exec, named in a record on the new command
+//! line: `--upgraded=<record>` ahead of the arguments it was started with.
+//! The pid stays, so its shells stay its children; the new process loads
+//! the dump and takes those fds back (each host's `resume`). A new build
+//! that cannot load the dump execs the old one again, from the copy this
+//! process left open (Linux), and with none it starts afresh with the
+//! shells adopted, the dump left for a Restore by hand.
+const std = @import("std");
+const builtin = @import("builtin");
+const libc = std.c;
+const posix = std.posix;
+const pardes = @import("pardes.zig");
+
+pub const supported = builtin.os.tag == .linux or builtin.os.tag == .freebsd;
+pub const flag = "--upgraded=";
+
+/// What this build says it is (`pardes --version`'s first line).
+pub const version_line = if (pardes.commit) |c| "pardes " ++ pardes.version ++ " (" ++ c ++ ")" else "pardes " ++ pardes.version;
+
+// ---- the path it was started from ----
+
+/// The path this process was started from, what Upgrade execs: a reinstall
+/// puts the new build there, while /proc/self/exe names the old file,
+/// deleted by then.
+var exe_buf: [4096:0]u8 = undefined;
+var exe_len: usize = 0;
+/// The arguments it was started with (an upgrade's record left out).
+var given: []const [:0]const u8 = &.{};
+
+/// Its path asked of the system now, at its start (one readlink), and its
+/// arguments kept; an upgraded process takes the path its record names
+/// (the system would name a fallback's old binary, deleted).
+pub fn remember(args: []const [:0]const u8) void {
+ given = if (args.len > 1 and std.mem.startsWith(u8, args[1], flag)) args[2..] else if (args.len > 0) args[1..] else &.{};
+ if (resumed) |*rec| if (rec.exe.len > 0 and rec.exe.len < exe_buf.len) {
+ @memcpy(exe_buf[0..rec.exe.len], rec.exe);
+ exe_buf[rec.exe.len] = 0;
+ exe_len = rec.exe.len;
+ return;
+ };
+ const n = std.process.executablePath(std.Io.Threaded.global_single_threaded.io(), &exe_buf) catch 0;
+ exe_buf[n] = 0;
+ exe_len = n;
+}
+
+pub fn exe() ?[:0]const u8 {
+ return if (exe_len == 0) null else exe_buf[0..exe_len :0];
+}
+
+// ---- the record ----
+
+pub const Pty = struct { pane: u8, pid: libc.pid_t, fd: c_int };
+/// A terminal and its view: the primary one's stub is daemon.stub; its
+/// termios is the cooked one it is put back to at the end (it is raw now).
+pub const Tty = struct { view: u8, fd: c_int, stub: c_int, primary: bool, termios: posix.termios };
+
+pub const Record = struct {
+ /// daemon.link and daemon.stub.
+ link: c_int = -1,
+ stub: c_int = -1,
+ /// The binary being replaced, open (Linux): a new one that cannot load
+ /// the dump execs it again.
+ old: c_int = -1,
+ /// A window was open (the GUI).
+ window: bool = false,
+ ptys: [pardes.MAX_PANES]Pty = undefined,
+ nptys: usize = 0,
+ ttys: [pardes.views.max]Tty = undefined,
+ nttys: usize = 0,
+ /// The path exec'd, the one a later Upgrade execs again.
+ exe: []const u8 = "",
+ /// The session's dump.
+ dump: []const u8 = "",
+ /// Why the new build could not load it: a start that went back to the
+ /// old binary says so.
+ refused: []const u8 = "",
+ /// This process's own: its dump would not load, so it started afresh
+ /// and adopts the shells.
+ fresh: bool = false,
+
+ pub fn addPty(rec: *Record, pane: usize, pid: libc.pid_t, fd: c_int) void {
+ if (rec.nptys == rec.ptys.len or fd < 0) return;
+ rec.ptys[rec.nptys] = .{ .pane = @intCast(pane), .pid = pid, .fd = fd };
+ rec.nptys += 1;
+ }
+
+ pub fn addTty(rec: *Record, t: Tty) void {
+ if (rec.nttys == rec.ttys.len or t.fd < 0) return;
+ rec.ttys[rec.nttys] = t;
+ rec.nttys += 1;
+ }
+
+ /// Every fd it names, close-on-exec (`on`) or kept across one.
+ pub fn closeOnExec(rec: *const Record, on: bool) void {
+ const set = struct {
+ fn f(fd: c_int, cloexec: bool) void {
+ if (fd >= 0) _ = libc.fcntl(fd, libc.F.SETFD, @as(c_int, if (cloexec) 1 else 0));
+ }
+ }.f;
+ set(rec.link, on);
+ set(rec.stub, on);
+ set(rec.old, on);
+ for (rec.ptys[0..rec.nptys]) |p| set(p.fd, on);
+ for (rec.ttys[0..rec.nttys]) |t| {
+ set(t.fd, on);
+ set(t.stub, on);
+ }
+ }
+
+ /// One `word value` a line, the dump's path last (its line is all of it).
+ pub fn encode(rec: *const Record, w: *std.Io.Writer) !void {
+ try w.print("link {d}\nstub {d}\nold {d}\nwindow {d}\n", .{ rec.link, rec.stub, rec.old, @intFromBool(rec.window) });
+ for (rec.ptys[0..rec.nptys]) |p| try w.print("pty {d} {d} {d}\n", .{ p.pane, p.pid, p.fd });
+ for (rec.ttys[0..rec.nttys]) |t| try w.print("tty {d} {d} {d} {d} {x}\n", .{ t.view, t.fd, t.stub, @intFromBool(t.primary), std.mem.asBytes(&t.termios) });
+ if (rec.refused.len > 0) try w.print("refused {s}\n", .{rec.refused});
+ try w.print("exe {s}\ndump {s}\n", .{ rec.exe, rec.dump });
+ }
+
+ /// `text`'s record; its strings are slices of it.
+ pub fn decode(text: []const u8) !Record {
+ var rec: Record = .{};
+ var lines = std.mem.splitScalar(u8, text, '\n');
+ while (lines.next()) |line| {
+ if (line.len == 0) continue;
+ const sp = std.mem.indexOfScalar(u8, line, ' ') orelse return error.BadRecord;
+ const word = line[0..sp];
+ const rest = line[sp + 1 ..];
+ var it = std.mem.tokenizeScalar(u8, rest, ' ');
+ if (std.mem.eql(u8, word, "link")) {
+ rec.link = try std.fmt.parseInt(c_int, rest, 10);
+ } else if (std.mem.eql(u8, word, "stub")) {
+ rec.stub = try std.fmt.parseInt(c_int, rest, 10);
+ } else if (std.mem.eql(u8, word, "old")) {
+ rec.old = try std.fmt.parseInt(c_int, rest, 10);
+ } else if (std.mem.eql(u8, word, "window")) {
+ rec.window = std.mem.eql(u8, rest, "1");
+ } else if (std.mem.eql(u8, word, "pty")) {
+ if (rec.nptys == rec.ptys.len) return error.BadRecord;
+ const pane = try std.fmt.parseInt(u8, it.next() orelse return error.BadRecord, 10);
+ if (pane >= pardes.MAX_PANES) return error.BadRecord;
+ rec.ptys[rec.nptys] = .{
+ .pane = pane,
+ .pid = try std.fmt.parseInt(libc.pid_t, it.next() orelse return error.BadRecord, 10),
+ .fd = try std.fmt.parseInt(c_int, it.next() orelse return error.BadRecord, 10),
+ };
+ rec.nptys += 1;
+ } else if (std.mem.eql(u8, word, "tty")) {
+ if (rec.nttys == rec.ttys.len) return error.BadRecord;
+ var t: Tty = .{
+ .view = try std.fmt.parseInt(u8, it.next() orelse return error.BadRecord, 10),
+ .fd = try std.fmt.parseInt(c_int, it.next() orelse return error.BadRecord, 10),
+ .stub = try std.fmt.parseInt(c_int, it.next() orelse return error.BadRecord, 10),
+ .primary = std.mem.eql(u8, it.next() orelse return error.BadRecord, "1"),
+ .termios = undefined,
+ };
+ const hex = it.next() orelse return error.BadRecord;
+ // Another build's termios is the kernel's, of one size.
+ if (hex.len != 2 * @sizeOf(posix.termios) or t.view >= pardes.views.max) return error.BadRecord;
+ _ = try std.fmt.hexToBytes(std.mem.asBytes(&t.termios), hex);
+ rec.ttys[rec.nttys] = t;
+ rec.nttys += 1;
+ } else if (std.mem.eql(u8, word, "refused")) {
+ rec.refused = rest;
+ } else if (std.mem.eql(u8, word, "exe")) {
+ rec.exe = rest;
+ } else if (std.mem.eql(u8, word, "dump")) {
+ rec.dump = rest;
+ }
+ // A word of a later build's record is passed over.
+ }
+ if (rec.dump.len == 0) return error.BadRecord;
+ return rec;
+ }
+};
+
+/// The record this process was started with (`--upgraded=`), set by main.
+pub var resumed: ?Record = null;
+
+// ---- before: asking the new binary, and the exec ----
+
+pub const Checked = union(enum) { ok: []const u8, no: []const u8 };
+
+/// `path --version` run as it is: a binary not there, not a pardes, or one
+/// that cannot start, found before anything is let go. Its first line
+/// (`pardes <version>`), or why not, in `buf`.
+pub fn check(path: [:0]const u8, buf: []u8) Checked {
+ var pipe: [2]c_int = undefined;
+ if (libc.pipe(&pipe) != 0) return .{ .no = "Upgrade: no pipe to ask the new pardes its version" };
+ const argv = [_:null]?[*:0]const u8{ path, "--version", null };
+ const pid = libc.fork();
+ if (pid < 0) {
+ _ = libc.close(pipe[0]);
+ _ = libc.close(pipe[1]);
+ return .{ .no = "Upgrade: no process to ask the new pardes its version" };
+ }
+ if (pid == 0) {
+ // Only async-signal-safe calls between fork and exec.
+ _ = libc.dup2(pipe[1], 1);
+ const null_fd = libc.open("/dev/null", .{ .ACCMODE = .RDWR }, @as(libc.mode_t, 0));
+ if (null_fd >= 0) {
+ _ = libc.dup2(null_fd, 0);
+ _ = libc.dup2(null_fd, 2);
+ }
+ _ = libc.execve(path, &argv, @ptrCast(libc.environ));
+ libc._exit(127);
+ }
+ _ = libc.close(pipe[1]);
+ var len: usize = 0;
+ var waited = false;
+ while (len < buf.len) {
+ // A pardes answers --version in milliseconds; 10 s is one that hangs.
+ var fds = [_]libc.pollfd{.{ .fd = pipe[0], .events = libc.POLL.IN, .revents = 0 }};
+ const ready = libc.poll(&fds, 1, 10_000);
+ if (ready < 0 and libc.errno(ready) == .INTR) continue;
+ if (ready <= 0) {
+ _ = libc.kill(pid, .KILL);
+ waited = true;
+ break;
+ }
+ const n = libc.read(pipe[0], buf[len..].ptr, buf.len - len);
+ if (n < 0 and libc.errno(n) == .INTR) continue;
+ if (n <= 0) break;
+ len += @intCast(n);
+ }
+ _ = libc.close(pipe[0]);
+ var status: c_int = 0;
+ while (libc.waitpid(pid, &status, 0) < 0 and libc.errno(-1) == .INTR) {}
+ const s: u32 = @bitCast(status);
+ const said = buf[0..len];
+ const first = said[0 .. std.mem.indexOfScalar(u8, said, '\n') orelse said.len];
+ if (!waited and libc.W.IFEXITED(s) and libc.W.EXITSTATUS(s) == 0 and std.mem.startsWith(u8, first, "pardes ")) return .{ .ok = first };
+ // The words go where the line was: the rest of `buf`.
+ var tail: [96]u8 = undefined;
+ const how = if (waited)
+ "did not answer --version in 10 s"
+ else if (libc.W.IFEXITED(s) and libc.W.EXITSTATUS(s) == 127)
+ "would not start"
+ else if (libc.W.IFEXITED(s) and libc.W.EXITSTATUS(s) != 0)
+ std.fmt.bufPrint(&tail, "exited {d} at --version", .{libc.W.EXITSTATUS(s)}) catch "failed at --version"
+ else if (libc.W.IFSIGNALED(s))
+ std.fmt.bufPrint(&tail, "died of signal {d} at --version", .{libc.W.TERMSIG(s)}) catch "died at --version"
+ else
+ "does not answer --version as a pardes does";
+ return .{ .no = std.fmt.bufPrint(buf, "Upgrade: {s} {s}; this session stays as it is", .{ path[0..@min(path.len, 400)], how }) catch "Upgrade: the new pardes would not start; this session stays as it is" };
+}
+
+/// The binary this process runs, open, for a new one to fall back to: on
+/// Linux the file even once deleted. ponytail: FreeBSD has no /proc by
+/// default, so a new build there that cannot load a dump starts afresh.
+pub fn openSelf() c_int {
+ if (comptime builtin.os.tag != .linux) return -1;
+ return libc.open("/proc/self/exe", .{ .ACCMODE = .RDONLY, .CLOEXEC = true }, @as(libc.mode_t, 0));
+}
+
+/// This process exec'd as `path` (or the binary open on `old`), the record
+/// on its command line and the fds it names kept open. Returns only when
+/// the exec failed, those fds close-on-exec again: why, in words.
+pub fn exec(gpa: std.mem.Allocator, path: ?[:0]const u8, old: c_int, rec: *const Record) []const u8 {
+ var text: std.Io.Writer.Allocating = .init(gpa);
+ defer text.deinit();
+ text.writer.writeAll(flag) catch return "no memory for its record";
+ rec.encode(&text.writer) catch return "no memory for its record";
+ text.writer.writeByte(0) catch return "no memory for its record";
+ const record: [*:0]const u8 = @ptrCast(text.written().ptr);
+ const argv = gpa.allocSentinel(?[*:0]const u8, given.len + 2, null) catch return "no memory for its arguments";
+ defer gpa.free(argv);
+ argv[0] = if (path) |p| p.ptr else if (exe()) |e| e.ptr else "pardes";
+ argv[1] = record;
+ for (given, argv[2..]) |a, *slot| slot.* = a.ptr;
+ rec.closeOnExec(false);
+ const envp: [*:null]const ?[*:0]const u8 = @ptrCast(libc.environ);
+ const r = if (path) |p|
+ libc.execve(p, argv.ptr, envp)
+ else if (comptime builtin.os.tag == .linux)
+ libc.execveat(old, "", argv.ptr, envp, .{ .SYMLINK_NOFOLLOW = false, .EMPTY_PATH = true })
+ else
+ -1;
+ const e = libc.errno(r);
+ rec.closeOnExec(true);
+ return switch (e) {
+ .NOENT => "it is not there",
+ .ACCES, .PERM => "it may not be run",
+ .NOEXEC => "it is not a program this system runs",
+ .@"2BIG" => "its record and arguments are too long",
+ .NOMEM => "no memory for it",
+ .TXTBSY => "it is still being written",
+ else => "the exec failed",
+ };
+}
+
+/// The dump of a session to `path` (0600, replaced): false when it could
+/// not be written whole.
+pub fn writeDump(path: [:0]const u8, bytes: []const u8) bool {
+ const fd = libc.open(path, .{ .ACCMODE = .WRONLY, .CREAT = true, .TRUNC = true, .CLOEXEC = true }, @as(libc.mode_t, 0o600));
+ if (fd < 0) return false;
+ defer _ = libc.close(fd);
+ var at: usize = 0;
+ while (at < bytes.len) {
+ const n = libc.write(fd, bytes[at..].ptr, bytes.len - at);
+ if (n < 0 and libc.errno(n) == .INTR) continue;
+ if (n <= 0) {
+ _ = libc.unlink(path);
+ return false;
+ }
+ at += @intCast(n);
+ }
+ return true;
+}
+
+// ---- after: the new process ----
+
+/// The core an upgraded process starts with: the session its dump is. A
+/// build that cannot load it execs the binary it replaced to load it; with
+/// none, a fresh session (`fresh`) the host adopts the shells into, the
+/// dump left where a Restore finds it. `PARDES_TEST_UPGRADE_REFUSE` refuses
+/// a load as such a build would (test/daemon.py's failing upgrade), in the
+/// first start only, or (`all`) in the start it falls back to as well.
+pub fn load(gpa: std.mem.Allocator, core_gpa: std.mem.Allocator, opts: pardes.Options, rec: *Record) !*pardes.Pardes {
+ var kept: [pardes.MAX_PANES]bool = @splat(false);
+ for (rec.ptys[0..rec.nptys]) |p| kept[p.pane] = true;
+ var path_buf: [4096:0]u8 = undefined;
+ const path = std.fmt.bufPrintSentinel(&path_buf, "{s}", .{rec.dump}, 0) catch "";
+ const loaded = loaded: {
+ if (libc.getenv("PARDES_TEST_UPGRADE_REFUSE")) |how| if (rec.refused.len == 0 or std.mem.eql(u8, std.mem.span(how), "all"))
+ break :loaded error.RefusedByTest;
+ const bytes = pardes.filesystem.readFile(gpa, rec.dump) catch |err| break :loaded err;
+ defer gpa.free(bytes);
+ break :loaded pardes.dump.resumeFromDump(core_gpa, opts, bytes, &kept);
+ };
+ var buf: [700]u8 = undefined;
+ if (loaded) |p| {
+ _ = libc.unlink(path);
+ p.setMessage(p.active, if (rec.refused.len > 0)
+ std.fmt.bufPrint(&buf, "Upgrade: the new build could not load this session ({s}); it goes on as {s}", .{ rec.refused[0..@min(rec.refused.len, 200)], version_line }) catch "Upgrade: the new build could not load this session; it goes on as before"
+ else
+ "Upgrade: now " ++ version_line);
+ return p;
+ } else |err| {
+ var words_buf: [128]u8 = undefined;
+ const why = if (err == error.RefusedByTest) "refused by PARDES_TEST_UPGRADE_REFUSE" else pardes.Messages.errorWords(err, &words_buf);
+ // The binary it replaced loads its own dump: tried once, never from
+ // a start that is that fallback already.
+ if (rec.old >= 0 and rec.refused.len == 0) {
+ var again = rec.*;
+ again.refused = why;
+ again.old = -1;
+ _ = exec(gpa, null, rec.old, &again);
+ }
+ if (rec.old >= 0) _ = libc.close(rec.old);
+ rec.old = -1;
+ rec.fresh = true;
+ var o = opts;
+ o.load_path = null;
+ const p = try pardes.Pardes.init(core_gpa, o);
+ p.setMessage(p.active, std.fmt.bufPrint(&buf, "Upgrade: no build could load the session ({s}); its shells are here, and Restore {s} brings the rest back", .{ why, rec.dump[0..@min(rec.dump.len, 400)] }) catch "Upgrade: no build could load the session; its dump is kept for a Restore");
+ return p;
+ }
+}
+
+test "an upgrade's record reads back as it was written, and refuses one cut short" {
+ var rec: Record = .{ .link = 5, .stub = 7, .old = 9, .window = true, .exe = "/a b/pardes", .dump = "/run/u/pardes-upgrade-1.dump" };
+ rec.addPty(3, 1234, 11);
+ rec.addPty(0, 99, 12);
+ var tio: posix.termios = std.mem.zeroes(posix.termios);
+ std.mem.asBytes(&tio)[0] = 0x5a;
+ rec.addTty(.{ .view = 2, .fd = 13, .stub = 14, .primary = true, .termios = tio });
+ var buf: [4096]u8 = undefined;
+ var w: std.Io.Writer = .fixed(&buf);
+ try rec.encode(&w);
+ const back = try Record.decode(w.buffered());
+ try std.testing.expectEqual(@as(c_int, 5), back.link);
+ try std.testing.expectEqual(@as(c_int, 9), back.old);
+ try std.testing.expect(back.window);
+ try std.testing.expectEqual(@as(usize, 2), back.nptys);
+ try std.testing.expectEqual(Pty{ .pane = 3, .pid = 1234, .fd = 11 }, back.ptys[0]);
+ try std.testing.expectEqual(@as(usize, 1), back.nttys);
+ try std.testing.expect(back.ttys[0].primary and back.ttys[0].view == 2 and back.ttys[0].stub == 14);
+ try std.testing.expectEqual(@as(u8, 0x5a), std.mem.asBytes(&back.ttys[0].termios)[0]);
+ try std.testing.expectEqualStrings("/a b/pardes", back.exe);
+ try std.testing.expectEqualStrings("/run/u/pardes-upgrade-1.dump", back.dump);
+ try std.testing.expectError(error.BadRecord, Record.decode("link 5\n"));
+ try std.testing.expectError(error.BadRecord, Record.decode("tty 0 1 2 1 abc\ndump x\n"));
+}