xref: /titanic_44/usr/src/cmd/boot/scripts/create_ramdisk.ksh (revision 3f7d54a6b84904c8f4d8daa4c7b577bede7df8b9)
1#!/bin/ksh -p
2#
3# CDDL HEADER START
4#
5# The contents of this file are subject to the terms of the
6# Common Development and Distribution License (the "License").
7# You may not use this file except in compliance with the License.
8#
9# You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
10# or http://www.opensolaris.org/os/licensing.
11# See the License for the specific language governing permissions
12# and limitations under the License.
13#
14# When distributing Covered Code, include this CDDL HEADER in each
15# file and include the License file at usr/src/OPENSOLARIS.LICENSE.
16# If applicable, add the following below this CDDL HEADER, with the
17# fields enclosed by brackets "[]" replaced with your own identifying
18# information: Portions Copyright [yyyy] [name of copyright owner]
19#
20# CDDL HEADER END
21#
22
23# Copyright 2009 Sun Microsystems, Inc.  All rights reserved.
24# Use is subject to license terms.
25
26format=ufs
27ALT_ROOT=
28EXTRACT_ARGS=
29compress=yes
30SPLIT=unknown
31ERROR=0
32dirsize32=0
33dirsize64=0
34
35usage() {
36	echo "This utility is a component of the bootadm(1M) implementation"
37	echo "and it is not recommended for stand-alone use."
38	echo "Please use bootadm(1M) instead."
39	echo ""
40	echo "Usage: ${0##*/}: [-R \<root\>] [-p \<platform\>] [--nocompress]"
41	echo "where \<platform\> is one of i86pc, sun4u or sun4v"
42	exit
43}
44
45# default platform is what we're running on
46PLATFORM=`uname -m`
47
48#
49# set path, but inherit /tmp/bfubin if owned by
50# same uid executing this process, which must be root.
51#
52if [ "`echo $PATH | cut -f 1 -d :`" = /tmp/bfubin ] && \
53    [ -O /tmp/bfubin ] ; then
54	export PATH=/tmp/bfubin
55	export GZIP_CMD=/tmp/bfubin/gzip
56else
57	export PATH=/usr/sbin:/usr/bin:/sbin
58	export GZIP_CMD=/usr/bin/gzip
59fi
60
61EXTRACT_FILELIST="/boot/solaris/bin/extract_boot_filelist"
62
63#
64# Parse options
65#
66while [ "$1" != "" ]
67do
68        case $1 in
69        -R)	shift
70		ALT_ROOT="$1"
71		if [ "$ALT_ROOT" != "/" ]; then
72			echo "Creating boot_archive for $ALT_ROOT"
73			EXTRACT_ARGS="${EXTRACT_ARGS} -R ${ALT_ROOT}"
74			EXTRACT_FILELIST="${ALT_ROOT}${EXTRACT_FILELIST}"
75		fi
76		;;
77	-n|--nocompress) compress=no
78		;;
79	-p)	shift
80		PLATFORM="$1"
81		EXTRACT_ARGS="${EXTRACT_ARGS} -p ${PLATFORM}"
82		;;
83        *)      usage
84		;;
85        esac
86	shift
87done
88
89if [ -x /usr/bin/mkisofs -o -x /tmp/bfubin/mkisofs ] ; then
90	format=isofs
91fi
92
93#
94# mkisofs on s8 doesn't support functionality used by GRUB boot.
95# Use ufs format for boot archive instead.
96#
97release=`uname -r`
98if [ "$release" = "5.8" ]; then
99	format=ufs
100fi
101
102shift `expr $OPTIND - 1`
103
104if [ $# -eq 1 ]; then
105	ALT_ROOT="$1"
106	echo "Creating boot_archive for $ALT_ROOT"
107fi
108
109case $PLATFORM in
110i386)	PLATFORM=i86pc
111	ISA=i386
112	ARCH64=amd64
113	;;
114i86pc)	ISA=i386
115	ARCH64=amd64
116	;;
117sun4u)	ISA=sparc
118	ARCH64=sparcv9
119	;;
120sun4v)	ISA=sparc
121	ARCH64=sparcv9
122	;;
123*)	usage
124	;;
125esac
126
127BOOT_ARCHIVE=platform/$PLATFORM/boot_archive
128BOOT_ARCHIVE_64=platform/$PLATFORM/$ARCH64/boot_archive
129
130if [ $PLATFORM = i86pc ] ; then
131	if [ ! -x "$ALT_ROOT"/boot/solaris/bin/symdef ]; then
132		# no dboot implies combined archives for example
133		# live-upgrade from s9 to s10u6 is multiboot-only
134		echo "Creating single archive at $ALT_ROOT/$BOOT_ARCHIVE"
135		SPLIT=no
136		compress=no
137	else
138		SPLIT=yes
139	fi
140else			# must be sparc
141	SPLIT=no	# there's only 64-bit (sparcv9), so don't split
142	compress=no
143fi
144
145[ -x $GZIP_CMD ] || compress=no
146
147function cleanup
148{
149	umount -f "$rdmnt32" 2>/dev/null
150	umount -f "$rdmnt64" 2>/dev/null
151	lofiadm -d "$rdfile32" 2>/dev/null
152	lofiadm -d "$rdfile64" 2>/dev/null
153	[ -n "$rddir" ] && rm -fr "$rddir" 2> /dev/null
154	[ -n "$new_rddir" ] && rm -fr "$new_rddir" 2>/dev/null
155}
156
157function getsize
158{
159	# Estimate image size and add 10% overhead for ufs stuff.
160	# Note, we can't use du here in case we're on a filesystem, e.g. zfs,
161	# in which the disk usage is less than the sum of the file sizes.
162	# The nawk code
163	#
164	#	{t += ($5 % 1024) ? (int($5 / 1024) + 1) * 1024 : $5}
165	#
166	# below rounds up the size of a file/directory, in bytes, to the
167	# next multiple of 1024.  This mimics the behavior of ufs especially
168	# with directories.  This results in a total size that's slightly
169	# bigger than if du was called on a ufs directory.
170	size32=$(cat "$list32" | xargs -I {} ls -lLd "{}" 2> /dev/null |
171		nawk '{t += ($5 % 1024) ? (int($5 / 1024) + 1) * 1024 : $5}
172		END {print int(t * 1.10 / 1024)}')
173	(( size32 += dirsize32 ))
174	size64=$(cat "$list64" | xargs -I {} ls -lLd "{}" 2> /dev/null |
175		nawk '{t += ($5 % 1024) ? (int($5 / 1024) + 1) * 1024 : $5}
176		END {print int(t * 1.10 / 1024)}')
177	(( size64 += dirsize64 ))
178	(( total_size = size32 + size64 ))
179
180	if [ $compress = yes ] ; then
181		total_size=`echo $total_size | nawk '{print int($1 / 2)}'`
182	fi
183}
184
185#
186# Copies all desired files to a target directory.  One argument should be
187# passed: the file containing the list of files to copy.  This function also
188# depends on several variables that must be set before calling:
189#
190# $ALT_ROOT - the target directory
191# $compress - whether or not the files in the archives should be compressed
192# $rdmnt - the target directory
193#
194function copy_files
195{
196	list="$1"
197
198	#
199	# If compress is set, the files are gzip'd and put in the correct
200	# location in the loop.  Nothing is printed, so the pipe and cpio
201	# at the end is a nop.
202	#
203	# If compress is not set, the file names are printed, which causes
204	# the cpio at the end to do the copy.
205	#
206	while read path
207	do
208		if [ $compress = yes ]; then
209			dir="${path%/*}"
210			[ -d "$rdmnt/$dir" ] || mkdir -p "$rdmnt/$dir"
211			$GZIP_CMD -c "$path" > "$rdmnt/$path"
212		else
213			print "$path"
214		fi
215	done <"$list" | cpio -pdum "$rdmnt" 2>/dev/null
216
217	if [ $ISA = sparc ] ; then
218		# copy links
219		find $filelist -type l -print 2>/dev/null |\
220		    cpio -pdum "$rdmnt" 2>/dev/null
221		if [ $compress = yes ] ; then
222			# always copy unix uncompressed
223			find $filelist -name unix -type f -print 2>/dev/null |\
224			    cpio -pdum "$rdmnt" 2>/dev/null
225		fi
226	fi
227
228}
229
230#
231# The first argument can be:
232#
233# "both" - create an archive with both 32-bit and 64-bit binaries
234# "32-bit" - create an archive with only 32-bit binaries
235# "64-bit" - create an archive with only 64-bit binaries
236#
237function create_ufs
238{
239	which=$1
240	archive=$2
241	lofidev=$3
242
243	# should we exclude amd64 binaries?
244	if [ "$which" = "32-bit" ]; then
245		rdfile="$rdfile32"
246		rdmnt="$rdmnt32"
247		list="$list32"
248	elif [ "$which" = "64-bit" ]; then
249		rdfile="$rdfile64"
250		rdmnt="$rdmnt64"
251		list="$list64"
252	else
253		rdfile="$rdfile32"
254		rdmnt="$rdmnt32"
255		list="$list32"
256	fi
257
258	newfs $lofidev < /dev/null 2> /dev/null
259	mkdir "$rdmnt"
260	mount -F mntfs mnttab /etc/mnttab > /dev/null 2>&1
261	mount -F ufs -o nologging $lofidev "$rdmnt"
262	files=
263
264	# do the actual copy
265	copy_files "$list"
266	umount -f "$rdmnt"
267	rmdir "$rdmnt"
268
269	if [ $ISA = sparc ] ; then
270		rlofidev=`echo "$lofidev" | sed -e "s/dev\/lofi/dev\/rlofi/"`
271		bb="$ALT_ROOT/platform/$PLATFORM/lib/fs/ufs/bootblk"
272		# installboot is not available on all platforms
273		dd if=$bb of=$rlofidev bs=1b oseek=1 count=15 conv=sync 2>&1
274	fi
275
276	#
277	# Check if gzip exists in /usr/bin, so we only try to run gzip
278	# on systems that have gzip. Then run gzip out of the patch to
279	# pick it up from bfubin or something like that if needed.
280	#
281	# If compress is set, the individual files in the archive are
282	# compressed, and the final compression will accomplish very
283	# little.  To save time, we skip the gzip in this case.
284	#
285	if [ $ISA = i386 ] && [ $compress = no ] && \
286	    [ -x $GZIP_CMD ] ; then
287		gzip -c "$rdfile" > "${archive}-new"
288	else
289		cat "$rdfile" > "${archive}-new"
290	fi
291
292	if [ $? -ne 0 ] ; then
293		rm -f "${archive}-new"
294	fi
295}
296
297#
298# The first argument can be:
299#
300# "both" - create an archive with both 32-bit and 64-bit binaries
301# "32-bit" - create an archive with only 32-bit binaries
302# "64-bit" - create an archive with only 64-bit binaries
303#
304function create_isofs
305{
306	which=$1
307	archive=$2
308
309	# should we exclude amd64 binaries?
310	if [ "$which" = "32-bit" ]; then
311		rdmnt="$rdmnt32"
312		errlog="$errlog32"
313		list="$list32"
314	elif [ "$which" = "64-bit" ]; then
315		rdmnt="$rdmnt64"
316		errlog="$errlog64"
317		list="$list64"
318	else
319		rdmnt="$rdmnt32"
320		errlog="$errlog32"
321		list="$list32"
322	fi
323
324	# create image directory seed with graft points
325	mkdir "$rdmnt"
326	files=
327	isocmd="mkisofs -quiet -graft-points -dlrDJN -relaxed-filenames"
328
329	if [ $ISA = sparc ] ; then
330		bb="$ALT_ROOT/platform/$PLATFORM/lib/fs/hsfs/bootblk"
331		isocmd="$isocmd -G \"$bb\""
332	fi
333
334	copy_files "$list"
335	isocmd="$isocmd \"$rdmnt\""
336	rm -f "$errlog"
337
338	#
339	# Check if gzip exists in /usr/bin, so we only try to run gzip
340	# on systems that have gzip. Then run gzip out of the patch to
341	# pick it up from bfubin or something like that if needed.
342	#
343	# If compress is set, the individual files in the archive are
344	# compressed, and the final compression will accomplish very
345	# little.  To save time, we skip the gzip in this case.
346	#
347	mkiso_ret=0
348
349	if [ $ISA = i386 ] &&[ $compress = no ] && [ -x $GZIP_CMD ]
350	then
351		ksh -c "$isocmd" 2> "$errlog" | \
352		    gzip > "${archive}-new"
353	else
354		ksh -c "$isocmd" 2> "$errlog" > "${archive}-new"
355	fi
356
357	if [ $? -ne 0 ]; then
358		cat "$errlog"
359		rm -f "${archive}-new" 2> /dev/null
360		rm -f "$errlog" 2> /dev/null
361		return
362	fi
363
364	dd_ret=0
365	if [ $ISA = sparc ] ; then
366		bb="$ALT_ROOT/platform/$PLATFORM/lib/fs/hsfs/bootblk"
367		dd if="$bb" of="${archive}-new" bs=1b oseek=1 count=15 \
368		    conv=notrunc conv=sync >> "$errlog" 2>&1
369		dd_ret=$?
370	fi
371
372	if [ -s "$errlog" ] || [ $dd_ret -ne 0 ] ; then
373		grep Error: "$errlog" >/dev/null 2>&1
374		if [ $? -eq 0 ] || [ $dd_ret -ne 0 ] ; then
375			cat "$errlog"
376			rm -f "${archive}-new"
377		fi
378	fi
379	rm -f "$errlog"
380}
381
382function create_archive
383{
384	which=$1
385	archive=$2
386	lofidev=$3
387
388	echo "updating $archive"
389
390	if [ "$format" = "ufs" ]; then
391		create_ufs "$which" "$archive" "$lofidev"
392	else
393		create_isofs "$which" "$archive"
394	fi
395
396	# sanity check the archive before moving it into place
397	#
398	ARCHIVE_SIZE=`ls -l "${archive}-new" 2> /dev/null | nawk '{ print $5 }'`
399	if [ $compress = yes ] || [ $ISA = sparc ] ; then
400		#
401		# 'file' will report "English text" for uncompressed
402		# boot_archives.  Checking for that doesn't seem stable,
403		# so we just check that the file exists.
404		#
405		ls "${archive}-new" >/dev/null 2>&1
406	else
407		#
408		# the file type check also establishes that the
409		# file exists at all
410		#
411		LC_MESSAGES=C file "${archive}-new" | grep gzip > /dev/null
412	fi
413
414	if [ $? = 1 ] && [ -x $GZIP_CMD ] || [ "$ARCHIVE_SIZE" -lt 10000 ]
415	then
416		#
417		# Two of these functions may be run in parallel.  We
418		# need to allow the other to clean up, so we can't
419		# exit immediately.  Instead, we set a flag.
420		#
421		echo "update of $archive failed"
422		ERROR=1
423	else
424		lockfs -f "/$ALT_ROOT" 2>/dev/null
425		mv "${archive}-new" "$archive"
426		lockfs -f "/$ALT_ROOT" 2>/dev/null
427	fi
428
429}
430
431function fatal_error
432{
433	print -u2 $*
434	exit 1
435}
436
437#
438# get filelist
439#
440if [ ! -f "$ALT_ROOT/boot/solaris/filelist.ramdisk" ] &&
441    [ ! -f "$ALT_ROOT/etc/boot/solaris/filelist.ramdisk" ]
442then
443	print -u2 "Can't find filelist.ramdisk"
444	exit 1
445fi
446filelist=$($EXTRACT_FILELIST $EXTRACT_ARGS \
447	/boot/solaris/filelist.ramdisk \
448	/etc/boot/solaris/filelist.ramdisk \
449		2>/dev/null | sort -u)
450
451#
452# We use /tmp/ for scratch space now.  This may be changed later if there
453# is insufficient space in /tmp/.
454#
455rddir="/tmp/create_ramdisk.$$.tmp"
456new_rddir=
457rm -rf "$rddir"
458mkdir "$rddir" || fatal_error "Could not create temporary directory $rddir"
459
460# Clean up upon exit.
461trap 'cleanup' EXIT
462
463list32="$rddir/filelist.32"
464list64="$rddir/filelist.64"
465
466touch $list32 $list64
467
468#
469# This loop creates the 32-bit and 64-bit lists of files.  The 32-bit list
470# is written to stdout, which is redirected at the end of the loop.  The
471# 64-bit list is appended with each write.
472#
473cd "/$ALT_ROOT"
474find $filelist -print 2>/dev/null | while read path
475do
476	if [ $SPLIT = no ]; then
477		print "$path"
478	elif [ -d "$path" ]; then
479		if [ $format = ufs ]; then
480			size=`ls -lLd "$path" | nawk '
481			    {print ($5 % 1024) ? (int($5 / 1024) + 1) * 1024 : $5}'`
482			if [ `basename "$path"` != "amd64" ]; then
483				(( dirsize32 += size ))
484			fi
485			(( dirsize64 += size ))
486		fi
487	else
488		case `LC_MESSAGES=C /usr/bin/file -m /dev/null "$path" 2>/dev/null` in
489		*ELF\ 64-bit*)
490			print "$path" >> "$list64"
491			;;
492		*ELF\ 32-bit*)
493			print "$path"
494			;;
495		*)
496			# put in both lists
497			print "$path"
498			print "$path" >> "$list64"
499		esac
500	fi
501done >"$list32"
502
503if [ $format = ufs ] ; then
504	# calculate image size
505	getsize
506
507	# check to see if there is sufficient space in tmpfs
508	#
509	tmp_free=`df -b /tmp | tail -1 | awk '{ printf ($2) }'`
510	(( tmp_free = tmp_free / 3 ))
511	if [ $SPLIT = yes ]; then
512		(( tmp_free = tmp_free / 2 ))
513	fi
514
515	if [ $total_size -gt $tmp_free  ] ; then
516		# assumes we have enough scratch space on $ALT_ROOT
517		new_rddir="/$ALT_ROOT/var/tmp/create_ramdisk.$$.tmp"
518		rm -rf "$new_rddir"
519		mkdir "$new_rddir" || fatal_error \
520		    "Could not create temporary directory $new_rddir"
521
522		# Save the file lists
523		mv "$list32" "$new_rddir"/
524		mv "$list64" "$new_rddir"/
525		list32="/$new_rddir/filelist.32"
526		list64="/$new_rddir/filelist.64"
527
528		# Remove the old $rddir and set the new value of rddir
529		rm -rf "$rddir"
530		rddir="$new_rddir"
531		new_rddir=
532	fi
533fi
534
535rdfile32="$rddir/rd.file.32"
536rdfile64="$rddir/rd.file.64"
537rdmnt32="$rddir/rd.mount.32"
538rdmnt64="$rddir/rd.mount.64"
539errlog32="$rddir/rd.errlog.32"
540errlog64="$rddir/rd.errlog.64"
541lofidev32=""
542lofidev64=""
543
544if [ $SPLIT = yes ]; then
545	#
546	# We can't run lofiadm commands in parallel, so we have to do
547	# them here.
548	#
549	if [ "$format" = "ufs" ]; then
550		mkfile ${size32}k "$rdfile32"
551		lofidev32=`lofiadm -a "$rdfile32"`
552		mkfile ${size64}k "$rdfile64"
553		lofidev64=`lofiadm -a "$rdfile64"`
554	fi
555	create_archive "32-bit" "$ALT_ROOT/$BOOT_ARCHIVE" $lofidev32 &
556	create_archive "64-bit" "$ALT_ROOT/$BOOT_ARCHIVE_64" $lofidev64
557	wait
558	if [ "$format" = "ufs" ]; then
559		lofiadm -d "$rdfile32"
560		lofiadm -d "$rdfile64"
561	fi
562else
563	if [ "$format" = "ufs" ]; then
564		mkfile ${total_size}k "$rdfile32"
565		lofidev32=`lofiadm -a "$rdfile32"`
566	fi
567	create_archive "both" "$ALT_ROOT/$BOOT_ARCHIVE" $lofidev32
568	[ "$format" = "ufs" ] && lofiadm -d "$rdfile32"
569fi
570if [ $ERROR = 1 ]; then
571	cleanup
572	exit 1
573fi
574
575#
576# For the diskless case, hardlink archive to /boot to make it
577# visible via tftp. /boot is lofs mounted under /tftpboot/<hostname>.
578# NOTE: this script must work on both client and server.
579#
580grep "[	 ]/[	 ]*nfs[	 ]" "$ALT_ROOT/etc/vfstab" > /dev/null
581if [ $? = 0 ]; then
582	rm -f "$ALT_ROOT/boot/boot_archive" "$ALT_ROOT/boot/amd64/boot_archive"
583	ln "$ALT_ROOT/$BOOT_ARCHIVE" "$ALT_ROOT/boot/boot_archive"
584	if [ $SPLIT = yes ]; then
585		ln "$ALT_ROOT/$BOOT_ARCHIVE_64" \
586		    "$ALT_ROOT/boot/amd64/boot_archive"
587	fi
588fi
589[ -n "$rddir" ] && rm -rf "$rddir"
590