mirror of
git://git.yoctoproject.org/poky.git
synced 2025-07-19 21:09:03 +02:00
5fa3c3d2e3
Allows the --offset argument to use the "s" or "S" suffix to specify that it is reporting the number of 512 byte sectors. This is required for some SoCs where the mask ROM looks for an item at a sector that isn't aligned to a 1KB boundary. (From OE-Core rev: 938595d1dc4abaf5f7f3a7900add3f0492b805d0) Signed-off-by: Joshua Watt <JPEWhacker@gmail.com> Signed-off-by: Richard Purdie <richard.purdie@linuxfoundation.org>
273 lines
10 KiB
Python
273 lines
10 KiB
Python
#!/usr/bin/env python3
|
|
#
|
|
# Copyright (c) 2016 Intel, Inc.
|
|
#
|
|
# SPDX-License-Identifier: GPL-2.0-only
|
|
#
|
|
# DESCRIPTION
|
|
# This module provides parser for kickstart format
|
|
#
|
|
# AUTHORS
|
|
# Ed Bartosh <ed.bartosh> (at] linux.intel.com>
|
|
|
|
"""Kickstart parser module."""
|
|
|
|
import os
|
|
import shlex
|
|
import logging
|
|
import re
|
|
|
|
from argparse import ArgumentParser, ArgumentError, ArgumentTypeError
|
|
|
|
from wic.engine import find_canned
|
|
from wic.partition import Partition
|
|
from wic.misc import get_bitbake_var
|
|
|
|
logger = logging.getLogger('wic')
|
|
|
|
__expand_var_regexp__ = re.compile(r"\${[^{}@\n\t :]+}")
|
|
|
|
def expand_line(line):
|
|
while True:
|
|
m = __expand_var_regexp__.search(line)
|
|
if not m:
|
|
return line
|
|
key = m.group()[2:-1]
|
|
val = get_bitbake_var(key)
|
|
if val is None:
|
|
logger.warning("cannot expand variable %s" % key)
|
|
return line
|
|
line = line[:m.start()] + val + line[m.end():]
|
|
|
|
class KickStartError(Exception):
|
|
"""Custom exception."""
|
|
pass
|
|
|
|
class KickStartParser(ArgumentParser):
|
|
"""
|
|
This class overwrites error method to throw exception
|
|
instead of producing usage message(default argparse behavior).
|
|
"""
|
|
def error(self, message):
|
|
raise ArgumentError(None, message)
|
|
|
|
def sizetype(default, size_in_bytes=False):
|
|
def f(arg):
|
|
"""
|
|
Custom type for ArgumentParser
|
|
Converts size string in <num>[S|s|K|k|M|G] format into the integer value
|
|
"""
|
|
try:
|
|
suffix = default
|
|
size = int(arg)
|
|
except ValueError:
|
|
try:
|
|
suffix = arg[-1:]
|
|
size = int(arg[:-1])
|
|
except ValueError:
|
|
raise ArgumentTypeError("Invalid size: %r" % arg)
|
|
|
|
|
|
if size_in_bytes:
|
|
if suffix == 's' or suffix == 'S':
|
|
return size * 512
|
|
mult = 1024
|
|
else:
|
|
mult = 1
|
|
|
|
if suffix == "k" or suffix == "K":
|
|
return size * mult
|
|
if suffix == "M":
|
|
return size * mult * 1024
|
|
if suffix == "G":
|
|
return size * mult * 1024 * 1024
|
|
|
|
raise ArgumentTypeError("Invalid size: %r" % arg)
|
|
return f
|
|
|
|
def overheadtype(arg):
|
|
"""
|
|
Custom type for ArgumentParser
|
|
Converts overhead string to float and checks if it's bigger than 1.0
|
|
"""
|
|
try:
|
|
result = float(arg)
|
|
except ValueError:
|
|
raise ArgumentTypeError("Invalid value: %r" % arg)
|
|
|
|
if result < 1.0:
|
|
raise ArgumentTypeError("Overhead factor should be > 1.0" % arg)
|
|
|
|
return result
|
|
|
|
def cannedpathtype(arg):
|
|
"""
|
|
Custom type for ArgumentParser
|
|
Tries to find file in the list of canned wks paths
|
|
"""
|
|
scripts_path = os.path.abspath(os.path.dirname(__file__) + '../../..')
|
|
result = find_canned(scripts_path, arg)
|
|
if not result:
|
|
raise ArgumentTypeError("file not found: %s" % arg)
|
|
return result
|
|
|
|
def systemidtype(arg):
|
|
"""
|
|
Custom type for ArgumentParser
|
|
Checks if the argument sutisfies system id requirements,
|
|
i.e. if it's one byte long integer > 0
|
|
"""
|
|
error = "Invalid system type: %s. must be hex "\
|
|
"between 0x1 and 0xFF" % arg
|
|
try:
|
|
result = int(arg, 16)
|
|
except ValueError:
|
|
raise ArgumentTypeError(error)
|
|
|
|
if result <= 0 or result > 0xff:
|
|
raise ArgumentTypeError(error)
|
|
|
|
return arg
|
|
|
|
class KickStart():
|
|
"""Kickstart parser implementation."""
|
|
|
|
DEFAULT_EXTRA_SPACE = 10*1024
|
|
DEFAULT_OVERHEAD_FACTOR = 1.3
|
|
|
|
def __init__(self, confpath):
|
|
|
|
self.partitions = []
|
|
self.bootloader = None
|
|
self.lineno = 0
|
|
self.partnum = 0
|
|
|
|
parser = KickStartParser()
|
|
subparsers = parser.add_subparsers()
|
|
|
|
part = subparsers.add_parser('part')
|
|
part.add_argument('mountpoint', nargs='?')
|
|
part.add_argument('--active', action='store_true')
|
|
part.add_argument('--align', type=int)
|
|
part.add_argument('--offset', type=sizetype("K", True))
|
|
part.add_argument('--exclude-path', nargs='+')
|
|
part.add_argument('--include-path', nargs='+', action='append')
|
|
part.add_argument('--change-directory')
|
|
part.add_argument("--extra-space", type=sizetype("M"))
|
|
part.add_argument('--fsoptions', dest='fsopts')
|
|
part.add_argument('--fstype', default='vfat',
|
|
choices=('ext2', 'ext3', 'ext4', 'btrfs',
|
|
'squashfs', 'vfat', 'msdos', 'swap'))
|
|
part.add_argument('--mkfs-extraopts', default='')
|
|
part.add_argument('--label')
|
|
part.add_argument('--use-label', action='store_true')
|
|
part.add_argument('--no-table', action='store_true')
|
|
part.add_argument('--ondisk', '--ondrive', dest='disk', default='sda')
|
|
part.add_argument("--overhead-factor", type=overheadtype)
|
|
part.add_argument('--part-name')
|
|
part.add_argument('--part-type')
|
|
part.add_argument('--rootfs-dir')
|
|
part.add_argument('--type', default='primary',
|
|
choices = ('primary', 'logical'))
|
|
|
|
# --size and --fixed-size cannot be specified together; options
|
|
# ----extra-space and --overhead-factor should also raise a parser
|
|
# --error, but since nesting mutually exclusive groups does not work,
|
|
# ----extra-space/--overhead-factor are handled later
|
|
sizeexcl = part.add_mutually_exclusive_group()
|
|
sizeexcl.add_argument('--size', type=sizetype("M"), default=0)
|
|
sizeexcl.add_argument('--fixed-size', type=sizetype("M"), default=0)
|
|
|
|
part.add_argument('--source')
|
|
part.add_argument('--sourceparams')
|
|
part.add_argument('--system-id', type=systemidtype)
|
|
part.add_argument('--use-uuid', action='store_true')
|
|
part.add_argument('--uuid')
|
|
part.add_argument('--fsuuid')
|
|
|
|
bootloader = subparsers.add_parser('bootloader')
|
|
bootloader.add_argument('--append')
|
|
bootloader.add_argument('--configfile')
|
|
bootloader.add_argument('--ptable', choices=('msdos', 'gpt'),
|
|
default='msdos')
|
|
bootloader.add_argument('--timeout', type=int)
|
|
bootloader.add_argument('--source')
|
|
|
|
include = subparsers.add_parser('include')
|
|
include.add_argument('path', type=cannedpathtype)
|
|
|
|
self._parse(parser, confpath)
|
|
if not self.bootloader:
|
|
logger.warning('bootloader config not specified, using defaults\n')
|
|
self.bootloader = bootloader.parse_args([])
|
|
|
|
def _parse(self, parser, confpath):
|
|
"""
|
|
Parse file in .wks format using provided parser.
|
|
"""
|
|
with open(confpath) as conf:
|
|
lineno = 0
|
|
for line in conf:
|
|
line = line.strip()
|
|
lineno += 1
|
|
if line and line[0] != '#':
|
|
line = expand_line(line)
|
|
try:
|
|
line_args = shlex.split(line)
|
|
parsed = parser.parse_args(line_args)
|
|
except ArgumentError as err:
|
|
raise KickStartError('%s:%d: %s' % \
|
|
(confpath, lineno, err))
|
|
if line.startswith('part'):
|
|
# SquashFS does not support filesystem UUID
|
|
if parsed.fstype == 'squashfs':
|
|
if parsed.fsuuid:
|
|
err = "%s:%d: SquashFS does not support UUID" \
|
|
% (confpath, lineno)
|
|
raise KickStartError(err)
|
|
if parsed.label:
|
|
err = "%s:%d: SquashFS does not support LABEL" \
|
|
% (confpath, lineno)
|
|
raise KickStartError(err)
|
|
if parsed.use_label and not parsed.label:
|
|
err = "%s:%d: Must set the label with --label" \
|
|
% (confpath, lineno)
|
|
raise KickStartError(err)
|
|
# using ArgumentParser one cannot easily tell if option
|
|
# was passed as argument, if said option has a default
|
|
# value; --overhead-factor/--extra-space cannot be used
|
|
# with --fixed-size, so at least detect when these were
|
|
# passed with non-0 values ...
|
|
if parsed.fixed_size:
|
|
if parsed.overhead_factor or parsed.extra_space:
|
|
err = "%s:%d: arguments --overhead-factor and --extra-space not "\
|
|
"allowed with argument --fixed-size" \
|
|
% (confpath, lineno)
|
|
raise KickStartError(err)
|
|
else:
|
|
# ... and provide defaults if not using
|
|
# --fixed-size iff given option was not used
|
|
# (again, one cannot tell if option was passed but
|
|
# with value equal to 0)
|
|
if '--overhead-factor' not in line_args:
|
|
parsed.overhead_factor = self.DEFAULT_OVERHEAD_FACTOR
|
|
if '--extra-space' not in line_args:
|
|
parsed.extra_space = self.DEFAULT_EXTRA_SPACE
|
|
|
|
self.partnum += 1
|
|
self.partitions.append(Partition(parsed, self.partnum))
|
|
elif line.startswith('include'):
|
|
self._parse(parser, parsed.path)
|
|
elif line.startswith('bootloader'):
|
|
if not self.bootloader:
|
|
self.bootloader = parsed
|
|
# Concatenate the strings set in APPEND
|
|
append_var = get_bitbake_var("APPEND")
|
|
if append_var:
|
|
self.bootloader.append = ' '.join(filter(None, \
|
|
(self.bootloader.append, append_var)))
|
|
else:
|
|
err = "%s:%d: more than one bootloader specified" \
|
|
% (confpath, lineno)
|
|
raise KickStartError(err)
|