84 files changed, 2765 insertions, 1944 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..829cc4cd30
--- /dev/null
+++ b/scripts/contrib/improve_kernel_cve_report.py
@@ -0,0 +1,467 @@
+#! /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":
+        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
+        kernel_cves = get_kernel_cves(args.datadir,
+                                      compiled_files,
+                                      Version(pkg["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..aa23942858 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.1'
-DEFAULT_INSTALLER_VERSION = '4.1'
+DEFAULT_INSTALLER_VERSION = '5.2.1'
 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 65f1a227ad..86435273cf 100644
--- a/scripts/lib/build_perf/html/measurement_chart.html
+++ b/scripts/lib/build_perf/html/measurement_chart.html
@@ -1,50 +1,168 @@
-<script type="text/javascript">
+<script type="module">
-  chartsDrawing += 1;
+  // Get raw data
-  google.charts.setOnLoadCallback(drawChart_{{ chart_elem_id }});
+  const rawData = [
-  function drawChart_{{ chart_elem_id }}() {
+    {% for sample in measurement.samples %}
-    var data = new google.visualization.DataTable();
+      [{{ sample.commit_num }}, {{ sample.mean.gv_value() }}, {{ sample.start_time }}, '{{sample.commit}}'],
+    {% endfor %}
-    // Chart options
+  ];
-    var options = {
-      theme : 'material',
+  const convertToMinute = (time) => {
-      legend: 'none',
+    return time[0]*60 + time[1] + time[2]/60 + time[3]/3600;
-      hAxis: { format: '', title: 'Commit number',
+  }
-               minValue: {{ chart_opts.haxis.min }},
-               maxValue: {{ chart_opts.haxis.max }} },
+  // Update value format to either minutes or leave as size value
-      {% if measurement.type == 'time' %}
+  const updateValue = (value) => {
-      vAxis: { format: 'h:mm:ss' },
+    // Assuming the array values are duration in the format [hours, minutes, seconds, milliseconds]
-      {% else %}
+    return Array.isArray(value) ? convertToMinute(value) : value
-      vAxis: { format: '' },
+  }
-      {% endif %}
-      pointSize: 5,
+  // Convert raw data to the format: [time, value]
-      chartArea: { left: 80, right: 15 },
+  const data = rawData.map(([commit, value, time]) => {
-    };
+    return [
+      // The Date object takes values in milliseconds rather than seconds. So to use a Unix timestamp we have to multiply it by 1000.
-    // Define data columns
+      new Date(time * 1000).getTime(),
-    data.addColumn('number', 'Commit');
+      // Assuming the array values are duration in the format [hours, minutes, seconds, milliseconds]
-    data.addColumn('{{ measurement.value_type.gv_data_type }}',
+      updateValue(value)
-                   '{{ measurement.value_type.quantity }}');
+    ]
-    // Add data rows
+  });
-    data.addRows([
-      {% for sample in measurement.samples %}
+  const commitCountList = rawData.map(([commit, value, time]) => {
-        [{{ sample.commit_num }}, {{ sample.mean.gv_value() }}],
+    return commit
-      {% endfor %}
+  });
-    ]);
+  const commitCountData = rawData.map(([commit, value, time]) => {
-    // Finally, draw the chart
+    return updateValue(value)
-    chart_div = document.getElementById('{{ chart_elem_id }}');
+  });
-    var chart = new google.visualization.LineChart(chart_div);
-    google.visualization.events.addListener(chart, 'ready', function () {
+  // Set chart options
-      //chart_div = document.getElementById('{{ chart_elem_id }}');
+  const option_start_time = {
-      //chart_div.innerHTML = '<img src="' + chart.getImageURI() + '">';
+    tooltip: {
-      png_div = document.getElementById('{{ chart_elem_id }}_png');
+      trigger: 'axis',
-      png_div.outerHTML = '<a id="{{ chart_elem_id }}_png" href="' + chart.getImageURI() + '">PNG</a>';
+      enterable: true,
-      console.log("CHART READY: {{ chart_elem_id }}");
+      position: function (point, params, dom, rect, size) {
-      chartsDrawing -= 1;
+        return [point[0], '0%'];
-      if (chartsDrawing == 0)
+      },
-        console.log("ALL CHARTS READY");
+      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 `<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: {
+      type: 'time',
+    },
+    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: 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 draw_chart = (chart_id, option) => {
+    let chart_name
+    const chart_div = document.getElementById(chart_id);
+    // Set dark mode
+    if (window.matchMedia('(prefers-color-scheme: dark)').matches) {
+        chart_name= echarts.init(chart_div, 'dark', {
+        height: 320
+      });
+    } else {
+        chart_name= echarts.init(chart_div, null, {
+        height: 320
+      });
+    }
+    // Change chart size with browser resize
+    window.addEventListener('resize', function() {
+      chart_name.resize();
    });
-    chart.draw(data, options);
+    return chart_name.setOption(option);
-}
+  }
-</script>
+  draw_chart('{{ chart_elem_start_time_id }}', option_start_time)
+  draw_chart('{{ chart_elem_commit_count_id }}', option_commit_count)
+</script>
diff --git a/scripts/lib/build_perf/html/report.html b/scripts/lib/build_perf/html/report.html
index d1ba6f2578..28cd80e738 100644
--- a/scripts/lib/build_perf/html/report.html
+++ b/scripts/lib/build_perf/html/report.html
@@ -3,17 +3,14 @@
 <head>
 {# Scripts, for visualization#}
 <!--START-OF-SCRIPTS-->
-<script type="text/javascript" src="https://www.gstatic.com/charts/loader.js"></script>
+<script src=" https://cdn.jsdelivr.net/npm/echarts@5.5.0/dist/echarts.min.js "></script>
-<script type="text/javascript">
-google.charts.load('current', {'packages':['corechart']});
-var chartsDrawing = 0;
-</script>
 {# Render measurement result charts #}
 {% 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 %}
@@ -23,28 +20,29 @@ var chartsDrawing = 0;
 {# Styles #}
 <style>
+:root {
+  --text: #000;
+  --bg: #fff;
+  --h2heading: #707070;
+  --link: #0000EE;
+  --trtopborder: #9ca3af;
+  --trborder: #e5e7eb;
+  --chartborder: #f0f0f0;
+  }
 .meta-table {
  font-size: 14px;
  text-align: left;
  border-collapse: collapse;
 }
-.meta-table tr:nth-child(even){background-color: #f2f2f2}
-meta-table th, .meta-table td {
-  padding: 4px;
-}
 .summary {
-  margin: 0;
  font-size: 14px;
  text-align: left;
  border-collapse: collapse;
 }
-summary th, .meta-table td {
-  padding: 4px;
-}
 .measurement {
  padding: 8px 0px 8px 8px;
-  border: 2px solid #f0f0f0;
+  border: 2px solid var(--chartborder);
-  margin-bottom: 10px;
+  margin: 1.5rem 0;
 }
 .details {
  margin: 0;
@@ -64,18 +62,97 @@ summary th, .meta-table td {
  background-color: #f0f0f0;
  margin-left: 10px;
 }
-hr {
+.card-container {
-  color: #f0f0f0;
+  border-bottom-width: 1px;
+  padding: 1.25rem 3rem;
+  box-shadow: 0 1px 3px 0 rgb(0 0 0 / 0.1), 0 1px 2px -1px rgb(0 0 0 / 0.1);
+  border-radius: 0.25rem;
+}
+body {
+  font-family: 'Helvetica', sans-serif;
+  margin: 3rem 8rem;
+  background-color: var(--bg);
+  color: var(--text);
+}
+h1 {
+  text-align: center;
 }
 h2 {
-  font-size: 20px;
+  font-size: 1.5rem;
  margin-bottom: 0px;
-  color: #707070;
+  color: var(--h2heading);
+  padding-top: 1.5rem;
 }
 h3 {
-  font-size: 16px;
+  font-size: 1.3rem;
  margin: 0px;
-  color: #707070;
+  color: var(--h2heading);
+  padding: 1.5rem 0;
+}
+h4 {
+  font-size: 14px;
+  font-weight: lighter;
+  line-height: 1.2rem;
+  margin: auto;
+  padding-top: 1rem;
+}
+table {
+  margin-top: 1.5rem;
+  line-height: 2rem;
+}
+tr {
+  border-bottom: 1px solid var(--trborder);
+}
+tr:first-child {
+  border-bottom: 1px solid var(--trtopborder);
+}
+tr:last-child {
+  border-bottom: none;
+}
+a {
+  text-decoration: none;
+  font-weight: bold;
+  color: var(--link);
+}
+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;
+    --bg: #0F0C28;
+    --h2heading: #B8B7CB;
+    --link: #87cefa;
+    --trtopborder: #394150;
+    --trborder: #212936;
+    --chartborder: #b1b0bf;
+  }
+  button {
+    background-color: #28303E;
+    color: #fff;
+  }
+  button:hover {
+    background-color: #545a69;
+  }
+  .tab button.active {
+    background-color: #545a69;
+  }
 }
 </style>
@@ -83,13 +160,14 @@ h3 {
 </head>
 {% macro poky_link(commit) -%}
-    <a href="http://git.yoctoproject.org/cgit/cgit.cgi/poky/log/?id={{ commit }}">{{ commit[0:11] }}</a>
+  <a href="http://git.yoctoproject.org/cgit/cgit.cgi/poky/log/?id={{ commit }}">{{ commit[0:11] }}</a>
 {%- endmacro %}
-<body><div style="width: 700px">
+<body><div>
+  <h1 style="text-align: center;">Performance Test Report</h1>
  {# Test metadata #}
  <h2>General</h2>
-  <hr>
+  <h4>The table provides an overview of the comparison between two selected commits from the same branch.</h4>
  <table class="meta-table" style="width: 100%">
    <tr>
      <th></th>
@@ -112,19 +190,21 @@ h3 {
  {# Test result summary #}
  <h2>Test result summary</h2>
-  <hr>
+  <h4>The test summary presents a thorough breakdown of each test conducted on the branch, including details such as build time and disk space consumption. Additionally, it gives insights into the average time taken for test execution, along with absolute and relative values for a better understanding.</h4>
  <table class="summary" style="width: 100%">
+    <tr>
+      <th>Test name</th>
+      <th>Measurement description</th>
+      <th>Mean value</th>
+      <th>Absolute difference</th>
+      <th>Relative difference</th>
+    </tr>
    {% for test in test_data %}
-      {% if loop.index is even %}
-        {% set row_style = 'style="background-color: #f2f2f2"' %}
-      {% else %}
-        {% set row_style = 'style="background-color: #ffffff"' %}
-      {% endif %}
      {% if test.status == 'SUCCESS' %}
        {% for measurement in test.measurements %}
          <tr {{ row_style }}>
            {% if loop.index == 1 %}
-              <td>{{ test.name }}: {{ test.description }}</td>
+              <td><a href=#{{test.name}}>{{ test.name }}: {{ test.description }}</a></td>
            {% else %}
              {# add empty cell in place of the test name#}
              <td></td>
@@ -153,10 +233,12 @@ h3 {
  </table>
  {# Detailed test results #}
+  <h2>Test details</h2>
+  <h4>The following section provides details of each test, accompanied by charts representing build time and disk usage over time or by commit number.</h4>
  {% for test in test_data %}
-  <h2>{{ test.name }}: {{ test.description }}</h2>
+  <h3 style="color: #000;" id={{test.name}}>{{ test.name }}: {{ test.description }}</h3>
-  <hr>
    {% if test.status == 'SUCCESS' %}
+    <div class="card-container">
      {% for measurement in test.measurements %}
        <div class="measurement">
          <h3>{{ measurement.description }}</h3>
@@ -178,7 +260,18 @@ h3 {
            <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 #}
@@ -275,7 +368,8 @@ h3 {
            {% endif %}
          {% endif %}
        </div>
-      {% endfor %}
+        {% endfor %}
+      </div>
    {# Unsuccessful test #}
    {% else %}
      <span style="font-size: 150%; font-weight: bold; color: red;">{{ test.status }}
@@ -284,6 +378,31 @@ h3 {
      <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/build_perf/report.py b/scripts/lib/build_perf/report.py
index ab77424cc7..f4e6a92e09 100644
--- a/scripts/lib/build_perf/report.py
+++ b/scripts/lib/build_perf/report.py
@@ -294,7 +294,7 @@ class SizeVal(MeasurementVal):
            return "null"
        return self / 1024
-def measurement_stats(meas, prefix=''):
+def measurement_stats(meas, prefix='', time=0):
    """Get statistics of a measurement"""
    if not meas:
        return {prefix + 'sample_cnt': 0,
@@ -319,6 +319,8 @@ def measurement_stats(meas, prefix=''):
    stats['quantity'] = val_cls.quantity
    stats[prefix + 'sample_cnt'] = len(values)
+    # Add start time for both type sysres and disk usage
+    start_time = time 
    mean_val = val_cls(mean(values))
    min_val = val_cls(min(values))
    max_val = val_cls(max(values))
@@ -334,6 +336,7 @@ def measurement_stats(meas, prefix=''):
    stats[prefix + 'max'] = max_val
    stats[prefix + 'minus'] = val_cls(mean_val - min_val)
    stats[prefix + 'plus'] = val_cls(max_val - mean_val)
+    stats[prefix + 'start_time'] = start_time
    return stats
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..fa6e1a34fd 100644
--- a/scripts/lib/devtool/__init__.py
+++ b/scripts/lib/devtool/__init__.py
@@ -234,7 +234,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 +256,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):
    """
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 7807b322b3..931408fa74 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):
@@ -288,6 +288,7 @@ class RecipeModified:
        self.bblayers = None
        self.bpn = None
        self.d = None
+        self.debug_build = None
        self.fakerootcmd = None
        self.fakerootenv = None
        self.libdir = None
@@ -333,7 +334,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(
@@ -348,6 +349,7 @@ class RecipeModified:
        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 +391,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 +403,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 +456,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 +508,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 +675,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
@@ -785,8 +712,6 @@ class RecipeModified:
        """Generate a script which does install and deploy"""
        cmd_lines = ['#!/bin/bash']
-        cmd_lines.append(self.gen_delete_package_dirs())
        # . oe-init-build-env $BUILDDIR
        # Note: Sourcing scripts with arguments requires bash
        cmd_lines.append('cd "%s" || { echo "cd %s failed"; exit 1; }' % (
@@ -988,6 +913,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 +927,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 +956,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'
@@ -1052,7 +993,7 @@ def register_commands(subparsers, context):
    parser_ide_sdk.add_argument(
        '-I', '--key', help='Specify ssh private key for connection to the target')
    parser_ide_sdk.add_argument(
-        '--skip-bitbake', help='Generate IDE configuration but skip calling bibtake to update the SDK.', action='store_true')
+        '--skip-bitbake', help='Generate IDE configuration but skip calling bitbake to update the SDK', action='store_true')
    parser_ide_sdk.add_argument(
        '-k', '--bitbake-k', help='Pass -k parameter to bitbake', action='store_true')
    parser_ide_sdk.add_argument(
@@ -1065,6 +1006,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 6674e67267..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,35 +644,22 @@ 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:
-            bb.process.run('git fetch file://' + srcsubdir + ' ' + devbranch + ':' + devbranch, cwd=srctree)
+            try:
+                logger.info('Backing up current %s branch as branch: %s.bak' % (devbranch, devbranch))
-            # Move the oe-local-files directory to srctree.
+                bb.process.run('git branch -f ' + devbranch + '.bak', cwd=srctree)
-            # As oe-local-files is not part of the constructed git tree,
-            # removing it directly during the synchronization might surprise
+                # Use git fetch to update the source with the current recipe
-            # the user.  Instead, we move it to oe-local-files.bak and remind
+                # To be able to update the currently checked out branch with
-            # the user in the log message.
+                # possibly new history (no fast-forward) git needs to be told
-            if os.path.exists(srctree_localdir + '.bak'):
+                # that's ok
-                shutil.rmtree(srctree_localdir + '.bak')
+                logger.info('Syncing source files including patches to git branch: %s' % devbranch)
+                bb.process.run('git fetch --update-head-ok --force file://' + srcsubdir + ' ' + devbranch + ':' + devbranch, cwd=srctree)
-            if os.path.exists(srctree_localdir):
+            except bb.process.ExecutionError as e:
-                logger.info('Backing up current local file directory %s' % srctree_localdir)
+                raise DevtoolError("Error when syncing source files to local checkout: %s" % str(e))
-                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)
+        else:
            shutil.move(srcsubdir, srctree)
-            symlink_oelocal_files_srctree(d, srctree)
        if is_kernel_yocto:
            logger.info('Copying kernel config to srctree')
@@ -704,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:
@@ -724,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)
@@ -755,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
@@ -840,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)
@@ -893,7 +850,10 @@ def modify(args, config, basepath, workspace):
                (stdout, _) = bb.process.run('git rev-list --reverse %s..HEAD' % initial_revs["."], cwd=srctree)
                commits["."] = stdout.split()
                check_commits = True
-                (stdout, _) = bb.process.run('git submodule --quiet foreach --recursive  \'echo `git rev-parse devtool-base` $PWD\'', cwd=srctree)
+                try:
+                    (stdout, _) = bb.process.run('git submodule --quiet foreach --recursive  \'echo `git rev-parse devtool-base` $PWD\'', cwd=srctree)
+                except bb.process.ExecutionError:
+                    stdout = ""
                for line in stdout.splitlines():
                    (rev, submodule_path) = line.split()
                    submodule = os.path.relpath(submodule_path, srctree)
@@ -947,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:
@@ -987,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'
@@ -1017,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])
@@ -1061,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)
@@ -1138,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):
@@ -1226,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',
@@ -1352,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}-)?(.+)')
@@ -1373,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)
@@ -1421,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')
@@ -1452,16 +1412,21 @@ def _export_local_files(srctree, rd, destdir, srctreebase):
         1. updated - files that already exist in SRCURI
         2. added - new files files that don't exist in SRCURI
         3  removed - files that exist in SRCURI but not in exported files
-      In each dict the key is the 'basepath' of the URI and value is the
+       In each dict the key is the 'basepath' of the URI and value is:
-      absolute path to the existing file in recipe space (if any).
+         - for updated and added dicts, a dict with 1 optionnal key:
+           - 'path': the absolute path to the existing file in recipe space (if any)
+         - 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()
@@ -1478,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):
@@ -1503,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
@@ -1521,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] = origpath
-            elif fname != '.gitignore':
-                added[fname] = None
-        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] = origpath
-        removed = existing_files
    return (updated, added, removed)
@@ -1574,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 ''
@@ -1612,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)
@@ -1640,7 +1578,8 @@ def _update_recipe_srcrev(recipename, workspace, srctree, rd, appendlayerdir, wi
                    redirect_output=dry_run_outdir)
        else:
            files_dir = _determine_files_dir(rd)
-            for basepath, path in upd_f.items():
+            for basepath, param in upd_f.items():
+                path = param['path']
                logger.info('Updating file %s%s' % (basepath, dry_run_suffix))
                if os.path.isabs(basepath):
                    # Original file (probably with subdir pointing inside source tree)
@@ -1650,7 +1589,8 @@ def _update_recipe_srcrev(recipename, workspace, srctree, rd, appendlayerdir, wi
                    _move_file(os.path.join(local_files_dir, basepath), path,
                               dry_run_outdir=dry_run_outdir, base_outdir=recipedir)
                update_srcuri= True
-            for basepath, path in new_f.items():
+            for basepath, param in new_f.items():
+                path = param['path']
                logger.info('Adding new file %s%s' % (basepath, dry_run_suffix))
                _move_file(os.path.join(local_files_dir, basepath),
                           os.path.join(files_dir, basepath),
@@ -1673,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')
@@ -1772,7 +1711,8 @@ def _update_recipe_patch(recipename, workspace, srctree, rd, appendlayerdir, wil
        else:
            # Update existing files
            files_dir = _determine_files_dir(rd)
-            for basepath, path in upd_f.items():
+            for basepath, param in upd_f.items():
+                path = param['path']
                logger.info('Updating file %s' % basepath)
                if os.path.isabs(basepath):
                    # Original file (probably with subdir pointing inside source tree)
@@ -1786,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:
@@ -1806,7 +1747,7 @@ def _update_recipe_patch(recipename, workspace, srctree, rd, appendlayerdir, wil
                           dry_run_outdir=dry_run_outdir, base_outdir=recipedir)
                updatefiles = True
            # Add any new files
-            for basepath, path in new_f.items():
+            for basepath, param in new_f.items():
                logger.info('Adding new file %s%s' % (basepath, dry_run_suffix))
                _move_file(os.path.join(local_files_dir, basepath),
                           os.path.join(files_dir, basepath),
@@ -1851,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:
@@ -1872,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)
@@ -1994,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):
@@ -2006,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:
@@ -2097,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 = ""
@@ -2377,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..d9aca6e2db 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:
@@ -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 341e893305..041d79f162 100644
--- a/scripts/lib/recipetool/append.py
+++ b/scripts/lib/recipetool/append.py
@@ -101,7 +101,7 @@ def determine_file_source(targetpath, rd):
    import oe.recipeutils
    # See if it's in do_install for the recipe
-    workdir = rd.getVar('WORKDIR')
+    unpackdir = rd.getVar('UNPACKDIR')
    src_uri = rd.getVar('SRC_URI')
    srcfile = ''
    modpatches = []
@@ -113,9 +113,9 @@ def determine_file_source(targetpath, rd):
        if not srcpath.startswith('/'):
            # Handle non-absolute path
            srcpath = os.path.abspath(os.path.join(rd.getVarFlag('do_install', 'dirs').split()[-1], srcpath))
-        if srcpath.startswith(workdir):
+        if srcpath.startswith(unpackdir):
            # OK, now we have the source file name, look for it in SRC_URI
-            workdirfile = os.path.relpath(srcpath, workdir)
+            workdirfile = os.path.relpath(srcpath, unpackdir)
            # FIXME this is where we ought to have some code in the fetcher, because this is naive
            for item in src_uri.split():
                localpath = bb.fetch2.localpath(item, rd)
@@ -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 c560831442..4b1fa39d13 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
 import bb.utils
 import json
@@ -25,33 +19,20 @@ 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
    tinfoil = instance
 class GoRecipeHandler(RecipeHandler):
    """Class to handle the go recipe creation"""
@@ -83,580 +64,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:
-                        self.__srv = content[0][1].split()
-            @property
-            def import_prefix(self):
-                return self.__srv[0] if len(self.__srv) else None
-            @property
-            def vcs(self):
-                return self.__srv[1] if len(self.__srv) else None
-            @property
-            def repourl(self):
-                return self.__srv[2] if len(self.__srv) else None
-        url = url.geturl() + "?go-get=1"
-        req = urllib.request.Request(url)
-        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
-        parser = GoImportHTMLParser()
-        parser.feed(resp.read().decode('utf-8'))
-        parser.close()
-        return GoImport(parser.import_prefix, parser.vcs, parser.repourl, None)
-    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):
@@ -667,63 +74,52 @@ 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"
-        go_mod = json.loads(stdout)
+        with tempfile.TemporaryDirectory(prefix="go-mod-") as tmp_mod_dir:
-        go_import = go_mod['Module']['Path']
+            env = dict(os.environ)
-        go_version_match = re.match("([0-9]+).([0-9]+)", go_mod['Go'])
+            env["PATH"] += f":{go_bindir}"
-        go_version_major = int(go_version_match.group(1))
+            env['GOMODCACHE'] = tmp_mod_dir
-        go_version_minor = int(go_version_match.group(2))
-        src_uris = []
-        localfilesdir = tempfile.mkdtemp(prefix='recipetool-go-')
+            stdout = subprocess.check_output(["go", "mod", "edit", "-json"], cwd=srctree, env=env, text=True)
-        extravalues.setdefault('extrafiles', {})
+            go_mod = json.loads(stdout)
+            go_import = re.sub(r'/v([0-9]+)$', '', go_mod['Module']['Path'])
-        # Use an explicit name determined from the module name because it
+            localfilesdir = tempfile.mkdtemp(prefix='recipetool-go-')
-        # might differ from the actual URL for replaced modules
+            extravalues.setdefault('extrafiles', {})
-        # strip version part from module URL /vXX
-        baseurl = re.sub(r'/v(\d+)$', '', go_mod['Module']['Path'])
-        pn, _ = determine_from_url(baseurl)
-        # go.mod files with version < 1.17 may not include all indirect
+            # Write the stub ${BPN}-licenses.inc and ${BPN}-go-mods.inc files
-        # dependencies. Thus, we have to upgrade the go version.
+            basename = "{pn}-licenses.inc"
-        if go_version_major == 1 and go_version_minor < 17:
+            filename = os.path.join(localfilesdir, basename)
-            logger.warning(
+            with open(filename, "w") as f:
-                "go.mod files generated by Go < 1.17 might have incomplete indirect dependencies.")
+                f.write("# FROM RECIPETOOL\n")
-            go_mod, patchfilename = self.__go_mod_patch(srctree, localfilesdir,
+            extravalues['extrafiles'][f"../{basename}"] = filename
-                                                        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.
+            basename = "{pn}-go-mods.inc"
-        # Otherwise we gather all dependencies and add them to the recipe
+            filename = os.path.join(localfilesdir, basename)
-        if not os.path.exists(os.path.join(srctree, "vendor")):
+            with open(filename, "w") as f:
+                f.write("# FROM RECIPETOOL\n")
+            extravalues['extrafiles'][f"../{basename}"] = filename
-            # Write additional $BPN-modules.inc file
+            # Do generic license handling
-            self.__go_mod_vendor(go_mod, srctree, localfilesdir, extravalues, d)
+            d = bb.data.createCopy(tinfoil.config_data)
-            lines_before.append("LICENSE += \" & ${GO_MOD_LICENSES}\"")
+            handle_license_vars(srctree, lines_before, handled, extravalues, d)
-            lines_before.append("require %s-licenses.inc" % (pn))
+            self.__rewrite_lic_vars(lines_before)
-            self.__rewrite_src_uri(lines_before, ["file://modules.txt"])
+            self.__rewrite_src_uri(lines_before)
-            self.__go_handle_dependencies(go_mod, srctree, localfilesdir, extravalues, d)
+            lines_before.append('require ${BPN}-licenses.inc')
-            lines_before.append("require %s-modules.inc" % (pn))
+            lines_before.append('require ${BPN}-go-mods.inc')
+            lines_before.append(f'GO_IMPORT = "{go_import}"')
-        # Do generic license handling
-        handle_license_vars(srctree, lines_before, handled, extravalues, d)
-        self.__rewrite_lic_uri(lines_before)
-        lines_before.append("GO_IMPORT = \"{}\"".format(baseurl))
-        lines_before.append("SRCREV_FORMAT = \"${BPN}\"")
    def __update_lines_before(self, updated, newlines, lines_before):
        if updated:
@@ -735,9 +131,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('\\')
@@ -762,12 +158,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..2e3061f343 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
@@ -1045,6 +1058,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 +1088,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/partition.py b/scripts/lib/wic/partition.py
index 795707ec5d..b34691d313 100644
--- a/scripts/lib/wic/partition.py
+++ b/scripts/lib/wic/partition.py
@@ -164,6 +164,9 @@ 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"
@@ -178,7 +181,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)
@@ -222,19 +225,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 +247,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 +287,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 +336,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):
        """
@@ -437,13 +446,16 @@ class Partition():
        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)
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-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
index a207a83530..21f41e00bb 100644
--- a/scripts/lib/wic/plugins/source/bootimg-pcbios.py
+++ b/scripts/lib/wic/plugins/source/bootimg_pcbios.py
@@ -4,7 +4,7 @@
 # SPDX-License-Identifier: GPL-2.0-only
 #
 # DESCRIPTION
-# This implements the 'bootimg-pcbios' source plugin class for 'wic'
+# This implements the 'bootimg_pcbios' source plugin class for 'wic'
 #
 # AUTHORS
 # Tom Zanussi <tom.zanussi (at] linux.intel.com>
@@ -27,7 +27,7 @@ class BootimgPcbiosPlugin(SourcePlugin):
    Create MBR boot partition and install syslinux on it.
    """
-    name = 'bootimg-pcbios'
+    name = 'bootimg_pcbios'
    @classmethod
    def _get_bootimg_dir(cls, bootimg_dir, dirname):
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 e29f3a4c2f..06fce06bb1 100644
--- a/scripts/lib/wic/plugins/source/rootfs.py
+++ b/scripts/lib/wic/plugins/source/rootfs.py
@@ -41,9 +41,9 @@ 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:" % (cmd, path))
+            logger.error("%s: Must point inside the rootfs: %s" % (cmd, path))
            sys.exit(1)
        return full_path
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 7812ea4540..a36f3c1bca 100755
--- a/scripts/oe-build-perf-report
+++ b/scripts/oe-build-perf-report
@@ -336,8 +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')
-                samples.append(measurement_stats(meas_i))
+                commit = get_data_item(meta, 'layers.meta.commit')
+                # Add start_time for both test measurement types of sysres and disk usage
+                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']
@@ -473,7 +481,7 @@ Examine build performance test results from a Git repository"""
    group.add_argument('--branch', '-B', default='master', help="Branch to find commit in")
    group.add_argument('--branch2', help="Branch to find comparision revisions in")
    group.add_argument('--machine', default='qemux86')
-    group.add_argument('--history-length', default=25, type=int,
+    group.add_argument('--history-length', default=300, type=int,
                       help="Number of tested revisions to plot in html report")
    group.add_argument('--commit',
                       help="Revision to search for")
diff --git a/scripts/oe-debuginfod b/scripts/oe-debuginfod
index b525310225..5e70d37b8b 100755
--- a/scripts/oe-debuginfod
+++ b/scripts/oe-debuginfod
@@ -15,14 +15,29 @@ scriptpath.add_bitbake_lib_path()
 import bb.tinfoil
 import subprocess
+import argparse
 if __name__ == "__main__":
+    p = argparse.ArgumentParser()
+    p.add_argument("-d", action='store_true', \
+                         help="store debuginfod files in project sub-directory")
+    
+    args = p.parse_args()
+    
    with bb.tinfoil.Tinfoil() as tinfoil:
        tinfoil.prepare(config_only=True)
        package_classes_var = "DEPLOY_DIR_" + tinfoil.config_data.getVar("PACKAGE_CLASSES").split()[0].replace("package_", "").upper()
        feed_dir = tinfoil.config_data.getVar(package_classes_var, expand=True)
+    opts = [ '--verbose', '-R', '-U', feed_dir ]
+    
+    if args.d:
+        fdir = os.path.join(os.getcwd(), 'oedid-files')
+        os.makedirs(fdir, exist_ok=True)
+        opts += [ '-d', os.path.join(fdir, 'did.sqlite') ]
+        
    subprocess.call(['bitbake', '-c', 'addto_recipe_sysroot', 'elfutils-native'])
-    subprocess.call(['oe-run-native', 'elfutils-native', 'debuginfod', '--verbose', '-R', '-U', feed_dir])
+    subprocess.call(['oe-run-native', 'elfutils-native', 'debuginfod'] + opts)
+    # we should not get here
    print("\nTo use the debuginfod server please ensure that this variable PACKAGECONFIG:pn-elfutils-native = \"debuginfod libdebuginfod\" is set in the local.conf")
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 5364f2b481..49603d9fd1 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,11 +89,20 @@ 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 = "TEMPLATECONF={} . {} {}".format(template["templatepath"], os.path.join(coredir, 'oe-init-build-env'), builddir)
+    cmd_base = ". {} {}".format(os.path.join(coredir, 'oe-init-build-env'), os.path.abspath(builddir))
+    initbuild = os.path.join(builddir, 'init-build-env')
+    if not os.path.exists(initbuild):
+        os.makedirs(builddir, exist_ok=True)
+        with open(initbuild, 'w') as f:
+            f.write(cmd_base)
+    print("\nRun '. {}' to initialize the build in a current shell session.\n".format(initbuild))
+    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/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..3c1ee1af1d 100644
--- a/scripts/patchtest.README
+++ b/scripts/patchtest.README
@@ -3,40 +3,35 @@
 ## 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.
+- a patch in mbox format (either created with `git format-patch` or fetched
+from 'patchwork')
+- 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; in 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 patchtest layer, in addition to
-available in oe-core: https://git.yoctoproject.org/patchtest/
+the tools available in oe-core: https://git.yoctoproject.org/patchtest/
 ## Installation
-As a tool for use with the Yocto Project, the [quick start guide](https://docs.yoctoproject.org/brief-yoctoprojectqs/index.html) 
+As a tool for use with the Yocto Project, the [quick start
-contains the necessary prerequisites for a basic project. In addition,
+guide](https://docs.yoctoproject.org/brief-yoctoprojectqs/index.html)
-patchtest relies on the following Python modules:
+contains the necessary prerequisites. In addition, patchtest relies on
+several Python modules for parsing and analysis, which can be installed
- boto3 (for sending automated results emails only)
+by running `pip install -r meta/lib/patchtest/requirements.txt`. Note
- git-pw>=2.5.0
+that git-pw is not automatically added to the user's PATH; by default,
- jinja2
+it is installed at ~/.local/bin/git-pw.
- pylint
- pyparsing>=3.0.9
- unidiff
-These can be installed by running `pip install -r
-meta/lib/patchtest/requirements.txt`. Note that git-pw is not
-automatically added to the user's PATH; by default, it is installed at
-~/.local/bin/git-pw.
 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 (the project
@@ -74,7 +69,7 @@ the target project, but these parameters can be configured using the `--limit`,
 To run patchtest on the host, do the following:
 1. In openembedded-core/poky, do `source oe-init-build-env`
-2. Generate patch files from the target repository by doing `git-format patch -N`,
+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:
@@ -123,7 +118,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 +126,17 @@ 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.
 ## 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..16739a0fa1 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
@@ -437,6 +442,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)
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..3d77046972 100755
--- a/scripts/runqemu
+++ b/scripts/runqemu
@@ -468,9 +468,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 +481,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"):
@@ -1192,19 +1195,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 +1301,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 +1464,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 +1474,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 +1493,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 +1513,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"
@@ -1669,6 +1679,9 @@ 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:
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)