Re-implement non-preemptive section support.

Re-introduce NP sections in the configuration and in litmus.h. Remove the old
np_flag from rt_param.

If CONFIG_NP_SECTION is disabled, then all non-preemptive section checks are
constant expressions which should get removed by the dead code elimination
during optimization.

Instead of re-implementing sys_exit_np(), we simply repurposed sched_yield()
for calling into the scheduler to trigger delayed preemptions.

4 files changed, 106 insertions, 28 deletions

diff --git a/include/litmus/litmus.h b/include/litmus/litmus.h
index a03580bc707c..faaf83961dfa 100644
--- a/include/litmus/litmus.h
+++ b/include/litmus/litmus.h
@@ -27,11 +27,11 @@ extern atomic_t __log_seq_no;
         do { if (cond) TRACE("BUG_ON(%s) at %s:%d " \
                              "called from %p current=%s/%d state=%d " \
                              "flags=%x partition=%d cpu=%d rtflags=%d"\
-                             " job=%u knp=%d timeslice=%u\n",           \
+                             " job=%u timeslice=%u\n",          \
         #cond, __FILE__, __LINE__, __builtin_return_address(0), current->comm, \
         current->pid, current->state, current->flags,  \
         get_partition(current), smp_processor_id(), get_rt_flags(current), \
-        current->rt_param.job_params.job_no, current->rt_param.kernel_np, \
+        current->rt_param.job_params.job_no, \
         current->rt.time_slice\
         ); } while(0);
 
@@ -124,8 +124,6 @@ static inline lt_t litmus_clock(void)
         (a)->rt_param.job_params.release,\
         (b)->rt_param.job_params.release))
 
-#define make_np(t) do {t->rt_param.kernel_np++;} while(0);
-#define take_np(t) do {t->rt_param.kernel_np--;} while(0);
 
 #ifdef CONFIG_SRP
 void srp_ceiling_block(void);
@@ -135,12 +133,88 @@ void srp_ceiling_block(void);
 
 #define bheap2task(hn) ((struct task_struct*) hn->value)
 
-static inline int is_np(struct task_struct *t)
+#ifdef CONFIG_NP_SECTION
+
+static inline int is_kernel_np(struct task_struct *t)
 {
         return tsk_rt(t)->kernel_np;
 }
 
-#define  request_exit_np(t)
+static inline int is_user_np(struct task_struct *t)
+{
+        return tsk_rt(t)->ctrl_page ? tsk_rt(t)->ctrl_page->np_flag : 0;
+}
+
+static inline void request_exit_np(struct task_struct *t)
+{
+        if (is_user_np(t)) {
+                /* Set the flag that tells user space to call
+                 * into the kernel at the end of a critical section. */
+                if (likely(tsk_rt(t)->ctrl_page)) {
+                        TRACE_TASK(t, "setting delayed_preemption flag\n");
+                        tsk_rt(t)->ctrl_page->delayed_preemption = 1;
+                }
+        }
+}
+
+static inline void clear_exit_np(struct task_struct *t)
+{
+        if (likely(tsk_rt(t)->ctrl_page))
+                tsk_rt(t)->ctrl_page->delayed_preemption = 0;
+}
+
+static inline void make_np(struct task_struct *t)
+{
+        tsk_rt(t)->kernel_np++;
+}
+
+/* Caller should check if preemption is necessary when
+ * the function return 0.
+ */
+static inline int take_np(struct task_struct *t)
+{
+        return --tsk_rt(t)->kernel_np;
+}
+
+#else
+
+static inline int is_kernel_np(struct task_struct* t)
+{
+        return 0;
+}
+
+static inline int is_user_np(struct task_struct* t)
+{
+        return 0;
+}
+
+static inline void request_exit_np(struct task_struct *t)
+{
+        /* request_exit_np() shouldn't be called if !CONFIG_NP_SECTION */
+        BUG();
+}
+
+static inline void clear_exit_np(struct task_struct* t)
+{
+}
+
+#endif
+
+static inline int is_np(struct task_struct *t)
+{
+#ifdef CONFIG_SCHED_DEBUG_TRACE
+        int kernel, user;
+        kernel = is_kernel_np(t);
+        user   = is_user_np(t);
+        if (kernel || user)
+                TRACE_TASK(t, " is non-preemptive: kernel=%d user=%d\n",
+
+                           kernel, user);
+        return kernel || user;
+#else
+        return unlikely(is_kernel_np(t) || is_user_np(t));
+#endif
+}
 
 static inline int is_present(struct task_struct* t)
 {
diff --git a/include/litmus/rt_param.h b/include/litmus/rt_param.h
index 9353251fb30e..5b94d1a8eea7 100644
--- a/include/litmus/rt_param.h
+++ b/include/litmus/rt_param.h
@@ -85,7 +85,6 @@ struct rt_job {
         unsigned int    job_no;
 };
 
-
 struct pfair_param;
 
 /*      RT task parameters for scheduling extensions
@@ -116,26 +115,14 @@ struct rt_param {
          */
          struct task_struct*    inh_task;
 
-        /* Don't just dereference this pointer in kernel space!
-         * It might very well point to junk or nothing at all.
-         * NULL indicates that the task has not requested any non-preemptable
-         * section support.
-         * Not inherited upon fork.
+#ifdef CONFIG_NP_SECTION
+        /* For the FMLP under PSN-EDF, it is required to make the task
+         * non-preemptive from kernel space. In order not to interfere with
+         * user space, this counter indicates the kernel space np setting.
+         * kernel_np > 0 => task is non-preemptive
          */
-        short*                  np_flag;
-
-        /* re-use unused counter in plugins that don't need it */
-        union {
-                /* For the FMLP under PSN-EDF, it is required to make the task
-                 * non-preemptive from kernel space. In order not to interfere with
-                 * user space, this counter indicates the kernel space np setting.
-                 * kernel_np > 0 => task is non-preemptive
-                 */
-                unsigned int    kernel_np;
-
-                /* Used by GQ-EDF */
-                unsigned int    last_cpu;
-        };
+        unsigned int    kernel_np;
+#endif
 
         /* This field can be used by plugins to store where the task
          * is currently scheduled. It is the responsibility of the
diff --git a/litmus/Kconfig b/litmus/Kconfig
index 5556ae5cba45..874794f64af1 100644
--- a/litmus/Kconfig
+++ b/litmus/Kconfig
@@ -2,6 +2,17 @@ menu "LITMUS^RT"
 
 menu "Real-Time Synchronization"
 
+config NP_SECTION
+        bool "Non-preemptive section support"
+        default n
+        help
+          Allow tasks to become non-preemptable.
+          Note that plugins still need to explicitly support non-preemptivity.
+          Currently, only GSN-EDF and PSN-EDF have such support.
+
+          This is required to support the FMLP.
+          If disabled, all tasks will be considered preemptable at all times.
+
 config SRP
         bool "Stack Resource Policy (SRP)"
         default n
@@ -13,7 +24,7 @@ config SRP
 
 config FMLP
         bool "FMLP support"
-#       depends on NP_SECTION
+        depends on NP_SECTION
         default n
         help
           Include support for deterministic multiprocessor real-time
diff --git a/litmus/sched_litmus.c b/litmus/sched_litmus.c
index 64ad5db07795..c1fc7748e590 100644
--- a/litmus/sched_litmus.c
+++ b/litmus/sched_litmus.c
@@ -177,7 +177,13 @@ static void dequeue_task_litmus(struct rq *rq, struct task_struct *p, int sleep)
 static void yield_task_litmus(struct rq *rq)
 {
         BUG_ON(rq->curr != current);
-        litmus->complete_job();
+        /* sched_yield() is called to trigger delayed preemptions.
+         * Thus, mark the current task as needing to be rescheduled.
+         * This will cause the scheduler plugin to be invoked, which can
+         * then determine if a preemption is still required.
+         */
+        clear_exit_np(current);
+        set_tsk_need_resched(current);
 }
 
 /* Plugins are responsible for this.