sys/kern/vfs_lock.c

   1 /*
   2  * Copyright (c) 2004 The DragonFly Project.  All rights reserved.
   3  *
   4  * This code is derived from software contributed to The DragonFly Project
   5  * by Matthew Dillon <dillon@backplane.com>
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  *
  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
  15  *    the documentation and/or other materials provided with the
  16  *    distribution.
  17  * 3. Neither the name of The DragonFly Project nor the names of its
  18  *    contributors may be used to endorse or promote products derived
  19  *    from this software without specific, prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  22  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  23  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  24  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE
  25  * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  26  * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
  27  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  28  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
  29  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  30  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  31  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  32  * SUCH DAMAGE.
  33  *
  34  * $DragonFly: src/sys/kern/vfs_lock.c,v 1.17 2006/05/06 02:43:12 dillon Exp $
  35  */
  36
  37 /*
  38  * External virtual filesystem routines
  39  */
  40 #include "opt_ddb.h"
  41
  42 #include <sys/param.h>
  43 #include <sys/systm.h>
  44 #include <sys/kernel.h>
  45 #include <sys/malloc.h>
  46 #include <sys/mount.h>
  47 #include <sys/proc.h>
  48 #include <sys/vnode.h>
  49 #include <sys/buf.h>
  50 #include <sys/sysctl.h>
  51
  52 #include <machine/limits.h>
  53
  54 #include <vm/vm.h>
  55 #include <vm/vm_object.h>
  56
  57 #include <sys/buf2.h>
  58 #include <sys/thread2.h>
  59
  60
  61 static MALLOC_DEFINE(M_VNODE, "vnodes", "vnode structures");
  62
  63 static TAILQ_HEAD(freelst, vnode) vnode_free_list;      /* vnode free list */
  64
  65 int  freevnodes = 0;
  66 SYSCTL_INT(_debug, OID_AUTO, freevnodes, CTLFLAG_RD,
  67                 &freevnodes, 0, "");
  68 static int wantfreevnodes = 25;
  69 SYSCTL_INT(_debug, OID_AUTO, wantfreevnodes, CTLFLAG_RW,
  70                 &wantfreevnodes, 0, "");
  71 static int minvnodes;
  72 SYSCTL_INT(_kern, OID_AUTO, minvnodes, CTLFLAG_RW,
  73                 &minvnodes, 0, "Minimum number of vnodes");
  74
  75 /*
  76  * Called from vfsinit()
  77  */
  78 void
  79 vfs_lock_init(void)
  80 {
  81         minvnodes = desiredvnodes / 4;
  82
  83         TAILQ_INIT(&vnode_free_list);
  84 }
  85
  86 /*
  87  * Inline helper functions.  vbusy() and vfree() must be called while in a
  88  * critical section.
  89  */
  90 static __inline
  91 void
  92 __vbusy(struct vnode *vp)
  93 {
  94         KKASSERT(vp->v_flag & VFREE);
  95         TAILQ_REMOVE(&vnode_free_list, vp, v_freelist);
  96         freevnodes--;
  97         vp->v_flag &= ~(VFREE|VAGE);
  98 }
  99
 100 static __inline
 101 void
 102 __vfree(struct vnode *vp)
 103 {
 104         KKASSERT((vp->v_flag & VFREE) == 0);
 105         if (vp->v_flag & (VAGE|VRECLAIMED))
 106                 TAILQ_INSERT_HEAD(&vnode_free_list, vp, v_freelist);
 107         else
 108                 TAILQ_INSERT_TAIL(&vnode_free_list, vp, v_freelist);
 109         freevnodes++;
 110         vp->v_flag &= ~VAGE;
 111         vp->v_flag |= VFREE;
 112 }
 113
 114 /*
 115  * Return 1 if we can immediately place the vnode on the freelist.
 116  */
 117 static __inline int
 118 vshouldfree(struct vnode *vp, int usecount)
 119 {
 120         if (vp->v_holdcnt != 0 || vp->v_usecount != usecount)
 121                 return (0);             /* other holderse */
 122         if (vp->v_object &&
 123             (vp->v_object->ref_count || vp->v_object->resident_page_count)) {
 124                 return (0);
 125         }
 126         return (1);
 127 }
 128
 129 /*
 130  * Reference a vnode or release the reference on a vnode.  The vnode will
 131  * be taken off the freelist if it is on it and cannot be recycled or
 132  * deactivated while refd.  The last release of a vnode will deactivate the
 133  * vnode via VOP_INACTIVE().
 134  *
 135  * Special cases: refing a vnode does not clear VINACTIVE, you have to vget()
 136  * the vnode shared or exclusive to do that.
 137  */
 138 static __inline
 139 void
 140 __vref(struct vnode *vp)
 141 {
 142         ++vp->v_usecount;
 143         if (vp->v_flag & VFREE)
 144                 __vbusy(vp);
 145 }
 146
 147 void
 148 vref(struct vnode *vp)
 149 {
 150         crit_enter();
 151         __vref(vp);
 152         crit_exit();
 153 }
 154
 155 void
 156 vrele(struct vnode *vp)
 157 {
 158         crit_enter();
 159         if (vp->v_usecount == 1) {
 160                 KASSERT(lockcountnb(&vp->v_lock) == 0, ("last vrele vp %p still locked", vp));
 161
 162                 /*
 163                  * Deactivation requires an exclusive v_lock (vx_lock()), and
 164                  * only occurs if the usecount is still 1 after locking.
 165                  */
 166                 if ((vp->v_flag & VINACTIVE) == 0) {
 167                         if (vx_lock(vp) == 0) {
 168                                 if ((vp->v_flag & VINACTIVE) == 0 &&
 169                                     vp->v_usecount == 1) {
 170                                         vp->v_flag |= VINACTIVE;
 171                                         VOP_INACTIVE(vp);
 172                                 }
 173                                 vx_unlock(vp);
 174                         }
 175                 }
 176                 if (vshouldfree(vp, 1))
 177                         __vfree(vp);
 178         } else {
 179                 KKASSERT(vp->v_usecount > 0);
 180         }
 181         --vp->v_usecount;
 182         crit_exit();
 183 }
 184
 185 /*
 186  * Hold a vnode or drop the hold on a vnode.  The vnode will be taken off
 187  * the freelist if it is on it and cannot be recycled.  However, the
 188  * vnode can be deactivated and reactivated while held.
 189  *
 190  * Special cases: The last drop of a vnode does nothing special, allowing it
 191  * to be called from an interrupt.  vrele() on the otherhand cannot be called
 192  * from an interrupt.
 193  */
 194 void
 195 vhold(struct vnode *vp)
 196 {
 197         crit_enter();
 198         ++vp->v_holdcnt;
 199         if (vp->v_flag & VFREE)
 200                 __vbusy(vp);
 201         crit_exit();
 202 }
 203
 204 void
 205 vdrop(struct vnode *vp)
 206 {
 207         crit_enter();
 208         if (vp->v_holdcnt == 1) {
 209                 --vp->v_holdcnt;
 210                 if (vshouldfree(vp, 0))
 211                         __vfree(vp);
 212         } else {
 213                 --vp->v_holdcnt;
 214                 KKASSERT(vp->v_holdcnt > 0);
 215         }
 216         crit_exit();
 217 }
 218
 219 /****************************************************************
 220  *                      VX LOCKING FUNCTIONS                    *
 221  ****************************************************************
 222  *
 223  * These functions lock vnodes for reclamation and deactivation ops.
 224  * Only vp->v_lock, the top layer of the VFS, is locked.  You must be
 225  * holding a normal reference in order to be able to safely call vx_lock()
 226  * and vx_unlock().  vx_get() and vx_put() are combination functions which
 227  * vref+vx_lock and vrele+vx_unlock.
 228  */
 229
 230 #define VXLOCKFLAGS     (LK_EXCLUSIVE|LK_RETRY)
 231 #define VXLOCKFLAGS_NB  (LK_EXCLUSIVE|LK_NOWAIT)
 232
 233 static int
 234 __vxlock(struct vnode *vp, int flags)
 235 {
 236         return(lockmgr(&vp->v_lock, flags));
 237 }
 238
 239 static void
 240 __vxunlock(struct vnode *vp)
 241 {
 242         lockmgr(&vp->v_lock, LK_RELEASE);
 243 }
 244
 245 int
 246 vx_lock(struct vnode *vp)
 247 {
 248         return(__vxlock(vp, VXLOCKFLAGS));
 249 }
 250
 251 void
 252 vx_unlock(struct vnode *vp)
 253 {
 254         __vxunlock(vp);
 255 }
 256
 257 int
 258 vx_get(struct vnode *vp)
 259 {
 260         int error;
 261
 262         vref(vp);
 263         if ((error = __vxlock(vp, VXLOCKFLAGS)) != 0)
 264                 vrele(vp);
 265         return(error);
 266 }
 267
 268 int
 269 vx_get_nonblock(struct vnode *vp)
 270 {
 271         int error;
 272
 273         vref(vp);
 274         if ((error = __vxlock(vp, VXLOCKFLAGS_NB)) != 0)
 275                 vrele(vp);
 276         return(error);
 277 }
 278
 279 void
 280 vx_put(struct vnode *vp)
 281 {
 282         __vxunlock(vp);
 283         vrele(vp);
 284 }
 285
 286 /****************************************************************
 287  *                      VNODE ACQUISITION FUNCTIONS             *
 288  ****************************************************************
 289  *
 290  * vget() and vput() access a vnode for the intent of executing an
 291  * operation other then a reclamation or deactivation.  vget() will ref
 292  * and lock the vnode, vput() will unlock and deref the vnode.
 293  * The VOP_*() locking functions are used.
 294  *
 295  * CALLING VGET IS MANDATORY PRIOR TO ANY MODIFYING OPERATION ON A VNODE.
 296  * This is because vget handles the VINACTIVE interlock and is responsible
 297  * for clearing the bit.  If the bit is not cleared inode updates may not
 298  * make it to disk.
 299  *
 300  * Special cases: If vget()'s locking operation fails the vrele() call may
 301  * cause the vnode to be deactivated (VOP_INACTIVE called).  However, this
 302  * never occurs if the vnode is in a reclaimed state.  Vnodes in reclaimed
 303  * states always return an error code of ENOENT.
 304  *
 305  * Special cases: vput() will unlock and, if it is the last reference,
 306  * deactivate the vnode.  The deactivation uses a separate non-layered
 307  * VX lock after the normal unlock.  XXX make it more efficient.
 308  */
 309 int
 310 vget(struct vnode *vp, int flags)
 311 {
 312         int error;
 313
 314         crit_enter();
 315         __vref(vp);
 316         if (flags & LK_TYPE_MASK) {
 317                 if ((error = vn_lock(vp, flags)) != 0) {
 318                         vrele(vp);
 319                 } else if (vp->v_flag & VRECLAIMED) {
 320                         VOP_UNLOCK(vp, 0);
 321                         vrele(vp);
 322                         error = ENOENT;
 323                 } else {
 324                         vp->v_flag &= ~VINACTIVE;
 325                         error = 0;
 326                 }
 327         } else {
 328                 panic("vget() called with no lock specified!");
 329                 error = ENOENT; /* not reached, compiler opt */
 330         }
 331         crit_exit();
 332         return(error);
 333 }
 334
 335 void
 336 vput(struct vnode *vp)
 337 {
 338         VOP_UNLOCK(vp, 0);
 339         vrele(vp);
 340 }
 341
 342 void
 343 vsetflags(struct vnode *vp, int flags)
 344 {
 345         crit_enter();
 346         vp->v_flag |= flags;
 347         crit_exit();
 348 }
 349
 350 void
 351 vclrflags(struct vnode *vp, int flags)
 352 {
 353         crit_enter();
 354         vp->v_flag &= ~flags;
 355         crit_exit();
 356 }
 357
 358 /*
 359  * Obtain a new vnode from the freelist, allocating more if necessary.
 360  * The returned vnode is VX locked & refd.
 361  */
 362 struct vnode *
 363 allocvnode(int lktimeout, int lkflags)
 364 {
 365         struct thread *td;
 366         struct vnode *vp;
 367
 368         /*
 369          * Try to reuse vnodes if we hit the max.  This situation only
 370          * occurs in certain large-memory (2G+) situations.  We cannot
 371          * attempt to directly reclaim vnodes due to nasty recursion
 372          * problems.
 373          */
 374         while (numvnodes - freevnodes > desiredvnodes)
 375                 vnlru_proc_wait();
 376
 377         td = curthread;
 378         vp = NULL;
 379
 380         /*
 381          * Attempt to reuse a vnode already on the free list, allocating
 382          * a new vnode if we can't find one or if we have not reached a
 383          * good minimum for good LRU performance.
 384          */
 385         if (freevnodes >= wantfreevnodes && numvnodes >= minvnodes) {
 386                 int count;
 387
 388                 for (count = 0; count < freevnodes; count++) {
 389                         /*
 390                          * __VNODESCAN__
 391                          *
 392                          * Pull the next vnode off the free list and do some
 393                          * sanity checks.  Note that regardless of how we
 394                          * block, if freevnodes is non-zero there had better
 395                          * be something on the list.
 396                          */
 397                         vp = TAILQ_FIRST(&vnode_free_list);
 398                         if (vp == NULL)
 399                                 panic("getnewvnode: free vnode isn't");
 400
 401                         /*
 402                          * Note the lack of a critical section.  We vx_get()
 403                          * the vnode before we check it for validity, reducing
 404                          * the number of checks we have to make.  The vx_get()
 405                          * will pull it off the freelist.
 406                          */
 407                         if (vx_get(vp)) {
 408                                 vp = NULL;
 409                                 continue;
 410                         }
 411
 412                         /*
 413                          * Can this vnode be recycled?  It must be in a
 414                          * VINACTIVE state with only our reference to it.
 415                          * (vx_get(), unlike vget(), does not reactivate
 416                          * the vnode).  vx_put() will recycle it onto the
 417                          * end of the freelist.
 418                          */
 419                         if ((vp->v_flag & VINACTIVE) == 0 ||
 420                             vp->v_holdcnt || vp->v_usecount != 1) {
 421                                 vx_put(vp);
 422                                 vp = NULL;
 423                                 continue;
 424                         }
 425
 426                         /*
 427                          * Ok, we can reclaim the vnode if it isn't already
 428                          * in a reclaimed state.  If the reclamation fails,
 429                          * or if someone else is referencing the vnode after
 430                          * we have vgone()'d it, we recycle the vnode on the
 431                          * freelist or hold it (by calling vx_put()).
 432                          */
 433                         if ((vp->v_flag & VRECLAIMED) == 0) {
 434                                 vgone(vp);
 435                                 if ((vp->v_flag & VRECLAIMED) == 0 ||
 436                                     vp->v_holdcnt || vp->v_usecount != 1) {
 437                                         vx_put(vp);
 438                                         vp = NULL;
 439                                         continue;
 440                                 }
 441                         }
 442                         KKASSERT(vp->v_flag & VINACTIVE);
 443
 444                         /*
 445                          * We have a vnode!
 446                          */
 447                         break;
 448                 }
 449         }
 450
 451         /*
 452          * If we have a vp it will be refd and VX locked.
 453          */
 454         if (vp) {
 455 #ifdef INVARIANTS
 456                 if (vp->v_data)
 457                         panic("cleaned vnode isn't");
 458                 if (vp->v_track_read.bk_active + vp->v_track_write.bk_active)
 459                         panic("Clean vnode has pending I/O's");
 460                 KKASSERT(vp->v_mount == NULL);
 461 #endif
 462                 vp->v_flag = 0;
 463                 vp->v_lastw = 0;
 464                 vp->v_lasta = 0;
 465                 vp->v_cstart = 0;
 466                 vp->v_clen = 0;
 467                 vp->v_socket = 0;
 468                 vp->v_opencount = 0;
 469                 vp->v_writecount = 0;   /* XXX */
 470                 lockreinit(&vp->v_lock, "vnode", lktimeout, lkflags);
 471                 KKASSERT(TAILQ_FIRST(&vp->v_namecache) == NULL);
 472         } else {
 473                 /*
 474                  * A brand-new vnode (we could use malloc() here I think) XXX
 475                  */
 476                 vp = malloc(sizeof(struct vnode), M_VNODE, M_WAITOK|M_ZERO);
 477                 lwkt_token_init(&vp->v_pollinfo.vpi_token);
 478                 lockinit(&vp->v_lock, "vnode", lktimeout, lkflags);
 479                 TAILQ_INIT(&vp->v_namecache);
 480
 481                 /*
 482                  * short cut around vfreeing it and looping, just set it up
 483                  * as if we had pulled a reclaimed vnode off the freelist
 484                  * and reinitialized it.
 485                  */
 486                 vp->v_usecount = 1;
 487                 if (__vxlock(vp, VXLOCKFLAGS))
 488                         panic("getnewvnode: __vxlock failed");
 489                 numvnodes++;
 490         }
 491
 492         RB_INIT(&vp->v_rbclean_tree);
 493         RB_INIT(&vp->v_rbdirty_tree);
 494         RB_INIT(&vp->v_rbhash_tree);
 495         vp->v_filesize = NOOFFSET;
 496         vp->v_type = VNON;
 497         vp->v_tag = 0;
 498         vp->v_ops = NULL;
 499         vp->v_data = NULL;
 500         KKASSERT(vp->v_mount == NULL);
 501         return (vp);
 502 }
 503