Fixed BE server bugs.

2 files changed, 67 insertions, 39 deletions

diff --git a/litmus/sched_edf_hsb.c b/litmus/sched_edf_hsb.c
index adbcc2551280..49cc75d9ea81 100644
--- a/litmus/sched_edf_hsb.c
+++ b/litmus/sched_edf_hsb.c
@@ -176,7 +176,7 @@ static struct sched_plugin edf_hsb_plugin __cacheline_aligned_in_smp;
 #define task_job_no(task)       (tsk_rt(task)->job_params.job_no)
 #define task_data(task)         ((task_data_t*)tsk_rt(task)->plugin_data)
 #define task_srt_server(task)   ((server_t*)task_data(task)->srt_server)
-#define server_slack(s)         ((server_t*)s->data)
+#define server_slack(s)         ((server_t*)(s)->data)
 #define server_has_slack(s)     (server_slack(s)->deadline != 0)
 #define local_cpu_entry         (&__get_cpu_var(cpu_entries))
 #define global_lock             (&srt_domain.ready_lock)
@@ -332,6 +332,7 @@ static void donate_slack(server_t *donator)
  */
 static void check_donate_slack(server_t *donator, struct task_struct *was_scheduled)
 {
+        server_t *slack = server_slack(donator);
         hrt_server_t *hrt_server;
         int donate = 0;
 
@@ -342,7 +343,6 @@ static void check_donate_slack(server_t *donator, struct task_struct *was_schedu
                 return;
 
         if (server_has_slack(donator)) {
-                server_t *slack = server_slack(donator);
                 TRACE_SERVER_SUB(donator, "dead: %d, rel: %d, job: %d already donated",
                                  slack->deadline, slack->release, slack->job_no);
                 return;
@@ -592,6 +592,7 @@ static void requeue_server(server_t *server, lt_t now)
                         TRACE_SERVER_SUB(server, "P%d now ready at %llu", now);
                         hrt_server = container_of(server, hrt_server_t, server);
                         hrt_server->ready = 1;
+                        remove_slack(server_slack(server));
                         hrt_server->no_slack = 0;
                         sched_trace_action(NULL, SERVER_RELEASED_ACTION);
                 } else if (server->type == S_BE) {
@@ -644,6 +645,7 @@ static noinline void link_server(cpu_entry_t *entry,
                         BUG_ON(next_server->job_no + 1 < task_job_no(entry->linked));
                         BUG_ON(lt_after(get_deadline(entry->linked),
                                         next_server->deadline));
+                        BUG_ON(head_in_list(&task_data(entry->linked)->candidate_list));
                 } else if (next_server->type == S_HRT) {
                         /* HRT servers should never, ever migrate */
                         BUG_ON(entry->cpu != task_cpu(entry->linked));
@@ -651,10 +653,12 @@ static noinline void link_server(cpu_entry_t *entry,
                 } else if (next_server->type == S_SLACK) {
                         /* Should have already been removed from slack list */
                         BUG_ON(head_in_list(&task_data(entry->linked)->candidate_list));
+                        BUG_ON(is_be(entry->linked) && is_queued(entry->linked));
                         sched_trace_action(entry->linked, SLACK_RUN_ACTION);
                 } else { /* BE */
                         /* Should have already been removed from ready heap */
                         BUG_ON(bheap_node_in_heap(next_server->hn));
+                        BUG_ON(is_queued(entry->linked));
                         sched_trace_action(entry->linked, next_server->id);
                 }
 
@@ -832,7 +836,7 @@ static noinline void unlink(struct task_struct* t)
 
                 if (head_in_list(&task_data(t)->candidate_list)) {
                         list_del_init(&task_data(t)->candidate_list);
-                }
+                }
 
                 entry = task_sched_entry(t);
 
@@ -860,7 +864,6 @@ static noinline void unlink(struct task_struct* t)
                         remove(get_rt_domain(entry, t), t);
                         BUG_ON(is_queued(t));
                 }
-
         }
 }
 
@@ -999,8 +1002,9 @@ static struct task_struct* next_eligible_hrt(hrt_server_t *hrt_server)
                 slack = lt_subtract(dead, budget);
                 budget = hrt_server->server.budget;
 
-                TRACE_SERVER_SUB(&hrt_server->server, "dead: %llu, budget: %llu",
-                                 TIME(dead), TIME(budget));
+                TRACE_SERVER_SUB(&hrt_server->server, "dead: %llu, budget: %llu"
+                                 "now: %llu, slack: %llu",
+                                 TIME(dead), TIME(budget), TIME(now), TIME(slack));
 
                 if (!head_in_list(&hrt_server->server.release_list) &&
                     lt_before_eq(dead, now)) {
@@ -1008,6 +1012,7 @@ static struct task_struct* next_eligible_hrt(hrt_server_t *hrt_server)
                         catchup_server(&hrt_server->server, now);
                         TRACE_SERVER_SUB(&hrt_server->server, "now ready");
                         hrt_server->ready = 1;
+                        remove_slack(server_slack(&hrt_server->server));
                         hrt_server->no_slack = 0;
 
                         slack = lt_subtract(hrt_server->server.deadline,
@@ -1017,10 +1022,11 @@ static struct task_struct* next_eligible_hrt(hrt_server_t *hrt_server)
                 }
 
                 /* If the slack timer is active, this is not necessary */
-                if (!hrtimer_active(&hrt_server->slack_timer)) {
+                if (!hrtimer_active(&hrt_server->slack_timer) && hrt_server->ready) {
                         if (lt_before_eq(slack, now) && !hrt_server->no_slack) {
                                 /* The server missed the shift to no slack */
-                                TRACE_SERVER_SUB(&hrt_server->server, "now no slack");
+                                TRACE_SERVER_SUB(&hrt_server->server, "no slack: %llu",
+                                                 TIME(slack));
                                 hrt_server->no_slack = 1;
                                 sched_trace_action(task, NO_SLACK_ACTION);
                         } else {
@@ -1109,7 +1115,7 @@ static inline server_t* next_be_server(void)
         return (hn) ? hn->value : NULL;
 }
 
-static server_t* next_eligible_be_server(void)
+static noinline server_t* next_eligible_be_server(void)
 {
         server_t *be_server = next_be_server();
         lt_t now = litmus_clock();
@@ -1125,6 +1131,7 @@ static server_t* next_eligible_be_server(void)
                              be_server->hn);
 
                 be_server = next_be_server();
+                TRACE_SERVER_SUB(be_server, "catching up BE server");
                 sched_trace_action(NULL, SERVER_RELEASED_ACTION); /* Release */
         }
 
@@ -1132,6 +1139,12 @@ static server_t* next_eligible_be_server(void)
                 be_server = NULL;
         }
 
+        if (be_server) {
+                TRACE_SERVER_SUB(be_server, "dead: %llu, rel: %llu, budget: %llu",
+                                 be_server->deadline, be_server->release,
+                                 be_server->budget);
+        }
+
         return be_server;
 }
 
@@ -1363,8 +1376,8 @@ static void preempt(cpu_entry_t *entry, struct task_struct *next,
 
         remove_from_ready(next_server, next, entry);
 
-        check_for_slack_preempt(next, next_server, entry, slack_resched);
         linked = entry->linked;
+        check_for_slack_preempt(next, next_server, entry, slack_resched);
         link_to_cpu(entry, next, next_server);
 
         /* No need for this if only the server was preempted */
@@ -1382,7 +1395,7 @@ static void preempt(cpu_entry_t *entry, struct task_struct *next,
  * 1. task is being run by a slack server on a different CPU
  * 2. slack donated by server is running a task on a different CPU
  */
-static void check_for_slack_preempt(struct task_struct *task,
+static noinline void check_for_slack_preempt(struct task_struct *task,
                                     server_t *server,
                                     cpu_entry_t *next_entry,
                                     int resched)
@@ -1397,6 +1410,23 @@ static void check_for_slack_preempt(struct task_struct *task,
 
                 if (entry != next_entry) {
                         TRACE_TASK_SUB(task, "was on P%d", entry->cpu);
+                        BUG_ON(entry->linked_server->type != S_SLACK &&
+                               server->type == S_SLACK && entry->linked_server->type == S_BE);
+
+                        TRACE_SUB("hi");
+
+                        BUG_ON(entry->linked_server->type != S_SLACK &&
+                               server->type == S_SRT && entry->linked_server->type == S_SRT);
+
+                        TRACE_SUB("hi");
+
+                        BUG_ON(entry->linked_server->type != S_SLACK &&
+                               server->type == S_SRT);
+
+                        TRACE_SUB("hi");
+
+                        BUG_ON(entry->linked_server->type == S_BE && server->type == S_BE);
+
                         BUG_ON(entry->linked_server->type != S_SLACK);
 
                         unlink(task);
@@ -1471,15 +1501,6 @@ static void check_for_global_preempt(void)
                                 TRACE_TASK_SUB(next_task,
                                                "Already on P%d",
                                                sched->cpu);
-
-                                if (entry->linked) {
-                                        requeue(entry->linked,
-                                                get_rt_domain(entry,
-                                                              entry->linked));
-                                        unlink(entry->linked);
-                                }
-                                preempt_if_preemptable(entry->scheduled,
-                                                       entry->cpu);
                                 break;
                         }
                 }
@@ -1770,6 +1791,7 @@ static void hrt_server_released(server_t *server)
 
         hrt_server->no_slack = 0;
         hrt_server->ready = 1;
+        remove_slack(&hrt_server->server);
 
         check_for_hrt_preempt(entry);
 
@@ -1843,6 +1865,9 @@ static int admit_be_server(unsigned long long wcet,
                     wcet, period, 1);
         be_server->type = S_BE;
         server_slack_create(be_server);
+
+        TRACE_SERVER_SUB(be_server, "admitted BE server");
+
         list_add(&be_server->list, &be_servers);
  out:
         return rv;
@@ -1872,6 +1897,8 @@ static void stop_be_servers(void)
 
         //atomic_set(&servers_running, 0);
 
+        TRACE_SUB("stopping BE servers");
+
         list_for_each_safe(pos, safe, &be_servers) {
                 be_server = list_entry(pos, server_t, list);
 
@@ -2143,7 +2170,7 @@ static void edf_hsb_task_exit(struct task_struct *task)
 static struct task_struct* edf_hsb_schedule(struct task_struct *prev)
 {
         unsigned long flags;
-        int blocks, preempted, sleep, was_slack, np, srt_preempt, donated;
+        int blocks, preempted, sleep, was_slack, np, hrt_preempt, donated;
         struct task_struct *curr;
         cpu_entry_t *entry = local_cpu_entry;
 
@@ -2209,16 +2236,17 @@ static struct task_struct* edf_hsb_schedule(struct task_struct *prev)
         entry->scheduled_server = entry->linked_server;
         sched_state_task_picked();
 
-        /* An SRT was preempted by an HRT task. Due to the linking logic,
-         * the SRT cannot check for a preemption until it is descheduled.
+        /* An non-HRT was preempted by an HRT task. Because of the way linking
+         * works, it cannot link itself to anything else until the non-migratory
+         * HRT task is scheduled.
          */
-        srt_preempt = preempted && entry->linked && curr &&
+        hrt_preempt = preempted && entry->linked && curr &&
                 is_hrt(entry->linked) && !is_hrt(curr);
         /* A server just donated slack */
         donated = entry->linked && entry->linked_server->type != S_SLACK &&
                 head_in_list(&server_slack(entry->linked_server)->list);
 
-        if (srt_preempt || donated)
+        if (hrt_preempt || donated)
                 check_for_global_preempt();
 
         if (entry->scheduled)
@@ -2273,7 +2301,7 @@ static void edf_hsb_task_new(struct task_struct *task, int on_rq,  int running)
          * This tends to happen when the first tasks enter the system.
          */
         if (running) {
-                BUG_ON(entry->scheduled);
+                //BUG_ON(entry->scheduled);
 
 #ifdef CONFIG_RELEASE_MASTER
                 if (entry->cpu != edf_hsb_release_master) {
diff --git a/litmus/servers.c b/litmus/servers.c
index e0cc79e7a74b..5aebbe5ec1c1 100644
--- a/litmus/servers.c
+++ b/litmus/servers.c
@@ -486,19 +486,19 @@ static int server_proc_write(struct file *file, const char __user *input,
                                         "server config: %s\n", pos);
                         goto loop_end;
                 }
-                space_check = pos + chars_seen;
-                if (space_check != newline) {
-                        /* If the newline was not right after the numbers
-                         * converted, ensure extra characters are just space
-                         */
-                        for (; *space_check; space_check++) {
-                                if (!isspace(*space_check)) {
-                                        printk(KERN_WARNING "Extra characters "
-                                                        "in line: %s\n", pos);
-                                        goto loop_end;
-                                }
-                        }
-                }
+                /* space_check = pos + chars_seen; */
+                /* if (space_check != newline) { */
+                /*      /\* If the newline was not right after the numbers */
+                /*       * converted, ensure extra characters are just space */
+                /*       *\/ */
+                /*      for (; *space_check; space_check++) { */
+                /*              if (!isspace(*space_check)) { */
+                /*                      printk(KERN_WARNING "Extra characters " */
+                /*                                      "in line: %s\n", pos); */
+                /*                      goto loop_end; */
+                /*              } */
+                /*      } */
+                /* } */
 
                 ret = server_param_check(wcet, period, cpu);
                 if (ret) goto loop_end;