From fb6787a78c3a1e3a4868520d0531fc2ebdda21d8 Mon Sep 17 00:00:00 2001
From: David Goldblatt <davidgoldblatt@fb.com>
Date: Mon, 10 Jul 2017 13:19:31 -0700
Subject: [PATCH] Add a test of behavior under multi-threaded forking.

Forking a multithreaded process is dangerous but allowed, so long as the child
only executes async-signal-safe functions (e.g. exec).  Add a test to ensure
that we don't break this behavior.
---
 test/unit/fork.c | 108 ++++++++++++++++++++++++++++++++++++++---------
 1 file changed, 87 insertions(+), 21 deletions(-)

diff --git a/test/unit/fork.c b/test/unit/fork.c
index afe22141..b1690750 100644
--- a/test/unit/fork.c
+++ b/test/unit/fork.c
@@ -4,6 +4,30 @@
 #include <sys/wait.h>
 #endif
 
+#ifndef _WIN32
+static void
+wait_for_child_exit(int pid) {
+	int status;
+	while (true) {
+		if (waitpid(pid, &status, 0) == -1) {
+			test_fail("Unexpected waitpid() failure.");
+		}
+		if (WIFSIGNALED(status)) {
+			test_fail("Unexpected child termination due to "
+			    "signal %d", WTERMSIG(status));
+			break;
+		}
+		if (WIFEXITED(status)) {
+			if (WEXITSTATUS(status) != 0) {
+				test_fail("Unexpected child exit value %d",
+				    WEXITSTATUS(status));
+			}
+			break;
+		}
+	}
+}
+#endif
+
 TEST_BEGIN(test_fork) {
 #ifndef _WIN32
 	void *p;
@@ -40,26 +64,67 @@ TEST_BEGIN(test_fork) {
 		/* Child. */
 		_exit(0);
 	} else {
-		int status;
+		wait_for_child_exit(pid);
+	}
+#else
+	test_skip("fork(2) is irrelevant to Windows");
+#endif
+}
+TEST_END
 
-		/* Parent. */
-		while (true) {
-			if (waitpid(pid, &status, 0) == -1) {
-				test_fail("Unexpected waitpid() failure");
-			}
-			if (WIFSIGNALED(status)) {
-				test_fail("Unexpected child termination due to "
-				    "signal %d", WTERMSIG(status));
-				break;
-			}
-			if (WIFEXITED(status)) {
-				if (WEXITSTATUS(status) != 0) {
-					test_fail(
-					    "Unexpected child exit value %d",
-					    WEXITSTATUS(status));
-				}
-				break;
-			}
+#ifndef _WIN32
+static void *
+do_fork_thd(void *arg) {
+	malloc(1);
+	int pid = fork();
+	if (pid == -1) {
+		/* Error. */
+		test_fail("Unexpected fork() failure");
+	} else if (pid == 0) {
+		/* Child. */
+		char *args[] = {"true", NULL};
+		execvp(args[0], args);
+		test_fail("Exec failed");
+	} else {
+		/* Parent */
+		wait_for_child_exit(pid);
+	}
+	return NULL;
+}
+#endif
+
+#ifndef _WIN32
+static void
+do_test_fork_multithreaded() {
+	thd_t child;
+	thd_create(&child, do_fork_thd, NULL);
+	do_fork_thd(NULL);
+	thd_join(child, NULL);
+}
+#endif
+
+TEST_BEGIN(test_fork_multithreaded) {
+#ifndef _WIN32
+	/*
+	 * We've seen bugs involving hanging on arenas_lock (though the same
+	 * class of bugs can happen on any mutex).  The bugs are intermittent
+	 * though, so we want to run the test multiple times.  Since we hold the
+	 * arenas lock only early in the process lifetime, we can't just run
+	 * this test in a loop (since, after all the arenas are initialized, we
+	 * won't acquire arenas_lock any further).  We therefore repeat the test
+	 * with multiple processes.
+	 */
+	for (int i = 0; i < 100; i++) {
+		int pid = fork();
+		if (pid == -1) {
+			/* Error. */
+			test_fail("Unexpected fork() failure,");
+		} else if (pid == 0) {
+			/* Child. */
+			do_test_fork_multithreaded();
+			_exit(0);
+		} else {
+			wait_for_child_exit(pid);
 		}
 	}
 #else
@@ -70,6 +135,7 @@ TEST_END
 
 int
 main(void) {
-	return test(
-	    test_fork);
+	return test_no_reentrancy(
+	    test_fork,
+	    test_fork_multithreaded);
 }