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