/*
* 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) 2006, 2012, Oracle and/or its affiliates. All rights reserved.
*/
#include <signal.h>
#include <dirent.h>
#include <limits.h>
#include <alloca.h>
#include <unistd.h>
#include <stdio.h>
#include <pthread.h>
#include <synch.h>
#include <errno.h>
#include <strings.h>
#include <assert.h>
#include <sys/nvpair.h>
#include <topo_string.h>
#include <topo_alloc.h>
#include <topo_module.h>
#include <topo_error.h>
#include <topo_subr.h>
void
topo_mod_release(topo_mod_t *mod, tnode_t *node)
{
topo_mod_enter(mod);
if (mod->tm_info->tmi_ops->tmo_release != NULL)
mod->tm_info->tmi_ops->tmo_release(mod, node);
topo_mod_exit(mod);
}
void
topo_mod_hold(topo_mod_t *mod)
{
(void) pthread_mutex_lock(&mod->tm_lock);
mod->tm_refs++;
assert(mod->tm_refs != 0);
(void) pthread_mutex_unlock(&mod->tm_lock);
}
void
topo_mod_rele(topo_mod_t *mod)
{
assert(mod->tm_refs != 0);
(void) pthread_mutex_lock(&mod->tm_lock);
/*
* Lazy unload module
*/
if (--mod->tm_refs == 0)
topo_modhash_unload(mod);
else
(void) pthread_mutex_unlock(&mod->tm_lock);
}
void
topo_mod_enter(topo_mod_t *mod)
{
(void) pthread_mutex_lock(&mod->tm_lock);
while (mod->tm_busy != 0)
(void) pthread_cond_wait(&mod->tm_cv, &mod->tm_lock);
++mod->tm_busy;
(void) pthread_mutex_unlock(&mod->tm_lock);
}
void
topo_mod_exit(topo_mod_t *mod)
{
(void) pthread_mutex_lock(&mod->tm_lock);
--mod->tm_busy;
assert(mod->tm_busy == 0);
(void) pthread_cond_broadcast(&mod->tm_cv);
(void) pthread_mutex_unlock(&mod->tm_lock);
}
static void
topo_modhash_lock(topo_modhash_t *mhp)
{
(void) pthread_mutex_lock(&mhp->mh_lock);
}
static void
topo_modhash_unlock(topo_modhash_t *mhp)
{
(void) pthread_mutex_unlock(&mhp->mh_lock);
}
static void
topo_mod_stop(topo_mod_t *mod)
{
if (mod->tm_flags & TOPO_MOD_INIT) {
mod->tm_mops->mop_fini(mod);
if (mod->tm_flags & TOPO_MOD_REG)
topo_mod_unregister(mod);
}
mod->tm_flags = TOPO_MOD_FINI;
topo_dprintf(mod->tm_hdl, TOPO_DBG_MODSVC,
"module %s stopped\n", mod->tm_name);
}
static int
topo_mod_start(topo_mod_t *mod, topo_version_t version)
{
topo_dprintf(mod->tm_hdl, TOPO_DBG_MODSVC,
"starting module %s\n", mod->tm_name);
if (mod->tm_mops->mop_init(mod, version) != 0) {
if (mod->tm_errno == 0)
mod->tm_errno = ETOPO_MOD_INIT;
topo_dprintf(mod->tm_hdl, TOPO_DBG_ERR,
"module %s failed to initialize: %s\n", mod->tm_name,
topo_strerror(mod->tm_errno));
return (-1);
}
mod->tm_flags |= TOPO_MOD_INIT;
if (!(mod->tm_flags & TOPO_MOD_REG)) {
topo_dprintf(mod->tm_hdl, TOPO_DBG_ERR,
"module %s failed to register\n", mod->tm_name);
mod->tm_errno = ETOPO_MOD_NOREG;
topo_mod_stop(mod);
return (-1);
}
return (0);
}
topo_mod_t *
topo_mod_lookup(topo_hdl_t *thp, const char *name, int bump)
{
topo_mod_t *mod;
topo_modhash_t *mhp = thp->th_modhash;
topo_modhash_lock(mhp);
mod = topo_modhash_lookup(mhp, name);
if (mod != NULL && bump != 0)
topo_mod_hold(mod);
topo_modhash_unlock(mhp);
return (mod);
}
static void
topo_mod_destroy(topo_mod_t *mod)
{
topo_hdl_t *thp = mod->tm_hdl;
if (mod == NULL)
return;
assert(mod->tm_refs == 0);
assert(!MUTEX_HELD(&mod->tm_lock));
if (mod->tm_name != NULL)
topo_hdl_strfree(thp, mod->tm_name);
if (mod->tm_path != NULL)
topo_hdl_strfree(thp, mod->tm_path);
if (mod->tm_rootdir != NULL)
topo_hdl_strfree(thp, mod->tm_rootdir);
topo_hdl_free(thp, mod, sizeof (topo_mod_t));
}
static topo_mod_t *
set_create_error(topo_hdl_t *thp, topo_mod_t *mod, const char *path, int err)
{
if (path != NULL)
topo_dprintf(thp, TOPO_DBG_ERR, "unable to load module %s: "
"%s\n", path, topo_strerror(err));
else
topo_dprintf(thp, TOPO_DBG_ERR, "unable to load module: "
"%s\n", topo_strerror(err));
if (mod != NULL)
topo_mod_destroy(mod);
(void) topo_hdl_seterrno(thp, err);
return (NULL);
}
static topo_mod_t *
topo_mod_create(topo_hdl_t *thp, const char *name, const char *path,
const topo_imodops_t *ops, topo_version_t version)
{
topo_mod_t *mod;
if (topo_modhash_lookup(thp->th_modhash, name) != NULL)
return (set_create_error(thp, NULL, path, ETOPO_MOD_LOADED));
if ((mod = topo_hdl_zalloc(thp, sizeof (topo_mod_t))) == NULL)
return (set_create_error(thp, mod, path, ETOPO_NOMEM));
mod->tm_hdl = thp;
(void) pthread_mutex_init(&mod->tm_lock, NULL);
mod->tm_name = topo_hdl_strdup(thp, name);
if (path != NULL)
mod->tm_path = topo_hdl_strdup(thp, path);
mod->tm_rootdir = topo_hdl_strdup(thp, thp->th_rootdir);
if (mod->tm_name == NULL || mod->tm_rootdir == NULL)
return (set_create_error(thp, mod, path, ETOPO_NOMEM));
mod->tm_mops = (topo_imodops_t *)ops;
mod->tm_alloc = thp->th_alloc;
/*
* Module will be held upon a successful return from topo_mod_start()
*/
if ((topo_mod_start(mod, version)) < 0)
return (set_create_error(thp, mod, path, mod->tm_errno));
topo_dprintf(thp, TOPO_DBG_MODSVC, "loaded module %s\n", mod->tm_name);
return (mod);
}
topo_modhash_t *
topo_modhash_create(topo_hdl_t *thp)
{
topo_modhash_t *mhp;
if ((mhp = topo_hdl_zalloc(thp, sizeof (topo_modhash_t))) == NULL)
return (NULL);
mhp->mh_hashlen = TOPO_HASH_BUCKETS;
if ((mhp->mh_hash = topo_hdl_zalloc(thp,
sizeof (void *) * mhp->mh_hashlen)) == NULL) {
topo_hdl_free(thp, mhp, sizeof (topo_modhash_t));
return (NULL);
}
mhp->mh_nelems = 0;
(void) pthread_mutex_init(&mhp->mh_lock, NULL);
thp->th_modhash = mhp;
return (mhp);
}
void
topo_modhash_destroy(topo_hdl_t *thp)
{
topo_modhash_t *mhp = thp->th_modhash;
if (mhp == NULL)
return;
assert(mhp->mh_nelems == 0);
topo_hdl_free(thp, mhp->mh_hash, sizeof (void *) * mhp->mh_hashlen);
topo_hdl_free(thp, mhp, sizeof (topo_modhash_t));
thp->th_modhash = NULL;
}
topo_mod_t *
topo_modhash_lookup(topo_modhash_t *mhp, const char *name)
{
topo_mod_t *mod = NULL;
uint_t h;
h = topo_strhash(name) % mhp->mh_hashlen;
for (mod = mhp->mh_hash[h]; mod != NULL; mod = mod->tm_next) {
if (strcmp(name, mod->tm_name) == 0)
break;
}
return (mod);
}
topo_mod_t *
topo_modhash_load(topo_hdl_t *thp, const char *name, const char *path,
const topo_imodops_t *ops, topo_version_t version)
{
topo_modhash_t *mhp = thp->th_modhash;
topo_mod_t *mod;
uint_t h;
topo_modhash_lock(mhp);
if ((mod = topo_mod_create(thp, name, path, ops, version)) == NULL) {
topo_modhash_unlock(mhp);
return (NULL); /* th_errno set */
}
topo_mod_hold(mod);
h = topo_strhash(name) % mhp->mh_hashlen;
mod->tm_next = mhp->mh_hash[h];
mhp->mh_hash[h] = mod;
mhp->mh_nelems++;
topo_modhash_unlock(mhp);
return (mod);
}
void
topo_modhash_unload(topo_mod_t *mod)
{
uint_t h;
topo_mod_t **pp, *mp;
topo_hdl_t *thp = mod->tm_hdl;
topo_modhash_t *mhp;
assert(MUTEX_HELD(&mod->tm_lock));
assert(mod->tm_busy == 0);
mhp = thp->th_modhash;
topo_modhash_lock(mhp);
assert(mhp != NULL);
h = topo_strhash(mod->tm_name) % mhp->mh_hashlen;
pp = &mhp->mh_hash[h];
for (mp = *pp; mp != NULL; mp = mp->tm_next) {
if (mp == mod)
break;
else
pp = &mp->tm_next;
}
if (mp != NULL) {
*pp = mod->tm_next;
assert(mhp->mh_nelems != 0);
mhp->mh_nelems--;
}
topo_modhash_unlock(mhp);
(void) pthread_mutex_unlock(&mod->tm_lock);
topo_mod_stop(mod);
topo_mod_destroy(mod);
}
void
topo_modhash_unload_all(topo_hdl_t *thp)
{
int i;
topo_modhash_t *mhp = thp->th_modhash;
topo_mod_t *mp, **pp;
if (mhp == NULL)
return;
topo_modhash_lock(mhp);
for (i = 0; i < TOPO_HASH_BUCKETS; ++i) {
pp = &mhp->mh_hash[i];
mp = *pp;
while (mp != NULL) {
topo_mod_stop(mp);
/*
* At this point we are forcing all modules to
* stop, ignore any remaining module reference counts.
*/
mp->tm_refs = 0;
*pp = mp->tm_next;
topo_mod_destroy(mp);
mp = *pp;
--mhp->mh_nelems;
}
}
topo_modhash_unlock(mhp);
}