/*
* CDDL HEADER START
*
* The contents of this file are subject to the terms of the
* Common Development and Distribution License (the "License").
* You may not use this file except in compliance with the License.
*
* You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
* See the License for the specific language governing permissions
* and limitations under the License.
*
* When distributing Covered Code, include this CDDL HEADER in each
* file and include the License file at usr/src/OPENSOLARIS.LICENSE.
* If applicable, add the following below this CDDL HEADER, with the
* fields enclosed by brackets "[]" replaced with your own identifying
* information: Portions Copyright [yyyy] [name of copyright owner]
*
* CDDL HEADER END
*/
/*
* Copyright 2008 Sun Microsystems, Inc. All rights reserved.
* Use is subject to license terms.
*/
#pragma ident "%Z%%M% %I% %E% SMI"
#include "lint.h"
#include "thr_uberdata.h"
#include <stddef.h>
/*
* These symbols should not be exported from libc, but
* components reference them. These need to be fixed, too.
*/
/*
* 128 million keys should be enough for anyone.
* This allocates half a gigabyte of memory for the keys themselves and
* half a gigabyte of memory for each thread that uses the largest key.
*/
int
{
void (**new_data)(void *);
/*
* Unfortunately, pthread_getspecific() specifies that a
* pthread_getspecific() on an allocated key upon which the
* calling thread has not performed a pthread_setspecifc()
* must return NULL. Consider the following sequence:
*
* pthread_key_create(&key);
* pthread_setspecific(key, datum);
* pthread_key_delete(&key);
* pthread_key_create(&key);
* val = pthread_getspecific(key);
*
* According to POSIX, if the deleted key is reused for the new
* key returned by the second pthread_key_create(), then the
* pthread_getspecific() in the above example must return NULL
* (and not the stale datum). The implementation is thus left
* with two alternatives:
*
* (1) Reuse deleted keys. If this is to be implemented optimally,
* it requires that pthread_key_create() somehow associate
* the value NULL with the new (reused) key for each thread.
* Keeping the hot path fast and lock-free induces substantial
* complexity on the implementation.
*
* (2) Never reuse deleted keys. This allows the pthread_getspecific()
* implementation to simply perform a check against the number
* of keys set by the calling thread, returning NULL if the
* specified key is larger than the highest set key. This has
* the disadvantage of wasting memory (a program which simply
* loops calling pthread_key_create()/pthread_key_delete()
* will ultimately run out of memory), but permits an optimal
* pthread_getspecific() while allowing for simple key creation
* and deletion.
*
* All Solaris implementations have opted for (2). Given the
* ~10 years that this has been in the field, it is safe to assume
* that applications don't loop creating and destroying keys; we
* stick with (2).
*/
/*
* We need to allocate or double the number of keys.
* tsdm->tsdm_nused must always be a power of two.
*/
new_nkeys = 8;
return (EAGAIN);
}
return (ENOMEM);
}
/* key == 0 is always invalid */
new_data[0] = TSD_UNALLOCATED;
} else {
old_nkeys * sizeof (void *));
}
}
return (0);
}
int
{
}
/*
* Same as thr_keycreate(), above, except that the key creation
* is performed only once. This relies upon the fact that a key
* value of THR_ONCE_KEY is invalid, and requires that the key be
* allocated with a value of THR_ONCE_KEY before calling here.
* THR_ONCE_KEY and PTHREAD_ONCE_KEY_NP, defined in <thread.h>
* and <pthread.h> respectively, must have the same value.
* Example:
*
* static pthread_key_t key = PTHREAD_ONCE_KEY_NP;
* ...
* pthread_key_create_once_np(&key, destructor);
*/
int
{
int error;
if (*keyp == THR_ONCE_KEY) {
if (*keyp == THR_ONCE_KEY) {
if (error) {
return (error);
}
}
}
return (0);
}
int
{
return (EINVAL);
}
return (0);
}
/*
* Blessedly, the pthread_getspecific() interface is much better than the
* thr_getspecific() interface in that it cannot return an error status.
* Thus, if the key specified is bogus, pthread_getspecific()'s behavior
* is undefined. As an added bonus (and as an artificat of not returning
* an error code), the requested datum is returned rather than stored
* incurred by thr_getspecific(). Every once in a while, the Standards
* get it right -- but usually by accident.
*/
void *
{
/*
* We are cycle-shaving in this function because some
* applications make heavy use of it and one machine cycle
* can make a measurable difference in performance. This
* is why we waste a little memory and allocate a NULL value
* for the invalid key == 0 in curthread->ul_ftsd[0] rather
* than adjusting the key by subtracting one.
*/
return (NULL);
}
int
{
/*
* Amazingly, some application code (and worse, some particularly
* fugly Solaris library code) _relies_ on the fact that 0 is always
* an invalid key. To preserve this semantic, 0 is never returned
* as a key from thr_/pthread_key_create(); we explicitly check
* for it here and return EINVAL.
*/
if (key == 0)
return (EINVAL);
else
return (0);
}
/*
* We call thr_setspecific_slow() when the key specified
* is beyond the current thread's currently allocated range.
* This case is in a separate function because we want
* the compiler to optimize for the common case.
*/
static int
{
/*
* It isn't necessary to grab locks in this path;
* tsdm->tsdm_nused can only increase.
*/
return (EINVAL);
/*
* We would like to test (tsdm->tsdm_destro[key] == TSD_UNALLOCATED)
* here but that would require acquiring tsdm->tsdm_lock and we
* want to avoid locks in this path.
*
* We have a key which is (or at least _was_) valid. If this key
* is later deleted (or indeed, is deleted before we set the value),
* we don't care; such a condition would indicate an application
* race for which POSIX thankfully leaves the behavior unspecified.
*
* First, determine our new size. To avoid allocating more than we
* have to, continue doubling our size only until the new key fits.
* stsd->tsd_nalloc must always be a power of two.
*/
continue;
/*
* Allocate the new TSD.
*/
return (ENOMEM);
/*
* Copy the old TSD across to the new.
*/
}
return (0);
}
int
{
int ret;
/*
* See the comment in thr_getspecific(), above.
*/
if (key == 0)
return (EINVAL);
return (0);
}
return (0);
}
/*
* This is a critical region since we are dealing with memory
* allocation and free. Similar protection required in tsd_free().
*/
return (ret);
}
int
{
}
/*
* Contract-private interface for java. See PSARC/2003/159
*
* If the key falls within the TSD_NFAST range, return a non-negative
* offset that can be used by the caller to fetch the TSD data value
* directly out of the thread structure using %g7 (sparc) or %gs (x86).
* With the advent of TLS, %g7 and %gs are part of the ABI, even though
* the definition of the thread structure itself (ulwp_t) is private.
*
* We guarantee that the offset returned on sparc will fit within
* a SIMM13 field (that is, it is less than 2048).
*
* On failure (key is not in the TSD_NFAST range), return -1.
*/
{
return (-1);
}
/*
* This is called by _thrp_exit() to apply destructors to the thread's tsd.
*/
void
tsd_exit()
{
int recheck;
void *val;
void (*func)(void *);
do {
recheck = 0;
func != TSD_UNALLOCATED &&
recheck = 1;
}
}
continue;
/*
* Any of these destructors could cause us to grow the number
* TSD keys in the slow TSD; we cannot cache the slow TSD
* pointer through this loop.
*/
func != TSD_UNALLOCATED &&
recheck = 1;
}
}
} while (recheck);
/*
* We're done; if we have slow TSD, we need to free it.
*/
}
void
{
}