Finish user stack support. Change locking code to be safe in
[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 "pthread.h"
18 #include "semaphore.h"
19 #include "internals.h"
20 #include "spinlock.h"
21 #include "restart.h"
22 #include "queue.h"
23
24 int sem_init(sem_t *sem, int pshared, unsigned int value)
25 {
26   if (value > SEM_VALUE_MAX) {
27     errno = EINVAL;
28     return -1;
29   }
30   if (pshared) {
31     errno = ENOSYS;
32     return -1;
33   }
34   __pthread_init_lock((struct _pthread_fastlock *) &sem->sem_lock);
35   sem->sem_value = value;
36   sem->sem_waiting = NULL;
37   return 0;
38 }
39
40 int sem_wait(sem_t * sem)
41 {
42   volatile pthread_descr self;
43
44   __pthread_lock((struct _pthread_fastlock *) &sem->sem_lock);
45   if (sem->sem_value > 0) {
46     sem->sem_value--;
47     __pthread_unlock((struct _pthread_fastlock *) &sem->sem_lock);
48     return 0;
49   }
50   self = thread_self();
51   enqueue(&sem->sem_waiting, self);
52   /* Wait for sem_post or cancellation */
53   __pthread_unlock((struct _pthread_fastlock *) &sem->sem_lock);
54   suspend_with_cancellation(self);
55   /* This is a cancellation point */
56   if (self->p_canceled && self->p_cancelstate == PTHREAD_CANCEL_ENABLE) {
57     /* Remove ourselves from the waiting list if we're still on it */
58     __pthread_lock((struct _pthread_fastlock *) &sem->sem_lock);
59     remove_from_queue(&sem->sem_waiting, self);
60     __pthread_unlock((struct _pthread_fastlock *) &sem->sem_lock);
61     pthread_exit(PTHREAD_CANCELED);
62   }
63   /* We got the semaphore */
64   return 0;
65 }
66
67 int sem_trywait(sem_t * sem)
68 {
69   int retval;
70
71   __pthread_lock((struct _pthread_fastlock *) &sem->sem_lock);
72   if (sem->sem_value == 0) {
73     errno = EAGAIN;
74     retval = -1;
75   } else {
76     sem->sem_value--;
77     retval = 0;
78   }
79   return retval;
80 }
81
82 int sem_post(sem_t * sem)
83 {
84   pthread_descr self = thread_self();
85   pthread_descr th;
86   struct pthread_request request;
87
88   if (self->p_in_sighandler == NULL) {
89     __pthread_lock((struct _pthread_fastlock *) &sem->sem_lock);
90     if (sem->sem_waiting == NULL) {
91       if (sem->sem_value >= SEM_VALUE_MAX) {
92         /* Overflow */
93         errno = ERANGE;
94         __pthread_unlock((struct _pthread_fastlock *) &sem->sem_lock);
95         return -1;
96       }
97       sem->sem_value++;
98       __pthread_unlock((struct _pthread_fastlock *) &sem->sem_lock);
99     } else {
100       th = dequeue(&sem->sem_waiting);
101       __pthread_unlock((struct _pthread_fastlock *) &sem->sem_lock);
102       restart(th);
103     }
104   } else {
105     /* If we're in signal handler, delegate post operation to
106        the thread manager. */
107     if (__pthread_manager_request < 0) {
108       if (__pthread_initialize_manager() < 0) {
109         errno = EAGAIN;
110         return -1;
111       }
112     }
113     request.req_kind = REQ_POST;
114     request.req_args.post = sem;
115     __libc_write(__pthread_manager_request,
116                  (char *) &request, sizeof(request));
117   }
118   return 0;
119 }
120
121 int sem_getvalue(sem_t * sem, int * sval)
122 {
123   *sval = sem->sem_value;
124   return 0;
125 }
126
127 int sem_destroy(sem_t * sem)
128 {
129   if (sem->sem_waiting != NULL) {
130     errno = EBUSY;
131     return -1;
132   }
133   return 0;
134 }