Litmus core: simplify np-section protocolwip-2011.2-bbb

User a 32-bit word for all non-preemptive section flags.
Set the "please yield soon" flag atomically when
accessing it on remotely-scheduled tasks.

1 files changed, 38 insertions, 9 deletions

diff --git a/include/litmus/litmus.h b/include/litmus/litmus.h
index e7769ca36ec0..12af22266331 100644
--- a/include/litmus/litmus.h
+++ b/include/litmus/litmus.h
@@ -137,7 +137,7 @@ static inline int is_kernel_np(struct task_struct *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;
+        return tsk_rt(t)->ctrl_page ? tsk_rt(t)->ctrl_page->sched.np.flag : 0;
 }
 
 static inline void request_exit_np(struct task_struct *t)
@@ -147,17 +147,11 @@ static inline void request_exit_np(struct task_struct *t)
                  * 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;
+                        tsk_rt(t)->ctrl_page->sched.np.preempt = 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++;
@@ -171,6 +165,34 @@ static inline int take_np(struct task_struct *t)
         return --tsk_rt(t)->kernel_np;
 }
 
+/* returns 0 if remote CPU needs an IPI to preempt, 1 if no IPI is required */
+static inline int request_exit_np_atomic(struct task_struct *t)
+{
+        union np_flag old, new;
+
+        if (tsk_rt(t)->ctrl_page) {
+                old.raw = tsk_rt(t)->ctrl_page->sched.raw;
+                if (old.np.flag == 0) {
+                        /* no longer non-preemptive */
+                        return 0;
+                } else if (old.np.preempt) {
+                        /* already set, nothing for us to do */
+                        return 1;
+                } else {
+                        /* non preemptive and flag not set */
+                        new.raw = old.raw;
+                        new.np.preempt = 1;
+                        /* if we get old back, then we atomically set the flag */
+                        return cmpxchg(&tsk_rt(t)->ctrl_page->sched.raw, old.raw, new.raw) == old.raw;
+                        /* If we raced with a concurrent change, then so be
+                         * it. Deliver it by IPI.  We don't want an unbounded
+                         * retry loop here since tasks might exploit that to
+                         * keep the kernel busy indefinitely. */
+                }
+        } else
+                return 0;
+}
+
 #else
 
 static inline int is_kernel_np(struct task_struct* t)
@@ -189,12 +211,19 @@ static inline void request_exit_np(struct task_struct *t)
         BUG();
 }
 
-static inline void clear_exit_np(struct task_struct* t)
+static inline int request_exist_np_atomic(struct task_struct *t)
 {
+        return 0;
 }
 
 #endif
 
+static inline void clear_exit_np(struct task_struct *t)
+{
+        if (likely(tsk_rt(t)->ctrl_page))
+                tsk_rt(t)->ctrl_page->sched.np.preempt = 0;
+}
+
 static inline int is_np(struct task_struct *t)
 {
 #ifdef CONFIG_SCHED_DEBUG_TRACE