sys/fs/autofs/autofs_vnops.c

   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(&amp->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 }