[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]

[Libguestfs] [PATCH nbdkit] New filter: exitwhen: exit gracefully when an event occurs.



---
 docs/nbdkit-captive.pod                       |   6 +-
 docs/nbdkit-service.pod                       |   1 +
 filters/exitlast/nbdkit-exitlast-filter.pod   |   3 +
 filters/exitwhen/nbdkit-exitwhen-filter.pod   | 156 ++++++
 filters/ip/nbdkit-ip-filter.pod               |   1 +
 filters/limit/nbdkit-limit-filter.pod         |   1 +
 filters/rate/nbdkit-rate-filter.pod           |   1 +
 configure.ac                                  |   2 +
 filters/exitwhen/Makefile.am                  |  67 +++
 tests/Makefile.am                             |  24 +
 filters/exitwhen/exitwhen.c                   | 473 ++++++++++++++++++
 tests/test-exitwhen-file-already-created.sh   |  45 ++
 .../test-exitwhen-file-created-reject-new.sh  |  88 ++++
 tests/test-exitwhen-file-created-when-idle.sh |  63 +++
 tests/test-exitwhen-file-created.sh           |  91 ++++
 tests/test-exitwhen-file-deleted.sh           |  68 +++
 tests/test-exitwhen-process-exits.sh          |  69 +++
 tests/test-exitwhen-script.sh                 |  70 +++
 tests/test-exitwhen-pipe-closed.c             |  81 +++
 .gitignore                                    |   1 +
 20 files changed, 1309 insertions(+), 2 deletions(-)

diff --git a/docs/nbdkit-captive.pod b/docs/nbdkit-captive.pod
index 472f1951..0de963bc 100644
--- a/docs/nbdkit-captive.pod
+++ b/docs/nbdkit-captive.pod
@@ -15,8 +15,9 @@ You can run nbdkit under another process and have nbdkit reliably
 clean up.  There are two techniques depending on whether you want
 nbdkit to start the other process (L</CAPTIVE NBDKIT>), or if you want
 the other process to start nbdkit (L</EXIT WITH PARENT>).  Another way
-is to have nbdkit exit after the last client connection, see
-L<nbdkit-exitlast-filter(1)>.
+is to have nbdkit exit after the last client connection
+(L<nbdkit-exitlast-filter(1)>) or after an event
+(L<nbdkit-exitwhen-filter(1)>).
 
 =head1 CAPTIVE NBDKIT
 
@@ -154,6 +155,7 @@ reliably on all operating systems).
 
 L<nbdkit(1)>,
 L<nbdkit-exitlast-filter(1)>,
+L<nbdkit-exitwhen-filter(1)>,
 L<prctl(2)> (on Linux),
 L<procctl(2)> (on FreeBSD).
 
diff --git a/docs/nbdkit-service.pod b/docs/nbdkit-service.pod
index 42fbedd8..cd76ef52 100644
--- a/docs/nbdkit-service.pod
+++ b/docs/nbdkit-service.pod
@@ -145,6 +145,7 @@ L</SOCKET ACTIVATION>.
 L<nbdkit(1)>,
 L<nbdkit-client(1)>,
 L<nbdkit-exitlast-filter(1)>,
+L<nbdkit-exitwhen-filter(1)>,
 L<nbdkit-ip-filter(1)>,
 L<nbdkit-limit-filter(1)>,
 L<systemd(1)>,
diff --git a/filters/exitlast/nbdkit-exitlast-filter.pod b/filters/exitlast/nbdkit-exitlast-filter.pod
index 207ad4c8..1791d2cf 100644
--- a/filters/exitlast/nbdkit-exitlast-filter.pod
+++ b/filters/exitlast/nbdkit-exitlast-filter.pod
@@ -17,6 +17,8 @@ resources when nbdkit is not in use (see L<nbdkit-service(1)>).
 Another use is to ensure nbdkit exits after the client has finished
 (but see also nbdkit-captive(1) for other ways to do this).
 
+To exit when an event occurs, try L<nbdkit-exitwhen-filter(1)>.
+
 =head1 PARAMETERS
 
 There are no parameters specific to nbdkit-exitlast-filter.  Any
@@ -42,6 +44,7 @@ C<nbdkit-exitlast-filter> first appeared in nbdkit 1.20.
 =head1 SEE ALSO
 
 L<nbdkit(1)>,
+L<nbdkit-exitwhen-filter(1)>,
 L<nbdkit-ip-filter(1)>,
 L<nbdkit-limit-filter(1)>,
 L<nbdkit-rate-filter(1)>,
diff --git a/filters/exitwhen/nbdkit-exitwhen-filter.pod b/filters/exitwhen/nbdkit-exitwhen-filter.pod
new file mode 100644
index 00000000..b9c51561
--- /dev/null
+++ b/filters/exitwhen/nbdkit-exitwhen-filter.pod
@@ -0,0 +1,156 @@
+=head1 NAME
+
+nbdkit-exitwhen-filter - exit gracefully when an event occurs
+
+=head1 SYNOPSIS
+
+ nbdkit --filter=exitwhen PLUGIN
+                          [exit-when-file-created=FILENAME]
+                          [exit-when-file-deleted=FILENAME]
+                          [exit-when-pipe-closed=FD]
+                          [exit-when-process-exits=PID]
+                          [exit-when-script=SCRIPT]
+                          [exit-when-poll=SECS]
+
+=head1 DESCRIPTION
+
+C<nbdkit-exitwhen-filter> is an nbdkit filter that causes nbdkit to
+exit gracefully when some external event occurs.  Built-in events are:
+a file being created or deleted, a pipe being closed, or a process
+exiting.  You can also define custom events using an external script
+or command.
+
+After the event occurs nbdkit refuses new connections, waits for all
+current clients to disconnect, and then exits.
+
+A similar filter is L<nbdkit-exitlast-filter(1)>.  For other ways to
+ensure that nbdkit exits when you want see L<nbdkit-captive(1)> and
+L<nbdkit-service(1)>.
+
+=head1 EXAMPLES
+
+ nbdkit --filter=exitwhen memory 1G exit-when-file-created=/tmp/stop
+
+nbdkit will run normally until something creates F</tmp/stop>,
+whereupon nbdkit will refuse new connections and exit as soon as the
+last client has disconnected.  If F</tmp/stop> exists before nbdkit
+starts, it will exit immediately.
+
+ nbdkit --filter=exitwhen memory 1G exit-when-process-exits=1234
+
+nbdkit will exit gracefully when PID 1234 exits and all connections
+close.  If you want to exit when the parent process of nbdkit exits,
+consider using the I<--exit-with-parent> flag instead.
+
+=head1 PARAMETERS
+
+You can define multiple C<exit-when-*> events on the command line:
+nbdkit will exit if any of the events happens.  If there are no
+C<exit-when-*> events then the filter does nothing.
+
+=over 4
+
+=item B<exit-when-file-created=>FILENAME
+
+=item B<exit-when-file-deleted=>FILENAME
+
+Exit when the named file is created or deleted.
+
+=item B<exit-when-pipe-closed=>FD
+
+The read end of a L<pipe(2)> is passed to nbdkit in the given file
+descriptor number.  Exit when the pipe is closed.  The filter does not
+read any data from the pipe.
+
+=item B<exit-when-process-exits=>PID
+
+Exit when process ID C<PID> exits.
+
+Note there is a small race between passing the process ID to the
+filter and the filter checking it for the first time.  During this
+window the original PID might exit and an unrelated program might get
+the same PID, thus holding nbdkit open for longer than wanted.  The
+pipe method above is more reliable if you are able to modify the other
+process.
+
+=item B<exit-when-script=">SCRIPTB<">
+
+Create a custom event using the script or command C<SCRIPT>.  The
+C<SCRIPT> can be a program, shell script or a command with optional
+parameters.  Note if using a separate program or script that you may
+need to use the absolute path because nbdkit changes directory when it
+daemonizes.
+
+The script should exit with code 88 if the event is detected.  The
+filter does different things depending on the exit code of the script:
+
+=over 4
+
+=item C<0>
+
+I<The event has not been triggered>, so nbdkit continues to process
+requests as normal.
+
+=item C<1-87>
+
+An error is logged, but the event is I<not> triggered and nbdkit
+continues to process requests as normal.
+
+=item C<88>
+
+I<The event has been triggered>.  nbdkit will refuse new connections
+and exit gracefully as soon as all current clients disconnect.
+
+=item C<89->
+
+Exit codes 89 and above are reserved for future use.  The behaviour
+may change in future if scripts return any of these exit codes.
+
+=back
+
+=item B<exit-when-poll=>SECS
+
+When nbdkit is serving clients this filter does not need to poll
+because it can check for events when a client connects or disconnects.
+However when nbdkit is idle the filter needs to poll for events every
+C<SECS> seconds and if any event happens exit immediately.
+
+The default is 60 seconds.
+
+=back
+
+=head1 FILES
+
+=over 4
+
+=item F<$filterdir/nbdkit-exitwhen-filter.so>
+
+The filter.
+
+Use C<nbdkit --dump-config> to find the location of C<$filterdir>.
+
+=back
+
+=head1 VERSION
+
+C<nbdkit-exitwhen-filter> first appeared in nbdkit 1.24.
+
+=head1 SEE ALSO
+
+L<nbdkit(1)>,
+L<nbdkit-exitlast-filter(1)>,
+L<nbdkit-ip-filter(1)>,
+L<nbdkit-limit-filter(1)>,
+L<nbdkit-rate-filter(1)>,
+L<nbdkit-captive(1)>,
+L<nbdkit-service(1)>,
+L<nbdkit-filter(3)>,
+L<nbdkit-plugin(3)>.
+
+=head1 AUTHORS
+
+Richard W.M. Jones
+
+=head1 COPYRIGHT
+
+Copyright (C) 2020 Red Hat Inc.
diff --git a/filters/ip/nbdkit-ip-filter.pod b/filters/ip/nbdkit-ip-filter.pod
index 5d9e4616..48731a98 100644
--- a/filters/ip/nbdkit-ip-filter.pod
+++ b/filters/ip/nbdkit-ip-filter.pod
@@ -225,6 +225,7 @@ C<nbdkit-ip-filter> first appeared in nbdkit 1.18.
 
 L<nbdkit(1)>,
 L<nbdkit-exitlast-filter(1)>,
+L<nbdkit-exitwhen-filter(1)>,
 L<nbdkit-limit-filter(1)>,
 L<nbdkit-filter(3)>.
 
diff --git a/filters/limit/nbdkit-limit-filter.pod b/filters/limit/nbdkit-limit-filter.pod
index 434dde5c..5d211047 100644
--- a/filters/limit/nbdkit-limit-filter.pod
+++ b/filters/limit/nbdkit-limit-filter.pod
@@ -46,6 +46,7 @@ C<nbdkit-limit-filter> first appeared in nbdkit 1.20.
 
 L<nbdkit(1)>,
 L<nbdkit-exitlast-filter(1)>,
+L<nbdkit-exitwhen-filter(1)>,
 L<nbdkit-ip-filter(1)>,
 L<nbdkit-noparallel-filter(1)>,
 L<nbdkit-rate-filter(1)>,
diff --git a/filters/rate/nbdkit-rate-filter.pod b/filters/rate/nbdkit-rate-filter.pod
index 7aef4ec6..8956e641 100644
--- a/filters/rate/nbdkit-rate-filter.pod
+++ b/filters/rate/nbdkit-rate-filter.pod
@@ -130,6 +130,7 @@ L<nbdkit(1)>,
 L<nbdkit-blocksize-filter(1)>,
 L<nbdkit-delay-filter(1)>,
 L<nbdkit-exitlast-filter(1)>,
+L<nbdkit-exitwhen-filter(1)>,
 L<nbdkit-limit-filter(1)>,
 L<nbdkit-pause-filter(1)>,
 L<nbdkit-filter(3)>,
diff --git a/configure.ac b/configure.ac
index b4302dfc..ce7209da 100644
--- a/configure.ac
+++ b/configure.ac
@@ -104,6 +104,7 @@ filters="\
         delay \
         error \
         exitlast \
+        exitwhen \
 	exportname \
         ext2 \
         extentlist \
@@ -1228,6 +1229,7 @@ AC_CONFIG_FILES([Makefile
                  filters/delay/Makefile
                  filters/error/Makefile
                  filters/exitlast/Makefile
+                 filters/exitwhen/Makefile
                  filters/exportname/Makefile
                  filters/ext2/Makefile
                  filters/extentlist/Makefile
diff --git a/filters/exitwhen/Makefile.am b/filters/exitwhen/Makefile.am
new file mode 100644
index 00000000..dfef6abe
--- /dev/null
+++ b/filters/exitwhen/Makefile.am
@@ -0,0 +1,67 @@
+# nbdkit
+# Copyright (C) 2019-2020 Red Hat Inc.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+# * Redistributions of source code must retain the above copyright
+# notice, this list of conditions and the following disclaimer.
+#
+# * Redistributions in binary form must reproduce the above copyright
+# notice, this list of conditions and the following disclaimer in the
+# documentation and/or other materials provided with the distribution.
+#
+# * Neither the name of Red Hat nor the names of its contributors may be
+# used to endorse or promote products derived from this software without
+# specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY RED HAT AND CONTRIBUTORS ''AS IS'' AND
+# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+# THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+# PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL RED HAT OR
+# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
+# USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+# OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+# SUCH DAMAGE.
+
+include $(top_srcdir)/common-rules.mk
+
+EXTRA_DIST = nbdkit-exitwhen-filter.pod
+
+filter_LTLIBRARIES = nbdkit-exitwhen-filter.la
+
+nbdkit_exitwhen_filter_la_SOURCES = \
+	exitwhen.c \
+	$(top_srcdir)/include/nbdkit-filter.h \
+	$(NULL)
+
+nbdkit_exitwhen_filter_la_CPPFLAGS = \
+	-I$(top_srcdir)/include \
+	-I$(top_srcdir)/common/utils \
+	$(NULL)
+nbdkit_exitwhen_filter_la_CFLAGS = $(WARNINGS_CFLAGS)
+nbdkit_exitwhen_filter_la_LIBADD = \
+	$(top_builddir)/common/utils/libutils.la \
+	$(IMPORT_LIBRARY_ON_WINDOWS) \
+	$(NULL)
+nbdkit_exitwhen_filter_la_LDFLAGS = \
+	-module -avoid-version -shared $(NO_UNDEFINED_ON_WINDOWS) \
+	-Wl,--version-script=$(top_srcdir)/filters/filters.syms \
+	$(NULL)
+
+if HAVE_POD
+
+man_MANS = nbdkit-exitwhen-filter.1
+CLEANFILES += $(man_MANS)
+
+nbdkit-exitwhen-filter.1: nbdkit-exitwhen-filter.pod
+	$(PODWRAPPER) --section=1 --man $@ \
+	    --html $(top_builddir)/html/$  html \
+	    $<
+
+endif HAVE_POD
diff --git a/tests/Makefile.am b/tests/Makefile.am
index ee342cc4..071ac3b5 100644
--- a/tests/Makefile.am
+++ b/tests/Makefile.am
@@ -1382,6 +1382,30 @@ EXTRA_DIST += \
 TESTS += test-exitlast.sh
 EXTRA_DIST += test-exitlast.sh
 
+# exitwhen filter test.
+check_PROGRAMS += test-exitwhen-pipe-closed
+TESTS += \
+	test-exitwhen-file-already-created.sh \
+	test-exitwhen-file-created.sh \
+	test-exitwhen-file-created-reject-new.sh \
+	test-exitwhen-file-created-when-idle.sh \
+	test-exitwhen-file-deleted.sh \
+	test-exitwhen-pipe-closed \
+	test-exitwhen-process-exits.sh \
+	test-exitwhen-script.sh \
+	$(NULL)
+EXTRA_DIST += \
+	test-exitwhen-file-already-created.sh \
+	test-exitwhen-file-created.sh \
+	test-exitwhen-file-created-reject-new.sh \
+	test-exitwhen-file-created-when-idle.sh \
+	test-exitwhen-file-deleted.sh \
+	test-exitwhen-process-exits.sh \
+	test-exitwhen-script.sh \
+	$(NULL)
+
+test_exitwhen_pipe_closed_CFLAGS = $(WARNINGS_CFLAGS)
+
 # exportname filter test.
 TESTS += test-exportname.sh
 EXTRA_DIST += test-exportname.sh
diff --git a/filters/exitwhen/exitwhen.c b/filters/exitwhen/exitwhen.c
new file mode 100644
index 00000000..801c355a
--- /dev/null
+++ b/filters/exitwhen/exitwhen.c
@@ -0,0 +1,473 @@
+/* nbdkit
+ * Copyright (C) 2019-2020 Red Hat Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * * Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * * Neither the name of Red Hat nor the names of its contributors may be
+ * used to endorse or promote products derived from this software without
+ * specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY RED HAT AND CONTRIBUTORS ''AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL RED HAT OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
+ * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <config.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <inttypes.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <poll.h>
+#include <errno.h>
+#include <sys/types.h>
+
+#include <pthread.h>
+
+#include <nbdkit-filter.h>
+
+#include "cleanup.h"
+#include "utils.h"
+#include "vector.h"
+
+static unsigned pollsecs = 60;
+
+static pthread_mutex_t lock = PTHREAD_MUTEX_INITIALIZER;
+static unsigned connections = 0;
+static bool exiting = false;
+
+/* The list of events generated from command line parameters. */
+struct event {
+  enum { EVENT_FILE_CREATED = 1, EVENT_FILE_DELETED, EVENT_PROCESS_EXITS,
+         EVENT_FD_CLOSED, EVENT_SCRIPT } type;
+  union {
+    char *filename;             /* Filename or script. */
+    int fd;                     /* For PROCESS_EXITS or FD_CLOSED. */
+#ifndef __linux__
+    pid_t pid;                  /* For PROCESS_EXITS on non-Linux. */
+#endif
+  } u;
+};
+DEFINE_VECTOR_TYPE(event_list, struct event);
+static event_list events = empty_vector;
+
+static void
+free_event (struct event event)
+{
+  switch (event.type) {
+  case EVENT_FILE_CREATED:
+  case EVENT_FILE_DELETED:
+  case EVENT_SCRIPT:
+    free (event.u.filename);
+    break;
+  case EVENT_PROCESS_EXITS:
+#ifdef __linux__
+  case EVENT_FD_CLOSED:
+#endif
+    close (event.u.fd);
+    break;
+#ifndef __linux__
+  case EVENT_FD_CLOSED:
+    break;
+#endif
+  }
+}
+
+static void
+exitwhen_unload (void)
+{
+  event_list_iter (&events, free_event);
+  free (events.ptr);
+}
+
+/* If exiting is already true, this does nothing and returns true.
+ * Otherwise it checks if any event in the list has happened.  If an
+ * event has happened, sets exiting to true.  It returns the exiting
+ * flag.
+ *
+ * This must only be called with the lock held.
+ */
+static void check_for_event_file_created (const struct event *);
+static void check_for_event_file_deleted (const struct event *);
+static void check_for_event_process_exits (const struct event *);
+static void check_for_event_fd_closed (const struct event *);
+static void check_for_event_script (const struct event *);
+
+static bool
+check_for_event (void)
+{
+  size_t i;
+
+  if (!exiting) {
+    for (i = 0; i < events.size; ++i) {
+      const struct event *event = &events.ptr[i];
+
+      switch (event->type) {
+      case EVENT_FILE_CREATED:
+        check_for_event_file_created (event);
+        break;
+      case EVENT_FILE_DELETED:
+        check_for_event_file_deleted (event);
+        break;
+      case EVENT_PROCESS_EXITS:
+        check_for_event_process_exits (event);
+        break;
+      case EVENT_FD_CLOSED:
+        check_for_event_fd_closed (event);
+        break;
+      case EVENT_SCRIPT:
+        check_for_event_script (event);
+        break;
+      }
+    }
+  }
+
+  return exiting;
+}
+
+static void
+check_for_event_file_created (const struct event *event)
+{
+  if (access (event->u.filename, R_OK) == 0) {
+    nbdkit_debug ("exit-when-file-created: detected %s created",
+                  event->u.filename);
+    exiting = true;
+  }
+}
+
+static void
+check_for_event_file_deleted (const struct event *event)
+{
+  if (access (event->u.filename, R_OK) == -1) {
+    if (errno == ENOTDIR || errno == ENOENT) {
+      nbdkit_debug ("exit-when-file-deleted: detected %s deleted",
+                    event->u.filename);
+      exiting = true;
+    }
+    else {
+      /* Log the error but continue. */
+      nbdkit_error ("exit-when-file-deleted: access: %s: %m",
+                    event->u.filename);
+    }
+  }
+}
+
+static void
+check_for_event_process_exits (const struct event *event)
+{
+  char c;
+
+#ifdef __linux__
+  /* https://gitlab.freedesktop.org/polkit/polkit/-/issues/75
+   *
+   * event->u.fd holds /proc/PID/stat of the original process open.
+   * If we can still read a byte from it then the original process is
+   * still around.  If we get ESRCH then the process has exited.
+   */
+  lseek (event->u.fd, 0, SEEK_SET);
+  if (read (event->u.fd, &c, 1) == -1) {
+    if (errno == ESRCH) {
+      nbdkit_debug ("exit-when-process-exits: detected process exit");
+      exiting = true;
+    }
+    else {
+      /* Log the error but continue. */
+      nbdkit_error ("exit-when-process-exits: read: %m");
+    }
+  }
+#else /* !__linux__ */
+  /* XXX Find a safe way to do this on BSD at least. */
+  if (kill (event->u.pid, 0) == -1 && errno == ESRCH) {
+    nbdkit_debug ("exit-when-process-exits: detected process exit");
+    exiting = true;
+  }
+#endif /* !__linux__ */
+}
+
+static void
+check_for_event_fd_closed (const struct event *event)
+{
+  int r;
+  struct pollfd fds[1];
+
+  /* event->u.fd is the read side of a pipe or socket.  Check it is
+   * not closed.  We don't actually read anything from the pipe.
+   */
+  fds[0].fd = event->u.fd;
+  fds[0].events = 0;
+  r = poll (fds, 1, 0);
+  if (r == 1) {
+    if ((fds[0].revents & POLLHUP) != 0) {
+      nbdkit_debug ("exit-when-pipe-closed: detected pipe closed");
+      exiting = true;
+    }
+    else if ((fds[0].revents & POLLNVAL) != 0) {
+      /* If we were passed a bad file descriptor that is user error
+       * and we should exit with an error early.  Because
+       * check_for_event() is called first in get_ready() this should
+       * cause this to happen.
+       */
+      nbdkit_error ("exit-when-pipe-closed: invalid file descriptor");
+      exiting = true;
+    }
+  }
+  else if (r == -1) {
+    /* Log the error but continue. */
+    nbdkit_error ("exit-when-pipe-closed: poll: %m");
+  }
+}
+
+static void
+check_for_event_script (const struct event *event)
+{
+  int r;
+
+  /* event->u.filename is a script filename or command.  Exit code 88
+   * indicates the event has happened.
+   */
+  r = system (event->u.filename);
+  if (r == -1) {
+    /* Log the error but continue. */
+    nbdkit_error ("exit-when-script: %m");
+  }
+  else if (WIFEXITED (r) && WEXITSTATUS (r) == 0) {
+    /* Normal case, do nothing. */
+  }
+  else if (WIFEXITED (r) && WEXITSTATUS (r) == 88) {
+    nbdkit_debug ("exit-when-script: detected scripted event");
+    exiting = true;
+  }
+  else {
+    /* Log the error but continue. */
+    exit_status_to_nbd_error (r, "exit-when-script");
+  }
+}
+
+/* The background polling thread.
+ *
+ * This runs continuously in the background, but you can pause it by
+ * grabbing the "pause_lock" (use the pause/resume_polling_thread()
+ * wrappers).
+ */
+static pthread_mutex_t pause_lock = PTHREAD_MUTEX_INITIALIZER;
+
+static void *
+polling_thread (void *vp)
+{
+  for (;;) {
+    {
+      /* Note the order here is chosen to avoid possible deadlock
+       * because the callers of pause/resume_polling_thread() always
+       * acquire &lock before &pause_lock.
+       */
+      ACQUIRE_LOCK_FOR_CURRENT_SCOPE (&lock);
+      ACQUIRE_LOCK_FOR_CURRENT_SCOPE (&pause_lock);
+      if (check_for_event ()) {
+        nbdkit_debug ("exitwhen: shutdown from polling thread");
+        nbdkit_shutdown ();
+      }
+    }
+
+    sleep (pollsecs);
+  }
+}
+
+static void
+pause_polling_thread (void)
+{
+  pthread_mutex_lock (&pause_lock);
+}
+
+static void
+resume_polling_thread (void)
+{
+  pthread_mutex_unlock (&pause_lock);
+}
+
+static int
+exitwhen_config (nbdkit_next_config *next, void *nxdata,
+                 const char *key, const char *value)
+{
+  struct event event;
+
+  if (strcmp (key, "exit-when-file-created") == 0 ||
+      strcmp (key, "exit-when-file-deleted") == 0) {
+    event.type = key[15] == 'c' ? EVENT_FILE_CREATED : EVENT_FILE_DELETED;
+    event.u.filename = nbdkit_absolute_path (value);
+    if (event.u.filename == NULL)
+      return -1;
+    if (event_list_append (&events, event) == -1)
+      return -1;
+    return 0;
+  }
+  else if (strcmp (key, "exit-when-pipe-closed") == 0 ||
+           strcmp (key, "exit-when-fd-closed") == 0) {
+    event.type = EVENT_FD_CLOSED;
+    if (nbdkit_parse_int ("exit-when-pipe-closed", value, &event.u.fd) == -1)
+      return -1;
+    if (event_list_append (&events, event) == -1)
+      return -1;
+    return 0;
+  }
+  else if (strcmp (key, "exit-when-process-exits") == 0 ||
+           strcmp (key, "exit-when-pid-exits") == 0) {
+    uint64_t pid;
+    CLEANUP_FREE char *str = NULL;
+
+    event.type = EVENT_PROCESS_EXITS;
+    if (nbdkit_parse_uint64_t ("exit-when-process-exits", value, &pid) == -1)
+      return -1;
+#ifdef __linux__
+    /* See: https://gitlab.freedesktop.org/polkit/polkit/-/issues/75 */
+    if (asprintf (&str, "/proc/%" PRIu64 "/stat", pid) == -1) {
+      nbdkit_error ("asprintf: %m");
+      return -1;
+    }
+    event.u.fd = open (str, O_RDONLY);
+    if (event.u.fd == -1) {
+      nbdkit_error ("exit-when-process-exits: %s: %m", str);
+      return -1;
+    }
+#else
+    event.u.pid = (pid_t) pid;
+#endif
+    if (event_list_append (&events, event) == -1)
+      return -1;
+    return 0;
+  }
+  else if (strcmp (key, "exit-when-script") == 0) {
+    event.type = EVENT_SCRIPT;
+    event.u.filename = strdup (value);
+    if (event.u.filename == NULL) {
+      nbdkit_error ("strdup: %m");
+      return -1;
+    }
+    if (event_list_append (&events, event) == -1)
+      return -1;
+    return 0;
+  }
+  else if (strcmp (key, "exit-when-poll") == 0) {
+    if (nbdkit_parse_unsigned ("exit-when-poll", value, &pollsecs) == -1)
+      return -1;
+    return 0;
+  }
+  else
+    return next (nxdata, key, value);
+}
+
+/* Before forking, run the check.  If the event has already happened
+ * then we exit immediately.
+ */
+static int
+exitwhen_get_ready (nbdkit_next_get_ready *next, void *nxdata,
+                    int thread_model)
+{
+  ACQUIRE_LOCK_FOR_CURRENT_SCOPE (&lock);
+
+  if (check_for_event ())
+    exit (EXIT_SUCCESS);
+
+  return next (nxdata);
+}
+
+static int
+exitwhen_after_fork (nbdkit_next_after_fork *next, void *nxdata)
+{
+  int err;
+  pthread_t thread;
+
+  /* Start background polling thread.  Initially it is running. */
+  err = pthread_create (&thread, NULL, polling_thread, NULL);
+  if (err != 0) {
+    errno = err;
+    nbdkit_error ("pthread_create: %m");
+    return -1;
+  }
+  return next (nxdata);
+}
+
+static int
+exitwhen_preconnect (nbdkit_next_preconnect *next, void *nxdata, int readonly)
+{
+  ACQUIRE_LOCK_FOR_CURRENT_SCOPE (&lock);
+
+  if (check_for_event ()) {
+    nbdkit_error ("exitwhen: nbdkit is exiting: rejecting new connection");
+    return -1;
+  }
+
+  if (next (nxdata, readonly) == -1)
+    return -1;
+
+  return 0;
+}
+
+static void *
+exitwhen_open (nbdkit_next_open *next, nbdkit_backend *nxdata,
+               int readonly, const char *exportname, int is_tls)
+{
+  if (next (nxdata, readonly, exportname) == -1)
+    return NULL;
+
+  ACQUIRE_LOCK_FOR_CURRENT_SCOPE (&lock);
+  connections++;
+  if (connections == 1)
+    pause_polling_thread ();
+
+  return NBDKIT_HANDLE_NOT_NEEDED;
+}
+
+static void
+exitwhen_close (void *handle)
+{
+  ACQUIRE_LOCK_FOR_CURRENT_SCOPE (&lock);
+
+  check_for_event ();
+
+  --connections;
+  if (connections == 0) {
+    if (exiting) {
+      nbdkit_debug ("exitwhen: exiting on last client connection");
+      nbdkit_shutdown ();
+    }
+    else
+      resume_polling_thread ();
+  }
+}
+
+static struct nbdkit_filter filter = {
+  .name              = "exitwhen",
+  .longname          = "nbdkit exitwhen filter",
+  .unload            = exitwhen_unload,
+
+  .config            = exitwhen_config,
+  .get_ready         = exitwhen_get_ready,
+  .after_fork        = exitwhen_after_fork,
+
+  .preconnect        = exitwhen_preconnect,
+  .open              = exitwhen_open,
+  .close             = exitwhen_close,
+};
+
+NBDKIT_REGISTER_FILTER(filter)
diff --git a/tests/test-exitwhen-file-already-created.sh b/tests/test-exitwhen-file-already-created.sh
new file mode 100755
index 00000000..145864b5
--- /dev/null
+++ b/tests/test-exitwhen-file-already-created.sh
@@ -0,0 +1,45 @@
+#!/usr/bin/env bash
+# nbdkit
+# Copyright (C) 2020 Red Hat Inc.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+# * Redistributions of source code must retain the above copyright
+# notice, this list of conditions and the following disclaimer.
+#
+# * Redistributions in binary form must reproduce the above copyright
+# notice, this list of conditions and the following disclaimer in the
+# documentation and/or other materials provided with the distribution.
+#
+# * Neither the name of Red Hat nor the names of its contributors may be
+# used to endorse or promote products derived from this software without
+# specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY RED HAT AND CONTRIBUTORS ''AS IS'' AND
+# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+# THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+# PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL RED HAT OR
+# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
+# USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+# OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+# SUCH DAMAGE.
+
+source ./functions.sh
+set -x
+
+requires_filter exitwhen
+
+eventfile=exitwhen-file-already-created.event
+rm -f $eventfile
+cleanup_fn rm -f $eventfile
+
+# nbdkit should exit immediately if the event file already exists.
+
+touch $eventfile
+nbdkit -fv -U - --filter=exitwhen null exit-when-file-created=$eventfile
diff --git a/tests/test-exitwhen-file-created-reject-new.sh b/tests/test-exitwhen-file-created-reject-new.sh
new file mode 100755
index 00000000..7736e067
--- /dev/null
+++ b/tests/test-exitwhen-file-created-reject-new.sh
@@ -0,0 +1,88 @@
+#!/usr/bin/env bash
+# nbdkit
+# Copyright (C) 2020 Red Hat Inc.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+# * Redistributions of source code must retain the above copyright
+# notice, this list of conditions and the following disclaimer.
+#
+# * Redistributions in binary form must reproduce the above copyright
+# notice, this list of conditions and the following disclaimer in the
+# documentation and/or other materials provided with the distribution.
+#
+# * Neither the name of Red Hat nor the names of its contributors may be
+# used to endorse or promote products derived from this software without
+# specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY RED HAT AND CONTRIBUTORS ''AS IS'' AND
+# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+# THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+# PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL RED HAT OR
+# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
+# USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+# OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+# SUCH DAMAGE.
+
+source ./functions.sh
+set -x
+
+requires_filter exitwhen
+requires nbdsh --version
+
+sock=$(mktemp -u /tmp/nbdkit-test-sock.XXXXXX)
+pidfile=exitwhen-file-created-reject-new.pid
+eventfile=exitwhen-file-created-reject-new.event
+files="$pidfile $sock $eventfile"
+cleanup_fn rm -f $files
+
+# Start nbdkit with the exitwhen filter.
+start_nbdkit -P $pidfile -U $sock \
+             --filter=exitwhen memory size=1M \
+             exit-when-file-created=$eventfile
+
+# Connect and test.
+export eventfile sock
+nbdsh -c - <<'EOF'
+import os
+from pathlib import Path
+
+eventfile = os.environ['eventfile']
+sock = os.environ['sock']
+
+# Open a single connection.
+h.connect_unix(sock)
+
+# Check the connection is functional.
+buf = h.pread(512, 0)
+
+# Create the event.
+Path(eventfile).touch()
+
+# A new connection should be rejected.
+h2 = nbd.NBD()
+try:
+    h2.connect_unix(sock)
+    exit(1)
+except nbd.Error:
+    pass
+EOF
+
+# Now nbdkit should exit automatically.  Wait for it to do so.
+pid=`cat $pidfile`
+for i in {1..60}; do
+    if ! kill -s 0 $pid; then
+        break
+    fi
+    sleep 1
+done
+if kill -s 0 $pid; then
+    echo "$0: nbdkit did not exit after last client connection"
+    exit 1
+fi
diff --git a/tests/test-exitwhen-file-created-when-idle.sh b/tests/test-exitwhen-file-created-when-idle.sh
new file mode 100755
index 00000000..ff8a106b
--- /dev/null
+++ b/tests/test-exitwhen-file-created-when-idle.sh
@@ -0,0 +1,63 @@
+#!/usr/bin/env bash
+# nbdkit
+# Copyright (C) 2020 Red Hat Inc.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+# * Redistributions of source code must retain the above copyright
+# notice, this list of conditions and the following disclaimer.
+#
+# * Redistributions in binary form must reproduce the above copyright
+# notice, this list of conditions and the following disclaimer in the
+# documentation and/or other materials provided with the distribution.
+#
+# * Neither the name of Red Hat nor the names of its contributors may be
+# used to endorse or promote products derived from this software without
+# specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY RED HAT AND CONTRIBUTORS ''AS IS'' AND
+# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+# THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+# PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL RED HAT OR
+# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
+# USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+# OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+# SUCH DAMAGE.
+
+source ./functions.sh
+set -x
+
+requires_filter exitwhen
+
+pidfile=exitwhen-file-created-when-idle.pid
+eventfile=exitwhen-file-created-when-idle.event
+rm -f $eventfile $pidfile
+cleanup_fn rm -f $eventfile $pidfile
+
+start_nbdkit -P $pidfile -U - \
+             --filter=exitwhen null \
+             exit-when-file-created=$eventfile \
+             exit-when-poll=1
+
+# Creating the file should cause nbdkit to exit after a short time.
+sleep 1
+touch $eventfile
+sleep 1
+
+pid=`cat $pidfile`
+for i in {1..60}; do
+    if ! kill -s 0 $pid; then
+        break
+    fi
+    sleep 1
+done
+if kill -s 0 $pid; then
+    echo "$0: nbdkit did not exit when idle"
+    exit 1
+fi
diff --git a/tests/test-exitwhen-file-created.sh b/tests/test-exitwhen-file-created.sh
new file mode 100755
index 00000000..ff62604d
--- /dev/null
+++ b/tests/test-exitwhen-file-created.sh
@@ -0,0 +1,91 @@
+#!/usr/bin/env bash
+# nbdkit
+# Copyright (C) 2020 Red Hat Inc.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+# * Redistributions of source code must retain the above copyright
+# notice, this list of conditions and the following disclaimer.
+#
+# * Redistributions in binary form must reproduce the above copyright
+# notice, this list of conditions and the following disclaimer in the
+# documentation and/or other materials provided with the distribution.
+#
+# * Neither the name of Red Hat nor the names of its contributors may be
+# used to endorse or promote products derived from this software without
+# specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY RED HAT AND CONTRIBUTORS ''AS IS'' AND
+# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+# THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+# PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL RED HAT OR
+# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
+# USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+# OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+# SUCH DAMAGE.
+
+source ./functions.sh
+set -x
+
+requires_filter exitwhen
+requires nbdsh --version
+
+sock=$(mktemp -u /tmp/nbdkit-test-sock.XXXXXX)
+pidfile=exitwhen-file-created.pid
+eventfile=exitwhen-file-created.event
+files="$pidfile $sock $eventfile"
+cleanup_fn rm -f $files
+
+# Start nbdkit with the exitwhen filter.
+start_nbdkit -P $pidfile -U $sock \
+             --filter=exitwhen memory size=1M \
+             exit-when-file-created=$eventfile
+
+# Connect and test.
+export eventfile sock
+nbdsh -c - <<'EOF'
+import os
+from pathlib import Path
+
+eventfile = os.environ['eventfile']
+sock = os.environ['sock']
+
+# Open a couple of connections.
+h.connect_unix(sock)
+h2 = nbd.NBD()
+h2.connect_unix(sock)
+
+# The connections should both be functional.
+buf = h.pread(512, 0)
+buf = h2.pread(512, 0)
+
+# Create the event.
+Path(eventfile).touch()
+
+# The connections should still be functional.
+buf = h.pread(512, 0)
+h.shutdown()
+del h
+buf = h2.pread(512, 0)
+h2.shutdown()
+del h2
+EOF
+
+# Now nbdkit should exit automatically.  Wait for it to do so.
+pid=`cat $pidfile`
+for i in {1..60}; do
+    if ! kill -s 0 $pid; then
+        break
+    fi
+    sleep 1
+done
+if kill -s 0 $pid; then
+    echo "$0: nbdkit did not exit after last client connection"
+    exit 1
+fi
diff --git a/tests/test-exitwhen-file-deleted.sh b/tests/test-exitwhen-file-deleted.sh
new file mode 100755
index 00000000..2c0cafe2
--- /dev/null
+++ b/tests/test-exitwhen-file-deleted.sh
@@ -0,0 +1,68 @@
+#!/usr/bin/env bash
+# nbdkit
+# Copyright (C) 2020 Red Hat Inc.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+# * Redistributions of source code must retain the above copyright
+# notice, this list of conditions and the following disclaimer.
+#
+# * Redistributions in binary form must reproduce the above copyright
+# notice, this list of conditions and the following disclaimer in the
+# documentation and/or other materials provided with the distribution.
+#
+# * Neither the name of Red Hat nor the names of its contributors may be
+# used to endorse or promote products derived from this software without
+# specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY RED HAT AND CONTRIBUTORS ''AS IS'' AND
+# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+# THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+# PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL RED HAT OR
+# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
+# USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+# OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+# SUCH DAMAGE.
+
+source ./functions.sh
+set -x
+
+requires_filter exitwhen
+requires nbdsh --version
+
+sock=$(mktemp -u /tmp/nbdkit-test-sock.XXXXXX)
+pidfile=exitwhen-file-deleted.pid
+eventfile=exitwhen-file-deleted.event
+files="$pidfile $sock $eventfile"
+cleanup_fn rm -f $files
+
+touch $eventfile
+
+# Start nbdkit with the exitwhen filter.
+start_nbdkit -P $pidfile -U $sock \
+             --filter=exitwhen memory size=1M \
+             exit-when-file-deleted=$eventfile \
+             exit-when-poll=1
+
+sleep 1
+rm $eventfile
+sleep 1
+
+# Now nbdkit should exit automatically.  Wait for it to do so.
+pid=`cat $pidfile`
+for i in {1..60}; do
+    if ! kill -s 0 $pid; then
+        break
+    fi
+    sleep 1
+done
+if kill -s 0 $pid; then
+    echo "$0: nbdkit did not exit after last client connection"
+    exit 1
+fi
diff --git a/tests/test-exitwhen-process-exits.sh b/tests/test-exitwhen-process-exits.sh
new file mode 100755
index 00000000..22a17b58
--- /dev/null
+++ b/tests/test-exitwhen-process-exits.sh
@@ -0,0 +1,69 @@
+#!/usr/bin/env bash
+# nbdkit
+# Copyright (C) 2020 Red Hat Inc.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+# * Redistributions of source code must retain the above copyright
+# notice, this list of conditions and the following disclaimer.
+#
+# * Redistributions in binary form must reproduce the above copyright
+# notice, this list of conditions and the following disclaimer in the
+# documentation and/or other materials provided with the distribution.
+#
+# * Neither the name of Red Hat nor the names of its contributors may be
+# used to endorse or promote products derived from this software without
+# specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY RED HAT AND CONTRIBUTORS ''AS IS'' AND
+# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+# THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+# PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL RED HAT OR
+# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
+# USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+# OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+# SUCH DAMAGE.
+
+source ./functions.sh
+set -x
+
+requires_filter exitwhen
+requires nbdsh --version
+
+sock=$(mktemp -u /tmp/nbdkit-test-sock.XXXXXX)
+pidfile=exitwhen-process-exits.pid
+files="$pidfile $sock"
+cleanup_fn rm -f $files
+
+# Start the unrelated process.
+sleep 1h &
+sleeppid=$!
+
+# Start nbdkit with the exitwhen filter.
+start_nbdkit -P $pidfile -U $sock \
+             --filter=exitwhen memory size=1M \
+             exit-when-process-exits=$sleeppid \
+             exit-when-poll=1
+
+# Killing the sleep process should cause nbdkit to exit after a few
+# seconds.
+kill $sleeppid
+
+# Now nbdkit should exit automatically.  Wait for it to do so.
+pid=`cat $pidfile`
+for i in {1..60}; do
+    if ! kill -s 0 $pid; then
+        break
+    fi
+    sleep 1
+done
+if kill -s 0 $pid; then
+    echo "$0: nbdkit did not exit after last client connection"
+    exit 1
+fi
diff --git a/tests/test-exitwhen-script.sh b/tests/test-exitwhen-script.sh
new file mode 100755
index 00000000..43eeb58a
--- /dev/null
+++ b/tests/test-exitwhen-script.sh
@@ -0,0 +1,70 @@
+#!/usr/bin/env bash
+# nbdkit
+# Copyright (C) 2020 Red Hat Inc.
+#
+# Redistribution and use in source and binary forms, with or without
+# modification, are permitted provided that the following conditions are
+# met:
+#
+# * Redistributions of source code must retain the above copyright
+# notice, this list of conditions and the following disclaimer.
+#
+# * Redistributions in binary form must reproduce the above copyright
+# notice, this list of conditions and the following disclaimer in the
+# documentation and/or other materials provided with the distribution.
+#
+# * Neither the name of Red Hat nor the names of its contributors may be
+# used to endorse or promote products derived from this software without
+# specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY RED HAT AND CONTRIBUTORS ''AS IS'' AND
+# ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+# THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+# PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL RED HAT OR
+# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
+# USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+# OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+# OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+# SUCH DAMAGE.
+
+source ./functions.sh
+set -x
+
+requires_filter exitwhen
+requires nbdsh --version
+
+sock=$(mktemp -u /tmp/nbdkit-test-sock.XXXXXX)
+pidfile=exitwhen-script.pid
+files="$pidfile $sock"
+cleanup_fn rm -f $files
+
+# Start the unrelated process.
+sleep 1h &
+sleeppid=$!
+
+# Start nbdkit with the exitwhen filter.
+# The command tests if the sleep process is still running.
+start_nbdkit -P $pidfile -U $sock \
+             --filter=exitwhen memory size=1M \
+             exit-when-script="kill -0 $sleeppid || exit 88" \
+             exit-when-poll=1
+
+# Killing the sleep process should cause nbdkit to exit after a few
+# seconds.
+kill $sleeppid
+
+# Now nbdkit should exit automatically.  Wait for it to do so.
+pid=`cat $pidfile`
+for i in {1..60}; do
+    if ! kill -s 0 $pid; then
+        break
+    fi
+    sleep 1
+done
+if kill -s 0 $pid; then
+    echo "$0: nbdkit did not exit after last client connection"
+    exit 1
+fi
diff --git a/tests/test-exitwhen-pipe-closed.c b/tests/test-exitwhen-pipe-closed.c
new file mode 100644
index 00000000..b14bacc4
--- /dev/null
+++ b/tests/test-exitwhen-pipe-closed.c
@@ -0,0 +1,81 @@
+/* nbdkit
+ * Copyright (C) 2017-2020 Red Hat Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ * * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *
+ * * Redistributions in binary form must reproduce the above copyright
+ * notice, this list of conditions and the following disclaimer in the
+ * documentation and/or other materials provided with the distribution.
+ *
+ * * Neither the name of Red Hat nor the names of its contributors may be
+ * used to endorse or promote products derived from this software without
+ * specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY RED HAT AND CONTRIBUTORS ''AS IS'' AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
+ * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
+ * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL RED HAT OR
+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
+ * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
+ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
+ * SUCH DAMAGE.
+ */
+
+#include <config.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+int
+main (int argc, char *argv[])
+{
+  char *param;
+  int fd[2];
+  pid_t pid;
+
+  if (pipe (fd) == -1) {
+    perror ("pipe");
+    exit (EXIT_FAILURE);
+  }
+  if (asprintf (&param, "exit-when-pipe-closed=%d", fd[0]) == -1) {
+    perror ("asprintf");
+    exit (EXIT_FAILURE);
+  }
+
+  /* Run nbdkit. */
+  pid = fork ();
+  if (pid == -1) {
+    perror ("fork");
+    exit (EXIT_FAILURE);
+  }
+  if (pid == 0) {               /* Child - run nbdkit. */
+    /* Close the write side of the pipe. */
+    close (fd[1]);
+
+    /* Run nbdkit. */
+    execlp ("nbdkit", "nbdkit", "-v", "--filter=exitwhen",
+            "null", "1M", param, "exit-when-poll=1",
+            NULL);
+    perror ("execvp");
+    _exit (EXIT_FAILURE);
+  }
+
+  /* Close the read side of the pipe. */
+  close (fd[0]);
+
+  /* The test here is simply that nbdkit exits because we exit and our
+   * side of the pipe is closed.
+   */
+  free (param);
+  exit (EXIT_SUCCESS);
+}
diff --git a/.gitignore b/.gitignore
index 6434f83d..f98c3e9a 100644
--- a/.gitignore
+++ b/.gitignore
@@ -127,6 +127,7 @@ plugins/*/*.3
 /tests/test-data
 /tests/test-delay
 /tests/test-exit-with-parent
+/tests/test-exitwhen-pipe-closed
 /tests/test-ext2
 /tests/test-file-block
 /tests/test-golang
-- 
2.29.0.rc2


[Date Prev][Date Next]   [Thread Prev][Thread Next]   [Thread Index] [Date Index] [Author Index]