1 /* 2 * Copyright (c) 2008 The DragonFly Project. All rights reserved. 3 * 4 * This code is derived from software contributed to The DragonFly Project 5 * by Matthew Dillon <dillon@backplane.com> 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 11 * 1. Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * 2. Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in 15 * the documentation and/or other materials provided with the 16 * distribution. 17 * 3. Neither the name of The DragonFly Project nor the names of its 18 * contributors may be used to endorse or promote products derived 19 * from this software without specific, prior written permission. 20 * 21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 22 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 23 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 24 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE 25 * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 26 * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING, 27 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 28 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED 29 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 30 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT 31 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 32 * SUCH DAMAGE. 33 * 34 * $DragonFly: src/sys/vfs/hammer/hammer_blockmap.c,v 1.27 2008/07/31 22:30:33 dillon Exp $ 35 */ 36 37 /* 38 * HAMMER blockmap 39 */ 40 #include "hammer.h" 41 42 static int hammer_res_rb_compare(hammer_reserve_t res1, hammer_reserve_t res2); 43 static void hammer_reserve_setdelay_offset(hammer_mount_t hmp, 44 hammer_off_t base_offset, int zone, 45 struct hammer_blockmap_layer2 *layer2); 46 static void hammer_reserve_setdelay(hammer_mount_t hmp, hammer_reserve_t resv); 47 48 /* 49 * Reserved big-blocks red-black tree support 50 */ 51 RB_GENERATE2(hammer_res_rb_tree, hammer_reserve, rb_node, 52 hammer_res_rb_compare, hammer_off_t, zone_offset); 53 54 static int 55 hammer_res_rb_compare(hammer_reserve_t res1, hammer_reserve_t res2) 56 { 57 if (res1->zone_offset < res2->zone_offset) 58 return(-1); 59 if (res1->zone_offset > res2->zone_offset) 60 return(1); 61 return(0); 62 } 63 64 /* 65 * Allocate bytes from a zone 66 */ 67 hammer_off_t 68 hammer_blockmap_alloc(hammer_transaction_t trans, int zone, int bytes, 69 hammer_off_t hint, int *errorp) 70 { 71 hammer_mount_t hmp; 72 hammer_volume_t root_volume; 73 hammer_blockmap_t blockmap; 74 hammer_blockmap_t freemap; 75 hammer_reserve_t resv; 76 struct hammer_blockmap_layer1 *layer1; 77 struct hammer_blockmap_layer2 *layer2; 78 hammer_buffer_t buffer1 = NULL; 79 hammer_buffer_t buffer2 = NULL; 80 hammer_buffer_t buffer3 = NULL; 81 hammer_off_t tmp_offset; 82 hammer_off_t next_offset; 83 hammer_off_t result_offset; 84 hammer_off_t layer1_offset; 85 hammer_off_t layer2_offset; 86 hammer_off_t base_off; 87 int loops = 0; 88 int offset; /* offset within big-block */ 89 int use_hint; 90 91 hmp = trans->hmp; 92 93 /* 94 * Deal with alignment and buffer-boundary issues. 95 * 96 * Be careful, certain primary alignments are used below to allocate 97 * new blockmap blocks. 98 */ 99 bytes = (bytes + 15) & ~15; 100 KKASSERT(bytes > 0 && bytes <= HAMMER_XBUFSIZE); 101 KKASSERT(zone >= HAMMER_ZONE_BTREE_INDEX && zone < HAMMER_MAX_ZONES); 102 103 /* 104 * Setup 105 */ 106 root_volume = trans->rootvol; 107 *errorp = 0; 108 blockmap = &hmp->blockmap[zone]; 109 freemap = &hmp->blockmap[HAMMER_ZONE_FREEMAP_INDEX]; 110 KKASSERT(HAMMER_ZONE_DECODE(blockmap->next_offset) == zone); 111 112 /* 113 * Use the hint if we have one. 114 */ 115 if (hint && HAMMER_ZONE_DECODE(hint) == zone) { 116 next_offset = (hint + 15) & ~(hammer_off_t)15; 117 use_hint = 1; 118 } else { 119 next_offset = blockmap->next_offset; 120 use_hint = 0; 121 } 122 again: 123 124 /* 125 * use_hint is turned off if we leave the hinted big-block. 126 */ 127 if (use_hint && ((next_offset ^ hint) & ~HAMMER_HINTBLOCK_MASK64)) { 128 next_offset = blockmap->next_offset; 129 use_hint = 0; 130 } 131 132 /* 133 * Check for wrap 134 */ 135 if (next_offset == HAMMER_ZONE_ENCODE(zone + 1, 0)) { 136 if (++loops == 2) { 137 result_offset = 0; 138 *errorp = ENOSPC; 139 goto failed; 140 } 141 next_offset = HAMMER_ZONE_ENCODE(zone, 0); 142 } 143 144 /* 145 * The allocation request may not cross a buffer boundary. Special 146 * large allocations must not cross a large-block boundary. 147 */ 148 tmp_offset = next_offset + bytes - 1; 149 if (bytes <= HAMMER_BUFSIZE) { 150 if ((next_offset ^ tmp_offset) & ~HAMMER_BUFMASK64) { 151 next_offset = tmp_offset & ~HAMMER_BUFMASK64; 152 goto again; 153 } 154 } else { 155 if ((next_offset ^ tmp_offset) & ~HAMMER_LARGEBLOCK_MASK64) { 156 next_offset = tmp_offset & ~HAMMER_LARGEBLOCK_MASK64; 157 goto again; 158 } 159 } 160 offset = (int)next_offset & HAMMER_LARGEBLOCK_MASK; 161 162 /* 163 * Dive layer 1. 164 */ 165 layer1_offset = freemap->phys_offset + 166 HAMMER_BLOCKMAP_LAYER1_OFFSET(next_offset); 167 168 layer1 = hammer_bread(hmp, layer1_offset, errorp, &buffer1); 169 if (*errorp) { 170 result_offset = 0; 171 goto failed; 172 } 173 174 /* 175 * Check CRC. 176 */ 177 if (layer1->layer1_crc != crc32(layer1, HAMMER_LAYER1_CRCSIZE)) { 178 hammer_lock_ex(&hmp->blkmap_lock); 179 if (layer1->layer1_crc != crc32(layer1, HAMMER_LAYER1_CRCSIZE)) 180 panic("CRC FAILED: LAYER1"); 181 hammer_unlock(&hmp->blkmap_lock); 182 } 183 184 /* 185 * If we are at a big-block boundary and layer1 indicates no 186 * free big-blocks, then we cannot allocate a new bigblock in 187 * layer2, skip to the next layer1 entry. 188 */ 189 if (offset == 0 && layer1->blocks_free == 0) { 190 next_offset = (next_offset + HAMMER_BLOCKMAP_LAYER2) & 191 ~HAMMER_BLOCKMAP_LAYER2_MASK; 192 goto again; 193 } 194 KKASSERT(layer1->phys_offset != HAMMER_BLOCKMAP_UNAVAIL); 195 196 /* 197 * Skip this layer1 entry if it is pointing to a layer2 big-block 198 * on a volume that we are currently trying to remove from the 199 * file-system. This is used by the volume-del code together with 200 * the reblocker to free up a volume. 201 */ 202 if ((int)HAMMER_VOL_DECODE(layer1->phys_offset) == 203 hmp->volume_to_remove) { 204 next_offset = (next_offset + HAMMER_BLOCKMAP_LAYER2) & 205 ~HAMMER_BLOCKMAP_LAYER2_MASK; 206 goto again; 207 } 208 209 /* 210 * Dive layer 2, each entry represents a large-block. 211 */ 212 layer2_offset = layer1->phys_offset + 213 HAMMER_BLOCKMAP_LAYER2_OFFSET(next_offset); 214 layer2 = hammer_bread(hmp, layer2_offset, errorp, &buffer2); 215 if (*errorp) { 216 result_offset = 0; 217 goto failed; 218 } 219 220 /* 221 * Check CRC. This can race another thread holding the lock 222 * and in the middle of modifying layer2. 223 */ 224 if (layer2->entry_crc != crc32(layer2, HAMMER_LAYER2_CRCSIZE)) { 225 hammer_lock_ex(&hmp->blkmap_lock); 226 if (layer2->entry_crc != crc32(layer2, HAMMER_LAYER2_CRCSIZE)) 227 panic("CRC FAILED: LAYER2"); 228 hammer_unlock(&hmp->blkmap_lock); 229 } 230 231 /* 232 * Skip the layer if the zone is owned by someone other then us. 233 */ 234 if (layer2->zone && layer2->zone != zone) { 235 next_offset += (HAMMER_LARGEBLOCK_SIZE - offset); 236 goto again; 237 } 238 if (offset < layer2->append_off) { 239 next_offset += layer2->append_off - offset; 240 goto again; 241 } 242 243 /* 244 * If operating in the current non-hint blockmap block, do not 245 * allow it to get over-full. Also drop any active hinting so 246 * blockmap->next_offset is updated at the end. 247 * 248 * We do this for B-Tree and meta-data allocations to provide 249 * localization for updates. 250 */ 251 if ((zone == HAMMER_ZONE_BTREE_INDEX || 252 zone == HAMMER_ZONE_META_INDEX) && 253 offset >= HAMMER_LARGEBLOCK_OVERFILL && 254 !((next_offset ^ blockmap->next_offset) & ~HAMMER_LARGEBLOCK_MASK64) 255 ) { 256 if (offset >= HAMMER_LARGEBLOCK_OVERFILL) { 257 next_offset += (HAMMER_LARGEBLOCK_SIZE - offset); 258 use_hint = 0; 259 goto again; 260 } 261 } 262 263 /* 264 * We need the lock from this point on. We have to re-check zone 265 * ownership after acquiring the lock and also check for reservations. 266 */ 267 hammer_lock_ex(&hmp->blkmap_lock); 268 269 if (layer2->zone && layer2->zone != zone) { 270 hammer_unlock(&hmp->blkmap_lock); 271 next_offset += (HAMMER_LARGEBLOCK_SIZE - offset); 272 goto again; 273 } 274 if (offset < layer2->append_off) { 275 hammer_unlock(&hmp->blkmap_lock); 276 next_offset += layer2->append_off - offset; 277 goto again; 278 } 279 280 /* 281 * The bigblock might be reserved by another zone. If it is reserved 282 * by our zone we may have to move next_offset past the append_off. 283 */ 284 base_off = (next_offset & 285 (~HAMMER_LARGEBLOCK_MASK64 & ~HAMMER_OFF_ZONE_MASK)) | 286 HAMMER_ZONE_RAW_BUFFER; 287 resv = RB_LOOKUP(hammer_res_rb_tree, &hmp->rb_resv_root, base_off); 288 if (resv) { 289 if (resv->zone != zone) { 290 hammer_unlock(&hmp->blkmap_lock); 291 next_offset = (next_offset + HAMMER_LARGEBLOCK_SIZE) & 292 ~HAMMER_LARGEBLOCK_MASK64; 293 goto again; 294 } 295 if (offset < resv->append_off) { 296 hammer_unlock(&hmp->blkmap_lock); 297 next_offset += resv->append_off - offset; 298 goto again; 299 } 300 ++resv->refs; 301 } 302 303 /* 304 * Ok, we can allocate out of this layer2 big-block. Assume ownership 305 * of the layer for real. At this point we've validated any 306 * reservation that might exist and can just ignore resv. 307 */ 308 if (layer2->zone == 0) { 309 /* 310 * Assign the bigblock to our zone 311 */ 312 hammer_modify_buffer(trans, buffer1, 313 layer1, sizeof(*layer1)); 314 --layer1->blocks_free; 315 layer1->layer1_crc = crc32(layer1, 316 HAMMER_LAYER1_CRCSIZE); 317 hammer_modify_buffer_done(buffer1); 318 hammer_modify_buffer(trans, buffer2, 319 layer2, sizeof(*layer2)); 320 layer2->zone = zone; 321 KKASSERT(layer2->bytes_free == HAMMER_LARGEBLOCK_SIZE); 322 KKASSERT(layer2->append_off == 0); 323 hammer_modify_volume_field(trans, trans->rootvol, 324 vol0_stat_freebigblocks); 325 --root_volume->ondisk->vol0_stat_freebigblocks; 326 hmp->copy_stat_freebigblocks = 327 root_volume->ondisk->vol0_stat_freebigblocks; 328 hammer_modify_volume_done(trans->rootvol); 329 } else { 330 hammer_modify_buffer(trans, buffer2, 331 layer2, sizeof(*layer2)); 332 } 333 KKASSERT(layer2->zone == zone); 334 335 layer2->bytes_free -= bytes; 336 KKASSERT(layer2->append_off <= offset); 337 layer2->append_off = offset + bytes; 338 layer2->entry_crc = crc32(layer2, HAMMER_LAYER2_CRCSIZE); 339 hammer_modify_buffer_done(buffer2); 340 KKASSERT(layer2->bytes_free >= 0); 341 342 /* 343 * We hold the blockmap lock and should be the only ones 344 * capable of modifying resv->append_off. Track the allocation 345 * as appropriate. 346 */ 347 KKASSERT(bytes != 0); 348 if (resv) { 349 KKASSERT(resv->append_off <= offset); 350 resv->append_off = offset + bytes; 351 resv->flags &= ~HAMMER_RESF_LAYER2FREE; 352 hammer_blockmap_reserve_complete(hmp, resv); 353 } 354 355 /* 356 * If we are allocating from the base of a new buffer we can avoid 357 * a disk read by calling hammer_bnew(). 358 */ 359 if ((next_offset & HAMMER_BUFMASK) == 0) { 360 hammer_bnew_ext(trans->hmp, next_offset, bytes, 361 errorp, &buffer3); 362 } 363 result_offset = next_offset; 364 365 /* 366 * If we weren't supplied with a hint or could not use the hint 367 * then we wound up using blockmap->next_offset as the hint and 368 * need to save it. 369 */ 370 if (use_hint == 0) { 371 hammer_modify_volume(NULL, root_volume, NULL, 0); 372 blockmap->next_offset = next_offset + bytes; 373 hammer_modify_volume_done(root_volume); 374 } 375 hammer_unlock(&hmp->blkmap_lock); 376 failed: 377 378 /* 379 * Cleanup 380 */ 381 if (buffer1) 382 hammer_rel_buffer(buffer1, 0); 383 if (buffer2) 384 hammer_rel_buffer(buffer2, 0); 385 if (buffer3) 386 hammer_rel_buffer(buffer3, 0); 387 388 return(result_offset); 389 } 390 391 /* 392 * Frontend function - Reserve bytes in a zone. 393 * 394 * This code reserves bytes out of a blockmap without committing to any 395 * meta-data modifications, allowing the front-end to directly issue disk 396 * write I/O for large blocks of data 397 * 398 * The backend later finalizes the reservation with hammer_blockmap_finalize() 399 * upon committing the related record. 400 */ 401 hammer_reserve_t 402 hammer_blockmap_reserve(hammer_mount_t hmp, int zone, int bytes, 403 hammer_off_t *zone_offp, int *errorp) 404 { 405 hammer_volume_t root_volume; 406 hammer_blockmap_t blockmap; 407 hammer_blockmap_t freemap; 408 struct hammer_blockmap_layer1 *layer1; 409 struct hammer_blockmap_layer2 *layer2; 410 hammer_buffer_t buffer1 = NULL; 411 hammer_buffer_t buffer2 = NULL; 412 hammer_buffer_t buffer3 = NULL; 413 hammer_off_t tmp_offset; 414 hammer_off_t next_offset; 415 hammer_off_t layer1_offset; 416 hammer_off_t layer2_offset; 417 hammer_off_t base_off; 418 hammer_reserve_t resv; 419 hammer_reserve_t resx; 420 int loops = 0; 421 int offset; 422 423 /* 424 * Setup 425 */ 426 KKASSERT(zone >= HAMMER_ZONE_BTREE_INDEX && zone < HAMMER_MAX_ZONES); 427 root_volume = hammer_get_root_volume(hmp, errorp); 428 if (*errorp) 429 return(NULL); 430 blockmap = &hmp->blockmap[zone]; 431 freemap = &hmp->blockmap[HAMMER_ZONE_FREEMAP_INDEX]; 432 KKASSERT(HAMMER_ZONE_DECODE(blockmap->next_offset) == zone); 433 434 /* 435 * Deal with alignment and buffer-boundary issues. 436 * 437 * Be careful, certain primary alignments are used below to allocate 438 * new blockmap blocks. 439 */ 440 bytes = (bytes + 15) & ~15; 441 KKASSERT(bytes > 0 && bytes <= HAMMER_XBUFSIZE); 442 443 next_offset = blockmap->next_offset; 444 again: 445 resv = NULL; 446 /* 447 * Check for wrap 448 */ 449 if (next_offset == HAMMER_ZONE_ENCODE(zone + 1, 0)) { 450 if (++loops == 2) { 451 *errorp = ENOSPC; 452 goto failed; 453 } 454 next_offset = HAMMER_ZONE_ENCODE(zone, 0); 455 } 456 457 /* 458 * The allocation request may not cross a buffer boundary. Special 459 * large allocations must not cross a large-block boundary. 460 */ 461 tmp_offset = next_offset + bytes - 1; 462 if (bytes <= HAMMER_BUFSIZE) { 463 if ((next_offset ^ tmp_offset) & ~HAMMER_BUFMASK64) { 464 next_offset = tmp_offset & ~HAMMER_BUFMASK64; 465 goto again; 466 } 467 } else { 468 if ((next_offset ^ tmp_offset) & ~HAMMER_LARGEBLOCK_MASK64) { 469 next_offset = tmp_offset & ~HAMMER_LARGEBLOCK_MASK64; 470 goto again; 471 } 472 } 473 offset = (int)next_offset & HAMMER_LARGEBLOCK_MASK; 474 475 /* 476 * Dive layer 1. 477 */ 478 layer1_offset = freemap->phys_offset + 479 HAMMER_BLOCKMAP_LAYER1_OFFSET(next_offset); 480 layer1 = hammer_bread(hmp, layer1_offset, errorp, &buffer1); 481 if (*errorp) 482 goto failed; 483 484 /* 485 * Check CRC. 486 */ 487 if (layer1->layer1_crc != crc32(layer1, HAMMER_LAYER1_CRCSIZE)) { 488 hammer_lock_ex(&hmp->blkmap_lock); 489 if (layer1->layer1_crc != crc32(layer1, HAMMER_LAYER1_CRCSIZE)) 490 panic("CRC FAILED: LAYER1"); 491 hammer_unlock(&hmp->blkmap_lock); 492 } 493 494 /* 495 * If we are at a big-block boundary and layer1 indicates no 496 * free big-blocks, then we cannot allocate a new bigblock in 497 * layer2, skip to the next layer1 entry. 498 */ 499 if ((next_offset & HAMMER_LARGEBLOCK_MASK) == 0 && 500 layer1->blocks_free == 0) { 501 next_offset = (next_offset + HAMMER_BLOCKMAP_LAYER2) & 502 ~HAMMER_BLOCKMAP_LAYER2_MASK; 503 goto again; 504 } 505 KKASSERT(layer1->phys_offset != HAMMER_BLOCKMAP_UNAVAIL); 506 507 /* 508 * Dive layer 2, each entry represents a large-block. 509 */ 510 layer2_offset = layer1->phys_offset + 511 HAMMER_BLOCKMAP_LAYER2_OFFSET(next_offset); 512 layer2 = hammer_bread(hmp, layer2_offset, errorp, &buffer2); 513 if (*errorp) 514 goto failed; 515 516 /* 517 * Check CRC if not allocating into uninitialized space (which we 518 * aren't when reserving space). 519 */ 520 if (layer2->entry_crc != crc32(layer2, HAMMER_LAYER2_CRCSIZE)) { 521 hammer_lock_ex(&hmp->blkmap_lock); 522 if (layer2->entry_crc != crc32(layer2, HAMMER_LAYER2_CRCSIZE)) 523 panic("CRC FAILED: LAYER2"); 524 hammer_unlock(&hmp->blkmap_lock); 525 } 526 527 /* 528 * Skip the layer if the zone is owned by someone other then us. 529 */ 530 if (layer2->zone && layer2->zone != zone) { 531 next_offset += (HAMMER_LARGEBLOCK_SIZE - offset); 532 goto again; 533 } 534 if (offset < layer2->append_off) { 535 next_offset += layer2->append_off - offset; 536 goto again; 537 } 538 539 /* 540 * We need the lock from this point on. We have to re-check zone 541 * ownership after acquiring the lock and also check for reservations. 542 */ 543 hammer_lock_ex(&hmp->blkmap_lock); 544 545 if (layer2->zone && layer2->zone != zone) { 546 hammer_unlock(&hmp->blkmap_lock); 547 next_offset += (HAMMER_LARGEBLOCK_SIZE - offset); 548 goto again; 549 } 550 if (offset < layer2->append_off) { 551 hammer_unlock(&hmp->blkmap_lock); 552 next_offset += layer2->append_off - offset; 553 goto again; 554 } 555 556 /* 557 * The bigblock might be reserved by another zone. If it is reserved 558 * by our zone we may have to move next_offset past the append_off. 559 */ 560 base_off = (next_offset & 561 (~HAMMER_LARGEBLOCK_MASK64 & ~HAMMER_OFF_ZONE_MASK)) | 562 HAMMER_ZONE_RAW_BUFFER; 563 resv = RB_LOOKUP(hammer_res_rb_tree, &hmp->rb_resv_root, base_off); 564 if (resv) { 565 if (resv->zone != zone) { 566 hammer_unlock(&hmp->blkmap_lock); 567 next_offset = (next_offset + HAMMER_LARGEBLOCK_SIZE) & 568 ~HAMMER_LARGEBLOCK_MASK64; 569 goto again; 570 } 571 if (offset < resv->append_off) { 572 hammer_unlock(&hmp->blkmap_lock); 573 next_offset += resv->append_off - offset; 574 goto again; 575 } 576 ++resv->refs; 577 resx = NULL; 578 } else { 579 resx = kmalloc(sizeof(*resv), hmp->m_misc, 580 M_WAITOK | M_ZERO | M_USE_RESERVE); 581 resx->refs = 1; 582 resx->zone = zone; 583 resx->zone_offset = base_off; 584 if (layer2->bytes_free == HAMMER_LARGEBLOCK_SIZE) 585 resx->flags |= HAMMER_RESF_LAYER2FREE; 586 resv = RB_INSERT(hammer_res_rb_tree, &hmp->rb_resv_root, resx); 587 KKASSERT(resv == NULL); 588 resv = resx; 589 ++hammer_count_reservations; 590 } 591 resv->append_off = offset + bytes; 592 593 /* 594 * If we are not reserving a whole buffer but are at the start of 595 * a new block, call hammer_bnew() to avoid a disk read. 596 * 597 * If we are reserving a whole buffer (or more), the caller will 598 * probably use a direct read, so do nothing. 599 */ 600 if (bytes < HAMMER_BUFSIZE && (next_offset & HAMMER_BUFMASK) == 0) { 601 hammer_bnew(hmp, next_offset, errorp, &buffer3); 602 } 603 604 /* 605 * Adjust our iterator and alloc_offset. The layer1 and layer2 606 * space beyond alloc_offset is uninitialized. alloc_offset must 607 * be big-block aligned. 608 */ 609 blockmap->next_offset = next_offset + bytes; 610 hammer_unlock(&hmp->blkmap_lock); 611 612 failed: 613 if (buffer1) 614 hammer_rel_buffer(buffer1, 0); 615 if (buffer2) 616 hammer_rel_buffer(buffer2, 0); 617 if (buffer3) 618 hammer_rel_buffer(buffer3, 0); 619 hammer_rel_volume(root_volume, 0); 620 *zone_offp = next_offset; 621 622 return(resv); 623 } 624 625 /* 626 * Dereference a reservation structure. Upon the final release the 627 * underlying big-block is checked and if it is entirely free we delete 628 * any related HAMMER buffers to avoid potential conflicts with future 629 * reuse of the big-block. 630 */ 631 void 632 hammer_blockmap_reserve_complete(hammer_mount_t hmp, hammer_reserve_t resv) 633 { 634 hammer_off_t base_offset; 635 int error; 636 637 KKASSERT(resv->refs > 0); 638 KKASSERT((resv->zone_offset & HAMMER_OFF_ZONE_MASK) == 639 HAMMER_ZONE_RAW_BUFFER); 640 641 /* 642 * Setting append_off to the max prevents any new allocations 643 * from occuring while we are trying to dispose of the reservation, 644 * allowing us to safely delete any related HAMMER buffers. 645 * 646 * If we are unable to clean out all related HAMMER buffers we 647 * requeue the delay. 648 */ 649 if (resv->refs == 1 && (resv->flags & HAMMER_RESF_LAYER2FREE)) { 650 resv->append_off = HAMMER_LARGEBLOCK_SIZE; 651 base_offset = resv->zone_offset & ~HAMMER_OFF_ZONE_MASK; 652 base_offset = HAMMER_ZONE_ENCODE(resv->zone, base_offset); 653 error = hammer_del_buffers(hmp, base_offset, 654 resv->zone_offset, 655 HAMMER_LARGEBLOCK_SIZE, 656 0); 657 if (error) 658 hammer_reserve_setdelay(hmp, resv); 659 } 660 if (--resv->refs == 0) { 661 KKASSERT((resv->flags & HAMMER_RESF_ONDELAY) == 0); 662 RB_REMOVE(hammer_res_rb_tree, &hmp->rb_resv_root, resv); 663 kfree(resv, hmp->m_misc); 664 --hammer_count_reservations; 665 } 666 } 667 668 /* 669 * Prevent a potentially free big-block from being reused until after 670 * the related flushes have completely cycled, otherwise crash recovery 671 * could resurrect a data block that was already reused and overwritten. 672 * 673 * The caller might reset the underlying layer2 entry's append_off to 0, so 674 * our covering append_off must be set to max to prevent any reallocation 675 * until after the flush delays complete, not to mention proper invalidation 676 * of any underlying cached blocks. 677 */ 678 static void 679 hammer_reserve_setdelay_offset(hammer_mount_t hmp, hammer_off_t base_offset, 680 int zone, struct hammer_blockmap_layer2 *layer2) 681 { 682 hammer_reserve_t resv; 683 684 /* 685 * Allocate the reservation if necessary. 686 * 687 * NOTE: need lock in future around resv lookup/allocation and 688 * the setdelay call, currently refs is not bumped until the call. 689 */ 690 again: 691 resv = RB_LOOKUP(hammer_res_rb_tree, &hmp->rb_resv_root, base_offset); 692 if (resv == NULL) { 693 resv = kmalloc(sizeof(*resv), hmp->m_misc, 694 M_WAITOK | M_ZERO | M_USE_RESERVE); 695 resv->zone = zone; 696 resv->zone_offset = base_offset; 697 resv->refs = 0; 698 resv->append_off = HAMMER_LARGEBLOCK_SIZE; 699 700 if (layer2->bytes_free == HAMMER_LARGEBLOCK_SIZE) 701 resv->flags |= HAMMER_RESF_LAYER2FREE; 702 if (RB_INSERT(hammer_res_rb_tree, &hmp->rb_resv_root, resv)) { 703 kfree(resv, hmp->m_misc); 704 goto again; 705 } 706 ++hammer_count_reservations; 707 } else { 708 if (layer2->bytes_free == HAMMER_LARGEBLOCK_SIZE) 709 resv->flags |= HAMMER_RESF_LAYER2FREE; 710 } 711 hammer_reserve_setdelay(hmp, resv); 712 } 713 714 /* 715 * Enter the reservation on the on-delay list, or move it if it 716 * is already on the list. 717 */ 718 static void 719 hammer_reserve_setdelay(hammer_mount_t hmp, hammer_reserve_t resv) 720 { 721 if (resv->flags & HAMMER_RESF_ONDELAY) { 722 TAILQ_REMOVE(&hmp->delay_list, resv, delay_entry); 723 resv->flush_group = hmp->flusher.next + 1; 724 TAILQ_INSERT_TAIL(&hmp->delay_list, resv, delay_entry); 725 } else { 726 ++resv->refs; 727 ++hmp->rsv_fromdelay; 728 resv->flags |= HAMMER_RESF_ONDELAY; 729 resv->flush_group = hmp->flusher.next + 1; 730 TAILQ_INSERT_TAIL(&hmp->delay_list, resv, delay_entry); 731 } 732 } 733 734 void 735 hammer_reserve_clrdelay(hammer_mount_t hmp, hammer_reserve_t resv) 736 { 737 KKASSERT(resv->flags & HAMMER_RESF_ONDELAY); 738 resv->flags &= ~HAMMER_RESF_ONDELAY; 739 TAILQ_REMOVE(&hmp->delay_list, resv, delay_entry); 740 --hmp->rsv_fromdelay; 741 hammer_blockmap_reserve_complete(hmp, resv); 742 } 743 744 /* 745 * Backend function - free (offset, bytes) in a zone. 746 * 747 * XXX error return 748 */ 749 void 750 hammer_blockmap_free(hammer_transaction_t trans, 751 hammer_off_t zone_offset, int bytes) 752 { 753 hammer_mount_t hmp; 754 hammer_volume_t root_volume; 755 hammer_blockmap_t blockmap; 756 hammer_blockmap_t freemap; 757 struct hammer_blockmap_layer1 *layer1; 758 struct hammer_blockmap_layer2 *layer2; 759 hammer_buffer_t buffer1 = NULL; 760 hammer_buffer_t buffer2 = NULL; 761 hammer_off_t layer1_offset; 762 hammer_off_t layer2_offset; 763 hammer_off_t base_off; 764 int error; 765 int zone; 766 767 if (bytes == 0) 768 return; 769 hmp = trans->hmp; 770 771 /* 772 * Alignment 773 */ 774 bytes = (bytes + 15) & ~15; 775 KKASSERT(bytes <= HAMMER_XBUFSIZE); 776 KKASSERT(((zone_offset ^ (zone_offset + (bytes - 1))) & 777 ~HAMMER_LARGEBLOCK_MASK64) == 0); 778 779 /* 780 * Basic zone validation & locking 781 */ 782 zone = HAMMER_ZONE_DECODE(zone_offset); 783 KKASSERT(zone >= HAMMER_ZONE_BTREE_INDEX && zone < HAMMER_MAX_ZONES); 784 root_volume = trans->rootvol; 785 error = 0; 786 787 blockmap = &hmp->blockmap[zone]; 788 freemap = &hmp->blockmap[HAMMER_ZONE_FREEMAP_INDEX]; 789 790 /* 791 * Dive layer 1. 792 */ 793 layer1_offset = freemap->phys_offset + 794 HAMMER_BLOCKMAP_LAYER1_OFFSET(zone_offset); 795 layer1 = hammer_bread(hmp, layer1_offset, &error, &buffer1); 796 if (error) 797 goto failed; 798 KKASSERT(layer1->phys_offset && 799 layer1->phys_offset != HAMMER_BLOCKMAP_UNAVAIL); 800 if (layer1->layer1_crc != crc32(layer1, HAMMER_LAYER1_CRCSIZE)) { 801 hammer_lock_ex(&hmp->blkmap_lock); 802 if (layer1->layer1_crc != crc32(layer1, HAMMER_LAYER1_CRCSIZE)) 803 panic("CRC FAILED: LAYER1"); 804 hammer_unlock(&hmp->blkmap_lock); 805 } 806 807 /* 808 * Dive layer 2, each entry represents a large-block. 809 */ 810 layer2_offset = layer1->phys_offset + 811 HAMMER_BLOCKMAP_LAYER2_OFFSET(zone_offset); 812 layer2 = hammer_bread(hmp, layer2_offset, &error, &buffer2); 813 if (error) 814 goto failed; 815 if (layer2->entry_crc != crc32(layer2, HAMMER_LAYER2_CRCSIZE)) { 816 hammer_lock_ex(&hmp->blkmap_lock); 817 if (layer2->entry_crc != crc32(layer2, HAMMER_LAYER2_CRCSIZE)) 818 panic("CRC FAILED: LAYER2"); 819 hammer_unlock(&hmp->blkmap_lock); 820 } 821 822 hammer_lock_ex(&hmp->blkmap_lock); 823 824 hammer_modify_buffer(trans, buffer2, layer2, sizeof(*layer2)); 825 826 /* 827 * Free space previously allocated via blockmap_alloc(). 828 */ 829 KKASSERT(layer2->zone == zone); 830 layer2->bytes_free += bytes; 831 KKASSERT(layer2->bytes_free <= HAMMER_LARGEBLOCK_SIZE); 832 833 /* 834 * If a big-block becomes entirely free we must create a covering 835 * reservation to prevent premature reuse. Note, however, that 836 * the big-block and/or reservation may still have an append_off 837 * that allows further (non-reused) allocations. 838 * 839 * Once the reservation has been made we re-check layer2 and if 840 * the big-block is still entirely free we reset the layer2 entry. 841 * The reservation will prevent premature reuse. 842 * 843 * NOTE: hammer_buffer's are only invalidated when the reservation 844 * is completed, if the layer2 entry is still completely free at 845 * that time. Any allocations from the reservation that may have 846 * occured in the mean time, or active references on the reservation 847 * from new pending allocations, will prevent the invalidation from 848 * occuring. 849 */ 850 if (layer2->bytes_free == HAMMER_LARGEBLOCK_SIZE) { 851 base_off = (zone_offset & (~HAMMER_LARGEBLOCK_MASK64 & ~HAMMER_OFF_ZONE_MASK)) | HAMMER_ZONE_RAW_BUFFER; 852 853 hammer_reserve_setdelay_offset(hmp, base_off, zone, layer2); 854 if (layer2->bytes_free == HAMMER_LARGEBLOCK_SIZE) { 855 layer2->zone = 0; 856 layer2->append_off = 0; 857 hammer_modify_buffer(trans, buffer1, 858 layer1, sizeof(*layer1)); 859 ++layer1->blocks_free; 860 layer1->layer1_crc = crc32(layer1, 861 HAMMER_LAYER1_CRCSIZE); 862 hammer_modify_buffer_done(buffer1); 863 hammer_modify_volume_field(trans, 864 trans->rootvol, 865 vol0_stat_freebigblocks); 866 ++root_volume->ondisk->vol0_stat_freebigblocks; 867 hmp->copy_stat_freebigblocks = 868 root_volume->ondisk->vol0_stat_freebigblocks; 869 hammer_modify_volume_done(trans->rootvol); 870 } 871 } 872 layer2->entry_crc = crc32(layer2, HAMMER_LAYER2_CRCSIZE); 873 hammer_modify_buffer_done(buffer2); 874 hammer_unlock(&hmp->blkmap_lock); 875 876 failed: 877 if (buffer1) 878 hammer_rel_buffer(buffer1, 0); 879 if (buffer2) 880 hammer_rel_buffer(buffer2, 0); 881 } 882 883 /* 884 * Backend function - finalize (offset, bytes) in a zone. 885 * 886 * Allocate space that was previously reserved by the frontend. 887 */ 888 int 889 hammer_blockmap_finalize(hammer_transaction_t trans, 890 hammer_reserve_t resv, 891 hammer_off_t zone_offset, int bytes) 892 { 893 hammer_mount_t hmp; 894 hammer_volume_t root_volume; 895 hammer_blockmap_t blockmap; 896 hammer_blockmap_t freemap; 897 struct hammer_blockmap_layer1 *layer1; 898 struct hammer_blockmap_layer2 *layer2; 899 hammer_buffer_t buffer1 = NULL; 900 hammer_buffer_t buffer2 = NULL; 901 hammer_off_t layer1_offset; 902 hammer_off_t layer2_offset; 903 int error; 904 int zone; 905 int offset; 906 907 if (bytes == 0) 908 return(0); 909 hmp = trans->hmp; 910 911 /* 912 * Alignment 913 */ 914 bytes = (bytes + 15) & ~15; 915 KKASSERT(bytes <= HAMMER_XBUFSIZE); 916 917 /* 918 * Basic zone validation & locking 919 */ 920 zone = HAMMER_ZONE_DECODE(zone_offset); 921 KKASSERT(zone >= HAMMER_ZONE_BTREE_INDEX && zone < HAMMER_MAX_ZONES); 922 root_volume = trans->rootvol; 923 error = 0; 924 925 blockmap = &hmp->blockmap[zone]; 926 freemap = &hmp->blockmap[HAMMER_ZONE_FREEMAP_INDEX]; 927 928 /* 929 * Dive layer 1. 930 */ 931 layer1_offset = freemap->phys_offset + 932 HAMMER_BLOCKMAP_LAYER1_OFFSET(zone_offset); 933 layer1 = hammer_bread(hmp, layer1_offset, &error, &buffer1); 934 if (error) 935 goto failed; 936 KKASSERT(layer1->phys_offset && 937 layer1->phys_offset != HAMMER_BLOCKMAP_UNAVAIL); 938 if (layer1->layer1_crc != crc32(layer1, HAMMER_LAYER1_CRCSIZE)) { 939 hammer_lock_ex(&hmp->blkmap_lock); 940 if (layer1->layer1_crc != crc32(layer1, HAMMER_LAYER1_CRCSIZE)) 941 panic("CRC FAILED: LAYER1"); 942 hammer_unlock(&hmp->blkmap_lock); 943 } 944 945 /* 946 * Dive layer 2, each entry represents a large-block. 947 */ 948 layer2_offset = layer1->phys_offset + 949 HAMMER_BLOCKMAP_LAYER2_OFFSET(zone_offset); 950 layer2 = hammer_bread(hmp, layer2_offset, &error, &buffer2); 951 if (error) 952 goto failed; 953 if (layer2->entry_crc != crc32(layer2, HAMMER_LAYER2_CRCSIZE)) { 954 hammer_lock_ex(&hmp->blkmap_lock); 955 if (layer2->entry_crc != crc32(layer2, HAMMER_LAYER2_CRCSIZE)) 956 panic("CRC FAILED: LAYER2"); 957 hammer_unlock(&hmp->blkmap_lock); 958 } 959 960 hammer_lock_ex(&hmp->blkmap_lock); 961 962 hammer_modify_buffer(trans, buffer2, layer2, sizeof(*layer2)); 963 964 /* 965 * Finalize some or all of the space covered by a current 966 * reservation. An allocation in the same layer may have 967 * already assigned ownership. 968 */ 969 if (layer2->zone == 0) { 970 hammer_modify_buffer(trans, buffer1, 971 layer1, sizeof(*layer1)); 972 --layer1->blocks_free; 973 layer1->layer1_crc = crc32(layer1, 974 HAMMER_LAYER1_CRCSIZE); 975 hammer_modify_buffer_done(buffer1); 976 layer2->zone = zone; 977 KKASSERT(layer2->bytes_free == HAMMER_LARGEBLOCK_SIZE); 978 KKASSERT(layer2->append_off == 0); 979 hammer_modify_volume_field(trans, 980 trans->rootvol, 981 vol0_stat_freebigblocks); 982 --root_volume->ondisk->vol0_stat_freebigblocks; 983 hmp->copy_stat_freebigblocks = 984 root_volume->ondisk->vol0_stat_freebigblocks; 985 hammer_modify_volume_done(trans->rootvol); 986 } 987 if (layer2->zone != zone) 988 kprintf("layer2 zone mismatch %d %d\n", layer2->zone, zone); 989 KKASSERT(layer2->zone == zone); 990 KKASSERT(bytes != 0); 991 layer2->bytes_free -= bytes; 992 if (resv) 993 resv->flags &= ~HAMMER_RESF_LAYER2FREE; 994 995 /* 996 * Finalizations can occur out of order, or combined with allocations. 997 * append_off must be set to the highest allocated offset. 998 */ 999 offset = ((int)zone_offset & HAMMER_LARGEBLOCK_MASK) + bytes; 1000 if (layer2->append_off < offset) 1001 layer2->append_off = offset; 1002 1003 layer2->entry_crc = crc32(layer2, HAMMER_LAYER2_CRCSIZE); 1004 hammer_modify_buffer_done(buffer2); 1005 hammer_unlock(&hmp->blkmap_lock); 1006 1007 failed: 1008 if (buffer1) 1009 hammer_rel_buffer(buffer1, 0); 1010 if (buffer2) 1011 hammer_rel_buffer(buffer2, 0); 1012 return(error); 1013 } 1014 1015 /* 1016 * Return the number of free bytes in the big-block containing the 1017 * specified blockmap offset. 1018 */ 1019 int 1020 hammer_blockmap_getfree(hammer_mount_t hmp, hammer_off_t zone_offset, 1021 int *curp, int *errorp) 1022 { 1023 hammer_volume_t root_volume; 1024 hammer_blockmap_t blockmap; 1025 hammer_blockmap_t freemap; 1026 struct hammer_blockmap_layer1 *layer1; 1027 struct hammer_blockmap_layer2 *layer2; 1028 hammer_buffer_t buffer = NULL; 1029 hammer_off_t layer1_offset; 1030 hammer_off_t layer2_offset; 1031 int bytes; 1032 int zone; 1033 1034 zone = HAMMER_ZONE_DECODE(zone_offset); 1035 KKASSERT(zone >= HAMMER_ZONE_BTREE_INDEX && zone < HAMMER_MAX_ZONES); 1036 root_volume = hammer_get_root_volume(hmp, errorp); 1037 if (*errorp) { 1038 *curp = 0; 1039 return(0); 1040 } 1041 blockmap = &hmp->blockmap[zone]; 1042 freemap = &hmp->blockmap[HAMMER_ZONE_FREEMAP_INDEX]; 1043 1044 /* 1045 * Dive layer 1. 1046 */ 1047 layer1_offset = freemap->phys_offset + 1048 HAMMER_BLOCKMAP_LAYER1_OFFSET(zone_offset); 1049 layer1 = hammer_bread(hmp, layer1_offset, errorp, &buffer); 1050 if (*errorp) { 1051 bytes = 0; 1052 goto failed; 1053 } 1054 KKASSERT(layer1->phys_offset); 1055 if (layer1->layer1_crc != crc32(layer1, HAMMER_LAYER1_CRCSIZE)) { 1056 hammer_lock_ex(&hmp->blkmap_lock); 1057 if (layer1->layer1_crc != crc32(layer1, HAMMER_LAYER1_CRCSIZE)) 1058 panic("CRC FAILED: LAYER1"); 1059 hammer_unlock(&hmp->blkmap_lock); 1060 } 1061 1062 /* 1063 * Dive layer 2, each entry represents a large-block. 1064 * 1065 * (reuse buffer, layer1 pointer becomes invalid) 1066 */ 1067 layer2_offset = layer1->phys_offset + 1068 HAMMER_BLOCKMAP_LAYER2_OFFSET(zone_offset); 1069 layer2 = hammer_bread(hmp, layer2_offset, errorp, &buffer); 1070 if (*errorp) { 1071 bytes = 0; 1072 goto failed; 1073 } 1074 if (layer2->entry_crc != crc32(layer2, HAMMER_LAYER2_CRCSIZE)) { 1075 hammer_lock_ex(&hmp->blkmap_lock); 1076 if (layer2->entry_crc != crc32(layer2, HAMMER_LAYER2_CRCSIZE)) 1077 panic("CRC FAILED: LAYER2"); 1078 hammer_unlock(&hmp->blkmap_lock); 1079 } 1080 KKASSERT(layer2->zone == zone); 1081 1082 bytes = layer2->bytes_free; 1083 1084 if ((blockmap->next_offset ^ zone_offset) & ~HAMMER_LARGEBLOCK_MASK64) 1085 *curp = 0; 1086 else 1087 *curp = 1; 1088 failed: 1089 if (buffer) 1090 hammer_rel_buffer(buffer, 0); 1091 hammer_rel_volume(root_volume, 0); 1092 if (hammer_debug_general & 0x0800) { 1093 kprintf("hammer_blockmap_getfree: %016llx -> %d\n", 1094 (long long)zone_offset, bytes); 1095 } 1096 return(bytes); 1097 } 1098 1099 1100 /* 1101 * Lookup a blockmap offset. 1102 */ 1103 hammer_off_t 1104 hammer_blockmap_lookup(hammer_mount_t hmp, hammer_off_t zone_offset, 1105 int *errorp) 1106 { 1107 hammer_volume_t root_volume; 1108 hammer_blockmap_t freemap; 1109 struct hammer_blockmap_layer1 *layer1; 1110 struct hammer_blockmap_layer2 *layer2; 1111 hammer_buffer_t buffer = NULL; 1112 hammer_off_t layer1_offset; 1113 hammer_off_t layer2_offset; 1114 hammer_off_t result_offset; 1115 hammer_off_t base_off; 1116 hammer_reserve_t resv; 1117 int zone; 1118 1119 /* 1120 * Calculate the zone-2 offset. 1121 */ 1122 zone = HAMMER_ZONE_DECODE(zone_offset); 1123 KKASSERT(zone >= HAMMER_ZONE_BTREE_INDEX && zone < HAMMER_MAX_ZONES); 1124 1125 result_offset = (zone_offset & ~HAMMER_OFF_ZONE_MASK) | 1126 HAMMER_ZONE_RAW_BUFFER; 1127 1128 /* 1129 * We can actually stop here, normal blockmaps are now direct-mapped 1130 * onto the freemap and so represent zone-2 addresses. 1131 */ 1132 if (hammer_verify_zone == 0) { 1133 *errorp = 0; 1134 return(result_offset); 1135 } 1136 1137 /* 1138 * Validate the allocation zone 1139 */ 1140 root_volume = hammer_get_root_volume(hmp, errorp); 1141 if (*errorp) 1142 return(0); 1143 freemap = &hmp->blockmap[HAMMER_ZONE_FREEMAP_INDEX]; 1144 KKASSERT(freemap->phys_offset != 0); 1145 1146 /* 1147 * Dive layer 1. 1148 */ 1149 layer1_offset = freemap->phys_offset + 1150 HAMMER_BLOCKMAP_LAYER1_OFFSET(zone_offset); 1151 layer1 = hammer_bread(hmp, layer1_offset, errorp, &buffer); 1152 if (*errorp) 1153 goto failed; 1154 KKASSERT(layer1->phys_offset != HAMMER_BLOCKMAP_UNAVAIL); 1155 if (layer1->layer1_crc != crc32(layer1, HAMMER_LAYER1_CRCSIZE)) { 1156 hammer_lock_ex(&hmp->blkmap_lock); 1157 if (layer1->layer1_crc != crc32(layer1, HAMMER_LAYER1_CRCSIZE)) 1158 panic("CRC FAILED: LAYER1"); 1159 hammer_unlock(&hmp->blkmap_lock); 1160 } 1161 1162 /* 1163 * Dive layer 2, each entry represents a large-block. 1164 */ 1165 layer2_offset = layer1->phys_offset + 1166 HAMMER_BLOCKMAP_LAYER2_OFFSET(zone_offset); 1167 layer2 = hammer_bread(hmp, layer2_offset, errorp, &buffer); 1168 1169 if (*errorp) 1170 goto failed; 1171 if (layer2->zone == 0) { 1172 base_off = (zone_offset & (~HAMMER_LARGEBLOCK_MASK64 & ~HAMMER_OFF_ZONE_MASK)) | HAMMER_ZONE_RAW_BUFFER; 1173 resv = RB_LOOKUP(hammer_res_rb_tree, &hmp->rb_resv_root, 1174 base_off); 1175 KKASSERT(resv && resv->zone == zone); 1176 1177 } else if (layer2->zone != zone) { 1178 panic("hammer_blockmap_lookup: bad zone %d/%d\n", 1179 layer2->zone, zone); 1180 } 1181 if (layer2->entry_crc != crc32(layer2, HAMMER_LAYER2_CRCSIZE)) { 1182 hammer_lock_ex(&hmp->blkmap_lock); 1183 if (layer2->entry_crc != crc32(layer2, HAMMER_LAYER2_CRCSIZE)) 1184 panic("CRC FAILED: LAYER2"); 1185 hammer_unlock(&hmp->blkmap_lock); 1186 } 1187 1188 failed: 1189 if (buffer) 1190 hammer_rel_buffer(buffer, 0); 1191 hammer_rel_volume(root_volume, 0); 1192 if (hammer_debug_general & 0x0800) { 1193 kprintf("hammer_blockmap_lookup: %016llx -> %016llx\n", 1194 (long long)zone_offset, (long long)result_offset); 1195 } 1196 return(result_offset); 1197 } 1198 1199 1200 /* 1201 * Check space availability 1202 */ 1203 int 1204 _hammer_checkspace(hammer_mount_t hmp, int slop, int64_t *resp) 1205 { 1206 const int in_size = sizeof(struct hammer_inode_data) + 1207 sizeof(union hammer_btree_elm); 1208 const int rec_size = (sizeof(union hammer_btree_elm) * 2); 1209 int64_t usedbytes; 1210 1211 usedbytes = hmp->rsv_inodes * in_size + 1212 hmp->rsv_recs * rec_size + 1213 hmp->rsv_databytes + 1214 ((int64_t)hmp->rsv_fromdelay << HAMMER_LARGEBLOCK_BITS) + 1215 ((int64_t)hidirtybufspace << 2) + 1216 (slop << HAMMER_LARGEBLOCK_BITS); 1217 1218 hammer_count_extra_space_used = usedbytes; /* debugging */ 1219 if (resp) 1220 *resp = usedbytes; 1221 1222 if (hmp->copy_stat_freebigblocks >= 1223 (usedbytes >> HAMMER_LARGEBLOCK_BITS)) { 1224 return(0); 1225 } 1226 return (ENOSPC); 1227 } 1228 1229