/*

 * CDDL HEADER START

 *

 * The contents of this file are subject to the terms of the

 * Common Development and Distribution License, Version 1.0 only

 * (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 2004 Sun Microsystems, Inc.  All rights reserved.

 * Use is subject to license terms.

 */

#pragma ident	"%Z%%M%	%I%	%E% SMI"

#include <sys/param.h>

#include <sys/modctl.h>

#include <sys/modhash.h>

#include <sys/open.h>

#include <sys/conf.h>

#include <sys/errno.h>

#include <sys/sysmacros.h>

#include <sys/kmem.h>

#include <sys/cmn_err.h>

#include <sys/stat.h>

#include <sys/mode.h>

#include <sys/pathname.h>

#include <sys/vnode.h>

#include <sys/ddi_impldefs.h>

#include <sys/ddi_implfuncs.h>

#include <sys/esunddi.h>

#include <sys/sunddi.h>

#include <sys/sunndi.h>

#include <sys/systeminfo.h>

#include <sys/hwconf.h>

#include <sys/file.h>

#include <sys/varargs.h>

#include <sys/thread.h>

#include <sys/cred.h>

#include <sys/autoconf.h>

#include <sys/kobj.h>

#include <sys/consdev.h>

#include <sys/systm.h>

#include <sys/debug.h>

#include <sys/atomic.h>

extern struct dev_ops nodev_ops;

extern struct dev_ops mod_nodev_ops;

struct mod_noload {

	struct mod_noload *mn_next;

	char *mn_name;

};

/*

 * Function prototypes

 */

static int init_stubs(struct modctl *, struct mod_modinfo *);

static int nm_hash(char *);

static void make_syscallname(char *, int);

static void hwc_hash_init();

static void hwc_hash(struct hwc_spec *, major_t);

static void hwc_unhash(struct hwc_spec *);

struct dev_ops *

mod_hold_dev_by_major(major_t major)

{

	struct dev_ops **devopspp, *ops;

	int loaded;

	char *drvname;

	if (major >= devcnt)

		return (NULL);

	LOCK_DEV_OPS(&(devnamesp[major].dn_lock));

	devopspp = &devopsp[major];

	loaded = 1;

	while (loaded && !CB_DRV_INSTALLED(*devopspp)) {

		UNLOCK_DEV_OPS(&(devnamesp[major].dn_lock));

		drvname = mod_major_to_name(major);

		if (drvname == NULL)

			return (NULL);

		loaded = (modload("drv", drvname) != -1);

		LOCK_DEV_OPS(&(devnamesp[major].dn_lock));

	}

	if (loaded) {

		INCR_DEV_OPS_REF(*devopspp);

		ops = *devopspp;

	} else {

		ops = NULL;

	}

	UNLOCK_DEV_OPS(&(devnamesp[major].dn_lock));

	return (ops);

}

#ifdef	DEBUG_RELE

static int mod_rele_pause = DEBUG_RELE;

#endif	/* DEBUG_RELE */

void

mod_rele_dev_by_major(major_t major)

{

	struct dev_ops *ops;

	struct devnames *dnp;

	if (major >= devcnt)

		return;

	dnp = &devnamesp[major];

	LOCK_DEV_OPS(&dnp->dn_lock);

	ops = devopsp[major];

	ASSERT(CB_DRV_INSTALLED(ops));

#ifdef	DEBUG_RELE

	if (!DEV_OPS_HELD(ops))  {

		char *s;

		static char *msg = "mod_rele_dev_by_major: unheld driver!";

		printf("mod_rele_dev_by_major: Major dev <%u>, name <%s>\n",

		    (uint_t)major,

		    (s = mod_major_to_name(major)) ? s : "unknown");

		if (mod_rele_pause)

			debug_enter(msg);

		else

			printf("%s\n", msg);

		UNLOCK_DEV_OPS(&dnp->dn_lock);

		return;			/* XXX: Note changed behavior */

	}

#endif	/* DEBUG_RELE */

	if (!DEV_OPS_HELD(ops)) {

		cmn_err(CE_PANIC,

		    "mod_rele_dev_by_major: Unheld driver: major number <%u>",

		    (uint_t)major);

	}

	DECR_DEV_OPS_REF(ops);

	UNLOCK_DEV_OPS(&dnp->dn_lock);

}

struct dev_ops *

mod_hold_dev_by_devi(dev_info_t *devi)

{

	major_t major;

	char *name;

	name = ddi_get_name(devi);

	if ((major = mod_name_to_major(name)) == (major_t)-1)

		return (NULL);

	return (mod_hold_dev_by_major(major));

}

void

mod_rele_dev_by_devi(dev_info_t *devi)

{

	major_t major;

	char *name;

	name = ddi_get_name(devi);

	if ((major = mod_name_to_major(name)) == (major_t)-1)

		return;

	mod_rele_dev_by_major(major);

}

int

nomod_zero()

{

	return (0);

}

int

nomod_minus_one()

{

	return (-1);

}

int

nomod_einval()

{

	return (EINVAL);

}

void

nomod_void()

{

	/* nothing */

}

/*

 * Install all the stubs for a module.

 * Return zero if there were no errors or an errno value.

 */

int

install_stubs_by_name(struct modctl *modp, char *name)

{

	char *p;

	char *filenamep;

	char namebuf[MODMAXNAMELEN + 12];

	struct mod_modinfo *mp;

	p = name;

	filenamep = name;

	while (*p)

		if (*p++ == '/')

			filenamep = p;

	/*

	 * Concatenate "name" with "_modname" then look up this symbol

	 * in the kernel.  If not found, we're done.

	 * If found, then find the "mod" info structure and call init_stubs().

	 */

	p = namebuf;

	while (*filenamep && *filenamep != '.')

		*p++ = *filenamep++;

	(void) strcpy(p, "_modinfo");

	if ((mp = (struct mod_modinfo *)modgetsymvalue(namebuf, 1)) != 0)

		return (init_stubs(modp, mp));

	else

		return (0);

}

static int

init_stubs(struct modctl *modp, struct mod_modinfo *mp)

{

	struct mod_stub_info *sp;

	int i;

	ulong_t offset;

	uintptr_t funcadr;

	char *funcname;

	modp->mod_modinfo = mp;

	/*

	 * Fill in all stubs for this module.  We can't be lazy, since

	 * some calls could come in from interrupt level, and we

	 * can't modlookup then (symbols may be paged out).

	 */

	sp = mp->modm_stubs;

	for (i = 0; sp->mods_func_adr; i++, sp++) {

		funcname = modgetsymname(sp->mods_stub_adr, &offset);

		if (funcname == NULL) {

		    printf("init_stubs: couldn't find symbol in module %s\n",

			mp->modm_module_name);

			return (EFAULT);

		}

		funcadr = kobj_lookup(modp->mod_mp, funcname);

		if (kobj_addrcheck(modp->mod_mp, (caddr_t)funcadr)) {

			printf("%s:%s() not defined properly\n",

				mp->modm_module_name, funcname);

			return (EFAULT);

		}

		sp->mods_func_adr = funcadr;

	}

	mp->mp = modp;

	return (0);

}

/*

 * modp->mod_modinfo has to be checked in these functions before

 * mod_stub_info is accessed because it's not guranteed that all

 * modules define mod_stub_info structures.

 */

void

install_stubs(struct modctl *modp)

{

	struct mod_stub_info *stub;

	if (modp->mod_modinfo) {

		membar_producer();

		for (stub = modp->mod_modinfo->modm_stubs;

		    stub->mods_func_adr; stub++) {

			stub->mods_flag |= MODS_INSTALLED;

		}

		membar_producer();

	}

}

void

uninstall_stubs(struct modctl *modp)

{

	struct mod_stub_info *stub;

	if (modp->mod_modinfo) {

		membar_producer();

		for (stub = modp->mod_modinfo->modm_stubs;

		    stub->mods_func_adr; stub++) {

			stub->mods_flag &= ~MODS_INSTALLED;

		}

		membar_producer();

	}

}

void

reset_stubs(struct modctl *modp)

{

	struct mod_stub_info *stub;

	if (modp->mod_modinfo) {

		for (stub = modp->mod_modinfo->modm_stubs;

		    stub->mods_func_adr; stub++) {

			if (stub->mods_flag & (MODS_WEAK | MODS_NOUNLOAD))

				stub->mods_func_adr =

				    (uintptr_t)stub->mods_errfcn;

			else

				stub->mods_func_adr =

				    (uintptr_t)mod_hold_stub;

		}

		modp->mod_modinfo->mp = NULL;

	}

}

struct modctl *

mod_getctl(struct modlinkage *modlp)

{

	struct modctl	*modp;

	mutex_enter(&mod_lock);

	modp = &modules;

	do {

		if (modp->mod_linkage == modlp) {

			mutex_exit(&mod_lock);

			return (modp);

		}

	} while ((modp = modp->mod_next) != &modules);

	mutex_exit(&mod_lock);

	return (NULL);

}

/*

 * Attach driver.conf info to devnames for a driver

 */

struct par_list *

impl_make_parlist(major_t major)

{

	int err;

	struct par_list *pl = NULL, *tmp;

	ddi_prop_t *props = NULL;

	char *confname, *drvname;

	struct devnames *dnp;

	dnp = &devnamesp[major];

	ASSERT(mutex_owned(&dnp->dn_lock));

	/*

	 * If .conf file already parsed or driver removed, just return.

	 * May return NULL.

	 */

	if (dnp->dn_flags & (DN_CONF_PARSED | DN_DRIVER_REMOVED))

		return (dnp->dn_pl);

	drvname = mod_major_to_name(major);

	if (drvname == NULL)

		return (NULL);

	confname = kmem_alloc(MAXNAMELEN, KM_SLEEP);

	(void) snprintf(confname, MAXNAMELEN, "drv/%s.conf", drvname);

	err = hwc_parse(confname, &pl, &props);

	kmem_free(confname, MAXNAMELEN);

	if (err)	/* file doesn't exist */

		return (NULL);

	/*

	 * If there are global properties, reference it from dnp.

	 */

	if (props)

		dnp->dn_global_prop_ptr = i_ddi_prop_list_create(props);

	/*

	 * Hash specs to be looked up by nexus drivers

	 */

	tmp = pl;

	while (tmp) {

		(void) hwc_hash(tmp->par_specs, major);

		tmp = tmp->par_next;

	}

	if (!i_ddi_io_initialized()) {

		if (i_ddi_prop_search(DDI_DEV_T_ANY, DDI_FORCEATTACH,

		    DDI_PROP_TYPE_INT, &props))

			dnp->dn_flags |= DN_FORCE_ATTACH;

	}

	dnp->dn_flags |= DN_CONF_PARSED;

	dnp->dn_pl = pl;

	return (pl);

}

/*

 * Destroy driver.conf info in devnames array for a driver

 */

int

impl_free_parlist(major_t major)

{

	struct par_list *pl;

	struct devnames *dnp = &devnamesp[major];

	/*

	 * Unref driver global property list. Don't destroy it

	 * because some instances may still be referencing it.

	 * The property list will be freed when the last ref

	 * goes away.

	 */

	if (dnp->dn_global_prop_ptr) {

		i_ddi_prop_list_rele(dnp->dn_global_prop_ptr, dnp);

		dnp->dn_global_prop_ptr = NULL;

	}

	/*

	 * remove specs from hash table

	 */

	for (pl = dnp->dn_pl; pl; pl = pl->par_next)

		hwc_unhash(pl->par_specs);

	impl_delete_par_list(dnp->dn_pl);

	dnp->dn_pl = NULL;

	dnp->dn_flags &= ~DN_CONF_PARSED;

	return (0);

}

struct bind *mb_hashtab[MOD_BIND_HASHSIZE];

struct bind *sb_hashtab[MOD_BIND_HASHSIZE];

static int

nm_hash(char *name)

{

	char c;

	int hash = 0;

	for (c = *name++; c; c = *name++)

		hash ^= c;

	return (hash & MOD_BIND_HASHMASK);

}

void

clear_binding_hash(struct bind **bhash)

{

	int i;

	struct bind *bp, *bp1;

	for (i = 0; i < MOD_BIND_HASHSIZE; i++) {

		bp = bhash[i];

		while (bp != NULL) {

			kmem_free(bp->b_name, strlen(bp->b_name) + 1);

			if (bp->b_bind_name) {

				kmem_free(bp->b_bind_name,

				    strlen(bp->b_bind_name) + 1);

			}

			bp1 = bp;

			bp = bp->b_next;

			kmem_free(bp1, sizeof (struct bind));

		}

		bhash[i] = NULL;

	}

}

static struct bind *

find_mbind(char *name, struct bind **hashtab)

{

	int hashndx;

	struct bind *mb;

	hashndx = nm_hash(name);

	for (mb = hashtab[hashndx]; mb; mb = mb->b_next) {

		if (strcmp(name, mb->b_name) == 0)

			break;

	}

	return (mb);

}

/*

 * Create an entry for the given (name, major, bind_name) tuple in the

 * hash table supplied.  Reject the attempt to do so if 'name' is already

 * in the hash table.

 *

 * Does not provide synchronization, so use only during boot or with

 * externally provided locking.

 */

int

make_mbind(char *name, int major, char *bind_name, struct bind **hashtab)

{

	struct bind *bp;

	int hashndx;

	ASSERT(hashtab != NULL);

	/*

	 * Fail if the key being added is already in the hash table

	 */

	if (find_mbind(name, hashtab) != NULL)

		return (-1);

	bp = kmem_zalloc(sizeof (struct bind), KM_SLEEP);

	bp->b_name = kmem_alloc(strlen(name) + 1, KM_SLEEP);

	(void) strcpy(bp->b_name, name);

	bp->b_num = major;

	if (bind_name != NULL) {

		bp->b_bind_name = kmem_alloc(strlen(bind_name) + 1, KM_SLEEP);

		(void) strcpy(bp->b_bind_name, bind_name);

	}

	hashndx = nm_hash(name);

	bp->b_next = hashtab[hashndx];

	hashtab[hashndx] = bp;

	return (0);

}

/*