# SPDX-License-Identifier: GPL-2.0+
# Copyright (c) 2012 The Chromium OS Authors.
# Author: Simon Glass <sjg@chromium.org>
# Author: Masahiro Yamada <yamada.m@jp.panasonic.com>
"""Maintains a list of boards and allows them to be selected"""
from collections import OrderedDict
import errno
import fnmatch
import glob
import multiprocessing
import os
import re
import sys
import tempfile
import time
from buildman import board
from buildman import kconfiglib
from u_boot_pylib.terminal import print_clear, tprint
### constant variables ###
OUTPUT_FILE = 'boards.cfg'
CONFIG_DIR = 'configs'
SLEEP_TIME = 0.03
COMMENT_BLOCK = f'''#
# List of boards
# Automatically generated by {__file__}: don't edit
#
# Status, Arch, CPU, SoC, Vendor, Board, Target, Config, Maintainers
'''
def try_remove(fname):
"""Remove a file ignoring 'No such file or directory' error.
Args:
fname (str): Filename to remove
Raises:
OSError: output file exists but could not be removed
"""
try:
os.remove(fname)
except OSError as exception:
# Ignore 'No such file or directory' error
if exception.errno != errno.ENOENT:
raise
def output_is_new(output, config_dir, srcdir):
"""Check if the output file is up to date.
Looks at defconfig and Kconfig files to make sure none is newer than the
output file. Also ensures that the boards.cfg does not mention any removed
boards.
Args:
output (str): Filename to check
config_dir (str): Directory containing defconfig files
srcdir (str): Directory containing Kconfig and MAINTAINERS files
Returns:
True if the given output file exists and is newer than any of
*_defconfig, MAINTAINERS and Kconfig*. False otherwise.
Raises:
OSError: output file exists but could not be opened
"""
# pylint: disable=too-many-branches
try:
ctime = os.path.getctime(output)
except OSError as exception:
if exception.errno == errno.ENOENT:
# return False on 'No such file or directory' error
return False
raise
for (dirpath, _, filenames) in os.walk(config_dir):
for filename in fnmatch.filter(filenames, '*_defconfig'):
if fnmatch.fnmatch(filename, '.*'):
continue
filepath = os.path.join(dirpath, filename)
if ctime < os.path.getctime(filepath):
return False
for (dirpath, _, filenames) in os.walk(srcdir):
for filename in filenames:
if (fnmatch.fnmatch(filename, '*~') or
not fnmatch.fnmatch(filename, 'Kconfig*') and
not filename == 'MAINTAINERS'):
continue
filepath = os.path.join(dirpath, filename)
if ctime < os.path.getctime(filepath):
return False
# Detect a board that has been removed since the current board database
# was generated
with open(output, encoding="utf-8") as inf:
for line in inf:
if 'Options,' in line:
return False
if line[0] == '#' or line == '\n':
continue
defconfig = line.split()[6] + '_defconfig'
if not os.path.exists(os.path.join(config_dir, defconfig)):
return False
return True
class Expr:
"""A single regular expression for matching boards to build"""
def __init__(self, expr):
"""Set up a new Expr object.
Args:
expr (str): String containing regular expression to store
"""
self._expr = expr
self._re = re.compile(expr)
def matches(self, props):
"""Check if any of the properties match the regular expression.
Args:
props (list of str): List of properties to check
Returns:
True if any of the properties match the regular expression
"""
for prop in props:
if self._re.match(prop):
return True
return False
def __str__(self):
return self._expr
class Term:
"""A list of expressions each of which must match with properties.
This provides a list of 'AND' expressions, meaning that each must
match the board properties for that board to be built.
"""
def __init__(self):
self._expr_list = []
self._board_count = 0
def add_expr(self, expr):
"""Add an Expr object to the list to check.
Args:
expr (Expr): New Expr object to add to the list of those that must
match for a board to be built.
"""
self._expr_list.append(Expr(expr))
def __str__(self):
"""Return some sort of useful string describing the term"""
return '&'.join([str(expr) for expr in self._expr_list])
def matches(self, props):
"""Check if any of the properties match this term
Each of the expressions in the term is checked. All must match.
Args:
props (list of str): List of properties to check
Returns:
True if all of the expressions in the Term match, else False
"""
for expr in self._expr_list:
if not expr.matches(props):
return False
return True
class KconfigScanner:
"""Kconfig scanner."""
### constant variable only used in this class ###
_SYMBOL_TABLE = {
'arch' : 'SYS_ARCH',
'cpu' : 'SYS_CPU',
'soc' : 'SYS_SOC',
'vendor' : 'SYS_VENDOR',
'board' : 'SYS_BOARD',
'config' : 'SYS_CONFIG_NAME',
# 'target' is added later
}
def __init__(self, srctree):
"""Scan all the Kconfig files and create a Kconfig object."""
# Define environment variables referenced from Kconfig
os.environ['srctree'] = srctree
os.environ['UBOOTVERSION'] = 'dummy'
os.environ['KCONFIG_OBJDIR'] = ''
self._tmpfile = None
self._conf = kconfiglib.Kconfig(warn=False)
def __del__(self):
"""Delete a leftover temporary file before exit.
The scan() method of this class creates a temporay file and deletes
it on success. If scan() method throws an exception on the way,
the temporary file might be left over. In that case, it should be
deleted in this destructor.
"""
if self._tmpfile:
try_remove(self._tmpfile)
def scan(self, defconfig, warn_targets):
"""Load a defconfig file to obtain board parameters.
Args:
defconfig (str): path to the defconfig file to be processed
warn_targets (bool): True to warn about missing or duplicate
CONFIG_TARGET options
Returns:
tuple: dictionary of board parameters. It has a form of:
{
'arch': <arch_name>,
'cpu': <cpu_name>,
'soc': <soc_name>,
'vendor': <vendor_name>,
'board': <board_name>,
'target': <target_name>,
'config': <config_header_name>,
}
warnings (list of str): list of warnings found
"""
leaf = os.path.basename(defconfig)
expect_target, match, rear = leaf.partition('_defconfig')
assert match and not rear, f'{leaf} : invalid defconfig'
self._conf.load_config(defconfig)
self._tmpfile = None
params = {}
warnings = []
# Get the value of CONFIG_SYS_ARCH, CONFIG_SYS_CPU, ... etc.
# Set '-' if the value is empty.
for key, symbol in list(self._SYMBOL_TABLE.items()):
value = self._conf.syms.get(symbol).str_value
if value:
params[key] = value
else:
params[key] = '-'
# Check there is exactly one TARGET_xxx set
if warn_targets:
target = None
for name, sym in self._conf.syms.items():
if name.startswith('TARGET_') and sym.str_value == 'y':
tname = name[7:].lower()
if target:
warnings.append(
f'WARNING: {leaf}: Duplicate TARGET_xxx: {target} and {tname}')
else:
target = tname
if not target:
cfg_name = expect_target.replace('-', '_').upper()
warnings.append(f'WARNING: {leaf}: No TARGET_{cfg_name} enabled')
params['target'] = expect_target
# fix-up for aarch64
if params['arch'] == 'arm' and params['cpu'] == 'armv8':
params['arch'] = 'aarch64'
# fix-up for riscv
if params['arch'] == 'riscv':
try:
value = self._conf.syms.get('ARCH_RV32I').str_value
except:
value = ''
if value == 'y':
params['arch'] = 'riscv32'
else:
params['arch'] = 'riscv64'
return params, warnings
class MaintainersDatabase:
"""The database of board status and maintainers.
Properties:
database: dict:
key: Board-target name (e.g. 'snow')
value: tuple:
str: Board status (e.g. 'Active')
str: List of maintainers, separated by :
warnings (list of str): List of warnings due to missing status, etc.
"""
def __init__(self):
"""Create an empty database."""
self.database = {}
self.warnings = []
def get_status(self, target):
"""Return the status of the given board.
The board status is generally either 'Active' or 'Orphan'.
Display a warning message and return '-' if status information
is not found.
Args:
target (str): Build-target name
Returns:
str: 'Active', 'Orphan' or '-'.
"""
if not target in self.database:
self.warnings.append(f"WARNING: no status info for '{target}'")
return '-'
tmp = self.database[target][0]
if tmp.startswith('Maintained'):
return 'Active'
if tmp.startswith('Supported'):
return 'Active'
if tmp.startswith('Orphan'):
return 'Orphan'
self.warnings.append(f"WARNING: {tmp}: unknown status for '{target}'")
return '-'
def get_maintainers(self, target):
"""Return the maintainers of the given board.
Args:
target (str): Build-target name
Returns:
str: Maintainers of the board. If the board has two or more
maintainers, they are separated with colons.
"""
entry = self.database.get(target)
if entry:
status, maint_list = entry
if not status.startswith('Orphan'):
if len(maint_list) > 1 or (maint_list and maint_list[0] != '-'):
return ':'.join(maint_list)
self.warnings.append(f"WARNING: no maintainers for '{target}'")
return ''
def parse_file(self, srcdir, fname):
"""Parse a MAINTAINERS file.
Parse a MAINTAINERS file and accumulate board status and maintainers
information in the self.database dict.
defconfig files are used to specify the target, e.g. xxx_defconfig is
used for target 'xxx'. If there is no defconfig file mentioned in the
MAINTAINERS file F: entries, then this function does nothing.
The N: name entries can be used to specify a defconfig file using
wildcards.
Args:
srcdir (str): Directory containing source code (Kconfig files)
fname (str): MAINTAINERS file to be parsed
"""
def add_targets(linenum):
"""Add any new targets
Args:
linenum (int): Current line number
"""
if targets:
for target in targets:
self.database[target] = (status, maintainers)
targets = []
maintainers = []
status = '-'
with open(fname, encoding="utf-8") as inf:
for linenum, line in enumerate(inf):
# Check also commented maintainers
if line[:3] == '#M:':
line = line[1:]
tag, rest = line[:2], line[2:].strip()
if tag == 'M:':
maintainers.append(rest)
elif tag == 'F:':
# expand wildcard and filter by 'configs/*_defconfig'
glob_path = os.path.join(srcdir, rest)
for item in glob.glob(glob_path):
front, match, rear = item.partition('configs/')
if front.endswith('/'):
front = front[:-1]
if front == srcdir and match:
front, match, rear = rear.rpartition('_defconfig')
if match and not rear:
targets.append(front)
elif tag == 'S:':
status = rest
elif tag == 'N:':
# Just scan the configs directory since that's all we care
# about
walk_path = os.walk(os.path.join(srcdir, 'configs'))
for dirpath, _, fnames in walk_path:
for cfg in fnames:
path = os.path.join(dirpath, cfg)[len(srcdir) + 1:]
front, match, rear = path.partition('configs/')
if front or not match:
continue
front, match, rear = rear.rpartition('_defconfig')
# Use this entry if it matches the defconfig file
# without the _defconfig suffix. For example
# 'am335x.*' matches am335x_guardian_defconfig
if match and not rear and re.search(rest, front):
targets.append(front)
elif line == '\n':
add_targets(linenum)
targets = []
maintainers = []
status = '-'
add_targets(linenum)
class Boards:
"""Manage a list of boards."""
def __init__(self):
self._boards = []
def add_board(self, brd):
"""Add a new board to the list.
The board's target member must not already exist in the board list.
Args:
brd (Board): board to add
"""
self._boards.append(brd)
def read_boards(self, fname):
"""Read a list of boards from a board file.
Create a Board object for each and add it to our _boards list.
Args:
fname (str): Filename of boards.cfg file
"""
with open(fname, 'r', encoding='utf-8') as inf:
for line in inf:
if line[0] == '#':
continue
fields = line.split()
if not fields:
continue
for upto, field in enumerate(fields):
if field == '-':
fields[upto] = ''
while len(fields) < 8:
fields.append('')
if len(fields) > 8:
fields = fields[:8]
brd = board.Board(*fields)
self.add_board(brd)
def get_list(self):
"""Return a list of available boards.
Returns:
List of Board objects
"""
return self._boards
def get_dict(self):
"""Build a dictionary containing all the boards.
Returns:
Dictionary:
key is board.target
value is board
"""
board_dict = OrderedDict()
for brd in self._boards:
board_dict[brd.target] = brd
return board_dict
def get_selected_dict(self):
"""Return a dictionary containing the selected boards
Returns:
List of Board objects that are marked selected
"""
board_dict = OrderedDict()
for brd in self._boards:
if brd.build_it:
board_dict[brd.target] = brd
return board_dict
def get_selected(self):
"""Return a list of selected boards
Returns:
List of Board objects that are marked selected
"""
return [brd for brd in self._boards if brd.build_it]
def get_selected_names(self):
"""Return a list of selected boards
Returns:
List of board names that are marked selected
"""
return [brd.target for brd in self._boards if brd.build_it]
@classmethod
def _build_terms(cls, args):
"""Convert command line arguments to a list of terms.
This deals with parsing of the arguments. It handles the '&'
operator, which joins several expressions into a single Term.
For example:
['arm & freescale sandbox', 'tegra']
will produce 3 Terms containing expressions as follows:
arm, freescale
sandbox
tegra
The first Term has two expressions, both of which must match for
a board to be selected.
Args:
args (list of str): List of command line arguments
Returns:
list of Term: A list of Term objects
"""
syms = []
for arg in args:
for word in arg.split():
sym_build = []
for term in word.split('&'):
if term:
sym_build.append(term)
sym_build.append('&')
syms += sym_build[:-1]
terms = []
term = None
oper = None
for sym in syms:
if sym == '&':
oper = sym
elif oper:
term.add_expr(sym)
oper = None
else:
if term:
terms.append(term)
term = Term()
term.add_expr(sym)
if term:
terms.append(term)
return terms
def select_boards(self, args, exclude=None, brds=None):
"""Mark boards selected based on args
Normally either boards (an explicit list of boards) or args (a list of
terms to match against) is used. It is possible to specify both, in
which case they are additive.
If brds and args are both empty, all boards are selected.
Args:
args (list of str): List of strings specifying boards to include,
either named, or by their target, architecture, cpu, vendor or
soc. If empty, all boards are selected.
exclude (list of str): List of boards to exclude, regardless of
'args', or None for none
brds (list of Board): List of boards to build, or None/[] for all
Returns:
Tuple
Dictionary which holds the list of boards which were selected
due to each argument, arranged by argument.
List of errors found
"""
def _check_board(brd):
"""Check whether to include or exclude a board
Checks the various terms and decide whether to build it or not (the
'build_it' variable).
If it is built, add the board to the result[term] list so we know
which term caused it to be built. Add it to result['all'] also.
Keep a list of boards we found in 'found', so we can report boards
which appear in self._boards but not in brds.
Args:
brd (Board): Board to check
"""
matching_term = None
build_it = False
if terms:
for term in terms:
if term.matches(brd.props):
matching_term = str(term)
build_it = True
break
elif brds:
if brd.target in brds:
build_it = True
found.append(brd.target)
else:
build_it = True
# Check that it is not specifically excluded
for expr in exclude_list:
if expr.matches(brd.props):
build_it = False
break
if build_it:
brd.build_it = True
if matching_term:
result[matching_term].append(brd.target)
result['all'].append(brd.target)
result = OrderedDict()
warnings = []
terms = self._build_terms(args)
result['all'] = []
for term in terms:
result[str(term)] = []
exclude_list = []
if exclude:
for expr in exclude:
exclude_list.append(Expr(expr))
found = []
for brd in self._boards:
_check_board(brd)
if brds:
remaining = set(brds) - set(found)
if remaining:
warnings.append(f"Boards not found: {', '.join(remaining)}\n")
return result, warnings
@classmethod
def scan_defconfigs_for_multiprocess(cls, srcdir, queue, defconfigs,
warn_targets):
"""Scan defconfig files and queue their board parameters
This function is intended to be passed to multiprocessing.Process()
constructor.
Args:
srcdir (str): Directory containing source code
queue (multiprocessing.Queue): The resulting board parameters are
written into this.
defconfigs (sequence of str): A sequence of defconfig files to be
scanned.
warn_targets (bool): True to warn about missing or duplicate
CONFIG_TARGET options
"""
kconf_scanner = KconfigScanner(srcdir)
for defconfig in defconfigs:
queue.put(kconf_scanner.scan(defconfig, warn_targets))
@classmethod
def read_queues(cls, queues, params_list, warnings):
"""Read the queues and append the data to the paramers list
Args:
queues (list of multiprocessing.Queue): Queues to read
params_list (list of dict): List to add params too
warnings (set of str): Set to add warnings to
"""
for que in queues:
while not que.empty():
params, warn = que.get()
params_list.append(params)
warnings.update(warn)
def scan_defconfigs(self, config_dir, srcdir, jobs=1, warn_targets=False):
"""Collect board parameters for all defconfig files.
This function invokes multiple processes for faster processing.
Args:
config_dir (str): Directory containing the defconfig files
srcdir (str): Directory containing source code (Kconfig files)
jobs (int): The number of jobs to run simultaneously
warn_targets (bool): True to warn about missing or duplicate
CONFIG_TARGET options
Returns:
tuple:
list of dict: List of board parameters, each a dict:
key: 'arch', 'cpu', 'soc', 'vendor', 'board', 'target',
'config'
value: string value of the key
list of str: List of warnings recorded
"""
all_defconfigs = []
for (dirpath, _, filenames) in os.walk(config_dir):
for filename in fnmatch.filter(filenames, '*_defconfig'):
if fnmatch.fnmatch(filename, '.*'):
continue
all_defconfigs.append(os.path.join(dirpath, filename))
total_boards = len(all_defconfigs)
processes = []
queues = []
for i in range(jobs):
defconfigs = all_defconfigs[total_boards * i // jobs :
total_boards * (i + 1) // jobs]
que = multiprocessing.Queue(maxsize=-1)
proc = multiprocessing.Process(
target=self.scan_defconfigs_for_multiprocess,
args=(srcdir, que, defconfigs, warn_targets))
proc.start()
processes.append(proc)
queues.append(que)
# The resulting data should be accumulated to these lists
params_list = []
warnings = set()
# Data in the queues should be retrieved preriodically.
# Otherwise, the queues would become full and subprocesses would get stuck.
while any(p.is_alive() for p in processes):
self.read_queues(queues, params_list, warnings)
# sleep for a while until the queues are filled
time.sleep(SLEEP_TIME)
# Joining subprocesses just in case
# (All subprocesses should already have been finished)
for proc in processes:
proc.join()
# retrieve leftover data
self.read_queues(queues, params_list, warnings)
return params_list, sorted(list(warnings))
@classmethod
def insert_maintainers_info(cls, srcdir, params_list):
"""Add Status and Maintainers information to the board parameters list.
Args:
params_list (list of dict): A list of the board parameters
Returns:
list of str: List of warnings collected due to missing status, etc.
"""
database = MaintainersDatabase()
for (dirpath, _, filenames) in os.walk(srcdir):
if 'MAINTAINERS' in filenames and 'tools/buildman' not in dirpath:
database.parse_file(srcdir,
os.path.join(dirpath, 'MAINTAINERS'))
for i, params in enumerate(params_list):
target = params['target']
maintainers = database.get_maintainers(target)
params['maintainers'] = maintainers
if maintainers:
params['status'] = database.get_status(target)
else:
params['status'] = '-'
params_list[i] = params
return sorted(database.warnings)
@classmethod
def format_and_output(cls, params_list, output):
"""Write board parameters into a file.
Columnate the board parameters, sort lines alphabetically,
and then write them to a file.
Args:
params_list (list of dict): The list of board parameters
output (str): The path to the output file
"""
fields = ('status', 'arch', 'cpu', 'soc', 'vendor', 'board', 'target',
'config', 'maintainers')
# First, decide the width of each column
max_length = {f: 0 for f in fields}
for params in params_list:
for field in fields:
max_length[field] = max(max_length[field], len(params[field]))
output_lines = []
for params in params_list:
line = ''
for field in fields:
# insert two spaces between fields like column -t would
line += ' ' + params[field].ljust(max_length[field])
output_lines.append(line.strip())
# ignore case when sorting
output_lines.sort(key=str.lower)
with open(output, 'w', encoding="utf-8") as outf:
outf.write(COMMENT_BLOCK + '\n'.join(output_lines) + '\n')
def build_board_list(self, config_dir=CONFIG_DIR, srcdir='.', jobs=1,
warn_targets=False):
"""Generate a board-database file
This works by reading the Kconfig, then loading each board's defconfig
in to get the setting for each option. In particular, CONFIG_TARGET_xxx
is typically set by the defconfig, where xxx is the target to build.
Args:
config_dir (str): Directory containing the defconfig files
srcdir (str): Directory containing source code (Kconfig files)
jobs (int): The number of jobs to run simultaneously
warn_targets (bool): True to warn about missing or duplicate
CONFIG_TARGET options
Returns:
tuple:
list of dict: List of board parameters, each a dict:
key: 'arch', 'cpu', 'soc', 'vendor', 'board', 'config',
'target'
value: string value of the key
list of str: Warnings that came up
"""
params_list, warnings = self.scan_defconfigs(config_dir, srcdir, jobs,
warn_targets)
m_warnings = self.insert_maintainers_info(srcdir, params_list)
return params_list, warnings + m_warnings
def ensure_board_list(self, output, jobs=1, force=False, quiet=False):
"""Generate a board database file if needed.
This is intended to check if Kconfig has changed since the boards.cfg
files was generated.
Args:
output (str): The name of the output file
jobs (int): The number of jobs to run simultaneously
force (bool): Force to generate the output even if it is new
quiet (bool): True to avoid printing a message if nothing needs doing
Returns:
bool: True if all is well, False if there were warnings
"""
if not force:
if not quiet:
tprint('\rChecking for Kconfig changes...', newline=False)
is_new = output_is_new(output, CONFIG_DIR, '.')
print_clear()
if is_new:
if not quiet:
print(f'{output} is up to date. Nothing to do.')
return True
if not quiet:
tprint('\rGenerating board list...', newline=False)
params_list, warnings = self.build_board_list(CONFIG_DIR, '.', jobs)
print_clear()
for warn in warnings:
print(warn, file=sys.stderr)
self.format_and_output(params_list, output)
return not warnings