Fixed a few comment inconsistencies. Added stubs for an SRP "semaphore",

which needs to be expanded in the LSO and by adding system call numbers in
kernel space.

4 files changed, 152 insertions, 3 deletions

diff --git a/arch/i386/kernel/Makefile b/arch/i386/kernel/Makefile
index b8815ad4e8..f77d3e4bc7 100644
--- a/arch/i386/kernel/Makefile
+++ b/arch/i386/kernel/Makefile
@@ -8,7 +8,7 @@ obj-y	:= process.o signal.o entry.o traps.o irq.o \
                 ptrace.o time.o ioport.o ldt.o setup.o i8259.o sys_i386.o \
                 pci-dma.o i386_ksyms.o i387.o bootflag.o e820.o\
                 quirks.o i8237.o topology.o alternative.o i8253.o tsc.o \
-                pi_sem_syscalls.o sem_syscalls.o
+                pi_sem_syscalls.o sem_syscalls.o srp_sem_syscalls.o
 
 obj-$(CONFIG_STACKTRACE)        += stacktrace.o
 obj-y                           += cpu/
diff --git a/arch/i386/kernel/pi_sem_syscalls.c b/arch/i386/kernel/pi_sem_syscalls.c
index 72fd67e6e5..6aa66d2081 100644
--- a/arch/i386/kernel/pi_sem_syscalls.c
+++ b/arch/i386/kernel/pi_sem_syscalls.c
@@ -29,7 +29,7 @@ static int __init pi_sema_boot_init(void)
 }
 __initcall(pi_sema_boot_init);
 
-/* Find a free semaphore and assign to sem. */
+/* Find a free semaphore and return. */
 asmlinkage long sys_pi_sema_init (void)
 {
         pi_sema_id sem_id;
diff --git a/arch/i386/kernel/sem_syscalls.c b/arch/i386/kernel/sem_syscalls.c
index 8b3270d0d4..1a70e0dbbc 100644
--- a/arch/i386/kernel/sem_syscalls.c
+++ b/arch/i386/kernel/sem_syscalls.c
@@ -26,7 +26,7 @@ static int __init sema_boot_init(void)
 }
 __initcall(sema_boot_init);
 
-/* Find a free semaphore and assign to sem. */
+/* Find a free semaphore and return. */
 asmlinkage long sys_sema_init (void)
 {
         sema_id sem_id;
diff --git a/arch/i386/kernel/srp_sem_syscalls.c b/arch/i386/kernel/srp_sem_syscalls.c
new file mode 100644
index 0000000000..3a7e63b550
--- /dev/null
+++ b/arch/i386/kernel/srp_sem_syscalls.c
@@ -0,0 +1,149 @@
+#ifdef __KERNEL__
+
+/*
+ * Uniprocessor SRP "semaphores".
+ */
+
+#include <linux/sched.h>
+#include <linux/queuelock.h>
+#include <linux/sched_plugin.h>
+
+#define MAX_SRP_SEMAPHORES 256
+
+/* struct for uniprocessor SRP "semaphore" */
+struct srp_semaphore {
+        struct task_struct *pc_task; /* task representing prio ceil of sem */
+        int claimed; /* is the resource claimed (ceiling should be used)? */
+        int used; /* is the semaphore being used? */
+};
+
+struct srp_semaphore srp_sems[MAX_SRP_SEMAPHORES]; /* all SRP sems */
+typedef int srp_sema_id; /* Userspace ID of a srp_semaphore */
+
+/* System-wide priority ceiling, represented as a pointer to a task. */
+struct task_struct *spc_task = NULL;
+
+/* Used to serialize access to SRP semaphores and system priority ceiling. */
+static queuelock_t srp_lock;
+
+/* Initialize SRP semaphores at boot time. */
+static int __init srp_sema_boot_init(void)
+{
+        srp_sema_id sem_id;
+
+        printk("Initializing SRP semaphores...");
+        for (sem_id = 0; sem_id < MAX_SRP_SEMAPHORES; sem_id++)
+                srp_sems[sem_id].used = 0;
+        queue_lock_init(&srp_lock);
+        printk(" complete!\n");
+
+        return 0;
+}
+__initcall(srp_sema_boot_init);
+
+/* Find a free semaphore and return. */
+asmlinkage long sys_srp_sema_init (void)
+{
+        srp_sema_id sem_id;
+
+        for (sem_id = 0; sem_id < MAX_SRP_SEMAPHORES; sem_id++) {
+                if (!cmpxchg(&srp_sems[sem_id].used, 0, 1)) {
+                        srp_sems[sem_id].pc_task = NULL;
+                        srp_sems[sem_id].claimed = 0;
+                        return sem_id;
+                }
+        }
+        return -ENOMEM;
+}
+
+/* Adjust the system-wide priority ceiling if resource is claimed. */
+asmlinkage long sys_srp_down(srp_sema_id sem_id)
+{
+        unsigned long flags;
+
+        if (sem_id < 0 || sem_id >= MAX_SRP_SEMAPHORES)
+                return -EINVAL;
+
+        queue_lock_irqsave(&srp_lock, flags);
+        srp_sems[sem_id].claimed = 1;
+        if (/* srp_sems[sem_id].pc_task higher prio than spc_task */1) {
+                spc_task = srp_sems[sem_id].pc_task;
+        }
+        queue_unlock_irqrestore(&srp_lock, flags);                      
+        
+        return 0;
+}
+
+/* Adjust the system-wide priority ceiling if resource is freed. */
+asmlinkage long sys_srp_up(srp_sema_id sem_id)
+{
+        srp_sema_id sem_ctr;
+        unsigned long flags;
+
+        if (sem_id < 0 || sem_id >= MAX_SRP_SEMAPHORES)
+                return -EINVAL;
+        
+        queue_lock_irqsave(&srp_lock, flags);
+        srp_sems[sem_id].claimed = 0;
+        spc_task = NULL;
+        for (sem_ctr = 0; sem_ctr < MAX_SRP_SEMAPHORES; sem_ctr++) {                            
+                if (srp_sems[sem_ctr].used && srp_sems[sem_ctr].claimed /* && */
+                    /* srp_sems[sem_ctr].pc_task higher prio than spc_task */) {
+                        spc_task = srp_sems[sem_ctr].pc_task;
+                }
+        }
+        queue_unlock_irqrestore(&srp_lock, flags);
+
+        return 0;
+}
+
+/* Indicate that task will use a resource associated with a given
+ * semaphore. Should be done *a priori* before RT task system is
+ * executed, so this does *not* update the system priority
+ * ceiling! (The ceiling would be meaningless anyway, as the SRP
+ * breaks without this a priori knowledge.)
+ */
+asmlinkage long register_task_with_srp_sem(srp_sema_id sem_id,
+                                           struct task_struct *t)
+{
+        unsigned long flags;
+
+        if (sem_id < 0 || sem_id >= MAX_SRP_SEMAPHORES)
+                return -EINVAL;
+
+        queue_lock_irqsave(&srp_lock, flags);
+        if (/* t higher prio than srp_sems[sem_id].pc_task */1) {
+                srp_sems[sem_id].pc_task = t;
+        }
+        queue_unlock_irqrestore(&srp_lock, flags);
+
+        return 0;
+}
+
+/* Wait for current task priority to exceed system-wide priority ceiling.
+ * Can be used to determine when it is safe to run a job after its release.
+ */
+void wait_until_exceed_spc(void)
+{
+        unsigned long flags;
+
+        queue_lock_irqsave(&srp_lock, flags);
+        for (;;) { /* use callbacks here... */
+                if (/* current higher prio than spc_task */1) {
+                        break;
+                }
+                queue_unlock_irqrestore(&srp_lock, flags);                              
+                schedule();
+                queue_lock_irqsave(&srp_lock, flags);
+        }
+        queue_unlock_irqrestore(&srp_lock, flags);
+}
+
+/* Free semaphore. */
+asmlinkage long sys_srp_sema_free(srp_sema_id sem_id)
+{
+        srp_sems[sem_id].used = 0;
+        return 0;
+}
+
+#endif