For a fresh RHEL5.2 install start the installation with the kernel command line "linux mpath"
after first reboot you will need to boot into linux rescue mode from the install disk again because install does not properly create the grub-install
Grub should now be properly setup and you should be able to reboot into your new OS and continue with the mpath configuration
# cp /usr/share/doc/device-mapper-multipath-<version>/multipath.conf.annotated /etc/multipath.conf
# cp /usr/share/doc/device-mapper-multipath-<version>/multipath.conf.defaults /etc/multipath.conf
Search for your local disk UID entry. For example, /dev/sda UID=.......
Edit the /etc/multipath.conf file by uncommenting the necesarry sections/lines of the file.
The default settings for DM-Multipath are compiled in to the system and do not need to be
explicitly set in the /etc/multipath.conf file.
Save the configuration file and exit the editor.
You will see multipathed devices (/dev/mapper/mpath*) as installation devices.
Edit /etc/fstab to use the mpath_links directory for mounting devices properly (where u01 and u02 match the labels you just created above):
Then I simply add a section to my multipath.conf file that looks like the following:
So now, instead of /dev/mapper/3600601606de0220046fe38b57324de11 my dm-multipath device will be called /dev/mapper/rootvg and thus my volumes
Edit lvm.conf, add preferred devices stanza and change filter to reject SAN related /dev/sd* devices. If these are not explicitly ignored, the mkinitrd script has an internal state inconsistency and won't look for a multipath config at all.
# - add the following line immediately below the above line (before the for loop)
# use the wwid that was saved in step (1) Add a line for every disk/wwid noted down in step (2)
THEN - there is a bug in mkinitrd that this will be exposed in RHEL5.2 2.6.18-92.el5, add the following line immediately before line 368:
[ ! -d 'slaves' ] && break or diff the file below against your own mkinitrd to see the changes...
Make the initrd, the hardware handler for the clariion is used by multipath, BUT mkinitrd skips it (this is what I found out with high speed footage).
You can verify your mkinitrd file by copying to /tmp/initfiles or somewhere with a .gz extension and gzip -d the file
cat init and verify that /bin/multipath -v 0 36006016017811900cc8...... line is before the mkrootdev -t ext3 -o defaults,ro /dev/mapper/... line
After all this the details of the boot multipath device will NOT be hidden under the abstracted /dev/root. It will be seen and can be managed as any other multipath or lvm device:
This section gives details on how to move your root and sdev/sd?? to /dev/mappper/mpath??
This procedure is tested on RHEL 5.1. If you are trying on a different wap from /release of RHEL, your mileage may vary.
#!/bin/bash --norc
#
# 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>
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=""
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
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
[ -n "$verbose" ] && echo $NONL "$@"
}
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 <module>]"
$cmd " [--force-ide-probe] [--force-scsi-probe | --omit-scsi-modules]"
$cmd " [--image-version] [--force-raid-probe | --omit-raid-modules]"
$cmd " [--with=<module>] [--force-lvm-probe | --omit-lvm-modules]"
$cmd " [--builtin=<module>] [--net-dev=<interface>]"
$cmd " [--without-usb] [--without-multipath] [--without-dmraid]"
$cmd " [--fstab=<fstab>] [--nocompress] <initrd-image> <kernel-version>"
$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 [ -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 " 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
}
inst() {
if [ "$#" != "2" ];then
echo "usage: inst <file> <destination>"
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}" != "<empty>" ]; 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}" != "<empty>" ]; 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
}
while [ $# -gt 0 ]; do
case $1 in
--fstab*)
if [ "$1" != "${1##--fstab=}" ]; then
fstab=${1##--fstab=}
else
fstab=$2
shift
fi
;;
--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
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
if [[ "$swsuspdev" =~ ^(LABEL=|UUID=) ]]; then
swsuspdev=$(resolve_device_name $swsuspdev)
fi
handlelvordev $swsuspdev
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=1
use_emc=1
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=$(find_mpath_deps ${rd})
[ "$?" == "0" ] && use_emc=1
[ -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 rootdev in ${rootdevs} ; do
disk=$(find_dm_in_sysblock ${rootdev} | 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
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 $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
cp $verbose --parents /etc/lvm/lvm.conf $MNTIMAGE/
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
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/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"
usb_mounted="prep"
scsi=""
for MODULE in $MODULES; 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 <<EOF
echo -n $WWPN > /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"
#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 -ay -i -p -t 2>/dev/null | \
egrep -iv "^no " | awk -F ':' '{ print $1 }') ; do
dmname=$(resolve_dm_name $x)
[ -z "$dmname" ] && continue
emit "dmraid -ay -i -p \"$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
Posts
