2 * Copyright (c) 1995 John Birrell <jb@cimlogic.com.au>.
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
13 * 3. Neither the name of the author nor the names of any co-contributors
14 * may be used to endorse or promote products derived from this software
15 * without specific prior written permission.
17 * THIS SOFTWARE IS PROVIDED BY JOHN BIRRELL AND CONTRIBUTORS ``AS IS'' AND
18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
20 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
31 #include "namespace.h"
32 #include <machine/tls.h>
38 #include "un-namespace.h"
40 #include "thr_private.h"
42 struct pthread_key _thread_keytable
[PTHREAD_KEYS_MAX
];
43 umtx_t _keytable_lock
;
46 _pthread_key_create(pthread_key_t
*key
, void (*destructor
) (void *))
48 struct pthread
*curthread
;
51 /* User program might be preparing to call pthread_create() */
54 curthread
= tls_get_curthread();
56 /* Lock the key table: */
57 THR_LOCK_ACQUIRE(curthread
, &_keytable_lock
);
58 for (i
= 0; i
< PTHREAD_KEYS_MAX
; i
++) {
60 if (_thread_keytable
[i
].allocated
== 0) {
61 _thread_keytable
[i
].allocated
= 1;
62 _thread_keytable
[i
].destructor
= destructor
;
63 _thread_keytable
[i
].seqno
++;
65 /* Unlock the key table: */
66 THR_LOCK_RELEASE(curthread
, &_keytable_lock
);
72 /* Unlock the key table: */
73 THR_LOCK_RELEASE(curthread
, &_keytable_lock
);
78 _pthread_key_delete(pthread_key_t key
)
80 struct pthread
*curthread
= tls_get_curthread();
83 if ((unsigned int)key
< PTHREAD_KEYS_MAX
) {
84 /* Lock the key table: */
85 THR_LOCK_ACQUIRE(curthread
, &_keytable_lock
);
87 if (_thread_keytable
[key
].allocated
)
88 _thread_keytable
[key
].allocated
= 0;
92 /* Unlock the key table: */
93 THR_LOCK_RELEASE(curthread
, &_keytable_lock
);
100 _thread_cleanupspecific(void)
102 struct pthread
*curthread
= tls_get_curthread();
103 void (*destructor
)( void *);
104 const void *data
= NULL
;
108 if (curthread
->specific
== NULL
)
111 /* Lock the key table: */
112 THR_LOCK_ACQUIRE(curthread
, &_keytable_lock
);
113 for (i
= 0; (i
< PTHREAD_DESTRUCTOR_ITERATIONS
) &&
114 (curthread
->specific_data_count
> 0); i
++) {
115 for (key
= 0; (key
< PTHREAD_KEYS_MAX
) &&
116 (curthread
->specific_data_count
> 0); key
++) {
119 if (_thread_keytable
[key
].allocated
&&
120 (curthread
->specific
[key
].data
!= NULL
)) {
121 if (curthread
->specific
[key
].seqno
==
122 _thread_keytable
[key
].seqno
) {
123 data
= curthread
->specific
[key
].data
;
124 destructor
= _thread_keytable
[key
].destructor
;
126 curthread
->specific
[key
].data
= NULL
;
127 curthread
->specific_data_count
--;
128 } else if (curthread
->specific
[key
].data
!= NULL
) {
130 * This can happen if the key is deleted via
131 * pthread_key_delete without first setting the value
132 * to NULL in all threads. POSIX says that the
133 * destructor is not invoked in this case.
135 curthread
->specific
[key
].data
= NULL
;
136 curthread
->specific_data_count
--;
140 * If there is a destructor, call it
141 * with the key table entry unlocked:
143 if (destructor
!= NULL
) {
145 * Don't hold the lock while calling the
148 THR_LOCK_RELEASE(curthread
, &_keytable_lock
);
149 destructor(__DECONST(void *, data
));
150 THR_LOCK_ACQUIRE(curthread
, &_keytable_lock
);
154 THR_LOCK_RELEASE(curthread
, &_keytable_lock
);
155 free(curthread
->specific
);
156 curthread
->specific
= NULL
;
157 if (curthread
->specific_data_count
> 0)
158 stderr_debug("Thread %p has exited with leftover "
159 "thread-specific data after %d destructor iterations\n",
160 curthread
, PTHREAD_DESTRUCTOR_ITERATIONS
);
163 static inline struct pthread_specific_elem
*
164 pthread_key_allocate_data(void)
166 struct pthread_specific_elem
*new_data
;
168 new_data
= (struct pthread_specific_elem
*)
169 malloc(sizeof(struct pthread_specific_elem
) * PTHREAD_KEYS_MAX
);
170 if (new_data
!= NULL
) {
171 memset((void *) new_data
, 0,
172 sizeof(struct pthread_specific_elem
) * PTHREAD_KEYS_MAX
);
178 _pthread_setspecific(pthread_key_t key
, const void *value
)
180 struct pthread
*pthread
;
183 /* Point to the running thread: */
184 pthread
= tls_get_curthread();
186 if ((pthread
->specific
) ||
187 (pthread
->specific
= pthread_key_allocate_data())) {
188 if ((unsigned int)key
< PTHREAD_KEYS_MAX
) {
189 if (_thread_keytable
[key
].allocated
) {
190 if (pthread
->specific
[key
].data
== NULL
) {
192 pthread
->specific_data_count
++;
193 } else if (value
== NULL
)
194 pthread
->specific_data_count
--;
195 pthread
->specific
[key
].data
= value
;
196 pthread
->specific
[key
].seqno
=
197 _thread_keytable
[key
].seqno
;
209 _pthread_getspecific(pthread_key_t key
)
211 struct pthread
*pthread
;
214 /* Point to the running thread: */
215 pthread
= tls_get_curthread();
217 /* Check if there is specific data: */
218 if (pthread
->specific
!= NULL
&& (unsigned int)key
< PTHREAD_KEYS_MAX
) {
219 /* Check if this key has been used before: */
220 if (_thread_keytable
[key
].allocated
&&
221 (pthread
->specific
[key
].seqno
== _thread_keytable
[key
].seqno
)) {
222 /* Return the value: */
223 data
= pthread
->specific
[key
].data
;
226 * This key has not been used before, so return NULL
232 /* No specific data has been created, so just return NULL: */
234 return __DECONST(void *, data
);
237 __strong_reference(_pthread_key_create
, pthread_key_create
);
238 __strong_reference(_pthread_key_delete
, pthread_key_delete
);
239 __strong_reference(_pthread_getspecific
, pthread_getspecific
);
240 __strong_reference(_pthread_setspecific
, pthread_setspecific
);