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