87 files changed, 3492 insertions, 2227 deletions
diff --git a/scripts/b4-wrapper-poky.py b/scripts/b4-wrapper-poky.py
new file mode 100755
index 0000000000..f1170db06b
--- /dev/null
+++ b/scripts/b4-wrapper-poky.py
@@ -0,0 +1,185 @@
+#!/usr/bin/env python3
+#
+# Copyright OpenEmbedded Contributors
+#
+# SPDX-License-Identifier: MIT
+#
+# This script is to be called by b4:
+# - through the b4.prep-perpatch-check-cmd with "prep-perpatch-check-cmd" as
+#   first argument,
+# - through b4.send-auto-cc-cmd with "send-auto-cc-cmd" as first argument,
+# - through b4.send-auto-to-cmd with "send-auto-to-cmd" as first argument,
+#
+# When prep-perpatch-check-cmd is passsed:
+#
+#  This checks that a patch makes changes to at most one project in the poky
+#  combo repo (that is, out of yocto-docs, bitbake, openembedded-core combined
+#  into poky and the poky-specific files).
+#
+#  Printing something to stdout in this file will result in b4 prep --check fail
+#  for the currently parsed patch.
+#
+#  It checks that all patches in the series make changes to at most one project.
+#
+# When send-auto-cc-cmd is passed:
+#
+#  This returns the list of Cc recipients for a patch.
+#
+# When send-auto-to-cmd is passed:
+#
+#  This returns the list of To recipients for a patch.
+#
+# This script takes as stdin a patch.
+import pathlib
+import re
+import shutil
+import subprocess
+import sys
+cmd = sys.argv[1]
+patch = sys.stdin.readlines()
+# Subject field is used to identify the last patch as this script is called for
+# each patch. We edit the same file in a series by using the References field
+# unique identifier to check which projects are modified by earlier patches in
+# the series. To avoid cluttering the disk, the last patch in the list removes
+# that shared file.
+re_subject = re.compile(r'^Subject:.*\[.*PATCH.*\s(\d+)/\1')
+re_ref = re.compile(r'^References: <(.*)>$')
+subject = None
+ref = None
+if not shutil.which("lsdiff"):
+    print("lsdiff missing from host, please install patchutils", file=sys.stderr)
+    sys.exit(-1)
+try:
+    one_patch_series = False
+    for line in patch:
+        subject = re_subject.match(line)
+        if subject:
+            # Handle [PATCH 1/1]
+            if subject.group(1) == 1:
+                one_patch_series = True
+            break
+        if re.match(r'^Subject: .*\[.*PATCH[^/]*\]', line):
+            # Single patch is named [PATCH] but if there are prefix, it could be
+            # [PATCH prefix], so handle everything that doesn't have a /
+            # character which is used as separator between current patch number
+            # and total patch number
+            one_patch_series = True
+            break
+    if cmd == "prep-perpatch-check-cmd" and not one_patch_series:
+        for line in patch:
+            ref = re_ref.match(line)
+            if ref:
+                break
+        if not ref:
+            print("Failed to find ref to cover letter (References:)...", file=sys.stderr)
+            sys.exit(-2)
+        ref = ref.group(1)
+        series_check = pathlib.Path(f".tmp-{ref}")
+    patch = "".join(patch)
+    if cmd == "send-auto-cc-cmd":
+        # Patches to BitBake documentation should also go to yocto-docs mailing list
+        project_paths = {
+                "yocto-docs": ["bitbake/doc/*"],
+        }
+    else:
+        project_paths = {
+                "bitbake": ["bitbake/*"],
+                "yocto-docs": ["documentation/*"],
+                "poky": [
+                    "meta-poky/*",
+                    "meta-yocto-bsp/*",
+                    "README.hardware.md",
+                    "README.poky.md",
+                    # scripts/b4-wrapper-poky.py is only run by b4 when in poky
+                    # git repo. With that limitation, changes made to .b4-config
+                    # can only be for poky's and not OE-Core's as only poky's is
+                    # stored in poky git repo.
+                    ".b4-config",
+                    ],
+        }
+    # List of projects touched by this patch
+    projs = []
+    # Any file not matched by any path in project_paths means it is from
+    # OE-Core.
+    # When matching some path in project_paths, remove the matched files from
+    # that list.
+    files_left = subprocess.check_output(["lsdiff", "--strip-match=1", "--strip=1"],
+                                         input=patch, text=True)
+    files_left = set(files_left)
+    for proj, proj_paths in project_paths.items():
+        lsdiff_args = [f"--include={path}" for path in proj_paths]
+        files = subprocess.check_output(["lsdiff", "--strip-match=1", "--strip=1"] + lsdiff_args,
+                                        input=patch, text=True)
+        if len(files):
+            files_left = files_left - set(files)
+            projs.append(proj)
+            continue
+        # Handle patches made with --no-prefix
+        files = subprocess.check_output(["lsdiff"] + lsdiff_args,
+                                        input=patch, text=True)
+        if len(files):
+            files_left = files_left - set(files)
+            projs.append(proj)
+    # Catch-all for everything not poky-specific or in bitbake/yocto-docs
+    if len(files_left) and cmd != "send-auto-cc-cmd":
+        projs.append("openembedded-core")
+    if cmd == "prep-perpatch-check-cmd":
+        if len(projs) > 1:
+            print(f"Diff spans more than one project ({', '.join(sorted(projs))}), split into multiple commits...",
+                  file=sys.stderr)
+            sys.exit(-3)
+        # No need to check other patches in the series as there aren't any
+        if one_patch_series:
+            sys.exit(0)
+        # This should be replaced once b4 supports prep-perseries-check-cmd (or something similar)
+        if series_check.exists():
+            # NOT race-free if b4 decides to parallelize prep-perpatch-check-cmd
+            series_projs = series_check.read_text().split('\n')
+        else:
+            series_projs = []
+        series_projs += projs
+        uniq_series_projs = set(series_projs)
+        # NOT race-free, if b4 decides to parallelize prep-perpatch-check-cmd
+        series_check.write_text('\n'.join(uniq_series_projs))
+        if len(uniq_series_projs) > 1:
+            print(f"Series spans more than one project ({', '.join(sorted(uniq_series_projs))}), split into multiple series...",
+                  file=sys.stderr)
+            sys.exit(-4)
+    else:  # send-auto-cc-cmd / send-auto-to-cmd
+        ml_projs = {
+            "bitbake": "bitbake-devel@lists.openembedded.org",
+            "yocto-docs": "docs@lists.yoctoproject.org",
+            "poky": "poky@lists.yoctoproject.org",
+            "openembedded-core": "openembedded-core@lists.openembedded.org",
+        }
+        print("\n".join([ml_projs[ml] for ml in projs]))
+    sys.exit(0)
+finally:
+    # Last patch in the series, cleanup tmp file
+    if subject and ref and series_check.exists():
+        series_check.unlink()
diff --git a/scripts/bitbake-prserv-tool b/scripts/bitbake-prserv-tool
index 80028342b1..0559c4c38a 100755
--- a/scripts/bitbake-prserv-tool
+++ b/scripts/bitbake-prserv-tool
@@ -55,43 +55,6 @@ do_import ()
    return $ret
 }
-do_migrate_localcount ()
-{
-    df=`bitbake -R conf/migrate_localcount.conf -e | \
-                grep ^LOCALCOUNT_DUMPFILE= | cut -f2 -d\"`
-    if [ "x${df}" == "x" ];
-    then
-        echo "LOCALCOUNT_DUMPFILE is not defined!"
-        return 1
-    fi
-    rm -f $df
-    clean_cache
-    echo "Exporting LOCALCOUNT to AUTOINCs..."
-    bitbake -R conf/migrate_localcount.conf -p
-    [ ! $? -eq 0 ] && echo "Exporting to file $df failed!" && exit 1
-    if [ -e $df ];
-    then
-        echo "Exporting to file $df succeeded!"
-    else
-        echo "Exporting to file $df failed!"
-        exit 1
-    fi
-    
-    echo "Importing generated AUTOINC entries..."
-    [ -e $df ] && do_import $df
-    if [ ! $? -eq 0 ]
-    then
-        echo "Migration from LOCALCOUNT to AUTOINCs failed!"
-        return 1
-    fi
-    echo "Migration from LOCALCOUNT to AUTOINCs succeeded!"
-    return 0
-}
 [ $# -eq 0 ] && help  && exit 1
 case $2 in
@@ -110,9 +73,6 @@ export)
 import)
    do_import $2
    ;;
-migrate_localcount)
-    do_migrate_localcount
-    ;;
 *)
    help
    exit 1
diff --git a/scripts/buildstats-diff b/scripts/buildstats-diff
index c9aa76a8fa..df1df432f1 100755
--- a/scripts/buildstats-diff
+++ b/scripts/buildstats-diff
@@ -12,6 +12,7 @@ import glob
 import logging
 import math
 import os
+import pathlib
 import sys
 from operator import attrgetter
@@ -251,11 +252,32 @@ Script for comparing buildstats of two separate builds."""
                             "average over them")
    parser.add_argument('--only-task', dest='only_tasks', metavar='TASK', action='append', default=[],
                        help="Only include TASK in report. May be specified multiple times")
-    parser.add_argument('buildstats1', metavar='BUILDSTATS1', help="'Left' buildstat")
+    parser.add_argument('buildstats1', metavar='BUILDSTATS1', nargs="?", help="'Left' buildstat")
-    parser.add_argument('buildstats2', metavar='BUILDSTATS2', help="'Right' buildstat")
+    parser.add_argument('buildstats2', metavar='BUILDSTATS2', nargs="?", help="'Right' buildstat")
    args = parser.parse_args(argv)
+    if args.buildstats1 and args.buildstats2:
+        # Both paths specified
+        pass
+    elif args.buildstats1 or args.buildstats2:
+        # Just one path specified, this is an error
+        parser.print_usage(sys.stderr)
+        print("Either specify two buildstats paths, or none to use the last two paths.", file=sys.stderr)
+        sys.exit(1)
+    else:
+        # No paths specified, try to find the last two buildstats
+        try:
+            buildstats_dir = pathlib.Path(os.environ["BUILDDIR"]) / "tmp" / "buildstats"
+            paths = sorted(buildstats_dir.iterdir())
+            args.buildstats2 = paths.pop()
+            args.buildstats1 = paths.pop()
+            print(f"Comparing {args.buildstats1} -> {args.buildstats2}\n")
+        except KeyError:
+            parser.print_usage(sys.stderr)
+            print("Build environment has not been configured, cannot find buildstats", file=sys.stderr)
+            sys.exit(1)
    # We do not nedd/want to read all buildstats if we just want to look at the
    # package versions
    if args.ver_diff:
diff --git a/scripts/buildstats-summary b/scripts/buildstats-summary
index b10c671b29..cc2a27722a 100755
--- a/scripts/buildstats-summary
+++ b/scripts/buildstats-summary
@@ -87,7 +87,11 @@ def main(argv=None) -> int:
    )
    parser.add_argument(
-        "buildstats", metavar="BUILDSTATS", help="Buildstats file", type=pathlib.Path
+        "buildstats",
+        metavar="BUILDSTATS",
+        nargs="?",
+        type=pathlib.Path,
+        help="Buildstats file, or latest if not specified",
    )
    parser.add_argument(
        "--sort",
@@ -116,6 +120,16 @@ def main(argv=None) -> int:
    args = parser.parse_args(argv)
+    # If a buildstats file wasn't specified, try to find the last one
+    if not args.buildstats:
+        try:
+            builddir = pathlib.Path(os.environ["BUILDDIR"])
+            buildstats_dir = builddir / "tmp" / "buildstats"
+            args.buildstats = sorted(buildstats_dir.iterdir())[-1]
+        except KeyError:
+            print("Build environment has not been configured, cannot find buildstats")
+            return 1
    bs = read_buildstats(args.buildstats)
    dump_buildstats(args, bs)
diff --git a/scripts/clean-hashserver-database b/scripts/clean-hashserver-database
new file mode 100755
index 0000000000..9fa162c981
--- /dev/null
+++ b/scripts/clean-hashserver-database
@@ -0,0 +1,77 @@
+#!/bin/bash
+set -euo pipefail
+SSTATE_DIR=""
+BB_HASHCLIENT=""
+BB_HASHSERVER=""
+ALIVE_DB_MARK="alive"
+CLEAN_DB="false"
+THRESHOLD_AGE="3600"
+function help() {
+    cat <<HELP_TEXT
+Usage: $0 --sstate-dir path --hashclient path --hashserver-address address \
+[--mark value] [--clean-db] [--threshold-age seconds]
+Auxiliary script remove unused or no longer relevant entries from the hashequivalence database, based
+on the files available on the sstate directory.
+    -h | --help)               Show this help message and exit
+    -a | --hashserver-adress)  bitbake-hashserver address
+    -c | --hashclient)         Path to bitbake-hashclient
+    -m | --mark)               Marker string to mark database entries
+    -s | --sstate-dir)         Path to the sstate dir
+    -t | --threshold-age)      Remove unused entries older than SECONDS old (default: 3600)
+    --clean-db)                Remove all unmarked and unused entries from the database
+HELP_TEXT
+}
+function argument_parser() {
+    while [ $# -gt 0 ]; do
+        case "$1" in
+            -h | --help) help; exit 0 ;;
+            -a | --hashserver-address) BB_HASHSERVER="$2"; shift ;;
+            -c | --hashclient) BB_HASHCLIENT="$2"; shift ;;
+            -m | --mark) ALIVE_DB_MARK="$2"; shift ;;
+            -s | --sstate-dir) SSTATE_DIR="$2"; shift ;;
+            -t | --threshold-age) THRESHOLD_AGE="$2"; shift ;;
+            --clean-db) CLEAN_DB="true";;
+            *)
+                echo "Argument '$1' is not supported" >&2
+                help >&2
+                exit 1
+                ;;
+        esac
+        shift
+    done
+    function validate_mandatory_argument() {
+        local var_value="$1"
+        local error_message="$2"
+        if [ -z "$var_value" ]; then
+            echo "$error_message"
+            help >&2
+            exit 1
+        fi
+    }
+    validate_mandatory_argument "$SSTATE_DIR" "Please provide the path to the sstate dir."
+    validate_mandatory_argument "$BB_HASHCLIENT" "Please provide the path to bitbake-hashclient."
+    validate_mandatory_argument "$BB_HASHSERVER" "Please provide the address of bitbake-hashserver."
+}
+# -- main code --
+argument_parser $@
+# Mark all db sstate hashes
+find "$SSTATE_DIR" -name "*.tar.zst" | \
+sed 's/.*:\([^_]*\)_.*/unihash \1/' | \
+$BB_HASHCLIENT --address "$BB_HASHSERVER" gc-mark-stream "$ALIVE_DB_MARK"
+# Remove unmarked and unused entries
+if [ "$CLEAN_DB" = "true" ]; then
+    $BB_HASHCLIENT --address "$BB_HASHSERVER" gc-sweep "$ALIVE_DB_MARK"
+    $BB_HASHCLIENT --address "$BB_HASHSERVER" clean-unused "$THRESHOLD_AGE"
+fi
diff --git a/scripts/contrib/convert-spdx-licenses.py b/scripts/contrib/convert-spdx-licenses.py
index 4e194dee3f..13cf12a33f 100755
--- a/scripts/contrib/convert-spdx-licenses.py
+++ b/scripts/contrib/convert-spdx-licenses.py
@@ -93,7 +93,7 @@ license_map = {
 "Nauman" : "Naumen",
 "tcl" : "TCL",
 "vim" : "Vim",
-"SGIv1" : "SGI-1",
+"SGIv1" : "SGI-OpenGL",
 }
 def processfile(fn):
diff --git a/scripts/contrib/improve_kernel_cve_report.py b/scripts/contrib/improve_kernel_cve_report.py
new file mode 100755
index 0000000000..5c39df05a5
--- /dev/null
+++ b/scripts/contrib/improve_kernel_cve_report.py
@@ -0,0 +1,473 @@
+#! /usr/bin/env python3
+#
+# Copyright OpenEmbedded Contributors
+#
+# The script uses another source of CVE information from linux-vulns
+# to enrich the cve-summary from cve-check or vex.
+# It can also use the list of compiled files from the kernel spdx to ignore CVEs
+# that are not affected since the files are not compiled.
+#
+# It creates a new json file with updated CVE information
+#
+# Compiled files can be extracted adding the following in local.conf
+# SPDX_INCLUDE_COMPILED_SOURCES:pn-linux-yocto = "1"
+#
+# Tested with the following CVE sources:
+# - https://git.kernel.org/pub/scm/linux/security/vulns.git
+# - https://github.com/CVEProject/cvelistV5
+#
+# Example:
+# python3 ./openembedded-core/scripts/contrib/improve_kernel_cve_report.py --spdx tmp/deploy/spdx/3.0.1/qemux86_64/recipes/recipe-linux-yocto.spdx.json --kernel-version 6.12.27 --datadir ./vulns
+# python3 ./openembedded-core/scripts/contrib/improve_kernel_cve_report.py --spdx tmp/deploy/spdx/3.0.1/qemux86_64/recipes/recipe-linux-yocto.spdx.json --datadir ./vulns --old-cve-report build/tmp/log/cve/cve-summary.json
+#
+# SPDX-License-Identifier: GPLv2
+import argparse
+import json
+import sys
+import logging
+import glob
+import os
+import pathlib
+from packaging.version import Version
+def is_linux_cve(cve_info):
+    '''Return true is the CVE belongs to Linux'''
+    if not "affected" in cve_info["containers"]["cna"]:
+        return False
+    for affected in cve_info["containers"]["cna"]["affected"]:
+        if not "product" in affected:
+            return False
+        if affected["product"] == "Linux" and affected["vendor"] == "Linux":
+            return True
+    return False
+def get_kernel_cves(datadir, compiled_files, version):
+    """
+    Get CVEs for the kernel
+    """
+    cves = {}
+    check_config = len(compiled_files) > 0
+    base_version = Version(f"{version.major}.{version.minor}")
+    # Check all CVES from kernel vulns
+    pattern = os.path.join(datadir, '**', "CVE-*.json")
+    cve_files = glob.glob(pattern, recursive=True)
+    not_applicable_config = 0
+    fixed_as_later_backport = 0
+    vulnerable = 0
+    not_vulnerable = 0
+    for cve_file in sorted(cve_files):
+        cve_info = {}
+        with open(cve_file, "r", encoding='ISO-8859-1') as f:
+            cve_info = json.load(f)
+        if len(cve_info) == 0:
+            logging.error("Not valid data in %s. Aborting", cve_file)
+            break
+        if not is_linux_cve(cve_info):
+            continue
+        cve_id = os.path.basename(cve_file)[:-5]
+        description = cve_info["containers"]["cna"]["descriptions"][0]["value"]
+        if cve_file.find("rejected") >= 0:
+            logging.debug("%s is rejected by the CNA", cve_id)
+            cves[cve_id] = {
+                "id": cve_id,
+                "status": "Ignored",
+                "detail": "rejected",
+                "summary": description,
+                "description": f"Rejected by CNA"
+            }
+            continue
+        if any(elem in cve_file for elem in ["review", "reverved", "testing"]):
+            continue
+        is_vulnerable, first_affected, last_affected, better_match_first, better_match_last, affected_versions = get_cpe_applicability(cve_info, version)
+        logging.debug("%s: %s (%s - %s) (%s - %s)", cve_id, is_vulnerable, better_match_first, better_match_last, first_affected, last_affected)
+        if is_vulnerable is None:
+            logging.warning("%s doesn't have good metadata", cve_id)
+        if is_vulnerable:
+            is_affected = True
+            affected_files = []
+            if check_config:
+                is_affected, affected_files = check_kernel_compiled_files(compiled_files, cve_info)
+            if not is_affected and len(affected_files) > 0:
+                logging.debug(
+                    "%s - not applicable configuration since affected files not compiled: %s",
+                    cve_id, affected_files)
+                cves[cve_id] = {
+                    "id": cve_id,
+                    "status": "Ignored",
+                    "detail": "not-applicable-config",
+                    "summary": description,
+                    "description": f"Source code not compiled by config. {affected_files}"
+                }
+                not_applicable_config +=1
+            # Check if we have backport
+            else:
+                if not better_match_last:
+                    fixed_in = last_affected
+                else:
+                    fixed_in = better_match_last
+                logging.debug("%s needs backporting (fixed from %s)", cve_id, fixed_in)
+                cves[cve_id] = {
+                        "id": cve_id,
+                        "status": "Unpatched",
+                        "detail": "version-in-range",
+                        "summary": description,
+                        "description": f"Needs backporting (fixed from {fixed_in})"
+                }
+                vulnerable += 1
+                if (better_match_last and
+                    Version(f"{better_match_last.major}.{better_match_last.minor}") == base_version):
+                    fixed_as_later_backport += 1
+        # Not vulnerable
+        else:
+            if not first_affected:
+                logging.debug("%s - not known affected %s",
+                              cve_id,
+                              better_match_last)
+                cves[cve_id] = {
+                    "id": cve_id,
+                    "status": "Patched",
+                    "detail": "version-not-in-range",
+                    "summary": description,
+                    "description": "No CPE match"
+                }
+                not_vulnerable += 1
+                continue
+            backport_base = Version(f"{better_match_last.major}.{better_match_last.minor}")
+            if version < first_affected:
+                logging.debug('%s - fixed-version: only affects %s onwards',
+                              cve_id,
+                              first_affected)
+                cves[cve_id] = {
+                    "id": cve_id,
+                    "status": "Patched",
+                    "detail": "fixed-version",
+                    "summary": description,
+                    "description": f"only affects {first_affected} onwards"
+                }
+                not_vulnerable += 1
+            elif last_affected <= version:
+                logging.debug("%s - fixed-version: Fixed from version %s",
+                              cve_id,
+                              last_affected)
+                cves[cve_id] = {
+                    "id": cve_id,
+                    "status": "Patched",
+                    "detail": "fixed-version",
+                    "summary": description,
+                    "description": f"fixed-version: Fixed from version {last_affected}"
+                }
+                not_vulnerable += 1
+            elif backport_base == base_version:
+                logging.debug("%s - cpe-stable-backport: Backported in %s",
+                              cve_id,
+                              better_match_last)
+                cves[cve_id] = {
+                    "id": cve_id,
+                    "status": "Patched",
+                    "detail": "cpe-stable-backport",
+                    "summary": description,
+                    "description": f"Backported in {better_match_last}"
+                }
+                not_vulnerable += 1
+            else:
+                logging.debug("%s - version not affected %s", cve_id, str(affected_versions))
+                cves[cve_id] = {
+                    "id": cve_id,
+                    "status": "Patched",
+                    "detail": "version-not-in-range",
+                    "summary": description,
+                    "description": f"Range {affected_versions}"
+                }
+                not_vulnerable += 1
+    logging.info("Total CVEs ignored due to not applicable config: %d", not_applicable_config)
+    logging.info("Total CVEs not vulnerable due version-not-in-range: %d", not_vulnerable)
+    logging.info("Total vulnerable CVEs: %d", vulnerable)
+    logging.info("Total CVEs already backported in %s: %s", base_version,
+                    fixed_as_later_backport)
+    return cves
+def read_spdx(spdx_file):
+    '''Open SPDX file and extract compiled files'''
+    with open(spdx_file, 'r', encoding='ISO-8859-1') as f:
+        spdx = json.load(f)
+        if "spdxVersion" in spdx:
+            if spdx["spdxVersion"] == "SPDX-2.2":
+                return read_spdx2(spdx)
+        if "@graph" in spdx:
+            return read_spdx3(spdx)
+    return []
+def read_spdx2(spdx):
+    '''
+    Read spdx2 compiled files from spdx
+    '''
+    cfiles = set()
+    if 'files' not in spdx:
+        return cfiles
+    for item in spdx['files']:
+        for ftype in item['fileTypes']:
+            if ftype == "SOURCE":
+                filename = item["fileName"][item["fileName"].find("/")+1:]
+                cfiles.add(filename)
+    return cfiles
+def read_spdx3(spdx):
+    '''
+    Read spdx3 compiled files from spdx
+    '''
+    cfiles = set()
+    for item in spdx["@graph"]:
+        if "software_primaryPurpose" not in item:
+            continue
+        if item["software_primaryPurpose"] == "source":
+            filename = item['name'][item['name'].find("/")+1:]
+            cfiles.add(filename)
+    return cfiles
+def check_kernel_compiled_files(compiled_files, cve_info):
+    """
+    Return if a CVE affected us depending on compiled files
+    """
+    files_affected = set()
+    is_affected = False
+    for item in cve_info['containers']['cna']['affected']:
+        if "programFiles" in item:
+            for f in item['programFiles']:
+                if f not in files_affected:
+                    files_affected.add(f)
+    if len(files_affected) > 0:
+        for f in files_affected:
+            if f in compiled_files:
+                logging.debug("File match: %s", f)
+                is_affected = True
+    return is_affected, files_affected
+def get_cpe_applicability(cve_info, v):
+    '''
+    Check if version is affected and return affected versions
+    '''
+    base_branch = Version(f"{v.major}.{v.minor}")
+    affected = []
+    if not 'cpeApplicability' in cve_info["containers"]["cna"]:
+        return None, None, None, None, None, None
+    for nodes in cve_info["containers"]["cna"]["cpeApplicability"]:
+        for node in nodes.values():
+            vulnerable = False
+            matched_branch = False
+            first_affected = Version("5000")
+            last_affected = Version("0")
+            better_match_first = Version("0")
+            better_match_last = Version("5000")
+            if len(node[0]['cpeMatch']) == 0:
+                first_affected = None
+                last_affected = None
+                better_match_first = None
+                better_match_last = None
+            for cpe_match in node[0]['cpeMatch']:
+                version_start_including = Version("0")
+                version_end_excluding = Version("0")
+                if 'versionStartIncluding' in cpe_match:
+                    version_start_including = Version(cpe_match['versionStartIncluding'])
+                else:
+                    version_start_including = Version("0")
+                # if versionEndExcluding is missing we are in a branch, which is not fixed.
+                if "versionEndExcluding" in cpe_match:
+                    version_end_excluding = Version(cpe_match["versionEndExcluding"])
+                else:
+                    # if versionEndExcluding is missing we are in a branch, which is not fixed.
+                    version_end_excluding = Version(
+                        f"{version_start_including.major}.{version_start_including.minor}.5000"
+                    )
+                affected.append(f" {version_start_including}-{version_end_excluding}")
+                # Detect if versionEnd is in fixed in base branch. It has precedence over the rest
+                branch_end = Version(f"{version_end_excluding.major}.{version_end_excluding.minor}")
+                if branch_end == base_branch:
+                    if version_start_including <= v < version_end_excluding:
+                        vulnerable = cpe_match['vulnerable']
+                    # If we don't match in our branch, we are not vulnerable,
+                    # since we have a backport
+                    matched_branch = True
+                    better_match_first = version_start_including
+                    better_match_last = version_end_excluding
+                if version_start_including <= v < version_end_excluding and not matched_branch:
+                    if version_end_excluding < better_match_last:
+                        better_match_first = max(version_start_including, better_match_first)
+                        better_match_last = min(better_match_last, version_end_excluding)
+                        vulnerable = cpe_match['vulnerable']
+                        matched_branch = True
+                first_affected = min(version_start_including, first_affected)
+                last_affected = max(version_end_excluding, last_affected)
+            # Not a better match, we use the first and last affected instead of the fake .5000
+            if vulnerable and better_match_last == Version(f"{base_branch}.5000"):
+                better_match_last = last_affected
+                better_match_first = first_affected
+    return vulnerable, first_affected, last_affected, better_match_first, better_match_last, affected
+def copy_data(old, new):
+    '''Update dictionary with new entries, while keeping the old ones'''
+    for k in new.keys():
+        old[k] = new[k]
+    return old
+# Function taken from cve_check.bbclass. Adapted to cve fields
+def cve_update(cve_data, cve, entry):
+    # If no entry, just add it
+    if cve not in cve_data:
+        cve_data[cve] = entry
+        return
+    # If we are updating, there might be change in the status
+    if cve_data[cve]['status'] == "Unknown":
+        cve_data[cve] = copy_data(cve_data[cve], entry)
+        return
+    if cve_data[cve]['status'] == entry['status']:
+        return
+    if entry['status'] == "Unpatched" and cve_data[cve]['status'] == "Patched":
+        # Backported-patch (e.g. vendor kernel repo with cherry-picked CVE patch)
+        # has priority over unpatch from CNA
+        if cve_data[cve]['detail'] == "backported-patch":
+            return
+        logging.warning("CVE entry %s update from Patched to Unpatched from the scan result", cve)
+        cve_data[cve] = copy_data(cve_data[cve], entry)
+        return
+    if entry['status'] == "Patched" and cve_data[cve]['status'] == "Unpatched":
+        logging.warning("CVE entry %s update from Unpatched to Patched from the scan result", cve)
+        cve_data[cve] = copy_data(cve_data[cve], entry)
+        return
+    # If we have an "Ignored", it has a priority
+    if cve_data[cve]['status'] == "Ignored":
+        logging.debug("CVE %s not updating because Ignored", cve)
+        return
+    # If we have an "Ignored", it has a priority
+    if entry['status'] == "Ignored":
+        cve_data[cve] = copy_data(cve_data[cve], entry)
+        logging.debug("CVE entry %s updated from Unpatched to Ignored", cve)
+        return
+    logging.warning("Unhandled CVE entry update for %s %s from %s %s to %s",
+        cve, cve_data[cve]['status'], cve_data[cve]['detail'],  entry['status'], entry['detail'])
+def main():
+    parser = argparse.ArgumentParser(
+        description="Update cve-summary with kernel compiled files and kernel CVE information"
+    )
+    parser.add_argument(
+        "-s",
+        "--spdx",
+        help="SPDX2/3 for the kernel. Needs to include compiled sources",
+    )
+    parser.add_argument(
+        "--datadir",
+        type=pathlib.Path,
+        help="Directory where CVE data is",
+        required=True
+    )
+    parser.add_argument(
+        "--old-cve-report",
+        help="CVE report to update. (Optional)",
+    )
+    parser.add_argument(
+        "--kernel-version",
+        help="Kernel version. Needed if old cve_report is not provided (Optional)",
+        type=Version
+    )
+    parser.add_argument(
+        "--new-cve-report",
+        help="Output file",
+        default="cve-summary-enhance.json"
+    )
+    parser.add_argument(
+        "-D",
+        "--debug",
+        help='Enable debug ',
+        action="store_true")
+    args = parser.parse_args()
+    if args.debug:
+        log_level=logging.DEBUG
+    else:
+        log_level=logging.INFO
+    logging.basicConfig(format='[%(filename)s:%(lineno)d] %(message)s', level=log_level)
+    if not args.kernel_version and not args.old_cve_report:
+        parser.error("either --kernel-version or --old-cve-report are needed")
+        return -1
+    # by default we don't check the compiled files, unless provided
+    compiled_files = []
+    if args.spdx:
+        compiled_files = read_spdx(args.spdx)
+        logging.info("Total compiled files %d", len(compiled_files))
+    if args.old_cve_report:
+        with open(args.old_cve_report, encoding='ISO-8859-1') as f:
+            cve_report = json.load(f)
+    else:
+        #If summary not provided, we create one
+        cve_report = {
+            "version": "1",
+            "package": [
+                {
+                    "name": "linux-yocto",
+                    "version": str(args.kernel_version),
+                    "products": [
+                        {
+                            "product": "linux_kernel",
+                            "cvesInRecord": "Yes"
+                        }
+                    ],
+                    "issue": []
+                }
+            ]
+        }
+    for pkg in cve_report['package']:
+        is_kernel = False
+        for product in pkg['products']:
+            if product['product'] == "linux_kernel":
+                is_kernel=True
+        if not is_kernel:
+            continue
+        # We remove custom versions after -
+        upstream_version = Version(pkg["version"].split("-")[0])
+        logging.info("Checking kernel %s", upstream_version)
+        kernel_cves = get_kernel_cves(args.datadir,
+                                      compiled_files,
+                                      upstream_version)
+        logging.info("Total kernel cves from kernel CNA: %s", len(kernel_cves))
+        cves = {issue["id"]: issue for issue in pkg["issue"]}
+        logging.info("Total kernel before processing cves: %s", len(cves))
+        for cve in kernel_cves:
+            cve_update(cves, cve, kernel_cves[cve])
+        pkg["issue"] = []
+        for cve in sorted(cves):
+            pkg["issue"].extend([cves[cve]])
+        logging.info("Total kernel cves after processing: %s", len(pkg['issue']))
+    with open(args.new_cve_report, "w", encoding='ISO-8859-1') as f:
+        json.dump(cve_report, f, indent=2)
+    return 0
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/scripts/contrib/make-spdx-bindings.sh b/scripts/contrib/make-spdx-bindings.sh
new file mode 100755
index 0000000000..31caaf339d
--- /dev/null
+++ b/scripts/contrib/make-spdx-bindings.sh
@@ -0,0 +1,12 @@
+#! /bin/sh
+#
+# SPDX-License-Identifier: MIT
+THIS_DIR="$(dirname "$0")"
+VERSION="3.0.1"
+shacl2code generate --input https://spdx.org/rdf/$VERSION/spdx-model.ttl \
+    --input https://spdx.org/rdf/$VERSION/spdx-json-serialize-annotations.ttl \
+    --context https://spdx.org/rdf/$VERSION/spdx-context.jsonld \
+    python -o $THIS_DIR/../../meta/lib/oe/spdx30.py
diff --git a/scripts/contrib/oe-image-files-spdx/.gitignore b/scripts/contrib/oe-image-files-spdx/.gitignore
new file mode 100644
index 0000000000..285851c984
--- /dev/null
+++ b/scripts/contrib/oe-image-files-spdx/.gitignore
@@ -0,0 +1,8 @@
+*.spdx.json
+*.pyc
+*.bak
+*.swp
+*.swo
+*.swn
+venv/*
+.venv/*
diff --git a/scripts/contrib/oe-image-files-spdx/README.md b/scripts/contrib/oe-image-files-spdx/README.md
new file mode 100644
index 0000000000..44f76eacd8
--- /dev/null
+++ b/scripts/contrib/oe-image-files-spdx/README.md
@@ -0,0 +1,24 @@
+# OE Image Files from SBoM
+This is an example python script that will list the packaged files with their
+checksums based on the SPDX 3.0.1 SBoM.
+It can be used as a template for other programs to investigate output based on
+OE SPDX SBoMs
+## Installation
+This project can be installed using an virtual environment:
+```
+python3 -m venv .venv
+.venv/bin/activate
+python3 -m pip install -e '.[dev]'
+```
+## Usage
+After installing, the `oe-image-files` program can be used to show the files, e.g.:
+```
+oe-image-files core-image-minimal-qemux86-64.rootfs.spdx.json
+```
diff --git a/scripts/contrib/oe-image-files-spdx/pyproject.toml b/scripts/contrib/oe-image-files-spdx/pyproject.toml
new file mode 100644
index 0000000000..3fab5dd605
--- /dev/null
+++ b/scripts/contrib/oe-image-files-spdx/pyproject.toml
@@ -0,0 +1,23 @@
+[project]
+name = "oe-image-files"
+description = "Displays all packaged files on the root file system"
+dynamic = ["version"]
+requires-python = ">= 3.8"
+readme = "README.md"
+dependencies = [
+    "spdx_python_model @ git+https://github.com/spdx/spdx-python-model.git@aa40861f11d1b5d20edba7101835341a70d91179",
+]
+[project.scripts]
+oe-image-files = "oe_image_files:main"
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+[tool.hatch.version]
+path = "src/oe_image_files/version.py"
+[tool.hatch.metadata]
+allow-direct-references = true
diff --git a/scripts/contrib/oe-image-files-spdx/src/oe_image_files/__init__.py b/scripts/contrib/oe-image-files-spdx/src/oe_image_files/__init__.py
new file mode 100644
index 0000000000..c28a133f2d
--- /dev/null
+++ b/scripts/contrib/oe-image-files-spdx/src/oe_image_files/__init__.py
@@ -0,0 +1 @@
+from .main import main
diff --git a/scripts/contrib/oe-image-files-spdx/src/oe_image_files/main.py b/scripts/contrib/oe-image-files-spdx/src/oe_image_files/main.py
new file mode 100644
index 0000000000..8476bf6369
--- /dev/null
+++ b/scripts/contrib/oe-image-files-spdx/src/oe_image_files/main.py
@@ -0,0 +1,86 @@
+# SPDX-License-Identifier: MIT
+import argparse
+from pathlib import Path
+from spdx_python_model import v3_0_1 as spdx_3_0_1
+from .version import VERSION
+def main():
+    parser = argparse.ArgumentParser(
+        description="Show the packaged files and checksums in an OE image from the SPDX SBoM"
+    )
+    parser.add_argument("file", help="SPDX 3 input file", type=Path)
+    parser.add_argument("--version", "-V", action="version", version=VERSION)
+    args = parser.parse_args()
+    # Load SPDX data from file into a new object set
+    objset = spdx_3_0_1.SHACLObjectSet()
+    with args.file.open("r") as f:
+        d = spdx_3_0_1.JSONLDDeserializer()
+        d.read(f, objset)
+    # Find the top level SPDX Document object
+    for o in objset.foreach_type(spdx_3_0_1.SpdxDocument):
+        doc = o
+        break
+    else:
+        print("ERROR: No SPDX Document found!")
+        return 1
+    # Find the root SBoM in the document
+    for o in doc.rootElement:
+        if isinstance(o, spdx_3_0_1.software_Sbom):
+            sbom = o
+            break
+    else:
+        print("ERROR: SBoM not found in document")
+        return 1
+    # Find the root file system package in the SBoM
+    for o in sbom.rootElement:
+        if (
+            isinstance(o, spdx_3_0_1.software_Package)
+            and o.software_primaryPurpose == spdx_3_0_1.software_SoftwarePurpose.archive
+        ):
+            root_package = o
+            break
+    else:
+        print("ERROR: Package not found in document")
+        return 1
+    # Find all relationships of type "contains" that go FROM the root file
+    # system
+    files = []
+    for rel in objset.foreach_type(spdx_3_0_1.Relationship):
+        if not rel.relationshipType == spdx_3_0_1.RelationshipType.contains:
+            continue
+        if not rel.from_ is root_package:
+            continue
+        # Iterate over all files in the TO of the relationship
+        for o in rel.to:
+            if not isinstance(o, spdx_3_0_1.software_File):
+                continue
+            # Find the SHA 256 hash of the file (if any)
+            for h in o.verifiedUsing:
+                if (
+                    isinstance(h, spdx_3_0_1.Hash)
+                    and h.algorithm == spdx_3_0_1.HashAlgorithm.sha256
+                ):
+                    files.append((o.name, h.hashValue))
+                    break
+            else:
+                files.append((o.name, ""))
+    # Print files
+    files.sort(key=lambda x: x[0])
+    for name, hash_val in files:
+        print(f"{name} - {hash_val}")
+    return 0
diff --git a/scripts/contrib/oe-image-files-spdx/src/oe_image_files/version.py b/scripts/contrib/oe-image-files-spdx/src/oe_image_files/version.py
new file mode 100644
index 0000000000..901e5110b2
--- /dev/null
+++ b/scripts/contrib/oe-image-files-spdx/src/oe_image_files/version.py
@@ -0,0 +1 @@
+VERSION = "0.0.1"
diff --git a/scripts/contrib/patchreview.py b/scripts/contrib/patchreview.py
index bceae06561..d8d7b214e5 100755
--- a/scripts/contrib/patchreview.py
+++ b/scripts/contrib/patchreview.py
@@ -14,6 +14,10 @@ import pathlib
 import re
 import subprocess
+import sys
+sys.path.append(os.path.join(sys.path[0], '../../meta/lib'))
+import oe.qa
 # TODO
 # - option to just list all broken files
 # - test suite
@@ -47,7 +51,7 @@ def blame_patch(patch):
    return subprocess.check_output(("git", "log",
                                    "--follow", "--find-renames", "--diff-filter=A",
                                    "--format=%s (%aN <%aE>)",
-                                    "--", patch)).decode("utf-8").splitlines()
+                                    "--", patch), cwd=os.path.dirname(patch)).decode("utf-8").splitlines()
 def patchreview(patches):
@@ -78,12 +82,11 @@ def patchreview(patches):
        else:
            result.missing_sob = True
        # Find the Upstream-Status tag
        match = status_re.search(content)
        if match:
-            value = match.group(1)
+            value = oe.qa.check_upstream_status(patch)
-            if value != "Upstream-Status:":
+            if value:
                result.malformed_upstream_status = value
            value = match.group(2).lower()
diff --git a/scripts/cve-json-to-text.py b/scripts/cve-json-to-text.py
new file mode 100755
index 0000000000..8d309b37e5
--- /dev/null
+++ b/scripts/cve-json-to-text.py
@@ -0,0 +1,146 @@
+#!/bin/env python3
+# SPDX-FileCopyrightText: OpenEmbedded Contributors
+#
+# SPDX-License-Identifier: MIT
+# CVE results conversion script: JSON format to text
+# Derived from cve-report.py from Oniro (MIT, by Huawei Inc)
+import sys
+import getopt
+infile = "in.json"
+outfile = "out.txt"
+def show_syntax_and_exit(code):
+    """
+    Show the program syntax and exit with an errror
+    Arguments:
+        code: the error code to return
+    """
+    print("Syntax: %s [-h] [-i inputJSONfile][-o outputfile]" % sys.argv[0])
+    sys.exit(code)
+def exit_error(code, message):
+    """
+    Show the error message and exit with an errror
+    Arguments:
+        code: the error code to return
+        message: the message to show
+    """
+    print("Error: %s" % message)
+    sys.exit(code)
+def parse_args(argv):
+    """
+    Parse the program arguments, put options in global variables
+    Arguments:
+        argv: program arguments
+    """
+    global infile, outfile
+    try:
+        opts, args = getopt.getopt(
+            argv, "hi:o:", ["help", "input", "output"]
+        )
+    except getopt.GetoptError:
+        show_syntax_and_exit(1)
+    for opt, arg in opts:
+        if opt in ("-h"):
+            show_syntax_and_exit(0)
+        elif opt in ("-i"):
+            infile = arg
+        elif opt in ("-o"):
+            outfile = arg
+def load_json(filename):
+    """
+    Load the JSON file, return the resulting dictionary
+    Arguments:
+        filename: the file to open
+    Returns:
+        Parsed file as a dictionary
+    """
+    import json
+    out = {}
+    try:
+        with open(filename, "r") as f:
+            out = json.load(f)
+    except FileNotFoundError:
+        exit_error(1, "Input file (%s) not found" % (filename))
+    except json.decoder.JSONDecodeError as error:
+        exit_error(1, "Malformed JSON file: %s" % str(error))
+    return out
+def process_data(filename, data):
+    """
+    Write the resulting CSV with one line for each package
+    Arguments:
+        filename: the file to write to
+        data: dictionary from parsing the JSON file
+    Returns:
+        None
+    """
+    if not "version" in data or data["version"] != "1":
+        exit_error(1, "Unrecognized format version number")
+    if not "package" in data:
+        exit_error(1, "Mandatory 'package' key not found")
+    lines = ""
+    total_issue_count = 0
+    for package in data["package"]:
+        package_info = ""
+        keys_in_package = {"name", "layer", "version", "issue"}
+        if keys_in_package - package.keys():
+            exit_error(
+                1,
+                "Missing a mandatory key in package: %s"
+                % (keys_in_package - package.keys()),
+            )
+        package_info += "LAYER: %s\n" % package["layer"]
+        package_info += "PACKAGE NAME: %s\n" % package["name"]
+        package_info += "PACKAGE VERSION: %s\n" % package["version"]
+        for issue in package["issue"]:
+            keys_in_issue = {"id", "status", "detail"}
+            if keys_in_issue - issue.keys():
+                print("Warning: Missing keys %s in 'issue' for the package '%s'"
+                    % (keys_in_issue - issue.keys(), package["name"]))
+            lines += package_info
+            lines += "CVE: %s\n" % issue["id"]
+            lines += "CVE STATUS: %s\n" % issue["status"]
+            lines += "CVE DETAIL: %s\n" % issue["detail"]
+            if "description" in issue:
+                lines += "CVE DESCRIPTION: %s\n" % issue["description"]
+            if "summary" in issue:
+                lines += "CVE SUMMARY: %s\n" % issue["summary"]
+            if "scorev2" in issue:
+                lines += "CVSS v2 BASE SCORE: %s\n" % issue["scorev2"]
+            if "scorev3" in issue:
+                lines += "CVSS v3 BASE SCORE: %s\n" % issue["scorev3"]
+            if "scorev4" in issue:
+                lines += "CVSS v4 BASE SCORE: %s\n" % issue["scorev4"]
+            if "vector" in issue:
+                lines += "VECTOR: %s\n" % issue["vector"]
+            if "vectorString" in issue:
+                lines += "VECTORSTRING: %s\n" % issue["vectorString"]
+            lines += "MORE INFORMATION: https://nvd.nist.gov/vuln/detail/%s\n" % issue["id"]
+            lines += "\n"
+    with open(filename, "w") as f:
+        f.write(lines)
+def main(argv):
+    parse_args(argv)
+    data = load_json(infile)
+    process_data(outfile, data)
+if __name__ == "__main__":
+    main(sys.argv[1:])
diff --git a/scripts/devtool b/scripts/devtool
index 60ea3e8298..39cebec0d8 100755
--- a/scripts/devtool
+++ b/scripts/devtool
@@ -7,19 +7,17 @@
 # SPDX-License-Identifier: GPL-2.0-only
 #
+import dataclasses
 import sys
 import os
 import argparse
 import glob
 import re
 import configparser
-import subprocess
 import logging
-basepath = ''
+# This can be removed once our minimum is Python 3.9: https://docs.python.org/3/whatsnew/3.9.html#type-hinting-generics-in-standard-collections
-workspace = {}
+from typing import List
-config = None
-context = None
 scripts_path = os.path.dirname(os.path.realpath(__file__))
@@ -30,16 +28,16 @@ import scriptutils
 import argparse_oe
 logger = scriptutils.logger_create('devtool')
-plugins = []
+class ConfigHandler:
-class ConfigHandler(object):
+    basepath = None
    config_file = ''
    config_obj = None
    init_path = ''
    workspace_path = ''
-    def __init__(self, filename):
+    def __init__(self, basepath, filename):
+        self.basepath = basepath
        self.config_file = filename
        self.config_obj = configparser.ConfigParser()
@@ -47,7 +45,7 @@ class ConfigHandler(object):
        try:
            ret = self.config_obj.get(section, option)
        except (configparser.NoOptionError, configparser.NoSectionError):
-            if default != None:
+            if default is not None:
                ret = default
            else:
                raise
@@ -59,14 +57,14 @@ class ConfigHandler(object):
            if self.config_obj.has_option('General', 'init_path'):
                pth = self.get('General', 'init_path')
-                self.init_path = os.path.join(basepath, pth)
+                self.init_path = os.path.join(self.basepath, pth)
                if not os.path.exists(self.init_path):
                    logger.error('init_path %s specified in config file cannot be found' % pth)
                    return False
        else:
            self.config_obj.add_section('General')
-        self.workspace_path = self.get('General', 'workspace_path', os.path.join(basepath, 'workspace'))
+        self.workspace_path = self.get('General', 'workspace_path', os.path.join(self.basepath, 'workspace'))
        return True
@@ -81,27 +79,29 @@ class ConfigHandler(object):
            self.config_obj.add_section(section)
        self.config_obj.set(section, option, value)
+@dataclasses.dataclass
 class Context:
-    def __init__(self, **kwargs):
+    fixed_setup: bool
-        self.__dict__.update(kwargs)
+    config: ConfigHandler
+    pluginpaths: List[str]
-def read_workspace():
+def read_workspace(basepath, context):
-    global workspace
    workspace = {}
-    if not os.path.exists(os.path.join(config.workspace_path, 'conf', 'layer.conf')):
+    if not os.path.exists(os.path.join(context.config.workspace_path, 'conf', 'layer.conf')):
        if context.fixed_setup:
            logger.error("workspace layer not set up")
            sys.exit(1)
        else:
-            logger.info('Creating workspace layer in %s' % config.workspace_path)
+            logger.info('Creating workspace layer in %s' % context.config.workspace_path)
-            _create_workspace(config.workspace_path, config, basepath)
+            _create_workspace(context.config.workspace_path, basepath)
    if not context.fixed_setup:
-        _enable_workspace_layer(config.workspace_path, config, basepath)
+        _enable_workspace_layer(context.config.workspace_path, context.config, basepath)
-    logger.debug('Reading workspace in %s' % config.workspace_path)
+    logger.debug('Reading workspace in %s' % context.config.workspace_path)
    externalsrc_re = re.compile(r'^EXTERNALSRC(:pn-([^ =]+))? *= *"([^"]*)"$')
-    for fn in glob.glob(os.path.join(config.workspace_path, 'appends', '*.bbappend')):
+    for fn in glob.glob(os.path.join(context.config.workspace_path, 'appends', '*.bbappend')):
        with open(fn, 'r') as f:
            pnvalues = {}
            pn = None
@@ -112,7 +112,7 @@ def read_workspace():
                    pn = res.group(2) or recipepn
                    # Find the recipe file within the workspace, if any
                    bbfile = os.path.basename(fn).replace('.bbappend', '.bb').replace('%', '*')
-                    recipefile = glob.glob(os.path.join(config.workspace_path,
+                    recipefile = glob.glob(os.path.join(context.config.workspace_path,
                                                        'recipes',
                                                        recipepn,
                                                        bbfile))
@@ -126,13 +126,15 @@ def read_workspace():
            if pnvalues:
                if not pn:
                    raise DevtoolError("Found *.bbappend in %s, but could not determine EXTERNALSRC:pn-*. "
-                            "Maybe still using old syntax?" % config.workspace_path)
+                            "Maybe still using old syntax?" % context.config.workspace_path)
                if not pnvalues.get('srctreebase', None):
                    pnvalues['srctreebase'] = pnvalues['srctree']
                logger.debug('Found recipe %s' % pnvalues)
                workspace[pn] = pnvalues
-def create_workspace(args, config, basepath, workspace):
+    return workspace
+def create_workspace(args, config, basepath, _workspace):
    if args.layerpath:
        workspacedir = os.path.abspath(args.layerpath)
    else:
@@ -140,12 +142,12 @@ def create_workspace(args, config, basepath, workspace):
    layerseries = None
    if args.layerseries:
        layerseries = args.layerseries
-    _create_workspace(workspacedir, config, basepath, layerseries)
+    _create_workspace(workspacedir, basepath, layerseries)
    if not args.create_only:
        _enable_workspace_layer(workspacedir, config, basepath)
-def _create_workspace(workspacedir, config, basepath, layerseries=None):
+def _create_workspace(workspacedir, basepath, layerseries=None):
-    import bb
+    import bb.utils
    confdir = os.path.join(workspacedir, 'conf')
    if os.path.exists(os.path.join(confdir, 'layer.conf')):
@@ -190,7 +192,7 @@ def _create_workspace(workspacedir, config, basepath, layerseries=None):
 def _enable_workspace_layer(workspacedir, config, basepath):
    """Ensure the workspace layer is in bblayers.conf"""
-    import bb
+    import bb.utils
    bblayers_conf = os.path.join(basepath, 'conf', 'bblayers.conf')
    if not os.path.exists(bblayers_conf):
        logger.error('Unable to find bblayers.conf')
@@ -209,15 +211,9 @@ def _enable_workspace_layer(workspacedir, config, basepath):
 def main():
-    global basepath
-    global config
-    global context
    if sys.getfilesystemencoding() != "utf-8":
        sys.exit("Please use a locale setting which supports utf-8.\nPython can't change the filesystem locale after loading so we need a utf-8 when python starts or things won't work.")
-    context = Context(fixed_setup=False)
    # Default basepath
    basepath = os.path.dirname(os.path.abspath(__file__))
@@ -242,21 +238,23 @@ def main():
    elif global_args.quiet:
        logger.setLevel(logging.ERROR)
+    is_fixed_setup = False
    if global_args.basepath:
        # Override
        basepath = global_args.basepath
        if os.path.exists(os.path.join(basepath, '.devtoolbase')):
-            context.fixed_setup = True
+            is_fixed_setup = True
    else:
        pth = basepath
        while pth != '' and pth != os.sep:
            if os.path.exists(os.path.join(pth, '.devtoolbase')):
-                context.fixed_setup = True
+                is_fixed_setup = True
                basepath = pth
                break
            pth = os.path.dirname(pth)
-        if not context.fixed_setup:
+        if not is_fixed_setup:
            basepath = os.environ.get('BUILDDIR')
            if not basepath:
                logger.error("This script can only be run after initialising the build environment (e.g. by using oe-init-build-env)")
@@ -264,10 +262,9 @@ def main():
    logger.debug('Using basepath %s' % basepath)
-    config = ConfigHandler(os.path.join(basepath, 'conf', 'devtool.conf'))
+    config = ConfigHandler(basepath, os.path.join(basepath, 'conf', 'devtool.conf'))
    if not config.read():
        return -1
-    context.config = config
    bitbake_subdir = config.get('General', 'bitbake_subdir', '')
    if bitbake_subdir:
@@ -289,6 +286,7 @@ def main():
    scriptutils.logger_setup_color(logger, global_args.color)
    if global_args.bbpath is None:
+        import bb
        try:
            tinfoil = setup_tinfoil(config_only=True, basepath=basepath)
            try:
@@ -300,7 +298,10 @@ def main():
    # Search BBPATH first to allow layers to override plugins in scripts_path
    pluginpaths = [os.path.join(path, 'lib', 'devtool') for path in global_args.bbpath.split(':') + [scripts_path]]
-    context.pluginpaths = pluginpaths
+    context = Context(fixed_setup=is_fixed_setup, config=config, pluginpaths=pluginpaths)
+    plugins = []
    for pluginpath in pluginpaths:
        scriptutils.load_plugins(logger, plugins, pluginpath)
@@ -331,9 +332,9 @@ def main():
    args = parser.parse_args(unparsed_args, namespace=global_args)
    try:
+        workspace = {}
        if not getattr(args, 'no_workspace', False):
-            read_workspace()
+            workspace = read_workspace(basepath, context)
        ret = args.func(args, config, basepath, workspace)
    except DevtoolError as err:
        if str(err):
@@ -341,6 +342,7 @@ def main():
        ret = err.exitcode
    except argparse_oe.ArgumentUsageError as ae:
        parser.error_subcommand(ae.message, ae.subcommand)
+        ret = 2
    return ret
diff --git a/scripts/gen-site-config b/scripts/gen-site-config
deleted file mode 100755
index 727b809c0f..0000000000
--- a/scripts/gen-site-config
+++ /dev/null
@@ -1,43 +0,0 @@
-#! /bin/sh
-#  Copyright (c) 2005-2008 Wind River Systems, Inc.
-#
-# SPDX-License-Identifier: GPL-2.0-only
-#
-cat << EOF
-AC_PREREQ(2.57)
-AC_INIT([site_wide],[1.0.0])
-EOF
-# Disable as endian is set in the default config
-#echo AC_C_BIGENDIAN
-#echo
-if [ -e $1/types ] ; then
-  while read type ; do
-    echo "AC_CHECK_SIZEOF([$type])"
-  done < $1/types
-  echo
-fi
-if [ -e $1/funcs ]; then
-  while read func ; do
-    echo "AC_CHECK_FUNCS([$func])"
-  done < $1/funcs
-  echo
-fi
-if [ -e $1/headers ]; then
-  while read header ; do
-    echo "AC_CHECK_HEADERS([$header])"
-  done < $1/headers
-  echo
-fi
-cat << EOF
-AC_OUTPUT
-EOF
diff --git a/scripts/install-buildtools b/scripts/install-buildtools
index 2218f3ffac..93f3e2d678 100755
--- a/scripts/install-buildtools
+++ b/scripts/install-buildtools
@@ -56,9 +56,9 @@ PROGNAME = 'install-buildtools'
 logger = scriptutils.logger_create(PROGNAME, stream=sys.stdout)
 DEFAULT_INSTALL_DIR = os.path.join(os.path.split(scripts_path)[0],'buildtools')
-DEFAULT_BASE_URL = 'http://downloads.yoctoproject.org/releases/yocto'
+DEFAULT_BASE_URL = 'https://downloads.yoctoproject.org/releases/yocto'
-DEFAULT_RELEASE = 'yocto-4.1'
+DEFAULT_RELEASE = 'yocto-5.2.3'
-DEFAULT_INSTALLER_VERSION = '4.1'
+DEFAULT_INSTALLER_VERSION = '5.2.3'
 DEFAULT_BUILDDATE = '202110XX'
 # Python version sanity check
@@ -102,6 +102,16 @@ def sha256_file(filename):
    import hashlib
    return _hasher(hashlib.sha256(), filename)
+def remove_quotes(var):
+    """
+    If a variable starts and ends with double quotes, remove them.
+    Assumption: if a variable starts with double quotes, it must also
+    end with them.
+    """
+    if var[0] == '"':
+        var = var[1:-1]
+    return var
 def main():
    global DEFAULT_INSTALL_DIR
@@ -117,7 +127,8 @@ def main():
    parser = argparse.ArgumentParser(
        description="Buildtools installation helper",
-        add_help=False)
+        add_help=False,
+        formatter_class=argparse.RawTextHelpFormatter)
    parser.add_argument('-u', '--url',
                        help='URL from where to fetch buildtools SDK installer, not '
                             'including filename (optional)\n'
@@ -131,6 +142,9 @@ def main():
                        default=DEFAULT_INSTALL_DIR,
                        help='directory where buildtools SDK will be installed (optional)',
                        action='store')
+    parser.add_argument('--downloads-directory',
+                        help='use this directory for tarball/checksum downloads and do not erase them (default is a temporary directory which is deleted after unpacking and installing the buildtools)',
+                        action='store')
    parser.add_argument('-r', '--release',
                        default=DEFAULT_RELEASE,
                        help='Yocto Project release string for SDK which will be '
@@ -224,11 +238,14 @@ def main():
                safe_filename = quote(filename)
                buildtools_url = "%s/%s/buildtools/%s" % (base_url, args.release, safe_filename)
-    tmpsdk_dir = tempfile.mkdtemp()
+    sdk_dir = args.downloads_directory or tempfile.mkdtemp()
+    os.makedirs(sdk_dir, exist_ok=True)
    try:
        # Fetch installer
        logger.info("Fetching buildtools installer")
-        tmpbuildtools = os.path.join(tmpsdk_dir, filename)
+        tmpbuildtools = os.path.join(sdk_dir, filename)
+        with open(os.path.join(sdk_dir, 'buildtools_url'), 'w') as f:
+            f.write(buildtools_url)
        ret = subprocess.call("wget -q -O %s %s" %
                              (tmpbuildtools, buildtools_url), shell=True)
        if ret != 0:
@@ -238,19 +255,17 @@ def main():
        # Verify checksum
        if args.check:
            logger.info("Fetching buildtools installer checksum")
-            checksum_type = ""
+            checksum_type = "sha256sum"
-            for checksum_type in ["md5sum", "sha256sum"]:
+            checksum_url = "{}.{}".format(buildtools_url, checksum_type)
-                check_url = "{}.{}".format(buildtools_url, checksum_type)
+            checksum_filename = "{}.{}".format(filename, checksum_type)
-                checksum_filename = "{}.{}".format(filename, checksum_type)
+            tmpbuildtools_checksum = os.path.join(sdk_dir, checksum_filename)
-                tmpbuildtools_checksum = os.path.join(tmpsdk_dir, checksum_filename)
+            with open(os.path.join(sdk_dir, 'checksum_url'), 'w') as f:
-                ret = subprocess.call("wget -q -O %s %s" %
+                f.write(checksum_url)
-                                      (tmpbuildtools_checksum, check_url), shell=True)
+            ret = subprocess.call("wget -q -O %s %s" %
-                if ret == 0:
+                                    (tmpbuildtools_checksum, checksum_url), shell=True)
-                    break
+            if ret != 0:
-            else:
+                logger.error("Could not download file from %s" % checksum_url)
-                if ret != 0:
+                return ret
-                    logger.error("Could not download file from %s" % check_url)
-                    return ret
            regex = re.compile(r"^(?P<checksum>[0-9a-f]+)\s+(?P<path>.*/)?(?P<filename>.*)$")
            with open(tmpbuildtools_checksum, 'rb') as f:
                original = f.read()
@@ -263,10 +278,7 @@ def main():
                    logger.error("Filename does not match name in checksum")
                    return 1
                checksum = m.group('checksum')
-            if checksum_type == "md5sum":
+            checksum_value = sha256_file(tmpbuildtools)
-                checksum_value = md5_file(tmpbuildtools)
-            else:
-                checksum_value = sha256_file(tmpbuildtools)
            if checksum == checksum_value:
                    logger.info("Checksum success")
            else:
@@ -280,7 +292,7 @@ def main():
        os.chmod(tmpbuildtools, st.st_mode | stat.S_IEXEC)
        logger.debug(os.stat(tmpbuildtools))
        if args.directory:
-            install_dir = args.directory
+            install_dir = os.path.abspath(args.directory)
            ret = subprocess.call("%s -d %s -y" %
                                  (tmpbuildtools, install_dir), shell=True)
        else:
@@ -301,7 +313,7 @@ def main():
                if match:
                    env_var = match.group('env_var')
                    logger.debug("env_var: %s" % env_var)
-                    env_val = match.group('env_val')
+                    env_val = remove_quotes(match.group('env_val'))
                    logger.debug("env_val: %s" % env_val)
                    os.environ[env_var] = env_val
@@ -343,7 +355,8 @@ def main():
    finally:
        # cleanup tmp directory
-        shutil.rmtree(tmpsdk_dir)
+        if not args.downloads_directory:
+            shutil.rmtree(sdk_dir)
 if __name__ == '__main__':
diff --git a/scripts/lib/build_perf/html/measurement_chart.html b/scripts/lib/build_perf/html/measurement_chart.html
index ad4a93ed02..86435273cf 100644
--- a/scripts/lib/build_perf/html/measurement_chart.html
+++ b/scripts/lib/build_perf/html/measurement_chart.html
@@ -2,7 +2,7 @@
  // Get raw data
  const rawData = [
    {% for sample in measurement.samples %}
-      [{{ sample.commit_num }}, {{ sample.mean.gv_value() }}, {{ sample.start_time }}],
+      [{{ sample.commit_num }}, {{ sample.mean.gv_value() }}, {{ sample.start_time }}, '{{sample.commit}}'],
    {% endfor %}
  ];
@@ -26,27 +26,37 @@
    ]
  });
+  const commitCountList = rawData.map(([commit, value, time]) => {
+    return commit
+  });
+  const commitCountData = rawData.map(([commit, value, time]) => {
+    return updateValue(value)
+  });
  // Set chart options
-  const option = {
+  const option_start_time = {
    tooltip: {
      trigger: 'axis',
-      valueFormatter: (value) => {
+      enterable: true,
-        const commitNumber  = rawData.filter(([commit, dataValue, time]) => updateValue(dataValue) === value)
+      position: function (point, params, dom, rect, size) {
+        return [point[0], '0%'];
+      },
+      formatter: function (param) {
+        const value = param[0].value[1]
+        const sample  = rawData.filter(([commit, dataValue]) => updateValue(dataValue) === value)
+        const formattedDate = new Date(sample[0][2] * 1000).toString().replace(/GMT[+-]\d{4}/, '').replace(/\(.*\)/, '(CEST)');
+        // Add commit hash to the tooltip as a link
+        const commitLink = `https://git.yoctoproject.org/poky/commit/?id=${sample[0][3]}`
        if ('{{ measurement.value_type.quantity }}' == 'time') {
          const hours = Math.floor(value/60)
          const minutes = Math.floor(value % 60)
          const seconds = Math.floor((value * 60) % 60)
-          return [
+          return `<strong>Duration:</strong> ${hours}:${minutes}:${seconds}, <strong>Commit number:</strong> <a href="${commitLink}" target="_blank" rel="noreferrer noopener">${sample[0][0]}</a>, <br/> <strong>Start time:</strong> ${formattedDate}`
-                hours + ':' + minutes + ':' + seconds + ', ' +
-                'commit number: ' + commitNumber[0][0]
-              ]
        }
-        return [
+        return `<strong>Size:</strong> ${value.toFixed(2)} MB, <strong>Commit number:</strong> <a href="${commitLink}" target="_blank" rel="noreferrer noopener">${sample[0][0]}</a>, <br/> <strong>Start time:</strong> ${formattedDate}`
-          value.toFixed(2) + ' MB' + ', ' +
+      ;}
-          'commit number: ' + commitNumber[0][0]
-        ]
-      },
    },
    xAxis: {
      type: 'time',
@@ -72,29 +82,87 @@
      {
        name: '{{ measurement.value_type.quantity }}',
        type: 'line',
-        step: 'start',
        symbol: 'none',
        data: data
      }
    ]
  };
+  const option_commit_count = {
+    tooltip: {
+      trigger: 'axis',
+      enterable: true,
+      position: function (point, params, dom, rect, size) {
+        return [point[0], '0%'];
+      },
+      formatter: function (param) {
+        const value = param[0].value
+        const sample  = rawData.filter(([commit, dataValue]) => updateValue(dataValue) === value)
+        const formattedDate = new Date(sample[0][2] * 1000).toString().replace(/GMT[+-]\d{4}/, '').replace(/\(.*\)/, '(CEST)');
+        // Add commit hash to the tooltip as a link
+        const commitLink = `https://git.yoctoproject.org/poky/commit/?id=${sample[0][3]}`
+        if ('{{ measurement.value_type.quantity }}' == 'time') {
+          const hours = Math.floor(value/60)
+          const minutes = Math.floor(value % 60)
+          const seconds = Math.floor((value * 60) % 60)
+          return `<strong>Duration:</strong> ${hours}:${minutes}:${seconds}, <strong>Commit number:</strong> <a href="${commitLink}" target="_blank" rel="noreferrer noopener">${sample[0][0]}</a>, <br/> <strong>Start time:</strong> ${formattedDate}`
+        }
+        return `<strong>Size:</strong> ${value.toFixed(2)} MB, <strong>Commit number:</strong> <a href="${commitLink}" target="_blank" rel="noreferrer noopener">${sample[0][0]}</a>, <br/> <strong>Start time:</strong> ${formattedDate}`
+      ;}
+    },
+    xAxis: {
+      name: 'Commit count',
+      type: 'category',
+      data: commitCountList
+    },
+    yAxis: {
+      name: '{{ measurement.value_type.quantity }}' == 'time' ? 'Duration in minutes' : 'Disk size in MB',
+      type: 'value',
+      min: function(value) {
+        return Math.round(value.min - 0.5);
+      },
+      max: function(value) {
+        return Math.round(value.max + 0.5);
+      }
+    },
+    dataZoom: [
+      {
+        type: 'slider',
+        xAxisIndex: 0,
+        filterMode: 'none'
+      },
+    ],
+    series: [
+      {
+        name: '{{ measurement.value_type.quantity }}',
+        type: 'line',
+        symbol: 'none',
+        data: commitCountData
+      }
+    ]
+  };
  // Draw chart
-  const chart_div = document.getElementById('{{ chart_elem_id }}');
+  const draw_chart = (chart_id, option) => {
-  // Set dark mode
+    let chart_name
-  let measurement_chart
+    const chart_div = document.getElementById(chart_id);
-  if (window.matchMedia('(prefers-color-scheme: dark)').matches) {
+    // Set dark mode
-      measurement_chart= echarts.init(chart_div, 'dark', {
+    if (window.matchMedia('(prefers-color-scheme: dark)').matches) {
-      height: 320
+        chart_name= echarts.init(chart_div, 'dark', {
-    });
+        height: 320
-  } else {
+      });
-      measurement_chart= echarts.init(chart_div, null, {
+    } else {
-      height: 320
+        chart_name= echarts.init(chart_div, null, {
+        height: 320
+      });
+    }
+    // Change chart size with browser resize
+    window.addEventListener('resize', function() {
+      chart_name.resize();
    });
+    return chart_name.setOption(option);
  }
-  // Change chart size with browser resize
-  window.addEventListener('resize', function() {
+  draw_chart('{{ chart_elem_start_time_id }}', option_start_time)
-    measurement_chart.resize();
+  draw_chart('{{ chart_elem_commit_count_id }}', option_commit_count)
-  });
-  measurement_chart.setOption(option);
 </script>
diff --git a/scripts/lib/build_perf/html/report.html b/scripts/lib/build_perf/html/report.html
index 537ed3ee52..28cd80e738 100644
--- a/scripts/lib/build_perf/html/report.html
+++ b/scripts/lib/build_perf/html/report.html
@@ -9,7 +9,8 @@
 {% for test in test_data %}
  {% if test.status == 'SUCCESS' %}
    {% for measurement in test.measurements %}
-      {% set chart_elem_id = test.name + '_' + measurement.name + '_chart' %}
+      {% set chart_elem_start_time_id = test.name + '_' + measurement.name + '_chart_start_time' %}
+      {% set chart_elem_commit_count_id = test.name + '_' + measurement.name + '_chart_commit_count' %}
      {% include 'measurement_chart.html' %}
    {% endfor %}
  {% endif %}
@@ -116,6 +117,22 @@ a {
 a:hover {
  color: #8080ff;
 }
+button {
+  background-color: #F3F4F6;
+  border: none;
+  outline: none;
+  cursor: pointer;
+  padding: 10px 12px;
+  transition: 0.3s;
+  border-radius: 8px;
+  color: #3A4353;
+}
+button:hover {
+  background-color: #d6d9e0;
+}
+.tab button.active {
+  background-color: #d6d9e0;
+}
 @media (prefers-color-scheme: dark) {
  :root {
    --text: #e9e8fa;
@@ -126,6 +143,16 @@ a:hover {
    --trborder: #212936;
    --chartborder: #b1b0bf;
  }
+  button {
+    background-color: #28303E;
+    color: #fff;
+  }
+  button:hover {
+    background-color: #545a69;
+  }
+  .tab button.active {
+    background-color: #545a69;
+  }
 }
 </style>
@@ -233,7 +260,18 @@ a:hover {
            <tr>
              <td style="width: 75%">
                {# Linechart #}
-                <div id="{{ test.name }}_{{ measurement.name }}_chart"></div>
+                <div class="tab {{ test.name }}_{{ measurement.name }}_tablinks">
+                  <button class="tablinks active" onclick="openChart(event, '{{ test.name }}_{{ measurement.name }}_start_time', '{{ test.name }}_{{ measurement.name }}')">Chart with start time</button>
+                  <button class="tablinks" onclick="openChart(event, '{{ test.name }}_{{ measurement.name }}_commit_count', '{{ test.name }}_{{ measurement.name }}')">Chart with commit count</button>
+                </div>
+                <div class="{{ test.name }}_{{ measurement.name }}_tabcontent">
+                  <div id="{{ test.name }}_{{ measurement.name }}_start_time" class="tabcontent" style="display: block;">
+                    <div id="{{ test.name }}_{{ measurement.name }}_chart_start_time"></div>
+                  </div>
+                  <div id="{{ test.name }}_{{ measurement.name }}_commit_count" class="tabcontent" style="display: none;">
+                    <div id="{{ test.name }}_{{ measurement.name }}_chart_commit_count"></div>
+                  </div>
+                </div>
              </td>
              <td>
                {# Measurement statistics #}
@@ -340,6 +378,31 @@ a:hover {
      <div class="preformatted">{{ test.message }}</div>
    {% endif %}
  {% endfor %}
-</div></body>
+</div>
-</html>
+<script>
+function openChart(event, chartType, chartName) {
+  let i, tabcontents, tablinks
+  tabcontents = document.querySelectorAll(`.${chartName}_tabcontent > .tabcontent`);
+  tabcontents.forEach((tabcontent) => {
+    tabcontent.style.display = "none";
+  });
+  tablinks = document.querySelectorAll(`.${chartName}_tablinks > .tablinks`);
+  tablinks.forEach((tabLink) => {
+    tabLink.classList.remove('active');
+  });
+  const targetTab = document.getElementById(chartType)
+  targetTab.style.display = "block";
+  // Call resize on the ECharts instance to redraw the chart
+  const chartContainer = targetTab.querySelector('div')
+  echarts.init(chartContainer).resize();
+  event.currentTarget.classList.add('active');
+}
+</script>
+</body>
+</html>
diff --git a/scripts/lib/checklayer/__init__.py b/scripts/lib/checklayer/__init__.py
index 62ecdfe390..86aadf39a6 100644
--- a/scripts/lib/checklayer/__init__.py
+++ b/scripts/lib/checklayer/__init__.py
@@ -452,3 +452,15 @@ def compare_signatures(old_sigs, curr_sigs):
            msg.extend(['      ' + line for line in output.splitlines()])
            msg.append('')
    return '\n'.join(msg)
+def get_git_toplevel(directory):
+    """
+    Try and find the top of the git repository that directory might be in.
+    Returns the top-level directory, or None.
+    """
+    cmd = ["git", "-C", directory, "rev-parse", "--show-toplevel"]
+    try:
+        return subprocess.check_output(cmd, text=True).strip()
+    except:
+        return None
diff --git a/scripts/lib/checklayer/cases/common.py b/scripts/lib/checklayer/cases/common.py
index 97b16f78c8..ddead69a7b 100644
--- a/scripts/lib/checklayer/cases/common.py
+++ b/scripts/lib/checklayer/cases/common.py
@@ -7,7 +7,7 @@ import glob
 import os
 import unittest
 import re
-from checklayer import get_signatures, LayerType, check_command, get_depgraph, compare_signatures
+from checklayer import get_signatures, LayerType, check_command, compare_signatures, get_git_toplevel
 from checklayer.case import OECheckLayerTestCase
 class CommonCheckLayer(OECheckLayerTestCase):
@@ -40,6 +40,38 @@ class CommonCheckLayer(OECheckLayerTestCase):
        email_regex = re.compile(r"[^@]+@[^@]+")
        self.assertTrue(email_regex.match(data))
+    def find_file_by_name(self, globs):
+        """
+        Utility function to find a file that matches the specified list of
+        globs, in either the layer directory itself or the repository top-level
+        directory.
+        """
+        directories = [self.tc.layer["path"]]
+        toplevel = get_git_toplevel(directories[0])
+        if toplevel:
+            directories.append(toplevel)
+        for path in directories:
+            for name in globs:
+                files = glob.glob(os.path.join(path, name))
+                if files:
+                    return sorted(files)[0]
+        return None
+    def test_security(self):
+        """
+        Test that the layer has a SECURITY.md (or similar) file, either in the
+        layer itself or at the top of the containing git repository.
+        """
+        if self.tc.layer["type"] == LayerType.CORE:
+            raise unittest.SkipTest("Core layer's SECURITY is top level")
+        filename = self.find_file_by_name(("SECURITY", "SECURITY.*"))
+        self.assertTrue(filename, msg="Layer doesn't contain a SECURITY.md file.")
+        size = os.path.getsize(filename)
+        self.assertGreater(size, 0, msg=f"{filename} has no content.")
    def test_parse(self):
        check_command('Layer %s failed to parse.' % self.tc.layer['name'],
                      'bitbake -p')
@@ -72,7 +104,6 @@ class CommonCheckLayer(OECheckLayerTestCase):
                self.tc.layer['name'])
            self.fail('\n'.join(msg))
-    @unittest.expectedFailure
    def test_patches_upstream_status(self):
        import sys
        sys.path.append(os.path.join(sys.path[0], '../../../../meta/lib/'))
diff --git a/scripts/lib/devtool/__init__.py b/scripts/lib/devtool/__init__.py
index 6133c1c5b4..969d6dc13a 100644
--- a/scripts/lib/devtool/__init__.py
+++ b/scripts/lib/devtool/__init__.py
@@ -26,7 +26,7 @@ class DevtoolError(Exception):
 def exec_build_env_command(init_path, builddir, cmd, watch=False, **options):
    """Run a program in bitbake build context"""
-    import bb
+    import bb.process
    if not 'cwd' in options:
        options["cwd"] = builddir
    if init_path:
@@ -50,7 +50,7 @@ def exec_build_env_command(init_path, builddir, cmd, watch=False, **options):
 def exec_watch(cmd, **options):
    """Run program with stdout shown on sys.stdout"""
-    import bb
+    import bb.process
    if isinstance(cmd, str) and not "shell" in options:
        options["shell"] = True
@@ -66,7 +66,7 @@ def exec_watch(cmd, **options):
            sys.stdout.write(out)
            sys.stdout.flush()
            buf += out
-        elif out == '' and process.poll() != None:
+        elif out == '' and process.poll() is not None:
            break
    if process.returncode != 0:
@@ -74,13 +74,6 @@ def exec_watch(cmd, **options):
    return buf, None
-def exec_fakeroot(d, cmd, **kwargs):
-    """Run a command under fakeroot (pseudo, in fact) so that it picks up the appropriate file permissions"""
-    # Grab the command and check it actually exists
-    fakerootcmd = d.getVar('FAKEROOTCMD')
-    fakerootenv = d.getVar('FAKEROOTENV')
-    exec_fakeroot_no_d(fakerootcmd, fakerootenv, cmd, kwargs)
 def exec_fakeroot_no_d(fakerootcmd, fakerootenv, cmd, **kwargs):
    if not os.path.exists(fakerootcmd):
        logger.error('pseudo executable %s could not be found - have you run a build yet? pseudo-native should install this and if you have run any build then that should have been built')
@@ -122,6 +115,7 @@ def setup_tinfoil(config_only=False, basepath=None, tracking=False):
 def parse_recipe(config, tinfoil, pn, appends, filter_workspace=True):
    """Parse the specified recipe"""
+    import bb.providers
    try:
        recipefile = tinfoil.get_recipe_file(pn)
    except bb.providers.NoProvider as e:
@@ -147,6 +141,8 @@ def check_workspace_recipe(workspace, pn, checksrc=True, bbclassextend=False):
    Check that a recipe is in the workspace and (optionally) that source
    is present.
    """
+    import bb.runqueue
+    _, pn = bb.runqueue.split_mc(pn)
    workspacepn = pn
@@ -176,6 +172,7 @@ def use_external_build(same_dir, no_same_dir, d):
    """
    Determine if we should use B!=S (separate build and source directories) or not
    """
+    import bb.data
    b_is_s = True
    if no_same_dir:
        logger.info('Using separate build directory since --no-same-dir specified')
@@ -234,7 +231,7 @@ def setup_git_repo(repodir, version, devbranch, basetag='devtool-base', d=None):
            f.write(line)
    bb.process.run('git checkout -b %s' % devbranch, cwd=repodir)
-    bb.process.run('git tag -f %s' % basetag, cwd=repodir)
+    bb.process.run('git tag -f --no-sign %s' % basetag, cwd=repodir)
    # if recipe unpacks another git repo inside S, we need to declare it as a regular git submodule now,
    # so we will be able to tag branches on it and extract patches when doing finish/update on the recipe
@@ -256,7 +253,7 @@ def setup_git_repo(repodir, version, devbranch, basetag='devtool-base', d=None):
                    oe.patch.GitApplyTree.commitIgnored("Add additional submodule from SRC_URI", dir=os.path.join(root, ".."), d=d)
                    found = False
    if os.path.exists(os.path.join(repodir, '.gitmodules')):
-        bb.process.run('git submodule foreach --recursive  "git tag -f %s"' % basetag, cwd=repodir)
+        bb.process.run('git submodule foreach --recursive  "git tag -f --no-sign %s"' % basetag, cwd=repodir)
 def recipe_to_append(recipefile, config, wildcard=False):
    """
@@ -298,31 +295,18 @@ def get_bbclassextend_targets(recipefile, pn):
 def replace_from_file(path, old, new):
    """Replace strings on a file"""
-    def read_file(path):
-        data = None
-        with open(path) as f:
-            data = f.read()
-        return data
-    def write_file(path, data):
-        if data is None:
-            return
-        wdata = data.rstrip() + "\n"
-        with open(path, "w") as f:
-            f.write(wdata)
-    # In case old is None, return immediately
    if old is None:
        return
    try:
-        rdata = read_file(path)
+        with open(path) as f:
+            rdata = f.read()
    except IOError as e:
+        import errno
        # if file does not exit, just quit, otherwise raise an exception
        if e.errno == errno.ENOENT:
            return
-        else:
+        raise
-            raise
    old_contents = rdata.splitlines()
    new_contents = []
@@ -331,12 +315,16 @@ def replace_from_file(path, old, new):
            new_contents.append(old_content.replace(old, new))
        except ValueError:
            pass
-    write_file(path, "\n".join(new_contents))
+    wdata = ("\n".join(new_contents)).rstrip() + "\n"
+    with open(path, "w") as f:
+        f.write(wdata)
 def update_unlockedsigs(basepath, workspace, fixed_setup, extra=None):
    """ This function will make unlocked-sigs.inc match the recipes in the
    workspace plus any extras we want unlocked. """
+    import bb.utils
    if not fixed_setup:
        # Only need to write this out within the eSDK
@@ -388,11 +376,13 @@ def check_prerelease_version(ver, operation):
 def check_git_repo_dirty(repodir):
    """Check if a git repository is clean or not"""
+    import bb.process
    stdout, _ = bb.process.run('git status --porcelain', cwd=repodir)
    return stdout
 def check_git_repo_op(srctree, ignoredirs=None):
    """Check if a git repository is in the middle of a rebase"""
+    import bb.process
    stdout, _ = bb.process.run('git rev-parse --show-toplevel', cwd=srctree)
    topleveldir = stdout.strip()
    if ignoredirs and topleveldir in ignoredirs:
diff --git a/scripts/lib/devtool/build.py b/scripts/lib/devtool/build.py
index 935ffab46c..0b2c3d33dc 100644
--- a/scripts/lib/devtool/build.py
+++ b/scripts/lib/devtool/build.py
@@ -49,7 +49,7 @@ def build(args, config, basepath, workspace):
        rd = parse_recipe(config, tinfoil, args.recipename, appends=True, filter_workspace=False)
        if not rd:
            return 1
-        deploytask = 'do_deploy' in rd.getVar('__BBTASKS')
+        deploytask = 'do_deploy' in bb.build.listtasks(rd)
    finally:
        tinfoil.shutdown()
diff --git a/scripts/lib/devtool/build_sdk.py b/scripts/lib/devtool/build_sdk.py
index 1cd4831d2b..990303982c 100644
--- a/scripts/lib/devtool/build_sdk.py
+++ b/scripts/lib/devtool/build_sdk.py
@@ -5,14 +5,7 @@
 # SPDX-License-Identifier: GPL-2.0-only
 #
-import os
-import subprocess
 import logging
-import glob
-import shutil
-import errno
-import sys
-import tempfile
 from devtool import DevtoolError
 from devtool import build_image
diff --git a/scripts/lib/devtool/ide_plugins/ide_code.py b/scripts/lib/devtool/ide_plugins/ide_code.py
index a62b93224e..ee5bb57265 100644
--- a/scripts/lib/devtool/ide_plugins/ide_code.py
+++ b/scripts/lib/devtool/ide_plugins/ide_code.py
@@ -161,7 +161,6 @@ class IdeVSCode(IdeBase):
        if modified_recipe.build_tool is not BuildTool.CMAKE:
            return
        recommendations += [
-            "twxs.cmake",
            "ms-vscode.cmake-tools",
            "ms-vscode.cpptools",
            "ms-vscode.cpptools-extension-pack",
diff --git a/scripts/lib/devtool/ide_sdk.py b/scripts/lib/devtool/ide_sdk.py
index 65873b088d..d9b54f7991 100755
--- a/scripts/lib/devtool/ide_sdk.py
+++ b/scripts/lib/devtool/ide_sdk.py
@@ -167,7 +167,7 @@ class RecipeImage:
            self.__rootfs_dbg = os.path.join(workdir, 'rootfs-dbg')
        self.gdbserver_missing = 'gdbserver' not in image_d.getVar(
-            'IMAGE_INSTALL')
+            'IMAGE_INSTALL') and 'tools-debug' not in image_d.getVar('IMAGE_FEATURES')
    @property
    def debug_support(self):
@@ -286,8 +286,10 @@ class RecipeModified:
        self.b = None
        self.base_libdir = None
        self.bblayers = None
+        self.bitbakepath = None
        self.bpn = None
        self.d = None
+        self.debug_build = None
        self.fakerootcmd = None
        self.fakerootenv = None
        self.libdir = None
@@ -296,6 +298,7 @@ class RecipeModified:
        self.package_debug_split_style = None
        self.path = None
        self.pn = None
+        self.recipe_id = None
        self.recipe_sysroot = None
        self.recipe_sysroot_native = None
        self.staging_incdir = None
@@ -304,7 +307,6 @@ class RecipeModified:
        self.target_dbgsrc_dir = None
        self.topdir = None
        self.workdir = None
-        self.recipe_id = None
        # replicate bitbake build environment
        self.exported_vars = None
        self.cmd_compile = None
@@ -333,7 +335,7 @@ class RecipeModified:
        self.srctree = workspace[workspacepn]['srctree']
        # Need to grab this here in case the source is within a subdirectory
        self.real_srctree = get_real_srctree(
-            self.srctree, recipe_d.getVar('S'), recipe_d.getVar('WORKDIR'))
+            self.srctree, recipe_d.getVar('S'), recipe_d.getVar('UNPACKDIR'))
        self.bbappend = workspace[workspacepn]['bbappend']
        self.ide_sdk_dir = os.path.join(
@@ -345,9 +347,11 @@ class RecipeModified:
        self.b = recipe_d.getVar('B')
        self.base_libdir = recipe_d.getVar('base_libdir')
        self.bblayers = recipe_d.getVar('BBLAYERS').split()
+        self.bitbakepath = recipe_d.getVar('BITBAKEPATH')
        self.bpn = recipe_d.getVar('BPN')
        self.cxx = recipe_d.getVar('CXX')
        self.d = recipe_d.getVar('D')
+        self.debug_build = recipe_d.getVar('DEBUG_BUILD')
        self.fakerootcmd = recipe_d.getVar('FAKEROOTCMD')
        self.fakerootenv = recipe_d.getVar('FAKEROOTENV')
        self.libdir = recipe_d.getVar('libdir')
@@ -389,17 +393,6 @@ class RecipeModified:
        self.recipe_id = self.bpn + "-" + self.package_arch
        self.recipe_id_pretty = self.bpn + ": " + self.package_arch
-    def append_to_bbappend(self, append_text):
-        with open(self.bbappend, 'a') as bbap:
-            bbap.write(append_text)
-    def remove_from_bbappend(self, append_text):
-        with open(self.bbappend, 'r') as bbap:
-            text = bbap.read()
-        new_text = text.replace(append_text, '')
-        with open(self.bbappend, 'w') as bbap:
-            bbap.write(new_text)
    @staticmethod
    def is_valid_shell_variable(var):
        """Skip strange shell variables like systemd
@@ -412,34 +405,6 @@ class RecipeModified:
            return True
        return False
-    def debug_build_config(self, args):
-        """Explicitely set for example CMAKE_BUILD_TYPE to Debug if not defined otherwise"""
-        if self.build_tool is BuildTool.CMAKE:
-            append_text = os.linesep + \
-                'OECMAKE_ARGS:append = " -DCMAKE_BUILD_TYPE:STRING=Debug"' + os.linesep
-            if args.debug_build_config and not 'CMAKE_BUILD_TYPE' in self.cmake_cache_vars:
-                self.cmake_cache_vars['CMAKE_BUILD_TYPE'] = {
-                    "type": "STRING",
-                    "value": "Debug",
-                }
-                self.append_to_bbappend(append_text)
-            elif 'CMAKE_BUILD_TYPE' in self.cmake_cache_vars:
-                del self.cmake_cache_vars['CMAKE_BUILD_TYPE']
-                self.remove_from_bbappend(append_text)
-        elif self.build_tool is BuildTool.MESON:
-            append_text = os.linesep + 'MESON_BUILDTYPE = "debug"' + os.linesep
-            if args.debug_build_config and self.meson_buildtype != "debug":
-                self.mesonopts.replace(
-                    '--buildtype ' + self.meson_buildtype, '--buildtype debug')
-                self.append_to_bbappend(append_text)
-            elif self.meson_buildtype == "debug":
-                self.mesonopts.replace(
-                    '--buildtype debug', '--buildtype plain')
-                self.remove_from_bbappend(append_text)
-        elif args.debug_build_config:
-            logger.warn(
-                "--debug-build-config is not implemented for this build tool yet.")
    def solib_search_path(self, image):
        """Search for debug symbols in the rootfs and rootfs-dbg
@@ -493,7 +458,7 @@ class RecipeModified:
        vars = (key for key in d.keys() if not key.startswith(
            "__") and not d.getVarFlag(key, "func", False))
-        for var in vars:
+        for var in sorted(vars):
            func = d.getVarFlag(var, "func", False)
            if d.getVarFlag(var, 'python', False) and func:
                continue
@@ -545,7 +510,7 @@ class RecipeModified:
        cache_vars = {}
        oecmake_args = d.getVar('OECMAKE_ARGS').split()
        extra_oecmake = d.getVar('EXTRA_OECMAKE').split()
-        for param in oecmake_args + extra_oecmake:
+        for param in sorted(oecmake_args + extra_oecmake):
            d_pref = "-D"
            if param.startswith(d_pref):
                param = param[len(d_pref):]
@@ -712,42 +677,6 @@ class RecipeModified:
                    binaries.append(abs_name[d_len:])
        return sorted(binaries)
-    def gen_delete_package_dirs(self):
-        """delete folders of package tasks
-        This is a workaround for and issue with recipes having their sources
-        downloaded as file://
-        This likely breaks pseudo like:
-        path mismatch [3 links]: ino 79147802 db
-        .../build/tmp/.../cmake-example/1.0/package/usr/src/debug/
-                             cmake-example/1.0-r0/oe-local-files/cpp-example-lib.cpp
-        .../build/workspace/sources/cmake-example/oe-local-files/cpp-example-lib.cpp
-        Since the files are anyway outdated lets deleted them (also from pseudo's db) to workaround this issue.
-        """
-        cmd_lines = ['#!/bin/sh']
-        # Set up the appropriate environment
-        newenv = dict(os.environ)
-        for varvalue in self.fakerootenv.split():
-            if '=' in varvalue:
-                splitval = varvalue.split('=', 1)
-                newenv[splitval[0]] = splitval[1]
-        # Replicate the environment variables from bitbake
-        for var, val in newenv.items():
-            if not RecipeModified.is_valid_shell_variable(var):
-                continue
-            cmd_lines.append('%s="%s"' % (var, val))
-            cmd_lines.append('export %s' % var)
-        # Delete the folders
-        pkg_dirs = ' '.join([os.path.join(self.workdir, d) for d in [
-            "package", "packages-split", "pkgdata", "sstate-install-package", "debugsources.list", "*.spec"]])
-        cmd = "%s rm -rf %s" % (self.fakerootcmd, pkg_dirs)
-        cmd_lines.append('%s || { "%s failed"; exit 1; }' % (cmd, cmd))
-        return self.write_script(cmd_lines, 'delete_package_dirs')
    def gen_deploy_target_script(self, args):
        """Generate a script which does what devtool deploy-target does
@@ -783,16 +712,15 @@ class RecipeModified:
    def gen_install_deploy_script(self, args):
        """Generate a script which does install and deploy"""
-        cmd_lines = ['#!/bin/bash']
+        cmd_lines = ['#!/bin/sh']
-        cmd_lines.append(self.gen_delete_package_dirs())
-        # . oe-init-build-env $BUILDDIR
+        # . oe-init-build-env $BUILDDIR $BITBAKEDIR
-        # Note: Sourcing scripts with arguments requires bash
+        # Using 'set' to pass the build directory to oe-init-build-env in sh syntax
        cmd_lines.append('cd "%s" || { echo "cd %s failed"; exit 1; }' % (
            self.oe_init_dir, self.oe_init_dir))
-        cmd_lines.append('. "%s" "%s" || { echo ". %s %s failed"; exit 1; }' % (
+        cmd_lines.append('set %s %s' % (self.topdir, self.bitbakepath.rstrip('/bin')))
-            self.oe_init_build_env, self.topdir, self.oe_init_build_env, self.topdir))
+        cmd_lines.append('. "%s" || { echo ". %s %s failed"; exit 1; }' % (
+            self.oe_init_build_env, self.oe_init_build_env, self.topdir))
        # bitbake -c install
        cmd_lines.append(
@@ -988,6 +916,13 @@ def ide_setup(args, config, basepath, workspace):
                recipe_modified.gen_meson_wrapper()
            ide.setup_modified_recipe(
                args, recipe_image, recipe_modified)
+            if recipe_modified.debug_build != '1':
+                logger.warn(
+                    'Recipe %s is compiled with release build configuration. '
+                    'You might want to add DEBUG_BUILD = "1" to %s. '
+                    'Note that devtool modify --debug-build can do this automatically.',
+                    recipe_modified.name, recipe_modified.bbappend)
    else:
        raise DevtoolError("Must not end up here.")
@@ -995,6 +930,15 @@ def ide_setup(args, config, basepath, workspace):
 def register_commands(subparsers, context):
    """Register devtool subcommands from this plugin"""
+    # The ide-sdk command bootstraps the SDK from the bitbake environment before the IDE
+    # configuration is generated. In the case of the eSDK, the bootstrapping is performed
+    # during the installation of the eSDK installer. Running the ide-sdk plugin from an
+    # eSDK installer-based setup would require skipping the bootstrapping and probably
+    # taking some other differences into account when generating the IDE configurations.
+    # This would be possible. But it is not implemented.
+    if context.fixed_setup:
+        return
    global ide_plugins
    # Search for IDE plugins in all sub-folders named ide_plugins where devtool seraches for plugins.
@@ -1015,7 +959,7 @@ def register_commands(subparsers, context):
                                           help='Setup the SDK and configure the IDE')
    parser_ide_sdk.add_argument(
        'recipenames', nargs='+', help='Generate an IDE configuration suitable to work on the given recipes.\n'
-        'Depending on the --mode paramter different types of SDKs and IDE configurations are generated.')
+        'Depending on the --mode parameter different types of SDKs and IDE configurations are generated.')
    parser_ide_sdk.add_argument(
        '-m', '--mode', type=DevtoolIdeMode, default=DevtoolIdeMode.modified,
        help='Different SDK types are supported:\n'
@@ -1065,6 +1009,4 @@ def register_commands(subparsers, context):
        '-p', '--no-preserve', help='Do not preserve existing files', action='store_true')
    parser_ide_sdk.add_argument(
        '--no-check-space', help='Do not check for available space before deploying', action='store_true')
-    parser_ide_sdk.add_argument(
-        '--debug-build-config', help='Use debug build flags, for example set CMAKE_BUILD_TYPE=Debug', action='store_true')
    parser_ide_sdk.set_defaults(func=ide_setup)
diff --git a/scripts/lib/devtool/menuconfig.py b/scripts/lib/devtool/menuconfig.py
index 18daef30c3..1054960551 100644
--- a/scripts/lib/devtool/menuconfig.py
+++ b/scripts/lib/devtool/menuconfig.py
@@ -23,9 +23,6 @@
 import os
 import bb
 import logging
-import argparse
-import re
-import glob
 from devtool import setup_tinfoil, parse_recipe, DevtoolError, standard, exec_build_env_command
 from devtool import check_workspace_recipe
 logger = logging.getLogger('devtool')
@@ -34,7 +31,6 @@ def menuconfig(args, config, basepath, workspace):
    """Entry point for the devtool 'menuconfig' subcommand"""
    rd = ""
-    kconfigpath = ""
    pn_src = ""
    localfilesdir = ""
    workspace_dir = ""
@@ -51,7 +47,6 @@ def menuconfig(args, config, basepath, workspace):
            raise DevtoolError("This recipe does not support menuconfig option")
        workspace_dir = os.path.join(config.workspace_path,'sources')
-        kconfigpath = rd.getVar('B')
        pn_src = os.path.join(workspace_dir,pn)
        # add check to see if oe_local_files exists or not
@@ -70,7 +65,7 @@ def menuconfig(args, config, basepath, workspace):
    logger.info('Launching menuconfig')
    exec_build_env_command(config.init_path, basepath, 'bitbake -c menuconfig %s' % pn, watch=True)
    fragment = os.path.join(localfilesdir, 'devtool-fragment.cfg')
-    res = standard._create_kconfig_diff(pn_src,rd,fragment)
+    standard._create_kconfig_diff(pn_src,rd,fragment)
    return 0
diff --git a/scripts/lib/devtool/standard.py b/scripts/lib/devtool/standard.py
index 05161942b7..1fd5947c41 100644
--- a/scripts/lib/devtool/standard.py
+++ b/scripts/lib/devtool/standard.py
@@ -18,11 +18,13 @@ import argparse_oe
 import scriptutils
 import errno
 import glob
-import filecmp
 from collections import OrderedDict
 from devtool import exec_build_env_command, setup_tinfoil, check_workspace_recipe, use_external_build, setup_git_repo, recipe_to_append, get_bbclassextend_targets, update_unlockedsigs, check_prerelease_version, check_git_repo_dirty, check_git_repo_op, DevtoolError
 from devtool import parse_recipe
+import bb.utils
 logger = logging.getLogger('devtool')
 override_branch_prefix = 'devtool-override-'
@@ -30,7 +32,8 @@ override_branch_prefix = 'devtool-override-'
 def add(args, config, basepath, workspace):
    """Entry point for the devtool 'add' subcommand"""
-    import bb
+    import bb.data
+    import bb.process
    import oe.recipeutils
    if not args.recipename and not args.srctree and not args.fetch and not args.fetchuri:
@@ -206,7 +209,7 @@ def add(args, config, basepath, workspace):
            for fn in os.listdir(tempdir):
                shutil.move(os.path.join(tempdir, fn), recipedir)
        else:
-            raise DevtoolError('Command \'%s\' did not create any recipe file:\n%s' % (e.command, e.stdout))
+            raise DevtoolError(f'Failed to create a recipe file for source {source}')
        attic_recipe = os.path.join(config.workspace_path, 'attic', recipename, os.path.basename(recipefile))
        if os.path.exists(attic_recipe):
            logger.warning('A modified recipe from a previous invocation exists in %s - you may wish to move this over the top of the new recipe if you had changes in it that you want to continue with' % attic_recipe)
@@ -305,6 +308,7 @@ def add(args, config, basepath, workspace):
 def _check_compatible_recipe(pn, d):
    """Check if the recipe is supported by devtool"""
+    import bb.data
    if pn == 'perf':
        raise DevtoolError("The perf recipe does not actually check out "
                           "source and thus cannot be supported by this tool",
@@ -374,7 +378,7 @@ def _copy_file(src, dst, dry_run_outdir=None, base_outdir=None):
 def _git_ls_tree(repodir, treeish='HEAD', recursive=False):
    """List contents of a git treeish"""
-    import bb
+    import bb.process
    cmd = ['git', 'ls-tree', '-z', treeish]
    if recursive:
        cmd.append('-r')
@@ -387,6 +391,19 @@ def _git_ls_tree(repodir, treeish='HEAD', recursive=False):
                ret[split[3]] = split[0:3]
    return ret
+def _git_modified(repodir):
+    """List the difference between HEAD and the index"""
+    import bb.process
+    cmd = ['git', 'status', '--porcelain']
+    out, _ = bb.process.run(cmd, cwd=repodir)
+    ret = []
+    if out:
+        for line in out.split("\n"):
+            if line and not line.startswith('??'):
+                ret.append(line[3:])
+    return ret
 def _git_exclude_path(srctree, path):
    """Return pathspec (list of paths) that excludes certain path"""
    # NOTE: "Filtering out" files/paths in this way is not entirely reliable -
@@ -414,8 +431,6 @@ def _ls_tree(directory):
 def extract(args, config, basepath, workspace):
    """Entry point for the devtool 'extract' subcommand"""
-    import bb
    tinfoil = setup_tinfoil(basepath=basepath, tracking=True)
    if not tinfoil:
        # Error already shown
@@ -438,8 +453,6 @@ def extract(args, config, basepath, workspace):
 def sync(args, config, basepath, workspace):
    """Entry point for the devtool 'sync' subcommand"""
-    import bb
    tinfoil = setup_tinfoil(basepath=basepath, tracking=True)
    if not tinfoil:
        # Error already shown
@@ -460,37 +473,11 @@ def sync(args, config, basepath, workspace):
    finally:
        tinfoil.shutdown()
-def symlink_oelocal_files_srctree(rd, srctree):
-    import oe.patch
-    if os.path.abspath(rd.getVar('S')) == os.path.abspath(rd.getVar('WORKDIR')):
-        # If recipe extracts to ${WORKDIR}, symlink the files into the srctree
-        # (otherwise the recipe won't build as expected)
-        local_files_dir = os.path.join(srctree, 'oe-local-files')
-        addfiles = []
-        for root, _, files in os.walk(local_files_dir):
-            relpth = os.path.relpath(root, local_files_dir)
-            if relpth != '.':
-                bb.utils.mkdirhier(os.path.join(srctree, relpth))
-            for fn in files:
-                if fn == '.gitignore':
-                    continue
-                destpth = os.path.join(srctree, relpth, fn)
-                if os.path.exists(destpth):
-                    os.unlink(destpth)
-                if relpth != '.':
-                    back_relpth = os.path.relpath(local_files_dir, root)
-                    os.symlink('%s/oe-local-files/%s/%s' % (back_relpth, relpth, fn), destpth)
-                else:
-                    os.symlink('oe-local-files/%s' % fn, destpth)
-                addfiles.append(os.path.join(relpth, fn))
-        if addfiles:
-            oe.patch.GitApplyTree.commitIgnored("Add local file symlinks", dir=srctree, files=addfiles, d=rd)
 def _extract_source(srctree, keep_temp, devbranch, sync, config, basepath, workspace, fixed_setup, d, tinfoil, no_overrides=False):
    """Extract sources of a recipe"""
-    import oe.recipeutils
-    import oe.patch
    import oe.path
+    import bb.data
+    import bb.process
    pn = d.getVar('PN')
@@ -555,6 +542,7 @@ def _extract_source(srctree, keep_temp, devbranch, sync, config, basepath, works
    tempbasedir = d.getVar('WORKDIR')
    bb.utils.mkdirhier(tempbasedir)
    tempdir = tempfile.mkdtemp(prefix='devtooltmp-', dir=tempbasedir)
+    appendbackup = None
    try:
        tinfoil.logger.setLevel(logging.WARNING)
@@ -565,7 +553,6 @@ def _extract_source(srctree, keep_temp, devbranch, sync, config, basepath, works
            appendbackup = os.path.join(tempdir, os.path.basename(appendfile) + '.bak')
            shutil.copyfile(appendfile, appendbackup)
        else:
-            appendbackup = None
            bb.utils.mkdirhier(os.path.dirname(appendfile))
        logger.debug('writing append file %s' % appendfile)
        with open(appendfile, 'a') as f:
@@ -638,7 +625,7 @@ def _extract_source(srctree, keep_temp, devbranch, sync, config, basepath, works
                srcsubdir = f.read()
        except FileNotFoundError as e:
            raise DevtoolError('Something went wrong with source extraction - the devtool-source class was not active or did not function correctly:\n%s' % str(e))
-        srcsubdir_rel = os.path.relpath(srcsubdir, os.path.join(tempdir, 'workdir'))
+        srcsubdir_rel = os.path.relpath(srcsubdir, os.path.join(tempdir, 'workdir', os.path.relpath(d.getVar('UNPACKDIR'), d.getVar('WORKDIR'))))
        # Check if work-shared is empty, if yes
        # find source and copy to work-shared
@@ -657,9 +644,6 @@ def _extract_source(srctree, keep_temp, devbranch, sync, config, basepath, works
            elif not os.path.exists(workshareddir):
                oe.path.copyhardlinktree(srcsubdir, workshareddir)
-        tempdir_localdir = os.path.join(tempdir, 'oe-local-files')
-        srctree_localdir = os.path.join(srctree, 'oe-local-files')
        if sync:
            try:
                logger.info('Backing up current %s branch as branch: %s.bak' % (devbranch, devbranch))
@@ -674,29 +658,8 @@ def _extract_source(srctree, keep_temp, devbranch, sync, config, basepath, works
            except bb.process.ExecutionError as e:
                raise DevtoolError("Error when syncing source files to local checkout: %s" % str(e))
-            # Move the oe-local-files directory to srctree.
-            # As oe-local-files is not part of the constructed git tree,
-            # removing it directly during the synchronization might surprise
-            # the user.  Instead, we move it to oe-local-files.bak and remind
-            # the user in the log message.
-            if os.path.exists(srctree_localdir + '.bak'):
-                shutil.rmtree(srctree_localdir + '.bak')
-            if os.path.exists(srctree_localdir):
-                logger.info('Backing up current local file directory %s' % srctree_localdir)
-                shutil.move(srctree_localdir, srctree_localdir + '.bak')
-            if os.path.exists(tempdir_localdir):
-                logger.info('Syncing local source files to srctree...')
-                shutil.copytree(tempdir_localdir, srctree_localdir)
        else:
-            # Move oe-local-files directory to srctree
-            if os.path.exists(tempdir_localdir):
-                logger.info('Adding local source files to srctree...')
-                shutil.move(tempdir_localdir, srcsubdir)
            shutil.move(srcsubdir, srctree)
-            symlink_oelocal_files_srctree(d, srctree)
        if is_kernel_yocto:
            logger.info('Copying kernel config to srctree')
@@ -715,8 +678,6 @@ def _extract_source(srctree, keep_temp, devbranch, sync, config, basepath, works
 def _add_md5(config, recipename, filename):
    """Record checksum of a file (or recursively for a directory) to the md5-file of the workspace"""
-    import bb.utils
    def addfile(fn):
        md5 = bb.utils.md5_file(fn)
        with open(os.path.join(config.workspace_path, '.devtool_md5'), 'a+') as f:
@@ -735,7 +696,6 @@ def _add_md5(config, recipename, filename):
 def _check_preserve(config, recipename):
    """Check if a file was manually changed and needs to be saved in 'attic'
       directory"""
-    import bb.utils
    origfile = os.path.join(config.workspace_path, '.devtool_md5')
    newfile = os.path.join(config.workspace_path, '.devtool_md5_new')
    preservepath = os.path.join(config.workspace_path, 'attic', recipename)
@@ -766,36 +726,36 @@ def _check_preserve(config, recipename):
 def get_staging_kver(srcdir):
    # Kernel version from work-shared
-    kerver = []
+    import itertools
-    staging_kerVer=""
+    try:
-    if os.path.exists(srcdir) and os.listdir(srcdir):
        with open(os.path.join(srcdir, "Makefile")) as f:
-            version = [next(f) for x in range(5)][1:4]
+            # Take VERSION, PATCHLEVEL, SUBLEVEL from lines 1, 2, 3
-            for word in version:
+            return ".".join(line.rstrip().split('= ')[1] for line in itertools.islice(f, 1, 4))
-                kerver.append(word.split('= ')[1].split('\n')[0])
+    except FileNotFoundError:
-            staging_kerVer = ".".join(kerver)
+        return ""
-    return staging_kerVer
 def get_staging_kbranch(srcdir):
+    import bb.process
    staging_kbranch = ""
    if os.path.exists(srcdir) and os.listdir(srcdir):
        (branch, _) = bb.process.run('git branch | grep \\* | cut -d \' \' -f2', cwd=srcdir)
        staging_kbranch = "".join(branch.split('\n')[0])
    return staging_kbranch
-def get_real_srctree(srctree, s, workdir):
+def get_real_srctree(srctree, s, unpackdir):
    # Check that recipe isn't using a shared workdir
    s = os.path.abspath(s)
-    workdir = os.path.abspath(workdir)
+    unpackdir = os.path.abspath(unpackdir)
-    if s.startswith(workdir) and s != workdir and os.path.dirname(s) != workdir:
+    if s.startswith(unpackdir) and s != unpackdir and os.path.dirname(s) != unpackdir:
        # Handle if S is set to a subdirectory of the source
-        srcsubdir = os.path.relpath(s, workdir).split(os.sep, 1)[1]
+        srcsubdir = os.path.relpath(s, unpackdir).split(os.sep, 1)[1]
        srctree = os.path.join(srctree, srcsubdir)
    return srctree
 def modify(args, config, basepath, workspace):
    """Entry point for the devtool 'modify' subcommand"""
-    import bb
+    import bb.data
+    import bb.process
    import oe.recipeutils
    import oe.patch
    import oe.path
@@ -851,35 +811,21 @@ def modify(args, config, basepath, workspace):
            staging_kbranch = get_staging_kbranch(srcdir)
            if (os.path.exists(srcdir) and os.listdir(srcdir)) and (kernelVersion in staging_kerVer and staging_kbranch == kbranch):
                oe.path.copyhardlinktree(srcdir, srctree)
-                workdir = rd.getVar('WORKDIR')
+                unpackdir = rd.getVar('UNPACKDIR')
                srcsubdir = rd.getVar('S')
-                localfilesdir = os.path.join(srctree, 'oe-local-files')
-                # Move local source files into separate subdir
-                recipe_patches = [os.path.basename(patch) for patch in oe.recipeutils.get_recipe_patches(rd)]
-                local_files = oe.recipeutils.get_recipe_local_files(rd)
-                for key in local_files.copy():
+                # Add locally copied files to gitignore as we add back to the metadata directly
-                    if key.endswith('scc'):
+                local_files = oe.recipeutils.get_recipe_local_files(rd)
-                        sccfile = open(local_files[key], 'r')
-                        for l in sccfile:
-                            line = l.split()
-                            if line and line[0] in ('kconf', 'patch'):
-                                cfg = os.path.join(os.path.dirname(local_files[key]), line[-1])
-                                if not cfg in local_files.values():
-                                    local_files[line[-1]] = cfg
-                                    shutil.copy2(cfg, workdir)
-                        sccfile.close()
-                # Ignore local files with subdir={BP}
                srcabspath = os.path.abspath(srcsubdir)
-                local_files = [fname for fname in local_files if os.path.exists(os.path.join(workdir, fname)) and  (srcabspath == workdir or not  os.path.join(workdir, fname).startswith(srcabspath + os.sep))]
+                local_files = [fname for fname in local_files if
+                               os.path.exists(os.path.join(unpackdir, fname)) and
+                               srcabspath == unpackdir]
                if local_files:
-                    for fname in local_files:
+                    with open(os.path.join(srctree, '.gitignore'), 'a+') as f:
-                        _move_file(os.path.join(workdir, fname), os.path.join(srctree, 'oe-local-files', fname))
+                        f.write('# Ignore local files, by default. Remove following lines'
-                    with open(os.path.join(srctree, 'oe-local-files', '.gitignore'), 'w') as f:
+                                'if you want to commit the directory to Git\n')
-                        f.write('# Ignore local files, by default. Remove this file if you want to commit the directory to Git\n*\n')
+                        for fname in local_files:
+                            f.write('%s\n' % fname)
-                symlink_oelocal_files_srctree(rd, srctree)
                task = 'do_configure'
                res = tinfoil.build_targets(pn, task, handle_events=True)
@@ -961,7 +907,7 @@ def modify(args, config, basepath, workspace):
        # Need to grab this here in case the source is within a subdirectory
        srctreebase = srctree
-        srctree = get_real_srctree(srctree, rd.getVar('S'), rd.getVar('WORKDIR'))
+        srctree = get_real_srctree(srctree, rd.getVar('S'), rd.getVar('UNPACKDIR'))
        bb.utils.mkdirhier(os.path.dirname(appendfile))
        with open(appendfile, 'w') as f:
@@ -1001,13 +947,6 @@ def modify(args, config, basepath, workspace):
                f.write('EXTERNALSRC_BUILD:pn-%s = "%s"\n' % (pn, srctree))
            if bb.data.inherits_class('kernel', rd):
-                f.write('SRCTREECOVEREDTASKS = "do_validate_branches do_kernel_checkout '
-                        'do_fetch do_unpack do_kernel_configcheck"\n')
-                f.write('\ndo_patch[noexec] = "1"\n')
-                f.write('\ndo_configure:append() {\n'
-                        '    cp ${B}/.config ${S}/.config.baseline\n'
-                        '    ln -sfT ${B}/.config ${S}/.config.new\n'
-                        '}\n')
                f.write('\ndo_kernel_configme:prepend() {\n'
                        '    if [ -e ${S}/.config ]; then\n'
                        '        mv ${S}/.config ${S}/.config.old\n'
@@ -1031,6 +970,8 @@ def modify(args, config, basepath, workspace):
                    if branch == args.branch:
                        continue
                    f.write('# patches_%s: %s\n' % (branch, ','.join(branch_patches[branch])))
+            if args.debug_build:
+                f.write('\nDEBUG_BUILD = "1"\n')
        update_unlockedsigs(basepath, workspace, args.fixed_setup, [pn])
@@ -1075,6 +1016,7 @@ def rename(args, config, basepath, workspace):
        origfnver = ''
    recipefilemd5 = None
+    newrecipefilemd5 = None
    tinfoil = setup_tinfoil(basepath=basepath, tracking=True)
    try:
        rd = parse_recipe(config, tinfoil, args.recipename, True)
@@ -1152,6 +1094,7 @@ def rename(args, config, basepath, workspace):
    # Rename source tree if it's the default path
    appendmd5 = None
+    newappendmd5 = None
    if not args.no_srctree:
        srctree = workspace[args.recipename]['srctree']
        if os.path.abspath(srctree) == os.path.join(config.workspace_path, 'sources', args.recipename):
@@ -1240,7 +1183,7 @@ def _get_patchset_revs(srctree, recipe_path, initial_rev=None, force_patch_refre
    """Get initial and update rev of a recipe. These are the start point of the
    whole patchset and start point for the patches to be re-generated/updated.
    """
-    import bb
+    import bb.process
    # Get current branch
    stdout, _ = bb.process.run('git rev-parse --abbrev-ref HEAD',
@@ -1366,6 +1309,7 @@ def _export_patches(srctree, rd, start_revs, destdir, changed_revs=None):
    """
    import oe.recipeutils
    from oe.patch import GitApplyTree
+    import bb.process
    updated = OrderedDict()
    added = OrderedDict()
    seqpatch_re = re.compile('^([0-9]{4}-)?(.+)')
@@ -1387,6 +1331,7 @@ def _export_patches(srctree, rd, start_revs, destdir, changed_revs=None):
            # values, but they ought to be anyway...
            new_basename = seqpatch_re.match(new_patch).group(2)
            match_name = None
+            old_patch = None
            for old_patch in existing_patches:
                old_basename = seqpatch_re.match(old_patch).group(2)
                old_basename_splitext = os.path.splitext(old_basename)
@@ -1435,6 +1380,7 @@ def _export_patches(srctree, rd, start_revs, destdir, changed_revs=None):
 def _create_kconfig_diff(srctree, rd, outfile):
    """Create a kconfig fragment"""
+    import bb.process
    # Only update config fragment if both config files exist
    orig_config = os.path.join(srctree, '.config.baseline')
    new_config = os.path.join(srctree, '.config.new')
@@ -1472,12 +1418,15 @@ def _export_local_files(srctree, rd, destdir, srctreebase):
         - for removed dict, the absolute path to the existing file in recipe space
    """
    import oe.recipeutils
+    import bb.data
+    import bb.process
    # Find out local files (SRC_URI files that exist in the "recipe space").
    # Local files that reside in srctree are not included in patch generation.
    # Instead they are directly copied over the original source files (in
    # recipe space).
    existing_files = oe.recipeutils.get_recipe_local_files(rd)
    new_set = None
    updated = OrderedDict()
    added = OrderedDict()
@@ -1494,24 +1443,28 @@ def _export_local_files(srctree, rd, destdir, srctreebase):
    if branchname.startswith(override_branch_prefix):
        return (updated, added, removed)
-    local_files_dir = os.path.join(srctreebase, 'oe-local-files')
+    files = _git_modified(srctree)
-    git_files = _git_ls_tree(srctree)
+        #if not files:
-    if 'oe-local-files' in git_files:
+        #    files = _ls_tree(srctree)
-        # If tracked by Git, take the files from srctree HEAD. First get
+    for f in files:
-        # the tree object of the directory
+        fullfile = os.path.join(srctree, f)
-        tmp_index = os.path.join(srctree, '.git', 'index.tmp.devtool')
+        if os.path.exists(os.path.join(fullfile, ".git")):
-        tree = git_files['oe-local-files'][2]
+            # submodules handled elsewhere
-        bb.process.run(['git', 'checkout', tree, '--', '.'], cwd=srctree,
+            continue
-                        env=dict(os.environ, GIT_WORK_TREE=destdir,
+        if f not in existing_files:
-                                 GIT_INDEX_FILE=tmp_index))
+            added[f] = {}
-        new_set = list(_git_ls_tree(srctree, tree, True).keys())
+            if os.path.isdir(os.path.join(srctree, f)):
-    elif os.path.isdir(local_files_dir):
+                shutil.copytree(fullfile, os.path.join(destdir, f))
-        # If not tracked by Git, just copy from working copy
+            else:
-        new_set = _ls_tree(local_files_dir)
+                shutil.copy2(fullfile, os.path.join(destdir, f))
-        bb.process.run(['cp', '-ax',
+        elif not os.path.exists(fullfile):
-                        os.path.join(local_files_dir, '.'), destdir])
+            removed[f] = existing_files[f]
-    else:
+        elif f in existing_files:
-        new_set = []
+            updated[f] = {'path' : existing_files[f]}
+            if os.path.isdir(os.path.join(srctree, f)):
+                shutil.copytree(fullfile, os.path.join(destdir, f))
+            else:
+                shutil.copy2(fullfile, os.path.join(destdir, f))
    # Special handling for kernel config
    if bb.data.inherits_class('kernel-yocto', rd):
@@ -1519,17 +1472,14 @@ def _export_local_files(srctree, rd, destdir, srctreebase):
        fragment_path = os.path.join(destdir, fragment_fn)
        if _create_kconfig_diff(srctree, rd, fragment_path):
            if os.path.exists(fragment_path):
-                if fragment_fn not in new_set:
+                if fragment_fn in removed:
-                    new_set.append(fragment_fn)
+                    del removed[fragment_fn]
-                # Copy fragment to local-files
+                if fragment_fn not in updated and fragment_fn not in added:
-                if os.path.isdir(local_files_dir):
+                    added[fragment_fn] = {}
-                    shutil.copy2(fragment_path, local_files_dir)
            else:
-                if fragment_fn in new_set:
+                if fragment_fn in updated:
-                    new_set.remove(fragment_fn)
+                    removed[fragment_fn] = updated[fragment_fn]
-                # Remove fragment from local-files
+                    del updated[fragment_fn]
-                if os.path.exists(os.path.join(local_files_dir, fragment_fn)):
-                    os.unlink(os.path.join(local_files_dir, fragment_fn))
    # Special handling for cml1, ccmake, etc bbclasses that generated
    # configuration fragment files that are consumed as source files
@@ -1537,42 +1487,13 @@ def _export_local_files(srctree, rd, destdir, srctreebase):
        if bb.data.inherits_class(frag_class, rd):
            srcpath = os.path.join(rd.getVar('WORKDIR'), frag_name)
            if os.path.exists(srcpath):
-                if frag_name not in new_set:
+                if frag_name in removed:
-                    new_set.append(frag_name)
+                    del removed[frag_name]
+                if frag_name not in updated:
+                    added[frag_name] = {}
                # copy fragment into destdir
                shutil.copy2(srcpath, destdir)
-                # copy fragment into local files if exists
-                if os.path.isdir(local_files_dir):
-                    shutil.copy2(srcpath, local_files_dir)
-    if new_set is not None:
-        for fname in new_set:
-            if fname in existing_files:
-                origpath = existing_files.pop(fname)
-                workpath = os.path.join(local_files_dir, fname)
-                if not filecmp.cmp(origpath, workpath):
-                    updated[fname] = {'path' : origpath}
-            elif fname != '.gitignore':
-                added[fname] = {}
-        workdir = rd.getVar('WORKDIR')
-        s = rd.getVar('S')
-        if not s.endswith(os.sep):
-            s += os.sep
-        if workdir != s:
-            # Handle files where subdir= was specified
-            for fname in list(existing_files.keys()):
-                # FIXME handle both subdir starting with BP and not?
-                fworkpath = os.path.join(workdir, fname)
-                if fworkpath.startswith(s):
-                    fpath = os.path.join(srctree, os.path.relpath(fworkpath, s))
-                    if os.path.exists(fpath):
-                        origpath = existing_files.pop(fname)
-                        if not filecmp.cmp(origpath, fpath):
-                            updated[fpath] = {'path' : origpath}
-        removed = existing_files
    return (updated, added, removed)
@@ -1590,7 +1511,7 @@ def _determine_files_dir(rd):
 def _update_recipe_srcrev(recipename, workspace, srctree, rd, appendlayerdir, wildcard_version, no_remove, no_report_remove, dry_run_outdir=None):
    """Implement the 'srcrev' mode of update-recipe"""
-    import bb
+    import bb.process
    import oe.recipeutils
    dry_run_suffix = ' (dry-run)' if dry_run_outdir else ''
@@ -1628,6 +1549,7 @@ def _update_recipe_srcrev(recipename, workspace, srctree, rd, appendlayerdir, wi
        local_files_dir = tempfile.mkdtemp(dir=tempdir)
        srctreebase = workspace[recipename]['srctreebase']
        upd_f, new_f, del_f = _export_local_files(srctree, rd, local_files_dir, srctreebase)
+        removedentries = {}
        if not no_remove:
            # Find list of existing patches in recipe file
            patches_dir = tempfile.mkdtemp(dir=tempdir)
@@ -1691,7 +1613,6 @@ def _update_recipe_srcrev(recipename, workspace, srctree, rd, appendlayerdir, wi
 def _update_recipe_patch(recipename, workspace, srctree, rd, appendlayerdir, wildcard_version, no_remove, no_report_remove, initial_rev, dry_run_outdir=None, force_patch_refresh=False):
    """Implement the 'patch' mode of update-recipe"""
-    import bb
    import oe.recipeutils
    recipefile = rd.getVar('FILE')
@@ -1805,6 +1726,7 @@ def _update_recipe_patch(recipename, workspace, srctree, rd, appendlayerdir, wil
            for basepath, param in upd_p.items():
                path = param['path']
                patchdir = param.get('patchdir', ".")
+                patchdir_param = {}
                if patchdir != "." :
                    patchdir_param = dict(patchdir_params)
                    if patchdir_param:
@@ -1870,6 +1792,7 @@ def _update_recipe_patch(recipename, workspace, srctree, rd, appendlayerdir, wil
 def _guess_recipe_update_mode(srctree, rdata):
    """Guess the recipe update mode to use"""
+    import bb.process
    src_uri = (rdata.getVar('SRC_URI') or '').split()
    git_uris = [uri for uri in src_uri if uri.startswith('git://')]
    if not git_uris:
@@ -1891,6 +1814,8 @@ def _guess_recipe_update_mode(srctree, rdata):
    return 'patch'
 def _update_recipe(recipename, workspace, rd, mode, appendlayerdir, wildcard_version, no_remove, initial_rev, no_report_remove=False, dry_run_outdir=None, no_overrides=False, force_patch_refresh=False):
+    import bb.data
+    import bb.process
    srctree = workspace[recipename]['srctree']
    if mode == 'auto':
        mode = _guess_recipe_update_mode(srctree, rd)
@@ -2013,6 +1938,7 @@ def status(args, config, basepath, workspace):
 def _reset(recipes, no_clean, remove_work, config, basepath, workspace):
    """Reset one or more recipes"""
+    import bb.process
    import oe.path
    def clean_preferred_provider(pn, layerconf_path):
@@ -2025,7 +1951,7 @@ def _reset(recipes, no_clean, remove_work, config, basepath, workspace):
            lines = f.readlines()
            with open(new_layerconf_file, 'a') as nf:
                for line in lines:
-                    pprovider_exp = r'^PREFERRED_PROVIDER_.*? = "' + pn + r'"$'
+                    pprovider_exp = r'^PREFERRED_PROVIDER_.*? = "' + re.escape(pn) + r'"$'
                    if not re.match(pprovider_exp, line):
                        nf.write(line)
                    else:
@@ -2116,8 +2042,6 @@ def _reset(recipes, no_clean, remove_work, config, basepath, workspace):
 def reset(args, config, basepath, workspace):
    """Entry point for the devtool 'reset' subcommand"""
-    import bb
-    import shutil
    recipes = ""
@@ -2396,6 +2320,7 @@ def register_commands(subparsers, context):
    parser_modify.add_argument('--branch', '-b', default="devtool", help='Name for development branch to checkout (when not using -n/--no-extract) (default "%(default)s")')
    parser_modify.add_argument('--no-overrides', '-O', action="store_true", help='Do not create branches for other override configurations')
    parser_modify.add_argument('--keep-temp', help='Keep temporary directory (for debugging)', action="store_true")
+    parser_modify.add_argument('--debug-build', action="store_true", help='Add DEBUG_BUILD = "1" to the modified recipe')
    parser_modify.set_defaults(func=modify, fixed_setup=context.fixed_setup)
    parser_extract = subparsers.add_parser('extract', help='Extract the source for an existing recipe',
diff --git a/scripts/lib/devtool/upgrade.py b/scripts/lib/devtool/upgrade.py
index fa5b8ef3c7..dda0a58098 100644
--- a/scripts/lib/devtool/upgrade.py
+++ b/scripts/lib/devtool/upgrade.py
@@ -32,7 +32,7 @@ def _run(cmd, cwd=''):
 def _get_srctree(tmpdir):
    srctree = tmpdir
-    dirs = scriptutils.filter_src_subdirs(tmpdir)
+    dirs = os.listdir(tmpdir)
    if len(dirs) == 1:
        srctree = os.path.join(tmpdir, dirs[0])
    else:
@@ -76,19 +76,19 @@ def _rename_recipe_dirs(oldpv, newpv, path):
                        bb.utils.rename(os.path.join(path, oldfile),
                              os.path.join(path, newfile))
-def _rename_recipe_file(oldrecipe, bpn, oldpv, newpv, path):
+def _rename_recipe_file(oldrecipe, pn, oldpv, newpv, path):
    oldrecipe = os.path.basename(oldrecipe)
    if oldrecipe.endswith('_%s.bb' % oldpv):
-        newrecipe = '%s_%s.bb' % (bpn, newpv)
+        newrecipe = '%s_%s.bb' % (pn, newpv)
        if oldrecipe != newrecipe:
            shutil.move(os.path.join(path, oldrecipe), os.path.join(path, newrecipe))
    else:
        newrecipe = oldrecipe
    return os.path.join(path, newrecipe)
-def _rename_recipe_files(oldrecipe, bpn, oldpv, newpv, path):
+def _rename_recipe_files(oldrecipe, pn, oldpv, newpv, path):
    _rename_recipe_dirs(oldpv, newpv, path)
-    return _rename_recipe_file(oldrecipe, bpn, oldpv, newpv, path)
+    return _rename_recipe_file(oldrecipe, pn, oldpv, newpv, path)
 def _write_append(rc, srctreebase, srctree, same_dir, no_same_dir, revs, copied, workspace, d):
    """Writes an append file"""
@@ -169,6 +169,7 @@ def _get_uri(rd):
 def _extract_new_source(newpv, srctree, no_patch, srcrev, srcbranch, branch, keep_temp, tinfoil, rd):
    """Extract sources of a recipe with a new version"""
+    import oe.patch
    def __run(cmd):
        """Simple wrapper which calls _run with srctree as cwd"""
@@ -187,9 +188,9 @@ def _extract_new_source(newpv, srctree, no_patch, srcrev, srcbranch, branch, kee
    if uri.startswith('git://') or uri.startswith('gitsm://'):
        __run('git fetch')
        __run('git checkout %s' % rev)
-        __run('git tag -f devtool-base-new')
+        __run('git tag -f --no-sign devtool-base-new')
        __run('git submodule update --recursive')
-        __run('git submodule foreach \'git tag -f devtool-base-new\'')
+        __run('git submodule foreach \'git tag -f --no-sign devtool-base-new\'')
        (stdout, _) = __run('git submodule --quiet foreach \'echo $sm_path\'')
        paths += [os.path.join(srctree, p) for p in stdout.splitlines()]
        checksums = {}
@@ -256,7 +257,7 @@ def _extract_new_source(newpv, srctree, no_patch, srcrev, srcbranch, branch, kee
        useroptions = []
        oe.patch.GitApplyTree.gitCommandUserOptions(useroptions, d=rd)
        __run('git %s commit -q -m "Commit of upstream changes at version %s" --allow-empty' % (' '.join(useroptions), newpv))
-        __run('git tag -f devtool-base-%s' % newpv)
+        __run('git tag -f --no-sign devtool-base-%s' % newpv)
    revs = {}
    for path in paths:
@@ -279,7 +280,7 @@ def _extract_new_source(newpv, srctree, no_patch, srcrev, srcbranch, branch, kee
            # note is still attached to the old commit. Avoid this by making
            # sure all old devtool related commits have a note attached to them
            # (this assumes git config notes.rewriteMode is set to ignore).
-            (stdout, _) = __run('git rev-list devtool-base..%s' % target_branch)
+            (stdout, _) = _run('git rev-list devtool-base..%s' % target_branch, cwd=path)
            for rev in stdout.splitlines():
                if not oe.patch.GitApplyTree.getNotes(path, rev):
                    oe.patch.GitApplyTree.addNote(path, rev, "dummy")
@@ -297,7 +298,7 @@ def _extract_new_source(newpv, srctree, no_patch, srcrev, srcbranch, branch, kee
                        logger.warning('Command \'%s\' failed:\n%s' % (e.command, e.stdout))
            # Remove any dummy notes added above.
-            (stdout, _) = __run('git rev-list devtool-base..%s' % target_branch)
+            (stdout, _) = _run('git rev-list devtool-base..%s' % target_branch, cwd=path)
            for rev in stdout.splitlines():
                oe.patch.GitApplyTree.removeNote(path, rev, "dummy")
@@ -335,19 +336,19 @@ def _add_license_diff_to_recipe(path, diff):
 def _create_new_recipe(newpv, checksums, srcrev, srcbranch, srcsubdir_old, srcsubdir_new, workspace, tinfoil, rd, license_diff, new_licenses, srctree, keep_failure):
    """Creates the new recipe under workspace"""
-    bpn = rd.getVar('BPN')
+    pn = rd.getVar('PN')
-    path = os.path.join(workspace, 'recipes', bpn)
+    path = os.path.join(workspace, 'recipes', pn)
    bb.utils.mkdirhier(path)
    copied, _ = oe.recipeutils.copy_recipe_files(rd, path, all_variants=True)
    if not copied:
-        raise DevtoolError('Internal error - no files were copied for recipe %s' % bpn)
+        raise DevtoolError('Internal error - no files were copied for recipe %s' % pn)
    logger.debug('Copied %s to %s' % (copied, path))
    oldpv = rd.getVar('PV')
    if not newpv:
        newpv = oldpv
    origpath = rd.getVar('FILE')
-    fullpath = _rename_recipe_files(origpath, bpn, oldpv, newpv, path)
+    fullpath = _rename_recipe_files(origpath, pn, oldpv, newpv, path)
    logger.debug('Upgraded %s => %s' % (origpath, fullpath))
    newvalues = {}
@@ -534,6 +535,15 @@ def _generate_license_diff(old_licenses, new_licenses):
            diff = diff + line
    return diff
+def _run_recipe_upgrade_extra_tasks(pn, rd, tinfoil):
+    tasks = []
+    for task in (rd.getVar('RECIPE_UPGRADE_EXTRA_TASKS') or '').split():
+        logger.info('Running extra recipe upgrade task: %s' % task)
+        res = tinfoil.build_targets(pn, task, handle_events=True)
+        if not res:
+            raise DevtoolError('Running extra recipe upgrade task %s for %s failed' % (task, pn))
 def upgrade(args, config, basepath, workspace):
    """Entry point for the devtool 'upgrade' subcommand"""
@@ -561,7 +571,7 @@ def upgrade(args, config, basepath, workspace):
        else:
            srctree = standard.get_default_srctree(config, pn)
-        srctree_s = standard.get_real_srctree(srctree, rd.getVar('S'), rd.getVar('WORKDIR'))
+        srctree_s = standard.get_real_srctree(srctree, rd.getVar('S'), rd.getVar('UNPACKDIR'))
        # try to automatically discover latest version and revision if not provided on command line
        if not args.version and not args.srcrev:
@@ -601,7 +611,7 @@ def upgrade(args, config, basepath, workspace):
            license_diff = _generate_license_diff(old_licenses, new_licenses)
            rf, copied = _create_new_recipe(args.version, checksums, args.srcrev, srcbranch, srcsubdir1, srcsubdir2, config.workspace_path, tinfoil, rd, license_diff, new_licenses, srctree, args.keep_failure)
        except (bb.process.CmdError, DevtoolError) as e:
-            recipedir = os.path.join(config.workspace_path, 'recipes', rd.getVar('BPN'))
+            recipedir = os.path.join(config.workspace_path, 'recipes', rd.getVar('PN'))
            _upgrade_error(e, recipedir, srctree, args.keep_failure)
        standard._add_md5(config, pn, os.path.dirname(rf))
@@ -609,6 +619,8 @@ def upgrade(args, config, basepath, workspace):
                        copied, config.workspace_path, rd)
        standard._add_md5(config, pn, af)
+        _run_recipe_upgrade_extra_tasks(pn, rd, tinfoil)
        update_unlockedsigs(basepath, workspace, args.fixed_setup, [pn])
        logger.info('Upgraded source extracted to %s' % srctree)
@@ -643,18 +655,28 @@ def latest_version(args, config, basepath, workspace):
    return 0
 def check_upgrade_status(args, config, basepath, workspace):
+    def _print_status(recipe):
+        print("{:25} {:15} {:15} {} {} {}".format(   recipe['pn'],
+                                                               recipe['cur_ver'],
+                                                               recipe['status'] if recipe['status'] != 'UPDATE' else (recipe['next_ver'] if not recipe['next_ver'].endswith("new-commits-available") else "new commits"),
+                                                               recipe['maintainer'],
+                                                               recipe['revision'] if recipe['revision'] != 'N/A' else "",
+                                                               "cannot be updated due to: %s" %(recipe['no_upgrade_reason']) if recipe['no_upgrade_reason'] else ""))
    if not args.recipe:
        logger.info("Checking the upstream status for all recipes may take a few minutes")
    results = oe.recipeutils.get_recipe_upgrade_status(args.recipe)
-    for result in results:
+    for recipegroup in results:
-        # pn, update_status, current, latest, maintainer, latest_commit, no_update_reason
+        upgrades = [r for r in recipegroup if r['status'] != 'MATCH']
-        if args.all or result[1] != 'MATCH':
+        currents = [r for r in recipegroup if r['status'] == 'MATCH']
-            print("{:25} {:15} {:15} {} {} {}".format(   result[0],
+        if len(upgrades) > 1:
-                                                               result[2],
+            print("These recipes need to be upgraded together {")
-                                                               result[1] if result[1] != 'UPDATE' else (result[3] if not result[3].endswith("new-commits-available") else "new commits"),
+        for r in sorted(upgrades, key=lambda r:r['pn']):
-                                                               result[4],
+            _print_status(r)
-                                                               result[5] if result[5] != 'N/A' else "",
+        if len(upgrades) > 1:
-                                                               "cannot be updated due to: %s" %(result[6]) if result[6] else ""))
+            print("}")
+        for r in currents:
+            if args.all:
+                _print_status(r)
 def register_commands(subparsers, context):
    """Register devtool subcommands from this plugin"""
diff --git a/scripts/lib/devtool/utilcmds.py b/scripts/lib/devtool/utilcmds.py
index 964817766b..bf39f71b11 100644
--- a/scripts/lib/devtool/utilcmds.py
+++ b/scripts/lib/devtool/utilcmds.py
@@ -64,7 +64,7 @@ def configure_help(args, config, basepath, workspace):
        b = rd.getVar('B')
        s = rd.getVar('S')
        configurescript = os.path.join(s, 'configure')
-        confdisabled = 'noexec' in rd.getVarFlags('do_configure') or 'do_configure' not in (rd.getVar('__BBTASKS', False) or [])
+        confdisabled = 'noexec' in rd.getVarFlags('do_configure') or 'do_configure' not in (bb.build.listtasks(rd))
        configureopts = oe.utils.squashspaces(rd.getVar('CONFIGUREOPTS') or '')
        extra_oeconf = oe.utils.squashspaces(rd.getVar('EXTRA_OECONF') or '')
        extra_oecmake = oe.utils.squashspaces(rd.getVar('EXTRA_OECMAKE') or '')
diff --git a/scripts/lib/recipetool/append.py b/scripts/lib/recipetool/append.py
index 10945d6008..041d79f162 100644
--- a/scripts/lib/recipetool/append.py
+++ b/scripts/lib/recipetool/append.py
@@ -317,7 +317,7 @@ def appendsrc(args, files, rd, extralines=None):
    import oe.recipeutils
    srcdir = rd.getVar('S')
-    workdir = rd.getVar('WORKDIR')
+    unpackdir = rd.getVar('UNPACKDIR')
    import bb.fetch
    simplified = {}
@@ -336,10 +336,10 @@ def appendsrc(args, files, rd, extralines=None):
        src_destdir = os.path.dirname(srcfile)
        if not args.use_workdir:
            if rd.getVar('S') == rd.getVar('STAGING_KERNEL_DIR'):
-                srcdir = os.path.join(workdir, 'git')
+                srcdir = os.path.join(unpackdir, rd.getVar('BB_GIT_DEFAULT_DESTSUFFIX'))
                if not bb.data.inherits_class('kernel-yocto', rd):
-                    logger.warning('S == STAGING_KERNEL_DIR and non-kernel-yocto, unable to determine path to srcdir, defaulting to ${WORKDIR}/git')
+                    logger.warning('S == STAGING_KERNEL_DIR and non-kernel-yocto, unable to determine path to srcdir, defaulting to ${UNPACKDIR}/${BB_GIT_DEFAULT_DESTSUFFIX}')
-            src_destdir = os.path.join(os.path.relpath(srcdir, workdir), src_destdir)
+            src_destdir = os.path.join(os.path.relpath(srcdir, unpackdir), src_destdir)
        src_destdir = os.path.normpath(src_destdir)
        if src_destdir and src_destdir != '.':
diff --git a/scripts/lib/recipetool/create.py b/scripts/lib/recipetool/create.py
index 8e9ff38db6..ef0ba974a9 100644
--- a/scripts/lib/recipetool/create.py
+++ b/scripts/lib/recipetool/create.py
@@ -18,6 +18,8 @@ from urllib.parse import urlparse, urldefrag, urlsplit
 import hashlib
 import bb.fetch2
 logger = logging.getLogger('recipetool')
+from oe.license import tidy_licenses
+from oe.license_finder import find_licenses
 tinfoil = None
 plugins = None
@@ -528,7 +530,7 @@ def create_recipe(args):
        if ftmpdir and args.keep_temp:
            logger.info('Fetch temp directory is %s' % ftmpdir)
-        dirlist = scriptutils.filter_src_subdirs(srctree)
+        dirlist = os.listdir(srctree)
        logger.debug('Directory listing (excluding filtered out):\n  %s' % '\n  '.join(dirlist))
        if len(dirlist) == 1:
            singleitem = os.path.join(srctree, dirlist[0])
@@ -637,7 +639,6 @@ def create_recipe(args):
                    if len(splitline) > 1:
                        if splitline[0] == 'origin' and scriptutils.is_src_url(splitline[1]):
                            srcuri = reformat_git_uri(splitline[1]) + ';branch=master'
-                            srcsubdir = 'git'
                            break
    if args.src_subdir:
@@ -735,7 +736,7 @@ def create_recipe(args):
    if srcsubdir and not args.binary:
        # (for binary packages we explicitly specify subdir= when fetching to
        # match the default value of S, so we don't need to set it in that case)
-        lines_before.append('S = "${WORKDIR}/%s"' % srcsubdir)
+        lines_before.append('S = "${UNPACKDIR}/%s"' % srcsubdir)
        lines_before.append('')
    if pkgarch:
@@ -764,6 +765,7 @@ def create_recipe(args):
    extrafiles = extravalues.pop('extrafiles', {})
    extra_pn = extravalues.pop('PN', None)
    extra_pv = extravalues.pop('PV', None)
+    run_tasks = extravalues.pop('run_tasks', "").split()
    if extra_pv and not realpv:
        realpv = extra_pv
@@ -824,7 +826,8 @@ def create_recipe(args):
            extraoutdir = os.path.join(os.path.dirname(outfile), pn)
        bb.utils.mkdirhier(extraoutdir)
        for destfn, extrafile in extrafiles.items():
-            shutil.move(extrafile, os.path.join(extraoutdir, destfn))
+            fn = destfn.format(pn=pn, pv=realpv)
+            shutil.move(extrafile, os.path.join(extraoutdir, fn))
    lines = lines_before
    lines_before = []
@@ -839,7 +842,7 @@ def create_recipe(args):
                line = line.replace(realpv, '${PV}')
            if pn:
                line = line.replace(pn, '${BPN}')
-            if line == 'S = "${WORKDIR}/${BPN}-${PV}"':
+            if line == 'S = "${UNPACKDIR}/${BPN}-${PV}"' or 'tmp-recipetool-' in line:
                skipblank = True
                continue
        elif line.startswith('SRC_URI = '):
@@ -917,6 +920,10 @@ def create_recipe(args):
        log_info_cond('Recipe %s has been created; further editing may be required to make it fully functional' % outfile, args.devtool)
        tinfoil.modified_files()
+    for task in run_tasks:
+        logger.info("Running task %s" % task)
+        tinfoil.build_file_sync(outfile, task)
    if tempsrc:
        if args.keep_temp:
            logger.info('Preserving temporary directory %s' % tempsrc)
@@ -944,23 +951,13 @@ def fixup_license(value):
        return '(' + value + ')'
    return value
-def tidy_licenses(value):
-    """Flat, split and sort licenses"""
-    from oe.license import flattened_licenses
-    def _choose(a, b):
-        str_a, str_b  = sorted((" & ".join(a), " & ".join(b)), key=str.casefold)
-        return ["(%s | %s)" % (str_a, str_b)]
-    if not isinstance(value, str):
-        value = " & ".join(value)
-    return sorted(list(set(flattened_licenses(value, _choose))), key=str.casefold)
 def handle_license_vars(srctree, lines_before, handled, extravalues, d):
    lichandled = [x for x in handled if x[0] == 'license']
    if lichandled:
        # Someone else has already handled the license vars, just return their value
        return lichandled[0][1]
-    licvalues = guess_license(srctree, d)
+    licvalues = find_licenses(srctree, d)
    licenses = []
    lic_files_chksum = []
    lic_unknown = []
@@ -1040,222 +1037,9 @@ def handle_license_vars(srctree, lines_before, handled, extravalues, d):
    handled.append(('license', licvalues))
    return licvalues
-def get_license_md5sums(d, static_only=False, linenumbers=False):
-    import bb.utils
-    import csv
-    md5sums = {}
-    if not static_only and not linenumbers:
-        # Gather md5sums of license files in common license dir
-        commonlicdir = d.getVar('COMMON_LICENSE_DIR')
-        for fn in os.listdir(commonlicdir):
-            md5value = bb.utils.md5_file(os.path.join(commonlicdir, fn))
-            md5sums[md5value] = fn
-    # The following were extracted from common values in various recipes
-    # (double checking the license against the license file itself, not just
-    # the LICENSE value in the recipe)
-    # Read license md5sums from csv file
-    scripts_path = os.path.dirname(os.path.realpath(__file__))
-    for path in (d.getVar('BBPATH').split(':')
-                + [os.path.join(scripts_path, '..', '..')]):
-        csv_path = os.path.join(path, 'lib', 'recipetool', 'licenses.csv')
-        if os.path.isfile(csv_path):
-            with open(csv_path, newline='') as csv_file:
-                fieldnames = ['md5sum', 'license', 'beginline', 'endline', 'md5']
-                reader = csv.DictReader(csv_file, delimiter=',', fieldnames=fieldnames)
-                for row in reader:
-                    if linenumbers:
-                        md5sums[row['md5sum']] = (
-                            row['license'], row['beginline'], row['endline'], row['md5'])
-                    else:
-                        md5sums[row['md5sum']] = row['license']
-    return md5sums
-def crunch_known_licenses(d):
-    '''
-    Calculate the MD5 checksums for the crunched versions of all common
-    licenses. Also add additional known checksums.
-    '''
-    
-    crunched_md5sums = {}
-    # common licenses
-    crunched_md5sums['ad4e9d34a2e966dfe9837f18de03266d'] = 'GFDL-1.1-only'
-    crunched_md5sums['d014fb11a34eb67dc717fdcfc97e60ed'] = 'GFDL-1.2-only'
-    crunched_md5sums['e020ca655b06c112def28e597ab844f1'] = 'GFDL-1.3-only'
-    # The following two were gleaned from the "forever" npm package
-    crunched_md5sums['0a97f8e4cbaf889d6fa51f84b89a79f6'] = 'ISC'
-    # https://github.com/waffle-gl/waffle/blob/master/LICENSE.txt
-    crunched_md5sums['50fab24ce589d69af8964fdbfe414c60'] = 'BSD-2-Clause'
-    # https://github.com/spigwitmer/fakeds1963s/blob/master/LICENSE
-    crunched_md5sums['88a4355858a1433fea99fae34a44da88'] = 'GPL-2.0-only'
-    # http://www.gnu.org/licenses/old-licenses/gpl-2.0.txt
-    crunched_md5sums['063b5c3ebb5f3aa4c85a2ed18a31fbe7'] = 'GPL-2.0-only'
-    # https://github.com/FFmpeg/FFmpeg/blob/master/COPYING.LGPLv2.1
-    crunched_md5sums['7f5202f4d44ed15dcd4915f5210417d8'] = 'LGPL-2.1-only'
-    # unixODBC-2.3.4 COPYING
-    crunched_md5sums['3debde09238a8c8e1f6a847e1ec9055b'] = 'LGPL-2.1-only'
-    # https://github.com/FFmpeg/FFmpeg/blob/master/COPYING.LGPLv3
-    crunched_md5sums['f90c613c51aa35da4d79dd55fc724ceb'] = 'LGPL-3.0-only'
-    # https://raw.githubusercontent.com/eclipse/mosquitto/v1.4.14/epl-v10
-    crunched_md5sums['efe2cb9a35826992b9df68224e3c2628'] = 'EPL-1.0'
-    # https://raw.githubusercontent.com/jquery/esprima/3.1.3/LICENSE.BSD
-    crunched_md5sums['80fa7b56a28e8c902e6af194003220a5'] = 'BSD-2-Clause'
-    # https://raw.githubusercontent.com/npm/npm-install-checks/master/LICENSE
-    crunched_md5sums['e659f77bfd9002659e112d0d3d59b2c1'] = 'BSD-2-Clause'
-    # https://raw.githubusercontent.com/silverwind/default-gateway/4.2.0/LICENSE
-    crunched_md5sums['4c641f2d995c47f5cb08bdb4b5b6ea05'] = 'BSD-2-Clause'
-    # https://raw.githubusercontent.com/tad-lispy/node-damerau-levenshtein/v1.0.5/LICENSE
-    crunched_md5sums['2b8c039b2b9a25f0feb4410c4542d346'] = 'BSD-2-Clause'
-    # https://raw.githubusercontent.com/terser/terser/v3.17.0/LICENSE
-    crunched_md5sums['8bd23871802951c9ad63855151204c2c'] = 'BSD-2-Clause'
-    # https://raw.githubusercontent.com/alexei/sprintf.js/1.0.3/LICENSE
-    crunched_md5sums['008c22318c8ea65928bf730ddd0273e3'] = 'BSD-3-Clause'
-    # https://raw.githubusercontent.com/Caligatio/jsSHA/v3.2.0/LICENSE
-    crunched_md5sums['0e46634a01bfef056892949acaea85b1'] = 'BSD-3-Clause'
-    # https://raw.githubusercontent.com/d3/d3-path/v1.0.9/LICENSE
-    crunched_md5sums['b5f72aef53d3b2b432702c30b0215666'] = 'BSD-3-Clause'
-    # https://raw.githubusercontent.com/feross/ieee754/v1.1.13/LICENSE
-    crunched_md5sums['a39327c997c20da0937955192d86232d'] = 'BSD-3-Clause'
-    # https://raw.githubusercontent.com/joyent/node-extsprintf/v1.3.0/LICENSE
-    crunched_md5sums['721f23a96ff4161ca3a5f071bbe18108'] = 'MIT'
-    # https://raw.githubusercontent.com/pvorb/clone/v0.2.0/LICENSE
-    crunched_md5sums['b376d29a53c9573006b9970709231431'] = 'MIT'
-    # https://raw.githubusercontent.com/andris9/encoding/v0.1.12/LICENSE
-    crunched_md5sums['85d8a977ee9d7c5ab4ac03c9b95431c4'] = 'MIT-0'
-    # https://raw.githubusercontent.com/faye/websocket-driver-node/0.7.3/LICENSE.md
-    crunched_md5sums['b66384e7137e41a9b1904ef4d39703b6'] = 'Apache-2.0'
-    # https://raw.githubusercontent.com/less/less.js/v4.1.1/LICENSE
-    crunched_md5sums['b27575459e02221ccef97ec0bfd457ae'] = 'Apache-2.0'
-    # https://raw.githubusercontent.com/microsoft/TypeScript/v3.5.3/LICENSE.txt
-    crunched_md5sums['a54a1a6a39e7f9dbb4a23a42f5c7fd1c'] = 'Apache-2.0'
-    # https://raw.githubusercontent.com/request/request/v2.87.0/LICENSE
-    crunched_md5sums['1034431802e57486b393d00c5d262b8a'] = 'Apache-2.0'
-    # https://raw.githubusercontent.com/dchest/tweetnacl-js/v0.14.5/LICENSE
-    crunched_md5sums['75605e6bdd564791ab698fca65c94a4f'] = 'Unlicense'
-    # https://raw.githubusercontent.com/stackgl/gl-mat3/v2.0.0/LICENSE.md
-    crunched_md5sums['75512892d6f59dddb6d1c7e191957e9c'] = 'Zlib'
-    commonlicdir = d.getVar('COMMON_LICENSE_DIR')
-    for fn in sorted(os.listdir(commonlicdir)):
-        md5value, lictext = crunch_license(os.path.join(commonlicdir, fn))
-        if md5value not in crunched_md5sums:
-            crunched_md5sums[md5value] = fn
-        elif fn != crunched_md5sums[md5value]:
-            bb.debug(2, "crunched_md5sums['%s'] is already set to '%s' rather than '%s'" % (md5value, crunched_md5sums[md5value], fn))
-        else:
-            bb.debug(2, "crunched_md5sums['%s'] is already set to '%s'" % (md5value, crunched_md5sums[md5value]))
-    return crunched_md5sums
-def crunch_license(licfile):
-    '''
-    Remove non-material text from a license file and then calculate its
-    md5sum. This works well for licenses that contain a copyright statement,
-    but is also a useful way to handle people's insistence upon reformatting
-    the license text slightly (with no material difference to the text of the
-    license).
-    '''
-    import oe.utils
-    # Note: these are carefully constructed!
-    license_title_re = re.compile(r'^#*\(? *(This is )?([Tt]he )?.{0,15} ?[Ll]icen[sc]e( \(.{1,10}\))?\)?[:\.]? ?#*$')
-    license_statement_re = re.compile(r'^((This (project|software)|.{1,10}) is( free software)? (released|licen[sc]ed)|(Released|Licen[cs]ed)) under the .{1,10} [Ll]icen[sc]e:?$')
-    copyright_re = re.compile(r'^ *[#\*]* *(Modified work |MIT LICENSED )?Copyright ?(\([cC]\))? .*$')
-    disclaimer_re = re.compile(r'^ *\*? ?All [Rr]ights [Rr]eserved\.$')
-    email_re = re.compile(r'^.*<[\w\.-]*@[\w\.\-]*>$')
-    header_re = re.compile(r'^(\/\**!?)? ?[\-=\*]* ?(\*\/)?$')
-    tag_re = re.compile(r'^ *@?\(?([Ll]icense|MIT)\)?$')
-    url_re = re.compile(r'^ *[#\*]* *https?:\/\/[\w\.\/\-]+$')
-    lictext = []
-    with open(licfile, 'r', errors='surrogateescape') as f:
-        for line in f:
-            # Drop opening statements
-            if copyright_re.match(line):
-                continue
-            elif disclaimer_re.match(line):
-                continue
-            elif email_re.match(line):
-                continue
-            elif header_re.match(line):
-                continue
-            elif tag_re.match(line):
-                continue
-            elif url_re.match(line):
-                continue
-            elif license_title_re.match(line):
-                continue
-            elif license_statement_re.match(line):
-                continue
-            # Strip comment symbols
-            line = line.replace('*', '') \
-                       .replace('#', '')
-            # Unify spelling
-            line = line.replace('sub-license', 'sublicense')
-            # Squash spaces
-            line = oe.utils.squashspaces(line.strip())
-            # Replace smart quotes, double quotes and backticks with single quotes
-            line = line.replace(u"\u2018", "'").replace(u"\u2019", "'").replace(u"\u201c","'").replace(u"\u201d", "'").replace('"', '\'').replace('`', '\'')
-            # Unify brackets
-            line = line.replace("{", "[").replace("}", "]")
-            if line:
-                lictext.append(line)
-    m = hashlib.md5()
-    try:
-        m.update(' '.join(lictext).encode('utf-8'))
-        md5val = m.hexdigest()
-    except UnicodeEncodeError:
-        md5val = None
-        lictext = ''
-    return md5val, lictext
-def guess_license(srctree, d):
-    import bb
-    md5sums = get_license_md5sums(d)
-    crunched_md5sums = crunch_known_licenses(d)
-    licenses = []
-    licspecs = ['*LICEN[CS]E*', 'COPYING*', '*[Ll]icense*', 'LEGAL*', '[Ll]egal*', '*GPL*', 'README.lic*', 'COPYRIGHT*', '[Cc]opyright*', 'e[dp]l-v10']
-    skip_extensions = (".html", ".js", ".json", ".svg", ".ts", ".go")
-    licfiles = []
-    for root, dirs, files in os.walk(srctree):
-        for fn in files:
-            if fn.endswith(skip_extensions):
-                continue
-            for spec in licspecs:
-                if fnmatch.fnmatch(fn, spec):
-                    fullpath = os.path.join(root, fn)
-                    if not fullpath in licfiles:
-                        licfiles.append(fullpath)
-    for licfile in sorted(licfiles):
-        md5value = bb.utils.md5_file(licfile)
-        license = md5sums.get(md5value, None)
-        if not license:
-            crunched_md5, lictext = crunch_license(licfile)
-            license = crunched_md5sums.get(crunched_md5, None)
-            if lictext and not license:
-                license = 'Unknown'
-                logger.info("Please add the following line for '%s' to a 'lib/recipetool/licenses.csv' " \
-                    "and replace `Unknown` with the license:\n" \
-                    "%s,Unknown" % (os.path.relpath(licfile, srctree), md5value))
-        if license:
-            licenses.append((license, os.path.relpath(licfile, srctree), md5value))
-    # FIXME should we grab at least one source file with a license header and add that too?
-    return licenses
 def split_pkg_licenses(licvalues, packages, outlines, fallback_licenses=None, pn='${PN}'):
    """
-    Given a list of (license, path, md5sum) as returned by guess_license(),
+    Given a list of (license, path, md5sum) as returned by match_licenses(),
    a dict of package name to path mappings, write out a set of
    package-specific LICENSE values.
    """
@@ -1284,6 +1068,14 @@ def split_pkg_licenses(licvalues, packages, outlines, fallback_licenses=None, pn
        outlicenses[pkgname] = licenses
    return outlicenses
+def generate_common_licenses_chksums(common_licenses, d):
+    lic_files_chksums = []
+    for license in tidy_licenses(common_licenses):
+        licfile = '${COMMON_LICENSE_DIR}/' + license
+        md5value = bb.utils.md5_file(d.expand(licfile))
+        lic_files_chksums.append('file://%s;md5=%s' % (licfile, md5value))
+    return lic_files_chksums
 def read_pkgconfig_provides(d):
    pkgdatadir = d.getVar('PKGDATA_DIR')
    pkgmap = {}
@@ -1418,4 +1210,3 @@ def register_commands(subparsers):
    parser_create.add_argument('--devtool', action="store_true", help=argparse.SUPPRESS)
    parser_create.add_argument('--mirrors', action="store_true", help='Enable PREMIRRORS and MIRRORS for source tree fetching (disabled by default).')
    parser_create.set_defaults(func=create_recipe)
diff --git a/scripts/lib/recipetool/create_go.py b/scripts/lib/recipetool/create_go.py
index a85a2f2786..1b2e5a03d5 100644
--- a/scripts/lib/recipetool/create_go.py
+++ b/scripts/lib/recipetool/create_go.py
@@ -10,13 +10,7 @@
 #
-from collections import namedtuple
-from enum import Enum
-from html.parser import HTMLParser
 from recipetool.create import RecipeHandler, handle_license_vars
-from recipetool.create import guess_license, tidy_licenses, fixup_license
-from recipetool.create import determine_from_url
-from urllib.error import URLError, HTTPError
 import bb.utils
 import json
@@ -25,27 +19,13 @@ import os
 import re
 import subprocess
 import sys
-import shutil
 import tempfile
-import urllib.parse
-import urllib.request
-GoImport = namedtuple('GoImport', 'root vcs url suffix')
 logger = logging.getLogger('recipetool')
-CodeRepo = namedtuple(
-    'CodeRepo', 'path codeRoot codeDir pathMajor pathPrefix pseudoMajor')
 tinfoil = None
-# Regular expression to parse pseudo semantic version
-# see https://go.dev/ref/mod#pseudo-versions
-re_pseudo_semver = re.compile(
-    r"^v[0-9]+\.(0\.0-|\d+\.\d+-([^+]*\.)?0\.)(?P<utc>\d{14})-(?P<commithash>[A-Za-z0-9]+)(\+[0-9A-Za-z-]+(\.[0-9A-Za-z-]+)*)?$")
-# Regular expression to parse semantic version
-re_semver = re.compile(
-    r"^v(?P<major>0|[1-9]\d*)\.(?P<minor>0|[1-9]\d*)\.(?P<patch>0|[1-9]\d*)(?:-(?P<prerelease>(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?(?:\+(?P<buildmetadata>[0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$")
 def tinfoil_init(instance):
    global tinfoil
@@ -83,578 +63,6 @@ class GoRecipeHandler(RecipeHandler):
        return bindir
-    def __resolve_repository_static(self, modulepath):
-        """Resolve the repository in a static manner
-            The method is based on the go implementation of
-            `repoRootFromVCSPaths` in
-            https://github.com/golang/go/blob/master/src/cmd/go/internal/vcs/vcs.go
-        """
-        url = urllib.parse.urlparse("https://" + modulepath)
-        req = urllib.request.Request(url.geturl())
-        try:
-            resp = urllib.request.urlopen(req)
-            # Some modulepath are just redirects to github (or some other vcs
-            # hoster). Therefore, we check if this modulepath redirects to
-            # somewhere else
-            if resp.geturl() != url.geturl():
-                bb.debug(1, "%s is redirectred to %s" %
-                         (url.geturl(), resp.geturl()))
-                url = urllib.parse.urlparse(resp.geturl())
-                modulepath = url.netloc + url.path
-        except URLError as url_err:
-            # This is probably because the module path
-            # contains the subdir and major path. Thus,
-            # we ignore this error for now
-            logger.debug(
-                1, "Failed to fetch page from [%s]: %s" % (url, str(url_err)))
-        host, _, _ = modulepath.partition('/')
-        class vcs(Enum):
-            pathprefix = "pathprefix"
-            regexp = "regexp"
-            type = "type"
-            repo = "repo"
-            check = "check"
-            schemelessRepo = "schemelessRepo"
-        # GitHub
-        vcsGitHub = {}
-        vcsGitHub[vcs.pathprefix] = "github.com"
-        vcsGitHub[vcs.regexp] = re.compile(
-            r'^(?P<root>github\.com/[A-Za-z0-9_.\-]+/[A-Za-z0-9_.\-]+)(/(?P<suffix>[A-Za-z0-9_.\-]+))*$')
-        vcsGitHub[vcs.type] = "git"
-        vcsGitHub[vcs.repo] = "https://\\g<root>"
-        # Bitbucket
-        vcsBitbucket = {}
-        vcsBitbucket[vcs.pathprefix] = "bitbucket.org"
-        vcsBitbucket[vcs.regexp] = re.compile(
-            r'^(?P<root>bitbucket\.org/(?P<bitname>[A-Za-z0-9_.\-]+/[A-Za-z0-9_.\-]+))(/(?P<suffix>[A-Za-z0-9_.\-]+))*$')
-        vcsBitbucket[vcs.type] = "git"
-        vcsBitbucket[vcs.repo] = "https://\\g<root>"
-        # IBM DevOps Services (JazzHub)
-        vcsIBMDevOps = {}
-        vcsIBMDevOps[vcs.pathprefix] = "hub.jazz.net/git"
-        vcsIBMDevOps[vcs.regexp] = re.compile(
-            r'^(?P<root>hub\.jazz\.net/git/[a-z0-9]+/[A-Za-z0-9_.\-]+)(/(?P<suffix>[A-Za-z0-9_.\-]+))*$')
-        vcsIBMDevOps[vcs.type] = "git"
-        vcsIBMDevOps[vcs.repo] = "https://\\g<root>"
-        # Git at Apache
-        vcsApacheGit = {}
-        vcsApacheGit[vcs.pathprefix] = "git.apache.org"
-        vcsApacheGit[vcs.regexp] = re.compile(
-            r'^(?P<root>git\.apache\.org/[a-z0-9_.\-]+\.git)(/(?P<suffix>[A-Za-z0-9_.\-]+))*$')
-        vcsApacheGit[vcs.type] = "git"
-        vcsApacheGit[vcs.repo] = "https://\\g<root>"
-        # Git at OpenStack
-        vcsOpenStackGit = {}
-        vcsOpenStackGit[vcs.pathprefix] = "git.openstack.org"
-        vcsOpenStackGit[vcs.regexp] = re.compile(
-            r'^(?P<root>git\.openstack\.org/[A-Za-z0-9_.\-]+/[A-Za-z0-9_.\-]+)(\.git)?(/(?P<suffix>[A-Za-z0-9_.\-]+))*$')
-        vcsOpenStackGit[vcs.type] = "git"
-        vcsOpenStackGit[vcs.repo] = "https://\\g<root>"
-        # chiselapp.com for fossil
-        vcsChiselapp = {}
-        vcsChiselapp[vcs.pathprefix] = "chiselapp.com"
-        vcsChiselapp[vcs.regexp] = re.compile(
-            r'^(?P<root>chiselapp\.com/user/[A-Za-z0-9]+/repository/[A-Za-z0-9_.\-]+)$')
-        vcsChiselapp[vcs.type] = "fossil"
-        vcsChiselapp[vcs.repo] = "https://\\g<root>"
-        # General syntax for any server.
-        # Must be last.
-        vcsGeneralServer = {}
-        vcsGeneralServer[vcs.regexp] = re.compile(
-            "(?P<root>(?P<repo>([a-z0-9.\\-]+\\.)+[a-z0-9.\\-]+(:[0-9]+)?(/~?[A-Za-z0-9_.\\-]+)+?)\\.(?P<vcs>bzr|fossil|git|hg|svn))(/~?(?P<suffix>[A-Za-z0-9_.\\-]+))*$")
-        vcsGeneralServer[vcs.schemelessRepo] = True
-        vcsPaths = [vcsGitHub, vcsBitbucket, vcsIBMDevOps,
-                    vcsApacheGit, vcsOpenStackGit, vcsChiselapp,
-                    vcsGeneralServer]
-        if modulepath.startswith("example.net") or modulepath == "rsc.io":
-            logger.warning("Suspicious module path %s" % modulepath)
-            return None
-        if modulepath.startswith("http:") or modulepath.startswith("https:"):
-            logger.warning("Import path should not start with %s %s" %
-                           ("http", "https"))
-            return None
-        rootpath = None
-        vcstype = None
-        repourl = None
-        suffix = None
-        for srv in vcsPaths:
-            m = srv[vcs.regexp].match(modulepath)
-            if vcs.pathprefix in srv:
-                if host == srv[vcs.pathprefix]:
-                    rootpath = m.group('root')
-                    vcstype = srv[vcs.type]
-                    repourl = m.expand(srv[vcs.repo])
-                    suffix = m.group('suffix')
-                    break
-            elif m and srv[vcs.schemelessRepo]:
-                rootpath = m.group('root')
-                vcstype = m[vcs.type]
-                repourl = m[vcs.repo]
-                suffix = m.group('suffix')
-                break
-        return GoImport(rootpath, vcstype, repourl, suffix)
-    def __resolve_repository_dynamic(self, modulepath):
-        """Resolve the repository root in a dynamic manner.
-            The method is based on the go implementation of
-            `repoRootForImportDynamic` in
-            https://github.com/golang/go/blob/master/src/cmd/go/internal/vcs/vcs.go
-        """
-        url = urllib.parse.urlparse("https://" + modulepath)
-        class GoImportHTMLParser(HTMLParser):
-            def __init__(self):
-                super().__init__()
-                self.__srv = {}
-            def handle_starttag(self, tag, attrs):
-                if tag == 'meta' and list(
-                        filter(lambda a: (a[0] == 'name' and a[1] == 'go-import'), attrs)):
-                    content = list(
-                        filter(lambda a: (a[0] == 'content'), attrs))
-                    if content:
-                        srv = content[0][1].split()
-                        self.__srv[srv[0]] = srv
-            def go_import(self, modulepath):
-                if modulepath in self.__srv:
-                    srv = self.__srv[modulepath]
-                    return GoImport(srv[0], srv[1], srv[2], None)
-                return None
-        url = url.geturl() + "?go-get=1"
-        req = urllib.request.Request(url)
-        try:
-            body = urllib.request.urlopen(req).read()
-        except HTTPError as http_err:
-            logger.warning(
-                "Unclean status when fetching page from [%s]: %s", url, str(http_err))
-            body = http_err.fp.read()
-        except URLError as url_err:
-            logger.warning(
-                "Failed to fetch page from [%s]: %s", url, str(url_err))
-            return None
-        parser = GoImportHTMLParser()
-        parser.feed(body.decode('utf-8'))
-        parser.close()
-        return parser.go_import(modulepath)
-    def __resolve_from_golang_proxy(self, modulepath, version):
-        """
-        Resolves repository data from golang proxy
-        """
-        url = urllib.parse.urlparse("https://proxy.golang.org/"
-                                    + modulepath
-                                    + "/@v/"
-                                    + version
-                                    + ".info")
-        # Transform url to lower case, golang proxy doesn't like mixed case
-        req = urllib.request.Request(url.geturl().lower())
-        try:
-            resp = urllib.request.urlopen(req)
-        except URLError as url_err:
-            logger.warning(
-                "Failed to fetch page from [%s]: %s", url, str(url_err))
-            return None
-        golang_proxy_res = resp.read().decode('utf-8')
-        modinfo = json.loads(golang_proxy_res)
-        if modinfo and 'Origin' in modinfo:
-            origin = modinfo['Origin']
-            _root_url = urllib.parse.urlparse(origin['URL'])
-            # We normalize the repo URL since we don't want the scheme in it
-            _subdir = origin['Subdir'] if 'Subdir' in origin else None
-            _root, _, _ = self.__split_path_version(modulepath)
-            if _subdir:
-                _root = _root[:-len(_subdir)].strip('/')
-            _commit = origin['Hash']
-            _vcs = origin['VCS']
-            return (GoImport(_root, _vcs, _root_url.geturl(), None), _commit)
-        return None
-    def __resolve_repository(self, modulepath):
-        """
-        Resolves src uri from go module-path
-        """
-        repodata = self.__resolve_repository_static(modulepath)
-        if not repodata or not repodata.url:
-            repodata = self.__resolve_repository_dynamic(modulepath)
-            if not repodata or not repodata.url:
-                logger.error(
-                    "Could not resolve repository for module path '%s'" % modulepath)
-                # There is no way to recover from this
-                sys.exit(14)
-        if repodata:
-            logger.debug(1, "Resolved download path for import '%s' => %s" % (
-                modulepath, repodata.url))
-        return repodata
-    def __split_path_version(self, path):
-        i = len(path)
-        dot = False
-        for j in range(i, 0, -1):
-            if path[j - 1] < '0' or path[j - 1] > '9':
-                break
-            if path[j - 1] == '.':
-                dot = True
-                break
-            i = j - 1
-        if i <= 1 or i == len(
-                path) or path[i - 1] != 'v' or path[i - 2] != '/':
-            return path, "", True
-        prefix, pathMajor = path[:i - 2], path[i - 2:]
-        if dot or len(
-                pathMajor) <= 2 or pathMajor[2] == '0' or pathMajor == "/v1":
-            return path, "", False
-        return prefix, pathMajor, True
-    def __get_path_major(self, pathMajor):
-        if not pathMajor:
-            return ""
-        if pathMajor[0] != '/' and pathMajor[0] != '.':
-            logger.error(
-                "pathMajor suffix %s passed to PathMajorPrefix lacks separator", pathMajor)
-        if pathMajor.startswith(".v") and pathMajor.endswith("-unstable"):
-            pathMajor = pathMajor[:len("-unstable") - 2]
-        return pathMajor[1:]
-    def __build_coderepo(self, repo, path):
-        codedir = ""
-        pathprefix, pathMajor, _ = self.__split_path_version(path)
-        if repo.root == path:
-            pathprefix = path
-        elif path.startswith(repo.root):
-            codedir = pathprefix[len(repo.root):].strip('/')
-        pseudoMajor = self.__get_path_major(pathMajor)
-        logger.debug("root='%s', codedir='%s', prefix='%s', pathMajor='%s', pseudoMajor='%s'",
-                     repo.root, codedir, pathprefix, pathMajor, pseudoMajor)
-        return CodeRepo(path, repo.root, codedir,
-                        pathMajor, pathprefix, pseudoMajor)
-    def __resolve_version(self, repo, path, version):
-        hash = None
-        coderoot = self.__build_coderepo(repo, path)
-        def vcs_fetch_all():
-            tmpdir = tempfile.mkdtemp()
-            clone_cmd = "%s clone --bare %s %s" % ('git', repo.url, tmpdir)
-            bb.process.run(clone_cmd)
-            log_cmd = "git log --all --pretty='%H %d' --decorate=short"
-            output, _ = bb.process.run(
-                log_cmd, shell=True, stderr=subprocess.PIPE, cwd=tmpdir)
-            bb.utils.prunedir(tmpdir)
-            return output.strip().split('\n')
-        def vcs_fetch_remote(tag):
-            # add * to grab ^{}
-            refs = {}
-            ls_remote_cmd = "git ls-remote -q --tags {} {}*".format(
-                repo.url, tag)
-            output, _ = bb.process.run(ls_remote_cmd)
-            output = output.strip().split('\n')
-            for line in output:
-                f = line.split(maxsplit=1)
-                if len(f) != 2:
-                    continue
-                for prefix in ["HEAD", "refs/heads/", "refs/tags/"]:
-                    if f[1].startswith(prefix):
-                        refs[f[1][len(prefix):]] = f[0]
-            for key, hash in refs.items():
-                if key.endswith(r"^{}"):
-                    refs[key.strip(r"^{}")] = hash
-            return refs[tag]
-        m_pseudo_semver = re_pseudo_semver.match(version)
-        if m_pseudo_semver:
-            remote_refs = vcs_fetch_all()
-            short_commit = m_pseudo_semver.group('commithash')
-            for l in remote_refs:
-                r = l.split(maxsplit=1)
-                sha1 = r[0] if len(r) else None
-                if not sha1:
-                    logger.error(
-                        "Ups: could not resolve abbref commit for %s" % short_commit)
-                elif sha1.startswith(short_commit):
-                    hash = sha1
-                    break
-        else:
-            m_semver = re_semver.match(version)
-            if m_semver:
-                def get_sha1_remote(re):
-                    rsha1 = None
-                    for line in remote_refs:
-                        # Split lines of the following format:
-                        # 22e90d9b964610628c10f673ca5f85b8c2a2ca9a  (tag: sometag)
-                        lineparts = line.split(maxsplit=1)
-                        sha1 = lineparts[0] if len(lineparts) else None
-                        refstring = lineparts[1] if len(
-                            lineparts) == 2 else None
-                        if refstring:
-                            # Normalize tag string and split in case of multiple
-                            # regs e.g. (tag: speech/v1.10.0, tag: orchestration/v1.5.0 ...)
-                            refs = refstring.strip('(), ').split(',')
-                            for ref in refs:
-                                if re.match(ref.strip()):
-                                    rsha1 = sha1
-                    return rsha1
-                semver = "v" + m_semver.group('major') + "."\
-                             + m_semver.group('minor') + "."\
-                             + m_semver.group('patch') \
-                             + (("-" + m_semver.group('prerelease'))
-                                if m_semver.group('prerelease') else "")
-                tag = os.path.join(
-                    coderoot.codeDir, semver) if coderoot.codeDir else semver
-                # probe tag using 'ls-remote', which is faster than fetching
-                # complete history
-                hash = vcs_fetch_remote(tag)
-                if not hash:
-                    # backup: fetch complete history
-                    remote_refs = vcs_fetch_all()
-                    hash = get_sha1_remote(
-                        re.compile(fr"(tag:|HEAD ->) ({tag})"))
-                logger.debug(
-                    "Resolving commit for tag '%s' -> '%s'", tag, hash)
-        return hash
-    def __generate_srcuri_inline_fcn(self, path, version, replaces=None):
-        """Generate SRC_URI functions for go imports"""
-        logger.info("Resolving repository for module %s", path)
-        # First try to resolve repo and commit from golang proxy
-        # Most info is already there and we don't have to go through the
-        # repository or even perform the version resolve magic
-        golang_proxy_info = self.__resolve_from_golang_proxy(path, version)
-        if golang_proxy_info:
-            repo = golang_proxy_info[0]
-            commit = golang_proxy_info[1]
-        else:
-            # Fallback
-            # Resolve repository by 'hand'
-            repo = self.__resolve_repository(path)
-            commit = self.__resolve_version(repo, path, version)
-        url = urllib.parse.urlparse(repo.url)
-        repo_url = url.netloc + url.path
-        coderoot = self.__build_coderepo(repo, path)
-        inline_fcn = "${@go_src_uri("
-        inline_fcn += f"'{repo_url}','{version}'"
-        if repo_url != path:
-            inline_fcn += f",path='{path}'"
-        if coderoot.codeDir:
-            inline_fcn += f",subdir='{coderoot.codeDir}'"
-        if repo.vcs != 'git':
-            inline_fcn += f",vcs='{repo.vcs}'"
-        if replaces:
-            inline_fcn += f",replaces='{replaces}'"
-        if coderoot.pathMajor:
-            inline_fcn += f",pathmajor='{coderoot.pathMajor}'"
-        inline_fcn += ")}"
-        return inline_fcn, commit
-    def __go_handle_dependencies(self, go_mod, srctree, localfilesdir, extravalues, d):
-        import re
-        src_uris = []
-        src_revs = []
-        def generate_src_rev(path, version, commithash):
-            src_rev = f"# {path}@{version} => {commithash}\n"
-            # Ups...maybe someone manipulated the source repository and the
-            # version or commit could not be resolved. This is a sign of
-            # a) the supply chain was manipulated (bad)
-            # b) the implementation for the version resolving didn't work
-            #    anymore (less bad)
-            if not commithash:
-                src_rev += f"#!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n"
-                src_rev += f"#!!!   Could not resolve version  !!!\n"
-                src_rev += f"#!!! Possible supply chain attack !!!\n"
-                src_rev += f"#!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n"
-            src_rev += f"SRCREV_{path.replace('/', '.')} = \"{commithash}\""
-            return src_rev
-        # we first go over replacement list, because we are essentialy
-        # interested only in the replaced path
-        if go_mod['Replace']:
-            for replacement in go_mod['Replace']:
-                oldpath = replacement['Old']['Path']
-                path = replacement['New']['Path']
-                version = ''
-                if 'Version' in replacement['New']:
-                    version = replacement['New']['Version']
-                if os.path.exists(os.path.join(srctree, path)):
-                    # the module refers to the local path, remove it from requirement list
-                    # because it's a local module
-                    go_mod['Require'][:] = [v for v in go_mod['Require'] if v.get('Path') != oldpath]
-                else:
-                    # Replace the path and the version, so we don't iterate replacement list anymore
-                    for require in go_mod['Require']:
-                        if require['Path'] == oldpath:
-                            require.update({'Path': path, 'Version': version})
-                            break
-        for require in go_mod['Require']:
-            path = require['Path']
-            version = require['Version']
-            inline_fcn, commithash = self.__generate_srcuri_inline_fcn(
-                path, version)
-            src_uris.append(inline_fcn)
-            src_revs.append(generate_src_rev(path, version, commithash))
-        # strip version part from module URL /vXX
-        baseurl = re.sub(r'/v(\d+)$', '', go_mod['Module']['Path'])
-        pn, _ = determine_from_url(baseurl)
-        go_mods_basename = "%s-modules.inc" % pn
-        go_mods_filename = os.path.join(localfilesdir, go_mods_basename)
-        with open(go_mods_filename, "w") as f:
-            # We introduce this indirection to make the tests a little easier
-            f.write("SRC_URI += \"${GO_DEPENDENCIES_SRC_URI}\"\n")
-            f.write("GO_DEPENDENCIES_SRC_URI = \"\\\n")
-            for uri in src_uris:
-                f.write("    " + uri + " \\\n")
-            f.write("\"\n\n")
-            for rev in src_revs:
-                f.write(rev + "\n")
-        extravalues['extrafiles'][go_mods_basename] = go_mods_filename
-    def __go_run_cmd(self, cmd, cwd, d):
-        return bb.process.run(cmd, env=dict(os.environ, PATH=d.getVar('PATH')),
-                              shell=True, cwd=cwd)
-    def __go_native_version(self, d):
-        stdout, _ = self.__go_run_cmd("go version", None, d)
-        m = re.match(r".*\sgo((\d+).(\d+).(\d+))\s([\w\/]*)", stdout)
-        major = int(m.group(2))
-        minor = int(m.group(3))
-        patch = int(m.group(4))
-        return major, minor, patch
-    def __go_mod_patch(self, srctree, localfilesdir, extravalues, d):
-        patchfilename = "go.mod.patch"
-        go_native_version_major, go_native_version_minor, _ = self.__go_native_version(
-            d)
-        self.__go_run_cmd("go mod tidy -go=%d.%d" %
-                          (go_native_version_major, go_native_version_minor), srctree, d)
-        stdout, _ = self.__go_run_cmd("go mod edit -json", srctree, d)
-        # Create patch in order to upgrade go version
-        self.__go_run_cmd("git diff go.mod > %s" % (patchfilename), srctree, d)
-        # Restore original state
-        self.__go_run_cmd("git checkout HEAD go.mod go.sum", srctree, d)
-        go_mod = json.loads(stdout)
-        tmpfile = os.path.join(localfilesdir, patchfilename)
-        shutil.move(os.path.join(srctree, patchfilename), tmpfile)
-        extravalues['extrafiles'][patchfilename] = tmpfile
-        return go_mod, patchfilename
-    def __go_mod_vendor(self, go_mod, srctree, localfilesdir, extravalues, d):
-        # Perform vendoring to retrieve the correct modules.txt
-        tmp_vendor_dir = tempfile.mkdtemp()
-        # -v causes to go to print modules.txt to stderr
-        _, stderr = self.__go_run_cmd(
-            "go mod vendor -v -o %s" % (tmp_vendor_dir), srctree, d)
-        modules_txt_basename = "modules.txt"
-        modules_txt_filename = os.path.join(localfilesdir, modules_txt_basename)
-        with open(modules_txt_filename, "w") as f:
-            f.write(stderr)
-        extravalues['extrafiles'][modules_txt_basename] = modules_txt_filename
-        licenses = []
-        lic_files_chksum = []
-        licvalues = guess_license(tmp_vendor_dir, d)
-        shutil.rmtree(tmp_vendor_dir)
-        if licvalues:
-            for licvalue in licvalues:
-                license = licvalue[0]
-                lics = tidy_licenses(fixup_license(license))
-                lics = [lic for lic in lics if lic not in licenses]
-                if len(lics):
-                    licenses.extend(lics)
-                lic_files_chksum.append(
-                    'file://src/${GO_IMPORT}/vendor/%s;md5=%s' % (licvalue[1], licvalue[2]))
-        # strip version part from module URL /vXX
-        baseurl = re.sub(r'/v(\d+)$', '', go_mod['Module']['Path'])
-        pn, _ = determine_from_url(baseurl)
-        licenses_basename = "%s-licenses.inc" % pn
-        licenses_filename = os.path.join(localfilesdir, licenses_basename)
-        with open(licenses_filename, "w") as f:
-            f.write("GO_MOD_LICENSES = \"%s\"\n\n" %
-                    ' & '.join(sorted(licenses, key=str.casefold)))
-            # We introduce this indirection to make the tests a little easier
-            f.write("LIC_FILES_CHKSUM  += \"${VENDORED_LIC_FILES_CHKSUM}\"\n")
-            f.write("VENDORED_LIC_FILES_CHKSUM = \"\\\n")
-            for lic in lic_files_chksum:
-                f.write("    " + lic + " \\\n")
-            f.write("\"\n")
-        extravalues['extrafiles'][licenses_basename] = licenses_filename
    def process(self, srctree, classes, lines_before,
                lines_after, handled, extravalues):
@@ -665,63 +73,51 @@ class GoRecipeHandler(RecipeHandler):
        if not files:
            return False
-        d = bb.data.createCopy(tinfoil.config_data)
        go_bindir = self.__ensure_go()
        if not go_bindir:
            sys.exit(14)
-        d.prependVar('PATH', '%s:' % go_bindir)
        handled.append('buildsystem')
-        classes.append("go-vendor")
+        classes.append("go-mod")
-        stdout, _ = self.__go_run_cmd("go mod edit -json", srctree, d)
+        # Use go-mod-update-modules to set the full SRC_URI and LICENSE
+        classes.append("go-mod-update-modules")
+        extravalues["run_tasks"] = "update_modules"
+        env = dict(os.environ)
+        env["PATH"] += f":{go_bindir}"
+        stdout = subprocess.check_output(("go", "mod", "edit", "-json"),
+                                         cwd=srctree, env=env, text=True)
        go_mod = json.loads(stdout)
-        go_import = go_mod['Module']['Path']
+        go_import = re.sub(r'/v([0-9]+)$', '', go_mod['Module']['Path'])
-        go_version_match = re.match("([0-9]+).([0-9]+)", go_mod['Go'])
-        go_version_major = int(go_version_match.group(1))
-        go_version_minor = int(go_version_match.group(2))
-        src_uris = []
        localfilesdir = tempfile.mkdtemp(prefix='recipetool-go-')
        extravalues.setdefault('extrafiles', {})
-        # Use an explicit name determined from the module name because it
+        # Write the stub ${BPN}-licenses.inc and ${BPN}-go-mods.inc files
-        # might differ from the actual URL for replaced modules
+        basename = "{pn}-licenses.inc"
-        # strip version part from module URL /vXX
+        filename = os.path.join(localfilesdir, basename)
-        baseurl = re.sub(r'/v(\d+)$', '', go_mod['Module']['Path'])
+        with open(filename, "w") as f:
-        pn, _ = determine_from_url(baseurl)
+            f.write("# FROM RECIPETOOL\n")
+        extravalues['extrafiles'][f"../{basename}"] = filename
-        # go.mod files with version < 1.17 may not include all indirect
-        # dependencies. Thus, we have to upgrade the go version.
-        if go_version_major == 1 and go_version_minor < 17:
-            logger.warning(
-                "go.mod files generated by Go < 1.17 might have incomplete indirect dependencies.")
-            go_mod, patchfilename = self.__go_mod_patch(srctree, localfilesdir,
-                                                        extravalues, d)
-            src_uris.append(
-                "file://%s;patchdir=src/${GO_IMPORT}" % (patchfilename))
-        # Check whether the module is vendored. If so, we have nothing to do.
-        # Otherwise we gather all dependencies and add them to the recipe
-        if not os.path.exists(os.path.join(srctree, "vendor")):
-            # Write additional $BPN-modules.inc file
-            self.__go_mod_vendor(go_mod, srctree, localfilesdir, extravalues, d)
-            lines_before.append("LICENSE += \" & ${GO_MOD_LICENSES}\"")
-            lines_before.append("require %s-licenses.inc" % (pn))
-            self.__rewrite_src_uri(lines_before, ["file://modules.txt"])
+        basename = "{pn}-go-mods.inc"
+        filename = os.path.join(localfilesdir, basename)
-            self.__go_handle_dependencies(go_mod, srctree, localfilesdir, extravalues, d)
+        with open(filename, "w") as f:
-            lines_before.append("require %s-modules.inc" % (pn))
+            f.write("# FROM RECIPETOOL\n")
+        extravalues['extrafiles'][f"../{basename}"] = filename
        # Do generic license handling
+        d = bb.data.createCopy(tinfoil.config_data)
        handle_license_vars(srctree, lines_before, handled, extravalues, d)
-        self.__rewrite_lic_uri(lines_before)
+        self.__rewrite_lic_vars(lines_before)
-        lines_before.append("GO_IMPORT = \"{}\"".format(baseurl))
+        self.__rewrite_src_uri(lines_before)
-        lines_before.append("SRCREV_FORMAT = \"${BPN}\"")
+        lines_before.append('require ${BPN}-licenses.inc')
+        lines_before.append('require ${BPN}-go-mods.inc')
+        lines_before.append(f'GO_IMPORT = "{go_import}"')
    def __update_lines_before(self, updated, newlines, lines_before):
        if updated:
@@ -733,9 +129,9 @@ class GoRecipeHandler(RecipeHandler):
                lines_before.append(line)
        return updated
-    def __rewrite_lic_uri(self, lines_before):
+    def __rewrite_lic_vars(self, lines_before):
        def varfunc(varname, origvalue, op, newlines):
+            import urllib.parse
            if varname == 'LIC_FILES_CHKSUM':
                new_licenses = []
                licenses = origvalue.split('\\')
@@ -760,12 +156,11 @@ class GoRecipeHandler(RecipeHandler):
            lines_before, ['LIC_FILES_CHKSUM'], varfunc)
        return self.__update_lines_before(updated, newlines, lines_before)
-    def __rewrite_src_uri(self, lines_before, additional_uris = []):
+    def __rewrite_src_uri(self, lines_before):
        def varfunc(varname, origvalue, op, newlines):
            if varname == 'SRC_URI':
-                src_uri = ["git://${GO_IMPORT};destsuffix=git/src/${GO_IMPORT};nobranch=1;name=${BPN};protocol=https"]
+                src_uri = ['git://${GO_IMPORT};protocol=https;nobranch=1;destsuffix=${GO_SRCURI_DESTSUFFIX}']
-                src_uri.extend(additional_uris)
                return src_uri, None, -1, True
            return origvalue, None, 0, True
diff --git a/scripts/lib/recipetool/create_npm.py b/scripts/lib/recipetool/create_npm.py
index 113a89f6a6..8c4cdd5234 100644
--- a/scripts/lib/recipetool/create_npm.py
+++ b/scripts/lib/recipetool/create_npm.py
@@ -15,9 +15,9 @@ import bb
 from bb.fetch2.npm import NpmEnvironment
 from bb.fetch2.npm import npm_package
 from bb.fetch2.npmsw import foreach_dependencies
+from oe.license_finder import match_licenses, find_license_files
 from recipetool.create import RecipeHandler
-from recipetool.create import get_license_md5sums
+from recipetool.create import generate_common_licenses_chksums
-from recipetool.create import guess_license
 from recipetool.create import split_pkg_licenses
 logger = logging.getLogger('recipetool')
@@ -112,40 +112,54 @@ class NpmRecipeHandler(RecipeHandler):
        """Return the extra license files and the list of packages"""
        licfiles = []
        packages = {}
+        # Licenses from package.json will point to COMMON_LICENSE_DIR so we need
+        # to associate them explicitely to packages for split_pkg_licenses()
+        fallback_licenses = dict()
+        def _find_package_licenses(destdir):
+            """Either find license files, or use package.json metadata"""
+            def _get_licenses_from_package_json(package_json):
+                with open(os.path.join(srctree, package_json), "r") as f:
+                    data = json.load(f)
+                    if "license" in data:
+                        licenses = data["license"].split(" ")
+                        licenses = [license.strip("()") for license in licenses if license != "OR" and license != "AND"]
+                        return [], licenses
+                    else:
+                        return [package_json], None
-        # Handle the parent package
-        packages["${PN}"] = ""
-        def _licfiles_append_fallback_readme_files(destdir):
-            """Append README files as fallback to license files if a license files is missing"""
-            fallback = True
-            readmes = []
            basedir = os.path.join(srctree, destdir)
-            for fn in os.listdir(basedir):
+            licfiles = find_license_files(basedir)
-                upper = fn.upper()
+            if len(licfiles) > 0:
-                if upper.startswith("README"):
+                return licfiles, None
-                    fullpath = os.path.join(basedir, fn)
+            else:
-                    readmes.append(fullpath)
+                # A license wasn't found in the package directory, so we'll use the package.json metadata
-                if upper.startswith("COPYING") or "LICENCE" in upper or "LICENSE" in upper:
+                pkg_json = os.path.join(basedir, "package.json")
-                    fallback = False
+                return _get_licenses_from_package_json(pkg_json)
-            if fallback:
-                for readme in readmes:
+        def _get_package_licenses(destdir, package):
-                    licfiles.append(os.path.relpath(readme, srctree))
+            (package_licfiles, package_licenses) = _find_package_licenses(destdir)
+            if package_licfiles:
+                licfiles.extend(package_licfiles)
+            else:
+                fallback_licenses[package] = package_licenses
        # Handle the dependencies
        def _handle_dependency(name, params, destdir):
            deptree = destdir.split('node_modules/')
            suffix = "-".join([npm_package(dep) for dep in deptree])
            packages["${PN}" + suffix] = destdir
-            _licfiles_append_fallback_readme_files(destdir)
+            _get_package_licenses(destdir, "${PN}" + suffix)
        with open(shrinkwrap_file, "r") as f:
            shrinkwrap = json.load(f)
        foreach_dependencies(shrinkwrap, _handle_dependency, dev)
-        return licfiles, packages
+        # Handle the parent package
+        packages["${PN}"] = ""
+        _get_package_licenses(srctree, "${PN}")
+        return licfiles, packages, fallback_licenses
    
    # Handle the peer dependencies   
    def _handle_peer_dependency(self, shrinkwrap_file):
@@ -266,36 +280,12 @@ class NpmRecipeHandler(RecipeHandler):
        fetcher.unpack(srctree)
        bb.note("Handling licences ...")
-        (licfiles, packages) = self._handle_licenses(srctree, shrinkwrap_file, dev)
+        (licfiles, packages, fallback_licenses) = self._handle_licenses(srctree, shrinkwrap_file, dev)
+        licvalues = match_licenses(licfiles, srctree, d)
-        def _guess_odd_license(licfiles):
+        split_pkg_licenses(licvalues, packages, lines_after, fallback_licenses)
-            import bb
+        fallback_licenses_flat = [license for sublist in fallback_licenses.values() for license in sublist]
+        extravalues["LIC_FILES_CHKSUM"] = generate_common_licenses_chksums(fallback_licenses_flat, d)
-            md5sums = get_license_md5sums(d, linenumbers=True)
+        extravalues["LICENSE"] = fallback_licenses_flat
-            chksums = []
-            licenses = []
-            for licfile in licfiles:
-                f = os.path.join(srctree, licfile)
-                md5value = bb.utils.md5_file(f)
-                (license, beginline, endline, md5) = md5sums.get(md5value,
-                    (None, "", "", ""))
-                if not license:
-                    license = "Unknown"
-                    logger.info("Please add the following line for '%s' to a "
-                        "'lib/recipetool/licenses.csv' and replace `Unknown`, "
-                        "`X`, `Y` and `MD5` with the license, begin line, "
-                        "end line and partial MD5 checksum:\n" \
-                        "%s,Unknown,X,Y,MD5" % (licfile, md5value))
-                chksums.append("file://%s%s%s;md5=%s" % (licfile,
-                    ";beginline=%s" % (beginline) if beginline else "",
-                    ";endline=%s" % (endline) if endline else "",
-                    md5 if md5 else md5value))
-                licenses.append((license, licfile, md5value))
-            return (licenses, chksums)
-        (licenses, extravalues["LIC_FILES_CHKSUM"]) = _guess_odd_license(licfiles)
-        split_pkg_licenses([*licenses, *guess_license(srctree, d)], packages, lines_after)
        classes.append("npm")
        handled.append("buildsystem")
diff --git a/scripts/lib/recipetool/licenses.csv b/scripts/lib/recipetool/licenses.csv
deleted file mode 100644
index 80851111b3..0000000000
--- a/scripts/lib/recipetool/licenses.csv
+++ /dev/null
@@ -1,37 +0,0 @@
-0636e73ff0215e8d672dc4c32c317bb3,GPL-2.0-only
-12f884d2ae1ff87c09e5b7ccc2c4ca7e,GPL-2.0-only
-18810669f13b87348459e611d31ab760,GPL-2.0-only
-252890d9eee26aab7b432e8b8a616475,LGPL-2.0-only
-2d5025d4aa3495befef8f17206a5b0a1,LGPL-2.1-only
-3214f080875748938ba060314b4f727d,LGPL-2.0-only
-385c55653886acac3821999a3ccd17b3,Artistic-1.0 | GPL-2.0-only
-393a5ca445f6965873eca0259a17f833,GPL-2.0-only
-3b83ef96387f14655fc854ddc3c6bd57,Apache-2.0
-3bf50002aefd002f49e7bb854063f7e7,LGPL-2.0-only
-4325afd396febcb659c36b49533135d4,GPL-2.0-only
-4fbd65380cdd255951079008b364516c,LGPL-2.1-only
-54c7042be62e169199200bc6477f04d1,BSD-3-Clause
-55ca817ccb7d5b5b66355690e9abc605,LGPL-2.0-only
-59530bdf33659b29e73d4adb9f9f6552,GPL-2.0-only
-5f30f0716dfdd0d91eb439ebec522ec2,LGPL-2.0-only
-6a6a8e020838b23406c81b19c1d46df6,LGPL-3.0-only
-751419260aa954499f7abaabaa882bbe,GPL-2.0-only
-7fbc338309ac38fefcd64b04bb903e34,LGPL-2.1-only
-8ca43cbc842c2336e835926c2166c28b,GPL-2.0-only
-94d55d512a9ba36caa9b7df079bae19f,GPL-2.0-only
-9ac2e7cff1ddaf48b6eab6028f23ef88,GPL-2.0-only
-9f604d8a4f8e74f4f5140845a21b6674,LGPL-2.0-only
-a6f89e2100d9b6cdffcea4f398e37343,LGPL-2.1-only
-b234ee4d69f5fce4486a80fdaf4a4263,GPL-2.0-only
-bbb461211a33b134d42ed5ee802b37ff,LGPL-2.1-only
-bfe1f75d606912a4111c90743d6c7325,MPL-1.1-only
-c93c0550bd3173f4504b2cbd8991e50b,GPL-2.0-only
-d32239bcb673463ab874e80d47fae504,GPL-3.0-only
-d7810fab7487fb0aad327b76f1be7cd7,GPL-2.0-only
-d8045f3b8f929c1cb29a1e3fd737b499,LGPL-2.1-only
-db979804f025cf55aabec7129cb671ed,LGPL-2.0-only
-eb723b61539feef013de476e68b5c50a,GPL-2.0-only
-ebb5c50ab7cab4baeffba14977030c07,GPL-2.0-only
-f27defe1e96c2e1ecd4e0c9be8967949,GPL-3.0-only
-fad9b3332be894bab9bc501572864b29,LGPL-2.1-only
-fbc093901857fcd118f065f900982c24,LGPL-2.1-only
diff --git a/scripts/lib/resulttool/junit.py b/scripts/lib/resulttool/junit.py
new file mode 100644
index 0000000000..c7a53dc550
--- /dev/null
+++ b/scripts/lib/resulttool/junit.py
@@ -0,0 +1,77 @@
+# resulttool - report test results in JUnit XML format
+#
+# Copyright (c) 2024, Siemens AG.
+#
+# SPDX-License-Identifier: GPL-2.0-only
+#
+import os
+import re
+import xml.etree.ElementTree as ET
+import resulttool.resultutils as resultutils
+def junit(args, logger):
+    testresults = resultutils.load_resultsdata(args.json_file, configmap=resultutils.store_map)
+    total_time = 0
+    skipped = 0
+    failures = 0
+    errors = 0
+    for tests in testresults.values():
+        results = tests[next(reversed(tests))].get("result", {})
+    for result_id, result in results.items():
+        # filter out ptestresult.rawlogs and ptestresult.sections
+        if re.search(r'\.test_', result_id):
+            total_time += result.get("duration", 0)
+            if result['status'] == "FAILED":
+                failures += 1
+            elif result['status'] == "ERROR":
+                errors += 1
+            elif result['status'] == "SKIPPED":
+                skipped += 1
+    testsuites_node = ET.Element("testsuites")
+    testsuites_node.set("time", "%s" % total_time)
+    testsuite_node = ET.SubElement(testsuites_node, "testsuite")
+    testsuite_node.set("name", "Testimage")
+    testsuite_node.set("time", "%s" % total_time)
+    testsuite_node.set("tests", "%s" % len(results))
+    testsuite_node.set("failures", "%s" % failures)
+    testsuite_node.set("errors", "%s" % errors)
+    testsuite_node.set("skipped", "%s" % skipped)
+    for result_id, result in results.items():
+        if re.search(r'\.test_', result_id):
+            testcase_node = ET.SubElement(testsuite_node, "testcase", {
+                "name": result_id,
+                "classname": "Testimage",
+                "time": str(result['duration'])
+            })
+            if result['status'] == "SKIPPED":
+                ET.SubElement(testcase_node, "skipped", message=result['log'])
+            elif result['status'] == "FAILED":
+                ET.SubElement(testcase_node, "failure", message=result['log'])
+            elif result['status'] == "ERROR":
+                ET.SubElement(testcase_node, "error", message=result['log'])
+    tree = ET.ElementTree(testsuites_node)
+    if args.junit_xml_path is None:
+        args.junit_xml_path = os.environ['BUILDDIR'] + '/tmp/log/oeqa/junit.xml'
+    tree.write(args.junit_xml_path, encoding='UTF-8', xml_declaration=True)
+    logger.info('Saved JUnit XML report as %s' % args.junit_xml_path)
+def register_commands(subparsers):
+    """Register subcommands from this plugin"""
+    parser_build = subparsers.add_parser('junit', help='create test report in JUnit XML format',
+                                         description='generate unit test report in JUnit XML format based on the latest test results in the testresults.json.',
+                                         group='analysis')
+    parser_build.set_defaults(func=junit)
+    parser_build.add_argument('json_file',
+                              help='json file should point to the testresults.json')
+    parser_build.add_argument('-j', '--junit_xml_path',
+                              help='junit xml path allows setting the path of the generated test report. The default location is <build_dir>/tmp/log/oeqa/junit.xml')
diff --git a/scripts/lib/resulttool/manualexecution.py b/scripts/lib/resulttool/manualexecution.py
index ecb27c5933..ae0861ac6b 100755
--- a/scripts/lib/resulttool/manualexecution.py
+++ b/scripts/lib/resulttool/manualexecution.py
@@ -22,7 +22,7 @@ def load_json_file(f):
 def write_json_file(f, json_data):
    os.makedirs(os.path.dirname(f), exist_ok=True)
    with open(f, 'w') as filedata:
-        filedata.write(json.dumps(json_data, sort_keys=True, indent=4))
+        filedata.write(json.dumps(json_data, sort_keys=True, indent=1))
 class ManualTestRunner(object):
diff --git a/scripts/lib/resulttool/regression.py b/scripts/lib/resulttool/regression.py
index 10e7d13841..33b3119c54 100644
--- a/scripts/lib/resulttool/regression.py
+++ b/scripts/lib/resulttool/regression.py
@@ -212,6 +212,8 @@ def compare_result(logger, base_name, target_name, base_result, target_result, d
    if base_result and target_result:
        for k in base_result:
+            if k in ['ptestresult.rawlogs', 'ptestresult.sections']:
+                continue
            base_testcase = base_result[k]
            base_status = base_testcase.get('status')
            if base_status:
@@ -422,6 +424,7 @@ def register_commands(subparsers):
                              help='(optional) filter the base results to this result ID')
    parser_build.add_argument('-t', '--target-result-id', default='',
                              help='(optional) filter the target results to this result ID')
+    parser_build.add_argument('-l', '--limit', default=REGRESSIONS_DISPLAY_LIMIT, help="Maximum number of changes to display per test. Can be set to 0 to print all changes")
    parser_build = subparsers.add_parser('regression-git', help='regression git analysis',
                                         description='regression analysis comparing base result set to target '
diff --git a/scripts/lib/resulttool/report.py b/scripts/lib/resulttool/report.py
index a349510ab8..1c100b00ab 100644
--- a/scripts/lib/resulttool/report.py
+++ b/scripts/lib/resulttool/report.py
@@ -256,7 +256,7 @@ class ResultsTextReport(object):
                if selected_test_case_only:
                    print_selected_testcase_result(raw_results, selected_test_case_only)
                else:
-                    print(json.dumps(raw_results, sort_keys=True, indent=4))
+                    print(json.dumps(raw_results, sort_keys=True, indent=1))
            else:
                print('Could not find raw test result for %s' % raw_test)
            return 0
diff --git a/scripts/lib/resulttool/resultutils.py b/scripts/lib/resulttool/resultutils.py
index c5521d81bd..b8fc79a6ac 100644
--- a/scripts/lib/resulttool/resultutils.py
+++ b/scripts/lib/resulttool/resultutils.py
@@ -14,8 +14,11 @@ import scriptpath
 import copy
 import urllib.request
 import posixpath
+import logging
 scriptpath.add_oe_lib_path()
+logger = logging.getLogger('resulttool')
 flatten_map = {
    "oeselftest": [],
    "runtime": [],
@@ -31,13 +34,19 @@ regression_map = {
    "manual": ['TEST_TYPE', 'TEST_MODULE', 'IMAGE_BASENAME', 'MACHINE']
 }
 store_map = {
-    "oeselftest": ['TEST_TYPE'],
+    "oeselftest": ['TEST_TYPE', 'TESTSERIES', 'MACHINE'],
    "runtime": ['TEST_TYPE', 'DISTRO', 'MACHINE', 'IMAGE_BASENAME'],
    "sdk": ['TEST_TYPE', 'MACHINE', 'SDKMACHINE', 'IMAGE_BASENAME'],
    "sdkext": ['TEST_TYPE', 'MACHINE', 'SDKMACHINE', 'IMAGE_BASENAME'],
    "manual": ['TEST_TYPE', 'TEST_MODULE', 'MACHINE', 'IMAGE_BASENAME']
 }
+rawlog_sections = {
+    "ptestresult.rawlogs": "ptest",
+    "ltpresult.rawlogs": "ltp",
+    "ltpposixresult.rawlogs": "ltpposix"
+}
 def is_url(p):
    """
    Helper for determining if the given path is a URL
@@ -108,21 +117,57 @@ def filter_resultsdata(results, resultid):
                 newresults[r][i] = results[r][i]
    return newresults
-def strip_ptestresults(results):
+def strip_logs(results):
    newresults = copy.deepcopy(results)
-    #for a in newresults2:
-    #  newresults = newresults2[a]
    for res in newresults:
        if 'result' not in newresults[res]:
            continue
-        if 'ptestresult.rawlogs' in newresults[res]['result']:
+        for logtype in rawlog_sections:
-            del newresults[res]['result']['ptestresult.rawlogs']
+            if logtype in newresults[res]['result']:
+                del newresults[res]['result'][logtype]
        if 'ptestresult.sections' in newresults[res]['result']:
            for i in newresults[res]['result']['ptestresult.sections']:
                if 'log' in newresults[res]['result']['ptestresult.sections'][i]:
                    del newresults[res]['result']['ptestresult.sections'][i]['log']
    return newresults
+# For timing numbers, crazy amounts of precision don't make sense and just confuse
+# the logs. For numbers over 1, trim to 3 decimal places, for numbers less than 1,
+# trim to 4 significant digits
+def trim_durations(results):
+    for res in results:
+        if 'result' not in results[res]:
+            continue
+        for entry in results[res]['result']:
+            if 'duration' in results[res]['result'][entry]:
+                duration = results[res]['result'][entry]['duration']
+                if duration > 1:
+                    results[res]['result'][entry]['duration'] = float("%.3f" % duration)
+                elif duration < 1:
+                    results[res]['result'][entry]['duration'] = float("%.4g" % duration)
+    return results
+def handle_cleanups(results):
+    # Remove pointless path duplication from old format reproducibility results
+    for res2 in results:
+        try:
+            section = results[res2]['result']['reproducible']['files']
+            for pkgtype in section:
+                for filelist in section[pkgtype].copy():
+                    if section[pkgtype][filelist] and type(section[pkgtype][filelist][0]) == dict:
+                        newlist = []
+                        for entry in section[pkgtype][filelist]:
+                            newlist.append(entry["reference"].split("/./")[1])
+                        section[pkgtype][filelist] = newlist
+        except KeyError:
+            pass
+    # Remove pointless duplicate rawlogs data
+    try:
+        del results[res2]['result']['reproducible.rawlogs']
+    except KeyError:
+        pass
 def decode_log(logdata):
    if isinstance(logdata, str):
        return logdata
@@ -155,9 +200,6 @@ def generic_get_rawlogs(sectname, results):
        return None
    return decode_log(results[sectname]['log'])
-def ptestresult_get_rawlogs(results):
-    return generic_get_rawlogs('ptestresult.rawlogs', results)
 def save_resultsdata(results, destdir, fn="testresults.json", ptestjson=False, ptestlogs=False):
    for res in results:
        if res:
@@ -167,16 +209,20 @@ def save_resultsdata(results, destdir, fn="testresults.json", ptestjson=False, p
        os.makedirs(os.path.dirname(dst), exist_ok=True)
        resultsout = results[res]
        if not ptestjson:
-            resultsout = strip_ptestresults(results[res])
+            resultsout = strip_logs(results[res])
+        trim_durations(resultsout)
+        handle_cleanups(resultsout)
        with open(dst, 'w') as f:
-            f.write(json.dumps(resultsout, sort_keys=True, indent=4))
+            f.write(json.dumps(resultsout, sort_keys=True, indent=1))
        for res2 in results[res]:
            if ptestlogs and 'result' in results[res][res2]:
                seriesresults = results[res][res2]['result']
-                rawlogs = ptestresult_get_rawlogs(seriesresults)
+                for logtype in rawlog_sections:
-                if rawlogs is not None:
+                    logdata = generic_get_rawlogs(logtype, seriesresults)
-                    with open(dst.replace(fn, "ptest-raw.log"), "w+") as f:
+                    if logdata is not None:
-                        f.write(rawlogs)
+                        logger.info("Extracting " + rawlog_sections[logtype] + "-raw.log")
+                        with open(dst.replace(fn, rawlog_sections[logtype] + "-raw.log"), "w+") as f:
+                            f.write(logdata)
                if 'ptestresult.sections' in seriesresults:
                    for i in seriesresults['ptestresult.sections']:
                        sectionlog = ptestresult_get_log(seriesresults, i)
diff --git a/scripts/lib/resulttool/store.py b/scripts/lib/resulttool/store.py
index e0951f0a8f..b143334e69 100644
--- a/scripts/lib/resulttool/store.py
+++ b/scripts/lib/resulttool/store.py
@@ -65,18 +65,35 @@ def store(args, logger):
        for r in revisions:
            results = revisions[r]
+            if args.revision and r[0] != args.revision:
+                logger.info('skipping %s as non-matching' % r[0])
+                continue
            keywords = {'commit': r[0], 'branch': r[1], "commit_count": r[2]}
-            subprocess.check_call(["find", tempdir, "!", "-path", "./.git/*", "-delete"])
+            subprocess.check_call(["find", tempdir, "-name", "testresults.json", "!", "-path", "./.git/*", "-delete"])
            resultutils.save_resultsdata(results, tempdir, ptestlogs=True)
            logger.info('Storing test result into git repository %s' % args.git_dir)
-            gitarchive.gitarchive(tempdir, args.git_dir, False, False,
+            excludes = []
+            if args.logfile_archive:
+                excludes = ['*.log', "*.log.zst"]
+            tagname = gitarchive.gitarchive(tempdir, args.git_dir, False, False,
                                  "Results of {branch}:{commit}", "branch: {branch}\ncommit: {commit}", "{branch}",
                                  False, "{branch}/{commit_count}-g{commit}/{tag_number}",
                                  'Test run #{tag_number} of {branch}:{commit}', '',
-                                  [], [], False, keywords, logger)
+                                  excludes, [], False, keywords, logger)
+            if args.logfile_archive:
+                logdir = args.logfile_archive + "/" + tagname
+                shutil.copytree(tempdir, logdir)
+                os.chmod(logdir, 0o755)
+                for root, dirs,  files in os.walk(logdir):
+                    for name in files:
+                        if not name.endswith(".log"):
+                            continue
+                        f = os.path.join(root, name)
+                        subprocess.run(["zstd", f, "--rm"], check=True, capture_output=True)
    finally:
        subprocess.check_call(["rm", "-rf",  tempdir])
@@ -102,3 +119,7 @@ def register_commands(subparsers):
                              help='add executed-by configuration to each result file')
    parser_build.add_argument('-t', '--extra-test-env', default='',
                              help='add extra test environment data to each result file configuration')
+    parser_build.add_argument('-r', '--revision', default='',
+                              help='only store data for the specified revision')
+    parser_build.add_argument('-l', '--logfile-archive', default='',
+                              help='directory to separately archive log files along with a copy of the results')
diff --git a/scripts/lib/scriptutils.py b/scripts/lib/scriptutils.py
index f23e53cba9..32e749dbb1 100644
--- a/scripts/lib/scriptutils.py
+++ b/scripts/lib/scriptutils.py
@@ -179,8 +179,13 @@ def fetch_url(tinfoil, srcuri, srcrev, destdir, logger, preserve_tmp=False, mirr
                f.write('SRCREV = "%s"\n' % srcrev)
                f.write('PV = "0.0+"\n')
                f.write('WORKDIR = "%s"\n' % tmpworkdir)
+                f.write('UNPACKDIR = "%s"\n' % destdir)
                # Set S out of the way so it doesn't get created under the workdir
-                f.write('S = "%s"\n' % os.path.join(tmpdir, 'emptysrc'))
+                s_dir = os.path.join(tmpdir, 'emptysrc')
+                bb.utils.mkdirhier(s_dir)
+                f.write('S = "%s"\n' % s_dir)
                if not mirrors:
                    # We do not need PREMIRRORS since we are almost certainly
                    # fetching new source rather than something that has already
@@ -232,10 +237,6 @@ def fetch_url(tinfoil, srcuri, srcrev, destdir, logger, preserve_tmp=False, mirr
                if e.errno != errno.ENOTEMPTY:
                    raise
-        bb.utils.mkdirhier(destdir)
-        for fn in os.listdir(tmpworkdir):
-            shutil.move(os.path.join(tmpworkdir, fn), destdir)
    finally:
        if not preserve_tmp:
            shutil.rmtree(tmpdir)
@@ -271,12 +272,3 @@ def is_src_url(param):
        return True
    return False
-def filter_src_subdirs(pth):
-    """
-    Filter out subdirectories of initial unpacked source trees that we do not care about.
-    Used by devtool and recipetool.
-    """
-    dirlist = os.listdir(pth)
-    filterout = ['git.indirectionsymlink', 'source-date-epoch', 'sstate-install-recipe_qa']
-    dirlist = [x for x in dirlist if x not in filterout]
-    return dirlist
diff --git a/scripts/lib/wic/canned-wks/common.wks.inc b/scripts/lib/wic/canned-wks/common.wks.inc
index 89880b417b..4a440ddafe 100644
--- a/scripts/lib/wic/canned-wks/common.wks.inc
+++ b/scripts/lib/wic/canned-wks/common.wks.inc
@@ -1,3 +1,3 @@
 # This file is included into 3 canned wks files from this directory
-part /boot --source bootimg-pcbios --ondisk sda --label boot --active --align 1024
+part /boot --source bootimg_pcbios --ondisk sda --label boot --active --align 1024
 part / --source rootfs --use-uuid --fstype=ext4 --label platform --align 1024
diff --git a/scripts/lib/wic/canned-wks/directdisk-gpt.wks b/scripts/lib/wic/canned-wks/directdisk-gpt.wks
index 8d7d8de6ea..cb640056f1 100644
--- a/scripts/lib/wic/canned-wks/directdisk-gpt.wks
+++ b/scripts/lib/wic/canned-wks/directdisk-gpt.wks
@@ -3,7 +3,7 @@
 # can directly dd to boot media.
-part /boot --source bootimg-pcbios --ondisk sda --label boot --active --align 1024
+part /boot --source bootimg_pcbios --ondisk sda --label boot --active --align 1024
 part / --source rootfs --ondisk sda --fstype=ext4 --label platform --align 1024 --use-uuid
 bootloader  --ptable gpt --timeout=0  --append="rootwait rootfstype=ext4 video=vesafb vga=0x318 console=tty0 console=ttyS0,115200n8"
diff --git a/scripts/lib/wic/canned-wks/directdisk-multi-rootfs.wks b/scripts/lib/wic/canned-wks/directdisk-multi-rootfs.wks
index f61d941d6d..4fd1999ffb 100644
--- a/scripts/lib/wic/canned-wks/directdisk-multi-rootfs.wks
+++ b/scripts/lib/wic/canned-wks/directdisk-multi-rootfs.wks
@@ -15,7 +15,7 @@
 #
 #   - or any combinations of -r and --rootfs command line options
-part /boot --source bootimg-pcbios --ondisk sda --label boot --active --align 1024
+part /boot --source bootimg_pcbios --ondisk sda --label boot --active --align 1024
 part / --source rootfs --rootfs-dir=rootfs1 --ondisk sda --fstype=ext4 --label platform --align 1024
 part /rescue --source rootfs --rootfs-dir=rootfs2 --ondisk sda --fstype=ext4 --label secondary --align 1024
diff --git a/scripts/lib/wic/canned-wks/efi-bootdisk.wks.in b/scripts/lib/wic/canned-wks/efi-bootdisk.wks.in
index 2fd286ff98..5211972955 100644
--- a/scripts/lib/wic/canned-wks/efi-bootdisk.wks.in
+++ b/scripts/lib/wic/canned-wks/efi-bootdisk.wks.in
@@ -1,3 +1,3 @@
 bootloader --ptable gpt
-part /boot --source rootfs --rootfs-dir=${IMAGE_ROOTFS}/boot --fstype=vfat --label boot --active --align 1024 --use-uuid --overhead-factor 1.1
+part /boot --source rootfs --rootfs-dir=${IMAGE_ROOTFS}/boot --fstype=vfat --label boot --active --align 1024 --use-uuid --overhead-factor 1.2
 part / --source rootfs --fstype=ext4 --label root --align 1024 --exclude-path boot/
diff --git a/scripts/lib/wic/canned-wks/efi-uki-bootdisk.wks.in b/scripts/lib/wic/canned-wks/efi-uki-bootdisk.wks.in
new file mode 100644
index 0000000000..cac0fa32cd
--- /dev/null
+++ b/scripts/lib/wic/canned-wks/efi-uki-bootdisk.wks.in
@@ -0,0 +1,3 @@
+bootloader --ptable gpt --timeout=5
+part /boot --source bootimg_efi --sourceparams="loader=${EFI_PROVIDER}" --label boot --active --align 1024 --use-uuid --part-name="ESP" --part-type=C12A7328-F81F-11D2-BA4B-00A0C93EC93B --overhead-factor=1
+part / --source rootfs --fstype=ext4 --label root --align 1024 --exclude-path boot/
diff --git a/scripts/lib/wic/canned-wks/mkefidisk.wks b/scripts/lib/wic/canned-wks/mkefidisk.wks
index 9f534fe184..16dfe76dfe 100644
--- a/scripts/lib/wic/canned-wks/mkefidisk.wks
+++ b/scripts/lib/wic/canned-wks/mkefidisk.wks
@@ -2,10 +2,10 @@
 # long-description: Creates a partitioned EFI disk image that the user
 # can directly dd to boot media.
-part /boot --source bootimg-efi --sourceparams="loader=grub-efi" --ondisk sda --label msdos --active --align 1024
+part /boot --source bootimg_efi --sourceparams="loader=grub-efi" --ondisk sda --label msdos --active --align 1024
 part / --source rootfs --ondisk sda --fstype=ext4 --label platform --align 1024 --use-uuid
 part swap --ondisk sda --size 44 --label swap1 --fstype=swap
-bootloader --ptable gpt --timeout=5 --append="rootfstype=ext4 console=ttyS0,115200 console=tty0"
+bootloader --ptable gpt --timeout=5 --append="rootfstype=ext4 console=${KERNEL_CONSOLE} console=tty0"
diff --git a/scripts/lib/wic/canned-wks/mkhybridiso.wks b/scripts/lib/wic/canned-wks/mkhybridiso.wks
index 48c5ac4791..c3a030e5b4 100644
--- a/scripts/lib/wic/canned-wks/mkhybridiso.wks
+++ b/scripts/lib/wic/canned-wks/mkhybridiso.wks
@@ -2,6 +2,6 @@
 # long-description: Creates an EFI and legacy bootable hybrid ISO image
 # which can be used on optical media as well as USB media.
-part /boot --source isoimage-isohybrid --sourceparams="loader=grub-efi,image_name=HYBRID_ISO_IMG" --ondisk cd --label HYBRIDISO
+part /boot --source isoimage_isohybrid --sourceparams="loader=grub-efi,image_name=HYBRID_ISO_IMG" --ondisk cd --label HYBRIDISO
 bootloader  --timeout=15  --append=""
diff --git a/scripts/lib/wic/canned-wks/sdimage-bootpart.wks b/scripts/lib/wic/canned-wks/sdimage-bootpart.wks
index 63bc4dab6a..f9f8044f7d 100644
--- a/scripts/lib/wic/canned-wks/sdimage-bootpart.wks
+++ b/scripts/lib/wic/canned-wks/sdimage-bootpart.wks
@@ -2,5 +2,5 @@
 # long-description: Creates a partitioned SD card image. Boot files
 # are located in the first vfat partition.
-part /boot --source bootimg-partition --ondisk mmcblk0 --fstype=vfat --label boot --active --align 4 --size 16
+part /boot --source bootimg_partition --ondisk mmcblk0 --fstype=vfat --label boot --active --align 4 --size 16
 part / --source rootfs --ondisk mmcblk0 --fstype=ext4 --label root --align 4
diff --git a/scripts/lib/wic/canned-wks/systemd-bootdisk.wks b/scripts/lib/wic/canned-wks/systemd-bootdisk.wks
index 95d7b97a60..3fb2c0e35f 100644
--- a/scripts/lib/wic/canned-wks/systemd-bootdisk.wks
+++ b/scripts/lib/wic/canned-wks/systemd-bootdisk.wks
@@ -2,7 +2,7 @@
 # long-description: Creates a partitioned EFI disk image that the user
 # can directly dd to boot media. The selected bootloader is systemd-boot.
-part /boot --source bootimg-efi --sourceparams="loader=systemd-boot" --ondisk sda --label msdos --active --align 1024 --use-uuid
+part /boot --source bootimg_efi --sourceparams="loader=systemd-boot" --ondisk sda --label msdos --active --align 1024 --use-uuid
 part / --source rootfs --ondisk sda --fstype=ext4 --label platform --align 1024 --use-uuid
diff --git a/scripts/lib/wic/engine.py b/scripts/lib/wic/engine.py
index 674ccfc244..b9e60cbe4e 100644
--- a/scripts/lib/wic/engine.py
+++ b/scripts/lib/wic/engine.py
@@ -180,6 +180,8 @@ def wic_create(wks_file, rootfs_dir, bootimg_dir, kernel_dir,
        os.makedirs(options.outdir)
    pname = options.imager
+    # Don't support '-' in plugin names
+    pname = pname.replace("-", "_")
    plugin_class = PluginMgr.get_plugins('imager').get(pname)
    if not plugin_class:
        raise WicError('Unknown plugin: %s' % pname)
@@ -232,6 +234,16 @@ class Disk:
        self._psector_size = None
        self._ptable_format = None
+        # define sector size
+        sector_size_str = get_bitbake_var('WIC_SECTOR_SIZE')
+        if sector_size_str is not None:
+            try:
+                self.sector_size = int(sector_size_str)
+            except ValueError:
+                self.sector_size = None
+        else:
+            self.sector_size = None
        # find parted
        # read paths from $PATH environment variable
        # if it fails, use hardcoded paths
@@ -258,7 +270,13 @@ class Disk:
    def get_partitions(self):
        if self._partitions is None:
            self._partitions = OrderedDict()
-            out = exec_cmd("%s -sm %s unit B print" % (self.parted, self.imagepath))
+            if self.sector_size is not None:
+                out = exec_cmd("export PARTED_SECTOR_SIZE=%d; %s -sm %s unit B print" % \
+                           (self.sector_size, self.parted, self.imagepath), True)
+            else:
+                out = exec_cmd("%s -sm %s unit B print" % (self.parted, self.imagepath))
            parttype = namedtuple("Part", "pnum start end size fstype")
            splitted = out.splitlines()
            # skip over possible errors in exec_cmd output
@@ -359,7 +377,7 @@ class Disk:
        Remove files/dirs and their contents from the partition.
        This only applies to ext* partition.
        """
-        abs_path = re.sub('\/\/+', '/', path)
+        abs_path = re.sub(r'\/\/+', '/', path)
        cmd = "{} {} -wR 'rm \"{}\"'".format(self.debugfs,
                                            self._get_part_image(pnum),
                                            abs_path)
diff --git a/scripts/lib/wic/help.py b/scripts/lib/wic/help.py
index 163535e431..6b49a67de9 100644
--- a/scripts/lib/wic/help.py
+++ b/scripts/lib/wic/help.py
@@ -544,18 +544,18 @@ DESCRIPTION
    the --source param given to that partition.  For example, if the
    partition is set up like this:
-      part /boot --source bootimg-pcbios   ...
+      part /boot --source bootimg_pcbios   ...
    then the methods defined as class members of the plugin having the
-    matching bootimg-pcbios .name class member would be used.
+    matching bootimg_pcbios .name class member would be used.
    To be more concrete, here's the plugin definition that would match
-    a '--source bootimg-pcbios' usage, along with an example method
+    a '--source bootimg_pcbios' usage, along with an example method
    that would be called by the wic implementation when it needed to
    invoke an implementation-specific partition-preparation function:
    class BootimgPcbiosPlugin(SourcePlugin):
-        name = 'bootimg-pcbios'
+        name = 'bootimg_pcbios'
    @classmethod
        def do_prepare_partition(self, part, ...)
@@ -794,7 +794,7 @@ DESCRIPTION
     Here is a content of test.wks:
-     part /boot --source bootimg-pcbios --ondisk sda --label boot --active --align 1024
+     part /boot --source bootimg_pcbios --ondisk sda --label boot --active --align 1024
     part / --source rootfs --ondisk sda --fstype=ext3 --label platform --align 1024
     bootloader  --timeout=0  --append="rootwait rootfstype=ext3 video=vesafb vga=0x318 console=tty0"
@@ -916,6 +916,10 @@ DESCRIPTION
                   will create empty partition. --size parameter has
                   to be used to specify size of empty partition.
+         --sourceparams: This option is specific to wic. Supply additional
+                         parameters to the source plugin in
+                         key1=value1,key2 format.
         --ondisk or --ondrive: Forces the partition to be created on
                                a particular disk.
@@ -932,6 +936,7 @@ DESCRIPTION
             squashfs
             erofs
             swap
+             none
         --fsoptions: Specifies a free-form string of options to be
                      used when mounting the filesystem. This string
@@ -965,6 +970,14 @@ DESCRIPTION
                              to start a partition on an x KBytes
                              boundary.
+         --offset: This option is specific to wic that says to place a partition
+                   at exactly the specified offset. If the partition cannot be
+                   placed at the specified offset, the image build will fail.
+                   Specify as an integer value optionally followed by one of the
+                   units s/S for 512 byte sector, k/K for kibibyte, M for
+                   mebibyte and G for gibibyte. The default unit if none is
+                   given is k.
         --no-table: This option is specific to wic. Space will be
                     reserved for the partition and it will be
                     populated but it will not be added to the
@@ -1000,12 +1013,20 @@ DESCRIPTION
         --no-fstab-update: This option is specific to wic. It does not update the
                            '/etc/fstab' stock file for the given partition.
-         --extra-space: This option is specific to wic. It adds extra
+         --extra-filesystem-space: This option is specific to wic. It adds extra
-                        space after the space filled by the content
+                                   space after the space filled by the content
-                        of the partition. The final size can go
+                                   of the partition. The final size can go
-                        beyond the size specified by --size.
+                                   beyond the size specified by --size.
-                        By default, 10MB. This option cannot be used
+                                   By default, 10MB. This option cannot be used
-                        with --fixed-size option.
+                                   with --fixed-size option.
+         --extra-partition-space: This option is specific to wic. It adds extra
+                                  empty space after the space filled by the
+                                  filesystem. With --fixed-size, the extra
+                                  partition space is removed from the filesystem
+                                  size. Otherwise (with or without --size flag),
+                                  the extra partition space is added to the final
+                                  paritition size. The default value is 0MB.
         --overhead-factor: This option is specific to wic. The
                            size of the partition is multiplied by
@@ -1045,6 +1066,18 @@ DESCRIPTION
                           not take effect when --mkfs-extraopts is used. This should be taken into
                           account when using --mkfs-extraopts.
+         --type: This option is specific to wic. Valid values are 'primary',
+                 'logical'. For msdos partition tables, this option specifies
+                 the partition type.
+         --hidden: This option is specific to wic. This option sets the
+                   RequiredPartition bit (bit 0) on GPT partitions.
+         --mbr: This option is specific to wic. This option is used with the
+                gpt-hybrid partition type that uses both a GPT partition and
+                an MBR header. Partitions with this flag will be included in
+                this MBR header.
    * bootloader
      This command allows the user to specify various bootloader
@@ -1063,6 +1096,13 @@ DESCRIPTION
                      file. Using this option will override any other
                      bootloader option.
+        --ptable: Specifies the partition table format. Valid values are
+                  'msdos', 'gpt', 'gpt-hybrid'.
+        --source: Specifies the source plugin. If not specified, the
+                  --source value will be copied from the partition that has
+                  /boot as mountpoint.
      Note that bootloader functionality and boot partitions are
      implemented by the various --source plugins that implement
      bootloader functionality; the bootloader command essentially
diff --git a/scripts/lib/wic/ksparser.py b/scripts/lib/wic/ksparser.py
index 7ef3dc83dd..a762d3b6cf 100644
--- a/scripts/lib/wic/ksparser.py
+++ b/scripts/lib/wic/ksparser.py
@@ -132,7 +132,7 @@ def systemidtype(arg):
 class KickStart():
    """Kickstart parser implementation."""
-    DEFAULT_EXTRA_SPACE = 10*1024
+    DEFAULT_EXTRA_FILESYSTEM_SPACE = 10*1024
    DEFAULT_OVERHEAD_FACTOR = 1.3
    def __init__(self, confpath):
@@ -153,7 +153,8 @@ class KickStart():
        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('--extra-filesystem-space', '--extra-space', type=sizetype("M"))
+        part.add_argument('--extra-partition-space', type=sizetype("M"))
        part.add_argument('--fsoptions', dest='fsopts')
        part.add_argument('--fspassno', dest='fspassno')
        part.add_argument('--fstype', default='vfat',
@@ -174,9 +175,9 @@ class KickStart():
        part.add_argument('--hidden', action='store_true')
        # --size and --fixed-size cannot be specified together; options
-        # ----extra-space and --overhead-factor should also raise a parser
+        # ----extra-filesystem-space and --overhead-factor should also raise a
-        # --error, but since nesting mutually exclusive groups does not work,
+        # parser error, but since nesting mutually exclusive groups does not work,
-        # ----extra-space/--overhead-factor are handled later
+        # ----extra-filesystem-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)
@@ -259,14 +260,17 @@ class KickStart():
                            err = "%s:%d: Must set the label with --label" \
                                  % (confpath, lineno)
                            raise KickStartError(err)
+                        if not parsed.extra_partition_space:
+                            parsed.extra_partition_space = 0
                        # 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
+                        # value; --overhead-factor/--extra-filesystem-space
-                        # with --fixed-size, so at least detect when these were
+                        # cannot be used with --fixed-size, so at least detect
-                        # passed with non-0 values ...
+                        # when these were passed with non-0 values ...
                        if parsed.fixed_size:
-                            if parsed.overhead_factor or parsed.extra_space:
+                            if parsed.overhead_factor or parsed.extra_filesystem_space:
-                                err = "%s:%d: arguments --overhead-factor and --extra-space not "\
+                                err = "%s:%d: arguments --overhead-factor and "\
+                                      "--extra-filesystem-space not "\
                                      "allowed with argument --fixed-size" \
                                      % (confpath, lineno)
                                raise KickStartError(err)
@@ -275,10 +279,10 @@ class KickStart():
                            # --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:
+                            if not parsed.overhead_factor:
                                parsed.overhead_factor = self.DEFAULT_OVERHEAD_FACTOR
-                            if '--extra-space' not in line_args:
+                            if not parsed.extra_filesystem_space:
-                                parsed.extra_space = self.DEFAULT_EXTRA_SPACE
+                                parsed.extra_filesystem_space = self.DEFAULT_EXTRA_FILESYSTEM_SPACE
                        self.partnum += 1
                        self.partitions.append(Partition(parsed, self.partnum))
diff --git a/scripts/lib/wic/partition.py b/scripts/lib/wic/partition.py
index 795707ec5d..531ac6eb3d 100644
--- a/scripts/lib/wic/partition.py
+++ b/scripts/lib/wic/partition.py
@@ -28,7 +28,8 @@ class Partition():
        self.align = args.align
        self.disk = args.disk
        self.device = None
-        self.extra_space = args.extra_space
+        self.extra_filesystem_space = args.extra_filesystem_space
+        self.extra_partition_space = args.extra_partition_space
        self.exclude_path = args.exclude_path
        self.include_path = args.include_path
        self.change_directory = args.change_directory
@@ -91,21 +92,20 @@ class Partition():
    def get_rootfs_size(self, actual_rootfs_size=0):
        """
        Calculate the required size of rootfs taking into consideration
-        --size/--fixed-size flags as well as overhead and extra space, as
+        --size/--fixed-size and --extra-partition-space flags as well as overhead
-        specified in kickstart file. Raises an error if the
+        and extra space, as specified in kickstart file. Raises an error
-        `actual_rootfs_size` is larger than fixed-size rootfs.
+        if the `actual_rootfs_size` is larger than fixed-size rootfs.
        """
        if self.fixed_size:
-            rootfs_size = self.fixed_size
+            rootfs_size = self.fixed_size - self.extra_partition_space
            if actual_rootfs_size > rootfs_size:
                raise WicError("Actual rootfs size (%d kB) is larger than "
                               "allowed size %d kB" %
                               (actual_rootfs_size, rootfs_size))
        else:
            extra_blocks = self.get_extra_block_count(actual_rootfs_size)
-            if extra_blocks < self.extra_space:
+            if extra_blocks < self.extra_filesystem_space:
-                extra_blocks = self.extra_space
+                extra_blocks = self.extra_filesystem_space
            rootfs_size = actual_rootfs_size + extra_blocks
            rootfs_size = int(rootfs_size * self.overhead_factor)
@@ -119,10 +119,18 @@ class Partition():
    def disk_size(self):
        """
        Obtain on-disk size of partition taking into consideration
-        --size/--fixed-size options.
+        --size/--fixed-size and --extra-partition-space options.
+        """
+        return self.fixed_size if self.fixed_size else self.size + self.extra_partition_space
+    @property
+    def fs_size(self):
+        """
+        Obtain on-disk size of filesystem inside the partition taking into
+        consideration --size/--fixed-size and --extra-partition-space options.
        """
-        return self.fixed_size if self.fixed_size else self.size
+        return self.fixed_size - self.extra_partition_space if self.fixed_size else self.size
    def prepare(self, creator, cr_workdir, oe_builddir, rootfs_dir,
                bootimg_dir, kernel_dir, native_sysroot, updated_fstab_path):
@@ -164,10 +172,13 @@ class Partition():
        plugins = PluginMgr.get_plugins('source')
+        # Don't support '-' in plugin names
+        self.source = self.source.replace("-", "_")
        if self.source not in plugins:
            raise WicError("The '%s' --source specified for %s doesn't exist.\n\t"
                           "See 'wic list source-plugins' for a list of available"
-                           " --sources.\n\tSee 'wic help source-plugins' for "
+                           " --sources.\n\tSee 'wic help plugins' for "
                           "details on adding a new source plugin." %
                           (self.source, self.mountpoint))
@@ -178,7 +189,7 @@ class Partition():
            splitted = self.sourceparams.split(',')
            srcparams_dict = dict((par.split('=', 1) + [None])[:2] for par in splitted if par)
-        plugin = PluginMgr.get_plugins('source')[self.source]
+        plugin = plugins[self.source]
        plugin.do_configure_partition(self, srcparams_dict, creator,
                                      cr_workdir, oe_builddir, bootimg_dir,
                                      kernel_dir, native_sysroot)
@@ -199,10 +210,10 @@ class Partition():
                           "This a bug in source plugin %s and needs to be fixed." %
                           (self.mountpoint, self.source))
-        if self.fixed_size and self.size > self.fixed_size:
+        if self.fixed_size and self.size + self.extra_partition_space > self.fixed_size:
            raise WicError("File system image of partition %s is "
-                           "larger (%d kB) than its allowed size %d kB" %
+                           "larger (%d kB + %d kB extra part space) than its allowed size %d kB" %
-                           (self.mountpoint, self.size, self.fixed_size))
+                           (self.mountpoint, self.size, self.extra_partition_space, self.fixed_size))
    def prepare_rootfs(self, cr_workdir, oe_builddir, rootfs_dir,
                       native_sysroot, real_rootfs = True, pseudo_dir = None):
@@ -222,19 +233,19 @@ class Partition():
        if (pseudo_dir):
            # Canonicalize the ignore paths. This corresponds to
            # calling oe.path.canonicalize(), which is used in bitbake.conf.
-            ignore_paths = [rootfs] + (get_bitbake_var("PSEUDO_IGNORE_PATHS") or "").split(",")
+            include_paths = [rootfs_dir] + (get_bitbake_var("PSEUDO_INCLUDE_PATHS") or "").split(",")
            canonical_paths = []
-            for path in ignore_paths:
+            for path in include_paths:
                if "$" not in path:
                    trailing_slash = path.endswith("/") and "/" or ""
                    canonical_paths.append(os.path.realpath(path) + trailing_slash)
-            ignore_paths = ",".join(canonical_paths)
+            include_paths = ",".join(canonical_paths)
            pseudo = "export PSEUDO_PREFIX=%s;" % p_prefix
            pseudo += "export PSEUDO_LOCALSTATEDIR=%s;" % pseudo_dir
            pseudo += "export PSEUDO_PASSWD=%s;" % rootfs_dir
            pseudo += "export PSEUDO_NOSYMLINKEXP=1;"
-            pseudo += "export PSEUDO_IGNORE_PATHS=%s;" % ignore_paths
+            pseudo += "export PSEUDO_INCLUDE_PATHS=%s;" % include_paths
            pseudo += "%s " % get_bitbake_var("FAKEROOTCMD")
        else:
            pseudo = None
@@ -244,7 +255,7 @@ class Partition():
            # from bitbake variable
            rsize_bb = get_bitbake_var('ROOTFS_SIZE')
            rdir = get_bitbake_var('IMAGE_ROOTFS')
-            if rsize_bb and rdir == rootfs_dir:
+            if rsize_bb and (rdir == rootfs_dir or (rootfs_dir.split('/')[-2] == "tmp-wic" and rootfs_dir.split('/')[-1][:6] == "rootfs")):
                # Bitbake variable ROOTFS_SIZE is calculated in
                # Image._get_rootfs_size method from meta/lib/oe/image.py
                # using IMAGE_ROOTFS_SIZE, IMAGE_ROOTFS_ALIGNMENT,
@@ -284,19 +295,8 @@ class Partition():
        extraopts = self.mkfs_extraopts or "-F -i 8192"
-        if os.getenv('SOURCE_DATE_EPOCH'):
+        # use hash_seed to generate reproducible ext4 images
-            sde_time = int(os.getenv('SOURCE_DATE_EPOCH'))
+        (extraopts, pseudo) = self.get_hash_seed_ext4(extraopts, pseudo)
-            if pseudo:
-                pseudo = "export E2FSPROGS_FAKE_TIME=%s;%s " % (sde_time, pseudo)
-            else:
-                pseudo = "export E2FSPROGS_FAKE_TIME=%s; " % sde_time
-            # Set hash_seed to generate deterministic directory indexes
-            namespace = uuid.UUID("e7429877-e7b3-4a68-a5c9-2f2fdf33d460")
-            if self.fsuuid:
-                namespace = uuid.UUID(self.fsuuid)
-            hash_seed = str(uuid.uuid5(namespace, str(sde_time)))
-            extraopts += " -E hash_seed=%s" % hash_seed
        label_str = ""
        if self.label:
@@ -344,6 +344,23 @@ class Partition():
        self.check_for_Y2038_problem(rootfs, native_sysroot)
+    def get_hash_seed_ext4(self, extraopts, pseudo):
+        if os.getenv('SOURCE_DATE_EPOCH'):
+            sde_time = int(os.getenv('SOURCE_DATE_EPOCH'))
+            if pseudo:
+                pseudo = "export E2FSPROGS_FAKE_TIME=%s;%s " % (sde_time, pseudo)
+            else:
+                pseudo = "export E2FSPROGS_FAKE_TIME=%s; " % sde_time
+            # Set hash_seed to generate deterministic directory indexes
+            namespace = uuid.UUID("e7429877-e7b3-4a68-a5c9-2f2fdf33d460")
+            if self.fsuuid:
+                namespace = uuid.UUID(self.fsuuid)
+            hash_seed = str(uuid.uuid5(namespace, str(sde_time)))
+            extraopts += " -E hash_seed=%s" % hash_seed
+        return (extraopts, pseudo)
    def prepare_rootfs_btrfs(self, rootfs, cr_workdir, oe_builddir, rootfs_dir,
                             native_sysroot, pseudo):
        """
@@ -431,19 +448,22 @@ class Partition():
        """
        Prepare an empty ext2/3/4 partition.
        """
-        size = self.disk_size
+        size = self.fs_size
        with open(rootfs, 'w') as sparse:
            os.ftruncate(sparse.fileno(), size * 1024)
        extraopts = self.mkfs_extraopts or "-i 8192"
+        # use hash_seed to generate reproducible ext4 images
+        (extraopts, pseudo) = self.get_hash_seed_ext4(extraopts, None)
        label_str = ""
        if self.label:
            label_str = "-L %s" % self.label
        mkfs_cmd = "mkfs.%s -F %s %s -U %s %s" % \
            (self.fstype, extraopts, label_str, self.fsuuid, rootfs)
-        exec_native_cmd(mkfs_cmd, native_sysroot)
+        exec_native_cmd(mkfs_cmd, native_sysroot, pseudo=pseudo)
        self.check_for_Y2038_problem(rootfs, native_sysroot)
@@ -452,7 +472,7 @@ class Partition():
        """
        Prepare an empty btrfs partition.
        """
-        size = self.disk_size
+        size = self.fs_size
        with open(rootfs, 'w') as sparse:
            os.ftruncate(sparse.fileno(), size * 1024)
@@ -470,7 +490,7 @@ class Partition():
        """
        Prepare an empty vfat partition.
        """
-        blocks = self.disk_size
+        blocks = self.fs_size
        label_str = "-n boot"
        if self.label:
diff --git a/scripts/lib/wic/pluginbase.py b/scripts/lib/wic/pluginbase.py
index b64568339b..640da292d3 100644
--- a/scripts/lib/wic/pluginbase.py
+++ b/scripts/lib/wic/pluginbase.py
@@ -44,7 +44,7 @@ class PluginMgr:
                    path = os.path.join(layer_path, script_plugin_dir)
                    path = os.path.abspath(os.path.expanduser(path))
                    if path not in cls._plugin_dirs and os.path.isdir(path):
-                        cls._plugin_dirs.insert(0, path)
+                        cls._plugin_dirs.append(path)
        if ptype not in PLUGINS:
            # load all ptype plugins
diff --git a/scripts/lib/wic/plugins/imager/direct.py b/scripts/lib/wic/plugins/imager/direct.py
index a1d152659b..6e1f1c8cba 100644
--- a/scripts/lib/wic/plugins/imager/direct.py
+++ b/scripts/lib/wic/plugins/imager/direct.py
@@ -203,6 +203,8 @@ class DirectPlugin(ImagerPlugin):
        source_plugin = self.ks.bootloader.source
        disk_name = self.parts[0].disk
        if source_plugin:
+            # Don't support '-' in plugin names
+            source_plugin = source_plugin.replace("-", "_")
            plugin = PluginMgr.get_plugins('source')[source_plugin]
            plugin.do_install_disk(self._image, disk_name, self, self.workdir,
                                   self.oe_builddir, self.bootimg_dir,
@@ -321,7 +323,15 @@ class PartitionedImage():
        self.partitions = partitions
        self.partimages = []
        # Size of a sector used in calculations
-        self.sector_size = SECTOR_SIZE
+        sector_size_str = get_bitbake_var('WIC_SECTOR_SIZE')
+        if sector_size_str is not None:
+            try:
+                self.sector_size = int(sector_size_str)
+            except ValueError:
+                self.sector_size = SECTOR_SIZE
+        else:
+            self.sector_size = SECTOR_SIZE
        self.native_sysroot = native_sysroot
        num_real_partitions = len([p for p in self.partitions if not p.no_table])
        self.extra_space = extra_space
@@ -508,7 +518,8 @@ class PartitionedImage():
        logger.debug("Added '%s' partition, sectors %d-%d, size %d sectors",
                     parttype, start, end, size)
-        cmd = "parted -s %s unit s mkpart %s" % (device, parttype)
+        cmd = "export PARTED_SECTOR_SIZE=%d; parted -s %s unit s mkpart %s" % \
+                     (self.sector_size, device, parttype)
        if fstype:
            cmd += " %s" % fstype
        cmd += " %d %d" % (start, end)
@@ -527,8 +538,8 @@ class PartitionedImage():
            os.ftruncate(sparse.fileno(), min_size)
        logger.debug("Initializing partition table for %s", device)
-        exec_native_cmd("parted -s %s mklabel %s" % (device, ptable_format),
+        exec_native_cmd("export PARTED_SECTOR_SIZE=%d; parted -s %s mklabel %s" %
-                        self.native_sysroot)
+                        (self.sector_size, device, ptable_format), self.native_sysroot)
    def _write_disk_guid(self):
        if self.ptable_format in ('gpt', 'gpt-hybrid'):
@@ -538,7 +549,8 @@ class PartitionedImage():
                self.disk_guid = uuid.uuid4()
            logger.debug("Set disk guid %s", self.disk_guid)
-            sfdisk_cmd = "sfdisk --disk-id %s %s" % (self.path, self.disk_guid)
+            sfdisk_cmd = "sfdisk --sector-size %s --disk-id %s %s" % \
+                        (self.sector_size, self.path, self.disk_guid)
            exec_native_cmd(sfdisk_cmd, self.native_sysroot)
    def create(self):
@@ -613,45 +625,44 @@ class PartitionedImage():
                partition_label = part.part_name if part.part_name else part.label
                logger.debug("partition %d: set name to %s",
                             part.num, partition_label)
-                exec_native_cmd("sgdisk --change-name=%d:%s %s" % \
+                exec_native_cmd("sfdisk --sector-size %s --part-label %s %d %s" % \
-                                         (part.num, partition_label,
+                                         (self.sector_size, self.path, part.num,
-                                          self.path), self.native_sysroot)
+                                          partition_label), self.native_sysroot)
            if part.part_type:
                logger.debug("partition %d: set type UID to %s",
                             part.num, part.part_type)
-                exec_native_cmd("sgdisk --typecode=%d:%s %s" % \
+                exec_native_cmd("sfdisk --sector-size %s --part-type %s %d %s" % \
-                                         (part.num, part.part_type,
+                                         (self.sector_size, self.path, part.num,
-                                          self.path), self.native_sysroot)
+                                          part.part_type), self.native_sysroot)
            if part.uuid and self.ptable_format in ("gpt", "gpt-hybrid"):
                logger.debug("partition %d: set UUID to %s",
                             part.num, part.uuid)
-                exec_native_cmd("sgdisk --partition-guid=%d:%s %s" % \
+                exec_native_cmd("sfdisk --sector-size %s --part-uuid %s %d %s" % \
-                                (part.num, part.uuid, self.path),
+                                (self.sector_size, self.path, part.num, part.uuid),
                                self.native_sysroot)
            if part.active:
                flag_name = "legacy_boot" if self.ptable_format in ('gpt', 'gpt-hybrid') else "boot"
                logger.debug("Set '%s' flag for partition '%s' on disk '%s'",
                             flag_name, part.num, self.path)
-                exec_native_cmd("parted -s %s set %d %s on" % \
+                exec_native_cmd("export PARTED_SECTOR_SIZE=%d; parted -s %s set %d %s on" % \
-                                (self.path, part.num, flag_name),
+                                (self.sector_size, self.path, part.num, flag_name),
                                self.native_sysroot)
                if self.ptable_format == 'gpt-hybrid' and part.mbr:
-                    exec_native_cmd("parted -s %s set %d %s on" % \
+                    exec_native_cmd("export PARTED_SECTOR_SIZE=%d; parted -s %s set %d %s on" % \
-                                    (mbr_path, hybrid_mbr_part_num, "boot"),
+                                    (self.sector_size, mbr_path, hybrid_mbr_part_num, "boot"),
                                    self.native_sysroot)
            if part.system_id:
-                exec_native_cmd("sfdisk --part-type %s %s %s" % \
+                exec_native_cmd("sfdisk --sector-size %s --part-type %s %s %s" % \
-                                (self.path, part.num, part.system_id),
+                                (self.sector_size, self.path, part.num, part.system_id),
                                self.native_sysroot)
            if part.hidden and self.ptable_format == "gpt":
                logger.debug("Set hidden attribute for partition '%s' on disk '%s'",
                             part.num, self.path)
-                exec_native_cmd("sfdisk --part-attrs %s %s RequiredPartition" % \
+                exec_native_cmd("sfdisk --sector-size %s --part-attrs %s %s RequiredPartition" % \
-                                (self.path, part.num),
+                                (self.sector_size, self.path, part.num),
                                self.native_sysroot)
        if self.ptable_format == "gpt-hybrid":
@@ -664,7 +675,8 @@ class PartitionedImage():
            # create with an arbitrary type, then change it to the correct type
            # with sfdisk
            self._create_partition(mbr_path, "primary", "fat32", 1, GPT_OVERHEAD)
-            exec_native_cmd("sfdisk --part-type %s %d 0xee" % (mbr_path, hybrid_mbr_part_num),
+            exec_native_cmd("sfdisk --sector-size %s --part-type %s %d 0xee" % \
+                            (self.sector_size, mbr_path, hybrid_mbr_part_num),
                            self.native_sysroot)
            # Copy hybrid MBR
diff --git a/scripts/lib/wic/plugins/source/bootimg-pcbios.py b/scripts/lib/wic/plugins/source/bootimg-pcbios.py
deleted file mode 100644
index a207a83530..0000000000
--- a/scripts/lib/wic/plugins/source/bootimg-pcbios.py
+++ /dev/null
@@ -1,209 +0,0 @@
-#
-# Copyright (c) 2014, Intel Corporation.
-#
-# SPDX-License-Identifier: GPL-2.0-only
-#
-# DESCRIPTION
-# This implements the 'bootimg-pcbios' source plugin class for 'wic'
-#
-# AUTHORS
-# Tom Zanussi <tom.zanussi (at] linux.intel.com>
-#
-import logging
-import os
-import re
-from wic import WicError
-from wic.engine import get_custom_config
-from wic.pluginbase import SourcePlugin
-from wic.misc import (exec_cmd, exec_native_cmd,
-                      get_bitbake_var, BOOTDD_EXTRA_SPACE)
-logger = logging.getLogger('wic')
-class BootimgPcbiosPlugin(SourcePlugin):
-    """
-    Create MBR boot partition and install syslinux on it.
-    """
-    name = 'bootimg-pcbios'
-    @classmethod
-    def _get_bootimg_dir(cls, bootimg_dir, dirname):
-        """
-        Check if dirname exists in default bootimg_dir or in STAGING_DIR.
-        """
-        staging_datadir = get_bitbake_var("STAGING_DATADIR")
-        for result in (bootimg_dir, staging_datadir):
-            if os.path.exists("%s/%s" % (result, dirname)):
-                return result
-        # STAGING_DATADIR is expanded with MLPREFIX if multilib is enabled
-        # but dependency syslinux is still populated to original STAGING_DATADIR
-        nonarch_datadir = re.sub('/[^/]*recipe-sysroot', '/recipe-sysroot', staging_datadir)
-        if os.path.exists(os.path.join(nonarch_datadir, dirname)):
-            return nonarch_datadir
-        raise WicError("Couldn't find correct bootimg_dir, exiting")
-    @classmethod
-    def do_install_disk(cls, disk, disk_name, creator, workdir, oe_builddir,
-                        bootimg_dir, kernel_dir, native_sysroot):
-        """
-        Called after all partitions have been prepared and assembled into a
-        disk image.  In this case, we install the MBR.
-        """
-        bootimg_dir = cls._get_bootimg_dir(bootimg_dir, 'syslinux')
-        mbrfile = "%s/syslinux/" % bootimg_dir
-        if creator.ptable_format == 'msdos':
-            mbrfile += "mbr.bin"
-        elif creator.ptable_format == 'gpt':
-            mbrfile += "gptmbr.bin"
-        else:
-            raise WicError("Unsupported partition table: %s" %
-                           creator.ptable_format)
-        if not os.path.exists(mbrfile):
-            raise WicError("Couldn't find %s.  If using the -e option, do you "
-                           "have the right MACHINE set in local.conf?  If not, "
-                           "is the bootimg_dir path correct?" % mbrfile)
-        full_path = creator._full_path(workdir, disk_name, "direct")
-        logger.debug("Installing MBR on disk %s as %s with size %s bytes",
-                     disk_name, full_path, disk.min_size)
-        dd_cmd = "dd if=%s of=%s conv=notrunc" % (mbrfile, full_path)
-        exec_cmd(dd_cmd, native_sysroot)
-    @classmethod
-    def do_configure_partition(cls, part, source_params, creator, cr_workdir,
-                               oe_builddir, bootimg_dir, kernel_dir,
-                               native_sysroot):
-        """
-        Called before do_prepare_partition(), creates syslinux config
-        """
-        hdddir = "%s/hdd/boot" % cr_workdir
-        install_cmd = "install -d %s" % hdddir
-        exec_cmd(install_cmd)
-        bootloader = creator.ks.bootloader
-        custom_cfg = None
-        if bootloader.configfile:
-            custom_cfg = get_custom_config(bootloader.configfile)
-            if custom_cfg:
-                # Use a custom configuration for grub
-                syslinux_conf = custom_cfg
-                logger.debug("Using custom configuration file %s "
-                             "for syslinux.cfg", bootloader.configfile)
-            else:
-                raise WicError("configfile is specified but failed to "
-                               "get it from %s." % bootloader.configfile)
-        if not custom_cfg:
-            # Create syslinux configuration using parameters from wks file
-            splash = os.path.join(cr_workdir, "/hdd/boot/splash.jpg")
-            if os.path.exists(splash):
-                splashline = "menu background splash.jpg"
-            else:
-                splashline = ""
-            syslinux_conf = ""
-            syslinux_conf += "PROMPT 0\n"
-            syslinux_conf += "TIMEOUT " + str(bootloader.timeout) + "\n"
-            syslinux_conf += "\n"
-            syslinux_conf += "ALLOWOPTIONS 1\n"
-            syslinux_conf += "SERIAL 0 115200\n"
-            syslinux_conf += "\n"
-            if splashline:
-                syslinux_conf += "%s\n" % splashline
-            syslinux_conf += "DEFAULT boot\n"
-            syslinux_conf += "LABEL boot\n"
-            kernel = "/" + get_bitbake_var("KERNEL_IMAGETYPE")
-            syslinux_conf += "KERNEL " + kernel + "\n"
-            syslinux_conf += "APPEND label=boot root=%s %s\n" % \
-                             (creator.rootdev, bootloader.append)
-        logger.debug("Writing syslinux config %s/hdd/boot/syslinux.cfg",
-                     cr_workdir)
-        cfg = open("%s/hdd/boot/syslinux.cfg" % cr_workdir, "w")
-        cfg.write(syslinux_conf)
-        cfg.close()
-    @classmethod
-    def do_prepare_partition(cls, part, source_params, creator, cr_workdir,
-                             oe_builddir, bootimg_dir, kernel_dir,
-                             rootfs_dir, native_sysroot):
-        """
-        Called to do the actual content population for a partition i.e. it
-        'prepares' the partition to be incorporated into the image.
-        In this case, prepare content for legacy bios boot partition.
-        """
-        bootimg_dir = cls._get_bootimg_dir(bootimg_dir, 'syslinux')
-        staging_kernel_dir = kernel_dir
-        hdddir = "%s/hdd/boot" % cr_workdir
-        kernel = get_bitbake_var("KERNEL_IMAGETYPE")
-        if get_bitbake_var("INITRAMFS_IMAGE_BUNDLE") == "1":
-            if get_bitbake_var("INITRAMFS_IMAGE"):
-                kernel = "%s-%s.bin" % \
-                    (get_bitbake_var("KERNEL_IMAGETYPE"), get_bitbake_var("INITRAMFS_LINK_NAME"))
-        cmds = ("install -m 0644 %s/%s %s/%s" %
-                (staging_kernel_dir, kernel, hdddir, get_bitbake_var("KERNEL_IMAGETYPE")),
-                "install -m 444 %s/syslinux/ldlinux.sys %s/ldlinux.sys" %
-                (bootimg_dir, hdddir),
-                "install -m 0644 %s/syslinux/vesamenu.c32 %s/vesamenu.c32" %
-                (bootimg_dir, hdddir),
-                "install -m 444 %s/syslinux/libcom32.c32 %s/libcom32.c32" %
-                (bootimg_dir, hdddir),
-                "install -m 444 %s/syslinux/libutil.c32 %s/libutil.c32" %
-                (bootimg_dir, hdddir))
-        for install_cmd in cmds:
-            exec_cmd(install_cmd)
-        du_cmd = "du -bks %s" % hdddir
-        out = exec_cmd(du_cmd)
-        blocks = int(out.split()[0])
-        extra_blocks = part.get_extra_block_count(blocks)
-        if extra_blocks < BOOTDD_EXTRA_SPACE:
-            extra_blocks = BOOTDD_EXTRA_SPACE
-        blocks += extra_blocks
-        logger.debug("Added %d extra blocks to %s to get to %d total blocks",
-                     extra_blocks, part.mountpoint, blocks)
-        # dosfs image, created by mkdosfs
-        bootimg = "%s/boot%s.img" % (cr_workdir, part.lineno)
-        label = part.label if part.label else "boot"
-        dosfs_cmd = "mkdosfs -n %s -i %s -S 512 -C %s %d" % \
-                    (label, part.fsuuid, bootimg, blocks)
-        exec_native_cmd(dosfs_cmd, native_sysroot)
-        mcopy_cmd = "mcopy -i %s -s %s/* ::/" % (bootimg, hdddir)
-        exec_native_cmd(mcopy_cmd, native_sysroot)
-        syslinux_cmd = "syslinux %s" % bootimg
-        exec_native_cmd(syslinux_cmd, native_sysroot)
-        chmod_cmd = "chmod 644 %s" % bootimg
-        exec_cmd(chmod_cmd)
-        du_cmd = "du -Lbks %s" % bootimg
-        out = exec_cmd(du_cmd)
-        bootimg_size = out.split()[0]
-        part.size = int(bootimg_size)
-        part.source_file = bootimg
diff --git a/scripts/lib/wic/plugins/source/bootimg-biosplusefi.py b/scripts/lib/wic/plugins/source/bootimg_biosplusefi.py
index 5bd7390680..4279ddded8 100644
--- a/scripts/lib/wic/plugins/source/bootimg-biosplusefi.py
+++ b/scripts/lib/wic/plugins/source/bootimg_biosplusefi.py
@@ -13,7 +13,7 @@
 # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 #
 # DESCRIPTION
-# This implements the 'bootimg-biosplusefi' source plugin class for 'wic'
+# This implements the 'bootimg_biosplusefi' source plugin class for 'wic'
 #
 # AUTHORS
 # William Bourque <wbourque [at) gmail.com>
@@ -34,7 +34,7 @@ class BootimgBiosPlusEFIPlugin(SourcePlugin):
    Note it is possible to create an image that can boot from both
    legacy BIOS and EFI by defining two partitions : one with arg
-    --source bootimg-efi  and another one with --source bootimg-pcbios.
+    --source bootimg_efi  and another one with --source bootimg_pcbios.
    However, this method has the obvious downside that it requires TWO
    partitions to be created on the storage device.
    Both partitions will also be marked as "bootable" which does not work on
@@ -45,7 +45,7 @@ class BootimgBiosPlusEFIPlugin(SourcePlugin):
    the first partition will be duplicated into the second, even though it
    will not be used at all.
-    Also, unlike "isoimage-isohybrid" that also does BIOS and EFI, this plugin
+    Also, unlike "isoimage_isohybrid" that also does BIOS and EFI, this plugin
    allows you to have more than only a single rootfs partitions and does
    not turn the rootfs into an initramfs RAM image.
@@ -53,32 +53,32 @@ class BootimgBiosPlusEFIPlugin(SourcePlugin):
    does not have the limitations listed above.
    The plugin is made so it does tries not to reimplement what's already
-    been done in other plugins; as such it imports "bootimg-pcbios"
+    been done in other plugins; as such it imports "bootimg_pcbios"
-    and "bootimg-efi".
+    and "bootimg_efi".
-    Plugin "bootimg-pcbios" is used to generate legacy BIOS boot.
+    Plugin "bootimg_pcbios" is used to generate legacy BIOS boot.
-    Plugin "bootimg-efi" is used to generate the UEFI boot. Note that it
+    Plugin "bootimg_efi" is used to generate the UEFI boot. Note that it
    requires a --sourceparams argument to know which loader to use; refer
-    to "bootimg-efi" code/documentation for the list of loader.
+    to "bootimg_efi" code/documentation for the list of loader.
    Imports are handled with "SourceFileLoader" from importlib as it is
    otherwise very difficult to import module that has hyphen "-" in their
    filename.
    The SourcePlugin() methods used in the plugins (do_install_disk,
    do_configure_partition, do_prepare_partition) are then called on both,
-    beginning by "bootimg-efi".
+    beginning by "bootimg_efi".
    Plugin options, such as "--sourceparams" can still be passed to a
    plugin, as long they does not cause issue in the other plugin.
    Example wic configuration:
-    part /boot --source bootimg-biosplusefi --sourceparams="loader=grub-efi"\\
+    part /boot --source bootimg_biosplusefi --sourceparams="loader=grub-efi"\\
               --ondisk sda --label os_boot --active --align 1024 --use-uuid
    """
-    name = 'bootimg-biosplusefi'
+    name = 'bootimg_biosplusefi'
-    __PCBIOS_MODULE_NAME = "bootimg-pcbios"
+    __PCBIOS_MODULE_NAME = "bootimg_pcbios"
-    __EFI_MODULE_NAME = "bootimg-efi"
+    __EFI_MODULE_NAME = "bootimg_efi"
    __imgEFIObj = None
    __imgBiosObj = None
@@ -100,7 +100,7 @@ class BootimgBiosPlusEFIPlugin(SourcePlugin):
        """
-        # Import bootimg-pcbios (class name "BootimgPcbiosPlugin")
+        # Import bootimg_pcbios (class name "BootimgPcbiosPlugin")
        modulePath = os.path.join(os.path.dirname(os.path.realpath(__file__)),
                                  cls.__PCBIOS_MODULE_NAME + ".py")
        loader = SourceFileLoader(cls.__PCBIOS_MODULE_NAME, modulePath)
@@ -108,7 +108,7 @@ class BootimgBiosPlusEFIPlugin(SourcePlugin):
        loader.exec_module(mod)
        cls.__imgBiosObj = mod.BootimgPcbiosPlugin()
-        # Import bootimg-efi (class name "BootimgEFIPlugin")
+        # Import bootimg_efi (class name "BootimgEFIPlugin")
        modulePath = os.path.join(os.path.dirname(os.path.realpath(__file__)),
                                  cls.__EFI_MODULE_NAME + ".py")
        loader = SourceFileLoader(cls.__EFI_MODULE_NAME, modulePath)
diff --git a/scripts/lib/wic/plugins/source/bootimg-efi.py b/scripts/lib/wic/plugins/source/bootimg_efi.py
index 13a9cddf4e..cf16705a28 100644
--- a/scripts/lib/wic/plugins/source/bootimg-efi.py
+++ b/scripts/lib/wic/plugins/source/bootimg_efi.py
@@ -4,7 +4,7 @@
 # SPDX-License-Identifier: GPL-2.0-only
 #
 # DESCRIPTION
-# This implements the 'bootimg-efi' source plugin class for 'wic'
+# This implements the 'bootimg_efi' source plugin class for 'wic'
 #
 # AUTHORS
 # Tom Zanussi <tom.zanussi (at] linux.intel.com>
@@ -32,7 +32,7 @@ class BootimgEFIPlugin(SourcePlugin):
    This plugin supports GRUB 2 and systemd-boot bootloaders.
    """
-    name = 'bootimg-efi'
+    name = 'bootimg_efi'
    @classmethod
    def _copy_additional_files(cls, hdddir, initrd, dtb):
@@ -43,16 +43,18 @@ class BootimgEFIPlugin(SourcePlugin):
        if initrd:
            initrds = initrd.split(';')
            for rd in initrds:
-                cp_cmd = "cp %s/%s %s" % (bootimg_dir, rd, hdddir)
+                cp_cmd = "cp -v -p %s/%s %s" % (bootimg_dir, rd, hdddir)
-                exec_cmd(cp_cmd, True)
+                out = exec_cmd(cp_cmd, True)
+                logger.debug("initrd files:\n%s" % (out))
        else:
            logger.debug("Ignoring missing initrd")
        if dtb:
            if ';' in dtb:
                raise WicError("Only one DTB supported, exiting")
-            cp_cmd = "cp %s/%s %s" % (bootimg_dir, dtb, hdddir)
+            cp_cmd = "cp -v -p %s/%s %s" % (bootimg_dir, dtb, hdddir)
-            exec_cmd(cp_cmd, True)
+            out = exec_cmd(cp_cmd, True)
+            logger.debug("dtb files:\n%s" % (out))
    @classmethod
    def do_configure_grubefi(cls, hdddir, creator, cr_workdir, source_params):
@@ -123,8 +125,16 @@ class BootimgEFIPlugin(SourcePlugin):
    @classmethod
    def do_configure_systemdboot(cls, hdddir, creator, cr_workdir, source_params):
        """
-        Create loader-specific systemd-boot/gummiboot config
+        Create loader-specific systemd-boot/gummiboot config. Unified Kernel Image (uki)
+        support is done in image recipe with uki.bbclass and only systemd-boot loader config
+        and ESP partition structure is created here.
        """
+        # detect uki.bbclass usage
+        image_classes = get_bitbake_var("IMAGE_CLASSES").split()
+        unified_image = False
+        if "uki" in image_classes:
+            unified_image = True
        install_cmd = "install -d %s/loader" % hdddir
        exec_cmd(install_cmd)
@@ -132,28 +142,26 @@ class BootimgEFIPlugin(SourcePlugin):
        exec_cmd(install_cmd)
        bootloader = creator.ks.bootloader
-        unified_image = source_params.get('create-unified-kernel-image') == "true"
        loader_conf = ""
-        if not unified_image:
-            loader_conf += "default boot\n"
-        loader_conf += "timeout %d\n" % bootloader.timeout
-        initrd = source_params.get('initrd')
+        # 5 seconds is a sensible default timeout
-        dtb = source_params.get('dtb')
+        loader_conf += "timeout %d\n" % (bootloader.timeout or 5)
-        if not unified_image:
-            cls._copy_additional_files(hdddir, initrd, dtb)
        logger.debug("Writing systemd-boot config "
                     "%s/hdd/boot/loader/loader.conf", cr_workdir)
        cfg = open("%s/hdd/boot/loader/loader.conf" % cr_workdir, "w")
        cfg.write(loader_conf)
+        logger.debug("loader.conf:\n%s" % (loader_conf))
        cfg.close()
+        initrd = source_params.get('initrd')
+        dtb = source_params.get('dtb')
+        if not unified_image:
+            cls._copy_additional_files(hdddir, initrd, dtb)
        configfile = creator.ks.bootloader.configfile
        custom_cfg = None
+        boot_conf = ""
        if configfile:
            custom_cfg = get_custom_config(configfile)
            if custom_cfg:
@@ -164,8 +172,7 @@ class BootimgEFIPlugin(SourcePlugin):
            else:
                raise WicError("configfile is specified but failed to "
                               "get it from %s.", configfile)
+        else:
-        if not custom_cfg:
            # Create systemd-boot configuration using parameters from wks file
            kernel = get_bitbake_var("KERNEL_IMAGETYPE")
            if get_bitbake_var("INITRAMFS_IMAGE_BUNDLE") == "1":
@@ -175,7 +182,6 @@ class BootimgEFIPlugin(SourcePlugin):
            title = source_params.get('title')
-            boot_conf = ""
            boot_conf += "title %s\n" % (title if title else "boot")
            boot_conf += "linux /%s\n" % kernel
@@ -200,6 +206,7 @@ class BootimgEFIPlugin(SourcePlugin):
                         "%s/hdd/boot/loader/entries/boot.conf", cr_workdir)
            cfg = open("%s/hdd/boot/loader/entries/boot.conf" % cr_workdir, "w")
            cfg.write(boot_conf)
+            logger.debug("boot.conf:\n%s" % (boot_conf))
            cfg.close()
@@ -223,9 +230,9 @@ class BootimgEFIPlugin(SourcePlugin):
            elif source_params['loader'] == 'uefi-kernel':
                pass
            else:
-                raise WicError("unrecognized bootimg-efi loader: %s" % source_params['loader'])
+                raise WicError("unrecognized bootimg_efi loader: %s" % source_params['loader'])
        except KeyError:
-            raise WicError("bootimg-efi requires a loader, none specified")
+            raise WicError("bootimg_efi requires a loader, none specified")
        if get_bitbake_var("IMAGE_EFI_BOOT_FILES") is None:
            logger.debug('No boot files defined in IMAGE_EFI_BOOT_FILES')
@@ -245,7 +252,7 @@ class BootimgEFIPlugin(SourcePlugin):
            # list of tuples (src_name, dst_name)
            deploy_files = []
-            for src_entry in re.findall(r'[\w;\-\./\*]+', boot_files):
+            for src_entry in re.findall(r'[\w;\-\.\+/\*]+', boot_files):
                if ';' in src_entry:
                    dst_entry = tuple(src_entry.split(';'))
                    if not dst_entry[0] or not dst_entry[1]:
@@ -304,134 +311,43 @@ class BootimgEFIPlugin(SourcePlugin):
                    (get_bitbake_var("KERNEL_IMAGETYPE"), get_bitbake_var("INITRAMFS_LINK_NAME"))
        if source_params.get('create-unified-kernel-image') == "true":
-            initrd = source_params.get('initrd')
+            raise WicError("create-unified-kernel-image is no longer supported. Please use uki.bbclass.")
-            if not initrd:
-                raise WicError("initrd= must be specified when create-unified-kernel-image=true, exiting")
-            deploy_dir = get_bitbake_var("DEPLOY_DIR_IMAGE")
-            efi_stub = glob("%s/%s" % (deploy_dir, "linux*.efi.stub"))
-            if len(efi_stub) == 0:
-                raise WicError("Unified Kernel Image EFI stub not found, exiting")
-            efi_stub = efi_stub[0]
-            with tempfile.TemporaryDirectory() as tmp_dir:
-                label = source_params.get('label')
-                label_conf = "root=%s" % creator.rootdev
-                if label:
-                    label_conf = "LABEL=%s" % label
-                bootloader = creator.ks.bootloader
-                cmdline = open("%s/cmdline" % tmp_dir, "w")
-                cmdline.write("%s %s" % (label_conf, bootloader.append))
-                cmdline.close()
-                initrds = initrd.split(';')
+        if source_params.get('install-kernel-into-boot-dir') != 'false':
-                initrd = open("%s/initrd" % tmp_dir, "wb")
+            install_cmd = "install -v -p -m 0644 %s/%s %s/%s" % \
-                for f in initrds:
+                (staging_kernel_dir, kernel, hdddir, kernel)
-                    with open("%s/%s" % (deploy_dir, f), 'rb') as in_file:
+            out = exec_cmd(install_cmd)
-                        shutil.copyfileobj(in_file, initrd)
+            logger.debug("Installed kernel files:\n%s" % out)
-                initrd.close()
-                # Searched by systemd-boot:
-                # https://systemd.io/BOOT_LOADER_SPECIFICATION/#type-2-efi-unified-kernel-images
-                install_cmd = "install -d %s/EFI/Linux" % hdddir
-                exec_cmd(install_cmd)
-                staging_dir_host = get_bitbake_var("STAGING_DIR_HOST")
-                target_sys = get_bitbake_var("TARGET_SYS")
-                objdump_cmd = "%s-objdump" % target_sys
-                objdump_cmd += " -p %s" % efi_stub
-                objdump_cmd += " | awk '{ if ($1 == \"SectionAlignment\"){print $2} }'"
-                ret, align_str = exec_native_cmd(objdump_cmd, native_sysroot)
-                align = int(align_str, 16)
-                objdump_cmd = "%s-objdump" % target_sys
-                objdump_cmd += " -h %s | tail -2" % efi_stub
-                ret, output = exec_native_cmd(objdump_cmd, native_sysroot)
-                offset = int(output.split()[2], 16) + int(output.split()[3], 16)
-                osrel_off = offset + align - offset % align
-                osrel_path = "%s/usr/lib/os-release" % staging_dir_host
-                osrel_sz = os.stat(osrel_path).st_size
-                cmdline_off = osrel_off + osrel_sz
-                cmdline_off = cmdline_off + align - cmdline_off % align
-                cmdline_sz = os.stat(cmdline.name).st_size
-                dtb_off = cmdline_off + cmdline_sz
-                dtb_off = dtb_off + align - dtb_off % align
-                dtb = source_params.get('dtb')
-                if dtb:
-                    if ';' in dtb:
-                        raise WicError("Only one DTB supported, exiting")
-                    dtb_path = "%s/%s" % (deploy_dir, dtb)
-                    dtb_params = '--add-section .dtb=%s --change-section-vma .dtb=0x%x' % \
-                            (dtb_path, dtb_off)
-                    linux_off = dtb_off + os.stat(dtb_path).st_size
-                    linux_off = linux_off + align - linux_off % align
-                else:
-                    dtb_params = ''
-                    linux_off = dtb_off
-                linux_path = "%s/%s" % (staging_kernel_dir, kernel)
-                linux_sz = os.stat(linux_path).st_size
-                initrd_off = linux_off + linux_sz
-                initrd_off = initrd_off + align - initrd_off % align
-                # https://www.freedesktop.org/software/systemd/man/systemd-stub.html
-                objcopy_cmd = "%s-objcopy" % target_sys
-                objcopy_cmd += " --enable-deterministic-archives"
-                objcopy_cmd += " --preserve-dates"
-                objcopy_cmd += " --add-section .osrel=%s" % osrel_path
-                objcopy_cmd += " --change-section-vma .osrel=0x%x" % osrel_off
-                objcopy_cmd += " --add-section .cmdline=%s" % cmdline.name
-                objcopy_cmd += " --change-section-vma .cmdline=0x%x" % cmdline_off
-                objcopy_cmd += dtb_params
-                objcopy_cmd += " --add-section .linux=%s" % linux_path
-                objcopy_cmd += " --change-section-vma .linux=0x%x" % linux_off
-                objcopy_cmd += " --add-section .initrd=%s" % initrd.name
-                objcopy_cmd += " --change-section-vma .initrd=0x%x" % initrd_off
-                objcopy_cmd += " %s %s/EFI/Linux/linux.efi" % (efi_stub, hdddir)
-                exec_native_cmd(objcopy_cmd, native_sysroot)
-        else:
-            if source_params.get('install-kernel-into-boot-dir') != 'false':
-                install_cmd = "install -m 0644 %s/%s %s/%s" % \
-                    (staging_kernel_dir, kernel, hdddir, kernel)
-                exec_cmd(install_cmd)
        if get_bitbake_var("IMAGE_EFI_BOOT_FILES"):
            for src_path, dst_path in cls.install_task:
-                install_cmd = "install -m 0644 -D %s %s" \
+                install_cmd = "install -v -p -m 0644 -D %s %s" \
                              % (os.path.join(kernel_dir, src_path),
                                 os.path.join(hdddir, dst_path))
-                exec_cmd(install_cmd)
+                out = exec_cmd(install_cmd)
+                logger.debug("Installed IMAGE_EFI_BOOT_FILES:\n%s" % out)
        try:
            if source_params['loader'] == 'grub-efi':
                shutil.copyfile("%s/hdd/boot/EFI/BOOT/grub.cfg" % cr_workdir,
                                "%s/grub.cfg" % cr_workdir)
                for mod in [x for x in os.listdir(kernel_dir) if x.startswith("grub-efi-")]:
-                    cp_cmd = "cp %s/%s %s/EFI/BOOT/%s" % (kernel_dir, mod, hdddir, mod[9:])
+                    cp_cmd = "cp -v -p %s/%s %s/EFI/BOOT/%s" % (kernel_dir, mod, hdddir, mod[9:])
                    exec_cmd(cp_cmd, True)
                shutil.move("%s/grub.cfg" % cr_workdir,
                            "%s/hdd/boot/EFI/BOOT/grub.cfg" % cr_workdir)
            elif source_params['loader'] == 'systemd-boot':
                for mod in [x for x in os.listdir(kernel_dir) if x.startswith("systemd-")]:
-                    cp_cmd = "cp %s/%s %s/EFI/BOOT/%s" % (kernel_dir, mod, hdddir, mod[8:])
+                    cp_cmd = "cp -v -p %s/%s %s/EFI/BOOT/%s" % (kernel_dir, mod, hdddir, mod[8:])
-                    exec_cmd(cp_cmd, True)
+                    out = exec_cmd(cp_cmd, True)
+                    logger.debug("systemd-boot files:\n%s" % out)
            elif source_params['loader'] == 'uefi-kernel':
                kernel = get_bitbake_var("KERNEL_IMAGETYPE")
                if not kernel:
-                    raise WicError("Empty KERNEL_IMAGETYPE %s\n" % target)
+                    raise WicError("Empty KERNEL_IMAGETYPE")
                target = get_bitbake_var("TARGET_SYS")
                if not target:
-                    raise WicError("Unknown arch (TARGET_SYS) %s\n" % target)
+                    raise WicError("Empty TARGET_SYS")
                if re.match("x86_64", target):
                    kernel_efi_image = "bootx64.efi"
@@ -445,23 +361,33 @@ class BootimgEFIPlugin(SourcePlugin):
                    raise WicError("UEFI stub kernel is incompatible with target %s" % target)
                for mod in [x for x in os.listdir(kernel_dir) if x.startswith(kernel)]:
-                    cp_cmd = "cp %s/%s %s/EFI/BOOT/%s" % (kernel_dir, mod, hdddir, kernel_efi_image)
+                    cp_cmd = "cp -v -p %s/%s %s/EFI/BOOT/%s" % (kernel_dir, mod, hdddir, kernel_efi_image)
-                    exec_cmd(cp_cmd, True)
+                    out = exec_cmd(cp_cmd, True)
+                    logger.debug("uefi-kernel files:\n%s" % out)
            else:
-                raise WicError("unrecognized bootimg-efi loader: %s" %
+                raise WicError("unrecognized bootimg_efi loader: %s" %
                               source_params['loader'])
+            # must have installed at least one EFI bootloader
+            out = glob(os.path.join(hdddir, 'EFI', 'BOOT', 'boot*.efi'))
+            logger.debug("Installed EFI loader files:\n%s" % out)
+            if not out:
+                raise WicError("No EFI loaders installed to ESP partition. Check that grub-efi, systemd-boot or similar is installed.")
        except KeyError:
-            raise WicError("bootimg-efi requires a loader, none specified")
+            raise WicError("bootimg_efi requires a loader, none specified")
        startup = os.path.join(kernel_dir, "startup.nsh")
        if os.path.exists(startup):
-            cp_cmd = "cp %s %s/" % (startup, hdddir)
+            cp_cmd = "cp -v -p %s %s/" % (startup, hdddir)
-            exec_cmd(cp_cmd, True)
+            out = exec_cmd(cp_cmd, True)
+            logger.debug("startup files:\n%s" % out)
        for paths in part.include_path or []:
            for path in paths:
-                cp_cmd = "cp -r %s %s/" % (path, hdddir)
+                cp_cmd = "cp -v -p -r %s %s/" % (path, hdddir)
                exec_cmd(cp_cmd, True)
+                logger.debug("include_path files:\n%s" % out)
        du_cmd = "du -bks %s" % hdddir
        out = exec_cmd(du_cmd)
@@ -489,12 +415,14 @@ class BootimgEFIPlugin(SourcePlugin):
        label = part.label if part.label else "ESP"
-        dosfs_cmd = "mkdosfs -n %s -i %s -C %s %d" % \
+        dosfs_cmd = "mkdosfs -v -n %s -i %s -C %s %d" % \
                    (label, part.fsuuid, bootimg, blocks)
        exec_native_cmd(dosfs_cmd, native_sysroot)
+        logger.debug("mkdosfs:\n%s" % (str(out)))
-        mcopy_cmd = "mcopy -i %s -s %s/* ::/" % (bootimg, hdddir)
+        mcopy_cmd = "mcopy -v -p -i %s -s %s/* ::/" % (bootimg, hdddir)
-        exec_native_cmd(mcopy_cmd, native_sysroot)
+        out = exec_native_cmd(mcopy_cmd, native_sysroot)
+        logger.debug("mcopy:\n%s" % (str(out)))
        chmod_cmd = "chmod 644 %s" % bootimg
        exec_cmd(chmod_cmd)
diff --git a/scripts/lib/wic/plugins/source/bootimg-partition.py b/scripts/lib/wic/plugins/source/bootimg_partition.py
index 1071d1af3f..cc121a78f0 100644
--- a/scripts/lib/wic/plugins/source/bootimg-partition.py
+++ b/scripts/lib/wic/plugins/source/bootimg_partition.py
@@ -4,7 +4,7 @@
 # SPDX-License-Identifier: GPL-2.0-only
 #
 # DESCRIPTION
-# This implements the 'bootimg-partition' source plugin class for
+# This implements the 'bootimg_partition' source plugin class for
 # 'wic'. The plugin creates an image of boot partition, copying over
 # files listed in IMAGE_BOOT_FILES bitbake variable.
 #
@@ -16,7 +16,7 @@ import logging
 import os
 import re
-from glob import glob
+from oe.bootfiles import get_boot_files
 from wic import WicError
 from wic.engine import get_custom_config
@@ -31,7 +31,7 @@ class BootimgPartitionPlugin(SourcePlugin):
    listed in IMAGE_BOOT_FILES bitbake variable.
    """
-    name = 'bootimg-partition'
+    name = 'bootimg_partition'
    image_boot_files_var_name = 'IMAGE_BOOT_FILES'
    @classmethod
@@ -66,42 +66,7 @@ class BootimgPartitionPlugin(SourcePlugin):
        logger.debug('Boot files: %s', boot_files)
-        # list of tuples (src_name, dst_name)
+        cls.install_task = get_boot_files(kernel_dir, boot_files)
-        deploy_files = []
-        for src_entry in re.findall(r'[\w;\-\./\*]+', boot_files):
-            if ';' in src_entry:
-                dst_entry = tuple(src_entry.split(';'))
-                if not dst_entry[0] or not dst_entry[1]:
-                    raise WicError('Malformed boot file entry: %s' % src_entry)
-            else:
-                dst_entry = (src_entry, src_entry)
-            logger.debug('Destination entry: %r', dst_entry)
-            deploy_files.append(dst_entry)
-        cls.install_task = [];
-        for deploy_entry in deploy_files:
-            src, dst = deploy_entry
-            if '*' in src:
-                # by default install files under their basename
-                entry_name_fn = os.path.basename
-                if dst != src:
-                    # unless a target name was given, then treat name
-                    # as a directory and append a basename
-                    entry_name_fn = lambda name: \
-                                    os.path.join(dst,
-                                                 os.path.basename(name))
-                srcs = glob(os.path.join(kernel_dir, src))
-                logger.debug('Globbed sources: %s', ', '.join(srcs))
-                for entry in srcs:
-                    src = os.path.relpath(entry, kernel_dir)
-                    entry_dst_name = entry_name_fn(entry)
-                    cls.install_task.append((src, entry_dst_name))
-            else:
-                cls.install_task.append((src, dst))
        if source_params.get('loader') != "u-boot":
            return
diff --git a/scripts/lib/wic/plugins/source/bootimg_pcbios.py b/scripts/lib/wic/plugins/source/bootimg_pcbios.py
new file mode 100644
index 0000000000..caabda6318
--- /dev/null
+++ b/scripts/lib/wic/plugins/source/bootimg_pcbios.py
@@ -0,0 +1,483 @@
+#
+# Copyright (c) 2014, Intel Corporation.
+#
+# SPDX-License-Identifier: GPL-2.0-only
+#
+# DESCRIPTION
+# This implements the 'bootimg_pcbios' source plugin class for 'wic'
+#
+# AUTHORS
+# Tom Zanussi <tom.zanussi (at] linux.intel.com>
+#
+import logging
+import os
+import re
+import shutil
+from glob import glob
+from wic import WicError
+from wic.engine import get_custom_config
+from wic.pluginbase import SourcePlugin
+from wic.misc import (exec_cmd, exec_native_cmd,
+                      get_bitbake_var, BOOTDD_EXTRA_SPACE)
+logger = logging.getLogger('wic')
+class BootimgPcbiosPlugin(SourcePlugin):
+    """
+    Creates boot partition that is legacy BIOS firmare bootable with
+    MBR/MSDOS as partition table format. Plugin will install caller
+    selected bootloader directly to resulting wic image.
+    Supported Bootloaders:
+        * syslinux (default)
+        * grub
+    ****************** Wic Plugin Depends/Vars ******************
+    WKS_FILE_DEPENDS = "grub-native grub"
+    WKS_FILE_DEPENDS = "syslinux-native syslinux"
+    # Optional variables
+    # GRUB_MKIMAGE_FORMAT_PC - Used to define target platform.
+    # GRUB_PREFIX_PATH       - Used to define which directory
+    #                          grub config and modules are going
+    #                          to reside in.
+    GRUB_PREFIX_PATH = '/boot/grub2'    # Default: /boot/grub
+    GRUB_MKIMAGE_FORMAT_PC = 'i386-pc'  # Default: i386-pc
+    WICVARS:append = "\
+        GRUB_PREFIX_PATH \
+        GRUB_MKIMAGE_FORMAT_PC \
+        "
+    ****************** Wic Plugin Depends/Vars ******************
+    **************** Example kickstart Legacy Bios Grub Boot ****************
+    part boot --label bios_boot --fstype ext4 --offset 1024 --fixed-size 78M
+        --source bootimg_pcbios --sourceparams="loader-bios=grub" --active
+    part roots --label rootfs --fstype ext4 --source rootfs --use-uuid
+    bootloader --ptable msdos --source bootimg_pcbios
+    **************** Example kickstart Legacy Bios Grub Boot ****************
+    *************** Example kickstart Legacy Bios Syslinux Boot ****************
+    part /boot --source bootimg_pcbios --sourceparams="loader-bios=syslinux"
+           --ondisk sda --label boot --fstype vfat --align 1024 --active
+    part roots --label rootfs --fstype ext4 --source rootfs --use-uuid
+    bootloader --ptable msdos --source bootimg_pcbios
+    """
+    name = 'bootimg_pcbios'
+    # Variable required for do_install_disk
+    loader = ''
+    @classmethod
+    def _get_bootimg_dir(cls, bootimg_dir, dirname):
+        """
+        Check if dirname exists in default bootimg_dir or in STAGING_DIR.
+        """
+        staging_datadir = get_bitbake_var("STAGING_DATADIR")
+        for result in (bootimg_dir, staging_datadir):
+            if os.path.exists("%s/%s" % (result, dirname)):
+                return result
+        # STAGING_DATADIR is expanded with MLPREFIX if multilib is enabled
+        # but dependency syslinux is still populated to original STAGING_DATADIR
+        nonarch_datadir = re.sub('/[^/]*recipe-sysroot', '/recipe-sysroot', staging_datadir)
+        if os.path.exists(os.path.join(nonarch_datadir, dirname)):
+            return nonarch_datadir
+        raise WicError("Couldn't find correct bootimg_dir, exiting")
+    @classmethod
+    def do_install_disk(cls, disk, disk_name, creator, workdir, oe_builddir,
+                        bootimg_dir, kernel_dir, native_sysroot):
+        full_path = creator._full_path(workdir, disk_name, "direct")
+        logger.debug("Installing MBR on disk %s as %s with size %s bytes",
+                     disk_name, full_path, disk.min_size)
+        if cls.loader == 'grub':
+            cls._do_install_grub(creator, kernel_dir,
+                            native_sysroot, full_path)
+        elif cls.loader == 'syslinux':
+            cls._do_install_syslinux(creator, bootimg_dir,
+                            native_sysroot, full_path)
+        else:
+            raise WicError("boot loader some how not specified check do_prepare_partition")
+    @classmethod
+    def do_configure_partition(cls, part, source_params, creator, cr_workdir,
+                               oe_builddir, bootimg_dir, kernel_dir,
+                               native_sysroot):
+        try:
+            if source_params['loader-bios'] == 'grub':
+                cls._do_configure_grub(part, creator, cr_workdir)
+            elif source_params['loader-bios'] == 'syslinux':
+                cls._do_configure_syslinux(part, creator, cr_workdir)
+            else:
+                raise WicError("unrecognized bootimg_pcbios loader: %s" % source_params['loader-bios'])
+        except KeyError:
+            cls._do_configure_syslinux(part, creator, cr_workdir)
+    @classmethod
+    def do_prepare_partition(cls, part, source_params, creator, cr_workdir,
+                             oe_builddir, bootimg_dir, kernel_dir,
+                             rootfs_dir, native_sysroot):
+        try:
+            if source_params['loader-bios'] == 'grub':
+                cls._do_prepare_grub(part, cr_workdir, oe_builddir,
+                                kernel_dir, rootfs_dir, native_sysroot)
+            elif source_params['loader-bios'] == 'syslinux':
+                cls._do_prepare_syslinux(part, cr_workdir, bootimg_dir,
+                                    kernel_dir, native_sysroot)
+            else:
+                raise WicError("unrecognized bootimg_pcbios loader: %s" % source_params['loader-bios'])
+            # Required by do_install_disk
+            cls.loader = source_params['loader-bios']
+        except KeyError:
+            # Required by do_install_disk
+            cls.loader = 'syslinux'
+            cls._do_prepare_syslinux(part, cr_workdir, bootimg_dir,
+                                kernel_dir, native_sysroot)
+    @classmethod
+    def _get_staging_libdir(cls):
+        """
+        For unknown reasons when running test with poky
+        STAGING_LIBDIR gets unset when wic create is executed.
+        Bellow is a hack to determine what STAGING_LIBDIR should
+        be if not specified.
+        """
+        staging_libdir = get_bitbake_var('STAGING_LIBDIR')
+        staging_dir_target = get_bitbake_var('STAGING_DIR_TARGET')
+        if not staging_libdir:
+            staging_libdir = '%s/usr/lib64' % staging_dir_target
+            if not os.path.isdir(staging_libdir):
+                staging_libdir = '%s/usr/lib32' % staging_dir_target
+                if not os.path.isdir(staging_libdir):
+                    staging_libdir = '%s/usr/lib' % staging_dir_target
+        return staging_libdir
+    @classmethod
+    def _get_bootloader_config(cls, bootloader, loader):
+        custom_cfg = None
+        if bootloader.configfile:
+            custom_cfg = get_custom_config(bootloader.configfile)
+            if custom_cfg:
+                logger.debug("Using custom configuration file %s "
+                             "for %s.cfg", bootloader.configfile,
+                             loader)
+                return custom_cfg
+            else:
+                raise WicError("configfile is specified but failed to "
+                               "get it from %s." % bootloader.configfile)
+        return custom_cfg
+    @classmethod
+    def _do_configure_syslinux(cls, part, creator, cr_workdir):
+        """
+        Called before do_prepare_partition(), creates syslinux config
+        """
+        hdddir = "%s/hdd/boot" % cr_workdir
+        install_cmd = "install -d %s" % hdddir
+        exec_cmd(install_cmd)
+        bootloader = creator.ks.bootloader
+        syslinux_conf = cls._get_bootloader_config(bootloader, 'syslinux')
+        if not syslinux_conf:
+            # Create syslinux configuration using parameters from wks file
+            splash = os.path.join(hdddir, "/splash.jpg")
+            if os.path.exists(splash):
+                splashline = "menu background splash.jpg"
+            else:
+                splashline = ""
+            # Set a default timeout if none specified to avoid
+            # 'None' being the value placed within the configuration
+            # file.
+            if not bootloader.timeout:
+                bootloader.timeout = 500
+            # Set a default kernel params string if none specified
+            # to avoid 'None' being the value placed within the
+            # configuration file.
+            if not bootloader.append:
+                bootloader.append = "rootwait console=ttyS0,115200 console=tty0"
+            syslinux_conf = ""
+            syslinux_conf += "PROMPT 0\n"
+            syslinux_conf += "TIMEOUT " + str(bootloader.timeout) + "\n"
+            syslinux_conf += "\n"
+            syslinux_conf += "ALLOWOPTIONS 1\n"
+            syslinux_conf += "SERIAL 0 115200\n"
+            syslinux_conf += "\n"
+            if splashline:
+                syslinux_conf += "%s\n" % splashline
+            syslinux_conf += "DEFAULT boot\n"
+            syslinux_conf += "LABEL boot\n"
+            kernel = "/" + get_bitbake_var("KERNEL_IMAGETYPE")
+            syslinux_conf += "KERNEL " + kernel + "\n"
+            syslinux_conf += "APPEND label=boot root=%s %s\n" % \
+                             (creator.rootdev, bootloader.append)
+        logger.debug("Writing syslinux config %s/syslinux.cfg", hdddir)
+        cfg = open("%s/hdd/boot/syslinux.cfg" % cr_workdir, "w")
+        cfg.write(syslinux_conf)
+        cfg.close()
+    @classmethod
+    def _do_prepare_syslinux(cls, part, cr_workdir, bootimg_dir,
+                             kernel_dir, native_sysroot):
+        """
+        Called to do the actual content population for a partition i.e. it
+        'prepares' the partition to be incorporated into the image.
+        In this case, prepare content for legacy bios boot partition.
+        """
+        bootimg_dir = cls._get_bootimg_dir(bootimg_dir, 'syslinux')
+        staging_kernel_dir = kernel_dir
+        hdddir = "%s/hdd/boot" % cr_workdir
+        kernel = get_bitbake_var("KERNEL_IMAGETYPE")
+        if get_bitbake_var("INITRAMFS_IMAGE_BUNDLE") == "1":
+            if get_bitbake_var("INITRAMFS_IMAGE"):
+                kernel = "%s-%s.bin" % \
+                    (get_bitbake_var("KERNEL_IMAGETYPE"), get_bitbake_var("INITRAMFS_LINK_NAME"))
+        cmds = ("install -m 0644 %s/%s %s/%s" %
+                (staging_kernel_dir, kernel, hdddir, get_bitbake_var("KERNEL_IMAGETYPE")),
+                "install -m 444 %s/syslinux/ldlinux.sys %s/ldlinux.sys" %
+                (bootimg_dir, hdddir),
+                "install -m 0644 %s/syslinux/vesamenu.c32 %s/vesamenu.c32" %
+                (bootimg_dir, hdddir),
+                "install -m 444 %s/syslinux/libcom32.c32 %s/libcom32.c32" %
+                (bootimg_dir, hdddir),
+                "install -m 444 %s/syslinux/libutil.c32 %s/libutil.c32" %
+                (bootimg_dir, hdddir))
+        for install_cmd in cmds:
+            exec_cmd(install_cmd)
+        du_cmd = "du -bks %s" % hdddir
+        out = exec_cmd(du_cmd)
+        blocks = int(out.split()[0])
+        extra_blocks = part.get_extra_block_count(blocks)
+        if extra_blocks < BOOTDD_EXTRA_SPACE:
+            extra_blocks = BOOTDD_EXTRA_SPACE
+        blocks += extra_blocks
+        logger.debug("Added %d extra blocks to %s to get to %d total blocks",
+                     extra_blocks, part.mountpoint, blocks)
+        # dosfs image, created by mkdosfs
+        bootimg = "%s/boot%s.img" % (cr_workdir, part.lineno)
+        label = part.label if part.label else "boot"
+        dosfs_cmd = "mkdosfs -n %s -i %s -S 512 -C %s %d" % \
+                    (label, part.fsuuid, bootimg, blocks)
+        exec_native_cmd(dosfs_cmd, native_sysroot)
+        mcopy_cmd = "mcopy -i %s -s %s/* ::/" % (bootimg, hdddir)
+        exec_native_cmd(mcopy_cmd, native_sysroot)
+        syslinux_cmd = "syslinux %s" % bootimg
+        exec_native_cmd(syslinux_cmd, native_sysroot)
+        chmod_cmd = "chmod 644 %s" % bootimg
+        exec_cmd(chmod_cmd)
+        du_cmd = "du -Lbks %s" % bootimg
+        out = exec_cmd(du_cmd)
+        bootimg_size = out.split()[0]
+        part.size = int(bootimg_size)
+        part.source_file = bootimg
+    @classmethod
+    def _do_install_syslinux(cls, creator, bootimg_dir,
+                             native_sysroot, full_path):
+        """
+        Called after all partitions have been prepared and assembled into a
+        disk image.  In this case, we install the MBR.
+        """
+        bootimg_dir = cls._get_bootimg_dir(bootimg_dir, 'syslinux')
+        mbrfile = "%s/syslinux/" % bootimg_dir
+        if creator.ptable_format == 'msdos':
+            mbrfile += "mbr.bin"
+        elif creator.ptable_format == 'gpt':
+            mbrfile += "gptmbr.bin"
+        else:
+            raise WicError("Unsupported partition table: %s" %
+                           creator.ptable_format)
+        if not os.path.exists(mbrfile):
+            raise WicError("Couldn't find %s.  If using the -e option, do you "
+                           "have the right MACHINE set in local.conf?  If not, "
+                           "is the bootimg_dir path correct?" % mbrfile)
+        dd_cmd = "dd if=%s of=%s conv=notrunc" % (mbrfile, full_path)
+        exec_cmd(dd_cmd, native_sysroot)
+    @classmethod
+    def _do_configure_grub(cls, part, creator, cr_workdir):
+        hdddir = "%s/hdd" % cr_workdir
+        bootloader = creator.ks.bootloader
+        grub_conf = cls._get_bootloader_config(bootloader, 'grub')
+        grub_prefix_path = get_bitbake_var('GRUB_PREFIX_PATH')
+        if not grub_prefix_path:
+            grub_prefix_path = '/boot/grub'
+        grub_path = "%s/%s" %(hdddir, grub_prefix_path)
+        install_cmd = "install -d %s" % grub_path
+        exec_cmd(install_cmd)
+        if not grub_conf:
+            # Set a default timeout if none specified to avoid
+            # 'None' being the value placed within the configuration
+            # file.
+            if not bootloader.timeout:
+                bootloader.timeout = 500
+            # Set a default kernel params string if none specified
+            # to avoid 'None' being the value placed within the
+            # configuration file.
+            if not bootloader.append:
+                bootloader.append = "rootwait rootfstype=%s " % (part.fstype)
+                bootloader.append += "console=ttyS0,115200 console=tty0"
+            kernel = "/boot/" + get_bitbake_var("KERNEL_IMAGETYPE")
+            grub_conf = 'serial --unit=0 --speed=115200 --word=8 --parity=no --stop=1\n'
+            grub_conf += 'set gfxmode=auto\n'
+            grub_conf += 'set gfxpayload=keep\n\n'
+            grub_conf += 'set default=0\n\n'
+            grub_conf += '# Boot automatically after %d secs.\n' % (bootloader.timeout)
+            grub_conf += 'set timeout=%d\n\n' % (bootloader.timeout)
+            grub_conf += 'menuentry \'default\' {\n'
+            grub_conf += '\tsearch --no-floppy --set=root --file %s\n' % (kernel)
+            grub_conf += '\tprobe --set partuuid --part-uuid ($root)\n'
+            grub_conf += '\tlinux %s root=PARTUUID=$partuuid %s\n}\n' % \
+                            (kernel, bootloader.append)
+        logger.debug("Writing grub config %s/grub.cfg", grub_path)
+        cfg = open("%s/grub.cfg" % grub_path, "w")
+        cfg.write(grub_conf)
+        cfg.close()
+    @classmethod
+    def _do_prepare_grub(cls, part, cr_workdir, oe_builddir,
+                         kernel_dir, rootfs_dir, native_sysroot):
+        """
+        1. Generate embed.cfg that'll later be embedded into core.img.
+           So, that core.img knows where to search for grub.cfg.
+        2. Generate core.img or grub stage 1.5.
+        3. Copy modules into partition.
+        4. Create partition rootfs file.
+        """
+        hdddir = "%s/hdd" % cr_workdir
+        copy_types = [ '*.mod', '*.o', '*.lst' ]
+        builtin_modules = 'boot linux ext2 fat serial part_msdos part_gpt \
+        normal multiboot probe biosdisk msdospart configfile search loadenv test'
+        staging_libdir = cls._get_staging_libdir()
+        grub_format = get_bitbake_var('GRUB_MKIMAGE_FORMAT_PC')
+        if not grub_format:
+            grub_format = 'i386-pc'
+        grub_prefix_path = get_bitbake_var('GRUB_PREFIX_PATH')
+        if not grub_prefix_path:
+            grub_prefix_path = '/boot/grub'
+        grub_path = "%s/%s" %(hdddir, grub_prefix_path)
+        core_img = '%s/grub-bios-core.img' % (kernel_dir)
+        grub_mods_path = '%s/grub/%s' % (staging_libdir, grub_format)
+        # Generate embedded grub config
+        embed_cfg_str = 'search.file %s/grub.cfg root\n' % (grub_prefix_path)
+        embed_cfg_str += 'set prefix=($root)%s\n' % (grub_prefix_path)
+        embed_cfg_str += 'configfile ($root)%s/grub.cfg\n' % (grub_prefix_path)
+        cfg = open('%s/embed.cfg' % (kernel_dir), 'w+')
+        cfg.write(embed_cfg_str)
+        cfg.close()
+        # core.img doesn't get included into boot partition
+        # it's later dd onto the resulting wic image.
+        grub_mkimage = 'grub-mkimage \
+        --prefix=%s \
+        --format=%s \
+        --config=%s/embed.cfg \
+        --directory=%s \
+        --output=%s %s' % \
+        (grub_prefix_path, grub_format, kernel_dir,
+         grub_mods_path, core_img, builtin_modules)
+        exec_native_cmd(grub_mkimage, native_sysroot)
+        # Copy grub modules
+        install_dir = '%s/%s/%s' % (hdddir, grub_prefix_path, grub_format)
+        os.makedirs(install_dir, exist_ok=True)
+        for ctype in copy_types:
+            files = glob('%s/grub/%s/%s' % \
+                (staging_libdir, grub_format, ctype))
+            for file in files:
+                shutil.copy2(file, install_dir, follow_symlinks=True)
+        # Create boot partition
+        logger.debug('Prepare partition using rootfs in %s', hdddir)
+        part.prepare_rootfs(cr_workdir, oe_builddir, hdddir,
+                            native_sysroot, False)
+    @classmethod
+    def _do_install_grub(cls, creator, kernel_dir,
+                         native_sysroot, full_path):
+        core_img = '%s/grub-bios-core.img' % (kernel_dir)
+        staging_libdir = cls._get_staging_libdir()
+        grub_format = get_bitbake_var('GRUB_MKIMAGE_FORMAT_PC')
+        if not grub_format:
+            grub_format = 'i386-pc'
+        boot_img = '%s/grub/%s/boot.img' % (staging_libdir, grub_format)
+        if not os.path.exists(boot_img):
+            raise WicError("Couldn't find %s. Did you include "
+                           "do_image_wic[depends] += \"grub:do_populate_sysroot\" "
+                           "in your image recipe" % boot_img)
+        # Install boot.img or grub stage 1
+        dd_cmd = "dd if=%s of=%s conv=notrunc bs=1 seek=0 count=440" % (boot_img, full_path)
+        exec_cmd(dd_cmd, native_sysroot)
+        if creator.ptable_format == 'msdos':
+            # Install core.img or grub stage 1.5
+            dd_cmd = "dd if=%s of=%s conv=notrunc bs=1 seek=512" % (core_img, full_path)
+            exec_cmd(dd_cmd, native_sysroot)
+        else:
+            raise WicError("Unsupported partition table: %s" %
+                           creator.ptable_format)
diff --git a/scripts/lib/wic/plugins/source/extra_partition.py b/scripts/lib/wic/plugins/source/extra_partition.py
new file mode 100644
index 0000000000..d370b0107e
--- /dev/null
+++ b/scripts/lib/wic/plugins/source/extra_partition.py
@@ -0,0 +1,134 @@
+import logging
+import os
+import re
+from glob import glob
+from wic import WicError
+from wic.pluginbase import SourcePlugin
+from wic.misc import exec_cmd, get_bitbake_var
+logger = logging.getLogger('wic')
+class ExtraPartitionPlugin(SourcePlugin):
+    """
+    Populates an extra partition with files listed in the IMAGE_EXTRA_PARTITION_FILES
+    BitBake variable. Files should be deployed to the DEPLOY_DIR_IMAGE directory.
+    The plugin supports:
+    - Glob pattern matching for file selection.
+    - File renaming.
+    - Suffixes to specify the target partition (by label, UUID, or partname),
+      enabling multiple extra partitions to coexist.
+    For example:
+        IMAGE_EXTRA_PARTITION_FILES_label-foo = "bar.conf;foo.conf"
+        IMAGE_EXTRA_PARTITION_FILES_uuid-e7d0824e-cda3-4bed-9f54-9ef5312d105d = "bar.conf;foobar.conf"
+        IMAGE_EXTRA_PARTITION_FILES = "foo/*"
+        WICVARS:append = "\
+            IMAGE_EXTRA_PARTITION_FILES_label-foo \
+            IMAGE_EXTRA_PARTITION_FILES_uuid-e7d0824e-cda3-4bed-9f54-9ef5312d105d \
+        "
+    """
+    name = 'extra_partition'
+    image_extra_partition_files_var_name = 'IMAGE_EXTRA_PARTITION_FILES'
+    @classmethod
+    def do_configure_partition(cls, part, source_params, cr, cr_workdir,
+                             oe_builddir, bootimg_dir, kernel_dir,
+                             native_sysroot):
+        """
+        Called before do_prepare_partition(), list the files to copy
+        """
+        extradir = "%s/extra.%d" % (cr_workdir, part.lineno)
+        install_cmd = "install -d %s" % extradir
+        exec_cmd(install_cmd)
+        if not kernel_dir:
+            kernel_dir = get_bitbake_var("DEPLOY_DIR_IMAGE")
+            if not kernel_dir:
+                raise WicError("Couldn't find DEPLOY_DIR_IMAGE, exiting")
+        extra_files = None
+        for (fmt, id) in (("_uuid-%s", part.uuid), ("_label-%s", part.label), ("_part-name-%s", part.part_name), (None, None)):
+            if fmt:
+                var = fmt % id
+            else:
+                var = ""
+            extra_files = get_bitbake_var(cls.image_extra_partition_files_var_name + var)
+            if extra_files is not None:
+                break
+        if extra_files is None:
+            raise WicError('No extra files defined, %s unset for entry #%d' % (cls.image_extra_partition_files_var_name, part.lineno))
+        logger.info('Extra files: %s', extra_files)
+        # list of tuples (src_name, dst_name)
+        deploy_files = []
+        for src_entry in re.findall(r'[\w;\-\./\*]+', extra_files):
+            if ';' in src_entry:
+                dst_entry = tuple(src_entry.split(';'))
+                if not dst_entry[0] or not dst_entry[1]:
+                    raise WicError('Malformed extra file entry: %s' % src_entry)
+            else:
+                dst_entry = (src_entry, src_entry)
+            logger.debug('Destination entry: %r', dst_entry)
+            deploy_files.append(dst_entry)
+        cls.install_task = [];
+        for deploy_entry in deploy_files:
+            src, dst = deploy_entry
+            if '*' in src:
+                # by default install files under their basename
+                entry_name_fn = os.path.basename
+                if dst != src:
+                    # unless a target name was given, then treat name
+                    # as a directory and append a basename
+                    entry_name_fn = lambda name: \
+                                    os.path.join(dst,
+                                                 os.path.basename(name))
+                srcs = glob(os.path.join(kernel_dir, src))
+                logger.debug('Globbed sources: %s', ', '.join(srcs))
+                for entry in srcs:
+                    src = os.path.relpath(entry, kernel_dir)
+                    entry_dst_name = entry_name_fn(entry)
+                    cls.install_task.append((src, entry_dst_name))
+            else:
+                cls.install_task.append((src, dst))
+    @classmethod
+    def do_prepare_partition(cls, part, source_params, cr, cr_workdir,
+                             oe_builddir, bootimg_dir, kernel_dir,
+                             rootfs_dir, native_sysroot):
+        """
+        Called to do the actual content population for a partition i.e. it
+        'prepares' the partition to be incorporated into the image.
+        In this case, we copies all files listed in IMAGE_EXTRA_PARTITION_FILES variable.
+        """
+        extradir = "%s/extra.%d" % (cr_workdir, part.lineno)
+        if not kernel_dir:
+            kernel_dir = get_bitbake_var("DEPLOY_DIR_IMAGE")
+            if not kernel_dir:
+                raise WicError("Couldn't find DEPLOY_DIR_IMAGE, exiting")
+        for task in cls.install_task:
+            src_path, dst_path = task
+            logger.debug('Install %s as %s', src_path, dst_path)
+            install_cmd = "install -m 0644 -D %s %s" \
+                          % (os.path.join(kernel_dir, src_path),
+                             os.path.join(extradir, dst_path))
+            exec_cmd(install_cmd)
+        logger.debug('Prepare extra partition using rootfs in %s', extradir)
+        part.prepare_rootfs(cr_workdir, oe_builddir, extradir,
+                            native_sysroot, False)
diff --git a/scripts/lib/wic/plugins/source/isoimage-isohybrid.py b/scripts/lib/wic/plugins/source/isoimage_isohybrid.py
index 607356ad13..5d42eb5d3e 100644
--- a/scripts/lib/wic/plugins/source/isoimage-isohybrid.py
+++ b/scripts/lib/wic/plugins/source/isoimage_isohybrid.py
@@ -4,7 +4,7 @@
 # SPDX-License-Identifier: GPL-2.0-only
 #
 # DESCRIPTION
-# This implements the 'isoimage-isohybrid' source plugin class for 'wic'
+# This implements the 'isoimage_isohybrid' source plugin class for 'wic'
 #
 # AUTHORS
 # Mihaly Varga <mihaly.varga (at] ni.com>
@@ -35,7 +35,7 @@ class IsoImagePlugin(SourcePlugin):
    bootloader files.
    Example kickstart file:
-    part /boot --source isoimage-isohybrid --sourceparams="loader=grub-efi, \\
+    part /boot --source isoimage_isohybrid --sourceparams="loader=grub-efi, \\
    image_name= IsoImage" --ondisk cd --label LIVECD
    bootloader  --timeout=10  --append=" "
@@ -45,7 +45,7 @@ class IsoImagePlugin(SourcePlugin):
    extension added by direct imeger plugin) and a file named IsoImage-cd.iso
    """
-    name = 'isoimage-isohybrid'
+    name = 'isoimage_isohybrid'
    @classmethod
    def do_configure_syslinux(cls, creator, cr_workdir):
@@ -340,10 +340,10 @@ class IsoImagePlugin(SourcePlugin):
                    cls.do_configure_grubefi(part, creator, target_dir)
            else:
-                raise WicError("unrecognized bootimg-efi loader: %s" %
+                raise WicError("unrecognized bootimg_efi loader: %s" %
                               source_params['loader'])
        except KeyError:
-            raise WicError("bootimg-efi requires a loader, none specified")
+            raise WicError("bootimg_efi requires a loader, none specified")
        # Create efi.img that contains bootloader files for EFI booting
        # if ISODIR didn't exist or didn't contains it
diff --git a/scripts/lib/wic/plugins/source/rootfs.py b/scripts/lib/wic/plugins/source/rootfs.py
index c990143c0d..06fce06bb1 100644
--- a/scripts/lib/wic/plugins/source/rootfs.py
+++ b/scripts/lib/wic/plugins/source/rootfs.py
@@ -41,7 +41,7 @@ class RootfsPlugin(SourcePlugin):
        # Disallow climbing outside of parent directory using '..',
        # because doing so could be quite disastrous (we will delete the
        # directory, or modify a directory outside OpenEmbedded).
-        full_path = os.path.realpath(os.path.join(rootfs_dir, path))
+        full_path = os.path.abspath(os.path.join(rootfs_dir, path))
        if not full_path.startswith(os.path.realpath(rootfs_dir)):
            logger.error("%s: Must point inside the rootfs: %s" % (cmd, path))
            sys.exit(1)
diff --git a/scripts/lz4c b/scripts/lz4c
new file mode 100755
index 0000000000..466fc349e0
--- /dev/null
+++ b/scripts/lz4c
@@ -0,0 +1,26 @@
+#!/usr/bin/env bash
+# Wrapper to intercept legacy lz4c arguments and convert to lz4.
+args=()
+while [ $# -ne 0 ]; do
+    case ${1} in
+        -c0)
+            args+=(-0)
+            ;;
+        -c1)
+            args+=(-9)
+            ;;
+        -c2|-hc)
+            args+=(-12)
+            ;;
+        -y)
+            args+=(--force)
+            ;;
+        *)
+            args+=("${1}")
+            ;;
+    esac
+    shift
+done
+exec lz4 "${args[@]}"
diff --git a/scripts/makefile-getvar b/scripts/makefile-getvar
new file mode 100755
index 0000000000..4a07055e68
--- /dev/null
+++ b/scripts/makefile-getvar
@@ -0,0 +1,24 @@
+#! /bin/sh
+# Get a variable's value from a makefile:
+#
+# $ makefile-getvar Makefile VARIABLE VARIABLE ...
+#
+# If multiple variables are specified, they will be printed one per line.
+#
+# SPDX-FileCopyrightText: Copyright 2024 Arm Limited and/or its affiliates <open-source-office@arm.com>
+# SPDX-License-Identifier: GPL-2.0-only
+set -eu
+MAKEFILE=$1
+shift
+for VARIABLE in $*; do
+        make -f - $VARIABLE.var <<EOF
+include $MAKEFILE
+%.var:
+        @echo \$(\$*)
+EOF
+done
diff --git a/scripts/oe-build-perf-report b/scripts/oe-build-perf-report
index 266700d294..a36f3c1bca 100755
--- a/scripts/oe-build-perf-report
+++ b/scripts/oe-build-perf-report
@@ -336,10 +336,16 @@ def print_html_report(data, id_comp, buildstats):
                test_i = test_data['tests'][test]
                meas_i = test_i['measurements'][meas]
                commit_num = get_data_item(meta, 'layers.meta.commit_count')
+                commit = get_data_item(meta, 'layers.meta.commit')
                # Add start_time for both test measurement types of sysres and disk usage
-                start_time = test_i['start_time'][0]
+                try:
+                    # Use the commit_time if available, falling back to start_time
+                    start_time = get_data_item(meta, 'layers.meta.commit_time')
+                except KeyError:
+                    start_time = test_i['start_time'][0]
                samples.append(measurement_stats(meas_i, '', start_time))
                samples[-1]['commit_num'] = commit_num
+                samples[-1]['commit'] = commit
            absdiff = samples[-1]['val_cls'](samples[-1]['mean'] - samples[id_comp]['mean'])
            reldiff = absdiff * 100 / samples[id_comp]['mean']
diff --git a/scripts/oe-selftest b/scripts/oe-selftest
index 18ac0f5869..afc48d9905 100755
--- a/scripts/oe-selftest
+++ b/scripts/oe-selftest
@@ -18,8 +18,6 @@
 import os
 import sys
-import argparse
-import logging
 scripts_path = os.path.dirname(os.path.realpath(__file__))
 lib_path = scripts_path + '/lib'
diff --git a/scripts/oe-setup-build b/scripts/oe-setup-build
index c0476992a2..edbcd48355 100755
--- a/scripts/oe-setup-build
+++ b/scripts/oe-setup-build
@@ -18,8 +18,7 @@ def makebuildpath(topdir, template):
 def discover_templates(layers_file):
    if not os.path.exists(layers_file):
-        print("List of layers {} does not exist; were the layers set up using the setup-layers script?".format(layers_file))
+        raise Exception("List of layers {} does not exist; were the layers set up using the setup-layers script or bitbake-setup tool?".format(layers_file))
-        return None
    templates = []
    layers_list = json.load(open(layers_file))["layers"]
@@ -77,8 +76,7 @@ def find_template(template_name, templates):
        for t in templates:
            if t["templatename"] == template_name:
                return t
-        print("Configuration {} is not one of {}, please try again.".format(tempalte_name, [t["templatename"] for t in templates]))
+        raise Exception("Configuration {} is not one of {}, please try again.".format(template_name, [t["templatename"] for t in templates]))
-        return None
 def setup_build_env(args):
    templates = discover_templates(args.layerlist)
@@ -91,7 +89,7 @@ def setup_build_env(args):
    builddir = args.b if args.b else template["buildpath"]
    no_shell = args.no_shell
    coredir = os.path.abspath(os.path.join(os.path.dirname(os.path.realpath(__file__)), '..'))
-    cmd_base = ". {} {}".format(os.path.join(coredir, 'oe-init-build-env'), os.path.abspath(builddir))
+    cmd_base = "cd {}\nset {}\n. ./oe-init-build-env\n".format(coredir, os.path.abspath(builddir))
    initbuild = os.path.join(builddir, 'init-build-env')
    if not os.path.exists(initbuild):
@@ -102,9 +100,9 @@ def setup_build_env(args):
    cmd = "TEMPLATECONF={} {}".format(template["templatepath"], cmd_base)
    if not no_shell:
-        cmd = cmd + " && {}".format(os.environ['SHELL'])
+        cmd = cmd + " && {}".format(os.environ.get('SHELL','bash'))
    print("Running:", cmd)
-    subprocess.run(cmd, shell=True, executable=os.environ['SHELL'])
+    subprocess.run(cmd, shell=True, executable=os.environ.get('SHELL','bash'))
 parser = argparse.ArgumentParser(description="A script that discovers available build configurations and sets up a build environment based on one of them. Run without arguments to choose one interactively.")
 parser.add_argument("--layerlist", default=defaultlayers(), help='Where to look for available layers (as written out by setup-layers script) (default is {}).'.format(defaultlayers()))
diff --git a/scripts/oe-test b/scripts/oe-test
index 55985b0b24..3a00369e01 100755
--- a/scripts/oe-test
+++ b/scripts/oe-test
@@ -7,14 +7,18 @@
 # SPDX-License-Identifier: MIT
 #
-import os
-import sys
 import argparse
+import glob
 import logging
+import os
+import sys
 scripts_path = os.path.dirname(os.path.realpath(__file__))
-lib_path = scripts_path + '/lib'
+lib_path = os.path.join(scripts_path, 'lib')
-sys.path = sys.path + [lib_path]
+sys.path.append(lib_path)
+meta_lib_paths = glob.glob(scripts_path + '/*/lib', recursive=True)
+for p in meta_lib_paths:
+    sys.path.append(p)
 import argparse_oe
 import scriptutils
diff --git a/scripts/patchtest b/scripts/patchtest
index 0be7062dc2..9218db232a 100755
--- a/scripts/patchtest
+++ b/scripts/patchtest
@@ -9,12 +9,12 @@
 # SPDX-License-Identifier: GPL-2.0-only
 #
-import sys
+import json
-import os
-import unittest
 import logging
+import os
+import sys
 import traceback
-import json
+import unittest
 # Include current path so test cases can see it
 sys.path.insert(0, os.path.dirname(os.path.realpath(__file__)))
@@ -22,16 +22,17 @@ sys.path.insert(0, os.path.dirname(os.path.realpath(__file__)))
 # Include patchtest library
 sys.path.insert(0, os.path.join(os.path.dirname(os.path.realpath(__file__)), '../meta/lib/patchtest'))
-from data import PatchTestInput
+from patchtest_parser import PatchtestParser
 from repo import PatchTestRepo
-import utils
+logger = logging.getLogger("patchtest")
-logger = utils.logger_create('patchtest')
+loggerhandler = logging.StreamHandler()
+loggerhandler.setFormatter(logging.Formatter("%(message)s"))
+logger.addHandler(loggerhandler)
+logger.setLevel(logging.INFO)
 info = logger.info
 error = logger.error
-import repo
 def getResult(patch, mergepatch, logfile=None):
    class PatchTestResult(unittest.TextTestResult):
@@ -46,10 +47,10 @@ def getResult(patch, mergepatch, logfile=None):
        def startTestRun(self):
            # let's create the repo already, it can be used later on
            repoargs = {
-                'repodir': PatchTestInput.repodir,
+                "repodir": PatchtestParser.repodir,
-                'commit' : PatchTestInput.basecommit,
+                "commit": PatchtestParser.basecommit,
-                'branch' : PatchTestInput.basebranch,
+                "branch": PatchtestParser.basebranch,
-                'patch'  : patch,
+                "patch": patch,
            }
            self.repo_error    = False
@@ -57,7 +58,7 @@ def getResult(patch, mergepatch, logfile=None):
            self.test_failure  = False
            try:
-                self.repo = PatchTestInput.repo = PatchTestRepo(**repoargs)
+                self.repo = PatchtestParser.repo = PatchTestRepo(**repoargs)
            except:
                logger.error(traceback.print_exc())
                self.repo_error = True
@@ -128,7 +129,11 @@ def _runner(resultklass, prefix=None):
        loader.testMethodPrefix = prefix
    # create the suite with discovered tests and the corresponding runner
-    suite = loader.discover(start_dir=PatchTestInput.testdir, pattern=PatchTestInput.pattern, top_level_dir=PatchTestInput.topdir)
+    suite = loader.discover(
+        start_dir=PatchtestParser.testdir,
+        pattern=PatchtestParser.pattern,
+        top_level_dir=PatchtestParser.topdir,
+    )
    ntc = suite.countTestCases()
    # if there are no test cases, just quit
@@ -160,24 +165,31 @@ def run(patch, logfile=None):
    postmerge_resultklass = getResult(patch, True, logfile)
    postmerge_result = _runner(postmerge_resultklass, 'test')
-    print('----------------------------------------------------------------------\n')
+    print_result_message(premerge_result, postmerge_result)
-    if premerge_result == 2 and postmerge_result == 2:
-        logger.error('patchtest: No test cases found - did you specify the correct suite directory?')
-    if premerge_result == 1 or postmerge_result == 1:
-        logger.error('WARNING: patchtest: At least one patchtest caused a failure or an error - please check https://wiki.yoctoproject.org/wiki/Patchtest for further guidance')
-    else:
-        logger.info('OK: patchtest: All patchtests passed')
-    print('----------------------------------------------------------------------\n')
    return premerge_result or postmerge_result
+def print_result_message(preresult, postresult):
+    print("----------------------------------------------------------------------\n")
+    if preresult == 2 and postresult == 2:
+        logger.error(
+            "patchtest: No test cases found - did you specify the correct suite directory?"
+        )
+    if preresult == 1 or postresult == 1:
+        logger.error(
+            "WARNING: patchtest: At least one patchtest caused a failure or an error - please check https://wiki.yoctoproject.org/wiki/Patchtest for further guidance"
+        )
+    else:
+        logger.info("OK: patchtest: All patchtests passed")
+    print("----------------------------------------------------------------------\n")
 def main():
    tmp_patch = False
-    patch_path = PatchTestInput.patch_path
+    patch_path = PatchtestParser.patch_path
-    log_results = PatchTestInput.log_results
+    log_results = PatchtestParser.log_results
    log_path = None
    patch_list = None
-    git_status = os.popen("(cd %s && git status)" % PatchTestInput.repodir).read()
+    git_status = os.popen("(cd %s && git status)" % PatchtestParser.repodir).read()
    status_matches = ["Changes not staged for commit", "Changes to be committed"]
    if any([match in git_status for match in status_matches]):
        logger.error("patchtest: there are uncommitted changes in the target repo that would be overwritten. Please commit or restore them before running patchtest")
@@ -212,16 +224,16 @@ def main():
 if __name__ == '__main__':
    ret = 1
-    # Parse the command line arguments and store it on the PatchTestInput namespace
+    # Parse the command line arguments and store it on the PatchtestParser namespace
-    PatchTestInput.set_namespace()
+    PatchtestParser.set_namespace()
    # set debugging level
-    if PatchTestInput.debug:
+    if PatchtestParser.debug:
        logger.setLevel(logging.DEBUG)
    # if topdir not define, default it to testdir
-    if not PatchTestInput.topdir:
+    if not PatchtestParser.topdir:
-        PatchTestInput.topdir = PatchTestInput.testdir
+        PatchtestParser.topdir = PatchtestParser.testdir
    try:
        ret = main()
diff --git a/scripts/patchtest.README b/scripts/patchtest.README
index 76b5fcdb6d..fc1267f053 100644
--- a/scripts/patchtest.README
+++ b/scripts/patchtest.README
@@ -3,62 +3,105 @@
 ## Introduction
 Patchtest is a test framework for community patches based on the standard
-unittest python module. As input, it needs tree elements to work properly:
+unittest python module. As input, it needs three elements to work properly:
-a patch in mbox format (either created with `git format-patch` or fetched
-from 'patchwork'), a test suite and a target repository.
+- one or more patches in separate, mbox-formated files
+- a test suite
+- a target repository
 The first test suite intended to be used with patchtest is found in the
-openembedded-core repository [1] targeted for patches that get into the
+openembedded-core repository [1], targeted for patches that get into the
 openembedded-core mailing list [2]. This suite is also intended as a
 baseline for development of similar suites for other layers as needed.
-Patchtest can either run on a host or a guest machine, depending on which
+Patchtest can either run on a host or a guest machine, depending on
-environment the execution needs to be done. If you plan to test your own patches
+which environment you prefer. If you plan to test your own patches (a
-(a good practice before these are sent to the mailing list), the easiest way is
+good practice before these are sent to the mailing list), the easiest
-to install and execute on your local host; in the other hand, if automatic
+way is to install and execute on your local host; on the other hand, if
-testing is intended, the guest method is strongly recommended. The guest
+automatic testing is intended, the guest method is strongly recommended.
-method requires the use of the patchtest layer, in addition to the tools
+The guest method requires the use of the meta-patchtest layer, in
-available in oe-core: https://git.yoctoproject.org/patchtest/
+addition to the tools available in oe-core:
+https://git.yoctoproject.org/meta-patchtest/
 ## Installation
-As a tool for use with the Yocto Project, the [quick start guide](https://docs.yoctoproject.org/brief-yoctoprojectqs/index.html) 
+Patchtest checks patches which are expected to be applied to
-contains the necessary prerequisites for a basic project. In addition,
+Yocto layers. Therefore, familiarity with the Yocto Project, its
-patchtest relies on the following Python modules:
+functionality, and image-build processes is assumed. Otherwise the
+[quick start guide](https://docs.yoctoproject.org/brief-yoctoprojectqs/index.html)
- boto3 (for sending automated results emails only)
+contains the necessary information.
- git-pw>=2.5.0
- jinja2
+As a Python application, the recommended way it should be installed
- pylint
+(following Python best practices) is to use a virtual environment. A
- pyparsing>=3.0.9
+Python virtual environment provides a convenient sandbox into which its
- unidiff
+requirements can also be installed with out affecting a user's entire
+system at large. Patchtest makes use of a test suite found in oe-core,
-These can be installed by running `pip install -r
+so it needs to be available as well.
-meta/lib/patchtest/requirements.txt`. Note that git-pw is not
-automatically added to the user's PATH; by default, it is installed at
+For example, to install patchtest into a Python virtual environment
-~/.local/bin/git-pw.
+called "patchtest.venv" located at some/where in your filesystem:
-For git-pw (and therefore scripts such as patchtest-get--series) to work, you need
+    $ mkdir -p some/where
-to provide a Patchwork instance in your user's .gitconfig, like so (the project
+    $ cd some/where
-can be specified using the --project argument):
+    $ mkdir yocto
+    $ pushd yocto
+    $ git clone https://git.openembedded.org/openembedded-core
+    $ git clone https://git.openembedded.org/bitbake
+    $ git clone https://git.yoctoproject.org/meta-patchtest
+    $ popd
+    $ . yocto/openembedded-core/oe-init-build-env build yocto/bitbake
+    $ cd ..
+    $ python3 -m venv patchtest.venv
+    $ . patchtest.venv/bin/activate
+    (patchtest.venv) $ pip install -r yocto/openembedded-core/meta/lib/patchtest/requirements.txt
+In the above list of cloned repositories, the meta-patchtest layer is
+only needed if you intend to use patchtest in "guest" mode. Also the
+oe-core + bitbake clones can be replaced with poky instead.
+If "guest" mode will be used, the meta-patchtest layer needs to be added
+to the conf/bblayers.conf file generated above.
+If you would like to run the patchtest selftest found in oe-core, the
+openembedded-core/meta-selftest (or poky/meta-selftest, if using poky)
+layer also needs to be added to bblayers.conf.
+Once the installation is done, your directory layout will look like:
+    .
+    ├── build
+    │   └── conf
+    ├── yocto
+    │   ├── bitbake
+    │   ├── meta-patchtest
+    │   └── openembedded-core
+    └── patchtest.venv
+        ├── bin
+        ├── include
+        ├── lib
+        ├── lib64 -> lib
+        ├── pyvenv.cfg
+        └── share
+For git-pw (and therefore scripts such as patchtest-get-series) to work, you need
+to provide a Patchwork instance in your user's .gitconfig, like so (alternatively
+the project can be specified using the --project argument to git-pw on its
+cmdline):
    git config --global pw.server "https://patchwork.yoctoproject.org/api/1.2/"
-To work with patchtest, you should have the following repositories cloned:
-1. https://git.openembedded.org/openembedded-core/ (or https://git.yoctoproject.org/poky/)
-2. https://git.openembedded.org/bitbake/ (if not using poky)
-3. https://git.yoctoproject.org/patchtest (if using guest mode)
 ## Usage
 ### Obtaining Patches
-Patch files can be obtained directly from cloned repositories using `git
+Separate, mbox-formatted patch files can be obtained in a number of
-format-patch -N` (where N is the number of patches starting from HEAD to
+ways:
-generate). git-pw can also be used with filters for users, patch/series IDs,
-and timeboxes if specific patches are desired. For more information, see the
+    - using b4 to obtain patches from a lore server
-git-pw [documentation](https://patchwork.readthedocs.io/projects/git-pw/en/latest/).
+    - using git-pw to obtain patches from a patchwork server
+    - using "git format-patch ..." to create patches from a git
+      repository
+    - using an email program, such as mutt or thunderbird, to obtain
+      patches from a mailing list
 Alternatively, `scripts/patchtest-get-series` can be used to pull mbox files from
 the Patchwork instance configured previously in .gitconfig. It uses a log file
@@ -69,29 +112,111 @@ the target project, but these parameters can be configured using the `--limit`,
 `--interval`, and `--project` arguments respectively. For more information, run
 `patchtest-get-series -h`.
+#### git-pw
+git-pw can be used with filters for users, patch/series IDs, and
+timeboxes if specific patches are desired. For more information, see the
+git-pw [documentation](https://patchwork.readthedocs.io/projects/git-pw/en/latest/).
+For example, to download a single patch from the Yocto Project's
+Patchwork server (and to demonstrate not having modified ~/.gitconfig):
+    (patchtest.venv) $ mkdir gawk
+    (patchtest.venv) $ git-pw --server https://patchwork.yoctoproject.org/api/1.2/ --project oe-core patch download --mbox 70101 gawk/
+To download a series, for example, try:
+    (patchtest.venv) $ mkdir clang
+    (patchtest.venv) $ git-pw --server https://patchwork.yoctoproject.org/api/1.2 --project oe-core series download --separate 38107 clang/
+#### git format-patch
+Patch files can be obtained directly from a git repository using `git
+format-patch -N` (where N is the number of patches starting from HEAD to
+generate) or using any other way of specifying a range of commit SHAs to
+git.
+This method would be the most likely used when testing patches in local
+mode before emailing them for review.
+#### b4
+In order to use b4, it needs to be installed. Fortunately it is a Python
+program that is hosted on pypi and can easily be installed into the same
+Python virtual environment that was created to run patchwork:
+    (patchtest.venv) $ pip install b4
+    (patchtest.venv) $ b4 --version
+    0.14.2
+To fetch the same single patch using b4 that was fetched with git-pw
+earlier, use:
+    (patchtest.venv) $ mkdir gawk-2
+    (patchtest.venv) $ b4 am -o gawk-2 https://lore.kernel.org/openembedded-core/20250912200740.2873851-1-Randy.MacLeod@windriver.com
+Fetching a patch series with b4 is a little more involved since b4 will
+create one mbox file with all the patches in the series in it. Given an
+mbox file with more than one patch in it, patchtest will only test the
+first one. So there needs to be a separate step to break apart the
+multiple patches into separate files:
+    (patchtest.venv) $ mkdir clang-2
+    (patchtest.venv) $ b4 am -o ross https://lore.kernel.org/openembedded-core/20250914133258.2625735-1-ross.burton@arm.com
+    (patchtest.venv) $ cat clang-2/v2_20250914_ross_burton_clang_improve_opt_viewer_packageconfig.mbx | formail -ds sh -c 'cat > ross/msg.$FILENO'
+NOTE: the formail utility is part of the procmail package for most Linux
+      distributions.
+#### mail user agents (MUA)
+Most email applications have a way of saving patch emails. Details for
+each MUA is beyond the scope of this document, but it is possible in
+most cases. The only catch is that each patch has to be saved in mbox
+format in its own individual file. Some client applications prefer to
+save emails in the Maildir format, and some programs will save a set of
+patches into one mbox file. The formail program from the procmail
+package is useful for manipulating and converting between formats and
+storage formats.
 ### Host Mode
-To run patchtest on the host, do the following:
+To run patchtest in "host" mode, do the following:
+1. Using openembedded-core or poky, do the following if re-using the
+   installation given in the installation procedure above:
+    $ . yocto/openembedded-core/oe-init-build-env build yocto/bitbake
+   or
-1. In openembedded-core/poky, do `source oe-init-build-env`
+    $ . yocto/poky/oe-init-build-env
-2. Generate patch files from the target repository by doing `git-format patch -N`,
-   where N is the number of patches starting at HEAD, or by using git-pw
-   or patchtest-get-series
-3. Run patchtest on a patch file by doing the following:
-        patchtest --patch /path/to/patch/file
+2. Activate the Python virtual environment that was created using the
+   steps from the installation procedure given above:
+    $ . patchtest.venv/bin/activate
+3. Obtain one or more patches (see section above)
+4. Run patchtest on a patch file by doing the following:
+        (patchtest.venv) $ patchtest --patch /path/to/patch/file
    or, if you have stored the patch files in a directory, do:
-        patchtest --directory /path/to/patch/directory
+        (patchtest.venv) $ patchtest --directory /path/to/patch/directory
-    For example, to test `master-gcc-Fix--fstack-protector-issue-on-aarch64.patch` against the oe-core test suite:
+    For example, to test
+    `master-gcc-Fix--fstack-protector-issue-on-aarch64.patch` against the
+    oe-core test suite:
        
-        patchtest --patch master-gcc-Fix--fstack-protector-issue-on-aarch64.patch
+        (patchtest.venv) $ patchtest --patch master-gcc-Fix--fstack-protector-issue-on-aarch64.patch
-    If you want to use a different test suite or target repository, you can use the --testdir and --repodir flags:
+    If you want to use a different test suite or target repository, you
+    can use the --testdir and --repodir flags:
    
-        patchtest --patch /path/to/patch/file --repodir /path/to/repo --testdir /path/to/test/dir
+        (patchtest.venv) $ patchtest --patch /path/to/patch/file --repodir /path/to/repo --testdir /path/to/test/dir
 ### Guest Mode
@@ -103,8 +228,8 @@ from the mailing lists. When executed this way, the test process is
 essentially running random code from the internet and could be
 catastrophic if malicious bits or even poorly-handled edge cases aren't
 protected against. In order to use this mode, the
-https://git.yoctoproject.org/patchtest/ repository must be cloned and
+https://git.yoctoproject.org/meta-patchtest/ repository must be cloned
-the meta-patchtest layer added to bblayers.conf.
+and added to bblayers.conf.
 The general flow of guest mode is:
@@ -123,7 +248,7 @@ The general flow of guest mode is:
   -device virtio-9p-pci,fsdev=test_mount,mount_tag=test_mount -smp 4 -m
   2048"`
-Patchtest runs as an initscript for the core-image-patchtest image and
+Patchtest is run by an initscript for the core-image-patchtest image and
 shuts down after completion, so there is no input required from a user
 during operation. Unlike in host mode, the guest is designed to
 automatically generate test result files, in the same directory as the
@@ -131,6 +256,29 @@ targeted patch files but with .testresult as an extension. These contain
 the entire output of the patchtest run for each respective pass,
 including the PASS, FAIL, and SKIP indicators for each test run.
+### Running Patchtest Selftests
+Patchtest also includes selftests, which are currently in the form of
+several contrived patch files and a runner script found in
+`meta/lib/patchtest/selftest/`. In order to run these, the
+`meta-selftest` layer must be added to bblayers.conf. It is also
+recommended to set BB_SERVER_TIMEOUT (and thus enable memory-resident
+bitbake) in local.conf to reduce runtime, as the bitbake startup process
+will otherwise add to it significantly when restarted for each test
+patch.
+If you have setup a Python virtual environment and sourced the
+oe-init-build-env script to run patchtest following the directions
+provided above in the "Installation" section, and you have added the
+meta-selftest layer (from oe-core or poky) to your build, running the
+patchtest selftest is as simple as:
+    (patchtest.venv) $ yocto/openembedded-core/meta/lib/patchtest/selftest/selftest
+or:
+    (patchtest.venv) $ yocto/poky/meta/lib/patchtest/selftest/selftest
 ## Contributing
 The yocto mailing list (openembedded-core@lists.openembedded.org) is used for questions,
diff --git a/scripts/pull-sdpx-licenses.py b/scripts/pull-sdpx-licenses.py
new file mode 100755
index 0000000000..597a62133f
--- /dev/null
+++ b/scripts/pull-sdpx-licenses.py
@@ -0,0 +1,101 @@
+#! /usr/bin/env python3
+#
+# Copyright OpenEmbedded Contributors
+#
+# SPDX-License-Identifier: GPL-2.0-only
+import argparse
+import json
+import sys
+import urllib.request
+from pathlib import Path
+TOP_DIR = Path(__file__).parent.parent
+def main():
+    parser = argparse.ArgumentParser(
+        description="Update SPDX License files from upstream"
+    )
+    parser.add_argument(
+        "-v",
+        "--version",
+        metavar="MAJOR.MINOR[.MICRO]",
+        help="Pull specific version of License list instead of latest",
+    )
+    parser.add_argument(
+        "--overwrite",
+        action="store_true",
+        help="Update existing license file text with upstream text",
+    )
+    parser.add_argument(
+        "--deprecated",
+        action="store_true",
+        help="Update deprecated licenses",
+    )
+    parser.add_argument(
+        "--dest",
+        type=Path,
+        default=TOP_DIR / "meta" / "files" / "common-licenses",
+        help="Write licenses to directory DEST. Default is %(default)s",
+    )
+    args = parser.parse_args()
+    if args.version:
+        version = f"v{args.version}"
+    else:
+        # Fetch the latest release
+        req = urllib.request.Request(
+            "https://api.github.com/repos/spdx/license-list-data/releases/latest"
+        )
+        req.add_header("X-GitHub-Api-Version", "2022-11-28")
+        req.add_header("Accept", "application/vnd.github+json")
+        with urllib.request.urlopen(req) as response:
+            data = json.load(response)
+            version = data["tag_name"]
+    print(f"Pulling SPDX license list version {version}")
+    req = urllib.request.Request(
+        f"https://raw.githubusercontent.com/spdx/license-list-data/{version}/json/licenses.json"
+    )
+    with urllib.request.urlopen(req) as response:
+        spdx_licenses = json.load(response)
+    with (TOP_DIR / "meta" / "files" / "spdx-licenses.json").open("w") as f:
+        json.dump(spdx_licenses, f, sort_keys=True, indent=2)
+    total_count = len(spdx_licenses["licenses"])
+    updated = 0
+    for idx, lic in enumerate(spdx_licenses["licenses"]):
+        lic_id = lic["licenseId"]
+        print(f"[{idx + 1} of {total_count}] ", end="")
+        dest_license_file = args.dest / lic_id
+        if dest_license_file.is_file() and not args.overwrite:
+            print(f"Skipping {lic_id} since it already exists")
+            continue
+        print(f"Fetching {lic_id}... ", end="", flush=True)
+        req = urllib.request.Request(lic["detailsUrl"])
+        with urllib.request.urlopen(req) as response:
+            lic_data = json.load(response)
+        if lic_data["isDeprecatedLicenseId"] and not args.deprecated:
+            print("Skipping (deprecated)")
+            continue
+        with dest_license_file.open("w") as f:
+            f.write(lic_data["licenseText"])
+        updated += 1
+        print("done")
+    print(f"Updated {updated} licenses")
+    return 0
+if __name__ == "__main__":
+    sys.exit(main())
diff --git a/scripts/pybootchartgui/pybootchartgui/draw.py b/scripts/pybootchartgui/pybootchartgui/draw.py
index c6e67833ab..4d76ce6e8e 100644
--- a/scripts/pybootchartgui/pybootchartgui/draw.py
+++ b/scripts/pybootchartgui/pybootchartgui/draw.py
@@ -69,6 +69,11 @@ CPU_COLOR = (0.40, 0.55, 0.70, 1.0)
 IO_COLOR = (0.76, 0.48, 0.48, 0.5)
 # Disk throughput color.
 DISK_TPUT_COLOR = (0.20, 0.71, 0.20, 1.0)
+BYTES_RECEIVED_COLOR = (0.0, 0.0, 1.0, 1.0)
+BYTES_TRANSMITTED_COLOR = (1.0, 0.0, 0.0, 1.0)
+BYTES_RECEIVE_DIFF_COLOR = (0.0, 0.0, 1.0, 0.3)
+BYTES_TRANSMIT_DIFF_COLOR = (1.0, 0.0, 0.0, 0.3)
 # CPU load chart color.
 FILE_OPEN_COLOR = (0.20, 0.71, 0.71, 1.0)
 # Mem cached color
@@ -366,6 +371,8 @@ def extents(options, xscale, trace):
            h += 30 + bar_h
        if trace.mem_stats:
            h += meminfo_bar_h
+        if trace.net_stats:
+            h += (30 + bar_h) * len(trace.net_stats)
    # Allow for width of process legend and offset
    if w < (720 + off_x):
@@ -437,6 +444,49 @@ def render_charts(ctx, options, clip, trace, curr_y, w, h, sec_w):
        curr_y = curr_y + 30 + bar_h
+    if trace.net_stats:
+        for iface, samples in trace.net_stats.items():
+            max_received_sample = max(samples, key=lambda s: s.received_bytes)
+            max_transmitted_sample = max(samples, key=lambda s: s.transmitted_bytes)
+            max_receive_diff_sample = max(samples, key=lambda s: s.receive_diff)
+            max_transmit_diff_sample = max(samples, key=lambda s: s.transmit_diff)
+            draw_text(ctx, "Iface: %s" % (iface), TEXT_COLOR, off_x, curr_y+20)
+            draw_legend_line(ctx, "Bytes received (max %d)" % (max_received_sample.received_bytes),
+                             BYTES_RECEIVED_COLOR, off_x+150, curr_y+20, leg_s)
+            draw_legend_line(ctx, "Bytes transmitted (max %d)" % (max_transmitted_sample.transmitted_bytes),
+                             BYTES_TRANSMITTED_COLOR, off_x+400, curr_y+20, leg_s)
+            draw_legend_box(ctx, "Bytes receive diff (max %d)" % (max_receive_diff_sample.receive_diff),
+                             BYTES_RECEIVE_DIFF_COLOR, off_x+650, curr_y+20, leg_s)
+            draw_legend_box(ctx, "Bytes transmit diff (max %d)" % (max_transmit_diff_sample.transmit_diff),
+                             BYTES_TRANSMIT_DIFF_COLOR, off_x+900, curr_y+20, leg_s)
+            chart_rect = (off_x, curr_y + 30, w, bar_h)
+            if clip_visible(clip, chart_rect):
+                draw_box_ticks(ctx, chart_rect, sec_w)
+                draw_annotations(ctx, proc_tree, trace.times, chart_rect)
+            if clip_visible (clip, chart_rect):
+                draw_chart (ctx, BYTES_RECEIVED_COLOR, False, chart_rect, \
+                        [(sample.time, sample.received_bytes) for sample in samples], \
+                        proc_tree, None)
+                draw_chart (ctx, BYTES_TRANSMITTED_COLOR, False, chart_rect, \
+                        [(sample.time, sample.transmitted_bytes) for sample in samples], \
+                        proc_tree, None)
+            if clip_visible (clip, chart_rect):
+                draw_chart (ctx, BYTES_RECEIVE_DIFF_COLOR, True, chart_rect, \
+                        [(sample.time, sample.receive_diff) for sample in samples], \
+                        proc_tree, None)
+                draw_chart (ctx, BYTES_TRANSMIT_DIFF_COLOR, True, chart_rect, \
+                        [(sample.time, sample.transmit_diff) for sample in samples], \
+                        proc_tree, None)
+            curr_y = curr_y + 30 + bar_h
    # render CPU pressure chart
    if trace.cpu_pressure:
        max_sample_avg = max (trace.cpu_pressure, key = lambda s: s.avg10)
@@ -796,7 +846,7 @@ def draw_header (ctx, headers, duration):
    toshow = [
      ('system.uname', 'uname', lambda s: s),
      ('system.release', 'release', lambda s: s),
-      ('system.cpu', 'CPU', lambda s: re.sub('model name\s*:\s*', '', s, 1)),
+      ('system.cpu', 'CPU', lambda s: re.sub(r'model name\s*:\s*', '', s, 1)),
      ('system.kernel.options', 'kernel options', lambda s: s),
    ]
diff --git a/scripts/pybootchartgui/pybootchartgui/parsing.py b/scripts/pybootchartgui/pybootchartgui/parsing.py
index 63a53b6b88..72a54c6ba5 100644
--- a/scripts/pybootchartgui/pybootchartgui/parsing.py
+++ b/scripts/pybootchartgui/pybootchartgui/parsing.py
@@ -48,6 +48,7 @@ class Trace:
        self.filename = None
        self.parent_map = None
        self.mem_stats = []
+        self.net_stats = []
        self.monitor_disk = None
        self.cpu_pressure = []
        self.io_pressure = []
@@ -457,7 +458,7 @@ def _parse_proc_disk_stat_log(file):
    not sda1, sda2 etc. The format of relevant lines should be:
    {major minor name rio rmerge rsect ruse wio wmerge wsect wuse running use aveq}
    """
-    disk_regex_re = re.compile ('^([hsv]d.|mtdblock\d|mmcblk\d|cciss/c\d+d\d+.*)$')
+    disk_regex_re = re.compile (r'^([hsv]d.|mtdblock\d|mmcblk\d|cciss/c\d+d\d+.*)$')
    # this gets called an awful lot.
    def is_relevant_line(linetokens):
@@ -557,6 +558,21 @@ def _parse_monitor_disk_log(file):
    return disk_stats
+def _parse_reduced_net_log(file):
+    net_stats = {}
+    for time, lines in _parse_timed_blocks(file):
+        for line in lines:
+            parts = line.split()
+            iface = parts[0][:-1]
+            if iface not in net_stats:
+                net_stats[iface] = [NetSample(time, iface, int(parts[1]), int(parts[2]), int(parts[3]), int(parts[4]))]
+            else:
+                net_stats[iface].append(NetSample(time, iface, int(parts[1]), int(parts[2]), int(parts[3]), int(parts[4])))
+    return net_stats
 def _parse_pressure_logs(file, filename):
    """
    Parse file for "some" pressure with 'avg10', 'avg60' 'avg300' and delta total values
@@ -594,8 +610,8 @@ def _parse_pressure_logs(file, filename):
 # [    0.039993] calling  migration_init+0x0/0x6b @ 1
 # [    0.039993] initcall migration_init+0x0/0x6b returned 1 after 0 usecs
 def _parse_dmesg(writer, file):
-    timestamp_re = re.compile ("^\[\s*(\d+\.\d+)\s*]\s+(.*)$")
+    timestamp_re = re.compile (r"^\[\s*(\d+\.\d+)\s*]\s+(.*)$")
-    split_re = re.compile ("^(\S+)\s+([\S\+_-]+) (.*)$")
+    split_re = re.compile (r"^(\S+)\s+([\S\+_-]+) (.*)$")
    processMap = {}
    idx = 0
    inc = 1.0 / 1000000
@@ -640,7 +656,7 @@ def _parse_dmesg(writer, file):
 #               print "foo: '%s' '%s' '%s'" % (type, func, rest)
        if type == "calling":
            ppid = kernel.pid
-            p = re.match ("\@ (\d+)", rest)
+            p = re.match (r"\@ (\d+)", rest)
            if p is not None:
                ppid = float (p.group(1)) // 1000
 #                               print "match: '%s' ('%g') at '%s'" % (func, ppid, time_ms)
@@ -742,7 +758,7 @@ def get_num_cpus(headers):
    cpu_model = headers.get("system.cpu")
    if cpu_model is None:
        return 1
-    mat = re.match(".*\\((\\d+)\\)", cpu_model)
+    mat = re.match(r".*\\((\\d+)\\)", cpu_model)
    if mat is None:
        return 1
    return max (int(mat.group(1)), 1)
@@ -767,6 +783,8 @@ def _do_parse(writer, state, filename, file):
        state.cmdline = _parse_cmdline_log(writer, file)
    elif name == "monitor_disk.log":
        state.monitor_disk = _parse_monitor_disk_log(file)
+    elif name == "reduced_proc_net.log":
+        state.net_stats = _parse_reduced_net_log(file)
    #pressure logs are in a subdirectory
    elif name == "cpu.log":
        state.cpu_pressure = _parse_pressure_logs(file, name)
diff --git a/scripts/pybootchartgui/pybootchartgui/samples.py b/scripts/pybootchartgui/pybootchartgui/samples.py
index a70d8a5a28..7c92d2ce6a 100644
--- a/scripts/pybootchartgui/pybootchartgui/samples.py
+++ b/scripts/pybootchartgui/pybootchartgui/samples.py
@@ -37,6 +37,16 @@ class CPUSample:
        return str(self.time) + "\t" + str(self.user) + "\t" + \
               str(self.sys) + "\t" + str(self.io) + "\t" + str (self.swap)
+class NetSample:
+    def __init__(self, time, iface, received_bytes, transmitted_bytes, receive_diff, transmit_diff):
+        self.time = time
+        self.iface = iface
+        self.received_bytes = received_bytes
+        self.transmitted_bytes = transmitted_bytes
+        self.receive_diff = receive_diff
+        self.transmit_diff = transmit_diff
 class CPUPressureSample:
    def __init__(self, time, avg10, avg60, avg300, deltaTotal):
        self.time = time
diff --git a/scripts/relocate_sdk.py b/scripts/relocate_sdk.py
index 8a728720ba..9e01c09cb0 100755
--- a/scripts/relocate_sdk.py
+++ b/scripts/relocate_sdk.py
@@ -49,6 +49,34 @@ def get_arch():
    elif ei_class == 2:
        return 64
+def get_dl_arch(dl_path):
+    try:
+        with open(dl_path, "r+b") as f:
+            e_ident =f.read(16)
+    except IOError:
+        exctype, ioex = sys.exc_info()[:2]
+        if ioex.errno == errno.ETXTBSY:
+            print("Could not open %s. File used by another process.\nPlease "\
+                  "make sure you exit all processes that might use any SDK "\
+                  "binaries." % e)
+        else:
+            print("Could not open %s: %s(%d)" % (e, ioex.strerror, ioex.errno))
+        sys.exit(-1)
+    ei_mag0,ei_mag1_3,ei_class,ei_data,ei_version = struct.unpack("<B3sBBB9x", e_ident)
+    if (ei_mag0 != 0x7f and ei_mag1_3 != "ELF") or ei_class == 0:
+        print("ERROR: unknow %s" % dl_path)
+        sys.exit(-1)
+    if ei_class == 1:
+        arch = 32
+    elif ei_class == 2:
+        arch = 64
+    return arch
 def parse_elf_header():
    global e_type, e_machine, e_version, e_entry, e_phoff, e_shoff, e_flags,\
           e_ehsize, e_phentsize, e_phnum, e_shentsize, e_shnum, e_shstrndx
@@ -223,6 +251,8 @@ else:
 executables_list = sys.argv[3:]
+dl_arch = get_dl_arch(new_dl_path)
 errors = False
 for e in executables_list:
    perms = os.stat(e)[stat.ST_MODE]
@@ -247,7 +277,7 @@ for e in executables_list:
    old_size = os.path.getsize(e)
    if old_size >= 64:
        arch = get_arch()
-        if arch:
+        if arch and arch == dl_arch:
            parse_elf_header()
            if not change_interpreter(e):
                errors = True
diff --git a/scripts/resulttool b/scripts/resulttool
index fc282bda6c..66a6af9959 100755
--- a/scripts/resulttool
+++ b/scripts/resulttool
@@ -15,6 +15,9 @@
 # To report test report, execute the below
 #     $ resulttool report <source_dir>
 #
+# To create a unit test report in JUnit XML format, execute the below
+#     $ resulttool junit <json_file>
+#
 # To perform regression file analysis, execute the below
 #     $ resulttool regression-file <base_result_file> <target_result_file>
 #
@@ -43,6 +46,7 @@ import resulttool.regression
 import resulttool.report
 import resulttool.manualexecution
 import resulttool.log
+import resulttool.junit
 logger = scriptutils.logger_create('resulttool')
 def main():
@@ -61,6 +65,7 @@ def main():
    resulttool.regression.register_commands(subparsers)
    resulttool.report.register_commands(subparsers)
    resulttool.log.register_commands(subparsers)
+    resulttool.junit.register_commands(subparsers)
    args = parser.parse_args()
    if args.debug:
diff --git a/scripts/runqemu b/scripts/runqemu
index 69cd44864e..2be7a0f286 100755
--- a/scripts/runqemu
+++ b/scripts/runqemu
@@ -197,11 +197,13 @@ class BaseConfig(object):
        self.portlocks = {}
        self.bitbake_e = ''
        self.snapshot = False
-        self.wictypes = ('wic', 'wic.vmdk', 'wic.qcow2', 'wic.vdi', "wic.vhd", "wic.vhdx")
+        self.wictypes = ('wic.zst', 'wic', 'wic.vmdk', 'wic.qcow2', 'wic.vdi', "wic.vhd", "wic.vhdx")
-        self.fstypes = ('ext2', 'ext3', 'ext4', 'jffs2', 'nfs', 'btrfs',
+        self.fstypes = ('ext2', 'ext3', 'ext4', 'ext2.zst', 'ext3.zst', 'ext4.zst',
-                        'cpio.gz', 'cpio', 'ramfs', 'tar.bz2', 'tar.gz',
+                        'jffs2', 'nfs', 'btrfs', 'cpio.gz', 'cpio', 'ramfs',
+                        'tar.bz2', 'tar.gz', 'tar.zst',
                        'squashfs', 'squashfs-xz', 'squashfs-lzo',
-                        'squashfs-lz4', 'squashfs-zst')
+                        'squashfs-lz4', 'squashfs-zst',
+                        'erofs', 'erofs-lz4', 'erofs-lz4hc')
        self.vmtypes = ('hddimg', 'iso')
        self.fsinfo = {}
        self.network_device = "-device e1000,netdev=net0,mac=@MAC@"
@@ -368,19 +370,20 @@ class BaseConfig(object):
        - Check whether it is an NFS dir
        - Check whether it is an OVMF flash file
        """
+        n = os.path.basename(p)
        if p.endswith('.qemuboot.conf'):
            self.qemuboot = p
            self.qbconfload = True
-        elif re.search('\\.bin$', p) or re.search('bzImage', p) or \
+        elif re.search('\\.bin$', n) or re.search('bzImage', n) or \
-             re.search('zImage', p) or re.search('vmlinux', p) or \
+             re.search('zImage', n) or re.search('vmlinux', n) or \
-             re.search('fitImage', p) or re.search('uImage', p):
+             re.search('fitImage', n) or re.search('uImage', n):
            self.kernel =  p
        elif os.path.isfile(p) and ('-image-' in os.path.basename(p) or '.rootfs.' in os.path.basename(p)):
            self.rootfs = p
            # Check filename against self.fstypes can handle <file>.cpio.gz,
            # otherwise, its type would be "gz", which is incorrect.
            fst = ""
-            for t in self.fstypes:
+            for t in self.fstypes + self.vmtypes + self.wictypes:
                if p.endswith(t):
                    fst = t
                    break
@@ -418,6 +421,46 @@ class BaseConfig(object):
        else:
            raise RunQemuError("Unknown path arg %s" % p)
+    def uncompress_rootfs(self):
+        """Decompress ZST rootfs image if needed"""
+        if not self.rootfs or not self.fstype.endswith('.zst'):
+            return
+        
+        # Ensure snapshot mode is active before allowing decompression.
+        if not self.snapshot:
+            raise RunQemuError(".zst images are only supported with snapshot mode. " \
+                                "You can either use the \"snapshot\" option or use an uncompressed image.")
+        
+        # Get the real path to the image to avoid issues when a symbolic link is passed.
+        # This ensures we always operate on the actual file.
+        image_path = os.path.realpath(self.rootfs)
+        # Extract target filename by removing .zst
+        image_dir = os.path.dirname(image_path)
+        uncompressed_name = os.path.basename(image_path).replace(".zst", "")
+        uncompressed_path = os.path.join(image_dir, uncompressed_name)
+    
+        # If the decompressed image already exists (e.g., in the deploy directory),
+        # we use it directly to avoid overwriting artifacts generated by the build system.
+        # This prevents redundant decompression and preserves build outputs.
+        if os.path.exists(uncompressed_path):
+            logger.warning(f"Found existing decompressed image: {uncompressed_path}, Using it directly.")
+        else:
+            logger.info(f"Decompressing {self.rootfs} to {uncompressed_path}")
+            # Ensure the 'zstd' tool is installed before attempting to decompress.
+            if not shutil.which('zstd'):
+                raise RunQemuError(f"'zstd' is required to decompress {self.rootfs} but was not found in PATH")
+            try:
+                subprocess.check_call(['zstd', '-d', image_path, '-o', uncompressed_path])
+            except subprocess.CalledProcessError as e:
+                raise RunQemuError(f"Failed to decompress {self.rootfs}: {e}")
+            finally:
+                # Mark temporary file for deletion
+                self.cleanup_files.append(uncompressed_path)
+    
+        # Use the decompressed image as the rootfs
+        self.rootfs = uncompressed_path
+        self.fstype = self.fstype.removesuffix(".zst")
    def check_arg_machine(self, arg):
        """Check whether it is a machine"""
        if self.get('MACHINE') == arg:
@@ -468,9 +511,11 @@ class BaseConfig(object):
                self.set("IMAGE_LINK_NAME", image_link_name)
                logger.debug('Using IMAGE_LINK_NAME = "%s"' % image_link_name)
-    def set_dri_path(self):
+    def set_mesa_paths(self):
        drivers_path = os.path.join(self.bindir_native, '../lib/dri')
-        if not os.path.exists(drivers_path) or not os.listdir(drivers_path):
+        gbm_path = os.path.join(self.bindir_native, '../lib/gbm')
+        if not os.path.exists(drivers_path) or not os.listdir(drivers_path) \
+                or not os.path.exists(gbm_path) or not os.listdir(gbm_path):
            raise RunQemuError("""
 qemu has been built without opengl support and accelerated graphics support is not available.
 To enable it, add:
@@ -479,6 +524,7 @@ DISTRO_FEATURES_NATIVESDK:append = " opengl"
 to your build configuration.
 """)
        self.qemu_environ['LIBGL_DRIVERS_PATH'] = drivers_path
+        self.qemu_environ['GBM_BACKENDS_PATH'] = gbm_path
    def check_args(self):
        for debug in ("-d", "--debug"):
@@ -961,34 +1007,12 @@ to your build configuration.
            if not self.bitbake_e:
                self.load_bitbake_env()
-            if self.bitbake_e:
+            native_vars = ['STAGING_DIR_NATIVE']
-                native_vars = ['STAGING_DIR_NATIVE']
+            for nv in native_vars:
-                for nv in native_vars:
+                s = re.search('^%s="(.*)"' % nv, self.bitbake_e, re.M)
-                    s = re.search('^%s="(.*)"' % nv, self.bitbake_e, re.M)
+                if s and s.group(1) != self.get(nv):
-                    if s and s.group(1) != self.get(nv):
+                    logger.info('Overriding conf file setting of %s to %s from Bitbake environment' % (nv, s.group(1)))
-                        logger.info('Overriding conf file setting of %s to %s from Bitbake environment' % (nv, s.group(1)))
+                    self.set(nv, s.group(1))
-                        self.set(nv, s.group(1))
-            else:
-                # when we're invoked from a running bitbake instance we won't
-                # be able to call `bitbake -e`, then try:
-                # - get OE_TMPDIR from environment and guess paths based on it
-                # - get OECORE_NATIVE_SYSROOT from environment (for sdk)
-                tmpdir = self.get('OE_TMPDIR')
-                oecore_native_sysroot = self.get('OECORE_NATIVE_SYSROOT')
-                if tmpdir:
-                    logger.info('Setting STAGING_DIR_NATIVE and STAGING_BINDIR_NATIVE relative to OE_TMPDIR (%s)' % tmpdir)
-                    hostos, _, _, _, machine = os.uname()
-                    buildsys = '%s-%s' % (machine, hostos.lower())
-                    staging_dir_native = '%s/sysroots/%s' % (tmpdir, buildsys)
-                    self.set('STAGING_DIR_NATIVE', staging_dir_native)
-                elif oecore_native_sysroot:
-                    logger.info('Setting STAGING_DIR_NATIVE to OECORE_NATIVE_SYSROOT (%s)' % oecore_native_sysroot)
-                    self.set('STAGING_DIR_NATIVE', oecore_native_sysroot)
-                if self.get('STAGING_DIR_NATIVE'):
-                    # we have to assume that STAGING_BINDIR_NATIVE is at usr/bin
-                    staging_bindir_native = '%s/usr/bin' % self.get('STAGING_DIR_NATIVE')
-                    logger.info('Setting STAGING_BINDIR_NATIVE to %s' % staging_bindir_native)
-                    self.set('STAGING_BINDIR_NATIVE', '%s/usr/bin' % self.get('STAGING_DIR_NATIVE'))
    def print_config(self):
        logoutput = ['Continuing with the following parameters:']
@@ -1008,6 +1032,9 @@ to your build configuration.
            logoutput.append('NFS_DIR: [%s]' % self.rootfs)
        else:
            logoutput.append('ROOTFS: [%s]' % self.rootfs)
+        logoutput.append('SNAPSHOT: [%s]' %
+                         "Enabled. Changes on rootfs won't be kept after QEMU shutdown." if self.snapshot
+                         else "Disabled. Changes on rootfs will be kept after QEMU shutdown.")
        if self.ovmf_bios:
            logoutput.append('OVMF: %s' % self.ovmf_bios)
        if (self.ovmf_secboot_pkkek1):
@@ -1192,19 +1219,22 @@ to your build configuration.
                raise RunQemuError("a new one with sudo.")
            gid = os.getgid()
-            uid = os.getuid()
            logger.info("Setting up tap interface under sudo")
            cmd = ('sudo', self.qemuifup, str(gid))
-            try:
+            for _ in range(5):
-                tap = subprocess.check_output(cmd).decode('utf-8').strip()
+                try:
-            except subprocess.CalledProcessError as e:
+                    tap = subprocess.check_output(cmd).decode('utf-8').strip()
-                logger.error('Setting up tap device failed:\n%s\nRun runqemu-gen-tapdevs to manually create one.' % str(e))
+                except subprocess.CalledProcessError as e:
-                sys.exit(1)
+                    logger.error('Setting up tap device failed:\n%s\nRun runqemu-gen-tapdevs to manually create one.' % str(e))
-            lockfile = os.path.join(lockdir, tap)
+                    sys.exit(1)
-            self.taplock = lockfile + '.lock'
+                lockfile = os.path.join(lockdir, tap)
-            self.acquire_taplock()
+                self.taplock = lockfile + '.lock'
-            self.cleantap = True
+                if self.acquire_taplock():
-            logger.debug('Created tap: %s' % tap)
+                    self.cleantap = True
+                    logger.debug('Created tap: %s' % tap)
+                    break
+                else:
+                    tap = None
        if not tap:
            logger.error("Failed to setup tap device. Run runqemu-gen-tapdevs to manually create.")
@@ -1295,6 +1325,10 @@ to your build configuration.
                    elif drive_type.startswith("/dev/hd"):
                        logger.info('Using ide drive')
                        vm_drive = "-drive file=%s,format=%s" % (self.rootfs, rootfs_format)
+                    elif drive_type.startswith("/dev/mmcblk"):
+                        logger.info('Using sdcard drive')
+                        vm_drive = '-drive id=sdcard0,if=none,file=%s,format=%s -device sdhci-pci -device sd-card,drive=sdcard0' \
+                                    % (self.rootfs, rootfs_format)
                    elif drive_type.startswith("/dev/vdb"):
                        logger.info('Using block virtio drive');
                        vm_drive = '-drive id=disk0,file=%s,if=none,format=%s -device virtio-blk-device,drive=disk0%s' \
@@ -1454,7 +1488,7 @@ to your build configuration.
            self.qemu_opt += ' -display '
            if self.egl_headless == True:
                self.check_render_nodes()
-                self.set_dri_path()
+                self.set_mesa_paths()
                self.qemu_opt += 'egl-headless,'
            else:
                if self.sdl == True:
@@ -1464,10 +1498,10 @@ to your build configuration.
                    self.qemu_opt += 'gtk,'
                if self.gl == True:
-                    self.set_dri_path()
+                    self.set_mesa_paths()
                    self.qemu_opt += 'gl=on,'
                elif self.gl_es == True:
-                    self.set_dri_path()
+                    self.set_mesa_paths()
                    self.qemu_opt += 'gl=es,'
            self.qemu_opt += 'show-cursor=on'
@@ -1483,7 +1517,7 @@ to your build configuration.
        # If no serial or serialtcp options were specified, only ttyS0 is created
        # and sysvinit shows an error trying to enable ttyS1:
        #     INIT: Id "S1" respawning too fast: disabled for 5 minutes
-        serial_num = len(re.findall("-serial", self.qemu_opt))
+        serial_num = len(re.findall("(^| )-serial ", self.qemu_opt))
        # Assume if the user passed serial options, they know what they want
        # and pad to two devices
@@ -1503,7 +1537,7 @@ to your build configuration.
                self.qemu_opt += " %s" % self.get("QB_SERIAL_OPT")
-        serial_num = len(re.findall("-serial", self.qemu_opt))
+        serial_num = len(re.findall("(^| )-serial ", self.qemu_opt))
        if serial_num < 2:
            self.qemu_opt += " -serial null"
@@ -1658,9 +1692,6 @@ to your build configuration.
        self.cleaned = True
    def run_bitbake_env(self, mach=None, target=''):
-        bitbake = shutil.which('bitbake')
-        if not bitbake:
-            return
        if not mach:
            mach = self.get('MACHINE')
@@ -1669,11 +1700,18 @@ to your build configuration.
        if multiconfig:
            multiconfig = "mc:%s" % multiconfig
+        if self.rootfs and not target:
+            target = self.rootfs
        if mach:
            cmd = 'MACHINE=%s bitbake -e %s %s' % (mach, multiconfig, target)
        else:
            cmd = 'bitbake -e %s %s' % (multiconfig, target)
+        bitbake = shutil.which('bitbake')
+        if not bitbake:
+            raise OEPathError("Bitbake is needed to run '%s', but it is not found in PATH. Please source the bitbake build environment." % cmd.strip())
        logger.info('Running %s...' % cmd)
        try:
            return subprocess.check_output(cmd, shell=True).decode('utf-8')
@@ -1685,11 +1723,7 @@ to your build configuration.
                cmd = 'MACHINE=%s bitbake -e %s %s' % (mach, multiconfig, target)
            else:
                cmd = 'bitbake -e %s %s' % (multiconfig, target)
-            try:
+            return subprocess.check_output(cmd, shell=True).decode('utf-8')
-                return subprocess.check_output(cmd, shell=True).decode('utf-8')
-            except subprocess.CalledProcessError as err:
-                logger.warning("Couldn't run '%s' to gather environment information, giving up with 'bitbake -e':\n%s" % (cmd, err.output.decode('utf-8')))
-                return ''
    def load_bitbake_env(self, mach=None, target=None):
@@ -1749,6 +1783,7 @@ def main():
        config.check_args()
        config.read_qemuboot()
        config.check_and_set()
+        config.uncompress_rootfs()
        # Check whether the combos is valid or not
        config.validate_combos()
        config.print_config()
diff --git a/scripts/send-error-report b/scripts/send-error-report
index cfbcaa52cb..cc1bc7c2b1 100755
--- a/scripts/send-error-report
+++ b/scripts/send-error-report
@@ -6,6 +6,7 @@
 # Copyright (C) 2013 Intel Corporation
 # Author: Andreea Proca <andreea.b.proca@intel.com>
 # Author: Michael Wood <michael.g.wood@intel.com>
+# Author: Thomas Perrot <thomas.perrot@bootlin.com>
 #
 # SPDX-License-Identifier: GPL-2.0-only
 #
@@ -22,7 +23,7 @@ scripts_lib_path = os.path.join(os.path.dirname(os.path.realpath(__file__)), 'li
 sys.path.insert(0, scripts_lib_path)
 import argparse_oe
-version = "0.3"
+version = "0.4"
 log = logging.getLogger("send-error-report")
 logging.basicConfig(format='%(levelname)s: %(message)s')
@@ -65,7 +66,7 @@ def edit_content(json_file_path):
 def prepare_data(args):
    # attempt to get the max_log_size from the server's settings
-    max_log_size = getPayloadLimit(args.protocol+args.server+"/ClientPost/JSON")
+    max_log_size = getPayloadLimit(args.server+"/ClientPost/JSON")
    if not os.path.isfile(args.error_file):
        log.error("No data file found.")
@@ -135,19 +136,38 @@ def send_data(data, args):
    headers={'Content-type': 'application/json', 'User-Agent': "send-error-report/"+version}
    if args.json:
-        url = args.protocol+args.server+"/ClientPost/JSON/"
+        url = args.server+"/ClientPost/JSON/"
    else:
-        url = args.protocol+args.server+"/ClientPost/"
+        url = args.server+"/ClientPost/"
    req = urllib.request.Request(url, data=data, headers=headers)
+    log.debug(f"Request URL: {url}")
+    log.debug(f"Request Headers: {headers}")
+    log.debug(f"Request Data: {data.decode('utf-8')}")
    try:
        response = urllib.request.urlopen(req)
    except urllib.error.HTTPError as e:
-        logging.error(str(e))
+        log.error(f"HTTP Error {e.code}: {e.reason}")
+        log.debug(f"Response Content: {e.read().decode('utf-8')}")
        sys.exit(1)
+    log.debug(f"Response Status: {response.status}")
+    log.debug(f"Response Headers: {response.getheaders()}")
    print(response.read().decode('utf-8'))
+def validate_server_url(args):
+    # Get the error report server from an argument
+    server = args.server or 'https://errors.yoctoproject.org'
+    if not server.startswith('http://') and not server.startswith('https://'):
+        log.error("Missing a URL scheme either http:// or https:// in the server name: " + server)
+        sys.exit(1)
+    # Construct the final URL
+    return f"{server}"
 if __name__ == '__main__':
    arg_parse = argparse_oe.ArgumentParser(description="This scripts will send an error report to your specified error-report-web server.")
@@ -164,8 +184,7 @@ if __name__ == '__main__':
    arg_parse.add_argument("-s",
                           "--server",
                           help="Server to send error report to",
-                           type=str,
+                           type=str)
-                           default="errors.yoctoproject.org")
    arg_parse.add_argument("-e",
                           "--email",
@@ -190,18 +209,22 @@ if __name__ == '__main__':
                           help="Return the result in json format, silences all other output",
                           action="store_true")
-    arg_parse.add_argument("--no-ssl",
+    arg_parse.add_argument("-d",
-                           help="Use http instead of https protocol",
+                           "--debug",
-                           dest="protocol",
+                           help="Enable debug mode to print request/response details",
-                           action="store_const", const="http://", default="https://")
+                           action="store_true")
    args = arg_parse.parse_args()
+    args.server = validate_server_url(args)
    if (args.json == False):
        print("Preparing to send errors to: "+args.server)
+    # Enable debugging if requested
+    if args.debug:
+        log.setLevel(logging.DEBUG)
    data = prepare_data(args)
    send_data(data, args)
diff --git a/scripts/sstate-cache-management.py b/scripts/sstate-cache-management.py
index d3f600bd28..303b8f13a3 100755
--- a/scripts/sstate-cache-management.py
+++ b/scripts/sstate-cache-management.py
@@ -268,6 +268,10 @@ def parse_arguments():
    # )
    parser.add_argument(
+        "-n", "--dry-run", action="store_true", help="Don't execute, just go through the motions."
+    )
+    parser.add_argument(
        "-y",
        "--yes",
        action="store_true",
@@ -314,6 +318,9 @@ def main():
    if args.debug >= 1:
        print("\n".join([str(p.path) for p in remove]))
    print(f"{len(remove)} out of {len(paths)} files will be removed!")
+    if args.dry_run:
+        return 0
    if not args.yes:
        print("Do you want to continue (y/n)?")
        confirm = input() in ("y", "Y")
diff --git a/scripts/test-remote-image b/scripts/test-remote-image
index d209d22854..1d018992b0 100755
--- a/scripts/test-remote-image
+++ b/scripts/test-remote-image
@@ -152,8 +152,7 @@ class AutoTargetProfile(BaseTargetProfile):
        return controller
    def set_kernel_file(self):
-        postconfig = "QA_GET_MACHINE = \"${MACHINE}\""
+        machine = get_bb_var('MACHINE')
-        machine = get_bb_var('QA_GET_MACHINE', postconfig=postconfig)
        self.kernel_file = self.kernel_type + '-' + machine + '.bin'
    def set_rootfs_file(self):
@@ -215,13 +214,11 @@ class PublicAB(BaseRepoProfile):
    def get_repo_path(self):
        path = '/machines/'
-        postconfig = "QA_GET_MACHINE = \"${MACHINE}\""
+        machine = get_bb_var('MACHINE')
-        machine = get_bb_var('QA_GET_MACHINE', postconfig=postconfig)
        if 'qemu' in machine:
            path += 'qemu/'
-        postconfig = "QA_GET_DISTRO = \"${DISTRO}\""
+        distro = get_bb_var('DISTRO')
-        distro = get_bb_var('QA_GET_DISTRO', postconfig=postconfig)
        path += distro.replace('poky', machine) + '/'
        return path
diff --git a/scripts/wic b/scripts/wic
index 06e0b48db0..9137208f5e 100755
--- a/scripts/wic
+++ b/scripts/wic
@@ -237,6 +237,13 @@ def wic_ls_subcommand(args, usage_str):
    Command-line handling for list content of images.
    The real work is done by engine.wic_ls()
    """
+    if args.image_name:
+        BB_VARS.default_image = args.image_name
+    if args.vars_dir:
+        BB_VARS.vars_dir = args.vars_dir
    engine.wic_ls(args, args.native_sysroot)
 def wic_cp_subcommand(args, usage_str):
@@ -244,6 +251,12 @@ def wic_cp_subcommand(args, usage_str):
    Command-line handling for copying files/dirs to images.
    The real work is done by engine.wic_cp()
    """
+    if args.image_name:
+        BB_VARS.default_image = args.image_name
+    if args.vars_dir:
+        BB_VARS.vars_dir = args.vars_dir
    engine.wic_cp(args, args.native_sysroot)
 def wic_rm_subcommand(args, usage_str):
@@ -251,6 +264,12 @@ def wic_rm_subcommand(args, usage_str):
    Command-line handling for removing files/dirs from images.
    The real work is done by engine.wic_rm()
    """
+    if args.image_name:
+        BB_VARS.default_image = args.image_name
+    if args.vars_dir:
+        BB_VARS.vars_dir = args.vars_dir
    engine.wic_rm(args, args.native_sysroot)
 def wic_write_subcommand(args, usage_str):
@@ -258,6 +277,12 @@ def wic_write_subcommand(args, usage_str):
    Command-line handling for writing images.
    The real work is done by engine.wic_write()
    """
+    if args.image_name:
+        BB_VARS.default_image = args.image_name
+    if args.vars_dir:
+        BB_VARS.vars_dir = args.vars_dir
    engine.wic_write(args, args.native_sysroot)
 def wic_help_subcommand(args, usage_str):
@@ -390,6 +415,12 @@ def wic_init_parser_ls(subparser):
                        help="image spec: <image>[:<vfat partition>[<path>]]")
    subparser.add_argument("-n", "--native-sysroot",
                        help="path to the native sysroot containing the tools")
+    subparser.add_argument("-e", "--image-name", dest="image_name",
+                      help="name of the image to use the artifacts from "
+                           "e.g. core-image-sato")
+    subparser.add_argument("-v", "--vars", dest='vars_dir',
+                      help="directory with <image>.env files that store "
+                           "bitbake variables")
 def imgpathtype(arg):
    img = imgtype(arg)
@@ -404,6 +435,12 @@ def wic_init_parser_cp(subparser):
                        help="image spec: <image>:<vfat partition>[<path>] or <file>")
    subparser.add_argument("-n", "--native-sysroot",
                        help="path to the native sysroot containing the tools")
+    subparser.add_argument("-e", "--image-name", dest="image_name",
+                      help="name of the image to use the artifacts from "
+                           "e.g. core-image-sato")
+    subparser.add_argument("-v", "--vars", dest='vars_dir',
+                      help="directory with <image>.env files that store "
+                           "bitbake variables")
 def wic_init_parser_rm(subparser):
    subparser.add_argument("path", type=imgpathtype,
@@ -413,6 +450,12 @@ def wic_init_parser_rm(subparser):
    subparser.add_argument("-r", dest="recursive_delete", action="store_true", default=False,
                        help="remove directories and their contents recursively, "
                        " this only applies to ext* partition")
+    subparser.add_argument("-e", "--image-name", dest="image_name",
+                      help="name of the image to use the artifacts from "
+                           "e.g. core-image-sato")
+    subparser.add_argument("-v", "--vars", dest='vars_dir',
+                      help="directory with <image>.env files that store "
+                           "bitbake variables")
 def expandtype(rules):
    """
@@ -454,6 +497,12 @@ def wic_init_parser_write(subparser):
                        help="expand rules: auto or <partition>:<size>[,<partition>:<size>]")
    subparser.add_argument("-n", "--native-sysroot",
                        help="path to the native sysroot containing the tools")
+    subparser.add_argument("--image-name", dest="image_name",
+                      help="name of the image to use the artifacts from "
+                           "e.g. core-image-sato")
+    subparser.add_argument("-v", "--vars", dest='vars_dir',
+                      help="directory with <image>.env files that store "
+                           "bitbake variables")
 def wic_init_parser_help(subparser):
    helpparsers = subparser.add_subparsers(dest='help_topic', help=hlp.wic_usage)
diff --git a/scripts/yocto-check-layer b/scripts/yocto-check-layer
index 67cc71950f..8c8b4dbcad 100755
--- a/scripts/yocto-check-layer
+++ b/scripts/yocto-check-layer
@@ -35,6 +35,7 @@ logger = scriptutils.logger_create(PROGNAME, stream=sys.stdout)
 def test_layer(td, layer, test_software_layer_signatures):
    from checklayer.context import CheckLayerTestContext
    logger.info("Starting to analyze: %s" % layer['name'])
+    logger.info('Distro: %s' % td['bbvars']["DISTRO"])
    logger.info("----------------------------------------------------------------------")
    tc = CheckLayerTestContext(td=td, logger=logger, layer=layer, test_software_layer_signatures=test_software_layer_signatures)