Fixed a boosting bug.

3 files changed, 66 insertions, 21 deletions

diff --git a/include/litmus/debug_trace.h b/include/litmus/debug_trace.h
index 1266ac6a760c..928b1dfd1dbf 100644
--- a/include/litmus/debug_trace.h
+++ b/include/litmus/debug_trace.h
@@ -17,10 +17,22 @@ extern atomic_t __log_seq_no;
 #define TRACE_ARGS  atomic_add_return(1, &__log_seq_no),        \
                 raw_smp_processor_id(),                         \
                 __FUNCTION__, __FILE__, __LINE__
+#define STRACE(fmt, args...) \
+        sched_trace_log_message("%d P%d      [%s@%s:%d]: " fmt, \
+                                TRACE_ARGS,  ## args)
+#define STRACE2(fmt, args...) \
+        sched_trace_log_message("%d P%d              [%s@%s:%d]: " fmt, \
+                                TRACE_ARGS,  ## args)
 #else
 #define TRACE_PREFIX "%d P%d: "
 #define TRACE_ARGS  atomic_add_return(1, &__log_seq_no), \
                 raw_smp_processor_id()
+#define STRACE(fmt, args...) \
+        sched_trace_log_message("%d P%d      : " fmt,   \
+                                TRACE_ARGS,  ## args)
+#define STRACE2(fmt, args...) \
+        sched_trace_log_message("%d P%d              : " fmt,   \
+                                TRACE_ARGS,  ## args)
 #endif
 
 #define TRACE(fmt, args...)                                             \
@@ -34,7 +46,13 @@ extern atomic_t __log_seq_no;
               t ? (t)->rt_param.job_params.job_no : 0,   \
               ##args)
 
+#define STRACE_TASK(t, fmt, args...)                    \
+        STRACE("(%s/%d:%d) " fmt, (t)->comm, (t)->pid,  \
+              (t)->rt_param.job_params.job_no,  ##args)
+
 #define TRACE_CUR(fmt, args...) \
         TRACE_TASK(current, fmt, ## args)
 
+
+
 #endif
diff --git a/litmus/locking.c b/litmus/locking.c
index 65fd51f2c80a..665eef30fe0f 100644
--- a/litmus/locking.c
+++ b/litmus/locking.c
@@ -69,7 +69,6 @@ asmlinkage long sys_dynamic_group_lock(resource_mask_t lock_ods)
     if (entry && is_lock(entry)) {
         l = get_lock(entry);
         if (l->type == DGL_SEM){
-            TRACE_CUR("attempts to lock %d\n", lock_ods);
             err = l->ops->dynamic_group_lock(l, lock_ods);
         }
     }
@@ -91,7 +90,6 @@ asmlinkage long sys_dynamic_group_unlock(resource_mask_t lock_ods)
     if (entry && is_lock(entry)) {
         l = get_lock(entry);
         if (l->type == DGL_SEM){
-            TRACE_CUR("attempts to unlock all resources in 0x%p\n",l);
             err = l->ops->dynamic_group_unlock(l, lock_ods);
         } else{
             TRACE_CUR("Wrong Type: %d\n", l->type);
diff --git a/litmus/sched_psn_edf.c b/litmus/sched_psn_edf.c
index 9da32a773db0..451433c9d543 100644
--- a/litmus/sched_psn_edf.c
+++ b/litmus/sched_psn_edf.c
@@ -59,7 +59,7 @@ static void psnedf_domain_init(psnedf_domain_t* pedf,
 static void requeue(struct task_struct* t, rt_domain_t *edf)
 {
         if (t->state != TASK_RUNNING)
-                TRACE_TASK(t, "requeue: !TASK_RUNNING\n");
+                STRACE_TASK(t, "requeue: !TASK_RUNNING\n");
 
         tsk_rt(t)->completed = 0;
         if (is_early_releasing(t) || is_released(t, litmus_clock()))
@@ -85,7 +85,7 @@ static void boost_priority(struct task_struct* t)
     raw_spin_lock_irqsave(&pedf->slock, flags);
     now = litmus_clock();
 
-    TRACE_TASK(t, "priority boosted at %llu\n", now);
+    STRACE_TASK(t, "priority boosted at %llu\n", now);
 
     tsk_rt(t)->priority_boosted = 1;
     tsk_rt(t)->boost_start_time = now;
@@ -117,7 +117,7 @@ static void unboost_priority(struct task_struct* t)
         /* assumption: this only happens when the job is scheduled */
         BUG_ON(pedf->scheduled != t);
 
-        TRACE_TASK(t, "priority restored at %llu\n", now);
+        STRACE_TASK(t, "priority restored at %llu\n", now);
 
         /* priority boosted jobs must be scheduled */
         BUG_ON(pedf->scheduled != t);
@@ -159,7 +159,7 @@ static int psnedf_check_resched(rt_domain_t *edf)
 static void job_completion(struct task_struct* t, int forced)
 {
         sched_trace_task_completion(t,forced);
-        TRACE_TASK(t, "job_completion().\n");
+        STRACE_TASK(t, "job_completion().\n");
 
         tsk_rt(t)->completed = 1;
         prepare_for_next_period(t);
@@ -199,6 +199,12 @@ static struct task_struct* psnedf_schedule(struct task_struct * prev)
         int                     out_of_time, sleep, preempt,
                                 np, exists, blocks, resched;
 
+    if (prev && is_realtime(prev)){
+        TRACE_TASK(prev, "Rescheduling\n");
+    }else{
+        TRACE("Rescheduling\n");
+    }
+
         raw_spin_lock(&pedf->slock);
 
         /* sanity checking
@@ -266,10 +272,10 @@ static struct task_struct* psnedf_schedule(struct task_struct * prev)
                         next = prev;
 
         if (next) {
-                TRACE_TASK(next, "scheduled at %llu\n", litmus_clock());
-                tsk_rt(next)->completed = 0;
+                STRACE_TASK(next, "scheduled at %llu\n", litmus_clock());
+                set_rt_flags(next, RT_F_RUNNING);
         } else {
-                TRACE("becoming idle at %llu\n", litmus_clock());
+                STRACE("becoming idle at %llu\n", litmus_clock());
         }
 
         pedf->scheduled = next;
@@ -347,7 +353,7 @@ static void psnedf_task_wake_up(struct task_struct *task)
         }
 
         raw_spin_unlock_irqrestore(&pedf->slock, flags);
-        TRACE_TASK(task, "wake up done\n");
+        STRACE_TASK(task, "wake up done\n");
 }
 
 static void psnedf_task_block(struct task_struct *t)
@@ -641,7 +647,7 @@ int psnedf_dgl_dynamic_group_lock(struct litmus_lock* l, resource_mask_t resourc
     wait_queue_t wait;
     unsigned long flags;
     
-    TRACE("Trying to lock a DGL\n");
+    TRACE_CUR("Trying to lock a DGL\n");
 
     if (!is_realtime(t))
         return -EPERM;
@@ -656,6 +662,9 @@ int psnedf_dgl_dynamic_group_lock(struct litmus_lock* l, resource_mask_t resourc
     // if sem->locked & resources == 0, then all resources are available,
     // otherwise we must suspend.
     if (sem->locked & resources){
+
+        STRACE("Resources locked, suspending\n");
+
         init_waitqueue_entry(&wait, t);
 
         set_task_state(t, TASK_UNINTERRUPTIBLE);
@@ -670,6 +679,9 @@ int psnedf_dgl_dynamic_group_lock(struct litmus_lock* l, resource_mask_t resourc
 
         TS_LOCK_RESUME;
     } else {
+
+        STRACE("Acquired a resource\n");
+
         sem->locked = sem->locked | resources;
 
         // if a job requests a resource, then it was scheduled, and therefore
@@ -705,18 +717,21 @@ int psnedf_dgl_dynamic_group_unlock(struct litmus_lock* l, resource_mask_t resou
     resource_mask_t logically_locked;
     struct list_head *pos, *tmp;
 
-    TRACE("Trying to unlock a DGL\n");
+    TRACE_CUR("Trying to unlock a DGL\n");
+
+    //Unlocking but priority is not boosted
+    BUG_ON(!sem->boosted[task_cpu(t)]);
 
     spin_lock_irqsave(&sem->wait.lock, flags);
 
     // ~resources | t->resources checks that t owns the resources being released
     // note that a job can release a subset of the resources it has acquired.
     if ( !is_mask_valid(l, resources)){
-        TRACE("Invalid mask %d\n", resources);
+        STRACE("Invalid mask %d\n", resources);
         err = -EINVAL;
         goto out;
     } else if ( (~resources | t->resources) != -1){
-        TRACE("Trying to lock unowned resources: %d\t%d\n", resources, t->resources);
+        STRACE("Trying to lock unowned resources: %d\t%d\n", resources, t->resources);
         err = -EINVAL;
         goto out;
     } else {
@@ -725,9 +740,12 @@ int psnedf_dgl_dynamic_group_unlock(struct litmus_lock* l, resource_mask_t resou
 
     // if the job released all of the resources it owned, then unboost.
     if (resources == t->resources){
+        STRACE("Released all resources\n");
         unboost_priority(t);
+        sem->boosted[task_cpu(t)] = false;
     } else {
         // update t->resources to reflect the resources currently owned.
+        STRACE("Unlocked a subset of locked resources\n");
         t->resources = t->resources & ~resources;
     }
 
@@ -736,21 +754,30 @@ int psnedf_dgl_dynamic_group_unlock(struct litmus_lock* l, resource_mask_t resou
         list_for_each_safe(pos, tmp, &sem->wait.task_list) {
                 tsk  = (struct task_struct*) list_entry(pos, wait_queue_t,
                                                            task_list)->private;
+        STRACE_TASK(tsk, "Evaluating\n");
 
-
-        if ( (logically_locked == -1) && (num_boosted(sem) == NR_CPUS) ){
+        if ( (logically_locked == -1) || (num_boosted(sem) == NR_CPUS) ){
+            STRACE_TASK(tsk, "All procs boosted, or all resources locked\n");
             break;
         }
 
-        // the resources requested are unlocked
+        STRACE_TASK(tsk, "Logically locked: %o\n", logically_locked);
+        STRACE_TASK(tsk, "tsk->resources: %o\n", tsk->resources);
+        STRACE_TASK(tsk, "!(tsk->resources & logically_locked): %o\n", !(tsk->resources & logically_locked));
+        STRACE_TASK(tsk, "!sem->boosted: %d\n", !sem->boosted[task_cpu(tsk)]);
+
+        // the resources requested are unlocked, tsk acquires its resources
         if( !(tsk->resources & logically_locked) && !sem->boosted[task_cpu(tsk)]) {
 
+            STRACE_TASK(tsk, "Acquired a resource\n");
+
             list_del_init(pos);
 
             sem->locked = sem->locked | tsk->resources;
-            sem->boosted[task_cpu(t)] = true;
 
+            sem->boosted[task_cpu(tsk)] = true;
             boost_priority(tsk);
+
             wake_up_process(tsk);
         }
 
@@ -824,6 +851,7 @@ static long psnedf_allocate_lock(struct litmus_lock **lock, int type,
                                  void* __user config)
 {
         int err = -ENXIO;
+    int config_num;
         struct srp_semaphore* srp;
     struct od_table_entry* entry;
 
@@ -854,8 +882,9 @@ static long psnedf_allocate_lock(struct litmus_lock **lock, int type,
          * and that a config > 0 means point this resource to the existing DGL
          * for the resource in entry number config.
          */
-        TRACE("config: %d\n", *(int*)(config));
-        if (*(int*)(config) < 0){
+        config_num = *(int*)(config);
+        TRACE("config: %d\n", config_num);
+        if (config_num < 0){
             *lock = psnedf_new_dgl();
             if (*lock)
                 err = 0;
@@ -863,7 +892,7 @@ static long psnedf_allocate_lock(struct litmus_lock **lock, int type,
                 err = -ENOMEM;
         /* In this case, we are adding a resource to an existing lock */
         } else {
-            entry = get_entry_for_od(*(int*)(config));
+            entry = get_entry_for_od(config_num);
             if (entry && entry->obj && entry->obj->type == DGL_SEM){
                 *lock = (struct litmus_lock*) entry->obj->obj;
                 err = 0;