Fixed level-A crash when cancel task execution

6 files changed, 50 insertions, 10 deletions

diff --git a/include/litmus/sched_trace.h b/include/litmus/sched_trace.h
index e25a26e9d861..7179fc2745ad 100644
--- a/include/litmus/sched_trace.h
+++ b/include/litmus/sched_trace.h
@@ -193,6 +193,12 @@ feather_callback void do_sched_trace_sys_release(unsigned long id,
         SCHED_TRACE(SCHED_TRACE_BASE_ID + 10, do_sched_trace_sys_release, when)
 
 
+#define QT_START lt_t _qt_start = litmus_clock()
+#define QT_END \
+        sched_trace_log_message("%d P%d      [%s@%s:%d]: Took %llu\n\n", \
+                TRACE_ARGS, litmus_clock() - _qt_start)
+
+
 #define sched_trace_quantum_boundary() /* NOT IMPLEMENTED */
 
 #endif /* __KERNEL__ */
diff --git a/include/litmus/trace.h b/include/litmus/trace.h
index 05f487263f28..95e1ee647a8a 100644
--- a/include/litmus/trace.h
+++ b/include/litmus/trace.h
@@ -99,5 +99,4 @@ feather_callback void save_timestamp_cpu(unsigned long event, unsigned long cpu)
 #define TS_SEND_RESCHED_START(c)        CTIMESTAMP(190, c)
 #define TS_SEND_RESCHED_END             DTIMESTAMP(191, TSK_UNKNOWN)
 
-
 #endif /* !_SYS_TRACE_H_ */
diff --git a/litmus/ce_domain.c b/litmus/ce_domain.c
index fd9904e29a08..b2c5d4e935a5 100644
--- a/litmus/ce_domain.c
+++ b/litmus/ce_domain.c
@@ -59,7 +59,8 @@ struct task_struct* ce_peek_and_take_ready(domain_t *dom)
         struct task_struct *ret = NULL, *sched = ce_data->should_schedule;
         const int exists = NULL != sched;
         const int blocked = exists && !is_running(sched);
-        const int elig = exists && tsk_mc_data(sched)->mc_task.lvl_a_eligible;
+        const int elig = exists && tsk_mc_data(sched) &&
+                tsk_mc_data(sched)->mc_task.lvl_a_eligible;
 
         /* Return the task we should schedule if it is not blocked or sleeping. */
         if (exists && !blocked && elig)
diff --git a/litmus/event_group.c b/litmus/event_group.c
index 81bc87e98bbd..06520299fb1d 100644
--- a/litmus/event_group.c
+++ b/litmus/event_group.c
@@ -30,15 +30,18 @@ static unsigned int time2slot(lt_t time)
 static enum hrtimer_restart on_timer(struct hrtimer *timer)
 {
         int prio, num;
+        unsigned long flags;
         struct event_list *el;
         struct rt_event *e;
         struct list_head *pos, events[NUM_EVENT_PRIORITIES];
         raw_spinlock_t *queue_lock;
 
+        QT_START;
+
         el = container_of(timer, struct event_list, timer);
         queue_lock = &el->group->queue_lock;
 
-        raw_spin_lock(queue_lock);
+        raw_spin_lock_irqsave(queue_lock, flags);
 
         /* Remove event_list from hashtable so that no more events
          * are added to it.
@@ -65,18 +68,21 @@ static enum hrtimer_restart on_timer(struct hrtimer *timer)
 
                         e = list_entry(pos, struct rt_event, events_node);
                         list_del_init(pos);
-                        raw_spin_unlock(queue_lock);
+                        raw_spin_unlock_irqrestore(queue_lock, flags);
 
                         VTRACE("Dequeueing event 0x%x with prio %d from 0x%x\n",
                                e, e->prio, el);
                         e->function(e);
 
-                        raw_spin_lock(queue_lock);
+                        raw_spin_lock_irqsave(queue_lock, flags);
                 }
         }
-        raw_spin_unlock(queue_lock);
+        raw_spin_unlock_irqrestore(queue_lock, flags);
 
         VTRACE("Exhausted %d events from list 0x%x\n", num, el);
+
+        QT_END;
+
         return HRTIMER_NORESTART;
 }
 
@@ -165,6 +171,8 @@ void add_event(struct event_group *group, struct rt_event *e, lt_t fire)
         struct event_list *el;
         int in_use;
 
+        QT_START;
+
         VTRACE("Adding event 0x%x with priority %d for time %llu\n",
                e, e->prio, fire);
 
@@ -199,6 +207,8 @@ void add_event(struct event_group *group, struct rt_event *e, lt_t fire)
         } else {
                 VTRACE("Not my timer @%llu\n", fire);
         }
+
+        QT_END;
 }
 
 /**
@@ -212,6 +222,8 @@ void cancel_event(struct rt_event *e)
         struct event_group *group;
         struct list_head *list, *pos;
 
+        QT_START;
+
         VTRACE("Canceling event 0x%x with priority %d\n", e, e->prio);
         group = e->_event_group;
         if (!group) return;
@@ -258,6 +270,7 @@ void cancel_event(struct rt_event *e)
         e->_event_group = NULL;
 
         raw_spin_unlock(&group->queue_lock);
+        QT_END;
 }
 
 struct kmem_cache *event_list_cache;
diff --git a/litmus/rt_domain.c b/litmus/rt_domain.c
index 3355eb5a73be..24b7a260e95b 100644
--- a/litmus/rt_domain.c
+++ b/litmus/rt_domain.c
@@ -405,6 +405,8 @@ static void pd_requeue(domain_t *dom, struct task_struct *task)
 {
         rt_domain_t *domain = (rt_domain_t*)dom->data;
 
+        QT_START;
+
         BUG_ON(!task || !is_realtime(task));
         TRACE_TASK(task, "Requeueing\n");
         BUG_ON(is_queued(task));
@@ -420,6 +422,8 @@ static void pd_requeue(domain_t *dom, struct task_struct *task)
                 VTRACE_TASK(task, "add release(), rel=%llu\n", get_release(task));
                 add_release(domain, task);
         }
+
+        QT_END;
 }
 
 /* pd_take_ready - removes and returns the next ready task from the rt_domain
diff --git a/litmus/sched_mc.c b/litmus/sched_mc.c
index 5067b79b026b..9edf038ef164 100644
--- a/litmus/sched_mc.c
+++ b/litmus/sched_mc.c
@@ -492,6 +492,9 @@ static void check_for_preempt(struct domain *dom)
                         entry = crit_cpu(ce);
                         recheck = 1;
 
+                        /* Cache ready task */
+                        dom->peek_ready(dom);
+
                         raw_spin_lock(&entry->lock);
                         if (!can_use(ce))
                                 /* CPU disabled while locking! */
@@ -530,6 +533,8 @@ static void remove_from_all(struct task_struct* task)
         struct crit_entry *ce;
         struct domain *dom = get_task_domain(task);
 
+        QT_START;
+
         TRACE_MC_TASK(task, "Removing from everything\n");
         BUG_ON(!task);
 
@@ -551,7 +556,7 @@ static void remove_from_all(struct task_struct* task)
                                 link_task_to_cpu(entry, NULL);
                         }
                 } else {
-                        TRACE_MC_TASK(task, "Unlinked before we got lock!");
+                        TRACE_MC_TASK(task, "Unlinked before we got lock!\n");
                 }
                 if (update)
                         update_crit_levels(entry);
@@ -566,6 +571,7 @@ static void remove_from_all(struct task_struct* task)
 
         BUG_ON(is_queued(task));
         raw_spin_unlock(dom->lock);
+        QT_END;
 }
 
 /**
@@ -663,6 +669,7 @@ static lt_t __ce_timer_function(struct ce_dom_data *ce_data)
         struct domain *dom = ce->domain;
         struct task_struct *old_link = NULL;
         lt_t next_timer_abs;
+        QT_START;
 
         TRACE("MC level-A timer callback for CPU %d\n", ce_data->cpu);
 
@@ -692,6 +699,7 @@ static lt_t __ce_timer_function(struct ce_dom_data *ce_data)
                 raw_spin_unlock(dom->lock);
                 check_for_preempt(dom);
         }
+        QT_END;
         return next_timer_abs;
 }
 
@@ -734,11 +742,15 @@ static void mc_release_jobs(rt_domain_t* rt, struct bheap* tasks)
         struct task_struct *first = bheap_peek(rt->order, tasks)->value;
         struct domain *dom = get_task_domain(first);
 
+        QT_START;
+
         raw_spin_lock_irqsave(dom->lock, flags);
         TRACE(TS "Jobs released\n", TA(first));
         __merge_ready(rt, tasks);
         check_for_preempt(dom);
         raw_spin_unlock_irqrestore(dom->lock, flags);
+
+        QT_END;
 }
 
 /**
@@ -877,6 +889,7 @@ static struct task_struct* mc_schedule(struct task_struct* prev)
         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;
+        QT_START;
 
         local_irq_save(flags);
         raw_spin_lock(&entry->lock);
@@ -944,12 +957,15 @@ static struct task_struct* mc_schedule(struct task_struct* prev)
                  */
                 raw_spin_unlock(&entry->lock);
                 raw_spin_lock(dom->lock);
+
+                /* Peek at task here to avoid lock use */
+                dtask = dom->peek_ready(dom);
+
                 raw_spin_lock(&entry->lock);
 
                 /* Now that we hold the domain lock...*/
                 fix_crit_position(ce);
 
-                dtask = dom->peek_ready(dom);
                 if (!entry->linked && !ce->linked && dtask && can_use(ce)) {
                         dom->take_ready(dom);
                         link_task_to_crit(ce, dtask);
@@ -977,9 +993,10 @@ static struct task_struct* mc_schedule(struct task_struct* prev)
         raw_spin_unlock(&entry->lock);
         local_irq_restore(flags);
         if (next) {
-                TRACE_TASK(next, "Picked this task\n");
+                TRACE_MC_TASK(next, "Picked this task\n");
         } else if (exists && !next)
                 TRACE_ENTRY(entry, "Becomes idle at %llu\n", litmus_clock());
+        QT_END;
         return next;
 }
 
@@ -987,7 +1004,7 @@ void mc_finish_switch(struct task_struct *prev)
 {
         struct cpu_entry* entry = &__get_cpu_var(cpus);
         entry->scheduled = is_realtime(current) ? current : NULL;
-        TRACE_TASK(prev, "Switched away from to " TS,
+        TRACE_TASK(prev, "Switched away from to " TS "\n",
                    TA(entry->scheduled));
 }