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/kernel.h> 38 #include <sys/condvar.h> 39 #include <sys/dirent.h> 40 #include <sys/fcntl.h> 41 #include <sys/lock.h> 42 #include <sys/mount.h> 43 #include <sys/mutex.h> 44 #include <sys/namei.h> 45 #include <sys/signalvar.h> 46 #include <sys/stat.h> 47 #include <sys/systm.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, 0); 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 ((vp->v_iflag & VI_DOOMED) != 0) { 173 AUTOFS_DEBUG("VI_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 208 return (autofs_node_vn(arg, mp, flags, vpp)); 209 } 210 211 static int 212 autofs_lookup(struct vop_lookup_args *ap) 213 { 214 struct vnode *dvp, *newvp, **vpp; 215 struct mount *mp; 216 struct autofs_mount *amp; 217 struct autofs_node *anp, *child; 218 struct componentname *cnp; 219 int error; 220 221 dvp = ap->a_dvp; 222 vpp = ap->a_vpp; 223 mp = dvp->v_mount; 224 amp = VFSTOAUTOFS(mp); 225 anp = dvp->v_data; 226 cnp = ap->a_cnp; 227 228 if (cnp->cn_flags & ISDOTDOT) { 229 KASSERT(anp->an_parent != NULL, ("NULL parent")); 230 /* 231 * Note that in this case, dvp is the child vnode, and we 232 * are looking up the parent vnode - exactly reverse from 233 * normal operation. Unlocking dvp requires some rather 234 * tricky unlock/relock dance to prevent mp from being freed; 235 * use vn_vget_ino_gen() which takes care of all that. 236 */ 237 error = vn_vget_ino_gen(dvp, autofs_vget_callback, 238 anp->an_parent, cnp->cn_lkflags, vpp); 239 if (error != 0) { 240 AUTOFS_WARN("vn_vget_ino_gen() failed with error %d", 241 error); 242 return (error); 243 } 244 return (error); 245 } 246 247 if (cnp->cn_namelen == 1 && cnp->cn_nameptr[0] == '.') { 248 vref(dvp); 249 *vpp = dvp; 250 251 return (0); 252 } 253 254 if (autofs_cached(anp, cnp->cn_nameptr, cnp->cn_namelen) == false && 255 autofs_ignore_thread(cnp->cn_thread) == false) { 256 error = autofs_trigger_vn(dvp, 257 cnp->cn_nameptr, cnp->cn_namelen, &newvp); 258 if (error != 0) 259 return (error); 260 261 if (newvp != NULL) { 262 /* 263 * The target filesystem got automounted. 264 * Let the lookup(9) go around with the same 265 * path component. 266 */ 267 vput(newvp); 268 return (ERELOOKUP); 269 } 270 } 271 272 AUTOFS_SLOCK(amp); 273 error = autofs_node_find(anp, cnp->cn_nameptr, cnp->cn_namelen, &child); 274 if (error != 0) { 275 if ((cnp->cn_flags & ISLASTCN) && cnp->cn_nameiop == CREATE) { 276 AUTOFS_SUNLOCK(amp); 277 return (EJUSTRETURN); 278 } 279 280 AUTOFS_SUNLOCK(amp); 281 return (ENOENT); 282 } 283 284 /* 285 * XXX: Dropping the node here is ok, because we never remove nodes. 286 */ 287 AUTOFS_SUNLOCK(amp); 288 289 error = autofs_node_vn(child, mp, cnp->cn_lkflags, vpp); 290 if (error != 0) { 291 if ((cnp->cn_flags & ISLASTCN) && cnp->cn_nameiop == CREATE) 292 return (EJUSTRETURN); 293 294 return (error); 295 } 296 297 return (0); 298 } 299 300 static int 301 autofs_mkdir(struct vop_mkdir_args *ap) 302 { 303 struct vnode *vp; 304 struct autofs_node *anp; 305 struct autofs_mount *amp; 306 struct autofs_node *child; 307 int error; 308 309 vp = ap->a_dvp; 310 anp = vp->v_data; 311 amp = VFSTOAUTOFS(vp->v_mount); 312 313 /* 314 * Do not allow mkdir() if the calling thread is not 315 * automountd(8) descendant. 316 */ 317 if (autofs_ignore_thread(curthread) == false) 318 return (EPERM); 319 320 AUTOFS_XLOCK(amp); 321 error = autofs_node_new(anp, amp, ap->a_cnp->cn_nameptr, 322 ap->a_cnp->cn_namelen, &child); 323 if (error != 0) { 324 AUTOFS_XUNLOCK(amp); 325 return (error); 326 } 327 AUTOFS_XUNLOCK(amp); 328 329 error = autofs_node_vn(child, vp->v_mount, LK_EXCLUSIVE, ap->a_vpp); 330 331 return (error); 332 } 333 334 static int 335 autofs_print(struct vop_print_args *ap) 336 { 337 struct vnode *vp; 338 struct autofs_node *anp; 339 340 vp = ap->a_vp; 341 anp = vp->v_data; 342 343 printf(" name \"%s\", fileno %d, cached %d, wildcards %d\n", 344 anp->an_name, anp->an_fileno, anp->an_cached, anp->an_wildcards); 345 346 return (0); 347 } 348 349 /* 350 * Write out a single 'struct dirent', based on 'name' and 'fileno' arguments. 351 */ 352 static int 353 autofs_readdir_one(struct uio *uio, const char *name, int fileno, 354 size_t *reclenp) 355 { 356 struct dirent dirent; 357 size_t namlen, padded_namlen, reclen; 358 int error; 359 360 namlen = strlen(name); 361 padded_namlen = roundup2(namlen + 1, __alignof(struct dirent)); 362 KASSERT(padded_namlen <= MAXNAMLEN, ("%zd > MAXNAMLEN", padded_namlen)); 363 reclen = offsetof(struct dirent, d_name) + padded_namlen; 364 365 if (reclenp != NULL) 366 *reclenp = reclen; 367 368 if (uio == NULL) 369 return (0); 370 371 if (uio->uio_resid < reclen) 372 return (EINVAL); 373 374 dirent.d_fileno = fileno; 375 dirent.d_reclen = reclen; 376 dirent.d_type = DT_DIR; 377 dirent.d_namlen = namlen; 378 memcpy(dirent.d_name, name, namlen); 379 memset(dirent.d_name + namlen, 0, padded_namlen - namlen); 380 error = uiomove(&dirent, reclen, uio); 381 382 return (error); 383 } 384 385 static size_t 386 autofs_dirent_reclen(const char *name) 387 { 388 size_t reclen; 389 390 (void)autofs_readdir_one(NULL, name, -1, &reclen); 391 392 return (reclen); 393 } 394 395 static int 396 autofs_readdir(struct vop_readdir_args *ap) 397 { 398 struct vnode *vp, *newvp; 399 struct autofs_mount *amp; 400 struct autofs_node *anp, *child; 401 struct uio *uio; 402 size_t reclen, reclens; 403 ssize_t initial_resid; 404 int error; 405 406 vp = ap->a_vp; 407 amp = VFSTOAUTOFS(vp->v_mount); 408 anp = vp->v_data; 409 uio = ap->a_uio; 410 initial_resid = ap->a_uio->uio_resid; 411 412 KASSERT(vp->v_type == VDIR, ("!VDIR")); 413 414 if (autofs_cached(anp, NULL, 0) == false && 415 autofs_ignore_thread(curthread) == false) { 416 error = autofs_trigger_vn(vp, "", 0, &newvp); 417 if (error != 0) 418 return (error); 419 420 if (newvp != NULL) { 421 error = VOP_READDIR(newvp, ap->a_uio, ap->a_cred, 422 ap->a_eofflag, ap->a_ncookies, ap->a_cookies); 423 vput(newvp); 424 return (error); 425 } 426 } 427 428 if (uio->uio_offset < 0) 429 return (EINVAL); 430 431 if (ap->a_eofflag != NULL) 432 *ap->a_eofflag = FALSE; 433 434 /* 435 * Write out the directory entry for ".". This is conditional 436 * on the current offset into the directory; same applies to the 437 * other two cases below. 438 */ 439 if (uio->uio_offset == 0) { 440 error = autofs_readdir_one(uio, ".", anp->an_fileno, &reclen); 441 if (error != 0) 442 goto out; 443 } 444 reclens = autofs_dirent_reclen("."); 445 446 /* 447 * Write out the directory entry for "..". 448 */ 449 if (uio->uio_offset <= reclens) { 450 if (uio->uio_offset != reclens) 451 return (EINVAL); 452 if (anp->an_parent == NULL) { 453 error = autofs_readdir_one(uio, "..", 454 anp->an_fileno, &reclen); 455 } else { 456 error = autofs_readdir_one(uio, "..", 457 anp->an_parent->an_fileno, &reclen); 458 } 459 if (error != 0) 460 goto out; 461 } 462 463 reclens += autofs_dirent_reclen(".."); 464 465 /* 466 * Write out the directory entries for subdirectories. 467 */ 468 AUTOFS_SLOCK(amp); 469 RB_FOREACH(child, autofs_node_tree, &anp->an_children) { 470 /* 471 * Check the offset to skip entries returned by previous 472 * calls to getdents(). 473 */ 474 if (uio->uio_offset > reclens) { 475 reclens += autofs_dirent_reclen(child->an_name); 476 continue; 477 } 478 479 /* 480 * Prevent seeking into the middle of dirent. 481 */ 482 if (uio->uio_offset != reclens) { 483 AUTOFS_SUNLOCK(amp); 484 return (EINVAL); 485 } 486 487 error = autofs_readdir_one(uio, child->an_name, 488 child->an_fileno, &reclen); 489 reclens += reclen; 490 if (error != 0) { 491 AUTOFS_SUNLOCK(amp); 492 goto out; 493 } 494 } 495 AUTOFS_SUNLOCK(amp); 496 497 if (ap->a_eofflag != NULL) 498 *ap->a_eofflag = TRUE; 499 500 return (0); 501 502 out: 503 /* 504 * Return error if the initial buffer was too small to do anything. 505 */ 506 if (uio->uio_resid == initial_resid) 507 return (error); 508 509 /* 510 * Don't return an error if we managed to copy out some entries. 511 */ 512 if (uio->uio_resid < reclen) 513 return (0); 514 515 return (error); 516 } 517 518 static int 519 autofs_reclaim(struct vop_reclaim_args *ap) 520 { 521 struct vnode *vp; 522 struct autofs_node *anp; 523 524 vp = ap->a_vp; 525 anp = vp->v_data; 526 527 /* 528 * We do not free autofs_node here; instead we are 529 * destroying them in autofs_node_delete(). 530 */ 531 sx_xlock(&anp->an_vnode_lock); 532 anp->an_vnode = NULL; 533 vp->v_data = NULL; 534 sx_xunlock(&anp->an_vnode_lock); 535 536 return (0); 537 } 538 539 struct vop_vector autofs_vnodeops = { 540 .vop_default = &default_vnodeops, 541 542 .vop_access = autofs_access, 543 .vop_lookup = autofs_lookup, 544 .vop_create = VOP_EOPNOTSUPP, 545 .vop_getattr = autofs_getattr, 546 .vop_link = VOP_EOPNOTSUPP, 547 .vop_mkdir = autofs_mkdir, 548 .vop_mknod = VOP_EOPNOTSUPP, 549 .vop_print = autofs_print, 550 .vop_read = VOP_EOPNOTSUPP, 551 .vop_readdir = autofs_readdir, 552 .vop_remove = VOP_EOPNOTSUPP, 553 .vop_rename = VOP_EOPNOTSUPP, 554 .vop_rmdir = VOP_EOPNOTSUPP, 555 .vop_setattr = VOP_EOPNOTSUPP, 556 .vop_symlink = VOP_EOPNOTSUPP, 557 .vop_write = VOP_EOPNOTSUPP, 558 .vop_reclaim = autofs_reclaim, 559 }; 560 561 int 562 autofs_node_new(struct autofs_node *parent, struct autofs_mount *amp, 563 const char *name, int namelen, struct autofs_node **anpp) 564 { 565 struct autofs_node *anp; 566 567 if (parent != NULL) { 568 AUTOFS_ASSERT_XLOCKED(parent->an_mount); 569 570 KASSERT(autofs_node_find(parent, name, namelen, NULL) == ENOENT, 571 ("node \"%s\" already exists", name)); 572 } 573 574 anp = uma_zalloc(autofs_node_zone, M_WAITOK | M_ZERO); 575 if (namelen >= 0) 576 anp->an_name = strndup(name, namelen, M_AUTOFS); 577 else 578 anp->an_name = strdup(name, M_AUTOFS); 579 anp->an_fileno = atomic_fetchadd_int(&->am_last_fileno, 1); 580 callout_init(&anp->an_callout, 1); 581 /* 582 * The reason for SX_NOWITNESS here is that witness(4) 583 * cannot tell vnodes apart, so the following perfectly 584 * valid lock order... 585 * 586 * vnode lock A -> autofsvlk B -> vnode lock B 587 * 588 * ... gets reported as a LOR. 589 */ 590 sx_init_flags(&anp->an_vnode_lock, "autofsvlk", SX_NOWITNESS); 591 getnanotime(&anp->an_ctime); 592 anp->an_parent = parent; 593 anp->an_mount = amp; 594 if (parent != NULL) 595 RB_INSERT(autofs_node_tree, &parent->an_children, anp); 596 RB_INIT(&anp->an_children); 597 598 *anpp = anp; 599 return (0); 600 } 601 602 int 603 autofs_node_find(struct autofs_node *parent, const char *name, 604 int namelen, struct autofs_node **anpp) 605 { 606 struct autofs_node *anp, find; 607 int error; 608 609 AUTOFS_ASSERT_LOCKED(parent->an_mount); 610 611 if (namelen >= 0) 612 find.an_name = strndup(name, namelen, M_AUTOFS); 613 else 614 find.an_name = strdup(name, M_AUTOFS); 615 616 anp = RB_FIND(autofs_node_tree, &parent->an_children, &find); 617 if (anp != NULL) { 618 error = 0; 619 if (anpp != NULL) 620 *anpp = anp; 621 } else { 622 error = ENOENT; 623 } 624 625 free(find.an_name, M_AUTOFS); 626 627 return (error); 628 } 629 630 void 631 autofs_node_delete(struct autofs_node *anp) 632 { 633 struct autofs_node *parent; 634 635 AUTOFS_ASSERT_XLOCKED(anp->an_mount); 636 KASSERT(RB_EMPTY(&anp->an_children), ("have children")); 637 638 callout_drain(&anp->an_callout); 639 640 parent = anp->an_parent; 641 if (parent != NULL) 642 RB_REMOVE(autofs_node_tree, &parent->an_children, anp); 643 sx_destroy(&anp->an_vnode_lock); 644 free(anp->an_name, M_AUTOFS); 645 uma_zfree(autofs_node_zone, anp); 646 } 647 648 int 649 autofs_node_vn(struct autofs_node *anp, struct mount *mp, int flags, 650 struct vnode **vpp) 651 { 652 struct vnode *vp; 653 int error; 654 655 AUTOFS_ASSERT_UNLOCKED(anp->an_mount); 656 657 sx_xlock(&anp->an_vnode_lock); 658 659 vp = anp->an_vnode; 660 if (vp != NULL) { 661 error = vget(vp, flags | LK_RETRY, curthread); 662 if (error != 0) { 663 AUTOFS_WARN("vget failed with error %d", error); 664 sx_xunlock(&anp->an_vnode_lock); 665 return (error); 666 } 667 if (vp->v_iflag & VI_DOOMED) { 668 /* 669 * We got forcibly unmounted. 670 */ 671 AUTOFS_DEBUG("doomed vnode"); 672 sx_xunlock(&anp->an_vnode_lock); 673 vput(vp); 674 675 return (ENOENT); 676 } 677 678 *vpp = vp; 679 sx_xunlock(&anp->an_vnode_lock); 680 return (0); 681 } 682 683 error = getnewvnode("autofs", mp, &autofs_vnodeops, &vp); 684 if (error != 0) { 685 sx_xunlock(&anp->an_vnode_lock); 686 return (error); 687 } 688 689 error = vn_lock(vp, LK_EXCLUSIVE | LK_RETRY); 690 if (error != 0) { 691 sx_xunlock(&anp->an_vnode_lock); 692 vdrop(vp); 693 return (error); 694 } 695 696 vp->v_type = VDIR; 697 if (anp->an_parent == NULL) 698 vp->v_vflag |= VV_ROOT; 699 vp->v_data = anp; 700 701 VN_LOCK_ASHARE(vp); 702 703 error = insmntque(vp, mp); 704 if (error != 0) { 705 AUTOFS_DEBUG("insmntque() failed with error %d", error); 706 sx_xunlock(&anp->an_vnode_lock); 707 return (error); 708 } 709 710 KASSERT(anp->an_vnode == NULL, ("lost race")); 711 anp->an_vnode = vp; 712 713 sx_xunlock(&anp->an_vnode_lock); 714 715 *vpp = vp; 716 return (0); 717 } 718