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  * 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/systm.h>
   38 #include <sys/kernel.h>
   39 #include <sys/condvar.h>
   40 #include <sys/dirent.h>
   41 #include <sys/fcntl.h>
   42 #include <sys/lock.h>
   43 #include <sys/mount.h>
   44 #include <sys/mutex.h>
   45 #include <sys/namei.h>
   46 #include <sys/signalvar.h>
   47 #include <sys/stat.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, reclen;
  358         int error;
  359 
  360         namlen = strlen(name);
  361         reclen = _GENERIC_DIRLEN(namlen);
  362         if (reclenp != NULL)
  363                 *reclenp = reclen;
  364 
  365         if (uio == NULL)
  366                 return (0);
  367 
  368         if (uio->uio_resid < reclen)
  369                 return (EINVAL);
  370 
  371         dirent.d_fileno = fileno;
  372         dirent.d_off = uio->uio_offset + reclen;
  373         dirent.d_reclen = reclen;
  374         dirent.d_type = DT_DIR;
  375         dirent.d_namlen = namlen;
  376         memcpy(dirent.d_name, name, namlen);
  377         dirent_terminate(&dirent);
  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(&amp->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 }
Cache object: b0eabadacc2d19f84d90a9076401d542
[ 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
