2 * Copyright (c) 2011-2015 The DragonFly Project. All rights reserved.
4 * This code is derived from software contributed to The DragonFly Project
5 * by Matthew Dillon <dillon@dragonflybsd.org>
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
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
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.
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
35 #include <sys/types.h>
36 #include <sys/diskslice.h>
37 #include <sys/diskmbr.h>
40 #include <sys/sysctl.h>
41 #include <vfs/hammer2/hammer2_xxhash.h>
42 #include <vfs/hammer2/hammer2_disk.h>
56 #define MAXLABELS HAMMER2_SET_COUNT
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
);
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);
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
,
74 static hammer2_key_t
dirhash(const unsigned char *name
, size_t len
);
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
;
89 #define GIG ((hammer2_off_t)1024*1024*1024)
92 main(int ac
, char **av
)
95 hammer2_off_t total_space
;
96 hammer2_off_t free_space
;
97 hammer2_off_t reserved_space
;
101 int defaultlabels
= 1;
108 Label
[NLabels
++] = "LOCAL";
111 * Sanity check basic filesystem structures. No cookies for us
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
);
119 * Generate a filesystem id and lookup the filesystem type
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");
135 while ((ch
= getopt(ac
, av
, "fL:b:m:r:V:")) != -1) {
142 if (strcasecmp(optarg
, "none") == 0) {
145 if (NLabels
>= MAXLABELS
) {
147 "Limit of %d local labels",
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
);
157 BootAreaSize
= getsize(optarg
,
159 HAMMER2_BOOT_MAX_BYTES
, 2);
162 AuxAreaSize
= getsize(optarg
,
164 HAMMER2_REDO_MAX_BYTES
, 2);
167 Hammer2Version
= strtol(optarg
, NULL
, 0);
168 if (Hammer2Version
< HAMMER2_VOL_VERSION_MIN
||
169 Hammer2Version
>= HAMMER2_VOL_VERSION_WIP
) {
171 "I don't understand how to format "
172 "HAMMER2 version %d\n",
183 * Check Hammer2 version
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;
193 "newfs_hammer2: WARNING: HAMMER2 VFS "
194 "supports higher version than I "
196 "using version %d\n",
201 "newfs_hammer2: WARNING: HAMMER2 VFS not "
202 "loaded, cannot get version info.\n"
203 "Using version %d\n",
204 HAMMER2_VOL_VERSION_DEFAULT
);
211 if (ac
!= 1 || av
[0][0] == 0) {
212 fprintf(stderr
, "Exactly one disk device must be specified\n");
217 * Adjust Label[] and NLabels.
220 char c
= av
[0][strlen(av
[0]) - 1];
222 Label
[NLabels
++] = "BOOT";
224 Label
[NLabels
++] = "ROOT";
226 Label
[NLabels
++] = "DATA";
230 * Collect volume information.
232 total_space
= check_volume(av
[0], &fd
);
235 * ~typically 8MB alignment to avoid edge cases for reserved blocks
236 * and so raid stripes (if any) operate efficiently.
238 total_space
&= ~HAMMER2_VOLUME_ALIGNMASK64
;
241 * Calculate defaults for the boot area size and round to the
242 * volume alignment boundary.
244 * NOTE: These areas are currently not used for booting but are
245 * reserved for future filesystem expansion.
247 if (BootAreaSize
== 0) {
248 BootAreaSize
= HAMMER2_BOOT_NOM_BYTES
;
249 while (BootAreaSize
> total_space
/ 20)
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
;
256 BootAreaSize
= (BootAreaSize
+ HAMMER2_VOLUME_ALIGNMASK64
) &
257 ~HAMMER2_VOLUME_ALIGNMASK64
;
260 * Calculate defaults for the redo area size and round to the
261 * volume alignment boundary.
263 * NOTE: These areas are currently not used for logging but are
264 * reserved for future filesystem expansion.
266 if (AuxAreaSize
== 0) {
267 AuxAreaSize
= HAMMER2_REDO_NOM_BYTES
;
268 while (AuxAreaSize
> total_space
/ 20)
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
;
275 AuxAreaSize
= (AuxAreaSize
+ HAMMER2_VOLUME_ALIGNMASK64
) &
276 ~HAMMER2_VOLUME_ALIGNMASK64
;
279 * We'll need to stuff this in the volume header soon.
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
);
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.
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
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
299 reserved_space
= ((total_space
+ HAMMER2_FREEMAP_LEVEL1_MASK
) /
300 HAMMER2_FREEMAP_LEVEL1_SIZE
) * HAMMER2_ZONE_SEG64
;
302 free_space
= total_space
- reserved_space
-
303 BootAreaSize
- AuxAreaSize
;
305 format_hammer2(fd
, total_space
, free_space
);
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
);
338 "usage: newfs_hammer2 -L label [-f] [-b bootsize] "
339 "[-r redosize] [-V version] special ...\n"
345 * Convert the size in bytes to a human readable string.
349 sizetostr(hammer2_off_t size
)
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));
365 snprintf(buf
, sizeof(buf
), "%6.2fTB",
366 (double)size
/ (1024 * 1024 * 1024LL * 1024LL));
372 * Convert a string to a 64 bit signed integer with various requirements.
375 getsize(const char *str
, int64_t minval
, int64_t maxval
, int powerof2
)
380 val
= strtoll(str
, &ptr
, 0);
399 errx(1, "Unknown suffix in number '%s'\n", str
);
403 errx(1, "Unknown suffix in number '%s'\n", str
);
407 errx(1, "Value too small: %s, min is %s\n",
408 str
, sizetostr(minval
));
412 errx(1, "Value too large: %s, max is %s\n",
413 str
, sizetostr(maxval
));
416 if ((powerof2
& 1) && (val
^ (val
- 1)) != ((val
<< 1) - 1)) {
417 errx(1, "Value not power of 2: %s\n", str
);
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
);
434 gettimeofday(&tv
, NULL
);
435 xtime
= tv
.tv_sec
* 1000000LL + tv
.tv_usec
;
440 * Figure out how big the volume is.
444 check_volume(const char *path
, int *fdp
)
446 struct partinfo pinfo
;
451 * Get basic information about the volume
453 *fdp
= open(path
, O_RDWR
);
455 err(1, "Unable to open %s R+W", path
);
456 if (ioctl(*fdp
, DIOCGPART
, &pinfo
) < 0) {
458 * Allow the formatting of regular files as HAMMER2 volumes
460 if (fstat(*fdp
, &st
) < 0)
461 err(1, "Unable to stat %s", path
);
462 if (!S_ISREG(st
.st_mode
))
463 errx(1, "Unsupported file type for %s", path
);
467 * When formatting a block device as a HAMMER2 volume the
468 * sector size must be compatible. HAMMER2 uses 64K
469 * filesystem buffers but logical buffers for direct I/O
470 * can be as small as HAMMER2_LOGSIZE (16KB).
472 if (pinfo
.reserved_blocks
) {
473 errx(1, "HAMMER2 cannot be placed in a partition "
474 "which overlaps the disklabel or MBR");
476 if (pinfo
.media_blksize
> HAMMER2_PBUFSIZE
||
477 HAMMER2_PBUFSIZE
% pinfo
.media_blksize
) {
478 errx(1, "A media sector size of %d is not supported",
479 pinfo
.media_blksize
);
481 size
= pinfo
.media_size
;
483 printf("Volume %-15s size %s\n", path
, sizetostr(size
));
488 * Create the volume header, the super-root directory inode, and
489 * the writable snapshot subdirectory (named via the label) which
490 * is to be the initial mount point, or at least the first mount point.
492 * [----reserved_area----][boot_area][aux_area]
493 * [[vol_hdr]... ] [sroot][root]...
495 * The sroot and root inodes eat 512 bytes each. newfs labels can only be
496 * 64 bytes so the root (snapshot) inode does not need to extend past 512
497 * bytes. We use the correct hash slot correct but note that because
498 * directory hashes are chained 16x, any slot in the inode will work.
500 * Also format the allocation map.
502 * NOTE: The passed total_space is 8MB-aligned to avoid edge cases.
506 format_hammer2(int fd
, hammer2_off_t total_space
, hammer2_off_t free_space
)
508 char *buf
= malloc(HAMMER2_PBUFSIZE
);
509 hammer2_volume_data_t
*vol
;
510 hammer2_inode_data_t
*rawip
;
511 hammer2_blockref_t sroot_blockref
;
512 hammer2_blockref_t root_blockref
[MAXLABELS
];
514 hammer2_off_t volu_base
= 0;
515 hammer2_off_t boot_base
= HAMMER2_ZONE_SEG
;
516 hammer2_off_t aux_base
= boot_base
+ BootAreaSize
;
517 hammer2_off_t alloc_base
= aux_base
+ AuxAreaSize
;
518 hammer2_off_t tmp_base
;
523 * Clear the entire reserve for the first 2G segment and
524 * make sure we can write to the last block.
526 bzero(buf
, HAMMER2_PBUFSIZE
);
527 tmp_base
= volu_base
;
528 for (i
= 0; i
< HAMMER2_ZONE_BLOCKS_SEG
; ++i
) {
529 n
= pwrite(fd
, buf
, HAMMER2_PBUFSIZE
, tmp_base
);
530 if (n
!= HAMMER2_PBUFSIZE
) {
534 tmp_base
+= HAMMER2_PBUFSIZE
;
537 n
= pwrite(fd
, buf
, HAMMER2_PBUFSIZE
,
538 volu_base
+ total_space
- HAMMER2_PBUFSIZE
);
539 if (n
!= HAMMER2_PBUFSIZE
) {
540 perror("write (at-end-of-volume)");
545 * Make sure alloc_base won't cross the reserved area at the
546 * beginning of each 2GB zone.
548 * Reserve space for the super-root inode and the root inode.
549 * Make sure they are in the same 64K block to simplify our code.
551 assert((alloc_base
& HAMMER2_PBUFMASK
) == 0);
552 assert(alloc_base
< HAMMER2_ZONE_BYTES64
- HAMMER2_ZONE_SEG
);
554 bzero(buf
, HAMMER2_PBUFSIZE
);
556 alloc_base
&= ~HAMMER2_PBUFMASK64
;
557 alloc_direct(&alloc_base
, &sroot_blockref
, HAMMER2_INODE_BYTES
);
559 for (i
= 0; i
< NLabels
; ++i
) {
560 uuidgen(&Hammer2_PfsCLID
[i
], 1);
561 uuidgen(&Hammer2_PfsFSID
[i
], 1);
563 alloc_direct(&alloc_base
, &root_blockref
[i
],
564 HAMMER2_INODE_BYTES
);
565 assert(((sroot_blockref
.data_off
^ root_blockref
[i
].data_off
) &
566 HAMMER2_OFF_MASK_HI
) == 0);
569 * Format the root directory inode, which is left empty.
571 rawip
= (void *)(buf
+ (HAMMER2_OFF_MASK_LO
&
572 root_blockref
[i
].data_off
));
573 rawip
->meta
.version
= HAMMER2_INODE_VERSION_ONE
;
574 rawip
->meta
.ctime
= now
;
575 rawip
->meta
.mtime
= now
;
576 /* rawip->atime = now; NOT IMPL MUST BE ZERO */
577 rawip
->meta
.btime
= now
;
578 rawip
->meta
.type
= HAMMER2_OBJTYPE_DIRECTORY
;
579 rawip
->meta
.mode
= 0755;
580 rawip
->meta
.inum
= 1; /* root inode, inumber 1 */
581 rawip
->meta
.nlinks
= 1; /* directory link count compat */
583 rawip
->meta
.name_len
= strlen(Label
[i
]);
584 bcopy(Label
[i
], rawip
->filename
, rawip
->meta
.name_len
);
585 rawip
->meta
.name_key
=
586 dirhash(rawip
->filename
, rawip
->meta
.name_len
);
589 * Compression mode and supported copyids.
591 * Do not allow compression when creating any "BOOT" label
592 * (pfs-create also does the same if the pfs is named "BOOT")
594 if (strcasecmp(Label
[i
], "BOOT") == 0) {
595 rawip
->meta
.comp_algo
= HAMMER2_ENC_ALGO(
596 HAMMER2_COMP_AUTOZERO
);
597 rawip
->meta
.check_algo
= HAMMER2_ENC_ALGO(
598 HAMMER2_CHECK_XXHASH64
);
600 rawip
->meta
.comp_algo
= HAMMER2_ENC_ALGO(
601 HAMMER2_COMP_NEWFS_DEFAULT
);
602 rawip
->meta
.check_algo
= HAMMER2_ENC_ALGO(
603 HAMMER2_CHECK_XXHASH64
);
607 * NOTE: We leave nmasters set to 0, which means that we
608 * don't know how many masters there are. The quorum
609 * calculation will effectively be 1 ( 0 / 2 + 1 ).
611 rawip
->meta
.pfs_clid
= Hammer2_PfsCLID
[i
];
612 rawip
->meta
.pfs_fsid
= Hammer2_PfsFSID
[i
];
613 rawip
->meta
.pfs_type
= HAMMER2_PFSTYPE_MASTER
;
614 rawip
->meta
.op_flags
|= HAMMER2_OPFLAG_PFSROOT
;
616 /* first allocatable inode number */
617 rawip
->meta
.pfs_inum
= 16;
619 /* rawip->u.blockset is left empty */
622 * The root blockref will be stored in the super-root inode as
623 * the only directory entry. The copyid here is the actual
624 * copyid of the storage ref.
626 * The key field for a directory entry's blockref is
627 * essentially the name key for the entry.
629 root_blockref
[i
].key
= rawip
->meta
.name_key
;
630 root_blockref
[i
].copyid
= HAMMER2_COPYID_LOCAL
;
631 root_blockref
[i
].keybits
= 0;
632 root_blockref
[i
].check
.xxhash64
.value
=
633 XXH64(rawip
, sizeof(*rawip
), XXH_HAMMER2_SEED
);
634 root_blockref
[i
].type
= HAMMER2_BREF_TYPE_INODE
;
635 root_blockref
[i
].methods
=
636 HAMMER2_ENC_CHECK(HAMMER2_CHECK_XXHASH64
) |
637 HAMMER2_ENC_COMP(HAMMER2_COMP_NONE
);
638 root_blockref
[i
].mirror_tid
= 16;
639 root_blockref
[i
].flags
= HAMMER2_BREF_FLAG_PFSROOT
;
643 * Format the super-root directory inode, giving it one directory
644 * entry (root_blockref) and fixup the icrc method.
646 * The superroot contains one directory entry pointing at the root
647 * inode (named via the label). Inodes contain one blockset which
648 * is fully associative so we can put the entry anywhere without
649 * having to worry about the hash. Use index 0.
651 rawip
= (void *)(buf
+ (HAMMER2_OFF_MASK_LO
& sroot_blockref
.data_off
));
652 rawip
->meta
.version
= HAMMER2_INODE_VERSION_ONE
;
653 rawip
->meta
.ctime
= now
;
654 rawip
->meta
.mtime
= now
;
655 /* rawip->meta.atime = now; NOT IMPL MUST BE ZERO */
656 rawip
->meta
.btime
= now
;
657 rawip
->meta
.type
= HAMMER2_OBJTYPE_DIRECTORY
;
658 rawip
->meta
.mode
= 0700; /* super-root - root only */
659 rawip
->meta
.inum
= 0; /* super root inode, inumber 0 */
660 rawip
->meta
.nlinks
= 2; /* directory link count compat */
662 rawip
->meta
.name_len
= 0; /* super-root is unnamed */
663 rawip
->meta
.name_key
= 0;
665 rawip
->meta
.comp_algo
= HAMMER2_ENC_ALGO(HAMMER2_COMP_AUTOZERO
);
666 rawip
->meta
.check_algo
= HAMMER2_ENC_ALGO(HAMMER2_CHECK_XXHASH64
);
669 * The super-root is flagged as a PFS and typically given its own
670 * random FSID, making it possible to mirror an entire HAMMER2 disk
671 * snapshots and all if desired. PFS ids are used to match up
672 * mirror sources and targets and cluster copy sources and targets.
674 * (XXX whole-disk logical mirroring is not really supported in
675 * the first attempt because each PFS is in its own modify/mirror
676 * transaction id domain, so normal mechanics cannot cross a PFS
679 rawip
->meta
.pfs_clid
= Hammer2_SupCLID
;
680 rawip
->meta
.pfs_fsid
= Hammer2_SupFSID
;
681 rawip
->meta
.pfs_type
= HAMMER2_PFSTYPE_SUPROOT
;
682 snprintf((char*)rawip
->filename
, sizeof(rawip
->filename
), "SUPROOT");
683 rawip
->meta
.name_key
= 0;
684 rawip
->meta
.name_len
= strlen((char*)rawip
->filename
);
686 /* The super-root has an inode number of 0 */
687 rawip
->meta
.pfs_inum
= 0;
690 * Currently newfs_hammer2 just throws the PFS inodes into the
691 * top-level block table at the volume root and doesn't try to
692 * create an indirect block, so we are limited to ~4 at filesystem
693 * creation time. More can be added after mounting.
695 qsort(root_blockref
, NLabels
, sizeof(root_blockref
[0]), blkrefary_cmp
);
696 for (i
= 0; i
< NLabels
; ++i
)
697 rawip
->u
.blockset
.blockref
[i
] = root_blockref
[i
];
700 * The sroot blockref will be stored in the volume header.
702 sroot_blockref
.copyid
= HAMMER2_COPYID_LOCAL
;
703 sroot_blockref
.keybits
= 0;
704 sroot_blockref
.check
.xxhash64
.value
=
705 XXH64(rawip
, sizeof(*rawip
), XXH_HAMMER2_SEED
);
706 sroot_blockref
.type
= HAMMER2_BREF_TYPE_INODE
;
707 sroot_blockref
.methods
= HAMMER2_ENC_CHECK(HAMMER2_CHECK_XXHASH64
) |
708 HAMMER2_ENC_COMP(HAMMER2_COMP_AUTOZERO
);
709 sroot_blockref
.mirror_tid
= 16;
713 * Write out the 64K HAMMER2 block containing the root and sroot.
715 n
= pwrite(fd
, buf
, HAMMER2_PBUFSIZE
,
716 sroot_blockref
.data_off
& HAMMER2_OFF_MASK_HI
);
717 if (n
!= HAMMER2_PBUFSIZE
) {
723 * Format the volume header.
725 * The volume header points to sroot_blockref. Also be absolutely
726 * sure that allocator_beg is set.
728 bzero(buf
, HAMMER2_PBUFSIZE
);
731 vol
->magic
= HAMMER2_VOLUME_ID_HBO
;
732 vol
->boot_beg
= boot_base
;
733 vol
->boot_end
= boot_base
+ BootAreaSize
;
734 vol
->aux_beg
= aux_base
;
735 vol
->aux_end
= aux_base
+ AuxAreaSize
;
736 vol
->volu_size
= total_space
;
737 vol
->version
= Hammer2Version
;
740 vol
->fsid
= Hammer2_VolFSID
;
741 vol
->fstype
= Hammer2_FSType
;
743 vol
->peer_type
= DMSG_PEER_HAMMER2
; /* LNK_CONN identification */
745 vol
->allocator_size
= free_space
;
746 vol
->allocator_free
= free_space
;
747 vol
->allocator_beg
= alloc_base
;
749 vol
->sroot_blockset
.blockref
[0] = sroot_blockref
;
750 vol
->mirror_tid
= 16; /* all blockref mirror TIDs set to 16 */
751 vol
->freemap_tid
= 16; /* all blockref mirror TIDs set to 16 */
752 vol
->icrc_sects
[HAMMER2_VOL_ICRC_SECT1
] =
753 hammer2_icrc32((char *)vol
+ HAMMER2_VOLUME_ICRC1_OFF
,
754 HAMMER2_VOLUME_ICRC1_SIZE
);
757 * Set ICRC_SECT0 after all remaining elements of sect0 have been
758 * populated in the volume header. Note hat ICRC_SECT* (except for
759 * SECT0) are part of sect0.
761 vol
->icrc_sects
[HAMMER2_VOL_ICRC_SECT0
] =
762 hammer2_icrc32((char *)vol
+ HAMMER2_VOLUME_ICRC0_OFF
,
763 HAMMER2_VOLUME_ICRC0_SIZE
);
764 vol
->icrc_volheader
=
765 hammer2_icrc32((char *)vol
+ HAMMER2_VOLUME_ICRCVH_OFF
,
766 HAMMER2_VOLUME_ICRCVH_SIZE
);
769 * Write the volume header and all alternates.
771 for (i
= 0; i
< HAMMER2_NUM_VOLHDRS
; ++i
) {
772 if (i
* HAMMER2_ZONE_BYTES64
>= total_space
)
774 n
= pwrite(fd
, buf
, HAMMER2_PBUFSIZE
,
775 volu_base
+ i
* HAMMER2_ZONE_BYTES64
);
776 if (n
!= HAMMER2_PBUFSIZE
) {
789 alloc_direct(hammer2_off_t
*basep
, hammer2_blockref_t
*bref
, size_t bytes
)
795 while ((bytes
& 1) == 0) {
800 if (radix
< HAMMER2_RADIX_MIN
)
801 radix
= HAMMER2_RADIX_MIN
;
803 bzero(bref
, sizeof(*bref
));
804 bref
->data_off
= *basep
| radix
;
805 bref
->vradix
= radix
;
807 *basep
+= 1U << radix
;
811 * Borrow HAMMER1's directory hash algorithm #1 with a few modifications.
812 * The filename is split into fields which are hashed separately and then
815 * Differences include: bit 63 must be set to 1 for HAMMER2 (HAMMER1 sets
816 * it to 0), this is because bit63=0 is used for hidden hardlinked inodes.
817 * (This means we do not need to do a 0-check/or-with-0x100000000 either).
819 * Also, the iscsi crc code is used instead of the old crc32 code.
822 dirhash(const unsigned char *name
, size_t len
)
824 const unsigned char *aname
= name
;
831 * Filesystem version 6 or better will create directories
832 * using the ALG1 dirhash. This hash breaks the filename
833 * up into domains separated by special characters and
834 * hashes each domain independently.
836 * We also do a simple sub-sort using the first character
837 * of the filename in the top 5-bits.
845 for (i
= j
= 0; i
< len
; ++i
) {
846 if (aname
[i
] == '.' ||
851 crcx
+= hammer2_icrc32(aname
+ j
, i
- j
);
856 crcx
+= hammer2_icrc32(aname
+ j
, i
- j
);
859 * The directory hash utilizes the top 32 bits of the 64-bit key.
860 * Bit 63 must be set to 1.
863 key
|= (uint64_t)crcx
<< 32;
866 * l16 - crc of entire filename
868 * This crc reduces degenerate hash collision conditions
870 crcx
= hammer2_icrc32(aname
, len
);
871 crcx
= crcx
^ (crcx
<< 16);
872 key
|= crcx
& 0xFFFF0000U
;
875 * Set bit 15. This allows readdir to strip bit 63 so a positive
876 * 64-bit cookie/offset can always be returned, and still guarantee
877 * that the values 0x0000-0x7FFF are available for artificial entries.
886 blkrefary_cmp(const void *b1
, const void *b2
)
888 const hammer2_blockref_t
*bref1
= b1
;
889 const hammer2_blockref_t
*bref2
= b2
;
890 if (bref1
->key
< bref2
->key
)
892 if (bref1
->key
> bref2
->key
)