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-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10
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$"); 39 40 #include "opt_ktrace.h" 41 #include "opt_mac.h" 42 43 #include <sys/param.h> 44 #include <sys/systm.h> 45 #include <sys/kernel.h> 46 #include <sys/lock.h> 47 #include <sys/mutex.h> 48 #include <sys/namei.h> 49 #include <sys/vnode.h> 50 #include <sys/mount.h> 51 #include <sys/filedesc.h> 52 #include <sys/proc.h> 53 #include <sys/syscallsubr.h> 54 #include <sys/sysctl.h> 55 #ifdef KTRACE 56 #include <sys/ktrace.h> 57 #endif 58 59 #include <security/audit/audit.h> 60 #include <security/mac/mac_framework.h> 61 62 #include <vm/uma.h> 63 64 #define NAMEI_DIAGNOSTIC 1 65 #undef NAMEI_DIAGNOSTIC 66 67 /* 68 * Allocation zone for namei 69 */ 70 uma_zone_t namei_zone; 71 /* 72 * Placeholder vnode for mp traversal 73 */ 74 static struct vnode *vp_crossmp; 75 76 static void 77 nameiinit(void *dummy __unused) 78 { 79 int error; 80 81 namei_zone = uma_zcreate("NAMEI", MAXPATHLEN, NULL, NULL, NULL, NULL, 82 UMA_ALIGN_PTR, 0); 83 error = getnewvnode("crossmp", NULL, &dead_vnodeops, &vp_crossmp); 84 if (error != 0) 85 panic("nameiinit: getnewvnode"); 86 vp_crossmp->v_vnlock->lk_flags &= ~LK_NOSHARE; 87 } 88 SYSINIT(vfs, SI_SUB_VFS, SI_ORDER_SECOND, nameiinit, NULL); 89 90 static int lookup_shared = 0; 91 SYSCTL_INT(_vfs, OID_AUTO, lookup_shared, CTLFLAG_RW, &lookup_shared, 0, 92 "Enables/Disables shared locks for path name translation"); 93 TUNABLE_INT("vfs.lookup_shared", &lookup_shared); 94 95 /* 96 * Convert a pathname into a pointer to a locked vnode. 97 * 98 * The FOLLOW flag is set when symbolic links are to be followed 99 * when they occur at the end of the name translation process. 100 * Symbolic links are always followed for all other pathname 101 * components other than the last. 102 * 103 * The segflg defines whether the name is to be copied from user 104 * space or kernel space. 105 * 106 * Overall outline of namei: 107 * 108 * copy in name 109 * get starting directory 110 * while (!done && !error) { 111 * call lookup to search path. 112 * if symbolic link, massage name in buffer and continue 113 * } 114 */ 115 int 116 namei(struct nameidata *ndp) 117 { 118 struct filedesc *fdp; /* pointer to file descriptor state */ 119 char *cp; /* pointer into pathname argument */ 120 struct vnode *dp; /* the directory we are searching */ 121 struct iovec aiov; /* uio for reading symbolic links */ 122 struct uio auio; 123 int error, linklen; 124 struct componentname *cnp = &ndp->ni_cnd; 125 struct thread *td = cnp->cn_thread; 126 struct proc *p = td->td_proc; 127 int vfslocked; 128 129 KASSERT((cnp->cn_flags & MPSAFE) != 0 || mtx_owned(&Giant) != 0, 130 ("NOT MPSAFE and Giant not held")); 131 ndp->ni_cnd.cn_cred = ndp->ni_cnd.cn_thread->td_ucred; 132 KASSERT(cnp->cn_cred && p, ("namei: bad cred/proc")); 133 KASSERT((cnp->cn_nameiop & (~OPMASK)) == 0, 134 ("namei: nameiop contaminated with flags")); 135 KASSERT((cnp->cn_flags & OPMASK) == 0, 136 ("namei: flags contaminated with nameiops")); 137 if (!lookup_shared) 138 cnp->cn_flags &= ~LOCKSHARED; 139 fdp = p->p_fd; 140 141 /* 142 * Get a buffer for the name to be translated, and copy the 143 * name into the buffer. 144 */ 145 if ((cnp->cn_flags & HASBUF) == 0) 146 cnp->cn_pnbuf = uma_zalloc(namei_zone, M_WAITOK); 147 if (ndp->ni_segflg == UIO_SYSSPACE) 148 error = copystr(ndp->ni_dirp, cnp->cn_pnbuf, 149 MAXPATHLEN, (size_t *)&ndp->ni_pathlen); 150 else 151 error = copyinstr(ndp->ni_dirp, cnp->cn_pnbuf, 152 MAXPATHLEN, (size_t *)&ndp->ni_pathlen); 153 154 /* If we are auditing the kernel pathname, save the user pathname. */ 155 if (cnp->cn_flags & AUDITVNODE1) 156 AUDIT_ARG(upath, td, cnp->cn_pnbuf, ARG_UPATH1); 157 if (cnp->cn_flags & AUDITVNODE2) 158 AUDIT_ARG(upath, td, cnp->cn_pnbuf, ARG_UPATH2); 159 160 /* 161 * Don't allow empty pathnames. 162 */ 163 if (!error && *cnp->cn_pnbuf == '\0') 164 error = ENOENT; 165 166 if (error) { 167 uma_zfree(namei_zone, cnp->cn_pnbuf); 168 #ifdef DIAGNOSTIC 169 cnp->cn_pnbuf = NULL; 170 cnp->cn_nameptr = NULL; 171 #endif 172 ndp->ni_vp = NULL; 173 return (error); 174 } 175 ndp->ni_loopcnt = 0; 176 #ifdef KTRACE 177 if (KTRPOINT(td, KTR_NAMEI)) { 178 KASSERT(cnp->cn_thread == curthread, 179 ("namei not using curthread")); 180 ktrnamei(cnp->cn_pnbuf); 181 } 182 #endif 183 184 /* 185 * Get starting point for the translation. 186 */ 187 FILEDESC_SLOCK(fdp); 188 ndp->ni_rootdir = fdp->fd_rdir; 189 ndp->ni_topdir = fdp->fd_jdir; 190 191 dp = fdp->fd_cdir; 192 vfslocked = VFS_LOCK_GIANT(dp->v_mount); 193 VREF(dp); 194 FILEDESC_SUNLOCK(fdp); 195 for (;;) { 196 /* 197 * Check if root directory should replace current directory. 198 * Done at start of translation and after symbolic link. 199 */ 200 cnp->cn_nameptr = cnp->cn_pnbuf; 201 if (*(cnp->cn_nameptr) == '/') { 202 vrele(dp); 203 VFS_UNLOCK_GIANT(vfslocked); 204 while (*(cnp->cn_nameptr) == '/') { 205 cnp->cn_nameptr++; 206 ndp->ni_pathlen--; 207 } 208 dp = ndp->ni_rootdir; 209 vfslocked = VFS_LOCK_GIANT(dp->v_mount); 210 VREF(dp); 211 } 212 if (vfslocked) 213 ndp->ni_cnd.cn_flags |= GIANTHELD; 214 ndp->ni_startdir = dp; 215 error = lookup(ndp); 216 if (error) { 217 uma_zfree(namei_zone, cnp->cn_pnbuf); 218 #ifdef DIAGNOSTIC 219 cnp->cn_pnbuf = NULL; 220 cnp->cn_nameptr = NULL; 221 #endif 222 return (error); 223 } 224 vfslocked = (ndp->ni_cnd.cn_flags & GIANTHELD) != 0; 225 ndp->ni_cnd.cn_flags &= ~GIANTHELD; 226 /* 227 * Check for symbolic link 228 */ 229 if ((cnp->cn_flags & ISSYMLINK) == 0) { 230 if ((cnp->cn_flags & (SAVENAME | SAVESTART)) == 0) { 231 uma_zfree(namei_zone, cnp->cn_pnbuf); 232 #ifdef DIAGNOSTIC 233 cnp->cn_pnbuf = NULL; 234 cnp->cn_nameptr = NULL; 235 #endif 236 } else 237 cnp->cn_flags |= HASBUF; 238 239 if ((cnp->cn_flags & MPSAFE) == 0) { 240 VFS_UNLOCK_GIANT(vfslocked); 241 } else if (vfslocked) 242 ndp->ni_cnd.cn_flags |= GIANTHELD; 243 return (0); 244 } 245 if (ndp->ni_loopcnt++ >= MAXSYMLINKS) { 246 error = ELOOP; 247 break; 248 } 249 #ifdef MAC 250 if ((cnp->cn_flags & NOMACCHECK) == 0) { 251 error = mac_check_vnode_readlink(td->td_ucred, 252 ndp->ni_vp); 253 if (error) 254 break; 255 } 256 #endif 257 if (ndp->ni_pathlen > 1) 258 cp = uma_zalloc(namei_zone, M_WAITOK); 259 else 260 cp = cnp->cn_pnbuf; 261 aiov.iov_base = cp; 262 aiov.iov_len = MAXPATHLEN; 263 auio.uio_iov = &aiov; 264 auio.uio_iovcnt = 1; 265 auio.uio_offset = 0; 266 auio.uio_rw = UIO_READ; 267 auio.uio_segflg = UIO_SYSSPACE; 268 auio.uio_td = (struct thread *)0; 269 auio.uio_resid = MAXPATHLEN; 270 error = VOP_READLINK(ndp->ni_vp, &auio, cnp->cn_cred); 271 if (error) { 272 if (ndp->ni_pathlen > 1) 273 uma_zfree(namei_zone, cp); 274 break; 275 } 276 linklen = MAXPATHLEN - auio.uio_resid; 277 if (linklen == 0) { 278 if (ndp->ni_pathlen > 1) 279 uma_zfree(namei_zone, cp); 280 error = ENOENT; 281 break; 282 } 283 if (linklen + ndp->ni_pathlen >= MAXPATHLEN) { 284 if (ndp->ni_pathlen > 1) 285 uma_zfree(namei_zone, cp); 286 error = ENAMETOOLONG; 287 break; 288 } 289 if (ndp->ni_pathlen > 1) { 290 bcopy(ndp->ni_next, cp + linklen, ndp->ni_pathlen); 291 uma_zfree(namei_zone, cnp->cn_pnbuf); 292 cnp->cn_pnbuf = cp; 293 } else 294 cnp->cn_pnbuf[linklen] = '\0'; 295 ndp->ni_pathlen += linklen; 296 vput(ndp->ni_vp); 297 dp = ndp->ni_dvp; 298 } 299 uma_zfree(namei_zone, cnp->cn_pnbuf); 300 #ifdef DIAGNOSTIC 301 cnp->cn_pnbuf = NULL; 302 cnp->cn_nameptr = NULL; 303 #endif 304 vput(ndp->ni_vp); 305 ndp->ni_vp = NULL; 306 vrele(ndp->ni_dvp); 307 VFS_UNLOCK_GIANT(vfslocked); 308 return (error); 309 } 310 311 static int 312 compute_cn_lkflags(struct mount *mp, int lkflags) 313 { 314 if (mp == NULL || 315 ((lkflags & LK_SHARED) && !(mp->mnt_kern_flag & MNTK_LOOKUP_SHARED))) { 316 lkflags &= ~LK_SHARED; 317 lkflags |= LK_EXCLUSIVE; 318 } 319 return lkflags; 320 } 321 322 /* 323 * Search a pathname. 324 * This is a very central and rather complicated routine. 325 * 326 * The pathname is pointed to by ni_ptr and is of length ni_pathlen. 327 * The starting directory is taken from ni_startdir. The pathname is 328 * descended until done, or a symbolic link is encountered. The variable 329 * ni_more is clear if the path is completed; it is set to one if a 330 * symbolic link needing interpretation is encountered. 331 * 332 * The flag argument is LOOKUP, CREATE, RENAME, or DELETE depending on 333 * whether the name is to be looked up, created, renamed, or deleted. 334 * When CREATE, RENAME, or DELETE is specified, information usable in 335 * creating, renaming, or deleting a directory entry may be calculated. 336 * If flag has LOCKPARENT or'ed into it, the parent directory is returned 337 * locked. If flag has WANTPARENT or'ed into it, the parent directory is 338 * returned unlocked. Otherwise the parent directory is not returned. If 339 * the target of the pathname exists and LOCKLEAF is or'ed into the flag 340 * the target is returned locked, otherwise it is returned unlocked. 341 * When creating or renaming and LOCKPARENT is specified, the target may not 342 * be ".". When deleting and LOCKPARENT is specified, the target may be ".". 343 * 344 * Overall outline of lookup: 345 * 346 * dirloop: 347 * identify next component of name at ndp->ni_ptr 348 * handle degenerate case where name is null string 349 * if .. and crossing mount points and on mounted filesys, find parent 350 * call VOP_LOOKUP routine for next component name 351 * directory vnode returned in ni_dvp, unlocked unless LOCKPARENT set 352 * component vnode returned in ni_vp (if it exists), locked. 353 * if result vnode is mounted on and crossing mount points, 354 * find mounted on vnode 355 * if more components of name, do next level at dirloop 356 * return the answer in ni_vp, locked if LOCKLEAF set 357 * if LOCKPARENT set, return locked parent in ni_dvp 358 * if WANTPARENT set, return unlocked parent in ni_dvp 359 */ 360 int 361 lookup(struct nameidata *ndp) 362 { 363 char *cp; /* pointer into pathname argument */ 364 struct vnode *dp = 0; /* the directory we are searching */ 365 struct vnode *tdp; /* saved dp */ 366 struct mount *mp; /* mount table entry */ 367 int docache; /* == 0 do not cache last component */ 368 int wantparent; /* 1 => wantparent or lockparent flag */ 369 int rdonly; /* lookup read-only flag bit */ 370 int trailing_slash; 371 int error = 0; 372 int dpunlocked = 0; /* dp has already been unlocked */ 373 struct componentname *cnp = &ndp->ni_cnd; 374 struct thread *td = cnp->cn_thread; 375 int vfslocked; /* VFS Giant state for child */ 376 int dvfslocked; /* VFS Giant state for parent */ 377 int tvfslocked; 378 int lkflags_save; 379 380 /* 381 * Setup: break out flag bits into variables. 382 */ 383 dvfslocked = (ndp->ni_cnd.cn_flags & GIANTHELD) != 0; 384 vfslocked = 0; 385 ndp->ni_cnd.cn_flags &= ~GIANTHELD; 386 wantparent = cnp->cn_flags & (LOCKPARENT | WANTPARENT); 387 KASSERT(cnp->cn_nameiop == LOOKUP || wantparent, 388 ("CREATE, DELETE, RENAME require LOCKPARENT or WANTPARENT.")); 389 docache = (cnp->cn_flags & NOCACHE) ^ NOCACHE; 390 if (cnp->cn_nameiop == DELETE || 391 (wantparent && cnp->cn_nameiop != CREATE && 392 cnp->cn_nameiop != LOOKUP)) 393 docache = 0; 394 rdonly = cnp->cn_flags & RDONLY; 395 cnp->cn_flags &= ~ISSYMLINK; 396 ndp->ni_dvp = NULL; 397 /* 398 * We use shared locks until we hit the parent of the last cn then 399 * we adjust based on the requesting flags. 400 */ 401 if (lookup_shared) 402 cnp->cn_lkflags = LK_SHARED; 403 else 404 cnp->cn_lkflags = LK_EXCLUSIVE; 405 dp = ndp->ni_startdir; 406 ndp->ni_startdir = NULLVP; 407 vn_lock(dp, compute_cn_lkflags(dp->v_mount, cnp->cn_lkflags | LK_RETRY), td); 408 409 dirloop: 410 /* 411 * Search a new directory. 412 * 413 * The last component of the filename is left accessible via 414 * cnp->cn_nameptr for callers that need the name. Callers needing 415 * the name set the SAVENAME flag. When done, they assume 416 * responsibility for freeing the pathname buffer. 417 */ 418 cnp->cn_consume = 0; 419 for (cp = cnp->cn_nameptr; *cp != 0 && *cp != '/'; cp++) 420 continue; 421 cnp->cn_namelen = cp - cnp->cn_nameptr; 422 if (cnp->cn_namelen > NAME_MAX) { 423 error = ENAMETOOLONG; 424 goto bad; 425 } 426 #ifdef NAMEI_DIAGNOSTIC 427 { char c = *cp; 428 *cp = '\0'; 429 printf("{%s}: ", cnp->cn_nameptr); 430 *cp = c; } 431 #endif 432 ndp->ni_pathlen -= cnp->cn_namelen; 433 ndp->ni_next = cp; 434 435 /* 436 * Replace multiple slashes by a single slash and trailing slashes 437 * by a null. This must be done before VOP_LOOKUP() because some 438 * fs's don't know about trailing slashes. Remember if there were 439 * trailing slashes to handle symlinks, existing non-directories 440 * and non-existing files that won't be directories specially later. 441 */ 442 trailing_slash = 0; 443 while (*cp == '/' && (cp[1] == '/' || cp[1] == '\0')) { 444 cp++; 445 ndp->ni_pathlen--; 446 if (*cp == '\0') { 447 trailing_slash = 1; 448 *ndp->ni_next = '\0'; /* XXX for direnter() ... */ 449 } 450 } 451 ndp->ni_next = cp; 452 453 cnp->cn_flags |= MAKEENTRY; 454 if (*cp == '\0' && docache == 0) 455 cnp->cn_flags &= ~MAKEENTRY; 456 if (cnp->cn_namelen == 2 && 457 cnp->cn_nameptr[1] == '.' && cnp->cn_nameptr[0] == '.') 458 cnp->cn_flags |= ISDOTDOT; 459 else 460 cnp->cn_flags &= ~ISDOTDOT; 461 if (*ndp->ni_next == 0) 462 cnp->cn_flags |= ISLASTCN; 463 else 464 cnp->cn_flags &= ~ISLASTCN; 465 466 467 /* 468 * Check for degenerate name (e.g. / or "") 469 * which is a way of talking about a directory, 470 * e.g. like "/." or ".". 471 */ 472 if (cnp->cn_nameptr[0] == '\0') { 473 if (dp->v_type != VDIR) { 474 error = ENOTDIR; 475 goto bad; 476 } 477 if (cnp->cn_nameiop != LOOKUP) { 478 error = EISDIR; 479 goto bad; 480 } 481 if (wantparent) { 482 ndp->ni_dvp = dp; 483 VREF(dp); 484 } 485 ndp->ni_vp = dp; 486 487 if (cnp->cn_flags & AUDITVNODE1) 488 AUDIT_ARG(vnode, dp, ARG_VNODE1); 489 else if (cnp->cn_flags & AUDITVNODE2) 490 AUDIT_ARG(vnode, dp, ARG_VNODE2); 491 492 if (!(cnp->cn_flags & (LOCKPARENT | LOCKLEAF))) 493 VOP_UNLOCK(dp, 0, td); 494 /* XXX This should probably move to the top of function. */ 495 if (cnp->cn_flags & SAVESTART) 496 panic("lookup: SAVESTART"); 497 goto success; 498 } 499 500 /* 501 * Handle "..": four special cases. 502 * 1. Return an error if this is the last component of 503 * the name and the operation is DELETE or RENAME. 504 * 2. If at root directory (e.g. after chroot) 505 * or at absolute root directory 506 * then ignore it so can't get out. 507 * 3. If this vnode is the root of a mounted 508 * filesystem, then replace it with the 509 * vnode which was mounted on so we take the 510 * .. in the other filesystem. 511 * 4. If the vnode is the top directory of 512 * the jail or chroot, don't let them out. 513 */ 514 if (cnp->cn_flags & ISDOTDOT) { 515 if ((cnp->cn_flags & ISLASTCN) != 0 && 516 (cnp->cn_nameiop == DELETE || cnp->cn_nameiop == RENAME)) { 517 error = EINVAL; 518 goto bad; 519 } 520 for (;;) { 521 if (dp == ndp->ni_rootdir || 522 dp == ndp->ni_topdir || 523 dp == rootvnode || 524 ((dp->v_vflag & VV_ROOT) != 0 && 525 (cnp->cn_flags & NOCROSSMOUNT) != 0)) { 526 ndp->ni_dvp = dp; 527 ndp->ni_vp = dp; 528 vfslocked = VFS_LOCK_GIANT(dp->v_mount); 529 VREF(dp); 530 goto nextname; 531 } 532 if ((dp->v_vflag & VV_ROOT) == 0) 533 break; 534 if (dp->v_iflag & VI_DOOMED) { /* forced unmount */ 535 error = EBADF; 536 goto bad; 537 } 538 tdp = dp; 539 dp = dp->v_mount->mnt_vnodecovered; 540 tvfslocked = dvfslocked; 541 dvfslocked = VFS_LOCK_GIANT(dp->v_mount); 542 VREF(dp); 543 vput(tdp); 544 VFS_UNLOCK_GIANT(tvfslocked); 545 vn_lock(dp, compute_cn_lkflags(dp->v_mount, cnp->cn_lkflags | LK_RETRY), td); 546 } 547 } 548 549 /* 550 * We now have a segment name to search for, and a directory to search. 551 */ 552 unionlookup: 553 #ifdef MAC 554 if ((cnp->cn_flags & NOMACCHECK) == 0) { 555 error = mac_check_vnode_lookup(td->td_ucred, dp, cnp); 556 if (error) 557 goto bad; 558 } 559 #endif 560 ndp->ni_dvp = dp; 561 ndp->ni_vp = NULL; 562 ASSERT_VOP_LOCKED(dp, "lookup"); 563 VNASSERT(vfslocked == 0, dp, ("lookup: vfslocked %d", vfslocked)); 564 /* 565 * If we have a shared lock we may need to upgrade the lock for the 566 * last operation. 567 */ 568 if (dp != vp_crossmp && 569 VOP_ISLOCKED(dp, td) == LK_SHARED && 570 (cnp->cn_flags & ISLASTCN) && (cnp->cn_flags & LOCKPARENT)) 571 vn_lock(dp, LK_UPGRADE|LK_RETRY, td); 572 /* 573 * If we're looking up the last component and we need an exclusive 574 * lock, adjust our lkflags. 575 */ 576 if ((cnp->cn_flags & (ISLASTCN|LOCKSHARED|LOCKLEAF)) == 577 (ISLASTCN|LOCKLEAF)) 578 cnp->cn_lkflags = LK_EXCLUSIVE; 579 #ifdef NAMEI_DIAGNOSTIC 580 vprint("lookup in", dp); 581 #endif 582 lkflags_save = cnp->cn_lkflags; 583 cnp->cn_lkflags = compute_cn_lkflags(dp->v_mount, cnp->cn_lkflags); 584 if ((error = VOP_LOOKUP(dp, &ndp->ni_vp, cnp)) != 0) { 585 cnp->cn_lkflags = lkflags_save; 586 KASSERT(ndp->ni_vp == NULL, ("leaf should be empty")); 587 #ifdef NAMEI_DIAGNOSTIC 588 printf("not found\n"); 589 #endif 590 if ((error == ENOENT) && 591 (dp->v_vflag & VV_ROOT) && (dp->v_mount != NULL) && 592 (dp->v_mount->mnt_flag & MNT_UNION)) { 593 tdp = dp; 594 dp = dp->v_mount->mnt_vnodecovered; 595 tvfslocked = dvfslocked; 596 dvfslocked = VFS_LOCK_GIANT(dp->v_mount); 597 VREF(dp); 598 vput(tdp); 599 VFS_UNLOCK_GIANT(tvfslocked); 600 vn_lock(dp, compute_cn_lkflags(dp->v_mount, cnp->cn_lkflags | LK_RETRY), td); 601 goto unionlookup; 602 } 603 604 if (error != EJUSTRETURN) 605 goto bad; 606 /* 607 * If creating and at end of pathname, then can consider 608 * allowing file to be created. 609 */ 610 if (rdonly) { 611 error = EROFS; 612 goto bad; 613 } 614 if (*cp == '\0' && trailing_slash && 615 !(cnp->cn_flags & WILLBEDIR)) { 616 error = ENOENT; 617 goto bad; 618 } 619 if ((cnp->cn_flags & LOCKPARENT) == 0) 620 VOP_UNLOCK(dp, 0, td); 621 /* 622 * This is a temporary assert to make sure I know what the 623 * behavior here was. 624 */ 625 KASSERT((cnp->cn_flags & (WANTPARENT|LOCKPARENT)) != 0, 626 ("lookup: Unhandled case.")); 627 /* 628 * We return with ni_vp NULL to indicate that the entry 629 * doesn't currently exist, leaving a pointer to the 630 * (possibly locked) directory vnode in ndp->ni_dvp. 631 */ 632 if (cnp->cn_flags & SAVESTART) { 633 ndp->ni_startdir = ndp->ni_dvp; 634 VREF(ndp->ni_startdir); 635 } 636 goto success; 637 } else 638 cnp->cn_lkflags = lkflags_save; 639 #ifdef NAMEI_DIAGNOSTIC 640 printf("found\n"); 641 #endif 642 /* 643 * Take into account any additional components consumed by 644 * the underlying filesystem. 645 */ 646 if (cnp->cn_consume > 0) { 647 cnp->cn_nameptr += cnp->cn_consume; 648 ndp->ni_next += cnp->cn_consume; 649 ndp->ni_pathlen -= cnp->cn_consume; 650 cnp->cn_consume = 0; 651 } 652 653 dp = ndp->ni_vp; 654 vfslocked = VFS_LOCK_GIANT(dp->v_mount); 655 656 /* 657 * Check to see if the vnode has been mounted on; 658 * if so find the root of the mounted filesystem. 659 */ 660 while (dp->v_type == VDIR && (mp = dp->v_mountedhere) && 661 (cnp->cn_flags & NOCROSSMOUNT) == 0) { 662 if (vfs_busy(mp, 0, 0, td)) 663 continue; 664 vput(dp); 665 VFS_UNLOCK_GIANT(vfslocked); 666 vfslocked = VFS_LOCK_GIANT(mp); 667 if (dp != ndp->ni_dvp) 668 vput(ndp->ni_dvp); 669 else 670 vrele(ndp->ni_dvp); 671 VFS_UNLOCK_GIANT(dvfslocked); 672 dvfslocked = 0; 673 vref(vp_crossmp); 674 ndp->ni_dvp = vp_crossmp; 675 error = VFS_ROOT(mp, compute_cn_lkflags(mp, cnp->cn_lkflags), &tdp, td); 676 vfs_unbusy(mp, td); 677 if (vn_lock(vp_crossmp, LK_SHARED | LK_NOWAIT, td)) 678 panic("vp_crossmp exclusively locked or reclaimed"); 679 if (error) { 680 dpunlocked = 1; 681 goto bad2; 682 } 683 ndp->ni_vp = dp = tdp; 684 } 685 686 /* 687 * Check for symbolic link 688 */ 689 if ((dp->v_type == VLNK) && 690 ((cnp->cn_flags & FOLLOW) || trailing_slash || 691 *ndp->ni_next == '/')) { 692 cnp->cn_flags |= ISSYMLINK; 693 if (dp->v_iflag & VI_DOOMED) { 694 /* We can't know whether the directory was mounted with 695 * NOSYMFOLLOW, so we can't follow safely. */ 696 error = EBADF; 697 goto bad2; 698 } 699 if (dp->v_mount->mnt_flag & MNT_NOSYMFOLLOW) { 700 error = EACCES; 701 goto bad2; 702 } 703 /* 704 * Symlink code always expects an unlocked dvp. 705 */ 706 if (ndp->ni_dvp != ndp->ni_vp) 707 VOP_UNLOCK(ndp->ni_dvp, 0, td); 708 goto success; 709 } 710 711 /* 712 * Check for bogus trailing slashes. 713 */ 714 if (trailing_slash && dp->v_type != VDIR) { 715 error = ENOTDIR; 716 goto bad2; 717 } 718 719 nextname: 720 /* 721 * Not a symbolic link. If more pathname, 722 * continue at next component, else return. 723 */ 724 KASSERT((cnp->cn_flags & ISLASTCN) || *ndp->ni_next == '/', 725 ("lookup: invalid path state.")); 726 if (*ndp->ni_next == '/') { 727 cnp->cn_nameptr = ndp->ni_next; 728 while (*cnp->cn_nameptr == '/') { 729 cnp->cn_nameptr++; 730 ndp->ni_pathlen--; 731 } 732 if (ndp->ni_dvp != dp) 733 vput(ndp->ni_dvp); 734 else 735 vrele(ndp->ni_dvp); 736 VFS_UNLOCK_GIANT(dvfslocked); 737 dvfslocked = vfslocked; /* dp becomes dvp in dirloop */ 738 vfslocked = 0; 739 goto dirloop; 740 } 741 /* 742 * Disallow directory write attempts on read-only filesystems. 743 */ 744 if (rdonly && 745 (cnp->cn_nameiop == DELETE || cnp->cn_nameiop == RENAME)) { 746 error = EROFS; 747 goto bad2; 748 } 749 if (cnp->cn_flags & SAVESTART) { 750 ndp->ni_startdir = ndp->ni_dvp; 751 VREF(ndp->ni_startdir); 752 } 753 if (!wantparent) { 754 if (ndp->ni_dvp != dp) 755 vput(ndp->ni_dvp); 756 else 757 vrele(ndp->ni_dvp); 758 VFS_UNLOCK_GIANT(dvfslocked); 759 dvfslocked = 0; 760 } else if ((cnp->cn_flags & LOCKPARENT) == 0 && ndp->ni_dvp != dp) 761 VOP_UNLOCK(ndp->ni_dvp, 0, td); 762 763 if (cnp->cn_flags & AUDITVNODE1) 764 AUDIT_ARG(vnode, dp, ARG_VNODE1); 765 else if (cnp->cn_flags & AUDITVNODE2) 766 AUDIT_ARG(vnode, dp, ARG_VNODE2); 767 768 if ((cnp->cn_flags & LOCKLEAF) == 0) 769 VOP_UNLOCK(dp, 0, td); 770 success: 771 /* 772 * Because of lookup_shared we may have the vnode shared locked, but 773 * the caller may want it to be exclusively locked. 774 */ 775 if ((cnp->cn_flags & (ISLASTCN | LOCKSHARED | LOCKLEAF)) == 776 (ISLASTCN | LOCKLEAF) && VOP_ISLOCKED(dp, td) != LK_EXCLUSIVE) { 777 vn_lock(dp, LK_UPGRADE | LK_RETRY, td); 778 if (dp->v_iflag & VI_DOOMED) { 779 error = ENOENT; 780 goto bad2; 781 } 782 } 783 if (vfslocked && dvfslocked) 784 VFS_UNLOCK_GIANT(dvfslocked); /* Only need one */ 785 if (vfslocked || dvfslocked) 786 ndp->ni_cnd.cn_flags |= GIANTHELD; 787 return (0); 788 789 bad2: 790 if (dp != ndp->ni_dvp) 791 vput(ndp->ni_dvp); 792 else 793 vrele(ndp->ni_dvp); 794 bad: 795 if (!dpunlocked) 796 vput(dp); 797 VFS_UNLOCK_GIANT(vfslocked); 798 VFS_UNLOCK_GIANT(dvfslocked); 799 ndp->ni_cnd.cn_flags &= ~GIANTHELD; 800 ndp->ni_vp = NULL; 801 return (error); 802 } 803 804 /* 805 * relookup - lookup a path name component 806 * Used by lookup to re-acquire things. 807 */ 808 int 809 relookup(struct vnode *dvp, struct vnode **vpp, struct componentname *cnp) 810 { 811 struct thread *td = cnp->cn_thread; 812 struct vnode *dp = 0; /* the directory we are searching */ 813 int wantparent; /* 1 => wantparent or lockparent flag */ 814 int rdonly; /* lookup read-only flag bit */ 815 int error = 0; 816 817 KASSERT(cnp->cn_flags & ISLASTCN, 818 ("relookup: Not given last component.")); 819 /* 820 * Setup: break out flag bits into variables. 821 */ 822 wantparent = cnp->cn_flags & (LOCKPARENT|WANTPARENT); 823 KASSERT(wantparent, ("relookup: parent not wanted.")); 824 rdonly = cnp->cn_flags & RDONLY; 825 cnp->cn_flags &= ~ISSYMLINK; 826 dp = dvp; 827 cnp->cn_lkflags = LK_EXCLUSIVE; 828 vn_lock(dp, LK_EXCLUSIVE | LK_RETRY, td); 829 830 /* 831 * Search a new directory. 832 * 833 * The last component of the filename is left accessible via 834 * cnp->cn_nameptr for callers that need the name. Callers needing 835 * the name set the SAVENAME flag. When done, they assume 836 * responsibility for freeing the pathname buffer. 837 */ 838 #ifdef NAMEI_DIAGNOSTIC 839 printf("{%s}: ", cnp->cn_nameptr); 840 #endif 841 842 /* 843 * Check for degenerate name (e.g. / or "") 844 * which is a way of talking about a directory, 845 * e.g. like "/." or ".". 846 */ 847 if (cnp->cn_nameptr[0] == '\0') { 848 if (cnp->cn_nameiop != LOOKUP || wantparent) { 849 error = EISDIR; 850 goto bad; 851 } 852 if (dp->v_type != VDIR) { 853 error = ENOTDIR; 854 goto bad; 855 } 856 if (!(cnp->cn_flags & LOCKLEAF)) 857 VOP_UNLOCK(dp, 0, td); 858 *vpp = dp; 859 /* XXX This should probably move to the top of function. */ 860 if (cnp->cn_flags & SAVESTART) 861 panic("lookup: SAVESTART"); 862 return (0); 863 } 864 865 if (cnp->cn_flags & ISDOTDOT) 866 panic ("relookup: lookup on dot-dot"); 867 868 /* 869 * We now have a segment name to search for, and a directory to search. 870 */ 871 #ifdef NAMEI_DIAGNOSTIC 872 vprint("search in:", dp); 873 #endif 874 if ((error = VOP_LOOKUP(dp, vpp, cnp)) != 0) { 875 KASSERT(*vpp == NULL, ("leaf should be empty")); 876 if (error != EJUSTRETURN) 877 goto bad; 878 /* 879 * If creating and at end of pathname, then can consider 880 * allowing file to be created. 881 */ 882 if (rdonly) { 883 error = EROFS; 884 goto bad; 885 } 886 /* ASSERT(dvp == ndp->ni_startdir) */ 887 if (cnp->cn_flags & SAVESTART) 888 VREF(dvp); 889 if ((cnp->cn_flags & LOCKPARENT) == 0) 890 VOP_UNLOCK(dp, 0, td); 891 /* 892 * This is a temporary assert to make sure I know what the 893 * behavior here was. 894 */ 895 KASSERT((cnp->cn_flags & (WANTPARENT|LOCKPARENT)) != 0, 896 ("relookup: Unhandled case.")); 897 /* 898 * We return with ni_vp NULL to indicate that the entry 899 * doesn't currently exist, leaving a pointer to the 900 * (possibly locked) directory vnode in ndp->ni_dvp. 901 */ 902 return (0); 903 } 904 905 dp = *vpp; 906 907 /* 908 * Disallow directory write attempts on read-only filesystems. 909 */ 910 if (rdonly && 911 (cnp->cn_nameiop == DELETE || cnp->cn_nameiop == RENAME)) { 912 if (dvp == dp) 913 vrele(dvp); 914 else 915 vput(dvp); 916 error = EROFS; 917 goto bad; 918 } 919 /* 920 * Set the parent lock/ref state to the requested state. 921 */ 922 if ((cnp->cn_flags & LOCKPARENT) == 0 && dvp != dp) { 923 if (wantparent) 924 VOP_UNLOCK(dvp, 0, td); 925 else 926 vput(dvp); 927 } else if (!wantparent) 928 vrele(dvp); 929 /* 930 * Check for symbolic link 931 */ 932 KASSERT(dp->v_type != VLNK || !(cnp->cn_flags & FOLLOW), 933 ("relookup: symlink found.\n")); 934 935 /* ASSERT(dvp == ndp->ni_startdir) */ 936 if (cnp->cn_flags & SAVESTART) 937 VREF(dvp); 938 939 if ((cnp->cn_flags & LOCKLEAF) == 0) 940 VOP_UNLOCK(dp, 0, td); 941 return (0); 942 bad: 943 vput(dp); 944 *vpp = NULL; 945 return (error); 946 } 947 948 /* 949 * Free data allocated by namei(); see namei(9) for details. 950 */ 951 void 952 NDFREE(struct nameidata *ndp, const u_int flags) 953 { 954 int unlock_dvp; 955 int unlock_vp; 956 957 unlock_dvp = 0; 958 unlock_vp = 0; 959 960 if (!(flags & NDF_NO_FREE_PNBUF) && 961 (ndp->ni_cnd.cn_flags & HASBUF)) { 962 uma_zfree(namei_zone, ndp->ni_cnd.cn_pnbuf); 963 ndp->ni_cnd.cn_flags &= ~HASBUF; 964 } 965 if (!(flags & NDF_NO_VP_UNLOCK) && 966 (ndp->ni_cnd.cn_flags & LOCKLEAF) && ndp->ni_vp) 967 unlock_vp = 1; 968 if (!(flags & NDF_NO_VP_RELE) && ndp->ni_vp) { 969 if (unlock_vp) { 970 vput(ndp->ni_vp); 971 unlock_vp = 0; 972 } else 973 vrele(ndp->ni_vp); 974 ndp->ni_vp = NULL; 975 } 976 if (unlock_vp) 977 VOP_UNLOCK(ndp->ni_vp, 0, ndp->ni_cnd.cn_thread); 978 if (!(flags & NDF_NO_DVP_UNLOCK) && 979 (ndp->ni_cnd.cn_flags & LOCKPARENT) && 980 ndp->ni_dvp != ndp->ni_vp) 981 unlock_dvp = 1; 982 if (!(flags & NDF_NO_DVP_RELE) && 983 (ndp->ni_cnd.cn_flags & (LOCKPARENT|WANTPARENT))) { 984 if (unlock_dvp) { 985 vput(ndp->ni_dvp); 986 unlock_dvp = 0; 987 } else 988 vrele(ndp->ni_dvp); 989 ndp->ni_dvp = NULL; 990 } 991 if (unlock_dvp) 992 VOP_UNLOCK(ndp->ni_dvp, 0, ndp->ni_cnd.cn_thread); 993 if (!(flags & NDF_NO_STARTDIR_RELE) && 994 (ndp->ni_cnd.cn_flags & SAVESTART)) { 995 vrele(ndp->ni_startdir); 996 ndp->ni_startdir = NULL; 997 } 998 } 999 1000 /* 1001 * Determine if there is a suitable alternate filename under the specified 1002 * prefix for the specified path. If the create flag is set, then the 1003 * alternate prefix will be used so long as the parent directory exists. 1004 * This is used by the various compatiblity ABIs so that Linux binaries prefer 1005 * files under /compat/linux for example. The chosen path (whether under 1006 * the prefix or under /) is returned in a kernel malloc'd buffer pointed 1007 * to by pathbuf. The caller is responsible for free'ing the buffer from 1008 * the M_TEMP bucket if one is returned. 1009 */ 1010 int 1011 kern_alternate_path(struct thread *td, const char *prefix, char *path, 1012 enum uio_seg pathseg, char **pathbuf, int create) 1013 { 1014 struct nameidata nd, ndroot; 1015 char *ptr, *buf, *cp; 1016 size_t len, sz; 1017 int error; 1018 1019 buf = (char *) malloc(MAXPATHLEN, M_TEMP, M_WAITOK); 1020 *pathbuf = buf; 1021 1022 /* Copy the prefix into the new pathname as a starting point. */ 1023 len = strlcpy(buf, prefix, MAXPATHLEN); 1024 if (len >= MAXPATHLEN) { 1025 *pathbuf = NULL; 1026 free(buf, M_TEMP); 1027 return (EINVAL); 1028 } 1029 sz = MAXPATHLEN - len; 1030 ptr = buf + len; 1031 1032 /* Append the filename to the prefix. */ 1033 if (pathseg == UIO_SYSSPACE) 1034 error = copystr(path, ptr, sz, &len); 1035 else 1036 error = copyinstr(path, ptr, sz, &len); 1037 1038 if (error) { 1039 *pathbuf = NULL; 1040 free(buf, M_TEMP); 1041 return (error); 1042 } 1043 1044 /* Only use a prefix with absolute pathnames. */ 1045 if (*ptr != '/') { 1046 error = EINVAL; 1047 goto keeporig; 1048 } 1049 1050 /* 1051 * We know that there is a / somewhere in this pathname. 1052 * Search backwards for it, to find the file's parent dir 1053 * to see if it exists in the alternate tree. If it does, 1054 * and we want to create a file (cflag is set). We don't 1055 * need to worry about the root comparison in this case. 1056 */ 1057 1058 if (create) { 1059 for (cp = &ptr[len] - 1; *cp != '/'; cp--); 1060 *cp = '\0'; 1061 1062 NDINIT(&nd, LOOKUP, FOLLOW | MPSAFE, UIO_SYSSPACE, buf, td); 1063 error = namei(&nd); 1064 *cp = '/'; 1065 if (error != 0) 1066 goto keeporig; 1067 } else { 1068 NDINIT(&nd, LOOKUP, FOLLOW | MPSAFE, UIO_SYSSPACE, buf, td); 1069 1070 error = namei(&nd); 1071 if (error != 0) 1072 goto keeporig; 1073 1074 /* 1075 * We now compare the vnode of the prefix to the one 1076 * vnode asked. If they resolve to be the same, then we 1077 * ignore the match so that the real root gets used. 1078 * This avoids the problem of traversing "../.." to find the 1079 * root directory and never finding it, because "/" resolves 1080 * to the emulation root directory. This is expensive :-( 1081 */ 1082 NDINIT(&ndroot, LOOKUP, FOLLOW | MPSAFE, UIO_SYSSPACE, prefix, 1083 td); 1084 1085 /* We shouldn't ever get an error from this namei(). */ 1086 error = namei(&ndroot); 1087 if (error == 0) { 1088 if (nd.ni_vp == ndroot.ni_vp) 1089 error = ENOENT; 1090 1091 NDFREE(&ndroot, NDF_ONLY_PNBUF); 1092 vrele(ndroot.ni_vp); 1093 VFS_UNLOCK_GIANT(NDHASGIANT(&ndroot)); 1094 } 1095 } 1096 1097 NDFREE(&nd, NDF_ONLY_PNBUF); 1098 vrele(nd.ni_vp); 1099 VFS_UNLOCK_GIANT(NDHASGIANT(&nd)); 1100 1101 keeporig: 1102 /* If there was an error, use the original path name. */ 1103 if (error) 1104 bcopy(ptr, buf, len); 1105 return (error); 1106 }
Cache object: 31d418d95ed663315b3474dd2386f60a
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]