Augment rt_task() with is_realtime()

Whenever the kernel checks for rt_task() to avoid delaying real-time
tasks, we want it to also not delay LITMUS^RT tasks.  Hence, most
calls to rt_task() should be matched by an equivalent call to
is_realtime().

Notably, this affects the implementations of select() and nanosleep(),
which use timer_slack_ns when setting up timers for non-real-time
tasks.

6 files changed, 21 insertions, 7 deletions

diff --git a/fs/select.c b/fs/select.c
index 3d4f85defeab..a61843335182 100644
--- a/fs/select.c
+++ b/fs/select.c
@@ -31,6 +31,8 @@
 #include <net/busy_poll.h>
 #include <linux/vmalloc.h>
 
+#include <litmus/litmus.h> /* for is_realtime() */
+
 #include <asm/uaccess.h>
 
 
@@ -80,7 +82,7 @@ u64 select_estimate_accuracy(struct timespec64 *tv)
          * Realtime tasks get a slack of 0 for obvious reasons.
          */
 
-        if (rt_task(current))
+        if (rt_task(current) || is_realtime(current))
                 return 0;
 
         ktime_get_ts64(&now);
diff --git a/kernel/locking/mutex.c b/kernel/locking/mutex.c
index a70b90db3909..cfb3552caa6e 100644
--- a/kernel/locking/mutex.c
+++ b/kernel/locking/mutex.c
@@ -27,6 +27,8 @@
 #include <linux/debug_locks.h>
 #include <linux/osq_lock.h>
 
+#include <litmus/litmus.h> /* for is_realtime() */
+
 /*
  * In the DEBUG case we are using the "NULL fastpath" for mutexes,
  * which forces all calls into the slowpath:
@@ -368,7 +370,7 @@ static bool mutex_optimistic_spin(struct mutex *lock,
                  * we're an RT task that will live-lock because we won't let
                  * the owner complete.
                  */
-                if (!owner && (need_resched() || rt_task(task)))
+                if (!owner && (need_resched() || rt_task(task) || is_realtime(task)))
                         break;
 
                 /*
diff --git a/kernel/locking/rwsem-xadd.c b/kernel/locking/rwsem-xadd.c
index 2337b4bb2366..2badbb915c53 100644
--- a/kernel/locking/rwsem-xadd.c
+++ b/kernel/locking/rwsem-xadd.c
@@ -18,6 +18,8 @@
 
 #include "rwsem.h"
 
+#include <litmus/litmus.h> /* for is_realtime() */
+
 /*
  * Guide to the rw_semaphore's count field for common values.
  * (32-bit case illustrated, similar for 64-bit)
@@ -414,7 +416,7 @@ static bool rwsem_optimistic_spin(struct rw_semaphore *sem)
                  * we're an RT task that will live-lock because we won't let
                  * the owner complete.
                  */
-                if (!sem->owner && (need_resched() || rt_task(current)))
+                if (!sem->owner && (need_resched() || rt_task(current) || is_realtime(current)))
                         break;
 
                 /*
diff --git a/kernel/time/hrtimer.c b/kernel/time/hrtimer.c
index bb5ec425dfe0..49da37510d78 100644
--- a/kernel/time/hrtimer.c
+++ b/kernel/time/hrtimer.c
@@ -56,6 +56,8 @@
 
 #include "tick-internal.h"
 
+#include <litmus/litmus.h> /* for is_realtime() */
+
 /*
  * The timer bases:
  *
@@ -1541,7 +1543,7 @@ long hrtimer_nanosleep(struct timespec *rqtp, struct timespec __user *rmtp,
         u64 slack;
 
         slack = current->timer_slack_ns;
-        if (dl_task(current) || rt_task(current))
+        if (dl_task(current) || rt_task(current) || is_realtime(current))
                 slack = 0;
 
         hrtimer_init_on_stack(&t.timer, clockid, mode);
diff --git a/mm/page-writeback.c b/mm/page-writeback.c
index 439cc63ad903..9073c0889192 100644
--- a/mm/page-writeback.c
+++ b/mm/page-writeback.c
@@ -41,6 +41,8 @@
 
 #include "internal.h"
 
+#include <litmus/litmus.h> /* for is_realtime() */
+
 /*
  * Sleep at most 200ms at a time in balance_dirty_pages().
  */
@@ -435,7 +437,7 @@ static void domain_dirty_limits(struct dirty_throttle_control *dtc)
         if (bg_thresh >= thresh)
                 bg_thresh = thresh / 2;
         tsk = current;
-        if (tsk->flags & PF_LESS_THROTTLE || rt_task(tsk)) {
+        if (tsk->flags & PF_LESS_THROTTLE || rt_task(tsk) || is_realtime(tsk)) {
                 bg_thresh += bg_thresh / 4 + global_wb_domain.dirty_limit / 32;
                 thresh += thresh / 4 + global_wb_domain.dirty_limit / 32;
         }
@@ -485,7 +487,7 @@ static unsigned long node_dirty_limit(struct pglist_data *pgdat)
         else
                 dirty = vm_dirty_ratio * node_memory / 100;
 
-        if (tsk->flags & PF_LESS_THROTTLE || rt_task(tsk))
+        if (tsk->flags & PF_LESS_THROTTLE || rt_task(tsk) || is_realtime(tsk))
                 dirty += dirty / 4;
 
         return dirty;
diff --git a/mm/page_alloc.c b/mm/page_alloc.c
index 5b06fb385dd7..7c51a38d5d53 100644
--- a/mm/page_alloc.c
+++ b/mm/page_alloc.c
@@ -66,6 +66,9 @@
 #include <linux/memcontrol.h>
 
 #include <asm/sections.h>
+
+#include <litmus/litmus.h> /* for is_realtime() */
+
 #include <asm/tlbflush.h>
 #include <asm/div64.h>
 #include "internal.h"
@@ -3365,7 +3368,8 @@ gfp_to_alloc_flags(gfp_t gfp_mask)
                  * comment for __cpuset_node_allowed().
                  */
                 alloc_flags &= ~ALLOC_CPUSET;
-        } else if (unlikely(rt_task(current)) && !in_interrupt())
+        } else if (unlikely(rt_task(current) || is_realtime(current))
+                   && !in_interrupt())
                 alloc_flags |= ALLOC_HARDER;
 
 #ifdef CONFIG_CMA