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 /* Returns the file name that would be used for a pidfile if 'name' were
  54  * provided to set_pidfile().  The caller must free the returned string. */
  55 char *
  56 make_pidfile_name(const char *name)
  57 {
  58     return (!name ? xasprintf("%s/%s.pid", RUNDIR, program_name)
  59             : *name == '/' ? xstrdup(name)
  60             : xasprintf("%s/%s", RUNDIR, name));
  61 }
  62
  63 /* Sets up a following call to daemonize() to create a pidfile named 'name'.
  64  * If 'name' begins with '/', then it is treated as an absolute path.
  65  * Otherwise, it is taken relative to RUNDIR, which is $(prefix)/var/run by
  66  * default.
  67  *
  68  * If 'name' is null, then program_name followed by ".pid" is used. */
  69 void
  70 set_pidfile(const char *name)
  71 {
  72     free(pidfile);
  73     pidfile = make_pidfile_name(name);
  74 }
  75
  76 /* Sets up a following call to daemonize() to detach from the foreground
  77  * session, running this process in the background.  */
  78 void
  79 set_detach(void)
  80 {
  81     detach = true;
  82 }
  83
  84 /* If a pidfile has been configured, creates it and stores the running process'
  85  * pid init.  Ensures that the pidfile will be deleted when the process
  86  * exits. */
  87 static void
  88 make_pidfile(void)
  89 {
  90     if (pidfile) {
  91         /* Create pidfile via temporary file, so that observers never see an
  92          * empty pidfile or an unlocked pidfile. */
  93         long int pid = getpid();
  94         char *tmpfile;
  95         int fd;
  96
  97         tmpfile = xasprintf("%s.tmp%ld", pidfile, pid);
  98         fatal_signal_add_file_to_unlink(tmpfile);
  99         fd = open(tmpfile, O_CREAT | O_WRONLY | O_TRUNC, 0666);
 100         if (fd >= 0) {
 101             struct flock lck;
 102             lck.l_type = F_WRLCK;
 103             lck.l_whence = SEEK_SET;
 104             lck.l_start = 0;
 105             lck.l_len = 0;
 106             if (fcntl(fd, F_SETLK, &lck) != -1) {
 107                 char *text = xasprintf("%ld\n", pid);
 108                 if (write(fd, text, strlen(text)) == strlen(text)) {
 109                     fatal_signal_add_file_to_unlink(pidfile);
 110                     if (rename(tmpfile, pidfile) < 0) {
 111                         VLOG_ERR("failed to rename \"%s\" to \"%s\": %s",
 112                                  tmpfile, pidfile, strerror(errno));
 113                         fatal_signal_remove_file_to_unlink(pidfile);
 114                         close(fd);
 115                     } else {
 116                         /* Keep 'fd' open to retain the lock. */
 117                     }
 118                 } else {
 119                     VLOG_ERR("%s: write failed: %s", tmpfile, strerror(errno));
 120                     close(fd);
 121                 }
 122             } else {
 123                 VLOG_ERR("%s: fcntl failed: %s", tmpfile, strerror(errno));
 124                 close(fd);
 125             }
 126         } else {
 127             VLOG_ERR("%s: create failed: %s", tmpfile, strerror(errno));
 128         }
 129         fatal_signal_remove_file_to_unlink(tmpfile);
 130         free(tmpfile);
 131     }
 132     free(pidfile);
 133     pidfile = NULL;
 134 }
 135
 136 /* If configured with set_pidfile() or set_detach(), creates the pid file and
 137  * detaches from the foreground session.  */
 138 void
 139 daemonize(void)
 140 {
 141     if (detach) {
 142         char c = 0;
 143         int fds[2];
 144         if (pipe(fds) < 0) {
 145             fatal(errno, "pipe failed");
 146         }
 147
 148         switch (fork()) {
 149         default:
 150             /* Parent process: wait for child to create pidfile, then exit. */
 151             close(fds[1]);
 152             fatal_signal_fork();
 153             read(fds[0], &c, 1);
 154             exit(0);
 155
 156         case 0:
 157             /* Child process. */
 158             close(fds[0]);
 159             make_pidfile();
 160             write(fds[1], &c, 1);
 161             close(fds[1]);
 162             setsid();
 163             chdir("/");
 164             break;
 165
 166         case -1:
 167             /* Error. */
 168             fatal(errno, "could not fork");
 169             break;
 170         }
 171     } else {
 172         make_pidfile();
 173     }
 174 }
 175