Viewing file: mkinitrd (54.29 KB) -rwxr-xr-x Select action/file-type: (+) | (+) | (+) | Code (+) | Session (+) | (+) | SDB (+) | (+) | (+) | (+) | (+) | (+) | #!/bin/bash --norc
#
# mkinitrd
#
# Copyright 2005 Red Hat, Inc.
#
# Written by Erik Troan
#
# Contributors:
# Elliot Lee
# Miguel de Icaza
# Christian 'Dr. Disk' Hechelmann
# Michael K. Johnson
# Pierre Habraken
# Jakub Jelinek
# Carlo Arenas Belon (carenas@chasqui.lared.net.pe>
# Keith Owens
# Bernhard Rosenkraenzer
# Matt Wilson
# Trond Eivind Glomsrød
# Jeremy Katz
# Preston Brown
# Bill Nottingham
# Guillaume Cottenceau
# Peter Jones
export MALLOC_PERTURB_=204
PATH=/sbin:/usr/sbin:/bin:/usr/bin:$PATH
export PATH
. /etc/rc.d/init.d/functions
LC_COLLATE=C
export LC_COLLATE
# Set the umask. For iscsi, the initrd can contain platintext
# password (chap secret), so only allow read by owner.
umask 077
VERSION=5.1.19.6
PROBE="yes"
MODULES=""
BOOTMODULES=""
FIPSMODULES=""
MODLOOPS=""
PREMODS=""
PREINTERFACES=""
NET_LIST=""
DHCPDEVS=""
ncryptodevs=0
ncryptoparts=0
ncryptolvs=0
ncryptoraids=0
CFG_DIR=${MKINITRD_CONFIG_DIR:-/etc/sysconfig/mkinitrd}
cfgs="$CFG_DIR/*[^~]"
for cfg in $cfgs ; do
[ -x $cfg ] && . $cfg
done
CONFMODS="$MODULES"
MODULES=""
ARCH=$(uname -m | sed -e 's/s390x/s390/')
compress=1
allowmissing=""
target=""
kernel=""
force=""
verbose=""
img_vers=""
builtins=""
modulefile=/etc/modules.conf
[ "$ARCH" == "s390" ] && withusb=0 || withusb=1
[ "$MULTIPATH" == "no" ] && withmpath=0 || withmpath=1
[ "$DMRAID" == "no" ] && withdmraid=0 || withdmraid=1
withfips=0
if [ -f /proc/sys/crypto/fips_enabled ]; then
withfips=$(cat /proc/sys/crypto/fips_enabled)
fi
rc=0
IMAGESIZE=8000
PRESCSIMODS="sd_mod"
fstab="/etc/fstab"
vg_list=""
net_list="$NET_LIST"
vecho()
{
NONL=""
if [ "$1" == "-n" ]; then
NONL="-n"
shift
fi
if [ -n "$verbose" ]; then
echo $NONL "$@"
fi
}
error()
{
NONL=""
if [ "$1" == "-n" ]; then
NONL="-n"
shift
fi
echo $NONL "$@" >&2
}
usage () {
if [ "$1" == "-n" ]; then
cmd=echo
else
cmd=error
fi
$cmd "usage: `basename $0` [--version] [--help] [-v] [-f] [--preload ]"
$cmd " [--force-ide-probe] [--force-scsi-probe | --omit-scsi-modules]"
$cmd " [--image-version] [--force-raid-probe | --omit-raid-modules]"
$cmd " [--with=] [--force-lvm-probe | --omit-lvm-modules]"
$cmd " [--builtin=] [--net-dev=] [--with-fips]"
$cmd " [--without-usb] [--without-multipath] [--without-dmraid]"
$cmd " [--fstab=] [--nocompress] "
$cmd ""
$cmd " (ex: `basename $0` /boot/initrd-2.2.5-15.img 2.2.5-15)"
if [ "$1" == "-n" ]; then
exit 0
else
exit 1
fi
}
moduledep() {
vecho -n "Looking for deps of module $1"
deps=$(modprobe --set-version $kernel --show-depends $1 2>/dev/null| awk '/^insmod / { print gensub(".*/","","g",$2) }' | while read foo ; do [ "${foo%%.ko}" != "$1" ] && echo -n "${foo%%.ko} " ; done)
[ -n "$deps" ] && vecho ": $deps" || vecho
}
locatemodule() {
fmPath=$(modprobe --set-version $kernel --show-depends $1 2>/dev/null | awk '/^insmod / { print $2; }' | tail -1)
if [ -n "$fmPath" -a -f "$fmPath" ]; then
return 0
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 $1.$modExt)
if [ -L "$fmPath" ]; then
fmPath=$(readlink -f "$fmPath")
fi
if [ -n "$fmPath" -a -f "$fmPath" ]; then
return 0
fi
fi
done
done
return 1
}
findone() {
echo nash-find "$@" | /sbin/nash --force --quiet \
| /bin/awk '{ print $1; exit; }'
}
findall() {
echo nash-find "$@" | /sbin/nash --force --quiet
}
resolve_device_name() {
echo nash-resolveDevice "$1" | /sbin/nash --forcequiet
}
find_dm_in_sysblock() {
devname=$(resolve_device_name $1)
[ -z "$devname" ] && return 1
majmin=$(get_numeric_dev dec $devname)
[ -z "$majmin" ] && return 1
findall /sys/block -name dev | while read device ; do \
echo "$majmin" | cmp -s $device && echo $device ; done \
| sed -e 's,/dev$,,'
}
is_mpath() {
major=$(echo $1 | cut -d: -f1)
minor=$(echo $1 | cut -d: -f2)
for target in $(dmsetup -C -j $major -m $minor table 2>/dev/null | \
grep -v "No devices found" | awk ' { print $3 }') ; do
[ "$target" == "multipath" ] && return 0
done
return 1
}
get_disk_vendor() {
local vendor=$(scsi_id -g -u -s ${1#/sys} -x | grep ^ID_VENDOR= | \
sed 's/^ID_VENDOR=//')
[ -n "$vendor" ] || vendor=$(scsi_id -g -ppre-spc3-83 -u -s ${1#/sys} -x \
| grep ^ID_VENDOR= | sed 's/^ID_VENDOR=//')
[ -z "$vendor" ] && return 1
echo ${vendor}
}
# this sucks; we need a generic way to get the hardware handler
is_emc() {
local syspath=$1
local devpath=$2
local majmin=$(cat ${syspath}/dev)
local major=$(echo $1 | cut -d: -f1)
local minor=$(echo $1 | cut -d: -f2)
if dmsetup -C -j $major -m $minor table 2>/dev/null | \
grep -v "No devices found" | grep -q " emc " ; then
return 0
fi
if [ "$(get_disk_vendor ${syspath})" == "DGC" ]; then
return 0
fi
return 1
}
find_mpath_deps() {
local devpath="/dev/$(echo $1 | sed -e 's,.*/\([^/]\+\),\1,' )"
local arg2="$2"
local majmin=$(cat $1/dev)
local ret=1
if [ "${arg2}" == "yes" ]; then
if is_emc ${1} ${devpath} ; then
ret=0
fi
fi
if is_mpath ${majmin} ; then
arg2=yes
fi
slaves="$1/slaves/*"
for slave in $slaves ; do
[ -e $slave ] || continue
find_mpath_deps $(readlink $slave) ${arg2} && ret=0
done
if [ "$2" == "yes" ]; then
echo $devpath
fi
return $ret
}
findmodule() {
skiperrors=""
if [ $1 == "--skiperrors" ]; then
skiperrors=--skiperrors
shift
fi
if [ $1 == "--loop" ]; then
MODLOOPS=" $MODLOOPS$2 "
shift
shift
fi
local modName=$1
if [ "$modName" = "off" -o "$modName" = "null" ]; then
return
fi
if [ "$modName" != "${modName##-}" ]; then
skiperrors=--skiperrors
modName="${modName##-}"
fi
case "$MODULES $BOOTMODULES $FIPSMODULES " in
*"/$modName.ko "*) return ;;
esac
if echo $builtins | egrep -q '(^| )'$modName'( |$)' ; then
vecho "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"
elif [ "$modName" = "gfs2" ]; then
case " $MODLOOPS " in
*" gfs2 "*) ;;
*)
findmodule --loop gfs2 lock_nolock
case " $MODULES " in
*"/gfs2.ko "*) return ;;
esac
;;
esac
elif [ "$modName" = "nfs" ]; then
findmodule sunrpc
modName="nfs"
elif [ "$modName" = "usb-storage" -o "$modName" = "ub" ]; then
usbModName="$modName"
fi
if [ -n "$usbModName" \
-a "$modName" != "uhci-hcd" \
-a "$modName" != "ohci-hcd" \
-a "$modName" != "ehci-hcd" ]; then
withusb=1
findmodule ehci-hcd
findmodule ohci-hcd
findmodule uhci-hcd
usbModName=""
fi
moduledep $modName
for i in $deps; do
findmodule $i
done
locatemodule $modName
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
error "WARNING: No module $modName found for kernel $kernel, continuing anyway"
return
fi
error "No module $modName found for kernel $kernel, aborting."
exit 1
fi
# only need to add each module once
MODULES="$MODULES $fmPath"
# need to handle prescsimods here -- they need to go _after_ scsi_mod
if [ "$modName" = "scsi_mod" ]; then
for n in $PRESCSIMODS ; do
findmodule $n
done
fi
}
find_scsi_dh_modules() {
local scsipath=$(modprobe --set-version $kernel --show-depends sg 2>/dev/null | awk '/^insmod / { print $2; }' | tail -1)
scsipath="${scsipath%%sg.ko}device_handler/"
[ -d "$scsipath" ] || return
for x in $scsipath/*.ko ; do
local h=${x##*/}
findmodule -${h%%.ko}
done
}
inst() {
if [ "$#" != "2" ];then
echo "usage: inst "
return
fi
vecho "$1 -> $2"
mkdir -p $(dirname $2)
cp $1 $2
}
readlink() {
echo nash-readlink "$1" | /sbin/nash --force --quiet
}
access() {
echo nash-access "$@" | /sbin/nash --force --quiet
}
slavestried=""
findstoragedriverinsys () {
while [ ! -L device ]; do
if [ -d slaves ]; then
for slave in slaves/* ; do
[ "$slave" == "slaves/*" ] && continue
slavename=${slave##*/}
case " $slavestried " in
*" $slavename "*)
continue
;;
*)
slavestried="$slavestried $slavename"
pushd $slave >/dev/null 2>&1
findstoragedriverinsys
popd >/dev/null 2>&1
;;
esac
done
fi
[ "$PWD" = "/sys" ] && return
cd ..
done
cd $(readlink ./device)
if is_iscsi $PWD; then
handleiscsi "$PWD"
return
fi
if echo $PWD | grep -q /virtio-pci/ ; then
findmodule virtio_pci
fi
while [ "$PWD" != "/sys/devices" ]; do
deps=
if [ -f modalias ]; then
moduledep $(cat modalias)
fi
[ -z "$deps" -a -L driver/module ] && \
deps=$(basename $(readlink driver/module))
for driver in $deps ; do
findmodule $driver
done
cd ..
done
}
findstoragedriver () {
for device in $@ ; do
case " $handleddevices " in
*" $device "*)
continue ;;
*) handleddevices="$handleddevices $device" ;;
esac
if [[ "$device" =~ "^md[0-9]+" ]]; then
vecho "Found RAID component $device"
handleraid "$device"
continue
fi
vecho "Looking for driver for device $device"
if [[ "$device" =~ ^(dm-|mapper/) ]]; then
device=$(resolve_dm $device)
vecho "Found DM device $device"
majmin=$(get_numeric_dev dec "/dev/$device")
sysfs=$(find_dm_in_sysblock /dev/$device)
handledm $(echo "$majmin" |cut -d : -f 1) $(echo "$majmin" |cut -d : -f 2)
else
sysfs=$(findone -type d /sys/block -name $device)
fi
[ -z "$sysfs" ] && return
pushd $sysfs >/dev/null 2>&1
findstoragedriverinsys
popd >/dev/null 2>&1
done
}
findnetdriver() {
for device in $@ ; do
case " $handleddevices " in
*" $device "*)
continue ;;
*) handleddevices="$handleddevices $device" ;;
esac
if [ -f /sys/class/net/$device/device/modalias ]; then
modalias=$(cat /sys/class/net/$device/device/modalias)
moduledep $modalias
for driver in $deps ; do
findmodule $driver
done
elif [ "$(basename $(readlink /sys/class/net/$device/device/bus) 2>/dev/null)" = "xen" ]; then
findmodule xennet # FIXME: hack for xennet sucking
else
findmodule $(ethtool -i $device | awk '/^driver:/ { print $2 }')
fi
done
}
iscsi_get_rec_val() {
# The open-iscsi 742 release changed to using flat files in
# /var/lib/iscsi.
result=$(/sbin/iscsiadm --show -m session -r ${1} | grep "^${2} = ")
result=${result##* = }
}
ibft_get_rec_val() {
result=$(/sbin/iscsiadm -m fw 2>/dev/null | grep "^${1} = ")
result=${result##* = }
}
iscsi_set_parameters() {
path=$1
vecho setting iscsi parameters
# Check once before getting explicit values, so we can output a decent
# error message.
if ! /sbin/iscsiadm -m session -r ${path} >/dev/null ; then
echo Unable to find iscsi record for $path
exit 1
fi
nit_name=$(grep "^InitiatorName=" /etc/iscsi/initiatorname.iscsi | \
sed -e "s/^InitiatorName=//")
iscsi_get_rec_val $path "node.name"; tgt_name=${result}
iscsi_get_rec_val $path "node.tpgt"; tpgt=${result}
iscsi_get_rec_val $path "node.conn\[0\].address"; tgt_ipaddr=${result}
iscsi_get_rec_val $path "node.conn\[0\].port"; tgt_port=${result}
# Note: we get chap secrets (passwords) in plaintext, and also store
# them in the initrd.
iscsi_get_rec_val $path "node.session.auth.username"
chap=${result}
if [ -n "${chap}" -a "${chap}" != "" ]; then
chap="-u ${chap}"
iscsi_get_rec_val $path "node.session.auth.password"
chap_pw="-w ${result}"
else
chap=""
fi
iscsi_get_rec_val $path "node.session.auth.username_in"
chap_in=${result}
if [ -n "${chap_in}" -a "${chap_in}" != "" ]; then
chap_in="-U ${chap_in}"
iscsi_get_rec_val $path "node.session.auth.password_in"
chap_in_pw="-W ${result}"
else
chap_in=""
fi
}
iscsi_is_ibft() {
path=$1
iscsi_get_rec_val $path "node.name"; tgt_name=${result}
iscsi_get_rec_val $path "node.conn\[0\].address"; tgt_ipaddr=${result}
iscsi_get_rec_val $path "node.conn\[0\].port"; tgt_port=${result}
found_name=no
found_ipaddr=no
found_port=no
res=$(iscsiadm -m fw 2>/dev/null | while read key equal value ; do
if [ "$key" == "node.name" ]; then
[ "$value" == "$tgt_name" ] && found_name=yes
elif [[ "$key" =~ "node.conn\[[[:alnum:]]+\].address" ]]; then
[ "$value" == "$tgt_ipaddr" ] && found_ipaddr=yes
elif [[ "$key" =~ "node.conn\[[[:alnum:]]+\].port" ]]; then
[ "$value" == "$tgt_port" ] && found_port=yes
fi
if [ "$found_name" == "yes" -a \
"$found_ipaddr" == "yes" -a "$found_port" == "yes" ]; then
echo yes
break
fi
done)
if [ "$res" == "yes" ]; then
return 0
else
return 1
fi
}
emit_iscsi_device() {
dev=${1##iscsi_device_}
emit "echo Attaching to iSCSI storage"
inst /sbin/iscsistart "$MNTIMAGE/sbin/iscsistart"
if iscsi_is_ibft $dev ; then
emit "/bin/iscsistart -b"
else
iscsi_set_parameters $dev
# recid is not really used, just use 0 for it
emit "/bin/iscsistart -t ${tgt_name} -i ${nit_name} \
-g ${tpgt} -a ${tgt_ipaddr} ${chap} ${chap_pw} \
${chap_in} ${chap_in_pw}"
fi
}
is_iscsi() {
path=$1
if echo $path | grep -q "/platform/host[0-9]*/session[0-9]*/target[0-9]*:[0-9]*:[0-9]*/[0-9]*:[0-9]*:[0-9]*:[0-9]*"; then
return 0
else
return 1
fi
}
handleiscsi() {
vecho "Found iscsi component $1"
findmodule iscsi_tcp
findmodule sd_mod
# We call iscsi_set_parameters once here to figure out what network to
# use (it sets tgt_ipaddr), and once again to emit iscsi values,
# not very efficient.
if iscsi_is_ibft $1 ; then
findmodule iscsi_ibft
for mac in $(cat /sys/firmware/ibft/ethernet*/mac) ; do
netdev=$(/sbin/ip -o link list | grep $mac | \
sed 's/^[^ ]\+ \([^ ]\+\): .*$/\1/g')
addnetdev $netdev
done
else
iscsi_set_parameters $1
netdev=$(/sbin/ip route get to $tgt_ipaddr | \
sed 's|.*dev \(.*\).*|\1|g' | awk '{ print $1; exit }')
addnetdev $netdev
fi
iscsi_devs="$iscsi_devs $1"
MODULES="$MODULES iscsi_device_$1"
}
handleraid() {
local start=0
if [ -n "$noraid" -o ! -f /proc/mdstat ]; then
return 0
fi
levels=$(awk "/^$1[ ]*:/ { print\$4 }" /proc/mdstat)
devs=$(gawk "/^$1[ ]*:/ { print gensub(\"\\\\[[0-9]*\\\\]\",\"\",\"g\",gensub(\"^md.*raid[0-9]*\",\"\",\"1\")) }" /proc/mdstat)
for level in $levels ; do
case $level in
linear)
findmodule linear
start=1
;;
multipath)
findmodule multipath
start=1
;;
raid[01456] | raid10)
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
}
resolve_dm() {
# resolve device mapper nodes to something of the form /dev/mapper/foo
if [[ ! "$1" =~ ^dm- ]]; then
echo $1
return 0
fi
majmin=$(cat /sys/block/$1/dev)
for dmdev in /dev/mapper/* ; do
dmnum=$(get_numeric_dev dec $dmdev)
if [ "$dmnum" = "$majmin" ]; then
echo ${dmdev#/dev/}
break
fi
done
}
handledm() {
major=$1
minor=$2
while read dmstart dmend dmtype r0 r1 r2 r3 r4 r5 r6 r7 r8 r9 ; do
case "$dmtype" in
crypt)
slavedev=$(findall /sys/block -name dev \
| while read device ; do \
echo "$r3" \
| cmp -s $device && echo $device ; \
done \
| sed -e 's,.*/\([^/]\+\)/dev,\1,;s,!,/,' )
slavedev=$(resolve_dm ${slavedev##/dev/})
cryptsetup isLuks "/dev/$slavedev" 2>/dev/null || continue
vecho "device is LUKS, slave is $slavedev"
find_base_dm_mods
findmodule dm-crypt
for mod in $(echo $r0 | tr ':-' ' ') ; do
findmodule --skiperrors $mod
done
dmname=$(dmsetup info -j $major -m $minor -c --noheadings -o name)
slavedev=$(resolve_dm $slavedev)
# determine if $slavedev is an LV
# if so, add the device to latecryptodevs
# if not, add the device to cryptodevs
local vg=$(lvm.static lvs --ignorelockingfailure --noheadings -o vg_name /dev/$slavedev 2>/dev/null)
if [ -n "$vg" ]; then
eval cryptolv${ncryptolvs}='"'/dev/$slavedev $dmname'"'
let ncryptolvs++
elif grep -q "^$slavedev :" /proc/mdstat ; then
eval cryptoraid${ncryptoraids}='"'/dev/$slavedev $dmname'"'
let ncryptoraids++
else
eval cryptopart${ncryptoparts}='"'/dev/$slavedev $dmname'"'
let ncryptoparts++
fi
let ncryptodevs++
handlelvordev "/dev/$slavedev"
;;
esac
done << EOF
$(dmsetup table -j $major -m $minor 2>/dev/null)
EOF
}
dmmods_found="n"
find_base_dm_mods()
{
[ "$dmmods_found" == "n" ] || return
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
dmmods_found="y"
}
handlelvordev() {
local vg=`lvm.static lvs --ignorelockingfailure --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 `lvm.static vgdisplay --ignorelockingfailure -v $vg 2>/dev/null | sed -n 's/PV Name//p'`; do
findstoragedriver ${device##/dev/}
done
;;
esac
else
findstoragedriver ${1##/dev/}
fi
}
handlenetdev() {
local dev=$1
source /etc/sysconfig/network
if [ ! -f /etc/sysconfig/network-scripts/ifcfg-$dev ]; then
error "unable to find network device configuration for $dev"
else
source /etc/sysconfig/network-scripts/ifcfg-$dev
fi
if [ x"$BOOTPROTO" = x ]; then
error "bootproto not specified for $dev, assuming DHCP"
BOOTPROTO=dhcp
fi
[ -n "$IPADDR" ] && IPSTR="$IPSTR --ip $IPADDR"
[ -n "$NETMASK" ] && IPSTR="$IPSTR --netmask $NETMASK"
[ -n "$GATEWAY" ] && IPSTR="$IPSTR --gateway $GATEWAY"
[ -n "$ETHTOOL_OPTS" ] && IPSTR="$IPSTR --ethtool \"$ETHTOOL_OPTS\""
[ -n "$MTU" ] && IPSTR="$IPSTR --mtu $MTU"
if [ -n "$IPADDR" ]; then
[ -z "$DOMAIN" ] && DOMAIN=$(awk '/^search / { print gensub("^search ","",1) }' /etc/resolv.conf)
if [ -z "$DNS1" ]; then
DNS1=$(awk '/^nameserver / { ORS="" ; if (x > 0) print "," ; printf "%s", $2 ; x = 1}' /etc/resolv.conf)
fi
fi
[ -n "$DOMAIN" ] && IPSTR="$IPSTR --domain \"$DOMAIN\""
if [ -n "$DNS1" ]; then
if [ -n "$DNS2" ]; then
IPSTR="$IPSTR --dns $DNS1,$DNS2"
else
IPSTR="$IPSTR --dns $DNS1"
fi
fi
prenetwork=""
if [ -n "$HWADDR" ]; then
prenetwork="netname $HWADDR $dev"
fi
network="network --device $dev --bootproto $BOOTPROTO $IPSTR"
if [ "$BOOTPROTO" = "dhcp" ]; then
postnetwork="rename /var/lib/dhclient/dhclient.leases /var/lib/dhclient/dhclient-$dev.leases"
DHCPDEVS="$DHCPDEVS $dev"
mkdir -p $MNTIMAGE/var/lib/dhclient
fi
}
addnetdev() {
dev=$1
vecho "Adding network device $dev"
findnetdriver $dev
MODULES="$MODULES network_device_$netdev"
net_list="$net_list $netdev"
}
handlenfs() {
remote=${1%%:*}
remoteip=$(host $remote | awk '/ address / { print $4 }')
# assume, if it didn't resolve, that it's an IP
[ -z "$remoteip" ] && remoteip=$remote
netdev=`/sbin/ip route get to $remoteip |sed 's|.*dev \(.*\).*|\1|g' |awk '{ print $1; exit }'`
addnetdev $netdev
}
emit_modules()
{
scsi=""
usb_mounted="prep"
for MODULE in "$@"; do
text=""
if [[ "$MODULE" =~ "^iscsi_device_" ]] ; then
emit_iscsi_device "${MODULE##iscsi_device_}"
continue
elif [[ "$MODULE" =~ "^network_device_" ]] ; then
netdev="${MODULE##network_device_}"
emit "echo Bringing up $netdev"
handlenetdev "$netdev"
if [ -n "$prenetwork" ]; then
emit $prenetwork
fi
emit $network
if [ -n "$postnetwork" ]; then
emit $postnetwork
fi
continue
fi
module=`echo $MODULE | sed -e "s|.*/||" -e "s/.k\?o$//"`
fullmodule=`echo $MODULE | sed "s|.*/||"`
options=`sed -n -e ':a' -e '/\\\\$/N; s/\\\\\n//; ta' -e "s/^options[ ][ ]*$module[ ][ ]*//p" $modulefile 2>/dev/null`
if [ -n "$options" ]; then
vecho "Adding module $module$text with options $options"
else
vecho "Adding module $module$text"
fi
# we mount usbfs before the first module *after* the HCDs
if [ "$usb_mounted" == "prep" ]; then
if [[ "$module" =~ ".hci[_-]hcd" ]]; then
usb_mounted="no"
fi
elif [ "$usb_mounted" == "no" ]; then
if [[ ! "$module" =~ ".hci[_-]hcd" ]]; then
usb_mounted=yes
emit "mount -t usbfs /proc/bus/usb /proc/bus/usb"
fi
fi
emit "echo \"Loading $fullmodule module\""
emit "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" -o "$module" = "ub" ]; then
emit "echo Waiting for driver initialization."
emit "stabilized /proc/bus/usb/devices"
fi
if [ "$module" = "sbp2" ]; then
emit "echo Waiting for driver initialization."
emit "stabilized /sys/bus/ieee1394/drivers/sbp2"
fi
if [ "$module" = "scsi_mod" ]; then
scsi="yes"
fi
if [ "$module" = "zfcp" -a -f /etc/zfcp.conf ]; then
emit "echo Waiting 2 seconds for driver initialization."
emit "sleep 2"
cat /etc/zfcp.conf | grep -v "^#" | tr "A-Z" "a-z" | while read DEVICE TWO THREE FOUR FIVE; do
if [ -z "$FIVE" ]; then
WWPN=$TWO
FCPLUN=$THREE
else
WWPN=$THREE
FCPLUN=$FIVE
fi
cemit < /sys/bus/ccw/drivers/zfcp/${DEVICE/0x/}/port_add
echo -n $FCPLUN > /sys/bus/ccw/drivers/zfcp/${DEVICE/0x/}/$WWPN/unit_add
echo -n 1 > /sys/bus/ccw/drivers/zfcp/${DEVICE/0x/}/online
EOF
done
fi
done
unset usb_mounted
if [ -n "$scsi" ]; then
emit "echo Waiting for driver initialization."
emit "stabilized --hash --interval 1000 /proc/scsi/scsi"
fi
# HACK: module loading + device creation isn't necessarily synchronous...
# this will make sure that we have all of our devices before trying
# things like RAID or LVM
emit "mkblkdevs"
}
while [ $# -gt 0 ]; do
case $1 in
--fstab*)
if [ "$1" != "${1##--fstab=}" ]; then
fstab=${1##--fstab=}
else
fstab=$2
shift
fi
;;
--with-fips)
withfips=1
;;
--with-usb*)
if [ "$1" != "${1##--with-usb=}" ]; then
usbmodule=${1##--with-usb=}
else
usbmodule="usb-storage"
fi
basicmodules="$basicmodules $usbmodule"
unset usbmodule
;;
--without-usb)
withusb=0
;;
--without-multipath)
withmpath=0
;;
--without-dmraid)
withdmraid=0
;;
--with*)
if [ "$1" != "${1##--with=}" ]; then
modname=${1##--with=}
else
modname=$2
shift
fi
basicmodules="$basicmodules $modname"
;;
--builtin*)
if [ "$1" != "${1##--builtin=}" ]; then
modname=${1##--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 [ "$1" != "${1##--preload=}" ]; then
modname=${1##--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
;;
--net-dev*)
if [ "$1" != "${1##--net-dev=}" ]; then
PREINTERFACES="$PREINTERFACES ${1##--net-dev=}"
else
PREINTERFACES="$PREINTERFACES $2"
shift
fi
;;
--noresume)
noresume=1
;;
--rootdev*)
if [ "$1" != "${1##--rootdev=}" ]; then
rootdev="${1##--rootdev=}"
else
rootdev="$2"
shift
fi
;;
--rootfs*)
if [ "$1" != "${1##--rootfs=}" ]; then
rootfs="${1##--rootfs=}"
else
rootfs="$2"
shift
fi
;;
--rootopts*)
if [ "$1" != "${1##--rootopts=}" ]; then
rootopts="${1##--rootopts=}"
else
rootopts="$2"
shift
fi
;;
--loopdev*)
if [ "$1" != "${1##--loopdev=}" ]; then
loopdev="${1##--loopdev=}"
else
loopdev="$2"
shift
fi
;;
--loopfs*)
if [ "$1" != "${1##--loopfs=}" ]; then
loopfs="${1##--loopfs=}"
else
loopfs="$2"
shift
fi
;;
--loopopts*)
if [ "$1" != "${1##--loopopts=}" ]; then
loopopts="${1##--loopopts=}"
else
loopopts="$2"
shift
fi
;;
--looppath*)
if [ "$1" != "${1##--looppath=}" ]; then
looppath="${1##--looppath=}"
else
looppath="$2"
shift
fi
;;
--help)
usage -n
;;
*)
if [ -z "$target" ]; then
target=$1
elif [ -z "$kernel" ]; then
kernel=$1
else
usage
fi
;;
esac
shift
done
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
error "$target already exists."
exit 1
fi
if [ -n "$forcescsi" -a -n "$noscsi" ]; then
error "Can't both force scsi probe and omit scsi modules"
exit 1
fi
if [ -n "$forceraid" -a -n "$noraid" ]; then
error "Can't both force raid probe and omit raid modules"
exit 1
fi
if [ -n "$forcelvm" -a -n "$nolvm" ]; then
error "Can't both force LVM probe and omit LVM modules"
exit 1
fi
if [ ! -d /lib/modules/$kernel ]; then
error 'No modules available for kernel "'${kernel}'".'
exit 1
fi
if [ $UID != 0 ]; then
error "mkinitrd must be run as root."
exit 1
fi
vecho "Creating initramfs"
modulefile=/etc/modprobe.conf
# find a temporary directory which doesn't use tmpfs
if [ -z "$loopfs" ]; then
TMPDIR="/tmp"
else
TMPDIR=""
for t in /tmp /var/tmp /root ${PWD}; do
if [ ! -d $t ]; then continue; fi
if ! access -w $t ; then continue; fi
fs=$(df -T $t 2>/dev/null | awk '{line=$1;} END {printf $2;}')
if [ "$fs" != "tmpfs" ]; then
TMPDIR=$t
break
fi
done
fi
if [ -z "$TMPDIR" ]; then
error "no temporary directory could be found."
exit 1
fi
if [ $TMPDIR = "/root" -o $TMPDIR = "${PWD}" ]; then
error "WARNING: using $TMPDIR for temporary files"
fi
if [ "$withfips" -eq 1 ]; then
if [ "$(uname -m)" == "ia64" ]; then
BOOT=/boot/efi
HMAC_PATH=/boot/efi/efi/redhat
else
BOOT=/boot
HMAC_PATH=/boot
fi
bootfs=$(awk '{ if ($1 !~ /^[ \t]*#/ && $2 == "'$BOOT'") { print $3; }}' $fstab)
bootdev=$(awk '/^[ \t]*[^#]/ { if ($2 == "'$BOOT'") { print $1; }}' $fstab)
if [ -z "$bootfs" ]; then
error "ERROR: fips without a separate $BOOT partition is not supported!"
exit 1
fi
# in case the boot filesystem is modular
findmodule -${bootfs}
if [[ "$bootdev" =~ ^(LABEL=|UUID=) ]]; then
devname=$(resolve_device_name $bootdev)
else
devname=$bootdev
fi
devname=${devname##/dev/}
# cciss is *very* special not only does its devicename contain a / which
# must be translated to a ! in sysfs, doing the translation is not enough
# as cciss' /sys/block entries lack a device symlink (great guys, really
# great!) so just hardcode it
if [[ "$devname" =~ "^cciss/" ]]; then
findmodule cciss
else
findstoragedriver $devname
fi
BOOTMODULES="$MODULES"
MODULES=""
vecho "Using $BOOT modules: $BOOTMODULES"
FIPSMODULES="aead aes_generic -aes-x86_64 ansi_cprng cbc ccm chainiv ctr"
FIPSMODULES="$FIPSMODULES des deflate ecb eseqiv hmac seqiv sha256 sha512"
FIPSMODULES="$FIPSMODULES cryptomgr crypto_null tcrypt"
# To resolve deps (and in case of aes-x86_64 see if it exists)
for n in $FIPSMODULES; do
findmodule $n
done
FIPSMODULES="$MODULES"
MODULES=""
vecho "Forcibly loading cryptmodules: $FIPSMODULES"
fi
for n in $PREMODS; do
findmodule $n
done
for n in $PREINTERFACES ; do
findnetdriver $n
MODULES="$MODULES network_device_$n"
net_list="$net_list $n"
done
if [ "$withusb" -eq 1 ]; then
findmodule ehci-hcd
findmodule ohci-hcd
findmodule uhci-hcd
fi
if [ "x$PROBE" == "xyes" ]; then
[ -z "$rootfs" ] && rootfs=$(awk '{ if ($1 !~ /^[ \t]*#/ && $2 == "/") { print $3; }}' $fstab)
[ -z "$rootopts" ] && rootopts=$(awk '{ if ($1 !~ /^[ \t]*#/ && $2 == "/") { print $4; }}' $fstab)
[ -z "$rootopts" ] && rootopts="defaults"
# in case the root filesystem is modular
findmodule -${rootfs}
[ -z "$rootdev" ] && rootdev=$(awk '/^[ \t]*[^#]/ { if ($2 == "/") { print $1; }}' $fstab)
# check if it's nfsroot
if [ "$rootfs" == "nfs" -a "x$net_list" == "x" ]; then
handlenfs $rootdev
# check if it's root by label
elif [ "$rootdev" != "${rootdev##LABEL=}" -o \
"$rootdev" != "${rootdev##UUID=}" ]; then
rootopts=$(echo $rootopts | sed -e 's/^r[ow],//' \
-e 's/,_netdev//' \
-e 's/_netdev//' \
-e 's/,_rnetdev//' \
-e 's/_rnetdev//' \
-e 's/,r[ow],$//' \
-e 's/,r[ow],/,/' \
-e 's/^r[ow]$/defaults/' \
-e 's/$/,ro/')
devname=$(resolve_device_name $rootdev)
majmin=$(get_numeric_dev dec $devname)
if [[ "$devname" =~ ^/dev/mapper/ ]]; then
vecho "Found root device $devname for $rootdev"
rootdev=$devname
elif [ -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
vecho "Found root device $dev for $rootdev"
rootdev=$dev
fi
fi
else
rootopts=$(echo $rootopts | sed -e 's/^r[ow],//' \
-e 's/,_netdev//' \
-e 's/_netdev//' \
-e 's/,_rnetdev//' \
-e 's/_rnetdev//' \
-e 's/,r[ow],$//' \
-e 's/,r[ow],/,/' \
-e 's/^r[ow]$/defaults/' \
-e 's/$/,ro/')
fi
[ "$rootfs" != "nfs" ] && handlelvordev $rootdev
# find the first swap dev which would get used for swsusp
swsuspdev=$(awk '/^[ \t]*[^#]/ { if ($3 == "swap") { print $1; exit }}' $fstab)
if [ -n "$swsuspdev" ]; then
swsuspdevresolved=$swsuspdev
if [[ "$swsuspdev" =~ ^(LABEL=|UUID=) ]]; then
swsuspdevresolved=$(resolve_device_name $swsuspdev)
fi
handlelvordev $swsuspdevresolved
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 $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
# Loopback root support
# loopdev : device or nfs server:path file is on
# looppath : filename
# loopfs : filesystem of loopdev
# loopots : options to mount loopfs
if [ -n "${loopfs}" ] || [[ "$rootopts" =~ "loop" ]]; then
# FIXME: probe this somehow?
rootdev=/dev/loop0
[ -z "$rootopts" ] && rootopts="defaults"
findmodule loop
findmodule -${loopfs}
if [ "$loopfs" == "nfs" -a "x$net_list" == "x" ]; then
handlenfs $loopdev
fi
# FIXME: label support
[ "$loopfs" != "nfs" ] && handlelvordev $loopdev
fi
# If we use LVM or dm-based raid, include dm-mod
testdm=""
[ -n "$vg_list" ] && testdm="yes"
[ -n "$forceraid" -o -n "$forcelvm" ] && testdm="yes"
[ -z "$nolvm" -o -z "$noraid" ] && testdm="yes"
[ "x$PROBE" != "xyes" ] && testdm=""
MNTIMAGE=`mktemp -d ${TMPDIR}/initrd.XXXXXX`
IMAGE=`mktemp ${TMPDIR}/initrd.img.XXXXXX`
RCFILE=$MNTIMAGE/init
cemit()
{
cat >> $RCFILE
}
emit()
{
NONL=""
if [ "$1" == "-n" ]; then
NONL="-n"
shift
fi
echo $NONL "$@" >> $RCFILE
}
use_multipath=0
use_emc=0
use_xdr=0
if [ -n "$testdm" -a -x /sbin/dmsetup -a -e /dev/mapper/control ]; then
dmout=$(/sbin/dmsetup ls 2>/dev/null)
if [ "$dmout" != "No devices found" -a "$dmout" != "" ]; then
sysroot=$(find_dm_in_sysblock ${rootdev})
rootdevs=""
if [ "${withmpath}" -eq 1 -a -n "${sysroot}" ]; then
for rd in ${sysroot} ; do
somedeps=""
vg=`lvm.static lvs --ignorelockingfailure --noheadings -o vg_name $rootdev 2>/dev/null`
if [ -n "$vg" ]; then
for pv in `lvm.static vgdisplay --ignorelockingfailure -v $vg 2>/dev/null | sed -n 's/PV Name//p'`; do
syspv=$(find_dm_in_sysblock ${pv})
thesedeps=$(find_mpath_deps ${syspv})
[ "$?" == "0" ] && use_emc=1
for dep in ${thesedeps}; do
[[ ${majmin} =~ ^9: ]] && continue
[[ ${dep} =~ ^/dev/xvd.+ ]] && continue
case " ${somedeps} " in
*" ${dep} "*) continue ;;
*) somedeps="${somedeps} ${dep}" ;;
esac
done
done
else
thesedeps=$(find_mpath_deps ${rd})
[ "$?" == "0" ] && use_emc=1
for dep in ${thesedeps}; do
[[ ${majmin} =~ ^9: ]] && continue
[[ ${dep} =~ ^/dev/xvd.+ ]] && continue
case " ${somedeps} " in
*" ${dep} "*) continue ;;
*) somedeps="${somedeps} ${dep}" ;;
esac
done
fi
[ -z "$somedeps" ] && continue
for dep in ${somedeps} ; do
majmin=$(get_numeric_dev dec ${dep})
[[ ${majmin} =~ ^9: ]] && continue
[[ ${dep} =~ ^/dev/xvd.+ ]] && continue
case " ${rootdevs} " in
*" ${dep} "*) continue ;;
*) rootdevs="${rootdevs} ${dep}" ;;
esac
done
done
fi
if [ -z "$rootdevs" ]; then
rootdevs="$rootdev"
fi
root_wwids=""
if [ "${withmpath}" -eq "1" ]; then
for rootpath in ${rootdevs} ; do
disk=$(find_dm_in_sysblock ${rootpath} | sed -e 's,^/sys,,')
wwid=$(/sbin/scsi_id -g -u -s ${disk})
if [ -z "${wwid}" ]; then
# Could be EMC unit requiring special option
wwid=$(/sbin/scsi_id -g -ppre-spc3-83 -u -s ${disk})
fi
if [ -n "${wwid}" ]; then
case " ${root_wwids} " in
*" ${wwid} "*) continue ;;
*) root_wwids="${root_wwids} ${wwid}" ;;
esac
fi
done
if [ -n "$root_wwids" ]; then
use_multipath=1
fi
fi
find_base_dm_mods
# If we use dm-multipath devices, include the needed modules
if [ "$use_multipath" == "1" ]; then
find_scsi_dh_modules
findmodule -dm-multipath
findmodule -dm-round-robin
if [ "$use_emc" == "1" ]; then
findmodule -dm-emc
fi
fi
fi
# could be using xDR multipath on s390
if [ "${ARCH}" = "s390" ]; then
if [ -x /sbin/xdrgetuid ]; then
dasdlist="$(cd /dev ; /bin/ls -1 dasd?)"
if [ ! -z "${dasdlist}" ]; then
for dasddev in ${dasdlist} ; do
if [ ! -z "$(/sbin/xdrgetuid -p ${dasddev} | grep "^xdr")" ]; then
use_multipath=1
use_xdr=1
break
fi
done
fi
fi
find_base_dm_mods
findmodule multipath
findmodule dm-multipath
findmodule -dm-round-robin
fi
fi
if [ "$withdmraid" == "1" ]; then
findmodule -dm-mem-cache
findmodule -dm-region_hash
findmodule -dm-message
findmodule -dm-raid45
fi
for n in $basicmodules; do
findmodule $n
done
for n in $CONFMODS; do
findmodule $n
done
vecho "Using modules: $MODULES"
if [ -z "$MNTIMAGE" -o -z "$IMAGE" ]; then
error "Error creating temporaries. Try again"
exit 1
fi
mkdir -p $MNTIMAGE
mkdir -p $MNTIMAGE/lib/firmware
mkdir -p $MNTIMAGE/bin
mkdir -p $MNTIMAGE/etc
mkdir -p $MNTIMAGE/dev
mkdir -p $MNTIMAGE/proc
mkdir -p $MNTIMAGE/sys
mkdir -p $MNTIMAGE/sysroot
ln -s bin $MNTIMAGE/sbin
if [ -e /etc/fstab.sys ]; then
inst /etc/fstab.sys "$MNTIMAGE/etc/fstab.sys"
fi
inst /sbin/nash "$MNTIMAGE/bin/nash"
inst /sbin/insmod.static "$MNTIMAGE/bin/insmod"
ln -s /sbin/nash $MNTIMAGE/sbin/modprobe
for MODULE in $BOOTMODULES $FIPSMODULES $MODULES; do
if [[ "$MODULE" =~ "^iscsi_device_" ]]; then
continue
fi
if [[ "$MODULE" =~ "^network_device_" ]] ; then
continue
fi
if [ -x /usr/bin/strip ]; then
/usr/bin/strip -g $verbose $MODULE -o $MNTIMAGE/lib/$(basename $MODULE)
else
cp $verbose -a $MODULE $MNTIMAGE/lib
fi
for fw in $(/sbin/modinfo -F firmware $MODULE 2>/dev/null); do
if [ -f /lib/firmware/$fw ]; then
cp $verbose -a /lib/firmware/$fw $MNTIMAGE/lib/firmware/
fi
done
done
# mknod'ing the devices instead of copying them works both with and
# without devfs...
mkdir $MNTIMAGE/dev/mapper
mknod $MNTIMAGE/dev/ram0 b 1 0
mknod $MNTIMAGE/dev/ram1 b 1 1
ln -sf ram1 $MNTIMAGE/dev/ram
mknod $MNTIMAGE/dev/null c 1 3
mknod $MNTIMAGE/dev/zero c 1 5
mknod $MNTIMAGE/dev/systty c 4 0
if ! echo "$(uname -m)" | grep -q "s390"; then
for i in 0 1 2 3 4 5 6 7 8 9 10 11 12 ; do
mknod $MNTIMAGE/dev/tty$i c 4 $i
done
fi
for i in 0 1 2 3 ; do
mknod $MNTIMAGE/dev/ttyS$i c 4 $(($i + 64))
done
mknod $MNTIMAGE/dev/tty c 5 0
mknod $MNTIMAGE/dev/console c 5 1
mknod $MNTIMAGE/dev/ptmx c 5 2
mknod $MNTIMAGE/dev/rtc c 10 135
if [ "$(uname -m)" == "ia64" ]; then
mknod $MNTIMAGE/dev/efirtc c 10 136
fi
# FIXME -- this can really go poorly with clvm or duplicate vg names.
# nash should do lvm probing for us and write its own configs.
if [ -n "$vg_list" ]; then
inst /sbin/lvm.static "$MNTIMAGE/bin/lvm"
if [ -f /etc/lvm/lvm.conf ]; then
mkdir -p $MNTIMAGE/etc/lvm
/sbin/lvm.static dumpconfig > $MNTIMAGE/etc/lvm/lvm.conf
fi
fi
if [ "$use_multipath" == "1" ]; then
# For multipath command
inst /sbin/multipath.static $MNTIMAGE/bin/multipath
if [ -f /etc/multipath.conf ]; then
inst /etc/multipath.conf $MNTIMAGE/etc/multipath.conf
fi
if [ -f /var/lib/multipath/bindings ]; then
inst /var/lib/multipath/bindings $MNTIMAGE/var/lib/multipath/bindings
fi
inst /sbin/scsi_id $MNTIMAGE/bin/scsi_id
inst /etc/scsi_id.config $MNTIMAGE/etc/scsi_id.config
# This includes all mpath_prio checkers in the image (~2.5M)
# Alternately we can only include those that are used by the
# current mpath config. This would require users to rebuild
# the initrd if migrating/adding controllers from different
# storage vendors
for M in /sbin/mpath_prio_*.static ; do
inst ${M} $MNTIMAGE/${M%%.static};
done
mkdir -p $MNTIMAGE/tmp
# For kpartx command which creates device maps for disk partitions
# and creates device files
inst /sbin/dmsetup.static $MNTIMAGE/bin/dmsetup
inst /sbin/kpartx.static $MNTIMAGE/bin/kpartx
fi
if [ "$use_xdr" == "1" ]; then
inst /sbin/xdrgetuid $MNTIMAGE/bin/xdrgetuid
inst /sbin/xdrgetprio $MNTIMAGE/bin/xdrgetprio
if [ -f /etc/xdrdevices.conf ]; then
inst /etc/xdrdevices.conf $MNTIMAGE/etc/xdrdevices.conf
fi
# ugly hack for starters because the xdr-tools are not static
inst /lib64/libc.so.6 $MNTIMAGE/lib64/libc.so.6
inst /lib/ld64.so.1 $MNTIMAGE/lib/ld64.so.1
fi
if [ "$withdmraid" == "1" ]; then
# Only dmraid is needed to set up dmraid volume
inst /sbin/dmraid.static "$MNTIMAGE/bin/dmraid"
inst /sbin/kpartx.static "$MNTIMAGE/bin/kpartx"
fi
findkeymap () {
local MAP=$1
if [ ! -f "$MAP" ]; then
MAP=$(find /lib/kbd/keymaps -type f -name $MAP -o -name $MAP.\* | head -n1)
fi
case " $KEYMAPS " in
*" $MAP "*)
return
esac
KEYMAPS="$KEYMAPS $MAP"
case $MAP in
*.gz)
cmd=zgrep
;;
*.bz2)
cmd=bzgrep
;;
*)
cmd=grep
;;
esac
for INCL in $($cmd "^include " $MAP | cut -d' ' -f2 | tr -d '"'); do
for FN in $(find /lib/kbd/keymaps -type f -name $INCL\*); do
findkeymap $FN
done
done
}
if [ $ncryptodevs -ne 0 ]; then
inst /sbin/cryptsetup "$MNTIMAGE/sbin/cryptsetup"
KEYTABLE=
KEYMAP=
LOADKEYS=
if [ -f /etc/sysconfig/console/default.kmap ]; then
KEYMAP=/etc/sysconfig/console/default.kmap
else
if [ -f /etc/sysconfig/keyboard ]; then
. /etc/sysconfig/keyboard
fi
if [ -n "$KEYTABLE" -a -d "/lib/kbd/keymaps" ]; then
KEYMAP="$KEYTABLE.map"
fi
fi
if [ -n "$KEYMAP" -a -x /bin/loadkeys.static ]; then
LOADKEYS=loadkeys
if [ -f /etc/sysconfig/i18n ]; then
. /etc/sysconfig/i18n
fi
if [ "${LANG}" != "${LANG%%.UTF-8}" -o "${LANG}" != "${LANG%%.utf8}" ]; then
LOADKEYS="loadkeys -u"
fi
inst /bin/loadkeys.static "$MNTIMAGE/bin/loadkeys"
findkeymap $KEYMAP
for FN in $KEYMAPS; do
inst $FN "$MNTIMAGE$FN"
case "$FN" in
*.gz)
gzip -d "$MNTIMAGE$FN"
;;
*.bz2)
bzip2 -d "$MNTIMAGE$FN"
;;
esac
done
else
vecho "Not including any keymaps"
fi
fi
if [ "$withfips" -eq 1 ]; then
set -e
inst /usr/bin/sha512hmac $MNTIMAGE/bin/sha512hmac
# sha512mac is dynamically linked and uses dlopen-ed .so files,
# this must be this way for libnss fips cert.
libs=$(ldd /usr/bin/sha512hmac | cut -d ' ' -f 3)
ld_linux=$(ldd /usr/bin/sha512hmac | cut -d ' ' -f 1 | grep /lib)
if echo "$libs" | grep -q lib64; then
libdir="lib64"
else
libdir="lib"
fi
libs="$libs $ld_linux"
libs="$libs /usr/$libdir/libsoftokn3.so /usr/$libdir/libsoftokn3.chk"
libs="$libs /usr/$libdir/libfreebl3.so /usr/$libdir/libfreebl3.chk"
for lib in $libs; do
basename=$(basename $lib)
while [ -L $lib ]; do
lib=$(readlink $lib)
done
inst $lib $MNTIMAGE/$libdir/$basename
done
inst /usr/$libdir/hmaccalc/sha512hmac.hmac $MNTIMAGE/usr/$libdir/hmaccalc/sha512hmac.hmac
# rmmod to rmmod tcrypt when we're done with it. Note rmmod is also
# dynmically linked, but sha512hmac already brings in all needed libs
inst /sbin/rmmod $MNTIMAGE/bin/rmmod
set +e
fi
echo -n >| $RCFILE
cemit << EOF
#!/bin/nash
mount -t proc /proc /proc
setquiet
echo Mounting proc filesystem
echo Mounting sysfs filesystem
mount -t sysfs /sys /sys
echo Creating /dev
mount -o mode=0755 -t tmpfs /dev /dev
mkdir /dev/pts
mount -t devpts -o gid=5,mode=620 /dev/pts /dev/pts
mkdir /dev/shm
mkdir /dev/mapper
echo Creating initial device nodes
mknod /dev/null c 1 3
mknod /dev/zero c 1 5
mknod /dev/urandom c 1 9
mknod /dev/systty c 4 0
mknod /dev/tty c 5 0
mknod /dev/console c 5 1
mknod /dev/ptmx c 5 2
mknod /dev/rtc c 10 135
EOF
if [ "$(uname -m)" == "ia64" ]; then
emit "mknod /dev/efirtc c 10 136"
fi
# XXX really we need to openvt too, in case someting changes the
# color palette and then changes vts on fbcon before gettys start.
# (yay, fbcon bugs!)
if ! echo "$(uname -m)" | grep -q "s390"; then
for i in 0 1 2 3 4 5 6 7 8 9 10 11 12 ; do
emit "mknod /dev/tty$i c 4 $i"
done
fi
for i in 0 1 2 3 ; do
emit "mknod /dev/ttyS$i c 4 $(($i + 64))"
done
emit "echo Setting up hotplug."
emit "hotplug"
emit "echo Creating block device nodes."
emit "mkblkdevs"
if [ "$withfips" -eq 1 ]; then
emit_modules $BOOTMODULES
emit "echo Mounting $BOOT and integrity checking the kernel"
emit "mkdir /boot"
if [ "$(uname -m)" == "ia64" ]; then
emit "mkdir /boot/efi"
fi
emit "mount -t $bootfs -o ro $bootdev $BOOT"
emit "sha512hmac -c $HMAC_PATH/.vmlinuz-$kernel.hmac"
emit "cond -ne 0 nash-exit 1"
emit "umount $BOOT"
# We need to load all crypt modules here, as they *all* need to
# have their signature checked before *any* of them may be used
# Also we need to stop booting if any of them fails to load.
emit "echo Loading and integrity checking all crypto modules"
for module in $FIPSMODULES; do
if [ "${module##*/}" != "tcrypt.ko" ]; then
emit "insmod /lib/${module##*/}"
emit "cond -ne 0 nash-exit 1"
fi
done
emit "echo Self testing crypto algorithms"
emit "insmod /lib/tcrypt.ko noexit=1"
emit "cond -ne 0 nash-exit 1"
emit "rmmod tcrypt"
emit "echo All initrd crypto checks done"
fi
emit_modules $MODULES
#if [ -n "$vg_list" ]; then
# emit "echo Making device-mapper control node"
# emit "mkdmnod"
#fi
if [ "$use_multipath" == "1" ]; then
emit "echo Creating multipath devices"
emit "/bin/multipath -v 0"
if [ "$use_xdr" == "1" ]; then
emit "echo Setting up XDR dm device"
emit "/bin/multipath -v 0"
fi
emit "dmsetup ls --target multipath --exec 'kpartx -a -p p'"
fi
if [ "$withdmraid" == "1" ]; then
emit "echo Scanning and configuring dmraid supported devices"
for x in $(/sbin/dmraid.static -s -cr -i 2>/dev/null | \
egrep -iv "^no ") ; do
dmname=$(resolve_dm_name $x)
[ -z "$dmname" ] && continue
emit "dmraid -ay -i -p --rm_partitions \"$dmname\""
emit "kpartx -a -p p \"/dev/mapper/$dmname\""
done
fi
emitcrypto()
{
emit "echo Setting up disk encryption: $1"
emit "cryptsetup luksOpen $1 $2"
}
if [ -n "$KEYMAP" -a -n "$LOADKEYS" ]; then
emit "echo Loading keymap."
emit "$LOADKEYS $KEYMAP"
fi
for cryptdev in ${!cryptopart@} ; do
emitcrypto `eval echo '$'$cryptdev`
done
if [ -n "$raiddevices" ]; then
for dev in $raiddevices; do
cp -a /dev/${dev} $MNTIMAGE/dev
emit "raidautorun /dev/${dev}"
done
fi
for cryptdev in ${!cryptoraid@} ; do
emitcrypto `eval echo '$'$cryptdev`
done
if [ -n "$vg_list" ]; then
emit "echo Scanning logical volumes"
emit "lvm vgscan --ignorelockingfailure"
emit "echo Activating logical volumes"
emit "lvm vgchange -ay --ignorelockingfailure $vg_list"
fi
for cryptdev in ${!cryptolv@} ; do
emitcrypto `eval echo '$'$cryptdev`
done
if [ -z "$noresume" -a -n "$swsuspdev" ]; then
emit "resume $swsuspdev"
fi
if [ -n "$loopfs" ]; then
emit "echo Mounting loop backing store."
emit "mkdir /tmpmount"
emit "mount -t $loopfs -o ${loopopts:-defaults} $loopdev /tmpmount"
emit "echo Creating loop device."
emit "losetup /dev/loop0 /tmpmount/$looppath"
fi
emit "echo Creating root device."
# mkrootdev does "echo /dev/root /sysroot ext3 defaults,ro 0 0 >/etc/fstab"
emit "mkrootdev -t $rootfs -o $rootopts $rootdev"
rootdev=/dev/root
emit "echo Mounting root filesystem."
emit "mount /sysroot"
if [ -n "$loopfs" ]; then
emit "Cleaning up loop mount."
emit "umount /tmpmount"
fi
emit "echo Setting up other filesystems."
emit "setuproot"
for dev in $DHCPDEVS ; do
emit "echo Copying DHCP lease for $dev"
emit "cp /var/lib/dhclient/dhclient-$dev.leases /sysroot/dev/.dhclient-$dev.leases"
done
emit "echo Switching to new root and running init."
emit "switchroot"
chmod +x $RCFILE
(cd $MNTIMAGE; findall . | cpio --quiet -c -o) >| $IMAGE || exit 1
if [ -n "$compress" ]; then
gzip -9 < $IMAGE >| $target || rc=1
else
cp -a $IMAGE $target || rc=1
fi
rm -rf $MNTIMAGE $IMAGE
if [ -n "$MNTPOINT" ]; then rm -rf $MNTPOINT ; fi
exit $rc
# vim:ts=8:sw=4:sts=4:et
|