/*

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

 */

/*

 * 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/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 */

/* static */

static struct vnodeops *sdev_get_vop(struct sdev_node *);

static void sdev_set_no_negcache(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;

	bzero(buf, sizeof (struct sdev_node));

	vp = dv->sdev_vnode = vn_alloc(flag);

	if (vp == NULL) {

		return (-1);

	}

	vp->v_data = dv;

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

	return (0);

}

/* sdev_node cache destructor */

/*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;

}

/*

 * Compare two nodes lexographically to balance avl tree

 */

static int

sdev_compare_nodes(const struct sdev_node *dv1, const struct sdev_node *dv2)

{

	int rv;

	if ((rv = strcmp(dv1->sdev_name, dv2->sdev_name)) == 0)

		return (0);

	return ((rv < 0) ? -1 : 1);

}

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_attr_update(struct sdev_node *dv, vattr_t *vap)

{

	timestruc_t	now;

	struct vattr	*attrp;

	uint_t		mask;

	ASSERT(dv->sdev_attr);

	ASSERT(vap);

	attrp = dv->sdev_attr;

	mask = vap->va_mask;

	if (mask & AT_TYPE)

		attrp->va_type = vap->va_type;

	if (mask & AT_MODE)

		attrp->va_mode = vap->va_mode;

	if (mask & AT_UID)

		attrp->va_uid = vap->va_uid;

	if (mask & AT_GID)

		attrp->va_gid = vap->va_gid;

	if (mask & AT_RDEV)

		attrp->va_rdev = vap->va_rdev;

	gethrestime(&now);

	attrp->va_atime = (mask & AT_ATIME) ? vap->va_atime : now;

	attrp->va_mtime = (mask & AT_MTIME) ? vap->va_mtime : now;

	attrp->va_ctime = (mask & AT_CTIME) ? vap->va_ctime : now;

}

static void

sdev_attr_alloc(struct sdev_node *dv, vattr_t *vap)

{

	ASSERT(dv->sdev_attr == NULL);

	ASSERT(vap->va_mask & AT_TYPE);

	ASSERT(vap->va_mask & AT_MODE);

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

	sdev_attr_update(dv, vap);

}

/* 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_attrvp = NULL;

	if (vap) {

		sdev_attr_alloc(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;

		dhl = &(dv->sdev_handle);

		dhl->dh_data = dv;

		dhl->dh_args = NULL;

		sdev_set_no_negcache(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 */

		ASSERT(dv->sdev_dotdot);

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

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

		avl_create(&dv->sdev_entries,

		    (int (*)(const void *, const void *))sdev_compare_nodes,

		    sizeof (struct sdev_node),

		    offsetof(struct sdev_node, sdev_avllink));

	} 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_attr_alloc(dv, vap);

		} else {

			sdev_attr_update(dv, vap);

		}

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

			error = sdev_shadow_node(dv, cred);

	}

	if (error == 0) {

		/* transition to READY state */

		sdev_set_nodestate(dv, SDEV_READY);

		sdev_nc_node_exists(dv);

	} else {

		sdev_set_nodestate(dv, SDEV_ZOMBIE);

	}

	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) {

		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;

	}

	avl_create(&dv->sdev_entries,

	    (int (*)(const void *, const void *))sdev_compare_nodes,

	    sizeof (struct sdev_node),

	    offsetof(struct sdev_node, sdev_avllink));

	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);

}

/* directory dependent vop table */

struct sdev_vop_table {

	char *vt_name;				/* subdirectory name */

	const fs_operation_def_t *vt_service;	/* vnodeops table */