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