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