PRIOQ: Handled budget exhaustion.

2 files changed, 42 insertions, 16 deletions

diff --git a/litmus/fifo_lock.c b/litmus/fifo_lock.c
index e3a4420851b2..88f27a016b16 100644
--- a/litmus/fifo_lock.c
+++ b/litmus/fifo_lock.c
@@ -684,7 +684,8 @@ inline static void __fifo_mutex_propagate_decrease_inheritance(
                 struct litmus_lock *still_blocked = tsk_rt(t)->blocked_lock;
 
                 /* TODO: is this code path valid for budgets? */
-                WARN_ON(1);
+                if (budget_tiggered)
+                        WARN_ON(1);
 
                 TRACE_TASK(t, "is not blocked on lock %d.\n", l->ident);
                 if(still_blocked) {
@@ -735,7 +736,7 @@ void fifo_mutex_budget_exhausted(struct litmus_lock* l, struct task_struct* t)
         struct fifo_mutex *mutex = fifo_mutex_from_lock(l);
         unsigned long flags = 0;
 
-        /* DGL lock must already be held on this code path */
+        /* DGL lock must already be held on this code path if DGLs are enabled. */
         lock_fine_irqsave(&mutex->lock, flags);
 
         /* unlocks mutex->lock */
diff --git a/litmus/prioq_lock.c b/litmus/prioq_lock.c
index cd351079c8bf..71ef87db316b 100644
--- a/litmus/prioq_lock.c
+++ b/litmus/prioq_lock.c
@@ -70,9 +70,9 @@ __dump_prioq_lock_info(struct prioq_mutex *mutex)
                                           "\n",
                                           blocked_task->comm, blocked_task->pid,
                                           (tsk_rt(blocked_task)->inh_task) ?
-                                          tsk_rt(blocked_task)->inh_task->comm : "null",
+                                              tsk_rt(blocked_task)->inh_task->comm : "null",
                                           (tsk_rt(blocked_task)->inh_task) ?
-                                          tsk_rt(blocked_task)->inh_task->pid : 0
+                                              tsk_rt(blocked_task)->inh_task->pid : 0
 #ifdef CONFIG_LITMUS_DGL_SUPPORT
                                           , enabled
 #endif
@@ -1158,18 +1158,17 @@ void prioq_mutex_propagate_increase_inheritance(struct litmus_lock* l,
 }
 
 
-void prioq_mutex_propagate_decrease_inheritance(struct litmus_lock* l,
-                                                                                         struct task_struct* t,
-                                                                                         raw_spinlock_t* to_unlock,
-                                                                                         unsigned long irqflags,
-                                                                                                int budget_triggered)
+
+
+
+inline static void __prioq_mutex_propagate_decrease_inheritance(
+                                                struct litmus_lock* l,
+                                                struct task_struct* t,
+                                                unsigned long irqflags,
+                                                int budget_triggered)
 {
         struct prioq_mutex *mutex = prioq_mutex_from_lock(l);
 
-        // relay-style locking
-        lock_fine(&mutex->lock);
-        unlock_fine(to_unlock);
-
 #ifdef CONFIG_LITMUS_DGL_SUPPORT
         __prioq_dgl_decrease_pos(mutex, t);
 #else
@@ -1195,7 +1194,7 @@ void prioq_mutex_propagate_decrease_inheritance(struct litmus_lock* l,
                         old_max_eff_prio = top_priority(&tsk_rt(owner)->hp_blocked_tasks);
 
                         binheap_delete(&l->nest.hp_binheap_node, &tsk_rt(owner)->hp_blocked_tasks);
-                        mutex->hp_waiter = __prioq_mutex_find_hp_waiter(mutex, NULL);
+                        mutex->hp_waiter = __prioq_mutex_find_hp_waiter(mutex, NULL); /* update HP waiter */
 
                         TRACE_TASK(t, "prioq_mutex %d state after prio decrease in priority queue\n", l->ident);
                         __dump_prioq_lock_info(mutex);
@@ -1240,7 +1239,8 @@ void prioq_mutex_propagate_decrease_inheritance(struct litmus_lock* l,
                                 }
 
                                 // beware: recursion
-                                litmus->nested_decrease_prio(owner, decreased_prio, &mutex->lock, irqflags, budget_triggered); // will unlock mutex->lock
+                                litmus->nested_decrease_prio(owner, decreased_prio, &mutex->lock, irqflags,
+                                        budget_triggered); // will unlock mutex->lock
                         }
                         else {
                                 raw_spin_unlock(&tsk_rt(owner)->hp_blocked_tasks_lock);
@@ -1261,6 +1261,9 @@ void prioq_mutex_propagate_decrease_inheritance(struct litmus_lock* l,
                 TRACE_TASK(t, "prioq_mutex %d state after prio decrease in priority queue\n", l->ident);
                 __dump_prioq_lock_info(mutex);
 
+                if (budget_triggered)
+                        WARN_ON(1);
+
                 still_blocked = tsk_rt(t)->blocked_lock;
 
                 TRACE_TASK(t, "is not blocked on lock %d.\n", l->ident);
@@ -1289,9 +1292,31 @@ void prioq_mutex_propagate_decrease_inheritance(struct litmus_lock* l,
         }
 }
 
+void prioq_mutex_propagate_decrease_inheritance(struct litmus_lock* l,
+                                                                                                struct task_struct* t,
+                                                                                                raw_spinlock_t* to_unlock,
+                                                                                                unsigned long irqflags,
+                                                                                                int budget_triggered)
+{
+        struct prioq_mutex *mutex = prioq_mutex_from_lock(l);
+
+        // relay-style locking
+        lock_fine(&mutex->lock);
+        unlock_fine(to_unlock);
+
+        __prioq_mutex_propagate_decrease_inheritance(&mutex->litmus_lock, t,
+                                                                                                 irqflags, budget_triggered);
+}
+
 void prioq_mutex_budget_exhausted(struct litmus_lock* l, struct task_struct* t)
 {
-        TRACE_TASK(t, "TODO!\n");
+        struct prioq_mutex *mutex = prioq_mutex_from_lock(l);
+        unsigned long flags = 0;
+
+        /* DGL lock must already be held on this code path if DGLs are enabled. */
+        lock_fine_irqsave(&mutex->lock, flags);
+
+        __prioq_mutex_propagate_decrease_inheritance(&mutex->litmus_lock, t, flags, 1);
 }
 
 int prioq_mutex_close(struct litmus_lock* l)