Minor bugfixes involving server linkage

2 files changed, 31 insertions, 12 deletions

diff --git a/litmus/Makefile b/litmus/Makefile
index 4bc14b8e3a3d..62c2bb064581 100644
--- a/litmus/Makefile
+++ b/litmus/Makefile
@@ -18,7 +18,6 @@ obj-y     = sched_plugin.o litmus.o \
             ctrldev.o \
             servers.o \
             sched_gsn_edf.o \
-            sched_psn_edf.o \
             sched_edf_hsb.o
 
 obj-$(CONFIG_PLUGIN_CEDF) += sched_cedf.o
diff --git a/litmus/sched_edf_hsb.c b/litmus/sched_edf_hsb.c
index c71c00df68df..fcad1072632a 100644
--- a/litmus/sched_edf_hsb.c
+++ b/litmus/sched_edf_hsb.c
@@ -239,11 +239,11 @@ static void server_slack_destroy(server_t *donator)
 
 static void remove_slack(server_t *slack)
 {
+        if (!slack)
+                return;
         TRACE_SERVER_SUB(slack, "slack removed");
         //sched_trace_action(NULL, SLACK_EXPIRED_ACTION);
 
-        BUG_ON(!slack);
-
         if (head_in_list(&slack->list))
                 list_del_init(&slack->list);
         slack->deadline = 0;
@@ -261,8 +261,8 @@ static void add_slack(server_t *slack)
 
         TRACE_SERVER_SUB(slack, "slack added");
 
-        BUG_ON(head_in_list(&slack->list));
-
+        if (head_in_list(&slack->list))
+                return;
 
         list_for_each_prev(pos, &slack_queue) {
                 queued = list_entry(pos, server_t, list);
@@ -402,7 +402,8 @@ static noinline server_t* next_eligible_slack_server(void)
                 BUG_ON(!next_slack);
 
                 if (lt_after(next_slack->deadline, litmus_clock()) &&
-                    lt_after(next_slack->budget, SLACK_MIN)) {
+                    lt_after(next_slack->budget, SLACK_MIN) &&
+                    !is_server_linked(next_slack)) {
                         break;
                 } else {
                         /* Slack has expired or has too little time */
@@ -926,7 +927,7 @@ static inline int is_eligible(struct task_struct *task,
                        hrt_server->ready, hrt_server->no_slack,
                        hrt_server->server.deadline,
                        get_deadline(task));
-        return hrt_server->ready &&
+        return hrt_server->ready && !is_server_linked(&hrt_server->server) &&
                 (hrt_server->no_slack ||
                  lt_after_eq(hrt_server->server.deadline, get_deadline(task)));
 }
@@ -936,8 +937,10 @@ static inline int is_eligible(struct task_struct *task,
  */
 static inline void catchup_server(server_t *server, lt_t time)
 {
-        lt_t diff = time - server->deadline;
-        lt_t sub  = diff % server->period;
+        lt_t diff, sub;
+
+        diff = time - server->deadline;
+        sub  = diff % server->period;
 
         server_release_at(server, time - sub);
         TRACE_SERVER_SUB(server, "catching up to %llu", time);
@@ -1105,6 +1108,9 @@ static noinline struct task_struct* next_eligible_srt(void)
                         if (!done) {
                                 remove(&srt_domain, next_srt);
                                 __add_ready(&srt_domain, next_srt);
+                        } else if (is_server_linked(task_srt_server(next_srt))){
+                                remove(&srt_domain, next_srt);
+                                done = 0;
                         }
                 } else {
                         done = 1;
@@ -1128,9 +1134,20 @@ static noinline server_t* next_eligible_be_server(void)
         /* Catch up any late be servers. This happens when the servers could
          * not find tasks to schedule or if the system is overutilized.
          */
-        while (be_server && lt_before_eq(be_server->deadline, now)) {
+        while (be_server && (lt_before_eq(be_server->deadline, now) ||
+                             is_server_linked(be_server))) {
+                if (!be_server->deadline) {
+                        TRACE_SERVER_SUB(be_server, "not intialized");
+                        return NULL;
+                }
                 bheap_delete(server_order, &be_ready_servers,
                              be_server->hn);
+
+                if (is_server_linked(be_server)) {
+                        TRACE_SERVER_SUB(be_server, "linked");
+                        continue;
+                }
+
                 catchup_server(be_server, now);
                 check_donate_slack(be_server, NULL);
                 bheap_insert(server_order, &be_ready_servers,
@@ -1141,6 +1158,7 @@ static noinline server_t* next_eligible_be_server(void)
         }
 
         if (be_server && lt_before(now, be_server->release)) {
+                TRACE_SERVER_SUB(be_server, "not released");
                 be_server = NULL;
         }
 
@@ -1734,6 +1752,7 @@ static void server_completed(server_t *server, struct task_struct *task)
         cpu_entry_t *entry = task_linked_entry(task);
 
         BUG_ON(entry->linked != task);
+        BUG_ON(entry->linked_server != server);
 
         if (server->type == S_SRT) {
                 TRACE_TASK_SUB(task, "must wait on server");
@@ -1873,6 +1892,7 @@ static int admit_be_server(unsigned long long wcet,
 
         list_add(&be_server->list, &be_servers);
         bheap_insert(server_order, &be_ready_servers, be_server->hn);
+
  out:
         return rv;
 }
@@ -2016,8 +2036,8 @@ static void start_servers(lt_t time)
         list_for_each(pos, &be_servers) {
                 be_server = list_entry(pos, server_t, list);
 
-                BUG_ON(bheap_node_in_heap(be_server->hn));
-                bheap_insert(server_order, &be_ready_servers, be_server->hn);
+                if (!bheap_node_in_heap(be_server->hn))
+                        bheap_insert(server_order, &be_ready_servers, be_server->hn);
 
                 /* Cause a catchup later */
                 server_release_at(be_server, time - be_server->period);