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 log string
 500         """
 501
 502         results = []
 503
 504         with open(self.dotconfig) as f:
 505             dotconfig_lines = f.readlines()
 506
 507         with open(self.autoconf) as f:
 508             autoconf_lines = f.readlines()
 509
 510         for config in self.configs:
 511             result = self.parse_one_config(config, dotconfig_lines,
 512                                            autoconf_lines)
 513             results.append(result)
 514
 515         log = ''
 516
 517         for (action, value) in results:
 518             if action == ACTION_MOVE:
 519                 actlog = "Move '%s'" % value
 520                 log_color = COLOR_LIGHT_GREEN
 521             elif action == ACTION_NO_ENTRY:
 522                 actlog = "%s is not defined in Kconfig.  Do nothing." % value
 523                 log_color = COLOR_LIGHT_BLUE
 524             elif action == ACTION_NO_CHANGE:
 525                 actlog = "'%s' is the same as the define in Kconfig.  Do nothing." \
 526                          % value
 527                 log_color = COLOR_LIGHT_PURPLE
 528             else:
 529                 sys.exit("Internal Error. This should not happen.")
 530
 531             log += color_text(self.options.color, log_color, actlog) + '\n'
 532
 533         with open(self.dotconfig, 'a') as f:
 534             for (action, value) in results:
 535                 if action == ACTION_MOVE:
 536                     f.write(value + '\n')
 537
 538         os.remove(self.config_autoconf)
 539         os.remove(self.autoconf)
 540
 541         return log
 542
 543 class Slot:
 544
 545     """A slot to store a subprocess.
 546
 547     Each instance of this class handles one subprocess.
 548     This class is useful to control multiple threads
 549     for faster processing.
 550     """
 551
 552     def __init__(self, configs, options, progress, devnull, make_cmd):
 553         """Create a new process slot.
 554
 555         Arguments:
 556           configs: A list of CONFIGs to move.
 557           options: option flags.
 558           progress: A progress indicator.
 559           devnull: A file object of '/dev/null'.
 560           make_cmd: command name of GNU Make.
 561         """
 562         self.options = options
 563         self.progress = progress
 564         self.build_dir = tempfile.mkdtemp()
 565         self.devnull = devnull
 566         self.make_cmd = (make_cmd, 'O=' + self.build_dir)
 567         self.parser = KconfigParser(configs, options, self.build_dir)
 568         self.state = STATE_IDLE
 569         self.failed_boards = []
 570
 571     def __del__(self):
 572         """Delete the working directory
 573
 574         This function makes sure the temporary directory is cleaned away
 575         even if Python suddenly dies due to error.  It should be done in here
 576         because it is guranteed the destructor is always invoked when the
 577         instance of the class gets unreferenced.
 578
 579         If the subprocess is still running, wait until it finishes.
 580         """
 581         if self.state != STATE_IDLE:
 582             while self.ps.poll() == None:
 583                 pass
 584         shutil.rmtree(self.build_dir)
 585
 586     def add(self, defconfig):
 587         """Assign a new subprocess for defconfig and add it to the slot.
 588
 589         If the slot is vacant, create a new subprocess for processing the
 590         given defconfig and add it to the slot.  Just returns False if
 591         the slot is occupied (i.e. the current subprocess is still running).
 592
 593         Arguments:
 594           defconfig: defconfig name.
 595
 596         Returns:
 597           Return True on success or False on failure
 598         """
 599         if self.state != STATE_IDLE:
 600             return False
 601         cmd = list(self.make_cmd)
 602         cmd.append(defconfig)
 603         self.ps = subprocess.Popen(cmd, stdout=self.devnull,
 604                                    stderr=subprocess.PIPE)
 605         self.defconfig = defconfig
 606         self.state = STATE_DEFCONFIG
 607         self.log = ''
 608         return True
 609
 610     def poll(self):
 611         """Check the status of the subprocess and handle it as needed.
 612
 613         Returns True if the slot is vacant (i.e. in idle state).
 614         If the configuration is successfully finished, assign a new
 615         subprocess to build include/autoconf.mk.
 616         If include/autoconf.mk is generated, invoke the parser to
 617         parse the .config and the include/autoconf.mk, and then set the
 618         slot back to the idle state.
 619
 620         Returns:
 621           Return True if the subprocess is terminated, False otherwise
 622         """
 623         if self.state == STATE_IDLE:
 624             return True
 625
 626         if self.ps.poll() == None:
 627             return False
 628
 629         if self.ps.poll() != 0:
 630             self.log += color_text(self.options.color, COLOR_LIGHT_RED,
 631                                    "Failed to process.\n")
 632             if self.options.verbose:
 633                 self.log += color_text(self.options.color, COLOR_LIGHT_CYAN,
 634                                        self.ps.stderr.read())
 635             self.show_log(sys.stderr)
 636             if self.options.exit_on_error:
 637                 sys.exit("Exit on error.")
 638             # If --exit-on-error flag is not set, skip this board and continue.
 639             # Record the failed board.
 640             self.failed_boards.append(self.defconfig)
 641             self.state = STATE_IDLE
 642             return True
 643
 644         if self.state == STATE_AUTOCONF:
 645             self.log += self.parser.update_dotconfig()
 646
 647             """Save off the defconfig in a consistent way"""
 648             cmd = list(self.make_cmd)
 649             cmd.append('savedefconfig')
 650             self.ps = subprocess.Popen(cmd, stdout=self.devnull,
 651                                        stderr=subprocess.PIPE)
 652             self.state = STATE_SAVEDEFCONFIG
 653             return False
 654
 655         if self.state == STATE_SAVEDEFCONFIG:
 656             if not self.options.dry_run:
 657                 shutil.move(os.path.join(self.build_dir, 'defconfig'),
 658                             os.path.join('configs', self.defconfig))
 659             self.show_log()
 660             self.state = STATE_IDLE
 661             return True
 662
 663         self.cross_compile = self.parser.get_cross_compile()
 664         if self.cross_compile is None:
 665             self.log += color_text(self.options.color, COLOR_YELLOW,
 666                                    "Compiler is missing.  Do nothing.\n")
 667             self.show_log(sys.stderr)
 668             if self.options.exit_on_error:
 669                 sys.exit("Exit on error.")
 670             # If --exit-on-error flag is not set, skip this board and continue.
 671             # Record the failed board.
 672             self.failed_boards.append(self.defconfig)
 673             self.state = STATE_IDLE
 674             return True
 675
 676         cmd = list(self.make_cmd)
 677         if self.cross_compile:
 678             cmd.append('CROSS_COMPILE=%s' % self.cross_compile)
 679         cmd.append('KCONFIG_IGNORE_DUPLICATES=1')
 680         cmd.append('include/config/auto.conf')
 681         self.ps = subprocess.Popen(cmd, stdout=self.devnull,
 682                                    stderr=subprocess.PIPE)
 683         self.state = STATE_AUTOCONF
 684         return False
 685
 686     def show_log(self, file=sys.stdout):
 687         """Display log along with progress.
 688
 689         Arguments:
 690           file: A file object to which the log string is sent.
 691         """
 692         # output at least 30 characters to hide the "* defconfigs out of *".
 693         log = self.defconfig.ljust(30) + '\n'
 694
 695         log += '\n'.join([ '    ' + s for s in self.log.split('\n') ])
 696         # Some threads are running in parallel.
 697         # Print log atomically to not mix up logs from different threads.
 698         print >> file, log
 699         self.progress.inc()
 700         self.progress.show()
 701
 702     def get_failed_boards(self):
 703         """Returns a list of failed boards (defconfigs) in this slot.
 704         """
 705         return self.failed_boards
 706
 707 class Slots:
 708
 709     """Controller of the array of subprocess slots."""
 710
 711     def __init__(self, configs, options, progress):
 712         """Create a new slots controller.
 713
 714         Arguments:
 715           configs: A list of CONFIGs to move.
 716           options: option flags.
 717           progress: A progress indicator.
 718         """
 719         self.options = options
 720         self.slots = []
 721         devnull = get_devnull()
 722         make_cmd = get_make_cmd()
 723         for i in range(options.jobs):
 724             self.slots.append(Slot(configs, options, progress, devnull,
 725                                    make_cmd))
 726
 727     def add(self, defconfig):
 728         """Add a new subprocess if a vacant slot is found.
 729
 730         Arguments:
 731           defconfig: defconfig name to be put into.
 732
 733         Returns:
 734           Return True on success or False on failure
 735         """
 736         for slot in self.slots:
 737             if slot.add(defconfig):
 738                 return True
 739         return False
 740
 741     def available(self):
 742         """Check if there is a vacant slot.
 743
 744         Returns:
 745           Return True if at lease one vacant slot is found, False otherwise.
 746         """
 747         for slot in self.slots:
 748             if slot.poll():
 749                 return True
 750         return False
 751
 752     def empty(self):
 753         """Check if all slots are vacant.
 754
 755         Returns:
 756           Return True if all the slots are vacant, False otherwise.
 757         """
 758         ret = True
 759         for slot in self.slots:
 760             if not slot.poll():
 761                 ret = False
 762         return ret
 763
 764     def show_failed_boards(self):
 765         """Display all of the failed boards (defconfigs)."""
 766         failed_boards = []
 767
 768         for slot in self.slots:
 769             failed_boards += slot.get_failed_boards()
 770
 771         if len(failed_boards) > 0:
 772             msg = [ "The following boards were not processed due to error:" ]
 773             msg += failed_boards
 774             for line in msg:
 775                 print >> sys.stderr, color_text(self.options.color,
 776                                                 COLOR_LIGHT_RED, line)
 777
 778             with open('moveconfig.failed', 'w') as f:
 779                 for board in failed_boards:
 780                     f.write(board + '\n')
 781
 782 def move_config(configs, options):
 783     """Move config options to defconfig files.
 784
 785     Arguments:
 786       configs: A list of CONFIGs to move.
 787       options: option flags
 788     """
 789     if len(configs) == 0:
 790         print 'Nothing to do. exit.'
 791         sys.exit(0)
 792
 793     print 'Move %s (jobs: %d)' % (', '.join(configs), options.jobs)
 794
 795     if options.defconfigs:
 796         defconfigs = [line.strip() for line in open(options.defconfigs)]
 797         for i, defconfig in enumerate(defconfigs):
 798             if not defconfig.endswith('_defconfig'):
 799                 defconfigs[i] = defconfig + '_defconfig'
 800             if not os.path.exists(os.path.join('configs', defconfigs[i])):
 801                 sys.exit('%s - defconfig does not exist. Stopping.' %
 802                          defconfigs[i])
 803     else:
 804         # All the defconfig files to be processed
 805         defconfigs = []
 806         for (dirpath, dirnames, filenames) in os.walk('configs'):
 807             dirpath = dirpath[len('configs') + 1:]
 808             for filename in fnmatch.filter(filenames, '*_defconfig'):
 809                 defconfigs.append(os.path.join(dirpath, filename))
 810
 811     progress = Progress(len(defconfigs))
 812     slots = Slots(configs, options, progress)
 813
 814     # Main loop to process defconfig files:
 815     #  Add a new subprocess into a vacant slot.
 816     #  Sleep if there is no available slot.
 817     for defconfig in defconfigs:
 818         while not slots.add(defconfig):
 819             while not slots.available():
 820                 # No available slot: sleep for a while
 821                 time.sleep(SLEEP_TIME)
 822
 823     # wait until all the subprocesses finish
 824     while not slots.empty():
 825         time.sleep(SLEEP_TIME)
 826
 827     print ''
 828     slots.show_failed_boards()
 829
 830 def main():
 831     try:
 832         cpu_count = multiprocessing.cpu_count()
 833     except NotImplementedError:
 834         cpu_count = 1
 835
 836     parser = optparse.OptionParser()
 837     # Add options here
 838     parser.add_option('-c', '--color', action='store_true', default=False,
 839                       help='display the log in color')
 840     parser.add_option('-d', '--defconfigs', type='string',
 841                       help='a file containing a list of defconfigs to move')
 842     parser.add_option('-n', '--dry-run', action='store_true', default=False,
 843                       help='perform a trial run (show log with no changes)')
 844     parser.add_option('-e', '--exit-on-error', action='store_true',
 845                       default=False,
 846                       help='exit immediately on any error')
 847     parser.add_option('-H', '--headers-only', dest='cleanup_headers_only',
 848                       action='store_true', default=False,
 849                       help='only cleanup the headers')
 850     parser.add_option('-j', '--jobs', type='int', default=cpu_count,
 851                       help='the number of jobs to run simultaneously')
 852     parser.add_option('-v', '--verbose', action='store_true', default=False,
 853                       help='show any build errors as boards are built')
 854     parser.usage += ' CONFIG ...'
 855
 856     (options, configs) = parser.parse_args()
 857
 858     if len(configs) == 0:
 859         parser.print_usage()
 860         sys.exit(1)
 861
 862     # prefix the option name with CONFIG_ if missing
 863     configs = [ config if config.startswith('CONFIG_') else 'CONFIG_' + config
 864                 for config in configs ]
 865
 866     check_top_directory()
 867
 868     check_clean_directory()
 869
 870     update_cross_compile(options.color)
 871
 872     if not options.cleanup_headers_only:
 873         move_config(configs, options)
 874
 875     cleanup_headers(configs, options.dry_run)
 876
 877 if __name__ == '__main__':
 878     main()