1 # Copyright (c) 2014 Google, Inc
3 # SPDX-License-Identifier: GPL-2.0+
15 RETURN_CODE_RETRY = -1
17 def Mkdir(dirname, parents = False):
18 """Make a directory if it doesn't already exist.
21 dirname: Directory to create
28 except OSError as err:
29 if err.errno == errno.EEXIST:
35 """Holds information about a job to be performed by a thread
38 board: Board object to build
39 commits: List of commit options to build.
46 class ResultThread(threading.Thread):
47 """This thread processes results from builder threads.
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.
52 def __init__(self, builder):
53 """Set up a new result thread
56 builder: Builder which will be sent each result
58 threading.Thread.__init__(self)
59 self.builder = builder
62 """Called to start up the result thread.
64 We collect the next result job and pass it on to the build.
67 result = self.builder.out_queue.get()
68 self.builder.ProcessResult(result)
69 self.builder.out_queue.task_done()
72 class BuilderThread(threading.Thread):
73 """This thread builds U-Boot for a particular board.
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.
79 builder: The builder which contains information we might need
80 thread_num: Our thread number (0-n-1), used to decide on a
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
91 def Make(self, commit, brd, stage, cwd, *args, **kwargs):
92 """Run 'make' on a particular commit and board.
94 The source code will already be checked out, so the 'commit'
95 argument is only for information.
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()
110 return self.builder.do_make(commit, brd, stage, cwd, *args,
113 def RunCommit(self, commit_upto, brd, work_dir, do_config, force_build,
114 force_build_failures):
115 """Build a particular commit.
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.
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
131 - CommandResult object containing the results of the build
132 - boolean indicating whether 'make config' is still needed
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:
141 if self.per_board_out_dir:
142 out_rel_dir = os.path.join('..', brd.target)
144 out_rel_dir = 'build'
145 out_dir = os.path.join(work_dir, out_rel_dir)
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())
157 # Check the signal that the build needs to be retried
158 if result.return_code == RETURN_CODE_RETRY:
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
169 # We are going to have to build it. First, get a toolchain
170 if not self.toolchain:
172 self.toolchain = self.builder.toolchains.Select(brd.arch)
173 except ValueError as err:
174 result.return_code = 10
176 result.stderr = str(err)
177 # TODO(sjg@chromium.org): This gets swallowed, but needs
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,
191 # Set up the environment and command line
192 env = self.toolchain.MakeEnvironment(self.builder.full_path)
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.
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)
209 src_dir = os.getcwd()
211 args.append('O=%s' % out_rel_dir)
212 if self.builder.verbose_build:
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]
220 args.extend(self.builder.toolchains.GetMakeArguments(brd))
222 # If we need to reconfigure, do that now
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,
236 result.stderr = result.stderr.replace(src_dir + '/', '')
237 if self.builder.verbose_build:
238 result.stdout = config_out + result.stdout
240 result.return_code = 1
241 result.stderr = 'No tool chain for %s\n' % brd.arch
242 result.already_done = False
244 result.toolchain = self.toolchain
246 result.commit_upto = commit_upto
247 result.out_dir = out_dir
248 return result, do_config
250 def _WriteResult(self, result, keep_outputs):
251 """Write a built result to the output directory.
254 result: CommandResult object containing result to write
255 keep_outputs: True to store the output binaries, False
259 if result.return_code < 0:
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
265 maybe_aborted = result.stderr and 'No child processes' in result.stderr
267 if result.already_done:
270 # Write the output and stderr
271 output_dir = self.builder._GetOutputDir(result.commit_upto)
273 build_dir = self.builder.GetBuildDir(result.commit_upto,
277 outfile = os.path.join(build_dir, 'log')
278 with open(outfile, 'w') as fd:
280 fd.write(result.stdout)
282 errfile = self.builder.GetErrFile(result.commit_upto,
285 with open(errfile, 'w') as fd:
286 fd.write(result.stderr)
287 elif os.path.exists(errfile):
291 # Write the build result and toolchain information.
292 done_file = self.builder.GetDoneFile(result.commit_upto,
294 with open(done_file, 'w') as fd:
296 # Special code to indicate we need to retry
297 fd.write('%s' % RETURN_CODE_RETRY)
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)
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
311 # Write out the image and function size information and an objdump
312 env = result.toolchain.MakeEnvironment(self.builder.full_path)
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)
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,
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)
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]
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] + ' ' +
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
353 sizes = self.builder.GetSizesFile(result.commit_upto,
355 with open(sizes, 'w') as fd:
356 print >>fd, '\n'.join(lines)
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'])
364 # Now write the actual build output
366 self.CopyFiles(result.out_dir, build_dir, '', ['u-boot*', '*.bin',
367 '*.map', '*.img', 'MLO', 'SPL', 'include/autoconf.mk',
370 def CopyFiles(self, out_dir, build_dir, dirname, patterns):
371 """Copy files from the build directory to the output.
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
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)
385 base, ext = os.path.splitext(target)
387 target = '%s-%s%s' % (base, dirname, ext)
388 shutil.copy(fname, os.path.join(build_dir, target))
390 def RunJob(self, job):
393 A job consists of a building a list of commits for a particular board.
399 work_dir = self.builder.GetThreadDir(self.thread_num)
400 self.toolchain = None
402 # Run 'make board_defconfig' on the first commit
406 for commit_upto in range(0, len(job.commits), job.step):
407 result, request_config = self.RunCommit(commit_upto, brd,
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
416 if self.builder.force_config_on_failure:
417 result, request_config = self.RunCommit(commit_upto,
418 brd, work_dir, True, True, False)
420 if not self.builder.force_reconfig:
421 do_config = request_config
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
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
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'.
449 if self.builder.force_config_on_failure:
452 result.commit_upto = commit_upto
453 if result.return_code < 0:
454 raise ValueError('Interrupt')
456 # We have the build results, so output the result
457 self._WriteResult(result, job.keep_outputs)
458 self.builder.out_queue.put(result)
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)
468 """Our thread's run function
470 This thread picks a job from the queue, runs it, and then goes to the
474 job = self.builder.queue.get()
476 self.builder.queue.task_done()