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