blob: a8599c0bb2a8bde66433aa64878be7af1dfb81c8 [file] [log] [blame]
# SPDX-License-Identifier: GPL-2.0+
# Copyright (c) 2014 Google, Inc
#
"""Implementation the bulider threads
This module provides the BuilderThread class, which handles calling the builder
based on the jobs provided.
"""
import errno
import glob
import io
import os
import shutil
import sys
import threading
from buildman import cfgutil
from patman import gitutil
from u_boot_pylib import command
RETURN_CODE_RETRY = -1
BASE_ELF_FILENAMES = ['u-boot', 'spl/u-boot-spl', 'tpl/u-boot-tpl']
# Common extensions for images
COMMON_EXTS = ['.bin', '.rom', '.itb', '.img']
def mkdir(dirname, parents=False):
"""Make a directory if it doesn't already exist.
Args:
dirname (str): Directory to create
parents (bool): True to also make parent directories
Raises:
OSError: File already exists
"""
try:
if parents:
os.makedirs(dirname)
else:
os.mkdir(dirname)
except OSError as err:
if err.errno == errno.EEXIST:
if os.path.realpath('.') == os.path.realpath(dirname):
print(f"Cannot create the current working directory '{dirname}'!")
sys.exit(1)
else:
raise
def _remove_old_outputs(out_dir):
"""Remove any old output-target files
Args:
out_dir (str): Output directory for the build
Since we use a build directory that was previously used by another
board, it may have produced an SPL image. If we don't remove it (i.e.
see do_config and self.mrproper below) then it will appear to be the
output of this build, even if it does not produce SPL images.
"""
for elf in BASE_ELF_FILENAMES:
fname = os.path.join(out_dir, elf)
if os.path.exists(fname):
os.remove(fname)
def copy_files(out_dir, build_dir, dirname, patterns):
"""Copy files from the build directory to the output.
Args:
out_dir (str): Path to output directory containing the files
build_dir (str): Place to copy the files
dirname (str): Source directory, '' for normal U-Boot, 'spl' for SPL
patterns (list of str): A list of filenames to copy, each relative
to the build directory
"""
for pattern in patterns:
file_list = glob.glob(os.path.join(out_dir, dirname, pattern))
for fname in file_list:
target = os.path.basename(fname)
if dirname:
base, ext = os.path.splitext(target)
if ext:
target = f'{base}-{dirname}{ext}'
shutil.copy(fname, os.path.join(build_dir, target))
# pylint: disable=R0903
class BuilderJob:
"""Holds information about a job to be performed by a thread
Members:
brd: Board object to build
commits: List of Commit objects to build
keep_outputs: True to save build output files
step: 1 to process every commit, n to process every nth commit
work_in_output: Use the output directory as the work directory and
don't write to a separate output directory.
"""
def __init__(self):
self.brd = None
self.commits = []
self.keep_outputs = False
self.step = 1
self.work_in_output = False
class ResultThread(threading.Thread):
"""This thread processes results from builder threads.
It simply passes the results on to the builder. There is only one
result thread, and this helps to serialise the build output.
"""
def __init__(self, builder):
"""Set up a new result thread
Args:
builder: Builder which will be sent each result
"""
threading.Thread.__init__(self)
self.builder = builder
def run(self):
"""Called to start up the result thread.
We collect the next result job and pass it on to the build.
"""
while True:
result = self.builder.out_queue.get()
self.builder.process_result(result)
self.builder.out_queue.task_done()
class BuilderThread(threading.Thread):
"""This thread builds U-Boot for a particular board.
An input queue provides each new job. We run 'make' to build U-Boot
and then pass the results on to the output queue.
Members:
builder: The builder which contains information we might need
thread_num: Our thread number (0-n-1), used to decide on a
temporary directory. If this is -1 then there are no threads
and we are the (only) main process
mrproper: Use 'make mrproper' before each reconfigure
per_board_out_dir: True to build in a separate persistent directory per
board rather than a thread-specific directory
test_exception: Used for testing; True to raise an exception instead of
reporting the build result
"""
def __init__(self, builder, thread_num, mrproper, per_board_out_dir,
test_exception=False):
"""Set up a new builder thread"""
threading.Thread.__init__(self)
self.builder = builder
self.thread_num = thread_num
self.mrproper = mrproper
self.per_board_out_dir = per_board_out_dir
self.test_exception = test_exception
self.toolchain = None
def make(self, commit, brd, stage, cwd, *args, **kwargs):
"""Run 'make' on a particular commit and board.
The source code will already be checked out, so the 'commit'
argument is only for information.
Args:
commit (Commit): Commit that is being built
brd (Board): Board that is being built
stage (str): Stage of the build. Valid stages are:
mrproper - can be called to clean source
config - called to configure for a board
build - the main make invocation - it does the build
cwd (str): Working directory to set, or None to leave it alone
*args (list of str): Arguments to pass to 'make'
**kwargs (dict): A list of keyword arguments to pass to
command.run_pipe()
Returns:
CommandResult object
"""
return self.builder.do_make(commit, brd, stage, cwd, *args,
**kwargs)
def _build_args(self, brd, out_dir, out_rel_dir, work_dir, commit_upto):
"""Set up arguments to the args list based on the settings
Args:
brd (Board): Board to create arguments for
out_dir (str): Path to output directory containing the files
out_rel_dir (str): Output directory relative to the current dir
work_dir (str): Directory to which the source will be checked out
commit_upto (int): Commit number to build (0...n-1)
Returns:
tuple:
list of str: Arguments to pass to make
str: Current working directory, or None if no commit
str: Source directory (typically the work directory)
"""
args = []
cwd = work_dir
src_dir = os.path.realpath(work_dir)
if not self.builder.in_tree:
if commit_upto is None:
# In this case we are building in the original source directory
# (i.e. the current directory where buildman is invoked. The
# output directory is set to this thread's selected work
# directory.
#
# Symlinks can confuse U-Boot's Makefile since we may use '..'
# in our path, so remove them.
real_dir = os.path.realpath(out_dir)
args.append(f'O={real_dir}')
cwd = None
src_dir = os.getcwd()
else:
args.append(f'O={out_rel_dir}')
if self.builder.verbose_build:
args.append('V=1')
else:
args.append('-s')
if self.builder.num_jobs is not None:
args.extend(['-j', str(self.builder.num_jobs)])
if self.builder.warnings_as_errors:
args.append('KCFLAGS=-Werror')
args.append('HOSTCFLAGS=-Werror')
if self.builder.allow_missing:
args.append('BINMAN_ALLOW_MISSING=1')
if self.builder.no_lto:
args.append('NO_LTO=1')
if self.builder.reproducible_builds:
args.append('SOURCE_DATE_EPOCH=0')
args.extend(self.builder.toolchains.GetMakeArguments(brd))
args.extend(self.toolchain.MakeArgs())
return args, cwd, src_dir
def _reconfigure(self, commit, brd, cwd, args, env, config_args, config_out,
cmd_list):
"""Reconfigure the build
Args:
commit (Commit): Commit only being built
brd (Board): Board being built
cwd (str): Current working directory
args (list of str): Arguments to pass to make
env (dict): Environment strings
config_args (list of str): defconfig arg for this board
cmd_list (list of str): List to add the commands to, for logging
Returns:
CommandResult object
"""
if self.mrproper:
result = self.make(commit, brd, 'mrproper', cwd, 'mrproper', *args,
env=env)
config_out.write(result.combined)
cmd_list.append([self.builder.gnu_make, 'mrproper', *args])
result = self.make(commit, brd, 'config', cwd, *(args + config_args),
env=env)
cmd_list.append([self.builder.gnu_make] + args + config_args)
config_out.write(result.combined)
return result
def _build(self, commit, brd, cwd, args, env, cmd_list, config_only):
"""Perform the build
Args:
commit (Commit): Commit only being built
brd (Board): Board being built
cwd (str): Current working directory
args (list of str): Arguments to pass to make
env (dict): Environment strings
cmd_list (list of str): List to add the commands to, for logging
config_only (bool): True if this is a config-only build (using the
'make cfg' target)
Returns:
CommandResult object
"""
if config_only:
args.append('cfg')
result = self.make(commit, brd, 'build', cwd, *args, env=env)
cmd_list.append([self.builder.gnu_make] + args)
if (result.return_code == 2 and
('Some images are invalid' in result.stderr)):
# This is handled later by the check for output in stderr
result.return_code = 0
return result
def _read_done_file(self, commit_upto, brd, force_build,
force_build_failures):
"""Check the 'done' file and see if this commit should be built
Args:
commit (Commit): Commit only being built
brd (Board): Board being built
force_build (bool): Force a build even if one was previously done
force_build_failures (bool): Force a bulid if the previous result
showed failure
Returns:
tuple:
bool: True if build should be built
CommandResult: if there was a previous run:
- already_done set to True
- return_code set to return code
- result.stderr set to 'bad' if stderr output was recorded
"""
result = command.CommandResult()
done_file = self.builder.get_done_file(commit_upto, brd.target)
result.already_done = os.path.exists(done_file)
will_build = (force_build or force_build_failures or
not result.already_done)
if result.already_done:
with open(done_file, 'r', encoding='utf-8') as outf:
try:
result.return_code = int(outf.readline())
except ValueError:
# The file may be empty due to running out of disk space.
# Try a rebuild
result.return_code = RETURN_CODE_RETRY
# Check the signal that the build needs to be retried
if result.return_code == RETURN_CODE_RETRY:
will_build = True
elif will_build:
err_file = self.builder.get_err_file(commit_upto, brd.target)
if os.path.exists(err_file) and os.stat(err_file).st_size:
result.stderr = 'bad'
elif not force_build:
# The build passed, so no need to build it again
will_build = False
return will_build, result
def _decide_dirs(self, brd, work_dir, work_in_output):
"""Decide the output directory to use
Args:
work_dir (str): Directory to which the source will be checked out
work_in_output (bool): Use the output directory as the work
directory and don't write to a separate output directory.
Returns:
tuple:
out_dir (str): Output directory for the build
out_rel_dir (str): Output directory relatie to the current dir
"""
if work_in_output or self.builder.in_tree:
out_rel_dir = None
out_dir = work_dir
else:
if self.per_board_out_dir:
out_rel_dir = os.path.join('..', brd.target)
else:
out_rel_dir = 'build'
out_dir = os.path.join(work_dir, out_rel_dir)
return out_dir, out_rel_dir
def _checkout(self, commit_upto, work_dir):
"""Checkout the right commit
Args:
commit_upto (int): Commit number to build (0...n-1)
work_dir (str): Directory to which the source will be checked out
Returns:
Commit: Commit being built, or 'current' for current source
"""
if self.builder.commits:
commit = self.builder.commits[commit_upto]
if self.builder.checkout:
git_dir = os.path.join(work_dir, '.git')
gitutil.checkout(commit.hash, git_dir, work_dir, force=True)
else:
commit = 'current'
return commit
def _config_and_build(self, commit_upto, brd, work_dir, do_config,
config_only, adjust_cfg, commit, out_dir, out_rel_dir,
result):
"""Do the build, configuring first if necessary
Args:
commit_upto (int): Commit number to build (0...n-1)
brd (Board): Board to create arguments for
work_dir (str): Directory to which the source will be checked out
do_config (bool): True to run a make <board>_defconfig on the source
config_only (bool): Only configure the source, do not build it
adjust_cfg (list of str): See the cfgutil module and run_commit()
commit (Commit): Commit only being built
out_dir (str): Output directory for the build
out_rel_dir (str): Output directory relatie to the current dir
result (CommandResult): Previous result
Returns:
tuple:
result (CommandResult): Result of the build
do_config (bool): indicates whether 'make config' is needed on
the next incremental build
"""
# Set up the environment and command line
env = self.toolchain.MakeEnvironment(self.builder.full_path)
mkdir(out_dir)
args, cwd, src_dir = self._build_args(brd, out_dir, out_rel_dir,
work_dir, commit_upto)
config_args = [f'{brd.target}_defconfig']
config_out = io.StringIO()
_remove_old_outputs(out_dir)
# If we need to reconfigure, do that now
cfg_file = os.path.join(out_dir, '.config')
cmd_list = []
if do_config or adjust_cfg:
result = self._reconfigure(
commit, brd, cwd, args, env, config_args, config_out, cmd_list)
do_config = False # No need to configure next time
if adjust_cfg:
cfgutil.adjust_cfg_file(cfg_file, adjust_cfg)
# Now do the build, if everything looks OK
if result.return_code == 0:
if adjust_cfg:
oldc_args = list(args) + ['oldconfig']
oldc_result = self.make(commit, brd, 'oldconfig', cwd,
*oldc_args, env=env)
if oldc_result.return_code:
return oldc_result
result = self._build(commit, brd, cwd, args, env, cmd_list,
config_only)
if adjust_cfg:
errs = cfgutil.check_cfg_file(cfg_file, adjust_cfg)
if errs:
result.stderr += errs
result.return_code = 1
result.stderr = result.stderr.replace(src_dir + '/', '')
if self.builder.verbose_build:
result.stdout = config_out.getvalue() + result.stdout
result.cmd_list = cmd_list
return result, do_config
def run_commit(self, commit_upto, brd, work_dir, do_config, config_only,
force_build, force_build_failures, work_in_output,
adjust_cfg):
"""Build a particular commit.
If the build is already done, and we are not forcing a build, we skip
the build and just return the previously-saved results.
Args:
commit_upto (int): Commit number to build (0...n-1)
brd (Board): Board to build
work_dir (str): Directory to which the source will be checked out
do_config (bool): True to run a make <board>_defconfig on the source
config_only (bool): Only configure the source, do not build it
force_build (bool): Force a build even if one was previously done
force_build_failures (bool): Force a bulid if the previous result
showed failure
work_in_output (bool) : Use the output directory as the work
directory and don't write to a separate output directory.
adjust_cfg (list of str): List of changes to make to .config file
before building. Each is one of (where C is either CONFIG_xxx
or just xxx):
C to enable C
~C to disable C
C=val to set the value of C (val must have quotes if C is
a string Kconfig
Returns:
tuple containing:
- CommandResult object containing the results of the build
- boolean indicating whether 'make config' is still needed
"""
# Create a default result - it will be overwritte by the call to
# self.make() below, in the event that we do a build.
out_dir, out_rel_dir = self._decide_dirs(brd, work_dir, work_in_output)
# Check if the job was already completed last time
will_build, result = self._read_done_file(commit_upto, brd, force_build,
force_build_failures)
if will_build:
# We are going to have to build it. First, get a toolchain
if not self.toolchain:
try:
self.toolchain = self.builder.toolchains.Select(brd.arch)
except ValueError as err:
result.return_code = 10
result.stdout = ''
result.stderr = f'Tool chain error for {brd.arch}: {str(err)}'
if self.toolchain:
commit = self._checkout(commit_upto, work_dir)
result, do_config = self._config_and_build(
commit_upto, brd, work_dir, do_config, config_only,
adjust_cfg, commit, out_dir, out_rel_dir, result)
result.already_done = False
result.toolchain = self.toolchain
result.brd = brd
result.commit_upto = commit_upto
result.out_dir = out_dir
return result, do_config
def _write_result(self, result, keep_outputs, work_in_output):
"""Write a built result to the output directory.
Args:
result (CommandResult): result to write
keep_outputs (bool): True to store the output binaries, False
to delete them
work_in_output (bool): Use the output directory as the work
directory and don't write to a separate output directory.
"""
# If we think this might have been aborted with Ctrl-C, record the
# failure but not that we are 'done' with this board. A retry may fix
# it.
maybe_aborted = result.stderr and 'No child processes' in result.stderr
if result.return_code >= 0 and result.already_done:
return
# Write the output and stderr
output_dir = self.builder.get_output_dir(result.commit_upto)
mkdir(output_dir)
build_dir = self.builder.get_build_dir(result.commit_upto,
result.brd.target)
mkdir(build_dir)
outfile = os.path.join(build_dir, 'log')
with open(outfile, 'w', encoding='utf-8') as outf:
if result.stdout:
outf.write(result.stdout)
errfile = self.builder.get_err_file(result.commit_upto,
result.brd.target)
if result.stderr:
with open(errfile, 'w', encoding='utf-8') as outf:
outf.write(result.stderr)
elif os.path.exists(errfile):
os.remove(errfile)
# Fatal error
if result.return_code < 0:
return
if result.toolchain:
# Write the build result and toolchain information.
done_file = self.builder.get_done_file(result.commit_upto,
result.brd.target)
with open(done_file, 'w', encoding='utf-8') as outf:
if maybe_aborted:
# Special code to indicate we need to retry
outf.write(f'{RETURN_CODE_RETRY}')
else:
outf.write(f'{result.return_code}')
with open(os.path.join(build_dir, 'toolchain'), 'w',
encoding='utf-8') as outf:
print('gcc', result.toolchain.gcc, file=outf)
print('path', result.toolchain.path, file=outf)
print('cross', result.toolchain.cross, file=outf)
print('arch', result.toolchain.arch, file=outf)
outf.write(f'{result.return_code}')
# Write out the image and function size information and an objdump
env = result.toolchain.MakeEnvironment(self.builder.full_path)
with open(os.path.join(build_dir, 'out-env'), 'wb') as outf:
for var in sorted(env.keys()):
outf.write(b'%s="%s"' % (var, env[var]))
with open(os.path.join(build_dir, 'out-cmd'), 'w',
encoding='utf-8') as outf:
for cmd in result.cmd_list:
print(' '.join(cmd), file=outf)
lines = []
for fname in BASE_ELF_FILENAMES:
cmd = [f'{self.toolchain.cross}nm', '--size-sort', fname]
nm_result = command.run_pipe([cmd], capture=True,
capture_stderr=True, cwd=result.out_dir,
raise_on_error=False, env=env)
if nm_result.stdout:
nm_fname = self.builder.get_func_sizes_file(
result.commit_upto, result.brd.target, fname)
with open(nm_fname, 'w', encoding='utf-8') as outf:
print(nm_result.stdout, end=' ', file=outf)
cmd = [f'{self.toolchain.cross}objdump', '-h', fname]
dump_result = command.run_pipe([cmd], capture=True,
capture_stderr=True, cwd=result.out_dir,
raise_on_error=False, env=env)
rodata_size = ''
if dump_result.stdout:
objdump = self.builder.get_objdump_file(result.commit_upto,
result.brd.target, fname)
with open(objdump, 'w', encoding='utf-8') as outf:
print(dump_result.stdout, end=' ', file=outf)
for line in dump_result.stdout.splitlines():
fields = line.split()
if len(fields) > 5 and fields[1] == '.rodata':
rodata_size = fields[2]
cmd = [f'{self.toolchain.cross}size', fname]
size_result = command.run_pipe([cmd], capture=True,
capture_stderr=True, cwd=result.out_dir,
raise_on_error=False, env=env)
if size_result.stdout:
lines.append(size_result.stdout.splitlines()[1] + ' ' +
rodata_size)
# Extract the environment from U-Boot and dump it out
cmd = [f'{self.toolchain.cross}objcopy', '-O', 'binary',
'-j', '.rodata.default_environment',
'env/built-in.o', 'uboot.env']
command.run_pipe([cmd], capture=True,
capture_stderr=True, cwd=result.out_dir,
raise_on_error=False, env=env)
if not work_in_output:
copy_files(result.out_dir, build_dir, '', ['uboot.env'])
# Write out the image sizes file. This is similar to the output
# of binutil's 'size' utility, but it omits the header line and
# adds an additional hex value at the end of each line for the
# rodata size
if lines:
sizes = self.builder.get_sizes_file(result.commit_upto,
result.brd.target)
with open(sizes, 'w', encoding='utf-8') as outf:
print('\n'.join(lines), file=outf)
if not work_in_output:
# Write out the configuration files, with a special case for SPL
for dirname in ['', 'spl', 'tpl']:
copy_files(
result.out_dir, build_dir, dirname,
['u-boot.cfg', 'spl/u-boot-spl.cfg', 'tpl/u-boot-tpl.cfg',
'.config', 'include/autoconf.mk',
'include/generated/autoconf.h'])
# Now write the actual build output
if keep_outputs:
to_copy = ['u-boot*', '*.map', 'MLO', 'SPL',
'include/autoconf.mk', 'spl/u-boot-spl*',
'tpl/u-boot-tpl*', 'vpl/u-boot-vpl*']
to_copy += [f'*{ext}' for ext in COMMON_EXTS]
copy_files(result.out_dir, build_dir, '', to_copy)
def _send_result(self, result):
"""Send a result to the builder for processing
Args:
result (CommandResult): results of the build
Raises:
ValueError: self.test_exception is true (for testing)
"""
if self.test_exception:
raise ValueError('test exception')
if self.thread_num != -1:
self.builder.out_queue.put(result)
else:
self.builder.process_result(result)
def run_job(self, job):
"""Run a single job
A job consists of a building a list of commits for a particular board.
Args:
job (Job): Job to build
Raises:
ValueError: Thread was interrupted
"""
brd = job.brd
work_dir = self.builder.get_thread_dir(self.thread_num)
self.toolchain = None
if job.commits:
# Run 'make board_defconfig' on the first commit
do_config = True
commit_upto = 0
force_build = False
for commit_upto in range(0, len(job.commits), job.step):
result, request_config = self.run_commit(commit_upto, brd,
work_dir, do_config, self.builder.config_only,
force_build or self.builder.force_build,
self.builder.force_build_failures,
job.work_in_output, job.adjust_cfg)
failed = result.return_code or result.stderr
did_config = do_config
if failed and not do_config:
# If our incremental build failed, try building again
# with a reconfig.
if self.builder.force_config_on_failure:
result, request_config = self.run_commit(commit_upto,
brd, work_dir, True, False, True, False,
job.work_in_output, job.adjust_cfg)
did_config = True
if not self.builder.force_reconfig:
do_config = request_config
# If we built that commit, then config is done. But if we got
# an warning, reconfig next time to force it to build the same
# files that created warnings this time. Otherwise an
# incremental build may not build the same file, and we will
# think that the warning has gone away.
# We could avoid this by using -Werror everywhere...
# For errors, the problem doesn't happen, since presumably
# the build stopped and didn't generate output, so will retry
# that file next time. So we could detect warnings and deal
# with them specially here. For now, we just reconfigure if
# anything goes work.
# Of course this is substantially slower if there are build
# errors/warnings (e.g. 2-3x slower even if only 10% of builds
# have problems).
if (failed and not result.already_done and not did_config and
self.builder.force_config_on_failure):
# If this build failed, try the next one with a
# reconfigure.
# Sometimes if the board_config.h file changes it can mess
# with dependencies, and we get:
# make: *** No rule to make target `include/autoconf.mk',
# needed by `depend'.
do_config = True
force_build = True
else:
force_build = False
if self.builder.force_config_on_failure:
if failed:
do_config = True
result.commit_upto = commit_upto
if result.return_code < 0:
raise ValueError('Interrupt')
# We have the build results, so output the result
self._write_result(result, job.keep_outputs, job.work_in_output)
self._send_result(result)
else:
# Just build the currently checked-out build
result, request_config = self.run_commit(None, brd, work_dir, True,
self.builder.config_only, True,
self.builder.force_build_failures, job.work_in_output,
job.adjust_cfg)
result.commit_upto = 0
self._write_result(result, job.keep_outputs, job.work_in_output)
self._send_result(result)
def run(self):
"""Our thread's run function
This thread picks a job from the queue, runs it, and then goes to the
next job.
"""
while True:
job = self.builder.queue.get()
try:
self.run_job(job)
except Exception as exc:
print('Thread exception (use -T0 to run without threads):',
exc)
self.builder.thread_exceptions.append(exc)
self.builder.queue.task_done()