Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

daemon: decouple init logic from main loop #699

Closed
wants to merge 1 commit into from
Closed

daemon: decouple init logic from main loop #699

Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
195 changes: 109 additions & 86 deletions usr.sbin/daemon/daemon.c
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -60,7 +60,12 @@ __FBSDID("$FreeBSD$");
#define LBUF_SIZE 4096

struct daemon_state {
sigset_t mask_orig;
sigset_t mask_read;
sigset_t mask_term;
sigset_t mask_susp;
int pipe_fd[2];
char **argv;
const char *child_pidfile;
const char *parent_pidfile;
const char *output_filename;
Expand Down Expand Up @@ -96,6 +101,7 @@ static void open_pid_files(struct daemon_state *);
static void do_output(const unsigned char *, size_t, struct daemon_state *);
static void daemon_sleep(time_t, long);
static void daemon_state_init(struct daemon_state *);
static void daemon_eventloop(struct daemon_state *);
static void daemon_terminate(struct daemon_state *);

static volatile sig_atomic_t terminate = 0;
Expand Down Expand Up @@ -163,47 +169,9 @@ main(int argc, char *argv[])
char *p = NULL;
int ch = 0;
struct daemon_state state;
sigset_t mask_orig;
sigset_t mask_read;
sigset_t mask_term;
sigset_t mask_susp;

daemon_state_init(&state);

/*
* Signal handling logic:
ngortheone marked this conversation as resolved.
Show resolved Hide resolved
*
* - SIGTERM is masked while there is no child.
*
* - SIGCHLD is masked while reading from the pipe. SIGTERM has to be
* caught, to avoid indefinite blocking on read().
*
* - Both SIGCHLD and SIGTERM are masked before calling sigsuspend()
* to avoid racing.
*
* - After SIGTERM is recieved and propagated to the child there are
* several options on what to do next:
* - read until EOF
* - read until EOF but only for a while
* - bail immediately
* Currently the third option is used, because otherwise there is no
* guarantee that read() won't block indefinitely if the child refuses
* to depart. To handle the second option, a different approach
* would be needed (procctl()?).
*
* - Child's exit might be detected by receiveing EOF from the pipe.
* But the child might have closed its stdout and stderr, so deamon
* must wait for the SIGCHLD to ensure that the child is actually gone.
*/
sigemptyset(&mask_susp);
sigemptyset(&mask_read);
sigemptyset(&mask_term);
sigemptyset(&mask_orig);
sigaddset(&mask_susp, SIGTERM);
sigaddset(&mask_susp, SIGCHLD);
sigaddset(&mask_term, SIGTERM);
sigaddset(&mask_read, SIGCHLD);

/*
* Supervision mode is enabled if one of the following options are used:
* --child-pidfile -p
Expand Down Expand Up @@ -309,6 +277,7 @@ main(int argc, char *argv[])
}
argc -= optind;
argv += optind;
state.argv = argv;

if (argc == 0) {
usage(1);
Expand Down Expand Up @@ -343,8 +312,8 @@ main(int argc, char *argv[])
pidfile_write(state.parent_pidfh);

if (state.supervision_enabled) {
/* Block SIGTERM to avoid racing until we have forked. */
if (sigprocmask(SIG_BLOCK, &mask_term, &mask_orig)) {
/* Block SIGTERM to avoid racing until the child is spawned. */
if (sigprocmask(SIG_BLOCK, &state.mask_term, &state.mask_orig)) {
warn("sigprocmask");
daemon_terminate(&state);
}
Expand All @@ -357,8 +326,50 @@ main(int argc, char *argv[])
* not have superuser privileges.
*/
(void)madvise(NULL, 0, MADV_PROTECT);
restart:
if (pipe(state.pipe_fd)) {
}
do {
daemon_eventloop(&state);
close(state.pipe_fd[0]);
state.pipe_fd[0] = -1;
} while (state.restart_enabled && !terminate);

daemon_terminate(&state);
}


/*
* Main event loop: fork the child and watch for events.
* In legacy mode simply execve into the target process.
*
* Signal handling logic:
*
* - SIGTERM is masked while there is no child.
*
* - SIGCHLD is masked while reading from the pipe. SIGTERM has to be
* caught, to avoid indefinite blocking on read().
*
* - Both SIGCHLD and SIGTERM are masked before calling sigsuspend()
* to avoid racing.
*
* - After SIGTERM is recieved and propagated to the child there are
* several options on what to do next:
* - read until EOF
* - read until EOF but only for a while
* - bail immediately
* Currently the third option is used, because otherwise there is no
* guarantee that read() won't block indefinitely if the child refuses
* to depart. To handle the second option, a different approach
* would be needed (procctl()?).
*
* - Child's exit might be detected by receiveing EOF from the pipe.
* But the child might have closed its stdout and stderr, so deamon
* must wait for the SIGCHLD to ensure that the child is actually gone.
*/
static void
daemon_eventloop(struct daemon_state *state)
{
if (state->supervision_enabled) {
if (pipe(state->pipe_fd)) {
err(1, "pipe");
}
/*
Expand All @@ -371,43 +382,43 @@ main(int argc, char *argv[])
/* fork failed, this can only happen when supervision is enabled */
if (pid == -1) {
warn("fork");
daemon_terminate(&state);
daemon_terminate(state);
}

/* fork succeeded, this is child's branch or supervision is disabled */
if (pid == 0) {
pidfile_write(state.child_pidfh);
pidfile_write(state->child_pidfh);

if (state.user != NULL) {
restrict_process(state.user);
if (state->user != NULL) {
restrict_process(state->user);
}
/*
* In supervision mode, the child gets the original sigmask,
* and dup'd pipes.
*/
if (state.supervision_enabled) {
close(state.pipe_fd[0]);
if (sigprocmask(SIG_SETMASK, &mask_orig, NULL)) {
if (state->supervision_enabled) {
close(state->pipe_fd[0]);
if (sigprocmask(SIG_SETMASK, &state->mask_orig, NULL)) {
err(1, "sigprogmask");
}
if (state.stdmask & STDERR_FILENO) {
if (dup2(state.pipe_fd[1], STDERR_FILENO) == -1) {
if (state->stdmask & STDERR_FILENO) {
if (dup2(state->pipe_fd[1], STDERR_FILENO) == -1) {
err(1, "dup2");
}
}
if (state.stdmask & STDOUT_FILENO) {
if (dup2(state.pipe_fd[1], STDOUT_FILENO) == -1) {
if (state->stdmask & STDOUT_FILENO) {
if (dup2(state->pipe_fd[1], STDOUT_FILENO) == -1) {
err(1, "dup2");
}
}
if (state.pipe_fd[1] != STDERR_FILENO &&
state.pipe_fd[1] != STDOUT_FILENO) {
close(state.pipe_fd[1]);
if (state->pipe_fd[1] != STDERR_FILENO &&
state->pipe_fd[1] != STDOUT_FILENO) {
close(state->pipe_fd[1]);
}
}
execvp(argv[0], argv);
execvp(state->argv[0], state->argv);
/* execvp() failed - report error and exit this process */
err(1, "%s", argv[0]);
err(1, "%s", state->argv[0]);
}

/*
Expand All @@ -417,64 +428,65 @@ main(int argc, char *argv[])
*
* Unblock SIGTERM - now there is a valid child PID to signal to.
*/
if (sigprocmask(SIG_UNBLOCK, &mask_term, NULL)) {
if (sigprocmask(SIG_UNBLOCK, &state->mask_term, NULL)) {
warn("sigprocmask");
daemon_terminate(&state);
daemon_terminate(state);
}
close(state.pipe_fd[1]);
state.pipe_fd[1] = -1;
close(state->pipe_fd[1]);
state->pipe_fd[1] = -1;

setproctitle("%s[%d]", state.title, (int)pid);
setproctitle("%s[%d]", state->title, (int)pid);
for (;;) {
if (child_gone && state.child_eof) {
if (child_gone && state->child_eof) {
break;
}

if (terminate) {
daemon_terminate(&state);
daemon_terminate(state);
}

if (state.child_eof) {
if (sigprocmask(SIG_BLOCK, &mask_susp, NULL)) {
if (state->child_eof) {
if (sigprocmask(SIG_BLOCK, &state->mask_susp, NULL)) {
warn("sigprocmask");
daemon_terminate(&state);
daemon_terminate(state);
}
while (!terminate && !child_gone) {
sigsuspend(&mask_orig);
sigsuspend(&state->mask_orig);
}
if (sigprocmask(SIG_UNBLOCK, &mask_susp, NULL)) {
if (sigprocmask(SIG_UNBLOCK, &state->mask_susp, NULL)) {
warn("sigprocmask");
daemon_terminate(&state);
daemon_terminate(state);
}
continue;
}

if (sigprocmask(SIG_BLOCK, &mask_read, NULL)) {
if (sigprocmask(SIG_BLOCK, &state->mask_read, NULL)) {
warn("sigprocmask");
daemon_terminate(&state);
daemon_terminate(state);
}

state.child_eof = !listen_child(state.pipe_fd[0], &state);
state->child_eof = !listen_child(state->pipe_fd[0], state);

if (sigprocmask(SIG_UNBLOCK, &mask_read, NULL)) {
if (sigprocmask(SIG_UNBLOCK, &state->mask_read, NULL)) {
warn("sigprocmask");
daemon_terminate(&state);
daemon_terminate(state);
}

}
if (state.restart_enabled && !terminate) {
daemon_sleep(state.restart_delay, 0);
}
if (sigprocmask(SIG_BLOCK, &mask_term, NULL)) {

/*
* At the end of the loop the the child is already gone.
* Block SIGTERM to avoid racing until the child is spawned.
*/
if (sigprocmask(SIG_BLOCK, &state->mask_term, NULL)) {
warn("sigprocmask");
daemon_terminate(&state);
daemon_terminate(state);
}
if (state.restart_enabled && !terminate) {
close(state.pipe_fd[0]);
state.pipe_fd[0] = -1;
goto restart;

/* sleep before exiting mainloop if restart is enabled */
if (state->restart_enabled && !terminate) {
daemon_sleep(state->restart_delay, 0);
}
daemon_terminate(&state);
}

static void
Expand Down Expand Up @@ -746,6 +758,7 @@ daemon_state_init(struct daemon_state *state)
{
*state = (struct daemon_state) {
.pipe_fd = { -1, -1 },
.argv = NULL,
.parent_pidfh = NULL,
.child_pidfh = NULL,
.child_pidfile = NULL,
Expand All @@ -767,6 +780,16 @@ daemon_state_init(struct daemon_state *state)
.output_fd = -1,
.output_filename = NULL,
};

sigemptyset(&state->mask_susp);
sigemptyset(&state->mask_read);
sigemptyset(&state->mask_term);
sigemptyset(&state->mask_orig);
sigaddset(&state->mask_susp, SIGTERM);
sigaddset(&state->mask_susp, SIGCHLD);
sigaddset(&state->mask_term, SIGTERM);
sigaddset(&state->mask_read, SIGCHLD);

}

static _Noreturn void
Expand Down