8322 nl: misleading-indentation

[unleashed/tickless.git] / usr / src / lib / libc / port / threads / tsd.c

/*
 * 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
 * or http://www.opensolaris.org/os/licensing.
 * 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
 * /lib/libm.so.2 references them.  libm needs to be fixed.
 * Also, some older versions of the Studio compiler/debugger
 * components reference them.  These need to be fixed, too.
 */
#pragma weak _thr_getspecific = thr_getspecific
#pragma weak _thr_keycreate = thr_keycreate
#pragma weak _thr_setspecific = thr_setspecific

/*
 * 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.
 */
#define MAX_KEYS        0x08000000U

int
thr_keycreate(thread_key_t *pkey, void (*destructor)(void *))
{
        tsd_metadata_t *tsdm = &curthread->ul_uberdata->tsd_metadata;
        void (**old_data)(void *) = NULL;
        void (**new_data)(void *);
        uint_t old_nkeys;
        uint_t new_nkeys;

        lmutex_lock(&tsdm->tsdm_lock);

        /*
         * 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).
         */
        if (tsdm->tsdm_nused == (old_nkeys = tsdm->tsdm_nkeys)) {
                /*
                 * We need to allocate or double the number of keys.
                 * tsdm->tsdm_nused must always be a power of two.
                 */
                if ((new_nkeys = (old_nkeys << 1)) == 0)
                        new_nkeys = 8;

                if (new_nkeys > MAX_KEYS) {
                        lmutex_unlock(&tsdm->tsdm_lock);
                        return (EAGAIN);
                }
                if ((new_data = lmalloc(new_nkeys * sizeof (void *))) == NULL) {
                        lmutex_unlock(&tsdm->tsdm_lock);
                        return (ENOMEM);
                }
                if ((old_data = tsdm->tsdm_destro) == NULL) {
                        /* key == 0 is always invalid */
                        new_data[0] = TSD_UNALLOCATED;
                        tsdm->tsdm_nused = 1;
                } else {
                        (void) memcpy(new_data, old_data,
                            old_nkeys * sizeof (void *));
                }
                tsdm->tsdm_destro = new_data;
                tsdm->tsdm_nkeys = new_nkeys;
        }

        *pkey = tsdm->tsdm_nused;
        tsdm->tsdm_destro[tsdm->tsdm_nused++] = destructor;
        lmutex_unlock(&tsdm->tsdm_lock);

        if (old_data != NULL)
                lfree(old_data, old_nkeys * sizeof (void *));

        return (0);
}

#pragma weak _pthread_key_create = pthread_key_create
int
pthread_key_create(pthread_key_t *pkey, void (*destructor)(void *))
{
        return (thr_keycreate(pkey, destructor));
}

/*
 * 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);
 */
#pragma weak pthread_key_create_once_np = thr_keycreate_once
int
thr_keycreate_once(thread_key_t *keyp, void (*destructor)(void *))
{
        static mutex_t key_lock = DEFAULTMUTEX;
        thread_key_t key;
        int error;

        if (*keyp == THR_ONCE_KEY) {
                lmutex_lock(&key_lock);
                if (*keyp == THR_ONCE_KEY) {
                        error = thr_keycreate(&key, destructor);
                        if (error) {
                                lmutex_unlock(&key_lock);
                                return (error);
                        }
                        membar_producer();
                        *keyp = key;
                }
                lmutex_unlock(&key_lock);
        }
        membar_consumer();

        return (0);
}

int
pthread_key_delete(pthread_key_t key)
{
        tsd_metadata_t *tsdm = &curthread->ul_uberdata->tsd_metadata;

        lmutex_lock(&tsdm->tsdm_lock);

        if (key >= tsdm->tsdm_nused ||
            tsdm->tsdm_destro[key] == TSD_UNALLOCATED) {
                lmutex_unlock(&tsdm->tsdm_lock);
                return (EINVAL);
        }

        tsdm->tsdm_destro[key] = TSD_UNALLOCATED;
        lmutex_unlock(&tsdm->tsdm_lock);

        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
 * through a parameter -- thereby avoiding the unnecessary store/load pair
 * incurred by thr_getspecific().  Every once in a while, the Standards
 * get it right -- but usually by accident.
 */
void *
pthread_getspecific(pthread_key_t key)
{
        tsd_t *stsd;

        /*
         * 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.
         */
        if (key < TSD_NFAST)
                return (curthread->ul_ftsd[key]);

        if ((stsd = curthread->ul_stsd) != NULL && key < stsd->tsd_nalloc)
                return (stsd->tsd_data[key]);

        return (NULL);
}

int
thr_getspecific(thread_key_t key, void **valuep)
{
        tsd_t *stsd;

        /*
         * 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);

        if (key < TSD_NFAST)
                *valuep = curthread->ul_ftsd[key];
        else if ((stsd = curthread->ul_stsd) != NULL && key < stsd->tsd_nalloc)
                *valuep = stsd->tsd_data[key];
        else
                *valuep = NULL;

        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
thr_setspecific_slow(thread_key_t key, void *value)
{
        ulwp_t *self = curthread;
        tsd_metadata_t *tsdm = &self->ul_uberdata->tsd_metadata;
        tsd_t *stsd;
        tsd_t *ntsd;
        uint_t nkeys;

        /*
         * It isn't necessary to grab locks in this path;
         * tsdm->tsdm_nused can only increase.
         */
        if (key >= tsdm->tsdm_nused)
                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.
         */
        nkeys = ((stsd = self->ul_stsd) != NULL)? stsd->tsd_nalloc : 8;
        for (; key >= nkeys; nkeys <<= 1)
                continue;

        /*
         * Allocate the new TSD.
         */
        if ((ntsd = lmalloc(nkeys * sizeof (void *))) == NULL)
                return (ENOMEM);

        if (stsd != NULL) {
                /*
                 * Copy the old TSD across to the new.
                 */
                (void) memcpy(ntsd, stsd, stsd->tsd_nalloc * sizeof (void *));
                lfree(stsd, stsd->tsd_nalloc * sizeof (void *));
        }

        ntsd->tsd_nalloc = nkeys;
        ntsd->tsd_data[key] = value;
        self->ul_stsd = ntsd;

        return (0);
}

int
thr_setspecific(thread_key_t key, void *value)
{
        tsd_t *stsd;
        int ret;
        ulwp_t *self = curthread;

        /*
         * See the comment in thr_getspecific(), above.
         */
        if (key == 0)
                return (EINVAL);

        if (key < TSD_NFAST) {
                curthread->ul_ftsd[key] = value;
                return (0);
        }

        if ((stsd = curthread->ul_stsd) != NULL && key < stsd->tsd_nalloc) {
                stsd->tsd_data[key] = value;
                return (0);
        }

        /*
         * This is a critical region since we are dealing with memory
         * allocation and free. Similar protection required in tsd_free().
         */
        enter_critical(self);
        ret = thr_setspecific_slow(key, value);
        exit_critical(self);
        return (ret);
}

int
pthread_setspecific(pthread_key_t key, const void *value)
{
        return (thr_setspecific(key, (void *)value));
}

/*
 * 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.
 */
ptrdiff_t
_thr_slot_offset(thread_key_t key)
{
        if (key != 0 && key < TSD_NFAST)
                return ((ptrdiff_t)offsetof(ulwp_t, ul_ftsd[key]));
        return (-1);
}

/*
 * This is called by _thrp_exit() to apply destructors to the thread's tsd.
 */
void
tsd_exit()
{
        ulwp_t *self = curthread;
        tsd_metadata_t *tsdm = &self->ul_uberdata->tsd_metadata;
        thread_key_t key;
        int recheck;
        void *val;
        void (*func)(void *);

        lmutex_lock(&tsdm->tsdm_lock);

        do {
                recheck = 0;

                for (key = 1; key < TSD_NFAST &&
                    key < tsdm->tsdm_nused; key++) {
                        if ((func = tsdm->tsdm_destro[key]) != NULL &&
                            func != TSD_UNALLOCATED &&
                            (val = self->ul_ftsd[key]) != NULL) {
                                self->ul_ftsd[key] = NULL;
                                lmutex_unlock(&tsdm->tsdm_lock);
                                (*func)(val);
                                lmutex_lock(&tsdm->tsdm_lock);
                                recheck = 1;
                        }
                }

                if (self->ul_stsd == NULL)
                        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.
                 */
                for (; key < self->ul_stsd->tsd_nalloc &&
                    key < tsdm->tsdm_nused; key++) {
                        if ((func = tsdm->tsdm_destro[key]) != NULL &&
                            func != TSD_UNALLOCATED &&
                            (val = self->ul_stsd->tsd_data[key]) != NULL) {
                                self->ul_stsd->tsd_data[key] = NULL;
                                lmutex_unlock(&tsdm->tsdm_lock);
                                (*func)(val);
                                lmutex_lock(&tsdm->tsdm_lock);
                                recheck = 1;
                        }
                }
        } while (recheck);

        lmutex_unlock(&tsdm->tsdm_lock);

        /*
         * We're done; if we have slow TSD, we need to free it.
         */
        tsd_free(self);
}

void
tsd_free(ulwp_t *ulwp)
{
        tsd_t *stsd;
        ulwp_t *self = curthread;

        enter_critical(self);
        if ((stsd = ulwp->ul_stsd) != NULL)
                lfree(stsd, stsd->tsd_nalloc * sizeof (void *));
        ulwp->ul_stsd = NULL;
        exit_critical(self);
}