Hallo, dies ist ein Test.

PWD: /www/data-lst1/unixsoft/unixsoft/kaempfer/.public_html

Running in File Mode
Relative path: ./../../../../../../sbin/./root_archive
Real path: /usr/sbin/root_archive
Zurück

#!/bin/ksh -p

# Copyright (c) 2005, 2017, Oracle and/or its affiliates. All rights reserved.
#

# utility to pack and unpack a boot/root archive
# both ufs and hsfs (iso9660) format archives are unpacked
# only ufs archives are generated
#
# usage: pack   <archive> <root>
#        unpack <archive> <root>
#
#   Where <root> is the directory to unpack to and will be cleaned out
#   if it exists.
#

usage()
{
	printf "usage: root_archive pack <archive> <root>\n"
	printf "       root_archive unpack <archive> <root>\n"
	exit 2
}

cleanup()
{
	if [ -d $MNT ] ; then
		umount $MNT 2> /dev/null
		rmdir $MNT
	fi

lofiadm -d "$TMR" 2>/dev/null
        if [ "$EXTRACTED" = true ] ; then
		rm -f "$TMR"
	fi
	rm -f "$TMR.gz"
	rm -f $TMP/flist$$

if [ -d $TMP ] ; then
		rmdir $TMP
	fi
}

do_unpack()
{
	(
		cd $MNT
		find . -print | cpio -pdum "$UNPACKED_ROOT" 2> /dev/null
	)
	# increase the chances the unmount will succeed
	umount -f $MNT
}

unpack()
{
	MR=$1
	if [ ! -f "$MR" ] ; then
		printf "$MR: not found\n"
		usage
	fi

file $MR | grep -q "gzip compressed data"

if [ $? -eq 0 ] ; then
		gzcat "$MR" > $TMR
		EXTRACTED=true ; export EXTRACTED 
	else
		TMR="$MR"
	fi

LOFIDEV=`/usr/sbin/lofiadm -a $TMR`
	if [ $? != 0 ] ; then
		echo lofi plumb failed
		exit 2
	fi

mkdir -p $MNT

FSTYP=`fstyp $LOFIDEV`

if [ "$FSTYP" = ufs ] ; then
		/usr/sbin/mount -o ro,nologging $LOFIDEV $MNT
		do_unpack
	elif [ "$FSTYP" = hsfs ] ; then
		/usr/sbin/mount -F hsfs -o ro $LOFIDEV $MNT
		do_unpack
	else
		printf "invalid root archive\n"
	fi

rmdir $MNT
	lofiadm -d $TMR ; LOFIDEV=

if [ "$EXTRACTED" = true ] ; then
		rm $TMR
	fi
}

compress()
{
	SRC=$1
	DST=$2

(
		cd $SRC
		filelist=`find .`

for file in $filelist ; do

file=`echo $file | sed s#^./##`

# copy all files over to preserve hard links
			#
			echo $file | cpio -pdum $DST 2> /dev/null

if [ -f $file ] && [ -s $file ] && [ ! -h $file ] ; then
				fiocompress -mc $file $DST/$file &
			fi

done

wait `pgrep fiocompress`

# now re-copy a couple of uncompressed files

if [ -d "$SRC/platform/i86pc" ] ; then
			find `cat boot/solaris/filelist.ramdisk` -type file \
			    -print 2> /dev/null > $TMP/flist$$
			find usr/kernel -type file -print 2> /dev/null \
			    >> $TMP/flist$$
			# some of the files are replaced with links into
			# tmp/root on the miniroot, so find the backing files
			# from there as well and add them to the list ti
			# be copied uncompressed
			(
				cd $SRC/tmp/root
				find `cat ../../boot/solaris/filelist.ramdisk` \
				    -type file -print 2> /dev/null | \
				    sed 's#^#tmp/root/#' >> $TMP/flist$$
			)
			flist=`cat $TMP/flist$$`
			(
				cd $DST
				rm -f $flist
			)
			for file in $flist ; do
				echo $file | cpio -pdum $DST 2> /dev/null
			done
		else
			find kernel platform -name unix | \
			    cpio -pdum $DST 2> /dev/null
			find kernel platform -name genunix | cpio -pdum $DST \
			    2> /dev/null
			find kernel platform -name platmod | cpio -pdum $DST \
			    2> /dev/null
			find `find kernel platform -name cpu` | \
			    cpio -pdum $DST 2> /dev/null
			find `find kernel platform -name kmdb\*` | \
				cpio -pdum $DST 2> /dev/null
			find kernel/misc/sparcv9/ctf kernel/fs/sparcv9/dcfs \
			    etc/system etc/name_to_major \
			    etc/devices/inception_points \
			    etc/devices/path_to_inst \
			    etc/name_to_sysnum  etc/driver_aliases \
			    etc/driver_classes etc/minor_perm | \
			    cpio -pdum $DST 2> /dev/null
		fi
	)
}

root_is_ramdisk()
{
	grep -v "set root_is_ramdisk=" "$UNPACKED_ROOT"/etc/system | \
	    grep -v "set ramdisk_size=" > $TMP/system.$$
	cat $TMP/system.$$ > "$UNPACKED_ROOT"/etc/system
	rm $TMP/system.$$

echo set root_is_ramdisk=1 >> "$UNPACKED_ROOT"/etc/system
	echo set ramdisk_size=$1 >> "$UNPACKED_ROOT"/etc/system
}

pack()
{
	MR="$1"
	[ -d "$UNPACKED_ROOT" ] || usage

# always compress if fiocompress exists
	#
	if [ -x /usr/sbin/fiocompress ] ; then
		COMPRESS=true
	fi

# Estimate image size and add %10 overhead for ufs stuff.
	# Note, we can't use du here in case $UNPACKED_ROOT is on a filesystem,
	# e.g. zfs, in which the disk usage is less than the sum of the file
	# sizes.  The nawk code
	#
	#	{t += ($7 % 1024) ? (int($7 / 1024) + 1) * 1024 : $7}
	#
	# below rounds up the size of a file/directory, in bytes, to the
	# next multiple of 1024.  This mimics the behavior of ufs especially
	# with directories.  This results in a total size that's slightly
	# bigger than if du was called on a ufs directory.
	#
	# if the operation in turn is compressing the files the amount
	# of typical shrinkage is used to come up with a useful archive
	# size
	size=$(find "$UNPACKED_ROOT" -ls | nawk '
	    {t += ($7 % 1024) ? (int($7 / 1024) + 1) * 1024 : $7}
	    END {print int(t * 1.10 / 1024)}')
	if [ "$COMPRESS" = true ] ; then
		size=`echo $size | nawk '{s = $1} END {print int(s * 0.6)}'`
	fi

/usr/sbin/mkfile ${size}k "$TMR"

LOFIDEV=`/usr/sbin/lofiadm -a "$TMR"`
	if [ $? != 0 ] ; then
		echo lofi plumb failed
		exit 2
	fi

RLOFIDEV=`echo $LOFIDEV | sed s/lofi/rlofi/`
	newfs $RLOFIDEV < /dev/null 2> /dev/null
	mkdir -p $MNT
	mount -o nologging $LOFIDEV $MNT
	rmdir $MNT/lost+found

if [ -d "$UNPACKED_ROOT/kernel/drv/sparcv9" ] ; then
		root_is_ramdisk $size
	fi

(
		cd "$UNPACKED_ROOT"
		if [ "$COMPRESS" = true ] ; then
			compress . $MNT
		else
			find . -print | cpio -pdum $MNT 2> /dev/null
		fi
	)
	lockfs -f $MNT
	umount $MNT
	rmdir $MNT

if [ -d "$UNPACKED_ROOT/kernel/drv/sparcv9" ] ; then
		"$UNPACKED_ROOT/usr/sbin/installboot" \
		    "$UNPACKED_ROOT/platform/sun4v/lib/fs/ufs/bootblk" \
		    $RLOFIDEV
	fi

lofiadm -d $LOFIDEV
	LOFIDEV=

rm -f "$TMR.gz"

if [ -d "$UNPACKED_ROOT/kernel/drv/sparcv9" ] ; then
		mv "$TMR" "$MR"
	else
		gzip -f "$TMR"
		mv "$TMR.gz" "$MR"
	fi

chmod a+r "$MR"
}

strip_amd64()
{
	find "$UNPACKED_ROOT" -name amd64 -type directory | xargs rm -rf
}

# main
#

EXTRA_SPACE=0
STRIP_AMD64=
COMPRESS=

PATH=/usr/sbin:/usr/bin ; export PATH

while getopts s:6c opt ; do
	case $opt in
	s)	EXTRA_SPACE="$OPTARG"
		;;
	6)	STRIP_AMD64=false
		;;
	c)	COMPRESS=true
		;;
	*)	usage
		;;
	esac
done
shift `expr $OPTIND - 1`

[ $# == 3 ] || usage

UNPACKED_ROOT="$3"
BASE="`pwd`"
LOFIDEV=
MR="$2"

# sanity check
[ "$UNPACKED_ROOT" != "/" ] || usage

if [ "`dirname $MR`" = . ] ; then
	MR="$BASE/$MR"
fi
if [ "`dirname $UNPACKED_ROOT`" = . ] ; then
	UNPACKED_ROOT="$BASE/$UNPACKED_ROOT"
fi

trap cleanup EXIT

TMP=`mktemp -d -p /tmp`
MNT=$TMP/mnt$$
TMR=$TMP/mr$$

# always unpack into a fresh root
case $1 in
	unpack)
		rm -rf "$UNPACKED_ROOT"
		mkdir -p "$UNPACKED_ROOT"
		;;
esac
[ -d "$UNPACKED_ROOT" ] || usage

case $1 in
	pack)	pack "$MR"
		;;
	unpack)	unpack "$MR"
		;;
	*)	cleanup
		usage
		;;
esac