sys/vfs/hammer/hammer_volume.c

   1 /*
   2  * Copyright (c) 2009 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> and
   6  * Michael Neumann <mneumann@ntecs.de>
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  *
  12  * 1. Redistributions of source code must retain the above copyright
  13  *    notice, this list of conditions and the following disclaimer.
  14  * 2. Redistributions in binary form must reproduce the above copyright
  15  *    notice, this list of conditions and the following disclaimer in
  16  *    the documentation and/or other materials provided with the
  17  *    distribution.
  18  * 3. Neither the name of The DragonFly Project nor the names of its
  19  *    contributors may be used to endorse or promote products derived
  20  *    from this software without specific, prior written permission.
  21  *
  22  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  23  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  24  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  25  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE
  26  * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  27  * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
  28  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  29  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
  30  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  31  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  32  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  33  * SUCH DAMAGE.
  34  *
  35  */
  36
  37 #include "hammer.h"
  38
  39 static int
  40 hammer_format_volume_header(hammer_mount_t hmp,
  41         struct hammer_ioc_volume *ioc,
  42         hammer_volume_ondisk_t ondisk,
  43         int vol_no);
  44
  45 static int
  46 hammer_update_volumes_header(hammer_transaction_t trans,
  47         int64_t total_bigblocks, int64_t empty_bigblocks);
  48
  49 static int
  50 hammer_do_reblock(hammer_transaction_t trans, hammer_inode_t ip);
  51
  52 static int
  53 hammer_format_freemap(hammer_transaction_t trans, hammer_volume_t volume);
  54
  55 static int
  56 hammer_free_freemap(hammer_transaction_t trans, hammer_volume_t volume);
  57
  58 static int
  59 hammer_count_bigblocks(hammer_mount_t hmp, hammer_volume_t volume,
  60         int64_t *total_bigblocks, int64_t *empty_bigblocks);
  61
  62 int
  63 hammer_ioc_volume_add(hammer_transaction_t trans, hammer_inode_t ip,
  64                 struct hammer_ioc_volume *ioc)
  65 {
  66         hammer_mount_t hmp = trans->hmp;
  67         struct mount *mp = hmp->mp;
  68         struct hammer_volume_ondisk ondisk;
  69         hammer_volume_t volume;
  70         int64_t total_bigblocks, empty_bigblocks;
  71         int free_vol_no = 0;
  72         int error;
  73
  74         if (mp->mnt_flag & MNT_RDONLY) {
  75                 hmkprintf(hmp, "Cannot add volume to read-only HAMMER filesystem\n");
  76                 return (EINVAL);
  77         }
  78
  79         if (hammer_lock_ex_try(&hmp->volume_lock) != 0) {
  80                 hmkprintf(hmp, "Another volume operation is in progress!\n");
  81                 return (EAGAIN);
  82         }
  83
  84         if (hmp->nvolumes >= HAMMER_MAX_VOLUMES) {
  85                 hammer_unlock(&hmp->volume_lock);
  86                 hmkprintf(hmp, "Max number of HAMMER volumes exceeded\n");
  87                 return (EINVAL);
  88         }
  89
  90         /*
  91          * Find an unused volume number.
  92          */
  93         while (free_vol_no < HAMMER_MAX_VOLUMES &&
  94                 hammer_volume_number_test(hmp, free_vol_no)) {
  95                 ++free_vol_no;
  96         }
  97         if (free_vol_no >= HAMMER_MAX_VOLUMES) {
  98                 hmkprintf(hmp, "Max number of HAMMER volumes exceeded\n");
  99                 error = EINVAL;
 100                 goto end;
 101         }
 102
 103         error = hammer_format_volume_header(hmp, ioc, &ondisk, free_vol_no);
 104         if (error)
 105                 goto end;
 106
 107         error = hammer_install_volume(hmp, ioc->device_name, NULL, &ondisk);
 108         if (error)
 109                 goto end;
 110
 111         hammer_sync_lock_sh(trans);
 112         hammer_lock_ex(&hmp->blkmap_lock);
 113
 114         volume = hammer_get_volume(hmp, free_vol_no, &error);
 115         KKASSERT(volume != NULL && error == 0);
 116
 117         error = hammer_format_freemap(trans, volume);
 118         KKASSERT(error == 0);
 119
 120         error = hammer_count_bigblocks(hmp, volume,
 121                         &total_bigblocks, &empty_bigblocks);
 122         KKASSERT(error == 0);
 123         KKASSERT(total_bigblocks == empty_bigblocks);
 124
 125         hammer_rel_volume(volume, 0);
 126
 127         ++hmp->nvolumes;
 128         error = hammer_update_volumes_header(trans,
 129                         total_bigblocks, empty_bigblocks);
 130         KKASSERT(error == 0);
 131
 132         hammer_unlock(&hmp->blkmap_lock);
 133         hammer_sync_unlock(trans);
 134
 135         KKASSERT(error == 0);
 136 end:
 137         hammer_unlock(&hmp->volume_lock);
 138         if (error)
 139                 hmkprintf(hmp, "An error occurred: %d\n", error);
 140         return (error);
 141 }
 142
 143
 144 /*
 145  * Remove a volume.
 146  */
 147 int
 148 hammer_ioc_volume_del(hammer_transaction_t trans, hammer_inode_t ip,
 149                 struct hammer_ioc_volume *ioc)
 150 {
 151         hammer_mount_t hmp = trans->hmp;
 152         struct mount *mp = hmp->mp;
 153         struct hammer_volume_ondisk ondisk;
 154         hammer_volume_t volume;
 155         int64_t total_bigblocks, empty_bigblocks;
 156         int vol_no;
 157         int error = 0;
 158
 159         if (mp->mnt_flag & MNT_RDONLY) {
 160                 hmkprintf(hmp, "Cannot del volume from read-only HAMMER filesystem\n");
 161                 return (EINVAL);
 162         }
 163
 164         if (hammer_lock_ex_try(&hmp->volume_lock) != 0) {
 165                 hmkprintf(hmp, "Another volume operation is in progress!\n");
 166                 return (EAGAIN);
 167         }
 168
 169         if (hmp->nvolumes <= 1) {
 170                 hammer_unlock(&hmp->volume_lock);
 171                 hmkprintf(hmp, "No HAMMER volume to delete\n");
 172                 return (EINVAL);
 173         }
 174
 175         /*
 176          * find volume by volname
 177          */
 178         volume = NULL;
 179         HAMMER_VOLUME_NUMBER_FOREACH(hmp, vol_no) {
 180                 volume = hammer_get_volume(hmp, vol_no, &error);
 181                 KKASSERT(volume != NULL && error == 0);
 182                 if (strcmp(volume->vol_name, ioc->device_name) == 0) {
 183                         break;
 184                 }
 185                 hammer_rel_volume(volume, 0);
 186                 volume = NULL;
 187         }
 188
 189         if (volume == NULL) {
 190                 hmkprintf(hmp, "Couldn't find volume\n");
 191                 error = EINVAL;
 192                 goto end;
 193         }
 194
 195         if (volume == trans->rootvol) {
 196                 hmkprintf(hmp, "Cannot remove root-volume\n");
 197                 hammer_rel_volume(volume, 0);
 198                 error = EINVAL;
 199                 goto end;
 200         }
 201
 202         /*
 203          * Reblock filesystem if the volume is not empty
 204          */
 205         hmp->volume_to_remove = volume->vol_no;
 206
 207         error = hammer_count_bigblocks(hmp, volume,
 208                         &total_bigblocks, &empty_bigblocks);
 209         KKASSERT(error == 0);
 210
 211         if (total_bigblocks == empty_bigblocks) {
 212                 hmkprintf(hmp, "%s is already empty\n", volume->vol_name);
 213         } else if (ioc->flag & HAMMER_IOC_VOLUME_REBLOCK) {
 214                 error = hammer_do_reblock(trans, ip);
 215                 if (error) {
 216                         hmp->volume_to_remove = -1;
 217                         hammer_rel_volume(volume, 0);
 218                         goto end;
 219                 }
 220         } else {
 221                 hmkprintf(hmp, "%s is not empty\n", volume->vol_name);
 222                 hammer_rel_volume(volume, 0);
 223                 error = ENOTEMPTY;
 224                 goto end;
 225         }
 226
 227         hammer_sync_lock_sh(trans);
 228         hammer_lock_ex(&hmp->blkmap_lock);
 229
 230         error = hammer_count_bigblocks(hmp, volume,
 231                         &total_bigblocks, &empty_bigblocks);
 232         KKASSERT(error == 0);
 233
 234         error = hammer_free_freemap(trans, volume);
 235         if (error) {
 236                 hmkprintf(hmp, "Failed to free volume: ");
 237                 if (error == EBUSY)
 238                         kprintf("Volume %d not empty\n", volume->vol_no);
 239                 else
 240                         kprintf("%d\n", error);
 241                 hmp->volume_to_remove = -1;
 242                 hammer_rel_volume(volume, 0);
 243                 goto end1;
 244         }
 245         hammer_rel_volume(volume, 0);
 246
 247         /*
 248          * XXX: Temporary solution for
 249          * http://lists.dragonflybsd.org/pipermail/kernel/2015-August/175027.html
 250          */
 251         hammer_unlock(&hmp->blkmap_lock);
 252         hammer_sync_unlock(trans);
 253         hammer_flusher_sync(hmp); /* 1 */
 254         hammer_flusher_sync(hmp); /* 2 */
 255         hammer_flusher_sync(hmp); /* 3 */
 256         hammer_sync_lock_sh(trans);
 257         hammer_lock_ex(&hmp->blkmap_lock);
 258
 259         /*
 260          * Unload buffers
 261          */
 262         RB_SCAN(hammer_buf_rb_tree, &hmp->rb_bufs_root, NULL,
 263                 hammer_unload_buffer, volume);
 264
 265         bzero(&ondisk, sizeof(ondisk));
 266         error = hammer_unload_volume(volume, &ondisk);
 267         if (error == -1) {
 268                 hmkprintf(hmp, "Failed to unload volume\n");
 269                 goto end1;
 270         }
 271
 272         --hmp->nvolumes;
 273         error = hammer_update_volumes_header(trans,
 274                         -total_bigblocks, -empty_bigblocks);
 275         KKASSERT(error == 0);
 276         hmp->volume_to_remove = -1;
 277
 278 end1:
 279         hammer_unlock(&hmp->blkmap_lock);
 280         hammer_sync_unlock(trans);
 281
 282 end:
 283         hammer_unlock(&hmp->volume_lock);
 284         if (error)
 285                 hmkprintf(hmp, "An error occurred: %d\n", error);
 286         return (error);
 287 }
 288
 289
 290 int
 291 hammer_ioc_volume_list(hammer_transaction_t trans, hammer_inode_t ip,
 292     struct hammer_ioc_volume_list *ioc)
 293 {
 294         hammer_mount_t hmp = trans->hmp;
 295         hammer_volume_t volume;
 296         int error = 0;
 297         int i, len, cnt = 0;
 298
 299         if (hammer_lock_ex_try(&hmp->volume_lock) != 0) {
 300                 hmkprintf(hmp, "Another volume operation is in progress!\n");
 301                 return (EAGAIN);
 302         }
 303
 304         HAMMER_VOLUME_NUMBER_FOREACH(hmp, i) {
 305                 if (cnt >= ioc->nvols)
 306                         break;
 307                 volume = hammer_get_volume(hmp, i, &error);
 308                 KKASSERT(volume != NULL && error == 0);
 309
 310                 len = strlen(volume->vol_name) + 1;
 311                 KKASSERT(len <= MAXPATHLEN);
 312
 313                 ioc->vols[cnt].vol_no = volume->vol_no;
 314                 error = copyout(volume->vol_name, ioc->vols[cnt].device_name,
 315                                 len);
 316                 hammer_rel_volume(volume, 0);
 317                 if (error)
 318                         goto end;
 319                 cnt++;
 320         }
 321         ioc->nvols = cnt;
 322
 323 end:
 324         hammer_unlock(&hmp->volume_lock);
 325         return (error);
 326 }
 327
 328 static
 329 int
 330 hammer_do_reblock(hammer_transaction_t trans, hammer_inode_t ip)
 331 {
 332         hammer_mount_t hmp = trans->hmp;
 333         int error;
 334         int vol_no;
 335
 336         struct hammer_ioc_reblock reblock;
 337         bzero(&reblock, sizeof(reblock));
 338
 339         vol_no = trans->hmp->volume_to_remove;
 340         KKASSERT(vol_no != -1);
 341
 342         reblock.key_beg.localization = HAMMER_MIN_LOCALIZATION;
 343         reblock.key_beg.obj_id = HAMMER_MIN_OBJID;
 344         reblock.key_end.localization = HAMMER_MAX_LOCALIZATION;
 345         reblock.key_end.obj_id = HAMMER_MAX_OBJID;
 346         reblock.head.flags = HAMMER_IOC_DO_FLAGS;
 347         reblock.free_level = 0; /* reblock all big-blocks */
 348         reblock.allpfs = 1;     /* reblock all PFS */
 349         reblock.vol_no = vol_no;
 350
 351         hmkprintf(hmp, "reblock started\n");
 352         error = hammer_ioc_reblock(trans, ip, &reblock);
 353
 354         if (reblock.head.flags & HAMMER_IOC_HEAD_INTR) {
 355                 error = EINTR;
 356         }
 357
 358         if (error) {
 359                 if (error == EINTR) {
 360                         hmkprintf(hmp, "reblock was interrupted\n");
 361                 } else {
 362                         hmkprintf(hmp, "reblock failed: %d\n", error);
 363                 }
 364                 return(error);
 365         }
 366
 367         return(0);
 368 }
 369
 370 /*
 371  * XXX This somehow needs to stop doing hammer_modify_buffer() for
 372  * layer2 entries.  In theory adding a large block device could
 373  * blow away UNDO fifo.  The best way is to format layer2 entries
 374  * in userspace without UNDO getting involved before the device is
 375  * safely added to the filesystem.  HAMMER has no interest in what
 376  * has happened to the device before it safely joins the filesystem.
 377  */
 378 static int
 379 hammer_format_freemap(hammer_transaction_t trans, hammer_volume_t volume)
 380 {
 381         hammer_mount_t hmp = trans->hmp;
 382         hammer_volume_ondisk_t ondisk;
 383         hammer_blockmap_t freemap;
 384         hammer_off_t alloc_offset;
 385         hammer_off_t phys_offset;
 386         hammer_off_t block_offset;
 387         hammer_off_t layer1_offset;
 388         hammer_off_t layer2_offset;
 389         hammer_off_t vol_free_end;
 390         hammer_off_t aligned_vol_free_end;
 391         hammer_blockmap_layer1_t layer1;
 392         hammer_blockmap_layer2_t layer2;
 393         hammer_buffer_t buffer1 = NULL;
 394         hammer_buffer_t buffer2 = NULL;
 395         int64_t vol_buf_size;
 396         int64_t layer1_count = 0;
 397         int error = 0;
 398
 399         KKASSERT(volume->vol_no != HAMMER_ROOT_VOLNO);
 400
 401         ondisk = volume->ondisk;
 402         vol_buf_size = HAMMER_VOL_BUF_SIZE(ondisk);
 403         KKASSERT((vol_buf_size & ~HAMMER_OFF_SHORT_MASK) == 0);
 404         vol_free_end = HAMMER_ENCODE_RAW_BUFFER(ondisk->vol_no,
 405                         vol_buf_size & ~HAMMER_BIGBLOCK_MASK64);
 406         aligned_vol_free_end = HAMMER_BLOCKMAP_LAYER2_DOALIGN(vol_free_end);
 407
 408         freemap = &hmp->blockmap[HAMMER_ZONE_FREEMAP_INDEX];
 409         alloc_offset = HAMMER_ENCODE_RAW_BUFFER(volume->vol_no, 0);
 410
 411         hmkprintf(hmp, "Initialize freemap volume %d\n", volume->vol_no);
 412
 413         for (phys_offset = HAMMER_ENCODE_RAW_BUFFER(volume->vol_no, 0);
 414              phys_offset < aligned_vol_free_end;
 415              phys_offset += HAMMER_BLOCKMAP_LAYER2) {
 416                 layer1_offset = freemap->phys_offset +
 417                                 HAMMER_BLOCKMAP_LAYER1_OFFSET(phys_offset);
 418                 layer1 = hammer_bread(hmp, layer1_offset, &error, &buffer1);
 419                 if (error)
 420                         goto end;
 421                 if (layer1->phys_offset == HAMMER_BLOCKMAP_UNAVAIL) {
 422                         hammer_modify_buffer(trans, buffer1, layer1, sizeof(*layer1));
 423                         bzero(layer1, sizeof(*layer1));
 424                         layer1->phys_offset = alloc_offset;
 425                         layer1->blocks_free = 0;
 426                         hammer_crc_set_layer1(layer1);
 427                         hammer_modify_buffer_done(buffer1);
 428                         alloc_offset += HAMMER_BIGBLOCK_SIZE;
 429                 }
 430         }
 431
 432         for (phys_offset = HAMMER_ENCODE_RAW_BUFFER(volume->vol_no, 0);
 433              phys_offset < aligned_vol_free_end;
 434              phys_offset += HAMMER_BLOCKMAP_LAYER2) {
 435                 layer1_count = 0;
 436                 layer1_offset = freemap->phys_offset +
 437                                 HAMMER_BLOCKMAP_LAYER1_OFFSET(phys_offset);
 438                 layer1 = hammer_bread(hmp, layer1_offset, &error, &buffer1);
 439                 if (error)
 440                         goto end;
 441                 KKASSERT(layer1->phys_offset != HAMMER_BLOCKMAP_UNAVAIL);
 442
 443                 for (block_offset = 0;
 444                      block_offset < HAMMER_BLOCKMAP_LAYER2;
 445                      block_offset += HAMMER_BIGBLOCK_SIZE) {
 446                         layer2_offset = layer1->phys_offset +
 447                                         HAMMER_BLOCKMAP_LAYER2_OFFSET(block_offset);
 448                         layer2 = hammer_bread(hmp, layer2_offset, &error, &buffer2);
 449                         if (error)
 450                                 goto end;
 451
 452                         hammer_modify_buffer(trans, buffer2, layer2, sizeof(*layer2));
 453                         bzero(layer2, sizeof(*layer2));
 454
 455                         if (phys_offset + block_offset < alloc_offset) {
 456                                 layer2->zone = HAMMER_ZONE_FREEMAP_INDEX;
 457                                 layer2->append_off = HAMMER_BIGBLOCK_SIZE;
 458                                 layer2->bytes_free = 0;
 459                         } else if (phys_offset + block_offset < vol_free_end) {
 460                                 layer2->zone = 0;
 461                                 layer2->append_off = 0;
 462                                 layer2->bytes_free = HAMMER_BIGBLOCK_SIZE;
 463                                 ++layer1_count;
 464                         } else {
 465                                 layer2->zone = HAMMER_ZONE_UNAVAIL_INDEX;
 466                                 layer2->append_off = HAMMER_BIGBLOCK_SIZE;
 467                                 layer2->bytes_free = 0;
 468                         }
 469
 470                         hammer_crc_set_layer2(layer2);
 471                         hammer_modify_buffer_done(buffer2);
 472                 }
 473
 474                 hammer_modify_buffer(trans, buffer1, layer1, sizeof(*layer1));
 475                 layer1->blocks_free += layer1_count;
 476                 hammer_crc_set_layer1(layer1);
 477                 hammer_modify_buffer_done(buffer1);
 478         }
 479
 480 end:
 481         if (buffer1)
 482                 hammer_rel_buffer(buffer1, 0);
 483         if (buffer2)
 484                 hammer_rel_buffer(buffer2, 0);
 485
 486         return error;
 487 }
 488
 489 /*
 490  * XXX This somehow needs to stop doing hammer_modify_buffer() for
 491  * layer2 entries.  In theory removing a large block device could
 492  * blow away UNDO fifo.  The best way is to erase layer2 entries
 493  * in userspace without UNDO getting involved after the device has
 494  * been safely removed from the filesystem.  HAMMER has no interest
 495  * in what happens to the device once it's safely removed.
 496  */
 497 static int
 498 hammer_free_freemap(hammer_transaction_t trans, hammer_volume_t volume)
 499 {
 500         hammer_mount_t hmp = trans->hmp;
 501         hammer_volume_ondisk_t ondisk;
 502         hammer_blockmap_t freemap;
 503         hammer_off_t phys_offset;
 504         hammer_off_t block_offset;
 505         hammer_off_t layer1_offset;
 506         hammer_off_t layer2_offset;
 507         hammer_off_t vol_free_end;
 508         hammer_off_t aligned_vol_free_end;
 509         hammer_blockmap_layer1_t layer1;
 510         hammer_blockmap_layer2_t layer2;
 511         hammer_buffer_t buffer1 = NULL;
 512         hammer_buffer_t buffer2 = NULL;
 513         int64_t vol_buf_size;
 514         int error = 0;
 515
 516         KKASSERT(volume->vol_no != HAMMER_ROOT_VOLNO);
 517
 518         ondisk = volume->ondisk;
 519         vol_buf_size = HAMMER_VOL_BUF_SIZE(ondisk);
 520         KKASSERT((vol_buf_size & ~HAMMER_OFF_SHORT_MASK) == 0);
 521         vol_free_end = HAMMER_ENCODE_RAW_BUFFER(ondisk->vol_no,
 522                         vol_buf_size & ~HAMMER_BIGBLOCK_MASK64);
 523         aligned_vol_free_end = HAMMER_BLOCKMAP_LAYER2_DOALIGN(vol_free_end);
 524
 525         freemap = &hmp->blockmap[HAMMER_ZONE_FREEMAP_INDEX];
 526
 527         hmkprintf(hmp, "Free freemap volume %d\n", volume->vol_no);
 528
 529         for (phys_offset = HAMMER_ENCODE_RAW_BUFFER(volume->vol_no, 0);
 530              phys_offset < aligned_vol_free_end;
 531              phys_offset += HAMMER_BLOCKMAP_LAYER2) {
 532                 layer1_offset = freemap->phys_offset +
 533                                 HAMMER_BLOCKMAP_LAYER1_OFFSET(phys_offset);
 534                 layer1 = hammer_bread(hmp, layer1_offset, &error, &buffer1);
 535                 if (error)
 536                         goto end;
 537                 KKASSERT(layer1->phys_offset != HAMMER_BLOCKMAP_UNAVAIL);
 538
 539                 for (block_offset = 0;
 540                      block_offset < HAMMER_BLOCKMAP_LAYER2;
 541                      block_offset += HAMMER_BIGBLOCK_SIZE) {
 542                         layer2_offset = layer1->phys_offset +
 543                                         HAMMER_BLOCKMAP_LAYER2_OFFSET(block_offset);
 544                         layer2 = hammer_bread(hmp, layer2_offset, &error, &buffer2);
 545                         if (error)
 546                                 goto end;
 547
 548                         switch (layer2->zone) {
 549                         case HAMMER_ZONE_UNDO_INDEX:
 550                                 KKASSERT(0);
 551                         case HAMMER_ZONE_FREEMAP_INDEX:
 552                         case HAMMER_ZONE_UNAVAIL_INDEX:
 553                                 continue;
 554                         default:
 555                                 KKASSERT(phys_offset + block_offset < aligned_vol_free_end);
 556                                 if (layer2->append_off == 0 &&
 557                                     layer2->bytes_free == HAMMER_BIGBLOCK_SIZE)
 558                                         continue;
 559                                 break;
 560                         }
 561                         return EBUSY;  /* Not empty */
 562                 }
 563         }
 564
 565         for (phys_offset = HAMMER_ENCODE_RAW_BUFFER(volume->vol_no, 0);
 566              phys_offset < aligned_vol_free_end;
 567              phys_offset += HAMMER_BLOCKMAP_LAYER2) {
 568                 layer1_offset = freemap->phys_offset +
 569                                 HAMMER_BLOCKMAP_LAYER1_OFFSET(phys_offset);
 570                 layer1 = hammer_bread(hmp, layer1_offset, &error, &buffer1);
 571                 if (error)
 572                         goto end;
 573                 KKASSERT(layer1->phys_offset != HAMMER_BLOCKMAP_UNAVAIL);
 574
 575                 for (block_offset = 0;
 576                      block_offset < HAMMER_BLOCKMAP_LAYER2;
 577                      block_offset += HAMMER_BIGBLOCK_SIZE) {
 578                         layer2_offset = layer1->phys_offset +
 579                                         HAMMER_BLOCKMAP_LAYER2_OFFSET(block_offset);
 580                         layer2 = hammer_bread(hmp, layer2_offset, &error, &buffer2);
 581                         if (error)
 582                                 goto end;
 583
 584                         switch (layer2->zone) {
 585                         case HAMMER_ZONE_UNDO_INDEX:
 586                                 KKASSERT(0);
 587                         default:
 588                                 KKASSERT(phys_offset + block_offset < aligned_vol_free_end);
 589                                 hammer_modify_buffer(trans, buffer2, layer2, sizeof(*layer2));
 590                                 bzero(layer2, sizeof(*layer2));
 591                                 hammer_modify_buffer_done(buffer2);
 592                                 break;
 593                         }
 594                 }
 595
 596                 hammer_modify_buffer(trans, buffer1, layer1, sizeof(*layer1));
 597                 bzero(layer1, sizeof(*layer1));
 598                 layer1->phys_offset = HAMMER_BLOCKMAP_UNAVAIL;
 599                 hammer_crc_set_layer1(layer1);
 600                 hammer_modify_buffer_done(buffer1);
 601         }
 602
 603 end:
 604         if (buffer1)
 605                 hammer_rel_buffer(buffer1, 0);
 606         if (buffer2)
 607                 hammer_rel_buffer(buffer2, 0);
 608
 609         return error;
 610 }
 611
 612 static int
 613 hammer_format_volume_header(hammer_mount_t hmp,
 614         struct hammer_ioc_volume *ioc,
 615         hammer_volume_ondisk_t ondisk,
 616         int vol_no)
 617 {
 618         hammer_volume_ondisk_t root_ondisk;
 619         int64_t vol_alloc;
 620
 621         KKASSERT(HAMMER_BUFSIZE >= sizeof(struct hammer_volume_ondisk));
 622
 623         /*
 624          * Just copy from the root volume header.
 625          */
 626         root_ondisk = hmp->rootvol->ondisk;
 627         bzero(ondisk, sizeof(struct hammer_volume_ondisk));
 628         ondisk->vol_fsid = root_ondisk->vol_fsid;
 629         ondisk->vol_fstype = root_ondisk->vol_fstype;
 630         ksnprintf(ondisk->vol_label, sizeof(ondisk->vol_label), "%s",
 631                 root_ondisk->vol_label);
 632         ondisk->vol_version = root_ondisk->vol_version;
 633         ondisk->vol_rootvol = root_ondisk->vol_no;
 634         ondisk->vol_signature = root_ondisk->vol_signature;
 635
 636         KKASSERT(ondisk->vol_rootvol == HAMMER_ROOT_VOLNO);
 637         KKASSERT(ondisk->vol_signature == HAMMER_FSBUF_VOLUME);
 638
 639         /*
 640          * Assign the new vol_no and vol_count.
 641          */
 642         ondisk->vol_no = vol_no;
 643         ondisk->vol_count = root_ondisk->vol_count + 1;
 644
 645         /*
 646          * Reserve space for (future) header junk.
 647          */
 648         vol_alloc = root_ondisk->vol_bot_beg;
 649         ondisk->vol_bot_beg = vol_alloc;
 650         vol_alloc += ioc->boot_area_size;
 651         ondisk->vol_mem_beg = vol_alloc;
 652         vol_alloc += ioc->memory_log_size;
 653
 654         /*
 655          * The remaining area is the zone 2 buffer allocation area.
 656          */
 657         ondisk->vol_buf_beg = vol_alloc;
 658         ondisk->vol_buf_end = ioc->vol_size & ~(int64_t)HAMMER_BUFMASK;
 659
 660         if (HAMMER_VOL_BUF_SIZE(ondisk) < 0) { /* int64_t */
 661                 hmkprintf(hmp, "volume %d is too small to hold the volume header\n",
 662                         ondisk->vol_no);
 663                 return(EFTYPE);
 664         }
 665
 666         return(0);
 667 }
 668
 669 static int
 670 hammer_update_volumes_header(hammer_transaction_t trans,
 671         int64_t total_bigblocks, int64_t empty_bigblocks)
 672 {
 673         hammer_mount_t hmp = trans->hmp;
 674         struct mount *mp = hmp->mp;
 675         hammer_volume_t volume;
 676         int vol_no;
 677         int error = 0;
 678
 679         /*
 680          * Set each volume's new value of the vol_count field.
 681          */
 682         HAMMER_VOLUME_NUMBER_FOREACH(hmp, vol_no) {
 683                 volume = hammer_get_volume(hmp, vol_no, &error);
 684                 KKASSERT(volume != NULL && error == 0);
 685                 hammer_modify_volume_field(trans, volume, vol_count);
 686                 volume->ondisk->vol_count = hmp->nvolumes;
 687                 hammer_modify_volume_done(volume);
 688
 689                 /*
 690                  * Only changes to the header of the root volume
 691                  * are automatically flushed to disk. For all
 692                  * other volumes that we modify we do it here.
 693                  *
 694                  * No interlock is needed, volume buffers are not
 695                  * messed with by bioops.
 696                  */
 697                 if (volume != trans->rootvol && volume->io.modified) {
 698                         hammer_crc_set_volume(volume->ondisk);
 699                         hammer_io_flush(&volume->io, 0);
 700                 }
 701
 702                 hammer_rel_volume(volume, 0);
 703         }
 704
 705         /*
 706          * Update the total number of big-blocks.
 707          */
 708         hammer_modify_volume_field(trans, trans->rootvol, vol0_stat_bigblocks);
 709         trans->rootvol->ondisk->vol0_stat_bigblocks += total_bigblocks;
 710         hammer_modify_volume_done(trans->rootvol);
 711
 712         /*
 713          * Big-block count changed so recompute the total number of blocks.
 714          */
 715         mp->mnt_stat.f_blocks = trans->rootvol->ondisk->vol0_stat_bigblocks *
 716                                 HAMMER_BUFFERS_PER_BIGBLOCK;
 717         mp->mnt_vstat.f_blocks = trans->rootvol->ondisk->vol0_stat_bigblocks *
 718                                 HAMMER_BUFFERS_PER_BIGBLOCK;
 719
 720         /*
 721          * Update the total number of free big-blocks.
 722          */
 723         hammer_modify_volume_field(trans, trans->rootvol,
 724                 vol0_stat_freebigblocks);
 725         trans->rootvol->ondisk->vol0_stat_freebigblocks += empty_bigblocks;
 726         hammer_modify_volume_done(trans->rootvol);
 727
 728         /*
 729          * Update the copy in hmp.
 730          */
 731         hmp->copy_stat_freebigblocks =
 732                 trans->rootvol->ondisk->vol0_stat_freebigblocks;
 733
 734         return(error);
 735 }
 736
 737 /*
 738  * Count total big-blocks and empty big-blocks within the volume.
 739  * The volume must be a non-root volume.
 740  *
 741  * Note that total big-blocks doesn't include big-blocks for layer2
 742  * (and obviously layer1 and undomap).  This is requirement of the
 743  * volume header and this function is to retrieve that information.
 744  */
 745 static int
 746 hammer_count_bigblocks(hammer_mount_t hmp, hammer_volume_t volume,
 747         int64_t *total_bigblocks, int64_t *empty_bigblocks)
 748 {
 749         hammer_volume_ondisk_t ondisk;
 750         hammer_blockmap_t freemap;
 751         hammer_off_t phys_offset;
 752         hammer_off_t block_offset;
 753         hammer_off_t layer1_offset;
 754         hammer_off_t layer2_offset;
 755         hammer_off_t vol_free_end;
 756         hammer_off_t aligned_vol_free_end;
 757         hammer_blockmap_layer1_t layer1;
 758         hammer_blockmap_layer2_t layer2;
 759         hammer_buffer_t buffer1 = NULL;
 760         hammer_buffer_t buffer2 = NULL;
 761         int64_t vol_buf_size;
 762         int64_t total = 0;
 763         int64_t empty = 0;
 764         int error = 0;
 765
 766         KKASSERT(volume->vol_no != HAMMER_ROOT_VOLNO);
 767
 768         *total_bigblocks = 0;   /* avoid gcc warnings */
 769         *empty_bigblocks = 0;   /* avoid gcc warnings */
 770
 771         ondisk = volume->ondisk;
 772         vol_buf_size = HAMMER_VOL_BUF_SIZE(ondisk);
 773         KKASSERT((vol_buf_size & ~HAMMER_OFF_SHORT_MASK) == 0);
 774         vol_free_end = HAMMER_ENCODE_RAW_BUFFER(ondisk->vol_no,
 775                         vol_buf_size & ~HAMMER_BIGBLOCK_MASK64);
 776         aligned_vol_free_end = HAMMER_BLOCKMAP_LAYER2_DOALIGN(vol_free_end);
 777
 778         freemap = &hmp->blockmap[HAMMER_ZONE_FREEMAP_INDEX];
 779
 780         for (phys_offset = HAMMER_ENCODE_RAW_BUFFER(volume->ondisk->vol_no, 0);
 781              phys_offset < aligned_vol_free_end;
 782              phys_offset += HAMMER_BLOCKMAP_LAYER2) {
 783                 layer1_offset = freemap->phys_offset +
 784                                 HAMMER_BLOCKMAP_LAYER1_OFFSET(phys_offset);
 785                 layer1 = hammer_bread(hmp, layer1_offset, &error, &buffer1);
 786                 if (error)
 787                         goto end;
 788
 789                 for (block_offset = 0;
 790                      block_offset < HAMMER_BLOCKMAP_LAYER2;
 791                      block_offset += HAMMER_BIGBLOCK_SIZE) {
 792                         layer2_offset = layer1->phys_offset +
 793                                         HAMMER_BLOCKMAP_LAYER2_OFFSET(block_offset);
 794                         layer2 = hammer_bread(hmp, layer2_offset, &error, &buffer2);
 795                         if (error)
 796                                 goto end;
 797
 798                         switch (layer2->zone) {
 799                         case HAMMER_ZONE_UNDO_INDEX:
 800                                 KKASSERT(0);
 801                         case HAMMER_ZONE_FREEMAP_INDEX:
 802                         case HAMMER_ZONE_UNAVAIL_INDEX:
 803                                 continue;
 804                         default:
 805                                 KKASSERT(phys_offset + block_offset < aligned_vol_free_end);
 806                                 total++;
 807                                 if (layer2->append_off == 0 &&
 808                                     layer2->bytes_free == HAMMER_BIGBLOCK_SIZE)
 809                                         empty++;
 810                                 break;
 811                         }
 812                 }
 813         }
 814
 815         hmkprintf(hmp, "big-blocks total=%jd empty=%jd\n", total, empty);
 816         *total_bigblocks = total;
 817         *empty_bigblocks = empty;
 818 end:
 819         if (buffer1)
 820                 hammer_rel_buffer(buffer1, 0);
 821         if (buffer2)
 822                 hammer_rel_buffer(buffer2, 0);
 823
 824         return error;
 825 }