path: root/upslak.sh

#!/bin/bash
#
# Copyright 2017, 2019, 2021, 2022, 2023  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.

# -----------------------------------------------------------------------------
#
# This script can perform the following changes on
# the USB version of on Slackware Live Edition.
# - upgrade the kernel and modules
# - add network support modules for PXE boot (if missing)
# - increase (or decrease) USB wait time during boot
# - replace the Live init script inside the initrd image
# - move current persistence data to a new squashfs module in 'addons'
#
# -----------------------------------------------------------------------------

# Be careful:
set -e

# Limit the search path:
export PATH="/usr/sbin:/sbin:/usr/bin:/bin"

# ---------------------------------------------------------------------------
# START possible tasks to be executed by the script:
# ---------------------------------------------------------------------------

# By default do not move persistence data into a new Live module:
CHANGES2SXZ=0

# Replace the live 'init' script with the file $LIVEINIT:
LIVEINIT=""

# Do we need to add network support? This can be enforced through commandline,
# otherwise will be determined by examining the original kernelmodules:
NETSUPPORT=""

# This will be set to '1' if the user wants to restore the backups of the
# previous kernel and modules:
RESTORE=0

# Set default for 'do we update the kernel':
UPKERNEL=0

# Do not change usb wait time by default:
WAIT=-1

# Not extending any container by default:
EXTENSION=""

# ---------------------------------------------------------------------------
# END possible tasks to be executed by the script:
# ---------------------------------------------------------------------------

# The extension for containerfiles accompanying an ISO is '.icc',
# whereas the persistent USB stick created with iso2usb.sh uses '.img'.
DEFEXT=".img"
CNTEXT="${DEFEXT}"

# Default filesystem for devices/containers:
DEF_FS="ext4"
FSYS="${DEF_FS}"

# Determine whether the USB stick has a supported kernel configuration
# i.e. one active and optionally one backup kernel plus mmodules:
SUPPORTED=1

# Values obtained from the init script on the USB:
CORE2RAMMODS=""
DEF_KBD=""
DEF_LOCALE=""
DEF_TZ=""
DISTRO=""
LIVE_HOSTNAME=""
LIVEMAIN=""
LIVEUID=""
MARKER=""
MEDIALABEL=""
PERSISTENCE=""
SQ_EXT_AVAIL=""
VERSION=""

# By default we make a backup of your old kernel/modules when adding new ones:
KBACKUP=1

# Does the initrd contain an old kernel that we can restore?
# The 'read_initrddir' routine may set this to '0':
KRESTORE=1

# By default we create an addon live module for the new kernel modules,
# otherwise the Live OS will be broken after reboot.
# User can skip this if they already installed the kernel-modules package
# in the Live OS earlier:
NOLIVEMODS=0

# Timeout when scanning for inserted USB device, 30 seconds by default,
# but this default can be changed from outside the script:
SCANWAIT=${SCANWAIT:-30}

# By default do not show file operations in detail:
VERBOSE=0

# Set to '1' if we are to scan for device insertion:
SCAN=0

# Minimim free space (in MB) we want to have left in any partition
# after we are done.
# The default value can be changed from the environment:
MINFREE=${MINFREE:-10}

# Variables to store content from an initrd we are going to refresh:
OLDKERNELSIZE=""
OLDKMODDIRSIZE=""
OLDWAIT=""

# Record the version of the new kernel:
KVER=""

# Define ahead of time, so that cleanup knows about them:
IMGDIR=""
KERDIR=""
USBMNT=""
EFIMNT=""
CNTDEV=""
LODEV=""

# Empty initialization:
INCSIZE=""
PARTFREE=""
PARTSIZE=""

# These tools are required by the script, we will check for their existence:
REQTOOLS="cpio gdisk inotifywait lsblk strings xz"

# Minimim free space (in MB) we want to have left in any partition
# after we are done.
# The default value can be changed from the environment:
MINFREE=${MINFREE:-10}

# Compressor used on the initrd ("gzip" or "xz --check=crc32");
# Note that the kernel's XZ decompressor does not understand CRC64:
COMPR="xz --check=crc32"

# -- START: Taken verbatim from make_slackware_live.sh -- #
# List of kernel modules required for a live medium to boot properly;
# Lots of HID modules added to support keyboard input for LUKS password entry;
# Virtio modules added to experiment with liveslak in a VM.
KMODS=${KMODS:-"squashfs:overlay:loop:efivarfs:xhci-pci:ohci-pci:ehci-pci:xhci-hcd:uhci-hcd:ehci-hcd:mmc-core:mmc-block:sdhci:sdhci-pci:sdhci-acpi:rtsx_pci:rtsx_pci_sdmmc:usb-storage:uas:hid:usbhid:i2c-hid:hid-generic:hid-apple:hid-cherry:hid-logitech:hid-logitech-dj:hid-logitech-hidpp:hid-lenovo:hid-microsoft:hid_multitouch:jbd:mbcache:ext3:ext4:zstd_compress:lz4hc_compress:lz4_compress:btrfs:f2fs:jfs:xfs:isofs:fat:nls_cp437:nls_iso8859-1:msdos:vfat:exfat:ntfs:virtio_ring:virtio:virtio_blk:virtio_balloon:virtio_pci:virtio_pci_modern_dev:virtio_net"}

# Network kernel modules to include for NFS root support:
NETMODS="kernel/drivers/net kernel/drivers/virtio"

# Network kernel modules to exclude from above list:
NETEXCL="appletalk arcnet bonding can dummy.ko hamradio hippi ifb.ko irda macvlan.ko macvtap.ko pcmcia sb1000.ko team tokenring tun.ko usb veth.ko wan wimax wireless xen-netback.ko"
# -- END: Taken verbatim from make_slackware_live.sh -- #

#
#  -- function definitions --
#

# Clean up in case of failure:
function cleanup() {
  # Clean up by unmounting our loopmounts, deleting tempfiles:
  echo "--- Cleaning up the staging area..."
  # During cleanup, do not abort due to non-zero exit code:
  set +e
  sync

  if [ -n "$CNTDEV" ]; then
    # In case of failure, only most recent LUKS mapped device is still open:
    if mount | grep -q ${CNTDEV} ; then
      umount -f ${CNTDEV}
      cryptsetup luksClose $(basename ${CNTDEV})
      losetup -d ${LODEV}
    fi
  fi

  # No longer needed:
  [ -n "${IMGDIR}" ] && ( rm -rf $IMGDIR )
  [ -n "${KERDIR}" ] && ( rm -rf $KERDIR )
  if [ -n "${USBMNT}" ]; then
    if mount |grep -qw ${USBMNT} ; then umount ${USBMNT} ; fi
    rmdir $USBMNT
  fi
  if [ -n "${EFIMNT}" ]; then
    if mount |grep -qw ${EFIMNT} ; then umount ${EFIMNT} ; fi
    rmdir $EFIMNT
  fi
  set -e
} # End of cleanup()

trap 'echo "*** $0 FAILED at line $LINENO ***"; cleanup; exit 1' ERR INT TERM

# Show the help text for this script:
function showhelp() {
cat <<EOT
#
# Purpose: to update the content of a Slackware Live USB stick.
#
# $(basename $0) accepts the following parameters:
#   -b|--nobackup              Do not try to backup original kernel and modules.
#   -d|--devices               List removable devices on this computer.
#   -e|--examples              Show some common usage examples.
#   -h|--help                  This help.
#   -i|--init <filename>       Replacement init script.
#   -k|--kernel <filename>     The kernel file (or package).
#   -m|--kmoddir <name>        The kernel modules directory (or package).
#   -n|--netsupport            Add network boot support if not yet present.
#   -o|--outdev <filename>     The device name of your USB drive.
#   -p|--persistence           Move persistent data into new Live module.
#   -r|--restore               Restore previous kernel and modules.
#   -s|--scan                  Scan for insertion of new USB device instead of
#                              providing a devicename (using option '-o').
#   -v|--verbose               Show verbose messages.
#   -w|--wait<number>          Add <number> seconds wait time to initialize USB.
#   -x|--extend <fullpath>     Full path (either in your filesystem or else
#                              relative to the USB partition root)
#                              to an existing (encrypted) container file,
#                              whose size you want to extend.
#                              Limitations:
#                              - container needs to be LUKS encrypted.
#                              - filename extension needs to be '${CNTEXT}'.
#                              Supported filesystems inside container:
#                              - $(resizefs).
#   -N|--nolivemods            Don't create an addon live module containing
#                              the new kernelmodules. Normally you *will* need
#                              this addon module, *unless* you have already
#                              installed these kernel-modules in the Live OS.
#                              FYI: the kernel and module upgrade applies only
#                              to the USB boot kernel and its initrd.
#   -X|--extendsize <size|perc> Extend size of existing container; value
#                              is the requested extension of the container
#                              in kB, MB, GB, or as percentage of free space
#                              (integer numbers only).
#                              Examples: '-X 125M', '-X 2G', '-X 20%'.
#
EOT
} # End of showhelp()

function showexamples() {
cat <<EOT
#
# Some common usage examples for $(basename $0)
# ---------------------------------------------------------------------------
#
# Get a listing of all available removable devices on the computer:
#   ./$(basename $0) -d
#
# Updating kernel and modules, providing two packages as input and assuming
# that the USB stick is known as /dev/sdX:
#   ./$(basename $0) -o /dev/sdX -m kernel-modules-4.19.0-x86_64-1.txz -k kernel-generic-4.19.0-x86_64-1.txz
#
# Restore the previous kernel and modules after a failed update,
# and let the script scan your computer for the insertion of your USB stick:
#   ./$(basename $0) -s -r
#
# Replace the Live init script with the latest template taken from
# the liveslak git repository:
#   wget https://git.liveslak.org/liveslak/plain/liveinit.tpl
#   ./$(basename $0) -o /dev/sdX -i liveinit.tpl
#
# Extend the size of the pre-existing LUKS container for your homedirectory
# with 3 GB, and let the script scan for the insertion of your USB stick:
#    ./$(basename $0) -s -x /slhome.img -X 3G
#
EOT
} # End of showexamples()

# Scan for insertion of a USB device:
function scan_devices() {
  local MYSCANWAIT="${1}"
  local BD
  # Inotifywatch does not trigger on symlink creation,
  # so we can not watch /sys/block/
  BD=$(inotifywait -q -t ${MYSCANWAIT} -e create /dev 2>/dev/null |cut -d' ' -f3)
  echo ${BD}
} # End of scan_devices()

# Show a list of removable devices detected on this computer:
function show_devices() {
  local MYDATA="${*}"
  if [ -z "${MYDATA}" ]; then
    MYDATA="$(ls --indicator-style=none /sys/block/ |grep -Ev '(ram|loop|dm-)')"
  fi
  echo "# Removable devices detected on this computer:"
  for BD in ${MYDATA} ; do
    if [ $(cat /sys/block/${BD}/removable) -eq 1 ]; then
      echo "# /dev/${BD} : $(cat /sys/block/${BD}/device/vendor 2>/dev/null) $(cat /sys/block/${BD}/device/model 2>/dev/null): $(( $(cat /sys/block/${BD}/size) / 2048)) MB"
    fi
  done
  echo "#"
} # End of show_devices()

# Determine size of a mounted partition (in MB):
function get_part_mb_size() {
  local MYPART="${1}"
  local MYSIZE
  MYSIZE=$(df -P -BM ${MYPART} |tail -n -1 |tr -s '\t' ' ' |cut -d' ' -f2)
  echo "${MYSIZE%M}"
} # End of get_part_mb_size()

# Determine free space of a mounted partition (in MB):
function get_part_mb_free() {
  local MYPART="${1}"
  local MYSIZE
  MYSIZE=$(df -P -BM ${MYPART} |tail -n -1 |tr -s '\t' ' ' |cut -d' ' -f4)
  echo "${MYSIZE%M}"
} # End of get_part_mb_free()

# Determine requested container size in MB (allow for '%|k|K|m|M|g|G' suffix).
# Note: sizes need to be integer values! Bash arithmetics don't work for floats.
function cont_mb() {
  # Uses global variables: PARTFREE
  local MYSIZE="$1"
  case "${MYSIZE: -1}" in
     "%") MYSIZE="$(( $PARTFREE * ${MYSIZE%\%} / 100 ))" ;;
     "k") MYSIZE="$(( ${MYSIZE%k} / 1024 ))" ;;
     "K") MYSIZE="$(( ${MYSIZE%K} / 1024 ))" ;;
     "m") MYSIZE="${MYSIZE%m}" ;;
     "M") MYSIZE="${MYSIZE%M}" ;;
     "g") MYSIZE="$(( ${MYSIZE%g} * 1024 ))" ;;
     "G") MYSIZE="$(( ${MYSIZE%G} * 1024 ))" ;;
       *) MYSIZE=-1 ;;
  esac
  echo "$MYSIZE"
} # End of cont_mb()

# Expand existing encrypted container file:
function expand_container() {
  # Uses external function: cleanup
  # Uses global variables: CNTEXT, MINFREE
  # Sets global variables: CNTDEV, LODEV, PARTFREE, PARTSIZE
  local MYPART="$1" # disk partition
  local MYINC="$2"  # requested increase ('%|k|K|m|M|g|G' suffix)
  local MYFILE="$3" # full path to ${CNTEXT} containerfile
  local MYMAP=""    # Name of the device-mapped file
  local CNTIS=""    # Stores size of the container

  # Determine requested container increase in MB:
  MYINC=$(cont_mb ${MYINC})

  # Determine size of the target partition (in MB), and the free space:
  PARTSIZE=$(get_part_mb_size ${MYPART})
  PARTFREE=$(get_part_mb_free ${MYPART})

  if [ $PARTFREE -lt $(( ${MYINC} + ${MINFREE} )) ]; then
    echo "*** Free space on USB partition after file-resizing would be less than ${MINFREE} MB;"
    echo "*** Not resizing the container file!"
    cleanup
    exit 1
  fi

  if ! file ${MYFILE} |grep -q 'LUKS' ; then
    echo "*** No LUKS container: '${MYFILE}'"
    cleanup
    exit 1
  else
    echo "--- Expanding '$(basename ${MYFILE})' on '${MYPART}' with ${MYINC} MB..."
  fi

  # Append random bytes to the end of the container file:
  dd if=/dev/urandom of=${MYFILE} bs=1M count=${MYINC} oflag=append conv=notrunc 2>/dev/null

  # Setup a loopback device that we can use with or without cryptsetup:
  LODEV=$(losetup -f)
  losetup ${LODEV} ${MYFILE}

  if cryptsetup isLuks ${LODEV} ; then
    # Unlock LUKS encrypted container first:
    MYMAP=$(basename ${MYFILE} ${CNTEXT})
    CNTDEV=/dev/mapper/${MYMAP}
    echo "--- Unlocking the LUKS container requires your passphrase..."
    until cryptsetup luksOpen ${LODEV} ${MYMAP} ; do
      echo ">>> Did you type an incorrect passphrases?"
      read -p ">>> Press [ENTER] to try again or Ctrl-C to abort ..." REPLY
    done
  else
    # Use the loopmounted block device for the un-encrypted container:
    CNTDEV=${LODEV}
  fi

  # Run fsck so the filesystem is clean before we resize it:
  fsck -fvy ${CNTDEV}
  # Resize the filesystem to occupy the full new size:
  resizefs ${CNTDEV}
  # Just to be safe:
  fsck -fvy ${CNTDEV}

  # Don't forget to clean up after ourselves:
  if cryptsetup isLuks ${LODEV} ; then
    cryptsetup luksClose ${MYMAP}
  fi
  losetup -d ${LODEV} || true
} # End of expand_container()

# Uncompress the initrd based on the compression algorithm used:
function uncompressfs () {
  if $(file "${1}" | grep -qi ": gzip"); then
    gzip -cd "${1}"
  elif $(file "${1}" | grep -qi ": XZ"); then
    xz -cd "${1}"
  fi
} # End of uncompressfs ()

# Resize the filesystem on a block device:
function resizefs() {
  # Uses external function: cleanup
  local MYDEV="${1}"
  local MYFS
  local TMPMNT

  if [ -z "${MYDEV}" ]; then
    # Without arguments given, reply with list of supported fs'es:
    echo  "btrfs,ext2,ext4,f2fs,jfs,xfs"
    return
  fi

  # Determine the current filesystem for the block device:
  MYFS=$(lsblk -n -o FSTYPE ${MYDEV})
  if [ -z "${MYFS}" ]; then
    echo "*** Failed to resize filesystem on device '${MYDEV}'!"
    echo "*** No filesystem found."
    cleanup
    exit 1
  fi

  TMPMNT=$(mktemp -d -p ${TMP:=/tmp} -t alienres.XXXXXX)
  if [ ! -d $TMPMNT ]; then
    echo "*** Failed to create temporary mount for the filesystem resize!"
    cleanup
    exit 1
  else
    chmod 711 ${TMPMNT}
  fi

  # Mount the block device prior to the resize
  # (btrfs, jfs and xfs do not support offline resize):
  mount -o rw -t ${MYFS} ${MYDEV} ${TMPMNT}

  # Resize the filesystem to occupy the full new device capacity:
  case "${MYFS}" in
    btrfs) btrfs filesystem resize max ${TMPMNT}
           ;;
    ext*)  resize2fs ${MYDEV}
           ;;
    f2fs)  resize.f2fs ${MYDEV}
           ;;
    jfs)   mount -o remount,resize,rw ${TMPMNT}
           ;;
    xfs)   xfs_growfs -d ${TMPMNT}
           ;;
    *)     echo "*** Unsupported filesystem '${MYFS}'!"
           cleanup
           exit 1
           ;;
  esac

  if [ ! $? ]; then
    echo "*** Failed to resize '${MYFS}'filesystem on device '${MYDEV}'!"
    cleanup
    exit 1
  else
    # Un-mount the device again:
    sync
    umount ${TMPMNT}
    rmdir ${TMPMNT}
  fi
} # End of resizefs()


# Collect the kernel modules we need for the liveslak initrd.
# When calling this function, the old module tree must already
# have been renamed to ${OLDKVER}.prev
function collect_kmods() {
  local IMGDIR="$1"

  # Borrow (and mangle) code from Slackware's mkinitrd
  # to convert the KMODS variable into a collection of modules:
  # Sanitize the modules list first, before any further processing.
  # The awk command eliminates doubles without changing the order:
  KMODS=$(echo $KMODS |tr -s ':' '\n' |awk '!x[$0]++' |tr '\n' ':')
  KMODS=$(echo ${KMODS%:}) # Weed out a trailing ':'

  # Count number of modules
  # This INDEX number gives us an easy way to find individual
  # modules and their arguments, as well as tells us how many
  # times to run through the list
  if ! echo $KMODS | grep ':' > /dev/null ; then  # only 1 module specified
    INDEX=1
  else
    # Trim excess ':' which will screw this routine:
    KMODS=$(echo $KMODS | tr -s ':')
    INDEX=1
    while [ ! "$(echo "$KMODS" | cut -f $INDEX -d ':' )" = "" ]; do
      INDEX=$(expr $INDEX + 1)
    done
    INDEX=$(expr $INDEX - 1)      # Don't include the null value
  fi

  mkdir -p $IMGDIR/lib/modules/${KVER}

  # Wrap everything in a while loop
  i=0
  while [ $i -ne $INDEX ]; do
    i=$(( $i + 1 ))
  
    # FULL_MOD is the module plus any arguments (if any)
    # MODULE is the module name
    # ARGS is any optional arguments to be passed to the kernel
    FULL_MOD="$(echo "$KMODS" | cut -d ':' -f $i)"
    MODULE="$(echo "$FULL_MOD" | cut -d ' ' -f 1 )"
    # Test for arguments
    if echo "$FULL_MOD" | grep ' ' > /dev/null; then
      ARGS=" $(echo "$FULL_MOD" | cut -d ' ' -f 2- )"
    else
      unset ARGS
    fi

    # Get MODULE deps and prepare modprobe lines
    modprobe --dirname ${KMODDIR%%/lib/modules/${KVER}} --set-version $KVER --show-depends --ignore-install $MODULE 2>/dev/null \
      | grep "^insmod " | cut -f 2 -d ' ' | while read SRCMOD; do

      if ! grep -Eq " $(basename $SRCMOD .ko)(\.| |$)" $IMGDIR/load_kernel_modules 2>/dev/null ; then
        LINE="$(echo "modprobe -v $(basename ${SRCMOD%%.gz} .ko)" )"

        # Test to see if arguments should be passed
        # Over-ride the previously defined LINE variable if so
        if [ "$(basename $SRCMOD .ko)" = "$MODULE" ]; then
          # SRCMOD and MODULE are same, ARGS can be passed
          LINE="$LINE$ARGS"
        fi

      fi

      if ! grep -qx "$LINE" $IMGDIR/load_kernel_modules ; then
        echo "$LINE" >> $IMGDIR/load_kernel_modules
      fi

      # Try to add the module to the initrd-tree.  This should be done
      # even if it exists there already as we may have changed compilers
      # or otherwise caused the modules in the initrd-tree to need
      # replacement.
      cd ${KMODDIR}
        # Need to strip ${KMODDIR} from the start of ${SRCMOD}:
        cp -a --parents  $(echo $SRCMOD |sed 's|'${KMODDIR}'/|./|' ) $IMGDIR/lib/modules/${KVER}/ 2>/dev/null
        COPYSTAT=$?
      cd - 1>/dev/null
      if [ $COPYSTAT -eq 0 ]; then
        if [ $VERBOSE -eq 1 ]; then
          echo "OK: $SRCMOD added."
        fi
        # If a module needs firmware, copy that too
        modinfo -F firmware "$SRCMOD" | sed 's/^/\/lib\/firmware\//' |
        while read SRCFW; do
          if cp -a --parents "$SRCFW" $IMGDIR 2>/dev/null; then
            if [ $VERBOSE -eq 1 ]; then
              echo "OK: $SRCFW added."
            fi
          else
            echo "*** WARNING:  Could not find firmware \"$SRCFW\""
          fi
        done
      else
        echo "*** WARNING:  Could not find module \"$SRCMOD\""
      fi
      unset COPYSTAT

    done
  done
  # End of Slackware mkinitrd code.

  # Do we have to add network support?
  if [ $NETSUPPORT -eq 1 ]; then
    # The initrd already contains dhcpcd so we just need to add kmods:
    for NETMODPATH in ${NETMODS} ; do 
      cd ${KMODDIR}
        mkdir -p ${IMGDIR}/lib/modules/${KVER}
        cp -a --parents ${NETMODPATH} ${IMGDIR}/lib/modules/${KVER}/
      cd - 1>/dev/null
      # Prune the ones we do not need:
      for KNETRM in ${NETEXCL} ; do
        find ${IMGDIR}/lib/modules/${KVER}/${NETMODPATH} \
          -name $KNETRM -depth -exec rm -rf {} \;
      done
      # Add any dependency modules:
      for MODULE in $(find ${IMGDIR}/lib/modules/${KVER}/${NETMODPATH} -type f -exec basename {} .ko \;) ; do
        modprobe --dirname ${KMODDIR%%/lib/modules/${KVER}} --set-version $KVER --show-depends --ignore-install $MODULE 2>/dev/null |grep "^insmod " |cut -f 2 -d ' ' |while read SRCMOD; do
          if [ "$(basename $SRCMOD .ko)" != "$MODULE" ]; then
            cd ${KMODDIR}
              # Need to strip ${KMODDIR} from the start of ${SRCMOD}:
              cp -a --parents $(echo $SRCMOD |sed 's|'${KMODDIR}'/|./|' ) \
                ${IMGDIR}/lib/modules/${KVER}/
            cd - 1>/dev/null
          fi
        done
      done
    done
  fi
  # We added extra modules to the initrd, so we run depmod again:
  if [ $VERBOSE -eq 1 ]; then
    chroot ${IMGDIR} depmod $KVER
  else
    chroot ${IMGDIR} depmod $KVER 2>/dev/null
  fi
} # End of collect_kmods ()

# Read configuration data from old initrd,
# after it has been extracted into a directory:
function read_initrddir() {
  local IMGDIR="$1"
  local INITVARS="$2"
  local OLDKVER
  local OLDMODDIR
  local PREVMODDIR

  cd ${IMGDIR}

  # Retrieve the currently defined USB wait time:
  OLDWAIT=$(cat ./wait-for-root)

  # Read the values of liveslak template variables in the init script:
  for TEMPLATEVAR in ${INITVARS} ; do
    eval $(grep "^ *${TEMPLATEVAR}=" ./init |head -1)
  done

  if [ $RESTORE -eq 1 ]; then
    # Add '||true' because grep's exit code '1' may abort the script:
    PREVMODDIR=$(find ./lib/modules -type d -mindepth 1 -maxdepth 1 |grep .prev || true)
    if [ -n "${PREVMODDIR}" ] ; then
      KRESTORE=1
    else
      echo "--- No backed-up kernel modules detected in '${IMGFILE}'."
      KRESTORE=0
    fi
  fi
  if [ $UPKERNEL -eq 1 ]; then
    OLDMODDIR=$(find ./lib/modules -type d -mindepth 1 -maxdepth 1 |grep -v .prev)
    if [ $(echo ${OLDMODDIR} |wc -w) -gt 1 ] ; then
      echo "*** Multiple kernelmodule trees detected in '${IMGFILE}'."
      SUPPORTED=0
    else
      OLDKVER=$(basename "${OLDMODDIR}")
      OLDKMODDIRSIZE=$(du -sm "${OLDMODDIR}" |tr '\t' ' ' |cut -d' ' -f1)
      # Find out if the old kernel contains network support.
      # Use presence of 'devlink.ko' in the old tree to determine this,
      # but allow for a pre-set override value based on commandline preference:
      if [ -f ${OLDMODDIR}/kernel/net/core/devlink.ko ]; then
        NETSUPPORT=${NETSUPPORT:-1}
      else
        NETSUPPORT=${NETSUPPORT:-0}
      fi
    fi
  fi
} # End read_initrddir()

# Extract the initrd into a new directory and report the dirname back:
function extract_initrd() {
  local MYIMGFILE="$1"
  local MYIMGDIR=$(mktemp -d -p ${TMP:=/tmp} -t alienimg.XXXXXX)
  if [ ! -d $MYIMGDIR ]; then
    echo "*** Failed to create temporary extraction directory for the initrd!"
    cleanup
    exit 1
  else
    chmod 711 $MYIMGDIR
  fi

  cd ${MYIMGDIR}
    uncompressfs ${MYIMGFILE} 2>/dev/null \
      | cpio -i -d -m -H newc 2>/dev/null
  echo "$MYIMGDIR"
} # End of extract_initrd()
    
# Modify the extracted initrd and re-pack it:
function update_initrd() {
  local MYIMGFILE="$1"
  local MYIMGDIR="$2"
  local NEED_RECOMP=0
  local NEWMODDIR
  local OLDMODDIR
  local OLDKVER

  cd ${MYIMGDIR}
    if [ ${WAIT} -ge 0 ]; then
      if [ $WAIT != $OLDWAIT ]; then
        echo "--- Updating 'waitforroot' time from '$OLDWAIT' to '$WAIT'"
        echo ${WAIT} > wait-for-root
        NEED_RECOMP=1
      fi
    fi

    if [ $UPKERNEL -eq 1 ]; then
      OLDMODDIR=$(find ./lib/modules -type d -mindepth 1 -maxdepth 1 |grep -v .prev)
      OLDKVER=$(strings $(find ${OLDMODDIR}/kernel/ -name "*.ko*" |head -1) |grep ^vermagic |cut -d= -f2 |cut -d' ' -f1)
      rm -rf ./lib/modules/*.prev
      if [ $KBACKUP -eq 1 ]; then
        # We make one backup:
        echo "--- Making backup of kernel modules (${OLDKVER}) in initrd"
        mv -i ${OLDMODDIR} ${OLDMODDIR}.prev
      else
        echo "--- No room for backing up old kernel modules in initrd"
        rm -rf ${OLDMODDIR}
      fi
      # Add modules for the new kernel:
      echo "--- Adding new kernel modules (${KVER}) to initrd"
      collect_kmods ${MYIMGDIR}
      NEED_RECOMP=1
    elif [ $RESTORE -eq 1 -a $KRESTORE -eq 1 ]; then
      # Restore previous kernel module tree.
      # The 'read_initrddir' routine will already have checked that we have
      # one active and one .prev modules tree:
      OLDMODDIR=$(find ./lib/modules -type d -mindepth 1 -maxdepth 1 |grep .prev || true)
      NEWMODDIR=$(find ./lib/modules -type d -mindepth 1 -maxdepth 1 |grep -v .prev)
      echo "--- Restoring old kernel modules"
      rm -rf ${NEWMODDIR}
      mv ${OLDMODDIR} ${OLDMODDIR%.prev}
      NEED_RECOMP=1
    fi

    if [ -n "${LIVEINIT}" ]; then
      if ! file "${LIVEINIT}" |grep -q 'shell script' ; then
        echo "*** Not a shell script: "${LIVEINIT}"!"
        cleanup
        exit 1
      fi
      echo "--- Replacing live init script"
      cp ./init ./init.prev
      if grep -q "@LIVEMAIN@" ${LIVEINIT} ; then
        # The provided init is a liveinit template, and we need
        # to substitute the placeholders with actual values:
        parse_template ${LIVEINIT} $(pwd)/init
      else
        cat ${LIVEINIT} > ./init
      fi
      NEED_RECOMP=1
    fi

    if [ ${NEED_RECOMP} -eq 1 ]; then
      echo "--- Compressing the initrd image again"
      chmod 0755 ${MYIMGDIR}
      find . |cpio -o -H newc |$COMPR > ${MYIMGFILE}
    fi
  cd - 1>/dev/null  # End of 'cd ${MYIMGDIR}'
} # End of update_initrd()

# Accept either a kernelimage or a packagename,
# and return the path to a kernelimage:
function getpath_kernelimg () {
  local MYDATA="${*}"

  if [ -z "${MYDATA}" ]; then
     echo ""
     return
  elif [ -n "$(file "${MYDATA}" |grep -E 'x86 boot (executable|sector)')" ]; then
    # We have a kernel image:
    echo "${MYDATA}"
  else
    # We assume a Slackware package:
    # Extract the generic kernel from the package and return its filename:
    tar --wildcards -C ${KERDIR} -xf ${MYDATA} boot/vmlinuz-generic-*
    echo "$(ls --indicator-style=none ${KERDIR}/boot/vmlinuz-generic-*)"
  fi
} # End of getpath_kernelimg

# Accept either a directory containing module tree, or a packagename,
# and return the path to a module tree:
function getpath_kernelmods () {
  local MYDATA="${*}"
  local MYKVER

  if [ -z "${MYDATA}" ]; then
     echo ""
     return
  elif [ -d "${MYDATA}" ]; then
    # We have directory, assume it contains the  kernel modules:
    MYKVER=$(strings $(find ${MYDATA}/kernel/ -name "*.ko*" |head -1) |grep ^vermagic |cut -d= -f2 |cut -d' ' -f1)
    if [ -z "${MYKVER}" ]; then
      echo "*** Could not determine new kernel version from module directory!"
      cleanup
      exit 1
    fi
    mkdir -p ${KERDIR}/lib/modules/${MYKVER}
    rsync -a ${MYDATA}/ ${KERDIR}/lib/modules/${MYKVER}/
  else
    # We assume a Slackware package:
    # Extract the kernel modules from the package and return the path:
    tar -C ${KERDIR} -xf ${MYDATA} lib/modules
  fi
  cd ${KERDIR}/lib/modules/*
  pwd
} # End of getpath_kernelmods

# Determine size of a mounted partition (in MB):
function get_part_mb_size() {
  local MYSIZE
  MYSIZE=$(df -P -BM ${1} |tail -1 |tr -s '\t' ' ' |cut -d' ' -f2)
  echo "${MYSIZE%M}"
} # End of get_part_mb_size

# Determine free space of a mounted partition (in MB):
function get_part_mb_free() {
  local MYSIZE
  MYSIZE=$(df -P -BM ${1} |tail -1 |tr -s '\t' ' ' |cut -d' ' -f4)
  echo "${MYSIZE%M}"
} # End of get_part_mb_free

# Parse a liveslak template file and substitute the placeholders.
function parse_template() {
  local INFILE="$1"
  local OUTFILE="$2"

  # We expect these variables to be set before calling this function.
  # But, we do provide default values.
  DISTRO=${DISTRO:-slackware}
  VERSION=${VERSION:-1337}

  cat ${INFILE} | sed \
    -e "s/@LIVEMAIN@/${LIVEMAIN:-liveslak}/g" \
    -e "s/@MARKER@/${MARKER:-LIVESLAK}/g" \
    -e "s/@MEDIALABEL@/${MEDIALABEL:-LIVESLAK}/g" \
    -e "s/@PERSISTENCE@/${PERSISTENCE:-persistence}/g" \
    -e "s/@DARKSTAR@/${LIVE_HOSTNAME:-darkstar}/g" \
    -e "s/@LIVEUID@/${LIVEUID:-live}/g" \
    -e "s/@LIVEUIDNR@/${LIVEUIDNR:-1000}/g" \
    -e "s/@DISTRO@/$DISTRO/g" \
    -e "s/@CDISTRO@/${DISTRO^}/g" \
    -e "s/@UDISTRO@/${DISTRO^^}/g" \
    -e "s/@CORE2RAMMODS@/${CORE2RAMMODS:-"min noxbase"}/g" \
    -e "s/@VERSION@/${VERSION}/g" \
    -e "s/@KVER@/$KVER/g" \
    -e "s/@SQ_EXT_AVAIL@/${SQ_EXT_AVAIL}/g" \
    -e "s,@DEF_KBD@,${DEF_KBD},g" \
    -e "s,@DEF_LOCALE@,${DEF_LOCALE},g" \
    -e "s,@DEF_TZ@,${DEF_TZ},g" \
    > ${OUTFILE}
} # End of parse_template()

#
#  -- end of function definitions --
#

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

# Parse the commandline parameters:
if [ -z "$1" ]; then
  showhelp
  exit 1
fi
while [ ! -z "$1" ]; do
  case $1 in
    -b|--nobackup)
      KBACKUP=0
      shift
      ;;
    -d|--devices)
      show_devices
      exit
      ;;
    -e|--examples)
      showexamples
      exit
      ;;
    -h|--help)
      showhelp
      exit
      ;;
    -i|--init)
      LIVEINIT="$(cd "$(dirname "$2")"; pwd)/$(basename "$2")"
      shift 2
      ;;
    -k|--kernel)
      KERNEL="$(cd "$(dirname "$2")"; pwd)/$(basename "$2")"
      shift 2
      ;;
    -m|--kmoddir)
      KMODDIR="$(cd "$(dirname "$2")"; pwd)/$(basename "$2")"
      shift 2
      ;;
    -n|--netsupport)
      NETSUPPORT=1
      shift
      ;;
    -o|--outdev)
      TARGET="$2"
      shift 2
      ;;
    -p|--persistence)
      CHANGES2SXZ=1
      shift
      ;;
    -r|--restore)
      RESTORE=1
      shift
      ;;
    -s|--scan)
      SCAN=1
      shift
      ;;
    -v|--verbose)
      VERBOSE=1
      shift
      ;;
    -w|--wait)
      WAIT="$2"
      shift 2
      ;;
     -N|--nolivemods)
      NOLIVEMODS=1
      shift
      ;;
     -x|--extend)
      EXTENSION="$2"
      shift 2
      ;;
    -X|--extendsize)
      INCSIZE="$2"
      shift 2
      ;;
    *)
      echo "*** Unknown parameter '$1'!"
      exit 1
      ;;
  esac
done

# Before we start:
if [ "$(id -u)" != "0" ]; then
  echo "*** You need to be root to run $(basename $0)."
  exit 1
fi

#
# More sanity checks:
#

# Either provide a block device, or else scan for a block device:
if [ -z "$TARGET" ]; then
  if [ $SCAN -eq 1 ]; then
    echo "--- Waiting ${SCANWAIT} seconds for a USB stick to be inserted..."
    TARGET=$(scan_devices ${SCANWAIT})
    if [ -z "$TARGET" ]; then
      echo "*** No new USB device detected during $SCANWAIT seconds scan."
      exit 1
    else
      TARGET="/dev/${TARGET}"
    fi
  else
    echo "*** You must specify the Live USB devicename (option '-o')!"
    echo "*** Alternatively, let the script scan for insertion (option '-s')!"
    exit 1
  fi
elif [ $SCAN -eq 1 ]; then
  echo "*** You can not use options '-o' and '-s' at the same time!"
  exit 1
fi

if [ ! -e /sys/block/$(basename $TARGET) ]; then
  echo "*** Not a block device: '$TARGET' !"
  show_devices
  exit 1
elif lsblk -l $TARGET |grep -w $(basename $TARGET) |grep -wq part ; then
  echo "*** You need to point to the storage device itself, not a partition ($TARGET)!"
  show_devices
  exit 1
fi

if [ -z "$KERNEL" -a -z "$KMODDIR" ]; then
  # We don't need to update the kernel/modules:
  UPKERNEL=0
else
  if [ $RESTORE -eq 1 ]; then
    echo "*** You can not use options '-k'/'-m' and '-r' at the same time!"
    exit 1
  fi
  # If we get here, we have one or both '-k' and '-m'.
  # Sanitize the input values of '-k' and '-m':
  if [ -z "$KERDIR" ]; then
    # Create a temporary extraction directory:
    mkdir -p /mnt
    KERDIR=$(mktemp -d -p /mnt -t alienker.XXXXXX)
    if [ ! -d $KERDIR ]; then
      echo "*** Failed to create temporary extraction dir for the kernel!"
      cleanup
      exit 1
    fi
  fi
  KERNEL="$(getpath_kernelimg ${KERNEL})"
  KMODDIR="$(getpath_kernelmods ${KMODDIR})"

  if [ ! -f "${KERNEL}" -o ! -d "${KMODDIR}" ]; then
    echo "*** You need to provide the path to a kernel imagefile (-k),"
    echo "*** as well as the directory containing the kernel modules (-m)!"
    cleanup
    exit 1
  else
    # Determine the new kernel version from a module,
    # rather than from a directory- or filenames:
    KVER=$(strings $(find ${KMODDIR}/kernel/ -name "*.ko*" |head -1) |grep ^vermagic |cut -d= -f2 |cut -d' ' -f1)
    if [ -z "${KVER}" ]; then
      echo "*** Could not determine kernel version from the module directory"
      cleanup
      exit 1
    fi
    UPKERNEL=1
  fi
fi

if [ -n "${LIVEINIT}" -a ! -f "${LIVEINIT}" ]; then
  echo "*** The replacement init script '${LIVEINIT}' is not a file!'"
  cleanup
  exit 1
fi

if [ -n "${EXTENSION}" ]; then
  if [ -z "${INCSIZE}" ]; then
    echo "*** LUKS container '${EXTENSION}' defined but no extension size provided!"
    echo "*** Not extending encrypted ${EXTENSION}, please use '-X' parameter."
    cleanup
    exit 1
  fi
fi

if [ $CHANGES2SXZ -eq 1 ] || [ $UPKERNEL -eq 1 ]; then
  # We need to create a module, so add squashfs to the required tools:
  REQTOOLS="${REQTOOLS} mksquashfs"
fi

# Are all the required tools present?
PROG_MISSING=""
for PROGN in ${REQTOOLS} ; do
  if ! which $PROGN 1>/dev/null 2>/dev/null ; then
    PROG_MISSING="${PROG_MISSING}--   $PROGN\n"
  fi
done
if [ ! -z "$PROG_MISSING" ] ; then
  echo "--- Required program(s) not found in search path '$PATH'!"
  echo -e ${PROG_MISSING}
  echo "--- Exiting."
  cleanup
  exit 1
fi

# We are refreshing the Live content.
# Confirm refresh:
cat <<EOT
#
# We are going to update the Live OS on this device.
# ---------------------------------------------------------------------------
# Target is - '$TARGET':
# Vendor : $(cat /sys/block/$(basename $TARGET)/device/vendor 2>/dev/null)
# Model  : $(cat /sys/block/$(basename $TARGET)/device/model 2>/dev/null)
# Size   : $(( $(cat /sys/block/$(basename $TARGET)/size) / 2048)) MB
# ---------------------------------------------------------------------------
#
# FDISK OUTPUT:
EOT

echo q |gdisk -l $TARGET 2>/dev/null | \
  while read LINE ; do echo "# $LINE" ; done

# If the user just used the scan option (-s) and did not select a task,
# we will exit the script gracefully now:
if [[ $WAIT -lt 0 && $UPKERNEL -ne 1 && $RESTORE -ne 1 && $NETSUPPORT -ne 1 && $LIVEINIT = ""  && $CHANGES2SXZ -ne 1  && $EXTENSION = "" ]]; then
  cleanup
  exit 0
else
  # We have one or more tasks to execute, allow user to back out:
  cat <<EOT
***                                                       ***
*** If this is the wrong drive, then press CONTROL-C now! ***
***                                                       ***

EOT
  read -p "Or press ENTER to continue: " JUNK
fi

# OK... the user was sure about the drive...
# Determine the three partition names independently of storage architecture:
TARGETP1=$(fdisk -l $TARGET |grep ^$TARGET |cut -d' ' -f1 |grep -E '[^0-9]1$')
TARGETP2=$(fdisk -l $TARGET |grep ^$TARGET |cut -d' ' -f1 |grep -E '[^0-9]2$')
TARGETP3=$(fdisk -l $TARGET |grep ^$TARGET |cut -d' ' -f1 |grep -E '[^0-9]3$')

# Normalize filepath:
if [ -f "${EXTENSION}" ]; then
    # Container is an actual file, so where are we mounted?
    EXTPART=$(cd "$(dirname "${EXTENSION}")" ; df --output=source . |tail -1)
    EXTMNT=$(cd "$(dirname "${EXTENSION}")" ; df --output=target . |tail -1)
    if [ "${EXTPART}" == "${TARGETP3}" ]; then
      # User already mounted the USB linux partition; remove mountpoint:
      EXTENSION="${EXTENSION#$EXTMNT}"
    fi
elif [ -n "${EXTENSION}" && "$(dirname ${EXTENSION})" == "." ]; then
  # Containerfile was provided without leading slash, add one:
  EXTENSION="/${EXTENSION}"
fi

# Create temporary mount point for the USB device:
mkdir -p /mnt
# USB mounts:
USBMNT=$(mktemp -d -p /mnt -t alienusb.XXXXXX)
if [ ! -d $USBMNT ]; then
  echo "*** Failed to create a temporary mount point for the USB device!"
  cleanup
  exit 1
else
  chmod 711 $USBMNT
fi
EFIMNT=$(mktemp -d -p /mnt -t alienefi.XXXXXX)
if [ ! -d $EFIMNT ]; then
  echo "*** Failed to create a temporary mount point for the USB device!"
  cleanup
  exit 1
else
  chmod 711 $EFIMNT
fi

# Mount the Linux partition:
mount -t auto ${TARGETP3} ${USBMNT}

# Mount the EFI partition:
mount -t vfat -o shortname=mixed ${TARGETP2} ${EFIMNT}

# Determine size of the Linux partition (in MB), and the free space:
USBPSIZE=$(get_part_mb_size ${USBMNT})
USBPFREE=$(get_part_mb_free ${USBMNT})

# Determine size of the EFI partition (in MB), and the free space:
EFIPSIZE=$(get_part_mb_size ${EFIMNT})
EFIPFREE=$(get_part_mb_free ${EFIMNT})

# Record the Slackware Live version:
OLDVERSION="$(cat ${USBMNT}/.isoversion 2>/dev/null)"
echo "--- The medium '${TARGET}' contains '${OLDVERSION}'"

# Try a write to the partition:
if touch ${USBMNT}/.rwtest 2>/dev/null && rm ${USBMNT}/.rwtest 2>/dev/null
then
  echo "--- The partition '${TARGETP3}' is writable."
else
  echo "--- Trying to remount readonly partition '${TARGETP3}' as writable..."
  mount -o remount,rw ${USBMNT}
  if [ $? -ne 0 ]; then
    echo "*** Failed to remount '${TARGETP3}' writable, unable to continue!"
    cleanup
    exit 1
  fi
fi

# Find out if the USB contains an EFI bootloader and use it:
if [ ! -f ${EFIMNT}/EFI/BOOT/boot*.efi ]; then
  EFIBOOT=0
  echo "--- Note: UEFI boot file 'bootx64.efi' or 'bootia32.efi' not found on ISO."
  echo "--- UEFI boot will not be supported"
else
  EFIBOOT=1
fi

# Record the size of the running kernel:
if  [ -f "${USBMNT}/boot/vmlinuz*" ]; then
  KIMG="$(find ${USBMNT}/boot/ -type f -name \"vmlinuz*\" |grep -v prev)"
else
  # Default liveslak kernelname:
  KIMG="${USBMNT}/boot/generic"
fi
OLDKERNELSIZE=$(du -sm "${KIMG}" |tr '\t' ' ' |cut -d' ' -f1)

# Collect data from the USB initrd:
IMGDIR="$( extract_initrd ${USBMNT}/boot/initrd.img )"
read_initrddir ${IMGDIR} "DEF_KBD DEF_LOCALE DEF_TZ DISTRO LIVE_HOSTNAME LIVEMAIN LIVEUID MARKER MEDIALABEL PERSISTENCE CORE2RAMMODS SQ_EXT_AVAIL VERSION"

# The read_initrddir routine will set SUPPORTED to '0'
# if it finds a non-standard configuration for kernel & modules:
if [ $KBACKUP -eq 1 ]; then
  if [ $SUPPORTED -ne 1 ]; then
    echo "*** ${TARGET} has an unsupported kernel configuration."
    echo "*** Exiting now."
    cleanup
    exit 1
  else
    # If free space is low, require '-b' to skip make a backup (unsafe).
    if [ $(( $USBPFREE - $OLDKMODDIRSIZE - $OLDKERNELSIZE )) -lt $MINFREE ]; then
      KBACKUP=-1
    fi
    if [ $EFIBOOT -eq 1 -a $(( $EFIPFREE - $OLDKMODDIRSIZE - $OLDKERNELSIZE )) -lt $MINFREE ]; then
      KBACKUP=-1
    fi
    if [ $KBACKUP -eq -1  ]; then
      echo "*** Not enough free space for a backup of old kernel and modules."
      echo "*** If you want to update your kerel anyway (without backup) then"
      echo "*** you have to add the parameter '-b' to the commandline."
      cleanup
      exit 1
    fi
  fi
fi

# Update the initrd with regard to USB wait time, liveinit, kernel:
update_initrd ${USBMNT}/boot/initrd.img ${IMGDIR}

# Add the new kernel modules as a squashfs module:
if [ $UPKERNEL -eq 1 ] && [ $NOLIVEMODS -eq 0 ]; then
  LIVE_MOD_SYS=$(dirname $(find ${USBMNT} -name "0099-${DISTRO}_zzzconf*.sxz" |head -1))
  LIVE_MOD_ADD=$(dirname ${LIVE_MOD_SYS})/addons
  MODNAME="0100-${DISTRO}_kernelmodules_${KVER}.sxz"
  echo "--- Creating kernelmodules addon live module '${MODNAME}'"
  rm -f ${LIVE_MOD_ADD}/${MODNAME}
  mksquashfs ${KERDIR} ${LIVE_MOD_ADD}/${MODNAME} -e boot -noappend -comp xz -b 1M
  unset LIVE_MOD_SYS LIVE_MOD_ADD MODNAME
fi

# Take care of the kernel in the Linux partition:
if [ $UPKERNEL -eq 1 ]; then
  if [ $KBACKUP -eq 1 ]; then
    # We always make one backup with the suffix ".prev":
    if [ $VERBOSE -eq 1 ]; then
      echo "--- Backing up ${KIMG} to ${USBMNT}/boot/$(basename \"${KIMG}\").prev"
    else
      echo "--- Backing up old kernel"
    fi
    mv "${KIMG}" ${USBMNT}/boot/$(basename "${KIMG}").prev
  else
    rm -rf "${KIMG}"
  fi
  # And we name our new kernel exactly as the old one:
  if [ $VERBOSE -eq 1 ]; then
    echo "--- Copying \"${KERNEL}\" to ${USBMNT}/boot/$(basename \"${KIMG}\")"
  else
      echo "--- Adding new kernel"
  fi
  cp "${KERNEL}" ${USBMNT}/boot/$(basename "${KIMG}")
elif [ $RESTORE -eq 1 -a $KRESTORE -eq 1 ]; then
  if [ $VERBOSE -eq 1 ]; then
    echo "--- Restoring ${USBMNT}/boot/$(basename \"${KIMG}\").prev to ${KIMG}"
  else
      echo "--- Restoring old kernel"
  fi
  OLDKVER=$(file "${KIMG}" |sed 's/^.*\(version [^ ]* \).*$/\1/' |cut -d' ' -f2)
  rm -f "${KIMG}"
  mv ${USBMNT}/boot/$(basename "${KIMG}").prev "${KIMG}"
  echo "--- You may remove obsolete 'addons/0100-${DISTRO}_kernelmodules_${OLDKVER}.sxz' module"
fi

if [ $EFIBOOT -eq 1 ]; then
  # Refresh the kernel/initrd on the EFI partition:
  if [ $VERBOSE -eq 1 ]; then
    rsync -rlptD  --delete -v ${USBMNT}/boot/* ${EFIMNT}/boot/
  else
    rsync -rlptD  --delete ${USBMNT}/boot/* ${EFIMNT}/boot/
  fi
  sync
fi

if [ $CHANGES2SXZ -eq 1 ]; then
  if [ ! -d /mnt/live/changes ]; then
    echo "*** No directory '/mnt/live/changes' exists!"
    echo "*** This script must be executed when running ${DISTRO^} Live Edition"
  else
    # We need to be able to write to the partition:
    mount -o remount,rw ${USBMNT}
    # Tell init to wipe the original persistence data at next boot:
    touch /mnt/live/changes/.wipe 2>/dev/null || true
    if [ ! -f /mnt/live/changes/.wipe ]; then
      echo "*** Unable to create file '/mnt/live/changes/.wipe'!"
      echo "*** Are you sure you are running ${DISTRO^} Live Edition?"
    else
      # Squash the persistence data into a Live .sxz module,
      # but only if we find the space to do so:
      CHANGESSIZE=$(du -sm /mnt/live/changes/ |tr '\t' ' ' |cut -d' ' -f1)
      if [ $(( $USBPFREE - $CHANGESSIZE )) -lt $MINFREE ]; then
        CHANGES2SXZ=-1
      fi
      if [ $CHANGES2SXZ -eq -1 ]; then
        echo "*** Not enough space to squash persistence data into a module."
        # Don't wipe persistence data on next boot!
        rm -f /mnt/live/changes/.wipe
        cleanup
        exit 1
      fi
      LIVE_MOD_SYS=$(dirname $(find ${USBMNT} -name "0099-${DISTRO}_zzzconf*.sxz" |head -1))
      LIVE_MOD_ADD=$(dirname ${LIVE_MOD_SYS})/addons
      MODNAME="0100-${DISTRO}_customchanges-$(date +%Y%m%d%H%M%S).sxz"
      echo "--- Moving current persistence data into addons module '${MODNAME}'"
      mksquashfs /mnt/live/changes ${LIVE_MOD_ADD}/${MODNAME} -noappend -comp xz -b 1M -e .wipe
    fi
  fi
fi

# Should we extend the size of a container?
if [ -n "${EXTENSION}" ]; then
  if [ "$(basename ${EXTENSION} ${CNTEXT})" == "$(basename ${EXTENSION})" ];
  then
    echo  "*** File '${EXTENSION}' does not have an '${CNTEXT}' extension!"
    cleanup
    exit 1
  fi
  # Expand existing container file:
  expand_container ${TARGETP3} ${INCSIZE} ${USBMNT}/${EXTENSION}
fi

# Unmount/remove stuff:
cleanup

# THE END