xref: /src/sys/kern/subr_specificdata.c

/*	$NetBSD: subr_specificdata.c,v 1.14 2017/06/01 02:45:13 chs Exp $	*/

/*-
 * Copyright (c) 2006, 2007 The NetBSD Foundation, Inc.
 * All rights reserved.
 *
 * This code is derived from software contributed to The NetBSD Foundation
 * by Jason R. Thorpe.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

/*-
 * Copyright (c) 2006 YAMAMOTO Takashi.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: subr_specificdata.c,v 1.14 2017/06/01 02:45:13 chs Exp $");

#include <sys/param.h>
#include <sys/kmem.h>
#include <sys/specificdata.h>
#include <sys/queue.h>
#include <sys/mutex.h>

/*
 * Locking notes:
 *
 * The specdataref_container pointer in the specificdata_reference
 * is volatile.  To read it, you must hold EITHER the domain lock
 * or the ref lock.  To write it, you must hold BOTH the domain lock
 * and the ref lock.  The locks must be acquired in the following
 * order:
 *	domain -> ref
 */

typedef struct {
	specificdata_dtor_t	ski_dtor;
} specificdata_key_impl;

struct specificdata_container {
	size_t		sc_nkey;
	LIST_ENTRY(specificdata_container) sc_list;
	void *		sc_data[];	/* variable length */
};

#define	SPECIFICDATA_CONTAINER_BYTESIZE(n)		\
	(sizeof(struct specificdata_container) + ((n) * sizeof(void *)))

struct specificdata_domain {
	kmutex_t	sd_lock;
	unsigned int	sd_nkey;
	LIST_HEAD(, specificdata_container) sd_list;
	specificdata_key_impl *sd_keys;
};

static void
specificdata_container_link(specificdata_domain_t sd,
			    specificdata_container_t sc)
{

	LIST_INSERT_HEAD(&sd->sd_list, sc, sc_list);
}

static void
specificdata_container_unlink(specificdata_domain_t sd,
			      specificdata_container_t sc)
{

	LIST_REMOVE(sc, sc_list);
}

static void
specificdata_destroy_datum(specificdata_domain_t sd,
			   specificdata_container_t sc, specificdata_key_t key)
{
	specificdata_dtor_t dtor;
	void *data;

	if (key >= sc->sc_nkey)
		return;

	KASSERT(key < sd->sd_nkey);

	data = sc->sc_data[key];
	dtor = sd->sd_keys[key].ski_dtor;

	if (dtor != NULL) {
		if (data != NULL) {
			sc->sc_data[key] = NULL;
			(*dtor)(data);
		}
	} else {
		KASSERT(data == NULL);
	}
}

static void
specificdata_noop_dtor(void *data)
{

	/* nothing */
}

/*
 * specificdata_domain_create --
 *	Create a specificdata domain.
 */
specificdata_domain_t
specificdata_domain_create(void)
{
	specificdata_domain_t sd;

	sd = kmem_zalloc(sizeof(*sd), KM_SLEEP);
	mutex_init(&sd->sd_lock, MUTEX_DEFAULT, IPL_NONE);
	LIST_INIT(&sd->sd_list);

	return (sd);
}

/*
 * specificdata_domain_delete --
 *	Destroy a specificdata domain.
 */
void
specificdata_domain_delete(specificdata_domain_t sd)
{

	panic("specificdata_domain_delete: not implemented");
}

/*
 * specificdata_key_create --
 *	Create a specificdata key for a domain.
 *
 *	Note: This is a rare operation.
 */
int
specificdata_key_create(specificdata_domain_t sd, specificdata_key_t *keyp,
			specificdata_dtor_t dtor)
{
	specificdata_key_impl *newkeys;
	specificdata_key_t key = 0;
	size_t nsz;

	ASSERT_SLEEPABLE();

	if (dtor == NULL)
		dtor = specificdata_noop_dtor;

	mutex_enter(&sd->sd_lock);

	if (sd->sd_keys == NULL)
		goto needalloc;

	for (; key < sd->sd_nkey; key++) {
		if (sd->sd_keys[key].ski_dtor == NULL)
			goto gotit;
	}

 needalloc:
	nsz = (sd->sd_nkey + 1) * sizeof(*newkeys);
	/* XXXSMP allocating memory while holding a lock. */
	newkeys = kmem_zalloc(nsz, KM_SLEEP);
	if (sd->sd_keys != NULL) {
		size_t osz = sd->sd_nkey * sizeof(*newkeys);
		memcpy(newkeys, sd->sd_keys, osz);
		kmem_free(sd->sd_keys, osz);
	}
	sd->sd_keys = newkeys;
	sd->sd_nkey++;
 gotit:
	sd->sd_keys[key].ski_dtor = dtor;

	mutex_exit(&sd->sd_lock);

	*keyp = key;
	return (0);
}

/*
 * specificdata_key_delete --
 *	Destroy a specificdata key for a domain.
 *
 *	Note: This is a rare operation.
 */
void
specificdata_key_delete(specificdata_domain_t sd, specificdata_key_t key)
{
	specificdata_container_t sc;

	mutex_enter(&sd->sd_lock);

	if (key >= sd->sd_nkey)
		goto out;

	/*
	 * Traverse all of the specificdata containers in the domain
	 * and the destroy the datum for the dying key.
	 */
	LIST_FOREACH(sc, &sd->sd_list, sc_list) {
		specificdata_destroy_datum(sd, sc, key);
	}

	sd->sd_keys[key].ski_dtor = NULL;

 out:
	mutex_exit(&sd->sd_lock);
}

/*
 * specificdata_init --
 *	Initialize a specificdata container for operation in the
 *	specified domain.
 */
int
specificdata_init(specificdata_domain_t sd, specificdata_reference *ref)
{

	/*
	 * Just NULL-out the container pointer; we'll allocate the
	 * container the first time specificdata is put into it.
	 */
	ref->specdataref_container = NULL;
	mutex_init(&ref->specdataref_lock, MUTEX_DEFAULT, IPL_NONE);

	return (0);
}

/*
 * specificdata_fini --
 *	Destroy a specificdata container.  We destroy all of the datums
 *	stuffed into the container just as if the key were destroyed.
 */
void
specificdata_fini(specificdata_domain_t sd, specificdata_reference *ref)
{
	specificdata_container_t sc;
	specificdata_key_t key;

	ASSERT_SLEEPABLE();

	mutex_destroy(&ref->specdataref_lock);

	sc = ref->specdataref_container;
	if (sc == NULL)
		return;
	ref->specdataref_container = NULL;

	mutex_enter(&sd->sd_lock);

	specificdata_container_unlink(sd, sc);
	for (key = 0; key < sc->sc_nkey; key++) {
		specificdata_destroy_datum(sd, sc, key);
	}

	mutex_exit(&sd->sd_lock);

	kmem_free(sc, SPECIFICDATA_CONTAINER_BYTESIZE(sc->sc_nkey));
}

/*
 * specificdata_getspecific --
 *	Get a datum from a container.
 */
void *
specificdata_getspecific(specificdata_domain_t sd, specificdata_reference *ref,
			 specificdata_key_t key)
{
	specificdata_container_t sc;
	void *data = NULL;

	mutex_enter(&ref->specdataref_lock);

	sc = ref->specdataref_container;
	if (sc != NULL && key < sc->sc_nkey)
		data = sc->sc_data[key];

	mutex_exit(&ref->specdataref_lock);

	return (data);
}

/*
 * specificdata_getspecific_unlocked --
 *	Get a datum from a container in a lockless fashion.
 *
 *	Note: When using this routine, care must be taken to ensure
 *	that no other thread could cause the specificdata_reference
 *	to become invalid (i.e. point at the wrong container) by
 *	issuing a setspecific call or destroying the container.
 */
void *
specificdata_getspecific_unlocked(specificdata_domain_t sd,
				  specificdata_reference *ref,
				  specificdata_key_t key)
{
	specificdata_container_t sc;

	sc = ref->specdataref_container;
	if (sc != NULL && key < sc->sc_nkey)
		return (sc->sc_data[key]);

	return (NULL);
}

/*
 * specificdata_setspecific --
 *      Put a datum into a container.
 */
void
specificdata_setspecific(specificdata_domain_t sd,
			 specificdata_reference *ref,
			 specificdata_key_t key, void *data)
{
	specificdata_container_t sc, newsc;
	size_t newnkey, sz;

	ASSERT_SLEEPABLE();

	mutex_enter(&ref->specdataref_lock);

	sc = ref->specdataref_container;
	if (__predict_true(sc != NULL && key < sc->sc_nkey)) {
		sc->sc_data[key] = data;
		mutex_exit(&ref->specdataref_lock);
		return;
	}

	mutex_exit(&ref->specdataref_lock);

	/*
	 * Slow path: need to resize.
	 */

	mutex_enter(&sd->sd_lock);
	newnkey = sd->sd_nkey;
	if (key >= newnkey) {
		mutex_exit(&sd->sd_lock);
		panic("specificdata_setspecific");
	}
	sz = SPECIFICDATA_CONTAINER_BYTESIZE(newnkey);
	newsc = kmem_zalloc(sz, KM_SLEEP);
	newsc->sc_nkey = newnkey;

	mutex_enter(&ref->specdataref_lock);

	sc = ref->specdataref_container;
	if (sc != NULL) {
		if (key < sc->sc_nkey) {
			/*
			 * Someone beat us to the punch.  Unwind and put
			 * the object into the now large enough container.
			 */
			sc->sc_data[key] = data;
			mutex_exit(&ref->specdataref_lock);
			mutex_exit(&sd->sd_lock);
			kmem_free(newsc, sz);
			return;
		}
		specificdata_container_unlink(sd, sc);
		memcpy(newsc->sc_data, sc->sc_data,
		       sc->sc_nkey * sizeof(void *));
	}
	newsc->sc_data[key] = data;
	specificdata_container_link(sd, newsc);
	ref->specdataref_container = newsc;

	mutex_exit(&ref->specdataref_lock);
	mutex_exit(&sd->sd_lock);

	if (sc != NULL)
		kmem_free(sc, SPECIFICDATA_CONTAINER_BYTESIZE(sc->sc_nkey));
}