deb-build-kernel

#!/bin/bash -eu
#
# Build Debian kernel packages
#

function debian_arch()
{
	case "${1}" in
		amd64|x86_64)    echo "amd64" ;;
		arm64)           echo "arm64" ;;
		armhf|arm)       echo "armhf" ;;
		ppc64el|powerpc) echo "ppc64el" ;;
		riscv64|riscv)   echo "riscv64" ;;
		s390x|s390)      echo "s390x" ;;
		*)
			echo "Invalid architecture: ${1}" >&2
			exit 1
			;;
	esac
}

function kernel_arch()
{
	case "${1}" in
		amd64|x86_64)    echo "x86_64" ;;
		arm64)           echo "arm64" ;;
		armhf|arm)       echo "arm" ;;
		ppc64el|powerpc) echo "powerpc" ;;
		riscv64|riscv)   echo "riscv" ;;
		s390x|s390)      echo "s390" ;;
		*)
			echo "Invalid architecture: ${1}" >&2
			exit 1
			;;
	esac
}

function run()
{
	local cmd

	cmd=()
	if [ -n "${SCHROOT}" ] ; then
		cmd=("schroot" "-p" "-r" "-c" "${SCHROOT}" "--")
	fi
	cmd+=("${@}")

	echo "-- Run: ${cmd[*]}"
	if [ "${DRY_RUN}" -eq 0 ] ; then
		"${cmd[@]}"
	fi
}

function usage()
{
	cat <<EOF
Usage: deb-build-kernel [-a ARCH] [-b ABI] [-c CPUS] [-d] [-g] [-h] [-l] [-n]
                        [-o CFG:VAL] [-s SCHROOT] [-v VERSION]
                        TARGET [-- ARGS...]

Build Debian kernel packages.

Positional arguments:
  TARGET                 Build target (see below).
  ARGS                   Additional arguments passed to kernel make. If not
                         provided, defaults to 'bindeb-pkg' (to build binary
                         Debian packages).

Supported TARGETs:
  v6                     Build an ARMv6 32-bit kernel.
  v7                     Build an ARMv7 32-bit kernel.
  v7l                    Build an ARMv7 32-bit LPAE kernel.
  v8                     Build an ARMv8 64-bit kernel.
  <defconfig>            Build a kernel using the provided defconfig.
  <arch>-<flavor>        Build a kernel using the Ubuntu kernel config file.
  <config_file>          Build a kernel using the provided config file.

Optional arguments:
  -a, --arch ARCH        Kernel architecture.
  -b, --abi ABI          Kernel ABI number. If not provided, defaults to 9000.
  -c, --cpus CPUS        Number of CPUs to use for compiling. If not provided,
                         defaults to the number of online CPUs.
  -d, --dry-run
  -g, --dbg-pkg          Enable build of kernel debug package.
  -h, --help             Show this help text and exit.
  -l, --clean            Run 'make clean' before the build.
  -n, --config-only      Only create the kernel config.
  -o, --config CFG:VAL   Set kernel config option CFG to value VAL.
                         Possible values for VAL:
                           e:     Enable option
                           d:     Disable option
                           m:     Turn option into a module
                           u:     Undefine option
                           s=foo: Set option to string 'foo'
                           v=bar: Set option to value bar
  -s, --schroot SCHROOT  Name of the schroot session to run the build in.
  -v, --version VERSION
  -x, --debug            Set -x.
EOF
}

DRY_RUN=0
SCHROOT=

arch=$(dpkg-architecture -q DEB_HOST_ARCH)
abi=9000
cpus=$(getconf _NPROCESSORS_ONLN)
dbg_pkg=0
clean=0
config_only=0
configs=()
version=

target=
args=("bindeb-pkg")

while [ ${#} -gt 0 ] ; do
	case "${1}" in
		-a|--arch)
			shift
			arch=${1}
			;;
		-b|--abi)
			shift
			abi=${1}
			;;
		-c|--cpus)
			shift
			cpus=${1}
			;;
		-d|--dry-run)
			DRY_RUN=1
			;;
		-g|--dbg-pkg)
			dbg_pkg=1
			;;
		-h|--help)
			usage
			exit
			;;
		-l|--clean)
			clean=1
			;;
		-n|--config-only)
			config_only=1
			;;
		-o|--config)
			shift
			configs+=("${1}")
			;;
		-s|--schroot)
			shift
			SCHROOT=${1}
			;;
		-v|--version)
			shift
			version=${1}
			;;
		-x|--debug)
			set -x
			;;
		--)
			shift
			args=("${@}")
			break
			;;
		*)
			if [ -n "${target}" ] ; then
				echo "Invalid argument: ${1}" >&2
				exit 2
			fi
			target=${1}
			;;
	esac
	shift
done

if [ -z "${target}" ] ; then
	usage
	exit 2
fi

config=
subdir=

if [ -e "${target}" ] ; then
	arch=$(sed -n 's,# Linux/,,p' "${target}" | sed 's, .*,,')
	config=${target}
	subdir=${target##*/}
else
	case "${target}" in
		v6)
			arch=arm
			config=bcmrpi_defconfig
			version=v6
			subdir=v6
			;;
		v7)
			arch=arm
			config=bcm2709_defconfig
			version=v7
			subdir=v7
			;;
		v7l)
			arch=arm
			config=bcm2711_defconfig
			version=v7l
			subdir=v7l
			;;
		v8)
			arch=arm64
			config=bcm2711_defconfig
			version=v8
			subdir=v8
			;;
		*defconfig)
			config=${target}
			subdir=${target}
			;;
		*-*)
			arch=${target%%-*}
			flavor=${target#*-}
			config=UBUNTU
			version=${abi}-${flavor}
			subdir=${flavor}
			;;
		*)
			echo "Invalid targt: ${target}" >&2
			exit 2
			;;
	esac
fi

# Debian architecture name
arch=$(debian_arch "${arch}")

# Set environment variables for the build
ARCH=$(kernel_arch "${arch}")
CROSS_COMPILE=$(dpkg-architecture -a "${arch}" -q DEB_HOST_GNU_TYPE \
                2>/dev/null)-
export ARCH CROSS_COMPILE
echo "-- Set ARCH=${ARCH} CROSS_COMPILE=${CROSS_COMPILE}"

# ----------------------------------------------------------------------------
# Initialize the build environment

# Initialize the build directory
buildd=$(pwd)/buildd/${ARCH}/${subdir}
if ! [ -d "${buildd}" ] ; then
	mkdir -p "${buildd}"
fi

# Do some cleaning up first
if [ ${clean} -eq 1 ] ; then
	run make O="${buildd}" clean
fi

# Initialize the build version
if ! [ -e "${buildd}"/.version ] ; then
	echo 1 > "${buildd}"/.version
fi

# ----------------------------------------------------------------------------
# Generate the kernel config file

if [ "${config}" = "UBUNTU" ] ; then
	echo "-- Use Ubuntu config ${arch}-${flavor}"
	#run fakeroot ./debian/rules clean genconfigs || true
	#cp CONFIGS/"${arch}"-config.flavour."${flavor}"
	if [ ${DRY_RUN} -eq 0 ] ; then
		run python3 ./debian/scripts/misc/annotations \
			--arch "${arch}" --flavour "${flavor}" --export > \
			"${buildd}"/.config
	else
		run python3 ./debian/scripts/misc/annotations \
			--arch "${arch}" --flavour "${flavor}" --export \> \
			"${buildd}"/.config
	fi
elif [ -f "${config}" ] ; then
	echo "-- Use config ${config}"
	cp "${config}" "${buildd}"/.config
else
	echo "-- Use config ${ARCH}/${config}"
	run make O="${buildd}" "${config}"
fi

# ----------------------------------------------------------------------------
# Modify the kernel config file

# Disable the build of the debug package
if [ ${dbg_pkg} -eq 0 ] ; then
	echo "-- Disable debug package"
	configs+=("DEBUG_INFO:u")
	configs+=("DEBUG_INFO_NONE:e")
fi

# Purge the local version
configs+=("LOCALVERSION:s=")

# Set/modify additional options
config_cmds=()
for cfg_val in "${configs[@]}" ; do
	cfg=${cfg_val%%:*}
	val=${cfg_val#*:}
	case "${val}" in
		e)   config_cmds+=("-e" "${cfg}") ;;
		d)   config_cmds+=("-d" "${cfg}") ;;
		m)   config_cmds+=("-m" "${cfg}") ;;
		u)   config_cmds+=("-u" "${cfg}") ;;
		s=*) config_cmds+=("--set-str" "${cfg}" "${val#*=}") ;;
		v=*) config_cmds+=("--set-val" "${cfg}" "${val#*=}") ;;
		*)
			echo "-- Ignore invalid config option: ${cfg_val}" >&2
			continue
			;;
	esac
done
if [ ${#config_cmds[@]} -gt 0 ] ; then
	run ./scripts/config --file "${buildd}"/.config "${config_cmds[@]}"
fi
run make O="${buildd}" olddefconfig

if [ ${config_only} -eq 1 ] ; then
	echo
	echo "-- Kernel config written to ${buildd}/.config"
	exit
fi

# ----------------------------------------------------------------------------
# Generate kernel and package versions

kernel_version=$(make -k kernelversion 2>/dev/null)
build_version=$(head -1 "${buildd}"/.version)
#abi_version=$((abi + build_version))
curr_commit=$(git rev-parse HEAD)

# FIXME

#if [ -n "${flavor}" ] ; then
#	local_version=-${abi_version}-${flavor}
#	pkg_version=${kernel_version}-${abi_version}+git${curr_commit::8}
#else
#	if [ -n "${version}" ] ; then
#		local_version=-${version}
#	else
#		local_version=
#	fi
#	pkg_version=${kernel_version}-${build_version}+git${curr_commit::8}
#fi

local_version=${version#-}
if [ -n "${local_version}" ] ; then
	local_version=-${local_version}
fi
pkg_version=${kernel_version}-${build_version}+git${curr_commit::8}

echo "-- Kernel version:  ${kernel_version}${local_version}"
echo "-- Package version: ${pkg_version}"

# ----------------------------------------------------------------------------
# Do the build

if [ "${config}" = "UBUNTU" ] ; then
	# Generate signing and revocation certs
	run fakeroot debian/rules clean
fi

make_opts=(
	"O=${buildd}"
	"LOCALVERSION=${local_version}"
	"KDEB_PKGVERSION=${pkg_version}"
	"-j${cpus}"
	"${args[@]}"
)

run make "${make_opts[@]}" 2>&1 | tee deb-build-kernel.log

echo
echo "-- Debian packages: ${buildd%/*}/linux-*_${pkg_version}_${arch}.*"