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