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