svn commit: r259476 - head/usr.sbin/bsdinstall/scripts
Devin Teske
dteske at FreeBSD.org
Mon Dec 16 19:37:16 UTC 2013
Author: dteske
Date: Mon Dec 16 19:37:15 2013
New Revision: 259476
URL: http://svnweb.freebsd.org/changeset/base/259476
Log:
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
Modified:
head/usr.sbin/bsdinstall/scripts/zfsboot
Modified: head/usr.sbin/bsdinstall/scripts/zfsboot
==============================================================================
--- head/usr.sbin/bsdinstall/scripts/zfsboot Mon Dec 16 19:31:23 2013 (r259475)
+++ head/usr.sbin/bsdinstall/scripts/zfsboot Mon Dec 16 19:37:15 2013 (r259476)
@@ -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
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"
+ 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 disk encryption..."
+ f_dprintf "$funcname: Setting up boot pool..."
+ [ "$ZFSBOOT_GELI_ENCRYPTION" ] &&
+ f_dprintf "$funcname: For encrypted root disk..."
- # Create the parent directories for our unencrypted pool
+ # 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
More information about the svn-src-head
mailing list