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
compare_and_swap(long * ptr,long oldval,long newval,int * spinlock)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
compare_and_swap_with_release_semantics(long * ptr,long oldval,long newval,int * spinlock)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
compare_and_swap(long * ptr,long oldval,long newval,int * spinlock)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
compare_and_swap(long * ptr,long oldval,long newval,int * spinlock)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
__pthread_init_lock(struct _pthread_fastlock * lock)99 static inline void __pthread_init_lock(struct _pthread_fastlock * lock)
100 {
101 lock->__status = 0;
102 lock->__spinlock = __LT_SPINLOCK_INIT;
103 }
104
__pthread_trylock(struct _pthread_fastlock * lock)105 static inline int __pthread_trylock (struct _pthread_fastlock * lock)
106 {
107 #if defined TEST_FOR_COMPARE_AND_SWAP
108 if (!__pthread_has_cas)
109 #endif
110 #if !defined HAS_COMPARE_AND_SWAP || defined TEST_FOR_COMPARE_AND_SWAP
111 {
112 return (testandset(&lock->__spinlock) ? EBUSY : 0);
113 }
114 #endif
115
116 #if defined HAS_COMPARE_AND_SWAP
117 do {
118 if (lock->__status != 0) return EBUSY;
119 } while(! __compare_and_swap(&lock->__status, 0, 1));
120 return 0;
121 #endif
122 }
123
124 /* Variation of internal lock used for pthread_mutex_t, supporting
125 timed-out waits. Warning: do not mix these operations with the above ones
126 over the same lock object! */
127
128 extern void __pthread_alt_lock(struct _pthread_fastlock * lock,
129 pthread_descr self);
130
131 extern int __pthread_alt_timedlock(struct _pthread_fastlock * lock,
132 pthread_descr self, const struct timespec *abstime);
133
134 extern void __pthread_alt_unlock(struct _pthread_fastlock *lock);
135
__pthread_alt_init_lock(struct _pthread_fastlock * lock)136 static inline void __pthread_alt_init_lock(struct _pthread_fastlock * lock)
137 {
138 lock->__status = 0;
139 lock->__spinlock = __LT_SPINLOCK_INIT;
140 }
141
__pthread_alt_trylock(struct _pthread_fastlock * lock)142 static inline int __pthread_alt_trylock (struct _pthread_fastlock * lock)
143 {
144 #if defined TEST_FOR_COMPARE_AND_SWAP
145 if (!__pthread_has_cas)
146 #endif
147 #if !defined HAS_COMPARE_AND_SWAP || defined TEST_FOR_COMPARE_AND_SWAP
148 {
149 int res = EBUSY;
150
151 if (testandset(&lock->__spinlock) == 0)
152 {
153 if (lock->__status == 0)
154 {
155 lock->__status = 1;
156 WRITE_MEMORY_BARRIER();
157 res = 0;
158 }
159 lock->__spinlock = __LT_SPINLOCK_INIT;
160 }
161 return res;
162 }
163 #endif
164
165 #if defined HAS_COMPARE_AND_SWAP
166 do {
167 if (lock->__status != 0) return EBUSY;
168 } while(! compare_and_swap(&lock->__status, 0, 1, &lock->__spinlock));
169 return 0;
170 #endif
171 }
172
173 /* Operations on pthread_atomic, which is defined in internals.h */
174
atomic_increment(struct pthread_atomic * pa)175 static inline long atomic_increment(struct pthread_atomic *pa)
176 {
177 long oldval;
178
179 do {
180 oldval = pa->p_count;
181 } while (!compare_and_swap(&pa->p_count, oldval, oldval + 1, &pa->p_spinlock));
182
183 return oldval;
184 }
185
186
atomic_decrement(struct pthread_atomic * pa)187 static inline long atomic_decrement(struct pthread_atomic *pa)
188 {
189 long oldval;
190
191 do {
192 oldval = pa->p_count;
193 } while (!compare_and_swap(&pa->p_count, oldval, oldval - 1, &pa->p_spinlock));
194
195 return oldval;
196 }
197
198
199 static inline void
__pthread_set_own_extricate_if(pthread_descr self,pthread_extricate_if * peif)200 __pthread_set_own_extricate_if (pthread_descr self, pthread_extricate_if *peif)
201 {
202 /* Only store a non-null peif if the thread has cancellation enabled.
203 Otherwise pthread_cancel will unconditionally call the extricate handler,
204 and restart the thread giving rise to forbidden spurious wakeups. */
205 if (peif == NULL
206 || THREAD_GETMEM(self, p_cancelstate) == PTHREAD_CANCEL_ENABLE)
207 {
208 /* If we are removing the extricate interface, we need to synchronize
209 against pthread_cancel so that it does not continue with a pointer
210 to a deallocated pthread_extricate_if struct! The thread lock
211 is (ab)used for this synchronization purpose. */
212 if (peif == NULL)
213 __pthread_lock (THREAD_GETMEM(self, p_lock), self);
214 THREAD_SETMEM(self, p_extricate, peif);
215 if (peif == NULL)
216 __pthread_unlock (THREAD_GETMEM(self, p_lock));
217 }
218 }
219