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