WebSVN – livecd – Diff – /trunk/linux-live.sl/initrd/liblinuxlive


#!/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
# - add sata_svw
# - add $DHCPDELAY parameter
# - add $USBDELAY parameter
#
 
# ===========================================================
# 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 "[0;1m$1[0;0m"
}
 
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 sata_svw
   modprobe_module sg
 
   modprobe_module sd_mod
   modprobe_module sr_mod
   modprobe_module usb-storage
   echolog "waiting $USBDELAY seconds for USB devices"
   sleep $USBDELAY
   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 up > /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 -v 8021q | 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 and 8021q maybe need by NIC driver
    modprobe_module 8021q
    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 and 8021q, if not needed
    rmmod 8021q > /dev/null 2>&1
    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
    
    # wait for interface coming up
    if [ $DHCPDELAY -gt 0 ]; then 
        echolog "delaying DHCP for $DHCPDELAY seconds (dhcpdelay=$DHCPDELAY) ..."
        sleep $DHCPDELAY
        echolog "if getting dhcp lease freezes, try define a higher dhcpdelay value as boot parameter."
    fi
    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
	    echolog "ERROR: couldn't get DHCP lease on $iface."
	fi
    done
}

Rev 246	Rev 248
1	`#!/bin/ash`	1	`#!/bin/ash`
2	`#`	2	`#`
3	`# Functions library :: for Linux Live scripts 5.x.y`	3	`# Functions library :: for Linux Live scripts 5.x.y`
4	`# Author: Tomas M. <http://www.linux-live.org>`	4	`# Author: Tomas M. <http://www.linux-live.org>`
5	`#`	5	`#`
6	`# modified by Urs Beyerle`	6	`# modified by Urs Beyerle`
7	`# - to allow LiveCD mounted over nfs`	7	`# - to allow LiveCD mounted over nfs`
8	`# - add scsi_mod, sd_mod for usb-storage module`	8	`# - add scsi_mod, sd_mod for usb-storage module`
9	`# - only with boot option "automount", all devices in fstab are rw automounted`	9	`# - only with boot option "automount", all devices in fstab are rw automounted`
10	`# - remove detect of CD and Floppy (done by fstab-sync)`	10	`# - remove detect of CD and Floppy (done by fstab-sync)`
11	`# - add sr_mod (USB CDROM support)`	11	`# - add sr_mod (USB CDROM support)`
12	`# - add SATA to modprobe_usb_modules -> modprobe_usb_sata_modules`	12	`# - add SATA to modprobe_usb_modules -> modprobe_usb_sata_modules`
13	`# - add fscache (for SL5)`	13	`# - add fscache (for SL5)`
14	`# - add ide-cd, sr_mod, cdrom (for SL5 cdrom support)`	14	`# - add ide-cd, sr_mod, cdrom (for SL5 cdrom support)`
15	`# - add aufs (unionfs replacement)`	15	`# - add aufs (unionfs replacement)`
16	`# - to allow LiveCD mounted over NFS (for diskless client)`	16	`# - to allow LiveCD mounted over NFS (for diskless client)`
17	`# - add functions get_dhcp_lease() and load_network_modules()`	17	`# - add functions get_dhcp_lease() and load_network_modules()`
18	`# - add ata_piix to modprobe_usb_sata_modules`	18	`# - add ata_piix to modprobe_usb_sata_modules`
19	`# - works with unionfs 2.x`	19	`# - works with unionfs 2.x`
20	`# - better detection of network card in case of diskless client`	20	`# - better detection of network card in case of diskless client`
21	`# - add sg, sata_nv module`	21	`# - add sg, sata_nv module`
22	`# - to allow LiveCD mounted over CIFS (for diskless client)`	22	`# - to allow LiveCD mounted over CIFS (for diskless client)`
23	`# - add function find_changes`	23	`# - add function find_changes`
24	`# - add sata_svw`	24	`# - add sata_svw`
25	`# - add $DHCPDELAY parameter`	25	`# - add $DHCPDELAY parameter`
-		26	`# - add $USBDELAY parameter`
26	`#`	27	`#`
27		28
28	`# ===========================================================`	29	`# ===========================================================`
29	`# user interface functions`	30	`# user interface functions`
30	`# ===========================================================`	31	`# ===========================================================`
31		32
32	`# echolog`	33	`# echolog`
33	`# $1 = text to show and to write to /var/log/messages`	34	`# $1 = text to show and to write to /var/log/messages`
34	`#`	35	`#`
35	`echolog()`	36	`echolog()`
36	`{`	37	`{`
37	`echo "LIVECD:" "$@" >>/var/log/livedbg`	38	`echo "LIVECD:" "$@" >>/var/log/livedbg`
38	`echo "$@"`	39	`echo "$@"`
39	`}`	40	`}`
40		41
41	`# debug`	42	`# debug`
42	`# commands executed when debug boot parameter is present`	43	`# commands executed when debug boot parameter is present`
43	`#`	44	`#`
44	`debug()`	45	`debug()`
45	`{`	46	`{`
46	`echo`	47	`echo`
47	`echo "====="`	48	`echo "====="`
48	`echo ": Debugging started. Here is the root shell for you."`	49	`echo ": Debugging started. Here is the root shell for you."`
49	`echo ": Type your desired command or hit Ctrl+D to continue booting."`	50	`echo ": Type your desired command or hit Ctrl+D to continue booting."`
50	`echo`	51	`echo`
51	`ash`	52	`ash`
52	`}`	53	`}`
53		54
54	`# header`	55	`# header`
55	`# $1 = text to show`	56	`# $1 = text to show`
56	`#`	57	`#`
57	`header()`	58	`header()`
58	`{`	59	`{`
59	`echolog "[0;1m$1[0;0m"`	60	`echolog "[0;1m$1[0;0m"`
60	`}`	61	`}`
61		62
62	`fatal()`	63	`fatal()`
63	`{`	64	`{`
64	`header "Fatal error occured - $1"`	65	`header "Fatal error occured - $1"`
65	`echolog "Something went wrong and we can't continue booting :("`	66	`echolog "Something went wrong and we can't continue booting :("`
66	`echolog "You may explore the system by using simple commands like ls, lsmod, mount, etc."`	67	`echolog "You may explore the system by using simple commands like ls, lsmod, mount, etc."`
67	`echolog "You may also try to hit Ctrl+D. Booting will continue. Use at your own risk."`	68	`echolog "You may also try to hit Ctrl+D. Booting will continue. Use at your own risk."`
68	`echolog "To be safe, hit Ctrl+Alt+Delete to reboot."`	69	`echolog "To be safe, hit Ctrl+Alt+Delete to reboot."`
69	`echolog`	70	`echolog`
70	`ash`	71	`ash`
71	`}`	72	`}`
72		73
73	`# ===========================================================`	74	`# ===========================================================`
74	`# text processing functions`	75	`# text processing functions`
75	`# ===========================================================`	76	`# ===========================================================`
76		77
77	`# egrep_o is a replacement for "egrep -o". It prints only the last`	78	`# egrep_o is a replacement for "egrep -o". It prints only the last`
78	`# matching text`	79	`# matching text`
79	`# $1 = regular expression`	80	`# $1 = regular expression`
80	`#`	81	`#`
81	`egrep_o()`	82	`egrep_o()`
82	`{`	83	`{`
83	`cat \| egrep "$1" \| sed -r "s/.($1)./\\1/"`	84	`cat \| egrep "$1" \| sed -r "s/.($1)./\\1/"`
84	`}`	85	`}`
85		86
86	`# look into cmdline and echo $1 back if $1 is set`	87	`# look into cmdline and echo $1 back if $1 is set`
87	`# $1 = value name, case sensitive, for example livecd_subdir`	88	`# $1 = value name, case sensitive, for example livecd_subdir`
88	`# $2 = file to use instead /proc/cmdline, optional`	89	`# $2 = file to use instead /proc/cmdline, optional`
89	`#`	90	`#`
90	`cmdline_parameter()`	91	`cmdline_parameter()`
91	`{`	92	`{`
92	`CMDLINE=/proc/cmdline`	93	`CMDLINE=/proc/cmdline`
93	`if [ "$2" != "" ]; then CMDLINE="$2"; fi`	94	`if [ "$2" != "" ]; then CMDLINE="$2"; fi`
94	`cat "$CMDLINE" \| egrep_o "(^\|[[:space:]]+)$1(\$\|=\|[[:space:]]+)" \| egrep_o "$1"`	95	`cat "$CMDLINE" \| egrep_o "(^\|[[:space:]]+)$1(\$\|=\|[[:space:]]+)" \| egrep_o "$1"`
95	`}`	96	`}`
96		97
97	`# look into cmdline and echo value of $1 option`	98	`# look into cmdline and echo value of $1 option`
98	`# $1 = value name, case sensitive, for example livecd_subdir`	99	`# $1 = value name, case sensitive, for example livecd_subdir`
99	`# $2 = file to use instead /proc/cmdline, optional`	100	`# $2 = file to use instead /proc/cmdline, optional`
100	`#`	101	`#`
101	`cmdline_value()`	102	`cmdline_value()`
102	`{`	103	`{`
103	`CMDLINE=/proc/cmdline`	104	`CMDLINE=/proc/cmdline`
104	`if [ "$2" != "" ]; then CMDLINE="$2"; fi`	105	`if [ "$2" != "" ]; then CMDLINE="$2"; fi`
105	`cat "$CMDLINE" \| egrep_o "(^\|[[:space:]]+)$1=([^[:space:]]+)" \| egrep_o "=.*" \| cut -b 2- \| tail -n 1`	106	`cat "$CMDLINE" \| egrep_o "(^\|[[:space:]]+)$1=([^[:space:]]+)" \| egrep_o "=.*" \| cut -b 2- \| tail -n 1`
106	`}`	107	`}`
107		108
108	`# ===========================================================`	109	`# ===========================================================`
109	`# system functions`	110	`# system functions`
110	`# ===========================================================`	111	`# ===========================================================`
111		112
112	`# modprobe module $1, including all dependencies, suppress all messages`	113	`# modprobe module $1, including all dependencies, suppress all messages`
113	`# (own function because modprobe in busybox doesn't work with gzipped modules)`	114	`# (own function because modprobe in busybox doesn't work with gzipped modules)`
114	`# $1 = module name, eg. ehci-hcd`	115	`# $1 = module name, eg. ehci-hcd`
115	`# $2 = optional argument`	116	`# $2 = optional argument`
116	`#`	117	`#`
117	`modprobe_module()`	118	`modprobe_module()`
118	`{`	119	`{`
119	`if [ "$1" = "" ]; then return 1; fi`	120	`if [ "$1" = "" ]; then return 1; fi`
120	PRINTK=`cat /proc/sys/kernel/printk`	121	PRINTK=`cat /proc/sys/kernel/printk`
121	`echo "0" >/proc/sys/kernel/printk`	122	`echo "0" >/proc/sys/kernel/printk`
122		123
123	KERNEL="`uname -r`"; LSMOD=/tmp/lsmod	124	KERNEL="`uname -r`"; LSMOD=/tmp/lsmod
124	MODULEDEPS="`cat /lib/modules/$KERNEL/modules.dep \| egrep \"$1\\.ko(\\.gz)?:\"`"	125	MODULEDEPS="`cat /lib/modules/$KERNEL/modules.dep \| egrep \"$1\\.ko(\\.gz)?:\"`"
125		126
126	for MODULE in `echo $MODULEDEPS \| cut -d ":" -f 2-` `echo $MODULEDEPS \| cut -d ":" -f 1`; do	127	for MODULE in `echo $MODULEDEPS \| cut -d ":" -f 2-` `echo $MODULEDEPS \| cut -d ":" -f 1`; do
127	`MODULE=${MODULE%%:}; # remove : at the end, a bug`	128	`MODULE=${MODULE%%:}; # remove : at the end, a bug`
128	TMPMOD="/tmp/`basename $MODULE .gz`";	129	TMPMOD="/tmp/`basename $MODULE .gz`";
129	`# if the module is not loaded already`	130	`# if the module is not loaded already`
130	if [ "`cat $LSMOD 2>/dev/null \| egrep \"^$TMPMOD\\\$\"`" = "" ]; then	131	if [ "`cat $LSMOD 2>/dev/null \| egrep \"^$TMPMOD\\\$\"`" = "" ]; then
131	`gunzip -c $MODULE 2>/dev/null >$TMPMOD`	132	`gunzip -c $MODULE 2>/dev/null >$TMPMOD`
132	`if [ $? -ne 0 ]; then cp $MODULE $TMPMOD; fi # can't gunzip? copy`	133	`if [ $? -ne 0 ]; then cp $MODULE $TMPMOD; fi # can't gunzip? copy`
133	`insmod $TMPMOD $2; err=$?`	134	`insmod $TMPMOD $2; err=$?`
134	`### insmod $TMPMOD $2 >/dev/null 2>/dev/null; err=$?`	135	`### insmod $TMPMOD $2 >/dev/null 2>/dev/null; err=$?`
135	`if [ "$err" -eq 0 ]; then echo $TMPMOD >>$LSMOD; fi # module log`	136	`if [ "$err" -eq 0 ]; then echo $TMPMOD >>$LSMOD; fi # module log`
136	`rm $TMPMOD`	137	`rm $TMPMOD`
137	`fi`	138	`fi`
138	`done`	139	`done`
139		140
140	`echo "$PRINTK" >/proc/sys/kernel/printk`	141	`echo "$PRINTK" >/proc/sys/kernel/printk`
141	`if [ "$err" -ne 0 ]; then echolog "error inserting module $1 ($err)"; fi`	142	`if [ "$err" -ne 0 ]; then echolog "error inserting module $1 ($err)"; fi`
142	`return $err`	143	`return $err`
143	`}`	144	`}`
144		145
145	`# Mount device $1 to $2`	146	`# Mount device $1 to $2`
146	`# $1 = /dev device to mount, eg. /dev/hda1`	147	`# $1 = /dev device to mount, eg. /dev/hda1`
147	`# $2 = mountpoint, eg. /mnt/hda1`	148	`# $2 = mountpoint, eg. /mnt/hda1`
148	`# $3 = mount options, for example "loop", "ro", or "remount,rw"`	149	`# $3 = mount options, for example "loop", "ro", or "remount,rw"`
149	`#`	150	`#`
150	`mount_device()`	151	`mount_device()`
151	`{`	152	`{`
152	`mkdir -p $2`	153	`mkdir -p $2`
153	`if [ "$3" != "" ]; then OPTIONS="-o $3"; else OPTIONS=""; fi`	154	`if [ "$3" != "" ]; then OPTIONS="-o $3"; else OPTIONS=""; fi`
154		155
155	PRINTK=`cat /proc/sys/kernel/printk`	156	PRINTK=`cat /proc/sys/kernel/printk`
156	`echo "0" >/proc/sys/kernel/printk`	157	`echo "0" >/proc/sys/kernel/printk`
157		158
158	`mount -t auto $1 $2 $OPTIONS >/dev/null 2>/dev/null`	159	`mount -t auto $1 $2 $OPTIONS >/dev/null 2>/dev/null`
159	`err=$?`	160	`err=$?`
160		161
161	`if [ "$err" -ne 0 ]; then rmdir $2 2>/dev/null; fi`	162	`if [ "$err" -ne 0 ]; then rmdir $2 2>/dev/null; fi`
162	`echo "$PRINTK" >/proc/sys/kernel/printk`	163	`echo "$PRINTK" >/proc/sys/kernel/printk`
163	`return $err`	164	`return $err`
164	`}`	165	`}`
165		166
166	`# ===========================================================`	167	`# ===========================================================`
167	`# live module functions`	168	`# live module functions`
168	`# ===========================================================`	169	`# ===========================================================`
169		170
170	`# Create module`	171	`# Create module`
171	`# call mksquashfs with apropriate arguments`	172	`# call mksquashfs with apropriate arguments`
172	`# $1 = directory which will be compressed to squashfs module`	173	`# $1 = directory which will be compressed to squashfs module`
173	`# $2 = output .mo file`	174	`# $2 = output .mo file`
174	`# $3 = optional -keep-as-directory argument`	175	`# $3 = optional -keep-as-directory argument`
175	`#`	176	`#`
176	`create_module()`	177	`create_module()`
177	`{`	178	`{`
178	`mksquashfs $1 $2 $3 >/dev/null`	179	`mksquashfs $1 $2 $3 >/dev/null`
179	`if [ $? -ne 0 ]; then return 1; fi`	180	`if [ $? -ne 0 ]; then return 1; fi`
180	`chmod oga-x $2 # remove execute attrib`	181	`chmod oga-x $2 # remove execute attrib`
181	`}`	182	`}`
182		183
183	`# Mount .mo module to destination directory`	184	`# Mount .mo module to destination directory`
184	`# $1 = path to .mo livecd compressed module`	185	`# $1 = path to .mo livecd compressed module`
185	`# $2 = destination folder`	186	`# $2 = destination folder`
186	`#`	187	`#`
187	`mount_module()`	188	`mount_module()`
188	`{`	189	`{`
189	`mount -t squashfs -o loop,ro $1 $2`	190	`mount -t squashfs -o loop,ro $1 $2`
190	`}`	191	`}`
191		192
192	`# Insert a directory tree $2 to an union specified by $1`	193	`# Insert a directory tree $2 to an union specified by $1`
193	`# Top-level read-write branch is specified by it's index 0`	194	`# Top-level read-write branch is specified by it's index 0`
194	`# $1 = union absolute path (starting with /)`	195	`# $1 = union absolute path (starting with /)`
195	`# $2 = path to data directory`	196	`# $2 = path to data directory`
196	`#`	197	`#`
197	`union_insert_dir()`	198	`union_insert_dir()`
198	`{`	199	`{`
199	`which unionctl >/dev/null 2>&1`	200	`which unionctl >/dev/null 2>&1`
200	`if [ $? -eq 0 ]; then`	201	`if [ $? -eq 0 ]; then`
201	`# unionfs 1.x or aufs`	202	`# unionfs 1.x or aufs`
202	`unionctl "$1" --add --after 0 --mode ro "$2"`	203	`unionctl "$1" --add --after 0 --mode ro "$2"`
203	`else`	204	`else`
204	`# unionfs 2.x`	205	`# unionfs 2.x`
205	`mount -t unionfs -o remount,add=:${2}=ro none "$1"`	206	`mount -t unionfs -o remount,add=:${2}=ro none "$1"`
206	`fi`	207	`fi`
207	`}`	208	`}`
208		209
209	`# List all modules in all directories (base, modules, optional)`	210	`# List all modules in all directories (base, modules, optional)`
210	`# and filter out unneeded optional modules (not specified by load= kernel parameter)`	211	`# and filter out unneeded optional modules (not specified by load= kernel parameter)`
211	`# $1 = root directory of mounted DATAdir`	212	`# $1 = root directory of mounted DATAdir`
212	`#`	213	`#`
213	`list_modules()`	214	`list_modules()`
214	`{`	215	`{`
215	LOAD="`cmdline_value load`"	216	LOAD="`cmdline_value load`"
216	`ls -A1d $1/.mo $1//*.mo 2>/dev/null \| while read LINE; do`	217	`ls -A1d $1/.mo $1//*.mo 2>/dev/null \| while read LINE; do`
217	MODNAME="`basename $LINE .mo`"	218	MODNAME="`basename $LINE .mo`"
218	if [ "$LOAD" != "*" -a "`echo $LINE \| grep optional`" != "" -a "`echo $LOAD \| egrep \"(^\|,)$MODNAME(\\\$\|,)\"`" = "" ]; then continue	219	if [ "$LOAD" != "*" -a "`echo $LINE \| grep optional`" != "" -a "`echo $LOAD \| egrep \"(^\|,)$MODNAME(\\\$\|,)\"`" = "" ]; then continue
219	`else echo $LINE; fi`	220	`else echo $LINE; fi`
220	`done`	221	`done`
221	`}`	222	`}`
222		223
223	`# Insert one single .mo module to the union`	224	`# Insert one single .mo module to the union`
224	`# $1 = union absolute path (starting with /)`	225	`# $1 = union absolute path (starting with /)`
225	`# $2 = module.mo full path`	226	`# $2 = module.mo full path`
226	`# $3 = destination folder, where images will be mounted to`	227	`# $3 = destination folder, where images will be mounted to`
227	`#`	228	`#`
228	`union_insert_module()`	229	`union_insert_module()`
229	`{`	230	`{`
230	TARGET="$3/`basename $2`"	231	TARGET="$3/`basename $2`"
231	`while [ -e $TARGET ]; do TARGET=$TARGET.X; done`	232	`while [ -e $TARGET ]; do TARGET=$TARGET.X; done`
232	`mkdir -p $TARGET`	233	`mkdir -p $TARGET`
233	`mount_module $2 $TARGET`	234	`mount_module $2 $TARGET`
234	`if [ $? -ne 0 ]; then echo "can't read module data"; return 1; fi`	235	`if [ $? -ne 0 ]; then echo "can't read module data"; return 1; fi`
235	`union_insert_dir $1 $TARGET;`	236	`union_insert_dir $1 $TARGET;`
236	`}`	237	`}`
237		238
238	`# Insert all .mo modules, in $2 directory and subdirectories, to the union`	239	`# Insert all .mo modules, in $2 directory and subdirectories, to the union`
239	`# $1 = union absolute path (starting with /)`	240	`# $1 = union absolute path (starting with /)`
240	`# $2 = LiveCD data dir (with directories /base, /modules, etc.)`	241	`# $2 = LiveCD data dir (with directories /base, /modules, etc.)`
241	`# $3 = destination folder, where images will be mounted to`	242	`# $3 = destination folder, where images will be mounted to`
242	`#`	243	`#`
243	`union_insert_modules()`	244	`union_insert_modules()`
244	`{`	245	`{`
245	PRINTK=`cat /proc/sys/kernel/printk`	246	PRINTK=`cat /proc/sys/kernel/printk`
246	`echo "0" >/proc/sys/kernel/printk`	247	`echo "0" >/proc/sys/kernel/printk`
247		248
248	`list_modules $2 \| while read MODULE; do`	249	`list_modules $2 \| while read MODULE; do`
249	echo " -> `basename $MODULE`"	250	echo " -> `basename $MODULE`"
250	`union_insert_module $1 $MODULE $3`	251	`union_insert_module $1 $MODULE $3`
251	`done`	252	`done`
252		253
253	`echo "$PRINTK" >/proc/sys/kernel/printk`	254	`echo "$PRINTK" >/proc/sys/kernel/printk`
254	`}`	255	`}`
255		256
256	`# Copy modules to RAM directory`	257	`# Copy modules to RAM directory`
257	`# $1 = data directory`	258	`# $1 = data directory`
258	`# $2 = target directory in RAM`	259	`# $2 = target directory in RAM`
259	`#`	260	`#`
260	`copy_to_ram()`	261	`copy_to_ram()`
261	`{`	262	`{`
262	`cp -R $1/* $2`	263	`cp -R $1/* $2`
263	`if [ $? -ne 0 ]; then fatal "can't copy to RAM, not enough memory?"; fi`	264	`if [ $? -ne 0 ]; then fatal "can't copy to RAM, not enough memory?"; fi`
264	`}`	265	`}`
265		266
266	`# Copy content of "rootcopy" directory on the CD to $2 (union, usually)`	267	`# Copy content of "rootcopy" directory on the CD to $2 (union, usually)`
267	`# $1 = source`	268	`# $1 = source`
268	`# $2 = destination`	269	`# $2 = destination`
269	`#`	270	`#`
270	`copy_rootchanges()`	271	`copy_rootchanges()`
271	`{`	272	`{`
272	`cp -a $1/rootcopy/* $2 2>/dev/null # could be empty`	273	`cp -a $1/rootcopy/* $2 2>/dev/null # could be empty`
273	`}`	274	`}`
274		275
275	`# ===========================================================`	276	`# ===========================================================`
276	`# discovery functions`	277	`# discovery functions`
277	`# ===========================================================`	278	`# ===========================================================`
278		279
279	`# List all CD-ROMs`	280	`# List all CD-ROMs`
280	`# by using /proc entries`	281	`# by using /proc entries`
281	`#`	282	`#`
282	`list_cdrom_devices()`	283	`list_cdrom_devices()`
283	`{`	284	`{`
284	if [ "`cmdline_parameter nocd`" != "" ]; then return 1; fi	285	if [ "`cmdline_parameter nocd`" != "" ]; then return 1; fi
285	for CDDEVICE in `cat /proc/sys/dev/cdrom/info \| head -n 3 \| tail -n 1 \| cut -d ":" -f 2`; do	286	for CDDEVICE in `cat /proc/sys/dev/cdrom/info \| head -n 3 \| tail -n 1 \| cut -d ":" -f 2`; do
286	`echo "/dev/$CDDEVICE"`	287	`echo "/dev/$CDDEVICE"`
287	`done`	288	`done`
288	`}`	289	`}`
289		290
290	`# List all partition devices`	291	`# List all partition devices`
291	`# take list of all partitions and output unique disks.`	292	`# take list of all partitions and output unique disks.`
292	`# Return empty result when nohd parameter was given.`	293	`# Return empty result when nohd parameter was given.`
293	`#`	294	`#`
294	`list_partition_devices()`	295	`list_partition_devices()`
295	`{`	296	`{`
296	if [ "`cmdline_parameter nohd`" != "" ]; then return 1; fi	297	if [ "`cmdline_parameter nohd`" != "" ]; then return 1; fi
297	`cat /proc/partitions \| grep -v loop \| sed -r "s/^[0-9[:space:]]+/\/dev\//" \| grep /dev/`	298	`cat /proc/partitions \| grep -v loop \| sed -r "s/^[0-9[:space:]]+/\/dev\//" \| grep /dev/`
298	`}`	299	`}`
299		300
300	`# List all disk devices`	301	`# List all disk devices`
301	`#`	302	`#`
302	`list_disk_devices()`	303	`list_disk_devices()`
303	`{`	304	`{`
304	`list_partition_devices \| egrep -v "[0-9]"`	305	`list_partition_devices \| egrep -v "[0-9]"`
305	`}`	306	`}`
306		307
307	`# List all block devices`	308	`# List all block devices`
308	`#`	309	`#`
309	`list_block_devices()`	310	`list_block_devices()`
310	`{`	311	`{`
311	`list_cdrom_devices`	312	`list_cdrom_devices`
312	`list_partition_devices`	313	`list_partition_devices`
313	`}`	314	`}`
314		315
315	`# Try to mount all disks, partitions and cdroms and Find where the LiveCD is.`	316	`# Try to mount all disks, partitions and cdroms and Find where the LiveCD is.`
316	`# If LiveCD found in the device, echo dirname of it's directory,`	317	`# If LiveCD found in the device, echo dirname of it's directory,`
317	`# and leave the device mounted. Mounting is not ro, but without any argument.`	318	`# and leave the device mounted. Mounting is not ro, but without any argument.`
318	`# $1 = directory where devices will be mounted`	319	`# $1 = directory where devices will be mounted`
319	`# added: mount $NFSROOT to /$1/nfs if NFSROOT is set. and search there for LiveCD`	320	`# added: mount $NFSROOT to /$1/nfs if NFSROOT is set. and search there for LiveCD`
320	`#`	321	`#`
321	`find_live_data_dir()`	322	`find_live_data_dir()`
322	`{`	323	`{`
323	`if [ "$NFSROOT" != "" ]; then`	324	`if [ "$NFSROOT" != "" ]; then`
324	`DIR="/$1/nfs"`	325	`DIR="/$1/nfs"`
325	`mkdir -p $DIR`	326	`mkdir -p $DIR`
326	`# try to mount nfs dir`	327	`# try to mount nfs dir`
327	`mount -t nfs $NFSROOT $DIR -o $NFSOPTS`	328	`mount -t nfs $NFSROOT $DIR -o $NFSOPTS`
328	`fi`	329	`fi`
329		330
330	`if [ "$CIFSROOT" != "" ]; then`	331	`if [ "$CIFSROOT" != "" ]; then`
331	`DIR="/$1/cifs"`	332	`DIR="/$1/cifs"`
332	`mkdir -p $DIR`	333	`mkdir -p $DIR`
333	`# try to mount cifs dir`	334	`# try to mount cifs dir`
334	`mount -t cifs $CIFSROOT $DIR -o ro,$CIFSOPTS`	335	`mount -t cifs $CIFSROOT $DIR -o ro,$CIFSOPTS`
335	`fi`	336	`fi`
336		337
337	`if [ "$DIR" = "" ]; then`	338	`if [ "$DIR" = "" ]; then`
338	`list_block_devices \| while read DEVICE; do`	339	`list_block_devices \| while read DEVICE; do`
339	DIR="/$1/`basename $DEVICE`"	340	DIR="/$1/`basename $DEVICE`"
340	`mount_device $DEVICE $DIR`	341	`mount_device $DEVICE $DIR`
341	`if [ $? -ne 0 ]; then continue; fi`	342	`if [ $? -ne 0 ]; then continue; fi`
342	# FOUND=`find $DIR -name livecd.sgn -type f \| head -n 1`	343	# FOUND=`find $DIR -name livecd.sgn -type f \| head -n 1`
343	FOUND=`ls -A1d $DIR/livecd.sgn $DIR/*/livecd.sgn 2>/dev/null \| head -n 1`	344	FOUND=`ls -A1d $DIR/livecd.sgn $DIR/*/livecd.sgn 2>/dev/null \| head -n 1`
344	`if [ "$FOUND" = "" ]; then umount $DIR 2>/dev/null; rmdir $DIR 2>/dev/null`	345	`if [ "$FOUND" = "" ]; then umount $DIR 2>/dev/null; rmdir $DIR 2>/dev/null`
345	`else dirname "$FOUND"; return 1; fi`	346	`else dirname "$FOUND"; return 1; fi`
346	`done`	347	`done`
347	`else`	348	`else`
348	# FOUND=`find $DIR -name livecd.sgn -type f \| head -n 1`	349	# FOUND=`find $DIR -name livecd.sgn -type f \| head -n 1`
349	FOUND=`ls -A1d $DIR/livecd.sgn $DIR/*/livecd.sgn 2>/dev/null \| head -n 1`	350	FOUND=`ls -A1d $DIR/livecd.sgn $DIR/*/livecd.sgn 2>/dev/null \| head -n 1`
350	`if [ "$FOUND" != "" ]; then`	351	`if [ "$FOUND" != "" ]; then`
351	`dirname "$FOUND"`	352	`dirname "$FOUND"`
352	`fi`	353	`fi`
353	`fi`	354	`fi`
354	`}`	355	`}`
355		356
356	`# ===========================================================`	357	`# ===========================================================`
357	`# hardware preparation functions`	358	`# hardware preparation functions`
358	`# ===========================================================`	359	`# ===========================================================`
359		360
360	`# Create block devices to /dev described by /sys entries`	361	`# Create block devices to /dev described by /sys entries`
361	`#`	362	`#`
362	`create_block_devices()`	363	`create_block_devices()`
363	`{`	364	`{`
364	`echolog "creating /dev entries for block devices"`	365	`echolog "creating /dev entries for block devices"`
365	`ls -A1d /sys/block//dev /sys/block//*/dev 2>/dev/null \| grep -v loop \| while read BLOCK; do`	366	`ls -A1d /sys/block//dev /sys/block//*/dev 2>/dev/null \| grep -v loop \| while read BLOCK; do`
366	DEVICE="/dev/`basename \`dirname $BLOCK\``"	367	DEVICE="/dev/`basename \`dirname $BLOCK\``"
367	`if [ ! -b $DEVICE ]; then`	368	`if [ ! -b $DEVICE ]; then`
368	MINORMAJOR="`head -n 1 $BLOCK \| tr ':' ' '`"	369	MINORMAJOR="`head -n 1 $BLOCK \| tr ':' ' '`"
369	`mknod $DEVICE b $MINORMAJOR`	370	`mknod $DEVICE b $MINORMAJOR`
370	`fi`	371	`fi`
371	`done`	372	`done`
372	`}`	373	`}`
373		374
374	`# modprobe kernel modules needed for the LiveCD`	375	`# modprobe kernel modules needed for the LiveCD`
375	`#`	376	`#`
376	`modprobe_essential_modules()`	377	`modprobe_essential_modules()`
377	`{`	378	`{`
378	`echolog "starting loop device support"`	379	`echolog "starting loop device support"`
379	`modprobe_module loop max_loop=32`	380	`modprobe_module loop max_loop=32`
380	`echolog "starting cdrom support"`	381	`echolog "starting cdrom support"`
381	`modprobe_module ide_cd`	382	`modprobe_module ide_cd`
382	`modprobe_module ide-cd`	383	`modprobe_module ide-cd`
383	`modprobe_module sr_mod`	384	`modprobe_module sr_mod`
384	`modprobe_module cdrom`	385	`modprobe_module cdrom`
385	`echolog "starting cdrom filesystem support"`	386	`echolog "starting cdrom filesystem support"`
386	`modprobe_module isofs`	387	`modprobe_module isofs`
387	`echolog "starting squashfs support"`	388	`echolog "starting squashfs support"`
388	`modprobe_module squashfs`	389	`modprobe_module squashfs`
389	`echolog "starting unionfs/aufs support"`	390	`echolog "starting unionfs/aufs support"`
390	`modprobe_module unionfs`	391	`modprobe_module unionfs`
391	`modprobe_module aufs`	392	`modprobe_module aufs`
392	`echolog "starting vfat support"`	393	`echolog "starting vfat support"`
393	`# modprobe_module nls_cp437`	394	`# modprobe_module nls_cp437`
394	`# modprobe_module nls_iso8859-1`	395	`# modprobe_module nls_iso8859-1`
395	`# modprobe_module nls_iso8859-2`	396	`# modprobe_module nls_iso8859-2`
396	`modprobe_module vfat`	397	`modprobe_module vfat`
397	`echolog "starting ntfs support"`	398	`echolog "starting ntfs support"`
398	`modprobe_module ntfs`	399	`modprobe_module ntfs`
399	`modprobe_module nls_utf8`	400	`modprobe_module nls_utf8`
400	`create_block_devices`	401	`create_block_devices`
401	`}`	402	`}`
402		403
403		404
404	`# modprobe kernel modules needed for USB masstorage devices`	405	`# modprobe kernel modules needed for USB masstorage devices`
405	`#`	406	`#`
406	`modprobe_usb_sata_modules()`	407	`modprobe_usb_sata_modules()`
407	`{`	408	`{`
408	`echolog "starting USB and SATA support"`	409	`echolog "starting USB and SATA support"`
409	`modprobe_module ehci-hcd`	410	`modprobe_module ehci-hcd`
410	`modprobe_module ohci-hcd`	411	`modprobe_module ohci-hcd`
411	`modprobe_module uhci-hcd`	412	`modprobe_module uhci-hcd`
412	`modprobe_module scsi_mod`	413	`modprobe_module scsi_mod`
413		414
414	`modprobe_module libata`	415	`modprobe_module libata`
415	`modprobe_module ata_piix`	416	`modprobe_module ata_piix`
416	`modprobe_module ahci`	417	`modprobe_module ahci`
417	`modprobe_module sata_nv`	418	`modprobe_module sata_nv`
418	`modprobe_module sata_svw`	419	`modprobe_module sata_svw`
419	`modprobe_module sg`	420	`modprobe_module sg`
420		421
421	`modprobe_module sd_mod`	422	`modprobe_module sd_mod`
422	`modprobe_module sr_mod`	423	`modprobe_module sr_mod`
423	`modprobe_module usb-storage`	424	`modprobe_module usb-storage`
424	`echolog "waiting for USB devices, max 8 seconds"`	425	`echolog "waiting $USBDELAY seconds for USB devices"`
425	`sleep 8`	426	`sleep $USBDELAY`
426	`create_block_devices`	427	`create_block_devices`
427	`}`	428	`}`
428		429
429	`# modprobe nfs kernel modules`	430	`# modprobe nfs kernel modules`
430	`#`	431	`#`
431	`modprobe_nfs_modules()`	432	`modprobe_nfs_modules()`
432	`{`	433	`{`
433	`echolog "starting nfs support"`	434	`echolog "starting nfs support"`
434	`modprobe_module lockd`	435	`modprobe_module lockd`
435	`modprobe_module fscache`	436	`modprobe_module fscache`
436	`modprobe_module nfs_acl`	437	`modprobe_module nfs_acl`
437	`modprobe_module nfs`	438	`modprobe_module nfs`
438	`}`	439	`}`
439		440
440	`# modprobe cifs kernel module`	441	`# modprobe cifs kernel module`
441	`#`	442	`#`
442	`modprobe_cifs_modules()`	443	`modprobe_cifs_modules()`
443	`{`	444	`{`
444	`echolog "starting cifs support"`	445	`echolog "starting cifs support"`
445	`modprobe_module cifs`	446	`modprobe_module cifs`
446	`}`	447	`}`
447		448
448	`# enable/disable CD autoejecting when unmounted`	449	`# enable/disable CD autoejecting when unmounted`
449	`# $1 = 1\|0 ... enable\|disable`	450	`# $1 = 1\|0 ... enable\|disable`
450	`#`	451	`#`
451	`cd_autoeject()`	452	`cd_autoeject()`
452	`{`	453	`{`
453	`echo $1 >/proc/sys/dev/cdrom/autoeject`	454	`echo $1 >/proc/sys/dev/cdrom/autoeject`
454	`}`	455	`}`
455		456
456	`# Disable DMA if nodma boot parameter is present`	457	`# Disable DMA if nodma boot parameter is present`
457	`#`	458	`#`
458	`setup_dma()`	459	`setup_dma()`
459	`{`	460	`{`
460	if [ ! "`cmdline_parameter nodma`" = "" ]; then	461	if [ ! "`cmdline_parameter nodma`" = "" ]; then
461	for DEVICE in `list_cdrom_devices` `list_disk_devices`; do	462	for DEVICE in `list_cdrom_devices` `list_disk_devices`; do
462	`echolog "setting DMA support off for $DEVICE"`	463	`echolog "setting DMA support off for $DEVICE"`
463	`hdparm -d 0 $DEVICE`	464	`hdparm -d 0 $DEVICE`
464	`done`	465	`done`
465	`fi`	466	`fi`
466	`}`	467	`}`
467		468
468	`# create correct fstab file in $1/etc/fstab and create apropriate`	469	`# create correct fstab file in $1/etc/fstab and create apropriate`
469	`# mount directories in $1`	470	`# mount directories in $1`
470	`# $1 = root directory (union)`	471	`# $1 = root directory (union)`
471	`#`	472	`#`
472	`activate_fstab()`	473	`activate_fstab()`
473	`{`	474	`{`
474	`mkdir -p $1/etc`	475	`mkdir -p $1/etc`
475	`FSTAB="$1/etc/fstab"`	476	`FSTAB="$1/etc/fstab"`
476	`echo "tmpfs / tmpfs defaults 0 0" >$FSTAB`	477	`echo "tmpfs / tmpfs defaults 0 0" >$FSTAB`
477	`echo "devpts /dev/pts devpts gid=5,mode=620 0 0" >>$FSTAB`	478	`echo "devpts /dev/pts devpts gid=5,mode=620 0 0" >>$FSTAB`
478	`echo "proc /proc proc defaults 0 0" >>$FSTAB`	479	`echo "proc /proc proc defaults 0 0" >>$FSTAB`
479		480
480	`# all the rest will be done by runlast or by fstab-sync`	481	`# all the rest will be done by runlast or by fstab-sync`
481	`# search for SWAP done later in /etc/rc.sysinit`	482	`# search for SWAP done later in /etc/rc.sysinit`
482	`}`	483	`}`
483		484
484		485
485	`# find partition and/or folder that stores the changes`	486	`# find partition and/or folder that stores the changes`
486	`# return false, if changes not set or changes folder/partition not found`	487	`# return false, if changes not set or changes folder/partition not found`
487	`# Urs Beyerle`	488	`# Urs Beyerle`
488	`#`	489	`#`
489	`find_changes()`	490	`find_changes()`
490	`{`	491	`{`
491	`echolog "looking for changes in $CHANGESVAL"`	492	`echolog "looking for changes in $CHANGESVAL"`
492		493
493	CHANGESDEV="`echo "$CHANGESVAL" \| egrep -o "^/dev/[^/]+"`"	494	CHANGESDEV="`echo "$CHANGESVAL" \| egrep -o "^/dev/[^/]+"`"
494	CHANGESFOLDER="`echo "$CHANGESVAL" \| sed -r 's:^/dev/[^/]+(.*):\1:'`"	495	CHANGESFOLDER="`echo "$CHANGESVAL" \| sed -r 's:^/dev/[^/]+(.*):\1:'`"
495	`# (re-)define CHANGES if CHANGESFOLDER is set`	496	`# (re-)define CHANGES if CHANGESFOLDER is set`
496	`if [ "$CHANGESFOLDER" != "" ]; then CHANGES=$MEMORY/$CHANGESFOLDER; fi`	497	`if [ "$CHANGESFOLDER" != "" ]; then CHANGES=$MEMORY/$CHANGESFOLDER; fi`
497		498
498	`# we may need usb and sata support`	499	`# we may need usb and sata support`
499	`modprobe_usb_sata_modules`	500	`modprobe_usb_sata_modules`

Subversion Repositories livecd

(root)/trunk/linux-live.sl/initrd/liblinuxlive @ 258 – Rev 246 → 248