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:
 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             if will_build:
 146                 err_file = self.builder.GetErrFile(commit_upto, brd.target)
 147                 if os.path.exists(err_file) and os.stat(err_file).st_size:
 148                     result.stderr = 'bad'
 149                 elif not force_build:
 150                     # The build passed, so no need to build it again
 151                     will_build = False
 152
 153         if will_build:
 154             # We are going to have to build it. First, get a toolchain
 155             if not self.toolchain:
 156                 try:
 157                     self.toolchain = self.builder.toolchains.Select(brd.arch)
 158                 except ValueError as err:
 159                     result.return_code = 10
 160                     result.stdout = ''
 161                     result.stderr = str(err)
 162                     # TODO(sjg@chromium.org): This gets swallowed, but needs
 163                     # to be reported.
 164
 165             if self.toolchain:
 166                 # Checkout the right commit
 167                 if self.builder.commits:
 168                     commit = self.builder.commits[commit_upto]
 169                     if self.builder.checkout:
 170                         git_dir = os.path.join(work_dir, '.git')
 171                         gitutil.Checkout(commit.hash, git_dir, work_dir,
 172                                          force=True)
 173                 else:
 174                     commit = 'current'
 175
 176                 # Set up the environment and command line
 177                 env = self.toolchain.MakeEnvironment()
 178                 Mkdir(out_dir)
 179                 args = []
 180                 cwd = work_dir
 181                 src_dir = os.path.realpath(work_dir)
 182                 if not self.builder.in_tree:
 183                     if commit_upto is None:
 184                         # In this case we are building in the original source
 185                         # directory (i.e. the current directory where buildman
 186                         # is invoked. The output directory is set to this
 187                         # thread's selected work directory.
 188                         #
 189                         # Symlinks can confuse U-Boot's Makefile since
 190                         # we may use '..' in our path, so remove them.
 191                         work_dir = os.path.realpath(work_dir)
 192                         args.append('O=%s/build' % work_dir)
 193                         cwd = None
 194                         src_dir = os.getcwd()
 195                     else:
 196                         args.append('O=build')
 197                 args.append('-s')
 198                 if self.builder.num_jobs is not None:
 199                     args.extend(['-j', str(self.builder.num_jobs)])
 200                 config_args = ['%s_defconfig' % brd.target]
 201                 config_out = ''
 202                 args.extend(self.builder.toolchains.GetMakeArguments(brd))
 203
 204                 # If we need to reconfigure, do that now
 205                 if do_config:
 206                     result = self.Make(commit, brd, 'mrproper', cwd,
 207                             'mrproper', *args, env=env)
 208                     result = self.Make(commit, brd, 'config', cwd,
 209                             *(args + config_args), env=env)
 210                     config_out = result.combined
 211                     do_config = False   # No need to configure next time
 212                 if result.return_code == 0:
 213                     result = self.Make(commit, brd, 'build', cwd, *args,
 214                             env=env)
 215                 result.stderr = result.stderr.replace(src_dir + '/', '')
 216             else:
 217                 result.return_code = 1
 218                 result.stderr = 'No tool chain for %s\n' % brd.arch
 219             result.already_done = False
 220
 221         result.toolchain = self.toolchain
 222         result.brd = brd
 223         result.commit_upto = commit_upto
 224         result.out_dir = out_dir
 225         return result, do_config
 226
 227     def _WriteResult(self, result, keep_outputs):
 228         """Write a built result to the output directory.
 229
 230         Args:
 231             result: CommandResult object containing result to write
 232             keep_outputs: True to store the output binaries, False
 233                 to delete them
 234         """
 235         # Fatal error
 236         if result.return_code < 0:
 237             return
 238
 239         # Aborted?
 240         if result.stderr and 'No child processes' in result.stderr:
 241             return
 242
 243         if result.already_done:
 244             return
 245
 246         # Write the output and stderr
 247         output_dir = self.builder._GetOutputDir(result.commit_upto)
 248         Mkdir(output_dir)
 249         build_dir = self.builder.GetBuildDir(result.commit_upto,
 250                 result.brd.target)
 251         Mkdir(build_dir)
 252
 253         outfile = os.path.join(build_dir, 'log')
 254         with open(outfile, 'w') as fd:
 255             if result.stdout:
 256                 fd.write(result.stdout)
 257
 258         errfile = self.builder.GetErrFile(result.commit_upto,
 259                 result.brd.target)
 260         if result.stderr:
 261             with open(errfile, 'w') as fd:
 262                 fd.write(result.stderr)
 263         elif os.path.exists(errfile):
 264             os.remove(errfile)
 265
 266         if result.toolchain:
 267             # Write the build result and toolchain information.
 268             done_file = self.builder.GetDoneFile(result.commit_upto,
 269                     result.brd.target)
 270             with open(done_file, 'w') as fd:
 271                 fd.write('%s' % result.return_code)
 272             with open(os.path.join(build_dir, 'toolchain'), 'w') as fd:
 273                 print >>fd, 'gcc', result.toolchain.gcc
 274                 print >>fd, 'path', result.toolchain.path
 275                 print >>fd, 'cross', result.toolchain.cross
 276                 print >>fd, 'arch', result.toolchain.arch
 277                 fd.write('%s' % result.return_code)
 278
 279             with open(os.path.join(build_dir, 'toolchain'), 'w') as fd:
 280                 print >>fd, 'gcc', result.toolchain.gcc
 281                 print >>fd, 'path', result.toolchain.path
 282
 283             # Write out the image and function size information and an objdump
 284             env = result.toolchain.MakeEnvironment()
 285             lines = []
 286             for fname in ['u-boot', 'spl/u-boot-spl']:
 287                 cmd = ['%snm' % self.toolchain.cross, '--size-sort', fname]
 288                 nm_result = command.RunPipe([cmd], capture=True,
 289                         capture_stderr=True, cwd=result.out_dir,
 290                         raise_on_error=False, env=env)
 291                 if nm_result.stdout:
 292                     nm = self.builder.GetFuncSizesFile(result.commit_upto,
 293                                     result.brd.target, fname)
 294                     with open(nm, 'w') as fd:
 295                         print >>fd, nm_result.stdout,
 296
 297                 cmd = ['%sobjdump' % self.toolchain.cross, '-h', fname]
 298                 dump_result = command.RunPipe([cmd], capture=True,
 299                         capture_stderr=True, cwd=result.out_dir,
 300                         raise_on_error=False, env=env)
 301                 rodata_size = ''
 302                 if dump_result.stdout:
 303                     objdump = self.builder.GetObjdumpFile(result.commit_upto,
 304                                     result.brd.target, fname)
 305                     with open(objdump, 'w') as fd:
 306                         print >>fd, dump_result.stdout,
 307                     for line in dump_result.stdout.splitlines():
 308                         fields = line.split()
 309                         if len(fields) > 5 and fields[1] == '.rodata':
 310                             rodata_size = fields[2]
 311
 312                 cmd = ['%ssize' % self.toolchain.cross, fname]
 313                 size_result = command.RunPipe([cmd], capture=True,
 314                         capture_stderr=True, cwd=result.out_dir,
 315                         raise_on_error=False, env=env)
 316                 if size_result.stdout:
 317                     lines.append(size_result.stdout.splitlines()[1] + ' ' +
 318                                  rodata_size)
 319
 320             # Write out the image sizes file. This is similar to the output
 321             # of binutil's 'size' utility, but it omits the header line and
 322             # adds an additional hex value at the end of each line for the
 323             # rodata size
 324             if len(lines):
 325                 sizes = self.builder.GetSizesFile(result.commit_upto,
 326                                 result.brd.target)
 327                 with open(sizes, 'w') as fd:
 328                     print >>fd, '\n'.join(lines)
 329
 330         # Now write the actual build output
 331         if keep_outputs:
 332             patterns = ['u-boot', '*.bin', 'u-boot.dtb', '*.map',
 333                         'include/autoconf.mk', 'spl/u-boot-spl',
 334                         'spl/u-boot-spl.bin']
 335             for pattern in patterns:
 336                 file_list = glob.glob(os.path.join(result.out_dir, pattern))
 337                 for fname in file_list:
 338                     shutil.copy(fname, build_dir)
 339
 340
 341     def RunJob(self, job):
 342         """Run a single job
 343
 344         A job consists of a building a list of commits for a particular board.
 345
 346         Args:
 347             job: Job to build
 348         """
 349         brd = job.board
 350         work_dir = self.builder.GetThreadDir(self.thread_num)
 351         self.toolchain = None
 352         if job.commits:
 353             # Run 'make board_defconfig' on the first commit
 354             do_config = True
 355             commit_upto  = 0
 356             force_build = False
 357             for commit_upto in range(0, len(job.commits), job.step):
 358                 result, request_config = self.RunCommit(commit_upto, brd,
 359                         work_dir, do_config,
 360                         force_build or self.builder.force_build,
 361                         self.builder.force_build_failures)
 362                 failed = result.return_code or result.stderr
 363                 did_config = do_config
 364                 if failed and not do_config:
 365                     # If our incremental build failed, try building again
 366                     # with a reconfig.
 367                     if self.builder.force_config_on_failure:
 368                         result, request_config = self.RunCommit(commit_upto,
 369                             brd, work_dir, True, True, False)
 370                         did_config = True
 371                 if not self.builder.force_reconfig:
 372                     do_config = request_config
 373
 374                 # If we built that commit, then config is done. But if we got
 375                 # an warning, reconfig next time to force it to build the same
 376                 # files that created warnings this time. Otherwise an
 377                 # incremental build may not build the same file, and we will
 378                 # think that the warning has gone away.
 379                 # We could avoid this by using -Werror everywhere...
 380                 # For errors, the problem doesn't happen, since presumably
 381                 # the build stopped and didn't generate output, so will retry
 382                 # that file next time. So we could detect warnings and deal
 383                 # with them specially here. For now, we just reconfigure if
 384                 # anything goes work.
 385                 # Of course this is substantially slower if there are build
 386                 # errors/warnings (e.g. 2-3x slower even if only 10% of builds
 387                 # have problems).
 388                 if (failed and not result.already_done and not did_config and
 389                         self.builder.force_config_on_failure):
 390                     # If this build failed, try the next one with a
 391                     # reconfigure.
 392                     # Sometimes if the board_config.h file changes it can mess
 393                     # with dependencies, and we get:
 394                     # make: *** No rule to make target `include/autoconf.mk',
 395                     #     needed by `depend'.
 396                     do_config = True
 397                     force_build = True
 398                 else:
 399                     force_build = False
 400                     if self.builder.force_config_on_failure:
 401                         if failed:
 402                             do_config = True
 403                     result.commit_upto = commit_upto
 404                     if result.return_code < 0:
 405                         raise ValueError('Interrupt')
 406
 407                 # We have the build results, so output the result
 408                 self._WriteResult(result, job.keep_outputs)
 409                 self.builder.out_queue.put(result)
 410         else:
 411             # Just build the currently checked-out build
 412             result, request_config = self.RunCommit(None, brd, work_dir, True,
 413                         True, self.builder.force_build_failures)
 414             result.commit_upto = 0
 415             self._WriteResult(result, job.keep_outputs)
 416             self.builder.out_queue.put(result)
 417
 418     def run(self):
 419         """Our thread's run function
 420
 421         This thread picks a job from the queue, runs it, and then goes to the
 422         next job.
 423         """
 424         alive = True
 425         while True:
 426             job = self.builder.queue.get()
 427             if self.builder.active and alive:
 428                 self.RunJob(job)
 429             '''
 430             try:
 431                 if self.builder.active and alive:
 432                     self.RunJob(job)
 433             except Exception as err:
 434                 alive = False
 435                 print err
 436             '''
 437             self.builder.queue.task_done()