Files
orca/native/provider-exec/provider-exec.c
Brennan Benson 980352d897 Reduce native chat memory by replacing per-chat Electron supervisors (#42760)
* Launch provider CLIs without a per-chat runtime supervisor

* Initialize process-owner fixtures with an isolated app environment

* Retire provider output transports and failed ownership drafts

* Finish provider stops when the session group empties

* Complete native cleanup from verified watcher exit and cancel held launches

* Let native watcher finish one-shot provider exits

* Retire late ownership records after canceled provider launches settle

* Reap each provider subtree in an isolated native parent

* Preserve provider outcomes and compatibility with native parents

* Publish actual provider identities and retire native parent observers

* Retire numeric writer PIDs when their group is proven absent

* Retire provider transports and accept proven group absence

* Fence retired process identities across asynchronous cleanup

* Use native timer types and readonly process fixtures

* Reuse bounded timeout for compatibility output drain

* Release launch scopes held by late transport error handlers

* Keep processless launch failures out of watcher waits

* Align lifecycle validation with final ownership contracts

* Remove duplicate helper preparation from the dev launcher

* Keep legacy fallback in place and simplify native ownership handoff

* Defer background provider maintenance until the first window

* Release startup hook maintenance for terminal launches

* Use relocated artifact module in native prebuild scripts

* Preserve agent failure outcomes and clean tools before ownership is lost

* Budget ownership capture for its bounded identity reads

* Keep lifecycle regressions at their behavior-owning seam

* Explain the fake-clock process-read fixture

* Capture tool ownership before restart recovery removes the CLI

* Skip descendant inventories for absent provider roots

* Make final output drain regression test deterministic

* Keep output drain fixture assertions type-safe with IPC

* Use existing provider fixtures across Node and Bun

* Prepare native provider helper for Codex contract CI

* Verify provider ownership using its recorded start precision

* Preserve exact provider ownership through reader failures

* Retire exhausted recovery records without blocking watcher cleanup

* Distinguish exited descendants from unreaped zombies

* Preserve group retirement without trusting an exited root

* Keep CLI input owned through native parent loss

* Keep watcher cleanup proof through lost-parent retirement

* Guard retirement against late watcher cleanup proof

* Contain provider launches that fail before stdio setup

* fix(claude): preserve startup diagnostics after input pipe failures

* fix(provider): capture lost outcomes before native completion cleanup

* fix(provider): retire speculative captures after a valid outcome

* fix(provider): share spawn absence classification through its existing boundary
2026-11-16 01:01:24 -08:00

712 lines
24 KiB
C

// Gated exec for POSIX provider CLIs. This pid is a small parent that forks the leader, reports the
// leader's wait status on fd 6 and reaps it; on Linux it is a subreaper that reaps the watcher and
// adopted descendants until leader and watcher are gone, then exits and leaves live descendants to
// the next reaper. The leader starts its own session, forks the same-session owner-pipe
// watcher, reports both on fd 5, waits for the owner's GO on fd 4, then execs the CLI with its argv,
// environment, signal mask and dispositions unchanged.
// Usage: orca-provider-exec --cli-input-fd7 <stdinEndGraceMs> <sigtermGraceMs> <session|one-shot>
// <stdin-end|stdin-end-and-sigterm> -- <command> [args...]
// The fixed --cli-input-fd7 prefix identifies the private input protocol.
#if !defined(__APPLE__)
#define _POSIX_C_SOURCE 200809L
#endif
#include <errno.h>
#include <fcntl.h>
#include <poll.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <time.h>
#include <unistd.h>
#if defined(__linux__)
#include <sys/prctl.h>
#endif
#if defined(__APPLE__)
#include <limits.h>
#include <sys/sysctl.h>
#endif
enum { OWNER_FD = 3, GATE_FD = 4, STATUS_FD = 5, OUTCOME_FD = 6, INPUT_FD = 7 };
enum {
EXIT_USAGE = 64,
EXIT_GATE_CLOSED = 69,
EXIT_NO_SUBREAPER = 70,
EXIT_BOOTSTRAP = 71,
EXIT_OUTCOME_LOST = 74,
EXIT_EXEC_FAILED = 127,
};
enum { STDIN_END_GRACE_MAX_MS = 1000, SIGTERM_GRACE_MAX_MS = 3000 };
static const int STOP_SIGNALS[] = {SIGTERM, SIGINT, SIGHUP};
enum { STOP_SIGNAL_COUNT = sizeof STOP_SIGNALS / sizeof STOP_SIGNALS[0] };
static volatile sig_atomic_t stop_signal = 0;
static struct sigaction saved_stop_actions[STOP_SIGNAL_COUNT];
static struct sigaction saved_pipe_action;
static struct sigaction saved_child_action;
static sigset_t saved_mask;
static sigset_t stop_set;
static pid_t watcher_pid = -1;
#if defined(__linux__)
// The parent's read end; only the leader before exec and the watcher hold the write end.
static int watcher_gone_fd = -1;
#endif
static void on_stop_signal(int signal_number) { stop_signal = signal_number; }
static int write_all(int fd, const char *data, size_t length) {
while (length > 0) {
ssize_t written = write(fd, data, length);
if (written < 0) {
if (errno == EINTR) {
continue;
}
return -1;
}
data += written;
length -= (size_t)written;
}
return 0;
}
#if defined(__APPLE__)
// Independent of the app's addon worker pool; preserves the same exact kernel birth marker.
static int print_process_row(const char *text) {
if (text[0] < '1' || text[0] > '9') {
return EXIT_USAGE;
}
char *end;
errno = 0;
long value = strtol(text, &end, 10);
if (errno != 0 || *end != '\0' || value > INT_MAX) {
return EXIT_USAGE;
}
pid_t pid = (pid_t)value;
int mib[] = {CTL_KERN, KERN_PROC, KERN_PROC_PID, pid};
struct kinfo_proc row;
size_t size = sizeof row;
if (sysctl(mib, 4, &row, &size, NULL, 0) != 0) {
return EXIT_BOOTSTRAP;
}
if (size == 0) {
return write_all(1, "absent\n", 7) == 0 ? 0 : EXIT_BOOTSTRAP;
}
if (size != sizeof row || row.kp_proc.p_pid != pid) {
return EXIT_BOOTSTRAP;
}
char frame[128];
int length = snprintf(frame, sizeof frame, "%ld %ld %ld %lld %lld\n", (long)pid,
(long)row.kp_eproc.e_ppid, (long)row.kp_eproc.e_pgid,
(long long)row.kp_proc.p_starttime.tv_sec,
(long long)row.kp_proc.p_starttime.tv_usec);
return length > 0 && (size_t)length < sizeof frame &&
write_all(1, frame, (size_t)length) == 0
? 0
: EXIT_BOOTSTRAP;
}
#endif
// Strict decimal: no sign, whitespace or leading zero, and never above `max`.
static int parse_ms(const char *text, unsigned max, unsigned *out) {
unsigned value = 0;
if (text[0] == '\0' || (text[0] == '0' && text[1] != '\0')) {
return -1;
}
for (const char *c = text; *c != '\0'; c++) {
if (*c < '0' || *c > '9') {
return -1;
}
value = value * 10 + (unsigned)(*c - '0');
if (value > max) {
return -1;
}
}
*out = value;
return 0;
}
static int set_cloexec(int fd, int enabled) {
int flags = fcntl(fd, F_GETFD);
if (flags < 0) {
return -1;
}
flags = enabled ? flags | FD_CLOEXEC : flags & ~FD_CLOEXEC;
return fcntl(fd, F_SETFD, flags);
}
static void reap_watcher(void) {
if (watcher_pid <= 0) {
return;
}
kill(watcher_pid, SIGKILL);
while (waitpid(watcher_pid, NULL, 0) < 0 && errno == EINTR) {
}
watcher_pid = -1;
}
// Never leaves a watcher behind; a stop signal that arrived during bootstrap still ends this pid.
static _Noreturn void fail(int code) {
reap_watcher();
int signal_number = stop_signal;
if (signal_number != 0) {
sigset_t raised;
sigemptyset(&raised);
sigaddset(&raised, signal_number);
signal(signal_number, SIG_DFL);
sigprocmask(SIG_UNBLOCK, &raised, NULL);
raise(signal_number);
}
_exit(code);
}
// The watcher reserves the CLI session ID from its own group and holds the owner pipe (fd 3).
// Commands there are stdin-end, term and reap; EOF there is owner death. One phase and absolute
// deadline own the stop, so owner EOF resumes it and a repeated term never restarts or shortens it.
enum watcher_phase { WATCH_IDLE, WATCH_STDIN_GRACE, WATCH_TERM_GRACE, WATCH_REAP };
enum { WATCH_LINE_MAX = 32, WATCH_READ_MAX = 256, WATCH_POLL_MS = 25, WATCH_REAP_MS = 1500 };
struct watcher {
pid_t group;
unsigned stdin_end_grace_ms;
unsigned sigterm_grace_ms;
int session;
int close_stdin_end;
enum watcher_phase phase;
long long deadline_ns;
char line[WATCH_LINE_MAX];
size_t line_length;
int discarding;
};
static _Noreturn void watcher_complete(int absent) {
const char *completion = absent ? "group-absent\n" : "group-unverifiable\n";
write_all(OWNER_FD, completion, strlen(completion));
_exit(absent ? 0 : EXIT_BOOTSTRAP);
}
static int group_absent(struct watcher *w) {
return kill(-w->group, 0) < 0 && errno == ESRCH;
}
static long long monotonic_ns(struct watcher *w) {
struct timespec now;
if (clock_gettime(CLOCK_MONOTONIC, &now) != 0) {
kill(-w->group, SIGKILL);
watcher_complete(0);
}
return (long long)now.tv_sec * 1000000000LL + now.tv_nsec;
}
static void kill_group(struct watcher *w) {
if (w->phase == WATCH_REAP) {
return;
}
if (kill(-w->group, SIGKILL) < 0 && errno == ESRCH) {
watcher_complete(1);
}
w->phase = WATCH_REAP;
w->deadline_ns = monotonic_ns(w) + (long long)WATCH_REAP_MS * 1000000LL;
}
// TERM grace starts once TERM is issued, so a late wakeup never spends it beforehand.
static void watcher_term(struct watcher *w) {
if (kill(-w->group, SIGTERM) < 0 && errno == ESRCH) {
watcher_complete(1);
}
if (w->sigterm_grace_ms == 0) {
kill_group(w);
return;
}
w->phase = WATCH_TERM_GRACE;
w->deadline_ns = monotonic_ns(w) + (long long)w->sigterm_grace_ms * 1000000LL;
}
static void watcher_stdin_grace(struct watcher *w) {
if (w->stdin_end_grace_ms == 0) {
watcher_term(w);
return;
}
w->phase = WATCH_STDIN_GRACE;
w->deadline_ns = monotonic_ns(w) + (long long)w->stdin_end_grace_ms * 1000000LL;
}
static void watcher_command(struct watcher *w) {
size_t n = w->line_length;
if (n == 9 && memcmp(w->line, "stdin-end", 9) == 0) {
if (w->session && w->phase == WATCH_IDLE) {
watcher_stdin_grace(w);
}
} else if (n == 4 && memcmp(w->line, "term", 4) == 0) {
if (w->phase != WATCH_TERM_GRACE && w->phase != WATCH_REAP) {
watcher_term(w);
}
} else if (n == 4 && memcmp(w->line, "reap", 4) == 0) {
kill_group(w);
} else if (n == 11 && memcmp(w->line, "leader-exit", 11) == 0) {
if (!w->session || w->phase != WATCH_TERM_GRACE) {
kill_group(w);
}
}
}
// Complete lines only; an overlong or unknown line is dropped through its newline.
static void watcher_input(struct watcher *w, const char *data, size_t length) {
for (size_t i = 0; i < length; i++) {
char c = data[i];
if (c == '\n') {
if (!w->discarding) {
watcher_command(w);
}
w->line_length = 0;
w->discarding = 0;
} else if (w->line_length < sizeof w->line) {
w->line[w->line_length++] = c;
} else {
w->discarding = 1;
}
}
}
static void watcher_owner_eof(struct watcher *w) {
if (w->phase != WATCH_IDLE) {
return;
}
if (w->session && w->close_stdin_end) {
watcher_stdin_grace(w);
} else {
watcher_term(w);
}
}
// Idle blocks indefinitely; stopping probes only the reserved CLI group, without a table scan.
static _Noreturn void watch_owner(struct watcher *w) {
int owner_open = 1;
struct pollfd owner = {.fd = OWNER_FD, .events = POLLIN};
for (;;) {
int timeout = -1;
if (w->phase != WATCH_IDLE) {
if (group_absent(w)) {
watcher_complete(1);
}
long long remaining = w->deadline_ns - monotonic_ns(w);
if (remaining <= 0) {
if (w->phase == WATCH_STDIN_GRACE) {
watcher_term(w);
continue;
}
if (w->phase == WATCH_REAP) {
watcher_complete(0);
}
kill_group(w);
continue;
}
timeout = (int)((remaining + 999999LL) / 1000000LL);
if (timeout > WATCH_POLL_MS) {
timeout = WATCH_POLL_MS;
}
}
int ready;
ready = poll(owner_open ? &owner : NULL, owner_open ? 1 : 0, timeout);
if (ready < 0) {
if (errno == EINTR) {
continue;
}
owner_open = 0;
kill_group(w);
continue;
}
if (ready == 0 || !owner_open) {
continue;
}
// One bounded read per wake, so steady input cannot hold off a deadline.
char data[WATCH_READ_MAX];
ssize_t got = read(OWNER_FD, data, sizeof data);
if (got > 0) {
watcher_input(w, data, (size_t)got);
} else if (got == 0 || (errno != EINTR && errno != EAGAIN && errno != EWOULDBLOCK)) {
// A failed read also means the owner is unreachable; its pipe leaves the poll set.
// Retain the write side for completion when the owner only half-closed its pipe.
owner_open = 0;
watcher_owner_eof(w);
}
}
}
// Stop signals stay blocked from fork until the ignores are in place.
static _Noreturn void run_watcher(int report_fd, struct watcher *w) {
static const int IGNORED_SIGNALS[] = {SIGTERM, SIGINT, SIGHUP, SIGUSR1, SIGPIPE};
struct sigaction ignore;
memset(&ignore, 0, sizeof ignore);
ignore.sa_handler = SIG_IGN;
sigemptyset(&ignore.sa_mask);
if (setpgid(0, 0) != 0) {
goto failed;
}
if (getpgrp() != getpid() || getsid(0) != w->group) {
errno = EPERM;
goto failed;
}
// Survives the group SIGTERM it sends.
for (size_t i = 0; i < sizeof IGNORED_SIGNALS / sizeof IGNORED_SIGNALS[0]; i++) {
if (sigaction(IGNORED_SIGNALS[i], &ignore, NULL) != 0) {
goto failed;
}
}
sigset_t none;
sigemptyset(&none);
if (sigprocmask(SIG_SETMASK, &none, NULL) != 0) {
goto failed;
}
int null_fd = open("/dev/null", O_RDWR);
if (null_fd < 0 || dup2(null_fd, 0) < 0 || dup2(null_fd, 1) < 0 || dup2(null_fd, 2) < 0) {
goto failed;
}
close(null_fd);
close(GATE_FD);
close(STATUS_FD);
close(INPUT_FD);
struct timespec probe;
if (chdir("/") != 0 || clock_gettime(CLOCK_MONOTONIC, &probe) != 0) {
goto failed;
}
int ready = 0;
if (write_all(report_fd, (const char *)&ready, sizeof ready) != 0) {
_exit(EXIT_BOOTSTRAP);
}
close(report_fd);
watch_owner(w);
failed:;
int error = errno != 0 ? errno : EIO;
write_all(report_fd, (const char *)&error, sizeof error);
_exit(EXIT_BOOTSTRAP);
}
// Returns only once the watcher acknowledged it is ready, so its pid is safe to publish. EOF
// without that acknowledgement is a failed start.
static int start_watcher(struct watcher *w) {
int report[2];
if (pipe(report) != 0) {
return -1;
}
if (set_cloexec(report[0], 1) != 0 || set_cloexec(report[1], 1) != 0) {
close(report[0]);
close(report[1]);
return -1;
}
pid_t pid = fork();
if (pid == 0) {
close(report[0]);
run_watcher(report[1], w);
}
close(report[1]);
if (pid < 0) {
close(report[0]);
return -1;
}
watcher_pid = pid;
int answer = -1;
size_t have = 0;
while (have < sizeof answer) {
struct pollfd startup[] = {
{.fd = report[0], .events = POLLIN}, {.fd = GATE_FD, .events = POLLIN}};
int ready = poll(startup, 2, -1);
if (ready < 0 && errno == EINTR) {
continue;
}
// Gate cancellation must still reap a watcher stopped before its readiness reply.
if (ready < 0 || startup[1].revents != 0) {
break;
}
ssize_t got = read(report[0], (char *)&answer + have, sizeof answer - have);
if (got < 0 && errno == EINTR) {
continue;
}
if (got <= 0) {
break;
}
have += (size_t)got;
}
close(report[0]);
if (have != sizeof answer || answer != 0 || waitpid(pid, NULL, WNOHANG) != 0) {
reap_watcher();
return -1;
}
return 0;
}
static int await_gate(void) {
static const char expected[] = "g\n";
for (size_t i = 0; i < sizeof expected - 1;) {
char byte;
ssize_t got = read(GATE_FD, &byte, 1);
if (got < 0 && errno == EINTR) {
if (stop_signal != 0) {
return -1;
}
continue;
}
if (got != 1 || byte != expected[i]) {
return -1;
}
i++;
}
return 0;
}
static int install_stop_handlers(void) {
struct sigaction handler;
memset(&handler, 0, sizeof handler);
handler.sa_handler = on_stop_signal;
sigemptyset(&handler.sa_mask);
for (int i = 0; i < STOP_SIGNAL_COUNT; i++) {
if (sigaction(STOP_SIGNALS[i], NULL, &saved_stop_actions[i]) != 0) {
return -1;
}
// An inherited ignore stays an ignore, as it would for the CLI itself.
if (saved_stop_actions[i].sa_handler == SIG_DFL &&
sigaction(STOP_SIGNALS[i], &handler, NULL) != 0) {
return -1;
}
}
struct sigaction ignore;
memset(&ignore, 0, sizeof ignore);
ignore.sa_handler = SIG_IGN;
sigemptyset(&ignore.sa_mask);
// A closed status reader must surface as EPIPE, not kill this pid with its watcher alive.
return sigaction(SIGPIPE, &ignore, &saved_pipe_action);
}
static void restore_signal_actions(void) {
for (int i = 0; i < STOP_SIGNAL_COUNT; i++) {
sigaction(STOP_SIGNALS[i], &saved_stop_actions[i], NULL);
}
sigaction(SIGPIPE, &saved_pipe_action, NULL);
}
// The leader: runs today's bootstrap in a session of its own, then becomes the CLI.
static _Noreturn void run_leader(struct watcher *watcher, char *command[]) {
// Only the parent may hold the outcome pipe, so its EOF means the parent is gone.
close(OUTCOME_FD);
#if defined(__linux__)
close(watcher_gone_fd);
#endif
if (setsid() < 0 || sigaction(SIGCHLD, &saved_child_action, NULL) != 0 ||
install_stop_handlers() != 0 || set_cloexec(OWNER_FD, 1) != 0 ||
set_cloexec(GATE_FD, 1) != 0 || set_cloexec(STATUS_FD, 1) != 0) {
fail(EXIT_BOOTSTRAP);
}
watcher->group = getpid();
// Stop signals stay blocked from the parent's fork, so the watcher installs its ignores first.
int started = start_watcher(watcher);
sigprocmask(SIG_SETMASK, &saved_mask, NULL);
if (started != 0 || stop_signal != 0) {
fail(EXIT_BOOTSTRAP);
}
// Only the watcher holds the owner pipe, so its EOF on either side means the other died.
close(OWNER_FD);
char status[128];
int length = snprintf(status, sizeof status, "{\"leaderPid\":%ld,\"watcherPid\":%ld}\n",
(long)watcher->group, (long)watcher_pid);
if (length <= 0 || (size_t)length >= sizeof status ||
write_all(STATUS_FD, status, (size_t)length) != 0) {
fail(EXIT_BOOTSTRAP);
}
if (await_gate() != 0) {
fail(EXIT_GATE_CLOSED);
}
close(GATE_FD);
// The GUI owns this channel independently of the parent's ChildProcess stdin.
if (dup2(INPUT_FD, STDIN_FILENO) < 0) {
fail(EXIT_BOOTSTRAP);
}
close(INPUT_FD);
sigprocmask(SIG_BLOCK, &stop_set, NULL);
restore_signal_actions();
sigset_t pending;
sigpending(&pending);
for (int i = 0; i < STOP_SIGNAL_COUNT; i++) {
if (stop_signal == 0 && sigismember(&pending, STOP_SIGNALS[i]) == 1) {
stop_signal = STOP_SIGNALS[i];
}
}
// A stop during the gate, or a watcher that died before release, cancels the launch.
if (stop_signal != 0 || waitpid(watcher_pid, NULL, WNOHANG) != 0) {
fail(EXIT_GATE_CLOSED);
}
sigprocmask(SIG_SETMASK, &saved_mask, NULL);
execvp(command[0], command);
int error = errno;
signal(SIGPIPE, SIG_IGN);
length = snprintf(status, sizeof status, "{\"errno\":%d}\n", error);
if (length > 0 && (size_t)length < sizeof status) {
write_all(STATUS_FD, status, (size_t)length);
}
reap_watcher();
_exit(EXIT_EXEC_FAILED);
}
// One frame for the leader's actual wait status, then EOF.
static int publish_outcome(int status) {
char frame[48];
int length = WIFSIGNALED(status)
? snprintf(frame, sizeof frame, "{\"code\":null,\"signal\":%d}\n",
WTERMSIG(status))
: snprintf(frame, sizeof frame, "{\"code\":%d,\"signal\":null}\n",
WEXITSTATUS(status));
int written = length > 0 && (size_t)length < sizeof frame &&
write_all(OUTCOME_FD, frame, (size_t)length) == 0;
close(OUTCOME_FD);
return written ? 0 : -1;
}
#if defined(__linux__)
// Hangup means the watcher exited; on a failed probe it falls to the next reaper instead.
static int watcher_exited(void) {
struct pollfd watcher = {.fd = watcher_gone_fd, .events = POLLIN};
return poll(&watcher, 1, 0) != 0;
}
#endif
// Holds nothing the owner reads EOF from: stdio and fds 3-5 now belong to the leader and watcher.
// Survives stop signals, which the watcher turns into the group stop, and blocks in wait only.
static _Noreturn void await_leader(pid_t leader) {
static const int IGNORED_SIGNALS[] = {SIGTERM, SIGINT, SIGHUP, SIGPIPE};
struct sigaction ignore;
memset(&ignore, 0, sizeof ignore);
ignore.sa_handler = SIG_IGN;
sigemptyset(&ignore.sa_mask);
for (size_t i = 0; i < sizeof IGNORED_SIGNALS / sizeof IGNORED_SIGNALS[0]; i++) {
sigaction(IGNORED_SIGNALS[i], &ignore, NULL);
}
sigprocmask(SIG_SETMASK, &saved_mask, NULL);
close(INPUT_FD);
int null_fd = open("/dev/null", O_RDWR | O_CLOEXEC);
for (int fd = 0; fd <= STATUS_FD; fd++) {
if (fd > 2 || null_fd < 0 || dup2(null_fd, fd) < 0) {
close(fd);
}
}
if (null_fd > STATUS_FD) {
close(null_fd);
}
if (chdir("/") != 0) {
// Keep reaping even if the current directory cannot be released.
}
// Stays 1 until the leader is reaped.
int outcome = 1;
for (;;) {
int status;
pid_t pid = waitpid(-1, &status, 0);
if (pid < 0) {
if (errno == EINTR) {
continue;
}
break;
}
if (pid == leader) {
outcome = publish_outcome(status);
#if !defined(__linux__)
// Only the leader is this pid's child here; init reaps the watcher.
break;
#endif
}
#if defined(__linux__)
// A watcher outliving the leader is adopted here, so its exit is a later wake of this wait.
if (outcome != 1 && watcher_exited()) {
while (waitpid(-1, NULL, WNOHANG) > 0) {
}
break;
}
#endif
}
_exit(outcome == 0 ? 0 : outcome < 0 ? EXIT_OUTCOME_LOST : EXIT_BOOTSTRAP);
}
int main(int argc, char *argv[]) {
#if defined(__APPLE__)
if (argc == 3 && strcmp(argv[1], "--process-row") == 0) {
return print_process_row(argv[2]);
}
#endif
unsigned stdin_end_grace_ms;
unsigned sigterm_grace_ms;
// A fixed protocol discriminator rejects mismatched helpers before a CLI can execute.
if (argc < 8 || strcmp(argv[1], "--cli-input-fd7") != 0 ||
parse_ms(argv[2], STDIN_END_GRACE_MAX_MS, &stdin_end_grace_ms) != 0 ||
parse_ms(argv[3], SIGTERM_GRACE_MAX_MS, &sigterm_grace_ms) != 0 ||
(strcmp(argv[4], "session") != 0 && strcmp(argv[4], "one-shot") != 0) ||
(strcmp(argv[5], "stdin-end") != 0 && strcmp(argv[5], "stdin-end-and-sigterm") != 0) ||
strcmp(argv[6], "--") != 0 || argv[7][0] == '\0') {
return EXIT_USAGE;
}
for (int fd = 0; fd <= INPUT_FD; fd++) {
if (fcntl(fd, F_GETFD) < 0) {
return EXIT_USAGE;
}
}
struct watcher watcher = {
.stdin_end_grace_ms = stdin_end_grace_ms,
.sigterm_grace_ms = sigterm_grace_ms,
.session = strcmp(argv[4], "session") == 0,
.close_stdin_end = strcmp(argv[5], "stdin-end") == 0,
.phase = WATCH_IDLE,
};
sigset_t fork_set;
sigemptyset(&stop_set);
sigemptyset(&fork_set);
for (int i = 0; i < STOP_SIGNAL_COUNT; i++) {
sigaddset(&stop_set, STOP_SIGNALS[i]);
sigaddset(&fork_set, STOP_SIGNALS[i]);
}
sigaddset(&fork_set, SIGPIPE);
// An inherited SIGCHLD ignore would auto-reap the leader and lose its status; the leader
// restores it for the CLI.
struct sigaction child_default;
memset(&child_default, 0, sizeof child_default);
child_default.sa_handler = SIG_DFL;
sigemptyset(&child_default.sa_mask);
if (set_cloexec(OUTCOME_FD, 1) != 0 ||
sigaction(SIGCHLD, &child_default, &saved_child_action) != 0) {
return EXIT_BOOTSTRAP;
}
#if defined(__linux__)
// Without it the watcher and orphaned descendants would be left to a possibly non-reaping init,
// so refuse before any CLI starts.
if (prctl(PR_SET_CHILD_SUBREAPER, 1, 0, 0, 0) != 0) {
return EXIT_NO_SUBREAPER;
}
int watcher_alive[2];
if (pipe(watcher_alive) != 0 || set_cloexec(watcher_alive[0], 1) != 0 ||
set_cloexec(watcher_alive[1], 1) != 0) {
return EXIT_BOOTSTRAP;
}
watcher_gone_fd = watcher_alive[0];
#endif
// Blocked across fork so a stop signal lands either before it (default action, nothing started)
// or on the leader's handler or this pid's ignore, never on the defaults in between.
if (sigprocmask(SIG_BLOCK, &fork_set, &saved_mask) != 0) {
return EXIT_BOOTSTRAP;
}
pid_t leader = fork();
if (leader == 0) {
run_leader(&watcher, &argv[7]);
}
if (leader < 0) {
return EXIT_BOOTSTRAP;
}
#if defined(__linux__)
close(watcher_alive[1]);
#endif
await_leader(leader);
}