X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=lib%2Fdaemon.c;h=5486504641b6ded5fa94dae6b5506be66a07ba0c;hb=refs%2Fheads%2Flts-1.0a;hp=4ad4af4c607a9eca9fa961750d79ac36eae165a5;hpb=34e63086edddcae06d7c1a4fa84fec0861e50758;p=sliver-openvswitch.git diff --git a/lib/daemon.c b/lib/daemon.c index 4ad4af4c6..548650464 100644 --- a/lib/daemon.c +++ b/lib/daemon.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 2008, 2009 Nicira Networks. + * Copyright (c) 2008, 2009, 2010 Nicira Networks. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -18,33 +18,52 @@ #include "daemon.h" #include #include +#include #include #include +#include +#include #include +#include "command-line.h" #include "fatal-signal.h" #include "dirs.h" +#include "lockfile.h" +#include "process.h" +#include "socket-util.h" +#include "timeval.h" #include "util.h" - -#define THIS_MODULE VLM_daemon #include "vlog.h" -/* Should we run in the background? */ +VLOG_DEFINE_THIS_MODULE(daemon) + +/* --detach: Should we run in the background? */ static bool detach; -/* Name of pidfile (null if none). */ +/* --pidfile: Name of pidfile (null if none). */ static char *pidfile; -/* Create pidfile even if one already exists and is locked? */ -static bool force; +/* --overwrite-pidfile: Create pidfile even if one already exists and is + locked? */ +static bool overwrite_pidfile; + +/* --no-chdir: Should we chdir to "/"? */ +static bool chdir_ = true; + +/* File descriptor used by daemonize_start() and daemonize_complete(). */ +static int daemonize_fd = -1; + +/* --monitor: Should a supervisory process monitor the daemon and restart it if + * it dies due to an error signal? */ +static bool monitor; /* Returns the file name that would be used for a pidfile if 'name' were * provided to set_pidfile(). The caller must free the returned string. */ char * -make_pidfile_name(const char *name) +make_pidfile_name(const char *name) { - return (!name ? xasprintf("%s/%s.pid", ovs_rundir, program_name) - : *name == '/' ? xstrdup(name) - : xasprintf("%s/%s", ovs_rundir, name)); + return (!name + ? xasprintf("%s/%s.pid", ovs_rundir, program_name) + : abs_file_name(ovs_rundir, name)); } /* Sets up a following call to daemonize() to create a pidfile named 'name'. @@ -69,13 +88,27 @@ get_pidfile(void) return pidfile; } +/* Sets that we do not chdir to "/". */ +void +set_no_chdir(void) +{ + chdir_ = false; +} + +/* Will we chdir to "/" as part of daemonizing? */ +bool +is_chdir_enabled(void) +{ + return chdir_; +} + /* Normally, die_if_already_running() will terminate the program with a message * if a locked pidfile already exists. If this function is called, * die_if_already_running() will merely log a warning. */ void ignore_existing_pidfile(void) { - force = true; + overwrite_pidfile = true; } /* Sets up a following call to daemonize() to detach from the foreground @@ -86,6 +119,21 @@ set_detach(void) detach = true; } +/* Will daemonize() really detach? */ +bool +get_detach(void) +{ + return detach; +} + +/* Sets up a following call to daemonize() to fork a supervisory process to + * monitor the daemon and restart it if it dies due to an error signal. */ +void +daemon_set_monitor(void) +{ + monitor = true; +} + /* If a pidfile has been configured and that pidfile already exists and is * locked by a running process, returns the pid of the running process. * Otherwise, returns 0. */ @@ -117,7 +165,7 @@ die_if_already_running(void) { pid_t pid = already_running(); if (pid) { - if (!force) { + if (!overwrite_pidfile) { ovs_fatal(0, "%s: already running as pid %ld", get_pidfile(), (long int) pid); } else { @@ -127,9 +175,9 @@ die_if_already_running(void) } } -/* If a pidfile has been configured, creates it and stores the running process' - * pid init. Ensures that the pidfile will be deleted when the process - * exits. */ +/* If a pidfile has been configured, creates it and stores the running + * process's pid in it. Ensures that the pidfile will be deleted when the + * process exits. */ static void make_pidfile(void) { @@ -185,40 +233,241 @@ make_pidfile(void) void daemonize(void) { - if (detach) { - char c = 0; - int fds[2]; - if (pipe(fds) < 0) { - ovs_fatal(errno, "pipe failed"); + daemonize_start(); + daemonize_complete(); +} + +static pid_t +fork_and_wait_for_startup(int *fdp) +{ + int fds[2]; + pid_t pid; + + if (pipe(fds) < 0) { + ovs_fatal(errno, "pipe failed"); + } + + pid = fork(); + if (pid > 0) { + /* Running in parent process. */ + char c; + + close(fds[1]); + fatal_signal_fork(); + if (read(fds[0], &c, 1) != 1) { + int retval; + int status; + + do { + retval = waitpid(pid, &status, 0); + } while (retval == -1 && errno == EINTR); + + if (retval == pid + && WIFEXITED(status) + && WEXITSTATUS(status)) { + /* Child exited with an error. Convey the same error to + * our parent process as a courtesy. */ + exit(WEXITSTATUS(status)); + } + + ovs_fatal(errno, "fork child failed to signal startup"); + } + close(fds[0]); + *fdp = -1; + } else if (!pid) { + /* Running in child process. */ + close(fds[0]); + time_postfork(); + lockfile_postfork(); + *fdp = fds[1]; + } else { + ovs_fatal(errno, "could not fork"); + } + + return pid; +} + +static void +fork_notify_startup(int fd) +{ + if (fd != -1) { + size_t bytes_written; + int error; + + error = write_fully(fd, "", 1, &bytes_written); + if (error) { + ovs_fatal(error, "could not write to pipe"); } - switch (fork()) { - default: - /* Parent process: wait for child to create pidfile, then exit. */ - close(fds[1]); - fatal_signal_fork(); - if (read(fds[0], &c, 1) != 1) { - ovs_fatal(errno, "daemon child failed to signal startup"); + close(fd); + } +} + +static bool +should_restart(int status) +{ + if (WIFSIGNALED(status)) { + static const int error_signals[] = { + SIGABRT, SIGALRM, SIGBUS, SIGFPE, SIGILL, SIGPIPE, SIGSEGV, + SIGXCPU, SIGXFSZ + }; + + size_t i; + + for (i = 0; i < ARRAY_SIZE(error_signals); i++) { + if (error_signals[i] == WTERMSIG(status)) { + return true; } + } + } + return false; +} + +static void +monitor_daemon(pid_t daemon_pid) +{ + /* XXX Should log daemon's stderr output at startup time. */ + const char *saved_program_name; + time_t last_restart; + char *status_msg; + + saved_program_name = program_name; + program_name = xasprintf("monitor(%s)", program_name); + status_msg = xstrdup("healthy"); + last_restart = TIME_MIN; + for (;;) { + int retval; + int status; + + proctitle_set("%s: monitoring pid %lu (%s)", + saved_program_name, (unsigned long int) daemon_pid, + status_msg); + + do { + retval = waitpid(daemon_pid, &status, 0); + } while (retval == -1 && errno == EINTR); + + if (retval == -1) { + ovs_fatal(errno, "waitpid failed"); + } else if (retval == daemon_pid) { + char *s = process_status_msg(status); + free(status_msg); + status_msg = xasprintf("pid %lu died, %s", + (unsigned long int) daemon_pid, s); + free(s); + + if (should_restart(status)) { + if (WCOREDUMP(status)) { + /* Disable further core dumps to save disk space. */ + struct rlimit r; + + r.rlim_cur = 0; + r.rlim_max = 0; + if (setrlimit(RLIMIT_CORE, &r) == -1) { + VLOG_WARN("failed to disable core dumps: %s", + strerror(errno)); + } + } + + /* Throttle restarts to no more than once every 10 seconds. */ + if (time(NULL) < last_restart + 10) { + VLOG_WARN("%s, waiting until 10 seconds since last " + "restart", status_msg); + for (;;) { + time_t now = time(NULL); + time_t wakeup = last_restart + 10; + if (now >= wakeup) { + break; + } + sleep(wakeup - now); + } + } + last_restart = time(NULL); + + VLOG_ERR("%s, restarting", status_msg); + daemon_pid = fork_and_wait_for_startup(&daemonize_fd); + if (!daemon_pid) { + break; + } + } else { + VLOG_INFO("%s, exiting", status_msg); + exit(0); + } + } + } + free(status_msg); + + /* Running in new daemon process. */ + proctitle_restore(); + free((char *) program_name); + program_name = saved_program_name; +} + +/* Close stdin, stdout, stderr. If we're started from e.g. an SSH session, + * then this keeps us from holding that session open artificially. */ +static void +close_standard_fds(void) +{ + int null_fd = get_null_fd(); + if (null_fd >= 0) { + dup2(null_fd, STDIN_FILENO); + dup2(null_fd, STDOUT_FILENO); + dup2(null_fd, STDERR_FILENO); + } +} + +/* If daemonization is configured, then starts daemonization, by forking and + * returning in the child process. The parent process hangs around until the + * child lets it know either that it completed startup successfully (by calling + * daemon_complete()) or that it failed to start up (by exiting with a nonzero + * exit code). */ +void +daemonize_start(void) +{ + daemonize_fd = -1; + + if (detach) { + if (fork_and_wait_for_startup(&daemonize_fd) > 0) { + /* Running in parent process. */ exit(0); + } + /* Running in daemon or monitor process. */ + } - case 0: - /* Child process. */ - close(fds[0]); - make_pidfile(); - write(fds[1], &c, 1); - close(fds[1]); - setsid(); - chdir("/"); - break; - - case -1: - /* Error. */ - ovs_fatal(errno, "could not fork"); - break; + if (monitor) { + int saved_daemonize_fd = daemonize_fd; + pid_t daemon_pid; + + daemon_pid = fork_and_wait_for_startup(&daemonize_fd); + if (daemon_pid > 0) { + /* Running in monitor process. */ + fork_notify_startup(saved_daemonize_fd); + close_standard_fds(); + monitor_daemon(daemon_pid); } - } else { - make_pidfile(); + /* Running in daemon process. */ + } + + make_pidfile(); + + /* Make sure that the unixctl commands for vlog get registered in a + * daemon, even before the first log message. */ + vlog_init(); +} + +/* If daemonization is configured, then this function notifies the parent + * process that the child process has completed startup successfully. */ +void +daemonize_complete(void) +{ + fork_notify_startup(daemonize_fd); + + if (detach) { + setsid(); + if (chdir_) { + ignore(chdir("/")); + } + close_standard_fds(); } } @@ -227,9 +476,11 @@ daemon_usage(void) { printf( "\nDaemon options:\n" - " -D, --detach run in background as daemon\n" - " -P, --pidfile[=FILE] create pidfile (default: %s/%s.pid)\n" - " -f, --force with -P, start even if already running\n", + " --detach run in background as daemon\n" + " --no-chdir do not chdir to '/'\n" + " --pidfile[=FILE] create pidfile (default: %s/%s.pid)\n" + " --overwrite-pidfile with --pidfile, start even if already " + "running\n", ovs_rundir, program_name); }