Fixed SRP so that it uses per-processor priority ceilings.

1 files changed, 38 insertions, 14 deletions

diff --git a/arch/i386/kernel/srp_sem_syscalls.c b/arch/i386/kernel/srp_sem_syscalls.c
index 24436a9bc8..9c73325cf8 100644
--- a/arch/i386/kernel/srp_sem_syscalls.c
+++ b/arch/i386/kernel/srp_sem_syscalls.c
@@ -13,6 +13,7 @@
 /* struct for uniprocessor SRP "semaphore" */
 struct srp_semaphore {
         struct task_struct *pc_task; /* task representing prio ceil of sem */
+        int cpu; /* cpu associated with this "semaphore" and resource */
         int claimed; /* is the resource claimed (ceiling should be used)? */
         int used; /* is the semaphore being used? */
 };
@@ -21,7 +22,7 @@ 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;
+DEFINE_PER_CPU(struct task_struct *, spc_tasks);
 
 /* Used to serialize access to SRP semaphores and system priority ceiling. */
 static queuelock_t srp_lock;
@@ -30,12 +31,16 @@ static queuelock_t srp_lock;
 static int __init srp_sema_boot_init(void)
 {
         srp_sema_id sem_id;
+        int i;
 
         printk("Initializing SRP semaphores...");
         for (sem_id = 0; sem_id < MAX_SRP_SEMAPHORES; sem_id++) {
                 srp_sems[sem_id].used = 0;
                 srp_sems[sem_id].claimed = 0;
+                srp_sems[sem_id].cpu = -1;
         }
+        for (i = 0; i < NR_CPUS; i++)
+                per_cpu(spc_tasks, i) = NULL;
         queue_lock_init(&srp_lock);
         printk(" complete!\n");
 
@@ -72,14 +77,17 @@ int srp_higher_prio(struct task_struct* first, struct task_struct* second)
 asmlinkage long sys_srp_down(srp_sema_id sem_id)
 {
         unsigned long flags;
+        int cpu = smp_processor_id();
 
-        if (sem_id < 0 || sem_id >= MAX_SRP_SEMAPHORES)
+        if (sem_id < 0 || sem_id >= MAX_SRP_SEMAPHORES ||
+            srp_sems[sem_id].cpu != cpu)
                 return -EINVAL;
 
         queue_lock_irqsave(&srp_lock, flags);
         srp_sems[sem_id].claimed = 1;
-        if (srp_higher_prio(srp_sems[sem_id].pc_task, spc_task)) {
-                spc_task = srp_sems[sem_id].pc_task;
+        if (srp_higher_prio(srp_sems[sem_id].pc_task,
+                            __get_cpu_var(spc_tasks))) {
+                __get_cpu_var(spc_tasks) = srp_sems[sem_id].pc_task;
         }
         queue_unlock_irqrestore(&srp_lock, flags);                      
         
@@ -91,17 +99,21 @@ asmlinkage long sys_srp_up(srp_sema_id sem_id)
 {
         srp_sema_id sem_ctr;
         unsigned long flags;
+        int cpu = smp_processor_id();
 
-        if (sem_id < 0 || sem_id >= MAX_SRP_SEMAPHORES)
+        if (sem_id < 0 || sem_id >= MAX_SRP_SEMAPHORES ||
+            srp_sems[sem_id].cpu != cpu)
                 return -EINVAL;
         
         queue_lock_irqsave(&srp_lock, flags);
         srp_sems[sem_id].claimed = 0;
-        spc_task = NULL;
+        __get_cpu_var(spc_tasks) = NULL;
         for (sem_ctr = 0; sem_ctr < MAX_SRP_SEMAPHORES; sem_ctr++)
                 if (srp_sems[sem_ctr].used && srp_sems[sem_ctr].claimed &&
-                    srp_higher_prio(srp_sems[sem_ctr].pc_task, spc_task))
-                        spc_task = srp_sems[sem_ctr].pc_task;
+                    srp_sems[sem_ctr].cpu == cpu &&
+                    srp_higher_prio(srp_sems[sem_ctr].pc_task,
+                                    __get_cpu_var(spc_tasks)))
+                        __get_cpu_var(spc_tasks) = srp_sems[sem_ctr].pc_task;
         queue_unlock_irqrestore(&srp_lock, flags);
 
         return 0;
@@ -131,6 +143,12 @@ asmlinkage long sys_reg_task_srp_sem(srp_sema_id sem_id, pid_t t_pid)
                 return -EINVAL;
 
         queue_lock_irqsave(&srp_lock, flags);
+        if (srp_sems[sem_id] == -1)
+                srp_sems[sem_id] = get_partition(t);
+        else if (srp_sems[sem_id] != get_partition(t)) {
+                queue_unlock_irqrestore(&srp_lock, flags);
+                return -EINVAL;
+        }
         if (srp_higher_prio(t, srp_sems[sem_id].pc_task))
                 srp_sems[sem_id].pc_task = t;
         queue_unlock_irqrestore(&srp_lock, flags);
@@ -146,8 +164,9 @@ void wait_until_exceed_spc(void)
         unsigned long flags;
 
         queue_lock_irqsave(&srp_lock, flags);
-        while(!srp_higher_prio(current, spc_task)) {
-                queue_unlock_irqrestore(&srp_lock, flags);                                      schedule();
+        while(!srp_higher_prio(current, __get_cpu_var(spc_tasks))) {
+                queue_unlock_irqrestore(&srp_lock, flags);
+                schedule();
                 queue_lock_irqsave(&srp_lock, flags);
         }
         queue_unlock_irqrestore(&srp_lock, flags);
@@ -158,18 +177,23 @@ asmlinkage long sys_srp_sema_free(srp_sema_id sem_id)
 {
         srp_sema_id sem_ctr;
         unsigned long flags;
+        int cpu = smp_processor_id();
 
-        if (sem_id < 0 || sem_id >= MAX_SRP_SEMAPHORES)
+        if (sem_id < 0 || sem_id >= MAX_SRP_SEMAPHORES ||
+            srp_sems[sem_id].cpu != cpu)
                 return -EINVAL;
 
         queue_lock_irqsave(&srp_lock, flags);
         srp_sems[sem_id].claimed = 0;
         srp_sems[sem_id].used = 0;
-        spc_task = NULL;
+        __get_cpu_var(spc_tasks) = NULL;
         for (sem_ctr = 0; sem_ctr < MAX_SRP_SEMAPHORES; sem_ctr++)
                 if (srp_sems[sem_ctr].used && srp_sems[sem_ctr].claimed &&
-                    srp_higher_prio(srp_sems[sem_ctr].pc_task, spc_task))
-                        spc_task = srp_sems[sem_ctr].pc_task;
+                    srp_sems[sem_ctr].cpu == cpu &&
+                    srp_higher_prio(srp_sems[sem_ctr].pc_task,
+                                    __get_cpu_var(spc_tasks)))
+                        __get_cpu_var(spc_tasks) = srp_sems[sem_ctr].pc_task;
+        spc_task[sem_id].cpu = -1;
         queue_unlock_irqrestore(&srp_lock, flags);
 
         return 0;