mirror of
https://github.com/freebsd/freebsd-src
synced 2024-07-21 18:27:22 +00:00
![Jessica Clarke](/assets/img/avatar_default.png)
This helper binary will run a given command on every on console, as defined by /etc/ttys (except for ttyv*, where only ttyv0 will be used). If one of the command processes exits, the rest will be killed. This will be used by a future change to start the installer on multiple consoles. Reviewed by: brooks, imp, gjb Differential Revision: https://reviews.freebsd.org/D36804
648 lines
17 KiB
C
648 lines
17 KiB
C
/*-
|
|
* SPDX-License-Identifier: BSD-2-Clause
|
|
*
|
|
* Copyright (c) 2022 Jessica Clarke <jrtc27@FreeBSD.org>
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright
|
|
* notice, this list of conditions and the following disclaimer in the
|
|
* documentation and/or other materials provided with the distribution.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
|
|
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
|
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
|
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
|
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
|
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
|
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
|
* SUCH DAMAGE.
|
|
*/
|
|
|
|
/*
|
|
* We create the following process hierarchy:
|
|
*
|
|
* runconsoles utility
|
|
* |-- runconsoles [ttyX]
|
|
* | `-- utility primary
|
|
* |-- runconsoles [ttyY]
|
|
* | `-- utility secondary
|
|
* ...
|
|
* `-- runconsoles [ttyZ]
|
|
* `-- utility secondary
|
|
*
|
|
* Whilst the intermediate processes might seem unnecessary, they are important
|
|
* so we can ensure the session leader stays around until the actual program
|
|
* being run and all its children have exited when killing them (and, in the
|
|
* case of our controlling terminal, that nothing in our current session goes
|
|
* on to write to it before then), giving them a chance to clean up the
|
|
* terminal (important if a dialog box is showing).
|
|
*
|
|
* Each of the intermediate processes acquires reaper status, allowing it to
|
|
* kill its descendants, not just a single process group, and wait until all
|
|
* have finished, not just its immediate child.
|
|
*/
|
|
|
|
#include <sys/param.h>
|
|
#include <sys/errno.h>
|
|
#include <sys/queue.h>
|
|
#include <sys/resource.h>
|
|
#include <sys/sysctl.h>
|
|
#include <sys/wait.h>
|
|
|
|
#include <err.h>
|
|
#include <errno.h>
|
|
#include <fcntl.h>
|
|
#include <getopt.h>
|
|
#include <signal.h>
|
|
#include <stdarg.h>
|
|
#include <stdbool.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <sysexits.h>
|
|
#include <termios.h>
|
|
#include <ttyent.h>
|
|
#include <unistd.h>
|
|
|
|
#include "common.h"
|
|
#include "child.h"
|
|
|
|
struct consinfo {
|
|
const char *name;
|
|
STAILQ_ENTRY(consinfo) link;
|
|
int fd;
|
|
/* -1: not started, 0: reaped */
|
|
volatile pid_t pid;
|
|
volatile int exitstatus;
|
|
};
|
|
|
|
STAILQ_HEAD(consinfo_list, consinfo);
|
|
|
|
static struct consinfo_list consinfos;
|
|
static struct consinfo *primary_consinfo;
|
|
static struct consinfo *controlling_consinfo;
|
|
|
|
static struct consinfo * volatile first_sigchld_consinfo;
|
|
|
|
static struct pipe_barrier wait_first_child_barrier;
|
|
static struct pipe_barrier wait_all_children_barrier;
|
|
|
|
static const char primary[] = "primary";
|
|
static const char secondary[] = "secondary";
|
|
|
|
static const struct option longopts[] = {
|
|
{ "help", no_argument, NULL, 'h' },
|
|
{ NULL, 0, NULL, 0 }
|
|
};
|
|
|
|
static void
|
|
kill_consoles(int sig)
|
|
{
|
|
struct consinfo *consinfo;
|
|
sigset_t set, oset;
|
|
|
|
/* Temporarily block signals so PID reading and killing are atomic */
|
|
sigfillset(&set);
|
|
sigprocmask(SIG_BLOCK, &set, &oset);
|
|
STAILQ_FOREACH(consinfo, &consinfos, link) {
|
|
if (consinfo->pid != -1 && consinfo->pid != 0)
|
|
kill(consinfo->pid, sig);
|
|
}
|
|
sigprocmask(SIG_SETMASK, &oset, NULL);
|
|
}
|
|
|
|
static void
|
|
sigalrm_handler(int code __unused)
|
|
{
|
|
int saved_errno;
|
|
|
|
saved_errno = errno;
|
|
kill_consoles(SIGKILL);
|
|
errno = saved_errno;
|
|
}
|
|
|
|
static void
|
|
wait_all_consoles(void)
|
|
{
|
|
sigset_t set, oset;
|
|
int error;
|
|
|
|
err_set_exit(NULL);
|
|
|
|
/*
|
|
* We may be run in a context where SIGALRM is blocked; temporarily
|
|
* unblock so we can SIGKILL. Similarly, SIGCHLD may be blocked, but if
|
|
* we're waiting on the pipe we need to make sure it's not.
|
|
*/
|
|
sigemptyset(&set);
|
|
sigaddset(&set, SIGALRM);
|
|
sigaddset(&set, SIGCHLD);
|
|
sigprocmask(SIG_UNBLOCK, &set, &oset);
|
|
alarm(KILL_TIMEOUT);
|
|
pipe_barrier_wait(&wait_all_children_barrier);
|
|
alarm(0);
|
|
sigprocmask(SIG_SETMASK, &oset, NULL);
|
|
|
|
if (controlling_consinfo != NULL) {
|
|
error = tcsetpgrp(controlling_consinfo->fd,
|
|
getpgrp());
|
|
if (error != 0)
|
|
err(EX_OSERR, "could not give up control of %s",
|
|
controlling_consinfo->name);
|
|
}
|
|
}
|
|
|
|
static void
|
|
kill_wait_all_consoles(int sig)
|
|
{
|
|
kill_consoles(sig);
|
|
wait_all_consoles();
|
|
}
|
|
|
|
static void
|
|
kill_wait_all_consoles_err_exit(int eval __unused)
|
|
{
|
|
kill_wait_all_consoles(SIGTERM);
|
|
}
|
|
|
|
static void __dead2
|
|
exit_signal_handler(int code)
|
|
{
|
|
struct consinfo *consinfo;
|
|
bool started_console;
|
|
|
|
started_console = false;
|
|
STAILQ_FOREACH(consinfo, &consinfos, link) {
|
|
if (consinfo->pid != -1) {
|
|
started_console = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* If we haven't yet started a console, don't wait for them, since
|
|
* we'll never get a SIGCHLD that will wake us up.
|
|
*/
|
|
if (started_console)
|
|
kill_wait_all_consoles(SIGTERM);
|
|
|
|
reproduce_signal_death(code);
|
|
exit(EXIT_FAILURE);
|
|
}
|
|
|
|
static void
|
|
sigchld_handler_reaped_one(pid_t pid, int status)
|
|
{
|
|
struct consinfo *consinfo, *child_consinfo;
|
|
bool others;
|
|
|
|
child_consinfo = NULL;
|
|
others = false;
|
|
STAILQ_FOREACH(consinfo, &consinfos, link) {
|
|
/*
|
|
* NB: No need to check consinfo->pid as the caller is
|
|
* responsible for passing a valid PID
|
|
*/
|
|
if (consinfo->pid == pid)
|
|
child_consinfo = consinfo;
|
|
else if (consinfo->pid != -1 && consinfo->pid != 0)
|
|
others = true;
|
|
}
|
|
|
|
if (child_consinfo == NULL)
|
|
return;
|
|
|
|
child_consinfo->pid = 0;
|
|
child_consinfo->exitstatus = status;
|
|
|
|
if (first_sigchld_consinfo == NULL) {
|
|
first_sigchld_consinfo = child_consinfo;
|
|
pipe_barrier_ready(&wait_first_child_barrier);
|
|
}
|
|
|
|
if (others)
|
|
return;
|
|
|
|
pipe_barrier_ready(&wait_all_children_barrier);
|
|
}
|
|
|
|
static void
|
|
sigchld_handler(int code __unused)
|
|
{
|
|
int status, saved_errno;
|
|
pid_t pid;
|
|
|
|
saved_errno = errno;
|
|
while ((void)(pid = waitpid(-1, &status, WNOHANG)),
|
|
pid != -1 && pid != 0)
|
|
sigchld_handler_reaped_one(pid, status);
|
|
errno = saved_errno;
|
|
}
|
|
|
|
static const char *
|
|
read_primary_console(void)
|
|
{
|
|
char *buf, *p, *cons;
|
|
size_t len;
|
|
int error;
|
|
|
|
/*
|
|
* NB: Format is "cons,...cons,/cons,...cons,", with the list before
|
|
* the / being the set of configured consoles, and the list after being
|
|
* the list of available consoles.
|
|
*/
|
|
error = sysctlbyname("kern.console", NULL, &len, NULL, 0);
|
|
if (error == -1)
|
|
err(EX_OSERR, "could not read kern.console length");
|
|
buf = malloc(len);
|
|
if (buf == NULL)
|
|
err(EX_OSERR, "could not allocate kern.console buffer");
|
|
error = sysctlbyname("kern.console", buf, &len, NULL, 0);
|
|
if (error == -1)
|
|
err(EX_OSERR, "could not read kern.console");
|
|
|
|
/* Truncate at / to get just the configured consoles */
|
|
p = strchr(buf, '/');
|
|
if (p == NULL)
|
|
errx(EX_OSERR, "kern.console malformed: no / found");
|
|
*p = '\0';
|
|
|
|
/*
|
|
* Truncate at , to get just the first configured console, the primary
|
|
* ("high level") one.
|
|
*/
|
|
p = strchr(buf, ',');
|
|
if (p != NULL)
|
|
*p = '\0';
|
|
|
|
if (*buf != '\0')
|
|
cons = strdup(buf);
|
|
else
|
|
cons = NULL;
|
|
|
|
free(buf);
|
|
|
|
return (cons);
|
|
}
|
|
|
|
static void
|
|
read_consoles(void)
|
|
{
|
|
const char *primary_console;
|
|
struct consinfo *consinfo;
|
|
int fd, error, flags;
|
|
struct ttyent *tty;
|
|
char *dev, *name;
|
|
pid_t pgrp;
|
|
|
|
primary_console = read_primary_console();
|
|
|
|
STAILQ_INIT(&consinfos);
|
|
while ((tty = getttyent()) != NULL) {
|
|
if ((tty->ty_status & TTY_ON) == 0)
|
|
continue;
|
|
|
|
/*
|
|
* Only use the first VTY; starting on others is pointless as
|
|
* they're multiplexed, and they get used to show the install
|
|
* log and start a shell.
|
|
*/
|
|
if (strncmp(tty->ty_name, "ttyv", 4) == 0 &&
|
|
strcmp(tty->ty_name + 4, "0") != 0)
|
|
continue;
|
|
|
|
consinfo = malloc(sizeof(struct consinfo));
|
|
if (consinfo == NULL)
|
|
err(EX_OSERR, "could not allocate consinfo");
|
|
|
|
asprintf(&dev, "/dev/%s", tty->ty_name);
|
|
if (dev == NULL)
|
|
err(EX_OSERR, "could not allocate dev path");
|
|
|
|
name = dev + 5;
|
|
fd = open(dev, O_RDWR | O_NONBLOCK);
|
|
if (fd == -1)
|
|
err(EX_IOERR, "could not open %s", dev);
|
|
|
|
flags = fcntl(fd, F_GETFL);
|
|
if (flags == -1)
|
|
err(EX_IOERR, "could not get flags for %s", dev);
|
|
|
|
error = fcntl(fd, F_SETFL, flags & ~O_NONBLOCK);
|
|
if (error == -1)
|
|
err(EX_IOERR, "could not set flags for %s", dev);
|
|
|
|
if (tcgetsid(fd) != -1) {
|
|
/*
|
|
* No need to check controlling session is ours as
|
|
* tcgetsid fails with ENOTTY if not.
|
|
*/
|
|
pgrp = tcgetpgrp(fd);
|
|
if (pgrp == -1)
|
|
err(EX_IOERR, "could not get pgrp of %s",
|
|
dev);
|
|
else if (pgrp != getpgrp())
|
|
errx(EX_IOERR, "%s controlled by another group",
|
|
dev);
|
|
|
|
if (controlling_consinfo != NULL)
|
|
errx(EX_OSERR,
|
|
"multiple controlling terminals %s and %s",
|
|
controlling_consinfo->name, name);
|
|
|
|
controlling_consinfo = consinfo;
|
|
}
|
|
|
|
consinfo->name = name;
|
|
consinfo->pid = -1;
|
|
consinfo->fd = fd;
|
|
consinfo->exitstatus = -1;
|
|
STAILQ_INSERT_TAIL(&consinfos, consinfo, link);
|
|
|
|
if (primary_console != NULL &&
|
|
strcmp(consinfo->name, primary_console) == 0)
|
|
primary_consinfo = consinfo;
|
|
}
|
|
|
|
endttyent();
|
|
free(__DECONST(char *, primary_console));
|
|
|
|
if (STAILQ_EMPTY(&consinfos))
|
|
errx(EX_OSERR, "no consoles found");
|
|
|
|
if (primary_consinfo == NULL) {
|
|
warnx("no primary console found, using first");
|
|
primary_consinfo = STAILQ_FIRST(&consinfos);
|
|
}
|
|
}
|
|
|
|
static void
|
|
start_console(struct consinfo *consinfo, const char **argv,
|
|
char *primary_secondary, struct pipe_barrier *start_barrier,
|
|
const sigset_t *oset)
|
|
{
|
|
pid_t pid;
|
|
|
|
if (consinfo == primary_consinfo)
|
|
strcpy(primary_secondary, primary);
|
|
else
|
|
strcpy(primary_secondary, secondary);
|
|
|
|
fprintf(stderr, "Starting %s installer on %s\n", primary_secondary,
|
|
consinfo->name);
|
|
|
|
pid = fork();
|
|
if (pid == -1)
|
|
err(EX_OSERR, "could not fork");
|
|
|
|
if (pid == 0) {
|
|
/* Redundant for the first fork but not subsequent ones */
|
|
err_set_exit(NULL);
|
|
|
|
/*
|
|
* We need to destroy the ready ends so we don't block these
|
|
* parent-only self-pipes, and might as well destroy the wait
|
|
* ends too given we're not going to use them.
|
|
*/
|
|
pipe_barrier_destroy(&wait_first_child_barrier);
|
|
pipe_barrier_destroy(&wait_all_children_barrier);
|
|
|
|
child_leader_run(consinfo->name, consinfo->fd,
|
|
consinfo != controlling_consinfo, argv, oset,
|
|
start_barrier);
|
|
}
|
|
|
|
consinfo->pid = pid;
|
|
|
|
/*
|
|
* We have at least one child now so make sure we kill children on
|
|
* exit. We also must not do this until we have at least one since
|
|
* otherwise we will never receive a SIGCHLD that will ready the pipe
|
|
* barrier and thus we will wait forever.
|
|
*/
|
|
err_set_exit(kill_wait_all_consoles_err_exit);
|
|
}
|
|
|
|
static void
|
|
start_consoles(int argc, char **argv)
|
|
{
|
|
struct pipe_barrier start_barrier;
|
|
struct consinfo *consinfo;
|
|
char *primary_secondary;
|
|
const char **newargv;
|
|
struct sigaction sa;
|
|
sigset_t set, oset;
|
|
int error, i;
|
|
|
|
error = pipe_barrier_init(&start_barrier);
|
|
if (error != 0)
|
|
err(EX_OSERR, "could not create start children barrier");
|
|
|
|
error = pipe_barrier_init(&wait_first_child_barrier);
|
|
if (error != 0)
|
|
err(EX_OSERR, "could not create wait first child barrier");
|
|
|
|
error = pipe_barrier_init(&wait_all_children_barrier);
|
|
if (error != 0)
|
|
err(EX_OSERR, "could not create wait all children barrier");
|
|
|
|
/*
|
|
* About to start children, so use our SIGCHLD handler to get notified
|
|
* when we need to stop. Once the first child has started we will have
|
|
* registered kill_wait_all_consoles_err_exit which needs our SIGALRM handler to
|
|
* SIGKILL the children on timeout; do it up front so we can err if it
|
|
* fails beforehand.
|
|
*
|
|
* Also set up our SIGTERM (and SIGINT and SIGQUIT if we're keeping
|
|
* control of this terminal) handler before we start children so we can
|
|
* clean them up when signalled.
|
|
*/
|
|
sa.sa_flags = SA_RESTART | SA_NOCLDSTOP;
|
|
sa.sa_handler = sigchld_handler;
|
|
sigfillset(&sa.sa_mask);
|
|
error = sigaction(SIGCHLD, &sa, NULL);
|
|
if (error != 0)
|
|
err(EX_OSERR, "could not enable SIGCHLD handler");
|
|
sa.sa_flags = SA_RESTART;
|
|
sa.sa_handler = sigalrm_handler;
|
|
error = sigaction(SIGALRM, &sa, NULL);
|
|
if (error != 0)
|
|
err(EX_OSERR, "could not enable SIGALRM handler");
|
|
sa.sa_handler = exit_signal_handler;
|
|
error = sigaction(SIGTERM, &sa, NULL);
|
|
if (error != 0)
|
|
err(EX_OSERR, "could not enable SIGTERM handler");
|
|
if (controlling_consinfo == NULL) {
|
|
error = sigaction(SIGINT, &sa, NULL);
|
|
if (error != 0)
|
|
err(EX_OSERR, "could not enable SIGINT handler");
|
|
error = sigaction(SIGQUIT, &sa, NULL);
|
|
if (error != 0)
|
|
err(EX_OSERR, "could not enable SIGQUIT handler");
|
|
}
|
|
|
|
/*
|
|
* Ignore SIGINT/SIGQUIT in parent if a child leader will take control
|
|
* of this terminal so only it gets them, and ignore SIGPIPE in parent,
|
|
* and child until unblocked, since we're using pipes internally as
|
|
* synchronisation barriers between parent and children.
|
|
*
|
|
* Also ignore SIGTTOU so we can print errors if needed after the child
|
|
* has started.
|
|
*/
|
|
sa.sa_flags = SA_RESTART;
|
|
sa.sa_handler = SIG_IGN;
|
|
if (controlling_consinfo != NULL) {
|
|
error = sigaction(SIGINT, &sa, NULL);
|
|
if (error != 0)
|
|
err(EX_OSERR, "could not ignore SIGINT");
|
|
error = sigaction(SIGQUIT, &sa, NULL);
|
|
if (error != 0)
|
|
err(EX_OSERR, "could not ignore SIGQUIT");
|
|
}
|
|
error = sigaction(SIGPIPE, &sa, NULL);
|
|
if (error != 0)
|
|
err(EX_OSERR, "could not ignore SIGPIPE");
|
|
error = sigaction(SIGTTOU, &sa, NULL);
|
|
if (error != 0)
|
|
err(EX_OSERR, "could not ignore SIGTTOU");
|
|
|
|
/*
|
|
* Create a fresh copy of the argument array and perform %-substitution;
|
|
* a literal % will be replaced with primary_secondary, and any other
|
|
* string that starts % will have the leading % removed (thus arguments
|
|
* that should start with a % should be escaped with an additional %).
|
|
*
|
|
* Having all % arguments use primary_secondary means that copying
|
|
* either "primary" or "secondary" to it will yield the final argument
|
|
* array for the child in constant time, regardless of how many appear.
|
|
*/
|
|
newargv = malloc(((size_t)argc + 1) * sizeof(char *));
|
|
if (newargv == NULL)
|
|
err(EX_OSERR, "could not allocate newargv");
|
|
|
|
primary_secondary = malloc(MAX(sizeof(primary), sizeof(secondary)));
|
|
if (primary_secondary == NULL)
|
|
err(EX_OSERR, "could not allocate primary_secondary");
|
|
|
|
newargv[0] = argv[0];
|
|
for (i = 1; i < argc; ++i) {
|
|
switch (argv[i][0]) {
|
|
case '%':
|
|
if (argv[i][1] == '\0')
|
|
newargv[i] = primary_secondary;
|
|
else
|
|
newargv[i] = argv[i] + 1;
|
|
break;
|
|
default:
|
|
newargv[i] = argv[i];
|
|
break;
|
|
}
|
|
}
|
|
newargv[argc] = NULL;
|
|
|
|
/*
|
|
* Temporarily block signals. The parent needs forking, assigning
|
|
* consinfo->pid and, for the first iteration, calling err_set_exit, to
|
|
* be atomic, and the child leader shouldn't have signals re-enabled
|
|
* until it has configured its signal handlers appropriately as the
|
|
* current ones are for the parent's handling of children.
|
|
*/
|
|
sigfillset(&set);
|
|
sigprocmask(SIG_BLOCK, &set, &oset);
|
|
STAILQ_FOREACH(consinfo, &consinfos, link)
|
|
start_console(consinfo, newargv, primary_secondary,
|
|
&start_barrier, &oset);
|
|
sigprocmask(SIG_SETMASK, &oset, NULL);
|
|
|
|
/* Now ready for children to start */
|
|
pipe_barrier_ready(&start_barrier);
|
|
}
|
|
|
|
static int
|
|
wait_consoles(void)
|
|
{
|
|
pipe_barrier_wait(&wait_first_child_barrier);
|
|
|
|
/*
|
|
* Once one of our children has exited, kill off the rest and wait for
|
|
* them all to exit. This will also set the foreground process group of
|
|
* the controlling terminal back to ours if it's one of the consoles.
|
|
*/
|
|
kill_wait_all_consoles(SIGTERM);
|
|
|
|
if (first_sigchld_consinfo == NULL)
|
|
errx(EX_SOFTWARE, "failed to find first child that exited");
|
|
|
|
return (first_sigchld_consinfo->exitstatus);
|
|
}
|
|
|
|
static void __dead2
|
|
usage(void)
|
|
{
|
|
fprintf(stderr, "usage: %s utility [argument ...]", getprogname());
|
|
exit(EX_USAGE);
|
|
}
|
|
|
|
int
|
|
main(int argc, char **argv)
|
|
{
|
|
int ch, status;
|
|
|
|
while ((ch = getopt_long(argc, argv, "+h", longopts, NULL)) != -1) {
|
|
switch (ch) {
|
|
case 'h':
|
|
default:
|
|
usage();
|
|
}
|
|
}
|
|
|
|
argc -= optind;
|
|
argv += optind;
|
|
|
|
if (argc < 2)
|
|
usage();
|
|
|
|
/*
|
|
* Gather the list of enabled consoles from /etc/ttys, ignoring VTYs
|
|
* other than ttyv0 since they're used for other purposes when the
|
|
* installer is running, and there would be no point having multiple
|
|
* copies on each of the multiplexed virtual consoles anyway.
|
|
*/
|
|
read_consoles();
|
|
|
|
/*
|
|
* Start the installer on all the consoles. Do not print after this
|
|
* point until our process group is in the foreground again unless
|
|
* necessary (we ignore SIGTTOU so we can print errors, but don't want
|
|
* to garble a child's output).
|
|
*/
|
|
start_consoles(argc, argv);
|
|
|
|
/*
|
|
* Wait for one of the installers to exit, kill the rest, become the
|
|
* foreground process group again and get the exit code of the first
|
|
* child to exit.
|
|
*/
|
|
status = wait_consoles();
|
|
|
|
/*
|
|
* Reproduce the exit code of the first child to exit, including
|
|
* whether it was a fatal signal or normal termination.
|
|
*/
|
|
if (WIFSIGNALED(status))
|
|
reproduce_signal_death(WTERMSIG(status));
|
|
|
|
if (WIFEXITED(status))
|
|
return (WEXITSTATUS(status));
|
|
|
|
return (EXIT_FAILURE);
|
|
}
|