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