Protect tsd array modification in thread data structures by getting the
[kopensolaris-gnu/glibc.git] / linuxthreads / specific.c
1 /* Linuxthreads - a simple clone()-based implementation of Posix        */
2 /* threads for Linux.                                                   */
3 /* Copyright (C) 1996 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 /* Thread-specific data */
16
17 #include <errno.h>
18 #include <stddef.h>
19 #include <stdlib.h>
20 #include "pthread.h"
21 #include "internals.h"
22 #include "spinlock.h"
23
24 /* Table of keys. */
25
26 static struct pthread_key_struct pthread_keys[PTHREAD_KEYS_MAX] =
27   { { 0, NULL } };
28
29 /* For debugging purposes put the maximum number of keys in a variable.  */
30 const int __linuxthreads_pthread_keys_max = PTHREAD_KEYS_MAX;
31 const int __linuxthreads_pthread_key_2ndlevel_size = PTHREAD_KEY_2NDLEVEL_SIZE;
32
33 /* Mutex to protect access to pthread_keys */
34
35 static pthread_mutex_t pthread_keys_mutex = PTHREAD_MUTEX_INITIALIZER;
36
37 /* Create a new key */
38
39 int __pthread_key_create(pthread_key_t * key, destr_function destr)
40 {
41   int i;
42
43   pthread_mutex_lock(&pthread_keys_mutex);
44   for (i = 0; i < PTHREAD_KEYS_MAX; i++) {
45     if (! pthread_keys[i].in_use) {
46       /* Mark key in use */
47       pthread_keys[i].in_use = 1;
48       pthread_keys[i].destr = destr;
49       pthread_mutex_unlock(&pthread_keys_mutex);
50       *key = i;
51       return 0;
52     }
53   }
54   pthread_mutex_unlock(&pthread_keys_mutex);
55   return EAGAIN;
56 }
57 strong_alias (__pthread_key_create, pthread_key_create)
58
59 /* Delete a key */
60
61 int pthread_key_delete(pthread_key_t key)
62 {
63   pthread_descr self = thread_self();
64   pthread_descr th;
65   unsigned int idx1st, idx2nd;
66
67   pthread_mutex_lock(&pthread_keys_mutex);
68   if (key >= PTHREAD_KEYS_MAX || !pthread_keys[key].in_use) {
69     pthread_mutex_unlock(&pthread_keys_mutex);
70     return EINVAL;
71   }
72   pthread_keys[key].in_use = 0;
73   pthread_keys[key].destr = NULL;
74   /* Set the value of the key to NULL in all running threads, so
75      that if the key is reallocated later by pthread_key_create, its
76      associated values will be NULL in all threads. */
77   idx1st = key / PTHREAD_KEY_2NDLEVEL_SIZE;
78   idx2nd = key % PTHREAD_KEY_2NDLEVEL_SIZE;
79   th = self;
80   do {
81     /* If the thread already is terminated don't modify the memory.  */
82     if (!th->p_terminated) {
83       /* pthread_exit() may try to free th->p_specific[idx1st] concurrently. */
84       __pthread_lock(THREAD_GETMEM(th, p_lock), self);
85       if (th->p_specific[idx1st] != NULL)
86         th->p_specific[idx1st][idx2nd] = NULL;
87       __pthread_unlock(THREAD_GETMEM(th, p_lock));
88     }
89     th = th->p_nextlive;
90   } while (th != self);
91   pthread_mutex_unlock(&pthread_keys_mutex);
92   return 0;
93 }
94
95 /* Set the value of a key */
96
97 int __pthread_setspecific(pthread_key_t key, const void * pointer)
98 {
99   pthread_descr self = thread_self();
100   unsigned int idx1st, idx2nd;
101
102   if (key >= PTHREAD_KEYS_MAX || !pthread_keys[key].in_use)
103     return EINVAL;
104   idx1st = key / PTHREAD_KEY_2NDLEVEL_SIZE;
105   idx2nd = key % PTHREAD_KEY_2NDLEVEL_SIZE;
106   if (THREAD_GETMEM_NC(self, p_specific[idx1st]) == NULL) {
107     void *newp = calloc(PTHREAD_KEY_2NDLEVEL_SIZE, sizeof (void *));
108     if (newp == NULL)
109       return ENOMEM;
110     THREAD_SETMEM_NC(self, p_specific[idx1st], newp);
111   }
112   THREAD_GETMEM_NC(self, p_specific[idx1st])[idx2nd] = (void *) pointer;
113   return 0;
114 }
115 strong_alias (__pthread_setspecific, pthread_setspecific)
116
117 /* Get the value of a key */
118
119 void * __pthread_getspecific(pthread_key_t key)
120 {
121   pthread_descr self = thread_self();
122   unsigned int idx1st, idx2nd;
123
124   if (key >= PTHREAD_KEYS_MAX)
125     return NULL;
126   idx1st = key / PTHREAD_KEY_2NDLEVEL_SIZE;
127   idx2nd = key % PTHREAD_KEY_2NDLEVEL_SIZE;
128   if (THREAD_GETMEM_NC(self, p_specific[idx1st]) == NULL
129       || !pthread_keys[key].in_use)
130     return NULL;
131   return THREAD_GETMEM_NC(self, p_specific[idx1st])[idx2nd];
132 }
133 strong_alias (__pthread_getspecific, pthread_getspecific)
134
135 /* Call the destruction routines on all keys */
136
137 void __pthread_destroy_specifics()
138 {
139   pthread_descr self = thread_self();
140   int i, j, round, found_nonzero;
141   destr_function destr;
142   void * data;
143
144   for (round = 0, found_nonzero = 1;
145        found_nonzero && round < PTHREAD_DESTRUCTOR_ITERATIONS;
146        round++) {
147     found_nonzero = 0;
148     for (i = 0; i < PTHREAD_KEY_1STLEVEL_SIZE; i++)
149       if (THREAD_GETMEM_NC(self, p_specific[i]) != NULL)
150         for (j = 0; j < PTHREAD_KEY_2NDLEVEL_SIZE; j++) {
151           destr = pthread_keys[i * PTHREAD_KEY_2NDLEVEL_SIZE + j].destr;
152           data = THREAD_GETMEM_NC(self, p_specific[i])[j];
153           if (destr != NULL && data != NULL) {
154             THREAD_GETMEM_NC(self, p_specific[i])[j] = NULL;
155             destr(data);
156             found_nonzero = 1;
157           }
158         }
159   }
160   __pthread_lock(THREAD_GETMEM(self, p_lock), self);
161   for (i = 0; i < PTHREAD_KEY_1STLEVEL_SIZE; i++) {
162     if (THREAD_GETMEM_NC(self, p_specific[i]) != NULL) {
163       free(THREAD_GETMEM_NC(self, p_specific[i]));
164       THREAD_SETMEM_NC(self, p_specific[i], NULL);
165     }
166   }
167   __pthread_unlock(THREAD_GETMEM(self, p_lock));
168 }
169
170 /* Thread-specific data for libc. */
171
172 static int
173 libc_internal_tsd_set(enum __libc_tsd_key_t key, const void * pointer)
174 {
175   pthread_descr self = thread_self();
176
177   THREAD_SETMEM_NC(self, p_libc_specific[key], (void *) pointer);
178   return 0;
179 }
180 int (*__libc_internal_tsd_set)(enum __libc_tsd_key_t key, const void * pointer)
181      = libc_internal_tsd_set;
182
183 static void *
184 libc_internal_tsd_get(enum __libc_tsd_key_t key)
185 {
186   pthread_descr self = thread_self();
187
188   return THREAD_GETMEM_NC(self, p_libc_specific[key]);
189 }
190 void * (*__libc_internal_tsd_get)(enum __libc_tsd_key_t key)
191      = libc_internal_tsd_get;