/*

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

 */

#include <sys/param.h>

#include <sys/systm.h>

#include <sys/errno.h>

#include <sys/proc.h>

#include <sys/vnode.h>

#include <sys/vfs.h>

#include <sys/vfs_opreg.h>

#include <sys/uio.h>

#include <sys/cred.h>

#include <sys/pathname.h>

#include <sys/dirent.h>

#include <sys/debug.h>

#include <sys/sysmacros.h>

#include <sys/tiuser.h>

#include <sys/cmn_err.h>

#include <sys/stat.h>

#include <sys/mode.h>

#include <sys/policy.h>

#include <rpc/types.h>

#include <rpc/auth.h>

#include <rpc/clnt.h>

#include <sys/fs/autofs.h>

#include <rpcsvc/autofs_prot.h>

#include <fs/fs_subr.h>

/*

 *  Vnode ops for autofs

 */

static int auto_open(vnode_t **, int, cred_t *, caller_context_t *);

static int auto_close(vnode_t *, int, int, offset_t, cred_t *,

	caller_context_t *);

static int auto_getattr(vnode_t *, vattr_t *, int, cred_t *,

	caller_context_t *);

static int auto_setattr(vnode_t *, vattr_t *, int, cred_t *,

	caller_context_t *);

static int auto_access(vnode_t *, int, int, cred_t *, caller_context_t *);

static int auto_lookup(vnode_t *, char *, vnode_t **,

	pathname_t *, int, vnode_t *, cred_t *, caller_context_t *, int *,

	pathname_t *);

static int auto_create(vnode_t *, char *, vattr_t *, vcexcl_t,

	int, vnode_t **, cred_t *, int, caller_context_t *,  vsecattr_t *);

static int auto_remove(vnode_t *, char *, cred_t *, caller_context_t *, int);

static int auto_link(vnode_t *, vnode_t *, char *, cred_t *,

	caller_context_t *, int);

static int auto_rename(vnode_t *, char *, vnode_t *, char *, cred_t *,

	caller_context_t *, int);

static int auto_mkdir(vnode_t *, char *, vattr_t *, vnode_t **, cred_t *,

	caller_context_t *, int, vsecattr_t *);

static int auto_rmdir(vnode_t *, char *, vnode_t *, cred_t *,

	caller_context_t *, int);

static int auto_readdir(vnode_t *, uio_t *, cred_t *, int *,

	caller_context_t *, int);

static int auto_symlink(vnode_t *, char *, vattr_t *, char *, cred_t *,

	caller_context_t *, int);

static int auto_readlink(vnode_t *, struct uio *, cred_t *,

	caller_context_t *);

static int auto_fsync(vnode_t *, int, cred_t *, caller_context_t *);

static void auto_inactive(vnode_t *, cred_t *, caller_context_t *);

static int auto_rwlock(vnode_t *, int, caller_context_t *);

static void auto_rwunlock(vnode_t *vp, int, caller_context_t *);

static int auto_seek(vnode_t *vp, offset_t, offset_t *, caller_context_t *);

static int auto_trigger_mount(vnode_t *, cred_t *, vnode_t **);

vnodeops_t *auto_vnodeops;

const fs_operation_def_t auto_vnodeops_template[] = {

	VOPNAME_OPEN,		{ .vop_open = auto_open },

	VOPNAME_CLOSE,		{ .vop_close = auto_close },

	VOPNAME_GETATTR,	{ .vop_getattr = auto_getattr },

	VOPNAME_SETATTR,	{ .vop_setattr = auto_setattr },

	VOPNAME_ACCESS,		{ .vop_access = auto_access },

	VOPNAME_LOOKUP,		{ .vop_lookup = auto_lookup },

	VOPNAME_CREATE,		{ .vop_create = auto_create },

	VOPNAME_REMOVE,		{ .vop_remove = auto_remove },

	VOPNAME_LINK,		{ .vop_link = auto_link },

	VOPNAME_RENAME,		{ .vop_rename = auto_rename },

	VOPNAME_MKDIR,		{ .vop_mkdir = auto_mkdir },

	VOPNAME_RMDIR,		{ .vop_rmdir = auto_rmdir },

	VOPNAME_READDIR,	{ .vop_readdir = auto_readdir },

	VOPNAME_SYMLINK,	{ .vop_symlink = auto_symlink },

	VOPNAME_READLINK,	{ .vop_readlink = auto_readlink },

	VOPNAME_FSYNC,		{ .vop_fsync = auto_fsync },

	VOPNAME_INACTIVE,	{ .vop_inactive = auto_inactive },

	VOPNAME_RWLOCK,		{ .vop_rwlock = auto_rwlock },

	VOPNAME_RWUNLOCK,	{ .vop_rwunlock = auto_rwunlock },

	VOPNAME_SEEK,		{ .vop_seek = auto_seek },

	VOPNAME_FRLOCK,		{ .error = fs_error },

	VOPNAME_DISPOSE,	{ .error = fs_error },

	VOPNAME_SHRLOCK,	{ .error = fs_error },

	VOPNAME_VNEVENT,	{ .vop_vnevent = fs_vnevent_support },

	NULL,			NULL

};

/* ARGSUSED */

static int

auto_open(vnode_t **vpp, int flag, cred_t *cred, caller_context_t *ct)

{

	vnode_t *newvp;

	int error;

	AUTOFS_DPRINT((4, "auto_open: *vpp=%p\n", (void *)*vpp));

	error = auto_trigger_mount(*vpp, cred, &newvp);

	if (error)

		goto done;

	if (newvp != NULL) {

		/*

		 * Node is now mounted on.

		 */

		VN_RELE(*vpp);

		*vpp = newvp;

		error = VOP_ACCESS(*vpp, VREAD, 0, cred, ct);

		if (!error)

			error = VOP_OPEN(vpp, flag, cred, ct);

	}

done:

	AUTOFS_DPRINT((5, "auto_open: *vpp=%p error=%d\n", (void *)*vpp,

	    error));

	return (error);

}

/* ARGSUSED */

static int

auto_close(

	vnode_t *vp,

	int flag,

	int count,

	offset_t offset,

	cred_t *cred,

	caller_context_t *ct)

{

	return (0);

}

static int

auto_getattr(

	vnode_t *vp,

	vattr_t *vap,

	int flags,

	cred_t *cred,

	caller_context_t *ct)

{

	fnnode_t *fnp = vntofn(vp);

	vnode_t *newvp;

	vfs_t *vfsp;

	int error;

	AUTOFS_DPRINT((4, "auto_getattr vp %p\n", (void *)vp));

	if (flags & ATTR_TRIGGER) {

		/*

		 * Pre-trigger the mount

		 */

		error = auto_trigger_mount(vp, cred, &newvp);

		if (error)

			return (error);

		if (newvp == NULL)

			goto defattr;

		if (error = vn_vfsrlock_wait(vp))

			return (error);

		vfsp = newvp->v_vfsp;

	} else {

		/*

		 * Recursive auto_getattr/mount; go to the vfsp == NULL

		 * case.

		 */

		if (vn_vfswlock_held(vp))

			goto defattr;

		if (error = vn_vfsrlock_wait(vp))

			return (error);

		vfsp = vn_mountedvfs(vp);

	}

	if (vfsp != NULL) {

		/*

		 * Node is mounted on.

		 */

		error = VFS_ROOT(vfsp, &newvp);

		vn_vfsunlock(vp);

		if (error)

			return (error);

		mutex_enter(&fnp->fn_lock);

		if (fnp->fn_seen == newvp && fnp->fn_thread == curthread) {

			/*

			 * Recursive auto_getattr(); just release newvp and drop

			 * into the vfsp == NULL case.

			 */

			mutex_exit(&fnp->fn_lock);

			VN_RELE(newvp);

		} else {

			while (fnp->fn_thread && fnp->fn_thread != curthread) {

				fnp->fn_flags |= MF_ATTR_WAIT;

				cv_wait(&fnp->fn_cv_mount, &fnp->fn_lock);

			}

			fnp->fn_thread = curthread;

			fnp->fn_seen = newvp;

			mutex_exit(&fnp->fn_lock);

			error = VOP_GETATTR(newvp, vap, flags, cred, ct);

			VN_RELE(newvp);

			mutex_enter(&fnp->fn_lock);

			fnp->fn_seen = 0;

			fnp->fn_thread = 0;

			if (fnp->fn_flags & MF_ATTR_WAIT) {

				fnp->fn_flags &= ~MF_ATTR_WAIT;

				cv_broadcast(&fnp->fn_cv_mount);

			}

			mutex_exit(&fnp->fn_lock);

			return (error);

		}

	} else {

		vn_vfsunlock(vp);

	}

defattr:

	ASSERT(vp->v_type == VDIR || vp->v_type == VLNK);

	vap->va_uid	= 0;

	vap->va_gid	= 0;

	vap->va_nlink	= fnp->fn_linkcnt;

	vap->va_nodeid	= (u_longlong_t)fnp->fn_nodeid;

	vap->va_size	= fnp->fn_size;

	vap->va_atime	= fnp->fn_atime;

	vap->va_mtime	= fnp->fn_mtime;

	vap->va_ctime	= fnp->fn_ctime;

	vap->va_type	= vp->v_type;

	vap->va_mode	= fnp->fn_mode;

	vap->va_fsid	= vp->v_vfsp->vfs_dev;

	vap->va_rdev	= 0;

	vap->va_blksize	= MAXBSIZE;

	vap->va_nblocks	= (fsblkcnt64_t)btod(vap->va_size);

	vap->va_seq	= 0;

	return (0);

}

/*ARGSUSED4*/

static int

auto_setattr(

	vnode_t *vp,

	struct vattr *vap,

	int flags,

	cred_t *cred,

	caller_context_t *ct)

{

	vnode_t *newvp;

	int error;

	AUTOFS_DPRINT((4, "auto_setattr vp %p\n", (void *)vp));

	if (error = auto_trigger_mount(vp, cred, &newvp))

		goto done;

	if (newvp != NULL) {

		/*

		 * Node is mounted on.

		 */

		if (vn_is_readonly(newvp))

			error = EROFS;

		else

			error = VOP_SETATTR(newvp, vap, flags, cred, ct);

		VN_RELE(newvp);

	} else

		error = ENOSYS;

done:

	AUTOFS_DPRINT((5, "auto_setattr: error=%d\n", error));

	return (error);

}

/* ARGSUSED */

static int

auto_access(

	vnode_t *vp,

	int mode,

	int flags,

	cred_t *cred,

	caller_context_t *ct)

{

	fnnode_t *fnp = vntofn(vp);

	vnode_t *newvp;

	int error;

	AUTOFS_DPRINT((4, "auto_access: vp=%p\n", (void *)vp));

	if (error = auto_trigger_mount(vp, cred, &newvp))

		goto done;

	if (newvp != NULL) {

		/*

		 * Node is mounted on.

		 */

		error = VOP_ACCESS(newvp, mode, 0, cred, ct);

		VN_RELE(newvp);

	} else {

		int shift = 0;

		/*

		 * really interested in the autofs node, check the

		 * access on it

		 */

		ASSERT(error == 0);

		if (crgetuid(cred) != fnp->fn_uid) {

			shift += 3;

			if (groupmember(fnp->fn_gid, cred) == 0)

				shift += 3;

		}

	}

done:

	AUTOFS_DPRINT((5, "auto_access: error=%d\n", error));

	return (error);

}

static int

auto_lookup(

	vnode_t *dvp,

	char *nm,

	vnode_t **vpp,

	pathname_t *pnp,

	int flags,

	vnode_t *rdir,

	cred_t *cred,

	caller_context_t *ct,

	int *direntflags,

	pathname_t *realpnp)

{

	int error = 0;

	vnode_t *newvp = NULL;

	vfs_t *vfsp;

	fninfo_t *dfnip;

	fnnode_t *dfnp = NULL;

	fnnode_t *fnp = NULL;

	char *searchnm;

	int operation;		/* either AUTOFS_LOOKUP or AUTOFS_MOUNT */

	dfnip = vfstofni(dvp->v_vfsp);

	AUTOFS_DPRINT((3, "auto_lookup: dvp=%p (%s) name=%s\n",

	    (void *)dvp, dfnip->fi_map, nm));

	if (nm[0] == 0) {

		VN_HOLD(dvp);

		*vpp = dvp;

		return (0);

	}

	if (error = VOP_ACCESS(dvp, VEXEC, 0, cred, ct))

		return (error);

	if (nm[0] == '.' && nm[1] == 0) {

		VN_HOLD(dvp);

		*vpp = dvp;

		return (0);

	}

	if (nm[0] == '.' && nm[1] == '.' && nm[2] == 0) {

		fnnode_t *pdfnp;

		pdfnp = (vntofn(dvp))->fn_parent;

		ASSERT(pdfnp != NULL);

		/*

		 * Since it is legitimate to have the VROOT flag set for the

		 * subdirectories of the indirect map in autofs filesystem,

		 * rootfnnodep is checked against fnnode of dvp instead of

		 * just checking whether VROOT flag is set in dvp

		 */

		if (pdfnp == pdfnp->fn_globals->fng_rootfnnodep) {

			vnode_t *vp;

			vfs_rlock_wait(dvp->v_vfsp);

			if (dvp->v_vfsp->vfs_flag & VFS_UNMOUNTED) {

				vfs_unlock(dvp->v_vfsp);

				return (EIO);

			}

			vp = dvp->v_vfsp->vfs_vnodecovered;

			VN_HOLD(vp);

			vfs_unlock(dvp->v_vfsp);

			error = VOP_LOOKUP(vp, nm, vpp, pnp, flags, rdir, cred,

			    ct, direntflags, realpnp);

			VN_RELE(vp);

			return (error);

		} else {

			*vpp = fntovn(pdfnp);

			VN_HOLD(*vpp);

			return (0);

		}

	}

top:

	dfnp = vntofn(dvp);

	searchnm = nm;

	operation = 0;

	ASSERT(vn_matchops(dvp, auto_vnodeops));

	AUTOFS_DPRINT((3, "auto_lookup: dvp=%p dfnp=%p\n", (void *)dvp,

	    (void *)dfnp));

	/*

	 * If a lookup or mount of this node is in progress, wait for it

	 * to finish, and return whatever result it got.

	 */

	mutex_enter(&dfnp->fn_lock);

	if (dfnp->fn_flags & (MF_LOOKUP | MF_INPROG)) {

		mutex_exit(&dfnp->fn_lock);

		error = auto_wait4mount(dfnp);

		if (error == AUTOFS_SHUTDOWN)

			error = ENOENT;

		if (error == EAGAIN)

			goto top;

		if (error)

			return (error);

	} else

		mutex_exit(&dfnp->fn_lock);

	error = vn_vfsrlock_wait(dvp);

	if (error)

		return (error);

	vfsp = vn_mountedvfs(dvp);

	if (vfsp != NULL) {

		error = VFS_ROOT(vfsp, &newvp);

		vn_vfsunlock(dvp);

		if (!error) {

			error = VOP_LOOKUP(newvp, nm, vpp, pnp,

			    flags, rdir, cred, ct, direntflags, realpnp);

			VN_RELE(newvp);

		}

		return (error);

	}

	vn_vfsunlock(dvp);

	rw_enter(&dfnp->fn_rwlock, RW_READER);

	error = auto_search(dfnp, nm, &fnp, cred);

	if (error) {

		if (dfnip->fi_flags & MF_DIRECT) {

			/*

			 * direct map.

			 */

			if (dfnp->fn_dirents) {

				/*

				 * Mount previously triggered.

				 * 'nm' not found

				 */

				error = ENOENT;

			} else {

				/*

				 * I need to contact the daemon to trigger

				 * the mount. 'dfnp' will be the mountpoint.

				 */

				operation = AUTOFS_MOUNT;

				VN_HOLD(fntovn(dfnp));

				fnp = dfnp;

				error = 0;

			}

		} else if (dvp == dfnip->fi_rootvp) {

			/*

			 * 'dfnp' is the root of the indirect AUTOFS.

			 */

			if (rw_tryupgrade(&dfnp->fn_rwlock) == 0) {

				/*

				 * Could not acquire writer lock, release

				 * reader, and wait until available. We

				 * need to search for 'nm' again, since we

				 * had to release the lock before reacquiring

				 * it.

				 */

				rw_exit(&dfnp->fn_rwlock);

				rw_enter(&dfnp->fn_rwlock, RW_WRITER);

				error = auto_search(dfnp, nm, &fnp, cred);

			}

			ASSERT(RW_WRITE_HELD(&dfnp->fn_rwlock));

			if (error) {

				/*

				 * create node being looked-up and request

				 * mount on it.

				 */

				error = auto_enter(dfnp, nm, &fnp, kcred);

				if (!error)