fix minor bugs. there is still a bug in GEDF PAI.

3 files changed, 50 insertions, 33 deletions

diff --git a/include/litmus/fpmath.h b/include/litmus/fpmath.h
index ba4121eaa1bf..04d4bcaeae96 100644
--- a/include/litmus/fpmath.h
+++ b/include/litmus/fpmath.h
@@ -19,8 +19,10 @@ typedef struct
 
 #define _fp(x) ((fp_t) {x})
 
+#ifdef __KERNEL__
 static const fp_t LITMUS_FP_ZERO = {.val = 0};
 static const fp_t LITMUS_FP_ONE = {.val = (1 << FP_SHIFT)};
+#endif
 
 static inline fp_t FP(fpbuf_t x)
 {
diff --git a/litmus/locking.c b/litmus/locking.c
index 48b548a61f63..cb11c04ed0d4 100644
--- a/litmus/locking.c
+++ b/litmus/locking.c
@@ -282,6 +282,8 @@ static long do_litmus_dgl_lock(dgl_wait_state_t *dgl_wait)
 
         dgl_wait->nr_remaining = dgl_wait->size;
 
+        TRACE_CUR("Locking DGL with size %d\n", dgl_wait->size);
+
         // try to acquire each lock.  enqueue (non-blocking) if it is unavailable.
         for(i = 0; i < dgl_wait->size; ++i) {
                 struct litmus_lock *l = dgl_wait->locks[i];
@@ -339,7 +341,7 @@ static long do_litmus_dgl_lock(dgl_wait_state_t *dgl_wait)
                 }
 
                 TRACE_CUR("Didn't have to suspend after all, but calling schedule() anyway.\n");
-                BUG();
+                //BUG();
         }
 
         raw_spin_unlock_irqrestore(dgl_lock, irqflags);
@@ -357,14 +359,14 @@ all_acquired:
         return 0;
 }
 
-//static int supports_dgl(struct litmus_lock *l)
-//{
-//      struct litmus_lock_ops* ops = l->ops;
-//
-//      return (ops->dgl_lock                   &&
-//                      ops->is_owner                   &&
-//                      ops->enable_priority);
-//}
+static int supports_dgl(struct litmus_lock *l)
+{
+        struct litmus_lock_ops* ops = l->ops;
+
+        return (ops->dgl_lock                   &&
+                        ops->is_owner                   &&
+                        ops->enable_priority);
+}
 
 asmlinkage long sys_litmus_dgl_lock(void* __user usr_dgl_ods, int dgl_size)
 {
@@ -393,11 +395,11 @@ asmlinkage long sys_litmus_dgl_lock(void* __user usr_dgl_ods, int dgl_size)
                 struct od_table_entry *entry = get_entry_for_od(dgl_ods[i]);
                 if(entry && is_lock(entry)) {
                         dgl_wait_state.locks[i] = get_lock(entry);
-//                      if(!supports_dgl(dgl_wait_state.locks[i])) {
-//                              TRACE_CUR("Lock %d does not support all required DGL operations.\n",
-//                                                dgl_wait_state.locks[i]->ident);
-//                              goto out;
-//                      }
+                        if(!supports_dgl(dgl_wait_state.locks[i])) {
+                                TRACE_CUR("Lock %d does not support all required DGL operations.\n",
+                                                  dgl_wait_state.locks[i]->ident);
+                                goto out;
+                        }
                 }
                 else {
                         TRACE_CUR("Invalid lock identifier\n");
@@ -468,11 +470,11 @@ asmlinkage long sys_litmus_dgl_unlock(void* __user usr_dgl_ods, int dgl_size)
                 entry = get_entry_for_od(dgl_ods[i]);
                 if(entry && is_lock(entry)) {
                         dgl_locks[i] = get_lock(entry);
-//                      if(!supports_dgl(dgl_locks[i])) {
-//                              TRACE_CUR("Lock %d does not support all required DGL operations.\n",
-//                                                dgl_locks[i]->ident);
-//                              goto out;
-//                      }
+                        if(!supports_dgl(dgl_locks[i])) {
+                                TRACE_CUR("Lock %d does not support all required DGL operations.\n",
+                                                  dgl_locks[i]->ident);
+                                goto out;
+                        }
                 }
                 else {
                         TRACE_CUR("Invalid lock identifier\n");
diff --git a/litmus/sched_cedf.c b/litmus/sched_cedf.c
index e78ff0ade237..99f7620925ba 100644
--- a/litmus/sched_cedf.c
+++ b/litmus/sched_cedf.c
@@ -504,7 +504,6 @@ static void do_lit_tasklets(cedf_domain_t* cluster, struct task_struct* sched_ta
 
                 TS_NV_SCHED_BOTISR_START;
 
-                // remove tasklet at head of list if it has higher priority.
                 raw_spin_lock_irqsave(&cluster->cluster_lock, flags);
 
                 if(cluster->pending_tasklets.head != NULL) {
@@ -512,25 +511,35 @@ static void do_lit_tasklets(cedf_domain_t* cluster, struct task_struct* sched_ta
                         struct tasklet_struct *prev = NULL;
                         tasklet = cluster->pending_tasklets.head;
 
-                        while(tasklet && edf_higher_prio(sched_task, tasklet->owner)) {
+                        // find a tasklet with prio to execute; skip ones where
+                        // sched_task has a higher priority.
+                        // We use the '!edf' test instead of swaping function arguments since
+                        // both sched_task and owner could be NULL.  In this case, we want to
+                        // still execute the tasklet.
+                        while(tasklet && !edf_higher_prio(tasklet->owner, sched_task)) {
                                 prev = tasklet;
                                 tasklet = tasklet->next;
                         }
 
-                        // remove the tasklet from the queue
-                        if(prev) {
-                                prev->next = tasklet->next;
-                                if(prev->next == NULL) {
-                                        TRACE("%s: Tasklet for %d is the last element in tasklet queue.\n", __FUNCTION__, tasklet->owner->pid);
-                                        cluster->pending_tasklets.tail = &(prev);
+                        if(tasklet) {  // found something to execuite
+                                // remove the tasklet from the queue
+                                if(prev) {
+                                        prev->next = tasklet->next;
+                                        if(prev->next == NULL) {
+                                                TRACE("%s: Tasklet for %d is the last element in tasklet queue.\n", __FUNCTION__, tasklet->owner->pid);
+                                                cluster->pending_tasklets.tail = &(prev);
+                                        }
+                                }
+                                else {
+                                        cluster->pending_tasklets.head = tasklet->next;
+                                        if(tasklet->next == NULL) {
+                                                TRACE("%s: Tasklet for %d is the last element in tasklet queue.\n", __FUNCTION__, tasklet->owner->pid);
+                                                cluster->pending_tasklets.tail = &(cluster->pending_tasklets.head);
+                                        }
                                 }
                         }
                         else {
-                                cluster->pending_tasklets.head = tasklet->next;
-                                if(tasklet->next == NULL) {
-                                        TRACE("%s: Tasklet for %d is the last element in tasklet queue.\n", __FUNCTION__, tasklet->owner->pid);
-                                        cluster->pending_tasklets.tail = &(cluster->pending_tasklets.head);
-                                }
+                                TRACE("%s: No tasklets with eligible priority.\n", __FUNCTION__);
                         }
                 }
                 else {
@@ -629,6 +638,7 @@ static void cedf_run_tasklets(struct task_struct* sched_task)
 
 static int cedf_enqueue_pai_tasklet(struct tasklet_struct* tasklet)
 {
+#if 0
         cedf_domain_t *cluster = NULL;
         cpu_entry_t *targetCPU = NULL;
         int thisCPU;
@@ -709,7 +719,10 @@ static int cedf_enqueue_pai_tasklet(struct tasklet_struct* tasklet)
         else {
                 TRACE("%s: Scheduling of tasklet was deferred.\n", __FUNCTION__);
         }
-
+#else
+        TRACE("%s: Running tasklet on CPU where it was received.\n", __FUNCTION__);
+        __do_lit_tasklet(tasklet, 0ul);
+#endif
         return(1); // success
 }