Re: [OE-core] [PATCH v6 12/21] kernel-fit-image.bbclass: add a new FIT image implementation

[Bruce Ashfield <bruce.ashfield@gmail.com>]

In message: [OE-core] [PATCH v6 12/21] kernel-fit-image.bbclass: add a new FIT image implementation
on 02/06/2025 Adrian Freihofer via lists.openembedded.org wrote:

> From: Adrian Freihofer <adrian.freihofer@siemens.com>
> 
> The new recipe linux-yocto-fitimage.bb and the new
> kernel-fit-image.bbclass are intended to become successors of the
> kernel-fitimage.bbclass.
> 
> Instead of injecting the FIT image related build steps into the kernel
> recipe, the new recipe takes the kernel artifacts from the kernel recipe
> and creates the FIT image as an independent task.
> 
> This solves some basic problems:
> * sstate does not work well when a fitImage contains an initramfs. The
>   kernel is rebuilt from scratch if the build runs from an empty TMPDIR.
> * A fitImage kernel is not available as a package, but all other kernel
>   image types are.
> * The task dependencies in the kernel are very complex and difficult to
>   debug if something goes wrong. As a separate, downstream recipe, this
>   is now much easier.
> 
> The recipe takes the kernel artifacts from the deploy folder. There was
> also a test implementation passing the kernel artifacts via sysroot
> directory. This requires changes on the kernel.bbclass to make it
> copying the artifacts also to the sysroot directory while the same
> artifacts are already in the sstate-cached deploy directory.
> 
> The long story about this issue is here:
> [YOCTO #12912]
> 
> Signed-off-by: Adrian Freihofer <adrian.freihofer@siemens.com>
> ---
>  meta/classes-recipe/kernel-fit-image.bbclass  | 187 ++++++
>  meta/classes/multilib.bbclass                 |   1 +
>  meta/lib/oe/fitimage.py                       | 547 ++++++++++++++++++
>  .../linux/linux-yocto-fitimage.bb             |  13 +
>  4 files changed, 748 insertions(+)
>  create mode 100644 meta/classes-recipe/kernel-fit-image.bbclass
>  create mode 100644 meta/lib/oe/fitimage.py
>  create mode 100644 meta/recipes-kernel/linux/linux-yocto-fitimage.bb
> 
> diff --git a/meta/classes-recipe/kernel-fit-image.bbclass b/meta/classes-recipe/kernel-fit-image.bbclass
> new file mode 100644
> index 00000000000..6d80cd4bb47
> --- /dev/null
> +++ b/meta/classes-recipe/kernel-fit-image.bbclass
> @@ -0,0 +1,187 @@
> +
> +inherit kernel-arch kernel-artifact-names uboot-config deploy
> +require conf/image-fitimage.conf
> +
> +S = "${WORKDIR}/sources"
> +UNPACKDIR = "${S}"
> +
> +PACKAGE_ARCH = "${MACHINE_ARCH}"
> +
> +DEPENDS += "\
> +    u-boot-tools-native dtc-native \
> +    ${@'kernel-signing-keys-native' if d.getVar('FIT_GENERATE_KEYS') == '1' else ''} \
> +"
> +
> +python () {
> +    image = d.getVar('INITRAMFS_IMAGE')
> +    if image and d.getVar('INITRAMFS_IMAGE_BUNDLE') != '1':
> +        if d.getVar('INITRAMFS_MULTICONFIG'):
> +            mc = d.getVar('BB_CURRENT_MC')
> +            d.appendVarFlag('do_compile', 'mcdepends', ' mc:' + mc + ':${INITRAMFS_MULTICONFIG}:${INITRAMFS_IMAGE}:do_image_complete')
> +        else:
> +            d.appendVarFlag('do_compile', 'depends', ' ${INITRAMFS_IMAGE}:do_image_complete')
> +
> +    #check if there are any dtb providers
> +    providerdtb = d.getVar("PREFERRED_PROVIDER_virtual/dtb")
> +    if providerdtb:
> +        d.appendVarFlag('do_compile', 'depends', ' virtual/dtb:do_populate_sysroot')
> +        d.setVar('EXTERNAL_KERNEL_DEVICETREE', "${RECIPE_SYSROOT}/boot/devicetree")
> +}
> +
> +do_configure[noexec] = "1"
> +
> +UBOOT_MKIMAGE_KERNEL_TYPE ?= "kernel"
> +KERNEL_IMAGEDEST ?= "/boot"
> +
> +python do_compile() {
> +    import shutil
> +    import oe.fitimage
> +
> +    itsfile = "fit-image.its"
> +    fitname = "fitImage"
> +    kernel_deploydir = d.getVar('DEPLOY_DIR_IMAGE')
> +    kernel_deploysubdir = d.getVar('KERNEL_DEPLOYSUBDIR')
> +    if kernel_deploysubdir:
> +        kernel_deploydir = os.path.join(kernel_deploydir, kernel_deploysubdir)
> +
> +    # Collect all the its nodes before the its file is generated and mkimage gets executed
> +    root_node = oe.fitimage.ItsNodeRootKernel(
> +        d.getVar("FIT_DESC"), d.getVar("FIT_ADDRESS_CELLS"),
> +        d.getVar('HOST_PREFIX'), d.getVar('UBOOT_ARCH'),  d.getVar("FIT_CONF_PREFIX"),
> +        oe.types.boolean(d.getVar('UBOOT_SIGN_ENABLE')), d.getVar("UBOOT_SIGN_KEYDIR"),
> +        d.getVar("UBOOT_MKIMAGE"), d.getVar("UBOOT_MKIMAGE_DTCOPTS"),
> +        d.getVar("UBOOT_MKIMAGE_SIGN"), d.getVar("UBOOT_MKIMAGE_SIGN_ARGS"),
> +        d.getVar('FIT_HASH_ALG'), d.getVar('FIT_SIGN_ALG'), d.getVar('FIT_PAD_ALG'),
> +        d.getVar('UBOOT_SIGN_KEYNAME'),
> +        oe.types.boolean(d.getVar('FIT_SIGN_INDIVIDUAL')), d.getVar('UBOOT_SIGN_IMG_KEYNAME')
> +    )
> +
> +    # Prepare a kernel image section.
> +    shutil.copyfile(os.path.join(kernel_deploydir, "linux.bin"), "linux.bin")
> +    with open(os.path.join(kernel_deploydir, "linux_comp")) as linux_comp_f:
> +        linux_comp = linux_comp_f.read()
> +    root_node.fitimage_emit_section_kernel("kernel-1", "linux.bin", linux_comp,
> +        d.getVar('UBOOT_LOADADDRESS'), d.getVar('UBOOT_ENTRYPOINT'),
> +        d.getVar('UBOOT_MKIMAGE_KERNEL_TYPE'), d.getVar("UBOOT_ENTRYSYMBOL"))
> +
> +    # Prepare a DTB image section
> +    kernel_devicetree = d.getVar('KERNEL_DEVICETREE')
> +    external_kernel_devicetree = d.getVar("EXTERNAL_KERNEL_DEVICETREE")
> +    if kernel_devicetree:
> +        for dtb in kernel_devicetree.split():
> +            # In deploy_dir the DTBs are without sub-directories also with KERNEL_DTBVENDORED = "1"
> +            dtb_name = os.path.basename(dtb)
> +
> +            # Skip DTB if it's also provided in EXTERNAL_KERNEL_DEVICETREE directory
> +            if external_kernel_devicetree:
> +                ext_dtb_path = os.path.join(external_kernel_devicetree, dtb_name)
> +                if os.path.exists(ext_dtb_path) and os.path.getsize(ext_dtb_path) > 0:
> +                    continue
> +
> +            # Copy the dtb or dtbo file into the FIT image assembly directory
> +            shutil.copyfile(os.path.join(kernel_deploydir, dtb_name), dtb_name)
> +            root_node.fitimage_emit_section_dtb(dtb_name, dtb_name,
> +                d.getVar("UBOOT_DTB_LOADADDRESS"), d.getVar("UBOOT_DTBO_LOADADDRESS"))
> +
> +    if external_kernel_devicetree:
> +        # iterate over all .dtb and .dtbo files in the external kernel devicetree directory
> +        # and copy them to the FIT image assembly directory
> +        for dtb_name in sorted(os.listdir(external_kernel_devicetree)):
> +            if dtb_name.endswith('.dtb') or dtb_name.endswith('.dtbo'):
> +                dtb_path = os.path.join(external_kernel_devicetree, dtb_name)
> +
> +                # For symlinks, add a configuration node that refers to the DTB image node to which the symlink points
> +                symlink_target = oe.fitimage.symlink_points_below(dtb_name, external_kernel_devicetree)
> +                if symlink_target:
> +                    root_node.fitimage_emit_section_dtb_alias(dtb_name, symlink_target, True)
> +                # For real DTB files add an image node and a configuration node
> +                else:
> +                    shutil.copyfile(dtb_path, dtb_name)
> +                    root_node.fitimage_emit_section_dtb(dtb_name, dtb_name,
> +                        d.getVar("UBOOT_DTB_LOADADDRESS"), d.getVar("UBOOT_DTBO_LOADADDRESS"), True)
> +
> +    # Prepare a u-boot script section
> +    fit_uboot_env = d.getVar("FIT_UBOOT_ENV")
> +    if fit_uboot_env:
> +        root_node.fitimage_emit_section_boot_script("bootscr-"+fit_uboot_env , fit_uboot_env)
> +
> +    # Prepare a setup section (For x86)
> +    setup_bin_path = os.path.join(kernel_deploydir, "setup.bin")
> +    if os.path.exists(setup_bin_path):
> +        shutil.copyfile(setup_bin_path, "setup.bin")
> +        root_node.fitimage_emit_section_setup("setup-1", "setup.bin")
> +
> +    # Prepare a ramdisk section.
> +    initramfs_image = d.getVar('INITRAMFS_IMAGE')
> +    if initramfs_image and d.getVar("INITRAMFS_IMAGE_BUNDLE") != '1':
> +        # Find and use the first initramfs image archive type we find
> +        found = False
> +        for img in d.getVar("FIT_SUPPORTED_INITRAMFS_FSTYPES").split():
> +            initramfs_path = os.path.join(d.getVar("DEPLOY_DIR_IMAGE"), "%s.%s" % (d.getVar('INITRAMFS_IMAGE_NAME'), img))
> +            if os.path.exists(initramfs_path):
> +                bb.note("Found initramfs image: " + initramfs_path)
> +                found = True
> +                root_node.fitimage_emit_section_ramdisk("ramdisk-1", initramfs_path,
> +                    initramfs_image,
> +                    d.getVar("UBOOT_RD_LOADADDRESS"),
> +                    d.getVar("UBOOT_RD_ENTRYPOINT"))
> +                break
> +            else:
> +                bb.note("Did not find initramfs image: " + initramfs_path)
> +
> +        if not found:
> +            bb.fatal("Could not find a valid initramfs type for %s, the supported types are: %s" % (d.getVar('INITRAMFS_IMAGE_NAME'), d.getVar('FIT_SUPPORTED_INITRAMFS_FSTYPES')))
> +
> +    # Generate the configuration section
> +    root_node.fitimage_emit_section_config(d.getVar("FIT_CONF_DEFAULT_DTB"))
> +
> +    # Write the its file
> +    root_node.write_its_file(itsfile)
> +
> +    # Assemble the FIT image
> +    root_node.run_mkimage_assemble(itsfile, fitname)
> +
> +    # Sign the FIT image if required
> +    root_node.run_mkimage_sign(fitname)
> +}
> +do_compile[depends] += "virtual/kernel:do_deploy"
> +
> +do_install() {
> +    install -d "${D}/${KERNEL_IMAGEDEST}"
> +    install -m 0644 "${B}/fitImage" "${D}/${KERNEL_IMAGEDEST}/fitImage"
> +}
> +
> +FILES:${PN} = "${KERNEL_IMAGEDEST}"
> +
> +
> +do_deploy() {
> +    deploy_dir="${DEPLOYDIR}"
> +    if [ -n "${KERNEL_DEPLOYSUBDIR}" ]; then
> +        deploy_dir="${DEPLOYDIR}/${KERNEL_DEPLOYSUBDIR}"
> +    fi
> +    install -d "$deploy_dir"
> +    install -m 0644 "${B}/fitImage" "$deploy_dir/fitImage"
> +    install -m 0644 "${B}/fit-image.its" "$deploy_dir/fit-image.its"
> +
> +    if [ "${INITRAMFS_IMAGE_BUNDLE}" != "1" ]; then
> +        ln -snf fit-image.its "$deploy_dir/fitImage-its-${KERNEL_FIT_NAME}.its"
> +        if [ -n "${KERNEL_FIT_LINK_NAME}" ] ; then
> +            ln -snf fit-image.its "$deploy_dir/fitImage-its-${KERNEL_FIT_LINK_NAME}"
> +        fi
> +    fi
> +
> +    if [ -n "${INITRAMFS_IMAGE}" ]; then
> +        ln -snf fit-image-its "$deploy_dir/fitImage-its-${INITRAMFS_IMAGE_NAME}-${KERNEL_FIT_NAME}.its"
> +        if [ -n "${KERNEL_FIT_LINK_NAME}" ]; then
> +            ln -snf fit-image.its "$deploy_dir/fitImage-its-${INITRAMFS_IMAGE_NAME}-${KERNEL_FIT_LINK_NAME}"
> +        fi
> +
> +        if [ "${INITRAMFS_IMAGE_BUNDLE}" != "1" ]; then
> +            ln -snf fitImage "$deploy_dir/fitImage-${INITRAMFS_IMAGE_NAME}-${KERNEL_FIT_NAME}${KERNEL_FIT_BIN_EXT}"
> +            if [ -n "${KERNEL_FIT_LINK_NAME}" ] ; then
> +                ln -snf fitImage "$deploy_dir/fitImage-${INITRAMFS_IMAGE_NAME}-${KERNEL_FIT_LINK_NAME}"
> +            fi
> +        fi
> +    fi
> +}
> +addtask deploy after do_compile before do_build
> diff --git a/meta/classes/multilib.bbclass b/meta/classes/multilib.bbclass
> index a4151658a62..b959bbd93c0 100644
> --- a/meta/classes/multilib.bbclass
> +++ b/meta/classes/multilib.bbclass
> @@ -21,6 +21,7 @@ python multilib_virtclass_handler () {
>      bpn = d.getVar("BPN")
>      if ("virtual/kernel" in provides
>              or bb.data.inherits_class('module-base', d)
> +            or bb.data.inherits_class('kernel-fit-image', d)
>              or bpn in non_ml_recipes):
>          raise bb.parse.SkipRecipe("We shouldn't have multilib variants for %s" % bpn)
>  
> diff --git a/meta/lib/oe/fitimage.py b/meta/lib/oe/fitimage.py
> new file mode 100644
> index 00000000000..f3037991558
> --- /dev/null
> +++ b/meta/lib/oe/fitimage.py
> @@ -0,0 +1,547 @@
> +#
> +# Copyright OpenEmbedded Contributors
> +#
> +# SPDX-License-Identifier: GPL-2.0-only
> +#
> +# This file contains common functions for the fitimage generation
> +
> +import os
> +import shlex
> +import subprocess
> +import bb
> +
> +from oeqa.utils.commands import runCmd
> +
> +class ItsNode:
> +    INDENT_SIZE = 8
> +
> +    def __init__(self, name, parent_node, sub_nodes=None, properties=None):
> +        self.name = name
> +        self.parent_node = parent_node
> +
> +        self.sub_nodes = []
> +        if sub_nodes:
> +            self.sub_nodes = sub_nodes
> +
> +        self.properties = {}
> +        if properties:
> +            self.properties = properties
> +
> +        if parent_node:
> +            parent_node.add_sub_node(self)
> +
> +    def add_sub_node(self, sub_node):
> +        self.sub_nodes.append(sub_node)
> +
> +    def add_property(self, key, value):
> +        self.properties[key] = value
> +
> +    def emit(self, f, indent):
> +        indent_str_name = " " * indent
> +        indent_str_props = " " * (indent + self.INDENT_SIZE)
> +        f.write("%s%s {\n" % (indent_str_name, self.name))
> +        for key, value in self.properties.items():
> +            bb.debug(1, "key: %s, value: %s" % (key, str(value)))
> +            # Single integer: <0x12ab>
> +            if isinstance(value, int):
> +                f.write(indent_str_props + key + ' = <0x%x>;\n' % value)
> +            # list of strings: "string1", "string2" or integers: <0x12ab 0x34cd>
> +            elif isinstance(value, list):
> +                if len(value) == 0:
> +                    f.write(indent_str_props + key + ' = "";\n')
> +                elif isinstance(value[0], int):
> +                    list_entries = ' '.join('0x%x' % entry for entry in value)
> +                    f.write(indent_str_props + key + ' = <%s>;\n' % list_entries)
> +                else:
> +                    list_entries = ', '.join('"%s"' % entry for entry in value)
> +                    f.write(indent_str_props + key + ' = %s;\n' % list_entries)
> +            elif isinstance(value, str):
> +                # path: /incbin/("path/to/file")
> +                if key in ["data"] and value.startswith('/incbin/('):
> +                    f.write(indent_str_props + key + ' = %s;\n' % value)
> +                # Integers which are already string formatted
> +                elif value.startswith("<") and value.endswith(">"):
> +                    f.write(indent_str_props + key + ' = %s;\n' % value)
> +                else:
> +                    f.write(indent_str_props + key + ' = "%s";\n' % value)
> +            else:
> +                bb.fatal("%s has unexpexted data type." % str(value))
> +        for sub_node in self.sub_nodes:
> +            sub_node.emit(f, indent + self.INDENT_SIZE)
> +        f.write(indent_str_name + '};\n')
> +
> +class ItsNodeImages(ItsNode):
> +    def __init__(self, parent_node):
> +        super().__init__("images", parent_node)
> +
> +class ItsNodeConfigurations(ItsNode):
> +    def __init__(self, parent_node):
> +        super().__init__("configurations", parent_node)
> +
> +class ItsNodeHash(ItsNode):
> +    def __init__(self, name, parent_node, algo, opt_props=None):
> +        properties = {
> +            "algo": algo
> +        }
> +        if opt_props:
> +            properties.update(opt_props)
> +        super().__init__(name, parent_node, None, properties)
> +
> +class ItsImageSignature(ItsNode):
> +    def __init__(self, name, parent_node, algo, keyname, opt_props=None):
> +        properties = {
> +            "algo": algo,
> +            "key-name-hint": keyname
> +        }
> +        if opt_props:
> +            properties.update(opt_props)
> +        super().__init__(name, parent_node, None, properties)
> +
> +class ItsNodeImage(ItsNode):
> +    def __init__(self, name, parent_node, description, type, compression, sub_nodes=None, opt_props=None):
> +        properties = {
> +            "description": description,
> +            "type": type,
> +            "compression": compression,
> +        }
> +        if opt_props:
> +            properties.update(opt_props)
> +        super().__init__(name, parent_node, sub_nodes, properties)
> +
> +class ItsNodeDtb(ItsNodeImage):
> +    def __init__(self, name, parent_node, description, type, compression,
> +                 sub_nodes=None, opt_props=None, compatible=None):
> +        super().__init__(name, parent_node, description, type, compression, sub_nodes, opt_props)
> +        self.compatible = compatible
> +
> +class ItsNodeDtbAlias(ItsNode):
> +    """Additional Configuration Node for a DTB
> +
> +    Symlinks pointing to a DTB file are handled by an addtitional
> +    configuration node referring to another DTB image node.
> +    """
> +    def __init__(self, name, alias_name, compatible=None):
> +        super().__init__(name, parent_node=None, sub_nodes=None, properties=None)
> +        self.alias_name = alias_name
> +        self.compatible = compatible
> +
> +class ItsNodeConfigurationSignature(ItsNode):
> +    def __init__(self, name, parent_node, algo, keyname, opt_props=None):
> +        properties = {
> +            "algo": algo,
> +            "key-name-hint": keyname
> +        }
> +        if opt_props:
> +            properties.update(opt_props)
> +        super().__init__(name, parent_node, None, properties)
> +
> +class ItsNodeConfiguration(ItsNode):
> +    def __init__(self, name, parent_node, description, sub_nodes=None, opt_props=None):
> +        properties = {
> +            "description": description,
> +        }
> +        if opt_props:
> +            properties.update(opt_props)
> +        super().__init__(name, parent_node, sub_nodes, properties)
> +
> +class ItsNodeRootKernel(ItsNode):
> +    """Create FIT images for the kernel
> +
> +    Currently only a single kernel (no less or more) can be added to the FIT
> +    image along with 0 or more device trees and 0 or 1 ramdisk.
> +
> +    If a device tree included in the FIT image, the default configuration is the
> +    firt DTB. If there is no dtb present than the default configuation the kernel.
> +    """
> +    def __init__(self, description, address_cells, host_prefix, arch, conf_prefix,
> +                 sign_enable=False, sign_keydir=None,
> +                 mkimage=None, mkimage_dtcopts=None,
> +                 mkimage_sign=None, mkimage_sign_args=None,
> +                 hash_algo=None, sign_algo=None, pad_algo=None,
> +                 sign_keyname_conf=None,
> +                 sign_individual=False, sign_keyname_img=None):
> +        props = {
> +            "description": description,
> +            "#address-cells": f"<{address_cells}>"
> +        }
> +        super().__init__("/", None, None, props)
> +        self.images = ItsNodeImages(self)
> +        self.configurations = ItsNodeConfigurations(self)
> +
> +        self._host_prefix = host_prefix
> +        self._arch = arch
> +        self._conf_prefix = conf_prefix
> +
> +        # Signature related properties
> +        self._sign_enable = sign_enable
> +        self._sign_keydir = sign_keydir
> +        self._mkimage = mkimage
> +        self._mkimage_dtcopts = mkimage_dtcopts
> +        self._mkimage_sign = mkimage_sign
> +        self._mkimage_sign_args = mkimage_sign_args
> +        self._hash_algo = hash_algo
> +        self._sign_algo = sign_algo
> +        self._pad_algo = pad_algo
> +        self._sign_keyname_conf = sign_keyname_conf
> +        self._sign_individual = sign_individual
> +        self._sign_keyname_img = sign_keyname_img
> +        self._sanitize_sign_config()
> +
> +        self._dtbs = []
> +        self._dtb_alias = []
> +        self._kernel = None
> +        self._ramdisk = None
> +        self._bootscr = None
> +        self._setup = None
> +
> +    def _sanitize_sign_config(self):
> +        if self._sign_enable:
> +            if not self._hash_algo:
> +                bb.fatal("FIT image signing is enabled but no hash algorithm is provided.")
> +            if not self._sign_algo:
> +                bb.fatal("FIT image signing is enabled but no signature algorithm is provided.")
> +            if not self._pad_algo:
> +                bb.fatal("FIT image signing is enabled but no padding algorithm is provided.")
> +            if not self._sign_keyname_conf:
> +                bb.fatal("FIT image signing is enabled but no configuration key name is provided.")
> +            if self._sign_individual and not self._sign_keyname_img:
> +                bb.fatal("FIT image signing is enabled for individual images but no image key name is provided.")
> +
> +    def write_its_file(self, itsfile):
> +        with open(itsfile, 'w') as f:
> +            f.write("/dts-v1/;\n\n")
> +            self.emit(f, 0)
> +
> +    def its_add_node_image(self, image_id, description, image_type, compression, opt_props):
> +        image_node = ItsNodeImage(
> +            image_id,
> +            self.images,
> +            description,
> +            image_type,
> +            compression,
> +            opt_props=opt_props
> +        )
> +        if self._hash_algo:
> +            ItsNodeHash(
> +                "hash-1",
> +                image_node,
> +                self._hash_algo
> +            )
> +        if self._sign_individual:
> +            ItsImageSignature(
> +                "signature-1",
> +                image_node,
> +                f"{self._hash_algo},{self._sign_algo}",
> +                self._sign_keyname_img
> +            )
> +        return image_node
> +
> +    def its_add_node_dtb(self, image_id, description, image_type, compression, opt_props, compatible):
> +        dtb_node = ItsNodeDtb(
> +            image_id,
> +            self.images,
> +            description,
> +            image_type,
> +            compression,
> +            opt_props=opt_props,
> +            compatible=compatible
> +        )
> +        if self._hash_algo:
> +            ItsNodeHash(
> +                "hash-1",
> +                dtb_node,
> +                self._hash_algo
> +            )
> +        if self._sign_individual:
> +            ItsImageSignature(
> +                "signature-1",
> +                dtb_node,
> +                f"{self._hash_algo},{self._sign_algo}",
> +                self._sign_keyname_img
> +            )
> +        return dtb_node
> +
> +    def fitimage_emit_section_kernel(self, kernel_id, kernel_path, compression,
> +        load, entrypoint, mkimage_kernel_type, entrysymbol=None):
> +        """Emit the fitImage ITS kernel section"""
> +        if self._kernel:
> +            bb.fatal("Kernel section already exists in the ITS file.")
> +        if entrysymbol:
> +            result = subprocess.run([self._host_prefix + "nm", "vmlinux"], capture_output=True, text=True)
> +            for line in result.stdout.splitlines():
> +                parts = line.split()
> +                if len(parts) == 3 and parts[2] == entrysymbol:
> +                    entrypoint = "<0x%s>" % parts[0]
> +                    break
> +        kernel_node = self.its_add_node_image(
> +            kernel_id,
> +            "Linux kernel",
> +            mkimage_kernel_type,
> +            compression,
> +            {
> +                "data": '/incbin/("' + kernel_path + '")',
> +                "arch": self._arch,
> +                "os": "linux",
> +                "load": f"<{load}>",
> +                "entry": f"<{entrypoint}>"
> +            }
> +        )
> +        self._kernel = kernel_node
> +
> +    def fitimage_emit_section_dtb(self, dtb_id, dtb_path, dtb_loadaddress=None,
> +                                  dtbo_loadaddress=None, add_compatible=False):
> +        """Emit the fitImage ITS DTB section"""
> +        load=None
> +        dtb_ext = os.path.splitext(dtb_path)[1]
> +        if dtb_ext == ".dtbo":
> +            if dtbo_loadaddress:
> +                load = dtbo_loadaddress
> +        elif dtb_loadaddress:
> +            load = dtb_loadaddress
> +
> +        opt_props = {
> +            "data": '/incbin/("' + dtb_path + '")',
> +            "arch": self._arch
> +        }
> +        if load:
> +            opt_props["load"] = f"<{load}>"
> +
> +        # Preserve the DTB's compatible string to be added to the configuration node
> +        compatible = None
> +        if add_compatible:
> +            compatible = get_compatible_from_dtb(dtb_path)
> +
> +        dtb_node = self.its_add_node_dtb(
> +            "fdt-" + dtb_id,
> +            "Flattened Device Tree blob",
> +            "flat_dt",
> +            "none",
> +            opt_props,
> +            compatible
> +        )
> +        self._dtbs.append(dtb_node)
> +
> +    def fitimage_emit_section_dtb_alias(self, dtb_alias_id, dtb_path, add_compatible=False):
> +        """Add a configuration node referring to another DTB"""
> +        # Preserve the DTB's compatible string to be added to the configuration node
> +        compatible = None
> +        if add_compatible:
> +            compatible = get_compatible_from_dtb(dtb_path)
> +
> +        dtb_id = os.path.basename(dtb_path)
> +        dtb_alias_node = ItsNodeDtbAlias("fdt-" + dtb_id, dtb_alias_id, compatible)
> +        self._dtb_alias.append(dtb_alias_node)
> +        bb.warn(f"compatible: {compatible}, dtb_alias_id: {dtb_alias_id}, dtb_id: {dtb_id}, dtb_path: {dtb_path}")
> +
> +    def fitimage_emit_section_boot_script(self, bootscr_id, bootscr_path):
> +        """Emit the fitImage ITS u-boot script section"""
> +        if self._bootscr:
> +            bb.fatal("U-boot script section already exists in the ITS file.")
> +        bootscr_node = self.its_add_node_image(
> +            bootscr_id,
> +            "U-boot script",
> +            "script",
> +            "none",
> +            {
> +                "data": '/incbin/("' + bootscr_path + '")',
> +                "arch": self._arch,
> +                "type": "script"
> +            }
> +        )
> +        self._bootscr = bootscr_node
> +
> +    def fitimage_emit_section_setup(self, setup_id, setup_path):
> +        """Emit the fitImage ITS setup section"""
> +        if self._setup:
> +            bb.fatal("Setup section already exists in the ITS file.")
> +        load = "<0x00090000>"
> +        entry = "<0x00090000>"
> +        setup_node = self.its_add_node_image(
> +            setup_id,
> +            "Linux setup.bin",
> +            "x86_setup",
> +            "none",
> +            {
> +                "data": '/incbin/("' + setup_path + '")',
> +                "arch": self._arch,
> +                "os": "linux",
> +                "load": load,
> +                "entry": entry
> +            }
> +        )
> +        self._setup = setup_node
> +
> +    def fitimage_emit_section_ramdisk(self, ramdisk_id, ramdisk_path, description="ramdisk", load=None, entry=None):
> +        """Emit the fitImage ITS ramdisk section"""
> +        if self._ramdisk:
> +            bb.fatal("Ramdisk section already exists in the ITS file.")
> +        opt_props = {
> +            "data": '/incbin/("' + ramdisk_path + '")',
> +            "type": "ramdisk",
> +            "arch": self._arch,
> +            "os": "linux"
> +        }
> +        if load:
> +            opt_props["load"] = f"<{load}>"
> +        if entry:
> +            opt_props["entry"] = f"<{entry}>"
> +
> +        ramdisk_node = self.its_add_node_image(
> +            ramdisk_id,
> +            description,
> +            "ramdisk",
> +            "none",
> +            opt_props
> +        )
> +        self._ramdisk = ramdisk_node
> +
> +    def _fitimage_emit_one_section_config(self, conf_node_name, dtb=None):
> +        """Emit the fitImage ITS configuration section"""
> +        opt_props = {}
> +        conf_desc = []
> +        sign_entries = []
> +
> +        if self._kernel:
> +            conf_desc.append("Linux kernel")
> +            opt_props["kernel"] = self._kernel.name
> +            if self._sign_enable:
> +                sign_entries.append("kernel")
> +
> +        if dtb:
> +            conf_desc.append("FDT blob")
> +            opt_props["fdt"] = dtb.name
> +            if dtb.compatible:
> +                opt_props["compatible"] = dtb.compatible
> +            if self._sign_enable:
> +                sign_entries.append("fdt")
> +
> +        if self._ramdisk:
> +            conf_desc.append("ramdisk")
> +            opt_props["ramdisk"] = self._ramdisk.name
> +            if self._sign_enable:
> +                sign_entries.append("ramdisk")
> +
> +        if self._bootscr:
> +            conf_desc.append("u-boot script")
> +            opt_props["bootscr"] = self._bootscr.name
> +            if self._sign_enable:
> +                sign_entries.append("bootscr")
> +
> +        if self._setup:
> +            conf_desc.append("setup")
> +            opt_props["setup"] = self._setup.name
> +            if self._sign_enable:
> +                sign_entries.append("setup")
> +
> +        # First added configuration is the default configuration
> +        default_flag = "0"
> +        if len(self.configurations.sub_nodes) == 0:
> +            default_flag = "1"
> +
> +        conf_node = ItsNodeConfiguration(
> +            conf_node_name,
> +            self.configurations,
> +            f"{default_flag} {', '.join(conf_desc)}",
> +            opt_props=opt_props
> +        )
> +        if self._hash_algo:
> +            ItsNodeHash(
> +                "hash-1",
> +                conf_node,
> +                self._hash_algo
> +            )
> +        if self._sign_enable:
> +            ItsNodeConfigurationSignature(
> +                "signature-1",
> +                conf_node,
> +                f"{self._hash_algo},{self._sign_algo}",
> +                self._sign_keyname_conf,
> +                opt_props={
> +                    "padding": self._pad_algo,
> +                    "sign-images": sign_entries
> +                }
> +            )
> +
> +    def fitimage_emit_section_config(self, default_dtb_image=None):
> +        if self._dtbs:
> +            for dtb in self._dtbs:
> +                dtb_name = dtb.name
> +                if dtb.name.startswith("fdt-"):
> +                    dtb_name = dtb.name[len("fdt-"):]
> +                self._fitimage_emit_one_section_config(self._conf_prefix + dtb_name, dtb)
> +            for dtb in self._dtb_alias:
> +                self._fitimage_emit_one_section_config(self._conf_prefix + dtb.alias_name, dtb)
> +        else:
> +            # Currently exactly one kernel is supported.
> +            self._fitimage_emit_one_section_config(self._conf_prefix + "1")
> +
> +        default_conf = self.configurations.sub_nodes[0].name
> +        if default_dtb_image and self._dtbs:
> +            default_conf = self._conf_prefix + default_dtb_image
> +        self.configurations.add_property('default', default_conf)
> +
> +    def run_mkimage_assemble(self, itsfile, fitfile):
> +        cmd = [
> +            self._mkimage,
> +            '-f', itsfile,
> +            fitfile
> +        ]
> +        if self._mkimage_dtcopts:
> +            cmd.insert(1, '-D')
> +            cmd.insert(2, self._mkimage_dtcopts)
> +        try:
> +            subprocess.run(cmd, check=True, capture_output=True)
> +        except subprocess.CalledProcessError as e:
> +            bb.fatal(f"Command '{' '.join(cmd)}' failed with return code {e.returncode}\nstdout: {e.stdout.decode()}\nstderr: {e.stderr.decode()}\nitsflile: {os.path.abspath(itsfile)}")
> +
> +    def run_mkimage_sign(self, fitfile):
> +        if not self._sign_enable:
> +            bb.debug(1, "FIT image signing is disabled. Skipping signing.")
> +            return
> +
> +        # Some sanity checks because mkimage exits with 0 also without needed keys
> +        sign_key_path = os.path.join(self._sign_keydir, self._sign_keyname_conf)
> +        if not os.path.exists(sign_key_path + '.key') or not os.path.exists(sign_key_path + '.crt'):
> +            bb.fatal("%s.key or .crt does not exist" % sign_key_path)
> +        if self._sign_individual:
> +            sign_key_img_path = os.path.join(self._sign_keydir, self._sign_keyname_img)
> +            if not os.path.exists(sign_key_img_path + '.key') or not os.path.exists(sign_key_img_path + '.crt'):
> +                bb.fatal("%s.key or .crt does not exist" % sign_key_img_path)
> +
> +        cmd = [
> +            self._mkimage_sign,
> +            '-F',
> +            '-k', self._sign_keydir,
> +            '-r', fitfile
> +        ]
> +        if self._mkimage_dtcopts:
> +            cmd.extend(['-D', self._mkimage_dtcopts])
> +        if self._mkimage_sign_args:
> +            cmd.extend(shlex.split(self._mkimage_sign_args))
> +        try:
> +            subprocess.run(cmd, check=True, capture_output=True)
> +        except subprocess.CalledProcessError as e:
> +            bb.fatal(f"Command '{' '.join(cmd)}' failed with return code {e.returncode}\nstdout: {e.stdout.decode()}\nstderr: {e.stderr.decode()}")
> +
> +
> +def symlink_points_below(file_or_symlink, expected_parent_dir):
> +    """returns symlink destination if it points below directory"""
> +    file_path = os.path.join(expected_parent_dir, file_or_symlink)
> +    if not os.path.islink(file_path):
> +        return None
> +
> +    realpath = os.path.relpath(os.path.realpath(file_path), expected_parent_dir)
> +    if realpath.startswith(".."):
> +        return None
> +
> +    return realpath
> +
> +def get_compatible_from_dtb(dtb_path, fdtget_path="fdtget"):
> +    compatible = None
> +    cmd = [fdtget_path, "-t", "s", dtb_path, "/", "compatible"]
> +    try:
> +        ret = subprocess.run(cmd, check=True, capture_output=True, text=True)
> +        compatible = ret.stdout.strip().split()
> +    except subprocess.CalledProcessError:
> +        compatible = None
> +    return compatible
> diff --git a/meta/recipes-kernel/linux/linux-yocto-fitimage.bb b/meta/recipes-kernel/linux/linux-yocto-fitimage.bb
> new file mode 100644
> index 00000000000..6ce1960a871
> --- /dev/null
> +++ b/meta/recipes-kernel/linux/linux-yocto-fitimage.bb
> @@ -0,0 +1,13 @@
> +SUMMARY = "The Linux kernel as a FIT image (optionally with initramfs)"
> +SECTION = "kernel"
> +
> +# If an initramfs is included in the FIT image more licenses apply.
> +# But also the kernel uses more than one license (see Documentation/process/license-rules.rst)
> +LICENSE = "GPL-2.0-with-Linux-syscall-note"
> +LIC_FILES_CHKSUM = "file://${COREBASE}/meta/files/common-licenses/GPL-2.0-with-Linux-syscall-note;md5=0bad96c422c41c3a94009dcfe1bff992"
> +
> +inherit linux-kernel-base kernel-fit-image
> +
> +# Set the version of this recipe to the version of the included kernel
> +# (without taking the long way around via PV)
> +PKGV = "${@get_kernelversion_file("${STAGING_KERNEL_BUILDDIR}")}"

At least for this part of the series, I have no concerns. Now that this
won't need to be updated to match the kernel, the maintenance is low.

I'll have a look at the other parts shortly as well.

Bruce

> -- 
> 2.49.0
> 

> 
> -=-=-=-=-=-=-=-=-=-=-=-
> Links: You receive all messages sent to this group.
> View/Reply Online (#217695): https://lists.openembedded.org/g/openembedded-core/message/217695
> Mute This Topic: https://lists.openembedded.org/mt/113424429/1050810
> Group Owner: openembedded-core+owner@lists.openembedded.org
> Unsubscribe: https://lists.openembedded.org/g/openembedded-core/unsub [bruce.ashfield@gmail.com]
> -=-=-=-=-=-=-=-=-=-=-=-
>