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