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