path: root/build-test-kernel

#!/bin/bash

set -o nounset
set -o errexit
set -o errtrace

ktest_dir=$(dirname "$(readlink -f "$0")")
KTEST=$ktest_dir/ktest

. "$ktest_dir/lib/libktest.sh"

checkdep gcc
checkdep make

ktest_kernel_source="."	# dir of kernel source
			#       set with: -k <path>
			#       defaults: current directory
ktest_kernel_build=""	# kernel build dir
			# defaults to $ktest_kernel_source/.build-test-kernel-$ARCH
ktest_kernel_binary=""	# kernel output dir
			# defaults to $ktest_kernel_build/kpkg

BUILD=1			# if set to 1, kernel will build
DEPS=1
COVERAGE=""		# doing code coverage?
MAKEARGS=()
ktest_njobs=$(($(grep -c '^processor' /proc/cpuinfo) * 2))
			# number of jobs to passed to make during kernel compile
			#       sets with: -j
			#       defaults to 2 * number of processor


usage()
{
    echo "build-test-kernel: Run generic virtual machine tests"
    echo "Usage: build-test-kernel cmd [options]"
    ktest_usage_cmds
    echo "  oldconfig   Run make oldconfig"
    echo "  config      Run make nconfig"
    echo
    echo "  options:"
    ktest_usage_opts
    echo
    echo " options for build-test-kernel run:"
    ktest_usage_run_opts
    echo "      -k <dir>    kernel source dir"
    echo "      -b <dir>    build directory for kernel (default: kernel_source/.build-test-kernel)"
    echo "      -o <dir>    output directory for kernel binary (default: kernel_build/kpkg"
    echo "      -K          don't rebuild kernel"
    echo "      -D          don't modify kernel .config"
    echo "      -c <dir>    enable coverage for this dir (only valid without -K)"
    echo "      -j <num>    j option to make"
    echo "      -K          don't rebuild kernel"
    echo
    ktest_usage_post
}

if [[ $# = 0 ]]; then
    usage
    exit 1
fi

#parse command and shift for rest of arg parsing
CMD="$1"
shift

while getopts "k:b:o:KDc:j:h${ktest_args}" arg; do
    case $arg in
	k)
	    ktest_kernel_source="$OPTARG"
	    ;;
	b)
	    ktest_kernel_build="$OPTARG"
	    ;;
	o)
	    ktest_kernel_binary="$OPTARG"
	    ;;
	K)
	    BUILD=""
	    ;;
	D)
	    DEPS=""
	    ;;
	c)
	    if [[ ! -d $OPTARG ]]; then
		echo "$OPTARG must be a directory"
		exit 1
	    fi

	    checkdep lcov

	    # Strip trailing / from directory name, substitute _ for /
	    OPTARG=$(echo "${OPTARG%/}"|tr / _)
	    MAKEARGS+=("GCOV_PROFILE_$OPTARG=y")
	    COVERAGE=1
	    ;;
	j)
	    ktest_njobs=$OPTARG
	    ;;

	h)
	    usage
	    exit 0
	    ;;
    esac
    parse_ktest_arg $arg
done
shift $(( OPTIND - 1 ))

# default parameters
[[ -z $ktest_kernel_source ]]	&& ktest_kernel_source="."
[[ -z $ktest_kernel_build ]]	&& ktest_kernel_build="$ktest_kernel_source/.build_test_kernel-$ARCH"
[[ -z $ktest_kernel_binary ]]	&& ktest_kernel_binary="$ktest_kernel_build/kpgk"

if [[ ! -d $ktest_kernel_source ]]; then
    echo "kernel source directory $ktest_kernel_source does not exist"
    exit 1
fi

ktest_kernel_source=$(readlink -e "$ktest_kernel_source")

mkdir -p "$ktest_kernel_build"

ktest_kernel_build=$(readlink -e "$ktest_kernel_build")
ktest_kernel_binary=$(readlink -f "$ktest_kernel_binary")

parse_args_post

if [[ -n $CROSS_COMPILE ]]; then
    checkdep "$ARCH_TRIPLE-gcc" "gcc-$ARCH_TRIPLE"
fi

run_ktest()
{
    arg=$1
    shift

    "$KTEST" "$arg" $KTESTARGS -k "$ktest_kernel_binary" "$@"
}

__do_make()
{
    if [[ -n $CROSS_COMPILE ]]; then
	export ARCH="$KERNEL_ARCH"
	export CROSS_COMPILE="$ARCH_TRIPLE-"
    fi

    if [[ $# = 0 || $1 != nconfig ]]; then
	MAKEARGS+=("--output-sync=target")
    fi

    make --jobs="$ktest_njobs"			\
	--directory="$ktest_kernel_source"    	\
	O="$ktest_kernel_build"			\
	INSTALL_MOD_PATH="$ktest_kernel_binary"	\
	EXTRA_CFLAGS="-g3"			\
	"${MAKEARGS[@]}"			\
	"$@"
}

new_config()
{
    local kconfig="$ktest_kernel_build/.config"
    local config_tool="$ktest_kernel_source/scripts/config"

    __do_make allnoconfig

    # Really undefine everything:
    sed -i -e 's/\(CONFIG_.*\)=.*/# \1 is not set/' "$kconfig"
}

do_make()
{
    if [[ ! -f $ktest_kernel_build/.config ]]; then
	new_config
    fi

    __do_make "$@"
}

kernel_opt()
{
    local cmd=$1
    local opt=$2
    local kconfig="$ktest_kernel_build/.config"
    local config_tool="$ktest_kernel_source/scripts/config"

    if [[ $opt =~ = ]]; then
	local val=${opt: -1}
	opt="${opt%=?}"
    else
	local val=y
    fi

    case $cmd in
	set)
	    "$config_tool" --file "$kconfig" --set-val "$opt" "$val"
	    ;;
	check)
	    local c=$("$config_tool" --file "$kconfig" -s "$opt")

	    if [[ $c != $val ]]; then
		echo "Kernel config option $opt is $c; should be $val"
		exit 1
	    fi
	    ;;
    esac
}

build_kernel()
{
    local magic=$ktest_kernel_binary/ktest-kernel-binary-dir

    if [[ -e $ktest_kernel_binary ]] && [[ ! -d $ktest_kernel_binary ]]; then
	echo "$ktest_kernel_binary already exists and is not a directory"
	exit 1
    fi

    if [[ -d $ktest_kernel_binary ]] && [[ -n $(ls -A $ktest_kernel_binary) ]]; then
	if [[ ! -f $magic ]]; then
	    echo "$ktest_kernel_binary already exists and has non ktest kernel contents"
	    exit 1
	fi

	rm -rf "$ktest_kernel_binary"
    fi

    mkdir -p "$ktest_kernel_binary"
    touch "$magic"

    if [[ -n $DEPS ]]; then
	local kconfig="$ktest_kernel_build/.config"
	local config_tool="$ktest_kernel_source/scripts/config"

	[[ ! -f $kconfig ]] && new_config

	for opt in "${ktest_kernel_config_require[@]}"; do
	    [[ -n $opt ]] && kernel_opt set "$opt"
	done

	if [[ $BITS = 64 ]]; then
	    kernel_opt set 64BIT
	else
	    kernel_opt clear 64BIT
	fi

	#do_make olddefconfig
	do_make oldnoconfig

	for opt in "${ktest_kernel_config_require[@]}"; do
	    [[ -n $opt ]] && kernel_opt check "$opt"
	done
    fi

    do_make

    local BOOT=$ktest_kernel_build/arch/$KERNEL_ARCH/boot

    if   [[ -f "$BOOT/bzImage" ]]; then
	install -m0644 "$BOOT/bzImage"		"$ktest_kernel_binary/vmlinuz"
    elif [[ -f "$BOOT/vmlinux.strip" ]]; then
	install -m0644 "$BOOT/vmlinux.strip"	"$ktest_kernel_binary/vmlinuz"
    else
	install -m0644 "$ktest_kernel_build/vmlinux"	"$ktest_kernel_binary/vmlinuz"
    fi

    install -m0644 "$ktest_kernel_build/vmlinux" "$ktest_kernel_binary/vmlinux"
    install -m0644 "$ktest_kernel_build/.config" "$ktest_kernel_binary/config"

    do_make modules_install
}

cmd_run()
{
    if [[ $# = 0 ]]; then
	echo "build-test-kernel: missing test"
	usage
	exit 1
    fi

    local TEST=$1

    parse_test_deps "$TEST"

    if [[ -n $COVERAGE ]]; then
	ktest_kernel_config_require+=(GCOV_KERNEL)
	ktest_kernel_config_require+=(GCOV_FORMAT_AUTODETECT)
    fi

    if [[ -n $BUILD ]]; then
	run_quiet "building kernel" build_kernel
    fi

    ktest_run "$@"
}

cmd_boot()
{
    cmd_run "$ktest_dir/boot.ktest"
}

cmd_oldconfig()
{
    do_make oldconfig
}

cmd_config()
{
    do_make nconfig
}

cmd_help()
{
    usage
}

if [[ $(type -t "cmd_$CMD") == function ]]; then
    CMD="cmd_$CMD"
elif [[ $(type -t "ktest_$CMD") == function ]]; then
    CMD="ktest_$CMD"
else
    usage
    exit 1
fi

$CMD "$@"