First attempt at FIFO semaphores and PI sems. This may not work...

Before FIFO, everything seemed to be (finally) working ok.

4 files changed, 13 insertions, 12 deletions

diff --git a/arch/i386/kernel/pi_sem_syscalls.c b/arch/i386/kernel/pi_sem_syscalls.c
index 1034c1ccbe..0d1753495e 100644
--- a/arch/i386/kernel/pi_sem_syscalls.c
+++ b/arch/i386/kernel/pi_sem_syscalls.c
@@ -68,7 +68,9 @@ void __sys_pi_down(struct pi_semaphore * sem)
 //              :"+m" (sem->count)
 //              :
 //              :"memory","ax");
-        if (atomic_dec_return(&sem->count) < 0)
+//
+        /* Checking for active waitqueue gives others a chance... */
+        if (atomic_dec_return(&sem->count) < 0 || waitqueue_active(&sem->wait))
                 __pi_down(sem);
 }
 
diff --git a/arch/i386/kernel/sem_syscalls.c b/arch/i386/kernel/sem_syscalls.c
index 274687d21c..4ca92c9be5 100644
--- a/arch/i386/kernel/sem_syscalls.c
+++ b/arch/i386/kernel/sem_syscalls.c
@@ -45,7 +45,11 @@ asmlinkage long sys_down(sema_id sem_id)
         if (sem_id < 0 || sem_id >= MAX_SEMAPHORES)
                 return -EINVAL;
 
-        down(&sems[sem_id]);
+        /* This allows for FIFO sems and gives others a chance... */
+        if (waitqueue_active(&sems[sem_id].wait))
+                __down(&sems[sem_id]);
+        else
+                down(&sems[sem_id]);
         return 0;
 }
 
diff --git a/kernel/sched_gsn_edf.c b/kernel/sched_gsn_edf.c
index c8d0f9910a..d2d77f98cc 100644
--- a/kernel/sched_gsn_edf.c
+++ b/kernel/sched_gsn_edf.c
@@ -120,7 +120,6 @@ static noinline void link_task_to_cpu(struct task_struct* linked,
         /* Currently linked task is set to be unlinked. */
         if (entry->linked) {
                 entry->linked->rt_param.linked_on = NO_CPU;
-                TRACE("unlinked %d from CPU%d\n", entry->linked->pid, entry->cpu);
         }
 
         /* Link new task to CPU. */
@@ -129,10 +128,8 @@ static noinline void link_task_to_cpu(struct task_struct* linked,
                 /* handle task is already scheduled somewhere! */
                 on_cpu = linked->rt_param.scheduled_on;
                 if (on_cpu != NO_CPU) {
-                        TRACE("to be linked task is already running!\n");
-                        TRACE("to be linked = %d, sched = %d\n", entry->cpu, on_cpu)
                         sched = &per_cpu(gsnedf_cpu_entries, on_cpu);
-                        /* this should only happen if it is not linked already */
+                        /* this should only happen if not linked already */
                         BUG_ON(sched->linked == linked);
                         
                         /* If we are already scheduled on the CPU to which we
@@ -145,7 +142,6 @@ static noinline void link_task_to_cpu(struct task_struct* linked,
                                 linked->rt_param.linked_on = sched->cpu;
                                 sched->linked = linked;
                                 update_cpu_position(sched);
-                                TRACE("task %d linked to CPU%d\n", linked->pid, linked->rt_param.linked_on);
                                 linked = tmp;
                         }
                 }
@@ -154,10 +150,6 @@ static noinline void link_task_to_cpu(struct task_struct* linked,
         }
         entry->linked = linked;
         update_cpu_position(entry);
-        
-        if (linked) {
-                TRACE("task %d linked to CPU%d\n", linked?linked->pid:0, linked?linked->rt_param.linked_on:0);
-        }
 }
 
 /* unlink - Make sure a task is not linked any longer to an entry
diff --git a/lib/semaphore-sleepers.c b/lib/semaphore-sleepers.c
index 07acc899d3..24c6680fd0 100644
--- a/lib/semaphore-sleepers.c
+++ b/lib/semaphore-sleepers.c
@@ -68,6 +68,8 @@ fastcall void __sched __down(struct semaphore * sem)
 
         tsk->state = TASK_UNINTERRUPTIBLE;
         spin_lock_irqsave(&sem->wait.lock, flags);
+        if (is_realtime(tsk)) /* these sems should be FIFO */
+                wait.flags = WQ_FLAG_EXCLUSIVE;
         add_wait_queue_exclusive_locked(&sem->wait, &wait);
 
         sem->sleepers++;
@@ -115,7 +117,7 @@ fastcall int __sched __down_interruptible(struct semaphore * sem)
                 /*
                  * With signals pending, this turns into
                  * the trylock failure case - we won't be
-                 * sleeping, and we* can't get the lock as
+                 * sleeping, and we can't get the lock as
                  * it has contention. Just correct the count
                  * and exit.
                  */
@@ -189,6 +191,7 @@ fastcall void __sched __pi_down(struct pi_semaphore * sem)
         unsigned long flags;
 
         spin_lock_irqsave(&sem->wait.lock, flags);
+        wait.flags = WQ_FLAG_EXCLUSIVE;
         add_wait_queue_exclusive_locked(&sem->wait, &wait);
 
         /* Change semaphore priority here, if applicable. */