/*

 * CDDL HEADER START

 *

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

 *

 * 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

 */

/*

 * Use is subject to license terms.

 */

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

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

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

static int auto_getattr(vnode_t *, vattr_t *, int, cred_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 *);

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

	pathname_t *, int, vnode_t *, cred_t *);

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

	int, vnode_t **, cred_t *, int);

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

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

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

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

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

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

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

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

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

static void auto_inactive(vnode_t *, cred_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 *);

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, auto_open,

	VOPNAME_CLOSE, auto_close,

	VOPNAME_GETATTR, auto_getattr,

	VOPNAME_SETATTR, auto_setattr,

	VOPNAME_ACCESS, auto_access,

	VOPNAME_LOOKUP, auto_lookup,

	VOPNAME_CREATE, auto_create,

	VOPNAME_REMOVE, auto_remove,

	VOPNAME_LINK, auto_link,

	VOPNAME_RENAME, auto_rename,

	VOPNAME_MKDIR, auto_mkdir,

	VOPNAME_RMDIR, auto_rmdir,

	VOPNAME_READDIR, auto_readdir,

	VOPNAME_SYMLINK, auto_symlink,

	VOPNAME_READLINK, auto_readlink,

	VOPNAME_FSYNC, auto_fsync,

	VOPNAME_INACTIVE, (fs_generic_func_p) auto_inactive,

	VOPNAME_RWLOCK, auto_rwlock,

	VOPNAME_RWUNLOCK, (fs_generic_func_p) auto_rwunlock,

	VOPNAME_SEEK, auto_seek,

	VOPNAME_FRLOCK, fs_error,

	VOPNAME_DISPOSE, fs_error,

	VOPNAME_SHRLOCK, fs_error,

	NULL, NULL

};

/* ARGSUSED */

static int

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

{

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

		if (!error)

			error = VOP_OPEN(vpp, flag, cred);

	}

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)

{

	return (0);

}

static int

auto_getattr(vnode_t *vp, vattr_t *vap, int flags, cred_t *cred)

{

	fnnode_t *fnp = vntofn(vp);

	vnode_t *newvp;

	vfs_t *vfsp;

	int error;

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

	/*

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

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

		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)

{

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

		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;

		}

		mode &= ~(fnp->fn_mode << shift);

		if (mode != 0)

			error = secpolicy_vnode_access(cred, vp, fnp->fn_uid,

									mode);

	}

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)

{

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

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

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

			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)

					operation = AUTOFS_LOOKUP;

			}

		} else if ((dfnp->fn_dirents == NULL) &&

		    ((dvp->v_flag & VROOT) == 0) &&

		    ((fntovn(dfnp->fn_parent))->v_flag & VROOT)) {

			/*

			 * dfnp is the actual 'mountpoint' of indirect map,

			 * it is the equivalent of a direct mount,

			 * ie, /home/'user1'

			 */

			operation = AUTOFS_MOUNT;

			VN_HOLD(fntovn(dfnp));

			fnp = dfnp;

			error = 0;

			searchnm = dfnp->fn_name;

		}

	}

	if (error == EAGAIN) {

		rw_exit(&dfnp->fn_rwlock);

		goto top;

	}

	if (error) {

		rw_exit(&dfnp->fn_rwlock);

		return (error);

	}

	/*

	 * We now have the actual fnnode we're interested in.

	 * The 'MF_LOOKUP' indicates another thread is currently

	 * performing a daemon lookup of this node, therefore we

	 * wait for its completion.

	 * The 'MF_INPROG' indicates another thread is currently

	 * performing a daemon mount of this node, we wait for it

	 * to be done if we are performing a MOUNT. We don't

	 * wait for it if we are performing a LOOKUP.

	 * We can release the reader/writer lock as soon as we acquire

	 * the mutex, since the state of the lock can only change by

	 * first acquiring the mutex.

	 */

	mutex_enter(&fnp->fn_lock);

	rw_exit(&dfnp->fn_rwlock);

	if ((fnp->fn_flags & MF_LOOKUP) ||

	    ((operation == AUTOFS_MOUNT) && (fnp->fn_flags & MF_INPROG))) {

		mutex_exit(&fnp->fn_lock);

		error = auto_wait4mount(fnp);

		VN_RELE(fntovn(fnp));

		if (error == AUTOFS_SHUTDOWN)

			error = ENOENT;

		if (error && error != EAGAIN)

			return (error);

		goto top;

	}

	if (operation == 0) {