Fixed global task deadlock

2 files changed, 33 insertions, 18 deletions

diff --git a/litmus/sched_mc.c b/litmus/sched_mc.c
index 8e261426171e..90a60c568183 100644
--- a/litmus/sched_mc.c
+++ b/litmus/sched_mc.c
@@ -176,15 +176,30 @@ static void update_ghost_time(struct task_struct *p)
         }
 }
 
+/*
+ * Update crit entry position in a global heap. Caller must hold
+ * @ce's domain lock.
+ */
+static inline void update_crit_position(struct crit_entry *ce)
+{
+        struct bheap *heap;
+        if (is_global(ce->domain)) {
+                heap = domain_data(ce->domain)->heap;
+                BUG_ON(!heap);
+                BUG_ON(!bheap_node_in_heap(ce->node));
+                bheap_delete(cpu_lower_prio, heap, ce->node);
+                bheap_insert(cpu_lower_prio, heap, ce->node);
+        }
+}
+
 /**
  * link_task_to_crit() - Logically run a task at a criticality level.
- * Caller must hold @ce's domain's lock.
+ * Caller must hold @ce's CPU lock.
  */
 static void link_task_to_crit(struct crit_entry *ce,
                               struct task_struct *task)
 {
         lt_t when_to_fire;
-        struct bheap *heap;
 
         TRACE_CRIT_ENTRY(ce, "Linking " TS, TA(task));
         BUG_ON(!ce->usable && task);
@@ -221,15 +236,6 @@ static void link_task_to_crit(struct crit_entry *ce,
                         arm_ghost(ce, when_to_fire);
                 }
         }
-
-        /* Update global heap node position */
-        if (is_global(ce->domain)) {
-                heap = domain_data(ce->domain)->heap;
-                BUG_ON(!heap);
-                BUG_ON(!bheap_node_in_heap(ce->node));
-                bheap_delete(cpu_lower_prio, heap, ce->node);
-                bheap_insert(cpu_lower_prio, heap, ce->node);
-        }
 }
 
 static void check_for_preempt(struct domain*);
@@ -351,18 +357,18 @@ static void preempt(struct domain *dom, struct crit_entry *ce)
 {
         struct task_struct *task = dom->take_ready(dom);
         struct cpu_entry *entry = crit_cpu(ce);
-        struct task_struct *old;
+        struct task_struct *old = ce->linked;
 
         BUG_ON(!task);
         TRACE_CRIT_ENTRY(ce, "Preempted by " TS, TA(task));
 
-        old = ce->linked;
-
         /* Per-domain preemption */
         if (old && can_requeue(old)) {
                 dom->requeue(dom, old);
         }
         link_task_to_crit(ce, task);
+        update_crit_position(ce);
+
         /* Preempt actual execution if this is a running task */
         if (!is_ghost(task)) {
                 link_task_to_cpu(entry, task);
@@ -412,8 +418,18 @@ static void update_crit_levels(struct cpu_entry *entry)
         /* Re-admit tasks to the system */
         for (i = level + 1; i < NUM_CRIT_LEVELS; i++) {
                 ce = &entry->crit_entries[i];
-                if (readmit[i])
+                if (readmit[i]) {
+                        /* Position of the crit entry changed earlier.
+                         * We couldn't update it while we held the entry
+                         * lock. Update it here.
+                         */
+                        if (is_global(ce->domain)) {
+                                raw_spin_lock(ce->domain->lock);
+                                update_crit_position(ce);
+                                raw_spin_unlock(ce->domain->lock);
+                        }
                         low_prio_arrival(readmit[i]);
+                }
         }
 }
 
@@ -479,6 +495,7 @@ static void remove_from_all(struct task_struct* task)
                 if (task->rt_param.linked_on != NO_CPU) {
                         BUG_ON(ce->linked != task);
                         link_task_to_crit(ce, NULL);
+                        update_crit_position(ce);
                         if (!is_ghost(task) && entry->linked == task) {
                                 update = 1;
                                 link_task_to_cpu(entry, NULL);
@@ -577,7 +594,6 @@ static enum hrtimer_restart mc_ghost_exhausted(struct hrtimer *timer)
                 update_ghost_time(ce->linked);
                 if (tsk_mc_data(ce->linked)->mc_job.ghost_budget == 0) {
                         tmp = ce->linked;
-                        link_task_to_crit(ce, NULL);
                 }
         }
         raw_spin_unlock(&crit_cpu(ce)->lock);
@@ -886,6 +902,7 @@ static struct task_struct* mc_schedule(struct task_struct * prev)
                 if (!entry->linked && ce->usable && !ce->linked && dtask) {
                         dom->take_ready(dom);
                         link_task_to_crit(ce, dtask);
+                        update_crit_position(ce);
                         ready_task = (is_ghost(dtask)) ? NULL : dtask;
 
                         /* Task found! */
diff --git a/litmus/sched_mc_ce.c b/litmus/sched_mc_ce.c
index ffcc25873581..5a19628b06df 100644
--- a/litmus/sched_mc_ce.c
+++ b/litmus/sched_mc_ce.c
@@ -421,10 +421,8 @@ void mc_ce_task_exit_common(struct task_struct *ts)
         const int lvl_a_id = tsk_mc_data(ts)->mc_task.lvl_a_id;
         struct ce_pid_table *pid_table = get_pid_table(ce_data->cpu);
 
-        BUG_ON(task_cpu(ts) != get_partition(ts));
         BUG_ON(CRIT_LEVEL_A != tsk_mc_crit(ts));
         BUG_ON(lvl_a_id >= pid_table->num_pid_entries);
-        BUG_ON(ce_data->cpu != task_cpu(ts));
 
         raw_spin_lock_irqsave(dom->lock, flags);
         pid = pid_table->entries[lvl_a_id].pid;