kernel: configure: Pass arch as an extra argument

[ipfire-3.x.git] / kernel / scripts / configure

#!/bin/bash
###############################################################################
# IPFire.org    - An Open Source Firewall Solution                            #
# Copyright (C) - IPFire Development Team <info@ipfire.org>                   #
###############################################################################

BASEDIR=$(dirname ${0})
SCRIPTS_DIR=${BASEDIR}

# x86_64
CONFIGS="x86_64:default"

# aarch64
CONFIGS="${CONFIGS} aarch64:default"

# armv7hl
CONFIGS="${CONFIGS} armv7hl:default"

PLATFORMS="x86 arm"
declare -A SUBPLATFORMS
SUBPLATFORMS=(
	[arm]="arm64 arm32"
)

search_kernel_dir() {
	local dir
	for dir in /builddir/source/linux-*; do
		if [ -d "${dir}" ]; then
			echo "${dir}"
			break
		fi
	done
}

function get_platform() {
	local arch="${1}"

	case "${arch}" in
		aarch64|arm*)
			echo "arm"
			;;
		x86_64|i?86)
			echo "x86"
			;;
		*)
			return 1
			;;
	esac
}

function get_subplatform() {
	local arch="${1}"

	case "${arch}" in
		aarch64)
			echo "arm64"
			;;
		arm*)
			echo "arm32"
			;;
		*)
			return 1
			;;
	esac
}

function get_kernel_arch() {
	local arch="${1}"

	case "${arch}" in
		aarch64)
			echo "arm64"
			;;
		arm*)
			echo "arm"
			;;
		x86_64)
			echo "x86"
			;;
	esac
}

function merge_config() {
	local arch=${1}
	local flavour=${2}
	local output=${3}
	shift 3

	local arg
	for arg in arch flavour output; do
		if [ -z "${!arg}" ]; then
			echo >&2 "merge usage: <arch> <flavour> <output filename>"
			exit 2
		fi
	done

	local config_mode="olddefconfig"
	local extra_configs
	while [ $# -gt 0 ]; do
		case "${1}" in
			--mode=*)
				config_mode=${1#--mode=}
				shift
				;;
			-*)
				echo >&2 "Unknown option: ${1}"
				;;
			*)
				extra_configs="${extra_configs} ${1}"
				;;
		esac
		shift
	done

	local configs="${extra_configs} config-generic"

	case "${arch}:${flavour}" in
		# x86
		x86_64:default)
			configs="${configs} config-x86-generic"
			;;

		# ARM64
		aarch64:default)
			configs="${configs} config-arm-generic config-arm64-generic"
			;;

		# ARM
		armv7hl:default)
			configs="${configs} config-arm-generic config-arm32-generic"
			;;
		*)
			echo >&2 "ERROR: Invalid parameters given: $@"
			return 1
			;;
	esac

	# Merge the configuration files from its elementary configuration
	# files.
	local tmp_out=$(mktemp)
	local tmp_in=$(mktemp)

	local config
	for config in ${configs}; do
		cat ${tmp_out} > ${tmp_in}
		perl ${SCRIPTS_DIR}/merge.pl \
			${tmp_in} ${config} > ${tmp_out}
	done

	if [ "${config_mode}" != "none" ]; then
		echo "Running 'make olddefconfig' for ${arch} (${flavour})..."
		local kernel_arch="$(get_kernel_arch "${arch}")"
		(
			cd ${KERNEL_DIR}
			cat ${tmp_out} > .config
			make ARCH="${kernel_arch}" ${config_mode}
			cat .config > ${tmp_out}
		)
	fi

	cat ${tmp_out} > ${output}
	rm -f ${tmp_in} ${tmp_out}
}

# This function runs an interactive "make oldconfig".
function make_config() {
	local action="${1}"
	local arch="${2}"

	# Default to x86_64 when no arch is given
	if [ -z "${arch}" ]; then
		arch="x86_64"
	fi

	# Detect kernel arch
	local kernel_arch="$(get_kernel_arch "${arch}")"
	local flavour="default"

	local config_in=$(mktemp)
	local config_out=$(mktemp)
	local diff_out=$(mktemp)

	merge_config ${arch} ${flavour} ${config_in} --mode=none

	(
		pushd ${KERNEL_DIR}
		cat ${config_in} > .config

		echo "You may now edit the configuration..."
		make ARCH=${kernel_arch} "${action}"

		cat .config > ${config_out}
		popd
	)

	${SCRIPTS_DIR}/configdiff.py ${config_in} ${config_out} > ${diff_out}

	# Update the rest of the configurations.
	diff_configs ${diff_out} --mode=oldconfig

	rm -f ${config_in} ${config_out} ${diff_out}
}

# config-generic
#  Intersection of all files.
# config-x86-x86_64
#  Diff against merge of (config-generic and config-x86-generic).

function diff_configs() {
	local extra_configs="$@"

	local filename
	local platform
	local subplatform

	declare -A platform_configs
	declare -A subplatform_configs

	tmpdir=$(mktemp -d)

	for config in ${CONFIGS}; do
		arch=${config%:*}
		flavour=${config#*:}

		filename=${tmpdir}/config-${arch}-${flavour}

		merge_config ${arch} ${flavour} ${filename} ${extra_configs}

		platform="$(get_platform "${arch}")"
		subplatform="$(get_subplatform "${arch}")"

		if [ -n "${subplatform}" ]; then
			subplatform_configs[${subplatform}]="${subplatform_configs[${subplatform}]} ${filename}"
		else
			platform_configs[${platform}]="${platform_configs[${platform}]} ${filename}"
		fi
	done

	local common_configs
	for platform in ${PLATFORMS}; do
		for subplatform in ${SUBPLATFORMS[${platform}]}; do
			filename="${tmpdir}/config-${subplatform}-common"
			${SCRIPTS_DIR}/configcommon.py ${subplatform_configs[${subplatform}]} \
				> ${filename}

			platform_configs[${platform}]="${platform_configs[${platform}]} ${filename}"
		done

		filename="${tmpdir}/config-${platform}-common"
		${SCRIPTS_DIR}/configcommon.py ${platform_configs[${platform}]} \
			> ${filename}

		common_configs="${common_configs} ${filename}"
	done

	${SCRIPTS_DIR}/configcommon.py ${common_configs} > ${tmpdir}/config-generic

	for platform in ${PLATFORMS}; do
		for subplatform in ${SUBPLATFORMS[${platform}]}; do
			${SCRIPTS_DIR}/configdiff.py \
				${tmpdir}/config-${platform}-common \
				${tmpdir}/config-${subplatform}-common \
				> ${tmpdir}/config-${subplatform}-generic
		done

		${SCRIPTS_DIR}/configdiff.py \
			${tmpdir}/config-generic \
			${tmpdir}/config-${platform}-common \
			> ${tmpdir}/config-${platform}-generic
	done

	for config in ${CONFIGS}; do
		arch=${config%:*}
		flavour=${config#*:}

		filename=${tmpdir}/config-${arch}-${flavour}

		case "${config}" in
			aarch64:default|armv7hl:default|x86_64:default)
				# Virtual configuration
				rm -f ${filename}
				continue
				;;
			*)
				platform="$(get_subplatform "${arch}" || get_platform "${arch}")"
				${SCRIPTS_DIR}/configdiff.py ${tmpdir}/config-${platform}-common \
					${filename} > ${filename}.tmp
				;;
		esac
		mv ${filename}{.tmp,}
	done
	rm -f ${tmpdir}/config-*-common

	for config in ${tmpdir}/*; do
		if ! cmp $(basename ${config}) ${config} &>/dev/null; then
			echo "$(basename ${config}) has changed."
		fi
		cat ${config} > $(basename ${config})
	done

	rm -rf ${tmpdir}
}

KERNEL_DIR="$(search_kernel_dir)"

# Parse commandline.
while [ $# -gt 0 ]; do
	arg=${1}; shift
	case "${arg}" in
		help|"")
			echo "${0} - available commands:"
			echo "    * merge <arch> <flavour> <output filename>"
			echo "    * menuconfig"
			echo "    * oldconfig"
			echo "    * olddefconfig"
			exit 0
			;;
		listnewconfig|menuconfig|merge|oldconfig|olddefconfig)
			action=${arg}
			break
			;;
	esac
done

if [ -z "${KERNEL_DIR}" ]; then
	echo >&2 "KERNEL_DIR was not set!"
	exit 2
fi

if [ -z "${action}" ]; then
	echo >&2 "No action given... Try ${0} help."
	exit 2
fi

case "${action}" in
	merge)
		merge_config $@
		exit $?
		;;
	listnewconfig|menuconfig|oldconfig|olddefconfig)
		make_config "${action}" "$@"
		exit $?
		;;
esac

exit 1