Made changes in Litmus so that user-space semaphores can work.

A user now makes a system call where a semaphore ID is specified, and
the semaphore implementation is hidden away in the kernel. There are a
finite number of semaphores and the kernel system call will return an error
if it cannot claim one, however user space code in libso does not yet
acknowledge this.

2 files changed, 59 insertions, 18 deletions

diff --git a/arch/i386/kernel/pi_sem_syscalls.c b/arch/i386/kernel/pi_sem_syscalls.c
index 07c11fd327..5f474d2779 100644
--- a/arch/i386/kernel/pi_sem_syscalls.c
+++ b/arch/i386/kernel/pi_sem_syscalls.c
@@ -11,13 +11,35 @@
 #include <linux/sched.h>
 #include <linux/wait.h>
 
-asmlinkage long sys_pi_sema_init (struct pi_semaphore *sem)
+#define MAX_PI_SEMAPHORES 256
+
+struct pi_semaphore pi_sems[MAX_PI_SEMAPHORES]; /* all PI sems */
+typedef int pi_sema_id; /* Userspace ID of a pi_semaphore */
+
+/* Initialize PI semaphores at boot time. */
+void __init pi_sema_boot_init(void)
 {
-        atomic_set(&sem->count, 1);
-        sem->sleepers = 0;
-        init_waitqueue_head(&sem->wait);
-        sem->sem_prio = LOWEST_SEM_PRIO;
-        return 0;
+        int sem_id;
+
+        printk("Initializing PI semaphores...");
+        for (sem_id = 0; sem_id < MAX_PI_SEMAPHORES; sem_id++)
+                pi_sems[sem_id].used = 0;
+        printk(" complete!\n");
+}
+
+/* Find a free semaphore and assign to sem. */
+asmlinkage long sys_pi_sema_init (pi_sema_id *sem_id)
+{
+        for (*sem_id = 0; *sem_id < MAX_PI_SEMAPHORES; (*sem_id)++) {
+                if (!cmpxchg(&pi_sems[*sem_id].used, 0, 1)) {
+                        atomic_set(&pi_sems[*sem_id].count, 1);
+                        pi_sems[*sem_id].sleepers = 0;
+                        init_waitqueue_head(&pi_sems[*sem_id].wait);
+                        pi_sems[*sem_id].sem_prio = LOWEST_SEM_PRIO;
+                        return 0;
+                }
+        }
+        return -ENOMEM;
 }
 
 fastcall void __pi_down_failed(void /* special register calling convention */);
@@ -28,7 +50,7 @@ fastcall void __pi_up_wakeup(void /* special register calling convention */);
  * "__down_failed" is a special asm handler that calls the C
  * routine that actually waits. See arch/i386/kernel/semaphore.c
  */
-asmlinkage long sys_pi_down(struct pi_semaphore * sem)
+void __sys_pi_down(struct pi_semaphore * sem)
 {
         might_sleep();
         __asm__ __volatile__(
@@ -41,6 +63,14 @@ asmlinkage long sys_pi_down(struct pi_semaphore * sem)
                 :"+m" (sem->count)
                 :
                 :"memory","ax");
+}
+
+asmlinkage long sys_pi_down(pi_sema_id sem_id)
+{
+        if (sem_id < 0 || sem_id >= MAX_PI_SEMAPHORES)
+                return -EINVAL;
+
+        __sys_pi_down(&pi_sems[sem_id]);
         return 0;
 }
 
@@ -48,7 +78,7 @@ asmlinkage long sys_pi_down(struct pi_semaphore * sem)
  * Note! This is subtle. We jump to wake people up only if
  * the semaphore was negative (== somebody was waiting on it).
  */
-asmlinkage long sys_pi_up(struct pi_semaphore * sem)
+void __sys_pi_up(struct pi_semaphore * sem)
 {
         __asm__ __volatile__(
                 "# atomic up operation\n\t"
@@ -60,23 +90,32 @@ asmlinkage long sys_pi_up(struct pi_semaphore * sem)
                 :"+m" (sem->count)
                 :
                 :"memory","ax");
+}
+
+asmlinkage long sys_pi_up(pi_sema_id sem_id)
+{
+        if (sem_id < 0 || sem_id >= MAX_PI_SEMAPHORES)
+                return -EINVAL;
+
+        __sys_pi_up(&pi_sems[sem_id]);
         return 0;
 }
 
-/* Clear wait queue and wakeup waiting tasks. */
-asmlinkage long sys_pi_sema_free_wq(struct pi_semaphore * sem)
+/* Clear wait queue and wakeup waiting tasks, and free semaphore. */
+asmlinkage long sys_pi_sema_free(pi_sema_id sem_id)
 {
         struct list_head *tmp, *next;
         unsigned long flags;
 
-        spin_lock_irqsave(&sem->wait.lock, flags);
-        list_for_each_safe(tmp, next, &sem->wait.task_list) {               
+        spin_lock_irqsave(&pi_sems[sem_id].wait.lock, flags);
+        list_for_each_safe(tmp, next, &pi_sems[sem_id].wait.task_list) {                    
                 wait_queue_t *curr = list_entry(tmp, wait_queue_t, task_list);
                 list_del(tmp);
                 curr->func(curr, TASK_UNINTERRUPTIBLE | TASK_INTERRUPTIBLE, 0, NULL);
         }
-        spin_unlock_irqrestore(&sem->wait.lock, flags);
-        
+        spin_unlock_irqrestore(&pi_sems[sem_id].wait.lock, flags);
+        pi_sems[sem_id].used = 0;
+
         return 0;
 }
 
diff --git a/arch/i386/kernel/syscall_table.S b/arch/i386/kernel/syscall_table.S
index 674fe443e8..297a511c37 100644
--- a/arch/i386/kernel/syscall_table.S
+++ b/arch/i386/kernel/syscall_table.S
@@ -329,9 +329,11 @@ ENTRY(sys_call_table)
         .long sys_ni_syscall            /* CLEANUP: sys_reset_stat */
         .long sys_sleep_next_period
         .long sys_scheduler_setup
+        .long sys_ni_syscall            /* to be replaced... */
+        .long sys_ni_syscall            /* 330 */
         .long sys_pi_sema_init
-        .long sys_pi_down               /* 330 */
+        .long sys_pi_down
         .long sys_pi_up                 
-        .long sys_pi_sema_free_wq
-        .long sys_in_blocking_zone
-        .long sys_wait_for_zone_exit    /* 334 */
+        .long sys_pi_sema_free
+        .long sys_in_blocking_zone      /* 335 */
+        .long sys_wait_for_zone_exit    /* 336 */