Introduce generic NP-section aware preemption function

Dealing with preemptions across CPUs in the presence of non-preemptive
sections can be tricky and should not be replicated across (event-driven) plugins.

This patch introduces a generic preemption function that handles
non-preemptive sections (hopefully) correctly.

2 files changed, 60 insertions, 1 deletions

diff --git a/include/litmus/litmus.h b/include/litmus/litmus.h
index faaf83961dfa..62107e659c12 100644
--- a/include/litmus/litmus.h
+++ b/include/litmus/litmus.h
@@ -124,6 +124,7 @@ static inline lt_t litmus_clock(void)
         (a)->rt_param.job_params.release,\
         (b)->rt_param.job_params.release))
 
+void preempt_if_preemptable(struct task_struct* t, int on_cpu);
 
 #ifdef CONFIG_SRP
 void srp_ceiling_block(void);
diff --git a/litmus/sched_plugin.c b/litmus/sched_plugin.c
index 0be091ece569..bc7c0e93fb18 100644
--- a/litmus/sched_plugin.c
+++ b/litmus/sched_plugin.c
@@ -1,7 +1,7 @@
 /* sched_plugin.c -- core infrastructure for the scheduler plugin system
  *
  * This file includes the initialization of the plugin system, the no-op Linux
- * scheduler plugin and some dummy functions.
+ * scheduler plugin, some dummy functions, and some helper functions.
  */
 
 #include <linux/list.h>
@@ -12,6 +12,64 @@
 
 #include <litmus/jobs.h>
 
+/*
+ * Generic function to trigger preemption on either local or remote cpu
+ * from scheduler plugins. The key feature is that this function is
+ * non-preemptive section aware and does not invoke the scheduler / send
+ * IPIs if the to-be-preempted task is actually non-preemptive.
+ */
+void preempt_if_preemptable(struct task_struct* t, int on_cpu)
+{
+        /* t is the real-time task executing on CPU on_cpu If t is NULL, then
+         * on_cpu is currently scheduling background work.
+         */
+
+        int send_ipi;
+
+        if (smp_processor_id() == on_cpu) {
+                /* local CPU case */
+                if (t) {
+                        /* check if we need to poke userspace */
+                        if (is_user_np(t))
+                                /* yes, poke it */
+                                request_exit_np(t);
+                        else
+                                /* no, see if we are allowed to preempt the
+                                 * currently-executing task */
+                                if (!is_kernel_np(t))
+                                        set_tsk_need_resched(t);
+                } else
+                        /* move non-real-time task out of the way */
+                        set_tsk_need_resched(current);
+        } else {
+                /* remote CPU case */
+                if (!t)
+                        /* currently schedules non-real-time work */
+                        send_ipi = 1;
+                else {
+                        /* currently schedules real-time work */
+                        if (is_user_np(t)) {
+                                /* need to notify user space of delayed
+                                 * preemption */
+
+                                /* to avoid a race, set the flag, then test
+                                 * again */
+                                request_exit_np(t);
+                                /* make sure it got written */
+                                mb();
+                        }
+                        /* Only send an ipi if remote task might have raced our
+                         * request, i.e., send an IPI to make sure if it exited
+                         * its critical section.
+                         */
+                        send_ipi = !is_np(t) && !is_kernel_np(t);
+                }
+                if (likely(send_ipi))
+                        smp_send_reschedule(on_cpu);
+        }
+}
+
+
 /*************************************************************
  *                   Dummy plugin functions                  *
  *************************************************************/