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