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/systm.h> 45 #include <sys/taskqueue.h> 46 #include <sys/vnode.h> 47 #include <machine/atomic.h> 48 #include <vm/uma.h> 49 50 #include <fs/autofs/autofs.h> 51 52 static int autofs_trigger_vn(struct vnode *vp, const char *path, 53 int pathlen, struct vnode **newvp); 54 55 extern struct autofs_softc *autofs_softc; 56 57 static int 58 autofs_access(struct vop_access_args *ap) 59 { 60 61 /* 62 * Nothing to do here; the only kind of access control 63 * needed is in autofs_mkdir(). 64 */ 65 66 return (0); 67 } 68 69 static int 70 autofs_getattr(struct vop_getattr_args *ap) 71 { 72 struct vnode *vp, *newvp; 73 struct autofs_node *anp; 74 struct mount *mp; 75 struct vattr *vap; 76 int error; 77 78 vp = ap->a_vp; 79 anp = vp->v_data; 80 mp = vp->v_mount; 81 vap = ap->a_vap; 82 83 KASSERT(ap->a_vp->v_type == VDIR, ("!VDIR")); 84 85 /* 86 * The reason we must do this is that some tree-walking software, 87 * namely fts(3), assumes that stat(".") results will not change 88 * between chdir("subdir") and chdir(".."), and fails with ENOENT 89 * otherwise. 90 */ 91 if (autofs_mount_on_stat && autofs_cached(anp, NULL, 0) == false && 92 autofs_ignore_thread(curthread) == false) { 93 error = autofs_trigger_vn(vp, "", 0, &newvp); 94 if (error != 0) 95 return (error); 96 97 if (newvp != NULL) { 98 error = VOP_GETATTR(newvp, ap->a_vap, 99 ap->a_cred); 100 vput(newvp); 101 return (error); 102 } 103 } 104 105 vap->va_type = VDIR; 106 vap->va_mode = 0755; 107 vap->va_nlink = 3; /* XXX */ 108 vap->va_uid = 0; 109 vap->va_gid = 0; 110 vap->va_rdev = NODEV; 111 vap->va_fsid = mp->mnt_stat.f_fsid.val[0]; 112 vap->va_fileid = anp->an_fileno; 113 vap->va_size = 512; /* XXX */ 114 vap->va_blocksize = 512; 115 vap->va_mtime = anp->an_ctime; 116 vap->va_atime = anp->an_ctime; 117 vap->va_ctime = anp->an_ctime; 118 vap->va_birthtime = anp->an_ctime; 119 vap->va_gen = 0; 120 vap->va_flags = 0; 121 vap->va_rdev = 0; 122 vap->va_bytes = 512; /* XXX */ 123 vap->va_filerev = 0; 124 vap->va_spare = 0; 125 126 return (0); 127 } 128 129 /* 130 * Unlock the vnode, request automountd(8) action, and then lock it back. 131 * If anything got mounted on top of the vnode, return the new filesystem's 132 * root vnode in 'newvp', locked. 133 */ 134 static int 135 autofs_trigger_vn(struct vnode *vp, const char *path, int pathlen, 136 struct vnode **newvp) 137 { 138 struct autofs_node *anp; 139 struct autofs_mount *amp; 140 int error, lock_flags; 141 142 anp = vp->v_data; 143 amp = VFSTOAUTOFS(vp->v_mount); 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, lock_flags; 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 error = VOP_LOOKUP(newvp, ap->a_vpp, ap->a_cnp); 261 262 /* 263 * Instead of figuring out whether our vnode should 264 * be locked or not given the error and cnp flags, 265 * just "copy" the lock status from vnode returned 266 * by mounted filesystem's VOP_LOOKUP(). Get rid 267 * of that new vnode afterwards. 268 */ 269 lock_flags = VOP_ISLOCKED(newvp); 270 if (lock_flags == 0) { 271 VOP_UNLOCK(dvp, 0); 272 vrele(newvp); 273 } else { 274 vput(newvp); 275 } 276 return (error); 277 } 278 } 279 280 AUTOFS_SLOCK(amp); 281 error = autofs_node_find(anp, cnp->cn_nameptr, cnp->cn_namelen, &child); 282 if (error != 0) { 283 if ((cnp->cn_flags & ISLASTCN) && cnp->cn_nameiop == CREATE) { 284 AUTOFS_SUNLOCK(amp); 285 return (EJUSTRETURN); 286 } 287 288 AUTOFS_SUNLOCK(amp); 289 return (ENOENT); 290 } 291 292 /* 293 * XXX: Dropping the node here is ok, because we never remove nodes. 294 */ 295 AUTOFS_SUNLOCK(amp); 296 297 error = autofs_node_vn(child, mp, cnp->cn_lkflags, vpp); 298 if (error != 0) { 299 if ((cnp->cn_flags & ISLASTCN) && cnp->cn_nameiop == CREATE) 300 return (EJUSTRETURN); 301 302 return (error); 303 } 304 305 return (0); 306 } 307 308 static int 309 autofs_mkdir(struct vop_mkdir_args *ap) 310 { 311 struct vnode *vp; 312 struct autofs_node *anp; 313 struct autofs_mount *amp; 314 struct autofs_node *child; 315 int error; 316 317 vp = ap->a_dvp; 318 anp = vp->v_data; 319 amp = VFSTOAUTOFS(vp->v_mount); 320 321 /* 322 * Do not allow mkdir() if the calling thread is not 323 * automountd(8) descendant. 324 */ 325 if (autofs_ignore_thread(curthread) == false) 326 return (EPERM); 327 328 AUTOFS_XLOCK(amp); 329 error = autofs_node_new(anp, amp, ap->a_cnp->cn_nameptr, 330 ap->a_cnp->cn_namelen, &child); 331 if (error != 0) { 332 AUTOFS_XUNLOCK(amp); 333 return (error); 334 } 335 AUTOFS_XUNLOCK(amp); 336 337 error = autofs_node_vn(child, vp->v_mount, LK_EXCLUSIVE, ap->a_vpp); 338 339 return (error); 340 } 341 342 static int 343 autofs_readdir_one(struct uio *uio, const char *name, int fileno) 344 { 345 struct dirent dirent; 346 int error, i; 347 348 memset(&dirent, 0, sizeof(dirent)); 349 dirent.d_type = DT_DIR; 350 dirent.d_reclen = AUTOFS_DELEN; 351 dirent.d_fileno = fileno; 352 /* PFS_DELEN was picked to fit PFS_NAMLEN */ 353 for (i = 0; i < AUTOFS_NAMELEN - 1 && name[i] != '\0'; ++i) 354 dirent.d_name[i] = name[i]; 355 dirent.d_name[i] = 0; 356 dirent.d_namlen = i; 357 358 error = uiomove(&dirent, AUTOFS_DELEN, uio); 359 return (error); 360 } 361 362 static int 363 autofs_readdir(struct vop_readdir_args *ap) 364 { 365 struct vnode *vp, *newvp; 366 struct autofs_mount *amp; 367 struct autofs_node *anp, *child; 368 struct uio *uio; 369 off_t offset; 370 int error, i, resid; 371 372 vp = ap->a_vp; 373 amp = VFSTOAUTOFS(vp->v_mount); 374 anp = vp->v_data; 375 uio = ap->a_uio; 376 377 KASSERT(vp->v_type == VDIR, ("!VDIR")); 378 379 if (autofs_cached(anp, NULL, 0) == false && 380 autofs_ignore_thread(curthread) == false) { 381 error = autofs_trigger_vn(vp, "", 0, &newvp); 382 if (error != 0) 383 return (error); 384 385 if (newvp != NULL) { 386 error = VOP_READDIR(newvp, ap->a_uio, ap->a_cred, 387 ap->a_eofflag, ap->a_ncookies, ap->a_cookies); 388 vput(newvp); 389 return (error); 390 } 391 } 392 393 /* only allow reading entire entries */ 394 offset = uio->uio_offset; 395 resid = uio->uio_resid; 396 if (offset < 0 || offset % AUTOFS_DELEN != 0 || 397 (resid && resid < AUTOFS_DELEN)) 398 return (EINVAL); 399 if (resid == 0) 400 return (0); 401 402 if (ap->a_eofflag != NULL) 403 *ap->a_eofflag = TRUE; 404 405 if (offset == 0 && resid >= AUTOFS_DELEN) { 406 error = autofs_readdir_one(uio, ".", anp->an_fileno); 407 if (error != 0) 408 return (error); 409 offset += AUTOFS_DELEN; 410 resid -= AUTOFS_DELEN; 411 } 412 413 if (offset == AUTOFS_DELEN && resid >= AUTOFS_DELEN) { 414 if (anp->an_parent == NULL) { 415 /* 416 * XXX: Right? 417 */ 418 error = autofs_readdir_one(uio, "..", anp->an_fileno); 419 } else { 420 error = autofs_readdir_one(uio, "..", 421 anp->an_parent->an_fileno); 422 } 423 if (error != 0) 424 return (error); 425 offset += AUTOFS_DELEN; 426 resid -= AUTOFS_DELEN; 427 } 428 429 i = 2; /* Account for "." and "..". */ 430 AUTOFS_SLOCK(amp); 431 TAILQ_FOREACH(child, &anp->an_children, an_next) { 432 if (resid < AUTOFS_DELEN) { 433 if (ap->a_eofflag != NULL) 434 *ap->a_eofflag = 0; 435 break; 436 } 437 438 /* 439 * Skip entries returned by previous call to getdents(). 440 */ 441 i++; 442 if (i * AUTOFS_DELEN <= offset) 443 continue; 444 445 error = autofs_readdir_one(uio, child->an_name, 446 child->an_fileno); 447 if (error != 0) { 448 AUTOFS_SUNLOCK(amp); 449 return (error); 450 } 451 offset += AUTOFS_DELEN; 452 resid -= AUTOFS_DELEN; 453 } 454 455 AUTOFS_SUNLOCK(amp); 456 return (0); 457 } 458 459 static int 460 autofs_reclaim(struct vop_reclaim_args *ap) 461 { 462 struct vnode *vp; 463 struct autofs_node *anp; 464 465 vp = ap->a_vp; 466 anp = vp->v_data; 467 468 /* 469 * We do not free autofs_node here; instead we are 470 * destroying them in autofs_node_delete(). 471 */ 472 sx_xlock(&anp->an_vnode_lock); 473 anp->an_vnode = NULL; 474 vp->v_data = NULL; 475 sx_xunlock(&anp->an_vnode_lock); 476 477 return (0); 478 } 479 480 struct vop_vector autofs_vnodeops = { 481 .vop_default = &default_vnodeops, 482 483 .vop_access = autofs_access, 484 .vop_lookup = autofs_lookup, 485 .vop_create = VOP_EOPNOTSUPP, 486 .vop_getattr = autofs_getattr, 487 .vop_link = VOP_EOPNOTSUPP, 488 .vop_mkdir = autofs_mkdir, 489 .vop_mknod = VOP_EOPNOTSUPP, 490 .vop_read = VOP_EOPNOTSUPP, 491 .vop_readdir = autofs_readdir, 492 .vop_remove = VOP_EOPNOTSUPP, 493 .vop_rename = VOP_EOPNOTSUPP, 494 .vop_rmdir = VOP_EOPNOTSUPP, 495 .vop_setattr = VOP_EOPNOTSUPP, 496 .vop_symlink = VOP_EOPNOTSUPP, 497 .vop_write = VOP_EOPNOTSUPP, 498 .vop_reclaim = autofs_reclaim, 499 }; 500 501 int 502 autofs_node_new(struct autofs_node *parent, struct autofs_mount *amp, 503 const char *name, int namelen, struct autofs_node **anpp) 504 { 505 struct autofs_node *anp; 506 507 if (parent != NULL) { 508 AUTOFS_ASSERT_XLOCKED(parent->an_mount); 509 510 KASSERT(autofs_node_find(parent, name, namelen, NULL) == ENOENT, 511 ("node \"%s\" already exists", name)); 512 } 513 514 anp = uma_zalloc(autofs_node_zone, M_WAITOK | M_ZERO); 515 if (namelen >= 0) 516 anp->an_name = strndup(name, namelen, M_AUTOFS); 517 else 518 anp->an_name = strdup(name, M_AUTOFS); 519 anp->an_fileno = atomic_fetchadd_int(&->am_last_fileno, 1); 520 callout_init(&anp->an_callout, 1); 521 /* 522 * The reason for SX_NOWITNESS here is that witness(4) 523 * cannot tell vnodes apart, so the following perfectly 524 * valid lock order... 525 * 526 * vnode lock A -> autofsvlk B -> vnode lock B 527 * 528 * ... gets reported as a LOR. 529 */ 530 sx_init_flags(&anp->an_vnode_lock, "autofsvlk", SX_NOWITNESS); 531 getnanotime(&anp->an_ctime); 532 anp->an_parent = parent; 533 anp->an_mount = amp; 534 if (parent != NULL) 535 TAILQ_INSERT_TAIL(&parent->an_children, anp, an_next); 536 TAILQ_INIT(&anp->an_children); 537 538 *anpp = anp; 539 return (0); 540 } 541 542 int 543 autofs_node_find(struct autofs_node *parent, const char *name, 544 int namelen, struct autofs_node **anpp) 545 { 546 struct autofs_node *anp; 547 548 AUTOFS_ASSERT_LOCKED(parent->an_mount); 549 550 TAILQ_FOREACH(anp, &parent->an_children, an_next) { 551 if (namelen >= 0) { 552 if (strlen(anp->an_name) != namelen) 553 continue; 554 if (strncmp(anp->an_name, name, namelen) != 0) 555 continue; 556 } else { 557 if (strcmp(anp->an_name, name) != 0) 558 continue; 559 } 560 561 if (anpp != NULL) 562 *anpp = anp; 563 return (0); 564 } 565 566 return (ENOENT); 567 } 568 569 void 570 autofs_node_delete(struct autofs_node *anp) 571 { 572 struct autofs_node *parent; 573 574 AUTOFS_ASSERT_XLOCKED(anp->an_mount); 575 KASSERT(TAILQ_EMPTY(&anp->an_children), ("have children")); 576 577 callout_drain(&anp->an_callout); 578 579 parent = anp->an_parent; 580 if (parent != NULL) 581 TAILQ_REMOVE(&parent->an_children, anp, an_next); 582 sx_destroy(&anp->an_vnode_lock); 583 free(anp->an_name, M_AUTOFS); 584 uma_zfree(autofs_node_zone, anp); 585 } 586 587 int 588 autofs_node_vn(struct autofs_node *anp, struct mount *mp, int flags, 589 struct vnode **vpp) 590 { 591 struct vnode *vp; 592 int error; 593 594 AUTOFS_ASSERT_UNLOCKED(anp->an_mount); 595 596 sx_xlock(&anp->an_vnode_lock); 597 598 vp = anp->an_vnode; 599 if (vp != NULL) { 600 error = vget(vp, flags | LK_RETRY, curthread); 601 if (error != 0) { 602 AUTOFS_WARN("vget failed with error %d", error); 603 sx_xunlock(&anp->an_vnode_lock); 604 return (error); 605 } 606 if (vp->v_iflag & VI_DOOMED) { 607 /* 608 * We got forcibly unmounted. 609 */ 610 AUTOFS_DEBUG("doomed vnode"); 611 sx_xunlock(&anp->an_vnode_lock); 612 vput(vp); 613 614 return (ENOENT); 615 } 616 617 *vpp = vp; 618 sx_xunlock(&anp->an_vnode_lock); 619 return (0); 620 } 621 622 error = getnewvnode("autofs", mp, &autofs_vnodeops, &vp); 623 if (error != 0) { 624 sx_xunlock(&anp->an_vnode_lock); 625 return (error); 626 } 627 628 error = vn_lock(vp, LK_EXCLUSIVE | LK_RETRY); 629 if (error != 0) { 630 sx_xunlock(&anp->an_vnode_lock); 631 vdrop(vp); 632 return (error); 633 } 634 635 vp->v_type = VDIR; 636 if (anp->an_parent == NULL) 637 vp->v_vflag |= VV_ROOT; 638 vp->v_data = anp; 639 640 VN_LOCK_ASHARE(vp); 641 642 error = insmntque(vp, mp); 643 if (error != 0) { 644 AUTOFS_WARN("insmntque() failed with error %d", error); 645 sx_xunlock(&anp->an_vnode_lock); 646 return (error); 647 } 648 649 KASSERT(anp->an_vnode == NULL, ("lost race")); 650 anp->an_vnode = vp; 651 652 sx_xunlock(&anp->an_vnode_lock); 653 654 *vpp = vp; 655 return (0); 656 } 657