/*
 * Copyright (c) 2007 The DragonFly Project.  All rights reserved.
 *
 * This code is derived from software contributed to The DragonFly Project
 * by Matthew Dillon <dillon@backplane.com>
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 * 3. Neither the name of The DragonFly Project nor the names of its
 *    contributors may be used to endorse or promote products derived
 *    from this software without specific, prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
 * FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE
 * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
 * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

#include "hammer_util.h"

#include <sys/sysctl.h>

#include <bus/cam/scsi/scsi_daio.h>

static int64_t getsize(const char *str, int pw);
static int trim_volume(volume_info_t volume);
static void format_volume(volume_info_t volume, int nvols,const char *label);
static hammer_off_t format_root_directory(const char *label);
static uint64_t nowtime(void);
static void print_volume(const volume_info_t volume);
static void usage(int exit_code);
static void test_header_junk_size(int64_t size);
static void test_boot_area_size(int64_t size);
static void test_memory_log_size(int64_t size);
static void test_undo_buffer_size(int64_t size);

static int ForceOpt;
static int64_t HeaderJunkSize = -1;
static int64_t BootAreaSize = -1;
static int64_t MemoryLogSize = -1;
static int64_t UndoBufferSize;

#define GIG	(1024LL*1024*1024)

int
main(int ac, char **av)
{
	off_t total;
	off_t avg_vol_size;
	int ch;
	int i;
	int nvols;
	int eflag = 0;
	const char *label = NULL;
	volume_info_t volume;

	/*
	 * Sanity check basic filesystem structures.  No cookies for us
	 * if it gets broken!
	 */
	assert(sizeof(struct hammer_volume_ondisk) <= HAMMER_BUFSIZE);
	assert(sizeof(struct hammer_volume_ondisk) <= HAMMER_MIN_VOL_JUNK);
	assert(sizeof(struct hammer_blockmap_layer1) == 32);
	assert(sizeof(struct hammer_blockmap_layer2) == 16);

	/*
	 * Parse arguments
	 */
	while ((ch = getopt(ac, av, "dfEL:j:b:m:u:hC:V:")) != -1) {
		switch(ch) {
		case 'd':
			++DebugOpt;
			break;
		case 'f':
			ForceOpt = 1;
			break;
		case 'E':
			eflag = 1;
			break;
		case 'L':
			label = optarg;
			break;
		case 'j': /* Not mentioned in newfs_hammer(8) */
			HeaderJunkSize = getsize(optarg, 2);
			test_header_junk_size(HeaderJunkSize);
			break;
		case 'b':
			BootAreaSize = getsize(optarg, 2);
			test_boot_area_size(BootAreaSize);
			break;
		case 'm':
			MemoryLogSize = getsize(optarg, 2);
			test_memory_log_size(MemoryLogSize);
			break;
		case 'u':
			UndoBufferSize = getsize(optarg, 2);
			test_undo_buffer_size(UndoBufferSize);
			break;
		case 'h':
			usage(0);
			/* not reached */
			break;
		case 'C':
			if (hammer_parse_cache_size(optarg) == -1) {
				usage(1);
				/* not reached */
			}
			break;
		case 'V':
			HammerVersion = strtol(optarg, NULL, 0);
			if (HammerVersion < HAMMER_VOL_VERSION_MIN ||
			    HammerVersion >= HAMMER_VOL_VERSION_WIP) {
				errx(1,
				     "I don't understand how to format "
				     "HAMMER version %d",
				     HammerVersion);
				/* not reached */
			}
			break;
		default:
			usage(1);
			/* not reached */
			break;
		}
	}
	ac -= optind;
	av += optind;
	nvols = ac;

	if (HammerVersion == (uint32_t)-1) {
		size_t olen = sizeof(HammerVersion);
		HammerVersion = HAMMER_VOL_VERSION_DEFAULT;

		if (sysctlbyname("vfs.hammer.supported_version",
				 &HammerVersion, &olen, NULL, 0)) {
			hwarn("HAMMER VFS not loaded, cannot get version info, "
				"using version %d",
				HammerVersion);
		} else if (HammerVersion >= HAMMER_VOL_VERSION_WIP) {
			HammerVersion = HAMMER_VOL_VERSION_WIP - 1;
			hwarnx("HAMMER VFS supports higher version than "
				"I understand, using version %d",
				HammerVersion);
		}
	}

	if (nvols == 0) {
		errx(1, "You must specify at least one special file (volume)");
		/* not reached */
	}
	if (nvols > HAMMER_MAX_VOLUMES) {
		errx(1, "The maximum number of volumes is %d",
			HAMMER_MAX_VOLUMES);
		/* not reached */
	}

	if (label == NULL) {
		hwarnx("A filesystem label must be specified");
		usage(1);
		/* not reached */
	}

	/*
	 * Generate a filesystem id and lookup the filesystem type
	 */
	hammer_uuid_create(&Hammer_FSId);
	if (hammer_uuid_name_lookup(&Hammer_FSType, HAMMER_FSTYPE_STRING)) {
		errx(1, "uuids file does not have the DragonFly "
			"HAMMER filesystem type");
		/* not reached */
	}

	total = 0;
	for (i = 0; i < nvols; ++i) {
		volume = init_volume(av[i], O_RDWR, i);
		printf("Volume %d %s %-15s size %s\n",
			volume->vol_no, volume->type, volume->name,
			sizetostr(volume->size));

		if (eflag) {
			if (trim_volume(volume) == -1 && ForceOpt == 0) {
				errx(1, "Use -f option to proceed");
				/* not reached */
			}
		}
		total += volume->size;
	}

	/*
	 * Reserve space for (future) header junk, setup our poor-man's
	 * big-block allocator.  Note that the header junk space includes
	 * volume header which is 1928 bytes.
	 */
	if (HeaderJunkSize == -1)
		HeaderJunkSize = HAMMER_VOL_JUNK_SIZE;
	else if (HeaderJunkSize < (int64_t)sizeof(struct hammer_volume_ondisk))
		HeaderJunkSize = sizeof(struct hammer_volume_ondisk);
	HeaderJunkSize = HAMMER_BUFSIZE_DOALIGN(HeaderJunkSize);

	/*
	 * Calculate defaults for the boot area and memory log sizes,
	 * only if not specified by -b or -m option.
	 */
	avg_vol_size = total / nvols;
	if (BootAreaSize == -1)
		BootAreaSize = init_boot_area_size(BootAreaSize, avg_vol_size);
	if (MemoryLogSize == -1)
		MemoryLogSize = init_memory_log_size(MemoryLogSize, avg_vol_size);

	/*
	 * Format the volumes.  Format the root volume first so we can
	 * bootstrap the freemap.
	 */
	format_volume(get_root_volume(), nvols, label);
	for (i = 0; i < nvols; ++i) {
		if (i != HAMMER_ROOT_VOLNO)
			format_volume(get_volume(i), nvols, label);
	}

	print_volume(get_root_volume());

	flush_all_volumes();
	return(0);
}

static
void
print_volume(const volume_info_t volume)
{
	hammer_volume_ondisk_t ondisk;
	hammer_blockmap_t blockmap;
	hammer_off_t total = 0;
	int i, nvols;
	const char *name = NULL;
	char *fsidstr;

	ondisk = volume->ondisk;
	blockmap = &ondisk->vol0_blockmap[HAMMER_ZONE_UNDO_INDEX];

	nvols = ondisk->vol_count;
	for (i = 0; i < nvols; ++i) {
		volume_info_t p = get_volume(i);
		total += p->size;
		if (p->vol_no == HAMMER_ROOT_VOLNO) {
			assert(name == NULL);
			name = p->name;
		}
	}

	hammer_uuid_to_string(&Hammer_FSId, &fsidstr);

	printf("---------------------------------------------\n");
	printf("HAMMER version %d\n", HammerVersion);
	printf("%d volume%s total size %s\n",
		nvols, (nvols == 1 ? "" : "s"), sizetostr(total));
	printf("root-volume:         %s\n", name);
	if (DebugOpt) {
		printf("header-junk-size:    %s\n",
			sizetostr(ondisk->vol_bot_beg));
	}
	printf("boot-area-size:      %s\n",
		sizetostr(ondisk->vol_mem_beg - ondisk->vol_bot_beg));
	printf("memory-log-size:     %s\n",
		sizetostr(ondisk->vol_buf_beg - ondisk->vol_mem_beg));
	printf("undo-buffer-size:    %s\n",
		sizetostr(HAMMER_OFF_LONG_ENCODE(blockmap->alloc_offset)));
	printf("total-pre-allocated: %s\n",
		sizetostr(HAMMER_OFF_SHORT_ENCODE(volume->vol_free_off)));
	printf("fsid:                %s\n", fsidstr);
	printf("\n");
	printf("NOTE: Please remember that you may have to manually set up a\n"
		"cron(8) job to prune and reblock the filesystem regularly.\n"
		"By default, the system automatically runs 'hammer cleanup'\n"
		"on a nightly basis.  The periodic.conf(5) variable\n"
		"'daily_clean_hammer_enable' can be unset to disable this.\n"
		"Also see 'man hammer' and 'man HAMMER' for more information.\n");
	if (total < 10*GIG) {
		printf("\nWARNING: The minimum UNDO/REDO FIFO is %s, "
			"you really should not\n"
			"try to format a HAMMER filesystem this small.\n",
			sizetostr(HAMMER_BIGBLOCK_SIZE *
			       HAMMER_MIN_UNDO_BIGBLOCKS));
	}
	if (total < 50*GIG) {
		printf("\nWARNING: HAMMER filesystems less than 50GB are "
			"not recommended!\n"
			"You may have to run 'hammer prune-everything' and "
			"'hammer reblock'\n"
			"quite often, even if using a nohistory mount.\n");
	}
}

static
void
usage(int exit_code)
{
	fprintf(stderr,
		"usage: newfs_hammer -L label [-Efh] [-b bootsize] [-m savesize] [-u undosize]\n"
		"                    [-C cachesize[:readahead]] [-V version] special ...\n"
	);
	exit(exit_code);
}

static
void
test_header_junk_size(int64_t size)
{
	if (size < HAMMER_MIN_VOL_JUNK) {
		if (ForceOpt == 0) {
			errx(1, "The minimum header junk size is %s",
				sizetostr(HAMMER_MIN_VOL_JUNK));
			/* not reached */
		} else {
			hwarnx("You have specified header junk size less than %s",
				sizetostr(HAMMER_MIN_VOL_JUNK));
		}
	} else if (size > HAMMER_MAX_VOL_JUNK) {
		errx(1, "The maximum header junk size is %s",
			sizetostr(HAMMER_MAX_VOL_JUNK));
		/* not reached */
	}
}

static
void
test_boot_area_size(int64_t size)
{
	if (size < HAMMER_BOOT_MINBYTES) {
		if (ForceOpt == 0) {
			errx(1, "The minimum boot area size is %s",
				sizetostr(HAMMER_BOOT_MINBYTES));
			/* not reached */
		} else {
			hwarnx("You have specified boot area size less than %s",
				sizetostr(HAMMER_BOOT_MINBYTES));
		}
	} else if (size > HAMMER_BOOT_MAXBYTES) {
		errx(1, "The maximum boot area size is %s",
			sizetostr(HAMMER_BOOT_MAXBYTES));
		/* not reached */
	}
}

static
void
test_memory_log_size(int64_t size)
{
	if (size < HAMMER_MEM_MINBYTES) {
		if (ForceOpt == 0) {
			errx(1, "The minimum memory log size is %s",
				sizetostr(HAMMER_MEM_MINBYTES));
			/* not reached */
		} else {
			hwarnx("You have specified memory log size less than %s",
				sizetostr(HAMMER_MEM_MINBYTES));
		}
	} else if (size > HAMMER_MEM_MAXBYTES) {
		errx(1, "The maximum memory log size is %s",
			sizetostr(HAMMER_MEM_MAXBYTES));
		/* not reached */
	}
}

static
void
test_undo_buffer_size(int64_t size)
{
	int64_t minbuf, maxbuf;

	minbuf = HAMMER_BIGBLOCK_SIZE * HAMMER_MIN_UNDO_BIGBLOCKS;
	maxbuf = HAMMER_BIGBLOCK_SIZE * HAMMER_MAX_UNDO_BIGBLOCKS;

	if (size < minbuf) {
		if (ForceOpt == 0) {
			errx(1, "The minimum UNDO/REDO FIFO size is %s",
				sizetostr(minbuf));
			/* not reached */
		} else {
			hwarnx("You have specified an UNDO/REDO FIFO size less "
				"than %s, which may lead to VFS panics",
				sizetostr(minbuf));
		}
	} else if (size > maxbuf) {
		errx(1, "The maximum UNDO/REDO FIFO size is %s",
			sizetostr(maxbuf));
		/* not reached */
	}
}

/*
 * Convert a string to a 64 bit signed integer with various requirements.
 */
static
int64_t
getsize(const char *str, int powerof2)
{
	int64_t val;
	char *ptr;

	val = strtoll(str, &ptr, 0);
	switch(*ptr) {
	case 't':
	case 'T':
		val *= 1024;
		/* fall through */
	case 'g':
	case 'G':
		val *= 1024;
		/* fall through */
	case 'm':
	case 'M':
		val *= 1024;
		/* fall through */
	case 'k':
	case 'K':
		val *= 1024;
		break;
	default:
		errx(1, "Unknown suffix in number '%s'", str);
		/* not reached */
	}

	if (ptr[1]) {
		errx(1, "Unknown suffix in number '%s'", str);
		/* not reached */
	}
	if ((powerof2 & 1) && (val ^ (val - 1)) != ((val << 1) - 1)) {
		errx(1, "Value not power of 2: %s", str);
		/* not reached */
	}
	if ((powerof2 & 2) && (val & HAMMER_BUFMASK)) {
		errx(1, "Value not an integral multiple of %dK: %s",
		     HAMMER_BUFSIZE / 1024, str);
		/* not reached */
	}
	return(val);
}

/*
 * Generate a transaction id.  Transaction ids are no longer time-based.
 * Put the nail in the coffin by not making the first one time-based.
 *
 * We could start at 1 here but start at 2^32 to reserve a small domain for
 * possible future use.
 */
static
hammer_tid_t
createtid(void)
{
	static hammer_tid_t lasttid;

	if (lasttid == 0)
		lasttid = 0x0000000100000000ULL;
	return(lasttid++);
}

static
uint64_t
nowtime(void)
{
	struct timeval tv;
	uint64_t xtime;

	gettimeofday(&tv, NULL);
	xtime = tv.tv_sec * 1000000LL + tv.tv_usec;
	return(xtime);
}

/*
 * TRIM the volume, but only if the backing store is not a regular file
 */
static
int
trim_volume(volume_info_t volume)
{
	size_t olen;
	char *dev_name, *p;
	char sysctl_name[64];
	int trim_enabled;
	off_t ioarg[2];

	if (is_regfile(volume)) {
		hwarnx("Cannot TRIM regular file %s", volume->name);
		return(-1);
	}
	if (strncmp(volume->name, "/dev/da", 7)) {
		hwarnx("%s does not support the TRIM command", volume->name);
		return(-1);
	}

	/* Extract a number from /dev/da?s? */
	dev_name = strdup(volume->name);
	p = strtok(dev_name + strlen("/dev/da"), "s");
	sprintf(sysctl_name, "kern.cam.da.%s.trim_enabled", p);
	free(dev_name);

	trim_enabled = 0;
	olen = sizeof(trim_enabled);

	if (sysctlbyname(sysctl_name, &trim_enabled, &olen, NULL, 0) == -1) {
		hwarnx("%s (%s) does not support the TRIM command",
			volume->name, sysctl_name);
		return(-1);
	}
	if (!trim_enabled) {
		hwarnx("Erase device option selected, but sysctl (%s) "
			"is not enabled", sysctl_name);
		return(-1);
	}

	ioarg[0] = volume->device_offset;
	ioarg[1] = volume->size;

	printf("Trimming %s %s, sectors %llu-%llu\n",
		volume->type, volume->name,
		(unsigned long long)ioarg[0] / 512,
		(unsigned long long)ioarg[1] / 512);

	if (ioctl(volume->fd, DAIOCTRIM, ioarg) == -1) {
		err(1, "Trimming %s failed", volume->name);
		/* not reached */
	}

	return(0);
}

/*
 * Format a HAMMER volume.
 */
static
void
format_volume(volume_info_t volume, int nvols, const char *label)
{
	volume_info_t root_vol;
	hammer_volume_ondisk_t ondisk;
	int64_t freeblks;
	int64_t freebytes;
	int64_t vol_buf_size;
	hammer_off_t vol_alloc;
	int i;

	/*
	 * Initialize basic information in the on-disk volume structure.
	 */
	ondisk = volume->ondisk;

	ondisk->vol_fsid = Hammer_FSId;
	ondisk->vol_fstype = Hammer_FSType;
	snprintf(ondisk->vol_label, sizeof(ondisk->vol_label), "%s", label);
	ondisk->vol_no = volume->vol_no;
	ondisk->vol_count = nvols;
	ondisk->vol_version = HammerVersion;

	vol_alloc = HeaderJunkSize;
	ondisk->vol_bot_beg = vol_alloc;
	vol_alloc += BootAreaSize;
	ondisk->vol_mem_beg = vol_alloc;
	vol_alloc += MemoryLogSize;

	/*
	 * The remaining area is the zone 2 buffer allocation area.
	 */
	ondisk->vol_buf_beg = vol_alloc;
	ondisk->vol_buf_end = volume->size & ~(int64_t)HAMMER_BUFMASK;
	vol_buf_size = HAMMER_VOL_BUF_SIZE(ondisk);

	if (vol_buf_size < (int64_t)sizeof(*ondisk)) {
		errx(1, "volume %d %s is too small to hold the volume header",
		     volume->vol_no, volume->name);
		/* not reached */
	}
	if ((vol_buf_size & ~HAMMER_OFF_SHORT_MASK) != 0) {
		errx(1, "volume %d %s is too large", volume->vol_no, volume->name);
		/* not reached */
	}

	ondisk->vol_rootvol = HAMMER_ROOT_VOLNO;
	ondisk->vol_signature = HAMMER_FSBUF_VOLUME;

	volume->vol_free_off = HAMMER_ENCODE_RAW_BUFFER(volume->vol_no, 0);
	volume->vol_free_end = HAMMER_ENCODE_RAW_BUFFER(volume->vol_no,
				vol_buf_size & ~HAMMER_BIGBLOCK_MASK64);

	/*
	 * Format the root volume.
	 */
	if (volume->vol_no == HAMMER_ROOT_VOLNO) {
		/*
		 * Check freemap counts before formatting
		 */
		freeblks = count_freemap(volume);
		freebytes = freeblks * HAMMER_BIGBLOCK_SIZE64;
		if (freebytes < 10*GIG && ForceOpt == 0) {
			errx(1, "Cannot create a HAMMER filesystem less than 10GB "
				"unless you use -f\n(for the size of Volume %d).  "
				"HAMMER filesystems less than 50GB are not "
				"recommended.", HAMMER_ROOT_VOLNO);
			/* not reached */
		}

		/*
		 * Starting TID
		 */
		ondisk->vol0_next_tid = createtid();

		/*
		 * Format freemap.  vol0_stat_freebigblocks is
		 * the number of big-blocks available for anything
		 * other than freemap zone at this point.
		 */
		format_freemap(volume);
		assert(ondisk->vol0_stat_freebigblocks == 0);
		ondisk->vol0_stat_freebigblocks = initialize_freemap(volume);

		/*
		 * Format zones that are mapped to zone-2.
		 */
		for (i = 0; i < HAMMER_MAX_ZONES; ++i) {
			if (hammer_is_index_record(i))
				format_blockmap(volume, i, 0);
		}

		/*
		 * Format undo zone.  Formatting decrements
		 * vol0_stat_freebigblocks whenever a new big-block
		 * is allocated for undo zone.
		 */
		format_undomap(volume, &UndoBufferSize);
		assert(ondisk->vol0_stat_bigblocks == 0);
		ondisk->vol0_stat_bigblocks = ondisk->vol0_stat_freebigblocks;

		/*
		 * Format the root directory.  Formatting decrements
		 * vol0_stat_freebigblocks whenever a new big-block
		 * is allocated for required zones.
		 */
		ondisk->vol0_btree_root = format_root_directory(label);
		++ondisk->vol0_stat_inodes;	/* root inode */
	} else {
		freeblks = initialize_freemap(volume);
		root_vol = get_root_volume();
		root_vol->ondisk->vol0_stat_freebigblocks += freeblks;
		root_vol->ondisk->vol0_stat_bigblocks += freeblks;
	}
}

/*
 * Format the root directory.
 */
static
hammer_off_t
format_root_directory(const char *label)
{
	hammer_off_t btree_off;
	hammer_off_t idata_off;
	hammer_off_t pfsd_off;
	hammer_tid_t create_tid;
	hammer_node_ondisk_t bnode;
	hammer_inode_data_t idata;
	hammer_pseudofs_data_t pfsd;
	buffer_info_t data_buffer0 = NULL;
	buffer_info_t data_buffer1 = NULL;
	buffer_info_t data_buffer2 = NULL;
	hammer_btree_elm_t elm;
	uint64_t xtime;

	/*
	 * Allocate zero-filled root btree node, inode and pfs
	 */
	bnode = alloc_btree_node(&btree_off, &data_buffer0);
	idata = alloc_meta_element(&idata_off, sizeof(*idata), &data_buffer1);
	pfsd = alloc_meta_element(&pfsd_off, sizeof(*pfsd), &data_buffer2);
	create_tid = createtid();
	xtime = nowtime();

	/*
	 * Populate the inode data and inode record for the root directory.
	 */
	idata->version = HAMMER_INODE_DATA_VERSION;
	idata->mode = 0755;
	idata->ctime = xtime;
	idata->mtime = xtime;
	idata->atime = xtime;
	idata->obj_type = HAMMER_OBJTYPE_DIRECTORY;
	idata->size = 0;
	idata->nlinks = 1;
	if (HammerVersion >= HAMMER_VOL_VERSION_TWO)
		idata->cap_flags |= HAMMER_INODE_CAP_DIR_LOCAL_INO;
	if (HammerVersion >= HAMMER_VOL_VERSION_SIX)
		idata->cap_flags |= HAMMER_INODE_CAP_DIRHASH_ALG1;

	/*
	 * Populate the PFS data for the root PFS.
	 */
	pfsd->sync_low_tid = 1;
	pfsd->sync_beg_tid = 0;
	pfsd->sync_end_tid = 0;	/* overridden by vol0_next_tid on root PFS */
	pfsd->shared_uuid = Hammer_FSId;
	pfsd->unique_uuid = Hammer_FSId;
	pfsd->mirror_flags = 0;
	snprintf(pfsd->label, sizeof(pfsd->label), "%s", label);

	/*
	 * Create the root of the B-Tree.  The root is a leaf node so we
	 * do not have to worry about boundary elements.
	 */
	bnode->parent = 0;  /* no parent */
	bnode->count = 2;
	bnode->type = HAMMER_BTREE_TYPE_LEAF;
	bnode->mirror_tid = 0;

	/*
	 * Create the first node element for the inode.
	 */
	elm = &bnode->elms[0];
	elm->leaf.base.btype = HAMMER_BTREE_TYPE_RECORD;
	elm->leaf.base.localization = HAMMER_DEF_LOCALIZATION |
				      HAMMER_LOCALIZE_INODE;
	elm->leaf.base.obj_id = HAMMER_OBJID_ROOT;
	elm->leaf.base.key = 0;
	elm->leaf.base.create_tid = create_tid;
	elm->leaf.base.delete_tid = 0;
	elm->leaf.base.rec_type = HAMMER_RECTYPE_INODE;
	elm->leaf.base.obj_type = HAMMER_OBJTYPE_DIRECTORY;
	elm->leaf.create_ts = (uint32_t)time(NULL);

	elm->leaf.data_offset = idata_off;
	elm->leaf.data_len = sizeof(*idata);
	hammer_crc_set_leaf(HammerVersion, idata, &elm->leaf);

	/*
	 * Create the second node element for the PFS data.
	 * This is supposed to be a record part of the root ip (inode),
	 * so it should have the same obj_type value as above.
	 */
	elm = &bnode->elms[1];
	elm->leaf.base.btype = HAMMER_BTREE_TYPE_RECORD;
	elm->leaf.base.localization = HAMMER_DEF_LOCALIZATION |
				      HAMMER_LOCALIZE_MISC;
	elm->leaf.base.obj_id = HAMMER_OBJID_ROOT;
	elm->leaf.base.key = 0;
	elm->leaf.base.create_tid = create_tid;
	elm->leaf.base.delete_tid = 0;
	elm->leaf.base.rec_type = HAMMER_RECTYPE_PFS;
	elm->leaf.base.obj_type = HAMMER_OBJTYPE_DIRECTORY;
	elm->leaf.create_ts = (uint32_t)time(NULL);

	elm->leaf.data_offset = pfsd_off;
	elm->leaf.data_len = sizeof(*pfsd);
	hammer_crc_set_leaf(HammerVersion, pfsd, &elm->leaf);

	hammer_crc_set_btree(HammerVersion, bnode);

	rel_buffer(data_buffer0);
	rel_buffer(data_buffer1);
	rel_buffer(data_buffer2);

	return(btree_off);
}