xref: /illumos-gate/usr/src/uts/common/fs/lookup.c (revision c6f039c7)
17c478bd9Sstevel@tonic-gate /*
27c478bd9Sstevel@tonic-gate  * CDDL HEADER START
37c478bd9Sstevel@tonic-gate  *
47c478bd9Sstevel@tonic-gate  * The contents of this file are subject to the terms of the
52e538c1cSvv  * Common Development and Distribution License (the "License").
62e538c1cSvv  * You may not use this file except in compliance with the License.
77c478bd9Sstevel@tonic-gate  *
87c478bd9Sstevel@tonic-gate  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
97c478bd9Sstevel@tonic-gate  * or http://www.opensolaris.org/os/licensing.
107c478bd9Sstevel@tonic-gate  * See the License for the specific language governing permissions
117c478bd9Sstevel@tonic-gate  * and limitations under the License.
127c478bd9Sstevel@tonic-gate  *
137c478bd9Sstevel@tonic-gate  * When distributing Covered Code, include this CDDL HEADER in each
147c478bd9Sstevel@tonic-gate  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
157c478bd9Sstevel@tonic-gate  * If applicable, add the following below this CDDL HEADER, with the
167c478bd9Sstevel@tonic-gate  * fields enclosed by brackets "[]" replaced with your own identifying
177c478bd9Sstevel@tonic-gate  * information: Portions Copyright [yyyy] [name of copyright owner]
187c478bd9Sstevel@tonic-gate  *
197c478bd9Sstevel@tonic-gate  * CDDL HEADER END
207c478bd9Sstevel@tonic-gate  */
21794f0adbSRoger A. Faulkner 
227c478bd9Sstevel@tonic-gate /*
236e062f4aSMarcel Telka  * Copyright 2015 Nexenta Systems, Inc.  All rights reserved.
242f5706a1SWilliam.Johnston  * Copyright (c) 1988, 2010, Oracle and/or its affiliates. All rights reserved.
25e2fc3408SPatrick Mooney  * Copyright 2016 Joyent, Inc.
267c478bd9Sstevel@tonic-gate  */
277c478bd9Sstevel@tonic-gate 
287c478bd9Sstevel@tonic-gate /*	Copyright (c) 1983, 1984, 1985, 1986, 1987, 1988, 1989 AT&T	*/
297c478bd9Sstevel@tonic-gate /*	  All Rights Reserved  	*/
307c478bd9Sstevel@tonic-gate 
317c478bd9Sstevel@tonic-gate /*
327c478bd9Sstevel@tonic-gate  * University Copyright- Copyright (c) 1982, 1986, 1988
337c478bd9Sstevel@tonic-gate  * The Regents of the University of California
347c478bd9Sstevel@tonic-gate  * All Rights Reserved
357c478bd9Sstevel@tonic-gate  *
367c478bd9Sstevel@tonic-gate  * University Acknowledgment- Portions of this document are derived from
377c478bd9Sstevel@tonic-gate  * software developed by the University of California, Berkeley, and its
387c478bd9Sstevel@tonic-gate  * contributors.
397c478bd9Sstevel@tonic-gate  */
407c478bd9Sstevel@tonic-gate 
417c478bd9Sstevel@tonic-gate #include <sys/types.h>
427c478bd9Sstevel@tonic-gate #include <sys/param.h>
437c478bd9Sstevel@tonic-gate #include <sys/systm.h>
447c478bd9Sstevel@tonic-gate #include <sys/cpuvar.h>
457c478bd9Sstevel@tonic-gate #include <sys/errno.h>
467c478bd9Sstevel@tonic-gate #include <sys/cred.h>
477c478bd9Sstevel@tonic-gate #include <sys/user.h>
487c478bd9Sstevel@tonic-gate #include <sys/uio.h>
497c478bd9Sstevel@tonic-gate #include <sys/vfs.h>
507c478bd9Sstevel@tonic-gate #include <sys/vnode.h>
517c478bd9Sstevel@tonic-gate #include <sys/pathname.h>
527c478bd9Sstevel@tonic-gate #include <sys/proc.h>
537c478bd9Sstevel@tonic-gate #include <sys/vtrace.h>
547c478bd9Sstevel@tonic-gate #include <sys/sysmacros.h>
557c478bd9Sstevel@tonic-gate #include <sys/debug.h>
567c478bd9Sstevel@tonic-gate #include <sys/dirent.h>
577c478bd9Sstevel@tonic-gate #include <c2/audit.h>
587c478bd9Sstevel@tonic-gate #include <sys/zone.h>
597c478bd9Sstevel@tonic-gate #include <sys/dnlc.h>
607c478bd9Sstevel@tonic-gate #include <sys/fs/snode.h>
617c478bd9Sstevel@tonic-gate 
627c478bd9Sstevel@tonic-gate /* Controls whether paths are stored with vnodes. */
637c478bd9Sstevel@tonic-gate int vfs_vnode_path = 1;
647c478bd9Sstevel@tonic-gate 
657c478bd9Sstevel@tonic-gate int
lookupname(char * fnamep,enum uio_seg seg,int followlink,vnode_t ** dirvpp,vnode_t ** compvpp)667c478bd9Sstevel@tonic-gate lookupname(
677c478bd9Sstevel@tonic-gate 	char *fnamep,
687c478bd9Sstevel@tonic-gate 	enum uio_seg seg,
69794f0adbSRoger A. Faulkner 	int followlink,
707c478bd9Sstevel@tonic-gate 	vnode_t **dirvpp,
717c478bd9Sstevel@tonic-gate 	vnode_t **compvpp)
727c478bd9Sstevel@tonic-gate {
737a142be9SCasper H.S. Dik 	return (lookupnameatcred(fnamep, seg, followlink, dirvpp, compvpp, NULL,
747a142be9SCasper H.S. Dik 	    CRED()));
757c478bd9Sstevel@tonic-gate }
767c478bd9Sstevel@tonic-gate 
777c478bd9Sstevel@tonic-gate /*
787c478bd9Sstevel@tonic-gate  * Lookup the user file name,
797c478bd9Sstevel@tonic-gate  * Handle allocation and freeing of pathname buffer, return error.
807c478bd9Sstevel@tonic-gate  */
817c478bd9Sstevel@tonic-gate int
lookupnameatcred(char * fnamep,enum uio_seg seg,int followlink,vnode_t ** dirvpp,vnode_t ** compvpp,vnode_t * startvp,cred_t * cr)827a142be9SCasper H.S. Dik lookupnameatcred(
837c478bd9Sstevel@tonic-gate 	char *fnamep,			/* user pathname */
847c478bd9Sstevel@tonic-gate 	enum uio_seg seg,		/* addr space that name is in */
85794f0adbSRoger A. Faulkner 	int followlink,			/* follow sym links */
867c478bd9Sstevel@tonic-gate 	vnode_t **dirvpp,		/* ret for ptr to parent dir vnode */
877c478bd9Sstevel@tonic-gate 	vnode_t **compvpp,		/* ret for ptr to component vnode */
887a142be9SCasper H.S. Dik 	vnode_t *startvp,		/* start path search from vp */
897a142be9SCasper H.S. Dik 	cred_t *cr)			/* credential */
907c478bd9Sstevel@tonic-gate {
917c478bd9Sstevel@tonic-gate 	char namebuf[TYPICALMAXPATHLEN];
927c478bd9Sstevel@tonic-gate 	struct pathname lookpn;
937c478bd9Sstevel@tonic-gate 	int error;
947c478bd9Sstevel@tonic-gate 
957c478bd9Sstevel@tonic-gate 	error = pn_get_buf(fnamep, seg, &lookpn, namebuf, sizeof (namebuf));
967c478bd9Sstevel@tonic-gate 	if (error == 0) {
977a142be9SCasper H.S. Dik 		error = lookuppnatcred(&lookpn, NULL, followlink,
987a142be9SCasper H.S. Dik 		    dirvpp, compvpp, startvp, cr);
997c478bd9Sstevel@tonic-gate 	}
1007c478bd9Sstevel@tonic-gate 	if (error == ENAMETOOLONG) {
1017c478bd9Sstevel@tonic-gate 		/*
1027c478bd9Sstevel@tonic-gate 		 * This thread used a pathname > TYPICALMAXPATHLEN bytes long.
1037c478bd9Sstevel@tonic-gate 		 */
1047c478bd9Sstevel@tonic-gate 		if (error = pn_get(fnamep, seg, &lookpn))
1057c478bd9Sstevel@tonic-gate 			return (error);
1067a142be9SCasper H.S. Dik 		error = lookuppnatcred(&lookpn, NULL, followlink,
1077a142be9SCasper H.S. Dik 		    dirvpp, compvpp, startvp, cr);
1087c478bd9Sstevel@tonic-gate 		pn_free(&lookpn);
1097c478bd9Sstevel@tonic-gate 	}
1107c478bd9Sstevel@tonic-gate 
1117c478bd9Sstevel@tonic-gate 	return (error);
1127c478bd9Sstevel@tonic-gate }
1137c478bd9Sstevel@tonic-gate 
1147a142be9SCasper H.S. Dik int
lookupnameat(char * fnamep,enum uio_seg seg,int followlink,vnode_t ** dirvpp,vnode_t ** compvpp,vnode_t * startvp)115794f0adbSRoger A. Faulkner lookupnameat(char *fnamep, enum uio_seg seg, int followlink,
1167a142be9SCasper H.S. Dik     vnode_t **dirvpp, vnode_t **compvpp, vnode_t *startvp)
1177a142be9SCasper H.S. Dik {
1187a142be9SCasper H.S. Dik 	return (lookupnameatcred(fnamep, seg, followlink, dirvpp, compvpp,
1197a142be9SCasper H.S. Dik 	    startvp, CRED()));
1207a142be9SCasper H.S. Dik }
1217a142be9SCasper H.S. Dik 
1227c478bd9Sstevel@tonic-gate int
lookuppn(struct pathname * pnp,struct pathname * rpnp,int followlink,vnode_t ** dirvpp,vnode_t ** compvpp)1237c478bd9Sstevel@tonic-gate lookuppn(
1247c478bd9Sstevel@tonic-gate 	struct pathname *pnp,
1257c478bd9Sstevel@tonic-gate 	struct pathname *rpnp,
126794f0adbSRoger A. Faulkner 	int followlink,
1277c478bd9Sstevel@tonic-gate 	vnode_t **dirvpp,
1287c478bd9Sstevel@tonic-gate 	vnode_t **compvpp)
1297c478bd9Sstevel@tonic-gate {
1307a142be9SCasper H.S. Dik 	return (lookuppnatcred(pnp, rpnp, followlink, dirvpp, compvpp, NULL,
1317a142be9SCasper H.S. Dik 	    CRED()));
1327c478bd9Sstevel@tonic-gate }
1337c478bd9Sstevel@tonic-gate 
1347a142be9SCasper H.S. Dik /*
1357a142be9SCasper H.S. Dik  * Lookup the user file name from a given vp, using a specific credential.
1367a142be9SCasper H.S. Dik  */
1377c478bd9Sstevel@tonic-gate int
lookuppnatcred(struct pathname * pnp,struct pathname * rpnp,int followlink,vnode_t ** dirvpp,vnode_t ** compvpp,vnode_t * startvp,cred_t * cr)1387a142be9SCasper H.S. Dik lookuppnatcred(
1397c478bd9Sstevel@tonic-gate 	struct pathname *pnp,		/* pathname to lookup */
1407c478bd9Sstevel@tonic-gate 	struct pathname *rpnp,		/* if non-NULL, return resolved path */
141794f0adbSRoger A. Faulkner 	int followlink,			/* (don't) follow sym links */
1427c478bd9Sstevel@tonic-gate 	vnode_t **dirvpp,		/* ptr for parent vnode */
1437c478bd9Sstevel@tonic-gate 	vnode_t **compvpp,		/* ptr for entry vnode */
1447a142be9SCasper H.S. Dik 	vnode_t *startvp,		/* start search from this vp */
1457a142be9SCasper H.S. Dik 	cred_t *cr)			/* user credential */
1467c478bd9Sstevel@tonic-gate {
1477c478bd9Sstevel@tonic-gate 	vnode_t *vp;	/* current directory vp */
1487c478bd9Sstevel@tonic-gate 	vnode_t *rootvp;
1497c478bd9Sstevel@tonic-gate 	proc_t *p = curproc;
1507c478bd9Sstevel@tonic-gate 
1517c478bd9Sstevel@tonic-gate 	if (pnp->pn_pathlen == 0)
1527c478bd9Sstevel@tonic-gate 		return (ENOENT);
1537c478bd9Sstevel@tonic-gate 
1547c478bd9Sstevel@tonic-gate 	mutex_enter(&p->p_lock);	/* for u_rdir and u_cdir */
1557c478bd9Sstevel@tonic-gate 	if ((rootvp = PTOU(p)->u_rdir) == NULL)
1567c478bd9Sstevel@tonic-gate 		rootvp = rootdir;
1577c478bd9Sstevel@tonic-gate 	else if (rootvp != rootdir)	/* no need to VN_HOLD rootdir */
1587c478bd9Sstevel@tonic-gate 		VN_HOLD(rootvp);
1597c478bd9Sstevel@tonic-gate 
1607c478bd9Sstevel@tonic-gate 	if (pnp->pn_path[0] == '/') {
1617c478bd9Sstevel@tonic-gate 		vp = rootvp;
1627c478bd9Sstevel@tonic-gate 	} else {
1637c478bd9Sstevel@tonic-gate 		vp = (startvp == NULL) ? PTOU(p)->u_cdir : startvp;
1647c478bd9Sstevel@tonic-gate 	}
1657c478bd9Sstevel@tonic-gate 	VN_HOLD(vp);
1667c478bd9Sstevel@tonic-gate 	mutex_exit(&p->p_lock);
1677c478bd9Sstevel@tonic-gate 
1687c478bd9Sstevel@tonic-gate 	/*
1697c478bd9Sstevel@tonic-gate 	 * Skip over leading slashes
1707c478bd9Sstevel@tonic-gate 	 */
1717c478bd9Sstevel@tonic-gate 	if (pnp->pn_path[0] == '/') {
1727c478bd9Sstevel@tonic-gate 		do {
1737c478bd9Sstevel@tonic-gate 			pnp->pn_path++;
1747c478bd9Sstevel@tonic-gate 			pnp->pn_pathlen--;
1757c478bd9Sstevel@tonic-gate 		} while (pnp->pn_path[0] == '/');
1767c478bd9Sstevel@tonic-gate 	}
1777c478bd9Sstevel@tonic-gate 
1787c478bd9Sstevel@tonic-gate 	return (lookuppnvp(pnp, rpnp, followlink, dirvpp,
1797a142be9SCasper H.S. Dik 	    compvpp, rootvp, vp, cr));
1807a142be9SCasper H.S. Dik }
1817a142be9SCasper H.S. Dik 
1827a142be9SCasper H.S. Dik int
lookuppnat(struct pathname * pnp,struct pathname * rpnp,int followlink,vnode_t ** dirvpp,vnode_t ** compvpp,vnode_t * startvp)1837a142be9SCasper H.S. Dik lookuppnat(struct pathname *pnp, struct pathname *rpnp,
184794f0adbSRoger A. Faulkner     int followlink, vnode_t **dirvpp, vnode_t **compvpp,
1857a142be9SCasper H.S. Dik     vnode_t *startvp)
1867a142be9SCasper H.S. Dik {
1877a142be9SCasper H.S. Dik 	return (lookuppnatcred(pnp, rpnp, followlink, dirvpp, compvpp, startvp,
1887a142be9SCasper H.S. Dik 	    CRED()));
1897c478bd9Sstevel@tonic-gate }
1907c478bd9Sstevel@tonic-gate 
1917c478bd9Sstevel@tonic-gate /* Private flag to do our getcwd() dirty work */
1927c478bd9Sstevel@tonic-gate #define	LOOKUP_CHECKREAD	0x10
1937c478bd9Sstevel@tonic-gate #define	LOOKUP_MASK		(~LOOKUP_CHECKREAD)
1947c478bd9Sstevel@tonic-gate 
1957c478bd9Sstevel@tonic-gate /*
1967c478bd9Sstevel@tonic-gate  * Starting at current directory, translate pathname pnp to end.
1977c478bd9Sstevel@tonic-gate  * Leave pathname of final component in pnp, return the vnode
1987c478bd9Sstevel@tonic-gate  * for the final component in *compvpp, and return the vnode
1997c478bd9Sstevel@tonic-gate  * for the parent of the final component in dirvpp.
2007c478bd9Sstevel@tonic-gate  *
2017c478bd9Sstevel@tonic-gate  * This is the central routine in pathname translation and handles
2027c478bd9Sstevel@tonic-gate  * multiple components in pathnames, separating them at /'s.  It also
2037c478bd9Sstevel@tonic-gate  * implements mounted file systems and processes symbolic links.
2047c478bd9Sstevel@tonic-gate  *
2057c478bd9Sstevel@tonic-gate  * vp is the vnode where the directory search should start.
2067c478bd9Sstevel@tonic-gate  *
2077c478bd9Sstevel@tonic-gate  * Reference counts: vp must be held prior to calling this function.  rootvp
2087c478bd9Sstevel@tonic-gate  * should only be held if rootvp != rootdir.
2097c478bd9Sstevel@tonic-gate  */
2107c478bd9Sstevel@tonic-gate int
lookuppnvp(struct pathname * pnp,struct pathname * rpnp,int flags,vnode_t ** dirvpp,vnode_t ** compvpp,vnode_t * rootvp,vnode_t * vp,cred_t * cr)2117c478bd9Sstevel@tonic-gate lookuppnvp(
2127c478bd9Sstevel@tonic-gate 	struct pathname *pnp,		/* pathname to lookup */
2137c478bd9Sstevel@tonic-gate 	struct pathname *rpnp,		/* if non-NULL, return resolved path */
2147c478bd9Sstevel@tonic-gate 	int flags,			/* follow symlinks */
2157c478bd9Sstevel@tonic-gate 	vnode_t **dirvpp,		/* ptr for parent vnode */
2167c478bd9Sstevel@tonic-gate 	vnode_t **compvpp,		/* ptr for entry vnode */
2177c478bd9Sstevel@tonic-gate 	vnode_t *rootvp,		/* rootvp */
2187c478bd9Sstevel@tonic-gate 	vnode_t *vp,			/* directory to start search at */
2197c478bd9Sstevel@tonic-gate 	cred_t *cr)			/* user's credential */
2207c478bd9Sstevel@tonic-gate {
2217c478bd9Sstevel@tonic-gate 	vnode_t *cvp;	/* current component vp */
2227c478bd9Sstevel@tonic-gate 	char component[MAXNAMELEN];	/* buffer for component (incl null) */
2237c478bd9Sstevel@tonic-gate 	int error;
2247c478bd9Sstevel@tonic-gate 	int nlink;
2257c478bd9Sstevel@tonic-gate 	int lookup_flags;
226da6c28aaSamw 	struct pathname presrvd; /* case preserved name */
227da6c28aaSamw 	struct pathname *pp = NULL;
2287c478bd9Sstevel@tonic-gate 	vnode_t *startvp;
2297c478bd9Sstevel@tonic-gate 	vnode_t *zonevp = curproc->p_zone->zone_rootvp;		/* zone root */
2307c478bd9Sstevel@tonic-gate 	int must_be_directory = 0;
23153ebc32aSVallish Vaidyeshwara 	boolean_t retry_with_kcred;
232005d3febSMarek Pospisil 	uint32_t auditing = AU_AUDITING();
2337c478bd9Sstevel@tonic-gate 
2347c478bd9Sstevel@tonic-gate 	CPU_STATS_ADDQ(CPU, sys, namei, 1);
2357c478bd9Sstevel@tonic-gate 	nlink = 0;
2367c478bd9Sstevel@tonic-gate 	cvp = NULL;
2377c478bd9Sstevel@tonic-gate 	if (rpnp)
2387c478bd9Sstevel@tonic-gate 		rpnp->pn_pathlen = 0;
239da6c28aaSamw 
2407c478bd9Sstevel@tonic-gate 	lookup_flags = dirvpp ? LOOKUP_DIR : 0;
241da6c28aaSamw 	if (flags & FIGNORECASE) {
242da6c28aaSamw 		lookup_flags |= FIGNORECASE;
243da6c28aaSamw 		pn_alloc(&presrvd);
244da6c28aaSamw 		pp = &presrvd;
245da6c28aaSamw 	}
246da6c28aaSamw 
247005d3febSMarek Pospisil 	if (auditing)
2487c478bd9Sstevel@tonic-gate 		audit_anchorpath(pnp, vp == rootvp);
2497c478bd9Sstevel@tonic-gate 
2507c478bd9Sstevel@tonic-gate 	/*
2517c478bd9Sstevel@tonic-gate 	 * Eliminate any trailing slashes in the pathname.
2527c478bd9Sstevel@tonic-gate 	 * If there are any, we must follow all symlinks.
2537c478bd9Sstevel@tonic-gate 	 * Also, we must guarantee that the last component is a directory.
2547c478bd9Sstevel@tonic-gate 	 */
2557c478bd9Sstevel@tonic-gate 	if (pn_fixslash(pnp)) {
2567c478bd9Sstevel@tonic-gate 		flags |= FOLLOW;
2577c478bd9Sstevel@tonic-gate 		must_be_directory = 1;
2587c478bd9Sstevel@tonic-gate 	}
2597c478bd9Sstevel@tonic-gate 
2607c478bd9Sstevel@tonic-gate 	startvp = vp;
2617c478bd9Sstevel@tonic-gate next:
26253ebc32aSVallish Vaidyeshwara 	retry_with_kcred = B_FALSE;
26353ebc32aSVallish Vaidyeshwara 
2647c478bd9Sstevel@tonic-gate 	/*
2657c478bd9Sstevel@tonic-gate 	 * Make sure we have a directory.
2667c478bd9Sstevel@tonic-gate 	 */
2677c478bd9Sstevel@tonic-gate 	if (vp->v_type != VDIR) {
2687c478bd9Sstevel@tonic-gate 		error = ENOTDIR;
2697c478bd9Sstevel@tonic-gate 		goto bad;
2707c478bd9Sstevel@tonic-gate 	}
2717c478bd9Sstevel@tonic-gate 
2727c478bd9Sstevel@tonic-gate 	if (rpnp && VN_CMP(vp, rootvp))
2737c478bd9Sstevel@tonic-gate 		(void) pn_set(rpnp, "/");
2747c478bd9Sstevel@tonic-gate 
2757c478bd9Sstevel@tonic-gate 	/*
2767c478bd9Sstevel@tonic-gate 	 * Process the next component of the pathname.
2777c478bd9Sstevel@tonic-gate 	 */
2787c478bd9Sstevel@tonic-gate 	if (error = pn_getcomponent(pnp, component)) {
2797c478bd9Sstevel@tonic-gate 		goto bad;
2807c478bd9Sstevel@tonic-gate 	}
2817c478bd9Sstevel@tonic-gate 
2827c478bd9Sstevel@tonic-gate 	/*
2837c478bd9Sstevel@tonic-gate 	 * Handle "..": two special cases.
2847c478bd9Sstevel@tonic-gate 	 * 1. If we're at the root directory (e.g. after chroot or
2857c478bd9Sstevel@tonic-gate 	 *    zone_enter) then change ".." to "." so we can't get
2867c478bd9Sstevel@tonic-gate 	 *    out of this subtree.
2877c478bd9Sstevel@tonic-gate 	 * 2. If this vnode is the root of a mounted file system,
2887c478bd9Sstevel@tonic-gate 	 *    then replace it with the vnode that was mounted on
2897c478bd9Sstevel@tonic-gate 	 *    so that we take the ".." in the other file system.
2907c478bd9Sstevel@tonic-gate 	 */
2917c478bd9Sstevel@tonic-gate 	if (component[0] == '.' && component[1] == '.' && component[2] == 0) {
2927c478bd9Sstevel@tonic-gate checkforroot:
2937c478bd9Sstevel@tonic-gate 		if (VN_CMP(vp, rootvp) || VN_CMP(vp, zonevp)) {
2947c478bd9Sstevel@tonic-gate 			component[1] = '\0';
2957c478bd9Sstevel@tonic-gate 		} else if (vp->v_flag & VROOT) {
2967c478bd9Sstevel@tonic-gate 			vfs_t *vfsp;
2977c478bd9Sstevel@tonic-gate 			cvp = vp;
2987c478bd9Sstevel@tonic-gate 
2997c478bd9Sstevel@tonic-gate 			/*
3007c478bd9Sstevel@tonic-gate 			 * While we deal with the vfs pointer from the vnode
3017c478bd9Sstevel@tonic-gate 			 * the filesystem could have been forcefully unmounted
3027c478bd9Sstevel@tonic-gate 			 * and the vnode's v_vfsp could have been invalidated
3037c478bd9Sstevel@tonic-gate 			 * by VFS_UNMOUNT. Hence, we cache v_vfsp and use it
3047c478bd9Sstevel@tonic-gate 			 * with vfs_rlock_wait/vfs_unlock.
3057c478bd9Sstevel@tonic-gate 			 * It is safe to use the v_vfsp even it is freed by
3067c478bd9Sstevel@tonic-gate 			 * VFS_UNMOUNT because vfs_rlock_wait/vfs_unlock
3077c478bd9Sstevel@tonic-gate 			 * do not dereference v_vfsp. It is just used as a
3087c478bd9Sstevel@tonic-gate 			 * magic cookie.
3097c478bd9Sstevel@tonic-gate 			 * One more corner case here is the memory getting
3107c478bd9Sstevel@tonic-gate 			 * reused for another vfs structure. In this case
3117c478bd9Sstevel@tonic-gate 			 * lookuppnvp's vfs_rlock_wait will succeed, domount's
3127c478bd9Sstevel@tonic-gate 			 * vfs_lock will fail and domount will bail out with an
3137c478bd9Sstevel@tonic-gate 			 * error (EBUSY).
3147c478bd9Sstevel@tonic-gate 			 */
3157c478bd9Sstevel@tonic-gate 			vfsp = cvp->v_vfsp;
3167c478bd9Sstevel@tonic-gate 
3177c478bd9Sstevel@tonic-gate 			/*
3187c478bd9Sstevel@tonic-gate 			 * This lock is used to synchronize
3197c478bd9Sstevel@tonic-gate 			 * mounts/unmounts and lookups.
3207c478bd9Sstevel@tonic-gate 			 * Threads doing mounts/unmounts hold the
3217c478bd9Sstevel@tonic-gate 			 * writers version vfs_lock_wait().
3227c478bd9Sstevel@tonic-gate 			 */
3237c478bd9Sstevel@tonic-gate 
3247c478bd9Sstevel@tonic-gate 			vfs_rlock_wait(vfsp);
3257c478bd9Sstevel@tonic-gate 
3267c478bd9Sstevel@tonic-gate 			/*
3277c478bd9Sstevel@tonic-gate 			 * If this vnode is on a file system that
3287c478bd9Sstevel@tonic-gate 			 * has been forcibly unmounted,
3297c478bd9Sstevel@tonic-gate 			 * we can't proceed. Cancel this operation
3307c478bd9Sstevel@tonic-gate 			 * and return EIO.
3317c478bd9Sstevel@tonic-gate 			 *
3327c478bd9Sstevel@tonic-gate 			 * vfs_vnodecovered is NULL if unmounted.
3337c478bd9Sstevel@tonic-gate 			 * Currently, nfs uses VFS_UNMOUNTED to
3347c478bd9Sstevel@tonic-gate 			 * check if it's a forced-umount. Keep the
3357c478bd9Sstevel@tonic-gate 			 * same checking here as well even though it
3367c478bd9Sstevel@tonic-gate 			 * may not be needed.
3377c478bd9Sstevel@tonic-gate 			 */
3387c478bd9Sstevel@tonic-gate 			if (((vp = cvp->v_vfsp->vfs_vnodecovered) == NULL) ||
3397c478bd9Sstevel@tonic-gate 			    (cvp->v_vfsp->vfs_flag & VFS_UNMOUNTED)) {
3407c478bd9Sstevel@tonic-gate 				vfs_unlock(vfsp);
3417c478bd9Sstevel@tonic-gate 				VN_RELE(cvp);
342da6c28aaSamw 				if (pp)
343da6c28aaSamw 					pn_free(pp);
3447c478bd9Sstevel@tonic-gate 				return (EIO);
3457c478bd9Sstevel@tonic-gate 			}
3467c478bd9Sstevel@tonic-gate 			VN_HOLD(vp);
3477c478bd9Sstevel@tonic-gate 			vfs_unlock(vfsp);
3487c478bd9Sstevel@tonic-gate 			VN_RELE(cvp);
3497c478bd9Sstevel@tonic-gate 			cvp = NULL;
3502e538c1cSvv 			/*
3512e538c1cSvv 			 * Crossing mount points. For eg: We are doing
3522e538c1cSvv 			 * a lookup of ".." for file systems root vnode
3532e538c1cSvv 			 * mounted here, and VOP_LOOKUP() (with covered vnode)
3542e538c1cSvv 			 * will be on underlying file systems mount point
3552e538c1cSvv 			 * vnode. Set retry_with_kcred flag as we might end
3562e538c1cSvv 			 * up doing VOP_LOOKUP() with kcred if required.
3572e538c1cSvv 			 */
3582e538c1cSvv 			retry_with_kcred = B_TRUE;
3597c478bd9Sstevel@tonic-gate 			goto checkforroot;
3607c478bd9Sstevel@tonic-gate 		}
3617c478bd9Sstevel@tonic-gate 	}
3627c478bd9Sstevel@tonic-gate 
3637c478bd9Sstevel@tonic-gate 	/*
3647c478bd9Sstevel@tonic-gate 	 * LOOKUP_CHECKREAD is a private flag used by vnodetopath() to indicate
3657c478bd9Sstevel@tonic-gate 	 * that we need to have read permission on every directory in the entire
3667c478bd9Sstevel@tonic-gate 	 * path.  This is used to ensure that a forward-lookup of a cached value
3677c478bd9Sstevel@tonic-gate 	 * has the same effect as a reverse-lookup when the cached value cannot
3687c478bd9Sstevel@tonic-gate 	 * be found.
3697c478bd9Sstevel@tonic-gate 	 */
3707c478bd9Sstevel@tonic-gate 	if ((flags & LOOKUP_CHECKREAD) &&
371da6c28aaSamw 	    (error = VOP_ACCESS(vp, VREAD, 0, cr, NULL)) != 0)
3727c478bd9Sstevel@tonic-gate 		goto bad;
3737c478bd9Sstevel@tonic-gate 
3747c478bd9Sstevel@tonic-gate 	/*
3757c478bd9Sstevel@tonic-gate 	 * Perform a lookup in the current directory.
3767c478bd9Sstevel@tonic-gate 	 */
3776e062f4aSMarcel Telka 	error = VOP_LOOKUP(vp, component, &cvp, pnp, lookup_flags,
378da6c28aaSamw 	    rootvp, cr, NULL, NULL, pp);
3792e538c1cSvv 
3802e538c1cSvv 	/*
3812e538c1cSvv 	 * Retry with kcred - If crossing mount points & error is EACCES.
3822e538c1cSvv 	 *
3832e538c1cSvv 	 * If we are crossing mount points here and doing ".." lookup,
3842e538c1cSvv 	 * VOP_LOOKUP() might fail if the underlying file systems
3852e538c1cSvv 	 * mount point has no execute permission. In cases like these,
3862e538c1cSvv 	 * we retry VOP_LOOKUP() by giving as much privilage as possible
3872e538c1cSvv 	 * by passing kcred credentials.
3882e538c1cSvv 	 *
3892e538c1cSvv 	 * In case of hierarchical file systems, passing kcred still may
3902e538c1cSvv 	 * or may not work.
3912e538c1cSvv 	 * For eg: UFS FS --> Mount NFS FS --> Again mount UFS on some
3922e538c1cSvv 	 *			directory inside NFS FS.
3932e538c1cSvv 	 */
3942e538c1cSvv 	if ((error == EACCES) && retry_with_kcred)
3956e062f4aSMarcel Telka 		error = VOP_LOOKUP(vp, component, &cvp, pnp, lookup_flags,
396da6c28aaSamw 		    rootvp, zone_kcred(), NULL, NULL, pp);
3972e538c1cSvv 
3987c478bd9Sstevel@tonic-gate 	if (error) {
3997c478bd9Sstevel@tonic-gate 		cvp = NULL;
4007c478bd9Sstevel@tonic-gate 		/*
4017c478bd9Sstevel@tonic-gate 		 * On error, return hard error if
4027c478bd9Sstevel@tonic-gate 		 * (a) we're not at the end of the pathname yet, or
4037c478bd9Sstevel@tonic-gate 		 * (b) the caller didn't want the parent directory, or
4047c478bd9Sstevel@tonic-gate 		 * (c) we failed for some reason other than a missing entry.
4057c478bd9Sstevel@tonic-gate 		 */
4067c478bd9Sstevel@tonic-gate 		if (pn_pathleft(pnp) || dirvpp == NULL || error != ENOENT)
4077c478bd9Sstevel@tonic-gate 			goto bad;
408005d3febSMarek Pospisil 		if (auditing) {	/* directory access */
4094a0fa546SMarek Pospisil 			if (error = audit_savepath(pnp, vp, vp, error, cr))
4107c478bd9Sstevel@tonic-gate 				goto bad_noaudit;
4117c478bd9Sstevel@tonic-gate 		}
4124a0fa546SMarek Pospisil 
4137c478bd9Sstevel@tonic-gate 		pn_setlast(pnp);
4147c478bd9Sstevel@tonic-gate 		/*
4157c478bd9Sstevel@tonic-gate 		 * We inform the caller that the desired entry must be
4167c478bd9Sstevel@tonic-gate 		 * a directory by adding a '/' to the component name.
4177c478bd9Sstevel@tonic-gate 		 */
4187c478bd9Sstevel@tonic-gate 		if (must_be_directory && (error = pn_addslash(pnp)) != 0)
4197c478bd9Sstevel@tonic-gate 			goto bad;
4207c478bd9Sstevel@tonic-gate 		*dirvpp = vp;
4217c478bd9Sstevel@tonic-gate 		if (compvpp != NULL)
4227c478bd9Sstevel@tonic-gate 			*compvpp = NULL;
4237c478bd9Sstevel@tonic-gate 		if (rootvp != rootdir)
4247c478bd9Sstevel@tonic-gate 			VN_RELE(rootvp);
425da6c28aaSamw 		if (pp)
426da6c28aaSamw 			pn_free(pp);
4277c478bd9Sstevel@tonic-gate 		return (0);
4287c478bd9Sstevel@tonic-gate 	}
4297c478bd9Sstevel@tonic-gate 
4307c478bd9Sstevel@tonic-gate 	/*
4317c478bd9Sstevel@tonic-gate 	 * Traverse mount points.
4327c478bd9Sstevel@tonic-gate 	 * XXX why don't we need to hold a read lock here (call vn_vfsrlock)?
4337c478bd9Sstevel@tonic-gate 	 * What prevents a concurrent update to v_vfsmountedhere?
4347c478bd9Sstevel@tonic-gate 	 * 	Possible answer: if mounting, we might not see the mount
4357c478bd9Sstevel@tonic-gate 	 *	if it is concurrently coming into existence, but that's
4367c478bd9Sstevel@tonic-gate 	 *	really not much different from the thread running a bit slower.
4377c478bd9Sstevel@tonic-gate 	 *	If unmounting, we may get into traverse() when we shouldn't,
4387c478bd9Sstevel@tonic-gate 	 *	but traverse() will catch this case for us.
4397c478bd9Sstevel@tonic-gate 	 *	(For this to work, fetching v_vfsmountedhere had better
4407c478bd9Sstevel@tonic-gate 	 *	be atomic!)
4417c478bd9Sstevel@tonic-gate 	 */
4427c478bd9Sstevel@tonic-gate 	if (vn_mountedvfs(cvp) != NULL) {
4436e062f4aSMarcel Telka 		if ((error = traverse(&cvp)) != 0)
4447c478bd9Sstevel@tonic-gate 			goto bad;
4457c478bd9Sstevel@tonic-gate 	}
4467c478bd9Sstevel@tonic-gate 
4477c478bd9Sstevel@tonic-gate 	/*
4487c478bd9Sstevel@tonic-gate 	 * If we hit a symbolic link and there is more path to be
4497c478bd9Sstevel@tonic-gate 	 * translated or this operation does not wish to apply
4507c478bd9Sstevel@tonic-gate 	 * to a link, then place the contents of the link at the
4517c478bd9Sstevel@tonic-gate 	 * front of the remaining pathname.
4527c478bd9Sstevel@tonic-gate 	 */
4537c478bd9Sstevel@tonic-gate 	if (cvp->v_type == VLNK && ((flags & FOLLOW) || pn_pathleft(pnp))) {
4547c478bd9Sstevel@tonic-gate 		struct pathname linkpath;
4557c478bd9Sstevel@tonic-gate 
4567c478bd9Sstevel@tonic-gate 		if (++nlink > MAXSYMLINKS) {
4577c478bd9Sstevel@tonic-gate 			error = ELOOP;
4587c478bd9Sstevel@tonic-gate 			goto bad;
4597c478bd9Sstevel@tonic-gate 		}
4607c478bd9Sstevel@tonic-gate 		pn_alloc(&linkpath);
4617c478bd9Sstevel@tonic-gate 		if (error = pn_getsymlink(cvp, &linkpath, cr)) {
4627c478bd9Sstevel@tonic-gate 			pn_free(&linkpath);
4637c478bd9Sstevel@tonic-gate 			goto bad;
4647c478bd9Sstevel@tonic-gate 		}
4657c478bd9Sstevel@tonic-gate 
466005d3febSMarek Pospisil 		if (auditing)
4677c478bd9Sstevel@tonic-gate 			audit_symlink(pnp, &linkpath);
4687c478bd9Sstevel@tonic-gate 
4697c478bd9Sstevel@tonic-gate 		if (pn_pathleft(&linkpath) == 0)
4707c478bd9Sstevel@tonic-gate 			(void) pn_set(&linkpath, ".");
4717c478bd9Sstevel@tonic-gate 		error = pn_insert(pnp, &linkpath, strlen(component));
4727c478bd9Sstevel@tonic-gate 		pn_free(&linkpath);
4737c478bd9Sstevel@tonic-gate 		if (error)
4747c478bd9Sstevel@tonic-gate 			goto bad;
4757c478bd9Sstevel@tonic-gate 		VN_RELE(cvp);
4767c478bd9Sstevel@tonic-gate 		cvp = NULL;
4777c478bd9Sstevel@tonic-gate 		if (pnp->pn_pathlen == 0) {
4787c478bd9Sstevel@tonic-gate 			error = ENOENT;
4797c478bd9Sstevel@tonic-gate 			goto bad;
4807c478bd9Sstevel@tonic-gate 		}
4817c478bd9Sstevel@tonic-gate 		if (pnp->pn_path[0] == '/') {
4827c478bd9Sstevel@tonic-gate 			do {
4837c478bd9Sstevel@tonic-gate 				pnp->pn_path++;
4847c478bd9Sstevel@tonic-gate 				pnp->pn_pathlen--;
4857c478bd9Sstevel@tonic-gate 			} while (pnp->pn_path[0] == '/');
4867c478bd9Sstevel@tonic-gate 			VN_RELE(vp);
4877c478bd9Sstevel@tonic-gate 			vp = rootvp;
4887c478bd9Sstevel@tonic-gate 			VN_HOLD(vp);
4897c478bd9Sstevel@tonic-gate 		}
490005d3febSMarek Pospisil 		if (auditing)
4917c478bd9Sstevel@tonic-gate 			audit_anchorpath(pnp, vp == rootvp);
4927c478bd9Sstevel@tonic-gate 		if (pn_fixslash(pnp)) {
4937c478bd9Sstevel@tonic-gate 			flags |= FOLLOW;
4947c478bd9Sstevel@tonic-gate 			must_be_directory = 1;
4957c478bd9Sstevel@tonic-gate 		}
4967c478bd9Sstevel@tonic-gate 		goto next;
4977c478bd9Sstevel@tonic-gate 	}
4987c478bd9Sstevel@tonic-gate 
4997c478bd9Sstevel@tonic-gate 	/*
5007c478bd9Sstevel@tonic-gate 	 * If rpnp is non-NULL, remember the resolved path name therein.
5017c478bd9Sstevel@tonic-gate 	 * Do not include "." components.  Collapse occurrences of
5027c478bd9Sstevel@tonic-gate 	 * "previous/..", so long as "previous" is not itself "..".
5037c478bd9Sstevel@tonic-gate 	 * Exhausting rpnp results in error ENAMETOOLONG.
5047c478bd9Sstevel@tonic-gate 	 */
5057c478bd9Sstevel@tonic-gate 	if (rpnp && strcmp(component, ".") != 0) {
5067c478bd9Sstevel@tonic-gate 		size_t len;
5077c478bd9Sstevel@tonic-gate 
5087c478bd9Sstevel@tonic-gate 		if (strcmp(component, "..") == 0 &&
5097c478bd9Sstevel@tonic-gate 		    rpnp->pn_pathlen != 0 &&
5107c478bd9Sstevel@tonic-gate 		    !((rpnp->pn_pathlen > 2 &&
5117c478bd9Sstevel@tonic-gate 		    strncmp(rpnp->pn_path+rpnp->pn_pathlen-3, "/..", 3) == 0) ||
5127c478bd9Sstevel@tonic-gate 		    (rpnp->pn_pathlen == 2 &&
5137c478bd9Sstevel@tonic-gate 		    strncmp(rpnp->pn_path, "..", 2) == 0))) {
5147c478bd9Sstevel@tonic-gate 			while (rpnp->pn_pathlen &&
5157c478bd9Sstevel@tonic-gate 			    rpnp->pn_path[rpnp->pn_pathlen-1] != '/')
5167c478bd9Sstevel@tonic-gate 				rpnp->pn_pathlen--;
5177c478bd9Sstevel@tonic-gate 			if (rpnp->pn_pathlen > 1)
5187c478bd9Sstevel@tonic-gate 				rpnp->pn_pathlen--;
5197c478bd9Sstevel@tonic-gate 			rpnp->pn_path[rpnp->pn_pathlen] = '\0';
5207c478bd9Sstevel@tonic-gate 		} else {
5217c478bd9Sstevel@tonic-gate 			if (rpnp->pn_pathlen != 0 &&
5227c478bd9Sstevel@tonic-gate 			    rpnp->pn_path[rpnp->pn_pathlen-1] != '/')
5237c478bd9Sstevel@tonic-gate 				rpnp->pn_path[rpnp->pn_pathlen++] = '/';
524da6c28aaSamw 			if (flags & FIGNORECASE) {
525da6c28aaSamw 				/*
526da6c28aaSamw 				 * Return the case-preserved name
527da6c28aaSamw 				 * within the resolved path.
528da6c28aaSamw 				 */
529ab04eb8eStimh 				error = copystr(pp->pn_buf,
530da6c28aaSamw 				    rpnp->pn_path + rpnp->pn_pathlen,
531da6c28aaSamw 				    rpnp->pn_bufsize - rpnp->pn_pathlen, &len);
532da6c28aaSamw 			} else {
533da6c28aaSamw 				error = copystr(component,
534da6c28aaSamw 				    rpnp->pn_path + rpnp->pn_pathlen,
535da6c28aaSamw 				    rpnp->pn_bufsize - rpnp->pn_pathlen, &len);
536da6c28aaSamw 			}
5377c478bd9Sstevel@tonic-gate 			if (error)	/* copystr() returns ENAMETOOLONG */
5387c478bd9Sstevel@tonic-gate 				goto bad;
5397c478bd9Sstevel@tonic-gate 			rpnp->pn_pathlen += (len - 1);
5407c478bd9Sstevel@tonic-gate 			ASSERT(rpnp->pn_bufsize > rpnp->pn_pathlen);
5417c478bd9Sstevel@tonic-gate 		}
5427c478bd9Sstevel@tonic-gate 	}
5437c478bd9Sstevel@tonic-gate 
5447c478bd9Sstevel@tonic-gate 	/*
5457c478bd9Sstevel@tonic-gate 	 * If no more components, return last directory (if wanted) and
5467c478bd9Sstevel@tonic-gate 	 * last component (if wanted).
5477c478bd9Sstevel@tonic-gate 	 */
5487c478bd9Sstevel@tonic-gate 	if (pn_pathleft(pnp) == 0) {
5497c478bd9Sstevel@tonic-gate 		/*
5507c478bd9Sstevel@tonic-gate 		 * If there was a trailing slash in the pathname,
5517c478bd9Sstevel@tonic-gate 		 * make sure the last component is a directory.
5527c478bd9Sstevel@tonic-gate 		 */
5537c478bd9Sstevel@tonic-gate 		if (must_be_directory && cvp->v_type != VDIR) {
5547c478bd9Sstevel@tonic-gate 			error = ENOTDIR;
5557c478bd9Sstevel@tonic-gate 			goto bad;
5567c478bd9Sstevel@tonic-gate 		}
5577c478bd9Sstevel@tonic-gate 		if (dirvpp != NULL) {
5587c478bd9Sstevel@tonic-gate 			/*
5597c478bd9Sstevel@tonic-gate 			 * Check that we have the real parent and not
5607c478bd9Sstevel@tonic-gate 			 * an alias of the last component.
5617c478bd9Sstevel@tonic-gate 			 */
5627c478bd9Sstevel@tonic-gate 			if (vn_compare(vp, cvp)) {
563005d3febSMarek Pospisil 				if (auditing)
5644a0fa546SMarek Pospisil 					(void) audit_savepath(pnp, cvp, vp,
5652e538c1cSvv 					    EINVAL, cr);
5667c478bd9Sstevel@tonic-gate 				pn_setlast(pnp);
5677c478bd9Sstevel@tonic-gate 				VN_RELE(vp);
5687c478bd9Sstevel@tonic-gate 				VN_RELE(cvp);
5697c478bd9Sstevel@tonic-gate 				if (rootvp != rootdir)
5707c478bd9Sstevel@tonic-gate 					VN_RELE(rootvp);
571da6c28aaSamw 				if (pp)
572da6c28aaSamw 					pn_free(pp);
5737c478bd9Sstevel@tonic-gate 				return (EINVAL);
5747c478bd9Sstevel@tonic-gate 			}
5757c478bd9Sstevel@tonic-gate 			*dirvpp = vp;
5767c478bd9Sstevel@tonic-gate 		} else
5777c478bd9Sstevel@tonic-gate 			VN_RELE(vp);
578005d3febSMarek Pospisil 		if (auditing)
5794a0fa546SMarek Pospisil 			(void) audit_savepath(pnp, cvp, vp, 0, cr);
5807c478bd9Sstevel@tonic-gate 		if (pnp->pn_path == pnp->pn_buf)
5817c478bd9Sstevel@tonic-gate 			(void) pn_set(pnp, ".");
5827c478bd9Sstevel@tonic-gate 		else
5837c478bd9Sstevel@tonic-gate 			pn_setlast(pnp);
5847c478bd9Sstevel@tonic-gate 		if (rpnp) {
5857c478bd9Sstevel@tonic-gate 			if (VN_CMP(cvp, rootvp))
5867c478bd9Sstevel@tonic-gate 				(void) pn_set(rpnp, "/");
5877c478bd9Sstevel@tonic-gate 			else if (rpnp->pn_pathlen == 0)
5887c478bd9Sstevel@tonic-gate 				(void) pn_set(rpnp, ".");
5897c478bd9Sstevel@tonic-gate 		}
5907c478bd9Sstevel@tonic-gate 
5917c478bd9Sstevel@tonic-gate 		if (compvpp != NULL)
5927c478bd9Sstevel@tonic-gate 			*compvpp = cvp;
5937c478bd9Sstevel@tonic-gate 		else
5947c478bd9Sstevel@tonic-gate 			VN_RELE(cvp);
5957c478bd9Sstevel@tonic-gate 		if (rootvp != rootdir)
5967c478bd9Sstevel@tonic-gate 			VN_RELE(rootvp);
597da6c28aaSamw 		if (pp)
598da6c28aaSamw 			pn_free(pp);
5997c478bd9Sstevel@tonic-gate 		return (0);
6007c478bd9Sstevel@tonic-gate 	}
6017c478bd9Sstevel@tonic-gate 
6027c478bd9Sstevel@tonic-gate 	/*
6037c478bd9Sstevel@tonic-gate 	 * Skip over slashes from end of last component.
6047c478bd9Sstevel@tonic-gate 	 */
6057c478bd9Sstevel@tonic-gate 	while (pnp->pn_path[0] == '/') {
6067c478bd9Sstevel@tonic-gate 		pnp->pn_path++;
6077c478bd9Sstevel@tonic-gate 		pnp->pn_pathlen--;
6087c478bd9Sstevel@tonic-gate 	}
6097c478bd9Sstevel@tonic-gate 
6107c478bd9Sstevel@tonic-gate 	/*
6117c478bd9Sstevel@tonic-gate 	 * Searched through another level of directory:
6127c478bd9Sstevel@tonic-gate 	 * release previous directory handle and save new (result
6137c478bd9Sstevel@tonic-gate 	 * of lookup) as current directory.
6147c478bd9Sstevel@tonic-gate 	 */
6157c478bd9Sstevel@tonic-gate 	VN_RELE(vp);
6167c478bd9Sstevel@tonic-gate 	vp = cvp;
6177c478bd9Sstevel@tonic-gate 	cvp = NULL;
6187c478bd9Sstevel@tonic-gate 	goto next;
6197c478bd9Sstevel@tonic-gate 
6207c478bd9Sstevel@tonic-gate bad:
621005d3febSMarek Pospisil 	if (auditing)	/* reached end of path */
6224a0fa546SMarek Pospisil 		(void) audit_savepath(pnp, cvp, vp, error, cr);
6237c478bd9Sstevel@tonic-gate bad_noaudit:
6247c478bd9Sstevel@tonic-gate 	/*
6257c478bd9Sstevel@tonic-gate 	 * Error.  Release vnodes and return.
6267c478bd9Sstevel@tonic-gate 	 */
6277c478bd9Sstevel@tonic-gate 	if (cvp)
6287c478bd9Sstevel@tonic-gate 		VN_RELE(cvp);
6297c478bd9Sstevel@tonic-gate 	/*
6307c478bd9Sstevel@tonic-gate 	 * If the error was ESTALE and the current directory to look in
6317c478bd9Sstevel@tonic-gate 	 * was the root for this lookup, the root for a mounted file
6327c478bd9Sstevel@tonic-gate 	 * system, or the starting directory for lookups, then
6337c478bd9Sstevel@tonic-gate 	 * return ENOENT instead of ESTALE.  In this case, no recovery
6347c478bd9Sstevel@tonic-gate 	 * is possible by the higher level.  If ESTALE was returned for
6357c478bd9Sstevel@tonic-gate 	 * some intermediate directory along the path, then recovery
6367c478bd9Sstevel@tonic-gate 	 * is potentially possible and retrying from the higher level
6377c478bd9Sstevel@tonic-gate 	 * will either correct the situation by purging stale cache
6387c478bd9Sstevel@tonic-gate 	 * entries or eventually get back to the point where no recovery
6397c478bd9Sstevel@tonic-gate 	 * is possible.
6407c478bd9Sstevel@tonic-gate 	 */
6417c478bd9Sstevel@tonic-gate 	if (error == ESTALE &&
6427c478bd9Sstevel@tonic-gate 	    (VN_CMP(vp, rootvp) || (vp->v_flag & VROOT) || vp == startvp))
6437c478bd9Sstevel@tonic-gate 		error = ENOENT;
6447c478bd9Sstevel@tonic-gate 	VN_RELE(vp);
6457c478bd9Sstevel@tonic-gate 	if (rootvp != rootdir)
6467c478bd9Sstevel@tonic-gate 		VN_RELE(rootvp);
647da6c28aaSamw 	if (pp)
648da6c28aaSamw 		pn_free(pp);
6497c478bd9Sstevel@tonic-gate 	return (error);
6507c478bd9Sstevel@tonic-gate }
6517c478bd9Sstevel@tonic-gate 
6527c478bd9Sstevel@tonic-gate /*
6537c478bd9Sstevel@tonic-gate  * Traverse a mount point.  Routine accepts a vnode pointer as a reference
6547c478bd9Sstevel@tonic-gate  * parameter and performs the indirection, releasing the original vnode.
6557c478bd9Sstevel@tonic-gate  */
6567c478bd9Sstevel@tonic-gate int
traverse(vnode_t ** cvpp)6577c478bd9Sstevel@tonic-gate traverse(vnode_t **cvpp)
6587c478bd9Sstevel@tonic-gate {
6597c478bd9Sstevel@tonic-gate 	int error = 0;
6607c478bd9Sstevel@tonic-gate 	vnode_t *cvp;
6617c478bd9Sstevel@tonic-gate 	vnode_t *tvp;
6627c478bd9Sstevel@tonic-gate 	vfs_t *vfsp;
6637c478bd9Sstevel@tonic-gate 
6647c478bd9Sstevel@tonic-gate 	cvp = *cvpp;
6657c478bd9Sstevel@tonic-gate 
6667c478bd9Sstevel@tonic-gate 	/*
6677c478bd9Sstevel@tonic-gate 	 * If this vnode is mounted on, then we transparently indirect
6687c478bd9Sstevel@tonic-gate 	 * to the vnode which is the root of the mounted file system.
6697c478bd9Sstevel@tonic-gate 	 * Before we do this we must check that an unmount is not in
6707c478bd9Sstevel@tonic-gate 	 * progress on this vnode.
6717c478bd9Sstevel@tonic-gate 	 */
6727c478bd9Sstevel@tonic-gate 
6737c478bd9Sstevel@tonic-gate 	for (;;) {
6747c478bd9Sstevel@tonic-gate 		/*
6757c478bd9Sstevel@tonic-gate 		 * Try to read lock the vnode.  If this fails because
6767c478bd9Sstevel@tonic-gate 		 * the vnode is already write locked, then check to
6777c478bd9Sstevel@tonic-gate 		 * see whether it is the current thread which locked
6787c478bd9Sstevel@tonic-gate 		 * the vnode.  If it is not, then read lock the vnode
6797c478bd9Sstevel@tonic-gate 		 * by waiting to acquire the lock.
6807c478bd9Sstevel@tonic-gate 		 *
6817c478bd9Sstevel@tonic-gate 		 * The code path in domount() is an example of support
6827c478bd9Sstevel@tonic-gate 		 * which needs to look up two pathnames and locks one
6837c478bd9Sstevel@tonic-gate 		 * of them in between the two lookups.
6847c478bd9Sstevel@tonic-gate 		 */
6857c478bd9Sstevel@tonic-gate 		error = vn_vfsrlock(cvp);
6867c478bd9Sstevel@tonic-gate 		if (error) {
6877c478bd9Sstevel@tonic-gate 			if (!vn_vfswlock_held(cvp))
6887c478bd9Sstevel@tonic-gate 				error = vn_vfsrlock_wait(cvp);
6897c478bd9Sstevel@tonic-gate 			if (error != 0) {
6907c478bd9Sstevel@tonic-gate 				/*
6917c478bd9Sstevel@tonic-gate 				 * lookuppn() expects a held vnode to be
6927c478bd9Sstevel@tonic-gate 				 * returned because it promptly calls
6937c478bd9Sstevel@tonic-gate 				 * VN_RELE after the error return
6947c478bd9Sstevel@tonic-gate 				 */
6957c478bd9Sstevel@tonic-gate 				*cvpp = cvp;
6967c478bd9Sstevel@tonic-gate 				return (error);
6977c478bd9Sstevel@tonic-gate 			}
6987c478bd9Sstevel@tonic-gate 		}
6997c478bd9Sstevel@tonic-gate 
7007c478bd9Sstevel@tonic-gate 		/*
7017c478bd9Sstevel@tonic-gate 		 * Reached the end of the mount chain?
7027c478bd9Sstevel@tonic-gate 		 */
7037c478bd9Sstevel@tonic-gate 		vfsp = vn_mountedvfs(cvp);
7047c478bd9Sstevel@tonic-gate 		if (vfsp == NULL) {
7057c478bd9Sstevel@tonic-gate 			vn_vfsunlock(cvp);
7067c478bd9Sstevel@tonic-gate 			break;
7077c478bd9Sstevel@tonic-gate 		}
7087c478bd9Sstevel@tonic-gate 
7097c478bd9Sstevel@tonic-gate 		/*
7107c478bd9Sstevel@tonic-gate 		 * The read lock must be held across the call to VFS_ROOT() to
7117c478bd9Sstevel@tonic-gate 		 * prevent a concurrent unmount from destroying the vfs.
7127c478bd9Sstevel@tonic-gate 		 */
7137c478bd9Sstevel@tonic-gate 		error = VFS_ROOT(vfsp, &tvp);
7147c478bd9Sstevel@tonic-gate 		vn_vfsunlock(cvp);
7157c478bd9Sstevel@tonic-gate 
7167c478bd9Sstevel@tonic-gate 		if (error)
7177c478bd9Sstevel@tonic-gate 			break;
7187c478bd9Sstevel@tonic-gate 
7197c478bd9Sstevel@tonic-gate 		VN_RELE(cvp);
7207c478bd9Sstevel@tonic-gate 
7217c478bd9Sstevel@tonic-gate 		cvp = tvp;
7227c478bd9Sstevel@tonic-gate 	}
7237c478bd9Sstevel@tonic-gate 
7247c478bd9Sstevel@tonic-gate 	*cvpp = cvp;
7257c478bd9Sstevel@tonic-gate 	return (error);
7267c478bd9Sstevel@tonic-gate }
7277c478bd9Sstevel@tonic-gate 
7287c478bd9Sstevel@tonic-gate /*
7297c478bd9Sstevel@tonic-gate  * Return the lowermost vnode if this is a mountpoint.
7307c478bd9Sstevel@tonic-gate  */
7317c478bd9Sstevel@tonic-gate static vnode_t *
vn_under(vnode_t * vp)7327c478bd9Sstevel@tonic-gate vn_under(vnode_t *vp)
7337c478bd9Sstevel@tonic-gate {
7347c478bd9Sstevel@tonic-gate 	vnode_t *uvp;
7357c478bd9Sstevel@tonic-gate 	vfs_t *vfsp;
7367c478bd9Sstevel@tonic-gate 
7377c478bd9Sstevel@tonic-gate 	while (vp->v_flag & VROOT) {
7387c478bd9Sstevel@tonic-gate 
7397c478bd9Sstevel@tonic-gate 		vfsp = vp->v_vfsp;
7407c478bd9Sstevel@tonic-gate 		vfs_rlock_wait(vfsp);
7417c478bd9Sstevel@tonic-gate 		if ((uvp = vfsp->vfs_vnodecovered) == NULL ||
7427c478bd9Sstevel@tonic-gate 		    (vfsp->vfs_flag & VFS_UNMOUNTED)) {
7437c478bd9Sstevel@tonic-gate 			vfs_unlock(vfsp);
7447c478bd9Sstevel@tonic-gate 			break;
7457c478bd9Sstevel@tonic-gate 		}
7467c478bd9Sstevel@tonic-gate 		VN_HOLD(uvp);
7477c478bd9Sstevel@tonic-gate 		vfs_unlock(vfsp);
7487c478bd9Sstevel@tonic-gate 		VN_RELE(vp);
7497c478bd9Sstevel@tonic-gate 		vp = uvp;
7507c478bd9Sstevel@tonic-gate 	}
7517c478bd9Sstevel@tonic-gate 
7527c478bd9Sstevel@tonic-gate 	return (vp);
7537c478bd9Sstevel@tonic-gate }
7547c478bd9Sstevel@tonic-gate 
7557c478bd9Sstevel@tonic-gate static int
vnode_match(vnode_t * v1,vnode_t * v2,cred_t * cr)7567c478bd9Sstevel@tonic-gate vnode_match(vnode_t *v1, vnode_t *v2, cred_t *cr)
7577c478bd9Sstevel@tonic-gate {
7587c478bd9Sstevel@tonic-gate 	vattr_t	v1attr, v2attr;
7597c478bd9Sstevel@tonic-gate 
7607c478bd9Sstevel@tonic-gate 	/*
7617c478bd9Sstevel@tonic-gate 	 * If we have a device file, check to see if is a cloned open of the
7627c478bd9Sstevel@tonic-gate 	 * same device.  For self-cloning devices, the major numbers will match.
7637c478bd9Sstevel@tonic-gate 	 * For devices cloned through the 'clone' driver, the minor number of
7647c478bd9Sstevel@tonic-gate 	 * the source device will be the same as the major number of the cloned
7657c478bd9Sstevel@tonic-gate 	 * device.
7667c478bd9Sstevel@tonic-gate 	 */
7677c478bd9Sstevel@tonic-gate 	if ((v1->v_type == VCHR || v1->v_type == VBLK) &&
7687c478bd9Sstevel@tonic-gate 	    v1->v_type == v2->v_type) {
7697c478bd9Sstevel@tonic-gate 		if ((spec_is_selfclone(v1) || spec_is_selfclone(v2)) &&
7707c478bd9Sstevel@tonic-gate 		    getmajor(v1->v_rdev) == getmajor(v2->v_rdev))
7717c478bd9Sstevel@tonic-gate 			return (1);
7727c478bd9Sstevel@tonic-gate 
7737c478bd9Sstevel@tonic-gate 		if (spec_is_clone(v1) &&
7747c478bd9Sstevel@tonic-gate 		    getmajor(v1->v_rdev) == getminor(v2->v_rdev))
7757c478bd9Sstevel@tonic-gate 			return (1);
7767c478bd9Sstevel@tonic-gate 
7777c478bd9Sstevel@tonic-gate 		if (spec_is_clone(v2) &&
7787c478bd9Sstevel@tonic-gate 		    getmajor(v2->v_rdev) == getminor(v1->v_rdev))
7797c478bd9Sstevel@tonic-gate 			return (1);
7807c478bd9Sstevel@tonic-gate 	}
7817c478bd9Sstevel@tonic-gate 
7827c478bd9Sstevel@tonic-gate 	v1attr.va_mask = v2attr.va_mask = AT_TYPE;
7837c478bd9Sstevel@tonic-gate 
7847c478bd9Sstevel@tonic-gate 	/*
7857c478bd9Sstevel@tonic-gate 	 * This check for symbolic links handles the pseudo-symlinks in procfs.
7867c478bd9Sstevel@tonic-gate 	 * These particular links have v_type of VDIR, but the attributes have a
7877c478bd9Sstevel@tonic-gate 	 * type of VLNK.  We need to avoid these links because otherwise if we
7887c478bd9Sstevel@tonic-gate 	 * are currently in '/proc/self/fd', then '/proc/self/cwd' will compare
7897c478bd9Sstevel@tonic-gate 	 * as the same vnode.
7907c478bd9Sstevel@tonic-gate 	 */
791da6c28aaSamw 	if (VOP_GETATTR(v1, &v1attr, 0, cr, NULL) != 0 ||
792da6c28aaSamw 	    VOP_GETATTR(v2, &v2attr, 0, cr, NULL) != 0 ||
7937c478bd9Sstevel@tonic-gate 	    v1attr.va_type == VLNK || v2attr.va_type == VLNK)
7947c478bd9Sstevel@tonic-gate 		return (0);
7957c478bd9Sstevel@tonic-gate 
7967c478bd9Sstevel@tonic-gate 	v1attr.va_mask = v2attr.va_mask = AT_TYPE | AT_FSID | AT_NODEID;
7977c478bd9Sstevel@tonic-gate 
798da6c28aaSamw 	if (VOP_GETATTR(v1, &v1attr, ATTR_REAL, cr, NULL) != 0 ||
799da6c28aaSamw 	    VOP_GETATTR(v2, &v2attr, ATTR_REAL, cr, NULL) != 0)
8007c478bd9Sstevel@tonic-gate 		return (0);
8017c478bd9Sstevel@tonic-gate 
8027c478bd9Sstevel@tonic-gate 	return (v1attr.va_fsid == v2attr.va_fsid &&
8037c478bd9Sstevel@tonic-gate 	    v1attr.va_nodeid == v2attr.va_nodeid);
8047c478bd9Sstevel@tonic-gate }
8057c478bd9Sstevel@tonic-gate 
8067c478bd9Sstevel@tonic-gate 
8077c478bd9Sstevel@tonic-gate /*
8087c478bd9Sstevel@tonic-gate  * Find the entry in the directory corresponding to the target vnode.
8097c478bd9Sstevel@tonic-gate  */
8107c478bd9Sstevel@tonic-gate int
dirfindvp(vnode_t * vrootp,vnode_t * dvp,vnode_t * tvp,cred_t * cr,char * dbuf,size_t dlen,dirent64_t ** rdp)8117c478bd9Sstevel@tonic-gate dirfindvp(vnode_t *vrootp, vnode_t *dvp, vnode_t *tvp, cred_t *cr, char *dbuf,
8127c478bd9Sstevel@tonic-gate     size_t dlen, dirent64_t **rdp)
8137c478bd9Sstevel@tonic-gate {
8147c478bd9Sstevel@tonic-gate 	size_t dbuflen;
8157c478bd9Sstevel@tonic-gate 	struct iovec iov;
8167c478bd9Sstevel@tonic-gate 	struct uio uio;
817fa9e4066Sahrens 	int error;
8187c478bd9Sstevel@tonic-gate 	int eof;
8197c478bd9Sstevel@tonic-gate 	vnode_t *cmpvp;
8207c478bd9Sstevel@tonic-gate 	struct dirent64 *dp;
8217c478bd9Sstevel@tonic-gate 	pathname_t pnp;
8227c478bd9Sstevel@tonic-gate 
8237c478bd9Sstevel@tonic-gate 	ASSERT(dvp->v_type == VDIR);
8247c478bd9Sstevel@tonic-gate 
8257c478bd9Sstevel@tonic-gate 	/*
8267c478bd9Sstevel@tonic-gate 	 * This is necessary because of the strange semantics of VOP_LOOKUP().
8277c478bd9Sstevel@tonic-gate 	 */
8287c478bd9Sstevel@tonic-gate 	bzero(&pnp, sizeof (pnp));
8297c478bd9Sstevel@tonic-gate 
8307c478bd9Sstevel@tonic-gate 	uio.uio_iov = &iov;
8317c478bd9Sstevel@tonic-gate 	uio.uio_iovcnt = 1;
8327c478bd9Sstevel@tonic-gate 	uio.uio_segflg = UIO_SYSSPACE;
8337c478bd9Sstevel@tonic-gate 	uio.uio_fmode = 0;
8347c478bd9Sstevel@tonic-gate 	uio.uio_extflg = UIO_COPY_CACHED;
8357c478bd9Sstevel@tonic-gate 	uio.uio_loffset = 0;
8367c478bd9Sstevel@tonic-gate 
837da6c28aaSamw 	if ((error = VOP_ACCESS(dvp, VREAD, 0, cr, NULL)) != 0)
838fa9e4066Sahrens 		return (error);
8397c478bd9Sstevel@tonic-gate 
840*c6f039c7SToomas Soome 	dp = NULL;
841*c6f039c7SToomas Soome 	eof = 0;
842*c6f039c7SToomas Soome 
8437c478bd9Sstevel@tonic-gate 	while (!eof) {
8447c478bd9Sstevel@tonic-gate 		uio.uio_resid = dlen;
8457c478bd9Sstevel@tonic-gate 		iov.iov_base = dbuf;
8467c478bd9Sstevel@tonic-gate 		iov.iov_len = dlen;
8477c478bd9Sstevel@tonic-gate 
8487c478bd9Sstevel@tonic-gate 		(void) VOP_RWLOCK(dvp, V_WRITELOCK_FALSE, NULL);
849da6c28aaSamw 		error = VOP_READDIR(dvp, &uio, cr, &eof, NULL, 0);
8507c478bd9Sstevel@tonic-gate 		VOP_RWUNLOCK(dvp, V_WRITELOCK_FALSE, NULL);
8517c478bd9Sstevel@tonic-gate 
8527c478bd9Sstevel@tonic-gate 		dbuflen = dlen - uio.uio_resid;
8537c478bd9Sstevel@tonic-gate 
854fa9e4066Sahrens 		if (error || dbuflen == 0)
8557c478bd9Sstevel@tonic-gate 			break;
8567c478bd9Sstevel@tonic-gate 
8577c478bd9Sstevel@tonic-gate 		dp = (dirent64_t *)dbuf;
8587c478bd9Sstevel@tonic-gate 		while ((intptr_t)dp < (intptr_t)dbuf + dbuflen) {
8597c478bd9Sstevel@tonic-gate 			/*
8607c478bd9Sstevel@tonic-gate 			 * Ignore '.' and '..' entries
8617c478bd9Sstevel@tonic-gate 			 */
8627c478bd9Sstevel@tonic-gate 			if (strcmp(dp->d_name, ".") == 0 ||
8637c478bd9Sstevel@tonic-gate 			    strcmp(dp->d_name, "..") == 0) {
8647c478bd9Sstevel@tonic-gate 				dp = (dirent64_t *)((intptr_t)dp +
8657c478bd9Sstevel@tonic-gate 				    dp->d_reclen);
8667c478bd9Sstevel@tonic-gate 				continue;
8677c478bd9Sstevel@tonic-gate 			}
8687c478bd9Sstevel@tonic-gate 
869fa9e4066Sahrens 			error = VOP_LOOKUP(dvp, dp->d_name, &cmpvp, &pnp, 0,
870da6c28aaSamw 			    vrootp, cr, NULL, NULL, NULL);
8717c478bd9Sstevel@tonic-gate 
8727c478bd9Sstevel@tonic-gate 			/*
8737c478bd9Sstevel@tonic-gate 			 * We only want to bail out if there was an error other
8747c478bd9Sstevel@tonic-gate 			 * than ENOENT.  Otherwise, it could be that someone
8757c478bd9Sstevel@tonic-gate 			 * just removed an entry since the readdir() call, and
8767c478bd9Sstevel@tonic-gate 			 * the entry we want is further on in the directory.
8777c478bd9Sstevel@tonic-gate 			 */
878fa9e4066Sahrens 			if (error == 0) {
8797c478bd9Sstevel@tonic-gate 				if (vnode_match(tvp, cmpvp, cr)) {
8807c478bd9Sstevel@tonic-gate 					VN_RELE(cmpvp);
8817c478bd9Sstevel@tonic-gate 					*rdp = dp;
8827c478bd9Sstevel@tonic-gate 					return (0);
8837c478bd9Sstevel@tonic-gate 				}
8847c478bd9Sstevel@tonic-gate 
8857c478bd9Sstevel@tonic-gate 				VN_RELE(cmpvp);
886fa9e4066Sahrens 			} else if (error != ENOENT) {
887fa9e4066Sahrens 				return (error);
8887c478bd9Sstevel@tonic-gate 			}
8897c478bd9Sstevel@tonic-gate 
8907c478bd9Sstevel@tonic-gate 			dp = (dirent64_t *)((intptr_t)dp + dp->d_reclen);
8917c478bd9Sstevel@tonic-gate 		}
8927c478bd9Sstevel@tonic-gate 	}
8937c478bd9Sstevel@tonic-gate 
8947c478bd9Sstevel@tonic-gate 	/*
8957c478bd9Sstevel@tonic-gate 	 * Something strange has happened, this directory does not contain the
8967c478bd9Sstevel@tonic-gate 	 * specified vnode.  This should never happen in the normal case, since
897fa9e4066Sahrens 	 * we ensured that dvp is the parent of vp.  This is possible in some
898fa9e4066Sahrens 	 * rare conditions (races and the special .zfs directory).
8997c478bd9Sstevel@tonic-gate 	 */
900fa9e4066Sahrens 	if (error == 0) {
901