null_subr.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) 1992, 1993
    3  *      The Regents of the University of California.  All rights reserved.
    4  *
    5  * This code is derived from software donated to Berkeley by
    6  * Jan-Simon Pendry.
    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  * 4. Neither the name of the University nor the names of its contributors
   17  *    may be used to endorse or promote products derived from this software
   18  *    without specific prior written permission.
   19  *
   20  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
   21  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
   22  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
   23  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
   24  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
   25  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
   26  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
   27  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
   28  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
   29  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
   30  * SUCH DAMAGE.
   31  *
   32  *      @(#)null_subr.c 8.7 (Berkeley) 5/14/95
   33  *
   34  * $FreeBSD: releng/8.0/sys/fs/nullfs/null_subr.c 193173 2009-05-31 14:54:20Z kib $
   35  */
   36 
   37 #include <sys/param.h>
   38 #include <sys/systm.h>
   39 #include <sys/kernel.h>
   40 #include <sys/lock.h>
   41 #include <sys/mutex.h>
   42 #include <sys/malloc.h>
   43 #include <sys/mount.h>
   44 #include <sys/proc.h>
   45 #include <sys/vnode.h>
   46 
   47 #include <fs/nullfs/null.h>
   48 
   49 #define LOG2_SIZEVNODE 8                /* log2(sizeof struct vnode) */
   50 #define NNULLNODECACHE 16
   51 
   52 /*
   53  * Null layer cache:
   54  * Each cache entry holds a reference to the lower vnode
   55  * along with a pointer to the alias vnode.  When an
   56  * entry is added the lower vnode is VREF'd.  When the
   57  * alias is removed the lower vnode is vrele'd.
   58  */
   59 
   60 #define NULL_NHASH(vp) \
   61         (&null_node_hashtbl[(((uintptr_t)vp)>>LOG2_SIZEVNODE) & null_node_hash])
   62 
   63 static LIST_HEAD(null_node_hashhead, null_node) *null_node_hashtbl;
   64 static u_long null_node_hash;
   65 struct mtx null_hashmtx;
   66 
   67 static MALLOC_DEFINE(M_NULLFSHASH, "nullfs_hash", "NULLFS hash table");
   68 MALLOC_DEFINE(M_NULLFSNODE, "nullfs_node", "NULLFS vnode private part");
   69 
   70 static struct vnode * null_hashget(struct mount *, struct vnode *);
   71 static struct vnode * null_hashins(struct mount *, struct null_node *);
   72 
   73 /*
   74  * Initialise cache headers
   75  */
   76 int
   77 nullfs_init(vfsp)
   78         struct vfsconf *vfsp;
   79 {
   80 
   81         NULLFSDEBUG("nullfs_init\n");           /* printed during system boot */
   82         null_node_hashtbl = hashinit(NNULLNODECACHE, M_NULLFSHASH, &null_node_hash);
   83         mtx_init(&null_hashmtx, "nullhs", NULL, MTX_DEF);
   84         return (0);
   85 }
   86 
   87 int
   88 nullfs_uninit(vfsp)
   89         struct vfsconf *vfsp;
   90 {
   91 
   92         mtx_destroy(&null_hashmtx);
   93         free(null_node_hashtbl, M_NULLFSHASH);
   94         return (0);
   95 }
   96 
   97 /*
   98  * Return a VREF'ed alias for lower vnode if already exists, else 0.
   99  * Lower vnode should be locked on entry and will be left locked on exit.
  100  */
  101 static struct vnode *
  102 null_hashget(mp, lowervp)
  103         struct mount *mp;
  104         struct vnode *lowervp;
  105 {
  106         struct null_node_hashhead *hd;
  107         struct null_node *a;
  108         struct vnode *vp;
  109 
  110         ASSERT_VOP_LOCKED(lowervp, "null_hashget");
  111 
  112         /*
  113          * Find hash base, and then search the (two-way) linked
  114          * list looking for a null_node structure which is referencing
  115          * the lower vnode.  If found, the increment the null_node
  116          * reference count (but NOT the lower vnode's VREF counter).
  117          */
  118         hd = NULL_NHASH(lowervp);
  119         mtx_lock(&null_hashmtx);
  120         LIST_FOREACH(a, hd, null_hash) {
  121                 if (a->null_lowervp == lowervp && NULLTOV(a)->v_mount == mp) {
  122                         /*
  123                          * Since we have the lower node locked the nullfs
  124                          * node can not be in the process of recycling.  If
  125                          * it had been recycled before we grabed the lower
  126                          * lock it would not have been found on the hash.
  127                          */
  128                         vp = NULLTOV(a);
  129                         vref(vp);
  130                         mtx_unlock(&null_hashmtx);
  131                         return (vp);
  132                 }
  133         }
  134         mtx_unlock(&null_hashmtx);
  135         return (NULLVP);
  136 }
  137 
  138 /*
  139  * Act like null_hashget, but add passed null_node to hash if no existing
  140  * node found.
  141  */
  142 static struct vnode *
  143 null_hashins(mp, xp)
  144         struct mount *mp;
  145         struct null_node *xp;
  146 {
  147         struct null_node_hashhead *hd;
  148         struct null_node *oxp;
  149         struct vnode *ovp;
  150 
  151         hd = NULL_NHASH(xp->null_lowervp);
  152         mtx_lock(&null_hashmtx);
  153         LIST_FOREACH(oxp, hd, null_hash) {
  154                 if (oxp->null_lowervp == xp->null_lowervp &&
  155                     NULLTOV(oxp)->v_mount == mp) {
  156                         /*
  157                          * See null_hashget for a description of this
  158                          * operation.
  159                          */
  160                         ovp = NULLTOV(oxp);
  161                         vref(ovp);
  162                         mtx_unlock(&null_hashmtx);
  163                         return (ovp);
  164                 }
  165         }
  166         LIST_INSERT_HEAD(hd, xp, null_hash);
  167         mtx_unlock(&null_hashmtx);
  168         return (NULLVP);
  169 }
  170 
  171 static void
  172 null_insmntque_dtr(struct vnode *vp, void *xp)
  173 {
  174         vp->v_data = NULL;
  175         vp->v_vnlock = &vp->v_lock;
  176         free(xp, M_NULLFSNODE);
  177         vp->v_op = &dead_vnodeops;
  178         (void) vn_lock(vp, LK_EXCLUSIVE | LK_RETRY);
  179         vgone(vp);
  180         vput(vp);
  181 }
  182 
  183 /*
  184  * Make a new or get existing nullfs node.
  185  * Vp is the alias vnode, lowervp is the lower vnode.
  186  * 
  187  * The lowervp assumed to be locked and having "spare" reference. This routine
  188  * vrele lowervp if nullfs node was taken from hash. Otherwise it "transfers"
  189  * the caller's "spare" reference to created nullfs vnode.
  190  */
  191 int
  192 null_nodeget(mp, lowervp, vpp)
  193         struct mount *mp;
  194         struct vnode *lowervp;
  195         struct vnode **vpp;
  196 {
  197         struct null_node *xp;
  198         struct vnode *vp;
  199         int error;
  200 
  201         /* Lookup the hash firstly */
  202         *vpp = null_hashget(mp, lowervp);
  203         if (*vpp != NULL) {
  204                 vrele(lowervp);
  205                 return (0);
  206         }
  207 
  208         /*
  209          * We do not serialize vnode creation, instead we will check for
  210          * duplicates later, when adding new vnode to hash.
  211          *
  212          * Note that duplicate can only appear in hash if the lowervp is
  213          * locked LK_SHARED.
  214          */
  215 
  216         /*
  217          * Do the MALLOC before the getnewvnode since doing so afterward
  218          * might cause a bogus v_data pointer to get dereferenced
  219          * elsewhere if MALLOC should block.
  220          */
  221         xp = malloc(sizeof(struct null_node),
  222             M_NULLFSNODE, M_WAITOK);
  223 
  224         error = getnewvnode("null", mp, &null_vnodeops, &vp);
  225         if (error) {
  226                 free(xp, M_NULLFSNODE);
  227                 return (error);
  228         }
  229 
  230         xp->null_vnode = vp;
  231         xp->null_lowervp = lowervp;
  232         vp->v_type = lowervp->v_type;
  233         vp->v_data = xp;
  234         vp->v_vnlock = lowervp->v_vnlock;
  235         if (vp->v_vnlock == NULL)
  236                 panic("null_nodeget: Passed a NULL vnlock.\n");
  237         error = insmntque1(vp, mp, null_insmntque_dtr, xp);
  238         if (error != 0)
  239                 return (error);
  240         /*
  241          * Atomically insert our new node into the hash or vget existing 
  242          * if someone else has beaten us to it.
  243          */
  244         *vpp = null_hashins(mp, xp);
  245         if (*vpp != NULL) {
  246                 vrele(lowervp);
  247                 vp->v_vnlock = &vp->v_lock;
  248                 xp->null_lowervp = NULL;
  249                 vrele(vp);
  250                 return (0);
  251         }
  252         *vpp = vp;
  253 
  254         return (0);
  255 }
  256 
  257 /*
  258  * Remove node from hash.
  259  */
  260 void
  261 null_hashrem(xp)
  262         struct null_node *xp;
  263 {
  264 
  265         mtx_lock(&null_hashmtx);
  266         LIST_REMOVE(xp, null_hash);
  267         mtx_unlock(&null_hashmtx);
  268 }
  269 
  270 #ifdef DIAGNOSTIC
  271 
  272 struct vnode *
  273 null_checkvp(vp, fil, lno)
  274         struct vnode *vp;
  275         char *fil;
  276         int lno;
  277 {
  278         struct null_node *a = VTONULL(vp);
  279 
  280 #ifdef notyet
  281         /*
  282          * Can't do this check because vop_reclaim runs
  283          * with a funny vop vector.
  284          */
  285         if (vp->v_op != null_vnodeop_p) {
  286                 printf ("null_checkvp: on non-null-node\n");
  287                 panic("null_checkvp");
  288         }
  289 #endif
  290         if (a->null_lowervp == NULLVP) {
  291                 /* Should never happen */
  292                 int i; u_long *p;
  293                 printf("vp = %p, ZERO ptr\n", (void *)vp);
  294                 for (p = (u_long *) a, i = 0; i < 8; i++)
  295                         printf(" %lx", p[i]);
  296                 printf("\n");
  297                 panic("null_checkvp");
  298         }
  299         VI_LOCK_FLAGS(a->null_lowervp, MTX_DUPOK);
  300         if (a->null_lowervp->v_usecount < 1) {
  301                 int i; u_long *p;
  302                 printf("vp = %p, unref'ed lowervp\n", (void *)vp);
  303                 for (p = (u_long *) a, i = 0; i < 8; i++)
  304                         printf(" %lx", p[i]);
  305                 printf("\n");
  306                 panic ("null with unref'ed lowervp");
  307         }
  308         VI_UNLOCK(a->null_lowervp);
  309 #ifdef notyet
  310         printf("null %x/%d -> %x/%d [%s, %d]\n",
  311                 NULLTOV(a), vrefcnt(NULLTOV(a)),
  312                 a->null_lowervp, vrefcnt(a->null_lowervp),
  313                 fil, lno);
  314 #endif
  315         return (a->null_lowervp);
  316 }
  317 #endif
Cache object: fd21ecc02a4f1c39966e7ad9fe10703c
[ 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/nullfs/null_subr.c

FreeBSD/Linux Kernel Cross Reference
sys/fs/nullfs/null_subr.c
