Merge git://git.tuxdriver.com/git/netdev-jwl
[linux-2.6] / arch / s390 / kernel / semaphore.c
1 /*
2  *  linux/arch/s390/kernel/semaphore.c
3  *
4  *  S390 version
5  *    Copyright (C) 1998-2000 IBM Corporation
6  *    Author(s): Martin Schwidefsky
7  *
8  *  Derived from "linux/arch/i386/kernel/semaphore.c
9  *    Copyright (C) 1999, Linus Torvalds
10  *
11  */
12 #include <linux/sched.h>
13 #include <linux/errno.h>
14 #include <linux/init.h>
15
16 #include <asm/semaphore.h>
17
18 /*
19  * Atomically update sem->count. Equivalent to:
20  *   old_val = sem->count.counter;
21  *   new_val = ((old_val >= 0) ? old_val : 0) + incr;
22  *   sem->count.counter = new_val;
23  *   return old_val;
24  */
25 static inline int __sem_update_count(struct semaphore *sem, int incr)
26 {
27         int old_val, new_val;
28
29         __asm__ __volatile__("   l     %0,0(%3)\n"
30                              "0: ltr   %1,%0\n"
31                              "   jhe   1f\n"
32                              "   lhi   %1,0\n"
33                              "1: ar    %1,%4\n"
34                              "   cs    %0,%1,0(%3)\n"
35                              "   jl    0b\n"
36                              : "=&d" (old_val), "=&d" (new_val),
37                                "=m" (sem->count)
38                              : "a" (&sem->count), "d" (incr), "m" (sem->count)
39                              : "cc" );
40         return old_val;
41 }
42
43 /*
44  * The inline function up() incremented count but the result
45  * was <= 0. This indicates that some process is waiting on
46  * the semaphore. The semaphore is free and we'll wake the
47  * first sleeping process, so we set count to 1 unless some
48  * other cpu has called up in the meantime in which case
49  * we just increment count by 1.
50  */
51 void __up(struct semaphore *sem)
52 {
53         __sem_update_count(sem, 1);
54         wake_up(&sem->wait);
55 }
56
57 /*
58  * The inline function down() decremented count and the result
59  * was < 0. The wait loop will atomically test and update the
60  * semaphore counter following the rules:
61  *   count > 0: decrement count, wake up queue and exit.
62  *   count <= 0: set count to -1, go to sleep.
63  */
64 void __sched __down(struct semaphore * sem)
65 {
66         struct task_struct *tsk = current;
67         DECLARE_WAITQUEUE(wait, tsk);
68
69         __set_task_state(tsk, TASK_UNINTERRUPTIBLE);
70         add_wait_queue_exclusive(&sem->wait, &wait);
71         while (__sem_update_count(sem, -1) <= 0) {
72                 schedule();
73                 set_task_state(tsk, TASK_UNINTERRUPTIBLE);
74         }
75         remove_wait_queue(&sem->wait, &wait);
76         __set_task_state(tsk, TASK_RUNNING);
77         wake_up(&sem->wait);
78 }
79
80 /*
81  * Same as __down() with an additional test for signals.
82  * If a signal is pending the count is updated as follows:
83  *   count > 0: wake up queue and exit.
84  *   count <= 0: set count to 0, wake up queue and exit.
85  */
86 int __sched __down_interruptible(struct semaphore * sem)
87 {
88         int retval = 0;
89         struct task_struct *tsk = current;
90         DECLARE_WAITQUEUE(wait, tsk);
91
92         __set_task_state(tsk, TASK_INTERRUPTIBLE);
93         add_wait_queue_exclusive(&sem->wait, &wait);
94         while (__sem_update_count(sem, -1) <= 0) {
95                 if (signal_pending(current)) {
96                         __sem_update_count(sem, 0);
97                         retval = -EINTR;
98                         break;
99                 }
100                 schedule();
101                 set_task_state(tsk, TASK_INTERRUPTIBLE);
102         }
103         remove_wait_queue(&sem->wait, &wait);
104         __set_task_state(tsk, TASK_RUNNING);
105         wake_up(&sem->wait);
106         return retval;
107 }
108