core-helper: replace stress_redo_fork with stress_retry_fork

The new stress_retry_fork helper performs a fork and retries it
if it fails. The retries repeat until timeout, or bogo-ops are
reached or SIGALRM occurs. If a non-resource fork failure occurs
the retry is stopped. The retries option allows an upper limit
to retrying, zero means infinite retries.  This new helper
allows the ugly retry goto loops in stressors to be removed too.

Signed-off-by: Colin Ian King <colin.i.king@gmail.com>

Author: ColinIanKing

core-helper.c

@@ -1452,26 +1452,61 @@ int stress_tty_width_get(void)
 }
 
 /*
- *  stress_redo_fork()
- *	check fork errno (in err) and return true if
- *	an immediate fork can be retried due to known
- *	error cases that are retryable. Also force a
- *	scheduling yield.
- */
-bool stress_redo_fork(stress_args_t *args, const int err)
-{
-	/* Timed out! */
-	if (UNLIKELY(stress_time_now() > args->time_end)) {
-		stress_continue_set_flag(false);
-		return false;
-	}
-	/* More bogo-ops to go and errors indicate a fork retry? */
-	if (LIKELY(stress_continue(args)) &&
-	    ((err == EAGAIN) || (err == EINTR) || (err == ENOMEM))) {
-		(void)shim_sched_yield();
-		return true;
+ *  stress_retry_fork()
+ *	retry fork until we timeout, stress_continue() is false
+ *	or an unexepcted fork() error occurred. Return the pid
+ *	and errno set to that of the fork() return.
+ *
+ *	if retries > 0 then retry that many times, else retry forever
+ */
+pid_t stress_retry_fork(stress_args_t *args, const int retries)
+{
+	pid_t pid;
+	int saved_errno;
+	int retry = 0;
+
+	for (;;) {
+		errno = 0;
+		pid = fork();
+
+		/* save error as it gets clobbered */
+		saved_errno = errno;
+
+		/* parent or child, OK fork paths */
+		if (LIKELY(pid >= 0))
+			break;
+
+		/* Clock time out */
+		if (UNLIKELY(stress_time_now() > args->time_end)) {
+			stress_continue_set_flag(false);
+			break;
+		}
+
+		/* SIGAALRM or bogos reached? */
+		if (!stress_continue(args)) {
+			break;
+		}
+
+		/* An unexpected fork errror occurred, bail out */
+		if ((saved_errno != EAGAIN) &&
+		    (saved_errno != EINTR) &&
+		    (saved_errno != ENOMEM)) {
+			break;
+		}
+		/*
+		 * fork may have failed because of low resources
+		 * or interrupt, so do yield sleep and try again
+		 */
+		if (retries > 0) {
+			if (retry++ > retries)
+				break;
+		} else {
+			stress_yield_sleep_ms();
+		}
 	}
-	return false;
+	/* errno set to fork()'s errno */
+	errno = saved_errno;
+	return pid;
 }
 
 /*

core-helper.h

@@ -76,7 +76,7 @@ extern WARN_UNUSED int stress_kernel_release_get(void);
 extern WARN_UNUSED pid_t stress_unused_racy_pid_get(const bool fork_test);
 extern WARN_UNUSED size_t stress_hostname_length_get(void);
 extern WARN_UNUSED int stress_tty_width_get(void);
-extern WARN_UNUSED bool stress_redo_fork(stress_args_t *args, const int err);
+extern WARN_UNUSED pid_t stress_retry_fork(stress_args_t *args, const int retries);
 extern void stress_clear_warn_once(void);
 extern WARN_UNUSED size_t stress_flag_permutation(const int flags, int **permutations);
 extern CONST WARN_UNUSED int stress_exit_status(const int err);

stress-alarm.c

@@ -66,11 +66,8 @@ static int stress_alarm(stress_args_t *args)
 	stress_sync_start_wait(args);
 	stress_proc_state_set(args->name, STRESS_STATE_RUN);
 
-again:
-	pid = fork();
+	pid = stress_retry_fork(args, 0);
 	if (pid < 0) {
-		if (stress_redo_fork(args, errno))
-			goto again;
 		if (UNLIKELY(!stress_continue(args)))
 			return EXIT_SUCCESS;
 		pr_fail("%s: fork failed, errno=%d (%s)\n",

stress-apparmor.c

@@ -243,11 +243,8 @@ static void apparmor_spawn(
 	stress_pid_t **s_pids_head,
 	stress_pid_t *s_pid)
 {
-again:
-	s_pid->pid = fork();
+	s_pid->pid = stress_retry_fork(args, 0);
 	if (s_pid->pid < 0) {
-		if (stress_redo_fork(args, errno))
-			goto again;
 		return;
 	} else if (s_pid->pid == 0) {
 		int ret = EXIT_SUCCESS;

stress-bad-altstack.c

@@ -384,13 +384,10 @@ static int stress_bad_altstack(stress_args_t *args)
 		pid_t pid;
 
 		(void)stress_mwc32();
-again:
 		if (UNLIKELY(!stress_continue_flag()))
 			return EXIT_SUCCESS;
-		pid = fork();
+		pid = stress_retry_fork(args, 0);
 		if (pid < 0) {
-			if (stress_redo_fork(args, errno))
-				goto again;
 			if (UNLIKELY(!stress_continue(args)))
 				return EXIT_SUCCESS;
 			pr_err("%s: fork failed, errno=%d: (%s)\n",
@@ -424,7 +421,7 @@ static int stress_bad_altstack(stress_args_t *args)
 							"killer, restarting again "
 							"(instance %" PRIu32 ")\n",
 							args->name, args->instance);
-						goto again;
+						continue;
 					}
 				}
 				/* expected: child killed itself with SIGSEGV */

stress-bad-ioctl.c

@@ -572,11 +572,14 @@ static int stress_bad_ioctl(stress_args_t *args)
 	do {
 		pid_t pid;
 
-again:
-		pid = fork();
+		pid = stress_retry_fork(args, 0);
 		if (pid < 0) {
-			if (stress_redo_fork(args, errno))
-				goto again;
+			if (UNLIKELY(!stress_continue(args)))
+				return EXIT_SUCCESS;
+			pr_fail("%s: fork failed, errno=%d (%s)\n",
+				args->name, errno, strerror(errno));
+			rc = EXIT_FAILURE;
+			break;
 		} else if (pid > 0) {
 			int status;
 			pid_t wret;

stress-cacheline.c

@@ -774,11 +774,8 @@ static int stress_cacheline(stress_args_t *args)
 				rc = EXIT_NO_RESOURCE;
 				goto finish;
 			}
-again:
-			s_pids[i].pid = fork();
+			s_pids[i].pid = stress_retry_fork(args, 0);
 			if (s_pids[i].pid < 0) {
-				if (stress_redo_fork(args, errno))
-					goto again;
 				if (UNLIKELY(!stress_continue(args)))
 					goto finish;
 				pr_err("%s: fork failed, errno=%d: (%s)\n",

stress-cgroup.c

@@ -616,14 +616,8 @@ static int stress_cgroup_mount(stress_args_t *args)
 	stress_proc_state_set(args->name, STRESS_STATE_RUN);
 
 	do {
-again:
-		if (UNLIKELY(!stress_continue_flag()))
-			break;
-
-		pid = fork();
+		pid = stress_retry_fork(args, 0);
 		if (pid < 0) {
-			if (stress_redo_fork(args, errno))
-				goto again;
 			if (UNLIKELY(!stress_continue(args)))
 				goto finish;
 			pr_err("%s: fork failed, errno=%d (%s)\n",
@@ -651,7 +645,7 @@ static int stress_cgroup_mount(stress_args_t *args)
 					pr_dbg("%s: assuming killed by OOM killer, "
 						"restarting again (instance %" PRIu32 ")\n",
 						args->name, args->instance);
-					goto again;
+					continue;
 				}
 			} else if (WEXITSTATUS(status) == EXIT_FAILURE) {
 				pr_fail("%s: child mount/umount failed\n", args->name);

stress-chroot.c

@@ -478,11 +478,17 @@ static int stress_chroot(stress_args_t *args)
 
 	do {
 		pid_t pid;
-again:
-		pid = fork();
+
+		pid = stress_retry_fork(args, 0);
 		if (pid < 0) {
-			if (stress_redo_fork(args, errno))
-				goto again;
+			if (UNLIKELY(!stress_continue(args))) {
+				ret = EXIT_SUCCESS;
+				break;
+			}
+			pr_fail("%s: fork failed, errno=%d (%s)\n",
+				args->name, errno, strerror(errno));
+			ret = EXIT_FAILURE;
+			break;
 		} else if (pid == 0) {
 			stress_proc_state_set(args->name, STRESS_STATE_RUN);
 			stress_set_oom_adjustment(args, true);

stress-cpu-sched.c

@@ -491,7 +491,6 @@ static void stress_cpu_sched_child_exercise(const pid_t pid, const int cpu)
 static void stress_cpu_sched_fork(stress_args_t *args)
 {
 	pid_t pid;
-	int retry = 0;
 
 	stress_cpu_sched_set_handler();
 
@@ -500,13 +499,8 @@ static void stress_cpu_sched_fork(stress_args_t *args)
 	if (stress_cpu_sched_hrtimer_sigprocmask(SIG_BLOCK) < 0)
 		return;
 #endif
-again:
-	pid = fork();
+	pid = stress_retry_fork(args, 10);
 	if (pid == -1) {
-                if ((retry++ < 10) && stress_redo_fork(args, errno)) {
-			(void)shim_usleep_interruptible(50000);
-                        goto again;
-		}
 		goto err;
 	} else if (pid == 0) {
 		const pid_t child_pid = getpid();
@@ -622,21 +616,15 @@ static int stress_cpu_sched_next_cpu_idx(const int instance, const int last_cpu_
 static void stress_cpu_sched_exec(stress_args_t *args, char *exec_prog)
 {
 	pid_t pid;
-	int retry = 0;
 
 #if defined(HAVE_TIMER_CLOCK_REALTIME)
 	stress_cpu_sched_hrtimer_set(0);
 	if (stress_cpu_sched_hrtimer_sigprocmask(SIG_BLOCK) < 0)
 		return;
 #endif
 
-again:
-	pid = fork();
+	pid = stress_retry_fork(args, 10);
 	if (pid < 0) {
-                if ((retry++ < 10) && stress_redo_fork(args, errno)) {
-			(void)shim_usleep_interruptible(50000);
-                        goto again;
-		}
 #if defined(HAVE_TIMER_CLOCK_REALTIME)
 		(void)stress_cpu_sched_hrtimer_sigprocmask(SIG_UNBLOCK);
 #endif
@@ -714,15 +702,9 @@ static int stress_cpu_sched_child(stress_args_t *args, void *context)
 
 	for (i = 0; LIKELY((i < cpu_sched_procs) && stress_continue(args)); i++) {
 		pid_t pid;
-		int retry = 0;
 
-again:
-		pid = fork();
+		pid = stress_retry_fork(args, 10);
 		if (pid < 0) {
-                	if ((retry++ < 10) && stress_redo_fork(args, errno)) {
-				(void)shim_usleep_interruptible(50000);
-				goto again;
-			}
 			stress_cpu_sched_pids[i].pid = -1;
 		} else if (pid == 0) {
 			pid_t mypid = getpid();