git.sur5r.net Git - u-boot/blob - tools/moveconfig.py

   1 #!/usr/bin/env python2
   2 #
   3 # Author: Masahiro Yamada <yamada.masahiro@socionext.com>
   4 #
   5 # SPDX-License-Identifier:      GPL-2.0+
   6 #
   7
   8 """
   9 Move config options from headers to defconfig files.
  10
  11 Since Kconfig was introduced to U-Boot, we have worked on moving
  12 config options from headers to Kconfig (defconfig).
  13
  14 This tool intends to help this tremendous work.
  15
  16
  17 Usage
  18 -----
  19
  20 First, you must edit the Kconfig to add the menu entries for the configs
  21 you are moving.
  22
  23 And then run this tool giving CONFIG names you want to move.
  24 For example, if you want to move CONFIG_CMD_USB and CONFIG_SYS_TEXT_BASE,
  25 simply type as follows:
  26
  27   $ tools/moveconfig.py CONFIG_CMD_USB CONFIG_SYS_TEXT_BASE
  28
  29 The tool walks through all the defconfig files and move the given CONFIGs.
  30
  31 The log is also displayed on the terminal.
  32
  33 The log is printed for each defconfig as follows:
  34
  35 <defconfig_name>
  36     <action1>
  37     <action2>
  38     <action3>
  39     ...
  40
  41 <defconfig_name> is the name of the defconfig.
  42
  43 <action*> shows what the tool did for that defconfig.
  44 It looks like one of the followings:
  45
  46  - Move 'CONFIG_... '
  47    This config option was moved to the defconfig
  48
  49  - CONFIG_... is not defined in Kconfig.  Do nothing.
  50    The entry for this CONFIG was not found in Kconfig.
  51    There are two common cases:
  52      - You forgot to create an entry for the CONFIG before running
  53        this tool, or made a typo in a CONFIG passed to this tool.
  54      - The entry was hidden due to unmet 'depends on'.
  55        This is correct behavior.
  56
  57  - 'CONFIG_...' is the same as the define in Kconfig.  Do nothing.
  58    The define in the config header matched the one in Kconfig.
  59    We do not need to touch it.
  60
  61  - Undefined.  Do nothing.
  62    This config option was not found in the config header.
  63    Nothing to do.
  64
  65  - Compiler is missing.  Do nothing.
  66    The compiler specified for this architecture was not found
  67    in your PATH environment.
  68    (If -e option is passed, the tool exits immediately.)
  69
  70  - Failed to process.
  71    An error occurred during processing this defconfig.  Skipped.
  72    (If -e option is passed, the tool exits immediately on error.)
  73
  74 Finally, you will be asked, Clean up headers? [y/n]:
  75
  76 If you say 'y' here, the unnecessary config defines are removed
  77 from the config headers (include/configs/*.h).
  78 It just uses the regex method, so you should not rely on it.
  79 Just in case, please do 'git diff' to see what happened.
  80
  81
  82 How does it work?
  83 -----------------
  84
  85 This tool runs configuration and builds include/autoconf.mk for every
  86 defconfig.  The config options defined in Kconfig appear in the .config
  87 file (unless they are hidden because of unmet dependency.)
  88 On the other hand, the config options defined by board headers are seen
  89 in include/autoconf.mk.  The tool looks for the specified options in both
  90 of them to decide the appropriate action for the options.  If the given
  91 config option is found in the .config, but its value does not match the
  92 one from the board header, the config option in the .config is replaced
  93 with the define in the board header.  Then, the .config is synced by
  94 "make savedefconfig" and the defconfig is updated with it.
  95
  96 For faster processing, this tool handles multi-threading.  It creates
  97 separate build directories where the out-of-tree build is run.  The
  98 temporary build directories are automatically created and deleted as
  99 needed.  The number of threads are chosen based on the number of the CPU
 100 cores of your system although you can change it via -j (--jobs) option.
 101
 102
 103 Toolchains
 104 ----------
 105
 106 Appropriate toolchain are necessary to generate include/autoconf.mk
 107 for all the architectures supported by U-Boot.  Most of them are available
 108 at the kernel.org site, some are not provided by kernel.org.
 109
 110 The default per-arch CROSS_COMPILE used by this tool is specified by
 111 the list below, CROSS_COMPILE.  You may wish to update the list to
 112 use your own.  Instead of modifying the list directly, you can give
 113 them via environments.
 114
 115
 116 Available options
 117 -----------------
 118
 119  -c, --color
 120    Surround each portion of the log with escape sequences to display it
 121    in color on the terminal.
 122
 123  -d, --defconfigs
 124   Specify a file containing a list of defconfigs to move
 125
 126  -n, --dry-run
 127    Perform a trial run that does not make any changes.  It is useful to
 128    see what is going to happen before one actually runs it.
 129
 130  -e, --exit-on-error
 131    Exit immediately if Make exits with a non-zero status while processing
 132    a defconfig file.
 133
 134  -H, --headers-only
 135    Only cleanup the headers; skip the defconfig processing
 136
 137  -j, --jobs
 138    Specify the number of threads to run simultaneously.  If not specified,
 139    the number of threads is the same as the number of CPU cores.
 140
 141  -v, --verbose
 142    Show any build errors as boards are built
 143
 144 To see the complete list of supported options, run
 145
 146   $ tools/moveconfig.py -h
 147
 148 """
 149
 150 import fnmatch
 151 import multiprocessing
 152 import optparse
 153 import os
 154 import re
 155 import shutil
 156 import subprocess
 157 import sys
 158 import tempfile
 159 import time
 160
 161 SHOW_GNU_MAKE = 'scripts/show-gnu-make'
 162 SLEEP_TIME=0.03
 163
 164 # Here is the list of cross-tools I use.
 165 # Most of them are available at kernel.org
 166 # (https://www.kernel.org/pub/tools/crosstool/files/bin/), except the followings:
 167 # arc: https://github.com/foss-for-synopsys-dwc-arc-processors/toolchain/releases
 168 # blackfin: http://sourceforge.net/projects/adi-toolchain/files/
 169 # nds32: http://osdk.andestech.com/packages/nds32le-linux-glibc-v1.tgz
 170 # nios2: https://sourcery.mentor.com/GNUToolchain/subscription42545
 171 # sh: http://sourcery.mentor.com/public/gnu_toolchain/sh-linux-gnu
 172 #
 173 # openrisc kernel.org toolchain is out of date, download latest one from
 174 # http://opencores.org/or1k/OpenRISC_GNU_tool_chain#Prebuilt_versions
 175 CROSS_COMPILE = {
 176     'arc': 'arc-linux-',
 177     'aarch64': 'aarch64-linux-',
 178     'arm': 'arm-unknown-linux-gnueabi-',
 179     'avr32': 'avr32-linux-',
 180     'blackfin': 'bfin-elf-',
 181     'm68k': 'm68k-linux-',
 182     'microblaze': 'microblaze-linux-',
 183     'mips': 'mips-linux-',
 184     'nds32': 'nds32le-linux-',
 185     'nios2': 'nios2-linux-gnu-',
 186     'openrisc': 'or1k-elf-',
 187     'powerpc': 'powerpc-linux-',
 188     'sh': 'sh-linux-gnu-',
 189     'sparc': 'sparc-linux-',
 190     'x86': 'i386-linux-'
 191 }
 192
 193 STATE_IDLE = 0
 194 STATE_DEFCONFIG = 1
 195 STATE_AUTOCONF = 2
 196 STATE_SAVEDEFCONFIG = 3
 197
 198 ACTION_MOVE = 0
 199 ACTION_NO_ENTRY = 1
 200 ACTION_NO_CHANGE = 2
 201
 202 COLOR_BLACK        = '0;30'
 203 COLOR_RED          = '0;31'
 204 COLOR_GREEN        = '0;32'
 205 COLOR_BROWN        = '0;33'
 206 COLOR_BLUE         = '0;34'
 207 COLOR_PURPLE       = '0;35'
 208 COLOR_CYAN         = '0;36'
 209 COLOR_LIGHT_GRAY   = '0;37'
 210 COLOR_DARK_GRAY    = '1;30'
 211 COLOR_LIGHT_RED    = '1;31'
 212 COLOR_LIGHT_GREEN  = '1;32'
 213 COLOR_YELLOW       = '1;33'
 214 COLOR_LIGHT_BLUE   = '1;34'
 215 COLOR_LIGHT_PURPLE = '1;35'
 216 COLOR_LIGHT_CYAN   = '1;36'
 217 COLOR_WHITE        = '1;37'
 218
 219 ### helper functions ###
 220 def get_devnull():
 221     """Get the file object of '/dev/null' device."""
 222     try:
 223         devnull = subprocess.DEVNULL # py3k
 224     except AttributeError:
 225         devnull = open(os.devnull, 'wb')
 226     return devnull
 227
 228 def check_top_directory():
 229     """Exit if we are not at the top of source directory."""
 230     for f in ('README', 'Licenses'):
 231         if not os.path.exists(f):
 232             sys.exit('Please run at the top of source directory.')
 233
 234 def check_clean_directory():
 235     """Exit if the source tree is not clean."""
 236     for f in ('.config', 'include/config'):
 237         if os.path.exists(f):
 238             sys.exit("source tree is not clean, please run 'make mrproper'")
 239
 240 def get_make_cmd():
 241     """Get the command name of GNU Make.
 242
 243     U-Boot needs GNU Make for building, but the command name is not
 244     necessarily "make". (for example, "gmake" on FreeBSD).
 245     Returns the most appropriate command name on your system.
 246     """
 247     process = subprocess.Popen([SHOW_GNU_MAKE], stdout=subprocess.PIPE)
 248     ret = process.communicate()
 249     if process.returncode:
 250         sys.exit('GNU Make not found')
 251     return ret[0].rstrip()
 252
 253 def color_text(color_enabled, color, string):
 254     """Return colored string."""
 255     if color_enabled:
 256         # LF should not be surrounded by the escape sequence.
 257         # Otherwise, additional whitespace or line-feed might be printed.
 258         return '\n'.join([ '\033[' + color + 'm' + s + '\033[0m' if s else ''
 259                            for s in string.split('\n') ])
 260     else:
 261         return string
 262
 263 def update_cross_compile(color_enabled):
 264     """Update per-arch CROSS_COMPILE via environment variables
 265
 266     The default CROSS_COMPILE values are available
 267     in the CROSS_COMPILE list above.
 268
 269     You can override them via environment variables
 270     CROSS_COMPILE_{ARCH}.
 271
 272     For example, if you want to override toolchain prefixes
 273     for ARM and PowerPC, you can do as follows in your shell:
 274
 275     export CROSS_COMPILE_ARM=...
 276     export CROSS_COMPILE_POWERPC=...
 277
 278     Then, this function checks if specified compilers really exist in your
 279     PATH environment.
 280     """
 281     archs = []
 282
 283     for arch in os.listdir('arch'):
 284         if os.path.exists(os.path.join('arch', arch, 'Makefile')):
 285             archs.append(arch)
 286
 287     # arm64 is a special case
 288     archs.append('aarch64')
 289
 290     for arch in archs:
 291         env = 'CROSS_COMPILE_' + arch.upper()
 292         cross_compile = os.environ.get(env)
 293         if not cross_compile:
 294             cross_compile = CROSS_COMPILE.get(arch, '')
 295
 296         for path in os.environ["PATH"].split(os.pathsep):
 297             gcc_path = os.path.join(path, cross_compile + 'gcc')
 298             if os.path.isfile(gcc_path) and os.access(gcc_path, os.X_OK):
 299                 break
 300         else:
 301             print >> sys.stderr, color_text(color_enabled, COLOR_YELLOW,
 302                  'warning: %sgcc: not found in PATH.  %s architecture boards will be skipped'
 303                                             % (cross_compile, arch))
 304             cross_compile = None
 305
 306         CROSS_COMPILE[arch] = cross_compile
 307
 308 def cleanup_one_header(header_path, patterns, dry_run):
 309     """Clean regex-matched lines away from a file.
 310
 311     Arguments:
 312       header_path: path to the cleaned file.
 313       patterns: list of regex patterns.  Any lines matching to these
 314                 patterns are deleted.
 315       dry_run: make no changes, but still display log.
 316     """
 317     with open(header_path) as f:
 318         lines = f.readlines()
 319
 320     matched = []
 321     for i, line in enumerate(lines):
 322         for pattern in patterns:
 323             m = pattern.search(line)
 324             if m:
 325                 print '%s: %s: %s' % (header_path, i + 1, line),
 326                 matched.append(i)
 327                 break
 328
 329     if dry_run or not matched:
 330         return
 331
 332     with open(header_path, 'w') as f:
 333         for i, line in enumerate(lines):
 334             if not i in matched:
 335                 f.write(line)
 336
 337 def cleanup_headers(configs, dry_run):
 338     """Delete config defines from board headers.
 339
 340     Arguments:
 341       configs: A list of CONFIGs to remove.
 342       dry_run: make no changes, but still display log.
 343     """
 344     while True:
 345         choice = raw_input('Clean up headers? [y/n]: ').lower()
 346         print choice
 347         if choice == 'y' or choice == 'n':
 348             break
 349
 350     if choice == 'n':
 351         return
 352
 353     patterns = []
 354     for config in configs:
 355         patterns.append(re.compile(r'#\s*define\s+%s\W' % config))
 356         patterns.append(re.compile(r'#\s*undef\s+%s\W' % config))
 357
 358     for dir in 'include', 'arch', 'board':
 359         for (dirpath, dirnames, filenames) in os.walk(dir):
 360             for filename in filenames:
 361                 if not fnmatch.fnmatch(filename, '*~'):
 362                     cleanup_one_header(os.path.join(dirpath, filename),
 363                                        patterns, dry_run)
 364
 365 ### classes ###
 366 class Progress:
 367
 368     """Progress Indicator"""
 369
 370     def __init__(self, total):
 371         """Create a new progress indicator.
 372
 373         Arguments:
 374           total: A number of defconfig files to process.
 375         """
 376         self.current = 0
 377         self.total = total
 378
 379     def inc(self):
 380         """Increment the number of processed defconfig files."""
 381
 382         self.current += 1
 383
 384     def show(self):
 385         """Display the progress."""
 386         print ' %d defconfigs out of %d\r' % (self.current, self.total),
 387         sys.stdout.flush()
 388
 389 class KconfigParser:
 390
 391     """A parser of .config and include/autoconf.mk."""
 392
 393     re_arch = re.compile(r'CONFIG_SYS_ARCH="(.*)"')
 394     re_cpu = re.compile(r'CONFIG_SYS_CPU="(.*)"')
 395
 396     def __init__(self, configs, options, build_dir):
 397         """Create a new parser.
 398
 399         Arguments:
 400           configs: A list of CONFIGs to move.
 401           options: option flags.
 402           build_dir: Build directory.
 403         """
 404         self.configs = configs
 405         self.options = options
 406         self.dotconfig = os.path.join(build_dir, '.config')
 407         self.autoconf = os.path.join(build_dir, 'include', 'autoconf.mk')
 408         self.config_autoconf = os.path.join(build_dir, 'include', 'config',
 409                                             'auto.conf')
 410
 411     def get_cross_compile(self):
 412         """Parse .config file and return CROSS_COMPILE.
 413
 414         Returns:
 415           A string storing the compiler prefix for the architecture.
 416           Return a NULL string for architectures that do not require
 417           compiler prefix (Sandbox and native build is the case).
 418           Return None if the specified compiler is missing in your PATH.
 419           Caller should distinguish '' and None.
 420         """
 421         arch = ''
 422         cpu = ''
 423         for line in open(self.dotconfig):
 424             m = self.re_arch.match(line)
 425             if m:
 426                 arch = m.group(1)
 427                 continue
 428             m = self.re_cpu.match(line)
 429             if m:
 430                 cpu = m.group(1)
 431
 432         if not arch:
 433             return None
 434
 435         # fix-up for aarch64
 436         if arch == 'arm' and cpu == 'armv8':
 437             arch = 'aarch64'
 438
 439         return CROSS_COMPILE.get(arch, None)
 440
 441     def parse_one_config(self, config, dotconfig_lines, autoconf_lines):
 442         """Parse .config, defconfig, include/autoconf.mk for one config.
 443
 444         This function looks for the config options in the lines from
 445         defconfig, .config, and include/autoconf.mk in order to decide
 446         which action should be taken for this defconfig.
 447
 448         Arguments:
 449           config: CONFIG name to parse.
 450           dotconfig_lines: lines from the .config file.
 451           autoconf_lines: lines from the include/autoconf.mk file.
 452
 453         Returns:
 454           A tupple of the action for this defconfig and the line
 455           matched for the config.
 456         """
 457         not_set = '# %s is not set' % config
 458
 459         for line in dotconfig_lines:
 460             line = line.rstrip()
 461             if line.startswith(config + '=') or line == not_set:
 462                 old_val = line
 463                 break
 464         else:
 465             return (ACTION_NO_ENTRY, config)
 466
 467         for line in autoconf_lines:
 468             line = line.rstrip()
 469             if line.startswith(config + '='):
 470                 new_val = line
 471                 break
 472         else:
 473             new_val = not_set
 474
 475         if old_val == new_val:
 476             return (ACTION_NO_CHANGE, new_val)
 477
 478         # If this CONFIG is neither bool nor trisate
 479         if old_val[-2:] != '=y' and old_val[-2:] != '=m' and old_val != not_set:
 480             # tools/scripts/define2mk.sed changes '1' to 'y'.
 481             # This is a problem if the CONFIG is int type.
 482             # Check the type in Kconfig and handle it correctly.
 483             if new_val[-2:] == '=y':
 484                 new_val = new_val[:-1] + '1'
 485
 486         return (ACTION_MOVE, new_val)
 487
 488     def update_dotconfig(self):
 489         """Parse files for the config options and update the .config.
 490
 491         This function parses the generated .config and include/autoconf.mk
 492         searching the target options.
 493         Move the config option(s) to the .config as needed.
 494
 495         Arguments:
 496           defconfig: defconfig name.
 497
 498         Returns:
 499           Return a tuple of (updated flag, log string).
 500           The "updated flag" is True if the .config was updated, False
 501           otherwise.  The "log string" shows what happend to the .config.
 502         """
 503
 504         results = []
 505         updated = False
 506
 507         with open(self.dotconfig) as f:
 508             dotconfig_lines = f.readlines()
 509
 510         with open(self.autoconf) as f:
 511             autoconf_lines = f.readlines()
 512
 513         for config in self.configs:
 514             result = self.parse_one_config(config, dotconfig_lines,
 515                                            autoconf_lines)
 516             results.append(result)
 517
 518         log = ''
 519
 520         for (action, value) in results:
 521             if action == ACTION_MOVE:
 522                 actlog = "Move '%s'" % value
 523                 log_color = COLOR_LIGHT_GREEN
 524             elif action == ACTION_NO_ENTRY:
 525                 actlog = "%s is not defined in Kconfig.  Do nothing." % value
 526                 log_color = COLOR_LIGHT_BLUE
 527             elif action == ACTION_NO_CHANGE:
 528                 actlog = "'%s' is the same as the define in Kconfig.  Do nothing." \
 529                          % value
 530                 log_color = COLOR_LIGHT_PURPLE
 531             else:
 532                 sys.exit("Internal Error. This should not happen.")
 533
 534             log += color_text(self.options.color, log_color, actlog) + '\n'
 535
 536         with open(self.dotconfig, 'a') as f:
 537             for (action, value) in results:
 538                 if action == ACTION_MOVE:
 539                     f.write(value + '\n')
 540                     updated = True
 541
 542         os.remove(self.config_autoconf)
 543         os.remove(self.autoconf)
 544
 545         return (updated, log)
 546
 547 class Slot:
 548
 549     """A slot to store a subprocess.
 550
 551     Each instance of this class handles one subprocess.
 552     This class is useful to control multiple threads
 553     for faster processing.
 554     """
 555
 556     def __init__(self, configs, options, progress, devnull, make_cmd):
 557         """Create a new process slot.
 558
 559         Arguments:
 560           configs: A list of CONFIGs to move.
 561           options: option flags.
 562           progress: A progress indicator.
 563           devnull: A file object of '/dev/null'.
 564           make_cmd: command name of GNU Make.
 565         """
 566         self.options = options
 567         self.progress = progress
 568         self.build_dir = tempfile.mkdtemp()
 569         self.devnull = devnull
 570         self.make_cmd = (make_cmd, 'O=' + self.build_dir)
 571         self.parser = KconfigParser(configs, options, self.build_dir)
 572         self.state = STATE_IDLE
 573         self.failed_boards = []
 574
 575     def __del__(self):
 576         """Delete the working directory
 577
 578         This function makes sure the temporary directory is cleaned away
 579         even if Python suddenly dies due to error.  It should be done in here
 580         because it is guranteed the destructor is always invoked when the
 581         instance of the class gets unreferenced.
 582
 583         If the subprocess is still running, wait until it finishes.
 584         """
 585         if self.state != STATE_IDLE:
 586             while self.ps.poll() == None:
 587                 pass
 588         shutil.rmtree(self.build_dir)
 589
 590     def add(self, defconfig):
 591         """Assign a new subprocess for defconfig and add it to the slot.
 592
 593         If the slot is vacant, create a new subprocess for processing the
 594         given defconfig and add it to the slot.  Just returns False if
 595         the slot is occupied (i.e. the current subprocess is still running).
 596
 597         Arguments:
 598           defconfig: defconfig name.
 599
 600         Returns:
 601           Return True on success or False on failure
 602         """
 603         if self.state != STATE_IDLE:
 604             return False
 605         cmd = list(self.make_cmd)
 606         cmd.append(defconfig)
 607         self.ps = subprocess.Popen(cmd, stdout=self.devnull,
 608                                    stderr=subprocess.PIPE)
 609         self.defconfig = defconfig
 610         self.state = STATE_DEFCONFIG
 611         self.log = ''
 612         return True
 613
 614     def poll(self):
 615         """Check the status of the subprocess and handle it as needed.
 616
 617         Returns True if the slot is vacant (i.e. in idle state).
 618         If the configuration is successfully finished, assign a new
 619         subprocess to build include/autoconf.mk.
 620         If include/autoconf.mk is generated, invoke the parser to
 621         parse the .config and the include/autoconf.mk, moving
 622         config options to the .config as needed.
 623         If the .config was updated, run "make savedefconfig" to sync
 624         it, update the original defconfig, and then set the slot back
 625         to the idle state.
 626
 627         Returns:
 628           Return True if the subprocess is terminated, False otherwise
 629         """
 630         if self.state == STATE_IDLE:
 631             return True
 632
 633         if self.ps.poll() == None:
 634             return False
 635
 636         if self.ps.poll() != 0:
 637             self.log += color_text(self.options.color, COLOR_LIGHT_RED,
 638                                    "Failed to process.\n")
 639             if self.options.verbose:
 640                 self.log += color_text(self.options.color, COLOR_LIGHT_CYAN,
 641                                        self.ps.stderr.read())
 642             self.finish(False)
 643             return True
 644
 645         if self.state == STATE_AUTOCONF:
 646             (updated, log) = self.parser.update_dotconfig()
 647             self.log += log
 648
 649             if not updated:
 650                 self.finish(True)
 651                 return True
 652             """Save off the defconfig in a consistent way"""
 653             cmd = list(self.make_cmd)
 654             cmd.append('savedefconfig')
 655             self.ps = subprocess.Popen(cmd, stdout=self.devnull,
 656                                        stderr=subprocess.PIPE)
 657             self.state = STATE_SAVEDEFCONFIG
 658             return False
 659
 660         if self.state == STATE_SAVEDEFCONFIG:
 661             if not self.options.dry_run:
 662                 shutil.move(os.path.join(self.build_dir, 'defconfig'),
 663                             os.path.join('configs', self.defconfig))
 664             self.finish(True)
 665             return True
 666
 667         self.cross_compile = self.parser.get_cross_compile()
 668         if self.cross_compile is None:
 669             self.log += color_text(self.options.color, COLOR_YELLOW,
 670                                    "Compiler is missing.  Do nothing.\n")
 671             self.finish(False)
 672             return True
 673
 674         cmd = list(self.make_cmd)
 675         if self.cross_compile:
 676             cmd.append('CROSS_COMPILE=%s' % self.cross_compile)
 677         cmd.append('KCONFIG_IGNORE_DUPLICATES=1')
 678         cmd.append('include/config/auto.conf')
 679         self.ps = subprocess.Popen(cmd, stdout=self.devnull,
 680                                    stderr=subprocess.PIPE)
 681         self.state = STATE_AUTOCONF
 682         return False
 683
 684     def finish(self, success):
 685         """Display log along with progress and go to the idle state.
 686
 687         Arguments:
 688           success: Should be True when the defconfig was processed
 689                    successfully, or False when it fails.
 690         """
 691         # output at least 30 characters to hide the "* defconfigs out of *".
 692         log = self.defconfig.ljust(30) + '\n'
 693
 694         log += '\n'.join([ '    ' + s for s in self.log.split('\n') ])
 695         # Some threads are running in parallel.
 696         # Print log atomically to not mix up logs from different threads.
 697         print >> (sys.stdout if success else sys.stderr), log
 698
 699         if not success:
 700             if self.options.exit_on_error:
 701                 sys.exit("Exit on error.")
 702             # If --exit-on-error flag is not set, skip this board and continue.
 703             # Record the failed board.
 704             self.failed_boards.append(self.defconfig)
 705
 706         self.progress.inc()
 707         self.progress.show()
 708         self.state = STATE_IDLE
 709
 710     def get_failed_boards(self):
 711         """Returns a list of failed boards (defconfigs) in this slot.
 712         """
 713         return self.failed_boards
 714
 715 class Slots:
 716
 717     """Controller of the array of subprocess slots."""
 718
 719     def __init__(self, configs, options, progress):
 720         """Create a new slots controller.
 721
 722         Arguments:
 723           configs: A list of CONFIGs to move.
 724           options: option flags.
 725           progress: A progress indicator.
 726         """
 727         self.options = options
 728         self.slots = []
 729         devnull = get_devnull()
 730         make_cmd = get_make_cmd()
 731         for i in range(options.jobs):
 732             self.slots.append(Slot(configs, options, progress, devnull,
 733                                    make_cmd))
 734
 735     def add(self, defconfig):
 736         """Add a new subprocess if a vacant slot is found.
 737
 738         Arguments:
 739           defconfig: defconfig name to be put into.
 740
 741         Returns:
 742           Return True on success or False on failure
 743         """
 744         for slot in self.slots:
 745             if slot.add(defconfig):
 746                 return True
 747         return False
 748
 749     def available(self):
 750         """Check if there is a vacant slot.
 751
 752         Returns:
 753           Return True if at lease one vacant slot is found, False otherwise.
 754         """
 755         for slot in self.slots:
 756             if slot.poll():
 757                 return True
 758         return False
 759
 760     def empty(self):
 761         """Check if all slots are vacant.
 762
 763         Returns:
 764           Return True if all the slots are vacant, False otherwise.
 765         """
 766         ret = True
 767         for slot in self.slots:
 768             if not slot.poll():
 769                 ret = False
 770         return ret
 771
 772     def show_failed_boards(self):
 773         """Display all of the failed boards (defconfigs)."""
 774         failed_boards = []
 775
 776         for slot in self.slots:
 777             failed_boards += slot.get_failed_boards()
 778
 779         if len(failed_boards) > 0:
 780             msg = [ "The following boards were not processed due to error:" ]
 781             msg += failed_boards
 782             for line in msg:
 783                 print >> sys.stderr, color_text(self.options.color,
 784                                                 COLOR_LIGHT_RED, line)
 785
 786             with open('moveconfig.failed', 'w') as f:
 787                 for board in failed_boards:
 788                     f.write(board + '\n')
 789
 790 def move_config(configs, options):
 791     """Move config options to defconfig files.
 792
 793     Arguments:
 794       configs: A list of CONFIGs to move.
 795       options: option flags
 796     """
 797     if len(configs) == 0:
 798         print 'Nothing to do. exit.'
 799         sys.exit(0)
 800
 801     print 'Move %s (jobs: %d)' % (', '.join(configs), options.jobs)
 802
 803     if options.defconfigs:
 804         defconfigs = [line.strip() for line in open(options.defconfigs)]
 805         for i, defconfig in enumerate(defconfigs):
 806             if not defconfig.endswith('_defconfig'):
 807                 defconfigs[i] = defconfig + '_defconfig'
 808             if not os.path.exists(os.path.join('configs', defconfigs[i])):
 809                 sys.exit('%s - defconfig does not exist. Stopping.' %
 810                          defconfigs[i])
 811     else:
 812         # All the defconfig files to be processed
 813         defconfigs = []
 814         for (dirpath, dirnames, filenames) in os.walk('configs'):
 815             dirpath = dirpath[len('configs') + 1:]
 816             for filename in fnmatch.filter(filenames, '*_defconfig'):
 817                 defconfigs.append(os.path.join(dirpath, filename))
 818
 819     progress = Progress(len(defconfigs))
 820     slots = Slots(configs, options, progress)
 821
 822     # Main loop to process defconfig files:
 823     #  Add a new subprocess into a vacant slot.
 824     #  Sleep if there is no available slot.
 825     for defconfig in defconfigs:
 826         while not slots.add(defconfig):
 827             while not slots.available():
 828                 # No available slot: sleep for a while
 829                 time.sleep(SLEEP_TIME)
 830
 831     # wait until all the subprocesses finish
 832     while not slots.empty():
 833         time.sleep(SLEEP_TIME)
 834
 835     print ''
 836     slots.show_failed_boards()
 837
 838 def main():
 839     try:
 840         cpu_count = multiprocessing.cpu_count()
 841     except NotImplementedError:
 842         cpu_count = 1
 843
 844     parser = optparse.OptionParser()
 845     # Add options here
 846     parser.add_option('-c', '--color', action='store_true', default=False,
 847                       help='display the log in color')
 848     parser.add_option('-d', '--defconfigs', type='string',
 849                       help='a file containing a list of defconfigs to move')
 850     parser.add_option('-n', '--dry-run', action='store_true', default=False,
 851                       help='perform a trial run (show log with no changes)')
 852     parser.add_option('-e', '--exit-on-error', action='store_true',
 853                       default=False,
 854                       help='exit immediately on any error')
 855     parser.add_option('-H', '--headers-only', dest='cleanup_headers_only',
 856                       action='store_true', default=False,
 857                       help='only cleanup the headers')
 858     parser.add_option('-j', '--jobs', type='int', default=cpu_count,
 859                       help='the number of jobs to run simultaneously')
 860     parser.add_option('-v', '--verbose', action='store_true', default=False,
 861                       help='show any build errors as boards are built')
 862     parser.usage += ' CONFIG ...'
 863
 864     (options, configs) = parser.parse_args()
 865
 866     if len(configs) == 0:
 867         parser.print_usage()
 868         sys.exit(1)
 869
 870     # prefix the option name with CONFIG_ if missing
 871     configs = [ config if config.startswith('CONFIG_') else 'CONFIG_' + config
 872                 for config in configs ]
 873
 874     check_top_directory()
 875
 876     check_clean_directory()
 877
 878     update_cross_compile(options.color)
 879
 880     if not options.cleanup_headers_only:
 881         move_config(configs, options)
 882
 883     cleanup_headers(configs, options.dry_run)
 884
 885 if __name__ == '__main__':
 886     main()