The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/fs/autofs/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  * 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: releng/10.4/sys/fs/autofs/autofs_vnops.c 274239 2014-11-07 15:52:32Z trasz $");
   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 }

Cache object: c94f679a5a7698d0d76585fd1ae08947


[ 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.