Bug fixes

4 files changed, 62 insertions, 47 deletions

diff --git a/kernel/hrtimer.c b/kernel/hrtimer.c
index cb49883b64e5..805ac8701723 100644
--- a/kernel/hrtimer.c
+++ b/kernel/hrtimer.c
@@ -1062,7 +1062,7 @@ void hrtimer_pull(void)
 {
         struct hrtimer_cpu_base *base = &__get_cpu_var(hrtimer_bases);
         struct hrtimer_start_on_info *info;
-        struct list_head *pos, *safe, list;
+        struct list_head *pos, *safe, *prev, list;
 
         raw_spin_lock(&base->lock);
         list_replace_init(&base->to_pull, &list);
@@ -1073,6 +1073,8 @@ void hrtimer_pull(void)
                 TRACE("pulled timer 0x%x\n", info->timer);
                 list_del(pos);
                 hrtimer_start(info->timer, info->time, info->mode);
+                atomic_set(&info->state, HRTIMER_START_ON_INACTIVE);
+                prev = pos;
         }
 }
 
diff --git a/litmus/litmus.c b/litmus/litmus.c
index c4f899510900..38f276d67095 100644
--- a/litmus/litmus.c
+++ b/litmus/litmus.c
@@ -368,12 +368,12 @@ void litmus_exit_task(struct task_struct* tsk)
 
                 litmus->task_exit(tsk);
 
-                BUG_ON(bheap_node_in_heap(tsk_rt(tsk)->heap_node));
-                bheap_node_free(tsk_rt(tsk)->heap_node);
-                release_heap_free(tsk_rt(tsk)->rel_heap);
-
-                atomic_dec(&rt_task_count);
-                reinit_litmus_state(tsk, 1);
+                if (!bheap_node_in_heap(tsk_rt(tsk)->heap_node)) {
+                        bheap_node_free(tsk_rt(tsk)->heap_node);
+                        release_heap_free(tsk_rt(tsk)->rel_heap);
+                        atomic_dec(&rt_task_count);
+                        reinit_litmus_state(tsk, 1);
+                }
         }
 }
 
diff --git a/litmus/sched_edf_hsb.c b/litmus/sched_edf_hsb.c
index 7f944d1d97f0..70e254981861 100644
--- a/litmus/sched_edf_hsb.c
+++ b/litmus/sched_edf_hsb.c
@@ -15,14 +15,15 @@
  * stop_[hrt|be]_servers
  * admit_[hrt|be]_server
  *
- * TODO BE SERVER TASK PREEMPTGION A;SDIFHSAKEUHFLKH
- * TODO BE server heap needed?
+ * TODO system for removing tasks from their release queues
+ * TODO clean up link_task_to_cpu and check_slack args
  * TODO move slack completion into release
  * TODO fix concurrent arms
  * TODO slack and BE servers, include slack higher prio
  * TODO start servers should no longer be cessary
  * TODO harmonize order of method arguments
  * TODO test crazy task_new hack
+ * TODO remove bheap_node_in_heap check in litmus_exit_task
  */
 #include <linux/module.h>
 #include <linux/uaccess.h>
@@ -361,7 +362,8 @@ static void check_slack_candidate(struct task_struct *task)
             /* The task has yet to be released */
             lt_after(get_release(task), litmus_clock()) &&
             /* The task didn't just complete */
-            get_rt_flags(task) != RT_F_SLEEP &&
+            !(get_rt_flags(task) == RT_F_SLEEP && task_srt_server(task)->job_no ==
+              task_job_no(task)) &&
             /* The task hasn't already been added to the list */
             !head_in_list(&task_data(task)->candidate_list)) {
 
@@ -598,33 +600,33 @@ static void reclaim_slack(server_t *slack)
         BUG_ON(!slack->wcet);
         BUG_ON(!donator->budget);
 
-        donator->budget -= exec;
+        donator->budget = lt_subtract(donator->budget, exec);
         slack->wcet = slack->budget;
 
         /* If budget exhausted, server needs to wait for next release */
         if (!donator->budget) {
                 TRACE_SERVER_SUB(donator, "exhausted by slack");
-                if (donator->type == S_HRT) {
-                        hrt_server = container_of(donator,
-                                                  hrt_server_t,
-                                                  server);
-                        BUG_ON(!hrt_server->ready);
-                        TRACE_SERVER_SUB(donator, "no longer ready");
-                        hrt_server->ready = 0;
-                        slack_timer_cancel(hrt_server);
-                } else if (donator->type == S_BE) {
-                        TRACE_SERVER_SUB(donator, "BE removed from ready");
-                        bheap_delete(server_order, &be_ready_servers,
-                                     donator->hn);
-                }
+                /* if (donator->type == S_HRT) { */
+                /*      hrt_server = container_of(donator, */
+                /*                                hrt_server_t, */
+                /*                                server); */
+                /*      /\* BUG_ON(!hrt_server->ready); *\/ */
+                /*      /\* TRACE_SERVER_SUB(donator, "exhausted"); *\/ */
+                /*      /\* hrt_server->ready = 0; *\/ */
+                /*      /\* slack_timer_cancel(hrt_server); *\/ */
+                /* } else if (donator->type == S_BE) { */
+                /*      TRACE_SERVER_SUB(donator, "BE removed from ready"); */
+                /*      /\* bheap_delete(server_order, &be_ready_servers, *\/ */
+                /*      /\*          donator->hn); *\/ */
+                /* } */
 
-                /* Prepare servers for their next period. SRT servers are
-                 * handled with their SRT tasks and don't need assistance.
-                 */
-                if (donator->type != S_SRT) {
-                        server_release(donator);
-                        requeue_server(donator);
-                }
+                /* /\* Prepare servers for their next period. SRT servers are */
+                /*  * handled with their SRT tasks and don't need assistance. */
+                /*  *\/ */
+                /* if (donator->type != S_SRT) { */
+                /*      /\* server_release(donator); *\/ */
+                /*      /\* requeue_server(donator); *\/ */
+                /* } */
         }
 }
 
@@ -721,7 +723,7 @@ static noinline void link_task_to_cpu(cpu_entry_t *entry,
 
         BUG_ON(linked && !is_realtime(linked));
         BUG_ON(linked && is_hrt(linked) && entry->cpu != task_cpu(linked));
-        BUG_ON(entry->cpu == edf_hsb_release_master);
+        BUG_ON(entry->cpu == edf_hsb_release_master); 
 
         if (linked)
                 TRACE_TASK_SERVER_SUB(linked, next_server, "linking to P%d",
@@ -963,7 +965,9 @@ static struct task_struct* next_eligible_srt(void)
          * task blocked while it was being run by a slack server.
          * Remove and ignore this task.
          */
-        while (next_srt && !is_running(next_srt)) {
+        while (next_srt && (!is_running(next_srt) ||
+                            unlikely(!is_realtime(next_srt)))) {
+                TRACE_TASK_SUB(next_srt, "removing blocking task");
                 remove(&srt_domain, next_srt);
                 next_srt = __peek_ready(&srt_domain);
         }
@@ -1191,7 +1195,7 @@ static void check_for_slack_preempt(struct task_struct*,server_t*,cpu_entry_t*,
  */
 static void edf_hsb_pick_next(cpu_entry_t *entry)
 {
-        struct task_struct *next_task;
+        struct task_struct *next_task, *linked;
         server_t *next_server;
 
         BUG_ON(entry->linked);
@@ -1209,11 +1213,16 @@ static void edf_hsb_pick_next(cpu_entry_t *entry)
                 TRACE_TASK_SERVER_SUB(next_task, next_server,
                                       "removing and picked");
 
-                /* Force the link to go to the CPU we ask for since we are
-                 * trying to reschedule for this CPU only.
+                /* A slack preemption could cause something that was already
+                 * running to be 'swapped' to this CPU in link_task_to_cpu.
                  */
-                link_task_to_cpu(entry, next_task, next_server,
-                                 0 /* Always link to what we want */);
+                if (entry->linked) {
+                        linked = entry->linked;
+                        unlink(entry->linked);
+                        requeue(linked, get_rt_domain(entry, linked));
+                        TRACE_TASK_SUB(linked, "preempted next pick");
+                }
+                link_task_to_cpu(entry, next_task, next_server, 1);
         }
 }
 
@@ -1224,14 +1233,16 @@ static void edf_hsb_pick_next(cpu_entry_t *entry)
 static void preempt(cpu_entry_t *entry, struct task_struct *next,
                     server_t *next_server, int slack_resched)
 {
-        struct task_struct *linked = entry->linked;
+        struct task_struct *linked;
         rt_domain_t *domain;
 
         TRACE_TASK_SERVER_SUB(next, next_server,
                               "preempting on P%d", entry->cpu);
 
         remove_from_ready(next_server, next, entry);
+
         check_for_slack_preempt(next, next_server, entry, slack_resched);
+        linked = entry->linked;
         link_task_to_cpu(entry, next, next_server, 1);
 
         /* No need for this if only the server was preempted */
@@ -1250,9 +1261,9 @@ static void preempt(cpu_entry_t *entry, struct task_struct *next,
  * 2. slack donated by server is running a task on a different CPU
  */
 static void check_for_slack_preempt(struct task_struct *task,
-                                    server_t *server,
-                                    cpu_entry_t *next_entry,
-                                    int resched)
+                                   server_t *server,
+                                   cpu_entry_t *next_entry,
+                                   int resched)
 {
         cpu_entry_t *entry = NULL;
         server_t *slack = server_slack(server);
@@ -1986,8 +1997,10 @@ static struct task_struct* edf_hsb_schedule(struct task_struct *prev)
         /* Bail out early if we are the release master.
          * The release master never schedules any real-time tasks.
          */
-        if (edf_hsb_release_master == entry->cpu)
+        if (edf_hsb_release_master == entry->cpu) {
+                sched_state_task_picked();
                 return NULL;
+        }
 #endif
 
         raw_spin_lock_irqsave(global_lock, flags);
@@ -2129,6 +2142,7 @@ static void edf_hsb_task_wake_up(struct task_struct *task)
         unsigned long flags;
         cpu_entry_t *entry = task_sched_entry(task);
 
+
         TRACE_TASK(task, "wake_up at %llu on %d, %d\n", TIME(litmus_clock()),
                    task_cpu(task), task->rt_param.task_params.cpu);
 
diff --git a/litmus/servers.c b/litmus/servers.c
index 5bd0e3c937a9..577c83662357 100644
--- a/litmus/servers.c
+++ b/litmus/servers.c
@@ -91,7 +91,6 @@ static int completion_timer_arm(server_domain_t* domain, int cpu)
                 TRACE_SUB(server, "cannot arm completion, already active");
                 return 0;
         }
-
         if (domain->completion_timers[cpu].armed) {
                 TRACE_SUB(server, "cannot arm completion, waiting for arm");
                 return 0;
@@ -110,8 +109,6 @@ static int completion_timer_arm(server_domain_t* domain, int cpu)
                 on_cpu = cpu;
 
         if (cpu != smp_processor_id()) {
-                atomic_set(&domain->completion_timers[cpu].info.state,
-                           HRTIMER_START_ON_INACTIVE);
                 err = hrtimer_start_on(on_cpu,
                                        &domain->completion_timers[cpu].info,
                                        &domain->completion_timers[cpu].timer,
@@ -132,7 +129,9 @@ static int completion_timer_arm(server_domain_t* domain, int cpu)
 
         domain->completion_timers[cpu].armed = 1;
 
-        TRACE_SUB(server, "completion armed to fire at %llu",
+        TRACE_SUB(server, "completion 0x%x and %p armed to fire at %llu",
+                  &domain->completion_timers[cpu].timer,
+                  &domain->completion_timers[cpu].timer,
                   TIME(budget_exhausted));
 
         return 1;