/*
 * 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 (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
 */

#include <sys/sysmacros.h>
#include <sys/atomic.h>
#include <sys/strsubr.h>
#include <sys/socket.h>
#include <sys/socketvar.h>
#include <sys/cmn_err.h>
#include <sys/modctl.h>
#include <sys/sdt.h>

list_t smod_list;
kmutex_t smod_list_lock;

so_create_func_t sock_comm_create_function;
so_destroy_func_t sock_comm_destroy_function;

static smod_info_t *smod_create(const char *);
static void smod_destroy(smod_info_t *);

extern void smod_add(smod_info_t *);

void
smod_init(void)
{
        list_create(&smod_list, sizeof (smod_info_t),
            offsetof(smod_info_t, smod_node));
        mutex_init(&smod_list_lock, NULL, MUTEX_DEFAULT, NULL);
}

static smod_info_t *
smod_find(const char *modname)
{
        smod_info_t *smodp;

        ASSERT(MUTEX_HELD(&smod_list_lock));

        for (smodp = list_head(&smod_list); smodp != NULL;
            smodp = list_next(&smod_list, smodp))
                if (strcmp(smodp->smod_name, modname) == 0)
                        return (smodp);
        return (NULL);
}

/*
 * Register the socket module.
 */
int
smod_register(const smod_reg_t *reg)
{
        smod_info_t     *smodp;

        /*
         * Make sure the socket module does not depend on capabilities
         * not available on the system.
         */
        if (reg->smod_version != SOCKMOD_VERSION ||
            reg->smod_dc_version != SOCK_DC_VERSION ||
            reg->smod_uc_version != SOCK_UC_VERSION) {
                cmn_err(CE_WARN,
                    "Failed to register socket module %s: version mismatch",
                    reg->smod_name);
                return (EINVAL);
        }

#ifdef DEBUG
        mutex_enter(&smod_list_lock);
        if ((smodp = smod_find(reg->smod_name)) != NULL) {
                mutex_exit(&smod_list_lock);
                return (EEXIST);
        }
        mutex_exit(&smod_list_lock);
#endif

        smodp = smod_create(reg->smod_name);
        smodp->smod_version = reg->smod_version;
        if (strcmp(smodp->smod_name, SOTPI_SMOD_NAME) == 0 ||
            strcmp(smodp->smod_name, "socksctp") == 0 ||
            strcmp(smodp->smod_name, "socksdp") == 0) {
                ASSERT(smodp->smod_proto_create_func == NULL);
                ASSERT(reg->__smod_priv != NULL);
                smodp->smod_sock_create_func =
                    reg->__smod_priv->smodp_sock_create_func;
                smodp->smod_sock_destroy_func =
                    reg->__smod_priv->smodp_sock_destroy_func;
                smodp->smod_proto_create_func = NULL;
        } else {
                if (reg->smod_proto_create_func == NULL ||
                    (reg->__smod_priv != NULL &&
                    (reg->__smod_priv->smodp_sock_create_func != NULL ||
                    reg->__smod_priv->smodp_sock_destroy_func != NULL))) {
#ifdef DEBUG
                        cmn_err(CE_CONT, "smod_register of %s failed",
                            smodp->smod_name);
#endif
                        smod_destroy(smodp);
                        return (EINVAL);
                }
                smodp->smod_proto_create_func = reg->smod_proto_create_func;
                smodp->smod_sock_create_func = sock_comm_create_function;
                smodp->smod_sock_destroy_func = sock_comm_destroy_function;
                smodp->smod_uc_version = reg->smod_uc_version;
                smodp->smod_dc_version = reg->smod_dc_version;
                if (reg->__smod_priv != NULL) {
                        smodp->smod_proto_fallback_func =
                            reg->__smod_priv->smodp_proto_fallback_func;
                        smodp->smod_fallback_devpath_v4 =
                            reg->__smod_priv->smodp_fallback_devpath_v4;
                        smodp->smod_fallback_devpath_v6 =
                            reg->__smod_priv->smodp_fallback_devpath_v6;
                }
        }
        smod_add(smodp);
        return (0);
}

/*
 * Unregister the socket module
 */
int
smod_unregister(const char *mod_name)
{
        smod_info_t     *smodp;

        mutex_enter(&smod_list_lock);
        if ((smodp = smod_find(mod_name)) != NULL) {
                if (smodp->smod_refcnt != 0) {
                        mutex_exit(&smod_list_lock);
                        return (EBUSY);
                } else {
                        /*
                         * Delete the entry from the socket module list.
                         */
                        list_remove(&smod_list, smodp);
                        mutex_exit(&smod_list_lock);

                        smod_destroy(smodp);
                        return (0);
                }
        }
        mutex_exit(&smod_list_lock);

        return (ENXIO);
}

/*
 * Initialize the socket module entry.
 */
static smod_info_t *
smod_create(const char *modname)
{
        smod_info_t *smodp;
        int len;

        smodp = kmem_zalloc(sizeof (*smodp), KM_SLEEP);
        len = strlen(modname) + 1;
        smodp->smod_name = kmem_alloc(len, KM_SLEEP);
        bcopy(modname, smodp->smod_name, len);
        smodp->smod_name[len - 1] = '\0';
        return (smodp);
}

/*
 * Clean up the socket module part of the sockparams entry.
 */
static void
smod_destroy(smod_info_t *smodp)
{
        ASSERT(smodp->smod_name != NULL);
        ASSERT(smodp->smod_refcnt == 0);
        ASSERT(!list_link_active(&smodp->smod_node));
        ASSERT(strcmp(smodp->smod_name, "socktpi") != 0);

        kmem_free(smodp->smod_name, strlen(smodp->smod_name) + 1);
        smodp->smod_name = NULL;
        smodp->smod_proto_create_func = NULL;
        smodp->smod_sock_create_func = NULL;
        smodp->smod_sock_destroy_func = NULL;
        kmem_free(smodp, sizeof (*smodp));
}

/*
 * Add an entry at the front of the socket module list.
 */
void
smod_add(smod_info_t *smodp)
{
        ASSERT(smodp != NULL);
        mutex_enter(&smod_list_lock);
        list_insert_head(&smod_list, smodp);
        mutex_exit(&smod_list_lock);
}

/*
 * Lookup the socket module table by the socket module name.
 * If there is an existing entry, then increase the reference count.
 * Otherwise we load the module and in the module register function create
 * a new entry and add it to the end of the socket module table.
 */
smod_info_t *
smod_lookup_byname(const char *modname)
{
        smod_info_t *smodp;
        int error;

again:
        /*
         * If find an entry, increase the reference count and
         * return the entry pointer.
         */
        mutex_enter(&smod_list_lock);
        if ((smodp = smod_find(modname)) != NULL) {
                SMOD_INC_REF(smodp);
                mutex_exit(&smod_list_lock);
                return (smodp);
        }
        mutex_exit(&smod_list_lock);

        /*
         * We have a sockmod, and it is not loaded.
         * Load the module into the kernel, modload() will
         * take care of the multiple threads.
         */
        DTRACE_PROBE1(load__socket__module, char *, modname);
        error = modload(SOCKMOD_PATH, modname);
        if (error == -1) {
                cmn_err(CE_CONT, "modload of %s/%s failed",
                    SOCKMOD_PATH, modname);
                return (NULL);
        }
        goto again;
}