/*

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

 * Use is subject to license terms.

 */

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

/*

 * utility routines for the /dev fs

 */

#include <sys/types.h>

#include <sys/param.h>

#include <sys/t_lock.h>

#include <sys/systm.h>

#include <sys/sysmacros.h>

#include <sys/user.h>

#include <sys/time.h>

#include <sys/vfs.h>

#include <sys/vnode.h>

#include <sys/file.h>

#include <sys/fcntl.h>

#include <sys/flock.h>

#include <sys/kmem.h>

#include <sys/uio.h>

#include <sys/errno.h>

#include <sys/stat.h>

#include <sys/cred.h>

#include <sys/dirent.h>

#include <sys/pathname.h>

#include <sys/cmn_err.h>

#include <sys/debug.h>

#include <sys/mode.h>

#include <sys/policy.h>

#include <fs/fs_subr.h>

#include <sys/mount.h>

#include <sys/fs/snode.h>

#include <sys/fs/dv_node.h>

#include <sys/fs/sdev_impl.h>

#include <sys/fs/sdev_node.h>

#include <sys/sunndi.h>

#include <sys/sunmdi.h>

#include <sys/conf.h>

#include <sys/proc.h>

#include <sys/user.h>

#include <sys/modctl.h>

#ifdef DEBUG

int sdev_debug = 0x00000001;

int sdev_debug_cache_flags = 0;

#endif

/*

 * globals

 */

/* prototype memory vattrs */

vattr_t sdev_vattr_dir = {

	AT_TYPE|AT_MODE|AT_UID|AT_GID,		/* va_mask */

	VDIR,					/* va_type */

	SDEV_DIRMODE_DEFAULT,			/* va_mode */

	SDEV_UID_DEFAULT,			/* va_uid */

	SDEV_GID_DEFAULT,			/* va_gid */

	0,					/* va_fsid */

	0,					/* va_nodeid */

	0,					/* va_nlink */

	0,					/* va_size */

	0,					/* va_atime */

	0,					/* va_mtime */

	0,					/* va_ctime */

	0,					/* va_rdev */

	0,					/* va_blksize */

	0,					/* va_nblocks */

	0					/* va_vcode */

};

vattr_t sdev_vattr_lnk = {

	AT_TYPE|AT_MODE,			/* va_mask */

	VLNK,					/* va_type */

	SDEV_LNKMODE_DEFAULT,			/* va_mode */

	SDEV_UID_DEFAULT,			/* va_uid */

	SDEV_GID_DEFAULT,			/* va_gid */

	0,					/* va_fsid */

	0,					/* va_nodeid */

	0,					/* va_nlink */

	0,					/* va_size */

	0,					/* va_atime */

	0,					/* va_mtime */

	0,					/* va_ctime */

	0,					/* va_rdev */

	0,					/* va_blksize */

	0,					/* va_nblocks */

	0					/* va_vcode */

};

vattr_t sdev_vattr_blk = {

	AT_TYPE|AT_MODE|AT_UID|AT_GID,		/* va_mask */

	VBLK,					/* va_type */

	S_IFBLK | SDEV_DEVMODE_DEFAULT,		/* va_mode */

	SDEV_UID_DEFAULT,			/* va_uid */

	SDEV_GID_DEFAULT,			/* va_gid */

	0,					/* va_fsid */

	0,					/* va_nodeid */

	0,					/* va_nlink */

	0,					/* va_size */

	0,					/* va_atime */

	0,					/* va_mtime */

	0,					/* va_ctime */

	0,					/* va_rdev */

	0,					/* va_blksize */

	0,					/* va_nblocks */

	0					/* va_vcode */

};

vattr_t sdev_vattr_chr = {

	AT_TYPE|AT_MODE|AT_UID|AT_GID,		/* va_mask */

	VCHR,					/* va_type */

	S_IFCHR | SDEV_DEVMODE_DEFAULT,		/* va_mode */

	SDEV_UID_DEFAULT,			/* va_uid */

	SDEV_GID_DEFAULT,			/* va_gid */

	0,					/* va_fsid */

	0,					/* va_nodeid */

	0,					/* va_nlink */

	0,					/* va_size */

	0,					/* va_atime */

	0,					/* va_mtime */

	0,					/* va_ctime */

	0,					/* va_rdev */

	0,					/* va_blksize */

	0,					/* va_nblocks */

	0					/* va_vcode */

};

kmem_cache_t	*sdev_node_cache;	/* sdev_node cache */

int		devtype;		/* fstype */

struct devname_ops *devname_ns_ops;	/* default name service directory ops */

kmutex_t devname_nsmaps_lock;	/* protect devname_nsmaps */

/* static */

static struct devname_nsmap *devname_nsmaps = NULL;

				/* contents from /etc/dev/devname_master */

static int devname_nsmaps_invalidated = 0; /* "devfsadm -m" has run */

static struct vnodeops *sdev_get_vop(struct sdev_node *);

static void sdev_set_no_nocache(struct sdev_node *);

static int sdev_get_moduleops(struct sdev_node *);

static fs_operation_def_t *sdev_merge_vtab(const fs_operation_def_t []);

static void sdev_free_vtab(fs_operation_def_t *);

static void

sdev_prof_free(struct sdev_node *dv)

{

	ASSERT(!SDEV_IS_GLOBAL(dv));

	if (dv->sdev_prof.dev_name)

		nvlist_free(dv->sdev_prof.dev_name);

	if (dv->sdev_prof.dev_map)

		nvlist_free(dv->sdev_prof.dev_map);

	if (dv->sdev_prof.dev_symlink)

		nvlist_free(dv->sdev_prof.dev_symlink);

	if (dv->sdev_prof.dev_glob_incdir)

		nvlist_free(dv->sdev_prof.dev_glob_incdir);

	if (dv->sdev_prof.dev_glob_excdir)

		nvlist_free(dv->sdev_prof.dev_glob_excdir);

	bzero(&dv->sdev_prof, sizeof (dv->sdev_prof));

}

/*

 * sdev_node cache constructor

 */

/*ARGSUSED1*/

static int

i_sdev_node_ctor(void *buf, void *cfarg, int flag)

{

	struct sdev_node *dv = (struct sdev_node *)buf;

	struct vnode *vp;

	ASSERT(flag == KM_SLEEP);

	bzero(buf, sizeof (struct sdev_node));

	rw_init(&dv->sdev_contents, NULL, RW_DEFAULT, NULL);

	dv->sdev_vnode = vn_alloc(KM_SLEEP);

	vp = SDEVTOV(dv);

	vp->v_data = (caddr_t)dv;

	return (0);

}

/* sdev_node destructor for kmem cache */

/*ARGSUSED1*/

static void

i_sdev_node_dtor(void *buf, void *arg)

{

	struct sdev_node *dv = (struct sdev_node *)buf;

	struct vnode *vp = SDEVTOV(dv);

	rw_destroy(&dv->sdev_contents);

	vn_free(vp);

}

/* initialize sdev_node cache */

void

sdev_node_cache_init()

{

	int flags = 0;

#ifdef	DEBUG

	flags = sdev_debug_cache_flags;

	if (flags)

		sdcmn_err(("cache debug flags 0x%x\n", flags));

#endif	/* DEBUG */

	ASSERT(sdev_node_cache == NULL);

	sdev_node_cache = kmem_cache_create("sdev_node_cache",

	    sizeof (struct sdev_node), 0, i_sdev_node_ctor, i_sdev_node_dtor,

	    NULL, NULL, NULL, flags);

}

/* destroy sdev_node cache */

void

sdev_node_cache_fini()

{

	ASSERT(sdev_node_cache != NULL);

	kmem_cache_destroy(sdev_node_cache);

	sdev_node_cache = NULL;

}

void

sdev_set_nodestate(struct sdev_node *dv, sdev_node_state_t state)

{

	ASSERT(dv);

	ASSERT(RW_WRITE_HELD(&dv->sdev_contents));

	dv->sdev_state = state;

}

static void

sdev_attrinit(struct sdev_node *dv, vattr_t *vap)

{

	timestruc_t now;

	ASSERT(vap);

	dv->sdev_attr = kmem_zalloc(sizeof (struct vattr), KM_SLEEP);

	*dv->sdev_attr = *vap;

	dv->sdev_attr->va_mode = MAKEIMODE(vap->va_type, vap->va_mode);

	gethrestime(&now);

	dv->sdev_attr->va_atime = now;

	dv->sdev_attr->va_mtime = now;

	dv->sdev_attr->va_ctime = now;

}

/* alloc and initialize a sdev_node */

int

sdev_nodeinit(struct sdev_node *ddv, char *nm, struct sdev_node **newdv,

    vattr_t *vap)

{

	struct sdev_node *dv = NULL;

	struct vnode *vp;

	size_t nmlen, len;

	devname_handle_t  *dhl;

	nmlen = strlen(nm) + 1;

	if (nmlen > MAXNAMELEN) {

		sdcmn_err9(("sdev_nodeinit: node name %s"

		    " too long\n", nm));

		*newdv = NULL;

		return (ENAMETOOLONG);

	}

	dv = kmem_cache_alloc(sdev_node_cache, KM_SLEEP);

	dv->sdev_name = kmem_alloc(nmlen, KM_SLEEP);

	bcopy(nm, dv->sdev_name, nmlen);

	dv->sdev_namelen = nmlen - 1;	/* '\0' not included */

	len = strlen(ddv->sdev_path) + strlen(nm) + 2;

	dv->sdev_path = kmem_alloc(len, KM_SLEEP);

	(void) snprintf(dv->sdev_path, len, "%s/%s", ddv->sdev_path, nm);

	/* overwritten for VLNK nodes */

	dv->sdev_symlink = NULL;

	vp = SDEVTOV(dv);

	vn_reinit(vp);

	vp->v_vfsp = SDEVTOV(ddv)->v_vfsp;

	if (vap)

		vp->v_type = vap->va_type;

	/*

	 * initialized to the parent's vnodeops.

	 * maybe overwriten for a VDIR

	 */

	vn_setops(vp, vn_getops(SDEVTOV(ddv)));

	vn_exists(vp);

	dv->sdev_dotdot = NULL;

	dv->sdev_dot = NULL;

	dv->sdev_next = NULL;

	dv->sdev_attrvp = NULL;

	if (vap) {

		sdev_attrinit(dv, vap);

	} else {

		dv->sdev_attr = NULL;

	}

	dv->sdev_ino = sdev_mkino(dv);

	dv->sdev_nlink = 0;		/* updated on insert */

	dv->sdev_flags = ddv->sdev_flags; /* inherit from the parent first */

	dv->sdev_flags |= SDEV_BUILD;

	mutex_init(&dv->sdev_lookup_lock, NULL, MUTEX_DEFAULT, NULL);

	cv_init(&dv->sdev_lookup_cv, NULL, CV_DEFAULT, NULL);

	if (SDEV_IS_GLOBAL(ddv)) {

		dv->sdev_flags |= SDEV_GLOBAL;

		dv->sdev_mapinfo = NULL;

		dhl = &(dv->sdev_handle);

		dhl->dh_data = dv;

		dhl->dh_spec = DEVNAME_NS_NONE;

		dhl->dh_args = NULL;

		sdev_set_no_nocache(dv);

		dv->sdev_gdir_gen = 0;

	} else {

		dv->sdev_flags &= ~SDEV_GLOBAL;

		dv->sdev_origin = NULL; /* set later */

		bzero(&dv->sdev_prof, sizeof (dv->sdev_prof));

		dv->sdev_ldir_gen = 0;

		dv->sdev_devtree_gen = 0;

	}

	rw_enter(&dv->sdev_contents, RW_WRITER);

	sdev_set_nodestate(dv, SDEV_INIT);

	rw_exit(&dv->sdev_contents);

	*newdv = dv;

	return (0);

}

/*

 * transition a sdev_node into SDEV_READY state

 */

int

sdev_nodeready(struct sdev_node *dv, struct vattr *vap, struct vnode *avp,

    void *args, struct cred *cred)

{

	int error = 0;

	struct vnode *vp = SDEVTOV(dv);

	vtype_t type;

	ASSERT(dv && (dv->sdev_state != SDEV_READY) && vap);

	type = vap->va_type;

	vp->v_type = type;

	vp->v_rdev = vap->va_rdev;

	rw_enter(&dv->sdev_contents, RW_WRITER);

	if (type == VDIR) {

		dv->sdev_nlink = 2;

		dv->sdev_flags &= ~SDEV_PERSIST;

		dv->sdev_flags &= ~SDEV_DYNAMIC;

		vn_setops(vp, sdev_get_vop(dv)); /* from internal vtab */

		error = sdev_get_moduleops(dv); /* from plug-in module */

		ASSERT(dv->sdev_dotdot);

		ASSERT(SDEVTOV(dv->sdev_dotdot)->v_type == VDIR);

		vp->v_rdev = SDEVTOV(dv->sdev_dotdot)->v_rdev;

	} else if (type == VLNK) {

		ASSERT(args);

		dv->sdev_nlink = 1;

		dv->sdev_symlink = i_ddi_strdup((char *)args, KM_SLEEP);

	} else {

		dv->sdev_nlink = 1;

	}

	if (!(SDEV_IS_GLOBAL(dv))) {

		dv->sdev_origin = (struct sdev_node *)args;

		dv->sdev_flags &= ~SDEV_PERSIST;

	}

	/*

	 * shadow node is created here OR

	 * if failed (indicated by dv->sdev_attrvp == NULL),

	 * created later in sdev_setattr

	 */

	if (avp) {

		dv->sdev_attrvp = avp;

	} else {

		if (dv->sdev_attr == NULL)

			sdev_attrinit(dv, vap);

		else

			*dv->sdev_attr = *vap;

		if ((SDEV_IS_PERSIST(dv) && (dv->sdev_attrvp == NULL)) ||

		    ((SDEVTOV(dv)->v_type == VDIR) &&

		    (dv->sdev_attrvp == NULL)))

			error = sdev_shadow_node(dv, cred);

	}

	/* transition to READY state */

	sdev_set_nodestate(dv, SDEV_READY);

	sdev_nc_node_exists(dv);

	rw_exit(&dv->sdev_contents);

	return (error);

}

/*

 * setting ZOMBIE state

 */

static int

sdev_nodezombied(struct sdev_node *dv)

{

	rw_enter(&dv->sdev_contents, RW_WRITER);

	sdev_set_nodestate(dv, SDEV_ZOMBIE);

	rw_exit(&dv->sdev_contents);

	return (0);

}

/*

 * Build the VROOT sdev_node.

 */

/*ARGSUSED*/

struct sdev_node *

sdev_mkroot(struct vfs *vfsp, dev_t devdev, struct vnode *mvp,

    struct vnode *avp, struct cred *cred)

{

	struct sdev_node *dv;

	struct vnode *vp;

	char devdir[] = "/dev";

	ASSERT(sdev_node_cache != NULL);

	ASSERT(avp);

	dv = kmem_cache_alloc(sdev_node_cache, KM_SLEEP);

	vp = SDEVTOV(dv);

	vn_reinit(vp);

	vp->v_flag |= VROOT;

	vp->v_vfsp = vfsp;

	vp->v_type = VDIR;

	vp->v_rdev = devdev;

	vn_setops(vp, sdev_vnodeops); /* apply the default vnodeops at /dev */

	vn_exists(vp);

	if (vfsp->vfs_mntpt)

		dv->sdev_name = i_ddi_strdup(

		    (char *)refstr_value(vfsp->vfs_mntpt), KM_SLEEP);

	else

		/* vfs_mountdev1 set mount point later */

		dv->sdev_name = i_ddi_strdup("/dev", KM_SLEEP);

	dv->sdev_namelen = strlen(dv->sdev_name); /* '\0' not included */

	dv->sdev_path = i_ddi_strdup(devdir, KM_SLEEP);

	dv->sdev_ino = SDEV_ROOTINO;

	dv->sdev_nlink = 2;		/* name + . (no sdev_insert) */

	dv->sdev_dotdot = dv;		/* .. == self */

	dv->sdev_attrvp = avp;

	dv->sdev_attr = NULL;

	mutex_init(&dv->sdev_lookup_lock, NULL, MUTEX_DEFAULT, NULL);

	cv_init(&dv->sdev_lookup_cv, NULL, CV_DEFAULT, NULL);

	if (strcmp(dv->sdev_name, "/dev") == 0) {

		mutex_init(&devname_nsmaps_lock, NULL, MUTEX_DEFAULT, NULL);

		dv->sdev_mapinfo = NULL;

		dv->sdev_flags = SDEV_BUILD|SDEV_GLOBAL|SDEV_PERSIST;

		bzero(&dv->sdev_handle, sizeof (dv->sdev_handle));

		dv->sdev_gdir_gen = 0;

	} else {

		dv->sdev_flags = SDEV_BUILD;

		dv->sdev_flags &= ~SDEV_PERSIST;

		bzero(&dv->sdev_prof, sizeof (dv->sdev_prof));

		dv->sdev_ldir_gen = 0;

		dv->sdev_devtree_gen = 0;

	}

	rw_enter(&dv->sdev_contents, RW_WRITER);

	sdev_set_nodestate(dv, SDEV_READY);

	rw_exit(&dv->sdev_contents);

	sdev_nc_node_exists(dv);

	return (dv);

}

/*

 *  1. load the module

 *  2. modload invokes sdev_module_register, which in turn sets

 *     the dv->sdev_mapinfo->dir_ops

 *

 * note: locking order:

 *	dv->sdev_contents -> map->dir_lock

 */

static int

sdev_get_moduleops(struct sdev_node *dv)

{

	int error = 0;

	struct devname_nsmap *map = NULL;

	char *module;

	char *path;

	int load = 1;

	ASSERT(SDEVTOV(dv)->v_type == VDIR);

	if (devname_nsmaps == NULL)

		return (0);

	if (!sdev_nsmaps_loaded() && !sdev_nsmaps_reloaded())

		return (0);

	path = dv->sdev_path;

	if ((map = sdev_get_nsmap_by_dir(path, 0))) {

		rw_enter(&map->dir_lock, RW_READER);

		if (map->dir_invalid) {

			if (map->dir_module && map->dir_newmodule &&

			    (strcmp(map->dir_module,

				load = 0;

			}

			sdev_replace_nsmap(map, map->dir_newmodule,

			    map->dir_newmap);