Message-ID: <159557963214.4006.16818994245868035978.tip-bot2@tip-bot2>
Date:   Fri, 24 Jul 2020 08:33:52 -0000
From:   "tip-bot2 for Peter Zijlstra" <tip-bot2@...utronix.de>
To:     linux-tip-commits@...r.kernel.org
Cc:     airlied@...hat.com, alexander.deucher@....com,
        awalls@...metrocast.net, axboe@...nel.dk, broonie@...nel.org,
        daniel.lezcano@...aro.org, gregkh@...uxfoundation.org,
        hannes@...xchg.org, herbert@...dor.apana.org.au,
        hverkuil@...all.nl, john.stultz@...aro.org, nico@...xnic.net,
        paulmck@...nel.org, rafael.j.wysocki@...el.com,
        rmk+kernel@....linux.org.uk, sudeep.holla@....com,
        tglx@...utronix.de, ulf.hansson@...aro.org, wim@...ux-watchdog.org,
        "Peter Zijlstra (Intel)" <peterz@...radead.org>,
        Ingo Molnar <mingo@...nel.org>, x86 <x86@...nel.org>,
        LKML <linux-kernel@...r.kernel.org>
Subject: [tip: sched/fifo] sched: Provide sched_set_fifo()

The following commit has been merged into the sched/fifo branch of tip:

Commit-ID:     7318d4cc14c8c8a5dde2b0b72ea50fd2545f0b7a
Gitweb:        https://git.kernel.org/tip/7318d4cc14c8c8a5dde2b0b72ea50fd2545f0b7a
Author:        Peter Zijlstra <peterz@...radead.org>
AuthorDate:    Tue, 21 Apr 2020 12:09:13 +02:00
Committer:     Peter Zijlstra <peterz@...radead.org>
CommitterDate: Mon, 15 Jun 2020 14:10:20 +02:00

sched: Provide sched_set_fifo()

SCHED_FIFO (or any static priority scheduler) is a broken scheduler
model; it is fundamentally incapable of resource management, the one
thing an OS is actually supposed to do.

It is impossible to compose static priority workloads. One cannot take
two well designed and functional static priority workloads and mash
them together and still expect them to work.

Therefore it doesn't make sense to expose the priority field; the
kernel is fundamentally incapable of setting a sensible value, it
needs systems knowledge that it doesn't have.

Take away sched_setschedule() / sched_setattr() from modules and
replace them with:

  - sched_set_fifo(p); create a FIFO task (at prio 50)
  - sched_set_fifo_low(p); create a task higher than NORMAL,
	which ends up being a FIFO task at prio 1.
  - sched_set_normal(p, nice); (re)set the task to normal

This stops the proliferation of randomly chosen, and irrelevant, FIFO
priorities that dont't really mean anything anyway.

The system administrator/integrator, whoever has insight into the
actual system design and requirements (userspace) can set-up
appropriate priorities if and when needed.

Cc: airlied@...hat.com
Cc: alexander.deucher@....com
Cc: awalls@...metrocast.net
Cc: axboe@...nel.dk
Cc: broonie@...nel.org
Cc: daniel.lezcano@...aro.org
Cc: gregkh@...uxfoundation.org
Cc: hannes@...xchg.org
Cc: herbert@...dor.apana.org.au
Cc: hverkuil@...all.nl
Cc: john.stultz@...aro.org
Cc: nico@...xnic.net
Cc: paulmck@...nel.org
Cc: rafael.j.wysocki@...el.com
Cc: rmk+kernel@....linux.org.uk
Cc: sudeep.holla@....com
Cc: tglx@...utronix.de
Cc: ulf.hansson@...aro.org
Cc: wim@...ux-watchdog.org
Signed-off-by: Peter Zijlstra (Intel) <peterz@...radead.org>
Reviewed-by: Ingo Molnar <mingo@...nel.org>
Tested-by: Paul E. McKenney <paulmck@...nel.org>
---
 include/linux/sched.h |  3 +++-
 kernel/sched/core.c   | 47 ++++++++++++++++++++++++++++++++++++++++++-
 2 files changed, 50 insertions(+)

diff --git a/include/linux/sched.h b/include/linux/sched.h
index b62e6aa..b792b8f 100644
--- a/include/linux/sched.h
+++ b/include/linux/sched.h
@@ -1653,6 +1653,9 @@ extern int idle_cpu(int cpu);
 extern int available_idle_cpu(int cpu);
 extern int sched_setscheduler(struct task_struct *, int, const struct sched_param *);
 extern int sched_setscheduler_nocheck(struct task_struct *, int, const struct sched_param *);
+extern int sched_set_fifo(struct task_struct *p);
+extern int sched_set_fifo_low(struct task_struct *p);
+extern int sched_set_normal(struct task_struct *p, int nice);
 extern int sched_setattr(struct task_struct *, const struct sched_attr *);
 extern int sched_setattr_nocheck(struct task_struct *, const struct sched_attr *);
 extern struct task_struct *idle_task(int cpu);
diff --git a/kernel/sched/core.c b/kernel/sched/core.c
index 0208b71..40d3939 100644
--- a/kernel/sched/core.c
+++ b/kernel/sched/core.c
@@ -5124,6 +5124,8 @@ static int _sched_setscheduler(struct task_struct *p, int policy,
  * @policy: new policy.
  * @param: structure containing the new RT priority.
  *
+ * Use sched_set_fifo(), read its comment.
+ *
  * Return: 0 on success. An error code otherwise.
  *
  * NOTE that the task may be already dead.
@@ -5166,6 +5168,51 @@ int sched_setscheduler_nocheck(struct task_struct *p, int policy,
 }
 EXPORT_SYMBOL_GPL(sched_setscheduler_nocheck);
 
+/*
+ * SCHED_FIFO is a broken scheduler model; that is, it is fundamentally
+ * incapable of resource management, which is the one thing an OS really should
+ * be doing.
+ *
+ * This is of course the reason it is limited to privileged users only.
+ *
+ * Worse still; it is fundamentally impossible to compose static priority
+ * workloads. You cannot take two correctly working static prio workloads
+ * and smash them together and still expect them to work.
+ *
+ * For this reason 'all' FIFO tasks the kernel creates are basically at:
+ *
+ *   MAX_RT_PRIO / 2
+ *
+ * The administrator _MUST_ configure the system, the kernel simply doesn't
+ * know enough information to make a sensible choice.
+ */
+int sched_set_fifo(struct task_struct *p)
+{
+	struct sched_param sp = { .sched_priority = MAX_RT_PRIO / 2 };
+	return sched_setscheduler_nocheck(p, SCHED_FIFO, &sp);
+}
+EXPORT_SYMBOL_GPL(sched_set_fifo);
+
+/*
+ * For when you don't much care about FIFO, but want to be above SCHED_NORMAL.
+ */
+int sched_set_fifo_low(struct task_struct *p)
+{
+	struct sched_param sp = { .sched_priority = 1 };
+	return sched_setscheduler_nocheck(p, SCHED_FIFO, &sp);
+}
+EXPORT_SYMBOL_GPL(sched_set_fifo_low);
+
+int sched_set_normal(struct task_struct *p, int nice)
+{
+	struct sched_attr attr = {
+		.sched_policy = SCHED_NORMAL,
+		.sched_nice = nice,
+	};
+	return sched_setattr_nocheck(p, &attr);
+}
+EXPORT_SYMBOL_GPL(sched_set_normal);
+
 static int
 do_sched_setscheduler(pid_t pid, int policy, struct sched_param __user *param)
 {

Powered by blists - more mailing lists