The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/kern/vfs_lookup.c

Version: -  FREEBSD  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-2  -  FREEBSD-11-1  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-4  -  FREEBSD-10-3  -  FREEBSD-10-2  -  FREEBSD-10-1  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-3  -  FREEBSD-9-2  -  FREEBSD-9-1  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-4  -  FREEBSD-8-3  -  FREEBSD-8-2  -  FREEBSD-8-1  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-4  -  FREEBSD-7-3  -  FREEBSD-7-2  -  FREEBSD-7-1  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-4  -  FREEBSD-6-3  -  FREEBSD-6-2  -  FREEBSD-6-1  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-5  -  FREEBSD-5-4  -  FREEBSD-5-3  -  FREEBSD-5-2  -  FREEBSD-5-1  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  linux-2.6  -  linux-2.4.22  -  MK83  -  MK84  -  PLAN9  -  DFBSD  -  NETBSD  -  NETBSD5  -  NETBSD4  -  NETBSD3  -  NETBSD20  -  OPENBSD  -  xnu-517  -  xnu-792  -  xnu-792.6.70  -  xnu-1228  -  xnu-1456.1.26  -  xnu-1699.24.8  -  xnu-2050.18.24  -  OPENSOLARIS  -  minix-3-1-1 
SearchContext: -  none  -  3  -  10 

    1 /*-
    2  * Copyright (c) 1982, 1986, 1989, 1993
    3  *      The Regents of the University of California.  All rights reserved.
    4  * (c) UNIX System Laboratories, Inc.
    5  * All or some portions of this file are derived from material licensed
    6  * to the University of California by American Telephone and Telegraph
    7  * Co. or Unix System Laboratories, Inc. and are reproduced herein with
    8  * the permission of UNIX System Laboratories, Inc.
    9  *
   10  * Redistribution and use in source and binary forms, with or without
   11  * modification, are permitted provided that the following conditions
   12  * are met:
   13  * 1. Redistributions of source code must retain the above copyright
   14  *    notice, this list of conditions and the following disclaimer.
   15  * 2. Redistributions in binary form must reproduce the above copyright
   16  *    notice, this list of conditions and the following disclaimer in the
   17  *    documentation and/or other materials provided with the distribution.
   18  * 4. Neither the name of the University nor the names of its contributors
   19  *    may be used to endorse or promote products derived from this software
   20  *    without specific prior written permission.
   21  *
   22  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
   23  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   24  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   25  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
   26  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   27  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   28  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   29  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   30  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   31  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   32  * SUCH DAMAGE.
   33  *
   34  *      @(#)vfs_lookup.c        8.4 (Berkeley) 2/16/94
   35  */
   36 
   37 #include <sys/cdefs.h>
   38 __FBSDID("$FreeBSD: releng/10.1/sys/kern/vfs_lookup.c 273414 2014-10-21 20:20:36Z delphij $");
   39 
   40 #include "opt_capsicum.h"
   41 #include "opt_kdtrace.h"
   42 #include "opt_ktrace.h"
   43 
   44 #include <sys/param.h>
   45 #include <sys/systm.h>
   46 #include <sys/kernel.h>
   47 #include <sys/capability.h>
   48 #include <sys/fcntl.h>
   49 #include <sys/jail.h>
   50 #include <sys/lock.h>
   51 #include <sys/mutex.h>
   52 #include <sys/namei.h>
   53 #include <sys/vnode.h>
   54 #include <sys/mount.h>
   55 #include <sys/filedesc.h>
   56 #include <sys/proc.h>
   57 #include <sys/sdt.h>
   58 #include <sys/syscallsubr.h>
   59 #include <sys/sysctl.h>
   60 #ifdef KTRACE
   61 #include <sys/ktrace.h>
   62 #endif
   63 
   64 #include <security/audit/audit.h>
   65 #include <security/mac/mac_framework.h>
   66 
   67 #include <vm/uma.h>
   68 
   69 #define NAMEI_DIAGNOSTIC 1
   70 #undef NAMEI_DIAGNOSTIC
   71 
   72 SDT_PROVIDER_DECLARE(vfs);
   73 SDT_PROBE_DEFINE3(vfs, namei, lookup, entry, "struct vnode *", "char *",
   74     "unsigned long");
   75 SDT_PROBE_DEFINE2(vfs, namei, lookup, return, "int", "struct vnode *");
   76 
   77 /*
   78  * Allocation zone for namei
   79  */
   80 uma_zone_t namei_zone;
   81 /*
   82  * Placeholder vnode for mp traversal
   83  */
   84 static struct vnode *vp_crossmp;
   85 
   86 static void
   87 nameiinit(void *dummy __unused)
   88 {
   89 
   90         namei_zone = uma_zcreate("NAMEI", MAXPATHLEN, NULL, NULL, NULL, NULL,
   91             UMA_ALIGN_PTR, 0);
   92         getnewvnode("crossmp", NULL, &dead_vnodeops, &vp_crossmp);
   93         vn_lock(vp_crossmp, LK_EXCLUSIVE);
   94         VN_LOCK_ASHARE(vp_crossmp);
   95         VOP_UNLOCK(vp_crossmp, 0);
   96 }
   97 SYSINIT(vfs, SI_SUB_VFS, SI_ORDER_SECOND, nameiinit, NULL);
   98 
   99 static int lookup_shared = 1;
  100 SYSCTL_INT(_vfs, OID_AUTO, lookup_shared, CTLFLAG_RW, &lookup_shared, 0,
  101     "Enables/Disables shared locks for path name translation");
  102 TUNABLE_INT("vfs.lookup_shared", &lookup_shared);
  103 
  104 /*
  105  * Convert a pathname into a pointer to a locked vnode.
  106  *
  107  * The FOLLOW flag is set when symbolic links are to be followed
  108  * when they occur at the end of the name translation process.
  109  * Symbolic links are always followed for all other pathname
  110  * components other than the last.
  111  *
  112  * The segflg defines whether the name is to be copied from user
  113  * space or kernel space.
  114  *
  115  * Overall outline of namei:
  116  *
  117  *      copy in name
  118  *      get starting directory
  119  *      while (!done && !error) {
  120  *              call lookup to search path.
  121  *              if symbolic link, massage name in buffer and continue
  122  *      }
  123  */
  124 static void
  125 namei_cleanup_cnp(struct componentname *cnp)
  126 {
  127         uma_zfree(namei_zone, cnp->cn_pnbuf);
  128 #ifdef DIAGNOSTIC
  129         cnp->cn_pnbuf = NULL;
  130         cnp->cn_nameptr = NULL;
  131 #endif
  132 }
  133 
  134 int
  135 namei(struct nameidata *ndp)
  136 {
  137         struct filedesc *fdp;   /* pointer to file descriptor state */
  138         char *cp;               /* pointer into pathname argument */
  139         struct vnode *dp;       /* the directory we are searching */
  140         struct iovec aiov;              /* uio for reading symbolic links */
  141         struct uio auio;
  142         int error, linklen;
  143         struct componentname *cnp = &ndp->ni_cnd;
  144         struct thread *td = cnp->cn_thread;
  145         struct proc *p = td->td_proc;
  146 
  147         ndp->ni_cnd.cn_cred = ndp->ni_cnd.cn_thread->td_ucred;
  148         KASSERT(cnp->cn_cred && p, ("namei: bad cred/proc"));
  149         KASSERT((cnp->cn_nameiop & (~OPMASK)) == 0,
  150             ("namei: nameiop contaminated with flags"));
  151         KASSERT((cnp->cn_flags & OPMASK) == 0,
  152             ("namei: flags contaminated with nameiops"));
  153         if (!lookup_shared)
  154                 cnp->cn_flags &= ~LOCKSHARED;
  155         fdp = p->p_fd;
  156 
  157         /* We will set this ourselves if we need it. */
  158         cnp->cn_flags &= ~TRAILINGSLASH;
  159 
  160         /*
  161          * Get a buffer for the name to be translated, and copy the
  162          * name into the buffer.
  163          */
  164         if ((cnp->cn_flags & HASBUF) == 0)
  165                 cnp->cn_pnbuf = uma_zalloc(namei_zone, M_WAITOK);
  166         if (ndp->ni_segflg == UIO_SYSSPACE)
  167                 error = copystr(ndp->ni_dirp, cnp->cn_pnbuf,
  168                             MAXPATHLEN, (size_t *)&ndp->ni_pathlen);
  169         else
  170                 error = copyinstr(ndp->ni_dirp, cnp->cn_pnbuf,
  171                             MAXPATHLEN, (size_t *)&ndp->ni_pathlen);
  172 
  173         /*
  174          * Don't allow empty pathnames.
  175          */
  176         if (!error && *cnp->cn_pnbuf == '\0')
  177                 error = ENOENT;
  178 
  179 #ifdef CAPABILITY_MODE
  180         /*
  181          * In capability mode, lookups must be "strictly relative" (i.e.
  182          * not an absolute path, and not containing '..' components) to
  183          * a real file descriptor, not the pseudo-descriptor AT_FDCWD.
  184          */
  185         if (error == 0 && IN_CAPABILITY_MODE(td) &&
  186             (cnp->cn_flags & NOCAPCHECK) == 0) {
  187                 ndp->ni_strictrelative = 1;
  188                 if (ndp->ni_dirfd == AT_FDCWD) {
  189 #ifdef KTRACE
  190                         if (KTRPOINT(td, KTR_CAPFAIL))
  191                                 ktrcapfail(CAPFAIL_LOOKUP, NULL, NULL);
  192 #endif
  193                         error = ECAPMODE;
  194                 }
  195         }
  196 #endif
  197         if (error) {
  198                 namei_cleanup_cnp(cnp);
  199                 ndp->ni_vp = NULL;
  200                 return (error);
  201         }
  202         ndp->ni_loopcnt = 0;
  203 #ifdef KTRACE
  204         if (KTRPOINT(td, KTR_NAMEI)) {
  205                 KASSERT(cnp->cn_thread == curthread,
  206                     ("namei not using curthread"));
  207                 ktrnamei(cnp->cn_pnbuf);
  208         }
  209 #endif
  210         /*
  211          * Get starting point for the translation.
  212          */
  213         FILEDESC_SLOCK(fdp);
  214         ndp->ni_rootdir = fdp->fd_rdir;
  215         ndp->ni_topdir = fdp->fd_jdir;
  216 
  217         /*
  218          * If we are auditing the kernel pathname, save the user pathname.
  219          */
  220         if (cnp->cn_flags & AUDITVNODE1)
  221                 AUDIT_ARG_UPATH1(td, ndp->ni_dirfd, cnp->cn_pnbuf);
  222         if (cnp->cn_flags & AUDITVNODE2)
  223                 AUDIT_ARG_UPATH2(td, ndp->ni_dirfd, cnp->cn_pnbuf);
  224 
  225         dp = NULL;
  226         if (cnp->cn_pnbuf[0] != '/') {
  227                 if (ndp->ni_startdir != NULL) {
  228                         dp = ndp->ni_startdir;
  229                         error = 0;
  230                 } else if (ndp->ni_dirfd != AT_FDCWD) {
  231                         cap_rights_t rights;
  232 
  233                         rights = ndp->ni_rightsneeded;
  234                         cap_rights_set(&rights, CAP_LOOKUP);
  235 
  236                         if (cnp->cn_flags & AUDITVNODE1)
  237                                 AUDIT_ARG_ATFD1(ndp->ni_dirfd);
  238                         if (cnp->cn_flags & AUDITVNODE2)
  239                                 AUDIT_ARG_ATFD2(ndp->ni_dirfd);
  240                         error = fgetvp_rights(td, ndp->ni_dirfd,
  241                             &rights, &ndp->ni_filecaps, &dp);
  242 #ifdef CAPABILITIES
  243                         /*
  244                          * If file descriptor doesn't have all rights,
  245                          * all lookups relative to it must also be
  246                          * strictly relative.
  247                          */
  248                         CAP_ALL(&rights);
  249                         if (!cap_rights_contains(&ndp->ni_filecaps.fc_rights,
  250                             &rights) ||
  251                             ndp->ni_filecaps.fc_fcntls != CAP_FCNTL_ALL ||
  252                             ndp->ni_filecaps.fc_nioctls != -1) {
  253                                 ndp->ni_strictrelative = 1;
  254                         }
  255 #endif
  256                 }
  257                 if (error != 0 || dp != NULL) {
  258                         FILEDESC_SUNLOCK(fdp);
  259                         if (error == 0 && dp->v_type != VDIR) {
  260                                 vrele(dp);
  261                                 error = ENOTDIR;
  262                         }
  263                 }
  264                 if (error) {
  265                         namei_cleanup_cnp(cnp);
  266                         return (error);
  267                 }
  268         }
  269         if (dp == NULL) {
  270                 dp = fdp->fd_cdir;
  271                 VREF(dp);
  272                 FILEDESC_SUNLOCK(fdp);
  273                 if (ndp->ni_startdir != NULL)
  274                         vrele(ndp->ni_startdir);
  275         }
  276         SDT_PROBE(vfs, namei, lookup, entry, dp, cnp->cn_pnbuf,
  277             cnp->cn_flags, 0, 0);
  278         for (;;) {
  279                 /*
  280                  * Check if root directory should replace current directory.
  281                  * Done at start of translation and after symbolic link.
  282                  */
  283                 cnp->cn_nameptr = cnp->cn_pnbuf;
  284                 if (*(cnp->cn_nameptr) == '/') {
  285                         vrele(dp);
  286                         if (ndp->ni_strictrelative != 0) {
  287 #ifdef KTRACE
  288                                 if (KTRPOINT(curthread, KTR_CAPFAIL))
  289                                         ktrcapfail(CAPFAIL_LOOKUP, NULL, NULL);
  290 #endif
  291                                 namei_cleanup_cnp(cnp);
  292                                 return (ENOTCAPABLE);
  293                         }
  294                         while (*(cnp->cn_nameptr) == '/') {
  295                                 cnp->cn_nameptr++;
  296                                 ndp->ni_pathlen--;
  297                         }
  298                         dp = ndp->ni_rootdir;
  299                         VREF(dp);
  300                 }
  301                 ndp->ni_startdir = dp;
  302                 error = lookup(ndp);
  303                 if (error) {
  304                         namei_cleanup_cnp(cnp);
  305                         SDT_PROBE(vfs, namei, lookup, return, error, NULL, 0,
  306                             0, 0);
  307                         return (error);
  308                 }
  309                 /*
  310                  * If not a symbolic link, we're done.
  311                  */
  312                 if ((cnp->cn_flags & ISSYMLINK) == 0) {
  313                         if ((cnp->cn_flags & (SAVENAME | SAVESTART)) == 0) {
  314                                 namei_cleanup_cnp(cnp);
  315                         } else
  316                                 cnp->cn_flags |= HASBUF;
  317 
  318                         SDT_PROBE(vfs, namei, lookup, return, 0, ndp->ni_vp,
  319                             0, 0, 0);
  320                         return (0);
  321                 }
  322                 if (ndp->ni_loopcnt++ >= MAXSYMLINKS) {
  323                         error = ELOOP;
  324                         break;
  325                 }
  326 #ifdef MAC
  327                 if ((cnp->cn_flags & NOMACCHECK) == 0) {
  328                         error = mac_vnode_check_readlink(td->td_ucred,
  329                             ndp->ni_vp);
  330                         if (error)
  331                                 break;
  332                 }
  333 #endif
  334                 if (ndp->ni_pathlen > 1)
  335                         cp = uma_zalloc(namei_zone, M_WAITOK);
  336                 else
  337                         cp = cnp->cn_pnbuf;
  338                 aiov.iov_base = cp;
  339                 aiov.iov_len = MAXPATHLEN;
  340                 auio.uio_iov = &aiov;
  341                 auio.uio_iovcnt = 1;
  342                 auio.uio_offset = 0;
  343                 auio.uio_rw = UIO_READ;
  344                 auio.uio_segflg = UIO_SYSSPACE;
  345                 auio.uio_td = td;
  346                 auio.uio_resid = MAXPATHLEN;
  347                 error = VOP_READLINK(ndp->ni_vp, &auio, cnp->cn_cred);
  348                 if (error) {
  349                         if (ndp->ni_pathlen > 1)
  350                                 uma_zfree(namei_zone, cp);
  351                         break;
  352                 }
  353                 linklen = MAXPATHLEN - auio.uio_resid;
  354                 if (linklen == 0) {
  355                         if (ndp->ni_pathlen > 1)
  356                                 uma_zfree(namei_zone, cp);
  357                         error = ENOENT;
  358                         break;
  359                 }
  360                 if (linklen + ndp->ni_pathlen >= MAXPATHLEN) {
  361                         if (ndp->ni_pathlen > 1)
  362                                 uma_zfree(namei_zone, cp);
  363                         error = ENAMETOOLONG;
  364                         break;
  365                 }
  366                 if (ndp->ni_pathlen > 1) {
  367                         bcopy(ndp->ni_next, cp + linklen, ndp->ni_pathlen);
  368                         uma_zfree(namei_zone, cnp->cn_pnbuf);
  369                         cnp->cn_pnbuf = cp;
  370                 } else
  371                         cnp->cn_pnbuf[linklen] = '\0';
  372                 ndp->ni_pathlen += linklen;
  373                 vput(ndp->ni_vp);
  374                 dp = ndp->ni_dvp;
  375         }
  376         namei_cleanup_cnp(cnp);
  377         vput(ndp->ni_vp);
  378         ndp->ni_vp = NULL;
  379         vrele(ndp->ni_dvp);
  380         SDT_PROBE(vfs, namei, lookup, return, error, NULL, 0, 0, 0);
  381         return (error);
  382 }
  383 
  384 static int
  385 compute_cn_lkflags(struct mount *mp, int lkflags, int cnflags)
  386 {
  387 
  388         if (mp == NULL || ((lkflags & LK_SHARED) &&
  389             (!(mp->mnt_kern_flag & MNTK_LOOKUP_SHARED) ||
  390             ((cnflags & ISDOTDOT) &&
  391             (mp->mnt_kern_flag & MNTK_LOOKUP_EXCL_DOTDOT))))) {
  392                 lkflags &= ~LK_SHARED;
  393                 lkflags |= LK_EXCLUSIVE;
  394         }
  395         return (lkflags);
  396 }
  397 
  398 static __inline int
  399 needs_exclusive_leaf(struct mount *mp, int flags)
  400 {
  401 
  402         /*
  403          * Intermediate nodes can use shared locks, we only need to
  404          * force an exclusive lock for leaf nodes.
  405          */
  406         if ((flags & (ISLASTCN | LOCKLEAF)) != (ISLASTCN | LOCKLEAF))
  407                 return (0);
  408 
  409         /* Always use exclusive locks if LOCKSHARED isn't set. */
  410         if (!(flags & LOCKSHARED))
  411                 return (1);
  412 
  413         /*
  414          * For lookups during open(), if the mount point supports
  415          * extended shared operations, then use a shared lock for the
  416          * leaf node, otherwise use an exclusive lock.
  417          */
  418         if ((flags & ISOPEN) != 0)
  419                 return (!MNT_EXTENDED_SHARED(mp));
  420 
  421         /*
  422          * Lookup requests outside of open() that specify LOCKSHARED
  423          * only need a shared lock on the leaf vnode.
  424          */
  425         return (0);
  426 }
  427 
  428 /*
  429  * Search a pathname.
  430  * This is a very central and rather complicated routine.
  431  *
  432  * The pathname is pointed to by ni_ptr and is of length ni_pathlen.
  433  * The starting directory is taken from ni_startdir. The pathname is
  434  * descended until done, or a symbolic link is encountered. The variable
  435  * ni_more is clear if the path is completed; it is set to one if a
  436  * symbolic link needing interpretation is encountered.
  437  *
  438  * The flag argument is LOOKUP, CREATE, RENAME, or DELETE depending on
  439  * whether the name is to be looked up, created, renamed, or deleted.
  440  * When CREATE, RENAME, or DELETE is specified, information usable in
  441  * creating, renaming, or deleting a directory entry may be calculated.
  442  * If flag has LOCKPARENT or'ed into it, the parent directory is returned
  443  * locked. If flag has WANTPARENT or'ed into it, the parent directory is
  444  * returned unlocked. Otherwise the parent directory is not returned. If
  445  * the target of the pathname exists and LOCKLEAF is or'ed into the flag
  446  * the target is returned locked, otherwise it is returned unlocked.
  447  * When creating or renaming and LOCKPARENT is specified, the target may not
  448  * be ".".  When deleting and LOCKPARENT is specified, the target may be ".".
  449  *
  450  * Overall outline of lookup:
  451  *
  452  * dirloop:
  453  *      identify next component of name at ndp->ni_ptr
  454  *      handle degenerate case where name is null string
  455  *      if .. and crossing mount points and on mounted filesys, find parent
  456  *      call VOP_LOOKUP routine for next component name
  457  *          directory vnode returned in ni_dvp, unlocked unless LOCKPARENT set
  458  *          component vnode returned in ni_vp (if it exists), locked.
  459  *      if result vnode is mounted on and crossing mount points,
  460  *          find mounted on vnode
  461  *      if more components of name, do next level at dirloop
  462  *      return the answer in ni_vp, locked if LOCKLEAF set
  463  *          if LOCKPARENT set, return locked parent in ni_dvp
  464  *          if WANTPARENT set, return unlocked parent in ni_dvp
  465  */
  466 int
  467 lookup(struct nameidata *ndp)
  468 {
  469         char *cp;               /* pointer into pathname argument */
  470         struct vnode *dp = 0;   /* the directory we are searching */
  471         struct vnode *tdp;              /* saved dp */
  472         struct mount *mp;               /* mount table entry */
  473         struct prison *pr;
  474         int docache;                    /* == 0 do not cache last component */
  475         int wantparent;                 /* 1 => wantparent or lockparent flag */
  476         int rdonly;                     /* lookup read-only flag bit */
  477         int error = 0;
  478         int dpunlocked = 0;             /* dp has already been unlocked */
  479         struct componentname *cnp = &ndp->ni_cnd;
  480         int lkflags_save;
  481         int ni_dvp_unlocked;
  482         
  483         /*
  484          * Setup: break out flag bits into variables.
  485          */
  486         ni_dvp_unlocked = 0;
  487         wantparent = cnp->cn_flags & (LOCKPARENT | WANTPARENT);
  488         KASSERT(cnp->cn_nameiop == LOOKUP || wantparent,
  489             ("CREATE, DELETE, RENAME require LOCKPARENT or WANTPARENT."));
  490         docache = (cnp->cn_flags & NOCACHE) ^ NOCACHE;
  491         if (cnp->cn_nameiop == DELETE ||
  492             (wantparent && cnp->cn_nameiop != CREATE &&
  493              cnp->cn_nameiop != LOOKUP))
  494                 docache = 0;
  495         rdonly = cnp->cn_flags & RDONLY;
  496         cnp->cn_flags &= ~ISSYMLINK;
  497         ndp->ni_dvp = NULL;
  498         /*
  499          * We use shared locks until we hit the parent of the last cn then
  500          * we adjust based on the requesting flags.
  501          */
  502         if (lookup_shared)
  503                 cnp->cn_lkflags = LK_SHARED;
  504         else
  505                 cnp->cn_lkflags = LK_EXCLUSIVE;
  506         dp = ndp->ni_startdir;
  507         ndp->ni_startdir = NULLVP;
  508         vn_lock(dp,
  509             compute_cn_lkflags(dp->v_mount, cnp->cn_lkflags | LK_RETRY,
  510             cnp->cn_flags));
  511 
  512 dirloop:
  513         /*
  514          * Search a new directory.
  515          *
  516          * The last component of the filename is left accessible via
  517          * cnp->cn_nameptr for callers that need the name. Callers needing
  518          * the name set the SAVENAME flag. When done, they assume
  519          * responsibility for freeing the pathname buffer.
  520          */
  521         cnp->cn_consume = 0;
  522         for (cp = cnp->cn_nameptr; *cp != 0 && *cp != '/'; cp++)
  523                 continue;
  524         cnp->cn_namelen = cp - cnp->cn_nameptr;
  525         if (cnp->cn_namelen > NAME_MAX) {
  526                 error = ENAMETOOLONG;
  527                 goto bad;
  528         }
  529 #ifdef NAMEI_DIAGNOSTIC
  530         { char c = *cp;
  531         *cp = '\0';
  532         printf("{%s}: ", cnp->cn_nameptr);
  533         *cp = c; }
  534 #endif
  535         ndp->ni_pathlen -= cnp->cn_namelen;
  536         ndp->ni_next = cp;
  537 
  538         /*
  539          * Replace multiple slashes by a single slash and trailing slashes
  540          * by a null.  This must be done before VOP_LOOKUP() because some
  541          * fs's don't know about trailing slashes.  Remember if there were
  542          * trailing slashes to handle symlinks, existing non-directories
  543          * and non-existing files that won't be directories specially later.
  544          */
  545         while (*cp == '/' && (cp[1] == '/' || cp[1] == '\0')) {
  546                 cp++;
  547                 ndp->ni_pathlen--;
  548                 if (*cp == '\0') {
  549                         *ndp->ni_next = '\0';
  550                         cnp->cn_flags |= TRAILINGSLASH;
  551                 }
  552         }
  553         ndp->ni_next = cp;
  554 
  555         cnp->cn_flags |= MAKEENTRY;
  556         if (*cp == '\0' && docache == 0)
  557                 cnp->cn_flags &= ~MAKEENTRY;
  558         if (cnp->cn_namelen == 2 &&
  559             cnp->cn_nameptr[1] == '.' && cnp->cn_nameptr[0] == '.')
  560                 cnp->cn_flags |= ISDOTDOT;
  561         else
  562                 cnp->cn_flags &= ~ISDOTDOT;
  563         if (*ndp->ni_next == 0)
  564                 cnp->cn_flags |= ISLASTCN;
  565         else
  566                 cnp->cn_flags &= ~ISLASTCN;
  567 
  568         if ((cnp->cn_flags & ISLASTCN) != 0 &&
  569             cnp->cn_namelen == 1 && cnp->cn_nameptr[0] == '.' &&
  570             (cnp->cn_nameiop == DELETE || cnp->cn_nameiop == RENAME)) {
  571                 error = EINVAL;
  572                 goto bad;
  573         }
  574 
  575         /*
  576          * Check for degenerate name (e.g. / or "")
  577          * which is a way of talking about a directory,
  578          * e.g. like "/." or ".".
  579          */
  580         if (cnp->cn_nameptr[0] == '\0') {
  581                 if (dp->v_type != VDIR) {
  582                         error = ENOTDIR;
  583                         goto bad;
  584                 }
  585                 if (cnp->cn_nameiop != LOOKUP) {
  586                         error = EISDIR;
  587                         goto bad;
  588                 }
  589                 if (wantparent) {
  590                         ndp->ni_dvp = dp;
  591                         VREF(dp);
  592                 }
  593                 ndp->ni_vp = dp;
  594 
  595                 if (cnp->cn_flags & AUDITVNODE1)
  596                         AUDIT_ARG_VNODE1(dp);
  597                 else if (cnp->cn_flags & AUDITVNODE2)
  598                         AUDIT_ARG_VNODE2(dp);
  599 
  600                 if (!(cnp->cn_flags & (LOCKPARENT | LOCKLEAF)))
  601                         VOP_UNLOCK(dp, 0);
  602                 /* XXX This should probably move to the top of function. */
  603                 if (cnp->cn_flags & SAVESTART)
  604                         panic("lookup: SAVESTART");
  605                 goto success;
  606         }
  607 
  608         /*
  609          * Handle "..": five special cases.
  610          * 0. If doing a capability lookup, return ENOTCAPABLE (this is a
  611          *    fairly conservative design choice, but it's the only one that we
  612          *    are satisfied guarantees the property we're looking for).
  613          * 1. Return an error if this is the last component of
  614          *    the name and the operation is DELETE or RENAME.
  615          * 2. If at root directory (e.g. after chroot)
  616          *    or at absolute root directory
  617          *    then ignore it so can't get out.
  618          * 3. If this vnode is the root of a mounted
  619          *    filesystem, then replace it with the
  620          *    vnode which was mounted on so we take the
  621          *    .. in the other filesystem.
  622          * 4. If the vnode is the top directory of
  623          *    the jail or chroot, don't let them out.
  624          */
  625         if (cnp->cn_flags & ISDOTDOT) {
  626                 if (ndp->ni_strictrelative != 0) {
  627 #ifdef KTRACE
  628                         if (KTRPOINT(curthread, KTR_CAPFAIL))
  629                                 ktrcapfail(CAPFAIL_LOOKUP, NULL, NULL);
  630 #endif
  631                         error = ENOTCAPABLE;
  632                         goto bad;
  633                 }
  634                 if ((cnp->cn_flags & ISLASTCN) != 0 &&
  635                     (cnp->cn_nameiop == DELETE || cnp->cn_nameiop == RENAME)) {
  636                         error = EINVAL;
  637                         goto bad;
  638                 }
  639                 for (;;) {
  640                         for (pr = cnp->cn_cred->cr_prison; pr != NULL;
  641                              pr = pr->pr_parent)
  642                                 if (dp == pr->pr_root)
  643                                         break;
  644                         if (dp == ndp->ni_rootdir || 
  645                             dp == ndp->ni_topdir || 
  646                             dp == rootvnode ||
  647                             pr != NULL ||
  648                             ((dp->v_vflag & VV_ROOT) != 0 &&
  649                              (cnp->cn_flags & NOCROSSMOUNT) != 0)) {
  650                                 ndp->ni_dvp = dp;
  651                                 ndp->ni_vp = dp;
  652                                 VREF(dp);
  653                                 goto nextname;
  654                         }
  655                         if ((dp->v_vflag & VV_ROOT) == 0)
  656                                 break;
  657                         if (dp->v_iflag & VI_DOOMED) {  /* forced unmount */
  658                                 error = ENOENT;
  659                                 goto bad;
  660                         }
  661                         tdp = dp;
  662                         dp = dp->v_mount->mnt_vnodecovered;
  663                         VREF(dp);
  664                         vput(tdp);
  665                         vn_lock(dp,
  666                             compute_cn_lkflags(dp->v_mount, cnp->cn_lkflags |
  667                             LK_RETRY, ISDOTDOT));
  668                 }
  669         }
  670 
  671         /*
  672          * We now have a segment name to search for, and a directory to search.
  673          */
  674 unionlookup:
  675 #ifdef MAC
  676         if ((cnp->cn_flags & NOMACCHECK) == 0) {
  677                 error = mac_vnode_check_lookup(cnp->cn_thread->td_ucred, dp,
  678                     cnp);
  679                 if (error)
  680                         goto bad;
  681         }
  682 #endif
  683         ndp->ni_dvp = dp;
  684         ndp->ni_vp = NULL;
  685         ASSERT_VOP_LOCKED(dp, "lookup");
  686         /*
  687          * If we have a shared lock we may need to upgrade the lock for the
  688          * last operation.
  689          */
  690         if (dp != vp_crossmp &&
  691             VOP_ISLOCKED(dp) == LK_SHARED &&
  692             (cnp->cn_flags & ISLASTCN) && (cnp->cn_flags & LOCKPARENT))
  693                 vn_lock(dp, LK_UPGRADE|LK_RETRY);
  694         if ((dp->v_iflag & VI_DOOMED) != 0) {
  695                 error = ENOENT;
  696                 goto bad;
  697         }
  698         /*
  699          * If we're looking up the last component and we need an exclusive
  700          * lock, adjust our lkflags.
  701          */
  702         if (needs_exclusive_leaf(dp->v_mount, cnp->cn_flags))
  703                 cnp->cn_lkflags = LK_EXCLUSIVE;
  704 #ifdef NAMEI_DIAGNOSTIC
  705         vprint("lookup in", dp);
  706 #endif
  707         lkflags_save = cnp->cn_lkflags;
  708         cnp->cn_lkflags = compute_cn_lkflags(dp->v_mount, cnp->cn_lkflags,
  709             cnp->cn_flags);
  710         if ((error = VOP_LOOKUP(dp, &ndp->ni_vp, cnp)) != 0) {
  711                 cnp->cn_lkflags = lkflags_save;
  712                 KASSERT(ndp->ni_vp == NULL, ("leaf should be empty"));
  713 #ifdef NAMEI_DIAGNOSTIC
  714                 printf("not found\n");
  715 #endif
  716                 if ((error == ENOENT) &&
  717                     (dp->v_vflag & VV_ROOT) && (dp->v_mount != NULL) &&
  718                     (dp->v_mount->mnt_flag & MNT_UNION)) {
  719                         tdp = dp;
  720                         dp = dp->v_mount->mnt_vnodecovered;
  721                         VREF(dp);
  722                         vput(tdp);
  723                         vn_lock(dp,
  724                             compute_cn_lkflags(dp->v_mount, cnp->cn_lkflags |
  725                             LK_RETRY, cnp->cn_flags));
  726                         goto unionlookup;
  727                 }
  728 
  729                 if (error != EJUSTRETURN)
  730                         goto bad;
  731                 /*
  732                  * At this point, we know we're at the end of the
  733                  * pathname.  If creating / renaming, we can consider
  734                  * allowing the file or directory to be created / renamed,
  735                  * provided we're not on a read-only filesystem.
  736                  */
  737                 if (rdonly) {
  738                         error = EROFS;
  739                         goto bad;
  740                 }
  741                 /* trailing slash only allowed for directories */
  742                 if ((cnp->cn_flags & TRAILINGSLASH) &&
  743                     !(cnp->cn_flags & WILLBEDIR)) {
  744                         error = ENOENT;
  745                         goto bad;
  746                 }
  747                 if ((cnp->cn_flags & LOCKPARENT) == 0)
  748                         VOP_UNLOCK(dp, 0);
  749                 /*
  750                  * We return with ni_vp NULL to indicate that the entry
  751                  * doesn't currently exist, leaving a pointer to the
  752                  * (possibly locked) directory vnode in ndp->ni_dvp.
  753                  */
  754                 if (cnp->cn_flags & SAVESTART) {
  755                         ndp->ni_startdir = ndp->ni_dvp;
  756                         VREF(ndp->ni_startdir);
  757                 }
  758                 goto success;
  759         } else
  760                 cnp->cn_lkflags = lkflags_save;
  761 #ifdef NAMEI_DIAGNOSTIC
  762         printf("found\n");
  763 #endif
  764         /*
  765          * Take into account any additional components consumed by
  766          * the underlying filesystem.
  767          */
  768         if (cnp->cn_consume > 0) {
  769                 cnp->cn_nameptr += cnp->cn_consume;
  770                 ndp->ni_next += cnp->cn_consume;
  771                 ndp->ni_pathlen -= cnp->cn_consume;
  772                 cnp->cn_consume = 0;
  773         }
  774 
  775         dp = ndp->ni_vp;
  776 
  777         /*
  778          * Check to see if the vnode has been mounted on;
  779          * if so find the root of the mounted filesystem.
  780          */
  781         while (dp->v_type == VDIR && (mp = dp->v_mountedhere) &&
  782                (cnp->cn_flags & NOCROSSMOUNT) == 0) {
  783                 if (vfs_busy(mp, 0))
  784                         continue;
  785                 vput(dp);
  786                 if (dp != ndp->ni_dvp)
  787                         vput(ndp->ni_dvp);
  788                 else
  789                         vrele(ndp->ni_dvp);
  790                 vref(vp_crossmp);
  791                 ndp->ni_dvp = vp_crossmp;
  792                 error = VFS_ROOT(mp, compute_cn_lkflags(mp, cnp->cn_lkflags,
  793                     cnp->cn_flags), &tdp);
  794                 vfs_unbusy(mp);
  795                 if (vn_lock(vp_crossmp, LK_SHARED | LK_NOWAIT))
  796                         panic("vp_crossmp exclusively locked or reclaimed");
  797                 if (error) {
  798                         dpunlocked = 1;
  799                         goto bad2;
  800                 }
  801                 ndp->ni_vp = dp = tdp;
  802         }
  803 
  804         /*
  805          * Check for symbolic link
  806          */
  807         if ((dp->v_type == VLNK) &&
  808             ((cnp->cn_flags & FOLLOW) || (cnp->cn_flags & TRAILINGSLASH) ||
  809              *ndp->ni_next == '/')) {
  810                 cnp->cn_flags |= ISSYMLINK;
  811                 if (dp->v_iflag & VI_DOOMED) {
  812                         /*
  813                          * We can't know whether the directory was mounted with
  814                          * NOSYMFOLLOW, so we can't follow safely.
  815                          */
  816                         error = ENOENT;
  817                         goto bad2;
  818                 }
  819                 if (dp->v_mount->mnt_flag & MNT_NOSYMFOLLOW) {
  820                         error = EACCES;
  821                         goto bad2;
  822                 }
  823                 /*
  824                  * Symlink code always expects an unlocked dvp.
  825                  */
  826                 if (ndp->ni_dvp != ndp->ni_vp) {
  827                         VOP_UNLOCK(ndp->ni_dvp, 0);
  828                         ni_dvp_unlocked = 1;
  829                 }
  830                 goto success;
  831         }
  832 
  833 nextname:
  834         /*
  835          * Not a symbolic link that we will follow.  Continue with the
  836          * next component if there is any; otherwise, we're done.
  837          */
  838         KASSERT((cnp->cn_flags & ISLASTCN) || *ndp->ni_next == '/',
  839             ("lookup: invalid path state."));
  840         if (*ndp->ni_next == '/') {
  841                 cnp->cn_nameptr = ndp->ni_next;
  842                 while (*cnp->cn_nameptr == '/') {
  843                         cnp->cn_nameptr++;
  844                         ndp->ni_pathlen--;
  845                 }
  846                 if (ndp->ni_dvp != dp)
  847                         vput(ndp->ni_dvp);
  848                 else
  849                         vrele(ndp->ni_dvp);
  850                 goto dirloop;
  851         }
  852         /*
  853          * If we're processing a path with a trailing slash,
  854          * check that the end result is a directory.
  855          */
  856         if ((cnp->cn_flags & TRAILINGSLASH) && dp->v_type != VDIR) {
  857                 error = ENOTDIR;
  858                 goto bad2;
  859         }
  860         /*
  861          * Disallow directory write attempts on read-only filesystems.
  862          */
  863         if (rdonly &&
  864             (cnp->cn_nameiop == DELETE || cnp->cn_nameiop == RENAME)) {
  865                 error = EROFS;
  866                 goto bad2;
  867         }
  868         if (cnp->cn_flags & SAVESTART) {
  869                 ndp->ni_startdir = ndp->ni_dvp;
  870                 VREF(ndp->ni_startdir);
  871         }
  872         if (!wantparent) {
  873                 ni_dvp_unlocked = 2;
  874                 if (ndp->ni_dvp != dp)
  875                         vput(ndp->ni_dvp);
  876                 else
  877                         vrele(ndp->ni_dvp);
  878         } else if ((cnp->cn_flags & LOCKPARENT) == 0 && ndp->ni_dvp != dp) {
  879                 VOP_UNLOCK(ndp->ni_dvp, 0);
  880                 ni_dvp_unlocked = 1;
  881         }
  882 
  883         if (cnp->cn_flags & AUDITVNODE1)
  884                 AUDIT_ARG_VNODE1(dp);
  885         else if (cnp->cn_flags & AUDITVNODE2)
  886                 AUDIT_ARG_VNODE2(dp);
  887 
  888         if ((cnp->cn_flags & LOCKLEAF) == 0)
  889                 VOP_UNLOCK(dp, 0);
  890 success:
  891         /*
  892          * Because of lookup_shared we may have the vnode shared locked, but
  893          * the caller may want it to be exclusively locked.
  894          */
  895         if (needs_exclusive_leaf(dp->v_mount, cnp->cn_flags) &&
  896             VOP_ISLOCKED(dp) != LK_EXCLUSIVE) {
  897                 vn_lock(dp, LK_UPGRADE | LK_RETRY);
  898                 if (dp->v_iflag & VI_DOOMED) {
  899                         error = ENOENT;
  900                         goto bad2;
  901                 }
  902         }
  903         return (0);
  904 
  905 bad2:
  906         if (ni_dvp_unlocked != 2) {
  907                 if (dp != ndp->ni_dvp && !ni_dvp_unlocked)
  908                         vput(ndp->ni_dvp);
  909                 else
  910                         vrele(ndp->ni_dvp);
  911         }
  912 bad:
  913         if (!dpunlocked)
  914                 vput(dp);
  915         ndp->ni_vp = NULL;
  916         return (error);
  917 }
  918 
  919 /*
  920  * relookup - lookup a path name component
  921  *    Used by lookup to re-acquire things.
  922  */
  923 int
  924 relookup(struct vnode *dvp, struct vnode **vpp, struct componentname *cnp)
  925 {
  926         struct vnode *dp = 0;           /* the directory we are searching */
  927         int wantparent;                 /* 1 => wantparent or lockparent flag */
  928         int rdonly;                     /* lookup read-only flag bit */
  929         int error = 0;
  930 
  931         KASSERT(cnp->cn_flags & ISLASTCN,
  932             ("relookup: Not given last component."));
  933         /*
  934          * Setup: break out flag bits into variables.
  935          */
  936         wantparent = cnp->cn_flags & (LOCKPARENT|WANTPARENT);
  937         KASSERT(wantparent, ("relookup: parent not wanted."));
  938         rdonly = cnp->cn_flags & RDONLY;
  939         cnp->cn_flags &= ~ISSYMLINK;
  940         dp = dvp;
  941         cnp->cn_lkflags = LK_EXCLUSIVE;
  942         vn_lock(dp, LK_EXCLUSIVE | LK_RETRY);
  943 
  944         /*
  945          * Search a new directory.
  946          *
  947          * The last component of the filename is left accessible via
  948          * cnp->cn_nameptr for callers that need the name. Callers needing
  949          * the name set the SAVENAME flag. When done, they assume
  950          * responsibility for freeing the pathname buffer.
  951          */
  952 #ifdef NAMEI_DIAGNOSTIC
  953         printf("{%s}: ", cnp->cn_nameptr);
  954 #endif
  955 
  956         /*
  957          * Check for "" which represents the root directory after slash
  958          * removal.
  959          */
  960         if (cnp->cn_nameptr[0] == '\0') {
  961                 /*
  962                  * Support only LOOKUP for "/" because lookup()
  963                  * can't succeed for CREATE, DELETE and RENAME.
  964                  */
  965                 KASSERT(cnp->cn_nameiop == LOOKUP, ("nameiop must be LOOKUP"));
  966                 KASSERT(dp->v_type == VDIR, ("dp is not a directory"));
  967 
  968                 if (!(cnp->cn_flags & LOCKLEAF))
  969                         VOP_UNLOCK(dp, 0);
  970                 *vpp = dp;
  971                 /* XXX This should probably move to the top of function. */
  972                 if (cnp->cn_flags & SAVESTART)
  973                         panic("lookup: SAVESTART");
  974                 return (0);
  975         }
  976 
  977         if (cnp->cn_flags & ISDOTDOT)
  978                 panic ("relookup: lookup on dot-dot");
  979 
  980         /*
  981          * We now have a segment name to search for, and a directory to search.
  982          */
  983 #ifdef NAMEI_DIAGNOSTIC
  984         vprint("search in:", dp);
  985 #endif
  986         if ((error = VOP_LOOKUP(dp, vpp, cnp)) != 0) {
  987                 KASSERT(*vpp == NULL, ("leaf should be empty"));
  988                 if (error != EJUSTRETURN)
  989                         goto bad;
  990                 /*
  991                  * If creating and at end of pathname, then can consider
  992                  * allowing file to be created.
  993                  */
  994                 if (rdonly) {
  995                         error = EROFS;
  996                         goto bad;
  997                 }
  998                 /* ASSERT(dvp == ndp->ni_startdir) */
  999                 if (cnp->cn_flags & SAVESTART)
 1000                         VREF(dvp);
 1001                 if ((cnp->cn_flags & LOCKPARENT) == 0)
 1002                         VOP_UNLOCK(dp, 0);
 1003                 /*
 1004                  * We return with ni_vp NULL to indicate that the entry
 1005                  * doesn't currently exist, leaving a pointer to the
 1006                  * (possibly locked) directory vnode in ndp->ni_dvp.
 1007                  */
 1008                 return (0);
 1009         }
 1010 
 1011         dp = *vpp;
 1012 
 1013         /*
 1014          * Disallow directory write attempts on read-only filesystems.
 1015          */
 1016         if (rdonly &&
 1017             (cnp->cn_nameiop == DELETE || cnp->cn_nameiop == RENAME)) {
 1018                 if (dvp == dp)
 1019                         vrele(dvp);
 1020                 else
 1021                         vput(dvp);
 1022                 error = EROFS;
 1023                 goto bad;
 1024         }
 1025         /*
 1026          * Set the parent lock/ref state to the requested state.
 1027          */
 1028         if ((cnp->cn_flags & LOCKPARENT) == 0 && dvp != dp) {
 1029                 if (wantparent)
 1030                         VOP_UNLOCK(dvp, 0);
 1031                 else
 1032                         vput(dvp);
 1033         } else if (!wantparent)
 1034                 vrele(dvp);
 1035         /*
 1036          * Check for symbolic link
 1037          */
 1038         KASSERT(dp->v_type != VLNK || !(cnp->cn_flags & FOLLOW),
 1039             ("relookup: symlink found.\n"));
 1040 
 1041         /* ASSERT(dvp == ndp->ni_startdir) */
 1042         if (cnp->cn_flags & SAVESTART)
 1043                 VREF(dvp);
 1044         
 1045         if ((cnp->cn_flags & LOCKLEAF) == 0)
 1046                 VOP_UNLOCK(dp, 0);
 1047         return (0);
 1048 bad:
 1049         vput(dp);
 1050         *vpp = NULL;
 1051         return (error);
 1052 }
 1053 
 1054 void
 1055 NDINIT_ALL(struct nameidata *ndp, u_long op, u_long flags, enum uio_seg segflg,
 1056     const char *namep, int dirfd, struct vnode *startdir, cap_rights_t *rightsp,
 1057     struct thread *td)
 1058 {
 1059 
 1060         ndp->ni_cnd.cn_nameiop = op;
 1061         ndp->ni_cnd.cn_flags = flags;
 1062         ndp->ni_segflg = segflg;
 1063         ndp->ni_dirp = namep;
 1064         ndp->ni_dirfd = dirfd;
 1065         ndp->ni_startdir = startdir;
 1066         ndp->ni_strictrelative = 0;
 1067         if (rightsp != NULL)
 1068                 ndp->ni_rightsneeded = *rightsp;
 1069         else
 1070                 cap_rights_init(&ndp->ni_rightsneeded);
 1071         filecaps_init(&ndp->ni_filecaps);
 1072         ndp->ni_cnd.cn_thread = td;
 1073 }
 1074 
 1075 /*
 1076  * Free data allocated by namei(); see namei(9) for details.
 1077  */
 1078 void
 1079 NDFREE(struct nameidata *ndp, const u_int flags)
 1080 {
 1081         int unlock_dvp;
 1082         int unlock_vp;
 1083 
 1084         unlock_dvp = 0;
 1085         unlock_vp = 0;
 1086 
 1087         if (!(flags & NDF_NO_FREE_PNBUF) &&
 1088             (ndp->ni_cnd.cn_flags & HASBUF)) {
 1089                 uma_zfree(namei_zone, ndp->ni_cnd.cn_pnbuf);
 1090                 ndp->ni_cnd.cn_flags &= ~HASBUF;
 1091         }
 1092         if (!(flags & NDF_NO_VP_UNLOCK) &&
 1093             (ndp->ni_cnd.cn_flags & LOCKLEAF) && ndp->ni_vp)
 1094                 unlock_vp = 1;
 1095         if (!(flags & NDF_NO_VP_RELE) && ndp->ni_vp) {
 1096                 if (unlock_vp) {
 1097                         vput(ndp->ni_vp);
 1098                         unlock_vp = 0;
 1099                 } else
 1100                         vrele(ndp->ni_vp);
 1101                 ndp->ni_vp = NULL;
 1102         }
 1103         if (unlock_vp)
 1104                 VOP_UNLOCK(ndp->ni_vp, 0);
 1105         if (!(flags & NDF_NO_DVP_UNLOCK) &&
 1106             (ndp->ni_cnd.cn_flags & LOCKPARENT) &&
 1107             ndp->ni_dvp != ndp->ni_vp)
 1108                 unlock_dvp = 1;
 1109         if (!(flags & NDF_NO_DVP_RELE) &&
 1110             (ndp->ni_cnd.cn_flags & (LOCKPARENT|WANTPARENT))) {
 1111                 if (unlock_dvp) {
 1112                         vput(ndp->ni_dvp);
 1113                         unlock_dvp = 0;
 1114                 } else
 1115                         vrele(ndp->ni_dvp);
 1116                 ndp->ni_dvp = NULL;
 1117         }
 1118         if (unlock_dvp)
 1119                 VOP_UNLOCK(ndp->ni_dvp, 0);
 1120         if (!(flags & NDF_NO_STARTDIR_RELE) &&
 1121             (ndp->ni_cnd.cn_flags & SAVESTART)) {
 1122                 vrele(ndp->ni_startdir);
 1123                 ndp->ni_startdir = NULL;
 1124         }
 1125 }
 1126 
 1127 /*
 1128  * Determine if there is a suitable alternate filename under the specified
 1129  * prefix for the specified path.  If the create flag is set, then the
 1130  * alternate prefix will be used so long as the parent directory exists.
 1131  * This is used by the various compatiblity ABIs so that Linux binaries prefer
 1132  * files under /compat/linux for example.  The chosen path (whether under
 1133  * the prefix or under /) is returned in a kernel malloc'd buffer pointed
 1134  * to by pathbuf.  The caller is responsible for free'ing the buffer from
 1135  * the M_TEMP bucket if one is returned.
 1136  */
 1137 int
 1138 kern_alternate_path(struct thread *td, const char *prefix, const char *path,
 1139     enum uio_seg pathseg, char **pathbuf, int create, int dirfd)
 1140 {
 1141         struct nameidata nd, ndroot;
 1142         char *ptr, *buf, *cp;
 1143         size_t len, sz;
 1144         int error;
 1145 
 1146         buf = (char *) malloc(MAXPATHLEN, M_TEMP, M_WAITOK);
 1147         *pathbuf = buf;
 1148 
 1149         /* Copy the prefix into the new pathname as a starting point. */
 1150         len = strlcpy(buf, prefix, MAXPATHLEN);
 1151         if (len >= MAXPATHLEN) {
 1152                 *pathbuf = NULL;
 1153                 free(buf, M_TEMP);
 1154                 return (EINVAL);
 1155         }
 1156         sz = MAXPATHLEN - len;
 1157         ptr = buf + len;
 1158 
 1159         /* Append the filename to the prefix. */
 1160         if (pathseg == UIO_SYSSPACE)
 1161                 error = copystr(path, ptr, sz, &len);
 1162         else
 1163                 error = copyinstr(path, ptr, sz, &len);
 1164 
 1165         if (error) {
 1166                 *pathbuf = NULL;
 1167                 free(buf, M_TEMP);
 1168                 return (error);
 1169         }
 1170 
 1171         /* Only use a prefix with absolute pathnames. */
 1172         if (*ptr != '/') {
 1173                 error = EINVAL;
 1174                 goto keeporig;
 1175         }
 1176 
 1177         if (dirfd != AT_FDCWD) {
 1178                 /*
 1179                  * We want the original because the "prefix" is
 1180                  * included in the already opened dirfd.
 1181                  */
 1182                 bcopy(ptr, buf, len);
 1183                 return (0);
 1184         }
 1185 
 1186         /*
 1187          * We know that there is a / somewhere in this pathname.
 1188          * Search backwards for it, to find the file's parent dir
 1189          * to see if it exists in the alternate tree. If it does,
 1190          * and we want to create a file (cflag is set). We don't
 1191          * need to worry about the root comparison in this case.
 1192          */
 1193 
 1194         if (create) {
 1195                 for (cp = &ptr[len] - 1; *cp != '/'; cp--);
 1196                 *cp = '\0';
 1197 
 1198                 NDINIT(&nd, LOOKUP, FOLLOW, UIO_SYSSPACE, buf, td);
 1199                 error = namei(&nd);
 1200                 *cp = '/';
 1201                 if (error != 0)
 1202                         goto keeporig;
 1203         } else {
 1204                 NDINIT(&nd, LOOKUP, FOLLOW, UIO_SYSSPACE, buf, td);
 1205 
 1206                 error = namei(&nd);
 1207                 if (error != 0)
 1208                         goto keeporig;
 1209 
 1210                 /*
 1211                  * We now compare the vnode of the prefix to the one
 1212                  * vnode asked. If they resolve to be the same, then we
 1213                  * ignore the match so that the real root gets used.
 1214                  * This avoids the problem of traversing "../.." to find the
 1215                  * root directory and never finding it, because "/" resolves
 1216                  * to the emulation root directory. This is expensive :-(
 1217                  */
 1218                 NDINIT(&ndroot, LOOKUP, FOLLOW, UIO_SYSSPACE, prefix,
 1219                     td);
 1220 
 1221                 /* We shouldn't ever get an error from this namei(). */
 1222                 error = namei(&ndroot);
 1223                 if (error == 0) {
 1224                         if (nd.ni_vp == ndroot.ni_vp)
 1225                                 error = ENOENT;
 1226 
 1227                         NDFREE(&ndroot, NDF_ONLY_PNBUF);
 1228                         vrele(ndroot.ni_vp);
 1229                 }
 1230         }
 1231 
 1232         NDFREE(&nd, NDF_ONLY_PNBUF);
 1233         vrele(nd.ni_vp);
 1234 
 1235 keeporig:
 1236         /* If there was an error, use the original path name. */
 1237         if (error)
 1238                 bcopy(ptr, buf, len);
 1239         return (error);
 1240 }

Cache object: 3db63205a5b476fc35c0f7bd79c197fc


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.