tools/buildman/builderthread.py

   1 # SPDX-License-Identifier: GPL-2.0+
   2 # Copyright (c) 2014 Google, Inc
   3 #
   4
   5 import errno
   6 import glob
   7 import os
   8 import shutil
   9 import sys
  10 import threading
  11
  12 from buildman import cfgutil
  13 from patman import command
  14 from patman import gitutil
  15
  16 RETURN_CODE_RETRY = -1
  17 BASE_ELF_FILENAMES = ['u-boot', 'spl/u-boot-spl', 'tpl/u-boot-tpl']
  18
  19 def Mkdir(dirname, parents = False):
  20     """Make a directory if it doesn't already exist.
  21
  22     Args:
  23         dirname: Directory to create
  24     """
  25     try:
  26         if parents:
  27             os.makedirs(dirname)
  28         else:
  29             os.mkdir(dirname)
  30     except OSError as err:
  31         if err.errno == errno.EEXIST:
  32             if os.path.realpath('.') == os.path.realpath(dirname):
  33                 print("Cannot create the current working directory '%s'!" % dirname)
  34                 sys.exit(1)
  35             pass
  36         else:
  37             raise
  38
  39 class BuilderJob:
  40     """Holds information about a job to be performed by a thread
  41
  42     Members:
  43         brd: Board object to build
  44         commits: List of Commit objects to build
  45         keep_outputs: True to save build output files
  46         step: 1 to process every commit, n to process every nth commit
  47         work_in_output: Use the output directory as the work directory and
  48             don't write to a separate output directory.
  49     """
  50     def __init__(self):
  51         self.brd = None
  52         self.commits = []
  53         self.keep_outputs = False
  54         self.step = 1
  55         self.work_in_output = False
  56
  57
  58 class ResultThread(threading.Thread):
  59     """This thread processes results from builder threads.
  60
  61     It simply passes the results on to the builder. There is only one
  62     result thread, and this helps to serialise the build output.
  63     """
  64     def __init__(self, builder):
  65         """Set up a new result thread
  66
  67         Args:
  68             builder: Builder which will be sent each result
  69         """
  70         threading.Thread.__init__(self)
  71         self.builder = builder
  72
  73     def run(self):
  74         """Called to start up the result thread.
  75
  76         We collect the next result job and pass it on to the build.
  77         """
  78         while True:
  79             result = self.builder.out_queue.get()
  80             self.builder.ProcessResult(result)
  81             self.builder.out_queue.task_done()
  82
  83
  84 class BuilderThread(threading.Thread):
  85     """This thread builds U-Boot for a particular board.
  86
  87     An input queue provides each new job. We run 'make' to build U-Boot
  88     and then pass the results on to the output queue.
  89
  90     Members:
  91         builder: The builder which contains information we might need
  92         thread_num: Our thread number (0-n-1), used to decide on a
  93             temporary directory. If this is -1 then there are no threads
  94             and we are the (only) main process
  95         mrproper: Use 'make mrproper' before each reconfigure
  96         per_board_out_dir: True to build in a separate persistent directory per
  97             board rather than a thread-specific directory
  98         test_exception: Used for testing; True to raise an exception instead of
  99             reporting the build result
 100     """
 101     def __init__(self, builder, thread_num, mrproper, per_board_out_dir,
 102                  test_exception=False):
 103         """Set up a new builder thread"""
 104         threading.Thread.__init__(self)
 105         self.builder = builder
 106         self.thread_num = thread_num
 107         self.mrproper = mrproper
 108         self.per_board_out_dir = per_board_out_dir
 109         self.test_exception = test_exception
 110
 111     def Make(self, commit, brd, stage, cwd, *args, **kwargs):
 112         """Run 'make' on a particular commit and board.
 113
 114         The source code will already be checked out, so the 'commit'
 115         argument is only for information.
 116
 117         Args:
 118             commit: Commit object that is being built
 119             brd: Board object that is being built
 120             stage: Stage of the build. Valid stages are:
 121                         mrproper - can be called to clean source
 122                         config - called to configure for a board
 123                         build - the main make invocation - it does the build
 124             args: A list of arguments to pass to 'make'
 125             kwargs: A list of keyword arguments to pass to command.run_pipe()
 126
 127         Returns:
 128             CommandResult object
 129         """
 130         return self.builder.do_make(commit, brd, stage, cwd, *args,
 131                 **kwargs)
 132
 133     def RunCommit(self, commit_upto, brd, work_dir, do_config, config_only,
 134                   force_build, force_build_failures, work_in_output,
 135                   adjust_cfg):
 136         """Build a particular commit.
 137
 138         If the build is already done, and we are not forcing a build, we skip
 139         the build and just return the previously-saved results.
 140
 141         Args:
 142             commit_upto: Commit number to build (0...n-1)
 143             brd: Board object to build
 144             work_dir: Directory to which the source will be checked out
 145             do_config: True to run a make <board>_defconfig on the source
 146             config_only: Only configure the source, do not build it
 147             force_build: Force a build even if one was previously done
 148             force_build_failures: Force a bulid if the previous result showed
 149                 failure
 150             work_in_output: Use the output directory as the work directory and
 151                 don't write to a separate output directory.
 152             adjust_cfg (list of str): List of changes to make to .config file
 153                 before building. Each is one of (where C is either CONFIG_xxx
 154                 or just xxx):
 155                      C to enable C
 156                      ~C to disable C
 157                      C=val to set the value of C (val must have quotes if C is
 158                          a string Kconfig
 159
 160         Returns:
 161             tuple containing:
 162                 - CommandResult object containing the results of the build
 163                 - boolean indicating whether 'make config' is still needed
 164         """
 165         # Create a default result - it will be overwritte by the call to
 166         # self.Make() below, in the event that we do a build.
 167         result = command.CommandResult()
 168         result.return_code = 0
 169         if work_in_output or self.builder.in_tree:
 170             out_dir = work_dir
 171         else:
 172             if self.per_board_out_dir:
 173                 out_rel_dir = os.path.join('..', brd.target)
 174             else:
 175                 out_rel_dir = 'build'
 176             out_dir = os.path.join(work_dir, out_rel_dir)
 177
 178         # Check if the job was already completed last time
 179         done_file = self.builder.GetDoneFile(commit_upto, brd.target)
 180         result.already_done = os.path.exists(done_file)
 181         will_build = (force_build or force_build_failures or
 182             not result.already_done)
 183         if result.already_done:
 184             # Get the return code from that build and use it
 185             with open(done_file, 'r') as fd:
 186                 try:
 187                     result.return_code = int(fd.readline())
 188                 except ValueError:
 189                     # The file may be empty due to running out of disk space.
 190                     # Try a rebuild
 191                     result.return_code = RETURN_CODE_RETRY
 192
 193             # Check the signal that the build needs to be retried
 194             if result.return_code == RETURN_CODE_RETRY:
 195                 will_build = True
 196             elif will_build:
 197                 err_file = self.builder.GetErrFile(commit_upto, brd.target)
 198                 if os.path.exists(err_file) and os.stat(err_file).st_size:
 199                     result.stderr = 'bad'
 200                 elif not force_build:
 201                     # The build passed, so no need to build it again
 202                     will_build = False
 203
 204         if will_build:
 205             # We are going to have to build it. First, get a toolchain
 206             if not self.toolchain:
 207                 try:
 208                     self.toolchain = self.builder.toolchains.Select(brd.arch)
 209                 except ValueError as err:
 210                     result.return_code = 10
 211                     result.stdout = ''
 212                     result.stderr = str(err)
 213                     # TODO(sjg@chromium.org): This gets swallowed, but needs
 214                     # to be reported.
 215
 216             if self.toolchain:
 217                 # Checkout the right commit
 218                 if self.builder.commits:
 219                     commit = self.builder.commits[commit_upto]
 220                     if self.builder.checkout:
 221                         git_dir = os.path.join(work_dir, '.git')
 222                         gitutil.checkout(commit.hash, git_dir, work_dir,
 223                                          force=True)
 224                 else:
 225                     commit = 'current'
 226
 227                 # Set up the environment and command line
 228                 env = self.toolchain.MakeEnvironment(self.builder.full_path)
 229                 Mkdir(out_dir)
 230                 args = []
 231                 cwd = work_dir
 232                 src_dir = os.path.realpath(work_dir)
 233                 if not self.builder.in_tree:
 234                     if commit_upto is None:
 235                         # In this case we are building in the original source
 236                         # directory (i.e. the current directory where buildman
 237                         # is invoked. The output directory is set to this
 238                         # thread's selected work directory.
 239                         #
 240                         # Symlinks can confuse U-Boot's Makefile since
 241                         # we may use '..' in our path, so remove them.
 242                         out_dir = os.path.realpath(out_dir)
 243                         args.append('O=%s' % out_dir)
 244                         cwd = None
 245                         src_dir = os.getcwd()
 246                     else:
 247                         args.append('O=%s' % out_rel_dir)
 248                 if self.builder.verbose_build:
 249                     args.append('V=1')
 250                 else:
 251                     args.append('-s')
 252                 if self.builder.num_jobs is not None:
 253                     args.extend(['-j', str(self.builder.num_jobs)])
 254                 if self.builder.warnings_as_errors:
 255                     args.append('KCFLAGS=-Werror')
 256                 if self.builder.allow_missing:
 257                     args.append('BINMAN_ALLOW_MISSING=1')
 258                 if self.builder.no_lto:
 259                     args.append('NO_LTO=1')
 260                 if self.builder.reproducible_builds:
 261                     args.append('SOURCE_DATE_EPOCH=0')
 262                 config_args = ['%s_defconfig' % brd.target]
 263                 config_out = ''
 264                 args.extend(self.builder.toolchains.GetMakeArguments(brd))
 265                 args.extend(self.toolchain.MakeArgs())
 266
 267                 # Remove any output targets. Since we use a build directory that
 268                 # was previously used by another board, it may have produced an
 269                 # SPL image. If we don't remove it (i.e. see do_config and
 270                 # self.mrproper below) then it will appear to be the output of
 271                 # this build, even if it does not produce SPL images.
 272                 build_dir = self.builder.GetBuildDir(commit_upto, brd.target)
 273                 for elf in BASE_ELF_FILENAMES:
 274                     fname = os.path.join(out_dir, elf)
 275                     if os.path.exists(fname):
 276                         os.remove(fname)
 277
 278                 # If we need to reconfigure, do that now
 279                 cfg_file = os.path.join(out_dir, '.config')
 280                 cmd_list = []
 281                 if do_config or adjust_cfg:
 282                     config_out = ''
 283                     if self.mrproper:
 284                         result = self.Make(commit, brd, 'mrproper', cwd,
 285                                 'mrproper', *args, env=env)
 286                         config_out += result.combined
 287                         cmd_list.append([self.builder.gnu_make, 'mrproper',
 288                                          *args])
 289                     result = self.Make(commit, brd, 'config', cwd,
 290                             *(args + config_args), env=env)
 291                     cmd_list.append([self.builder.gnu_make] + args +
 292                                     config_args)
 293                     config_out += result.combined
 294                     do_config = False   # No need to configure next time
 295                     if adjust_cfg:
 296                         cfgutil.adjust_cfg_file(cfg_file, adjust_cfg)
 297                 if result.return_code == 0:
 298                     if config_only:
 299                         args.append('cfg')
 300                     result = self.Make(commit, brd, 'build', cwd, *args,
 301                             env=env)
 302                     cmd_list.append([self.builder.gnu_make] + args)
 303                     if (result.return_code == 2 and
 304                         ('Some images are invalid' in result.stderr)):
 305                         # This is handled later by the check for output in
 306                         # stderr
 307                         result.return_code = 0
 308                     if adjust_cfg:
 309                         errs = cfgutil.check_cfg_file(cfg_file, adjust_cfg)
 310                         if errs:
 311                             result.stderr += errs
 312                             result.return_code = 1
 313                 result.stderr = result.stderr.replace(src_dir + '/', '')
 314                 if self.builder.verbose_build:
 315                     result.stdout = config_out + result.stdout
 316                 result.cmd_list = cmd_list
 317             else:
 318                 result.return_code = 1
 319                 result.stderr = 'No tool chain for %s\n' % brd.arch
 320             result.already_done = False
 321
 322         result.toolchain = self.toolchain
 323         result.brd = brd
 324         result.commit_upto = commit_upto
 325         result.out_dir = out_dir
 326         return result, do_config
 327
 328     def _WriteResult(self, result, keep_outputs, work_in_output):
 329         """Write a built result to the output directory.
 330
 331         Args:
 332             result: CommandResult object containing result to write
 333             keep_outputs: True to store the output binaries, False
 334                 to delete them
 335             work_in_output: Use the output directory as the work directory and
 336                 don't write to a separate output directory.
 337         """
 338         # If we think this might have been aborted with Ctrl-C, record the
 339         # failure but not that we are 'done' with this board. A retry may fix
 340         # it.
 341         maybe_aborted = result.stderr and 'No child processes' in result.stderr
 342
 343         if result.return_code >= 0 and result.already_done:
 344             return
 345
 346         # Write the output and stderr
 347         output_dir = self.builder._GetOutputDir(result.commit_upto)
 348         Mkdir(output_dir)
 349         build_dir = self.builder.GetBuildDir(result.commit_upto,
 350                 result.brd.target)
 351         Mkdir(build_dir)
 352
 353         outfile = os.path.join(build_dir, 'log')
 354         with open(outfile, 'w') as fd:
 355             if result.stdout:
 356                 fd.write(result.stdout)
 357
 358         errfile = self.builder.GetErrFile(result.commit_upto,
 359                 result.brd.target)
 360         if result.stderr:
 361             with open(errfile, 'w') as fd:
 362                 fd.write(result.stderr)
 363         elif os.path.exists(errfile):
 364             os.remove(errfile)
 365
 366         # Fatal error
 367         if result.return_code < 0:
 368             return
 369
 370         if result.toolchain:
 371             # Write the build result and toolchain information.
 372             done_file = self.builder.GetDoneFile(result.commit_upto,
 373                     result.brd.target)
 374             with open(done_file, 'w') as fd:
 375                 if maybe_aborted:
 376                     # Special code to indicate we need to retry
 377                     fd.write('%s' % RETURN_CODE_RETRY)
 378                 else:
 379                     fd.write('%s' % result.return_code)
 380             with open(os.path.join(build_dir, 'toolchain'), 'w') as fd:
 381                 print('gcc', result.toolchain.gcc, file=fd)
 382                 print('path', result.toolchain.path, file=fd)
 383                 print('cross', result.toolchain.cross, file=fd)
 384                 print('arch', result.toolchain.arch, file=fd)
 385                 fd.write('%s' % result.return_code)
 386
 387             # Write out the image and function size information and an objdump
 388             env = result.toolchain.MakeEnvironment(self.builder.full_path)
 389             with open(os.path.join(build_dir, 'out-env'), 'wb') as fd:
 390                 for var in sorted(env.keys()):
 391                     fd.write(b'%s="%s"' % (var, env[var]))
 392
 393             with open(os.path.join(build_dir, 'out-cmd'), 'w',
 394                       encoding='utf-8') as fd:
 395                 for cmd in result.cmd_list:
 396                     print(' '.join(cmd), file=fd)
 397
 398             lines = []
 399             for fname in BASE_ELF_FILENAMES:
 400                 cmd = ['%snm' % self.toolchain.cross, '--size-sort', fname]
 401                 nm_result = command.run_pipe([cmd], capture=True,
 402                         capture_stderr=True, cwd=result.out_dir,
 403                         raise_on_error=False, env=env)
 404                 if nm_result.stdout:
 405                     nm = self.builder.GetFuncSizesFile(result.commit_upto,
 406                                     result.brd.target, fname)
 407                     with open(nm, 'w') as fd:
 408                         print(nm_result.stdout, end=' ', file=fd)
 409
 410                 cmd = ['%sobjdump' % self.toolchain.cross, '-h', fname]
 411                 dump_result = command.run_pipe([cmd], capture=True,
 412                         capture_stderr=True, cwd=result.out_dir,
 413                         raise_on_error=False, env=env)
 414                 rodata_size = ''
 415                 if dump_result.stdout:
 416                     objdump = self.builder.GetObjdumpFile(result.commit_upto,
 417                                     result.brd.target, fname)
 418                     with open(objdump, 'w') as fd:
 419                         print(dump_result.stdout, end=' ', file=fd)
 420                     for line in dump_result.stdout.splitlines():
 421                         fields = line.split()
 422                         if len(fields) > 5 and fields[1] == '.rodata':
 423                             rodata_size = fields[2]
 424
 425                 cmd = ['%ssize' % self.toolchain.cross, fname]
 426                 size_result = command.run_pipe([cmd], capture=True,
 427                         capture_stderr=True, cwd=result.out_dir,
 428                         raise_on_error=False, env=env)
 429                 if size_result.stdout:
 430                     lines.append(size_result.stdout.splitlines()[1] + ' ' +
 431                                  rodata_size)
 432
 433             # Extract the environment from U-Boot and dump it out
 434             cmd = ['%sobjcopy' % self.toolchain.cross, '-O', 'binary',
 435                    '-j', '.rodata.default_environment',
 436                    'env/built-in.o', 'uboot.env']
 437             command.run_pipe([cmd], capture=True,
 438                             capture_stderr=True, cwd=result.out_dir,
 439                             raise_on_error=False, env=env)
 440             ubootenv = os.path.join(result.out_dir, 'uboot.env')
 441             if not work_in_output:
 442                 self.CopyFiles(result.out_dir, build_dir, '', ['uboot.env'])
 443
 444             # Write out the image sizes file. This is similar to the output
 445             # of binutil's 'size' utility, but it omits the header line and
 446             # adds an additional hex value at the end of each line for the
 447             # rodata size
 448             if len(lines):
 449                 sizes = self.builder.GetSizesFile(result.commit_upto,
 450                                 result.brd.target)
 451                 with open(sizes, 'w') as fd:
 452                     print('\n'.join(lines), file=fd)
 453
 454         if not work_in_output:
 455             # Write out the configuration files, with a special case for SPL
 456             for dirname in ['', 'spl', 'tpl']:
 457                 self.CopyFiles(
 458                     result.out_dir, build_dir, dirname,
 459                     ['u-boot.cfg', 'spl/u-boot-spl.cfg', 'tpl/u-boot-tpl.cfg',
 460                      '.config', 'include/autoconf.mk',
 461                      'include/generated/autoconf.h'])
 462
 463             # Now write the actual build output
 464             if keep_outputs:
 465                 self.CopyFiles(
 466                     result.out_dir, build_dir, '',
 467                     ['u-boot*', '*.bin', '*.map', '*.img', 'MLO', 'SPL',
 468                      'include/autoconf.mk', 'spl/u-boot-spl*'])
 469
 470     def CopyFiles(self, out_dir, build_dir, dirname, patterns):
 471         """Copy files from the build directory to the output.
 472
 473         Args:
 474             out_dir: Path to output directory containing the files
 475             build_dir: Place to copy the files
 476             dirname: Source directory, '' for normal U-Boot, 'spl' for SPL
 477             patterns: A list of filenames (strings) to copy, each relative
 478                to the build directory
 479         """
 480         for pattern in patterns:
 481             file_list = glob.glob(os.path.join(out_dir, dirname, pattern))
 482             for fname in file_list:
 483                 target = os.path.basename(fname)
 484                 if dirname:
 485                     base, ext = os.path.splitext(target)
 486                     if ext:
 487                         target = '%s-%s%s' % (base, dirname, ext)
 488                 shutil.copy(fname, os.path.join(build_dir, target))
 489
 490     def _SendResult(self, result):
 491         """Send a result to the builder for processing
 492
 493         Args:
 494             result: CommandResult object containing the results of the build
 495
 496         Raises:
 497             ValueError if self.test_exception is true (for testing)
 498         """
 499         if self.test_exception:
 500             raise ValueError('test exception')
 501         if self.thread_num != -1:
 502             self.builder.out_queue.put(result)
 503         else:
 504             self.builder.ProcessResult(result)
 505
 506     def RunJob(self, job):
 507         """Run a single job
 508
 509         A job consists of a building a list of commits for a particular board.
 510
 511         Args:
 512             job: Job to build
 513
 514         Returns:
 515             List of Result objects
 516         """
 517         brd = job.brd
 518         work_dir = self.builder.GetThreadDir(self.thread_num)
 519         self.toolchain = None
 520         if job.commits:
 521             # Run 'make board_defconfig' on the first commit
 522             do_config = True
 523             commit_upto  = 0
 524             force_build = False
 525             for commit_upto in range(0, len(job.commits), job.step):
 526                 result, request_config = self.RunCommit(commit_upto, brd,
 527                         work_dir, do_config, self.builder.config_only,
 528                         force_build or self.builder.force_build,
 529                         self.builder.force_build_failures,
 530                         job.work_in_output, job.adjust_cfg)
 531                 failed = result.return_code or result.stderr
 532                 did_config = do_config
 533                 if failed and not do_config:
 534                     # If our incremental build failed, try building again
 535                     # with a reconfig.
 536                     if self.builder.force_config_on_failure:
 537                         result, request_config = self.RunCommit(commit_upto,
 538                             brd, work_dir, True, False, True, False,
 539                             job.work_in_output, job.adjust_cfg)
 540                         did_config = True
 541                 if not self.builder.force_reconfig:
 542                     do_config = request_config
 543
 544                 # If we built that commit, then config is done. But if we got
 545                 # an warning, reconfig next time to force it to build the same
 546                 # files that created warnings this time. Otherwise an
 547                 # incremental build may not build the same file, and we will
 548                 # think that the warning has gone away.
 549                 # We could avoid this by using -Werror everywhere...
 550                 # For errors, the problem doesn't happen, since presumably
 551                 # the build stopped and didn't generate output, so will retry
 552                 # that file next time. So we could detect warnings and deal
 553                 # with them specially here. For now, we just reconfigure if
 554                 # anything goes work.
 555                 # Of course this is substantially slower if there are build
 556                 # errors/warnings (e.g. 2-3x slower even if only 10% of builds
 557                 # have problems).
 558                 if (failed and not result.already_done and not did_config and
 559                         self.builder.force_config_on_failure):
 560                     # If this build failed, try the next one with a
 561                     # reconfigure.
 562                     # Sometimes if the board_config.h file changes it can mess
 563                     # with dependencies, and we get:
 564                     # make: *** No rule to make target `include/autoconf.mk',
 565                     #     needed by `depend'.
 566                     do_config = True
 567                     force_build = True
 568                 else:
 569                     force_build = False
 570                     if self.builder.force_config_on_failure:
 571                         if failed:
 572                             do_config = True
 573                     result.commit_upto = commit_upto
 574                     if result.return_code < 0:
 575                         raise ValueError('Interrupt')
 576
 577                 # We have the build results, so output the result
 578                 self._WriteResult(result, job.keep_outputs, job.work_in_output)
 579                 self._SendResult(result)
 580         else:
 581             # Just build the currently checked-out build
 582             result, request_config = self.RunCommit(None, brd, work_dir, True,
 583                         self.builder.config_only, True,
 584                         self.builder.force_build_failures, job.work_in_output,
 585                         job.adjust_cfg)
 586             result.commit_upto = 0
 587             self._WriteResult(result, job.keep_outputs, job.work_in_output)
 588             self._SendResult(result)
 589
 590     def run(self):
 591         """Our thread's run function
 592
 593         This thread picks a job from the queue, runs it, and then goes to the
 594         next job.
 595         """
 596         while True:
 597             job = self.builder.queue.get()
 598             try:
 599                 self.RunJob(job)
 600             except Exception as e:
 601                 print('Thread exception (use -T0 to run without threads):', e)
 602                 self.builder.thread_exceptions.append(e)
 603             self.builder.queue.task_done()