DataMuseum.dk

top - download

    Length: 20986 (0x51fa)
    Types: TextFile
    Notes: @(#)install.sh 13.18 (RC international) 91/12/16
    Names: »TXinstall«

└─⟦50656ff4a⟧ Bits:30010538 TX 3.1 Coldstart
    └─⟦bbf173f5c⟧ »0004« 
        └─⟦this⟧ »./usr/pkg/TXinstall« 

TextFile

#!/bin/sh
#
#	@(#)install.sh	13.18 (RC international) 91/12/16
#

#			TX System Software Installation Script
#	********************************************************************
#	This script is intended to be run first on the mini root after it has
#	been dropped from tape.  The script assumes a standard installation.
#	That is:
#
#	volume		vol name	fs name		lv name
#	--------------------------------------------------------------------
#	miniroot	miniroot_<pu>	NA		NA
#	swap		swap_<pu>	NA		NA
#	globalroot	root		/root		/dev/lvroot
#	localroot	<pu>		/<pu>		/dev/lv<pu>
#	dump		dump_<pu>	/dump/<pu>	/dev/lvdump_<pu>
#
#	Boot each PU (in turn) from the mini root, run this script, and then
#	halt the PU.  After running this script on each PU mini root, all
#	PUs should be booted to the local root and ONE PU (re)booted to the
#	global root.  The global root PU should then re-execute this script.
#	After this, ALL PUs should then be (re)booted to the global root.
#
#	The mini root should be booted via "miniroot_<pu>/txload -v".
#	********************************************************************
#

#
#	STEP 1B: Initial Set Up
#

cd /
pu=`puname`
prog=TXinstall

release=`/bin/uname -r`
stamp=`echo stamp_*`
oldstamp=""
marker=.globalroot.to.be.done
stampexists=0
rootexists=0
localrootexists=0
swapexists=0
dumpexists=0
rootinstall=0
VoldescUsed=0

pkg=/usr/pkg
presdir=$pkg/tx/preserves
preslocal=$presdir/localroot
presglobal=$presdir/globalroot
logdir=$pkg/tx/logs
instlog=$logdir/TXinstall

tmpok=/tmp/${prog}OK
tmpsubputab=/tmp/${prog}subputab

readtape() {
	while : ; do
		huh="Installation Tape Ready?"
		eval "$yesorno"
		if test "$ans" = no
		then
			continue
		fi
		cd $1
		echo Locating $2 Files On Tape ...
		(set -e
		 mt rewind
		 mt fsf $3
		)
		if [ "$?" != 0 ]; then
			continue
		fi
		echo Reading $2 Files From Tape ...
		logmsg tar xvp \($2\)
		rm -f $tmpok
		if tar xvp 2>&1; then
			> $tmpok
		fi | tee -a $instlog
		if [ -r $tmpok ]; then
			return
		fi
		huh="Retry With Best-extent-size Fit?"
		eval "$yesorno"
		if [ "$ans" = no ]; then
			continue
		fi
		logmsg tar xvpC \($2\)
		rm -f $tmpok
		if tar xvpC 2>&1; then
			> $tmpok
		fi | tee -a $instlog
		if [ -r $tmpok ]; then
			return
		fi
		continue
	done
}

logmsg() {
	echo '***' `date` $pu $* >> $instlog
}

kernellist() {
    s=`echo $1`
    if [ "$s" != "$1" ]; then
	for k in $s; do
	    case $k in
	    $init|$upu|$rpu)	;;
	    *)		kernels="$kernels $k";;
	    esac
	done
    fi
}

trap '
if test "$status" = ok -a "$?" = 0
then
	rm -f /tmp/${prog}* /tmp/sh*
	echo; echo "Normal Program Termination"
	logmsg "Normal Program Termination\n"
else
	rm -f /tmp/${prog}* /tmp/sh*
	case $root in
	Mini)	if test -d /$pu
		then
		    cd /$pu
		    $pkg/preserve -r $release < $preslocal > /dev/null 2>&1
		    if [ -f txload:${release}- ]; then
			mv txload:${release}- txload
		    fi
		fi
		if test -d /root
		then
		    cd /root
		    $pkg/preserve -r $release < $presglobal > /dev/null 2>&1
		fi
		;;
	*)	;;
	esac
	echo; echo "Abnormal Program Termination"
	logmsg "Abnormal Program Termination\n"
fi' 0

doread='echo "$huh \c"
read ans
if test "$interrupt"
then
	interrupt=""
	continue
fi'

yorn="'yes' or 'no'"
yesorno='while :
do
	eval "$doread"
	if test "$ans" = no -o "$ans" = yes
	then
		break
	fi
	echo; echo "*** Answer Must be $yorn"; echo
done'

trap 'if test "$huh" = Exit?
then
	status=oops; exit 0
fi
huhsave="$huh"
echo
huh="Exit?"
eval "$yesorno"
if test "$ans" = yes
then
	status=oops; exit 0
else
	interrupt=1; huh="$huhsave"; echo
fi' 2

#
#	STEP 2B: Issue Greeting (Depending on Where We Are)
#

if test -f /.Global.root
then
	root=Global
else
	root=Mini
fi
echo; echo "${root} Root Installation"
logmsg ${root} Root Installation TX release $release

#
#	STEP 3M: Make Mini Root Nodes (Do This BEFORE Checking Environment)
#

if test "$root" = Mini
then
	echo; echo "OK: Make Mini Root Device Nodes ..."
	logmsg mknodes -m -r
	/$pkg/mknodes -m -r 2>&1  | tee -a $instlog
fi

#
#	STEP 4B: Set Up Environment (TERM and TAPE Variables)
#

echo; echo "OK: Check Environment ..."
if test -z "$TERM"
then
	TERM=qs
fi
while :
do
	huh="Enter TERM Type (Default '$TERM') >"
	eval "$doread"
	if test -z "$ans"
	then
		ans="$TERM"
	fi
	break
done
TERM="$ans"; export TERM

if test -z "$TAPE"
then
	TAPE=/dev/mt_$pu
fi
while :
do
	if [ "`echo /dev/mt_*`" != "/dev/mt_$pu" ]; then
		echo "OK: Select the Tape Device Among the Following:"
		ls -l /dev/mt_*
	fi
	huh="Enter TAPE Device (Default '$TAPE') >"
	eval "$doread"
	if test -z "$ans"
	then
		ans="$TAPE"
	fi
	if test ! -r "$ans"
	then
		echo "No Such Device: $ans"
		ans=""
		continue
	fi
	break
done
TAPE="$ans"; export TAPE

#
#	********************************************************************
#	This is the first part of the installation.  It should be run on
#	the mini root while all other (dual-port) PUs are halted.
#	********************************************************************
#

#
#	STEP 5M: Deposit Bootstrap Loader
#

if test "$root" = Mini
then
	echo "\nOK: Deposit Bootstrap Loader On Disks ..."
	for disk in `ls -d /dev/ds_*`
	do
		huh="\nDeposit Bootstrap Loader on Disk '$disk'?"
		eval "$yesorno"
		if [ "$ans" = yes ]; then
			formatdisk -b $disk
		fi
	done

#
#	STEP 6M: Should Global Root Files Be Installed?
#

	echo; echo "OK: Global Root Files Must Be Installed Only Once ..."
	huh="Should They Be Installed From This PU?"
	eval "$yesorno"
	if test "$ans" = yes
	then
		rootinstall=1
	fi

#
#	STEP 7M: Ascertain Volume Situation
#

	echo "\nOK: Check the System Volumes ..."
	s="	$pu swap_$pu dump_$pu"
	if [ "$rootinstall" = 1 ]; then
		s="$s root"
	fi
	echo "These Volumes Must Be Present:\n\t$s"
	list=`
		vol volinfo |
		sed -e '
			1d
			s|.* \(.*\)|\1|
		'
	`
	for vol in $list; do
		case $vol in
			root)		rootexists=1
					sysvol="$sysvol $vol";;
			$pu)		localrootexists=1
					sysvol="$sysvol $vol";;
			swap_$pu)	swapexists=1
					sysvol="$sysvol $vol";;
			dump_$pu)	dumpexists=1
					sysvol="$sysvol $vol";;
		esac
	done
	if [ "$rootexists" = 1 -a ! -d /root ]; then
		mount /dev/lvroot
	fi
	oldstamp="`expr /root/stamp_* : \".*\(stamp_.*\)\"`"
	if [ "$stamp" = "$oldstamp" ]; then
		stampexists=1
	fi
	if [ "$rootinstall" = 1 -a "$rootexists" = 0 ]; then
	    echo "\nOK: The Volume \"root\" Is Missing ..."
	    huh="Confirm That Global Root Files Should Be Installed From This PU (yes/no) >"
	    eval "$yesorno"
	    if [ "$ans" = no ]; then
		rootinstall=0
		echo "OK: Global Root Files Will Not Be Installed From This PU"
		# Give time to read message.
		sleep 5
	    fi
	fi
	if [ "$rootinstall" = 1 -a "$stampexists" = 1 ]; then
	    echo "\nOK: The Global Root Files May Be Installed Already ..."
	    huh="Install Them Anyway?"
	    eval "$yesorno"
	    if [ "$ans" = no ]; then
		rootinstall=0
		echo "OK: Global Root Files Will Not Be Installed From This PU"
	    fi
	fi
	for vol in root $pu swap_$pu dump_$pu; do
		if [ "`expr \"$sysvol\" : \".* $vol\"`" = 0 ]; then
			if [ "$vol" != root -o \
			\( "$vol" = root -a "$rootinstall" = 1 \) ]; then
				misvol="$misvol $vol"
			fi
		fi
	done
	if [ -n "$misvol" ]; then
		echo "\nThe Following System Volumes are missing:\n\t$misvol"
	else
		echo "\nAll Needed System Volumes Are Present"
	fi

#
#	STEP 8M: Update the Voldesc File (Do This BEFORE Modifying Volinfo)
#

	if [ -n "$misvol" ]; then
		echo "\nOK: System Volumes Are Missing and Must Be Created"
		echo "Specify a Volume Description File to Use ..."
		while :
		do
			huh="1) Use the Global Root '/etc/voldesc' File
2) Restore './etc/voldesc' From Tape
3) Use the Mini Root '/etc/voldesc' File
4) Create '/etc/voldesc' From System
>"
			eval "$doread"
			case $ans in
			1)	if test "$root" = Global
				then
					break
				fi
				if test -d /root
				then
					cp /root/etc/voldesc /etc/voldesc
					break
				fi
				(set -e
				 mount /dev/lvroot
				 cp /root/etc/voldesc /etc/voldesc
				 umount /dev/lvroot)
				if test "$?" = 0
				then
					break
				fi
				echo "Sorry, the Global Root is Unavailable"
				;;
			2)	while :
				do
					echo
					huh="Configuration Files Tape Ready?"
					eval "$yesorno"
					if test "$ans" = no
					then
						break
					fi
					(set -e
					 mt rewind	# Assumes BOT!
					 tar xvpmC ./etc/voldesc
					)
					if [ "$?" = 0 ]; then
						break
					fi 
					(set -e
					 mt rewind
					 tar xvpmC etc/voldesc
					)
					if [ "$?" = 0 ]; then
						break
					fi 
				done
				if test "$ans" = yes
				then
					break
				fi
				;;
			3)	break
				;;
			4)	mkvoldesc > /etc/voldesc
				break
				;;
			*)	echo "Invalid Selection (Use 1, 2, 3, or 4)"
			esac
			echo
		done
		echo
		while :
		do
			huh="Edit the '/etc/voldesc' File?"
			eval "$yesorno"
			if test "$ans" = no
			then
				break
			fi
#
#	Use mini root tmp, not the default 'vi' tmp directory '/<pu>/tmp'
#
			EXINIT="set dir=/tmp" vi -z /etc/voldesc
		done
		VoldescUsed=1
	fi

#
#	STEP 9M: Make Swap Volume (Assumes "swap_<pu>")
#

	if [ "$swapexists" = 0 ]; then
		echo; echo "OK: Make the 'swap_$pu' Volume ..."
		mkvol -q -i miniroot_$pu swap_$pu
		if test "$?" != 0
		then
			echo "Failed: mkvol -q -i miniroot_$pu swap_$pu"
			status=oops; exit 1
		fi
	fi

#
#	STEP 10M: Make Dump Volume (Assumes "dump_<pu>")
#

	if [ "$dumpexists" = 0 ]; then
		echo; echo "OK: Make the 'dump_$pu' Volume ..."
		(set -e
		 mkvol -q -i miniroot_$pu dump_$pu
		 mkfs /dev/lvdump_$pu
		 mount /dev/lvdump_$pu)
		if test "$?" != 0
		then
			echo "Could Not Make the 'dump_$pu' Volume"
			status=oops; exit 1
		fi
	fi

#
#	STEP 11M: Make or Preserve Local Root Volume (Assumes "<pu>")
#

	if [ "$localrootexists" = 0 ]; then
		makevl=1
		makefs=1
	else
		makevl=0
		makefs=0
		echo; echo "OK: Check the '$pu' Volume ..."
		huh="Make the '$pu' File System Before Installation?"
		eval "$yesorno"
		if test $ans = yes
		then
			makefs=1
		fi
	fi
	if test "$makefs" = 1
	then
		echo; echo "OK: Make the '$pu' Volume ..."
		if test -d /$pu			# safety
		then
			umount /dev/lv$pu
		fi
		if test "$makevl" = 1
		then
			mkvol -q -i miniroot_$pu $pu
			if test "$?" != 0
			then
				echo "Failed: mkvol -q -i miniroot_$pu $pu"
				status=oops; exit 1
			fi
			#
			# If the local root volume already contains a file
			# system, it will be mounted again by the volume
			# manager after mkvol.
			# Use "ls" to synchronize if this is the case.
			#
			if dumpfs /dev/lv$pu > /dev/null 2>&1; then
				ls /$pu/dummy > /dev/null 2>&1
			fi
		fi
		if test -d /$pu
		then
			umount /dev/lv$pu
		fi
		(set -e
		 mkfs /dev/lv$pu
		 mount /dev/lv$pu)
		if test "$?" != 0
		then
			echo "Could Not Make the '$pu' Volume"
			status=oops; exit 1
		fi
	else
		echo; echo "OK: Preserve Files In the '$pu' File System ..."
		if test ! -d /$pu
		then
			mount /dev/lv$pu
		fi
		if test ! -d /$pu
		then
			echo "Cannot access /$pu"
			status=oops; exit 1
		fi
		cd /$pu
		if [ -f txload ]; then
			txload=`cat txload`
		fi
		logmsg "preserve -s (local root)"
		$pkg/preserve -s $release < $preslocal 2>&1 | tee -a $instlog
	fi

#
#	STEP 12M: Install Local Root Files From Tape
#

	cd /$pu
	txload="$txload EOV"
	upu=`expr "$txload" : '.*\([tT][xX]:[0-9][0-9]*\) .*'`
	rpu=`expr "$txload" : '.*\([tT][xX]:[0-9][0-9]*.rpu\) .*'`
	init=`expr "$txload" : '.*\([tT][xX]:[0-9][0-9]*.init\) .*'`
	while : ; do
		kernels=""
		kernellist 'ram_rte*'
		kernellist 'TX:*'
		kernellist 'tx:*'
		if [ -z "$kernels" ]; then
			break
		fi
		echo "\nOK: There May Not Be Space Left For the New Kernels ..."
		echo "\nOld Kernels: $kernels\n"
		df -B .
		huh="\nRemove Some Of The Old Kernels?"
		eval "$yesorno"
		if [ "$ans" = no ]; then
			break
		fi
		rm -i $kernels
	done
	echo; echo "OK: Install the Local Root Files ..."
	echo "$pu local root" > .$pu.root
	readtape /$pu "Local Root" 3
	if test "$makefs" = 1
	then
		while :
		do
			echo
			huh="Restore Local Root Configuration Files?"
			eval "$yesorno"
			if test "$ans" = no
			then
				break
			fi
			while :
			do
				echo
				huh="Configuration Files Tape Ready?"
				eval "$yesorno"
				if test "$ans" = no
				then
					break
				fi
				(set -e
				 mt rewind			# assumes BOT
				 cd /$pu; tar xvpmC)
				if test "$?" = 0
				then
					break
				fi
			done
		done
	else
		echo; echo "OK: Restore Preserved Local Root Files ..."
		cd /$pu
		logmsg "preserve -r (local root)"
		$pkg/preserve -r $release < $preslocal 2>&1 | tee -a $instlog
	fi
	if [ "$VoldescUsed" = 1 ]; then
		cp /etc/voldesc /$pu/etc/voldesc
	fi

#
#	STEP 13M: Edit the Local Root Configuration Files (Add Others)
#

	echo; echo "OK: Edit Local Root Configuration Files ..."
	while :
	do
		for vol in etc/statetab etc/inittab
		do
			while :
			do
				huh="Edit the '/$pu/$vol' File?"
				eval "$yesorno"
				if test "$ans" = no
				then
					break
				fi
				EXINIT="set dir=/tmp" vi -z /$pu/$vol
			done
		done
		(cd /$pu/etc; ./mk_config -l)
		if test "$?" = 0
		then
			break
		fi
	done

#
#	STEP 14M: Make Global Root Volume (Assumes "root")
#

	makevl=0
	makefs=0
	if test "$rootinstall" = 1
	then
		if test "$rootexists" = 0
		then
			makevl=1
			makefs=1
		else
			echo; echo "OK: Check the 'root' Volume ..."
			huh="Make the 'root' File System Before Installation?"
			eval "$yesorno"
			if test "$ans" = yes
			then
				makefs=1
			fi
		fi
#
#	else ($rootinstall = 0)
#		if test "$rootexists" = 1
#		then
#			1) Either the global root files are already installed
#			   or are to be installed in this volume
#			2) Or the volume should be deleted.
#			Assume that the user knows what he does and don't ask.
#		else
#			This is consistent - don't do anything.
#		fi
#	fi
#	if test "$rootinstall" = 1
#	then
#
		if test "$makefs" = 1
		then
			echo; echo "OK: Make the 'root' Volume ..."
			if test -d /root
			then
				umount /dev/lvroot
			fi
			if test "$makevl" = 1
			then
				mkvol -q -i miniroot_$pu root
				if test "$?" != 0
				then
				    echo "Failed: mkvol -q -i miniroot_$pu root"
				    status=oops; exit 1
				fi
			fi
			(set -e
			 mkfs /dev/lvroot
			 mount /dev/lvroot)
			if test "$?" != 0
			then
				echo "Could Not Make the 'root' Volume"
				status=oops; exit 1
			fi
		else						# $makefs = 0
			echo; echo "OK: Preserve Files In the 'root' File System ..."
			if test ! -d /root
			then
				mount /dev/lvroot
			fi
			if test ! -d /root
			then
				echo "Cannot access /root"
				status=oops; exit 1
			fi
			cd /root
			logmsg "preserve -s (global root)"
			$pkg/preserve -s $release < $presglobal 2>&1 |
			tee -a $instlog
		fi

#
#	STEP 15M: Install Global Root Files From Tape
#

		cd /root
		echo; echo "OK: Install the Global Root Files ..."
		echo "GLOBAL ROOT" > .Global.root
		readtape /root "Global Root" 4
		if test "$makefs" = 1
		then
			while :
			do
				echo
				huh="Restore Global Root Configuration Files?"
				eval "$yesorno"
				if test "$ans" = no
				then
					break
				fi
				while :
				do
					echo
					huh="Configuration Files Tape Ready?"
					eval "$yesorno"
					if test "$ans" = no
					then
						break
					fi
					(set -e
					 mt rewind	# assumes BOT
					 cd /root; tar xvpmC)
					if test "$?" = 0
					then
						break
					fi
				done
			done
			cp /root/etc/subputab $tmpsubputab
			sed "
s|pu1|$pu|g
s|pua|$pu|g
			" $tmpsubputab > /root/etc/subputab
		else
			echo; echo "OK: Restore Preserved Global Root Files ..."
			cd /root
			logmsg "preserve -r (global root)"
			$pkg/preserve -r $release < $presglobal 2>&1 |
			tee -a $instlog
		fi
		if [ "$VoldescUsed" = 1 ]; then
			cp /etc/voldesc /root/etc/voldesc
		fi

		cat <<!EOF > /root/etc/nologin

`date`
Installation of TX release $release in progress - login not possible.

!EOF

		echo `date` $prog > /root/$marker

#
#	STEP 16M: Edit the Global Root Configuration Files (Add Others)
#

		echo; echo "OK: Edit Global Root Configuration Files ..."
		cd /root
		while :
		do
			for vol in etc/inittab etc/statetab \
				   etc/subputab etc/hosts usr/lib/crontab
			do
				while :
				do
					huh="Edit the '/root/$vol' File?"
					eval "$yesorno"
					if test "$ans" = no
					then
						break
					fi
					EXINIT="set dir=/tmp" vi -z /root/$vol
				done
			done
			(cd /root/etc; ./mk_config)
			if test "$?" = 0
			then
				break
			fi
		done
	fi # $rootinstall = 1

#
#	STEP 17M: Make Local Root Nodes (Do This BEFORE Global Root Nodes)
#

	echo; echo "OK: Make Local Root Device Nodes ..."
	logmsg mknodes -l -r
	/$pkg/mknodes -l -r 2>&1 | tee -a $instlog

#
#	STEP 18M: Make Global Root Nodes for This PU
#

	if test -d /root					# safety
	then
		echo; echo "OK: Make Global Root Device Nodes ..."
		logmsg mknodes -g -r
		/$pkg/mknodes -g -r 2>&1 | tee -a $instlog
	fi

#
#	STEP 19M: Make Global Root Subpu Nodes (Do This AFTER Local Root Nodes)
#
 
	if test "$rootinstall" = 1
	then
		echo; echo "OK: Make Subpu Device Nodes ..."
		logmsg devconf -mknod
		devconf -mknod 2>&1 | tee -a $instlog
	fi

#
#	STEP 20M: Copy Log and Preserve Files to Local Root
#

	if test ! -d /$pu/usr/pkg
	then
		mkdir /$pu/usr/pkg
	fi
	cp -r /usr/pkg/tx /$pu/usr/pkg

#
#	STEP 21M: Issue Reminder 
#

	if test "$rootinstall" = 0
	then
		echo; echo "OK: Global Root Files Not Installed From This PU\c"
		if test "$stampexists" = 0
		then
			echo " - Remember To Do It From Another"
		else
			echo
		fi
	fi
fi # $root = Mini

#
#	********************************************************************
#	This is the second part of the installation.  It should be run on
#	the global root while all other PUs are booted to the local roots.
#	********************************************************************
#

#
#	STEP 22G: Which Are the Visible PU's?
#

if [ "$root" = Global ]; then

	PUlist=`
		/usr/tx/config |
		sed '
			1,2d
			s|^\([a-zA-Z0-9]*\) .*|\1|
		'
	`

#
#	STEP 23G: Install Files In /home.
#

	echo; echo "OK: Install '/home' Files ..."
	list=""
	for p in $PUlist; do
		list="$list $p dump_$p swap_$p miniroot_$p"
	done
	while : ; do
		huh="Enter Name of Volume to Contain '/home' Files
(Default 'home', 'NONE' to skip) >"
		eval "$doread"
		if [ -z "$ans" ]; then
			home=home
		elif [ "$ans" = root ]; then
			huh="Do You Really Wish to Install '/home' Files In the Global Root?"
			eval "$yesorno"
			if [ "$ans" = yes ]; then
				home=/
			else
				continue
			fi
		elif [ "$ans" = NONE ]; then
			huh="Do You Really Wish to Skip Installation of '/home' Files Now?"
			eval "$yesorno"
			if [ "$ans" = yes ]; then
				echo; echo "OK: Skipping Installation of '/home' Files For Now -
But Remember to Install Them Later"
				break;
			else
				continue
			fi
		else
			home="$ans"
		fi
		again=0
		for v in $list; do
			if [ "$home" = "$v" ]; then
				echo \'$v\' Is a System Volume And Not Allowed
				again=1
				break
			fi
		done
		if [ "$again" = 1 ]; then
			continue
		fi
		if [ "$home" != / ]; then
			expect="$home is not a logical volume"
			saw=`vol volinfo $home | sed -n -e '$p'`
			if [ "$expect" = "$saw" ]; then
				echo \'$home\' Is Not a Logical Volume
				continue
			fi
			umount /dev/lv$home 2> /dev/null
			if [ ! -r /home ] || rm /home > /dev/null 2>&1; then
			    :
			else
			    echo Unable to Create Mount Point For Volume $home -
			    echo '/home' Cannot Be Removed
			    continue
			fi
			vol fsnode $home <<EOF > /dev/null
/home
EOF
			mount /home 2> /dev/null
			if [ ! -d /home ]; then
			    echo Cannot Create Mount Point for Volume $home
			    continue
			fi
		fi
		readtape / "'/home'" 5
		break
	done

#
#	STEP 24G: Install X
#

	echo; echo "OK: Install 'X' Files ..."
	cd /
	df -B .
	echo "You Will Need At Least 40 Mbytes Free Disk Space ..."
	huh="Do You Wish to Install 'X'?"
	eval "$yesorno"
	if [ "$ans" = yes ]; then
		readtape / "'X'" 6
	else
		echo; echo OK: "You May Install 'X' Another Time"
	fi
fi

#
#	STEP 25G: Make Global Root Nodes for Everybody
#

if test "$root" = Global -a -f /$marker
then
	cd /dev
	echo; echo "OK: Make Global Root Device Nodes ..."
	logmsg mknodes -g -r -a
	/$pkg/mknodes -g -r -a 2>&1 | tee -a $instlog

#
#	STEP 26G: Copy log files from local roots to global root
#

	list=""
	for p in $PUlist; do
		list="$list /${p}${instlog}"
	done
	cat $list $instlog > $instlog+
	mv -f $instlog+ $instlog

#
#	STEP 27G: Install the Mail System
#
	echo; echo "OK: Install the Mail System ..."
	/usr/lib/sendmail -bz
	newaliases

#
#	STEP 28G: Make Some User Volumes
#

	list=`
		vol volinfo |
		sed '
			1d
			/ root /d
			/ swap /d
			/dump_/d
			/lvroot/d
			/miniroot_/d
			s/.* \(.*\)$/\1/
		'
	`
	# 
	# Is this a destructive installation?
	#
	if [ \( ! -f /etc/passwd:$release \) -a -n "$list" ]; then
		echo; echo "OK: Check User Volumes ..."
		huh="Make Mount Points (fs-nodes) For Any User Volumes?"
		eval "$yesorno"
		if test "$ans" = yes
		then
			for v in $list; do
				echo
				huh="For ${v}?"
				eval "$yesorno"
				if test "$ans" = yes
				then
					vol fsnode $v
				fi
			done
			echo
		fi
	fi
	rm -f /$marker
fi # $root = Global

#
#	STEP 29B: We are All Done
#

echo; echo "OK: All Done (${root} Root Installation) ..."
status=ok
exit 0