autofs_vnops.c

Version: - FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10
    1 /*-
    2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
    3  *
    4  * Copyright (c) 2014 The FreeBSD Foundation
    5  *
    6  * This software was developed by Edward Tomasz Napierala under sponsorship
    7  * from the FreeBSD Foundation.
    8  *
    9  * Redistribution and use in source and binary forms, with or without
   10  * modification, are permitted provided that the following conditions
   11  * are met:
   12  * 1. Redistributions of source code must retain the above copyright
   13  *    notice, this list of conditions and the following disclaimer.
   14  * 2. Redistributions in binary form must reproduce the above copyright
   15  *    notice, this list of conditions and the following disclaimer in the
   16  *    documentation and/or other materials provided with the distribution.
   17  *
   18  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
   19  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   20  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   21  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
   22  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   23  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   24  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   25  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   26  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   27  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   28  * SUCH DAMAGE.
   29  *
   30  */
   31 
   32 #include <sys/cdefs.h>
   33 __FBSDID("$FreeBSD$");
   34 
   35 #include <sys/param.h>
   36 #include <sys/systm.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/taskqueue.h>
   48 #include <sys/tree.h>
   49 #include <sys/vnode.h>
   50 #include <machine/atomic.h>
   51 #include <vm/uma.h>
   52 
   53 #include <fs/autofs/autofs.h>
   54 
   55 static int      autofs_trigger_vn(struct vnode *vp, const char *path,
   56                     int pathlen, struct vnode **newvp);
   57 
   58 extern struct autofs_softc      *autofs_softc;
   59 
   60 static int
   61 autofs_access(struct vop_access_args *ap)
   62 {
   63 
   64         /*
   65          * Nothing to do here; the only kind of access control
   66          * needed is in autofs_mkdir().
   67          */
   68 
   69         return (0);
   70 }
   71 
   72 static int
   73 autofs_getattr(struct vop_getattr_args *ap)
   74 {
   75         struct vnode *vp, *newvp;
   76         struct autofs_node *anp;
   77         struct mount *mp;
   78         struct vattr *vap;
   79         int error;
   80 
   81         vp = ap->a_vp;
   82         anp = vp->v_data;
   83         mp = vp->v_mount;
   84         vap = ap->a_vap;
   85 
   86         KASSERT(ap->a_vp->v_type == VDIR, ("!VDIR"));
   87 
   88         /*
   89          * The reason we must do this is that some tree-walking software,
   90          * namely fts(3), assumes that stat(".") results will not change
   91          * between chdir("subdir") and chdir(".."), and fails with ENOENT
   92          * otherwise.
   93          */
   94         if (autofs_mount_on_stat && autofs_cached(anp, NULL, 0) == false &&
   95             autofs_ignore_thread(curthread) == false) {
   96                 error = autofs_trigger_vn(vp, "", 0, &newvp);
   97                 if (error != 0)
   98                         return (error);
   99 
  100                 if (newvp != NULL) {
  101                         error = VOP_GETATTR(newvp, ap->a_vap,
  102                             ap->a_cred);
  103                         vput(newvp);
  104                         return (error);
  105                 }
  106         }
  107 
  108         vap->va_type = VDIR;
  109         vap->va_mode = 0755;
  110         vap->va_nlink = 3; /* XXX */
  111         vap->va_uid = 0;
  112         vap->va_gid = 0;
  113         vap->va_rdev = NODEV;
  114         vap->va_fsid = mp->mnt_stat.f_fsid.val[0];
  115         vap->va_fileid = anp->an_fileno;
  116         vap->va_size = S_BLKSIZE;
  117         vap->va_blocksize = S_BLKSIZE;
  118         vap->va_mtime = anp->an_ctime;
  119         vap->va_atime = anp->an_ctime;
  120         vap->va_ctime = anp->an_ctime;
  121         vap->va_birthtime = anp->an_ctime;
  122         vap->va_gen = 0;
  123         vap->va_flags = 0;
  124         vap->va_rdev = 0;
  125         vap->va_bytes = S_BLKSIZE;
  126         vap->va_filerev = 0;
  127         vap->va_spare = 0;
  128 
  129         return (0);
  130 }
  131 
  132 /*
  133  * Unlock the vnode, request automountd(8) action, and then lock it back.
  134  * If anything got mounted on top of the vnode, return the new filesystem's
  135  * root vnode in 'newvp', locked.
  136  */
  137 static int
  138 autofs_trigger_vn(struct vnode *vp, const char *path, int pathlen,
  139     struct vnode **newvp)
  140 {
  141         struct autofs_node *anp;
  142         int error, lock_flags;
  143 
  144         anp = vp->v_data;
  145 
  146         /*
  147          * Release the vnode lock, so that other operations, in partcular
  148          * mounting a filesystem on top of it, can proceed.  Increase use
  149          * count, to prevent the vnode from being deallocated and to prevent
  150          * filesystem from being unmounted.
  151          */
  152         lock_flags = VOP_ISLOCKED(vp);
  153         vref(vp);
  154         VOP_UNLOCK(vp);
  155 
  156         sx_xlock(&autofs_softc->sc_lock);
  157 
  158         /*
  159          * XXX: Workaround for mounting the same thing multiple times; revisit.
  160          */
  161         if (vp->v_mountedhere != NULL) {
  162                 error = 0;
  163                 goto mounted;
  164         }
  165 
  166         error = autofs_trigger(anp, path, pathlen);
  167 mounted:
  168         sx_xunlock(&autofs_softc->sc_lock);
  169         vn_lock(vp, lock_flags | LK_RETRY);
  170         vunref(vp);
  171         if (VN_IS_DOOMED(vp)) {
  172                 AUTOFS_DEBUG("VIRF_DOOMED");
  173                 return (ENOENT);
  174         }
  175 
  176         if (error != 0)
  177                 return (error);
  178 
  179         if (vp->v_mountedhere == NULL) {
  180                 *newvp = NULL;
  181                 return (0);
  182         } else {
  183                 /*
  184                  * If the operation that succeeded was mount, then mark
  185                  * the node as non-cached.  Otherwise, if someone unmounts
  186                  * the filesystem before the cache times out, we will fail
  187                  * to trigger.
  188                  */
  189                 anp->an_cached = false;
  190         }
  191 
  192         error = VFS_ROOT(vp->v_mountedhere, lock_flags, newvp);
  193         if (error != 0) {
  194                 AUTOFS_WARN("VFS_ROOT() failed with error %d", error);
  195                 return (error);
  196         }
  197 
  198         return (0);
  199 }
  200 
  201 static int
  202 autofs_vget_callback(struct mount *mp, void *arg, int flags,
  203     struct vnode **vpp)
  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(curthread) == 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, reclen;
  356         int error;
  357 
  358         namlen = strlen(name);
  359         reclen = _GENERIC_DIRLEN(namlen);
  360         if (reclenp != NULL)
  361                 *reclenp = reclen;
  362 
  363         if (uio == NULL)
  364                 return (0);
  365 
  366         if (uio->uio_resid < reclen)
  367                 return (EINVAL);
  368 
  369         dirent.d_fileno = fileno;
  370         dirent.d_off = uio->uio_offset + reclen;
  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(&amp->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         vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
  687 
  688         vp->v_type = VDIR;
  689         if (anp->an_parent == NULL)
  690                 vp->v_vflag |= VV_ROOT;
  691         vp->v_data = anp;
  692 
  693         VN_LOCK_ASHARE(vp);
  694 
  695         error = insmntque(vp, mp);
  696         if (error != 0) {
  697                 AUTOFS_DEBUG("insmntque() failed with error %d", error);
  698                 sx_xunlock(&anp->an_vnode_lock);
  699                 return (error);
  700         }
  701 
  702         KASSERT(anp->an_vnode == NULL, ("lost race"));
  703         anp->an_vnode = vp;
  704 
  705         sx_xunlock(&anp->an_vnode_lock);
  706 
  707         vn_set_state(vp, VSTATE_CONSTRUCTED);
  708         *vpp = vp;
  709         return (0);
  710 }
Cache object: 695e2854fdefb6173dd06c45d2e4d976
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]
This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.
FreeBSD/Linux Kernel Cross Reference sys/fs/autofs/autofs_vnops.c

FreeBSD/Linux Kernel Cross Reference
sys/fs/autofs/autofs_vnops.c
