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