kunit: tool: add support for QEMU (87c9c163) · Commits · EulixOS / Software / Kernel

tools/testing/kunit/kunit.py

+49 −8

Original line number	Diff line number	Diff line
		@@ -70,7 +70,7 @@ def build_tests(linux: kunit_kernel.LinuxSourceTree,
		kunit_parser.print_with_timestamp('Building KUnit Kernel ...')

		build_start = time.time()
		success = linux.build_um_kernel(request.alltests,
		success = linux.build_kernel(request.alltests,
		request.jobs,
		request.build_dir,
		request.make_options)
		@@ -189,6 +189,31 @@ def add_common_opts(parser) -> None:
		'will get automatically appended.',
		metavar='kunitconfig')

		parser.add_argument('--arch',
		help=('Specifies the architecture to run tests under. '
		'The architecture specified here must match the '
		'string passed to the ARCH make param, '
		'e.g. i386, x86_64, arm, um, etc. Non-UML '
		'architectures run on QEMU.'),
		type=str, default='um', metavar='arch')

		parser.add_argument('--cross_compile',
		help=('Sets make\'s CROSS_COMPILE variable; it should '
		'be set to a toolchain path prefix (the prefix '
		'of gcc and other tools in your toolchain, for '
		'example `sparc64-linux-gnu-` if you have the '
		'sparc toolchain installed on your system, or '
		'`$HOME/toolchains/microblaze/gcc-9.2.0-nolibc/microblaze-linux/bin/microblaze-linux-` '
		'if you have downloaded the microblaze toolchain '
		'from the 0-day website to a directory in your '
		'home directory called `toolchains`).'),
		metavar='cross_compile')

		parser.add_argument('--qemu_config',
		help=('Takes a path to a path to a file containing '
		'a QemuArchParams object.'),
		type=str, metavar='qemu_config')

		def add_build_opts(parser) -> None:
		parser.add_argument('--jobs',
		help='As in the make command, "Specifies the number of '
		@@ -270,7 +295,11 @@ def main(argv, linux=None):
		os.mkdir(cli_args.build_dir)

		if not linux:
		linux = kunit_kernel.LinuxSourceTree(cli_args.build_dir, kunitconfig_path=cli_args.kunitconfig)
		linux = kunit_kernel.LinuxSourceTree(cli_args.build_dir,
		kunitconfig_path=cli_args.kunitconfig,
		arch=cli_args.arch,
		cross_compile=cli_args.cross_compile,
		qemu_config_path=cli_args.qemu_config)

		request = KunitRequest(cli_args.raw_output,
		cli_args.timeout,
		@@ -289,7 +318,11 @@ def main(argv, linux=None):
		os.mkdir(cli_args.build_dir)

		if not linux:
		linux = kunit_kernel.LinuxSourceTree(cli_args.build_dir, kunitconfig_path=cli_args.kunitconfig)
		linux = kunit_kernel.LinuxSourceTree(cli_args.build_dir,
		kunitconfig_path=cli_args.kunitconfig,
		arch=cli_args.arch,
		cross_compile=cli_args.cross_compile,
		qemu_config_path=cli_args.qemu_config)

		request = KunitConfigRequest(cli_args.build_dir,
		cli_args.make_options)
		@@ -301,7 +334,11 @@ def main(argv, linux=None):
		sys.exit(1)
		elif cli_args.subcommand == 'build':
		if not linux:
		linux = kunit_kernel.LinuxSourceTree(cli_args.build_dir, kunitconfig_path=cli_args.kunitconfig)
		linux = kunit_kernel.LinuxSourceTree(cli_args.build_dir,
		kunitconfig_path=cli_args.kunitconfig,
		arch=cli_args.arch,
		cross_compile=cli_args.cross_compile,
		qemu_config_path=cli_args.qemu_config)

		request = KunitBuildRequest(cli_args.jobs,
		cli_args.build_dir,
		@@ -315,7 +352,11 @@ def main(argv, linux=None):
		sys.exit(1)
		elif cli_args.subcommand == 'exec':
		if not linux:
		linux = kunit_kernel.LinuxSourceTree(cli_args.build_dir)
		linux = kunit_kernel.LinuxSourceTree(cli_args.build_dir,
		kunitconfig_path=cli_args.kunitconfig,
		arch=cli_args.arch,
		cross_compile=cli_args.cross_compile,
		qemu_config_path=cli_args.qemu_config)

		exec_request = KunitExecRequest(cli_args.timeout,
		cli_args.build_dir,

tools/testing/kunit/kunit_config.py

+6 −1

Original line number	Diff line number	Diff line
		@@ -52,8 +52,13 @@ class Kconfig(object):
		return False
		return True

		def merge_in_entries(self, other: 'Kconfig') -> None:
		if other.is_subset_of(self):
		return
		self._entries = list(self.entries().union(other.entries()))

		def write_to_file(self, path: str) -> None:
		with open(path, 'w') as f:
		with open(path, 'a+') as f:
		for entry in self.entries():
		f.write(str(entry) + '\n')

tools/testing/kunit/kunit_kernel.py

+148 −27

Original line number	Diff line number	Diff line
		@@ -6,23 +6,31 @@
		# Author: Felix Guo <felixguoxiuping@gmail.com>
		# Author: Brendan Higgins <brendanhiggins@google.com>

		from __future__ import annotations
		import importlib.util
		import logging
		import subprocess
		import os
		import shutil
		import signal
		from typing import Iterator
		from typing import Optional

		from contextlib import ExitStack

		from collections import namedtuple

		import kunit_config
		import kunit_parser
		import qemu_config

		KCONFIG_PATH = '.config'
		KUNITCONFIG_PATH = '.kunitconfig'
		DEFAULT_KUNITCONFIG_PATH = 'arch/um/configs/kunit_defconfig'
		BROKEN_ALLCONFIG_PATH = 'tools/testing/kunit/configs/broken_on_uml.config'
		OUTFILE_PATH = 'test.log'
		ABS_TOOL_PATH = os.path.abspath(os.path.dirname(__file__))
		QEMU_CONFIGS_DIR = os.path.join(ABS_TOOL_PATH, 'qemu_configs')

		def get_file_path(build_dir, default):
		if build_dir:
		@@ -40,6 +48,10 @@ class BuildError(Exception):
		class LinuxSourceTreeOperations(object):
		"""An abstraction over command line operations performed on a source tree."""

		def __init__(self, linux_arch: str, cross_compile: Optional[str]):
		self._linux_arch = linux_arch
		self._cross_compile = cross_compile

		def make_mrproper(self) -> None:
		try:
		subprocess.check_output(['make', 'mrproper'], stderr=subprocess.STDOUT)
		@@ -48,12 +60,21 @@ class LinuxSourceTreeOperations(object):
		except subprocess.CalledProcessError as e:
		raise ConfigError(e.output.decode())

		def make_arch_qemuconfig(self, kconfig: kunit_config.Kconfig) -> None:
		pass

		def make_allyesconfig(self, build_dir, make_options) -> None:
		raise ConfigError('Only the "um" arch is supported for alltests')

		def make_olddefconfig(self, build_dir, make_options) -> None:
		command = ['make', 'ARCH=um', 'olddefconfig']
		command = ['make', 'ARCH=' + self._linux_arch, 'olddefconfig']
		if self._cross_compile:
		command += ['CROSS_COMPILE=' + self._cross_compile]
		if make_options:
		command.extend(make_options)
		if build_dir:
		command += ['O=' + build_dir]
		print('Populating config with:\n$', ' '.join(command))
		try:
		subprocess.check_output(command, stderr=subprocess.STDOUT)
		except OSError as e:
		@@ -61,6 +82,79 @@ class LinuxSourceTreeOperations(object):
		except subprocess.CalledProcessError as e:
		raise ConfigError(e.output.decode())

		def make(self, jobs, build_dir, make_options) -> None:
		command = ['make', 'ARCH=' + self._linux_arch, '--jobs=' + str(jobs)]
		if make_options:
		command.extend(make_options)
		if self._cross_compile:
		command += ['CROSS_COMPILE=' + self._cross_compile]
		if build_dir:
		command += ['O=' + build_dir]
		print('Building with:\n$', ' '.join(command))
		try:
		proc = subprocess.Popen(command,
		stderr=subprocess.PIPE,
		stdout=subprocess.DEVNULL)
		except OSError as e:
		raise BuildError('Could not call execute make: ' + str(e))
		except subprocess.CalledProcessError as e:
		raise BuildError(e.output)
		_, stderr = proc.communicate()
		if proc.returncode != 0:
		raise BuildError(stderr.decode())
		if stderr: # likely only due to build warnings
		print(stderr.decode())

		def run(self, params, timeout, build_dir, outfile) -> None:
		pass


		class LinuxSourceTreeOperationsQemu(LinuxSourceTreeOperations):

		def __init__(self, qemu_arch_params: qemu_config.QemuArchParams, cross_compile: Optional[str]):
		super().__init__(linux_arch=qemu_arch_params.linux_arch,
		cross_compile=cross_compile)
		self._kconfig = qemu_arch_params.kconfig
		self._qemu_arch = qemu_arch_params.qemu_arch
		self._kernel_path = qemu_arch_params.kernel_path
		self._kernel_command_line = qemu_arch_params.kernel_command_line + ' kunit_shutdown=reboot'
		self._extra_qemu_params = qemu_arch_params.extra_qemu_params

		def make_arch_qemuconfig(self, base_kunitconfig: kunit_config.Kconfig) -> None:
		kconfig = kunit_config.Kconfig()
		kconfig.parse_from_string(self._kconfig)
		base_kunitconfig.merge_in_entries(kconfig)

		def run(self, params, timeout, build_dir, outfile):
		kernel_path = os.path.join(build_dir, self._kernel_path)
		qemu_command = ['qemu-system-' + self._qemu_arch,
		'-nodefaults',
		'-m', '1024',
		'-kernel', kernel_path,
		'-append', '\'' + ' '.join(params + [self._kernel_command_line]) + '\'',
		'-no-reboot',
		'-nographic',
		'-serial stdio'] + self._extra_qemu_params
		print('Running tests with:\n$', ' '.join(qemu_command))
		with open(outfile, 'w') as output:
		process = subprocess.Popen(' '.join(qemu_command),
		stdin=subprocess.PIPE,
		stdout=output,
		stderr=subprocess.STDOUT,
		text=True, shell=True)
		try:
		process.wait(timeout=timeout)
		except Exception as e:
		print(e)
		process.terminate()
		return process

		class LinuxSourceTreeOperationsUml(LinuxSourceTreeOperations):
		"""An abstraction over command line operations performed on a source tree."""

		def __init__(self, cross_compile=None):
		super().__init__(linux_arch='um', cross_compile=cross_compile)

		def make_allyesconfig(self, build_dir, make_options) -> None:
		kunit_parser.print_with_timestamp(
		'Enabling all CONFIGs for UML...')
		@@ -83,32 +177,16 @@ class LinuxSourceTreeOperations(object):
		kunit_parser.print_with_timestamp(
		'Starting Kernel with all configs takes a few minutes...')

		def make(self, jobs, build_dir, make_options) -> None:
		command = ['make', 'ARCH=um', '--jobs=' + str(jobs)]
		if make_options:
		command.extend(make_options)
		if build_dir:
		command += ['O=' + build_dir]
		try:
		proc = subprocess.Popen(command,
		stderr=subprocess.PIPE,
		stdout=subprocess.DEVNULL)
		except OSError as e:
		raise BuildError('Could not call make command: ' + str(e))
		_, stderr = proc.communicate()
		if proc.returncode != 0:
		raise BuildError(stderr.decode())
		if stderr: # likely only due to build warnings
		print(stderr.decode())

		def linux_bin(self, params, timeout, build_dir) -> None:
		def run(self, params, timeout, build_dir, outfile):
		"""Runs the Linux UML binary. Must be named 'linux'."""
		linux_bin = get_file_path(build_dir, 'linux')
		outfile = get_outfile_path(build_dir)
		with open(outfile, 'w') as output:
		process = subprocess.Popen([linux_bin] + params,
		stdin=subprocess.PIPE,
		stdout=output,
		stderr=subprocess.STDOUT)
		stderr=subprocess.STDOUT,
		text=True)
		process.wait(timeout)

		def get_kconfig_path(build_dir) -> str:
		@@ -120,13 +198,54 @@ def get_kunitconfig_path(build_dir) -> str:
		def get_outfile_path(build_dir) -> str:
		return get_file_path(build_dir, OUTFILE_PATH)

		def get_source_tree_ops(arch: str, cross_compile: Optional[str]) -> LinuxSourceTreeOperations:
		config_path = os.path.join(QEMU_CONFIGS_DIR, arch + '.py')
		if arch == 'um':
		return LinuxSourceTreeOperationsUml(cross_compile=cross_compile)
		elif os.path.isfile(config_path):
		return get_source_tree_ops_from_qemu_config(config_path, cross_compile)[1]
		else:
		raise ConfigError(arch + ' is not a valid arch')

		def get_source_tree_ops_from_qemu_config(config_path: str,
		cross_compile: Optional[str]) -> tuple[
		str, LinuxSourceTreeOperations]:
		# The module name/path has very little to do with where the actual file
		# exists (I learned this through experimentation and could not find it
		# anywhere in the Python documentation).
		#
		# Bascially, we completely ignore the actual file location of the config
		# we are loading and just tell Python that the module lives in the
		# QEMU_CONFIGS_DIR for import purposes regardless of where it actually
		# exists as a file.
		module_path = '.' + os.path.join(os.path.basename(QEMU_CONFIGS_DIR), os.path.basename(config_path))
		spec = importlib.util.spec_from_file_location(module_path, config_path)
		config = importlib.util.module_from_spec(spec)
		# TODO(brendanhiggins@google.com): I looked this up and apparently other
		# Python projects have noted that pytype complains that "No attribute
		# 'exec_module' on _importlib_modulespec._Loader". Disabling for now.
		spec.loader.exec_module(config) # pytype: disable=attribute-error
		return config.QEMU_ARCH.linux_arch, LinuxSourceTreeOperationsQemu(
		config.QEMU_ARCH, cross_compile=cross_compile)

		class LinuxSourceTree(object):
		"""Represents a Linux kernel source tree with KUnit tests."""

		def __init__(self, build_dir: str, load_config=True, kunitconfig_path='') -> None:
		def __init__(
		self,
		build_dir: str,
		load_config=True,
		kunitconfig_path='',
		arch=None,
		cross_compile=None,
		qemu_config_path=None) -> None:
		signal.signal(signal.SIGINT, self.signal_handler)

		self._ops = LinuxSourceTreeOperations()
		if qemu_config_path:
		self._arch, self._ops = get_source_tree_ops_from_qemu_config(
		qemu_config_path, cross_compile)
		else:
		self._arch = 'um' if arch is None else arch
		self._ops = get_source_tree_ops(self._arch, cross_compile)

		if not load_config:
		return
		@@ -170,8 +289,9 @@ class LinuxSourceTree(object):
		kconfig_path = get_kconfig_path(build_dir)
		if build_dir and not os.path.exists(build_dir):
		os.mkdir(build_dir)
		self._kconfig.write_to_file(kconfig_path)
		try:
		self._ops.make_arch_qemuconfig(self._kconfig)
		self._kconfig.write_to_file(kconfig_path)
		self._ops.make_olddefconfig(build_dir, make_options)
		except ConfigError as e:
		logging.error(e)
		@@ -184,6 +304,7 @@ class LinuxSourceTree(object):
		if os.path.exists(kconfig_path):
		existing_kconfig = kunit_config.Kconfig()
		existing_kconfig.read_from_file(kconfig_path)
		self._ops.make_arch_qemuconfig(self._kconfig)
		if not self._kconfig.is_subset_of(existing_kconfig):
		print('Regenerating .config ...')
		os.remove(kconfig_path)
		@@ -194,7 +315,7 @@ class LinuxSourceTree(object):
		print('Generating .config ...')
		return self.build_config(build_dir, make_options)

		def build_um_kernel(self, alltests, jobs, build_dir, make_options) -> bool:
		def build_kernel(self, alltests, jobs, build_dir, make_options) -> bool:
		try:
		if alltests:
		self._ops.make_allyesconfig(build_dir, make_options)
		@@ -211,8 +332,8 @@ class LinuxSourceTree(object):
		args.extend(['mem=1G', 'console=tty', 'kunit_shutdown=halt'])
		if filter_glob:
		args.append('kunit.filter_glob='+filter_glob)
		self._ops.linux_bin(args, timeout, build_dir)
		outfile = get_outfile_path(build_dir)
		self._ops.run(args, timeout, build_dir, outfile)
		subprocess.call(['stty', 'sane'])
		with open(outfile, 'r') as file:
		for line in file:

tools/testing/kunit/kunit_tool_test.py

+13 −5

Original line number	Diff line number	Diff line
		@@ -303,7 +303,7 @@ class KUnitMainTest(unittest.TestCase):

		self.linux_source_mock = mock.Mock()
		self.linux_source_mock.build_reconfig = mock.Mock(return_value=True)
		self.linux_source_mock.build_um_kernel = mock.Mock(return_value=True)
		self.linux_source_mock.build_kernel = mock.Mock(return_value=True)
		self.linux_source_mock.run_kernel = mock.Mock(return_value=all_passed_log)

		def test_config_passes_args_pass(self):
		@@ -314,7 +314,7 @@ class KUnitMainTest(unittest.TestCase):
		def test_build_passes_args_pass(self):
		kunit.main(['build'], self.linux_source_mock)
		self.assertEqual(self.linux_source_mock.build_reconfig.call_count, 0)
		self.linux_source_mock.build_um_kernel.assert_called_once_with(False, 8, '.kunit', None)
		self.linux_source_mock.build_kernel.assert_called_once_with(False, 8, '.kunit', None)
		self.assertEqual(self.linux_source_mock.run_kernel.call_count, 0)

		def test_exec_passes_args_pass(self):
		@@ -396,7 +396,7 @@ class KUnitMainTest(unittest.TestCase):
		def test_build_builddir(self):
		build_dir = '.kunit'
		kunit.main(['build', '--build_dir', build_dir], self.linux_source_mock)
		self.linux_source_mock.build_um_kernel.assert_called_once_with(False, 8, build_dir, None)
		self.linux_source_mock.build_kernel.assert_called_once_with(False, 8, build_dir, None)

		def test_exec_builddir(self):
		build_dir = '.kunit'
		@@ -410,14 +410,22 @@ class KUnitMainTest(unittest.TestCase):
		mock_linux_init.return_value = self.linux_source_mock
		kunit.main(['run', '--kunitconfig=mykunitconfig'])
		# Just verify that we parsed and initialized it correctly here.
		mock_linux_init.assert_called_once_with('.kunit', kunitconfig_path='mykunitconfig')
		mock_linux_init.assert_called_once_with('.kunit',
		kunitconfig_path='mykunitconfig',
		arch='um',
		cross_compile=None,
		qemu_config_path=None)

		@mock.patch.object(kunit_kernel, 'LinuxSourceTree')
		def test_config_kunitconfig(self, mock_linux_init):
		mock_linux_init.return_value = self.linux_source_mock
		kunit.main(['config', '--kunitconfig=mykunitconfig'])
		# Just verify that we parsed and initialized it correctly here.
		mock_linux_init.assert_called_once_with('.kunit', kunitconfig_path='mykunitconfig')
		mock_linux_init.assert_called_once_with('.kunit',
		kunitconfig_path='mykunitconfig',
		arch='um',
		cross_compile=None,
		qemu_config_path=None)

		if __name__ == '__main__':
		unittest.main()

tools/testing/kunit/qemu_config.py

0 → 100644

+16 −0

Original line number	Diff line number	Diff line
		# SPDX-License-Identifier: GPL-2.0
		#
		# Collection of configs for building non-UML kernels and running them on QEMU.
		#
		# Copyright (C) 2021, Google LLC.
		# Author: Brendan Higgins <brendanhiggins@google.com>

		from collections import namedtuple


		QemuArchParams = namedtuple('QemuArchParams', ['linux_arch',
		'kconfig',
		'qemu_arch',
		'kernel_path',
		'kernel_command_line',
		'extra_qemu_params'])