lib/daemon.c

   1 /* Copyright (c) 2008 The Board of Trustees of The Leland Stanford
   2  * Junior University
   3  *
   4  * We are making the OpenFlow specification and associated documentation
   5  * (Software) available for public use and benefit with the expectation
   6  * that others will use, modify and enhance the Software and contribute
   7  * those enhancements back to the community. However, since we would
   8  * like to make the Software available for broadest use, with as few
   9  * restrictions as possible permission is hereby granted, free of
  10  * charge, to any person obtaining a copy of this Software to deal in
  11  * the Software under the copyrights without restriction, including
  12  * without limitation the rights to use, copy, modify, merge, publish,
  13  * distribute, sublicense, and/or sell copies of the Software, and to
  14  * permit persons to whom the Software is furnished to do so, subject to
  15  * the following conditions:
  16  *
  17  * The above copyright notice and this permission notice shall be
  18  * included in all copies or substantial portions of the Software.
  19  *
  20  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  21  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  22  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  23  * NONINFRINGEMENT.  IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
  24  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
  25  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  26  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  27  * SOFTWARE.
  28  *
  29  * The name and trademarks of copyright holder(s) may NOT be used in
  30  * advertising or publicity pertaining to the Software or any
  31  * derivatives without specific, written prior permission.
  32  */
  33
  34 #include <config.h>
  35 #include "daemon.h"
  36 #include <errno.h>
  37 #include <fcntl.h>
  38 #include <stdlib.h>
  39 #include <string.h>
  40 #include <unistd.h>
  41 #include "fatal-signal.h"
  42 #include "util.h"
  43
  44 #define THIS_MODULE VLM_daemon
  45 #include "vlog.h"
  46
  47 /* Should we run in the background? */
  48 static bool detach;
  49
  50 /* Name of pidfile (null if none). */
  51 static char *pidfile;
  52
  53 /* Create pidfile even if one already exists and is locked? */
  54 static bool force;
  55
  56 /* Returns the file name that would be used for a pidfile if 'name' were
  57  * provided to set_pidfile().  The caller must free the returned string. */
  58 char *
  59 make_pidfile_name(const char *name)
  60 {
  61     return (!name ? xasprintf("%s/%s.pid", RUNDIR, program_name)
  62             : *name == '/' ? xstrdup(name)
  63             : xasprintf("%s/%s", RUNDIR, name));
  64 }
  65
  66 /* Sets up a following call to daemonize() to create a pidfile named 'name'.
  67  * If 'name' begins with '/', then it is treated as an absolute path.
  68  * Otherwise, it is taken relative to RUNDIR, which is $(prefix)/var/run by
  69  * default.
  70  *
  71  * If 'name' is null, then program_name followed by ".pid" is used. */
  72 void
  73 set_pidfile(const char *name)
  74 {
  75     free(pidfile);
  76     pidfile = make_pidfile_name(name);
  77 }
  78
  79 /* Returns an absolute path to the configured pidfile, or a null pointer if no
  80  * pidfile is configured.  The caller must not modify or free the returned
  81  * string. */
  82 const char *
  83 get_pidfile(void)
  84 {
  85     return pidfile;
  86 }
  87
  88 /* Normally, die_if_already_running() will terminate the program with a message
  89  * if a locked pidfile already exists.  If this function is called,
  90  * die_if_already_running() will merely log a warning. */
  91 void
  92 ignore_existing_pidfile(void)
  93 {
  94     force = true;
  95 }
  96
  97 /* Sets up a following call to daemonize() to detach from the foreground
  98  * session, running this process in the background.  */
  99 void
 100 set_detach(void)
 101 {
 102     detach = true;
 103 }
 104
 105 /* If a pidfile has been configured and that pidfile already exists and is
 106  * locked by a running process, returns the pid of the running process.
 107  * Otherwise, returns 0. */
 108 static pid_t
 109 already_running(void)
 110 {
 111     pid_t pid = 0;
 112     if (pidfile) {
 113         int fd = open(pidfile, O_RDWR);
 114         if (fd >= 0) {
 115             struct flock lck;
 116             lck.l_type = F_WRLCK;
 117             lck.l_whence = SEEK_SET;
 118             lck.l_start = 0;
 119             lck.l_len = 0;
 120             if (fcntl(fd, F_GETLK, &lck) != -1 && lck.l_type != F_UNLCK) {
 121                 pid = lck.l_pid;
 122             }
 123             close(fd);
 124         }
 125     }
 126     return pid;
 127 }
 128
 129 /* If a locked pidfile exists, issue a warning message and, unless
 130  * ignore_existing_pidfile() has been called, terminate the program. */
 131 void
 132 die_if_already_running(void)
 133 {
 134     pid_t pid = already_running();
 135     if (pid) {
 136         if (!force) {
 137             ofp_fatal(0, "%s: already running as pid %ld",
 138                       get_pidfile(), (long int) pid);
 139         } else {
 140             VLOG_WARN("%s: %s already running as pid %ld",
 141                       get_pidfile(), program_name, (long int) pid);
 142         }
 143     }
 144 }
 145
 146 /* If a pidfile has been configured, creates it and stores the running process'
 147  * pid init.  Ensures that the pidfile will be deleted when the process
 148  * exits. */
 149 static void
 150 make_pidfile(void)
 151 {
 152     if (pidfile) {
 153         /* Create pidfile via temporary file, so that observers never see an
 154          * empty pidfile or an unlocked pidfile. */
 155         long int pid = getpid();
 156         char *tmpfile;
 157         int fd;
 158
 159         tmpfile = xasprintf("%s.tmp%ld", pidfile, pid);
 160         fatal_signal_add_file_to_unlink(tmpfile);
 161         fd = open(tmpfile, O_CREAT | O_WRONLY | O_TRUNC, 0666);
 162         if (fd >= 0) {
 163             struct flock lck;
 164             lck.l_type = F_WRLCK;
 165             lck.l_whence = SEEK_SET;
 166             lck.l_start = 0;
 167             lck.l_len = 0;
 168             if (fcntl(fd, F_SETLK, &lck) != -1) {
 169                 char *text = xasprintf("%ld\n", pid);
 170                 if (write(fd, text, strlen(text)) == strlen(text)) {
 171                     fatal_signal_add_file_to_unlink(pidfile);
 172                     if (rename(tmpfile, pidfile) < 0) {
 173                         VLOG_ERR("failed to rename \"%s\" to \"%s\": %s",
 174                                  tmpfile, pidfile, strerror(errno));
 175                         fatal_signal_remove_file_to_unlink(pidfile);
 176                         close(fd);
 177                     } else {
 178                         /* Keep 'fd' open to retain the lock. */
 179                     }
 180                 } else {
 181                     VLOG_ERR("%s: write failed: %s", tmpfile, strerror(errno));
 182                     close(fd);
 183                 }
 184             } else {
 185                 VLOG_ERR("%s: fcntl failed: %s", tmpfile, strerror(errno));
 186                 close(fd);
 187             }
 188         } else {
 189             VLOG_ERR("%s: create failed: %s", tmpfile, strerror(errno));
 190         }
 191         fatal_signal_remove_file_to_unlink(tmpfile);
 192         free(tmpfile);
 193     }
 194     free(pidfile);
 195     pidfile = NULL;
 196 }
 197
 198 /* If configured with set_pidfile() or set_detach(), creates the pid file and
 199  * detaches from the foreground session.  */
 200 void
 201 daemonize(void)
 202 {
 203     if (detach) {
 204         char c = 0;
 205         int fds[2];
 206         if (pipe(fds) < 0) {
 207             ofp_fatal(errno, "pipe failed");
 208         }
 209
 210         switch (fork()) {
 211         default:
 212             /* Parent process: wait for child to create pidfile, then exit. */
 213             close(fds[1]);
 214             fatal_signal_fork();
 215             read(fds[0], &c, 1);
 216             exit(0);
 217
 218         case 0:
 219             /* Child process. */
 220             close(fds[0]);
 221             make_pidfile();
 222             write(fds[1], &c, 1);
 223             close(fds[1]);
 224             setsid();
 225             chdir("/");
 226             break;
 227
 228         case -1:
 229             /* Error. */
 230             ofp_fatal(errno, "could not fork");
 231             break;
 232         }
 233     } else {
 234         make_pidfile();
 235     }
 236 }
 237