Added stubs for modifying "semaphore" priority, in order to facilitate

priority inheritance. Also fixed a few bugs. Many files were modified, as
the PI semaphores were are implementing replicate much of the original
Linux semaphore implementation with minor changes, often causing a cascade
of changes as functions were chased down and changed in several files.

1 files changed, 52 insertions, 0 deletions

diff --git a/kernel/sched.c b/kernel/sched.c
index aa4a9e9426..27dcab489b 100644
--- a/kernel/sched.c
+++ b/kernel/sched.c
@@ -60,6 +60,7 @@
 #define __SCHED_C__
 #include <linux/sched_plugin.h>
 #include <linux/sched_trace.h>
+#include <linux/rt_param.h>
 
 /*
  * Convert user-nice values [ -20 ... 0 ... 19 ]
@@ -3802,6 +3803,36 @@ static void __wake_up_common(wait_queue_head_t *q, unsigned int mode,
         }
 }
 
+/*
+ * The core wakeup function, this time including priority inheritance. As a result,
+ * this function takes the semaphore as a parameter instead of just its waitqueue.
+ */ 
+static void __pi_wake_up_common(struct pi_semaphore *s, unsigned int mode,
+                                int nr_exclusive, int sync, void *key)
+{
+        struct list_head *tmp, *next;
+        jiffie_t highest_prio = LOWEST_SEM_PRIO;
+
+        list_for_each_safe(tmp, next, &s->wait.task_list) {
+                wait_queue_t *curr = list_entry(tmp, wait_queue_t, task_list);
+                unsigned flags = curr->flags;
+        
+                /* TODO: Find highest priority task remaining in queue. */
+                /* task_priority = tmp_task->rt_param.times.deadline;
+                 * if (time_before(task_priority, highest_prio)) {
+                 *      highest_prio = task_priority;
+                 * }
+                 */
+
+                if (curr->func(curr, mode, sync, key) &&
+                                (flags & WQ_FLAG_EXCLUSIVE) && !--nr_exclusive)
+                        break;
+        }
+
+        /* TODO: Set new priority to highest priority task remaining in queue. */
+        /* s->sem_prio = highest_prio; */
+}
+
 /**
  * __wake_up - wake up threads blocked on a waitqueue.
  * @q: the waitqueue
@@ -3820,6 +3851,27 @@ void fastcall __wake_up(wait_queue_head_t *q, unsigned int mode,
 }
 EXPORT_SYMBOL(__wake_up);
 
+/**
+ *  __pi_wake_up - wake up threads blocked on a waitqueue,
+ *                 and handle priority inheritance as well.
+  * @s: the semaphore (NOT just the waitqueue, since we need to modify
+  *     semaphore priority as well!)
+  * @mode: which threads
+  * @nr_exclusive: how many wake-one or wake-many threads to wake up
+  * @key: is directly passed to the wakeup function
+  *
+ */
+void fastcall __pi_wake_up(struct pi_semaphore *s, unsigned int mode,
+                           int nr_exclusive, void *key)
+{
+        unsigned long flags;
+
+        spin_lock_irqsave(&s->wait.lock, flags);
+        __pi_wake_up_common(s, mode, nr_exclusive, 0, key);
+        spin_unlock_irqrestore(&s->wait.lock, flags);
+}
+EXPORT_SYMBOL(__pi_wake_up);
+
 /*
  * Same as __wake_up but called with the spinlock in wait_queue_head_t held.
  */