1 /* 2 * Copyright (c) 1994,1997 John S. Dyson 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice immediately at the beginning of the file, without modification, 10 * this list of conditions, and the following disclaimer. 11 * 2. Absolutely no warranty of function or purpose is made by the author 12 * John S. Dyson. 13 * 14 * $FreeBSD: src/sys/kern/vfs_bio.c,v 1.242.2.20 2003/05/28 18:38:10 alc Exp $ 15 */ 16 17 /* 18 * this file contains a new buffer I/O scheme implementing a coherent 19 * VM object and buffer cache scheme. Pains have been taken to make 20 * sure that the performance degradation associated with schemes such 21 * as this is not realized. 22 * 23 * Author: John S. Dyson 24 * Significant help during the development and debugging phases 25 * had been provided by David Greenman, also of the FreeBSD core team. 26 * 27 * see man buf(9) for more info. Note that man buf(9) doesn't reflect 28 * the actual buf/bio implementation in DragonFly. 29 */ 30 31 #include <sys/param.h> 32 #include <sys/systm.h> 33 #include <sys/buf.h> 34 #include <sys/conf.h> 35 #include <sys/devicestat.h> 36 #include <sys/eventhandler.h> 37 #include <sys/lock.h> 38 #include <sys/malloc.h> 39 #include <sys/mount.h> 40 #include <sys/kernel.h> 41 #include <sys/kthread.h> 42 #include <sys/proc.h> 43 #include <sys/reboot.h> 44 #include <sys/resourcevar.h> 45 #include <sys/sysctl.h> 46 #include <sys/vmmeter.h> 47 #include <sys/vnode.h> 48 #include <sys/dsched.h> 49 #include <vm/vm.h> 50 #include <vm/vm_param.h> 51 #include <vm/vm_kern.h> 52 #include <vm/vm_pageout.h> 53 #include <vm/vm_page.h> 54 #include <vm/vm_object.h> 55 #include <vm/vm_extern.h> 56 #include <vm/vm_map.h> 57 #include <vm/vm_pager.h> 58 #include <vm/swap_pager.h> 59 60 #include <sys/buf2.h> 61 #include <sys/thread2.h> 62 #include <sys/spinlock2.h> 63 #include <vm/vm_page2.h> 64 65 #include "opt_ddb.h" 66 #ifdef DDB 67 #include <ddb/ddb.h> 68 #endif 69 70 /* 71 * Buffer queues. 72 */ 73 enum bufq_type { 74 BQUEUE_NONE, /* not on any queue */ 75 BQUEUE_LOCKED, /* locked buffers */ 76 BQUEUE_CLEAN, /* non-B_DELWRI buffers */ 77 BQUEUE_DIRTY, /* B_DELWRI buffers */ 78 BQUEUE_DIRTY_HW, /* B_DELWRI buffers - heavy weight */ 79 BQUEUE_EMPTY, /* empty buffer headers */ 80 81 BUFFER_QUEUES /* number of buffer queues */ 82 }; 83 84 typedef enum bufq_type bufq_type_t; 85 86 #define BD_WAKE_SIZE 16384 87 #define BD_WAKE_MASK (BD_WAKE_SIZE - 1) 88 89 TAILQ_HEAD(bqueues, buf); 90 91 struct bufpcpu { 92 struct spinlock spin; 93 struct bqueues bufqueues[BUFFER_QUEUES]; 94 } __cachealign; 95 96 struct bufpcpu bufpcpu[MAXCPU]; 97 98 static MALLOC_DEFINE(M_BIOBUF, "BIO buffer", "BIO buffer"); 99 100 struct buf *buf; /* buffer header pool */ 101 102 static void vfs_clean_pages(struct buf *bp); 103 static void vfs_clean_one_page(struct buf *bp, int pageno, vm_page_t m); 104 #if 0 105 static void vfs_dirty_one_page(struct buf *bp, int pageno, vm_page_t m); 106 #endif 107 static void vfs_vmio_release(struct buf *bp); 108 static int flushbufqueues(struct buf *marker, bufq_type_t q); 109 static vm_page_t bio_page_alloc(struct buf *bp, vm_object_t obj, 110 vm_pindex_t pg, int deficit); 111 112 static void bd_signal(long totalspace); 113 static void buf_daemon(void); 114 static void buf_daemon_hw(void); 115 116 /* 117 * bogus page -- for I/O to/from partially complete buffers 118 * this is a temporary solution to the problem, but it is not 119 * really that bad. it would be better to split the buffer 120 * for input in the case of buffers partially already in memory, 121 * but the code is intricate enough already. 122 */ 123 vm_page_t bogus_page; 124 125 /* 126 * These are all static, but make the ones we export globals so we do 127 * not need to use compiler magic. 128 */ 129 long bufspace; /* atomic ops */ 130 long maxbufspace; 131 long maxbufmallocspace, lobufspace, hibufspace; 132 static long lorunningspace; 133 static long hirunningspace; 134 static long dirtykvaspace; /* atomic */ 135 long dirtybufspace; /* atomic (global for systat) */ 136 static long dirtybufcount; /* atomic */ 137 static long dirtybufspacehw; /* atomic */ 138 static long dirtybufcounthw; /* atomic */ 139 static long runningbufspace; /* atomic */ 140 static long runningbufcount; /* atomic */ 141 long lodirtybufspace; 142 long hidirtybufspace; 143 static int getnewbufcalls; 144 static int needsbuffer; /* atomic */ 145 static int runningbufreq; /* atomic */ 146 static int bd_request; /* atomic */ 147 static int bd_request_hw; /* atomic */ 148 static u_int bd_wake_ary[BD_WAKE_SIZE]; 149 static u_int bd_wake_index; 150 static u_int vm_cycle_point = 40; /* 23-36 will migrate more act->inact */ 151 static int debug_commit; 152 static int debug_bufbio; 153 static int debug_kvabio; 154 static long bufcache_bw = 200 * 1024 * 1024; 155 156 static struct thread *bufdaemon_td; 157 static struct thread *bufdaemonhw_td; 158 static u_int lowmempgallocs; 159 static u_int flushperqueue = 1024; 160 161 /* 162 * Sysctls for operational control of the buffer cache. 163 */ 164 SYSCTL_UINT(_vfs, OID_AUTO, flushperqueue, CTLFLAG_RW, &flushperqueue, 0, 165 "Number of buffers to flush from each per-cpu queue"); 166 SYSCTL_LONG(_vfs, OID_AUTO, lodirtybufspace, CTLFLAG_RW, &lodirtybufspace, 0, 167 "Number of dirty buffers to flush before bufdaemon becomes inactive"); 168 SYSCTL_LONG(_vfs, OID_AUTO, hidirtybufspace, CTLFLAG_RW, &hidirtybufspace, 0, 169 "High watermark used to trigger explicit flushing of dirty buffers"); 170 SYSCTL_LONG(_vfs, OID_AUTO, lorunningspace, CTLFLAG_RW, &lorunningspace, 0, 171 "Minimum amount of buffer space required for active I/O"); 172 SYSCTL_LONG(_vfs, OID_AUTO, hirunningspace, CTLFLAG_RW, &hirunningspace, 0, 173 "Maximum amount of buffer space to usable for active I/O"); 174 SYSCTL_LONG(_vfs, OID_AUTO, bufcache_bw, CTLFLAG_RW, &bufcache_bw, 0, 175 "Buffer-cache -> VM page cache transfer bandwidth"); 176 SYSCTL_UINT(_vfs, OID_AUTO, lowmempgallocs, CTLFLAG_RW, &lowmempgallocs, 0, 177 "Page allocations done during periods of very low free memory"); 178 SYSCTL_UINT(_vfs, OID_AUTO, vm_cycle_point, CTLFLAG_RW, &vm_cycle_point, 0, 179 "Recycle pages to active or inactive queue transition pt 0-64"); 180 /* 181 * Sysctls determining current state of the buffer cache. 182 */ 183 SYSCTL_LONG(_vfs, OID_AUTO, nbuf, CTLFLAG_RD, &nbuf, 0, 184 "Total number of buffers in buffer cache"); 185 SYSCTL_LONG(_vfs, OID_AUTO, dirtykvaspace, CTLFLAG_RD, &dirtykvaspace, 0, 186 "KVA reserved by dirty buffers (all)"); 187 SYSCTL_LONG(_vfs, OID_AUTO, dirtybufspace, CTLFLAG_RD, &dirtybufspace, 0, 188 "Pending bytes of dirty buffers (all)"); 189 SYSCTL_LONG(_vfs, OID_AUTO, dirtybufspacehw, CTLFLAG_RD, &dirtybufspacehw, 0, 190 "Pending bytes of dirty buffers (heavy weight)"); 191 SYSCTL_LONG(_vfs, OID_AUTO, dirtybufcount, CTLFLAG_RD, &dirtybufcount, 0, 192 "Pending number of dirty buffers"); 193 SYSCTL_LONG(_vfs, OID_AUTO, dirtybufcounthw, CTLFLAG_RD, &dirtybufcounthw, 0, 194 "Pending number of dirty buffers (heavy weight)"); 195 SYSCTL_LONG(_vfs, OID_AUTO, runningbufspace, CTLFLAG_RD, &runningbufspace, 0, 196 "I/O bytes currently in progress due to asynchronous writes"); 197 SYSCTL_LONG(_vfs, OID_AUTO, runningbufcount, CTLFLAG_RD, &runningbufcount, 0, 198 "I/O buffers currently in progress due to asynchronous writes"); 199 SYSCTL_LONG(_vfs, OID_AUTO, maxbufspace, CTLFLAG_RD, &maxbufspace, 0, 200 "Hard limit on maximum amount of memory usable for buffer space"); 201 SYSCTL_LONG(_vfs, OID_AUTO, hibufspace, CTLFLAG_RD, &hibufspace, 0, 202 "Soft limit on maximum amount of memory usable for buffer space"); 203 SYSCTL_LONG(_vfs, OID_AUTO, lobufspace, CTLFLAG_RD, &lobufspace, 0, 204 "Minimum amount of memory to reserve for system buffer space"); 205 SYSCTL_LONG(_vfs, OID_AUTO, bufspace, CTLFLAG_RD, &bufspace, 0, 206 "Amount of memory available for buffers"); 207 SYSCTL_LONG(_vfs, OID_AUTO, maxmallocbufspace, CTLFLAG_RD, &maxbufmallocspace, 208 0, "Maximum amount of memory reserved for buffers using malloc"); 209 SYSCTL_INT(_vfs, OID_AUTO, getnewbufcalls, CTLFLAG_RD, &getnewbufcalls, 0, 210 "New buffer header acquisition requests"); 211 SYSCTL_INT(_vfs, OID_AUTO, debug_commit, CTLFLAG_RW, &debug_commit, 0, ""); 212 SYSCTL_INT(_vfs, OID_AUTO, debug_bufbio, CTLFLAG_RW, &debug_bufbio, 0, ""); 213 SYSCTL_INT(_vfs, OID_AUTO, debug_kvabio, CTLFLAG_RW, &debug_kvabio, 0, ""); 214 SYSCTL_INT(_debug_sizeof, OID_AUTO, buf, CTLFLAG_RD, 0, sizeof(struct buf), 215 "sizeof(struct buf)"); 216 217 char *buf_wmesg = BUF_WMESG; 218 219 #define VFS_BIO_NEED_ANY 0x01 /* any freeable buffer */ 220 #define VFS_BIO_NEED_UNUSED02 0x02 221 #define VFS_BIO_NEED_UNUSED04 0x04 222 #define VFS_BIO_NEED_BUFSPACE 0x08 /* wait for buf space, lo hysteresis */ 223 224 /* 225 * Called when buffer space is potentially available for recovery. 226 * getnewbuf() will block on this flag when it is unable to free 227 * sufficient buffer space. Buffer space becomes recoverable when 228 * bp's get placed back in the queues. 229 */ 230 static __inline void 231 bufspacewakeup(void) 232 { 233 /* 234 * If someone is waiting for BUF space, wake them up. Even 235 * though we haven't freed the kva space yet, the waiting 236 * process will be able to now. 237 */ 238 for (;;) { 239 int flags = needsbuffer; 240 cpu_ccfence(); 241 if ((flags & VFS_BIO_NEED_BUFSPACE) == 0) 242 break; 243 if (atomic_cmpset_int(&needsbuffer, flags, 244 flags & ~VFS_BIO_NEED_BUFSPACE)) { 245 wakeup(&needsbuffer); 246 break; 247 } 248 /* retry */ 249 } 250 } 251 252 /* 253 * runningbufwakeup: 254 * 255 * Accounting for I/O in progress. 256 * 257 */ 258 static __inline void 259 runningbufwakeup(struct buf *bp) 260 { 261 long totalspace; 262 long flags; 263 264 if ((totalspace = bp->b_runningbufspace) != 0) { 265 atomic_add_long(&runningbufspace, -totalspace); 266 atomic_add_long(&runningbufcount, -1); 267 bp->b_runningbufspace = 0; 268 269 /* 270 * see waitrunningbufspace() for limit test. 271 */ 272 for (;;) { 273 flags = runningbufreq; 274 cpu_ccfence(); 275 if (flags == 0) 276 break; 277 if (atomic_cmpset_int(&runningbufreq, flags, 0)) { 278 wakeup(&runningbufreq); 279 break; 280 } 281 /* retry */ 282 } 283 bd_signal(totalspace); 284 } 285 } 286 287 /* 288 * bufcountwakeup: 289 * 290 * Called when a buffer has been added to one of the free queues to 291 * account for the buffer and to wakeup anyone waiting for free buffers. 292 * This typically occurs when large amounts of metadata are being handled 293 * by the buffer cache ( else buffer space runs out first, usually ). 294 */ 295 static __inline void 296 bufcountwakeup(void) 297 { 298 long flags; 299 300 for (;;) { 301 flags = needsbuffer; 302 if (flags == 0) 303 break; 304 if (atomic_cmpset_int(&needsbuffer, flags, 305 (flags & ~VFS_BIO_NEED_ANY))) { 306 wakeup(&needsbuffer); 307 break; 308 } 309 /* retry */ 310 } 311 } 312 313 /* 314 * waitrunningbufspace() 315 * 316 * If runningbufspace exceeds 4/6 hirunningspace we block until 317 * runningbufspace drops to 3/6 hirunningspace. We also block if another 318 * thread blocked here in order to be fair, even if runningbufspace 319 * is now lower than the limit. 320 * 321 * The caller may be using this function to block in a tight loop, we 322 * must block while runningbufspace is greater than at least 323 * hirunningspace * 3 / 6. 324 */ 325 void 326 waitrunningbufspace(void) 327 { 328 long limit = hirunningspace * 4 / 6; 329 long flags; 330 331 while (runningbufspace > limit || runningbufreq) { 332 tsleep_interlock(&runningbufreq, 0); 333 flags = atomic_fetchadd_int(&runningbufreq, 1); 334 if (runningbufspace > limit || flags) 335 tsleep(&runningbufreq, PINTERLOCKED, "wdrn1", hz); 336 } 337 } 338 339 /* 340 * buf_dirty_count_severe: 341 * 342 * Return true if we have too many dirty buffers. 343 */ 344 int 345 buf_dirty_count_severe(void) 346 { 347 return (runningbufspace + dirtykvaspace >= hidirtybufspace || 348 dirtybufcount >= nbuf / 2); 349 } 350 351 /* 352 * Return true if the amount of running I/O is severe and BIOQ should 353 * start bursting. 354 */ 355 int 356 buf_runningbufspace_severe(void) 357 { 358 return (runningbufspace >= hirunningspace * 4 / 6); 359 } 360 361 /* 362 * vfs_buf_test_cache: 363 * 364 * Called when a buffer is extended. This function clears the B_CACHE 365 * bit if the newly extended portion of the buffer does not contain 366 * valid data. 367 * 368 * NOTE! Dirty VM pages are not processed into dirty (B_DELWRI) buffer 369 * cache buffers. The VM pages remain dirty, as someone had mmap()'d 370 * them while a clean buffer was present. 371 */ 372 static __inline__ 373 void 374 vfs_buf_test_cache(struct buf *bp, 375 vm_ooffset_t foff, vm_offset_t off, vm_offset_t size, 376 vm_page_t m) 377 { 378 if (bp->b_flags & B_CACHE) { 379 int base = (foff + off) & PAGE_MASK; 380 if (vm_page_is_valid(m, base, size) == 0) 381 bp->b_flags &= ~B_CACHE; 382 } 383 } 384 385 /* 386 * bd_speedup() 387 * 388 * Spank the buf_daemon[_hw] if the total dirty buffer space exceeds the 389 * low water mark. 390 */ 391 static __inline__ 392 void 393 bd_speedup(void) 394 { 395 if (dirtykvaspace < lodirtybufspace && dirtybufcount < nbuf / 2) 396 return; 397 398 if (bd_request == 0 && 399 (dirtykvaspace > lodirtybufspace / 2 || 400 dirtybufcount - dirtybufcounthw >= nbuf / 2)) { 401 if (atomic_fetchadd_int(&bd_request, 1) == 0) 402 wakeup(&bd_request); 403 } 404 if (bd_request_hw == 0 && 405 (dirtykvaspace > lodirtybufspace / 2 || 406 dirtybufcounthw >= nbuf / 2)) { 407 if (atomic_fetchadd_int(&bd_request_hw, 1) == 0) 408 wakeup(&bd_request_hw); 409 } 410 } 411 412 /* 413 * bd_heatup() 414 * 415 * Get the buf_daemon heated up when the number of running and dirty 416 * buffers exceeds the mid-point. 417 * 418 * Return the total number of dirty bytes past the second mid point 419 * as a measure of how much excess dirty data there is in the system. 420 */ 421 long 422 bd_heatup(void) 423 { 424 long mid1; 425 long mid2; 426 long totalspace; 427 428 mid1 = lodirtybufspace + (hidirtybufspace - lodirtybufspace) / 2; 429 430 totalspace = runningbufspace + dirtykvaspace; 431 if (totalspace >= mid1 || dirtybufcount >= nbuf / 2) { 432 bd_speedup(); 433 mid2 = mid1 + (hidirtybufspace - mid1) / 2; 434 if (totalspace >= mid2) 435 return(totalspace - mid2); 436 } 437 return(0); 438 } 439 440 /* 441 * bd_wait() 442 * 443 * Wait for the buffer cache to flush (totalspace) bytes worth of 444 * buffers, then return. 445 * 446 * Regardless this function blocks while the number of dirty buffers 447 * exceeds hidirtybufspace. 448 */ 449 void 450 bd_wait(long totalspace) 451 { 452 u_int i; 453 u_int j; 454 u_int mi; 455 int count; 456 457 if (curthread == bufdaemonhw_td || curthread == bufdaemon_td) 458 return; 459 460 while (totalspace > 0) { 461 bd_heatup(); 462 463 /* 464 * Order is important. Suppliers adjust bd_wake_index after 465 * updating runningbufspace/dirtykvaspace. We want to fetch 466 * bd_wake_index before accessing. Any error should thus 467 * be in our favor. 468 */ 469 i = atomic_fetchadd_int(&bd_wake_index, 0); 470 if (totalspace > runningbufspace + dirtykvaspace) 471 totalspace = runningbufspace + dirtykvaspace; 472 count = totalspace / MAXBSIZE; 473 if (count >= BD_WAKE_SIZE / 2) 474 count = BD_WAKE_SIZE / 2; 475 i = i + count; 476 mi = i & BD_WAKE_MASK; 477 478 /* 479 * This is not a strict interlock, so we play a bit loose 480 * with locking access to dirtybufspace*. We have to re-check 481 * bd_wake_index to ensure that it hasn't passed us. 482 */ 483 tsleep_interlock(&bd_wake_ary[mi], 0); 484 atomic_add_int(&bd_wake_ary[mi], 1); 485 j = atomic_fetchadd_int(&bd_wake_index, 0); 486 if ((int)(i - j) >= 0) 487 tsleep(&bd_wake_ary[mi], PINTERLOCKED, "flstik", hz); 488 489 totalspace = runningbufspace + dirtykvaspace - hidirtybufspace; 490 } 491 } 492 493 /* 494 * bd_signal() 495 * 496 * This function is called whenever runningbufspace or dirtykvaspace 497 * is reduced. Track threads waiting for run+dirty buffer I/O 498 * complete. 499 */ 500 static void 501 bd_signal(long totalspace) 502 { 503 u_int i; 504 505 if (totalspace > 0) { 506 if (totalspace > MAXBSIZE * BD_WAKE_SIZE) 507 totalspace = MAXBSIZE * BD_WAKE_SIZE; 508 while (totalspace > 0) { 509 i = atomic_fetchadd_int(&bd_wake_index, 1); 510 i &= BD_WAKE_MASK; 511 if (atomic_readandclear_int(&bd_wake_ary[i])) 512 wakeup(&bd_wake_ary[i]); 513 totalspace -= MAXBSIZE; 514 } 515 } 516 } 517 518 /* 519 * BIO tracking support routines. 520 * 521 * Release a ref on a bio_track. Wakeup requests are atomically released 522 * along with the last reference so bk_active will never wind up set to 523 * only 0x80000000. 524 */ 525 static 526 void 527 bio_track_rel(struct bio_track *track) 528 { 529 int active; 530 int desired; 531 532 /* 533 * Shortcut 534 */ 535 active = track->bk_active; 536 if (active == 1 && atomic_cmpset_int(&track->bk_active, 1, 0)) 537 return; 538 539 /* 540 * Full-on. Note that the wait flag is only atomically released on 541 * the 1->0 count transition. 542 * 543 * We check for a negative count transition using bit 30 since bit 31 544 * has a different meaning. 545 */ 546 for (;;) { 547 desired = (active & 0x7FFFFFFF) - 1; 548 if (desired) 549 desired |= active & 0x80000000; 550 if (atomic_cmpset_int(&track->bk_active, active, desired)) { 551 if (desired & 0x40000000) 552 panic("bio_track_rel: bad count: %p", track); 553 if (active & 0x80000000) 554 wakeup(track); 555 break; 556 } 557 active = track->bk_active; 558 } 559 } 560 561 /* 562 * Wait for the tracking count to reach 0. 563 * 564 * Use atomic ops such that the wait flag is only set atomically when 565 * bk_active is non-zero. 566 */ 567 int 568 bio_track_wait(struct bio_track *track, int slp_flags, int slp_timo) 569 { 570 int active; 571 int desired; 572 int error; 573 574 /* 575 * Shortcut 576 */ 577 if (track->bk_active == 0) 578 return(0); 579 580 /* 581 * Full-on. Note that the wait flag may only be atomically set if 582 * the active count is non-zero. 583 * 584 * NOTE: We cannot optimize active == desired since a wakeup could 585 * clear active prior to our tsleep_interlock(). 586 */ 587 error = 0; 588 while ((active = track->bk_active) != 0) { 589 cpu_ccfence(); 590 desired = active | 0x80000000; 591 tsleep_interlock(track, slp_flags); 592 if (atomic_cmpset_int(&track->bk_active, active, desired)) { 593 error = tsleep(track, slp_flags | PINTERLOCKED, 594 "trwait", slp_timo); 595 if (error) 596 break; 597 } 598 } 599 return (error); 600 } 601 602 /* 603 * bufinit: 604 * 605 * Load time initialisation of the buffer cache, called from machine 606 * dependant initialization code. 607 */ 608 static 609 void 610 bufinit(void *dummy __unused) 611 { 612 struct bufpcpu *pcpu; 613 struct buf *bp; 614 vm_offset_t bogus_offset; 615 int i; 616 int j; 617 long n; 618 619 /* next, make a null set of free lists */ 620 for (i = 0; i < ncpus; ++i) { 621 pcpu = &bufpcpu[i]; 622 spin_init(&pcpu->spin, "bufinit"); 623 for (j = 0; j < BUFFER_QUEUES; j++) 624 TAILQ_INIT(&pcpu->bufqueues[j]); 625 } 626 627 /* 628 * Finally, initialize each buffer header and stick on empty q. 629 * Each buffer gets its own KVA reservation. 630 */ 631 i = 0; 632 pcpu = &bufpcpu[i]; 633 634 for (n = 0; n < nbuf; n++) { 635 bp = &buf[n]; 636 bzero(bp, sizeof *bp); 637 bp->b_flags = B_INVAL; /* we're just an empty header */ 638 bp->b_cmd = BUF_CMD_DONE; 639 bp->b_qindex = BQUEUE_EMPTY; 640 bp->b_qcpu = i; 641 bp->b_kvabase = (void *)(vm_map_min(&buffer_map) + 642 MAXBSIZE * n); 643 bp->b_kvasize = MAXBSIZE; 644 initbufbio(bp); 645 xio_init(&bp->b_xio); 646 buf_dep_init(bp); 647 TAILQ_INSERT_TAIL(&pcpu->bufqueues[bp->b_qindex], 648 bp, b_freelist); 649 650 i = (i + 1) % ncpus; 651 pcpu = &bufpcpu[i]; 652 } 653 654 /* 655 * maxbufspace is the absolute maximum amount of buffer space we are 656 * allowed to reserve in KVM and in real terms. The absolute maximum 657 * is nominally used by buf_daemon. hibufspace is the nominal maximum 658 * used by most other processes. The differential is required to 659 * ensure that buf_daemon is able to run when other processes might 660 * be blocked waiting for buffer space. 661 * 662 * Calculate hysteresis (lobufspace, hibufspace). Don't make it 663 * too large or we might lockup a cpu for too long a period of 664 * time in our tight loop. 665 */ 666 maxbufspace = nbuf * NBUFCALCSIZE; 667 hibufspace = lmax(3 * maxbufspace / 4, maxbufspace - MAXBSIZE * 10); 668 lobufspace = hibufspace * 7 / 8; 669 if (hibufspace - lobufspace > 64 * 1024 * 1024) 670 lobufspace = hibufspace - 64 * 1024 * 1024; 671 if (lobufspace > hibufspace - MAXBSIZE) 672 lobufspace = hibufspace - MAXBSIZE; 673 674 lorunningspace = 512 * 1024; 675 /* hirunningspace -- see below */ 676 677 /* 678 * Limit the amount of malloc memory since it is wired permanently 679 * into the kernel space. Even though this is accounted for in 680 * the buffer allocation, we don't want the malloced region to grow 681 * uncontrolled. The malloc scheme improves memory utilization 682 * significantly on average (small) directories. 683 */ 684 maxbufmallocspace = hibufspace / 20; 685 686 /* 687 * Reduce the chance of a deadlock occuring by limiting the number 688 * of delayed-write dirty buffers we allow to stack up. 689 * 690 * We don't want too much actually queued to the device at once 691 * (XXX this needs to be per-mount!), because the buffers will 692 * wind up locked for a very long period of time while the I/O 693 * drains. 694 */ 695 hidirtybufspace = hibufspace / 2; /* dirty + running */ 696 hirunningspace = hibufspace / 16; /* locked & queued to device */ 697 if (hirunningspace < 1024 * 1024) 698 hirunningspace = 1024 * 1024; 699 700 dirtykvaspace = 0; 701 dirtybufspace = 0; 702 dirtybufspacehw = 0; 703 704 lodirtybufspace = hidirtybufspace / 2; 705 706 /* 707 * Maximum number of async ops initiated per buf_daemon loop. This is 708 * somewhat of a hack at the moment, we really need to limit ourselves 709 * based on the number of bytes of I/O in-transit that were initiated 710 * from buf_daemon. 711 */ 712 713 bogus_offset = kmem_alloc_pageable(&kernel_map, PAGE_SIZE, 714 VM_SUBSYS_BOGUS); 715 vm_object_hold(&kernel_object); 716 bogus_page = vm_page_alloc(&kernel_object, 717 (bogus_offset >> PAGE_SHIFT), 718 VM_ALLOC_NORMAL); 719 vm_object_drop(&kernel_object); 720 vmstats.v_wire_count++; 721 722 } 723 724 SYSINIT(do_bufinit, SI_BOOT2_MACHDEP, SI_ORDER_FIRST, bufinit, NULL); 725 726 /* 727 * Initialize the embedded bio structures, typically used by 728 * deprecated code which tries to allocate its own struct bufs. 729 */ 730 void 731 initbufbio(struct buf *bp) 732 { 733 bp->b_bio1.bio_buf = bp; 734 bp->b_bio1.bio_prev = NULL; 735 bp->b_bio1.bio_offset = NOOFFSET; 736 bp->b_bio1.bio_next = &bp->b_bio2; 737 bp->b_bio1.bio_done = NULL; 738 bp->b_bio1.bio_flags = 0; 739 740 bp->b_bio2.bio_buf = bp; 741 bp->b_bio2.bio_prev = &bp->b_bio1; 742 bp->b_bio2.bio_offset = NOOFFSET; 743 bp->b_bio2.bio_next = NULL; 744 bp->b_bio2.bio_done = NULL; 745 bp->b_bio2.bio_flags = 0; 746 747 BUF_LOCKINIT(bp); 748 } 749 750 /* 751 * Reinitialize the embedded bio structures as well as any additional 752 * translation cache layers. 753 */ 754 void 755 reinitbufbio(struct buf *bp) 756 { 757 struct bio *bio; 758 759 for (bio = &bp->b_bio1; bio; bio = bio->bio_next) { 760 bio->bio_done = NULL; 761 bio->bio_offset = NOOFFSET; 762 } 763 } 764 765 /* 766 * Undo the effects of an initbufbio(). 767 */ 768 void 769 uninitbufbio(struct buf *bp) 770 { 771 dsched_buf_exit(bp); 772 BUF_LOCKFREE(bp); 773 } 774 775 /* 776 * Push another BIO layer onto an existing BIO and return it. The new 777 * BIO layer may already exist, holding cached translation data. 778 */ 779 struct bio * 780 push_bio(struct bio *bio) 781 { 782 struct bio *nbio; 783 784 if ((nbio = bio->bio_next) == NULL) { 785 int index = bio - &bio->bio_buf->b_bio_array[0]; 786 if (index >= NBUF_BIO - 1) { 787 panic("push_bio: too many layers %d for bp %p", 788 index, bio->bio_buf); 789 } 790 nbio = &bio->bio_buf->b_bio_array[index + 1]; 791 bio->bio_next = nbio; 792 nbio->bio_prev = bio; 793 nbio->bio_buf = bio->bio_buf; 794 nbio->bio_offset = NOOFFSET; 795 nbio->bio_done = NULL; 796 nbio->bio_next = NULL; 797 } 798 KKASSERT(nbio->bio_done == NULL); 799 return(nbio); 800 } 801 802 /* 803 * Pop a BIO translation layer, returning the previous layer. The 804 * must have been previously pushed. 805 */ 806 struct bio * 807 pop_bio(struct bio *bio) 808 { 809 return(bio->bio_prev); 810 } 811 812 void 813 clearbiocache(struct bio *bio) 814 { 815 while (bio) { 816 bio->bio_offset = NOOFFSET; 817 bio = bio->bio_next; 818 } 819 } 820 821 /* 822 * Remove the buffer from the appropriate free list. 823 * (caller must be locked) 824 */ 825 static __inline void 826 _bremfree(struct buf *bp) 827 { 828 struct bufpcpu *pcpu = &bufpcpu[bp->b_qcpu]; 829 830 if (bp->b_qindex != BQUEUE_NONE) { 831 KASSERT(BUF_LOCKINUSE(bp), ("bremfree: bp %p not locked", bp)); 832 TAILQ_REMOVE(&pcpu->bufqueues[bp->b_qindex], bp, b_freelist); 833 bp->b_qindex = BQUEUE_NONE; 834 } else { 835 if (!BUF_LOCKINUSE(bp)) 836 panic("bremfree: removing a buffer not on a queue"); 837 } 838 } 839 840 /* 841 * bremfree() - must be called with a locked buffer 842 */ 843 void 844 bremfree(struct buf *bp) 845 { 846 struct bufpcpu *pcpu = &bufpcpu[bp->b_qcpu]; 847 848 spin_lock(&pcpu->spin); 849 _bremfree(bp); 850 spin_unlock(&pcpu->spin); 851 } 852 853 /* 854 * bremfree_locked - must be called with pcpu->spin locked 855 */ 856 static void 857 bremfree_locked(struct buf *bp) 858 { 859 _bremfree(bp); 860 } 861 862 /* 863 * This version of bread issues any required I/O asyncnronously and 864 * makes a callback on completion. 865 * 866 * The callback must check whether BIO_DONE is set in the bio and issue 867 * the bpdone(bp, 0) if it isn't. The callback is responsible for clearing 868 * BIO_DONE and disposing of the I/O (bqrelse()ing it). 869 */ 870 void 871 breadcb(struct vnode *vp, off_t loffset, int size, int bflags, 872 void (*func)(struct bio *), void *arg) 873 { 874 struct buf *bp; 875 876 bp = getblk(vp, loffset, size, 0, 0); 877 878 /* if not found in cache, do some I/O */ 879 if ((bp->b_flags & B_CACHE) == 0) { 880 bp->b_flags &= ~(B_ERROR | B_EINTR | B_INVAL | B_NOTMETA); 881 bp->b_flags |= bflags; 882 bp->b_cmd = BUF_CMD_READ; 883 bp->b_bio1.bio_done = func; 884 bp->b_bio1.bio_caller_info1.ptr = arg; 885 vfs_busy_pages(vp, bp); 886 BUF_KERNPROC(bp); 887 vn_strategy(vp, &bp->b_bio1); 888 } else if (func) { 889 /* 890 * Since we are issuing the callback synchronously it cannot 891 * race the BIO_DONE, so no need for atomic ops here. 892 */ 893 /*bp->b_bio1.bio_done = func;*/ 894 bp->b_bio1.bio_caller_info1.ptr = arg; 895 bp->b_bio1.bio_flags |= BIO_DONE; 896 func(&bp->b_bio1); 897 } else { 898 bqrelse(bp); 899 } 900 } 901 902 /* 903 * breadnx() - Terminal function for bread() and breadn(). 904 * 905 * This function will start asynchronous I/O on read-ahead blocks as well 906 * as satisfy the primary request. 907 * 908 * We must clear B_ERROR and B_INVAL prior to initiating I/O. If B_CACHE is 909 * set, the buffer is valid and we do not have to do anything. 910 */ 911 int 912 breadnx(struct vnode *vp, off_t loffset, int size, int bflags, 913 off_t *raoffset, int *rabsize, 914 int cnt, struct buf **bpp) 915 { 916 struct buf *bp, *rabp; 917 int i; 918 int rv = 0, readwait = 0; 919 int blkflags = (bflags & B_KVABIO) ? GETBLK_KVABIO : 0; 920 921 if (*bpp) 922 bp = *bpp; 923 else 924 *bpp = bp = getblk(vp, loffset, size, blkflags, 0); 925 926 /* if not found in cache, do some I/O */ 927 if ((bp->b_flags & B_CACHE) == 0) { 928 bp->b_flags &= ~(B_ERROR | B_EINTR | B_INVAL | B_NOTMETA); 929 bp->b_flags |= bflags; 930 bp->b_cmd = BUF_CMD_READ; 931 bp->b_bio1.bio_done = biodone_sync; 932 bp->b_bio1.bio_flags |= BIO_SYNC; 933 vfs_busy_pages(vp, bp); 934 vn_strategy(vp, &bp->b_bio1); 935 ++readwait; 936 } 937 938 for (i = 0; i < cnt; i++, raoffset++, rabsize++) { 939 if (inmem(vp, *raoffset)) 940 continue; 941 rabp = getblk(vp, *raoffset, *rabsize, GETBLK_KVABIO, 0); 942 943 if ((rabp->b_flags & B_CACHE) == 0) { 944 rabp->b_flags &= ~(B_ERROR | B_EINTR | 945 B_INVAL | B_NOTMETA); 946 rabp->b_flags |= (bflags & ~B_KVABIO); 947 rabp->b_cmd = BUF_CMD_READ; 948 vfs_busy_pages(vp, rabp); 949 BUF_KERNPROC(rabp); 950 vn_strategy(vp, &rabp->b_bio1); 951 } else { 952 brelse(rabp); 953 } 954 } 955 if (readwait) 956 rv = biowait(&bp->b_bio1, "biord"); 957 return (rv); 958 } 959 960 /* 961 * bwrite: 962 * 963 * Synchronous write, waits for completion. 964 * 965 * Write, release buffer on completion. (Done by iodone 966 * if async). Do not bother writing anything if the buffer 967 * is invalid. 968 * 969 * Note that we set B_CACHE here, indicating that buffer is 970 * fully valid and thus cacheable. This is true even of NFS 971 * now so we set it generally. This could be set either here 972 * or in biodone() since the I/O is synchronous. We put it 973 * here. 974 */ 975 int 976 bwrite(struct buf *bp) 977 { 978 int error; 979 980 if (bp->b_flags & B_INVAL) { 981 brelse(bp); 982 return (0); 983 } 984 if (BUF_LOCKINUSE(bp) == 0) 985 panic("bwrite: buffer is not busy???"); 986 987 /* 988 * NOTE: We no longer mark the buffer clear prior to the vn_strategy() 989 * call because it will remove the buffer from the vnode's 990 * dirty buffer list prematurely and possibly cause filesystem 991 * checks to race buffer flushes. This is now handled in 992 * bpdone(). 993 * 994 * bundirty(bp); REMOVED 995 */ 996 997 bp->b_flags &= ~(B_ERROR | B_EINTR); 998 bp->b_flags |= B_CACHE; 999 bp->b_cmd = BUF_CMD_WRITE; 1000 bp->b_error = 0; 1001 bp->b_bio1.bio_done = biodone_sync; 1002 bp->b_bio1.bio_flags |= BIO_SYNC; 1003 vfs_busy_pages(bp->b_vp, bp); 1004 1005 /* 1006 * Normal bwrites pipeline writes. NOTE: b_bufsize is only 1007 * valid for vnode-backed buffers. 1008 */ 1009 bsetrunningbufspace(bp, bp->b_bufsize); 1010 vn_strategy(bp->b_vp, &bp->b_bio1); 1011 error = biowait(&bp->b_bio1, "biows"); 1012 brelse(bp); 1013 1014 return (error); 1015 } 1016 1017 /* 1018 * bawrite: 1019 * 1020 * Asynchronous write. Start output on a buffer, but do not wait for 1021 * it to complete. The buffer is released when the output completes. 1022 * 1023 * bwrite() ( or the VOP routine anyway ) is responsible for handling 1024 * B_INVAL buffers. Not us. 1025 */ 1026 void 1027 bawrite(struct buf *bp) 1028 { 1029 if (bp->b_flags & B_INVAL) { 1030 brelse(bp); 1031 return; 1032 } 1033 if (BUF_LOCKINUSE(bp) == 0) 1034 panic("bawrite: buffer is not busy???"); 1035 1036 /* 1037 * NOTE: We no longer mark the buffer clear prior to the vn_strategy() 1038 * call because it will remove the buffer from the vnode's 1039 * dirty buffer list prematurely and possibly cause filesystem 1040 * checks to race buffer flushes. This is now handled in 1041 * bpdone(). 1042 * 1043 * bundirty(bp); REMOVED 1044 */ 1045 bp->b_flags &= ~(B_ERROR | B_EINTR); 1046 bp->b_flags |= B_CACHE; 1047 bp->b_cmd = BUF_CMD_WRITE; 1048 bp->b_error = 0; 1049 KKASSERT(bp->b_bio1.bio_done == NULL); 1050 vfs_busy_pages(bp->b_vp, bp); 1051 1052 /* 1053 * Normal bwrites pipeline writes. NOTE: b_bufsize is only 1054 * valid for vnode-backed buffers. 1055 */ 1056 bsetrunningbufspace(bp, bp->b_bufsize); 1057 BUF_KERNPROC(bp); 1058 vn_strategy(bp->b_vp, &bp->b_bio1); 1059 } 1060 1061 /* 1062 * bdwrite: 1063 * 1064 * Delayed write. (Buffer is marked dirty). Do not bother writing 1065 * anything if the buffer is marked invalid. 1066 * 1067 * Note that since the buffer must be completely valid, we can safely 1068 * set B_CACHE. In fact, we have to set B_CACHE here rather then in 1069 * biodone() in order to prevent getblk from writing the buffer 1070 * out synchronously. 1071 */ 1072 void 1073 bdwrite(struct buf *bp) 1074 { 1075 if (BUF_LOCKINUSE(bp) == 0) 1076 panic("bdwrite: buffer is not busy"); 1077 1078 if (bp->b_flags & B_INVAL) { 1079 brelse(bp); 1080 return; 1081 } 1082 bdirty(bp); 1083 1084 dsched_buf_enter(bp); /* might stack */ 1085 1086 /* 1087 * Set B_CACHE, indicating that the buffer is fully valid. This is 1088 * true even of NFS now. 1089 */ 1090 bp->b_flags |= B_CACHE; 1091 1092 /* 1093 * This bmap keeps the system from needing to do the bmap later, 1094 * perhaps when the system is attempting to do a sync. Since it 1095 * is likely that the indirect block -- or whatever other datastructure 1096 * that the filesystem needs is still in memory now, it is a good 1097 * thing to do this. Note also, that if the pageout daemon is 1098 * requesting a sync -- there might not be enough memory to do 1099 * the bmap then... So, this is important to do. 1100 */ 1101 if (bp->b_bio2.bio_offset == NOOFFSET) { 1102 VOP_BMAP(bp->b_vp, bp->b_loffset, &bp->b_bio2.bio_offset, 1103 NULL, NULL, BUF_CMD_WRITE); 1104 } 1105 1106 /* 1107 * Because the underlying pages may still be mapped and 1108 * writable trying to set the dirty buffer (b_dirtyoff/end) 1109 * range here will be inaccurate. 1110 * 1111 * However, we must still clean the pages to satisfy the 1112 * vnode_pager and pageout daemon, so they think the pages 1113 * have been "cleaned". What has really occured is that 1114 * they've been earmarked for later writing by the buffer 1115 * cache. 1116 * 1117 * So we get the b_dirtyoff/end update but will not actually 1118 * depend on it (NFS that is) until the pages are busied for 1119 * writing later on. 1120 */ 1121 vfs_clean_pages(bp); 1122 bqrelse(bp); 1123 1124 /* 1125 * note: we cannot initiate I/O from a bdwrite even if we wanted to, 1126 * due to the softdep code. 1127 */ 1128 } 1129 1130 /* 1131 * Fake write - return pages to VM system as dirty, leave the buffer clean. 1132 * This is used by tmpfs. 1133 * 1134 * It is important for any VFS using this routine to NOT use it for 1135 * IO_SYNC or IO_ASYNC operations which occur when the system really 1136 * wants to flush VM pages to backing store. 1137 */ 1138 void 1139 buwrite(struct buf *bp) 1140 { 1141 vm_page_t m; 1142 int i; 1143 1144 /* 1145 * Only works for VMIO buffers. If the buffer is already 1146 * marked for delayed-write we can't avoid the bdwrite(). 1147 */ 1148 if ((bp->b_flags & B_VMIO) == 0 || (bp->b_flags & B_DELWRI)) { 1149 bdwrite(bp); 1150 return; 1151 } 1152 1153 /* 1154 * Mark as needing a commit. 1155 */ 1156 for (i = 0; i < bp->b_xio.xio_npages; i++) { 1157 m = bp->b_xio.xio_pages[i]; 1158 vm_page_need_commit(m); 1159 } 1160 bqrelse(bp); 1161 } 1162 1163 /* 1164 * bdirty: 1165 * 1166 * Turn buffer into delayed write request by marking it B_DELWRI. 1167 * B_RELBUF and B_NOCACHE must be cleared. 1168 * 1169 * We reassign the buffer to itself to properly update it in the 1170 * dirty/clean lists. 1171 * 1172 * Must be called from a critical section. 1173 * The buffer must be on BQUEUE_NONE. 1174 */ 1175 void 1176 bdirty(struct buf *bp) 1177 { 1178 KASSERT(bp->b_qindex == BQUEUE_NONE, 1179 ("bdirty: buffer %p still on queue %d", bp, bp->b_qindex)); 1180 if (bp->b_flags & B_NOCACHE) { 1181 kprintf("bdirty: clearing B_NOCACHE on buf %p\n", bp); 1182 bp->b_flags &= ~B_NOCACHE; 1183 } 1184 if (bp->b_flags & B_INVAL) { 1185 kprintf("bdirty: warning, dirtying invalid buffer %p\n", bp); 1186 } 1187 bp->b_flags &= ~B_RELBUF; 1188 1189 if ((bp->b_flags & B_DELWRI) == 0) { 1190 lwkt_gettoken(&bp->b_vp->v_token); 1191 bp->b_flags |= B_DELWRI; 1192 reassignbuf(bp); 1193 lwkt_reltoken(&bp->b_vp->v_token); 1194 1195 atomic_add_long(&dirtybufcount, 1); 1196 atomic_add_long(&dirtykvaspace, bp->b_kvasize); 1197 atomic_add_long(&dirtybufspace, bp->b_bufsize); 1198 if (bp->b_flags & B_HEAVY) { 1199 atomic_add_long(&dirtybufcounthw, 1); 1200 atomic_add_long(&dirtybufspacehw, bp->b_bufsize); 1201 } 1202 bd_heatup(); 1203 } 1204 } 1205 1206 /* 1207 * Set B_HEAVY, indicating that this is a heavy-weight buffer that 1208 * needs to be flushed with a different buf_daemon thread to avoid 1209 * deadlocks. B_HEAVY also imposes restrictions in getnewbuf(). 1210 */ 1211 void 1212 bheavy(struct buf *bp) 1213 { 1214 if ((bp->b_flags & B_HEAVY) == 0) { 1215 bp->b_flags |= B_HEAVY; 1216 if (bp->b_flags & B_DELWRI) { 1217 atomic_add_long(&dirtybufcounthw, 1); 1218 atomic_add_long(&dirtybufspacehw, bp->b_bufsize); 1219 } 1220 } 1221 } 1222 1223 /* 1224 * bundirty: 1225 * 1226 * Clear B_DELWRI for buffer. 1227 * 1228 * Must be called from a critical section. 1229 * 1230 * The buffer is typically on BQUEUE_NONE but there is one case in 1231 * brelse() that calls this function after placing the buffer on 1232 * a different queue. 1233 */ 1234 void 1235 bundirty(struct buf *bp) 1236 { 1237 if (bp->b_flags & B_DELWRI) { 1238 lwkt_gettoken(&bp->b_vp->v_token); 1239 bp->b_flags &= ~B_DELWRI; 1240 reassignbuf(bp); 1241 lwkt_reltoken(&bp->b_vp->v_token); 1242 1243 atomic_add_long(&dirtybufcount, -1); 1244 atomic_add_long(&dirtykvaspace, -bp->b_kvasize); 1245 atomic_add_long(&dirtybufspace, -bp->b_bufsize); 1246 if (bp->b_flags & B_HEAVY) { 1247 atomic_add_long(&dirtybufcounthw, -1); 1248 atomic_add_long(&dirtybufspacehw, -bp->b_bufsize); 1249 } 1250 bd_signal(bp->b_bufsize); 1251 } 1252 /* 1253 * Since it is now being written, we can clear its deferred write flag. 1254 */ 1255 bp->b_flags &= ~B_DEFERRED; 1256 } 1257 1258 /* 1259 * Set the b_runningbufspace field, used to track how much I/O is 1260 * in progress at any given moment. 1261 */ 1262 void 1263 bsetrunningbufspace(struct buf *bp, int bytes) 1264 { 1265 bp->b_runningbufspace = bytes; 1266 if (bytes) { 1267 atomic_add_long(&runningbufspace, bytes); 1268 atomic_add_long(&runningbufcount, 1); 1269 } 1270 } 1271 1272 /* 1273 * brelse: 1274 * 1275 * Release a busy buffer and, if requested, free its resources. The 1276 * buffer will be stashed in the appropriate bufqueue[] allowing it 1277 * to be accessed later as a cache entity or reused for other purposes. 1278 */ 1279 void 1280 brelse(struct buf *bp) 1281 { 1282 struct bufpcpu *pcpu; 1283 #ifdef INVARIANTS 1284 int saved_flags = bp->b_flags; 1285 #endif 1286 1287 KASSERT(!(bp->b_flags & (B_CLUSTER|B_PAGING)), 1288 ("brelse: inappropriate B_PAGING or B_CLUSTER bp %p", bp)); 1289 1290 /* 1291 * If B_NOCACHE is set we are being asked to destroy the buffer and 1292 * its backing store. Clear B_DELWRI. 1293 * 1294 * B_NOCACHE is set in two cases: (1) when the caller really wants 1295 * to destroy the buffer and backing store and (2) when the caller 1296 * wants to destroy the buffer and backing store after a write 1297 * completes. 1298 */ 1299 if ((bp->b_flags & (B_NOCACHE|B_DELWRI)) == (B_NOCACHE|B_DELWRI)) { 1300 bundirty(bp); 1301 } 1302 1303 if ((bp->b_flags & (B_INVAL | B_DELWRI)) == B_DELWRI) { 1304 /* 1305 * A re-dirtied buffer is only subject to destruction 1306 * by B_INVAL. B_ERROR and B_NOCACHE are ignored. 1307 */ 1308 /* leave buffer intact */ 1309 } else if ((bp->b_flags & (B_NOCACHE | B_INVAL | B_ERROR)) || 1310 (bp->b_bufsize <= 0)) { 1311 /* 1312 * Either a failed read or we were asked to free or not 1313 * cache the buffer. This path is reached with B_DELWRI 1314 * set only if B_INVAL is already set. B_NOCACHE governs 1315 * backing store destruction. 1316 * 1317 * NOTE: HAMMER will set B_LOCKED in buf_deallocate if the 1318 * buffer cannot be immediately freed. 1319 */ 1320 bp->b_flags |= B_INVAL; 1321 if (LIST_FIRST(&bp->b_dep) != NULL) 1322 buf_deallocate(bp); 1323 if (bp->b_flags & B_DELWRI) { 1324 atomic_add_long(&dirtybufcount, -1); 1325 atomic_add_long(&dirtykvaspace, -bp->b_kvasize); 1326 atomic_add_long(&dirtybufspace, -bp->b_bufsize); 1327 if (bp->b_flags & B_HEAVY) { 1328 atomic_add_long(&dirtybufcounthw, -1); 1329 atomic_add_long(&dirtybufspacehw, 1330 -bp->b_bufsize); 1331 } 1332 bd_signal(bp->b_bufsize); 1333 } 1334 bp->b_flags &= ~(B_DELWRI | B_CACHE); 1335 } 1336 1337 /* 1338 * We must clear B_RELBUF if B_DELWRI or B_LOCKED is set, 1339 * or if b_refs is non-zero. 1340 * 1341 * If vfs_vmio_release() is called with either bit set, the 1342 * underlying pages may wind up getting freed causing a previous 1343 * write (bdwrite()) to get 'lost' because pages associated with 1344 * a B_DELWRI bp are marked clean. Pages associated with a 1345 * B_LOCKED buffer may be mapped by the filesystem. 1346 * 1347 * If we want to release the buffer ourselves (rather then the 1348 * originator asking us to release it), give the originator a 1349 * chance to countermand the release by setting B_LOCKED. 1350 * 1351 * We still allow the B_INVAL case to call vfs_vmio_release(), even 1352 * if B_DELWRI is set. 1353 * 1354 * If B_DELWRI is not set we may have to set B_RELBUF if we are low 1355 * on pages to return pages to the VM page queues. 1356 */ 1357 if ((bp->b_flags & (B_DELWRI | B_LOCKED)) || bp->b_refs) { 1358 bp->b_flags &= ~B_RELBUF; 1359 } else if (vm_page_count_min(0)) { 1360 if (LIST_FIRST(&bp->b_dep) != NULL) 1361 buf_deallocate(bp); /* can set B_LOCKED */ 1362 if (bp->b_flags & (B_DELWRI | B_LOCKED)) 1363 bp->b_flags &= ~B_RELBUF; 1364 else 1365 bp->b_flags |= B_RELBUF; 1366 } 1367 1368 /* 1369 * Make sure b_cmd is clear. It may have already been cleared by 1370 * biodone(). 1371 * 1372 * At this point destroying the buffer is governed by the B_INVAL 1373 * or B_RELBUF flags. 1374 */ 1375 bp->b_cmd = BUF_CMD_DONE; 1376 dsched_buf_exit(bp); 1377 1378 /* 1379 * VMIO buffer rundown. Make sure the VM page array is restored 1380 * after an I/O may have replaces some of the pages with bogus pages 1381 * in order to not destroy dirty pages in a fill-in read. 1382 * 1383 * Note that due to the code above, if a buffer is marked B_DELWRI 1384 * then the B_RELBUF and B_NOCACHE bits will always be clear. 1385 * B_INVAL may still be set, however. 1386 * 1387 * For clean buffers, B_INVAL or B_RELBUF will destroy the buffer 1388 * but not the backing store. B_NOCACHE will destroy the backing 1389 * store. 1390 * 1391 * Note that dirty NFS buffers contain byte-granular write ranges 1392 * and should not be destroyed w/ B_INVAL even if the backing store 1393 * is left intact. 1394 */ 1395 if (bp->b_flags & B_VMIO) { 1396 /* 1397 * Rundown for VMIO buffers which are not dirty NFS buffers. 1398 */ 1399 int i, j, resid; 1400 vm_page_t m; 1401 off_t foff; 1402 vm_pindex_t poff; 1403 vm_object_t obj; 1404 struct vnode *vp; 1405 1406 vp = bp->b_vp; 1407 1408 /* 1409 * Get the base offset and length of the buffer. Note that 1410 * in the VMIO case if the buffer block size is not 1411 * page-aligned then b_data pointer may not be page-aligned. 1412 * But our b_xio.xio_pages array *IS* page aligned. 1413 * 1414 * block sizes less then DEV_BSIZE (usually 512) are not 1415 * supported due to the page granularity bits (m->valid, 1416 * m->dirty, etc...). 1417 * 1418 * See man buf(9) for more information 1419 */ 1420 1421 resid = bp->b_bufsize; 1422 foff = bp->b_loffset; 1423 1424 for (i = 0; i < bp->b_xio.xio_npages; i++) { 1425 m = bp->b_xio.xio_pages[i]; 1426 1427 /* 1428 * If we hit a bogus page, fixup *all* of them 1429 * now. Note that we left these pages wired 1430 * when we removed them so they had better exist, 1431 * and they cannot be ripped out from under us so 1432 * no critical section protection is necessary. 1433 */ 1434 if (m == bogus_page) { 1435 obj = vp->v_object; 1436 poff = OFF_TO_IDX(bp->b_loffset); 1437 1438 vm_object_hold(obj); 1439 for (j = i; j < bp->b_xio.xio_npages; j++) { 1440 vm_page_t mtmp; 1441 1442 mtmp = bp->b_xio.xio_pages[j]; 1443 if (mtmp == bogus_page) { 1444 if ((bp->b_flags & B_HASBOGUS) == 0) 1445 panic("brelse: bp %p corrupt bogus", bp); 1446 mtmp = vm_page_lookup(obj, poff + j); 1447 if (!mtmp) 1448 panic("brelse: bp %p page %d missing", bp, j); 1449 bp->b_xio.xio_pages[j] = mtmp; 1450 } 1451 } 1452 vm_object_drop(obj); 1453 1454 if ((bp->b_flags & B_HASBOGUS) || 1455 (bp->b_flags & B_INVAL) == 0) { 1456 pmap_qenter_noinval( 1457 trunc_page((vm_offset_t)bp->b_data), 1458 bp->b_xio.xio_pages, 1459 bp->b_xio.xio_npages); 1460 bp->b_flags &= ~B_HASBOGUS; 1461 bp->b_flags |= B_KVABIO; 1462 bkvareset(bp); 1463 } 1464 m = bp->b_xio.xio_pages[i]; 1465 } 1466 1467 /* 1468 * Invalidate the backing store if B_NOCACHE is set 1469 * (e.g. used with vinvalbuf()). If this is NFS 1470 * we impose a requirement that the block size be 1471 * a multiple of PAGE_SIZE and create a temporary 1472 * hack to basically invalidate the whole page. The 1473 * problem is that NFS uses really odd buffer sizes 1474 * especially when tracking piecemeal writes and 1475 * it also vinvalbuf()'s a lot, which would result 1476 * in only partial page validation and invalidation 1477 * here. If the file page is mmap()'d, however, 1478 * all the valid bits get set so after we invalidate 1479 * here we would end up with weird m->valid values 1480 * like 0xfc. nfs_getpages() can't handle this so 1481 * we clear all the valid bits for the NFS case 1482 * instead of just some of them. 1483 * 1484 * The real bug is the VM system having to set m->valid 1485 * to VM_PAGE_BITS_ALL for faulted-in pages, which 1486 * itself is an artifact of the whole 512-byte 1487 * granular mess that exists to support odd block 1488 * sizes and UFS meta-data block sizes (e.g. 6144). 1489 * A complete rewrite is required. 1490 * 1491 * XXX 1492 */ 1493 if (bp->b_flags & (B_NOCACHE|B_ERROR)) { 1494 int poffset = foff & PAGE_MASK; 1495 int presid; 1496 1497 presid = PAGE_SIZE - poffset; 1498 if (bp->b_vp->v_tag == VT_NFS && 1499 bp->b_vp->v_type == VREG) { 1500 ; /* entire page */ 1501 } else if (presid > resid) { 1502 presid = resid; 1503 } 1504 KASSERT(presid >= 0, ("brelse: extra page")); 1505 vm_page_set_invalid(m, poffset, presid); 1506 1507 /* 1508 * Also make sure any swap cache is removed 1509 * as it is now stale (HAMMER in particular 1510 * uses B_NOCACHE to deal with buffer 1511 * aliasing). 1512 */ 1513 swap_pager_unswapped(m); 1514 } 1515 resid -= PAGE_SIZE - (foff & PAGE_MASK); 1516 foff = (foff + PAGE_SIZE) & ~(off_t)PAGE_MASK; 1517 } 1518 if (bp->b_flags & (B_INVAL | B_RELBUF)) 1519 vfs_vmio_release(bp); 1520 } else { 1521 /* 1522 * Rundown for non-VMIO buffers. 1523 */ 1524 if (bp->b_flags & (B_INVAL | B_RELBUF)) { 1525 if (bp->b_bufsize) 1526 allocbuf(bp, 0); 1527 KKASSERT (LIST_FIRST(&bp->b_dep) == NULL); 1528 if (bp->b_vp) 1529 brelvp(bp); 1530 } 1531 } 1532 1533 if (bp->b_qindex != BQUEUE_NONE) 1534 panic("brelse: free buffer onto another queue???"); 1535 1536 /* 1537 * Figure out the correct queue to place the cleaned up buffer on. 1538 * Buffers placed in the EMPTY or EMPTYKVA had better already be 1539 * disassociated from their vnode. 1540 * 1541 * Return the buffer to its original pcpu area 1542 */ 1543 pcpu = &bufpcpu[bp->b_qcpu]; 1544 spin_lock(&pcpu->spin); 1545 1546 if (bp->b_flags & B_LOCKED) { 1547 /* 1548 * Buffers that are locked are placed in the locked queue 1549 * immediately, regardless of their state. 1550 */ 1551 bp->b_qindex = BQUEUE_LOCKED; 1552 TAILQ_INSERT_TAIL(&pcpu->bufqueues[bp->b_qindex], 1553 bp, b_freelist); 1554 } else if (bp->b_bufsize == 0) { 1555 /* 1556 * Buffers with no memory. Due to conditionals near the top 1557 * of brelse() such buffers should probably already be 1558 * marked B_INVAL and disassociated from their vnode. 1559 */ 1560 bp->b_flags |= B_INVAL; 1561 KASSERT(bp->b_vp == NULL, 1562 ("bp1 %p flags %08x/%08x vnode %p " 1563 "unexpectededly still associated!", 1564 bp, saved_flags, bp->b_flags, bp->b_vp)); 1565 KKASSERT((bp->b_flags & B_HASHED) == 0); 1566 bp->b_qindex = BQUEUE_EMPTY; 1567 TAILQ_INSERT_HEAD(&pcpu->bufqueues[bp->b_qindex], 1568 bp, b_freelist); 1569 } else if (bp->b_flags & (B_INVAL | B_NOCACHE | B_RELBUF)) { 1570 /* 1571 * Buffers with junk contents. Again these buffers had better 1572 * already be disassociated from their vnode. 1573 */ 1574 KASSERT(bp->b_vp == NULL, 1575 ("bp2 %p flags %08x/%08x vnode %p unexpectededly " 1576 "still associated!", 1577 bp, saved_flags, bp->b_flags, bp->b_vp)); 1578 KKASSERT((bp->b_flags & B_HASHED) == 0); 1579 bp->b_flags |= B_INVAL; 1580 bp->b_qindex = BQUEUE_CLEAN; 1581 TAILQ_INSERT_HEAD(&pcpu->bufqueues[bp->b_qindex], 1582 bp, b_freelist); 1583 } else { 1584 /* 1585 * Remaining buffers. These buffers are still associated with 1586 * their vnode. 1587 */ 1588 switch(bp->b_flags & (B_DELWRI|B_HEAVY)) { 1589 case B_DELWRI: 1590 bp->b_qindex = BQUEUE_DIRTY; 1591 TAILQ_INSERT_TAIL(&pcpu->bufqueues[bp->b_qindex], 1592 bp, b_freelist); 1593 break; 1594 case B_DELWRI | B_HEAVY: 1595 bp->b_qindex = BQUEUE_DIRTY_HW; 1596 TAILQ_INSERT_TAIL(&pcpu->bufqueues[bp->b_qindex], 1597 bp, b_freelist); 1598 break; 1599 default: 1600 /* 1601 * NOTE: Buffers are always placed at the end of the 1602 * queue. If B_AGE is not set the buffer will cycle 1603 * through the queue twice. 1604 */ 1605 bp->b_qindex = BQUEUE_CLEAN; 1606 TAILQ_INSERT_TAIL(&pcpu->bufqueues[bp->b_qindex], 1607 bp, b_freelist); 1608 break; 1609 } 1610 } 1611 spin_unlock(&pcpu->spin); 1612 1613 /* 1614 * If B_INVAL, clear B_DELWRI. We've already placed the buffer 1615 * on the correct queue but we have not yet unlocked it. 1616 */ 1617 if ((bp->b_flags & (B_INVAL|B_DELWRI)) == (B_INVAL|B_DELWRI)) 1618 bundirty(bp); 1619 1620 /* 1621 * The bp is on an appropriate queue unless locked. If it is not 1622 * locked or dirty we can wakeup threads waiting for buffer space. 1623 * 1624 * We've already handled the B_INVAL case ( B_DELWRI will be clear 1625 * if B_INVAL is set ). 1626 */ 1627 if ((bp->b_flags & (B_LOCKED|B_DELWRI)) == 0) 1628 bufcountwakeup(); 1629 1630 /* 1631 * Something we can maybe free or reuse 1632 */ 1633 if (bp->b_bufsize || bp->b_kvasize) 1634 bufspacewakeup(); 1635 1636 /* 1637 * Clean up temporary flags and unlock the buffer. 1638 */ 1639 bp->b_flags &= ~(B_NOCACHE | B_RELBUF | B_DIRECT); 1640 BUF_UNLOCK(bp); 1641 } 1642 1643 /* 1644 * bqrelse: 1645 * 1646 * Release a buffer back to the appropriate queue but do not try to free 1647 * it. The buffer is expected to be used again soon. 1648 * 1649 * bqrelse() is used by bdwrite() to requeue a delayed write, and used by 1650 * biodone() to requeue an async I/O on completion. It is also used when 1651 * known good buffers need to be requeued but we think we may need the data 1652 * again soon. 1653 * 1654 * XXX we should be able to leave the B_RELBUF hint set on completion. 1655 */ 1656 void 1657 bqrelse(struct buf *bp) 1658 { 1659 struct bufpcpu *pcpu; 1660 1661 KASSERT(!(bp->b_flags & (B_CLUSTER|B_PAGING)), 1662 ("bqrelse: inappropriate B_PAGING or B_CLUSTER bp %p", bp)); 1663 1664 if (bp->b_qindex != BQUEUE_NONE) 1665 panic("bqrelse: free buffer onto another queue???"); 1666 1667 buf_act_advance(bp); 1668 1669 pcpu = &bufpcpu[bp->b_qcpu]; 1670 spin_lock(&pcpu->spin); 1671 1672 if (bp->b_flags & B_LOCKED) { 1673 /* 1674 * Locked buffers are released to the locked queue. However, 1675 * if the buffer is dirty it will first go into the dirty 1676 * queue and later on after the I/O completes successfully it 1677 * will be released to the locked queue. 1678 */ 1679 bp->b_qindex = BQUEUE_LOCKED; 1680 TAILQ_INSERT_TAIL(&pcpu->bufqueues[bp->b_qindex], 1681 bp, b_freelist); 1682 } else if (bp->b_flags & B_DELWRI) { 1683 bp->b_qindex = (bp->b_flags & B_HEAVY) ? 1684 BQUEUE_DIRTY_HW : BQUEUE_DIRTY; 1685 TAILQ_INSERT_TAIL(&pcpu->bufqueues[bp->b_qindex], 1686 bp, b_freelist); 1687 } else if (vm_page_count_min(0)) { 1688 /* 1689 * We are too low on memory, we have to try to free the 1690 * buffer (most importantly: the wired pages making up its 1691 * backing store) *now*. 1692 */ 1693 spin_unlock(&pcpu->spin); 1694 brelse(bp); 1695 return; 1696 } else { 1697 bp->b_qindex = BQUEUE_CLEAN; 1698 TAILQ_INSERT_TAIL(&pcpu->bufqueues[bp->b_qindex], 1699 bp, b_freelist); 1700 } 1701 spin_unlock(&pcpu->spin); 1702 1703 /* 1704 * We have now placed the buffer on the proper queue, but have yet 1705 * to unlock it. 1706 */ 1707 if ((bp->b_flags & B_LOCKED) == 0 && 1708 ((bp->b_flags & B_INVAL) || (bp->b_flags & B_DELWRI) == 0)) { 1709 bufcountwakeup(); 1710 } 1711 1712 /* 1713 * Something we can maybe free or reuse. 1714 */ 1715 if (bp->b_bufsize && !(bp->b_flags & B_DELWRI)) 1716 bufspacewakeup(); 1717 1718 /* 1719 * Final cleanup and unlock. Clear bits that are only used while a 1720 * buffer is actively locked. 1721 */ 1722 bp->b_flags &= ~(B_NOCACHE | B_RELBUF); 1723 dsched_buf_exit(bp); 1724 BUF_UNLOCK(bp); 1725 } 1726 1727 /* 1728 * Hold a buffer, preventing it from being reused. This will prevent 1729 * normal B_RELBUF operations on the buffer but will not prevent B_INVAL 1730 * operations. If a B_INVAL operation occurs the buffer will remain held 1731 * but the underlying pages may get ripped out. 1732 * 1733 * These functions are typically used in VOP_READ/VOP_WRITE functions 1734 * to hold a buffer during a copyin or copyout, preventing deadlocks 1735 * or recursive lock panics when read()/write() is used over mmap()'d 1736 * space. 1737 * 1738 * NOTE: bqhold() requires that the buffer be locked at the time of the 1739 * hold. bqdrop() has no requirements other than the buffer having 1740 * previously been held. 1741 */ 1742 void 1743 bqhold(struct buf *bp) 1744 { 1745 atomic_add_int(&bp->b_refs, 1); 1746 } 1747 1748 void 1749 bqdrop(struct buf *bp) 1750 { 1751 KKASSERT(bp->b_refs > 0); 1752 atomic_add_int(&bp->b_refs, -1); 1753 } 1754 1755 /* 1756 * Return backing pages held by the buffer 'bp' back to the VM system. 1757 * This routine is called when the bp is invalidated, released, or 1758 * reused. 1759 * 1760 * The KVA mapping (b_data) for the underlying pages is removed by 1761 * this function. 1762 * 1763 * WARNING! This routine is integral to the low memory critical path 1764 * when a buffer is B_RELBUF'd. If the system has a severe page 1765 * deficit we need to get the page(s) onto the PQ_FREE or PQ_CACHE 1766 * queues so they can be reused in the current pageout daemon 1767 * pass. 1768 */ 1769 static void 1770 vfs_vmio_release(struct buf *bp) 1771 { 1772 int i; 1773 vm_page_t m; 1774 1775 for (i = 0; i < bp->b_xio.xio_npages; i++) { 1776 m = bp->b_xio.xio_pages[i]; 1777 bp->b_xio.xio_pages[i] = NULL; 1778 1779 /* 1780 * We need to own the page in order to safely unwire it. 1781 */ 1782 vm_page_busy_wait(m, FALSE, "vmiopg"); 1783 1784 /* 1785 * The VFS is telling us this is not a meta-data buffer 1786 * even if it is backed by a block device. 1787 */ 1788 if (bp->b_flags & B_NOTMETA) 1789 vm_page_flag_set(m, PG_NOTMETA); 1790 1791 /* 1792 * This is a very important bit of code. We try to track 1793 * VM page use whether the pages are wired into the buffer 1794 * cache or not. While wired into the buffer cache the 1795 * bp tracks the act_count. 1796 * 1797 * We can choose to place unwired pages on the inactive 1798 * queue (0) or active queue (1). If we place too many 1799 * on the active queue the queue will cycle the act_count 1800 * on pages we'd like to keep, just from single-use pages 1801 * (such as when doing a tar-up or file scan). 1802 */ 1803 if (bp->b_act_count < vm_cycle_point) 1804 vm_page_unwire(m, 0); 1805 else 1806 vm_page_unwire(m, 1); 1807 1808 /* 1809 * If the wire_count has dropped to 0 we may need to take 1810 * further action before unbusying the page. 1811 * 1812 * WARNING: vm_page_try_*() also checks PG_NEED_COMMIT for us. 1813 */ 1814 if (m->wire_count == 0) { 1815 if (bp->b_flags & B_DIRECT) { 1816 /* 1817 * Attempt to free the page if B_DIRECT is 1818 * set, the caller does not desire the page 1819 * to be cached. 1820 */ 1821 vm_page_wakeup(m); 1822 vm_page_try_to_free(m); 1823 } else if ((bp->b_flags & B_NOTMETA) || 1824 vm_page_count_min(0)) { 1825 /* 1826 * Attempt to move the page to PQ_CACHE 1827 * if B_NOTMETA is set. This flag is set 1828 * by HAMMER to remove one of the two pages 1829 * present when double buffering is enabled. 1830 * 1831 * Attempt to move the page to PQ_CACHE 1832 * If we have a severe page deficit. This 1833 * will cause buffer cache operations related 1834 * to pageouts to recycle the related pages 1835 * in order to avoid a low memory deadlock. 1836 */ 1837 m->act_count = bp->b_act_count; 1838 vm_page_try_to_cache(m); 1839 } else { 1840 /* 1841 * Nominal case, leave the page on the 1842 * queue the original unwiring placed it on 1843 * (active or inactive). 1844 */ 1845 m->act_count = bp->b_act_count; 1846 vm_page_wakeup(m); 1847 } 1848 } else { 1849 vm_page_wakeup(m); 1850 } 1851 } 1852 1853 /* 1854 * Zero out the pmap pte's for the mapping, but don't bother 1855 * invalidating the TLB. The range will be properly invalidating 1856 * when new pages are entered into the mapping. 1857 * 1858 * This in particular reduces tmpfs tear-down overhead and reduces 1859 * buffer cache re-use overhead (one invalidation sequence instead 1860 * of two per re-use). 1861 */ 1862 pmap_qremove_noinval(trunc_page((vm_offset_t) bp->b_data), 1863 bp->b_xio.xio_npages); 1864 CPUMASK_ASSZERO(bp->b_cpumask); 1865 if (bp->b_bufsize) { 1866 atomic_add_long(&bufspace, -bp->b_bufsize); 1867 bp->b_bufsize = 0; 1868 bufspacewakeup(); 1869 } 1870 bp->b_xio.xio_npages = 0; 1871 bp->b_flags &= ~B_VMIO; 1872 KKASSERT (LIST_FIRST(&bp->b_dep) == NULL); 1873 if (bp->b_vp) 1874 brelvp(bp); 1875 } 1876 1877 /* 1878 * Find and initialize a new buffer header, freeing up existing buffers 1879 * in the bufqueues as necessary. The new buffer is returned locked. 1880 * 1881 * Important: B_INVAL is not set. If the caller wishes to throw the 1882 * buffer away, the caller must set B_INVAL prior to calling brelse(). 1883 * 1884 * We block if: 1885 * We have insufficient buffer headers 1886 * We have insufficient buffer space 1887 * 1888 * To avoid VFS layer recursion we do not flush dirty buffers ourselves. 1889 * Instead we ask the buf daemon to do it for us. We attempt to 1890 * avoid piecemeal wakeups of the pageout daemon. 1891 */ 1892 struct buf * 1893 getnewbuf(int blkflags, int slptimeo, int size, int maxsize) 1894 { 1895 struct bufpcpu *pcpu; 1896 struct buf *bp; 1897 struct buf *nbp; 1898 int nqindex; 1899 int nqcpu; 1900 int slpflags = (blkflags & GETBLK_PCATCH) ? PCATCH : 0; 1901 int maxloops = 200000; 1902 int restart_reason = 0; 1903 struct buf *restart_bp = NULL; 1904 static char flushingbufs[MAXCPU]; 1905 char *flushingp; 1906 1907 /* 1908 * We can't afford to block since we might be holding a vnode lock, 1909 * which may prevent system daemons from running. We deal with 1910 * low-memory situations by proactively returning memory and running 1911 * async I/O rather then sync I/O. 1912 */ 1913 1914 ++getnewbufcalls; 1915 nqcpu = mycpu->gd_cpuid; 1916 flushingp = &flushingbufs[nqcpu]; 1917 restart: 1918 if (bufspace < lobufspace) 1919 *flushingp = 0; 1920 1921 if (debug_bufbio && --maxloops == 0) 1922 panic("getnewbuf, excessive loops on cpu %d restart %d (%p)", 1923 mycpu->gd_cpuid, restart_reason, restart_bp); 1924 1925 /* 1926 * Setup for scan. If we do not have enough free buffers, 1927 * we setup a degenerate case that immediately fails. Note 1928 * that if we are specially marked process, we are allowed to 1929 * dip into our reserves. 1930 * 1931 * The scanning sequence is nominally: EMPTY->CLEAN 1932 */ 1933 pcpu = &bufpcpu[nqcpu]; 1934 spin_lock(&pcpu->spin); 1935 1936 /* 1937 * Prime the scan for this cpu. Locate the first buffer to 1938 * check. If we are flushing buffers we must skip the 1939 * EMPTY queue. 1940 */ 1941 nqindex = BQUEUE_EMPTY; 1942 nbp = TAILQ_FIRST(&pcpu->bufqueues[BQUEUE_EMPTY]); 1943 if (nbp == NULL || *flushingp) { 1944 nqindex = BQUEUE_CLEAN; 1945 nbp = TAILQ_FIRST(&pcpu->bufqueues[BQUEUE_CLEAN]); 1946 } 1947 1948 /* 1949 * Run scan, possibly freeing data and/or kva mappings on the fly, 1950 * depending. 1951 * 1952 * WARNING! spin is held! 1953 */ 1954 while ((bp = nbp) != NULL) { 1955 int qindex = nqindex; 1956 1957 nbp = TAILQ_NEXT(bp, b_freelist); 1958 1959 /* 1960 * BQUEUE_CLEAN - B_AGE special case. If not set the bp 1961 * cycles through the queue twice before being selected. 1962 */ 1963 if (qindex == BQUEUE_CLEAN && 1964 (bp->b_flags & B_AGE) == 0 && nbp) { 1965 bp->b_flags |= B_AGE; 1966 TAILQ_REMOVE(&pcpu->bufqueues[qindex], 1967 bp, b_freelist); 1968 TAILQ_INSERT_TAIL(&pcpu->bufqueues[qindex], 1969 bp, b_freelist); 1970 continue; 1971 } 1972 1973 /* 1974 * Calculate next bp ( we can only use it if we do not block 1975 * or do other fancy things ). 1976 */ 1977 if (nbp == NULL) { 1978 switch(qindex) { 1979 case BQUEUE_EMPTY: 1980 nqindex = BQUEUE_CLEAN; 1981 if ((nbp = TAILQ_FIRST(&pcpu->bufqueues[BQUEUE_CLEAN]))) 1982 break; 1983 /* fall through */ 1984 case BQUEUE_CLEAN: 1985 /* 1986 * nbp is NULL. 1987 */ 1988 break; 1989 } 1990 } 1991 1992 /* 1993 * Sanity Checks 1994 */ 1995 KASSERT(bp->b_qindex == qindex, 1996 ("getnewbuf: inconsistent queue %d bp %p", qindex, bp)); 1997 1998 /* 1999 * Note: we no longer distinguish between VMIO and non-VMIO 2000 * buffers. 2001 */ 2002 KASSERT((bp->b_flags & B_DELWRI) == 0, 2003 ("delwri buffer %p found in queue %d", bp, qindex)); 2004 2005 /* 2006 * Do not try to reuse a buffer with a non-zero b_refs. 2007 * This is an unsynchronized test. A synchronized test 2008 * is also performed after we lock the buffer. 2009 */ 2010 if (bp->b_refs) 2011 continue; 2012 2013 /* 2014 * Start freeing the bp. This is somewhat involved. nbp 2015 * remains valid only for BQUEUE_EMPTY bp's. Buffers 2016 * on the clean list must be disassociated from their 2017 * current vnode. Buffers on the empty lists have 2018 * already been disassociated. 2019 * 2020 * b_refs is checked after locking along with queue changes. 2021 * We must check here to deal with zero->nonzero transitions 2022 * made by the owner of the buffer lock, which is used by 2023 * VFS's to hold the buffer while issuing an unlocked 2024 * uiomove()s. We cannot invalidate the buffer's pages 2025 * for this case. Once we successfully lock a buffer the 2026 * only 0->1 transitions of b_refs will occur via findblk(). 2027 * 2028 * We must also check for queue changes after successful 2029 * locking as the current lock holder may dispose of the 2030 * buffer and change its queue. 2031 */ 2032 if (BUF_LOCK(bp, LK_EXCLUSIVE | LK_NOWAIT) != 0) { 2033 spin_unlock(&pcpu->spin); 2034 tsleep(&bd_request, 0, "gnbxxx", (hz + 99) / 100); 2035 restart_reason = 1; 2036 restart_bp = bp; 2037 goto restart; 2038 } 2039 if (bp->b_qindex != qindex || bp->b_refs) { 2040 spin_unlock(&pcpu->spin); 2041 BUF_UNLOCK(bp); 2042 restart_reason = 2; 2043 restart_bp = bp; 2044 goto restart; 2045 } 2046 bremfree_locked(bp); 2047 spin_unlock(&pcpu->spin); 2048 2049 /* 2050 * Dependancies must be handled before we disassociate the 2051 * vnode. 2052 * 2053 * NOTE: HAMMER will set B_LOCKED if the buffer cannot 2054 * be immediately disassociated. HAMMER then becomes 2055 * responsible for releasing the buffer. 2056 * 2057 * NOTE: spin is UNLOCKED now. 2058 */ 2059 if (LIST_FIRST(&bp->b_dep) != NULL) { 2060 buf_deallocate(bp); 2061 if (bp->b_flags & B_LOCKED) { 2062 bqrelse(bp); 2063 restart_reason = 3; 2064 restart_bp = bp; 2065 goto restart; 2066 } 2067 KKASSERT(LIST_FIRST(&bp->b_dep) == NULL); 2068 } 2069 2070 /* 2071 * CLEAN buffers have content or associations that must be 2072 * cleaned out if not repurposing. 2073 */ 2074 if (qindex == BQUEUE_CLEAN) { 2075 if (bp->b_flags & B_VMIO) 2076 vfs_vmio_release(bp); 2077 if (bp->b_vp) 2078 brelvp(bp); 2079 } 2080 2081 /* 2082 * NOTE: nbp is now entirely invalid. We can only restart 2083 * the scan from this point on. 2084 * 2085 * Get the rest of the buffer freed up. b_kva* is still 2086 * valid after this operation. 2087 */ 2088 KASSERT(bp->b_vp == NULL, 2089 ("bp3 %p flags %08x vnode %p qindex %d " 2090 "unexpectededly still associated!", 2091 bp, bp->b_flags, bp->b_vp, qindex)); 2092 KKASSERT((bp->b_flags & B_HASHED) == 0); 2093 2094 if (bp->b_bufsize) 2095 allocbuf(bp, 0); 2096 2097 if (bp->b_flags & (B_VNDIRTY | B_VNCLEAN | B_HASHED)) { 2098 kprintf("getnewbuf: caught bug vp queue " 2099 "%p/%08x qidx %d\n", 2100 bp, bp->b_flags, qindex); 2101 brelvp(bp); 2102 } 2103 bp->b_flags = B_BNOCLIP; 2104 bp->b_cmd = BUF_CMD_DONE; 2105 bp->b_vp = NULL; 2106 bp->b_error = 0; 2107 bp->b_resid = 0; 2108 bp->b_bcount = 0; 2109 bp->b_xio.xio_npages = 0; 2110 bp->b_dirtyoff = bp->b_dirtyend = 0; 2111 bp->b_act_count = ACT_INIT; 2112 reinitbufbio(bp); 2113 KKASSERT(LIST_FIRST(&bp->b_dep) == NULL); 2114 buf_dep_init(bp); 2115 if (blkflags & GETBLK_BHEAVY) 2116 bp->b_flags |= B_HEAVY; 2117 2118 if (bufspace >= hibufspace) 2119 *flushingp = 1; 2120 if (bufspace < lobufspace) 2121 *flushingp = 0; 2122 if (*flushingp) { 2123 bp->b_flags |= B_INVAL; 2124 brelse(bp); 2125 restart_reason = 5; 2126 restart_bp = bp; 2127 goto restart; 2128 } 2129 2130 /* 2131 * b_refs can transition to a non-zero value while we hold 2132 * the buffer locked due to a findblk(). Our brelvp() above 2133 * interlocked any future possible transitions due to 2134 * findblk()s. 2135 * 2136 * If we find b_refs to be non-zero we can destroy the 2137 * buffer's contents but we cannot yet reuse the buffer. 2138 */ 2139 if (bp->b_refs) { 2140 bp->b_flags |= B_INVAL; 2141 brelse(bp); 2142 restart_reason = 6; 2143 restart_bp = bp; 2144 2145 goto restart; 2146 } 2147 2148 /* 2149 * We found our buffer! 2150 */ 2151 break; 2152 } 2153 2154 /* 2155 * If we exhausted our list, iterate other cpus. If that fails, 2156 * sleep as appropriate. We may have to wakeup various daemons 2157 * and write out some dirty buffers. 2158 * 2159 * Generally we are sleeping due to insufficient buffer space. 2160 * 2161 * NOTE: spin is held if bp is NULL, else it is not held. 2162 */ 2163 if (bp == NULL) { 2164 int flags; 2165 char *waitmsg; 2166 2167 spin_unlock(&pcpu->spin); 2168 2169 nqcpu = (nqcpu + 1) % ncpus; 2170 if (nqcpu != mycpu->gd_cpuid) { 2171 restart_reason = 7; 2172 restart_bp = bp; 2173 goto restart; 2174 } 2175 2176 if (bufspace >= hibufspace) { 2177 waitmsg = "bufspc"; 2178 flags = VFS_BIO_NEED_BUFSPACE; 2179 } else { 2180 waitmsg = "newbuf"; 2181 flags = VFS_BIO_NEED_ANY; 2182 } 2183 2184 bd_speedup(); /* heeeelp */ 2185 atomic_set_int(&needsbuffer, flags); 2186 while (needsbuffer & flags) { 2187 int value; 2188 2189 tsleep_interlock(&needsbuffer, 0); 2190 value = atomic_fetchadd_int(&needsbuffer, 0); 2191 if (value & flags) { 2192 if (tsleep(&needsbuffer, PINTERLOCKED|slpflags, 2193 waitmsg, slptimeo)) { 2194 return (NULL); 2195 } 2196 } 2197 } 2198 } else { 2199 /* 2200 * We finally have a valid bp. Reset b_data. 2201 * 2202 * (spin is not held) 2203 */ 2204 bp->b_data = bp->b_kvabase; 2205 } 2206 return(bp); 2207 } 2208 2209 /* 2210 * buf_daemon: 2211 * 2212 * Buffer flushing daemon. Buffers are normally flushed by the 2213 * update daemon but if it cannot keep up this process starts to 2214 * take the load in an attempt to prevent getnewbuf() from blocking. 2215 * 2216 * Once a flush is initiated it does not stop until the number 2217 * of buffers falls below lodirtybuffers, but we will wake up anyone 2218 * waiting at the mid-point. 2219 */ 2220 static struct kproc_desc buf_kp = { 2221 "bufdaemon", 2222 buf_daemon, 2223 &bufdaemon_td 2224 }; 2225 SYSINIT(bufdaemon, SI_SUB_KTHREAD_BUF, SI_ORDER_FIRST, 2226 kproc_start, &buf_kp); 2227 2228 static struct kproc_desc bufhw_kp = { 2229 "bufdaemon_hw", 2230 buf_daemon_hw, 2231 &bufdaemonhw_td 2232 }; 2233 SYSINIT(bufdaemon_hw, SI_SUB_KTHREAD_BUF, SI_ORDER_FIRST, 2234 kproc_start, &bufhw_kp); 2235 2236 static void 2237 buf_daemon1(struct thread *td, int queue, int (*buf_limit_fn)(long), 2238 int *bd_req) 2239 { 2240 long limit; 2241 struct buf *marker; 2242 2243 marker = kmalloc(sizeof(*marker), M_BIOBUF, M_WAITOK | M_ZERO); 2244 marker->b_flags |= B_MARKER; 2245 marker->b_qindex = BQUEUE_NONE; 2246 marker->b_qcpu = 0; 2247 2248 /* 2249 * This process needs to be suspended prior to shutdown sync. 2250 */ 2251 EVENTHANDLER_REGISTER(shutdown_pre_sync, shutdown_kproc, 2252 td, SHUTDOWN_PRI_LAST); 2253 curthread->td_flags |= TDF_SYSTHREAD; 2254 2255 /* 2256 * This process is allowed to take the buffer cache to the limit 2257 */ 2258 for (;;) { 2259 kproc_suspend_loop(); 2260 2261 /* 2262 * Do the flush as long as the number of dirty buffers 2263 * (including those running) exceeds lodirtybufspace. 2264 * 2265 * When flushing limit running I/O to hirunningspace 2266 * Do the flush. Limit the amount of in-transit I/O we 2267 * allow to build up, otherwise we would completely saturate 2268 * the I/O system. Wakeup any waiting processes before we 2269 * normally would so they can run in parallel with our drain. 2270 * 2271 * Our aggregate normal+HW lo water mark is lodirtybufspace, 2272 * but because we split the operation into two threads we 2273 * have to cut it in half for each thread. 2274 */ 2275 waitrunningbufspace(); 2276 limit = lodirtybufspace / 2; 2277 while (buf_limit_fn(limit)) { 2278 if (flushbufqueues(marker, queue) == 0) 2279 break; 2280 if (runningbufspace < hirunningspace) 2281 continue; 2282 waitrunningbufspace(); 2283 } 2284 2285 /* 2286 * We reached our low water mark, reset the 2287 * request and sleep until we are needed again. 2288 * The sleep is just so the suspend code works. 2289 */ 2290 tsleep_interlock(bd_req, 0); 2291 if (atomic_swap_int(bd_req, 0) == 0) 2292 tsleep(bd_req, PINTERLOCKED, "psleep", hz); 2293 } 2294 /* NOT REACHED */ 2295 /*kfree(marker, M_BIOBUF);*/ 2296 } 2297 2298 static int 2299 buf_daemon_limit(long limit) 2300 { 2301 return (runningbufspace + dirtykvaspace > limit || 2302 dirtybufcount - dirtybufcounthw >= nbuf / 2); 2303 } 2304 2305 static int 2306 buf_daemon_hw_limit(long limit) 2307 { 2308 return (runningbufspace + dirtykvaspace > limit || 2309 dirtybufcounthw >= nbuf / 2); 2310 } 2311 2312 static void 2313 buf_daemon(void) 2314 { 2315 buf_daemon1(bufdaemon_td, BQUEUE_DIRTY, buf_daemon_limit, 2316 &bd_request); 2317 } 2318 2319 static void 2320 buf_daemon_hw(void) 2321 { 2322 buf_daemon1(bufdaemonhw_td, BQUEUE_DIRTY_HW, buf_daemon_hw_limit, 2323 &bd_request_hw); 2324 } 2325 2326 /* 2327 * Flush up to (flushperqueue) buffers in the dirty queue. Each cpu has a 2328 * localized version of the queue. Each call made to this function iterates 2329 * to another cpu. It is desireable to flush several buffers from the same 2330 * cpu's queue at once, as these are likely going to be linear. 2331 * 2332 * We must be careful to free up B_INVAL buffers instead of write them, which 2333 * NFS is particularly sensitive to. 2334 * 2335 * B_RELBUF may only be set by VFSs. We do set B_AGE to indicate that we 2336 * really want to try to get the buffer out and reuse it due to the write 2337 * load on the machine. 2338 * 2339 * We must lock the buffer in order to check its validity before we can mess 2340 * with its contents. spin isn't enough. 2341 */ 2342 static int 2343 flushbufqueues(struct buf *marker, bufq_type_t q) 2344 { 2345 struct bufpcpu *pcpu; 2346 struct buf *bp; 2347 int r = 0; 2348 u_int loops = flushperqueue; 2349 int lcpu = marker->b_qcpu; 2350 2351 KKASSERT(marker->b_qindex == BQUEUE_NONE); 2352 KKASSERT(marker->b_flags & B_MARKER); 2353 2354 again: 2355 /* 2356 * Spinlock needed to perform operations on the queue and may be 2357 * held through a non-blocking BUF_LOCK(), but cannot be held when 2358 * BUF_UNLOCK()ing or through any other major operation. 2359 */ 2360 pcpu = &bufpcpu[marker->b_qcpu]; 2361 spin_lock(&pcpu->spin); 2362 marker->b_qindex = q; 2363 TAILQ_INSERT_HEAD(&pcpu->bufqueues[q], marker, b_freelist); 2364 bp = marker; 2365 2366 while ((bp = TAILQ_NEXT(bp, b_freelist)) != NULL) { 2367 /* 2368 * NOTE: spinlock is always held at the top of the loop 2369 */ 2370 if (bp->b_flags & B_MARKER) 2371 continue; 2372 if ((bp->b_flags & B_DELWRI) == 0) { 2373 kprintf("Unexpected clean buffer %p\n", bp); 2374 continue; 2375 } 2376 if (BUF_LOCK(bp, LK_EXCLUSIVE | LK_NOWAIT)) 2377 continue; 2378 KKASSERT(bp->b_qcpu == marker->b_qcpu && bp->b_qindex == q); 2379 2380 /* 2381 * Once the buffer is locked we will have no choice but to 2382 * unlock the spinlock around a later BUF_UNLOCK and re-set 2383 * bp = marker when looping. Move the marker now to make 2384 * things easier. 2385 */ 2386 TAILQ_REMOVE(&pcpu->bufqueues[q], marker, b_freelist); 2387 TAILQ_INSERT_AFTER(&pcpu->bufqueues[q], bp, marker, b_freelist); 2388 2389 /* 2390 * Must recheck B_DELWRI after successfully locking 2391 * the buffer. 2392 */ 2393 if ((bp->b_flags & B_DELWRI) == 0) { 2394 spin_unlock(&pcpu->spin); 2395 BUF_UNLOCK(bp); 2396 spin_lock(&pcpu->spin); 2397 bp = marker; 2398 continue; 2399 } 2400 2401 /* 2402 * Remove the buffer from its queue. We still own the 2403 * spinlock here. 2404 */ 2405 _bremfree(bp); 2406 2407 /* 2408 * Disposing of an invalid buffer counts as a flush op 2409 */ 2410 if (bp->b_flags & B_INVAL) { 2411 spin_unlock(&pcpu->spin); 2412 brelse(bp); 2413 goto doloop; 2414 } 2415 2416 /* 2417 * Release the spinlock for the more complex ops we 2418 * are now going to do. 2419 */ 2420 spin_unlock(&pcpu->spin); 2421 lwkt_yield(); 2422 2423 /* 2424 * This is a bit messy 2425 */ 2426 if (LIST_FIRST(&bp->b_dep) != NULL && 2427 (bp->b_flags & B_DEFERRED) == 0 && 2428 buf_countdeps(bp, 0)) { 2429 spin_lock(&pcpu->spin); 2430 TAILQ_INSERT_TAIL(&pcpu->bufqueues[q], bp, b_freelist); 2431 bp->b_qindex = q; 2432 bp->b_flags |= B_DEFERRED; 2433 spin_unlock(&pcpu->spin); 2434 BUF_UNLOCK(bp); 2435 spin_lock(&pcpu->spin); 2436 bp = marker; 2437 continue; 2438 } 2439 2440 /* 2441 * spinlock not held here. 2442 * 2443 * If the buffer has a dependancy, buf_checkwrite() must 2444 * also return 0 for us to be able to initate the write. 2445 * 2446 * If the buffer is flagged B_ERROR it may be requeued 2447 * over and over again, we try to avoid a live lock. 2448 */ 2449 if (LIST_FIRST(&bp->b_dep) != NULL && buf_checkwrite(bp)) { 2450 brelse(bp); 2451 } else if (bp->b_flags & B_ERROR) { 2452 tsleep(bp, 0, "bioer", 1); 2453 bp->b_flags &= ~B_AGE; 2454 cluster_awrite(bp); 2455 } else { 2456 bp->b_flags |= B_AGE | B_KVABIO; 2457 cluster_awrite(bp); 2458 } 2459 /* bp invalid but needs to be NULL-tested if we break out */ 2460 doloop: 2461 spin_lock(&pcpu->spin); 2462 ++r; 2463 if (--loops == 0) 2464 break; 2465 bp = marker; 2466 } 2467 /* bp is invalid here but can be NULL-tested to advance */ 2468 2469 TAILQ_REMOVE(&pcpu->bufqueues[q], marker, b_freelist); 2470 marker->b_qindex = BQUEUE_NONE; 2471 spin_unlock(&pcpu->spin); 2472 2473 /* 2474 * Advance the marker to be fair. 2475 */ 2476 marker->b_qcpu = (marker->b_qcpu + 1) % ncpus; 2477 if (bp == NULL) { 2478 if (marker->b_qcpu != lcpu) 2479 goto again; 2480 } 2481 2482 return (r); 2483 } 2484 2485 /* 2486 * inmem: 2487 * 2488 * Returns true if no I/O is needed to access the associated VM object. 2489 * This is like findblk except it also hunts around in the VM system for 2490 * the data. 2491 * 2492 * Note that we ignore vm_page_free() races from interrupts against our 2493 * lookup, since if the caller is not protected our return value will not 2494 * be any more valid then otherwise once we exit the critical section. 2495 */ 2496 int 2497 inmem(struct vnode *vp, off_t loffset) 2498 { 2499 vm_object_t obj; 2500 vm_offset_t toff, tinc, size; 2501 vm_page_t m; 2502 int res = 1; 2503 2504 if (findblk(vp, loffset, FINDBLK_TEST)) 2505 return 1; 2506 if (vp->v_mount == NULL) 2507 return 0; 2508 if ((obj = vp->v_object) == NULL) 2509 return 0; 2510 2511 size = PAGE_SIZE; 2512 if (size > vp->v_mount->mnt_stat.f_iosize) 2513 size = vp->v_mount->mnt_stat.f_iosize; 2514 2515 vm_object_hold(obj); 2516 for (toff = 0; toff < vp->v_mount->mnt_stat.f_iosize; toff += tinc) { 2517 m = vm_page_lookup(obj, OFF_TO_IDX(loffset + toff)); 2518 if (m == NULL) { 2519 res = 0; 2520 break; 2521 } 2522 tinc = size; 2523 if (tinc > PAGE_SIZE - ((toff + loffset) & PAGE_MASK)) 2524 tinc = PAGE_SIZE - ((toff + loffset) & PAGE_MASK); 2525 if (vm_page_is_valid(m, 2526 (vm_offset_t) ((toff + loffset) & PAGE_MASK), tinc) == 0) { 2527 res = 0; 2528 break; 2529 } 2530 } 2531 vm_object_drop(obj); 2532 return (res); 2533 } 2534 2535 /* 2536 * findblk: 2537 * 2538 * Locate and return the specified buffer. Unless flagged otherwise, 2539 * a locked buffer will be returned if it exists or NULL if it does not. 2540 * 2541 * findblk()'d buffers are still on the bufqueues and if you intend 2542 * to use your (locked NON-TEST) buffer you need to bremfree(bp) 2543 * and possibly do other stuff to it. 2544 * 2545 * FINDBLK_TEST - Do not lock the buffer. The caller is responsible 2546 * for locking the buffer and ensuring that it remains 2547 * the desired buffer after locking. 2548 * 2549 * FINDBLK_NBLOCK - Lock the buffer non-blocking. If we are unable 2550 * to acquire the lock we return NULL, even if the 2551 * buffer exists. 2552 * 2553 * FINDBLK_REF - Returns the buffer ref'd, which prevents normal 2554 * reuse by getnewbuf() but does not prevent 2555 * disassociation (B_INVAL). Used to avoid deadlocks 2556 * against random (vp,loffset)s due to reassignment. 2557 * 2558 * FINDBLK_KVABIO - Only applicable when returning a locked buffer. 2559 * Indicates that the caller supports B_KVABIO. 2560 * 2561 * (0) - Lock the buffer blocking. 2562 */ 2563 struct buf * 2564 findblk(struct vnode *vp, off_t loffset, int flags) 2565 { 2566 struct buf *bp; 2567 int lkflags; 2568 2569 lkflags = LK_EXCLUSIVE; 2570 if (flags & FINDBLK_NBLOCK) 2571 lkflags |= LK_NOWAIT; 2572 2573 for (;;) { 2574 /* 2575 * Lookup. Ref the buf while holding v_token to prevent 2576 * reuse (but does not prevent diassociation). 2577 */ 2578 lwkt_gettoken_shared(&vp->v_token); 2579 bp = buf_rb_hash_RB_LOOKUP(&vp->v_rbhash_tree, loffset); 2580 if (bp == NULL) { 2581 lwkt_reltoken(&vp->v_token); 2582 return(NULL); 2583 } 2584 bqhold(bp); 2585 lwkt_reltoken(&vp->v_token); 2586 2587 /* 2588 * If testing only break and return bp, do not lock. 2589 */ 2590 if (flags & FINDBLK_TEST) 2591 break; 2592 2593 /* 2594 * Lock the buffer, return an error if the lock fails. 2595 * (only FINDBLK_NBLOCK can cause the lock to fail). 2596 */ 2597 if (BUF_LOCK(bp, lkflags)) { 2598 atomic_subtract_int(&bp->b_refs, 1); 2599 /* bp = NULL; not needed */ 2600 return(NULL); 2601 } 2602 2603 /* 2604 * Revalidate the locked buf before allowing it to be 2605 * returned. 2606 * 2607 * B_KVABIO is only set/cleared when locking. When 2608 * clearing B_KVABIO, we must ensure that the buffer 2609 * is synchronized to all cpus. 2610 */ 2611 if (bp->b_vp == vp && bp->b_loffset == loffset) { 2612 if (flags & FINDBLK_KVABIO) 2613 bp->b_flags |= B_KVABIO; 2614 else 2615 bkvasync_all(bp); 2616 break; 2617 } 2618 atomic_subtract_int(&bp->b_refs, 1); 2619 BUF_UNLOCK(bp); 2620 } 2621 2622 /* 2623 * Success 2624 */ 2625 if ((flags & FINDBLK_REF) == 0) 2626 atomic_subtract_int(&bp->b_refs, 1); 2627 return(bp); 2628 } 2629 2630 /* 2631 * getcacheblk: 2632 * 2633 * Similar to getblk() except only returns the buffer if it is 2634 * B_CACHE and requires no other manipulation. Otherwise NULL 2635 * is returned. NULL is also returned if GETBLK_NOWAIT is set 2636 * and the getblk() would block. 2637 * 2638 * If B_RAM is set the buffer might be just fine, but we return 2639 * NULL anyway because we want the code to fall through to the 2640 * cluster read to issue more read-aheads. Otherwise read-ahead breaks. 2641 * 2642 * If blksize is 0 the buffer cache buffer must already be fully 2643 * cached. 2644 * 2645 * If blksize is non-zero getblk() will be used, allowing a buffer 2646 * to be reinstantiated from its VM backing store. The buffer must 2647 * still be fully cached after reinstantiation to be returned. 2648 */ 2649 struct buf * 2650 getcacheblk(struct vnode *vp, off_t loffset, int blksize, int blkflags) 2651 { 2652 struct buf *bp; 2653 int fndflags = 0; 2654 2655 if (blkflags & GETBLK_NOWAIT) 2656 fndflags |= FINDBLK_NBLOCK; 2657 if (blkflags & GETBLK_KVABIO) 2658 fndflags |= FINDBLK_KVABIO; 2659 2660 if (blksize) { 2661 bp = getblk(vp, loffset, blksize, blkflags, 0); 2662 if (bp) { 2663 if ((bp->b_flags & (B_INVAL | B_CACHE)) == B_CACHE) { 2664 bp->b_flags &= ~B_AGE; 2665 if (bp->b_flags & B_RAM) { 2666 bqrelse(bp); 2667 bp = NULL; 2668 } 2669 } else { 2670 brelse(bp); 2671 bp = NULL; 2672 } 2673 } 2674 } else { 2675 bp = findblk(vp, loffset, fndflags); 2676 if (bp) { 2677 if ((bp->b_flags & (B_INVAL | B_CACHE | B_RAM)) == 2678 B_CACHE) { 2679 bp->b_flags &= ~B_AGE; 2680 bremfree(bp); 2681 } else { 2682 BUF_UNLOCK(bp); 2683 bp = NULL; 2684 } 2685 } 2686 } 2687 return (bp); 2688 } 2689 2690 /* 2691 * getblk: 2692 * 2693 * Get a block given a specified block and offset into a file/device. 2694 * B_INVAL may or may not be set on return. The caller should clear 2695 * B_INVAL prior to initiating a READ. 2696 * 2697 * IT IS IMPORTANT TO UNDERSTAND THAT IF YOU CALL GETBLK() AND B_CACHE 2698 * IS NOT SET, YOU MUST INITIALIZE THE RETURNED BUFFER, ISSUE A READ, 2699 * OR SET B_INVAL BEFORE RETIRING IT. If you retire a getblk'd buffer 2700 * without doing any of those things the system will likely believe 2701 * the buffer to be valid (especially if it is not B_VMIO), and the 2702 * next getblk() will return the buffer with B_CACHE set. 2703 * 2704 * For a non-VMIO buffer, B_CACHE is set to the opposite of B_INVAL for 2705 * an existing buffer. 2706 * 2707 * For a VMIO buffer, B_CACHE is modified according to the backing VM. 2708 * If getblk()ing a previously 0-sized invalid buffer, B_CACHE is set 2709 * and then cleared based on the backing VM. If the previous buffer is 2710 * non-0-sized but invalid, B_CACHE will be cleared. 2711 * 2712 * If getblk() must create a new buffer, the new buffer is returned with 2713 * both B_INVAL and B_CACHE clear unless it is a VMIO buffer, in which 2714 * case it is returned with B_INVAL clear and B_CACHE set based on the 2715 * backing VM. 2716 * 2717 * getblk() also forces a bwrite() for any B_DELWRI buffer whos 2718 * B_CACHE bit is clear. 2719 * 2720 * What this means, basically, is that the caller should use B_CACHE to 2721 * determine whether the buffer is fully valid or not and should clear 2722 * B_INVAL prior to issuing a read. If the caller intends to validate 2723 * the buffer by loading its data area with something, the caller needs 2724 * to clear B_INVAL. If the caller does this without issuing an I/O, 2725 * the caller should set B_CACHE ( as an optimization ), else the caller 2726 * should issue the I/O and biodone() will set B_CACHE if the I/O was 2727 * a write attempt or if it was a successfull read. If the caller 2728 * intends to issue a READ, the caller must clear B_INVAL and B_ERROR 2729 * prior to issuing the READ. biodone() will *not* clear B_INVAL. 2730 * 2731 * getblk flags: 2732 * 2733 * GETBLK_PCATCH - catch signal if blocked, can cause NULL return 2734 * GETBLK_BHEAVY - heavy-weight buffer cache buffer 2735 */ 2736 struct buf * 2737 getblk(struct vnode *vp, off_t loffset, int size, int blkflags, int slptimeo) 2738 { 2739 struct buf *bp; 2740 int slpflags = (blkflags & GETBLK_PCATCH) ? PCATCH : 0; 2741 int error; 2742 int lkflags; 2743 2744 if (size > MAXBSIZE) 2745 panic("getblk: size(%d) > MAXBSIZE(%d)", size, MAXBSIZE); 2746 if (vp->v_object == NULL) 2747 panic("getblk: vnode %p has no object!", vp); 2748 2749 /* 2750 * NOTE: findblk does not try to resolve KVABIO in REF-only mode. 2751 * we still have to handle that ourselves. 2752 */ 2753 loop: 2754 if ((bp = findblk(vp, loffset, FINDBLK_REF | FINDBLK_TEST)) != NULL) { 2755 /* 2756 * The buffer was found in the cache, but we need to lock it. 2757 * We must acquire a ref on the bp to prevent reuse, but 2758 * this will not prevent disassociation (brelvp()) so we 2759 * must recheck (vp,loffset) after acquiring the lock. 2760 * 2761 * Without the ref the buffer could potentially be reused 2762 * before we acquire the lock and create a deadlock 2763 * situation between the thread trying to reuse the buffer 2764 * and us due to the fact that we would wind up blocking 2765 * on a random (vp,loffset). 2766 */ 2767 if (BUF_LOCK(bp, LK_EXCLUSIVE | LK_NOWAIT)) { 2768 if (blkflags & GETBLK_NOWAIT) { 2769 bqdrop(bp); 2770 return(NULL); 2771 } 2772 lkflags = LK_EXCLUSIVE | LK_SLEEPFAIL; 2773 if (blkflags & GETBLK_PCATCH) 2774 lkflags |= LK_PCATCH; 2775 error = BUF_TIMELOCK(bp, lkflags, "getblk", slptimeo); 2776 if (error) { 2777 bqdrop(bp); 2778 if (error == ENOLCK) 2779 goto loop; 2780 return (NULL); 2781 } 2782 /* buffer may have changed on us */ 2783 } 2784 bqdrop(bp); 2785 2786 /* 2787 * Once the buffer has been locked, make sure we didn't race 2788 * a buffer recyclement. Buffers that are no longer hashed 2789 * will have b_vp == NULL, so this takes care of that check 2790 * as well. 2791 */ 2792 if (bp->b_vp != vp || bp->b_loffset != loffset) { 2793 #if 0 2794 kprintf("Warning buffer %p (vp %p loffset %lld) " 2795 "was recycled\n", 2796 bp, vp, (long long)loffset); 2797 #endif 2798 BUF_UNLOCK(bp); 2799 goto loop; 2800 } 2801 2802 /* 2803 * If SZMATCH any pre-existing buffer must be of the requested 2804 * size or NULL is returned. The caller absolutely does not 2805 * want getblk() to bwrite() the buffer on a size mismatch. 2806 */ 2807 if ((blkflags & GETBLK_SZMATCH) && size != bp->b_bcount) { 2808 BUF_UNLOCK(bp); 2809 return(NULL); 2810 } 2811 2812 /* 2813 * All vnode-based buffers must be backed by a VM object. 2814 * 2815 * Set B_KVABIO for any incidental work, we will fix it 2816 * up later. 2817 */ 2818 KKASSERT(bp->b_flags & B_VMIO); 2819 KKASSERT(bp->b_cmd == BUF_CMD_DONE); 2820 bp->b_flags &= ~B_AGE; 2821 bp->b_flags |= B_KVABIO; 2822 2823 /* 2824 * Make sure that B_INVAL buffers do not have a cached 2825 * block number translation. 2826 */ 2827 if ((bp->b_flags & B_INVAL) && 2828 (bp->b_bio2.bio_offset != NOOFFSET)) { 2829 kprintf("Warning invalid buffer %p (vp %p loffset %lld)" 2830 " did not have cleared bio_offset cache\n", 2831 bp, vp, (long long)loffset); 2832 clearbiocache(&bp->b_bio2); 2833 } 2834 2835 /* 2836 * The buffer is locked. B_CACHE is cleared if the buffer is 2837 * invalid. 2838 * 2839 * After the bremfree(), disposals must use b[q]relse(). 2840 */ 2841 if (bp->b_flags & B_INVAL) 2842 bp->b_flags &= ~B_CACHE; 2843 bremfree(bp); 2844 2845 /* 2846 * Any size inconsistancy with a dirty buffer or a buffer 2847 * with a softupdates dependancy must be resolved. Resizing 2848 * the buffer in such circumstances can lead to problems. 2849 * 2850 * Dirty or dependant buffers are written synchronously. 2851 * Other types of buffers are simply released and 2852 * reconstituted as they may be backed by valid, dirty VM 2853 * pages (but not marked B_DELWRI). 2854 * 2855 * NFS NOTE: NFS buffers which straddle EOF are oddly-sized 2856 * and may be left over from a prior truncation (and thus 2857 * no longer represent the actual EOF point), so we 2858 * definitely do not want to B_NOCACHE the backing store. 2859 */ 2860 if (size != bp->b_bcount) { 2861 if (bp->b_flags & B_DELWRI) { 2862 bp->b_flags |= B_RELBUF; 2863 bwrite(bp); 2864 } else if (LIST_FIRST(&bp->b_dep)) { 2865 bp->b_flags |= B_RELBUF; 2866 bwrite(bp); 2867 } else { 2868 bp->b_flags |= B_RELBUF; 2869 brelse(bp); 2870 } 2871 goto loop; 2872 } 2873 KKASSERT(size <= bp->b_kvasize); 2874 KASSERT(bp->b_loffset != NOOFFSET, 2875 ("getblk: no buffer offset")); 2876 2877 /* 2878 * A buffer with B_DELWRI set and B_CACHE clear must 2879 * be committed before we can return the buffer in 2880 * order to prevent the caller from issuing a read 2881 * ( due to B_CACHE not being set ) and overwriting 2882 * it. 2883 * 2884 * Most callers, including NFS and FFS, need this to 2885 * operate properly either because they assume they 2886 * can issue a read if B_CACHE is not set, or because 2887 * ( for example ) an uncached B_DELWRI might loop due 2888 * to softupdates re-dirtying the buffer. In the latter 2889 * case, B_CACHE is set after the first write completes, 2890 * preventing further loops. 2891 * 2892 * NOTE! b*write() sets B_CACHE. If we cleared B_CACHE 2893 * above while extending the buffer, we cannot allow the 2894 * buffer to remain with B_CACHE set after the write 2895 * completes or it will represent a corrupt state. To 2896 * deal with this we set B_NOCACHE to scrap the buffer 2897 * after the write. 2898 * 2899 * XXX Should this be B_RELBUF instead of B_NOCACHE? 2900 * I'm not even sure this state is still possible 2901 * now that getblk() writes out any dirty buffers 2902 * on size changes. 2903 * 2904 * We might be able to do something fancy, like setting 2905 * B_CACHE in bwrite() except if B_DELWRI is already set, 2906 * so the below call doesn't set B_CACHE, but that gets real 2907 * confusing. This is much easier. 2908 */ 2909 if ((bp->b_flags & (B_CACHE|B_DELWRI)) == B_DELWRI) { 2910 kprintf("getblk: Warning, bp %p loff=%jx DELWRI set " 2911 "and CACHE clear, b_flags %08x\n", 2912 bp, (uintmax_t)bp->b_loffset, bp->b_flags); 2913 bp->b_flags |= B_NOCACHE; 2914 bwrite(bp); 2915 goto loop; 2916 } 2917 } else { 2918 /* 2919 * Buffer is not in-core, create new buffer. The buffer 2920 * returned by getnewbuf() is locked. Note that the returned 2921 * buffer is also considered valid (not marked B_INVAL). 2922 * 2923 * Calculating the offset for the I/O requires figuring out 2924 * the block size. We use DEV_BSIZE for VBLK or VCHR and 2925 * the mount's f_iosize otherwise. If the vnode does not 2926 * have an associated mount we assume that the passed size is 2927 * the block size. 2928 * 2929 * Note that vn_isdisk() cannot be used here since it may 2930 * return a failure for numerous reasons. Note that the 2931 * buffer size may be larger then the block size (the caller 2932 * will use block numbers with the proper multiple). Beware 2933 * of using any v_* fields which are part of unions. In 2934 * particular, in DragonFly the mount point overloading 2935 * mechanism uses the namecache only and the underlying 2936 * directory vnode is not a special case. 2937 */ 2938 int bsize, maxsize; 2939 2940 if (vp->v_type == VBLK || vp->v_type == VCHR) 2941 bsize = DEV_BSIZE; 2942 else if (vp->v_mount) 2943 bsize = vp->v_mount->mnt_stat.f_iosize; 2944 else 2945 bsize = size; 2946 2947 maxsize = size + (loffset & PAGE_MASK); 2948 maxsize = imax(maxsize, bsize); 2949 2950 bp = getnewbuf(blkflags, slptimeo, size, maxsize); 2951 if (bp == NULL) { 2952 if (slpflags || slptimeo) 2953 return NULL; 2954 goto loop; 2955 } 2956 2957 /* 2958 * Atomically insert the buffer into the hash, so that it can 2959 * be found by findblk(). 2960 * 2961 * If bgetvp() returns non-zero a collision occured, and the 2962 * bp will not be associated with the vnode. 2963 * 2964 * Make sure the translation layer has been cleared. 2965 */ 2966 bp->b_loffset = loffset; 2967 bp->b_bio2.bio_offset = NOOFFSET; 2968 /* bp->b_bio2.bio_next = NULL; */ 2969 2970 if (bgetvp(vp, bp, size)) { 2971 bp->b_flags |= B_INVAL; 2972 brelse(bp); 2973 goto loop; 2974 } 2975 2976 /* 2977 * All vnode-based buffers must be backed by a VM object. 2978 * 2979 * Set B_KVABIO for incidental work 2980 */ 2981 KKASSERT(vp->v_object != NULL); 2982 bp->b_flags |= B_VMIO | B_KVABIO; 2983 KKASSERT(bp->b_cmd == BUF_CMD_DONE); 2984 2985 allocbuf(bp, size); 2986 } 2987 2988 /* 2989 * Do the nasty smp broadcast (if the buffer needs it) when KVABIO 2990 * is not supported. 2991 */ 2992 if (bp && (blkflags & GETBLK_KVABIO) == 0) { 2993 bkvasync_all(bp); 2994 } 2995 return (bp); 2996 } 2997 2998 /* 2999 * regetblk(bp) 3000 * 3001 * Reacquire a buffer that was previously released to the locked queue, 3002 * or reacquire a buffer which is interlocked by having bioops->io_deallocate 3003 * set B_LOCKED (which handles the acquisition race). 3004 * 3005 * To this end, either B_LOCKED must be set or the dependancy list must be 3006 * non-empty. 3007 */ 3008 void 3009 regetblk(struct buf *bp) 3010 { 3011 KKASSERT((bp->b_flags & B_LOCKED) || LIST_FIRST(&bp->b_dep) != NULL); 3012 BUF_LOCK(bp, LK_EXCLUSIVE | LK_RETRY); 3013 bremfree(bp); 3014 } 3015 3016 /* 3017 * allocbuf: 3018 * 3019 * This code constitutes the buffer memory from either anonymous system 3020 * memory (in the case of non-VMIO operations) or from an associated 3021 * VM object (in the case of VMIO operations). This code is able to 3022 * resize a buffer up or down. 3023 * 3024 * Note that this code is tricky, and has many complications to resolve 3025 * deadlock or inconsistant data situations. Tread lightly!!! 3026 * There are B_CACHE and B_DELWRI interactions that must be dealt with by 3027 * the caller. Calling this code willy nilly can result in the loss of 3028 * data. 3029 * 3030 * allocbuf() only adjusts B_CACHE for VMIO buffers. getblk() deals with 3031 * B_CACHE for the non-VMIO case. 3032 * 3033 * This routine does not need to be called from a critical section but you 3034 * must own the buffer. 3035 */ 3036 void 3037 allocbuf(struct buf *bp, int size) 3038 { 3039 vm_page_t m; 3040 int newbsize; 3041 int desiredpages; 3042 int i; 3043 3044 if (BUF_LOCKINUSE(bp) == 0) 3045 panic("allocbuf: buffer not busy"); 3046 3047 if (bp->b_kvasize < size) 3048 panic("allocbuf: buffer too small"); 3049 3050 KKASSERT(bp->b_flags & B_VMIO); 3051 3052 newbsize = roundup2(size, DEV_BSIZE); 3053 desiredpages = ((int)(bp->b_loffset & PAGE_MASK) + 3054 newbsize + PAGE_MASK) >> PAGE_SHIFT; 3055 KKASSERT(desiredpages <= XIO_INTERNAL_PAGES); 3056 3057 /* 3058 * Set B_CACHE initially if buffer is 0 length or will become 3059 * 0-length. 3060 */ 3061 if (size == 0 || bp->b_bufsize == 0) 3062 bp->b_flags |= B_CACHE; 3063 3064 if (newbsize < bp->b_bufsize) { 3065 /* 3066 * DEV_BSIZE aligned new buffer size is less then the 3067 * DEV_BSIZE aligned existing buffer size. Figure out 3068 * if we have to remove any pages. 3069 */ 3070 if (desiredpages < bp->b_xio.xio_npages) { 3071 for (i = desiredpages; i < bp->b_xio.xio_npages; i++) { 3072 /* 3073 * the page is not freed here -- it 3074 * is the responsibility of 3075 * vnode_pager_setsize 3076 */ 3077 m = bp->b_xio.xio_pages[i]; 3078 KASSERT(m != bogus_page, 3079 ("allocbuf: bogus page found")); 3080 vm_page_busy_wait(m, TRUE, "biodep"); 3081 bp->b_xio.xio_pages[i] = NULL; 3082 vm_page_unwire(m, 0); 3083 vm_page_wakeup(m); 3084 } 3085 pmap_qremove_noinval((vm_offset_t) 3086 trunc_page((vm_offset_t)bp->b_data) + 3087 (desiredpages << PAGE_SHIFT), 3088 (bp->b_xio.xio_npages - desiredpages)); 3089 bp->b_xio.xio_npages = desiredpages; 3090 3091 /* 3092 * Don't bother invalidating the pmap changes 3093 * (which wastes global SMP invalidation IPIs) 3094 * when setting the size to 0. This case occurs 3095 * when called via getnewbuf() during buffer 3096 * recyclement. 3097 */ 3098 if (desiredpages == 0) { 3099 CPUMASK_ASSZERO(bp->b_cpumask); 3100 } else { 3101 bkvareset(bp); 3102 } 3103 } 3104 } else if (size > bp->b_bcount) { 3105 /* 3106 * We are growing the buffer, possibly in a 3107 * byte-granular fashion. 3108 */ 3109 struct vnode *vp; 3110 vm_object_t obj; 3111 vm_offset_t toff; 3112 vm_offset_t tinc; 3113 3114 /* 3115 * Step 1, bring in the VM pages from the object, 3116 * allocating them if necessary. We must clear 3117 * B_CACHE if these pages are not valid for the 3118 * range covered by the buffer. 3119 */ 3120 vp = bp->b_vp; 3121 obj = vp->v_object; 3122 3123 vm_object_hold(obj); 3124 while (bp->b_xio.xio_npages < desiredpages) { 3125 vm_page_t m; 3126 vm_pindex_t pi; 3127 int error; 3128 3129 pi = OFF_TO_IDX(bp->b_loffset) + 3130 bp->b_xio.xio_npages; 3131 3132 /* 3133 * Blocking on m->busy_count might lead to a 3134 * deadlock: 3135 * 3136 * vm_fault->getpages->cluster_read->allocbuf 3137 */ 3138 m = vm_page_lookup_busy_try(obj, pi, FALSE, 3139 &error); 3140 if (error) { 3141 vm_page_sleep_busy(m, FALSE, "pgtblk"); 3142 continue; 3143 } 3144 if (m == NULL) { 3145 /* 3146 * note: must allocate system pages 3147 * since blocking here could intefere 3148 * with paging I/O, no matter which 3149 * process we are. 3150 */ 3151 m = bio_page_alloc(bp, obj, pi, 3152 desiredpages - 3153 bp->b_xio.xio_npages); 3154 if (m) { 3155 vm_page_wire(m); 3156 vm_page_wakeup(m); 3157 bp->b_flags &= ~B_CACHE; 3158 bp->b_xio.xio_pages[bp->b_xio.xio_npages] = m; 3159 ++bp->b_xio.xio_npages; 3160 } 3161 continue; 3162 } 3163 3164 /* 3165 * We found a page and were able to busy it. 3166 */ 3167 vm_page_wire(m); 3168 vm_page_wakeup(m); 3169 bp->b_xio.xio_pages[bp->b_xio.xio_npages] = m; 3170 ++bp->b_xio.xio_npages; 3171 if (bp->b_act_count < m->act_count) 3172 bp->b_act_count = m->act_count; 3173 } 3174 vm_object_drop(obj); 3175 3176 /* 3177 * Step 2. We've loaded the pages into the buffer, 3178 * we have to figure out if we can still have B_CACHE 3179 * set. Note that B_CACHE is set according to the 3180 * byte-granular range ( bcount and size ), not the 3181 * aligned range ( newbsize ). 3182 * 3183 * The VM test is against m->valid, which is DEV_BSIZE 3184 * aligned. Needless to say, the validity of the data 3185 * needs to also be DEV_BSIZE aligned. Note that this 3186 * fails with NFS if the server or some other client 3187 * extends the file's EOF. If our buffer is resized, 3188 * B_CACHE may remain set! XXX 3189 */ 3190 3191 toff = bp->b_bcount; 3192 tinc = PAGE_SIZE - ((bp->b_loffset + toff) & PAGE_MASK); 3193 3194 while ((bp->b_flags & B_CACHE) && toff < size) { 3195 vm_pindex_t pi; 3196 3197 if (tinc > (size - toff)) 3198 tinc = size - toff; 3199 3200 pi = ((bp->b_loffset & PAGE_MASK) + toff) >> 3201 PAGE_SHIFT; 3202 3203 vfs_buf_test_cache( 3204 bp, 3205 bp->b_loffset, 3206 toff, 3207 tinc, 3208 bp->b_xio.xio_pages[pi] 3209 ); 3210 toff += tinc; 3211 tinc = PAGE_SIZE; 3212 } 3213 3214 /* 3215 * Step 3, fixup the KVM pmap. Remember that 3216 * bp->b_data is relative to bp->b_loffset, but 3217 * bp->b_loffset may be offset into the first page. 3218 */ 3219 bp->b_data = (caddr_t)trunc_page((vm_offset_t)bp->b_data); 3220 pmap_qenter_noinval((vm_offset_t)bp->b_data, 3221 bp->b_xio.xio_pages, bp->b_xio.xio_npages); 3222 bp->b_data = (caddr_t)((vm_offset_t)bp->b_data | 3223 (vm_offset_t)(bp->b_loffset & PAGE_MASK)); 3224 bkvareset(bp); 3225 } 3226 atomic_add_long(&bufspace, newbsize - bp->b_bufsize); 3227 3228 /* adjust space use on already-dirty buffer */ 3229 if (bp->b_flags & B_DELWRI) { 3230 /* dirtykvaspace unchanged */ 3231 atomic_add_long(&dirtybufspace, newbsize - bp->b_bufsize); 3232 if (bp->b_flags & B_HEAVY) { 3233 atomic_add_long(&dirtybufspacehw, 3234 newbsize - bp->b_bufsize); 3235 } 3236 } 3237 bp->b_bufsize = newbsize; /* actual buffer allocation */ 3238 bp->b_bcount = size; /* requested buffer size */ 3239 bufspacewakeup(); 3240 } 3241 3242 /* 3243 * biowait: 3244 * 3245 * Wait for buffer I/O completion, returning error status. B_EINTR 3246 * is converted into an EINTR error but not cleared (since a chain 3247 * of biowait() calls may occur). 3248 * 3249 * On return bpdone() will have been called but the buffer will remain 3250 * locked and will not have been brelse()'d. 3251 * 3252 * NOTE! If a timeout is specified and ETIMEDOUT occurs the I/O is 3253 * likely still in progress on return. 3254 * 3255 * NOTE! This operation is on a BIO, not a BUF. 3256 * 3257 * NOTE! BIO_DONE is cleared by vn_strategy() 3258 */ 3259 static __inline int 3260 _biowait(struct bio *bio, const char *wmesg, int to) 3261 { 3262 struct buf *bp = bio->bio_buf; 3263 u_int32_t flags; 3264 u_int32_t nflags; 3265 int error; 3266 3267 KKASSERT(bio == &bp->b_bio1); 3268 for (;;) { 3269 flags = bio->bio_flags; 3270 if (flags & BIO_DONE) 3271 break; 3272 nflags = flags | BIO_WANT; 3273 tsleep_interlock(bio, 0); 3274 if (atomic_cmpset_int(&bio->bio_flags, flags, nflags)) { 3275 if (wmesg) 3276 error = tsleep(bio, PINTERLOCKED, wmesg, to); 3277 else if (bp->b_cmd == BUF_CMD_READ) 3278 error = tsleep(bio, PINTERLOCKED, "biord", to); 3279 else 3280 error = tsleep(bio, PINTERLOCKED, "biowr", to); 3281 if (error) { 3282 kprintf("tsleep error biowait %d\n", error); 3283 return (error); 3284 } 3285 } 3286 } 3287 3288 /* 3289 * Finish up. 3290 */ 3291 KKASSERT(bp->b_cmd == BUF_CMD_DONE); 3292 bio->bio_flags &= ~(BIO_DONE | BIO_SYNC); 3293 if (bp->b_flags & B_EINTR) 3294 return (EINTR); 3295 if (bp->b_flags & B_ERROR) 3296 return (bp->b_error ? bp->b_error : EIO); 3297 return (0); 3298 } 3299 3300 int 3301 biowait(struct bio *bio, const char *wmesg) 3302 { 3303 return(_biowait(bio, wmesg, 0)); 3304 } 3305 3306 int 3307 biowait_timeout(struct bio *bio, const char *wmesg, int to) 3308 { 3309 return(_biowait(bio, wmesg, to)); 3310 } 3311 3312 /* 3313 * This associates a tracking count with an I/O. vn_strategy() and 3314 * dev_dstrategy() do this automatically but there are a few cases 3315 * where a vnode or device layer is bypassed when a block translation 3316 * is cached. In such cases bio_start_transaction() may be called on 3317 * the bypassed layers so the system gets an I/O in progress indication 3318 * for those higher layers. 3319 */ 3320 void 3321 bio_start_transaction(struct bio *bio, struct bio_track *track) 3322 { 3323 bio->bio_track = track; 3324 bio_track_ref(track); 3325 dsched_buf_enter(bio->bio_buf); /* might stack */ 3326 } 3327 3328 /* 3329 * Initiate I/O on a vnode. 3330 * 3331 * SWAPCACHE OPERATION: 3332 * 3333 * Real buffer cache buffers have a non-NULL bp->b_vp. Unfortunately 3334 * devfs also uses b_vp for fake buffers so we also have to check 3335 * that B_PAGING is 0. In this case the passed 'vp' is probably the 3336 * underlying block device. The swap assignments are related to the 3337 * buffer cache buffer's b_vp, not the passed vp. 3338 * 3339 * The passed vp == bp->b_vp only in the case where the strategy call 3340 * is made on the vp itself for its own buffers (a regular file or 3341 * block device vp). The filesystem usually then re-calls vn_strategy() 3342 * after translating the request to an underlying device. 3343 * 3344 * Cluster buffers set B_CLUSTER and the passed vp is the vp of the 3345 * underlying buffer cache buffers. 3346 * 3347 * We can only deal with page-aligned buffers at the moment, because 3348 * we can't tell what the real dirty state for pages straddling a buffer 3349 * are. 3350 * 3351 * In order to call swap_pager_strategy() we must provide the VM object 3352 * and base offset for the underlying buffer cache pages so it can find 3353 * the swap blocks. 3354 */ 3355 void 3356 vn_strategy(struct vnode *vp, struct bio *bio) 3357 { 3358 struct bio_track *track; 3359 struct buf *bp = bio->bio_buf; 3360 3361 KKASSERT(bp->b_cmd != BUF_CMD_DONE); 3362 3363 /* 3364 * Set when an I/O is issued on the bp. Cleared by consumers 3365 * (aka HAMMER), allowing the consumer to determine if I/O had 3366 * actually occurred. 3367 */ 3368 bp->b_flags |= B_IOISSUED; 3369 3370 /* 3371 * Handle the swapcache intercept. 3372 * 3373 * NOTE: The swapcache itself always supports KVABIO and will 3374 * do the right thing if its underlying devices do not. 3375 */ 3376 if (vn_cache_strategy(vp, bio)) 3377 return; 3378 3379 /* 3380 * If the vnode does not support KVABIO and the buffer is using 3381 * KVABIO, we must synchronize b_data to all cpus before dispatching. 3382 */ 3383 if ((vp->v_flag & VKVABIO) == 0 && (bp->b_flags & B_KVABIO)) 3384 bkvasync_all(bp); 3385 3386 /* 3387 * Otherwise do the operation through the filesystem 3388 */ 3389 if (bp->b_cmd == BUF_CMD_READ) 3390 track = &vp->v_track_read; 3391 else 3392 track = &vp->v_track_write; 3393 KKASSERT((bio->bio_flags & BIO_DONE) == 0); 3394 bio->bio_track = track; 3395 bio_track_ref(track); 3396 dsched_buf_enter(bp); /* might stack */ 3397 vop_strategy(*vp->v_ops, vp, bio); 3398 } 3399 3400 /* 3401 * vn_cache_strategy() 3402 * 3403 * Returns 1 if the interrupt was successful, 0 if not. 3404 * 3405 * NOTE: This function supports the KVABIO API wherein b_data might not 3406 * be synchronized to the current cpu. 3407 */ 3408 static void vn_cache_strategy_callback(struct bio *bio); 3409 3410 int 3411 vn_cache_strategy(struct vnode *vp, struct bio *bio) 3412 { 3413 struct buf *bp = bio->bio_buf; 3414 struct bio *nbio; 3415 vm_object_t object; 3416 vm_page_t m; 3417 int i; 3418 3419 /* 3420 * Stop using swapcache if paniced, dumping, or dumped 3421 */ 3422 if (panicstr || dumping) 3423 return(0); 3424 3425 /* 3426 * Is this buffer cache buffer suitable for reading from 3427 * the swap cache? 3428 */ 3429 if (vm_swapcache_read_enable == 0 || 3430 bp->b_cmd != BUF_CMD_READ || 3431 ((bp->b_flags & B_CLUSTER) == 0 && 3432 (bp->b_vp == NULL || (bp->b_flags & B_PAGING))) || 3433 ((int)bp->b_loffset & PAGE_MASK) != 0 || 3434 (bp->b_bcount & PAGE_MASK) != 0) { 3435 return(0); 3436 } 3437 3438 /* 3439 * Figure out the original VM object (it will match the underlying 3440 * VM pages). Note that swap cached data uses page indices relative 3441 * to that object, not relative to bio->bio_offset. 3442 */ 3443 if (bp->b_flags & B_CLUSTER) 3444 object = vp->v_object; 3445 else 3446 object = bp->b_vp->v_object; 3447 3448 /* 3449 * In order to be able to use the swap cache all underlying VM 3450 * pages must be marked as such, and we can't have any bogus pages. 3451 */ 3452 for (i = 0; i < bp->b_xio.xio_npages; ++i) { 3453 m = bp->b_xio.xio_pages[i]; 3454 if ((m->flags & PG_SWAPPED) == 0) 3455 break; 3456 if (m == bogus_page) 3457 break; 3458 } 3459 3460 /* 3461 * If we are good then issue the I/O using swap_pager_strategy(). 3462 * 3463 * We can only do this if the buffer actually supports object-backed 3464 * I/O. If it doesn't npages will be 0. 3465 */ 3466 if (i && i == bp->b_xio.xio_npages) { 3467 m = bp->b_xio.xio_pages[0]; 3468 nbio = push_bio(bio); 3469 nbio->bio_done = vn_cache_strategy_callback; 3470 nbio->bio_offset = ptoa(m->pindex); 3471 KKASSERT(m->object == object); 3472 swap_pager_strategy(object, nbio); 3473 return(1); 3474 } 3475 return(0); 3476 } 3477 3478 /* 3479 * This is a bit of a hack but since the vn_cache_strategy() function can 3480 * override a VFS's strategy function we must make sure that the bio, which 3481 * is probably bio2, doesn't leak an unexpected offset value back to the 3482 * filesystem. The filesystem (e.g. UFS) might otherwise assume that the 3483 * bio went through its own file strategy function and the the bio2 offset 3484 * is a cached disk offset when, in fact, it isn't. 3485 */ 3486 static void 3487 vn_cache_strategy_callback(struct bio *bio) 3488 { 3489 bio->bio_offset = NOOFFSET; 3490 biodone(pop_bio(bio)); 3491 } 3492 3493 /* 3494 * bpdone: 3495 * 3496 * Finish I/O on a buffer after all BIOs have been processed. 3497 * Called when the bio chain is exhausted or by biowait. If called 3498 * by biowait, elseit is typically 0. 3499 * 3500 * bpdone is also responsible for setting B_CACHE in a B_VMIO bp. 3501 * In a non-VMIO bp, B_CACHE will be set on the next getblk() 3502 * assuming B_INVAL is clear. 3503 * 3504 * For the VMIO case, we set B_CACHE if the op was a read and no 3505 * read error occured, or if the op was a write. B_CACHE is never 3506 * set if the buffer is invalid or otherwise uncacheable. 3507 * 3508 * bpdone does not mess with B_INVAL, allowing the I/O routine or the 3509 * initiator to leave B_INVAL set to brelse the buffer out of existance 3510 * in the biodone routine. 3511 * 3512 * bpdone is responsible for calling bundirty() on the buffer after a 3513 * successful write. We previously did this prior to initiating the 3514 * write under the assumption that the buffer might be dirtied again 3515 * while the write was in progress, however doing it before-hand creates 3516 * a race condition prior to the call to vn_strategy() where the 3517 * filesystem may not be aware that a dirty buffer is present. 3518 * It should not be possible for the buffer or its underlying pages to 3519 * be redirtied prior to bpdone()'s unbusying of the underlying VM 3520 * pages. 3521 */ 3522 void 3523 bpdone(struct buf *bp, int elseit) 3524 { 3525 buf_cmd_t cmd; 3526 3527 KASSERT(BUF_LOCKINUSE(bp), ("bpdone: bp %p not busy", bp)); 3528 KASSERT(bp->b_cmd != BUF_CMD_DONE, 3529 ("bpdone: bp %p already done!", bp)); 3530 3531 /* 3532 * No more BIOs are left. All completion functions have been dealt 3533 * with, now we clean up the buffer. 3534 */ 3535 cmd = bp->b_cmd; 3536 bp->b_cmd = BUF_CMD_DONE; 3537 3538 /* 3539 * Only reads and writes are processed past this point. 3540 */ 3541 if (cmd != BUF_CMD_READ && cmd != BUF_CMD_WRITE) { 3542 if (cmd == BUF_CMD_FREEBLKS) 3543 bp->b_flags |= B_NOCACHE; 3544 if (elseit) 3545 brelse(bp); 3546 return; 3547 } 3548 3549 /* 3550 * A failed write must re-dirty the buffer unless B_INVAL 3551 * was set. 3552 * 3553 * A successful write must clear the dirty flag. This is done after 3554 * the write to ensure that the buffer remains on the vnode's dirty 3555 * list for filesystem interlocks / checks until the write is actually 3556 * complete. HAMMER2 is sensitive to this issue. 3557 * 3558 * Only applicable to normal buffers (with VPs). vinum buffers may 3559 * not have a vp. 3560 * 3561 * Must be done prior to calling buf_complete() as the callback might 3562 * re-dirty the buffer. 3563 */ 3564 if (cmd == BUF_CMD_WRITE) { 3565 if ((bp->b_flags & (B_ERROR | B_INVAL)) == B_ERROR) { 3566 bp->b_flags &= ~B_NOCACHE; 3567 if (bp->b_vp) 3568 bdirty(bp); 3569 } else { 3570 if (bp->b_vp) 3571 bundirty(bp); 3572 } 3573 } 3574 3575 /* 3576 * Warning: softupdates may re-dirty the buffer, and HAMMER can do 3577 * a lot worse. XXX - move this above the clearing of b_cmd 3578 */ 3579 if (LIST_FIRST(&bp->b_dep) != NULL) 3580 buf_complete(bp); 3581 3582 if (bp->b_flags & B_VMIO) { 3583 int i; 3584 vm_ooffset_t foff; 3585 vm_page_t m; 3586 vm_object_t obj; 3587 int iosize; 3588 struct vnode *vp = bp->b_vp; 3589 3590 obj = vp->v_object; 3591 3592 #if defined(VFS_BIO_DEBUG) 3593 if (vp->v_auxrefs == 0) 3594 panic("bpdone: zero vnode hold count"); 3595 if ((vp->v_flag & VOBJBUF) == 0) 3596 panic("bpdone: vnode is not setup for merged cache"); 3597 #endif 3598 3599 foff = bp->b_loffset; 3600 KASSERT(foff != NOOFFSET, ("bpdone: no buffer offset")); 3601 KASSERT(obj != NULL, ("bpdone: missing VM object")); 3602 3603 #if defined(VFS_BIO_DEBUG) 3604 if (obj->paging_in_progress < bp->b_xio.xio_npages) { 3605 kprintf("bpdone: paging in progress(%d) < " 3606 "bp->b_xio.xio_npages(%d)\n", 3607 obj->paging_in_progress, 3608 bp->b_xio.xio_npages); 3609 } 3610 #endif 3611 3612 /* 3613 * Set B_CACHE if the op was a normal read and no error 3614 * occured. B_CACHE is set for writes in the b*write() 3615 * routines. 3616 */ 3617 iosize = bp->b_bcount - bp->b_resid; 3618 if (cmd == BUF_CMD_READ && 3619 (bp->b_flags & (B_INVAL|B_NOCACHE|B_ERROR)) == 0) { 3620 bp->b_flags |= B_CACHE; 3621 } 3622 3623 vm_object_hold(obj); 3624 for (i = 0; i < bp->b_xio.xio_npages; i++) { 3625 int resid; 3626 int isbogus; 3627 3628 resid = ((foff + PAGE_SIZE) & ~(off_t)PAGE_MASK) - foff; 3629 if (resid > iosize) 3630 resid = iosize; 3631 3632 /* 3633 * cleanup bogus pages, restoring the originals. Since 3634 * the originals should still be wired, we don't have 3635 * to worry about interrupt/freeing races destroying 3636 * the VM object association. 3637 */ 3638 m = bp->b_xio.xio_pages[i]; 3639 if (m == bogus_page) { 3640 if ((bp->b_flags & B_HASBOGUS) == 0) 3641 panic("bpdone: bp %p corrupt bogus", bp); 3642 m = vm_page_lookup(obj, OFF_TO_IDX(foff)); 3643 if (m == NULL) 3644 panic("bpdone: page disappeared"); 3645 bp->b_xio.xio_pages[i] = m; 3646 isbogus = 1; 3647 } else { 3648 isbogus = 0; 3649 } 3650 #if defined(VFS_BIO_DEBUG) 3651 if (OFF_TO_IDX(foff) != m->pindex) { 3652 kprintf("bpdone: foff(%lu)/m->pindex(%ld) " 3653 "mismatch\n", 3654 (unsigned long)foff, (long)m->pindex); 3655 } 3656 #endif 3657 3658 /* 3659 * In the write case, the valid and clean bits are 3660 * already changed correctly (see bdwrite()), so we 3661 * only need to do this here in the read case. 3662 */ 3663 vm_page_busy_wait(m, FALSE, "bpdpgw"); 3664 if (cmd == BUF_CMD_READ && isbogus == 0 && resid > 0) 3665 vfs_clean_one_page(bp, i, m); 3666 3667 /* 3668 * when debugging new filesystems or buffer I/O 3669 * methods, this is the most common error that pops 3670 * up. if you see this, you have not set the page 3671 * busy flag correctly!!! 3672 */ 3673 if ((m->busy_count & PBUSY_MASK) == 0) { 3674 kprintf("bpdone: page busy < 0, " 3675 "pindex: %d, foff: 0x(%x,%x), " 3676 "resid: %d, index: %d\n", 3677 (int) m->pindex, (int)(foff >> 32), 3678 (int) foff & 0xffffffff, resid, i); 3679 if (!vn_isdisk(vp, NULL)) 3680 kprintf(" iosize: %ld, loffset: %lld, " 3681 "flags: 0x%08x, npages: %d\n", 3682 bp->b_vp->v_mount->mnt_stat.f_iosize, 3683 (long long)bp->b_loffset, 3684 bp->b_flags, bp->b_xio.xio_npages); 3685 else 3686 kprintf(" VDEV, loffset: %lld, flags: 0x%08x, npages: %d\n", 3687 (long long)bp->b_loffset, 3688 bp->b_flags, bp->b_xio.xio_npages); 3689 kprintf(" valid: 0x%x, dirty: 0x%x, " 3690 "wired: %d\n", 3691 m->valid, m->dirty, 3692 m->wire_count); 3693 panic("bpdone: page busy < 0"); 3694 } 3695 vm_page_io_finish(m); 3696 vm_page_wakeup(m); 3697 vm_object_pip_wakeup(obj); 3698 foff = (foff + PAGE_SIZE) & ~(off_t)PAGE_MASK; 3699 iosize -= resid; 3700 } 3701 if (bp->b_flags & B_HASBOGUS) { 3702 pmap_qenter_noinval(trunc_page((vm_offset_t)bp->b_data), 3703 bp->b_xio.xio_pages, 3704 bp->b_xio.xio_npages); 3705 bp->b_flags &= ~B_HASBOGUS; 3706 bkvareset(bp); 3707 } 3708 vm_object_drop(obj); 3709 } 3710 3711 /* 3712 * Finish up by releasing the buffer. There are no more synchronous 3713 * or asynchronous completions, those were handled by bio_done 3714 * callbacks. 3715 */ 3716 if (elseit) { 3717 if (bp->b_flags & (B_NOCACHE|B_INVAL|B_ERROR|B_RELBUF)) 3718 brelse(bp); 3719 else 3720 bqrelse(bp); 3721 } 3722 } 3723 3724 /* 3725 * Normal biodone. 3726 */ 3727 void 3728 biodone(struct bio *bio) 3729 { 3730 struct buf *bp = bio->bio_buf; 3731 3732 runningbufwakeup(bp); 3733 3734 /* 3735 * Run up the chain of BIO's. Leave b_cmd intact for the duration. 3736 */ 3737 while (bio) { 3738 biodone_t *done_func; 3739 struct bio_track *track; 3740 3741 /* 3742 * BIO tracking. Most but not all BIOs are tracked. 3743 */ 3744 if ((track = bio->bio_track) != NULL) { 3745 bio_track_rel(track); 3746 bio->bio_track = NULL; 3747 } 3748 3749 /* 3750 * A bio_done function terminates the loop. The function 3751 * will be responsible for any further chaining and/or 3752 * buffer management. 3753 * 3754 * WARNING! The done function can deallocate the buffer! 3755 */ 3756 if ((done_func = bio->bio_done) != NULL) { 3757 bio->bio_done = NULL; 3758 done_func(bio); 3759 return; 3760 } 3761 bio = bio->bio_prev; 3762 } 3763 3764 /* 3765 * If we've run out of bio's do normal [a]synchronous completion. 3766 */ 3767 bpdone(bp, 1); 3768 } 3769 3770 /* 3771 * Synchronous biodone - this terminates a synchronous BIO. 3772 * 3773 * bpdone() is called with elseit=FALSE, leaving the buffer completed 3774 * but still locked. The caller must brelse() the buffer after waiting 3775 * for completion. 3776 */ 3777 void 3778 biodone_sync(struct bio *bio) 3779 { 3780 struct buf *bp = bio->bio_buf; 3781 int flags; 3782 int nflags; 3783 3784 KKASSERT(bio == &bp->b_bio1); 3785 bpdone(bp, 0); 3786 3787 for (;;) { 3788 flags = bio->bio_flags; 3789 nflags = (flags | BIO_DONE) & ~BIO_WANT; 3790 3791 if (atomic_cmpset_int(&bio->bio_flags, flags, nflags)) { 3792 if (flags & BIO_WANT) 3793 wakeup(bio); 3794 break; 3795 } 3796 } 3797 } 3798 3799 /* 3800 * vfs_unbusy_pages: 3801 * 3802 * This routine is called in lieu of iodone in the case of 3803 * incomplete I/O. This keeps the busy status for pages 3804 * consistant. 3805 */ 3806 void 3807 vfs_unbusy_pages(struct buf *bp) 3808 { 3809 int i; 3810 3811 runningbufwakeup(bp); 3812 3813 if (bp->b_flags & B_VMIO) { 3814 struct vnode *vp = bp->b_vp; 3815 vm_object_t obj; 3816 3817 obj = vp->v_object; 3818 vm_object_hold(obj); 3819 3820 for (i = 0; i < bp->b_xio.xio_npages; i++) { 3821 vm_page_t m = bp->b_xio.xio_pages[i]; 3822 3823 /* 3824 * When restoring bogus changes the original pages 3825 * should still be wired, so we are in no danger of 3826 * losing the object association and do not need 3827 * critical section protection particularly. 3828 */ 3829 if (m == bogus_page) { 3830 m = vm_page_lookup(obj, OFF_TO_IDX(bp->b_loffset) + i); 3831 if (!m) { 3832 panic("vfs_unbusy_pages: page missing"); 3833 } 3834 bp->b_xio.xio_pages[i] = m; 3835 } 3836 vm_page_busy_wait(m, FALSE, "bpdpgw"); 3837 vm_page_io_finish(m); 3838 vm_page_wakeup(m); 3839 vm_object_pip_wakeup(obj); 3840 } 3841 if (bp->b_flags & B_HASBOGUS) { 3842 pmap_qenter_noinval(trunc_page((vm_offset_t)bp->b_data), 3843 bp->b_xio.xio_pages, 3844 bp->b_xio.xio_npages); 3845 bp->b_flags &= ~B_HASBOGUS; 3846 bkvareset(bp); 3847 } 3848 vm_object_drop(obj); 3849 } 3850 } 3851 3852 /* 3853 * vfs_busy_pages: 3854 * 3855 * This routine is called before a device strategy routine. 3856 * It is used to tell the VM system that paging I/O is in 3857 * progress, and treat the pages associated with the buffer 3858 * almost as being PBUSY_LOCKED. Also the object 'paging_in_progress' 3859 * flag is handled to make sure that the object doesn't become 3860 * inconsistant. 3861 * 3862 * Since I/O has not been initiated yet, certain buffer flags 3863 * such as B_ERROR or B_INVAL may be in an inconsistant state 3864 * and should be ignored. 3865 */ 3866 void 3867 vfs_busy_pages(struct vnode *vp, struct buf *bp) 3868 { 3869 int i, bogus; 3870 struct lwp *lp = curthread->td_lwp; 3871 3872 /* 3873 * The buffer's I/O command must already be set. If reading, 3874 * B_CACHE must be 0 (double check against callers only doing 3875 * I/O when B_CACHE is 0). 3876 */ 3877 KKASSERT(bp->b_cmd != BUF_CMD_DONE); 3878 KKASSERT(bp->b_cmd == BUF_CMD_WRITE || (bp->b_flags & B_CACHE) == 0); 3879 3880 if (bp->b_flags & B_VMIO) { 3881 vm_object_t obj; 3882 3883 obj = vp->v_object; 3884 KASSERT(bp->b_loffset != NOOFFSET, 3885 ("vfs_busy_pages: no buffer offset")); 3886 3887 /* 3888 * Busy all the pages. We have to busy them all at once 3889 * to avoid deadlocks. 3890 */ 3891 retry: 3892 for (i = 0; i < bp->b_xio.xio_npages; i++) { 3893 vm_page_t m = bp->b_xio.xio_pages[i]; 3894 3895 if (vm_page_busy_try(m, FALSE)) { 3896 vm_page_sleep_busy(m, FALSE, "vbpage"); 3897 while (--i >= 0) 3898 vm_page_wakeup(bp->b_xio.xio_pages[i]); 3899 goto retry; 3900 } 3901 } 3902 3903 /* 3904 * Setup for I/O, soft-busy the page right now because 3905 * the next loop may block. 3906 */ 3907 for (i = 0; i < bp->b_xio.xio_npages; i++) { 3908 vm_page_t m = bp->b_xio.xio_pages[i]; 3909 3910 if ((bp->b_flags & B_CLUSTER) == 0) { 3911 vm_object_pip_add(obj, 1); 3912 vm_page_io_start(m); 3913 } 3914 } 3915 3916 /* 3917 * Adjust protections for I/O and do bogus-page mapping. 3918 * Assume that vm_page_protect() can block (it can block 3919 * if VM_PROT_NONE, don't take any chances regardless). 3920 * 3921 * In particular note that for writes we must incorporate 3922 * page dirtyness from the VM system into the buffer's 3923 * dirty range. 3924 * 3925 * For reads we theoretically must incorporate page dirtyness 3926 * from the VM system to determine if the page needs bogus 3927 * replacement, but we shortcut the test by simply checking 3928 * that all m->valid bits are set, indicating that the page 3929 * is fully valid and does not need to be re-read. For any 3930 * VM system dirtyness the page will also be fully valid 3931 * since it was mapped at one point. 3932 */ 3933 bogus = 0; 3934 for (i = 0; i < bp->b_xio.xio_npages; i++) { 3935 vm_page_t m = bp->b_xio.xio_pages[i]; 3936 3937 if (bp->b_cmd == BUF_CMD_WRITE) { 3938 /* 3939 * When readying a vnode-backed buffer for 3940 * a write we must zero-fill any invalid 3941 * portions of the backing VM pages, mark 3942 * it valid and clear related dirty bits. 3943 * 3944 * vfs_clean_one_page() incorporates any 3945 * VM dirtyness and updates the b_dirtyoff 3946 * range (after we've made the page RO). 3947 * 3948 * It is also expected that the pmap modified 3949 * bit has already been cleared by the 3950 * vm_page_protect(). We may not be able 3951 * to clear all dirty bits for a page if it 3952 * was also memory mapped (NFS). 3953 * 3954 * Finally be sure to unassign any swap-cache 3955 * backing store as it is now stale. 3956 */ 3957 vm_page_protect(m, VM_PROT_READ); 3958 vfs_clean_one_page(bp, i, m); 3959 swap_pager_unswapped(m); 3960 } else if (m->valid == VM_PAGE_BITS_ALL) { 3961 /* 3962 * When readying a vnode-backed buffer for 3963 * read we must replace any dirty pages with 3964 * a bogus page so dirty data is not destroyed 3965 * when filling gaps. 3966 * 3967 * To avoid testing whether the page is 3968 * dirty we instead test that the page was 3969 * at some point mapped (m->valid fully 3970 * valid) with the understanding that 3971 * this also covers the dirty case. 3972 */ 3973 bp->b_xio.xio_pages[i] = bogus_page; 3974 bp->b_flags |= B_HASBOGUS; 3975 bogus++; 3976 } else if (m->valid & m->dirty) { 3977 /* 3978 * This case should not occur as partial 3979 * dirtyment can only happen if the buffer 3980 * is B_CACHE, and this code is not entered 3981 * if the buffer is B_CACHE. 3982 */ 3983 kprintf("Warning: vfs_busy_pages - page not " 3984 "fully valid! loff=%jx bpf=%08x " 3985 "idx=%d val=%02x dir=%02x\n", 3986 (uintmax_t)bp->b_loffset, bp->b_flags, 3987 i, m->valid, m->dirty); 3988 vm_page_protect(m, VM_PROT_NONE); 3989 } else { 3990 /* 3991 * The page is not valid and can be made 3992 * part of the read. 3993 */ 3994 vm_page_protect(m, VM_PROT_NONE); 3995 } 3996 vm_page_wakeup(m); 3997 } 3998 if (bogus) { 3999 pmap_qenter_noinval(trunc_page((vm_offset_t)bp->b_data), 4000 bp->b_xio.xio_pages, 4001 bp->b_xio.xio_npages); 4002 bkvareset(bp); 4003 } 4004 } 4005 4006 /* 4007 * This is the easiest place to put the process accounting for the I/O 4008 * for now. 4009 */ 4010 if (lp != NULL) { 4011 if (bp->b_cmd == BUF_CMD_READ) 4012 lp->lwp_ru.ru_inblock++; 4013 else 4014 lp->lwp_ru.ru_oublock++; 4015 } 4016 } 4017 4018 /* 4019 * Tell the VM system that the pages associated with this buffer 4020 * are clean. This is used for delayed writes where the data is 4021 * going to go to disk eventually without additional VM intevention. 4022 * 4023 * NOTE: While we only really need to clean through to b_bcount, we 4024 * just go ahead and clean through to b_bufsize. 4025 */ 4026 static void 4027 vfs_clean_pages(struct buf *bp) 4028 { 4029 vm_page_t m; 4030 int i; 4031 4032 if ((bp->b_flags & B_VMIO) == 0) 4033 return; 4034 4035 KASSERT(bp->b_loffset != NOOFFSET, 4036 ("vfs_clean_pages: no buffer offset")); 4037 4038 for (i = 0; i < bp->b_xio.xio_npages; i++) { 4039 m = bp->b_xio.xio_pages[i]; 4040 vfs_clean_one_page(bp, i, m); 4041 } 4042 } 4043 4044 /* 4045 * vfs_clean_one_page: 4046 * 4047 * Set the valid bits and clear the dirty bits in a page within a 4048 * buffer. The range is restricted to the buffer's size and the 4049 * buffer's logical offset might index into the first page. 4050 * 4051 * The caller has busied or soft-busied the page and it is not mapped, 4052 * test and incorporate the dirty bits into b_dirtyoff/end before 4053 * clearing them. Note that we need to clear the pmap modified bits 4054 * after determining the the page was dirty, vm_page_set_validclean() 4055 * does not do it for us. 4056 * 4057 * This routine is typically called after a read completes (dirty should 4058 * be zero in that case as we are not called on bogus-replace pages), 4059 * or before a write is initiated. 4060 */ 4061 static void 4062 vfs_clean_one_page(struct buf *bp, int pageno, vm_page_t m) 4063 { 4064 int bcount; 4065 int xoff; 4066 int soff; 4067 int eoff; 4068 4069 /* 4070 * Calculate offset range within the page but relative to buffer's 4071 * loffset. loffset might be offset into the first page. 4072 */ 4073 xoff = (int)bp->b_loffset & PAGE_MASK; /* loffset offset into pg 0 */ 4074 bcount = bp->b_bcount + xoff; /* offset adjusted */ 4075 4076 if (pageno == 0) { 4077 soff = xoff; 4078 eoff = PAGE_SIZE; 4079 } else { 4080 soff = (pageno << PAGE_SHIFT); 4081 eoff = soff + PAGE_SIZE; 4082 } 4083 if (eoff > bcount) 4084 eoff = bcount; 4085 if (soff >= eoff) 4086 return; 4087 4088 /* 4089 * Test dirty bits and adjust b_dirtyoff/end. 4090 * 4091 * If dirty pages are incorporated into the bp any prior 4092 * B_NEEDCOMMIT state (NFS) must be cleared because the 4093 * caller has not taken into account the new dirty data. 4094 * 4095 * If the page was memory mapped the dirty bits might go beyond the 4096 * end of the buffer, but we can't really make the assumption that 4097 * a file EOF straddles the buffer (even though this is the case for 4098 * NFS if B_NEEDCOMMIT is also set). So for the purposes of clearing 4099 * B_NEEDCOMMIT we only test the dirty bits covered by the buffer. 4100 * This also saves some console spam. 4101 * 4102 * When clearing B_NEEDCOMMIT we must also clear B_CLUSTEROK, 4103 * NFS can handle huge commits but not huge writes. 4104 */ 4105 vm_page_test_dirty(m); 4106 if (m->dirty) { 4107 if ((bp->b_flags & B_NEEDCOMMIT) && 4108 (m->dirty & vm_page_bits(soff & PAGE_MASK, eoff - soff))) { 4109 if (debug_commit) 4110 kprintf("Warning: vfs_clean_one_page: bp %p " 4111 "loff=%jx,%d flgs=%08x clr B_NEEDCOMMIT" 4112 " cmd %d vd %02x/%02x x/s/e %d %d %d " 4113 "doff/end %d %d\n", 4114 bp, (uintmax_t)bp->b_loffset, bp->b_bcount, 4115 bp->b_flags, bp->b_cmd, 4116 m->valid, m->dirty, xoff, soff, eoff, 4117 bp->b_dirtyoff, bp->b_dirtyend); 4118 bp->b_flags &= ~(B_NEEDCOMMIT | B_CLUSTEROK); 4119 if (debug_commit) 4120 print_backtrace(-1); 4121 } 4122 /* 4123 * Only clear the pmap modified bits if ALL the dirty bits 4124 * are set, otherwise the system might mis-clear portions 4125 * of a page. 4126 */ 4127 if (m->dirty == VM_PAGE_BITS_ALL && 4128 (bp->b_flags & B_NEEDCOMMIT) == 0) { 4129 pmap_clear_modify(m); 4130 } 4131 if (bp->b_dirtyoff > soff - xoff) 4132 bp->b_dirtyoff = soff - xoff; 4133 if (bp->b_dirtyend < eoff - xoff) 4134 bp->b_dirtyend = eoff - xoff; 4135 } 4136 4137 /* 4138 * Set related valid bits, clear related dirty bits. 4139 * Does not mess with the pmap modified bit. 4140 * 4141 * WARNING! We cannot just clear all of m->dirty here as the 4142 * buffer cache buffers may use a DEV_BSIZE'd aligned 4143 * block size, or have an odd size (e.g. NFS at file EOF). 4144 * The putpages code can clear m->dirty to 0. 4145 * 4146 * If a VOP_WRITE generates a buffer cache buffer which 4147 * covers the same space as mapped writable pages the 4148 * buffer flush might not be able to clear all the dirty 4149 * bits and still require a putpages from the VM system 4150 * to finish it off. 4151 * 4152 * WARNING! vm_page_set_validclean() currently assumes vm_token 4153 * is held. The page might not be busied (bdwrite() case). 4154 * XXX remove this comment once we've validated that this 4155 * is no longer an issue. 4156 */ 4157 vm_page_set_validclean(m, soff & PAGE_MASK, eoff - soff); 4158 } 4159 4160 #if 0 4161 /* 4162 * Similar to vfs_clean_one_page() but sets the bits to valid and dirty. 4163 * The page data is assumed to be valid (there is no zeroing here). 4164 */ 4165 static void 4166 vfs_dirty_one_page(struct buf *bp, int pageno, vm_page_t m) 4167 { 4168 int bcount; 4169 int xoff; 4170 int soff; 4171 int eoff; 4172 4173 /* 4174 * Calculate offset range within the page but relative to buffer's 4175 * loffset. loffset might be offset into the first page. 4176 */ 4177 xoff = (int)bp->b_loffset & PAGE_MASK; /* loffset offset into pg 0 */ 4178 bcount = bp->b_bcount + xoff; /* offset adjusted */ 4179 4180 if (pageno == 0) { 4181 soff = xoff; 4182 eoff = PAGE_SIZE; 4183 } else { 4184 soff = (pageno << PAGE_SHIFT); 4185 eoff = soff + PAGE_SIZE; 4186 } 4187 if (eoff > bcount) 4188 eoff = bcount; 4189 if (soff >= eoff) 4190 return; 4191 vm_page_set_validdirty(m, soff & PAGE_MASK, eoff - soff); 4192 } 4193 #endif 4194 4195 /* 4196 * vfs_bio_clrbuf: 4197 * 4198 * Clear a buffer. This routine essentially fakes an I/O, so we need 4199 * to clear B_ERROR and B_INVAL. 4200 * 4201 * Note that while we only theoretically need to clear through b_bcount, 4202 * we go ahead and clear through b_bufsize. 4203 */ 4204 void 4205 vfs_bio_clrbuf(struct buf *bp) 4206 { 4207 int i, mask = 0; 4208 caddr_t sa, ea; 4209 KKASSERT(bp->b_flags & B_VMIO); 4210 4211 bp->b_flags &= ~(B_INVAL | B_EINTR | B_ERROR); 4212 bkvasync(bp); 4213 4214 if ((bp->b_xio.xio_npages == 1) && (bp->b_bufsize < PAGE_SIZE) && 4215 (bp->b_loffset & PAGE_MASK) == 0) { 4216 mask = (1 << (bp->b_bufsize / DEV_BSIZE)) - 1; 4217 if ((bp->b_xio.xio_pages[0]->valid & mask) == mask) { 4218 bp->b_resid = 0; 4219 return; 4220 } 4221 if ((bp->b_xio.xio_pages[0]->valid & mask) == 0) { 4222 bzero(bp->b_data, bp->b_bufsize); 4223 bp->b_xio.xio_pages[0]->valid |= mask; 4224 bp->b_resid = 0; 4225 return; 4226 } 4227 } 4228 sa = bp->b_data; 4229 for(i = 0; i < bp->b_xio.xio_npages; i++, sa=ea) { 4230 int j = ((vm_offset_t)sa & PAGE_MASK) / DEV_BSIZE; 4231 ea = (caddr_t)trunc_page((vm_offset_t)sa + PAGE_SIZE); 4232 ea = (caddr_t)(vm_offset_t)ulmin( 4233 (u_long)(vm_offset_t)ea, 4234 (u_long)(vm_offset_t)bp->b_data + bp->b_bufsize); 4235 mask = ((1 << ((ea - sa) / DEV_BSIZE)) - 1) << j; 4236 if ((bp->b_xio.xio_pages[i]->valid & mask) == mask) 4237 continue; 4238 if ((bp->b_xio.xio_pages[i]->valid & mask) == 0) { 4239 bzero(sa, ea - sa); 4240 } else { 4241 for (; sa < ea; sa += DEV_BSIZE, j++) { 4242 if ((bp->b_xio.xio_pages[i]->valid & 4243 (1<<j)) == 0) { 4244 bzero(sa, DEV_BSIZE); 4245 } 4246 } 4247 } 4248 bp->b_xio.xio_pages[i]->valid |= mask; 4249 } 4250 bp->b_resid = 0; 4251 } 4252 4253 /* 4254 * Allocate a page for a buffer cache buffer. 4255 * 4256 * If NULL is returned the caller is expected to retry (typically check if 4257 * the page already exists on retry before trying to allocate one). 4258 * 4259 * NOTE! Low-memory handling is dealt with in b[q]relse(), not here. This 4260 * function will use the system reserve with the hope that the page 4261 * allocations can be returned to PQ_CACHE/PQ_FREE when the caller 4262 * is done with the buffer. 4263 * 4264 * NOTE! However, TMPFS is a special case because flushing a dirty buffer 4265 * to TMPFS doesn't clean the page. For TMPFS, only the pagedaemon 4266 * is capable of retiring pages (to swap). For TMPFS we don't dig 4267 * into the system reserve because doing so could stall out pretty 4268 * much every process running on the system. 4269 */ 4270 static 4271 vm_page_t 4272 bio_page_alloc(struct buf *bp, vm_object_t obj, vm_pindex_t pg, int deficit) 4273 { 4274 int vmflags = VM_ALLOC_NORMAL | VM_ALLOC_NULL_OK; 4275 vm_page_t p; 4276 4277 ASSERT_LWKT_TOKEN_HELD(vm_object_token(obj)); 4278 4279 /* 4280 * Try a normal allocation first. 4281 */ 4282 p = vm_page_alloc(obj, pg, vmflags); 4283 if (p) 4284 return(p); 4285 if (vm_page_lookup(obj, pg)) 4286 return(NULL); 4287 vm_pageout_deficit += deficit; 4288 4289 /* 4290 * Try again, digging into the system reserve. 4291 * 4292 * Trying to recover pages from the buffer cache here can deadlock 4293 * against other threads trying to busy underlying pages so we 4294 * depend on the code in brelse() and bqrelse() to free/cache the 4295 * underlying buffer cache pages when memory is low. 4296 */ 4297 if (curthread->td_flags & TDF_SYSTHREAD) 4298 vmflags |= VM_ALLOC_SYSTEM | VM_ALLOC_INTERRUPT; 4299 else if (bp->b_vp && bp->b_vp->v_tag == VT_TMPFS) 4300 vmflags |= 0; 4301 else 4302 vmflags |= VM_ALLOC_SYSTEM; 4303 4304 /*recoverbufpages();*/ 4305 p = vm_page_alloc(obj, pg, vmflags); 4306 if (p) 4307 return(p); 4308 if (vm_page_lookup(obj, pg)) 4309 return(NULL); 4310 4311 /* 4312 * Wait for memory to free up and try again 4313 */ 4314 if (vm_page_count_severe()) 4315 ++lowmempgallocs; 4316 vm_wait(hz / 20 + 1); 4317 4318 p = vm_page_alloc(obj, pg, vmflags); 4319 if (p) 4320 return(p); 4321 if (vm_page_lookup(obj, pg)) 4322 return(NULL); 4323 4324 /* 4325 * Ok, now we are really in trouble. 4326 */ 4327 if (bootverbose) { 4328 static struct krate biokrate = { .freq = 1 }; 4329 krateprintf(&biokrate, 4330 "Warning: bio_page_alloc: memory exhausted " 4331 "during buffer cache page allocation from %s\n", 4332 curthread->td_comm); 4333 } 4334 if (curthread->td_flags & TDF_SYSTHREAD) 4335 vm_wait(hz / 20 + 1); 4336 else 4337 vm_wait(hz / 2 + 1); 4338 return (NULL); 4339 } 4340 4341 /* 4342 * The buffer's mapping has changed. Adjust the buffer's memory 4343 * synchronization. The caller is the exclusive holder of the buffer 4344 * and has set or cleared B_KVABIO according to preference. 4345 * 4346 * WARNING! If the caller is using B_KVABIO mode, this function will 4347 * not map the data to the current cpu. The caller must also 4348 * call bkvasync(bp). 4349 */ 4350 void 4351 bkvareset(struct buf *bp) 4352 { 4353 if (bp->b_flags & B_KVABIO) { 4354 CPUMASK_ASSZERO(bp->b_cpumask); 4355 } else { 4356 CPUMASK_ORMASK(bp->b_cpumask, smp_active_mask); 4357 smp_invltlb(); 4358 cpu_invltlb(); 4359 } 4360 } 4361 4362 /* 4363 * The buffer will be used by the caller on the caller's cpu, synchronize 4364 * its data to the current cpu. Caller must control the buffer by holding 4365 * its lock, but calling cpu does not necessarily have to be the owner of 4366 * the lock (i.e. HAMMER2's concurrent I/O accessors). 4367 * 4368 * If B_KVABIO is not set, the buffer is already fully synchronized. 4369 */ 4370 void 4371 bkvasync(struct buf *bp) 4372 { 4373 int cpuid = mycpu->gd_cpuid; 4374 char *bdata; 4375 4376 if ((bp->b_flags & B_KVABIO) && 4377 CPUMASK_TESTBIT(bp->b_cpumask, cpuid) == 0) { 4378 bdata = bp->b_data; 4379 while (bdata < bp->b_data + bp->b_bufsize) { 4380 cpu_invlpg(bdata); 4381 bdata += PAGE_SIZE - 4382 ((intptr_t)bdata & PAGE_MASK); 4383 } 4384 ATOMIC_CPUMASK_ORBIT(bp->b_cpumask, cpuid); 4385 } 4386 } 4387 4388 /* 4389 * The buffer will be used by a subsystem that does not understand 4390 * the KVABIO API. Make sure its data is synchronized to all cpus. 4391 * 4392 * If B_KVABIO is not set, the buffer is already fully synchronized. 4393 * 4394 * NOTE! This is the only safe way to clear B_KVABIO on a buffer. 4395 */ 4396 void 4397 bkvasync_all(struct buf *bp) 4398 { 4399 if (debug_kvabio > 0) { 4400 --debug_kvabio; 4401 print_backtrace(10); 4402 } 4403 4404 if ((bp->b_flags & B_KVABIO) && 4405 CPUMASK_CMPMASKNEQ(bp->b_cpumask, smp_active_mask)) { 4406 smp_invltlb(); 4407 cpu_invltlb(); 4408 ATOMIC_CPUMASK_ORMASK(bp->b_cpumask, smp_active_mask); 4409 } 4410 bp->b_flags &= ~B_KVABIO; 4411 } 4412 4413 /* 4414 * Scan all buffers in the system and issue the callback. 4415 */ 4416 int 4417 scan_all_buffers(int (*callback)(struct buf *, void *), void *info) 4418 { 4419 int count = 0; 4420 int error; 4421 long n; 4422 4423 for (n = 0; n < nbuf; ++n) { 4424 if ((error = callback(&buf[n], info)) < 0) { 4425 count = error; 4426 break; 4427 } 4428 count += error; 4429 } 4430 return (count); 4431 } 4432 4433 /* 4434 * nestiobuf_iodone: biodone callback for nested buffers and propagate 4435 * completion to the master buffer. 4436 */ 4437 static void 4438 nestiobuf_iodone(struct bio *bio) 4439 { 4440 struct bio *mbio; 4441 struct buf *mbp, *bp; 4442 struct devstat *stats; 4443 int error; 4444 int donebytes; 4445 4446 bp = bio->bio_buf; 4447 mbio = bio->bio_caller_info1.ptr; 4448 stats = bio->bio_caller_info2.ptr; 4449 mbp = mbio->bio_buf; 4450 4451 KKASSERT(bp->b_bcount <= bp->b_bufsize); 4452 KKASSERT(mbp != bp); 4453 4454 error = bp->b_error; 4455 if (bp->b_error == 0 && 4456 (bp->b_bcount < bp->b_bufsize || bp->b_resid > 0)) { 4457 /* 4458 * Not all got transfered, raise an error. We have no way to 4459 * propagate these conditions to mbp. 4460 */ 4461 error = EIO; 4462 } 4463 4464 donebytes = bp->b_bufsize; 4465 4466 relpbuf(bp, NULL); 4467 4468 nestiobuf_done(mbio, donebytes, error, stats); 4469 } 4470 4471 void 4472 nestiobuf_done(struct bio *mbio, int donebytes, int error, struct devstat *stats) 4473 { 4474 struct buf *mbp; 4475 4476 mbp = mbio->bio_buf; 4477 4478 KKASSERT((int)(intptr_t)mbio->bio_driver_info > 0); 4479 4480 /* 4481 * If an error occured, propagate it to the master buffer. 4482 * 4483 * Several biodone()s may wind up running concurrently so 4484 * use an atomic op to adjust b_flags. 4485 */ 4486 if (error) { 4487 mbp->b_error = error; 4488 atomic_set_int(&mbp->b_flags, B_ERROR); 4489 } 4490 4491 /* 4492 * Decrement the operations in progress counter and terminate the 4493 * I/O if this was the last bit. 4494 */ 4495 if (atomic_fetchadd_int((int *)&mbio->bio_driver_info, -1) == 1) { 4496 mbp->b_resid = 0; 4497 if (stats) 4498 devstat_end_transaction_buf(stats, mbp); 4499 biodone(mbio); 4500 } 4501 } 4502 4503 /* 4504 * Initialize a nestiobuf for use. Set an initial count of 1 to prevent 4505 * the mbio from being biodone()'d while we are still adding sub-bios to 4506 * it. 4507 */ 4508 void 4509 nestiobuf_init(struct bio *bio) 4510 { 4511 bio->bio_driver_info = (void *)1; 4512 } 4513 4514 /* 4515 * The BIOs added to the nestedio have already been started, remove the 4516 * count that placeheld our mbio and biodone() it if the count would 4517 * transition to 0. 4518 */ 4519 void 4520 nestiobuf_start(struct bio *mbio) 4521 { 4522 struct buf *mbp = mbio->bio_buf; 4523 4524 /* 4525 * Decrement the operations in progress counter and terminate the 4526 * I/O if this was the last bit. 4527 */ 4528 if (atomic_fetchadd_int((int *)&mbio->bio_driver_info, -1) == 1) { 4529 if (mbp->b_flags & B_ERROR) 4530 mbp->b_resid = mbp->b_bcount; 4531 else 4532 mbp->b_resid = 0; 4533 biodone(mbio); 4534 } 4535 } 4536 4537 /* 4538 * Set an intermediate error prior to calling nestiobuf_start() 4539 */ 4540 void 4541 nestiobuf_error(struct bio *mbio, int error) 4542 { 4543 struct buf *mbp = mbio->bio_buf; 4544 4545 if (error) { 4546 mbp->b_error = error; 4547 atomic_set_int(&mbp->b_flags, B_ERROR); 4548 } 4549 } 4550 4551 /* 4552 * nestiobuf_add: setup a "nested" buffer. 4553 * 4554 * => 'mbp' is a "master" buffer which is being divided into sub pieces. 4555 * => 'bp' should be a buffer allocated by getiobuf. 4556 * => 'offset' is a byte offset in the master buffer. 4557 * => 'size' is a size in bytes of this nested buffer. 4558 */ 4559 void 4560 nestiobuf_add(struct bio *mbio, struct buf *bp, int offset, size_t size, struct devstat *stats) 4561 { 4562 struct buf *mbp = mbio->bio_buf; 4563 struct vnode *vp = mbp->b_vp; 4564 4565 KKASSERT(mbp->b_bcount >= offset + size); 4566 4567 atomic_add_int((int *)&mbio->bio_driver_info, 1); 4568 4569 /* kernel needs to own the lock for it to be released in biodone */ 4570 BUF_KERNPROC(bp); 4571 bp->b_vp = vp; 4572 bp->b_cmd = mbp->b_cmd; 4573 bp->b_bio1.bio_done = nestiobuf_iodone; 4574 bp->b_data = (char *)mbp->b_data + offset; 4575 bp->b_resid = bp->b_bcount = size; 4576 bp->b_bufsize = bp->b_bcount; 4577 4578 bp->b_bio1.bio_track = NULL; 4579 bp->b_bio1.bio_caller_info1.ptr = mbio; 4580 bp->b_bio1.bio_caller_info2.ptr = stats; 4581 } 4582 4583 #ifdef DDB 4584 4585 DB_SHOW_COMMAND(buffer, db_show_buffer) 4586 { 4587 /* get args */ 4588 struct buf *bp = (struct buf *)addr; 4589 4590 if (!have_addr) { 4591 db_printf("usage: show buffer <addr>\n"); 4592 return; 4593 } 4594 4595 db_printf("b_flags = 0x%pb%i\n", PRINT_BUF_FLAGS, bp->b_flags); 4596 db_printf("b_cmd = %d\n", bp->b_cmd); 4597 db_printf("b_error = %d, b_bufsize = %d, b_bcount = %d, " 4598 "b_resid = %d\n, b_data = %p, " 4599 "bio_offset(disk) = %lld, bio_offset(phys) = %lld\n", 4600 bp->b_error, bp->b_bufsize, bp->b_bcount, bp->b_resid, 4601 bp->b_data, 4602 (long long)bp->b_bio2.bio_offset, 4603 (long long)(bp->b_bio2.bio_next ? 4604 bp->b_bio2.bio_next->bio_offset : (off_t)-1)); 4605 if (bp->b_xio.xio_npages) { 4606 int i; 4607 db_printf("b_xio.xio_npages = %d, pages(OBJ, IDX, PA): ", 4608 bp->b_xio.xio_npages); 4609 for (i = 0; i < bp->b_xio.xio_npages; i++) { 4610 vm_page_t m; 4611 m = bp->b_xio.xio_pages[i]; 4612 db_printf("(%p, 0x%lx, 0x%lx)", (void *)m->object, 4613 (u_long)m->pindex, (u_long)VM_PAGE_TO_PHYS(m)); 4614 if ((i + 1) < bp->b_xio.xio_npages) 4615 db_printf(","); 4616 } 4617 db_printf("\n"); 4618 } 4619 } 4620 #endif /* DDB */ 4621