common/os/damap.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 2009 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#include <sys/note.h>
#include <sys/types.h>
#include <sys/param.h>
#include <sys/systm.h>
#include <sys/buf.h>
#include <sys/kmem.h>
#include <sys/cmn_err.h>
#include <sys/debug.h>
#include <sys/sunndi.h>
#include <sys/kstat.h>
#include <sys/conf.h>
#include <sys/ddi_timer.h>
#include <sys/devctl.h>
#include <sys/callb.h>
#include <sys/sysevent.h>
#include <sys/taskq.h>
#include <sys/ddi.h>
#include <sys/bitset.h>
#include <sys/damap.h>
#include <sys/damap_impl.h>

#ifdef DEBUG
static int damap_debug = 0;
#endif /* DEBUG */

static void dam_addrset_activate(dam_t *, bitset_t *);
static void dam_addrset_release(dam_t *, bitset_t *);
static void dam_activate_taskq(void *);
static void dam_addr_stable_cb(void *);
static void dam_set_stable_cb(void *);
static void dam_sched_tmo(dam_t *, clock_t, void (*tmo_cb)());
static void dam_add_report(dam_t *, dam_da_t *, id_t, int);
static void dam_release(dam_t *, id_t);
static void dam_release_report(dam_t *, id_t);
static void dam_deactivate_addr(dam_t *, id_t);
static id_t dam_get_addrid(dam_t *, char *);
static int dam_kstat_create(dam_t *);
static void dam_kstat_destroy(dam_t *);

#define	DAM_INCR_STAT(mapp, stat)				\
	if ((mapp)->dam_kstatsp) {				\
		struct dam_kstats *stp = (mapp)->dam_kstatsp->ks_data;	\
		stp->stat.value.ui32++;				\
	}

#define	DAM_SET_STAT(mapp, stat, val)				\
	if ((mapp)->dam_kstatsp) {				\
		struct dam_kstats *stp = (mapp)->dam_kstatsp->ks_data;	\
		stp->stat.value.ui32 = (val);			\
	}

/*
 * Create new device address map
 *
 * ident:		map name (kstat)
 * size:		max # of map entries
 * rptmode:		type or mode of reporting
 * stable_usec:		# of quiescent microseconds before report/map is stable
 *
 * activate_arg:	address provider activation-callout private
 * activate_cb:		address provider activation callback handler
 * deactivate_cb:	address provider deactivation callback handler
 *
 * config_arg:		configuration-callout private
 * config_cb:		class configuration callout
 * unconfig_cb:		class unconfiguration callout
 *
 * damapp:		pointer to map handle (return)
 *
 * Returns:	DAM_SUCCESS
 *		DAM_EINVAL	Invalid argument(s)
 *		DAM_FAILURE	General failure
 */
int
damap_create(char *ident, size_t size, damap_rptmode_t rptmode,
    clock_t stable_usec,
    void *activate_arg, damap_activate_cb_t activate_cb,
    damap_deactivate_cb_t deactivate_cb,
    void *config_arg, damap_configure_cb_t configure_cb,
    damap_unconfig_cb_t unconfig_cb,
    damap_t **damapp)
{
	dam_t *mapp;
	void *softstate_p;

	DTRACE_PROBE1(damap__create__entry, char *, ident);
	if ((configure_cb == NULL) || (unconfig_cb == NULL))
		return (DAM_EINVAL);

	if (ddi_soft_state_init(&softstate_p, sizeof (dam_da_t), size) !=
	    DDI_SUCCESS)
		return (DAM_FAILURE);

	mapp = kmem_zalloc(sizeof (*mapp), KM_SLEEP);
	if (ddi_strid_init(&mapp->dam_addr_hash, size) != DDI_SUCCESS) {
		ddi_soft_state_fini(&softstate_p);
		kmem_free(mapp, sizeof (*mapp));
		return (DAM_FAILURE);
	}

	mapp->dam_da = softstate_p;
	mapp->dam_stabletmo = drv_usectohz(stable_usec);
	mapp->dam_size = size;
	mapp->dam_high = 1;
	mapp->dam_rptmode = rptmode;

	mapp->dam_activate_arg = activate_arg;
	mapp->dam_activate_cb = (activate_cb_t)activate_cb;
	mapp->dam_deactivate_cb = (deactivate_cb_t)deactivate_cb;

	mapp->dam_config_arg = config_arg;
	mapp->dam_configure_cb = (configure_cb_t)configure_cb;
	mapp->dam_unconfig_cb = (unconfig_cb_t)unconfig_cb;

	if (ident)
		mapp->dam_name = i_ddi_strdup(ident, KM_SLEEP);

	bitset_init(&mapp->dam_active_set);
	bitset_resize(&mapp->dam_active_set, size);
	bitset_init(&mapp->dam_stable_set);
	bitset_resize(&mapp->dam_stable_set, size);
	bitset_init(&mapp->dam_report_set);
	bitset_resize(&mapp->dam_report_set, size);
	mutex_init(&mapp->dam_lock, NULL, MUTEX_DRIVER, NULL);
	cv_init(&mapp->dam_cv, NULL, CV_DRIVER, NULL);
	mapp->dam_taskqp = ddi_taskq_create(NULL, ident, 1, TASKQ_DEFAULTPRI,
	    0);
	*damapp = (damap_t *)mapp;
	if (dam_kstat_create(mapp) != DDI_SUCCESS) {
		damap_destroy((damap_t *)mapp);
		return (DAM_FAILURE);
	}

	DTRACE_PROBE1(damap__create__exit, dam_t *, mapp);
	return (DAM_SUCCESS);
}

/*
 * Destroy device address map
 *
 * damapp:	address map
 *
 * Returns:	DAM_SUCCESS
 *		DAM_EINVAL	Invalid argument(s)
 *		DAM_FAILURE	General failure
 */
void
damap_destroy(damap_t *damapp)
{
	int i;
	dam_t *mapp = (dam_t *)damapp;

	ASSERT(mapp);

	DTRACE_PROBE2(damap__destroy__entry, dam_t *, mapp, char *,
	    mapp->dam_name);

	DAM_FLAG_SET(mapp, DAM_DESTROYPEND);
	(void) damap_sync(damapp);

	/*
	 * cancel pending timeouts and kill off the taskq
	 */
	dam_sched_tmo(mapp, 0, NULL);
	ddi_taskq_wait(mapp->dam_taskqp);
	ddi_taskq_destroy(mapp->dam_taskqp);

	for (i = 1; i < mapp->dam_high; i++) {
		if (ddi_get_soft_state(mapp->dam_da, i) == NULL)
			continue;
		if (DAM_IN_REPORT(mapp, i))
			dam_release_report(mapp, i);
		if (DAM_IS_STABLE(mapp, i))
			dam_deactivate_addr(mapp, i);
		ddi_strid_free(mapp->dam_addr_hash, i);
		ddi_soft_state_free(mapp->dam_da, i);
	}
	ddi_strid_fini(&mapp->dam_addr_hash);
	ddi_soft_state_fini(&mapp->dam_da);
	bitset_fini(&mapp->dam_active_set);
	bitset_fini(&mapp->dam_stable_set);
	bitset_fini(&mapp->dam_report_set);
	dam_kstat_destroy(mapp);
	mutex_destroy(&mapp->dam_lock);
	cv_destroy(&mapp->dam_cv);
	if (mapp->dam_name)
		kmem_free(mapp->dam_name, strlen(mapp->dam_name) + 1);
	kmem_free(mapp, sizeof (*mapp));
	DTRACE_PROBE(damap__destroy__exit);
}

/*
 * Wait for map stability.
 *
 * damapp:	address map
 */
int
damap_sync(damap_t *damapp)
{

#define	WAITFOR_FLAGS (DAM_SETADD | DAM_SPEND | MAP_LOCK)

	dam_t *mapp = (dam_t *)damapp;
	int   none_active;

	ASSERT(mapp);

	DTRACE_PROBE1(damap__sync__entry, dam_t *, mapp);

	mutex_enter(&mapp->dam_lock);
	while ((mapp->dam_flags & WAITFOR_FLAGS) ||
	    (!bitset_is_null(&mapp->dam_report_set)) || (mapp->dam_tid != 0)) {
		cv_wait(&mapp->dam_cv, &mapp->dam_lock);
	}

	none_active = bitset_is_null(&mapp->dam_active_set);

	mutex_exit(&mapp->dam_lock);
	DTRACE_PROBE2(damap__sync__exit, dam_t *, mapp, int, none_active);

	return (none_active);
}

/*
 * Get the name of a device address map
 *
 * damapp:	address map
 *
 * Returns:	name
 */
char *
damap_name(damap_t *damapp)
{
	dam_t *mapp = (dam_t *)damapp;

	return (mapp ? mapp->dam_name : "UNKNOWN_damap");
}

/*
 * Report an address to per-address report
 *
 * damapp:	address map handle
 * address:	address in ascii string representation
 * rindx:	index if address stabilizes
 * nvl:		optional nvlist of configuration-private data
 * addr_priv:	optional provider-private (passed to activate/deactivate cb)
 *
 * Returns:	DAM_SUCCESS
 *		DAM_EINVAL	Invalid argument(s)
 *		DAM_MAPFULL	address map exhausted
 */
int
damap_addr_add(damap_t *damapp, char *address, damap_id_t *ridx, nvlist_t *nvl,
    void *addr_priv)
{
	dam_t *mapp = (dam_t *)damapp;
	id_t addrid;
	dam_da_t *passp;

	DTRACE_PROBE2(damap__addr__add__entry, dam_t *, mapp,
	    char *, address);
	if (!mapp || !address || (mapp->dam_rptmode != DAMAP_REPORT_PERADDR) ||
	    (mapp->dam_flags & DAM_DESTROYPEND))
		return (DAM_EINVAL);

	DAM_LOCK(mapp, ADDR_LOCK);
	if ((addrid = dam_get_addrid(mapp, address)) == 0) {
		DAM_UNLOCK(mapp, ADDR_LOCK);
		return (DAM_MAPFULL);
	}

	passp = ddi_get_soft_state(mapp->dam_da, addrid);
	ASSERT(passp != NULL);

	/*
	 * If re-reporting the same address (add or remove) clear
	 * the existing report
	 */
	if (DAM_IN_REPORT(mapp, addrid)) {
		DAM_INCR_STAT(mapp, dam_rereport);
		dam_release_report(mapp, addrid);
		passp->da_jitter++;
	}
	passp->da_ppriv_rpt = addr_priv;
	if (nvl)
		(void) nvlist_dup(nvl, &passp->da_nvl_rpt, KM_SLEEP);

	dam_add_report(mapp, passp, addrid, RPT_ADDR_ADD);
	if (ridx != NULL)
		*ridx = (damap_id_t)addrid;
	DAM_UNLOCK(mapp, ADDR_LOCK);
	DTRACE_PROBE3(damap__addr__add__exit, dam_t *, mapp, char *,
	    address, int, addrid);
	return (DAM_SUCCESS);
}

/*
 * Report removal of address from per-address report
 *
 * damapp:	address map
 * address:	address in ascii string representation
 *
 * Returns:	DAM_SUCCESS
 *		DAM_EINVAL	Invalid argument(s)
 *		DAM_FAILURE	General failure
 */
int
damap_addr_del(damap_t *damapp, char *address)
{
	dam_t *mapp = (dam_t *)damapp;
	id_t addrid;
	dam_da_t *passp;

	DTRACE_PROBE2(damap__addr__del__entry, dam_t *, mapp,
	    char *, address);
	if (!mapp || !address || (mapp->dam_rptmode != DAMAP_REPORT_PERADDR) ||
	    (mapp->dam_flags & DAM_DESTROYPEND))
		return (DAM_EINVAL);

	DAM_LOCK(mapp, ADDR_LOCK);
	if (!(addrid = ddi_strid_str2id(mapp->dam_addr_hash, address))) {
		DAM_UNLOCK(mapp, ADDR_LOCK);
		return (DAM_SUCCESS);
	}
	passp = ddi_get_soft_state(mapp->dam_da, addrid);
	ASSERT(passp);
	if (DAM_IN_REPORT(mapp, addrid)) {
		DAM_INCR_STAT(mapp, dam_rereport);
		dam_release_report(mapp, addrid);
		passp->da_jitter++;
	}
	dam_add_report(mapp, passp, addrid, RPT_ADDR_DEL);
	DAM_UNLOCK(mapp, ADDR_LOCK);
	DTRACE_PROBE3(damap__addr__del__exit, dam_t *, mapp,
	    char *, address, int, addrid);
	return (DAM_SUCCESS);
}

/*
 * Initiate full-set report
 *
 * damapp:	address map
 *
 * Returns:	DAM_SUCCESS
 *		DAM_EINVAL	Invalid argument(s)
 */
int
damap_addrset_begin(damap_t *damapp)
{
	dam_t *mapp = (dam_t *)damapp;
	int i;

	DTRACE_PROBE1(damap__addrset__begin__entry, dam_t *, mapp);

	if ((mapp->dam_rptmode != DAMAP_REPORT_FULLSET) ||
	    (mapp->dam_flags & DAM_DESTROYPEND))
		return (DAM_EINVAL);

	DAM_LOCK(mapp, MAP_LOCK);
	/*
	 * reset any pending reports
	 */
	if (mapp->dam_flags & DAM_SETADD) {
		/*
		 * cancel stabilization timeout
		 */
		dam_sched_tmo(mapp, 0, NULL);
		DAM_INCR_STAT(mapp, dam_rereport);
		DAM_UNLOCK(mapp, MAP_LOCK);
		DAM_LOCK(mapp, ADDR_LOCK);
		for (i = 1; i < mapp->dam_high; i++) {
			if (DAM_IN_REPORT(mapp, i))
				dam_release_report(mapp, i);
		}
		DAM_UNLOCK(mapp, ADDR_LOCK);
		DAM_LOCK(mapp, MAP_LOCK);
	}
	DAM_FLAG_SET(mapp, DAM_SETADD);
	bitset_zero(&mapp->dam_report_set);
	DAM_UNLOCK(mapp, MAP_LOCK);
	DTRACE_PROBE(damap__addrset__begin__exit);
	return (DAM_SUCCESS);
}

/*
 * Report address to full-set report
 *
 * damapp:	address map handle
 * address:	address in ascii string representation
 * rindx:	index if address stabilizes
 * nvl:		optional nvlist of configuration-private data
 * addr_priv:	optional provider-private data (passed to activate/release cb)
 *
 * Returns:	DAM_SUCCESS
 *		DAM_EINVAL	Invalid argument(s)
 *		DAM_MAPFULL	address map exhausted
 *		DAM_FAILURE	General failure
 */
int
damap_addrset_add(damap_t *damapp, char *address, damap_id_t *ridx,
    nvlist_t *nvl, void *addr_priv)
{
	dam_t *mapp = (dam_t *)damapp;
	id_t addrid;
	dam_da_t *passp;

	DTRACE_PROBE2(damap__addrset__add__entry, dam_t *, mapp,
	    char *, address);

	if (!mapp || !address || (mapp->dam_rptmode != DAMAP_REPORT_FULLSET) ||
	    (mapp->dam_flags & DAM_DESTROYPEND))
		return (DAM_EINVAL);

	if (!(mapp->dam_flags & DAM_SETADD))
		return (DAM_FAILURE);

	DAM_LOCK(mapp, ADDR_LOCK);
	if ((addrid = dam_get_addrid(mapp, address)) == 0) {
		DAM_UNLOCK(mapp, ADDR_LOCK);
		return (DAM_MAPFULL);
	}

	passp = ddi_get_soft_state(mapp->dam_da, addrid);
	ASSERT(passp);
	if (DAM_IN_REPORT(mapp, addrid)) {
		dam_release_report(mapp, addrid);
		passp->da_jitter++;
	}
	passp->da_ppriv_rpt = addr_priv;
	if (nvl)
		(void) nvlist_dup(nvl, &passp->da_nvl_rpt, KM_SLEEP);
	DAM_LOCK(mapp, MAP_LOCK);
	bitset_add(&mapp->dam_report_set, addrid);
	DAM_UNLOCK(mapp, MAP_LOCK);
	if (ridx)
		*ridx = (damap_id_t)addrid;
	DAM_UNLOCK(mapp, ADDR_LOCK);
	DTRACE_PROBE3(damap__addr__addset__exit, dam_t *, mapp, char *,
	    address, int, addrid);
	return (DAM_SUCCESS);
}

/*
 * Commit full-set report for stabilization
 *
 * damapp:	address map handle
 * flags:	(currently 0)
 *
 * Returns:	DAM_SUCCESS
 *		DAM_EINVAL	Invalid argument(s)
 *		DAM_FAILURE	General failure
 */
int
damap_addrset_end(damap_t *damapp, int flags)
{
	dam_t *mapp = (dam_t *)damapp;
	int i;

	DTRACE_PROBE1(damap__addrset__end__entry, dam_t *, mapp);

	if (!mapp || (mapp->dam_rptmode != DAMAP_REPORT_FULLSET) ||
	    (mapp->dam_flags & DAM_DESTROYPEND))
		return (DAM_EINVAL);

	if (!(mapp->dam_flags & DAM_SETADD))
		return (DAM_FAILURE);

	if (flags & DAMAP_RESET) {
		DAM_LOCK(mapp, MAP_LOCK);
		dam_sched_tmo(mapp, 0, NULL);
		DAM_UNLOCK(mapp, MAP_LOCK);
		DAM_LOCK(mapp, ADDR_LOCK);
		for (i = 1; i < mapp->dam_high; i++)
			if (DAM_IN_REPORT(mapp, i))
				dam_release_report(mapp, i);
		DAM_UNLOCK(mapp, ADDR_LOCK);
	} else {
		mapp->dam_last_update = gethrtime();
		DAM_LOCK(mapp, MAP_LOCK);
		dam_sched_tmo(mapp, mapp->dam_stabletmo, dam_set_stable_cb);
		DAM_UNLOCK(mapp, MAP_LOCK);
	}
	DTRACE_PROBE(damap__addrset__end__exit);
	return (DAM_SUCCESS);
}

/*
 * Return nvlist registered with reported address
 *
 * damapp:	address map handle
 * aid:		address ID
 *
 * Returns:	nvlist_t *	provider supplied via damap_addr{set}_add())
 *		NULL
 */
nvlist_t *
damap_id2nvlist(damap_t *damapp, damap_id_t addrid)
{
	dam_t *mapp = (dam_t *)damapp;
	id_t aid = (id_t)addrid;
	dam_da_t *pass;

	if (ddi_strid_id2str(mapp->dam_addr_hash, aid)) {
		if (pass = ddi_get_soft_state(mapp->dam_da, aid))
			return (pass->da_nvl);
	}
	return (NULL);
}

/*
 * Return address string
 *
 * damapp:	address map handle
 * aid:		address ID
 *
 * Returns:	char *		Address string
 *		NULL
 */
char *
damap_id2addr(damap_t *damapp, damap_id_t aid)
{
	dam_t *mapp = (dam_t *)damapp;

	return (ddi_strid_id2str(mapp->dam_addr_hash, (id_t)aid));
}

/*
 * Hold address reference in map
 *
 * damapp:	address map handle
 * aid:		address ID
 *
 * Returns:	DAM_SUCCESS
 *		DAM_FAILURE
 */
int
damap_id_hold(damap_t *damapp, damap_id_t aid)
{
	dam_t *mapp = (dam_t *)damapp;
	dam_da_t *passp;


	DAM_LOCK(mapp, ADDR_LOCK);
	passp = ddi_get_soft_state(mapp->dam_da, (id_t)aid);
	if (!passp) {
		DAM_UNLOCK(mapp, ADDR_LOCK);
		return (DAM_FAILURE);
	}
	passp->da_ref++;
	DAM_UNLOCK(mapp, ADDR_LOCK);
	return (DAM_SUCCESS);
}

/*
 * Release address reference in map
 *
 * damapp:	address map handle
 * aid:		address ID
 */
void
damap_id_rele(damap_t *damapp, damap_id_t addrid)
{
	dam_t *mapp = (dam_t *)damapp;

	DAM_LOCK(mapp, ADDR_LOCK);
	dam_release(mapp, (id_t)addrid);
	DAM_UNLOCK(mapp, ADDR_LOCK);
}

/*
 * Return current reference count on address reference in map
 *
 * damapp:	address map handle
 * aid:		address ID
 *
 * Returns:	DAM_SUCCESS
 *		DAM_FAILURE
 */
int
damap_id_ref(damap_t *damapp, damap_id_t aid)
{
	dam_t *mapp = (dam_t *)damapp;
	dam_da_t *passp;
	int ref = -1;

	DAM_LOCK(mapp, ADDR_LOCK);
	passp = ddi_get_soft_state(mapp->dam_da, (id_t)aid);
	if (passp)
		ref = passp->da_ref;
	DAM_UNLOCK(mapp, ADDR_LOCK);
	return (ref);
}

/*
 * Return next address ID in list
 *
 * damapp:	address map handle
 * damap_list:	address ID list passed to config|unconfig
 *		returned by look by lookup_all
 * last:	last ID returned, 0 is start of list
 *
 * Returns:	addrid		Next ID from the list
 *		0		End of the list
 */
damap_id_t
damap_id_next(damap_t *damapp, damap_id_list_t damap_list, damap_id_t last)
{
	int i, start;
	dam_t *mapp = (dam_t *)damapp;
	bitset_t *dam_list = (bitset_t *)damap_list;

	if (!mapp || !dam_list)
		return ((damap_id_t)0);

	start = (int)last + 1;
	for (i = start; i < mapp->dam_high; i++)
		if (bitset_in_set(dam_list, i))
			return ((damap_id_t)i);
	return ((damap_id_t)0);
}

/*
 * Set config private data
 *
 * damapp:	address map handle
 * aid:		address ID
 * cfg_priv:	configuration private data
 *
 */
void
damap_id_priv_set(damap_t *damapp, damap_id_t aid, void *cfg_priv)
{
	dam_t *mapp = (dam_t *)damapp;
	dam_da_t *passp;


	DAM_LOCK(mapp, ADDR_LOCK);
	passp = ddi_get_soft_state(mapp->dam_da, (id_t)aid);
	if (!passp) {
		DAM_UNLOCK(mapp, ADDR_LOCK);
		return;
	}
	passp->da_cfg_priv = cfg_priv;
	DAM_UNLOCK(mapp, ADDR_LOCK);
}

/*
 * Get config private data
 *
 * damapp:	address map handle
 * aid:		address ID
 *
 * Returns:	configuration private data
 */
void *
damap_id_priv_get(damap_t *damapp, damap_id_t aid)
{
	dam_t *mapp = (dam_t *)damapp;
	dam_da_t *passp;
	void *rv;


	DAM_LOCK(mapp, ADDR_LOCK);
	passp = ddi_get_soft_state(mapp->dam_da, (id_t)aid);
	if (!passp) {
		DAM_UNLOCK(mapp, ADDR_LOCK);
		return (NULL);
	}
	rv = passp->da_cfg_priv;
	DAM_UNLOCK(mapp, ADDR_LOCK);
	return (rv);
}

/*
 * Lookup a single address in the active address map
 *
 * damapp:	address map handle
 * address:	address string
 *
 * Returns:	ID of active/stable address
 *		0	Address not in stable set
 *
 * Future: Allow the caller to wait for stabilize before returning not found.
 */
damap_id_t
damap_lookup(damap_t *damapp, char *address)
{
	dam_t *mapp = (dam_t *)damapp;
	id_t addrid = 0;
	dam_da_t *passp = NULL;

	DAM_LOCK(mapp, ADDR_LOCK);
	addrid = ddi_strid_str2id(mapp->dam_addr_hash, address);
	if (addrid) {
		DAM_LOCK(mapp, MAP_LOCK);
		if (DAM_IS_STABLE(mapp, addrid)) {
			passp = ddi_get_soft_state(mapp->dam_da, addrid);
			ASSERT(passp);
			if (passp) {
				passp->da_ref++;
			} else {
				addrid = 0;
			}
		} else {
			addrid = 0;
		}
		DAM_UNLOCK(mapp, MAP_LOCK);
	}
	DAM_UNLOCK(mapp, ADDR_LOCK);
	return ((damap_id_t)addrid);
}


/*
 * Return the list of stable addresses in the map
 *
 * damapp:	address map handle
 * id_listp:	pointer to list of address IDs in stable map (returned)
 *
 * Returns:	# of entries returned in alist
 */
int
damap_lookup_all(damap_t *damapp, damap_id_list_t *id_listp)
{
	dam_t *mapp = (dam_t *)damapp;
	int mapsz = mapp->dam_size;
	int n_ids, i;
	bitset_t *bsp;
	dam_da_t *passp;

	bsp = kmem_alloc(sizeof (*bsp), KM_SLEEP);
	bitset_init(bsp);
	bitset_resize(bsp, mapsz);
	DAM_LOCK(mapp, MAP_LOCK);
	bitset_copy(&mapp->dam_active_set, bsp);
	DAM_UNLOCK(mapp, MAP_LOCK);
	DAM_LOCK(mapp, ADDR_LOCK);
	for (n_ids = 0, i = 1; i < mapsz; i++) {
		if (bitset_in_set(bsp, i)) {
			passp = ddi_get_soft_state(mapp->dam_da, i);
			ASSERT(passp);
			if (passp) {
				passp->da_ref++;
				n_ids++;
			}
		}
	}
	DAM_UNLOCK(mapp, ADDR_LOCK);
	if (n_ids) {
		*id_listp = (damap_id_list_t)bsp;
		return (n_ids);
	} else {
		*id_listp = (damap_id_list_t)NULL;
		bitset_fini(bsp);
		kmem_free(bsp, sizeof (*bsp));
		return (0);
	}
}

/*
 * Release the address list returned by damap_lookup_all()
 *
 * mapp:	address map handle
 * id_list:	list of address IDs returned in damap_lookup_all()
 */
void
damap_id_list_rele(damap_t *damapp, damap_id_list_t id_list)
{
	dam_t *mapp = (dam_t *)damapp;
	int i;

	if (id_list == NULL)
		return;

	DAM_LOCK(mapp, ADDR_LOCK);
	for (i = 1; i < mapp->dam_high; i++) {
		if (bitset_in_set((bitset_t *)id_list, i))
			(void) dam_release(mapp, i);
	}
	DAM_UNLOCK(mapp, ADDR_LOCK);
	bitset_fini((bitset_t *)id_list);
	kmem_free((void *)id_list, sizeof (bitset_t));
}

/*
 * Activate a set of stabilized addresses
 */
static void
dam_addrset_activate(dam_t *mapp, bitset_t *active_set)
{
	dam_da_t *passp;
	char *addrstr;
	int i;
	uint32_t n_active = 0;

	for (i = 1; i < mapp->dam_high; i++) {
		if (bitset_in_set(&mapp->dam_active_set, i))
			n_active++;
		if (!bitset_in_set(active_set, i))
			continue;
		n_active++;
		passp = ddi_get_soft_state(mapp->dam_da, i);
		ASSERT(passp);
		if (mapp->dam_activate_cb) {
			addrstr = ddi_strid_id2str(mapp->dam_addr_hash, i);
			(*mapp->dam_activate_cb)(
			    mapp->dam_activate_arg, addrstr, i,
			    &passp->da_ppriv_rpt);
		}
		DTRACE_PROBE2(damap__addrset__activate, dam_t *, mapp, int, i);
		DAM_LOCK(mapp, MAP_LOCK);
		bitset_add(&mapp->dam_active_set, i);
		/*
		 * copy the reported nvlist and provider private data
		 */
		passp->da_nvl = passp->da_nvl_rpt;
		passp->da_ppriv = passp->da_ppriv_rpt;
		passp->da_ppriv_rpt = NULL;
		passp->da_nvl_rpt = NULL;
		passp->da_last_stable = gethrtime();
		passp->da_stable_cnt++;
		DAM_UNLOCK(mapp, MAP_LOCK);
		DAM_SET_STAT(mapp, dam_numstable, n_active);
	}
}

/*
 * Release a set of stabilized addresses
 */
static void
dam_addrset_release(dam_t *mapp, bitset_t *release_set)
{
	int i;

	DAM_LOCK(mapp, ADDR_LOCK);
	for (i = 1; i < mapp->dam_high; i++) {
		if (bitset_in_set(release_set, i)) {
			DTRACE_PROBE2(damap__addrset__release, dam_t *, mapp,
			    int, i);
			DAM_LOCK(mapp, MAP_LOCK);
			bitset_del(&mapp->dam_active_set, i);
			DAM_UNLOCK(mapp, MAP_LOCK);
			(void) dam_release(mapp, i);
		}
	}
	DAM_UNLOCK(mapp, ADDR_LOCK);
}

/*
 * release a previously activated address
 */
static void
dam_release(dam_t *mapp, id_t addrid)
{
	dam_da_t *passp;

	DAM_ASSERT_LOCKED(mapp, ADDR_LOCK);
	passp = ddi_get_soft_state(mapp->dam_da, addrid);
	ASSERT(passp);

	/*
	 * invoke the deactivation callback to notify
	 * this address is no longer active
	 */
	dam_deactivate_addr(mapp, addrid);

	/*
	 * allow pending reports for this address to stabilize
	 */
	if (DAM_IN_REPORT(mapp, addrid))
		return;

	/*
	 * defer teardown until outstanding references are released
	 */
	if (--passp->da_ref) {
		passp->da_flags |= DA_RELE;
		return;
	}
	ddi_strid_free(mapp->dam_addr_hash, addrid);
	ddi_soft_state_free(mapp->dam_da, addrid);
}

/*
 * process stabilized address reports
 */
static void
dam_activate_taskq(void *arg)
{
	dam_t *mapp = (dam_t *)arg;
	bitset_t delta;
	bitset_t cfg;
	bitset_t uncfg;
	int has_cfg, has_uncfg;

	bitset_init(&delta);
	bitset_resize(&delta, mapp->dam_size);
	bitset_init(&cfg);
	bitset_resize(&cfg, mapp->dam_size);
	bitset_init(&uncfg);
	bitset_resize(&uncfg, mapp->dam_size);

	DTRACE_PROBE1(damap__activate__taskq__entry, dam_t, mapp);
	DAM_LOCK(mapp, MAP_LOCK);
	if (!bitset_xor(&mapp->dam_active_set, &mapp->dam_stable_set,
	    &delta)) {
		bitset_zero(&mapp->dam_stable_set);
		DAM_FLAG_CLR(mapp, DAM_SPEND);
		DAM_UNLOCK(mapp, MAP_LOCK);
		bitset_fini(&uncfg);
		bitset_fini(&cfg);
		bitset_fini(&delta);
		return;
	}
	has_cfg = bitset_and(&delta, &mapp->dam_stable_set, &cfg);
	has_uncfg = bitset_and(&delta, &mapp->dam_active_set, &uncfg);
	DAM_UNLOCK(mapp, MAP_LOCK);
	if (has_cfg) {
		dam_addrset_activate(mapp, &cfg);
		(*mapp->dam_configure_cb)(mapp->dam_config_arg, mapp, &cfg);
	}
	if (has_uncfg) {
		(*mapp->dam_unconfig_cb)(mapp->dam_config_arg, mapp, &uncfg);
		dam_addrset_release(mapp, &uncfg);
	}
	DAM_LOCK(mapp, MAP_LOCK);
	bitset_zero(&mapp->dam_stable_set);
	DAM_FLAG_CLR(mapp, DAM_SPEND);
	mapp->dam_last_stable = gethrtime();
	mapp->dam_stable_cnt++;
	DAM_INCR_STAT(mapp, dam_stable);
	DAM_UNLOCK(mapp, MAP_LOCK);
	bitset_fini(&uncfg);
	bitset_fini(&cfg);
	bitset_fini(&delta);
	DTRACE_PROBE1(damap__activate__taskq__exit, dam_t, mapp);
}

/*
 * per-address stabilization timeout
 */
static void
dam_addr_stable_cb(void *arg)
{
	dam_t *mapp = (dam_t *)arg;
	int i;
	dam_da_t *passp;
	int spend = 0;
	int tpend = 0;
	int64_t	next_tmov = mapp->dam_stabletmo;
	int64_t tmo_delta;
	int64_t ts = lbolt64;

	DTRACE_PROBE1(damap__addr__stable__cb__entry, dam_t *, mapp);
	DAM_LOCK(mapp, MAP_LOCK);
	if (mapp->dam_tid == 0) {
		DAM_UNLOCK(mapp, MAP_LOCK);
		return;
	}
	mapp->dam_tid = 0;
	/*
	 * If still under stabilization, reschedule timeout,
	 * else dispatch the task to activate & deactivate the stable
	 * set.
	 */
	if (mapp->dam_flags & DAM_SPEND) {
		DAM_INCR_STAT(mapp, dam_stable_blocked);
		mapp->dam_stable_overrun++;
		dam_sched_tmo(mapp, mapp->dam_stabletmo, dam_addr_stable_cb);
		DAM_UNLOCK(mapp, MAP_LOCK);
		DTRACE_PROBE1(damap__addr__stable__cb__overrun,
		    dam_t *, mapp);
		return;
	}

	bitset_copy(&mapp->dam_active_set, &mapp->dam_stable_set);
	for (i = 1; i < mapp->dam_high; i++) {
		if (!bitset_in_set(&mapp->dam_report_set, i))
			continue;
		/*
		 * Stabilize each address
		 */
		passp = ddi_get_soft_state(mapp->dam_da, i);
		ASSERT(passp);
		if (!passp) {
			cmn_err(CE_WARN, "Clearing report no softstate %d", i);
			bitset_del(&mapp->dam_report_set, i);
			continue;
		}

		/* report has stabilized */
		if (passp->da_deadline <= ts) {
			bitset_del(&mapp->dam_report_set, i);
			if (passp->da_flags & DA_RELE) {
				DTRACE_PROBE2(damap__addr__stable__del,
				    dam_t *, mapp, int, i);
				bitset_del(&mapp->dam_stable_set, i);
			} else {
				DTRACE_PROBE2(damap__addr__stable__add,
				    dam_t *, mapp, int, i);
				bitset_add(&mapp->dam_stable_set, i);
			}
			spend++;
			continue;
		}

		/*
		 * not stabilized, determine next (future) map timeout
		 */
		tpend++;
		tmo_delta = passp->da_deadline - ts;
		if (tmo_delta < next_tmov)
			next_tmov = tmo_delta;
	}

	/*
	 * schedule taskq activation of stabilized reports
	 */
	if (spend) {
		if (ddi_taskq_dispatch(mapp->dam_taskqp, dam_activate_taskq,
		    mapp, DDI_NOSLEEP) == DDI_SUCCESS) {
			DAM_FLAG_SET(mapp, DAM_SPEND);
		} else
			tpend++;
	}

	/*
	 * schedule timeout to handle future stabalization of active reports
	 */
	if (tpend)
		dam_sched_tmo(mapp, (clock_t)next_tmov, dam_addr_stable_cb);
	DAM_UNLOCK(mapp, MAP_LOCK);
	DTRACE_PROBE1(damap__addr__stable__cb__exit, dam_t *, mapp);
}

/*
 * fullset stabilization timeout
 */
static void
dam_set_stable_cb(void *arg)
{
	dam_t *mapp = (dam_t *)arg;

	DTRACE_PROBE1(damap__set__stable__cb__enter, dam_t *, mapp);

	DAM_LOCK(mapp, MAP_LOCK);
	if (mapp->dam_tid == 0) {
		DAM_UNLOCK(mapp, MAP_LOCK);
		return;
	}
	mapp->dam_tid = 0;

	/*
	 * If still under stabilization, reschedule timeout,
	 * else dispatch the task to activate & deactivate the stable
	 * set.
	 */
	if (mapp->dam_flags & DAM_SPEND) {
		DAM_INCR_STAT(mapp, dam_stable_blocked);
		mapp->dam_stable_overrun++;
		dam_sched_tmo(mapp, mapp->dam_stabletmo, dam_set_stable_cb);
		DTRACE_PROBE1(damap__set__stable__cb__overrun,
		    dam_t *, mapp);
	} else if (ddi_taskq_dispatch(mapp->dam_taskqp, dam_activate_taskq,
	    mapp, DDI_NOSLEEP) == DDI_FAILURE) {
		dam_sched_tmo(mapp, mapp->dam_stabletmo, dam_set_stable_cb);
	} else {
		bitset_copy(&mapp->dam_report_set, &mapp->dam_stable_set);
		bitset_zero(&mapp->dam_report_set);
		DAM_FLAG_CLR(mapp, DAM_SETADD);
		DAM_FLAG_SET(mapp, DAM_SPEND);
	}
	DAM_UNLOCK(mapp, MAP_LOCK);
	DTRACE_PROBE1(damap__set__stable__cb__exit, dam_t *, mapp);
}

/*
 * reschedule map timeout 'tmo_ms' ticks
 */
static void
dam_sched_tmo(dam_t *mapp, clock_t tmo_ms, void (*tmo_cb)())
{
	timeout_id_t tid;

	if ((tid = mapp->dam_tid) != 0) {
		mapp->dam_tid = 0;
		DAM_UNLOCK(mapp, MAP_LOCK);
		(void) untimeout(tid);
		DAM_LOCK(mapp, MAP_LOCK);
	}

	if (tmo_cb && (tmo_ms != 0))
		mapp->dam_tid = timeout(tmo_cb, mapp, tmo_ms);
}

/*
 * record report addition or removal of an address
 */
static void
dam_add_report(dam_t *mapp, dam_da_t *passp, id_t addrid, int report)
{
	ASSERT(!DAM_IN_REPORT(mapp, addrid));
	passp->da_last_report = gethrtime();
	mapp->dam_last_update = gethrtime();
	passp->da_report_cnt++;
	passp->da_deadline = lbolt64 + mapp->dam_stabletmo;
	if (report == RPT_ADDR_DEL)
		passp->da_flags |= DA_RELE;
	else if (report == RPT_ADDR_ADD)
		passp->da_flags &= ~DA_RELE;
	DAM_LOCK(mapp, MAP_LOCK);
	bitset_add(&mapp->dam_report_set, addrid);
	dam_sched_tmo(mapp, mapp->dam_stabletmo, dam_addr_stable_cb);
	DAM_UNLOCK(mapp, MAP_LOCK);

}

/*
 * release an address report
 */
static void
dam_release_report(dam_t *mapp, id_t addrid)
{
	dam_da_t *passp;

	passp = ddi_get_soft_state(mapp->dam_da, addrid);
	ASSERT(passp);
	passp->da_ppriv_rpt = NULL;
	if (passp->da_nvl_rpt)
		nvlist_free(passp->da_nvl_rpt);
	passp->da_nvl_rpt = NULL;
	DAM_LOCK(mapp, MAP_LOCK);
	bitset_del(&mapp->dam_report_set, addrid);
	DAM_UNLOCK(mapp, MAP_LOCK);
}

/*
 * deactivate a previously stable address
 */
static void
dam_deactivate_addr(dam_t *mapp, id_t addrid)
{
	dam_da_t *passp;

	passp = ddi_get_soft_state(mapp->dam_da, addrid);
	ASSERT(passp);
	if (passp == NULL)
		return;
	DAM_UNLOCK(mapp, ADDR_LOCK);
	if (mapp->dam_deactivate_cb)
		(*mapp->dam_deactivate_cb)(
		    mapp->dam_activate_arg,
		    ddi_strid_id2str(mapp->dam_addr_hash,
		    addrid), addrid, passp->da_ppriv);
	DAM_LOCK(mapp, ADDR_LOCK);
	passp->da_ppriv = NULL;
	if (passp->da_nvl)
		nvlist_free(passp->da_nvl);
	passp->da_nvl = NULL;
}

/*
 * return the map ID of an address
 */
static id_t
dam_get_addrid(dam_t *mapp, char *address)
{
	damap_id_t addrid;
	dam_da_t *passp;

	if ((addrid = ddi_strid_str2id(mapp->dam_addr_hash, address)) == 0) {
		if ((addrid = ddi_strid_fixed_alloc(mapp->dam_addr_hash,
		    address)) == (damap_id_t)0) {
			return (0);
		}
		if (ddi_soft_state_zalloc(mapp->dam_da, addrid) !=
		    DDI_SUCCESS) {
			ddi_strid_free(mapp->dam_addr_hash, addrid);
			return (0);
		}
		if (addrid >= mapp->dam_high)
			mapp->dam_high = addrid + 1;
	}
	passp = ddi_get_soft_state(mapp->dam_da, addrid);
	if (passp == NULL)
		return (0);
	passp->da_ref++;
	if (passp->da_addr == NULL)
		passp->da_addr = ddi_strid_id2str(
		    mapp->dam_addr_hash, addrid); /* for mdb */
	return (addrid);
}

/*
 * create and install map statistics
 */
static int
dam_kstat_create(dam_t *mapp)
{
	kstat_t			*mapsp;
	struct dam_kstats	*statsp;

	mapsp = kstat_create("dam", 0, mapp->dam_name, "damap",
	    KSTAT_TYPE_NAMED,
	    sizeof (struct dam_kstats) / sizeof (kstat_named_t), 0);
	if (mapsp == NULL) {
		return (DDI_FAILURE);
	}

	statsp = (struct dam_kstats *)mapsp->ks_data;
	kstat_named_init(&statsp->dam_stable, "stable cycles",
	    KSTAT_DATA_UINT32);
	kstat_named_init(&statsp->dam_stable_blocked,
	    "stable cycle overrun", KSTAT_DATA_UINT32);
	kstat_named_init(&statsp->dam_rereport,
	    "restarted reports", KSTAT_DATA_UINT32);
	kstat_named_init(&statsp->dam_numstable,
	    "# of stable map entries", KSTAT_DATA_UINT32);
	kstat_install(mapsp);
	mapp->dam_kstatsp = mapsp;
	return (DDI_SUCCESS);
}

/*
 * destroy map stats
 */
static void
dam_kstat_destroy(dam_t *mapp)
{

	kstat_delete(mapp->dam_kstatsp);
}