X-Git-Url: http://git.onelab.eu/?a=blobdiff_plain;f=lib%2Fdaemon.c;h=64e2f9e9ab769229719f82057c84299952ef9e56;hb=a328a943f173391cd9a9a54e257c8dabcd463402;hp=6b61879dbb76723a926dea8683716bc39eaacca7;hpb=cbbdf81cf8bfcc87e141f66b93bf3bcf1220bff8;p=sliver-openvswitch.git diff --git a/lib/daemon.c b/lib/daemon.c index 6b61879db..64e2f9e9a 100644 --- a/lib/daemon.c +++ b/lib/daemon.c @@ -1,5 +1,5 @@ /* - * Copyright (c) 2008, 2009, 2010 Nicira Networks. + * Copyright (c) 2008, 2009, 2010, 2011 Nicira Networks. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -23,6 +23,7 @@ #include #include #include +#include #include #include "command-line.h" #include "fatal-signal.h" @@ -34,7 +35,7 @@ #include "util.h" #include "vlog.h" -VLOG_DEFINE_THIS_MODULE(daemon) +VLOG_DEFINE_THIS_MODULE(daemon); /* --detach: Should we run in the background? */ static bool detach; @@ -42,6 +43,10 @@ static bool detach; /* --pidfile: Name of pidfile (null if none). */ static char *pidfile; +/* Device and inode of pidfile, so we can avoid reopening it. */ +static dev_t pidfile_dev; +static ino_t pidfile_ino; + /* --overwrite-pidfile: Create pidfile even if one already exists and is locked? */ static bool overwrite_pidfile; @@ -62,8 +67,8 @@ char * make_pidfile_name(const char *name) { return (!name - ? xasprintf("%s/%s.pid", ovs_rundir, program_name) - : abs_file_name(ovs_rundir, 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'. @@ -134,38 +139,20 @@ 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. */ -static pid_t -already_running(void) -{ - pid_t pid = 0; - if (pidfile) { - int fd = open(pidfile, O_RDWR); - if (fd >= 0) { - struct flock lck; - lck.l_type = F_WRLCK; - lck.l_whence = SEEK_SET; - lck.l_start = 0; - lck.l_len = 0; - if (fcntl(fd, F_GETLK, &lck) != -1 && lck.l_type != F_UNLCK) { - pid = lck.l_pid; - } - close(fd); - } - } - return pid; -} - /* If a locked pidfile exists, issue a warning message and, unless * ignore_existing_pidfile() has been called, terminate the program. */ void die_if_already_running(void) { - pid_t pid = already_running(); - if (pid) { + pid_t pid; + if (!pidfile) { + return; + } + pid = read_pidfile_if_exists(pidfile); + if (pid > 0) { if (!overwrite_pidfile) { + VLOG_ERR("%s: %s already running as pid %ld, aborting", + get_pidfile(), program_name, (long int) pid); ovs_fatal(0, "%s: already running as pid %ld", get_pidfile(), (long int) pid); } else { @@ -208,12 +195,21 @@ make_pidfile(void) close(fd); } else { /* Keep 'fd' open to retain the lock. */ + struct stat s; + + if (!fstat(fd, &s)) { + pidfile_dev = s.st_dev; + pidfile_ino = s.st_ino; + } else { + VLOG_ERR("%s: fstat failed: %s", + pidfile, strerror(errno)); + } } - free(text); } else { VLOG_ERR("%s: write failed: %s", tmpfile, strerror(errno)); close(fd); } + free(text); } else { VLOG_ERR("%s: fcntl failed: %s", tmpfile, strerror(errno)); close(fd); @@ -243,9 +239,7 @@ fork_and_wait_for_startup(int *fdp) int fds[2]; pid_t pid; - if (pipe(fds) < 0) { - ovs_fatal(errno, "pipe failed"); - } + xpipe(fds); pid = fork(); if (pid > 0) { @@ -270,7 +264,8 @@ fork_and_wait_for_startup(int *fdp) exit(WEXITSTATUS(status)); } - ovs_fatal(errno, "fork child failed to signal startup"); + VLOG_FATAL("fork child failed to signal startup (%s)", + strerror(errno)); } close(fds[0]); *fdp = -1; @@ -281,7 +276,7 @@ fork_and_wait_for_startup(int *fdp) lockfile_postfork(); *fdp = fds[1]; } else { - ovs_fatal(errno, "could not fork"); + VLOG_FATAL("fork failed (%s)", strerror(errno)); } return pid; @@ -296,7 +291,7 @@ fork_notify_startup(int fd) error = write_fully(fd, "", 1, &bytes_written); if (error) { - ovs_fatal(error, "could not write to pipe"); + VLOG_FATAL("pipe write failed (%s)", strerror(error)); } close(fd); @@ -350,16 +345,16 @@ monitor_daemon(pid_t daemon_pid) } while (retval == -1 && errno == EINTR); if (retval == -1) { - ovs_fatal(errno, "waitpid failed"); + VLOG_FATAL("waitpid failed (%s)", strerror(errno)); } else if (retval == daemon_pid) { char *s = process_status_msg(status); - free(status_msg); - status_msg = xasprintf("%d crashes: pid %lu died, %s", - ++crashes, - (unsigned long int) daemon_pid, s); - free(s); - if (should_restart(status)) { + free(status_msg); + status_msg = xasprintf("%d crashes: pid %lu died, %s", + ++crashes, + (unsigned long int) daemon_pid, s); + free(s); + if (WCOREDUMP(status)) { /* Disable further core dumps to save disk space. */ struct rlimit r; @@ -393,7 +388,9 @@ monitor_daemon(pid_t daemon_pid) break; } } else { - VLOG_INFO("%s, exiting", status_msg); + VLOG_INFO("pid %lu died, %s, exiting", + (unsigned long int) daemon_pid, s); + free(s); exit(0); } } @@ -459,11 +456,14 @@ daemonize_start(void) } /* If daemonization is configured, then this function notifies the parent - * process that the child process has completed startup successfully. */ + * process that the child process has completed startup successfully. + * + * Calling this function more than once has no additional effect. */ void daemonize_complete(void) { fork_notify_startup(daemonize_fd); + daemonize_fd = -1; if (detach) { setsid(); @@ -471,6 +471,7 @@ daemonize_complete(void) ignore(chdir("/")); } close_standard_fds(); + detach = false; } } @@ -484,21 +485,34 @@ daemon_usage(void) " --pidfile[=FILE] create pidfile (default: %s/%s.pid)\n" " --overwrite-pidfile with --pidfile, start even if already " "running\n", - ovs_rundir, program_name); + ovs_rundir(), program_name); } -/* Opens and reads a PID from 'pidfile'. Returns the nonnegative PID if - * successful, otherwise a negative errno value. */ -pid_t -read_pidfile(const char *pidfile) +static pid_t +read_pidfile__(const char *pidfile, bool must_exist) { char line[128]; struct flock lck; + struct stat s; FILE *file; int error; + if ((pidfile_ino || pidfile_dev) + && !stat(pidfile, &s) + && s.st_ino == pidfile_ino && s.st_dev == pidfile_dev) { + /* It's our own pidfile. We can't afford to open it, because closing + * *any* fd for a file that a process has locked also releases all the + * locks on that file. + * + * Fortunately, we know the associated pid anyhow: */ + return getpid(); + } + file = fopen(pidfile, "r"); if (!file) { + if (errno == ENOENT && !must_exist) { + return 0; + } error = errno; VLOG_WARN("%s: open: %s", pidfile, strerror(error)); goto error; @@ -508,6 +522,7 @@ read_pidfile(const char *pidfile) lck.l_whence = SEEK_SET; lck.l_start = 0; lck.l_len = 0; + lck.l_pid = 0; if (fcntl(fileno(file), F_GETLK, &lck)) { error = errno; VLOG_WARN("%s: fcntl: %s", pidfile, strerror(error)); @@ -546,3 +561,21 @@ error: } return -error; } + +/* Opens and reads a PID from 'pidfile'. Returns the positive PID if + * successful, otherwise a negative errno value. */ +pid_t +read_pidfile(const char *pidfile) +{ + return read_pidfile__(pidfile, true); +} + + +/* Opens and reads a PID from 'pidfile', if it exists. Returns 0 if 'pidfile' + * doesn't exist, the positive PID if successful, otherwise a negative errno + * value. */ +pid_t +read_pidfile_if_exists(const char *pidfile) +{ + return read_pidfile__(pidfile, false); +}