2002-08-02 Roland McGrath <roland@redhat.com>
[kopensolaris-gnu/glibc.git] / linuxthreads / semaphore.c
1 /* Linuxthreads - a simple clone()-based implementation of Posix        */
2 /* threads for Linux.                                                   */
3 /* Copyright (C) 1996 Xavier Leroy (Xavier.Leroy@inria.fr)              */
4 /*                                                                      */
5 /* This program is free software; you can redistribute it and/or        */
6 /* modify it under the terms of the GNU Library General Public License  */
7 /* as published by the Free Software Foundation; either version 2       */
8 /* of the License, or (at your option) any later version.               */
9 /*                                                                      */
10 /* This program is distributed in the hope that it will be useful,      */
11 /* but WITHOUT ANY WARRANTY; without even the implied warranty of       */
12 /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the        */
13 /* GNU Library General Public License for more details.                 */
14
15 /* Semaphores a la POSIX 1003.1b */
16
17 #include <errno.h>
18 #include "pthread.h"
19 #include "semaphore.h"
20 #include "internals.h"
21 #include "spinlock.h"
22 #include "restart.h"
23 #include "queue.h"
24 #include <shlib-compat.h>
25
26 int __new_sem_init(sem_t *sem, int pshared, unsigned int value)
27 {
28   if (value > SEM_VALUE_MAX) {
29     errno = EINVAL;
30     return -1;
31   }
32   if (pshared) {
33     errno = ENOSYS;
34     return -1;
35   }
36   __pthread_init_lock(&sem->__sem_lock);
37   sem->__sem_value = value;
38   sem->__sem_waiting = NULL;
39   return 0;
40 }
41
42 /* Function called by pthread_cancel to remove the thread from
43    waiting inside __new_sem_wait. */
44
45 static int new_sem_extricate_func(void *obj, pthread_descr th)
46 {
47   volatile pthread_descr self = thread_self();
48   sem_t *sem = obj;
49   int did_remove = 0;
50
51   __pthread_lock(&sem->__sem_lock, self);
52   did_remove = remove_from_queue(&sem->__sem_waiting, th);
53   __pthread_unlock(&sem->__sem_lock);
54
55   return did_remove;
56 }
57
58 int __new_sem_wait(sem_t * sem)
59 {
60   volatile pthread_descr self = thread_self();
61   pthread_extricate_if extr;
62   int already_canceled = 0;
63   int spurious_wakeup_count;
64
65   /* Set up extrication interface */
66   extr.pu_object = sem;
67   extr.pu_extricate_func = new_sem_extricate_func;
68
69   __pthread_lock(&sem->__sem_lock, self);
70   if (sem->__sem_value > 0) {
71     sem->__sem_value--;
72     __pthread_unlock(&sem->__sem_lock);
73     return 0;
74   }
75   /* Register extrication interface */
76   THREAD_SETMEM(self, p_sem_avail, 0);
77   __pthread_set_own_extricate_if(self, &extr);
78   /* Enqueue only if not already cancelled. */
79   if (!(THREAD_GETMEM(self, p_canceled)
80       && THREAD_GETMEM(self, p_cancelstate) == PTHREAD_CANCEL_ENABLE))
81     enqueue(&sem->__sem_waiting, self);
82   else
83     already_canceled = 1;
84   __pthread_unlock(&sem->__sem_lock);
85
86   if (already_canceled) {
87     __pthread_set_own_extricate_if(self, 0);
88     __pthread_do_exit(PTHREAD_CANCELED, CURRENT_STACK_FRAME);
89   }
90
91   /* Wait for sem_post or cancellation, or fall through if already canceled */
92   spurious_wakeup_count = 0;
93   while (1)
94     {
95       suspend(self);
96       if (THREAD_GETMEM(self, p_sem_avail) == 0
97           && (THREAD_GETMEM(self, p_woken_by_cancel) == 0
98               || THREAD_GETMEM(self, p_cancelstate) != PTHREAD_CANCEL_ENABLE))
99         {
100           /* Count resumes that don't belong to us. */
101           spurious_wakeup_count++;
102           continue;
103         }
104       break;
105     }
106   __pthread_set_own_extricate_if(self, 0);
107
108   /* Terminate only if the wakeup came from cancellation. */
109   /* Otherwise ignore cancellation because we got the semaphore. */
110
111   if (THREAD_GETMEM(self, p_woken_by_cancel)
112       && THREAD_GETMEM(self, p_cancelstate) == PTHREAD_CANCEL_ENABLE) {
113     THREAD_SETMEM(self, p_woken_by_cancel, 0);
114     __pthread_do_exit(PTHREAD_CANCELED, CURRENT_STACK_FRAME);
115   }
116   /* We got the semaphore */
117   return 0;
118 }
119
120 int __new_sem_trywait(sem_t * sem)
121 {
122   int retval;
123
124   __pthread_lock(&sem->__sem_lock, NULL);
125   if (sem->__sem_value == 0) {
126     errno = EAGAIN;
127     retval = -1;
128   } else {
129     sem->__sem_value--;
130     retval = 0;
131   }
132   __pthread_unlock(&sem->__sem_lock);
133   return retval;
134 }
135
136 int __new_sem_post(sem_t * sem)
137 {
138   pthread_descr self = thread_self();
139   pthread_descr th;
140   struct pthread_request request;
141
142   if (THREAD_GETMEM(self, p_in_sighandler) == NULL) {
143     __pthread_lock(&sem->__sem_lock, self);
144     if (sem->__sem_waiting == NULL) {
145       if (sem->__sem_value >= SEM_VALUE_MAX) {
146         /* Overflow */
147         errno = ERANGE;
148         __pthread_unlock(&sem->__sem_lock);
149         return -1;
150       }
151       sem->__sem_value++;
152       __pthread_unlock(&sem->__sem_lock);
153     } else {
154       th = dequeue(&sem->__sem_waiting);
155       __pthread_unlock(&sem->__sem_lock);
156       th->p_sem_avail = 1;
157       WRITE_MEMORY_BARRIER();
158       restart(th);
159     }
160   } else {
161     /* If we're in signal handler, delegate post operation to
162        the thread manager. */
163     if (__pthread_manager_request < 0) {
164       if (__pthread_initialize_manager() < 0) {
165         errno = EAGAIN;
166         return -1;
167       }
168     }
169     request.req_kind = REQ_POST;
170     request.req_args.post = sem;
171     TEMP_FAILURE_RETRY(__libc_write(__pthread_manager_request,
172                                     (char *) &request, sizeof(request)));
173   }
174   return 0;
175 }
176
177 int __new_sem_getvalue(sem_t * sem, int * sval)
178 {
179   *sval = sem->__sem_value;
180   return 0;
181 }
182
183 int __new_sem_destroy(sem_t * sem)
184 {
185   if (sem->__sem_waiting != NULL) {
186     __set_errno (EBUSY);
187     return -1;
188   }
189   return 0;
190 }
191
192 sem_t *sem_open(const char *name, int oflag, ...)
193 {
194   __set_errno (ENOSYS);
195   return SEM_FAILED;
196 }
197
198 int sem_close(sem_t *sem)
199 {
200   __set_errno (ENOSYS);
201   return -1;
202 }
203
204 int sem_unlink(const char *name)
205 {
206   __set_errno (ENOSYS);
207   return -1;
208 }
209
210 int sem_timedwait(sem_t *sem, const struct timespec *abstime)
211 {
212   pthread_descr self = thread_self();
213   pthread_extricate_if extr;
214   int already_canceled = 0;
215   int spurious_wakeup_count;
216
217   __pthread_lock(&sem->__sem_lock, self);
218   if (sem->__sem_value > 0) {
219     --sem->__sem_value;
220     __pthread_unlock(&sem->__sem_lock);
221     return 0;
222   }
223
224   if (abstime->tv_nsec < 0 || abstime->tv_nsec >= 1000000000) {
225     /* The standard requires that if the function would block and the
226        time value is illegal, the function returns with an error.  */
227     __pthread_unlock(&sem->__sem_lock);
228     return EINVAL;
229   }
230
231   /* Set up extrication interface */
232   extr.pu_object = sem;
233   extr.pu_extricate_func = new_sem_extricate_func;
234
235   /* Register extrication interface */
236   THREAD_SETMEM(self, p_sem_avail, 0);
237   __pthread_set_own_extricate_if(self, &extr);
238   /* Enqueue only if not already cancelled. */
239   if (!(THREAD_GETMEM(self, p_canceled)
240       && THREAD_GETMEM(self, p_cancelstate) == PTHREAD_CANCEL_ENABLE))
241     enqueue(&sem->__sem_waiting, self);
242   else
243     already_canceled = 1;
244   __pthread_unlock(&sem->__sem_lock);
245
246   if (already_canceled) {
247     __pthread_set_own_extricate_if(self, 0);
248     __pthread_do_exit(PTHREAD_CANCELED, CURRENT_STACK_FRAME);
249   }
250
251   spurious_wakeup_count = 0;
252   while (1)
253     {
254       if (timedsuspend(self, abstime) == 0) {
255         int was_on_queue;
256
257         /* __pthread_lock will queue back any spurious restarts that
258            may happen to it. */
259
260         __pthread_lock(&sem->__sem_lock, self);
261         was_on_queue = remove_from_queue(&sem->__sem_waiting, self);
262         __pthread_unlock(&sem->__sem_lock);
263
264         if (was_on_queue) {
265           __pthread_set_own_extricate_if(self, 0);
266           return ETIMEDOUT;
267         }
268
269         /* Eat the outstanding restart() from the signaller */
270         suspend(self);
271       }
272
273       if (THREAD_GETMEM(self, p_sem_avail) == 0
274           && (THREAD_GETMEM(self, p_woken_by_cancel) == 0
275               || THREAD_GETMEM(self, p_cancelstate) != PTHREAD_CANCEL_ENABLE))
276         {
277           /* Count resumes that don't belong to us. */
278           spurious_wakeup_count++;
279           continue;
280         }
281       break;
282     }
283
284  __pthread_set_own_extricate_if(self, 0);
285
286   /* Terminate only if the wakeup came from cancellation. */
287   /* Otherwise ignore cancellation because we got the semaphore. */
288
289   if (THREAD_GETMEM(self, p_woken_by_cancel)
290       && THREAD_GETMEM(self, p_cancelstate) == PTHREAD_CANCEL_ENABLE) {
291     THREAD_SETMEM(self, p_woken_by_cancel, 0);
292     __pthread_do_exit(PTHREAD_CANCELED, CURRENT_STACK_FRAME);
293   }
294   /* We got the semaphore */
295   return 0;
296 }
297
298
299 versioned_symbol (libpthread, __new_sem_init, sem_init, GLIBC_2_1);
300 versioned_symbol (libpthread, __new_sem_wait, sem_wait, GLIBC_2_1);
301 versioned_symbol (libpthread, __new_sem_trywait, sem_trywait, GLIBC_2_1);
302 versioned_symbol (libpthread, __new_sem_post, sem_post, GLIBC_2_1);
303 versioned_symbol (libpthread, __new_sem_getvalue, sem_getvalue, GLIBC_2_1);
304 versioned_symbol (libpthread, __new_sem_destroy, sem_destroy, GLIBC_2_1);