/*
 * 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.
 */

/*
 * This file contains most of the functionality
 * required to support the threads portion of libc_db.
 */

#include "lint.h"
#include "thr_uberdata.h"

static void
tdb_event_ready(void) {}

static void
tdb_event_sleep(void) {}

static void
tdb_event_switchto(void) {}

static void
tdb_event_switchfrom(void) {}

static void
tdb_event_lock_try(void) {}

static void
tdb_event_catchsig(void) {}

static void
tdb_event_idle(void) {}

static void
tdb_event_create(void) {}

static void
tdb_event_death(void) {}

static void
tdb_event_preempt(void) {}

static void
tdb_event_pri_inherit(void) {}

static void
tdb_event_reap(void) {}

static void
tdb_event_concurrency(void) {}

static void
tdb_event_timeout(void) {}

/*
 * uberflags.uf_tdb_register_sync is set to REGISTER_SYNC_ENABLE by a debugger
 * to empty the table and then enable synchronization object registration.
 *
 * uberflags.uf_tdb_register_sync is set to REGISTER_SYNC_DISABLE by a debugger
 * to empty the table and then disable synchronization object registration.
 */

const tdb_ev_func_t tdb_events[TD_MAX_EVENT_NUM - TD_MIN_EVENT_NUM + 1] = {
	tdb_event_ready,
	tdb_event_sleep,
	tdb_event_switchto,
	tdb_event_switchfrom,
	tdb_event_lock_try,
	tdb_event_catchsig,
	tdb_event_idle,
	tdb_event_create,
	tdb_event_death,
	tdb_event_preempt,
	tdb_event_pri_inherit,
	tdb_event_reap,
	tdb_event_concurrency,
	tdb_event_timeout
};

#if TDB_HASH_SHIFT != 15
#error "this is all broken because TDB_HASH_SHIFT is not 15"
#endif

static uint_t
tdb_addr_hash(void *addr)
{
	/*
	 * This knows for a fact that the hash table has
	 * 32K entries; that is, that TDB_HASH_SHIFT is 15.
	 */
#ifdef	_LP64
	uint64_t value60 = ((uintptr_t)addr >> 4);	/* 60 bits */
	uint32_t value30 = (value60 >> 30) ^ (value60 & 0x3fffffff);
#else
	uint32_t value30 = ((uintptr_t)addr >> 2);	/* 30 bits */
#endif
	return ((value30 >> 15) ^ (value30 & 0x7fff));
}

static tdb_sync_stats_t *
alloc_sync_addr(void *addr)
{
	uberdata_t *udp = curthread->ul_uberdata;
	tdb_t *tdbp = &udp->tdb;
	tdb_sync_stats_t *sap;

	ASSERT(MUTEX_OWNED(&udp->tdb_hash_lock, curthread));

	if ((sap = tdbp->tdb_sync_addr_free) == NULL) {
		void *vaddr;
		int i;

		/*
		 * Don't keep trying after mmap() has already failed.
		 */
		if (tdbp->tdb_hash_alloc_failed)
			return (NULL);

		/* double the allocation each time */
		tdbp->tdb_sync_alloc *= 2;
		if ((vaddr = mmap(NULL,
		    tdbp->tdb_sync_alloc * sizeof (tdb_sync_stats_t),
		    PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANON,
		    -1, (off_t)0)) == MAP_FAILED) {
			tdbp->tdb_hash_alloc_failed = 1;
			return (NULL);
		}
		sap = tdbp->tdb_sync_addr_free = vaddr;
		for (i = 1; i < tdbp->tdb_sync_alloc; sap++, i++)
			sap->next = (uintptr_t)(sap + 1);
		sap->next = (uintptr_t)0;
		tdbp->tdb_sync_addr_last = sap;

		sap = tdbp->tdb_sync_addr_free;
	}

	tdbp->tdb_sync_addr_free = (tdb_sync_stats_t *)(uintptr_t)sap->next;
	sap->next = (uintptr_t)0;
	sap->sync_addr = (uintptr_t)addr;
	(void) memset(&sap->un, 0, sizeof (sap->un));
	return (sap);
}

static void
initialize_sync_hash()
{
	uberdata_t *udp = curthread->ul_uberdata;
	tdb_t *tdbp = &udp->tdb;
	uint64_t *addr_hash;
	tdb_sync_stats_t *sap;
	void *vaddr;
	int i;

	if (tdbp->tdb_hash_alloc_failed)
		return;
	lmutex_lock(&udp->tdb_hash_lock);
	if (udp->uberflags.uf_tdb_register_sync == REGISTER_SYNC_DISABLE) {
		/*
		 * There is no point allocating the hash table
		 * if we are disabling registration.
		 */
		udp->uberflags.uf_tdb_register_sync = REGISTER_SYNC_OFF;
		lmutex_unlock(&udp->tdb_hash_lock);
		return;
	}
	if (tdbp->tdb_sync_addr_hash != NULL || tdbp->tdb_hash_alloc_failed) {
		lmutex_unlock(&udp->tdb_hash_lock);
		return;
	}
	/* start with a free list of 2k elements */
	tdbp->tdb_sync_alloc = 2*1024;
	if ((vaddr = mmap(NULL, TDB_HASH_SIZE * sizeof (uint64_t) +
	    tdbp->tdb_sync_alloc * sizeof (tdb_sync_stats_t),
	    PROT_READ|PROT_WRITE, MAP_PRIVATE|MAP_ANON,
	    -1, (off_t)0)) == MAP_FAILED) {
		tdbp->tdb_hash_alloc_failed = 1;
		return;
	}
	addr_hash = vaddr;

	/* initialize the free list */
	tdbp->tdb_sync_addr_free = sap =
	    (tdb_sync_stats_t *)&addr_hash[TDB_HASH_SIZE];
	for (i = 1; i < tdbp->tdb_sync_alloc; sap++, i++)
		sap->next = (uintptr_t)(sap + 1);
	sap->next = (uintptr_t)0;
	tdbp->tdb_sync_addr_last = sap;

	/* insert &udp->tdb_hash_lock itself into the new (empty) table */
	udp->tdb_hash_lock_stats.next = (uintptr_t)0;
	udp->tdb_hash_lock_stats.sync_addr = (uintptr_t)&udp->tdb_hash_lock;
	addr_hash[tdb_addr_hash(&udp->tdb_hash_lock)] =
	    (uintptr_t)&udp->tdb_hash_lock_stats;

	tdbp->tdb_register_count = 1;
	/* assign to tdb_sync_addr_hash only after fully initialized */
	membar_producer();
	tdbp->tdb_sync_addr_hash = addr_hash;
	lmutex_unlock(&udp->tdb_hash_lock);
}

tdb_sync_stats_t *
tdb_sync_obj_register(void *addr, int *new)
{
	ulwp_t *self = curthread;
	uberdata_t *udp = self->ul_uberdata;
	tdb_t *tdbp = &udp->tdb;
	uint64_t *sapp;
	tdb_sync_stats_t *sap = NULL;
	int locked = 0;
	int i;

	/*
	 * Don't start statistics collection until
	 * we have initialized the primary link map.
	 */
	if (!self->ul_primarymap)
		return (NULL);

	if (new)
		*new = 0;
	/*
	 * To avoid recursion problems, we must do two things:
	 * 1. Make a special case for tdb_hash_lock (we use it internally).
	 * 2. Deal with the dynamic linker's lock interface:
	 *    When calling any external function, we may invoke the
	 *    dynamic linker.  It grabs a lock, which calls back here.
	 *    This only happens on the first call to the external
	 *    function, so we can just return NULL if we are called
	 *    recursively (and miss the first count).
	 */
	if (addr == (void *)&udp->tdb_hash_lock)
		return (&udp->tdb_hash_lock_stats);
	if (self->ul_sync_obj_reg)		/* recursive call */
		return (NULL);
	self->ul_sync_obj_reg = 1;

	/*
	 * On the first time through, initialize the hash table and free list.
	 */
	if (tdbp->tdb_sync_addr_hash == NULL) {
		initialize_sync_hash();
		if (tdbp->tdb_sync_addr_hash == NULL) {	/* utter failure */
			udp->uberflags.uf_tdb_register_sync = REGISTER_SYNC_OFF;
			goto out;
		}
	}
	membar_consumer();

	sapp = &tdbp->tdb_sync_addr_hash[tdb_addr_hash(addr)];
	if (udp->uberflags.uf_tdb_register_sync == REGISTER_SYNC_ON) {
		/*
		 * Look up an address in the synchronization object hash table.
		 * No lock is required since it can only deliver a false
		 * negative, in which case we fall into the locked case below.
		 */
		for (sap = (tdb_sync_stats_t *)(uintptr_t)*sapp; sap != NULL;
		    sap = (tdb_sync_stats_t *)(uintptr_t)sap->next) {
			if (sap->sync_addr == (uintptr_t)addr)
				goto out;
		}
	}

	/*
	 * The search with no lock held failed or a special action is required.
	 * Grab tdb_hash_lock to do special actions and/or get a precise result.
	 */
	lmutex_lock(&udp->tdb_hash_lock);
	locked = 1;

	switch (udp->uberflags.uf_tdb_register_sync) {
	case REGISTER_SYNC_ON:
		break;
	case REGISTER_SYNC_OFF:
		goto out;
	default:
		/*
		 * For all debugger actions, first zero out the
		 * statistics block of every element in the hash table.
		 */
		for (i = 0; i < TDB_HASH_SIZE; i++)
			for (sap = (tdb_sync_stats_t *)
			    (uintptr_t)tdbp->tdb_sync_addr_hash[i];
			    sap != NULL;
			    sap = (tdb_sync_stats_t *)(uintptr_t)sap->next)
				(void) memset(&sap->un, 0, sizeof (sap->un));

		switch (udp->uberflags.uf_tdb_register_sync) {
		case REGISTER_SYNC_ENABLE:
			udp->uberflags.uf_tdb_register_sync = REGISTER_SYNC_ON;
			break;
		case REGISTER_SYNC_DISABLE:
		default:
			udp->uberflags.uf_tdb_register_sync = REGISTER_SYNC_OFF;
			goto out;
		}
		break;
	}

	/*
	 * Perform the search while holding tdb_hash_lock.
	 * Keep track of the insertion point.
	 */
	while ((sap = (tdb_sync_stats_t *)(uintptr_t)*sapp) != NULL) {
		if (sap->sync_addr == (uintptr_t)addr)
			break;
		sapp = &sap->next;
	}

	/*
	 * Insert a new element if necessary.
	 */
	if (sap == NULL && (sap = alloc_sync_addr(addr)) != NULL) {
		*sapp = (uintptr_t)sap;
		tdbp->tdb_register_count++;
		if (new)
			*new = 1;
	}

out:
	if (locked)
		lmutex_unlock(&udp->tdb_hash_lock);
	self->ul_sync_obj_reg = 0;
	return (sap);
}

void
tdb_sync_obj_deregister(void *addr)
{
	uberdata_t *udp = curthread->ul_uberdata;
	tdb_t *tdbp = &udp->tdb;
	uint64_t *sapp;
	tdb_sync_stats_t *sap;
	uint_t hash;

	/*
	 * tdb_hash_lock is never destroyed.
	 */
	ASSERT(addr != &udp->tdb_hash_lock);

	/*
	 * Avoid acquiring tdb_hash_lock if lock statistics gathering has
	 * never been initiated or there is nothing in the hash bucket.
	 * (Once the hash table is allocated, it is never deallocated.)
	 */
	if (tdbp->tdb_sync_addr_hash == NULL ||
	    tdbp->tdb_sync_addr_hash[hash = tdb_addr_hash(addr)] == 0)
		return;

	lmutex_lock(&udp->tdb_hash_lock);
	sapp = &tdbp->tdb_sync_addr_hash[hash];
	while ((sap = (tdb_sync_stats_t *)(uintptr_t)*sapp) != NULL) {
		if (sap->sync_addr == (uintptr_t)addr) {
			/* remove it from the hash table */
			*sapp = sap->next;
			tdbp->tdb_register_count--;
			/* clear it */
			sap->next = (uintptr_t)0;
			sap->sync_addr = (uintptr_t)0;
			/* insert it on the tail of the free list */
			if (tdbp->tdb_sync_addr_free == NULL) {
				tdbp->tdb_sync_addr_free = sap;
				tdbp->tdb_sync_addr_last = sap;
			} else {
				tdbp->tdb_sync_addr_last->next = (uintptr_t)sap;
				tdbp->tdb_sync_addr_last = sap;
			}
			break;
		}
		sapp = &sap->next;
	}
	lmutex_unlock(&udp->tdb_hash_lock);
}

/*
 * Return a mutex statistics block for the given mutex.
 */
tdb_mutex_stats_t *
tdb_mutex_stats(mutex_t *mp)
{
	tdb_sync_stats_t *tssp;

	/* avoid stealing the cache line unnecessarily */
	if (mp->mutex_magic != MUTEX_MAGIC)
		mp->mutex_magic = MUTEX_MAGIC;
	if ((tssp = tdb_sync_obj_register(mp, NULL)) == NULL)
		return (NULL);
	tssp->un.type = TDB_MUTEX;
	return (&tssp->un.mutex);
}

/*
 * Return a condvar statistics block for the given condvar.
 */
tdb_cond_stats_t *
tdb_cond_stats(cond_t *cvp)
{
	tdb_sync_stats_t *tssp;

	/* avoid stealing the cache line unnecessarily */
	if (cvp->cond_magic != COND_MAGIC)
		cvp->cond_magic = COND_MAGIC;
	if ((tssp = tdb_sync_obj_register(cvp, NULL)) == NULL)
		return (NULL);
	tssp->un.type = TDB_COND;
	return (&tssp->un.cond);
}

/*
 * Return an rwlock statistics block for the given rwlock.
 */
tdb_rwlock_stats_t *
tdb_rwlock_stats(rwlock_t *rwlp)
{
	tdb_sync_stats_t *tssp;

	/* avoid stealing the cache line unnecessarily */
	if (rwlp->magic != RWL_MAGIC)
		rwlp->magic = RWL_MAGIC;
	if ((tssp = tdb_sync_obj_register(rwlp, NULL)) == NULL)
		return (NULL);
	tssp->un.type = TDB_RWLOCK;
	return (&tssp->un.rwlock);
}

/*
 * Return a semaphore statistics block for the given semaphore.
 */
tdb_sema_stats_t *
tdb_sema_stats(sema_t *sp)
{
	tdb_sync_stats_t *tssp;
	int new;

	/* avoid stealing the cache line unnecessarily */
	if (sp->magic != SEMA_MAGIC)
		sp->magic = SEMA_MAGIC;
	if ((tssp = tdb_sync_obj_register(sp, &new)) == NULL)
		return (NULL);
	tssp->un.type = TDB_SEMA;
	if (new) {
		tssp->un.sema.sema_max_count = sp->count;
		tssp->un.sema.sema_min_count = sp->count;
	}
	return (&tssp->un.sema);
}