freebsd-dev/usr.sbin/pc-sysinstall/backend/functions-disk.sh
Josh Paetzel fc78178fcb Patch pc-sysinstall to deal with 4k sector size drives
PR:	bin/151967
Submitted by:	kmoore
Approved by:	imp
2011-01-10 19:11:25 +00:00

840 lines
22 KiB
Bash
Executable File

#!/bin/sh
#-
# Copyright (c) 2010 iXsystems, Inc. All rights reserved.
#
# 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.
#
# THIS SOFTWARE IS PROVIDED BY THE AUTHOR 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 AUTHOR 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.
#
# $FreeBSD$
# Functions related to disk operations using gpart
# See if device is a full disk or partition/slice
is_disk()
{
for _dsk in `sysctl -n kern.disks`
do
if [ "$_dsk" = "${1}" ] ; then return 0 ; fi
done
return 1
}
# Get a MBR partitions sysid
get_partition_sysid_mbr()
{
INPART="0"
DISK="$1"
PARTNUM=`echo ${2} | sed "s|${DISK}s||g"`
fdisk ${DISK} >${TMPDIR}/disk-${DISK} 2>/dev/null
while read i
do
echo "$i" | grep "The data for partition" >/dev/null 2>/dev/null
if [ "$?" = "0" ] ; then
INPART="0"
PART="`echo ${i} | cut -d ' ' -f 5`"
if [ "$PART" = "$PARTNUM" ] ; then
INPART="1"
fi
fi
# In the partition section
if [ "$INPART" = "1" ] ; then
echo "$i" | grep "^sysid" >/dev/null 2>/dev/null
if [ "$?" = "0" ] ; then
SYSID="`echo ${i} | tr -s '\t' ' ' | cut -d ' ' -f 2`"
break
fi
fi
done < ${TMPDIR}/disk-${DISK}
rm ${TMPDIR}/disk-${DISK}
VAL="${SYSID}"
export VAL
};
# Get the partitions MBR label
get_partition_label_mbr()
{
INPART="0"
DISK="$1"
PARTNUM=`echo ${2} | sed "s|${DISK}s||g"`
fdisk ${DISK} >${TMPDIR}/disk-${DISK} 2>/dev/null
while read i
do
echo "$i" | grep "The data for partition" >/dev/null 2>/dev/null
if [ "$?" = "0" ] ; then
INPART="0"
PART="`echo ${i} | cut -d ' ' -f 5`"
if [ "$PART" = "$PARTNUM" ] ; then
INPART="1"
fi
fi
# In the partition section
if [ "$INPART" = "1" ] ; then
echo "$i" | grep "^sysid" >/dev/null 2>/dev/null
if [ "$?" = "0" ] ; then
LABEL="`echo ${i} | tr -s '\t' ' ' | cut -d ',' -f 2-10`"
break
fi
fi
done < ${TMPDIR}/disk-${DISK}
rm ${TMPDIR}/disk-${DISK}
VAL="${LABEL}"
export VAL
};
# Get a GPT partitions label
get_partition_label_gpt()
{
DISK="${1}"
PARTNUM=`echo ${2} | sed "s|${DISK}p||g"`
gpart show ${DISK} >${TMPDIR}/disk-${DISK}
while read i
do
SLICE="`echo ${i} | grep -v ${DISK} | grep -v ' free ' |tr -s '\t' ' ' | cut -d ' ' -f 3`"
if [ "${SLICE}" = "${PARTNUM}" ] ; then
LABEL="`echo ${i} | grep -v ${DISK} | grep -v ' free ' |tr -s '\t' ' ' | cut -d ' ' -f 4`"
break
fi
done <${TMPDIR}/disk-${DISK}
rm ${TMPDIR}/disk-${DISK}
VAL="${LABEL}"
export VAL
};
# Get a partitions startblock
get_partition_startblock()
{
DISK="${1}"
PARTNUM=`echo ${2} | sed "s|${DISK}p||g" | sed "s|${DISK}s||g"`
gpart show ${DISK} >${TMPDIR}/disk-${DISK}
while read i
do
SLICE="`echo ${i} | grep -v ${DISK} | grep -v ' free ' |tr -s '\t' ' ' | cut -d ' ' -f 3`"
if [ "$SLICE" = "${PARTNUM}" ] ; then
SB="`echo ${i} | grep -v ${DISK} | grep -v ' free ' |tr -s '\t' ' ' | cut -d ' ' -f 1`"
break
fi
done <${TMPDIR}/disk-${DISK}
rm ${TMPDIR}/disk-${DISK}
VAL="${SB}"
export VAL
};
# Get a partitions blocksize
get_partition_blocksize()
{
DISK="${1}"
PARTNUM=`echo ${2} | sed "s|${DISK}p||g" | sed "s|${DISK}s||g"`
gpart show ${DISK} >${TMPDIR}/disk-${DISK}
while read i
do
SLICE="`echo ${i} | grep -v ${DISK} | grep -v ' free ' |tr -s '\t' ' ' | cut -d ' ' -f 3`"
if [ "$SLICE" = "${PARTNUM}" ] ; then
BS="`echo ${i} | grep -v ${DISK} | grep -v ' free ' |tr -s '\t' ' ' | cut -d ' ' -f 2`"
break
fi
done <${TMPDIR}/disk-${DISK}
rm ${TMPDIR}/disk-${DISK}
VAL="${BS}"
export VAL
};
# Function which returns the partitions on a target disk
get_disk_partitions()
{
gpart show ${1} >/dev/null 2>/dev/null
if [ "$?" != "0" ] ; then
VAL="" ; export VAL
return
fi
type=`gpart show ${1} | awk '/^=>/ { printf("%s",$5); }'`
SLICES="`gpart show ${1} | grep -v ${1} | grep -v ' free ' |tr -s '\t' ' ' | cut -d ' ' -f 4 | sed '/^$/d'`"
for i in ${SLICES}
do
case $type in
MBR) name="${1}s${i}" ;;
GPT) name="${1}p${i}";;
*) name="${1}s${i}";;
esac
if [ -z "${RSLICES}" ]
then
RSLICES="${name}"
else
RSLICES="${RSLICES} ${name}"
fi
done
VAL="${RSLICES}" ; export VAL
};
# Function which returns a target disks cylinders
get_disk_cyl()
{
cyl=`diskinfo -v ${1} | grep "# Cylinders" | tr -s ' ' | cut -f 2`
VAL="${cyl}" ; export VAL
};
# Function which returns a target disks sectors
get_disk_sectors()
{
sec=`diskinfo -v ${1} | grep "# Sectors" | tr -s ' ' | cut -f 2`
VAL="${sec}" ; export VAL
};
# Function which returns a target disks heads
get_disk_heads()
{
head=`diskinfo -v ${1} | grep "# Heads" | tr -s ' ' | cut -f 2`
VAL="${head}" ; export VAL
};
# Function which returns a target disks mediasize in sectors
get_disk_mediasize()
{
mediasize=`diskinfo -v ${1} | grep "# mediasize in sectors" | tr -s ' ' | cut -f 2`
VAL="${mediasize}" ; export VAL
};
# Function which exports all zpools, making them safe to overwrite potentially
export_all_zpools()
{
# Export any zpools
for i in `zpool list -H -o name`
do
zpool export -f ${i}
done
};
# Function to delete all gparts before starting an install
delete_all_gpart()
{
echo_log "Deleting all gparts"
local DISK="$1"
# Check for any swaps to stop
for i in `gpart show ${DISK} 2>/dev/null | grep 'freebsd-swap' | tr -s ' ' | cut -d ' ' -f 4`
do
swapoff /dev/${DISK}s${i}b >/dev/null 2>/dev/null
swapoff /dev/${DISK}p${i} >/dev/null 2>/dev/null
done
# Delete the gparts now
for i in `gpart show ${DISK} 2>/dev/null | tr -s ' ' | cut -d ' ' -f 4`
do
if [ "${i}" != "${DISK}" -a "${i}" != "-" ] ; then
rc_nohalt "gpart delete -i ${i} ${DISK}"
fi
done
# Destroy the disk geom
rc_nohalt "gpart destroy ${DISK}"
# Make sure we clear any hidden gpt tables
clear_backup_gpt_table "${DISK}"
# Wipe out front of disk
rc_nohalt "dd if=/dev/zero of=/dev/${DISK} count=3000"
};
# Function to export all zpools before starting an install
stop_all_zfs()
{
# Export all zpools again, so that we can overwrite these partitions potentially
for i in `zpool list -H -o name`
do
zpool export -f ${i}
done
};
# Function which stops all gmirrors before doing any disk manipulation
stop_all_gmirror()
{
DISK="${1}"
GPROV="`gmirror list | grep ". Name: mirror/" | cut -d '/' -f 2`"
for gprov in $GPROV
do
gmirror list | grep "Name: ${DISK}" >/dev/null 2>/dev/null
if [ "$?" = "0" ]
then
echo_log "Stopping mirror $gprov $DISK"
rc_nohalt "gmirror remove $gprov $DISK"
rc_nohalt "dd if=/dev/zero of=/dev/${DISK} count=4096"
fi
done
};
# Make sure we don't have any geli providers active on this disk
stop_all_geli()
{
_geld="${1}"
cd /dev
for i in `ls ${_geld}*`
do
echo $i | grep '.eli' >/dev/null 2>/dev/null
if [ "$?" = "0" ]
then
echo_log "Detaching GELI on ${i}"
rc_halt "geli detach ${i}"
fi
done
};
# Function which reads in the disk slice config, and performs it
setup_disk_slice()
{
# Cleanup any slice / mirror dirs
rm -rf ${SLICECFGDIR} >/dev/null 2>/dev/null
mkdir ${SLICECFGDIR}
rm -rf ${MIRRORCFGDIR} >/dev/null 2>/dev/null
mkdir ${MIRRORCFGDIR}
# Start with disk0
disknum="0"
# Make sure all zpools are exported
export_all_zpools
# We are ready to start setting up the disks, lets read the config and do the actions
while read line
do
echo $line | grep "^disk${disknum}=" >/dev/null 2>/dev/null
if [ "$?" = "0" ]
then
# Found a disk= entry, lets get the disk we are working on
get_value_from_string "${line}"
strip_white_space "$VAL"
DISK="$VAL"
# Before we go further, lets confirm this disk really exists
if [ ! -e "/dev/${DISK}" ]
then
exit_err "ERROR: The disk ${DISK} does not exist!"
fi
# Make sure we stop any gmirrors on this disk
stop_all_gmirror ${DISK}
# Make sure we stop any geli stuff on this disk
stop_all_geli ${DISK}
# Make sure we don't have any zpools loaded
stop_all_zfs
fi
# Lets look if this device will be mirrored on another disk
echo $line | grep "^mirror=" >/dev/null 2>/dev/null
if [ "$?" = "0" ]
then
# Found a disk= entry, lets get the disk we are working on
get_value_from_string "${line}"
strip_white_space "$VAL"
MIRRORDISK="$VAL"
# Before we go further, lets confirm this disk really exists
if [ ! -e "/dev/${MIRRORDISK}" ]
then
exit_err "ERROR: The mirror disk ${MIRRORDISK} does not exist!"
fi
fi
# Lets see if we have been given a mirror balance choice
echo $line | grep "^mirrorbal=" >/dev/null 2>/dev/null
if [ "$?" = "0" ]
then
# Found a disk= entry, lets get the disk we are working on
get_value_from_string "${line}"
strip_white_space "$VAL"
MIRRORBAL="$VAL"
fi
echo $line | grep "^partition=" >/dev/null 2>/dev/null
if [ "$?" = "0" ]
then
# Found a partition= entry, lets read / set it
get_value_from_string "${line}"
strip_white_space "$VAL"
PTYPE=`echo $VAL|tr A-Z a-z`
# We are using free space, figure out the slice number
if [ "${PTYPE}" = "free" ]
then
# Lets figure out what number this slice will be
LASTSLICE="`gpart show ${DISK} \
| grep -v ${DISK} \
| grep -v ' free' \
| tr -s '\t' ' ' \
| cut -d ' ' -f 4 \
| sed '/^$/d' \
| tail -n 1`"
if [ -z "${LASTSLICE}" ]
then
LASTSLICE="1"
else
LASTSLICE="`expr $LASTSLICE + 1`"
fi
if [ $LASTSLICE -gt 4 ]
then
exit_err "ERROR: BSD only supports primary partitions, and there are none availble on $DISK"
fi
fi
fi
# Check if we have an image file defined
echo $line | grep "^image=" >/dev/null 2>/dev/null
if [ "$?" = "0" ] ; then
# Found an image= entry, lets read / set it
get_value_from_string "${line}"
strip_white_space "$VAL"
IMAGE="$VAL"
if [ ! -f "$IMAGE" ] ; then
exit_err "$IMAGE file does not exist"
fi
fi
# Check if we have a partscheme specified
echo $line | grep "^partscheme=" >/dev/null 2>/dev/null
if [ "$?" = "0" ] ; then
# Found a partscheme= entry, lets read / set it
get_value_from_string "${line}"
strip_white_space "$VAL"
PSCHEME="$VAL"
if [ "$PSCHEME" != "GPT" -a "$PSCHEME" != "MBR" ] ; then
exit_err "Unknown partition scheme: $PSCHEME"
fi
fi
echo $line | grep "^bootManager=" >/dev/null 2>/dev/null
if [ "$?" = "0" ]
then
# Found a bootManager= entry, lets read /set it
get_value_from_string "${line}"
strip_white_space "$VAL"
BMANAGER="$VAL"
fi
echo $line | grep "^commitDiskPart" >/dev/null 2>/dev/null
if [ "$?" = "0" ]
then
# Found our flag to commit this disk setup / lets do sanity check and do it
if [ ! -z "${DISK}" -a ! -z "${PTYPE}" ]
then
case ${PTYPE} in
all)
if [ "$PSCHEME" = "MBR" -o -z "$PSCHEME" ] ; then
PSCHEME="MBR"
tmpSLICE="${DISK}s1"
else
tmpSLICE="${DISK}p1"
fi
run_gpart_full "${DISK}" "${BMANAGER}" "${PSCHEME}"
;;
s1|s2|s3|s4)
tmpSLICE="${DISK}${PTYPE}"
# Get the number of the slice we are working on
s="`echo ${PTYPE} | awk '{print substr($0,length,1)}'`"
run_gpart_slice "${DISK}" "${BMANAGER}" "${s}"
;;
free)
tmpSLICE="${DISK}s${LASTSLICE}"
run_gpart_free "${DISK}" "${LASTSLICE}" "${BMANAGER}"
;;
image)
if [ -z "${IMAGE}" ]
then
exit_err "ERROR: partition type image specified with no image!"
fi
;;
*) exit_err "ERROR: Unknown PTYPE: $PTYPE" ;;
esac
if [ -n "${IMAGE}" ]
then
local DEST
if [ -n "${tmpSLICE}" ]
then
DEST="${tmpSLICE}"
else
DEST="${DISK}"
fi
write_image "${IMAGE}" "${DEST}"
check_disk_layout "${DEST}"
fi
# Now save which disk<num> this is, so we can parse it later during slice partition setup
if [ -z "${IMAGE}" ]
then
echo "disk${disknum}" >${SLICECFGDIR}/$tmpSLICE
fi
# Save any mirror config
if [ ! -z "$MIRRORDISK" ]
then
# Default to round-robin if the user didn't specify
if [ -z "$MIRRORBAL" ]
then
MIRRORBAL="round-robin"
fi
echo "$MIRRORDISK:$MIRRORBAL" >${MIRRORCFGDIR}/$DISK
fi
# Increment our disk counter to look for next disk and unset
unset BMANAGER PTYPE DISK MIRRORDISK MIRRORBAL PSCHEME IMAGE
disknum="`expr $disknum + 1`"
else
exit_err "ERROR: commitDiskPart was called without procceding disk<num>= and partition= entries!!!"
fi
fi
done <${CFGF}
};
# Stop all gjournals on disk / slice
stop_gjournal()
{
_gdsk="$1"
# Check if we need to shutdown any journals on this drive
ls /dev/${_gdsk}*.journal >/dev/null 2>/dev/null
if [ "$?" = "0" ]
then
cd /dev
for i in `ls ${_gdsk}*.journal`
do
rawjournal="`echo ${i} | cut -d '.' -f 1`"
gjournal stop -f ${rawjournal} >>${LOGOUT} 2>>${LOGOUT}
gjournal clear ${rawjournal} >>${LOGOUT} 2>>${LOGOUT}
done
fi
} ;
# Function to wipe the potential backup gpt table from a disk
clear_backup_gpt_table()
{
# Get the disk block size
local dSize="`gpart show $1 | grep $1 | tr -s ' ' | cut -d ' ' -f 3`"
# Make sure this is a valid number
is_num "${dSize}" >/dev/null 2>/dev/null
if [ "$?" != "0" ] ; then return ; fi
# Die backup label, DIE
echo_log "Clearing gpt backup table location on disk"
rc_nohalt "dd if=/dev/zero of=${1} bs=512 seek=${dSize}"
} ;
# Function which runs gpart and creates a single large GPT partition scheme
init_gpt_full_disk()
{
_intDISK=$1
# Set our sysctl so we can overwrite any geom using drives
sysctl kern.geom.debugflags=16 >>${LOGOUT} 2>>${LOGOUT}
# Stop any journaling
stop_gjournal "${_intDISK}"
# Remove any existing partitions
delete_all_gpart "${_intDISK}"
sleep 2
echo_log "Running gpart on ${_intDISK}"
rc_halt "gpart create -s GPT ${_intDISK}"
rc_halt "gpart add -b 34 -s 64 -t freebsd-boot ${_intDISK}"
echo_log "Stamping boot sector on ${_intDISK}"
rc_halt "gpart bootcode -b /boot/pmbr ${_intDISK}"
}
# Function which runs gpart and creates a single large MBR partition scheme
init_mbr_full_disk()
{
_intDISK=$1
_intBOOT=$2
startblock="2016"
# Set our sysctl so we can overwrite any geom using drives
sysctl kern.geom.debugflags=16 >>${LOGOUT} 2>>${LOGOUT}
# Stop any journaling
stop_gjournal "${_intDISK}"
# Remove any existing partitions
delete_all_gpart "${_intDISK}"
sleep 2
echo_log "Running gpart on ${_intDISK}"
rc_halt "gpart create -s mbr ${_intDISK}"
# Lets figure out disk size in blocks
# Get the cyl of this disk
get_disk_cyl "${_intDISK}"
cyl="${VAL}"
# Get the heads of this disk
get_disk_heads "${_intDISK}"
head="${VAL}"
# Get the tracks/sectors of this disk
get_disk_sectors "${_intDISK}"
sec="${VAL}"
# Multiply them all together to get our total blocks
totalblocks="`expr ${cyl} \* ${head}`"
totalblocks="`expr ${totalblocks} \* ${sec}`"
if [ -z "${totalblocks}" ]
then
totalblocks=`gpart show "${_intDISK}"|tail -2|head -1|awk '{ print $2 }'`
fi
# Now set the ending block to the total disk block size
sizeblock="`expr ${totalblocks} - ${startblock}`"
# Install new partition setup
echo_log "Running gpart add on ${_intDISK}"
rc_halt "gpart add -b ${startblock} -s ${sizeblock} -t freebsd -i 1 ${_intDISK}"
sleep 2
echo_log "Cleaning up ${_intDISK}s1"
rc_halt "dd if=/dev/zero of=/dev/${_intDISK}s1 count=1024"
if [ "$_intBOOT" = "bsd" ] ; then
echo_log "Stamping boot0 on ${_intDISK}"
rc_halt "gpart bootcode -b /boot/boot0 ${_intDISK}"
else
echo_log "Stamping boot1 on ${_intDISK}"
rc_halt "gpart bootcode -b /boot/boot1 ${_intDISK}"
fi
}
# Function which runs gpart and creates a single large slice
run_gpart_full()
{
DISK=$1
BOOT=$2
SCHEME=$3
if [ "$SCHEME" = "MBR" ] ; then
init_mbr_full_disk "$DISK" "$BOOT"
slice="${DISK}-1-mbr"
else
init_gpt_full_disk "$DISK"
slice="${DISK}-1-gpt"
fi
# Lets save our slice, so we know what to look for in the config file later on
if [ -z "$WORKINGSLICES" ]
then
WORKINGSLICES="${slice}"
export WORKINGSLICES
else
WORKINGSLICES="${WORKINGSLICES} ${slice}"
export WORKINGSLICES
fi
};
# Function which runs gpart on a specified s1-4 slice
run_gpart_slice()
{
DISK=$1
if [ ! -z "$2" ]
then
BMANAGER="$2"
fi
# Set the slice we will use later
slice="${1}s${3}"
# Set our sysctl so we can overwrite any geom using drives
sysctl kern.geom.debugflags=16 >>${LOGOUT} 2>>${LOGOUT}
# Get the number of the slice we are working on
slicenum="$3"
# Stop any journaling
stop_gjournal "${slice}"
# Make sure we have disabled swap on this drive
if [ -e "${slice}b" ]
then
swapoff ${slice}b >/dev/null 2>/dev/null
swapoff ${slice}b.eli >/dev/null 2>/dev/null
fi
# Modify partition type
echo_log "Running gpart modify on ${DISK}"
rc_halt "gpart modify -t freebsd -i ${slicenum} ${DISK}"
sleep 2
# Clean up old partition
echo_log "Cleaning up $slice"
rc_halt "dd if=/dev/zero of=/dev/${DISK}s${slicenum} count=1024"
sleep 1
if [ "${BMANAGER}" = "bsd" ]
then
echo_log "Stamping boot sector on ${DISK}"
rc_halt "gpart bootcode -b /boot/boot0 ${DISK}"
fi
# Set the slice to the format we'll be using for gpart later
slice="${1}-${3}-mbr"
# Lets save our slice, so we know what to look for in the config file later on
if [ -z "$WORKINGSLICES" ]
then
WORKINGSLICES="${slice}"
export WORKINGSLICES
else
WORKINGSLICES="${WORKINGSLICES} ${slice}"
export WORKINGSLICES
fi
};
# Function which runs gpart and creates a new slice from free disk space
run_gpart_free()
{
DISK=$1
SLICENUM=$2
if [ ! -z "$3" ]
then
BMANAGER="$3"
fi
# Set our sysctl so we can overwrite any geom using drives
sysctl kern.geom.debugflags=16 >>${LOGOUT} 2>>${LOGOUT}
slice="${DISK}s${SLICENUM}"
slicenum="${SLICENUM}"
# Working on the first slice, make sure we have MBR setup
gpart show ${DISK} >/dev/null 2>/dev/null
if [ "$?" != "0" -a "$SLICENUM" = "1" ] ; then
echo_log "Initializing disk, no existing MBR setup"
rc_halt "gpart create -s mbr ${DISK}"
fi
# Lets get the starting block first
if [ "${slicenum}" = "1" ]
then
startblock="63"
else
# Lets figure out where the prior slice ends
checkslice="`expr ${slicenum} - 1`"
# Get starting block of this slice
sblk=`gpart show ${DISK} | grep -v ${DISK} | tr -s '\t' ' ' | sed '/^$/d' | grep " ${checkslice} " | cut -d ' ' -f 2`
blksize=`gpart show ${DISK} | grep -v ${DISK} | tr -s '\t' ' ' | sed '/^$/d' | grep " ${checkslice} " | cut -d ' ' -f 3`
startblock="`expr ${sblk} + ${blksize}`"
fi
# No slice after the new slice, lets figure out the free space remaining and use it
# Get the cyl of this disk
get_disk_cyl "${DISK}"
cyl="${VAL}"
# Get the heads of this disk
get_disk_heads "${DISK}"
head="${VAL}"
# Get the tracks/sectors of this disk
get_disk_sectors "${DISK}"
sec="${VAL}"
# Multiply them all together to get our total blocks
totalblocks="`expr ${cyl} \* ${head}`"
totalblocks="`expr ${totalblocks} \* ${sec}`"
# Now set the ending block to the total disk block size
sizeblock="`expr ${totalblocks} - ${startblock}`"
# Install new partition setup
echo_log "Running gpart on ${DISK}"
rc_halt "gpart add -b ${startblock} -s ${sizeblock} -t freebsd -i ${slicenum} ${DISK}"
sleep 2
echo_log "Cleaning up $slice"
rc_halt "dd if=/dev/zero of=/dev/${slice} count=1024"
sleep 1
if [ "${BMANAGER}" = "bsd" ]
then
echo_log "Stamping boot sector on ${DISK}"
rc_halt "gpart bootcode -b /boot/boot0 ${DISK}"
fi
slice="${DISK}-${SLICENUM}-mbr"
# Lets save our slice, so we know what to look for in the config file later on
if [ -z "$WORKINGSLICES" ]
then
WORKINGSLICES="${slice}"
export WORKINGSLICES
else
WORKINGSLICES="${WORKINGSLICES} ${slice}"
export WORKINGSLICES
fi
};