Rearrange a bit.
[kopensolaris-gnu/glibc.git] / linuxthreads / spinlock.h
1 /* Linuxthreads - a simple clone()-based implementation of Posix        */
2 /* threads for Linux.                                                   */
3 /* Copyright (C) 1998 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 #include <bits/initspin.h>
16
17
18 /* There are 2 compare and swap synchronization primitives with
19    different semantics:
20
21         1. compare_and_swap, which has acquire semantics (i.e. it
22         completes befor subsequent writes.)
23         2. compare_and_swap_with_release_semantics, which has release
24         semantics (it completes after previous writes.)
25
26    For those platforms on which they are the same. HAS_COMPARE_AND_SWAP
27    should be defined. For those platforms on which they are different,
28    HAS_COMPARE_AND_SWAP_WITH_RELEASE_SEMANTICS has to be defined.  */
29
30 #ifndef HAS_COMPARE_AND_SWAP
31 #ifdef HAS_COMPARE_AND_SWAP_WITH_RELEASE_SEMANTICS
32 #define HAS_COMPARE_AND_SWAP
33 #endif
34 #endif
35
36 #if defined(TEST_FOR_COMPARE_AND_SWAP)
37
38 extern int __pthread_has_cas;
39 extern int __pthread_compare_and_swap(long * ptr, long oldval, long newval,
40                                       int * spinlock);
41
42 static inline int compare_and_swap(long * ptr, long oldval, long newval,
43                                    int * spinlock)
44 {
45   if (__builtin_expect (__pthread_has_cas, 1))
46     return __compare_and_swap(ptr, oldval, newval);
47   else
48     return __pthread_compare_and_swap(ptr, oldval, newval, spinlock);
49 }
50
51 #elif defined(HAS_COMPARE_AND_SWAP)
52
53 #ifdef IMPLEMENT_TAS_WITH_CAS
54 #define testandset(p) !__compare_and_swap((long int *) p, 0, 1)
55 #endif
56
57 #ifdef HAS_COMPARE_AND_SWAP_WITH_RELEASE_SEMANTICS
58
59 static inline int
60 compare_and_swap_with_release_semantics (long * ptr, long oldval,
61                                          long newval, int * spinlock)
62 {
63   return __compare_and_swap_with_release_semantics (ptr, oldval,
64                                                     newval);
65 }
66
67 #endif
68
69 static inline int compare_and_swap(long * ptr, long oldval, long newval,
70                                    int * spinlock)
71 {
72   return __compare_and_swap(ptr, oldval, newval);
73 }
74
75 #else
76
77 extern int __pthread_compare_and_swap(long * ptr, long oldval, long newval,
78                                       int * spinlock);
79
80 static inline int compare_and_swap(long * ptr, long oldval, long newval,
81                                    int * spinlock)
82 {
83   return __pthread_compare_and_swap(ptr, oldval, newval, spinlock);
84 }
85
86 #endif
87
88 #ifndef HAS_COMPARE_AND_SWAP_WITH_RELEASE_SEMANTICS
89 #define compare_and_swap_with_release_semantics compare_and_swap
90 #define __compare_and_swap_with_release_semantics __compare_and_swap
91 #endif
92
93 /* Internal locks */
94
95 extern void internal_function __pthread_lock(struct _pthread_fastlock * lock,
96                                              pthread_descr self);
97 extern int __pthread_unlock(struct _pthread_fastlock *lock);
98
99 static inline void __pthread_init_lock(struct _pthread_fastlock * lock)
100 {
101   lock->__status = 0;
102   lock->__spinlock = __LT_SPINLOCK_INIT;
103 }
104
105 static inline int __pthread_trylock (struct _pthread_fastlock * lock)
106 {
107 #if defined HAS_COMPARE_AND_SWAP
108   long oldstatus;
109 #endif
110
111 #if defined TEST_FOR_COMPARE_AND_SWAP
112   if (!__pthread_has_cas)
113 #endif
114 #if !defined HAS_COMPARE_AND_SWAP || defined TEST_FOR_COMPARE_AND_SWAP
115   {
116     return (testandset(&lock->__spinlock) ? EBUSY : 0);
117   }
118 #endif
119
120 #if defined HAS_COMPARE_AND_SWAP
121   do {
122     oldstatus = lock->__status;
123     if (oldstatus != 0) return EBUSY;
124   } while(! __compare_and_swap(&lock->__status, 0, 1));
125   return 0;
126 #endif
127 }
128
129 /* Variation of internal lock used for pthread_mutex_t, supporting
130    timed-out waits.  Warning: do not mix these operations with the above ones
131    over the same lock object! */
132
133 extern void __pthread_alt_lock(struct _pthread_fastlock * lock,
134                                pthread_descr self);
135
136 extern int __pthread_alt_timedlock(struct _pthread_fastlock * lock,
137                                pthread_descr self, const struct timespec *abstime);
138
139 extern void __pthread_alt_unlock(struct _pthread_fastlock *lock);
140
141 static inline void __pthread_alt_init_lock(struct _pthread_fastlock * lock)
142 {
143   lock->__status = 0;
144   lock->__spinlock = __LT_SPINLOCK_INIT;
145 }
146
147 static inline int __pthread_alt_trylock (struct _pthread_fastlock * lock)
148 {
149 #if defined HAS_COMPARE_AND_SWAP
150   long oldstatus;
151 #endif
152
153 #if defined TEST_FOR_COMPARE_AND_SWAP
154   if (!__pthread_has_cas)
155 #endif
156 #if !defined HAS_COMPARE_AND_SWAP || defined TEST_FOR_COMPARE_AND_SWAP
157   {
158     int res = EBUSY;
159
160     if (testandset(&lock->__spinlock) == 0)
161       {
162         if (lock->__status == 0)
163           {
164             lock->__status = 1;
165             WRITE_MEMORY_BARRIER();
166             res = 0;
167           }
168         lock->__spinlock = __LT_SPINLOCK_INIT;
169       }
170     return res;
171   }
172 #endif
173
174 #if defined HAS_COMPARE_AND_SWAP
175   do {
176     oldstatus = lock->__status;
177     if (oldstatus != 0) return EBUSY;
178   } while(! compare_and_swap(&lock->__status, 0, 1, &lock->__spinlock));
179   return 0;
180 #endif
181 }
182
183 /* Operations on pthread_atomic, which is defined in internals.h */
184
185 static inline long atomic_increment(struct pthread_atomic *pa)
186 {
187     long oldval;
188
189     do {
190         oldval = pa->p_count;
191     } while (!compare_and_swap(&pa->p_count, oldval, oldval + 1, &pa->p_spinlock));
192
193     return oldval;
194 }
195
196
197 static inline long atomic_decrement(struct pthread_atomic *pa)
198 {
199     long oldval;
200
201     do {
202         oldval = pa->p_count;
203     } while (!compare_and_swap(&pa->p_count, oldval, oldval - 1, &pa->p_spinlock));
204
205     return oldval;
206 }
207
208
209 static inline void
210 __pthread_set_own_extricate_if (pthread_descr self, pthread_extricate_if *peif)
211 {
212   /* Only store a non-null peif if the thread has cancellation enabled.
213      Otherwise pthread_cancel will unconditionally call the extricate handler,
214      and restart the thread giving rise to forbidden spurious wakeups. */
215   if (peif == NULL
216       || THREAD_GETMEM(self, p_cancelstate) == PTHREAD_CANCEL_ENABLE)
217     {
218       /* If we are removing the extricate interface, we need to synchronize
219          against pthread_cancel so that it does not continue with a pointer
220          to a deallocated pthread_extricate_if struct! The thread lock
221          is (ab)used for this synchronization purpose. */
222       if (peif == NULL)
223         __pthread_lock (THREAD_GETMEM(self, p_lock), self);
224       THREAD_SETMEM(self, p_extricate, peif);
225       if (peif == NULL)
226         __pthread_unlock (THREAD_GETMEM(self, p_lock));
227     }
228 }