[c3e3bf]: tsd.c Maximize Restore History

Download this file

tsd.c    207 lines (169 with data), 5.5 kB

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
/*
* tsd.c
*
* Description:
* POSIX thread functions which implement thread-specific data (TSD).
*/
/*
* Why we can't use Win32 TLS
* --------------------------
*
* In a word: Destructors
*
* POSIX 1003.1 1996, Section 17 allows for optional destructor functions
* to be associated with each key value.
*
* This is my (revised) understanding of how destructors work:
*
* A key is created by a single thread, which then provides in every
* existing thread a TSD matching the same key, but initialised
* to NULL. Each new thread will also get a matching key with value NULL.
* The creating thread can optionally associate a function, called a
* destructor, with the key.
*
* When each thread exits, it calls the destructor function, which
* will then perform an action on that threads key value
* only. (Previously I thought that only the key creating thread ran
* the destructor on the key in all threads. That proposition is
* sounding scarier by the minute.)
*
* SOME APPROACHES TO MANAGING TSD MEMORY
*
* We could simply allocate enough memory on process startup to hold
* all possible data for all possible threads.
*
* We could allocate memory for just a table to hold a single pointer
* for each of POSIX_THREAD_KEYS_MAX keys. pthread_key_create() could then
* allocate space for POSIX_THREADS_MAX key values in one hit and store
* the location of the array in the first table.
*
* The standard also suggests that each thread might store key/value pairs
* on its private stack. This seems like a good idea. I had concerns about
* memory leaks and key re-use if a key was deleted, but the standard talks
* at length on this and basically says it's up to the application to
* make sure everything goes smoothly here, making sure that proper cleanup
* is done before a key is deleted. (section B.17.1.3 in particular)
*
* One more thing to note: destructors must never be called on deleted keys.
*/
#include <errno.h>
#include "pthread.h"
#include "implement.h"
int
pthread_key_create(pthread_key_t *key, void (*destructor)(void *))
{
pthread_key_t k;
int ret = 0;
/* CRITICAL SECTION */
pthread_mutex_lock(&_pthread_tsd_mutex);
if (_pthread_key_reuse_top >= 0)
{
k = _pthread_key_reuse[_pthread_key_reuse_top--];
}
else
{
if (_pthread_key_virgin_next < PTHREAD_KEYS_MAX)
{
k = _pthread_key_virgins[_pthread_key_virgin_next++];
}
else
{
return EAGAIN;
}
}
/* FIXME: This needs to be implemented as a list plus a re-use stack as for
thread IDs. _pthread_destructor_run_all() then needs to be changed
to push keys onto the re-use stack.
*/
_pthread_tsd_key_table[k].in_use = 0;
_pthread_tsd_key_table[k].status = _PTHREAD_TSD_KEY_INUSE;
_pthread_tsd_key_table[k].destructor = destructor;
pthread_mutex_unlock(&_pthread_tsd_mutex);
/* END CRITICAL SECTION */
*key = k;
return ret;
}
int
pthread_setspecific(pthread_key_t key, void *value)
{
void ** keys;
int inuse;
/* CRITICAL SECTION */
pthread_mutex_lock(&_pthread_tsd_mutex);
inuse = (_pthread_tsd_key_table[key].status == _PTHREAD_TSD_KEY_INUSE);
pthread_mutex_unlock(&_pthread_tsd_mutex);
/* END CRITICAL SECTION */
if (! inuse)
return EINVAL;
keys = (void **) TlsGetValue(_pthread_TSD_keys_TlsIndex);
if (keys[key] != NULL)
{
if (value == NULL)
{
/* Key is no longer in use by this thread. */
_pthread_tsd_key_table[key].in_use--;
}
}
else
{
if (value != NULL)
{
/* Key is now in use by this thread. */
_pthread_tsd_key_table[key].in_use++;
}
}
keys[key] = value;
return 0;
}
void *
pthread_getspecific(pthread_key_t key)
{
void ** keys;
int inuse;
/* CRITICAL SECTION */
pthread_mutex_lock(&_pthread_tsd_mutex);
inuse = (_pthread_tsd_key_table[key].status == _PTHREAD_TSD_KEY_INUSE);
pthread_mutex_unlock(&_pthread_tsd_mutex);
/* END CRITICAL SECTION */
if (! inuse)
return (void *) NULL;
keys = (void **) TlsGetValue(_pthread_TSD_keys_TlsIndex);
return keys[key];
}
/*
pthread_key_delete:
ANSI/IEEE Std 1003.1, 1996 Edition
Section 17.1.3.2
This function deletes a thread-specific data key previously returned by
pthread_key_create(). The thread specific data values associated with
"key" need not be NULL at the time pthread_key_delete() is called. It is
the responsibility of the application to free any application storage
or perform any cleanup actions for data structures related to the deleted
key or associated thread-specific data in any threads; this cleanup
can be done either before or after pthread_key_delete() is called. Any
attempt to use "key" following the call to pthread_key_delete()
results in undefined behaviour.
The pthread_key_delete() function shall be callable from within
destructor functions. No destructor functions shall be invoked by
pthread_key_delete(). Any destructor function that may have been associated
with "key" shall no longer be called upon thread exit.
*/
int
pthread_key_delete(pthread_key_t key)
{
int ret = 0;
/* CRITICAL SECTION */
pthread_mutex_lock(&_pthread_tsd_mutex);
if (_pthread_tsd_key_table[key].status != _PTHREAD_TSD_KEY_INUSE)
{
ret = EINVAL;
}
else
{
_pthread_tsd_key_table[key].status = _PTHREAD_TSD_KEY_DELETED;
_pthread_tsd_key_table[key].destructor = NULL;
}
pthread_mutex_unlock(&_pthread_tsd_mutex);
/* END CRITICAL SECTION */
return ret;
}