Change rwlock_can_rdlock call to meet special requirement for trylock variant.
[kopensolaris-gnu/glibc.git] / linuxthreads / rwlock.c
1 /* Read-write lock implementation.
2    Copyright (C) 1998, 2000 Free Software Foundation, Inc.
3    This file is part of the GNU C Library.
4    Contributed by Xavier Leroy <Xavier.Leroy@inria.fr>
5    and Ulrich Drepper <drepper@cygnus.com>, 1998.
6
7    The GNU C Library is free software; you can redistribute it and/or
8    modify it under the terms of the GNU Library General Public License as
9    published by the Free Software Foundation; either version 2 of the
10    License, or (at your option) any later version.
11
12    The GNU C Library is distributed in the hope that it will be useful,
13    but WITHOUT ANY WARRANTY; without even the implied warranty of
14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15    Library General Public License for more details.
16
17    You should have received a copy of the GNU Library General Public
18    License along with the GNU C Library; see the file COPYING.LIB.  If not,
19    write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
20    Boston, MA 02111-1307, USA.  */
21
22 #include <errno.h>
23 #include <pthread.h>
24 #include <stdlib.h>
25 #include "internals.h"
26 #include "queue.h"
27 #include "spinlock.h"
28 #include "restart.h"
29
30 /*
31  * Check whether the calling thread already owns one or more read locks on the
32  * specified lock. If so, return a pointer to the read lock info structure
33  * corresponding to that lock.
34  */
35
36 static pthread_readlock_info *
37 rwlock_is_in_list(pthread_descr self, pthread_rwlock_t *rwlock)
38 {
39   pthread_readlock_info *info;
40
41   for (info = self->p_readlock_list; info != NULL; info = info->pr_next)
42     {
43       if (info->pr_lock == rwlock)
44         return info;
45     }
46
47   return NULL;
48 }
49
50 /*
51  * Add a new lock to the thread's list of locks for which it has a read lock.
52  * A new info node must be allocated for this, which is taken from the thread's
53  * free list, or by calling malloc. If malloc fails, a null pointer is
54  * returned. Otherwise the lock info structure is initialized and pushed
55  * onto the thread's list.
56  */
57
58 static pthread_readlock_info *
59 rwlock_add_to_list(pthread_descr self, pthread_rwlock_t *rwlock)
60 {
61   pthread_readlock_info *info = self->p_readlock_free;
62
63   if (info != NULL)
64     self->p_readlock_free = info->pr_next;
65   else
66     info = malloc(sizeof *info);
67
68   if (info == NULL)
69     return NULL;
70
71   info->pr_lock_count = 1;
72   info->pr_lock = rwlock;
73   info->pr_next = self->p_readlock_list;
74   self->p_readlock_list = info;
75
76   return info;
77 }
78
79 /*
80  * If the thread owns a read lock over the given pthread_rwlock_t,
81  * and this read lock is tracked in the thread's lock list,
82  * this function returns a pointer to the info node in that list.
83  * It also decrements the lock count within that node, and if
84  * it reaches zero, it removes the node from the list.
85  * If nothing is found, it returns a null pointer.
86  */
87
88 static pthread_readlock_info *
89 rwlock_remove_from_list(pthread_descr self, pthread_rwlock_t *rwlock)
90 {
91   pthread_readlock_info **pinfo;
92
93   for (pinfo = &self->p_readlock_list; *pinfo != NULL; pinfo = &(*pinfo)->pr_next)
94     {
95       if ((*pinfo)->pr_lock == rwlock)
96         {
97           pthread_readlock_info *info = *pinfo;
98           if (--info->pr_lock_count == 0)
99             *pinfo = info->pr_next;
100           return info;
101         }
102     }
103
104   return NULL;
105 }
106
107 /*
108  * This function checks whether the conditions are right to place a read lock.
109  * It returns 1 if so, otherwise zero. The rwlock's internal lock must be
110  * locked upon entry.
111  */
112
113 static int
114 rwlock_can_rdlock(pthread_rwlock_t *rwlock, int have_lock_already)
115 {
116   /* Can't readlock; it is write locked. */
117   if (rwlock->__rw_writer != NULL)
118     return 0;
119
120   /* Lock prefers readers; get it. */
121   if (rwlock->__rw_kind == PTHREAD_RWLOCK_PREFER_READER_NP)
122     return 1;
123
124   /* Lock prefers writers, but none are waiting. */
125   if (queue_is_empty(&rwlock->__rw_write_waiting))
126     return 1;
127
128   /* Writers are waiting, but this thread already has a read lock */
129   if (have_lock_already)
130     return 1;
131
132   /* Writers are waiting, and this is a new lock */
133   return 0;
134 }
135
136 /*
137  * This function helps support brain-damaged recursive read locking
138  * semantics required by Unix 98, while maintaining write priority.
139  * This basically determines whether this thread already holds a read lock
140  * already. It returns 1 if so, otherwise it returns 0.
141  *
142  * If the thread has any ``untracked read locks'' then it just assumes
143  * that this lock is among them, just to be safe, and returns 1.
144  *
145  * Also, if it finds the thread's lock in the list, it sets the pointer
146  * referenced by pexisting to refer to the list entry.
147  *
148  * If the thread has no untracked locks, and the lock is not found
149  * in its list, then it is added to the list. If this fails,
150  * then *pout_of_mem is set to 1.
151  */
152
153 static int
154 rwlock_have_already(pthread_descr *pself, pthread_rwlock_t *rwlock,
155     pthread_readlock_info **pexisting, int *pout_of_mem)
156 {
157   pthread_readlock_info *existing = NULL;
158   int out_of_mem = 0, have_lock_already = 0;
159   pthread_descr self = *pself;
160
161   if (rwlock->__rw_kind == PTHREAD_RWLOCK_PREFER_WRITER_NP)
162     {
163       if (!self)
164         self = thread_self();
165
166       existing = rwlock_is_in_list(self, rwlock);
167
168       if (existing != NULL || self->p_untracked_readlock_count > 0)
169         have_lock_already = 1;
170       else
171         {
172           existing = rwlock_add_to_list(self, rwlock);
173           if (existing == NULL)
174             out_of_mem = 1;
175         }
176     }
177
178   *pout_of_mem = out_of_mem;
179   *pexisting = existing;
180   *pself = self;
181
182   return have_lock_already;
183 }
184
185 int
186 pthread_rwlock_init (pthread_rwlock_t *rwlock,
187                      const pthread_rwlockattr_t *attr)
188 {
189   __pthread_init_lock(&rwlock->__rw_lock);
190   rwlock->__rw_readers = 0;
191   rwlock->__rw_writer = NULL;
192   rwlock->__rw_read_waiting = NULL;
193   rwlock->__rw_write_waiting = NULL;
194
195   if (attr == NULL)
196     {
197       rwlock->__rw_kind = PTHREAD_RWLOCK_DEFAULT_NP;
198       rwlock->__rw_pshared = PTHREAD_PROCESS_PRIVATE;
199     }
200   else
201     {
202       rwlock->__rw_kind = attr->__lockkind;
203       rwlock->__rw_pshared = attr->__pshared;
204     }
205
206   return 0;
207 }
208
209
210 int
211 pthread_rwlock_destroy (pthread_rwlock_t *rwlock)
212 {
213   int readers;
214   _pthread_descr writer;
215
216   __pthread_lock (&rwlock->__rw_lock, NULL);
217   readers = rwlock->__rw_readers;
218   writer = rwlock->__rw_writer;
219   __pthread_unlock (&rwlock->__rw_lock);
220
221   if (readers > 0 || writer != NULL)
222     return EBUSY;
223
224   return 0;
225 }
226
227 int
228 pthread_rwlock_rdlock (pthread_rwlock_t *rwlock)
229 {
230   pthread_descr self = NULL;
231   pthread_readlock_info *existing;
232   int out_of_mem, have_lock_already;
233
234   have_lock_already = rwlock_have_already(&self, rwlock,
235       &existing, &out_of_mem);
236
237   for (;;)
238     {
239       if (self == NULL)
240         self = thread_self ();
241
242       __pthread_lock (&rwlock->__rw_lock, self);
243
244       if (rwlock_can_rdlock(rwlock, have_lock_already))
245         break;
246
247       enqueue (&rwlock->__rw_read_waiting, self);
248       __pthread_unlock (&rwlock->__rw_lock);
249       suspend (self); /* This is not a cancellation point */
250     }
251
252   ++rwlock->__rw_readers;
253   __pthread_unlock (&rwlock->__rw_lock);
254
255   if (have_lock_already || out_of_mem)
256     {
257       if (existing != NULL)
258         existing->pr_lock_count++;
259       else
260         self->p_untracked_readlock_count++;
261     }
262
263   return 0;
264 }
265
266 int
267 pthread_rwlock_tryrdlock (pthread_rwlock_t *rwlock)
268 {
269   pthread_descr self = thread_self();
270   pthread_readlock_info *existing;
271   int out_of_mem, have_lock_already;
272   int retval = EBUSY;
273
274   have_lock_already = rwlock_have_already(&self, rwlock,
275       &existing, &out_of_mem);
276
277   __pthread_lock (&rwlock->__rw_lock, self);
278
279   /* 0 is passed to here instead of have_lock_already.
280      This is to meet Single Unix Spec requirements:
281      if writers are waiting, pthread_rwlock_tryrdlock
282      does not acquire a read lock, even if the caller has
283      one or more read locks already. */
284
285   if (rwlock_can_rdlock(rwlock, 0))
286     {
287       ++rwlock->__rw_readers;
288       retval = 0;
289     }
290
291   __pthread_unlock (&rwlock->__rw_lock);
292
293   if (retval == 0)
294     {
295       if (have_lock_already || out_of_mem)
296         {
297           if (existing != NULL)
298             existing->pr_lock_count++;
299           else
300             self->p_untracked_readlock_count++;
301         }
302     }
303
304   return retval;
305 }
306
307
308 int
309 pthread_rwlock_wrlock (pthread_rwlock_t *rwlock)
310 {
311   pthread_descr self = thread_self ();
312
313   while(1)
314     {
315       __pthread_lock (&rwlock->__rw_lock, self);
316       if (rwlock->__rw_readers == 0 && rwlock->__rw_writer == NULL)
317         {
318           rwlock->__rw_writer = self;
319           __pthread_unlock (&rwlock->__rw_lock);
320           return 0;
321         }
322
323       /* Suspend ourselves, then try again */
324       enqueue (&rwlock->__rw_write_waiting, self);
325       __pthread_unlock (&rwlock->__rw_lock);
326       suspend (self); /* This is not a cancellation point */
327     }
328 }
329
330
331 int
332 pthread_rwlock_trywrlock (pthread_rwlock_t *rwlock)
333 {
334   int result = EBUSY;
335
336   __pthread_lock (&rwlock->__rw_lock, NULL);
337   if (rwlock->__rw_readers == 0 && rwlock->__rw_writer == NULL)
338     {
339       rwlock->__rw_writer = thread_self ();
340       result = 0;
341     }
342   __pthread_unlock (&rwlock->__rw_lock);
343
344   return result;
345 }
346
347
348 int
349 pthread_rwlock_unlock (pthread_rwlock_t *rwlock)
350 {
351   pthread_descr torestart;
352   pthread_descr th;
353
354   __pthread_lock (&rwlock->__rw_lock, NULL);
355   if (rwlock->__rw_writer != NULL)
356     {
357       /* Unlocking a write lock.  */
358       if (rwlock->__rw_writer != thread_self ())
359         {
360           __pthread_unlock (&rwlock->__rw_lock);
361           return EPERM;
362         }
363       rwlock->__rw_writer = NULL;
364
365       if (rwlock->__rw_kind == PTHREAD_RWLOCK_PREFER_READER_NP
366           || (th = dequeue (&rwlock->__rw_write_waiting)) == NULL)
367         {
368           /* Restart all waiting readers.  */
369           torestart = rwlock->__rw_read_waiting;
370           rwlock->__rw_read_waiting = NULL;
371           __pthread_unlock (&rwlock->__rw_lock);
372           while ((th = dequeue (&torestart)) != NULL)
373             restart (th);
374         }
375       else
376         {
377           /* Restart one waiting writer.  */
378           __pthread_unlock (&rwlock->__rw_lock);
379           restart (th);
380         }
381     }
382   else
383     {
384       /* Unlocking a read lock.  */
385       if (rwlock->__rw_readers == 0)
386         {
387           __pthread_unlock (&rwlock->__rw_lock);
388           return EPERM;
389         }
390
391       --rwlock->__rw_readers;
392       if (rwlock->__rw_readers == 0)
393         /* Restart one waiting writer, if any.  */
394         th = dequeue (&rwlock->__rw_write_waiting);
395       else
396         th = NULL;
397
398       __pthread_unlock (&rwlock->__rw_lock);
399       if (th != NULL)
400         restart (th);
401
402       /* Recursive lock fixup */
403
404       if (rwlock->__rw_kind == PTHREAD_RWLOCK_PREFER_WRITER_NP)
405         {
406           pthread_descr self = thread_self();
407           pthread_readlock_info *victim = rwlock_remove_from_list(self, rwlock);
408
409           if (victim != NULL)
410             {
411               if (victim->pr_lock_count == 0)
412                 {
413                   victim->pr_next = self->p_readlock_free;
414                   self->p_readlock_free = victim;
415                 }
416             }
417           else
418             {
419               if (self->p_untracked_readlock_count > 0)
420                 self->p_untracked_readlock_count--;
421             }
422         }
423     }
424
425   return 0;
426 }
427
428
429
430 int
431 pthread_rwlockattr_init (pthread_rwlockattr_t *attr)
432 {
433   attr->__lockkind = 0;
434   attr->__pshared = 0;
435
436   return 0;
437 }
438
439
440 int
441 pthread_rwlockattr_destroy (pthread_rwlockattr_t *attr)
442 {
443   return 0;
444 }
445
446
447 int
448 pthread_rwlockattr_getpshared (const pthread_rwlockattr_t *attr, int *pshared)
449 {
450   *pshared = attr->__pshared;
451   return 0;
452 }
453
454
455 int
456 pthread_rwlockattr_setpshared (pthread_rwlockattr_t *attr, int pshared)
457 {
458   if (pshared != PTHREAD_PROCESS_PRIVATE && pshared != PTHREAD_PROCESS_SHARED)
459     return EINVAL;
460
461   attr->__pshared = pshared;
462
463   return 0;
464 }
465
466
467 int
468 pthread_rwlockattr_getkind_np (const pthread_rwlockattr_t *attr, int *pref)
469 {
470   *pref = attr->__lockkind;
471   return 0;
472 }
473
474
475 int
476 pthread_rwlockattr_setkind_np (pthread_rwlockattr_t *attr, int pref)
477 {
478   if (pref != PTHREAD_RWLOCK_PREFER_READER_NP
479       && pref != PTHREAD_RWLOCK_PREFER_WRITER_NP
480       && pref != PTHREAD_RWLOCK_DEFAULT_NP)
481     return EINVAL;
482
483   attr->__lockkind = pref;
484
485   return 0;
486 }