mirror of
git://git.yoctoproject.org/poky.git
synced 2025-07-19 12:59:02 +02:00
63b3c44d27
Since Linux 5.4 a new read-only filesystem is available, erofs. Compared to squashfs it offers much better read performance with and without compression enabled. It suppports two optional compressors, lz4 and lz4hc. >From the mkfs.erofs man page: EROFS is a new enhanced lightweight linux read-only filesystem with modern designs (eg. no buffer head, reduced metadata, inline xattrs/data, etc.) for scenarios which need high-performance read-only requirements, e.g. Android OS for smartphones and LIVECDs. It also provides fixed-sized output compression support, which improves storage density, keeps relatively higher compression ratios, which is more useful to achieve high performance for embedded devices with limited memory since it has unnoticable memory overhead and page cache thrashing. This commit adds support for three new filesystem targets: erofs: erofs without compression erofs-lz4: erofs with lz4 compresssion enabled erofs-lz4hc: erofs with lz4hc compression enabled (From OE-Core rev: 41dead1ff8ccc49e6cd6e6f5d41a59d164693e0d) Signed-off-by: Richard Weinberger <richard@nod.at> Signed-off-by: Richard Purdie <richard.purdie@linuxfoundation.org>
295 lines
12 KiB
Python
295 lines
12 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', 'erofs',
|
|
'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)
|
|
# erofs does not support filesystem labels
|
|
if parsed.fstype == 'erofs' and parsed.label:
|
|
err = "%s:%d: erofs does not support LABEL" % (confpath, lineno)
|
|
raise KickStartError(err)
|
|
if parsed.fstype == 'msdos' or parsed.fstype == 'vfat':
|
|
if parsed.fsuuid:
|
|
if parsed.fsuuid.upper().startswith('0X'):
|
|
if len(parsed.fsuuid) > 10:
|
|
err = "%s:%d: fsuuid %s given in wks kickstart file " \
|
|
"exceeds the length limit for %s filesystem. " \
|
|
"It should be in the form of a 32 bit hexadecimal" \
|
|
"number (for example, 0xABCD1234)." \
|
|
% (confpath, lineno, parsed.fsuuid, parsed.fstype)
|
|
raise KickStartError(err)
|
|
elif len(parsed.fsuuid) > 8:
|
|
err = "%s:%d: fsuuid %s given in wks kickstart file " \
|
|
"exceeds the length limit for %s filesystem. " \
|
|
"It should be in the form of a 32 bit hexadecimal" \
|
|
"number (for example, 0xABCD1234)." \
|
|
% (confpath, lineno, parsed.fsuuid, parsed.fstype)
|
|
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)
|