1 /*- 2 * SPDX-License-Identifier: BSD-2-Clause-FreeBSD 3 * 4 * Copyright (c) 2014 The FreeBSD Foundation 5 * All rights reserved. 6 * 7 * This software was developed by Edward Tomasz Napierala under sponsorship 8 * from the FreeBSD Foundation. 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 * 19 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND 20 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 22 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE 23 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 24 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 25 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 26 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 28 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 29 * SUCH DAMAGE. 30 * 31 */ 32 33 #include <sys/cdefs.h> 34 __FBSDID("$FreeBSD$"); 35 36 #include <sys/param.h> 37 #include <sys/systm.h> 38 #include <sys/kernel.h> 39 #include <sys/condvar.h> 40 #include <sys/dirent.h> 41 #include <sys/fcntl.h> 42 #include <sys/lock.h> 43 #include <sys/mount.h> 44 #include <sys/mutex.h> 45 #include <sys/namei.h> 46 #include <sys/signalvar.h> 47 #include <sys/stat.h> 48 #include <sys/taskqueue.h> 49 #include <sys/tree.h> 50 #include <sys/vnode.h> 51 #include <machine/atomic.h> 52 #include <vm/uma.h> 53 54 #include <fs/autofs/autofs.h> 55 56 static int autofs_trigger_vn(struct vnode *vp, const char *path, 57 int pathlen, struct vnode **newvp); 58 59 extern struct autofs_softc *autofs_softc; 60 61 static int 62 autofs_access(struct vop_access_args *ap) 63 { 64 65 /* 66 * Nothing to do here; the only kind of access control 67 * needed is in autofs_mkdir(). 68 */ 69 70 return (0); 71 } 72 73 static int 74 autofs_getattr(struct vop_getattr_args *ap) 75 { 76 struct vnode *vp, *newvp; 77 struct autofs_node *anp; 78 struct mount *mp; 79 struct vattr *vap; 80 int error; 81 82 vp = ap->a_vp; 83 anp = vp->v_data; 84 mp = vp->v_mount; 85 vap = ap->a_vap; 86 87 KASSERT(ap->a_vp->v_type == VDIR, ("!VDIR")); 88 89 /* 90 * The reason we must do this is that some tree-walking software, 91 * namely fts(3), assumes that stat(".") results will not change 92 * between chdir("subdir") and chdir(".."), and fails with ENOENT 93 * otherwise. 94 */ 95 if (autofs_mount_on_stat && autofs_cached(anp, NULL, 0) == false && 96 autofs_ignore_thread(curthread) == false) { 97 error = autofs_trigger_vn(vp, "", 0, &newvp); 98 if (error != 0) 99 return (error); 100 101 if (newvp != NULL) { 102 error = VOP_GETATTR(newvp, ap->a_vap, 103 ap->a_cred); 104 vput(newvp); 105 return (error); 106 } 107 } 108 109 vap->va_type = VDIR; 110 vap->va_mode = 0755; 111 vap->va_nlink = 3; /* XXX */ 112 vap->va_uid = 0; 113 vap->va_gid = 0; 114 vap->va_rdev = NODEV; 115 vap->va_fsid = mp->mnt_stat.f_fsid.val[0]; 116 vap->va_fileid = anp->an_fileno; 117 vap->va_size = S_BLKSIZE; 118 vap->va_blocksize = S_BLKSIZE; 119 vap->va_mtime = anp->an_ctime; 120 vap->va_atime = anp->an_ctime; 121 vap->va_ctime = anp->an_ctime; 122 vap->va_birthtime = anp->an_ctime; 123 vap->va_gen = 0; 124 vap->va_flags = 0; 125 vap->va_rdev = 0; 126 vap->va_bytes = S_BLKSIZE; 127 vap->va_filerev = 0; 128 vap->va_spare = 0; 129 130 return (0); 131 } 132 133 /* 134 * Unlock the vnode, request automountd(8) action, and then lock it back. 135 * If anything got mounted on top of the vnode, return the new filesystem's 136 * root vnode in 'newvp', locked. 137 */ 138 static int 139 autofs_trigger_vn(struct vnode *vp, const char *path, int pathlen, 140 struct vnode **newvp) 141 { 142 struct autofs_node *anp; 143 int error, lock_flags; 144 145 anp = vp->v_data; 146 147 /* 148 * Release the vnode lock, so that other operations, in partcular 149 * mounting a filesystem on top of it, can proceed. Increase use 150 * count, to prevent the vnode from being deallocated and to prevent 151 * filesystem from being unmounted. 152 */ 153 lock_flags = VOP_ISLOCKED(vp); 154 vref(vp); 155 VOP_UNLOCK(vp); 156 157 sx_xlock(&autofs_softc->sc_lock); 158 159 /* 160 * XXX: Workaround for mounting the same thing multiple times; revisit. 161 */ 162 if (vp->v_mountedhere != NULL) { 163 error = 0; 164 goto mounted; 165 } 166 167 error = autofs_trigger(anp, path, pathlen); 168 mounted: 169 sx_xunlock(&autofs_softc->sc_lock); 170 vn_lock(vp, lock_flags | LK_RETRY); 171 vunref(vp); 172 if (VN_IS_DOOMED(vp)) { 173 AUTOFS_DEBUG("VIRF_DOOMED"); 174 return (ENOENT); 175 } 176 177 if (error != 0) 178 return (error); 179 180 if (vp->v_mountedhere == NULL) { 181 *newvp = NULL; 182 return (0); 183 } else { 184 /* 185 * If the operation that succeeded was mount, then mark 186 * the node as non-cached. Otherwise, if someone unmounts 187 * the filesystem before the cache times out, we will fail 188 * to trigger. 189 */ 190 anp->an_cached = false; 191 } 192 193 error = VFS_ROOT(vp->v_mountedhere, lock_flags, newvp); 194 if (error != 0) { 195 AUTOFS_WARN("VFS_ROOT() failed with error %d", error); 196 return (error); 197 } 198 199 return (0); 200 } 201 202 static int 203 autofs_vget_callback(struct mount *mp, void *arg, int flags, 204 struct vnode **vpp) 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 static int 334 autofs_print(struct vop_print_args *ap) 335 { 336 struct vnode *vp; 337 struct autofs_node *anp; 338 339 vp = ap->a_vp; 340 anp = vp->v_data; 341 342 printf(" name \"%s\", fileno %d, cached %d, wildcards %d\n", 343 anp->an_name, anp->an_fileno, anp->an_cached, anp->an_wildcards); 344 345 return (0); 346 } 347 348 /* 349 * Write out a single 'struct dirent', based on 'name' and 'fileno' arguments. 350 */ 351 static int 352 autofs_readdir_one(struct uio *uio, const char *name, int fileno, 353 size_t *reclenp) 354 { 355 struct dirent dirent; 356 size_t namlen, reclen; 357 int error; 358 359 namlen = strlen(name); 360 reclen = _GENERIC_DIRLEN(namlen); 361 if (reclenp != NULL) 362 *reclenp = reclen; 363 364 if (uio == NULL) 365 return (0); 366 367 if (uio->uio_resid < reclen) 368 return (EINVAL); 369 370 dirent.d_fileno = fileno; 371 dirent.d_reclen = reclen; 372 dirent.d_type = DT_DIR; 373 dirent.d_namlen = namlen; 374 memcpy(dirent.d_name, name, namlen); 375 dirent_terminate(&dirent); 376 error = uiomove(&dirent, reclen, uio); 377 378 return (error); 379 } 380 381 static size_t 382 autofs_dirent_reclen(const char *name) 383 { 384 size_t reclen; 385 386 (void)autofs_readdir_one(NULL, name, -1, &reclen); 387 388 return (reclen); 389 } 390 391 static int 392 autofs_readdir(struct vop_readdir_args *ap) 393 { 394 struct vnode *vp, *newvp; 395 struct autofs_mount *amp; 396 struct autofs_node *anp, *child; 397 struct uio *uio; 398 size_t reclen, reclens; 399 ssize_t initial_resid; 400 int error; 401 402 vp = ap->a_vp; 403 amp = VFSTOAUTOFS(vp->v_mount); 404 anp = vp->v_data; 405 uio = ap->a_uio; 406 initial_resid = ap->a_uio->uio_resid; 407 408 KASSERT(vp->v_type == VDIR, ("!VDIR")); 409 410 if (autofs_cached(anp, NULL, 0) == false && 411 autofs_ignore_thread(curthread) == false) { 412 error = autofs_trigger_vn(vp, "", 0, &newvp); 413 if (error != 0) 414 return (error); 415 416 if (newvp != NULL) { 417 error = VOP_READDIR(newvp, ap->a_uio, ap->a_cred, 418 ap->a_eofflag, ap->a_ncookies, ap->a_cookies); 419 vput(newvp); 420 return (error); 421 } 422 } 423 424 if (uio->uio_offset < 0) 425 return (EINVAL); 426 427 if (ap->a_eofflag != NULL) 428 *ap->a_eofflag = FALSE; 429 430 /* 431 * Write out the directory entry for ".". This is conditional 432 * on the current offset into the directory; same applies to the 433 * other two cases below. 434 */ 435 if (uio->uio_offset == 0) { 436 error = autofs_readdir_one(uio, ".", anp->an_fileno, &reclen); 437 if (error != 0) 438 goto out; 439 } 440 reclens = autofs_dirent_reclen("."); 441 442 /* 443 * Write out the directory entry for "..". 444 */ 445 if (uio->uio_offset <= reclens) { 446 if (uio->uio_offset != reclens) 447 return (EINVAL); 448 if (anp->an_parent == NULL) { 449 error = autofs_readdir_one(uio, "..", 450 anp->an_fileno, &reclen); 451 } else { 452 error = autofs_readdir_one(uio, "..", 453 anp->an_parent->an_fileno, &reclen); 454 } 455 if (error != 0) 456 goto out; 457 } 458 459 reclens += autofs_dirent_reclen(".."); 460 461 /* 462 * Write out the directory entries for subdirectories. 463 */ 464 AUTOFS_SLOCK(amp); 465 RB_FOREACH(child, autofs_node_tree, &anp->an_children) { 466 /* 467 * Check the offset to skip entries returned by previous 468 * calls to getdents(). 469 */ 470 if (uio->uio_offset > reclens) { 471 reclens += autofs_dirent_reclen(child->an_name); 472 continue; 473 } 474 475 /* 476 * Prevent seeking into the middle of dirent. 477 */ 478 if (uio->uio_offset != reclens) { 479 AUTOFS_SUNLOCK(amp); 480 return (EINVAL); 481 } 482 483 error = autofs_readdir_one(uio, child->an_name, 484 child->an_fileno, &reclen); 485 reclens += reclen; 486 if (error != 0) { 487 AUTOFS_SUNLOCK(amp); 488 goto out; 489 } 490 } 491 AUTOFS_SUNLOCK(amp); 492 493 if (ap->a_eofflag != NULL) 494 *ap->a_eofflag = TRUE; 495 496 return (0); 497 498 out: 499 /* 500 * Return error if the initial buffer was too small to do anything. 501 */ 502 if (uio->uio_resid == initial_resid) 503 return (error); 504 505 /* 506 * Don't return an error if we managed to copy out some entries. 507 */ 508 if (uio->uio_resid < reclen) 509 return (0); 510 511 return (error); 512 } 513 514 static int 515 autofs_reclaim(struct vop_reclaim_args *ap) 516 { 517 struct vnode *vp; 518 struct autofs_node *anp; 519 520 vp = ap->a_vp; 521 anp = vp->v_data; 522 523 /* 524 * We do not free autofs_node here; instead we are 525 * destroying them in autofs_node_delete(). 526 */ 527 sx_xlock(&anp->an_vnode_lock); 528 anp->an_vnode = NULL; 529 vp->v_data = NULL; 530 sx_xunlock(&anp->an_vnode_lock); 531 532 return (0); 533 } 534 535 struct vop_vector autofs_vnodeops = { 536 .vop_default = &default_vnodeops, 537 538 .vop_access = autofs_access, 539 .vop_lookup = autofs_lookup, 540 .vop_create = VOP_EOPNOTSUPP, 541 .vop_getattr = autofs_getattr, 542 .vop_link = VOP_EOPNOTSUPP, 543 .vop_mkdir = autofs_mkdir, 544 .vop_mknod = VOP_EOPNOTSUPP, 545 .vop_print = autofs_print, 546 .vop_read = VOP_EOPNOTSUPP, 547 .vop_readdir = autofs_readdir, 548 .vop_remove = VOP_EOPNOTSUPP, 549 .vop_rename = VOP_EOPNOTSUPP, 550 .vop_rmdir = VOP_EOPNOTSUPP, 551 .vop_setattr = VOP_EOPNOTSUPP, 552 .vop_symlink = VOP_EOPNOTSUPP, 553 .vop_write = VOP_EOPNOTSUPP, 554 .vop_reclaim = autofs_reclaim, 555 }; 556 VFS_VOP_VECTOR_REGISTER(autofs_vnodeops); 557 558 int 559 autofs_node_new(struct autofs_node *parent, struct autofs_mount *amp, 560 const char *name, int namelen, struct autofs_node **anpp) 561 { 562 struct autofs_node *anp; 563 564 if (parent != NULL) { 565 AUTOFS_ASSERT_XLOCKED(parent->an_mount); 566 567 KASSERT(autofs_node_find(parent, name, namelen, NULL) == ENOENT, 568 ("node \"%s\" already exists", name)); 569 } 570 571 anp = uma_zalloc(autofs_node_zone, M_WAITOK | M_ZERO); 572 if (namelen >= 0) 573 anp->an_name = strndup(name, namelen, M_AUTOFS); 574 else 575 anp->an_name = strdup(name, M_AUTOFS); 576 anp->an_fileno = atomic_fetchadd_int(&->am_last_fileno, 1); 577 callout_init(&anp->an_callout, 1); 578 /* 579 * The reason for SX_NOWITNESS here is that witness(4) 580 * cannot tell vnodes apart, so the following perfectly 581 * valid lock order... 582 * 583 * vnode lock A -> autofsvlk B -> vnode lock B 584 * 585 * ... gets reported as a LOR. 586 */ 587 sx_init_flags(&anp->an_vnode_lock, "autofsvlk", SX_NOWITNESS); 588 getnanotime(&anp->an_ctime); 589 anp->an_parent = parent; 590 anp->an_mount = amp; 591 if (parent != NULL) 592 RB_INSERT(autofs_node_tree, &parent->an_children, anp); 593 RB_INIT(&anp->an_children); 594 595 *anpp = anp; 596 return (0); 597 } 598 599 int 600 autofs_node_find(struct autofs_node *parent, const char *name, 601 int namelen, struct autofs_node **anpp) 602 { 603 struct autofs_node *anp, find; 604 int error; 605 606 AUTOFS_ASSERT_LOCKED(parent->an_mount); 607 608 if (namelen >= 0) 609 find.an_name = strndup(name, namelen, M_AUTOFS); 610 else 611 find.an_name = strdup(name, M_AUTOFS); 612 613 anp = RB_FIND(autofs_node_tree, &parent->an_children, &find); 614 if (anp != NULL) { 615 error = 0; 616 if (anpp != NULL) 617 *anpp = anp; 618 } else { 619 error = ENOENT; 620 } 621 622 free(find.an_name, M_AUTOFS); 623 624 return (error); 625 } 626 627 void 628 autofs_node_delete(struct autofs_node *anp) 629 { 630 struct autofs_node *parent; 631 632 AUTOFS_ASSERT_XLOCKED(anp->an_mount); 633 KASSERT(RB_EMPTY(&anp->an_children), ("have children")); 634 635 callout_drain(&anp->an_callout); 636 637 parent = anp->an_parent; 638 if (parent != NULL) 639 RB_REMOVE(autofs_node_tree, &parent->an_children, anp); 640 sx_destroy(&anp->an_vnode_lock); 641 free(anp->an_name, M_AUTOFS); 642 uma_zfree(autofs_node_zone, anp); 643 } 644 645 int 646 autofs_node_vn(struct autofs_node *anp, struct mount *mp, int flags, 647 struct vnode **vpp) 648 { 649 struct vnode *vp; 650 int error; 651 652 AUTOFS_ASSERT_UNLOCKED(anp->an_mount); 653 654 sx_xlock(&anp->an_vnode_lock); 655 656 vp = anp->an_vnode; 657 if (vp != NULL) { 658 error = vget(vp, flags | LK_RETRY); 659 if (error != 0) { 660 AUTOFS_WARN("vget failed with error %d", error); 661 sx_xunlock(&anp->an_vnode_lock); 662 return (error); 663 } 664 if (VN_IS_DOOMED(vp)) { 665 /* 666 * We got forcibly unmounted. 667 */ 668 AUTOFS_DEBUG("doomed vnode"); 669 sx_xunlock(&anp->an_vnode_lock); 670 vput(vp); 671 672 return (ENOENT); 673 } 674 675 *vpp = vp; 676 sx_xunlock(&anp->an_vnode_lock); 677 return (0); 678 } 679 680 error = getnewvnode("autofs", mp, &autofs_vnodeops, &vp); 681 if (error != 0) { 682 sx_xunlock(&anp->an_vnode_lock); 683 return (error); 684 } 685 686 error = vn_lock(vp, LK_EXCLUSIVE | LK_RETRY); 687 if (error != 0) { 688 sx_xunlock(&anp->an_vnode_lock); 689 vdrop(vp); 690 return (error); 691 } 692 693 vp->v_type = VDIR; 694 if (anp->an_parent == NULL) 695 vp->v_vflag |= VV_ROOT; 696 vp->v_data = anp; 697 698 VN_LOCK_ASHARE(vp); 699 700 error = insmntque(vp, mp); 701 if (error != 0) { 702 AUTOFS_DEBUG("insmntque() failed with error %d", error); 703 sx_xunlock(&anp->an_vnode_lock); 704 return (error); 705 } 706 707 KASSERT(anp->an_vnode == NULL, ("lost race")); 708 anp->an_vnode = vp; 709 710 sx_xunlock(&anp->an_vnode_lock); 711 712 *vpp = vp; 713 return (0); 714 } 715