-# Copyright (c) 2010 Nicira Networks
+# Copyright (c) 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.
# --pidfile: Name of pidfile (null if none).
_pidfile = None
+# Our pidfile's inode and device, if we have created one.
+_pidfile_dev = None
+_pidfile_ino = None
+
# --overwrite-pidfile: Create pidfile even if one already exists and is locked?
_overwrite_pidfile = False
# File descriptor used by daemonize_start() and daemonize_complete().
_daemonize_fd = None
+RESTART_EXIT_CODE = 5
+
+
def make_pidfile_name(name):
"""Returns the file name that would be used for a pidfile if 'name' were
provided to set_pidfile()."""
else:
return ovs.util.abs_file_name(ovs.dirs.RUNDIR, name)
+
def set_pidfile(name):
"""Sets up a following call to daemonize() to create a pidfile named
'name'. If 'name' begins with '/', then it is treated as an absolute path.
Otherwise, it is taken relative to ovs.util.RUNDIR, which is
$(prefix)/var/run by default.
-
+
If 'name' is null, then ovs.util.PROGRAM_NAME followed by ".pid" is
used."""
global _pidfile
_pidfile = make_pidfile_name(name)
+
def get_pidfile():
"""Returns an absolute path to the configured pidfile, or None if no
- pidfile is configured. The caller must not modify or free the returned
- string."""
+ pidfile is configured."""
return _pidfile
+
def set_no_chdir():
"""Sets that we do not chdir to "/"."""
global _chdir
_chdir = False
+
def is_chdir_enabled():
"""Will we chdir to "/" as part of daemonizing?"""
return _chdir
+
def ignore_existing_pidfile():
- """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."""
+ """Normally, daemonize() or daemonize_start() will terminate the program
+ with a message if a locked pidfile already exists. If this function is
+ called, an existing pidfile will be replaced, with a warning."""
global _overwrite_pidfile
_overwrite_pidfile = True
+
def set_detach():
"""Sets up a following call to daemonize() to detach from the foreground
session, running this process in the background."""
global _detach
_detach = True
+
def get_detach():
"""Will daemonize() really detach?"""
return _detach
+
def set_monitor():
"""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."""
global _monitor
_monitor = True
-def _already_running():
- """If a pidfile has been configured and that pidfile already exists and is
- locked by a running process, returns True. Otherwise, returns False."""
- if _pidfile is not None:
- try:
- file = open(_pidfile, "r+")
- try:
- try:
- fcntl.lockf(file, fcntl.LOCK_EX | fcntl.LOCK_NB)
- except IOError, e:
- if e.errno in [errno.EACCES, errno.EAGAIN]:
- return True
- logging.error("error locking %s (%s)"
- % (_pidfile, os.strerror(e.errno)))
- return False
- finally:
- # This releases the lock, which we don't really want.
- file.close()
- except IOError, e:
- if e.errno == errno.ENOENT:
- return False
- logging.error("error opening %s (%s)"
- % (_pidfile, os.strerror(e.errno)))
- return False
-def die_if_already_running():
- """If a locked pidfile exists, issue a warning message and, unless
- ignore_existing_pidfile() has been called, terminate the program."""
- if _already_running():
- if not _overwrite_pidfile:
- sys.stderr.write("%s: already running\n" % get_pidfile())
- sys.exit(1)
- else:
- logging.warn("%s: %s already running"
- % (get_pidfile(), ovs.util.PROGRAM_NAME))
+def _fatal(msg):
+ logging.error(msg)
+ sys.stderr.write("%s\n" % msg)
+ sys.exit(1)
+
def _make_pidfile():
"""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."""
- if _pidfile is not None:
- # Create pidfile via temporary file, so that observers never see an
- # empty pidfile or an unlocked pidfile.
- pid = os.getpid()
- tmpfile = "%s.tmp%d" % (_pidfile, pid)
- ovs.fatal_signal.add_file_to_unlink(tmpfile)
+ pid = os.getpid()
- try:
- # This is global to keep Python from garbage-collecting and
- # therefore closing our file after this function exits. That would
- # unlock the lock for us, and we don't want that.
- global file
+ # Create a temporary pidfile.
+ tmpfile = "%s.tmp%d" % (_pidfile, pid)
+ ovs.fatal_signal.add_file_to_unlink(tmpfile)
+ try:
+ # This is global to keep Python from garbage-collecting and
+ # therefore closing our file after this function exits. That would
+ # unlock the lock for us, and we don't want that.
+ global file
- file = open(tmpfile, "w")
- except IOError, e:
- logging.error("%s: create failed: %s"
- % (tmpfile, os.strerror(e.errno)))
- return
-
- try:
- fcntl.lockf(file, fcntl.LOCK_EX | fcntl.LOCK_NB)
- except IOError, e:
- logging.error("%s: fcntl failed: %s"
- % (tmpfile, os.strerror(e.errno)))
- file.close()
- return
+ file_handle = open(tmpfile, "w")
+ except IOError, e:
+ _fatal("%s: create failed (%s)" % (tmpfile, e.strerror))
- try:
- file.write("%s\n" % pid)
- file.flush()
- ovs.fatal_signal.add_file_to_unlink(_pidfile)
- except OSError, e:
- logging.error("%s: write failed: %s"
- % (tmpfile, os.strerror(e.errno)))
- file.close()
- return
-
+ try:
+ s = os.fstat(file_handle.fileno())
+ except IOError, e:
+ _fatal("%s: fstat failed (%s)" % (tmpfile, e.strerror))
+
+ try:
+ file_handle.write("%s\n" % pid)
+ file_handle.flush()
+ except OSError, e:
+ _fatal("%s: write failed: %s" % (tmpfile, e.strerror))
+
+ try:
+ fcntl.lockf(file_handle, fcntl.LOCK_EX | fcntl.LOCK_NB)
+ except IOError, e:
+ _fatal("%s: fcntl failed: %s" % (tmpfile, e.strerror))
+
+ # Rename or link it to the correct name.
+ if _overwrite_pidfile:
try:
os.rename(tmpfile, _pidfile)
except OSError, e:
- ovs.fatal_signal.remove_file_to_unlink(_pidfile)
- logging.error("failed to rename \"%s\" to \"%s\": %s"
- % (tmpfile, _pidfile, os.strerror(e.errno)))
- file.close()
- return
+ _fatal("failed to rename \"%s\" to \"%s\" (%s)"
+ % (tmpfile, _pidfile, e.strerror))
+ else:
+ while True:
+ try:
+ os.link(tmpfile, _pidfile)
+ error = 0
+ except OSError, e:
+ error = e.errno
+ if error == errno.EEXIST:
+ _check_already_running()
+ elif error != errno.EINTR:
+ break
+ if error:
+ _fatal("failed to link \"%s\" as \"%s\" (%s)"
+ % (tmpfile, _pidfile, os.strerror(error)))
+
+ # Ensure that the pidfile will get deleted on exit.
+ ovs.fatal_signal.add_file_to_unlink(_pidfile)
+
+ # Delete the temporary pidfile if it still exists.
+ if not _overwrite_pidfile:
+ error = ovs.fatal_signal.unlink_file_now(tmpfile)
+ if error:
+ _fatal("%s: unlink failed (%s)" % (tmpfile, os.strerror(error)))
+
+ global _pidfile_dev
+ global _pidfile_ino
+ _pidfile_dev = s.st_dev
+ _pidfile_ino = s.st_ino
+
def daemonize():
"""If configured with set_pidfile() or set_detach(), creates the pid file
daemonize_start()
daemonize_complete()
+
def _waitpid(pid, options):
while True:
try:
pass
return -e.errno, 0
+
def _fork_and_wait_for_startup():
try:
rfd, wfd = os.pipe()
# Running in parent process.
os.close(wfd)
ovs.fatal_signal.fork()
- try:
- s = os.read(rfd, 1)
- except OSError, e:
- s = ""
+ while True:
+ try:
+ s = os.read(rfd, 1)
+ error = 0
+ except OSError, e:
+ s = ""
+ error = e.errno
+ if error != errno.EINTR:
+ break
if len(s) != 1:
retval, status = _waitpid(pid, 0)
if (retval == pid and
_daemonize_fd = wfd
return pid
+
def _fork_notify_startup(fd):
if fd is not None:
error, bytes_written = ovs.socket_util.write_fully(fd, "0")
sys.exit(1)
os.close(fd)
+
def _should_restart(status):
+ global RESTART_EXIT_CODE
+
+ if os.WIFEXITED(status) and os.WEXITSTATUS(status) == RESTART_EXIT_CODE:
+ return True
+
if os.WIFSIGNALED(status):
for signame in ("SIGABRT", "SIGALRM", "SIGBUS", "SIGFPE", "SIGILL",
"SIGPIPE", "SIGSEGV", "SIGXCPU", "SIGXFSZ"):
- if (signame in signal.__dict__ and
- os.WTERMSIG(status) == signal.__dict__[signame]):
+ if os.WTERMSIG(status) == getattr(signal, signame, None):
return True
return False
+
def _monitor_daemon(daemon_pid):
# XXX should log daemon's stderr output at startup time
# XXX should use setproctitle module if available
elif retval == daemon_pid:
status_msg = ("pid %d died, %s"
% (daemon_pid, ovs.process.status_msg(status)))
-
+
if _should_restart(status):
if os.WCOREDUMP(status):
# Disable further core dumps to save disk space.
# Running in new daemon process.
+
def _close_standard_fds():
"""Close stdin, stdout, stderr. If we're started from e.g. an SSH session,
then this keeps us from holding that session open artificially."""
os.dup2(null_fd, 1)
os.dup2(null_fd, 2)
+
def daemonize_start():
"""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)."""
-
+
if _detach:
if _fork_and_wait_for_startup() > 0:
# Running in parent process.
_close_standard_fds()
_monitor_daemon(daemon_pid)
# Running in daemon process
-
- _make_pidfile()
+
+ if _pidfile:
+ _make_pidfile()
+
def daemonize_complete():
"""If daemonization is configured, then this function notifies the parent
os.chdir("/")
_close_standard_fds()
+
def usage():
sys.stdout.write("""
Daemon options:
--overwrite-pidfile with --pidfile, start even if already running
""" % (ovs.dirs.RUNDIR, ovs.util.PROGRAM_NAME))
-def read_pidfile(pidfile):
- """Opens and reads a PID from 'pidfile'. Returns the nonnegative PID if
- successful, otherwise a negative errno value."""
+
+def __read_pidfile(pidfile, delete_if_stale):
+ if _pidfile_dev is not None:
+ try:
+ s = os.stat(pidfile)
+ if s.st_ino == _pidfile_ino and 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 os.getpid()
+ except OSError:
+ pass
+
try:
- file = open(pidfile, "r")
+ file_handle = open(pidfile, "r+")
except IOError, e:
- logging.warning("%s: open: %s" % (pidfile, os.strerror(e.errno)))
+ if e.errno == errno.ENOENT and delete_if_stale:
+ return 0
+ logging.warning("%s: open: %s" % (pidfile, e.strerror))
return -e.errno
# Python fcntl doesn't directly support F_GETLK so we have to just try
- # to lock it. If we get a conflicting lock that's "success"; otherwise
- # the file is not locked.
+ # to lock it.
try:
- fcntl.lockf(file, fcntl.LOCK_EX | fcntl.LOCK_NB)
- # File isn't locked if we get here, so treat that as an error.
- logging.warning("%s: pid file is not locked" % pidfile)
+ fcntl.lockf(file_handle, fcntl.LOCK_EX | fcntl.LOCK_NB)
+
+ # pidfile exists but wasn't locked by anyone. Now we have the lock.
+ if not delete_if_stale:
+ file_handle.close()
+ logging.warning("%s: pid file is stale" % pidfile)
+ return -errno.ESRCH
+
+ # Is the file we have locked still named 'pidfile'?
try:
- # As a side effect, this drops the lock.
- file.close()
+ raced = False
+ s = os.stat(pidfile)
+ s2 = os.fstat(file_handle.fileno())
+ if s.st_ino != s2.st_ino or s.st_dev != s2.st_dev:
+ raced = True
except IOError:
- pass
- return -errno.ESRCH
+ raced = True
+ if raced:
+ logging.warning("%s: lost race to delete pidfile" % pidfile)
+ return -errno.EALREADY
+
+ # We won the right to delete the stale pidfile.
+ try:
+ os.unlink(pidfile)
+ except IOError, e:
+ logging.warning("%s: failed to delete stale pidfile (%s)"
+ % (pidfile, e.strerror))
+ return -e.errno
+ else:
+ logging.debug("%s: deleted stale pidfile" % pidfile)
+ file_handle.close()
+ return 0
except IOError, e:
if e.errno not in [errno.EACCES, errno.EAGAIN]:
- logging.warn("%s: fcntl: %s" % (pidfile, os.strerror(e.errno)))
+ logging.warn("%s: fcntl: %s" % (pidfile, e.strerror))
return -e.errno
+ # Someone else has the pidfile locked.
try:
try:
- return int(file.readline())
+ error = int(file_handle.readline())
except IOError, e:
logging.warning("%s: read: %s" % (pidfile, e.strerror))
- return -e.errno
+ error = -e.errno
except ValueError:
logging.warning("%s does not contain a pid" % pidfile)
- return -errno.EINVAL
+ error = -errno.EINVAL
+
+ return error
finally:
try:
- file.close()
+ file_handle.close()
except IOError:
pass
-# XXX Python's getopt does not support options with optional arguments, so we
-# have to separate --pidfile (with no argument) from --pidfile-name (with an
-# argument). Need to write our own getopt I guess.
-LONG_OPTIONS = ["detach", "no-chdir", "pidfile", "pidfile-name=",
- "overwrite-pidfile", "monitor"]
-def parse_opt(option, arg):
- if option == '--detach':
+def read_pidfile(pidfile):
+ """Opens and reads a PID from 'pidfile'. Returns the positive PID if
+ successful, otherwise a negative errno value."""
+ return __read_pidfile(pidfile, False)
+
+
+def _check_already_running():
+ pid = __read_pidfile(_pidfile, True)
+ if pid > 0:
+ _fatal("%s: already running as pid %d, aborting" % (_pidfile, pid))
+ elif pid < 0:
+ _fatal("%s: pidfile check failed (%s), aborting"
+ % (_pidfile, os.strerror(pid)))
+
+
+def add_args(parser):
+ """Populates 'parser', an ArgumentParser allocated using the argparse
+ module, with the command line arguments required by the daemon module."""
+
+ pidfile = make_pidfile_name(None)
+
+ group = parser.add_argument_group(title="Daemon Options")
+ group.add_argument("--detach", action="store_true",
+ help="Run in background as a daemon.")
+ group.add_argument("--no-chdir", action="store_true",
+ help="Do not chdir to '/'.")
+ group.add_argument("--monitor", action="store_true",
+ help="Monitor %s process." % ovs.util.PROGRAM_NAME)
+ group.add_argument("--pidfile", nargs="?", default=pidfile,
+ help="Create pidfile (default %s)." % pidfile)
+ group.add_argument("--overwrite-pidfile", action="store_true",
+ help="With --pidfile, start even if already running.")
+
+
+def handle_args(args):
+ """Handles daemon module settings in 'args'. 'args' is an object
+ containing values parsed by the parse_args() method of ArgumentParser. The
+ parent ArgumentParser should have been prepared by add_args() before
+ calling parse_args()."""
+
+ if args.detach:
set_detach()
- elif option == '--no-chdir':
+
+ if args.no_chdir:
set_no_chdir()
- elif option == '--pidfile':
- set_pidfile(None)
- elif option == '--pidfile-name':
- set_pidfile(arg)
- elif option == '--overwrite-pidfile':
+
+ if args.pidfile:
+ set_pidfile(args.pidfile)
+
+ if args.overwrite_pidfile:
ignore_existing_pidfile()
- elif option == '--monitor':
+
+ if args.monitor:
set_monitor()
- else:
- return False
- return True
git://git.onelab.eu / sliver-openvswitch.git / blobdiff