#!/bin/bash
set +o posix
shopt -s extglob

##########################################################################
# Script : kernel.SlackBuild
# Purpose: Natively build and package the Linux Kernel for Slackware ARM
# Author : Stuart Winter <mozes@slackware.com>
# Date...: 10-Feb-2022
##########################################################################
# Changelog
############
# 10-Feb-22:
#  Build a/kernel-modules & d/kernel-headers package to reduce build time
#  for Kernel packages, and ease maintenance of stable releases.
# 20-Apr-21:
#  Updated for AArch64.
#  Removed legacy ARM initrd creation code.
# 01-Apr-2018:
#  * Handle building Kernels in /patches
#  * Simplify and remove duplication of code.
# 20-Sep-2005
#  * First version for Linux 2.6.13.1 on the StrongARM RiscPC
# 31-Dec-2005
#   * Linux 2.6.14.5
##########################################################################
#
# Copyright 2005-2022  Stuart Winter, Surrey, England, UK.
# 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.
#

# Record toolchain & other info for the build log:
slackbuildinfo

# Paths to skeleton port's source & real Slackware source tree:
export CWD=$PWD

# Detect whether we're building for /patches:  This function sets the variable 'SLACKPATCHING'
slack_findpkgstore_is_stablerelease
echo "Building in /patches/? $SLACKPATCHING"

# Temporary build locations:
export TMPBUILD=$TMP/build-$PKGNAM
export PKG=$TMP/package-$PKGNAM
# Delete & re-create temporary directories then cd into $TMPBUILD
mkpkgdirs

# When using xz with tar, set the options:
export XZ_OPTS="--threads $(( $(nproc) -1 )) -ze9f -C crc32"

# Extract the kernel source:
echo -n "Extracting Kernel source... "
tar xf $CWD/sources/linux-*.tar.xz || exit 1
echo "done"
# Make the source tree dir name match $VERSION (useful for rc releases)
mv -fv linux-* linux-$VERSION
cd linux-*/ || exit 1
slackhousekeeping

# Install the appropriate Kernel config file:
install -vpm644 $CWD/configs/config-$SLKKERNELARCH .config

# Remove any hyphen from the EXTRAVERSION name.
sed -i '/EXTRAVERSION *=/s/-//g' Makefile

# Ensure that the Kernel version reported in the Makefile matches
# the version in the package name that we plan to use.
#
# If we're doing builds of RC kernels, we can ignore this check and assume we performed the
# necessary due dilligence.  Non-RC releases have no 'EXTRAVERSION' value set.
#
if ! echo "$VERSION" | egrep "rc|next" ; then
   if [ "$( echo "$(sed -ne's/^VERSION *= *//p' Makefile).$(sed -ne's/^PATCHLEVEL *= *//p' Makefile).$(sed -ne's/^SUBLEVEL *= *//p' Makefile)" )" != $VERSION ]; then
      echo "**** Package name vs Kernel version mismatch ****"
      echo "*** Slackware Packaging Version: $VERSION"
      echo "*** Kernel versions (From files): $( sed -ne's/^VERSION *= *//p' Makefile).$(sed -ne's/^PATCHLEVEL *= *//p' Makefile).$(sed -ne's/^SUBLEVEL *= *//p' Makefile )"
      exit 1
   fi
fi

echo "Kernel Slackware package version: $VERSION"

# Apply patches:
for i in $CWD/sources/patches/!(*debian*|*no-autopatch*)xz ; do
   auto_apply_patch $i || exit 1
done
#for i in $CWD/sources/patches/H3/* ; do xzcat $i | patch --verbose -p1 ; done
#[ "$SLKPORTARCH" = "aarch64" ] && { auto_apply_patch $CWD/sources/patches/0103-futex-no-autopatch.patch.xz || failpatch ;}

# For GCC-10:
sed -i "s/--param=allow-store-data-races=0/-fno-allow-store-data-races/g" Makefile

#tar xvvf $CWD/sources/patches/linux*debian*z
#for i in debian/patches/features/arm/* ; do
#   auto_apply_patch $i || exit 1
#done
#for i in debian/patches/bugfix/arm/* ; do
#   auto_apply_patch $i || exit 1
#done

# Build Kernel
echo "Cleaning Kernel.."
make clean
echo "******************************"
echo "*** Building kernel Image  ***"
echo "******************************"

[ "$SLKPORTARCH" = "arm" ] && \
   { make $NUMJOBS ARCH=$LINUXKERNELARCH CONFIG_DEBUG_SECTION_MISMATCH=y zImage || failmake ;}
[ "$SLKPORTARCH" = "aarch64" ] && \
  { make $NUMJOBS ARCH=$LINUXKERNELARCH CONFIG_DEBUG_SECTION_MISMATCH=y Image || failmake ;}

# Build modules:
echo "************************"
echo "*** Building modules ***"
echo "************************"
make $NUMJOBS ARCH=$LINUXKERNELARCH CONFIG_DEBUG_SECTION_MISMATCH=y modules || failmake

# Archive the compiled kernel source - this is used to create the kernel-source package.
# The reason why we check the architecture is because with the soft float port we had
# multiple kernels, but there was no need to have multiple Kernel sources.
# With the hard float and aarch64 port, we have just one Kernel; but in case we end up with
# more than one Kernel in the future, we'll keep this check in place.
# "SLKKERNELARCH" is the _package_ name architecture not the OS architecture - e.g. it'd be "armv5", "armv7", "armv8"
# e.g. the ARM port's packages are named "foo-1.0-arm-1.txz", but this particular _package_ will only run
# on armv7 or greater, so its specific package architecture is "armv7".
# If there is a case to require >1 kernel per arch again, there should be
# a kernel-source package for it, since it would be required to build modules that we don't ship, but
# that can easily be added by the user.
#
# The kernel-source package is now built at the end of this process rather than
# from a separate build script.
#if [[ "${SLKKERNELARCH}" =~ (armv7|armv8) ]]; then
#   echo "Archiving compiled source for kernel-source package..."
#   # This takes far too long on ARM. I'll let the Distro polishing script pack this one:
#   # ( cd .. && tar -Ixz -pcf $CWD/compiled-sources/$SLKKERNELARCH-kernel-$VERSION-compiled.tar.xz linux-$VERSION )
#   ( cd .. && tar pcf $CWD/compiled-sources/$SLKKERNELARCH-kernel-$VERSION-compiled.tar linux-$VERSION )
#fi

echo "Installing Kernel includes for package d/kernel-headers..."
# Create package structure:
mkdir -vpm755 $TMPBUILD/package-kernel-headers/{install,usr}
# Install 'sanitised' headers:
make ARCH=$LINUXKERNELARCH \
     INSTALL_HDR_PATH=$TMPBUILD/package-kernel-headers/usr \
     headers_install || failinstall
( cd $TMPBUILD/package-kernel-headers || exit 1
  # Wipe these '.install' and '..install.cmd' files
  find . -iname '.*' -type f -print0 | xargs -0 rm -f )
# Not anymore - the glibc build uses the Kernel package headers.
#  echo "Archiving kernel-headers for use with glibc"
#  mkdir -vpm755 $CWD/sources/kernel-headers
#  time tar -Ixz -pcf $CWD/sources/kernel-headers/$SLKKERNELARCH-kernel-headers-$VERSION.tar.xz . )

# Install modules into the package:
make ARCH=$LINUXKERNELARCH modules_install INSTALL_MOD_PATH=$PKG || exit 1

# We'll install the Kernel modules to the OS once they have been
# compressed within $PKG:
rm -rf /lib/modules/$VERSION-$SLKKERNELARCH
# Needed for mkinitrd to find the modules, but we'll install
# the compressed versions from $PKG since it cuts down on build time.
#make ARCH=$LINUXKERNELARCH modules_install || exit 1

# Wipe the firmware from the package since it's included in the a/kernel-firmware package
# and dealt with above:
echo "Wiping /lib/firmware from the current package contents so that"
echo "it won't be included in the a/kernel-modules package ..."
rm -rf $PKG/lib/firmware

# Compress the Kernel modules that have been installed into the
# package:
echo "Compressing package's Kernel modules with xz -e9 -- this will take 10-15 mins.."
pushd $PKG
   time find ./lib/modules -type f -name "*.ko" -exec xz $XZ_OPTS {} \;
   # Fix symlinks now that the Kernel modules have a .xz suffix:
   for i in $(find ./lib/modules -type l -name "*.ko") ; do ln -vfs $( readlink $i ).xz $i.xz ; rm -fv $i ; done

   # Install the newly-compressed Kernel modules into the OS:
   echo "Installing compressed Kernel modules into /lib/modules for the running OS"
   time cp -fa ./lib/modules/$VERSION-$SLKKERNELARCH /lib/modules/
popd

# Compress OS's copy of the Linux kernel modules to reduce the size of the initrd.
#echo "Compressing Host OS' Kernel modules (for $SLKKERNELARCH) with xz -e9 -- this will take 10-15 mins.."
##find /lib/modules/$VERSION-$SLKKERNELARCH -type f -name "*.ko" -exec gzip -9f {} \;
#time find /lib/modules -type f -name "*.ko" -exec xz $XZ_OPTS \;
#for i in $(find /lib/modules/$VERSION-$SLKKERNELARCH -type l -name "*.ko") ; do ln -vfs $( readlink $i ).xz $i.xz ; rm -fv $i ; done

# Archive the Kernel modules for the Slackware 'a/kernel-modules'
# package:
# To be removed - we create the kernel-modules package from this
# build script.
#if [ "$SLACKPATCHING" = "no" ]; then
##   ( cd $PKG && tar -Ixz -pcf $CWD/../a/kernel-modules/sources/$SLKKERNELARCH-kernel-modules-$VERSION.tar.xz lib/ )
#   # We don't create a compressed archive here since the only contents are Kernel modules
#   # which are already LZMA compressed:
#   time ( cd $PKG && tar pcf $CWD/../a/kernel-modules/sources/$SLKKERNELARCH-kernel-modules-$VERSION.tar lib/ )
# else
##   ( cd $PKG && tar -Ixz -pcf $CWD/../kernel-modules/sources/$SLKKERNELARCH-kernel-modules-$VERSION.tar.xz lib/ )
#   time ( cd $PKG && tar pcf $CWD/../kernel-modules/sources/$SLKKERNELARCH-kernel-modules-$VERSION.tar lib/ )
#fi

## Usually we'd do this inside the resulting package but we need the modules
## to be up to date on the live system so that mkinitrd can grab what it needs:
( cd /
  echo "Updating host OS' module dependencies for $VERSION-$SLKKERNELARCH"
  find lib/modules -name $VERSION-$SLKKERNELARCH -type d -mindepth 1 -maxdepth 1 -printf "%f\n" | xargs -i depmod {} -b. )

# Install the kernel image and system map:
mkdir -vpm755 $PKG/{install,boot}

# Building zImage for ARM creates Image, and subsequently
# compresses it.  Since we don't ship the uncompressed version
# for ARM, we'll delete it so that it doesn't get included
# by the search code below.
[ "$SLKPORTARCH" = "arm" ] && rm -f arch/$LINUXKERNELARCH/boot/Image

#gzip -f9cv System.map > $PKG/boot/System.map-$SLKKERNELARCH-$VERSION.gz
# These are named after their respective architectures so that you
# can have more than 1 Kernel package installed on the system
# at any one time, and configure your boot loader to boot, say
# "/uImage-", and not then have to maintain Kernel version
# numbers.
# We'll wipe the ones we don't need for this architecture a bit
# further down.
install -vpm644 System.map $PKG/boot/System.map-$SLKKERNELARCH-$VERSION
for imgtype in {,z,u}Image ; do
   [ -f arch/$LINUXKERNELARCH/boot/$imgtype ] && \
   install -vpm644 arch/$LINUXKERNELARCH/boot/$imgtype $PKG/boot/$imgtype-$SLKKERNELARCH-$VERSION
done
# Make symlinks:
( cd $PKG/boot
  ln -vfs System.map-$SLKKERNELARCH-$VERSION System.map-$SLKKERNELARCH
  for imgtype in {,z,u}Image ; do
     [ -f $imgtype-$SLKKERNELARCH-$VERSION ] && \
     ln -vfs $imgtype-$SLKKERNELARCH-$VERSION $imgtype-$SLKKERNELARCH
  done )

# The Kernel config file used (following the Slackware standard):
install -pvm644 .config $PKG/boot/config-$SLKKERNELARCH-$VERSION

# The package description:
install -pvm644 $CWD/slack-descs/$SLKKERNELARCH-kernel $PKG/install/slack-desc
# The script to handle appending DTB files to systems that have the
# 'dtb=' kernel paramater specified:
# Not needed for hard float port since all of the U-Boot versions are new enough
# to handle loading a DTB, but we'll leave this in here and let it error out.
install -pvm644 $CWD/sources/doinst.sh $PKG/install/

# Copy the Kernel into our tree's 'kernels' directory:
# If you want to keep these, move the old one out of the way first
# otherwise it gets clobbered.
if [ "$SLACKPATCHING" = "no" ]; then
   mkdir -vpm755 $PKGSTORE/../kernels/$SLKKERNELARCH

   for imgtype in {,z,u}Image ; do
        [ -f arch/$LINUXKERNELARCH/boot/$imgtype ] && \
        install -vpm644 arch/$LINUXKERNELARCH/boot/$imgtype \
                       $PKGSTORE/../kernels/$SLKKERNELARCH/$imgtype-$SLKKERNELARCH
   done

   # This is really for the installer build script:
   gzip -f9cv System.map  > $PKGSTORE/../kernels/$SLKKERNELARCH/System.map.gz

   # And because Slackware includes the kernel config, let's do it too!
   install -vpm644 .config $PKGSTORE/../kernels/$SLKKERNELARCH/config
fi

# Make an initrd for the architecture.
# Unpack the generic Slackware Initial RAM disk ('OS initrd') tree:
rm -rf $TMPBUILD/initrd-tree
mkdir -vpm755 $TMPBUILD/initrd-tree
tar xf /usr/share/mkinitrd/initrd-tree.tar.gz -C $TMPBUILD/initrd-tree

# Unpack bash, ncurses, jfsutils and xfsprogs as we need a few
# components:
mkdir -p $TMPBUILD/pkg-extract
pushd $TMPBUILD/pkg-extract
   explodepkg $PKGSTORE/a/bash-+([^-])-+([^-])-+([^-]).t[gblx]z
   explodepkg $PKGSTORE/l/ncurses-+([^-])-+([^-])-+([^-]).t[gblx]z
   sh install/doinst.sh # set up symlinks for ncurses
   explodepkg $PKGSTORE/a/jfsutils-+([^-])-+([^-])-+([^-]).t[gblx]z
   explodepkg $PKGSTORE/a/xfsprogs-+([^-])-+([^-])-+([^-]).t[gblx]z
   explodepkg $PKGSTORE/a/util-linux-+([^-])-+([^-])-+([^-]).t[gblx]z
   sh install/doinst.sh # set up symlinks for util-linux

   # Install libtinfo from ncurses:
   mkdir -vpm755 $TMPBUILD/initrd-tree/lib${LIBDIRSUFFIX}
   cp -fav lib${LIBDIRSUFFIX}/libtinfo.so* $TMPBUILD/initrd-tree/lib${LIBDIRSUFFIX}/

   # Install lsblk and its dependencies from the a/util-linux package:
   # This is used by the 'await_device' to find labeled file systems.
   cp -fav bin/lsblk $TMPBUILD/initrd-tree/bin/
   cp -fav lib${LIBDIRSUFFIX}/libmount.so.* $TMPBUILD/initrd-tree/lib${LIBDIRSUFFIX}/
   cp -fav lib${LIBDIRSUFFIX}/libsmartcols.so.* $TMPBUILD/initrd-tree/lib${LIBDIRSUFFIX}/

   # Support custom keymaps:
   install -vpm644 /usr/share/mkinitrd/keymaps.tar.gz $TMPBUILD/initrd-tree/etc/

   # These are added by Slackware's 'mkinitrd' if these modules are required.
   # We'll add them as standard, since we bundle the modules in the generic
   # initrd.
   install -Dvpm755 sbin/{xfs_repair,jfs_fsck} -t $TMPBUILD/initrd-tree/sbin/

   # Use the 'bash' shell instead of busybox, as Slackware ARM uses the
   # richer feature set to make the module loader scripts more succinct:
   rm -f $TMPBUILD/initrd-tree/bin/bash # is a symlink to busybox
   # /init needs to use bash as we use some of the extended features:
   sed -i 's?#!/bin/ash?#!/bin/bash?g' $TMPBUILD/initrd-tree/init
   install -vpm755 bin/bash* $TMPBUILD/initrd-tree/bin/bash

   # Helper to wait for the root device to become available:
   sed -i '\?^sleep \$WAIT*? a\. /await_device' $TMPBUILD/initrd-tree/init || exit 1
   install -vpm755 $CWD/SlkOS-initrd-overlay/await_device $TMPBUILD/initrd-tree/

   # Support execution of a function prior to switching into the OS proper:
   # This could be defined within a Hardware Model's Kernel Module Loader helper
   # script, or perhaps within the /boot/local/load_kernel_modules.post.
   # This is the last chance before the OS proper boots, and it's post software RAID
   # et al initialisation.
   sed -i '\?exec switch_root ?i\fnexists hwm_hook_pre_switch_root && hwm_hook_pre_switch_root' $TMPBUILD/initrd-tree/init || exit 1
   sed -i '\?exec switch_root ?i\fnexists hook_pre_switch_root && hook_pre_switch_root' $TMPBUILD/initrd-tree/init || exit 1

   # Wrap reboot to call the reboot binary with -f(orce).  This is required because the
   # OS environment isn't fully established:
   # This wraps the binary because /usr/local/sbin is ahead of /sbin in $PATH
   mkdir -vpm755 $TMPBUILD/initrd-tree/usr/local/sbin
   echo "/sbin/reboot -f" > $TMPBUILD/initrd-tree/usr/local/sbin/reboot
   chmod 755 $TMPBUILD/initrd-tree/usr/local/sbin/reboot
popd

# Use mkinitrd to create a default environment:
cd $TMPBUILD

echo "Calling mkinitrd: creating a default Slackware initrd environment"
MKINITRD_ALLOWEXEC=yes mkinitrd \
  -R \
  -L \
  -u \
  -k $VERSION-$SLKKERNELARCH \
  -s $TMPBUILD/initrd-tree \
  -o $TMPBUILD/initrdtmp.gz

# Sanity check that mkinitrd created some output:
[ ! -f $TMPBUILD/initrdtmp.gz ] && {
   read -p "ERROR: creation of temporary Initial RAM disk failed"
   exit 1 ;}

# Switch to that new environment.
# At this stage, we've
# 1. Unpacked the standard Slackware initrd environment that's packaged
#    within the a/mkinitrd package
# 2. Added 'bash' and a library from 'ncurses' to that environment
# 3. Used the mkinitrd tool to populate that enviromnemt with the default
#    set of runtime libraries, taken from the host build system.
# 4. Now we're going to switch to that new environment and continue
#    populating it to become the generic ARM OS InitRD.
mv -fv $TMPBUILD/initrd-tree{,.orig}
mkdir -vpm755 $TMPBUILD/initrd-tree
cd $TMPBUILD/initrd-tree
# Unpack the newly built initrd image into the fresh initrd root fs:
zcat $TMPBUILD/initrdtmp.gz | cpio -di

echo "Copying packaged Kernel modules into OS initrd"
rm -rf lib/modules/ # clean what the mkinitrd populated here
mkdir -vpm755 lib/modules/
cp -fa $PKG/lib/modules/* lib/modules/

# Slim down the modules within the initrd by removing unnecessary
# major sub systems or drivers for hardware that is not required during
# the initial boot.
# There will be far more that are also surplus to requirements but I'm
# trying to strike a balance between size and enabling the community to
# more easily light up Slackware AArch64 onto new platforms.
#
pushd lib/modules/*/kernel
   rm -rfv sound
   rm -rfv drivers/{bluetooth,interconnect,mailbox}
   rm -rfv drivers/{perf,ptp,soundwire,thermal}
   rm -rfv drivers/net/{wireless,can,ipa}
   rm -rfv fs/{ntfs}
   rm -rfv net/{802,8021q,bluetooth,bridge,can,dsa,mac80211,netfilter,nfc,wireless}
popd

echo "Compressing initrd's Kernel modules with xz -e9 -- this will take 10-15 mins.."
#time find ./lib/modules -type f -name "*.ko" -exec xz --threads $(( $(nproc) -1 )) -ze9f -C crc32 {} \;
time find ./lib/modules -type f -name "*.ko" -exec xz $XZ_OPTS {} \;
# Fix any broken symlinks post compression:
for i in $(find ./lib/modules -type l -name "*.ko") ; do ln -vfs $( readlink $i ).xz $i.xz ; rm -fv $i ; done

# Kernel Module loader for Slackware AArch64.  This loads a base set of
# platform modules generally useful on all SoCs, and at boot time
# loads specific SoC modules for the host platform.
# If you want to add support for a new platform, please look at this
# script and give mozes@slackware.com a diff.
install -vpm755 $CWD/SlkOS-initrd-overlay/load_kernel_modules .
# Install the board support scripts:
mkdir -vpm755 load_kernel_modules.scr/platform/$SLKPORTARCH
install -vpm755 $CWD/SlkOS-initrd-overlay/load_kernel_modules.scr/platform/$SLKPORTARCH/* \
                load_kernel_modules.scr/platform/$SLKPORTARCH/

# Walk the host architecture, calling the helper scripts to
# perform any Hardware Model specific actions.
if [ -d  $CWD/platform/$SLKPORTARCH ]; then
   for helper in $( find $CWD/platform/$SLKPORTARCH -type f -mindepth 1 -maxdepth 1 ) ; do
      echo "Executing Kernel Build helper for ${helper##*/}"
      . $helper
   done
fi

# Generic initrd configuration:
> rootdev # both are controlled by the Kernel cmdline parameters since
> rootfs  # this is a generic platform initrd.
echo 4 > wait-for-root # media spinup delay
echo "/boot/initrd-$SLKKERNELARCH.gz" > initrd-name
rm -f command_line # it was a temporary build - useless info

# Shipping the Software RAID configuration of a build machine
# doesn't make sense.  /init tries to set up Software RAID itself
# but users can also use the os-initrd-mgr tool to manage the
# addition and removal of the OS's /etc/mdadm.conf.
rm -f etc/mdadm.conf

# Update the indexes so we can boot this baby:
echo "Updating linker cache and Kernel module maps...."
ldconfig -r.
depmod -b. $VERSION-$SLKKERNELARCH

# Pack into initramfs format:
# The kernel panics when I pack this with XZ, despite having support
# compiled in.
#find . | cpio -o -H newc | xz -ze9 > /boot/initrd-armv8
# So we'll use gzip:
find . | cpio -o -H newc | gzip -9 > $TMPBUILD/initrd-$SLKKERNELARCH.gz

# Store the size of the initrd uncompressed, so that the
# /usr/sbin/os-initrd-mgr knows how much temp space to allocate
# when repacking the OS initrd to include any user local additions:
cat << EOF > $PKG/boot/.boot_details
# This file was created originally by source/k/kernel.SlackBuild
# during the Kernel package build process, and potentially updated
# by /usr/sbin/os-initrd-mgr.
#
#
# Do not edit this file by hand!
#
#
# Size of the OS InitRD in bytes.  This is used for os-initrd-mgr to
# determine whether it can safely unpack the initrd.
initrdsize=$( du -sb . | awk '{print $1}' )
# ARM architecture version.  This allows os-initrd-mgr to rebuild
# the initrd via the symlink /boot/initrd-armvN.
# armv7 = "Slackware ARM"
# armv8 = "Slackware AArch64"
platform=$SLKKERNELARCH
EOF
# Add the sample scripts:
install -Dvpm644 $CWD/boot-skeleton/local/* -t $PKG/boot/local/
# Add the Hardware Model post Kernel package installation helper scripts.
# There aren't any for ARM presently:
[ "$SLKPORTARCH" = "aarch64" ] && {
   install -Dvpm644 $CWD/boot-skeleton/platform/aarch64/helper/README.txt -t $PKG/boot/platform/aarch64/helper/
   # We may store other types of helper scripts here in the future, so
   # we'll take only our 'kernel' helpers:
   install -Dvpm755 $CWD/boot-skeleton/platform/aarch64/helper/pkg-kernel-* -t $PKG/boot/platform/aarch64/helper/
}

# Add the initrd manager:
install -Dvpm755 $CWD/sources/os-initrd-mgr -t $PKG/usr/sbin/
mkdir -vpm755 $PKG/usr/man/man8
pod2man \
   --section=8  \
   --release="$( grep -E ' Date.*:' $CWD/sources/os-initrd-mgr | awk -F: '{ print $2 }' )" \
   --center=' ' \
   --date="os-initrd-mgr Version $( grep -E ' Version.*: ' $CWD/sources/os-initrd-mgr | awk -F: '{ print $2 }' )" \
   $CWD/sources/os-initrd-mgr.pod 2>&1 | gzip -9f > $PKG/usr/man/man8/os-initrd-mgr.8.gz

# Store the standard gzipped initial RAM disk, plus its U-Boot format counterpart:
#
# 1. Within the 'slackware-current/kernels' directory.
#
# When building patch packages, we never provide an updated version of this file outside of the
# package archive.  This is because files in the '/kernels' directory are generally for
# use with the Slackware installer image, and we normally don't update those once the
# Slackware version is released (as they'd be different versions to those in the main
# 'slackware/' tree).
if [ "$SLACKPATCHING" = "no" ]; then
   for imgtype in {,u}initrd ; do
      [ -f $TMPBUILD/${imgtype}-$SLKKERNELARCH.gz ] && \
      install -vpm644 $TMPBUILD/${imgtype}-$SLKKERNELARCH.gz \
                      $PKGSTORE/../kernels/$SLKKERNELARCH/${imgtype}-$SLKKERNELARCH
   done
fi

# 2. Within $PKG/boot
#
# This allows devices whose boot loader can read the partition where /boot resides
# (all Directly Integrated Hardware Model support):
[ -f $TMPBUILD/uinitrd-$SLKKERNELARCH ] && \
   install -vpm644 $TMPBUILD/uinitrd-$SLKKERNELARCH $PKG/boot/uinitrd-$SLKKERNELARCH-$VERSION
# The gzipped compressed cpio version:
install -vpm644 $TMPBUILD/initrd-$SLKKERNELARCH.gz $PKG/boot/initrd-$SLKKERNELARCH-$VERSION

# Create symlinks to enable static boot loader configuration:
# (having version numbers would necessitate a boot loader change with every
# Kernel package release):
( cd $PKG/boot
 for imgtype in {,u}initrd ; do
     [ -f $imgtype-$SLKKERNELARCH-$VERSION ] && \
     ln -vfs $imgtype-$SLKKERNELARCH-$VERSION $imgtype-$SLKKERNELARCH
  done )

# It's nice to have this final touch (pun intended):
#if [ "$SLACKPATCHING" = "no" ]; then
#   ( cd $PKGSTORE/../kernels/$SLKKERNELARCH/
#     for imgtype in {,z,u}Image ; do
#        [ -f $imgtype-$SLKKERNELARCH ] && \
#          touch -r $imgtype-$SLKKERNELARCH * $PKG/boot/*
#     done )
#fi

# Compile the Device Tree Source (DTS) files into Device Tree Blobs (DTB):
# This file is for the 'Flattened Device Tree' technology.
# For the generic 'armv7' kernels, we have no way of knowing which DTB file
# the user will require, so we have to ship them all for each architecture.
#
mkdir -vpm755 $PKG/{install,boot/dtb-$VERSION}
ln -rvfs $PKG/boot/dtb-$VERSION $PKG/boot/dtb

# Ensure that we're in the correct directory to build the DTB files.
cd $TMPBUILD/linux-$VERSION && make ARCH=$LINUXKERNELARCH dtbs || failmake

# Install them to a temporary directory.  The make install
# creates a 'dtbs' directory within the specified path.
make INSTALL_PATH=$TMPBUILD dtbs_install || failmake

# Copy the extra ones that are not yet in the mainline kernel.  These are only for
# armv7:
# This was for an experiment where I was using a forked Kernel tree.
#if [ "$SLKKERNELARCH" = "armv7" ]; then
#  echo "Adding extra DTBs from $CWD/sources/extra-dtb/ (if any exist)"
#  cp -fav $CWD/sources/extra-dtb/*.dtb $TMPBUILD/linux-$VERSION/arch/$LINUXKERNELARCH/boot/dts/
#fi

# Install DTB's into the package:
#install -vpm644 $TMPBUILD/linux-$VERSION/arch/$LINUXKERNELARCH/boot/dts/*.dtb $PKG/boot/dtb-$VERSION/
# AArch64 groups the DTBs by platform type, unlike ARM where they're in a
# flat level directory structure.
# The directory structure is: $TMPBUILD/dtbs/5.10.21-armv8
cp -fa $TMPBUILD/dtbs/*/* $PKG/boot/dtb-$VERSION/ || failinstall

# Install copies into the 'kernels' directory so that they can be easily
# available for tftp booting:
# We don't version the DTB files inside the '/kernels' directory because
# the kernel + initrd files are not versioned here since this dir is not
# packaged/version managed.
if [ "$SLACKPATCHING" = "no" ]; then
   rm -rf $PKGSTORE/../kernels/$SLKKERNELARCH/dtb
   mkdir -vpm755 $PKGSTORE/../kernels/$SLKKERNELARCH/dtb
   cp -fa $TMPBUILD/dtbs/*/* $PKGSTORE/../kernels/$SLKKERNELARCH/dtb/ || failinstall
   #install -vpm644 -oroot -groot $PKG/boot/dtb-$VERSION/* $PKGSTORE/../kernels/$SLKKERNELARCH/dtb/
fi

# Move the Kernel modules into their own package:
cd $PKG
mkdir -vpm755 $TMPBUILD/package-kernel-modules/install
mv -fv lib $TMPBUILD/package-kernel-modules/

###############################################################################
# Build the base 'a/kernel' package:
###############################################################################
echo "*****************************************************************"
echo "Building base package slackware/a/$SLACKPACKAGE"
echo "*****************************************************************"

# Replace version number with a _ so it doesn't get confused with
# the package name.
# This is incase we're using any '-rc' releases.
export VERSION="$( echo $VERSION | sed 's?-??g' )"

cd $PKG

# Apply some of the generic Slackware packaging policies:
slackslack  # chown -R root:root, chmod -R og-w, slackchown, slack644docs

# We need to pre-pend the symlink code to the main 'doinst.sh' since it requires the
# versionless symlinks for /usr/sbin/os-initrd-mgr
#makepkg -p -l y -c n $PKGSTORE/$PKGSERIES/$PKGNAM-$VERSION-$SLKPORTARCH-$BUILD.txz
slackmp -p # run makepkg --prepend -l y -c n

###############################################################################
# Build the 'a/kernel-modules' package:
###############################################################################
# Set the package name to the particular architecture we're currently processing:
# I don't know why I had this - it makes no sense to have a package named
# "kernel-modules-kirkwood-2.6.38.2_kirkwood-arm-2.t?z"
# export SLACKPACKAGE=$PKGNAM-$ARCHTYPE-${VERSION}-$PKGARCH-$BUILD.t?z
# I do now, this matches the naming scheme for Slackware x86's "smp" kernel package.
# Even though the package name is different thus indeed creates a separate package,
# it breaks the installer build script and since the x86 package will remain with the
# same naming convention, it makes no sense to break it all here!
export PKGNAM=kernel-modules
[ $SLACKPATCHING = "no" ] && export PKGSERIES=a
export SLACKPACKAGE=$PKGNAM-$SLKKERNELARCH-${VERSION}_${SLKKERNELARCH}-$PKGARCH-$BUILD.txz

echo "*****************************************************************"
echo "Building package: $SLACKPACKAGE"
echo "*****************************************************************"

cd $TMPBUILD/package-kernel-modules

# Install package description:
install -vpm644 $CWD/slack-descs/$SLKKERNELARCH-kernel-modules install/slack-desc

# Install the post install script.
# This is taken from Slackware's kernel-modules.SlackBuild script:
cat << EOF > install/doinst.sh
# A good idea whenever kernel modules are added or changed:
if [ -x sbin/depmod ]; then
  chroot . /sbin/depmod -a $VERSION-$SLKKERNELARCH 1> /dev/null 2> /dev/null
fi

EOF

# This is a symlink to where the kernel was compiled
# We wipe these and create new ones pointing to /usr/src
# (our kernels were compiled in a temporary location, so the symlink would be broken)
# The symlinks looked like this:
# /lib/modules/<ver>/build -> /root/tmp/build-kernel_armv7/linux-5.15.19
# Why don't we just make the symlink using the existing variables?
# That's because at the time of writing I'm taking this from the old kernel-modules.SlackBuild
# and my guess is that at some points, the dir name might not be what we expected.
pushd lib/modules/*
LINKLOC=$( find . -name source -printf "%l\n" | rev | cut -d/ -f1 | rev )
rm -rf source
ln -vfs ../../../usr/src/$LINKLOC source
LINKLOC=$( find . -name build -printf "%l\n" | rev | cut -d/ -f1 | rev )
rm -rf build
ln -vfs ../../../usr/src/$LINKLOC build
popd

# Update the dependencies list:
# depmod -b $PKG $VERSION
# Generate modules.dep files for each ARM architecture we have inside lib/modules.
# This is legacy from when we had the all-in-one script, but I like it so it stays :-)
find lib/modules -type d -mindepth 1 -maxdepth 1 -printf "%f\n" | xargs -i depmod {} -b.

# Handle building within /patches:
# This shouldn't be needed and I want all patches to be placed into
# /tmp/patches for future automation.
#if [ $SLACKPATCHING = "no" ]; then
#   export PKGSERIES=k
# else
#   export PKGSERIES=patches
#   export PKGSTORE=/tmp/
#   mkdir -vpm755 $PKGSTORE/$PKGSERIES
#fi

# Apply some of the generic Slackware packaging policies:
slackslack  # chown -R root:root, chmod -R og-w, slackchown, slack644docs

# run makepkg -l y -c n
slackmp

###############################################################################
# Build the 'd/kernel-headers' package:
###############################################################################

# The headers are installed into the root of this package earlier
# in the Kernel build process, so all we need here is to install the
# slack-desc and set permissions.

# Package information:
export PKGNAM=kernel-headers
export SLACKPACKAGE=$PKGNAM-$VERSION-$PKGARCH-$BUILD.txz

echo "*****************************************************************"
echo "Building package: $SLACKPACKAGE"
echo "*****************************************************************"

# Handle building within /patches:
[ $SLACKPATCHING = "no" ] && export PKGSERIES=d

# Enter package root:
cd $TMPBUILD/package-kernel-headers || exit 1

# Install package description:
install -vpm644 $CWD/slack-descs/kernel-headers install/slack-desc

# Apply some of the generic Slackware packaging policies:
slackslack  # chown -R root:root, chmod -R og-w, slackchown, slack644docs

echo " + Running makepkg for 'kernel-headers'"
slackmp # run makepkg

###############################################################################
# Build the 'k/kernel-source' package:
###############################################################################

# Package information:
export PKGNAM=kernel-source
export SLACKPACKAGE=$PKGNAM-$VERSION-$PKGARCH-$BUILD.txz

echo "*****************************************************************"
echo "Building package: $SLACKPACKAGE"
echo "*****************************************************************"

# Handle building within /patches:
[ $SLACKPATCHING = "no" ] && export PKGSERIES=k

# Move the Kernel source into a directory into which we can package it:
cd $TMPBUILD

# Prepare the package framework:
mkdir -vpm755 package-kernel-source/{install,usr/src}

# Move the Linux source into our packaging directory:
# echo "Copying Linux source for packaging..."
# We won't do this since it takes longer and during development
# I never need any of the assets that are removed by the packaging process.
# cp -fa linux-$VERSION package-kernel-source/usr/src/
mv -fv linux-$VERSION package-kernel-source/usr/src/ || exit 1
cd package-kernel-source/usr/src || exit 1

# Ensure that the linux dir name matches the $VERSION of the package so that
# in the a/kernel-modules package, the /lib/modules/*/{build,source}
# symlinks are correct.
ln -vfs linux-$VERSION linux
cd linux || exit 1

# Prepare for packaging:
echo " + Cleaning up the source tree"
make ARCH=$LINUXKERNELARCH clean
# Make sure header files aren't missing:
make ARCH=$LINUXKERNELARCH prepare
# Don't package the kernel in the sources:
find . -name "*Image" -exec rm "{}" \;
# No need for these:
rm -fv .config.old .version
find . -name "*.cmd" -exec rm -f "{}" \;
rm -v .*.d
find . -name '.gitignore' -print0 | xargs -0 rm -rf
find . -name '.tmp*' -print0 | xargs -0 rm -rf

# Install package description:
cd $TMPBUILD/package-kernel-source
install -vpm644 $CWD/slack-descs/kernel-source install/slack-desc

# Apply some of the generic Slackware packaging policies:
slackslack  # chown -R root:root, chmod -R og-w, slackchown, slack644docs

echo " + Running makepkg for 'kernel-source'"
slackmp # run makepkg

#EOF