[PATCH v2 00/32] kselftest harness and nolibc compatibility

[PATCH v2 00/32] kselftest harness and nolibc compatibility

[Thomas Weißschuh]

Nolibc is useful for selftests as the test programs can be very small,
and compiled with just a kernel crosscompiler, without userspace support.
Currently nolibc is only usable with kselftest.h, not the more
convenient to use kselftest_harness.h
This series provides this compatibility by adding new features to nolibc
and removing the usage of problematic features from the harness.

The first half of the series are changes to the harness, the second one
are for nolibc. Both parts are very independent and should go through
different trees.
The last patch is not meant to be applied and serves as test that
everything works together correctly.

Signed-off-by: Thomas Weißschuh <thomas.weissschuh@linutronix.de>
---
Changes in v2:
- Rebase unto v6.15-rc1
- Rename internal nolibc symbols
- Handle edge case of waitpid(INT_MIN) == ESRCH
- Fix arm configurations for final testing patch
- Clean up global getopt.h variable declarations
- Add Acks from Willy
- Link to v1: https://lore.kernel.org/r/20250304-nolibc-kselftest-harness-v1-0-adca7cd231e2@linutronix.de

---
Thomas Weißschuh (32):
      selftests: harness: Add harness selftest
      selftests: harness: Use C89 comment style
      selftests: harness: Ignore unused variant argument warning
      selftests: harness: Mark functions without prototypes static
      selftests: harness: Remove inline qualifier for wrappers
      selftests: harness: Remove dependency on libatomic
      selftests: harness: Implement test timeouts through pidfd
      selftests: harness: Don't set setup_completed for fixtureless tests
      selftests: harness: Always provide "self" and "variant"
      selftests: harness: Move teardown conditional into test metadata
      selftests: harness: Add teardown callback to test metadata
      selftests: harness: Stop using setjmp()/longjmp()
      selftests: harness: Guard includes on nolibc
      tools/nolibc: handle intmax_t/uintmax_t in printf
      tools/nolibc: use intmax definitions from compiler
      tools/nolibc: use pselect6_time64 if available
      tools/nolibc: use ppoll_time64 if available
      tools/nolibc: add tolower() and toupper()
      tools/nolibc: add _exit()
      tools/nolibc: add setpgrp()
      tools/nolibc: implement waitpid() in terms of waitid()
      Revert "selftests/nolibc: use waitid() over waitpid()"
      tools/nolibc: add dprintf() and vdprintf()
      tools/nolibc: add getopt()
      tools/nolibc: allow different write callbacks in printf
      tools/nolibc: allow limiting of printf destination size
      tools/nolibc: add snprintf() and friends
      selftests/nolibc: use snprintf() for printf tests
      selftests/nolibc: rename vfprintf test suite
      selftests/nolibc: add test for snprintf() truncation
      tools/nolibc: implement width padding in printf()
      HACK: selftests/nolibc: demonstrate usage of the kselftest harness

 tools/include/nolibc/Makefile                      |    1 +
 tools/include/nolibc/getopt.h                      |  101 ++
 tools/include/nolibc/nolibc.h                      |    1 +
 tools/include/nolibc/stdint.h                      |    4 +-
 tools/include/nolibc/stdio.h                       |  127 +-
 tools/include/nolibc/string.h                      |   17 +
 tools/include/nolibc/sys.h                         |  105 +-
 tools/testing/selftests/Makefile                   |    1 +
 tools/testing/selftests/kselftest/.gitignore       |    1 +
 tools/testing/selftests/kselftest/Makefile         |    6 +
 .../testing/selftests/kselftest/harness-selftest.c |  129 ++
 .../selftests/kselftest/harness-selftest.expected  |   62 +
 .../selftests/kselftest/harness-selftest.sh        |   14 +
 tools/testing/selftests/kselftest_harness.h        |  181 +-
 tools/testing/selftests/nolibc/Makefile            |   13 +-
 tools/testing/selftests/nolibc/harness-selftest.c  |    1 +
 tools/testing/selftests/nolibc/nolibc-test.c       | 1729 +-------------------
 tools/testing/selftests/nolibc/run-tests.sh        |    2 +-
 18 files changed, 635 insertions(+), 1860 deletions(-)
---
base-commit: 0af2f6be1b4281385b618cb86ad946eded089ac8
change-id: 20250130-nolibc-kselftest-harness-8b2c8cac43bf

Best regards,
-- 
Thomas Weißschuh <thomas.weissschuh@linutronix.de>

[PATCH v2 01/32] selftests: harness: Add harness selftest

[Thomas Weißschuh]

Add a selftest for the harness itself so any changes can be validated.

Signed-off-by: Thomas Weißschuh <thomas.weissschuh@linutronix.de>
---
 tools/testing/selftests/Makefile                   |   1 +
 tools/testing/selftests/kselftest/.gitignore       |   1 +
 tools/testing/selftests/kselftest/Makefile         |   6 +
 .../testing/selftests/kselftest/harness-selftest.c | 129 +++++++++++++++++++++
 .../selftests/kselftest/harness-selftest.expected  |  62 ++++++++++
 .../selftests/kselftest/harness-selftest.sh        |  14 +++
 6 files changed, 213 insertions(+)

diff --git a/tools/testing/selftests/Makefile b/tools/testing/selftests/Makefile
index c77c8c8e3d9bdd8047c9cb7722c3830447e504e5..3ce071eefa86af59aadd1df7972fdf3bf6e01d52 100644
--- a/tools/testing/selftests/Makefile
+++ b/tools/testing/selftests/Makefile
@@ -48,6 +48,7 @@ TARGETS += ipc
 TARGETS += ir
 TARGETS += kcmp
 TARGETS += kexec
+TARGETS += kselftest
 TARGETS += kvm
 TARGETS += landlock
 TARGETS += lib
diff --git a/tools/testing/selftests/kselftest/.gitignore b/tools/testing/selftests/kselftest/.gitignore
new file mode 100644
index 0000000000000000000000000000000000000000..9aab194e8ea25a2c5ccc116f9f728b8afd0c51c4
--- /dev/null
+++ b/tools/testing/selftests/kselftest/.gitignore
@@ -0,0 +1 @@
+/harness-selftest
diff --git a/tools/testing/selftests/kselftest/Makefile b/tools/testing/selftests/kselftest/Makefile
new file mode 100644
index 0000000000000000000000000000000000000000..2f2933553dbc47014d9dfe0b4bd8ad3bc36e38c2
--- /dev/null
+++ b/tools/testing/selftests/kselftest/Makefile
@@ -0,0 +1,6 @@
+# SPDX-License-Identifier: GPL-2.0
+
+TEST_GEN_PROGS_EXTENDED := harness-selftest
+TEST_PROGS := harness-selftest.sh
+
+include ../lib.mk
diff --git a/tools/testing/selftests/kselftest/harness-selftest.c b/tools/testing/selftests/kselftest/harness-selftest.c
new file mode 100644
index 0000000000000000000000000000000000000000..8d39e7a0b99c41a5d33edfe2dbf875cac04c098d
--- /dev/null
+++ b/tools/testing/selftests/kselftest/harness-selftest.c
@@ -0,0 +1,129 @@
+// SPDX-License-Identifier: GPL-2.0
+
+#include <stdio.h>
+
+#ifndef NOLIBC
+#include <sys/resource.h>
+#include <sys/prctl.h>
+#endif
+
+/* Avoid any inconsistencies */
+#define TH_LOG_STREAM stdout
+
+#include "../kselftest_harness.h"
+
+TEST(standalone_pass) {
+	TH_LOG("before");
+	ASSERT_EQ(0, 0);
+	EXPECT_EQ(0, 0);
+	TH_LOG("after");
+}
+
+TEST(standalone_fail) {
+	TH_LOG("before");
+	EXPECT_EQ(0, 0);
+	EXPECT_EQ(0, 1);
+	ASSERT_EQ(0, 1);
+	TH_LOG("after");
+}
+
+TEST_SIGNAL(signal_pass, SIGUSR1) {
+	TH_LOG("before");
+	ASSERT_EQ(0, 0);
+	TH_LOG("after");
+	kill(getpid(), SIGUSR1);
+}
+
+TEST_SIGNAL(signal_fail, SIGUSR1) {
+	TH_LOG("before");
+	ASSERT_EQ(0, 1);
+	TH_LOG("after");
+	kill(getpid(), SIGUSR1);
+}
+
+FIXTURE(fixture) {
+	pid_t testpid;
+};
+
+FIXTURE_SETUP(fixture) {
+	TH_LOG("setup");
+	self->testpid = getpid();
+}
+
+FIXTURE_TEARDOWN(fixture) {
+	TH_LOG("teardown same-process=%d", self->testpid == getpid());
+}
+
+TEST_F(fixture, pass) {
+	TH_LOG("before");
+	ASSERT_EQ(0, 0);
+	TH_LOG("after");
+}
+
+TEST_F(fixture, fail) {
+	TH_LOG("before");
+	ASSERT_EQ(0, 1);
+	TH_LOG("after");
+}
+
+TEST_F_TIMEOUT(fixture, timeout, 1) {
+	TH_LOG("before");
+	sleep(2);
+	TH_LOG("after");
+}
+
+FIXTURE(fixture_parent) {
+	pid_t testpid;
+};
+
+FIXTURE_SETUP(fixture_parent) {
+	TH_LOG("setup");
+	self->testpid = getpid();
+}
+
+FIXTURE_TEARDOWN_PARENT(fixture_parent) {
+	TH_LOG("teardown same-process=%d", self->testpid == getpid());
+}
+
+TEST_F(fixture_parent, pass) {
+	TH_LOG("before");
+	ASSERT_EQ(0, 0);
+	TH_LOG("after");
+}
+
+FIXTURE(fixture_setup_failure) {
+	pid_t testpid;
+};
+
+FIXTURE_SETUP(fixture_setup_failure) {
+	TH_LOG("setup");
+	self->testpid = getpid();
+	ASSERT_EQ(0, 1);
+}
+
+FIXTURE_TEARDOWN(fixture_setup_failure) {
+	TH_LOG("teardown same-process=%d", self->testpid == getpid());
+}
+
+TEST_F(fixture_setup_failure, pass) {
+	TH_LOG("before");
+	ASSERT_EQ(0, 0);
+	TH_LOG("after");
+}
+
+int main(int argc, char **argv)
+{
+	/*
+	 * The harness uses abort() to signal assertion failures, which triggers coredumps.
+	 * This may be useful to debug real failures but not for this selftest, disable them.
+	 */
+	struct rlimit rlimit = {
+		.rlim_cur = 0,
+		.rlim_max = 0,
+	};
+
+	prctl(PR_SET_DUMPABLE, 0, 0, 0, 0);
+	setrlimit(RLIMIT_CORE, &rlimit);
+
+	return test_harness_run(argc, argv);
+}
diff --git a/tools/testing/selftests/kselftest/harness-selftest.expected b/tools/testing/selftests/kselftest/harness-selftest.expected
new file mode 100644
index 0000000000000000000000000000000000000000..1aa6461db90d4e7cc0679f19b69aadf4032875ec
--- /dev/null
+++ b/tools/testing/selftests/kselftest/harness-selftest.expected
@@ -0,0 +1,62 @@
+TAP version 13
+1..9
+# Starting 9 tests from 4 test cases.
+#  RUN           global.standalone_pass ...
+# harness-selftest.c:16:standalone_pass:before
+# harness-selftest.c:19:standalone_pass:after
+#            OK  global.standalone_pass
+ok 1 global.standalone_pass
+#  RUN           global.standalone_fail ...
+# harness-selftest.c:23:standalone_fail:before
+# harness-selftest.c:25:standalone_fail:Expected 0 (0) == 1 (1)
+# harness-selftest.c:26:standalone_fail:Expected 0 (0) == 1 (1)
+# standalone_fail: Test terminated by assertion
+#          FAIL  global.standalone_fail
+not ok 2 global.standalone_fail
+#  RUN           global.signal_pass ...
+# harness-selftest.c:31:signal_pass:before
+# harness-selftest.c:33:signal_pass:after
+#            OK  global.signal_pass
+ok 3 global.signal_pass
+#  RUN           global.signal_fail ...
+# harness-selftest.c:38:signal_fail:before
+# harness-selftest.c:39:signal_fail:Expected 0 (0) == 1 (1)
+# signal_fail: Test terminated by assertion
+#          FAIL  global.signal_fail
+not ok 4 global.signal_fail
+#  RUN           fixture.pass ...
+# harness-selftest.c:49:pass:setup
+# harness-selftest.c:58:pass:before
+# harness-selftest.c:60:pass:after
+# harness-selftest.c:54:pass:teardown same-process=1
+#            OK  fixture.pass
+ok 5 fixture.pass
+#  RUN           fixture.fail ...
+# harness-selftest.c:49:fail:setup
+# harness-selftest.c:64:fail:before
+# harness-selftest.c:65:fail:Expected 0 (0) == 1 (1)
+# harness-selftest.c:54:fail:teardown same-process=1
+# fail: Test terminated by assertion
+#          FAIL  fixture.fail
+not ok 6 fixture.fail
+#  RUN           fixture.timeout ...
+# harness-selftest.c:49:timeout:setup
+# harness-selftest.c:70:timeout:before
+# timeout: Test terminated by timeout
+#          FAIL  fixture.timeout
+not ok 7 fixture.timeout
+#  RUN           fixture_parent.pass ...
+# harness-selftest.c:80:pass:setup
+# harness-selftest.c:89:pass:before
+# harness-selftest.c:91:pass:after
+# harness-selftest.c:85:pass:teardown same-process=0
+#            OK  fixture_parent.pass
+ok 8 fixture_parent.pass
+#  RUN           fixture_setup_failure.pass ...
+# harness-selftest.c:99:pass:setup
+# harness-selftest.c:101:pass:Expected 0 (0) == 1 (1)
+# pass: Test terminated by assertion
+#          FAIL  fixture_setup_failure.pass
+not ok 9 fixture_setup_failure.pass
+# FAILED: 4 / 9 tests passed.
+# Totals: pass:4 fail:5 xfail:0 xpass:0 skip:0 error:0
diff --git a/tools/testing/selftests/kselftest/harness-selftest.sh b/tools/testing/selftests/kselftest/harness-selftest.sh
new file mode 100755
index 0000000000000000000000000000000000000000..bf691adf0b41aaedb2fbc5f06add9fd1d5689044
--- /dev/null
+++ b/tools/testing/selftests/kselftest/harness-selftest.sh
@@ -0,0 +1,14 @@
+#!/bin/sh
+# SPDX-License-Identifier: GPL-2.0
+#
+# Selftest for kselftest_harness.h
+#
+
+DIR="$(dirname $(readlink -f "$0"))"
+
+TMPFILE="$(mktemp)"
+trap 'rm "$TMPFILE"' EXIT
+
+$DIR/harness-selftest > "$TMPFILE"
+
+diff -u "$DIR"/harness-selftest.expected "$TMPFILE"

-- 
2.49.0

Re: [PATCH v2 01/32] selftests: harness: Add harness selftest

[Shuah Khan]

On 4/7/25 00:52, Thomas Weißschuh wrote:
> Add a selftest for the harness itself so any changes can be validated.
> 

kselftest harness?

> Signed-off-by: Thomas Weißschuh <thomas.weissschuh@linutronix.de>
> ---
>   tools/testing/selftests/Makefile                   |   1 +
>   tools/testing/selftests/kselftest/.gitignore       |   1 +
>   tools/testing/selftests/kselftest/Makefile         |   6 +
>   .../testing/selftests/kselftest/harness-selftest.c | 129 +++++++++++++++++++++
>   .../selftests/kselftest/harness-selftest.expected  |  62 ++++++++++
>   .../selftests/kselftest/harness-selftest.sh        |  14 +++
>   6 files changed, 213 insertions(+)
> 
> diff --git a/tools/testing/selftests/Makefile b/tools/testing/selftests/Makefile
> index c77c8c8e3d9bdd8047c9cb7722c3830447e504e5..3ce071eefa86af59aadd1df7972fdf3bf6e01d52 100644
> --- a/tools/testing/selftests/Makefile
> +++ b/tools/testing/selftests/Makefile
> @@ -48,6 +48,7 @@ TARGETS += ipc
>   TARGETS += ir
>   TARGETS += kcmp
>   TARGETS += kexec
> +TARGETS += kselftest

kselftest name can be confusing to users  since the the test suite is called
kselftest in the main Makefile. Find different name - kselftest_harness?

Also don't add files to selftests/kselftest - create a new directory.

make kselftest (runs the entire suite).

>   TARGETS += kvm
>   TARGETS += landlock
>   TARGETS += lib
> diff --git a/tools/testing/selftests/kselftest/.gitignore b/tools/testing/selftests/kselftest/.gitignore

Add a new directory - kselftest_harness?

> new file mode 100644
> index 0000000000000000000000000000000000000000..9aab194e8ea25a2c5ccc116f9f728b8afd0c51c4
> --- /dev/null
> +++ b/tools/testing/selftests/kselftest/.gitignore
> @@ -0,0 +1 @@
> +/harness-selftest
> diff --git a/tools/testing/selftests/kselftest/Makefile b/tools/testing/selftests/kselftest/Makefile
> new file mode 100644
> index 0000000000000000000000000000000000000000..2f2933553dbc47014d9dfe0b4bd8ad3bc36e38c2
> --- /dev/null
> +++ b/tools/testing/selftests/kselftest/Makefile

Same here - don't put these under selftests/kselftest

> @@ -0,0 +1,6 @@
> +# SPDX-License-Identifier: GPL-2.0
> +
> +TEST_GEN_PROGS_EXTENDED := harness-selftest
> +TEST_PROGS := harness-selftest.sh
> +
> +include ../lib.mk

Need a clean override since you are creatinbg a TMPFILE so it
gets cleaned up.

> diff --git a/tools/testing/selftests/kselftest/harness-selftest.c b/tools/testing/selftests/kselftest/harness-selftest.c
> new file mode 100644
> index 0000000000000000000000000000000000000000..8d39e7a0b99c41a5d33edfe2dbf875cac04c098d
> --- /dev/null
> +++ b/tools/testing/selftests/kselftest/harness-selftest.c
> @@ -0,0 +1,129 @@
> +// SPDX-License-Identifier: GPL-2.0
> +
> +#include <stdio.h>
> +
> +#ifndef NOLIBC
> +#include <sys/resource.h>
> +#include <sys/prctl.h>
> +#endif
> +
> +/* Avoid any inconsistencies */
> +#define TH_LOG_STREAM stdout
> +
> +#include "../kselftest_harness.h"
> +
> +TEST(standalone_pass) {
> +	TH_LOG("before");
> +	ASSERT_EQ(0, 0);
> +	EXPECT_EQ(0, 0);
> +	TH_LOG("after");
> +}
> +
> +TEST(standalone_fail) {
> +	TH_LOG("before");
> +	EXPECT_EQ(0, 0);
> +	EXPECT_EQ(0, 1);
> +	ASSERT_EQ(0, 1);
> +	TH_LOG("after");
> +}
> +
> +TEST_SIGNAL(signal_pass, SIGUSR1) {
> +	TH_LOG("before");
> +	ASSERT_EQ(0, 0);
> +	TH_LOG("after");
> +	kill(getpid(), SIGUSR1);
> +}
> +
> +TEST_SIGNAL(signal_fail, SIGUSR1) {
> +	TH_LOG("before");
> +	ASSERT_EQ(0, 1);
> +	TH_LOG("after");
> +	kill(getpid(), SIGUSR1);
> +}
> +
> +FIXTURE(fixture) {
> +	pid_t testpid;
> +};
> +
> +FIXTURE_SETUP(fixture) {
> +	TH_LOG("setup");
> +	self->testpid = getpid();
> +}
> +
> +FIXTURE_TEARDOWN(fixture) {
> +	TH_LOG("teardown same-process=%d", self->testpid == getpid());
> +}
> +
> +TEST_F(fixture, pass) {
> +	TH_LOG("before");
> +	ASSERT_EQ(0, 0);
> +	TH_LOG("after");
> +}
> +
> +TEST_F(fixture, fail) {
> +	TH_LOG("before");
> +	ASSERT_EQ(0, 1);
> +	TH_LOG("after");
> +}
> +
> +TEST_F_TIMEOUT(fixture, timeout, 1) {
> +	TH_LOG("before");
> +	sleep(2);
> +	TH_LOG("after");
> +}
> +
> +FIXTURE(fixture_parent) {
> +	pid_t testpid;
> +};
> +
> +FIXTURE_SETUP(fixture_parent) {
> +	TH_LOG("setup");
> +	self->testpid = getpid();
> +}
> +
> +FIXTURE_TEARDOWN_PARENT(fixture_parent) {
> +	TH_LOG("teardown same-process=%d", self->testpid == getpid());
> +}
> +
> +TEST_F(fixture_parent, pass) {
> +	TH_LOG("before");
> +	ASSERT_EQ(0, 0);
> +	TH_LOG("after");
> +}
> +
> +FIXTURE(fixture_setup_failure) {
> +	pid_t testpid;
> +};
> +
> +FIXTURE_SETUP(fixture_setup_failure) {
> +	TH_LOG("setup");
> +	self->testpid = getpid();
> +	ASSERT_EQ(0, 1);
> +}
> +
> +FIXTURE_TEARDOWN(fixture_setup_failure) {
> +	TH_LOG("teardown same-process=%d", self->testpid == getpid());
> +}
> +
> +TEST_F(fixture_setup_failure, pass) {
> +	TH_LOG("before");
> +	ASSERT_EQ(0, 0);
> +	TH_LOG("after");
> +}
> +
> +int main(int argc, char **argv)
> +{
> +	/*
> +	 * The harness uses abort() to signal assertion failures, which triggers coredumps.
> +	 * This may be useful to debug real failures but not for this selftest, disable them.
> +	 */
> +	struct rlimit rlimit = {
> +		.rlim_cur = 0,
> +		.rlim_max = 0,
> +	};
> +
> +	prctl(PR_SET_DUMPABLE, 0, 0, 0, 0);
> +	setrlimit(RLIMIT_CORE, &rlimit);
> +
> +	return test_harness_run(argc, argv);
> +}
> diff --git a/tools/testing/selftests/kselftest/harness-selftest.expected b/tools/testing/selftests/kselftest/harness-selftest.expected
> new file mode 100644
> index 0000000000000000000000000000000000000000..1aa6461db90d4e7cc0679f19b69aadf4032875ec
> --- /dev/null
> +++ b/tools/testing/selftests/kselftest/harness-selftest.expected
> @@ -0,0 +1,62 @@
> +TAP version 13
> +1..9
> +# Starting 9 tests from 4 test cases.
> +#  RUN           global.standalone_pass ...
> +# harness-selftest.c:16:standalone_pass:before
> +# harness-selftest.c:19:standalone_pass:after
> +#            OK  global.standalone_pass
> +ok 1 global.standalone_pass
> +#  RUN           global.standalone_fail ...
> +# harness-selftest.c:23:standalone_fail:before
> +# harness-selftest.c:25:standalone_fail:Expected 0 (0) == 1 (1)
> +# harness-selftest.c:26:standalone_fail:Expected 0 (0) == 1 (1)
> +# standalone_fail: Test terminated by assertion
> +#          FAIL  global.standalone_fail
> +not ok 2 global.standalone_fail
> +#  RUN           global.signal_pass ...
> +# harness-selftest.c:31:signal_pass:before
> +# harness-selftest.c:33:signal_pass:after
> +#            OK  global.signal_pass
> +ok 3 global.signal_pass
> +#  RUN           global.signal_fail ...
> +# harness-selftest.c:38:signal_fail:before
> +# harness-selftest.c:39:signal_fail:Expected 0 (0) == 1 (1)
> +# signal_fail: Test terminated by assertion
> +#          FAIL  global.signal_fail
> +not ok 4 global.signal_fail
> +#  RUN           fixture.pass ...
> +# harness-selftest.c:49:pass:setup
> +# harness-selftest.c:58:pass:before
> +# harness-selftest.c:60:pass:after
> +# harness-selftest.c:54:pass:teardown same-process=1
> +#            OK  fixture.pass
> +ok 5 fixture.pass
> +#  RUN           fixture.fail ...
> +# harness-selftest.c:49:fail:setup
> +# harness-selftest.c:64:fail:before
> +# harness-selftest.c:65:fail:Expected 0 (0) == 1 (1)
> +# harness-selftest.c:54:fail:teardown same-process=1
> +# fail: Test terminated by assertion
> +#          FAIL  fixture.fail
> +not ok 6 fixture.fail
> +#  RUN           fixture.timeout ...
> +# harness-selftest.c:49:timeout:setup
> +# harness-selftest.c:70:timeout:before
> +# timeout: Test terminated by timeout
> +#          FAIL  fixture.timeout
> +not ok 7 fixture.timeout
> +#  RUN           fixture_parent.pass ...
> +# harness-selftest.c:80:pass:setup
> +# harness-selftest.c:89:pass:before
> +# harness-selftest.c:91:pass:after
> +# harness-selftest.c:85:pass:teardown same-process=0
> +#            OK  fixture_parent.pass
> +ok 8 fixture_parent.pass
> +#  RUN           fixture_setup_failure.pass ...
> +# harness-selftest.c:99:pass:setup
> +# harness-selftest.c:101:pass:Expected 0 (0) == 1 (1)
> +# pass: Test terminated by assertion
> +#          FAIL  fixture_setup_failure.pass
> +not ok 9 fixture_setup_failure.pass
> +# FAILED: 4 / 9 tests passed.
> +# Totals: pass:4 fail:5 xfail:0 xpass:0 skip:0 error:0
> diff --git a/tools/testing/selftests/kselftest/harness-selftest.sh b/tools/testing/selftests/kselftest/harness-selftest.sh
> new file mode 100755
> index 0000000000000000000000000000000000000000..bf691adf0b41aaedb2fbc5f06add9fd1d5689044
> --- /dev/null
> +++ b/tools/testing/selftests/kselftest/harness-selftest.sh
> @@ -0,0 +1,14 @@
> +#!/bin/sh
> +# SPDX-License-Identifier: GPL-2.0
> +#
> +# Selftest for kselftest_harness.h
> +#
> +
> +DIR="$(dirname $(readlink -f "$0"))"
> +
> +TMPFILE="$(mktemp)"
> +trap 'rm "$TMPFILE"' EXIT
> +
> +$DIR/harness-selftest > "$TMPFILE"
> +
> +diff -u "$DIR"/harness-selftest.expected "$TMPFILE"

This TMPFILE needs to be removed from make clean

> 

thanks,
-- Shuah

[PATCH v2 02/32] selftests: harness: Use C89 comment style

[Thomas Weißschuh]

All comments in this file use C89 comment style.
Except for this one. Change it to get one step closer to C89
compatibility.

Signed-off-by: Thomas Weißschuh <thomas.weissschuh@linutronix.de>
---
 tools/testing/selftests/kselftest_harness.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tools/testing/selftests/kselftest_harness.h b/tools/testing/selftests/kselftest_harness.h
index 666c9fde76da9d25fe6e248a7f2143c113473fe1..bac4327775ea65dbe977e9b22ee548bedcbd33ff 100644
--- a/tools/testing/selftests/kselftest_harness.h
+++ b/tools/testing/selftests/kselftest_harness.h
@@ -983,7 +983,7 @@ static void __timeout_handler(int sig, siginfo_t *info, void *ucontext)
 	}
 
 	t->timed_out = true;
-	// signal process group
+	/* signal process group */
 	kill(-(t->pid), SIGKILL);
 }
 

-- 
2.49.0

Re: [PATCH v2 02/32] selftests: harness: Use C89 comment style

[Shuah Khan]

On 4/7/25 00:52, Thomas Weißschuh wrote:
> All comments in this file use C89 comment style.
> Except for this one. Change it to get one step closer to C89
> compatibility.
> 
> Signed-off-by: Thomas Weißschuh <thomas.weissschuh@linutronix.de>
> ---
>   tools/testing/selftests/kselftest_harness.h | 2 +-
>   1 file changed, 1 insertion(+), 1 deletion(-)
> 
> diff --git a/tools/testing/selftests/kselftest_harness.h b/tools/testing/selftests/kselftest_harness.h
> index 666c9fde76da9d25fe6e248a7f2143c113473fe1..bac4327775ea65dbe977e9b22ee548bedcbd33ff 100644
> --- a/tools/testing/selftests/kselftest_harness.h
> +++ b/tools/testing/selftests/kselftest_harness.h
> @@ -983,7 +983,7 @@ static void __timeout_handler(int sig, siginfo_t *info, void *ucontext)
>   	}
>   
>   	t->timed_out = true;
> -	// signal process group
> +	/* signal process group */
>   	kill(-(t->pid), SIGKILL);
>   }
>   
> 

Looks good to me.

thanks,
-- Shuah

[PATCH v2 03/32] selftests: harness: Ignore unused variant argument warning

[Thomas Weißschuh]

For tests without fixtures the variant argument is unused.
This is intentional, prevent to compiler from complaining.

Signed-off-by: Thomas Weißschuh <thomas.weissschuh@linutronix.de>
---
 tools/testing/selftests/kselftest_harness.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tools/testing/selftests/kselftest_harness.h b/tools/testing/selftests/kselftest_harness.h
index bac4327775ea65dbe977e9b22ee548bedcbd33ff..2b350ed60b2bf1cbede8e3a9b4ac5fe716900144 100644
--- a/tools/testing/selftests/kselftest_harness.h
+++ b/tools/testing/selftests/kselftest_harness.h
@@ -174,7 +174,7 @@
 	static void test_name(struct __test_metadata *_metadata); \
 	static inline void wrapper_##test_name( \
 		struct __test_metadata *_metadata, \
-		struct __fixture_variant_metadata *variant) \
+		struct __fixture_variant_metadata __attribute__((unused)) *variant) \
 	{ \
 		_metadata->setup_completed = true; \
 		if (setjmp(_metadata->env) == 0) \

-- 
2.49.0

Re: [PATCH v2 03/32] selftests: harness: Ignore unused variant argument warning

[Shuah Khan]

On 4/7/25 00:52, Thomas Weißschuh wrote:
> For tests without fixtures the variant argument is unused.
> This is intentional, prevent to compiler from complaining.
> 

Include the warning in the change log for reference.

> Signed-off-by: Thomas Weißschuh <thomas.weissschuh@linutronix.de>
> ---
>   tools/testing/selftests/kselftest_harness.h | 2 +-
>   1 file changed, 1 insertion(+), 1 deletion(-)
> 
> diff --git a/tools/testing/selftests/kselftest_harness.h b/tools/testing/selftests/kselftest_harness.h
> index bac4327775ea65dbe977e9b22ee548bedcbd33ff..2b350ed60b2bf1cbede8e3a9b4ac5fe716900144 100644
> --- a/tools/testing/selftests/kselftest_harness.h
> +++ b/tools/testing/selftests/kselftest_harness.h
> @@ -174,7 +174,7 @@
>   	static void test_name(struct __test_metadata *_metadata); \
>   	static inline void wrapper_##test_name( \
>   		struct __test_metadata *_metadata, \
> -		struct __fixture_variant_metadata *variant) \
> +		struct __fixture_variant_metadata __attribute__((unused)) *variant) \
>   	{ \
>   		_metadata->setup_completed = true; \
>   		if (setjmp(_metadata->env) == 0) \
> 

thanks,
-- Shuah

[PATCH v2 04/32] selftests: harness: Mark functions without prototypes static

[Thomas Weißschuh]

With -Wmissing-prototypes the compiler will warn about non-static
functions which don't have a prototype defined.
As they are not used from a different compilation unit they don't need to
be defined globally.

Avoid the issue by marking the functions static.

Signed-off-by: Thomas Weißschuh <thomas.weissschuh@linutronix.de>
---
 tools/testing/selftests/kselftest_harness.h | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/tools/testing/selftests/kselftest_harness.h b/tools/testing/selftests/kselftest_harness.h
index 2b350ed60b2bf1cbede8e3a9b4ac5fe716900144..5822bc0b86a3c623fd34830fb8b541b27672a00b 100644
--- a/tools/testing/selftests/kselftest_harness.h
+++ b/tools/testing/selftests/kselftest_harness.h
@@ -258,7 +258,7 @@
  * A bare "return;" statement may be used to return early.
  */
 #define FIXTURE_SETUP(fixture_name) \
-	void fixture_name##_setup( \
+	static void fixture_name##_setup( \
 		struct __test_metadata __attribute__((unused)) *_metadata, \
 		FIXTURE_DATA(fixture_name) __attribute__((unused)) *self, \
 		const FIXTURE_VARIANT(fixture_name) \
@@ -307,7 +307,7 @@
 	__FIXTURE_TEARDOWN(fixture_name)
 
 #define __FIXTURE_TEARDOWN(fixture_name) \
-	void fixture_name##_teardown( \
+	static void fixture_name##_teardown( \
 		struct __test_metadata __attribute__((unused)) *_metadata, \
 		FIXTURE_DATA(fixture_name) __attribute__((unused)) *self, \
 		const FIXTURE_VARIANT(fixture_name) \
@@ -987,7 +987,7 @@ static void __timeout_handler(int sig, siginfo_t *info, void *ucontext)
 	kill(-(t->pid), SIGKILL);
 }
 
-void __wait_for_test(struct __test_metadata *t)
+static void __wait_for_test(struct __test_metadata *t)
 {
 	struct sigaction action = {
 		.sa_sigaction = __timeout_handler,
@@ -1205,9 +1205,9 @@ static bool test_enabled(int argc, char **argv,
 	return !has_positive;
 }
 
-void __run_test(struct __fixture_metadata *f,
-		struct __fixture_variant_metadata *variant,
-		struct __test_metadata *t)
+static void __run_test(struct __fixture_metadata *f,
+		       struct __fixture_variant_metadata *variant,
+		       struct __test_metadata *t)
 {
 	struct __test_xfail *xfail;
 	char test_name[1024];

-- 
2.49.0

[PATCH v2 05/32] selftests: harness: Remove inline qualifier for wrappers

[Thomas Weißschuh]

The pointers to the wrappers are stored in function pointers,
preventing them from actually being inlined.
Remove the inline qualifier, aligning these wrappers with the other
functions defined through macros.

Signed-off-by: Thomas Weißschuh <thomas.weissschuh@linutronix.de>
---
 tools/testing/selftests/kselftest_harness.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/tools/testing/selftests/kselftest_harness.h b/tools/testing/selftests/kselftest_harness.h
index 5822bc0b86a3c623fd34830fb8b541b27672a00b..222a4f51a8d704c41597e09a241ad887ef787139 100644
--- a/tools/testing/selftests/kselftest_harness.h
+++ b/tools/testing/selftests/kselftest_harness.h
@@ -172,7 +172,7 @@
 
 #define __TEST_IMPL(test_name, _signal) \
 	static void test_name(struct __test_metadata *_metadata); \
-	static inline void wrapper_##test_name( \
+	static void wrapper_##test_name( \
 		struct __test_metadata *_metadata, \
 		struct __fixture_variant_metadata __attribute__((unused)) *variant) \
 	{ \
@@ -401,7 +401,7 @@
 		struct __test_metadata *_metadata, \
 		FIXTURE_DATA(fixture_name) *self, \
 		const FIXTURE_VARIANT(fixture_name) *variant); \
-	static inline void wrapper_##fixture_name##_##test_name( \
+	static void wrapper_##fixture_name##_##test_name( \
 		struct __test_metadata *_metadata, \
 		struct __fixture_variant_metadata *variant) \
 	{ \

-- 
2.49.0

[PATCH v2 06/32] selftests: harness: Remove dependency on libatomic

[Thomas Weißschuh]

__sync_bool_compare_and_swap() is deprecated and requires libatomic on
GCC. Compiler toolchains don't necessarily have libatomic available, so
avoid this requirement by using atomics that don't need libatomic.

Signed-off-by: Thomas Weißschuh <thomas.weissschuh@linutronix.de>
---
 tools/testing/selftests/kselftest_harness.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/tools/testing/selftests/kselftest_harness.h b/tools/testing/selftests/kselftest_harness.h
index 222a4f51a8d704c41597e09a241ad887ef787139..7ec4f66d0e3d7f129f6c2a45ff58310dabe5d03f 100644
--- a/tools/testing/selftests/kselftest_harness.h
+++ b/tools/testing/selftests/kselftest_harness.h
@@ -439,12 +439,12 @@
 		} \
 		if (child == 0) { \
 			if (_metadata->setup_completed && !fixture_name##_teardown_parent && \
-					__sync_bool_compare_and_swap(teardown, false, true)) \
+					!__atomic_test_and_set(teardown, __ATOMIC_RELAXED)) \
 				fixture_name##_teardown(_metadata, self, variant->data); \
 			_exit(0); \
 		} \
 		if (_metadata->setup_completed && fixture_name##_teardown_parent && \
-				__sync_bool_compare_and_swap(teardown, false, true)) \
+				!__atomic_test_and_set(teardown, __ATOMIC_RELAXED)) \
 			fixture_name##_teardown(_metadata, self, variant->data); \
 		munmap(teardown, sizeof(*teardown)); \
 		if (self && fixture_name##_teardown_parent) \

-- 
2.49.0

[PATCH v2 07/32] selftests: harness: Implement test timeouts through pidfd

[Thomas Weißschuh]

Make the harness compatible with nolibc which does not implement signals
by replacing the signal logic with pidfds.
The code also becomes simpler.

Signed-off-by: Thomas Weißschuh <thomas.weissschuh@linutronix.de>
---
 tools/testing/selftests/kselftest_harness.h | 72 ++++++++++-------------------
 1 file changed, 25 insertions(+), 47 deletions(-)

diff --git a/tools/testing/selftests/kselftest_harness.h b/tools/testing/selftests/kselftest_harness.h
index 7ec4f66d0e3d7f129f6c2a45ff58310dabe5d03f..1e459619fe8657d7d213a7b16d7bcbc58e76e892 100644
--- a/tools/testing/selftests/kselftest_harness.h
+++ b/tools/testing/selftests/kselftest_harness.h
@@ -56,6 +56,8 @@
 #include <asm/types.h>
 #include <ctype.h>
 #include <errno.h>
+#include <linux/unistd.h>
+#include <poll.h>
 #include <stdbool.h>
 #include <stdint.h>
 #include <stdio.h>
@@ -914,7 +916,6 @@ struct __test_metadata {
 	int exit_code;
 	int trigger; /* extra handler after the evaluation */
 	int timeout;	/* seconds to wait for test timeout */
-	bool timed_out;	/* did this test timeout instead of exiting? */
 	bool aborted;	/* stopped test due to failed ASSERT */
 	bool setup_completed; /* did setup finish? */
 	jmp_buf env;	/* for exiting out of test early */
@@ -964,75 +965,52 @@ static inline void __test_check_assert(struct __test_metadata *t)
 		abort();
 }
 
-struct __test_metadata *__active_test;
-static void __timeout_handler(int sig, siginfo_t *info, void *ucontext)
-{
-	struct __test_metadata *t = __active_test;
-
-	/* Sanity check handler execution environment. */
-	if (!t) {
-		fprintf(TH_LOG_STREAM,
-			"# no active test in SIGALRM handler!?\n");
-		abort();
-	}
-	if (sig != SIGALRM || sig != info->si_signo) {
-		fprintf(TH_LOG_STREAM,
-			"# %s: SIGALRM handler caught signal %d!?\n",
-			t->name, sig != SIGALRM ? sig : info->si_signo);
-		abort();
-	}
-
-	t->timed_out = true;
-	/* signal process group */
-	kill(-(t->pid), SIGKILL);
-}
-
 static void __wait_for_test(struct __test_metadata *t)
 {
-	struct sigaction action = {
-		.sa_sigaction = __timeout_handler,
-		.sa_flags = SA_SIGINFO,
-	};
-	struct sigaction saved_action;
 	/*
 	 * Sets status so that WIFEXITED(status) returns true and
 	 * WEXITSTATUS(status) returns KSFT_FAIL.  This safe default value
 	 * should never be evaluated because of the waitpid(2) check and
-	 * SIGALRM handling.
+	 * timeout handling.
 	 */
 	int status = KSFT_FAIL << 8;
-	int child;
+	struct pollfd poll_child;
+	int ret, child, childfd;
+	bool timed_out = false;
 
-	if (sigaction(SIGALRM, &action, &saved_action)) {
+	childfd = syscall(__NR_pidfd_open, t->pid, 0);
+	if (childfd == -1) {
 		t->exit_code = KSFT_FAIL;
 		fprintf(TH_LOG_STREAM,
-			"# %s: unable to install SIGALRM handler\n",
+			"# %s: unable to open pidfd\n",
 			t->name);
 		return;
 	}
-	__active_test = t;
-	t->timed_out = false;
-	alarm(t->timeout);
-	child = waitpid(t->pid, &status, 0);
-	if (child == -1 && errno != EINTR) {
+
+	poll_child.fd = childfd;
+	poll_child.events = POLLIN;
+	ret = poll(&poll_child, 1, t->timeout * 1000);
+	if (ret == -1) {
 		t->exit_code = KSFT_FAIL;
 		fprintf(TH_LOG_STREAM,
-			"# %s: Failed to wait for PID %d (errno: %d)\n",
-			t->name, t->pid, errno);
+			"# %s: unable to wait on child pidfd\n",
+			t->name);
 		return;
+	} else if (ret == 0) {
+		timed_out = true;
+		/* signal process group */
+		kill(-(t->pid), SIGKILL);
 	}
-
-	alarm(0);
-	if (sigaction(SIGALRM, &saved_action, NULL)) {
+	child = waitpid(t->pid, &status, WNOHANG);
+	if (child == -1 && errno != EINTR) {
 		t->exit_code = KSFT_FAIL;
 		fprintf(TH_LOG_STREAM,
-			"# %s: unable to uninstall SIGALRM handler\n",
-			t->name);
+			"# %s: Failed to wait for PID %d (errno: %d)\n",
+			t->name, t->pid, errno);
 		return;
 	}
-	__active_test = NULL;
 
-	if (t->timed_out) {
+	if (timed_out) {
 		t->exit_code = KSFT_FAIL;
 		fprintf(TH_LOG_STREAM,
 			"# %s: Test terminated by timeout\n", t->name);

-- 
2.49.0

[PATCH v2 08/32] selftests: harness: Don't set setup_completed for fixtureless tests

[Thomas Weißschuh]

This field is unused and has no meaning for tests without fixtures.
Don't set it for them.

Signed-off-by: Thomas Weißschuh <thomas.weissschuh@linutronix.de>
---
 tools/testing/selftests/kselftest_harness.h | 1 -
 1 file changed, 1 deletion(-)

diff --git a/tools/testing/selftests/kselftest_harness.h b/tools/testing/selftests/kselftest_harness.h
index 1e459619fe8657d7d213a7b16d7bcbc58e76e892..905986debbfb0ce8c9659dbd52b6c67c6759cae7 100644
--- a/tools/testing/selftests/kselftest_harness.h
+++ b/tools/testing/selftests/kselftest_harness.h
@@ -178,7 +178,6 @@
 		struct __test_metadata *_metadata, \
 		struct __fixture_variant_metadata __attribute__((unused)) *variant) \
 	{ \
-		_metadata->setup_completed = true; \
 		if (setjmp(_metadata->env) == 0) \
 			test_name(_metadata); \
 		__test_check_assert(_metadata); \

-- 
2.49.0

[PATCH v2 09/32] selftests: harness: Always provide "self" and "variant"

[Thomas Weißschuh]

Some upcoming changes to the assertion macros need those two symbols
also to be available for tests without fixtures.
Provide them with a NULL value.

Signed-off-by: Thomas Weißschuh <thomas.weissschuh@linutronix.de>
---
 tools/testing/selftests/kselftest_harness.h | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/tools/testing/selftests/kselftest_harness.h b/tools/testing/selftests/kselftest_harness.h
index 905986debbfb0ce8c9659dbd52b6c67c6759cae7..4038ceeb42a870a2b77c6888df8a7bb4c4a258ba 100644
--- a/tools/testing/selftests/kselftest_harness.h
+++ b/tools/testing/selftests/kselftest_harness.h
@@ -173,13 +173,13 @@
 #define TEST_SIGNAL(test_name, signal) __TEST_IMPL(test_name, signal)
 
 #define __TEST_IMPL(test_name, _signal) \
-	static void test_name(struct __test_metadata *_metadata); \
+	static void test_name(struct __test_metadata *_metadata, void *self, const void *variant); \
 	static void wrapper_##test_name( \
 		struct __test_metadata *_metadata, \
 		struct __fixture_variant_metadata __attribute__((unused)) *variant) \
 	{ \
 		if (setjmp(_metadata->env) == 0) \
-			test_name(_metadata); \
+			test_name(_metadata, NULL, NULL); \
 		__test_check_assert(_metadata); \
 	} \
 	static struct __test_metadata _##test_name##_object = \
@@ -193,7 +193,9 @@
 		__register_test(&_##test_name##_object); \
 	} \
 	static void test_name( \
-		struct __test_metadata __attribute__((unused)) *_metadata)
+		struct __test_metadata __attribute__((unused)) *_metadata, \
+		void __attribute__((unused)) *self, \
+		const void __attribute__((unused)) *variant)
 
 /**
  * FIXTURE_DATA() - Wraps the struct name so we have one less

-- 
2.49.0

[PATCH v2 10/32] selftests: harness: Move teardown conditional into test metadata

[Thomas Weißschuh]

To get rid of setjmp()/longjmp(), the teardown logic needs to be usable
from __bail(). To access the atomic teardown conditional from there,
move it into the test metadata.
This also allows the removal of "setup_completed".

Signed-off-by: Thomas Weißschuh <thomas.weissschuh@linutronix.de>
---
 tools/testing/selftests/kselftest_harness.h | 21 +++++++++++----------
 1 file changed, 11 insertions(+), 10 deletions(-)

diff --git a/tools/testing/selftests/kselftest_harness.h b/tools/testing/selftests/kselftest_harness.h
index 4038ceeb42a870a2b77c6888df8a7bb4c4a258ba..790445c541aa3875d8d42822ab979295cc869d39 100644
--- a/tools/testing/selftests/kselftest_harness.h
+++ b/tools/testing/selftests/kselftest_harness.h
@@ -413,9 +413,9 @@
 		pid_t child = 1; \
 		int status = 0; \
 		/* Makes sure there is only one teardown, even when child forks again. */ \
-		bool *teardown = mmap(NULL, sizeof(*teardown), \
+		_metadata->no_teardown = mmap(NULL, sizeof(*_metadata->no_teardown), \
 			PROT_READ | PROT_WRITE, MAP_SHARED | MAP_ANONYMOUS, -1, 0); \
-		*teardown = false; \
+		*_metadata->no_teardown = true; \
 		if (sizeof(*self) > 0) { \
 			if (fixture_name##_teardown_parent) { \
 				self = mmap(NULL, sizeof(*self), PROT_READ | PROT_WRITE, \
@@ -433,7 +433,7 @@
 				/* Let setup failure terminate early. */ \
 				if (_metadata->exit_code) \
 					_exit(0); \
-				_metadata->setup_completed = true; \
+				*_metadata->no_teardown = false; \
 				fixture_name##_##test_name(_metadata, self, variant->data); \
 			} else if (child < 0 || child != waitpid(child, &status, 0)) { \
 				ksft_print_msg("ERROR SPAWNING TEST GRANDCHILD\n"); \
@@ -441,15 +441,16 @@
 			} \
 		} \
 		if (child == 0) { \
-			if (_metadata->setup_completed && !fixture_name##_teardown_parent && \
-					!__atomic_test_and_set(teardown, __ATOMIC_RELAXED)) \
+			if (!fixture_name##_teardown_parent && \
+					!__atomic_test_and_set(_metadata->no_teardown, __ATOMIC_RELAXED)) \
 				fixture_name##_teardown(_metadata, self, variant->data); \
 			_exit(0); \
 		} \
-		if (_metadata->setup_completed && fixture_name##_teardown_parent && \
-				!__atomic_test_and_set(teardown, __ATOMIC_RELAXED)) \
+		if (fixture_name##_teardown_parent && \
+				!__atomic_test_and_set(_metadata->no_teardown, __ATOMIC_RELAXED)) \
 			fixture_name##_teardown(_metadata, self, variant->data); \
-		munmap(teardown, sizeof(*teardown)); \
+		munmap(_metadata->no_teardown, sizeof(*_metadata->no_teardown)); \
+		_metadata->no_teardown = NULL; \
 		if (self && fixture_name##_teardown_parent) \
 			munmap(self, sizeof(*self)); \
 		if (WIFEXITED(status)) { \
@@ -918,7 +919,7 @@ struct __test_metadata {
 	int trigger; /* extra handler after the evaluation */
 	int timeout;	/* seconds to wait for test timeout */
 	bool aborted;	/* stopped test due to failed ASSERT */
-	bool setup_completed; /* did setup finish? */
+	bool *no_teardown; /* fixture needs teardown */
 	jmp_buf env;	/* for exiting out of test early */
 	struct __test_results *results;
 	struct __test_metadata *prev, *next;
@@ -1197,7 +1198,7 @@ static void __run_test(struct __fixture_metadata *f,
 	t->exit_code = KSFT_PASS;
 	t->trigger = 0;
 	t->aborted = false;
-	t->setup_completed = false;
+	t->no_teardown = NULL;
 	memset(t->env, 0, sizeof(t->env));
 	memset(t->results->reason, 0, sizeof(t->results->reason));
 

-- 
2.49.0

[PATCH v2 11/32] selftests: harness: Add teardown callback to test metadata

[Thomas Weißschuh]

To get rid of setjmp()/longjmp(), the teardown logic needs to be usable
from __bail(). Introduce a new callback for it.

Signed-off-by: Thomas Weißschuh <thomas.weissschuh@linutronix.de>
---
 tools/testing/selftests/kselftest_harness.h | 19 +++++++++++++------
 1 file changed, 13 insertions(+), 6 deletions(-)

diff --git a/tools/testing/selftests/kselftest_harness.h b/tools/testing/selftests/kselftest_harness.h
index 790445c541aa3875d8d42822ab979295cc869d39..5373b8da8886aef5df3368aeff95080636ae2343 100644
--- a/tools/testing/selftests/kselftest_harness.h
+++ b/tools/testing/selftests/kselftest_harness.h
@@ -441,14 +441,10 @@
 			} \
 		} \
 		if (child == 0) { \
-			if (!fixture_name##_teardown_parent && \
-					!__atomic_test_and_set(_metadata->no_teardown, __ATOMIC_RELAXED)) \
-				fixture_name##_teardown(_metadata, self, variant->data); \
+			_metadata->teardown_fn(false, _metadata, self, variant->data); \
 			_exit(0); \
 		} \
-		if (fixture_name##_teardown_parent && \
-				!__atomic_test_and_set(_metadata->no_teardown, __ATOMIC_RELAXED)) \
-			fixture_name##_teardown(_metadata, self, variant->data); \
+		_metadata->teardown_fn(true, _metadata, self, variant->data); \
 		munmap(_metadata->no_teardown, sizeof(*_metadata->no_teardown)); \
 		_metadata->no_teardown = NULL; \
 		if (self && fixture_name##_teardown_parent) \
@@ -462,6 +458,14 @@
 		} \
 		__test_check_assert(_metadata); \
 	} \
+	static void wrapper_##fixture_name##_##test_name##_teardown( \
+		bool in_parent, struct __test_metadata *_metadata, \
+		void *self, const void *variant) \
+	{ \
+		if (fixture_name##_teardown_parent == in_parent && \
+				!__atomic_test_and_set(_metadata->no_teardown, __ATOMIC_RELAXED)) \
+			fixture_name##_teardown(_metadata, self, variant); \
+	} \
 	static struct __test_metadata *_##fixture_name##_##test_name##_object; \
 	static void __attribute__((constructor)) \
 			_register_##fixture_name##_##test_name(void) \
@@ -471,6 +475,7 @@
 		object->name = #test_name; \
 		object->fn = &wrapper_##fixture_name##_##test_name; \
 		object->fixture = &_##fixture_name##_fixture_object; \
+		object->teardown_fn = &wrapper_##fixture_name##_##test_name##_teardown; \
 		object->termsig = signal; \
 		object->timeout = tmout; \
 		_##fixture_name##_##test_name##_object = object; \
@@ -914,6 +919,8 @@ struct __test_metadata {
 		   struct __fixture_variant_metadata *);
 	pid_t pid;	/* pid of test when being run */
 	struct __fixture_metadata *fixture;
+	void (*teardown_fn)(bool in_parent, struct __test_metadata *_metadata,
+			    void *self, const void *variant);
 	int termsig;
 	int exit_code;
 	int trigger; /* extra handler after the evaluation */

-- 
2.49.0

[PATCH v2 12/32] selftests: harness: Stop using setjmp()/longjmp()

[Thomas Weißschuh]

Usage of longjmp() was added to ensure that teardown is always run in
commit 63e6b2a42342 ("selftests/harness: Run TEARDOWN for ASSERT failures")
However instead of calling longjmp() to the teardown handler it is easier to
just call the teardown handler directly from __bail().
Any potential duplicate teardown invocations are harmless as the actual
handler will only ever be executed once since
commit fff37bd32c76 ("selftests/harness: Fix fixture teardown").

Additionally this removes a incompatibility with nolibc,
which does not support setjmp()/longjmp().

Signed-off-by: Thomas Weißschuh <thomas.weissschuh@linutronix.de>
---
 tools/testing/selftests/kselftest_harness.h | 49 ++++++++++-------------------
 1 file changed, 17 insertions(+), 32 deletions(-)

diff --git a/tools/testing/selftests/kselftest_harness.h b/tools/testing/selftests/kselftest_harness.h
index 5373b8da8886aef5df3368aeff95080636ae2343..1e584f39a42023c400988dea96f0274d4dc3645b 100644
--- a/tools/testing/selftests/kselftest_harness.h
+++ b/tools/testing/selftests/kselftest_harness.h
@@ -67,7 +67,6 @@
 #include <sys/types.h>
 #include <sys/wait.h>
 #include <unistd.h>
-#include <setjmp.h>
 
 #include "kselftest.h"
 
@@ -178,9 +177,7 @@
 		struct __test_metadata *_metadata, \
 		struct __fixture_variant_metadata __attribute__((unused)) *variant) \
 	{ \
-		if (setjmp(_metadata->env) == 0) \
-			test_name(_metadata, NULL, NULL); \
-		__test_check_assert(_metadata); \
+		test_name(_metadata, NULL, NULL); \
 	} \
 	static struct __test_metadata _##test_name##_object = \
 		{ .name = #test_name, \
@@ -425,24 +422,20 @@
 				self = &self_private; \
 			} \
 		} \
-		if (setjmp(_metadata->env) == 0) { \
-			/* _metadata and potentially self are shared with all forks. */ \
-			child = fork(); \
-			if (child == 0) { \
-				fixture_name##_setup(_metadata, self, variant->data); \
-				/* Let setup failure terminate early. */ \
-				if (_metadata->exit_code) \
-					_exit(0); \
-				*_metadata->no_teardown = false; \
-				fixture_name##_##test_name(_metadata, self, variant->data); \
-			} else if (child < 0 || child != waitpid(child, &status, 0)) { \
-				ksft_print_msg("ERROR SPAWNING TEST GRANDCHILD\n"); \
-				_metadata->exit_code = KSFT_FAIL; \
-			} \
-		} \
+		/* _metadata and potentially self are shared with all forks. */ \
+		child = fork(); \
 		if (child == 0) { \
+			fixture_name##_setup(_metadata, self, variant->data); \
+			/* Let setup failure terminate early. */ \
+			if (_metadata->exit_code) \
+				_exit(0); \
+			*_metadata->no_teardown = false; \
+			fixture_name##_##test_name(_metadata, self, variant->data); \
 			_metadata->teardown_fn(false, _metadata, self, variant->data); \
 			_exit(0); \
+		} else if (child < 0 || child != waitpid(child, &status, 0)) { \
+			ksft_print_msg("ERROR SPAWNING TEST GRANDCHILD\n"); \
+			_metadata->exit_code = KSFT_FAIL; \
 		} \
 		_metadata->teardown_fn(true, _metadata, self, variant->data); \
 		munmap(_metadata->no_teardown, sizeof(*_metadata->no_teardown)); \
@@ -456,7 +449,6 @@
 			/* Forward signal to __wait_for_test(). */ \
 			kill(getpid(), WTERMSIG(status)); \
 		} \
-		__test_check_assert(_metadata); \
 	} \
 	static void wrapper_##fixture_name##_##test_name##_teardown( \
 		bool in_parent, struct __test_metadata *_metadata, \
@@ -757,7 +749,7 @@
  */
 #define OPTIONAL_HANDLER(_assert) \
 	for (; _metadata->trigger; _metadata->trigger = \
-			__bail(_assert, _metadata))
+			__bail(_assert, _metadata, self, variant))
 
 #define is_signed_type(var)       (!!(((__typeof__(var))(-1)) < (__typeof__(var))1))
 
@@ -927,7 +919,6 @@ struct __test_metadata {
 	int timeout;	/* seconds to wait for test timeout */
 	bool aborted;	/* stopped test due to failed ASSERT */
 	bool *no_teardown; /* fixture needs teardown */
-	jmp_buf env;	/* for exiting out of test early */
 	struct __test_results *results;
 	struct __test_metadata *prev, *next;
 };
@@ -957,23 +948,18 @@ static inline void __register_xfail(struct __test_xfail *xf)
 	__LIST_APPEND(xf->variant->xfails, xf);
 }
 
-static inline int __bail(int for_realz, struct __test_metadata *t)
+static inline int __bail(int for_realz, struct __test_metadata *t, void *self, const void *variant)
 {
 	/* if this is ASSERT, return immediately. */
 	if (for_realz) {
-		t->aborted = true;
-		longjmp(t->env, 1);
+		if (t->teardown_fn)
+			t->teardown_fn(false, t, self, variant);
+		abort();
 	}
 	/* otherwise, end the for loop and continue. */
 	return 0;
 }
 
-static inline void __test_check_assert(struct __test_metadata *t)
-{
-	if (t->aborted)
-		abort();
-}
-
 static void __wait_for_test(struct __test_metadata *t)
 {
 	/*
@@ -1206,7 +1192,6 @@ static void __run_test(struct __fixture_metadata *f,
 	t->trigger = 0;
 	t->aborted = false;
 	t->no_teardown = NULL;
-	memset(t->env, 0, sizeof(t->env));
 	memset(t->results->reason, 0, sizeof(t->results->reason));
 
 	snprintf(test_name, sizeof(test_name), "%s%s%s.%s",

-- 
2.49.0

[PATCH v2 13/32] selftests: harness: Guard includes on nolibc

[Thomas Weißschuh]

Nolibc doesn't provide all normal header files.

Don't try to include these non-existent header files, as the symbols are
available unconditionally anyways.

Signed-off-by: Thomas Weißschuh <thomas.weissschuh@linutronix.de>
---
 tools/testing/selftests/kselftest_harness.h | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/tools/testing/selftests/kselftest_harness.h b/tools/testing/selftests/kselftest_harness.h
index 1e584f39a42023c400988dea96f0274d4dc3645b..4247c67b3060fbe9d224c1171f3ec998ae6b1080 100644
--- a/tools/testing/selftests/kselftest_harness.h
+++ b/tools/testing/selftests/kselftest_harness.h
@@ -57,16 +57,19 @@
 #include <ctype.h>
 #include <errno.h>
 #include <linux/unistd.h>
-#include <poll.h>
 #include <stdbool.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <unistd.h>
+
+#ifndef NOLIBC
+#include <poll.h>
 #include <sys/mman.h>
 #include <sys/types.h>
 #include <sys/wait.h>
-#include <unistd.h>
+#endif
 
 #include "kselftest.h"
 

-- 
2.49.0

[PATCH v2 14/32] tools/nolibc: handle intmax_t/uintmax_t in printf

[Thomas Weißschuh]

In nolibc intmax_t and uintmax_t are always the same as
(unsigned) long long/uint64_t as 128bit numbers are not supported.
Even libcs that do support 128bit numbers often fix intmax_t to 64bit
as it is used in ABIs and any change would break those.

Signed-off-by: Thomas Weißschuh <thomas.weissschuh@linutronix.de>
Acked-by: Willy Tarreau <w@1wt.eu>
---
 tools/include/nolibc/stdio.h                 | 2 ++
 tools/testing/selftests/nolibc/nolibc-test.c | 2 ++
 2 files changed, 4 insertions(+)

diff --git a/tools/include/nolibc/stdio.h b/tools/include/nolibc/stdio.h
index a403351dbf6098ac8292b9589ed8a054b4c5669f..b32b8b794015276ab6242c2be18f860c095f90a3 100644
--- a/tools/include/nolibc/stdio.h
+++ b/tools/include/nolibc/stdio.h
@@ -286,6 +286,8 @@ int vfprintf(FILE *stream, const char *fmt, va_list args)
 				if (c == 'l') {
 					/* long format prefix, maintain the escape */
 					lpref++;
+				} else if (c == 'j') {
+					lpref = 2;
 				}
 				escape = 1;
 				goto do_escape;
diff --git a/tools/testing/selftests/nolibc/nolibc-test.c b/tools/testing/selftests/nolibc/nolibc-test.c
index 5884a891c491544050fc35b07322c73a1a9dbaf3..ccf865e80eb715488f4ee5d623b7a02d9dd8abec 100644
--- a/tools/testing/selftests/nolibc/nolibc-test.c
+++ b/tools/testing/selftests/nolibc/nolibc-test.c
@@ -1430,6 +1430,8 @@ static int run_vfprintf(int min, int max)
 		CASE_TEST(char);         EXPECT_VFPRINTF(1, "c", "%c", 'c'); break;
 		CASE_TEST(hex);          EXPECT_VFPRINTF(1, "f", "%x", 0xf); break;
 		CASE_TEST(pointer);      EXPECT_VFPRINTF(3, "0x1", "%p", (void *) 0x1); break;
+		CASE_TEST(uintmax_t);    EXPECT_VFPRINTF(20, "18446744073709551615", "%ju", 0xffffffffffffffffULL); break;
+		CASE_TEST(intmax_t);     EXPECT_VFPRINTF(20, "-9223372036854775807", "%jd", 0x8000000000000001LL); break;
 		CASE_TEST(scanf);        EXPECT_ZR(1, test_scanf()); break;
 		case __LINE__:
 			return ret; /* must be last */

-- 
2.49.0

[PATCH v2 15/32] tools/nolibc: use intmax definitions from compiler

[Thomas Weißschuh]

The printf format checking in the compiler uses the intmax types from
the compiler, not libc. This can lead to compiler errors.

Instead use the types already provided by the compiler.

Example issue with clang 19 for arm64:

nolibc-test.c:30:2: error: format specifies type 'uintmax_t' (aka 'unsigned long') but the argument has type 'uintmax_t' (aka 'unsigned long long') [-Werror,-Wformat]

Signed-off-by: Thomas Weißschuh <thomas.weissschuh@linutronix.de>
Acked-by: Willy Tarreau <w@1wt.eu>
---
 tools/include/nolibc/stdint.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/tools/include/nolibc/stdint.h b/tools/include/nolibc/stdint.h
index cd79ddd6170e05b19945e66151bcbcf840028d32..b052ad6303c38f09685b645268dad1fa8848370d 100644
--- a/tools/include/nolibc/stdint.h
+++ b/tools/include/nolibc/stdint.h
@@ -39,8 +39,8 @@ typedef   size_t      uint_fast32_t;
 typedef  int64_t       int_fast64_t;
 typedef uint64_t      uint_fast64_t;
 
-typedef  int64_t           intmax_t;
-typedef uint64_t          uintmax_t;
+typedef __INTMAX_TYPE__    intmax_t;
+typedef __UINTMAX_TYPE__  uintmax_t;
 
 /* limits of integral types */
 

-- 
2.49.0

[PATCH v2 16/32] tools/nolibc: use pselect6_time64 if available

[Thomas Weißschuh]

riscv32 does not have any of the older select systemcalls.
Use pselect6_time64 instead.
poll() is also used to implement sleep().

Signed-off-by: Thomas Weißschuh <thomas.weissschuh@linutronix.de>
Acked-by: Willy Tarreau <w@1wt.eu>
---
 tools/include/nolibc/sys.h | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/tools/include/nolibc/sys.h b/tools/include/nolibc/sys.h
index 08c1c074bec89a27e53e5d461a3ebbf71ec323d1..a5decdba402236fa0935207f9207c771ac2700bf 100644
--- a/tools/include/nolibc/sys.h
+++ b/tools/include/nolibc/sys.h
@@ -1023,6 +1023,14 @@ int sys_select(int nfds, fd_set *rfds, fd_set *wfds, fd_set *efds, struct timeva
 		t.tv_nsec = timeout->tv_usec * 1000;
 	}
 	return my_syscall6(__NR_pselect6, nfds, rfds, wfds, efds, timeout ? &t : NULL, NULL);
+#elif defined(__NR_pselect6_time64)
+	struct __kernel_timespec t;
+
+	if (timeout) {
+		t.tv_sec  = timeout->tv_sec;
+		t.tv_nsec = timeout->tv_usec * 1000;
+	}
+	return my_syscall6(__NR_pselect6_time64, nfds, rfds, wfds, efds, timeout ? &t : NULL, NULL);
 #else
 	return __nolibc_enosys(__func__, nfds, rfds, wfds, efds, timeout);
 #endif

-- 
2.49.0

[PATCH v2 17/32] tools/nolibc: use ppoll_time64 if available

[Thomas Weißschuh]

riscv32 does not have any of the older poll systemcalls.
Use ppoll_time64 instead.

Signed-off-by: Thomas Weißschuh <thomas.weissschuh@linutronix.de>
Acked-by: Willy Tarreau <w@1wt.eu>
---
 tools/include/nolibc/sys.h | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/tools/include/nolibc/sys.h b/tools/include/nolibc/sys.h
index a5decdba402236fa0935207f9207c771ac2700bf..b04d83a7ec50cad7beb32198d9d47bd9d5873f69 100644
--- a/tools/include/nolibc/sys.h
+++ b/tools/include/nolibc/sys.h
@@ -893,6 +893,14 @@ int sys_poll(struct pollfd *fds, int nfds, int timeout)
 		t.tv_nsec = (timeout % 1000) * 1000000;
 	}
 	return my_syscall5(__NR_ppoll, fds, nfds, (timeout >= 0) ? &t : NULL, NULL, 0);
+#elif defined(__NR_ppoll_time64)
+	struct __kernel_timespec t;
+
+	if (timeout >= 0) {
+		t.tv_sec  = timeout / 1000;
+		t.tv_nsec = (timeout % 1000) * 1000000;
+	}
+	return my_syscall5(__NR_ppoll_time64, fds, nfds, (timeout >= 0) ? &t : NULL, NULL, 0);
 #elif defined(__NR_poll)
 	return my_syscall3(__NR_poll, fds, nfds, timeout);
 #else

-- 
2.49.0

[PATCH v2 18/32] tools/nolibc: add tolower() and toupper()

[Thomas Weißschuh]

The kselftest harness uses these functions.

Signed-off-by: Thomas Weißschuh <thomas.weissschuh@linutronix.de>
Acked-by: Willy Tarreau <w@1wt.eu>
---
 tools/include/nolibc/string.h                | 17 +++++++++++++++++
 tools/testing/selftests/nolibc/nolibc-test.c |  5 +++++
 2 files changed, 22 insertions(+)

diff --git a/tools/include/nolibc/string.h b/tools/include/nolibc/string.h
index ba84ab700e3001a7d105e1c9e40c01bf45db9d8c..f0d335f0e467ec870066811289dfd11e46e60a92 100644
--- a/tools/include/nolibc/string.h
+++ b/tools/include/nolibc/string.h
@@ -289,6 +289,23 @@ char *strrchr(const char *s, int c)
 	return (char *)ret;
 }
 
+static __attribute__((unused))
+int tolower(int c)
+{
+	if (c >= 'A' && c <= 'Z')
+		return c - 'A' + 'a';
+	return c;
+}
+
+static __attribute__((unused))
+int toupper(int c)
+{
+	if (c >= 'a' && c <= 'z')
+		return c - 'a' + 'A';
+	return c;
+}
+
+
 /* make sure to include all global symbols */
 #include "nolibc.h"
 
diff --git a/tools/testing/selftests/nolibc/nolibc-test.c b/tools/testing/selftests/nolibc/nolibc-test.c
index ccf865e80eb715488f4ee5d623b7a02d9dd8abec..70d418b87f7731572b85d64a8128c62d01df6b2b 100644
--- a/tools/testing/selftests/nolibc/nolibc-test.c
+++ b/tools/testing/selftests/nolibc/nolibc-test.c
@@ -40,6 +40,7 @@
 #include <stdint.h>
 #include <unistd.h>
 #include <limits.h>
+#include <ctype.h>
 #endif
 #endif
 
@@ -1281,6 +1282,10 @@ int run_stdlib(int min, int max)
 		CASE_TEST(strerror_EINVAL);         EXPECT_STREQ(is_nolibc, strerror(EINVAL), "errno=22"); break;
 		CASE_TEST(strerror_int_max);        EXPECT_STREQ(is_nolibc, strerror(INT_MAX), "errno=2147483647"); break;
 		CASE_TEST(strerror_int_min);        EXPECT_STREQ(is_nolibc, strerror(INT_MIN), "errno=-2147483648"); break;
+		CASE_TEST(tolower);                 EXPECT_EQ(1, tolower('A'), 'a'); break;
+		CASE_TEST(tolower_noop);            EXPECT_EQ(1, tolower('a'), 'a'); break;
+		CASE_TEST(toupper);                 EXPECT_EQ(1, toupper('a'), 'A'); break;
+		CASE_TEST(toupper_noop);            EXPECT_EQ(1, toupper('A'), 'A'); break;
 
 		case __LINE__:
 			return ret; /* must be last */

-- 
2.49.0

[PATCH v2 19/32] tools/nolibc: add _exit()

[Thomas Weißschuh]

_exit() is the faster variant of exit(), skipping all cleanup actions.
As nolibc does not perform any cleanup anyways, the implementation is
trivial.

Signed-off-by: Thomas Weißschuh <thomas.weissschuh@linutronix.de>
Acked-by: Willy Tarreau <w@1wt.eu>
---
 tools/include/nolibc/sys.h | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/tools/include/nolibc/sys.h b/tools/include/nolibc/sys.h
index b04d83a7ec50cad7beb32198d9d47bd9d5873f69..f52e1953020945fb2902d47ad5f7a8e7c2c1c290 100644
--- a/tools/include/nolibc/sys.h
+++ b/tools/include/nolibc/sys.h
@@ -301,11 +301,17 @@ void sys_exit(int status)
 }
 
 static __attribute__((noreturn,unused))
-void exit(int status)
+void _exit(int status)
 {
 	sys_exit(status);
 }
 
+static __attribute__((noreturn,unused))
+void exit(int status)
+{
+	_exit(status);
+}
+
 
 /*
  * pid_t fork(void);

-- 
2.49.0

[PATCH v2 20/32] tools/nolibc: add setpgrp()

[Thomas Weißschuh]

setpgrp() is defined to be identical to setpgid(0, 0).

Signed-off-by: Thomas Weißschuh <thomas.weissschuh@linutronix.de>
Acked-by: Willy Tarreau <w@1wt.eu>
---
 tools/include/nolibc/sys.h | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/tools/include/nolibc/sys.h b/tools/include/nolibc/sys.h
index f52e1953020945fb2902d47ad5f7a8e7c2c1c290..5c71a2f65c7bd93f6f516a54f7e63244466fad47 100644
--- a/tools/include/nolibc/sys.h
+++ b/tools/include/nolibc/sys.h
@@ -1073,6 +1073,16 @@ int setpgid(pid_t pid, pid_t pgid)
 	return __sysret(sys_setpgid(pid, pgid));
 }
 
+/*
+ * pid_t setpgrp(void)
+ */
+
+static __attribute__((unused))
+pid_t setpgrp(void)
+{
+	return setpgid(0, 0);
+}
+
 
 /*
  * pid_t setsid(void);

-- 
2.49.0

[PATCH v2 21/32] tools/nolibc: implement waitpid() in terms of waitid()

[Thomas Weißschuh]

The old wait4() syscall used by waitpid() before is not available everywhere.
Switch to the waitid() syscall which is the new replacement.

Signed-off-by: Thomas Weißschuh <thomas.weissschuh@linutronix.de>
Acked-by: Willy Tarreau <w@1wt.eu>
---
 tools/include/nolibc/sys.h | 71 ++++++++++++++++++++++++++++++++++++++--------
 1 file changed, 59 insertions(+), 12 deletions(-)

diff --git a/tools/include/nolibc/sys.h b/tools/include/nolibc/sys.h
index 5c71a2f65c7bd93f6f516a54f7e63244466fad47..e39eefb2b82cc97eccfc030005fe0321632f12c4 100644
--- a/tools/include/nolibc/sys.h
+++ b/tools/include/nolibc/sys.h
@@ -1267,6 +1267,7 @@ int unlink(const char *path)
  * pid_t wait(int *status);
  * pid_t wait4(pid_t pid, int *status, int options, struct rusage *rusage);
  * pid_t waitpid(pid_t pid, int *status, int options);
+ * int waitid(idtype_t idtype, id_t id, siginfo_t *infop, int options);
  */
 
 static __attribute__((unused))
@@ -1291,18 +1292,6 @@ pid_t wait4(pid_t pid, int *status, int options, struct rusage *rusage)
 	return __sysret(sys_wait4(pid, status, options, rusage));
 }
 
-
-static __attribute__((unused))
-pid_t waitpid(pid_t pid, int *status, int options)
-{
-	return __sysret(sys_wait4(pid, status, options, NULL));
-}
-
-
-/*
- * int waitid(idtype_t idtype, id_t id, siginfo_t *infop, int options);
- */
-
 static __attribute__((unused))
 int sys_waitid(int which, pid_t pid, siginfo_t *infop, int options, struct rusage *rusage)
 {
@@ -1316,6 +1305,64 @@ int waitid(int which, pid_t pid, siginfo_t *infop, int options)
 }
 
 
+static __attribute__((unused))
+pid_t waitpid(pid_t pid, int *status, int options)
+{
+	int idtype, ret;
+	siginfo_t info;
+	pid_t id;
+
+	if (pid == INT_MIN) {
+		SET_ERRNO(ESRCH);
+		return -1;
+	} else if (pid < -1) {
+		idtype = P_PGID;
+		id = -pid;
+	} else if (pid == -1) {
+		idtype = P_ALL;
+		id = 0;
+	} else if (pid == 0) {
+		idtype = P_PGID;
+		id = 0;
+	} else {
+		idtype = P_PID;
+		id = pid;
+	}
+
+	options |= WEXITED;
+
+	ret = waitid(idtype, id, &info, options);
+	if (ret)
+		return ret;
+
+	switch (info.si_code) {
+	case 0:
+		*status = 0;
+		break;
+	case CLD_EXITED:
+		*status = (info.si_status & 0xff) << 8;
+		break;
+	case CLD_KILLED:
+		*status = info.si_status & 0x7f;
+		break;
+	case CLD_DUMPED:
+		*status = (info.si_status & 0x7f) | 0x80;
+		break;
+	case CLD_STOPPED:
+	case CLD_TRAPPED:
+		*status = (info.si_status << 8) + 0x7f;
+		break;
+	case CLD_CONTINUED:
+		*status = 0xffff;
+		break;
+	default:
+		return -1;
+	}
+
+	return info.si_pid;
+}
+
+
 /*
  * ssize_t write(int fd, const void *buf, size_t count);
  */

-- 
2.49.0

[PATCH v2 22/32] Revert "selftests/nolibc: use waitid() over waitpid()"

[Thomas Weißschuh]

nolibc's waitpid() now uses the waitid() syscall internally.
This removes the original reasoning for the reverted commit as
waitpid() is now available on all platforms and has an easier interface.

Switch back to waitpid().

This reverts commit a0bc8947ac731ff95a56e0c1737e69e8c56d5b78.

Signed-off-by: Thomas Weißschuh <thomas.weissschuh@linutronix.de>
Acked-by: Willy Tarreau <w@1wt.eu>
---
 tools/testing/selftests/nolibc/nolibc-test.c | 10 ++++------
 1 file changed, 4 insertions(+), 6 deletions(-)

diff --git a/tools/testing/selftests/nolibc/nolibc-test.c b/tools/testing/selftests/nolibc/nolibc-test.c
index 70d418b87f7731572b85d64a8128c62d01df6b2b..b4b9a8422d76e1170ff967850429916a2190139b 100644
--- a/tools/testing/selftests/nolibc/nolibc-test.c
+++ b/tools/testing/selftests/nolibc/nolibc-test.c
@@ -1462,8 +1462,7 @@ static int run_protection(int min __attribute__((unused)),
 			  int max __attribute__((unused)))
 {
 	pid_t pid;
-	int llen = 0, ret;
-	siginfo_t siginfo = {};
+	int llen = 0, status;
 	struct rlimit rlimit = { 0, 0 };
 
 	llen += printf("0 -fstackprotector ");
@@ -1501,11 +1500,10 @@ static int run_protection(int min __attribute__((unused)),
 		return 1;
 
 	default:
-		ret = waitid(P_PID, pid, &siginfo, WEXITED);
+		pid = waitpid(pid, &status, 0);
 
-		if (ret != 0 || siginfo.si_signo != SIGCHLD ||
-		    siginfo.si_code != CLD_KILLED || siginfo.si_status != SIGABRT) {
-			llen += printf("waitid()");
+		if (pid == -1 || !WIFSIGNALED(status) || WTERMSIG(status) != SIGABRT) {
+			llen += printf("waitpid()");
 			result(llen, FAIL);
 			return 1;
 		}

-- 
2.49.0

[PATCH v2 23/32] tools/nolibc: add dprintf() and vdprintf()

[Thomas Weißschuh]

dprintf() and vdprintf() are printf() variants printing directly into a
filedescriptor. As FILE in nolibc is based directly on filedescriptors,
the implementation is trivial.

Signed-off-by: Thomas Weißschuh <thomas.weissschuh@linutronix.de>
Acked-by: Willy Tarreau <w@1wt.eu>
---
 tools/include/nolibc/stdio.h | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)

diff --git a/tools/include/nolibc/stdio.h b/tools/include/nolibc/stdio.h
index b32b8b794015276ab6242c2be18f860c095f90a3..262d0da4da9062e0c83b55661b2509f36548cf88 100644
--- a/tools/include/nolibc/stdio.h
+++ b/tools/include/nolibc/stdio.h
@@ -351,6 +351,30 @@ int printf(const char *fmt, ...)
 	return ret;
 }
 
+static __attribute__((unused, format(printf, 2, 0)))
+int vdprintf(int fd, const char *fmt, va_list args)
+{
+	FILE *stream;
+
+	stream = fdopen(fd, NULL);
+	if (!stream)
+		return -1;
+	/* Technically 'stream' is leaked, but as it's only a wrapper around 'fd' that is fine */
+	return vfprintf(stream, fmt, args);
+}
+
+static __attribute__((unused, format(printf, 2, 3)))
+int dprintf(int fd, const char *fmt, ...)
+{
+	va_list args;
+	int ret;
+
+	va_start(args, fmt);
+	ret = vdprintf(fd, fmt, args);
+	va_end(args);
+	return ret;
+}
+
 static __attribute__((unused))
 int vsscanf(const char *str, const char *format, va_list args)
 {

-- 
2.49.0

[PATCH v2 24/32] tools/nolibc: add getopt()

[Thomas Weißschuh]

Introduce a getopt() implementation based on the one from musl.
The only deviations are adaption to the kernel coding style and nolibc
infrastructure and removal of multi-byte support.

Signed-off-by: Thomas Weißschuh <thomas.weissschuh@linutronix.de>
Acked-by: Willy Tarreau <w@1wt.eu>
---
 tools/include/nolibc/Makefile |   1 +
 tools/include/nolibc/getopt.h | 101 ++++++++++++++++++++++++++++++++++++++++++
 tools/include/nolibc/nolibc.h |   1 +
 3 files changed, 103 insertions(+)

diff --git a/tools/include/nolibc/Makefile b/tools/include/nolibc/Makefile
index f9702877ac21ab5ad30df1740e40e67f477f3824..e47e1607bab82f1d91effc025c9257e8a451f047 100644
--- a/tools/include/nolibc/Makefile
+++ b/tools/include/nolibc/Makefile
@@ -31,6 +31,7 @@ all_files := \
 		ctype.h \
 		dirent.h \
 		errno.h \
+		getopt.h \
 		limits.h \
 		nolibc.h \
 		signal.h \
diff --git a/tools/include/nolibc/getopt.h b/tools/include/nolibc/getopt.h
new file mode 100644
index 0000000000000000000000000000000000000000..5fd06c9702e96e8c58a6b242f535bca09db69343
--- /dev/null
+++ b/tools/include/nolibc/getopt.h
@@ -0,0 +1,101 @@
+/* SPDX-License-Identifier: LGPL-2.1 OR MIT */
+/*
+ * getopt function definitions for NOLIBC, adapted from musl libc
+ * Copyright (C) 2005-2020 Rich Felker, et al.
+ * Copyright (C) 2025 Thomas Weißschuh <linux@weissschuh.net>
+ */
+
+#ifndef _NOLIBC_GETOPT_H
+#define _NOLIBC_GETOPT_H
+
+struct FILE;
+static struct FILE *const stderr;
+static int fprintf(struct FILE *stream, const char *fmt, ...);
+
+__attribute__((weak,unused,section(".data.nolibc_getopt")))
+char *optarg;
+
+__attribute__((weak,unused,section(".data.nolibc_getopt")))
+int optind = 1, opterr = 1, optopt;
+
+static __attribute__((unused))
+int getopt(int argc, char * const argv[], const char *optstring)
+{
+	static int __optpos;
+	int i;
+	char c, d;
+	char *optchar;
+
+	if (!optind) {
+		__optpos = 0;
+		optind = 1;
+	}
+
+	if (optind >= argc || !argv[optind])
+		return -1;
+
+	if (argv[optind][0] != '-') {
+		if (optstring[0] == '-') {
+			optarg = argv[optind++];
+			return 1;
+		}
+		return -1;
+	}
+
+	if (!argv[optind][1])
+		return -1;
+
+	if (argv[optind][1] == '-' && !argv[optind][2])
+		return optind++, -1;
+
+	if (!__optpos)
+		__optpos++;
+	c = argv[optind][__optpos];
+	optchar = argv[optind] + __optpos;
+	__optpos++;
+
+	if (!argv[optind][__optpos]) {
+		optind++;
+		__optpos = 0;
+	}
+
+	if (optstring[0] == '-' || optstring[0] == '+')
+		optstring++;
+
+	i = 0;
+	d = 0;
+	do {
+		d = optstring[i++];
+	} while (d && d != c);
+
+	if (d != c || c == ':') {
+		optopt = c;
+		if (optstring[0] != ':' && opterr)
+			fprintf(stderr, "%s: unrecognized option: %c\n", argv[0], *optchar);
+		return '?';
+	}
+	if (optstring[i] == ':') {
+		optarg = 0;
+		if (optstring[i + 1] != ':' || __optpos) {
+			optarg = argv[optind++];
+			if (__optpos)
+				optarg += __optpos;
+			__optpos = 0;
+		}
+		if (optind > argc) {
+			optopt = c;
+			if (optstring[0] == ':')
+				return ':';
+			if (opterr)
+				fprintf(stderr, "%s: option requires argument: %c\n",
+					argv[0], *optchar);
+			return '?';
+		}
+	}
+	return c;
+}
+
+/* make sure to include all global symbols */
+#include "nolibc.h"
+
+#endif /* _NOLIBC_GETOPT_H */
diff --git a/tools/include/nolibc/nolibc.h b/tools/include/nolibc/nolibc.h
index 70872401aca8d5aa37b12ee585193353f692576d..187490535d1359aff371e2981118e62bcc0c6948 100644
--- a/tools/include/nolibc/nolibc.h
+++ b/tools/include/nolibc/nolibc.h
@@ -105,6 +105,7 @@
 #include "time.h"
 #include "stackprotector.h"
 #include "dirent.h"
+#include "getopt.h"
 
 /* Used by programs to avoid std includes */
 #define NOLIBC

-- 
2.49.0

[PATCH v2 25/32] tools/nolibc: allow different write callbacks in printf

[Thomas Weißschuh]

Decouple the formatting logic from the writing logic to later enable
writing straight to a buffer in sprintf().

Signed-off-by: Thomas Weißschuh <thomas.weissschuh@linutronix.de>
Acked-by: Willy Tarreau <w@1wt.eu>
---
 tools/include/nolibc/stdio.h | 21 +++++++++++++++++----
 1 file changed, 17 insertions(+), 4 deletions(-)

diff --git a/tools/include/nolibc/stdio.h b/tools/include/nolibc/stdio.h
index 262d0da4da9062e0c83b55661b2509f36548cf88..5c893b4903a3040a366e11b600ccde30913d7db2 100644
--- a/tools/include/nolibc/stdio.h
+++ b/tools/include/nolibc/stdio.h
@@ -208,13 +208,15 @@ char *fgets(char *s, int size, FILE *stream)
 }
 
 
-/* minimal vfprintf(). It supports the following formats:
+/* minimal printf(). It supports the following formats:
  *  - %[l*]{d,u,c,x,p}
  *  - %s
  *  - unknown modifiers are ignored.
  */
-static __attribute__((unused, format(printf, 2, 0)))
-int vfprintf(FILE *stream, const char *fmt, va_list args)
+typedef int (*__nolibc_printf_cb)(intptr_t state, const char *buf, size_t size);
+
+static __attribute__((unused, format(printf, 3, 0)))
+int __nolibc_printf(__nolibc_printf_cb cb, intptr_t state, const char *fmt, va_list args)
 {
 	char escape, lpref, c;
 	unsigned long long v;
@@ -304,7 +306,7 @@ int vfprintf(FILE *stream, const char *fmt, va_list args)
 			outstr = fmt;
 			len = ofs - 1;
 		flush_str:
-			if (_fwrite(outstr, len, stream) != 0)
+			if (cb(state, outstr, len) != 0)
 				break;
 
 			written += len;
@@ -321,6 +323,17 @@ int vfprintf(FILE *stream, const char *fmt, va_list args)
 	return written;
 }
 
+static int __nolibc_fprintf_cb(intptr_t state, const char *buf, size_t size)
+{
+	return _fwrite(buf, size, (FILE *)state);
+}
+
+static __attribute__((unused, format(printf, 2, 0)))
+int vfprintf(FILE *stream, const char *fmt, va_list args)
+{
+	return __nolibc_printf(__nolibc_fprintf_cb, (intptr_t)stream, fmt, args);
+}
+
 static __attribute__((unused, format(printf, 1, 0)))
 int vprintf(const char *fmt, va_list args)
 {

-- 
2.49.0

[PATCH v2 26/32] tools/nolibc: allow limiting of printf destination size

[Thomas Weißschuh]

snprintf() allows limiting the output buffer, while still returning the
number of all bytes that would have been written.
Implement the limitation logic in preparation for snprintf().

Signed-off-by: Thomas Weißschuh <thomas.weissschuh@linutronix.de>
Acked-by: Willy Tarreau <w@1wt.eu>
---
 tools/include/nolibc/stdio.h | 16 ++++++++++------
 1 file changed, 10 insertions(+), 6 deletions(-)

diff --git a/tools/include/nolibc/stdio.h b/tools/include/nolibc/stdio.h
index 5c893b4903a3040a366e11b600ccde30913d7db2..b17b473bd8751a6283309178b4848e61e1683305 100644
--- a/tools/include/nolibc/stdio.h
+++ b/tools/include/nolibc/stdio.h
@@ -215,13 +215,13 @@ char *fgets(char *s, int size, FILE *stream)
  */
 typedef int (*__nolibc_printf_cb)(intptr_t state, const char *buf, size_t size);
 
-static __attribute__((unused, format(printf, 3, 0)))
-int __nolibc_printf(__nolibc_printf_cb cb, intptr_t state, const char *fmt, va_list args)
+static __attribute__((unused, format(printf, 4, 0)))
+int __nolibc_printf(__nolibc_printf_cb cb, intptr_t state, size_t n, const char *fmt, va_list args)
 {
 	char escape, lpref, c;
 	unsigned long long v;
 	unsigned int written;
-	size_t len, ofs;
+	size_t len, ofs, w;
 	char tmpbuf[21];
 	const char *outstr;
 
@@ -306,8 +306,12 @@ int __nolibc_printf(__nolibc_printf_cb cb, intptr_t state, const char *fmt, va_l
 			outstr = fmt;
 			len = ofs - 1;
 		flush_str:
-			if (cb(state, outstr, len) != 0)
-				break;
+			if (n) {
+				w = len < n ? len : n;
+				n -= w;
+				if (cb(state, outstr, w) != 0)
+					break;
+			}
 
 			written += len;
 		do_escape:
@@ -331,7 +335,7 @@ static int __nolibc_fprintf_cb(intptr_t state, const char *buf, size_t size)
 static __attribute__((unused, format(printf, 2, 0)))
 int vfprintf(FILE *stream, const char *fmt, va_list args)
 {
-	return __nolibc_printf(__nolibc_fprintf_cb, (intptr_t)stream, fmt, args);
+	return __nolibc_printf(__nolibc_fprintf_cb, (intptr_t)stream, SIZE_MAX, fmt, args);
 }
 
 static __attribute__((unused, format(printf, 1, 0)))

-- 
2.49.0

[PATCH v2 27/32] tools/nolibc: add snprintf() and friends

[Thomas Weißschuh]

Add more of the printf() functions.

Signed-off-by: Thomas Weißschuh <thomas.weissschuh@linutronix.de>
Acked-by: Willy Tarreau <w@1wt.eu>
---
 tools/include/nolibc/stdio.h | 55 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 55 insertions(+)

diff --git a/tools/include/nolibc/stdio.h b/tools/include/nolibc/stdio.h
index b17b473bd8751a6283309178b4848e61e1683305..46bd90f96d654fadda20292baddc98358a3afc62 100644
--- a/tools/include/nolibc/stdio.h
+++ b/tools/include/nolibc/stdio.h
@@ -389,6 +389,61 @@ int dprintf(int fd, const char *fmt, ...)
 	va_start(args, fmt);
 	ret = vdprintf(fd, fmt, args);
 	va_end(args);
+
+	return ret;
+}
+
+static int __nolibc_sprintf_cb(intptr_t _state, const char *buf, size_t size)
+{
+	char **state = (char **)_state;
+
+	memcpy(*state, buf, size);
+	*state += size;
+	return 0;
+}
+
+static __attribute__((unused, format(printf, 3, 0)))
+int vsnprintf(char *buf, size_t size, const char *fmt, va_list args)
+{
+	char *state = buf;
+	int ret;
+
+	ret = __nolibc_printf(__nolibc_sprintf_cb, (intptr_t)&state, size, fmt, args);
+	if (ret < 0)
+		return ret;
+	buf[(size_t)ret < size ? (size_t)ret : size - 1] = '\0';
+	return ret;
+}
+
+static __attribute__((unused, format(printf, 3, 4)))
+int snprintf(char *buf, size_t size, const char *fmt, ...)
+{
+	va_list args;
+	int ret;
+
+	va_start(args, fmt);
+	ret = vsnprintf(buf, size, fmt, args);
+	va_end(args);
+
+	return ret;
+}
+
+static __attribute__((unused, format(printf, 2, 0)))
+int vsprintf(char *buf, const char *fmt, va_list args)
+{
+	return vsnprintf(buf, SIZE_MAX, fmt, args);
+}
+
+static __attribute__((unused, format(printf, 2, 3)))
+int sprintf(char *buf, const char *fmt, ...)
+{
+	va_list args;
+	int ret;
+
+	va_start(args, fmt);
+	ret = vsprintf(buf, fmt, args);
+	va_end(args);
+
 	return ret;
 }
 

-- 
2.49.0

[PATCH v2 28/32] selftests/nolibc: use snprintf() for printf tests

[Thomas Weißschuh]

With a proper snprintf() implementation in place, the ugly pipe usage is
not necessary anymore.

Signed-off-by: Thomas Weißschuh <thomas.weissschuh@linutronix.de>
Acked-by: Willy Tarreau <w@1wt.eu>
---
 tools/testing/selftests/nolibc/nolibc-test.c | 30 +++-------------------------
 1 file changed, 3 insertions(+), 27 deletions(-)

diff --git a/tools/testing/selftests/nolibc/nolibc-test.c b/tools/testing/selftests/nolibc/nolibc-test.c
index b4b9a8422d76e1170ff967850429916a2190139b..8fb241af33cbba2ceb1303bf41582d51f70df68e 100644
--- a/tools/testing/selftests/nolibc/nolibc-test.c
+++ b/tools/testing/selftests/nolibc/nolibc-test.c
@@ -1300,27 +1300,14 @@ int run_stdlib(int min, int max)
 
 static int expect_vfprintf(int llen, int c, const char *expected, const char *fmt, ...)
 {
-	int ret, pipefd[2];
-	ssize_t w, r;
 	char buf[100];
-	FILE *memfile;
 	va_list args;
+	ssize_t w;
+	int ret;
 
-	ret = pipe(pipefd);
-	if (ret == -1) {
-		llen += printf(" pipe() != %s", strerror(errno));
-		result(llen, FAIL);
-		return 1;
-	}
-
-	memfile = fdopen(pipefd[1], "w");
-	if (!memfile) {
-		result(llen, FAIL);
-		return 1;
-	}
 
 	va_start(args, fmt);
-	w = vfprintf(memfile, fmt, args);
+	w = vsnprintf(buf, sizeof(buf), fmt, args);
 	va_end(args);
 
 	if (w != c) {
@@ -1329,17 +1316,6 @@ static int expect_vfprintf(int llen, int c, const char *expected, const char *fm
 		return 1;
 	}
 
-	fclose(memfile);
-
-	r = read(pipefd[0], buf, sizeof(buf) - 1);
-
-	if (r != w) {
-		llen += printf(" written(%d) != read(%d)", (int)w, (int)r);
-		result(llen, FAIL);
-		return 1;
-	}
-
-	buf[r] = '\0';
 	llen += printf(" \"%s\" = \"%s\"", expected, buf);
 	ret = strncmp(expected, buf, c);
 

-- 
2.49.0

[PATCH v2 29/32] selftests/nolibc: rename vfprintf test suite

[Thomas Weißschuh]

With the addition of snprintf() and its usage in nolibc-test, the name of
the "vfprintf" test suite is not accurate anymore.

Rename the suite to be more generic.

Signed-off-by: Thomas Weißschuh <thomas.weissschuh@linutronix.de>
Acked-by: Willy Tarreau <w@1wt.eu>
---
 tools/testing/selftests/nolibc/nolibc-test.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/tools/testing/selftests/nolibc/nolibc-test.c b/tools/testing/selftests/nolibc/nolibc-test.c
index 8fb241af33cbba2ceb1303bf41582d51f70df68e..6dfa94df37547dae46ab19195a763fe22b065bab 100644
--- a/tools/testing/selftests/nolibc/nolibc-test.c
+++ b/tools/testing/selftests/nolibc/nolibc-test.c
@@ -1390,7 +1390,7 @@ static int test_scanf(void)
 	return 0;
 }
 
-static int run_vfprintf(int min, int max)
+static int run_printf(int min, int max)
 {
 	int test;
 	int ret = 0;
@@ -1551,7 +1551,7 @@ static const struct test test_names[] = {
 	{ .name = "startup",    .func = run_startup    },
 	{ .name = "syscall",    .func = run_syscall    },
 	{ .name = "stdlib",     .func = run_stdlib     },
-	{ .name = "vfprintf",   .func = run_vfprintf   },
+	{ .name = "printf",     .func = run_printf     },
 	{ .name = "protection", .func = run_protection },
 	{ 0 }
 };

-- 
2.49.0

[PATCH v2 30/32] selftests/nolibc: add test for snprintf() truncation

[Thomas Weißschuh]

Now that we have a proper snprintf() implementation,
make sure truncation is handled properly.

Signed-off-by: Thomas Weißschuh <thomas.weissschuh@linutronix.de>
Acked-by: Willy Tarreau <w@1wt.eu>
---
 tools/testing/selftests/nolibc/nolibc-test.c | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/tools/testing/selftests/nolibc/nolibc-test.c b/tools/testing/selftests/nolibc/nolibc-test.c
index 6dfa94df37547dae46ab19195a763fe22b065bab..9bd0a9c68b903cbd660ff81d4b0386b0b7c13977 100644
--- a/tools/testing/selftests/nolibc/nolibc-test.c
+++ b/tools/testing/selftests/nolibc/nolibc-test.c
@@ -1307,7 +1307,8 @@ static int expect_vfprintf(int llen, int c, const char *expected, const char *fm
 
 
 	va_start(args, fmt);
-	w = vsnprintf(buf, sizeof(buf), fmt, args);
+	/* Only allow writing 21 bytes, to test truncation */
+	w = vsnprintf(buf, 21, fmt, args);
 	va_end(args);
 
 	if (w != c) {
@@ -1413,6 +1414,7 @@ static int run_printf(int min, int max)
 		CASE_TEST(pointer);      EXPECT_VFPRINTF(3, "0x1", "%p", (void *) 0x1); break;
 		CASE_TEST(uintmax_t);    EXPECT_VFPRINTF(20, "18446744073709551615", "%ju", 0xffffffffffffffffULL); break;
 		CASE_TEST(intmax_t);     EXPECT_VFPRINTF(20, "-9223372036854775807", "%jd", 0x8000000000000001LL); break;
+		CASE_TEST(truncation);   EXPECT_VFPRINTF(25, "01234567890123456789", "%s", "0123456789012345678901234"); break;
 		CASE_TEST(scanf);        EXPECT_ZR(1, test_scanf()); break;
 		case __LINE__:
 			return ret; /* must be last */

-- 
2.49.0

[PATCH v2 31/32] tools/nolibc: implement width padding in printf()

[Thomas Weißschuh]

printf can pad each argument to a certain width.
Implement this for compatibility with the kselftest harness.
Currently only padding with spaces is supported.

Signed-off-by: Thomas Weißschuh <thomas.weissschuh@linutronix.de>
Acked-by: Willy Tarreau <w@1wt.eu>
---
 tools/include/nolibc/stdio.h                 | 17 ++++++++++++++++-
 tools/testing/selftests/nolibc/nolibc-test.c |  3 +++
 2 files changed, 19 insertions(+), 1 deletion(-)

diff --git a/tools/include/nolibc/stdio.h b/tools/include/nolibc/stdio.h
index 46bd90f96d654fadda20292baddc98358a3afc62..fb0417477759ee6c9663e84807c1d1067e735dec 100644
--- a/tools/include/nolibc/stdio.h
+++ b/tools/include/nolibc/stdio.h
@@ -220,7 +220,7 @@ int __nolibc_printf(__nolibc_printf_cb cb, intptr_t state, size_t n, const char
 {
 	char escape, lpref, c;
 	unsigned long long v;
-	unsigned int written;
+	unsigned int written, width;
 	size_t len, ofs, w;
 	char tmpbuf[21];
 	const char *outstr;
@@ -228,10 +228,20 @@ int __nolibc_printf(__nolibc_printf_cb cb, intptr_t state, size_t n, const char
 	written = ofs = escape = lpref = 0;
 	while (1) {
 		c = fmt[ofs++];
+		width = 0;
 
 		if (escape) {
 			/* we're in an escape sequence, ofs == 1 */
 			escape = 0;
+
+			/* width */
+			while (c >= '0' && c <= '9') {
+				width *= 10;
+				width += c - '0';
+
+				c = fmt[ofs++];
+			}
+
 			if (c == 'c' || c == 'd' || c == 'u' || c == 'x' || c == 'p') {
 				char *out = tmpbuf;
 
@@ -309,6 +319,11 @@ int __nolibc_printf(__nolibc_printf_cb cb, intptr_t state, size_t n, const char
 			if (n) {
 				w = len < n ? len : n;
 				n -= w;
+				while (width-- > w) {
+					if (cb(state, " ", 1) != 0)
+						break;
+					written += 1;
+				}
 				if (cb(state, outstr, w) != 0)
 					break;
 			}
diff --git a/tools/testing/selftests/nolibc/nolibc-test.c b/tools/testing/selftests/nolibc/nolibc-test.c
index 9bd0a9c68b903cbd660ff81d4b0386b0b7c13977..16ec4f658bbec43440679c5d5c35014827c377bc 100644
--- a/tools/testing/selftests/nolibc/nolibc-test.c
+++ b/tools/testing/selftests/nolibc/nolibc-test.c
@@ -1415,6 +1415,9 @@ static int run_printf(int min, int max)
 		CASE_TEST(uintmax_t);    EXPECT_VFPRINTF(20, "18446744073709551615", "%ju", 0xffffffffffffffffULL); break;
 		CASE_TEST(intmax_t);     EXPECT_VFPRINTF(20, "-9223372036854775807", "%jd", 0x8000000000000001LL); break;
 		CASE_TEST(truncation);   EXPECT_VFPRINTF(25, "01234567890123456789", "%s", "0123456789012345678901234"); break;
+		CASE_TEST(string_width); EXPECT_VFPRINTF(10, "         1", "%10s", "1"); break;
+		CASE_TEST(number_width); EXPECT_VFPRINTF(10, "         1", "%10d", 1); break;
+		CASE_TEST(width_trunc);  EXPECT_VFPRINTF(25, "                    ", "%25d", 1); break;
 		CASE_TEST(scanf);        EXPECT_ZR(1, test_scanf()); break;
 		case __LINE__:
 			return ret; /* must be last */

-- 
2.49.0

[PATCH v2 32/32] HACK: selftests/nolibc: demonstrate usage of the kselftest harness

[Thomas Weißschuh]

Show how to use the kselftest harness together with nolibc.
This just runs the existing harness selftest by crudely replacing the
regular nolibc-test.c with the harness-selftest.c to get that wired up easily.
To use it:
	$ cd tools/testing/selftests/nolibc/
	$ ./run-tests -m user

In the future nolibc-test can use the harness for itself.

Not-Signed-off-by: Thomas Weißschuh <thomas.weissschuh@linutronix.de>
---
 .../testing/selftests/kselftest/harness-selftest.c |    2 +-
 tools/testing/selftests/nolibc/Makefile            |   13 +-
 tools/testing/selftests/nolibc/harness-selftest.c  |    1 +
 tools/testing/selftests/nolibc/nolibc-test.c       | 1715 +-------------------
 tools/testing/selftests/nolibc/run-tests.sh        |    2 +-
 5 files changed, 11 insertions(+), 1722 deletions(-)

diff --git a/tools/testing/selftests/kselftest/harness-selftest.c b/tools/testing/selftests/kselftest/harness-selftest.c
index 8d39e7a0b99c41a5d33edfe2dbf875cac04c098d..bbb2fda7042ca8bac608625e6f4302466b23f7b3 100644
--- a/tools/testing/selftests/kselftest/harness-selftest.c
+++ b/tools/testing/selftests/kselftest/harness-selftest.c
@@ -1,4 +1,4 @@
-// SPDX-License-Identifier: GPL-2.0
+/* SPDX-License-Identifier: GPL-2.0 */
 
 #include <stdio.h>
 
diff --git a/tools/testing/selftests/nolibc/Makefile b/tools/testing/selftests/nolibc/Makefile
index 58bcbbd029bc3ad9ccac968191b703ccf5df0717..7c037fb3f3c8d8e510cf8a6e80fcd11f0ec3538c 100644
--- a/tools/testing/selftests/nolibc/Makefile
+++ b/tools/testing/selftests/nolibc/Makefile
@@ -165,8 +165,8 @@ Q=@
 endif
 
 CFLAGS_i386 = $(call cc-option,-m32)
-CFLAGS_arm = -marm
-CFLAGS_armthumb = -mthumb -march=armv6t2
+CFLAGS_arm = -marm -march=armv7-a
+CFLAGS_armthumb = -mthumb -march=armv7
 CFLAGS_ppc = -m32 -mbig-endian -mno-vsx $(call cc-option,-mmultiple)
 CFLAGS_ppc64 = -m64 -mbig-endian -mno-vsx $(call cc-option,-mmultiple)
 CFLAGS_ppc64le = -m64 -mlittle-endian -mno-vsx $(call cc-option,-mabi=elfv2)
@@ -175,8 +175,10 @@ CFLAGS_s390 = -m31
 CFLAGS_mips32le = -EL -mabi=32 -fPIC
 CFLAGS_mips32be = -EB -mabi=32
 CFLAGS_STACKPROTECTOR ?= $(call cc-option,-mstack-protector-guard=global $(call cc-option,-fstack-protector-all))
-CFLAGS  ?= -Os -fno-ident -fno-asynchronous-unwind-tables -std=c89 -W -Wall -Wextra \
+CFLAGS  ?= -Os -fno-ident -fno-asynchronous-unwind-tables -std=c89 -W -Wall -Wextra -ggdb -ffreestanding \
+	        -ffile-prefix-map=./= \
 		$(call cc-option,-fno-stack-protector) $(call cc-option,-Wmissing-prototypes) \
+		$(call cc-option,-mno-outline-atomics) \
 		$(CFLAGS_$(XARCH)) $(CFLAGS_STACKPROTECTOR) $(CFLAGS_EXTRA)
 LDFLAGS :=
 
@@ -193,10 +195,7 @@ include $(srctree)/tools/scripts/Makefile.include
 # GCC uses "s390", clang "systemz"
 CLANG_CROSS_FLAGS := $(subst --target=s390-linux,--target=systemz-linux,$(CLANG_CROSS_FLAGS))
 
-REPORT  ?= awk '/\[OK\][\r]*$$/{p++} /\[FAIL\][\r]*$$/{if (!f) printf("\n"); f++; print;} /\[SKIPPED\][\r]*$$/{s++} \
-		END{ printf("\n%3d test(s): %3d passed, %3d skipped, %3d failed => status: ", p+s+f, p, s, f); \
-		if (f || !p) printf("failure\n"); else if (s) printf("warning\n"); else printf("success\n");; \
-		printf("\nSee all results in %s\n", ARGV[1]); }'
+REPORT  = sed -i -e '/^\[/d' -e 's/\x0d//' run.out; cmp ../kselftest/harness-selftest.expected run.out && echo ok; true
 
 help:
 	@echo "Supported targets under selftests/nolibc:"
diff --git a/tools/testing/selftests/nolibc/harness-selftest.c b/tools/testing/selftests/nolibc/harness-selftest.c
new file mode 120000
index 0000000000000000000000000000000000000000..847b121e60482513cd0911422cfdb19bdf681bd6
--- /dev/null
+++ b/tools/testing/selftests/nolibc/harness-selftest.c
@@ -0,0 +1 @@
+../kselftest/harness-selftest.c
\ No newline at end of file
diff --git a/tools/testing/selftests/nolibc/nolibc-test.c b/tools/testing/selftests/nolibc/nolibc-test.c
index 16ec4f658bbec43440679c5d5c35014827c377bc..9a074d2b24c99d86bf27f8399f2e7dc719dbcd24 100644
--- a/tools/testing/selftests/nolibc/nolibc-test.c
+++ b/tools/testing/selftests/nolibc/nolibc-test.c
@@ -1,1716 +1,5 @@
 /* SPDX-License-Identifier: GPL-2.0 */
 
-#define _GNU_SOURCE
-#define _LARGEFILE64_SOURCE
+#define inline __inline__
 
-/* libc-specific include files
- * The program may be built in 3 ways:
- *   $(CC) -nostdlib -include /path/to/nolibc.h => NOLIBC already defined
- *   $(CC) -nostdlib -I/path/to/nolibc/sysroot  => _NOLIBC_* guards are present
- *   $(CC) with default libc                    => NOLIBC* never defined
- */
-#ifndef NOLIBC
-#include <stdio.h>
-#include <stdlib.h>
-#include <string.h>
-#ifndef _NOLIBC_STDIO_H
-/* standard libcs need more includes */
-#include <sys/auxv.h>
-#include <sys/io.h>
-#include <sys/ioctl.h>
-#include <sys/mman.h>
-#include <sys/mount.h>
-#include <sys/prctl.h>
-#include <sys/reboot.h>
-#include <sys/resource.h>
-#include <sys/stat.h>
-#include <sys/syscall.h>
-#include <sys/sysmacros.h>
-#include <sys/time.h>
-#include <sys/utsname.h>
-#include <sys/wait.h>
-#include <dirent.h>
-#include <errno.h>
-#include <fcntl.h>
-#include <poll.h>
-#include <sched.h>
-#include <signal.h>
-#include <stdarg.h>
-#include <stddef.h>
-#include <stdint.h>
-#include <unistd.h>
-#include <limits.h>
-#include <ctype.h>
-#endif
-#endif
-
-#pragma GCC diagnostic ignored "-Wmissing-prototypes"
-
-#include "nolibc-test-linkage.h"
-
-/* for the type of int_fast16_t and int_fast32_t, musl differs from glibc and nolibc */
-#define SINT_MAX_OF_TYPE(type) (((type)1 << (sizeof(type) * 8 - 2)) - (type)1 + ((type)1 << (sizeof(type) * 8 - 2)))
-#define SINT_MIN_OF_TYPE(type) (-SINT_MAX_OF_TYPE(type) - 1)
-
-/* will be used to test initialization of environ */
-static char **test_envp;
-
-/* will be used to test initialization of argv */
-static char **test_argv;
-
-/* will be used to test initialization of argc */
-static int test_argc;
-
-/* will be used by some test cases as readable file, please don't write it */
-static const char *argv0;
-
-/* will be used by constructor tests */
-static int constructor_test_value;
-
-static const int is_nolibc =
-#ifdef NOLIBC
-	1
-#else
-	0
-#endif
-;
-
-/* definition of a series of tests */
-struct test {
-	const char *name;              /* test name */
-	int (*func)(int min, int max); /* handler */
-};
-
-#ifndef _NOLIBC_STDLIB_H
-char *itoa(int i)
-{
-	static char buf[12];
-	int ret;
-
-	ret = snprintf(buf, sizeof(buf), "%d", i);
-	return (ret >= 0 && ret < sizeof(buf)) ? buf : "#err";
-}
-#endif
-
-#define CASE_ERR(err) \
-	case err: return #err
-
-/* returns the error name (e.g. "ENOENT") for common errors, "SUCCESS" for 0,
- * or the decimal value for less common ones.
- */
-static const char *errorname(int err)
-{
-	switch (err) {
-	case 0: return "SUCCESS";
-	CASE_ERR(EPERM);
-	CASE_ERR(ENOENT);
-	CASE_ERR(ESRCH);
-	CASE_ERR(EINTR);
-	CASE_ERR(EIO);
-	CASE_ERR(ENXIO);
-	CASE_ERR(E2BIG);
-	CASE_ERR(ENOEXEC);
-	CASE_ERR(EBADF);
-	CASE_ERR(ECHILD);
-	CASE_ERR(EAGAIN);
-	CASE_ERR(ENOMEM);
-	CASE_ERR(EACCES);
-	CASE_ERR(EFAULT);
-	CASE_ERR(ENOTBLK);
-	CASE_ERR(EBUSY);
-	CASE_ERR(EEXIST);
-	CASE_ERR(EXDEV);
-	CASE_ERR(ENODEV);
-	CASE_ERR(ENOTDIR);
-	CASE_ERR(EISDIR);
-	CASE_ERR(EINVAL);
-	CASE_ERR(ENFILE);
-	CASE_ERR(EMFILE);
-	CASE_ERR(ENOTTY);
-	CASE_ERR(ETXTBSY);
-	CASE_ERR(EFBIG);
-	CASE_ERR(ENOSPC);
-	CASE_ERR(ESPIPE);
-	CASE_ERR(EROFS);
-	CASE_ERR(EMLINK);
-	CASE_ERR(EPIPE);
-	CASE_ERR(EDOM);
-	CASE_ERR(ERANGE);
-	CASE_ERR(ENOSYS);
-	CASE_ERR(EOVERFLOW);
-	default:
-		return itoa(err);
-	}
-}
-
-static void align_result(size_t llen)
-{
-	const size_t align = 64;
-	char buf[align];
-	size_t n;
-
-	if (llen >= align)
-		return;
-
-	n = align - llen;
-	memset(buf, ' ', n);
-	buf[n] = '\0';
-	fputs(buf, stdout);
-}
-
-enum RESULT {
-	OK,
-	FAIL,
-	SKIPPED,
-};
-
-static void result(int llen, enum RESULT r)
-{
-	const char *msg;
-
-	if (r == OK)
-		msg = "  [OK]";
-	else if (r == SKIPPED)
-		msg = "[SKIPPED]";
-	else
-		msg = " [FAIL]";
-
-	align_result(llen);
-	puts(msg);
-}
-
-/* The tests below are intended to be used by the macroes, which evaluate
- * expression <expr>, print the status to stdout, and update the "ret"
- * variable to count failures. The functions themselves return the number
- * of failures, thus either 0 or 1.
- */
-
-#define EXPECT_ZR(cond, expr)				\
-	do { if (!(cond)) result(llen, SKIPPED); else ret += expect_zr(expr, llen); } while (0)
-
-static __attribute__((unused))
-int expect_zr(int expr, int llen)
-{
-	int ret = !(expr == 0);
-
-	llen += printf(" = %d ", expr);
-	result(llen, ret ? FAIL : OK);
-	return ret;
-}
-
-
-#define EXPECT_NZ(cond, expr, val)			\
-	do { if (!(cond)) result(llen, SKIPPED); else ret += expect_nz(expr, llen; } while (0)
-
-static __attribute__((unused))
-int expect_nz(int expr, int llen)
-{
-	int ret = !(expr != 0);
-
-	llen += printf(" = %d ", expr);
-	result(llen, ret ? FAIL : OK);
-	return ret;
-}
-
-
-#define EXPECT_EQ(cond, expr, val)				\
-	do { if (!(cond)) result(llen, SKIPPED); else ret += expect_eq(expr, llen, val); } while (0)
-
-static __attribute__((unused))
-int expect_eq(uint64_t expr, int llen, uint64_t val)
-{
-	int ret = !(expr == val);
-
-	llen += printf(" = %lld ", (long long)expr);
-	result(llen, ret ? FAIL : OK);
-	return ret;
-}
-
-
-#define EXPECT_NE(cond, expr, val)				\
-	do { if (!(cond)) result(llen, SKIPPED); else ret += expect_ne(expr, llen, val); } while (0)
-
-static __attribute__((unused))
-int expect_ne(int expr, int llen, int val)
-{
-	int ret = !(expr != val);
-
-	llen += printf(" = %d ", expr);
-	result(llen, ret ? FAIL : OK);
-	return ret;
-}
-
-
-#define EXPECT_GE(cond, expr, val)				\
-	do { if (!(cond)) result(llen, SKIPPED); else ret += expect_ge(expr, llen, val); } while (0)
-
-static __attribute__((unused))
-int expect_ge(int expr, int llen, int val)
-{
-	int ret = !(expr >= val);
-
-	llen += printf(" = %d ", expr);
-	result(llen, ret ? FAIL : OK);
-	return ret;
-}
-
-
-#define EXPECT_GT(cond, expr, val)				\
-	do { if (!(cond)) result(llen, SKIPPED); else ret += expect_gt(expr, llen, val); } while (0)
-
-static __attribute__((unused))
-int expect_gt(int expr, int llen, int val)
-{
-	int ret = !(expr > val);
-
-	llen += printf(" = %d ", expr);
-	result(llen, ret ? FAIL : OK);
-	return ret;
-}
-
-
-#define EXPECT_LE(cond, expr, val)				\
-	do { if (!(cond)) result(llen, SKIPPED); else ret += expect_le(expr, llen, val); } while (0)
-
-static __attribute__((unused))
-int expect_le(int expr, int llen, int val)
-{
-	int ret = !(expr <= val);
-
-	llen += printf(" = %d ", expr);
-	result(llen, ret ? FAIL : OK);
-	return ret;
-}
-
-
-#define EXPECT_LT(cond, expr, val)				\
-	do { if (!(cond)) result(llen, SKIPPED); else ret += expect_lt(expr, llen, val); } while (0)
-
-static __attribute__((unused))
-int expect_lt(int expr, int llen, int val)
-{
-	int ret = !(expr < val);
-
-	llen += printf(" = %d ", expr);
-	result(llen, ret ? FAIL : OK);
-	return ret;
-}
-
-
-#define EXPECT_SYSZR(cond, expr)				\
-	do { if (!(cond)) result(llen, SKIPPED); else ret += expect_syszr(expr, llen); } while (0)
-
-static __attribute__((unused))
-int expect_syszr(int expr, int llen)
-{
-	int ret = 0;
-
-	if (errno == ENOSYS) {
-		llen += printf(" = ENOSYS");
-		result(llen, SKIPPED);
-	} else if (expr) {
-		ret = 1;
-		llen += printf(" = %d %s ", expr, errorname(errno));
-		result(llen, FAIL);
-	} else {
-		llen += printf(" = %d ", expr);
-		result(llen, OK);
-	}
-	return ret;
-}
-
-
-#define EXPECT_SYSEQ(cond, expr, val)				\
-	do { if (!(cond)) result(llen, SKIPPED); else ret += expect_syseq(expr, llen, val); } while (0)
-
-static __attribute__((unused))
-int expect_syseq(int expr, int llen, int val)
-{
-	int ret = 0;
-
-	if (expr != val) {
-		ret = 1;
-		llen += printf(" = %d %s ", expr, errorname(errno));
-		result(llen, FAIL);
-	} else {
-		llen += printf(" = %d ", expr);
-		result(llen, OK);
-	}
-	return ret;
-}
-
-
-#define EXPECT_SYSNE(cond, expr, val)				\
-	do { if (!(cond)) result(llen, SKIPPED); else ret += expect_sysne(expr, llen, val); } while (0)
-
-static __attribute__((unused))
-int expect_sysne(int expr, int llen, int val)
-{
-	int ret = 0;
-
-	if (errno == ENOSYS) {
-		llen += printf(" = ENOSYS");
-		result(llen, SKIPPED);
-	} else if (expr == val) {
-		ret = 1;
-		llen += printf(" = %d %s ", expr, errorname(errno));
-		result(llen, FAIL);
-	} else {
-		llen += printf(" = %d ", expr);
-		result(llen, OK);
-	}
-	return ret;
-}
-
-
-#define EXPECT_SYSER2(cond, expr, expret, experr1, experr2)		\
-	do { if (!(cond)) result(llen, SKIPPED); else ret += expect_syserr2(expr, expret, experr1, experr2, llen); } while (0)
-
-#define EXPECT_SYSER(cond, expr, expret, experr)			\
-	EXPECT_SYSER2(cond, expr, expret, experr, 0)
-
-static __attribute__((unused))
-int expect_syserr2(int expr, int expret, int experr1, int experr2, int llen)
-{
-	int ret = 0;
-	int _errno = errno;
-
-	llen += printf(" = %d %s ", expr, errorname(_errno));
-	if (errno == ENOSYS) {
-		result(llen, SKIPPED);
-	} else if (expr != expret || (_errno != experr1 && _errno != experr2)) {
-		ret = 1;
-		if (experr2 == 0)
-			llen += printf(" != (%d %s) ", expret, errorname(experr1));
-		else
-			llen += printf(" != (%d %s %s) ", expret, errorname(experr1), errorname(experr2));
-		result(llen, FAIL);
-	} else {
-		result(llen, OK);
-	}
-	return ret;
-}
-
-
-#define EXPECT_PTRZR(cond, expr)				\
-	do { if (!(cond)) result(llen, SKIPPED); else ret += expect_ptrzr(expr, llen); } while (0)
-
-static __attribute__((unused))
-int expect_ptrzr(const void *expr, int llen)
-{
-	int ret = 0;
-
-	llen += printf(" = <%p> ", expr);
-	if (expr) {
-		ret = 1;
-		result(llen, FAIL);
-	} else {
-		result(llen, OK);
-	}
-	return ret;
-}
-
-
-#define EXPECT_PTRNZ(cond, expr)				\
-	do { if (!(cond)) result(llen, SKIPPED); else ret += expect_ptrnz(expr, llen); } while (0)
-
-static __attribute__((unused))
-int expect_ptrnz(const void *expr, int llen)
-{
-	int ret = 0;
-
-	llen += printf(" = <%p> ", expr);
-	if (!expr) {
-		ret = 1;
-		result(llen, FAIL);
-	} else {
-		result(llen, OK);
-	}
-	return ret;
-}
-
-#define EXPECT_PTREQ(cond, expr, cmp)				\
-	do { if (!(cond)) result(llen, SKIPPED); else ret += expect_ptreq(expr, llen, cmp); } while (0)
-
-static __attribute__((unused))
-int expect_ptreq(const void *expr, int llen, const void *cmp)
-{
-	int ret = 0;
-
-	llen += printf(" = <%p> ", expr);
-	if (expr != cmp) {
-		ret = 1;
-		result(llen, FAIL);
-	} else {
-		result(llen, OK);
-	}
-	return ret;
-}
-
-#define EXPECT_PTRNE(cond, expr, cmp)				\
-	do { if (!(cond)) result(llen, SKIPPED); else ret += expect_ptrne(expr, llen, cmp); } while (0)
-
-static __attribute__((unused))
-int expect_ptrne(const void *expr, int llen, const void *cmp)
-{
-	int ret = 0;
-
-	llen += printf(" = <%p> ", expr);
-	if (expr == cmp) {
-		ret = 1;
-		result(llen, FAIL);
-	} else {
-		result(llen, OK);
-	}
-	return ret;
-}
-
-#define EXPECT_PTRGE(cond, expr, cmp)				\
-	do { if (!(cond)) result(llen, SKIPPED); else ret += expect_ptrge(expr, llen, cmp); } while (0)
-
-static __attribute__((unused))
-int expect_ptrge(const void *expr, int llen, const void *cmp)
-{
-	int ret = !(expr >= cmp);
-
-	llen += printf(" = <%p> ", expr);
-	result(llen, ret ? FAIL : OK);
-	return ret;
-}
-
-#define EXPECT_PTRGT(cond, expr, cmp)				\
-	do { if (!(cond)) result(llen, SKIPPED); else ret += expect_ptrgt(expr, llen, cmp); } while (0)
-
-static __attribute__((unused))
-int expect_ptrgt(const void *expr, int llen, const void *cmp)
-{
-	int ret = !(expr > cmp);
-
-	llen += printf(" = <%p> ", expr);
-	result(llen, ret ? FAIL : OK);
-	return ret;
-}
-
-
-#define EXPECT_PTRLE(cond, expr, cmp)				\
-	do { if (!(cond)) result(llen, SKIPPED); else ret += expect_ptrle(expr, llen, cmp); } while (0)
-
-static __attribute__((unused))
-int expect_ptrle(const void *expr, int llen, const void *cmp)
-{
-	int ret = !(expr <= cmp);
-
-	llen += printf(" = <%p> ", expr);
-	result(llen, ret ? FAIL : OK);
-	return ret;
-}
-
-
-#define EXPECT_PTRLT(cond, expr, cmp)				\
-	do { if (!(cond)) result(llen, SKIPPED); else ret += expect_ptrlt(expr, llen, cmp); } while (0)
-
-static __attribute__((unused))
-int expect_ptrlt(const void *expr, int llen, const void *cmp)
-{
-	int ret = !(expr < cmp);
-
-	llen += printf(" = <%p> ", expr);
-	result(llen, ret ? FAIL : OK);
-	return ret;
-}
-
-#define EXPECT_PTRER2(cond, expr, expret, experr1, experr2)		\
-	do { if (!(cond)) result(llen, SKIPPED); else ret += expect_ptrerr2(expr, expret, experr1, experr2, llen); } while (0)
-
-#define EXPECT_PTRER(cond, expr, expret, experr)			\
-	EXPECT_PTRER2(cond, expr, expret, experr, 0)
-
-static __attribute__((unused))
-int expect_ptrerr2(const void *expr, const void *expret, int experr1, int experr2, int llen)
-{
-	int ret = 0;
-	int _errno = errno;
-
-	llen += printf(" = <%p> %s ", expr, errorname(_errno));
-	if (expr != expret || (_errno != experr1 && _errno != experr2)) {
-		ret = 1;
-		if (experr2 == 0)
-			llen += printf(" != (<%p> %s) ", expret, errorname(experr1));
-		else
-			llen += printf(" != (<%p> %s %s) ", expret, errorname(experr1), errorname(experr2));
-		result(llen, FAIL);
-	} else {
-		result(llen, OK);
-	}
-	return ret;
-}
-
-#define EXPECT_STRZR(cond, expr)				\
-	do { if (!(cond)) result(llen, SKIPPED); else ret += expect_strzr(expr, llen); } while (0)
-
-static __attribute__((unused))
-int expect_strzr(const char *expr, int llen)
-{
-	int ret = 0;
-
-	llen += printf(" = <%s> ", expr ? expr : "(null)");
-	if (expr) {
-		ret = 1;
-		result(llen, FAIL);
-	} else {
-		result(llen, OK);
-	}
-	return ret;
-}
-
-
-#define EXPECT_STRNZ(cond, expr)				\
-	do { if (!(cond)) result(llen, SKIPPED); else ret += expect_strnz(expr, llen); } while (0)
-
-static __attribute__((unused))
-int expect_strnz(const char *expr, int llen)
-{
-	int ret = 0;
-
-	llen += printf(" = <%s> ", expr ? expr : "(null)");
-	if (!expr) {
-		ret = 1;
-		result(llen, FAIL);
-	} else {
-		result(llen, OK);
-	}
-	return ret;
-}
-
-
-#define EXPECT_STREQ(cond, expr, cmp)				\
-	do { if (!(cond)) result(llen, SKIPPED); else ret += expect_streq(expr, llen, cmp); } while (0)
-
-static __attribute__((unused))
-int expect_streq(const char *expr, int llen, const char *cmp)
-{
-	int ret = 0;
-
-	llen += printf(" = <%s> ", expr);
-	if (strcmp(expr, cmp) != 0) {
-		ret = 1;
-		result(llen, FAIL);
-	} else {
-		result(llen, OK);
-	}
-	return ret;
-}
-
-
-#define EXPECT_STRNE(cond, expr, cmp)				\
-	do { if (!(cond)) result(llen, SKIPPED); else ret += expect_strne(expr, llen, cmp); } while (0)
-
-static __attribute__((unused))
-int expect_strne(const char *expr, int llen, const char *cmp)
-{
-	int ret = 0;
-
-	llen += printf(" = <%s> ", expr);
-	if (strcmp(expr, cmp) == 0) {
-		ret = 1;
-		result(llen, FAIL);
-	} else {
-		result(llen, OK);
-	}
-	return ret;
-}
-
-#define EXPECT_STRBUFEQ(cond, expr, buf, val, cmp)				\
-	do { if (!(cond)) result(llen, SKIPPED); else ret += expect_str_buf_eq(expr, buf, val, llen, cmp); } while (0)
-
-static __attribute__((unused))
-int expect_str_buf_eq(size_t expr, const char *buf, size_t val, int llen, const char *cmp)
-{
-	llen += printf(" = %lu <%s> ", (unsigned long)expr, buf);
-	if (strcmp(buf, cmp) != 0) {
-		result(llen, FAIL);
-		return 1;
-	}
-	if (expr != val) {
-		result(llen, FAIL);
-		return 1;
-	}
-
-	result(llen, OK);
-	return 0;
-}
-
-#define EXPECT_STRTOX(cond, func, input, base, expected, chars, expected_errno)				\
-	do { if (!(cond)) result(llen, SKIPPED); else ret += expect_strtox(llen, func, input, base, expected, chars, expected_errno); } while (0)
-
-static __attribute__((unused))
-int expect_strtox(int llen, void *func, const char *input, int base, intmax_t expected, int expected_chars, int expected_errno)
-{
-	char *endptr;
-	int actual_errno, actual_chars;
-	intmax_t r;
-
-	errno = 0;
-	if (func == strtol) {
-		r = strtol(input, &endptr, base);
-	} else if (func == strtoul) {
-		r = strtoul(input, &endptr, base);
-	} else {
-		result(llen, FAIL);
-		return 1;
-	}
-	actual_errno = errno;
-	actual_chars = endptr - input;
-
-	llen += printf(" %lld = %lld", (long long)expected, (long long)r);
-	if (r != expected) {
-		result(llen, FAIL);
-		return 1;
-	}
-	if (expected_chars == -1) {
-		if (*endptr != '\0') {
-			result(llen, FAIL);
-			return 1;
-		}
-	} else if (expected_chars != actual_chars) {
-		result(llen, FAIL);
-		return 1;
-	}
-	if (actual_errno != expected_errno) {
-		result(llen, FAIL);
-		return 1;
-	}
-
-	result(llen, OK);
-	return 0;
-}
-
-/* declare tests based on line numbers. There must be exactly one test per line. */
-#define CASE_TEST(name) \
-	case __LINE__: llen += printf("%d %s", test, #name);
-
-/* constructors validate that they are executed in definition order */
-__attribute__((constructor))
-static void constructor1(void)
-{
-	constructor_test_value |= 1 << 0;
-}
-
-__attribute__((constructor))
-static void constructor2(int argc, char **argv, char **envp)
-{
-	if (argc && argv && envp)
-		constructor_test_value |= 1 << 1;
-}
-
-int run_startup(int min, int max)
-{
-	int test;
-	int ret = 0;
-	/* kernel at least passes HOME and TERM, shell passes more */
-	int env_total = 2;
-	/* checking NULL for argv/argv0, environ and _auxv is not enough, let's compare with sbrk(0) or &end */
-	extern char end;
-	char *brk = sbrk(0) != (void *)-1 ? sbrk(0) : &end;
-	/* differ from nolibc, both glibc and musl have no global _auxv */
-	const unsigned long *test_auxv = (void *)-1;
-#ifdef NOLIBC
-	test_auxv = _auxv;
-#endif
-
-	for (test = min; test >= 0 && test <= max; test++) {
-		int llen = 0; /* line length */
-
-		/* avoid leaving empty lines below, this will insert holes into
-		 * test numbers.
-		 */
-		switch (test + __LINE__ + 1) {
-		CASE_TEST(argc);             EXPECT_GE(1, test_argc, 1); break;
-		CASE_TEST(argv_addr);        EXPECT_PTRGT(1, test_argv, brk); break;
-		CASE_TEST(argv_environ);     EXPECT_PTRLT(1, test_argv, environ); break;
-		CASE_TEST(argv_total);       EXPECT_EQ(1, environ - test_argv - 1, test_argc ?: 1); break;
-		CASE_TEST(argv0_addr);       EXPECT_PTRGT(1, argv0, brk); break;
-		CASE_TEST(argv0_str);        EXPECT_STRNZ(1, argv0 > brk ? argv0 : NULL); break;
-		CASE_TEST(argv0_len);        EXPECT_GE(1,  argv0 > brk ? strlen(argv0) : 0, 1); break;
-		CASE_TEST(environ_addr);     EXPECT_PTRGT(1, environ, brk); break;
-		CASE_TEST(environ_envp);     EXPECT_PTREQ(1, environ, test_envp); break;
-		CASE_TEST(environ_auxv);     EXPECT_PTRLT(test_auxv != (void *)-1, environ, test_auxv); break;
-		CASE_TEST(environ_total);    EXPECT_GE(test_auxv != (void *)-1, (void *)test_auxv - (void *)environ - 1, env_total); break;
-		CASE_TEST(environ_HOME);     EXPECT_PTRNZ(1, getenv("HOME")); break;
-		CASE_TEST(auxv_addr);        EXPECT_PTRGT(test_auxv != (void *)-1, test_auxv, brk); break;
-		CASE_TEST(auxv_AT_UID);      EXPECT_EQ(1, getauxval(AT_UID), getuid()); break;
-		CASE_TEST(constructor);      EXPECT_EQ(is_nolibc, constructor_test_value, 0x3); break;
-		CASE_TEST(linkage_errno);    EXPECT_PTREQ(1, linkage_test_errno_addr(), &errno); break;
-		CASE_TEST(linkage_constr);   EXPECT_EQ(1, linkage_test_constructor_test_value, 0x3); break;
-		case __LINE__:
-			return ret; /* must be last */
-		/* note: do not set any defaults so as to permit holes above */
-		}
-	}
-	return ret;
-}
-
-
-/* used by some syscall tests below */
-int test_getdents64(const char *dir)
-{
-	char buffer[4096];
-	int fd, ret;
-	int err;
-
-	ret = fd = open(dir, O_RDONLY | O_DIRECTORY, 0);
-	if (ret < 0)
-		return ret;
-
-	ret = getdents64(fd, (void *)buffer, sizeof(buffer));
-	err = errno;
-	close(fd);
-
-	errno = err;
-	return ret;
-}
-
-static int test_dirent(void)
-{
-	int comm = 0, cmdline = 0;
-	struct dirent dirent, *result;
-	DIR *dir;
-	int ret;
-
-	dir = opendir("/proc/self");
-	if (!dir)
-		return 1;
-
-	while (1) {
-		errno = 0;
-		ret = readdir_r(dir, &dirent, &result);
-		if (ret != 0)
-			return 1;
-		if (!result)
-			break;
-
-		if (strcmp(dirent.d_name, "comm") == 0)
-			comm++;
-		else if (strcmp(dirent.d_name, "cmdline") == 0)
-			cmdline++;
-	}
-
-	if (errno)
-		return 1;
-
-	ret = closedir(dir);
-	if (ret)
-		return 1;
-
-	if (comm != 1 || cmdline != 1)
-		return 1;
-
-	return 0;
-}
-
-int test_getpagesize(void)
-{
-	int x = getpagesize();
-	int c;
-
-	if (x < 0)
-		return x;
-
-#if defined(__x86_64__) || defined(__i386__) || defined(__i486__) || defined(__i586__) || defined(__i686__)
-	/*
-	 * x86 family is always 4K page.
-	 */
-	c = (x == 4096);
-#elif defined(__aarch64__)
-	/*
-	 * Linux aarch64 supports three values of page size: 4K, 16K, and 64K
-	 * which are selected at kernel compilation time.
-	 */
-	c = (x == 4096 || x == (16 * 1024) || x == (64 * 1024));
-#else
-	/*
-	 * Assuming other architectures must have at least 4K page.
-	 */
-	c = (x >= 4096);
-#endif
-
-	return !c;
-}
-
-int test_fork(void)
-{
-	int status;
-	pid_t pid;
-
-	/* flush the printf buffer to avoid child flush it */
-	fflush(stdout);
-	fflush(stderr);
-
-	pid = fork();
-
-	switch (pid) {
-	case -1:
-		return 1;
-
-	case 0:
-		exit(123);
-
-	default:
-		pid = waitpid(pid, &status, 0);
-
-		return pid == -1 || !WIFEXITED(status) || WEXITSTATUS(status) != 123;
-	}
-}
-
-int test_stat_timestamps(void)
-{
-	struct stat st;
-
-	if (sizeof(st.st_atim.tv_sec) != sizeof(st.st_atime))
-		return 1;
-
-	if (stat("/proc/self/", &st) && stat(argv0, &st) && stat("/", &st))
-		return 1;
-
-	if (st.st_atim.tv_sec != st.st_atime || st.st_atim.tv_nsec > 1000000000)
-		return 1;
-
-	if (st.st_mtim.tv_sec != st.st_mtime || st.st_mtim.tv_nsec > 1000000000)
-		return 1;
-
-	if (st.st_ctim.tv_sec != st.st_ctime || st.st_ctim.tv_nsec > 1000000000)
-		return 1;
-
-	return 0;
-}
-
-int test_uname(void)
-{
-	struct utsname buf;
-	char osrelease[sizeof(buf.release)];
-	ssize_t r;
-	int fd;
-
-	memset(&buf.domainname, 'P', sizeof(buf.domainname));
-
-	if (uname(&buf))
-		return 1;
-
-	if (strncmp("Linux", buf.sysname, sizeof(buf.sysname)))
-		return 1;
-
-	fd = open("/proc/sys/kernel/osrelease", O_RDONLY);
-	if (fd == -1)
-		return 1;
-
-	r = read(fd, osrelease, sizeof(osrelease));
-	if (r == -1)
-		return 1;
-
-	close(fd);
-
-	if (osrelease[r - 1] == '\n')
-		r--;
-
-	/* Validate one of the later fields to ensure field sizes are correct */
-	if (strncmp(osrelease, buf.release, r))
-		return 1;
-
-	/* Ensure the field domainname is set, it is missing from struct old_utsname */
-	if (strnlen(buf.domainname, sizeof(buf.domainname)) == sizeof(buf.domainname))
-		return 1;
-
-	return 0;
-}
-
-int test_mmap_munmap(void)
-{
-	int ret, fd, i, page_size;
-	void *mem;
-	size_t file_size, length;
-	off_t offset, pa_offset;
-	struct stat stat_buf;
-	const char * const files[] = {
-		"/dev/zero",
-		"/proc/1/exe", "/proc/self/exe",
-		argv0,
-		NULL
-	};
-
-	page_size = getpagesize();
-	if (page_size < 0)
-		return 1;
-
-	/* find a right file to mmap, existed and accessible */
-	for (i = 0; files[i] != NULL; i++) {
-		ret = fd = open(files[i], O_RDONLY);
-		if (ret == -1)
-			continue;
-		else
-			break;
-	}
-	if (ret == -1)
-		return 1;
-
-	ret = stat(files[i], &stat_buf);
-	if (ret == -1)
-		goto end;
-
-	/* file size of the special /dev/zero is 0, let's assign one manually */
-	if (i == 0)
-		file_size = 3*page_size;
-	else
-		file_size = stat_buf.st_size;
-
-	offset = file_size - 1;
-	if (offset < 0)
-		offset = 0;
-	length = file_size - offset;
-	pa_offset = offset & ~(page_size - 1);
-
-	mem = mmap(NULL, length + offset - pa_offset, PROT_READ, MAP_SHARED, fd, pa_offset);
-	if (mem == MAP_FAILED) {
-		ret = 1;
-		goto end;
-	}
-
-	ret = munmap(mem, length + offset - pa_offset);
-
-end:
-	close(fd);
-	return !!ret;
-}
-
-int test_pipe(void)
-{
-	const char *const msg = "hello, nolibc";
-	int pipefd[2];
-	char buf[32];
-	size_t len;
-
-	if (pipe(pipefd) == -1)
-		return 1;
-
-	write(pipefd[1], msg, strlen(msg));
-	close(pipefd[1]);
-	len = read(pipefd[0], buf, sizeof(buf));
-	close(pipefd[0]);
-
-	if (len != strlen(msg))
-		return 1;
-
-	return !!memcmp(buf, msg, len);
-}
-
-int test_rlimit(void)
-{
-	struct rlimit rlim = {
-		.rlim_cur = 1 << 20,
-		.rlim_max = 1 << 21,
-	};
-	int ret;
-
-	ret = setrlimit(RLIMIT_CORE, &rlim);
-	if (ret)
-		return -1;
-
-	rlim.rlim_cur = 0;
-	rlim.rlim_max = 0;
-
-	ret = getrlimit(RLIMIT_CORE, &rlim);
-	if (ret)
-		return -1;
-
-	if (rlim.rlim_cur != 1 << 20)
-		return -1;
-	if (rlim.rlim_max != 1 << 21)
-		return -1;
-
-	return 0;
-}
-
-int test_openat(void)
-{
-	int dev, null;
-
-	dev = openat(AT_FDCWD, "/dev", O_DIRECTORY);
-	if (dev < 0)
-		return -1;
-
-	null = openat(dev, "null", O_RDONLY);
-	close(dev);
-	if (null < 0)
-		return -1;
-
-	close(null);
-	return 0;
-}
-
-/* Run syscall tests between IDs <min> and <max>.
- * Return 0 on success, non-zero on failure.
- */
-int run_syscall(int min, int max)
-{
-	struct timeval tv;
-	struct timezone tz;
-	struct stat stat_buf;
-	int euid0;
-	int proc;
-	int test;
-	int tmp;
-	int ret = 0;
-	void *p1, *p2;
-	int has_gettid = 1;
-	int has_brk;
-
-	/* <proc> indicates whether or not /proc is mounted */
-	proc = stat("/proc", &stat_buf) == 0;
-
-	/* this will be used to skip certain tests that can't be run unprivileged */
-	euid0 = geteuid() == 0;
-
-	/* from 2.30, glibc provides gettid() */
-#if defined(__GLIBC_MINOR__) && defined(__GLIBC__)
-	has_gettid = __GLIBC__ > 2 || (__GLIBC__ == 2 && __GLIBC_MINOR__ >= 30);
-#endif
-
-	/* on musl setting brk()/sbrk() always fails */
-	has_brk = brk(0) == 0;
-
-	for (test = min; test >= 0 && test <= max; test++) {
-		int llen = 0; /* line length */
-
-		/* avoid leaving empty lines below, this will insert holes into
-		 * test numbers.
-		 */
-		switch (test + __LINE__ + 1) {
-		CASE_TEST(getpid);            EXPECT_SYSNE(1, getpid(), -1); break;
-		CASE_TEST(getppid);           EXPECT_SYSNE(1, getppid(), -1); break;
-		CASE_TEST(gettid);            EXPECT_SYSNE(has_gettid, gettid(), -1); break;
-		CASE_TEST(getpgid_self);      EXPECT_SYSNE(1, getpgid(0), -1); break;
-		CASE_TEST(getpgid_bad);       EXPECT_SYSER(1, getpgid(-1), -1, ESRCH); break;
-		CASE_TEST(kill_0);            EXPECT_SYSZR(1, kill(getpid(), 0)); break;
-		CASE_TEST(kill_CONT);         EXPECT_SYSZR(1, kill(getpid(), 0)); break;
-		CASE_TEST(kill_BADPID);       EXPECT_SYSER(1, kill(INT_MAX, 0), -1, ESRCH); break;
-		CASE_TEST(sbrk_0);            EXPECT_PTRNE(has_brk, sbrk(0), (void *)-1); break;
-		CASE_TEST(sbrk);              if ((p1 = p2 = sbrk(4096)) != (void *)-1) p2 = sbrk(-4096); EXPECT_SYSZR(has_brk, (p2 == (void *)-1) || p2 == p1); break;
-		CASE_TEST(brk);               EXPECT_SYSZR(has_brk, brk(sbrk(0))); break;
-		CASE_TEST(chdir_root);        EXPECT_SYSZR(1, chdir("/")); chdir(getenv("PWD")); break;
-		CASE_TEST(chdir_dot);         EXPECT_SYSZR(1, chdir(".")); break;
-		CASE_TEST(chdir_blah);        EXPECT_SYSER(1, chdir("/blah"), -1, ENOENT); break;
-		CASE_TEST(chmod_argv0);       EXPECT_SYSZR(1, chmod(argv0, 0555)); break;
-		CASE_TEST(chmod_self);        EXPECT_SYSER(proc, chmod("/proc/self", 0555), -1, EPERM); break;
-		CASE_TEST(chown_self);        EXPECT_SYSER(proc, chown("/proc/self", 0, 0), -1, EPERM); break;
-		CASE_TEST(chroot_root);       EXPECT_SYSZR(euid0, chroot("/")); break;
-		CASE_TEST(chroot_blah);       EXPECT_SYSER(1, chroot("/proc/self/blah"), -1, ENOENT); break;
-		CASE_TEST(chroot_exe);        EXPECT_SYSER(1, chroot(argv0), -1, ENOTDIR); break;
-		CASE_TEST(close_m1);          EXPECT_SYSER(1, close(-1), -1, EBADF); break;
-		CASE_TEST(close_dup);         EXPECT_SYSZR(1, close(dup(0))); break;
-		CASE_TEST(dup_0);             tmp = dup(0);  EXPECT_SYSNE(1, tmp, -1); close(tmp); break;
-		CASE_TEST(dup_m1);            tmp = dup(-1); EXPECT_SYSER(1, tmp, -1, EBADF); if (tmp != -1) close(tmp); break;
-		CASE_TEST(dup2_0);            tmp = dup2(0, 100);  EXPECT_SYSNE(1, tmp, -1); close(tmp); break;
-		CASE_TEST(dup2_m1);           tmp = dup2(-1, 100); EXPECT_SYSER(1, tmp, -1, EBADF); if (tmp != -1) close(tmp); break;
-		CASE_TEST(dup3_0);            tmp = dup3(0, 100, 0);  EXPECT_SYSNE(1, tmp, -1); close(tmp); break;
-		CASE_TEST(dup3_m1);           tmp = dup3(-1, 100, 0); EXPECT_SYSER(1, tmp, -1, EBADF); if (tmp != -1) close(tmp); break;
-		CASE_TEST(execve_root);       EXPECT_SYSER(1, execve("/", (char*[]){ [0] = "/", [1] = NULL }, NULL), -1, EACCES); break;
-		CASE_TEST(fork);              EXPECT_SYSZR(1, test_fork()); break;
-		CASE_TEST(getdents64_root);   EXPECT_SYSNE(1, test_getdents64("/"), -1); break;
-		CASE_TEST(getdents64_null);   EXPECT_SYSER(1, test_getdents64("/dev/null"), -1, ENOTDIR); break;
-		CASE_TEST(directories);       EXPECT_SYSZR(proc, test_dirent()); break;
-		CASE_TEST(gettimeofday_tv);   EXPECT_SYSZR(1, gettimeofday(&tv, NULL)); break;
-		CASE_TEST(gettimeofday_tv_tz);EXPECT_SYSZR(1, gettimeofday(&tv, &tz)); break;
-		CASE_TEST(getpagesize);       EXPECT_SYSZR(1, test_getpagesize()); break;
-		CASE_TEST(ioctl_tiocinq);     EXPECT_SYSZR(1, ioctl(0, TIOCINQ, &tmp)); break;
-		CASE_TEST(link_root1);        EXPECT_SYSER(1, link("/", "/"), -1, EEXIST); break;
-		CASE_TEST(link_blah);         EXPECT_SYSER(1, link("/proc/self/blah", "/blah"), -1, ENOENT); break;
-		CASE_TEST(link_dir);          EXPECT_SYSER(euid0, link("/", "/blah"), -1, EPERM); break;
-		CASE_TEST(link_cross);        EXPECT_SYSER(proc, link("/proc/self/cmdline", "/blah"), -1, EXDEV); break;
-		CASE_TEST(lseek_m1);          EXPECT_SYSER(1, lseek(-1, 0, SEEK_SET), -1, EBADF); break;
-		CASE_TEST(lseek_0);           EXPECT_SYSER(1, lseek(0, 0, SEEK_SET), -1, ESPIPE); break;
-		CASE_TEST(mkdir_root);        EXPECT_SYSER(1, mkdir("/", 0755), -1, EEXIST); break;
-		CASE_TEST(mmap_bad);          EXPECT_PTRER(1, mmap(NULL, 0, PROT_READ, MAP_PRIVATE, 0, 0), MAP_FAILED, EINVAL); break;
-		CASE_TEST(munmap_bad);        EXPECT_SYSER(1, munmap(NULL, 0), -1, EINVAL); break;
-		CASE_TEST(mmap_munmap_good);  EXPECT_SYSZR(1, test_mmap_munmap()); break;
-		CASE_TEST(open_tty);          EXPECT_SYSNE(1, tmp = open("/dev/null", O_RDONLY), -1); if (tmp != -1) close(tmp); break;
-		CASE_TEST(open_blah);         EXPECT_SYSER(1, tmp = open("/proc/self/blah", O_RDONLY), -1, ENOENT); if (tmp != -1) close(tmp); break;
-		CASE_TEST(openat_dir);        EXPECT_SYSZR(1, test_openat()); break;
-		CASE_TEST(pipe);              EXPECT_SYSZR(1, test_pipe()); break;
-		CASE_TEST(poll_null);         EXPECT_SYSZR(1, poll(NULL, 0, 0)); break;
-		CASE_TEST(poll_stdout);       EXPECT_SYSNE(1, ({ struct pollfd fds = { 1, POLLOUT, 0}; poll(&fds, 1, 0); }), -1); break;
-		CASE_TEST(poll_fault);        EXPECT_SYSER(1, poll(NULL, 1, 0), -1, EFAULT); break;
-		CASE_TEST(prctl);             EXPECT_SYSER(1, prctl(PR_SET_NAME, (unsigned long)NULL, 0, 0, 0), -1, EFAULT); break;
-		CASE_TEST(read_badf);         EXPECT_SYSER(1, read(-1, &tmp, 1), -1, EBADF); break;
-		CASE_TEST(rlimit);            EXPECT_SYSZR(1, test_rlimit()); break;
-		CASE_TEST(rmdir_blah);        EXPECT_SYSER(1, rmdir("/blah"), -1, ENOENT); break;
-		CASE_TEST(sched_yield);       EXPECT_SYSZR(1, sched_yield()); break;
-		CASE_TEST(select_null);       EXPECT_SYSZR(1, ({ struct timeval tv = { 0 }; select(0, NULL, NULL, NULL, &tv); })); break;
-		CASE_TEST(select_stdout);     EXPECT_SYSNE(1, ({ fd_set fds; FD_ZERO(&fds); FD_SET(1, &fds); select(2, NULL, &fds, NULL, NULL); }), -1); break;
-		CASE_TEST(select_fault);      EXPECT_SYSER(1, select(1, (void *)1, NULL, NULL, 0), -1, EFAULT); break;
-		CASE_TEST(stat_blah);         EXPECT_SYSER(1, stat("/proc/self/blah", &stat_buf), -1, ENOENT); break;
-		CASE_TEST(stat_fault);        EXPECT_SYSER(1, stat(NULL, &stat_buf), -1, EFAULT); break;
-		CASE_TEST(stat_timestamps);   EXPECT_SYSZR(1, test_stat_timestamps()); break;
-		CASE_TEST(symlink_root);      EXPECT_SYSER(1, symlink("/", "/"), -1, EEXIST); break;
-		CASE_TEST(uname);             EXPECT_SYSZR(proc, test_uname()); break;
-		CASE_TEST(uname_fault);       EXPECT_SYSER(1, uname(NULL), -1, EFAULT); break;
-		CASE_TEST(unlink_root);       EXPECT_SYSER(1, unlink("/"), -1, EISDIR); break;
-		CASE_TEST(unlink_blah);       EXPECT_SYSER(1, unlink("/proc/self/blah"), -1, ENOENT); break;
-		CASE_TEST(wait_child);        EXPECT_SYSER(1, wait(&tmp), -1, ECHILD); break;
-		CASE_TEST(waitpid_min);       EXPECT_SYSER(1, waitpid(INT_MIN, &tmp, WNOHANG), -1, ESRCH); break;
-		CASE_TEST(waitpid_child);     EXPECT_SYSER(1, waitpid(getpid(), &tmp, WNOHANG), -1, ECHILD); break;
-		CASE_TEST(write_badf);        EXPECT_SYSER(1, write(-1, &tmp, 1), -1, EBADF); break;
-		CASE_TEST(write_zero);        EXPECT_SYSZR(1, write(1, &tmp, 0)); break;
-		CASE_TEST(syscall_noargs);    EXPECT_SYSEQ(1, syscall(__NR_getpid), getpid()); break;
-		CASE_TEST(syscall_args);      EXPECT_SYSER(1, syscall(__NR_statx, 0, NULL, 0, 0, NULL), -1, EFAULT); break;
-		case __LINE__:
-			return ret; /* must be last */
-		/* note: do not set any defaults so as to permit holes above */
-		}
-	}
-	return ret;
-}
-
-int run_stdlib(int min, int max)
-{
-	int test;
-	int ret = 0;
-
-	for (test = min; test >= 0 && test <= max; test++) {
-		int llen = 0; /* line length */
-
-		/* For functions that take a long buffer, like strlcat()
-		 * Add some more chars after the \0, to test functions that overwrite the buffer set
-		 * the \0 at the exact right position.
-		 */
-		char buf[10] = "test123456";
-		buf[4] = '\0';
-
-
-		/* avoid leaving empty lines below, this will insert holes into
-		 * test numbers.
-		 */
-		switch (test + __LINE__ + 1) {
-		CASE_TEST(getenv_TERM);        EXPECT_STRNZ(1, getenv("TERM")); break;
-		CASE_TEST(getenv_blah);        EXPECT_STRZR(1, getenv("blah")); break;
-		CASE_TEST(setcmp_blah_blah);   EXPECT_EQ(1, strcmp("blah", "blah"), 0); break;
-		CASE_TEST(setcmp_blah_blah2);  EXPECT_NE(1, strcmp("blah", "blah2"), 0); break;
-		CASE_TEST(setncmp_blah_blah);  EXPECT_EQ(1, strncmp("blah", "blah", 10), 0); break;
-		CASE_TEST(setncmp_blah_blah4); EXPECT_EQ(1, strncmp("blah", "blah4", 4), 0); break;
-		CASE_TEST(setncmp_blah_blah5); EXPECT_NE(1, strncmp("blah", "blah5", 5), 0); break;
-		CASE_TEST(setncmp_blah_blah6); EXPECT_NE(1, strncmp("blah", "blah6", 6), 0); break;
-		CASE_TEST(strchr_foobar_o);    EXPECT_STREQ(1, strchr("foobar", 'o'), "oobar"); break;
-		CASE_TEST(strchr_foobar_z);    EXPECT_STRZR(1, strchr("foobar", 'z')); break;
-		CASE_TEST(strrchr_foobar_o);   EXPECT_STREQ(1, strrchr("foobar", 'o'), "obar"); break;
-		CASE_TEST(strrchr_foobar_z);   EXPECT_STRZR(1, strrchr("foobar", 'z')); break;
-		CASE_TEST(strlcat_0);          EXPECT_STRBUFEQ(is_nolibc, strlcat(buf, "bar", 0), buf, 3, "test"); break;
-		CASE_TEST(strlcat_1);          EXPECT_STRBUFEQ(is_nolibc, strlcat(buf, "bar", 1), buf, 4, "test"); break;
-		CASE_TEST(strlcat_5);          EXPECT_STRBUFEQ(is_nolibc, strlcat(buf, "bar", 5), buf, 7, "test"); break;
-		CASE_TEST(strlcat_6);          EXPECT_STRBUFEQ(is_nolibc, strlcat(buf, "bar", 6), buf, 7, "testb"); break;
-		CASE_TEST(strlcat_7);          EXPECT_STRBUFEQ(is_nolibc, strlcat(buf, "bar", 7), buf, 7, "testba"); break;
-		CASE_TEST(strlcat_8);          EXPECT_STRBUFEQ(is_nolibc, strlcat(buf, "bar", 8), buf, 7, "testbar"); break;
-		CASE_TEST(strlcpy_0);          EXPECT_STRBUFEQ(is_nolibc, strlcpy(buf, "bar", 0), buf, 3, "test"); break;
-		CASE_TEST(strlcpy_1);          EXPECT_STRBUFEQ(is_nolibc, strlcpy(buf, "bar", 1), buf, 3, ""); break;
-		CASE_TEST(strlcpy_2);          EXPECT_STRBUFEQ(is_nolibc, strlcpy(buf, "bar", 2), buf, 3, "b"); break;
-		CASE_TEST(strlcpy_3);          EXPECT_STRBUFEQ(is_nolibc, strlcpy(buf, "bar", 3), buf, 3, "ba"); break;
-		CASE_TEST(strlcpy_4);          EXPECT_STRBUFEQ(is_nolibc, strlcpy(buf, "bar", 4), buf, 3, "bar"); break;
-		CASE_TEST(memcmp_20_20);       EXPECT_EQ(1, memcmp("aaa\x20", "aaa\x20", 4), 0); break;
-		CASE_TEST(memcmp_20_60);       EXPECT_LT(1, memcmp("aaa\x20", "aaa\x60", 4), 0); break;
-		CASE_TEST(memcmp_60_20);       EXPECT_GT(1, memcmp("aaa\x60", "aaa\x20", 4), 0); break;
-		CASE_TEST(memcmp_20_e0);       EXPECT_LT(1, memcmp("aaa\x20", "aaa\xe0", 4), 0); break;
-		CASE_TEST(memcmp_e0_20);       EXPECT_GT(1, memcmp("aaa\xe0", "aaa\x20", 4), 0); break;
-		CASE_TEST(memcmp_80_e0);       EXPECT_LT(1, memcmp("aaa\x80", "aaa\xe0", 4), 0); break;
-		CASE_TEST(memcmp_e0_80);       EXPECT_GT(1, memcmp("aaa\xe0", "aaa\x80", 4), 0); break;
-		CASE_TEST(limit_int8_max);          EXPECT_EQ(1, INT8_MAX,         (int8_t)          0x7f); break;
-		CASE_TEST(limit_int8_min);          EXPECT_EQ(1, INT8_MIN,         (int8_t)          0x80); break;
-		CASE_TEST(limit_uint8_max);         EXPECT_EQ(1, UINT8_MAX,        (uint8_t)         0xff); break;
-		CASE_TEST(limit_int16_max);         EXPECT_EQ(1, INT16_MAX,        (int16_t)         0x7fff); break;
-		CASE_TEST(limit_int16_min);         EXPECT_EQ(1, INT16_MIN,        (int16_t)         0x8000); break;
-		CASE_TEST(limit_uint16_max);        EXPECT_EQ(1, UINT16_MAX,       (uint16_t)        0xffff); break;
-		CASE_TEST(limit_int32_max);         EXPECT_EQ(1, INT32_MAX,        (int32_t)         0x7fffffff); break;
-		CASE_TEST(limit_int32_min);         EXPECT_EQ(1, INT32_MIN,        (int32_t)         0x80000000); break;
-		CASE_TEST(limit_uint32_max);        EXPECT_EQ(1, UINT32_MAX,       (uint32_t)        0xffffffff); break;
-		CASE_TEST(limit_int64_max);         EXPECT_EQ(1, INT64_MAX,        (int64_t)         0x7fffffffffffffff); break;
-		CASE_TEST(limit_int64_min);         EXPECT_EQ(1, INT64_MIN,        (int64_t)         0x8000000000000000); break;
-		CASE_TEST(limit_uint64_max);        EXPECT_EQ(1, UINT64_MAX,       (uint64_t)        0xffffffffffffffff); break;
-		CASE_TEST(limit_int_least8_max);    EXPECT_EQ(1, INT_LEAST8_MAX,   (int_least8_t)    0x7f); break;
-		CASE_TEST(limit_int_least8_min);    EXPECT_EQ(1, INT_LEAST8_MIN,   (int_least8_t)    0x80); break;
-		CASE_TEST(limit_uint_least8_max);   EXPECT_EQ(1, UINT_LEAST8_MAX,  (uint_least8_t)   0xff); break;
-		CASE_TEST(limit_int_least16_max);   EXPECT_EQ(1, INT_LEAST16_MAX,  (int_least16_t)   0x7fff); break;
-		CASE_TEST(limit_int_least16_min);   EXPECT_EQ(1, INT_LEAST16_MIN,  (int_least16_t)   0x8000); break;
-		CASE_TEST(limit_uint_least16_max);  EXPECT_EQ(1, UINT_LEAST16_MAX, (uint_least16_t)  0xffff); break;
-		CASE_TEST(limit_int_least32_max);   EXPECT_EQ(1, INT_LEAST32_MAX,  (int_least32_t)   0x7fffffff); break;
-		CASE_TEST(limit_int_least32_min);   EXPECT_EQ(1, INT_LEAST32_MIN,  (int_least32_t)   0x80000000); break;
-		CASE_TEST(limit_uint_least32_max);  EXPECT_EQ(1, UINT_LEAST32_MAX, (uint_least32_t)  0xffffffffU); break;
-		CASE_TEST(limit_int_least64_min);   EXPECT_EQ(1, INT_LEAST64_MIN,  (int_least64_t)   0x8000000000000000LL); break;
-		CASE_TEST(limit_int_least64_max);   EXPECT_EQ(1, INT_LEAST64_MAX,  (int_least64_t)   0x7fffffffffffffffLL); break;
-		CASE_TEST(limit_uint_least64_max);  EXPECT_EQ(1, UINT_LEAST64_MAX, (uint_least64_t)  0xffffffffffffffffULL); break;
-		CASE_TEST(limit_int_fast8_max);     EXPECT_EQ(1, INT_FAST8_MAX,    (int_fast8_t)     0x7f); break;
-		CASE_TEST(limit_int_fast8_min);     EXPECT_EQ(1, INT_FAST8_MIN,    (int_fast8_t)     0x80); break;
-		CASE_TEST(limit_uint_fast8_max);    EXPECT_EQ(1, UINT_FAST8_MAX,   (uint_fast8_t)    0xff); break;
-		CASE_TEST(limit_int_fast16_min);    EXPECT_EQ(1, INT_FAST16_MIN,   (int_fast16_t)    SINT_MIN_OF_TYPE(int_fast16_t)); break;
-		CASE_TEST(limit_int_fast16_max);    EXPECT_EQ(1, INT_FAST16_MAX,   (int_fast16_t)    SINT_MAX_OF_TYPE(int_fast16_t)); break;
-		CASE_TEST(limit_uint_fast16_max);   EXPECT_EQ(1, UINT_FAST16_MAX,  (uint_fast16_t)   UINTPTR_MAX); break;
-		CASE_TEST(limit_int_fast32_min);    EXPECT_EQ(1, INT_FAST32_MIN,   (int_fast32_t)    SINT_MIN_OF_TYPE(int_fast32_t)); break;
-		CASE_TEST(limit_int_fast32_max);    EXPECT_EQ(1, INT_FAST32_MAX,   (int_fast32_t)    SINT_MAX_OF_TYPE(int_fast32_t)); break;
-		CASE_TEST(limit_uint_fast32_max);   EXPECT_EQ(1, UINT_FAST32_MAX,  (uint_fast32_t)   UINTPTR_MAX); break;
-		CASE_TEST(limit_int_fast64_min);    EXPECT_EQ(1, INT_FAST64_MIN,   (int_fast64_t)    INT64_MIN); break;
-		CASE_TEST(limit_int_fast64_max);    EXPECT_EQ(1, INT_FAST64_MAX,   (int_fast64_t)    INT64_MAX); break;
-		CASE_TEST(limit_uint_fast64_max);   EXPECT_EQ(1, UINT_FAST64_MAX,  (uint_fast64_t)   UINT64_MAX); break;
-		CASE_TEST(sizeof_long_sane);        EXPECT_EQ(1, sizeof(long) == 8 || sizeof(long) == 4, 1); break;
-		CASE_TEST(limit_intptr_min);        EXPECT_EQ(1, INTPTR_MIN,  sizeof(long) == 8 ? (intptr_t)  0x8000000000000000LL  : (intptr_t)  0x80000000); break;
-		CASE_TEST(limit_intptr_max);        EXPECT_EQ(1, INTPTR_MAX,  sizeof(long) == 8 ? (intptr_t)  0x7fffffffffffffffLL  : (intptr_t)  0x7fffffff); break;
-		CASE_TEST(limit_uintptr_max);       EXPECT_EQ(1, UINTPTR_MAX, sizeof(long) == 8 ? (uintptr_t) 0xffffffffffffffffULL : (uintptr_t) 0xffffffffU); break;
-		CASE_TEST(limit_ptrdiff_min);       EXPECT_EQ(1, PTRDIFF_MIN, sizeof(long) == 8 ? (ptrdiff_t) 0x8000000000000000LL  : (ptrdiff_t) 0x80000000); break;
-		CASE_TEST(limit_ptrdiff_max);       EXPECT_EQ(1, PTRDIFF_MAX, sizeof(long) == 8 ? (ptrdiff_t) 0x7fffffffffffffffLL  : (ptrdiff_t) 0x7fffffff); break;
-		CASE_TEST(limit_size_max);          EXPECT_EQ(1, SIZE_MAX,    sizeof(long) == 8 ? (size_t)    0xffffffffffffffffULL : (size_t)    0xffffffffU); break;
-		CASE_TEST(strtol_simple);           EXPECT_STRTOX(1, strtol, "35", 10, 35, -1, 0); break;
-		CASE_TEST(strtol_positive);         EXPECT_STRTOX(1, strtol, "+35", 10, 35, -1, 0); break;
-		CASE_TEST(strtol_negative);         EXPECT_STRTOX(1, strtol, "-35", 10, -35, -1, 0); break;
-		CASE_TEST(strtol_hex_auto);         EXPECT_STRTOX(1, strtol, "0xFF", 0, 255, -1, 0); break;
-		CASE_TEST(strtol_base36);           EXPECT_STRTOX(1, strtol, "12yZ", 36, 50507, -1, 0); break;
-		CASE_TEST(strtol_cutoff);           EXPECT_STRTOX(1, strtol, "1234567890", 8, 342391, 7, 0); break;
-		CASE_TEST(strtol_octal_auto);       EXPECT_STRTOX(1, strtol, "011", 0, 9, -1, 0); break;
-		CASE_TEST(strtol_hex_00);           EXPECT_STRTOX(1, strtol, "0x00", 16, 0, -1, 0); break;
-		CASE_TEST(strtol_hex_FF);           EXPECT_STRTOX(1, strtol, "FF", 16, 255, -1, 0); break;
-		CASE_TEST(strtol_hex_ff);           EXPECT_STRTOX(1, strtol, "ff", 16, 255, -1, 0); break;
-		CASE_TEST(strtol_hex_prefix);       EXPECT_STRTOX(1, strtol, "0xFF", 16, 255, -1, 0); break;
-		CASE_TEST(strtol_trailer);          EXPECT_STRTOX(1, strtol, "35foo", 10, 35, 2, 0); break;
-		CASE_TEST(strtol_overflow);         EXPECT_STRTOX(1, strtol, "0x8000000000000000", 16, LONG_MAX, -1, ERANGE); break;
-		CASE_TEST(strtol_underflow);        EXPECT_STRTOX(1, strtol, "-0x8000000000000001", 16, LONG_MIN, -1, ERANGE); break;
-		CASE_TEST(strtoul_negative);        EXPECT_STRTOX(1, strtoul, "-0x1", 16, ULONG_MAX, 4, 0); break;
-		CASE_TEST(strtoul_overflow);        EXPECT_STRTOX(1, strtoul, "0x10000000000000000", 16, ULONG_MAX, -1, ERANGE); break;
-		CASE_TEST(strerror_success);        EXPECT_STREQ(is_nolibc, strerror(0), "errno=0"); break;
-		CASE_TEST(strerror_EINVAL);         EXPECT_STREQ(is_nolibc, strerror(EINVAL), "errno=22"); break;
-		CASE_TEST(strerror_int_max);        EXPECT_STREQ(is_nolibc, strerror(INT_MAX), "errno=2147483647"); break;
-		CASE_TEST(strerror_int_min);        EXPECT_STREQ(is_nolibc, strerror(INT_MIN), "errno=-2147483648"); break;
-		CASE_TEST(tolower);                 EXPECT_EQ(1, tolower('A'), 'a'); break;
-		CASE_TEST(tolower_noop);            EXPECT_EQ(1, tolower('a'), 'a'); break;
-		CASE_TEST(toupper);                 EXPECT_EQ(1, toupper('a'), 'A'); break;
-		CASE_TEST(toupper_noop);            EXPECT_EQ(1, toupper('A'), 'A'); break;
-
-		case __LINE__:
-			return ret; /* must be last */
-		/* note: do not set any defaults so as to permit holes above */
-		}
-	}
-	return ret;
-}
-
-#define EXPECT_VFPRINTF(c, expected, fmt, ...)				\
-	ret += expect_vfprintf(llen, c, expected, fmt, ##__VA_ARGS__)
-
-static int expect_vfprintf(int llen, int c, const char *expected, const char *fmt, ...)
-{
-	char buf[100];
-	va_list args;
-	ssize_t w;
-	int ret;
-
-
-	va_start(args, fmt);
-	/* Only allow writing 21 bytes, to test truncation */
-	w = vsnprintf(buf, 21, fmt, args);
-	va_end(args);
-
-	if (w != c) {
-		llen += printf(" written(%d) != %d", (int)w, c);
-		result(llen, FAIL);
-		return 1;
-	}
-
-	llen += printf(" \"%s\" = \"%s\"", expected, buf);
-	ret = strncmp(expected, buf, c);
-
-	result(llen, ret ? FAIL : OK);
-	return ret;
-}
-
-static int test_scanf(void)
-{
-	unsigned long long ull;
-	unsigned long ul;
-	unsigned int u;
-	long long ll;
-	long l;
-	void *p;
-	int i;
-
-	/* return __LINE__ to point to the specific failure */
-
-	/* test EOF */
-	if (sscanf("", "foo") != EOF)
-		return __LINE__;
-
-	/* test simple literal without placeholder */
-	if (sscanf("foo", "foo") != 0)
-		return __LINE__;
-
-	/* test single placeholder */
-	if (sscanf("123", "%d", &i) != 1)
-		return __LINE__;
-
-	if (i != 123)
-		return __LINE__;
-
-	/* test multiple place holders and separators */
-	if (sscanf("a123b456c0x90", "a%db%uc%p", &i, &u, &p) != 3)
-		return __LINE__;
-
-	if (i != 123)
-		return __LINE__;
-
-	if (u != 456)
-		return __LINE__;
-
-	if (p != (void *)0x90)
-		return __LINE__;
-
-	/* test space handling */
-	if (sscanf("a    b1", "a b%d", &i) != 1)
-		return __LINE__;
-
-	if (i != 1)
-		return __LINE__;
-
-	/* test literal percent */
-	if (sscanf("a%1", "a%%%d", &i) != 1)
-		return __LINE__;
-
-	if (i != 1)
-		return __LINE__;
-
-	/* test stdint.h types */
-	if (sscanf("1|2|3|4|5|6",
-		   "%d|%ld|%lld|%u|%lu|%llu",
-		   &i, &l, &ll, &u, &ul, &ull) != 6)
-		return __LINE__;
-
-	if (i != 1 || l != 2 || ll != 3 ||
-	    u != 4 || ul != 5 || ull != 6)
-		return __LINE__;
-
-	return 0;
-}
-
-static int run_printf(int min, int max)
-{
-	int test;
-	int ret = 0;
-
-	for (test = min; test >= 0 && test <= max; test++) {
-		int llen = 0; /* line length */
-
-		/* avoid leaving empty lines below, this will insert holes into
-		 * test numbers.
-		 */
-		switch (test + __LINE__ + 1) {
-		CASE_TEST(empty);        EXPECT_VFPRINTF(0, "", ""); break;
-		CASE_TEST(simple);       EXPECT_VFPRINTF(3, "foo", "foo"); break;
-		CASE_TEST(string);       EXPECT_VFPRINTF(3, "foo", "%s", "foo"); break;
-		CASE_TEST(number);       EXPECT_VFPRINTF(4, "1234", "%d", 1234); break;
-		CASE_TEST(negnumber);    EXPECT_VFPRINTF(5, "-1234", "%d", -1234); break;
-		CASE_TEST(unsigned);     EXPECT_VFPRINTF(5, "12345", "%u", 12345); break;
-		CASE_TEST(char);         EXPECT_VFPRINTF(1, "c", "%c", 'c'); break;
-		CASE_TEST(hex);          EXPECT_VFPRINTF(1, "f", "%x", 0xf); break;
-		CASE_TEST(pointer);      EXPECT_VFPRINTF(3, "0x1", "%p", (void *) 0x1); break;
-		CASE_TEST(uintmax_t);    EXPECT_VFPRINTF(20, "18446744073709551615", "%ju", 0xffffffffffffffffULL); break;
-		CASE_TEST(intmax_t);     EXPECT_VFPRINTF(20, "-9223372036854775807", "%jd", 0x8000000000000001LL); break;
-		CASE_TEST(truncation);   EXPECT_VFPRINTF(25, "01234567890123456789", "%s", "0123456789012345678901234"); break;
-		CASE_TEST(string_width); EXPECT_VFPRINTF(10, "         1", "%10s", "1"); break;
-		CASE_TEST(number_width); EXPECT_VFPRINTF(10, "         1", "%10d", 1); break;
-		CASE_TEST(width_trunc);  EXPECT_VFPRINTF(25, "                    ", "%25d", 1); break;
-		CASE_TEST(scanf);        EXPECT_ZR(1, test_scanf()); break;
-		case __LINE__:
-			return ret; /* must be last */
-		/* note: do not set any defaults so as to permit holes above */
-		}
-	}
-	return ret;
-}
-
-static int smash_stack(void)
-{
-	char buf[100];
-	volatile char *ptr = buf;
-	size_t i;
-
-	for (i = 0; i < 200; i++)
-		ptr[i] = 'P';
-
-	return 1;
-}
-
-static int run_protection(int min __attribute__((unused)),
-			  int max __attribute__((unused)))
-{
-	pid_t pid;
-	int llen = 0, status;
-	struct rlimit rlimit = { 0, 0 };
-
-	llen += printf("0 -fstackprotector ");
-
-#if !defined(_NOLIBC_STACKPROTECTOR)
-	llen += printf("not supported");
-	result(llen, SKIPPED);
-	return 0;
-#endif
-
-#if defined(_NOLIBC_STACKPROTECTOR)
-	if (!__stack_chk_guard) {
-		llen += printf("__stack_chk_guard not initialized");
-		result(llen, FAIL);
-		return 1;
-	}
-#endif
-
-	pid = -1;
-	pid = fork();
-
-	switch (pid) {
-	case -1:
-		llen += printf("fork()");
-		result(llen, FAIL);
-		return 1;
-
-	case 0:
-		close(STDOUT_FILENO);
-		close(STDERR_FILENO);
-
-		prctl(PR_SET_DUMPABLE, 0, 0, 0, 0);
-		setrlimit(RLIMIT_CORE, &rlimit);
-		smash_stack();
-		return 1;
-
-	default:
-		pid = waitpid(pid, &status, 0);
-
-		if (pid == -1 || !WIFSIGNALED(status) || WTERMSIG(status) != SIGABRT) {
-			llen += printf("waitpid()");
-			result(llen, FAIL);
-			return 1;
-		}
-		result(llen, OK);
-		return 0;
-	}
-}
-
-/* prepare what needs to be prepared for pid 1 (stdio, /dev, /proc, etc) */
-int prepare(void)
-{
-	struct stat stat_buf;
-
-	/* It's possible that /dev doesn't even exist or was not mounted, so
-	 * we'll try to create it, mount it, or create minimal entries into it.
-	 * We want at least /dev/null and /dev/console.
-	 */
-	if (stat("/dev/.", &stat_buf) == 0 || mkdir("/dev", 0755) == 0) {
-		if (stat("/dev/console", &stat_buf) != 0 ||
-		    stat("/dev/null", &stat_buf) != 0 ||
-		    stat("/dev/zero", &stat_buf) != 0) {
-			/* try devtmpfs first, otherwise fall back to manual creation */
-			if (mount("/dev", "/dev", "devtmpfs", 0, 0) != 0) {
-				mknod("/dev/console", 0600 | S_IFCHR, makedev(5, 1));
-				mknod("/dev/null",    0666 | S_IFCHR, makedev(1, 3));
-				mknod("/dev/zero",    0666 | S_IFCHR, makedev(1, 5));
-			}
-		}
-	}
-
-	/* If no /dev/console was found before calling init, stdio is closed so
-	 * we need to reopen it from /dev/console. If it failed above, it will
-	 * still fail here and we cannot emit a message anyway.
-	 */
-	if (close(dup(1)) == -1) {
-		int fd = open("/dev/console", O_RDWR);
-
-		if (fd >= 0) {
-			if (fd != 0)
-				dup2(fd, 0);
-			if (fd != 1)
-				dup2(fd, 1);
-			if (fd != 2)
-				dup2(fd, 2);
-			if (fd > 2)
-				close(fd);
-			puts("\nSuccessfully reopened /dev/console.");
-		}
-	}
-
-	/* try to mount /proc if not mounted. Silently fail otherwise */
-	if (stat("/proc/.", &stat_buf) == 0 || mkdir("/proc", 0755) == 0) {
-		if (stat("/proc/self", &stat_buf) != 0) {
-			/* If not mountable, remove /proc completely to avoid misuse */
-			if (mount("none", "/proc", "proc", 0, 0) != 0)
-				rmdir("/proc");
-		}
-	}
-
-	/* some tests rely on a writable /tmp */
-	mkdir("/tmp", 0755);
-
-	return 0;
-}
-
-/* This is the definition of known test names, with their functions */
-static const struct test test_names[] = {
-	/* add new tests here */
-	{ .name = "startup",    .func = run_startup    },
-	{ .name = "syscall",    .func = run_syscall    },
-	{ .name = "stdlib",     .func = run_stdlib     },
-	{ .name = "printf",     .func = run_printf     },
-	{ .name = "protection", .func = run_protection },
-	{ 0 }
-};
-
-static int is_setting_valid(char *test)
-{
-	int idx, len, test_len, valid = 0;
-	char delimiter;
-
-	if (!test)
-		return valid;
-
-	test_len = strlen(test);
-
-	for (idx = 0; test_names[idx].name; idx++) {
-		len = strlen(test_names[idx].name);
-		if (test_len < len)
-			continue;
-
-		if (strncmp(test, test_names[idx].name, len) != 0)
-			continue;
-
-		delimiter = test[len];
-		if (delimiter != ':' && delimiter != ',' && delimiter != '\0')
-			continue;
-
-		valid = 1;
-		break;
-	}
-
-	return valid;
-}
-
-int main(int argc, char **argv, char **envp)
-{
-	int min = 0;
-	int max = INT_MAX;
-	int ret = 0;
-	int err;
-	int idx;
-	char *test;
-
-	argv0 = argv[0];
-	test_argc = argc;
-	test_argv = argv;
-	test_envp = envp;
-
-	/* when called as init, it's possible that no console was opened, for
-	 * example if no /dev file system was provided. We'll check that fd#1
-	 * was opened, and if not we'll attempt to create and open /dev/console
-	 * and /dev/null that we'll use for later tests.
-	 */
-	if (getpid() == 1)
-		prepare();
-
-	/* the definition of a series of tests comes from either argv[1] or the
-	 * "NOLIBC_TEST" environment variable. It's made of a comma-delimited
-	 * series of test names and optional ranges:
-	 *    syscall:5-15[:.*],stdlib:8-10
-	 */
-	test = argv[1];
-	if (!is_setting_valid(test))
-		test = getenv("NOLIBC_TEST");
-
-	if (is_setting_valid(test)) {
-		char *comma, *colon, *dash, *value;
-
-		do {
-			comma = strchr(test, ',');
-			if (comma)
-				*(comma++) = '\0';
-
-			colon = strchr(test, ':');
-			if (colon)
-				*(colon++) = '\0';
-
-			for (idx = 0; test_names[idx].name; idx++) {
-				if (strcmp(test, test_names[idx].name) == 0)
-					break;
-			}
-
-			if (test_names[idx].name) {
-				/* The test was named, it will be called at least
-				 * once. We may have an optional range at <colon>
-				 * here, which defaults to the full range.
-				 */
-				do {
-					min = 0; max = INT_MAX;
-					value = colon;
-					if (value && *value) {
-						colon = strchr(value, ':');
-						if (colon)
-							*(colon++) = '\0';
-
-						dash = strchr(value, '-');
-						if (dash)
-							*(dash++) = '\0';
-
-						/* support :val: :min-max: :min-: :-max: */
-						if (*value)
-							min = atoi(value);
-						if (!dash)
-							max = min;
-						else if (*dash)
-							max = atoi(dash);
-
-						value = colon;
-					}
-
-					/* now's time to call the test */
-					printf("Running test '%s'\n", test_names[idx].name);
-					err = test_names[idx].func(min, max);
-					ret += err;
-					printf("Errors during this test: %d\n\n", err);
-				} while (colon && *colon);
-			} else
-				printf("Ignoring unknown test name '%s'\n", test);
-
-			test = comma;
-		} while (test && *test);
-	} else {
-		/* no test mentioned, run everything */
-		for (idx = 0; test_names[idx].name; idx++) {
-			printf("Running test '%s'\n", test_names[idx].name);
-			err = test_names[idx].func(min, max);
-			ret += err;
-			printf("Errors during this test: %d\n\n", err);
-		}
-	}
-
-	printf("Total number of errors: %d\n", ret);
-
-	if (getpid() == 1) {
-		/* we're running as init, there's no other process on the
-		 * system, thus likely started from a VM for a quick check.
-		 * Exiting will provoke a kernel panic that may be reported
-		 * as an error by Qemu or the hypervisor, while stopping
-		 * cleanly will often be reported as a success. This allows
-		 * to use the output of this program for bisecting kernels.
-		 */
-		printf("Leaving init with final status: %d\n", !!ret);
-		if (ret == 0)
-			reboot(RB_POWER_OFF);
-#if defined(__x86_64__)
-		/* QEMU started with "-device isa-debug-exit -no-reboot" will
-		 * exit with status code 2N+1 when N is written to 0x501. We
-		 * hard-code the syscall here as it's arch-dependent.
-		 */
-		else if (syscall(__NR_ioperm, 0x501, 1, 1) == 0)
-			__asm__ volatile ("outb %%al, %%dx" :: "d"(0x501), "a"(0));
-		/* if it does nothing, fall back to the regular panic */
-#endif
-	}
-
-	printf("Exiting with status %d\n", !!ret);
-	return !!ret;
-}
+#include "harness-selftest.c"
diff --git a/tools/testing/selftests/nolibc/run-tests.sh b/tools/testing/selftests/nolibc/run-tests.sh
index 0299a0912d4049dd12217f9835b81d231e1d2bfd..9344e3e8e10466dbb04a80028439599bb0cb28a2 100755
--- a/tools/testing/selftests/nolibc/run-tests.sh
+++ b/tools/testing/selftests/nolibc/run-tests.sh
@@ -189,7 +189,7 @@ test_arch() {
 	swallow_output "${MAKE[@]}" defconfig
 	swallow_output "${MAKE[@]}" CFLAGS_EXTRA="$CFLAGS_EXTRA" "$test_target" V=1
 	cp run.out run.out."${arch}"
-	"${MAKE[@]}" report | grep passed
+	"${MAKE[@]}" report
 }
 
 if [ "$perform_download" -ne 0 ]; then

-- 
2.49.0

Re: [PATCH v2 00/32] kselftest harness and nolibc compatibility

[Shuah Khan]

On 4/7/25 00:52, Thomas Weißschuh wrote:
> Nolibc is useful for selftests as the test programs can be very small,
> and compiled with just a kernel crosscompiler, without userspace support.
> Currently nolibc is only usable with kselftest.h, not the more
> convenient to use kselftest_harness.h
> This series provides this compatibility by adding new features to nolibc
> and removing the usage of problematic features from the harness.
> 
> The first half of the series are changes to the harness, the second one
> are for nolibc. Both parts are very independent and should go through
> different trees.
> The last patch is not meant to be applied and serves as test that
> everything works together correctly.
> 
> Signed-off-by: Thomas Weißschuh <thomas.weissschuh@linutronix.de>
> ---
> Changes in v2:
> - Rebase unto v6.15-rc1
> - Rename internal nolibc symbols
> - Handle edge case of waitpid(INT_MIN) == ESRCH
> - Fix arm configurations for final testing patch
> - Clean up global getopt.h variable declarations
> - Add Acks from Willy
> - Link to v1: https://lore.kernel.org/r/20250304-nolibc-kselftest-harness-v1-0-adca7cd231e2@linutronix.de

Thank you. I am going to start reviewing the series. It could take
me a few days to get through all 32 patches. :)

> 
> ---
> Thomas Weißschuh (32):
>        selftests: harness: Add harness selftest
>        selftests: harness: Use C89 comment style
>        selftests: harness: Ignore unused variant argument warning
>        selftests: harness: Mark functions without prototypes static
>        selftests: harness: Remove inline qualifier for wrappers
>        selftests: harness: Remove dependency on libatomic
>        selftests: harness: Implement test timeouts through pidfd
>        selftests: harness: Don't set setup_completed for fixtureless tests
>        selftests: harness: Always provide "self" and "variant"
>        selftests: harness: Move teardown conditional into test metadata
>        selftests: harness: Add teardown callback to test metadata
>        selftests: harness: Stop using setjmp()/longjmp()
>        selftests: harness: Guard includes on nolibc
>        tools/nolibc: handle intmax_t/uintmax_t in printf
>        tools/nolibc: use intmax definitions from compiler
>        tools/nolibc: use pselect6_time64 if available
>        tools/nolibc: use ppoll_time64 if available
>        tools/nolibc: add tolower() and toupper()
>        tools/nolibc: add _exit()
>        tools/nolibc: add setpgrp()
>        tools/nolibc: implement waitpid() in terms of waitid()
>        Revert "selftests/nolibc: use waitid() over waitpid()"
>        tools/nolibc: add dprintf() and vdprintf()
>        tools/nolibc: add getopt()
>        tools/nolibc: allow different write callbacks in printf
>        tools/nolibc: allow limiting of printf destination size
>        tools/nolibc: add snprintf() and friends
>        selftests/nolibc: use snprintf() for printf tests
>        selftests/nolibc: rename vfprintf test suite
>        selftests/nolibc: add test for snprintf() truncation
>        tools/nolibc: implement width padding in printf()
>        HACK: selftests/nolibc: demonstrate usage of the kselftest harness
> 
>   tools/include/nolibc/Makefile                      |    1 +
>   tools/include/nolibc/getopt.h                      |  101 ++
>   tools/include/nolibc/nolibc.h                      |    1 +
>   tools/include/nolibc/stdint.h                      |    4 +-
>   tools/include/nolibc/stdio.h                       |  127 +-
>   tools/include/nolibc/string.h                      |   17 +
>   tools/include/nolibc/sys.h                         |  105 +-
>   tools/testing/selftests/Makefile                   |    1 +
>   tools/testing/selftests/kselftest/.gitignore       |    1 +
>   tools/testing/selftests/kselftest/Makefile         |    6 +
>   .../testing/selftests/kselftest/harness-selftest.c |  129 ++
>   .../selftests/kselftest/harness-selftest.expected  |   62 +
>   .../selftests/kselftest/harness-selftest.sh        |   14 +
>   tools/testing/selftests/kselftest_harness.h        |  181 +-
>   tools/testing/selftests/nolibc/Makefile            |   13 +-
>   tools/testing/selftests/nolibc/harness-selftest.c  |    1 +
>   tools/testing/selftests/nolibc/nolibc-test.c       | 1729 +-------------------
>   tools/testing/selftests/nolibc/run-tests.sh        |    2 +-
>   18 files changed, 635 insertions(+), 1860 deletions(-)
> ---
> base-commit: 0af2f6be1b4281385b618cb86ad946eded089ac8
> change-id: 20250130-nolibc-kselftest-harness-8b2c8cac43bf
> 

thanks,
-- Shuah

Re: [PATCH v2 00/32] kselftest harness and nolibc compatibility

[Shuah Khan]

On 4/10/25 09:19, Shuah Khan wrote:
> On 4/7/25 00:52, Thomas Weißschuh wrote:
>> Nolibc is useful for selftests as the test programs can be very small,
>> and compiled with just a kernel crosscompiler, without userspace support.
>> Currently nolibc is only usable with kselftest.h, not the more
>> convenient to use kselftest_harness.h
>> This series provides this compatibility by adding new features to nolibc
>> and removing the usage of problematic features from the harness.
>>
>> The first half of the series are changes to the harness, the second one
>> are for nolibc. Both parts are very independent and should go through
>> different trees.
>> The last patch is not meant to be applied and serves as test that
>> everything works together correctly.
>>
>> Signed-off-by: Thomas Weißschuh <thomas.weissschuh@linutronix.de>
>> ---
>> Changes in v2:
>> - Rebase unto v6.15-rc1
>> - Rename internal nolibc symbols
>> - Handle edge case of waitpid(INT_MIN) == ESRCH
>> - Fix arm configurations for final testing patch
>> - Clean up global getopt.h variable declarations
>> - Add Acks from Willy
>> - Link to v1: https://lore.kernel.org/r/20250304-nolibc-kselftest-harness-v1-0-adca7cd231e2@linutronix.de
> 
> Thank you. I am going to start reviewing the series. It could take
> me a few days to get through all 32 patches. :)
> 
>>
>> ---
>> Thomas Weißschuh (32):
>>        selftests: harness: Add harness selftest
>>        selftests: harness: Use C89 comment style
>>        selftests: harness: Ignore unused variant argument warning
>>        selftests: harness: Mark functions without prototypes static
>>        selftests: harness: Remove inline qualifier for wrappers
>>        selftests: harness: Remove dependency on libatomic
>>        selftests: harness: Implement test timeouts through pidfd
>>        selftests: harness: Don't set setup_completed for fixtureless tests
>>        selftests: harness: Always provide "self" and "variant"
>>        selftests: harness: Move teardown conditional into test metadata
>>        selftests: harness: Add teardown callback to test metadata
>>        selftests: harness: Stop using setjmp()/longjmp()
>>        selftests: harness: Guard includes on nolibc
>>        tools/nolibc: handle intmax_t/uintmax_t in printf
>>        tools/nolibc: use intmax definitions from compiler
>>        tools/nolibc: use pselect6_time64 if available
>>        tools/nolibc: use ppoll_time64 if available
>>        tools/nolibc: add tolower() and toupper()
>>        tools/nolibc: add _exit()
>>        tools/nolibc: add setpgrp()
>>        tools/nolibc: implement waitpid() in terms of waitid()
>>        Revert "selftests/nolibc: use waitid() over waitpid()"
>>        tools/nolibc: add dprintf() and vdprintf()
>>        tools/nolibc: add getopt()
>>        tools/nolibc: allow different write callbacks in printf
>>        tools/nolibc: allow limiting of printf destination size
>>        tools/nolibc: add snprintf() and friends
>>        selftests/nolibc: use snprintf() for printf tests
>>        selftests/nolibc: rename vfprintf test suite
>>        selftests/nolibc: add test for snprintf() truncation
>>        tools/nolibc: implement width padding in printf()
>>        HACK: selftests/nolibc: demonstrate usage of the kselftest harness
>>
>>   tools/include/nolibc/Makefile                      |    1 +
>>   tools/include/nolibc/getopt.h                      |  101 ++
>>   tools/include/nolibc/nolibc.h                      |    1 +
>>   tools/include/nolibc/stdint.h                      |    4 +-
>>   tools/include/nolibc/stdio.h                       |  127 +-
>>   tools/include/nolibc/string.h                      |   17 +
>>   tools/include/nolibc/sys.h                         |  105 +-
>>   tools/testing/selftests/Makefile                   |    1 +
>>   tools/testing/selftests/kselftest/.gitignore       |    1 +
>>   tools/testing/selftests/kselftest/Makefile         |    6 +
>>   .../testing/selftests/kselftest/harness-selftest.c |  129 ++

One more thing. You are missing kselftest_harness maintainers.
Please send v3 with the changes I requested for test name and
directory, and make cleanup?

The fixes to existing kselftest_harness compile warnings and such
can go in an upcoming rc and the others can go into the next release.

>>   .../selftests/kselftest/harness-selftest.expected  |   62 +
>>   .../selftests/kselftest/harness-selftest.sh        |   14 +
>>   tools/testing/selftests/kselftest_harness.h        |  181 +-
>>   tools/testing/selftests/nolibc/Makefile            |   13 +-
>>   tools/testing/selftests/nolibc/harness-selftest.c  |    1 +
>>   tools/testing/selftests/nolibc/nolibc-test.c       | 1729 +-------------------
>>   tools/testing/selftests/nolibc/run-tests.sh        |    2 +-
>>   18 files changed, 635 insertions(+), 1860 deletions(-)
>> ---
>> base-commit: 0af2f6be1b4281385b618cb86ad946eded089ac8
>> change-id: 20250130-nolibc-kselftest-harness-8b2c8cac43bf
>>
> 

thanks,
-- Shuah