sys/vfs/hammer/hammer_blockmap.c

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