ROOTDEVNAME="/dev/sdr3"		# Name of root device
LINUXVER="2.6.21.5"		# Linux modules version
CLIBVER="2.5"			# C library version
ROOTDIR="/boot/initrd-tree"	# Location of root filesystm
# Get most of the needed programs from the normal mkinitrd
mkinitrd -k $LINUXVER -c -r "$ROOTDEVNAME" -f ext3
# Create directories
for dir in \
   "bin" "dev" "etc" "mnt" "proc" "sbin" "sys" "usr" \
   "tmp" "var" "var/lock" "var/log" "var/run" "var/tmp"
   do
   if [ ! -d "$ROOTDIR/$dir" ] ; then
      mkdir -p "$ROOTDIR/$dir"
   fi
done
# Create devices
pushd "$ROOTDIR/dev" > /dev/null
# Remove existing devices
rm -Rf *
# Create root device name
cp -dpPR "$ROOTDEVNAME" .
chmod u=rw,g=rw,o= "$ROOTDIR$ROOTDEVNAME" 
# Device mapper for "dmraid"
mkdir mapper
chmod u=rwx,g=rx,o=rx mapper
chown root:root mapper
mknod -m u=rw,g=rw,o= mapper/control c 10 63
chown root:root mapper/control
# Required devices
mknod -m u=rw,g=,o= console c 5 1
chown root:tty console 
mknod -m u=rw,g=rw,o= ram0 b 1 0
chown root:disk ram0 
mknod -m u=rw,g=r,o= mem c 1 1
chown root:kmem mem 
mknod -m u=rw,g=r,o= kmem c 1 2
chown root:kmem kmem 
mknod -m u=rw,g=rw,o=rw null c 1 3
chown root:root null 
mknod -m u=rw,g=rw,o=rw zero c 1 5
chown root:root zero 
mkdir vc
chmod u=rwx,g=rx,o=rx vc
chown root:root vc
mknod -m u=rw,g=rw,o= vc/1 c 4 1
chown root:tty vc/1 
ln -s vc/1 tty1
# IDE Disks (up to 20) max 64 partitions per disk
drives=4
partitions=9
if [ $drives -gt 0 ] ; then
   majors=( 3 22 33 34 56 57 88 89 90 91)
   for drv in `seq 0 $(($drives-1))` ; do
      dev="abcdefghijklmnopqrst"
      dev=hd${dev:$drv:1} 
      major=${majors[$(($drv/2))]}  
      minor=$(( ($drv%2) * 64 ))
      mknod -m u=rw,g=rw,o= $dev b $major $minor
      chown root:disk $dev
      if [ $partitions -gt 0 ] ; then 
         for i in `seq 1 $partitions` ; do
            mknod -m u=rw,g=rw,o= $dev$i b $major $(($minor+$i)) 
            chown root:disk $dev$i
         done
      fi
   done
fi
# SCSI Disks (0 to 127) max 16 partitions per disk
drives=4
partitions=9
if [ $drives -gt 0 ] ; then
   majors=( 8 65 66 67 68 69 70 71)
   for drv in `seq 0 $(($drives-1))` ; do
      dev="abcdefghijklmnopqrstuvwxyz"
      if [ $drv -lt 26 ] ; then
         dev=sd${dev:$drv:1}
      else
         dev=sd${dev:$(($drv/26-1)):1}${dev:$(($drv%26)):1}
      fi
      major=${majors[$(($drv/16))]}  
      minor=$(( ($drv%16) * 16 ))
      mknod -m u=rw,g=rw,o= $dev b $major $minor
      chown root:disk $dev
      if [ $partitions -gt 0 ] ; then 
         for i in `seq 1 $partitions` ; do
            mknod -m u=rw,g=rw,o= $dev$i b $major $(($minor+$i)) 
            chown root:disk $dev$i
         done
      fi
   done
fi
# Floppy disks A and B
for i in `seq 0 1` ; do
   mknod -m u=rw,g=rw,o= fd$i b 2 $i 
   chown root:floppy fd$i
done
# Done with devices
popd > /dev/null
# Copy scripts and programs
cp -p init "$ROOTDIR"
chmod u=rwx,g=rx,o=rx "$ROOTDIR/init"
cp -p /sbin/dmraid "$ROOTDIR/sbin"
cp -p /bin/cut "$ROOTDIR/bin"
for lib in \
   "libdevmapper.so" "libdevmapper.so.1.02" \
   "libc.so.6" "ld-linux.so.2" \
   "ld-$CLIBVER.so" "libc-$CLIBVER.so"
   do
   if [ -e "/lib/$lib" ] ; then
      cp -Pp "/lib/$lib" "$ROOTDIR/lib/$lib"
   else
      echo "Library file not found \"/lib/$lib\""
      exit 1
   fi
done
# Make the compressed image file
mkinitrd

ROOTDEVNAME="/dev/sdr3"		# Name of root device
LINUXVER="2.6.24.5"		# Linux modules version
CLIBVER="2.7"			# C library version
ROOTDIR="/boot/initrd-tree"	# Location of root filesystm
# Get most of the needed programs from the normal mkinitrd
mkinitrd -k $LINUXVER -c -r "$ROOTDEVNAME" -f ext3
# Create root device
cp -a "$ROOTDEVNAME" "$ROOTDIR/dev"
# Copy scripts and programs
cp -p init "$ROOTDIR"
chmod u=rwx,g=rx,o=rx "$ROOTDIR/init"
cp -p /sbin/dmraid "$ROOTDIR/sbin"
for lib in \
   "libdevmapper.so.1.02" \
   "libc.so.6" "ld-linux.so.2" \
   "ld-$CLIBVER.so" "libc-$CLIBVER.so"
   do
   if [ -e "/lib/$lib" ] ; then
      cp -Pp "/lib/$lib" "$ROOTDIR/lib/$lib"
   else
      echo "Library file not found \"/lib/$lib\""
      exit 1
   fi
done
# Make the compressed image file
mkinitrd

#!/bin/ash
#
# /linuxrc:  init script to load kernel modules from an initramfs
#            This requires that your kernel supports initramfs!!!
#
# Copyright 2004  Slackware Linux, Inc., Concord, CA, USA
# Copyright 2007  Patrick J. Volkerding, Sebeka, MN, USA
# All rights reserved.
#
# Redistribution and use of this script, with or without modification, is
# permitted provided that the following conditions are met:
#
# 1. Redistributions of this script must retain the above copyright
#    notice, this list of conditions and the following disclaimer.
#
#  THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
#  WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
#  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO
#  EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
#  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
#  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
#  OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
#  WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
#  OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
#  ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.


# With a generic kernel, you need to load the modules needed to mount the
# root partition.  This might mean a SCSI, RAID, or other drive controller
# module, as well as the module to support the root filesystem.  Once the
# root partition is mounted all the other modules will be available so you
# don't need to load them here.
#
# Config files used by this script:
#
# /rootdev   Contains the name of the root device, such as: /dev/hda1 
#
# /rootfs    Contains the root filesystem type, such as: xfs
#
# /initrd-name    Contains the name of the initrd file.
#
# Optional:
# /load_kernel_modules   A script that uses insmod to load the desired
#            modules.  If this file is not present, all the modules
#            in /lib/modules/`uname -r`/ will be loaded in the usual
#            sorted order.  If you need to load the modules in a
#            certain order, or if the modules need extra options,
#            then use a load_kernel_modules script.
#
#            There's an example in here.  To actually use it, you'll
#            need to make it executable:  
#
#                chmod 755 load_kernel_modules

INITRD=`cat /initrd-name`
ROOTDEV=`cat /rootdev`
ROOTFS=`cat /rootfs`
LUKSDEV=`cat /luksdev`
RESUMEDEV=`cat /resumedev`
WAIT=`cat /wait-for-root`
KEYMAP=`cat /keymap`

# Mount /proc and /sys:
mount -n proc /proc -t proc
mount -n sysfs /sys -t sysfs

# Parse command line
for ARG in `cat /proc/cmdline`; do
  case $ARG in
    rescue)
      RESCUE=1
    ;;
    root=/dev/*)
      ROOTDEV=`echo $ARG | cut -f2 -d=`
    ;;
    resume=*)
      RESUMEDEV=`echo $ARG | cut -f2 -d=`
    ;;
    0|1|2|3|4|5|6)
      RUNLEVEL=$ARG
    ;;
    single)
      RUNLEVEL=1
    ;;
  esac
done

# Load kernel modules:
if [ ! -d /lib/modules/`uname -r` ]; then
  echo "No kernel modules found for Linux `uname -r`."
elif [ -x ./load_kernel_modules ]; then # use load_kernel_modules script:
  echo "${INITRD}:  Loading kernel modules from initrd image:"
  . ./load_kernel_modules
else # load modules (if any) in order:
  if ls /lib/modules/`uname -r`/*.*o 1> /dev/null 2> /dev/null ; then
    echo "${INITRD}:  Loading kernel modules from initrd image:"
    for module in /lib/modules/`uname -r`/*.*o ; do
      insmod $module
    done
    unset module
  fi
fi

# Sometimes the devices needs extra time to be available.
# root on USB are good example of that.
sleep $WAIT

# Use mdev to read sysfs and generate the needed devices 
mdev -s

# Load a custom keyboard mapping:
if [ -n "$KEYMAP" ]; then
  echo "${INITRD}:  Loading '$KEYMAP' keyboard mapping:"
  tar xzOf /etc/keymaps.tar.gz ${KEYMAP}.bmap | loadkmap
fi

# Find any dmraid detectable partitions
dmraid -ay

if [ "$RESCUE" = "" ]; then 
  # Make encrypted root partition available:
  # The useable device will be under /dev/mapper/
  # Three scenarios for the commandline exist:
  # 1- ROOTDEV is on a LUKS volume, and LUKSDEV is a real block device
  # 2- ROOTDEV is on a LVM volume, and LUKSDEV is a real block device
  # 3- ROOTDEV is on a LUKS volume, and LUKSDEV is on a LVM volume
  # Case (3) will have to wait until we initialize the LVM.
  # Test if ROOTDEV is "/dev/someting" or just "something" - the first means
  # ROOTDEV is on a LVM volume (scenario 2) and we don't need to rewrite ROOTDEV.
  # The second means that ROOTDEV is on a LUKS volume (scenario 1).
  CRYPTDEV=""
  if [ -x /sbin/cryptsetup ]; then
    # If we find a LUKS device now, it is on a real block device: 
    if /sbin/cryptsetup isLuks ${LUKSDEV} 1>/dev/null 2>/dev/null ; then
      CRYPTDEV=$(basename $ROOTDEV)
      echo "Unlocking LUKS crypt volume '${CRYPTDEV}' on device '$LUKSDEV':"
      /sbin/cryptsetup luksOpen ${LUKSDEV} $CRYPTDEV </dev/systty >/dev/systty 2>&1
      if [ "$CRYPTDEV" == "$ROOTDEV" ]; then # scenario 1
        ROOTDEV="/dev/mapper/${CRYPTDEV}"
      fi
    fi
  fi

  # Initialize RAID:
  if [ -x /sbin/mdadm ]; then
    /sbin/mdadm -E -s >/etc/mdadm.conf
    /sbin/mdadm -A -s
  fi
  
  # Initialize LVM:
  if [ -x /sbin/vgscan ]; then
    /sbin/vgscan --mknodes --ignorelockingfailure
    sleep 10
    /sbin/vgchange -ay --ignorelockingfailure
  fi
  
  # Make encrypted root partition available (scenario 3):
  # We have to handle cases here where the LUKS volume is created on a LV
  if [ -x /sbin/cryptsetup ]; then
    if /sbin/cryptsetup isLuks ${LUKSDEV} 1>/dev/null 2>/dev/null ; then
      # Only act if we could not open the LUKS device before (i.e. is on a LV):
      if [ "x$CRYPTDEV" == "x" ]; then
        echo "Unlocking LUKS crypt volume '${ROOTDEV}' on device '$LUKSDEV':"
        /sbin/cryptsetup luksOpen ${LUKSDEV} $ROOTDEV </dev/systty >/dev/systty 2>&1
        ROOTDEV="/dev/mapper/${ROOTDEV}"
      fi
    fi
  fi

  # Resume state from swap
  if [ "$RESUMEDEV" != "" ]; then
    if ls -l $RESUMEDEV | grep -q "^l" ; then
      RESUMEDEV=`ls -l $RESUMEDEV | awk '{ print $NF }'`
    fi
    echo "Trying to resume from $RESUMEDEV"
    RESMAJMIN=`ls -l $RESUMEDEV | tr , : | awk '{ print $5$6 }'`
    echo $RESMAJMIN > /sys/power/resume
  fi
  
  # Switch to real root partition:
  echo 0x0100 > /proc/sys/kernel/real-root-dev
  mount -o ro -t $ROOTFS $ROOTDEV /mnt
  
  if [ ! -r /mnt/sbin/init ]; then
    echo "ERROR:  No /sbin/init found on rootdev (or not mounted).  Trouble ahead."
    echo "        You can try to fix it. Type 'exit' when things are done." 
    echo
    /bin/sh
  fi
  unset ERR
  umount /proc
  umount /sys
  echo "${INITRD}:  exiting"
  exec switch_root /mnt /sbin/init $RUNLEVEL
else
  echo "RESCUE mode"
  echo
  echo "        You can try to fix or rescue your system now. If you want"
  echo "        to boot into your fixed system, mount your root filesystem"
  echo "        read-only under /mnt:"
  echo
  echo "            # mount -o ro -t filesystem root_device /mnt"
  echo
  echo "        Type 'exit' when things are done."
  echo
  /bin/sh
  unset ERR
  umount /proc
  umount /sys
  echo "${INITRD}:  exiting"
  exec switch_root /mnt /sbin/init $RUNLEVEL
fi

#!/bin/sh
#
# Script to create a bootable Linux CD
#
LINUXVER="2.6.21.5"		# Linux version (for CD boot image)
MODVER="${LINUXVER}CD"		# Modules version (for CD modules)
FSCOMP="./rootfs.gz"		# root filesystem compressed file
FSBIN="./rootfs.bin"		# root filesystem file
ROOTFS="./rootfs"		# Where root filesystem is mounted
OUTFILE="./bootcd.iso"		# Output file
CONFIG="./config"		# Location of configuration files
CDROOT="./cdroot"		# Where to store the CD files	
GRUBBIN="/usr/sbin"		# Location of grub binary files
GRUBLDR="/usr/lib/grub/i386-pc"	# Location of grub boot loader files
BOOTIMAGE="/usr/src/linux-$LINUXVER/arch/i386/boot/bzImage"
SYSTEMMAP="/usr/src/linux-$LINUXVER/System.map"
CLIBVER="2.7"			# C library version

# CD Layout
CDBOOT="boot"
CDGRUB="$CDBOOT/grub"

# If CD files already exist, clean them
if [ -d "$CDROOT" ] ; then
   rm -R "$CDROOT"
fi

# If root filesystem file exists, clean it
if [ -f "$FSBIN" ] ; then
   rm "$FSBIN"
fi

# Create the root filesystem file
dd if=/dev/zero of="$FSBIN" bs=1k count=32768
mke2fs -m 0 -N 2000 -F "$FSBIN"
tune2fs -c 0 -i 0 "$FSBIN"

# Mount the root filesystem
mount -t ext2 -o loop "$FSBIN" "$ROOTFS"

# Create directories
for dir in \
   "bin" "dev" "etc" "mnt" "proc" "sbin" "sys" "usr" \
   "tmp" "var" "var/log" "var/run" "var/tmp" "root"
   do
   if [ ! -d "$ROOTFS/$dir" ] ; then
      mkdir -p "$ROOTFS/$dir"
   fi
done

# Create devices
pushd "$ROOTFS/dev" > /dev/null
# Required devices
mknod -m u=rw,g=,o= console c 5 1
chown root:tty console 
mknod -m u=rw,g=rw,o= ram0 b 1 0
chown root:disk ram0 
mknod -m u=rw,g=r,o= mem c 1 1
chown root:kmem mem 
mknod -m u=rw,g=r,o= kmem c 1 2
chown root:kmem kmem 
mknod -m u=rw,g=rw,o=rw null c 1 3
chown root:root null 
mknod -m u=rw,g=rw,o=rw zero c 1 5
chown root:root zero 
mkdir vc
chmod u=rwx,g=rx,o=rx vc
chown root:root vc
mknod -m u=rw,g=rw,o= vc/1 c 4 1
chown root:tty vc/1 
ln -s vc/1 tty1
mknod -m u=rw,g=rw,o= loop0 b 7 0
chown root:disk loop0 
# IDE Disks (up to 20) max 64 partitions per disk
drives=4
partitions=9
if [ $drives -gt 0 ] ; then
   majors=( 3 22 33 34 56 57 88 89 90 91)
   for drv in `seq 0 $(($drives-1))` ; do
      dev="abcdefghijklmnopqrst"
      dev=hd${dev:$drv:1} 
      major=${majors[$(($drv/2))]}  
      minor=$(( ($drv%2) * 64 ))
      mknod -m u=rw,g=rw,o= $dev b $major $minor
      chown root:disk $dev
      if [ $partitions -gt 0 ] ; then 
         for i in `seq 1 $partitions` ; do
            mknod -m u=rw,g=rw,o= $dev$i b $major $(($minor+$i)) 
            chown root:disk $dev$i
         done
      fi
   done
fi
# SCSI Disks (0 to 127) max 16 partitions per disk
drives=4
partitions=9
if [ $drives -gt 0 ] ; then
   majors=( 8 65 66 67 68 69 70 71)
   for drv in `seq 0 $(($drives-1))` ; do
      dev="abcdefghijklmnopqrstuvwxyz"
      if [ $drv -lt 26 ] ; then
         dev=sd${dev:$drv:1}
      else
         dev=sd${dev:$(($drv/26-1)):1}${dev:$(($drv%26)):1}
      fi
      major=${majors[$(($drv/16))]}  
      minor=$(( ($drv%16) * 16 ))
      mknod -m u=rw,g=rw,o= $dev b $major $minor
      chown root:disk $dev
      if [ $partitions -gt 0 ] ; then 
         for i in `seq 1 $partitions` ; do
            mknod -m u=rw,g=rw,o= $dev$i b $major $(($minor+$i)) 
            chown root:disk $dev$i
         done
      fi
   done
fi
# Floppy disks A and B
for i in `seq 0 1` ; do
   mknod -m u=rw,g=rw,o= fd$i b 2 $i 
   chown root:floppy fd$i
done
# Device mapper for "dmraid"
mkdir mapper
chmod u=rwx,g=rx,o=rx mapper
chown root:root mapper
mknod -m u=rw,g=rw,o= mapper/control c 10 63
chown root:root mapper/control
# Done with devices
popd > /dev/null

# Copy the configuration files
for cfg in \
   "fstab" "group" "inittab" "passwd" "rc" "shadow" "securetty" \
   "termcap" "nsswitch.conf" "profile" "HOSTNAME" "hosts" \
   "DIR_COLORS"
   do
   cp "$CONFIG/etc/$cfg" "$ROOTFS/etc/$cfg"
done

# Copy programs
for prg in \
   "agetty" "basename" "bash" "cat" "chgrp" "chmod" "chown" "chroot" \
   "chvt" "clear" "cmp" "cp" "cut" "date" "dd" "df" "dirname" "dmesg" \
   "du" "echo" "env" "false" "fbset" "find" "free" "grep" \
   "gunzip" "gzip" "head" "hostname" "init" "ifconfig" "kill" "killall" \
   "ln" "login" "ls" "mkdir" "mknod" "more" "mount" "mv" "ps" "pwd" \
   "reboot" "rm" "rmdir" "sh" "shutdown" "sleep" "stty" "sulogin" \
   "sync" "syslogd" "tail" "tar" "tee" "test" "touch" "tr" "true" "tty" \
   "umount" "uname" "uptime" "yes" "zcat" "vi" "elvis" "sed" "sort" \
   "uniq" "insmod" "lsmod" "rmmod" "bzip2" \
   "modprobe" "fdisk" "cfdisk" "dmraid" "mkfs" "mkdosfs" "mke2fs" \
   "mkfs.ext2" "mkfs.ext3" "mkfs.msdos" "mkfs.cramfs" "mkfs.reiserfs" \
   "mkreiserfs" "reiserfstune" "tune2fs" \
   "fsck" "dosfsck" "e2fsck" "fsck.ext2" "fsck.ext3" "fsck.msdos" \
   "fsck.reiserfs" "fsck.umsdos" "reiserfsck" \
   "id" "dircolors" "shutdown" "telinit" "ldd"
   do
   found=false
   for dir in "sbin" "usr/sbin" "bin" "usr/bin" ; do
      if [ -e "/$dir/$prg" ] ; then
         found=true
         if [ ! -d `dirname "$ROOTFS/$dir/$prg"` ] ; then
            mkdir -p `dirname "$ROOTFS/$dir/$prg"`
         fi
         cp -Pp "/$dir/$prg" "$ROOTFS/$dir/$prg"
      fi
   done
   if [ $found != true ] ; then
      echo "Binary file not found \"$prg\""
      umount "$ROOTFS"
      exit 1
   fi
done

# Copy grub boot loader programs
dir="$ROOTFS$GRUBBIN"
if [ ! -d "$dir" ] ; then
   mkdir -p "$dir"
fi
cp -Pp $GRUBBIN/grub* "$dir"
# Copy grub boot loader files
dir="$ROOTFS$GRUBLDR"
if [ ! -d "$dir" ] ; then
   mkdir -p "$dir"
fi
cp -Pp $GRUBLDR/* "$dir"

# Copy libraries
for lib in \
   "ld-linux.so.2" "ld-$CLIBVER.so" "libc.so.6" "libc-$CLIBVER.so" \
   "libresolv.so.2" "libresolv-$CLIBVER.so" \
   "libacl.so.1" "libacl.so.1.1.0" "libattr.so.1" "libattr.so.1.1.0" \
   "libcrypt.so.1" "libcrypt-$CLIBVER.so" "libdl.so.2" "libdl-$CLIBVER.so" \
   "libtermcap.so.2" "libtermcap.so.2.0.8" "libblkid.so.1" "libblkid.so.1.0" \
   "libuuid.so.1" "libuuid.so.1.2" "libproc-3.2.7.so" "libnss_files.so.2" \
   "libnss_files-$CLIBVER.so" "libnss_compat.so.2" "libnss_compat-$CLIBVER.so" \
   "libnss_dns.so.2" "libnss_dns-$CLIBVER.so" "libnss_nis.so.2" \
   "libnss_nis-$CLIBVER.so" "librt.so.1" "librt-$CLIBVER.so" "libpthread.so.0" \
   "libpthread-$CLIBVER.so" "libpthread-$CLIBVER.so" "libe2p.so.2" "libe2p.so.2.3" \
   "libnsl.so.1" "libnsl-$CLIBVER.so" "libncurses.so.5" "libncurses.so.5.6" \
   "libncursesw.so.5" "libncursesw.so.5.6" "libgpm.so.1" "libgpm.so.1.19.0" \
   "libcom_err.so.2" "libcom_err.so.2.1" "libext2fs.so.2" "libext2fs.so.2.4" \
   "libm.so.6" "libm-$CLIBVER.so" "libdevmapper.so" "libdevmapper.so.1.02"
   do
   found=false
   for dir in "lib" "lib/tls" ; do
      if [ -e "/$dir/$lib" ] ; then
         found=true
         if [ ! -d `dirname "$ROOTFS/$dir/$lib"` ] ; then
            mkdir -p `dirname "$ROOTFS/$dir/$lib"`
         fi
         cp -Pp "/$dir/$lib" "$ROOTFS/$dir/$lib"
      fi
   done
   if [ $found != true ] ; then
      echo "Library file not found \"$lib\""
      umount "$ROOTFS"
      exit 1
   fi
done

# Copy modules
dir="lib/modules/$MODVER"
for module in \
   "LEAVE-THIS-HERE"
   do
   if [ "$module" != "LEAVE-THIS-HERE" ] ; then
      module="$dir/$module.ko"
      if [ -e "/$module" ] ; then
         if [ ! -d `dirname "$ROOTFS/$module"` ] ; then
            mkdir -p `dirname "$ROOTFS/$module"`
         fi
         cp -Pp "/$module" "$ROOTFS/$module"
      else
         echo "Module file not found \"/$module\""
         umount "$ROOTFS"
         exit 1
      fi
   fi
done

# Update module dependencies
if [ ! -d "$ROOTFS/$dir" ] ; then
   mkdir -p "$ROOTFS/$dir"
fi
depmod -b "$ROOTFS" -v "$MODVER" -F "$SYSTEMMAP"

# Copy terminal information files
dir="usr/share/terminfo"
for file in \
   "linux" "linux-m" "linux-nic" \
   "vt100" "vt100-am"
   do
   file="$dir/${file:0:1}/$file"
   if [ -e "/$file" ] ; then
      if [ ! -d `dirname "$ROOTFS/$file"` ] ; then
         mkdir -p `dirname "$ROOTFS/$file"`
      fi
      cp -Pp "/$dirl/$file" "$ROOTFS/$file"
   else
      echo "Terminal info file not found \"/$file\""
      umount "$ROOTFS"
      exit 1
   fi
done

# Copy other files
for file in \
   "usr/tmp" "etc/services" "usr/lib/libncurses.so" \
   "usr/lib/libncurses.so.5" "usr/lib/libncursesw.so" \
   "usr/lib/libncursesw.so.5"
   do
   if [ -e "/$file" ] ; then
      if [ ! -d `dirname "$ROOTFS/$file"` ] ; then
         mkdir -p `dirname "$ROOTFS/$file"`
      fi
      cp -Pp "/$file" "$ROOTFS/$file"
   else
      echo "File not found \"/$file\""
      umount "$ROOTFS"
      exit 1
   fi
done

# Create empty files
for file in \
   "var/log/wtmp" "var/run/utmp"
   do
   if [ ! -d `dirname "$ROOTFS/$file"` ] ; then
      mkdir -p `dirname "$ROOTFS/$file"`
   fi
   touch "$ROOTFS/$file"
done

# Unmount the root filesystem
umount "$ROOTFS"

# Create the compressed filesystem
dd if="$FSBIN" bs=1k | gzip -v9 > "$FSCOMP"

# Create CD directories
mkdir "$CDROOT" 
mkdir "$CDROOT/$CDBOOT"
mkdir "$CDROOT/$CDGRUB"

# Copy grub boot loader
cp $GRUBLDR/stage2_eltorito "$CDROOT/$CDGRUB"
cp "$CONFIG/grub/menu.lst" "$CDROOT/$CDGRUB"

# Copy boot image
cp "$BOOTIMAGE" "$CDROOT/$CDBOOT/vmlinuz"

# Copy the compressed root filesystem
cp "$FSCOMP" "$CDROOT/$CDBOOT/rootfs.gz"

# Copy scripts to create initrd
mkdir -p "$CDROOT/install/initrd"
cp /root/initrd/makeinitrd "$CDROOT/install/initrd"
cp /root/initrd/init "$CDROOT/install/initrd"

# Create the ISO image for the CD
mkisofs -o "$OUTFILE" -r \
   -b "$CDGRUB/stage2_eltorito" -no-emul-boot \
   -boot-load-size 4 -boot-info-table "$CDROOT"

# These are the default runlevels in Slackware:
#   0 = halt
#   1 = single user mode
#   2 = unused (but configured the same as runlevel 3)
#   3 = multiuser mode (default Slackware runlevel)
#   4 = X11 with KDM/GDM/XDM (session managers)
#   5 = unused (but configured the same as runlevel 3)
#   6 = reboot

# Default runlevel. (Do not set to 0 or 6)
id:1:initdefault:

# System initialization (runs when system boots).
si::sysinit:/etc/rc

# These are the standard console login getties in multiuser mode:
c1:1235:respawn:/sbin/agetty 9600 tty1 linux
c2:23:respawn:/sbin/agetty 9600 tty2 linux

# End of /etc/inittab

#!/bin/sh
#
# /etc/rc:  System initialization script.

PATH=/sbin:/usr/sbin:/bin:/usr/bin

# Mount /proc right away:
/sbin/mount -v proc /proc -n -t proc

# Mount sysfs next, if the kernel supports it:
if [ -d /sys ]; then
  if cat /proc/filesystems | grep -w sysfs 1> /dev/null 2> /dev/null ; then
    if ! cat /proc/mounts | grep -w sysfs 1> /dev/null 2> /dev/null ; then
      /sbin/mount -v sysfs /sys -n -t sysfs
    fi
  fi
fi

# Set host name
/bin/hostname LinuxBootCD

# Remount the root filesystem in read-write mode
echo "Remounting root device with read-write enabled."
/sbin/mount -w -v -n -o remount /

# Any /etc/mtab that exists here is old, so we delete it to start over:
/bin/rm -f /etc/mtab*
# Remounting the / partition will initialize the new /etc/mtab:
/sbin/mount -w -o remount /

# Fix /etc/mtab to list sys and proc if they were not yet entered in
# /etc/mtab because / was still mounted read-only:
if [ -d /proc/sys ]; then
  /sbin/mount -f proc /proc -t proc
fi
if [ -d /sys/bus ]; then
  /sbin/mount -f sysfs /sys -t sysfs
fi