sbin/newfs_hammer2/newfs_hammer2.c

   1 /*
   2  * Copyright (c) 2011-2015 The DragonFly Project.  All rights reserved.
   3  *
   4  * This code is derived from software contributed to The DragonFly Project
   5  * by Matthew Dillon <dillon@dragonflybsd.org>
   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
  35 #include <sys/types.h>
  36 #include <sys/diskslice.h>
  37 #include <sys/diskmbr.h>
  38 #include <sys/stat.h>
  39 #include <sys/time.h>
  40 #include <sys/sysctl.h>
  41 #include <sys/ioctl.h>
  42 #include <vfs/hammer2/hammer2_xxhash.h>
  43 #include <vfs/hammer2/hammer2_disk.h>
  44
  45 #include <stdio.h>
  46 #include <stdlib.h>
  47 #include <stdarg.h>
  48 #include <stddef.h>
  49 #include <unistd.h>
  50 #include <string.h>
  51 #include <errno.h>
  52 #include <fcntl.h>
  53 #include <assert.h>
  54 #include <err.h>
  55 #include <uuid.h>
  56
  57 #include "hammer2_subs.h"
  58
  59 #define MAXLABELS       HAMMER2_SET_COUNT
  60
  61 static hammer2_off_t check_volume(const char *path, int *fdp);
  62 static int64_t getsize(const char *str, int64_t minval, int64_t maxval, int pw);
  63 static uint64_t nowtime(void);
  64 static int blkrefary_cmp(const void *b1, const void *b2);
  65 static void usage(void);
  66
  67 static void format_hammer2(int fd, hammer2_off_t total_space,
  68                                 hammer2_off_t free_space);
  69 static void alloc_direct(hammer2_off_t *basep, hammer2_blockref_t *bref,
  70                                 size_t bytes);
  71
  72 static int Hammer2Version = -1;
  73 static int ForceOpt;
  74 static uuid_t Hammer2_FSType;   /* static filesystem type id for HAMMER2 */
  75 static uuid_t Hammer2_VolFSID;  /* unique filesystem id in volu header */
  76 static uuid_t Hammer2_SupCLID;  /* PFS cluster id in super-root inode */
  77 static uuid_t Hammer2_SupFSID;  /* PFS unique id in super-root inode */
  78 static uuid_t Hammer2_PfsCLID[MAXLABELS];
  79 static uuid_t Hammer2_PfsFSID[MAXLABELS];
  80 static const char *Label[MAXLABELS];
  81 static hammer2_off_t BootAreaSize;
  82 static hammer2_off_t AuxAreaSize;
  83 static int NLabels;
  84
  85 int
  86 main(int ac, char **av)
  87 {
  88         uint32_t status;
  89         hammer2_off_t total_space;
  90         hammer2_off_t free_space;
  91         hammer2_off_t reserved_space;
  92         int ch;
  93         int fd = -1;
  94         int i;
  95         int defaultlabels = 1;
  96         char *vol_fsid = NULL;
  97         char *sup_clid_name = NULL;
  98         char *sup_fsid_name = NULL;
  99         char *pfs_clid_name = NULL;
 100         char *pfs_fsid_name = NULL;
 101
 102         Label[NLabels++] = "LOCAL";
 103
 104         /*
 105          * Sanity check basic filesystem structures.  No cookies for us
 106          * if it gets broken!
 107          */
 108         assert(sizeof(hammer2_volume_data_t) == HAMMER2_VOLUME_BYTES);
 109         assert(sizeof(hammer2_inode_data_t) == HAMMER2_INODE_BYTES);
 110         assert(sizeof(hammer2_blockref_t) == HAMMER2_BLOCKREF_BYTES);
 111
 112         /*
 113          * Generate a filesystem id and lookup the filesystem type
 114          */
 115         srandomdev();
 116         uuidgen(&Hammer2_VolFSID, 1);
 117         uuidgen(&Hammer2_SupCLID, 1);
 118         uuidgen(&Hammer2_SupFSID, 1);
 119         uuid_from_string(HAMMER2_UUID_STRING, &Hammer2_FSType, &status);
 120         /*uuid_name_lookup(&Hammer2_FSType, "DragonFly HAMMER2", &status);*/
 121         if (status != uuid_s_ok) {
 122                 errx(1, "uuids file does not have the DragonFly "
 123                         "HAMMER2 filesystem type");
 124         }
 125
 126         /*
 127          * Parse arguments
 128          */
 129         while ((ch = getopt(ac, av, "fL:b:r:V:")) != -1) {
 130                 switch(ch) {
 131                 case 'f':
 132                         ForceOpt = 1;
 133                         break;
 134                 case 'L':
 135                         defaultlabels = 0;
 136                         if (strcasecmp(optarg, "none") == 0) {
 137                                 break;
 138                         }
 139                         if (NLabels >= MAXLABELS) {
 140                                 errx(1, "Limit of %d local labels",
 141                                      MAXLABELS - 1);
 142                         }
 143                         Label[NLabels++] = optarg;
 144                         if (strlen(Label[NLabels-1]) > HAMMER2_INODE_MAXNAME) {
 145                                 errx(1, "Volume label '%s' is too long "
 146                                         "(64 chars max)\n", optarg);
 147                         }
 148                         break;
 149                 case 'b':
 150                         BootAreaSize = getsize(optarg,
 151                                          HAMMER2_NEWFS_ALIGN,
 152                                          HAMMER2_BOOT_MAX_BYTES, 2);
 153                         break;
 154                 case 'r':
 155                         AuxAreaSize = getsize(optarg,
 156                                          HAMMER2_NEWFS_ALIGN,
 157                                          HAMMER2_REDO_MAX_BYTES, 2);
 158                         break;
 159                 case 'V':
 160                         Hammer2Version = strtol(optarg, NULL, 0);
 161                         if (Hammer2Version < HAMMER2_VOL_VERSION_MIN ||
 162                             Hammer2Version >= HAMMER2_VOL_VERSION_WIP) {
 163                                 errx(1,
 164                                      "I don't understand how to format "
 165                                      "HAMMER2 version %d\n",
 166                                      Hammer2Version);
 167                         }
 168                         break;
 169                 default:
 170                         usage();
 171                         break;
 172                 }
 173         }
 174
 175         /*
 176          * Check Hammer2 version
 177          */
 178         if (Hammer2Version < 0) {
 179                 size_t olen = sizeof(Hammer2Version);
 180                 Hammer2Version = HAMMER2_VOL_VERSION_DEFAULT;
 181                 if (sysctlbyname("vfs.hammer2.supported_version",
 182                                  &Hammer2Version, &olen, NULL, 0) == 0) {
 183                         if (Hammer2Version >= HAMMER2_VOL_VERSION_WIP) {
 184                                 Hammer2Version = HAMMER2_VOL_VERSION_WIP - 1;
 185                                 fprintf(stderr,
 186                                         "newfs_hammer2: WARNING: HAMMER2 VFS "
 187                                         "supports higher version than I "
 188                                         "understand,\n"
 189                                         "using version %d\n",
 190                                         Hammer2Version);
 191                         }
 192                 } else {
 193                         fprintf(stderr,
 194                                 "newfs_hammer2: WARNING: HAMMER2 VFS not "
 195                                 "loaded, cannot get version info.\n"
 196                                 "Using version %d\n",
 197                                 HAMMER2_VOL_VERSION_DEFAULT);
 198                 }
 199         }
 200
 201         ac -= optind;
 202         av += optind;
 203
 204         if (ac != 1 || av[0][0] == 0) {
 205                 fprintf(stderr, "Exactly one disk device must be specified\n");
 206                 exit(1);
 207         }
 208
 209         /*
 210          * Adjust Label[] and NLabels.
 211          */
 212         if (defaultlabels) {
 213                 char c = av[0][strlen(av[0]) - 1];
 214                 if (c == 'a')
 215                         Label[NLabels++] = "BOOT";
 216                 else if (c == 'd')
 217                         Label[NLabels++] = "ROOT";
 218                 else
 219                         Label[NLabels++] = "DATA";
 220         }
 221
 222         /*
 223          * Collect volume information.
 224          */
 225         total_space = check_volume(av[0], &fd);
 226
 227         /*
 228          * ~typically 8MB alignment to avoid edge cases for reserved blocks
 229          * and so raid stripes (if any) operate efficiently.
 230          */
 231         total_space &= ~HAMMER2_VOLUME_ALIGNMASK64;
 232
 233         /*
 234          * Calculate defaults for the boot area size and round to the
 235          * volume alignment boundary.
 236          *
 237          * NOTE: These areas are currently not used for booting but are
 238          *       reserved for future filesystem expansion.
 239          */
 240         if (BootAreaSize == 0) {
 241                 BootAreaSize = HAMMER2_BOOT_NOM_BYTES;
 242                 while (BootAreaSize > total_space / 20)
 243                         BootAreaSize >>= 1;
 244                 if (BootAreaSize < HAMMER2_BOOT_MIN_BYTES)
 245                         BootAreaSize = HAMMER2_BOOT_MIN_BYTES;
 246         } else if (BootAreaSize < HAMMER2_BOOT_MIN_BYTES) {
 247                 BootAreaSize = HAMMER2_BOOT_MIN_BYTES;
 248         }
 249         BootAreaSize = (BootAreaSize + HAMMER2_VOLUME_ALIGNMASK64) &
 250                         ~HAMMER2_VOLUME_ALIGNMASK64;
 251
 252         /*
 253          * Calculate defaults for the redo area size and round to the
 254          * volume alignment boundary.
 255          *
 256          * NOTE: These areas are currently not used for logging but are
 257          *       reserved for future filesystem expansion.
 258          */
 259         if (AuxAreaSize == 0) {
 260                 AuxAreaSize = HAMMER2_REDO_NOM_BYTES;
 261                 while (AuxAreaSize > total_space / 20)
 262                         AuxAreaSize >>= 1;
 263                 if (AuxAreaSize < HAMMER2_REDO_MIN_BYTES)
 264                         AuxAreaSize = HAMMER2_REDO_MIN_BYTES;
 265         } else if (AuxAreaSize < HAMMER2_REDO_MIN_BYTES) {
 266                 AuxAreaSize = HAMMER2_REDO_MIN_BYTES;
 267         }
 268         AuxAreaSize = (AuxAreaSize + HAMMER2_VOLUME_ALIGNMASK64) &
 269                        ~HAMMER2_VOLUME_ALIGNMASK64;
 270
 271         /*
 272          * We'll need to stuff this in the volume header soon.
 273          */
 274         hammer2_uuid_to_str(&Hammer2_VolFSID, &vol_fsid);
 275         hammer2_uuid_to_str(&Hammer2_SupCLID, &sup_clid_name);
 276         hammer2_uuid_to_str(&Hammer2_SupFSID, &sup_fsid_name);
 277
 278         /*
 279          * Calculate the amount of reserved space.  HAMMER2_ZONE_SEG (4MB)
 280          * is reserved at the beginning of every 2GB of storage, rounded up.
 281          * Thus a 200MB filesystem will still have a 4MB reserve area.
 282          *
 283          * We also include the boot and redo areas in the reserve.  The
 284          * reserve is used to help 'df' calculate the amount of available
 285          * space.
 286          *
 287          * XXX I kinda screwed up and made the reserved area on the LEVEL1
 288          *     boundary rather than the ZONE boundary.  LEVEL1 is on 1GB
 289          *     boundaries rather than 2GB boundaries.  Stick with the LEVEL1
 290          *     boundary.
 291          */
 292         reserved_space = ((total_space + HAMMER2_FREEMAP_LEVEL1_MASK) /
 293                           HAMMER2_FREEMAP_LEVEL1_SIZE) * HAMMER2_ZONE_SEG64;
 294
 295         free_space = total_space - reserved_space - BootAreaSize - AuxAreaSize;
 296
 297         format_hammer2(fd, total_space, free_space);
 298         fsync(fd);
 299         close(fd);
 300
 301         printf("---------------------------------------------\n");
 302         printf("version:          %d\n", Hammer2Version);
 303         printf("total-size:       %s (%jd bytes)\n",
 304                sizetostr(total_space),
 305                (intmax_t)total_space);
 306         printf("boot-area-size:   %s\n", sizetostr(BootAreaSize));
 307         printf("aux-area-size:    %s\n", sizetostr(AuxAreaSize));
 308         printf("topo-reserved:    %s\n", sizetostr(reserved_space));
 309         printf("free-space:       %s\n", sizetostr(free_space));
 310         printf("vol-fsid:         %s\n", vol_fsid);
 311         printf("sup-clid:         %s\n", sup_clid_name);
 312         printf("sup-fsid:         %s\n", sup_fsid_name);
 313         for (i = 0; i < NLabels; ++i) {
 314                 printf("PFS \"%s\"\n", Label[i]);
 315                 hammer2_uuid_to_str(&Hammer2_PfsCLID[i], &pfs_clid_name);
 316                 hammer2_uuid_to_str(&Hammer2_PfsFSID[i], &pfs_fsid_name);
 317                 printf("    clid %s\n", pfs_clid_name);
 318                 printf("    fsid %s\n", pfs_fsid_name);
 319         }
 320         printf("\n");
 321
 322         free(vol_fsid);
 323         free(sup_clid_name);
 324         free(sup_fsid_name);
 325         free(pfs_clid_name);
 326         free(pfs_fsid_name);
 327
 328         return(0);
 329 }
 330
 331 static
 332 void
 333 usage(void)
 334 {
 335         fprintf(stderr,
 336                 "usage: newfs_hammer2 [-f] [-b bootsize] [-r redosize] "
 337                 "[-V version] [-L label ...] special\n"
 338         );
 339         exit(1);
 340 }
 341
 342 /*
 343  * Convert a string to a 64 bit signed integer with various requirements.
 344  */
 345 static int64_t
 346 getsize(const char *str, int64_t minval, int64_t maxval, int powerof2)
 347 {
 348         int64_t val;
 349         char *ptr;
 350
 351         val = strtoll(str, &ptr, 0);
 352         switch(*ptr) {
 353         case 't':
 354         case 'T':
 355                 val *= 1024;
 356                 /* fall through */
 357         case 'g':
 358         case 'G':
 359                 val *= 1024;
 360                 /* fall through */
 361         case 'm':
 362         case 'M':
 363                 val *= 1024;
 364                 /* fall through */
 365         case 'k':
 366         case 'K':
 367                 val *= 1024;
 368                 break;
 369         default:
 370                 errx(1, "Unknown suffix in number '%s'\n", str);
 371                 /* not reached */
 372         }
 373         if (ptr[1]) {
 374                 errx(1, "Unknown suffix in number '%s'\n", str);
 375                 /* not reached */
 376         }
 377         if (val < minval) {
 378                 errx(1, "Value too small: %s, min is %s\n",
 379                      str, sizetostr(minval));
 380                 /* not reached */
 381         }
 382         if (val > maxval) {
 383                 errx(1, "Value too large: %s, max is %s\n",
 384                      str, sizetostr(maxval));
 385                 /* not reached */
 386         }
 387         if ((powerof2 & 1) && (val ^ (val - 1)) != ((val << 1) - 1)) {
 388                 errx(1, "Value not power of 2: %s\n", str);
 389                 /* not reached */
 390         }
 391         if ((powerof2 & 2) && (val & HAMMER2_NEWFS_ALIGNMASK)) {
 392                 errx(1, "Value not an integral multiple of %dK: %s",
 393                      HAMMER2_NEWFS_ALIGN / 1024, str);
 394                 /* not reached */
 395         }
 396         return(val);
 397 }
 398
 399 static uint64_t
 400 nowtime(void)
 401 {
 402         struct timeval tv;
 403         uint64_t xtime;
 404
 405         gettimeofday(&tv, NULL);
 406         xtime = tv.tv_sec * 1000000LL + tv.tv_usec;
 407         return(xtime);
 408 }
 409
 410 /*
 411  * Figure out how big the volume is.
 412  */
 413 static
 414 hammer2_off_t
 415 check_volume(const char *path, int *fdp)
 416 {
 417         struct partinfo pinfo;
 418         struct stat st;
 419         hammer2_off_t size;
 420
 421         /*
 422          * Get basic information about the volume
 423          */
 424         *fdp = open(path, O_RDWR);
 425         if (*fdp < 0)
 426                 err(1, "Unable to open %s R+W", path);
 427         if (ioctl(*fdp, DIOCGPART, &pinfo) < 0) {
 428                 /*
 429                  * Allow the formatting of regular files as HAMMER2 volumes
 430                  */
 431                 if (fstat(*fdp, &st) < 0)
 432                         err(1, "Unable to stat %s", path);
 433                 if (!S_ISREG(st.st_mode))
 434                         errx(1, "Unsupported file type for %s", path);
 435                 size = st.st_size;
 436         } else {
 437                 /*
 438                  * When formatting a block device as a HAMMER2 volume the
 439                  * sector size must be compatible.  HAMMER2 uses 64K
 440                  * filesystem buffers but logical buffers for direct I/O
 441                  * can be as small as HAMMER2_LOGSIZE (16KB).
 442                  */
 443                 if (pinfo.reserved_blocks) {
 444                         errx(1, "HAMMER2 cannot be placed in a partition "
 445                                 "which overlaps the disklabel or MBR");
 446                 }
 447                 if (pinfo.media_blksize > HAMMER2_PBUFSIZE ||
 448                     HAMMER2_PBUFSIZE % pinfo.media_blksize) {
 449                         errx(1, "A media sector size of %d is not supported",
 450                              pinfo.media_blksize);
 451                 }
 452                 size = pinfo.media_size;
 453         }
 454         printf("Volume %-15s size %s\n", path, sizetostr(size));
 455         return (size);
 456 }
 457
 458 /*
 459  * Create the volume header, the super-root directory inode, and
 460  * the writable snapshot subdirectory (named via the label) which
 461  * is to be the initial mount point, or at least the first mount point.
 462  * newfs_hammer2 doesn't format the freemap bitmaps for these.
 463  *
 464  * 0                      4MB
 465  * [----reserved_area----][boot_area][aux_area]
 466  * [[vol_hdr][freemap]...]                     [sroot][root][root]...
 467  *     \                                        ^\     ^     ^
 468  *      \--------------------------------------/  \---/-----/---...
 469  *
 470  * NOTE: The passed total_space is 8MB-aligned to avoid edge cases.
 471  */
 472 static
 473 void
 474 format_hammer2(int fd, hammer2_off_t total_space, hammer2_off_t free_space)
 475 {
 476         char *buf = malloc(HAMMER2_PBUFSIZE);
 477         hammer2_volume_data_t *vol;
 478         hammer2_inode_data_t *rawip;
 479         hammer2_blockref_t sroot_blockref;
 480         hammer2_blockref_t root_blockref[MAXLABELS];
 481         uint64_t now;
 482         hammer2_off_t volu_base = 0;
 483         hammer2_off_t boot_base = HAMMER2_ZONE_SEG;
 484         hammer2_off_t aux_base = boot_base + BootAreaSize;
 485         hammer2_off_t alloc_base = aux_base + AuxAreaSize;
 486         hammer2_off_t tmp_base;
 487         size_t n;
 488         int i;
 489
 490         /*
 491          * Clear the entire reserve for the first 2G segment and
 492          * make sure we can write to the last block.
 493          */
 494         bzero(buf, HAMMER2_PBUFSIZE);
 495         tmp_base = volu_base;
 496         for (i = 0; i < HAMMER2_ZONE_BLOCKS_SEG; ++i) {
 497                 n = pwrite(fd, buf, HAMMER2_PBUFSIZE, tmp_base);
 498                 if (n != HAMMER2_PBUFSIZE) {
 499                         perror("write");
 500                         exit(1);
 501                 }
 502                 tmp_base += HAMMER2_PBUFSIZE;
 503         }
 504
 505         n = pwrite(fd, buf, HAMMER2_PBUFSIZE,
 506                    volu_base + total_space - HAMMER2_PBUFSIZE);
 507         if (n != HAMMER2_PBUFSIZE) {
 508                 perror("write (at-end-of-volume)");
 509                 exit(1);
 510         }
 511
 512         /*
 513          * Make sure alloc_base won't cross the reserved area at the
 514          * beginning of each 2GB zone.
 515          *
 516          * Reserve space for the super-root inode and the root inode.
 517          * Make sure they are in the same 64K block to simplify our code.
 518          */
 519         assert((alloc_base & HAMMER2_PBUFMASK) == 0);
 520         assert(alloc_base < HAMMER2_ZONE_BYTES64 - HAMMER2_ZONE_SEG);
 521
 522         /*
 523          * Clear the boot/aux area.
 524          */
 525         for (tmp_base = boot_base; tmp_base < alloc_base;
 526              tmp_base += HAMMER2_PBUFSIZE) {
 527                 n = pwrite(fd, buf, HAMMER2_PBUFSIZE, tmp_base);
 528                 if (n != HAMMER2_PBUFSIZE) {
 529                         perror("write (boot/aux)");
 530                         exit(1);
 531                 }
 532         }
 533
 534         now = nowtime();
 535         alloc_base &= ~HAMMER2_PBUFMASK64;
 536         alloc_direct(&alloc_base, &sroot_blockref, HAMMER2_INODE_BYTES);
 537
 538         for (i = 0; i < NLabels; ++i) {
 539                 uuidgen(&Hammer2_PfsCLID[i], 1);
 540                 uuidgen(&Hammer2_PfsFSID[i], 1);
 541
 542                 alloc_direct(&alloc_base, &root_blockref[i],
 543                              HAMMER2_INODE_BYTES);
 544                 assert(((sroot_blockref.data_off ^ root_blockref[i].data_off) &
 545                         HAMMER2_OFF_MASK_HI) == 0);
 546
 547                 /*
 548                  * Format the root directory inode, which is left empty.
 549                  */
 550                 rawip = (void *)(buf + (HAMMER2_OFF_MASK_LO &
 551                                         root_blockref[i].data_off));
 552                 rawip->meta.version = HAMMER2_INODE_VERSION_ONE;
 553                 rawip->meta.ctime = now;
 554                 rawip->meta.mtime = now;
 555                 /* rawip->atime = now; NOT IMPL MUST BE ZERO */
 556                 rawip->meta.btime = now;
 557                 rawip->meta.type = HAMMER2_OBJTYPE_DIRECTORY;
 558                 rawip->meta.mode = 0755;
 559                 rawip->meta.inum = 1;   /* root inode, inumber 1 */
 560                 rawip->meta.nlinks = 1; /* directory link count compat */
 561
 562                 rawip->meta.name_len = strlen(Label[i]);
 563                 bcopy(Label[i], rawip->filename, rawip->meta.name_len);
 564                 rawip->meta.name_key =
 565                                 dirhash(rawip->filename, rawip->meta.name_len);
 566
 567                 /*
 568                  * Compression mode and supported copyids.
 569                  *
 570                  * Do not allow compression when creating any "BOOT" label
 571                  * (pfs-create also does the same if the pfs is named "BOOT")
 572                  */
 573                 if (strcasecmp(Label[i], "BOOT") == 0) {
 574                         rawip->meta.comp_algo = HAMMER2_ENC_ALGO(
 575                                                     HAMMER2_COMP_AUTOZERO);
 576                         rawip->meta.check_algo = HAMMER2_ENC_ALGO(
 577                                                     HAMMER2_CHECK_XXHASH64);
 578                 } else  {
 579                         rawip->meta.comp_algo = HAMMER2_ENC_ALGO(
 580                                                     HAMMER2_COMP_NEWFS_DEFAULT);
 581                         rawip->meta.check_algo = HAMMER2_ENC_ALGO(
 582                                                     HAMMER2_CHECK_XXHASH64);
 583                 }
 584
 585                 /*
 586                  * NOTE: We leave nmasters set to 0, which means that we
 587                  *       don't know how many masters there are.  The quorum
 588                  *       calculation will effectively be 1 ( 0 / 2 + 1 ).
 589                  */
 590                 rawip->meta.pfs_clid = Hammer2_PfsCLID[i];
 591                 rawip->meta.pfs_fsid = Hammer2_PfsFSID[i];
 592                 rawip->meta.pfs_type = HAMMER2_PFSTYPE_MASTER;
 593                 rawip->meta.op_flags |= HAMMER2_OPFLAG_PFSROOT;
 594
 595                 /* first allocatable inode number */
 596                 rawip->meta.pfs_inum = 16;
 597
 598                 /* rawip->u.blockset is left empty */
 599
 600                 /*
 601                  * The root blockref will be stored in the super-root inode as
 602                  * the only directory entry.  The copyid here is the actual
 603                  * copyid of the storage ref.
 604                  *
 605                  * The key field for a directory entry's blockref is
 606                  * essentially the name key for the entry.
 607                  */
 608                 root_blockref[i].key = rawip->meta.name_key;
 609                 root_blockref[i].copyid = HAMMER2_COPYID_LOCAL;
 610                 root_blockref[i].keybits = 0;
 611                 root_blockref[i].check.xxhash64.value =
 612                                 XXH64(rawip, sizeof(*rawip), XXH_HAMMER2_SEED);
 613                 root_blockref[i].type = HAMMER2_BREF_TYPE_INODE;
 614                 root_blockref[i].methods =
 615                                 HAMMER2_ENC_CHECK(HAMMER2_CHECK_XXHASH64) |
 616                                 HAMMER2_ENC_COMP(HAMMER2_COMP_NONE);
 617                 root_blockref[i].mirror_tid = 16;
 618                 root_blockref[i].flags = HAMMER2_BREF_FLAG_PFSROOT;
 619         }
 620
 621         /*
 622          * Format the super-root directory inode, giving it one directory
 623          * entry (root_blockref) and fixup the icrc method.
 624          *
 625          * The superroot contains one directory entry pointing at the root
 626          * inode (named via the label).  Inodes contain one blockset which
 627          * is fully associative so we can put the entry anywhere without
 628          * having to worry about the hash.  Use index 0.
 629          */
 630         rawip = (void *)(buf + (HAMMER2_OFF_MASK_LO & sroot_blockref.data_off));
 631         rawip->meta.version = HAMMER2_INODE_VERSION_ONE;
 632         rawip->meta.ctime = now;
 633         rawip->meta.mtime = now;
 634         /* rawip->meta.atime = now; NOT IMPL MUST BE ZERO */
 635         rawip->meta.btime = now;
 636         rawip->meta.type = HAMMER2_OBJTYPE_DIRECTORY;
 637         rawip->meta.mode = 0700;        /* super-root - root only */
 638         rawip->meta.inum = 0;           /* super root inode, inumber 0 */
 639         rawip->meta.nlinks = 2;         /* directory link count compat */
 640
 641         rawip->meta.name_len = 0;       /* super-root is unnamed */
 642         rawip->meta.name_key = 0;
 643
 644         rawip->meta.comp_algo = HAMMER2_ENC_ALGO(HAMMER2_COMP_AUTOZERO);
 645         rawip->meta.check_algo = HAMMER2_ENC_ALGO(HAMMER2_CHECK_XXHASH64);
 646
 647         /*
 648          * The super-root is flagged as a PFS and typically given its own
 649          * random FSID, making it possible to mirror an entire HAMMER2 disk
 650          * snapshots and all if desired.  PFS ids are used to match up
 651          * mirror sources and targets and cluster copy sources and targets.
 652          *
 653          * (XXX whole-disk logical mirroring is not really supported in
 654          *  the first attempt because each PFS is in its own modify/mirror
 655          *  transaction id domain, so normal mechanics cannot cross a PFS
 656          *  boundary).
 657          */
 658         rawip->meta.pfs_clid = Hammer2_SupCLID;
 659         rawip->meta.pfs_fsid = Hammer2_SupFSID;
 660         rawip->meta.pfs_type = HAMMER2_PFSTYPE_SUPROOT;
 661         snprintf((char*)rawip->filename, sizeof(rawip->filename), "SUPROOT");
 662         rawip->meta.name_key = 0;
 663         rawip->meta.name_len = strlen((char*)rawip->filename);
 664
 665         /* The super-root has an inode number of 0 */
 666         rawip->meta.pfs_inum = 0;
 667
 668         /*
 669          * Currently newfs_hammer2 just throws the PFS inodes into the
 670          * top-level block table at the volume root and doesn't try to
 671          * create an indirect block, so we are limited to ~4 at filesystem
 672          * creation time.  More can be added after mounting.
 673          */
 674         qsort(root_blockref, NLabels, sizeof(root_blockref[0]), blkrefary_cmp);
 675         for (i = 0; i < NLabels; ++i)
 676                 rawip->u.blockset.blockref[i] = root_blockref[i];
 677
 678         /*
 679          * The sroot blockref will be stored in the volume header.
 680          */
 681         sroot_blockref.copyid = HAMMER2_COPYID_LOCAL;
 682         sroot_blockref.keybits = 0;
 683         sroot_blockref.check.xxhash64.value =
 684                                 XXH64(rawip, sizeof(*rawip), XXH_HAMMER2_SEED);
 685         sroot_blockref.type = HAMMER2_BREF_TYPE_INODE;
 686         sroot_blockref.methods = HAMMER2_ENC_CHECK(HAMMER2_CHECK_XXHASH64) |
 687                                  HAMMER2_ENC_COMP(HAMMER2_COMP_AUTOZERO);
 688         sroot_blockref.mirror_tid = 16;
 689         rawip = NULL;
 690
 691         /*
 692          * Write out the 64K HAMMER2 block containing the root and sroot.
 693          */
 694         n = pwrite(fd, buf, HAMMER2_PBUFSIZE,
 695                    sroot_blockref.data_off & HAMMER2_OFF_MASK_HI);
 696         if (n != HAMMER2_PBUFSIZE) {
 697                 perror("write");
 698                 exit(1);
 699         }
 700
 701         /*
 702          * Format the volume header.
 703          *
 704          * The volume header points to sroot_blockref.  Also be absolutely
 705          * sure that allocator_beg is set.
 706          */
 707         bzero(buf, HAMMER2_PBUFSIZE);
 708         vol = (void *)buf;
 709
 710         vol->magic = HAMMER2_VOLUME_ID_HBO;
 711         vol->boot_beg = boot_base;
 712         vol->boot_end = boot_base + BootAreaSize;
 713         vol->aux_beg = aux_base;
 714         vol->aux_end = aux_base + AuxAreaSize;
 715         vol->volu_size = total_space;
 716         vol->version = Hammer2Version;
 717         vol->flags = 0;
 718
 719         vol->fsid = Hammer2_VolFSID;
 720         vol->fstype = Hammer2_FSType;
 721
 722         vol->peer_type = DMSG_PEER_HAMMER2;     /* LNK_CONN identification */
 723
 724         vol->allocator_size = free_space;
 725         vol->allocator_free = free_space;
 726         vol->allocator_beg = alloc_base;
 727
 728         vol->sroot_blockset.blockref[0] = sroot_blockref;
 729         vol->mirror_tid = 16;   /* all blockref mirror TIDs set to 16 */
 730         vol->freemap_tid = 16;  /* all blockref mirror TIDs set to 16 */
 731         vol->icrc_sects[HAMMER2_VOL_ICRC_SECT1] =
 732                         hammer2_icrc32((char *)vol + HAMMER2_VOLUME_ICRC1_OFF,
 733                                        HAMMER2_VOLUME_ICRC1_SIZE);
 734
 735         /*
 736          * Set ICRC_SECT0 after all remaining elements of sect0 have been
 737          * populated in the volume header.  Note hat ICRC_SECT* (except for
 738          * SECT0) are part of sect0.
 739          */
 740         vol->icrc_sects[HAMMER2_VOL_ICRC_SECT0] =
 741                         hammer2_icrc32((char *)vol + HAMMER2_VOLUME_ICRC0_OFF,
 742                                        HAMMER2_VOLUME_ICRC0_SIZE);
 743         vol->icrc_volheader =
 744                         hammer2_icrc32((char *)vol + HAMMER2_VOLUME_ICRCVH_OFF,
 745                                        HAMMER2_VOLUME_ICRCVH_SIZE);
 746
 747         /*
 748          * Write the volume header and all alternates.
 749          */
 750         for (i = 0; i < HAMMER2_NUM_VOLHDRS; ++i) {
 751                 if (i * HAMMER2_ZONE_BYTES64 >= total_space)
 752                         break;
 753                 n = pwrite(fd, buf, HAMMER2_PBUFSIZE,
 754                            volu_base + i * HAMMER2_ZONE_BYTES64);
 755                 if (n != HAMMER2_PBUFSIZE) {
 756                         perror("write");
 757                         exit(1);
 758                 }
 759         }
 760
 761         /*
 762          * Cleanup
 763          */
 764         free(buf);
 765 }
 766
 767 static void
 768 alloc_direct(hammer2_off_t *basep, hammer2_blockref_t *bref, size_t bytes)
 769 {
 770         int radix;
 771
 772         radix = 0;
 773         assert(bytes);
 774         while ((bytes & 1) == 0) {
 775                 bytes >>= 1;
 776                 ++radix;
 777         }
 778         assert(bytes == 1);
 779         if (radix < HAMMER2_RADIX_MIN)
 780                 radix = HAMMER2_RADIX_MIN;
 781
 782         bzero(bref, sizeof(*bref));
 783         bref->data_off = *basep | radix;
 784         bref->vradix = radix;
 785
 786         *basep += 1U << radix;
 787 }
 788
 789 static int
 790 blkrefary_cmp(const void *b1, const void *b2)
 791 {
 792         const hammer2_blockref_t *bref1 = b1;
 793         const hammer2_blockref_t *bref2 = b2;
 794
 795         if (bref1->key < bref2->key)
 796                 return(-1);
 797         if (bref1->key > bref2->key)
 798                 return(1);
 799         return 0;
 800 }