root/branches/2.2.10/mindi/rootfs/sbin/init

#!/bin/sh
#
# $Id$
#
# init script launched during the restore process
#------------------------------------------------------------

export MINDI_CACHE=CCC

if [ -e "/proc/cmdline" ]; then
        export CMDLINE="/proc/cmdline"
elif [ -e "/tmp/cmdline" ]; then
        export CMDLINE="/tmp/cmdline"
else
        export CMDLINE="/dev/null"
fi



CaughtSoftReset() {
        trap SIGTERM
        reboot
}


ConfigureLoggingDaemons() {
        echo -en "Running klogd..."
        klogd -c 2 > /dev/null 2> /dev/null
        echo -en "Done.\nRunning syslogd..."
        syslogd > /dev/null 2> /dev/null
        echo "Done."
        LogIt "klogd and syslogd have been started."
}



CopyBootDevEntry() {
        local outfile devfile
        devfile=/dev/boot_device
        outfile=`cat /BOOTLOADER.DEVICE 2> /dev/null`
        [ ! "$outfile" ] && return 0
        echo -en "Copying boot device to $outfile..."
        if [ -e "$outfile" ] ; then
                echo "not needed."
                return 0
        fi
        mkdir -p $outfile
        rmdir $outfile
        cp -pRdf $devfile $outfile
        if [ "$?" -ne "0" ] ; then
                echo "Failed."
                return 1
        else
                echo "OK."
                return 0
        fi
}



Die() {
        LogIt "Fatal error! $1" 1
        exit 1
}



ExtractDevTarballs() {
        cd /
        for fname in ataraid.tgz ida.tgz i2o.tgz rd.tgz raw.tgz cciss.tgz nst.tgz dm.tgz vc.tgz ; do
                if [ ! -e "/$fname" ] ; then
                    LogIt "/$fname not found; cannot extract to /." 1
                else
                    echo -en "\rExtracting /$fname...     "
                    tar -zxf /$fname || LogIt "Error occurred while extracting /$fname"
                        rm -f /$fname
                fi
        done
        echo -en "\r"
        LogIt "Extracted additional /dev entries OK.     " 1
}



LaunchTerminals() {
        openvt -l /bin/sh
        openvt -l /bin/sh
        openvt -l /bin/sh
        openvt -l /bin/sh
        openvt -l /bin/sh
        openvt -l /bin/sh /sbin/wait-for-petris
        openvt -l /usr/bin/tail -f $LOGFILE
        # May avoid shell error messages
        # chmod 666 /dev/tty* /dev/console
        # By default first serial line is configured as tty
        # Required to have a correct serial console support (MP on ia64 or VSP with iLO2 e.g.)
        for i in `cat /proc/cmdline` ; do
        echo $i | grep -qi serial= && serial=`echo $i | cut -d= -f2`
        done
        # Doing that is only valid when using a real serial line
        if [ -f $serial ]; then
                LogIt "Redirecting serial $serial to /dev/tty" 1
                ln -s -f $serial /dev/tty
        fi
}


LoadKeymap() {
        local fname
        fname=`cat $MINDI_CACHE/KEYMAP-LIVES-HERE 2> /dev/null`
        [ "$fname" = "" ] && return
        if which loadkeys > /dev/null 2> /dev/null ; then
                loadkeys $fname
        else
                LogIt "Using default keyboard map." 1
        fi
}


UntarTapeStuff() {
        local old_pwd res
        old_pwd=`pwd`
        cd $GROOVY
        [ "$1" != "" ] && tapedev=$1
        [ ! "$tapedev" ] && tapedev=`grep media-dev $MINDI_CACHE/mondorestore.cfg 2>/dev/null | tr -s ' ' ' ' | cut -d' ' -f2`
        mt -f $tapedev rewind
        mt -f $tapedev fsf 2
        dd if=$tapedev bs=32k count=1024 | tar -zx
        res=$?
        if [ "$res" -eq "0" ] ; then
                # Store the dev name in case we changed it interactively
                if [ -f "$MINDI_CACHE/mondorestore.cfg" ]; then
                        sed -i "s/^media-dev .*$/media-dev  $tapedev/" $MINDI_CACHE/mondorestore.cfg
                fi
        fi
        cd $old_pwd
        return $res
}

HandleTape() {
        local res tapedev
        tapedev="" ; # will be set by UntarTapeStuff()

        # Here we can add the USB storage module, it's working even with OBDR !
        modprobe -q usb-storage
        # Tape takes some time to appear
        sleep 10
        UntarTapeStuff $tapedev
        res=$?
        while [ "$res" -ne "0" ] ; do
                LogIt "$tapedev failed to act as extended data disk for booting." 1
                LogIt "Please specify an alternate tape device," 1
                LogIt "or hit <Enter> to boot from another media." 1
                echo -en "---> "
                read tapedev
                if [ "$tapedev" ] ; then
                    LogIt "User specified $tapedev instead"
                    UntarTapeStuff $tapedev
                    res=$?
                else
                    LogIt "User opted not to specify an alternate tapedev"
                    res=1
            break
                fi
        done
        # For post-init
        export TAPEDEV=$tapedev

        if [ "$res" -ne "0" ] ; then
                LogIt "Failed to use tape as extended datadisk. Reverting to another media." 1
                HandleCDROM
                res=$?
        else
                LogIt "Using tape as extended datadisk. Good." 3
                echo "Using tape as extd ddisk." > /tmp/TAPEDEV-HAS-DATA-DISKS
                res=0
                CD_MOUNTED_OK=yes
        fi
        return $res
}



HandleCDROM() {
        # Just in case we have an iLO ensure we will map it correctly
        echo "$DENY_MODS" | grep -q "usb-storage "
        if [ $? -eq 0 ]; then
                return
        fi
        echo "Activating a potential USB Storage device"
        modprobe -q usb-storage
        for i in 1 2 3 4 5 6 7 8 9 10 ; do
                sleep 1
                echo -en "."
        done

        find-and-mount-cdrom
        res=$?
        if [ "$res" -ne "0" ] ; then
                LogIt "First call to find-and-mount-cdrom failed." 1
                LogIt "Sleeping for 3 seconds and trying again." 1
                sleep 3
                find-and-mount-cdrom
                res=$?
        fi
        if [ "$res" -eq "0" ] ; then
                LogIt "OK, I am running on a CD-ROM. Good." 3
                CD_MOUNTED_OK=yes
        else
                LogIt "You probably not have the right drivers" 3
                LogIt "to support the hardware on which we are running" 3
                LogIt "Your archives are probably fine but" 3
                LogIt "your tape streamer and/or CD-ROM drive are unsupported at that point." 3
                CD_MOUNTED_OK=""
        fi
        return 0
}


# --- cater for arbitrary locations of devfsd.conf by using the
#     config file path compiled into devfsd
RunDevfsd() {
        loc=`which devfsd 2> /dev/null`
        if [ "$loc" != "" ] ; then
        LogIt "Devfs found. Testing kernel support..."
        if [ ! -e "/dev/.devfsd" ] ; then
            mount -t devfs devfs /dev 2>> $LOGFILE
                    if [ "$?" -ne "0" ] ; then
                LogIt "Error while trying to mount devfs"
            else
                LogIt "Devfs mounted OK"
            fi
        fi
        #check if the kernel supports devfs
        if [ -e "/dev/.devfsd" ] ; then
            [ -d "/proc/1" ] || mount -n /proc
            LogIt "Kernel support found. Creating config file and starting devfsd"
            conffile=`strings $loc | grep -E "devfsd.conf$"`
            [ "$conffile" ] || conffile="/etc/devfsd.conf"
            confpath=`echo $conffile | sed "s/\/devfsd\.conf$//"`
            [ -d "$confpath" ] || mkdir -p $confpath
            echo -en "REGISTER .* MKOLDCOMPAT\nUNREGISTER .* RMOLDCOMPAT\n" > $conffile
            devfsd /dev &
            sleep 5
        else
            LogIt "No devfs kernel support."
        fi
        fi
}

# Taken from udev management in Mandriva 2008.0. Kudos guys
make_extra_nodes () {
        # there are a few things that sysfs does not export for us.
        # these things are listed in /etc/udev/links.conf
        grep '^[^#]' /etc/udev-links.conf | \
        while read type name arg1; do
                [ "$type" -a "$name" -a ! -e "/dev/$name" -a ! -L "/dev/$name" ] ||continue
                case "$type" in
                        L) ln -s $arg1 /dev/$name ;;
                        D) mkdir -p /dev/$name ;;
                        M) mknod /dev/$name $arg1 && chmod 600 /dev/$name;;
                        *) echo "udev-links.conf: unparseable line (%s %s %s)\n" "$type" "$name" "$arg1" ;;
                esac
        done
}

create_dev_makedev() {
  if [ -e /sbin/MAKEDEV ]; then
    ln -sf /sbin/MAKEDEV /dev/MAKEDEV
  else
    ln -sf /bin/true /dev/MAKEDEV
  fi
}

RunUdevd() {
        # Inspiration from Mandriva 2008.0 startup script
        echo "Preparing udev environment..."
        mv /dev /dev.static
        mkdir /dev
        mount -n -o size=5M,mode=0755 -t tmpfs none /dev
        make_extra_nodes
        mount -n -t devpts -o mode=620 none /dev/pts
        mount -n -t tmpfs  none /dev/shm
        if [ -e /proc/sys/kernel/hotplug ]; then
                echo > /proc/sys/kernel/hotplug
        fi
        PKLVL=`cut -f1 /proc/sys/kernel/printk`
        echo 0 > /proc/sys/kernel/printk
        # Many possibilities depending on udev versions
        if [ -x /sbin/startudev ]; then
                /sbin/startudev
        elif [ -x /sbin/start_udev ]; then
                /sbin/start_udev
        fi
        # Depending on udevd version it gives back the hand or not :-(
        ps | grep udevd 2> /dev/null 1> /dev/null
        if [ $? -ne 0 ]; then
                /sbin/udevd --daemon &
                echo "Waiting for udev to start..."
                sleep 5
        fi
        mkdir -p /dev/.udev/queue/
        if [ -x /sbin/udevtrigger ]; then
                /sbin/udevtrigger
        fi
        echo "Waiting for udev to discover..."
        create_dev_makedev
        # Newer version use udevadm for that
        if [ -x /sbin/udevsettle ]; then
                /sbin/udevsettle --timeout=10
        elif [ -x /sbin/udevadm ]; then
                /sbin/udevadm trigger 
                /sbin/udevadm settle --timeout=10
        fi
        # It seems we need to have more static devs on some distro were
        # udev as some other requirements to be covered later on.
        # So in the mean time:
        for d in `ls /dev.static`; do
                if [ ! -e /dev/$d ]; then
                        mv /dev.static/$d /dev
                fi
        done
        rm -rf /dev.static
        echo $PKLVL > /proc/sys/kernel/printk
}

RstHW() {

        # Restore the HW configuration if available (NOT by default)
        answer="NO"

        grep -q nohw $CMDLINE
        if [ "$?" -eq 0 ]; then
                return
        fi
        if [ -x $MINDI_CACHE/mindi-rsthw ]; then
                grep -q RESTORE $CMDLINE
                if [ "$?" -ne 0 ]; then
                        echo "*********************************************************************"
                        echo "Do you want to restore the HW configuration of the original machine ?"
                        echo "(This may dammage your hardware so be sure to check twice before saying yes)"
                        echo "*********************************************************************"
                        echo "Please confirm by typing YES exactly as written here (NO by default)"
                        echo -n "--> "
                        read answer
                else
                        answer="YES"
                fi
                if [ "$answer" = "YES" ] ; then
                        $MINDI_CACHE/mindi-rsthw
                fi
        fi
}


#RunDevfsd() {
#    loc=`which devfsd 2> /dev/null`
#    if [ "$loc" != "" ] ; then
#        LogIt "Starting devfsd"
#        devfsd /dev &
#        sleep 5
#    fi
#}



StartUSBKbd() {
# Prepare minimal USB env in case we have USB kbd such as with iLO
[ -d /proc/bus/usb ] && ! grep -q /proc/bus/usb /proc/mounts && mount -t usbfs none /proc/bus/usb
echo "$DENY_MODS" | grep -Eq 'uhcd_hci |usbhid |usbcore '
if [ $? -eq 0 ]; then
        return
fi
modprobe -q uhcd_hci
modprobe -q usbhid
}



StartLvms() {
        if [ "`grep -i nolvm /proc/cmdline`" ]; then
                return;
        fi
        if [ -e "/tmp/i-want-my-lvm" ] ; then
                LogIt "Scanning LVM's..." 1
                if which lvm ; then
                modprobe -q dm-mod
                modprobe -q dm_mod
                lvm vgscan --mknodes
                else
                vgscan
                fi

                # Exclude devices we may not want
                rm -f /tmp/restorevgs
                for d in $MINDI_EXCLUDE_DEVS ; do
                        echo " == $d"
                        EXCLUDE_VGS=`grep " $d" /tmp/i-want-my-lvm | grep vgcreate | awk '{print $4}'`
                        vg=`echo $EXCLUDE_VGS | sed "s/ /|/g"`
                        if [ "$vg" != "" ]; then
                                re=" $d|$vg"
                        else 
                                re=" $d"
                        fi
                        # Remove VGs from i-want-my-lvm
                        grep -Ev "$re" /tmp/i-want-my-lvm > /tmp/i-want-my-lvm.new
                        mv /tmp/i-want-my-lvm.new /tmp/i-want-my-lvm
                        # Prepare  script to restore the VG exluded here if needed
                        for v in $EXCLUDE_VGS; do
                                echo "vgcfgrestore $v" >> /tmp/restorevgs
                                # Remove LVs from mountlist
                                EXCLUDE_LVS=`grep " $v" /tmp/i-want-my-lvm | grep lvcreate | sed "s/^.*-n \([^ ][^ ]*\) .*$/$1/"`
                                for l in $EXCLUDE_LVS; do
                                        # FIXME: Should search for all possible device names here
                                        grep -Ev "/dev/$v/$l" /tmp/mountlist.txt > /tmp/mountlist.txt.new
                                        grep -Ev "/dev/mapper/${v}-$l" /tmp/mountlist.txt.new > /tmp/mountlist.txt
                                done
                        done
                done

                grep -E "^#.*vgchange" /tmp/i-want-my-lvm | sed "s/^#[ ]*//" > /tmp/start-lvm
                chmod +x /tmp/start-lvm
                echo -en "Starting LVM's..."
                /tmp/start-lvm &
                for i in 1 2 3 4 5 ; do
                echo -en "."
                sleep 1
                done
                rm -f /tmp/start-lvm
                echo "Done."
        fi
# If necessary, cannibalize 'analyze-my-lvm'; copy some of its code here,
# pipe vgscan's output, strip it, run 'vgchange' on its output, etc.etc.
        LogIt "LVM's have been started."
}

StartPowerPath() {

        # Taken from the init script of EMC PowerPath on RHEL
    if [ -f /etc/emcp_devicesDB.dat ]; then 
        if [ -f /etc/emcp_devicesDB.idx ]; then
            /etc/opt/emcpower/emcpmgr map -p > /dev/null 2>&1
        fi
    fi

    /sbin/powermt config > /dev/null 2>&1
        #  Wait for udev to finish creating emcpower devices
    #
    pdfound=1
    for i in 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15; do
        pdfound=1
        for pd in `/bin/ls -d /sys/block/emcpower* 2> /dev/null`; do
           bpd=`basename $pd`
           if [ ! -e /dev/$bpd ]; then
              pdfound=0
              sleep 2
              break;
           fi
        done
        if [ "$pdfound" -eq 1 ]; then
                        break
        fi
    done
    if [ "$pdfound" -eq 0 ]; then
       echo "Unable to start PowerPath"
    fi

    /sbin/powermt load          > /dev/null 2>&1
    /etc/opt/emcpower/emcpmgr map       > /dev/null 2>&1
    /etc/opt/emcpower/powercf -C        > /dev/null 2>&1
    if [ ! -e /etc/powermt.custom ]; then 
       /sbin/powermt save               > /dev/null 2>&1
    fi 
    /sbin/powermt register      > /dev/null 2>&1
    /sbin/powermig transition -startup -noprompt   > /dev/null 2>&1
}

StartMpath() {
        if [ "`grep -i nompath $CMDLINE`" ]; then
                return;
        fi
        if [ "`grep mpath $MINDI_CACHE/mountlist.txt`" ]; then
                if [ -x /sbin/multipath ]; then
                        echo "Starting Mpath..."
                        mkdir -p /var/lib/multipath
                        cat > /etc/multipath.conf << EOF
defaults {
        user_friendly_names yes
}
EOF
                        /sbin/multipath -v 0
                        if [ -x /sbin/kpartx ]; then
                                /sbin/dmsetup ls --target multipath --exec "/sbin/kpartx -a -p p"
                        fi
                fi
        fi
}

StartRaids() {
        local raid_devices i

        if [ "`grep -i noraid /proc/cmdline`" ]; then
                return;
        fi

        raid_devices=`grep /dev/md $MINDI_CACHE/mountlist.txt | cut -d' ' -f1`
        if which raidstart > /dev/null 2> /dev/null ; then
                for i in $raid_devices ; do
                        if grep `basename $i` /proc/mdstat > /dev/null 2> /dev/null ; then
                        LogIt "$i is started already; no need to run 'raidstart $i'" 1
                        else
                        LogIt "Running 'raidstart $i'" 1
                        raidstart $i
                        fi
                done
        elif which mdrun > /dev/null 2> /dev/null ; then
                if [ "`grep -i nomd /proc/cmdline`" ]; then
                        return;
                fi
                LogIt "Running 'mdrun'" 1
                mdrun
        elif which mdadm > /dev/null 2> /dev/null ; then
                if [ "`grep -i nomd /proc/cmdline`" ]; then
                        return;
                fi
                LogIt "Running 'mdadm'" 1
                for i in $raid_devices ; do
                        if grep `basename $i` /proc/mdstat > /dev/null 2> /dev/null ; then
                        LogIt "$i is started already; no need to run 'mdadm $i'" 1
                        else
                                if [ -f /etc/mdadm.conf ] ; then
                                        LogIt "Running 'mdadm $i' with user supplied /etc/mdadm.conf" 1
                                        mdadm -A $i -c /etc/mdadm.conf
                                elif [ -f /etc/mdadm/mdadm.conf ] ; then
                                        LogIt "Running 'mdadm $i' with user supplied /etc/mdadm/mdadm.conf" 1
                                        mdadm -A $i -c /etc/mdadm/mdadm.conf
                                else
                                LogIt "Running 'mdadm $i'" 1
                                mdadm -Ac partitions -m dev $i
                                fi
                        fi
                done
        elif which dmraid > /dev/null 2> /dev/null ; then
                if [ "`grep -i nodmraid $CMDLINE`" ]; then
                        return;
                fi
                for x in $(/sbin/dmraid -ay -i -p -t 2>/dev/null | grep -E  -iv "^no " |awk -F ':' '{ print $1 }') ; do
                        echo "Please send the result of /sbin/dmraid -ay -i -p -t to the devteam !!!"
                        return
                        #dmname=$(resolve_dm_name $x)
                        #[ -z "$dmname" ] && continue
                        #/sbin/dmraid  -ay -i -p "$dmname" >/dev/null 2>&1
                        #/sbin/kpartx -a -p p "/dev/mapper/$dmname"
                done
        else
                LogIt "Warning: Neither 'raidstart' nor 'mdrun''found. RAID devices may not have started." 1
        fi

}


TryAgainToFindCD() {
        local res
        mount | grep /mnt/cdrom && return 0
        [ "`grep "backup_media_type" $MINDI_CACHE/mondorestore.cfg 2> /dev/null | grep "cdstream"`" ] && return
        LogIt "Trying to mount CD-ROM a 2nd time..."
        find-and-mount-cdrom --second-try
        res=$?
        if [ "$res" -eq "0" ] ; then
                CD_MOUNTED_OK=yes
                LogIt "CD-ROM drive mounted successfully." 1
        else
                LogIt "I still cannot find or mount the CD-ROM drive, by the way."
        fi
}



UseTmpfs()
{
        local mount_cmd
        echo -en "Mounting /tmp/tmpfs..."
        mkdir -p /tmp/tmpfs
# For technical reasons, some sets are as large as 16MB.
# I am allowing 32MB because selective restore occupies a lot of space.
        for size in 128m 64m 48m 40m 32m ; do
                mount_cmd="mount /dev/shm -t tmpfs -o size=$size" ; # was 34m until 04/2003
                LogIt "Trying '$mount_cmd'"
                $mount_cmd /tmp/tmpfs 2>> $LOGFILE
                res=$?
                [ "$res" -eq "0" ] && break
        done
        if [ "$res" -ne "0" ] ; then
                LogIt "Failed. I could not run '$mount_cmd /tmp/tmpfs'. Your kernel is BROKEN or you do not have enough RAM." 1
                umount /tmp/tmpfs > /dev/null 2> /dev/null
                rmdir /tmp/tmpfs
                ln -sf /mnt/RESTORING/tmp /tmp/tmpfs; # used by mondo-restore
                LogIt "Failed to mount /tmp/tmpfs; using ugly softlink instead"
        else
                LogIt "Great. Pivot succeeded w/ size=$size" 1
                echo -en "Pivoting /tmp..."
                umount /tmp/tmpfs
                mkdir -p /tmp.old
                mv /tmp/* /tmp.old/
                rm -f /tmp/*
                $mount_cmd /tmp
                mv /tmp.old/* /tmp/
                rm -rf /tmp.old
                mkdir -p /tmp/tmpfs
                echo "Done."
                LogIt "Successfully mounted dynamic /tmp ramdisk"
        fi
}


WelcomeMessage()
{
        echo "********************************************************************"
        echo "MINDI-LINUX by Mondo Dev Team - web site: http://www.mondorescue.org"
        echo "Boot disk based on AlfaLinux & Trinux. BusyBox by Erik Andersen."
which petris > /dev/null 2> /dev/null && echo "Petris was written by Peter Seidler <p.seidler@mail1.stofanet.dk>."
        echo "Executables and source code are covered by the GNU GPL. No warranty."
        echo "running on $ARCH"
        echo "********************************************************************"
}


EnableCcissIfAppropriate() {
        local i fname
        for i in 0 1 2 3 ; do
                fname="/proc/driver/cciss/cciss$i"
                if [ -e "$fname" ] ; then
                LogIt "Engaging $fname"
                echo "engage scsi" > $fname
                LogIt "...result=$?"
                fi
        done
}

ModprobeAllModules() {

        lismod=`find /lib/modules -name '*\.ko*' -o -name '*\.o*'`
        # loading forced modules first
        for m in $lismod; do
                k=`basename $m | sed 's/\.ko.*$//'`
                j=`basename $k | sed 's/\.o.*$//'`
                echo "$FORCE_MODS" | grep -q "$j "
                if [ $? -eq 0 ]; then
                        echo "Forcing first $j..."
                        modprobe -q $j
                fi
        done
        for m in $lismod; do
                k=`basename $m | sed 's/\.ko.*$//'`
                j=`basename $k | sed 's/\.o.*$//'`
                echo "$DENY_MODS" | grep -q "$j "
                if [ $? -eq 0 ]; then
                        echo "Denying $j..."
                        continue
                fi
                echo "$FORCE_MODS" | grep -q "$j "
                if [ $? -eq 0 ]; then
                        continue
                fi
                echo "Probing $j..."
                modprobe -q $j
        done
}

ExtractDataDisksAndLoadModules() {
        echo "Installing additional tools ..."
        install-additional-tools
        # Keep the kernel silent again
        PKLVL=`cut -f1 /proc/sys/kernel/printk`
        echo 0 > /proc/sys/kernel/printk
        ModprobeAllModules
        echo $PKLVL > /proc/sys/kernel/printk

        # Retry failed udev events now that local filesystems are mounted read-write
        # (useful for rules creating network ifcfg files)
        if [ -e "$MINDI_CACHE/USE-UDEV" ] ; then
                if [ -x /sbin/udevadm ]; then
                        /sbin/udevadm trigger --retry-failed
                fi
        fi
}

# ------------------------ main -----------------------

MINDI_VER=PBVER
MINDI_REV=PBREV
trap CaughtSoftReset SIGTERM
LOGFILE=/var/log/mondorestore.log
PATH=/bin:/usr/bin:/sbin:/usr/sbin:/usr/local/bin:/usr/local/sbin:/mondo:/usr/games
GROOVY=$MINDI_CACHE/groovy-stuff
USER=root
ARCH=`uname -m`

export PATH GROOVY USER LOGFILE ARCH

echo "Welcome to init (from mindi ${MINDI_VER}-r${MINDI_REV})"

mount -o remount rw /
[ ! "$GROOVY" ] && Die "I'm not groovy!"
for i in /mnt/cdrom /mnt/isodir /var/local/petris /tmp/isodir; do
        mkdir -p $i
done
#/bin/update
mount /proc/ /proc -v -t proc 
mkdir /sys 2> /dev/null
mount /sys/ /sys -v -t sysfs 2>> $LOGFILE
# For ESX 3
[ -d /proc/vmware ] && ! grep -q /vmfs /proc/mounts && mount -t vmfs /vmfs /vmfs
rm -f /foozero

if [ "`grep -i denymods $CMDLINE`" ]; then
        export DENY_MODS="`cat $CMDLINE | sed 's~.*denymods=\"\(.*\)\".*~\1~'` mondonone"
else
        export DENY_MODS=" "
fi
if [ "`grep -i 'obdr ' $MINDI_CACHE/mondorestore.cfg 2> /dev/null`" ]; then
        # Do not try to load usb storage when dealing with OBDR it makes the modprobe hang :-(
        export DENY_MODS="usb-storage $DENY_MODS"
fi
if [ "`grep -i forcemods $CMDLINE`" ]; then
        export FORCE_MODS="`cat $CMDLINE | sed 's~.*forcemods=\"\(.*\)\".*~\1~'` mondonone"
else
        export FORCE_MODS=" "
fi
if [ "`grep -i excludedevs /proc/cmdline`" ]; then
        export MINDI_EXCLUDE_DEVS="`cat /proc/cmdline | sed 's~.*excludedevs=\"\(.*\)\".*~\1~'` mondonone"
else
        export MINDI_EXCLUDE_DEVS=" "
fi

echo "Activating a potential USB keyboard/mouse"
StartUSBKbd

if [ -f /proc/sys/kernel/exec-shield ]; then
        echo 0 > /proc/sys/kernel/exec-shield 2>> /dev/null
fi

if [ -f /proc/modules ]; then
        echo "/sbin/modprobe" > /proc/sys/kernel/modprobe
fi

if [ -e "$MINDI_CACHE/USE-UDEV" ] ; then
        RunUdevd
fi
ExtractDevTarballs
LaunchTerminals

# Keeping kernel silent  for module insertion
PKLVL=`cut -f1 /proc/sys/kernel/printk`
echo 0 > /proc/sys/kernel/printk
ModprobeAllModules
echo $PKLVL > /proc/sys/kernel/printk

EnableCcissIfAppropriate
#-------------------------------
#WHOLIVESINAPINEAPPLEUNDERTHESEA#;# --- don't touch this :)
#-------------------------------
UseTmpfs
if [ ! -e "$MINDI_CACHE/mondorestore.cfg" ] ; then
        LogIt "Warning - $MINDI_CACHE/mondorestore.cfg not found"
fi
if [ "`grep -i pxe $CMDLINE`" ] || [ "`grep -i net $CMDLINE`" ]; then
        # We need to get here exported variables from start-netfs
        . /sbin/start-netfs
fi

if [ "`grep -i 'obdr ' $MINDI_CACHE/mondorestore.cfg 2>/dev/null`" ] || [ "`grep -i ' udev' $MINDI_CACHE/mondorestore.cfg 2>/dev/null`" ]; then
        HandleTape
        ExtractDataDisksAndLoadModules
elif [ "`grep -i pxe $CMDLINE`" ]; then
        # Simulate a local CD
        echo "/mnt/cdrom" > $MINDI_CACHE/CDROM-LIVES-HERE
        CD_MOUNTED_OK=yes
        ExtractDataDisksAndLoadModules
        # Fake the conf file to force it to NFS mode, even if we made originally a CD (mandatory for mondorestore to work correctly)
        sed -i "s/backup-media-type.*/backup-media-type netfs/" $MINDI_CACHE/mondorestore.cfg
elif [ "`grep -i usb= $CMDLINE`" ] || [ "`grep -i usb $MINDI_CACHE/mondorestore.cfg 2>/dev/null | grep media-type`" ]; then
        . /sbin/start-usb

        # Simulate a local CD
        echo "/mnt/cdrom" > $MINDI_CACHE/CDROM-LIVES-HERE
        CD_MOUNTED_OK=yes
        ExtractDataDisksAndLoadModules
else
        HandleCDROM
        ExtractDataDisksAndLoadModules
        # We need to get here exported variables from start-netfs
        . /sbin/start-netfs
fi
res=$?
ConfigureLoggingDaemons
if [ -e "$MINDI_CACHE/USE-DEVFS" ] ; then
        umount /mnt/cdrom 2> /dev/null
        mv /dev/cdrom /cdrom.lnk 2> /dev/null
        CD_MOUNTED_OK=""
        RunDevfsd
fi
LoadKeymap
WelcomeMessage
RstHW
StartRaids
StartMpath
StartLvms
CopyBootDevEntry
mkdir -p /tmp/tmpfs
sleep 2
if [ -e "/dev/md0" ] && [ ! -e "/dev/md/0" ] && [ "`grep /dev/md/ $MINDI_CACHE/mountlist.txt`" != "" ] ; then
        LogIt "Creating /dev/md/* softlinks just in case." 1
        mkdir -p /dev/md
        cp -af /dev/md0 /dev/md/0 2> /dev/null
        cp -af /dev/md1 /dev/md/1 2> /dev/null
        cp -af /dev/md2 /dev/md/2 2> /dev/null
fi
[ -e "$MINDI_CACHE/mountlist.txt" ] && cp -f $MINDI_CACHE/mountlist.txt $MINDI_CACHE/mountlist.original

if ! [ "`grep -i "pxe" $CMDLINE`" ] ; then
        res="`cat /mnt/cdrom/archives/THIS-CD-NUMBER 2> /dev/null`"
        [ "$res" != "1" ] && [ "$res" != "" ] && Die "This is CD #$res in the series. Please insert CD #1."
        [ -e "/cdrom.lnk" ] && mv -f /cdrom.lnk /dev/cdrom && mount /dev/cdrom /mnt/cdrom && CD_MOUNTED_OK=yes
        [ "$CD_MOUNTED_OK" != "yes" ] && TryAgainToFindCD
        #mount | grep cdrom > /dev/null 2> /dev/null || mount /dev/cdrom /mnt/cdrom >> $LOGFILE 2>> $LOGFILE
fi
hack-cfg-if-necessary || LogIt "Cannot find hack-cfg-if-necessary"

# Log some useful info
LogIt "init (from mindi v$MINDI_VER-r${MINDI_REV})"
LogIt "$CMDLINE is:"
LogIt "----------"
cat $CMDLINE  >> $LOGFILE
LogIt "----------"
LogIt "df result:"
LogIt "----------"
df >> $LOGFILE
LogIt "-------------"
LogIt "mount result:"
LogIt "-------------"
mount >> $LOGFILE
LogIt "-------------"
LogIt "lsmod result:"
LogIt "-------------"
lsmod >> $LOGFILE
LogIt "-------------"
LogIt "dmesg result:"
LogIt "-------------"
dmesg >> $LOGFILE
LogIt "-------------"
LogIt "/proc/swaps:" >> $LOGFILE
LogIt "-------------"
cat /proc/swaps  >> $LOGFILE
LogIt "-------------"
LogIt "/proc/filesystems:" >> $LOGFILE
LogIt "-------------"
cat /proc/filesystems  >> $LOGFILE
LogIt "-------------"
LogIt "/proc/partitions:" >> $LOGFILE
LogIt "-------------"
cat /proc/partitions  >> $LOGFILE
LogIt "-------------"
LogIt "fdisk result:" >> $LOGFILE
LogIt "-------------"
fdisk -l  >> $LOGFILE

ide-opt

# Not sure it's still needed, but shouldn't hurt
if [ -e "/tmp/USE-UDEV" ] ; then
        if [ -x /sbin/udevadm ]; then
                /sbin/udevadm trigger --retry-failed
        fi
fi
if grep "backup-media-type" $MINDI_CACHE/mondorestore.cfg > /dev/null 2> /dev/null ; then
        LogIt "backup-media-type is specified in config file - great."
        LogIt "Calling post-init"
        # start-netfs moved it under /tmp as the NFS share is already unmounted 
        if [ "`echo $pre | grep -E '^/tmp/isodir'`" ]; then
                pre=`echo $pre | sed 's|^/tmp/isodir|/tmp|'`
        fi
        if [ -x $pre ]; then
                echo "Executing preliminary script $pre"
                LogIt "Executing preliminary script $pre"
                $pre
        fi
        post-init
else
        LogIt "backup-media-type is not specified in config file."
        LogIt "I think this media has no archives on it."
fi
if [ "`grep -i "post=" $CMDLINE`" ] ; then
        for i in `cat $CMDLINE` ; do
        echo $i | grep -qi post= && post=`echo $i | cut -d= -f2`
        done
        # start-netfs moved it under /tmp as the NFS share is already unmounted 
        if [ "`echo $post | grep -E '^/tmp/isodir'`" ]; then
                post=`echo $post | sed 's|^/tmp/isodir|/tmp|'`
        fi
        if [ -x $post ]; then
                echo "Executing final script $post"
                LogIt "Executing final script $post"
                if [ "`echo $post | grep -E '^/mnt/RESTORING'`" ]; then
                        mount-me
                fi
                $post
                if [ "`echo $post | grep -E '^/mnt/RESTORING'`" ]; then
                        unmount-me
                fi
        fi
fi
if grep "RESTORE" $CMDLINE > /dev/null 2> /dev/null ; then
        echo "Rebooting in 10 seconds automatically as per reboot order"
        echo -en "Press ^C to interrupt if you have to ..."
        for i in 1 2 3 4 5 6 7 8 9 10 ; do
                sleep 1
                echo -en "."
        done
        echo "Boom."
        sleep 1
else
        echo -en "Type 'exit' to reboot the PC\n"
        umount /mnt/cdrom 2> /dev/null
        mount / -o rw,remount > /dev/null 2> /dev/null
        LogIt "Launching Shell"
        sh
fi
CaughtSoftReset
# reboot