Improve default ZFS disk layout (tested):

+ For GPT, always provision zfs# partition after swap [for resizability]
+ For MBR, always use a boot pool to relialy place root vdevs at EOD
NB: Fixes edge-cases where MBR combination failed boot (e.g. swap-less)
+ Generalize boot pool logic so it can be used for any scheme (namely MBR)
+ Update existing comments and some whitespace fixes
+ Change some variable names to make reading/debugging the code easier
  in zfs_create_boot() (namely prepend zroot_ or bootpool_ to property)
+ Because zroot vdevs are at EOD, no longer need to calculate partsize
  (vdev consumes remaining space after allocating swap)
+ Optimize processing of disks -- no reason to loop over the disks 3-4
  separate times when we can logically use a single loop to do everything

Discussed on:	-stable
MFC after:	3 days

1 files changed, 197 insertions, 202 deletions

diff --git a/usr.sbin/bsdinstall/scripts/zfsboot b/usr.sbin/bsdinstall/scripts/zfsboot
index 1503d6cb58c9..a274cf55bbd1 100755
--- a/usr.sbin/bsdinstall/scripts/zfsboot
+++ b/usr.sbin/bsdinstall/scripts/zfsboot
@@ -66,23 +66,30 @@ f_include $BSDCFG_SHARE/variable.subr
 
 #
 # Should we use geli(8) to encrypt the drives?
+# NB: Automatically enables ZFSBOOT_BOOT_POOL
 #
 : ${ZFSBOOT_GELI_ENCRYPTION=}
 
 #
-# Default name the unencrypted pool when using geli(8) to encrypt the drives
+# Default path to the geli(8) keyfile used in drive encryption
 #
-: ${ZFSBOOT_GELI_POOL_NAME:=bootpool}
+: ${ZFSBOOT_GELI_KEY_FILE:=/boot/encryption.key}
 
 #
-# Default size for the unencrypted boot pool when using geli(8)
+# Create a separate boot pool?
+# NB: Automatically set when using geli(8) or MBR
 #
-: ${ZFSBOOT_GELI_BOOT_SIZE:=2g}
+: ${ZFSBOOT_BOOT_POOL=}
 
 #
-# Default path to the geli(8) keyfile used in drive encryption
+# Default name for boot pool when enabled (e.g., geli(8) or MBR)
 #
-: ${ZFSBOOT_GELI_KEY_FILE:=/boot/encryption.key}
+: ${ZFSBOOT_BOOT_POOL_NAME:=bootpool}
+
+#
+# Default size for boot pool when enabled (e.g., geli(8) or MBR)
+#
+: ${ZFSBOOT_BOOT_POOL_SIZE:=2g}
 
 #
 # Default disks to use (always empty unless being scripted)
@@ -212,8 +219,8 @@ msg_geli_setup="Initializing encryption on the selected disks, this will take se
 msg_install="Install"
 msg_install_desc="Proceed with Installation"
 msg_install_help="Create ZFS boot pool with displayed options"
+msg_invalid_boot_pool_size="Invalid boot pool size \`%s'"
 msg_invalid_disk_argument="Invalid disk argument \`%s'"
-msg_invalid_geli_boot_size="Invalid geli(8) boot size \`%s'"
 msg_invalid_index_argument="Invalid index argument \`%s'"
 msg_invalid_swap_size="Invalid swap size \`%s'"
 msg_invalid_virtual_device_type="Invalid Virtual Device type \`%s'"
@@ -617,15 +624,13 @@ dialog_menu_layout()
 # so we can have some real swap. This also provides wiggle room incase your
 # replacement drivers do not have the exact same sector counts.
 #
-# NOTE: The MBR layout is more complicated (GPT is preferred).
-# NOTE: $swapsize and $gelisize should be defined by the calling function.
+# NOTE: $swapsize and $bootsize should be defined by the calling function.
 # NOTE: Sets $bootpart and $targetpart for the calling function.
 #
 zfs_create_diskpart()
 {
 	local funcname=zfs_create_diskpart
 	local disk="$1" index="$2"
-	local disksize partsize
 
 	# Check arguments
 	if [ ! "$disk" ]; then
@@ -680,18 +685,10 @@ zfs_create_diskpart()
 	f_eval_catch -d $funcname gpart "$GPART_CREATE" gpt $disk
 	f_eval_catch -d $funcname gpart "$GPART_DESTROY_F" $disk
 
-	# Calculate partition size given desired amount of swap
-	f_dprintf "$funcname: Getting disk capactiy for \`%s'" "$disk"
-	if ! device_$disk get capacity disksize; then
-		f_dprintf "$funcname: Unable to get disk capacity of \`%s'" \
-		          "$disk"
-		msg_error="$msg_error: $funcname" \
-			f_show_err "$msg_unable_to_get_disk_capacity" "$disk"
-		return $FAILURE
-	fi
-	partsize=$(( $disksize - $swapsize ))
-	f_dprintf "$funcname: disksize=[%s] partsize=[%s]" \
-	          "$disksize" "$partsize"
+	#
+	# Enable boot pool if encryption is desired
+	#
+	[ "$ZFSBOOT_GELI_ENCRYPTION" ] && ZFSBOOT_BOOT_POOL=1
 
 	#
 	# Lay down the desired type of partition scheme
@@ -717,45 +714,36 @@ zfs_create_diskpart()
 
 		# NB: zpool will use the `zfs#' GPT labels
 		bootpart=p2 targetpart=p2
+		[ ${swapsize:-0} -gt 0 ] && targetpart=p3
 
-		# Change things around if we are using geli(8)
-		if [ "$ZFSBOOT_GELI_ENCRYPTION" ]; then
+		#
+		# Prepare boot pool if enabled (e.g., for geli(8))
+		#
+		if [ "$ZFSBOOT_BOOT_POOL" ]; then
 			bootpart=p2 targetpart=p3
-			partsize=$(( $partsize - $gelisize ))
+			[ ${swapsize:-0} -gt 0 ] && targetpart=p4
 			f_eval_catch $funcname gpart \
 			             "$GPART_ADD_LABEL_WITH_SIZE" boot$index \
-			             freebsd-zfs ${gelisize}b $disk ||
+			             freebsd-zfs ${bootsize}b $disk ||
 			             return $FAILURE
-			# Pedantically nuke any old labels, stop geli
+			# Pedantically nuke any old labels
 			f_eval_catch -d $funcname zpool "$ZPOOL_LABELCLEAR_F" \
 			                /dev/$disk$bootpart
-			f_eval_catch -d $funcname geli "$GELI_DETACH_F" \
-			                /dev/$disk$targetpart
+			if [ "$ZFSBOOT_GELI_ENCRYPTION" ]; then
+				# Pedantically detach targetpart for later
+				f_eval_catch -d $funcname geli \
+				                "$GELI_DETACH_F" \
+				                /dev/$disk$targetpart
+			fi
 		fi
 
 		#
-		# 3. Add freebsd-zfs partition labeled `zfs#' for zpool
-		# NOTE: Using above calculated partsize to leave room for swap.
+		# 3. Add freebsd-swap partition labeled `swap#'
 		#
 		if [ ${swapsize:-0} -gt 0 ]; then
 			f_eval_catch $funcname gpart \
-			             "$GPART_ADD_LABEL_WITH_SIZE" zfs$index \
-			             freebsd-zfs ${partsize}b $disk ||
-			             return $FAILURE
-		else
-			f_eval_catch $funcname gpart "$GPART_ADD_LABEL" \
-			             zfs$index freebsd-zfs $disk ||
-			             return $FAILURE
-		fi
-		f_eval_catch -d $funcname zpool "$ZPOOL_LABELCLEAR_F" \
-		                /dev/$disk$targetpart
-
-		#
-		# 4. Add freebsd-swap partition labeled `swap#'
-		#
-		if [ $swapsize -gt 0 ]; then
-			f_eval_catch $funcname gpart "$GPART_ADD_LABEL" \
-			             swap$index freebsd-swap $disk ||
+			             "$GPART_ADD_LABEL_WITH_SIZE" swap$index \
+			             freebsd-swap ${swapsize}b $disk ||
 			             return $FAILURE
 			# Update fstab(5)
 			f_eval_catch $funcname printf "$PRINTF_FSTAB" \
@@ -763,6 +751,14 @@ zfs_create_diskpart()
 			             $BSDINSTALL_TMPETC/fstab ||
 			             return $FAILURE
 		fi
+
+		#
+		# 4. Add freebsd-zfs partition labeled `zfs#' for zroot
+		#
+		f_eval_catch $funcname gpart "$GPART_ADD_LABEL" \
+		             zfs$index freebsd-zfs $disk || return $FAILURE
+		f_eval_catch -d $funcname zpool "$ZPOOL_LABELCLEAR_F" \
+		                /dev/$disk$targetpart
 		;;
 
 	MBR) f_dprintf "$funcname: Creating MBR layout..."
@@ -793,21 +789,21 @@ zfs_create_diskpart()
 		f_eval_catch $funcname gpart "$GPART_CREATE" BSD ${disk}s1 ||
 		             return $FAILURE
 
-		# zpool will use s1a (no labels)
-		bootpart=s1a targetpart=s1a mbrindex=1
+		# NB: zpool will use s1a (no labels)
+		bootpart=s1a targetpart=s1d mbrindex=4
 
-		# Change things around if we are using geli(8)
+		#
+		# Always prepare a boot pool on MBR
+		#
+		ZFSBOOT_BOOT_POOL=1
+		f_eval_catch $funcname gpart \
+		             "$GPART_ADD_INDEX_WITH_SIZE" \
+		             1 freebsd-zfs ${bootsize}b ${disk}s1 ||
+		             return $FAILURE
+		# Pedantically nuke any old labels
+		f_eval_catch -d $funcname zpool "$ZPOOL_LABELCLEAR_F" \
+		                /dev/$disk$bootpart
 		if [ "$ZFSBOOT_GELI_ENCRYPTION" ]; then
-			bootpart=s1a targetpart=s1d
-			partsize=$(( $partsize - $gelisize ))
-			mbrindex=4 # If this is s1a then make the zpool s1d
-			f_eval_catch $funcname gpart \
-			             "$GPART_ADD_INDEX_WITH_SIZE" \
-			             1 freebsd-zfs ${gelisize}b ${disk}s1 ||
-			             return $FAILURE
-			# Pedantically nuke any old labels
-			f_eval_catch -d $funcname zpool "$ZPOOL_LABELCLEAR_F" \
-					/dev/$disk$bootpart
 			# Pedantically detach targetpart for later
 			f_eval_catch -d $funcname geli \
 			                "$GELI_DETACH_F" \
@@ -815,28 +811,12 @@ zfs_create_diskpart()
 		fi
 
 		#
-		# 4. Partition the BSD slice for ZFS
-		# NOTE: Using above calculated partsize to leave room for swap.
+		# 4. Add freebsd-swap partition
 		#
 		if [ ${swapsize:-0} -gt 0 ]; then
 			f_eval_catch $funcname gpart \
-			             "$GPART_ADD_INDEX_WITH_SIZE" \
-			             $mbrindex freebsd-zfs ${partsize}b \
-			             ${disk}s1 || return $FAILURE
-		else
-			f_eval_catch $funcname gpart "$GPART_ADD_INDEX" \
-			             $mbrindex freebsd-zfs ${disk}s1 ||
-			             return $FAILURE
-		fi
-		f_eval_catch -d $funcname zpool "$ZPOOL_LABELCLEAR_F" \
-				/dev/$disk$targetpart # Pedantic
-
-		#
-		# 5. Add freebsd-swap partition
-		#
-		if [ $swapsize -gt 0 ]; then
-			f_eval_catch $funcname gpart "$GPART_ADD_INDEX" \
-			             2 freebsd-swap \${disk}s1 ||
+			             "$GPART_ADD_INDEX_WITH_SIZE" 2 \
+			             freebsd-swap ${swapsize}b ${disk}s1 ||
 			             return $FAILURE
 			# Update fstab(5)
 			f_eval_catch $funcname printf "$PRINTF_FSTAB" \
@@ -844,6 +824,17 @@ zfs_create_diskpart()
 			             $BSDINSTALL_TMPETC/fstab ||
 			             return $FAILURE
 		fi
+
+		#
+		# 5. Add freebsd-zfs partition for zroot
+		#
+		f_eval_catch $funcname gpart "$GPART_ADD_INDEX" \
+			     $mbrindex freebsd-zfs ${disk}s1 || return $FAILURE
+		f_eval_catch -d $funcname zpool "$ZPOOL_LABELCLEAR_F" \
+				/dev/$disk$targetpart # Pedantic
+		f_eval_catch $funcname dd "$DD_WITH_OPTIONS" \
+			     /boot/zfsboot /dev/${disk}s1 count=1 ||
+			     return $FAILURE
 		;;
 
 	esac # $ZFSBOOT_PARTITION_SCHEME
@@ -859,8 +850,10 @@ zfs_create_diskpart()
 zfs_create_boot()
 {
 	local funcname=zfs_create_boot
-	local poolname="$1" vdev_type="$2"
-	local bootpart targetpart
+	local zroot_name="$1"
+	local zroot_vdevtype="$2"
+	local zroot_vdevs= # Calculated below
+	local boot_vdevs= # Used for geli(8) and/or MBR layouts
 	shift 2 # poolname vdev_type
 	local disks="$*" disk
 	local bootpart targetpart # Set by zfs_create_diskpart() below
@@ -868,7 +861,7 @@ zfs_create_boot()
 	#
 	# Pedantic checks; should never be seen
 	#
-	if [ ! "$poolname" ]; then
+	if [ ! "$zroot_name" ]; then
 		f_dprintf "$funcname: NULL poolname"
 		msg_error="$msg_error: $funcname" \
 			f_show_err "$msg_null_poolname"
@@ -881,7 +874,7 @@ zfs_create_boot()
 		return $FAILURE
 	fi
 	f_dprintf "$funcname: poolname=[%s] vdev_type=[%s]" \
-	          "$poolname" "$vdev_type"
+	          "$zroot_name" "$zroot_vdevtype"
 
 	#
 	# Initialize fstab(5)
@@ -896,114 +889,114 @@ zfs_create_boot()
 	#
 	# Expand SI units in desired sizes
 	#
-	f_dprintf "$funcname: Expanding supplied swapsize/gelisize values..."
-	local swapsize gelisize
+	f_dprintf "$funcname: Expanding supplied size values..."
+	local swapsize bootsize
 	if ! f_expand_number "$ZFSBOOT_SWAP_SIZE" swapsize; then
 		f_dprintf "$funcname: Invalid swap size \`%s'" \
 		          "$ZFSBOOT_SWAP_SIZE"
 		f_show_err "$msg_invalid_swap_size" "$ZFSBOOT_SWAP_SIZE"
 		return $FAILURE
 	fi
-	if ! f_expand_number "$ZFSBOOT_GELI_BOOT_SIZE" gelisize; then
-		f_dprintf "$funcname: Invalid geli(8) boot size \`%s'" \
-		          "$ZFSBOOT_GELI_BOOT_SIZE"
-		f_show_err "$msg_invalid_geli_boot_size" \
-		           "$ZFSBOOT_GELI_BOOT_SIZE"
+	if ! f_expand_number "$ZFSBOOT_BOOT_POOL_SIZE" bootsize; then
+		f_dprintf "$funcname: Invalid boot pool size \`%s'" \
+		          "$ZFSBOOT_BOOT_POOL_SIZE"
+		f_show_err "$msg_invalid_boot_pool_size" \
+		           "$ZFSBOOT_BOOT_POOL_SIZE"
 		return $FAILURE
 	fi
 	f_dprintf "$funcname: ZFSBOOT_SWAP_SIZE=[%s] swapsize=[%s]" \
 	          "$ZFSBOOT_SWAP_SIZE" "$swapsize"
-	f_dprintf "$funcname: ZFSBOOT_GELI_BOOT_SIZE=[%s] gelisize=[%s]" \
-	          "$ZFSBOOT_GELI_BOOT_SIZE" "$gelisize"
+	f_dprintf "$funcname: ZFSBOOT_BOOT_POOL_SIZE=[%s] bootsize=[%s]" \
+	          "$ZFSBOOT_BOOT_POOL_SIZE" "$bootsize"
 
 	#
-	# Prepare the disks
+	# Prepare the disks and build pool device list(s)
 	#
 	f_dprintf "$funcname: Preparing disk partitions for ZFS pool..."
+	[ "$ZFSBOOT_GNOP_4K_FORCE_ALIGN" ] &&
+		f_dprintf "$funcname: With 4k alignment using gnop(8)..."
 	local n=0
 	for disk in $disks; do
 		zfs_create_diskpart $disk $n || return $FAILURE
-		n=$(( $n + 1 ))
-	done
-	# Now $bootpart and $targetpart are set (suffix for $disk)
-
-	# MBR boot loader hack part 1
-	# We have to do this early because geli gets in the way later
-	if [ "$ZFSBOOT_PARTITION_SCHEME" = "MBR" ]; then
-		f_dprintf "$funcname: Copying MBR boot loader to disks..."
-		for disk in $disks; do
-			f_eval_catch $funcname dd "$DD_WITH_OPTIONS" \
-			             /boot/zfsboot /dev/${disk}s1 count=1 ||
-			             return $FAILURE
-		done
-	fi
-
-	# Forced 4k alignment support provided by Geom NOP (see gnop(8))
-	local unenc_list=
-	if [ "$ZFSBOOT_GNOP_4K_FORCE_ALIGN" ]; then
-		local part="$targetpart" new_list=
-
-		# We don't gnop the encrypted partition because geli will do
-		# this for us gnop the unencrypted disk
-		[ "$ZFSBOOT_GELI_ENCRYPTION" ] && part="$bootpart"
-
-		f_dprintf "$funcname: Applying 4k alignment with gnop(8)..."
-		for disk in $disks; do
-			f_eval_catch $funcname gnop "$GNOP_CREATE" \
-			             $disk$part || return $FAILURE
+		# Now $bootpart and $targetpart are set (suffix for $disk)
+		
+		# Forced 4k alignment support using Geom NOP (see gnop(8))
+		if [ "$ZFSBOOT_GNOP_4K_FORCE_ALIGN" ]; then
+			if [ "$ZFSBOOT_BOOT_POOL" ]; then
+				boot_vdevs="$boot_vdevs $disk$bootpart.nop"
+				f_eval_catch $funcname gnop "$GNOP_CREATE" \
+				             $disk$bootpart || return $FAILURE
+			fi
+			# Don't gnop encrypted partition
 			if [ "$ZFSBOOT_GELI_ENCRYPTION" ]; then
-				unenc_list="$unenc_list $disk$part.nop"
+				zroot_vdevs="$zroot_vdevs $disk$targetpart.eli"
 			else
-				new_list="$new_list $disk$targetpart.nop"
+				zroot_vdevs="$zroot_vdevs $disk$targetpart.nop"
+				f_eval_catch $funcname gnop "$GNOP_CREATE" \
+					     $disk$targetpart ||
+				             return $FAILURE
 			fi
-		done
-		set -- $new_list
-	else
-		local new_list=
-		for disk in $disks; do
-			new_list="$new_list $disk$targetpart"
-			[ "$ZFSBOOT_GELI_ENCRYPTION" ] &&
-				unenc_list="$unenc_list $disk$bootpart"
-		done
-		set -- $new_list
-	fi
+		else
+			if [ "$ZFSBOOT_BOOT_POOL" ]; then
+				boot_vdevs="$boot_vdevs $disk$bootpart"
+			fi
+			zroot_vdevs="$zroot_vdevs $disk$targetpart"
+		fi
+
+		n=$(( $n + 1 ))
+	done # disks
 
 	#
-	# If encryption is enabled, we need to create the GEOMs
+	# If we need/want a boot pool, create it
 	#
-	if [ "$ZFSBOOT_GELI_ENCRYPTION" ]; then
-		local bootvdev= options=
-		local geli_pool="$BSDINSTALL_CHROOT/$ZFSBOOT_GELI_POOL_NAME"
-		local key="$ZFSBOOT_GELI_KEY_FILE"
-
-		f_dprintf "$funcname: Setting up disk encryption..."
-
-		# Create the parent directories for our unencrypted pool
+	if [ "$ZFSBOOT_BOOT_POOL" ]; then
+		local bootpool_vdevtype= # Calculated below
+		local bootpool_options= # Calculated below
+		local bootpool_name="$ZFSBOOT_BOOT_POOL_NAME"
+		local bootpool="$BSDINSTALL_CHROOT/$bootpool_name"
+		local zroot_key="${ZFSBOOT_GELI_KEY_FILE#/}"
+
+		f_dprintf "$funcname: Setting up boot pool..."
+		[ "$ZFSBOOT_GELI_ENCRYPTION" ] &&
+			f_dprintf "$funcname: For encrypted root disk..."
+
+		# Create parent directory for boot pool
 		f_eval_catch -d $funcname umount "$UMOUNT" /mnt
 		f_eval_catch $funcname mount "$MOUNT_TYPE" tmpfs none \
 		             $BSDINSTALL_CHROOT || return $FAILURE
 
-		# Create mirror across the unencrypted partition on all disks
-		[ $( set -- $unenc_list; echo $# ) -gt 1 ] && bootvdev=mirror
+		# Create mirror across the boot partition on all disks
+		[ $( set -- $boot_vdevs; echo $# ) -gt 1 ] &&
+			bootpool_vdevtype=mirror
 
-		options="-o altroot=$BSDINSTALL_CHROOT"
-		options="$options -m \"/$ZFSBOOT_GELI_POOL_NAME\" -f"
+		bootpool_options="-o altroot=$BSDINSTALL_CHROOT"
+		bootpool_options="$bootpool_options -m \"/$bootpool_name\" -f"
 		f_eval_catch $funcname zpool "$ZPOOL_CREATE_WITH_OPTIONS" \
-		             "$options" "$ZFSBOOT_GELI_POOL_NAME" $bootvdev \
-		             \$unenc_list || return $FAILURE
+		             "$bootpool_options" "$bootpool_name" \
+		             $bootpool_vdevtype $boot_vdevs || return $FAILURE
 
-		f_eval_catch $funcname mkdir "$MKDIR_P" $geli_pool/boot ||
+		f_eval_catch $funcname mkdir "$MKDIR_P" "$bootpool/boot" ||
 		             return $FAILURE
 
-		# Generate an encryption key using random(4)
-		f_eval_catch $funcname dd "$DD_WITH_OPTIONS" \
-		             /dev/random $geli_pool/$key "bs=4096 count=1" ||
-		             return $FAILURE
+		if [ "$ZFSBOOT_GELI_ENCRYPTION" ]; then
+			# Generate an encryption key using random(4)
+			f_eval_catch $funcname dd "$DD_WITH_OPTIONS" \
+				     /dev/random "$bootpool/$zroot_key" \
+			             "bs=4096 count=1" || return $FAILURE
+		else
+			# Clean up
+			f_eval_catch $funcname zfs "$ZFS_UNMOUNT" \
+			             "$bootpool_name" || return $FAILURE
+			f_eval_catch -d $funcname umount "$UMOUNT" /mnt # tmpfs
+		fi
 
-		#
-		# Create the geli(8) GEOMS
-		#
-		local geli_list
+	fi
+
+	#
+	# Create the geli(8) GEOMS
+	#
+	if [ "$ZFSBOOT_GELI_ENCRYPTION" ]; then
+		# Prompt user for password (twice)
 		if ! msg_enter_new_password="$msg_geli_password" \
 			f_dialog_input_password
 		then
@@ -1018,8 +1011,8 @@ zfs_create_boot()
 				2>&1 >&$DIALOG_TERMINAL_PASSTHRU_FD
 			if ! echo "$pw_password" | f_eval_catch \
 				$funcname geli "$GELI_PASSWORD_INIT" \
-				"$geli_pool/boot/$disk$targetpart.eli" \
-				AES-XTS "$geli_pool/$key" \
+				"$bootpool/boot/$disk$targetpart.eli" \
+				AES-XTS "$bootpool/$zroot_key" \
 				$disk$targetpart
 			then
 				f_interactive || f_die
@@ -1028,42 +1021,39 @@ zfs_create_boot()
 			fi
 			if ! echo "$pw_password" | f_eval_catch \
 				$funcname geli "$GELI_ATTACH" \
-				"$geli_pool/\$key" $disk$targetpart
+				"$bootpool/$zroot_key" $disk$targetpart
 			then
 				f_interactive || f_die
 				unset pw_password # Sensitive info
 				return $FAILURE
 			fi
-			geli_list="$geli_list $disk$targetpart.eli"
 		done
 		unset pw_password # Sensitive info
-		set -- $geli_list
 
 		# Clean up
-		f_eval_catch $funcname zfs "$ZFS_UNMOUNT" \
-		             "$ZFSBOOT_GELI_POOL_NAME" || return $FAILURE
+		f_eval_catch $funcname zfs "$ZFS_UNMOUNT" "$bootpool_name" ||
+			return $FAILURE
 		f_eval_catch -d $funcname umount "$UMOUNT" /mnt # tmpfs
 	fi
 
 	#
 	# Create the ZFS root pool with desired type and disk devices
 	#
-	local vdevs="$*"
-	f_dprintf "$funcname: Creating boot pool..."
+	f_dprintf "$funcname: Creating root pool..."
 	f_eval_catch $funcname zpool "$ZPOOL_CREATE_WITH_OPTIONS" \
 	             "-o altroot=$BSDINSTALL_CHROOT -m none -f" \
-	             $poolname $vdev_type $vdevs
+	             "$zroot_name" $zroot_vdevtype $zroot_vdevs
 
-	# Customize the zpool a bit...
+	# Customize the zroot a bit...
 	local option
-	f_dprintf "$funcname: Setting miscellaneous options on boot pool..."
+	f_dprintf "$funcname: Setting miscellaneous options on root pool..."
 	for option in checksum=fletcher4 atime=off; do
-		f_eval_catch $funcname zfs "$ZFS_SET" $option "$poolname" ||
+		f_eval_catch $funcname zfs "$ZFS_SET" $option "$zroot_name" ||
 			return $FAILURE
 	done
 
 	#
-	# Create ZFS dataset layout within the new boot pool
+	# Create ZFS dataset layout within the new root pool
 	#
 	f_dprintf "$funcname: Creating ZFS datasets..."
 	echo "$ZFSBOOT_DATASETS" | while read dataset options; do
@@ -1083,7 +1073,7 @@ zfs_create_boot()
 		f_replaceall "$options" "[ ,]" " -o " options
 		# Create the dataset with desired options
 		f_eval_catch $funcname zfs "$ZFS_CREATE_WITH_OPTIONS" \
-		             "${options:+-o $options}" "$poolname$dataset" ||
+		             "${options:+-o $options}" "$zroot_name$dataset" ||
 		             return $FAILURE
 	done
 
@@ -1096,40 +1086,41 @@ zfs_create_boot()
 	done
 
 	# Create symlink(s)
-	if [ "$ZFSBOOT_GELI_ENCRYPTION" ]; then
-		f_dprintf "$funcname: Creating /boot symlink for GELI..."
-		f_eval_catch $funcname ln "$LN_SF" \
-		             "$ZFSBOOT_GELI_POOL_NAME/boot" \
+	if [ "$ZFSBOOT_BOOT_POOL" ]; then
+		f_dprintf "$funcname: Creating /boot symlink for boot pool..."
+		f_eval_catch $funcname ln "$LN_SF" "$bootpool_name/boot" \
 		             $BSDINSTALL_CHROOT/boot || return $FAILURE
 	fi
 
 	# Set bootfs property
+	local zroot_bootfs="$ZFSBOOT_BEROOT_NAME/$ZFSBOOT_BOOTFS_NAME"
 	f_dprintf "$funcname: Setting bootfs property..."
 	f_eval_catch $funcname zpool "$ZPOOL_SET" \
-	    "bootfs=\"$poolname/$ZFSBOOT_BEROOT_NAME/$ZFSBOOT_BOOTFS_NAME\"" \
-	    "$poolname" || return $FAILURE
+		"bootfs=\"$zroot_name/$zroot_bootfs\"" "$zroot_name" ||
+		return $FAILURE
 
 	# Export the pool(s)
 	f_dprintf "$funcname: Temporarily exporting ZFS pool(s)..."
-	f_eval_catch $funcname zpool "$ZPOOL_EXPORT" "$poolname" ||
+	f_eval_catch $funcname zpool "$ZPOOL_EXPORT" "$zroot_name" ||
 	             return $FAILURE
-	if [ "$ZFSBOOT_GELI_ENCRYPTION" ]; then
+	if [ "$ZFSBOOT_BOOT_POOL" ]; then
 		f_eval_catch $funcname zpool "$ZPOOL_EXPORT" \
-		             "$ZFSBOOT_GELI_POOL_NAME" || return $FAILURE
+		             "$bootpool_name" || return $FAILURE
 	fi
 
 	# Destroy the gnop devices (if enabled)
 	for disk in ${ZFSBOOT_GNOP_4K_FORCE_ALIGN:+$disks}; do
-		if [ "$ZFSBOOT_GELI_ENCRYPTION" ]; then
+		if [ "$ZFSBOOT_BOOT_POOL" ]; then
 			f_eval_catch -d $funcname gnop "$GNOP_DESTROY" \
 			                $disk$bootpart.nop
-		else
+		fi
+		if [ ! "$ZFSBOOT_GELI_ENCRYPTION" ]; then
 			f_eval_catch -d $funcname gnop "$GNOP_DESTROY" \
 			                $disk$targetpart.nop
 		fi
 	done
 
-	# MBR boot loader hack part 2
+	# MBR boot loader touch-up
 	if [ "$ZFSBOOT_PARTITION_SCHEME" = "MBR" ]; then
 		f_dprintf "$funcname: Updating MBR boot loader on disks..."
 		# Stick the ZFS boot loader in the "convienient hole" after 
@@ -1144,12 +1135,12 @@ zfs_create_boot()
 	# Re-import the ZFS pool(s)
 	f_dprintf "$funcname: Re-importing ZFS pool(s)..."
 	f_eval_catch $funcname zpool "$ZPOOL_IMPORT_WITH_OPTIONS" \
-	             "-o altroot=\"$BSDINSTALL_CHROOT\"" "$poolname" ||
+	             "-o altroot=\"$BSDINSTALL_CHROOT\"" "$zroot_name" ||
 	             return $FAILURE
-	if [ "$ZFSBOOT_GELI_ENCRYPTION" ]; then
+	if [ "$ZFSBOOT_BOOT_POOL" ]; then
 		f_eval_catch $funcname zpool "$ZPOOL_IMPORT_WITH_OPTIONS" \
-		             "-o altroot=\"\$BSDINSTALL_CHROOT\"" \
-		             "$ZFSBOOT_GELI_POOL_NAME" || return $FAILURE
+		             "-o altroot=\"$BSDINSTALL_CHROOT\"" \
+		             "$bootpool_name" || return $FAILURE
 	fi
 
 	# While this is apparently not needed, it seems to help MBR
@@ -1158,7 +1149,7 @@ zfs_create_boot()
 	             return $FAILURE
 	f_eval_catch $funcname zpool "$ZPOOL_SET" \
 	             "cachefile=\"$BSDINSTALL_CHROOT/boot/zfs/zpool.cache\"" \
-	             "$poolname" || return $FAILURE
+	             "$zroot_name" || return $FAILURE
 
 	# Last, but not least... required lines for rc.conf(5)/loader.conf(5)
 	# NOTE: We later concatenate these into their destination
@@ -1169,8 +1160,8 @@ zfs_create_boot()
 	f_eval_catch $funcname echo "$ECHO_APPEND" 'zfs_load=\"YES\"' \
 	             $BSDINSTALL_TMPBOOT/loader.conf.zfs || return $FAILURE
 
-	# We're all done unless we should go on to do encryption
-	[ "$ZFSBOOT_GELI_ENCRYPTION" ] || return $SUCCESS
+	# We're all done unless we should go on for boot pool
+	[ "$ZFSBOOT_BOOT_POOL" ] || return $SUCCESS
 
 	# Some additional geli(8) requirements for loader.conf(5)
 	for option in \
@@ -1182,6 +1173,12 @@ zfs_create_boot()
 		             $BSDINSTALL_TMPBOOT/loader.conf.zfs ||
 		             return $FAILURE
 	done
+	f_eval_catch $funcname printf "$PRINTF_CONF" vfs.root.mountfrom \
+	    "\"zfs:$zroot_name/$zroot_bootfs\"" \
+	    $BSDINSTALL_TMPBOOT/loader.conf.root || return $FAILURE
+
+	# We're all done unless we should go on to do encryption
+	[ "$ZFSBOOT_GELI_ENCRYPTION" ] || return $SUCCESS
 
 	#
 	# Configure geli(8)-based encryption
@@ -1191,9 +1188,6 @@ zfs_create_boot()
 	    $BSDINSTALL_TMPBOOT/loader.conf.aesni || return $FAILURE
 	f_eval_catch $funcname echo "$ECHO_APPEND" 'geom_eli_load=\"YES\"' \
 	    $BSDINSTALL_TMPBOOT/loader.conf.geli || return $FAILURE
-	f_eval_catch $funcname printf "$PRINTF_CONF" vfs.root.mountfrom \
-	    "\"zfs:$poolname/$ZFSBOOT_BEROOT_NAME/$ZFSBOOT_BOOTFS_NAME\"" \
-	    $BSDINSTALL_TMPBOOT/loader.conf.root || return $FAILURE
 	for disk in $disks; do
 		f_eval_catch $funcname printf "$PRINTF_CONF" \
 			geli_%s_keyfile0_load "$disk$targetpart YES" \
@@ -1294,11 +1288,11 @@ while :; do
 
 		# Make sure each disk will be at least 50% ZFS
 		if f_expand_number "$ZFSBOOT_SWAP_SIZE" swapsize &&
-		   f_expand_number "$ZFSBOOT_GELI_BOOT_SIZE" gelisize
+		   f_expand_number "$ZFSBOOT_BOOT_POOL_SIZE" bootsize
 		then
 			minsize=$swapsize teeny_disks=
-			[ "$ZFSBOOT_GELI_ENCRYPTION" ] &&
-				minsize=$(( $minsize + $gelisize ))
+			[ "$ZFSBOOT_BOOT_POOL" ] &&
+				minsize=$(( $minsize + $bootsize ))
 			for disk in $ZFSBOOT_DISKS; do
 				device_$disk get capacity disksize || continue
 				disksize=$(( $disksize - $minsize ))
@@ -1306,14 +1300,15 @@ while :; do
 					teeny_disks="$teeny_disks $disk"
 			done
 			if [ "$teeny_disks" ]; then
-				f_dprintf "swapsize=[%s] gelisize[%s]" \
+				f_dprintf "swapsize=[%s] bootsize[%s] %s" \
 				          "$ZFSBOOT_SWAP_SIZE" \
-				          "$ZFSBOOT_GELI_BOOT_SIZE"
+				          "$ZFSBOOT_BOOT_POOL_SIZE" \
+				          "minsize=[$minsize]"
 				f_dprintf "These disks are too small: %s" \
 				          "$teeny_disks"
 				f_show_err "$msg_these_disks_are_too_small" \
 				           "$ZFSBOOT_SWAP_SIZE" \
-				           "$ZFSBOOT_GELI_BOOT_SIZE" \
+				           "$ZFSBOOT_BOOT_POOL_SIZE" \
 				           "$teeny_disks"
 				continue
 			fi