[PATCH v2 6/6] selftests/sched_ext: Report reload_loop attach failures

[Tao Cui <cui.tao@linux.dev>]

From: Tao Cui <cuitao@kylinos.cn>

reload_loop skips bpf_map__attach_struct_ops() failures silently:
measured on a loaded host, 1125-1233 of 2048 iterations failed, all
with EBUSY (the single scheduler slot changing hands between the two
threads) - the test passed while roughly half of its iterations never
ran.

Count the failures per thread, recording any errno other than EBUSY
separately. Fail the test on an unexpected errno or when a thread
failed every attach; a thread that completed at least one attach has
exercised the reload path, so ordinary EBUSY no longer prints on
every run. The iteration and thread counts move from #defines to an
enum, and two stray blank lines after setup() are dropped.

Signed-off-by: Tao Cui <cuitao@kylinos.cn>
---
 .../testing/selftests/sched_ext/reload_loop.c | 43 ++++++++++++++++---
 1 file changed, 36 insertions(+), 7 deletions(-)

diff --git a/tools/testing/selftests/sched_ext/reload_loop.c b/tools/testing/selftests/sched_ext/reload_loop.c
index a00f3964dba0..7d8880fa1a03 100644
--- a/tools/testing/selftests/sched_ext/reload_loop.c
+++ b/tools/testing/selftests/sched_ext/reload_loop.c
@@ -4,6 +4,7 @@
  * Copyright (c) 2024 David Vernet <dvernet@meta.com>
  */
 #include <bpf/bpf.h>
+#include <errno.h>
 #include <pthread.h>
 #include <scx/common.h>
 #include <sys/wait.h>
@@ -11,8 +12,14 @@
 #include "maximal.bpf.skel.h"
 #include "scx_test.h"
 
+enum {
+	RELOAD_ITERS	= 1024,
+	RELOAD_THREADS	= 2,
+};
+
 static struct maximal *skel;
-static pthread_t threads[2];
+static pthread_t threads[RELOAD_THREADS];
+static int unexpected_errno;
 
 bool force_exit = false;
 
@@ -31,22 +38,33 @@ static enum scx_test_status setup(void **ctx)
 
 static void *do_reload_loop(void *arg)
 {
-	u32 i;
+	u32 i, failures = 0;
 
-	for (i = 0; i < 1024 && !force_exit; i++) {
+	for (i = 0; i < RELOAD_ITERS && !force_exit; i++) {
 		struct bpf_link *link;
 
+		errno = 0;
 		link = bpf_map__attach_struct_ops(skel->maps.maximal_ops);
-		if (link)
-			bpf_link__destroy(link);
+		if (!link) {
+			int e = errno;
+
+			if (e != EBUSY)
+				__atomic_store_n(&unexpected_errno, e,
+						 __ATOMIC_RELAXED);
+			failures++;
+			continue;
+		}
+
+		bpf_link__destroy(link);
 	}
 
-	return NULL;
+	return (void *)(unsigned long)failures;
 }
 
 static enum scx_test_status run(void *ctx)
 {
-	int err;
+	unsigned long failures[RELOAD_THREADS] = {};
+	int err, i;
 	void *ret;
 
 	err = pthread_create(&threads[0], NULL, do_reload_loop, NULL);
@@ -60,7 +78,18 @@ static enum scx_test_status run(void *ctx)
 	}
 
 	SCX_FAIL_IF(pthread_join(threads[0], &ret), "thread 0 failed");
+	failures[0] = (unsigned long)ret;
+
 	SCX_FAIL_IF(pthread_join(threads[1], &ret), "thread 1 failed");
+	failures[1] = (unsigned long)ret;
+
+	SCX_FAIL_IF(unexpected_errno, "unexpected attach errno %d",
+		    unexpected_errno);
+
+	for (i = 0; i < RELOAD_THREADS; i++)
+		SCX_FAIL_IF(failures[i] == RELOAD_ITERS,
+			    "thread %d: every attach failed (%lu EBUSY)",
+			    i, failures[i]);
 
 	return SCX_TEST_PASS;
 }
-- 
2.53.0