[PATCH v7 17/23] sched: Initial sched_football test implementation

[John Stultz <jstultz@google.com>]

Reimplementation of the sched_football test from LTP:
https://github.com/linux-test-project/ltp/blob/master/testcases/realtime/func/sched_football/sched_football.c

But reworked to run in the kernel and utilize mutexes
to illustrate proper boosting of low priority mutex
holders.

TODO:
* Need a rt_mutex version so it can work w/o proxy-execution
* Need a better place to put it

Cc: Joel Fernandes <joelaf@google.com>
Cc: Qais Yousef <qyousef@google.com>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Juri Lelli <juri.lelli@redhat.com>
Cc: Vincent Guittot <vincent.guittot@linaro.org>
Cc: Dietmar Eggemann <dietmar.eggemann@arm.com>
Cc: Valentin Schneider <vschneid@redhat.com>
Cc: Steven Rostedt <rostedt@goodmis.org>
Cc: Ben Segall <bsegall@google.com>
Cc: Zimuzo Ezeozue <zezeozue@google.com>
Cc: Youssef Esmat <youssefesmat@google.com>
Cc: Mel Gorman <mgorman@suse.de>
Cc: Daniel Bristot de Oliveira <bristot@redhat.com>
Cc: Will Deacon <will@kernel.org>
Cc: Waiman Long <longman@redhat.com>
Cc: Boqun Feng <boqun.feng@gmail.com>
Cc: "Paul E. McKenney" <paulmck@kernel.org>
Cc: Metin Kaya <Metin.Kaya@arm.com>
Cc: Xuewen Yan <xuewen.yan94@gmail.com>
Cc: K Prateek Nayak <kprateek.nayak@amd.com>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: kernel-team@android.com
Signed-off-by: John Stultz <jstultz@google.com>
---
 kernel/sched/Makefile              |   1 +
 kernel/sched/test_sched_football.c | 242 +++++++++++++++++++++++++++++
 lib/Kconfig.debug                  |  14 ++
 3 files changed, 257 insertions(+)
 create mode 100644 kernel/sched/test_sched_football.c

diff --git a/kernel/sched/Makefile b/kernel/sched/Makefile
index 976092b7bd45..2729d565dfd7 100644
--- a/kernel/sched/Makefile
+++ b/kernel/sched/Makefile
@@ -32,3 +32,4 @@ obj-y += core.o
 obj-y += fair.o
 obj-y += build_policy.o
 obj-y += build_utility.o
+obj-$(CONFIG_SCHED_RT_INVARIENT_TEST) += test_sched_football.o
diff --git a/kernel/sched/test_sched_football.c b/kernel/sched/test_sched_football.c
new file mode 100644
index 000000000000..9742c45c0fe0
--- /dev/null
+++ b/kernel/sched/test_sched_football.c
@@ -0,0 +1,242 @@
+// SPDX-License-Identifier: GPL-2.0+
+/*
+ * Module-based test case for RT scheduling invariant
+ *
+ * A reimplementation of my old sched_football test
+ * found in LTP:
+ *   https://github.com/linux-test-project/ltp/blob/master/testcases/realtime/func/sched_football/sched_football.c
+ *
+ * Similar to that test, this tries to validate the RT
+ * scheduling invariant, that the across N available cpus, the
+ * top N priority tasks always running.
+ *
+ * This is done via having N offsensive players that are
+ * medium priority, which constantly are trying to increment the
+ * ball_pos counter.
+ *
+ * Blocking this, are N defensive players that are higher
+ * priority which just spin on the cpu, preventing the medium
+ * priroity tasks from running.
+ *
+ * To complicate this, there are also N defensive low priority
+ * tasks. These start first and each aquire one of N mutexes.
+ * The high priority defense tasks will later try to grab the
+ * mutexes and block, opening a window for the offsensive tasks
+ * to run and increment the ball. If priority inheritance or
+ * proxy execution is used, the low priority defense players
+ * should be boosted to the high priority levels, and will
+ * prevent the mid priority offensive tasks from running.
+ *
+ * Copyright © International Business Machines  Corp., 2007, 2008
+ * Copyright (C) Google, 2023
+ *
+ * Authors: John Stultz <jstultz@google.com>
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/kthread.h>
+#include <linux/delay.h>
+#include <linux/sched/rt.h>
+#include <linux/spinlock.h>
+#include <linux/mutex.h>
+#include <linux/rwsem.h>
+#include <linux/smp.h>
+#include <linux/slab.h>
+#include <linux/interrupt.h>
+#include <linux/sched.h>
+#include <uapi/linux/sched/types.h>
+#include <linux/rtmutex.h>
+
+atomic_t players_ready;
+atomic_t ball_pos;
+int players_per_team;
+bool game_over;
+
+struct mutex *mutex_low_list;
+struct mutex *mutex_mid_list;
+
+static inline
+struct task_struct *create_fifo_thread(int (*threadfn)(void *data), void *data,
+				       char *name, int prio)
+{
+	struct task_struct *kth;
+	struct sched_attr attr = {
+		.size		= sizeof(struct sched_attr),
+		.sched_policy	= SCHED_FIFO,
+		.sched_nice	= 0,
+		.sched_priority	= prio,
+	};
+	int ret;
+
+	kth = kthread_create(threadfn, data, name);
+	if (IS_ERR(kth)) {
+		pr_warn("%s eerr, kthread_create failed\n", __func__);
+		return kth;
+	}
+	ret = sched_setattr_nocheck(kth, &attr);
+	if (ret) {
+		kthread_stop(kth);
+		pr_warn("%s: failed to set SCHED_FIFO\n", __func__);
+		return ERR_PTR(ret);
+	}
+
+	wake_up_process(kth);
+	return kth;
+}
+
+int defense_low_thread(void *arg)
+{
+	long tnum = (long)arg;
+
+	atomic_inc(&players_ready);
+	mutex_lock(&mutex_low_list[tnum]);
+	while (!READ_ONCE(game_over)) {
+		if (kthread_should_stop())
+			break;
+		schedule();
+	}
+	mutex_unlock(&mutex_low_list[tnum]);
+	return 0;
+}
+
+int defense_mid_thread(void *arg)
+{
+	long tnum = (long)arg;
+
+	atomic_inc(&players_ready);
+	mutex_lock(&mutex_mid_list[tnum]);
+	mutex_lock(&mutex_low_list[tnum]);
+	while (!READ_ONCE(game_over)) {
+		if (kthread_should_stop())
+			break;
+		schedule();
+	}
+	mutex_unlock(&mutex_low_list[tnum]);
+	mutex_unlock(&mutex_mid_list[tnum]);
+	return 0;
+}
+
+int offense_thread(void *)
+{
+	atomic_inc(&players_ready);
+	while (!READ_ONCE(game_over)) {
+		if (kthread_should_stop())
+			break;
+		schedule();
+		atomic_inc(&ball_pos);
+	}
+	return 0;
+}
+
+int defense_hi_thread(void *arg)
+{
+	long tnum = (long)arg;
+
+	atomic_inc(&players_ready);
+	mutex_lock(&mutex_mid_list[tnum]);
+	while (!READ_ONCE(game_over)) {
+		if (kthread_should_stop())
+			break;
+		schedule();
+	}
+	mutex_unlock(&mutex_mid_list[tnum]);
+	return 0;
+}
+
+int crazy_fan_thread(void *)
+{
+	int count = 0;
+
+	atomic_inc(&players_ready);
+	while (!READ_ONCE(game_over)) {
+		if (kthread_should_stop())
+			break;
+		schedule();
+		udelay(1000);
+		msleep(2);
+		count++;
+	}
+	return 0;
+}
+
+int ref_thread(void *arg)
+{
+	struct task_struct *kth;
+	long game_time = (long)arg;
+	unsigned long final_pos;
+	long i;
+
+	pr_info("%s: started ref, game_time: %ld secs !\n", __func__,
+		game_time);
+
+	/* Create low  priority defensive team */
+	for (i = 0; i < players_per_team; i++)
+		kth = create_fifo_thread(defense_low_thread, (void *)i,
+					 "defese-low-thread", 2);
+	/* Wait for the defense threads to start */
+	while (atomic_read(&players_ready) < players_per_team)
+		msleep(1);
+
+	for (i = 0; i < players_per_team; i++)
+		kth = create_fifo_thread(defense_mid_thread,
+					 (void *)(players_per_team - i - 1),
+					 "defese-mid-thread", 3);
+	/* Wait for the defense threads to start */
+	while (atomic_read(&players_ready) < players_per_team * 2)
+		msleep(1);
+
+	/* Create mid priority offensive team */
+	for (i = 0; i < players_per_team; i++)
+		kth = create_fifo_thread(offense_thread, NULL,
+					 "offense-thread", 5);
+	/* Wait for the offense threads to start */
+	while (atomic_read(&players_ready) < players_per_team * 3)
+		msleep(1);
+
+	/* Create high priority defensive team */
+	for (i = 0; i < players_per_team; i++)
+		kth = create_fifo_thread(defense_hi_thread, (void *)i,
+					 "defese-hi-thread", 10);
+	/* Wait for the defense threads to start */
+	while (atomic_read(&players_ready) < players_per_team * 4)
+		msleep(1);
+
+	/* Create high priority defensive team */
+	for (i = 0; i < players_per_team; i++)
+		kth = create_fifo_thread(crazy_fan_thread, NULL,
+					 "crazy-fan-thread", 15);
+	/* Wait for the defense threads to start */
+	while (atomic_read(&players_ready) < players_per_team * 5)
+		msleep(1);
+
+	pr_info("%s: all players checked in! Starting game.\n", __func__);
+	atomic_set(&ball_pos, 0);
+	msleep(game_time * 1000);
+	final_pos = atomic_read(&ball_pos);
+	pr_info("%s: final ball_pos: %ld\n", __func__, final_pos);
+	WARN_ON(final_pos != 0);
+	game_over = true;
+	return 0;
+}
+
+static int __init test_sched_football_init(void)
+{
+	struct task_struct *kth;
+	int i;
+
+	players_per_team = num_online_cpus();
+
+	mutex_low_list = kmalloc_array(players_per_team,  sizeof(struct mutex), GFP_ATOMIC);
+	mutex_mid_list = kmalloc_array(players_per_team,  sizeof(struct mutex), GFP_ATOMIC);
+
+	for (i = 0; i < players_per_team; i++) {
+		mutex_init(&mutex_low_list[i]);
+		mutex_init(&mutex_mid_list[i]);
+	}
+
+	kth = create_fifo_thread(ref_thread, (void *)10, "ref-thread", 20);
+
+	return 0;
+}
+module_init(test_sched_football_init);
diff --git a/lib/Kconfig.debug b/lib/Kconfig.debug
index 4405f81248fb..1d90059d190f 100644
--- a/lib/Kconfig.debug
+++ b/lib/Kconfig.debug
@@ -1238,6 +1238,20 @@ config SCHED_DEBUG
 	  that can help debug the scheduler. The runtime overhead of this
 	  option is minimal.
 
+config SCHED_RT_INVARIENT_TEST
+	tristate "RT invarient scheduling tester"
+	depends on DEBUG_KERNEL
+	help
+	  This option provides a kernel module that runs tests to make
+	  sure the RT invarient holds (top N priority tasks run on N
+	  available cpus).
+
+	  Say Y here if you want kernel rt scheduling tests
+	  to be built into the kernel.
+	  Say M if you want this test to build as a module.
+	  Say N if you are unsure.
+
+
 config SCHED_INFO
 	bool
 	default n
-- 
2.43.0.472.g3155946c3a-goog