#!/bin/sh . /etc/initrd.defaults . /etc/initrd.d/00-splash.sh . /etc/initrd.d/00-common.sh . /etc/initrd.d/00-fsdev.sh . /etc/initrd.d/00-devmgr.sh . /etc/initrd.d/00-zfs.sh modules_load() { for module in $* do echo ${module} >> /etc/modules/extra_load done modules_scan extra_load } modules_scan() { local MODS local loaded MODS=$(cat /etc/modules/${1} 2>/dev/null) [ -n "${MODS}" ] && [ -z "${QUIET}" ] && \ echo -ne "${BOLD} ::${NORMAL} Loading from ${1}: " for x in ${MODS} do MLOAD=$(echo ${MLIST} | sed -e "s/.*${x}.*/${x}/") if [ "${MLOAD}" = "${x}" ] # Only module to no-load then [ -z "${QUIET}" ] && \ echo -e "${BOLD} ::${NORMAL} Skipping ${x}..." elif [ "${MLOAD}" = "${MLIST}" ] then if [ -n "${DEBUG}" ]; then echo -ne "${BOLD} ::${NORMAL} " echo -ne "Scanning for ${x}..." fi modprobe ${x} > /dev/null 2>&1 loaded=${?} [ -n "${DEBUG}" -a "${loaded}" = "0" ] && \ echo "loaded" [ -n "${DEBUG}" -a "${loaded}" != "0" ] && \ echo "not loaded" [ -z "${DEBUG}" -a "${loaded}" = "0" ] && \ [ -z "${QUIET}" ] && \ echo -en "${x} " else [ -z "${QUIET}" ] && \ echo -e "${BOLD} ::${NORMAL} Skipping ${x}..." fi done [ -n "${MODS}" ] && [ -z "${QUIET}" ] && echo } modules_init() { if [ -z "${DO_modules}" ]; then good_msg 'Skipping module load; disabled via commandline' elif [ -d "/lib/modules/${KV}" ]; then good_msg 'Loading modules' # Load appropriate kernel modules if [ "${NODETECT}" != '1' ]; then for modules in ${MY_HWOPTS} do modules_scan ${modules} done fi # Always eval doload=... modules_load ${MDOLIST} else good_msg 'Skipping module load; no modules in the ramdisk!' fi # Give udev time to execute all the rules. This may be beneficial # for usb-storage devices. is_udev && udevadm settle } uppercase() { # needs tr on busybox echo ${1} | tr 'a-z' 'A-Z' } real_root_init() { if [ -z "${REAL_ROOT}" ] && [ "${FAKE_ROOT}" != "/dev/ram0" ]; then REAL_ROOT="${FAKE_ROOT}" fi if [ -z "${REAL_INIT}" ] && [ "${FAKE_INIT}" != "/linuxrc" ]; then REAL_INIT="${FAKE_INIT}" fi if [ -z "${REAL_ROOTFLAGS}" ]; then REAL_ROOTFLAGS="${FAKE_ROOTFLAGS}" fi # let zfs code setup its parameters zfs_real_root_init } findmediamount() { # $1 = mount dir name / media name # $2 = recognition file # $3 = variable to have the device path # $4 = actual mount dir path (full path) # args remaining are possible devices local media=$1 recon=$2 vrbl=$3 mntdir=$4 shift 4 good_msg "Looking for the ${media}" ${CRYPT_SILENT} if [ "$#" -gt "0" ] then [ ! -d "${mntdir}" ] && mkdir -p ${mntdir} 2>/dev/null >/dev/null if [ -n "${ISOBOOT}" ] then mntcddir="${mntdir%${media}}iso" if [ ! -f ${mntcddir} ] then mkdir ${mntcddir} fi else mntcddir=${mntdir} fi for x in $* do # Check for a block device to mount if [ -b "${x}" ] then skip=0 bsn=$(basename "${x}") # # If disk and it has at least one partition, skip. # We use /sys/block/${bsn}/${bsn}[0-9]* to make sure that we # don't skip device mapper devices. Even the craziest scenario # deserves a fair chance. # for part in $(ls /sys/block/${bsn}/${bsn}*[0-9]* 2>/dev/null) do skip=1 break; done if [ ${skip} -eq 1 ] then continue fi good_msg "Attempting to mount media: ${x}" ${CRYPT_SILENT} mount -r -t ${CDROOT_TYPE} ${x} ${mntcddir} >/dev/null 2>&1 if [ "$?" = '0' ] then if [ -n "${ISOBOOT}" ]; then if [ -f ${mntcddir}/${ISOBOOT} ]; then mount -o loop ${mntcddir}/${ISOBOOT} ${mntdir} if [ "$?" = "0" ]; then good_msg "iso mounted on ${mntdir}" fi fi fi # Check for the media if [ -f "${mntdir}/${recon}" ] then #set REAL_ROOT, CRYPT_ROOT_KEYDEV or whatever ${vrbl} is eval ${vrbl}'='"${x}" good_msg "Media found on ${x}" ${CRYPT_SILENT} break else umount ${mntcddir} fi fi fi done fi eval local result='$'${vrbl} [ -n "${result}" ] || bad_msg "Media not found" ${CRYPT_SILENT} } devicelist() { # Locate the cdrom device with our media on it. # CDROM DEVICES local DEVICES="/dev/cdroms/* /dev/ide/cd/* /dev/sr*" # USB Keychain/Storage DEVICES="$DEVICES /dev/sd*" # IDE devices DEVICES="$DEVICES /dev/hd*" # virtio devices DEVICES="$DEVICES /dev/vd*" # USB using the USB Block Driver DEVICES="$DEVICES /dev/ubd* /dev/ubd/*" # iSeries devices DEVICES="$DEVICES /dev/iseries/vcd*" # builtin mmc/sd card reader devices DEVICES="$DEVICES /dev/mmcblk* /dev/mmcblk*/*" # fallback scanning, this might scan something twice, but it's better than # failing to boot. local parts=$(awk '/([0-9]+[[:space:]]+)/{print "/dev/" $4}' \ /proc/partitions) [ -e /proc/partitions ] && DEVICES="${DEVICES} ${parts}" echo ${DEVICES} } bootstrap_cd() { local DEVICES= # The device was specified on the command line, so there's no need # to scan a bunch of extra devices [ -n "${CDROOT_DEV}" ] && DEVICES="${CDROOT_DEV}" [ -z "${CDROOT_DEV}" ] && DEVICES=$(devicelist) findmediamount "cdrom" "${SUBDIR}/${CDROOT_MARKER}" \ "REAL_ROOT" "${CDROOT_PATH}" ${DEVICES} } bootstrap_key() { # $1 = ROOT/SWAP local KEYDEVS=$(devicelist) eval local keyloc='"${CRYPT_'${1}'_KEY}"' findmediamount "key" "${keyloc}" "CRYPT_${1}_KEYDEV" "/mnt/key" ${KEYDEVS} } cache_cd_contents() { # Check loop file exists and cache to ramdisk if DO_cache is enabled if [ "${LOOPTYPE}" != "noloop" ] && [ "${LOOPTYPE}" != "sgimips" ] then check_loop if [ "${DO_cache}" ] then # TODO: Check the size of the image versus the size of our tmpfs # along with the amount of available RAM and increase tmpfs size # if necessary. (Not having awk sucks...) # z=0 # for i in $(cat /proc/meminfo | grep -e ^MemFree -e ^Cached | \ # cut -d: -f2 | cut -dk -f1 | sed -e "s/^\s*//") ; do # z=$(($z + $i)) ; done # echo $z good_msg "Copying loop file for caching..." # Verify that the needed directory exists mkdir -p "$(dirname ${NEW_ROOT}/mnt/${LOOP})" cp -a ${CDROOT_PATH}/${LOOP} ${NEW_ROOT}/mnt/${LOOP} if [ $? -ne 0 ] then warn_msg "Failed to cache the loop file! Lack of RAM?" rm -rf ${NEW_ROOT}/mnt/${LOOP} 2>/dev/null rm -rf ${NEW_ROOT}/mnt/livecd.* 2>/dev/null rm -rf ${NEW_ROOT}/mnt/image.* 2>/dev/null rm -rf ${NEW_ROOT}/mnt/zisofs 2>/dev/null fi fi fi } mount_sysfs() { mount -t sysfs sysfs /sys -o noexec,nosuid,nodev >/dev/null 2>&1 ret=$? [ ${ret} -eq 0 ] || bad_msg "Failed to mount /sys!" } find_nfs() { if [ -z "${IP}" ]; then # IP is not set, return straight away return 1 fi if ! busybox udhcpc -n -T 15 -q; then bad_msg "udhcpc returned error, skipping nfs setup..." return 1 fi local options= [ -e /rootpath ] && NFSROOT=$(cat /rootpath) if [ -z "${NFSROOT}" ]; then # Obtain NFSIP # TODO: this is bogus, because dmesg is a circular buffer... # TODO: provide dmesg as symlink (see gen_initramfs.sh) options=$(busybox dmesg | grep rootserver | sed -e "s/,/ /g") local opt= optn= for opt in ${options}; do optn=$(echo $opt | sed -e "s/=/ /g" | cut -d " " -f 1) if [ "${optn}" = "rootserver" ]; then NFSIP=$(echo $opt | sed -e "s/=/ /g" | cut -d " " -f 2) fi done # Obtain NFSPATH # TODO: this is bogus, because dmesg is a circular buffer... # TODO: provide dmesg as symlink (see gen_initramfs.sh) options=$(busybox dmesg | grep rootpath | sed -e "s/,/ /g") for opt in ${options}; do optn=$(echo $opt | sed -e "s/=/ /g" | cut -d " " -f 1) if [ "${optn}" = "rootpath" ]; then NFSPATH=$(echo $opt | sed -e "s/=/ /g" | cut -d " " -f 2) fi done # Setup NFSROOT if [ -n "${NFSIP}" ] && [ -n "$NFSPATH" ]; then NFSROOT="${NFSIP}:${NFSPATH}" else bad_msg "The DHCP Server did not send a valid root-path." bad_msg "Please check your DHCP setup, or set nfsroot=<...>" return 1 fi fi # expecting a valid NFSROOT here, or the code should have returned NFSOPTIONS=${NFSROOT#*,} NFSROOT=${NFSROOT%%,*} if [ "${NFSOPTIONS}" = "${NFSROOT}" ]; then NFSOPTIONS="${DEFAULT_NFSOPTIONS}" else NFSOPTIONS="${DEFAULT_NFSOPTIONS},${NFSOPTIONS}" fi local path= # override path if on livecd if is_livecd; then path="${CDROOT_PATH}" good_msg "Attempting to mount NFS CD image on ${NFSROOT}." else path="${NEW_ROOT}" good_msg "Attempting to mount NFS root on ${NFSROOT}." fi good_msg "NFS options: ${NFSOPTIONS}" mount -t nfs -o ${NFSOPTIONS} "${NFSROOT}" "${path}" if [ "${?}" = "0" ]; then REAL_ROOT="/dev/nfs" return 0 else bad_msg "NFS Mounting failed. Is the path corrent ?" return 1 fi } check_loop() { if [ -z "${LOOP}" ] || [ ! -e "${CDROOT_PATH}/${LOOP}" ]; then bad_msg "Invalid loop location: ${LOOP}" bad_msg "Please export LOOP with a valid location" bad_msg "or reboot and pass a proper loop=..." bad_msg "kernel command line" run_shell fi } run_shell() { /bin/ash } test_success() { retcode=$? # If last command failed send error message and fall back to a shell if [ "$retcode" != '0' ] then error_string=$1 error_string="${error_string:-run command}" bad_msg 'Failed to $1; failing back to the shell...' run_shell fi } # Courtesy of dracut. Licensed under GPL-2. # Taken from: dracut/modules.d/90crypt/crypt-lib.sh # ask_for_password # # Wraps around plymouth ask-for-password and adds fallback to tty password ask # if plymouth is not present. # # --cmd command # Command to execute. Required. # --prompt prompt # Password prompt. Note that function already adds ':' at the end. # Recommended. # --tries n # How many times repeat command on its failure. Default is 3. # --ply-[cmd|prompt|tries] # Command/prompt/tries specific for plymouth password ask only. # --tty-[cmd|prompt|tries] # Command/prompt/tries specific for tty password ask only. # --tty-echo-off # Turn off input echo before tty command is executed and turn on after. # It's useful when password is read from stdin. ask_for_password() { local cmd; local prompt; local tries=3 local ply_cmd; local ply_prompt; local ply_tries=3 local tty_cmd; local tty_prompt; local tty_tries=3 local ret while [ $# -gt 0 ]; do case "$1" in --cmd) ply_cmd="$2"; tty_cmd="$2" shift;; --ply-cmd) ply_cmd="$2"; shift;; --tty-cmd) tty_cmd="$2"; shift;; --prompt) ply_prompt="$2"; tty_prompt="$2" shift;; --ply-prompt) ply_prompt="$2"; shift;; --tty-prompt) tty_prompt="$2"; shift;; --tries) ply_tries="$2"; tty_tries="$2"; shift;; --ply-tries) ply_tries="$2"; shift;; --tty-tries) tty_tries="$2"; shift;; --tty-echo-off) tty_echo_off=yes;; esac shift done { flock -s 9; # Prompt for password with plymouth, if installed and running. if is_plymouth_started then "${PLYMOUTH_BIN}" ask-for-password \ --prompt="$ply_prompt" \ --number-of-tries=$ply_tries \ --command="$ply_cmd" ret=$? else splashcmd verbose if [ "$tty_echo_off" = yes ]; then stty_orig="$(stty -g)" stty -echo fi local i=1 while [ $i -le $tty_tries ]; do [ -n "$tty_prompt" ] && \ printf "$tty_prompt [$i/$tty_tries]:" >&2 eval "$tty_cmd" && ret=0 && break ret=$? i=$(($i+1)) [ -n "$tty_prompt" ] && printf '\n' >&2 done [ "$tty_echo_off" = yes ] && stty $stty_orig # no need for: splashcmd quiet # since fbsplash does not support it if [ $ret -ne 0 ] && is_fbsplash then splashcmd set_msg 'Disk unlocked.' fi fi } 9>/.console_lock [ $ret -ne 0 ] && bad_msg "Wrong password" return $ret } crypt_exec() { if [ "${CRYPT_SILENT}" = '1' ] then eval ${1} >/dev/null 2>/dev/null else ask_for_password --ply-tries 5 \ --ply-cmd "${1}" \ --ply-prompt "Encryption password (${LUKS_DEVICE}): " \ --tty-tries 5 \ --tty-cmd "${1}" || return 1 return 0 fi } prompt_user() { # $1 = variable whose value is the path (examples: "REAL_ROOT", # "LUKS_KEYDEV") # $2 = label # $3 = optional explanations for failure eval local oldvalue='$'${1} [ $# != 2 -a $# != 3 ] && \ bad_msg "Bad invocation of function prompt_user." bad_msg "Please file a bug report with this message" && exit 1 [ -n "${3}" ] && local explnt=" or : ${3}" || local explnt="." splashcmd verbose bad_msg "Could not find the ${2} in ${oldvalue}${explnt}" bad_msg "Please specify another value or:" bad_msg "- press Enter for the same" bad_msg '- type "shell" for a shell' bad_msg '- type "q" to skip...' echo -n "${2}(${oldvalue}) :: " read ${1} case $(eval echo '$'${1}) in 'q') eval ${1}'='${oldvalue} warn_msg "Skipping step, this will likely cause a boot failure." break ;; 'shell') eval ${1}'='${oldvalue} warn_msg "To leave and try again just press +D" run_shell ;; '') eval ${1}'='${oldvalue} ;; esac splashcmd quiet } cmdline_hwopts() { # Scan CMDLINE for any "doscsi" or "noscsi"-type arguments local FOUND local TMP_HWOPTS for x in $HWOPTS do for y in $CMDLINE do if [ "${y}" = "do${x}" ] then MY_HWOPTS="${MY_HWOPTS} $x" elif [ "${y}" = "no${x}" ] then MY_HWOPTS="$(echo ${MY_HWOPTS} | sed -e \"s/${x}//g\" -)" fi if [ "$(echo ${y} | cut -b -7)" = "keymap=" ] then MY_HWOPTS="${MY_HWOPTS} keymap" fi done done # Shouldnt need to sort this as the following loop should figure out the # duplicates and strip them out #MY_HWOPTS=$(echo ${MY_HWOPTS}| sort) for x in ${MY_HWOPTS} do FOUND=0 for y in ${TMP_HWOPTS} do if [ "${y}" = "${x}" ] then continue 2 fi done TMP_HWOPTS="${TMP_HWOPTS} ${x}" eval DO_$(echo ${x} | sed 's/-//')=1 done MY_HWOPTS=${TMP_HWOPTS} } load_modules() { # Load modules listed in MY_HWOPTS if /lib/modules exists for the running # kernel version if [ -d "/lib/modules/${KV}" ] then good_msg 'Loading modules' # Load appropriate kernel modules for modules in $MY_HWOPTS do modules_scan $modules done else good_msg 'Skipping module load; no modules in the ramdisk!' fi } setup_keymap() { if [ "${DO_keymap}" ] then if [ ! -e /dev/vc/0 -a ! -e /dev/tty0 ] then DEVBIND=1 mount -o bind ${NEW_ROOT}/dev /dev fi [ ! -e /dev/tty0 ] && ln -s /dev/tty1 /dev/tty0 [ -f /lib/keymaps/keymapList ] && choose_keymap [ "${DEVBIND}" = '1' ] && umount /dev if [ -e /etc/sysconfig/keyboard ] && is_livecd then mkdir -p ${NEW_ROOT}/etc/sysconfig/ cp /etc/sysconfig/keyboard ${NEW_ROOT}/etc/sysconfig/keyboard fi fi } choose_keymap() { good_msg "Loading keymaps" if [ -z "${keymap}" ] then splashcmd verbose cat /lib/keymaps/keymapList read -t 10 -p '<< Load keymap (Enter for default): ' keymap case ${keymap} in 1|azerty) keymap=azerty ;; 2|be) keymap=be ;; 3|bg) keymap=bg ;; 4|br-a) keymap=br-a ;; 5|br-l) keymap=br-l ;; 6|by) keymap=by ;; 7|cf) keymap=cf ;; 8|croat) keymap=croat ;; 9|cz) keymap=cz ;; 10|de) keymap=de ;; 11|dk) keymap=dk ;; 12|dvorak) keymap=dvorak ;; 13|es) keymap=es ;; 14|et) keymap=et ;; 15|fi) keymap=fi ;; 16|fr) keymap=fr ;; 17|gr) keymap=gr ;; 18|hu) keymap=hu ;; 19|il) keymap=il ;; 20|is) keymap=is ;; 21|it) keymap=it ;; 22|jp) keymap=jp ;; 23|la) keymap=la ;; 24|lt) keymap=lt ;; 25|mk) keymap=mk ;; 26|nl) keymap=nl ;; 27|no) keymap=no ;; 28|pl) keymap=pl ;; 29|pt) keymap=pt ;; 30|ro) keymap=ro ;; 31|ru) keymap=ru ;; 32|se) keymap=se ;; 33|sg) keymap=sg ;; 34|sk-y) keymap=sk-y ;; 35|sk-z) keymap=sk-z ;; 36|slovene) keymap=slovene ;; 37|trf) keymap=trf ;; 38|trq) keymap=trq ;; 39|ua) keymap=ua ;; 40|uk) keymap=uk ;; 41|us) keymap=us ;; 42|wangbe) keymap=wangbe ;; 43|sf|ch*) keymap=sf ;; esac fi if [ -e /lib/keymaps/${keymap}.map ] then good_msg "Loading the ''${keymap}'' keymap" loadkmap < /lib/keymaps/${keymap}.map mkdir -p /etc/sysconfig echo "XKEYBOARD=${keymap}" > /etc/sysconfig/keyboard splashcmd set_msg "Set keymap to ${keymap}" elif [ -z "${keymap}" ] then good_msg good_msg "Keeping default keymap" splashcmd set_msg "Keeping default keymap" else bad_msg "Sorry, but keymap ''${keymap}'' is invalid!" unset keymap choose_keymap fi } start_volumes() { # Here, we check for /dev/device-mapper, and if it exists, we setup a # a symlink, which should hopefully fix bug #142775 and bug #147015 if [ -e /dev/device-mapper ] && [ ! -e /dev/mapper/control ]; then mkdir -p /dev/mapper ln -sf /dev/device-mapper /dev/mapper/control fi if [ "${USE_MDADM}" = "1" ]; then if [ -e "/sbin/mdadm" ]; then /sbin/mdadm --assemble --scan else bad_msg "mdadm not found: skipping mdadm raid assembly!" fi fi if [ "${USE_MULTIPATH_NORMAL}" = "1" ]; then good_msg "Scanning for multipath devices" /sbin/multipath -v 0 # TODO(lxnay): horrible sleep! sleep 2 good_msg "Activating multipath devices" /sbin/dmsetup ls --target multipath --exec "/sbin/kpartx -a -v" fi if [ "${USE_DMRAID_NORMAL}" = "1" ]; then if [ -e "/sbin/dmraid" ]; then good_msg "Activating Device-Mapper RAID(s)" /sbin/dmraid -ay ${DMRAID_OPTS} else bad_msg "/sbin/dmraid not found" fi fi if [ "${USE_LVM_NORMAL}" = "1" ]; then if [ -e "/sbin/lvm" ]; then if is_mdev; then for dev in ${RAID_DEVICES}; do setup_md_device "${dev}" done fi # This is needed for /sbin/lvm to accept the following logic local cmds="#! /sbin/lvm" # If there is a cahe, update it. Unbreak at least dmcrypt [ -d /etc/lvm/cache ] && cmds="${cmds} \nvgscan" # To activate volumegroups on all devices in the cache cmds="${cmds} \nvgchange -ay --sysinit" if is_mdev; then # To create symlinks so users can use # real_root=/dev/vg/root # This needs to run after vgchange, using # vgchange --mknodes is too early. cmds+="${cmds} \nvgmknodes --ignorelockingfailure" fi # And finally execute it all (/proc/... needed if lvm # is compiled without readline) good_msg "Scanning for and activating Volume Groups" printf "%b\n" "${cmds}" | /sbin/lvm /proc/self/fd/0 else bad_msg "/sbin/lvm not found: skipping LVM activation" fi fi # If zfs is enabled, this will initialize the volumes zfs_start_volumes is_udev && udevadm settle } start_iscsi() { if [ ! -e /usr/sbin/iscsistart ]; then return 0 # disabled fi if [ ! -n "${ISCSI_NOIBFT}" ] then good_msg "Activating iSCSI via iBFT" iscsistart -b fi if [ -n "${ISCSI_INITIATORNAME}" ] && [ -n "${ISCSI_TARGET}" ] && [ -n "${ISCSI_ADDRESS}" ]; then good_msg "Activating iSCSI via cmdline" if [ "${ISCSI_TGPT}" ] then ADDITIONAL="${ADDITIONAL} -g ${ISCSI_TGPT}" else ADDITIONAL="${ADDITIONAL} -g 1" fi if [ "${ISCSI_PORT}" ] then ADDITIONAL="${ADDITIONAL} -p ${ISCSI_PORT}" fi if [ "${ISCSI_USERNAME}" ] then ADDITIONAL="${ADDITIONAL} -u ${ISCSI_USERNAME}" fi if [ "${ISCSI_PASSWORD}" ] then ADDITIONAL="${ADDITIONAL} -w ${ISCSI_PASSWORD}" fi if [ "${ISCSI_USERNAME_IN}" ] then ADDITIONAL="${ADDITIONAL} -U ${ISCSI_USERNAME_IN}" fi if [ "${ISCSI_PASSWORD_IN}" ] then ADDITIONAL="${ADDITIONAL} -W ${ISCSI_PASSWORD_IN}" fi if [ "${ISCSI_DEBUG}" ] then ADDITIONAL="${ADDITIONAL} -d ${ISCSI_DEBUG}" fi iscsistart -i "${ISCSI_INITIATORNAME}" -t "${ISCSI_TARGET}" \ -a "${ISCSI_ADDRESS}" ${ADDITIONAL} # let iscsid settle - otherwise mounting the iSCSI-disk # will fail (very rarely, though) sleep 1 fi } # Open a LUKS device # It is either the root or a swap, other devices are supported in the scripts provided with sys-fs/cryptsetup-luks # $1 - root/swap open_luks() { # TODO(lxnay): what has been seen, cannot be unseen. # TODO(lxnay): there is so much wrong in this function... # please use 'tr' and this line, or remove it # eval local TYPE=$(uppercase $1) case $1 in root) local TYPE=ROOT ;; swap) local TYPE=SWAP ;; esac eval local LUKS_DEVICE='"${CRYPT_'${TYPE}'}"' LUKS_NAME="$1" LUKS_KEY='"${CRYPT_'${TYPE}'_KEY}"' LUKS_KEYDEV='"${CRYPT_'${TYPE}'_KEYDEV}"' LUKS_TRIM='"${CRYPT_'${TYPE}'_TRIM}"' local DEV_ERROR=0 KEY_ERROR=0 KEYDEV_ERROR=0 local mntkey="/mnt/key/" cryptsetup_options='' [ ! -e /sbin/cryptsetup ] && bad_msg "The ramdisk does not support LUKS" && exit 1 while [ 1 ] do local gpg_cmd="" # if crypt_silent=1 and some error occurs, enter shell quietly if [ \( ${CRYPT_SILENT} -eq 1 \) -a \( \( \( ${DEV_ERROR} -eq 1 \) -o \( ${KEY_ERROR} -eq 1 \) \) -o \( ${KEYDEV_ERROR} -eq 1 \) \) ] then run_shell elif [ ${DEV_ERROR} -eq 1 ] then prompt_user "LUKS_DEVICE" "${LUKS_NAME}" DEV_ERROR=0 elif [ ${KEY_ERROR} -eq 1 ] then prompt_user "LUKS_KEY" "${LUKS_NAME} key" KEY_ERROR=0 elif [ ${KEYDEV_ERROR} -eq 1 ] then prompt_user "LUKS_KEYDEV" "${LUKS_NAME} key device" KEYDEV_ERROR=0 else local luks_dev=$(find_real_device "${LUKS_DEVICE}") [ -n "${luks_dev}" ] && LUKS_DEVICE="${luks_dev}" # otherwise hope... setup_md_device "${LUKS_DEVICE}" /sbin/cryptsetup isLuks "${LUKS_DEVICE}" if [ $? -ne 0 ] then bad_msg "The LUKS device ${LUKS_DEVICE} does not contain a LUKS header" ${CRYPT_SILENT} DEV_ERROR=1 continue else # Handle keys if [ "x${LUKS_TRIM}" = "xyes" ] then good_msg "Enabling TRIM support for ${LUKS_NAME}." ${CRYPT_SILENT} cryptsetup_options="${cryptsetup_options} --allow-discards" fi if [ -n "${LUKS_KEY}" ] then local REAL_LUKS_KEYDEV="${LUKS_KEYDEV}" if [ ! -e "${mntkey}${LUKS_KEY}" ] then REAL_LUKS_KEYDEV=$(find_real_device "${LUKS_KEYDEV}") if [ -b "${REAL_LUKS_KEYDEV}" ] && [ -n "${REAL_LUKS_KEYDEV}" ] then good_msg "Using key device ${REAL_LUKS_KEYDEV}." ${CRYPT_SILENT} else good_msg "Please insert removable device ${LUKS_KEYDEV} for ${LUKS_NAME}" ${CRYPT_SILENT} # abort after 10 secs local count=10 while [ ${count} -gt 0 ] do count=$((count-1)) sleep 1 REAL_LUKS_KEYDEV=$(find_real_device "${LUKS_KEYDEV}") if [ -b "${REAL_LUKS_KEYDEV}" ] && [ -n "${REAL_LUKS_KEYDEV}" ] then good_msg "Removable device ${REAL_LUKS_KEYDEV} detected." ${CRYPT_SILENT} break fi done if [ ! -b "${REAL_LUKS_KEYDEV}" ] then eval CRYPT_${TYPE}_KEY=${LUKS_KEY} bootstrap_key ${TYPE} eval LUKS_KEYDEV='"${CRYPT_'${TYPE}'_KEYDEV}"' REAL_LUKS_KEYDEV=$(find_real_device "${LUKS_KEYDEV}") if [ ! -b "${REAL_LUKS_KEYDEV}" ]; then KEYDEV_ERROR=1 bad_msg "Removable device ${LUKS_KEYDEV} not found." ${CRYPT_SILENT} continue fi # continue otherwise will mount keydev which is mounted by bootstrap continue fi fi # At this point a device was recognized, now let's see if the key is there [ ! -d "$mntkey" ] && mkdir -p ${mntkey} 2>/dev/null >/dev/null mount -n -o ro ${REAL_LUKS_KEYDEV} ${mntkey} >/dev/null 2>/dev/null if [ "$?" != '0' ] then KEYDEV_ERROR=1 bad_msg "Mounting of device ${REAL_LUKS_KEYDEV} failed." ${CRYPT_SILENT} continue else good_msg "Removable device ${REAL_LUKS_KEYDEV} mounted." ${CRYPT_SILENT} sleep 2 # keyfile exists? if [ ! -e "${mntkey}${LUKS_KEY}" ]; then umount -n ${mntkey} 2>/dev/null >/dev/null KEY_ERROR=1 KEYDEV_ERROR=1 bad_msg "Key {LUKS_KEY} on device ${REAL_LUKS_KEYDEV} not found." ${CRYPT_SILENT} continue fi fi fi # At this point a candidate key exists (either mounted before or not) good_msg "${LUKS_KEY} on device ${REAL_LUKS_KEYDEV} found" ${CRYPT_SILENT} if [ "$(echo ${LUKS_KEY} | grep -o '.gpg$')" = ".gpg" ] && [ -e /usr/bin/gpg ] ; then [ -e /dev/tty ] && mv /dev/tty /dev/tty.org mknod /dev/tty c 5 1 cryptsetup_options="${cryptsetup_options} -d -" gpg_cmd="/usr/bin/gpg --logger-file /dev/null --quiet --decrypt ${mntkey}${LUKS_KEY} |" else cryptsetup_options="${cryptsetup_options} -d ${mntkey}${LUKS_KEY}" fi fi # At this point, keyfile or not, we're ready! crypt_exec "${gpg_cmd}/sbin/cryptsetup ${cryptsetup_options} luksOpen ${LUKS_DEVICE} ${LUKS_NAME}" crypt_exec_ret=$? [ -e /dev/tty.org ] \ && rm -f /dev/tty \ && mv /dev/tty.org /dev/tty if [ ${crypt_exec_ret} -eq 0 ] then good_msg "LUKS device ${LUKS_DEVICE} opened" ${CRYPT_SILENT} break else bad_msg "Failed to open LUKS device ${LUKS_DEVICE}" ${CRYPT_SILENT} DEV_ERROR=1 KEY_ERROR=1 KEYDEV_ERROR=1 fi fi fi done umount ${mntkey} 2>/dev/null >/dev/null rmdir -p ${mntkey} 2>/dev/null >/dev/null } start_luks() { # if key is set but key device isn't, find it [ -n "${CRYPT_ROOT_KEY}" ] && [ -z "${CRYPT_ROOT_KEYDEV}" ] \ && sleep 6 && bootstrap_key "ROOT" if [ -n "${CRYPT_ROOT}" ]; then open_luks "root" if [ -n "${REAL_ROOT}" ] then # Rescan volumes start_volumes else REAL_ROOT="/dev/mapper/root" fi fi # TODO(lxnay): this sleep 6 thing is hurting my eyes sooooo much. # same for swap, but no need to sleep if root was unencrypted [ -n "${CRYPT_SWAP_KEY}" ] && [ -z "${CRYPT_SWAP_KEYDEV}" ] \ && { [ -z "${CRYPT_ROOT}" ] && sleep 6; bootstrap_key "SWAP"; } if [ -n "${CRYPT_SWAP}" ]; then open_luks "swap" if [ -z "${REAL_RESUME}" ] then # Resume from swap as default REAL_RESUME="/dev/mapper/swap" fi fi } sdelay() { # Sleep a specific number of seconds if SDELAY is set if [ -n "${SDELAY}" ] then good_msg "Waiting ${SDELAY} seconds..." sleep ${SDELAY} elif is_livecd then good_msg 'Hint: Use scandelay[=seconds] if your live medium is slowand boot fails' fi } quiet_kmsg() { # if QUIET is set make the kernel less chatty [ -n "$QUIET" ] && echo '0' > /proc/sys/kernel/printk } verbose_kmsg() { # if QUIET is set make the kernel less chatty [ -n "$QUIET" ] && echo '6' > /proc/sys/kernel/printk } cdupdate() { if is_livecd then if [ -x /${CDROOT_PATH}/cdupdate.sh ] then good_msg "Running cdupdate.sh" ${CDROOT_PATH}/cdupdate.sh if [ "$?" != '0' ] then bad_msg "Executing cdupdate.sh failed!" run_shell fi else good_msg 'No cdupdate.sh script found, skipping...' fi fi } setup_md_device() { local device [ -z "$1" ] && device="${REAL_ROOT}" || device="$1" [ -z "${device}" ] && return # LiveCD if [ $(echo ${device}|sed -e 's#\(luks:\)\?\(/dev/md\)[[:digit:]]\+#\2#') = "/dev/md" ] then good_msg 'Detected real_root as a md device. Setting up the device node...' MD_NUMBER=$(echo ${device}|sed -e 's#\(luks:\)\?/dev/md\([[:digit:]]\+\)#\2#') if [ ! -e /dev/md${MD_NUMBER} ] then mknod /dev/md${MD_NUMBER} b 9 ${MD_NUMBER} >/dev/null 2>&1 [ $? -ne 0 ] && bad_msg "Creation of /dev/md${MD_NUMBER} failed..." fi mdstart ${MDPART} /dev/md${MD_NUMBER} fi } do_rundebugshell() { splashcmd verbose good_msg 'Type "exit" to continue with normal bootup.' [ -x /bin/sh ] && /bin/sh || /bin/ash splashcmd quiet } rundebugshell() { if [ -n "$DEBUG" ] then good_msg 'Starting debug shell as requested by "debug" option.' good_msg "Stopping by: ${1}" do_rundebugshell fi } resume_init() { if [ -z "${REAL_RESUME}" ]; then return 0 fi if [ "${NORESUME}" = "1" ]; then return 0 fi local resume_dev=$(find_real_device "${REAL_RESUME}") if [ -n "${resume_dev}" ]; then REAL_RESUME="${resume_dev}" good_msg "Detected real_resume=${resume_dev}" else bad_msg "Cannot resolve real_resume=${REAL_RESUME}" bad_msg "Something bad may happen, crossing fingers" fi swsusp_resume } swsusp_resume() { # determine swap resume partition local device=$(ls -lL "${REAL_RESUME}" | sed 's/\ */ /g' | \ cut -d \ -f 5-6 | sed 's/,\ */:/') [ -f /sys/power/resume -a -n "${device}" ] && \ echo "${device}" > /sys/power/resume } find_loop() { for loop in ${LOOPS} do if [ -e "${CDROOT_PATH}""${loop}" ] then LOOP="${loop}" fi done } find_looptype() { LOOPTYPE="${LOOP##*.}" [ "${LOOPTYPE}" == "loop" ] && LOOPTYPE="normal" [ "${LOOP}" == "/zisofs" ] && LOOPTYPE="${LOOP#/}" [ -z "${LOOPTYPE}" ] && LOOPTYPE="noloop" } getdvhoff() { echo $(( $(hexdump -n 4 -s $((316 + 12 * $2)) -e '"%i"' $1) * 512)) } setup_squashfs_aufs() { # Setup aufs directories and vars local overlay=/mnt/overlay local static=/mnt/livecd for i in "${overlay}" "${static}"; do [ ! -d "${i}" ] && mkdir -p "${i}" done good_msg "Loading aufs" modprobe aufs > /dev/null 2>&1 mount -t squashfs -o loop,ro "${CDROOT_PATH}/${LOOPEXT}${LOOP}" "${static}" mount -t tmpfs none "${overlay}" mount -t aufs -o br:${overlay}:${static} aufs "${NEW_ROOT}" [ ! -d "${NEW_ROOT}${overlay}" ] && mkdir -p "${NEW_ROOT}${overlay}" [ ! -d "${NEW_ROOT}${static}" ] && mkdir -p "${NEW_ROOT}${static}" echo "aufs / aufs defaults 0 0" > "${NEW_ROOT}"/etc/fstab for i in "${overlay}" "${static}"; do mount --move "${i}" "${NEW_ROOT}${i}" done # have handy /mnt/cdrom (CDROOT_PATH) as well local new_cdroot="${NEW_ROOT}${CDROOT_PATH}" [ ! -d "${new_cdroot}" ] && mkdir -p "${new_cdroot}" mount --bind "${CDROOT_PATH}" "${new_cdroot}" } livecd_init() { good_msg "Making tmpfs for ${NEW_ROOT}" mount -n -t tmpfs -o mode=0755 tmpfs "${NEW_ROOT}" local dirs= dirs="dev mnt proc run sys tmp mnt/livecd" dirs="${dirs} mnt/key tmp/.initrd mnt/gentoo" for i in ${dirs}; do mkdir -p "${NEW_ROOT}/${i}" chmod 755 "${NEW_ROOT}/${i}" done [ ! -d "${CDROOT_PATH}" ] && mkdir -p "${CDROOT_PATH}" [ ! -e "${NEW_ROOT}/dev/null" ] && mknod "${NEW_ROOT}"/dev/null c 1 3 [ ! -e "${NEW_ROOT}/dev/console" ] && \ mknod "${NEW_ROOT}"/dev/console c 5 1 # For SGI LiveCDs ... if [ "${LOOPTYPE}" = "sgimips" ]; then [ ! -e "${NEW_ROOT}/dev/sr0" ] && \ mknod "${NEW_ROOT}/dev/sr0" b 11 0 [ ! -e "${NEW_ROOT}/dev/loop0" ] && \ mknod "${NEW_ROOT}/dev/loop0" b 7 0 fi # Required for splash to work. Not an issue with the initrd as this # device isn't created there and is not needed. if [ -e /dev/tty1 ]; then [ ! -e "${NEW_ROOT}/dev/tty1" ] && \ mknod "${NEW_ROOT}/dev/tty1" c 4 1 fi if ! is_nfs && [ "${LOOPTYPE}" != "sgimips" ]; then bootstrap_cd fi if [ "${REAL_ROOT}" = '' ] then warn_msg "No bootable medium found. Waiting for new devices..." COUNTER=0 while [ ${COUNTER} -lt 3 ]; do sleep 3 let COUNTER=${COUNTER}+1 done sleep 1 bootstrap_cd fi if [ "${REAL_ROOT}" = '' ] then # leave stale mounts around, make possible to debug bad_msg 'Could not find CD to boot, something else needed!' CDROOT=0 fi } livecd_mount() { # Let Init scripts know that we booted from CD export CDBOOT CDBOOT=1 good_msg 'Determining looptype ...' cd "${NEW_ROOT}" # Find loop and looptype [ -z "${LOOP}" ] && find_loop [ -z "${LOOPTYPE}" ] && find_looptype cache_cd_contents # If encrypted, find key and mount, otherwise mount as usual if [ -n "${CRYPT_ROOT}" ] then CRYPT_ROOT_KEY="$(head -n 1 "${CDROOT_PATH}"/${CDROOT_MARKER})" CRYPT_ROOT='/dev/loop0' good_msg 'You booted an encrypted livecd' "${CRYPT_SILENT}" losetup /dev/loop0 "${CDROOT_PATH}/${LOOPEXT}${LOOP}" test_success 'Preparing loop filesystem' start_luks case ${LOOPTYPE} in normal) MOUNTTYPE="ext2" ;; *) MOUNTTYPE="${LOOPTYPE}" ;; esac mount -t "${MOUNTTYPE}" -o ro /dev/mapper/root \ "${NEW_ROOT}/mnt/livecd" test_success 'Mount filesystem' FS_LOCATION='mnt/livecd' else # Setup the loopback mounts, if unencrypted if [ "${LOOPTYPE}" = 'normal' ]; then _livecd_mount_normal FS_LOCATION='mnt/livecd' elif [ "${LOOPTYPE}" = 'squashfs' ]; then _livecd_mount_squashfs FS_LOCATION='mnt/livecd' elif [ "${LOOPTYPE}" = 'gcloop' ]; then _livecd_mount_gcloop FS_LOCATION='mnt/livecd' elif [ "${LOOPTYPE}" = 'zisofs' ]; then FS_LOCATION="${CDROOT_PATH/\/}/${LOOPEXT}${LOOP}" elif [ "${LOOPTYPE}" = 'noloop' ]; then FS_LOCATION="${CDROOT_PATH/\/}" elif [ "${LOOPTYPE}" = 'sgimips' ]; then _livecd_mount_sgimips FS_LOCATION='mnt/livecd' fi fi is_nfs && _livecd_mount_unpack_nfs # Manually copy livecd content to tmpfs if aufs is disabled is_aufs || _livecd_mount_copy_content } # Unpack additional packages from NFS mount # This is useful for adding kernel modules to /lib # We do this now, so that additional packages can add whereever # they want. _livecd_mount_unpack_nfs() { if [ -e "${CDROOT_PATH}/add" ]; then for targz in $(ls ${CDROOT_PATH}/add/*.tar.gz); do tarname=$(basename ${targz}) good_msg "Adding additional package ${tarname}" (cd ${NEW_ROOT} ; /bin/tar -xzf ${targz}) done fi } _livecd_mount_sgimips() { # getdvhoff finds the starting offset (in bytes) of the squashfs # partition on the cdrom and returns this offset for losetup # # All currently supported SGI Systems use SCSI CD-ROMs, so # so we know that the CD-ROM is usually going to be /dev/sr0. # # We use the value given to losetup to set /dev/loop0 to point # to the liveCD root partition, and then mount /dev/loop0 as # the LiveCD rootfs good_msg 'Locating the SGI LiveCD Root Partition' echo ' ' | \ losetup -o $(getdvhoff "${NEW_ROOT}${REAL_ROOT}" 0) \ "${NEW_ROOT}${CDROOT_DEV}" \ "${NEW_ROOT}${REAL_ROOT}" test_success 'losetup /dev/sr0 /dev/loop0' good_msg 'Mounting the Root Partition' mount -t squashfs -o ro "${NEW_ROOT}${CDROOT_DEV}" \ "${NEW_ROOT}/mnt/livecd" test_success 'mount /dev/loop0 /' } _livecd_mount_gcloop() { good_msg 'Mounting gcloop filesystem' echo ' ' | losetup -E 19 -e ucl-0 -p0 \ "${NEW_ROOT}/dev/loop0" \ "${CDROOT_PATH}/${LOOPEXT}${LOOP}" test_success 'losetup the loop device' mount -t ext2 -o ro "${NEW_ROOT}/dev/loop0" "${NEW_ROOT}/mnt/livecd" test_success 'Mount the losetup loop device' } _livecd_mount_normal() { good_msg 'Mounting loop filesystem' mount -t ext2 -o loop,ro \ "${CDROOT_PATH}/${LOOPEXT}${LOOP}" \ "${NEW_ROOT}/mnt/livecd" test_success 'Mount filesystem' } _livecd_mount_squashfs() { # if AUFS, redirect to the squashfs+aufs setup function if is_aufs; then good_msg 'Mounting squashfs & aufs filesystems' setup_squashfs_aufs test_success 'Mount filesystem' return # preserve old behaviour fi good_msg 'Mounting squashfs filesystem' local cached_squashfs_path="${NEW_ROOT}/mnt/${LOOP}" local squashfs_path="${CDROOT_PATH}/${LOOPEXT}${LOOP}" # Upgrade to cached version if possible if [ -n "${DO_cache}" ] && [ -f "${cached_squashfs_path}" ]; then squashfs_path="${cached_squashfs_path}" fi mount -t squashfs -o loop,ro "${squashfs_path}" \ "${NEW_ROOT}/mnt/livecd" || { bad_msg "squashfs filesystem could not be mounted." do_rundebugshell } } # Manually copy livecd read-only content into the final livecd root # filesystem directory, which has been mounted as tmpfs. _livecd_mount_copy_content() { local fs_loc="${NEW_ROOT}/${FS_LOCATION}" good_msg "Copying read-write image contents to tmpfs" # Copy over stuff that should be writable ( cd "${fs_loc}" && cp -a ${ROOT_TREES} "${NEW_ROOT}" ) || { bad_msg "Copy failed, dropping into a shell." do_rundebugshell } # Now we do the links. for x in ${ROOT_LINKS}; do if [ -L "${fs_loc}/${x}" ]; then ln -s "$(readlink ${fs_loc}/${x})" "${x}" 2>/dev/null continue fi # List all subdirectories of x find "${fs_loc}/${x}" -type d 2>/dev/null | \ while read directory; do # Strip the prefix of the FS_LOCATION directory="${directory#${fs_loc}/}" # Skip this directory if we already linked a parent # directory if [ "${current_parent}" != "" ]; then var=$(echo "${directory}" | \ grep "^${current_parent}") if [ "${var}" != "" ]; then continue fi fi local root_d="${NEW_ROOT}/${directory}" local fsloc_d="${FS_LOCATION}/${directory}" # Test if the directory exists already if [ ! -e "/${root_d}" ]; then # It does not exist, make a link to the livecd ln -s "/${FS_LOCATION}/${directory}" \ "${directory}" 2>/dev/null current_parent="${directory}" continue fi # It does exist, link all the individual files local fs_d="/${fs_loc}/${directory}" for file in $(ls "${fs_d}"); do [ -d "${fs_d}/${file}" ] && continue [ -e "${root_d}/${file}" ] && continue ln -s "/${fsloc_d}/${file}" \ "${directory}/${file}" 2> /dev/null done done done mkdir initramfs proc tmp sys run 2>/dev/null chmod 1777 tmp # have handy /mnt/cdrom (CDROOT_PATH) as well _new_cdroot="${NEW_ROOT}${CDROOT_PATH}" [ ! -d "${_new_cdroot}" ] && mkdir -p "${_new_cdroot}" mount --bind "${CDROOT_PATH}" "${_new_cdroot}" } get_mounts_list() { awk ' /^[[:blank:]]*#/ { next } { print $1 } ' ${NEW_ROOT}/etc/initramfs.mounts } get_mount_fstype() { [ -e "${NEW_ROOT}"/etc/fstab ] || return 1 awk -v fs="$1" ' /^[[:blank:]]*#/ { next } $2 == fs { print $3 } ' ${NEW_ROOT}/etc/fstab } get_mount_options() { [ -e "${NEW_ROOT}"/etc/fstab ] || return 1 awk -v fs="$1" ' /^[[:blank:]]*#/ { next } $2 == fs { print $4 } ' ${NEW_ROOT}/etc/fstab } get_mount_device() { [ -e "${NEW_ROOT}"/etc/fstab ] || return 1 awk -v fs="$1" ' /^[[:blank:]]*#/ { next } $2 == fs { print $1 } ' ${NEW_ROOT}/etc/fstab } # If the kernel is handed a mount option is does not recognize, it # WILL fail to mount. util-linux handles auto/noauto, but busybox # passes it straight to the kernel which then rejects the mount. To # make like a little easier, busybox mount does not care about # leading, trailing or duplicate commas. strip_mount_options() { sed -r 's/(,|^)(no)?auto(,|$)/,/g' } # Read /etc/initramfs.mounts from ${NEW_ROOT} and mount the # listed filesystem mountpoints. For instance, /usr, which is # required by udev & systemd. ensure_initramfs_mounts() { local fslist= if [ -f "${NEW_ROOT}/etc/initramfs.mounts" ]; then fslist="$(get_mounts_list)" else fslist="/usr" fi local dev= fstype= opts= mnt= cmd= for fs in ${fslist}; do mnt="${NEW_ROOT}${fs}" if mountpoint -q "${mnt}"; then good_msg "${fs} already mounted, skipping..." continue fi dev=$(get_mount_device "${fs}") [ -z "${dev}" ] && continue # Resolve it like util-linux mount does [ -L "${dev}" ] && dev=$(readlink "${dev}") # In this case, it's probably part of the filesystem # and not a mountpoint [ -z "${dev}" ] && continue fstype=$(get_mount_fstype "${fs}") if get_mount_options "${fs}" | fgrep -q bind; then opts="bind" dev="${NEW_ROOT}${dev}" else # ro must be trailing, and the options will always # contain at least 'defaults' opts="$(get_mount_options ${fs} | strip_mount_options)" opts="${opts},ro" fi cmd="mount -t ${fstype} -o ${opts} ${dev} ${mnt}" good_msg "Mounting ${dev} as ${fs}: ${cmd}" if ! ${cmd}; then bad_msg "Unable to mount ${dev} for ${fs}" fi done } fstype_init() { local fstype="${1}" if [ "${fstype}" = "btrfs" ]; then # start BTRFS volume detection, if available [ -x /sbin/btrfs ] && /sbin/btrfs device scan elif [ -z "${fstype}" ]; then warn_msg "Unable to detect the filesystem type (empty variable)" fi } _rootdev_detect() { local got_good_root=0 while [ "${got_good_root}" != "1" ]; do case "${REAL_ROOT}" in LABEL=*|UUID=*) local root_dev=$(find_real_device "${REAL_ROOT}") if [ -n "${root_dev}" ]; then REAL_ROOT="${root_dev}" good_msg "Detected root: ${REAL_ROOT}" else bad_msg "Unable to resolve root: ${REAL_ROOT}" got_good_root=0 prompt_user "REAL_ROOT" "root block device" continue fi ;; ZFS*) # zfs_rootdev_init will tweak ${REAL_ROOT} zfs_rootdev_init if [ "${?}" = "0" ]; then got_good_root=1 else got_good_root=0 prompt_user "REAL_ROOT" "root block device" continue fi ;; esac if [ -z "${REAL_ROOT}" ]; then # No REAL_ROOT determined/specified. # Prompt user for root block device. prompt_user "REAL_ROOT" "root block device" got_good_root=0 # Check for a block device or NFS elif [ -b "${REAL_ROOT}" ] || is_nfs; then got_good_root=1 else bad_msg "${REAL_ROOT} is an invalid root device..." REAL_ROOT="" got_good_root=0 fi done return 0 } _rootdev_mount() { local mount_opts=ro local mount_fstype="${ROOTFSTYPE}" local fstype=$(get_device_fstype "${REAL_ROOT}") if is_zfs_fstype "${fstype}"; then mount_fstype=zfs mount_opts=$(zfs_get_real_root_mount_flags) fi good_msg "Detected fstype: ${fstype}" good_msg "Using mount fstype: ${mount_fstype}" fstype_init "${fstype}" local mopts="${mount_opts}" [ -n "${REAL_ROOTFLAGS}" ] && \ mopts="${mopts},${REAL_ROOTFLAGS}" good_msg "Using mount opts: -o ${mopts}" mount -t "${mount_fstype}" -o "${mopts}" \ "${REAL_ROOT}" "${NEW_ROOT}" || return 1 return 0 } rootdev_init() { good_msg "Initializing root device..." while true; do if ! _rootdev_detect; then bad_msg "Could not mount specified ROOT, try again" prompt_user "REAL_ROOT" "root block device" continue fi if is_livecd && ! is_nfs; then # CD already mounted; no further checks necessary break fi if [ "${LOOPTYPE}" = "sgimips" ]; then # sgimips mounts the livecd root partition directly # there is no isofs filesystem to worry about break fi good_msg "Mounting ${REAL_ROOT} as root..." # Try to mount the device as ${NEW_ROOT} local out=1 if is_nfs; then find_nfs && out=0 else _rootdev_mount && out=0 fi if [ "${out}" != "0" ]; then bad_msg "Could not mount specified ROOT, try again" prompt_user "REAL_ROOT" "root block device" continue fi # now that the root filesystem is mounted, before # checking the validity of ${NEW_ROOT} and ${REAL_INIT}, # ensure that ${NEW_ROOT}/etc/initramfs.mounts entries # are mounted. ensure_initramfs_mounts # NFS does not need further checks here. is_nfs && break if [ ! -d "${NEW_ROOT}/dev" ]; then _msg="The filesystem ${REAL_ROOT}," _msg="${_msg} mounted at ${NEW_ROOT}" _msg="${_msg} does not contain /dev" _msg="${_msg}, init will likely fail..." bad_msg "${_msg}" prompt_user "REAL_ROOT" "root block device" continue fi if [ ! -x "${NEW_ROOT}${REAL_INIT}" ]; then _msg="The filesystem ${REAL_ROOT}," _msg="${_msg} mounted at ${NEW_ROOT}" _msg="${_msg} does not contain a valid" _msg="${_msg} init=${REAL_INIT}" bad_msg "${_msg}" prompt_user "REAL_ROOT" "root block device" continue fi break done } # If devtmpfs is mounted, try move it to the new root # If that fails, try to unmount all possible mounts of devtmpfs as # stuff breaks otherwise move_mounts_to_chroot() { for fs in /run /dev /sys /proc; do if grep -qs "$fs" /proc/mounts; then local chroot_dir="${CHROOT}${fs}" mkdir -p "${chroot_dir}" if ! mount --move $fs "${chroot_dir}" then umount $fs || \ bad_msg "Failed to move and umount $fs!" fi fi done }