1 /* 2 * CDDL HEADER START 3 * 4 * The contents of this file are subject to the terms of the 5 * Common Development and Distribution License (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 /* 22 * Copyright 2008 Sun Microsystems, Inc. All rights reserved. 23 * Use is subject to license terms. 24 */ 25 26 /* Copyright (c) 1983, 1984, 1985, 1986, 1987, 1988, 1989 AT&T */ 27 /* All Rights Reserved */ 28 29 /* 30 * University Copyright- Copyright (c) 1982, 1986, 1988 31 * The Regents of the University of California 32 * All Rights Reserved 33 * 34 * University Acknowledgment- Portions of this document are derived from 35 * software developed by the University of California, Berkeley, and its 36 * contributors. 37 */ 38 39 #include <sys/types.h> 40 #include <sys/param.h> 41 #include <sys/systm.h> 42 #include <sys/cpuvar.h> 43 #include <sys/errno.h> 44 #include <sys/cred.h> 45 #include <sys/user.h> 46 #include <sys/uio.h> 47 #include <sys/vfs.h> 48 #include <sys/vnode.h> 49 #include <sys/pathname.h> 50 #include <sys/proc.h> 51 #include <sys/vtrace.h> 52 #include <sys/sysmacros.h> 53 #include <sys/debug.h> 54 #include <sys/dirent.h> 55 #include <c2/audit.h> 56 #include <sys/zone.h> 57 #include <sys/dnlc.h> 58 #include <sys/fs/snode.h> 59 60 /* Controls whether paths are stored with vnodes. */ 61 int vfs_vnode_path = 1; 62 63 int 64 lookupname( 65 char *fnamep, 66 enum uio_seg seg, 67 enum symfollow followlink, 68 vnode_t **dirvpp, 69 vnode_t **compvpp) 70 { 71 return (lookupnameat(fnamep, seg, followlink, dirvpp, compvpp, NULL)); 72 } 73 74 75 /* 76 * Lookup the user file name, 77 * Handle allocation and freeing of pathname buffer, return error. 78 */ 79 int 80 lookupnameat( 81 char *fnamep, /* user pathname */ 82 enum uio_seg seg, /* addr space that name is in */ 83 enum symfollow followlink, /* follow sym links */ 84 vnode_t **dirvpp, /* ret for ptr to parent dir vnode */ 85 vnode_t **compvpp, /* ret for ptr to component vnode */ 86 vnode_t *startvp) /* start path search from vp */ 87 { 88 char namebuf[TYPICALMAXPATHLEN]; 89 struct pathname lookpn; 90 int error; 91 92 error = pn_get_buf(fnamep, seg, &lookpn, namebuf, sizeof (namebuf)); 93 if (error == 0) { 94 if (audit_active) 95 audit_lookupname(); 96 error = lookuppnat(&lookpn, NULL, followlink, 97 dirvpp, compvpp, startvp); 98 } 99 if (error == ENAMETOOLONG) { 100 /* 101 * This thread used a pathname > TYPICALMAXPATHLEN bytes long. 102 */ 103 if (error = pn_get(fnamep, seg, &lookpn)) 104 return (error); 105 error = lookuppnat(&lookpn, NULL, followlink, 106 dirvpp, compvpp, startvp); 107 pn_free(&lookpn); 108 } 109 110 return (error); 111 } 112 113 /* 114 * Lookup the user file name from a given vp, 115 */ 116 int 117 lookuppn( 118 struct pathname *pnp, 119 struct pathname *rpnp, 120 enum symfollow followlink, 121 vnode_t **dirvpp, 122 vnode_t **compvpp) 123 { 124 return (lookuppnat(pnp, rpnp, followlink, dirvpp, compvpp, NULL)); 125 } 126 127 int 128 lookuppnat( 129 struct pathname *pnp, /* pathname to lookup */ 130 struct pathname *rpnp, /* if non-NULL, return resolved path */ 131 enum symfollow followlink, /* (don't) follow sym links */ 132 vnode_t **dirvpp, /* ptr for parent vnode */ 133 vnode_t **compvpp, /* ptr for entry vnode */ 134 vnode_t *startvp) /* start search from this vp */ 135 { 136 vnode_t *vp; /* current directory vp */ 137 vnode_t *rootvp; 138 proc_t *p = curproc; 139 140 if (pnp->pn_pathlen == 0) 141 return (ENOENT); 142 143 mutex_enter(&p->p_lock); /* for u_rdir and u_cdir */ 144 if ((rootvp = PTOU(p)->u_rdir) == NULL) 145 rootvp = rootdir; 146 else if (rootvp != rootdir) /* no need to VN_HOLD rootdir */ 147 VN_HOLD(rootvp); 148 149 if (pnp->pn_path[0] == '/') { 150 vp = rootvp; 151 } else { 152 vp = (startvp == NULL) ? PTOU(p)->u_cdir : startvp; 153 } 154 VN_HOLD(vp); 155 mutex_exit(&p->p_lock); 156 157 /* 158 * Skip over leading slashes 159 */ 160 if (pnp->pn_path[0] == '/') { 161 do { 162 pnp->pn_path++; 163 pnp->pn_pathlen--; 164 } while (pnp->pn_path[0] == '/'); 165 } 166 167 return (lookuppnvp(pnp, rpnp, followlink, dirvpp, 168 compvpp, rootvp, vp, CRED())); 169 } 170 171 /* Private flag to do our getcwd() dirty work */ 172 #define LOOKUP_CHECKREAD 0x10 173 #define LOOKUP_MASK (~LOOKUP_CHECKREAD) 174 175 /* 176 * Starting at current directory, translate pathname pnp to end. 177 * Leave pathname of final component in pnp, return the vnode 178 * for the final component in *compvpp, and return the vnode 179 * for the parent of the final component in dirvpp. 180 * 181 * This is the central routine in pathname translation and handles 182 * multiple components in pathnames, separating them at /'s. It also 183 * implements mounted file systems and processes symbolic links. 184 * 185 * vp is the vnode where the directory search should start. 186 * 187 * Reference counts: vp must be held prior to calling this function. rootvp 188 * should only be held if rootvp != rootdir. 189 */ 190 int 191 lookuppnvp( 192 struct pathname *pnp, /* pathname to lookup */ 193 struct pathname *rpnp, /* if non-NULL, return resolved path */ 194 int flags, /* follow symlinks */ 195 vnode_t **dirvpp, /* ptr for parent vnode */ 196 vnode_t **compvpp, /* ptr for entry vnode */ 197 vnode_t *rootvp, /* rootvp */ 198 vnode_t *vp, /* directory to start search at */ 199 cred_t *cr) /* user's credential */ 200 { 201 vnode_t *cvp; /* current component vp */ 202 vnode_t *tvp; /* addressable temp ptr */ 203 char component[MAXNAMELEN]; /* buffer for component (incl null) */ 204 int error; 205 int nlink; 206 int lookup_flags; 207 struct pathname presrvd; /* case preserved name */ 208 struct pathname *pp = NULL; 209 vnode_t *startvp; 210 vnode_t *zonevp = curproc->p_zone->zone_rootvp; /* zone root */ 211 int must_be_directory = 0; 212 boolean_t retry_with_kcred = B_FALSE; 213 214 CPU_STATS_ADDQ(CPU, sys, namei, 1); 215 nlink = 0; 216 cvp = NULL; 217 if (rpnp) 218 rpnp->pn_pathlen = 0; 219 220 lookup_flags = dirvpp ? LOOKUP_DIR : 0; 221 if (flags & FIGNORECASE) { 222 lookup_flags |= FIGNORECASE; 223 pn_alloc(&presrvd); 224 pp = &presrvd; 225 } 226 227 if (audit_active) 228 audit_anchorpath(pnp, vp == rootvp); 229 230 /* 231 * Eliminate any trailing slashes in the pathname. 232 * If there are any, we must follow all symlinks. 233 * Also, we must guarantee that the last component is a directory. 234 */ 235 if (pn_fixslash(pnp)) { 236 flags |= FOLLOW; 237 must_be_directory = 1; 238 } 239 240 startvp = vp; 241 next: 242 /* 243 * Make sure we have a directory. 244 */ 245 if (vp->v_type != VDIR) { 246 error = ENOTDIR; 247 goto bad; 248 } 249 250 if (rpnp && VN_CMP(vp, rootvp)) 251 (void) pn_set(rpnp, "/"); 252 253 /* 254 * Process the next component of the pathname. 255 */ 256 if (error = pn_getcomponent(pnp, component)) { 257 if (audit_active) 258 audit_addcomponent(pnp); 259 goto bad; 260 } 261 262 /* 263 * Handle "..": two special cases. 264 * 1. If we're at the root directory (e.g. after chroot or 265 * zone_enter) then change ".." to "." so we can't get 266 * out of this subtree. 267 * 2. If this vnode is the root of a mounted file system, 268 * then replace it with the vnode that was mounted on 269 * so that we take the ".." in the other file system. 270 */ 271 if (component[0] == '.' && component[1] == '.' && component[2] == 0) { 272 checkforroot: 273 if (VN_CMP(vp, rootvp) || VN_CMP(vp, zonevp)) { 274 component[1] = '\0'; 275 } else if (vp->v_flag & VROOT) { 276 vfs_t *vfsp; 277 cvp = vp; 278 279 /* 280 * While we deal with the vfs pointer from the vnode 281 * the filesystem could have been forcefully unmounted 282 * and the vnode's v_vfsp could have been invalidated 283 * by VFS_UNMOUNT. Hence, we cache v_vfsp and use it 284 * with vfs_rlock_wait/vfs_unlock. 285 * It is safe to use the v_vfsp even it is freed by 286 * VFS_UNMOUNT because vfs_rlock_wait/vfs_unlock 287 * do not dereference v_vfsp. It is just used as a 288 * magic cookie. 289 * One more corner case here is the memory getting 290 * reused for another vfs structure. In this case 291 * lookuppnvp's vfs_rlock_wait will succeed, domount's 292 * vfs_lock will fail and domount will bail out with an 293 * error (EBUSY). 294 */ 295 vfsp = cvp->v_vfsp; 296 297 /* 298 * This lock is used to synchronize 299 * mounts/unmounts and lookups. 300 * Threads doing mounts/unmounts hold the 301 * writers version vfs_lock_wait(). 302 */ 303 304 vfs_rlock_wait(vfsp); 305 306 /* 307 * If this vnode is on a file system that 308 * has been forcibly unmounted, 309 * we can't proceed. Cancel this operation 310 * and return EIO. 311 * 312 * vfs_vnodecovered is NULL if unmounted. 313 * Currently, nfs uses VFS_UNMOUNTED to 314 * check if it's a forced-umount. Keep the 315 * same checking here as well even though it 316 * may not be needed. 317 */ 318 if (((vp = cvp->v_vfsp->vfs_vnodecovered) == NULL) || 319 (cvp->v_vfsp->vfs_flag & VFS_UNMOUNTED)) { 320 vfs_unlock(vfsp); 321 VN_RELE(cvp); 322 if (pp) 323 pn_free(pp); 324 return (EIO); 325 } 326 VN_HOLD(vp); 327 vfs_unlock(vfsp); 328 VN_RELE(cvp); 329 cvp = NULL; 330 /* 331 * Crossing mount points. For eg: We are doing 332 * a lookup of ".." for file systems root vnode 333 * mounted here, and VOP_LOOKUP() (with covered vnode) 334 * will be on underlying file systems mount point 335 * vnode. Set retry_with_kcred flag as we might end 336 * up doing VOP_LOOKUP() with kcred if required. 337 */ 338 retry_with_kcred = B_TRUE; 339 goto checkforroot; 340 } 341 } 342 343 /* 344 * LOOKUP_CHECKREAD is a private flag used by vnodetopath() to indicate 345 * that we need to have read permission on every directory in the entire 346 * path. This is used to ensure that a forward-lookup of a cached value 347 * has the same effect as a reverse-lookup when the cached value cannot 348 * be found. 349 */ 350 if ((flags & LOOKUP_CHECKREAD) && 351 (error = VOP_ACCESS(vp, VREAD, 0, cr, NULL)) != 0) 352 goto bad; 353 354 /* 355 * Perform a lookup in the current directory. 356 */ 357 error = VOP_LOOKUP(vp, component, &tvp, pnp, lookup_flags, 358 rootvp, cr, NULL, NULL, pp); 359 360 /* 361 * Retry with kcred - If crossing mount points & error is EACCES. 362 * 363 * If we are crossing mount points here and doing ".." lookup, 364 * VOP_LOOKUP() might fail if the underlying file systems 365 * mount point has no execute permission. In cases like these, 366 * we retry VOP_LOOKUP() by giving as much privilage as possible 367 * by passing kcred credentials. 368 * 369 * In case of hierarchical file systems, passing kcred still may 370 * or may not work. 371 * For eg: UFS FS --> Mount NFS FS --> Again mount UFS on some 372 * directory inside NFS FS. 373 */ 374 if ((error == EACCES) && retry_with_kcred) 375 error = VOP_LOOKUP(vp, component, &tvp, pnp, lookup_flags, 376 rootvp, zone_kcred(), NULL, NULL, pp); 377 378 cvp = tvp; 379 if (error) { 380 cvp = NULL; 381 /* 382 * On error, return hard error if 383 * (a) we're not at the end of the pathname yet, or 384 * (b) the caller didn't want the parent directory, or 385 * (c) we failed for some reason other than a missing entry. 386 */ 387 if (pn_pathleft(pnp) || dirvpp == NULL || error != ENOENT) 388 goto bad; 389 if (audit_active) { /* directory access */ 390 if (error = audit_savepath(pnp, vp, error, cr)) 391 goto bad_noaudit; 392 } 393 pn_setlast(pnp); 394 /* 395 * We inform the caller that the desired entry must be 396 * a directory by adding a '/' to the component name. 397 */ 398 if (must_be_directory && (error = pn_addslash(pnp)) != 0) 399 goto bad; 400 *dirvpp = vp; 401 if (compvpp != NULL) 402 *compvpp = NULL; 403 if (rootvp != rootdir) 404 VN_RELE(rootvp); 405 if (pp) 406 pn_free(pp); 407 return (0); 408 } 409 410 /* 411 * Traverse mount points. 412 * XXX why don't we need to hold a read lock here (call vn_vfsrlock)? 413 * What prevents a concurrent update to v_vfsmountedhere? 414 * Possible answer: if mounting, we might not see the mount 415 * if it is concurrently coming into existence, but that's 416 * really not much different from the thread running a bit slower. 417 * If unmounting, we may get into traverse() when we shouldn't, 418 * but traverse() will catch this case for us. 419 * (For this to work, fetching v_vfsmountedhere had better 420 * be atomic!) 421 */ 422 if (vn_mountedvfs(cvp) != NULL) { 423 tvp = cvp; 424 if ((error = traverse(&tvp)) != 0) { 425 /* 426 * It is required to assign cvp here, because 427 * traverse() will return a held vnode which 428 * may different than the vnode that was passed 429 * in (even in the error case). If traverse() 430 * changes the vnode it releases the original, 431 * and holds the new one. 432 */ 433 cvp = tvp; 434 goto bad; 435 } 436 cvp = tvp; 437 } 438 439 /* 440 * If we hit a symbolic link and there is more path to be 441 * translated or this operation does not wish to apply 442 * to a link, then place the contents of the link at the 443 * front of the remaining pathname. 444 */ 445 if (cvp->v_type == VLNK && ((flags & FOLLOW) || pn_pathleft(pnp))) { 446 struct pathname linkpath; 447 if (audit_active) { 448 if (error = audit_pathcomp(pnp, cvp, cr)) 449 goto bad; 450 } 451 452 if (++nlink > MAXSYMLINKS) { 453 error = ELOOP; 454 goto bad; 455 } 456 pn_alloc(&linkpath); 457 if (error = pn_getsymlink(cvp, &linkpath, cr)) { 458 pn_free(&linkpath); 459 goto bad; 460 } 461 462 if (audit_active) 463 audit_symlink(pnp, &linkpath); 464 465 if (pn_pathleft(&linkpath) == 0) 466 (void) pn_set(&linkpath, "."); 467 error = pn_insert(pnp, &linkpath, strlen(component)); 468 pn_free(&linkpath); 469 if (error) 470 goto bad; 471 VN_RELE(cvp); 472 cvp = NULL; 473 if (pnp->pn_pathlen == 0) { 474 error = ENOENT; 475 goto bad; 476 } 477 if (pnp->pn_path[0] == '/') { 478 do { 479 pnp->pn_path++; 480 pnp->pn_pathlen--; 481 } while (pnp->pn_path[0] == '/'); 482 VN_RELE(vp); 483 vp = rootvp; 484 VN_HOLD(vp); 485 } 486 if (audit_active) 487 audit_anchorpath(pnp, vp == rootvp); 488 if (pn_fixslash(pnp)) { 489 flags |= FOLLOW; 490 must_be_directory = 1; 491 } 492 goto next; 493 } 494 495 /* 496 * If rpnp is non-NULL, remember the resolved path name therein. 497 * Do not include "." components. Collapse occurrences of 498 * "previous/..", so long as "previous" is not itself "..". 499 * Exhausting rpnp results in error ENAMETOOLONG. 500 */ 501 if (rpnp && strcmp(component, ".") != 0) { 502 size_t len; 503 504 if (strcmp(component, "..") == 0 && 505 rpnp->pn_pathlen != 0 && 506 !((rpnp->pn_pathlen > 2 && 507 strncmp(rpnp->pn_path+rpnp->pn_pathlen-3, "/..", 3) == 0) || 508 (rpnp->pn_pathlen == 2 && 509 strncmp(rpnp->pn_path, "..", 2) == 0))) { 510 while (rpnp->pn_pathlen && 511 rpnp->pn_path[rpnp->pn_pathlen-1] != '/') 512 rpnp->pn_pathlen--; 513 if (rpnp->pn_pathlen > 1) 514 rpnp->pn_pathlen--; 515 rpnp->pn_path[rpnp->pn_pathlen] = '\0'; 516 } else { 517 if (rpnp->pn_pathlen != 0 && 518 rpnp->pn_path[rpnp->pn_pathlen-1] != '/') 519 rpnp->pn_path[rpnp->pn_pathlen++] = '/'; 520 if (flags & FIGNORECASE) { 521 /* 522 * Return the case-preserved name 523 * within the resolved path. 524 */ 525 error = copystr(pp->pn_buf, 526 rpnp->pn_path + rpnp->pn_pathlen, 527 rpnp->pn_bufsize - rpnp->pn_pathlen, &len); 528 } else { 529 error = copystr(component, 530 rpnp->pn_path + rpnp->pn_pathlen, 531 rpnp->pn_bufsize - rpnp->pn_pathlen, &len); 532 } 533 if (error) /* copystr() returns ENAMETOOLONG */ 534 goto bad; 535 rpnp->pn_pathlen += (len - 1); 536 ASSERT(rpnp->pn_bufsize > rpnp->pn_pathlen); 537 } 538 } 539 540 /* 541 * If no more components, return last directory (if wanted) and 542 * last component (if wanted). 543 */ 544 if (pn_pathleft(pnp) == 0) { 545 /* 546 * If there was a trailing slash in the pathname, 547 * make sure the last component is a directory. 548 */ 549 if (must_be_directory && cvp->v_type != VDIR) { 550 error = ENOTDIR; 551 goto bad; 552 } 553 if (dirvpp != NULL) { 554 /* 555 * Check that we have the real parent and not 556 * an alias of the last component. 557 */ 558 if (vn_compare(vp, cvp)) { 559 if (audit_active) 560 (void) audit_savepath(pnp, cvp, 561 EINVAL, cr); 562 pn_setlast(pnp); 563 VN_RELE(vp); 564 VN_RELE(cvp); 565 if (rootvp != rootdir) 566 VN_RELE(rootvp); 567 if (pp) 568 pn_free(pp); 569 return (EINVAL); 570 } 571 if (audit_active) { 572 if (error = audit_pathcomp(pnp, vp, cr)) 573 goto bad; 574 } 575 *dirvpp = vp; 576 } else 577 VN_RELE(vp); 578 if (audit_active) 579 (void) audit_savepath(pnp, cvp, 0, cr); 580 if (pnp->pn_path == pnp->pn_buf) 581 (void) pn_set(pnp, "."); 582 else 583 pn_setlast(pnp); 584 if (rpnp) { 585 if (VN_CMP(cvp, rootvp)) 586 (void) pn_set(rpnp, "/"); 587 else if (rpnp->pn_pathlen == 0) 588 (void) pn_set(rpnp, "."); 589 } 590 591 if (compvpp != NULL) 592 *compvpp = cvp; 593 else 594 VN_RELE(cvp); 595 if (rootvp != rootdir) 596 VN_RELE(rootvp); 597 if (pp) 598 pn_free(pp); 599 return (0); 600 } 601 602 if (audit_active) { 603 if (error = audit_pathcomp(pnp, cvp, cr)) 604 goto bad; 605 } 606 607 /* 608 * Skip over slashes from end of last component. 609 */ 610 while (pnp->pn_path[0] == '/') { 611 pnp->pn_path++; 612 pnp->pn_pathlen--; 613 } 614 615 /* 616 * Searched through another level of directory: 617 * release previous directory handle and save new (result 618 * of lookup) as current directory. 619 */ 620 VN_RELE(vp); 621 vp = cvp; 622 cvp = NULL; 623 goto next; 624 625 bad: 626 if (audit_active) /* reached end of path */ 627 (void) audit_savepath(pnp, cvp, error, cr); 628 bad_noaudit: 629 /* 630 * Error. Release vnodes and return. 631 */ 632 if (cvp) 633 VN_RELE(cvp); 634 /* 635 * If the error was ESTALE and the current directory to look in 636 * was the root for this lookup, the root for a mounted file 637 * system, or the starting directory for lookups, then 638 * return ENOENT instead of ESTALE. In this case, no recovery 639 * is possible by the higher level. If ESTALE was returned for 640 * some intermediate directory along the path, then recovery 641 * is potentially possible and retrying from the higher level 642 * will either correct the situation by purging stale cache 643 * entries or eventually get back to the point where no recovery 644 * is possible. 645 */ 646 if (error == ESTALE && 647 (VN_CMP(vp, rootvp) || (vp->v_flag & VROOT) || vp == startvp)) 648 error = ENOENT; 649 VN_RELE(vp); 650 if (rootvp != rootdir) 651 VN_RELE(rootvp); 652 if (pp) 653 pn_free(pp); 654 return (error); 655 } 656 657 /* 658 * Traverse a mount point. Routine accepts a vnode pointer as a reference 659 * parameter and performs the indirection, releasing the original vnode. 660 */ 661 int 662 traverse(vnode_t **cvpp) 663 { 664 int error = 0; 665 vnode_t *cvp; 666 vnode_t *tvp; 667 vfs_t *vfsp; 668 669 cvp = *cvpp; 670 671 /* 672 * If this vnode is mounted on, then we transparently indirect 673 * to the vnode which is the root of the mounted file system. 674 * Before we do this we must check that an unmount is not in 675 * progress on this vnode. 676 */ 677 678 for (;;) { 679 /* 680 * Try to read lock the vnode. If this fails because 681 * the vnode is already write locked, then check to 682 * see whether it is the current thread which locked 683 * the vnode. If it is not, then read lock the vnode 684 * by waiting to acquire the lock. 685 * 686 * The code path in domount() is an example of support 687 * which needs to look up two pathnames and locks one 688 * of them in between the two lookups. 689 */ 690 error = vn_vfsrlock(cvp); 691 if (error) { 692 if (!vn_vfswlock_held(cvp)) 693 error = vn_vfsrlock_wait(cvp); 694 if (error != 0) { 695 /* 696 * lookuppn() expects a held vnode to be 697 * returned because it promptly calls 698 * VN_RELE after the error return 699 */ 700 *cvpp = cvp; 701 return (error); 702 } 703 } 704 705 /* 706 * Reached the end of the mount chain? 707 */ 708 vfsp = vn_mountedvfs(cvp); 709 if (vfsp == NULL) { 710 vn_vfsunlock(cvp); 711 break; 712 } 713 714 /* 715 * The read lock must be held across the call to VFS_ROOT() to 716 * prevent a concurrent unmount from destroying the vfs. 717 */ 718 error = VFS_ROOT(vfsp, &tvp); 719 vn_vfsunlock(cvp); 720 721 if (error) 722 break; 723 724 VN_RELE(cvp); 725 726 cvp = tvp; 727 } 728 729 *cvpp = cvp; 730 return (error); 731 } 732 733 /* 734 * Return the lowermost vnode if this is a mountpoint. 735 */ 736 static vnode_t * 737 vn_under(vnode_t *vp) 738 { 739 vnode_t *uvp; 740 vfs_t *vfsp; 741 742 while (vp->v_flag & VROOT) { 743 744 vfsp = vp->v_vfsp; 745 vfs_rlock_wait(vfsp); 746 if ((uvp = vfsp->vfs_vnodecovered) == NULL || 747 (vfsp->vfs_flag & VFS_UNMOUNTED)) { 748 vfs_unlock(vfsp); 749 break; 750 } 751 VN_HOLD(uvp); 752 vfs_unlock(vfsp); 753 VN_RELE(vp); 754 vp = uvp; 755 } 756 757 return (vp); 758 } 759 760 static int 761 vnode_match(vnode_t *v1, vnode_t *v2, cred_t *cr) 762 { 763 vattr_t v1attr, v2attr; 764 765 /* 766 * If we have a device file, check to see if is a cloned open of the 767 * same device. For self-cloning devices, the major numbers will match. 768 * For devices cloned through the 'clone' driver, the minor number of 769 * the source device will be the same as the major number of the cloned 770 * device. 771 */ 772 if ((v1->v_type == VCHR || v1->v_type == VBLK) && 773 v1->v_type == v2->v_type) { 774 if ((spec_is_selfclone(v1) || spec_is_selfclone(v2)) && 775 getmajor(v1->v_rdev) == getmajor(v2->v_rdev)) 776 return (1); 777 778 if (spec_is_clone(v1) && 779 getmajor(v1->v_rdev) == getminor(v2->v_rdev)) 780 return (1); 781 782 if (spec_is_clone(v2) && 783 getmajor(v2->v_rdev) == getminor(v1->v_rdev)) 784 return (1); 785 } 786 787 v1attr.va_mask = v2attr.va_mask = AT_TYPE; 788 789 /* 790 * This check for symbolic links handles the pseudo-symlinks in procfs. 791 * These particular links have v_type of VDIR, but the attributes have a 792 * type of VLNK. We need to avoid these links because otherwise if we 793 * are currently in '/proc/self/fd', then '/proc/self/cwd' will compare 794 * as the same vnode. 795 */ 796 if (VOP_GETATTR(v1, &v1attr, 0, cr, NULL) != 0 || 797 VOP_GETATTR(v2, &v2attr, 0, cr, NULL) != 0 || 798 v1attr.va_type == VLNK || v2attr.va_type == VLNK) 799 return (0); 800 801 v1attr.va_mask = v2attr.va_mask = AT_TYPE | AT_FSID | AT_NODEID; 802 803 if (VOP_GETATTR(v1, &v1attr, ATTR_REAL, cr, NULL) != 0 || 804 VOP_GETATTR(v2, &v2attr, ATTR_REAL, cr, NULL) != 0) 805 return (0); 806 807 return (v1attr.va_fsid == v2attr.va_fsid && 808 v1attr.va_nodeid == v2attr.va_nodeid); 809 } 810 811 812 /* 813 * Find the entry in the directory corresponding to the target vnode. 814 */ 815 int 816 dirfindvp(vnode_t *vrootp, vnode_t *dvp, vnode_t *tvp, cred_t *cr, char *dbuf, 817 size_t dlen, dirent64_t **rdp) 818 { 819 size_t dbuflen; 820 struct iovec iov; 821 struct uio uio; 822 int error; 823 int eof; 824 vnode_t *cmpvp; 825 struct dirent64 *dp; 826 pathname_t pnp; 827 828 ASSERT(dvp->v_type == VDIR); 829 830 /* 831 * This is necessary because of the strange semantics of VOP_LOOKUP(). 832 */ 833 bzero(&pnp, sizeof (pnp)); 834 835 eof = 0; 836 837 uio.uio_iov = &iov; 838 uio.uio_iovcnt = 1; 839 uio.uio_segflg = UIO_SYSSPACE; 840 uio.uio_fmode = 0; 841 uio.uio_extflg = UIO_COPY_CACHED; 842 uio.uio_loffset = 0; 843 844 if ((error = VOP_ACCESS(dvp, VREAD, 0, cr, NULL)) != 0) 845 return (error); 846 847 while (!eof) { 848 uio.uio_resid = dlen; 849 iov.iov_base = dbuf; 850 iov.iov_len = dlen; 851 852 (void) VOP_RWLOCK(dvp, V_WRITELOCK_FALSE, NULL); 853 error = VOP_READDIR(dvp, &uio, cr, &eof, NULL, 0); 854 VOP_RWUNLOCK(dvp, V_WRITELOCK_FALSE, NULL); 855 856 dbuflen = dlen - uio.uio_resid; 857 858 if (error || dbuflen == 0) 859 break; 860 861 dp = (dirent64_t *)dbuf; 862 while ((intptr_t)dp < (intptr_t)dbuf + dbuflen) { 863 /* 864 * Ignore '.' and '..' entries 865 */ 866 if (strcmp(dp->d_name, ".") == 0 || 867 strcmp(dp->d_name, "..") == 0) { 868 dp = (dirent64_t *)((intptr_t)dp + 869 dp->d_reclen); 870 continue; 871 } 872 873 error = VOP_LOOKUP(dvp, dp->d_name, &cmpvp, &pnp, 0, 874 vrootp, cr, NULL, NULL, NULL); 875 876 /* 877 * We only want to bail out if there was an error other 878 * than ENOENT. Otherwise, it could be that someone 879 * just removed an entry since the readdir() call, and 880 * the entry we want is further on in the directory. 881 */ 882 if (error == 0) { 883 if (vnode_match(tvp, cmpvp, cr)) { 884 VN_RELE(cmpvp); 885 *rdp = dp; 886 return (0); 887 } 888 889 VN_RELE(cmpvp); 890 } else if (error != ENOENT) { 891 return (error); 892 } 893 894 dp = (dirent64_t *)((intptr_t)dp + dp->d_reclen); 895 } 896 } 897 898 /* 899 * Something strange has happened, this directory does not contain the 900 * specified vnode. This should never happen in the normal case, since 901 * we ensured that dvp is the parent of vp. This is possible in some 902 * rare conditions (races and the special .zfs directory). 903 */ 904 if (error == 0) { 905 error = VOP_LOOKUP(dvp, ".zfs", &cmpvp, &pnp, 0, vrootp, cr, 906 NULL, NULL, NULL); 907 if (error == 0) { 908 if (vnode_match(tvp, cmpvp, cr)) { 909 (void) strcpy(dp->d_name, ".zfs"); 910 dp->d_reclen = strlen(".zfs"); 911 dp->d_off = 2; 912 dp->d_ino = 1; 913 *rdp = dp; 914 } else { 915 error = ENOENT; 916 } 917 VN_RELE(cmpvp); 918 } 919 } 920 921 return (error); 922 } 923 924 /* 925 * Given a global path (from rootdir), and a vnode that is the current root, 926 * return the portion of the path that is beneath the current root or NULL on 927 * failure. The path MUST be a resolved path (no '..' entries or symlinks), 928 * otherwise this function will fail. 929 */ 930 static char * 931 localpath(char *path, struct vnode *vrootp, cred_t *cr) 932 { 933 vnode_t *vp; 934 vnode_t *cvp; 935 char component[MAXNAMELEN]; 936 char *ret = NULL; 937 pathname_t pn; 938 939 /* 940 * We use vn_compare() instead of VN_CMP() in order to detect lofs 941 * mounts and stacked vnodes. 942 */ 943 if (vn_compare(vrootp, rootdir)) 944 return (path); 945 946 if (pn_get(path, UIO_SYSSPACE, &pn) != 0) 947 return (NULL); 948 949 vp = rootdir; 950 VN_HOLD(vp); 951 952 if (vn_ismntpt(vp) && traverse(&vp) != 0) { 953 VN_RELE(vp); 954 pn_free(&pn); 955 return (NULL); 956 } 957 958 while (pn_pathleft(&pn)) { 959 pn_skipslash(&pn); 960 961 if (pn_getcomponent(&pn, component) != 0) 962 break; 963 964 if (VOP_LOOKUP(vp, component, &cvp, &pn, 0, rootdir, cr, 965 NULL, NULL, NULL) != 0) 966 break; 967 VN_RELE(vp); 968 vp = cvp; 969 970 if (vn_ismntpt(vp) && traverse(&vp) != 0) 971 break; 972 973 if (vn_compare(vp, vrootp)) { 974 ret = path + (pn.pn_path - pn.pn_buf); 975 break; 976 } 977 } 978 979 VN_RELE(vp); 980 pn_free(&pn); 981 982 return (ret); 983 } 984 985 /* 986 * Given a directory, return the full, resolved path. This looks up "..", 987 * searches for the given vnode in the parent, appends the component, etc. It 988 * is used to implement vnodetopath() and getcwd() when the cached path fails 989 * (or vfs_vnode_path is not set). 990 */ 991 static int 992 dirtopath(vnode_t *vrootp, vnode_t *vp, char *buf, size_t buflen, cred_t *cr) 993 { 994 pathname_t pn, rpn, emptypn; 995 vnode_t *cmpvp, *pvp = NULL; 996 vnode_t *startvp = vp; 997 int err = 0; 998 size_t complen; 999 char *dbuf; 1000 dirent64_t *dp; 1001 char *bufloc; 1002 size_t dlen = DIRENT64_RECLEN(MAXPATHLEN); 1003 refstr_t *mntpt; 1004 1005 /* Operation only allowed on directories */ 1006 ASSERT(vp->v_type == VDIR); 1007 1008 /* We must have at least enough space for "/" */ 1009 if (buflen < 2) 1010 return (ENAMETOOLONG); 1011 1012 /* Start at end of string with terminating null */ 1013 bufloc = &buf[buflen - 1]; 1014 *bufloc = '\0'; 1015 1016 pn_alloc(&pn); 1017 pn_alloc(&rpn); 1018 dbuf = kmem_alloc(dlen, KM_SLEEP); 1019 bzero(&emptypn, sizeof (emptypn)); 1020 1021 /* 1022 * Begin with an additional reference on vp. This will be decremented 1023 * during the loop. 1024 */ 1025 VN_HOLD(vp); 1026 1027 for (;;) { 1028 /* 1029 * Return if we've reached the root. If the buffer is empty, 1030 * return '/'. We explicitly don't use vn_compare(), since it 1031 * compares the real vnodes. A lofs mount of '/' would produce 1032 * incorrect results otherwise. 1033 */ 1034 if (VN_CMP(vrootp, vp)) { 1035 if (*bufloc == '\0') 1036 *--bufloc = '/'; 1037 break; 1038 } 1039 1040 /* 1041 * If we've reached the VFS root, something has gone wrong. We 1042 * should have reached the root in the above check. The only 1043 * explantation is that 'vp' is not contained withing the given 1044 * root, in which case we return EPERM. 1045 */ 1046 if (VN_CMP(rootdir, vp)) { 1047 err = EPERM; 1048 goto out; 1049 } 1050 1051 /* 1052 * Shortcut: see if this vnode is a mountpoint. If so, 1053 * grab the path information from the vfs_t. 1054 */ 1055 if (vp->v_flag & VROOT) { 1056 1057 mntpt = vfs_getmntpoint(vp->v_vfsp); 1058 if ((err = pn_set(&pn, (char *)refstr_value(mntpt))) 1059 == 0) { 1060 refstr_rele(mntpt); 1061 rpn.pn_path = rpn.pn_buf; 1062 1063 /* 1064 * Ensure the mointpoint still exists. 1065 */ 1066 VN_HOLD(vrootp); 1067 if (vrootp != rootdir) 1068 VN_HOLD(vrootp); 1069 if (lookuppnvp(&pn, &rpn, 0, NULL, 1070 &cmpvp, vrootp, vrootp, cr) == 0) { 1071 1072 if (VN_CMP(vp, cmpvp)) { 1073 VN_RELE(cmpvp); 1074 1075 complen = strlen(rpn.pn_path); 1076 bufloc -= complen; 1077 if (bufloc < buf) { 1078 err = ERANGE; 1079 goto out; 1080 } 1081 bcopy(rpn.pn_path, bufloc, 1082 complen); 1083 break; 1084 } else { 1085 VN_RELE(cmpvp); 1086 } 1087 } 1088 } else { 1089 refstr_rele(mntpt); 1090 } 1091 } 1092 1093 /* 1094 * Shortcuts failed, search for this vnode in its parent. If 1095 * this is a mountpoint, then get the vnode underneath. 1096 */ 1097 if (vp->v_flag & VROOT) 1098 vp = vn_under(vp); 1099 if ((err = VOP_LOOKUP(vp, "..", &pvp, &emptypn, 0, vrootp, cr, 1100 NULL, NULL, NULL)) != 0) 1101 goto out; 1102 1103 /* 1104 * With extended attributes, it's possible for a directory to 1105 * have a parent that is a regular file. Check for that here. 1106 */ 1107 if (pvp->v_type != VDIR) { 1108 err = ENOTDIR; 1109 goto out; 1110 } 1111 1112 /* 1113 * If this is true, something strange has happened. This is 1114 * only true if we are the root of a filesystem, which should 1115 * have been caught by the check above. 1116 */ 1117 if (VN_CMP(pvp, vp)) { 1118 err = ENOENT; 1119 goto out; 1120 } 1121 1122 /* 1123 * Search the parent directory for the entry corresponding to 1124 * this vnode. 1125 */ 1126 if ((err = dirfindvp(vrootp, pvp, vp, cr, dbuf, dlen, &dp)) 1127 != 0) 1128 goto out; 1129 complen = strlen(dp->d_name); 1130 bufloc -= complen; 1131 if (bufloc <= buf) { 1132 err = ENAMETOOLONG; 1133 goto out; 1134 } 1135 bcopy(dp->d_name, bufloc, complen); 1136 1137 /* Prepend a slash to the current path. */ 1138 *--bufloc = '/'; 1139 1140 /* And continue with the next component */ 1141 VN_RELE(vp); 1142 vp = pvp; 1143 pvp = NULL; 1144 } 1145 1146 /* 1147 * Place the path at the beginning of the buffer. 1148 */ 1149 if (bufloc != buf) 1150 ovbcopy(bufloc, buf, buflen - (bufloc - buf)); 1151 1152 out: 1153 /* 1154 * If the error was ESTALE and the current directory to look in 1155 * was the root for this lookup, the root for a mounted file 1156 * system, or the starting directory for lookups, then 1157 * return ENOENT instead of ESTALE. In this case, no recovery 1158 * is possible by the higher level. If ESTALE was returned for 1159 * some intermediate directory along the path, then recovery 1160 * is potentially possible and retrying from the higher level 1161 * will either correct the situation by purging stale cache 1162 * entries or eventually get back to the point where no recovery 1163 * is possible. 1164 */ 1165 if (err == ESTALE && 1166 (VN_CMP(vp, vrootp) || (vp->v_flag & VROOT) || vp == startvp)) 1167 err = ENOENT; 1168 1169 kmem_free(dbuf, dlen); 1170 VN_RELE(vp); 1171 if (pvp) 1172 VN_RELE(pvp); 1173 pn_free(&pn); 1174 pn_free(&rpn); 1175 1176 return (err); 1177 } 1178 1179 /* 1180 * The additional flag, LOOKUP_CHECKREAD, is ued to enforce artificial 1181 * constraints in order to be standards compliant. For example, if we have 1182 * the cached path of '/foo/bar', and '/foo' has permissions 100 (execute 1183 * only), then we can legitimately look up the path to the current working 1184 * directory without needing read permission. Existing standards tests, 1185 * however, assume that we are determining the path by repeatedly looking up 1186 * "..". We need to keep this behavior in order to maintain backwards 1187 * compatibility. 1188 */ 1189 static int 1190 vnodetopath_common(vnode_t *vrootp, vnode_t *vp, char *buf, size_t buflen, 1191 cred_t *cr, int flags) 1192 { 1193 pathname_t pn, rpn; 1194 int ret, len; 1195 vnode_t *compvp, *pvp, *realvp; 1196 proc_t *p = curproc; 1197 char path[MAXNAMELEN]; 1198 int doclose = 0; 1199 1200 /* 1201 * If vrootp is NULL, get the root for curproc. Callers with any other 1202 * requirements should pass in a different vrootp. 1203 */ 1204 if (vrootp == NULL) { 1205 mutex_enter(&p->p_lock); 1206 if ((vrootp = PTOU(p)->u_rdir) == NULL) 1207 vrootp = rootdir; 1208 VN_HOLD(vrootp); 1209 mutex_exit(&p->p_lock); 1210 } else { 1211 VN_HOLD(vrootp); 1212 } 1213 1214 /* 1215 * This is to get around an annoying artifact of the /proc filesystem, 1216 * which is the behavior of {cwd/root}. Trying to resolve this path 1217 * will result in /proc/pid/cwd instead of whatever the real working 1218 * directory is. We can't rely on VOP_REALVP(), since that will break 1219 * lofs. The only difference between procfs and lofs is that opening 1220 * the file will return the underling vnode in the case of procfs. 1221 */ 1222 if (vp->v_type == VDIR && VOP_REALVP(vp, &realvp, NULL) == 0 && 1223 realvp != vp) { 1224 VN_HOLD(vp); 1225 if (VOP_OPEN(&vp, FREAD, cr, NULL) == 0) 1226 doclose = 1; 1227 else 1228 VN_RELE(vp); 1229 } 1230 1231 pn_alloc(&pn); 1232 1233 /* 1234 * Check to see if we have a cached path in the vnode. 1235 */ 1236 mutex_enter(&vp->v_lock); 1237 if (vp->v_path != NULL) { 1238 (void) pn_set(&pn, vp->v_path); 1239 mutex_exit(&vp->v_lock); 1240 1241 pn_alloc(&rpn); 1242 1243 /* We should only cache absolute paths */ 1244 ASSERT(pn.pn_buf[0] == '/'); 1245 1246 /* 1247 * If we are in a zone or a chroot environment, then we have to 1248 * take additional steps, since the path to the root might not 1249 * be readable with the current credentials, even though the 1250 * process can legitmately access the file. In this case, we 1251 * do the following: 1252 * 1253 * lookuppnvp() with all privileges to get the resolved path. 1254 * call localpath() to get the local portion of the path, and 1255 * continue as normal. 1256 * 1257 * If the the conversion to a local path fails, then we continue 1258 * as normal. This is a heuristic to make process object file 1259 * paths available from within a zone. Because lofs doesn't 1260 * support page operations, the vnode stored in the seg_t is 1261 * actually the underlying real vnode, not the lofs node itself. 1262 * Most of the time, the lofs path is the same as the underlying 1263 * vnode (for example, /usr/lib/libc.so.1). 1264 */ 1265 if (vrootp != rootdir) { 1266 char *local = NULL; 1267 VN_HOLD(rootdir); 1268 if (lookuppnvp(&pn, &rpn, FOLLOW, 1269 NULL, &compvp, rootdir, rootdir, kcred) == 0) { 1270 local = localpath(rpn.pn_path, vrootp, 1271 kcred); 1272 VN_RELE(compvp); 1273 } 1274 1275 /* 1276 * The original pn was changed through lookuppnvp(), so 1277 * reset it. 1278 */ 1279 if (local) { 1280 (void) pn_set(&pn, local); 1281 } else { 1282 mutex_enter(&vp->v_lock); 1283 if (vp->v_path != NULL) { 1284 (void) pn_set(&pn, vp->v_path); 1285 mutex_exit(&vp->v_lock); 1286 } else { 1287 mutex_exit(&vp->v_lock); 1288 goto notcached; 1289 } 1290 } 1291 } 1292 1293 /* 1294 * We should have a local path at this point, so start the 1295 * search from the root of the current process. 1296 */ 1297 VN_HOLD(vrootp); 1298 if (vrootp != rootdir) 1299 VN_HOLD(vrootp); 1300 ret = lookuppnvp(&pn, &rpn, FOLLOW | flags, NULL, 1301 &compvp, vrootp, vrootp, cr); 1302 if (ret == 0) { 1303 /* 1304 * Check to see if the returned vnode is the same as 1305 * the one we expect. If not, give up. 1306 */ 1307 if (!vn_compare(vp, compvp) && 1308 !vnode_match(vp, compvp, cr)) { 1309 VN_RELE(compvp); 1310 goto notcached; 1311 } 1312 1313 VN_RELE(compvp); 1314 1315 /* 1316 * Return the result. 1317 */ 1318 if (buflen <= rpn.pn_pathlen) 1319 goto notcached; 1320 1321 bcopy(rpn.pn_path, buf, rpn.pn_pathlen + 1); 1322 pn_free(&pn); 1323 pn_free(&rpn); 1324 VN_RELE(vrootp); 1325 if (doclose) { 1326 (void) VOP_CLOSE(vp, FREAD, 1, 0, cr, NULL); 1327 VN_RELE(vp); 1328 } 1329 return (0); 1330 } 1331 1332 notcached: 1333 pn_free(&rpn); 1334 } else { 1335 mutex_exit(&vp->v_lock); 1336 } 1337 1338 pn_free(&pn); 1339 1340 if (vp->v_type != VDIR) { 1341 /* 1342 * If we don't have a directory, try to find it in the dnlc via 1343 * reverse lookup. Once this is found, we can use the regular 1344 * directory search to find the full path. 1345 */ 1346 if ((pvp = dnlc_reverse_lookup(vp, path, MAXNAMELEN)) != NULL) { 1347 ret = dirtopath(vrootp, pvp, buf, buflen, cr); 1348 if (ret == 0) { 1349 len = strlen(buf); 1350 if (len + strlen(path) + 1 >= buflen) { 1351 ret = ENAMETOOLONG; 1352 } else { 1353 if (buf[len - 1] != '/') 1354 buf[len++] = '/'; 1355 bcopy(path, buf + len, 1356 strlen(path) + 1); 1357 } 1358 } 1359 1360 VN_RELE(pvp); 1361 } else 1362 ret = ENOENT; 1363 } else 1364 ret = dirtopath(vrootp, vp, buf, buflen, cr); 1365 1366 VN_RELE(vrootp); 1367 if (doclose) { 1368 (void) VOP_CLOSE(vp, FREAD, 1, 0, cr, NULL); 1369 VN_RELE(vp); 1370 } 1371 1372 return (ret); 1373 } 1374 1375 int 1376 vnodetopath(vnode_t *vrootp, vnode_t *vp, char *buf, size_t buflen, cred_t *cr) 1377 { 1378 return (vnodetopath_common(vrootp, vp, buf, buflen, cr, 0)); 1379 } 1380 1381 int 1382 dogetcwd(char *buf, size_t buflen) 1383 { 1384 int ret; 1385 vnode_t *vp; 1386 vnode_t *compvp; 1387 refstr_t *cwd, *oldcwd; 1388 const char *value; 1389 pathname_t rpnp, pnp; 1390 proc_t *p = curproc; 1391 1392 /* 1393 * Check to see if there is a cached version of the cwd. If so, lookup 1394 * the cached value and make sure it is the same vnode. 1395 */ 1396 mutex_enter(&p->p_lock); 1397 if ((cwd = PTOU(p)->u_cwd) != NULL) 1398 refstr_hold(cwd); 1399 vp = PTOU(p)->u_cdir; 1400 VN_HOLD(vp); 1401 mutex_exit(&p->p_lock); 1402 1403 /* 1404 * Make sure we have permission to access the current directory. 1405 */ 1406 if ((ret = VOP_ACCESS(vp, VEXEC, 0, CRED(), NULL)) != 0) { 1407 if (cwd != NULL) 1408 refstr_rele(cwd); 1409 VN_RELE(vp); 1410 return (ret); 1411 } 1412 1413 if (cwd) { 1414 value = refstr_value(cwd); 1415 if ((ret = pn_get((char *)value, UIO_SYSSPACE, &pnp)) != 0) { 1416 refstr_rele(cwd); 1417 VN_RELE(vp); 1418 return (ret); 1419 } 1420 1421 pn_alloc(&rpnp); 1422 1423 if (lookuppn(&pnp, &rpnp, NO_FOLLOW, NULL, &compvp) == 0) { 1424 1425 if (VN_CMP(vp, compvp) && 1426 strcmp(value, rpnp.pn_path) == 0) { 1427 VN_RELE(compvp); 1428 VN_RELE(vp); 1429 pn_free(&pnp); 1430 pn_free(&rpnp); 1431 if (strlen(value) + 1 > buflen) { 1432 refstr_rele(cwd); 1433 return (ENAMETOOLONG); 1434 } 1435 bcopy(value, buf, strlen(value) + 1); 1436 refstr_rele(cwd); 1437 return (0); 1438 } 1439 1440 VN_RELE(compvp); 1441 } 1442 1443 pn_free(&rpnp); 1444 pn_free(&pnp); 1445 1446 refstr_rele(cwd); 1447 } 1448 1449 ret = vnodetopath_common(NULL, vp, buf, buflen, CRED(), 1450 LOOKUP_CHECKREAD); 1451 1452 VN_RELE(vp); 1453 1454 /* 1455 * Store the new cwd and replace the existing cached copy. 1456 */ 1457 if (ret == 0) 1458 cwd = refstr_alloc(buf); 1459 else 1460 cwd = NULL; 1461 1462 mutex_enter(&p->p_lock); 1463 oldcwd = PTOU(p)->u_cwd; 1464 PTOU(p)->u_cwd = cwd; 1465 mutex_exit(&p->p_lock); 1466 1467 if (oldcwd) 1468 refstr_rele(oldcwd); 1469 1470 return (ret); 1471 } 1472