1 /*- 2 * Copyright (c) 2014 The FreeBSD Foundation 3 * All rights reserved. 4 * 5 * This software was developed by Edward Tomasz Napierala under sponsorship 6 * from the FreeBSD Foundation. 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: 11 * 1. Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * 2. Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in the 15 * documentation and/or other materials provided with the distribution. 16 * 17 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 18 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 19 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 20 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 21 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 22 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 23 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 24 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 25 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 26 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 27 * SUCH DAMAGE. 28 * 29 */ 30 31 #include <sys/cdefs.h> 32 __FBSDID("$FreeBSD$"); 33 34 #include <sys/param.h> 35 #include <sys/kernel.h> 36 #include <sys/condvar.h> 37 #include <sys/dirent.h> 38 #include <sys/fcntl.h> 39 #include <sys/lock.h> 40 #include <sys/mount.h> 41 #include <sys/mutex.h> 42 #include <sys/namei.h> 43 #include <sys/signalvar.h> 44 #include <sys/stat.h> 45 #include <sys/systm.h> 46 #include <sys/taskqueue.h> 47 #include <sys/vnode.h> 48 #include <machine/atomic.h> 49 #include <vm/uma.h> 50 51 #include <fs/autofs/autofs.h> 52 53 static int autofs_trigger_vn(struct vnode *vp, const char *path, 54 int pathlen, struct vnode **newvp); 55 56 extern struct autofs_softc *autofs_softc; 57 58 static int 59 autofs_access(struct vop_access_args *ap) 60 { 61 62 /* 63 * Nothing to do here; the only kind of access control 64 * needed is in autofs_mkdir(). 65 */ 66 67 return (0); 68 } 69 70 static int 71 autofs_getattr(struct vop_getattr_args *ap) 72 { 73 struct vnode *vp, *newvp; 74 struct autofs_node *anp; 75 struct mount *mp; 76 struct vattr *vap; 77 int error; 78 79 vp = ap->a_vp; 80 anp = vp->v_data; 81 mp = vp->v_mount; 82 vap = ap->a_vap; 83 84 KASSERT(ap->a_vp->v_type == VDIR, ("!VDIR")); 85 86 /* 87 * The reason we must do this is that some tree-walking software, 88 * namely fts(3), assumes that stat(".") results will not change 89 * between chdir("subdir") and chdir(".."), and fails with ENOENT 90 * otherwise. 91 */ 92 if (autofs_mount_on_stat && autofs_cached(anp, NULL, 0) == false && 93 autofs_ignore_thread(curthread) == false) { 94 error = autofs_trigger_vn(vp, "", 0, &newvp); 95 if (error != 0) 96 return (error); 97 98 if (newvp != NULL) { 99 error = VOP_GETATTR(newvp, ap->a_vap, 100 ap->a_cred); 101 vput(newvp); 102 return (error); 103 } 104 } 105 106 vap->va_type = VDIR; 107 vap->va_mode = 0755; 108 vap->va_nlink = 3; /* XXX */ 109 vap->va_uid = 0; 110 vap->va_gid = 0; 111 vap->va_rdev = NODEV; 112 vap->va_fsid = mp->mnt_stat.f_fsid.val[0]; 113 vap->va_fileid = anp->an_fileno; 114 vap->va_size = S_BLKSIZE; 115 vap->va_blocksize = S_BLKSIZE; 116 vap->va_mtime = anp->an_ctime; 117 vap->va_atime = anp->an_ctime; 118 vap->va_ctime = anp->an_ctime; 119 vap->va_birthtime = anp->an_ctime; 120 vap->va_gen = 0; 121 vap->va_flags = 0; 122 vap->va_rdev = 0; 123 vap->va_bytes = S_BLKSIZE; 124 vap->va_filerev = 0; 125 vap->va_spare = 0; 126 127 return (0); 128 } 129 130 /* 131 * Unlock the vnode, request automountd(8) action, and then lock it back. 132 * If anything got mounted on top of the vnode, return the new filesystem's 133 * root vnode in 'newvp', locked. 134 */ 135 static int 136 autofs_trigger_vn(struct vnode *vp, const char *path, int pathlen, 137 struct vnode **newvp) 138 { 139 struct autofs_node *anp; 140 struct autofs_mount *amp; 141 int error, lock_flags; 142 143 anp = vp->v_data; 144 amp = VFSTOAUTOFS(vp->v_mount); 145 146 /* 147 * Release the vnode lock, so that other operations, in partcular 148 * mounting a filesystem on top of it, can proceed. Increase use 149 * count, to prevent the vnode from being deallocated and to prevent 150 * filesystem from being unmounted. 151 */ 152 lock_flags = VOP_ISLOCKED(vp); 153 vref(vp); 154 VOP_UNLOCK(vp, 0); 155 156 sx_xlock(&autofs_softc->sc_lock); 157 158 /* 159 * XXX: Workaround for mounting the same thing multiple times; revisit. 160 */ 161 if (vp->v_mountedhere != NULL) { 162 error = 0; 163 goto mounted; 164 } 165 166 error = autofs_trigger(anp, path, pathlen); 167 mounted: 168 sx_xunlock(&autofs_softc->sc_lock); 169 vn_lock(vp, lock_flags | LK_RETRY); 170 vunref(vp); 171 if ((vp->v_iflag & VI_DOOMED) != 0) { 172 AUTOFS_DEBUG("VI_DOOMED"); 173 return (ENOENT); 174 } 175 176 if (error != 0) 177 return (error); 178 179 if (vp->v_mountedhere == NULL) { 180 *newvp = NULL; 181 return (0); 182 } else { 183 /* 184 * If the operation that succeeded was mount, then mark 185 * the node as non-cached. Otherwise, if someone unmounts 186 * the filesystem before the cache times out, we will fail 187 * to trigger. 188 */ 189 anp->an_cached = false; 190 } 191 192 error = VFS_ROOT(vp->v_mountedhere, lock_flags, newvp); 193 if (error != 0) { 194 AUTOFS_WARN("VFS_ROOT() failed with error %d", error); 195 return (error); 196 } 197 198 return (0); 199 } 200 201 static int 202 autofs_vget_callback(struct mount *mp, void *arg, int flags, 203 struct vnode **vpp) 204 { 205 206 207 return (autofs_node_vn(arg, mp, flags, vpp)); 208 } 209 210 static int 211 autofs_lookup(struct vop_lookup_args *ap) 212 { 213 struct vnode *dvp, *newvp, **vpp; 214 struct mount *mp; 215 struct autofs_mount *amp; 216 struct autofs_node *anp, *child; 217 struct componentname *cnp; 218 int error; 219 220 dvp = ap->a_dvp; 221 vpp = ap->a_vpp; 222 mp = dvp->v_mount; 223 amp = VFSTOAUTOFS(mp); 224 anp = dvp->v_data; 225 cnp = ap->a_cnp; 226 227 if (cnp->cn_flags & ISDOTDOT) { 228 KASSERT(anp->an_parent != NULL, ("NULL parent")); 229 /* 230 * Note that in this case, dvp is the child vnode, and we 231 * are looking up the parent vnode - exactly reverse from 232 * normal operation. Unlocking dvp requires some rather 233 * tricky unlock/relock dance to prevent mp from being freed; 234 * use vn_vget_ino_gen() which takes care of all that. 235 */ 236 error = vn_vget_ino_gen(dvp, autofs_vget_callback, 237 anp->an_parent, cnp->cn_lkflags, vpp); 238 if (error != 0) { 239 AUTOFS_WARN("vn_vget_ino_gen() failed with error %d", 240 error); 241 return (error); 242 } 243 return (error); 244 } 245 246 if (cnp->cn_namelen == 1 && cnp->cn_nameptr[0] == '.') { 247 vref(dvp); 248 *vpp = dvp; 249 250 return (0); 251 } 252 253 if (autofs_cached(anp, cnp->cn_nameptr, cnp->cn_namelen) == false && 254 autofs_ignore_thread(cnp->cn_thread) == false) { 255 error = autofs_trigger_vn(dvp, 256 cnp->cn_nameptr, cnp->cn_namelen, &newvp); 257 if (error != 0) 258 return (error); 259 260 if (newvp != NULL) { 261 /* 262 * The target filesystem got automounted. 263 * Let the lookup(9) go around with the same 264 * path component. 265 */ 266 vput(newvp); 267 return (ERELOOKUP); 268 } 269 } 270 271 AUTOFS_SLOCK(amp); 272 error = autofs_node_find(anp, cnp->cn_nameptr, cnp->cn_namelen, &child); 273 if (error != 0) { 274 if ((cnp->cn_flags & ISLASTCN) && cnp->cn_nameiop == CREATE) { 275 AUTOFS_SUNLOCK(amp); 276 return (EJUSTRETURN); 277 } 278 279 AUTOFS_SUNLOCK(amp); 280 return (ENOENT); 281 } 282 283 /* 284 * XXX: Dropping the node here is ok, because we never remove nodes. 285 */ 286 AUTOFS_SUNLOCK(amp); 287 288 error = autofs_node_vn(child, mp, cnp->cn_lkflags, vpp); 289 if (error != 0) { 290 if ((cnp->cn_flags & ISLASTCN) && cnp->cn_nameiop == CREATE) 291 return (EJUSTRETURN); 292 293 return (error); 294 } 295 296 return (0); 297 } 298 299 static int 300 autofs_mkdir(struct vop_mkdir_args *ap) 301 { 302 struct vnode *vp; 303 struct autofs_node *anp; 304 struct autofs_mount *amp; 305 struct autofs_node *child; 306 int error; 307 308 vp = ap->a_dvp; 309 anp = vp->v_data; 310 amp = VFSTOAUTOFS(vp->v_mount); 311 312 /* 313 * Do not allow mkdir() if the calling thread is not 314 * automountd(8) descendant. 315 */ 316 if (autofs_ignore_thread(curthread) == false) 317 return (EPERM); 318 319 AUTOFS_XLOCK(amp); 320 error = autofs_node_new(anp, amp, ap->a_cnp->cn_nameptr, 321 ap->a_cnp->cn_namelen, &child); 322 if (error != 0) { 323 AUTOFS_XUNLOCK(amp); 324 return (error); 325 } 326 AUTOFS_XUNLOCK(amp); 327 328 error = autofs_node_vn(child, vp->v_mount, LK_EXCLUSIVE, ap->a_vpp); 329 330 return (error); 331 } 332 333 /* 334 * Write out a single 'struct dirent', based on 'name' and 'fileno' arguments. 335 */ 336 static int 337 autofs_readdir_one(struct uio *uio, const char *name, int fileno, 338 size_t *reclenp) 339 { 340 struct dirent dirent; 341 size_t namlen, padded_namlen, reclen; 342 int error; 343 344 namlen = strlen(name); 345 padded_namlen = roundup2(namlen + 1, __alignof(struct dirent)); 346 KASSERT(padded_namlen <= MAXNAMLEN, ("%zd > MAXNAMLEN", padded_namlen)); 347 reclen = offsetof(struct dirent, d_name) + padded_namlen; 348 349 if (reclenp != NULL) 350 *reclenp = reclen; 351 352 if (uio == NULL) 353 return (0); 354 355 if (uio->uio_resid < reclen) 356 return (EINVAL); 357 358 dirent.d_fileno = fileno; 359 dirent.d_reclen = reclen; 360 dirent.d_type = DT_DIR; 361 dirent.d_namlen = namlen; 362 memcpy(dirent.d_name, name, namlen); 363 memset(dirent.d_name + namlen, 0, padded_namlen - namlen); 364 error = uiomove(&dirent, reclen, uio); 365 366 return (error); 367 } 368 369 static size_t 370 autofs_dirent_reclen(const char *name) 371 { 372 size_t reclen; 373 374 autofs_readdir_one(NULL, name, -1, &reclen); 375 376 return (reclen); 377 } 378 379 static int 380 autofs_readdir(struct vop_readdir_args *ap) 381 { 382 struct vnode *vp, *newvp; 383 struct autofs_mount *amp; 384 struct autofs_node *anp, *child; 385 struct uio *uio; 386 size_t reclen, reclens; 387 ssize_t initial_resid; 388 int error; 389 390 vp = ap->a_vp; 391 amp = VFSTOAUTOFS(vp->v_mount); 392 anp = vp->v_data; 393 uio = ap->a_uio; 394 initial_resid = ap->a_uio->uio_resid; 395 396 KASSERT(vp->v_type == VDIR, ("!VDIR")); 397 398 if (autofs_cached(anp, NULL, 0) == false && 399 autofs_ignore_thread(curthread) == false) { 400 error = autofs_trigger_vn(vp, "", 0, &newvp); 401 if (error != 0) 402 return (error); 403 404 if (newvp != NULL) { 405 error = VOP_READDIR(newvp, ap->a_uio, ap->a_cred, 406 ap->a_eofflag, ap->a_ncookies, ap->a_cookies); 407 vput(newvp); 408 return (error); 409 } 410 } 411 412 if (uio->uio_offset < 0) 413 return (EINVAL); 414 415 if (ap->a_eofflag != NULL) 416 *ap->a_eofflag = FALSE; 417 418 /* 419 * Write out the directory entry for ".". This is conditional 420 * on the current offset into the directory; same applies to the 421 * other two cases below. 422 */ 423 if (uio->uio_offset == 0) { 424 error = autofs_readdir_one(uio, ".", anp->an_fileno, &reclen); 425 if (error != 0) 426 goto out; 427 } 428 reclens = autofs_dirent_reclen("."); 429 430 /* 431 * Write out the directory entry for "..". 432 */ 433 if (uio->uio_offset <= reclens) { 434 if (uio->uio_offset != reclens) 435 return (EINVAL); 436 if (anp->an_parent == NULL) { 437 error = autofs_readdir_one(uio, "..", 438 anp->an_fileno, &reclen); 439 } else { 440 error = autofs_readdir_one(uio, "..", 441 anp->an_parent->an_fileno, &reclen); 442 } 443 if (error != 0) 444 goto out; 445 } 446 447 reclens += autofs_dirent_reclen(".."); 448 449 /* 450 * Write out the directory entries for subdirectories. 451 */ 452 AUTOFS_SLOCK(amp); 453 TAILQ_FOREACH(child, &anp->an_children, an_next) { 454 /* 455 * Check the offset to skip entries returned by previous 456 * calls to getdents(). 457 */ 458 if (uio->uio_offset > reclens) { 459 reclens += autofs_dirent_reclen(child->an_name); 460 continue; 461 } 462 463 /* 464 * Prevent seeking into the middle of dirent. 465 */ 466 if (uio->uio_offset != reclens) { 467 AUTOFS_SUNLOCK(amp); 468 return (EINVAL); 469 } 470 471 error = autofs_readdir_one(uio, child->an_name, 472 child->an_fileno, &reclen); 473 reclens += reclen; 474 if (error != 0) { 475 AUTOFS_SUNLOCK(amp); 476 goto out; 477 } 478 } 479 AUTOFS_SUNLOCK(amp); 480 481 if (ap->a_eofflag != NULL) 482 *ap->a_eofflag = TRUE; 483 484 return (0); 485 486 out: 487 /* 488 * Return error if the initial buffer was too small to do anything. 489 */ 490 if (uio->uio_resid == initial_resid) 491 return (error); 492 493 /* 494 * Don't return an error if we managed to copy out some entries. 495 */ 496 if (uio->uio_resid < reclen) 497 return (0); 498 499 return (error); 500 } 501 502 static int 503 autofs_reclaim(struct vop_reclaim_args *ap) 504 { 505 struct vnode *vp; 506 struct autofs_node *anp; 507 508 vp = ap->a_vp; 509 anp = vp->v_data; 510 511 /* 512 * We do not free autofs_node here; instead we are 513 * destroying them in autofs_node_delete(). 514 */ 515 sx_xlock(&anp->an_vnode_lock); 516 anp->an_vnode = NULL; 517 vp->v_data = NULL; 518 sx_xunlock(&anp->an_vnode_lock); 519 520 return (0); 521 } 522 523 struct vop_vector autofs_vnodeops = { 524 .vop_default = &default_vnodeops, 525 526 .vop_access = autofs_access, 527 .vop_lookup = autofs_lookup, 528 .vop_create = VOP_EOPNOTSUPP, 529 .vop_getattr = autofs_getattr, 530 .vop_link = VOP_EOPNOTSUPP, 531 .vop_mkdir = autofs_mkdir, 532 .vop_mknod = VOP_EOPNOTSUPP, 533 .vop_read = VOP_EOPNOTSUPP, 534 .vop_readdir = autofs_readdir, 535 .vop_remove = VOP_EOPNOTSUPP, 536 .vop_rename = VOP_EOPNOTSUPP, 537 .vop_rmdir = VOP_EOPNOTSUPP, 538 .vop_setattr = VOP_EOPNOTSUPP, 539 .vop_symlink = VOP_EOPNOTSUPP, 540 .vop_write = VOP_EOPNOTSUPP, 541 .vop_reclaim = autofs_reclaim, 542 }; 543 544 int 545 autofs_node_new(struct autofs_node *parent, struct autofs_mount *amp, 546 const char *name, int namelen, struct autofs_node **anpp) 547 { 548 struct autofs_node *anp; 549 550 if (parent != NULL) { 551 AUTOFS_ASSERT_XLOCKED(parent->an_mount); 552 553 KASSERT(autofs_node_find(parent, name, namelen, NULL) == ENOENT, 554 ("node \"%s\" already exists", name)); 555 } 556 557 anp = uma_zalloc(autofs_node_zone, M_WAITOK | M_ZERO); 558 if (namelen >= 0) 559 anp->an_name = strndup(name, namelen, M_AUTOFS); 560 else 561 anp->an_name = strdup(name, M_AUTOFS); 562 anp->an_fileno = atomic_fetchadd_int(&->am_last_fileno, 1); 563 callout_init(&anp->an_callout, 1); 564 /* 565 * The reason for SX_NOWITNESS here is that witness(4) 566 * cannot tell vnodes apart, so the following perfectly 567 * valid lock order... 568 * 569 * vnode lock A -> autofsvlk B -> vnode lock B 570 * 571 * ... gets reported as a LOR. 572 */ 573 sx_init_flags(&anp->an_vnode_lock, "autofsvlk", SX_NOWITNESS); 574 getnanotime(&anp->an_ctime); 575 anp->an_parent = parent; 576 anp->an_mount = amp; 577 if (parent != NULL) 578 TAILQ_INSERT_TAIL(&parent->an_children, anp, an_next); 579 TAILQ_INIT(&anp->an_children); 580 581 *anpp = anp; 582 return (0); 583 } 584 585 int 586 autofs_node_find(struct autofs_node *parent, const char *name, 587 int namelen, struct autofs_node **anpp) 588 { 589 struct autofs_node *anp; 590 591 AUTOFS_ASSERT_LOCKED(parent->an_mount); 592 593 TAILQ_FOREACH(anp, &parent->an_children, an_next) { 594 if (namelen >= 0) { 595 if (strlen(anp->an_name) != namelen) 596 continue; 597 if (strncmp(anp->an_name, name, namelen) != 0) 598 continue; 599 } else { 600 if (strcmp(anp->an_name, name) != 0) 601 continue; 602 } 603 604 if (anpp != NULL) 605 *anpp = anp; 606 return (0); 607 } 608 609 return (ENOENT); 610 } 611 612 void 613 autofs_node_delete(struct autofs_node *anp) 614 { 615 struct autofs_node *parent; 616 617 AUTOFS_ASSERT_XLOCKED(anp->an_mount); 618 KASSERT(TAILQ_EMPTY(&anp->an_children), ("have children")); 619 620 callout_drain(&anp->an_callout); 621 622 parent = anp->an_parent; 623 if (parent != NULL) 624 TAILQ_REMOVE(&parent->an_children, anp, an_next); 625 sx_destroy(&anp->an_vnode_lock); 626 free(anp->an_name, M_AUTOFS); 627 uma_zfree(autofs_node_zone, anp); 628 } 629 630 int 631 autofs_node_vn(struct autofs_node *anp, struct mount *mp, int flags, 632 struct vnode **vpp) 633 { 634 struct vnode *vp; 635 int error; 636 637 AUTOFS_ASSERT_UNLOCKED(anp->an_mount); 638 639 sx_xlock(&anp->an_vnode_lock); 640 641 vp = anp->an_vnode; 642 if (vp != NULL) { 643 error = vget(vp, flags | LK_RETRY, curthread); 644 if (error != 0) { 645 AUTOFS_WARN("vget failed with error %d", error); 646 sx_xunlock(&anp->an_vnode_lock); 647 return (error); 648 } 649 if (vp->v_iflag & VI_DOOMED) { 650 /* 651 * We got forcibly unmounted. 652 */ 653 AUTOFS_DEBUG("doomed vnode"); 654 sx_xunlock(&anp->an_vnode_lock); 655 vput(vp); 656 657 return (ENOENT); 658 } 659 660 *vpp = vp; 661 sx_xunlock(&anp->an_vnode_lock); 662 return (0); 663 } 664 665 error = getnewvnode("autofs", mp, &autofs_vnodeops, &vp); 666 if (error != 0) { 667 sx_xunlock(&anp->an_vnode_lock); 668 return (error); 669 } 670 671 error = vn_lock(vp, LK_EXCLUSIVE | LK_RETRY); 672 if (error != 0) { 673 sx_xunlock(&anp->an_vnode_lock); 674 vdrop(vp); 675 return (error); 676 } 677 678 vp->v_type = VDIR; 679 if (anp->an_parent == NULL) 680 vp->v_vflag |= VV_ROOT; 681 vp->v_data = anp; 682 683 VN_LOCK_ASHARE(vp); 684 685 error = insmntque(vp, mp); 686 if (error != 0) { 687 AUTOFS_WARN("insmntque() failed with error %d", error); 688 sx_xunlock(&anp->an_vnode_lock); 689 return (error); 690 } 691 692 KASSERT(anp->an_vnode == NULL, ("lost race")); 693 anp->an_vnode = vp; 694 695 sx_xunlock(&anp->an_vnode_lock); 696 697 *vpp = vp; 698 return (0); 699 } 700