X-Git-Url: http://git.grml.org/?a=blobdiff_plain;f=scripts%2Flive;h=57a4d322c9521d979675cd63eccff9b70db8405e;hb=967bfeaca7c4f3e28f935b1afbd0cce0878dd559;hp=73a965e0b947af8fd69eb760b8390e05969fc45f;hpb=cdb98bbbdc41b29c6b94dc5aed36393daec84cf8;p=live-boot-grml.git diff --git a/scripts/live b/scripts/live index 73a965e..57a4d32 100755 --- a/scripts/live +++ b/scripts/live @@ -2,669 +2,1969 @@ # set -e -export PATH=/root/usr/bin:/root/usr/sbin:/root/bin:/root/sbin:/usr/bin:/usr/sbin:/bin:/sbin +export PATH="/root/usr/bin:/root/usr/sbin:/root/bin:/root/sbin:/usr/bin:/usr/sbin:/bin:/sbin" echo "/root/lib" >> /etc/ld.so.conf echo "/root/usr/lib" >> /etc/ld.so.conf -mountpoint=/live_media +mountpoint="/live/image" +alt_mountpoint="/media" +LIVE_MEDIA_PATH="live" root_persistence="live-rw" home_persistence="home-rw" root_snapshot_label="live-sn" home_snapshot_label="home-sn" -USERNAME=user +USERNAME="user" USERFULLNAME="Live user" -HOSTNAME=host -BUILD_SYSTEM=Custom +HOSTNAME="host" -mkdir -p $mountpoint +mkdir -p "${mountpoint}" +tried="/tmp/tried" -[ -f /etc/live.conf ] && . /etc/live.conf -export USERNAME USERFULLNAME HOSTNAME BUILD_SYSTEM +# Create /etc/mtab for debug purpose and future syncs +if [ ! -d /etc ] +then + mkdir /etc/ +fi + +if [ ! -f /etc/mtab ] +then + touch /etc/mtab +fi . /scripts/live-helpers -if [ ! -f /live.vars ]; then - touch /live.vars +if [ ! -f /live.vars ] +then + touch /live.vars fi -parse_cmdline () +Arguments () { - PRESEEDS= - # looking for live-initramfs specifics options as kernel parameters - for x in $(cat /proc/cmdline); do - case $x in - userfullname=*) - export USERFULLNAME=${x#userfullname=} - export LIVECONF="changed" - ;; - hostname=*) - export HOSTNAME=${x#hostname=} - export LIVECONF="changed" - ;; - username=*) - export USERNAME=${x#username=} - export LIVECONF="changed" - ;; - netboot*) - export NETBOOT=${x#netboot=} ;; - access=*) - export ACCESS=${x#access=} ;; - xdebconf) - export XDEBCONF="Yes" ;; - xvideomode=*) - export XVIDEOMODE="${x#xvideomode=}" ;; - toram) - export TORAM="Yes" ;; - todisk=*) - export TODISK=${x#todisk=} ;; - noswap) - export NOSWAP="Yes" ;; - noautologin) - export NOAUTOLOGIN="Yes" ;; - noxautologin) - export NOXAUTOLOGIN="Yes" ;; - nosudo) - export NOSUDO="Yes" ;; - showmounts) - export SHOWMOUNTS="Yes" ;; - persistent) - export PERSISTENT="Yes" ;; - nopersistent) - export PERSISTENT="" ;; - ip*) - STATICIP=${x#ip=} - if [ "${STATICIP}" == "" ]; then - STATICIP="frommedia" - fi - export STATICIP ;; - live-getty) - export LIVE_GETTY=1 ;; - bootfrom=*|live-media=*) - export LIVE_MEDIA=${x#*=} ;; - live-media-encryption=*|encryption=*) - export LIVE_MEDIA_ENCRYPTION=${x#*=} ;; - live-media-timeout=*) - export LIVE_MEDIA_TIMEOUT=${x#live-media-timeout=} ;; - live-media-offset=*) - export LIVE_MEDIA_OFFSET=${x#live-media-offset=} ;; - locale=*|debian-installer/locale=*) - export LOCALE=${x#*=} ;; - keyb=*|kbd-chooser/method=*) - export KBD=${x#*=} ;; - klayout=*|console-setup/layoutcode=*) - export KLAYOUT=${x#*=} ;; - koptions=*) - export KOPTIONS=${x#koptions=} ;; - kvariant=*|console-setup/variantcode=*) - export KVARIANT=${x#*=} ;; - kmodel=*|console-setup/modelcode=*) - export KMODEL=${x#*=} ;; - module=*) - export MODULE=${x#module=} ;; - preseed/file=*|file=*) - export LOCATION="${x#*=}" ;; - */*=*) - question="${x%%=*}" - value="${x#*=}" - PRESEEDS="${PRESEEDS}\"${question}=${value}\" " - ;; - console=*) - export DEFCONSOLE="${x#*=}" ;; - esac - done - - # sort of compatibility with netboot.h from linux docs - if [ -z "${NETBOOT}" ]; then - if [ "${ROOT}" == "/dev/nfs" ]; then - NETBOOT="nfs" - export NETBOOT - elif [ "${ROOT}" == "/dev/cifs" ]; then - NETBOOT="cifs" - export NETBOOT - fi - fi - - if [ -z "${MODULE}" ]; then - MODULE=order - fi + PRESEEDS="" + LOCATIONS="" + + for ARGUMENT in $(cat /proc/cmdline) + do + case "${ARGUMENT}" in + skipconfig) + NOACCESSIBILITY="Yes" + NOFASTBOOT="Yes" + NOFSTAB="Yes" + NONETWORKING="Yes" + + export NOACCESSIBILITY NOFASTBOOT NOFSTAB NONETWORKING + ;; + + access=*) + ACCESS="${ARGUMENT#access=}" + export ACCESS + ;; + + console=*) + DEFCONSOLE="${ARGUMENT#*=}" + export DEFCONSOLE + ;; + + BOOTIF=*) + BOOTIF="${x#BOOTIF=}" + ;; + + debug) + DEBUG="Yes" + export DEBUG + + set -x + ;; + + dhcp) + # Force dhcp even while netbooting + # Use for debugging in case somebody works on fixing dhclient + DHCP="Force"; + export DHCP + ;; + + nodhcp) + unset DHCP + ;; + + ethdevice=*) + DEVICE="${ARGUMENT#ethdevice=}" + ETHDEVICE="${DEVICE}" + export DEVICE ETHDEVICE + ;; + + ethdevice-timeout=*) + ETHDEV_TIMEOUT="${ARGUMENT#ethdevice-timeout=}" + export ETHDEV_TIMEOUT + ;; + + fetch=*) + FETCH="${ARGUMENT#fetch=}" + export FETCH + ;; + + forcepersistentfsck) + FORCEPERSISTENTFSCK="Yes" + export FORCEPERSISTENTFSCK + ;; + + ftpfs=*) + FTPFS="${ARGUMENT#ftpfs=}" + export FTPFS + ;; + + httpfs=*) + HTTPFS="${ARGUMENT#httpfs=}" + export HTTPFS + ;; + + iscsi=*) + ISCSI="${ARGUMENT#iscsi=}" + #ip:port - separated by ; + ISCSI_PORTAL="${ISCSI%;*}" + if echo "${ISCSI_PORTAL}" | grep -q , ; then + ISCSI_SERVER="${ISCSI_PORTAL%,*}" + ISCSI_PORT="${ISCSI_PORTAL#*,}" + fi + #target name + ISCSI_TARGET="${ISCSI#*;}" + export ISCSI ISCSI_PORTAL ISCSI_TARGET ISCSI_SERVER ISCSI_PORT + ;; + + isofrom=*|fromiso=*) + FROMISO="${ARGUMENT#*=}" + export FROMISO + ;; + + ignore_uuid) + IGNORE_UUID="Yes" + export IGNORE_UUID + ;; + + integrity-check) + INTEGRITY_CHECK="Yes" + export INTEGRITY_CHECK + ;; + + ip=*) + STATICIP="${ARGUMENT#ip=}" + + if [ -z "${STATICIP}" ] + then + STATICIP="frommedia" + fi + + export STATICIP + ;; + + live-getty) + LIVE_GETTY="1" + export LIVE_GETTY + ;; + + live-media=*|bootfrom=*) + LIVE_MEDIA="${ARGUMENT#*=}" + export LIVE_MEDIA + ;; + + live-media-encryption=*|encryption=*) + LIVE_MEDIA_ENCRYPTION="${ARGUMENT#*=}" + export LIVE_MEDIA_ENCRYPTION + ;; + + live-media-offset=*) + LIVE_MEDIA_OFFSET="${ARGUMENT#live-media-offset=}" + export LIVE_MEDIA_OFFSET + ;; + + live-media-path=*) + LIVE_MEDIA_PATH="${ARGUMENT#live-media-path=}" + export LIVE_MEDIA_PATH + ;; + + live-media-timeout=*) + LIVE_MEDIA_TIMEOUT="${ARGUMENT#live-media-timeout=}" + export LIVE_MEDIA_TIMEOUT + ;; + + module=*) + MODULE="${ARGUMENT#module=}" + export MODULE + ;; + + netboot=*) + NETBOOT="${ARGUMENT#netboot=}" + export NETBOOT + ;; + + nfsopts=*) + NFSOPTS="${ARGUMENT#nfsopts=}" + export NFSOPTS + ;; + + nfscow=*) + NFS_COW="${ARGUMENT#nfscow=}" + export NFS_COW + ;; + + noaccessibility) + NOACCESSIBILITY="Yes" + export NOACCESSIBILITY + ;; + + nofastboot) + NOFASTBOOT="Yes" + export NOFASTBOOT + ;; + + nofstab) + NOFSTAB="Yes" + export NOFSTAB + ;; + + nonetworking) + NONETWORKING="Yes" + export NONETWORKING + ;; + + ramdisk-size=*) + ramdisk_size="${ARGUMENT#ramdisk-size=}" + ;; + + swapon) + SWAPON="Yes" + export SWAPON + ;; + + persistent) + PERSISTENT="Yes" + export PERSISTENT + ;; + + persistent=*) + PERSISTENT="${ARGUMENT#persistent=}" + if [ -z "${PERSISTENT}" ] + then + PERSISTENT="Yes" + fi + export PERSISTENT + ;; + + persistent-path=*) + PERSISTENT_PATH="${ARGUMENT#persistent-path=}" + export PERSISTENT_PATH + ;; + + persistent-subtext=*) + root_persistence="${root_persistence}-${ARGUMENT#persistent-subtext=}" + home_persistence="${home_persistence}-${ARGUMENT#persistent-subtext=}" + root_snapshot_label="${root_snapshot_label}-${ARGUMENT#persistent-subtext=}" + home_snapshot_label="${home_snapshot_label}-${ARGUMENT#persistent-subtext=}" + ;; + + nopersistent) + NOPERSISTENT="Yes" + export NOPERSISTENT + ;; + + noprompt) + NOPROMPT="Yes" + export NOPROMPT + ;; + + noprompt=*) + NOPROMPT="${ARGUMENT#noprompt=}" + export NOPROMPT + ;; + + quickusbmodules) + QUICKUSBMODULES="Yes" + export QUICKUSBMODULES + ;; + + preseed/file=*|file=*) + LOCATIONS="${ARGUMENT#*=} ${LOCATIONS}" + export LOCATIONS + ;; + + nopreseed) + NOPRESEED="Yes" + export NOPRESEED + ;; + + */*=*) + question="${ARGUMENT%%=*}" + value="${ARGUMENT#*=}" + PRESEEDS="${PRESEEDS}\"${question}=${value}\" " + export PRESEEDS + ;; + + showmounts) + SHOWMOUNTS="Yes" + export SHOWMOUNTS + ;; + + silent) + SILENT="Yes" + export SILENT + ;; + + todisk=*) + TODISK="${ARGUMENT#todisk=}" + export TODISK + ;; + + toram) + TORAM="Yes" + export TORAM + ;; + + toram=*) + TORAM="Yes" + MODULETORAM="${ARGUMENT#toram=}" + export TORAM MODULETORAM + ;; + + exposedroot) + EXPOSED_ROOT="Yes" + export EXPOSED_ROOT + ;; + + plainroot) + PLAIN_ROOT="Yes" + export PLAIN_ROOT + ;; + + skipunion) + SKIP_UNION_MOUNTS="Yes" + export SKIP_UNION_MOUNTS + ;; + + root=*) + ROOT="${ARGUMENT#root=}" + export ROOT + ;; + + union=*) + UNIONTYPE="${ARGUMENT#union=}" + export UNIONTYPE + ;; + esac + done + + # sort of compatibility with netboot.h from linux docs + if [ -z "${NETBOOT}" ] + then + if [ "${ROOT}" = "/dev/nfs" ] + then + NETBOOT="nfs" + export NETBOOT + elif [ "${ROOT}" = "/dev/cifs" ] + then + NETBOOT="cifs" + export NETBOOT + fi + fi + + if [ -z "${MODULE}" ] + then + MODULE="filesystem" + export MODULE + fi + + if [ -z "${UNIONTYPE}" ] + then + UNIONTYPE="aufs" + export UNIONTYPE + fi } -is_live_path() { - path=$1 - if [ -d "$path/live" ]; then - if [ "$(echo $path/live/*.squashfs)" != "$path/live/*.squashfs" ] || - [ "$(echo $path/live/*.ext2)" != "$path/live/*.ext2" ] || - [ "$(echo $path/live/*.ext3)" != "$path/live/*.ext3" ] || - [ "$(echo $path/live/*.dir)" != "$path/live/*.dir" ]; then - return 0 - fi - fi - return 1 +is_live_path () +{ + DIRECTORY="${1}" + + if [ -d "${DIRECTORY}"/"${LIVE_MEDIA_PATH}" ] + then + for FILESYSTEM in squashfs ext2 ext3 ext4 xfs dir jffs2 + do + if [ "$(echo ${DIRECTORY}/${LIVE_MEDIA_PATH}/*.${FILESYSTEM})" != "${DIRECTORY}/${LIVE_MEDIA_PATH}/*.${FILESYSTEM}" ] + then + return 0 + fi + done + fi + + return 1 } -get_backing_device() { - case "$1" in - *.squashfs|*.ext2|*.ext3) - echo $(setup_loop "$1" "loop" "/sys/block/loop*" '0' "${LIVE_MEDIA_ENCRYPTION}") - ;; - *.dir) - echo "directory" - ;; - *) - panic "Unrecognized live filesystem: $1" - ;; - esac -} +matches_uuid () +{ + if [ "${IGNORE_UUID}" ] || [ ! -e /conf/uuid.conf ] + then + return 0 + fi -match_files_in_dir() { - # Does any files match pattern $1 ? + path="${1}" + uuid="$(cat /conf/uuid.conf)" - local pattern="$1" - if [ "$(echo $pattern)" != "$pattern" ]; then - return 0 - fi - return 1 + for try_uuid_file in "${path}/.disk/live-uuid"* + do + [ -e "${try_uuid_file}" ] || continue + + try_uuid="$(cat "${try_uuid_file}")" + + if [ "${uuid}" = "${try_uuid}" ] + then + return 0 + fi + done + + return 1 } -mount_images_in_directory() { - directory="$1" - rootmnt="$2" - if match_files_in_dir "$directory/live/*.squashfs" || - match_files_in_dir "$directory/live/*.ext2" || - match_files_in_dir "$directory/live/*.ext3" || - match_files_in_dir "$directory/live/*.dir"; then - setup_unionfs "$directory/live" "$rootmnt" - else - : - fi +get_backing_device () +{ + case "${1}" in + *.squashfs|*.ext2|*.ext3|*.ext4|*.jffs2) + echo $(setup_loop "${1}" "loop" "/sys/block/loop*" '0' "${LIVE_MEDIA_ENCRYPTION}" "${2}") + ;; + + *.dir) + echo "directory" + ;; + + *) + panic "Unrecognized live filesystem: ${1}" + ;; + esac } -is_nice_device() { - sysfs_path="${1#/sys}" - if /lib/udev/path_id "${sysfs_path}" | grep -E -q "ID_PATH=(usb|pci-[^-]*-[ide|scsi|usb])"; then - return 0 - fi - return 1 +match_files_in_dir () +{ + # Does any files match pattern ${1} ? + local pattern="${1}" + + if [ "$(echo ${pattern})" != "${pattern}" ] + then + return 0 + fi + + return 1 } -is_supported_fs () { - # FIXME: do something better like the scan of supported filesystems - fstype="${1}" - case ${fstype} in - vfat|iso9660|udf|ext2|ext3|ntfs) - return 0 - ;; - esac - return 1 +mount_images_in_directory () +{ + directory="${1}" + rootmnt="${2}" + mac="${3}" + + + if match_files_in_dir "${directory}/${LIVE_MEDIA_PATH}/*.squashfs" || + match_files_in_dir "${directory}/${LIVE_MEDIA_PATH}/*.ext2" || + match_files_in_dir "${directory}/${LIVE_MEDIA_PATH}/*.ext3" || + match_files_in_dir "${directory}/${LIVE_MEDIA_PATH}/*.ext4" || + match_files_in_dir "${directory}/${LIVE_MEDIA_PATH}/*.jffs2" || + match_files_in_dir "${directory}/${LIVE_MEDIA_PATH}/*.dir" + then + [ -n "${mac}" ] && adddirectory="${directory}/${LIVE_MEDIA_PATH}/${mac}" + setup_unionfs "${directory}/${LIVE_MEDIA_PATH}" "${rootmnt}" "${adddirectory}" + else + panic "No supported filesystem images found at /${LIVE_MEDIA_PATH}." + fi } -copy_live_to() { - copyfrom="${1}" - copytodev="${2}" - copyto="${copyfrom}_swap" - - size=$(fs_size "" ${copyfrom} "used") - - if [ "${copytodev}" = "ram" ]; then - # copying to ram: - freespace=$( expr $(awk '/MemFree/{print $2}' /proc/meminfo) + $( cat /proc/meminfo | grep Cached | head -n 1 | awk '/Cached/{print $2}' - ) ) - mount_options="-o size=${size}k" - free_string="memory" - fstype="tmpfs" - dev="/dev/shm" - else - # it should be a writable block device - if [ -b "${copytodev}" ]; then - dev="${copytodev}" - free_string="space" - fstype=$(get_fstype "${dev}") - freespace=$(fs_size "${dev}") - else - [ "$quiet" != "y" ] && log_warning_msg "${copytodev} is not a block device." - return 1 - fi - fi - if [ "${freespace}" -lt "${size}" ] ; then - [ "$quiet" != "y" ] && log_warning_msg "Not enough free ${free_string} (${freespace}k > ${size}k) to copy live media in ${copytodev}." - return 1 - fi - - # begin copying.. - mkdir "${copyto}" - echo "mount -t ${fstype} ${mount_options} ${dev} ${copyto}" - mount -t "${fstype}" ${mount_options} "${dev}" "${copyto}" - cp -a ${copyfrom}/* ${copyto} # "cp -a" from busybox also copies hidden files - umount ${copyfrom} - mount -r --move ${copyto} ${copyfrom} - rmdir ${copyto} - return 0 +is_nice_device () +{ + sysfs_path="${1#/sys}" + + if /lib/udev/path_id "${sysfs_path}" | egrep -q "ID_PATH=(usb|pci-|platform-sata_mv|platform-orion-ehci|platform-mmc|platform-mxsdhci|)" + then + return 0 + elif echo "${sysfs_path}" | grep -q '^/block/vd[a-z]$' + then + return 0 + elif echo ${sysfs_path} | grep -q "^/block/dm-" + then + return 0 + elif echo ${sysfs_path} | grep -q "^/block/mtdblock" + then + return 0 + fi + + return 1 } -do_netmount() { - rc=1 +copy_live_to () +{ + copyfrom="${1}" + copytodev="${2}" + copyto="${copyfrom}_swap" + + if [ -z "${MODULETORAM}" ] + then + size=$(fs_size "" ${copyfrom}/${LIVE_MEDIA_PATH} "used") + else + MODULETORAMFILE="${copyfrom}/${LIVE_MEDIA_PATH}/${MODULETORAM}" + + if [ -f "${MODULETORAMFILE}" ] + then + size=$( expr $(ls -la ${MODULETORAMFILE} | awk '{print $5}') / 1024 + 5000 ) + else + log_warning_msg "Error: toram-module ${MODULETORAM} (${MODULETORAMFILE}) could not be read." + return 1 + fi + fi + + if [ "${copytodev}" = "ram" ] + then + # copying to ram: + freespace=$(awk '/^MemFree:/{f=$2} /^Cached:/{c=$2} END{print f+c}' /proc/meminfo) + mount_options="-o size=${size}k" + free_string="memory" + fstype="tmpfs" + dev="/dev/shm" + else + # it should be a writable block device + if [ -b "${copytodev}" ] + then + dev="${copytodev}" + free_string="space" + fstype=$(get_fstype "${dev}") + freespace=$(fs_size "${dev}") + else + log_warning_msg "${copytodev} is not a block device." + return 1 + fi + fi + + if [ "${freespace}" -lt "${size}" ] + then + log_warning_msg "Not enough free ${free_string} (${freespace}k free, ${size}k needed) to copy live media in ${copytodev}." + return 1 + fi + + # Custom ramdisk size + if [ -z "${mount_options}" ] && [ -n "${ramdisk_size}" ] + then + # FIXME: should check for wrong values + mount_options="-o size=${ramdisk_size}" + fi + + # begin copying (or uncompressing) + mkdir "${copyto}" + log_begin_msg "mount -t ${fstype} ${mount_options} ${dev} ${copyto}" + mount -t "${fstype}" ${mount_options} "${dev}" "${copyto}" + + if [ "${extension}" = "tgz" ] + then + cd "${copyto}" + tar zxf "${copyfrom}/${LIVE_MEDIA_PATH}/$(basename ${FETCH})" + rm -f "${copyfrom}/${LIVE_MEDIA_PATH}/$(basename ${FETCH})" + mount -r -o move "${copyto}" "${rootmnt}" + cd "${OLDPWD}" + else + if [ -n "${MODULETORAMFILE}" ] + then + if [ -x /bin/rsync ] + then + echo " * Copying $MODULETORAMFILE to RAM" 1>/dev/console + rsync -a --progress ${MODULETORAMFILE} ${copyto} 1>/dev/console # copy only the filesystem module + else + cp ${MODULETORAMFILE} ${copyto} # copy only the filesystem module + fi + else + if [ -x /bin/rsync ] + then + echo " * Copying whole medium to RAM" 1>/dev/console + rsync -a --progress ${copyfrom}/* ${copyto} 1>/dev/console # "cp -a" from busybox also copies hidden files + else + mkdir -p ${copyto}/${LIVE_MEDIA_PATH} + cp -a ${copyfrom}/${LIVE_MEDIA_PATH}/* ${copyto}/${LIVE_MEDIA_PATH} + if [ -e ${copyfrom}/${LIVE_MEDIA_PATH}/.disk ] + then + cp -a ${copyfrom}/${LIVE_MEDIA_PATH}/.disk ${copyto} + fi + fi + fi + + umount ${copyfrom} + mount -r -o move ${copyto} ${copyfrom} + fi + + rmdir ${copyto} + return 0 +} + +do_netsetup () +{ + modprobe -q af_packet # For DHCP + + udevadm trigger + udevadm settle + + [ -n "$ETHDEV_TIMEOUT" ] || ETHDEV_TIMEOUT=15 + echo "Using timeout of $ETHDEV_TIMEOUT seconds for network configuration." + + if [ -z "${NETBOOT}" ] && [ -z "${FETCH}" ] && \ + [ -z "${HTTPFS}" ] && [ -z "${FTPFS}" ] + then + + + # support for Syslinux IPAPPEND parameter + # it sets the BOOTIF variable on the kernel parameter + + if [ -n "${BOOTIF}" ] + then + # pxelinux sets BOOTIF to a value based on the mac address of the + # network card used to PXE boot, so use this value for DEVICE rather + # than a hard-coded device name from initramfs.conf. this facilitates + # network booting when machines may have multiple network cards. + # pxelinux sets BOOTIF to 01-$mac_address + + # strip off the leading "01-", which isn't part of the mac + # address + temp_mac=${BOOTIF#*-} + + # convert to typical mac address format by replacing "-" with ":" + bootif_mac="" + IFS='-' + for x in $temp_mac + do + if [ -z "$bootif_mac" ] + then + bootif_mac="$x" + else + bootif_mac="$bootif_mac:$x" + fi + done + unset IFS + + # look for devices with matching mac address, and set DEVICE to + # appropriate value if match is found. + + for device in /sys/class/net/* + do + if [ -f "$device/address" ] + then + current_mac=$(cat "$device/address") + + if [ "$bootif_mac" = "$current_mac" ] + then + DEVICE=${device##*/} + break + fi + fi + done + fi + + # if ethdevice was not specified on the kernel command line + # make sure we try to get a working network configuration + # for *every* present network device (except for loopback of course) + if [ -z "$ETHDEVICE" ] ; then + echo "If you want to boot from a specific device use bootoption ethdevice=..." + for device in /sys/class/net/*; do + dev=${device##*/} ; + if [ "$dev" != "lo" ] ; then + ETHDEVICE="$ETHDEVICE $dev" + fi + done + fi + + # split args of ethdevice=eth0,eth1 into "eth0 eth1" + for device in $(echo $ETHDEVICE | sed 's/,/ /g') ; do + devlist="$devlist $device" + done + + # this is tricky (and ugly) because ipconfig sometimes just hangs/runs into + # an endless loop; iff execution fails give it two further tries, that's + # why we use '$devlist $devlist $devlist' for the other for loop + for dev in $devlist $devlist $devlist ; do + echo "Executing ipconfig -t $ETHDEV_TIMEOUT $dev" + ipconfig -t "$ETHDEV_TIMEOUT" $dev | tee -a /netboot.config & + jobid=$! + sleep "$ETHDEV_TIMEOUT" ; sleep 1 + if [ -r /proc/"$jobid"/status ] ; then + echo "Killing job $jobid for device $dev as ipconfig ran into recursion..." + kill -9 $jobid + fi - modprobe "${MP_QUIET}" af_packet # For DHCP + # if configuration of device worked we should have an assigned + # IP address, iff so let's use the according as $DEVICE for later usage + # simple and primitive approach which seems to work fine + if ifconfig $dev | grep -q 'inet.*addr:' ; then + export DEVICE="$dev" + break + fi + done + + else + for interface in ${DEVICE}; do + ipconfig -t "$ETHDEV_TIMEOUT" ${interface} | tee /netboot-${interface}.config + [ -e /tmp/net-${interface}.conf ] && . /tmp/net-${interface}.conf + if [ "$IPV4ADDR" != "0.0.0.0" ] + then + break + fi + done + fi + + for interface in ${DEVICE}; do + # source relevant ipconfig output + OLDHOSTNAME=${HOSTNAME} + [ -e /tmp/net-${interface}.conf ] && . /tmp/net-${interface}.conf + [ -z ${HOSTNAME} ] && HOSTNAME=${OLDHOSTNAME} + export HOSTNAME + + if [ -n "${interface}" ] + then + HWADDR="$(cat /sys/class/net/${interface}/address)" + fi - udevtrigger - udevsettle + if [ ! -e "/etc/resolv.conf" ] + then + echo "Creating /etc/resolv.conf" + + if [ -n "${DNSDOMAIN}" ] + then + echo "domain ${DNSDOMAIN}" > /etc/resolv.conf + echo "search ${DNSDOMAIN}" >> /etc/resolv.conf + fi + + for i in ${IPV4DNS0} ${IPV4DNS1} ${IPV4DNS1} + do + if [ -n "$i" ] && [ "$i" != 0.0.0.0 ] + then + echo "nameserver $i" >> /etc/resolv.conf + fi + done + fi - ipconfig ${DEVICE} /tmp/net-${DEVICE}.conf | tee /netboot.config + # Check if we have a network device at all + if ! ls /sys/class/net/"$interface" > /dev/null 2>&1 && \ + ! ls /sys/class/net/eth0 > /dev/null 2>&1 && \ + ! ls /sys/class/net/wlan0 > /dev/null 2>&1 && \ + ! ls /sys/class/net/ath0 > /dev/null 2>&1 && \ + ! ls /sys/class/net/ra0 > /dev/null 2>&1 + then + panic "No supported network device found, maybe a non-mainline driver is required." + fi + done +} - if [ "${NFSROOT}" = "auto" ]; then - NFSROOT=${ROOTSERVER}:${ROOTPATH} - fi +do_netmount() +{ + do_netsetup + + if [ "${NFSROOT}" = "auto" ] + then + NFSROOT=${ROOTSERVER}:${ROOTPATH} + fi + + rc=1 + + if ( [ -n "${FETCH}" ] || [ -n "${HTTPFS}" ] || [ -n "${FTPFS}" ] ) + then + do_httpmount + return $? + fi + + if [ "${NFSROOT#*:}" = "${NFSROOT}" ] && [ "$NETBOOT" != "cifs" ] + then + NFSROOT=${ROOTSERVER}:${NFSROOT} + fi + + log_begin_msg "Trying netboot from ${NFSROOT}" + + if [ "${NETBOOT}" != "nfs" ] && do_cifsmount + then + rc=0 + elif do_nfsmount + then + NETBOOT="nfs" + export NETBOOT + rc=0 + fi + + log_end_msg + return ${rc} +} - [ "$quiet" != "y" ] && log_begin_msg "Trying netboot from ${NFSROOT}" +do_iscsi() +{ + do_netsetup + #modprobe ib_iser + modprobe iscsi_tcp + local debugopt="" + [ "${DEBUG}" == "Yes" ] && debugopt="-d 8" + #FIXME this name is supposed to be unique - some date + ifconfig hash? + ISCSI_INITIATORNAME="iqn.1993-08.org.debian.live:01:$(echo "${HWADDR}" | sed -e s/://g)" + export ISCSI_INITIATORNAME + if [ -n "${ISCSI_SERVER}" ] ; then + iscsistart $debugopt -i "${ISCSI_INITIATORNAME}" -t "${ISCSI_TARGET}" -g 1 -a "${ISCSI_SERVER}" -p "${ISCSI_PORT}" + else + iscsistart $debugopt -i "${ISCSI_INITIATORNAME}" -t "${ISCSI_TARGET}" -g 1 -a "${ISCSI_PORTAL}" -p 3260 + fi + if [ $? != 0 ] + then + panic "Failed to log into iscsi target" + fi + local host="$(ls -d /sys/class/scsi_host/host*/device/iscsi_host:host* \ + /sys/class/scsi_host/host*/device/iscsi_host/host* | sed -e 's:/device.*::' -e 's:.*host::')" + if [ -n "${host}" ] + then + local devices="" + local i=0 + while [ -z "${devices}" -a $i -lt 60 ] + do + sleep 1 + devices="$(ls -d /sys/class/scsi_device/${host}*/device/block:* \ + /sys/class/scsi_device/${host}*/device/block/* | sed -e 's!.*[:/]!!')" + i=$(expr $i + 1) + echo -ne $i\\r + done + for dev in $devices + do + if check_dev "null" "/dev/$dev" + then + NETBOOT="iscsi" + export NETBOOT + return 0; + fi + done + panic "Failed to locate a live device on iSCSI devices (tried: $devices)." + else + panic "Failed to locate iSCSI host in /sys" + fi +} - if [ "${NETBOOT}" != "nfs" ] && do_cifsmount ; then - rc=0 - elif do_nfsmount ; then - NETBOOT="nfs" - export NETBOOT - rc=0 - fi +do_httpmount () +{ + rc=1 + + for webfile in HTTPFS FTPFS FETCH + do + local url="$(eval echo \"\$\{${webfile}\}\")" + local extension="$(echo "${url}" | sed 's/\(.*\)\.\(.*\)/\2/')" + + if [ -n "$url" ] + then + case "${extension}" in + iso|squashfs|tgz|tar) + if [ "${extension}" = "iso" ] + then + mkdir -p "${alt_mountpoint}" + dest="${alt_mountpoint}" + else + local dest="${mountpoint}/${LIVE_MEDIA_PATH}" + mount -t ramfs ram "${mountpoint}" + mkdir -p "${dest}" + fi + if [ "${webfile}" = "FETCH" ] + then + case "$url" in + tftp*) + ip="$(dirname $url | sed -e 's|tftp://||g' -e 's|/.*$||g')" + rfile="$(echo $url | sed -e "s|tftp://$ip||g")" + lfile="$(basename $url)" + log_begin_msg "Trying tftp -g -b 10240 -r $rfile -l ${dest}/$lfile $ip" + tftp -g -b 10240 -r $rfile -l ${dest}/$lfile $ip + ;; + + *) + log_begin_msg "Trying wget ${url} -O ${dest}/$(basename ${url})" + wget "${url}" -O "${dest}/$(basename ${url})" + ;; + esac + else + log_begin_msg "Trying to mount ${url} on ${dest}/$(basename ${url})" + if [ "${webfile}" = "FTPFS" ] + then + FUSE_MOUNT="curlftpfs" + url="$(dirname ${url})" + else + FUSE_MOUNT="httpfs" + fi + modprobe fuse + $FUSE_MOUNT "${url}" "${dest}" + ROOT_PID="$(minips h -C "$FUSE_MOUNT" | { read x y ; echo "$x" ; } )" + fi + [ ${?} -eq 0 ] && rc=0 + [ "${extension}" = "tgz" ] && live_dest="ram" + if [ "${extension}" = "iso" ] + then + isoloop=$(setup_loop "${dest}/$(basename "${url}")" "loop" "/sys/block/loop*" "" '') + mount -t iso9660 "${isoloop}" "${mountpoint}" + rc=${?} + fi + break + ;; + + *) + log_begin_msg "Unrecognized archive extension for ${url}" + ;; + esac + fi + done + + if [ ${rc} != 0 ] + then + if [ -d "${alt_mountpoint}" ] + then + umount "${alt_mountpoint}" + rmdir "${alt_mountpoint}" + fi + umount "${mountpoint}" + elif [ "${webfile}" != "FETCH" ] ; then + NETBOOT="${webfile}" + export NETBOOT + fi - [ "$quiet" != "y" ] && log_end_msg - return ${rc} + return ${rc} } -do_nfsmount() { - rc=1 - modprobe "${MP_QUIET}" nfs - if [ -z "${NFSOPTS}" ]; then - NFSOPTS="" - fi - - [ "$quiet" != "y" ] && log_begin_msg "Trying nfsmount -o nolock -o ro ${NFSOPTS} ${NFSROOT} ${mountpoint}" - # FIXME: This for loop is an ugly HACK round an nfs bug - for i in 0 1 2 3 4 5 6 7 8 9 a b c d e f 10 11 12 13; do - nfsmount -o nolock -o ro ${NFSOPTS} "${NFSROOT}" "${mountpoint}" && rc=0 && break - sleep 1 - done - return ${rc} +do_nfsmount () +{ + rc=1 + + modprobe -q nfs + + if [ -z "${NFSOPTS}" ] + then + NFSOPTS="" + fi + + log_begin_msg "Trying nfsmount -o nolock -o ro ${NFSOPTS} ${NFSROOT} ${mountpoint}" + + # FIXME: This while loop is an ugly HACK round an nfs bug + i=0 + while [ "$i" -lt 60 ] + do + nfsmount -o nolock -o ro ${NFSOPTS} "${NFSROOT}" "${mountpoint}" && rc=0 && break + sleep 1 + i="$(($i + 1))" + done + + return ${rc} } -do_cifsmount() { - rc=1 - if [ -x "/sbin/mount.cifs" ]; then - if [ -z "${NFSOPTS}" ]; then - CIFSOPTS="-ouser=root,password=" - else - CIFSOPTS="${NFSOPTS}" - fi - - [ "$quiet" != "y" ] && log_begin_msg "Trying mount.cifs ${NFSROOT} ${mountpoint} ${CIFSOPTS}" - modprobe "${MP_QUIET}" cifs - - if mount.cifs "${NFSROOT}" "${mountpoint}" "${CIFSOPTS}" ; then - rc=0 - fi - fi - return ${rc} +do_cifsmount () +{ + rc=1 + + if [ -x "/sbin/mount.cifs" ] + then + if [ -z "${NFSOPTS}" ] + then + CIFSOPTS="-ouser=root,password=" + else + CIFSOPTS="${NFSOPTS}" + fi + + log_begin_msg "Trying mount.cifs ${NFSROOT} ${mountpoint} ${CIFSOPTS}" + modprobe -q cifs + + if mount.cifs "${NFSROOT}" "${mountpoint}" "${CIFSOPTS}" + then + rc=0 + fi + fi + + return ${rc} } do_snap_copy () { - fromdev="${1}" - todir="${2}" - snap_type="${3}" - - size=$(fs_size "${fromdev}" "" "used") - - if [ -b "${fromdev}" ]; then - # look for free mem - if [ -n "${HOMEMOUNTED}" -a "${snap_type}" = "HOME" ]; then - todev=$(cat /proc/mounts | grep -s " $(base_path ${todir}) " | awk '{print $1}' ) - freespace=$(df -k | grep -s ${todev} | awk '{print $4}') - else - freespace=$( expr $(awk '/MemFree/{print $2}' /proc/meminfo) + $( cat /proc/meminfo | grep Cached | head -n 1 | awk '/Cached/{print $2}' - )) - fi - - tomount="/mnt/tmpsnap" - if [ ! -d "${tomount}" ] ; then - mkdir -p "${tomount}" - fi - - fstype=$(get_fstype "${fromdev}") - if [ -n "${fstype}" ]; then - # Copying stuff... - mount -t "${fstype}" -o ro "${fromdev}" "${tomount}" - cp -a "${tomount}"/* ${todir} - umount "${tomount}" - else - log_warning_msg "Unrecognized fstype: ${fstype} on ${fromdev}:${snap_type}" - fi - - rmdir "${tomount}" - if echo ${fromdev} | grep -qs loop; then - losetup -d "${fromdev}" - fi - return 0 - else - return 1 - [ "$quiet" != "y" ] && log_warning_msg "Unable to find the snapshot ${snap_type} medium" - fi + fromdev="${1}" + todir="${2}" + snap_type="${3}" + size=$(fs_size "${fromdev}" "" "used") + + if [ -b "${fromdev}" ] + then + log_success_msg "Copying snapshot ${fromdev} to ${todir}..." + + # look for free mem + if [ -n "${HOMEMOUNTED}" -a "${snap_type}" = "HOME" ] + then + todev=$(awk -v pat="$(base_path ${todir})" '$2 == pat { print $1 }' /proc/mounts) + freespace=$(df -k | awk '/'${todev}'/{print $4}') + else + freespace=$(awk '/^MemFree:/{f=$2} /^Cached:/{c=$2} END{print f+c}' /proc/meminfo) + fi + + tomount="/mnt/tmpsnap" + + if [ ! -d "${tomount}" ] + then + mkdir -p "${tomount}" + fi + + fstype=$(get_fstype "${fromdev}") + + if [ -n "${fstype}" ] + then + # Copying stuff... + mount -o ro -t "${fstype}" "${fromdev}" "${tomount}" || log_warning_msg "Error in mount -t ${fstype} -o ro ${fromdev} ${tomount}" + cp -a "${tomount}"/* ${todir} + umount "${tomount}" + else + log_warning_msg "Unrecognized fstype: ${fstype} on ${fromdev}:${snap_type}" + fi + + rmdir "${tomount}" + + if echo ${fromdev} | grep -qs loop + then + losetup -d "${fromdev}" + fi + + return 0 + else + log_warning_msg "Unable to find the snapshot ${snap_type} medium" + return 1 + fi +} + +find_snap () +{ + # Look for ${snap_label}.* in block devices + snap_label="${1}" + black_listed_devices="${2}" + + if [ "${PERSISTENT}" != "nofiles" ] + then + # search for image files + snapdata=$(find_files "${PERSISTENT_PATH}${snap_label}.squashfs ${PERSISTENT_PATH}${snap_label}.cpio.gz ${PERSISTENT_PATH}${snap_label}.ext2 ${PERSISTENT_PATH}${snap_label}.ext3 ${PERSISTENT_PATH}${snap_label}.ext4 ${PERSISTENT_PATH}${snap_label}.jffs2" "${black_listed_devices}") + fi + + if [ -z "${snapdata}" ] + then + snapdata=$(find_cow_device "${snap_label}" "${black_listed_devices}") + fi + echo "${snapdata}" } try_snap () { - # Look for $snap_label.* in block devices and copy the contents to $snap_mount - # and remember the device and filename for resync on exit in live-initramfs.init - - snap_label="${1}" - snap_mount="${2}" - snap_type="${3}" - - snapdata=$(find_files "${snap_label}.squashfs ${snap_label}.cpio.gz ${snap_label}.ext2 ${snap_label}.ext3") - if [ ! -z "${snapdata}" ]; then - snapdev="$(echo ${snapdata} | cut -f1 -d ' ')" - snapback="$(echo ${snapdata} | cut -f2 -d ' ')" - snapfile="$(echo ${snapdata} | cut -f3 -d ' ')" - if echo "${snapfile}" | grep -qs '\(squashfs\|ext2\|ext3\)'; then - # squashfs or ext2/ext3 snapshot - dev=$(get_backing_device "${snapback}/${snapfile}") - if ! do_snap_copy "${dev}" "${snap_mount}" "${snap_type}"; then - log_warning_msg "Impossible to include the ${snapfile} Snapshot" - return 1 - fi - else - # cpio.gz snapshot - if ! (cd "${snap_mount}" && zcat "${snapback}/${snapfile}" | cpio -i -u -d 2>/dev/null) ; then - log_warning_msg "Impossible to include the ${snapfile} Snapshot" - return 1 - fi - fi - umount "${snapback}" - else - dev=$(find_cow_device "${snap_label}") - if [ -b ${dev} ]; then - if echo "${dev}" | grep -qs loop; then - # strange things happens, user confused? - snaploop=$( losetup ${dev} | awk '{print $3}' | tr -d '()' ) - snapfile=$(basename ${snaploop}) - snapdev=$(cat /proc/mounts | awk '{print $2,$1}' | grep -es "^$( dirname ${snaploop} )" | cut -f2 -d ' ') - else - snapdev="${dev}" - fi - if ! do_snap_copy "${dev}" "${snap_mount}" "${snap_type}" ; then - log_warning_msg "Impossible to include the ${snap_label} Snapshot" - return 1 - else - if [ -n "${snapfile}" ]; then - # it was a loop device, user confused - umount ${snapdev} - fi - fi - else - log_warning_msg "Impossible to include the ${snap_label} Snapshot" - return 1 - fi - fi - echo "export ${snap_type}SNAP="${snap_mount}":${snapdev}:${snapfile}" >> /etc/live.conf # for resync on reboot/halt - return 0 + # copy the contents of previously found snapshot to ${snap_mount} + # and remember the device and filename for resync on exit in live-boot.init + + snapdata="${1}" + snap_mount="${2}" + snap_type="${3}" + snap_relpath="${4}" + + if [ -z "${snap_relpath}" ] + then + # root snapshot, default usage + snap_relpath="/" + else + # relative snapshot (actually used just for "/home" snapshots) + snap_mount="${2}${snap_relpath}" + fi + + if [ -n "${snapdata}" ] && [ ! -b "${snapdata}" ] + then + log_success_msg "found snapshot: ${snapdata}" + snapdev="$(echo ${snapdata} | cut -f1 -d ' ')" + snapback="$(echo ${snapdata} | cut -f2 -d ' ')" + snapfile="$(echo ${snapdata} | cut -f3 -d ' ')" + + if ! try_mount "${snapdev}" "${snapback}" "ro" + then + break + fi + + RES="0" + + if echo "${snapfile}" | grep -qs '\(squashfs\|ext2\|ext3\|ext4\|jffs2\)' + then + # squashfs, jffs2 or ext2/ext3/ext4 snapshot + dev=$(get_backing_device "${snapback}/${snapfile}") + + do_snap_copy "${dev}" "${snap_mount}" "${snap_type}" + RES="$?" + else + # cpio.gz snapshot + + # Unfortunately klibc's cpio is incompatible with the + # rest of the world; everything else requires -u -d, + # while klibc doesn't implement them. Try to detect + # whether it's in use. + cpiopath="$(which cpio)" || true + if [ "$cpiopath" ] && grep -aq /lib/klibc "$cpiopath" + then + cpioargs= + else + cpioargs='--unconditional --make-directories' + fi + + if [ -s "${snapback}/${snapfile}" ] + then + BEFOREDIR="$(pwd)" + cd "${snap_mount}" && zcat "${snapback}/${snapfile}" | $cpiopath $cpioargs --extract --preserve-modification-time --no-absolute-filenames --sparse 2>/dev/null + RES="$?" + cd "${BEFOREDIR}" + else + log_warning_msg "${snapback}/${snapfile} is empty, adding it for sync on reboot." + RES="0" + fi + + if [ "${RES}" != "0" ] + then + log_warning_msg "failure to \"zcat ${snapback}/${snapfile} | $cpiopath $cpioargs --extract --preserve-modification-time --no-absolute-filenames --sparse\"" + fi + fi + + umount "${snapback}" || log_warning_msg "failure to \"umount ${snapback}\"" + + if [ "${RES}" != "0" ] + then + log_warning_msg "Impossible to include the ${snapfile} Snapshot file" + fi + + elif [ -b "${snapdata}" ] + then + # Try to find if it could be a snapshot partition + dev="${snapdata}" + log_success_msg "found snapshot ${snap_type} device on ${dev}" + if echo "${dev}" | grep -qs loop + then + # strange things happens, user confused? + snaploop=$( losetup ${dev} | awk '{print $3}' | tr -d '()' ) + snapfile=$(basename ${snaploop}) + snapdev=$(awk -v pat="$( dirname ${snaploop})" '$2 == pat { print $1 }' /proc/mounts) + else + snapdev="${dev}" + fi + + if ! do_snap_copy "${dev}" "${snap_mount}" "${snap_type}" + then + log_warning_msg "Impossible to include the ${snap_type} Snapshot (i)" + return 1 + else + if [ -n "${snapfile}" ] + then + # it was a loop device, user confused + umount ${snapdev} + fi + fi + else + log_warning_msg "Impossible to include the ${snap_type} Snapshot (o)" + return 1 + fi + + echo "export ${snap_type}SNAP=${snap_relpath}:${snapdev}:${snapfile}" >> snapshot.conf # for resync on reboot/halt + return 0 } -setup_unionfs() { - image_directory="$1" - rootmnt="$2" - - modprobe "${MP_QUIET}" -b unionfs - - # run-init can't deal with images in a subdir, but we're going to - # move all of these away before it runs anyway. No, we're not, - # put them in / since move-mounting them into / breaks mono and - # some other apps. - - croot="/" - - # Let's just mount the read-only file systems first - rofsstring="" - rofslist="" - if [ "${NETBOOT}" = "nfs" ] ; then - roopt="nfsro" # go aroung a bug in nfs-unionfs locking - else - roopt="ro" - fi - - # Read image names from ${MODULE}.lst if it exists - if [ -e "${image_directory}/${MODULE}.lst" ]; then - for image in $(cat "${image_directory}/${MODULE}.lst"); do - image_string="${image_string} ${image_directory}/${image}"; - done - else - # If ${MODULE}.lst does not exist, create a list of images - for image_type in "ext2" "ext3" "squashfs" "dir"; do - for image in "${image_directory}"/*."${image_type}"; do - if [ -e "${image}" ]; then - image_string="${image_string} ${image}"; - fi - done - done - # Now sort the list - image_string=$(echo ${image_string} | sed -e 's/ /\n/g' | sort ) - fi - - mkdir -p "${croot}" - for image in ${image_string}; do - imagename=$(basename "${image}") - if [ -d "${image}" ]; then - # it is a plain directory: do nothing - rofsstring="${image}=${roopt}:${rofsstring}" - rofslist="${image} ${rofslist}" - elif [ -f "${image}" ]; then - backdev=$(get_backing_device "$image") - fstype=$(get_fstype "${backdev}") - if [ "${fstype}" = "unknown" ]; then - panic "Unknown file system type on ${backdev} (${image})" - fi - mkdir -p "${croot}/${imagename}" - mount -t "${fstype}" -o ro "${backdev}" "${croot}/${imagename}" || panic "Can not mount $backdev ($image) on ${croot}/${imagename}" && rofsstring="${croot}/${imagename}=${roopt}:${rofsstring}" && rofslist="${croot}/${imagename} ${rofslist}" - fi - done - rofsstring=${rofsstring%:} - - mkdir -p /cow - cowdevice="tmpfs" - cow_fstype="tmpfs" - - # Looking for "${root_persistence}" device or file - if [ -n "${PERSISTENT}" ]; then - cowprobe=$(find_cow_device "${root_persistence}") - if [ -b "${cowprobe}" ]; then - cowdevice=${cowprobe} - cow_fstype=$(get_fstype "${cowprobe}") - else - [ "$quiet" != "y" ] && log_warning_msg "Unable to find the persistent medium" - fi - fi - - mount ${cowdevice} -t ${cow_fstype} -o rw /cow || panic "Can not mount $cowdevice on /cow" - - mount -t unionfs -o dirs=/cow=rw:$rofsstring unionfs "$rootmnt" || panic "Unionfs mount failed" - - # Adding other custom mounts - if [ -n "${PERSISTENT}" ]; then - # directly mount /home - # FIXME: add a custom mounts configurable system - homecow=$(find_cow_device "${home_persistence}" ) - if [ -b "${homecow}" ]; then - mount -t $(get_fstype "${homecow}") -o rw "${homecow}" "${rootmnt}/home" - export HOMEMOUNTED=1 # used to proper calculate free space in do_snap_copy() - else - [ "$quiet" != "y" ] && log_warning_msg "Unable to find the persistent home medium" - fi - # Look for other snapshots to copy in - try_snap "${root_snapshot_label}" "${rootmnt}" "ROOT" - try_snap "${home_snapshot_label}" "${rootmnt}/home" "HOME" - fi - - if [ -n "${SHOWMOUNTS}" ]; then - for d in ${rofslist}; do - mkdir -p "${rootmnt}/live/${d##*/}" - case d in - *.dir) # do nothing # mount -o bind "${d}" "${rootmnt}/live/${d##*/}" - ;; - *) mount --move "${d}" "${rootmnt}/live/${d##*/}" - ;; - esac - done - fi - - # shows cow fs on /cow for use by live-snapshot - mkdir -p "${rootmnt}/cow" - mount -o bind /cow "${rootmnt}/cow" +setup_unionfs () +{ + image_directory="${1}" + rootmnt="${2}" + addimage_directory="${3}" + + case ${UNIONTYPE} in + aufs|unionfs) + modprobe -q -b ${UNIONTYPE} + + if ! cut -f2 /proc/filesystems | grep -q "^${UNIONTYPE}\$" && [ -x /bin/unionfs-fuse ] + then + echo "${UNIONTYPE} not available, falling back to unionfs-fuse." + echo "This might be really slow." + + UNIONTYPE="unionfs-fuse" + fi + ;; + esac + + if [ "${UNIONTYPE}" = unionfs-fuse ] + then + modprobe fuse + fi + + # run-init can't deal with images in a subdir, but we're going to + # move all of these away before it runs anyway. No, we're not, + # put them in / since move-mounting them into / breaks mono and + # some other apps. + + croot="/" + + # Let's just mount the read-only file systems first + rofslist="" + + if [ "${UNIONTYPE}" = "aufs" ] + then + roopt="rr" + noxino_opt="noxino," + elif [ "${UNIONTYPE}" = "unionfs-fuse" ] + then + roopt="RO" + else + roopt="ro" + fi + + if [ -z "${PLAIN_ROOT}" ] + then + # Read image names from ${MODULE}.module if it exists + if [ -e "${image_directory}/filesystem.${MODULE}.module" ] + then + for IMAGE in $(cat ${image_directory}/filesystem.${MODULE}.module) + do + image_string="${image_string} ${image_directory}/${IMAGE}" + done + elif [ -e "${image_directory}/${MODULE}.module" ] + then + for IMAGE in $(cat ${image_directory}/${MODULE}.module) + do + image_string="${image_string} ${image_directory}/${IMAGE}" + done + else + # ${MODULE}.module does not exist, create a list of images + for FILESYSTEM in squashfs ext2 ext3 ext4 xfs jffs2 dir + do + for IMAGE in "${image_directory}"/*."${FILESYSTEM}" + do + if [ -e "${IMAGE}" ] + then + image_string="${image_string} ${IMAGE}" + fi + done + done + + if [ -n "${addimage_directory}" ] && [ -d "${addimage_directory}" ] + then + for FILESYSTEM in squashfs ext2 ext3 ext4 xfs jffs2 dir + do + for IMAGE in "${addimage_directory}"/*."${FILESYSTEM}" + do + if [ -e "${IMAGE}" ] + then + image_string="${image_string} ${IMAGE}" + fi + done + done + fi + + # Now sort the list + image_string="$(echo ${image_string} | sed -e 's/ /\n/g' | sort )" + fi + + [ -n "${MODULETORAMFILE}" ] && image_string="${image_directory}/$(basename ${MODULETORAMFILE})" + + mkdir -p "${croot}" + + for image in ${image_string} + do + imagename=$(basename "${image}") + + export image devname + maybe_break live-realpremount + log_begin_msg "Running /scripts/live-realpremount" + run_scripts /scripts/live-realpremount + log_end_msg + + if [ -d "${image}" ] + then + # it is a plain directory: do nothing + rofslist="${image} ${rofslist}" + elif [ -f "${image}" ] + then + if losetup --help 2>&1 | grep -q -- "-r\b" + then + backdev=$(get_backing_device "${image}" "-r") + else + backdev=$(get_backing_device "${image}") + fi + fstype=$(get_fstype "${backdev}") + + if [ "${fstype}" = "unknown" ] + then + panic "Unknown file system type on ${backdev} (${image})" + fi + + if [ -z "${fstype}" ] + then + fstype="${imagename##*.}" + log_warning_msg "Unknown file system type on ${backdev} (${image}), assuming ${fstype}." + fi + + if [ "${UNIONTYPE}" != "unionmount" ] + then + mpoint="${croot}/${imagename}" + rofslist="${mpoint} ${rofslist}" + else + mpoint="${rootmnt}" + rofslist="${rootmnt} ${rofslist}" + fi + mkdir -p "${mpoint}" + log_begin_msg "Mounting \"${image}\" on \"${mpoint}\" via \"${backdev}\"" + mount -t "${fstype}" -o ro,noatime "${backdev}" "${mpoint}" || panic "Can not mount ${backdev} (${image}) on ${mpoint}" + log_end_msg + fi + done + else + # we have a plain root system + mkdir -p "${croot}/filesystem" + log_begin_msg "Mounting \"${image_directory}\" on \"${croot}/filesystem\"" + mount -t $(get_fstype "${image_directory}") -o ro,noatime "${image_directory}" "${croot}/filesystem" || \ + panic "Can not mount ${image_directory} on ${croot}/filesystem" && \ + rofslist="${croot}/filesystem ${rofslist}" + # probably broken: + mount -o bind ${croot}/filesystem $mountpoint + log_end_msg + fi + + mkdir -p /cow + + # Looking for "${root_persistence}" device or file + if [ -n "${PERSISTENT}" ] && [ -z "${NOPERSISTENT}" ] + then + if [ -z "${QUICKUSBMODULES}" ] + then + # Load USB modules + num_block=$(ls -l /sys/block | wc -l) + for module in sd_mod uhci-hcd ehci-hcd ohci-hcd usb-storage + do + modprobe -q -b ${module} + done + + udevadm trigger + udevadm settle + + # For some reason, udevsettle does not block in this scenario, + # so we sleep for a little while. + # + # See https://bugs.launchpad.net/ubuntu/+source/casper/+bug/84591 + for timeout in 5 4 3 2 1 + do + sleep 1 + + if [ $(ls -l /sys/block | wc -l) -gt ${num_block} ] + then + break + fi + done + fi + + # search for label and files (this could be hugely optimized) + cowprobe=$(find_cow_device "${root_persistence}") + if [ -b "${cowprobe}" ] + then + # Blacklist /cow device, to avoid inconsistent setups for overlapping snapshots + # makes sense to have both persistence for /cow and /home mounted, maybe also with + # snapshots to be sure to really store some e.g key config files, + # but not on the same media + blacklistdev="${cowprobe}" + PERSISTENCE_IS_ON="1" + export PERSISTENCE_IS_ON + fi + # homecow just mount something on /home, this should be generalized some way + homecow=$(find_cow_device "${home_persistence}" "${blacklistdev}") + if [ -b "${homecow}" ] + then + PERSISTENCE_IS_ON="1" + export PERSISTENCE_IS_ON + fi + root_snapdata=$(find_snap "${root_snapshot_label}" "${blacklistdev}") + # This second type should be removed when snapshot will get smarter, + # hence when "/etc/live-snapshot*list" will be supported also by + # ext2|ext3|ext4|jffs2 snapshot types. + home_snapdata=$(find_snap "${home_snapshot_label}" "${blacklistdev}") + + if [ -b "${cowprobe}" ] + then + cowdevice=${cowprobe} + cow_fstype=$(get_fstype "${cowprobe}") + cow_mountopt="rw,noatime" + + if [ "${FORCEPERSISTENTFSCK}" = "Yes" ] + then + fsck -y ${cowdevice} + fi + else + log_warning_msg "Unable to find the persistent medium" + cowdevice="tmpfs" + cow_fstype="tmpfs" + cow_mountopt="rw,noatime,mode=755" + fi + elif [ -n "${NFS_COW}" ] && [ -z "${NOPERSISTENT}" ] + then + # check if there are any nfs options + if echo ${NFS_COW}|grep -q ',' + then + nfs_cow_opts="-o nolock,$(echo ${NFS_COW}|cut -d, -f2-)" + nfs_cow=$(echo ${NFS_COW}|cut -d, -f1) + else + nfs_cow_opts="-o nolock" + nfs_cow=${NFS_COW} + fi + mac="$(get_mac)" + if [ -n "${mac}" ] + then + cowdevice=$(echo ${nfs_cow}|sed "s/client_mac_address/${mac}/") + cow_fstype="nfs" + else + panic "unable to determine mac address" + fi + else + cowdevice="tmpfs" + cow_fstype="tmpfs" + cow_mountopt="rw,noatime,mode=755" + fi + + if [ "${UNIONTYPE}" != "unionmount" ] + then + + if [ "${cow_fstype}" = "nfs" ] + then + log_begin_msg \ + "Trying nfsmount ${nfs_cow_opts} ${cowdevice} /cow" + nfsmount ${nfs_cow_opts} ${cowdevice} /cow || \ + panic "Can not mount ${cowdevice} (n: ${cow_fstype}) on /cow" + else + mount -t ${cow_fstype} -o ${cow_mountopt} ${cowdevice} /cow || \ + panic "Can not mount ${cowdevice} (o: ${cow_fstype}) on /cow" + fi + fi + + rofscount=$(echo ${rofslist} |wc -w) + + if [ ${rofscount} -ne 1 ] + then + panic "only one RO file system supported with exposedroot: ${rofslist}" + fi + rofs=${rofslist%% } + + if [ -n "${EXPOSED_ROOT}" ] + then + mount --bind ${rofs} ${rootmnt} || \ + panic "bind mount of ${rofs} failed" + + if [ -z "${SKIP_UNION_MOUNTS}" ] + then + cow_dirs='/var/tmp /var/lock /var/run /var/log /var/spool /home /var/lib/live' + else + cow_dirs='' + fi + else + cow_dirs="/" + fi + + if [ "${cow_fstype}" != "tmpfs" ] && [ "${cow_dirs}" != "/" ] && [ "${UNIONTYPE}" = "unionmount" ] + then + true # FIXME: Maybe it does, I don't really know. + #panic "unionmount does not support subunions (${cow_dirs})." + fi + + unionmountopts="" + unionmountpoint="" + + for dir in ${cow_dirs}; do + mkdir -p /cow${dir} + + unionmountpoint="${rootmnt}${dir}" + unionrw="/cow${dir}" + unionro="${rofs}${dir}" + # We don't handle spaces and other junk gracefully here, hopefully not needed. + case "${UNIONTYPE}" in + unionfs-fuse) + unionmountopts="-o cow -o noinitgroups -o default_permissions -o allow_other -o use_ino -o suid" + unionmountopts="${unionmountopts} ${unionrw}=RW:${unionro}=RO" + ( sysctl -w fs.file-max=391524 ; ulimit -HSn 16384 + unionfs-fuse ${unionmountopts} "${unionmountpoint}" ) && \ + ( mkdir -p /run/initramfs + pidof unionfs-fuse >> /run/initramfs/sendsigs.omit || true ) + ;; + + unionmount) + unionmountopts="-t ${cow_fstype} -o noatime,union,${cow_mountopt} ${cowdevice}" + mount_full $unionmountopts "${unionmountpoint}" + ;; + + + *) + unionmountopts="-o noatime,${noxino_opt}dirs=${unionrw}=rw:${unionro}=${roopt}" + mount -t ${UNIONTYPE} ${unionmountopts} ${UNIONTYPE} "${unionmountpoint}" + ;; + esac || \ + panic "mount ${UNIONTYPE} on ${unionmountpoint} failed with option ${unionmountopts}" + done + + # Correct the permissions of /: + chmod 0755 "${rootmnt}" + + # tmpfs file systems + touch /etc/fstab + mkdir -p "${rootmnt}/live" + mount -t tmpfs tmpfs ${rootmnt}/live + + # Adding other custom mounts + if [ -n "${PERSISTENT}" ] && [ -z "${NOPERSISTENT}" ] + then + # directly mount /home + # FIXME: add a custom mounts configurable system + + if [ -b "${homecow}" ] + then + mount -t $(get_fstype "${homecow}") -o rw,noatime "${homecow}" "${rootmnt}/home" + export HOMEMOUNTED=1 # used to proper calculate free space in do_snap_copy() + else + log_warning_msg "Unable to find the persistent home medium" + fi + + # Look for other snapshots to copy in + try_snap "${root_snapdata}" "${rootmnt}" "ROOT" + # This second type should be removed when snapshot grow smarter + try_snap "${home_snapdata}" "${rootmnt}" "HOME" "/home" + fi + + if [ -n "${SHOWMOUNTS}" ] + then + for d in ${rofslist} + do + mkdir -p "${rootmnt}/live/${d##*/}" + + case d in + *.dir) + # do nothing # mount -o bind "${d}" "${rootmnt}/live/${d##*/}" + ;; + + *) + case "${UNIONTYPE}" in + unionfs-fuse) + mount -o bind "${d}" "${rootmnt}/live/${d##*/}" + ;; + + *) + mount -o move "${d}" "${rootmnt}/live/${d##*/}" + ;; + esac + ;; + esac + done + fi + + # shows cow fs on /cow for use by live-snapshot + mkdir -p "${rootmnt}/live/cow" + mount -o move /cow "${rootmnt}/live/cow" >/dev/null 2>&1 || mount -o bind /cow "${rootmnt}/live/cow" || log_warning_msg "Unable to move or bind /cow to ${rootmnt}/live/cow" } check_dev () { - sysdev="${1}" - devname="${2}" - if [ -z "${devname}" ]; then - devname=$(sys2dev "${sysdev}") - fi - - if [ -n "${LIVE_MEDIA_OFFSET}" ]; then - loopdevname=$(setup_loop "${devname}" "loop" "/sys/block/loop*" "${LIVE_MEDIA_OFFSET}" '') - devname="${loopdevname}" - fi - - fstype=$(get_fstype "${devname}") - if is_supported_fs ${fstype}; then - mount -t ${fstype} -o ro "${devname}" $mountpoint || continue - if is_live_path $mountpoint; then - echo $mountpoint - return 0 - else - umount $mountpoint - fi - fi - - if [ -n "${LIVE_MEDIA_OFFSET}" ]; then - losetup -d "${loopdevname}" - fi - return 1 -} + sysdev="${1}" + devname="${2}" + skip_uuid_check="${3}" + + # support for fromiso=.../isofrom=.... + if [ -n "$FROMISO" ] + then + ISO_DEVICE=$(dirname $FROMISO) + if ! [ -b $ISO_DEVICE ] + then + # to support unusual device names like /dev/cciss/c0d0p1 + # as well we have to identify the block device name, let's + # do that for up to 15 levels + i=15 + while [ -n "$ISO_DEVICE" ] && [ "$i" -gt 0 ] + do + ISO_DEVICE=$(dirname ${ISO_DEVICE}) + [ -b "$ISO_DEVICE" ] && break + i=$(($i -1)) + done + fi + + if [ "$ISO_DEVICE" = "/" ] + then + echo "Warning: device for bootoption isofrom= ($FROMISO) not found.">>/live-boot.log + else + fs_type=$(get_fstype "${ISO_DEVICE}") + if is_supported_fs ${fs_type} + then + mkdir /isofrom + mount -t $fs_type "$ISO_DEVICE" /isofrom + ISO_NAME="$(echo $FROMISO | sed "s|$ISO_DEVICE||")" + loopdevname=$(setup_loop "/isofrom/${ISO_NAME}" "loop" "/sys/block/loop*" "" '') + devname="${loopdevname}" + else + echo "Warning: unable to mount $ISO_DEVICE." >>/live.log + fi + fi + fi + + if [ -z "${devname}" ] + then + devname=$(sys2dev "${sysdev}") + fi + + if [ -d "${devname}" ] + then + mount -o bind "${devname}" $mountpoint || continue + + if is_live_path $mountpoint + then + echo $mountpoint + return 0 + else + umount $mountpoint + fi + fi + [ -e "$devname" ] || continue + + if [ -n "${LIVE_MEDIA_OFFSET}" ] + then + loopdevname=$(setup_loop "${devname}" "loop" "/sys/block/loop*" "${LIVE_MEDIA_OFFSET}" '') + devname="${loopdevname}" + fi + + fstype=$(get_fstype "${devname}") + + if is_supported_fs ${fstype} + then + devuid=$(blkid -o value -s UUID "$devname") + [ -n "$devuid" ] && grep -qs "\<$devuid\>" $tried && continue + mount -t ${fstype} -o ro,noatime "${devname}" ${mountpoint} || continue + [ -n "$devuid" ] && echo "$devuid" >> $tried + + if is_live_path ${mountpoint} && \ + ([ "${skip_uuid_check}" ] || matches_uuid ${mountpoint}) + then + echo ${mountpoint} + return 0 + else + umount ${mountpoint} + fi + fi -find_livefs() { - timeout="${1}" - # first look at the one specified in the command line - if [ ! -z "${LIVE_MEDIA}" ]; then - if check_dev "null" "${LIVE_MEDIA}"; then - return 0 - fi - fi - # don't start autodetection before timeout has expired - if [ -n "${LIVE_MEDIA_TIMEOUT}" ]; then - if [ "${timeout}" -lt "${LIVE_MEDIA_TIMEOUT}" ]; then - return 1 - fi - fi - # or do the scan of block devices - for sysblock in $(echo /sys/block/* | tr ' ' '\n' | grep -v loop | grep -v ram); do - devname=$(sys2dev "${sysblock}") - fstype=$(get_fstype "${devname}") - if /lib/udev/cdrom_id ${devname} > /dev/null; then - if check_dev "null" "${devname}" ; then - return 0 - fi - elif is_nice_device "${sysblock}" ; then - for dev in $(subdevices "${sysblock}"); do - if check_dev "${dev}" ; then - return 0 - fi - done - elif [ "${fstype}" = "squashfs" -o \ - "${fstype}" = "ext2" -o \ - "${fstype}" = "ext3" ]; then - # This is an ugly hack situation, the block device has - # an image directly on it. It's hopefully - # live-initramfs, so take it and run with it. - ln -s "${devname}" "${devname}.${fstype}" - echo "${devname}.${fstype}" - return 0 - fi - done - return 1 + if [ -n "${LIVE_MEDIA_OFFSET}" ] + then + losetup -d "${loopdevname}" + fi + + return 1 } -pulsate() { - if [ -x /sbin/usplash_write ]; then - /sbin/usplash_write "PULSATE" - fi +find_livefs () +{ + timeout="${1}" + + # don't start autodetection before timeout has expired + if [ -n "${LIVE_MEDIA_TIMEOUT}" ] + then + if [ "${timeout}" -lt "${LIVE_MEDIA_TIMEOUT}" ] + then + return 1 + fi + fi + + # first look at the one specified in the command line + case "${LIVE_MEDIA}" in + removable-usb) + for sysblock in $(echo /sys/block/* | tr ' ' '\n' | grep -vE "/(loop|ram|dm-|fd)") + do + if [ "$(cat ${sysblock}/removable)" = "1" ] + then + if readlink ${sysblock} | grep -q usb + then + for dev in $(subdevices "${sysblock}") + do + if check_dev "${dev}" + then + return 0 + fi + done + fi + fi + done + return 1 + ;; + + removable) + for sysblock in $(echo /sys/block/* | tr ' ' '\n' | grep -vE "/(loop|ram|dm-|fd)") + do + if [ "$(cat ${sysblock}/removable)" = "1" ] + then + for dev in $(subdevices "${sysblock}") + do + if check_dev "${dev}" + then + return 0 + fi + done + fi + done + return 1 + ;; + + *) + if [ ! -z "${LIVE_MEDIA}" ] + then + if check_dev "null" "${LIVE_MEDIA}" "skip_uuid_check" + then + return 0 + fi + fi + ;; + esac + + # or do the scan of block devices + # prefer removable devices over non-removable devices, so scan them first + for sysblock in $(echo /sys/block/* | tr ' ' '\n' | egrep -v "/(loop|ram|dm-|fd)") + do + if [ "$(cat ${sysblock}/removable)" = "1" ] + then + removable_devices_to_scan="$removable_devices_to_scan $sysblock" + else + nonremovable_devices_to_scan="$nonremovable_devices_to_scan $sysblock" + fi + done + devices_to_scan="$removable_devices_to_scan $nonremovable_devices_to_scan" + + for sysblock in $devices_to_scan + do + devname=$(sys2dev "${sysblock}") + [ -e "$devname" ] || continue + fstype=$(get_fstype "${devname}") + + if /lib/udev/cdrom_id ${devname} > /dev/null + then + if check_dev "null" "${devname}" + then + return 0 + fi + elif is_nice_device "${sysblock}" + then + for dev in $(subdevices "${sysblock}") + do + if check_dev "${dev}" + then + return 0 + fi + done + elif [ "${fstype}" = "squashfs" -o \ + "${fstype}" = "btrfs" -o \ + "${fstype}" = "ext2" -o \ + "${fstype}" = "ext3" -o \ + "${fstype}" = "ext4" -o \ + "${fstype}" = "jffs2" ] + then + # This is an ugly hack situation, the block device has + # an image directly on it. It's hopefully + # live-boot, so take it and run with it. + ln -s "${devname}" "${devname}.${fstype}" + echo "${devname}.${fstype}" + return 0 + fi + done + + return 1 } -set_usplash_timeout() { - if [ -x /sbin/usplash_write ]; then - /sbin/usplash_write "TIMEOUT 120" - fi +integrity_check () +{ + media_mountpoint="${1}" + + log_begin_msg "Checking media integrity" + + cd ${media_mountpoint} + /bin/md5sum -c md5sum.txt < /dev/tty8 > /dev/tty8 + RC="${?}" + + log_end_msg + + if [ "${RC}" -eq 0 ] + then + log_success_msg "Everything ok, will reboot in 10 seconds." + sleep 10 + cd / + umount ${media_mountpoint} + sync + echo u > /proc/sysrq-trigger + echo b > /proc/sysrq-trigger + else + panic "Not ok, a media defect is likely, switch to VT8 for details." + fi } -mountroot() { - exec 6>&1 - exec 7>&2 - exec > live.log - exec 2>&1 - - parse_cmdline - - set_usplash_timeout - [ "$quiet" != "y" ] && log_begin_msg "Running /scripts/live-premount" - pulsate - run_scripts /scripts/live-premount - [ "$quiet" != "y" ] && log_end_msg - - # Needed here too because some things (*cough* udev *cough*) - # changes the timeout - - set_usplash_timeout - - if [ ! -z "${NETBOOT}" ]; then - if do_netmount ; then - livefs_root="${mountpoint}" - else - panic "Unable to find a live file system on the network" - fi - else - # Scan local devices for the image - for i in 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19; do - livefs_root=$(find_livefs $i) - if [ -n "${livefs_root}" ]; then - break - fi - sleep 1 - done - fi - - if [ -z "${livefs_root}" ]; then - panic "Unable to find a medium containing a live file system" - fi - - if [ "${TORAM}" ]; then - live_dest="ram" - elif [ "${TODISK}" ]; then - live_dest="${TODISK}" - fi - if [ "${live_dest}" ]; then - log_begin_msg "Copying live_media to ${live_dest}" - copy_live_to "${livefs_root}" "${live_dest}" - log_end_msg - fi - - mount_images_in_directory "${livefs_root}" "${rootmnt}" - - log_end_msg - - maybe_break live-bottom - [ "$quiet" != "y" ] && log_begin_msg "Running /scripts/live-bottom" - - pulsate - run_scripts /scripts/live-bottom - [ "$quiet" != "y" ] && log_end_msg - - exec 1>&6 6>&- - exec 2>&7 7>&- - cp live.log "${rootmnt}/var/log/" +mountroot () +{ + if [ -x /scripts/local-top/cryptroot ]; then + /scripts/local-top/cryptroot + fi + + exec 6>&1 + exec 7>&2 + exec > live-boot.log + exec 2>&1 + tail -f live-boot.log >&7 & + tailpid="${!}" + + # Ensure 'panic' function is overridden + . /scripts/live-functions + + Arguments + + maybe_break live-premount + log_begin_msg "Running /scripts/live-premount" + run_scripts /scripts/live-premount + log_end_msg + + # Needed here too because some things (*cough* udev *cough*) + # changes the timeout + + if [ ! -z "${NETBOOT}" ] || [ ! -z "${FETCH}" ] || [ ! -z "${HTTPFS}" ] || [ ! -z "${FTPFS}" ] + then + if do_netmount + then + livefs_root="${mountpoint}" + else + panic "Unable to find a live file system on the network" + fi + else + if [ -n "${ISCSI_PORTAL}" ] + then + do_iscsi && livefs_root="${mountpoint}" + elif [ -n "${PLAIN_ROOT}" ] && [ -n "${ROOT}" ] + then + # Do a local boot from hd + livefs_root=${ROOT} + else + if [ -x /usr/bin/memdiskfind ] + then + MEMDISK=$(/usr/bin/memdiskfind) + + if [ $? -eq 0 ] + then + # We found a memdisk, set up phram + modprobe phram phram=memdisk,${MEMDISK} + + # Load mtdblock, the memdisk will be /dev/mtdblock0 + modprobe mtdblock + fi + fi + + # Scan local devices for the image + i=0 + while [ "$i" -lt 60 ] + do + livefs_root=$(find_livefs ${i}) + + if [ -n "${livefs_root}" ] + then + break + fi + + sleep 1 + i="$(($i + 1))" + done + fi + fi + + if [ -z "${livefs_root}" ] + then + panic "Unable to find a medium containing a live file system" + fi + + if [ "${INTEGRITY_CHECK}" ] + then + integrity_check "${livefs_root}" + fi + + if [ "${TORAM}" ] + then + live_dest="ram" + elif [ "${TODISK}" ] + then + live_dest="${TODISK}" + fi + + if [ "${live_dest}" ] + then + log_begin_msg "Copying live media to ${live_dest}" + copy_live_to "${livefs_root}" "${live_dest}" + log_end_msg + fi + + # if we do not unmount the ISO we can't run "fsck /dev/ice" later on + # because the mountpoint is left behind in /proc/mounts, so let's get + # rid of it when running from RAM + if [ -n "$FROMISO" ] && [ "${TORAM}" ] + then + losetup -d /dev/loop0 + grep -q /isofrom /proc/mounts && umount /isofrom + fi + + if [ -n "${MODULETORAMFILE}" ] || [ -n "${PLAIN_ROOT}" ] + then + setup_unionfs "${livefs_root}" "${rootmnt}" + else + mac="$(get_mac)" + mac="$(echo ${mac} | sed 's/-//g')" + mount_images_in_directory "${livefs_root}" "${rootmnt}" "${mac}" + fi + + + if [ -n "${ROOT_PID}" ] ; then + echo "${ROOT_PID}" > "${rootmnt}"/live/root.pid + fi + + log_end_msg + + # unionfs-fuse needs /dev to be bind-mounted for the duration of + # live-bottom; udev's init script will take care of things after that + if [ "${UNIONTYPE}" = unionfs-fuse ] + then + mount -n -o bind /dev "${rootmnt}/dev" + fi + + # Move to the new root filesystem so that programs there can get at it. + if [ ! -d /root/live/image ] + then + mkdir -p /root/live/image + mount --move /live/image /root/live/image + fi + + # aufs2 in kernel versions around 2.6.33 has a regression: + # directories can't be accessed when read for the first the time, + # causing a failure for example when accessing /var/lib/fai + # when booting FAI, this simple workaround solves it + ls /root/* >/dev/null 2>&1 + + # copy snapshot configuration if exists + if [ -f snapshot.conf ] + then + log_begin_msg "Copying snapshot.conf to ${rootmnt}/etc/live/boot.d" + if [ ! -d "${rootmnt}/etc/live/boot.d" ] + then + mkdir -p "${rootmnt}/etc/live/boot.d" + fi + cp snapshot.conf "${rootmnt}/etc/live/boot.d/" + log_end_msg + fi + + if [ -f /etc/resolv.conf ] && [ ! -s ${rootmnt}/etc/resolv.conf ] + then + log_begin_msg "Copying /etc/resolv.conf to ${rootmnt}/etc/resolv.conf" + cp -v /etc/resolv.conf ${rootmnt}/etc/resolv.conf + log_end_msg + fi + + maybe_break live-bottom + log_begin_msg "Running /scripts/live-bottom\n" + + run_scripts /scripts/live-bottom + log_end_msg + + if [ "${UNIONFS}" = unionfs-fuse ] + then + umount "${rootmnt}/dev" + fi + + exec 1>&6 6>&- + exec 2>&7 7>&- + kill ${tailpid} + [ -w "${rootmnt}/var/log/" ] && cp live-boot.log "${rootmnt}/var/log/" 2>/dev/null }