Implement pthread_condattr_getpshared and pthread_condattr_setpshared.
[kopensolaris-gnu/glibc.git] / linuxthreads / condvar.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 /* and Pavel Krauz (krauz@fsid.cvut.cz).                                */
5 /*                                                                      */
6 /* This program is free software; you can redistribute it and/or        */
7 /* modify it under the terms of the GNU Library General Public License  */
8 /* as published by the Free Software Foundation; either version 2       */
9 /* of the License, or (at your option) any later version.               */
10 /*                                                                      */
11 /* This program is distributed in the hope that it will be useful,      */
12 /* but WITHOUT ANY WARRANTY; without even the implied warranty of       */
13 /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the        */
14 /* GNU Library General Public License for more details.                 */
15
16 /* Condition variables */
17
18 #include <errno.h>
19 #include <sched.h>
20 #include <stddef.h>
21 #include <sys/time.h>
22 #include "pthread.h"
23 #include "internals.h"
24 #include "spinlock.h"
25 #include "queue.h"
26 #include "restart.h"
27
28 int pthread_cond_init(pthread_cond_t *cond,
29                       const pthread_condattr_t *cond_attr)
30 {
31   __pthread_init_lock(&cond->__c_lock);
32   cond->__c_waiting = NULL;
33   return 0;
34 }
35
36 int pthread_cond_destroy(pthread_cond_t *cond)
37 {
38   if (cond->__c_waiting != NULL) return EBUSY;
39   return 0;
40 }
41
42 /* Function called by pthread_cancel to remove the thread from
43    waiting on a condition variable queue. */
44
45 static int cond_extricate_func(void *obj, pthread_descr th)
46 {
47   volatile pthread_descr self = thread_self();
48   pthread_cond_t *cond = obj;
49   int did_remove = 0;
50
51   __pthread_lock(&cond->__c_lock, self);
52   did_remove = remove_from_queue(&cond->__c_waiting, th);
53   __pthread_unlock(&cond->__c_lock);
54
55   return did_remove;
56 }
57
58 int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex)
59 {
60   volatile pthread_descr self = thread_self();
61   pthread_extricate_if extr;
62   int already_canceled = 0;
63
64   /* Check whether the mutex is locked and owned by this thread.  */
65   if (mutex->__m_kind != PTHREAD_MUTEX_TIMED_NP
66       && mutex->__m_kind != PTHREAD_MUTEX_ADAPTIVE_NP
67       && mutex->__m_owner != self)
68     return EINVAL;
69
70   /* Set up extrication interface */
71   extr.pu_object = cond;
72   extr.pu_extricate_func = cond_extricate_func;
73
74   /* Register extrication interface */
75   __pthread_set_own_extricate_if(self, &extr);
76
77   /* Atomically enqueue thread for waiting, but only if it is not
78      canceled. If the thread is canceled, then it will fall through the
79      suspend call below, and then call pthread_exit without
80      having to worry about whether it is still on the condition variable queue.
81      This depends on pthread_cancel setting p_canceled before calling the
82      extricate function. */
83
84   __pthread_lock(&cond->__c_lock, self);
85   if (!(THREAD_GETMEM(self, p_canceled)
86       && THREAD_GETMEM(self, p_cancelstate) == PTHREAD_CANCEL_ENABLE))
87     enqueue(&cond->__c_waiting, self);
88   else
89     already_canceled = 1;
90   __pthread_unlock(&cond->__c_lock);
91
92   if (already_canceled) {
93     __pthread_set_own_extricate_if(self, 0);
94     pthread_exit(PTHREAD_CANCELED);
95   }
96
97   pthread_mutex_unlock(mutex);
98
99   suspend(self);
100   __pthread_set_own_extricate_if(self, 0);
101
102   /* Check for cancellation again, to provide correct cancellation
103      point behavior */
104
105   if (THREAD_GETMEM(self, p_woken_by_cancel)
106       && THREAD_GETMEM(self, p_cancelstate) == PTHREAD_CANCEL_ENABLE) {
107     THREAD_SETMEM(self, p_woken_by_cancel, 0);
108     pthread_mutex_lock(mutex);
109     pthread_exit(PTHREAD_CANCELED);
110   }
111
112   pthread_mutex_lock(mutex);
113   return 0;
114 }
115
116 static int
117 pthread_cond_timedwait_relative(pthread_cond_t *cond,
118                                 pthread_mutex_t *mutex,
119                                 const struct timespec * abstime)
120 {
121   volatile pthread_descr self = thread_self();
122   int already_canceled = 0;
123   pthread_extricate_if extr;
124
125   /* Check whether the mutex is locked and owned by this thread.  */
126   if (mutex->__m_kind != PTHREAD_MUTEX_TIMED_NP
127       && mutex->__m_kind != PTHREAD_MUTEX_ADAPTIVE_NP
128       && mutex->__m_owner != self)
129     return EINVAL;
130
131   /* Set up extrication interface */
132   extr.pu_object = cond;
133   extr.pu_extricate_func = cond_extricate_func;
134
135   /* Register extrication interface */
136   __pthread_set_own_extricate_if(self, &extr);
137
138   /* Enqueue to wait on the condition and check for cancellation. */
139   __pthread_lock(&cond->__c_lock, self);
140   if (!(THREAD_GETMEM(self, p_canceled)
141       && THREAD_GETMEM(self, p_cancelstate) == PTHREAD_CANCEL_ENABLE))
142     enqueue(&cond->__c_waiting, self);
143   else
144     already_canceled = 1;
145   __pthread_unlock(&cond->__c_lock);
146
147   if (already_canceled) {
148     __pthread_set_own_extricate_if(self, 0);
149     pthread_exit(PTHREAD_CANCELED);
150   }
151
152   pthread_mutex_unlock(mutex);
153
154   if (!timedsuspend(self, abstime)) {
155     int was_on_queue;
156
157     /* __pthread_lock will queue back any spurious restarts that
158        may happen to it. */
159
160     __pthread_lock(&cond->__c_lock, self);
161     was_on_queue = remove_from_queue(&cond->__c_waiting, self);
162     __pthread_unlock(&cond->__c_lock);
163
164     if (was_on_queue) {
165       __pthread_set_own_extricate_if(self, 0);
166       pthread_mutex_lock(mutex);
167       return ETIMEDOUT;
168     }
169
170     /* Eat the outstanding restart() from the signaller */
171     suspend(self);
172   }
173
174   __pthread_set_own_extricate_if(self, 0);
175
176   /* The remaining logic is the same as in other cancellable waits,
177      such as pthread_join sem_wait or pthread_cond wait. */
178
179   if (THREAD_GETMEM(self, p_woken_by_cancel)
180       && THREAD_GETMEM(self, p_cancelstate) == PTHREAD_CANCEL_ENABLE) {
181     THREAD_SETMEM(self, p_woken_by_cancel, 0);
182     pthread_mutex_lock(mutex);
183     pthread_exit(PTHREAD_CANCELED);
184   }
185
186   pthread_mutex_lock(mutex);
187   return 0;
188 }
189
190 int pthread_cond_timedwait(pthread_cond_t *cond, pthread_mutex_t *mutex,
191                            const struct timespec * abstime)
192 {
193   /* Indirect call through pointer! */
194   return pthread_cond_timedwait_relative(cond, mutex, abstime);
195 }
196
197 int pthread_cond_signal(pthread_cond_t *cond)
198 {
199   pthread_descr th;
200
201   __pthread_lock(&cond->__c_lock, NULL);
202   th = dequeue(&cond->__c_waiting);
203   __pthread_unlock(&cond->__c_lock);
204   if (th != NULL) restart(th);
205   return 0;
206 }
207
208 int pthread_cond_broadcast(pthread_cond_t *cond)
209 {
210   pthread_descr tosignal, th;
211
212   __pthread_lock(&cond->__c_lock, NULL);
213   /* Copy the current state of the waiting queue and empty it */
214   tosignal = cond->__c_waiting;
215   cond->__c_waiting = NULL;
216   __pthread_unlock(&cond->__c_lock);
217   /* Now signal each process in the queue */
218   while ((th = dequeue(&tosignal)) != NULL) restart(th);
219   return 0;
220 }
221
222 int pthread_condattr_init(pthread_condattr_t *attr)
223 {
224   return 0;
225 }
226
227 int pthread_condattr_destroy(pthread_condattr_t *attr)
228 {
229   return 0;
230 }
231
232 int pthread_condattr_getpshared (const pthread_condattr_t *attr, int *pshared)
233 {
234   *pshared = PTHREAD_PROCESS_PRIVATE;
235   return 0;
236 }
237
238 int pthread_condattr_setpshared (pthread_condattr_t *attr, int pshared)
239 {
240   if (pshared != PTHREAD_PROCESS_PRIVATE && pshared != PTHREAD_PROCESS_SHARED)
241     return EINVAL;
242
243   /* For now it is not possible to shared a conditional variable.  */
244   if (pshared != PTHREAD_PROCESS_PRIVATE)
245     return ENOSYS;
246
247   return 0;
248 }