Subversion Repositories livecd

#!/bin/ash

#

# Functions library :: for Linux Live scripts 5.x.y

# Author: Tomas M. <http://www.linux-live.org>

#

# modified by Urs Beyerle

# - to allow LiveCD mounted over nfs

# - add scsi_mod, sd_mod for usb-storage module

# - only with boot option "automount", all devices in fstab are rw automounted

# - remove detect of CD and Floppy (done by fstab-sync)

# - add sr_mod (USB CDROM support)

# - add SATA to modprobe_usb_modules -> modprobe_usb_sata_modules

# - add fscache (for SL5) 

# - add ide-cd, sr_mod, cdrom (for SL5 cdrom support)

# - add aufs (unionfs replacement)

# - to allow LiveCD mounted over NFS (for diskless client)

# - add functions get_dhcp_lease() and load_network_modules()

# - add ata_piix to modprobe_usb_sata_modules

# - works with unionfs 2.x

# - better detection of network card in case of diskless client

# - add sg, sata_nv module

# - to allow LiveCD mounted over CIFS (for diskless client)

# - add function find_changes

#

# ===========================================================

# user interface functions

# ===========================================================

# echolog

# $1 = text to show and to write to /var/log/messages

#

echolog()

{

   echo "LIVECD:" "$@" >>/var/log/livedbg

   echo "$@"

}

# debug

# commands executed when debug boot parameter is present

#

debug()

{

   echo

   echo "====="

   echo ": Debugging started. Here is the root shell for you."

   echo ": Type your desired command or hit Ctrl+D to continue booting."

   echo

   ash

}

# header

# $1 = text to show

#

header()

{

   echolog "$1"

}

fatal()

{

   header "Fatal error occured - $1"

   echolog "Something went wrong and we can't continue booting :("

   echolog "You may explore the system by using simple commands like ls, lsmod, mount, etc."

   echolog "You may also try to hit Ctrl+D. Booting will continue. Use at your own risk."

   echolog "To be safe, hit Ctrl+Alt+Delete to reboot."

   echolog

   ash

}

# ===========================================================

# text processing functions

# ===========================================================

# egrep_o is a replacement for "egrep -o". It prints only the last

# matching text

# $1 = regular expression

#

egrep_o()

{

   cat | egrep "$1" | sed -r "s/.*($1).*/\\1/"

}

# look into cmdline and echo $1 back if $1 is set

# $1 = value name, case sensitive, for example livecd_subdir

# $2 = file to use instead /proc/cmdline, optional

#

cmdline_parameter()

{

   CMDLINE=/proc/cmdline

   if [ "$2" != "" ]; then CMDLINE="$2"; fi

   cat "$CMDLINE" | egrep_o "(^|[[:space:]]+)$1(\$|=|[[:space:]]+)" | egrep_o "$1"

}

# look into cmdline and echo value of $1 option

# $1 = value name, case sensitive, for example livecd_subdir

# $2 = file to use instead /proc/cmdline, optional

#

cmdline_value()

{

   CMDLINE=/proc/cmdline

   if [ "$2" != "" ]; then CMDLINE="$2"; fi

   cat "$CMDLINE" | egrep_o "(^|[[:space:]]+)$1=([^[:space:]]+)" | egrep_o "=.*" | cut -b 2- | tail -n 1

}

# ===========================================================

# system functions

# ===========================================================

# modprobe module $1, including all dependencies, suppress all messages

# (own function because modprobe in busybox doesn't work with gzipped modules)

# $1 = module name, eg. ehci-hcd

# $2 = optional argument

#

modprobe_module()

{

  if [ "$1" = "" ]; then return 1; fi

  PRINTK=`cat /proc/sys/kernel/printk`

  echo "0" >/proc/sys/kernel/printk

  KERNEL="`uname -r`"; LSMOD=/tmp/lsmod

  MODULEDEPS="`cat /lib/modules/$KERNEL/modules.dep | egrep \"$1\\.ko(\\.gz)?:\"`"

  for MODULE in `echo $MODULEDEPS | cut -d ":" -f 2-` `echo $MODULEDEPS | cut -d ":" -f 1`; do

     MODULE=${MODULE%%:};   # remove : at the end, a bug 

     TMPMOD="/tmp/`basename $MODULE .gz`";

     # if the module is not loaded already

     if [ "`cat $LSMOD 2>/dev/null | egrep \"^$TMPMOD\\\$\"`" = "" ]; then

        gunzip -c $MODULE 2>/dev/null >$TMPMOD

        if [ $? -ne 0 ]; then cp $MODULE $TMPMOD; fi # can't gunzip? copy

        insmod $TMPMOD $2; err=$?

        ### insmod $TMPMOD $2 >/dev/null 2>/dev/null; err=$?

        if [ "$err" -eq 0 ]; then echo $TMPMOD >>$LSMOD; fi # module log

        rm $TMPMOD

     fi

  done

  echo "$PRINTK" >/proc/sys/kernel/printk

  if [ "$err" -ne 0 ]; then echolog "error inserting module $1 ($err)"; fi

  return $err

}

# Mount device $1 to $2

# $1 = /dev device to mount, eg. /dev/hda1

# $2 = mountpoint, eg. /mnt/hda1

# $3 = mount options, for example "loop", "ro", or "remount,rw"

#

mount_device()

{

  mkdir -p $2

  if [ "$3" != "" ]; then OPTIONS="-o $3"; else OPTIONS=""; fi

  PRINTK=`cat /proc/sys/kernel/printk`

  echo "0" >/proc/sys/kernel/printk

  mount -t auto $1 $2 $OPTIONS >/dev/null 2>/dev/null

  err=$?

  if [ "$err" -ne 0 ]; then rmdir $2 2>/dev/null; fi

  echo "$PRINTK" >/proc/sys/kernel/printk

  return $err

}

# ===========================================================

# live module functions

# ===========================================================

# Create module

# call mksquashfs with apropriate arguments

# $1 = directory which will be compressed to squashfs module

# $2 = output .mo file

# $3 = optional -keep-as-directory argument

#

create_module()

{

   mksquashfs $1 $2 $3 >/dev/null

   if [ $? -ne 0 ]; then return 1; fi

   chmod oga-x $2 # remove execute attrib

}

# Mount .mo module to destination directory

# $1 = path to .mo livecd compressed module

# $2 = destination folder

#

mount_module()

{

   mount -t squashfs -o loop,ro $1 $2

}

# Insert a directory tree $2 to an union specified by $1

# Top-level read-write branch is specified by it's index 0

# $1 = union absolute path (starting with /)

# $2 = path to data directory

#

union_insert_dir()

{

   which unionctl >/dev/null 2>&1

   if [ $? -eq 0 ]; then

       # unionfs 1.x or aufs

       unionctl "$1" --add --after 0 --mode ro "$2"

   else

       # unionfs 2.x

       mount -t unionfs -o remount,add=:${2}=ro none "$1"

   fi

}

# List all modules in all directories (base, modules, optional)

# and filter out unneeded optional modules (not specified by load= kernel parameter)

# $1 = root directory of mounted DATAdir

#

list_modules()

{

   LOAD="`cmdline_value load`"

   ls -A1d $1/*.mo $1/*/*.mo 2>/dev/null | while read LINE; do

      MODNAME="`basename $LINE .mo`"

      if [ "$LOAD" != "*" -a "`echo $LINE | grep optional`" != "" -a "`echo $LOAD | egrep \"(^|,)$MODNAME(\\\$|,)\"`" = "" ]; then continue

        else echo $LINE; fi

   done

}

# Insert one single .mo module to the union

# $1 = union absolute path (starting with /)

# $2 = module.mo full path

# $3 = destination folder, where images will be mounted to

#

union_insert_module()

{

   TARGET="$3/`basename $2`"

   while [ -e $TARGET ]; do TARGET=$TARGET.X; done

   mkdir -p $TARGET

   mount_module $2 $TARGET

   if [ $? -ne 0 ]; then echo "can't read module data"; return 1; fi

   union_insert_dir $1 $TARGET; 

}

# Insert all .mo modules, in $2 directory and subdirectories, to the union

# $1 = union absolute path (starting with /)

# $2 = LiveCD data dir (with directories /base, /modules, etc.)

# $3 = destination folder, where images will be mounted to

#

union_insert_modules()

{

   PRINTK=`cat /proc/sys/kernel/printk`

   echo "0" >/proc/sys/kernel/printk

   list_modules $2 | while read MODULE; do

      echo " -> `basename $MODULE`"

      union_insert_module $1 $MODULE $3

   done

   echo "$PRINTK" >/proc/sys/kernel/printk

}

# Copy modules to RAM directory

# $1 = data directory

# $2 = target directory in RAM

#

copy_to_ram()

{

   cp -R $1/* $2

   if [ $? -ne 0 ]; then fatal "can't copy to RAM, not enough memory?"; fi

}

# Copy content of "rootcopy" directory on the CD to $2 (union, usually)

# $1 = source

# $2 = destination

#

copy_rootchanges()

{

   cp -a $1/rootcopy/* $2 2>/dev/null # could be empty

}

# ===========================================================

# discovery functions

# ===========================================================

# List all CD-ROMs

# by using /proc entries

#

list_cdrom_devices()

{

   if [ "`cmdline_parameter nocd`" != "" ]; then return 1; fi

   for CDDEVICE in `cat /proc/sys/dev/cdrom/info | head -n 3 | tail -n 1 | cut -d ":" -f 2`; do

      echo "/dev/$CDDEVICE"

   done

}

# List all partition devices

# take list of all partitions and output unique disks.

# Return empty result when nohd parameter was given.

#

list_partition_devices()

{

   if [ "`cmdline_parameter nohd`" != "" ]; then return 1; fi

   cat /proc/partitions | grep -v loop | sed -r "s/^[0-9[:space:]]+/\/dev\//" | grep /dev/

}

# List all disk devices

#

list_disk_devices()

{

   list_partition_devices | egrep -v "[0-9]"

}

# List all block devices

#

list_block_devices()

{

   list_cdrom_devices

   list_partition_devices

}

# Try to mount all disks, partitions and cdroms and Find where the LiveCD is.

# If LiveCD found in the device, echo dirname of it's directory,

# and leave the device mounted. Mounting is not ro, but without any argument.

# $1 = directory where devices will be mounted

# added: mount $NFSROOT to /$1/nfs if NFSROOT is set. and search there for LiveCD

#

find_live_data_dir()

{

   if [ "$NFSROOT" != "" ]; then 

      DIR="/$1/nfs"

      mkdir -p $DIR

      # try to mount nfs dir

      mount -t nfs $NFSROOT $DIR -o $NFSOPTS 

   fi

   if [ "$CIFSROOT" != "" ]; then

      DIR="/$1/cifs"

      mkdir -p $DIR

      # try to mount cifs dir

      mount -t cifs $CIFSROOT $DIR -o ro,$CIFSOPTS

   fi

   if [ "$DIR" = "" ]; then

       list_block_devices | while read DEVICE; do

	   DIR="/$1/`basename $DEVICE`"

	   mount_device $DEVICE $DIR

	   if [ $? -ne 0 ]; then continue; fi

	   # FOUND=`find $DIR -name livecd.sgn -type f | head -n 1`

	   FOUND=`ls -A1d $DIR/livecd.sgn $DIR/*/livecd.sgn 2>/dev/null | head -n 1`

	   if [ "$FOUND" = "" ]; then umount $DIR 2>/dev/null; rmdir $DIR 2>/dev/null

	   else dirname "$FOUND"; return 1; fi

       done

   else

       # FOUND=`find $DIR -name livecd.sgn -type f | head -n 1`

       FOUND=`ls -A1d $DIR/livecd.sgn $DIR/*/livecd.sgn 2>/dev/null | head -n 1`

       if [ "$FOUND" != "" ]; then 

	   dirname "$FOUND"

       fi

   fi

}

# ===========================================================

# hardware preparation functions

# ===========================================================

# Create block devices to /dev described by /sys entries

#

create_block_devices()

{

   echolog "creating /dev entries for block devices"

   ls -A1d /sys/block/*/dev /sys/block/*/*/dev 2>/dev/null | grep -v loop | while read BLOCK; do

      DEVICE="/dev/`basename \`dirname $BLOCK\``"

      if [ ! -b $DEVICE ]; then

         MINORMAJOR="`head -n 1 $BLOCK | tr ':' ' '`"

         mknod $DEVICE b $MINORMAJOR

      fi

   done

}

# modprobe kernel modules needed for the LiveCD

#

modprobe_essential_modules()

{

   echolog "starting loop device support"

   modprobe_module loop max_loop=32

   echolog "starting cdrom support"

   modprobe_module ide_cd

   modprobe_module ide-cd

   modprobe_module sr_mod

   modprobe_module cdrom

   echolog "starting cdrom filesystem support"

   modprobe_module isofs

   echolog "starting squashfs support"

   modprobe_module squashfs

   echolog "starting unionfs/aufs support"

   modprobe_module unionfs

   modprobe_module aufs

   echolog "starting vfat support"

   # modprobe_module nls_cp437

   # modprobe_module nls_iso8859-1

   # modprobe_module nls_iso8859-2

   modprobe_module vfat

   echolog "starting ntfs support"

   modprobe_module ntfs

   modprobe_module nls_utf8

   create_block_devices

}

# modprobe kernel modules needed for USB masstorage devices

#

modprobe_usb_sata_modules()

{

   echolog "starting USB and SATA support"

   modprobe_module ehci-hcd

   modprobe_module ohci-hcd

   modprobe_module uhci-hcd

   modprobe_module scsi_mod

   modprobe_module libata

   modprobe_module ata_piix

   modprobe_module ahci

   modprobe_module sata_nv

   modprobe_module sg

   modprobe_module sd_mod

   modprobe_module sr_mod

   modprobe_module usb-storage

   echolog "waiting for USB devices, max 8 seconds"

   sleep 8

   create_block_devices

}

# modprobe nfs kernel modules

#

modprobe_nfs_modules()

{

   echolog "starting nfs support"

   modprobe_module lockd

   modprobe_module fscache

   modprobe_module nfs_acl

   modprobe_module nfs

}

# modprobe cifs kernel module

#

modprobe_cifs_modules()

{

  echolog "starting cifs support"

  modprobe_module cifs

}

# enable/disable CD autoejecting when unmounted

# $1 = 1|0 ... enable|disable

#

cd_autoeject()

{

   echo $1 >/proc/sys/dev/cdrom/autoeject

}

# Disable DMA if nodma boot parameter is present

#

setup_dma()

{

   if [ ! "`cmdline_parameter nodma`" = "" ]; then

      for DEVICE in `list_cdrom_devices` `list_disk_devices`; do

         echolog "setting DMA support off for $DEVICE"

         hdparm -d 0 $DEVICE

      done

   fi

}

# create correct fstab file in $1/etc/fstab and create apropriate

# mount directories in $1

# $1 = root directory (union)

#

activate_fstab()

{

   mkdir -p $1/etc

   FSTAB="$1/etc/fstab"

   echo "tmpfs            /                tmpfs       defaults         0   0" >$FSTAB

   echo "devpts           /dev/pts         devpts      gid=5,mode=620   0   0" >>$FSTAB

   echo "proc             /proc            proc        defaults         0   0" >>$FSTAB

   # all the rest will be done by runlast or by fstab-sync

   # search for SWAP done later in /etc/rc.sysinit

}

# find partition and/or folder that stores the changes

# return false, if changes not set or changes folder/partition not found

# Urs Beyerle

#

find_changes()

{

    echolog "looking for changes in $CHANGESVAL"

    CHANGESDEV="`echo "$CHANGESVAL" | egrep -o "^/dev/[^/]+"`"

    CHANGESFOLDER="`echo "$CHANGESVAL" | sed -r 's:^/dev/[^/]+(.*):\1:'`"

    # (re-)define CHANGES if CHANGESFOLDER is set

    if [ "$CHANGESFOLDER" != "" ]; then CHANGES=$MEMORY/$CHANGESFOLDER; fi

    # we may need usb and sata support

    modprobe_usb_sata_modules

    # device defined?

    if [ "$CHANGESDEV" != "" ]; then

	mount_device $CHANGESDEV $MEMORY

	if [ $? -eq 0 ]; then 

	    echolog "mounted $CHANGESDEV to $MEMORY"

	else

	    echolog "WARNING: device $CHANGESDEV could not be mounted! Continue booting in 10 sec. ..."

	    CHANGESVAL=""

	    sleep 10

	fi

	return

    fi

    # if no device is specified, search all devices for folder CHANGESFOLDER

    list_block_devices | while read DEVICE; do

	mount_device $DEVICE $MEMORY

	if [ $? -ne 0 ]; then continue; fi

	FOUND_FOLDER=`ls -1d $MEMORY/$CHANGESFOLDER 2>/dev/null`

	if [ "$FOUND_FOLDER" = "" ]; then 

	    umount $MEMORY 2>/dev/null

	else

	    echolog "found folder $CHANGESFOLDER on $DEVICE"

	    break

	fi

    done

    FOUND_FOLDER=`ls -1d $MEMORY/$CHANGESFOLDER 2>/dev/null`

    if [ "$FOUND_FOLDER" = "" ]; then 

	echolog "WARNING: changes=$CHANGESVAL not found! Continue booting in 10 sec. ..."

	CHANGESVAL=""

	sleep 10

    fi

}

# ===========================================================

# functions used for LiveCD on NFS 

# ===========================================================

# load network modules, if NFSROOT is set

# Urs Beyerle

#

# network devices found ?

#

found_nic()

{

    found="1"

    for iface in eth0 eth1 eth2 eth3 eth4 eth5; do

	# nic already found ?

	echo $FOUND_IFACE | grep -q $iface 

	if [ $? -ne 0 ]; then

	    ifconfig $iface > /dev/null 2>&1

	    if [ $? -eq 0 ]; then 

		FOUND_IFACE="$FOUND_IFACE $iface"

		found="0"

	    fi

	fi

    done

    return $found

}

# 1. load network driver defined by kernel parameter nic

#

load_network_module_nic()

{

    NIC="`cmdline_value nic`"

    if [ -n "$NIC" ]; then

	echolog "load module $NIC"

	modprobe_module $NIC

    fi

}

# 2. auto probe for network card drivers

#

load_network_module_auto()

{

    echolog "auto-detection of network driver ..."

    FOUND_NICS=""

    KERNEL="`uname -r`"

    NETDRIVERS="`find /lib/modules/$KERNEL/kernel/drivers/net | grep -v mii | grep .ko | cut -d"/" -f8 | cut -d"." -f1 | uniq`"

    for driver in $NETDRIVERS; do

       	modprobe_module $driver > /dev/null 2>&1

	found_nic

	if [ $? -eq 0 ]; then

	    echolog "found network card $driver"

	    echolog "load module $driver"

	    FOUND_NICS="$FOUND_NICS $driver"

	else

	    rmmod $driver > /dev/null 2>&1

	fi

    done

    # clean up: remove unused modules until driver "mii"

    LOADED_DRIVERS="`lsmod | grep -v Module | cut -d" " -f1`"

    for driver in $LOADED_DRIVERS; do

	[ "$driver" = "mii" ]  && break

	[ "$driver" = "ntfs" ] && break

	[ "$driver" = "vfat" ] && break

	do_not_remove=""

	for nic in $FOUND_NICS; do

	    echo $driver | grep -q $nic 

	    [ $? -eq 0 ] && do_not_remove="$driver"

	done

	[ ! $do_not_remove ] && rmmod $driver > /dev/null 2>&1

    done

}

# 3. detecting network card from pcitable list

#

load_network_module_pcitable()

{

    PCITABLE=/bin/pcitable

    NICS=`lspci -n | awk '/Class 0200/ {print $4}' | tr ':' ' ' \

	| while read x y ; do grep "0x$x.*0x$y" $PCITABLE \

	| awk '$3 !~ /"unknown"/ {print $3}' | tr -d '"' ; done`

    if [ -n "$NICS" ]; then

	echolog "found network card(s): $NICS"

	for driver in $NICS; do

	    echolog "load module $driver"

	    modprobe_module $driver

	done

    fi

}

# 4. ask the user for a network driver

#

load_network_module_ask()

{

    echo "ERROR: No network card detected!"

    echo "Type in your network card driver (e.g. tg3, e1000). "

    echo "Or ask your system administrator for help."

    echo -n "Network card driver: "

    read driver

    echo "load module $driver"

    modprobe_module $driver

}

# Try to find a network driver

#

load_network_modules()

{

    echolog "load network modules"

    # mii maybe need by NIC driver

    modprobe_module mii

    FOUND_IFACE=""

    load_network_module_nic

    found_nic          || load_network_module_auto

    [ "$FOUND_IFACE" ] || load_network_module_pcitable

    [ "$FOUND_IFACE" ] || load_network_module_ask

    # remove mii, if not needed

    rmmod mii > /dev/null 2>&1

}

# get DHCP lease

# Urs Beyerle

#

get_dhcp_lease()

{

    # create /dev/urandom (needed by udhcpc)

    mknod /dev/urandom c 1 9

    for iface in eth0 eth1 eth2 eth3 eth4 eth5; do

	# interface up ?

	ifconfig $iface > /dev/null 2>&1

	if [ $? -eq 0 ]; then

	    # get dhcp lease

	    echolog "try to get DHCP lease on $iface"

	    udhcpc --now --quit --interface=$iface --script=/bin/udhcpc.script

	    [ $? -eq 0 ] && return

	    echo "ERROR: couldn't get DHCP lease on $iface."

	fi

    done

}