[PATCH RFC 0/4] selftests: harness: Provide global metadata pointer to allow clean teardown from selftest libraries

[PATCH RFC 0/4] selftests: harness: Provide global metadata pointer to allow clean teardown from selftest libraries

[Ackerley Tng]

Hi,

The common kselftest harness provides nice features such as tracking the
number of tests, common pass/fail printouts, and setup/teardown functions.

KVM would like to benefit from the common functionality provided in the
general kselftest harness, but KVM selftests are dependent on a selftest
library.

This selftest library provides common code for setting up virtual machines,
and is designed with assertions within the setup flows to reduce KVM
selftest developer burden of making common assertions.

The common kselftest library assertions (ASSERT_EQ and EXPECT_EQ) are
dependent on access to the _metadata parameter. Any function using the
assertion macros must be parametrized by _metadata.

The KVM selftest library has many nested function calls and it would be
impractical to pass _metadata through all those layers of function calls.

Without _metadata, the KVM selftest library can still reimplement its own
assertion macro (TEST_ASSERT), but it cannot perform teardown on assertion
failure.

Sean suggested using setjmp and longjmp [1] to back to the top level
TEST_F(). I looked at [1] and found myself wishing to use TEST_F() the from
kselftest harness directly. Also, setjmp/longjmp felt like it was
introducing state that could be messed up easily. I also found recent work
that removed setjmp/longjmp from kselftest harness [2].

The kselftests harness is running tests sequentially anyway, and the
function pointers in _metadata wouldn't be changing all that often in most
selftests.

Would maintainers be open to having the kselftest harness expose a pointer
to the metadata globally?

Another option would be to expose the current teardown function pointer
globally instead of the pointer to the entire metadata struct.

kselftest harness macros ASSERT_EQ might also benefit from using the global
pointer instead, which would open the functions up to calls from nested
functions without needing to parametrize those functions with _metadata.

[1] https://lore.kernel.org/all/ZjUwqEXPA5QVItyX@google.com/
[2] https://lore.kernel.org/all/20250610141252-1ee7ae72-dbad-4a80-931c-5b4b14fb07ce@linutronix.de/

Signed-off-by: Ackerley Tng <ackerleytng@google.com>
---
Ackerley Tng (4):
      selftests: harness: Move metadata structs to separate header file
      selftests: harness: Set global current_test_metadata for each test run
      KVM: selftests: Do teardown from kselftest harness if kselftest_harness is used
      HACK: Show that the teardown function is called from KVM selftests

 tools/testing/selftests/kselftest_harness.h        | 51 +++------------------
 .../testing/selftests/kselftest_harness_structs.h  | 53 ++++++++++++++++++++++
 tools/testing/selftests/kvm/Makefile.kvm           |  1 +
 .../selftests/kvm/kvm_test_harness_selftest.c      | 34 ++++++++++++++
 tools/testing/selftests/kvm/lib/assert.c           | 16 +++++++
 5 files changed, 110 insertions(+), 45 deletions(-)
---
base-commit: 5d0d3623303775d750e122a2542d1a26c8573d38
change-id: 20260414-selftest-global-metadata-7b1f04a405f3

Best regards,
--
Ackerley Tng <ackerleytng@google.com>

[PATCH RFC 1/4] selftests: harness: Move metadata structs to separate header file

[Ackerley Tng]

Move metadata structs to separate header file so that the structs can be
referenced without importing all the static functions, such as
test_harness_run.

Signed-off-by: Ackerley Tng <ackerleytng@google.com>
---
 tools/testing/selftests/kselftest_harness.h        | 47 +------------------
 .../testing/selftests/kselftest_harness_structs.h  | 53 ++++++++++++++++++++++
 2 files changed, 55 insertions(+), 45 deletions(-)

diff --git a/tools/testing/selftests/kselftest_harness.h b/tools/testing/selftests/kselftest_harness.h
index 4afaef01c22e9..68cde1556ac41 100644
--- a/tools/testing/selftests/kselftest_harness.h
+++ b/tools/testing/selftests/kselftest_harness.h
@@ -68,6 +68,7 @@
 #include <sys/wait.h>
 #include <unistd.h>
 
+#include "kselftest_harness_structs.h"
 #include "kselftest.h"
 
 static inline void __kselftest_memset_safe(void *s, int c, size_t n)
@@ -845,27 +846,11 @@ struct __test_results {
 	char reason[1024];	/* Reason for test result */
 };
 
-struct __test_metadata;
-struct __fixture_variant_metadata;
-
-/* Contains all the information about a fixture. */
-struct __fixture_metadata {
-	const char *name;
-	struct __test_metadata *tests;
-	struct __fixture_variant_metadata *variant;
-	struct __fixture_metadata *prev, *next;
-} _fixture_global __attribute__((unused)) = {
+struct __fixture_metadata _fixture_global __attribute__((unused)) = {
 	.name = "global",
 	.prev = &_fixture_global,
 };
 
-struct __test_xfail {
-	struct __fixture_metadata *fixture;
-	struct __fixture_variant_metadata *variant;
-	struct __test_metadata *test;
-	struct __test_xfail *prev, *next;
-};
-
 /**
  * XFAIL_ADD() - mark variant + test case combination as expected to fail
  * @fixture_name: name of the fixture
@@ -899,13 +884,6 @@ static inline void __register_fixture(struct __fixture_metadata *f)
 	__LIST_APPEND(__fixture_list, f);
 }
 
-struct __fixture_variant_metadata {
-	const char *name;
-	const void *data;
-	struct __test_xfail *xfails;
-	struct __fixture_variant_metadata *prev, *next;
-};
-
 static inline void
 __register_fixture_variant(struct __fixture_metadata *f,
 			   struct __fixture_variant_metadata *variant)
@@ -913,27 +891,6 @@ __register_fixture_variant(struct __fixture_metadata *f,
 	__LIST_APPEND(f->variant, variant);
 }
 
-/* Contains all the information for test execution and status checking. */
-struct __test_metadata {
-	const char *name;
-	void (*fn)(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 */
-	int timeout;	/* seconds to wait for test timeout */
-	bool aborted;	/* stopped test due to failed ASSERT */
-	bool *no_teardown; /* fixture needs teardown */
-	void *self;
-	const void *variant;
-	struct __test_results *results;
-	struct __test_metadata *prev, *next;
-};
-
 static inline bool __test_passed(struct __test_metadata *metadata)
 {
 	return metadata->exit_code != KSFT_FAIL &&
diff --git a/tools/testing/selftests/kselftest_harness_structs.h b/tools/testing/selftests/kselftest_harness_structs.h
new file mode 100644
index 0000000000000..cf9d15ad3de0c
--- /dev/null
+++ b/tools/testing/selftests/kselftest_harness_structs.h
@@ -0,0 +1,53 @@
+#ifndef __KSELFTEST_HARNESS_STRUCTS_H
+#define __KSELFTEST_HARNESS_STRUCTS_H
+
+#include <stdbool.h>
+#include <sys/types.h>
+
+struct __test_metadata;
+struct __fixture_variant_metadata;
+
+/* Contains all the information about a fixture. */
+struct __fixture_metadata {
+	const char *name;
+	struct __test_metadata *tests;
+	struct __fixture_variant_metadata *variant;
+	struct __fixture_metadata *prev, *next;
+};
+
+struct __test_xfail {
+	struct __fixture_metadata *fixture;
+	struct __fixture_variant_metadata *variant;
+	struct __test_metadata *test;
+	struct __test_xfail *prev, *next;
+};
+
+struct __fixture_variant_metadata {
+	const char *name;
+	const void *data;
+	struct __test_xfail *xfails;
+	struct __fixture_variant_metadata *prev, *next;
+};
+
+/* Contains all the information for test execution and status checking. */
+struct __test_metadata {
+	const char *name;
+	void (*fn)(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 */
+	int timeout;	/* seconds to wait for test timeout */
+	bool aborted;	/* stopped test due to failed ASSERT */
+	bool *no_teardown; /* fixture needs teardown */
+	void *self;
+	const void *variant;
+	struct __test_results *results;
+	struct __test_metadata *prev, *next;
+};
+
+#endif

-- 
2.54.0.rc0.605.g598a273b03-goog

[PATCH RFC 2/4] selftests: harness: Set global current_test_metadata for each test run

[Ackerley Tng]

Set global current_test_metadata for each test run so other test frameworks
can choose to access fields for the current test.

This avoids having to pass _metadata down through functions so that
code defined other functions can still use fields in _metadata.

Test functions t->fn() are executed in series, so during the runtime of the
test function, the function can count on current_test_metadata accurately
being the metadata for the running test.

Signed-off-by: Ackerley Tng <ackerleytng@google.com>
---
 tools/testing/selftests/kselftest_harness.h | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/tools/testing/selftests/kselftest_harness.h b/tools/testing/selftests/kselftest_harness.h
index 68cde1556ac41..85d9b4527fca6 100644
--- a/tools/testing/selftests/kselftest_harness.h
+++ b/tools/testing/selftests/kselftest_harness.h
@@ -1151,6 +1151,8 @@ static bool test_enabled(int argc, char **argv,
 	return !has_positive;
 }
 
+struct __test_metadata *current_test_metadata;
+
 static void __run_test(struct __fixture_metadata *f,
 		       struct __fixture_variant_metadata *variant,
 		       struct __test_metadata *t)
@@ -1182,7 +1184,9 @@ static void __run_test(struct __fixture_metadata *f,
 		t->exit_code = KSFT_FAIL;
 	} else if (child == 0) {
 		setpgrp();
+		current_test_metadata = t;
 		t->fn(t, variant);
+		current_test_metadata = NULL;
 		_exit(t->exit_code);
 	} else {
 		t->pid = child;

-- 
2.54.0.rc0.605.g598a273b03-goog

[PATCH RFC 3/4] KVM: selftests: Do teardown from kselftest harness if kselftest_harness is used

[Ackerley Tng]

If kselftest_harness is used, when an KVM selftest assertion fails, make
sure to perform teardown (like kselftest_harness) before exiting.

Provide a weak struct definition and default the pointer's value to NULL so
KVM selftests that don't use kselftest_harness will still work as before.

Signed-off-by: Ackerley Tng <ackerleytng@google.com>
---
 tools/testing/selftests/kvm/lib/assert.c | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

diff --git a/tools/testing/selftests/kvm/lib/assert.c b/tools/testing/selftests/kvm/lib/assert.c
index b49690658c606..06970611317fd 100644
--- a/tools/testing/selftests/kvm/lib/assert.c
+++ b/tools/testing/selftests/kvm/lib/assert.c
@@ -9,6 +9,7 @@
 #include <execinfo.h>
 #include <sys/syscall.h>
 
+#include "kselftest_harness_structs.h"
 #include "kselftest.h"
 
 /* Dumps the current stack trace to stderr. */
@@ -63,6 +64,8 @@ static pid_t _gettid(void)
 	return syscall(SYS_gettid);
 }
 
+struct __test_metadata *current_test_metadata __attribute__((weak)) = NULL;
+
 void __attribute__((noinline))
 test_assert(bool exp, const char *exp_str,
 	const char *file, unsigned int line, const char *fmt, ...)
@@ -89,6 +92,19 @@ test_assert(bool exp, const char *exp_str,
 			print_skip("Access denied - Exiting");
 			exit(KSFT_SKIP);
 		}
+
+		/*
+		 * When used with kselftest_harness, do teardown like
+		 * __bail() does. KVM only has TEST_ASSERT (no EXPECT
+		 * equivalent) and will definitely exit.
+		 */
+		if (current_test_metadata) {
+			struct __test_metadata *t = current_test_metadata;
+
+			if (t->teardown_fn)
+				t->teardown_fn(false, t, t->self, t->variant);
+		}
+
 		exit(254);
 	}
 

-- 
2.54.0.rc0.605.g598a273b03-goog

[PATCH RFC 4/4] HACK: Show that the teardown function is called from KVM selftests

[Ackerley Tng]

Running the selftest tools/testing/selftests/kvm/kvm_test_harness_selftest
gets me this:

$ tools/testing/selftests/kvm/kvm_test_harness_selftest
Random seed: 0x6b8b4567
TAP version 13
1..2
setup
teardown
ok 1 my_fixture.my_test_pass
setup
==== Test Assertion Failure ====
  kvm_test_harness_selftest.c:28: false
  pid=73044 tid=73044 errno=0 - Success
     1  0x0000000000402c04: my_fixture_my_test_assert at kvm_test_harness_selftest.c:28
     2   (inlined by) wrapper_my_fixture_my_test_assert at kvm_test_harness_selftest.c:26
     3  0x0000000000403497: __run_test at kselftest_harness.h:1185
     4  0x0000000000402340: test_harness_run at kselftest_harness.h:1256
     5   (inlined by) main at kvm_test_harness_selftest.c:33
     6  0x000000000041ef10: __libc_start_call_main at libc-start.o:?
     7  0x000000000042108c: __libc_start_main_impl at ??:?
     8  0x00000000004026e0: _start at ??:?
  foobar
teardown
not ok 2 my_fixture.my_test_assert

Signed-off-by: Ackerley Tng <ackerleytng@google.com>
---
 tools/testing/selftests/kvm/Makefile.kvm           |  1 +
 .../selftests/kvm/kvm_test_harness_selftest.c      | 34 ++++++++++++++++++++++
 2 files changed, 35 insertions(+)

diff --git a/tools/testing/selftests/kvm/Makefile.kvm b/tools/testing/selftests/kvm/Makefile.kvm
index 6471fa214a9f9..d32045f7d9396 100644
--- a/tools/testing/selftests/kvm/Makefile.kvm
+++ b/tools/testing/selftests/kvm/Makefile.kvm
@@ -64,6 +64,7 @@ TEST_GEN_PROGS_COMMON += kvm_binary_stats_test
 TEST_GEN_PROGS_COMMON += kvm_create_max_vcpus
 TEST_GEN_PROGS_COMMON += kvm_page_table_test
 TEST_GEN_PROGS_COMMON += set_memory_region_test
+TEST_GEN_PROGS_COMMON += kvm_test_harness_selftest
 
 # Compiled test targets
 TEST_GEN_PROGS_x86 = $(TEST_GEN_PROGS_COMMON)
diff --git a/tools/testing/selftests/kvm/kvm_test_harness_selftest.c b/tools/testing/selftests/kvm/kvm_test_harness_selftest.c
new file mode 100644
index 0000000000000..36ce14226fdb7
--- /dev/null
+++ b/tools/testing/selftests/kvm/kvm_test_harness_selftest.c
@@ -0,0 +1,34 @@
+#include <stdio.h>
+
+#include "kselftest_harness.h"
+#include "test_util.h"
+
+FIXTURE(my_fixture)
+{
+
+};
+
+FIXTURE_SETUP(my_fixture)
+{
+	pr_info("setup\n");
+}
+
+FIXTURE_TEARDOWN(my_fixture)
+{
+	pr_info("teardown\n");
+}
+
+TEST_F(my_fixture, my_test_pass)
+{
+	TEST_ASSERT(true, "foobar");
+}
+
+TEST_F(my_fixture, my_test_assert)
+{
+	TEST_ASSERT(false, "foobar");
+}
+
+int main(int argc, char **argv)
+{
+	return test_harness_run(argc, argv);
+}

-- 
2.54.0.rc0.605.g598a273b03-goog

Re: [PATCH RFC 0/4] selftests: harness: Provide global metadata pointer to allow clean teardown from selftest libraries

[Sean Christopherson]

On Tue, Apr 14, 2026, Ackerley Tng wrote:
> Sean suggested using setjmp and longjmp [1] to back to the top level
> TEST_F(). I looked at [1] and found myself wishing to use TEST_F() the from
> kselftest harness directly.

Can you elaborate?  If you have a need for direct TEST_F() in KVM selftests, odds
are good someone/something else will have a similar need, sooner or later.

> Also, setjmp/longjmp felt like it was introducing state that could be messed
> up easily.

Meh, same goes for the kselftests_harness.h.  I can point you at a half dozen
bugs where enhancements to the core framework wreaked havoc for unsuspecting
subsystems.  I'm not trying to throw shade at the harness; there's a _lot_ of
goodness in there.  My point is that doing complex things that impact a huge
variety of downstream users is going to have many sharp edges, regardless of
where the complexity resides.

I'm not wedded to setjmp/longjmp by any means, but for me this isn't a compelling
argument against the approach. 

> I also found recent work that removed setjmp/longjmp from kselftest harness
> [2].

KVM selftests don't support building with nolibc.

> The kselftests harness is running tests sequentially anyway, and the
> function pointers in _metadata wouldn't be changing all that often in most
> selftests.
> 
> Would maintainers be open to having the kselftest harness expose a pointer
> to the metadata globally?
>
> Another option would be to expose the current teardown function pointer
> globally instead of the pointer to the entire metadata struct.

I'm strongly opposed to any idea effectively requires special casing KVM selftests
in the common harness.  In my experience, the common harness is already quite
brittle, in large part because there is no singular maintainer(s) that is responsible
for ensuring changes work for all downstream users.  Adding odd bits of code that
is only ever used by a handful of KVM selftests is only going to increase the
probability that that code is broken.

Re: [PATCH RFC 0/4] selftests: harness: Provide global metadata pointer to allow clean teardown from selftest libraries

[Kees Cook]

On Tue, Apr 14, 2026 at 11:07:47AM -0700, Ackerley Tng wrote:
> Would maintainers be open to having the kselftest harness expose a pointer
> to the metadata globally?

I would like this, yes. It's been a real pain sometimes having to pass
_metadata down into various deep helper functions.

-- 
Kees Cook