d/freebsd-dev
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Some third-party malloc(3) implementations use pthread_setspecific(3)

Browse Source 
to handle per-thread information.  Since our pthread_setspecific()
implementation calls calloc(3) to allocate per-thread specific data
storage, things get complicated.

Switch the allocator to use bare mmap(2).  There is some loss of the
allocated page, since e.g. on amd64, PTHREAD_KEYS_MAX * sizeof(struct
pthread_specific_elem) is 3K (it actually spans whole page due to
padding), but I believe it is more acceptable than additional code for
specialized allocator().

The alternatives would either to make the specific data array be part of
the struct thread, or use internal bindings to call the libc malloc,
avoiding interposing.

Also do the style pass over the thr_spec.c, esp. simplify the
conditionals nesting by returning early when an error detected.
Remove trivial comments.

Found by:	yuri@rawbw.com
PR:	200138
Sponsored by:	The FreeBSD Foundation
MFC after:	2 weeks
This commit is contained in:
Konstantin Belousov 2015-05-15 08:40:17 +00:00
parent 100ac78be1
commit 9be6046a47
Notes: svn2git 2020-12-20 02:59:44 +00:00 
svn path=/head/; revision=282948
1 changed files with 91 additions and 110 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

201
lib/libthr/thread/thr_spec.c
View File

@ -30,6 +30,7 @@
*/
#include "namespace.h"
#include <sys/mman.h>
#include <signal.h>
#include <stdlib.h>
#include <string.h>
@ -40,7 +41,6 @@
#include "thr_private.h"
/* Static variables: */
struct pthread_key _thread_keytable[PTHREAD_KEYS_MAX];
__weak_reference(_pthread_key_create, pthread_key_create);
@ -50,7 +50,7 @@ __weak_reference(_pthread_setspecific, pthread_setspecific);
int
_pthread_key_create(pthread_key_t *key, void (*destructor) (void *))
_pthread_key_create(pthread_key_t *key, void (*destructor)(void *))
{
struct pthread *curthread;
int i;
@ -59,7 +59,6 @@ _pthread_key_create(pthread_key_t *key, void (*destructor) (void *))
curthread = _get_curthread();
/* Lock the key table: */
THR_LOCK_ACQUIRE(curthread, &_keytable_lock);
for (i = 0; i < PTHREAD_KEYS_MAX; i++) {
@ -68,14 +67,12 @@ _pthread_key_create(pthread_key_t *key, void (*destructor) (void *))
_thread_keytable[i].destructor = destructor;
_thread_keytable[i].seqno++;
/* Unlock the key table: */
THR_LOCK_RELEASE(curthread, &_keytable_lock);
*key = i + 1;
return (0);
}
}
/* Unlock the key table: */
THR_LOCK_RELEASE(curthread, &_keytable_lock);
return (EAGAIN);
}
@ -83,44 +80,40 @@ _pthread_key_create(pthread_key_t *key, void (*destructor) (void *))
int
_pthread_key_delete(pthread_key_t userkey)
{
struct pthread *curthread = _get_curthread();
int key = userkey - 1;
int ret = 0;
struct pthread *curthread;
int key, ret;
if ((unsigned int)key < PTHREAD_KEYS_MAX) {
/* Lock the key table: */
THR_LOCK_ACQUIRE(curthread, &_keytable_lock);
if (_thread_keytable[key].allocated)
_thread_keytable[key].allocated = 0;
else
ret = EINVAL;
/* Unlock the key table: */
THR_LOCK_RELEASE(curthread, &_keytable_lock);
} else
key = userkey - 1;
if ((unsigned int)key >= PTHREAD_KEYS_MAX)
return (EINVAL);
curthread = _get_curthread();
THR_LOCK_ACQUIRE(curthread, &_keytable_lock);
if (_thread_keytable[key].allocated) {
_thread_keytable[key].allocated = 0;
ret = 0;
} else {
ret = EINVAL;
}
THR_LOCK_RELEASE(curthread, &_keytable_lock);
return (ret);
}
void
_thread_cleanupspecific(void)
{
struct pthread *curthread = _get_curthread();
void (*destructor)( void *);
const void *data = NULL;
int key;
int i;
struct pthread *curthread;
void (*destructor)(void *);
const void *data;
int i, key;
curthread = _get_curthread();
if (curthread->specific == NULL)
return;
/* Lock the key table: */
THR_LOCK_ACQUIRE(curthread, &_keytable_lock);
for (i = 0; (i < PTHREAD_DESTRUCTOR_ITERATIONS) &&
(curthread->specific_data_count > 0); i++) {
for (key = 0; (key < PTHREAD_KEYS_MAX) &&
(curthread->specific_data_count > 0); key++) {
for (i = 0; i < PTHREAD_DESTRUCTOR_ITERATIONS &&
curthread->specific_data_count > 0; i++) {
for (key = 0; key < PTHREAD_KEYS_MAX &&
curthread->specific_data_count > 0; key++) {
destructor = NULL;
if (_thread_keytable[key].allocated &&
@ -128,31 +121,29 @@ _thread_cleanupspecific(void)
if (curthread->specific[key].seqno ==
_thread_keytable[key].seqno) {
data = curthread->specific[key].data;
destructor = _thread_keytable[key].destructor;
destructor = _thread_keytable[key].
destructor;
}
curthread->specific[key].data = NULL;
curthread->specific_data_count--;
}
else if (curthread->specific[key].data != NULL) {
} else if (curthread->specific[key].data != NULL) {
/*
* This can happen if the key is deleted via
* pthread_key_delete without first setting the value
* to NULL in all threads. POSIX says that the
* destructor is not invoked in this case.
* This can happen if the key is
* deleted via pthread_key_delete
* without first setting the value to
* NULL in all threads. POSIX says
* that the destructor is not invoked
* in this case.
*/
curthread->specific[key].data = NULL;
curthread->specific_data_count--;
}
/*
* If there is a destructor, call it
* with the key table entry unlocked:
* If there is a destructor, call it with the
* key table entry unlocked.
*/
if (destructor != NULL) {
/*
* Don't hold the lock while calling the
* destructor:
*/
THR_LOCK_RELEASE(curthread, &_keytable_lock);
destructor(__DECONST(void *, data));
THR_LOCK_ACQUIRE(curthread, &_keytable_lock);
@ -160,102 +151,92 @@ _thread_cleanupspecific(void)
}
}
THR_LOCK_RELEASE(curthread, &_keytable_lock);
free(curthread->specific);
munmap(curthread->specific, PTHREAD_KEYS_MAX * sizeof(struct
pthread_specific_elem));
curthread->specific = NULL;
if (curthread->specific_data_count > 0)
if (curthread->specific_data_count > 0) {
stderr_debug("Thread %p has exited with leftover "
"thread-specific data after %d destructor iterations\n",
curthread, PTHREAD_DESTRUCTOR_ITERATIONS);
}
static inline struct pthread_specific_elem *
pthread_key_allocate_data(void)
{
struct pthread_specific_elem *new_data;
new_data = (struct pthread_specific_elem *)
calloc(1, sizeof(struct pthread_specific_elem) * PTHREAD_KEYS_MAX);
return (new_data);
}
}
int
_pthread_setspecific(pthread_key_t userkey, const void *value)
{
struct pthread *pthread;
pthread_key_t key = userkey - 1;
int ret = 0;
struct pthread *pthread;
void *tmp;
pthread_key_t key;
key = userkey - 1;
if ((unsigned int)key >= PTHREAD_KEYS_MAX ||
!_thread_keytable[key].allocated)
return (EINVAL);
/* Point to the running thread: */
pthread = _get_curthread();
if ((pthread->specific) ||
(pthread->specific = pthread_key_allocate_data())) {
if ((unsigned int)key < PTHREAD_KEYS_MAX) {
if (_thread_keytable[key].allocated) {
if (pthread->specific[key].data == NULL) {
if (value != NULL)
pthread->specific_data_count++;
} else if (value == NULL)
pthread->specific_data_count--;
pthread->specific[key].data = value;
pthread->specific[key].seqno =
_thread_keytable[key].seqno;
ret = 0;
} else
ret = EINVAL;
} else
ret = EINVAL;
} else
ret = ENOMEM;
return (ret);
if (pthread->specific == NULL) {
tmp = mmap(NULL, PTHREAD_KEYS_MAX *
sizeof(struct pthread_specific_elem),
PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANON, -1, 0);
if (tmp == MAP_FAILED)
return (ENOMEM);
pthread->specific = tmp;
}
if (pthread->specific[key].data == NULL) {
if (value != NULL)
pthread->specific_data_count++;
} else if (value == NULL)
pthread->specific_data_count--;
pthread->specific[key].data = value;
pthread->specific[key].seqno = _thread_keytable[key].seqno;
return (0);
}
void *
_pthread_getspecific(pthread_key_t userkey)
{
struct pthread *pthread;
pthread_key_t key = userkey - 1;
const void *data;
struct pthread *pthread;
const void *data;
pthread_key_t key;
/* Check if there is specific data. */
key = userkey - 1;
if ((unsigned int)key >= PTHREAD_KEYS_MAX)
return (NULL);
/* Point to the running thread: */
pthread = _get_curthread();
/* Check if there is specific data: */
if (pthread->specific != NULL && (unsigned int)key < PTHREAD_KEYS_MAX) {
/* Check if this key has been used before: */
if (_thread_keytable[key].allocated &&
(pthread->specific[key].seqno == _thread_keytable[key].seqno)) {
/* Return the value: */
data = pthread->specific[key].data;
} else {
/*
* This key has not been used before, so return NULL
* instead:
*/
data = NULL;
}
} else
/* No specific data has been created, so just return NULL: */
/* Check if this key has been used before. */
if (_thread_keytable[key].allocated && pthread->specific != NULL &&
pthread->specific[key].seqno == _thread_keytable[key].seqno) {
/* Return the value: */
data = pthread->specific[key].data;
} else {
/*
* This key has not been used before, so return NULL
* instead.
*/
data = NULL;
}
return (__DECONST(void *, data));
}
void
_thr_tsd_unload(struct dl_phdr_info *phdr_info)
{
struct pthread *curthread = _get_curthread();
struct pthread *curthread;
void (*destructor)(void *);
int key;
curthread = _get_curthread();
THR_LOCK_ACQUIRE(curthread, &_keytable_lock);
for (key = 0; key < PTHREAD_KEYS_MAX; key++) {
if (_thread_keytable[key].allocated) {
destructor = _thread_keytable[key].destructor;
if (destructor != NULL) {
if (__elf_phdr_match_addr(phdr_info, destructor))
_thread_keytable[key].destructor = NULL;
}
}
if (!_thread_keytable[key].allocated)
continue;
destructor = _thread_keytable[key].destructor;
if (destructor == NULL)
continue;
if (__elf_phdr_match_addr(phdr_info, destructor))
_thread_keytable[key].destructor = NULL;
}
THR_LOCK_RELEASE(curthread, &_keytable_lock);
}