tags/mkinitrd-6_1_7/mkinitrd.in

#!/bin/bash
# $Header: /home/cvsd/magellan-cvs/magellan-src/mkinitrd-magellan/mkinitrd.in,v 1.4 2008-06-11 22:11:40 niro Exp $

# mkinitrd
#
# Copyright 2005 Red Hat, Inc.
#
# Written by Erik Troan <ewt@redhat.com>
#
# Contributors:
#	Elliot Lee <sopwith@cuc.edu>
#	Miguel de Icaza <miguel@nuclecu.unam.mx>
#	Christian 'Dr. Disk' Hechelmann <drdisk@ds9.au.s.shuttle.de>
#	Michael K. Johnson <johnsonm@redhat.com>
#	Pierre Habraken <Pierre.Habraken@ujf-grenoble.fr>
#	Jakub Jelinek <jakub@redhat.com>
#	Carlo Arenas Belon (carenas@chasqui.lared.net.pe>
#	Keith Owens <kaos@ocs.com.au>
#	Bernhard Rosenkraenzer <bero@redhat.com>
#	Matt Wilson <msw@redhat.com>
#       Trond Eivind Glomsrød <teg@redhat.com>
#       Jeremy Katz <katzj@redhat.com>
#       Preston Brown <pbrown@redhat.com>
#	Bill Nottingham <notting@redhat.com>
#       Guillaume Cottenceau <gc@mandrakesoft.com>
#	Peter Jones <pjones@redhat.com>

# heavily modified for magellan-linux by Niels Rogalla <niro@magellan-linux.de>

umask 0022
export MALLOC_PERTURB_=204

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

VERSION=%VERSIONTAG%

PROBE="yes"
MODULES=""
PREMODS=""
NOSTRIP=false

[ -e /etc/conf.d/mkinitrd ] && . /etc/conf.d/mkinitrd

CONFMODS="${MODULES}"
MODULES=""

compress=1
allowmissing=""
target=""
kernel=""
force=""
verbose=""
img_vers=""
builtins=""
modulefile=/etc/modules.conf
rc=0

IMAGESIZE=4000
PRESCSIMODS="sd_mod"
fstab="/etc/fstab"

vg_list=""

die() { echo "Error: $@"; exit 1; }
add_initrd() { echo "$@" >> ${DEST}/init || die; }

DEST="$(mktemp -d)"
IMAGE="$(mktemp)"

usage()
{
	echo "usage: $(basename $0) [--version] [--help] [-v] [-f] [--preload <module>]"
	echo "       [--force-ide-probe] [--force-scsi-probe | --omit-scsi-modules]"
	echo "       [--image-version] [--force-scsi-probe | --omit-raid-modules]"
	echo "       [--with=<module>] [--force-lvm-probe | --omit-lvm-modules]"
	echo "       [--builtin=<module>] [--initramfs | --loopback] [--no-strip]"
	echo "       [--fstab=<fstab>] [--nocompress] <initrd-image> <kernel-version>"
	echo
	echo "       (ex: $(basename $0) /boot/initrd-2.2.5-15.img 2.2.5-15)"

	exit 0
}

moduledep()
{
	if [ ! -f "/lib/modules/${kernel}/modules.dep" ]
	then
		die "No dep file found for kernel ${kernel}"
	fi

	echo "Looking for deps of module $1"
	deps=$(awk 'BEGIN { searched=ARGV[2]; ARGV[2]=""; rc=1 } \
		function modname(filename) { match(filename, /\/([^\/]+)\.k?o:?$/, ret); return ret[1] } \
		function show() { if (orig == searched) { print dep; orig=""; rc=0; exit } } \
		/^.*kernel/ { show(); \
			orig=modname($1); dep=""; \
			if ($2) { for (i = 2; i <= NF; i++) { dep=sprintf("%s %s", dep, modname($i)); } } } \
		/^	/ { dep=sprintf("%s %s", dep, modname($1));  } \
		END      { show(); exit(rc) }' /lib/modules/${kernel}/modules.dep $1)
	[ -n "${deps}" ] && echo ":${deps}" || echo
}

findone() { /usr/bin/find "$@" | /bin/awk '{ print $1; exit; }'; }
findall() { /usr/bin/find "$@"; }

findmodule()
{
	skiperrors=""

	if [[ $1 = --skiperrors ]]
	then
		skiperrors=--skiperrors
		shift
	fi

	local modName=$1

	if [ "${modName}" = "off" -o "${modName}" = "null" ]
	then
		return
	fi

	if [ $(echo ${modName} | cut -b1) = "-" ]
	then
		skiperrors=--skiperrors
		modName=$(echo ${modName} | cut -b2-)
	fi

	case "${MODULES} " in
		*"/${modName}.ko "*) return ;;
	esac

	if echo ${builtins} | egrep -q '(^| )'${modName}'( |$)'
	then
		echo "module ${modName} assumed to be built in"
		return
	fi

	# special cases
	if [[ ${modName} = i2o_block ]]
	then
		findmodule i2o_core
		findmodule -i2o_pci
		modName="i2o_block"
	elif [[ ${modName} = ppa ]]
	then
		findmodule parport
		findmodule parport_pc
		modName="ppa"
	elif [[ ${modName} = sbp2 ]]
	then
		findmodule ieee1394
		findmodule ohci1394
		modName="sbp2"
	else
		moduledep ${modName}
		for i in ${deps}
		do
			findmodule ${i}
		done
	fi

	for modExt in o.gz o ko
	do
		for modDir in /lib/modules/${kernel}/updates /lib/modules/${kernel}
		do
			if [ -d ${modDir} ]
			then
				fmPath=$(findone ${modDir} -name ${modName}.${modExt})
				if [ -f "${fmPath}" ]
				then
					break 2
				fi
			fi
		done
	done

	if [ ! -f ${fmPath} ]
	then
		if [ -n "${skiperrors}" ]
		then
			return
		fi

		# ignore the absence of the scsi modules
		for n in ${PRESCSIMODS}
		do
			if [[ ${n} = ${modName} ]]
			then
				return
			fi
		done

		if [ -n "${allowmissing}" ]
		then
			echo "WARNING: No module ${modName} found for kernel ${kernel}, continuing anyway"
			return
		fi

		die "No module ${modName} found for kernel ${kernel}, aborting."
	fi

	# only need to add each module once
	MODULES="${MODULES} ${fmPath}"
}

inst()
{
	if [ "$#" != "2" ]
	then
		echo "usage: inst <file> <destination>"
		return
	fi
	echo "$1 -> $2"
	cp $1 $2
}

findstoragedriver()
{
	for device in $@
	do
		case " ${handledevices} " in
			*" ${device} "*) continue ;;
			*) handleddevices="${handleddevices} ${device}" ;;
		esac

		if [[ "${device}" =~ "md[0-9]+" ]]
		then
			echo "Found RAID component ${device}"
			handleraid "${device}"
			continue
		fi
		echo "Looking for driver for device ${device}"
		sysfs=$(findone /sys/block -name ${device} -type d)
		[ -z "${sysfs}" ] && return
		pushd ${sysfs} >/dev/null 2>&1
		while [ ! -L device ]
		do
			[[ ${PWD} = /sys ]] && continue 2
			cd ..
		done
		cd $(readlink ./device)
		while [ ! -f modalias ]
		do
			[[ ${PWD} = /sys/devices ]] && continue 2
			cd ..
		done
		modalias=$(cat modalias)
		for driver in $(modprobe --set-version ${kernel} --show-depends ${modalias} 2>/dev/null| awk '{ print gensub(".*/","","g",$2) }')
		do
			findmodule ${driver%%.ko}
		done
		popd >/dev/null 2>&1
	done
}

handleraid()
{
	local start=0

	if [ -n "${noraid}" -o ! -f /proc/mdstat ]
	then
		return 0
	fi

	levels=$(grep "^$1[	 ]*:" /proc/mdstat | \
		awk '{ print $4 }')
	devs=$(grep "^$1[	 ]*:" /proc/mdstat | \
		awk '{ print gensub("\\[[0-9]*\\]","","g",gensub("^md.*raid[0-9]*","","1")) }')

	for level in ${levels}
	do
		case ${level} in
			linear)
				findmodule linear
				start=1
				;;
			multipath)
				findmodule multipath
				start=1
				;;
			raid[01456])
				findmodule ${level}
				start=1
				;;
			*)
				error "raid level ${level} (in /proc/mdstat) not recognized"
				;;
		esac
	done
	findstoragedriver ${devs}
	if [[ ${start} = 1 ]]
	then
		raiddevices="${raiddevices} $1"
	fi
	return ${start}
}

handlelvordev()
{
	local vg=$(lvs --noheadings -o vg_name $1 2>/dev/null)
	if [ -n "${vg}" ]
	then
		vg=$(echo ${vg}) # strip whitespace
		case " ${vg_list} " in
			*" ${vg} "*)
				;;
			*)
				vg_list="${vg_list} ${vg}"
				for device in $(vgdisplay -v ${vg} 2>/dev/null | sed -n 's/PV Name//p')
				do
					findstoragedriver ${device##/dev/}
				done
				;;
		esac
	else
		findstoragedriver ${1##/dev/}
	fi
}

get_blkid()
{
	local UUID
	local SEC_TYPE
	local TYPE
	
	local dev="$1"
	[[ -z ${dev} ]] && die "no dev given"

	# check if given device is already an UUID
	if [[ ${dev/UUID=/}x != ${dev}x ]]
	then
		eval "${dev}"
	else
		eval $(busybox.mkinitrd blkid ${dev} | grep "${dev}:" | sed 's/.*:\ //')
	fi
	echo ${UUID}
}

# need r00t privs
[[ $(id -u) != 0 ]] && die "you must be r00t."

while [ $# -gt 0 ]; do
	case $1 in
		--fstab*)
			if echo $1 | grep -q '=' ; then
				fstab=$(echo $1 | sed 's/^--fstab=//')
			else
				fstab=$2
				shift
			fi
		;;

		--with-usb) withusb=yes ;;

		--with*)
			if echo $1 | grep -q '=' ; then
				modname=$(echo $1 | sed 's/^--with=//')
			else
				modname=$2
				shift
			fi
			basicmodules="${basicmodules} ${modname}"
			;;

		--builtin*)
			if echo $1 | grep -q '=' ; then
				modname=$(echo $1 | sed 's/^--builtin=//')
			else
				modname=$2
				shift
			fi
			builtins="${builtins} ${modname}"
			;;

		--version)
			echo "mkinitrd: version ${VERSION}"
			exit 0
			;;

		-v) verbose=-v ;;
		--nocompress) compress="" ;;
		--ifneeded)
				# legacy
				;;
		-f) force=1 ;;

		--preload*)
			if echo $1 | grep -q '=' ; then
				modname=$(echo $1 | sed 's/^--preload=//')
			else
				modname=$2
				shift
			fi
			PREMODS="${PREMODS} ${modname}"
			;;

		--force-scsi-probe) forcescsi=1 ;;

		--omit-scsi-modules)
			PRESCSIMODS=""
			noscsi=1
			;;
		--force-raid-probe) forceraid=1 ;;
		--omit-raid-modules) noraid=1 ;;
		--force-lvm-probe) forcelvm=1 ;;
		--omit-lvm-modules) nolvm=1 ;;
		--force-ide-probe) forceide=1 ;;
		--image-version) img_vers=yes ;;
		--allow-missing) allowmissing=yes ;;
		--noresume) noresume=1 ;;
		--help) usage -n ;;
		--initramfs) IMAGE_TYPE=initramfs ;;
		--loopback) IMAGE_TYPE=loopback ;;
		--no-strip) NOSTRIP=true ;;
		*)
			if [ -z "${target}" ]
			then
				target=$1
			elif [ -z "${kernel}" ]
			then
				kernel=$1
			else
				usage
			fi
			;;
	esac

	shift
done

# enforce initramfs method as default
[[ -z ${IMAGE_TYPE} ]] && IMAGE_TYPE=initramfs

if [ -z "${target}" -o -z "${kernel}" ]
then
	usage
fi

if [ -n "${img_vers}" ]
then
	target="${target}-${kernel}"
fi

if [ -z "${force}" -a -f ${target} ]
then
	die "${target} already exists."
fi

if [ -n "${forcescsi}" -a -n "${noscsi}" ]
then
	die "Can't both force scsi probe and omit scsi modules"
fi

if [ -n "${forceraid}" -a -n "${noraid}" ]
then
	die "Can't both force raid probe and omit raid modules"
fi

if [ -n "${forcelvm}" -a -n "${nolvm}" ]
then
	die "Can't both force LVM probe and omit LVM modules"
fi

if [ ! -d /lib/modules/${kernel} ]
then
	die "No modules available for kernel '${kernel}'."
fi

##############################
####### get modules ##########

echo "Creating ${IMAGE_TYPE} initrd image"
modulefile=/etc/modprobe.conf

for n in ${PREMODS}
do
	findmodule ${n}
done

needusb=""
if [ -n "${withusb}" -a "x${PROBE}" == "xyes" ]
then
	# If / or /boot is on a USB device include the driver. With root by
	# label we could still get some odd behaviors
	for fs in / /boot
	do
		esc=$(echo ${fs} | sed 's,/,\\/,g')
		dev=$(mount | awk "/ on ${esc} / { print \$1 }" | sed 's/[0-9]*$//' | cut -d/ -f3)
		if [ "$(echo ${dev} | cut -c1-2)" = sd ]
		then
			if [ $(which kudzu 2>/dev/null) ]
			then
				host=$(kudzu --probe -b scsi |
					gawk '/^device: '${dev}'/,/^host:/ { if (/^host/) { print $2; exit; } }')
				if [ -d /proc/scsi/usb-storage-${host} -o -f /proc/scsi/usb-storage/${host} ]
				then
					needusb=1
				fi
			fi
		fi
	done
fi

if [ -n "${needusb}" -a "x${PROBE}" == "xyes" ]
then
	drivers=$(awk '/^alias[[:space:]]+usb-controller[0-9]* / { print $3}' < ${modulefile})
	if [ -n "${drivers}" ]
	then
		for driver in ${drivers}
		do
	    		findmodule ${driver}
		done
		findmodule scsi_mod
		findmodule sd_mod
		findmodule usb-storage
	fi
fi

if [ -n "${forcescsi}" -o -z "${noscsi}" -a "x${PROBE}" == "xyes" ]
then
	if [ ! -f ${modulefile} ]
	then
		modulefile=/etc/conf.modules
	fi

	if [ -f ${modulefile} ]
	then
		scsimodules=$(grep "alias[[:space:]]\+scsi_hostadapter" ${modulefile} | grep -v '^[ 	]*#' | LC_ALL=C sort -u | awk '{ print $3 }')

		if [ -n "${scsimodules}" ]
		then
			for n in ${PRESCSIMODS}
			do
				findmodule ${n}
			done

			for n in ${scsimodules}
			do
				# for now allow scsi modules to come from anywhere.  There are some
				# RAID controllers with drivers in block/
				findmodule ${n}
			done
		fi
	fi
fi

# If we have ide devices and module ide, do the right thing
ide=/proc/ide/ide*
if [ -n "${forceide}" -o -n "${ide}" -a "x${PROBE}" == "xyes" ]
then
	findmodule -ide-disk
fi

# If we have dasd devices, include the necessary modules (S/390)
if [ "x${PROBE}" == "xyes" -a -d /proc/dasd ]
then
	findmodule -dasd_mod
	findmodule -dasd_eckd_mod
	findmodule -dasd_fba_mod
fi

if [ "x${PROBE}" == "xyes" ]
then
	# check to see if we need to set up a loopback filesystem
	rootdev=$(awk '/^[ \t]*[^#]/ { if ($2 == "/") { print $1; }}' ${fstab})
	# check if it's root by label
	if echo ${rootdev} | cut -c1-6 | grep -q "LABEL="
	then
		majmin=$(stat -c "%t:%T" /dev/root)
		if [ -n "${majmin}" ]
		then
			dev=$(findall /sys/block -name dev | while read device ; do \
				echo "${majmin}" | cmp -s ${device} && echo ${device} ; done \
				| sed -e 's,.*/\([^/]\+\)/dev,\1,' )
			if [ -n "${dev}" ]; then
				echo "Found root device ${dev} for ${rootdev}"
				rootdev=${dev}
			fi
		fi
	fi
	if echo ${rootdev} | cut -d/ -f3 | grep -q loop
	then
		key="^# $(echo ${rootdev} | cut -d/ -f3 | tr '[a-z]' '[A-Z]'):"
		if ! grep "${key}" ${fstab} >> /dev/null
		then
			echo "The root filesystem is on a ${rootdev}, but there is no magic entry in ${fstab}"
			echo "for this device. Consult the mkinitrd man page for more information"
			echo "loopback root."
			exit 1
		fi

		line=$(grep "${key}" ${fstab})
		loopDev=$(echo ${line} | awk '{print $3}')
		loopFs=$(echo ${line} | awk '{print $4}')
		loopFile=$(echo ${line} | awk '{print $5}')

		basicmodules="${basicmodules} -loop"
		if [ "${loopFs}" = "vfat" -o "${loopFs}" = "msdos" ]
		then
			basicmodules="${basicmodules} -fat"
		fi
		basicmodules="${basicmodules} -${loopFs}"
		# check if the root fs is on a logical volume
		# this check must be last
	else
		handlelvordev ${rootdev}
	fi

	rootfs=$(awk '{ if ($1 !~ /^[ \t]*#/ && $2 == "/") { print $3; }}' ${fstab})
	rootopts=$(awk '{ if ($1 !~ /^[ \t]*#/ && $2 == "/") { print $4; }}' ${fstab}\
		| sed -e 's/^r[ow],//' -e 's/,r[ow],$//' -e 's/,r[ow],/,/' \
			-e 's/^r[ow]$/defaults/' -e 's/$/,ro/')

	# in case the root filesystem is modular
	findmodule -${rootfs}

	# find the first swap dev which would get used for swsusp
	swsuspdev=$(awk '/^[ \t]*[^#]/ { if ($3 == "swap") { print $1; }}' ${fstab} \
		| head -n 1)
	if ! echo ${swsuspdev} | cut -c1-6 | grep -q "LABEL="
	then
		handlelvordev ${swsupdev}
	fi
fi

# If we use LVM or dm-based raid, include dm-mod
# XXX: dm not really supported yet.
testdm=""
[ -n "${vg_list}" ] && testdm="yes"
[ -n "${forceraid}" -o -n "${forcelvm}" ] && testdm="yes"
[ "x${PROBE}" == "xyes" -a \
  -n "$(test -z \"${nolvm}\" -o -z \"${noraid}\")" ] && testdm="yes"

if [ -n "${testdm}" ]
then
	if [ -x /sbin/dmsetup -a -e /dev/mapper/control ]
	then
		dmout=$(/sbin/dmsetup ls 2>/dev/null)
		if [ "${dmout}" != "No devices found" -a "${dmout}" != "" ]
		then
			findmodule -dm-mod

			# DM requires all of these to be there in case someone used the
			# feature.  broken.  (#132001)
			findmodule -dm-mirror
			findmodule -dm-zero
			findmodule -dm-snapshot
		fi
	fi
fi

for n in ${basicmodules}
do
    findmodule ${n}
done

for n in ${CONFMODS}
do
    findmodule ${n}
done

echo "Using modules:${MODULES}"

####### eof modules ##########
##############################


# create basic filesystem layout
install -d ${DEST}/{bin,dev,etc,lib,loopfs,proc,sbin,sys,sysroot,usr/bin,usr/sbin} || die

# install busybox
echo "$(which busybox.mkinitrd)"
install -m0755 $(which busybox.mkinitrd) ${DEST}/bin/busybox || die
for i in '[' ash basename cat cut clear cp dirname echo env false find \
	grep gunzip gzip ln ls loadkmap mkdir mknod more mount mv \
	ps pwd rm rmdir sh sleep test touch true umount uname \
	xargs yes chmod chown
do
	# use soft links from now on;
	# hardlinks in initramfs apears to be broken on newer kernels
	# -> "request module: runaway loop modprobe binfmt-0000"
	# see: http://www.gossamer-threads.com/lists/linux/kernel/728042
	ln -s /bin/busybox ${DEST}/bin/${i} || die "${i}"
done

# sbin related
for i in chroot init losetup modprobe pivot_root
do
	ln -s ${DEST}/bin/busybox ${DEST}/sbin/${i} || die "${i}"
done

# install run-init
echo "$(which run-init.mkinitrd)"
install -m0755 $(which run-init.mkinitrd) ${DEST}/sbin/run-init || die

# install insmod.static
#echo "$(which insmod.static)"
#install -m0755 $(which insmod.static) ${DEST}/sbin/insmod || die

# install v86d for uvesafb support if installed
if which v86d &> /dev/null
then
	echo "$(which v86d)"
	install -m0755 $(which v86d) ${DEST}/sbin/v86d || die
fi

# install lvm
if [ -n "${vg_list}" ]
then
	inst /sbin/lvm.static "${DEST}/sbin/lvm"
	if [ -f /etc/lvm/lvm.conf ]
	then
		cp ${verbose} --parents /etc/lvm/lvm.conf ${DEST}/
	fi
fi

# create some needed device nodes
mkdir ${DEST}/dev/pts || die
mkdir ${DEST}/dev/shm || die
mkdir ${DEST}/dev/mapper || die
mkdir ${DEST}/dev/misc || die
mkdir ${DEST}/dev/fb || die
mkdir ${DEST}/dev/vc || die
mknod ${DEST}/dev/console c 5 1 || die
mknod ${DEST}/dev/null c 1 3 || die
mknod ${DEST}/dev/ram b 1 1 || die
mknod ${DEST}/dev/rtc c 10 135 || die
mknod ${DEST}/dev/systty c 4 0 || die
mknod ${DEST}/dev/tty c 5 0 || die
mknod ${DEST}/dev/zero c 1 5 || die
for ((i=0; i < 13; i++))
do
	mknod ${DEST}/dev/tty${i} c 4 ${i} || die "tty${i}"
done
for ((i=64; i < 68; i++))
do
	mknod ${DEST}/dev/ttyS$((${i} - 64)) c 4 ${i} || die "ttyS$((${i} - 64))"
done

# create init script
:> ${DEST}/init || die
add_initrd '#!/bin/sh'

add_initrd 'mount -t proc proc /proc'
add_initrd 'mount -t sysfs sysfs /sys'
add_initrd 'mount -t tmpfs tmpfs /dev -o rw,mode=0644,size=1024'

[[ ${IMAGE_TYPE} = loopback ]] && add_initrd 'mount -t ramfs -o remount,rw /dev/ram /'

# install all busybox applets
add_initrd 'busybox --install -s'

# silencio
add_initrd 'echo 0 > /proc/sys/kernel/printk'

add_initrd 'echo "-- Creating initial device nodes ..."'
# populate dev
add_initrd 'mdev -s'
# handle hotplug events properly
add_initrd 'echo /sbin/mdev > /proc/sys/kernel/hotplug'

# loading detected modules with options
for MODULE in ${MODULES}
do
	text=""
	module=$(echo ${MODULE} | sed "s|.*/||" | sed "s/.k\?o$//")
	fullmodule=$(echo ${MODULE} | sed "s|.*/||")

	options=$(sed -n -e "s/^options[     ][      ]*${module}[      ][      ]*//p" ${modulefile} 2>/dev/null)

	if [ -n "${options}" ]
	then
		echo "Adding module ${module}${text} with options ${options} ..."
	else
		echo "Adding module ${module}${text} ..."
	fi

	add_initrd "echo \"-- Loading ${fullmodule} module\""
	add_initrd "insmod /lib/${fullmodule} ${options}"

	# Hack - we need a delay after loading usb-storage to give things
	#        time to settle down before we start looking a block devices
	if [ "${module}" = "usb-storage" ]
	then
		add_initrd 'echo Waiting 8 seconds for driver initialization.'
		add_initrd 'sleep 8'
	fi
	if [ "${module}" = "zfcp" -a -f /etc/zfcp.conf ]
	then
		add_initrd 'echo Waiting 2 seconds for driver initialization.'
		add_initrd 'sleep 2'
		cat /etc/zfcp.conf | grep -v "^#" | tr "A-Z" "a-z" | while read DEVICE SCSIID WWPN SCSILUN FCPLUN
		do
			add_initrd "echo -n ${WWPN} > /sys/bus/ccw/drivers/zfcp/${DEVICE/0x/}/port_add"
			add_initrd "echo -n ${FCPLUN} > /sys/bus/ccw/drivers/zfcp/${DEVICE/0x/}/${WWPN}/unit_add"
			add_initrd "echo -n 1 > /sys/bus/ccw/drivers/zfcp/${DEVICE/0x/}/online"
		done
	fi
done

# lvm support
if [ -n "${vg_list}" ]
then
	add_initrd 'echo Scanning logical volumes'
	add_initrd 'lvm vgscan --ignorelockingfailure'
	add_initrd 'echo Activating logical volumes'
	add_initrd "lvm vgchange -ay --ignorelockingfailure ${vg_list}"
fi

# loopback support
if [ -n "${loopDev}" ]
then
	# needed on the host system
	install -d /initrd
	cp -a ${loopDev} ${DEST}/dev || die
	cp -a ${rootdev} ${DEST}/dev || die
	add_initrd 'echo "Mounting device containing loopback root filesystem ..."'
	add_initrd "mount -t ${loopFs} ${loopDev} /loopfs"
	add_initrd "echo Setting up loopback device ${rootdev}"
	add_initrd "losetup ${rootdev} /loopfs${loopFile}"
fi

# software suspend
if [ -z "${noresume}" ]
then
	add_initrd "[ -x /bin/resume ] && resume ${swsuspdev}"
fi

# raid
if [ -n "${raiddevices}" ]
then
	for dev in ${raiddevices}
	do
		cp -a /dev/${dev} ${DEST}/dev || die
		add_initrd "raidautorun /dev/${dev}"
	done
fi

add_initrd 'echo "-- Mounting sysroot ..."'
add_initrd '. /etc/rootdev'
add_initrd 'echo "${device} /sysroot ${rootfs} defaults,ro 0 0" > /etc/fstab'
add_initrd 'mount /sysroot || ash'

# unset hotplug event-manager
add_initrd 'echo > /proc/sys/kernel/hotplug'

# de-silencio
add_initrd 'echo 3 > /proc/sys/kernel/printk'

add_initrd 'echo "-- Switching to real sysroot ..."'
add_initrd 'umount /dev'
add_initrd 'umount /sys'
add_initrd 'umount /proc'

[[ ${IMAGE_TYPE} = initramfs ]] && add_initrd 'exec run-init /sysroot /sbin/init $@ </sysroot/dev/console >/sysroot/dev/console'
if [[ ${IMAGE_TYPE} = loopback ]]
then
	add_initrd 'cd /sysroot'
	add_initrd 'pivot_root . initrd'
	add_initrd "exec /sbin/chroot . sh -c 'umount -n /initrd >/dev/null 2>&1;exec -a init.new /sbin/init'</dev/console >/dev/console 2>&1"
fi

chmod +x ${DEST}/init || die

# setup root block device
[[ -z ${rootdev} ]] && die "no known rootdev found."
echo "device='UUID=$(get_blkid ${rootdev})'" > ${DEST}/etc/rootdev || die
echo "rootfs='${rootfs}'" >> ${DEST}/etc/rootdev || die

# install detected modules
echo "Coping your modules to '${DEST}/lib' ..."
for MODULE in ${MODULES}
do
	if [ -x /usr/bin/strip ] && [[ ${NOSTRIP} = false ]]
	then
		/usr/bin/strip -g ${verbose} ${MODULE} -o ${DEST}/lib/$(basename ${MODULE}) || die
	else
		cp ${verbose} -a ${MODULE} ${DEST}/lib || die
	fi
done

# create the image
echo "Creating initrd image '${target}' ..."
if [[ ${IMAGE_TYPE} = initramfs ]]
then
	(cd "${DEST}" ; find . | cpio --quiet -o -H newc | gzip -9 >${IMAGE})
	cat ${IMAGE} > ${target} || die
fi

if [[ ${IMAGE_TYPE} = loopback ]]
then
	MOUNTTMP="$(mktemp -d)"

	# create ext2 img
	dd if=/dev/zero of=${IMAGE} bs=1024 count=${IMAGESIZE} &> /dev/null || die
	mke2fs -m 0 -i 1024 -F ${IMAGE} &> /dev/null || die
	mount -o loop ${IMAGE} ${MOUNTTMP} || die
	mv ${DEST}/* ${MOUNTTMP} || die
	umount ${MOUNTTMP} || die
	gzip -9 ${IMAGE} || die
	cat ${IMAGE}.gz > ${target} || die
	[ -d ${MOUNTTMP} ] && rm -rf ${MOUNTTMP}

	# create inird dir for pivot_root
	[ ! -d /initrd ] && { install -d /initrd || die; }
fi

# clean up
[ -d ${DEST} ] && rm -rf ${DEST}
[ -f ${IMAGE} ] && rm -f ${IMAGE}

# all went ok at this point
exit 0