freebsd-dev/etc/etc.i386/cdinst1.install

1044 lines
28 KiB
Plaintext
Raw Normal View History

#!/bin/sh
# cd install floppy disk /install script
#
# $Id: cdinst1.install,v 1.6 1994/06/29 06:46:01 rgrimes Exp $
# ${OPSYSTEM}, the mounting of the cdrom drive, and the path are all
# setup by .profile
#
OPSYSID=165
ROOTMIN=7
SWAPMIN=8
USRMIN=45
DISKMIN=`expr $ROOTMIN + $SWAPMIN + $USRMIN + 1`
DEFBLOCKING=2
DEFSECT=17
DEFHEAD=12
DEFCYLN=1024
RUN_FDISK=""
DOS1_ID=1
DOS2_ID=4
DOS3_ID=6
set_arbitrary_defaults() {
cyls_per_disk=$DEFCYLN
tracks_per_cyl=$DEFHEAD
sects_per_track=$DEFSECT
unused_last_part=3
part_cnt=4
}
get_fdisk_data() {
cyls_per_disk=
part_id=
got_sysid=
part_cnt=0
sysid_cnt=0
have_opsys_part=
have_dos_part=
unused_last_part=
extent_max=0
extent_max_part=
fdisk /dev/r${drivename}d >fdisk.out 2>fdisk.err
if [ $? -gt 0 ]; then
echo "Can't open /dev/r${drivename}d for reading!"
set_arbitrary_defaults
>fdisk.out
>fdisk.err
return 2
elif [ -s fdisk.err ]; then
echo "Disk doesn't appear to be initialized..."
>fdisk.out
>fdisk.err
no_part_table=1
fi
while read data; do
if [ ! "$cyls_per_disk" ]; then
cyls_per_disk=`expr "$data" : '[^=]*=\([0-9]*\)'`
tracks_per_cyl=`expr "$data" : '[^=]*=[^=]*=\([0-9]*\)'`
sects_per_track=`expr "$data" : '[^=]*=[^=]*=[^=]*=\([0-9]*\)'`
continue
fi
if [ "$got_sysid" ]; then
start_part=`expr "$data" : '[^0-9]*\([0-9]*\)'`
size_part=`expr "$data" : '[^0-9]*[0-9]*[^0-9]*\([0-9]*\)'`
extent_part=`expr $start_part + $size_part`
if [ $extent_part -gt $extent_max ]; then
extent_max=$extent_part
extent_max_part=$part_id
fi
eval start${part_id}=$start_part
eval size${part_id}=$size_part
sysid_cnt=`expr $sysid_cnt + 1`
got_sysid=
part_id=
elif [ "$part_id" ]; then
sysid=`expr "$data" : 'sysid \([0-9]*\)'`
sysname=`expr "$data" : 'sysid[^(]*(\([^)]*\)'`
if [ "$no_part_table" -o "$sysid" = "0" -o \
"$(expr "$data" : '\(<UNUSED>\)')" = "<UNUSED>" ]; then
unused_last_part=$part_id
part_id=
continue
fi
if [ "$sysid" = "$OPSYSID" ]; then
have_opsys_part=$part_id
elif [ ! "$have_dos_part" -a \( "$sysid" = "$DOS1_ID" -o \
"$sysid" = "$DOS2_ID" -o "$sysid" = "$DOS3_ID" \) ]; then
have_dos_part=$part_id
fi
eval sysid${part_id}=$sysid
eval sysname${part_id}=\"$sysname\"
got_sysid=1
else
part_id=`expr "$data" : 'The data[^0-9]*\([0-9]*\)'`
beg_cyl=`expr "$data" : '[ ]*beg[^0-9]*\([0-9]*\)'`
end_cyl=`expr "$data" : '[ ]*end[^0-9]*\([0-9]*\)'`
if [ "$part_id" ]; then
part_cnt=`expr $part_cnt + 1`
elif [ "${beg_cyl}" -gt "${cyls_per_disk}" -o \
"${end_cyl}" -gt "${cyls_per_disk}" ]; then
no_part_table=1
sysid_cnt=0
have_opsys_part=0
unused_last_part=`expr $part_cnt - 1`
fi
fi
done <fdisk.out
if [ ! "$cyls_per_disk" ]; then
set_arbitrary_defaults
return 2
fi
>fdisk.out
>fdisk.err
return 0
}
set_existing_part() {
# Set existing partiton values as default (adjusting to cylinder boundaries)
eval opsys_size=\$size${opsys_part}
eval opsys_start=\$start${opsys_part}
[ $opsys_size -eq 50000 ] && opsys_size=$disksize
opsys_off=`expr $opsys_start / $cylindersize`
opsys_adjusted=`expr $opsys_off \* $cylindersize`
if [ $opsys_adjusted -lt $opsys_start -o $opsys_off -eq 0 ]; then
opsys_off=`expr $opsys_off + 1`
opsys_adjusted=`expr $opsys_off \* $cylindersize`
opsys_size=`expr $opsys_size - $opsys_adjusted + $opsys_start`
fi
cyls_per_opsys=`expr $opsys_size / $cylindersize`
RUN_FDISK="fdisk -u"
}
set_overwrite_part() {
while :; do
echo
echo -n "Please specify partition to overwrite: [3] "
read resp junk
opsys_part=${resp:-3}
if [ "$opsys_part" -ge 0 -a "$opsys_part" -le 3 ]; then
break
else
echo
echo "Partition must be in the range [0-3]"
fi
done
set_existing_part
}
analyze_fdisk_data() {
if [ "$part_cnt" -gt 0 ]; then
echo
echo "Partition Offset* Size* Name"
echo "--------- ------ ---- ----"
i=0
while [ $i -lt $part_cnt ]; do
pcyls=
poff=
eval psize=\$size${i}
eval pstart=\$start${i}
eval pname=\$sysname${i}
[ "$psize" -eq 50000 ] && psize=$disksize
if [ "$psize" ]; then
poff=`expr $pstart / $cylindersize`
padjusted=`expr $poff \* $cylindersize`
if [ "$padjusted" -lt "$pstart" ]; then
poff=`expr $poff + 1`
padjusted=`expr $poff \* $cylindersize`
psize=`expr $psize - $padjusted + $pstart`
fi
pcyls=`expr $psize / $cylindersize`
fi
echo -n "${i}"
echo -n " ${poff:-0}"
echo -n " ${pcyls:-0}"
echo " ${pname:-(Unused)}"
i=`expr $i + 1`
done
echo "* Sizes and offsets are in units of cylinders."
fi
# Case I: >1024 cylinders
force_offset=
if [ $cyls_per_disk -gt 1024 ]; then
echo
echo " WARNING: >1024 cylinders. On some hardware, this prevents"
echo " ${OPSYSTEM} from sharing the disk with other operating systems."
echo -n "Install ${OPSYSTEM} on entire disk, overwriting existing partitions? [n] "
read resp junk
case "$resp" in
y*|Y*)
RUN_FDISK=""
force_offset=1
opsys_off=0
cyls_per_opsys=${cyls_per_disk}
opsys_part=${unused_last_part:-3}
return 0
;;
*)
echo
echo "If the number of disk cylinders does not exceed 1024, then ${OPSYSTEM}"
echo "can be installed alongside other operating systems on a single disk."
echo "Otherwise, it is system-dependent whether this will work or not."
echo "In the worst case, ${OPSYSTEM} MUST be installed at the beginning of"
echo "the disk, and existing partitions will be lost."
echo
echo "For now, we will assume that >1024 cylinders creates no problems..."
# FALL THROUGH
;;
esac
fi
# Case II: no partitions used
if [ $sysid_cnt -eq 0 ]; then
echo
echo " WARNING: partition table is either missing or corrupt."
echo " Existing partitions will be lost."
part_cnt=${part_cnt:-4}
RUN_FDISK="overwrite"
opsys_off=1
cyls_per_opsys=`expr ${cyls_per_disk} - 1`
opsys_part=${unused_last_part:-3}
return 0
# Case IIIa: overwrite an existing 386BSD/NetBSD/FreeBSD partition
elif [ "$have_opsys_part" ]; then
echo
echo "386/Net/FreeBSD partition already exists!"
echo -n "Overwrite existing partition? [n] "
read resp junk
case "$resp" in
y*|Y*)
opsys_part=${have_opsys_part}
set_existing_part
return 0
;;
*)
have_opsys_part=
# FALL THROUGH
;;
esac
fi
# Case IIIb: no partitions available
if [ $sysid_cnt -eq $part_cnt -a ! "$have_opsys_part" ]; then
echo
echo "No unused partitions."
echo -n "Install $OPSYSTEM and overwrite the entire disk? [n] "
read resp junk
case "$resp" in
y*|Y*)
# don't use first cylinder!
opsys_off=1
cyls_per_opsys=`expr $cyls_per_disk - 1`
opsys_part=${unused_last_part}
RUN_FDISK="overwrite"
;;
*)
set_overwrite_part
;;
esac
return 0
fi
# *** CAVEAT ***
# $OPSYSTEM installs at the end of the disk. If the
# beginning of the disk is free but not the end, install fails!
# Assume `fdisk -u' to add $OPSYSTEM in last unused partition for remaining cases
opsys_part=${unused_last_part}
RUN_FDISK="fdisk -u"
mb_sect=`expr 1024 \* 1024 / $bytes_per_sect`
disk_minimum=`expr $DISKMIN \* $mb_sect`
# Case IV: No room (at end of disk) for mininal install
[ $extent_max -eq 50000 ] && extent_max=$disksize
disk_remaining=`expr $disksize - $extent_max`
if [ $disk_remaining -lt $disk_minimum ]; then
echo
echo "Not enough space ($DISKMIN Mb) at end of disk to install $OPSYSTEM."
echo -n "Install FreeBSD and overwrite the entire disk? [n] "
read resp junk
case "$resp" in
y*|Y*)
# don't use first cylinder!
opsys_off=1
cyls_per_opsys=`expr $cyls_per_disk - 1`
opsys_part=${unused_last_part}
RUN_FDISK="overwrite"
;;
*)
echo
echo -n "Overwrite an existing partition? [n] "
read resp junk
case "$resp" in
y*|Y*)
set_overwrite_part
;;
*)
echo
echo " WARNING: To install ${OPSYSTEM}, you're on your own in figuring"
echo " out where on the disk it will fit without overwriting another"
echo " partition..."
# Set defaults assuming there is only one partition at end of disk
eval start=\$start${extent_max_part}
# don't use first cylinder!
opsys_off=1
cyls_per_opsys=`expr $start / $cylindersize - 1`
[ $cyls_per_opsys -lt 0 ] && cyls_per_opsys=0
;;
esac
;;
esac
return 0
fi
# Case V: Room for $OPSYSTEM and partition data okay
opsys_off=`expr $extent_max / $cylindersize`
opsys_extent=`expr $opsys_off \* $cylindersize`
[ $opsys_extent -lt $extent_max ] && opsys_off=`expr $opsys_off + 1`
cyls_per_opsys=`expr $cyls_per_disk - $opsys_off`
return 0
}
put_fdisk_data() {
start=$root_offset
size=$partition
if [ "$RUN_FDISK" = "overwrite" ]; then
# How do you overwrite without explicitly editing each entry?
(
echo y
echo $cyls_per_disk
echo $tracks_per_cyl
echo $sects_per_track
echo y
) >fdisk.script
i=0
n=`expr ${part_cnt:-4} - 1`
while [ $i -lt $n ]; do
echo y
echo 0
echo 0
echo 0
echo n
echo y
i=`expr $i + 1`
done >>fdisk.script
( echo y
echo ${OPSYSID}
echo ${start}
echo ${size}
echo n
echo y
echo y
echo ${n}
echo y
echo y
) >>fdisk.script
fdisk -u /dev/r${drivename}d <fdisk.script >/dev/null 2>&1
elif [ "$RUN_FDISK" ]; then
$RUN_FDISK -${opsys_part:-${unused_last_part:-3}} /dev/r${drivename}d <<-EOF >/dev/null 2>&1
y
$cyls_per_disk
$tracks_per_cyl
$sects_per_track
y
y
${OPSYSID}
${start}
${size}
n
y
y
${opsys_part:-${unused_last_part:-3}}
y
y
EOF
fi
}
echo
echo "This program is designed to help put ${OPSYSTEM} on a hard disk with"
echo "at least $DISKMIN Megabytes of free space."
echo
echo "Before starting, it is important to know your hard disk's geometry"
echo "(i.e., number of cylinders, heads and sectors/track). If installing"
echo "${OPSYSTEM} on the same disk as another operating system, then the"
echo "two systems should use the same geometry. In particular, ${OPSYSTEM}'s"
echo "default geometry is inappropriate for MS-DOS. So in this case, the"
echo "DOS geometry should be used instead."
echo
echo "As with anything which modifies a hard drive's contents, this program"
echo "can cause SIGNIFICANT DATA LOSS. We strongly recommend making sure"
echo "that the hard drive is backed up before going further with the"
echo "installation process."
echo
echo -n "Proceed with installation? [y] "
read resp junk
resp=${resp:-y}
case "$resp" in
y*|Y*)
echo
echo "Cool! Let's get to it..."
echo
echo "You will be given a chance to start over if you make a"
echo "mistake during these questions."
echo "At the end, you have the option of redoing the configuration."
echo "If you really must quit at some point, type <CTRL>+C and"
echo "enter \`halt' at the command prompt, \`#'."
;;
*)
echo
echo "OK, then. Enter \`halt' to halt the machine."
echo "Once the machine has halted, remove the floppy,"
echo "and press any key to reboot."
exit
;;
esac
mount -u /dev/fd0 / || {
if mount -u /dev/fd1 / ; then
echo "[Please ignore the above error message, that's normal.]"
else
echo "Oh boy, we're in trouble here: Could not mount floppy read-write."
exit 1
fi
}
sync
verified_install=""
while [ ! "$verified_install" ]; do # Begin of Big Loop
rotdelay="-d 0 -n 1"
drivename=wd0
drivetype=wd
sect_fwd=""
echo
echo "First, we need to know the drive type. This can be can be one of"
echo "ESDI, SCSI, ST506, or IDE."
echo -n "Drive type? [${type:-IDE}] "
read resp junk
type=${resp:-${type:-IDE}}
case "$type" in
e*|E*|st*|ST*)
echo -n "Does it support AUTOMATIC sector remapping? [y] "
read remap junk
case "$remap" in
n*|N*)
sect_fwd="sf:"
;;
esac
case "$type" in
e*|E*)
DEFSECT=36
;;
esac
;;
i*|I*)
type=ST506
;;
sc*|SC*)
drivename=sd0
drivetype=sd
type=SCSI
DEFSECT=32
DEFHEAD=64
;;
*)
echo "Unknown type. Assuming ST506 with automatic sectoring..."
type=ST506
;;
esac
echo -n "Install onto which drive [$drivename] "
read resp junk
drivename=${resp:-${drivename}}
echo
echo "Disk $drivename is of device type $drivetype."
if [ ! "$partition" ]; then
echo
echo "Please wait. Examining device /dev/r${drivename}d..."
get_fdisk_data
if [ $? -gt 1 ]; then
echo "Hm - we can't seem to read that drive."
echo
echo -n "Are you sure that $type is the correct type? [n] "
read resp
case "$resp" in
y*|Y*)
echo
echo "Well, since we can't even open it, there isn't much"
echo "hope for writing a label on it. But you're free"
echo "to give it a try. You need to specify the geometry."
;;
*)
echo
echo "Okay. Let's start again from the top."
continue
;;
esac
fi
fi
echo
echo "Now we want to build a data base entry in /etc/disktab describing"
echo "the geometry of the /dev/$drivename disk. The name of the entry"
echo "should be descriptive of the disk's type and model. For example,"
echo "a Maxtor IDE, model 7080 disk might be named \`maxtor7080'."
echo -n "Disk label name (one word, please)? [${name:-mfr_model}] "
read resp junk
name=${resp:-${name:-mfr_model}}
echo
echo "${OPSYSTEM} should use the same hard disk geometry as used by other"
echo "operating systems on the hard disk."
echo -n "Number of bytes per disk sector? [${bytes_per_sect:-512}] "
read resp junk
bytes_per_sect=${resp:-${bytes_per_sect:-512}}
echo
echo -n "Total number of disk cylinders? [${cyls_per_disk:-${DEFCYLN}}] "
read resp junk
cyls_per_disk=${resp:-${cyls_per_disk:-${DEFCYLN}}}
echo
echo -n "Number of disk heads (i.e., tracks/cylinder)? [${tracks_per_cyl:-${DEFHEAD}}] "
read resp junk
tracks_per_cyl=${resp:-${tracks_per_cyl:-${DEFHEAD}}}
echo
echo -n "Number of disk sectors (i.e., sectors/track)? [${sects_per_track:-${DEFSECT}}] "
read resp junk
sects_per_track=${resp:-${sects_per_track:-${DEFSECT}}}
cylindersize=`expr $sects_per_track \* $tracks_per_cyl`
disksize=`expr $cylindersize \* $cyls_per_disk`
mb_sect=`expr 1024 \* 1024 / $bytes_per_sect`
mb_per_disk=`expr $disksize / $mb_sect`
opsys_cyls_min=`expr $DISKMIN \* $mb_sect / $cylindersize`
analyze_fdisk_data
if [ $? -eq 0 ]; then
partition=`expr $cyls_per_opsys \* $cylindersize`
part_offset=`expr $opsys_off \* $cylindersize`
fi
echo
echo "Disk has a total of $mb_per_disk Mb."
echo "The size of the ${OPSYSTEM} portion of the disk must be at least"
echo "${opsys_cyls_min} cylinders, and should not exceed $(expr $cyls_per_disk - 1) cylinders."
echo "The offset of ${OPSYSTEM} from the beginning of the disk should be at"
echo "least 1 cylinder."
echo
echo "For efficiency, partitions begin and end on cylinder boundaries."
echo "If you know the size NN in Megabytes (Mb) of a partition you want, then"
echo "use the following formula to determine the number NC of cylinders to use:"
echo " NC = integer { ( NN * $mb_sect ) / $cylindersize }"
while :; do
echo -n "Total size of the ${OPSYSTEM} portion of the disk (in cylinders)? [${cyls_per_opsys:-`expr ${cyls_per_disk} - 1`}] "
read resp junk
cyls_per_opsys=${resp:-${cyls_per_opsys:-`expr ${cyls_per_disk} - 1`}}
partition=`expr $cyls_per_opsys \* $cylindersize`
if [ $cyls_per_opsys -lt $cyls_per_disk -a ! "$force_offset" ]; then
echo
echo -n "Offset of ${OPSYSTEM} from beginning of disk (in cylinders)? [${opsys_off:-1}] "
read resp junk
opsys_off=${resp:-${opsys_off:-1}}
else
echo
echo " WARNING: Existing partitions will be lost. In addition,"
echo " installing at cylinder 0 may cause problems for some disk"
echo " controllers. If the filesystem is corrupted or install"
echo " fails, install at cylinder 1."
RUN_FDISK=""
cyls_per_opsys=$cyls_per_disk
partition=$disksize
opsys_off=0
fi
part_offset=`expr $opsys_off \* $cylindersize`
opsys_extent=`expr $opsys_off + $cyls_per_opsys`
if [ ${opsys_extent} -gt ${cyls_per_disk} ]; then
echo
echo "${OPSYSTEM} Size + Offset cannot exceed ${cyls_per_disk} cylinders."
elif [ ${cyls_per_opsys} -lt ${opsys_cyls_min} ]; then
echo
echo "${OPSYSTEM} requires at least ${opsys_cyls_min} cylinders to install."
else break
fi
done
badspacesec=0
if [ "$sect_fwd" = "sf:" ]; then
badspacecyl=`expr $sects_per_track + 126`
badspacecyl=`expr $badspacecyl + $cylindersize - 1`
badspacecyl=`expr $badspacecyl / $cylindersize`
badspacesec=`expr $badspacecyl \* $cylindersize`
echo
echo -n "Using $badspacesec sectors ($badspacecyl cylinders) for the "
echo "bad144 bad block table"
fi
whats_left=`expr $partition - $badspacesec`
cyl_left=`expr $whats_left / $cylindersize`
mb_left=`expr $whats_left / $mb_sect`
swap_cyls_min=`expr $SWAPMIN \* $mb_sect / $cylindersize`
root_cyls_max=`expr ${cyl_left} - ${swap_cyls_min}`
root_cyls_min=`expr $ROOTMIN \* $mb_sect / $cylindersize`
echo
echo "There are $mb_left Mb ($cyl_left cylinders) to allocate."
echo
echo "The $OPSYSTEM portion of the disk must itself be divided into at least"
echo "two partitions: one for the root filesystem and one for swap. It is a"
echo "good idea to have at least a third (large) $OPSYSTEM partition for the /usr"
echo "filesystem."
echo
echo "The root partition cannot exceed ${root_cyls_max} cylinders. It is usually"
echo "no larger than about 15 Mb ($(expr 15 \* $mb_sect / $cylindersize) cylinders), and sometimes"
echo "as small as $ROOTMIN Mb ($root_cyls_min cylinders)."
if [ ! "$cyls_per_root" ]; then
# set default root partition to 15MB
cyls_per_root=`expr \( 15 \* $mb_sect \) / $cylindersize`
usr_cyls_max=`expr ${root_cyls_max} - ${cyls_per_root}`
mb_usr=`expr ${usr_cyls_max} \* $cylindersize / $mb_sect`
[ $cyls_per_root -gt $root_cyls_max -o $mb_usr -lt $USRMIN ] &&
cyls_per_root=$root_cyls_max
fi
while :; do
echo -n "Root partition size (in cylinders)? [${cyls_per_root}] "
read resp junk
cyls_per_root=${resp:-${cyls_per_root}}
root=`expr $cyls_per_root \* $cylindersize`
if [ ${cyls_per_root} -gt ${root_cyls_max} ]; then
echo
echo "The root partition size cannot exceed $root_cyls_max cylinders."
elif [ ${cyls_per_root} -lt ${root_cyls_min} ]; then
echo
echo "The root partition size must be at least $root_cyls_min cylinders."
else
part_used=`expr $root + $badspacesec`
break
fi
done
root_offset=$part_offset
whats_left=`expr $partition - $part_used`
cyl_left=`expr $whats_left / $cylindersize`
mb_left=`expr $whats_left / $mb_sect`
blocking_factor=2
fragsize=`expr $bytes_per_sect \* $blocking_factor`
blocksize=`expr $bytes_per_sect \* $blocking_factor \* 8`
memsize=`dmesg | grep "^real mem" | awk '{ print $4 }'`
mb_ram=`expr \( $memsize / 1024 / 1024 \) + 1`
swap_mb=`expr \( 21 \* $mb_ram \) / 10`
echo
echo "$mb_left Mb ($cyl_left cylinders) remaining in ${OPSYSTEM} portion of disk."
echo
echo "Minimum swap space is $SWAPMIN Mb (${swap_cyls_min} cylinders.)"
echo "For running X, with your RAM size of $mb_ram Mb,"
echo "$swap_mb Mb (`expr \( \( 21 \* $mb_ram \* $mb_sect \) / 10 / ${cylindersize} \)` cylinders) of swap is recommended."
if [ ! "$swap_cyl" ]; then
swap_cyl=`expr \( 21 \* $mb_ram \* $mb_sect \) / 10`
swap_cyl=`expr $swap_cyl / ${cylindersize}`
# but not swap size more than 10% of disk size...
swap_quot=`expr $mb_left / $mb_ram`
if [ $swap_quot -lt 10 ]; then
swap_cyl=$swap_cyls_min
fi
fi
while :; do
echo -n "Swap partition size (in cylinders)? [${swap_cyl}] "
read resp junk
swap_cyl=${resp:-${swap_cyl}}
swap=`expr $swap_cyl \* $cylindersize`
if [ ${swap_cyl} -gt ${cyl_left} ]; then
echo
echo "Swap size cannot exceed $cyl_left cylinders."
elif [ ${swap_cyl} -lt ${swap_cyls_min} ]; then
echo
echo "Swap size must be at least ${swap_cyls_min} cylinders."
else
break
fi
done
swap_offset=`expr $root_offset + $root`
part_used=`expr $part_used + $swap`
echo "" >/etc/disktab
echo "$name|${OPSYSTEM} installation generated:\\" >>/etc/disktab
echo " :dt=${type}:ty=winchester:\\" >>/etc/disktab
echo -n " :nc#${cyls_per_disk}:ns#${sects_per_track}" >>/etc/disktab
echo ":nt#${tracks_per_cyl}:\\" >>/etc/disktab
echo " :se#${bytes_per_sect}:${sect_fwd}\\" >>/etc/disktab
echo -n " :pa#${root}:oa#${root_offset}" >>/etc/disktab
echo ":ta=4.2BSD:ba#${blocksize}:fa#${fragsize}:\\" >>/etc/disktab
echo " :pb#${swap}:ob#${swap_offset}:tb=swap:\\" >>/etc/disktab
echo " :pc#${partition}:oc#${part_offset}:\\" >>/etc/disktab
ename="";fname="";gname="";hname=""
if [ $part_used -lt $partition ]; then
echo
echo "Now we enter information about any other partitions and filesystems"
echo "to be created in the ${OPSYSTEM} portion of the disk. This process"
echo "is complete when we've filled up all remaining space in the ${OPSYSTEM}"
echo "portion of the disk."
fi
while [ $part_used -lt $partition ]; do
part_size=0
whats_left=`expr $partition - $part_used`
cyl_left=`expr $whats_left / $cylindersize`
mb_left=`expr $whats_left / $mb_sect`
echo
echo "$mb_left Mb ($cyl_left cylinders) remaining in ${OPSYSTEM} portion of disk."
echo
while :; do
echo -n "Next partition size (in cylinders)? [${cyl_left}] "
read resp junk
part_size=${resp:-${cyl_left}}
part_size=`expr $part_size \* $cylindersize`
total=`expr $part_used + $part_size`
if [ $total -gt $partition ]; then
echo
echo "Partition size cannot exceed ${cyl_left} cylinders."
else
part_used=$total
part_name=""
while [ "$part_name" = "" ]; do
echo
echo -n "On which directory should this filesystem be mounted? [usr] "
read resp junk
part_name=${resp:-usr}
part_name=`expr X"$part_name" : 'X/*\(.*\)'`
done
break
fi
done
if [ ! "$ename" ]; then
ename=$part_name
offset=`expr $part_offset + $root + $swap`
echo -n " :pe#${part_size}:oe#${offset}" >>/etc/disktab
echo ":te=4.2BSD:be#${blocksize}:fe#${fragsize}:\\" >>/etc/disktab
offset=`expr $offset + $part_size`
elif [ ! "$fname" ]; then
fname=$part_name
echo -n " :pf#${part_size}:of#${offset}" >>/etc/disktab
echo ":tf=4.2BSD:bf#${blocksize}:ff#${fragsize}:\\" >>/etc/disktab
offset=`expr $offset + $part_size`
elif [ ! "$gname" ]; then
gname=$part_name
echo -n " :pg#${part_size}:og#${offset}" >>/etc/disktab
echo ":tg=4.2BSD:bg#${blocksize}:fg#${fragsize}:\\" >>/etc/disktab
offset=`expr $offset + $part_size`
elif [ ! "$hname" ]; then
hname=$part_name
echo -n " :ph#${part_size}:oh#${offset}" >>/etc/disktab
echo ":th=4.2BSD:bh#${blocksize}:fh#${fragsize}:\\" >>/etc/disktab
part_used=partition
fi
done
if [ "$have_dos_part" -a "$have_dos_part" != "$opsys_part" -a \
"$RUN_FDISK" != "overwrite" -a ! "$hname" ]; then
echo
echo "There appears to be a MS-DOS filesystem on the hard disk."
echo -n "Make this be accessible from ${OPSYSTEM}? [y] "
read resp junk
case "${resp:-y}" in
y*|Y*)
part_name=""
while [ "$part_name" = "" ]; do
echo
echo -n "On which directory should this filesystem be mounted? [dos] "
read resp junk
part_name=${resp:-dos}
part_name=`expr X"$part_name" : 'X/*\(.*\)'`
done
hname=$part_name
eval offset=\$start${have_dos_part}
eval part_size=\$size${have_dos_part}
echo -n " :ph#${part_size}:oh#${offset}" >>/etc/disktab
echo ":th=MSDOS:\\" >>/etc/disktab
part_used=partition
;;
*)
have_dos_part=""
;;
esac
else
have_dos_part=""
fi
echo " :pd#${disksize}:od#0:" >>/etc/disktab
sync
# cat /etc/disktab
OIFS=$IFS
IFS='
'
while read data; do
echo $data
done < /etc/disktab
IFS=$OIFS
echo
echo -n "Verbose installation? [n] "
read resp
case $resp in
y*)
cpioverbose=-v
;;
*)
cpioverbose=
;;
esac
echo
echo "OK! THIS IS THE LAST CHANCE!!! Data on the hard disk wil be lost."
echo -n "Are you sure you want to install on the hard drive? (yes/no) "
resp=""
while [ ! "$resp" ]; do
read resp junk
case "$resp" in
Yes|yes|YES)
verified_install=1
echo
echo "OK! Here we go..."
;;
No|no|NO)
echo
echo -n "Would you like to change the configuration? [y] "
read resp junk
resp=${resp:-y}
case "$resp" in
y*|Y*)
;;
*)
echo
echo "OK, then. Enter 'halt' to halt the machine."
echo "Once the machine has halted, remove the floppy,"
echo "and press any key to reboot."
exit
;;
esac
;;
*)
echo "Please spell out either of \`yes' or \`no'..."
echo -n "Install on the hard disk? (yes/no) "
resp=
;;
esac
done
done # End of Big Loop
put_fdisk_data
echo
echo -n "Labelling disk..."
echo y |
disklabel -w -r ${drivename} $name \
${CDROM_FILESYSTEM}/usr/mdec/${drivetype}boot \
${CDROM_FILESYSTEM}/usr/mdec/boot${drivetype}
# XXX >/dev/null 2>&1
echo " done."
if [ "$sect_fwd" = "sf:" ]; then
echo -n "Initializing bad144 badblock table..."
bad144 $drivename 0
echo " done."
echo "Updating badblock table..."
# `2>&1 >/dev/null' filters stdout and leaves only stderr...
badlist=$(bad144 -s $drivename 2>&1 >/dev/null |
while read data; do
bad_seek=$(expr "$data" : '[^(]*(seek)[^0-9]*\([0-9]*\)')
bad_read=$(expr "$data" : '[^(]*(read)[^0-9]*\([0-9]*\)')
[ "$bad_seek" -o "$bad_read" ] && echo -n "$bad_seek $bad_read "
done)
[ "$badlist" ] && bad144 -a -c $drivename $badlist
echo " done."
fi
echo "Initializing root filesystem, and mounting..."
newfs ${rotdelay} /dev/r${drivename}a $name
mount -v /dev/${drivename}a /mnt
if [ "$ename" != "" ]; then
echo
echo "Initializing $ename filesystem, and mounting..."
newfs ${rotdelay} /dev/r${drivename}e $name
mkdir -p /mnt/$ename
mount -v /dev/${drivename}e /mnt/$ename
fi
if [ "$fname" != "" ]; then
echo
echo "Initializing $fname filesystem, and mounting..."
newfs ${rotdelay} /dev/r${drivename}f $name
mkdir -p /mnt/$fname
mount -v /dev/${drivename}f /mnt/$fname
fi
if [ "$gname" != "" ]; then
echo
echo "Initializing $gname filesystem, and mounting..."
newfs ${rotdelay} /dev/r${drivename}g $name
mkdir -p /mnt/$gname
mount -v /dev/${drivename}g /mnt/$gname
fi
if [ "$hname" != "" ]; then
echo
if [ ! "$have_dos_part" ]; then
echo "Initializing $hname filesystem, and mounting..."
newfs ${rotdelay} /dev/r${drivename}h $name
else
echo "Initializing $hname filesystem..."
fi
mkdir -p /mnt/$hname
[ ! "$have_dos_part" ] &&
mount -v /dev/${drivename}h /mnt/$hname
fi
echo
echo "Please wait. Copying to disk..."
cd /mnt
cat $CDROM_BINDIST | \
gunzip | tar --extract --file - --preserve-permissions ${cpioverbose}
echo "/dev/${drivename}a / ufs rw 1 1" >etc/fstab
if [ "$ename" != "" ]; then
echo "/dev/${drivename}e /$ename ufs rw 1 2" >>etc/fstab
fi
if [ "$fname" != "" ]; then
echo "/dev/${drivename}f /$fname ufs rw 1 3" >>etc/fstab
fi
if [ "$gname" != "" ]; then
echo "/dev/${drivename}g /$gname ufs rw 1 4" >>etc/fstab
fi
if [ "$hname" != "" ]; then
if [ ! "$have_dos_part" ]; then
echo "/dev/${drivename}h /$hname ufs rw 1 5" >>etc/fstab
else
echo "/dev/${drivename}h /$hname pcfs rw 0 0" >>etc/fstab
fi
fi
cat /etc/disktab >etc/disktab.install
cp -p /kernel /mnt
echo
echo "Building /dev files..."
chroot /mnt sh <<!
cd /dev
sh MAKEDEV all
cd /
!
echo " done."
echo "You will now be prompted for information about this"
echo "machine. If you hit return, the default answer (in"
echo "brackets) will be used."
echo
echo -n "What is this machine's hostname? [unknown.host.domain] "
read hname
if [ "$hname" = "" ]; then
hname=unknown.host.domain
fi
echo $hname > /mnt/etc/myname
proto_domain=`echo $hname | sed -e 's/[^.]*\.//'`
echo
echo "What domain is this machine in (this is NOT its YP"
echo -n "domain name)? [$proto_domain] "
read dname
if [ "$dname" = "" ]; then
dname=$proto_domain
fi
echo
echo -n "Does this machine have an ethernet interface? [y] "
read resp
case "$resp" in
n*)
;;
*)
intf=
while [ "$intf" = "" ]; do
echo -n "What is the primary interface name (i.e. ed0, etc.)? "
read intf
done
echo -n "What is the hostname for this interface? [$hname] "
read ifname
if [ "$ifname" = "" ]; then
ifname=$hname
fi
ifaddr=
while [ "$ifaddr" = "" ]; do
echo -n "What is the IP address associated with this interface? "
read ifaddr
done
echo "$ifaddr $ifname `echo $ifname | sed -e s/\.$dname//`" \
>> /mnt/etc/hosts
echo -n "Does this network have a special netmask? [n] "
read resp
case "$resp" in
y*)
echo -n "What is the netmask? [0xffffff00] "
read resp
if [ "$resp" = "" ]; then
ifnetmask="netmask 0xffffff00
else
ifnetmask="netmask $resp"
fi
;;
*)
ifnetmask=
;;
esac
echo -n "Does this network need additional flags? [n] "
read resp
case "$resp" in
y*)
echo -n "What flags? [llc0] "
read ifflags
if [ "$ifflags" = "" ]; then
ifflags=llc0
fi
;;
*)
ifflags=
;;
esac
echo "inet $ifname $ifnetmask $ifflags" > /mnt/etc/hostname.$intf
echo ""
echo "WARNING: you will need to finish the configuration of your"
echo "network by editing /etc/netstart, read the comments in that"
echo "file for more instructions."
;;
esac
echo
echo "Your system should be set up now for operation."
sync
echo
echo "The next step: reboot from the hard disk and enjoy the system!"
echo
echo "To do this, enter \`halt' now to halt the machine. After it"
echo "announces that it has halted, remove the floppy from the drive"
echo "and press any key to boot."
echo
echo "Okay, that's all for now. I'm waiting for you to enter \`halt'..."