src/pthread_tsd.c

/*
 * Copyright (c) 2000-2003, 2007, 2012 Apple Inc. All rights reserved.
 *
 * @APPLE_LICENSE_HEADER_START@
 *
 * This file contains Original Code and/or Modifications of Original Code
 * as defined in and that are subject to the Apple Public Source License
 * Version 2.0 (the 'License'). You may not use this file except in
 * compliance with the License. Please obtain a copy of the License at
 * http://www.opensource.apple.com/apsl/ and read it before using this
 * file.
 *
 * The Original Code and all software distributed under the License are
 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
 * Please see the License for the specific language governing rights and
 * limitations under the License.
 *
 * @APPLE_LICENSE_HEADER_END@
 */
/*
 * Copyright 1996 1995 by Open Software Foundation, Inc. 1997 1996 1995 1994 1993 1992 1991
 *              All Rights Reserved
 *
 * Permission to use, copy, modify, and distribute this software and
 * its documentation for any purpose and without fee is hereby granted,
 * provided that the above copyright notice appears in all copies and
 * that both the copyright notice and this permission notice appear in
 * supporting documentation.
 *
 * OSF DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE
 * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 * FOR A PARTICULAR PURPOSE.
 *
 * IN NO EVENT SHALL OSF BE LIABLE FOR ANY SPECIAL, INDIRECT, OR
 * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
 * LOSS OF USE, DATA OR PROFITS, WHETHER IN ACTION OF CONTRACT,
 * NEGLIGENCE, OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
 * WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 *
 */
/*
 * MkLinux
 */

/*
 * POSIX Pthread Library
 *   Thread Specific Data support
 *   NB: pthread_getspecific() is in a separate assembly file
 */

#include "internal.h"

#ifndef PTHREAD_KEY_LEGACY_SUPPORT
#if TARGET_OS_DRIVERKIT
#define PTHREAD_KEY_LEGACY_SUPPORT 0
#else
#define PTHREAD_KEY_LEGACY_SUPPORT 1
#endif // TARGET_OS_DRIVERKIT
#endif // PTHREAD_KEY_LEGACY_SUPPORT

#if !VARIANT_DYLD
// __pthread_tsd_first is first static key managed by libpthread.
// __pthread_tsd_max is the (observed) end of static key destructors.
// __pthread_tsd_start is the start of dynamic keys.
// __pthread_tsd_end is the end of dynamic keys.

static const int __pthread_tsd_first = __TSD_RESERVED_MAX + 1;
static const int __pthread_tsd_start = _INTERNAL_POSIX_THREAD_KEYS_MAX;
static const int __pthread_tsd_end = _INTERNAL_POSIX_THREAD_KEYS_END;

static int __pthread_tsd_max = __pthread_tsd_first;
static _pthread_lock __pthread_tsd_lock = _PTHREAD_LOCK_INITIALIZER;
#if PTHREAD_KEY_LEGACY_SUPPORT
static bool __pthread_key_legacy_behaviour = 0;
static bool __pthread_key_legacy_behaviour_log = 0;
#else
#define __pthread_key_legacy_behaviour 0
#define _pthread_tsd_cleanup_legacy(...)
#endif // PTHREAD_KEY_LEGACY_SUPPORT

// Omit support for pthread key destructors in the static archive for dyld.
// dyld does not create and destroy threads so these are not necessary.
//
// We store the bit-wise negation of the destructor so that a quick non-zero
// test can be used to determine if the destructor has been set, even if it is
// NULL. This means that a destructor of value ~0x0ull cannot be used. That
// shouldn't be a problem in practice since it isn't a valid function address.

static struct {
	uintptr_t destructor;
} _pthread_keys[_INTERNAL_POSIX_THREAD_KEYS_END];

// The pthread_tsd destruction order can be reverted to the old (pre-10.11) order
// by setting this environment variable.
void
_pthread_key_global_init(const char *envp[])
{
#if PTHREAD_KEY_LEGACY_SUPPORT
	if (_simple_getenv(envp, "PTHREAD_KEY_LEGACY_DESTRUCTOR_ORDER")) {
		__pthread_key_legacy_behaviour = true;
	}
	if (_simple_getenv(envp, "PTHREAD_KEY_LEGACY_DESTRUCTOR_ORDER_LOG")) {
		__pthread_key_legacy_behaviour_log = true;
	}
#endif // PTHREAD_KEY_LEGACY_SUPPORT
}

// Returns true if successful, false if destructor was already set.
static bool
_pthread_key_set_destructor(pthread_key_t key, void (*destructor)(void *))
{
	uintptr_t *ptr = &_pthread_keys[key].destructor;
	uintptr_t value = ~(uintptr_t)destructor;
	if (*ptr == 0) {
		*ptr = value;
		return true;
	}
	return false;
}

// Returns true if successful, false if the destructor was not set.
static bool
_pthread_key_unset_destructor(pthread_key_t key)
{
	uintptr_t *ptr = &_pthread_keys[key].destructor;
	if (*ptr != 0) {
		*ptr = 0;
		return true;
	}
	return false;
}

// Returns true if successful, false if the destructor was not set.
static bool
_pthread_key_get_destructor(pthread_key_t key, void (**destructor)(void *))
{
	uintptr_t value = _pthread_keys[key].destructor;
	if (destructor) {
		*destructor = (void (*)(void *))(~value);
	}
	return (value != 0);
}

int
pthread_key_create(pthread_key_t *key, void (*destructor)(void *))
{
	int res = EAGAIN; // Returns EAGAIN if key cannot be allocated.
	pthread_key_t k;

	_pthread_lock_lock(&__pthread_tsd_lock);
	for (k = __pthread_tsd_start; k < __pthread_tsd_end; k++) {
		if (_pthread_key_set_destructor(k, destructor)) {
			*key = k;
			res = 0;
			break;
		}
	}
	_pthread_lock_unlock(&__pthread_tsd_lock);

	return res;
}

int
pthread_key_delete(pthread_key_t key)
{
	int res = EINVAL; // Returns EINVAL if key is not allocated.

	_pthread_lock_lock(&__pthread_tsd_lock);
	if (key >= __pthread_tsd_start && key < __pthread_tsd_end) {
		if (_pthread_key_unset_destructor(key)) {
			pthread_t p;
			_pthread_lock_lock(&_pthread_list_lock);
			TAILQ_FOREACH(p, &__pthread_head, tl_plist) {
				// No lock for word-sized write.
				p->tsd[key] = 0;
			}
			_pthread_lock_unlock(&_pthread_list_lock);
			res = 0;
		}
	}
	_pthread_lock_unlock(&__pthread_tsd_lock);

	return res;
}

static inline int
_pthread_setspecific(pthread_t thread, pthread_key_t key, const void *value)
{
	int res = EINVAL;

	if (key >= __pthread_tsd_first && key < __pthread_tsd_end) {
		bool created = _pthread_key_get_destructor(key, NULL);
		if (key < __pthread_tsd_start || created) {
			thread->tsd[key] = (void *)value;
			res = 0;

			if (key < __pthread_tsd_start) {
				// XXX: is this really necessary?
				_pthread_key_set_destructor(key, NULL);
			}
			if (key > thread->max_tsd_key) {
				thread->max_tsd_key = (uint16_t)key;
			}
		}
	}

	return res;
}
#endif // !VARIANT_DYLD

int
pthread_setspecific(pthread_key_t key, const void *value)
{
#if VARIANT_DYLD
	return ENOTSUP;
#else
	return _pthread_setspecific(pthread_self(), key, value);
#endif // !VARIANT_DYLD
}

int
_pthread_setspecific_static(pthread_key_t key, void *value)
{
	int res = EINVAL;

#if !VARIANT_DYLD
	if (key < __pthread_tsd_start) {
		_pthread_setspecific_direct(key, value);
		res = 0;
	}
#endif // !VARIANT_DYLD

	return res;
}

void*
pthread_getspecific(pthread_key_t key)
{
	return _pthread_getspecific_direct(key);
}

#if !VARIANT_DYLD
int
pthread_introspection_setspecific_np(pthread_t thread,
		pthread_key_t key, const void *value)
{
	pthread_t self = _pthread_self();
	if (os_unlikely(self->introspection != PTHREAD_INTROSPECTION_THREAD_CREATE)) {
		PTHREAD_CLIENT_CRASH(0, "Calling pthread_introspection_setspecific_np "
				"outside of a CREATE introspection hook");
	}
	return _pthread_setspecific(thread, key, value);

}

void *
pthread_introspection_getspecific_np(pthread_t thread, pthread_key_t key)
{
	pthread_t self = _pthread_self();
	if (os_unlikely(self->introspection != PTHREAD_INTROSPECTION_THREAD_DESTROY)) {
		PTHREAD_CLIENT_CRASH(0, "Calling pthread_introspection_getspecific_np "
				"outside of a DESTROY introspection hook");
	}
	return thread->tsd[key];
}

static void
_pthread_tsd_cleanup_key(pthread_t self, pthread_key_t key)
{
	void (*destructor)(void *);
	if (_pthread_key_get_destructor(key, &destructor)) {
		void **ptr = &self->tsd[key];
		void *value = *ptr;
		if (value) {
			*ptr = NULL;
			if (destructor) {
				destructor(value);
			}
		}
	}
}

static void
_pthread_tsd_cleanup_new(pthread_t self)
{
	int j;

	// clean up all keys
	for (j = 0; j < PTHREAD_DESTRUCTOR_ITERATIONS; j++) {
		pthread_key_t k;
		for (k = __pthread_tsd_start; k <= self->max_tsd_key; k++) {
			_pthread_tsd_cleanup_key(self, k);
		}

		for (k = __pthread_tsd_first; k <= __pthread_tsd_max; k++) {
			_pthread_tsd_cleanup_key(self, k);
		}
	}

	self->max_tsd_key = 0;
}

#if PTHREAD_KEY_LEGACY_SUPPORT
#import <_simple.h>
#import <dlfcn.h>
static void
_pthread_tsd_behaviour_check(pthread_t self)
{
	// Iterate from dynamic-key start to dynamic-key end, if the key has both
	// a desctructor and a value then _pthread_tsd_cleanup_key would cause
	// us to re-trigger the destructor.
	pthread_key_t k;

	for (k = __pthread_tsd_start; k < __pthread_tsd_end; k++) {
		void (*destructor)(void *);
		if (_pthread_key_get_destructor(k, &destructor)) {
			void **ptr = &self->tsd[k];
			void *value = *ptr;
			if (value && destructor) {
				_simple_asl_log(ASL_LEVEL_ERR, "pthread_tsd",
						"warning: dynamic tsd keys dirty after static key cleanup loop.");
#if 0
				// enable this for debugging
				Dl_info i;
				if (dladdr(destructor, &i) == 0) {
					_simple_asl_log(ASL_LEVEL_ERR, "pthread_tsd", i.dli_fname);
					_simple_asl_log(ASL_LEVEL_ERR, "pthread_tsd", i.dli_saddr);
				}
#endif
			}
		}
	}

}

static void
_pthread_tsd_cleanup_legacy(pthread_t self)
{
	int j;

	// clean up dynamic keys first
	for (j = 0; j < PTHREAD_DESTRUCTOR_ITERATIONS; j++) {
		pthread_key_t k;
		for (k = __pthread_tsd_start; k <= self->max_tsd_key; k++) {
			_pthread_tsd_cleanup_key(self, k);
		}
	}

	self->max_tsd_key = 0;

	// clean up static keys
	for (j = 0; j < PTHREAD_DESTRUCTOR_ITERATIONS; j++) {
		pthread_key_t k;
		for (k = __pthread_tsd_first; k <= __pthread_tsd_max; k++) {
			_pthread_tsd_cleanup_key(self, k);
		}

		if (__pthread_key_legacy_behaviour_log != 0 && self->max_tsd_key != 0) {
			// max_tsd_key got dirtied, either by static or dynamic keys being
			// reset. check for any dirty dynamic keys.
			_pthread_tsd_behaviour_check(self);
		}
	}
}
#endif // PTHREAD_KEY_LEGACY_SUPPORT
#endif // !VARIANT_DYLD

void
_pthread_tsd_cleanup(pthread_t self)
{
#if !VARIANT_DYLD

	// unless __pthread_key_legacy_behaviour == 1, use the new pthread key
	// destructor order: (dynamic -> static) x5 -> (GC x5)

	if (__pthread_key_legacy_behaviour == 0) {
		_pthread_tsd_cleanup_new(self);
	} else {
		_pthread_tsd_cleanup_legacy(self);
	}
#endif // !VARIANT_DYLD
}

#if !VARIANT_DYLD
// XXX: key should be pthread_key_t
int
pthread_key_init_np(int key, void (*destructor)(void *))
{
	int res = EINVAL; // Returns EINVAL if key is out of range.
	if (key >= __pthread_tsd_first && key < __pthread_tsd_start) {
		_pthread_lock_lock(&__pthread_tsd_lock);
		_pthread_key_set_destructor(key, destructor);
		if (key > __pthread_tsd_max) {
			__pthread_tsd_max = key;
		}
		_pthread_lock_unlock(&__pthread_tsd_lock);
		res = 0;
	}
	return res;
}
#endif // !VARIANT_DYLD

#undef pthread_self
pthread_t
pthread_self(void)
{
	pthread_t self = _pthread_self_direct();
	_pthread_validate_signature(self);
	return self;
}

// rdar://57406917
pthread_t
_pthread_self(void)
{
	return pthread_self();
}
Commit	Line	Data
	1	/*
	2	* Copyright (c) 2000-2003, 2007, 2012 Apple Inc. All rights reserved.
	3	*
	4	* @APPLE_LICENSE_HEADER_START@
	5	*
	6	* This file contains Original Code and/or Modifications of Original Code
	7	* as defined in and that are subject to the Apple Public Source License
	8	* Version 2.0 (the 'License'). You may not use this file except in
	9	* compliance with the License. Please obtain a copy of the License at
	10	* http://www.opensource.apple.com/apsl/ and read it before using this
	11	* file.
	12	*
	13	* The Original Code and all software distributed under the License are
	14	* distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
	15	* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
	16	* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
	17	* FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
	18	* Please see the License for the specific language governing rights and
	19	* limitations under the License.
	20	*
	21	* @APPLE_LICENSE_HEADER_END@
	22	*/
	23	/*
	24	* Copyright 1996 1995 by Open Software Foundation, Inc. 1997 1996 1995 1994 1993 1992 1991
	25	* All Rights Reserved
	26	*
	27	* Permission to use, copy, modify, and distribute this software and
	28	* its documentation for any purpose and without fee is hereby granted,
	29	* provided that the above copyright notice appears in all copies and
	30	* that both the copyright notice and this permission notice appear in
	31	* supporting documentation.
	32	*
	33	* OSF DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE
	34	* INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
	35	* FOR A PARTICULAR PURPOSE.
	36	*
	37	* IN NO EVENT SHALL OSF BE LIABLE FOR ANY SPECIAL, INDIRECT, OR
	38	* CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
	39	* LOSS OF USE, DATA OR PROFITS, WHETHER IN ACTION OF CONTRACT,
	40	* NEGLIGENCE, OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION
	41	* WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
	42	*
	43	*/
	44	/*
	45	* MkLinux
	46	*/
	47
	48	/*
	49	* POSIX Pthread Library
	50	* Thread Specific Data support
	51	* NB: pthread_getspecific() is in a separate assembly file
	52	*/
	53
	54	#include "internal.h"
	55
	56	#ifndef PTHREAD_KEY_LEGACY_SUPPORT
	57	#if TARGET_OS_DRIVERKIT
	58	#define PTHREAD_KEY_LEGACY_SUPPORT 0
	59	#else
	60	#define PTHREAD_KEY_LEGACY_SUPPORT 1
	61	#endif // TARGET_OS_DRIVERKIT
	62	#endif // PTHREAD_KEY_LEGACY_SUPPORT
	63
	64	#if !VARIANT_DYLD
	65	// __pthread_tsd_first is first static key managed by libpthread.
	66	// __pthread_tsd_max is the (observed) end of static key destructors.
	67	// __pthread_tsd_start is the start of dynamic keys.
	68	// __pthread_tsd_end is the end of dynamic keys.
	69
	70	static const int __pthread_tsd_first = __TSD_RESERVED_MAX + 1;
	71	static const int __pthread_tsd_start = _INTERNAL_POSIX_THREAD_KEYS_MAX;
	72	static const int __pthread_tsd_end = _INTERNAL_POSIX_THREAD_KEYS_END;
	73
	74	static int __pthread_tsd_max = __pthread_tsd_first;
	75	static _pthread_lock __pthread_tsd_lock = _PTHREAD_LOCK_INITIALIZER;
	76	#if PTHREAD_KEY_LEGACY_SUPPORT
	77	static bool __pthread_key_legacy_behaviour = 0;
	78	static bool __pthread_key_legacy_behaviour_log = 0;
	79	#else
	80	#define __pthread_key_legacy_behaviour 0
	81	#define _pthread_tsd_cleanup_legacy(...)
	82	#endif // PTHREAD_KEY_LEGACY_SUPPORT
	83
	84	// Omit support for pthread key destructors in the static archive for dyld.
	85	// dyld does not create and destroy threads so these are not necessary.
	86	//
	87	// We store the bit-wise negation of the destructor so that a quick non-zero
	88	// test can be used to determine if the destructor has been set, even if it is
	89	// NULL. This means that a destructor of value ~0x0ull cannot be used. That
	90	// shouldn't be a problem in practice since it isn't a valid function address.
	91
	92	static struct {
	93	uintptr_t destructor;
	94	} _pthread_keys[_INTERNAL_POSIX_THREAD_KEYS_END];
	95
	96	// The pthread_tsd destruction order can be reverted to the old (pre-10.11) order
	97	// by setting this environment variable.
	98	void
	99	_pthread_key_global_init(const char *envp[])
	100	{
	101	#if PTHREAD_KEY_LEGACY_SUPPORT
	102	if (_simple_getenv(envp, "PTHREAD_KEY_LEGACY_DESTRUCTOR_ORDER")) {
	103	__pthread_key_legacy_behaviour = true;
	104	}
	105	if (_simple_getenv(envp, "PTHREAD_KEY_LEGACY_DESTRUCTOR_ORDER_LOG")) {
	106	__pthread_key_legacy_behaviour_log = true;
	107	}
	108	#endif // PTHREAD_KEY_LEGACY_SUPPORT
	109	}
	110
	111	// Returns true if successful, false if destructor was already set.
	112	static bool
	113	_pthread_key_set_destructor(pthread_key_t key, void (destructor)(void ))
	114	{
	115	uintptr_t *ptr = &_pthread_keys[key].destructor;
	116	uintptr_t value = ~(uintptr_t)destructor;
	117	if (*ptr == 0) {
	118	*ptr = value;
	119	return true;
	120	}
	121	return false;
	122	}
	123
	124	// Returns true if successful, false if the destructor was not set.
	125	static bool
	126	_pthread_key_unset_destructor(pthread_key_t key)
	127	{
	128	uintptr_t *ptr = &_pthread_keys[key].destructor;
	129	if (*ptr != 0) {
	130	*ptr = 0;
	131	return true;
	132	}
	133	return false;
	134	}
	135
	136	// Returns true if successful, false if the destructor was not set.
	137	static bool
	138	_pthread_key_get_destructor(pthread_key_t key, void (*destructor)(void ))
	139	{
	140	uintptr_t value = _pthread_keys[key].destructor;
	141	if (destructor) {
	142	destructor = (void ()(void *))(~value);
	143	}
	144	return (value != 0);
	145	}
	146
	147	int
	148	pthread_key_create(pthread_key_t key, void (destructor)(void *))
	149	{
	150	int res = EAGAIN; // Returns EAGAIN if key cannot be allocated.
	151	pthread_key_t k;
	152
	153	_pthread_lock_lock(&__pthread_tsd_lock);
	154	for (k = __pthread_tsd_start; k < __pthread_tsd_end; k++) {
	155	if (_pthread_key_set_destructor(k, destructor)) {
	156	*key = k;
	157	res = 0;
	158	break;
	159	}
	160	}
	161	_pthread_lock_unlock(&__pthread_tsd_lock);
	162
	163	return res;
	164	}
	165
	166	int
	167	pthread_key_delete(pthread_key_t key)
	168	{
	169	int res = EINVAL; // Returns EINVAL if key is not allocated.
	170
	171	_pthread_lock_lock(&__pthread_tsd_lock);
	172	if (key >= __pthread_tsd_start && key < __pthread_tsd_end) {
	173	if (_pthread_key_unset_destructor(key)) {
	174	pthread_t p;
	175	_pthread_lock_lock(&_pthread_list_lock);
	176	TAILQ_FOREACH(p, &__pthread_head, tl_plist) {
	177	// No lock for word-sized write.
	178	p->tsd[key] = 0;
	179	}
	180	_pthread_lock_unlock(&_pthread_list_lock);
	181	res = 0;
	182	}
	183	}
	184	_pthread_lock_unlock(&__pthread_tsd_lock);
	185
	186	return res;
	187	}
	188
	189	static inline int
	190	_pthread_setspecific(pthread_t thread, pthread_key_t key, const void *value)
	191	{
	192	int res = EINVAL;
	193
	194	if (key >= __pthread_tsd_first && key < __pthread_tsd_end) {
	195	bool created = _pthread_key_get_destructor(key, NULL);
	196	if (key < __pthread_tsd_start \|\| created) {
	197	thread->tsd[key] = (void *)value;
	198	res = 0;
	199
	200	if (key < __pthread_tsd_start) {
	201	// XXX: is this really necessary?
	202	_pthread_key_set_destructor(key, NULL);
	203	}
	204	if (key > thread->max_tsd_key) {
	205	thread->max_tsd_key = (uint16_t)key;
	206	}
	207	}
	208	}
	209
	210	return res;
	211	}
	212	#endif // !VARIANT_DYLD
	213
	214	int
	215	pthread_setspecific(pthread_key_t key, const void *value)
	216	{
	217	#if VARIANT_DYLD
	218	return ENOTSUP;
	219	#else
	220	return _pthread_setspecific(pthread_self(), key, value);
	221	#endif // !VARIANT_DYLD
	222	}
	223
	224	int
	225	_pthread_setspecific_static(pthread_key_t key, void *value)
	226	{
	227	int res = EINVAL;
	228
	229	#if !VARIANT_DYLD
	230	if (key < __pthread_tsd_start) {
	231	_pthread_setspecific_direct(key, value);
	232	res = 0;
	233	}
	234	#endif // !VARIANT_DYLD
	235
	236	return res;
	237	}
	238
	239	void*
	240	pthread_getspecific(pthread_key_t key)
	241	{
	242	return _pthread_getspecific_direct(key);
	243	}
	244
	245	#if !VARIANT_DYLD
	246	int
	247	pthread_introspection_setspecific_np(pthread_t thread,
	248	pthread_key_t key, const void *value)
	249	{
	250	pthread_t self = _pthread_self();
	251	if (os_unlikely(self->introspection != PTHREAD_INTROSPECTION_THREAD_CREATE)) {
	252	PTHREAD_CLIENT_CRASH(0, "Calling pthread_introspection_setspecific_np "
	253	"outside of a CREATE introspection hook");
	254	}
	255	return _pthread_setspecific(thread, key, value);
	256
	257	}
	258
	259	void *
	260	pthread_introspection_getspecific_np(pthread_t thread, pthread_key_t key)
	261	{
	262	pthread_t self = _pthread_self();
	263	if (os_unlikely(self->introspection != PTHREAD_INTROSPECTION_THREAD_DESTROY)) {
	264	PTHREAD_CLIENT_CRASH(0, "Calling pthread_introspection_getspecific_np "
	265	"outside of a DESTROY introspection hook");
	266	}
	267	return thread->tsd[key];
	268	}
	269
	270	static void
	271	_pthread_tsd_cleanup_key(pthread_t self, pthread_key_t key)
	272	{
	273	void (destructor)(void );
	274	if (_pthread_key_get_destructor(key, &destructor)) {
	275	void **ptr = &self->tsd[key];
	276	void value = ptr;
	277	if (value) {
	278	*ptr = NULL;
	279	if (destructor) {
	280	destructor(value);
	281	}
	282	}
	283	}
	284	}
	285
	286	static void
	287	_pthread_tsd_cleanup_new(pthread_t self)
	288	{
	289	int j;
	290
	291	// clean up all keys
	292	for (j = 0; j < PTHREAD_DESTRUCTOR_ITERATIONS; j++) {
	293	pthread_key_t k;
	294	for (k = __pthread_tsd_start; k <= self->max_tsd_key; k++) {
	295	_pthread_tsd_cleanup_key(self, k);
	296	}
	297
	298	for (k = __pthread_tsd_first; k <= __pthread_tsd_max; k++) {
	299	_pthread_tsd_cleanup_key(self, k);
	300	}
	301	}
	302
	303	self->max_tsd_key = 0;
	304	}
	305
	306	#if PTHREAD_KEY_LEGACY_SUPPORT
	307	#import <_simple.h>
	308	#import <dlfcn.h>
	309	static void
	310	_pthread_tsd_behaviour_check(pthread_t self)
	311	{
	312	// Iterate from dynamic-key start to dynamic-key end, if the key has both
	313	// a desctructor and a value then _pthread_tsd_cleanup_key would cause
	314	// us to re-trigger the destructor.
	315	pthread_key_t k;
	316
	317	for (k = __pthread_tsd_start; k < __pthread_tsd_end; k++) {
	318	void (destructor)(void );
	319	if (_pthread_key_get_destructor(k, &destructor)) {
	320	void **ptr = &self->tsd[k];
	321	void value = ptr;
	322	if (value && destructor) {
	323	_simple_asl_log(ASL_LEVEL_ERR, "pthread_tsd",
	324	"warning: dynamic tsd keys dirty after static key cleanup loop.");
	325	#if 0
	326	// enable this for debugging
	327	Dl_info i;
	328	if (dladdr(destructor, &i) == 0) {
	329	_simple_asl_log(ASL_LEVEL_ERR, "pthread_tsd", i.dli_fname);
	330	_simple_asl_log(ASL_LEVEL_ERR, "pthread_tsd", i.dli_saddr);
	331	}
	332	#endif
	333	}
	334	}
	335	}
	336
	337	}
	338
	339	static void
	340	_pthread_tsd_cleanup_legacy(pthread_t self)
	341	{
	342	int j;
	343
	344	// clean up dynamic keys first
	345	for (j = 0; j < PTHREAD_DESTRUCTOR_ITERATIONS; j++) {
	346	pthread_key_t k;
	347	for (k = __pthread_tsd_start; k <= self->max_tsd_key; k++) {
	348	_pthread_tsd_cleanup_key(self, k);
	349	}
	350	}
	351
	352	self->max_tsd_key = 0;
	353
	354	// clean up static keys
	355	for (j = 0; j < PTHREAD_DESTRUCTOR_ITERATIONS; j++) {
	356	pthread_key_t k;
	357	for (k = __pthread_tsd_first; k <= __pthread_tsd_max; k++) {
	358	_pthread_tsd_cleanup_key(self, k);
	359	}
	360
	361	if (__pthread_key_legacy_behaviour_log != 0 && self->max_tsd_key != 0) {
	362	// max_tsd_key got dirtied, either by static or dynamic keys being
	363	// reset. check for any dirty dynamic keys.
	364	_pthread_tsd_behaviour_check(self);
	365	}
	366	}
	367	}
	368	#endif // PTHREAD_KEY_LEGACY_SUPPORT
	369	#endif // !VARIANT_DYLD
	370
	371	void
	372	_pthread_tsd_cleanup(pthread_t self)
	373	{
	374	#if !VARIANT_DYLD
	375
	376	// unless __pthread_key_legacy_behaviour == 1, use the new pthread key
	377	// destructor order: (dynamic -> static) x5 -> (GC x5)
	378
	379	if (__pthread_key_legacy_behaviour == 0) {
	380	_pthread_tsd_cleanup_new(self);
	381	} else {
	382	_pthread_tsd_cleanup_legacy(self);
	383	}
	384	#endif // !VARIANT_DYLD
	385	}
	386
	387	#if !VARIANT_DYLD
	388	// XXX: key should be pthread_key_t
	389	int
	390	pthread_key_init_np(int key, void (destructor)(void ))
	391	{
	392	int res = EINVAL; // Returns EINVAL if key is out of range.
	393	if (key >= __pthread_tsd_first && key < __pthread_tsd_start) {
	394	_pthread_lock_lock(&__pthread_tsd_lock);
	395	_pthread_key_set_destructor(key, destructor);
	396	if (key > __pthread_tsd_max) {
	397	__pthread_tsd_max = key;
	398	}
	399	_pthread_lock_unlock(&__pthread_tsd_lock);
	400	res = 0;
	401	}
	402	return res;
	403	}
	404	#endif // !VARIANT_DYLD
	405
	406	#undef pthread_self
	407	pthread_t
	408	pthread_self(void)
	409	{
	410	pthread_t self = _pthread_self_direct();
	411	_pthread_validate_signature(self);
	412	return self;
	413	}
	414
	415	// rdar://57406917
	416	pthread_t
	417	_pthread_self(void)
	418	{
	419	return pthread_self();
	420	}