summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
authorGabriel Schneider <[email protected]>2026-10-30 12:04:45 -0300
committerGabriel Schneider <[email protected]>2026-10-30 12:24:57 -0300
commit11e67e636b39b9b2901ec5cc49a13a012088650f (patch)
tree06db91646b757af281c7322f84efb9ded91c6179
parentc6fa3545cc7b500c0b2b1a754ff7d46abf1d3768 (diff)
downloadpardes-11e67e636b39b9b2901ec5cc49a13a012088650f.tar.gz
pardes-11e67e636b39b9b2901ec5cc49a13a012088650f.zip
daemon: pardes --ps, --kill=<name>, --kill-all: the daemon's registry as a tree (the daemon, each session with its pid, kind, state and name and the shells it holds, then the shells no session holds, which Adopt takes) and sessions ended with their shells: a TERM, a KILL 2 s later, gone once the daemon no longer lists them (a zombie still answers kill 0), a killed session's held masters closed rather than kept for an Adopt and --kill-all's every kept one; in --help, the guide and the reference; --help's ssh default no longer -C; test/daemon.py --manage
Co-Authored-By: Claude Opus 5.5 <[email protected]>
-rw-r--r--docs/typ/guide.typ2
-rw-r--r--docs/typ/reference.typ8
-rw-r--r--src/daemon.zig61
-rw-r--r--src/main.zig113
-rw-r--r--test/daemon.py79
5 files changed, 259 insertions, 4 deletions
diff --git a/docs/typ/guide.typ b/docs/typ/guide.typ
index 4430276f..56fe3ebd 100644
--- a/docs/typ/guide.typ
+++ b/docs/typ/guide.typ
@@ -344,6 +344,8 @@ cheatsheet (#doc("cheatsheet")) say so.
pardes --detach=work & a session with no screen of its own
pardes --attach=work show it here
pardes-gui --attach=work a window session's window again
+pardes --ps every session the daemon keeps, and its shells
+pardes --kill=work end it and its shells (--kill-all: every one)
```
#word("Detach") (#key("SPC s D")) lets the terminal or the window go and
diff --git a/docs/typ/reference.typ b/docs/typ/reference.typ
index 2d8658c6..4de57d64 100644
--- a/docs/typ/reference.typ
+++ b/docs/typ/reference.typ
@@ -1012,7 +1012,13 @@ to its end before the write is answered, and one that finds nothing fails,
another; a removed line's `-` goes to the line now standing where it was.
git's `a/` `b/` (and `c/ i/ w/ o/`) prefixes are dropped; a
`--no-prefix` diff's paths are kept.
-- *Sessions.* Bare `--detach` names the session after its pid; bare
+- *Sessions.* `pardes --ps` prints what the daemon keeps: each session
+ (its pid, terminal or window, attached or detached, name) with the pids
+ and commands of the shells it holds, then the shells no session holds,
+ which #word("Adopt") takes. `--kill=NAME` ends that session and its
+ shells (a TERM, then a KILL 2 s later; unsaved changes are lost),
+ `--kill-all` every session and every kept shell; with no daemon running
+ each says so and exits 1. Bare `--detach` names the session after its pid; bare
`--attach` needs exactly one detached session of its kind (a terminal's
for `pardes`, a window's for `pardes-gui`), or with none detached the
only session of that kind; a second `--detach=NAME`
diff --git a/src/daemon.zig b/src/daemon.zig
index d2ae012c..c6cd7f85 100644
--- a/src/daemon.zig
+++ b/src/daemon.zig
@@ -489,6 +489,17 @@ pub fn attach(k: Kind, named: []const u8, fds: []const c_int, buf: []u8) Answer
return .{ .no = if (std.mem.startsWith(u8, got.words, "no ")) got.words[3..] else got.words };
}
+/// The daemon's answer to `words` (`list`, `kill <name>`, `killall`), in
+/// `buf`; null with no daemon running, or none answering.
+pub fn ask(words: []const u8, buf: []u8) ?[]const u8 {
+ const fd = connect(false) orelse return null;
+ defer _ = libc.close(fd);
+ if (!send(fd, words, &.{}) or !readable(fd, 2000)) return null;
+ const got = recv(fd, buf) orelse return null;
+ for (got.fds[0..got.nfds]) |f| _ = libc.close(f);
+ return got.words;
+}
+
// ---- a terminal's stub ----
var stub_child: libc.pid_t = 0;
@@ -665,6 +676,8 @@ const Conn = struct {
detached: bool = false,
/// Its build's wire.semantics: a replica's must be the same.
semantics: u64 = 0,
+ /// `pardes --kill` asked its end: its shells go with it, not kept.
+ killed: bool = false,
name: [128]u8 = undefined,
name_len: usize = 0,
@@ -709,12 +722,53 @@ const Daemon = struct {
fn hangUp(d: *Daemon, i: u8) void {
const c = &d.conns[i];
+ const killed = c.killed;
_ = libc.close(c.fd);
c.* = .{};
- // Whatever it still held, it died holding: kept for an Adopt.
+ // Whatever it still held, it died holding: kept for an Adopt, unless
+ // it was killed on purpose, when its shells hang up with it.
for (&d.held) |*h| if (h.fd >= 0 and h.owner == i) {
- h.owner = null;
+ if (killed) d.drop(h) else h.owner = null;
+ };
+ }
+
+ /// `pardes --kill`: each session named (every one, for null) sent a
+ /// TERM and marked, its pids answered; the shells of none kept, for
+ /// all of them.
+ fn kill(d: *Daemon, i: u8, named: ?[]const u8) void {
+ var line: [msg_max]u8 = undefined;
+ var w: std.Io.Writer = .fixed(&line);
+ w.writeAll("ok") catch {};
+ var n: usize = 0;
+ for (&d.conns) |*s| if (s.fd >= 0 and s.kind != null) {
+ if (named) |want| if (!std.mem.eql(u8, s.named(), want)) continue;
+ s.killed = true;
+ _ = libc.kill(s.pid, .TERM);
+ w.print(" {d}", .{s.pid}) catch {};
+ n += 1;
+ };
+ if (named == null) {
+ for (&d.held) |*h| if (h.fd >= 0 and h.owner == null) d.drop(h);
+ } else if (n == 0) {
+ var why: [256]u8 = undefined;
+ return d.reply(i, std.fmt.bufPrint(&why, "no no session called '{s}'", .{named.?}) catch "no no such session", &.{});
+ }
+ d.reply(i, w.buffered(), &.{});
+ }
+
+ /// `pardes --ps`: a line a session (pid, kind, state, name), a line
+ /// for each shell it holds after it, then the shells nobody holds.
+ /// ponytail: one message, so a registry past msg_max is cut short.
+ fn list(d: *Daemon, i: u8) void {
+ var line: [msg_max]u8 = undefined;
+ var w: std.Io.Writer = .fixed(&line);
+ w.print("daemon {d}\n", .{libc.getpid()}) catch {};
+ for (&d.conns, 0..) |*s, k| if (s.fd >= 0 and s.kind != null) {
+ w.print("session {d} {t} {s} {s}\n", .{ s.pid, s.kind.?, if (s.detached) "detached" else "attached", s.named() }) catch break;
+ for (d.held) |h| if (h.fd >= 0 and h.owner == @as(u8, @intCast(k))) w.print("shell {d}\n", .{h.pid}) catch break;
};
+ for (d.held) |h| if (h.fd >= 0 and h.owner == null) w.print("orphan {d}\n", .{h.pid}) catch break;
+ d.reply(i, w.buffered(), &.{});
}
fn reply(d: *Daemon, i: u8, words: []const u8, fds: []const c_int) void {
@@ -776,6 +830,9 @@ const Daemon = struct {
d.upgrade_asked = true;
return;
}
+ if (std.mem.eql(u8, verb, "list")) return d.list(i);
+ if (std.mem.eql(u8, verb, "kill")) return d.kill(i, std.mem.trim(u8, words.rest(), " "));
+ if (std.mem.eql(u8, verb, "killall")) return d.kill(i, null);
if (std.mem.eql(u8, verb, "adopt")) {
var line: [msg_max]u8 = undefined;
var w: std.Io.Writer = .fixed(&line);
diff --git a/src/main.zig b/src/main.zig
index fafafc08..d4edc74d 100644
--- a/src/main.zig
+++ b/src/main.zig
@@ -111,11 +111,17 @@ const help_text =
\\ --attach=<host>:<name> a client of session <name> on another machine,
\\ over `ssh -L` to its pardes-replica.sock
\\ ($PARDES_SSH: the ssh command, words, default
- \\ `ssh -C`; and
+ \\ `ssh`; and
\\ $PARDES_REMOTE_RUNTIME: its runtime directory,
\\ if not this one's path). Its keys show at once
\\ --attach=<sock>:<name> ...through that socket (a path, with a '/'),
\\ one forwarded already, or this machine's
+ \\ --ps what the pardes daemon keeps: each session (its
+ \\ pid, kind, whether attached) and its shells, then
+ \\ the shells no session holds
+ \\ --kill=<name> end session <name> and its shells (TERM, then
+ \\ KILL 2 s later); unsaved changes are lost
+ \\ --kill-all end every session and every shell the daemon keeps
\\ --geometry=WxH[+X+Y] the window's size in points, and where it goes
\\ where the display lets a window say (X11)
\\ -h, --help show this help and exit
@@ -507,6 +513,14 @@ fn nativeMain(std_init: std.process.Init) !void {
attach = "";
} else if (std.mem.startsWith(u8, a, "--attach=")) {
attach = a["--attach=".len..];
+ } else if (std.mem.eql(u8, a, "--ps")) {
+ manage(init.io, "list", "");
+ } else if (std.mem.startsWith(u8, a, "--kill=")) {
+ const name = a["--kill=".len..];
+ if (name.len == 0) badArgs(init.io, "--kill needs a session's name; --kill-all ends every one", .{});
+ manage(init.io, "kill", name);
+ } else if (std.mem.eql(u8, a, "--kill-all")) {
+ manage(init.io, "killall", "");
} else if (std.mem.eql(u8, a, "-h") or std.mem.eql(u8, a, "--help")) {
try std.Io.File.stdout().writeStreamingAll(init.io, help_text);
return;
@@ -870,6 +884,103 @@ fn nativeMain(std_init: std.process.Init) !void {
extern "c" fn execvp(file: [*:0]const u8, argv: [*:null]const ?[*:0]const u8) c_int;
+/// `pardes --ps`: what the per-user daemon keeps, as a tree; `--kill=<name>`
+/// and `--kill-all`: those sessions ended with their shells, a TERM and,
+/// for one still there 2 s later, a KILL.
+fn manage(io: std.Io, verb: []const u8, name: []const u8) noreturn {
+ const Say = struct {
+ fn no(o: std.Io, comptime fmt: []const u8, args: anytype) noreturn {
+ var buf: [700]u8 = undefined;
+ std.Io.File.stderr().writeStreamingAll(o, std.fmt.bufPrint(&buf, "pardes: " ++ fmt ++ "\n", args) catch "pardes: failed\n") catch {};
+ std.process.exit(1);
+ }
+ };
+ if (comptime !daemon.supported) Say.no(io, "this system has no pardes daemon", .{});
+ var words_buf: [300]u8 = undefined;
+ const words = if (std.mem.eql(u8, verb, "kill"))
+ std.fmt.bufPrint(&words_buf, "kill {s}", .{name}) catch Say.no(io, "that name is too long", .{})
+ else
+ verb;
+ var buf: [4096]u8 = undefined;
+ const said = daemon.ask(words, &buf) orelse Say.no(io, "no pardes daemon is running", .{});
+ if (std.mem.startsWith(u8, said, "no ")) Say.no(io, "{s}", .{said[3..]});
+ if (std.mem.eql(u8, verb, "list")) {
+ var out: [8192]u8 = undefined;
+ var w: std.Io.Writer = .fixed(&out);
+ var lines = std.mem.tokenizeScalar(u8, said, '\n');
+ var orphans = false;
+ while (lines.next()) |line| {
+ var it = std.mem.tokenizeScalar(u8, line, ' ');
+ const what = it.next() orelse continue;
+ const pid = it.next() orelse continue;
+ var comm_buf: [64]u8 = undefined;
+ const comm = commOf(pid, &comm_buf);
+ if (std.mem.eql(u8, what, "daemon")) {
+ w.print("pardes daemon {s}\n", .{pid}) catch break;
+ } else if (std.mem.eql(u8, what, "session")) {
+ const kind = it.next() orelse "";
+ const state = it.next() orelse "";
+ w.print(" session {s} {s} ({s}, {s})\n", .{ std.mem.trim(u8, it.rest(), " "), pid, kind, state }) catch break;
+ } else if (std.mem.eql(u8, what, "shell")) {
+ w.print(" shell {s} {s}\n", .{ pid, comm }) catch break;
+ } else if (std.mem.eql(u8, what, "orphan")) {
+ if (!orphans) w.writeAll(" shells no session holds (Adopt takes them, --kill-all ends them)\n") catch break;
+ orphans = true;
+ w.print(" shell {s} {s}\n", .{ pid, comm }) catch break;
+ }
+ }
+ std.Io.File.stdout().writeStreamingAll(io, w.buffered()) catch {};
+ std.process.exit(0);
+ }
+ var pids: [64]std.c.pid_t = undefined;
+ var n: usize = 0;
+ var it = std.mem.tokenizeScalar(u8, said, ' ');
+ _ = it.next(); // ok
+ while (it.next()) |p| if (n < pids.len) {
+ pids[n] = std.fmt.parseInt(std.c.pid_t, p, 10) catch continue;
+ n += 1;
+ };
+ // Gone once the daemon no longer lists them: a session's link ends with
+ // its process, a zombie's too, which kill(pid, 0) would call alive.
+ const Gone = struct {
+ fn all(list: []const std.c.pid_t, ms: u32) bool {
+ var waited: u32 = 0;
+ while (true) : (waited += 20) {
+ var reply: [4096]u8 = undefined;
+ const now = daemon.ask("list", &reply) orelse return true;
+ var lines = std.mem.tokenizeScalar(u8, now, '\n');
+ const left = while (lines.next()) |line| {
+ var fields = std.mem.tokenizeScalar(u8, line, ' ');
+ if (!std.mem.eql(u8, fields.next() orelse "", "session")) continue;
+ const pid = std.fmt.parseInt(std.c.pid_t, fields.next() orelse "", 10) catch continue;
+ if (std.mem.indexOfScalar(std.c.pid_t, list, pid) != null) break true;
+ } else false;
+ if (!left) return true;
+ if (waited >= ms) return false;
+ const ts: std.c.timespec = .{ .sec = 0, .nsec = 20 * std.time.ns_per_ms };
+ _ = std.c.nanosleep(&ts, null);
+ }
+ }
+ };
+ if (!Gone.all(pids[0..n], 2000)) {
+ for (pids[0..n]) |p| _ = std.c.kill(p, .KILL);
+ if (!Gone.all(pids[0..n], 1000)) Say.no(io, "a session would not end, even killed", .{});
+ }
+ std.process.exit(0);
+}
+
+/// The command `pid` runs, as /proc says it (Linux); empty where it does not.
+fn commOf(pid: []const u8, buf: *[64]u8) []const u8 {
+ var path_buf: [64]u8 = undefined;
+ const path = std.fmt.bufPrintSentinel(&path_buf, "/proc/{s}/comm", .{pid}, 0) catch return "";
+ const fd = std.c.open(path, .{ .ACCMODE = .RDONLY, .CLOEXEC = true }, @as(std.c.mode_t, 0));
+ if (fd < 0) return "";
+ defer _ = std.c.close(fd);
+ const got = std.c.read(fd, buf, buf.len);
+ if (got <= 0) return "";
+ return std.mem.trimEnd(u8, buf[0..@intCast(got)], "\n");
+}
+
/// `pardes --attach=<where>:<name>`: a replica client (tty.zig `remote`),
/// through the socket `where` names, or through `ssh -L` of host `where`'s
/// replica socket to one of this process's.
diff --git a/test/daemon.py b/test/daemon.py
index fb4f3013..d9ca7153 100644
--- a/test/daemon.py
+++ b/test/daemon.py
@@ -452,6 +452,82 @@ def clients(binary):
shutil.rmtree(root, ignore_errors=True)
+def manage(binary):
+ """`pardes --ps`, `--kill=NAME` and `--kill-all`: two detached sessions
+ and their shells listed, one session killed outright and its shell
+ listed as no one's, the other ended by name with its shell, a name no
+ session has refused, the kept shell ended by --kill-all, and the daemon
+ gone after it."""
+ scratch = Path(__file__).resolve().parent.parent.parent / '.scratch' / 'daemon' / 'dmn'
+ scratch.mkdir(parents=True, exist_ok=True)
+ root = Path(tempfile.mkdtemp(prefix='rm-', dir=scratch))
+ env = {k: v for k, v in os.environ.items() if not k.startswith('PARDES_') and 'PAGER' not in k}
+ env.update(HOME=str(root), XDG_RUNTIME_DIR=str(root), XDG_CONFIG_HOME=str(root / 'config'),
+ TERM='xterm-256color', SHELL=shutil.which('bash') or '/bin/bash', PARDES_NOTIME='1')
+ (root / 'config' / 'pardes').mkdir(parents=True)
+ (root / 'config' / 'pardes' / 'init').write_text('Shell bash\nMessageLinger 0\n')
+
+ def cli(*args):
+ return subprocess.run([binary, *args], env=env, cwd=root, capture_output=True, timeout=30)
+
+ started = []
+ try:
+ sessions, shells = {}, {}
+ for name in ('one', 'two'):
+ (root / f'{name}.txt').write_text(f'{name}\n')
+ started.append(subprocess.Popen([binary, f'--detach={name}', str(root / f'{name}.txt')], env=env, cwd=root,
+ stdin=subprocess.DEVNULL, stdout=subprocess.DEVNULL,
+ stderr=subprocess.DEVNULL, start_new_session=True).pid)
+ sock = root / f'pardes-9p-{name}.sock'
+ wait_for(f'session {name}\'s 9P socket', sock.exists)
+ with Client(sock) as c:
+ status = dict(line.split(maxsplit=1) for line in c.read('/status').decode().splitlines())
+ sessions[name] = int(status['pid'])
+ started.append(sessions[name])
+ c.write('/pane/1/exec', b'Tty\n')
+ wait_for(f'session {name}\'s shell', lambda: terminals(c))
+ shell = terminals(c)[0]
+ wait_for(f'session {name}\'s shell answers', lambda: run(c, shell, b'true\n') == b'exit 0\n')
+ shells[name] = int(run(c, shell, b'echo $$\n').split(b'\n')[1])
+ started.append(shells[name])
+ daemon = [p for p in processes(root) if cmdline(p)[1:2] == [b'--daemon']][0]
+ started.append(daemon)
+ out = cli('--ps')
+ assert out.returncode == 0, out
+ listed = out.stdout.decode()
+ assert f'pardes daemon {daemon}' in listed, listed
+ for name in ('one', 'two'):
+ assert f'session {name} {sessions[name]} (tty, detached)' in listed, listed
+ assert f'shell {shells[name]}' in listed, listed
+ os.kill(sessions['two'], signal.SIGKILL)
+ wait_for('session two gone', lambda: not alive(sessions['two']))
+ wait_for('its shell no session\'s', lambda: 'no session holds' in cli('--ps').stdout.decode())
+ listed = cli('--ps').stdout.decode()
+ assert 'session two' not in listed and listed.index(f'shell {shells["two"]}') > listed.index('no session holds'), listed
+ assert alive(shells['two'])
+ print('manage: --ps listed two sessions and their shells, then a killed one\'s shell as no one\'s')
+ refused = cli('--kill=nobody')
+ assert refused.returncode == 1 and b"no session called 'nobody'" in refused.stderr, refused
+ killed = cli('--kill=one')
+ assert killed.returncode == 0, killed
+ assert not alive(sessions['one'])
+ wait_for('session one\'s shell hung up with it', lambda: not alive(shells['one']))
+ assert alive(shells['two']) and 'session one' not in cli('--ps').stdout.decode()
+ assert cli('--kill-all').returncode == 0
+ wait_for('the kept shell ended', lambda: not alive(shells['two']))
+ wait_for('the daemon gone once it keeps nothing', lambda: not alive(daemon))
+ none = cli('--ps')
+ assert none.returncode == 1 and b'no pardes daemon is running' in none.stderr, none
+ print('manage: --kill=one ended it and its shell, --kill-all the kept shell, a name nobody has refused; the daemon left')
+ finally:
+ for pid in started + processes(root):
+ try:
+ os.kill(pid, signal.SIGKILL)
+ except (ProcessLookupError, PermissionError):
+ pass
+ shutil.rmtree(root, ignore_errors=True)
+
+
def joins(path):
"""A replica client's joins (PARDES_REPLICA_STATS, a line a link): how
many blobs each listed, how many it held already from the core it left
@@ -660,6 +736,7 @@ def main(binary, cycles):
replicas(root, binary, session, daemon)
clients(binary)
far(binary)
+ manage(binary)
shell = terminals(client)[0]
shell_pid = int(run(client, shell, b'echo $$\n').split(b'\n')[1])
started.append(shell_pid)
@@ -1260,6 +1337,8 @@ if __name__ == '__main__':
upgrades(Path(sys.argv[2]).resolve(), Path(sys.argv[3]).resolve())
elif sys.argv[1:2] == ['--clients']:
clients(sys.argv[2])
+ elif sys.argv[1:2] == ['--manage']:
+ manage(sys.argv[2])
elif sys.argv[1:2] == ['--far']:
far(sys.argv[2])
elif sys.argv[1:2] == ['--ping']: