git.sur5r.net Git - u-boot/blob - tools/buildman/builderthread.py

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