sys/kern/vfs_bio.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
   3  *
   4  * Copyright (c) 2004 Poul-Henning Kamp
   5  * Copyright (c) 1994,1997 John S. Dyson
   6  * Copyright (c) 2013 The FreeBSD Foundation
   7  * All rights reserved.
   8  *
   9  * Portions of this software were developed by Konstantin Belousov
  10  * under sponsorship from the FreeBSD Foundation.
  11  *
  12  * Redistribution and use in source and binary forms, with or without
  13  * modification, are permitted provided that the following conditions
  14  * are met:
  15  * 1. Redistributions of source code must retain the above copyright
  16  *    notice, this list of conditions and the following disclaimer.
  17  * 2. Redistributions in binary form must reproduce the above copyright
  18  *    notice, this list of conditions and the following disclaimer in the
  19  *    documentation and/or other materials provided with the distribution.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  31  * SUCH DAMAGE.
  32  */
  33
  34 /*
  35  * this file contains a new buffer I/O scheme implementing a coherent
  36  * VM object and buffer cache scheme.  Pains have been taken to make
  37  * sure that the performance degradation associated with schemes such
  38  * as this is not realized.
  39  *
  40  * Author:  John S. Dyson
  41  * Significant help during the development and debugging phases
  42  * had been provided by David Greenman, also of the FreeBSD core team.
  43  *
  44  * see man buf(9) for more info.
  45  */
  46
  47 #include <sys/cdefs.h>
  48 __FBSDID("$FreeBSD$");
  49
  50 #include <sys/param.h>
  51 #include <sys/systm.h>
  52 #include <sys/bio.h>
  53 #include <sys/bitset.h>
  54 #include <sys/conf.h>
  55 #include <sys/counter.h>
  56 #include <sys/buf.h>
  57 #include <sys/devicestat.h>
  58 #include <sys/eventhandler.h>
  59 #include <sys/fail.h>
  60 #include <sys/ktr.h>
  61 #include <sys/limits.h>
  62 #include <sys/lock.h>
  63 #include <sys/malloc.h>
  64 #include <sys/mount.h>
  65 #include <sys/mutex.h>
  66 #include <sys/kernel.h>
  67 #include <sys/kthread.h>
  68 #include <sys/proc.h>
  69 #include <sys/racct.h>
  70 #include <sys/refcount.h>
  71 #include <sys/resourcevar.h>
  72 #include <sys/rwlock.h>
  73 #include <sys/smp.h>
  74 #include <sys/sysctl.h>
  75 #include <sys/syscallsubr.h>
  76 #include <sys/vmem.h>
  77 #include <sys/vmmeter.h>
  78 #include <sys/vnode.h>
  79 #include <sys/watchdog.h>
  80 #include <geom/geom.h>
  81 #include <vm/vm.h>
  82 #include <vm/vm_param.h>
  83 #include <vm/vm_kern.h>
  84 #include <vm/vm_object.h>
  85 #include <vm/vm_page.h>
  86 #include <vm/vm_pageout.h>
  87 #include <vm/vm_pager.h>
  88 #include <vm/vm_extern.h>
  89 #include <vm/vm_map.h>
  90 #include <vm/swap_pager.h>
  91
  92 static MALLOC_DEFINE(M_BIOBUF, "biobuf", "BIO buffer");
  93
  94 struct  bio_ops bioops;         /* I/O operation notification */
  95
  96 struct  buf_ops buf_ops_bio = {
  97         .bop_name       =       "buf_ops_bio",
  98         .bop_write      =       bufwrite,
  99         .bop_strategy   =       bufstrategy,
 100         .bop_sync       =       bufsync,
 101         .bop_bdflush    =       bufbdflush,
 102 };
 103
 104 struct bufqueue {
 105         struct mtx_padalign     bq_lock;
 106         TAILQ_HEAD(, buf)       bq_queue;
 107         uint8_t                 bq_index;
 108         uint16_t                bq_subqueue;
 109         int                     bq_len;
 110 } __aligned(CACHE_LINE_SIZE);
 111
 112 #define BQ_LOCKPTR(bq)          (&(bq)->bq_lock)
 113 #define BQ_LOCK(bq)             mtx_lock(BQ_LOCKPTR((bq)))
 114 #define BQ_UNLOCK(bq)           mtx_unlock(BQ_LOCKPTR((bq)))
 115 #define BQ_ASSERT_LOCKED(bq)    mtx_assert(BQ_LOCKPTR((bq)), MA_OWNED)
 116
 117 struct bufdomain {
 118         struct bufqueue bd_subq[MAXCPU + 1]; /* Per-cpu sub queues + global */
 119         struct bufqueue bd_dirtyq;
 120         struct bufqueue *bd_cleanq;
 121         struct mtx_padalign bd_run_lock;
 122         /* Constants */
 123         long            bd_maxbufspace;
 124         long            bd_hibufspace;
 125         long            bd_lobufspace;
 126         long            bd_bufspacethresh;
 127         int             bd_hifreebuffers;
 128         int             bd_lofreebuffers;
 129         int             bd_hidirtybuffers;
 130         int             bd_lodirtybuffers;
 131         int             bd_dirtybufthresh;
 132         int             bd_lim;
 133         /* atomics */
 134         int             bd_wanted;
 135         int __aligned(CACHE_LINE_SIZE)  bd_numdirtybuffers;
 136         int __aligned(CACHE_LINE_SIZE)  bd_running;
 137         long __aligned(CACHE_LINE_SIZE) bd_bufspace;
 138         int __aligned(CACHE_LINE_SIZE)  bd_freebuffers;
 139 } __aligned(CACHE_LINE_SIZE);
 140
 141 #define BD_LOCKPTR(bd)          (&(bd)->bd_cleanq->bq_lock)
 142 #define BD_LOCK(bd)             mtx_lock(BD_LOCKPTR((bd)))
 143 #define BD_UNLOCK(bd)           mtx_unlock(BD_LOCKPTR((bd)))
 144 #define BD_ASSERT_LOCKED(bd)    mtx_assert(BD_LOCKPTR((bd)), MA_OWNED)
 145 #define BD_RUN_LOCKPTR(bd)      (&(bd)->bd_run_lock)
 146 #define BD_RUN_LOCK(bd)         mtx_lock(BD_RUN_LOCKPTR((bd)))
 147 #define BD_RUN_UNLOCK(bd)       mtx_unlock(BD_RUN_LOCKPTR((bd)))
 148 #define BD_DOMAIN(bd)           (bd - bdomain)
 149
 150 static char *buf;               /* buffer header pool */
 151 static struct buf *
 152 nbufp(unsigned i)
 153 {
 154         return ((struct buf *)(buf + (sizeof(struct buf) +
 155             sizeof(vm_page_t) * atop(maxbcachebuf)) * i));
 156 }
 157
 158 caddr_t __read_mostly unmapped_buf;
 159
 160 /* Used below and for softdep flushing threads in ufs/ffs/ffs_softdep.c */
 161 struct proc *bufdaemonproc;
 162
 163 static void vm_hold_free_pages(struct buf *bp, int newbsize);
 164 static void vm_hold_load_pages(struct buf *bp, vm_offset_t from,
 165                 vm_offset_t to);
 166 static void vfs_page_set_valid(struct buf *bp, vm_ooffset_t off, vm_page_t m);
 167 static void vfs_page_set_validclean(struct buf *bp, vm_ooffset_t off,
 168                 vm_page_t m);
 169 static void vfs_clean_pages_dirty_buf(struct buf *bp);
 170 static void vfs_setdirty_range(struct buf *bp);
 171 static void vfs_vmio_invalidate(struct buf *bp);
 172 static void vfs_vmio_truncate(struct buf *bp, int npages);
 173 static void vfs_vmio_extend(struct buf *bp, int npages, int size);
 174 static int vfs_bio_clcheck(struct vnode *vp, int size,
 175                 daddr_t lblkno, daddr_t blkno);
 176 static void breada(struct vnode *, daddr_t *, int *, int, struct ucred *, int,
 177                 void (*)(struct buf *));
 178 static int buf_flush(struct vnode *vp, struct bufdomain *, int);
 179 static int flushbufqueues(struct vnode *, struct bufdomain *, int, int);
 180 static void buf_daemon(void);
 181 static __inline void bd_wakeup(void);
 182 static int sysctl_runningspace(SYSCTL_HANDLER_ARGS);
 183 static void bufkva_reclaim(vmem_t *, int);
 184 static void bufkva_free(struct buf *);
 185 static int buf_import(void *, void **, int, int, int);
 186 static void buf_release(void *, void **, int);
 187 static void maxbcachebuf_adjust(void);
 188 static inline struct bufdomain *bufdomain(struct buf *);
 189 static void bq_remove(struct bufqueue *bq, struct buf *bp);
 190 static void bq_insert(struct bufqueue *bq, struct buf *bp, bool unlock);
 191 static int buf_recycle(struct bufdomain *, bool kva);
 192 static void bq_init(struct bufqueue *bq, int qindex, int cpu,
 193             const char *lockname);
 194 static void bd_init(struct bufdomain *bd);
 195 static int bd_flushall(struct bufdomain *bd);
 196 static int sysctl_bufdomain_long(SYSCTL_HANDLER_ARGS);
 197 static int sysctl_bufdomain_int(SYSCTL_HANDLER_ARGS);
 198
 199 static int sysctl_bufspace(SYSCTL_HANDLER_ARGS);
 200 int vmiodirenable = TRUE;
 201 SYSCTL_INT(_vfs, OID_AUTO, vmiodirenable, CTLFLAG_RW, &vmiodirenable, 0,
 202     "Use the VM system for directory writes");
 203 long runningbufspace;
 204 SYSCTL_LONG(_vfs, OID_AUTO, runningbufspace, CTLFLAG_RD, &runningbufspace, 0,
 205     "Amount of presently outstanding async buffer io");
 206 SYSCTL_PROC(_vfs, OID_AUTO, bufspace, CTLTYPE_LONG|CTLFLAG_MPSAFE|CTLFLAG_RD,
 207     NULL, 0, sysctl_bufspace, "L", "Physical memory used for buffers");
 208 static counter_u64_t bufkvaspace;
 209 SYSCTL_COUNTER_U64(_vfs, OID_AUTO, bufkvaspace, CTLFLAG_RD, &bufkvaspace,
 210     "Kernel virtual memory used for buffers");
 211 static long maxbufspace;
 212 SYSCTL_PROC(_vfs, OID_AUTO, maxbufspace,
 213     CTLTYPE_LONG|CTLFLAG_MPSAFE|CTLFLAG_RW, &maxbufspace,
 214     __offsetof(struct bufdomain, bd_maxbufspace), sysctl_bufdomain_long, "L",
 215     "Maximum allowed value of bufspace (including metadata)");
 216 static long bufmallocspace;
 217 SYSCTL_LONG(_vfs, OID_AUTO, bufmallocspace, CTLFLAG_RD, &bufmallocspace, 0,
 218     "Amount of malloced memory for buffers");
 219 static long maxbufmallocspace;
 220 SYSCTL_LONG(_vfs, OID_AUTO, maxmallocbufspace, CTLFLAG_RW, &maxbufmallocspace,
 221     0, "Maximum amount of malloced memory for buffers");
 222 static long lobufspace;
 223 SYSCTL_PROC(_vfs, OID_AUTO, lobufspace,
 224     CTLTYPE_LONG|CTLFLAG_MPSAFE|CTLFLAG_RW, &lobufspace,
 225     __offsetof(struct bufdomain, bd_lobufspace), sysctl_bufdomain_long, "L",
 226     "Minimum amount of buffers we want to have");
 227 long hibufspace;
 228 SYSCTL_PROC(_vfs, OID_AUTO, hibufspace,
 229     CTLTYPE_LONG|CTLFLAG_MPSAFE|CTLFLAG_RW, &hibufspace,
 230     __offsetof(struct bufdomain, bd_hibufspace), sysctl_bufdomain_long, "L",
 231     "Maximum allowed value of bufspace (excluding metadata)");
 232 long bufspacethresh;
 233 SYSCTL_PROC(_vfs, OID_AUTO, bufspacethresh,
 234     CTLTYPE_LONG|CTLFLAG_MPSAFE|CTLFLAG_RW, &bufspacethresh,
 235     __offsetof(struct bufdomain, bd_bufspacethresh), sysctl_bufdomain_long, "L",
 236     "Bufspace consumed before waking the daemon to free some");
 237 static counter_u64_t buffreekvacnt;
 238 SYSCTL_COUNTER_U64(_vfs, OID_AUTO, buffreekvacnt, CTLFLAG_RW, &buffreekvacnt,
 239     "Number of times we have freed the KVA space from some buffer");
 240 static counter_u64_t bufdefragcnt;
 241 SYSCTL_COUNTER_U64(_vfs, OID_AUTO, bufdefragcnt, CTLFLAG_RW, &bufdefragcnt,
 242     "Number of times we have had to repeat buffer allocation to defragment");
 243 static long lorunningspace;
 244 SYSCTL_PROC(_vfs, OID_AUTO, lorunningspace, CTLTYPE_LONG | CTLFLAG_MPSAFE |
 245     CTLFLAG_RW, &lorunningspace, 0, sysctl_runningspace, "L",
 246     "Minimum preferred space used for in-progress I/O");
 247 static long hirunningspace;
 248 SYSCTL_PROC(_vfs, OID_AUTO, hirunningspace, CTLTYPE_LONG | CTLFLAG_MPSAFE |
 249     CTLFLAG_RW, &hirunningspace, 0, sysctl_runningspace, "L",
 250     "Maximum amount of space to use for in-progress I/O");
 251 int dirtybufferflushes;
 252 SYSCTL_INT(_vfs, OID_AUTO, dirtybufferflushes, CTLFLAG_RW, &dirtybufferflushes,
 253     0, "Number of bdwrite to bawrite conversions to limit dirty buffers");
 254 int bdwriteskip;
 255 SYSCTL_INT(_vfs, OID_AUTO, bdwriteskip, CTLFLAG_RW, &bdwriteskip,
 256     0, "Number of buffers supplied to bdwrite with snapshot deadlock risk");
 257 int altbufferflushes;
 258 SYSCTL_INT(_vfs, OID_AUTO, altbufferflushes, CTLFLAG_RW | CTLFLAG_STATS,
 259     &altbufferflushes, 0, "Number of fsync flushes to limit dirty buffers");
 260 static int recursiveflushes;
 261 SYSCTL_INT(_vfs, OID_AUTO, recursiveflushes, CTLFLAG_RW | CTLFLAG_STATS,
 262     &recursiveflushes, 0, "Number of flushes skipped due to being recursive");
 263 static int sysctl_numdirtybuffers(SYSCTL_HANDLER_ARGS);
 264 SYSCTL_PROC(_vfs, OID_AUTO, numdirtybuffers,
 265     CTLTYPE_INT|CTLFLAG_MPSAFE|CTLFLAG_RD, NULL, 0, sysctl_numdirtybuffers, "I",
 266     "Number of buffers that are dirty (has unwritten changes) at the moment");
 267 static int lodirtybuffers;
 268 SYSCTL_PROC(_vfs, OID_AUTO, lodirtybuffers,
 269     CTLTYPE_INT|CTLFLAG_MPSAFE|CTLFLAG_RW, &lodirtybuffers,
 270     __offsetof(struct bufdomain, bd_lodirtybuffers), sysctl_bufdomain_int, "I",
 271     "How many buffers we want to have free before bufdaemon can sleep");
 272 static int hidirtybuffers;
 273 SYSCTL_PROC(_vfs, OID_AUTO, hidirtybuffers,
 274     CTLTYPE_INT|CTLFLAG_MPSAFE|CTLFLAG_RW, &hidirtybuffers,
 275     __offsetof(struct bufdomain, bd_hidirtybuffers), sysctl_bufdomain_int, "I",
 276     "When the number of dirty buffers is considered severe");
 277 int dirtybufthresh;
 278 SYSCTL_PROC(_vfs, OID_AUTO, dirtybufthresh,
 279     CTLTYPE_INT|CTLFLAG_MPSAFE|CTLFLAG_RW, &dirtybufthresh,
 280     __offsetof(struct bufdomain, bd_dirtybufthresh), sysctl_bufdomain_int, "I",
 281     "Number of bdwrite to bawrite conversions to clear dirty buffers");
 282 static int numfreebuffers;
 283 SYSCTL_INT(_vfs, OID_AUTO, numfreebuffers, CTLFLAG_RD, &numfreebuffers, 0,
 284     "Number of free buffers");
 285 static int lofreebuffers;
 286 SYSCTL_PROC(_vfs, OID_AUTO, lofreebuffers,
 287     CTLTYPE_INT|CTLFLAG_MPSAFE|CTLFLAG_RW, &lofreebuffers,
 288     __offsetof(struct bufdomain, bd_lofreebuffers), sysctl_bufdomain_int, "I",
 289    "Target number of free buffers");
 290 static int hifreebuffers;
 291 SYSCTL_PROC(_vfs, OID_AUTO, hifreebuffers,
 292     CTLTYPE_INT|CTLFLAG_MPSAFE|CTLFLAG_RW, &hifreebuffers,
 293     __offsetof(struct bufdomain, bd_hifreebuffers), sysctl_bufdomain_int, "I",
 294    "Threshold for clean buffer recycling");
 295 static counter_u64_t getnewbufcalls;
 296 SYSCTL_COUNTER_U64(_vfs, OID_AUTO, getnewbufcalls, CTLFLAG_RD,
 297    &getnewbufcalls, "Number of calls to getnewbuf");
 298 static counter_u64_t getnewbufrestarts;
 299 SYSCTL_COUNTER_U64(_vfs, OID_AUTO, getnewbufrestarts, CTLFLAG_RD,
 300     &getnewbufrestarts,
 301     "Number of times getnewbuf has had to restart a buffer acquisition");
 302 static counter_u64_t mappingrestarts;
 303 SYSCTL_COUNTER_U64(_vfs, OID_AUTO, mappingrestarts, CTLFLAG_RD,
 304     &mappingrestarts,
 305     "Number of times getblk has had to restart a buffer mapping for "
 306     "unmapped buffer");
 307 static counter_u64_t numbufallocfails;
 308 SYSCTL_COUNTER_U64(_vfs, OID_AUTO, numbufallocfails, CTLFLAG_RW,
 309     &numbufallocfails, "Number of times buffer allocations failed");
 310 static int flushbufqtarget = 100;
 311 SYSCTL_INT(_vfs, OID_AUTO, flushbufqtarget, CTLFLAG_RW, &flushbufqtarget, 0,
 312     "Amount of work to do in flushbufqueues when helping bufdaemon");
 313 static counter_u64_t notbufdflushes;
 314 SYSCTL_COUNTER_U64(_vfs, OID_AUTO, notbufdflushes, CTLFLAG_RD, &notbufdflushes,
 315     "Number of dirty buffer flushes done by the bufdaemon helpers");
 316 static long barrierwrites;
 317 SYSCTL_LONG(_vfs, OID_AUTO, barrierwrites, CTLFLAG_RW | CTLFLAG_STATS,
 318     &barrierwrites, 0, "Number of barrier writes");
 319 SYSCTL_INT(_vfs, OID_AUTO, unmapped_buf_allowed, CTLFLAG_RD,
 320     &unmapped_buf_allowed, 0,
 321     "Permit the use of the unmapped i/o");
 322 int maxbcachebuf = MAXBCACHEBUF;
 323 SYSCTL_INT(_vfs, OID_AUTO, maxbcachebuf, CTLFLAG_RDTUN, &maxbcachebuf, 0,
 324     "Maximum size of a buffer cache block");
 325
 326 /*
 327  * This lock synchronizes access to bd_request.
 328  */
 329 static struct mtx_padalign __exclusive_cache_line bdlock;
 330
 331 /*
 332  * This lock protects the runningbufreq and synchronizes runningbufwakeup and
 333  * waitrunningbufspace().
 334  */
 335 static struct mtx_padalign __exclusive_cache_line rbreqlock;
 336
 337 /*
 338  * Lock that protects bdirtywait.
 339  */
 340 static struct mtx_padalign __exclusive_cache_line bdirtylock;
 341
 342 /*
 343  * Wakeup point for bufdaemon, as well as indicator of whether it is already
 344  * active.  Set to 1 when the bufdaemon is already "on" the queue, 0 when it
 345  * is idling.
 346  */
 347 static int bd_request;
 348
 349 /*
 350  * Request for the buf daemon to write more buffers than is indicated by
 351  * lodirtybuf.  This may be necessary to push out excess dependencies or
 352  * defragment the address space where a simple count of the number of dirty
 353  * buffers is insufficient to characterize the demand for flushing them.
 354  */
 355 static int bd_speedupreq;
 356
 357 /*
 358  * Synchronization (sleep/wakeup) variable for active buffer space requests.
 359  * Set when wait starts, cleared prior to wakeup().
 360  * Used in runningbufwakeup() and waitrunningbufspace().
 361  */
 362 static int runningbufreq;
 363
 364 /*
 365  * Synchronization for bwillwrite() waiters.
 366  */
 367 static int bdirtywait;
 368
 369 /*
 370  * Definitions for the buffer free lists.
 371  */
 372 #define QUEUE_NONE      0       /* on no queue */
 373 #define QUEUE_EMPTY     1       /* empty buffer headers */
 374 #define QUEUE_DIRTY     2       /* B_DELWRI buffers */
 375 #define QUEUE_CLEAN     3       /* non-B_DELWRI buffers */
 376 #define QUEUE_SENTINEL  4       /* not an queue index, but mark for sentinel */
 377
 378 /* Maximum number of buffer domains. */
 379 #define BUF_DOMAINS     8
 380
 381 struct bufdomainset bdlodirty;          /* Domains > lodirty */
 382 struct bufdomainset bdhidirty;          /* Domains > hidirty */
 383
 384 /* Configured number of clean queues. */
 385 static int __read_mostly buf_domains;
 386
 387 BITSET_DEFINE(bufdomainset, BUF_DOMAINS);
 388 struct bufdomain __exclusive_cache_line bdomain[BUF_DOMAINS];
 389 struct bufqueue __exclusive_cache_line bqempty;
 390
 391 /*
 392  * per-cpu empty buffer cache.
 393  */
 394 uma_zone_t buf_zone;
 395
 396 /*
 397  * Single global constant for BUF_WMESG, to avoid getting multiple references.
 398  * buf_wmesg is referred from macros.
 399  */
 400 const char *buf_wmesg = BUF_WMESG;
 401
 402 static int
 403 sysctl_runningspace(SYSCTL_HANDLER_ARGS)
 404 {
 405         long value;
 406         int error;
 407
 408         value = *(long *)arg1;
 409         error = sysctl_handle_long(oidp, &value, 0, req);
 410         if (error != 0 || req->newptr == NULL)
 411                 return (error);
 412         mtx_lock(&rbreqlock);
 413         if (arg1 == &hirunningspace) {
 414                 if (value < lorunningspace)
 415                         error = EINVAL;
 416                 else
 417                         hirunningspace = value;
 418         } else {
 419                 KASSERT(arg1 == &lorunningspace,
 420                     ("%s: unknown arg1", __func__));
 421                 if (value > hirunningspace)
 422                         error = EINVAL;
 423                 else
 424                         lorunningspace = value;
 425         }
 426         mtx_unlock(&rbreqlock);
 427         return (error);
 428 }
 429
 430 static int
 431 sysctl_bufdomain_int(SYSCTL_HANDLER_ARGS)
 432 {
 433         int error;
 434         int value;
 435         int i;
 436
 437         value = *(int *)arg1;
 438         error = sysctl_handle_int(oidp, &value, 0, req);
 439         if (error != 0 || req->newptr == NULL)
 440                 return (error);
 441         *(int *)arg1 = value;
 442         for (i = 0; i < buf_domains; i++)
 443                 *(int *)(uintptr_t)(((uintptr_t)&bdomain[i]) + arg2) =
 444                     value / buf_domains;
 445
 446         return (error);
 447 }
 448
 449 static int
 450 sysctl_bufdomain_long(SYSCTL_HANDLER_ARGS)
 451 {
 452         long value;
 453         int error;
 454         int i;
 455
 456         value = *(long *)arg1;
 457         error = sysctl_handle_long(oidp, &value, 0, req);
 458         if (error != 0 || req->newptr == NULL)
 459                 return (error);
 460         *(long *)arg1 = value;
 461         for (i = 0; i < buf_domains; i++)
 462                 *(long *)(uintptr_t)(((uintptr_t)&bdomain[i]) + arg2) =
 463                     value / buf_domains;
 464
 465         return (error);
 466 }
 467
 468 #if defined(COMPAT_FREEBSD4) || defined(COMPAT_FREEBSD5) || \
 469     defined(COMPAT_FREEBSD6) || defined(COMPAT_FREEBSD7)
 470 static int
 471 sysctl_bufspace(SYSCTL_HANDLER_ARGS)
 472 {
 473         long lvalue;
 474         int ivalue;
 475         int i;
 476
 477         lvalue = 0;
 478         for (i = 0; i < buf_domains; i++)
 479                 lvalue += bdomain[i].bd_bufspace;
 480         if (sizeof(int) == sizeof(long) || req->oldlen >= sizeof(long))
 481                 return (sysctl_handle_long(oidp, &lvalue, 0, req));
 482         if (lvalue > INT_MAX)
 483                 /* On overflow, still write out a long to trigger ENOMEM. */
 484                 return (sysctl_handle_long(oidp, &lvalue, 0, req));
 485         ivalue = lvalue;
 486         return (sysctl_handle_int(oidp, &ivalue, 0, req));
 487 }
 488 #else
 489 static int
 490 sysctl_bufspace(SYSCTL_HANDLER_ARGS)
 491 {
 492         long lvalue;
 493         int i;
 494
 495         lvalue = 0;
 496         for (i = 0; i < buf_domains; i++)
 497                 lvalue += bdomain[i].bd_bufspace;
 498         return (sysctl_handle_long(oidp, &lvalue, 0, req));
 499 }
 500 #endif
 501
 502 static int
 503 sysctl_numdirtybuffers(SYSCTL_HANDLER_ARGS)
 504 {
 505         int value;
 506         int i;
 507
 508         value = 0;
 509         for (i = 0; i < buf_domains; i++)
 510                 value += bdomain[i].bd_numdirtybuffers;
 511         return (sysctl_handle_int(oidp, &value, 0, req));
 512 }
 513
 514 /*
 515  *      bdirtywakeup:
 516  *
 517  *      Wakeup any bwillwrite() waiters.
 518  */
 519 static void
 520 bdirtywakeup(void)
 521 {
 522         mtx_lock(&bdirtylock);
 523         if (bdirtywait) {
 524                 bdirtywait = 0;
 525                 wakeup(&bdirtywait);
 526         }
 527         mtx_unlock(&bdirtylock);
 528 }
 529
 530 /*
 531  *      bd_clear:
 532  *
 533  *      Clear a domain from the appropriate bitsets when dirtybuffers
 534  *      is decremented.
 535  */
 536 static void
 537 bd_clear(struct bufdomain *bd)
 538 {
 539
 540         mtx_lock(&bdirtylock);
 541         if (bd->bd_numdirtybuffers <= bd->bd_lodirtybuffers)
 542                 BIT_CLR(BUF_DOMAINS, BD_DOMAIN(bd), &bdlodirty);
 543         if (bd->bd_numdirtybuffers <= bd->bd_hidirtybuffers)
 544                 BIT_CLR(BUF_DOMAINS, BD_DOMAIN(bd), &bdhidirty);
 545         mtx_unlock(&bdirtylock);
 546 }
 547
 548 /*
 549  *      bd_set:
 550  *
 551  *      Set a domain in the appropriate bitsets when dirtybuffers
 552  *      is incremented.
 553  */
 554 static void
 555 bd_set(struct bufdomain *bd)
 556 {
 557
 558         mtx_lock(&bdirtylock);
 559         if (bd->bd_numdirtybuffers > bd->bd_lodirtybuffers)
 560                 BIT_SET(BUF_DOMAINS, BD_DOMAIN(bd), &bdlodirty);
 561         if (bd->bd_numdirtybuffers > bd->bd_hidirtybuffers)
 562                 BIT_SET(BUF_DOMAINS, BD_DOMAIN(bd), &bdhidirty);
 563         mtx_unlock(&bdirtylock);
 564 }
 565
 566 /*
 567  *      bdirtysub:
 568  *
 569  *      Decrement the numdirtybuffers count by one and wakeup any
 570  *      threads blocked in bwillwrite().
 571  */
 572 static void
 573 bdirtysub(struct buf *bp)
 574 {
 575         struct bufdomain *bd;
 576         int num;
 577
 578         bd = bufdomain(bp);
 579         num = atomic_fetchadd_int(&bd->bd_numdirtybuffers, -1);
 580         if (num == (bd->bd_lodirtybuffers + bd->bd_hidirtybuffers) / 2)
 581                 bdirtywakeup();
 582         if (num == bd->bd_lodirtybuffers || num == bd->bd_hidirtybuffers)
 583                 bd_clear(bd);
 584 }
 585
 586 /*
 587  *      bdirtyadd:
 588  *
 589  *      Increment the numdirtybuffers count by one and wakeup the buf
 590  *      daemon if needed.
 591  */
 592 static void
 593 bdirtyadd(struct buf *bp)
 594 {
 595         struct bufdomain *bd;
 596         int num;
 597
 598         /*
 599          * Only do the wakeup once as we cross the boundary.  The
 600          * buf daemon will keep running until the condition clears.
 601          */
 602         bd = bufdomain(bp);
 603         num = atomic_fetchadd_int(&bd->bd_numdirtybuffers, 1);
 604         if (num == (bd->bd_lodirtybuffers + bd->bd_hidirtybuffers) / 2)
 605                 bd_wakeup();
 606         if (num == bd->bd_lodirtybuffers || num == bd->bd_hidirtybuffers)
 607                 bd_set(bd);
 608 }
 609
 610 /*
 611  *      bufspace_daemon_wakeup:
 612  *
 613  *      Wakeup the daemons responsible for freeing clean bufs.
 614  */
 615 static void
 616 bufspace_daemon_wakeup(struct bufdomain *bd)
 617 {
 618
 619         /*
 620          * avoid the lock if the daemon is running.
 621          */
 622         if (atomic_fetchadd_int(&bd->bd_running, 1) == 0) {
 623                 BD_RUN_LOCK(bd);
 624                 atomic_store_int(&bd->bd_running, 1);
 625                 wakeup(&bd->bd_running);
 626                 BD_RUN_UNLOCK(bd);
 627         }
 628 }
 629
 630 /*
 631  *      bufspace_daemon_wait:
 632  *
 633  *      Sleep until the domain falls below a limit or one second passes.
 634  */
 635 static void
 636 bufspace_daemon_wait(struct bufdomain *bd)
 637 {
 638         /*
 639          * Re-check our limits and sleep.  bd_running must be
 640          * cleared prior to checking the limits to avoid missed
 641          * wakeups.  The waker will adjust one of bufspace or
 642          * freebuffers prior to checking bd_running.
 643          */
 644         BD_RUN_LOCK(bd);
 645         atomic_store_int(&bd->bd_running, 0);
 646         if (bd->bd_bufspace < bd->bd_bufspacethresh &&
 647             bd->bd_freebuffers > bd->bd_lofreebuffers) {
 648                 msleep(&bd->bd_running, BD_RUN_LOCKPTR(bd), PRIBIO|PDROP,
 649                     "-", hz);
 650         } else {
 651                 /* Avoid spurious wakeups while running. */
 652                 atomic_store_int(&bd->bd_running, 1);
 653                 BD_RUN_UNLOCK(bd);
 654         }
 655 }
 656
 657 /*
 658  *      bufspace_adjust:
 659  *
 660  *      Adjust the reported bufspace for a KVA managed buffer, possibly
 661  *      waking any waiters.
 662  */
 663 static void
 664 bufspace_adjust(struct buf *bp, int bufsize)
 665 {
 666         struct bufdomain *bd;
 667         long space;
 668         int diff;
 669
 670         KASSERT((bp->b_flags & B_MALLOC) == 0,
 671             ("bufspace_adjust: malloc buf %p", bp));
 672         bd = bufdomain(bp);
 673         diff = bufsize - bp->b_bufsize;
 674         if (diff < 0) {
 675                 atomic_subtract_long(&bd->bd_bufspace, -diff);
 676         } else if (diff > 0) {
 677                 space = atomic_fetchadd_long(&bd->bd_bufspace, diff);
 678                 /* Wake up the daemon on the transition. */
 679                 if (space < bd->bd_bufspacethresh &&
 680                     space + diff >= bd->bd_bufspacethresh)
 681                         bufspace_daemon_wakeup(bd);
 682         }
 683         bp->b_bufsize = bufsize;
 684 }
 685
 686 /*
 687  *      bufspace_reserve:
 688  *
 689  *      Reserve bufspace before calling allocbuf().  metadata has a
 690  *      different space limit than data.
 691  */
 692 static int
 693 bufspace_reserve(struct bufdomain *bd, int size, bool metadata)
 694 {
 695         long limit, new;
 696         long space;
 697
 698         if (metadata)
 699                 limit = bd->bd_maxbufspace;
 700         else
 701                 limit = bd->bd_hibufspace;
 702         space = atomic_fetchadd_long(&bd->bd_bufspace, size);
 703         new = space + size;
 704         if (new > limit) {
 705                 atomic_subtract_long(&bd->bd_bufspace, size);
 706                 return (ENOSPC);
 707         }
 708
 709         /* Wake up the daemon on the transition. */
 710         if (space < bd->bd_bufspacethresh && new >= bd->bd_bufspacethresh)
 711                 bufspace_daemon_wakeup(bd);
 712
 713         return (0);
 714 }
 715
 716 /*
 717  *      bufspace_release:
 718  *
 719  *      Release reserved bufspace after bufspace_adjust() has consumed it.
 720  */
 721 static void
 722 bufspace_release(struct bufdomain *bd, int size)
 723 {
 724
 725         atomic_subtract_long(&bd->bd_bufspace, size);
 726 }
 727
 728 /*
 729  *      bufspace_wait:
 730  *
 731  *      Wait for bufspace, acting as the buf daemon if a locked vnode is
 732  *      supplied.  bd_wanted must be set prior to polling for space.  The
 733  *      operation must be re-tried on return.
 734  */
 735 static void
 736 bufspace_wait(struct bufdomain *bd, struct vnode *vp, int gbflags,
 737     int slpflag, int slptimeo)
 738 {
 739         struct thread *td;
 740         int error, fl, norunbuf;
 741
 742         if ((gbflags & GB_NOWAIT_BD) != 0)
 743                 return;
 744
 745         td = curthread;
 746         BD_LOCK(bd);
 747         while (bd->bd_wanted) {
 748                 if (vp != NULL && vp->v_type != VCHR &&
 749                     (td->td_pflags & TDP_BUFNEED) == 0) {
 750                         BD_UNLOCK(bd);
 751                         /*
 752                          * getblk() is called with a vnode locked, and
 753                          * some majority of the dirty buffers may as
 754                          * well belong to the vnode.  Flushing the
 755                          * buffers there would make a progress that
 756                          * cannot be achieved by the buf_daemon, that
 757                          * cannot lock the vnode.
 758                          */
 759                         norunbuf = ~(TDP_BUFNEED | TDP_NORUNNINGBUF) |
 760                             (td->td_pflags & TDP_NORUNNINGBUF);
 761
 762                         /*
 763                          * Play bufdaemon.  The getnewbuf() function
 764                          * may be called while the thread owns lock
 765                          * for another dirty buffer for the same
 766                          * vnode, which makes it impossible to use
 767                          * VOP_FSYNC() there, due to the buffer lock
 768                          * recursion.
 769                          */
 770                         td->td_pflags |= TDP_BUFNEED | TDP_NORUNNINGBUF;
 771                         fl = buf_flush(vp, bd, flushbufqtarget);
 772                         td->td_pflags &= norunbuf;
 773                         BD_LOCK(bd);
 774                         if (fl != 0)
 775                                 continue;
 776                         if (bd->bd_wanted == 0)
 777                                 break;
 778                 }
 779                 error = msleep(&bd->bd_wanted, BD_LOCKPTR(bd),
 780                     (PRIBIO + 4) | slpflag, "newbuf", slptimeo);
 781                 if (error != 0)
 782                         break;
 783         }
 784         BD_UNLOCK(bd);
 785 }
 786
 787 /*
 788  *      bufspace_daemon:
 789  *
 790  *      buffer space management daemon.  Tries to maintain some marginal
 791  *      amount of free buffer space so that requesting processes neither
 792  *      block nor work to reclaim buffers.
 793  */
 794 static void
 795 bufspace_daemon(void *arg)
 796 {
 797         struct bufdomain *bd;
 798
 799         EVENTHANDLER_REGISTER(shutdown_pre_sync, kthread_shutdown, curthread,
 800             SHUTDOWN_PRI_LAST + 100);
 801
 802         bd = arg;
 803         for (;;) {
 804                 kthread_suspend_check();
 805
 806                 /*
 807                  * Free buffers from the clean queue until we meet our
 808                  * targets.
 809                  *
 810                  * Theory of operation:  The buffer cache is most efficient
 811                  * when some free buffer headers and space are always
 812                  * available to getnewbuf().  This daemon attempts to prevent
 813                  * the excessive blocking and synchronization associated
 814                  * with shortfall.  It goes through three phases according
 815                  * demand:
 816                  *
 817                  * 1)   The daemon wakes up voluntarily once per-second
 818                  *      during idle periods when the counters are below
 819                  *      the wakeup thresholds (bufspacethresh, lofreebuffers).
 820                  *
 821                  * 2)   The daemon wakes up as we cross the thresholds
 822                  *      ahead of any potential blocking.  This may bounce
 823                  *      slightly according to the rate of consumption and
 824                  *      release.
 825                  *
 826                  * 3)   The daemon and consumers are starved for working
 827                  *      clean buffers.  This is the 'bufspace' sleep below
 828                  *      which will inefficiently trade bufs with bqrelse
 829                  *      until we return to condition 2.
 830                  */
 831                 while (bd->bd_bufspace > bd->bd_lobufspace ||
 832                     bd->bd_freebuffers < bd->bd_hifreebuffers) {
 833                         if (buf_recycle(bd, false) != 0) {
 834                                 if (bd_flushall(bd))
 835                                         continue;
 836                                 /*
 837                                  * Speedup dirty if we've run out of clean
 838                                  * buffers.  This is possible in particular
 839                                  * because softdep may held many bufs locked
 840                                  * pending writes to other bufs which are
 841                                  * marked for delayed write, exhausting
 842                                  * clean space until they are written.
 843                                  */
 844                                 bd_speedup();
 845                                 BD_LOCK(bd);
 846                                 if (bd->bd_wanted) {
 847                                         msleep(&bd->bd_wanted, BD_LOCKPTR(bd),
 848                                             PRIBIO|PDROP, "bufspace", hz/10);
 849                                 } else
 850                                         BD_UNLOCK(bd);
 851                         }
 852                         maybe_yield();
 853                 }
 854                 bufspace_daemon_wait(bd);
 855         }
 856 }
 857
 858 /*
 859  *      bufmallocadjust:
 860  *
 861  *      Adjust the reported bufspace for a malloc managed buffer, possibly
 862  *      waking any waiters.
 863  */
 864 static void
 865 bufmallocadjust(struct buf *bp, int bufsize)
 866 {
 867         int diff;
 868
 869         KASSERT((bp->b_flags & B_MALLOC) != 0,
 870             ("bufmallocadjust: non-malloc buf %p", bp));
 871         diff = bufsize - bp->b_bufsize;
 872         if (diff < 0)
 873                 atomic_subtract_long(&bufmallocspace, -diff);
 874         else
 875                 atomic_add_long(&bufmallocspace, diff);
 876         bp->b_bufsize = bufsize;
 877 }
 878
 879 /*
 880  *      runningwakeup:
 881  *
 882  *      Wake up processes that are waiting on asynchronous writes to fall
 883  *      below lorunningspace.
 884  */
 885 static void
 886 runningwakeup(void)
 887 {
 888
 889         mtx_lock(&rbreqlock);
 890         if (runningbufreq) {
 891                 runningbufreq = 0;
 892                 wakeup(&runningbufreq);
 893         }
 894         mtx_unlock(&rbreqlock);
 895 }
 896
 897 /*
 898  *      runningbufwakeup:
 899  *
 900  *      Decrement the outstanding write count according.
 901  */
 902 void
 903 runningbufwakeup(struct buf *bp)
 904 {
 905         long space, bspace;
 906
 907         bspace = bp->b_runningbufspace;
 908         if (bspace == 0)
 909                 return;
 910         space = atomic_fetchadd_long(&runningbufspace, -bspace);
 911         KASSERT(space >= bspace, ("runningbufspace underflow %ld %ld",
 912             space, bspace));
 913         bp->b_runningbufspace = 0;
 914         /*
 915          * Only acquire the lock and wakeup on the transition from exceeding
 916          * the threshold to falling below it.
 917          */
 918         if (space < lorunningspace)
 919                 return;
 920         if (space - bspace > lorunningspace)
 921                 return;
 922         runningwakeup();
 923 }
 924
 925 /*
 926  *      waitrunningbufspace()
 927  *
 928  *      runningbufspace is a measure of the amount of I/O currently
 929  *      running.  This routine is used in async-write situations to
 930  *      prevent creating huge backups of pending writes to a device.
 931  *      Only asynchronous writes are governed by this function.
 932  *
 933  *      This does NOT turn an async write into a sync write.  It waits
 934  *      for earlier writes to complete and generally returns before the
 935  *      caller's write has reached the device.
 936  */
 937 void
 938 waitrunningbufspace(void)
 939 {
 940
 941         mtx_lock(&rbreqlock);
 942         while (runningbufspace > hirunningspace) {
 943                 runningbufreq = 1;
 944                 msleep(&runningbufreq, &rbreqlock, PVM, "wdrain", 0);
 945         }
 946         mtx_unlock(&rbreqlock);
 947 }
 948
 949 /*
 950  *      vfs_buf_test_cache:
 951  *
 952  *      Called when a buffer is extended.  This function clears the B_CACHE
 953  *      bit if the newly extended portion of the buffer does not contain
 954  *      valid data.
 955  */
 956 static __inline void
 957 vfs_buf_test_cache(struct buf *bp, vm_ooffset_t foff, vm_offset_t off,
 958     vm_offset_t size, vm_page_t m)
 959 {
 960
 961         /*
 962          * This function and its results are protected by higher level
 963          * synchronization requiring vnode and buf locks to page in and
 964          * validate pages.
 965          */
 966         if (bp->b_flags & B_CACHE) {
 967                 int base = (foff + off) & PAGE_MASK;
 968                 if (vm_page_is_valid(m, base, size) == 0)
 969                         bp->b_flags &= ~B_CACHE;
 970         }
 971 }
 972
 973 /* Wake up the buffer daemon if necessary */
 974 static void
 975 bd_wakeup(void)
 976 {
 977
 978         mtx_lock(&bdlock);
 979         if (bd_request == 0) {
 980                 bd_request = 1;
 981                 wakeup(&bd_request);
 982         }
 983         mtx_unlock(&bdlock);
 984 }
 985
 986 /*
 987  * Adjust the maxbcachbuf tunable.
 988  */
 989 static void
 990 maxbcachebuf_adjust(void)
 991 {
 992         int i;
 993
 994         /*
 995          * maxbcachebuf must be a power of 2 >= MAXBSIZE.
 996          */
 997         i = 2;
 998         while (i * 2 <= maxbcachebuf)
 999                 i *= 2;
1000         maxbcachebuf = i;
1001         if (maxbcachebuf < MAXBSIZE)
1002                 maxbcachebuf = MAXBSIZE;
1003         if (maxbcachebuf > maxphys)
1004                 maxbcachebuf = maxphys;
1005         if (bootverbose != 0 && maxbcachebuf != MAXBCACHEBUF)
1006                 printf("maxbcachebuf=%d\n", maxbcachebuf);
1007 }
1008
1009 /*
1010  * bd_speedup - speedup the buffer cache flushing code
1011  */
1012 void
1013 bd_speedup(void)
1014 {
1015         int needwake;
1016
1017         mtx_lock(&bdlock);
1018         needwake = 0;
1019         if (bd_speedupreq == 0 || bd_request == 0)
1020                 needwake = 1;
1021         bd_speedupreq = 1;
1022         bd_request = 1;
1023         if (needwake)
1024                 wakeup(&bd_request);
1025         mtx_unlock(&bdlock);
1026 }
1027
1028 #ifdef __i386__
1029 #define TRANSIENT_DENOM 5
1030 #else
1031 #define TRANSIENT_DENOM 10
1032 #endif
1033
1034 /*
1035  * Calculating buffer cache scaling values and reserve space for buffer
1036  * headers.  This is called during low level kernel initialization and
1037  * may be called more then once.  We CANNOT write to the memory area
1038  * being reserved at this time.
1039  */
1040 caddr_t
1041 kern_vfs_bio_buffer_alloc(caddr_t v, long physmem_est)
1042 {
1043         int tuned_nbuf;
1044         long maxbuf, maxbuf_sz, buf_sz, biotmap_sz;
1045
1046         /*
1047          * physmem_est is in pages.  Convert it to kilobytes (assumes
1048          * PAGE_SIZE is >= 1K)
1049          */
1050         physmem_est = physmem_est * (PAGE_SIZE / 1024);
1051
1052         maxbcachebuf_adjust();
1053         /*
1054          * The nominal buffer size (and minimum KVA allocation) is BKVASIZE.
1055          * For the first 64MB of ram nominally allocate sufficient buffers to
1056          * cover 1/4 of our ram.  Beyond the first 64MB allocate additional
1057          * buffers to cover 1/10 of our ram over 64MB.  When auto-sizing
1058          * the buffer cache we limit the eventual kva reservation to
1059          * maxbcache bytes.
1060          *
1061          * factor represents the 1/4 x ram conversion.
1062          */
1063         if (nbuf == 0) {
1064                 int factor = 4 * BKVASIZE / 1024;
1065
1066                 nbuf = 50;
1067                 if (physmem_est > 4096)
1068                         nbuf += min((physmem_est - 4096) / factor,
1069                             65536 / factor);
1070                 if (physmem_est > 65536)
1071                         nbuf += min((physmem_est - 65536) * 2 / (factor * 5),
1072                             32 * 1024 * 1024 / (factor * 5));
1073
1074                 if (maxbcache && nbuf > maxbcache / BKVASIZE)
1075                         nbuf = maxbcache / BKVASIZE;
1076                 tuned_nbuf = 1;
1077         } else
1078                 tuned_nbuf = 0;
1079
1080         /* XXX Avoid unsigned long overflows later on with maxbufspace. */
1081         maxbuf = (LONG_MAX / 3) / BKVASIZE;
1082         if (nbuf > maxbuf) {
1083                 if (!tuned_nbuf)
1084                         printf("Warning: nbufs lowered from %d to %ld\n", nbuf,
1085                             maxbuf);
1086                 nbuf = maxbuf;
1087         }
1088
1089         /*
1090          * Ideal allocation size for the transient bio submap is 10%
1091          * of the maximal space buffer map.  This roughly corresponds
1092          * to the amount of the buffer mapped for typical UFS load.
1093          *
1094          * Clip the buffer map to reserve space for the transient
1095          * BIOs, if its extent is bigger than 90% (80% on i386) of the
1096          * maximum buffer map extent on the platform.
1097          *
1098          * The fall-back to the maxbuf in case of maxbcache unset,
1099          * allows to not trim the buffer KVA for the architectures
1100          * with ample KVA space.
1101          */
1102         if (bio_transient_maxcnt == 0 && unmapped_buf_allowed) {
1103                 maxbuf_sz = maxbcache != 0 ? maxbcache : maxbuf * BKVASIZE;
1104                 buf_sz = (long)nbuf * BKVASIZE;
1105                 if (buf_sz < maxbuf_sz / TRANSIENT_DENOM *
1106                     (TRANSIENT_DENOM - 1)) {
1107                         /*
1108                          * There is more KVA than memory.  Do not
1109                          * adjust buffer map size, and assign the rest
1110                          * of maxbuf to transient map.
1111                          */
1112                         biotmap_sz = maxbuf_sz - buf_sz;
1113                 } else {
1114                         /*
1115                          * Buffer map spans all KVA we could afford on
1116                          * this platform.  Give 10% (20% on i386) of
1117                          * the buffer map to the transient bio map.
1118                          */
1119                         biotmap_sz = buf_sz / TRANSIENT_DENOM;
1120                         buf_sz -= biotmap_sz;
1121                 }
1122                 if (biotmap_sz / INT_MAX > maxphys)
1123                         bio_transient_maxcnt = INT_MAX;
1124                 else
1125                         bio_transient_maxcnt = biotmap_sz / maxphys;
1126                 /*
1127                  * Artificially limit to 1024 simultaneous in-flight I/Os
1128                  * using the transient mapping.
1129                  */
1130                 if (bio_transient_maxcnt > 1024)
1131                         bio_transient_maxcnt = 1024;
1132                 if (tuned_nbuf)
1133                         nbuf = buf_sz / BKVASIZE;
1134         }
1135
1136         if (nswbuf == 0) {
1137                 nswbuf = min(nbuf / 4, 256);
1138                 if (nswbuf < NSWBUF_MIN)
1139                         nswbuf = NSWBUF_MIN;
1140         }
1141
1142         /*
1143          * Reserve space for the buffer cache buffers
1144          */
1145         buf = (char *)v;
1146         v = (caddr_t)buf + (sizeof(struct buf) + sizeof(vm_page_t) *
1147             atop(maxbcachebuf)) * nbuf;
1148
1149         return (v);
1150 }
1151
1152 /* Initialize the buffer subsystem.  Called before use of any buffers. */
1153 void
1154 bufinit(void)
1155 {
1156         struct buf *bp;
1157         int i;
1158
1159         KASSERT(maxbcachebuf >= MAXBSIZE,
1160             ("maxbcachebuf (%d) must be >= MAXBSIZE (%d)\n", maxbcachebuf,
1161             MAXBSIZE));
1162         bq_init(&bqempty, QUEUE_EMPTY, -1, "bufq empty lock");
1163         mtx_init(&rbreqlock, "runningbufspace lock", NULL, MTX_DEF);
1164         mtx_init(&bdlock, "buffer daemon lock", NULL, MTX_DEF);
1165         mtx_init(&bdirtylock, "dirty buf lock", NULL, MTX_DEF);
1166
1167         unmapped_buf = (caddr_t)kva_alloc(maxphys);
1168
1169         /* finally, initialize each buffer header and stick on empty q */
1170         for (i = 0; i < nbuf; i++) {
1171                 bp = nbufp(i);
1172                 bzero(bp, sizeof(*bp) + sizeof(vm_page_t) * atop(maxbcachebuf));
1173                 bp->b_flags = B_INVAL;
1174                 bp->b_rcred = NOCRED;
1175                 bp->b_wcred = NOCRED;
1176                 bp->b_qindex = QUEUE_NONE;
1177                 bp->b_domain = -1;
1178                 bp->b_subqueue = mp_maxid + 1;
1179                 bp->b_xflags = 0;
1180                 bp->b_data = bp->b_kvabase = unmapped_buf;
1181                 LIST_INIT(&bp->b_dep);
1182                 BUF_LOCKINIT(bp);
1183                 bq_insert(&bqempty, bp, false);
1184         }
1185
1186         /*
1187          * maxbufspace is the absolute maximum amount of buffer space we are
1188          * allowed to reserve in KVM and in real terms.  The absolute maximum
1189          * is nominally used by metadata.  hibufspace is the nominal maximum
1190          * used by most other requests.  The differential is required to
1191          * ensure that metadata deadlocks don't occur.
1192          *
1193          * maxbufspace is based on BKVASIZE.  Allocating buffers larger then
1194          * this may result in KVM fragmentation which is not handled optimally
1195          * by the system. XXX This is less true with vmem.  We could use
1196          * PAGE_SIZE.
1197          */
1198         maxbufspace = (long)nbuf * BKVASIZE;
1199         hibufspace = lmax(3 * maxbufspace / 4, maxbufspace - maxbcachebuf * 10);
1200         lobufspace = (hibufspace / 20) * 19; /* 95% */
1201         bufspacethresh = lobufspace + (hibufspace - lobufspace) / 2;
1202
1203         /*
1204          * Note: The 16 MiB upper limit for hirunningspace was chosen
1205          * arbitrarily and may need further tuning. It corresponds to
1206          * 128 outstanding write IO requests (if IO size is 128 KiB),
1207          * which fits with many RAID controllers' tagged queuing limits.
1208          * The lower 1 MiB limit is the historical upper limit for
1209          * hirunningspace.
1210          */
1211         hirunningspace = lmax(lmin(roundup(hibufspace / 64, maxbcachebuf),
1212             16 * 1024 * 1024), 1024 * 1024);
1213         lorunningspace = roundup((hirunningspace * 2) / 3, maxbcachebuf);
1214
1215         /*
1216          * Limit the amount of malloc memory since it is wired permanently into
1217          * the kernel space.  Even though this is accounted for in the buffer
1218          * allocation, we don't want the malloced region to grow uncontrolled.
1219          * The malloc scheme improves memory utilization significantly on
1220          * average (small) directories.
1221          */
1222         maxbufmallocspace = hibufspace / 20;
1223
1224         /*
1225          * Reduce the chance of a deadlock occurring by limiting the number
1226          * of delayed-write dirty buffers we allow to stack up.
1227          */
1228         hidirtybuffers = nbuf / 4 + 20;
1229         dirtybufthresh = hidirtybuffers * 9 / 10;
1230         /*
1231          * To support extreme low-memory systems, make sure hidirtybuffers
1232          * cannot eat up all available buffer space.  This occurs when our
1233          * minimum cannot be met.  We try to size hidirtybuffers to 3/4 our
1234          * buffer space assuming BKVASIZE'd buffers.
1235          */
1236         while ((long)hidirtybuffers * BKVASIZE > 3 * hibufspace / 4) {
1237                 hidirtybuffers >>= 1;
1238         }
1239         lodirtybuffers = hidirtybuffers / 2;
1240
1241         /*
1242          * lofreebuffers should be sufficient to avoid stalling waiting on
1243          * buf headers under heavy utilization.  The bufs in per-cpu caches
1244          * are counted as free but will be unavailable to threads executing
1245          * on other cpus.
1246          *
1247          * hifreebuffers is the free target for the bufspace daemon.  This
1248          * should be set appropriately to limit work per-iteration.
1249          */
1250         lofreebuffers = MIN((nbuf / 25) + (20 * mp_ncpus), 128 * mp_ncpus);
1251         hifreebuffers = (3 * lofreebuffers) / 2;
1252         numfreebuffers = nbuf;
1253
1254         /* Setup the kva and free list allocators. */
1255         vmem_set_reclaim(buffer_arena, bufkva_reclaim);
1256         buf_zone = uma_zcache_create("buf free cache",
1257             sizeof(struct buf) + sizeof(vm_page_t) * atop(maxbcachebuf),
1258             NULL, NULL, NULL, NULL, buf_import, buf_release, NULL, 0);
1259
1260         /*
1261          * Size the clean queue according to the amount of buffer space.
1262          * One queue per-256mb up to the max.  More queues gives better
1263          * concurrency but less accurate LRU.
1264          */
1265         buf_domains = MIN(howmany(maxbufspace, 256*1024*1024), BUF_DOMAINS);
1266         for (i = 0 ; i < buf_domains; i++) {
1267                 struct bufdomain *bd;
1268
1269                 bd = &bdomain[i];
1270                 bd_init(bd);
1271                 bd->bd_freebuffers = nbuf / buf_domains;
1272                 bd->bd_hifreebuffers = hifreebuffers / buf_domains;
1273                 bd->bd_lofreebuffers = lofreebuffers / buf_domains;
1274                 bd->bd_bufspace = 0;
1275                 bd->bd_maxbufspace = maxbufspace / buf_domains;
1276                 bd->bd_hibufspace = hibufspace / buf_domains;
1277                 bd->bd_lobufspace = lobufspace / buf_domains;
1278                 bd->bd_bufspacethresh = bufspacethresh / buf_domains;
1279                 bd->bd_numdirtybuffers = 0;
1280                 bd->bd_hidirtybuffers = hidirtybuffers / buf_domains;
1281                 bd->bd_lodirtybuffers = lodirtybuffers / buf_domains;
1282                 bd->bd_dirtybufthresh = dirtybufthresh / buf_domains;
1283                 /* Don't allow more than 2% of bufs in the per-cpu caches. */
1284                 bd->bd_lim = nbuf / buf_domains / 50 / mp_ncpus;
1285         }
1286         getnewbufcalls = counter_u64_alloc(M_WAITOK);
1287         getnewbufrestarts = counter_u64_alloc(M_WAITOK);
1288         mappingrestarts = counter_u64_alloc(M_WAITOK);
1289         numbufallocfails = counter_u64_alloc(M_WAITOK);
1290         notbufdflushes = counter_u64_alloc(M_WAITOK);
1291         buffreekvacnt = counter_u64_alloc(M_WAITOK);
1292         bufdefragcnt = counter_u64_alloc(M_WAITOK);
1293         bufkvaspace = counter_u64_alloc(M_WAITOK);
1294 }
1295
1296 #ifdef INVARIANTS
1297 static inline void
1298 vfs_buf_check_mapped(struct buf *bp)
1299 {
1300
1301         KASSERT(bp->b_kvabase != unmapped_buf,
1302             ("mapped buf: b_kvabase was not updated %p", bp));
1303         KASSERT(bp->b_data != unmapped_buf,
1304             ("mapped buf: b_data was not updated %p", bp));
1305         KASSERT(bp->b_data < unmapped_buf || bp->b_data >= unmapped_buf +
1306             maxphys, ("b_data + b_offset unmapped %p", bp));
1307 }
1308
1309 static inline void
1310 vfs_buf_check_unmapped(struct buf *bp)
1311 {
1312
1313         KASSERT(bp->b_data == unmapped_buf,
1314             ("unmapped buf: corrupted b_data %p", bp));
1315 }
1316
1317 #define BUF_CHECK_MAPPED(bp) vfs_buf_check_mapped(bp)
1318 #define BUF_CHECK_UNMAPPED(bp) vfs_buf_check_unmapped(bp)
1319 #else
1320 #define BUF_CHECK_MAPPED(bp) do {} while (0)
1321 #define BUF_CHECK_UNMAPPED(bp) do {} while (0)
1322 #endif
1323
1324 static int
1325 isbufbusy(struct buf *bp)
1326 {
1327         if (((bp->b_flags & B_INVAL) == 0 && BUF_ISLOCKED(bp)) ||
1328             ((bp->b_flags & (B_DELWRI | B_INVAL)) == B_DELWRI))
1329                 return (1);
1330         return (0);
1331 }
1332
1333 /*
1334  * Shutdown the system cleanly to prepare for reboot, halt, or power off.
1335  */
1336 void
1337 bufshutdown(int show_busybufs)
1338 {
1339         static int first_buf_printf = 1;
1340         struct buf *bp;
1341         int i, iter, nbusy, pbusy;
1342 #ifndef PREEMPTION
1343         int subiter;
1344 #endif
1345
1346         /*
1347          * Sync filesystems for shutdown
1348          */
1349         wdog_kern_pat(WD_LASTVAL);
1350         kern_sync(curthread);
1351
1352         /*
1353          * With soft updates, some buffers that are
1354          * written will be remarked as dirty until other
1355          * buffers are written.
1356          */
1357         for (iter = pbusy = 0; iter < 20; iter++) {
1358                 nbusy = 0;
1359                 for (i = nbuf - 1; i >= 0; i--) {
1360                         bp = nbufp(i);
1361                         if (isbufbusy(bp))
1362                                 nbusy++;
1363                 }
1364                 if (nbusy == 0) {
1365                         if (first_buf_printf)
1366                                 printf("All buffers synced.");
1367                         break;
1368                 }
1369                 if (first_buf_printf) {
1370                         printf("Syncing disks, buffers remaining... ");
1371                         first_buf_printf = 0;
1372                 }
1373                 printf("%d ", nbusy);
1374                 if (nbusy < pbusy)
1375                         iter = 0;
1376                 pbusy = nbusy;
1377
1378                 wdog_kern_pat(WD_LASTVAL);
1379                 kern_sync(curthread);
1380
1381 #ifdef PREEMPTION
1382                 /*
1383                  * Spin for a while to allow interrupt threads to run.
1384                  */
1385                 DELAY(50000 * iter);
1386 #else
1387                 /*
1388                  * Context switch several times to allow interrupt
1389                  * threads to run.
1390                  */
1391                 for (subiter = 0; subiter < 50 * iter; subiter++) {
1392                         thread_lock(curthread);
1393                         mi_switch(SW_VOL);
1394                         DELAY(1000);
1395                 }
1396 #endif
1397         }
1398         printf("\n");
1399         /*
1400          * Count only busy local buffers to prevent forcing
1401          * a fsck if we're just a client of a wedged NFS server
1402          */
1403         nbusy = 0;
1404         for (i = nbuf - 1; i >= 0; i--) {
1405                 bp = nbufp(i);
1406                 if (isbufbusy(bp)) {
1407 #if 0
1408 /* XXX: This is bogus.  We should probably have a BO_REMOTE flag instead */
1409                         if (bp->b_dev == NULL) {
1410                                 TAILQ_REMOVE(&mountlist,
1411                                     bp->b_vp->v_mount, mnt_list);
1412                                 continue;
1413                         }
1414 #endif
1415                         nbusy++;
1416                         if (show_busybufs > 0) {
1417                                 printf(
1418             "%d: buf:%p, vnode:%p, flags:%0x, blkno:%jd, lblkno:%jd, buflock:",
1419                                     nbusy, bp, bp->b_vp, bp->b_flags,
1420                                     (intmax_t)bp->b_blkno,
1421                                     (intmax_t)bp->b_lblkno);
1422                                 BUF_LOCKPRINTINFO(bp);
1423                                 if (show_busybufs > 1)
1424                                         vn_printf(bp->b_vp,
1425                                             "vnode content: ");
1426                         }
1427                 }
1428         }
1429         if (nbusy) {
1430                 /*
1431                  * Failed to sync all blocks. Indicate this and don't
1432                  * unmount filesystems (thus forcing an fsck on reboot).
1433                  */
1434                 printf("Giving up on %d buffers\n", nbusy);
1435                 DELAY(5000000); /* 5 seconds */
1436         } else {
1437                 if (!first_buf_printf)
1438                         printf("Final sync complete\n");
1439                 /*
1440                  * Unmount filesystems
1441                  */
1442                 if (!KERNEL_PANICKED())
1443                         vfs_unmountall();
1444         }
1445         swapoff_all();
1446         DELAY(100000);          /* wait for console output to finish */
1447 }
1448
1449 static void
1450 bpmap_qenter(struct buf *bp)
1451 {
1452
1453         BUF_CHECK_MAPPED(bp);
1454
1455         /*
1456          * bp->b_data is relative to bp->b_offset, but
1457          * bp->b_offset may be offset into the first page.
1458          */
1459         bp->b_data = (caddr_t)trunc_page((vm_offset_t)bp->b_data);
1460         pmap_qenter((vm_offset_t)bp->b_data, bp->b_pages, bp->b_npages);
1461         bp->b_data = (caddr_t)((vm_offset_t)bp->b_data |
1462             (vm_offset_t)(bp->b_offset & PAGE_MASK));
1463 }
1464
1465 static inline struct bufdomain *
1466 bufdomain(struct buf *bp)
1467 {
1468
1469         return (&bdomain[bp->b_domain]);
1470 }
1471
1472 static struct bufqueue *
1473 bufqueue(struct buf *bp)
1474 {
1475
1476         switch (bp->b_qindex) {
1477         case QUEUE_NONE:
1478                 /* FALLTHROUGH */
1479         case QUEUE_SENTINEL:
1480                 return (NULL);
1481         case QUEUE_EMPTY:
1482                 return (&bqempty);
1483         case QUEUE_DIRTY:
1484                 return (&bufdomain(bp)->bd_dirtyq);
1485         case QUEUE_CLEAN:
1486                 return (&bufdomain(bp)->bd_subq[bp->b_subqueue]);
1487         default:
1488                 break;
1489         }
1490         panic("bufqueue(%p): Unhandled type %d\n", bp, bp->b_qindex);
1491 }
1492
1493 /*
1494  * Return the locked bufqueue that bp is a member of.
1495  */
1496 static struct bufqueue *
1497 bufqueue_acquire(struct buf *bp)
1498 {
1499         struct bufqueue *bq, *nbq;
1500
1501         /*
1502          * bp can be pushed from a per-cpu queue to the
1503          * cleanq while we're waiting on the lock.  Retry
1504          * if the queues don't match.
1505          */
1506         bq = bufqueue(bp);
1507         BQ_LOCK(bq);
1508         for (;;) {
1509                 nbq = bufqueue(bp);
1510                 if (bq == nbq)
1511                         break;
1512                 BQ_UNLOCK(bq);
1513                 BQ_LOCK(nbq);
1514                 bq = nbq;
1515         }
1516         return (bq);
1517 }
1518
1519 /*
1520  *      binsfree:
1521  *
1522  *      Insert the buffer into the appropriate free list.  Requires a
1523  *      locked buffer on entry and buffer is unlocked before return.
1524  */
1525 static void
1526 binsfree(struct buf *bp, int qindex)
1527 {
1528         struct bufdomain *bd;
1529         struct bufqueue *bq;
1530
1531         KASSERT(qindex == QUEUE_CLEAN || qindex == QUEUE_DIRTY,
1532             ("binsfree: Invalid qindex %d", qindex));
1533         BUF_ASSERT_XLOCKED(bp);
1534
1535         /*
1536          * Handle delayed bremfree() processing.
1537          */
1538         if (bp->b_flags & B_REMFREE) {
1539                 if (bp->b_qindex == qindex) {
1540                         bp->b_flags |= B_REUSE;
1541                         bp->b_flags &= ~B_REMFREE;
1542                         BUF_UNLOCK(bp);
1543                         return;
1544                 }
1545                 bq = bufqueue_acquire(bp);
1546                 bq_remove(bq, bp);
1547                 BQ_UNLOCK(bq);
1548         }
1549         bd = bufdomain(bp);
1550         if (qindex == QUEUE_CLEAN) {
1551                 if (bd->bd_lim != 0)
1552                         bq = &bd->bd_subq[PCPU_GET(cpuid)];
1553                 else
1554                         bq = bd->bd_cleanq;
1555         } else
1556                 bq = &bd->bd_dirtyq;
1557         bq_insert(bq, bp, true);
1558 }
1559
1560 /*
1561  * buf_free:
1562  *
1563  *      Free a buffer to the buf zone once it no longer has valid contents.
1564  */
1565 static void
1566 buf_free(struct buf *bp)
1567 {
1568
1569         if (bp->b_flags & B_REMFREE)
1570                 bremfreef(bp);
1571         if (bp->b_vflags & BV_BKGRDINPROG)
1572                 panic("losing buffer 1");
1573         if (bp->b_rcred != NOCRED) {
1574                 crfree(bp->b_rcred);
1575                 bp->b_rcred = NOCRED;
1576         }
1577         if (bp->b_wcred != NOCRED) {
1578                 crfree(bp->b_wcred);
1579                 bp->b_wcred = NOCRED;
1580         }
1581         if (!LIST_EMPTY(&bp->b_dep))
1582                 buf_deallocate(bp);
1583         bufkva_free(bp);
1584         atomic_add_int(&bufdomain(bp)->bd_freebuffers, 1);
1585         MPASS((bp->b_flags & B_MAXPHYS) == 0);
1586         BUF_UNLOCK(bp);
1587         uma_zfree(buf_zone, bp);
1588 }
1589
1590 /*
1591  * buf_import:
1592  *
1593  *      Import bufs into the uma cache from the buf list.  The system still
1594  *      expects a static array of bufs and much of the synchronization
1595  *      around bufs assumes type stable storage.  As a result, UMA is used
1596  *      only as a per-cpu cache of bufs still maintained on a global list.
1597  */
1598 static int
1599 buf_import(void *arg, void **store, int cnt, int domain, int flags)
1600 {
1601         struct buf *bp;
1602         int i;
1603
1604         BQ_LOCK(&bqempty);
1605         for (i = 0; i < cnt; i++) {
1606                 bp = TAILQ_FIRST(&bqempty.bq_queue);
1607                 if (bp == NULL)
1608                         break;
1609                 bq_remove(&bqempty, bp);
1610                 store[i] = bp;
1611         }
1612         BQ_UNLOCK(&bqempty);
1613
1614         return (i);
1615 }
1616
1617 /*
1618  * buf_release:
1619  *
1620  *      Release bufs from the uma cache back to the buffer queues.
1621  */
1622 static void
1623 buf_release(void *arg, void **store, int cnt)
1624 {
1625         struct bufqueue *bq;
1626         struct buf *bp;
1627         int i;
1628
1629         bq = &bqempty;
1630         BQ_LOCK(bq);
1631         for (i = 0; i < cnt; i++) {
1632                 bp = store[i];
1633                 /* Inline bq_insert() to batch locking. */
1634                 TAILQ_INSERT_TAIL(&bq->bq_queue, bp, b_freelist);
1635                 bp->b_flags &= ~(B_AGE | B_REUSE);
1636                 bq->bq_len++;
1637                 bp->b_qindex = bq->bq_index;
1638         }
1639         BQ_UNLOCK(bq);
1640 }
1641
1642 /*
1643  * buf_alloc:
1644  *
1645  *      Allocate an empty buffer header.
1646  */
1647 static struct buf *
1648 buf_alloc(struct bufdomain *bd)
1649 {
1650         struct buf *bp;
1651         int freebufs, error;
1652
1653         /*
1654          * We can only run out of bufs in the buf zone if the average buf
1655          * is less than BKVASIZE.  In this case the actual wait/block will
1656          * come from buf_reycle() failing to flush one of these small bufs.
1657          */
1658         bp = NULL;
1659         freebufs = atomic_fetchadd_int(&bd->bd_freebuffers, -1);
1660         if (freebufs > 0)
1661                 bp = uma_zalloc(buf_zone, M_NOWAIT);
1662         if (bp == NULL) {
1663                 atomic_add_int(&bd->bd_freebuffers, 1);
1664                 bufspace_daemon_wakeup(bd);
1665                 counter_u64_add(numbufallocfails, 1);
1666                 return (NULL);
1667         }
1668         /*
1669          * Wake-up the bufspace daemon on transition below threshold.
1670          */
1671         if (freebufs == bd->bd_lofreebuffers)
1672                 bufspace_daemon_wakeup(bd);
1673
1674         error = BUF_LOCK(bp, LK_EXCLUSIVE, NULL);
1675         KASSERT(error == 0, ("%s: BUF_LOCK on free buf %p: %d.", __func__, bp,
1676             error));
1677         (void)error;
1678
1679         KASSERT(bp->b_vp == NULL,
1680             ("bp: %p still has vnode %p.", bp, bp->b_vp));
1681         KASSERT((bp->b_flags & (B_DELWRI | B_NOREUSE)) == 0,
1682             ("invalid buffer %p flags %#x", bp, bp->b_flags));
1683         KASSERT((bp->b_xflags & (BX_VNCLEAN|BX_VNDIRTY)) == 0,
1684             ("bp: %p still on a buffer list. xflags %X", bp, bp->b_xflags));
1685         KASSERT(bp->b_npages == 0,
1686             ("bp: %p still has %d vm pages\n", bp, bp->b_npages));
1687         KASSERT(bp->b_kvasize == 0, ("bp: %p still has kva\n", bp));
1688         KASSERT(bp->b_bufsize == 0, ("bp: %p still has bufspace\n", bp));
1689         MPASS((bp->b_flags & B_MAXPHYS) == 0);
1690
1691         bp->b_domain = BD_DOMAIN(bd);
1692         bp->b_flags = 0;
1693         bp->b_ioflags = 0;
1694         bp->b_xflags = 0;
1695         bp->b_vflags = 0;
1696         bp->b_vp = NULL;
1697         bp->b_blkno = bp->b_lblkno = 0;
1698         bp->b_offset = NOOFFSET;
1699         bp->b_iodone = 0;
1700         bp->b_error = 0;
1701         bp->b_resid = 0;
1702         bp->b_bcount = 0;
1703         bp->b_npages = 0;
1704         bp->b_dirtyoff = bp->b_dirtyend = 0;
1705         bp->b_bufobj = NULL;
1706         bp->b_data = bp->b_kvabase = unmapped_buf;
1707         bp->b_fsprivate1 = NULL;
1708         bp->b_fsprivate2 = NULL;
1709         bp->b_fsprivate3 = NULL;
1710         LIST_INIT(&bp->b_dep);
1711
1712         return (bp);
1713 }
1714
1715 /*
1716  *      buf_recycle:
1717  *
1718  *      Free a buffer from the given bufqueue.  kva controls whether the
1719  *      freed buf must own some kva resources.  This is used for
1720  *      defragmenting.
1721  */
1722 static int
1723 buf_recycle(struct bufdomain *bd, bool kva)
1724 {
1725         struct bufqueue *bq;
1726         struct buf *bp, *nbp;
1727
1728         if (kva)
1729                 counter_u64_add(bufdefragcnt, 1);
1730         nbp = NULL;
1731         bq = bd->bd_cleanq;
1732         BQ_LOCK(bq);
1733         KASSERT(BQ_LOCKPTR(bq) == BD_LOCKPTR(bd),
1734             ("buf_recycle: Locks don't match"));
1735         nbp = TAILQ_FIRST(&bq->bq_queue);
1736
1737         /*
1738          * Run scan, possibly freeing data and/or kva mappings on the fly
1739          * depending.
1740          */
1741         while ((bp = nbp) != NULL) {
1742                 /*
1743                  * Calculate next bp (we can only use it if we do not
1744                  * release the bqlock).
1745                  */
1746                 nbp = TAILQ_NEXT(bp, b_freelist);
1747
1748                 /*
1749                  * If we are defragging then we need a buffer with
1750                  * some kva to reclaim.
1751                  */
1752                 if (kva && bp->b_kvasize == 0)
1753                         continue;
1754
1755                 if (BUF_LOCK(bp, LK_EXCLUSIVE | LK_NOWAIT, NULL) != 0)
1756                         continue;
1757
1758                 /*
1759                  * Implement a second chance algorithm for frequently
1760                  * accessed buffers.
1761                  */
1762                 if ((bp->b_flags & B_REUSE) != 0) {
1763                         TAILQ_REMOVE(&bq->bq_queue, bp, b_freelist);
1764                         TAILQ_INSERT_TAIL(&bq->bq_queue, bp, b_freelist);
1765                         bp->b_flags &= ~B_REUSE;
1766                         BUF_UNLOCK(bp);
1767                         continue;
1768                 }
1769
1770                 /*
1771                  * Skip buffers with background writes in progress.
1772                  */
1773                 if ((bp->b_vflags & BV_BKGRDINPROG) != 0) {
1774                         BUF_UNLOCK(bp);
1775                         continue;
1776                 }
1777
1778                 KASSERT(bp->b_qindex == QUEUE_CLEAN,
1779                     ("buf_recycle: inconsistent queue %d bp %p",
1780                     bp->b_qindex, bp));
1781                 KASSERT(bp->b_domain == BD_DOMAIN(bd),
1782                     ("getnewbuf: queue domain %d doesn't match request %d",
1783                     bp->b_domain, (int)BD_DOMAIN(bd)));
1784                 /*
1785                  * NOTE:  nbp is now entirely invalid.  We can only restart
1786                  * the scan from this point on.
1787                  */
1788                 bq_remove(bq, bp);
1789                 BQ_UNLOCK(bq);
1790
1791                 /*
1792                  * Requeue the background write buffer with error and
1793                  * restart the scan.
1794                  */
1795                 if ((bp->b_vflags & BV_BKGRDERR) != 0) {
1796                         bqrelse(bp);
1797                         BQ_LOCK(bq);
1798                         nbp = TAILQ_FIRST(&bq->bq_queue);
1799                         continue;
1800                 }
1801                 bp->b_flags |= B_INVAL;
1802                 brelse(bp);
1803                 return (0);
1804         }
1805         bd->bd_wanted = 1;
1806         BQ_UNLOCK(bq);
1807
1808         return (ENOBUFS);
1809 }
1810
1811 /*
1812  *      bremfree:
1813  *
1814  *      Mark the buffer for removal from the appropriate free list.
1815  *
1816  */
1817 void
1818 bremfree(struct buf *bp)
1819 {
1820
1821         CTR3(KTR_BUF, "bremfree(%p) vp %p flags %X", bp, bp->b_vp, bp->b_flags);
1822         KASSERT((bp->b_flags & B_REMFREE) == 0,
1823             ("bremfree: buffer %p already marked for delayed removal.", bp));
1824         KASSERT(bp->b_qindex != QUEUE_NONE,
1825             ("bremfree: buffer %p not on a queue.", bp));
1826         BUF_ASSERT_XLOCKED(bp);
1827
1828         bp->b_flags |= B_REMFREE;
1829 }
1830
1831 /*
1832  *      bremfreef:
1833  *
1834  *      Force an immediate removal from a free list.  Used only in nfs when
1835  *      it abuses the b_freelist pointer.
1836  */
1837 void
1838 bremfreef(struct buf *bp)
1839 {
1840         struct bufqueue *bq;
1841
1842         bq = bufqueue_acquire(bp);
1843         bq_remove(bq, bp);
1844         BQ_UNLOCK(bq);
1845 }
1846
1847 static void
1848 bq_init(struct bufqueue *bq, int qindex, int subqueue, const char *lockname)
1849 {
1850
1851         mtx_init(&bq->bq_lock, lockname, NULL, MTX_DEF);
1852         TAILQ_INIT(&bq->bq_queue);
1853         bq->bq_len = 0;
1854         bq->bq_index = qindex;
1855         bq->bq_subqueue = subqueue;
1856 }
1857
1858 static void
1859 bd_init(struct bufdomain *bd)
1860 {
1861         int i;
1862
1863         bd->bd_cleanq = &bd->bd_subq[mp_maxid + 1];
1864         bq_init(bd->bd_cleanq, QUEUE_CLEAN, mp_maxid + 1, "bufq clean lock");
1865         bq_init(&bd->bd_dirtyq, QUEUE_DIRTY, -1, "bufq dirty lock");
1866         for (i = 0; i <= mp_maxid; i++)
1867                 bq_init(&bd->bd_subq[i], QUEUE_CLEAN, i,
1868                     "bufq clean subqueue lock");
1869         mtx_init(&bd->bd_run_lock, "bufspace daemon run lock", NULL, MTX_DEF);
1870 }
1871
1872 /*
1873  *      bq_remove:
1874  *
1875  *      Removes a buffer from the free list, must be called with the
1876  *      correct qlock held.
1877  */
1878 static void
1879 bq_remove(struct bufqueue *bq, struct buf *bp)
1880 {
1881
1882         CTR3(KTR_BUF, "bq_remove(%p) vp %p flags %X",
1883             bp, bp->b_vp, bp->b_flags);
1884         KASSERT(bp->b_qindex != QUEUE_NONE,
1885             ("bq_remove: buffer %p not on a queue.", bp));
1886         KASSERT(bufqueue(bp) == bq,
1887             ("bq_remove: Remove buffer %p from wrong queue.", bp));
1888
1889         BQ_ASSERT_LOCKED(bq);
1890         if (bp->b_qindex != QUEUE_EMPTY) {
1891                 BUF_ASSERT_XLOCKED(bp);
1892         }
1893         KASSERT(bq->bq_len >= 1,
1894             ("queue %d underflow", bp->b_qindex));
1895         TAILQ_REMOVE(&bq->bq_queue, bp, b_freelist);
1896         bq->bq_len--;
1897         bp->b_qindex = QUEUE_NONE;
1898         bp->b_flags &= ~(B_REMFREE | B_REUSE);
1899 }
1900
1901 static void
1902 bd_flush(struct bufdomain *bd, struct bufqueue *bq)
1903 {
1904         struct buf *bp;
1905
1906         BQ_ASSERT_LOCKED(bq);
1907         if (bq != bd->bd_cleanq) {
1908                 BD_LOCK(bd);
1909                 while ((bp = TAILQ_FIRST(&bq->bq_queue)) != NULL) {
1910                         TAILQ_REMOVE(&bq->bq_queue, bp, b_freelist);
1911                         TAILQ_INSERT_TAIL(&bd->bd_cleanq->bq_queue, bp,
1912                             b_freelist);
1913                         bp->b_subqueue = bd->bd_cleanq->bq_subqueue;
1914                 }
1915                 bd->bd_cleanq->bq_len += bq->bq_len;
1916                 bq->bq_len = 0;
1917         }
1918         if (bd->bd_wanted) {
1919                 bd->bd_wanted = 0;
1920                 wakeup(&bd->bd_wanted);
1921         }
1922         if (bq != bd->bd_cleanq)
1923                 BD_UNLOCK(bd);
1924 }
1925
1926 static int
1927 bd_flushall(struct bufdomain *bd)
1928 {
1929         struct bufqueue *bq;
1930         int flushed;
1931         int i;
1932
1933         if (bd->bd_lim == 0)
1934                 return (0);
1935         flushed = 0;
1936         for (i = 0; i <= mp_maxid; i++) {
1937                 bq = &bd->bd_subq[i];
1938                 if (bq->bq_len == 0)
1939                         continue;
1940                 BQ_LOCK(bq);
1941                 bd_flush(bd, bq);
1942                 BQ_UNLOCK(bq);
1943                 flushed++;
1944         }
1945
1946         return (flushed);
1947 }
1948
1949 static void
1950 bq_insert(struct bufqueue *bq, struct buf *bp, bool unlock)
1951 {
1952         struct bufdomain *bd;
1953
1954         if (bp->b_qindex != QUEUE_NONE)
1955                 panic("bq_insert: free buffer %p onto another queue?", bp);
1956
1957         bd = bufdomain(bp);
1958         if (bp->b_flags & B_AGE) {
1959                 /* Place this buf directly on the real queue. */
1960                 if (bq->bq_index == QUEUE_CLEAN)
1961                         bq = bd->bd_cleanq;
1962                 BQ_LOCK(bq);
1963                 TAILQ_INSERT_HEAD(&bq->bq_queue, bp, b_freelist);
1964         } else {
1965                 BQ_LOCK(bq);
1966                 TAILQ_INSERT_TAIL(&bq->bq_queue, bp, b_freelist);
1967         }
1968         bp->b_flags &= ~(B_AGE | B_REUSE);
1969         bq->bq_len++;
1970         bp->b_qindex = bq->bq_index;
1971         bp->b_subqueue = bq->bq_subqueue;
1972
1973         /*
1974          * Unlock before we notify so that we don't wakeup a waiter that
1975          * fails a trylock on the buf and sleeps again.
1976          */
1977         if (unlock)
1978                 BUF_UNLOCK(bp);
1979
1980         if (bp->b_qindex == QUEUE_CLEAN) {
1981                 /*
1982                  * Flush the per-cpu queue and notify any waiters.
1983                  */
1984                 if (bd->bd_wanted || (bq != bd->bd_cleanq &&
1985                     bq->bq_len >= bd->bd_lim))
1986                         bd_flush(bd, bq);
1987         }
1988         BQ_UNLOCK(bq);
1989 }
1990
1991 /*
1992  *      bufkva_free:
1993  *
1994  *      Free the kva allocation for a buffer.
1995  *
1996  */
1997 static void
1998 bufkva_free(struct buf *bp)
1999 {
2000
2001 #ifdef INVARIANTS
2002         if (bp->b_kvasize == 0) {
2003                 KASSERT(bp->b_kvabase == unmapped_buf &&
2004                     bp->b_data == unmapped_buf,
2005                     ("Leaked KVA space on %p", bp));
2006         } else if (buf_mapped(bp))
2007                 BUF_CHECK_MAPPED(bp);
2008         else
2009                 BUF_CHECK_UNMAPPED(bp);
2010 #endif
2011         if (bp->b_kvasize == 0)
2012                 return;
2013
2014         vmem_free(buffer_arena, (vm_offset_t)bp->b_kvabase, bp->b_kvasize);
2015         counter_u64_add(bufkvaspace, -bp->b_kvasize);
2016         counter_u64_add(buffreekvacnt, 1);
2017         bp->b_data = bp->b_kvabase = unmapped_buf;
2018         bp->b_kvasize = 0;
2019 }
2020
2021 /*
2022  *      bufkva_alloc:
2023  *
2024  *      Allocate the buffer KVA and set b_kvasize and b_kvabase.
2025  */
2026 static int
2027 bufkva_alloc(struct buf *bp, int maxsize, int gbflags)
2028 {
2029         vm_offset_t addr;
2030         int error;
2031
2032         KASSERT((gbflags & GB_UNMAPPED) == 0 || (gbflags & GB_KVAALLOC) != 0,
2033             ("Invalid gbflags 0x%x in %s", gbflags, __func__));
2034         MPASS((bp->b_flags & B_MAXPHYS) == 0);
2035         KASSERT(maxsize <= maxbcachebuf,
2036             ("bufkva_alloc kva too large %d %u", maxsize, maxbcachebuf));
2037
2038         bufkva_free(bp);
2039
2040         addr = 0;
2041         error = vmem_alloc(buffer_arena, maxsize, M_BESTFIT | M_NOWAIT, &addr);
2042         if (error != 0) {
2043                 /*
2044                  * Buffer map is too fragmented.  Request the caller
2045                  * to defragment the map.
2046                  */
2047                 return (error);
2048         }
2049         bp->b_kvabase = (caddr_t)addr;
2050         bp->b_kvasize = maxsize;
2051         counter_u64_add(bufkvaspace, bp->b_kvasize);
2052         if ((gbflags & GB_UNMAPPED) != 0) {
2053                 bp->b_data = unmapped_buf;
2054                 BUF_CHECK_UNMAPPED(bp);
2055         } else {
2056                 bp->b_data = bp->b_kvabase;
2057                 BUF_CHECK_MAPPED(bp);
2058         }
2059         return (0);
2060 }
2061
2062 /*
2063  *      bufkva_reclaim:
2064  *
2065  *      Reclaim buffer kva by freeing buffers holding kva.  This is a vmem
2066  *      callback that fires to avoid returning failure.
2067  */
2068 static void
2069 bufkva_reclaim(vmem_t *vmem, int flags)
2070 {
2071         bool done;
2072         int q;
2073         int i;
2074
2075         done = false;
2076         for (i = 0; i < 5; i++) {
2077                 for (q = 0; q < buf_domains; q++)
2078                         if (buf_recycle(&bdomain[q], true) != 0)
2079                                 done = true;
2080                 if (done)
2081                         break;
2082         }
2083         return;
2084 }
2085
2086 /*
2087  * Attempt to initiate asynchronous I/O on read-ahead blocks.  We must
2088  * clear BIO_ERROR and B_INVAL prior to initiating I/O . If B_CACHE is set,
2089  * the buffer is valid and we do not have to do anything.
2090  */
2091 static void
2092 breada(struct vnode * vp, daddr_t * rablkno, int * rabsize, int cnt,
2093     struct ucred * cred, int flags, void (*ckhashfunc)(struct buf *))
2094 {
2095         struct buf *rabp;
2096         struct thread *td;
2097         int i;
2098
2099         td = curthread;
2100
2101         for (i = 0; i < cnt; i++, rablkno++, rabsize++) {
2102                 if (inmem(vp, *rablkno))
2103                         continue;
2104                 rabp = getblk(vp, *rablkno, *rabsize, 0, 0, 0);
2105                 if ((rabp->b_flags & B_CACHE) != 0) {
2106                         brelse(rabp);
2107                         continue;
2108                 }
2109 #ifdef RACCT
2110                 if (racct_enable) {
2111                         PROC_LOCK(curproc);
2112                         racct_add_buf(curproc, rabp, 0);
2113                         PROC_UNLOCK(curproc);
2114                 }
2115 #endif /* RACCT */
2116                 td->td_ru.ru_inblock++;
2117                 rabp->b_flags |= B_ASYNC;
2118                 rabp->b_flags &= ~B_INVAL;
2119                 if ((flags & GB_CKHASH) != 0) {
2120                         rabp->b_flags |= B_CKHASH;
2121                         rabp->b_ckhashcalc = ckhashfunc;
2122                 }
2123                 rabp->b_ioflags &= ~BIO_ERROR;
2124                 rabp->b_iocmd = BIO_READ;
2125                 if (rabp->b_rcred == NOCRED && cred != NOCRED)
2126                         rabp->b_rcred = crhold(cred);
2127                 vfs_busy_pages(rabp, 0);
2128                 BUF_KERNPROC(rabp);
2129                 rabp->b_iooffset = dbtob(rabp->b_blkno);
2130                 bstrategy(rabp);
2131         }
2132 }
2133
2134 /*
2135  * Entry point for bread() and breadn() via #defines in sys/buf.h.
2136  *
2137  * Get a buffer with the specified data.  Look in the cache first.  We
2138  * must clear BIO_ERROR and B_INVAL prior to initiating I/O.  If B_CACHE
2139  * is set, the buffer is valid and we do not have to do anything, see
2140  * getblk(). Also starts asynchronous I/O on read-ahead blocks.
2141  *
2142  * Always return a NULL buffer pointer (in bpp) when returning an error.
2143  *
2144  * The blkno parameter is the logical block being requested. Normally
2145  * the mapping of logical block number to disk block address is done
2146  * by calling VOP_BMAP(). However, if the mapping is already known, the
2147  * disk block address can be passed using the dblkno parameter. If the
2148  * disk block address is not known, then the same value should be passed
2149  * for blkno and dblkno.
2150  */
2151 int
2152 breadn_flags(struct vnode *vp, daddr_t blkno, daddr_t dblkno, int size,
2153     daddr_t *rablkno, int *rabsize, int cnt, struct ucred *cred, int flags,
2154     void (*ckhashfunc)(struct buf *), struct buf **bpp)
2155 {
2156         struct buf *bp;
2157         struct thread *td;
2158         int error, readwait, rv;
2159
2160         CTR3(KTR_BUF, "breadn(%p, %jd, %d)", vp, blkno, size);
2161         td = curthread;
2162         /*
2163          * Can only return NULL if GB_LOCK_NOWAIT or GB_SPARSE flags
2164          * are specified.
2165          */
2166         error = getblkx(vp, blkno, dblkno, size, 0, 0, flags, &bp);
2167         if (error != 0) {
2168                 *bpp = NULL;
2169                 return (error);
2170         }
2171         KASSERT(blkno == bp->b_lblkno,
2172             ("getblkx returned buffer for blkno %jd instead of blkno %jd",
2173             (intmax_t)bp->b_lblkno, (intmax_t)blkno));
2174         flags &= ~GB_NOSPARSE;
2175         *bpp = bp;
2176
2177         /*
2178          * If not found in cache, do some I/O
2179          */
2180         readwait = 0;
2181         if ((bp->b_flags & B_CACHE) == 0) {
2182 #ifdef RACCT
2183                 if (racct_enable) {
2184                         PROC_LOCK(td->td_proc);
2185                         racct_add_buf(td->td_proc, bp, 0);
2186                         PROC_UNLOCK(td->td_proc);
2187                 }
2188 #endif /* RACCT */
2189                 td->td_ru.ru_inblock++;
2190                 bp->b_iocmd = BIO_READ;
2191                 bp->b_flags &= ~B_INVAL;
2192                 if ((flags & GB_CKHASH) != 0) {
2193                         bp->b_flags |= B_CKHASH;
2194                         bp->b_ckhashcalc = ckhashfunc;
2195                 }
2196                 if ((flags & GB_CVTENXIO) != 0)
2197                         bp->b_xflags |= BX_CVTENXIO;
2198                 bp->b_ioflags &= ~BIO_ERROR;
2199                 if (bp->b_rcred == NOCRED && cred != NOCRED)
2200                         bp->b_rcred = crhold(cred);
2201                 vfs_busy_pages(bp, 0);
2202                 bp->b_iooffset = dbtob(bp->b_blkno);
2203                 bstrategy(bp);
2204                 ++readwait;
2205         }
2206
2207         /*
2208          * Attempt to initiate asynchronous I/O on read-ahead blocks.
2209          */
2210         breada(vp, rablkno, rabsize, cnt, cred, flags, ckhashfunc);
2211
2212         rv = 0;
2213         if (readwait) {
2214                 rv = bufwait(bp);
2215                 if (rv != 0) {
2216                         brelse(bp);
2217                         *bpp = NULL;
2218                 }
2219         }
2220         return (rv);
2221 }
2222
2223 /*
2224  * Write, release buffer on completion.  (Done by iodone
2225  * if async).  Do not bother writing anything if the buffer
2226  * is invalid.
2227  *
2228  * Note that we set B_CACHE here, indicating that buffer is
2229  * fully valid and thus cacheable.  This is true even of NFS
2230  * now so we set it generally.  This could be set either here
2231  * or in biodone() since the I/O is synchronous.  We put it
2232  * here.
2233  */
2234 int
2235 bufwrite(struct buf *bp)
2236 {
2237         int oldflags;
2238         struct vnode *vp;
2239         long space;
2240         int vp_md;
2241
2242         CTR3(KTR_BUF, "bufwrite(%p) vp %p flags %X", bp, bp->b_vp, bp->b_flags);
2243         if ((bp->b_bufobj->bo_flag & BO_DEAD) != 0) {
2244                 bp->b_flags |= B_INVAL | B_RELBUF;
2245                 bp->b_flags &= ~B_CACHE;
2246                 brelse(bp);
2247                 return (ENXIO);
2248         }
2249         if (bp->b_flags & B_INVAL) {
2250                 brelse(bp);
2251                 return (0);
2252         }
2253
2254         if (bp->b_flags & B_BARRIER)
2255                 atomic_add_long(&barrierwrites, 1);
2256
2257         oldflags = bp->b_flags;
2258
2259         KASSERT(!(bp->b_vflags & BV_BKGRDINPROG),
2260             ("FFS background buffer should not get here %p", bp));
2261
2262         vp = bp->b_vp;
2263         if (vp)
2264                 vp_md = vp->v_vflag & VV_MD;
2265         else
2266                 vp_md = 0;
2267
2268         /*
2269          * Mark the buffer clean.  Increment the bufobj write count
2270          * before bundirty() call, to prevent other thread from seeing
2271          * empty dirty list and zero counter for writes in progress,
2272          * falsely indicating that the bufobj is clean.
2273          */
2274         bufobj_wref(bp->b_bufobj);
2275         bundirty(bp);
2276
2277         bp->b_flags &= ~B_DONE;
2278         bp->b_ioflags &= ~BIO_ERROR;
2279         bp->b_flags |= B_CACHE;
2280         bp->b_iocmd = BIO_WRITE;
2281
2282         vfs_busy_pages(bp, 1);
2283
2284         /*
2285          * Normal bwrites pipeline writes
2286          */
2287         bp->b_runningbufspace = bp->b_bufsize;
2288         space = atomic_fetchadd_long(&runningbufspace, bp->b_runningbufspace);
2289
2290 #ifdef RACCT
2291         if (racct_enable) {
2292                 PROC_LOCK(curproc);
2293                 racct_add_buf(curproc, bp, 1);
2294                 PROC_UNLOCK(curproc);
2295         }
2296 #endif /* RACCT */
2297         curthread->td_ru.ru_oublock++;
2298         if (oldflags & B_ASYNC)
2299                 BUF_KERNPROC(bp);
2300         bp->b_iooffset = dbtob(bp->b_blkno);
2301         buf_track(bp, __func__);
2302         bstrategy(bp);
2303
2304         if ((oldflags & B_ASYNC) == 0) {
2305                 int rtval = bufwait(bp);
2306                 brelse(bp);
2307                 return (rtval);
2308         } else if (space > hirunningspace) {
2309                 /*
2310                  * don't allow the async write to saturate the I/O
2311                  * system.  We will not deadlock here because
2312                  * we are blocking waiting for I/O that is already in-progress
2313                  * to complete. We do not block here if it is the update
2314                  * or syncer daemon trying to clean up as that can lead
2315                  * to deadlock.
2316                  */
2317                 if ((curthread->td_pflags & TDP_NORUNNINGBUF) == 0 && !vp_md)
2318                         waitrunningbufspace();
2319         }
2320
2321         return (0);
2322 }
2323
2324 void
2325 bufbdflush(struct bufobj *bo, struct buf *bp)
2326 {
2327         struct buf *nbp;
2328
2329         if (bo->bo_dirty.bv_cnt > dirtybufthresh + 10) {
2330                 (void) VOP_FSYNC(bp->b_vp, MNT_NOWAIT, curthread);
2331                 altbufferflushes++;
2332         } else if (bo->bo_dirty.bv_cnt > dirtybufthresh) {
2333                 BO_LOCK(bo);
2334                 /*
2335                  * Try to find a buffer to flush.
2336                  */
2337                 TAILQ_FOREACH(nbp, &bo->bo_dirty.bv_hd, b_bobufs) {
2338                         if ((nbp->b_vflags & BV_BKGRDINPROG) ||
2339                             BUF_LOCK(nbp,
2340                                      LK_EXCLUSIVE | LK_NOWAIT, NULL))
2341                                 continue;
2342                         if (bp == nbp)
2343                                 panic("bdwrite: found ourselves");
2344                         BO_UNLOCK(bo);
2345                         /* Don't countdeps with the bo lock held. */
2346                         if (buf_countdeps(nbp, 0)) {
2347                                 BO_LOCK(bo);
2348                                 BUF_UNLOCK(nbp);
2349                                 continue;
2350                         }
2351                         if (nbp->b_flags & B_CLUSTEROK) {
2352                                 vfs_bio_awrite(nbp);
2353                         } else {
2354                                 bremfree(nbp);
2355                                 bawrite(nbp);
2356                         }
2357                         dirtybufferflushes++;
2358                         break;
2359                 }
2360                 if (nbp == NULL)
2361                         BO_UNLOCK(bo);
2362         }
2363 }
2364
2365 /*
2366  * Delayed write. (Buffer is marked dirty).  Do not bother writing
2367  * anything if the buffer is marked invalid.
2368  *
2369  * Note that since the buffer must be completely valid, we can safely
2370  * set B_CACHE.  In fact, we have to set B_CACHE here rather then in
2371  * biodone() in order to prevent getblk from writing the buffer
2372  * out synchronously.
2373  */
2374 void
2375 bdwrite(struct buf *bp)
2376 {
2377         struct thread *td = curthread;
2378         struct vnode *vp;
2379         struct bufobj *bo;
2380
2381         CTR3(KTR_BUF, "bdwrite(%p) vp %p flags %X", bp, bp->b_vp, bp->b_flags);
2382         KASSERT(bp->b_bufobj != NULL, ("No b_bufobj %p", bp));
2383         KASSERT((bp->b_flags & B_BARRIER) == 0,
2384             ("Barrier request in delayed write %p", bp));
2385
2386         if (bp->b_flags & B_INVAL) {
2387                 brelse(bp);
2388                 return;
2389         }
2390
2391         /*
2392          * If we have too many dirty buffers, don't create any more.
2393          * If we are wildly over our limit, then force a complete
2394          * cleanup. Otherwise, just keep the situation from getting
2395          * out of control. Note that we have to avoid a recursive
2396          * disaster and not try to clean up after our own cleanup!
2397          */
2398         vp = bp->b_vp;
2399         bo = bp->b_bufobj;
2400         if ((td->td_pflags & (TDP_COWINPROGRESS|TDP_INBDFLUSH)) == 0) {
2401                 td->td_pflags |= TDP_INBDFLUSH;
2402                 BO_BDFLUSH(bo, bp);
2403                 td->td_pflags &= ~TDP_INBDFLUSH;
2404         } else
2405                 recursiveflushes++;
2406
2407         bdirty(bp);
2408         /*
2409          * Set B_CACHE, indicating that the buffer is fully valid.  This is
2410          * true even of NFS now.
2411          */
2412         bp->b_flags |= B_CACHE;
2413
2414         /*
2415          * This bmap keeps the system from needing to do the bmap later,
2416          * perhaps when the system is attempting to do a sync.  Since it
2417          * is likely that the indirect block -- or whatever other datastructure
2418          * that the filesystem needs is still in memory now, it is a good
2419          * thing to do this.  Note also, that if the pageout daemon is
2420          * requesting a sync -- there might not be enough memory to do
2421          * the bmap then...  So, this is important to do.
2422          */
2423         if (vp->v_type != VCHR && bp->b_lblkno == bp->b_blkno) {
2424                 VOP_BMAP(vp, bp->b_lblkno, NULL, &bp->b_blkno, NULL, NULL);
2425         }
2426
2427         buf_track(bp, __func__);
2428
2429         /*
2430          * Set the *dirty* buffer range based upon the VM system dirty
2431          * pages.
2432          *
2433          * Mark the buffer pages as clean.  We need to do this here to
2434          * satisfy the vnode_pager and the pageout daemon, so that it
2435          * thinks that the pages have been "cleaned".  Note that since
2436          * the pages are in a delayed write buffer -- the VFS layer
2437          * "will" see that the pages get written out on the next sync,
2438          * or perhaps the cluster will be completed.
2439          */
2440         vfs_clean_pages_dirty_buf(bp);
2441         bqrelse(bp);
2442
2443         /*
2444          * note: we cannot initiate I/O from a bdwrite even if we wanted to,
2445          * due to the softdep code.
2446          */
2447 }
2448
2449 /*
2450  *      bdirty:
2451  *
2452  *      Turn buffer into delayed write request.  We must clear BIO_READ and
2453  *      B_RELBUF, and we must set B_DELWRI.  We reassign the buffer to
2454  *      itself to properly update it in the dirty/clean lists.  We mark it
2455  *      B_DONE to ensure that any asynchronization of the buffer properly
2456  *      clears B_DONE ( else a panic will occur later ).
2457  *
2458  *      bdirty() is kinda like bdwrite() - we have to clear B_INVAL which
2459  *      might have been set pre-getblk().  Unlike bwrite/bdwrite, bdirty()
2460  *      should only be called if the buffer is known-good.
2461  *
2462  *      Since the buffer is not on a queue, we do not update the numfreebuffers
2463  *      count.
2464  *
2465  *      The buffer must be on QUEUE_NONE.
2466  */
2467 void
2468 bdirty(struct buf *bp)
2469 {
2470
2471         CTR3(KTR_BUF, "bdirty(%p) vp %p flags %X",
2472             bp, bp->b_vp, bp->b_flags);
2473         KASSERT(bp->b_bufobj != NULL, ("No b_bufobj %p", bp));
2474         KASSERT(bp->b_flags & B_REMFREE || bp->b_qindex == QUEUE_NONE,
2475             ("bdirty: buffer %p still on queue %d", bp, bp->b_qindex));
2476         bp->b_flags &= ~(B_RELBUF);
2477         bp->b_iocmd = BIO_WRITE;
2478
2479         if ((bp->b_flags & B_DELWRI) == 0) {
2480                 bp->b_flags |= /* XXX B_DONE | */ B_DELWRI;
2481                 reassignbuf(bp);
2482                 bdirtyadd(bp);
2483         }
2484 }
2485
2486 /*
2487  *      bundirty:
2488  *
2489  *      Clear B_DELWRI for buffer.
2490  *
2491  *      Since the buffer is not on a queue, we do not update the numfreebuffers
2492  *      count.
2493  *
2494  *      The buffer must be on QUEUE_NONE.
2495  */
2496
2497 void
2498 bundirty(struct buf *bp)
2499 {
2500
2501         CTR3(KTR_BUF, "bundirty(%p) vp %p flags %X", bp, bp->b_vp, bp->b_flags);
2502         KASSERT(bp->b_bufobj != NULL, ("No b_bufobj %p", bp));
2503         KASSERT(bp->b_flags & B_REMFREE || bp->b_qindex == QUEUE_NONE,
2504             ("bundirty: buffer %p still on queue %d", bp, bp->b_qindex));
2505
2506         if (bp->b_flags & B_DELWRI) {
2507                 bp->b_flags &= ~B_DELWRI;
2508                 reassignbuf(bp);
2509                 bdirtysub(bp);
2510         }
2511         /*
2512          * Since it is now being written, we can clear its deferred write flag.
2513          */
2514         bp->b_flags &= ~B_DEFERRED;
2515 }
2516
2517 /*
2518  *      bawrite:
2519  *
2520  *      Asynchronous write.  Start output on a buffer, but do not wait for
2521  *      it to complete.  The buffer is released when the output completes.
2522  *
2523  *      bwrite() ( or the VOP routine anyway ) is responsible for handling
2524  *      B_INVAL buffers.  Not us.
2525  */
2526 void
2527 bawrite(struct buf *bp)
2528 {
2529
2530         bp->b_flags |= B_ASYNC;
2531         (void) bwrite(bp);
2532 }
2533
2534 /*
2535  *      babarrierwrite:
2536  *
2537  *      Asynchronous barrier write.  Start output on a buffer, but do not
2538  *      wait for it to complete.  Place a write barrier after this write so
2539  *      that this buffer and all buffers written before it are committed to
2540  *      the disk before any buffers written after this write are committed
2541  *      to the disk.  The buffer is released when the output completes.
2542  */
2543 void
2544 babarrierwrite(struct buf *bp)
2545 {
2546
2547         bp->b_flags |= B_ASYNC | B_BARRIER;
2548         (void) bwrite(bp);
2549 }
2550
2551 /*
2552  *      bbarrierwrite:
2553  *
2554  *      Synchronous barrier write.  Start output on a buffer and wait for
2555  *      it to complete.  Place a write barrier after this write so that
2556  *      this buffer and all buffers written before it are committed to
2557  *      the disk before any buffers written after this write are committed
2558  *      to the disk.  The buffer is released when the output completes.
2559  */
2560 int
2561 bbarrierwrite(struct buf *bp)
2562 {
2563
2564         bp->b_flags |= B_BARRIER;
2565         return (bwrite(bp));
2566 }
2567
2568 /*
2569  *      bwillwrite:
2570  *
2571  *      Called prior to the locking of any vnodes when we are expecting to
2572  *      write.  We do not want to starve the buffer cache with too many
2573  *      dirty buffers so we block here.  By blocking prior to the locking
2574  *      of any vnodes we attempt to avoid the situation where a locked vnode
2575  *      prevents the various system daemons from flushing related buffers.
2576  */
2577 void
2578 bwillwrite(void)
2579 {
2580
2581         if (buf_dirty_count_severe()) {
2582                 mtx_lock(&bdirtylock);
2583                 while (buf_dirty_count_severe()) {
2584                         bdirtywait = 1;
2585                         msleep(&bdirtywait, &bdirtylock, (PRIBIO + 4),
2586                             "flswai", 0);
2587                 }
2588                 mtx_unlock(&bdirtylock);
2589         }
2590 }
2591
2592 /*
2593  * Return true if we have too many dirty buffers.
2594  */
2595 int
2596 buf_dirty_count_severe(void)
2597 {
2598
2599         return (!BIT_EMPTY(BUF_DOMAINS, &bdhidirty));
2600 }
2601
2602 /*
2603  *      brelse:
2604  *
2605  *      Release a busy buffer and, if requested, free its resources.  The
2606  *      buffer will be stashed in the appropriate bufqueue[] allowing it
2607  *      to be accessed later as a cache entity or reused for other purposes.
2608  */
2609 void
2610 brelse(struct buf *bp)
2611 {
2612         struct mount *v_mnt;
2613         int qindex;
2614
2615         /*
2616          * Many functions erroneously call brelse with a NULL bp under rare
2617          * error conditions. Simply return when called with a NULL bp.
2618          */
2619         if (bp == NULL)
2620                 return;
2621         CTR3(KTR_BUF, "brelse(%p) vp %p flags %X",
2622             bp, bp->b_vp, bp->b_flags);
2623         KASSERT(!(bp->b_flags & (B_CLUSTER|B_PAGING)),
2624             ("brelse: inappropriate B_PAGING or B_CLUSTER bp %p", bp));
2625         KASSERT((bp->b_flags & B_VMIO) != 0 || (bp->b_flags & B_NOREUSE) == 0,
2626             ("brelse: non-VMIO buffer marked NOREUSE"));
2627
2628         if (BUF_LOCKRECURSED(bp)) {
2629                 /*
2630                  * Do not process, in particular, do not handle the
2631                  * B_INVAL/B_RELBUF and do not release to free list.
2632                  */
2633                 BUF_UNLOCK(bp);
2634                 return;
2635         }
2636
2637         if (bp->b_flags & B_MANAGED) {
2638                 bqrelse(bp);
2639                 return;
2640         }
2641
2642         if (LIST_EMPTY(&bp->b_dep)) {
2643                 bp->b_flags &= ~B_IOSTARTED;
2644         } else {
2645                 KASSERT((bp->b_flags & B_IOSTARTED) == 0,
2646                     ("brelse: SU io not finished bp %p", bp));
2647         }
2648
2649         if ((bp->b_vflags & (BV_BKGRDINPROG | BV_BKGRDERR)) == BV_BKGRDERR) {
2650                 BO_LOCK(bp->b_bufobj);
2651                 bp->b_vflags &= ~BV_BKGRDERR;
2652                 BO_UNLOCK(bp->b_bufobj);
2653                 bdirty(bp);
2654         }
2655
2656         if (bp->b_iocmd == BIO_WRITE && (bp->b_ioflags & BIO_ERROR) &&
2657             (bp->b_flags & B_INVALONERR)) {
2658                 /*
2659                  * Forced invalidation of dirty buffer contents, to be used
2660                  * after a failed write in the rare case that the loss of the
2661                  * contents is acceptable.  The buffer is invalidated and
2662                  * freed.
2663                  */
2664                 bp->b_flags |= B_INVAL | B_RELBUF | B_NOCACHE;
2665                 bp->b_flags &= ~(B_ASYNC | B_CACHE);
2666         }
2667
2668         if (bp->b_iocmd == BIO_WRITE && (bp->b_ioflags & BIO_ERROR) &&
2669             (bp->b_error != ENXIO || !LIST_EMPTY(&bp->b_dep)) &&
2670             !(bp->b_flags & B_INVAL)) {
2671                 /*
2672                  * Failed write, redirty.  All errors except ENXIO (which
2673                  * means the device is gone) are treated as being
2674                  * transient.
2675                  *
2676                  * XXX Treating EIO as transient is not correct; the
2677                  * contract with the local storage device drivers is that
2678                  * they will only return EIO once the I/O is no longer
2679                  * retriable.  Network I/O also respects this through the
2680                  * guarantees of TCP and/or the internal retries of NFS.
2681                  * ENOMEM might be transient, but we also have no way of
2682                  * knowing when its ok to retry/reschedule.  In general,
2683                  * this entire case should be made obsolete through better
2684                  * error handling/recovery and resource scheduling.
2685                  *
2686                  * Do this also for buffers that failed with ENXIO, but have
2687                  * non-empty dependencies - the soft updates code might need
2688                  * to access the buffer to untangle them.
2689                  *
2690                  * Must clear BIO_ERROR to prevent pages from being scrapped.
2691                  */
2692                 bp->b_ioflags &= ~BIO_ERROR;
2693                 bdirty(bp);
2694         } else if ((bp->b_flags & (B_NOCACHE | B_INVAL)) ||
2695             (bp->b_ioflags & BIO_ERROR) || (bp->b_bufsize <= 0)) {
2696                 /*
2697                  * Either a failed read I/O, or we were asked to free or not
2698                  * cache the buffer, or we failed to write to a device that's
2699                  * no longer present.
2700                  */
2701                 bp->b_flags |= B_INVAL;
2702                 if (!LIST_EMPTY(&bp->b_dep))
2703                         buf_deallocate(bp);
2704                 if (bp->b_flags & B_DELWRI)
2705                         bdirtysub(bp);
2706                 bp->b_flags &= ~(B_DELWRI | B_CACHE);
2707                 if ((bp->b_flags & B_VMIO) == 0) {
2708                         allocbuf(bp, 0);
2709                         if (bp->b_vp)
2710                                 brelvp(bp);
2711                 }
2712         }
2713
2714         /*
2715          * We must clear B_RELBUF if B_DELWRI is set.  If vfs_vmio_truncate()
2716          * is called with B_DELWRI set, the underlying pages may wind up
2717          * getting freed causing a previous write (bdwrite()) to get 'lost'
2718          * because pages associated with a B_DELWRI bp are marked clean.
2719          *
2720          * We still allow the B_INVAL case to call vfs_vmio_truncate(), even
2721          * if B_DELWRI is set.
2722          */
2723         if (bp->b_flags & B_DELWRI)
2724                 bp->b_flags &= ~B_RELBUF;
2725
2726         /*
2727          * VMIO buffer rundown.  It is not very necessary to keep a VMIO buffer
2728          * constituted, not even NFS buffers now.  Two flags effect this.  If
2729          * B_INVAL, the struct buf is invalidated but the VM object is kept
2730          * around ( i.e. so it is trivial to reconstitute the buffer later ).
2731          *
2732          * If BIO_ERROR or B_NOCACHE is set, pages in the VM object will be
2733          * invalidated.  BIO_ERROR cannot be set for a failed write unless the
2734          * buffer is also B_INVAL because it hits the re-dirtying code above.
2735          *
2736          * Normally we can do this whether a buffer is B_DELWRI or not.  If
2737          * the buffer is an NFS buffer, it is tracking piecemeal writes or
2738          * the commit state and we cannot afford to lose the buffer. If the
2739          * buffer has a background write in progress, we need to keep it
2740          * around to prevent it from being reconstituted and starting a second
2741          * background write.
2742          */
2743
2744         v_mnt = bp->b_vp != NULL ? bp->b_vp->v_mount : NULL;
2745
2746         if ((bp->b_flags & B_VMIO) && (bp->b_flags & B_NOCACHE ||
2747             (bp->b_ioflags & BIO_ERROR && bp->b_iocmd == BIO_READ)) &&
2748             (v_mnt == NULL || (v_mnt->mnt_vfc->vfc_flags & VFCF_NETWORK) == 0 ||
2749             vn_isdisk(bp->b_vp) || (bp->b_flags & B_DELWRI) == 0)) {
2750                 vfs_vmio_invalidate(bp);
2751                 allocbuf(bp, 0);
2752         }
2753
2754         if ((bp->b_flags & (B_INVAL | B_RELBUF)) != 0 ||
2755             (bp->b_flags & (B_DELWRI | B_NOREUSE)) == B_NOREUSE) {
2756                 allocbuf(bp, 0);
2757                 bp->b_flags &= ~B_NOREUSE;
2758                 if (bp->b_vp != NULL)
2759                         brelvp(bp);
2760         }
2761
2762         /*
2763          * If the buffer has junk contents signal it and eventually
2764          * clean up B_DELWRI and diassociate the vnode so that gbincore()
2765          * doesn't find it.
2766          */
2767         if (bp->b_bufsize == 0 || (bp->b_ioflags & BIO_ERROR) != 0 ||
2768             (bp->b_flags & (B_INVAL | B_NOCACHE | B_RELBUF)) != 0)
2769                 bp->b_flags |= B_INVAL;
2770         if (bp->b_flags & B_INVAL) {
2771                 if (bp->b_flags & B_DELWRI)
2772                         bundirty(bp);
2773                 if (bp->b_vp)
2774                         brelvp(bp);
2775         }
2776
2777         buf_track(bp, __func__);
2778
2779         /* buffers with no memory */
2780         if (bp->b_bufsize == 0) {
2781                 buf_free(bp);
2782                 return;
2783         }
2784         /* buffers with junk contents */
2785         if (bp->b_flags & (B_INVAL | B_NOCACHE | B_RELBUF) ||
2786             (bp->b_ioflags & BIO_ERROR)) {
2787                 bp->b_xflags &= ~(BX_BKGRDWRITE | BX_ALTDATA);
2788                 if (bp->b_vflags & BV_BKGRDINPROG)
2789                         panic("losing buffer 2");
2790                 qindex = QUEUE_CLEAN;
2791                 bp->b_flags |= B_AGE;
2792         /* remaining buffers */
2793         } else if (bp->b_flags & B_DELWRI)
2794                 qindex = QUEUE_DIRTY;
2795         else
2796                 qindex = QUEUE_CLEAN;
2797
2798         if ((bp->b_flags & B_DELWRI) == 0 && (bp->b_xflags & BX_VNDIRTY))
2799                 panic("brelse: not dirty");
2800
2801         bp->b_flags &= ~(B_ASYNC | B_NOCACHE | B_RELBUF | B_DIRECT);
2802         bp->b_xflags &= ~(BX_CVTENXIO);
2803         /* binsfree unlocks bp. */
2804         binsfree(bp, qindex);
2805 }
2806
2807 /*
2808  * Release a buffer back to the appropriate queue but do not try to free
2809  * it.  The buffer is expected to be used again soon.
2810  *
2811  * bqrelse() is used by bdwrite() to requeue a delayed write, and used by
2812  * biodone() to requeue an async I/O on completion.  It is also used when
2813  * known good buffers need to be requeued but we think we may need the data
2814  * again soon.
2815  *
2816  * XXX we should be able to leave the B_RELBUF hint set on completion.
2817  */
2818 void
2819 bqrelse(struct buf *bp)
2820 {
2821         int qindex;
2822
2823         CTR3(KTR_BUF, "bqrelse(%p) vp %p flags %X", bp, bp->b_vp, bp->b_flags);
2824         KASSERT(!(bp->b_flags & (B_CLUSTER|B_PAGING)),
2825             ("bqrelse: inappropriate B_PAGING or B_CLUSTER bp %p", bp));
2826
2827         qindex = QUEUE_NONE;
2828         if (BUF_LOCKRECURSED(bp)) {
2829                 /* do not release to free list */
2830                 BUF_UNLOCK(bp);
2831                 return;
2832         }
2833         bp->b_flags &= ~(B_ASYNC | B_NOCACHE | B_AGE | B_RELBUF);
2834         bp->b_xflags &= ~(BX_CVTENXIO);
2835
2836         if (LIST_EMPTY(&bp->b_dep)) {
2837                 bp->b_flags &= ~B_IOSTARTED;
2838         } else {
2839                 KASSERT((bp->b_flags & B_IOSTARTED) == 0,
2840                     ("bqrelse: SU io not finished bp %p", bp));
2841         }
2842
2843         if (bp->b_flags & B_MANAGED) {
2844                 if (bp->b_flags & B_REMFREE)
2845                         bremfreef(bp);
2846                 goto out;
2847         }
2848
2849         /* buffers with stale but valid contents */
2850         if ((bp->b_flags & B_DELWRI) != 0 || (bp->b_vflags & (BV_BKGRDINPROG |
2851             BV_BKGRDERR)) == BV_BKGRDERR) {
2852                 BO_LOCK(bp->b_bufobj);
2853                 bp->b_vflags &= ~BV_BKGRDERR;
2854                 BO_UNLOCK(bp->b_bufobj);
2855                 qindex = QUEUE_DIRTY;
2856         } else {
2857                 if ((bp->b_flags & B_DELWRI) == 0 &&
2858                     (bp->b_xflags & BX_VNDIRTY))
2859                         panic("bqrelse: not dirty");
2860                 if ((bp->b_flags & B_NOREUSE) != 0) {
2861                         brelse(bp);
2862                         return;
2863                 }
2864                 qindex = QUEUE_CLEAN;
2865         }
2866         buf_track(bp, __func__);
2867         /* binsfree unlocks bp. */
2868         binsfree(bp, qindex);
2869         return;
2870
2871 out:
2872         buf_track(bp, __func__);
2873         /* unlock */
2874         BUF_UNLOCK(bp);
2875 }
2876
2877 /*
2878  * Complete I/O to a VMIO backed page.  Validate the pages as appropriate,
2879  * restore bogus pages.
2880  */
2881 static void
2882 vfs_vmio_iodone(struct buf *bp)
2883 {
2884         vm_ooffset_t foff;
2885         vm_page_t m;
2886         vm_object_t obj;
2887         struct vnode *vp __unused;
2888         int i, iosize, resid;
2889         bool bogus;
2890
2891         obj = bp->b_bufobj->bo_object;
2892         KASSERT(blockcount_read(&obj->paging_in_progress) >= bp->b_npages,
2893             ("vfs_vmio_iodone: paging in progress(%d) < b_npages(%d)",
2894             blockcount_read(&obj->paging_in_progress), bp->b_npages));
2895
2896         vp = bp->b_vp;
2897         VNPASS(vp->v_holdcnt > 0, vp);
2898         VNPASS(vp->v_object != NULL, vp);
2899
2900         foff = bp->b_offset;
2901         KASSERT(bp->b_offset != NOOFFSET,
2902             ("vfs_vmio_iodone: bp %p has no buffer offset", bp));
2903
2904         bogus = false;
2905         iosize = bp->b_bcount - bp->b_resid;
2906         for (i = 0; i < bp->b_npages; i++) {
2907                 resid = ((foff + PAGE_SIZE) & ~(off_t)PAGE_MASK) - foff;
2908                 if (resid > iosize)
2909                         resid = iosize;
2910
2911                 /*
2912                  * cleanup bogus pages, restoring the originals
2913                  */
2914                 m = bp->b_pages[i];
2915                 if (m == bogus_page) {
2916                         bogus = true;
2917                         m = vm_page_relookup(obj, OFF_TO_IDX(foff));
2918                         if (m == NULL)
2919                                 panic("biodone: page disappeared!");
2920                         bp->b_pages[i] = m;
2921                 } else if ((bp->b_iocmd == BIO_READ) && resid > 0) {
2922                         /*
2923                          * In the write case, the valid and clean bits are
2924                          * already changed correctly ( see bdwrite() ), so we
2925                          * only need to do this here in the read case.
2926                          */
2927                         KASSERT((m->dirty & vm_page_bits(foff & PAGE_MASK,
2928                             resid)) == 0, ("vfs_vmio_iodone: page %p "
2929                             "has unexpected dirty bits", m));
2930                         vfs_page_set_valid(bp, foff, m);
2931                 }
2932                 KASSERT(OFF_TO_IDX(foff) == m->pindex,
2933                     ("vfs_vmio_iodone: foff(%jd)/pindex(%ju) mismatch",
2934                     (intmax_t)foff, (uintmax_t)m->pindex));
2935
2936                 vm_page_sunbusy(m);
2937                 foff = (foff + PAGE_SIZE) & ~(off_t)PAGE_MASK;
2938                 iosize -= resid;
2939         }
2940         vm_object_pip_wakeupn(obj, bp->b_npages);
2941         if (bogus && buf_mapped(bp)) {
2942                 BUF_CHECK_MAPPED(bp);
2943                 pmap_qenter(trunc_page((vm_offset_t)bp->b_data),
2944                     bp->b_pages, bp->b_npages);
2945         }
2946 }
2947
2948 /*
2949  * Perform page invalidation when a buffer is released.  The fully invalid
2950  * pages will be reclaimed later in vfs_vmio_truncate().
2951  */
2952 static void
2953 vfs_vmio_invalidate(struct buf *bp)
2954 {
2955         vm_object_t obj;
2956         vm_page_t m;
2957         int flags, i, resid, poffset, presid;
2958
2959         if (buf_mapped(bp)) {
2960                 BUF_CHECK_MAPPED(bp);
2961                 pmap_qremove(trunc_page((vm_offset_t)bp->b_data), bp->b_npages);
2962         } else
2963                 BUF_CHECK_UNMAPPED(bp);
2964         /*
2965          * Get the base offset and length of the buffer.  Note that
2966          * in the VMIO case if the buffer block size is not
2967          * page-aligned then b_data pointer may not be page-aligned.
2968          * But our b_pages[] array *IS* page aligned.
2969          *
2970          * block sizes less then DEV_BSIZE (usually 512) are not
2971          * supported due to the page granularity bits (m->valid,
2972          * m->dirty, etc...).
2973          *
2974          * See man buf(9) for more information
2975          */
2976         flags = (bp->b_flags & B_NOREUSE) != 0 ? VPR_NOREUSE : 0;
2977         obj = bp->b_bufobj->bo_object;
2978         resid = bp->b_bufsize;
2979         poffset = bp->b_offset & PAGE_MASK;
2980         VM_OBJECT_WLOCK(obj);
2981         for (i = 0; i < bp->b_npages; i++) {
2982                 m = bp->b_pages[i];
2983                 if (m == bogus_page)
2984                         panic("vfs_vmio_invalidate: Unexpected bogus page.");
2985                 bp->b_pages[i] = NULL;
2986
2987                 presid = resid > (PAGE_SIZE - poffset) ?
2988                     (PAGE_SIZE - poffset) : resid;
2989                 KASSERT(presid >= 0, ("brelse: extra page"));
2990                 vm_page_busy_acquire(m, VM_ALLOC_SBUSY);
2991                 if (pmap_page_wired_mappings(m) == 0)
2992                         vm_page_set_invalid(m, poffset, presid);
2993                 vm_page_sunbusy(m);
2994                 vm_page_release_locked(m, flags);
2995                 resid -= presid;
2996                 poffset = 0;
2997         }
2998         VM_OBJECT_WUNLOCK(obj);
2999         bp->b_npages = 0;
3000 }
3001
3002 /*
3003  * Page-granular truncation of an existing VMIO buffer.
3004  */
3005 static void
3006 vfs_vmio_truncate(struct buf *bp, int desiredpages)
3007 {
3008         vm_object_t obj;
3009         vm_page_t m;
3010         int flags, i;
3011
3012         if (bp->b_npages == desiredpages)
3013                 return;
3014
3015         if (buf_mapped(bp)) {
3016                 BUF_CHECK_MAPPED(bp);
3017                 pmap_qremove((vm_offset_t)trunc_page((vm_offset_t)bp->b_data) +
3018                     (desiredpages << PAGE_SHIFT), bp->b_npages - desiredpages);
3019         } else
3020                 BUF_CHECK_UNMAPPED(bp);
3021
3022         /*
3023          * The object lock is needed only if we will attempt to free pages.
3024          */
3025         flags = (bp->b_flags & B_NOREUSE) != 0 ? VPR_NOREUSE : 0;
3026         if ((bp->b_flags & B_DIRECT) != 0) {
3027                 flags |= VPR_TRYFREE;
3028                 obj = bp->b_bufobj->bo_object;
3029                 VM_OBJECT_WLOCK(obj);
3030         } else {
3031                 obj = NULL;
3032         }
3033         for (i = desiredpages; i < bp->b_npages; i++) {
3034                 m = bp->b_pages[i];
3035                 KASSERT(m != bogus_page, ("allocbuf: bogus page found"));
3036                 bp->b_pages[i] = NULL;
3037                 if (obj != NULL)
3038                         vm_page_release_locked(m, flags);
3039                 else
3040                         vm_page_release(m, flags);
3041         }
3042         if (obj != NULL)
3043                 VM_OBJECT_WUNLOCK(obj);
3044         bp->b_npages = desiredpages;
3045 }
3046
3047 /*
3048  * Byte granular extension of VMIO buffers.
3049  */
3050 static void
3051 vfs_vmio_extend(struct buf *bp, int desiredpages, int size)
3052 {
3053         /*
3054          * We are growing the buffer, possibly in a
3055          * byte-granular fashion.
3056          */
3057         vm_object_t obj;
3058         vm_offset_t toff;
3059         vm_offset_t tinc;
3060         vm_page_t m;
3061
3062         /*
3063          * Step 1, bring in the VM pages from the object, allocating
3064          * them if necessary.  We must clear B_CACHE if these pages
3065          * are not valid for the range covered by the buffer.
3066          */
3067         obj = bp->b_bufobj->bo_object;
3068         if (bp->b_npages < desiredpages) {
3069                 KASSERT(desiredpages <= atop(maxbcachebuf),
3070                     ("vfs_vmio_extend past maxbcachebuf %p %d %u",
3071                     bp, desiredpages, maxbcachebuf));
3072
3073                 /*
3074                  * We must allocate system pages since blocking
3075                  * here could interfere with paging I/O, no
3076                  * matter which process we are.
3077                  *
3078                  * Only exclusive busy can be tested here.
3079                  * Blocking on shared busy might lead to
3080                  * deadlocks once allocbuf() is called after
3081                  * pages are vfs_busy_pages().
3082                  */
3083                 (void)vm_page_grab_pages_unlocked(obj,
3084                     OFF_TO_IDX(bp->b_offset) + bp->b_npages,
3085                     VM_ALLOC_SYSTEM | VM_ALLOC_IGN_SBUSY |
3086                     VM_ALLOC_NOBUSY | VM_ALLOC_WIRED,
3087                     &bp->b_pages[bp->b_npages], desiredpages - bp->b_npages);
3088                 bp->b_npages = desiredpages;
3089         }
3090
3091         /*
3092          * Step 2.  We've loaded the pages into the buffer,
3093          * we have to figure out if we can still have B_CACHE
3094          * set.  Note that B_CACHE is set according to the
3095          * byte-granular range ( bcount and size ), not the
3096          * aligned range ( newbsize ).
3097          *
3098          * The VM test is against m->valid, which is DEV_BSIZE
3099          * aligned.  Needless to say, the validity of the data
3100          * needs to also be DEV_BSIZE aligned.  Note that this
3101          * fails with NFS if the server or some other client
3102          * extends the file's EOF.  If our buffer is resized,
3103          * B_CACHE may remain set! XXX
3104          */
3105         toff = bp->b_bcount;
3106         tinc = PAGE_SIZE - ((bp->b_offset + toff) & PAGE_MASK);
3107         while ((bp->b_flags & B_CACHE) && toff < size) {
3108                 vm_pindex_t pi;
3109
3110                 if (tinc > (size - toff))
3111                         tinc = size - toff;
3112                 pi = ((bp->b_offset & PAGE_MASK) + toff) >> PAGE_SHIFT;
3113                 m = bp->b_pages[pi];
3114                 vfs_buf_test_cache(bp, bp->b_offset, toff, tinc, m);
3115                 toff += tinc;
3116                 tinc = PAGE_SIZE;
3117         }
3118
3119         /*
3120          * Step 3, fixup the KVA pmap.
3121          */
3122         if (buf_mapped(bp))
3123                 bpmap_qenter(bp);
3124         else
3125                 BUF_CHECK_UNMAPPED(bp);
3126 }
3127
3128 /*
3129  * Check to see if a block at a particular lbn is available for a clustered
3130  * write.
3131  */
3132 static int
3133 vfs_bio_clcheck(struct vnode *vp, int size, daddr_t lblkno, daddr_t blkno)
3134 {
3135         struct buf *bpa;
3136         int match;
3137
3138         match = 0;
3139
3140         /* If the buf isn't in core skip it */
3141         if ((bpa = gbincore(&vp->v_bufobj, lblkno)) == NULL)
3142                 return (0);
3143
3144         /* If the buf is busy we don't want to wait for it */
3145         if (BUF_LOCK(bpa, LK_EXCLUSIVE | LK_NOWAIT, NULL) != 0)
3146                 return (0);
3147
3148         /* Only cluster with valid clusterable delayed write buffers */
3149         if ((bpa->b_flags & (B_DELWRI | B_CLUSTEROK | B_INVAL)) !=
3150             (B_DELWRI | B_CLUSTEROK))
3151                 goto done;
3152
3153         if (bpa->b_bufsize != size)
3154                 goto done;
3155
3156         /*
3157          * Check to see if it is in the expected place on disk and that the
3158          * block has been mapped.
3159          */
3160         if ((bpa->b_blkno != bpa->b_lblkno) && (bpa->b_blkno == blkno))
3161                 match = 1;
3162 done:
3163         BUF_UNLOCK(bpa);
3164         return (match);
3165 }
3166
3167 /*
3168  *      vfs_bio_awrite:
3169  *
3170  *      Implement clustered async writes for clearing out B_DELWRI buffers.
3171  *      This is much better then the old way of writing only one buffer at
3172  *      a time.  Note that we may not be presented with the buffers in the
3173  *      correct order, so we search for the cluster in both directions.
3174  */
3175 int
3176 vfs_bio_awrite(struct buf *bp)
3177 {
3178         struct bufobj *bo;
3179         int i;
3180         int j;
3181         daddr_t lblkno = bp->b_lblkno;
3182         struct vnode *vp = bp->b_vp;
3183         int ncl;
3184         int nwritten;
3185         int size;
3186         int maxcl;
3187         int gbflags;
3188
3189         bo = &vp->v_bufobj;
3190         gbflags = (bp->b_data == unmapped_buf) ? GB_UNMAPPED : 0;
3191         /*
3192          * right now we support clustered writing only to regular files.  If
3193          * we find a clusterable block we could be in the middle of a cluster
3194          * rather then at the beginning.
3195          */
3196         if ((vp->v_type == VREG) &&
3197             (vp->v_mount != 0) && /* Only on nodes that have the size info */
3198             (bp->b_flags & (B_CLUSTEROK | B_INVAL)) == B_CLUSTEROK) {
3199                 size = vp->v_mount->mnt_stat.f_iosize;
3200                 maxcl = maxphys / size;
3201
3202                 BO_RLOCK(bo);
3203                 for (i = 1; i < maxcl; i++)
3204                         if (vfs_bio_clcheck(vp, size, lblkno + i,
3205                             bp->b_blkno + ((i * size) >> DEV_BSHIFT)) == 0)
3206                                 break;
3207
3208                 for (j = 1; i + j <= maxcl && j <= lblkno; j++)
3209                         if (vfs_bio_clcheck(vp, size, lblkno - j,
3210                             bp->b_blkno - ((j * size) >> DEV_BSHIFT)) == 0)
3211                                 break;
3212                 BO_RUNLOCK(bo);
3213                 --j;
3214                 ncl = i + j;
3215                 /*
3216                  * this is a possible cluster write
3217                  */
3218                 if (ncl != 1) {
3219                         BUF_UNLOCK(bp);
3220                         nwritten = cluster_wbuild(vp, size, lblkno - j, ncl,
3221                             gbflags);
3222                         return (nwritten);
3223                 }
3224         }
3225         bremfree(bp);
3226         bp->b_flags |= B_ASYNC;
3227         /*
3228          * default (old) behavior, writing out only one block
3229          *
3230          * XXX returns b_bufsize instead of b_bcount for nwritten?
3231          */
3232         nwritten = bp->b_bufsize;
3233         (void) bwrite(bp);
3234
3235         return (nwritten);
3236 }
3237
3238 /*
3239  *      getnewbuf_kva:
3240  *
3241  *      Allocate KVA for an empty buf header according to gbflags.
3242  */
3243 static int
3244 getnewbuf_kva(struct buf *bp, int gbflags, int maxsize)
3245 {
3246
3247         if ((gbflags & (GB_UNMAPPED | GB_KVAALLOC)) != GB_UNMAPPED) {
3248                 /*
3249                  * In order to keep fragmentation sane we only allocate kva
3250                  * in BKVASIZE chunks.  XXX with vmem we can do page size.
3251                  */
3252                 maxsize = (maxsize + BKVAMASK) & ~BKVAMASK;
3253
3254                 if (maxsize != bp->b_kvasize &&
3255                     bufkva_alloc(bp, maxsize, gbflags))
3256                         return (ENOSPC);
3257         }
3258         return (0);
3259 }
3260
3261 /*
3262  *      getnewbuf:
3263  *
3264  *      Find and initialize a new buffer header, freeing up existing buffers
3265  *      in the bufqueues as necessary.  The new buffer is returned locked.
3266  *
3267  *      We block if:
3268  *              We have insufficient buffer headers
3269  *              We have insufficient buffer space
3270  *              buffer_arena is too fragmented ( space reservation fails )
3271  *              If we have to flush dirty buffers ( but we try to avoid this )
3272  *
3273  *      The caller is responsible for releasing the reserved bufspace after
3274  *      allocbuf() is called.
3275  */
3276 static struct buf *
3277 getnewbuf(struct vnode *vp, int slpflag, int slptimeo, int maxsize, int gbflags)
3278 {
3279         struct bufdomain *bd;
3280         struct buf *bp;
3281         bool metadata, reserved;
3282
3283         bp = NULL;
3284         KASSERT((gbflags & (GB_UNMAPPED | GB_KVAALLOC)) != GB_KVAALLOC,
3285             ("GB_KVAALLOC only makes sense with GB_UNMAPPED"));
3286         if (!unmapped_buf_allowed)
3287                 gbflags &= ~(GB_UNMAPPED | GB_KVAALLOC);
3288
3289         if (vp == NULL || (vp->v_vflag & (VV_MD | VV_SYSTEM)) != 0 ||
3290             vp->v_type == VCHR)
3291                 metadata = true;
3292         else
3293                 metadata = false;
3294         if (vp == NULL)
3295                 bd = &bdomain[0];
3296         else
3297                 bd = &bdomain[vp->v_bufobj.bo_domain];
3298
3299         counter_u64_add(getnewbufcalls, 1);
3300         reserved = false;
3301         do {
3302                 if (reserved == false &&
3303                     bufspace_reserve(bd, maxsize, metadata) != 0) {
3304                         counter_u64_add(getnewbufrestarts, 1);
3305                         continue;
3306                 }
3307                 reserved = true;
3308                 if ((bp = buf_alloc(bd)) == NULL) {
3309                         counter_u64_add(getnewbufrestarts, 1);
3310                         continue;
3311                 }
3312                 if (getnewbuf_kva(bp, gbflags, maxsize) == 0)
3313                         return (bp);
3314                 break;
3315         } while (buf_recycle(bd, false) == 0);
3316
3317         if (reserved)
3318                 bufspace_release(bd, maxsize);
3319         if (bp != NULL) {
3320                 bp->b_flags |= B_INVAL;
3321                 brelse(bp);
3322         }
3323         bufspace_wait(bd, vp, gbflags, slpflag, slptimeo);
3324
3325         return (NULL);
3326 }
3327
3328 /*
3329  *      buf_daemon:
3330  *
3331  *      buffer flushing daemon.  Buffers are normally flushed by the
3332  *      update daemon but if it cannot keep up this process starts to
3333  *      take the load in an attempt to prevent getnewbuf() from blocking.
3334  */
3335 static struct kproc_desc buf_kp = {
3336         "bufdaemon",
3337         buf_daemon,
3338         &bufdaemonproc
3339 };
3340 SYSINIT(bufdaemon, SI_SUB_KTHREAD_BUF, SI_ORDER_FIRST, kproc_start, &buf_kp);
3341
3342 static int
3343 buf_flush(struct vnode *vp, struct bufdomain *bd, int target)
3344 {
3345         int flushed;
3346
3347         flushed = flushbufqueues(vp, bd, target, 0);
3348         if (flushed == 0) {
3349                 /*
3350                  * Could not find any buffers without rollback
3351                  * dependencies, so just write the first one
3352                  * in the hopes of eventually making progress.
3353                  */
3354                 if (vp != NULL && target > 2)
3355                         target /= 2;
3356                 flushbufqueues(vp, bd, target, 1);
3357         }
3358         return (flushed);
3359 }
3360
3361 static void
3362 buf_daemon()
3363 {
3364         struct bufdomain *bd;
3365         int speedupreq;
3366         int lodirty;
3367         int i;
3368
3369         /*
3370          * This process needs to be suspended prior to shutdown sync.
3371          */
3372         EVENTHANDLER_REGISTER(shutdown_pre_sync, kthread_shutdown, curthread,
3373             SHUTDOWN_PRI_LAST + 100);
3374
3375         /*
3376          * Start the buf clean daemons as children threads.
3377          */
3378         for (i = 0 ; i < buf_domains; i++) {
3379                 int error;
3380
3381                 error = kthread_add((void (*)(void *))bufspace_daemon,
3382                     &bdomain[i], curproc, NULL, 0, 0, "bufspacedaemon-%d", i);
3383                 if (error)
3384                         panic("error %d spawning bufspace daemon", error);
3385         }
3386
3387         /*
3388          * This process is allowed to take the buffer cache to the limit
3389          */
3390         curthread->td_pflags |= TDP_NORUNNINGBUF | TDP_BUFNEED;
3391         mtx_lock(&bdlock);
3392         for (;;) {
3393                 bd_request = 0;
3394                 mtx_unlock(&bdlock);
3395
3396                 kthread_suspend_check();
3397
3398                 /*
3399                  * Save speedupreq for this pass and reset to capture new
3400                  * requests.
3401                  */
3402                 speedupreq = bd_speedupreq;
3403                 bd_speedupreq = 0;
3404
3405                 /*
3406                  * Flush each domain sequentially according to its level and
3407                  * the speedup request.
3408                  */
3409                 for (i = 0; i < buf_domains; i++) {
3410                         bd = &bdomain[i];
3411                         if (speedupreq)
3412                                 lodirty = bd->bd_numdirtybuffers / 2;
3413                         else
3414                                 lodirty = bd->bd_lodirtybuffers;
3415                         while (bd->bd_numdirtybuffers > lodirty) {
3416                                 if (buf_flush(NULL, bd,
3417                                     bd->bd_numdirtybuffers - lodirty) == 0)
3418                                         break;
3419                                 kern_yield(PRI_USER);
3420                         }
3421                 }
3422
3423                 /*
3424                  * Only clear bd_request if we have reached our low water
3425                  * mark.  The buf_daemon normally waits 1 second and
3426                  * then incrementally flushes any dirty buffers that have
3427                  * built up, within reason.
3428                  *
3429                  * If we were unable to hit our low water mark and couldn't
3430                  * find any flushable buffers, we sleep for a short period
3431                  * to avoid endless loops on unlockable buffers.
3432                  */
3433                 mtx_lock(&bdlock);
3434                 if (!BIT_EMPTY(BUF_DOMAINS, &bdlodirty)) {
3435                         /*
3436                          * We reached our low water mark, reset the
3437                          * request and sleep until we are needed again.
3438                          * The sleep is just so the suspend code works.
3439                          */
3440                         bd_request = 0;
3441                         /*
3442                          * Do an extra wakeup in case dirty threshold
3443                          * changed via sysctl and the explicit transition
3444                          * out of shortfall was missed.
3445                          */
3446                         bdirtywakeup();
3447                         if (runningbufspace <= lorunningspace)
3448                                 runningwakeup();
3449                         msleep(&bd_request, &bdlock, PVM, "psleep", hz);
3450                 } else {
3451                         /*
3452                          * We couldn't find any flushable dirty buffers but
3453                          * still have too many dirty buffers, we
3454                          * have to sleep and try again.  (rare)
3455                          */
3456                         msleep(&bd_request, &bdlock, PVM, "qsleep", hz / 10);
3457                 }
3458         }
3459 }
3460
3461 /*
3462  *      flushbufqueues:
3463  *
3464  *      Try to flush a buffer in the dirty queue.  We must be careful to
3465  *      free up B_INVAL buffers instead of write them, which NFS is
3466  *      particularly sensitive to.
3467  */
3468 static int flushwithdeps = 0;
3469 SYSCTL_INT(_vfs, OID_AUTO, flushwithdeps, CTLFLAG_RW | CTLFLAG_STATS,
3470     &flushwithdeps, 0,
3471     "Number of buffers flushed with dependecies that require rollbacks");
3472
3473 static int
3474 flushbufqueues(struct vnode *lvp, struct bufdomain *bd, int target,
3475     int flushdeps)
3476 {
3477         struct bufqueue *bq;
3478         struct buf *sentinel;
3479         struct vnode *vp;
3480         struct mount *mp;
3481         struct buf *bp;
3482         int hasdeps;
3483         int flushed;
3484         int error;
3485         bool unlock;
3486
3487         flushed = 0;
3488         bq = &bd->bd_dirtyq;
3489         bp = NULL;
3490         sentinel = malloc(sizeof(struct buf), M_TEMP, M_WAITOK | M_ZERO);
3491         sentinel->b_qindex = QUEUE_SENTINEL;
3492         BQ_LOCK(bq);
3493         TAILQ_INSERT_HEAD(&bq->bq_queue, sentinel, b_freelist);
3494         BQ_UNLOCK(bq);
3495         while (flushed != target) {
3496                 maybe_yield();
3497                 BQ_LOCK(bq);
3498                 bp = TAILQ_NEXT(sentinel, b_freelist);
3499                 if (bp != NULL) {
3500                         TAILQ_REMOVE(&bq->bq_queue, sentinel, b_freelist);
3501                         TAILQ_INSERT_AFTER(&bq->bq_queue, bp, sentinel,
3502                             b_freelist);
3503                 } else {
3504                         BQ_UNLOCK(bq);
3505                         break;
3506                 }
3507                 /*
3508                  * Skip sentinels inserted by other invocations of the
3509                  * flushbufqueues(), taking care to not reorder them.
3510                  *
3511                  * Only flush the buffers that belong to the
3512                  * vnode locked by the curthread.
3513                  */
3514                 if (bp->b_qindex == QUEUE_SENTINEL || (lvp != NULL &&
3515                     bp->b_vp != lvp)) {
3516                         BQ_UNLOCK(bq);
3517                         continue;
3518                 }
3519                 error = BUF_LOCK(bp, LK_EXCLUSIVE | LK_NOWAIT, NULL);
3520                 BQ_UNLOCK(bq);
3521                 if (error != 0)
3522                         continue;
3523
3524                 /*
3525                  * BKGRDINPROG can only be set with the buf and bufobj
3526                  * locks both held.  We tolerate a race to clear it here.
3527                  */
3528                 if ((bp->b_vflags & BV_BKGRDINPROG) != 0 ||
3529                     (bp->b_flags & B_DELWRI) == 0) {
3530                         BUF_UNLOCK(bp);
3531                         continue;
3532                 }
3533                 if (bp->b_flags & B_INVAL) {
3534                         bremfreef(bp);
3535                         brelse(bp);
3536                         flushed++;
3537                         continue;
3538                 }
3539
3540                 if (!LIST_EMPTY(&bp->b_dep) && buf_countdeps(bp, 0)) {
3541                         if (flushdeps == 0) {
3542                                 BUF_UNLOCK(bp);
3543                                 continue;
3544                         }
3545                         hasdeps = 1;
3546                 } else
3547                         hasdeps = 0;
3548                 /*
3549                  * We must hold the lock on a vnode before writing
3550                  * one of its buffers. Otherwise we may confuse, or
3551                  * in the case of a snapshot vnode, deadlock the
3552                  * system.
3553                  *
3554                  * The lock order here is the reverse of the normal
3555                  * of vnode followed by buf lock.  This is ok because
3556                  * the NOWAIT will prevent deadlock.
3557                  */
3558                 vp = bp->b_vp;
3559                 if (vn_start_write(vp, &mp, V_NOWAIT) != 0) {
3560                         BUF_UNLOCK(bp);
3561                         continue;
3562                 }
3563                 if (lvp == NULL) {
3564                         unlock = true;
3565                         error = vn_lock(vp, LK_EXCLUSIVE | LK_NOWAIT);
3566                 } else {
3567                         ASSERT_VOP_LOCKED(vp, "getbuf");
3568                         unlock = false;
3569                         error = VOP_ISLOCKED(vp) == LK_EXCLUSIVE ? 0 :
3570                             vn_lock(vp, LK_TRYUPGRADE);
3571                 }
3572                 if (error == 0) {
3573                         CTR3(KTR_BUF, "flushbufqueue(%p) vp %p flags %X",
3574                             bp, bp->b_vp, bp->b_flags);
3575                         if (curproc == bufdaemonproc) {
3576                                 vfs_bio_awrite(bp);
3577                         } else {
3578                                 bremfree(bp);
3579                                 bwrite(bp);
3580                                 counter_u64_add(notbufdflushes, 1);
3581                         }
3582                         vn_finished_write(mp);
3583                         if (unlock)
3584                                 VOP_UNLOCK(vp);
3585                         flushwithdeps += hasdeps;
3586                         flushed++;
3587
3588                         /*
3589                          * Sleeping on runningbufspace while holding
3590                          * vnode lock leads to deadlock.
3591                          */
3592                         if (curproc == bufdaemonproc &&
3593                             runningbufspace > hirunningspace)
3594                                 waitrunningbufspace();
3595                         continue;
3596                 }
3597                 vn_finished_write(mp);
3598                 BUF_UNLOCK(bp);
3599         }
3600         BQ_LOCK(bq);
3601         TAILQ_REMOVE(&bq->bq_queue, sentinel, b_freelist);
3602         BQ_UNLOCK(bq);
3603         free(sentinel, M_TEMP);
3604         return (flushed);
3605 }
3606
3607 /*
3608  * Check to see if a block is currently memory resident.
3609  */
3610 struct buf *
3611 incore(struct bufobj *bo, daddr_t blkno)
3612 {
3613         return (gbincore_unlocked(bo, blkno));
3614 }
3615
3616 /*
3617  * Returns true if no I/O is needed to access the
3618  * associated VM object.  This is like incore except
3619  * it also hunts around in the VM system for the data.
3620  */
3621 bool
3622 inmem(struct vnode * vp, daddr_t blkno)
3623 {
3624         vm_object_t obj;
3625         vm_offset_t toff, tinc, size;
3626         vm_page_t m, n;
3627         vm_ooffset_t off;
3628         int valid;
3629
3630         ASSERT_VOP_LOCKED(vp, "inmem");
3631
3632         if (incore(&vp->v_bufobj, blkno))
3633                 return (true);
3634         if (vp->v_mount == NULL)
3635                 return (false);
3636         obj = vp->v_object;
3637         if (obj == NULL)
3638                 return (false);
3639
3640         size = PAGE_SIZE;
3641         if (size > vp->v_mount->mnt_stat.f_iosize)
3642                 size = vp->v_mount->mnt_stat.f_iosize;
3643         off = (vm_ooffset_t)blkno * (vm_ooffset_t)vp->v_mount->mnt_stat.f_iosize;
3644
3645         for (toff = 0; toff < vp->v_mount->mnt_stat.f_iosize; toff += tinc) {
3646                 m = vm_page_lookup_unlocked(obj, OFF_TO_IDX(off + toff));
3647 recheck:
3648                 if (m == NULL)
3649                         return (false);
3650
3651                 tinc = size;
3652                 if (tinc > PAGE_SIZE - ((toff + off) & PAGE_MASK))
3653                         tinc = PAGE_SIZE - ((toff + off) & PAGE_MASK);
3654                 /*
3655                  * Consider page validity only if page mapping didn't change
3656                  * during the check.
3657                  */
3658                 valid = vm_page_is_valid(m,
3659                     (vm_offset_t)((toff + off) & PAGE_MASK), tinc);
3660                 n = vm_page_lookup_unlocked(obj, OFF_TO_IDX(off + toff));
3661                 if (m != n) {
3662                         m = n;
3663                         goto recheck;
3664                 }
3665                 if (!valid)
3666                         return (false);
3667         }
3668         return (true);
3669 }
3670
3671 /*
3672  * Set the dirty range for a buffer based on the status of the dirty
3673  * bits in the pages comprising the buffer.  The range is limited
3674  * to the size of the buffer.
3675  *
3676  * Tell the VM system that the pages associated with this buffer
3677  * are clean.  This is used for delayed writes where the data is
3678  * going to go to disk eventually without additional VM intevention.
3679  *
3680  * Note that while we only really need to clean through to b_bcount, we
3681  * just go ahead and clean through to b_bufsize.
3682  */
3683 static void
3684 vfs_clean_pages_dirty_buf(struct buf *bp)
3685 {
3686         vm_ooffset_t foff, noff, eoff;
3687         vm_page_t m;
3688         int i;
3689
3690         if ((bp->b_flags & B_VMIO) == 0 || bp->b_bufsize == 0)
3691                 return;
3692
3693         foff = bp->b_offset;
3694         KASSERT(bp->b_offset != NOOFFSET,
3695             ("vfs_clean_pages_dirty_buf: no buffer offset"));
3696
3697         vfs_busy_pages_acquire(bp);
3698         vfs_setdirty_range(bp);
3699         for (i = 0; i < bp->b_npages; i++) {
3700                 noff = (foff + PAGE_SIZE) & ~(off_t)PAGE_MASK;
3701                 eoff = noff;
3702                 if (eoff > bp->b_offset + bp->b_bufsize)
3703                         eoff = bp->b_offset + bp->b_bufsize;
3704                 m = bp->b_pages[i];
3705                 vfs_page_set_validclean(bp, foff, m);
3706                 /* vm_page_clear_dirty(m, foff & PAGE_MASK, eoff - foff); */
3707                 foff = noff;
3708         }
3709         vfs_busy_pages_release(bp);
3710 }
3711
3712 static void
3713 vfs_setdirty_range(struct buf *bp)
3714 {
3715         vm_offset_t boffset;
3716         vm_offset_t eoffset;
3717         int i;
3718
3719         /*
3720          * test the pages to see if they have been modified directly
3721          * by users through the VM system.
3722          */
3723         for (i = 0; i < bp->b_npages; i++)
3724                 vm_page_test_dirty(bp->b_pages[i]);
3725
3726         /*
3727          * Calculate the encompassing dirty range, boffset and eoffset,
3728          * (eoffset - boffset) bytes.
3729          */
3730
3731         for (i = 0; i < bp->b_npages; i++) {
3732                 if (bp->b_pages[i]->dirty)
3733                         break;
3734         }
3735         boffset = (i << PAGE_SHIFT) - (bp->b_offset & PAGE_MASK);
3736
3737         for (i = bp->b_npages - 1; i >= 0; --i) {
3738                 if (bp->b_pages[i]->dirty) {
3739                         break;
3740                 }
3741         }
3742         eoffset = ((i + 1) << PAGE_SHIFT) - (bp->b_offset & PAGE_MASK);
3743
3744         /*
3745          * Fit it to the buffer.
3746          */
3747
3748         if (eoffset > bp->b_bcount)
3749                 eoffset = bp->b_bcount;
3750
3751         /*
3752          * If we have a good dirty range, merge with the existing
3753          * dirty range.
3754          */
3755
3756         if (boffset < eoffset) {
3757                 if (bp->b_dirtyoff > boffset)
3758                         bp->b_dirtyoff = boffset;
3759                 if (bp->b_dirtyend < eoffset)
3760                         bp->b_dirtyend = eoffset;
3761         }
3762 }
3763
3764 /*
3765  * Allocate the KVA mapping for an existing buffer.
3766  * If an unmapped buffer is provided but a mapped buffer is requested, take
3767  * also care to properly setup mappings between pages and KVA.
3768  */
3769 static void
3770 bp_unmapped_get_kva(struct buf *bp, daddr_t blkno, int size, int gbflags)
3771 {
3772         int bsize, maxsize, need_mapping, need_kva;
3773         off_t offset;
3774
3775         need_mapping = bp->b_data == unmapped_buf &&
3776             (gbflags & GB_UNMAPPED) == 0;
3777         need_kva = bp->b_kvabase == unmapped_buf &&
3778             bp->b_data == unmapped_buf &&
3779             (gbflags & GB_KVAALLOC) != 0;
3780         if (!need_mapping && !need_kva)
3781                 return;
3782
3783         BUF_CHECK_UNMAPPED(bp);
3784
3785         if (need_mapping && bp->b_kvabase != unmapped_buf) {
3786                 /*
3787                  * Buffer is not mapped, but the KVA was already
3788                  * reserved at the time of the instantiation.  Use the
3789                  * allocated space.
3790                  */
3791                 goto has_addr;
3792         }
3793
3794         /*
3795          * Calculate the amount of the address space we would reserve
3796          * if the buffer was mapped.
3797          */
3798         bsize = vn_isdisk(bp->b_vp) ? DEV_BSIZE : bp->b_bufobj->bo_bsize;
3799         KASSERT(bsize != 0, ("bsize == 0, check bo->bo_bsize"));
3800         offset = blkno * bsize;
3801         maxsize = size + (offset & PAGE_MASK);
3802         maxsize = imax(maxsize, bsize);
3803
3804         while (bufkva_alloc(bp, maxsize, gbflags) != 0) {
3805                 if ((gbflags & GB_NOWAIT_BD) != 0) {
3806                         /*
3807                          * XXXKIB: defragmentation cannot
3808                          * succeed, not sure what else to do.
3809                          */
3810                         panic("GB_NOWAIT_BD and GB_UNMAPPED %p", bp);
3811                 }
3812                 counter_u64_add(mappingrestarts, 1);
3813                 bufspace_wait(bufdomain(bp), bp->b_vp, gbflags, 0, 0);
3814         }
3815 has_addr:
3816         if (need_mapping) {
3817                 /* b_offset is handled by bpmap_qenter. */
3818                 bp->b_data = bp->b_kvabase;
3819                 BUF_CHECK_MAPPED(bp);
3820                 bpmap_qenter(bp);
3821         }
3822 }
3823
3824 struct buf *
3825 getblk(struct vnode *vp, daddr_t blkno, int size, int slpflag, int slptimeo,
3826     int flags)
3827 {
3828         struct buf *bp;
3829         int error;
3830
3831         error = getblkx(vp, blkno, blkno, size, slpflag, slptimeo, flags, &bp);
3832         if (error != 0)
3833                 return (NULL);
3834         return (bp);
3835 }
3836
3837 /*
3838  *      getblkx:
3839  *
3840  *      Get a block given a specified block and offset into a file/device.
3841  *      The buffers B_DONE bit will be cleared on return, making it almost
3842  *      ready for an I/O initiation.  B_INVAL may or may not be set on
3843  *      return.  The caller should clear B_INVAL prior to initiating a
3844  *      READ.
3845  *
3846  *      For a non-VMIO buffer, B_CACHE is set to the opposite of B_INVAL for
3847  *      an existing buffer.
3848  *
3849  *      For a VMIO buffer, B_CACHE is modified according to the backing VM.
3850  *      If getblk()ing a previously 0-sized invalid buffer, B_CACHE is set
3851  *      and then cleared based on the backing VM.  If the previous buffer is
3852  *      non-0-sized but invalid, B_CACHE will be cleared.
3853  *
3854  *      If getblk() must create a new buffer, the new buffer is returned with
3855  *      both B_INVAL and B_CACHE clear unless it is a VMIO buffer, in which
3856  *      case it is returned with B_INVAL clear and B_CACHE set based on the
3857  *      backing VM.
3858  *
3859  *      getblk() also forces a bwrite() for any B_DELWRI buffer whose
3860  *      B_CACHE bit is clear.
3861  *
3862  *      What this means, basically, is that the caller should use B_CACHE to
3863  *      determine whether the buffer is fully valid or not and should clear
3864  *      B_INVAL prior to issuing a read.  If the caller intends to validate
3865  *      the buffer by loading its data area with something, the caller needs
3866  *      to clear B_INVAL.  If the caller does this without issuing an I/O,
3867  *      the caller should set B_CACHE ( as an optimization ), else the caller
3868  *      should issue the I/O and biodone() will set B_CACHE if the I/O was
3869  *      a write attempt or if it was a successful read.  If the caller
3870  *      intends to issue a READ, the caller must clear B_INVAL and BIO_ERROR
3871  *      prior to issuing the READ.  biodone() will *not* clear B_INVAL.
3872  *
3873  *      The blkno parameter is the logical block being requested. Normally
3874  *      the mapping of logical block number to disk block address is done
3875  *      by calling VOP_BMAP(). However, if the mapping is already known, the
3876  *      disk block address can be passed using the dblkno parameter. If the
3877  *      disk block address is not known, then the same value should be passed
3878  *      for blkno and dblkno.
3879  */
3880 int
3881 getblkx(struct vnode *vp, daddr_t blkno, daddr_t dblkno, int size, int slpflag,
3882     int slptimeo, int flags, struct buf **bpp)
3883 {
3884         struct buf *bp;
3885         struct bufobj *bo;
3886         daddr_t d_blkno;
3887         int bsize, error, maxsize, vmio;
3888         off_t offset;
3889
3890         CTR3(KTR_BUF, "getblk(%p, %ld, %d)", vp, (long)blkno, size);
3891         KASSERT((flags & (GB_UNMAPPED | GB_KVAALLOC)) != GB_KVAALLOC,
3892             ("GB_KVAALLOC only makes sense with GB_UNMAPPED"));
3893         ASSERT_VOP_LOCKED(vp, "getblk");
3894         if (size > maxbcachebuf)
3895                 panic("getblk: size(%d) > maxbcachebuf(%d)\n", size,
3896                     maxbcachebuf);
3897         if (!unmapped_buf_allowed)
3898                 flags &= ~(GB_UNMAPPED | GB_KVAALLOC);
3899
3900         bo = &vp->v_bufobj;
3901         d_blkno = dblkno;
3902
3903         /* Attempt lockless lookup first. */
3904         bp = gbincore_unlocked(bo, blkno);
3905         if (bp == NULL) {
3906                 /*
3907                  * With GB_NOCREAT we must be sure about not finding the buffer
3908                  * as it may have been reassigned during unlocked lookup.
3909                  */
3910                 if ((flags & GB_NOCREAT) != 0)
3911                         goto loop;
3912                 goto newbuf_unlocked;
3913         }
3914
3915         error = BUF_TIMELOCK(bp, LK_EXCLUSIVE | LK_NOWAIT, NULL, "getblku", 0,
3916             0);
3917         if (error != 0)
3918                 goto loop;
3919
3920         /* Verify buf identify has not changed since lookup. */
3921         if (bp->b_bufobj == bo && bp->b_lblkno == blkno)
3922                 goto foundbuf_fastpath;
3923
3924         /* It changed, fallback to locked lookup. */
3925         BUF_UNLOCK_RAW(bp);
3926
3927 loop:
3928         BO_RLOCK(bo);
3929         bp = gbincore(bo, blkno);
3930         if (bp != NULL) {
3931                 int lockflags;
3932
3933                 /*
3934                  * Buffer is in-core.  If the buffer is not busy nor managed,
3935                  * it must be on a queue.
3936                  */
3937                 lockflags = LK_EXCLUSIVE | LK_INTERLOCK |
3938                     ((flags & GB_LOCK_NOWAIT) ? LK_NOWAIT : LK_SLEEPFAIL);
3939
3940                 error = BUF_TIMELOCK(bp, lockflags,
3941                     BO_LOCKPTR(bo), "getblk", slpflag, slptimeo);
3942
3943                 /*
3944                  * If we slept and got the lock we have to restart in case
3945                  * the buffer changed identities.
3946                  */
3947                 if (error == ENOLCK)
3948                         goto loop;
3949                 /* We timed out or were interrupted. */
3950                 else if (error != 0)
3951                         return (error);
3952
3953 foundbuf_fastpath:
3954                 /* If recursed, assume caller knows the rules. */
3955                 if (BUF_LOCKRECURSED(bp))
3956                         goto end;
3957
3958                 /*
3959                  * The buffer is locked.  B_CACHE is cleared if the buffer is
3960                  * invalid.  Otherwise, for a non-VMIO buffer, B_CACHE is set
3961                  * and for a VMIO buffer B_CACHE is adjusted according to the
3962                  * backing VM cache.
3963                  */
3964                 if (bp->b_flags & B_INVAL)
3965                         bp->b_flags &= ~B_CACHE;
3966                 else if ((bp->b_flags & (B_VMIO | B_INVAL)) == 0)
3967                         bp->b_flags |= B_CACHE;
3968                 if (bp->b_flags & B_MANAGED)
3969                         MPASS(bp->b_qindex == QUEUE_NONE);
3970                 else
3971                         bremfree(bp);
3972
3973                 /*
3974                  * check for size inconsistencies for non-VMIO case.
3975                  */
3976                 if (bp->b_bcount != size) {
3977                         if ((bp->b_flags & B_VMIO) == 0 ||
3978                             (size > bp->b_kvasize)) {
3979                                 if (bp->b_flags & B_DELWRI) {
3980                                         bp->b_flags |= B_NOCACHE;
3981                                         bwrite(bp);
3982                                 } else {
3983                                         if (LIST_EMPTY(&bp->b_dep)) {
3984                                                 bp->b_flags |= B_RELBUF;
3985                                                 brelse(bp);
3986                                         } else {
3987                                                 bp->b_flags |= B_NOCACHE;
3988                                                 bwrite(bp);
3989                                         }
3990                                 }
3991                                 goto loop;
3992                         }
3993                 }
3994
3995                 /*
3996                  * Handle the case of unmapped buffer which should
3997                  * become mapped, or the buffer for which KVA
3998                  * reservation is requested.
3999                  */
4000                 bp_unmapped_get_kva(bp, blkno, size, flags);
4001
4002                 /*
4003                  * If the size is inconsistent in the VMIO case, we can resize
4004                  * the buffer.  This might lead to B_CACHE getting set or
4005                  * cleared.  If the size has not changed, B_CACHE remains
4006                  * unchanged from its previous state.
4007                  */
4008                 allocbuf(bp, size);
4009
4010                 KASSERT(bp->b_offset != NOOFFSET,
4011                     ("getblk: no buffer offset"));
4012
4013                 /*
4014                  * A buffer with B_DELWRI set and B_CACHE clear must
4015                  * be committed before we can return the buffer in
4016                  * order to prevent the caller from issuing a read
4017                  * ( due to B_CACHE not being set ) and overwriting
4018                  * it.
4019                  *
4020                  * Most callers, including NFS and FFS, need this to
4021                  * operate properly either because they assume they
4022                  * can issue a read if B_CACHE is not set, or because
4023                  * ( for example ) an uncached B_DELWRI might loop due
4024                  * to softupdates re-dirtying the buffer.  In the latter
4025                  * case, B_CACHE is set after the first write completes,
4026                  * preventing further loops.
4027                  * NOTE!  b*write() sets B_CACHE.  If we cleared B_CACHE
4028                  * above while extending the buffer, we cannot allow the
4029                  * buffer to remain with B_CACHE set after the write
4030                  * completes or it will represent a corrupt state.  To
4031                  * deal with this we set B_NOCACHE to scrap the buffer
4032                  * after the write.
4033                  *
4034                  * We might be able to do something fancy, like setting
4035                  * B_CACHE in bwrite() except if B_DELWRI is already set,
4036                  * so the below call doesn't set B_CACHE, but that gets real
4037                  * confusing.  This is much easier.
4038                  */
4039
4040                 if ((bp->b_flags & (B_CACHE|B_DELWRI)) == B_DELWRI) {
4041                         bp->b_flags |= B_NOCACHE;
4042                         bwrite(bp);
4043                         goto loop;
4044                 }
4045                 bp->b_flags &= ~B_DONE;
4046         } else {
4047                 /*
4048                  * Buffer is not in-core, create new buffer.  The buffer
4049                  * returned by getnewbuf() is locked.  Note that the returned
4050                  * buffer is also considered valid (not marked B_INVAL).
4051                  */
4052                 BO_RUNLOCK(bo);
4053 newbuf_unlocked:
4054                 /*
4055                  * If the user does not want us to create the buffer, bail out
4056                  * here.
4057                  */
4058                 if (flags & GB_NOCREAT)
4059                         return (EEXIST);
4060
4061                 bsize = vn_isdisk(vp) ? DEV_BSIZE : bo->bo_bsize;
4062                 KASSERT(bsize != 0, ("bsize == 0, check bo->bo_bsize"));
4063                 offset = blkno * bsize;
4064                 vmio = vp->v_object != NULL;
4065                 if (vmio) {
4066                         maxsize = size + (offset & PAGE_MASK);
4067                 } else {
4068                         maxsize = size;
4069                         /* Do not allow non-VMIO notmapped buffers. */
4070                         flags &= ~(GB_UNMAPPED | GB_KVAALLOC);
4071                 }
4072                 maxsize = imax(maxsize, bsize);
4073                 if ((flags & GB_NOSPARSE) != 0 && vmio &&
4074                     !vn_isdisk(vp)) {
4075                         error = VOP_BMAP(vp, blkno, NULL, &d_blkno, 0, 0);
4076                         KASSERT(error != EOPNOTSUPP,
4077                             ("GB_NOSPARSE from fs not supporting bmap, vp %p",
4078                             vp));
4079                         if (error != 0)
4080                                 return (error);
4081                         if (d_blkno == -1)
4082                                 return (EJUSTRETURN);
4083                 }
4084
4085                 bp = getnewbuf(vp, slpflag, slptimeo, maxsize, flags);
4086                 if (bp == NULL) {
4087                         if (slpflag || slptimeo)
4088                                 return (ETIMEDOUT);
4089                         /*
4090                          * XXX This is here until the sleep path is diagnosed
4091                          * enough to work under very low memory conditions.
4092                          *
4093                          * There's an issue on low memory, 4BSD+non-preempt
4094                          * systems (eg MIPS routers with 32MB RAM) where buffer
4095                          * exhaustion occurs without sleeping for buffer
4096                          * reclaimation.  This just sticks in a loop and
4097                          * constantly attempts to allocate a buffer, which
4098                          * hits exhaustion and tries to wakeup bufdaemon.
4099                          * This never happens because we never yield.
4100                          *
4101                          * The real solution is to identify and fix these cases
4102                          * so we aren't effectively busy-waiting in a loop
4103                          * until the reclaimation path has cycles to run.
4104                          */
4105                         kern_yield(PRI_USER);
4106                         goto loop;
4107                 }
4108
4109                 /*
4110                  * This code is used to make sure that a buffer is not
4111                  * created while the getnewbuf routine is blocked.
4112                  * This can be a problem whether the vnode is locked or not.
4113                  * If the buffer is created out from under us, we have to
4114                  * throw away the one we just created.
4115                  *
4116                  * Note: this must occur before we associate the buffer
4117                  * with the vp especially considering limitations in
4118                  * the splay tree implementation when dealing with duplicate
4119                  * lblkno's.
4120                  */
4121                 BO_LOCK(bo);
4122                 if (gbincore(bo, blkno)) {
4123                         BO_UNLOCK(bo);
4124                         bp->b_flags |= B_INVAL;
4125                         bufspace_release(bufdomain(bp), maxsize);
4126                         brelse(bp);
4127                         goto loop;
4128                 }
4129
4130                 /*
4131                  * Insert the buffer into the hash, so that it can
4132                  * be found by incore.
4133                  */
4134                 bp->b_lblkno = blkno;
4135                 bp->b_blkno = d_blkno;
4136                 bp->b_offset = offset;
4137                 bgetvp(vp, bp);
4138                 BO_UNLOCK(bo);
4139
4140                 /*
4141                  * set B_VMIO bit.  allocbuf() the buffer bigger.  Since the
4142                  * buffer size starts out as 0, B_CACHE will be set by
4143                  * allocbuf() for the VMIO case prior to it testing the
4144                  * backing store for validity.
4145                  */
4146
4147                 if (vmio) {
4148                         bp->b_flags |= B_VMIO;
4149                         KASSERT(vp->v_object == bp->b_bufobj->bo_object,
4150                             ("ARGH! different b_bufobj->bo_object %p %p %p\n",
4151                             bp, vp->v_object, bp->b_bufobj->bo_object));
4152                 } else {
4153                         bp->b_flags &= ~B_VMIO;
4154                         KASSERT(bp->b_bufobj->bo_object == NULL,
4155                             ("ARGH! has b_bufobj->bo_object %p %p\n",
4156                             bp, bp->b_bufobj->bo_object));
4157                         BUF_CHECK_MAPPED(bp);
4158                 }
4159
4160                 allocbuf(bp, size);
4161                 bufspace_release(bufdomain(bp), maxsize);
4162                 bp->b_flags &= ~B_DONE;
4163         }
4164         CTR4(KTR_BUF, "getblk(%p, %ld, %d) = %p", vp, (long)blkno, size, bp);
4165 end:
4166         buf_track(bp, __func__);
4167         KASSERT(bp->b_bufobj == bo,
4168             ("bp %p wrong b_bufobj %p should be %p", bp, bp->b_bufobj, bo));
4169         *bpp = bp;
4170         return (0);
4171 }
4172
4173 /*
4174  * Get an empty, disassociated buffer of given size.  The buffer is initially
4175  * set to B_INVAL.
4176  */
4177 struct buf *
4178 geteblk(int size, int flags)
4179 {
4180         struct buf *bp;
4181         int maxsize;
4182
4183         maxsize = (size + BKVAMASK) & ~BKVAMASK;
4184         while ((bp = getnewbuf(NULL, 0, 0, maxsize, flags)) == NULL) {
4185                 if ((flags & GB_NOWAIT_BD) &&
4186                     (curthread->td_pflags & TDP_BUFNEED) != 0)
4187                         return (NULL);
4188         }
4189         allocbuf(bp, size);
4190         bufspace_release(bufdomain(bp), maxsize);
4191         bp->b_flags |= B_INVAL; /* b_dep cleared by getnewbuf() */
4192         return (bp);
4193 }
4194
4195 /*
4196  * Truncate the backing store for a non-vmio buffer.
4197  */
4198 static void
4199 vfs_nonvmio_truncate(struct buf *bp, int newbsize)
4200 {
4201
4202         if (bp->b_flags & B_MALLOC) {
4203                 /*
4204                  * malloced buffers are not shrunk
4205                  */
4206                 if (newbsize == 0) {
4207                         bufmallocadjust(bp, 0);
4208                         free(bp->b_data, M_BIOBUF);
4209                         bp->b_data = bp->b_kvabase;
4210                         bp->b_flags &= ~B_MALLOC;
4211                 }
4212                 return;
4213         }
4214         vm_hold_free_pages(bp, newbsize);
4215         bufspace_adjust(bp, newbsize);
4216 }
4217
4218 /*
4219  * Extend the backing for a non-VMIO buffer.
4220  */
4221 static void
4222 vfs_nonvmio_extend(struct buf *bp, int newbsize)
4223 {
4224         caddr_t origbuf;
4225         int origbufsize;
4226
4227         /*
4228          * We only use malloced memory on the first allocation.
4229          * and revert to page-allocated memory when the buffer
4230          * grows.
4231          *
4232          * There is a potential smp race here that could lead
4233          * to bufmallocspace slightly passing the max.  It
4234          * is probably extremely rare and not worth worrying
4235          * over.
4236          */
4237         if (bp->b_bufsize == 0 && newbsize <= PAGE_SIZE/2 &&
4238             bufmallocspace < maxbufmallocspace) {
4239                 bp->b_data = malloc(newbsize, M_BIOBUF, M_WAITOK);
4240                 bp->b_flags |= B_MALLOC;
4241                 bufmallocadjust(bp, newbsize);
4242                 return;
4243         }
4244
4245         /*
4246          * If the buffer is growing on its other-than-first
4247          * allocation then we revert to the page-allocation
4248          * scheme.
4249          */
4250         origbuf = NULL;
4251         origbufsize = 0;
4252         if (bp->b_flags & B_MALLOC) {
4253                 origbuf = bp->b_data;
4254                 origbufsize = bp->b_bufsize;
4255                 bp->b_data = bp->b_kvabase;
4256                 bufmallocadjust(bp, 0);
4257                 bp->b_flags &= ~B_MALLOC;
4258                 newbsize = round_page(newbsize);
4259         }
4260         vm_hold_load_pages(bp, (vm_offset_t) bp->b_data + bp->b_bufsize,
4261             (vm_offset_t) bp->b_data + newbsize);
4262         if (origbuf != NULL) {
4263                 bcopy(origbuf, bp->b_data, origbufsize);
4264                 free(origbuf, M_BIOBUF);
4265         }
4266         bufspace_adjust(bp, newbsize);
4267 }
4268
4269 /*
4270  * This code constitutes the buffer memory from either anonymous system
4271  * memory (in the case of non-VMIO operations) or from an associated
4272  * VM object (in the case of VMIO operations).  This code is able to
4273  * resize a buffer up or down.
4274  *
4275  * Note that this code is tricky, and has many complications to resolve
4276  * deadlock or inconsistent data situations.  Tread lightly!!!
4277  * There are B_CACHE and B_DELWRI interactions that must be dealt with by
4278  * the caller.  Calling this code willy nilly can result in the loss of data.
4279  *
4280  * allocbuf() only adjusts B_CACHE for VMIO buffers.  getblk() deals with
4281  * B_CACHE for the non-VMIO case.
4282  */
4283 int
4284 allocbuf(struct buf *bp, int size)
4285 {
4286         int newbsize;
4287
4288         if (bp->b_bcount == size)
4289                 return (1);
4290
4291         if (bp->b_kvasize != 0 && bp->b_kvasize < size)
4292                 panic("allocbuf: buffer too small");
4293
4294         newbsize = roundup2(size, DEV_BSIZE);
4295         if ((bp->b_flags & B_VMIO) == 0) {
4296                 if ((bp->b_flags & B_MALLOC) == 0)
4297                         newbsize = round_page(newbsize);
4298                 /*
4299                  * Just get anonymous memory from the kernel.  Don't
4300                  * mess with B_CACHE.
4301                  */
4302                 if (newbsize < bp->b_bufsize)
4303                         vfs_nonvmio_truncate(bp, newbsize);
4304                 else if (newbsize > bp->b_bufsize)
4305                         vfs_nonvmio_extend(bp, newbsize);
4306         } else {
4307                 int desiredpages;
4308
4309                 desiredpages = (size == 0) ? 0 :
4310                     num_pages((bp->b_offset & PAGE_MASK) + newbsize);
4311
4312                 if (bp->b_flags & B_MALLOC)
4313                         panic("allocbuf: VMIO buffer can't be malloced");
4314                 /*
4315                  * Set B_CACHE initially if buffer is 0 length or will become
4316                  * 0-length.
4317                  */
4318                 if (size == 0 || bp->b_bufsize == 0)
4319                         bp->b_flags |= B_CACHE;
4320
4321                 if (newbsize < bp->b_bufsize)
4322                         vfs_vmio_truncate(bp, desiredpages);
4323                 /* XXX This looks as if it should be newbsize > b_bufsize */
4324                 else if (size > bp->b_bcount)
4325                         vfs_vmio_extend(bp, desiredpages, size);
4326                 bufspace_adjust(bp, newbsize);
4327         }
4328         bp->b_bcount = size;            /* requested buffer size. */
4329         return (1);
4330 }
4331
4332 extern int inflight_transient_maps;
4333
4334 static struct bio_queue nondump_bios;
4335
4336 void
4337 biodone(struct bio *bp)
4338 {
4339         struct mtx *mtxp;
4340         void (*done)(struct bio *);
4341         vm_offset_t start, end;
4342
4343         biotrack(bp, __func__);
4344
4345         /*
4346          * Avoid completing I/O when dumping after a panic since that may
4347          * result in a deadlock in the filesystem or pager code.  Note that
4348          * this doesn't affect dumps that were started manually since we aim
4349          * to keep the system usable after it has been resumed.
4350          */
4351         if (__predict_false(dumping && SCHEDULER_STOPPED())) {
4352                 TAILQ_INSERT_HEAD(&nondump_bios, bp, bio_queue);
4353                 return;
4354         }
4355         if ((bp->bio_flags & BIO_TRANSIENT_MAPPING) != 0) {
4356                 bp->bio_flags &= ~BIO_TRANSIENT_MAPPING;
4357                 bp->bio_flags |= BIO_UNMAPPED;
4358                 start = trunc_page((vm_offset_t)bp->bio_data);
4359                 end = round_page((vm_offset_t)bp->bio_data + bp->bio_length);
4360                 bp->bio_data = unmapped_buf;
4361                 pmap_qremove(start, atop(end - start));
4362                 vmem_free(transient_arena, start, end - start);
4363                 atomic_add_int(&inflight_transient_maps, -1);
4364         }
4365         done = bp->bio_done;
4366         if (done == NULL) {
4367                 mtxp = mtx_pool_find(mtxpool_sleep, bp);
4368                 mtx_lock(mtxp);
4369                 bp->bio_flags |= BIO_DONE;
4370                 wakeup(bp);
4371                 mtx_unlock(mtxp);
4372         } else
4373                 done(bp);
4374 }
4375
4376 /*
4377  * Wait for a BIO to finish.
4378  */
4379 int
4380 biowait(struct bio *bp, const char *wchan)
4381 {
4382         struct mtx *mtxp;
4383
4384         mtxp = mtx_pool_find(mtxpool_sleep, bp);
4385         mtx_lock(mtxp);
4386         while ((bp->bio_flags & BIO_DONE) == 0)
4387                 msleep(bp, mtxp, PRIBIO, wchan, 0);
4388         mtx_unlock(mtxp);
4389         if (bp->bio_error != 0)
4390                 return (bp->bio_error);
4391         if (!(bp->bio_flags & BIO_ERROR))
4392                 return (0);
4393         return (EIO);
4394 }
4395
4396 void
4397 biofinish(struct bio *bp, struct devstat *stat, int error)
4398 {
4399
4400         if (error) {
4401                 bp->bio_error = error;
4402                 bp->bio_flags |= BIO_ERROR;
4403         }
4404         if (stat != NULL)
4405                 devstat_end_transaction_bio(stat, bp);
4406         biodone(bp);
4407 }
4408
4409 #if defined(BUF_TRACKING) || defined(FULL_BUF_TRACKING)
4410 void
4411 biotrack_buf(struct bio *bp, const char *location)
4412 {
4413
4414         buf_track(bp->bio_track_bp, location);
4415 }
4416 #endif
4417
4418 /*
4419  *      bufwait:
4420  *
4421  *      Wait for buffer I/O completion, returning error status.  The buffer
4422  *      is left locked and B_DONE on return.  B_EINTR is converted into an EINTR
4423  *      error and cleared.
4424  */
4425 int
4426 bufwait(struct buf *bp)
4427 {
4428         if (bp->b_iocmd == BIO_READ)
4429                 bwait(bp, PRIBIO, "biord");
4430         else
4431                 bwait(bp, PRIBIO, "biowr");
4432         if (bp->b_flags & B_EINTR) {
4433                 bp->b_flags &= ~B_EINTR;
4434                 return (EINTR);
4435         }
4436         if (bp->b_ioflags & BIO_ERROR) {
4437                 return (bp->b_error ? bp->b_error : EIO);
4438         } else {
4439                 return (0);
4440         }
4441 }
4442
4443 /*
4444  *      bufdone:
4445  *
4446  *      Finish I/O on a buffer, optionally calling a completion function.
4447  *      This is usually called from an interrupt so process blocking is
4448  *      not allowed.
4449  *
4450  *      biodone is also responsible for setting B_CACHE in a B_VMIO bp.
4451  *      In a non-VMIO bp, B_CACHE will be set on the next getblk()
4452  *      assuming B_INVAL is clear.
4453  *
4454  *      For the VMIO case, we set B_CACHE if the op was a read and no
4455  *      read error occurred, or if the op was a write.  B_CACHE is never
4456  *      set if the buffer is invalid or otherwise uncacheable.
4457  *
4458  *      bufdone does not mess with B_INVAL, allowing the I/O routine or the
4459  *      initiator to leave B_INVAL set to brelse the buffer out of existence
4460  *      in the biodone routine.
4461  */
4462 void
4463 bufdone(struct buf *bp)
4464 {
4465         struct bufobj *dropobj;
4466         void    (*biodone)(struct buf *);
4467
4468         buf_track(bp, __func__);
4469         CTR3(KTR_BUF, "bufdone(%p) vp %p flags %X", bp, bp->b_vp, bp->b_flags);
4470         dropobj = NULL;
4471
4472         KASSERT(!(bp->b_flags & B_DONE), ("biodone: bp %p already done", bp));
4473
4474         runningbufwakeup(bp);
4475         if (bp->b_iocmd == BIO_WRITE)
4476                 dropobj = bp->b_bufobj;
4477         /* call optional completion function if requested */
4478         if (bp->b_iodone != NULL) {
4479                 biodone = bp->b_iodone;
4480                 bp->b_iodone = NULL;
4481                 (*biodone) (bp);
4482                 if (dropobj)
4483                         bufobj_wdrop(dropobj);
4484                 return;
4485         }
4486         if (bp->b_flags & B_VMIO) {
4487                 /*
4488                  * Set B_CACHE if the op was a normal read and no error
4489                  * occurred.  B_CACHE is set for writes in the b*write()
4490                  * routines.
4491                  */
4492                 if (bp->b_iocmd == BIO_READ &&
4493                     !(bp->b_flags & (B_INVAL|B_NOCACHE)) &&
4494                     !(bp->b_ioflags & BIO_ERROR))
4495                         bp->b_flags |= B_CACHE;
4496                 vfs_vmio_iodone(bp);
4497         }
4498         if (!LIST_EMPTY(&bp->b_dep))
4499                 buf_complete(bp);
4500         if ((bp->b_flags & B_CKHASH) != 0) {
4501                 KASSERT(bp->b_iocmd == BIO_READ,
4502                     ("bufdone: b_iocmd %d not BIO_READ", bp->b_iocmd));
4503                 KASSERT(buf_mapped(bp), ("bufdone: bp %p not mapped", bp));
4504                 (*bp->b_ckhashcalc)(bp);
4505         }
4506         /*
4507          * For asynchronous completions, release the buffer now. The brelse
4508          * will do a wakeup there if necessary - so no need to do a wakeup
4509          * here in the async case. The sync case always needs to do a wakeup.
4510          */
4511         if (bp->b_flags & B_ASYNC) {
4512                 if ((bp->b_flags & (B_NOCACHE | B_INVAL | B_RELBUF)) ||
4513                     (bp->b_ioflags & BIO_ERROR))
4514                         brelse(bp);
4515                 else
4516                         bqrelse(bp);
4517         } else
4518                 bdone(bp);
4519         if (dropobj)
4520                 bufobj_wdrop(dropobj);
4521 }
4522
4523 /*
4524  * This routine is called in lieu of iodone in the case of
4525  * incomplete I/O.  This keeps the busy status for pages
4526  * consistent.
4527  */
4528 void
4529 vfs_unbusy_pages(struct buf *bp)
4530 {
4531         int i;
4532         vm_object_t obj;
4533         vm_page_t m;
4534
4535         runningbufwakeup(bp);
4536         if (!(bp->b_flags & B_VMIO))
4537                 return;
4538
4539         obj = bp->b_bufobj->bo_object;
4540         for (i = 0; i < bp->b_npages; i++) {
4541                 m = bp->b_pages[i];
4542                 if (m == bogus_page) {
4543                         m = vm_page_relookup(obj, OFF_TO_IDX(bp->b_offset) + i);
4544                         if (!m)
4545                                 panic("vfs_unbusy_pages: page missing\n");
4546                         bp->b_pages[i] = m;
4547                         if (buf_mapped(bp)) {
4548                                 BUF_CHECK_MAPPED(bp);
4549                                 pmap_qenter(trunc_page((vm_offset_t)bp->b_data),
4550                                     bp->b_pages, bp->b_npages);
4551                         } else
4552                                 BUF_CHECK_UNMAPPED(bp);
4553                 }
4554                 vm_page_sunbusy(m);
4555         }
4556         vm_object_pip_wakeupn(obj, bp->b_npages);
4557 }
4558
4559 /*
4560  * vfs_page_set_valid:
4561  *
4562  *      Set the valid bits in a page based on the supplied offset.   The
4563  *      range is restricted to the buffer's size.
4564  *
4565  *      This routine is typically called after a read completes.
4566  */
4567 static void
4568 vfs_page_set_valid(struct buf *bp, vm_ooffset_t off, vm_page_t m)
4569 {
4570         vm_ooffset_t eoff;
4571
4572         /*
4573          * Compute the end offset, eoff, such that [off, eoff) does not span a
4574          * page boundary and eoff is not greater than the end of the buffer.
4575          * The end of the buffer, in this case, is our file EOF, not the
4576          * allocation size of the buffer.
4577          */
4578         eoff = (off + PAGE_SIZE) & ~(vm_ooffset_t)PAGE_MASK;
4579         if (eoff > bp->b_offset + bp->b_bcount)
4580                 eoff = bp->b_offset + bp->b_bcount;
4581
4582         /*
4583          * Set valid range.  This is typically the entire buffer and thus the
4584          * entire page.
4585          */
4586         if (eoff > off)
4587                 vm_page_set_valid_range(m, off & PAGE_MASK, eoff - off);
4588 }
4589
4590 /*
4591  * vfs_page_set_validclean:
4592  *
4593  *      Set the valid bits and clear the dirty bits in a page based on the
4594  *      supplied offset.   The range is restricted to the buffer's size.
4595  */
4596 static void
4597 vfs_page_set_validclean(struct buf *bp, vm_ooffset_t off, vm_page_t m)
4598 {
4599         vm_ooffset_t soff, eoff;
4600
4601         /*
4602          * Start and end offsets in buffer.  eoff - soff may not cross a
4603          * page boundary or cross the end of the buffer.  The end of the
4604          * buffer, in this case, is our file EOF, not the allocation size
4605          * of the buffer.
4606          */
4607         soff = off;
4608         eoff = (off + PAGE_SIZE) & ~(off_t)PAGE_MASK;
4609         if (eoff > bp->b_offset + bp->b_bcount)
4610                 eoff = bp->b_offset + bp->b_bcount;
4611
4612         /*
4613          * Set valid range.  This is typically the entire buffer and thus the
4614          * entire page.
4615          */
4616         if (eoff > soff) {
4617                 vm_page_set_validclean(
4618                     m,
4619                    (vm_offset_t) (soff & PAGE_MASK),
4620                    (vm_offset_t) (eoff - soff)
4621                 );
4622         }
4623 }
4624
4625 /*
4626  * Acquire a shared busy on all pages in the buf.
4627  */
4628 void
4629 vfs_busy_pages_acquire(struct buf *bp)
4630 {
4631         int i;
4632
4633         for (i = 0; i < bp->b_npages; i++)
4634                 vm_page_busy_acquire(bp->b_pages[i], VM_ALLOC_SBUSY);
4635 }
4636
4637 void
4638 vfs_busy_pages_release(struct buf *bp)
4639 {
4640         int i;
4641
4642         for (i = 0; i < bp->b_npages; i++)
4643                 vm_page_sunbusy(bp->b_pages[i]);
4644 }
4645
4646 /*
4647  * This routine is called before a device strategy routine.
4648  * It is used to tell the VM system that paging I/O is in
4649  * progress, and treat the pages associated with the buffer
4650  * almost as being exclusive busy.  Also the object paging_in_progress
4651  * flag is handled to make sure that the object doesn't become
4652  * inconsistent.
4653  *
4654  * Since I/O has not been initiated yet, certain buffer flags
4655  * such as BIO_ERROR or B_INVAL may be in an inconsistent state
4656  * and should be ignored.
4657  */
4658 void
4659 vfs_busy_pages(struct buf *bp, int clear_modify)
4660 {
4661         vm_object_t obj;
4662         vm_ooffset_t foff;
4663         vm_page_t m;
4664         int i;
4665         bool bogus;
4666
4667         if (!(bp->b_flags & B_VMIO))
4668                 return;
4669
4670         obj = bp->b_bufobj->bo_object;
4671         foff = bp->b_offset;
4672         KASSERT(bp->b_offset != NOOFFSET,
4673             ("vfs_busy_pages: no buffer offset"));
4674         if ((bp->b_flags & B_CLUSTER) == 0) {
4675                 vm_object_pip_add(obj, bp->b_npages);
4676                 vfs_busy_pages_acquire(bp);
4677         }
4678         if (bp->b_bufsize != 0)
4679                 vfs_setdirty_range(bp);
4680         bogus = false;
4681         for (i = 0; i < bp->b_npages; i++) {
4682                 m = bp->b_pages[i];
4683                 vm_page_assert_sbusied(m);
4684
4685                 /*
4686                  * When readying a buffer for a read ( i.e
4687                  * clear_modify == 0 ), it is important to do
4688                  * bogus_page replacement for valid pages in
4689                  * partially instantiated buffers.  Partially
4690                  * instantiated buffers can, in turn, occur when
4691                  * reconstituting a buffer from its VM backing store
4692                  * base.  We only have to do this if B_CACHE is
4693                  * clear ( which causes the I/O to occur in the
4694                  * first place ).  The replacement prevents the read
4695                  * I/O from overwriting potentially dirty VM-backed
4696                  * pages.  XXX bogus page replacement is, uh, bogus.
4697                  * It may not work properly with small-block devices.
4698                  * We need to find a better way.
4699                  */
4700                 if (clear_modify) {
4701                         pmap_remove_write(m);
4702                         vfs_page_set_validclean(bp, foff, m);
4703                 } else if (vm_page_all_valid(m) &&
4704                     (bp->b_flags & B_CACHE) == 0) {
4705                         bp->b_pages[i] = bogus_page;
4706                         bogus = true;
4707                 }
4708                 foff = (foff + PAGE_SIZE) & ~(off_t)PAGE_MASK;
4709         }
4710         if (bogus && buf_mapped(bp)) {
4711                 BUF_CHECK_MAPPED(bp);
4712                 pmap_qenter(trunc_page((vm_offset_t)bp->b_data),
4713                     bp->b_pages, bp->b_npages);
4714         }
4715 }
4716
4717 /*
4718  *      vfs_bio_set_valid:
4719  *
4720  *      Set the range within the buffer to valid.  The range is
4721  *      relative to the beginning of the buffer, b_offset.  Note that
4722  *      b_offset itself may be offset from the beginning of the first
4723  *      page.
4724  */
4725 void
4726 vfs_bio_set_valid(struct buf *bp, int base, int size)
4727 {
4728         int i, n;
4729         vm_page_t m;
4730
4731         if (!(bp->b_flags & B_VMIO))
4732                 return;
4733
4734         /*
4735          * Fixup base to be relative to beginning of first page.
4736          * Set initial n to be the maximum number of bytes in the
4737          * first page that can be validated.
4738          */
4739         base += (bp->b_offset & PAGE_MASK);
4740         n = PAGE_SIZE - (base & PAGE_MASK);
4741
4742         /*
4743          * Busy may not be strictly necessary here because the pages are
4744          * unlikely to be fully valid and the vnode lock will synchronize
4745          * their access via getpages.  It is grabbed for consistency with
4746          * other page validation.
4747          */
4748         vfs_busy_pages_acquire(bp);
4749         for (i = base / PAGE_SIZE; size > 0 && i < bp->b_npages; ++i) {
4750                 m = bp->b_pages[i];
4751                 if (n > size)
4752                         n = size;
4753                 vm_page_set_valid_range(m, base & PAGE_MASK, n);
4754                 base += n;
4755                 size -= n;
4756                 n = PAGE_SIZE;
4757         }
4758         vfs_busy_pages_release(bp);
4759 }
4760
4761 /*
4762  *      vfs_bio_clrbuf:
4763  *
4764  *      If the specified buffer is a non-VMIO buffer, clear the entire
4765  *      buffer.  If the specified buffer is a VMIO buffer, clear and
4766  *      validate only the previously invalid portions of the buffer.
4767  *      This routine essentially fakes an I/O, so we need to clear
4768  *      BIO_ERROR and B_INVAL.
4769  *
4770  *      Note that while we only theoretically need to clear through b_bcount,
4771  *      we go ahead and clear through b_bufsize.
4772  */
4773 void
4774 vfs_bio_clrbuf(struct buf *bp)
4775 {
4776         int i, j, mask, sa, ea, slide;
4777
4778         if ((bp->b_flags & (B_VMIO | B_MALLOC)) != B_VMIO) {
4779                 clrbuf(bp);
4780                 return;
4781         }
4782         bp->b_flags &= ~B_INVAL;
4783         bp->b_ioflags &= ~BIO_ERROR;
4784         vfs_busy_pages_acquire(bp);
4785         sa = bp->b_offset & PAGE_MASK;
4786         slide = 0;
4787         for (i = 0; i < bp->b_npages; i++, sa = 0) {
4788                 slide = imin(slide + PAGE_SIZE, bp->b_offset + bp->b_bufsize);
4789                 ea = slide & PAGE_MASK;
4790                 if (ea == 0)
4791                         ea = PAGE_SIZE;
4792                 if (bp->b_pages[i] == bogus_page)
4793                         continue;
4794                 j = sa / DEV_BSIZE;
4795                 mask = ((1 << ((ea - sa) / DEV_BSIZE)) - 1) << j;
4796                 if ((bp->b_pages[i]->valid & mask) == mask)
4797                         continue;
4798                 if ((bp->b_pages[i]->valid & mask) == 0)
4799                         pmap_zero_page_area(bp->b_pages[i], sa, ea - sa);
4800                 else {
4801                         for (; sa < ea; sa += DEV_BSIZE, j++) {
4802                                 if ((bp->b_pages[i]->valid & (1 << j)) == 0) {
4803                                         pmap_zero_page_area(bp->b_pages[i],
4804                                             sa, DEV_BSIZE);
4805                                 }
4806                         }
4807                 }
4808                 vm_page_set_valid_range(bp->b_pages[i], j * DEV_BSIZE,
4809                     roundup2(ea - sa, DEV_BSIZE));
4810         }
4811         vfs_busy_pages_release(bp);
4812         bp->b_resid = 0;
4813 }
4814
4815 void
4816 vfs_bio_bzero_buf(struct buf *bp, int base, int size)
4817 {
4818         vm_page_t m;
4819         int i, n;
4820
4821         if (buf_mapped(bp)) {
4822                 BUF_CHECK_MAPPED(bp);
4823                 bzero(bp->b_data + base, size);
4824         } else {
4825                 BUF_CHECK_UNMAPPED(bp);
4826                 n = PAGE_SIZE - (base & PAGE_MASK);
4827                 for (i = base / PAGE_SIZE; size > 0 && i < bp->b_npages; ++i) {
4828                         m = bp->b_pages[i];
4829                         if (n > size)
4830                                 n = size;
4831                         pmap_zero_page_area(m, base & PAGE_MASK, n);
4832                         base += n;
4833                         size -= n;
4834                         n = PAGE_SIZE;
4835                 }
4836         }
4837 }
4838
4839 /*
4840  * Update buffer flags based on I/O request parameters, optionally releasing the
4841  * buffer.  If it's VMIO or direct I/O, the buffer pages are released to the VM,
4842  * where they may be placed on a page queue (VMIO) or freed immediately (direct
4843  * I/O).  Otherwise the buffer is released to the cache.
4844  */
4845 static void
4846 b_io_dismiss(struct buf *bp, int ioflag, bool release)
4847 {
4848
4849         KASSERT((ioflag & IO_NOREUSE) == 0 || (ioflag & IO_VMIO) != 0,
4850             ("buf %p non-VMIO noreuse", bp));
4851
4852         if ((ioflag & IO_DIRECT) != 0)
4853                 bp->b_flags |= B_DIRECT;
4854         if ((ioflag & IO_EXT) != 0)
4855                 bp->b_xflags |= BX_ALTDATA;
4856         if ((ioflag & (IO_VMIO | IO_DIRECT)) != 0 && LIST_EMPTY(&bp->b_dep)) {
4857                 bp->b_flags |= B_RELBUF;
4858                 if ((ioflag & IO_NOREUSE) != 0)
4859                         bp->b_flags |= B_NOREUSE;
4860                 if (release)
4861                         brelse(bp);
4862         } else if (release)
4863                 bqrelse(bp);
4864 }
4865
4866 void
4867 vfs_bio_brelse(struct buf *bp, int ioflag)
4868 {
4869
4870         b_io_dismiss(bp, ioflag, true);
4871 }
4872
4873 void
4874 vfs_bio_set_flags(struct buf *bp, int ioflag)
4875 {
4876
4877         b_io_dismiss(bp, ioflag, false);
4878 }
4879
4880 /*
4881  * vm_hold_load_pages and vm_hold_free_pages get pages into
4882  * a buffers address space.  The pages are anonymous and are
4883  * not associated with a file object.
4884  */
4885 static void
4886 vm_hold_load_pages(struct buf *bp, vm_offset_t from, vm_offset_t to)
4887 {
4888         vm_offset_t pg;
4889         vm_page_t p;
4890         int index;
4891
4892         BUF_CHECK_MAPPED(bp);
4893
4894         to = round_page(to);
4895         from = round_page(from);
4896         index = (from - trunc_page((vm_offset_t)bp->b_data)) >> PAGE_SHIFT;
4897         MPASS((bp->b_flags & B_MAXPHYS) == 0);
4898         KASSERT(to - from <= maxbcachebuf,
4899             ("vm_hold_load_pages too large %p %#jx %#jx %u",
4900             bp, (uintmax_t)from, (uintmax_t)to, maxbcachebuf));
4901
4902         for (pg = from; pg < to; pg += PAGE_SIZE, index++) {
4903                 /*
4904                  * note: must allocate system pages since blocking here
4905                  * could interfere with paging I/O, no matter which
4906                  * process we are.
4907                  */
4908                 p = vm_page_alloc(NULL, 0, VM_ALLOC_SYSTEM | VM_ALLOC_NOOBJ |
4909                     VM_ALLOC_WIRED | VM_ALLOC_COUNT((to - pg) >> PAGE_SHIFT) |
4910                     VM_ALLOC_WAITOK);
4911                 pmap_qenter(pg, &p, 1);
4912                 bp->b_pages[index] = p;
4913         }
4914         bp->b_npages = index;
4915 }
4916
4917 /* Return pages associated with this buf to the vm system */
4918 static void
4919 vm_hold_free_pages(struct buf *bp, int newbsize)
4920 {
4921         vm_offset_t from;
4922         vm_page_t p;
4923         int index, newnpages;
4924
4925         BUF_CHECK_MAPPED(bp);
4926
4927         from = round_page((vm_offset_t)bp->b_data + newbsize);
4928         newnpages = (from - trunc_page((vm_offset_t)bp->b_data)) >> PAGE_SHIFT;
4929         if (bp->b_npages > newnpages)
4930                 pmap_qremove(from, bp->b_npages - newnpages);
4931         for (index = newnpages; index < bp->b_npages; index++) {
4932                 p = bp->b_pages[index];
4933                 bp->b_pages[index] = NULL;
4934                 vm_page_unwire_noq(p);
4935                 vm_page_free(p);
4936         }
4937         bp->b_npages = newnpages;
4938 }
4939
4940 /*
4941  * Map an IO request into kernel virtual address space.
4942  *
4943  * All requests are (re)mapped into kernel VA space.
4944  * Notice that we use b_bufsize for the size of the buffer
4945  * to be mapped.  b_bcount might be modified by the driver.
4946  *
4947  * Note that even if the caller determines that the address space should
4948  * be valid, a race or a smaller-file mapped into a larger space may
4949  * actually cause vmapbuf() to fail, so all callers of vmapbuf() MUST
4950  * check the return value.
4951  *
4952  * This function only works with pager buffers.
4953  */
4954 int
4955 vmapbuf(struct buf *bp, void *uaddr, size_t len, int mapbuf)
4956 {
4957         vm_prot_t prot;
4958         int pidx;
4959
4960         MPASS((bp->b_flags & B_MAXPHYS) != 0);
4961         prot = VM_PROT_READ;
4962         if (bp->b_iocmd == BIO_READ)
4963                 prot |= VM_PROT_WRITE;  /* Less backwards than it looks */
4964         pidx = vm_fault_quick_hold_pages(&curproc->p_vmspace->vm_map,
4965             (vm_offset_t)uaddr, len, prot, bp->b_pages, PBUF_PAGES);
4966         if (pidx < 0)
4967                 return (-1);
4968         bp->b_bufsize = len;
4969         bp->b_npages = pidx;
4970         bp->b_offset = ((vm_offset_t)uaddr) & PAGE_MASK;
4971         if (mapbuf || !unmapped_buf_allowed) {
4972                 pmap_qenter((vm_offset_t)bp->b_kvabase, bp->b_pages, pidx);
4973                 bp->b_data = bp->b_kvabase + bp->b_offset;
4974         } else
4975                 bp->b_data = unmapped_buf;
4976         return (0);
4977 }
4978
4979 /*
4980  * Free the io map PTEs associated with this IO operation.
4981  * We also invalidate the TLB entries and restore the original b_addr.
4982  *
4983  * This function only works with pager buffers.
4984  */
4985 void
4986 vunmapbuf(struct buf *bp)
4987 {
4988         int npages;
4989
4990         npages = bp->b_npages;
4991         if (buf_mapped(bp))
4992                 pmap_qremove(trunc_page((vm_offset_t)bp->b_data), npages);
4993         vm_page_unhold_pages(bp->b_pages, npages);
4994
4995         bp->b_data = unmapped_buf;
4996 }
4997
4998 void
4999 bdone(struct buf *bp)
5000 {
5001         struct mtx *mtxp;
5002
5003         mtxp = mtx_pool_find(mtxpool_sleep, bp);
5004         mtx_lock(mtxp);
5005         bp->b_flags |= B_DONE;
5006         wakeup(bp);
5007         mtx_unlock(mtxp);
5008 }
5009
5010 void
5011 bwait(struct buf *bp, u_char pri, const char *wchan)
5012 {
5013         struct mtx *mtxp;
5014
5015         mtxp = mtx_pool_find(mtxpool_sleep, bp);
5016         mtx_lock(mtxp);
5017         while ((bp->b_flags & B_DONE) == 0)
5018                 msleep(bp, mtxp, pri, wchan, 0);
5019         mtx_unlock(mtxp);
5020 }
5021
5022 int
5023 bufsync(struct bufobj *bo, int waitfor)
5024 {
5025
5026         return (VOP_FSYNC(bo2vnode(bo), waitfor, curthread));
5027 }
5028
5029 void
5030 bufstrategy(struct bufobj *bo, struct buf *bp)
5031 {
5032         int i __unused;
5033         struct vnode *vp;
5034
5035         vp = bp->b_vp;
5036         KASSERT(vp == bo->bo_private, ("Inconsistent vnode bufstrategy"));
5037         KASSERT(vp->v_type != VCHR && vp->v_type != VBLK,
5038             ("Wrong vnode in bufstrategy(bp=%p, vp=%p)", bp, vp));
5039         i = VOP_STRATEGY(vp, bp);
5040         KASSERT(i == 0, ("VOP_STRATEGY failed bp=%p vp=%p", bp, bp->b_vp));
5041 }
5042
5043 /*
5044  * Initialize a struct bufobj before use.  Memory is assumed zero filled.
5045  */
5046 void
5047 bufobj_init(struct bufobj *bo, void *private)
5048 {
5049         static volatile int bufobj_cleanq;
5050
5051         bo->bo_domain =
5052             atomic_fetchadd_int(&bufobj_cleanq, 1) % buf_domains;
5053         rw_init(BO_LOCKPTR(bo), "bufobj interlock");
5054         bo->bo_private = private;
5055         TAILQ_INIT(&bo->bo_clean.bv_hd);
5056         TAILQ_INIT(&bo->bo_dirty.bv_hd);
5057 }
5058
5059 void
5060 bufobj_wrefl(struct bufobj *bo)
5061 {
5062
5063         KASSERT(bo != NULL, ("NULL bo in bufobj_wref"));
5064         ASSERT_BO_WLOCKED(bo);
5065         bo->bo_numoutput++;
5066 }
5067
5068 void
5069 bufobj_wref(struct bufobj *bo)
5070 {
5071
5072         KASSERT(bo != NULL, ("NULL bo in bufobj_wref"));
5073         BO_LOCK(bo);
5074         bo->bo_numoutput++;
5075         BO_UNLOCK(bo);
5076 }
5077
5078 void
5079 bufobj_wdrop(struct bufobj *bo)
5080 {
5081
5082         KASSERT(bo != NULL, ("NULL bo in bufobj_wdrop"));
5083         BO_LOCK(bo);
5084         KASSERT(bo->bo_numoutput > 0, ("bufobj_wdrop non-positive count"));
5085         if ((--bo->bo_numoutput == 0) && (bo->bo_flag & BO_WWAIT)) {
5086                 bo->bo_flag &= ~BO_WWAIT;
5087                 wakeup(&bo->bo_numoutput);
5088         }
5089         BO_UNLOCK(bo);
5090 }
5091
5092 int
5093 bufobj_wwait(struct bufobj *bo, int slpflag, int timeo)
5094 {
5095         int error;
5096
5097         KASSERT(bo != NULL, ("NULL bo in bufobj_wwait"));
5098         ASSERT_BO_WLOCKED(bo);
5099         error = 0;
5100         while (bo->bo_numoutput) {
5101                 bo->bo_flag |= BO_WWAIT;
5102                 error = msleep(&bo->bo_numoutput, BO_LOCKPTR(bo),
5103                     slpflag | (PRIBIO + 1), "bo_wwait", timeo);
5104                 if (error)
5105                         break;
5106         }
5107         return (error);
5108 }
5109
5110 /*
5111  * Set bio_data or bio_ma for struct bio from the struct buf.
5112  */
5113 void
5114 bdata2bio(struct buf *bp, struct bio *bip)
5115 {
5116
5117         if (!buf_mapped(bp)) {
5118                 KASSERT(unmapped_buf_allowed, ("unmapped"));
5119                 bip->bio_ma = bp->b_pages;
5120                 bip->bio_ma_n = bp->b_npages;
5121                 bip->bio_data = unmapped_buf;
5122                 bip->bio_ma_offset = (vm_offset_t)bp->b_offset & PAGE_MASK;
5123                 bip->bio_flags |= BIO_UNMAPPED;
5124                 KASSERT(round_page(bip->bio_ma_offset + bip->bio_length) /
5125                     PAGE_SIZE == bp->b_npages,
5126                     ("Buffer %p too short: %d %lld %d", bp, bip->bio_ma_offset,
5127                     (long long)bip->bio_length, bip->bio_ma_n));
5128         } else {
5129                 bip->bio_data = bp->b_data;
5130                 bip->bio_ma = NULL;
5131         }
5132 }
5133
5134 /*
5135  * The MIPS pmap code currently doesn't handle aliased pages.
5136  * The VIPT caches may not handle page aliasing themselves, leading
5137  * to data corruption.
5138  *
5139  * As such, this code makes a system extremely unhappy if said
5140  * system doesn't support unaliasing the above situation in hardware.
5141  * Some "recent" systems (eg some mips24k/mips74k cores) don't enable
5142  * this feature at build time, so it has to be handled in software.
5143  *
5144  * Once the MIPS pmap/cache code grows to support this function on
5145  * earlier chips, it should be flipped back off.
5146  */
5147 #ifdef  __mips__
5148 static int buf_pager_relbuf = 1;
5149 #else
5150 static int buf_pager_relbuf = 0;
5151 #endif
5152 SYSCTL_INT(_vfs, OID_AUTO, buf_pager_relbuf, CTLFLAG_RWTUN,
5153     &buf_pager_relbuf, 0,
5154     "Make buffer pager release buffers after reading");
5155
5156 /*
5157  * The buffer pager.  It uses buffer reads to validate pages.
5158  *
5159  * In contrast to the generic local pager from vm/vnode_pager.c, this
5160  * pager correctly and easily handles volumes where the underlying
5161  * device block size is greater than the machine page size.  The
5162  * buffer cache transparently extends the requested page run to be
5163  * aligned at the block boundary, and does the necessary bogus page
5164  * replacements in the addends to avoid obliterating already valid
5165  * pages.
5166  *
5167  * The only non-trivial issue is that the exclusive busy state for
5168  * pages, which is assumed by the vm_pager_getpages() interface, is
5169  * incompatible with the VMIO buffer cache's desire to share-busy the
5170  * pages.  This function performs a trivial downgrade of the pages'
5171  * state before reading buffers, and a less trivial upgrade from the
5172  * shared-busy to excl-busy state after the read.
5173  */
5174 int
5175 vfs_bio_getpages(struct vnode *vp, vm_page_t *ma, int count,
5176     int *rbehind, int *rahead, vbg_get_lblkno_t get_lblkno,
5177     vbg_get_blksize_t get_blksize)
5178 {
5179         vm_page_t m;
5180         vm_object_t object;
5181         struct buf *bp;
5182         struct mount *mp;
5183         daddr_t lbn, lbnp;
5184         vm_ooffset_t la, lb, poff, poffe;
5185         long bsize;
5186         int bo_bs, br_flags, error, i, pgsin, pgsin_a, pgsin_b;
5187         bool redo, lpart;
5188
5189         object = vp->v_object;
5190         mp = vp->v_mount;
5191         error = 0;
5192         la = IDX_TO_OFF(ma[count - 1]->pindex);
5193         if (la >= object->un_pager.vnp.vnp_size)
5194                 return (VM_PAGER_BAD);
5195
5196         /*
5197          * Change the meaning of la from where the last requested page starts
5198          * to where it ends, because that's the end of the requested region
5199          * and the start of the potential read-ahead region.
5200          */
5201         la += PAGE_SIZE;
5202         lpart = la > object->un_pager.vnp.vnp_size;
5203         bo_bs = get_blksize(vp, get_lblkno(vp, IDX_TO_OFF(ma[0]->pindex)));
5204
5205         /*
5206          * Calculate read-ahead, behind and total pages.
5207          */
5208         pgsin = count;
5209         lb = IDX_TO_OFF(ma[0]->pindex);
5210         pgsin_b = OFF_TO_IDX(lb - rounddown2(lb, bo_bs));
5211         pgsin += pgsin_b;
5212         if (rbehind != NULL)
5213                 *rbehind = pgsin_b;
5214         pgsin_a = OFF_TO_IDX(roundup2(la, bo_bs) - la);
5215         if (la + IDX_TO_OFF(pgsin_a) >= object->un_pager.vnp.vnp_size)
5216                 pgsin_a = OFF_TO_IDX(roundup2(object->un_pager.vnp.vnp_size,
5217                     PAGE_SIZE) - la);
5218         pgsin += pgsin_a;
5219         if (rahead != NULL)
5220                 *rahead = pgsin_a;
5221         VM_CNT_INC(v_vnodein);
5222         VM_CNT_ADD(v_vnodepgsin, pgsin);
5223
5224         br_flags = (mp != NULL && (mp->mnt_kern_flag & MNTK_UNMAPPED_BUFS)
5225             != 0) ? GB_UNMAPPED : 0;
5226 again:
5227         for (i = 0; i < count; i++) {
5228                 if (ma[i] != bogus_page)
5229                         vm_page_busy_downgrade(ma[i]);
5230         }
5231
5232         lbnp = -1;
5233         for (i = 0; i < count; i++) {
5234                 m = ma[i];
5235                 if (m == bogus_page)
5236                         continue;
5237
5238                 /*
5239                  * Pages are shared busy and the object lock is not
5240                  * owned, which together allow for the pages'
5241                  * invalidation.  The racy test for validity avoids
5242                  * useless creation of the buffer for the most typical
5243                  * case when invalidation is not used in redo or for
5244                  * parallel read.  The shared->excl upgrade loop at
5245                  * the end of the function catches the race in a
5246                  * reliable way (protected by the object lock).
5247                  */
5248                 if (vm_page_all_valid(m))
5249                         continue;
5250
5251                 poff = IDX_TO_OFF(m->pindex);
5252                 poffe = MIN(poff + PAGE_SIZE, object->un_pager.vnp.vnp_size);
5253                 for (; poff < poffe; poff += bsize) {
5254                         lbn = get_lblkno(vp, poff);
5255                         if (lbn == lbnp)
5256                                 goto next_page;
5257                         lbnp = lbn;
5258
5259                         bsize = get_blksize(vp, lbn);
5260                         error = bread_gb(vp, lbn, bsize, curthread->td_ucred,
5261                             br_flags, &bp);
5262                         if (error != 0)
5263                                 goto end_pages;
5264                         if (bp->b_rcred == curthread->td_ucred) {
5265                                 crfree(bp->b_rcred);
5266                                 bp->b_rcred = NOCRED;
5267                         }
5268                         if (LIST_EMPTY(&bp->b_dep)) {
5269                                 /*
5270                                  * Invalidation clears m->valid, but
5271                                  * may leave B_CACHE flag if the
5272                                  * buffer existed at the invalidation
5273                                  * time.  In this case, recycle the
5274                                  * buffer to do real read on next
5275                                  * bread() after redo.
5276                                  *
5277                                  * Otherwise B_RELBUF is not strictly
5278                                  * necessary, enable to reduce buf
5279                                  * cache pressure.
5280                                  */
5281                                 if (buf_pager_relbuf ||
5282                                     !vm_page_all_valid(m))
5283                                         bp->b_flags |= B_RELBUF;
5284
5285                                 bp->b_flags &= ~B_NOCACHE;
5286                                 brelse(bp);
5287                         } else {
5288                                 bqrelse(bp);
5289                         }
5290                 }
5291                 KASSERT(1 /* racy, enable for debugging */ ||
5292                     vm_page_all_valid(m) || i == count - 1,
5293                     ("buf %d %p invalid", i, m));
5294                 if (i == count - 1 && lpart) {
5295                         if (!vm_page_none_valid(m) &&
5296                             !vm_page_all_valid(m))
5297                                 vm_page_zero_invalid(m, TRUE);
5298                 }
5299 next_page:;
5300         }
5301 end_pages:
5302
5303         redo = false;
5304         for (i = 0; i < count; i++) {
5305                 if (ma[i] == bogus_page)
5306                         continue;
5307                 if (vm_page_busy_tryupgrade(ma[i]) == 0) {
5308                         vm_page_sunbusy(ma[i]);
5309                         ma[i] = vm_page_grab_unlocked(object, ma[i]->pindex,
5310                             VM_ALLOC_NORMAL);
5311                 }
5312
5313                 /*
5314                  * Since the pages were only sbusy while neither the
5315                  * buffer nor the object lock was held by us, or
5316                  * reallocated while vm_page_grab() slept for busy
5317                  * relinguish, they could have been invalidated.
5318                  * Recheck the valid bits and re-read as needed.
5319                  *
5320                  * Note that the last page is made fully valid in the
5321                  * read loop, and partial validity for the page at
5322                  * index count - 1 could mean that the page was
5323                  * invalidated or removed, so we must restart for
5324                  * safety as well.
5325                  */
5326                 if (!vm_page_all_valid(ma[i]))
5327                         redo = true;
5328         }
5329         if (redo && error == 0)
5330                 goto again;
5331         return (error != 0 ? VM_PAGER_ERROR : VM_PAGER_OK);
5332 }
5333
5334 #include "opt_ddb.h"
5335 #ifdef DDB
5336 #include <ddb/ddb.h>
5337
5338 /* DDB command to show buffer data */
5339 DB_SHOW_COMMAND(buffer, db_show_buffer)
5340 {
5341         /* get args */
5342         struct buf *bp = (struct buf *)addr;
5343 #ifdef FULL_BUF_TRACKING
5344         uint32_t i, j;
5345 #endif
5346
5347         if (!have_addr) {
5348                 db_printf("usage: show buffer <addr>\n");
5349                 return;
5350         }
5351
5352         db_printf("buf at %p\n", bp);
5353         db_printf("b_flags = 0x%b, b_xflags=0x%b\n",
5354             (u_int)bp->b_flags, PRINT_BUF_FLAGS,
5355             (u_int)bp->b_xflags, PRINT_BUF_XFLAGS);
5356         db_printf("b_vflags=0x%b b_ioflags0x%b\n",
5357             (u_int)bp->b_vflags, PRINT_BUF_VFLAGS,
5358             (u_int)bp->b_ioflags, PRINT_BIO_FLAGS);
5359         db_printf(
5360             "b_error = %d, b_bufsize = %ld, b_bcount = %ld, b_resid = %ld\n"
5361             "b_bufobj = (%p), b_data = %p\n, b_blkno = %jd, b_lblkno = %jd, "
5362             "b_vp = %p, b_dep = %p\n",
5363             bp->b_error, bp->b_bufsize, bp->b_bcount, bp->b_resid,
5364             bp->b_bufobj, bp->b_data, (intmax_t)bp->b_blkno,
5365             (intmax_t)bp->b_lblkno, bp->b_vp, bp->b_dep.lh_first);
5366         db_printf("b_kvabase = %p, b_kvasize = %d\n",
5367             bp->b_kvabase, bp->b_kvasize);
5368         if (bp->b_npages) {
5369                 int i;
5370                 db_printf("b_npages = %d, pages(OBJ, IDX, PA): ", bp->b_npages);
5371                 for (i = 0; i < bp->b_npages; i++) {
5372                         vm_page_t m;
5373                         m = bp->b_pages[i];
5374                         if (m != NULL)
5375                                 db_printf("(%p, 0x%lx, 0x%lx)", m->object,
5376                                     (u_long)m->pindex,
5377                                     (u_long)VM_PAGE_TO_PHYS(m));
5378                         else
5379                                 db_printf("( ??? )");
5380                         if ((i + 1) < bp->b_npages)
5381                                 db_printf(",");
5382                 }
5383                 db_printf("\n");
5384         }
5385         BUF_LOCKPRINTINFO(bp);
5386 #if defined(FULL_BUF_TRACKING)
5387         db_printf("b_io_tracking: b_io_tcnt = %u\n", bp->b_io_tcnt);
5388
5389         i = bp->b_io_tcnt % BUF_TRACKING_SIZE;
5390         for (j = 1; j <= BUF_TRACKING_SIZE; j++) {
5391                 if (bp->b_io_tracking[BUF_TRACKING_ENTRY(i - j)] == NULL)
5392                         continue;
5393                 db_printf(" %2u: %s\n", j,
5394                     bp->b_io_tracking[BUF_TRACKING_ENTRY(i - j)]);
5395         }
5396 #elif defined(BUF_TRACKING)
5397         db_printf("b_io_tracking: %s\n", bp->b_io_tracking);
5398 #endif
5399         db_printf(" ");
5400 }
5401
5402 DB_SHOW_COMMAND(bufqueues, bufqueues)
5403 {
5404         struct bufdomain *bd;
5405         struct buf *bp;
5406         long total;
5407         int i, j, cnt;
5408
5409         db_printf("bqempty: %d\n", bqempty.bq_len);
5410
5411         for (i = 0; i < buf_domains; i++) {
5412                 bd = &bdomain[i];
5413                 db_printf("Buf domain %d\n", i);
5414                 db_printf("\tfreebufs\t%d\n", bd->bd_freebuffers);
5415                 db_printf("\tlofreebufs\t%d\n", bd->bd_lofreebuffers);
5416                 db_printf("\thifreebufs\t%d\n", bd->bd_hifreebuffers);
5417                 db_printf("\n");
5418                 db_printf("\tbufspace\t%ld\n", bd->bd_bufspace);
5419                 db_printf("\tmaxbufspace\t%ld\n", bd->bd_maxbufspace);
5420                 db_printf("\thibufspace\t%ld\n", bd->bd_hibufspace);
5421                 db_printf("\tlobufspace\t%ld\n", bd->bd_lobufspace);
5422                 db_printf("\tbufspacethresh\t%ld\n", bd->bd_bufspacethresh);
5423                 db_printf("\n");
5424                 db_printf("\tnumdirtybuffers\t%d\n", bd->bd_numdirtybuffers);
5425                 db_printf("\tlodirtybuffers\t%d\n", bd->bd_lodirtybuffers);
5426                 db_printf("\thidirtybuffers\t%d\n", bd->bd_hidirtybuffers);
5427                 db_printf("\tdirtybufthresh\t%d\n", bd->bd_dirtybufthresh);
5428                 db_printf("\n");
5429                 total = 0;
5430                 TAILQ_FOREACH(bp, &bd->bd_cleanq->bq_queue, b_freelist)
5431                         total += bp->b_bufsize;
5432                 db_printf("\tcleanq count\t%d (%ld)\n",
5433                     bd->bd_cleanq->bq_len, total);
5434                 total = 0;
5435                 TAILQ_FOREACH(bp, &bd->bd_dirtyq.bq_queue, b_freelist)
5436                         total += bp->b_bufsize;
5437                 db_printf("\tdirtyq count\t%d (%ld)\n",
5438                     bd->bd_dirtyq.bq_len, total);
5439                 db_printf("\twakeup\t\t%d\n", bd->bd_wanted);
5440                 db_printf("\tlim\t\t%d\n", bd->bd_lim);
5441                 db_printf("\tCPU ");
5442                 for (j = 0; j <= mp_maxid; j++)
5443                         db_printf("%d, ", bd->bd_subq[j].bq_len);
5444                 db_printf("\n");
5445                 cnt = 0;
5446                 total = 0;
5447                 for (j = 0; j < nbuf; j++) {
5448                         bp = nbufp(j);
5449                         if (bp->b_domain == i && BUF_ISLOCKED(bp)) {
5450                                 cnt++;
5451                                 total += bp->b_bufsize;
5452                         }
5453                 }
5454                 db_printf("\tLocked buffers: %d space %ld\n", cnt, total);
5455                 cnt = 0;
5456                 total = 0;
5457                 for (j = 0; j < nbuf; j++) {
5458                         bp = nbufp(j);
5459                         if (bp->b_domain == i) {
5460                                 cnt++;
5461                                 total += bp->b_bufsize;
5462                         }
5463                 }
5464                 db_printf("\tTotal buffers: %d space %ld\n", cnt, total);
5465         }
5466 }
5467
5468 DB_SHOW_COMMAND(lockedbufs, lockedbufs)
5469 {
5470         struct buf *bp;
5471         int i;
5472
5473         for (i = 0; i < nbuf; i++) {
5474                 bp = nbufp(i);
5475                 if (BUF_ISLOCKED(bp)) {
5476                         db_show_buffer((uintptr_t)bp, 1, 0, NULL);
5477                         db_printf("\n");
5478                         if (db_pager_quit)
5479                                 break;
5480                 }
5481         }
5482 }
5483
5484 DB_SHOW_COMMAND(vnodebufs, db_show_vnodebufs)
5485 {
5486         struct vnode *vp;
5487         struct buf *bp;
5488
5489         if (!have_addr) {
5490                 db_printf("usage: show vnodebufs <addr>\n");
5491                 return;
5492         }
5493         vp = (struct vnode *)addr;
5494         db_printf("Clean buffers:\n");
5495         TAILQ_FOREACH(bp, &vp->v_bufobj.bo_clean.bv_hd, b_bobufs) {
5496                 db_show_buffer((uintptr_t)bp, 1, 0, NULL);
5497                 db_printf("\n");
5498         }
5499         db_printf("Dirty buffers:\n");
5500         TAILQ_FOREACH(bp, &vp->v_bufobj.bo_dirty.bv_hd, b_bobufs) {
5501                 db_show_buffer((uintptr_t)bp, 1, 0, NULL);
5502                 db_printf("\n");
5503         }
5504 }
5505
5506 DB_COMMAND(countfreebufs, db_coundfreebufs)
5507 {
5508         struct buf *bp;
5509         int i, used = 0, nfree = 0;
5510
5511         if (have_addr) {
5512                 db_printf("usage: countfreebufs\n");
5513                 return;
5514         }
5515
5516         for (i = 0; i < nbuf; i++) {
5517                 bp = nbufp(i);
5518                 if (bp->b_qindex == QUEUE_EMPTY)
5519                         nfree++;
5520                 else
5521                         used++;
5522         }
5523
5524         db_printf("Counted %d free, %d used (%d tot)\n", nfree, used,
5525             nfree + used);
5526         db_printf("numfreebuffers is %d\n", numfreebuffers);
5527 }
5528 #endif /* DDB */