Add test for hang on fork

src/common/kevent.c

@@ -331,9 +331,11 @@ kevent_copyin(struct kqueue *kq, const struct kevent changelist[], int nchanges,
 
 #ifndef _WIN32
 static void
-kevent_release_kq_mutex(void *kq)
+kevent_release_kq_mutex(void *arg)
 {
- kqueue_unlock((struct kqueue *)kq);
+ struct kqueue *kq = arg;
+ dbg_printf("Unlocking kq=%p due to cancellation", kq);
+ kqueue_unlock(kq);
 }
 #endif
 
@@ -367,7 +369,7 @@ kevent(int kqfd,
  if (!changelist) changelist = null_kev;
 
 #ifndef _WIN32
- prev_cancel_state = pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);
+ pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &prev_cancel_state);
 #endif
  /*
  * Grab the global mutex. This prevents
@@ -439,8 +441,10 @@ kevent(int kqfd,
  */
 #ifndef _WIN32
  (void)pthread_setcancelstate(prev_cancel_state, NULL);
- if (prev_cancel_state == PTHREAD_CANCEL_ENABLE)
+ if (prev_cancel_state == PTHREAD_CANCEL_ENABLE) {
+ dbg_printf("Checking for deferred cancellations");
  pthread_testcancel();
+ }
 #endif
  rv = kqops.kevent_wait(kq, nevents, timeout);
 #ifndef _WIN32
@@ -482,16 +486,23 @@ kevent(int kqfd,
 
 out:
 #ifndef _WIN32
- pthread_cleanup_pop(0);
+ /*
+ * Test for cancellations first, so we don't
+ * double unlock the kqueue.
+ */
+ pthread_setcancelstate(prev_cancel_state, NULL);
+ if (prev_cancel_state == PTHREAD_CANCEL_ENABLE) {
+ dbg_printf("Checking for deferred cancellations");
+ pthread_testcancel();
+ }
 #endif
- kqueue_unlock(kq);
- dbg_printf("--- END kevent %u ret %d ---", myid, rv);
 
 #ifndef _WIN32
- pthread_setcancelstate(prev_cancel_state, NULL);
- if (prev_cancel_state == PTHREAD_CANCEL_ENABLE)
- pthread_testcancel();
+ pthread_cleanup_pop(0);
 #endif
 
+ kqueue_unlock(kq);
+ dbg_printf("--- END kevent %u ret %d ---", myid, rv);
+
  return (rv);
 }

src/common/kqueue.c

@@ -190,6 +190,8 @@ libkqueue_parent_fork(void)
  if (!libkqueue_fork_cleanup_active)
  return;
 
+ dbg_puts("resuming execution in parent");
+
  tracing_mutex_unlock(&kq_mtx);
 }
 
@@ -359,7 +361,7 @@ kqueue(void)
 #endif
 
 #ifndef _WIN32
- prev_cancel_state = pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, NULL);
+ pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &prev_cancel_state);
 #endif
  kq = calloc(1, sizeof(*kq));
  if (kq == NULL)

src/common/private.h

@@ -78,10 +78,10 @@ struct evfilt_data;
  *
  */
 #ifndef LIST_FOREACH_SAFE
-#define LIST_FOREACH_SAFE(var, head, field, tvar) \
- for ((var) = LIST_FIRST((head)); \
-  (var) && ((tvar) = LIST_NEXT((var), field), 1); \
-  (var) = (tvar))
+#define LIST_FOREACH_SAFE(var, head, field, tvar) \
+ for ((var) = LIST_FIRST((head)); \
+  (var) && ((tvar) = LIST_NEXT((var), field), 1); \
+  (var) = (tvar))
 #endif
 
 /** Convenience macros
@@ -666,8 +666,16 @@ extern unsigned int kq_cnt;
  * kqueue internal API
  */
 #define kqueue_mutex_assert(kq, state) tracing_mutex_assert(&(kq)->kq_mtx, state)
-#define kqueue_lock(kq) tracing_mutex_lock(&(kq)->kq_mtx)
-#define kqueue_unlock(kq) tracing_mutex_unlock(&(kq)->kq_mtx)
+
+#define kqueue_lock(kq) do { \
+ dbg_printf("locking kq=%p", kq); \
+ tracing_mutex_lock(&(kq)->kq_mtx); \
+ } while(0)
+
+#define kqueue_unlock(kq) do { \
+ dbg_printf("unlocking kq=%p", kq); \
+ tracing_mutex_unlock(&(kq)->kq_mtx); \
+ } while(0)
 
 /*
  * knote internal API

test/libkqueue.c

@@ -14,6 +14,7 @@
  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  */
 #include "common.h"
+#include <time.h>
 
 #ifdef EVFILT_LIBKQUEUE
 static void
@@ -52,10 +53,84 @@ test_libkqueue_version_str(struct test_context *ctx)
  }
 }
 
+static void *
+test_libkqueue_fork_no_hang_thread(void *arg)
+{
+ struct test_context *ctx = arg;
+ struct kevent receipt;
+
+ /*
+ * We shouldn't ever wait for 10 seconds...
+ */
+ if (kevent(ctx->kqfd, NULL, 0, &receipt, 1, &(struct timespec){ .tv_sec = 10 }) > 0) {
+ printf("Failed waiting...\n");
+ die("kevent - waiting");
+ }
+
+ printf("Shouldn't have hit timeout, expected to be cancelled\n");
+ die("kevent - timeout");
+
+ return NULL;
+}
+
+static void
+test_libkqueue_fork_no_hang(struct test_context *ctx)
+{
+ struct kevent kev, receipt;
+ pthread_t thread;
+ time_t start, end;
+ pid_t child;
+
+ start = time(NULL);
+
+ /*
+ * Create a new thread
+ */
+ if (pthread_create(&thread, NULL, test_libkqueue_fork_no_hang_thread, ctx) < 0)
+ die("kevent");
+
+ printf("Created test_libkqueue_fork_no_hang_thread [%u]\n", (unsigned int)thread);
+
+ /*
+ * We don't know when the thread will start
+ * listening on the kqueue, so we just
+ * deschedule ourselves for 10ms and hope...
+ */
+ nanosleep(&(struct timespec){ .tv_nsec = 10000000}, NULL);
+
+ /*
+ * Test that we can fork... The child exits
+ * immediately, we're just check that we _can_
+ * fork().
+ */
+#if 0
+ child = fork();
+ if (child == 0) {
+ testing_end_quiet();
+ exit(EXIT_SUCCESS);
+ }
+
+ printf("Forked child [%u]\n", (unsigned int)child);
+#endif
+
+ /*
+ * This also tests proper behaviour of kqueues
+ * on cancellation.
+ */
+ if (pthread_cancel(thread) < 0)
+ die("pthread_cancel");
+
+ if ((time(NULL) - start) > 5) {
+ printf("Thread hung instead of being cancelled");
+ die("kevent");
+ }
+}
+
 void
 test_evfilt_libkqueue(struct test_context *ctx)
 {
  test(libkqueue_version, ctx);
  test(libkqueue_version_str, ctx);
+ test(libkqueue_fork_no_hang, ctx);
 }
 #endif