1 /* 2 * Copyright (c) 2007 The DragonFly Project. All rights reserved. 3 * 4 * This code is derived from software contributed to The DragonFly Project 5 * by Matthew Dillon <dillon@backplane.com> 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 11 * 1. Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * 2. Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in 15 * the documentation and/or other materials provided with the 16 * distribution. 17 * 3. Neither the name of The DragonFly Project nor the names of its 18 * contributors may be used to endorse or promote products derived 19 * from this software without specific, prior written permission. 20 * 21 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 22 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 23 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS 24 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE 25 * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, 26 * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING, 27 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 28 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED 29 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, 30 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT 31 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 32 * SUCH DAMAGE. 33 */ 34 35 #include <sys/sysctl.h> 36 #include <sys/ioctl_compat.h> 37 38 #include "hammer_util.h" 39 40 static int64_t getsize(const char *str, int64_t minval, int64_t maxval, int pw); 41 static const char *sizetostr(off_t size); 42 static void trim_volume(struct volume_info *vol); 43 static void format_volume(struct volume_info *vol, int nvols,const char *label); 44 static hammer_off_t format_root_directory(const char *label); 45 static uint64_t nowtime(void); 46 static void usage(void); 47 48 static int ForceOpt; 49 static int64_t BootAreaSize; 50 static int64_t MemAreaSize; 51 static int64_t UndoBufferSize; 52 static int HammerVersion = -1; 53 54 #define GIG (1024LL*1024*1024) 55 56 int 57 main(int ac, char **av) 58 { 59 uint32_t status; 60 off_t total; 61 off_t avg_vol_size; 62 int ch; 63 int i; 64 int nvols; 65 int eflag = 0; 66 const char *label = NULL; 67 struct volume_info *vol; 68 char *fsidstr; 69 70 /* 71 * Sanity check basic filesystem structures. No cookies for us 72 * if it gets broken! 73 */ 74 assert(sizeof(struct hammer_volume_ondisk) <= HAMMER_BUFSIZE); 75 assert(sizeof(struct hammer_blockmap_layer1) == 32); 76 assert(sizeof(struct hammer_blockmap_layer2) == 16); 77 78 /* 79 * Generate a filesystem id and lookup the filesystem type 80 */ 81 uuidgen(&Hammer_FSId, 1); 82 uuid_name_lookup(&Hammer_FSType, "DragonFly HAMMER", &status); 83 if (status != uuid_s_ok) { 84 errx(1, "uuids file does not have the DragonFly " 85 "HAMMER filesystem type"); 86 } 87 88 /* 89 * Parse arguments 90 */ 91 while ((ch = getopt(ac, av, "fEL:b:m:u:V:")) != -1) { 92 switch(ch) { 93 case 'f': 94 ForceOpt = 1; 95 break; 96 case 'E': 97 eflag = 1; 98 break; 99 case 'L': 100 label = optarg; 101 break; 102 case 'b': 103 BootAreaSize = getsize(optarg, 104 HAMMER_BUFSIZE, 105 HAMMER_BOOT_MAXBYTES, 2); 106 break; 107 case 'm': 108 MemAreaSize = getsize(optarg, 109 HAMMER_BUFSIZE, 110 HAMMER_MEM_MAXBYTES, 2); 111 break; 112 case 'u': 113 UndoBufferSize = getsize(optarg, 114 HAMMER_BIGBLOCK_SIZE, 115 HAMMER_BIGBLOCK_SIZE * 116 HAMMER_UNDO_LAYER2, 2); 117 if (UndoBufferSize < 500*1024*1024 && ForceOpt == 0) 118 errx(1, "The minimum UNDO/REDO FIFO size is " 119 "500MB\n"); 120 if (UndoBufferSize < 500*1024*1024) { 121 fprintf(stderr, 122 "WARNING: you have specified an " 123 "UNDO/REDO FIFO size less than 500MB,\n" 124 "which may lead to VFS panics.\n"); 125 } 126 break; 127 case 'V': 128 HammerVersion = strtol(optarg, NULL, 0); 129 if (HammerVersion < HAMMER_VOL_VERSION_MIN || 130 HammerVersion >= HAMMER_VOL_VERSION_WIP) { 131 errx(1, 132 "I don't understand how to format " 133 "HAMMER version %d\n", 134 HammerVersion); 135 } 136 break; 137 default: 138 usage(); 139 break; 140 } 141 } 142 143 if (label == NULL) { 144 fprintf(stderr, 145 "newfs_hammer: A filesystem label must be specified\n"); 146 usage(); 147 } 148 149 if (HammerVersion < 0) { 150 size_t olen = sizeof(HammerVersion); 151 HammerVersion = HAMMER_VOL_VERSION_DEFAULT; 152 if (sysctlbyname("vfs.hammer.supported_version", 153 &HammerVersion, &olen, NULL, 0) == 0) { 154 if (HammerVersion >= HAMMER_VOL_VERSION_WIP) { 155 HammerVersion = HAMMER_VOL_VERSION_WIP - 1; 156 fprintf(stderr, 157 "newfs_hammer: WARNING: HAMMER VFS " 158 "supports higher version than I " 159 "understand,\n" 160 "using version %d\n", 161 HammerVersion); 162 } 163 } else { 164 fprintf(stderr, 165 "newfs_hammer: WARNING: HAMMER VFS not " 166 "loaded, cannot get version info.\n" 167 "Using version %d\n", 168 HAMMER_VOL_VERSION_DEFAULT); 169 } 170 } 171 172 /* 173 * Collect volume information 174 */ 175 ac -= optind; 176 av += optind; 177 nvols = ac; 178 179 if (nvols == 0) { 180 fprintf(stderr, 181 "newfs_hammer: You must specify at least one " 182 "special file (volume)\n"); 183 exit(1); 184 } 185 186 if (nvols > HAMMER_MAX_VOLUMES) { 187 fprintf(stderr, 188 "newfs_hammer: The maximum number of volumes is %d\n", 189 HAMMER_MAX_VOLUMES); 190 exit(1); 191 } 192 193 total = 0; 194 for (i = 0; i < nvols; ++i) { 195 vol = init_volume(i, av[i], O_RDWR); 196 197 /* 198 * Load up information on the volume and initialize 199 * its remaining fields. 200 */ 201 check_volume(vol); 202 printf("Volume %d %s %-15s size %s\n", 203 vol->vol_no, vol->type, vol->name, 204 sizetostr(vol->size)); 205 206 if (eflag) { 207 if (strcmp(vol->type, "REGFILE") == 0) { 208 fprintf(stderr, "Cannot TRIM regular file %s\n", 209 vol->name); 210 exit(1); 211 } 212 213 char sysctl_name[64]; 214 int trim_enabled = 0; 215 size_t olen = sizeof(trim_enabled); 216 char *dev_name = strdup(vol->name); 217 dev_name = strtok(dev_name + strlen("/dev/da"),"s"); 218 219 sprintf(sysctl_name, "kern.cam.da.%s.trim_enabled", 220 dev_name); 221 errno=0; 222 sysctlbyname(sysctl_name, &trim_enabled, &olen, NULL, 0); 223 if(errno == ENOENT) { 224 printf("%s %s (%s) does not support the TRIM " 225 "command\n", 226 vol->type, vol->name, sysctl_name); 227 usage(); 228 } 229 if(!trim_enabled) { 230 printf("Erase device option selected, but " 231 "sysctl (%s) is not enabled\n", sysctl_name); 232 usage(); 233 234 } 235 trim_volume(vol); 236 } 237 total += vol->size; 238 } 239 240 /* 241 * Calculate defaults for the boot and memory area sizes. 242 */ 243 avg_vol_size = total / nvols; 244 BootAreaSize = init_boot_area_size(BootAreaSize, avg_vol_size); 245 MemAreaSize = init_mem_area_size(MemAreaSize, avg_vol_size); 246 247 /* 248 * Format the volumes. Format the root volume first so we can 249 * bootstrap the freemap. 250 */ 251 format_volume(get_root_volume(), nvols, label); 252 for (i = 0; i < nvols; ++i) { 253 if (i != HAMMER_ROOT_VOLNO) 254 format_volume(get_volume(i), nvols, label); 255 } 256 257 /* 258 * Print information stored in the root volume header. 259 */ 260 vol = get_root_volume(); 261 vol->cache.modified = 1; 262 uuid_to_string(&Hammer_FSId, &fsidstr, &status); 263 264 printf("---------------------------------------------\n"); 265 printf("%d volume%s total size %s version %d\n", 266 nvols, (nvols == 1 ? "" : "s"), 267 sizetostr(total), HammerVersion); 268 printf("root-volume: %s\n", vol->name); 269 printf("boot-area-size: %s\n", sizetostr(BootAreaSize)); 270 printf("memory-log-size: %s\n", sizetostr(MemAreaSize)); 271 printf("undo-buffer-size: %s\n", sizetostr(UndoBufferSize)); 272 printf("total-pre-allocated: %s\n", 273 sizetostr(vol->vol_free_off & HAMMER_OFF_SHORT_MASK)); 274 printf("fsid: %s\n", fsidstr); 275 printf("\n"); 276 printf("NOTE: Please remember that you may have to manually set up a\n" 277 "cron(8) job to prune and reblock the filesystem regularly.\n" 278 "By default, the system automatically runs 'hammer cleanup'\n" 279 "on a nightly basis. The periodic.conf(5) variable\n" 280 "'daily_clean_hammer_enable' can be unset to disable this.\n" 281 "Also see 'man hammer' and 'man HAMMER' for more information.\n"); 282 if (total < 10*GIG) { 283 printf("\nWARNING: The minimum UNDO/REDO FIFO is 500MB, you " 284 "really should not\n" 285 "try to format a HAMMER filesystem this small.\n"); 286 } 287 if (total < 50*GIG) { 288 printf("\nWARNING: HAMMER filesystems less than 50GB are " 289 "not recommended!\n" 290 "You may have to run 'hammer prune-everything' and " 291 "'hammer reblock'\n" 292 "quite often, even if using a nohistory mount.\n"); 293 } 294 flush_all_volumes(); 295 return(0); 296 } 297 298 static 299 void 300 usage(void) 301 { 302 fprintf(stderr, 303 "usage: newfs_hammer -L label [-Ef] [-b bootsize] [-m savesize] [-u undosize]\n" 304 " [-V version] special ...\n" 305 ); 306 exit(1); 307 } 308 309 /* 310 * Convert the size in bytes to a human readable string. 311 */ 312 static 313 const char * 314 sizetostr(off_t size) 315 { 316 static char buf[32]; 317 318 if (size < 1024 / 2) { 319 snprintf(buf, sizeof(buf), "%6.2f", (double)size); 320 } else if (size < 1024 * 1024 / 2) { 321 snprintf(buf, sizeof(buf), "%6.2fKB", 322 (double)size / 1024); 323 } else if (size < 1024 * 1024 * 1024LL / 2) { 324 snprintf(buf, sizeof(buf), "%6.2fMB", 325 (double)size / (1024 * 1024)); 326 } else if (size < 1024 * 1024 * 1024LL * 1024LL / 2) { 327 snprintf(buf, sizeof(buf), "%6.2fGB", 328 (double)size / (1024 * 1024 * 1024LL)); 329 } else { 330 snprintf(buf, sizeof(buf), "%6.2fTB", 331 (double)size / (1024 * 1024 * 1024LL * 1024LL)); 332 } 333 return(buf); 334 } 335 336 /* 337 * Convert a string to a 64 bit signed integer with various requirements. 338 */ 339 static int64_t 340 getsize(const char *str, int64_t minval, int64_t maxval, int powerof2) 341 { 342 int64_t val; 343 char *ptr; 344 345 val = strtoll(str, &ptr, 0); 346 switch(*ptr) { 347 case 't': 348 case 'T': 349 val *= 1024; 350 /* fall through */ 351 case 'g': 352 case 'G': 353 val *= 1024; 354 /* fall through */ 355 case 'm': 356 case 'M': 357 val *= 1024; 358 /* fall through */ 359 case 'k': 360 case 'K': 361 val *= 1024; 362 break; 363 default: 364 errx(1, "Unknown suffix in number '%s'\n", str); 365 /* not reached */ 366 } 367 if (ptr[1]) { 368 errx(1, "Unknown suffix in number '%s'\n", str); 369 /* not reached */ 370 } 371 if (val < minval) { 372 errx(1, "Value too small: %s, min is %s\n", 373 str, sizetostr(minval)); 374 /* not reached */ 375 } 376 if (val > maxval) { 377 errx(1, "Value too large: %s, max is %s\n", 378 str, sizetostr(maxval)); 379 /* not reached */ 380 } 381 if ((powerof2 & 1) && (val ^ (val - 1)) != ((val << 1) - 1)) { 382 errx(1, "Value not power of 2: %s\n", str); 383 /* not reached */ 384 } 385 if ((powerof2 & 2) && (val & HAMMER_BUFMASK)) { 386 errx(1, "Value not an integral multiple of %dK: %s", 387 HAMMER_BUFSIZE / 1024, str); 388 /* not reached */ 389 } 390 return(val); 391 } 392 393 /* 394 * Generate a transaction id. Transaction ids are no longer time-based. 395 * Put the nail in the coffin by not making the first one time-based. 396 * 397 * We could start at 1 here but start at 2^32 to reserve a small domain for 398 * possible future use. 399 */ 400 static hammer_tid_t 401 createtid(void) 402 { 403 static hammer_tid_t lasttid; 404 405 if (lasttid == 0) 406 lasttid = 0x0000000100000000ULL; 407 return(lasttid++); 408 } 409 410 static uint64_t 411 nowtime(void) 412 { 413 struct timeval tv; 414 uint64_t xtime; 415 416 gettimeofday(&tv, NULL); 417 xtime = tv.tv_sec * 1000000LL + tv.tv_usec; 418 return(xtime); 419 } 420 421 /* 422 * TRIM the volume, but only if the backing store is a DEVICE 423 */ 424 static 425 void 426 trim_volume(struct volume_info *vol) 427 { 428 if (strncmp(vol->type, "DEVICE", sizeof("DEVICE")) == 0) { 429 off_t ioarg[2]; 430 431 /* 1MB offset to prevent destroying disk-reserved area */ 432 ioarg[0] = vol->device_offset; 433 ioarg[1] = vol->size; 434 435 printf("Trimming %s %s, sectors (%llu -%llu)\n", 436 vol->type, vol->name, 437 (unsigned long long)ioarg[0]/512, 438 (unsigned long long)ioarg[1]/512); 439 440 if (ioctl(vol->fd, IOCTLTRIM, ioarg) < 0) { 441 printf("Device trim failed\n"); 442 usage (); 443 } 444 } 445 } 446 447 /* 448 * Format a HAMMER volume. 449 */ 450 static 451 void 452 format_volume(struct volume_info *vol, int nvols, const char *label) 453 { 454 struct volume_info *root_vol; 455 struct hammer_volume_ondisk *ondisk; 456 int64_t freeblks; 457 int64_t freebytes; 458 int64_t vol_buf_size; 459 hammer_off_t vol_alloc; 460 int i; 461 462 /* 463 * Initialize basic information in the on-disk volume structure. 464 */ 465 ondisk = vol->ondisk; 466 467 ondisk->vol_fsid = Hammer_FSId; 468 ondisk->vol_fstype = Hammer_FSType; 469 snprintf(ondisk->vol_name, sizeof(ondisk->vol_name), "%s", label); 470 ondisk->vol_no = vol->vol_no; 471 ondisk->vol_count = nvols; 472 ondisk->vol_version = HammerVersion; 473 474 /* 475 * Reserve space for (future) header junk, setup our poor-man's 476 * big-block allocator. 477 */ 478 vol_alloc = HAMMER_BUFSIZE * 16; /* 262144 */ 479 480 ondisk->vol_bot_beg = vol_alloc; 481 vol_alloc += BootAreaSize; 482 ondisk->vol_mem_beg = vol_alloc; 483 vol_alloc += MemAreaSize; 484 485 /* 486 * The remaining area is the zone 2 buffer allocation area. 487 */ 488 ondisk->vol_buf_beg = vol_alloc; 489 ondisk->vol_buf_end = vol->size & ~(int64_t)HAMMER_BUFMASK; 490 vol_buf_size = ondisk->vol_buf_end - ondisk->vol_buf_beg; 491 492 if (vol_buf_size < 0) { 493 errx(1, "volume %d %s is too small to hold the volume header", 494 vol->vol_no, vol->name); 495 } 496 497 ondisk->vol_nblocks = vol_buf_size / HAMMER_BUFSIZE; 498 ondisk->vol_blocksize = HAMMER_BUFSIZE; 499 500 ondisk->vol_rootvol = HAMMER_ROOT_VOLNO; 501 ondisk->vol_signature = HAMMER_FSBUF_VOLUME; 502 503 vol->vol_free_off = HAMMER_ENCODE_RAW_BUFFER(vol->vol_no, 0); 504 vol->vol_free_end = HAMMER_ENCODE_RAW_BUFFER(vol->vol_no, 505 vol_buf_size & ~HAMMER_BIGBLOCK_MASK64); 506 507 /* 508 * Format the root volume. 509 */ 510 if (vol->vol_no == HAMMER_ROOT_VOLNO) { 511 /* 512 * Check freemap counts before formatting 513 */ 514 freeblks = count_freemap(vol); 515 freebytes = freeblks * HAMMER_BIGBLOCK_SIZE64; 516 if (freebytes < 10*GIG && ForceOpt == 0) { 517 errx(1, "Cannot create a HAMMER filesystem less than 10GB " 518 "unless you use -f\n(for the size of Volume %d). " 519 "HAMMER filesystems less than 50GB are not " 520 "recommended.\n", HAMMER_ROOT_VOLNO); 521 } 522 523 /* 524 * Starting TID 525 */ 526 ondisk->vol0_next_tid = createtid(); 527 528 /* 529 * Format freemap. vol0_stat_freebigblocks is 530 * the number of big-blocks available for anything 531 * other than freemap zone at this point. 532 */ 533 format_freemap(vol); 534 assert(ondisk->vol0_stat_freebigblocks == 0); 535 ondisk->vol0_stat_freebigblocks = initialize_freemap(vol); 536 537 /* 538 * Format zones that are mapped to zone-2. 539 */ 540 for (i = 0; i < HAMMER_MAX_ZONES; ++i) { 541 if (hammer_is_zone2_mapped_index(i)) 542 format_blockmap(vol, i, 0); 543 } 544 545 /* 546 * Format undo zone. Formatting decrements 547 * vol0_stat_freebigblocks whenever a new big-block 548 * is allocated for undo zone. 549 */ 550 format_undomap(vol, &UndoBufferSize); 551 assert(ondisk->vol0_stat_bigblocks == 0); 552 ondisk->vol0_stat_bigblocks = ondisk->vol0_stat_freebigblocks; 553 554 /* 555 * Format the root directory. Formatting decrements 556 * vol0_stat_freebigblocks whenever a new big-block 557 * is allocated for required zones. 558 */ 559 ondisk->vol0_btree_root = format_root_directory(label); 560 ++ondisk->vol0_stat_inodes; /* root inode */ 561 562 rel_volume(vol); 563 } else { 564 freeblks = initialize_freemap(vol); 565 root_vol = get_root_volume(); 566 root_vol->cache.modified = 1; 567 root_vol->ondisk->vol0_stat_freebigblocks += freeblks; 568 root_vol->ondisk->vol0_stat_bigblocks += freeblks; 569 rel_volume(root_vol); 570 } 571 } 572 573 /* 574 * Format the root directory. 575 */ 576 static 577 hammer_off_t 578 format_root_directory(const char *label) 579 { 580 hammer_off_t btree_off; 581 hammer_off_t pfsd_off; 582 hammer_off_t data_off; 583 hammer_tid_t create_tid; 584 hammer_node_ondisk_t bnode; 585 struct hammer_inode_data *idata; 586 hammer_pseudofs_data_t pfsd; 587 struct buffer_info *data_buffer0 = NULL; 588 struct buffer_info *data_buffer1 = NULL; 589 struct buffer_info *data_buffer2 = NULL; 590 hammer_btree_elm_t elm; 591 uint64_t xtime; 592 593 /* 594 * Allocate zero-filled root btree node, inode and pfs 595 */ 596 bnode = alloc_btree_element(&btree_off, &data_buffer0); 597 idata = alloc_meta_element(&data_off, sizeof(*idata), &data_buffer1); 598 pfsd = alloc_meta_element(&pfsd_off, sizeof(*pfsd), &data_buffer2); 599 create_tid = createtid(); 600 xtime = nowtime(); 601 602 /* 603 * Populate the inode data and inode record for the root directory. 604 */ 605 idata->version = HAMMER_INODE_DATA_VERSION; 606 idata->mode = 0755; 607 idata->ctime = xtime; 608 idata->mtime = xtime; 609 idata->atime = xtime; 610 idata->obj_type = HAMMER_OBJTYPE_DIRECTORY; 611 idata->size = 0; 612 idata->nlinks = 1; 613 if (HammerVersion >= HAMMER_VOL_VERSION_TWO) 614 idata->cap_flags |= HAMMER_INODE_CAP_DIR_LOCAL_INO; 615 if (HammerVersion >= HAMMER_VOL_VERSION_SIX) 616 idata->cap_flags |= HAMMER_INODE_CAP_DIRHASH_ALG1; 617 618 /* 619 * Populate the PFS data for the root PFS. 620 */ 621 pfsd->sync_low_tid = 1; 622 pfsd->sync_beg_tid = 0; 623 pfsd->sync_end_tid = 0; /* overriden by vol0_next_tid on pfs0 */ 624 pfsd->shared_uuid = Hammer_FSId; 625 pfsd->unique_uuid = Hammer_FSId; 626 pfsd->reserved01 = 0; 627 pfsd->mirror_flags = 0; 628 snprintf(pfsd->label, sizeof(pfsd->label), "%s", label); 629 630 /* 631 * Create the root of the B-Tree. The root is a leaf node so we 632 * do not have to worry about boundary elements. 633 */ 634 bnode->count = 2; 635 bnode->type = HAMMER_BTREE_TYPE_LEAF; 636 637 /* 638 * Create the first node element for the inode. 639 */ 640 elm = &bnode->elms[0]; 641 elm->leaf.base.btype = HAMMER_BTREE_TYPE_RECORD; 642 elm->leaf.base.localization = HAMMER_DEF_LOCALIZATION | 643 HAMMER_LOCALIZE_INODE; 644 elm->leaf.base.obj_id = HAMMER_OBJID_ROOT; 645 elm->leaf.base.key = 0; 646 elm->leaf.base.create_tid = create_tid; 647 elm->leaf.base.delete_tid = 0; 648 elm->leaf.base.rec_type = HAMMER_RECTYPE_INODE; 649 elm->leaf.base.obj_type = HAMMER_OBJTYPE_DIRECTORY; 650 elm->leaf.create_ts = (uint32_t)time(NULL); 651 652 elm->leaf.data_offset = data_off; 653 elm->leaf.data_len = sizeof(*idata); 654 elm->leaf.data_crc = crc32(idata, HAMMER_INODE_CRCSIZE); 655 656 /* 657 * Create the second node element for the PFS data. 658 */ 659 elm = &bnode->elms[1]; 660 elm->leaf.base.btype = HAMMER_BTREE_TYPE_RECORD; 661 elm->leaf.base.localization = HAMMER_DEF_LOCALIZATION | 662 HAMMER_LOCALIZE_MISC; 663 elm->leaf.base.obj_id = HAMMER_OBJID_ROOT; 664 elm->leaf.base.key = 0; 665 elm->leaf.base.create_tid = create_tid; 666 elm->leaf.base.delete_tid = 0; 667 elm->leaf.base.rec_type = HAMMER_RECTYPE_PFS; 668 elm->leaf.base.obj_type = 0; 669 elm->leaf.create_ts = (uint32_t)time(NULL); 670 671 elm->leaf.data_offset = pfsd_off; 672 elm->leaf.data_len = sizeof(*pfsd); 673 elm->leaf.data_crc = crc32(pfsd, sizeof(*pfsd)); 674 675 bnode->crc = crc32(&bnode->crc + 1, HAMMER_BTREE_CRCSIZE); 676 677 return(btree_off); 678 } 679