lib/tst_test.c: Fix tst_brk() handling

This makes the tst_brk() handling cleaner and saner as instead of
propagating the tst_brk() result in a return value an abort flag is
introduced into the shared memory.

Now:

- All the processes but the library one that reports the results exit
  with 0

- tst_brk(TBROK, ...) increments result counters, sets the abort flag,
  exit current process and makes sure all process group processes are
  terminated

- all other tst_brk() variants will just increments the counters and
  exits the current process (which is current iteration for
  .all_filesystems, .test_variants, etc.)

This makes the tst_brk() behavior well defined so we can now even call
tst_brk() with TFAIL and TPASS as well. And since TBROK is supposed to
exit the test immediately (i.e.  unrecoverable error) we are now
properly doing so.

The case that main test pid called TBROK was working correctly before
this patch, since send the SIGKILL signal to the process group after we
waited for the main test pid. All that was missing is a code that sends
a signal to the main test pid in the case that TBROK was triggered by
one of it's children and now we properly kill all test processes in that
case as well.

There is also special case where we call tst_brk() before the test
library has been initialized (mostly done by the C shell helpers) in
that case we have to exit with a proper return value, which is normally
done by the test library process.

Signed-off-by: Cyril Hrubis <[email protected]>
Acked-by: Andrea Cervesato <[email protected]>
Acked-by: Jan Stancek <[email protected]>
Reviewed-by: Petr Vorel <[email protected]>

Author: metan-ucw

doc/old/C-Test-API.asciidoc

@@ -245,13 +245,13 @@ The 'ttype' can be combined bitwise with 'TERRNO' or 'TTERRNO' to print
 void tst_brk(int ttype, char *arg_fmt, ...);
 -------------------------------------------------------------------------------
 
-Printf-like function to report error and exit the test, it can be used with ttype:
+Printf-like function to report result and exits current test. If test uses
+'.all_filesystems', '.test_variants' etc. the 'tst_brk()' exits current test
+iteration e.g. currently running filesystem test or a test variant unless
+'ttype' is set to 'TBROK'.
 
-|============================================================
-| 'TBROK' | Something has failed in test preparation phase.
-| 'TCONF' | Test is not appropriate for current configuration
-            (syscall not implemented, unsupported arch, ...)
-|============================================================
+If 'ttype' is set to 'TBROK' all test processes are killed and the test exits
+immediately with an error.
 
 The 'ttype' can be combined bitwise with 'TERRNO' or 'TTERRNO' to print
 'errno', 'TST_ERR' respectively.
@@ -647,15 +647,15 @@ IMPORTANT: You have to set the '.forks_child' flag in the test structure
 Results reported by 'tst_res()' are propagated to the parent test process via
 block of shared memory.
 
-Calling 'tst_brk()' causes child process to exit with non-zero exit value.
-Which means that it's safe to use 'SAFE_*()' macros in the child processes as
-well.
+Calling 'tst_brk()' causes child process to set the test library abort flag and
+exits the test immediately. Which means that it's safe to use 'SAFE_*()' macros
+in the child processes as well.
 
 Children that outlive the 'test()' function execution are waited for in the
 test library. Unclean child exit (killed by signal, non-zero exit value, etc.)
-will cause the main test process to exit with 'tst_brk()', which especially
-means that 'TBROK' propagated from a child process will cause the whole test
-to exit with 'TBROK'.
+will cause the main test process to exit with 'tst_brk()'. That means that all
+test child processes are supposed to exit with success unless they are
+explicitly waited for.
 
 If a test needs a child that segfaults or does anything else that cause it to
 exit uncleanly all you need to do is to wait for such children from the

include/tst_common.h

@@ -79,9 +79,6 @@
 #define TST_BUILD_BUG_ON(condition) \
 	do { ((void)sizeof(char[1 - 2 * !!(condition)])); } while (0)
 
-#define TST_BRK_SUPPORTS_ONLY_TCONF_TBROK(condition) \
-	TST_BUILD_BUG_ON(condition)
-
 #define TST_RES_SUPPORTS_TCONF_TDEBUG_TFAIL_TINFO_TPASS_TWARN(condition) \
 	TST_BUILD_BUG_ON(condition)
 

include/tst_test.h

@@ -98,28 +98,32 @@ void tst_brk_(const char *file, const int lineno, int ttype,
               __attribute__ ((format (printf, 4, 5)));
 
 /**
- * tst_brk() - Reports a breakage and exits the test.
+ * tst_brk() - Reports a breakage and exits the test or test process.
  *
  * @ttype: An &enum tst_res_flags.
  * @arg_fmt: A printf-like format.
  * @...: A printf-like parameters.
  *
- * Reports either TBROK or TCONF and exits the test immediately. When called
- * all children in the same process group as the main test library process are
- * killed. This function, unless in a test cleanup, calls _exit() and does not
- * return.
+ * Reports a single result and exits immediately. The call behaves differently
+ * based on the ttype parameter. For all ttype results but TBROK the call exits
+ * the current test process, i.e. increments test result counters and calls
+ * exit(0).
+ *
+ * The TBROK ttype is special that apart from exiting the current test process
+ * it also tells to the test library to exit immediately. When TBROK is
+ * triggered by any of the test processes the whole process group is killed so
+ * that there are no processes left after the library process exits. This also
+ * means that any subsequent test iterations are not executed, e.g. if a test
+ * runs for all filesystems and tst_brk() with TBROK is called, the test exits
+ * and does not attempt to continue a test iteration for the next filesystem.
  *
  * When test is in cleanup() function TBROK is converted into TWARN by the test
  * library and we attempt to carry on with a cleanup even when tst_brk() was
  * called. This makes it possible to use SAFE_FOO() macros in the test cleanup
  * without interrupting the cleanup process on a failure.
  */
-#define tst_brk(ttype, arg_fmt, ...)						\
-	({									\
-		TST_BRK_SUPPORTS_ONLY_TCONF_TBROK(!((ttype) &			\
-			(TBROK | TCONF | TFAIL)));				\
-		tst_brk_(__FILE__, __LINE__, (ttype), (arg_fmt), ##__VA_ARGS__);\
-	})
+#define tst_brk(ttype, arg_fmt, ...) \
+		tst_brk_(__FILE__, __LINE__, (ttype), (arg_fmt), ##__VA_ARGS__)
 
 void tst_printf(const char *const fmt, ...)
 		__attribute__((nonnull(1), format (printf, 1, 2)));

lib/newlib_tests/.gitignore

@@ -58,4 +58,10 @@ test_runtime01
 test_runtime02
 test_children_cleanup
 tst_res_flags
-tst_safe_sscanf
+tst_safe_sscanf
+test_brk_child
+test_brk_fail
+test_brk_parent
+test_brk_pass
+test_brk_variant
+test_fail_variant

lib/newlib_tests/test_brk_child.c

@@ -0,0 +1,31 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/*
+ * Copyright (c) 2025 Cyril Hrubis <[email protected]>
+ */
+
+/*
+ * Test that tst_brk(TFAIL, ...) exits only single test variant.
+ */
+#include "tst_test.h"
+
+static void do_test(void)
+{
+	int i;
+
+	for (i = 0; i < 10; i++) {
+		if (!SAFE_FORK()) {
+			tst_res(TINFO, "Suspending child %i", i);
+			pause();
+		}
+	}
+
+	if (!SAFE_FORK())
+		tst_brk(TBROK, "Child triggers TBROK");
+
+	pause();
+}
+
+static struct tst_test test = {
+	.test_all = do_test,
+	.forks_child = 1,
+};

lib/newlib_tests/test_brk_fail.c

@@ -0,0 +1,25 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/*
+ * Copyright (c) 2024 Cyril Hrubis <[email protected]>
+ */
+
+/*
+ * Test that tst_brk(TFAIL, ...) works properly.
+ */
+#include "tst_test.h"
+
+static void do_test(void)
+{
+	int pid = SAFE_FORK();
+
+	if (pid)
+		return;
+
+	tst_brk(TFAIL, "Test child exiting...");
+	tst_res(TWARN, "Test child stil alive!");
+}
+
+static struct tst_test test = {
+	.test_all = do_test,
+	.forks_child = 1,
+};

lib/newlib_tests/test_brk_parent.c

@@ -0,0 +1,28 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/*
+ * Copyright (c) 2025 Cyril Hrubis <[email protected]>
+ */
+
+/*
+ * Test that tst_brk(TFAIL, ...) exits only single test variant.
+ */
+#include "tst_test.h"
+
+static void do_test(void)
+{
+	int i;
+
+	for (i = 0; i < 10; i++) {
+		if (!SAFE_FORK()) {
+			tst_res(TINFO, "Suspending child %i", i);
+			pause();
+		}
+	}
+
+	tst_brk(TBROK, "Parent triggers TBROK");
+}
+
+static struct tst_test test = {
+	.test_all = do_test,
+	.forks_child = 1,
+};

lib/newlib_tests/test_brk_pass.c

@@ -0,0 +1,25 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/*
+ * Copyright (c) 2024 Cyril Hrubis <[email protected]>
+ */
+
+/*
+ * Test that tst_brk(TPASS, ...) works properly.
+ */
+#include "tst_test.h"
+
+static void do_test(void)
+{
+	int pid = SAFE_FORK();
+
+	if (pid)
+		return;
+
+	tst_brk(TPASS, "Test child exiting...");
+	tst_res(TWARN, "Test child stil alive!");
+}
+
+static struct tst_test test = {
+	.test_all = do_test,
+	.forks_child = 1,
+};

lib/newlib_tests/test_brk_variant.c

@@ -0,0 +1,19 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/*
+ * Copyright (c) 2024 Cyril Hrubis <[email protected]>
+ */
+
+/*
+ * Test that tst_brk(TBROK, ...) exits the test immediately.
+ */
+#include "tst_test.h"
+
+static void do_test(void)
+{
+	tst_brk(TBROK, "Exitting the test during the first variant");
+}
+
+static struct tst_test test = {
+	.test_all = do_test,
+	.test_variants = 10,
+};

lib/newlib_tests/test_fail_variant.c

@@ -0,0 +1,20 @@
+// SPDX-License-Identifier: GPL-2.0-or-later
+/*
+ * Copyright (c) 2024 Cyril Hrubis <[email protected]>
+ */
+
+/*
+ * Test that tst_brk(TFAIL, ...) exits only single test variant.
+ */
+#include "tst_test.h"
+
+static void do_test(void)
+{
+	tst_brk(TFAIL, "Failing a test variant");
+	tst_res(TWARN, "Shouldn't be reached");
+}
+
+static struct tst_test test = {
+	.test_all = do_test,
+	.test_variants = 10,
+};