1 /* $NetBSD: vfs_getcwd.c,v 1.17 2003/04/16 20:00:03 christos Exp $ */ 2 3 /*- 4 * Copyright (c) 1999 The NetBSD Foundation, Inc. 5 * All rights reserved. 6 * 7 * This code is derived from software contributed to The NetBSD Foundation 8 * by Bill Sommerfeld. 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 * 3. All advertising materials mentioning features or use of this software 19 * must display the following acknowledgement: 20 * This product includes software developed by the NetBSD 21 * Foundation, Inc. and its contributors. 22 * 4. Neither the name of The NetBSD Foundation nor the names of its 23 * contributors may be used to endorse or promote products derived 24 * from this software without specific prior written permission. 25 * 26 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 27 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 28 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 29 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 30 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 31 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 32 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 33 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 34 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 35 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 36 * POSSIBILITY OF SUCH DAMAGE. 37 */ 38 39 #include <sys/cdefs.h> 40 __KERNEL_RCSID(0, "$NetBSD: vfs_getcwd.c,v 1.17 2003/04/16 20:00:03 christos Exp $"); 41 42 #include <sys/param.h> 43 #include <sys/systm.h> 44 #include <sys/namei.h> 45 #include <sys/filedesc.h> 46 #include <sys/kernel.h> 47 #include <sys/file.h> 48 #include <sys/stat.h> 49 #include <sys/vnode.h> 50 #include <sys/mount.h> 51 #include <sys/proc.h> 52 #include <sys/uio.h> 53 #include <sys/malloc.h> 54 #include <sys/dirent.h> 55 #include <ufs/ufs/dir.h> /* XXX only for DIRBLKSIZ */ 56 57 #include <sys/sa.h> 58 #include <sys/syscallargs.h> 59 60 static int 61 getcwd_scandir __P((struct vnode **, struct vnode **, 62 char **, char *, struct proc *)); 63 static int 64 getcwd_getcache __P((struct vnode **, struct vnode **, 65 char **, char *)); 66 67 #define DIRENT_MINSIZE (sizeof(struct dirent) - (MAXNAMLEN+1) + 4) 68 69 /* 70 * Vnode variable naming conventions in this file: 71 * 72 * rvp: the current root we're aiming towards. 73 * lvp, *lvpp: the "lower" vnode 74 * uvp, *uvpp: the "upper" vnode. 75 * 76 * Since all the vnodes we're dealing with are directories, and the 77 * lookups are going *up* in the filesystem rather than *down*, the 78 * usual "pvp" (parent) or "dvp" (directory) naming conventions are 79 * too confusing. 80 */ 81 82 /* 83 * XXX Will infinite loop in certain cases if a directory read reliably 84 * returns EINVAL on last block. 85 * XXX is EINVAL the right thing to return if a directory is malformed? 86 */ 87 88 /* 89 * XXX Untested vs. mount -o union; probably does the wrong thing. 90 */ 91 92 /* 93 * Find parent vnode of *lvpp, return in *uvpp 94 * 95 * If we care about the name, scan it looking for name of directory 96 * entry pointing at lvp. 97 * 98 * Place the name in the buffer which starts at bufp, immediately 99 * before *bpp, and move bpp backwards to point at the start of it. 100 * 101 * On entry, *lvpp is a locked vnode reference; on exit, it is vput and NULL'ed 102 * On exit, *uvpp is either NULL or is a locked vnode reference. 103 */ 104 static int 105 getcwd_scandir(lvpp, uvpp, bpp, bufp, p) 106 struct vnode **lvpp; 107 struct vnode **uvpp; 108 char **bpp; 109 char *bufp; 110 struct proc *p; 111 { 112 int error = 0; 113 int eofflag; 114 off_t off; 115 int tries; 116 struct uio uio; 117 struct iovec iov; 118 char *dirbuf = NULL; 119 int dirbuflen; 120 ino_t fileno; 121 struct vattr va; 122 struct vnode *uvp = NULL; 123 struct vnode *lvp = *lvpp; 124 struct componentname cn; 125 int len, reclen; 126 tries = 0; 127 128 /* 129 * If we want the filename, get some info we need while the 130 * current directory is still locked. 131 */ 132 if (bufp != NULL) { 133 error = VOP_GETATTR(lvp, &va, p->p_ucred, p); 134 if (error) { 135 vput(lvp); 136 *lvpp = NULL; 137 *uvpp = NULL; 138 return error; 139 } 140 } 141 142 /* 143 * Ok, we have to do it the hard way.. 144 * Next, get parent vnode using lookup of .. 145 */ 146 cn.cn_nameiop = LOOKUP; 147 cn.cn_flags = ISLASTCN | ISDOTDOT | RDONLY; 148 cn.cn_proc = p; 149 cn.cn_cred = p->p_ucred; 150 cn.cn_pnbuf = NULL; 151 cn.cn_nameptr = ".."; 152 cn.cn_namelen = 2; 153 cn.cn_hash = 0; 154 cn.cn_consume = 0; 155 156 /* 157 * At this point, lvp is locked and will be unlocked by the lookup. 158 * On successful return, *uvpp will be locked 159 */ 160 error = VOP_LOOKUP(lvp, uvpp, &cn); 161 if (error) { 162 vput(lvp); 163 *lvpp = NULL; 164 *uvpp = NULL; 165 return error; 166 } 167 uvp = *uvpp; 168 169 /* If we don't care about the pathname, we're done */ 170 if (bufp == NULL) { 171 vrele(lvp); 172 *lvpp = NULL; 173 return 0; 174 } 175 176 fileno = va.va_fileid; 177 178 dirbuflen = DIRBLKSIZ; 179 if (dirbuflen < va.va_blocksize) 180 dirbuflen = va.va_blocksize; 181 dirbuf = (char *)malloc(dirbuflen, M_TEMP, M_WAITOK); 182 183 #if 0 184 unionread: 185 #endif 186 off = 0; 187 do { 188 /* call VOP_READDIR of parent */ 189 iov.iov_base = dirbuf; 190 iov.iov_len = dirbuflen; 191 192 uio.uio_iov = &iov; 193 uio.uio_iovcnt = 1; 194 uio.uio_offset = off; 195 uio.uio_resid = dirbuflen; 196 uio.uio_segflg = UIO_SYSSPACE; 197 uio.uio_rw = UIO_READ; 198 uio.uio_procp = p; 199 200 eofflag = 0; 201 202 error = VOP_READDIR(uvp, &uio, p->p_ucred, &eofflag, 0, 0); 203 204 off = uio.uio_offset; 205 206 /* 207 * Try again if NFS tosses its cookies. 208 * XXX this can still loop forever if the directory is busted 209 * such that the second or subsequent page of it always 210 * returns EINVAL 211 */ 212 if ((error == EINVAL) && (tries < 3)) { 213 off = 0; 214 tries++; 215 continue; /* once more, with feeling */ 216 } 217 218 if (!error) { 219 char *cpos; 220 struct dirent *dp; 221 222 cpos = dirbuf; 223 tries = 0; 224 225 /* scan directory page looking for matching vnode */ 226 for (len = (dirbuflen - uio.uio_resid); len > 0; len -= reclen) { 227 dp = (struct dirent *) cpos; 228 reclen = dp->d_reclen; 229 230 /* check for malformed directory.. */ 231 if (reclen < DIRENT_MINSIZE) { 232 error = EINVAL; 233 goto out; 234 } 235 /* 236 * XXX should perhaps do VOP_LOOKUP to 237 * check that we got back to the right place, 238 * but getting the locking games for that 239 * right would be heinous. 240 */ 241 if ((dp->d_type != DT_WHT) && 242 (dp->d_fileno == fileno)) { 243 char *bp = *bpp; 244 bp -= dp->d_namlen; 245 246 if (bp <= bufp) { 247 error = ERANGE; 248 goto out; 249 } 250 memcpy(bp, dp->d_name, dp->d_namlen); 251 error = 0; 252 *bpp = bp; 253 goto out; 254 } 255 cpos += reclen; 256 } 257 } else 258 goto out; 259 } while (!eofflag); 260 #if 0 261 /* 262 * Deal with mount -o union, which unions only the 263 * root directory of the mount. 264 */ 265 if ((uvp->v_flag & VROOT) && 266 (uvp->v_mount->mnt_flag & MNT_UNION)) { 267 struct vnode *tvp = uvp; 268 uvp = uvp->v_mount->mnt_vnodecovered; 269 vput(tvp); 270 VREF(uvp); 271 *uvpp = uvp; 272 error = vn_lock(uvp, LK_EXCLUSIVE | LK_RETRY); 273 if (error != 0) { 274 vrele(uvp); 275 *uvpp = uvp = NULL; 276 goto out; 277 } 278 goto unionread; 279 } 280 #endif 281 error = ENOENT; 282 283 out: 284 vrele(lvp); 285 *lvpp = NULL; 286 free(dirbuf, M_TEMP); 287 return error; 288 } 289 290 /* 291 * Look in the vnode-to-name reverse cache to see if 292 * we can find things the easy way. 293 * 294 * XXX vget failure path is untested. 295 * 296 * On entry, *lvpp is a locked vnode reference. 297 * On exit, one of the following is the case: 298 * 0) Both *lvpp and *uvpp are NULL and failure is returned. 299 * 1) *uvpp is NULL, *lvpp remains locked and -1 is returned (cache miss) 300 * 2) *uvpp is a locked vnode reference, *lvpp is vput and NULL'ed 301 * and 0 is returned (cache hit) 302 */ 303 304 static int 305 getcwd_getcache(lvpp, uvpp, bpp, bufp) 306 struct vnode **lvpp, **uvpp; 307 char **bpp; 308 char *bufp; 309 { 310 struct vnode *lvp, *uvp = NULL; 311 int error; 312 int vpid; 313 314 lvp = *lvpp; 315 316 /* 317 * This returns 0 on a cache hit, -1 on a clean cache miss, 318 * or an errno on other failure. 319 */ 320 error = cache_revlookup(lvp, uvpp, bpp, bufp); 321 if (error) { 322 if (error != -1) { 323 vput(lvp); 324 *lvpp = NULL; 325 *uvpp = NULL; 326 } 327 return error; 328 } 329 uvp = *uvpp; 330 vpid = uvp->v_id; 331 332 /* 333 * Since we're going up, we have to release the current lock 334 * before we take the parent lock. 335 */ 336 337 VOP_UNLOCK(lvp, 0); 338 339 error = vget(uvp, LK_EXCLUSIVE | LK_RETRY); 340 if (error != 0) 341 *uvpp = NULL; 342 /* 343 * Verify that vget succeeded, and check that vnode capability 344 * didn't change while we were waiting for the lock. 345 */ 346 if (error || (vpid != uvp->v_id)) { 347 /* 348 * Oops, we missed. If the vget failed, or the 349 * capability changed, try to get our lock back; if 350 * that works, tell caller to try things the hard way, 351 * otherwise give up. 352 */ 353 if (!error) vput(uvp); 354 *uvpp = NULL; 355 356 error = vn_lock(lvp, LK_EXCLUSIVE | LK_RETRY); 357 358 if (!error) 359 return -1; 360 } 361 vrele(lvp); 362 *lvpp = NULL; 363 364 return error; 365 } 366 367 /* 368 * common routine shared by sys___getcwd() and vn_isunder() 369 */ 370 371 int 372 getcwd_common (lvp, rvp, bpp, bufp, limit, flags, p) 373 struct vnode *lvp; 374 struct vnode *rvp; 375 char **bpp; 376 char *bufp; 377 int limit; 378 int flags; 379 struct proc *p; 380 { 381 struct cwdinfo *cwdi = p->p_cwdi; 382 struct vnode *uvp = NULL; 383 char *bp = NULL; 384 int error; 385 int perms = VEXEC; 386 387 if (rvp == NULL) { 388 rvp = cwdi->cwdi_rdir; 389 if (rvp == NULL) 390 rvp = rootvnode; 391 } 392 393 VREF(rvp); 394 VREF(lvp); 395 396 /* 397 * Error handling invariant: 398 * Before a `goto out': 399 * lvp is either NULL, or locked and held. 400 * uvp is either NULL, or locked and held. 401 */ 402 403 error = vn_lock(lvp, LK_EXCLUSIVE | LK_RETRY); 404 if (error) { 405 vrele(lvp); 406 lvp = NULL; 407 goto out; 408 } 409 if (bufp) 410 bp = *bpp; 411 /* 412 * this loop will terminate when one of the following happens: 413 * - we hit the root 414 * - getdirentries or lookup fails 415 * - we run out of space in the buffer. 416 */ 417 if (lvp == rvp) { 418 if (bp) 419 *(--bp) = '/'; 420 goto out; 421 } 422 do { 423 if (lvp->v_type != VDIR) { 424 error = ENOTDIR; 425 goto out; 426 } 427 428 /* 429 * access check here is optional, depending on 430 * whether or not caller cares. 431 */ 432 if (flags & GETCWD_CHECK_ACCESS) { 433 error = VOP_ACCESS(lvp, perms, p->p_ucred, p); 434 if (error) 435 goto out; 436 perms = VEXEC|VREAD; 437 } 438 439 /* 440 * step up if we're a covered vnode.. 441 */ 442 while (lvp->v_flag & VROOT) { 443 struct vnode *tvp; 444 445 if (lvp == rvp) 446 goto out; 447 448 tvp = lvp; 449 lvp = lvp->v_mount->mnt_vnodecovered; 450 vput(tvp); 451 /* 452 * hodie natus est radici frater 453 */ 454 if (lvp == NULL) { 455 error = ENOENT; 456 goto out; 457 } 458 VREF(lvp); 459 error = vn_lock(lvp, LK_EXCLUSIVE | LK_RETRY); 460 if (error != 0) { 461 vrele(lvp); 462 lvp = NULL; 463 goto out; 464 } 465 } 466 /* 467 * Look in the name cache; if that fails, look in the 468 * directory.. 469 */ 470 error = getcwd_getcache(&lvp, &uvp, &bp, bufp); 471 if (error == -1) 472 error = getcwd_scandir(&lvp, &uvp, &bp, bufp, p); 473 if (error) 474 goto out; 475 #if DIAGNOSTIC 476 if (lvp != NULL) 477 panic("getcwd: oops, forgot to null lvp"); 478 if (bufp && (bp <= bufp)) { 479 panic("getcwd: oops, went back too far"); 480 } 481 #endif 482 if (bp) 483 *(--bp) = '/'; 484 lvp = uvp; 485 uvp = NULL; 486 limit--; 487 } while ((lvp != rvp) && (limit > 0)); 488 489 out: 490 if (bpp) 491 *bpp = bp; 492 if (uvp) 493 vput(uvp); 494 if (lvp) 495 vput(lvp); 496 vrele(rvp); 497 return error; 498 } 499 500 /* 501 * Check if one directory can be found inside another in the directory 502 * hierarchy. 503 * 504 * Intended to be used in chroot, chdir, fchdir, etc., to ensure that 505 * chroot() actually means something. 506 */ 507 int 508 vn_isunder(lvp, rvp, p) 509 struct vnode *lvp; 510 struct vnode *rvp; 511 struct proc *p; 512 { 513 int error; 514 515 error = getcwd_common (lvp, rvp, NULL, NULL, MAXPATHLEN/2, 0, p); 516 517 if (!error) 518 return 1; 519 else 520 return 0; 521 } 522 523 /* 524 * Returns true if proc p1's root directory equal to or under p2's 525 * root directory. 526 * 527 * Intended to be used from ptrace/procfs sorts of things. 528 */ 529 530 int 531 proc_isunder (p1, p2) 532 struct proc *p1; 533 struct proc *p2; 534 { 535 struct vnode *r1 = p1->p_cwdi->cwdi_rdir; 536 struct vnode *r2 = p2->p_cwdi->cwdi_rdir; 537 538 if (r1 == NULL) 539 return (r2 == NULL); 540 else if (r2 == NULL) 541 return 1; 542 else 543 return vn_isunder(r1, r2, p2); 544 } 545 546 /* 547 * Find pathname of process's current directory. 548 * 549 * Use vfs vnode-to-name reverse cache; if that fails, fall back 550 * to reading directory contents. 551 */ 552 553 int 554 sys___getcwd(l, v, retval) 555 struct lwp *l; 556 void *v; 557 register_t *retval; 558 { 559 struct sys___getcwd_args /* { 560 syscallarg(char *) bufp; 561 syscallarg(size_t) length; 562 } */ *uap = v; 563 564 int error; 565 char *path; 566 char *bp, *bend; 567 int len = SCARG(uap, length); 568 int lenused; 569 570 if (len > MAXPATHLEN*4) 571 len = MAXPATHLEN*4; 572 else if (len < 2) 573 return ERANGE; 574 575 path = (char *)malloc(len, M_TEMP, M_WAITOK); 576 if (!path) 577 return ENOMEM; 578 579 bp = &path[len]; 580 bend = bp; 581 *(--bp) = '\0'; 582 583 /* 584 * 5th argument here is "max number of vnodes to traverse". 585 * Since each entry takes up at least 2 bytes in the output buffer, 586 * limit it to N/2 vnodes for an N byte buffer. 587 */ 588 error = getcwd_common (l->l_proc->p_cwdi->cwdi_cdir, NULL, &bp, path, 589 len/2, GETCWD_CHECK_ACCESS, l->l_proc); 590 591 if (error) 592 goto out; 593 lenused = bend - bp; 594 *retval = lenused; 595 /* put the result into user buffer */ 596 error = copyout(bp, SCARG(uap, bufp), lenused); 597 598 out: 599 free(path, M_TEMP); 600 return error; 601 } 602