hrtimer: Use and report correct timerslack values for realtime tasks

The timerslack_ns setting is used to specify how much the hardware
timers should be delayed, to potentially dispatch multiple timers in a
single interrupt. This is a performance optimization. Timers of
realtime tasks (having a realtime scheduling policy) should not be
delayed.

This logic was inconsitently applied to the hrtimers, leading to delays
of realtime tasks which used timed waits for events (e.g. condition
variables). Due to the downstream override of the slack for rt tasks,
the procfs reported incorrect (non-zero) timerslack_ns values.

This is changed by setting the timer_slack_ns task attribute to 0 for
all tasks with a rt policy. By that, downstream users do not need to
specially handle rt tasks (w.r.t. the slack), and the procfs entry
shows the correct value of "0". Setting non-zero slack values (either
via procfs or PR_SET_TIMERSLACK) on tasks with a rt policy is ignored,
as stated in "man 2 PR_SET_TIMERSLACK":

  Timer slack is not applied to threads that are scheduled under a
  real-time scheduling policy (see sched_setscheduler(2)).

The special handling of timerslack on rt tasks in downstream users
is removed as well.

Signed-off-by: Felix Moessbauer <felix.moessbauer@siemens.com>
Signed-off-by: Thomas Gleixner <tglx@linutronix.de>
Link: https://lore.kernel.org/all/20240814121032.368444-2-felix.moessbauer@siemens.com

diff --git a/fs/proc/base.c b/fs/proc/base.c
index dd579332a7f8abfef7a075a0efae6f0d86411058..afe573e8d8f1de89810f6766a0a0a9e4b8369e71 100644 (file)
--- a/fs/proc/base.c
+++ b/fs/proc/base.c
@@ -2569,10 +2569,11 @@ static ssize_t timerslack_ns_write(struct file *file, const char __user *buf,
        }
 
        task_lock(p);
-       if (slack_ns == 0)
-               p->timer_slack_ns = p->default_timer_slack_ns;
-       else
-               p->timer_slack_ns = slack_ns;
+       if (task_is_realtime(p))
+               slack_ns = 0;
+       else if (slack_ns == 0)
+               slack_ns = p->default_timer_slack_ns;
+       p->timer_slack_ns = slack_ns;
        task_unlock(p);
 
 out:

diff --git a/fs/select.c b/fs/select.c
index 9515c3fa1a03e8a8576f90f8a4dee46509dd1954..ad171b7a5c11f9d5a46b88af621862fa2d1e3fb7 100644 (file)
--- a/fs/select.c
+++ b/fs/select.c
@@ -77,19 +77,16 @@ u64 select_estimate_accuracy(struct timespec64 *tv)
 {
        u64 ret;
        struct timespec64 now;
+       u64 slack = current->timer_slack_ns;
 
-       /*
-        * Realtime tasks get a slack of 0 for obvious reasons.
-        */
-
-       if (rt_task(current))
+       if (slack == 0)
                return 0;
 
        ktime_get_ts64(&now);
        now = timespec64_sub(*tv, now);
        ret = __estimate_accuracy(&now);
-       if (ret < current->timer_slack_ns)
-               return current->timer_slack_ns;
+       if (ret < slack)
+               return slack;
        return ret;
 }
 

diff --git a/kernel/sched/syscalls.c b/kernel/sched/syscalls.c
index ae1b42775ef95c5f0ffc41d0491c4903f213db69..195d2f2834a9758ebc8c855336688d2e2520600e 100644 (file)
--- a/kernel/sched/syscalls.c
+++ b/kernel/sched/syscalls.c
@@ -406,6 +406,14 @@ static void __setscheduler_params(struct task_struct *p,
        else if (fair_policy(policy))
                p->static_prio = NICE_TO_PRIO(attr->sched_nice);
 
+       /* rt-policy tasks do not have a timerslack */
+       if (task_is_realtime(p)) {
+               p->timer_slack_ns = 0;
+       } else if (p->timer_slack_ns == 0) {
+               /* when switching back to non-rt policy, restore timerslack */
+               p->timer_slack_ns = p->default_timer_slack_ns;
+       }
+
        /*
         * __sched_setscheduler() ensures attr->sched_priority == 0 when
         * !rt_policy. Always setting this ensures that things like

diff --git a/kernel/sys.c b/kernel/sys.c
index 3a2df1bd9f640ebbd63ceda94dd8cc1c51018f1b..e3c4cffb520ceec414ff20cd769a2a6bfe19df2c 100644 (file)
--- a/kernel/sys.c
+++ b/kernel/sys.c
@@ -2557,6 +2557,8 @@ SYSCALL_DEFINE5(prctl, int, option, unsigned long, arg2, unsigned long, arg3,
                        error = current->timer_slack_ns;
                break;
        case PR_SET_TIMERSLACK:
+               if (task_is_realtime(current))
+                       break;
                if (arg2 <= 0)
                        current->timer_slack_ns =
                                        current->default_timer_slack_ns;

diff --git a/kernel/time/hrtimer.c b/kernel/time/hrtimer.c
index f56ef23aad90341c52fe6ab34457439530d73295..a023946f855803b8b7b0646a7dcbc421f524147c 100644 (file)
--- a/kernel/time/hrtimer.c
+++ b/kernel/time/hrtimer.c
@@ -2074,14 +2074,9 @@ long hrtimer_nanosleep(ktime_t rqtp, const enum hrtimer_mode mode,
        struct restart_block *restart;
        struct hrtimer_sleeper t;
        int ret = 0;
-       u64 slack;
-
-       slack = current->timer_slack_ns;
-       if (rt_task(current))
-               slack = 0;
 
        hrtimer_init_sleeper_on_stack(&t, clockid, mode);
-       hrtimer_set_expires_range_ns(&t.timer, rqtp, slack);
+       hrtimer_set_expires_range_ns(&t.timer, rqtp, current->timer_slack_ns);
        ret = do_nanosleep(&t, mode);
        if (ret != -ERESTART_RESTARTBLOCK)
                goto out;
@@ -2251,7 +2246,7 @@ void __init hrtimers_init(void)
 /**
  * schedule_hrtimeout_range_clock - sleep until timeout
  * @expires:   timeout value (ktime_t)
- * @delta:     slack in expires timeout (ktime_t) for SCHED_OTHER tasks
+ * @delta:     slack in expires timeout (ktime_t)
  * @mode:      timer mode
  * @clock_id:  timer clock to be used
  */
@@ -2278,13 +2273,6 @@ schedule_hrtimeout_range_clock(ktime_t *expires, u64 delta,
                return -EINTR;
        }
 
-       /*
-        * Override any slack passed by the user if under
-        * rt contraints.
-        */
-       if (rt_task(current))
-               delta = 0;
-
        hrtimer_init_sleeper_on_stack(&t, clock_id, mode);
        hrtimer_set_expires_range_ns(&t.timer, *expires, delta);
        hrtimer_sleeper_start_expires(&t, mode);
@@ -2304,7 +2292,7 @@ EXPORT_SYMBOL_GPL(schedule_hrtimeout_range_clock);
 /**
  * schedule_hrtimeout_range - sleep until timeout
  * @expires:   timeout value (ktime_t)
- * @delta:     slack in expires timeout (ktime_t) for SCHED_OTHER tasks
+ * @delta:     slack in expires timeout (ktime_t)
  * @mode:      timer mode
  *
  * Make the current task sleep until the given expiry time has