Removed race condition in lock_acquired code.

1 files changed, 82 insertions, 64 deletions

diff --git a/litmus/sched_mc.c b/litmus/sched_mc.c
index d0a56fc664c..8028ce85e2d 100644
--- a/litmus/sched_mc.c
+++ b/litmus/sched_mc.c
@@ -91,7 +91,6 @@ static int interrupt_cpu;
 static void acquire_resources(struct task_struct *t)
 {
         int cpu;
-        struct task_struct *sched;
 
         /* Can't contend for resources if not logically running */
         BUG_ON(tsk_rt(t)->linked_on == NO_CPU);
@@ -463,7 +462,7 @@ static void preempt_cpu(struct cpu_entry *entry, struct task_struct *t)
 }
 
 /**
- * preempt() - Preempt a logically running task with a higher priority one.
+ * preempt_crit() - Preempt a logically running task with a higher priority one.
  * @dom Domain from which to draw higher priority task
  * @ce  CPU criticality level to preempt
  *
@@ -493,9 +492,7 @@ static void preempt_crit(struct domain *dom, struct crit_entry *ce)
         if (!is_ghost(task)) {
                 preempt_cpu(entry, task);
         } else if (old && old == entry->linked) {
-                /* Preempted a running task with a ghost job. Null needs to be
-                 * running.
-                 */
+                /* Preempted running task with ghost job. Nothing should run */
                 preempt_cpu(entry, NULL);
         }
 }
@@ -993,17 +990,63 @@ out:
         return ret;
 }
 
+void pick_next_task(struct cpu_entry *entry)
+{
+        int i;
+        struct crit_entry *ce;
+        struct domain *dom;
+        struct task_struct *dtask, *ready_task;
+
+        for (i = 0; i < NUM_CRIT_LEVELS && !entry->linked; i++) {
+                ce = &entry->crit_entries[i];
+                dom = ce->domain;
+
+                /* Swap locks. We cannot acquire a domain lock while
+                 * holding an entry lock or deadlocks will happen.
+                 */
+                raw_spin_unlock(&entry->lock);
+                raw_spin_lock(dom->lock);
+
+                /* Do domain stuff before grabbing CPU locks */
+                dtask = dom->peek_ready(dom);
+                fix_crit_position(ce);
+
+                raw_spin_lock(&entry->lock);
+
+                ready_task = NULL;
+                if (!entry->linked && can_use(ce)) {
+                        if (ce->linked) {
+                                ready_task = ce->linked;
+                        } else if (dtask) {
+                                /* Need a new task */
+                                dom->take_ready(dom);
+                                ready_task = dtask;
+
+                                link_task_to_crit(ce, dtask);
+                                update_crit_position(ce);
+                        }
+                }
+                if (ready_task && !is_ghost(ready_task)) {
+                        link_task_to_cpu(entry, ready_task);
+                        raw_spin_unlock(dom->lock);
+                        update_crit_levels(entry);
+                        raw_spin_lock(&entry->lock);
+                        continue;
+                }
+                raw_spin_unlock(dom->lock);
+        }
+}
+
 /**
  * mc_schedule() - Return next task which should be scheduled.
  */
 static struct task_struct* mc_schedule(struct task_struct* prev)
 {
         unsigned long flags;
-        struct domain *dom;
         struct crit_entry *ce;
         struct cpu_entry* entry = &__get_cpu_var(cpus);
-        int i, out_of_time, sleep, preempt, exists, blocks, global, lower;
-        struct task_struct *dtask = NULL, *ready_task = NULL, *next = NULL;
+        int out_of_time, sleep, preempt, exists, blocks, global, lower, update;
+        struct task_struct *next = NULL;
 
         local_irq_save(flags);
 
@@ -1034,8 +1077,8 @@ static struct task_struct* mc_schedule(struct task_struct* prev)
         lower       = exists && preempt && entry->linked &&
                 tsk_mc_crit(entry->scheduled) > tsk_mc_crit(entry->linked);
 
-        TRACE(TS " blocks:%d out_of_time:%d sleep:%d preempt:%d\n",
-              TA(prev), blocks, out_of_time, sleep, preempt);
+        TRACE(TS " blocks:%d out_of_time:%d sleep:%d preempt:%d, now: %llu\n",
+              TA(prev), blocks, out_of_time, sleep, preempt, litmus_clock());
 
         if (exists)
                 prev->rt_param.scheduled_on = NO_CPU;
@@ -1052,79 +1095,54 @@ static struct task_struct* mc_schedule(struct task_struct* prev)
         if (blocks)
                 remove_from_all(entry->scheduled);
         /* Any task which exhausts its budget or sleeps waiting for its next
-         * period completes unless its execution has been forcibly stopped.
+         * period completes unless its execution has been forcibly stopped
          */
-        if ((out_of_time || sleep) && !blocks)/* && !preempt)*/
+        else if (out_of_time || sleep)/* && !preempt)*/
                 job_completion(entry->scheduled, !sleep);
         /* Global scheduled tasks must wait for a deschedule before they
-         * can rejoin the global state. Rejoin them here.
+         * can rejoin the global state. Rejoin them here
          */
-        else if (global && preempt && !blocks) {
+        else if (global && preempt) {
                 if (lower)
                         low_prio_arrival(entry->scheduled);
                 else
                         job_arrival(entry->scheduled);
         }
 
-        /* Signal sent by lock acquisition */
-        if (entry->lock_acquired < NUM_CRIT_LEVELS) {
-                STRACE("Lock acquired for %d\n", entry->lock_acquired);
-                dom = entry->crit_entries[entry->lock_acquired].domain;
-                raw_spin_lock(dom->lock);
-                check_for_preempt(dom);
-                raw_spin_unlock(dom->lock);
-                entry->lock_acquired = NUM_CRIT_LEVELS;
-        }
-
-        /* Pick next task if none is linked */
         raw_spin_lock(&entry->lock);
-        for (i = 0; i < NUM_CRIT_LEVELS && !entry->linked; i++) {
-                ce = &entry->crit_entries[i];
-                dom = ce->domain;
 
-                /* Swap locks. We cannot acquire a domain lock while
-                 * holding an entry lock or deadlocks will happen.
-                 */
-                raw_spin_unlock(&entry->lock);
-                raw_spin_lock(dom->lock);
-
-                /* Do domain stuff before grabbing CPU locks */
-                dtask = dom->peek_ready(dom);
-                fix_crit_position(ce);
-
-                raw_spin_lock(&entry->lock);
+        /* Pick next task if none is linked */
+        if (!entry->linked)
+                pick_next_task(entry);
 
-                ready_task = NULL;
-                if (!entry->linked && can_use(ce)) {
-                        if (ce->linked) {
-                                ready_task = ce->linked;
-                        } else if (dtask) {
-                                /* Need a new task */
-                                dom->take_ready(dom);
-                                ready_task = dtask;
+        /* Set this now so that any reschedule signals received after this
+         * point will cause another reschedule
+         */
+        sched_state_task_picked();
 
-                                link_task_to_crit(ce, dtask);
-                                update_crit_position(ce);
-                        }
-                }
-                if (ready_task && !is_ghost(ready_task)) {
-                        link_task_to_cpu(entry, ready_task);
-                        raw_spin_unlock(dom->lock);
-                        update_crit_levels(entry);
-                        raw_spin_lock(&entry->lock);
-                        continue;
+        /* Ghost task acquired lock, is no longer ghost */
+        update = 0;
+        if (entry->lock_acquired < NUM_CRIT_LEVELS) {
+                ce = &entry->crit_entries[entry->lock_acquired];
+                if (ce->linked && !is_ghost(ce->linked) &&
+                    ce->linked != entry->linked) {
+                        link_task_to_cpu(entry, ce->linked);
+                        update = 1;
                 }
-                raw_spin_unlock(dom->lock);
+                entry->lock_acquired = NUM_CRIT_LEVELS;
         }
 
         /* Schedule next task */
         next = entry->linked;
-        if (entry->linked)
-                entry->linked->rt_param.scheduled_on = entry->cpu;
-        entry->will_schedule = entry->linked;
-        sched_state_task_picked();
+        if (next)
+                next->rt_param.scheduled_on = entry->cpu;
+        entry->will_schedule = next;
+
+        if (update)
+                update_crit_levels(entry); /* Will release lock */
+        else
+                raw_spin_unlock(&entry->lock);
 
-        raw_spin_unlock(&entry->lock);
         local_irq_restore(flags);
         if (next) {
                 BUG_ON(!get_rt_job(next));
@@ -1222,7 +1240,7 @@ out:
 
 static void mc_release_ts(lt_t time)
 {
-        int i, cpu, base_id = 0, cont_id = -1;
+        int cpu, cont_id = -1;
         char name[TASK_COMM_LEN];
         enum crit_level level;
         struct cpu_entry *entry;