#!/bin/ash
#
# Copyright 2004 Slackware Linux, Inc., Concord, CA, USA
# Copyright 2007, 2008, 2009, 2010, 2012 Patrick J. Volkerding, Sebeka, MN, USA
# Copyright 2015, 2016 Eric Hameleers, Eindhoven, NL
# 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.
#
##################################################################################
# Changelog
# 10-Dec-2012 <mozes@slackware.com>
# * Added support for the official Kernel parameters to select root filesystem
# type ('rootfstype') and pause before attempting to mount the root filesystem
# ('rootdelay'). The original parameters may continue to be used.
# 23-Oct-2015 <alien@slackware.com>
# * Modified for booting as a Live filesystem.
##################################################################################
# The ISO creation script will create a filesystem with this label.
# Nevertheless, the user may have copied the ISO content to a different device.
MEDIALABEL="@MEDIALABEL@"
LIVEMAIN="@LIVEMAIN@"
MARKER="@MARKER@"
PERSISTENCE="@PERSISTENCE@"
LIVEMEDIA=""
LIVEPATH=""
# By default, let the media determine if we can write persistent changes:
# However, if we define TORAM=1, we will also set VIRGIN=1 since we want
# to avoid anything that writes to disk after we copy the OS to RAM.
VIRGIN=0
# Used for debugging the init; set to '1' to enable explicit pauses>
DEBUG=0
# Masochists can copy the live environment into RAM:
TORAM=0
# The default number of loop devices the Live OS will use (if you have
# a large number of addon modules, this value may be too low).
# Can be changed by the 'maxloops=' boot parameter:
MAXLOOPS=96
# By default we do not touch local hard disks (raid, lvm, btrfs):
LOCALHD=0
# Perhaps we need to blacklist some kernel module(s):
BLACKLIST=""
# QEMU X.Org and some other setups need glamor 2D acceleration disabled,
# default in X.Org is to enable it:
GLAMORACCEL=1
INITRD=$(cat /initrd-name)
WAIT=$(cat /wait-for-root)
KEYMAP=$(cat /keymap)
LUKSVOL=$(cat /luksdev)
INIT=/sbin/init
PATH="/sbin:/bin:/usr/sbin:/usr/bin"
# Mount /proc and /sys:
mount -n proc /proc -t proc
mount -n sysfs /sys -t sysfs
mount -n tmpfs /run -t tmpfs -o mode=0755
if grep devtmpfs /proc/filesystems 1>/dev/null 2>/dev/null ; then
DEVTMPFS=1
mount -n devtmpfs /dev -t devtmpfs
fi
# Parse command line
for ARG in $(cat /proc/cmdline); do
case $ARG in
0|1|2|3|4|5|6|S|s|single)
RUNLEVEL=$ARG
;;
blacklist=*)
BLACKLIST=$(echo $ARG | cut -f2 -d=)
;;
debug)
DEBUG=1
;;
debug=*)
DEBUG=$(echo $ARG | cut -f2 -d=)
;;
hostname=*)
LIVE_HOSTNAME=$(echo $ARG | cut -f2 -d=)
;;
init=*)
INIT=$(echo $ARG | cut -f2 -d=)
;;
kbd=*)
KEYMAP=$(echo $ARG | cut -f2 -d=)
;;
livemain=*)
LIVEMAIN=$(echo $ARG | cut -f2 -d=)
;;
livemedia=*)
# generic syntax: livemedia=/dev/sdX
# ISO syntax: livemedia=/dev/sdX:/path/to/slackwarelive.iso
LM=$(echo $ARG | cut -f2 -d=)
LIVEMEDIA=$(echo $LM | cut -f1 -d:)
LIVEPATH=$(echo $LM | cut -f2 -d:)
unset LM
;;
livepw=*)
LIVEPW=$(echo $ARG | cut -f2 -d=)
;;
load=*)
LOAD=$(echo $ARG | cut -f2 -d=)
;;
locale=*)
LOCALE=$(echo $ARG | cut -f2 -d=)
;;
localhd)
LOCALHD=1
;;
luksvol=*)
# Format: luksvol=file1[:/mountpoint1][,file1[:/mountpoint2],...]
LUKSVOL=$(echo $ARG | cut -f2 -d=)
;;
maxloops=*)
MAXLOOPS=$(echo $ARG | cut -f2 -d=)
;;
nga)
GLAMORACCEL=0
;;
noload=*)
NOLOAD=$(echo $ARG | cut -f2 -d=)
;;
nop)
VIRGIN=1
;;
persistence=*)
PERSISTENCE=$(echo $ARG | cut -f2 -d=)
;;
rescue)
RESCUE=1
;;
swap)
USE_SWAP=1
;;
rootpw=*)
ROOTPW=$(echo $ARG | cut -f2 -d=)
;;
toram)
TORAM=1
VIRGIN=1 # prevent writes to disk since we are supposed to run from RAM
;;
tz=*)
TZ=$(echo $ARG | cut -f2 -d=)
;;
waitforroot=*|rootdelay=*)
WAIT=$(echo $ARG | cut -f2 -d=)
;;
xkb=*)
XKB=$(echo $ARG | cut -f2 -d=)
;;
esac
done
[ $DEBUG -ge 2 ] && set -x
debugit () {
[ $DEBUG -eq 0 ] && return
echo "DEBUG>> -- blkid info -- :"
blkid | while read LINE ; do echo "DEBUG>> $LINE" ; done
echo "DEBUG>> -- mount info -- :"
mount | while read LINE ; do echo "DEBUG>> $LINE" ; done
echo "DEBUG>> -- Press ENTER to continue -- : "
read JUNK
return
}
rescue() {
if [ "x$1" != "x" ]; then
echo "$1"
fi
echo
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
}
# If udevd is available, use it to generate block devices
# else use mdev to read sysfs and generate the needed devices
if [ -x /sbin/udevd -a -x /sbin/udevadm ]; then
/sbin/udevd --daemon --resolve-names=never
/sbin/udevadm trigger --subsystem-match=block --action=add
/sbin/udevadm settle --timeout=10
else
[ "$DEVTMPFS" != "1" ] && mdev -s
fi
# Load kernel modules (ideally this was already done by udev):
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 "${MARKER}: Loading kernel modules from initrd image:"
. ./load_kernel_modules 1>/dev/null 2>/dev/null
else # load modules (if any) in order:
if ls /lib/modules/$(uname -r)/*.*o 1> /dev/null 2> /dev/null ; then
echo "${MARKER}: Loading kernel modules from initrd image:"
for module in /lib/modules/$(uname -r)/*.*o ; do
/sbin/modprobe $module 1>/dev/null 2>/dev/null
done
unset module
fi
fi
# Sometimes the devices need extra time to be available.
# A root filesystem on USB is a good example of that.
sleep $WAIT
# Fire at least one blkid:
blkid 1>/dev/null 2>/dev/null
# Load a custom keyboard mapping:
if [ -n "$KEYMAP" ]; then
echo "${MARKER}: Loading '$KEYMAP' keyboard mapping:"
tar xzOf /etc/keymaps.tar.gz ${KEYMAP}.bmap | loadkmap
fi
if [ "$RESCUE" = "" ]; then
if [ $LOCALHD -eq 1 ]; then
# We will initialize RAID/LVM/BTRFS on local harddisks:
# Initialize RAID:
if [ -x /sbin/mdadm ]; then
# If /etc/mdadm.conf is present, udev should DTRT on its own;
# If not, we'll make one and go from there:
if [ ! -r /etc/mdadm.conf ]; then
/sbin/mdadm -E -s >/etc/mdadm.conf
/sbin/mdadm -S -s
/sbin/mdadm -A -s
# This seems to make the kernel see partitions more reliably:
fdisk -l /dev/md* 1> /dev/null 2> /dev/null
fi
fi
# Initialize LVM:
if [ -x /sbin/vgchange ]; then
mkdir -p /var/lock/lvm # this avoids useless warnings
/sbin/vgchange -ay --ignorelockingfailure 2>/dev/null
/sbin/udevadm settle --timeout=10
fi
# Scan for btrfs multi-device filesystems:
if [ -x /sbin/btrfs ]; then
/sbin/btrfs device scan
fi
fi
# --------------------------------------------------------------------- #
# SLACKWARE LIVE - START #
# --------------------------------------------------------------------- #
## Support functions ##
find_loop() {
# The losetup of busybox is different from the real losetup - watch out!
lodev=$(losetup -f)
if [ -z "$lodev" ]; then
# We exhausted the available loop devices, so create the block device:
for NOD in $(seq 0 ${MAXLOOPS}); do
if [ ! -b /dev/loop${NOD} ]; then
mknod -m660 /dev/loop${NOD} b 7 ${NOD}
break
fi
done
lodev=/dev/loop${NOD}
elif [ ! -b $lodev ]; then
# We exhausted the available loop devices, so create the block device:
mknod -m660 $lodev b 7 $(echo $lodev |sed %/dev/loop%%)
fi
echo "$lodev"
}
find_modloc() {
MY_LOC="$1"
if [ $TORAM -ne 0 ]; then
# If we need to copy the module to RAM, we need a place for that:
mkdir -p /mnt/live/toram
# Copy the module to RAM before mounting it:
MODNAME="$(basename ${MY_LOC})"
cp ${MY_LOC} /mnt/live/toram
MY_LOC=/mnt/live/toram/${MODNAME}
fi
echo "${MY_LOC}"
}
load_modules() {
# SUBSYS can be 'system', 'addons', 'optional':
SUBSYS="$1"
if ls /mnt/media/${LIVEMAIN}/${SUBSYS}/*.sxz 1>/dev/null 2>/dev/null ; then
for MODULE in /mnt/media/${LIVEMAIN}/${SUBSYS}/*.sxz ; do
MODBASE="$(basename ${MODULE} .sxz)"
if [ "$SUBSYS" = "optional" ]; then
# Load one or more optionals by using boot parameter 'load':
# load=mod1[,mod2[,mod3]]
if [ -z "$LOAD" -o -z '$(echo ",${LOAD}," |grep -i ",$(echo $MODBASE |cut -d- -f2),")' ]; then
continue
fi
elif [ "$SUBSYS" = "addons" ]; then
# Skip loading one or more addons by using boot parameter 'noload':
# noload=mod1[,mod2[,mod3]]
if [ -n "$NOLOAD" -a -n '$(echo ",${NOLOAD}," |grep -i ",$(echo $MODBASE |cut -d- -f2),")' ]; then
echo "$MODBASE" >> /mnt/live/modules/skipped
continue
fi
fi
MODLOC=$(find_modloc ${MODULE})
mkdir /mnt/live/modules/${MODBASE}
mount -t squashfs -o loop ${MODLOC} /mnt/live/modules/${MODBASE}
RODIRS=":/mnt/live/modules/${MODBASE}${RODIRS}"
# 0099-* are the Live customizations, exclude those for setup2hd:
if ! echo ${MODBASE} | grep -q ^0099 ; then
FS2HD=":/mnt/live/modules/${MODBASE}${FS2HD}"
fi
done
fi
}
## End support functions ##
# We need a mounted filesystem here to be able to do a switch_root later,
# so we create one in RAM:
if [ $TORAM -eq 1 ]; then
RAMSIZE=90% # need to be able to load the entire OS in RAM
else
RAMSIZE=50% # the default value.
fi
mount -t tmpfs -o defaults,size=${RAMSIZE} none /mnt
# Find the Slackware Live media.
# TIP: Increase WAIT to give USB devices a chance to be seen by the kernel.
mkdir /mnt/media
if [ -z "$LIVEMEDIA" ]; then
# LIVEMEDIA not specified on the boot commandline using "livemedia="
# Filter out the block devices, only look at partitions at first:
LIVEALL=$(blkid |grep LABEL="\"$MEDIALABEL\"" |cut -d: -f1 |grep "[0-9]$")
LIVEMEDIA=$(blkid |grep LABEL="\"$MEDIALABEL\"" |cut -d: -f1 |grep "[0-9]$" |head -1)
if [ ! -z "$LIVEMEDIA" ]; then
# That was easy... we found the media straight away.
# Determine filesystem type ('iso9660' means we found a CDROM/DVD)
LIVEFS=$(blkid $LIVEMEDIA |rev |cut -d'"' -f2 |rev)
mount -t $LIVEFS -o ro $LIVEMEDIA /mnt/media
else
LIVEALL=$(blkid |grep LABEL="\"$MEDIALABEL\"" |cut -d: -f1 |grep -v "[0-9]$")
LIVEMEDIA=$(blkid |grep LABEL="\"$MEDIALABEL\"" |cut -d: -f1 |grep -v "[0-9]$" |head -1)
if [ ! -z "$LIVEMEDIA" ]; then
# We found a block device with the correct label (non-UEFI media).
# Determine filesystem type ('iso9660' means we found a CDROM/DVD)
LIVEFS=$(blkid $LIVEMEDIA |rev |cut -d'"' -f2 |rev)
mount -t $LIVEFS -o ro $LIVEMEDIA /mnt/media
else
# Bummer... label not found; the ISO was extracted to a different device.
# Separate partitions from block devices, look at partitions first:
for SLDEVICE in $(blkid |cut -d: -f1 |grep "[0-9]$") $(blkid |cut -d: -f1 |grep -v "[0-9]$") ; do
SLFS=$(blkid $SLDEVICE |rev |cut -d'"' -f2 |rev)
mount -t $SLFS -o ro $SLDEVICE /mnt/media
if [ -d /mnt/media/${LIVEMAIN} ]; then
# Found our media!
LIVEALL=$SLDEVICE
LIVEMEDIA=$SLDEVICE
LIVEFS=$(blkid $LIVEMEDIA |rev |cut -d'"' -f2 |rev)
break
else
umount $SLDEVICE
unset SLDEVICE
fi
done
fi
fi
if [ -n "$LIVEMEDIA" ]; then
# Gotcha!
break
fi
sleep 1
else
# LIVEMEDIA was specified on the boot commandline using "livemedia="
if [ ! -b "$LIVEMEDIA" ]; then
# Passed a UUID or LABEL?
LIVEALL=$(findfs UUID=$LIVEMEDIA 2>/dev/null) || LIVEALL=$(findfs LABEL=$LIVEMEDIA 2>/dev/null)
LIVEMEDIA="$LIVEALL"
else
LIVEALL="$LIVEMEDIA"
fi
if [ -z "$LIVEALL" ]; then
echo "${MARKER}: Live media '$LIVEMEDIA' not found... trouble ahead."
else
if [ -n "$LIVEPATH" -a "$LIVEPATH" != "$LIVEMEDIA" ]; then
# Boot option used: "livemedia=/dev/sdX:/path/to/live.iso",
# instead of just "livemedia=/dev/sdX".
# First mount the partition and then loopmount the ISO:
SUPERMNT=/mnt/super_$(od -An -N1 -tu1 /dev/urandom |tr -d ' ')
mkdir -p ${SUPERMNT}
SUPERFS=$(blkid $LIVEMEDIA |rev |cut -d'"' -f2 |rev)
mount -t $SUPERFS -o ro $LIVEMEDIA ${SUPERMNT}
if [ -f "${SUPERMNT}/$LIVEPATH" ]; then
LIVEFS=$(blkid "${SUPERMNT}/$LIVEPATH" |rev |cut -d'"' -f2 |rev)
LIVEALL="${SUPERMNT}/$LIVEPATH"
LIVEMEDIA="$LIVEALL"
MOUNTOPTS="loop"
fi
fi
LIVEFS=$(blkid $LIVEMEDIA |rev |cut -d'"' -f2 |rev)
mount -t $LIVEFS -o ${MOUNTOPTS:-ro} $LIVEMEDIA /mnt/media
fi
fi
# Finished determining the media availability, it should be mounted now.
if [ ! -z "$LIVEMEDIA" ]; then
echo "${MARKER}: Live media found at ${LIVEMEDIA}."
if [ ! -d /mnt/media/${LIVEMAIN} ]; then
echo "${MARKER}: However, live media was not mounted... trouble ahead."
fi
if [ "$LIVEMEDIA" != "$LIVEALL" ]; then
echo "${MARKER}: NOTE: Multiple partitions with '$MEDIALABEL' label were found ($(echo $LIVEALL))... success not guaranteed."
fi
else
echo "${MARKER}: No live media found... trouble ahead."
echo "${MARKER}: Try adding \"rootdelay=20\" to the boot command."
debugit
rescue
fi
debugit
# Start assembling our live system components below /mnt/live :
mkdir /mnt/live
# Mount our squashed modules (.sxz extension).
mkdir /mnt/live/modules
if [ $TORAM -ne 0 ]; then
echo "${MARKER}: Copying Live modules to RAM, please be patient."
fi
# Modules were created in specific order and will be mounted in that order.
# In the lowerdirs parameter for the overlay, the module with the highest
# number (i.e. created last) will be leftmost in a colon-separated list:
RODIRS=""
FS2HD=""
# First, the base Slackware system components:
load_modules system
# Next, the add-on (3rd party etc) components, if any:
# Remember, module name must adhere to convention: "NNNN-modname-*.sxz"
# where 'N' is a digit and 'modname' must not contain a dash '-'.
load_modules addons
# And finally any explicitly requested optionals (like nvidia drivers):
# Remember, module name must adhere to convention: "NNNN-modname-*.sxz"
# where 'N' is a digit and 'modname' must not contain a dash '-'.
load_modules optional
# Get rid of the starting colon:
RODIRS=$(echo $RODIRS |cut -c2-)
FS2HD=$(echo $FS2HD |cut -c2-)
if [ $TORAM -ne 0 ]; then
echo "${MARKER}: Live OS copied to RAM, you can remove the Live medium."
if [ "LIVEFS" = "iso9660" ]; then
eject ${LIVEMEDIA}
fi
fi
# Setup persistence in case our media is writable, *and* the user
# has created a directory "persistence" in the root of the media.
# otherwise we let the block changes accumulate in RAM only.
# Create the mount point for the writable upper directory of the overlay:
# Assume the default to be a readonly media - we write to RAM:
UPPERDIR=/mnt/live/changes
OVLWORK=/mnt/live/.ovlwork
if [ "$VIRGIN" = "0" ]; then
if [ "LIVEFS" != "iso9660" -a -d /mnt/media/${PERSISTENCE} ]; then
# Looks OK, but we need to remount the media in order to write
# to the persistence directory:
mount -o remount,rw /mnt/media
# Try a write... just to be dead sure:
if touch /mnt/media/${PERSISTENCE}/.rwtest 2>/dev/null && rm /mnt/media/${PERSISTENCE}/.rwtest 2>/dev/null ; then
# Writable media and we are allowed to write to it.
echo "${MARKER}: Writing persistent changes to media directory '/${PERSISTENCE}'."
UPPERDIR=/mnt/media/${PERSISTENCE}
OVLWORK=/mnt/media/.ovlwork
fi
elif [ "LIVEFS" != "iso9660" -a -f /mnt/media/${PERSISTENCE}.img ]; then
# Use a container file; the filesystem needs to be writable:
mount -o remount,rw /mnt/media
# Find a free loop device to mount the persistence container file:
prdev=$(find_loop)
prdir=${PERSISTENCE}_$(od -An -N1 -tu1 /dev/urandom |tr -d ' ')
mkdir -p /mnt/live/${prdir}
losetup $prdev /mnt/media/${PERSISTENCE}.img
# Check if the persistence container is LUKS encrypted:
if cryptsetup isLuks $prdev 1>/dev/null 2>/dev/null ; then
echo "Unlocking LUKS encrypted persistence file '/${PERSISTENCE}.img'"
cryptsetup luksOpen $prdev ${PERSISTENCE} </dev/tty0 >/dev/tty0 2>&1
if [ $? -ne 0 ]; then
echo "${MARKER}: Failed to unlock persistence file '/${PERSISTENCE}.img'."
echo "${MARKER}: Falling back to RAM."
else
# LUKS properly unlocked; from now on use the mapper device instead:
prdev=/dev/mapper/${PERSISTENCE}
fi
fi
prfs=$(blkid $prdev |rev |cut -d'"' -f2 |rev)
mount -t $prfs $prdev /mnt/live/${prdir} 2>/dev/null
if [ $? -ne 0 ]; then
echo "${MARKER}: Failed to mount persistence file '/${PERSISTENCE}.img'."
echo "${MARKER}: Falling back to RAM."
else
echo "${MARKER}: Writing persistent changes to file '/${PERSISTENCE}.img'."
UPPERDIR=/mnt/live/${prdir}/${PERSISTENCE}
OVLWORK=/mnt/live/${prdir}/.ovlwork
fi
fi
else
echo "${MARKER}: Writing changes to RAM - no persistence:"
if [ ! -z "$LUKSVOL" ]; then
# Even without persistence, we need to be able to write to the partition
# if we are using a LUKS container file:
mount -o remount,rw /mnt/media
fi
fi
# Create the writable upper directory, plus the workdir which is required
# for overlay to function (the two must be in the same POSIX filesystem):
[ ! -d ${UPPERDIR} ] && mkdir -p ${UPPERDIR}
[ ! -d ${OVLWORK} ] && mkdir -p ${OVLWORK}
# Create the overlays of readonly and writable directories:
mkdir -p /mnt/${LIVEMAIN}fs
mkdir -p /mnt/overlay
# We are going to use a readonly overlay of the unmodified filesystem
# as source for 'setup2hd':
mount -t overlay -o lowerdir=${FS2HD} overlay /mnt/${LIVEMAIN}fs
# And this is the actual Live overlay:
mount -t overlay -o workdir=${OVLWORK},upperdir=${UPPERDIR},lowerdir=${RODIRS} overlay /mnt/overlay
if [ $? -ne 0 -a "$VIRGIN" = "0" ]; then
# Failed to create the persistent overlay - try without persistence:
echo "${MARKER}: Failed to create persistent overlay, attempting to continue in RAM."
UPPERDIR=/mnt/live/changes
OVLWORK=/mnt/live/.ovlwork
mkdir -p ${UPPERDIR}
mkdir -p ${OVLWORK}
mount -t overlay -o workdir=${OVLWORK},upperdir=${UPPERDIR},lowerdir=${RODIRS} overlay /mnt/overlay
fi
debugit
# Make the underpinning RAM fs accessible in the live system (for fun):
mkdir -p /mnt/overlay/mnt/live
mount --bind /mnt/live /mnt/overlay/mnt/live
mkdir -p /mnt/overlay/mnt/${LIVEMAIN}fs
mount --bind /mnt/${LIVEMAIN}fs /mnt/overlay/mnt/${LIVEMAIN}fs
if [ $TORAM -eq 0 ]; then
# Same for the Linux filesystem on the USB stick:
mkdir -p /mnt/overlay/mnt/livemedia
mount --bind /mnt/media /mnt/overlay/mnt/livemedia
fi
if [ ! -z "$USE_SWAP" ]; then
# Use any available swap device:
for SWAPD in $(blkid |grep TYPE="\"swap\"" |cut -d: -f1) ; do
echo "${MARKER}: Enabling swapping to '$SWAPD'"
echo "$SWAPD swap swap defaults 0 0" >> /mnt/overlay/etc/fstab
done
fi
if [ ! -z "$KEYMAP" ]; then
# Configure custom keyboard mapping in console and X:
echo "${MARKER}: Switching live console to '$KEYMAP' keyboard"
cat <<EOT > /mnt/overlay/etc/rc.d/rc.keymap
#!/bin/sh
# Load the keyboard map. More maps are in /usr/share/kbd/keymaps.
if [ -x /usr/bin/loadkeys ]; then
/usr/bin/loadkeys ${KEYMAP}
fi
EOT
chmod 755 /mnt/overlay/etc/rc.d/rc.keymap
fi
if [ ! -z "$KEYMAP" -o ! -z "$XKB" ]; then
# Set a keyboard mapping in X.Org, derived from the console map if needed:
# Variable XKB can be set to "XkbLayout,XkbVariant", like "xkb=ch,fr"
# You can set just the XkbVariant by adding something like "kbd=ch xkb=,fr"
XKBLAYOUT=$(echo $XKB |cut -d, -f1)
XKBVARIANT=$(echo $XKB |cut -d, -f2)
# Ensure that XKBLAYOUT gets a value; XKBVARIANT is allowed to be empty.
if [ -z "$XKBLAYOUT" ]; then
if [ -z "$KEYMAP" ]; then
XKBLAYOUT="us"
else
XKBLAYOUT="$(echo $KEYMAP |cut -c1-2)"
fi
fi
else
XKBLAYOUT="us"
fi
echo "${MARKER}: Switching live X desktop to '$XKBLAYOUT' keyboard"
# Germans use the AltGr key, so Scroll Lock will be their Compose Key:
if [ "$XKBLAYOUT" = "de" ]; then
XKBOPTIONS="compose:sclk"
else
XKBOPTIONS="compose:ralt"
fi
# If the layout is not 'us' then add 'us' as a secondary nevertheless:
if [ "$XKBLAYOUT" != "us" ]; then
XKBLAYOUT="$XKBLAYOUT,us"
XKBVARIANT="$XKBVARIANT,"
XKBOPTIONS="grp:alt_shift_toggle,grp_led:scroll,$XKBOPTIONS"
fi
mkdir -p /mnt/overlay/etc/X11/xorg.conf.d
cat <<EOT > /mnt/overlay/etc/X11/xorg.conf.d/30-keyboard.conf
Section "InputClass"
Identifier "keyboard-all"
Driver "evdev"
Option "XkbLayout" "$XKBLAYOUT"
Option "XkbVariant" "$XKBVARIANT"
Option "XkbOptions" "$XKBOPTIONS"
MatchIsKeyboard "on"
EndSection
EOT
if [ ! -z "$LOCALE" ]; then
# Configure custom locale:
echo "${MARKER}: Switching to '$LOCALE' locale"
sed -i -e "s/^ *export LANG=.*/export LANG=${LOCALE}/" /mnt/overlay/etc/profile.d/lang.sh
fi
if [ ! -z "$TZ" -a -f /mnt/overlay/usr/share/zoneinfo/${TZ} ]; then
# Configure custom timezone:
echo "${MARKER}: Configuring timezone '$TZ'"
cp /mnt/overlay/usr/share/zoneinfo/${TZ} /mnt/overlay/etc/localtime
rm /mnt/overlay/etc/localtime-copied-from
ln -s /usr/share/zoneinfo/${TZ} /mnt/overlay/etc/localtime-copied-from
# Configure the hardware clock to be interpreted as localtime and not UTC:
cat <<EOT > /mnt/overlay/etc/hardwareclock
# /etc/hardwareclock
#
# Tells how the hardware clock time is stored.
# You should run timeconfig to edit this file.
localtime
EOT
fi
if [ ! -z "$LIVEPW" ]; then
# User entered a custom live password on the boot commandline:
echo "${MARKER}: Changing password for user 'live'."
chroot /mnt/overlay /usr/sbin/chpasswd <<EOPW
live:${LIVEPW}
EOPW
fi
if [ ! -z "$ROOTPW" ]; then
# User entered a custom root password on the boot commandline:
echo "${MARKER}: Changing password for user 'root'."
chroot /mnt/overlay /usr/sbin/chpasswd <<EOPW
root:${ROOTPW}
EOPW
fi
if [ ! -z "$LIVE_HOSTNAME" ]; then
# User entered a custom hostname on the boot commandline:
echo "${MARKER}: Changing hostname to '$LIVE_HOSTNAME'."
echo "${LIVE_HOSTNAME}.example.net" > /mnt/overlay/etc/HOSTNAME
if [ -f /mnt/overlay/etc/NetworkManager/NetworkManager.conf ]; then
sed -i -e "s/^hostname=.*/hostname=${LIVE_HOSTNAME}/" \
/mnt/overlay/etc/NetworkManager/NetworkManager.conf
fi
sed -i -e "s/^\(127.0.0.1\t*\)@DARKSTAR@.*/\1${LIVE_HOSTNAME}.example.net ${LIVE_HOSTNAME}/" /mnt/overlay/etc/hosts
fi
# Disable glamor 2D acceleration (QEMU needs this):
if [ $GLAMORACCEL -eq 0 ]; then
cat <<EOT > /mnt/overlay/etc/X11/xorg.conf.d/20-noglamor.conf
Section "Device"
Identifier "modesetting"
Driver "modesetting"
Option "AccelMethod" "none"
EndSection
EOT
fi
# Blacklist kernel modules if requested:
if [ ! -z "$BLACKLIST" ]; then
mkdir -p /mnt/overlay/etc/modprobe.d
echo "#Slackware Live blacklist" > /mnt/overlay/etc/modprobe.d/BLACKLIST-live.conf
for kernelmod in $(echo $BLACKLIST |tr ',' ' '); do
echo "blacklist $kernelmod" >> /mnt/overlay/etc/modprobe.d/BLACKLIST-live.conf
done
fi
# Delete ALSA state file, the Live OS may be booted on different computers:
rm -f /mnt/overlay/var/lib/alsa/asound.state
# Copy contents of rootcopy directory (may be empty) to overlay:
cp -af /mnt/media/${LIVEMAIN}/rootcopy/* /mnt/overlay/ 2>/dev/null
# Bind any LUKS container into the Live filesystem:
if [ ! -z "$LUKSVOL" ]; then
for luksvol in $(echo $LUKSVOL |tr ',' ' '); do
luksfil="$(echo $luksvol |cut -d: -f1)"
luksmnt="$(echo $luksvol |cut -d: -f2)"
luksnam="$(echo $(basename $luksfil) |tr '.' '_')"
if [ "$luksmnt" = "$luksfil" ]; then
# No optional mount point specified, so we use the default: /home/
luksmnt="/home"
fi
# Find a free loop device:
lodev=$(find_loop)
losetup $lodev /mnt/media/$luksfil
echo "Unlocking LUKS encrypted container '$luksfil' at mount point '$luksmnt'"
cryptsetup luksOpen $lodev $luksnam </dev/tty0 >/dev/tty0 2>&1
if [ $? -ne 0 ]; then
echo "${MARKER}: Failed to unlock LUKS container '$luksfil'... trouble ahead."
else
# Create the mount directory if it does not exist (unlikely):
mkdir -p /mnt/overlay/$luksmnt
# Let Slackware mount the unlocked container:
luksfs=$(blkid /dev/mapper/$luksnam |rev |cut -d'"' -f2 |rev)
if ! grep -q /dev/mapper/$luksnam /mnt/overlay/etc/fstab ; then
echo "/dev/mapper/$luksnam $luksmnt $luksfs defaults 1 1" >> /mnt/overlay/etc/fstab
fi
# On shutdown, ensure that the container gets locked again:
if ! grep -q "$luksnam $luksmnt" /mnt/overlay/etc/crypttab ; then
echo "$luksnam $luksmnt" >> /mnt/overlay/etc/crypttab
fi
fi
done
fi
# --------------------------------------------------------------------- #
# SLACKWARE LIVE - !END! #
# --------------------------------------------------------------------- #
# Minimal changes to the original Slackware init follow:
# Switch to real root partition:
/sbin/udevadm settle --timeout=10
echo 0x0100 > /proc/sys/kernel/real-root-dev
if [ ! -r /mnt/overlay/${INIT} ]; then
echo "ERROR: No ${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
else
rescue
fi
# Need to make sure OPTIONS+="db_persist" exists for all dm devices
# That should be handled in /sbin/mkinitrd now
/sbin/udevadm info --cleanup-db
/sbin/udevadm control --exit
unset ERR
umount /proc
umount /sys
umount /run
# We disable the filesystem checking code in /etc/rc.d/rc.S,
# so we need to keep the fs writable here.
#mount -o ro,remount /mnt/overlay 2>/dev/null
echo "${MARKER}: Slackware Live system is ready."
echo "${MARKER}: exiting"
exec switch_root /mnt/overlay $INIT $RUNLEVEL