mirror of
git://git.yoctoproject.org/poky.git
synced 2025-07-19 21:09:03 +02:00
6fdbc5144f
When embedding a rootfs image (e.g. 'rootfs-dir') as a partition we
might want to keep the stock fstab for that image. In such a case, use
this option to not update the fstab and use the stock one instead.
This option allows you to specify which partitions get the fstab
updated and which get the stock fstab.
The option matches the argument you can pass to wic itself where the
same action is performed but for all the partitions.
Example:
part /export --source rootfs --rootfs-dir=hockeycam-image
--fstype=ext4 --label export --align 1024 --no-fstab-update
part / --source rootfs --fstype=ext4 --label rootfs --align 1024
(From OE-Core rev: ab4c95af8ecd15dc136194ab761afae756db5803)
Signed-off-by: Daniel Gomez <daniel@qtec.com>
Signed-off-by: Richard Purdie <richard.purdie@linuxfoundation.org>
296 lines
12 KiB
Python
296 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')
|
|
part.add_argument('--no-fstab-update', action='store_true')
|
|
|
|
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)
|