(struct pthread_key_delete_helper_args): New type.
[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 #include "restart.h"
24 #include <bits/libc-lock.h>
25
26
27 /* Table of keys. */
28
29 static struct pthread_key_struct pthread_keys[PTHREAD_KEYS_MAX] =
30   { { 0, NULL } };
31
32 /* For debugging purposes put the maximum number of keys in a variable.  */
33 const int __linuxthreads_pthread_keys_max = PTHREAD_KEYS_MAX;
34 const int __linuxthreads_pthread_key_2ndlevel_size = PTHREAD_KEY_2NDLEVEL_SIZE;
35
36 /* Mutex to protect access to pthread_keys */
37
38 static pthread_mutex_t pthread_keys_mutex = PTHREAD_MUTEX_INITIALIZER;
39
40 /* Create a new key */
41
42 int __pthread_key_create(pthread_key_t * key, destr_function destr)
43 {
44   int i;
45
46   pthread_mutex_lock(&pthread_keys_mutex);
47   for (i = 0; i < PTHREAD_KEYS_MAX; i++) {
48     if (! pthread_keys[i].in_use) {
49       /* Mark key in use */
50       pthread_keys[i].in_use = 1;
51       pthread_keys[i].destr = destr;
52       pthread_mutex_unlock(&pthread_keys_mutex);
53       *key = i;
54       return 0;
55     }
56   }
57   pthread_mutex_unlock(&pthread_keys_mutex);
58   return EAGAIN;
59 }
60 strong_alias (__pthread_key_create, pthread_key_create)
61
62 /* Reset deleted key's value to NULL in each live thread.
63  * NOTE: this executes in the context of the thread manager! */
64
65 struct pthread_key_delete_helper_args {
66   /* Damn, we need lexical closures in C! ;) */
67   unsigned int idx1st, idx2nd;
68   pthread_descr self;
69 };
70
71 static void pthread_key_delete_helper(void *arg, pthread_descr th)
72 {
73   struct pthread_key_delete_helper_args *args = arg;
74   unsigned int idx1st = args->idx1st;
75   unsigned int idx2nd = args->idx2nd;
76   pthread_descr self = args->self;
77
78   if (self == 0)
79     self = args->self = thread_self();
80
81   if (!th->p_terminated) {
82     /* pthread_exit() may try to free th->p_specific[idx1st] concurrently. */
83     __pthread_lock(THREAD_GETMEM(th, p_lock), self);
84     if (th->p_specific[idx1st] != NULL)
85       th->p_specific[idx1st][idx2nd] = NULL;
86     __pthread_unlock(THREAD_GETMEM(th, p_lock));
87   }
88 }
89
90 /* Delete a key */
91 int pthread_key_delete(pthread_key_t key)
92 {
93   pthread_descr self = thread_self();
94
95   pthread_mutex_lock(&pthread_keys_mutex);
96   if (key >= PTHREAD_KEYS_MAX || !pthread_keys[key].in_use) {
97     pthread_mutex_unlock(&pthread_keys_mutex);
98     return EINVAL;
99   }
100   pthread_keys[key].in_use = 0;
101   pthread_keys[key].destr = NULL;
102
103   /* Set the value of the key to NULL in all running threads, so
104      that if the key is reallocated later by pthread_key_create, its
105      associated values will be NULL in all threads. */
106
107   {
108     struct pthread_key_delete_helper_args args;
109     struct pthread_request request;
110
111     args.idx1st = key / PTHREAD_KEY_2NDLEVEL_SIZE;
112     args.idx2nd = key % PTHREAD_KEY_2NDLEVEL_SIZE;
113     args.self = 0;
114
115     request.req_thread = self;
116     request.req_kind = REQ_FOR_EACH_THREAD;
117     request.req_args.for_each.arg = &args;
118     request.req_args.for_each.fn = pthread_key_delete_helper;
119
120     TEMP_FAILURE_RETRY(__libc_write(__pthread_manager_request,
121                                     (char *) &request, sizeof(request)));
122     suspend(self);
123   }
124
125   pthread_mutex_unlock(&pthread_keys_mutex);
126   return 0;
127 }
128
129 /* Set the value of a key */
130
131 int __pthread_setspecific(pthread_key_t key, const void * pointer)
132 {
133   pthread_descr self = thread_self();
134   unsigned int idx1st, idx2nd;
135
136   if (key >= PTHREAD_KEYS_MAX || !pthread_keys[key].in_use)
137     return EINVAL;
138   idx1st = key / PTHREAD_KEY_2NDLEVEL_SIZE;
139   idx2nd = key % PTHREAD_KEY_2NDLEVEL_SIZE;
140   if (THREAD_GETMEM_NC(self, p_specific[idx1st]) == NULL) {
141     void *newp = calloc(PTHREAD_KEY_2NDLEVEL_SIZE, sizeof (void *));
142     if (newp == NULL)
143       return ENOMEM;
144     THREAD_SETMEM_NC(self, p_specific[idx1st], newp);
145   }
146   THREAD_GETMEM_NC(self, p_specific[idx1st])[idx2nd] = (void *) pointer;
147   return 0;
148 }
149 strong_alias (__pthread_setspecific, pthread_setspecific)
150
151 /* Get the value of a key */
152
153 void * __pthread_getspecific(pthread_key_t key)
154 {
155   pthread_descr self = thread_self();
156   unsigned int idx1st, idx2nd;
157
158   if (key >= PTHREAD_KEYS_MAX)
159     return NULL;
160   idx1st = key / PTHREAD_KEY_2NDLEVEL_SIZE;
161   idx2nd = key % PTHREAD_KEY_2NDLEVEL_SIZE;
162   if (THREAD_GETMEM_NC(self, p_specific[idx1st]) == NULL
163       || !pthread_keys[key].in_use)
164     return NULL;
165   return THREAD_GETMEM_NC(self, p_specific[idx1st])[idx2nd];
166 }
167 strong_alias (__pthread_getspecific, pthread_getspecific)
168
169 /* Call the destruction routines on all keys */
170
171 void __pthread_destroy_specifics()
172 {
173   pthread_descr self = thread_self();
174   int i, j, round, found_nonzero;
175   destr_function destr;
176   void * data;
177
178   for (round = 0, found_nonzero = 1;
179        found_nonzero && round < PTHREAD_DESTRUCTOR_ITERATIONS;
180        round++) {
181     found_nonzero = 0;
182     for (i = 0; i < PTHREAD_KEY_1STLEVEL_SIZE; i++)
183       if (THREAD_GETMEM_NC(self, p_specific[i]) != NULL)
184         for (j = 0; j < PTHREAD_KEY_2NDLEVEL_SIZE; j++) {
185           destr = pthread_keys[i * PTHREAD_KEY_2NDLEVEL_SIZE + j].destr;
186           data = THREAD_GETMEM_NC(self, p_specific[i])[j];
187           if (destr != NULL && data != NULL) {
188             THREAD_GETMEM_NC(self, p_specific[i])[j] = NULL;
189             destr(data);
190             found_nonzero = 1;
191           }
192         }
193   }
194   __pthread_lock(THREAD_GETMEM(self, p_lock), self);
195   for (i = 0; i < PTHREAD_KEY_1STLEVEL_SIZE; i++) {
196     if (THREAD_GETMEM_NC(self, p_specific[i]) != NULL) {
197       free(THREAD_GETMEM_NC(self, p_specific[i]));
198       THREAD_SETMEM_NC(self, p_specific[i], NULL);
199     }
200   }
201   __pthread_unlock(THREAD_GETMEM(self, p_lock));
202 }
203
204 /* Thread-specific data for libc. */
205
206 static int
207 libc_internal_tsd_set(enum __libc_tsd_key_t key, const void * pointer)
208 {
209   pthread_descr self = thread_self();
210
211   THREAD_SETMEM_NC(self, p_libc_specific[key], (void *) pointer);
212   return 0;
213 }
214 int (*__libc_internal_tsd_set)(enum __libc_tsd_key_t key, const void * pointer)
215      = libc_internal_tsd_set;
216
217 static void *
218 libc_internal_tsd_get(enum __libc_tsd_key_t key)
219 {
220   pthread_descr self = thread_self();
221
222   return THREAD_GETMEM_NC(self, p_libc_specific[key]);
223 }
224 void * (*__libc_internal_tsd_get)(enum __libc_tsd_key_t key)
225      = libc_internal_tsd_get;