Tom Rini | 10e4779 | 2018-05-06 17:58:06 -0400 | [diff] [blame] | 1 | # SPDX-License-Identifier: GPL-2.0+ |
Simon Glass | c05694f | 2013-04-03 11:07:16 +0000 | [diff] [blame] | 2 | # Copyright (c) 2013 The Chromium OS Authors. |
| 3 | # |
Simon Glass | c05694f | 2013-04-03 11:07:16 +0000 | [diff] [blame] | 4 | |
| 5 | import multiprocessing |
Simon Glass | c573580 | 2023-02-23 18:18:12 -0700 | [diff] [blame^] | 6 | import importlib.resources |
Simon Glass | c05694f | 2013-04-03 11:07:16 +0000 | [diff] [blame] | 7 | import os |
Simon Glass | a10ebe1 | 2014-09-05 19:00:18 -0600 | [diff] [blame] | 8 | import shutil |
Simon Glass | f0d9c10 | 2020-04-17 18:09:02 -0600 | [diff] [blame] | 9 | import subprocess |
Simon Glass | c05694f | 2013-04-03 11:07:16 +0000 | [diff] [blame] | 10 | import sys |
| 11 | |
Simon Glass | 20751d6 | 2022-07-11 19:04:03 -0600 | [diff] [blame] | 12 | from buildman import boards |
Simon Glass | f0d9c10 | 2020-04-17 18:09:02 -0600 | [diff] [blame] | 13 | from buildman import bsettings |
Simon Glass | e5650a8 | 2022-01-22 05:07:33 -0700 | [diff] [blame] | 14 | from buildman import cfgutil |
Simon Glass | f0d9c10 | 2020-04-17 18:09:02 -0600 | [diff] [blame] | 15 | from buildman import toolchain |
| 16 | from buildman.builder import Builder |
Simon Glass | a997ea5 | 2020-04-17 18:09:04 -0600 | [diff] [blame] | 17 | from patman import gitutil |
| 18 | from patman import patchstream |
Simon Glass | 131444f | 2023-02-23 18:18:04 -0700 | [diff] [blame] | 19 | from u_boot_pylib import command |
| 20 | from u_boot_pylib import terminal |
| 21 | from u_boot_pylib import tools |
| 22 | from u_boot_pylib.terminal import tprint |
Simon Glass | c05694f | 2013-04-03 11:07:16 +0000 | [diff] [blame] | 23 | |
| 24 | def GetPlural(count): |
| 25 | """Returns a plural 's' if count is not 1""" |
| 26 | return 's' if count != 1 else '' |
| 27 | |
Simon Glass | d326ad7 | 2014-08-09 15:32:59 -0600 | [diff] [blame] | 28 | def GetActionSummary(is_summary, commits, selected, options): |
Simon Glass | c05694f | 2013-04-03 11:07:16 +0000 | [diff] [blame] | 29 | """Return a string summarising the intended action. |
| 30 | |
| 31 | Returns: |
| 32 | Summary string. |
| 33 | """ |
Simon Glass | d326ad7 | 2014-08-09 15:32:59 -0600 | [diff] [blame] | 34 | if commits: |
| 35 | count = len(commits) |
Simon Glass | c78ed66 | 2019-10-31 07:42:53 -0600 | [diff] [blame] | 36 | count = (count + options.step - 1) // options.step |
Simon Glass | d326ad7 | 2014-08-09 15:32:59 -0600 | [diff] [blame] | 37 | commit_str = '%d commit%s' % (count, GetPlural(count)) |
| 38 | else: |
| 39 | commit_str = 'current source' |
| 40 | str = '%s %s for %d boards' % ( |
| 41 | 'Summary of' if is_summary else 'Building', commit_str, |
Simon Glass | c05694f | 2013-04-03 11:07:16 +0000 | [diff] [blame] | 42 | len(selected)) |
| 43 | str += ' (%d thread%s, %d job%s per thread)' % (options.threads, |
| 44 | GetPlural(options.threads), options.jobs, GetPlural(options.jobs)) |
| 45 | return str |
| 46 | |
Simon Glass | d9eb9f0 | 2018-06-11 23:26:46 -0600 | [diff] [blame] | 47 | def ShowActions(series, why_selected, boards_selected, builder, options, |
| 48 | board_warnings): |
Simon Glass | c05694f | 2013-04-03 11:07:16 +0000 | [diff] [blame] | 49 | """Display a list of actions that we would take, if not a dry run. |
| 50 | |
| 51 | Args: |
| 52 | series: Series object |
| 53 | why_selected: Dictionary where each key is a buildman argument |
Simon Glass | 6af145f | 2017-01-23 05:38:56 -0700 | [diff] [blame] | 54 | provided by the user, and the value is the list of boards |
| 55 | brought in by that argument. For example, 'arm' might bring |
| 56 | in 400 boards, so in this case the key would be 'arm' and |
Simon Glass | c05694f | 2013-04-03 11:07:16 +0000 | [diff] [blame] | 57 | the value would be a list of board names. |
| 58 | boards_selected: Dict of selected boards, key is target name, |
| 59 | value is Board object |
| 60 | builder: The builder that will be used to build the commits |
| 61 | options: Command line options object |
Simon Glass | d9eb9f0 | 2018-06-11 23:26:46 -0600 | [diff] [blame] | 62 | board_warnings: List of warnings obtained from board selected |
Simon Glass | c05694f | 2013-04-03 11:07:16 +0000 | [diff] [blame] | 63 | """ |
| 64 | col = terminal.Color() |
Simon Glass | c78ed66 | 2019-10-31 07:42:53 -0600 | [diff] [blame] | 65 | print('Dry run, so not doing much. But I would do this:') |
| 66 | print() |
Simon Glass | d326ad7 | 2014-08-09 15:32:59 -0600 | [diff] [blame] | 67 | if series: |
| 68 | commits = series.commits |
| 69 | else: |
| 70 | commits = None |
Simon Glass | c78ed66 | 2019-10-31 07:42:53 -0600 | [diff] [blame] | 71 | print(GetActionSummary(False, commits, boards_selected, |
| 72 | options)) |
| 73 | print('Build directory: %s' % builder.base_dir) |
Simon Glass | d326ad7 | 2014-08-09 15:32:59 -0600 | [diff] [blame] | 74 | if commits: |
| 75 | for upto in range(0, len(series.commits), options.step): |
| 76 | commit = series.commits[upto] |
Simon Glass | f45d374 | 2022-01-29 14:14:17 -0700 | [diff] [blame] | 77 | print(' ', col.build(col.YELLOW, commit.hash[:8], bright=False), end=' ') |
Simon Glass | c78ed66 | 2019-10-31 07:42:53 -0600 | [diff] [blame] | 78 | print(commit.subject) |
| 79 | print() |
Simon Glass | c05694f | 2013-04-03 11:07:16 +0000 | [diff] [blame] | 80 | for arg in why_selected: |
| 81 | if arg != 'all': |
Simon Glass | c78ed66 | 2019-10-31 07:42:53 -0600 | [diff] [blame] | 82 | print(arg, ': %d boards' % len(why_selected[arg])) |
Simon Glass | 6af145f | 2017-01-23 05:38:56 -0700 | [diff] [blame] | 83 | if options.verbose: |
Simon Glass | c78ed66 | 2019-10-31 07:42:53 -0600 | [diff] [blame] | 84 | print(' %s' % ' '.join(why_selected[arg])) |
| 85 | print(('Total boards to build for each commit: %d\n' % |
| 86 | len(why_selected['all']))) |
Simon Glass | d9eb9f0 | 2018-06-11 23:26:46 -0600 | [diff] [blame] | 87 | if board_warnings: |
| 88 | for warning in board_warnings: |
Simon Glass | f45d374 | 2022-01-29 14:14:17 -0700 | [diff] [blame] | 89 | print(col.build(col.YELLOW, warning)) |
Simon Glass | c05694f | 2013-04-03 11:07:16 +0000 | [diff] [blame] | 90 | |
Simon Glass | 5df4522 | 2022-07-11 19:04:00 -0600 | [diff] [blame] | 91 | def ShowToolchainPrefix(brds, toolchains): |
Simon Glass | 48ac42e | 2019-12-05 15:59:14 -0700 | [diff] [blame] | 92 | """Show information about a the tool chain used by one or more boards |
| 93 | |
Simon Glass | 2df44be | 2020-03-18 09:42:47 -0600 | [diff] [blame] | 94 | The function checks that all boards use the same toolchain, then prints |
| 95 | the correct value for CROSS_COMPILE. |
Simon Glass | 48ac42e | 2019-12-05 15:59:14 -0700 | [diff] [blame] | 96 | |
| 97 | Args: |
| 98 | boards: Boards object containing selected boards |
| 99 | toolchains: Toolchains object containing available toolchains |
Simon Glass | 48ac42e | 2019-12-05 15:59:14 -0700 | [diff] [blame] | 100 | |
| 101 | Return: |
| 102 | None on success, string error message otherwise |
| 103 | """ |
Simon Glass | 127a239 | 2022-07-11 19:04:02 -0600 | [diff] [blame] | 104 | board_selected = brds.get_selected_dict() |
Simon Glass | 48ac42e | 2019-12-05 15:59:14 -0700 | [diff] [blame] | 105 | tc_set = set() |
Simon Glass | 5df4522 | 2022-07-11 19:04:00 -0600 | [diff] [blame] | 106 | for brd in board_selected.values(): |
Simon Glass | 48ac42e | 2019-12-05 15:59:14 -0700 | [diff] [blame] | 107 | tc_set.add(toolchains.Select(brd.arch)) |
| 108 | if len(tc_set) != 1: |
| 109 | return 'Supplied boards must share one toolchain' |
| 110 | return False |
| 111 | tc = tc_set.pop() |
Simon Glass | 2df44be | 2020-03-18 09:42:47 -0600 | [diff] [blame] | 112 | print(tc.GetEnvArgs(toolchain.VAR_CROSS_COMPILE)) |
Simon Glass | 48ac42e | 2019-12-05 15:59:14 -0700 | [diff] [blame] | 113 | return None |
| 114 | |
Tom Rini | 93ebd46 | 2022-11-09 19:14:53 -0700 | [diff] [blame] | 115 | def get_allow_missing(opt_allow, opt_no_allow, num_selected, has_branch): |
| 116 | allow_missing = False |
| 117 | am_setting = bsettings.GetGlobalItemValue('allow-missing') |
| 118 | if am_setting: |
| 119 | if am_setting == 'always': |
| 120 | allow_missing = True |
| 121 | if 'multiple' in am_setting and num_selected > 1: |
| 122 | allow_missing = True |
| 123 | if 'branch' in am_setting and has_branch: |
| 124 | allow_missing = True |
| 125 | |
| 126 | if opt_allow: |
| 127 | allow_missing = True |
| 128 | if opt_no_allow: |
| 129 | allow_missing = False |
| 130 | return allow_missing |
| 131 | |
Simon Glass | 5df4522 | 2022-07-11 19:04:00 -0600 | [diff] [blame] | 132 | def DoBuildman(options, args, toolchains=None, make_func=None, brds=None, |
Simon Glass | 9bf9a72 | 2021-04-11 16:27:27 +1200 | [diff] [blame] | 133 | clean_dir=False, test_thread_exceptions=False): |
Simon Glass | c05694f | 2013-04-03 11:07:16 +0000 | [diff] [blame] | 134 | """The main control code for buildman |
| 135 | |
| 136 | Args: |
| 137 | options: Command line options object |
| 138 | args: Command line arguments (list of strings) |
Simon Glass | ed098bb | 2014-09-05 19:00:13 -0600 | [diff] [blame] | 139 | toolchains: Toolchains to use - this should be a Toolchains() |
| 140 | object. If None, then it will be created and scanned |
| 141 | make_func: Make function to use for the builder. This is called |
| 142 | to execute 'make'. If this is None, the normal function |
| 143 | will be used, which calls the 'make' tool with suitable |
| 144 | arguments. This setting is useful for tests. |
Simon Glass | 5df4522 | 2022-07-11 19:04:00 -0600 | [diff] [blame] | 145 | brds: Boards() object to use, containing a list of available |
Simon Glass | cbd3658 | 2014-09-05 19:00:16 -0600 | [diff] [blame] | 146 | boards. If this is None it will be created and scanned. |
Simon Glass | a29b3ea | 2021-04-11 16:27:25 +1200 | [diff] [blame] | 147 | clean_dir: Used for tests only, indicates that the existing output_dir |
| 148 | should be removed before starting the build |
Simon Glass | 9bf9a72 | 2021-04-11 16:27:27 +1200 | [diff] [blame] | 149 | test_thread_exceptions: Uses for tests only, True to make the threads |
| 150 | raise an exception instead of reporting their result. This simulates |
| 151 | a failure in the code somewhere |
Simon Glass | c05694f | 2013-04-03 11:07:16 +0000 | [diff] [blame] | 152 | """ |
Simon Glass | a10ebe1 | 2014-09-05 19:00:18 -0600 | [diff] [blame] | 153 | global builder |
| 154 | |
Simon Glass | ca9b06e | 2014-09-05 19:00:11 -0600 | [diff] [blame] | 155 | if options.full_help: |
Simon Glass | c573580 | 2023-02-23 18:18:12 -0700 | [diff] [blame^] | 156 | with importlib.resources.path('buildman', 'README.rst') as readme: |
| 157 | tools.print_full_help(str(readme)) |
Simon Glass | ca9b06e | 2014-09-05 19:00:11 -0600 | [diff] [blame] | 158 | return 0 |
| 159 | |
Simon Glass | 761648b | 2022-01-29 14:14:11 -0700 | [diff] [blame] | 160 | gitutil.setup() |
Simon Glass | 9f1ba0f | 2016-07-27 20:33:02 -0600 | [diff] [blame] | 161 | col = terminal.Color() |
Simon Glass | c05694f | 2013-04-03 11:07:16 +0000 | [diff] [blame] | 162 | |
Simon Glass | c05694f | 2013-04-03 11:07:16 +0000 | [diff] [blame] | 163 | options.git_dir = os.path.join(options.git, '.git') |
| 164 | |
Simon Glass | a3d9b4f | 2016-07-27 20:33:04 -0600 | [diff] [blame] | 165 | no_toolchains = toolchains is None |
| 166 | if no_toolchains: |
Simon Glass | f77ca5b | 2019-01-07 16:44:20 -0700 | [diff] [blame] | 167 | toolchains = toolchain.Toolchains(options.override_toolchain) |
Simon Glass | c05694f | 2013-04-03 11:07:16 +0000 | [diff] [blame] | 168 | |
Simon Glass | 7e803e1 | 2014-12-01 17:34:06 -0700 | [diff] [blame] | 169 | if options.fetch_arch: |
| 170 | if options.fetch_arch == 'list': |
| 171 | sorted_list = toolchains.ListArchs() |
Simon Glass | f45d374 | 2022-01-29 14:14:17 -0700 | [diff] [blame] | 172 | print(col.build(col.BLUE, 'Available architectures: %s\n' % |
Simon Glass | c78ed66 | 2019-10-31 07:42:53 -0600 | [diff] [blame] | 173 | ' '.join(sorted_list))) |
Simon Glass | 7e803e1 | 2014-12-01 17:34:06 -0700 | [diff] [blame] | 174 | return 0 |
| 175 | else: |
| 176 | fetch_arch = options.fetch_arch |
| 177 | if fetch_arch == 'all': |
| 178 | fetch_arch = ','.join(toolchains.ListArchs()) |
Simon Glass | f45d374 | 2022-01-29 14:14:17 -0700 | [diff] [blame] | 179 | print(col.build(col.CYAN, '\nDownloading toolchains: %s' % |
Simon Glass | c78ed66 | 2019-10-31 07:42:53 -0600 | [diff] [blame] | 180 | fetch_arch)) |
Simon Glass | 7e803e1 | 2014-12-01 17:34:06 -0700 | [diff] [blame] | 181 | for arch in fetch_arch.split(','): |
Simon Glass | c78ed66 | 2019-10-31 07:42:53 -0600 | [diff] [blame] | 182 | print() |
Simon Glass | 7e803e1 | 2014-12-01 17:34:06 -0700 | [diff] [blame] | 183 | ret = toolchains.FetchAndInstall(arch) |
| 184 | if ret: |
| 185 | return ret |
| 186 | return 0 |
| 187 | |
Simon Glass | a3d9b4f | 2016-07-27 20:33:04 -0600 | [diff] [blame] | 188 | if no_toolchains: |
| 189 | toolchains.GetSettings() |
Simon Glass | 74579fc | 2018-11-06 16:02:10 -0700 | [diff] [blame] | 190 | toolchains.Scan(options.list_tool_chains and options.verbose) |
Simon Glass | a3d9b4f | 2016-07-27 20:33:04 -0600 | [diff] [blame] | 191 | if options.list_tool_chains: |
| 192 | toolchains.List() |
Simon Glass | c78ed66 | 2019-10-31 07:42:53 -0600 | [diff] [blame] | 193 | print() |
Simon Glass | a3d9b4f | 2016-07-27 20:33:04 -0600 | [diff] [blame] | 194 | return 0 |
| 195 | |
Simon Glass | d9c9863 | 2020-04-17 17:51:32 -0600 | [diff] [blame] | 196 | if not options.output_dir: |
| 197 | if options.work_in_output: |
Simon Glass | f45d374 | 2022-01-29 14:14:17 -0700 | [diff] [blame] | 198 | sys.exit(col.build(col.RED, '-w requires that you specify -o')) |
Simon Glass | d9c9863 | 2020-04-17 17:51:32 -0600 | [diff] [blame] | 199 | options.output_dir = '..' |
Simon Glass | 6029af1 | 2020-04-09 15:08:51 -0600 | [diff] [blame] | 200 | |
Simon Glass | c05694f | 2013-04-03 11:07:16 +0000 | [diff] [blame] | 201 | # Work out what subset of the boards we are building |
Simon Glass | 5df4522 | 2022-07-11 19:04:00 -0600 | [diff] [blame] | 202 | if not brds: |
Tom Rini | 6ef6b3f | 2019-11-19 15:14:33 -0500 | [diff] [blame] | 203 | if not os.path.exists(options.output_dir): |
| 204 | os.makedirs(options.output_dir) |
Bin Meng | 0733e20 | 2019-10-28 07:24:59 -0700 | [diff] [blame] | 205 | board_file = os.path.join(options.output_dir, 'boards.cfg') |
Masahiro Yamada | e9bc8d2 | 2014-07-30 14:08:22 +0900 | [diff] [blame] | 206 | |
Simon Glass | 20751d6 | 2022-07-11 19:04:03 -0600 | [diff] [blame] | 207 | brds = boards.Boards() |
Simon Glass | afbd213 | 2022-07-11 19:04:08 -0600 | [diff] [blame] | 208 | ok = brds.ensure_board_list(board_file, |
| 209 | options.threads or multiprocessing.cpu_count(), |
| 210 | force=options.regen_board_list, |
| 211 | quiet=not options.verbose) |
Simon Glass | 0c477b7 | 2022-07-11 19:04:04 -0600 | [diff] [blame] | 212 | if options.regen_board_list: |
Simon Glass | afbd213 | 2022-07-11 19:04:08 -0600 | [diff] [blame] | 213 | return 0 if ok else 2 |
Simon Glass | 127a239 | 2022-07-11 19:04:02 -0600 | [diff] [blame] | 214 | brds.read_boards(board_file) |
Simon Glass | 924c73a | 2014-08-28 09:43:41 -0600 | [diff] [blame] | 215 | |
| 216 | exclude = [] |
| 217 | if options.exclude: |
| 218 | for arg in options.exclude: |
| 219 | exclude += arg.split(',') |
| 220 | |
Simon Glass | d9eb9f0 | 2018-06-11 23:26:46 -0600 | [diff] [blame] | 221 | if options.boards: |
| 222 | requested_boards = [] |
| 223 | for b in options.boards: |
| 224 | requested_boards += b.split(',') |
| 225 | else: |
| 226 | requested_boards = None |
Simon Glass | 127a239 | 2022-07-11 19:04:02 -0600 | [diff] [blame] | 227 | why_selected, board_warnings = brds.select_boards(args, exclude, |
| 228 | requested_boards) |
| 229 | selected = brds.get_selected() |
Simon Glass | c05694f | 2013-04-03 11:07:16 +0000 | [diff] [blame] | 230 | if not len(selected): |
Simon Glass | f45d374 | 2022-01-29 14:14:17 -0700 | [diff] [blame] | 231 | sys.exit(col.build(col.RED, 'No matching boards found')) |
Simon Glass | c05694f | 2013-04-03 11:07:16 +0000 | [diff] [blame] | 232 | |
Simon Glass | 2df44be | 2020-03-18 09:42:47 -0600 | [diff] [blame] | 233 | if options.print_prefix: |
Simon Glass | 5df4522 | 2022-07-11 19:04:00 -0600 | [diff] [blame] | 234 | err = ShowToolchainPrefix(brds, toolchains) |
Simon Glass | 48ac42e | 2019-12-05 15:59:14 -0700 | [diff] [blame] | 235 | if err: |
Simon Glass | f45d374 | 2022-01-29 14:14:17 -0700 | [diff] [blame] | 236 | sys.exit(col.build(col.RED, err)) |
Simon Glass | 48ac42e | 2019-12-05 15:59:14 -0700 | [diff] [blame] | 237 | return 0 |
| 238 | |
Simon Glass | 9b55091 | 2019-12-05 15:59:13 -0700 | [diff] [blame] | 239 | # Work out how many commits to build. We want to build everything on the |
| 240 | # branch. We also build the upstream commit as a control so we can see |
| 241 | # problems introduced by the first commit on the branch. |
| 242 | count = options.count |
| 243 | has_range = options.branch and '..' in options.branch |
| 244 | if count == -1: |
| 245 | if not options.branch: |
| 246 | count = 1 |
| 247 | else: |
| 248 | if has_range: |
Simon Glass | 761648b | 2022-01-29 14:14:11 -0700 | [diff] [blame] | 249 | count, msg = gitutil.count_commits_in_range(options.git_dir, |
Simon Glass | 9b55091 | 2019-12-05 15:59:13 -0700 | [diff] [blame] | 250 | options.branch) |
| 251 | else: |
Simon Glass | 761648b | 2022-01-29 14:14:11 -0700 | [diff] [blame] | 252 | count, msg = gitutil.count_commits_in_branch(options.git_dir, |
Simon Glass | 9b55091 | 2019-12-05 15:59:13 -0700 | [diff] [blame] | 253 | options.branch) |
| 254 | if count is None: |
Simon Glass | f45d374 | 2022-01-29 14:14:17 -0700 | [diff] [blame] | 255 | sys.exit(col.build(col.RED, msg)) |
Simon Glass | 9b55091 | 2019-12-05 15:59:13 -0700 | [diff] [blame] | 256 | elif count == 0: |
Simon Glass | f45d374 | 2022-01-29 14:14:17 -0700 | [diff] [blame] | 257 | sys.exit(col.build(col.RED, "Range '%s' has no commits" % |
Simon Glass | 9b55091 | 2019-12-05 15:59:13 -0700 | [diff] [blame] | 258 | options.branch)) |
| 259 | if msg: |
Simon Glass | f45d374 | 2022-01-29 14:14:17 -0700 | [diff] [blame] | 260 | print(col.build(col.YELLOW, msg)) |
Simon Glass | 9b55091 | 2019-12-05 15:59:13 -0700 | [diff] [blame] | 261 | count += 1 # Build upstream commit also |
| 262 | |
| 263 | if not count: |
Simon Glass | ba666eb | 2023-02-23 18:18:11 -0700 | [diff] [blame] | 264 | msg = ("No commits found to process in branch '%s': " |
Simon Glass | 9b55091 | 2019-12-05 15:59:13 -0700 | [diff] [blame] | 265 | "set branch's upstream or use -c flag" % options.branch) |
Simon Glass | ba666eb | 2023-02-23 18:18:11 -0700 | [diff] [blame] | 266 | sys.exit(col.build(col.RED, msg)) |
Simon Glass | b6eb8cf | 2020-03-18 09:42:42 -0600 | [diff] [blame] | 267 | if options.work_in_output: |
| 268 | if len(selected) != 1: |
Simon Glass | f45d374 | 2022-01-29 14:14:17 -0700 | [diff] [blame] | 269 | sys.exit(col.build(col.RED, |
Simon Glass | b6eb8cf | 2020-03-18 09:42:42 -0600 | [diff] [blame] | 270 | '-w can only be used with a single board')) |
| 271 | if count != 1: |
Simon Glass | f45d374 | 2022-01-29 14:14:17 -0700 | [diff] [blame] | 272 | sys.exit(col.build(col.RED, |
Simon Glass | b6eb8cf | 2020-03-18 09:42:42 -0600 | [diff] [blame] | 273 | '-w can only be used with a single commit')) |
Simon Glass | 9b55091 | 2019-12-05 15:59:13 -0700 | [diff] [blame] | 274 | |
Simon Glass | c05694f | 2013-04-03 11:07:16 +0000 | [diff] [blame] | 275 | # Read the metadata from the commits. First look at the upstream commit, |
| 276 | # then the ones in the branch. We would like to do something like |
| 277 | # upstream/master~..branch but that isn't possible if upstream/master is |
| 278 | # a merge commit (it will list all the commits that form part of the |
| 279 | # merge) |
Simon Glass | 359b55a6 | 2014-09-05 19:00:23 -0600 | [diff] [blame] | 280 | # Conflicting tags are not a problem for buildman, since it does not use |
| 281 | # them. For example, Series-version is not useful for buildman. On the |
| 282 | # other hand conflicting tags will cause an error. So allow later tags |
| 283 | # to overwrite earlier ones by setting allow_overwrite=True |
Simon Glass | d326ad7 | 2014-08-09 15:32:59 -0600 | [diff] [blame] | 284 | if options.branch: |
Simon Glass | 16a5288 | 2014-08-09 15:33:09 -0600 | [diff] [blame] | 285 | if count == -1: |
Simon Glass | 5eeef46 | 2014-12-01 17:33:57 -0700 | [diff] [blame] | 286 | if has_range: |
| 287 | range_expr = options.branch |
| 288 | else: |
Simon Glass | 761648b | 2022-01-29 14:14:11 -0700 | [diff] [blame] | 289 | range_expr = gitutil.get_range_in_branch(options.git_dir, |
Simon Glass | 5eeef46 | 2014-12-01 17:33:57 -0700 | [diff] [blame] | 290 | options.branch) |
Simon Glass | 761648b | 2022-01-29 14:14:11 -0700 | [diff] [blame] | 291 | upstream_commit = gitutil.get_upstream(options.git_dir, |
Simon Glass | 16a5288 | 2014-08-09 15:33:09 -0600 | [diff] [blame] | 292 | options.branch) |
Simon Glass | 93f61c0 | 2020-10-29 21:46:19 -0600 | [diff] [blame] | 293 | series = patchstream.get_metadata_for_list(upstream_commit, |
Simon Glass | 359b55a6 | 2014-09-05 19:00:23 -0600 | [diff] [blame] | 294 | options.git_dir, 1, series=None, allow_overwrite=True) |
Simon Glass | d326ad7 | 2014-08-09 15:32:59 -0600 | [diff] [blame] | 295 | |
Simon Glass | 93f61c0 | 2020-10-29 21:46:19 -0600 | [diff] [blame] | 296 | series = patchstream.get_metadata_for_list(range_expr, |
Simon Glass | 359b55a6 | 2014-09-05 19:00:23 -0600 | [diff] [blame] | 297 | options.git_dir, None, series, allow_overwrite=True) |
Simon Glass | 16a5288 | 2014-08-09 15:33:09 -0600 | [diff] [blame] | 298 | else: |
| 299 | # Honour the count |
Simon Glass | 93f61c0 | 2020-10-29 21:46:19 -0600 | [diff] [blame] | 300 | series = patchstream.get_metadata_for_list(options.branch, |
Simon Glass | 359b55a6 | 2014-09-05 19:00:23 -0600 | [diff] [blame] | 301 | options.git_dir, count, series=None, allow_overwrite=True) |
Simon Glass | d326ad7 | 2014-08-09 15:32:59 -0600 | [diff] [blame] | 302 | else: |
| 303 | series = None |
Simon Glass | 6af145f | 2017-01-23 05:38:56 -0700 | [diff] [blame] | 304 | if not options.dry_run: |
| 305 | options.verbose = True |
| 306 | if not options.summary: |
| 307 | options.show_errors = True |
Simon Glass | c05694f | 2013-04-03 11:07:16 +0000 | [diff] [blame] | 308 | |
| 309 | # By default we have one thread per CPU. But if there are not enough jobs |
| 310 | # we can have fewer threads and use a high '-j' value for make. |
Simon Glass | c635d89 | 2021-01-30 22:17:46 -0700 | [diff] [blame] | 311 | if options.threads is None: |
Simon Glass | c05694f | 2013-04-03 11:07:16 +0000 | [diff] [blame] | 312 | options.threads = min(multiprocessing.cpu_count(), len(selected)) |
| 313 | if not options.jobs: |
| 314 | options.jobs = max(1, (multiprocessing.cpu_count() + |
Simon Glass | c78ed66 | 2019-10-31 07:42:53 -0600 | [diff] [blame] | 315 | len(selected) - 1) // len(selected)) |
Simon Glass | c05694f | 2013-04-03 11:07:16 +0000 | [diff] [blame] | 316 | |
| 317 | if not options.step: |
| 318 | options.step = len(series.commits) - 1 |
| 319 | |
Simon Glass | 840be73 | 2022-01-29 14:14:05 -0700 | [diff] [blame] | 320 | gnu_make = command.output(os.path.join(options.git, |
Simon Glass | c55e056 | 2016-07-25 18:59:00 -0600 | [diff] [blame] | 321 | 'scripts/show-gnu-make'), raise_on_error=False).rstrip() |
Masahiro Yamada | 1fe610d | 2014-07-22 11:19:09 +0900 | [diff] [blame] | 322 | if not gnu_make: |
Masahiro Yamada | 880828d | 2014-08-16 00:59:26 +0900 | [diff] [blame] | 323 | sys.exit('GNU Make not found') |
Masahiro Yamada | 1fe610d | 2014-07-22 11:19:09 +0900 | [diff] [blame] | 324 | |
Tom Rini | 93ebd46 | 2022-11-09 19:14:53 -0700 | [diff] [blame] | 325 | allow_missing = get_allow_missing(options.allow_missing, |
| 326 | options.no_allow_missing, len(selected), |
| 327 | options.branch) |
| 328 | |
Simon Glass | dbc01c7 | 2014-12-01 17:33:52 -0700 | [diff] [blame] | 329 | # Create a new builder with the selected options. |
| 330 | output_dir = options.output_dir |
Simon Glass | d326ad7 | 2014-08-09 15:32:59 -0600 | [diff] [blame] | 331 | if options.branch: |
Simon Glass | 4aeceb9 | 2014-09-05 19:00:22 -0600 | [diff] [blame] | 332 | dirname = options.branch.replace('/', '_') |
Simon Glass | e87bde1 | 2014-12-01 17:33:55 -0700 | [diff] [blame] | 333 | # As a special case allow the board directory to be placed in the |
| 334 | # output directory itself rather than any subdirectory. |
| 335 | if not options.no_subdirs: |
| 336 | output_dir = os.path.join(options.output_dir, dirname) |
Lothar Waßmann | ce6df92 | 2018-04-08 05:14:11 -0600 | [diff] [blame] | 337 | if clean_dir and os.path.exists(output_dir): |
| 338 | shutil.rmtree(output_dir) |
Simon Glass | e5650a8 | 2022-01-22 05:07:33 -0700 | [diff] [blame] | 339 | adjust_cfg = cfgutil.convert_list_to_dict(options.adjust_cfg) |
| 340 | |
Simon Glass | 828d70d | 2023-02-21 12:40:29 -0700 | [diff] [blame] | 341 | # Drop LOCALVERSION_AUTO since it changes the version string on every commit |
| 342 | if options.reproducible_builds: |
| 343 | # If these are mentioned, leave the local version alone |
| 344 | if 'LOCALVERSION' in adjust_cfg or 'LOCALVERSION_AUTO' in adjust_cfg: |
| 345 | print('Not dropping LOCALVERSION_AUTO for reproducible build') |
| 346 | else: |
| 347 | adjust_cfg['LOCALVERSION_AUTO'] = '~' |
| 348 | |
Simon Glass | c05694f | 2013-04-03 11:07:16 +0000 | [diff] [blame] | 349 | builder = Builder(toolchains, output_dir, options.git_dir, |
Masahiro Yamada | 1fe610d | 2014-07-22 11:19:09 +0900 | [diff] [blame] | 350 | options.threads, options.jobs, gnu_make=gnu_make, checkout=True, |
Simon Glass | e87bde1 | 2014-12-01 17:33:55 -0700 | [diff] [blame] | 351 | show_unknown=options.show_unknown, step=options.step, |
Simon Glass | 655b610 | 2014-12-01 17:34:07 -0700 | [diff] [blame] | 352 | no_subdirs=options.no_subdirs, full_path=options.full_path, |
Stephen Warren | 97c9690 | 2016-04-11 10:48:44 -0600 | [diff] [blame] | 353 | verbose_build=options.verbose_build, |
Simon Glass | 6029af1 | 2020-04-09 15:08:51 -0600 | [diff] [blame] | 354 | mrproper=options.mrproper, |
Simon Glass | 739e851 | 2016-11-13 14:25:51 -0700 | [diff] [blame] | 355 | per_board_out_dir=options.per_board_out_dir, |
Simon Glass | cde5c30 | 2016-11-13 14:25:53 -0700 | [diff] [blame] | 356 | config_only=options.config_only, |
Daniel Schwierzeck | 20e2ea9 | 2018-01-26 16:31:05 +0100 | [diff] [blame] | 357 | squash_config_y=not options.preserve_config_y, |
Simon Glass | b6eb8cf | 2020-03-18 09:42:42 -0600 | [diff] [blame] | 358 | warnings_as_errors=options.warnings_as_errors, |
Simon Glass | 9bf9a72 | 2021-04-11 16:27:27 +1200 | [diff] [blame] | 359 | work_in_output=options.work_in_output, |
Simon Glass | e5650a8 | 2022-01-22 05:07:33 -0700 | [diff] [blame] | 360 | test_thread_exceptions=test_thread_exceptions, |
Tom Rini | 93ebd46 | 2022-11-09 19:14:53 -0700 | [diff] [blame] | 361 | adjust_cfg=adjust_cfg, |
Simon Glass | 828d70d | 2023-02-21 12:40:29 -0700 | [diff] [blame] | 362 | allow_missing=allow_missing, no_lto=options.no_lto, |
| 363 | reproducible_builds=options.reproducible_builds) |
Simon Glass | c05694f | 2013-04-03 11:07:16 +0000 | [diff] [blame] | 364 | builder.force_config_on_failure = not options.quick |
Simon Glass | ed098bb | 2014-09-05 19:00:13 -0600 | [diff] [blame] | 365 | if make_func: |
| 366 | builder.do_make = make_func |
Simon Glass | c05694f | 2013-04-03 11:07:16 +0000 | [diff] [blame] | 367 | |
| 368 | # For a dry run, just show our actions as a sanity check |
| 369 | if options.dry_run: |
Simon Glass | d9eb9f0 | 2018-06-11 23:26:46 -0600 | [diff] [blame] | 370 | ShowActions(series, why_selected, selected, builder, options, |
| 371 | board_warnings) |
Simon Glass | c05694f | 2013-04-03 11:07:16 +0000 | [diff] [blame] | 372 | else: |
| 373 | builder.force_build = options.force_build |
Simon Glass | 7041c39 | 2014-07-13 12:22:31 -0600 | [diff] [blame] | 374 | builder.force_build_failures = options.force_build_failures |
Simon Glass | f3018b7a | 2014-07-14 17:51:02 -0600 | [diff] [blame] | 375 | builder.force_reconfig = options.force_reconfig |
Simon Glass | 38df2e2 | 2014-07-14 17:51:03 -0600 | [diff] [blame] | 376 | builder.in_tree = options.in_tree |
Simon Glass | c05694f | 2013-04-03 11:07:16 +0000 | [diff] [blame] | 377 | |
| 378 | # Work out which boards to build |
Simon Glass | 127a239 | 2022-07-11 19:04:02 -0600 | [diff] [blame] | 379 | board_selected = brds.get_selected_dict() |
Simon Glass | c05694f | 2013-04-03 11:07:16 +0000 | [diff] [blame] | 380 | |
Simon Glass | d326ad7 | 2014-08-09 15:32:59 -0600 | [diff] [blame] | 381 | if series: |
| 382 | commits = series.commits |
Simon Glass | a10ebe1 | 2014-09-05 19:00:18 -0600 | [diff] [blame] | 383 | # Number the commits for test purposes |
| 384 | for commit in range(len(commits)): |
| 385 | commits[commit].sequence = commit |
Simon Glass | d326ad7 | 2014-08-09 15:32:59 -0600 | [diff] [blame] | 386 | else: |
| 387 | commits = None |
| 388 | |
Simon Glass | 6c43562 | 2022-07-11 19:03:56 -0600 | [diff] [blame] | 389 | if not options.ide: |
| 390 | tprint(GetActionSummary(options.summary, commits, board_selected, |
| 391 | options)) |
Simon Glass | c05694f | 2013-04-03 11:07:16 +0000 | [diff] [blame] | 392 | |
Simon Glass | 232d850 | 2014-09-14 20:23:16 -0600 | [diff] [blame] | 393 | # We can't show function sizes without board details at present |
| 394 | if options.show_bloat: |
| 395 | options.show_detail = True |
Simon Glass | 9ea9381 | 2020-04-09 15:08:52 -0600 | [diff] [blame] | 396 | builder.SetDisplayOptions( |
| 397 | options.show_errors, options.show_sizes, options.show_detail, |
| 398 | options.show_bloat, options.list_error_boards, options.show_config, |
Simon Glass | f4ebfba | 2020-04-09 15:08:53 -0600 | [diff] [blame] | 399 | options.show_environment, options.filter_dtb_warnings, |
Simon Glass | 6c43562 | 2022-07-11 19:03:56 -0600 | [diff] [blame] | 400 | options.filter_migration_warnings, options.ide) |
Simon Glass | c05694f | 2013-04-03 11:07:16 +0000 | [diff] [blame] | 401 | if options.summary: |
Simon Glass | eb48bbc | 2014-08-09 15:33:02 -0600 | [diff] [blame] | 402 | builder.ShowSummary(commits, board_selected) |
Simon Glass | c05694f | 2013-04-03 11:07:16 +0000 | [diff] [blame] | 403 | else: |
Simon Glass | 9bf9a72 | 2021-04-11 16:27:27 +1200 | [diff] [blame] | 404 | fail, warned, excs = builder.BuildBoards( |
| 405 | commits, board_selected, options.keep_outputs, options.verbose) |
| 406 | if excs: |
| 407 | return 102 |
| 408 | elif fail: |
Simon Glass | e4cd506 | 2020-04-09 10:49:45 -0600 | [diff] [blame] | 409 | return 100 |
Simon Glass | 35e7d38 | 2020-03-18 09:42:44 -0600 | [diff] [blame] | 410 | elif warned and not options.ignore_warnings: |
Simon Glass | e4cd506 | 2020-04-09 10:49:45 -0600 | [diff] [blame] | 411 | return 101 |
Simon Glass | c2f9107 | 2014-08-28 09:43:39 -0600 | [diff] [blame] | 412 | return 0 |