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