1 files changed, 42 insertions, 60 deletions

diff --git a/litmus/litmus.c b/litmus/litmus.c
index 6a1095aa7725..2911e7ec7029 100644
--- a/litmus/litmus.c
+++ b/litmus/litmus.c
@@ -10,6 +10,7 @@
 #include <linux/module.h>
 #include <linux/slab.h>
 #include <linux/reboot.h>
+#include <linux/stop_machine.h>
 
 #include <litmus/litmus.h>
 #include <litmus/bheap.h>
@@ -32,9 +33,6 @@
 
 /* Number of RT tasks that exist in the system */
 atomic_t rt_task_count          = ATOMIC_INIT(0);
-static DEFINE_RAW_SPINLOCK(task_transition_lock);
-/* synchronize plugin switching */
-atomic_t cannot_use_plugin      = ATOMIC_INIT(0);
 
 /* Give log messages sequential IDs. */
 atomic_t __log_seq_no = ATOMIC_INIT(0);
@@ -479,13 +477,9 @@ static void reinit_litmus_state(struct task_struct* p, int restore)
 long __litmus_admit_task(struct task_struct* tsk)
 {
         long retval = 0;
-        unsigned long flags;
 
         INIT_LIST_HEAD(&tsk_rt(tsk)->list);
 
-        /* avoid scheduler plugin changing underneath us */
-        raw_spin_lock_irqsave(&task_transition_lock, flags);
-
         /* allocate heap node for this task */
         tsk_rt(tsk)->heap_node = bheap_node_alloc(GFP_ATOMIC);
         tsk_rt(tsk)->rel_heap = release_heap_alloc(GFP_ATOMIC);
@@ -493,11 +487,8 @@ long __litmus_admit_task(struct task_struct* tsk)
         if (!tsk_rt(tsk)->heap_node || !tsk_rt(tsk)->rel_heap) {
                 printk(KERN_WARNING "litmus: no more heap node memory!?\n");
 
-                bheap_node_free(tsk_rt(tsk)->heap_node);
-                release_heap_free(tsk_rt(tsk)->rel_heap);
-
                 retval = -ENOMEM;
-                goto out_unlock;
+                goto out;
         } else {
                 bheap_node_init(&tsk_rt(tsk)->heap_node, tsk);
         }
@@ -511,14 +502,10 @@ long __litmus_admit_task(struct task_struct* tsk)
 #ifdef CONFIG_LITMUS_NESTED_LOCKING
         tsk_rt(tsk)->blocked_lock = NULL;
         raw_spin_lock_init(&tsk_rt(tsk)->hp_blocked_tasks_lock);
-        //INIT_BINHEAP_HANDLE(&tsk_rt(tsk)->hp_blocked_tasks, prio_order);  // done by scheduler
-#endif
-#ifdef CONFIG_LITMUS_SOFTIRQD
-        /* not an interrupt thread by default */
-        //tsk_rt(tsk)->is_interrupt_thread = 0;
-    //tsk_rt(tsk)->klmirqd_info = NULL;
 #endif
 
+        preempt_disable();
+
         retval = litmus->admit_task(tsk);
 
         if (!retval) {
@@ -527,9 +514,14 @@ long __litmus_admit_task(struct task_struct* tsk)
                 atomic_inc(&rt_task_count);
         }
 
-out_unlock:
-        raw_spin_unlock_irqrestore(&task_transition_lock, flags);
+        preempt_enable();
+
+        if (retval) {
+                bheap_node_free(tsk_rt(tsk)->heap_node);
+                release_heap_free(tsk_rt(tsk)->rel_heap);
+        }
 
+out:
         return retval;
 }
 
@@ -590,39 +582,10 @@ void litmus_exit_task(struct task_struct* tsk)
         }
 }
 
-/* IPI callback to synchronize plugin switching */
-static void synch_on_plugin_switch(void* info)
-{
-        atomic_inc(&cannot_use_plugin);
-        while (atomic_read(&cannot_use_plugin) > 0)
-                cpu_relax();
-}
-
-int switch_sched_plugin(struct sched_plugin* plugin)
+static int do_plugin_switch(void *_plugin)
 {
-        //unsigned long flags;
-        int ret = 0;
-
-        BUG_ON(!plugin);
-
-#ifdef CONFIG_LITMUS_SOFTIRQD
-        if (!klmirqd_is_dead()) {
-                kill_klmirqd();
-        }
-#endif
-
-        /* forbid other cpus to use the plugin */
-        atomic_set(&cannot_use_plugin, 1);
-        /* send IPI to force other CPUs to synch with us */
-        smp_call_function(synch_on_plugin_switch, NULL, 0);
-
-        /* wait until all other CPUs have started synch */
-        while (atomic_read(&cannot_use_plugin) < num_online_cpus()) {
-                cpu_relax();
-        }
-
-        /* stop task transitions */
-        //raw_spin_lock_irqsave(&task_transition_lock, flags);
+        int ret;
+        struct sched_plugin* plugin = _plugin;
 
         /* don't switch if there are active real-time tasks */
         if (atomic_read(&rt_task_count) == 0) {
@@ -630,24 +593,45 @@ int switch_sched_plugin(struct sched_plugin* plugin)
                 if (0 != ret)
                         goto out;
 
-                litmus = plugin;  // switch
-                mb();  // make sure it's seen everywhere.
+                litmus = plugin;  /* optimistic switch */
+                mb();
+
                 ret = litmus->activate_plugin();
                 if (0 != ret) {
                         printk(KERN_INFO "Can't activate %s (%d).\n",
                                litmus->plugin_name, ret);
-                        litmus = &linux_sched_plugin;
+                        litmus = &linux_sched_plugin; /* fail to Linux */
+                        ret = litmus->activate_plugin();
+                        BUG_ON(ret);
                 }
-                printk(KERN_INFO "Switching to LITMUS^RT plugin %s.\n", litmus->plugin_name);
+                printk(KERN_INFO "Switched to LITMUS^RT plugin %s.\n", litmus->plugin_name);
         } else
                 ret = -EBUSY;
 out:
-        //raw_spin_unlock_irqrestore(&task_transition_lock, flags);
-        atomic_set(&cannot_use_plugin, 0);
-
         return ret;
 }
 
+/* Switching a plugin in use is tricky.
+ * We must watch out that no real-time tasks exists
+ * (and that none is created in parallel) and that the plugin is not
+ * currently in use on any processor (in theory).
+ */
+int switch_sched_plugin(struct sched_plugin* plugin)
+{
+        BUG_ON(!plugin);
+
+#ifdef CONFIG_LITMUS_SOFTIRQD
+        if (!klmirqd_is_dead()) {
+                kill_klmirqd();
+        }
+#endif
+
+        if (atomic_read(&rt_task_count) == 0)
+                return stop_machine(do_plugin_switch, plugin, NULL);
+        else
+                return -EBUSY;
+}
+
 /* Called upon fork.
  * p is the newly forked task.
  */
@@ -772,8 +756,6 @@ static int __init _init_litmus(void)
          */
         printk("Starting LITMUS^RT kernel\n");
 
-        BUILD_BUG_ON(sizeof(union np_flag) != sizeof(uint32_t));
-
         register_sched_plugin(&linux_sched_plugin);
 
         bheap_node_cache    = KMEM_CACHE(bheap_node, SLAB_PANIC);