2 * This file contains the old semaphore code that we need to
3 * preserve for glibc-2.0 backwards compatibility. Port to glibc 2.1
4 * done by Cristian Gafton.
7 /* Linuxthreads - a simple clone()-based implementation of Posix */
8 /* threads for Linux. */
9 /* Copyright (C) 1996 Xavier Leroy (Xavier.Leroy@inria.fr) */
11 /* This program is free software; you can redistribute it and/or */
12 /* modify it under the terms of the GNU Library General Public License */
13 /* as published by the Free Software Foundation; either version 2 */
14 /* of the License, or (at your option) any later version. */
16 /* This program is distributed in the hope that it will be useful, */
17 /* but WITHOUT ANY WARRANTY; without even the implied warranty of */
18 /* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the */
19 /* GNU Library General Public License for more details. */
21 /* Semaphores a la POSIX 1003.1b */
22 #include <shlib-compat.h>
23 #if SHLIB_COMPAT(libpthread, GLIBC_2_0, GLIBC_2_1)
27 #include "internals.h"
37 /* Maximum value the semaphore can have. */
38 #define SEM_VALUE_MAX ((int) ((~0u) >> 1))
40 static inline int sem_compare_and_swap(old_sem_t
*sem
, long oldval
, long newval
)
42 return compare_and_swap(&sem
->sem_status
, oldval
, newval
, &sem
->sem_spinlock
);
45 /* The state of a semaphore is represented by a long int encoding
46 either the semaphore count if >= 0 and no thread is waiting on it,
47 or the head of the list of threads waiting for the semaphore.
48 To distinguish the two cases, we encode the semaphore count N
49 as 2N+1, so that it has the lowest bit set.
51 A sequence of sem_wait operations on a semaphore initialized to N
52 result in the following successive states:
53 2N+1, 2N-1, ..., 3, 1, &first_waiting_thread, &second_waiting_thread, ...
56 static void sem_restart_list(pthread_descr waiting
);
58 int __old_sem_init(old_sem_t
*sem
, int pshared
, unsigned int value
)
60 if (value
> SEM_VALUE_MAX
) {
68 sem
->sem_spinlock
= 0;
69 sem
->sem_status
= ((long)value
<< 1) + 1;
73 /* Function called by pthread_cancel to remove the thread from
74 waiting inside __old_sem_wait. Here we simply unconditionally
75 indicate that the thread is to be woken, by returning 1. */
77 static int old_sem_extricate_func(void *obj
, pthread_descr th
)
82 int __old_sem_wait(old_sem_t
* sem
)
84 long oldstatus
, newstatus
;
85 volatile pthread_descr self
= thread_self();
87 pthread_extricate_if extr
;
89 /* Set up extrication interface */
91 extr
.pu_extricate_func
= old_sem_extricate_func
;
94 /* Register extrication interface */
95 __pthread_set_own_extricate_if(self
, &extr
);
97 oldstatus
= sem
->sem_status
;
98 if ((oldstatus
& 1) && (oldstatus
!= 1))
99 newstatus
= oldstatus
- 2;
101 newstatus
= (long) self
;
102 self
->p_nextwaiting
= (pthread_descr
) oldstatus
;
105 while (! sem_compare_and_swap(sem
, oldstatus
, newstatus
));
107 /* We got the semaphore. */
108 __pthread_set_own_extricate_if(self
, 0);
111 /* Wait for sem_post or cancellation */
113 __pthread_set_own_extricate_if(self
, 0);
115 /* This is a cancellation point */
116 if (self
->p_canceled
&& self
->p_cancelstate
== PTHREAD_CANCEL_ENABLE
) {
117 /* Remove ourselves from the waiting list if we're still on it */
118 /* First check if we're at the head of the list. */
120 oldstatus
= sem
->sem_status
;
121 if (oldstatus
!= (long) self
) break;
122 newstatus
= (long) self
->p_nextwaiting
;
124 while (! sem_compare_and_swap(sem
, oldstatus
, newstatus
));
125 /* Now, check if we're somewhere in the list.
126 There's a race condition with sem_post here, but it does not matter:
127 the net result is that at the time pthread_exit is called,
128 self is no longer reachable from sem->sem_status. */
129 if (oldstatus
!= (long) self
&& (oldstatus
& 1) == 0) {
130 for (th
= &(((pthread_descr
) oldstatus
)->p_nextwaiting
);
131 *th
!= NULL
&& *th
!= (pthread_descr
) 1;
132 th
= &((*th
)->p_nextwaiting
)) {
134 *th
= self
->p_nextwaiting
;
139 pthread_exit(PTHREAD_CANCELED
);
144 int __old_sem_trywait(old_sem_t
* sem
)
146 long oldstatus
, newstatus
;
149 oldstatus
= sem
->sem_status
;
150 if ((oldstatus
& 1) == 0 || (oldstatus
== 1)) {
154 newstatus
= oldstatus
- 2;
156 while (! sem_compare_and_swap(sem
, oldstatus
, newstatus
));
160 int __old_sem_post(old_sem_t
* sem
)
162 long oldstatus
, newstatus
;
165 oldstatus
= sem
->sem_status
;
166 if ((oldstatus
& 1) == 0)
169 if (oldstatus
>= SEM_VALUE_MAX
) {
174 newstatus
= oldstatus
+ 2;
177 while (! sem_compare_and_swap(sem
, oldstatus
, newstatus
));
178 if ((oldstatus
& 1) == 0)
179 sem_restart_list((pthread_descr
) oldstatus
);
183 int __old_sem_getvalue(old_sem_t
* sem
, int * sval
)
185 long status
= sem
->sem_status
;
187 *sval
= (int)((unsigned long) status
>> 1);
193 int __old_sem_destroy(old_sem_t
* sem
)
195 if ((sem
->sem_status
& 1) == 0) {
202 /* Auxiliary function for restarting all threads on a waiting list,
203 in priority order. */
205 static void sem_restart_list(pthread_descr waiting
)
207 pthread_descr th
, towake
, *p
;
209 /* Sort list of waiting threads by decreasing priority (insertion sort) */
211 while (waiting
!= (pthread_descr
) 1) {
213 waiting
= waiting
->p_nextwaiting
;
215 while (*p
!= NULL
&& th
->p_priority
< (*p
)->p_priority
)
216 p
= &((*p
)->p_nextwaiting
);
217 th
->p_nextwaiting
= *p
;
220 /* Wake up threads in priority order */
221 while (towake
!= NULL
) {
223 towake
= towake
->p_nextwaiting
;
224 th
->p_nextwaiting
= NULL
;
229 compat_symbol (libpthread
, __old_sem_init
, sem_init
, GLIBC_2_0
);
230 compat_symbol (libpthread
, __old_sem_wait
, sem_wait
, GLIBC_2_0
);
231 compat_symbol (libpthread
, __old_sem_trywait
, sem_trywait
, GLIBC_2_0
);
232 compat_symbol (libpthread
, __old_sem_post
, sem_post
, GLIBC_2_0
);
233 compat_symbol (libpthread
, __old_sem_getvalue
, sem_getvalue
, GLIBC_2_0
);
234 compat_symbol (libpthread
, __old_sem_destroy
, sem_destroy
, GLIBC_2_0
);