160 files changed, 0 insertions, 19226 deletions

diff --git a/meta/classes-recipe/allarch.bbclass b/meta/classes-recipe/allarch.bbclass
deleted file mode 100644
index e429b92437..0000000000
--- a/meta/classes-recipe/allarch.bbclass
+++ /dev/null
@@ -1,71 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-#
-# This class is used for architecture independent recipes/data files (usually scripts)
-#
-
-python allarch_package_arch_handler () {
-    if bb.data.inherits_class("native", d) or bb.data.inherits_class("nativesdk", d) \
-        or bb.data.inherits_class("crosssdk", d):
-        return
-
-    variants = d.getVar("MULTILIB_VARIANTS")
-    if not variants:
-        d.setVar("PACKAGE_ARCH", "all" )
-}
-
-addhandler allarch_package_arch_handler
-allarch_package_arch_handler[eventmask] = "bb.event.RecipePreFinalise"
-
-python () {
-    # Allow this class to be included but overridden - only set
-    # the values if we're still "all" package arch.
-    if d.getVar("PACKAGE_ARCH") == "all":
-        # No need for virtual/libc or a cross compiler
-        d.setVar("INHIBIT_DEFAULT_DEPS","1")
-
-        # Set these to a common set of values, we shouldn't be using them other that for WORKDIR directory
-        # naming anyway
-        d.setVar("baselib", "lib")
-        d.setVar("TARGET_ARCH", "allarch")
-        d.setVar("TARGET_OS", "linux")
-        d.setVar("TARGET_CC_ARCH", "none")
-        d.setVar("TARGET_LD_ARCH", "none")
-        d.setVar("TARGET_AS_ARCH", "none")
-        d.setVar("TARGET_FPU", "")
-        d.setVar("TARGET_PREFIX", "")
-        # Expand PACKAGE_EXTRA_ARCHS since the staging code needs this
-        # (this removes any dependencies from the hash perspective)
-        d.setVar("PACKAGE_EXTRA_ARCHS", d.getVar("PACKAGE_EXTRA_ARCHS"))
-        d.setVar("SDK_ARCH", "none")
-        d.setVar("SDK_CC_ARCH", "none")
-        d.setVar("TARGET_CPPFLAGS", "none")
-        d.setVar("TARGET_CFLAGS", "none")
-        d.setVar("TARGET_CXXFLAGS", "none")
-        d.setVar("TARGET_LDFLAGS", "none")
-        d.setVar("POPULATESYSROOTDEPS", "")
-
-        # Avoid this being unnecessarily different due to nuances of
-        # the target machine that aren't important for "all" arch
-        # packages.
-        d.setVar("LDFLAGS", "")
-
-        # No need to do shared library processing or debug symbol handling
-        d.setVar("EXCLUDE_FROM_SHLIBS", "1")
-        d.setVar("INHIBIT_PACKAGE_DEBUG_SPLIT", "1")
-        d.setVar("INHIBIT_PACKAGE_STRIP", "1")
-
-        # These multilib values shouldn't change allarch packages so exclude them
-        d.appendVarFlag("emit_pkgdata", "vardepsexclude", " MULTILIB_VARIANTS")
-        d.appendVarFlag("write_specfile", "vardepsexclude", " MULTILIBS")
-        d.appendVarFlag("do_package", "vardepsexclude", " package_do_shlibs")
-
-        d.setVar("qemu_wrapper_cmdline", "def qemu_wrapper_cmdline(data, rootfs_path, library_paths):\n    return 'false'")
-    elif bb.data.inherits_class('packagegroup', d) and not bb.data.inherits_class('nativesdk', d):
-        bb.error("Please ensure recipe %s sets PACKAGE_ARCH before inherit packagegroup" % d.getVar("FILE"))
-}
-
diff --git a/meta/classes-recipe/autotools-brokensep.bbclass b/meta/classes-recipe/autotools-brokensep.bbclass
deleted file mode 100644
index a0fb4b7b50..0000000000
--- a/meta/classes-recipe/autotools-brokensep.bbclass
+++ /dev/null
@@ -1,11 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-# Autotools class for recipes where separate build dir doesn't work
-# Ideally we should fix software so it does work. Standard autotools supports
-# this.
-inherit autotools
-B = "${S}"
diff --git a/meta/classes-recipe/autotools.bbclass b/meta/classes-recipe/autotools.bbclass
deleted file mode 100644
index bd477dc60f..0000000000
--- a/meta/classes-recipe/autotools.bbclass
+++ /dev/null
@@ -1,248 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-def get_autotools_dep(d):
-    if d.getVar('INHIBIT_AUTOTOOLS_DEPS'):
-        return ''
-
-    pn = d.getVar('PN')
-    deps = ''
-
-    if pn in ['autoconf-native', 'automake-native']:
-        return deps
-    deps += 'autoconf-native automake-native '
-
-    if not pn in ['libtool', 'libtool-native'] and not pn.endswith("libtool-cross"):
-        deps += 'libtool-native '
-        if not bb.data.inherits_class('native', d) \
-                        and not bb.data.inherits_class('nativesdk', d) \
-                        and not bb.data.inherits_class('cross', d) \
-                        and not d.getVar('INHIBIT_DEFAULT_DEPS'):
-            deps += 'libtool-cross '
-
-    return deps
-
-
-DEPENDS:prepend = "${@get_autotools_dep(d)} "
-
-inherit siteinfo
-
-# Space separated list of shell scripts with variables defined to supply test
-# results for autoconf tests we cannot run at build time.
-# The value of this variable is filled in in a prefunc because it depends on
-# the contents of the sysroot.
-export CONFIG_SITE
-
-EXTRA_AUTORECONF += "--exclude=autopoint"
-
-export lt_cv_sys_lib_dlsearch_path_spec = "${libdir} ${base_libdir}"
-
-# When building tools for use at build-time it's recommended for the build
-# system to use these variables when cross-compiling.
-# https://www.gnu.org/software/autoconf-archive/ax_prog_cc_for_build.html
-# https://stackoverflow.com/questions/24201260/autotools-cross-compilation-and-generated-sources/24208587#24208587
-export CPP_FOR_BUILD = "${BUILD_CPP}"
-export CPPFLAGS_FOR_BUILD = "${BUILD_CPPFLAGS}"
-
-export CC_FOR_BUILD = "${BUILD_CC}"
-export CFLAGS_FOR_BUILD = "${BUILD_CFLAGS}"
-
-export CXX_FOR_BUILD = "${BUILD_CXX}"
-export CXXFLAGS_FOR_BUILD = "${BUILD_CXXFLAGS}"
-
-export LD_FOR_BUILD = "${BUILD_LD}"
-export LDFLAGS_FOR_BUILD = "${BUILD_LDFLAGS}"
-
-CONFIGUREOPTS = " --build=${BUILD_SYS} \
-                  --host=${HOST_SYS} \
-                  --target=${TARGET_SYS} \
-                  --prefix=${prefix} \
-                  --exec_prefix=${exec_prefix} \
-                  --bindir=${bindir} \
-                  --sbindir=${sbindir} \
-                  --libexecdir=${libexecdir} \
-                  --datadir=${datadir} \
-                  --sysconfdir=${sysconfdir} \
-                  --sharedstatedir=${sharedstatedir} \
-                  --localstatedir=${localstatedir} \
-                  --libdir=${libdir} \
-                  --includedir=${includedir} \
-                  --oldincludedir=${includedir} \
-                  --infodir=${infodir} \
-                  --mandir=${mandir} \
-                  --disable-silent-rules \
-                  ${CONFIGUREOPT_DEPTRACK}"
-CONFIGUREOPT_DEPTRACK ?= "--disable-dependency-tracking"
-
-CACHED_CONFIGUREVARS ?= ""
-
-AUTOTOOLS_SCRIPT_PATH ?= "${S}"
-CONFIGURE_SCRIPT ?= "${AUTOTOOLS_SCRIPT_PATH}/configure"
-
-AUTOTOOLS_AUXDIR ?= "${AUTOTOOLS_SCRIPT_PATH}"
-
-oe_runconf () {
-        # Use relative path to avoid buildpaths in files
-        cfgscript_name="`basename ${CONFIGURE_SCRIPT}`"
-        cfgscript=`python3 -c "import os; print(os.path.relpath(os.path.dirname('${CONFIGURE_SCRIPT}'), '.'))"`/$cfgscript_name
-        if [ -x "$cfgscript" ] ; then
-                bbnote "Running $cfgscript ${CONFIGUREOPTS} ${EXTRA_OECONF} $@"
-                if ! CONFIG_SHELL=${CONFIG_SHELL-/bin/bash} ${CACHED_CONFIGUREVARS} $cfgscript ${CONFIGUREOPTS} ${EXTRA_OECONF} "$@"; then
-                        bbnote "The following config.log files may provide further information."
-                        bbnote `find ${B} -ignore_readdir_race -type f -name config.log`
-                        bbfatal_log "configure failed"
-                fi
-        else
-                bbfatal "no configure script found at $cfgscript"
-        fi
-}
-
-CONFIGURESTAMPFILE = "${WORKDIR}/configure.sstate"
-
-autotools_preconfigure() {
-        if [ -n "${CONFIGURESTAMPFILE}" -a -e "${CONFIGURESTAMPFILE}" ]; then
-                if [ "`cat ${CONFIGURESTAMPFILE}`" != "${BB_TASKHASH}" ]; then
-                        if [ "${S}" != "${B}" ]; then
-                                echo "Previously configured separate build directory detected, cleaning ${B}"
-                                rm -rf ${B}
-                                mkdir -p ${B}
-                        else
-                                # At least remove the .la files since automake won't automatically
-                                # regenerate them even if CFLAGS/LDFLAGS are different
-                                cd ${S}
-                                if [ "${CLEANBROKEN}" != "1" -a \( -e Makefile -o -e makefile -o -e GNUmakefile \) ]; then
-                                        oe_runmake clean
-                                fi
-                                find ${S} -ignore_readdir_race -name \*.la -delete
-                        fi
-                fi
-        fi
-}
-
-autotools_postconfigure(){
-        if [ -n "${CONFIGURESTAMPFILE}" ]; then
-                mkdir -p `dirname ${CONFIGURESTAMPFILE}`
-                echo ${BB_TASKHASH} > ${CONFIGURESTAMPFILE}
-        fi
-}
-
-EXTRACONFFUNCS ??= ""
-
-EXTRA_OECONF:append = " ${PACKAGECONFIG_CONFARGS}"
-
-do_configure[prefuncs] += "autotools_preconfigure autotools_sitefiles ${EXTRACONFFUNCS}"
-do_configure[postfuncs] += "autotools_postconfigure"
-
-# Tell autoconf to load the site defaults from siteinfo
-python autotools_sitefiles () {
-    sitefiles, searched = siteinfo_get_files(d, sysrootcache=True)
-    d.setVar("CONFIG_SITE", " ".join(sitefiles))
-}
-
-do_configure[file-checksums] += "${@' '.join(siteinfo_get_files(d, sysrootcache=False)[1])}"
-
-CONFIGURE_FILES = "${S}/configure.in ${S}/configure.ac ${S}/config.h.in *.m4 Makefile.am"
-
-autotools_do_configure() {
-        # WARNING: gross hack follows:
-        # An autotools built package generally needs these scripts, however only
-        # automake or libtoolize actually install the current versions of them.
-        # This is a problem in builds that do not use libtool or automake, in the case
-        # where we -need- the latest version of these scripts.  e.g. running a build
-        # for a package whose autotools are old, on an x86_64 machine, which the old
-        # config.sub does not support.  Work around this by installing them manually
-        # regardless.
-
-        PRUNE_M4=""
-
-        for ac in `find ${S} -ignore_readdir_race -name configure.in -o -name configure.ac`; do
-                rm -f `dirname $ac`/configure
-        done
-        if [ -e ${AUTOTOOLS_SCRIPT_PATH}/configure.in -o -e ${AUTOTOOLS_SCRIPT_PATH}/configure.ac ]; then
-                olddir=`pwd`
-                cd ${AUTOTOOLS_SCRIPT_PATH}
-                # aclocal looks in the native sysroot by default, so tell it to also look in the target sysroot.
-                ACLOCAL="aclocal --aclocal-path=${STAGING_DATADIR}/aclocal/"
-                # autoreconf is too shy to overwrite aclocal.m4 if it doesn't look
-                # like it was auto-generated.  Work around this by blowing it away
-                # by hand, unless the package specifically asked not to run aclocal.
-                if ! echo ${EXTRA_AUTORECONF} | grep -q "aclocal"; then
-                        bbnote Removing existing aclocal.m4
-                        rm -f aclocal.m4
-                fi
-                if [ -e configure.in ]; then
-                        CONFIGURE_AC=configure.in
-                else
-                        CONFIGURE_AC=configure.ac
-                fi
-                if grep -q "^[[:space:]]*AM_GLIB_GNU_GETTEXT" $CONFIGURE_AC; then
-                        if grep -q "sed.*POTFILES" $CONFIGURE_AC; then
-                                : do nothing -- we still have an old unmodified configure.ac
-                        else
-                                bbnote Executing glib-gettextize --force --copy
-                                echo "no" | glib-gettextize --force --copy
-                        fi
-                elif [ "${BPN}" != "gettext" ] && grep -q "^[[:space:]]*AM_GNU_GETTEXT" $CONFIGURE_AC; then
-                        # Gettextize could be called here, however it doesn't make the job much easier:
-                        # It doesn't discover relevant po folders on its own, so they still need to be
-                        # found by some heurestics. Also, it would require always the full gettext
-                        # package always, instead of gettext-minimal-native.
-                        cp ${STAGING_DATADIR_NATIVE}/gettext/config.rpath ${AUTOTOOLS_AUXDIR}/
-                        if [ -d ${S}/po ]; then
-                                # Copy the latest Makefile.in.in to the /po folder, regardless if it exists or not
-                                # If it exists, then also look for identical Makefile.in.in files, and update them too
-                                makefiles_to_update="./po/Makefile.in.in"
-                                if [ -f ${S}/po/Makefile.in.in ]; then
-                                        # search for all Makefile.in.in files that are identical to ./po/Makefile.in.in, by md5sum
-                                        base_makefile_hash=`md5sum ${S}/po/Makefile.in.in | tr -s ' ' | cut -f1 -d' '`
-                                        makefiles_to_update=`find ${S} -name Makefile.in.in -exec md5sum {} \+ | grep $base_makefile_hash | tr -s ' ' | cut -d' ' -f2`
-                                fi
-                                bbnote List of Makefile.in.ins to update: $makefiles_to_update
-                                for makefile in ${makefiles_to_update}; do
-                                        makefile_dir=$(dirname $makefile)
-                                        bbnote Executing: cp ${STAGING_DATADIR_NATIVE}/gettext/po/Makefile.in.in ${makefile_dir}/
-                                        cp ${STAGING_DATADIR_NATIVE}/gettext/po/Makefile.in.in ${makefile_dir}/
-                                        if [ ! -e ${makefile_dir}/remove-potcdate.sed ]; then
-                                                cp ${STAGING_DATADIR_NATIVE}/gettext/po/remove-potcdate.sed ${makefile_dir}/
-                                        fi
-                                done
-                                for makevars in `find ${S} -name Makevars`; do
-                                        bbnote Concatenating Makevars: $makevars
-                                        cat ${STAGING_DATADIR_NATIVE}/gettext/po/Makevars.template.minimal ${makevars} >> ${makevars}.yocto_temp
-                                        mv ${makevars}.yocto_temp ${makevars}
-                                done
-                        fi
-                        PRUNE_M4="$PRUNE_M4 gettext.m4 iconv.m4 lib-ld.m4 lib-link.m4 lib-prefix.m4 nls.m4 po.m4 progtest.m4"
-                fi
-                mkdir -p m4
-
-                for i in $PRUNE_M4; do
-                        find ${S} -ignore_readdir_race -name $i -delete
-                done
-
-                bbnote Executing ACLOCAL=\"$ACLOCAL\" autoreconf -Wcross --verbose --install --force ${EXTRA_AUTORECONF}
-                ACLOCAL="$ACLOCAL" autoreconf -Wcross -Wno-obsolete --verbose --install --force ${EXTRA_AUTORECONF} || die "autoreconf execution failed."
-                cd $olddir
-        fi
-
-        oe_runconf
-}
-
-autotools_do_compile() {
-        oe_runmake
-}
-
-autotools_do_install() {
-        oe_runmake 'DESTDIR=${D}' install
-        # Info dir listing isn't interesting at this point so remove it if it exists.
-        if [ -e "${D}${infodir}/dir" ]; then
-                rm -f ${D}${infodir}/dir
-        fi
-}
-
-EXPORT_FUNCTIONS do_configure do_compile do_install
-
-B = "${WORKDIR}/build"
diff --git a/meta/classes-recipe/barebox.bbclass b/meta/classes-recipe/barebox.bbclass
deleted file mode 100644
index 73615999aa..0000000000
--- a/meta/classes-recipe/barebox.bbclass
+++ /dev/null
@@ -1,162 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-inherit kernel-arch deploy cml1 pkgconfig
-
-LICENSE ?= "GPL-2.0-only"
-
-PROVIDES += "virtual/bootloader"
-
-PACKAGE_ARCH = "${MACHINE_ARCH}"
-
-DEPENDS += "bison-native flex-native lz4-native"
-
-S = "${UNPACKDIR}/barebox-${PV}"
-B = "${WORKDIR}/build"
-KBUILD_OUTPUT = "${B}"
-OE_TERMINAL_EXPORTS += "KBUILD_OUTPUT"
-
-require conf/image-uefi.conf
-
-# For some platforms and configuration, the barebox build process will require
-# additional host tools that can be activated/deactivated here.
-PACKAGECONFIG ??= "openssl libusb fit"
-
-PACKAGECONFIG[openssl] = ",,openssl-native"
-PACKAGECONFIG[libusb] = ",,libusb1-native"
-PACKAGECONFIG[fit] = ",,u-boot-tools-native dtc-native"
-
-export KBUILD_BUILD_USER ?= "oe-user"
-export KBUILD_BUILD_HOST ?= "oe-host"
-
-# unlike the kernel, barebox may build against host tools like openssl
-export HOST_EXTRACFLAGS
-
-def get_layer_rev(path):
-    try:
-        rev, _ = bb.process.run("git describe --match='' --always --dirty --broken", cwd=path)
-    except bb.process.ExecutionError:
-        rev = ""
-    return rev.strip()
-
-BAREBOX_BUILDSYSTEM_VERSION[doc] = "Build system version to add to the barebox image. By default this is the git description of the containing layer."
-BAREBOX_BUILDSYSTEM_VERSION ??= "${@get_layer_rev(os.path.dirname(d.getVar('FILE')))}"
-
-BAREBOX_FIRMWARE_DIR[doc] = "Overwrite barebox' firmware blobs search directory (CONFIG_EXTRA_FIRMWARE_DIR) with this path, default ${B}/firmware"
-BAREBOX_FIRMWARE_DIR ??= "${B}/firmware"
-
-EXTRA_OEMAKE = " \
-    CROSS_COMPILE=${TARGET_PREFIX} -C ${S} O=${B} \
-    BUILDSYSTEM_VERSION=${BAREBOX_BUILDSYSTEM_VERSION} \
-    CONFIG_EXTRA_FIRMWARE_DIR=${BAREBOX_FIRMWARE_DIR} \
-    PKG_CONFIG=pkg-config-native \
-    CROSS_PKG_CONFIG=pkg-config \
-"
-
-BAREBOX_CONFIG[doc] = "The barebox kconfig defconfig file. Not used if a file called defconfig is added to the SRC_URI."
-BAREBOX_CONFIG ?= ""
-
-# set sensible default configs for some of oe-core's QEMU MACHINEs
-BAREBOX_CONFIG:qemuarm = "multi_v7_defconfig"
-BAREBOX_CONFIG:qemuarm64 = "multi_v8_defconfig"
-BAREBOX_CONFIG:qemux86-64 = "efi_defconfig"
-
-# prevent from acting as non-buildable provider
-python () {
-    bareboxconfig = d.getVar('BAREBOX_CONFIG')
-    bareboxdefconfig = 'file://defconfig' in d.getVar('SRC_URI')
-
-    if not bareboxconfig and not bareboxdefconfig:
-        raise bb.parse.SkipRecipe("BAREBOX_CONFIG must be set in the %s machine configuration or file://defconfig must be given in SRC_URI." % d.getVar("MACHINE"))
-}
-
-barebox_do_configure() {
-        if [ -e ${UNPACKDIR}/defconfig ]; then
-                cp ${UNPACKDIR}/defconfig ${B}/.config
-        else
-                if [ -n "${BAREBOX_CONFIG}" ]; then
-                        oe_runmake ${BAREBOX_CONFIG}
-                else
-                        bbfatal "No defconfig given. Either add file 'file://defconfig' to SRC_URI or set BAREBOX_CONFIG"
-                fi
-        fi
-
-        ${S}/scripts/kconfig/merge_config.sh -m .config ${@" ".join(find_cfgs(d))}
-        cml1_do_configure
-}
-
-BAREBOX_ENV_DIR[doc] = "Overlay the barebox built-in environment with the environment provided by the BSP if specified."
-BAREBOX_ENV_DIR ??= "${UNPACKDIR}/env/"
-
-barebox_do_compile () {
-        export userccflags="${TARGET_LDFLAGS}${HOST_CC_ARCH}${TOOLCHAIN_OPTIONS}"
-        unset LDFLAGS
-        unset CFLAGS
-        unset CPPFLAGS
-        unset CXXFLAGS
-        unset MACHINE
-        # Allow to use ${UNPACKDIR} in kconfig options to include additionally fetched files
-        export UNPACKDIR=${UNPACKDIR}
-
-        if [ -d ${BAREBOX_ENV_DIR} ]; then
-                BAREBOX_DEFAULT_ENV="$(grep ^CONFIG_DEFAULT_ENVIRONMENT_PATH .config | cut -d '=' -f 2 | tr -d '"')"
-                oe_runmake CONFIG_DEFAULT_ENVIRONMENT_PATH="\"${BAREBOX_DEFAULT_ENV} ${BAREBOX_ENV_DIR}\""
-        else
-                oe_runmake
-        fi
-}
-
-BAREBOX_BINARY[doc] = "Specify the barebox binary to install. If not specified all barebox artifacts are installed."
-BAREBOX_BINARY ??= "${@'barebox.efi' if d.getVar('EFI_PROVIDER') == 'barebox' else ''}"
-BAREBOX_SUFFIX[doc] = "Specify the suffix for ${BAREBOX_IMAGE}."
-BAREBOX_SUFFIX ??= "img"
-BAREBOX_IMAGE[doc] = "A unique barebox image name. Unused if ${BAREBOX_BINARY} is not set."
-BAREBOX_IMAGE_DEFAULT ?= "${PN}-${MACHINE}-${PV}-${PR}.${BAREBOX_SUFFIX}"
-BAREBOX_IMAGE ?= "${@'${EFI_BOOT_IMAGE}' if d.getVar('EFI_PROVIDER') == 'barebox' else '${BAREBOX_IMAGE_DEFAULT}'}"
-
-BAREBOX_INSTALL_PATH ?= "${@'${EFI_FILES_PATH}' if d.getVar('EFI_PROVIDER') == 'barebox' else '/boot'}"
-
-barebox_do_install () {
-        if [ -n "${BAREBOX_BINARY}" ]; then
-
-                BAREBOX_BIN=${B}/${BAREBOX_BINARY}
-                if [ ! -f "${BAREBOX_BIN}" ]; then
-                        BAREBOX_BIN=${B}/images/${BAREBOX_BINARY}
-                fi
-                if [ ! -f "${BAREBOX_BIN}" ]; then
-                        bbfatal "Failed to locate ${BAREBOX_BINARY}"
-                fi
-
-                install -D -m 644 ${BAREBOX_BIN} ${D}${BAREBOX_INSTALL_PATH}/${BAREBOX_IMAGE}
-                ln -sf ${BAREBOX_IMAGE} ${D}${BAREBOX_INSTALL_PATH}/${BAREBOX_BINARY}
-        else
-                install -d ${D}${BAREBOX_INSTALL_PATH}/
-                for image in $(cat ${B}/barebox-flash-images); do
-                        install -m 644 ${B}/${image} ${D}${BAREBOX_INSTALL_PATH}/
-                done
-        fi
-}
-FILES:${PN} = "${BAREBOX_INSTALL_PATH}"
-
-barebox_do_deploy () {
-        if [ -n "${BAREBOX_BINARY}" ]; then
-
-                BAREBOX_BIN=${B}/${BAREBOX_BINARY}
-                if [ ! -f "${BAREBOX_BIN}" ]; then
-                        BAREBOX_BIN=${B}/images/${BAREBOX_BINARY}
-                fi
-
-                install -D -m 644 ${BAREBOX_BIN} ${DEPLOYDIR}/${BAREBOX_IMAGE}
-                ln -sf ${BAREBOX_IMAGE} ${DEPLOYDIR}/${BAREBOX_BINARY}
-        else
-                for image in $(cat ${B}/barebox-flash-images); do
-                        cp ${B}/${image} ${DEPLOYDIR}
-                done
-        fi
-}
-addtask deploy after do_compile
-
-EXPORT_FUNCTIONS do_configure do_compile do_install do_deploy
diff --git a/meta/classes-recipe/baremetal-image.bbclass b/meta/classes-recipe/baremetal-image.bbclass
deleted file mode 100644
index 4afc171314..0000000000
--- a/meta/classes-recipe/baremetal-image.bbclass
+++ /dev/null
@@ -1,170 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-# Baremetal image class
-#
-# This class is meant to be inherited by recipes for baremetal/RTOS applications
-# It contains code that would be used by all of them, every recipe just needs to
-# override certain variables.
-#
-# For scalability purposes, code within this class focuses on the "image" wiring
-# to satisfy the OpenEmbedded image creation and testing infrastructure.
-#
-# See meta-skeleton for a working example.
-
-
-# Toolchain should be baremetal or newlib/picolibc based.
-# TCLIBC="baremetal" or TCLIBC="newlib" or TCLIBC="picolibc"
-COMPATIBLE_HOST:libc-musl:class-target = "null"
-COMPATIBLE_HOST:libc-glibc:class-target = "null"
-
-
-inherit rootfs-postcommands
-
-# Set some defaults, but these should be overriden by each recipe if required
-IMGDEPLOYDIR ?= "${WORKDIR}/deploy-${PN}-image-complete"
-BAREMETAL_BINNAME ?= "hello_baremetal_${MACHINE}"
-IMAGE_LINK_NAME ?= "baremetal-helloworld-image-${MACHINE}"
-IMAGE_NAME_SUFFIX ?= ""
-
-IMAGE_OUTPUT_MANIFEST_DIR = "${WORKDIR}/deploy-image-output-manifest"
-IMAGE_OUTPUT_MANIFEST = "${IMAGE_OUTPUT_MANIFEST_DIR}/manifest.json"
-
-do_rootfs[dirs] = "${IMGDEPLOYDIR} ${DEPLOY_DIR_IMAGE}"
-
-do_image(){
-    install ${D}/${base_libdir}/firmware/${BAREMETAL_BINNAME}.bin ${IMGDEPLOYDIR}/${IMAGE_LINK_NAME}.bin
-    install ${D}/${base_libdir}/firmware/${BAREMETAL_BINNAME}.elf ${IMGDEPLOYDIR}/${IMAGE_LINK_NAME}.elf
-}
-
-python do_image_complete(){
-    from pathlib import Path
-    import json
-
-    data = {
-        "taskname": "do_image",
-        "imagetype": "baremetal-image",
-        "images": []
-    }
-
-    img_deploy_dir = Path(d.getVar("IMGDEPLOYDIR"))
-
-    for child in img_deploy_dir.iterdir():
-        if not child.is_file() or child.is_symlink():
-            continue
-
-        data["images"].append({
-            "filename": child.name,
-        })
-
-    with open(d.getVar("IMAGE_OUTPUT_MANIFEST"), "w") as f:
-        json.dump([data], f)
-}
-
-python do_rootfs(){
-    from oe.utils import execute_pre_post_process
-    from pathlib import Path
-
-    # Write empty manifest file to satisfy test infrastructure
-    deploy_dir = d.getVar('IMGDEPLOYDIR')
-    link_name = d.getVar('IMAGE_LINK_NAME')
-    manifest_name = d.getVar('IMAGE_MANIFEST')
-
-    Path(manifest_name).touch()
-    if os.path.exists(manifest_name) and link_name:
-        manifest_link = deploy_dir + "/" + link_name + ".manifest"
-        if manifest_link != manifest_name:
-            if os.path.lexists(manifest_link):
-                os.remove(manifest_link)
-            os.symlink(os.path.basename(manifest_name), manifest_link)
-    # A lot of postprocess commands assume the existence of rootfs/etc
-    sysconfdir = d.getVar("IMAGE_ROOTFS") + d.getVar('sysconfdir')
-    bb.utils.mkdirhier(sysconfdir)
-
-    execute_pre_post_process(d, d.getVar('ROOTFS_POSTPROCESS_COMMAND'))
-    execute_pre_post_process(d, d.getVar("ROOTFS_POSTUNINSTALL_COMMAND"))
-}
-
-
-# Assure binaries, manifest and qemubootconf are populated on DEPLOY_DIR_IMAGE
-do_image_complete[dirs] = "${TOPDIR}"
-SSTATETASKS += "do_image_complete"
-SSTATE_SKIP_CREATION:task-image-complete = '1'
-do_image_complete[sstate-inputdirs] = "${IMGDEPLOYDIR}"
-do_image_complete[sstate-outputdirs] = "${DEPLOY_DIR_IMAGE}"
-do_image_complete[stamp-extra-info] = "${MACHINE_ARCH}"
-do_image_complete[sstate-plaindirs] += "${IMAGE_OUTPUT_MANIFEST_DIR}"
-do_image_complete[dirs] += "${IMAGE_OUTPUT_MANIFEST_DIR}"
-addtask do_image_complete after do_image before do_build
-
-python do_image_complete_setscene () {
-    sstate_setscene(d)
-}
-addtask do_image_complete_setscene
-
-# QEMU generic Baremetal/RTOS parameters
-QB_DEFAULT_KERNEL ?= "${IMAGE_LINK_NAME}.bin"
-QB_MEM ?= "-m 256"
-QB_DEFAULT_FSTYPE ?= "bin"
-QB_DTB ?= ""
-QB_OPT_APPEND:append = " -nographic"
-
-# QEMU x86 requires an .elf kernel to boot rather than a .bin
-QB_DEFAULT_KERNEL:qemux86 ?= "${IMAGE_LINK_NAME}.elf"
-# QEMU x86-64 refuses to boot from -kernel, needs a multiboot compatible image
-QB_DEFAULT_FSTYPE:qemux86-64 ?= "iso"
-
-# RISC-V tunes set the BIOS, unset, and instruct QEMU to
-# ignore the BIOS and boot from -kernel
-QB_DEFAULT_BIOS:qemuriscv64 = ""
-QB_DEFAULT_BIOS:qemuriscv32 = ""
-QB_OPT_APPEND:append:qemuriscv64 = " -bios none"
-QB_OPT_APPEND:append:qemuriscv32 = " -bios none"
-
-
-# Use the medium-any code model for the RISC-V 64 bit implementation,
-# since medlow can only access addresses below 0x80000000 and RAM
-# starts at 0x80000000 on RISC-V 64
-# Keep RISC-V 32 using -mcmodel=medlow (symbols lie between -2GB:2GB)
-TARGET_CFLAGS:append:qemuriscv64 = " -mcmodel=medany"
-
-
-## Emulate image.bbclass
-# Handle inherits of any of the image classes we need
-IMAGE_CLASSES ??= ""
-IMGCLASSES = " ${IMAGE_CLASSES}"
-inherit_defer ${IMGCLASSES}
-# Set defaults to satisfy IMAGE_FEATURES check
-IMAGE_FEATURES ?= ""
-IMAGE_FEATURES[type] = "list"
-IMAGE_FEATURES[validitems] += ""
-
-
-# This next part is necessary to trick the build system into thinking
-# its building an image recipe so it generates the qemuboot.conf
-addtask do_rootfs before do_image after do_install
-addtask do_image after do_rootfs before do_image_complete
-addtask do_image_complete after do_image before do_build
-inherit qemuboot
-
-# Based on image.bbclass to make sure we build qemu
-python(){
-    # do_addto_recipe_sysroot doesnt exist for all recipes, but we need it to have
-    # /usr/bin on recipe-sysroot (qemu) populated
-    # The do_addto_recipe_sysroot dependency is coming from EXTRA_IMAGDEPENDS now,
-    # we just need to add the logic to add its dependency to do_image.
-    def extraimage_getdepends(task):
-        deps = ""
-        for dep in (d.getVar('EXTRA_IMAGEDEPENDS') or "").split():
-        # Make sure we only add it for qemu
-            if 'qemu' in dep:
-                if ":" in dep:
-                    deps += " %s " % (dep)
-                else:
-                    deps += " %s:%s" % (dep, task)
-        return deps
-    d.appendVarFlag('do_image', 'depends', extraimage_getdepends('do_populate_sysroot'))
-}
diff --git a/meta/classes-recipe/bash-completion.bbclass b/meta/classes-recipe/bash-completion.bbclass
deleted file mode 100644
index b656e76c09..0000000000
--- a/meta/classes-recipe/bash-completion.bbclass
+++ /dev/null
@@ -1,13 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-DEPENDS:append:class-target = " bash-completion"
-
-PACKAGES += "${PN}-bash-completion"
-
-FILES:${PN}-bash-completion = "${datadir}/bash-completion ${sysconfdir}/bash_completion.d"
-
-RDEPENDS:${PN}-bash-completion = "bash-completion"
diff --git a/meta/classes-recipe/bin_package.bbclass b/meta/classes-recipe/bin_package.bbclass
deleted file mode 100644
index 3a1befc29c..0000000000
--- a/meta/classes-recipe/bin_package.bbclass
+++ /dev/null
@@ -1,42 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-# Common variable and task for the binary package recipe.
-# Basic principle:
-# * The files have been unpacked to ${S} by base.bbclass
-# * Skip do_configure and do_compile
-# * Use do_install to install the files to ${D}
-#
-# Note:
-# The "subdir" parameter in the SRC_URI is useful when the input package
-# is rpm, ipk, deb and so on, for example:
-#
-# SRC_URI = "http://foo.com/foo-1.0-r1.i586.rpm;subdir=foo-1.0"
-#
-# Then the files would be unpacked to ${WORKDIR}/foo-1.0, otherwise
-# they would be in ${WORKDIR}.
-#
-
-# Skip the unwanted steps
-do_configure[noexec] = "1"
-do_compile[noexec] = "1"
-
-# Install the files to ${D}
-bin_package_do_install () {
-    # Do it carefully
-    [ -d "${S}" ] || exit 1
-    if [ -z "$(ls -A ${S})" ]; then
-        bbfatal bin_package has nothing to install. Be sure the SRC_URI unpacks into S.
-    fi
-    cd ${S}
-    install -d ${D}${base_prefix}
-    tar --no-same-owner --exclude='./patches' --exclude='./.pc' -cpf - . \
-        | tar --no-same-owner -xpf - -C ${D}${base_prefix}
-}
-
-FILES:${PN} = "/"
-
-EXPORT_FUNCTIONS do_install
diff --git a/meta/classes-recipe/binconfig-disabled.bbclass b/meta/classes-recipe/binconfig-disabled.bbclass
deleted file mode 100644
index cbe2078e0f..0000000000
--- a/meta/classes-recipe/binconfig-disabled.bbclass
+++ /dev/null
@@ -1,36 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-#
-# Class to disable binconfig files instead of installing them
-#
-
-# The list of scripts which should be disabled.
-BINCONFIG ?= ""
-
-FILES:${PN}-dev += "${bindir}/*-config"
-
-do_install:append () {
-        for x in ${BINCONFIG}; do
-                # Make the disabled script emit invalid parameters for those configure
-                # scripts which call it without checking the return code.
-                echo "#!/bin/sh" > ${D}$x
-                echo "echo 'ERROR: $x should not be used, use an alternative such as pkg-config' >&2" >> ${D}$x
-                echo "echo '--should-not-have-used-$x'" >> ${D}$x
-                echo "exit 1" >> ${D}$x
-                chmod +x ${D}$x
-        done
-}
-
-SYSROOT_PREPROCESS_FUNCS += "binconfig_disabled_sysroot_preprocess"
-
-binconfig_disabled_sysroot_preprocess () {
-        for x in ${BINCONFIG}; do
-                configname=`basename $x`
-                install -d ${SYSROOT_DESTDIR}${bindir_crossscripts}
-                install ${D}$x ${SYSROOT_DESTDIR}${bindir_crossscripts}
-        done
-}
diff --git a/meta/classes-recipe/binconfig.bbclass b/meta/classes-recipe/binconfig.bbclass
deleted file mode 100644
index 427dba7f1f..0000000000
--- a/meta/classes-recipe/binconfig.bbclass
+++ /dev/null
@@ -1,60 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-FILES:${PN}-dev += "${bindir}/*-config"
- 
-# The namespaces can clash here hence the two step replace
-def get_binconfig_mangle(d):
-    s = "-e ''"
-    if not bb.data.inherits_class('native', d):
-        optional_quote = r"\(\"\?\)"
-        s += " -e 's:=%s${base_libdir}:=\\1OEBASELIBDIR:;'" % optional_quote
-        s += " -e 's:=%s${libdir}:=\\1OELIBDIR:;'" % optional_quote
-        s += " -e 's:=%s${includedir}:=\\1OEINCDIR:;'" % optional_quote
-        s += " -e 's:=%s${datadir}:=\\1OEDATADIR:'" % optional_quote
-        s += " -e 's:=%s${prefix}/:=\\1OEPREFIX/:'" % optional_quote
-        s += " -e 's:=%s${exec_prefix}/:=\\1OEEXECPREFIX/:'" % optional_quote
-        s += " -e 's:-L${libdir}:-LOELIBDIR:;'"
-        s += " -e 's:-I${includedir}:-IOEINCDIR:;'"
-        s += " -e 's:-L${WORKDIR}:-LOELIBDIR:'"
-        s += " -e 's:-I${WORKDIR}:-IOEINCDIR:'"
-        s += " -e 's:OEBASELIBDIR:${STAGING_BASELIBDIR}:;'"
-        s += " -e 's:OELIBDIR:${STAGING_LIBDIR}:;'"
-        s += " -e 's:OEINCDIR:${STAGING_INCDIR}:;'"
-        s += " -e 's:OEDATADIR:${STAGING_DATADIR}:'"
-        s += " -e 's:OEPREFIX:${STAGING_DIR_HOST}${prefix}:'"
-        s += " -e 's:OEEXECPREFIX:${STAGING_DIR_HOST}${exec_prefix}:'"
-        if d.getVar("OE_BINCONFIG_EXTRA_MANGLE", False):
-            s += d.getVar("OE_BINCONFIG_EXTRA_MANGLE")
-
-    return s
-
-BINCONFIG_GLOB ?= "*-config"
-
-PACKAGE_PREPROCESS_FUNCS += "binconfig_package_preprocess"
-
-binconfig_package_preprocess () {
-        for config in `find ${PKGD} -type f -name '${BINCONFIG_GLOB}'`; do
-                sed -i \
-                    -e 's:${STAGING_BASELIBDIR}:${base_libdir}:g;' \
-                    -e 's:${STAGING_LIBDIR}:${libdir}:g;' \
-                    -e 's:${STAGING_INCDIR}:${includedir}:g;' \
-                    -e 's:${STAGING_DATADIR}:${datadir}:' \
-                    -e 's:${STAGING_DIR_HOST}${prefix}:${prefix}:' \
-                    $config
-        done
-}
-
-SYSROOT_PREPROCESS_FUNCS += "binconfig_sysroot_preprocess"
-
-binconfig_sysroot_preprocess () {
-        for config in `find ${S} -type f -name '${BINCONFIG_GLOB}'` `find ${B} -type f -name '${BINCONFIG_GLOB}'`; do
-                configname=`basename $config`
-                install -d ${SYSROOT_DESTDIR}${bindir_crossscripts}
-                sed ${@get_binconfig_mangle(d)} $config > ${SYSROOT_DESTDIR}${bindir_crossscripts}/$configname
-                chmod u+x ${SYSROOT_DESTDIR}${bindir_crossscripts}/$configname
-        done
-}
diff --git a/meta/classes-recipe/cargo-update-recipe-crates.bbclass b/meta/classes-recipe/cargo-update-recipe-crates.bbclass
deleted file mode 100644
index 3251d5ef2e..0000000000
--- a/meta/classes-recipe/cargo-update-recipe-crates.bbclass
+++ /dev/null
@@ -1,81 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-##
-## Purpose:
-## This class is used to update the list of crates in SRC_URI
-## by reading Cargo.lock in the source tree.
-##
-## See meta/recipes-devtools/python/python3-bcrypt_*.bb for an example
-##
-## To perform the update: bitbake -c update_crates recipe-name
-
-addtask do_update_crates after do_patch
-do_update_crates[depends] = "python3-native:do_populate_sysroot"
-do_update_crates[nostamp] = "1"
-do_update_crates[doc] = "Update the recipe by reading Cargo.lock and write in ${THISDIR}/${BPN}-crates.inc"
-
-RECIPE_UPGRADE_EXTRA_TASKS += "do_update_crates"
-
-# The directory where to search for Cargo.lock files
-CARGO_LOCK_SRC_DIR ??= "${S}"
-
-do_update_crates() {
-    TARGET_FILE="${THISDIR}/${BPN}-crates.inc"
-
-    nativepython3 - <<EOF
-
-def get_crates(f):
-    import tomllib
-    c_list = '# from %s' % os.path.relpath(f, '${CARGO_LOCK_SRC_DIR}')
-    c_list += '\nSRC_URI += " \\\'
-    crates = tomllib.load(open(f, 'rb'))
-
-    # Build a list with crates info that have crates.io in the source
-    crates_candidates = list(filter(lambda c: 'crates.io' in c.get('source', ''), crates['package']))
-
-    if not crates_candidates:
-        raise ValueError("Unable to find any candidate crates that use crates.io")
-
-    # Update crates uri and their checksum, to avoid name clashing on the checksum
-    # we need to rename crates with name and version to have a unique key
-    cksum_list = ''
-    for c in crates_candidates:
-        rename = "%s-%s" % (c['name'], c['version'])
-        c_list += '\n    crate://crates.io/%s/%s \\\' % (c['name'], c['version'])
-        if 'checksum' in c:
-            cksum_list += '\nSRC_URI[%s.sha256sum] = "%s"' % (rename, c['checksum'])
-
-    c_list += '\n"\n'
-    c_list += cksum_list
-    c_list += '\n'
-    return c_list
-
-import os
-crates = "# Autogenerated with 'bitbake -c update_crates ${PN}'\n\n"
-found = False
-for root, dirs, files in os.walk('${CARGO_LOCK_SRC_DIR}'):
-    # ignore git and patches directories
-    if root.startswith(os.path.join('${CARGO_LOCK_SRC_DIR}', '.pc')):
-        continue
-    if root.startswith(os.path.join('${CARGO_LOCK_SRC_DIR}', '.git')):
-        continue
-    for file in files:
-        if file == 'Cargo.lock':
-            try:
-                cargo_lock_path = os.path.join(root, file)
-                crates += get_crates(os.path.join(root, file))
-            except Exception as e:
-                raise ValueError("Cannot parse '%s'" % cargo_lock_path) from e
-            else:
-                found = True
-if not found:
-    raise ValueError("Unable to find any Cargo.lock in ${CARGO_LOCK_SRC_DIR}")
-open("${TARGET_FILE}", 'w').write(crates)
-EOF
-
-    bbnote "Successfully update crates inside '${TARGET_FILE}'"
-}
diff --git a/meta/classes-recipe/cargo.bbclass b/meta/classes-recipe/cargo.bbclass
deleted file mode 100644
index 2dd28e95d3..0000000000
--- a/meta/classes-recipe/cargo.bbclass
+++ /dev/null
@@ -1,95 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-##
-## Purpose:
-## This class is used by any recipes that are built using
-## Cargo.
-
-inherit cargo_common
-inherit rust-target-config
-
-# the binary we will use
-CARGO = "cargo"
-
-# We need cargo to compile for the target
-BASEDEPENDS:append = " cargo-native"
-
-# Ensure we get the right rust variant
-DEPENDS:append:class-target = " rust-native ${RUSTLIB_DEP}"
-DEPENDS:append:class-nativesdk = " rust-native ${RUSTLIB_DEP}"
-DEPENDS:append:class-native = " rust-native"
-
-# Enable build separation
-B = "${WORKDIR}/build"
-
-# In case something fails in the build process, give a bit more feedback on
-# where the issue occured
-export RUST_BACKTRACE = "1"
-
-RUSTFLAGS ??= ""
-BUILD_MODE = "${@['--release', ''][d.getVar('DEBUG_BUILD') == '1']}"
-# --frozen flag will prevent network access (which is required since only
-# the do_fetch step is authorized to access network)
-# and will require an up to date Cargo.lock file.
-# This force the package being built to already ship a Cargo.lock, in the end
-# this is what we want, at least, for reproducibility of the build.
-CARGO_BUILD_FLAGS = "-v --frozen --target ${RUST_HOST_SYS} ${BUILD_MODE} --manifest-path=${CARGO_MANIFEST_PATH}"
-
-# This is based on the content of CARGO_BUILD_FLAGS and generally will need to
-# change if CARGO_BUILD_FLAGS changes.
-BUILD_DIR = "${@['release', 'debug'][d.getVar('DEBUG_BUILD') == '1']}"
-CARGO_TARGET_SUBDIR = "${RUST_HOST_SYS}/${BUILD_DIR}"
-oe_cargo_build () {
-        export RUSTFLAGS="${RUSTFLAGS}"
-        bbnote "Using rust targets from ${RUST_TARGET_PATH}"
-        bbnote "cargo = $(which ${CARGO})"
-        bbnote "${CARGO} build ${CARGO_BUILD_FLAGS} ${PACKAGECONFIG_CONFARGS} $@"
-        "${CARGO}" build ${CARGO_BUILD_FLAGS} ${PACKAGECONFIG_CONFARGS} "$@"
-}
-
-do_compile[progress] = "outof:\s+(\d+)/(\d+)"
-cargo_do_compile () {
-        oe_cargo_build
-}
-
-cargo_do_install () {
-        local have_installed=false
-        for tgt in "${B}/target/${CARGO_TARGET_SUBDIR}/"*; do
-                case $tgt in
-                *.so|*.rlib)
-                        if [ -n "${CARGO_INSTALL_LIBRARIES}" ]; then
-                                install -d "${D}${rustlibdir}"
-                                install -m755 "$tgt" "${D}${rustlibdir}"
-                                have_installed=true
-                        fi
-                        ;;
-                *examples)
-                        if [ -d "$tgt" ]; then
-                                for example in "$tgt/"*; do
-                                        if [ -f "$example" ] && [ -x "$example" ]; then
-                                                install -d "${D}${bindir}"
-                                                install -m755 "$example" "${D}${bindir}"
-                                                have_installed=true
-                                        fi
-                                done
-                        fi
-                        ;;
-                *)
-                        if [ -f "$tgt" ] && [ -x "$tgt" ]; then
-                                install -d "${D}${bindir}"
-                                install -m755 "$tgt" "${D}${bindir}"
-                                have_installed=true
-                        fi
-                        ;;
-                esac
-        done
-        if ! $have_installed; then
-                die "Did not find anything to install"
-        fi
-}
-
-EXPORT_FUNCTIONS do_compile do_install
diff --git a/meta/classes-recipe/cargo_c.bbclass b/meta/classes-recipe/cargo_c.bbclass
deleted file mode 100644
index ef431634a2..0000000000
--- a/meta/classes-recipe/cargo_c.bbclass
+++ /dev/null
@@ -1,41 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-##
-## Purpose:
-## This class is used by any recipes that want to compile a C ABI compatible
-## library with header and pkg config file
-
-inherit cargo pkgconfig
-
-# the binaries we will use
-CARGO_C_BUILD = "cargo-cbuild"
-CARGO_C_INSTALL = "cargo-cinstall"
-
-# We need cargo-c to compile for the target
-BASEDEPENDS:append = " cargo-c-native"
-
-do_compile[progress] = "outof:\s+(\d+)/(\d+)"
-cargo_c_do_compile() {
-    oe_cargo_fix_env
-    export RUSTFLAGS="${RUSTFLAGS}"
-    bbnote "Using rust targets from ${RUST_TARGET_PATH}"
-    bbnote "cargo-cbuild = $(which ${CARGO_C_BUILD})"
-    bbnote "${CARGO_C_BUILD} cbuild ${CARGO_BUILD_FLAGS}"
-    "${CARGO_C_BUILD}" cbuild ${CARGO_BUILD_FLAGS}
-}
-
-cargo_c_do_install() {
-    oe_cargo_fix_env
-    export RUSTFLAGS="${RUSTFLAGS}"
-    bbnote "cargo-cinstall = $(which ${CARGO_C_INSTALL})"
-    "${CARGO_C_INSTALL}" cinstall ${CARGO_BUILD_FLAGS} \
-        --destdir ${D} \
-        --prefix ${prefix} \
-        --library-type cdylib
-}
-
-EXPORT_FUNCTIONS do_compile do_install
diff --git a/meta/classes-recipe/cargo_common.bbclass b/meta/classes-recipe/cargo_common.bbclass
deleted file mode 100644
index bc44ad7918..0000000000
--- a/meta/classes-recipe/cargo_common.bbclass
+++ /dev/null
@@ -1,242 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-##
-## Purpose:
-## This class is to support building with cargo. It
-## must be different than cargo.bbclass because Rust
-## now builds with Cargo but cannot use cargo.bbclass
-## due to dependencies and assumptions in cargo.bbclass
-## that Rust & Cargo are already installed. So this
-## is used by cargo.bbclass and Rust
-##
-
-# add crate fetch support
-inherit rust-common
-
-# Where we download our registry and dependencies to
-export CARGO_HOME = "${UNPACKDIR}/cargo_home"
-
-# The pkg-config-rs library used by cargo build scripts disables itself when
-# cross compiling unless this is defined. We set up pkg-config appropriately
-# for cross compilation, so tell it we know better than it.
-export PKG_CONFIG_ALLOW_CROSS = "1"
-
-# Don't instruct cargo to use crates downloaded by bitbake. Some rust packages,
-# for example the rust compiler itself, come with their own vendored sources.
-# Specifying two [source.crates-io] will not work.
-CARGO_DISABLE_BITBAKE_VENDORING ??= "0"
-
-# Used by libstd-rs to point to the vendor dir included in rustc src
-CARGO_VENDORING_DIRECTORY ??= "${CARGO_HOME}/bitbake"
-
-# The directory of the Cargo.toml relative to the root directory, per default
-# assume there's a Cargo.toml directly in the root directory
-CARGO_SRC_DIR ??= ""
-
-# The actual path to the Cargo.toml
-CARGO_MANIFEST_PATH ??= "${S}/${CARGO_SRC_DIR}/Cargo.toml"
-
-# Path to Cargo.lock
-CARGO_LOCK_PATH ??= "${@ os.path.join(os.path.dirname(d.getVar('CARGO_MANIFEST_PATH')), 'Cargo.lock')}"
-
-CARGO_RUST_TARGET_CCLD ??= "${RUST_TARGET_CCLD}"
-cargo_common_do_configure () {
-        mkdir -p ${CARGO_HOME}/bitbake
-
-        cat <<- EOF > ${CARGO_HOME}/config.toml
-        # EXTRA_OECARGO_PATHS
-        paths = [
-        $(for p in ${EXTRA_OECARGO_PATHS}; do echo \"$p\",; done)
-        ]
-        EOF
-
-        cat <<- EOF >> ${CARGO_HOME}/config.toml
-
-        # Local mirror vendored by bitbake
-        [source.bitbake]
-        directory = "${CARGO_VENDORING_DIRECTORY}"
-        EOF
-
-        if [ ${CARGO_DISABLE_BITBAKE_VENDORING} = "0" ]; then
-                cat <<- EOF >> ${CARGO_HOME}/config.toml
-
-                [source.crates-io]
-                replace-with = "bitbake"
-                local-registry = "/nonexistent"
-                EOF
-        fi
-
-        cat <<- EOF >> ${CARGO_HOME}/config.toml
-
-        [http]
-        # Multiplexing can't be enabled because http2 can't be enabled
-        # in curl-native without dependency loops
-        multiplexing = false
-
-        # Ignore the hard coded and incorrect path to certificates
-        cainfo = "${STAGING_ETCDIR_NATIVE}/ssl/certs/ca-certificates.crt"
-
-        EOF
-
-        cat <<- EOF >> ${CARGO_HOME}/config.toml
-
-        # HOST_SYS
-        [target.${RUST_HOST_SYS}]
-        linker = "${CARGO_RUST_TARGET_CCLD}"
-        EOF
-
-        if [ "${RUST_HOST_SYS}" != "${RUST_BUILD_SYS}" ]; then
-                cat <<- EOF >> ${CARGO_HOME}/config.toml
-
-                # BUILD_SYS
-                [target.${RUST_BUILD_SYS}]
-                linker = "${RUST_BUILD_CCLD}"
-                EOF
-        fi
-
-        if [ "${RUST_TARGET_SYS}" != "${RUST_BUILD_SYS}" -a "${RUST_TARGET_SYS}" != "${RUST_HOST_SYS}" ]; then
-                cat <<- EOF >> ${CARGO_HOME}/config.toml
-
-                # TARGET_SYS
-                [target.${RUST_TARGET_SYS}]
-                linker = "${RUST_TARGET_CCLD}"
-                EOF
-        fi
-
-        # Put build output in build directory preferred by bitbake instead of
-        # inside source directory unless they are the same
-        if [ "${B}" != "${S}" ]; then
-                # We should consider mandating out-of-tree builds and just using [cleandirs]
-                rm -rf ${B}/target
-                mkdir -p ${B}
-
-                cat <<- EOF >> ${CARGO_HOME}/config.toml
-
-                [build]
-                # Use out of tree build destination to avoid polluting the source tree
-                target-dir = "${B}/target"
-                EOF
-        fi
-
-        cat <<- EOF >> ${CARGO_HOME}/config.toml
-
-        [term]
-        progress.when = 'always'
-        progress.width = 80
-        EOF
-}
-
-python cargo_common_do_patch_paths() {
-    import shutil
-
-    cargo_config = os.path.join(d.getVar("CARGO_HOME"), "config.toml")
-    if not os.path.exists(cargo_config):
-        return
-
-    src_uri = (d.getVar('SRC_URI') or "").split()
-    if len(src_uri) == 0:
-        return
-
-    patches = dict()
-    workdir = d.getVar('UNPACKDIR')
-    fetcher = bb.fetch2.Fetch(src_uri, d)
-    for url in fetcher.urls:
-        ud = fetcher.ud[url]
-        if ud.type == 'git' or ud.type == 'gitsm':
-            name = ud.parm.get('name')
-            destsuffix = ud.parm.get('destsuffix')
-            if name is not None and destsuffix is not None:
-                if ud.user:
-                    repo = '%s://%s@%s%s' % (ud.proto, ud.user, ud.host, ud.path)
-                else:
-                    repo = '%s://%s%s' % (ud.proto, ud.host, ud.path)
-                path = '%s = { path = "%s" }' % (name, os.path.join(workdir, destsuffix))
-                patches.setdefault(repo, []).append(path)
-
-    with open(cargo_config, "a+") as config:
-        for k, v in patches.items():
-            print('\n[patch."%s"]' % k, file=config)
-            for name in v:
-                print(name, file=config)
-
-    if not patches:
-        return
-
-    # Cargo.lock file is needed for to be sure that artifacts
-    # downloaded by the fetch steps are those expected by the
-    # project and that the possible patches are correctly applied.
-    # Moreover since we do not want any modification
-    # of this file (for reproducibility purpose), we prevent it by
-    # using --frozen flag (in CARGO_BUILD_FLAGS) and raise a clear error
-    # here is better than letting cargo tell (in case the file is missing)
-    # "Cargo.lock should be modified but --frozen was given"
-
-    lockfile = d.getVar("CARGO_LOCK_PATH")
-    if not os.path.exists(lockfile):
-        bb.fatal(f"{lockfile} file doesn't exist")
-
-    # There are patched files and so Cargo.lock should be modified but we use
-    # --frozen so let's handle that modifications here.
-    #
-    # Note that a "better" (more elegant ?) would have been to use cargo update for
-    # patched packages:
-    #  cargo update --offline -p package_1 -p package_2
-    # But this is not possible since it requires that cargo local git db
-    # to be populated and this is not the case as we fetch git repo ourself.
-
-    lockfile_orig = lockfile + ".orig"
-    if not os.path.exists(lockfile_orig):
-        shutil.copy(lockfile, lockfile_orig)
-
-    newlines = []
-    with open(lockfile_orig, "r") as f:
-        for line in f.readlines():
-            if not line.startswith("source = \"git"):
-                newlines.append(line)
-
-    with open(lockfile, "w") as f:
-        f.writelines(newlines)
-}
-do_configure[postfuncs] += "cargo_common_do_patch_paths"
-
-do_compile:prepend () {
-        oe_cargo_fix_env
-}
-
-oe_cargo_fix_env () {
-        export CC="${RUST_TARGET_CC}"
-        export CXX="${RUST_TARGET_CXX}"
-        export CFLAGS="${CFLAGS}"
-        export CXXFLAGS="${CXXFLAGS}"
-        export AR="${AR}"
-        export TARGET_CC="${RUST_TARGET_CC}"
-        export TARGET_CXX="${RUST_TARGET_CXX}"
-        export TARGET_CFLAGS="${CFLAGS}"
-        export TARGET_CXXFLAGS="${CXXFLAGS}"
-        export TARGET_AR="${AR}"
-        export HOST_CC="${RUST_BUILD_CC}"
-        export HOST_CXX="${RUST_BUILD_CXX}"
-        export HOST_CFLAGS="${BUILD_CFLAGS}"
-        export HOST_CXXFLAGS="${BUILD_CXXFLAGS}"
-        export HOST_AR="${BUILD_AR}"
-}
-
-EXTRA_OECARGO_PATHS ??= ""
-
-EXPORT_FUNCTIONS do_configure
-
-# The culprit for this setting is the libc crate,
-# which as of Jun 2023 calls directly into 32 bit time functions in glibc,
-# bypassing all of glibc provisions to choose the right Y2038-safe functions. As
-# rust components statically link with that crate, pretty much everything
-# is affected, and so there's no point trying to have recipe-specific
-# INSANE_SKIP entries.
-#
-# Upstream ticket and PR:
-# https://github.com/rust-lang/libc/issues/3223
-# https://github.com/rust-lang/libc/pull/3175
-INSANE_SKIP:append = " 32bit-time"
diff --git a/meta/classes-recipe/cmake-qemu.bbclass b/meta/classes-recipe/cmake-qemu.bbclass
deleted file mode 100644
index 383fc74bf2..0000000000
--- a/meta/classes-recipe/cmake-qemu.bbclass
+++ /dev/null
@@ -1,32 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-# Not all platforms are supported by Qemu. Using qemu-user therefore
-# involves a certain risk, which is also the reason why this feature
-# is not part of the main cmake class by default.
-#
-# One use case is the execution of cross-compiled unit tests with CTest
-# on the build machine. If CMAKE_EXEWRAPPER_ENABLED is configured,
-#   cmake --build --target test
-# works transparently with qemu-user. If the cmake project is developed
-# with this use case in mind this works very nicely also out of an IDE
-# configured to use cmake-native for cross compiling.
-
-inherit qemu cmake
-
-DEPENDS:append:class-target = "${@' qemu-native' if bb.utils.contains('MACHINE_FEATURES', 'qemu-usermode', True, False, d) else ''}"
-
-cmake_do_generate_toolchain_file:append:class-target() {
-    if ${@bb.utils.contains('MACHINE_FEATURES', 'qemu-usermode', 'true', 'false', d)}; then
-        # Write out a qemu wrapper that will be used as exe_wrapper so that cmake
-        # can run target helper binaries through that. This also allows to execute ctest.
-        qemu_binary="${@qemu_wrapper_cmdline(d, '${STAGING_DIR_HOST}', ['${STAGING_DIR_HOST}/${libdir}','${STAGING_DIR_HOST}/${base_libdir}'])}"
-        echo "#!/bin/sh" > "${WORKDIR}/cmake-qemuwrapper"
-        echo "$qemu_binary \"\$@\"" >> "${WORKDIR}/cmake-qemuwrapper"
-        chmod +x "${WORKDIR}/cmake-qemuwrapper"
-        echo "set( CMAKE_CROSSCOMPILING_EMULATOR ${WORKDIR}/cmake-qemuwrapper)" \
-          >> ${WORKDIR}/toolchain.cmake
-    fi
-}
diff --git a/meta/classes-recipe/cmake.bbclass b/meta/classes-recipe/cmake.bbclass
deleted file mode 100644
index 4f59966521..0000000000
--- a/meta/classes-recipe/cmake.bbclass
+++ /dev/null
@@ -1,321 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-# Path to the CMake file to process.
-OECMAKE_SOURCEPATH ??= "${S}"
-
-DEPENDS:prepend = "cmake-native "
-B = "${WORKDIR}/build"
-
-# What CMake generator to use.
-# The supported options are "Unix Makefiles" or "Ninja".
-OECMAKE_GENERATOR ?= "Ninja"
-
-python() {
-    generator = d.getVar("OECMAKE_GENERATOR")
-    if "Unix Makefiles" in generator:
-        args = "-G '" + generator +  "' -DCMAKE_MAKE_PROGRAM=" + d.getVar("MAKE")
-        d.setVar("OECMAKE_GENERATOR_ARGS", args)
-        d.setVarFlag("do_compile", "progress", "percent")
-    elif "Ninja" in generator:
-        args = "-G '" + generator + "' -DCMAKE_MAKE_PROGRAM=ninja"
-        d.appendVar("DEPENDS", " ninja-native")
-        d.setVar("OECMAKE_GENERATOR_ARGS", args)
-        d.setVarFlag("do_compile", "progress", r"outof:^\[(\d+)/(\d+)\]\s+")
-    else:
-        bb.fatal("Unknown CMake Generator %s" % generator)
-}
-OECMAKE_AR ?= "${AR}"
-
-# Compiler flags
-OECMAKE_C_FLAGS ?= "${HOST_CC_ARCH} ${TOOLCHAIN_OPTIONS} ${CFLAGS}"
-OECMAKE_CXX_FLAGS ?= "${HOST_CC_ARCH} ${TOOLCHAIN_OPTIONS} ${CXXFLAGS}"
-OECMAKE_C_FLAGS_RELEASE ?= "-DNDEBUG"
-OECMAKE_CXX_FLAGS_RELEASE ?= "-DNDEBUG"
-OECMAKE_C_LINK_FLAGS ?= "${HOST_CC_ARCH} ${TOOLCHAIN_OPTIONS} ${CPPFLAGS} ${LDFLAGS}"
-OECMAKE_CXX_LINK_FLAGS ?= "${HOST_CC_ARCH} ${TOOLCHAIN_OPTIONS} ${CXXFLAGS} ${LDFLAGS}"
-
-def oecmake_map_compiler(compiler, d):
-    args = d.getVar(compiler).split()
-    if args[0] == "ccache":
-        return args[1], args[0]
-    return args[0], ""
-
-# C/C++ Compiler (without cpu arch/tune arguments)
-OECMAKE_C_COMPILER ?= "${@oecmake_map_compiler('CC', d)[0]}"
-OECMAKE_C_COMPILER_LAUNCHER ?= "${@oecmake_map_compiler('CC', d)[1]}"
-OECMAKE_CXX_COMPILER ?= "${@oecmake_map_compiler('CXX', d)[0]}"
-OECMAKE_CXX_COMPILER_LAUNCHER ?= "${@oecmake_map_compiler('CXX', d)[1]}"
-
-# Native C/C++ Compiler (without cpu arch/tune arguments)
-OECMAKE_NATIVE_C_COMPILER ?= "${@oecmake_map_compiler('BUILD_CC', d)[0]}"
-OECMAKE_NATIVE_C_COMPILER_LAUNCHER ?= "${@oecmake_map_compiler('BUILD_CC', d)[1]}"
-OECMAKE_NATIVE_CXX_COMPILER ?= "${@oecmake_map_compiler('BUILD_CXX', d)[0]}"
-OECMAKE_NATIVE_CXX_COMPILER_LAUNCHER ?= "${@oecmake_map_compiler('BUILD_CXX', d)[1]}"
-OECMAKE_NATIVE_AR ?= "${BUILD_AR}"
-OECMAKE_NATIVE_RANLIB ?= "${@d.getVar('BUILD_RANLIB').split()[0]}"
-OECMAKE_NATIVE_NM ?= "${BUILD_NM}"
-
-# Native compiler flags
-OECMAKE_NATIVE_C_FLAGS ?= "${BUILD_CC_ARCH} ${BUILD_CFLAGS}"
-OECMAKE_NATIVE_CXX_FLAGS ?= "${BUILD_CC_ARCH} ${BUILD_CXXFLAGS}"
-OECMAKE_NATIVE_C_FLAGS_RELEASE ?= "-DNDEBUG"
-OECMAKE_NATIVE_CXX_FLAGS_RELEASE ?= "-DNDEBUG"
-OECMAKE_NATIVE_C_LINK_FLAGS ?= "${BUILD_CC_ARCH} ${BUILD_CPPFLAGS} ${BUILD_LDFLAGS}"
-OECMAKE_NATIVE_CXX_LINK_FLAGS ?= "${BUILD_CC_ARCH} ${BUILD_CXXFLAGS} ${BUILD_LDFLAGS}"
-BUILD_CXXFLAGS += "${BUILD_CC_ARCH}"
-BUILD_CFLAGS += "${BUILD_CC_ARCH}"
-
-# clear compiler vars for allarch to avoid sig hash difference
-OECMAKE_C_COMPILER:allarch = ""
-OECMAKE_C_COMPILER_LAUNCHER:allarch = ""
-OECMAKE_CXX_COMPILER:allarch = ""
-OECMAKE_CXX_COMPILER_LAUNCHER:allarch = ""
-OECMAKE_NATIVE_C_COMPILER:allarch = ""
-OECMAKE_NATIVE_C_COMPILER_LAUNCHER:allarch = ""
-OECMAKE_NATIVE_CXX_COMPILER:allarch = ""
-OECMAKE_NATIVE_CXX_COMPILER_LAUNCHER:allarch = ""
-
-OECMAKE_RPATH ?= ""
-OECMAKE_PERLNATIVE_DIR ??= ""
-OECMAKE_EXTRA_ROOT_PATH ?= ""
-
-OECMAKE_FIND_ROOT_PATH_MODE_PROGRAM = "ONLY"
-
-EXTRA_OECMAKE:append = " ${PACKAGECONFIG_CONFARGS}"
-
-export CMAKE_BUILD_PARALLEL_LEVEL
-CMAKE_BUILD_PARALLEL_LEVEL:task-compile = "${@oe.utils.parallel_make(d, False)}"
-CMAKE_BUILD_PARALLEL_LEVEL:task-install = "${@oe.utils.parallel_make(d, True)}"
-CMAKE_BUILD_PARALLEL_LEVEL:task-compile-ptest-base = "${@oe.utils.parallel_make(d, False)}"
-CMAKE_BUILD_PARALLEL_LEVEL:task-install-ptest-base = "${@oe.utils.parallel_make(d, True)}"
-
-OECMAKE_TARGET_COMPILE ?= "all"
-OECMAKE_TARGET_INSTALL ?= "install"
-
-def map_host_os_to_system_name(host_os):
-    if host_os.startswith('darwin'):
-        return 'Darwin'
-    if host_os.startswith('mingw'):
-        return 'Windows'
-    if host_os.startswith('linux'):
-        return 'Linux'
-    return host_os
-
-# CMake expects target architectures in the format of uname(2),
-# which do not always match TARGET_ARCH, so all the necessary
-# conversions should happen here.
-def map_host_arch_to_uname_arch(host_arch):
-    if host_arch == "powerpc":
-        return "ppc"
-    if host_arch == "powerpc64le":
-        return "ppc64le"
-    if host_arch == "powerpc64":
-        return "ppc64"
-    return host_arch
-
-
-cmake_do_generate_toolchain_file() {
-        if [ "${BUILD_SYS}" = "${HOST_SYS}" ]; then
-                cmake_crosscompiling="set( CMAKE_CROSSCOMPILING FALSE )"
-        else
-                cmake_crosscompiling="set( CMAKE_CROSSCOMPILING TRUE )"
-                cmake_sysroot="set( CMAKE_SYSROOT \"${RECIPE_SYSROOT}\" )"
-        fi
-
-        cat > ${WORKDIR}/toolchain.cmake <<EOF
-# CMake system name must be something like "Linux".
-# This is important for cross-compiling.
-$cmake_crosscompiling
-set( CMAKE_SYSTEM_NAME ${@map_host_os_to_system_name(d.getVar('HOST_OS'))} )
-set( CMAKE_SYSTEM_PROCESSOR ${@map_host_arch_to_uname_arch(d.getVar('HOST_ARCH'))} )
-set( CMAKE_C_COMPILER ${OECMAKE_C_COMPILER} )
-set( CMAKE_CXX_COMPILER ${OECMAKE_CXX_COMPILER} )
-set( CMAKE_C_COMPILER_LAUNCHER ${OECMAKE_C_COMPILER_LAUNCHER} )
-set( CMAKE_CXX_COMPILER_LAUNCHER ${OECMAKE_CXX_COMPILER_LAUNCHER} )
-set( CMAKE_ASM_COMPILER ${OECMAKE_C_COMPILER} )
-find_program( CMAKE_AR ${OECMAKE_AR} DOC "Archiver" REQUIRED )
-
-set( CMAKE_C_FLAGS "${OECMAKE_C_FLAGS}" CACHE STRING "CFLAGS" )
-set( CMAKE_CXX_FLAGS "${OECMAKE_CXX_FLAGS}" CACHE STRING "CXXFLAGS" )
-set( CMAKE_ASM_FLAGS "${OECMAKE_C_FLAGS}" CACHE STRING "ASM FLAGS" )
-set( CMAKE_C_FLAGS_RELEASE "${OECMAKE_C_FLAGS_RELEASE}" CACHE STRING "Additional CFLAGS for release" )
-set( CMAKE_CXX_FLAGS_RELEASE "${OECMAKE_CXX_FLAGS_RELEASE}" CACHE STRING "Additional CXXFLAGS for release" )
-set( CMAKE_ASM_FLAGS_RELEASE "${OECMAKE_C_FLAGS_RELEASE}" CACHE STRING "Additional ASM FLAGS for release" )
-set( CMAKE_C_LINK_FLAGS "${OECMAKE_C_LINK_FLAGS}" CACHE STRING "LDFLAGS" )
-set( CMAKE_CXX_LINK_FLAGS "${OECMAKE_CXX_LINK_FLAGS}" CACHE STRING "LDFLAGS" )
-
-# only search in the paths provided so cmake doesnt pick
-# up libraries and tools from the native build machine
-set( CMAKE_FIND_ROOT_PATH ${STAGING_DIR_HOST} ${STAGING_DIR_NATIVE} ${CROSS_DIR} ${OECMAKE_PERLNATIVE_DIR} ${OECMAKE_EXTRA_ROOT_PATH} ${EXTERNAL_TOOLCHAIN} ${COREBASE}/scripts ${HOSTTOOLS_DIR} )
-set( CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ONLY )
-set( CMAKE_FIND_ROOT_PATH_MODE_PROGRAM ${OECMAKE_FIND_ROOT_PATH_MODE_PROGRAM} )
-set( CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY )
-set( CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY )
-set( CMAKE_PROGRAM_PATH "/" )
-
-$cmake_sysroot
-
-# Use qt.conf settings
-set( ENV{QT_CONF_PATH} ${WORKDIR}/qt.conf )
-
-# We need to set the rpath to the correct directory as cmake does not provide any
-# directory as rpath by default
-set( CMAKE_INSTALL_RPATH ${OECMAKE_RPATH} )
-
-# Use RPATHs relative to build directory for reproducibility
-set( CMAKE_BUILD_RPATH_USE_ORIGIN ON )
-
-# Use our cmake modules
-list(APPEND CMAKE_MODULE_PATH "${STAGING_DATADIR}/cmake/Modules/")
-
-# add for non /usr/lib libdir, e.g. /usr/lib64
-set( CMAKE_LIBRARY_PATH ${libdir} ${base_libdir})
-
-# add include dir to implicit includes in case it differs from /usr/include
-list(APPEND CMAKE_C_IMPLICIT_INCLUDE_DIRECTORIES ${includedir})
-list(APPEND CMAKE_CXX_IMPLICIT_INCLUDE_DIRECTORIES ${includedir})
-
-EOF
-        cat > ${WORKDIR}/toolchain-native.cmake <<EOF
-set( CMAKE_C_COMPILER ${OECMAKE_NATIVE_C_COMPILER} )
-set( CMAKE_CXX_COMPILER ${OECMAKE_NATIVE_CXX_COMPILER} )
-set( CMAKE_ASM_COMPILER ${OECMAKE_NATIVE_C_COMPILER} )
-set( CMAKE_AR ${OECMAKE_NATIVE_AR} CACHE FILEPATH "Archiver" )
-set( CMAKE_RANLIB ${OECMAKE_NATIVE_RANLIB} CACHE FILEPATH "Archive Indexer" )
-set( CMAKE_NM ${OECMAKE_NATIVE_NM} CACHE FILEPATH "Symbol Lister" )
-set( CMAKE_C_FLAGS "${OECMAKE_NATIVE_C_FLAGS}" CACHE STRING "CFLAGS" )
-set( CMAKE_CXX_FLAGS "${OECMAKE_NATIVE_CXX_FLAGS}" CACHE STRING "CXXFLAGS" )
-set( CMAKE_ASM_FLAGS "${OECMAKE_NATIVE_C_FLAGS}" CACHE STRING "ASM FLAGS" )
-set( CMAKE_C_FLAGS_RELEASE "${OECMAKE_NATIVE_C_FLAGS_RELEASE}" CACHE STRING "Additional CFLAGS for release" )
-set( CMAKE_CXX_FLAGS_RELEASE "${OECMAKE_NATIVE_CXX_FLAGS_RELEASE}" CACHE STRING "Additional CXXFLAGS for release" )
-set( CMAKE_ASM_FLAGS_RELEASE "${OECMAKE_NATIVE_C_FLAGS_RELEASE}" CACHE STRING "Additional ASM FLAGS for release" )
-set( CMAKE_C_LINK_FLAGS "${OECMAKE_NATIVE_C_LINK_FLAGS}" CACHE STRING "LDFLAGS" )
-set( CMAKE_CXX_LINK_FLAGS "${OECMAKE_NATIVE_CXX_LINK_FLAGS}" CACHE STRING "LDFLAGS" )
-
-set( CMAKE_FIND_ROOT_PATH ${STAGING_DIR_NATIVE} )
-set( CMAKE_FIND_ROOT_PATH_MODE_PACKAGE ONLY )
-set( CMAKE_FIND_ROOT_PATH_MODE_PROGRAM BOTH )
-set( CMAKE_FIND_ROOT_PATH_MODE_LIBRARY ONLY )
-set( CMAKE_FIND_ROOT_PATH_MODE_INCLUDE ONLY )
-
-# Use native cmake modules
-list(APPEND CMAKE_MODULE_PATH "${STAGING_DATADIR_NATIVE}/cmake/Modules/")
-
-# add for non /usr/lib libdir, e.g. /usr/lib64
-set( CMAKE_LIBRARY_PATH ${STAGING_BASE_LIBDIR_NATIVE} ${STAGING_LIBDIR_NATIVE})
-
-# add include dir to implicit includes in case it differs from /usr/include
-list(APPEND CMAKE_C_IMPLICIT_INCLUDE_DIRECTORIES ${STAGING_INCDIR_NATIVE})
-list(APPEND CMAKE_CXX_IMPLICIT_INCLUDE_DIRECTORIES ${STAGING_INCDIR_NATIVE})
-
-# The assignmens above override CFLAGS and CXXFLAGS from the environment but
-# not LDFLAGS, which ends up in CMAKE_EXE_LINKER_FLAGS. This then means our
-# native builds use target flags, and can fail.
-#
-# As there are a number of variables that are set from LDFLAGS,
-# clear it at source.
-#
-# https://cmake.org/cmake/help/latest/envvar/LDFLAGS.html
-unset(ENV{LDFLAGS})
-EOF
-}
-
-cmake_do_generate_toolchain_file:append:toolchain-clang() {
-        cat >> ${WORKDIR}/toolchain.cmake <<EOF
-set( CMAKE_CLANG_TIDY ${HOST_PREFIX}clang-tidy )
-EOF
-}
-
-addtask generate_toolchain_file after do_patch before do_configure
-
-CONFIGURE_FILES = "CMakeLists.txt *.cmake"
-
-do_configure[cleandirs] = "${@d.getVar('B') if d.getVar('S') != d.getVar('B') else ''}"
-
-OECMAKE_ARGS = "\
-    -DCMAKE_INSTALL_PREFIX:PATH=${prefix} \
-    -DCMAKE_INSTALL_BINDIR:PATH=${@os.path.relpath(d.getVar('bindir'), d.getVar('prefix') + '/')} \
-    -DCMAKE_INSTALL_SBINDIR:PATH=${@os.path.relpath(d.getVar('sbindir'), d.getVar('prefix') + '/')} \
-    -DCMAKE_INSTALL_LIBEXECDIR:PATH=${@os.path.relpath(d.getVar('libexecdir'), d.getVar('prefix') + '/')} \
-    -DCMAKE_INSTALL_SYSCONFDIR:PATH=${sysconfdir} \
-    -DCMAKE_INSTALL_SHAREDSTATEDIR:PATH=${@os.path.relpath(d.getVar('sharedstatedir'), d.getVar('prefix') + '/')} \
-    -DCMAKE_INSTALL_LOCALSTATEDIR:PATH=${localstatedir} \
-    -DCMAKE_INSTALL_LIBDIR:PATH=${@os.path.relpath(d.getVar('libdir'), d.getVar('prefix') + '/')} \
-    -DCMAKE_INSTALL_INCLUDEDIR:PATH=${@os.path.relpath(d.getVar('includedir'), d.getVar('prefix') + '/')} \
-    -DCMAKE_INSTALL_DATAROOTDIR:PATH=${@os.path.relpath(d.getVar('datadir'), d.getVar('prefix') + '/')} \
-    -DPYTHON_EXECUTABLE:PATH=${PYTHON} \
-    -DPython_EXECUTABLE:PATH=${PYTHON} \
-    -DPython3_EXECUTABLE:PATH=${PYTHON} \
-    -DLIB_SUFFIX=${@d.getVar('baselib').replace('lib', '')} \
-    -DCMAKE_INSTALL_SO_NO_EXE=0 \
-    -DCMAKE_TOOLCHAIN_FILE:FILEPATH=${WORKDIR}/toolchain.cmake \
-    -DCMAKE_NO_SYSTEM_FROM_IMPORTED=1 \
-    -DCMAKE_EXPORT_NO_PACKAGE_REGISTRY=ON \
-    -DFETCHCONTENT_FULLY_DISCONNECTED=ON \
-    -DCMAKE_EXPORT_COMPILE_COMMANDS:BOOL=ON \
-"
-
-cmake_do_configure() {
-        if [ "${OECMAKE_BUILDPATH}" ]; then
-                bbnote "cmake.bbclass no longer uses OECMAKE_BUILDPATH.  The default behaviour is now out-of-tree builds with B=WORKDIR/build."
-        fi
-
-        if [ "${S}" = "${B}" ]; then
-                find ${B} -name CMakeFiles -or -name Makefile -or -name cmake_install.cmake -or -name CMakeCache.txt -delete
-        fi
-
-        # Just like autotools cmake can use a site file to cache result that need generated binaries to run
-        if [ -e ${WORKDIR}/site-file.cmake ] ; then
-                oecmake_sitefile="-C ${WORKDIR}/site-file.cmake"
-        else
-                oecmake_sitefile=
-        fi
-
-        cmake \
-          ${OECMAKE_GENERATOR_ARGS} \
-          $oecmake_sitefile \
-          ${OECMAKE_SOURCEPATH} \
-          ${OECMAKE_ARGS} \
-          ${EXTRA_OECMAKE} \
-          -Wno-dev
-}
-
-# To disable verbose cmake logs for a given recipe or globally config metadata e.g. local.conf
-# add following
-#
-# CMAKE_VERBOSE = ""
-#
-
-CMAKE_VERBOSE ??= "VERBOSE=1"
-
-# Then run do_compile again
-cmake_runcmake_build() {
-        bbnote ${DESTDIR:+DESTDIR=${DESTDIR} }${CMAKE_VERBOSE} cmake --build '${B}' "$@" -- ${EXTRA_OECMAKE_BUILD}
-        eval ${DESTDIR:+DESTDIR=${DESTDIR} }${CMAKE_VERBOSE} cmake --build '${B}' "$@" -- ${EXTRA_OECMAKE_BUILD}
-}
-
-# Install an already-generated project binary tree. Not checking the compile
-# dependencies again is particularly important for SDK use cases.
-cmake_runcmake_install() {
-        bbnote ${DESTDIR:+DESTDIR=${DESTDIR} }${CMAKE_VERBOSE} cmake --install '${B}'
-        eval ${DESTDIR:+DESTDIR=${DESTDIR} }${CMAKE_VERBOSE} cmake --install '${B}'
-}
-
-cmake_do_compile()  {
-        cmake_runcmake_build --target ${OECMAKE_TARGET_COMPILE}
-}
-
-cmake_do_install() {
-        if [ "${OECMAKE_TARGET_INSTALL}" = "install" ]; then
-                DESTDIR='${D}' cmake_runcmake_install
-        else
-                # Legacy path which supports also custom install targets
-                DESTDIR='${D}' cmake_runcmake_build --target ${OECMAKE_TARGET_INSTALL}
-        fi
-}
-
-EXPORT_FUNCTIONS do_configure do_compile do_install do_generate_toolchain_file
diff --git a/meta/classes-recipe/cml1.bbclass b/meta/classes-recipe/cml1.bbclass
deleted file mode 100644
index 3c2b4da4af..0000000000
--- a/meta/classes-recipe/cml1.bbclass
+++ /dev/null
@@ -1,121 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-# returns all the elements from the src uri that are .cfg files
-def find_cfgs(d):
-    sources=src_patches(d, True)
-    sources_list=[]
-    for s in sources:
-        if s.endswith('.cfg'):
-            sources_list.append(s)
-
-    return sources_list
-
-cml1_do_configure() {
-        set -e
-        unset CFLAGS CPPFLAGS CXXFLAGS LDFLAGS
-        yes '' | oe_runmake oldconfig
-}
-
-EXPORT_FUNCTIONS do_configure
-
-inherit terminal
-
-OE_TERMINAL_EXPORTS += "HOST_EXTRACFLAGS HOSTLDFLAGS TERMINFO CROSS_CURSES_LIB CROSS_CURSES_INC"
-HOST_EXTRACFLAGS = "${BUILD_CFLAGS} ${BUILD_LDFLAGS}"
-HOSTLDFLAGS = "${BUILD_LDFLAGS}"
-CROSS_CURSES_LIB = "-lncurses -ltinfo"
-CROSS_CURSES_INC = '-DCURSES_LOC="<curses.h>"'
-TERMINFO = "${STAGING_DATADIR_NATIVE}/terminfo"
-
-KCONFIG_CONFIG_COMMAND ??= "menuconfig ${EXTRA_OEMAKE}"
-KCONFIG_CONFIG_ENABLE_MENUCONFIG ??= "true"
-KCONFIG_CONFIG_ROOTDIR ??= "${B}"
-python do_menuconfig() {
-    import shutil
-
-    if not bb.utils.to_boolean(d.getVar("KCONFIG_CONFIG_ENABLE_MENUCONFIG")):
-        bb.fatal("do_menuconfig is disabled, please check KCONFIG_CONFIG_ENABLE_MENUCONFIG variable.")
-        return
-
-    config = os.path.join(d.getVar('KCONFIG_CONFIG_ROOTDIR'), ".config")
-    configorig = os.path.join(d.getVar('KCONFIG_CONFIG_ROOTDIR'), ".config.orig")
-
-    try:
-        mtime = os.path.getmtime(config)
-        shutil.copy(config, configorig)
-    except OSError:
-        mtime = 0
-
-    # setup native pkg-config variables (kconfig scripts call pkg-config directly, cannot generically be overriden to pkg-config-native)
-    d.setVar("PKG_CONFIG_DIR", "${STAGING_DIR_NATIVE}${libdir_native}/pkgconfig")
-    d.setVar("PKG_CONFIG_PATH", "${PKG_CONFIG_DIR}:${STAGING_DATADIR_NATIVE}/pkgconfig")
-    d.setVar("PKG_CONFIG_LIBDIR", "${PKG_CONFIG_DIR}")
-    d.setVarFlag("PKG_CONFIG_SYSROOT_DIR", "unexport", "1")
-    # ensure that environment variables are overwritten with this tasks 'd' values
-    d.appendVar("OE_TERMINAL_EXPORTS", " PKG_CONFIG_DIR PKG_CONFIG_PATH PKG_CONFIG_LIBDIR PKG_CONFIG_SYSROOT_DIR")
-
-    oe_terminal("sh -c 'make %s; if [ $? -ne 0 ]; then echo \"Command failed.\"; printf \"Press any key to continue... \"; read r; fi'" % d.getVar('KCONFIG_CONFIG_COMMAND'),
-                d.getVar('PN') + ' Configuration', d)
-
-    try:
-        newmtime = os.path.getmtime(config)
-    except OSError:
-        newmtime = 0
-
-    if newmtime > mtime:
-        bb.plain("Changed configuration saved at:\n %s\nRecompile will be forced" % config)
-        bb.build.write_taint('do_compile', d)
-}
-do_menuconfig[depends] += "ncurses-native:do_populate_sysroot"
-do_menuconfig[nostamp] = "1"
-do_menuconfig[dirs] = "${KCONFIG_CONFIG_ROOTDIR}"
-addtask menuconfig after do_configure
-
-python do_diffconfig() {
-    import shutil
-    import subprocess
-
-    workdir = d.getVar('WORKDIR')
-    fragment = workdir + '/fragment.cfg'
-    configorig = os.path.join(d.getVar('KCONFIG_CONFIG_ROOTDIR'), ".config.orig")
-    config = os.path.join(d.getVar('KCONFIG_CONFIG_ROOTDIR'), ".config")
-
-    try:
-        md5newconfig = bb.utils.md5_file(configorig)
-        md5config = bb.utils.md5_file(config)
-        isdiff = md5newconfig != md5config
-    except IOError as e:
-        bb.fatal("No config files found. Did you do menuconfig ?\n%s" % e)
-
-    if isdiff:
-        statement = 'diff --unchanged-line-format= --old-line-format= --new-line-format="%L" ' + configorig + ' ' + config + '>' + fragment
-        # No need to check the exit code as we know it's going to be
-        # non-zero, but that's what we expect.
-        subprocess.call(statement, shell=True)
-
-        bb.plain("Config fragment has been dumped into:\n %s" % fragment)
-    else:
-        if os.path.exists(fragment):
-            os.unlink(fragment)
-}
-
-do_diffconfig[nostamp] = "1"
-do_diffconfig[dirs] = "${KCONFIG_CONFIG_ROOTDIR}"
-addtask diffconfig
-
-do_showconfig() {
-    bbplain "Config file written to ${KCONFIG_CONFIG_ROOTDIR}/.config"
-}
-do_showconfig[nostamp] = "1"
-addtask showconfig after do_configure
-
-do_savedefconfig() {
-        bbplain "Saving defconfig to:\n${B}/defconfig"
-        oe_runmake -C ${B} savedefconfig
-}
-do_savedefconfig[nostamp] = "1"
-addtask savedefconfig after do_configure
diff --git a/meta/classes-recipe/compress_doc.bbclass b/meta/classes-recipe/compress_doc.bbclass
deleted file mode 100644
index d603caf858..0000000000
--- a/meta/classes-recipe/compress_doc.bbclass
+++ /dev/null
@@ -1,269 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-# Compress man pages in ${mandir} and info pages in ${infodir}
-#
-# 1. The doc will be compressed to gz format by default.
-#
-# 2. It will automatically correct the compressed doc which is not
-# in ${DOC_COMPRESS} but in ${DOC_COMPRESS_LIST} to the format
-# of ${DOC_COMPRESS} policy
-#
-# 3. It is easy to add a new type compression by editing
-# local.conf, such as:
-# DOC_COMPRESS_LIST:append = ' abc'
-# DOC_COMPRESS = 'abc'
-# DOC_COMPRESS_CMD[abc] = 'abc compress cmd ***'
-# DOC_DECOMPRESS_CMD[abc] = 'abc decompress cmd ***'
-
-# All supported compression policy
-DOC_COMPRESS_LIST ?= "gz xz bz2"
-
-# Compression policy, must be one of ${DOC_COMPRESS_LIST}
-DOC_COMPRESS ?= "gz"
-
-# Compression shell command
-DOC_COMPRESS_CMD[gz] ?= 'gzip -v -9 -n'
-DOC_COMPRESS_CMD[bz2] ?= "bzip2 -v -9"
-DOC_COMPRESS_CMD[xz] ?= "xz -v"
-
-# Decompression shell command
-DOC_DECOMPRESS_CMD[gz] ?= 'gunzip -v'
-DOC_DECOMPRESS_CMD[bz2] ?= "bunzip2 -v"
-DOC_DECOMPRESS_CMD[xz] ?= "unxz -v"
-
-PACKAGE_PREPROCESS_FUNCS += "package_do_compress_doc compress_doc_updatealternatives"
-python package_do_compress_doc() {
-    compress_mode = d.getVar('DOC_COMPRESS')
-    compress_list = (d.getVar('DOC_COMPRESS_LIST') or '').split()
-    if compress_mode not in compress_list:
-        bb.fatal('Compression policy %s not supported (not listed in %s)\n' % (compress_mode, compress_list))
-
-    dvar = d.getVar('PKGD')
-    compress_cmds = {}
-    decompress_cmds = {}
-    for mode in compress_list:
-        compress_cmds[mode] = d.getVarFlag('DOC_COMPRESS_CMD', mode)
-        decompress_cmds[mode] = d.getVarFlag('DOC_DECOMPRESS_CMD', mode)
-
-    mandir = os.path.abspath(dvar + os.sep + d.getVar("mandir"))
-    if os.path.exists(mandir):
-        # Decompress doc files which format is not compress_mode
-        decompress_doc(mandir, compress_mode, decompress_cmds)
-        compress_doc(mandir, compress_mode, compress_cmds)
-
-    infodir = os.path.abspath(dvar + os.sep + d.getVar("infodir"))
-    if os.path.exists(infodir):
-        # Decompress doc files which format is not compress_mode
-        decompress_doc(infodir, compress_mode, decompress_cmds)
-        compress_doc(infodir, compress_mode, compress_cmds)
-}
-
-def _get_compress_format(file, compress_format_list):
-    for compress_format in compress_format_list:
-        compress_suffix = '.' + compress_format
-        if file.endswith(compress_suffix):
-            return compress_format
-
-    return ''
-
-# Collect hardlinks to dict, each element in dict lists hardlinks
-# which points to the same doc file.
-# {hardlink10: [hardlink11, hardlink12],,,}
-# The hardlink10, hardlink11 and hardlink12 are the same file.
-def _collect_hardlink(hardlink_dict, file):
-    for hardlink in hardlink_dict:
-        # Add to the existed hardlink
-        if os.path.samefile(hardlink, file):
-            hardlink_dict[hardlink].append(file)
-            return hardlink_dict
-
-    hardlink_dict[file] = []
-    return hardlink_dict
-
-def _process_hardlink(hardlink_dict, compress_mode, shell_cmds, decompress=False):
-    import subprocess
-    for target in hardlink_dict:
-        if decompress:
-            compress_format = _get_compress_format(target, shell_cmds.keys())
-            cmd = "%s -f %s" % (shell_cmds[compress_format], target)
-            bb.note('decompress hardlink %s' % target)
-        else:
-            cmd = "%s -f %s" % (shell_cmds[compress_mode], target)
-            bb.note('compress hardlink %s' % target)
-        (retval, output) = subprocess.getstatusoutput(cmd)
-        if retval:
-            bb.warn("de/compress file failed %s (cmd was %s)%s" % (retval, cmd, ":\n%s" % output if output else ""))
-            return
-
-        for hardlink_dup in hardlink_dict[target]:
-            if decompress:
-                # Remove compress suffix
-                compress_suffix = '.' + compress_format
-                new_hardlink = hardlink_dup[:-len(compress_suffix)]
-                new_target = target[:-len(compress_suffix)]
-            else:
-                # Append compress suffix
-                compress_suffix = '.' + compress_mode
-                new_hardlink = hardlink_dup + compress_suffix
-                new_target = target + compress_suffix
-
-            bb.note('hardlink %s-->%s' % (new_hardlink, new_target))
-            if not os.path.exists(new_hardlink):
-                os.link(new_target, new_hardlink)
-            if os.path.exists(hardlink_dup):
-                os.unlink(hardlink_dup)
-
-def _process_symlink(file, compress_format, decompress=False):
-    compress_suffix = '.' + compress_format
-    if decompress:
-        # Remove compress suffix
-        new_linkname = file[:-len(compress_suffix)]
-        new_source = os.readlink(file)[:-len(compress_suffix)]
-    else:
-        # Append compress suffix
-        new_linkname = file + compress_suffix
-        new_source = os.readlink(file) + compress_suffix
-
-    bb.note('symlink %s-->%s' % (new_linkname, new_source))
-    if not os.path.exists(new_linkname):
-        os.symlink(new_source, new_linkname)
-
-    os.unlink(file)
-
-def _is_info(file):
-    flags = '.info .info-'.split()
-    for flag in flags:
-        if flag in os.path.basename(file):
-            return True
-
-    return False
-
-def _is_man(file):
-    import re
-
-    # It refers MANSECT-var in man(1.6g)'s man.config
-    # ".1:.1p:.8:.2:.3:.3p:.4:.5:.6:.7:.9:.0p:.tcl:.n:.l:.p:.o"
-    # Not start with '.', and contain the above colon-seperate element
-    p = re.compile(r'[^\.]+\.([1-9lnop]|0p|tcl)')
-    if p.search(file):
-        return True
-
-    return False
-
-def _is_compress_doc(file, compress_format_list):
-    compress_format = _get_compress_format(file, compress_format_list)
-    compress_suffix = '.' + compress_format
-    if file.endswith(compress_suffix):
-        # Remove the compress suffix
-        uncompress_file = file[:-len(compress_suffix)]
-        if _is_info(uncompress_file) or _is_man(uncompress_file):
-            return True, compress_format
-
-    return False, ''
-
-def compress_doc(topdir, compress_mode, compress_cmds):
-    import subprocess
-    hardlink_dict = {}
-    for root, dirs, files in os.walk(topdir):
-        for f in files:
-            file = os.path.join(root, f)
-            if os.path.isdir(file):
-                continue
-
-            if _is_info(file) or _is_man(file):
-                # Symlink
-                if os.path.islink(file):
-                    _process_symlink(file, compress_mode)
-                # Hardlink
-                elif os.lstat(file).st_nlink > 1:
-                    _collect_hardlink(hardlink_dict, file)
-                # Normal file
-                elif os.path.isfile(file):
-                    cmd = "%s %s" % (compress_cmds[compress_mode], file)
-                    (retval, output) = subprocess.getstatusoutput(cmd)
-                    if retval:
-                        bb.warn("compress failed %s (cmd was %s)%s" % (retval, cmd, ":\n%s" % output if output else ""))
-                        continue
-                    bb.note('compress file %s' % file)
-
-    _process_hardlink(hardlink_dict, compress_mode, compress_cmds)
-
-# Decompress doc files which format is not compress_mode
-def decompress_doc(topdir, compress_mode, decompress_cmds):
-    import subprocess
-    hardlink_dict = {}
-    decompress = True
-    for root, dirs, files in os.walk(topdir):
-        for f in files:
-            file = os.path.join(root, f)
-            if os.path.isdir(file):
-                continue
-
-            res, compress_format = _is_compress_doc(file, decompress_cmds.keys())
-            # Decompress files which format is not compress_mode
-            if res and compress_mode!=compress_format:
-                # Symlink
-                if os.path.islink(file):
-                    _process_symlink(file, compress_format, decompress)
-                # Hardlink
-                elif os.lstat(file).st_nlink > 1:
-                    _collect_hardlink(hardlink_dict, file)
-                # Normal file
-                elif os.path.isfile(file):
-                    cmd = "%s %s" % (decompress_cmds[compress_format], file)
-                    (retval, output) = subprocess.getstatusoutput(cmd)
-                    if retval:
-                        bb.warn("decompress failed %s (cmd was %s)%s" % (retval, cmd, ":\n%s" % output if output else ""))
-                        continue
-                    bb.note('decompress file %s' % file)
-
-    _process_hardlink(hardlink_dict, compress_mode, decompress_cmds, decompress)
-
-python compress_doc_updatealternatives () {
-    if not bb.data.inherits_class('update-alternatives', d):
-        return
-
-    mandir = d.getVar("mandir")
-    infodir = d.getVar("infodir")
-    compress_mode = d.getVar('DOC_COMPRESS')
-    for pkg in (d.getVar('PACKAGES') or "").split():
-        old_names = (d.getVar('ALTERNATIVE:%s' % pkg) or "").split()
-        new_names = []
-        for old_name in old_names:
-            old_link     = d.getVarFlag('ALTERNATIVE_LINK_NAME', old_name)
-            old_target   = d.getVarFlag('ALTERNATIVE_TARGET_%s' % pkg, old_name) or \
-                d.getVarFlag('ALTERNATIVE_TARGET', old_name) or \
-                d.getVar('ALTERNATIVE_TARGET_%s' % pkg) or \
-                d.getVar('ALTERNATIVE_TARGET') or \
-                old_link
-            # Sometimes old_target is specified as relative to the link name.
-            old_target   = os.path.join(os.path.dirname(old_link), old_target)
-
-            # The updatealternatives used for compress doc
-            if mandir in old_target or infodir in old_target:
-                new_name = old_name + '.' + compress_mode
-                new_link = old_link + '.' + compress_mode
-                new_target = old_target + '.' + compress_mode
-                d.delVarFlag('ALTERNATIVE_LINK_NAME', old_name)
-                d.setVarFlag('ALTERNATIVE_LINK_NAME', new_name, new_link)
-                if d.getVarFlag('ALTERNATIVE_TARGET_%s' % pkg, old_name):
-                    d.delVarFlag('ALTERNATIVE_TARGET_%s' % pkg, old_name)
-                    d.setVarFlag('ALTERNATIVE_TARGET_%s' % pkg, new_name, new_target)
-                elif d.getVarFlag('ALTERNATIVE_TARGET', old_name):
-                    d.delVarFlag('ALTERNATIVE_TARGET', old_name)
-                    d.setVarFlag('ALTERNATIVE_TARGET', new_name, new_target)
-                elif d.getVar('ALTERNATIVE_TARGET_%s' % pkg):
-                    d.setVar('ALTERNATIVE_TARGET_%s' % pkg, new_target)
-                elif d.getVar('ALTERNATIVE_TARGET'):
-                    d.setVar('ALTERNATIVE_TARGET', new_target)
-
-                new_names.append(new_name)
-
-        if new_names:
-            d.setVar('ALTERNATIVE:%s' % pkg, ' '.join(new_names))
-}
-
diff --git a/meta/classes-recipe/core-image.bbclass b/meta/classes-recipe/core-image.bbclass
deleted file mode 100644
index 994185ed4c..0000000000
--- a/meta/classes-recipe/core-image.bbclass
+++ /dev/null
@@ -1,95 +0,0 @@
-# Common code for generating core reference images
-#
-# Copyright (C) 2007-2011 Linux Foundation
-#
-# SPDX-License-Identifier: MIT
-
-# IMAGE_FEATURES control the content of the core reference images
-# 
-# By default we install packagegroup-core-boot and packagegroup-base-extended packages;
-# this gives us a working (console only) rootfs.
-#
-# Available IMAGE_FEATURES:
-#
-# These features install additional packages into the rootfs:
-# - eclipse-debug       - Eclipse remote debugging support
-# - hwcodecs            - hardware acceleration codecs (specified in MACHINE_HWCODECS)
-# - nfs-client          - NFS client
-# - nfs-server          - NFS server
-# - package-management  - installs package management tools and preserves the package manager database
-# - splash              - bootup splash screen
-# - ssh-server-dropbear - SSH server (dropbear)
-# - ssh-server-openssh  - SSH server (openssh)
-# - tools-debug         - debugging tools
-# - tools-profile       - profiling tools
-# - tools-sdk           - SDK (C/C++ compiler, autotools, etc.)
-# - tools-testapps      - tools usable to make some device tests
-# - weston              - Weston Wayland compositor
-# - x11                 - X server
-# - x11-base            - X server with minimal environment
-# - x11-sato            - OpenedHand Sato environment
-#
-# These features install complementary packages for all installed packages in the rootfs:
-# - dbg-pkgs            - debug symbol packages
-# - dev-pkgs            - development packages (headers, etc.)
-# - doc-pkgs            - documentation packages
-# - lic-pkgs            - license packages, requires LICENSE_CREATE_PACKAGE="1" to be set when building packages too
-# - ptest-pkgs          - ptest packages for all ptest-enabled recipes
-#
-# These features install complementary development packages:
-# - bash-completion-pkgs - bash-completion packages for recipes using bash-completion bbclass
-# - zsh-completion-pkgs - zsh-completion packages
-#
-# These features tweak the behavior of the rootfs:
-# - overlayfs-etc       - sets up /etc in overlayfs
-# - read-only-rootfs    - tweaks an image to support a read-only rootfs
-# - read-only-rootfs-delayed-postinsts - supports post-install scripts with read-only-rootfs
-# - stateless-rootfs    - systemctl-native is not run, image is populated by systemd at runtime
-#
-# These features are for development purposes (some were previously part of the debug-tweaks feature):
-# - allow-empty-password  - users can have an empty password (debug-tweaks)
-# - allow-root-login      - the root user can login (debug-tweaks)
-# - empty-root-password   - the root user has no password set (debug-tweaks)
-# - post-install-logging  - log the output of postinstall scriptlets (debug-tweaks)
-# - serial-autologin-root - with 'empty-root-password': autologin 'root' on the serial console
-#
-FEATURE_PACKAGES_eclipse-debug = "packagegroup-core-eclipse-debug"
-FEATURE_PACKAGES_hwcodecs = "${MACHINE_HWCODECS}"
-FEATURE_PACKAGES_nfs-client = "packagegroup-core-nfs-client"
-FEATURE_PACKAGES_nfs-server = "packagegroup-core-nfs-server"
-FEATURE_PACKAGES_ssh-server-dropbear = "packagegroup-core-ssh-dropbear"
-FEATURE_PACKAGES_ssh-server-openssh = "packagegroup-core-ssh-openssh"
-FEATURE_PACKAGES_tools-debug = "packagegroup-core-tools-debug"
-FEATURE_PACKAGES_tools-profile = "packagegroup-core-tools-profile"
-FEATURE_PACKAGES_tools-sdk = "packagegroup-core-sdk packagegroup-core-standalone-sdk-target"
-FEATURE_PACKAGES_tools-testapps = "packagegroup-core-tools-testapps"
-FEATURE_PACKAGES_weston = "packagegroup-core-weston"
-FEATURE_PACKAGES_x11 = "packagegroup-core-x11"
-FEATURE_PACKAGES_x11-base = "packagegroup-core-x11-base"
-FEATURE_PACKAGES_x11-sato = "packagegroup-core-x11-sato"
-
-# IMAGE_FEATURES_REPLACES_foo = 'bar1 bar2'
-# Including image feature foo would replace the image features bar1 and bar2
-IMAGE_FEATURES_REPLACES_ssh-server-openssh = "ssh-server-dropbear"
-# Do not install openssh complementary packages if either packagegroup-core-ssh-dropbear or dropbear
-# is installed # to avoid openssh-dropbear conflict
-# see [Yocto #14858] for more information
-PACKAGE_EXCLUDE_COMPLEMENTARY:append = "${@bb.utils.contains_any('PACKAGE_INSTALL', 'packagegroup-core-ssh-dropbear dropbear', ' openssh', '' , d)}"
-
-# IMAGE_FEATURES_CONFLICTS_foo = 'bar1 bar2'
-# An error exception would be raised if both image features foo and bar1(or bar2) are included
-
-MACHINE_HWCODECS ??= ""
-
-CORE_IMAGE_BASE_INSTALL = '\
-    packagegroup-core-boot \
-    packagegroup-base-extended \
-    \
-    ${CORE_IMAGE_EXTRA_INSTALL} \
-    '
-
-CORE_IMAGE_EXTRA_INSTALL ?= ""
-
-IMAGE_INSTALL ?= "${CORE_IMAGE_BASE_INSTALL}"
-
-inherit image
diff --git a/meta/classes-recipe/cpan-base.bbclass b/meta/classes-recipe/cpan-base.bbclass
deleted file mode 100644
index 1db0a4ded6..0000000000
--- a/meta/classes-recipe/cpan-base.bbclass
+++ /dev/null
@@ -1,33 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-#
-# cpan-base providers various perl related information needed for building
-# cpan modules
-#
-FILES:${PN} += "${libdir}/perl5 ${datadir}/perl5"
-
-DEPENDS  += "${@["perl", "perl-native"][(bb.data.inherits_class('native', d))]}"
-RDEPENDS:${PN} += "${@["perl", ""][(bb.data.inherits_class('native', d))]}"
-
-inherit perl-version
-
-def is_target(d):
-    if not bb.data.inherits_class('native', d):
-        return "yes"
-    return "no"
-
-PERLLIBDIRS = "${libdir}/perl5"
-PERLLIBDIRS:class-native = "${libdir}/perl5"
-
-def cpan_upstream_check_pattern(d):
-    for x in (d.getVar('SRC_URI') or '').split(' '):
-        if x.startswith("https://cpan.metacpan.org"):
-            _pattern = x.split('/')[-1].replace(d.getVar('PV'), r'(?P<pver>\d+.\d+)')
-            return _pattern
-    return ''
-
-UPSTREAM_CHECK_REGEX ?= "${@cpan_upstream_check_pattern(d)}"
diff --git a/meta/classes-recipe/cpan.bbclass b/meta/classes-recipe/cpan.bbclass
deleted file mode 100644
index bb76a5b326..0000000000
--- a/meta/classes-recipe/cpan.bbclass
+++ /dev/null
@@ -1,71 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-#
-# This is for perl modules that use the old Makefile.PL build system
-#
-inherit cpan-base perlnative
-
-EXTRA_CPANFLAGS ?= ""
-EXTRA_PERLFLAGS ?= ""
-
-# Env var which tells perl if it should use host (no) or target (yes) settings
-export PERLCONFIGTARGET = "${@is_target(d)}"
-
-# Env var which tells perl where the perl include files are
-export PERL_INC = "${STAGING_LIBDIR}${PERL_OWN_DIR}/perl5/${@get_perl_version(d)}/${@get_perl_arch(d)}/CORE"
-export PERL_LIB = "${STAGING_LIBDIR}${PERL_OWN_DIR}/perl5/${@get_perl_version(d)}"
-export PERL_ARCHLIB = "${STAGING_LIBDIR}${PERL_OWN_DIR}/perl5/${@get_perl_version(d)}/${@get_perl_arch(d)}"
-export PERLHOSTLIB = "${STAGING_LIBDIR_NATIVE}/perl5/${@get_perl_version(d)}/"
-export PERLHOSTARCHLIB = "${STAGING_LIBDIR_NATIVE}/perl5/${@get_perl_version(d)}/${@get_perl_hostarch(d)}/"
-
-cpan_do_configure () {
-        yes '' | perl ${EXTRA_PERLFLAGS} Makefile.PL INSTALLDIRS=vendor NO_PERLLOCAL=1 NO_PACKLIST=1 PERL=$(which perl) ${EXTRA_CPANFLAGS}
-
-        # Makefile.PLs can exit with success without generating a
-        # Makefile, e.g. in cases of missing configure time
-        # dependencies. This is considered a best practice by
-        # cpantesters.org. See:
-        #  * http://wiki.cpantesters.org/wiki/CPANAuthorNotes
-        #  * http://www.nntp.perl.org/group/perl.qa/2008/08/msg11236.html
-        [ -e Makefile ] || bbfatal "No Makefile was generated by Makefile.PL"
-
-        if [ "${BUILD_SYS}" != "${HOST_SYS}" ]; then
-                . ${STAGING_LIBDIR}${PERL_OWN_DIR}/perl5/config.sh
-                # Use find since there can be a Makefile generated for each Makefile.PL
-                for f in `find -name Makefile.PL`; do
-                        f2=`echo $f | sed -e 's/.PL//'`
-                        test -f $f2 || continue
-                        sed -i -e "s:\(PERL_ARCHLIB = \).*:\1${PERL_ARCHLIB}:" \
-                                -e 's/perl.real/perl/' \
-                                -e "s|^\(CCFLAGS =.*\)|\1 ${CFLAGS}|" \
-                                $f2
-                done
-        fi
-}
-
-do_configure:append:class-target() {
-       find . -name Makefile | xargs sed -E -i \
-           -e 's:LD_RUN_PATH ?= ?"?[^"]*"?::g'
-}
-
-do_configure:append:class-nativesdk() {
-       find . -name Makefile | xargs sed -E -i \
-           -e 's:LD_RUN_PATH ?= ?"?[^"]*"?::g'
-}
-
-cpan_do_compile () {
-        oe_runmake PASTHRU_INC="${CFLAGS}" LD="${CCLD}"
-}
-
-cpan_do_install () {
-        oe_runmake DESTDIR="${D}" install_vendor
-        for PERLSCRIPT in `grep -rIEl '#! *${bindir}/perl-native.*/perl' ${D}`; do
-                sed -i -e 's|${bindir}/perl-native.*/perl|/usr/bin/env nativeperl|' $PERLSCRIPT
-        done
-}
-
-EXPORT_FUNCTIONS do_configure do_compile do_install
diff --git a/meta/classes-recipe/cpan_build.bbclass b/meta/classes-recipe/cpan_build.bbclass
deleted file mode 100644
index 026859b6c7..0000000000
--- a/meta/classes-recipe/cpan_build.bbclass
+++ /dev/null
@@ -1,47 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-#
-# This is for perl modules that use the new Build.PL build system
-#
-inherit cpan-base perlnative
-
-EXTRA_CPAN_BUILD_FLAGS ?= ""
-
-# Env var which tells perl if it should use host (no) or target (yes) settings
-export PERLCONFIGTARGET = "${@is_target(d)}"
-export PERL_ARCHLIB = "${STAGING_LIBDIR}${PERL_OWN_DIR}/perl5/${@get_perl_version(d)}/${@get_perl_arch(d)}"
-export PERLHOSTLIB = "${STAGING_LIBDIR_NATIVE}/perl5/${@get_perl_version(d)}/"
-export PERLHOSTARCHLIB = "${STAGING_LIBDIR_NATIVE}/perl5/${@get_perl_version(d)}/${@get_perl_hostarch(d)}/"
-export LD = "${CCLD}"
-
-cpan_build_do_configure () {
-        if [ "${@is_target(d)}" = "yes" ]; then
-                # build for target
-                . ${STAGING_LIBDIR}/perl5/config.sh
-        fi
-
-        perl Build.PL --installdirs vendor --destdir ${D} \
-                        ${EXTRA_CPAN_BUILD_FLAGS}
-
-        # Build.PLs can exit with success without generating a
-        # Build, e.g. in cases of missing configure time
-        # dependencies. This is considered a best practice by
-        # cpantesters.org. See:
-        #  * http://wiki.cpantesters.org/wiki/CPANAuthorNotes
-        #  * http://www.nntp.perl.org/group/perl.qa/2008/08/msg11236.html
-        [ -e Build ] || bbfatal "No Build was generated by Build.PL"
-}
-
-cpan_build_do_compile () {
-        perl Build --perl "${bindir}/perl" verbose=1
-}
-
-cpan_build_do_install () {
-        perl Build install --destdir ${D}
-}
-
-EXPORT_FUNCTIONS do_configure do_compile do_install
diff --git a/meta/classes-recipe/create-spdx-image-3.0.bbclass b/meta/classes-recipe/create-spdx-image-3.0.bbclass
deleted file mode 100644
index 636ab14eb0..0000000000
--- a/meta/classes-recipe/create-spdx-image-3.0.bbclass
+++ /dev/null
@@ -1,85 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: GPL-2.0-only
-#
-# SPDX image tasks
-
-SPDX_ROOTFS_PACKAGES = "${SPDXDIR}/rootfs-packages.json"
-SPDXIMAGEDEPLOYDIR = "${SPDXDIR}/image-deploy"
-SPDXROOTFSDEPLOY = "${SPDXDIR}/rootfs-deploy"
-
-python spdx_collect_rootfs_packages() {
-    import json
-    from pathlib import Path
-    from oe.rootfs import image_list_installed_packages
-
-    root_packages_file = Path(d.getVar("SPDX_ROOTFS_PACKAGES"))
-
-    packages = image_list_installed_packages(d)
-    if not packages:
-        packages = {}
-
-    root_packages_file.parent.mkdir(parents=True, exist_ok=True)
-    with root_packages_file.open("w") as f:
-        json.dump(packages, f)
-}
-ROOTFS_POSTUNINSTALL_COMMAND =+ "spdx_collect_rootfs_packages"
-
-python do_create_rootfs_spdx() {
-    import oe.spdx30_tasks
-    oe.spdx30_tasks.create_rootfs_spdx(d)
-}
-addtask do_create_rootfs_spdx after do_rootfs before do_image
-SSTATETASKS += "do_create_rootfs_spdx"
-do_create_rootfs_spdx[sstate-inputdirs] = "${SPDXROOTFSDEPLOY}"
-do_create_rootfs_spdx[sstate-outputdirs] = "${DEPLOY_DIR_SPDX}"
-do_create_rootfs_spdx[recrdeptask] += "do_create_spdx do_create_package_spdx"
-do_create_rootfs_spdx[cleandirs] += "${SPDXROOTFSDEPLOY}"
-do_create_rootfs_spdx[file-checksums] += "${SPDX3_DEP_FILES}"
-
-python do_create_rootfs_spdx_setscene() {
-    sstate_setscene(d)
-}
-addtask do_create_rootfs_spdx_setscene
-
-python do_create_image_spdx() {
-    import oe.spdx30_tasks
-    oe.spdx30_tasks.create_image_spdx(d)
-}
-addtask do_create_image_spdx after do_image_complete do_create_rootfs_spdx before do_build
-SSTATETASKS += "do_create_image_spdx"
-SSTATE_SKIP_CREATION:task-create-image-spdx = "1"
-do_create_image_spdx[sstate-inputdirs] = "${SPDXIMAGEWORK}"
-do_create_image_spdx[sstate-outputdirs] = "${DEPLOY_DIR_SPDX}"
-do_create_image_spdx[cleandirs] = "${SPDXIMAGEWORK}"
-do_create_image_spdx[dirs] = "${SPDXIMAGEWORK}"
-do_create_image_spdx[file-checksums] += "${SPDX3_DEP_FILES}"
-do_create_image_spdx[vardeps] += "\
-    SPDX_IMAGE_PURPOSE \
-    "
-
-python do_create_image_spdx_setscene() {
-    sstate_setscene(d)
-}
-addtask do_create_image_spdx_setscene
-
-
-python do_create_image_sbom_spdx() {
-    import oe.spdx30_tasks
-    oe.spdx30_tasks.create_image_sbom_spdx(d)
-}
-addtask do_create_image_sbom_spdx after do_create_rootfs_spdx do_create_image_spdx before do_build
-SSTATETASKS += "do_create_image_sbom_spdx"
-SSTATE_SKIP_CREATION:task-create-image-sbom = "1"
-do_create_image_sbom_spdx[sstate-inputdirs] = "${SPDXIMAGEDEPLOYDIR}"
-do_create_image_sbom_spdx[sstate-outputdirs] = "${DEPLOY_DIR_IMAGE}"
-do_create_image_sbom_spdx[stamp-extra-info] = "${MACHINE_ARCH}"
-do_create_image_sbom_spdx[cleandirs] = "${SPDXIMAGEDEPLOYDIR}"
-do_create_image_sbom_spdx[recrdeptask] += "do_create_spdx do_create_package_spdx"
-do_create_image_sbom_spdx[file-checksums] += "${SPDX3_DEP_FILES}"
-
-python do_create_image_sbom_spdx_setscene() {
-    sstate_setscene(d)
-}
-addtask do_create_image_sbom_spdx_setscene
diff --git a/meta/classes-recipe/create-spdx-sdk-3.0.bbclass b/meta/classes-recipe/create-spdx-sdk-3.0.bbclass
deleted file mode 100644
index e5f220cdfa..0000000000
--- a/meta/classes-recipe/create-spdx-sdk-3.0.bbclass
+++ /dev/null
@@ -1,74 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: GPL-2.0-only
-#
-# SPDX SDK tasks
-
-do_populate_sdk[recrdeptask] += "do_create_spdx do_create_package_spdx"
-do_populate_sdk[cleandirs] += "${SPDXSDKWORK}"
-do_populate_sdk[postfuncs] += "sdk_create_sbom"
-do_populate_sdk[file-checksums] += "${SPDX3_DEP_FILES}"
-POPULATE_SDK_POST_HOST_COMMAND:append:task-populate-sdk = " sdk_host_create_spdx"
-POPULATE_SDK_POST_TARGET_COMMAND:append:task-populate-sdk = " sdk_target_create_spdx"
-
-do_populate_sdk_ext[recrdeptask] += "do_create_spdx do_create_package_spdx"
-do_populate_sdk_ext[cleandirs] += "${SPDXSDKEXTWORK}"
-do_populate_sdk_ext[postfuncs] += "sdk_ext_create_sbom"
-do_populate_sdk_ext[file-checksums] += "${SPDX3_DEP_FILES}"
-POPULATE_SDK_POST_HOST_COMMAND:append:task-populate-sdk-ext = " sdk_ext_host_create_spdx"
-POPULATE_SDK_POST_TARGET_COMMAND:append:task-populate-sdk-ext = " sdk_ext_target_create_spdx"
-
-python sdk_host_create_spdx() {
-    from pathlib import Path
-    import oe.spdx30_tasks
-    spdx_work_dir = Path(d.getVar('SPDXSDKWORK'))
-
-    oe.spdx30_tasks.sdk_create_spdx(d, "host", spdx_work_dir, d.getVar("TOOLCHAIN_OUTPUTNAME"))
-}
-
-python sdk_target_create_spdx() {
-    from pathlib import Path
-    import oe.spdx30_tasks
-    spdx_work_dir = Path(d.getVar('SPDXSDKWORK'))
-
-    oe.spdx30_tasks.sdk_create_spdx(d, "target", spdx_work_dir, d.getVar("TOOLCHAIN_OUTPUTNAME"))
-}
-
-python sdk_ext_host_create_spdx() {
-    from pathlib import Path
-    import oe.spdx30_tasks
-    spdx_work_dir = Path(d.getVar('SPDXSDKEXTWORK'))
-
-    # TODO: This doesn't seem to work
-    oe.spdx30_tasks.sdk_create_spdx(d, "host", spdx_work_dir, d.getVar("TOOLCHAINEXT_OUTPUTNAME"))
-}
-
-python sdk_ext_target_create_spdx() {
-    from pathlib import Path
-    import oe.spdx30_tasks
-    spdx_work_dir = Path(d.getVar('SPDXSDKEXTWORK'))
-
-    # TODO: This doesn't seem to work
-    oe.spdx30_tasks.sdk_create_spdx(d, "target", spdx_work_dir, d.getVar("TOOLCHAINEXT_OUTPUTNAME"))
-}
-
-
-python sdk_create_sbom() {
-    from pathlib import Path
-    import oe.spdx30_tasks
-    sdk_deploydir = Path(d.getVar("SDKDEPLOYDIR"))
-    spdx_work_dir = Path(d.getVar('SPDXSDKWORK'))
-
-    oe.spdx30_tasks.create_sdk_sbom(d, sdk_deploydir, spdx_work_dir, d.getVar("TOOLCHAIN_OUTPUTNAME"))
-}
-
-python sdk_ext_create_sbom() {
-    from pathlib import Path
-    import oe.spdx30_tasks
-    sdk_deploydir = Path(d.getVar("SDKEXTDEPLOYDIR"))
-    spdx_work_dir = Path(d.getVar('SPDXSDKEXTWORK'))
-
-    oe.spdx30_tasks.create_sdk_sbom(d, sdk_deploydir, spdx_work_dir, d.getVar("TOOLCHAINEXT_OUTPUTNAME"))
-}
-
diff --git a/meta/classes-recipe/cross-canadian.bbclass b/meta/classes-recipe/cross-canadian.bbclass
deleted file mode 100644
index 059d9aa95f..0000000000
--- a/meta/classes-recipe/cross-canadian.bbclass
+++ /dev/null
@@ -1,200 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-# NOTE - When using this class the user is responsible for ensuring that
-# TRANSLATED_TARGET_ARCH is added into PN. This ensures that if the TARGET_ARCH
-# is changed, another nativesdk xxx-canadian-cross can be installed
-#
-
-
-# SDK packages are built either explicitly by the user,
-# or indirectly via dependency.  No need to be in 'world'.
-EXCLUDE_FROM_WORLD = "1"
-NATIVESDKLIBC ?= "libc-glibc"
-LIBCOVERRIDE = ":${NATIVESDKLIBC}"
-CLASSOVERRIDE = "class-cross-canadian"
-STAGING_BINDIR_TOOLCHAIN = "${STAGING_DIR_NATIVE}${bindir_native}/${SDK_ARCH}${SDK_VENDOR}-${SDK_OS}:${STAGING_DIR_NATIVE}${bindir_native}/${TARGET_ARCH}${TARGET_VENDOR}-${TARGET_OS}"
-
-#
-# Update BASE_PACKAGE_ARCH and PACKAGE_ARCHS
-#
-PACKAGE_ARCH = "${SDK_ARCH}-${SDKPKGSUFFIX}"
-BASECANADIANEXTRAOS ?= "linux-musl"
-CANADIANEXTRAOS = "${BASECANADIANEXTRAOS}"
-CANADIANEXTRAVENDOR = ""
-MODIFYTOS ??= "1"
-python () {
-    archs = d.getVar('PACKAGE_ARCHS').split()
-    sdkarchs = []
-    for arch in archs:
-        sdkarchs.append(arch + '-${SDKPKGSUFFIX}')
-    d.setVar('PACKAGE_ARCHS', " ".join(sdkarchs))
-
-    # Allow the following code segment to be disabled, e.g. meta-environment
-    if d.getVar("MODIFYTOS") != "1":
-        return
-
-    if d.getVar("TCLIBC") in [ 'baremetal', 'newlib', 'picolibc' ]:
-        return
-
-    tos = d.getVar("TARGET_OS")
-    tos_known = ["mingw32"]
-    extralibcs = [""]
-    if "musl" in d.getVar("BASECANADIANEXTRAOS"):
-        extralibcs.append("musl")
-    if "android" in tos:
-        extralibcs.append("android")
-    for variant in ["", "spe", "x32", "eabi", "n32", "_ilp32"]:
-        for libc in extralibcs:
-            entry = "linux"
-            if variant and libc:
-                entry = entry + "-" + libc + variant
-            elif variant:
-                entry = entry + "-gnu" + variant
-            elif libc:
-                entry = entry + "-" + libc
-            tos_known.append(entry)
-    if tos not in tos_known:
-        bb.fatal("Building cross-candian for an unknown TARGET_SYS (%s), please update cross-canadian.bbclass" % d.getVar("TARGET_SYS"))
-
-    for n in ["PROVIDES", "DEPENDS"]:
-        d.setVar(n, d.getVar(n))
-    d.setVar("STAGING_BINDIR_TOOLCHAIN", d.getVar("STAGING_BINDIR_TOOLCHAIN"))
-    for prefix in ["AR", "AS", "DLLTOOL", "CC", "CXX", "GCC", "LD", "LIPO", "NM", "OBJDUMP", "RANLIB", "STRIP", "WINDRES"]:
-        n = prefix + "_FOR_TARGET"
-        d.setVar(n, d.getVar(n))
-    # This is a bit ugly. We need to zero LIBC/ABI extension which will change TARGET_OS
-    # however we need the old value in some variables. We expand those here first.
-    tarch = d.getVar("TARGET_ARCH")
-    if tarch == "x86_64":
-        d.setVar("LIBCEXTENSION", "")
-        d.setVar("ABIEXTENSION", "")
-        d.appendVar("CANADIANEXTRAOS", " linux-gnux32")
-        for extraos in d.getVar("BASECANADIANEXTRAOS").split():
-            d.appendVar("CANADIANEXTRAOS", " " + extraos + "x32")
-    elif tarch == "powerpc":
-        # PowerPC can build "linux" and "linux-gnuspe"
-        d.setVar("LIBCEXTENSION", "")
-        d.setVar("ABIEXTENSION", "")
-        d.appendVar("CANADIANEXTRAOS", " linux-gnuspe")
-        for extraos in d.getVar("BASECANADIANEXTRAOS").split():
-            d.appendVar("CANADIANEXTRAOS", " " + extraos + "spe")
-    elif tarch == "mips64":
-        d.appendVar("CANADIANEXTRAOS", " linux-gnun32")
-        for extraos in d.getVar("BASECANADIANEXTRAOS").split():
-            d.appendVar("CANADIANEXTRAOS", " " + extraos + "n32")
-    if tarch == "arm" or tarch == "armeb":
-        d.appendVar("CANADIANEXTRAOS", " linux-gnueabi linux-musleabi")
-        d.setVar("TARGET_OS", "linux-gnueabi")
-    else:
-        d.setVar("TARGET_OS", "linux")
-
-    # Also need to handle multilib target vendors
-    vendors = d.getVar("CANADIANEXTRAVENDOR")
-    if not vendors:
-        vendors = all_multilib_tune_values(d, 'TARGET_VENDOR')
-    origvendor = d.getVar("TARGET_VENDOR_MULTILIB_ORIGINAL")
-    if origvendor:
-        d.setVar("TARGET_VENDOR", origvendor)
-        if origvendor not in vendors.split():
-            vendors = origvendor + " " + vendors
-    d.setVar("CANADIANEXTRAVENDOR", vendors)
-}
-MULTIMACH_TARGET_SYS = "${PACKAGE_ARCH}${HOST_VENDOR}-${HOST_OS}"
-
-INHIBIT_DEFAULT_DEPS = "1"
-
-STAGING_DIR_HOST = "${RECIPE_SYSROOT}"
-
-TOOLCHAIN_OPTIONS = " --sysroot=${RECIPE_SYSROOT}"
-
-PATH:append = ":${TMPDIR}/sysroots/${HOST_ARCH}/${bindir_cross}"
-PKGHIST_DIR = "${TMPDIR}/pkghistory/${HOST_ARCH}-${SDKPKGSUFFIX}${HOST_VENDOR}-${HOST_OS}/"
-
-HOST_ARCH = "${SDK_ARCH}"
-HOST_VENDOR = "${SDK_VENDOR}"
-HOST_OS = "${SDK_OS}"
-HOST_PREFIX = "${SDK_PREFIX}"
-HOST_CC_ARCH = "${SDK_CC_ARCH}"
-HOST_LD_ARCH = "${SDK_LD_ARCH}"
-HOST_AS_ARCH = "${SDK_AS_ARCH}"
-
-#assign DPKG_ARCH
-DPKG_ARCH = "${@debian_arch_map(d.getVar('SDK_ARCH'), '')}"
-
-CPPFLAGS = "${BUILDSDK_CPPFLAGS}"
-CFLAGS = "${BUILDSDK_CFLAGS}"
-CXXFLAGS = "${BUILDSDK_CFLAGS}"
-LDFLAGS = "${BUILDSDK_LDFLAGS} \
-           -Wl,-rpath-link,${STAGING_LIBDIR}/.. \
-           -Wl,-rpath,${libdir}/.. "
-
-#
-# We need chrpath >= 0.14 to ensure we can deal with 32 and 64 bit
-# binaries
-#
-DEPENDS:append = " chrpath-replacement-native"
-EXTRANATIVEPATH += "chrpath-native"
-
-# Path mangling needed by the cross packaging
-# Note that we use := here to ensure that libdir and includedir are
-# target paths.
-target_base_prefix := "${base_prefix}"
-target_prefix := "${prefix}"
-target_exec_prefix := "${exec_prefix}"
-target_base_libdir = "${target_base_prefix}/${baselib}"
-target_libdir = "${target_exec_prefix}/${baselib}"
-target_includedir := "${includedir}"
-
-# Change to place files in SDKPATH
-base_prefix = "${SDKPATHNATIVE}"
-prefix = "${SDKPATHNATIVE}${prefix_nativesdk}"
-exec_prefix = "${SDKPATHNATIVE}${prefix_nativesdk}"
-bindir = "${exec_prefix}/bin/${TARGET_ARCH}${TARGET_VENDOR}-${TARGET_OS}"
-sbindir = "${bindir}"
-base_bindir = "${bindir}"
-base_sbindir = "${bindir}"
-libdir = "${exec_prefix}/lib/${TARGET_ARCH}${TARGET_VENDOR}-${TARGET_OS}"
-libexecdir = "${exec_prefix}/libexec/${TARGET_ARCH}${TARGET_VENDOR}-${TARGET_OS}"
-
-FILES:${PN} = "${prefix}"
-
-export PKG_CONFIG_DIR = "${STAGING_DIR_HOST}${exec_prefix}/lib/pkgconfig"
-export PKG_CONFIG_SYSROOT_DIR = "${STAGING_DIR_HOST}"
-
-do_populate_sysroot[stamp-extra-info] = ""
-do_packagedata[stamp-extra-info] = ""
-
-USE_NLS = "${SDKUSE_NLS}"
-
-# We have to us TARGET_ARCH but we care about the absolute value
-# and not any particular tune that is enabled.
-TARGET_ARCH[vardepsexclude] = "TUNE_ARCH"
-
-PKGDATA_DIR = "${PKGDATA_DIR_SDK}"
-# If MLPREFIX is set by multilib code, shlibs
-# points to the wrong place so force it
-SHLIBSDIRS = "${PKGDATA_DIR}/nativesdk-shlibs2"
-SHLIBSWORKDIR = "${PKGDATA_DIR}/nativesdk-shlibs2"
-
-cross_canadian_bindirlinks () {
-        for i in linux ${CANADIANEXTRAOS}
-        do
-                for v in ${CANADIANEXTRAVENDOR}
-                do
-                        d=${D}${bindir}/../${TARGET_ARCH}$v-$i
-                        if [ -d $d ];
-                        then
-                            continue
-                        fi
-                        install -d $d
-                        for j in `ls ${D}${bindir}`
-                        do
-                                p=${TARGET_ARCH}$v-$i-`echo $j | sed -e s,${TARGET_PREFIX},,`
-                                ln -s ../${TARGET_SYS}/$j $d/$p
-                        done
-                done
-       done
-}
diff --git a/meta/classes-recipe/cross.bbclass b/meta/classes-recipe/cross.bbclass
deleted file mode 100644
index 9abf166e50..0000000000
--- a/meta/classes-recipe/cross.bbclass
+++ /dev/null
@@ -1,103 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-inherit relocatable
-
-# Cross packages are built indirectly via dependency,
-# no need for them to be a direct target of 'world'
-EXCLUDE_FROM_WORLD = "1"
-
-CLASSOVERRIDE = "class-cross"
-PACKAGES = ""
-PACKAGES_DYNAMIC = ""
-PACKAGES_DYNAMIC:class-native = ""
-
-HOST_ARCH = "${BUILD_ARCH}"
-HOST_VENDOR = "${BUILD_VENDOR}"
-HOST_OS = "${BUILD_OS}"
-HOST_PREFIX = "${BUILD_PREFIX}"
-HOST_CC_ARCH = "${BUILD_CC_ARCH}"
-HOST_LD_ARCH = "${BUILD_LD_ARCH}"
-HOST_AS_ARCH = "${BUILD_AS_ARCH}"
-
-# No strip sysroot when DEBUG_BUILD is enabled
-INHIBIT_SYSROOT_STRIP ?= "${@oe.utils.vartrue('DEBUG_BUILD', '1', '', d)}"
-
-export lt_cv_sys_lib_dlsearch_path_spec = "${libdir} ${base_libdir} /lib /lib64 /usr/lib /usr/lib64"
-
-STAGING_DIR_HOST = "${RECIPE_SYSROOT_NATIVE}"
-
-PACKAGE_ARCH = "${BUILD_ARCH}"
-
-MULTIMACH_TARGET_SYS = "${BUILD_ARCH}${BUILD_VENDOR}-${BUILD_OS}"
-
-export PKG_CONFIG_DIR = "${exec_prefix}/lib/pkgconfig"
-export PKG_CONFIG_SYSROOT_DIR = ""
-
-TARGET_CPPFLAGS = ""
-TARGET_CFLAGS = ""
-TARGET_CXXFLAGS = ""
-TARGET_LDFLAGS = ""
-
-CPPFLAGS = "${BUILD_CPPFLAGS}"
-CFLAGS = "${BUILD_CFLAGS}"
-CXXFLAGS = "${BUILD_CFLAGS}"
-LDFLAGS = "${BUILD_LDFLAGS}"
-
-TOOLCHAIN_OPTIONS = ""
-
-# This class encodes staging paths into its scripts data so can only be
-# reused if we manipulate the paths.
-SSTATE_SCAN_CMD ?= "${SSTATE_SCAN_CMD_NATIVE}"
-
-# Path mangling needed by the cross packaging
-# Note that we use := here to ensure that libdir and includedir are
-# target paths.
-target_base_prefix := "${root_prefix}"
-target_prefix := "${prefix}"
-target_exec_prefix := "${exec_prefix}"
-target_base_libdir = "${target_base_prefix}/${baselib}"
-target_libdir = "${target_exec_prefix}/${baselib}"
-target_includedir := "${includedir}"
-
-# Overrides for paths
-CROSS_TARGET_SYS_DIR = "${TARGET_SYS}"
-prefix = "${STAGING_DIR_NATIVE}${prefix_native}"
-base_prefix = "${STAGING_DIR_NATIVE}"
-exec_prefix = "${STAGING_DIR_NATIVE}${prefix_native}"
-bindir = "${exec_prefix}/bin/${CROSS_TARGET_SYS_DIR}"
-sbindir = "${bindir}"
-base_bindir = "${bindir}"
-base_sbindir = "${bindir}"
-libdir = "${exec_prefix}/lib/${CROSS_TARGET_SYS_DIR}"
-libexecdir = "${exec_prefix}/libexec/${CROSS_TARGET_SYS_DIR}"
-
-do_populate_sysroot[sstate-inputdirs] = "${SYSROOT_DESTDIR}/${STAGING_DIR_NATIVE}/"
-do_packagedata[stamp-extra-info] = ""
-
-USE_NLS = "no"
-
-CC = "${BUILD_CC}"
-CXX = "${BUILD_CXX}"
-FC = "${BUILD_FC}"
-CPP = "${BUILD_CPP}"
-LD = "${BUILD_LD}"
-CCLD = "${BUILD_CCLD}"
-AR = "${BUILD_AR}"
-AS = "${BUILD_AS}"
-RANLIB = "${BUILD_RANLIB}"
-STRIP = "${BUILD_STRIP}"
-NM = "${BUILD_NM}"
-
-inherit nopackages
-
-python do_addto_recipe_sysroot () {
-    bb.build.exec_func("extend_recipe_sysroot", d)
-}
-addtask addto_recipe_sysroot after do_populate_sysroot
-do_addto_recipe_sysroot[deptask] = "do_populate_sysroot"
-
-PATH:prepend = "${COREBASE}/scripts/cross-intercept:"
diff --git a/meta/classes-recipe/crosssdk.bbclass b/meta/classes-recipe/crosssdk.bbclass
deleted file mode 100644
index 3541c2c393..0000000000
--- a/meta/classes-recipe/crosssdk.bbclass
+++ /dev/null
@@ -1,58 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-BB_DEFER_BBCLASSES:remove = "cross"
-inherit cross
-
-CLASSOVERRIDE = "class-crosssdk"
-NATIVESDKLIBC ?= "libc-glibc"
-LIBCOVERRIDE = ":${NATIVESDKLIBC}"
-MACHINEOVERRIDES = ""
-PACKAGE_ARCH = "${SDK_ARCH}"
-
-python () {
-    # set TUNE_PKGARCH to SDK_ARCH
-    d.setVar('TUNE_PKGARCH', d.getVar('SDK_ARCH'))
-    # Set features here to prevent appends and distro features backfill
-    # from modifying nativesdk distro features
-    features = set(d.getVar("DISTRO_FEATURES_NATIVESDK").split())
-    filtered = set(bb.utils.filter("DISTRO_FEATURES", d.getVar("DISTRO_FEATURES_FILTER_NATIVESDK"), d).split())
-    d.setVar("DISTRO_FEATURES", " ".join(sorted(features | filtered)))
-}
-
-STAGING_BINDIR_TOOLCHAIN = "${STAGING_DIR_NATIVE}${bindir_native}/${TARGET_ARCH}${TARGET_VENDOR}-${TARGET_OS}"
-
-# This class encodes staging paths into its scripts data so can only be
-# reused if we manipulate the paths.
-SSTATE_SCAN_CMD ?= "${SSTATE_SCAN_CMD_NATIVE}"
-
-TARGET_ARCH = "${SDK_ARCH}"
-TARGET_VENDOR = "${SDK_VENDOR}"
-TARGET_OS = "${SDK_OS}"
-TARGET_PREFIX = "${SDK_PREFIX}"
-TARGET_CC_ARCH = "${SDK_CC_ARCH}"
-TARGET_LD_ARCH = "${SDK_LD_ARCH}"
-TARGET_AS_ARCH = "${SDK_AS_ARCH}"
-TARGET_CPPFLAGS = ""
-TARGET_CFLAGS = ""
-TARGET_CXXFLAGS = ""
-TARGET_LDFLAGS = ""
-TARGET_FPU = ""
-
-
-target_libdir = "${SDKPATHNATIVE}${libdir_nativesdk}"
-target_includedir = "${SDKPATHNATIVE}${includedir_nativesdk}"
-target_base_libdir = "${SDKPATHNATIVE}${base_libdir_nativesdk}"
-target_prefix = "${SDKPATHNATIVE}${prefix_nativesdk}"
-target_exec_prefix = "${SDKPATHNATIVE}${prefix_nativesdk}"
-baselib = "lib"
-
-do_packagedata[stamp-extra-info] = ""
-
-# Need to force this to ensure consitency across architectures
-EXTRA_OECONF_GCC_FLOAT = ""
-
-USE_NLS = "no"
diff --git a/meta/classes-recipe/cython.bbclass b/meta/classes-recipe/cython.bbclass
deleted file mode 100644
index 9ae7a29134..0000000000
--- a/meta/classes-recipe/cython.bbclass
+++ /dev/null
@@ -1,8 +0,0 @@
-DEPENDS:append = " python3-cython-native"
-
-do_compile[postfuncs] = "strip_cython_metadata"
-strip_cython_metadata() {
-    # Remove the Cython Metadata headers that we don't need after the build, and
-    # may contain build paths.
-    find ${S} \( -name "*.c" -o -name "*.cpp" \) -print0 | xargs --no-run-if-empty --null sed -i -e "/BEGIN: Cython Metadata/,/END: Cython Metadata/d"
-}
diff --git a/meta/classes-recipe/deploy.bbclass b/meta/classes-recipe/deploy.bbclass
deleted file mode 100644
index f56fe98d6d..0000000000
--- a/meta/classes-recipe/deploy.bbclass
+++ /dev/null
@@ -1,18 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-DEPLOYDIR = "${WORKDIR}/deploy-${PN}"
-SSTATETASKS += "do_deploy"
-do_deploy[sstate-inputdirs] = "${DEPLOYDIR}"
-do_deploy[sstate-outputdirs] = "${DEPLOY_DIR_IMAGE}"
-
-python do_deploy_setscene () {
-    sstate_setscene(d)
-}
-addtask do_deploy_setscene
-do_deploy[dirs] = "${B}"
-do_deploy[cleandirs] = "${DEPLOYDIR}"
-do_deploy[stamp-extra-info] = "${MACHINE_ARCH}"
diff --git a/meta/classes-recipe/devicetree.bbclass b/meta/classes-recipe/devicetree.bbclass
deleted file mode 100644
index ce9d008aac..0000000000
--- a/meta/classes-recipe/devicetree.bbclass
+++ /dev/null
@@ -1,169 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-# This bbclass implements device tree compilation for user provided device tree
-# sources. The compilation of the device tree sources is the same as the kernel
-# device tree compilation process, this includes being able to include sources
-# from the kernel such as soc dtsi files or header files such as gpio.h. In
-# addition to device trees this bbclass also handles compilation of device tree
-# overlays.
-#
-# The output of this class behaves similar to how kernel-devicetree.bbclass
-# operates in that the output files are installed into /boot/devicetree.
-# However this class on purpose separates the deployed device trees into the
-# 'devicetree' subdirectory. This prevents clashes with the kernel-devicetree
-# output. Additionally the device trees are populated into the sysroot for
-# access via the sysroot from within other recipes.
-
-SECTION ?= "bsp"
-
-# The default inclusion of kernel device tree includes and headers means that
-# device trees built with them are at least GPL-2.0-only (and in some cases dual
-# licensed). Default to GPL-2.0-only if the recipe does not specify a license.
-LICENSE ?= "GPL-2.0-only"
-LIC_FILES_CHKSUM ?= "file://${COMMON_LICENSE_DIR}/GPL-2.0-only;md5=801f80980d171dd6425610833a22dbe6"
-
-INHIBIT_DEFAULT_DEPS = "1"
-DEPENDS += "dtc-native"
-
-inherit deploy kernel-arch
-
-COMPATIBLE_MACHINE ?= "^$"
-
-PROVIDES = "virtual/dtb"
-
-PACKAGE_ARCH = "${MACHINE_ARCH}"
-
-SYSROOT_DIRS += "/boot/devicetree"
-FILES:${PN} = "/boot/devicetree/*.dtb /boot/devicetree/*.dtbo"
-
-S = "${UNPACKDIR}"
-B = "${WORKDIR}/build"
-
-# Default kernel includes, these represent what are normally used for in-kernel
-# sources.
-KERNEL_INCLUDE ??= " \
-        ${STAGING_KERNEL_DIR}/arch/${ARCH}/boot/dts \
-        ${STAGING_KERNEL_DIR}/arch/${ARCH}/boot/dts/* \
-        ${STAGING_KERNEL_DIR}/scripts/dtc/include-prefixes \
-        "
-
-DT_INCLUDE[doc] = "Search paths to be made available to both the device tree compiler and preprocessor for inclusion."
-DT_INCLUDE ?= "${DT_FILES_PATH} ${KERNEL_INCLUDE}"
-DT_FILES_PATH[doc] = "Path to the directory containing dts files to build. Defaults to source directory."
-DT_FILES_PATH ?= "${S}"
-DT_FILES[doc] = "Space-separated list of dts or dtb files (relative to DT_FILES_PATH) to build. If empty, all dts files are built."
-DT_FILES ?= ""
-
-DT_PADDING_SIZE[doc] = "Size of padding on the device tree blob, used as extra space typically for additional properties during boot."
-DT_PADDING_SIZE ??= "0x3000"
-DT_RESERVED_MAP[doc] = "Number of reserved map entires."
-DT_RESERVED_MAP ??= "8"
-DT_BOOT_CPU[doc] = "The boot cpu, defaults to 0"
-DT_BOOT_CPU ??= "0"
-
-DTC_FLAGS ?= "-R ${DT_RESERVED_MAP} -b ${DT_BOOT_CPU}"
-DTC_PPFLAGS ?= "-nostdinc -undef -D__DTS__ -x assembler-with-cpp"
-DTC_BFLAGS ?= "-p ${DT_PADDING_SIZE} -@"
-DTC_OFLAGS ?= "-p 0 -@ -H epapr"
-
-python () {
-    if d.getVar("KERNEL_INCLUDE"):
-        # auto add dependency on kernel tree, but only if kernel include paths
-        # are specified.
-        d.appendVarFlag("do_compile", "depends", " virtual/kernel:do_configure")
-}
-
-def expand_includes(varname, d):
-    import glob
-    includes = set()
-    # expand all includes with glob
-    for i in (d.getVar(varname) or "").split():
-        for g in glob.glob(i):
-            if os.path.isdir(g): # only add directories to include path
-                includes.add(g)
-    return includes
-
-def devicetree_source_is_overlay(path):
-    # determine if a dts file is an overlay by checking if it uses "/plugin/;"
-    with open(path, "r") as f:
-        for i in f:
-            if i.startswith("/plugin/;"):
-                return True
-    return False
-
-def devicetree_compile(dtspath, includes, d):
-    import subprocess
-    dts = os.path.basename(dtspath)
-    dtname = os.path.splitext(dts)[0]
-    bb.note("Processing {0} [{1}]".format(dtname, dts))
-
-    # preprocess
-    ppargs = d.getVar("BUILD_CPP").split()
-    ppargs += (d.getVar("DTC_PPFLAGS") or "").split()
-    for i in includes:
-        ppargs.append("-I{0}".format(i))
-    ppargs += ["-o", "{0}.pp".format(dts), dtspath]
-    bb.note("Running {0}".format(" ".join(ppargs)))
-    try:
-        subprocess.run(ppargs, check=True, capture_output=True)
-    except subprocess.CalledProcessError as e:
-        bb.fatal(f"Command '{' '.join(ppargs)}' failed with return code {e.returncode}\nstdout: {e.stdout.decode()}\nstderr: {e.stderr.decode()}\ndtspath: {os.path.abspath(dtspath)}")
-
-
-    # determine if the file is an overlay or not (using the preprocessed file)
-    isoverlay = devicetree_source_is_overlay("{0}.pp".format(dts))
-
-    # compile
-    dtcargs = ["dtc"] + (d.getVar("DTC_FLAGS") or "").split()
-    if isoverlay:
-        dtcargs += (d.getVar("DTC_OFLAGS") or "").split()
-    else:
-        dtcargs += (d.getVar("DTC_BFLAGS") or "").split()
-    for i in includes:
-        dtcargs += ["-i", i]
-    dtcargs += ["-o", "{0}.{1}".format(dtname, "dtbo" if isoverlay else "dtb")]
-    dtcargs += ["-I", "dts", "-O", "dtb", "{0}.pp".format(dts)]
-    bb.note("Running {0}".format(" ".join(dtcargs)))
-    try:
-        subprocess.run(dtcargs, check=True, capture_output=True)
-    except subprocess.CalledProcessError as e:
-        bb.fatal(f"Command '{' '.join(dtcargs)}' failed with return code {e.returncode}\nstdout: {e.stdout.decode()}\nstderr: {e.stderr.decode()}\ndtname: {dtname}")
-
-
-python devicetree_do_compile() {
-    import re
-    includes = expand_includes("DT_INCLUDE", d)
-    dtfiles = d.getVar("DT_FILES").split()
-    dtfiles = [ re.sub(r"\.dtbo?$", ".dts", dtfile) for dtfile in dtfiles ]
-    listpath = d.getVar("DT_FILES_PATH")
-    for dts in dtfiles or os.listdir(listpath):
-        dtspath = os.path.join(listpath, dts)
-        try:
-            if not(os.path.isfile(dtspath)) or not(dts.endswith(".dts") or devicetree_source_is_overlay(dtspath)):
-                continue # skip non-.dts files and non-overlay files
-        except:
-            continue # skip if can't determine if overlay
-        devicetree_compile(dtspath, includes, d)
-}
-
-devicetree_do_install() {
-    for dtb_file in *.dtb *.dtbo; do
-        [ -e "$dtb_file" ] || continue
-        install -Dm 0644 "${B}/$dtb_file" "${D}/boot/devicetree/$dtb_file"
-    done
-}
-
-devicetree_do_deploy() {
-    for dtb_file in *.dtb *.dtbo; do
-        [ -e "$dtb_file" ] || continue
-        install -Dm 0644 "${B}/$dtb_file" "${DEPLOYDIR}/devicetree/$dtb_file"
-    done
-}
-addtask deploy before do_build after do_install
-
-EXPORT_FUNCTIONS do_compile do_install do_deploy
-
diff --git a/meta/classes-recipe/devupstream.bbclass b/meta/classes-recipe/devupstream.bbclass
deleted file mode 100644
index 60026a527f..0000000000
--- a/meta/classes-recipe/devupstream.bbclass
+++ /dev/null
@@ -1,55 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-# Class for use in BBCLASSEXTEND to make it easier to have a single recipe that
-# can build both stable tarballs and snapshots from upstream source
-# repositories.
-#
-# Usage:
-# BBCLASSEXTEND = "devupstream:target"
-# SRC_URI:class-devupstream = "git://git.example.com/example;branch=master"
-# SRCREV:class-devupstream = "abcdef"
-#
-# There are a few caveats that remain to be solved:
-# - You can't build native or nativesdk recipes using for example
-#   devupstream:native, you can only build target recipes.
-# - If the fetcher requires native tools (such as subversion-native) then
-#   bitbake won't be able to add them automatically.
-
-python devupstream_virtclass_handler () {
-    # Do nothing if this is inherited, as it's for BBCLASSEXTEND
-    if "devupstream" not in (d.getVar('BBCLASSEXTEND') or ""):
-        bb.error("Don't inherit devupstream, use BBCLASSEXTEND")
-        return
-
-    variant = d.getVar("BBEXTENDVARIANT")
-    if variant not in ("target", "native"):
-        bb.error("Unsupported variant %s. Pass the variant when using devupstream, for example devupstream:target" % variant)
-        return
-
-    # Develpment releases are never preferred by default
-    d.setVar("DEFAULT_PREFERENCE", "-1")
-
-    src_uri = d.getVar("SRC_URI:class-devupstream") or d.getVar("SRC_URI")
-    uri = bb.fetch2.URI(src_uri.split()[0])
-
-    # Modify the PV if the recipe hasn't already overridden it
-    pv = d.getVar("PV")
-    proto_marker = "+" + uri.scheme
-    if proto_marker not in pv and not d.getVar("PV:class-devupstream"):
-        d.setVar("PV", pv + proto_marker)
-
-    if variant == "native":
-        pn = d.getVar("PN")
-        d.setVar("PN", "%s-native" % (pn))
-        fn = d.getVar("FILE")
-        bb.parse.BBHandler.inherit("native", fn, 0, d)
-
-    d.appendVar("CLASSOVERRIDE", ":class-devupstream")
-}
-
-addhandler devupstream_virtclass_handler
-devupstream_virtclass_handler[eventmask] = "bb.event.RecipePreFinalise"
diff --git a/meta/classes-recipe/distro_features_check.bbclass b/meta/classes-recipe/distro_features_check.bbclass
deleted file mode 100644
index 1f2674fd6e..0000000000
--- a/meta/classes-recipe/distro_features_check.bbclass
+++ /dev/null
@@ -1,13 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-# Temporarily provide fallback to the old name of the class
-
-python __anonymous() {
-    bb.warn("distro_features_check.bbclass is deprecated, please use features_check.bbclass instead")
-}
-
-inherit features_check
diff --git a/meta/classes-recipe/dos2unix.bbclass b/meta/classes-recipe/dos2unix.bbclass
deleted file mode 100644
index 18e89b1cf2..0000000000
--- a/meta/classes-recipe/dos2unix.bbclass
+++ /dev/null
@@ -1,20 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-# Class for use to convert all CRLF line terminators to LF
-# provided that some projects are being developed/maintained
-# on Windows so they have different line terminators(CRLF) vs
-# on Linux(LF), which can cause annoying patching errors during
-# git push/checkout processes.
-
-do_convert_crlf_to_lf[depends] += "dos2unix-native:do_populate_sysroot"
-
-# Convert CRLF line terminators to LF
-do_convert_crlf_to_lf () {
-        find ${S} -type f -exec dos2unix {} \;
-}
-
-addtask convert_crlf_to_lf after do_unpack before do_patch
diff --git a/meta/classes-recipe/features_check.bbclass b/meta/classes-recipe/features_check.bbclass
deleted file mode 100644
index 1e0eaa4eed..0000000000
--- a/meta/classes-recipe/features_check.bbclass
+++ /dev/null
@@ -1,57 +0,0 @@
-# Allow checking of required and conflicting features
-#
-# xxx = [DISTRO,MACHINE,COMBINED,IMAGE]
-#
-# ANY_OF_xxx_FEATURES:        ensure at least one item on this list is included
-#                             in xxx_FEATURES.
-# REQUIRED_xxx_FEATURES:      ensure every item on this list is included
-#                             in xxx_FEATURES.
-# CONFLICT_xxx_FEATURES:      ensure no item in this list is included in
-#                             xxx_FEATURES.
-#
-# Copyright 2019 (C) Texas Instruments Inc.
-# Copyright 2013 (C) O.S. Systems Software LTDA.
-#
-# SPDX-License-Identifier: MIT
-
-
-python () {
-    if bb.utils.to_boolean(d.getVar('PARSE_ALL_RECIPES', False)):
-        return
-
-    unused = True
-
-    for kind in ['DISTRO', 'MACHINE', 'COMBINED', 'IMAGE', 'TUNE']:
-        if d.getVar('ANY_OF_' + kind + '_FEATURES') is None and not d.hasOverrides('ANY_OF_' + kind + '_FEATURES') and \
-           d.getVar('REQUIRED_' + kind + '_FEATURES') is None and not d.hasOverrides('REQUIRED_' + kind + '_FEATURES') and \
-           d.getVar('CONFLICT_' + kind + '_FEATURES') is None and not d.hasOverrides('CONFLICT_' + kind + '_FEATURES'):
-            continue
-
-        unused = False
-
-        # Assume at least one var is set.
-        features = set((d.getVar(kind + '_FEATURES') or '').split())
-
-        any_of_features = set((d.getVar('ANY_OF_' + kind + '_FEATURES') or '').split())
-        if any_of_features:
-            if set.isdisjoint(any_of_features, features):
-                raise bb.parse.SkipRecipe("one of '%s' needs to be in %s_FEATURES"
-                    % (' '.join(any_of_features), kind))
-
-        required_features = set((d.getVar('REQUIRED_' + kind + '_FEATURES') or '').split())
-        if required_features:
-            missing = set.difference(required_features, features)
-            if missing:
-                raise bb.parse.SkipRecipe("missing required %s feature%s '%s' (not in %s_FEATURES)"
-                    % (kind.lower(), 's' if len(missing) > 1 else '', ' '.join(missing), kind))
-
-        conflict_features = set((d.getVar('CONFLICT_' + kind + '_FEATURES') or '').split())
-        if conflict_features:
-            conflicts = set.intersection(conflict_features, features)
-            if conflicts:
-                raise bb.parse.SkipRecipe("conflicting %s feature%s '%s' (in %s_FEATURES)"
-                    % (kind.lower(), 's' if len(conflicts) > 1 else '', ' '.join(conflicts), kind))
-
-    if unused:
-        bb.warn("Recipe inherits features_check but doesn't use it")
-}
diff --git a/meta/classes-recipe/fontcache.bbclass b/meta/classes-recipe/fontcache.bbclass
deleted file mode 100644
index deadcd2fbb..0000000000
--- a/meta/classes-recipe/fontcache.bbclass
+++ /dev/null
@@ -1,63 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-#
-# This class will generate the proper postinst/postrm scriptlets for font
-# packages.
-#
-
-PACKAGE_WRITE_DEPS += "qemuwrapper-cross"
-
-FONT_PACKAGES ??= "${PN}"
-FONT_PACKAGES:class-native = ""
-FONT_EXTRA_RDEPENDS ?= "${MLPREFIX}fontconfig-utils"
-FONTCONFIG_CACHE_DIR ?= "${localstatedir}/cache/fontconfig"
-FONTCONFIG_CACHE_PARAMS ?= "-v"
-# You can change this to e.g. FC_DEBUG=16 to debug fc-cache issues,
-# something has to be set, because qemuwrapper is using this variable after -E
-# multiple variables aren't allowed because for qemu they are separated
-# by comma and in -n "$D" case they should be separated by space
-FONTCONFIG_CACHE_ENV ?= "FC_DEBUG=1"
-fontcache_common() {
-if [ -n "$D" ] ; then
-        $INTERCEPT_DIR/postinst_intercept update_font_cache ${PKG} mlprefix=${MLPREFIX} binprefix=${MLPREFIX} \
-                'bindir="${bindir}"' \
-                'libdir="${libdir}"' \
-                'libexecdir="${libexecdir}"' \
-                'base_libdir="${base_libdir}"' \
-                'fontconfigcachedir="${FONTCONFIG_CACHE_DIR}"' \
-                'fontconfigcacheparams="${FONTCONFIG_CACHE_PARAMS}"' \
-                'fontconfigcacheenv="${FONTCONFIG_CACHE_ENV}"'
-else
-        ${FONTCONFIG_CACHE_ENV} fc-cache ${FONTCONFIG_CACHE_PARAMS}
-fi
-}
-
-python () {
-    font_pkgs = d.getVar('FONT_PACKAGES').split()
-    deps = d.getVar("FONT_EXTRA_RDEPENDS")
-
-    for pkg in font_pkgs:
-        if deps: d.appendVar('RDEPENDS:' + pkg, ' '+deps)
-}
-
-python add_fontcache_postinsts() {
-    for pkg in d.getVar('FONT_PACKAGES').split():
-        bb.note("adding fonts postinst and postrm scripts to %s" % pkg)
-        postinst = d.getVar('pkg_postinst:%s' % pkg) or d.getVar('pkg_postinst')
-        if not postinst:
-            postinst = '#!/bin/sh\n'
-        postinst += d.getVar('fontcache_common')
-        d.setVar('pkg_postinst:%s' % pkg, postinst)
-
-        postrm = d.getVar('pkg_postrm:%s' % pkg) or d.getVar('pkg_postrm')
-        if not postrm:
-            postrm = '#!/bin/sh\n'
-        postrm += d.getVar('fontcache_common')
-        d.setVar('pkg_postrm:%s' % pkg, postrm)
-}
-
-PACKAGEFUNCS =+ "add_fontcache_postinsts"
diff --git a/meta/classes-recipe/fs-uuid.bbclass b/meta/classes-recipe/fs-uuid.bbclass
deleted file mode 100644
index e215f06c80..0000000000
--- a/meta/classes-recipe/fs-uuid.bbclass
+++ /dev/null
@@ -1,30 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-# Extract UUID from ${ROOTFS}, which must have been built
-# by the time that this function gets called. Only works
-# on ext file systems and depends on tune2fs.
-def get_rootfs_uuid(d):
-    import subprocess
-    rootfs = d.getVar('ROOTFS')
-    output = subprocess.check_output(['tune2fs', '-l', rootfs], text=True)
-    for line in output.split('\n'):
-        if line.startswith('Filesystem UUID:'):
-            uuid = line.split()[-1]
-            bb.note('UUID of %s: %s' % (rootfs, uuid))
-            return uuid
-    bb.fatal('Could not determine filesystem UUID of %s' % rootfs)
-
-# Replace the special <<uuid-of-rootfs>> inside a string (like the
-# root= APPEND string in a syslinux.cfg or systemd-boot entry) with the
-# actual UUID of the rootfs. Does nothing if the special string
-# is not used.
-def replace_rootfs_uuid(d, string):
-    UUID_PLACEHOLDER = '<<uuid-of-rootfs>>'
-    if UUID_PLACEHOLDER in string:
-        uuid = get_rootfs_uuid(d)
-        string = string.replace(UUID_PLACEHOLDER, uuid)
-    return string
diff --git a/meta/classes-recipe/gconf.bbclass b/meta/classes-recipe/gconf.bbclass
deleted file mode 100644
index b81851bc78..0000000000
--- a/meta/classes-recipe/gconf.bbclass
+++ /dev/null
@@ -1,77 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-DEPENDS += "gconf"
-PACKAGE_WRITE_DEPS += "gconf-native"
-
-# These are for when gconftool is used natively and the prefix isn't necessarily
-# the sysroot.  TODO: replicate the postinst logic for -native packages going
-# into sysroot as they won't be running their own install-time schema
-# registration (disabled below) nor the postinst script (as they don't happen).
-export GCONF_SCHEMA_INSTALL_SOURCE = "xml:merged:${STAGING_DIR_NATIVE}${sysconfdir}/gconf/gconf.xml.defaults"
-export GCONF_BACKEND_DIR = "${STAGING_LIBDIR_NATIVE}/GConf/2"
-
-# Disable install-time schema registration as we're a packaging system so this
-# happens in the postinst script, not at install time.  Set both the configure
-# script option and the traditional envionment variable just to make sure.
-EXTRA_OECONF += "--disable-schemas-install"
-export GCONF_DISABLE_MAKEFILE_SCHEMA_INSTALL = "1"
-
-gconf_postinst() {
-if [ "x$D" != "x" ]; then
-        export GCONF_CONFIG_SOURCE="xml::$D${sysconfdir}/gconf/gconf.xml.defaults"
-else
-        export GCONF_CONFIG_SOURCE=`gconftool-2 --get-default-source`
-fi
-
-SCHEMA_LOCATION=$D/etc/gconf/schemas
-for SCHEMA in ${SCHEMA_FILES}; do
-        if [ -e $SCHEMA_LOCATION/$SCHEMA ]; then
-                HOME=$D/root gconftool-2 \
-                        --makefile-install-rule $SCHEMA_LOCATION/$SCHEMA > /dev/null
-        fi
-done
-}
-
-gconf_prerm() {
-SCHEMA_LOCATION=/etc/gconf/schemas
-for SCHEMA in ${SCHEMA_FILES}; do
-        if [ -e $SCHEMA_LOCATION/$SCHEMA ]; then
-                HOME=/root GCONF_CONFIG_SOURCE=`gconftool-2 --get-default-source` \
-                        gconftool-2 \
-                        --makefile-uninstall-rule $SCHEMA_LOCATION/$SCHEMA > /dev/null
-        fi
-done
-}
-
-python populate_packages:append () {
-    import re
-    packages = d.getVar('PACKAGES').split()
-    pkgdest =  d.getVar('PKGDEST')
-    
-    for pkg in packages:
-        schema_dir = '%s/%s/etc/gconf/schemas' % (pkgdest, pkg)
-        schemas = []
-        schema_re = re.compile(r".*\.schemas$")
-        if os.path.exists(schema_dir):
-            for f in os.listdir(schema_dir):
-                if schema_re.match(f):
-                    schemas.append(f)
-        if schemas != []:
-            bb.note("adding gconf postinst and prerm scripts to %s" % pkg)
-            d.setVar('SCHEMA_FILES', " ".join(schemas))
-            postinst = d.getVar('pkg_postinst:%s' % pkg)
-            if not postinst:
-                postinst = '#!/bin/sh\n'
-            postinst += d.getVar('gconf_postinst')
-            d.setVar('pkg_postinst:%s' % pkg, postinst)
-            prerm = d.getVar('pkg_prerm:%s' % pkg)
-            if not prerm:
-                prerm = '#!/bin/sh\n'
-            prerm += d.getVar('gconf_prerm')
-            d.setVar('pkg_prerm:%s' % pkg, prerm)
-            d.appendVar("RDEPENDS:%s" % pkg, ' ' + d.getVar('MLPREFIX', False) + 'gconf')
-}
diff --git a/meta/classes-recipe/gettext.bbclass b/meta/classes-recipe/gettext.bbclass
deleted file mode 100644
index c313885d52..0000000000
--- a/meta/classes-recipe/gettext.bbclass
+++ /dev/null
@@ -1,28 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-def gettext_dependencies(d):
-    if d.getVar('INHIBIT_DEFAULT_DEPS') and not oe.utils.inherits(d, 'cross-canadian'):
-        return ""
-    if d.getVar('USE_NLS') == 'no':
-        return "gettext-minimal-native"
-    return "gettext-native"
-
-def gettext_oeconf(d):
-    if d.getVar('USE_NLS') == 'no':
-        return '--disable-nls'
-    # Remove the NLS bits if USE_NLS is no or INHIBIT_DEFAULT_DEPS is set
-    if d.getVar('INHIBIT_DEFAULT_DEPS') and not oe.utils.inherits(d, 'cross-canadian'):
-        return '--disable-nls'
-    return "--enable-nls"
-
-BASEDEPENDS:append = " ${@gettext_dependencies(d)}"
-EXTRA_OECONF:append = " ${@gettext_oeconf(d)}"
-
-# Without this, msgfmt from gettext-native will not find ITS files
-# provided by target recipes (for example, polkit.its).
-GETTEXTDATADIRS:append:class-target = ":${STAGING_DATADIR}/gettext"
-export GETTEXTDATADIRS
diff --git a/meta/classes-recipe/gi-docgen.bbclass b/meta/classes-recipe/gi-docgen.bbclass
deleted file mode 100644
index b178d1c387..0000000000
--- a/meta/classes-recipe/gi-docgen.bbclass
+++ /dev/null
@@ -1,32 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-# gi-docgen is a new gnome documentation generator, which
-# seems to be a successor to gtk-doc:
-# https://gitlab.gnome.org/GNOME/gi-docgen
-
-# True if api-documentation and gobject-introspection-data are in DISTRO_FEATURES,
-# and qemu-user is in MACHINE_FEATURES, False otherwise.
-GIDOCGEN_ENABLED ?= "${@bb.utils.contains('DISTRO_FEATURES', 'api-documentation gobject-introspection-data', \
-                      bb.utils.contains('MACHINE_FEATURES', 'qemu-usermode', 'True', 'False', d), 'False', d)}"
-
-# When building native recipes, disable gi-docgen, as it is not necessary,
-# pulls in additional dependencies, and makes build times longer
-GIDOCGEN_ENABLED:class-native = "False"
-GIDOCGEN_ENABLED:class-nativesdk = "False"
-
-# meson: default option name to enable/disable gi-docgen. This matches most
-# projects' configuration. In doubts - check meson_options.txt in project's
-# source path.
-GIDOCGEN_MESON_OPTION ?= 'gtk_doc'
-GIDOCGEN_MESON_ENABLE_FLAG ?= 'true'
-GIDOCGEN_MESON_DISABLE_FLAG ?= 'false'
-
-# Auto enable/disable based on GIDOCGEN_ENABLED
-EXTRA_OEMESON:prepend = "-D${GIDOCGEN_MESON_OPTION}=${@bb.utils.contains('GIDOCGEN_ENABLED', 'True', '${GIDOCGEN_MESON_ENABLE_FLAG}', '${GIDOCGEN_MESON_DISABLE_FLAG}', d)} "
-
-DEPENDS:append = "${@' gi-docgen-native gi-docgen' if d.getVar('GIDOCGEN_ENABLED') == 'True' else ''}"
-
diff --git a/meta/classes-recipe/gio-module-cache.bbclass b/meta/classes-recipe/gio-module-cache.bbclass
deleted file mode 100644
index 3714678c7c..0000000000
--- a/meta/classes-recipe/gio-module-cache.bbclass
+++ /dev/null
@@ -1,43 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-PACKAGE_WRITE_DEPS += "qemuwrapper-cross"
-
-GIO_MODULE_PACKAGES ??= "${PN}"
-
-gio_module_cache_common() {
-if [ "x$D" != "x" ]; then
-    $INTERCEPT_DIR/postinst_intercept update_gio_module_cache ${PKG} \
-            mlprefix=${MLPREFIX} \
-            binprefix=${MLPREFIX} \
-            libdir=${libdir} \
-            libexecdir=${libexecdir} \
-            base_libdir=${base_libdir} \
-            bindir=${bindir}
-else
-    ${libexecdir}/${MLPREFIX}gio-querymodules ${libdir}/gio/modules/
-fi
-}
-
-python populate_packages:append () {
-    packages = d.getVar('GIO_MODULE_PACKAGES').split()
-
-    for pkg in packages:
-        bb.note("adding gio-module-cache postinst and postrm scripts to %s" % pkg)
-
-        postinst = d.getVar('pkg_postinst:%s' % pkg)
-        if not postinst:
-            postinst = '#!/bin/sh\n'
-        postinst += d.getVar('gio_module_cache_common')
-        d.setVar('pkg_postinst:%s' % pkg, postinst)
-
-        postrm = d.getVar('pkg_postrm:%s' % pkg)
-        if not postrm:
-            postrm = '#!/bin/sh\n'
-        postrm += d.getVar('gio_module_cache_common')
-        d.setVar('pkg_postrm:%s' % pkg, postrm)
-}
-
diff --git a/meta/classes-recipe/github-releases.bbclass b/meta/classes-recipe/github-releases.bbclass
deleted file mode 100644
index ed83b83731..0000000000
--- a/meta/classes-recipe/github-releases.bbclass
+++ /dev/null
@@ -1,3 +0,0 @@
-GITHUB_BASE_URI ?= "https://github.com/${BPN}/${BPN}/releases/"
-UPSTREAM_CHECK_URI ?= "${GITHUB_BASE_URI}"
-UPSTREAM_CHECK_REGEX ?= "releases/tag/v?(?P<pver>\d+(\.\d+)+)"
diff --git a/meta/classes-recipe/gnomebase.bbclass b/meta/classes-recipe/gnomebase.bbclass
deleted file mode 100644
index 74073321b8..0000000000
--- a/meta/classes-recipe/gnomebase.bbclass
+++ /dev/null
@@ -1,38 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-def gnome_verdir(v):
-    return ".".join(v.split(".")[:-1]) or v
-
-
-GNOME_COMPRESS_TYPE ?= "xz"
-SECTION ?= "x11/gnome"
-GNOMEBN ?= "${BPN}"
-SRC_URI = "${GNOME_MIRROR}/${GNOMEBN}/${@gnome_verdir("${PV}")}/${GNOMEBN}-${PV}.tar.${GNOME_COMPRESS_TYPE};name=archive"
-
-FILES:${PN} += "${datadir}/application-registry  \
-                ${datadir}/mime-info \
-                ${datadir}/mime/packages \
-                ${datadir}/mime/application \
-                ${datadir}/gnome-2.0 \
-                ${datadir}/polkit* \
-                ${datadir}/GConf \
-                ${datadir}/glib-2.0/schemas \
-                ${datadir}/appdata \
-                ${datadir}/icons \
-"
-
-FILES:${PN}-doc += "${datadir}/devhelp"
-
-GNOMEBASEBUILDCLASS ??= "meson"
-inherit pkgconfig
-inherit_defer ${GNOMEBASEBUILDCLASS}
-
-do_install:append() {
-        rm -rf ${D}${localstatedir}/lib/scrollkeeper/*
-        rm -rf ${D}${localstatedir}/scrollkeeper/*
-        rm -f ${D}${datadir}/applications/*.cache
-}
diff --git a/meta/classes-recipe/go-mod-update-modules.bbclass b/meta/classes-recipe/go-mod-update-modules.bbclass
deleted file mode 100644
index 0083588a25..0000000000
--- a/meta/classes-recipe/go-mod-update-modules.bbclass
+++ /dev/null
@@ -1,146 +0,0 @@
-addtask do_update_modules after do_configure
-do_update_modules[nostamp] = "1"
-do_update_modules[network] = "1"
-
-# This class maintains two files, BPN-go-mods.inc and BPN-licenses.inc.
-#
-# -go-mods.inc will append SRC_URI with all of the Go modules that are
-# dependencies of this recipe.
-#
-# -licenses.inc will append LICENSE and LIC_FILES_CHKSUM with the found licenses
-# in the modules.
-#
-# These files are machine-generated and should not be modified.
-
-python do_update_modules() {
-    import subprocess, tempfile, json, re, urllib.parse
-    from oe.license import tidy_licenses
-    from oe.license_finder import find_licenses_up
-
-    def unescape_path(path):
-        """Unescape capital letters using exclamation points."""
-        return re.sub(r'!([a-z])', lambda m: m.group(1).upper(), path)
-
-    def fold_uri(uri):
-        """Fold URI for sorting shorter module paths before longer."""
-        return uri.replace(';', ' ').replace('/', '!')
-
-    def parse_existing_licenses():
-        hashes = {}
-        for url in d.getVar("LIC_FILES_CHKSUM").split():
-            (method, host, path, user, pswd, parm) = bb.fetch.decodeurl(url)
-            if "spdx" in parm and parm["spdx"] != "Unknown":
-                hashes[parm["md5"]] = urllib.parse.unquote_plus(parm["spdx"])
-        return hashes
-
-    bpn = d.getVar("BPN")
-    thisdir = d.getVar("THISDIR")
-    s_dir = d.getVar("S")
-
-    with tempfile.TemporaryDirectory(prefix='go-mod-') as mod_cache_dir:
-        notice = """
-# This file has been generated by go-mod-update-modules.bbclass
-#
-# Do not modify it by hand, as the contents will be replaced when
-# running the update-modules task.
-
-"""
-
-        env = dict(os.environ, GOMODCACHE=mod_cache_dir)
-        source = d.expand("${UNPACKDIR}/${GO_SRCURI_DESTSUFFIX}")
-        go_install = d.getVar("GO_INSTALL").split()
-        output = subprocess.check_output(("go", "list", "-json=Dir,Module", "-deps", *go_install),
-                                         cwd=source, env=env, text=True)
-
-        #
-        # Licenses
-        #
-
-        # load hashes from the existing licenses.inc
-        extra_hashes = parse_existing_licenses()
-
-        # The output of this isn't actually valid JSON, but a series of dicts.
-        # Wrap in [] and join the dicts with ,
-        # Very frustrating that the json parser in python can't repeatedly
-        # parse from a stream.
-        pkgs = json.loads('[' + output.replace('}\n{', '},\n{') + ']')
-
-        # Collect licenses for the dependencies.
-        lic_files = {}
-        for pkg in pkgs:
-            pkg_dir = pkg['Dir']
-            if not pkg_dir.startswith(mod_cache_dir):
-                continue
-
-            mod_dir = pkg['Module']['Dir']
-            path = os.path.relpath(mod_dir, mod_cache_dir)
-
-            for name, file, md5 in find_licenses_up(pkg_dir, mod_dir, d, first_only=True, extra_hashes=extra_hashes):
-                lic_files[os.path.join(path, file)] = (name, md5)
-
-        licenses = set()
-        lic_files_chksum = []
-        for lic_file in lic_files:
-            license_name, license_md5 = lic_files[lic_file]
-            if license_name == "Unknown":
-                bb.warn(f"Unknown license: {lic_file} {license_md5}")
-
-            licenses.add(lic_files[lic_file][0])
-            lic_files_chksum.append(
-                f'file://pkg/mod/{lic_file};md5={license_md5};spdx={urllib.parse.quote_plus(license_name)}')
-
-        licenses_filename = os.path.join(thisdir, f"{bpn}-licenses.inc")
-        with open(licenses_filename, "w") as f:
-            f.write(notice)
-            f.write(f'LICENSE += "& {" & ".join(tidy_licenses(licenses))}"\n\n')
-            f.write('LIC_FILES_CHKSUM += "\\\n')
-            for lic in sorted(lic_files_chksum, key=fold_uri):
-                f.write('    ' + lic + ' \\\n')
-            f.write('"\n')
-
-        #
-        # Sources
-        #
-
-        # Collect the module cache files downloaded by the go list command as
-        # the go list command knows best what the go list command needs and it
-        # needs more files in the module cache than the go install command as
-        # it doesn't do the dependency pruning mentioned in the Go module
-        # reference, https://go.dev/ref/mod, for go 1.17 or higher.
-        src_uris = []
-        downloaddir = os.path.join(mod_cache_dir, 'cache', 'download')
-        for dirpath, _, filenames in os.walk(downloaddir):
-            # We want to process files under @v directories
-            path, base = os.path.split(os.path.relpath(dirpath, downloaddir))
-            if base != '@v':
-                continue
-
-            path = unescape_path(path)
-            zipver = None
-            for name in filenames:
-                ver, ext = os.path.splitext(name)
-                if ext == '.zip':
-                    chksum = bb.utils.sha256_file(os.path.join(dirpath, name))
-                    src_uris.append(f'gomod://{path};version={ver};sha256sum={chksum}')
-                    zipver = ver
-                    break
-            for name in filenames:
-                ver, ext = os.path.splitext(name)
-                if ext == '.mod' and ver != zipver:
-                    chksum = bb.utils.sha256_file(os.path.join(dirpath, name))
-                    src_uris.append(f'gomod://{path};version={ver};mod=1;sha256sum={chksum}')
-
-
-        go_mods_filename = os.path.join(thisdir, f"{bpn}-go-mods.inc")
-        with open(go_mods_filename, "w") as f:
-            f.write(notice)
-            f.write('SRC_URI += "\\\n')
-            for uri in sorted(src_uris, key=fold_uri):
-                f.write('    ' + uri + ' \\\n')
-            f.write('"\n')
-
-        subprocess.check_output(("go", "clean", "-modcache"), cwd=source, env=env, text=True)
-}
-
-# This doesn't work as we need to wipe the inc files first so we don't try looking for LICENSE files that don't yet exist
-# RECIPE_UPGRADE_EXTRA_TASKS += "do_update_modules"
diff --git a/meta/classes-recipe/go-mod.bbclass b/meta/classes-recipe/go-mod.bbclass
deleted file mode 100644
index a15dda8f0e..0000000000
--- a/meta/classes-recipe/go-mod.bbclass
+++ /dev/null
@@ -1,34 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-# Handle Go Modules support
-#
-# When using Go Modules, the current working directory MUST be at or below
-# the location of the 'go.mod' file when the go tool is used, and there is no
-# way to tell it to look elsewhere.  It will automatically look upwards for the
-# file, but not downwards.
-#
-# To support this use case, we provide the `GO_WORKDIR` variable, which defaults
-# to `GO_IMPORT` but allows for easy override.
-#
-# Copyright 2020 (C) O.S. Systems Software LTDA.
-
-# The '-modcacherw' option ensures we have write access to the cached objects so
-# we avoid errors during clean task as well as when removing the TMPDIR.
-GOBUILDFLAGS:append = " -modcacherw"
-
-inherit go
-
-export GOMODCACHE = "${S}/pkg/mod"
-GO_MOD_CACHE_DIR = "${@os.path.relpath(d.getVar('GOMODCACHE'), d.getVar('UNPACKDIR'))}"
-do_unpack[cleandirs] += "${GOMODCACHE}"
-
-GO_WORKDIR ?= "${GO_IMPORT}"
-do_compile[dirs] += "${B}/src/${GO_WORKDIR}"
-
-# Make go install unpack the module zip files in the module cache directory
-# before the license directory is polulated with license files.
-addtask do_compile before do_populate_lic
diff --git a/meta/classes-recipe/go-ptest.bbclass b/meta/classes-recipe/go-ptest.bbclass
deleted file mode 100644
index 54fcbb535d..0000000000
--- a/meta/classes-recipe/go-ptest.bbclass
+++ /dev/null
@@ -1,60 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-inherit go ptest
-
-do_compile_ptest_base() {
-        export TMPDIR="${GOTMPDIR}"
-        rm -f ${B}/.go_compiled_tests.list
-        go_list_package_tests | while read pkg; do
-                cd ${B}/src/$pkg
-                ${GO} test ${GOPTESTBUILDFLAGS} $pkg
-                find . -mindepth 1 -maxdepth 1 -type f -name '*.test' -exec echo $pkg/{} \; | \
-                        sed -e's,/\./,/,'>> ${B}/.go_compiled_tests.list
-        done
-        do_compile_ptest
-}
-
-do_compile_ptest_base[dirs] =+ "${GOTMPDIR}"
-
-go_make_ptest_wrapper() {
-        cat >${D}${PTEST_PATH}/run-ptest <<EOF
-#!/bin/sh
-RC=0
-run_test() (
-    cd "\$1"
-    ((((./\$2 ${GOPTESTFLAGS}; echo \$? >&3) | sed -r -e"s,^(PASS|SKIP|FAIL)\$,\\1: \$1/\$2," >&4) 3>&1) | (read rc; exit \$rc)) 4>&1
-    exit \$?)
-EOF
-
-}
-
-do_install_ptest_base() {
-        test -f "${B}/.go_compiled_tests.list" || exit 0
-        install -d ${D}${PTEST_PATH}
-        go_stage_testdata
-        go_make_ptest_wrapper
-        havetests=""
-        while read test; do
-                testdir=`dirname $test`
-                testprog=`basename $test`
-                install -d ${D}${PTEST_PATH}/$testdir
-                install -m 0755 ${B}/src/$test ${D}${PTEST_PATH}/$test
-        echo "run_test $testdir $testprog || RC=1" >> ${D}${PTEST_PATH}/run-ptest
-                havetests="yes"
-        done < ${B}/.go_compiled_tests.list
-        if [ -n "$havetests" ]; then
-                echo "exit \$RC" >> ${D}${PTEST_PATH}/run-ptest
-                chmod +x ${D}${PTEST_PATH}/run-ptest
-        else
-                rm -rf ${D}${PTEST_PATH}
-        fi
-        do_install_ptest
-        chown -R root:root ${D}${PTEST_PATH}
-}
-
-INSANE_SKIP:${PN}-ptest += "ldflags"
-
diff --git a/meta/classes-recipe/go.bbclass b/meta/classes-recipe/go.bbclass
deleted file mode 100644
index e0f667373e..0000000000
--- a/meta/classes-recipe/go.bbclass
+++ /dev/null
@@ -1,159 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-inherit goarch
-inherit linuxloader
-
-# if the GO_IMPORT is not set in recipe generate an error
-GO_IMPORT ??= "${@bb.fatal("The recipe needs to set GO_IMPORT for go.bbclass to work")}"
-
-GO_PARALLEL_BUILD ?= "${@oe.utils.parallel_make_argument(d, '-p %d')}"
-
-export GODEBUG = "gocachehash=1"
-
-GOROOT:class-native = "${STAGING_LIBDIR_NATIVE}/go"
-GOROOT:class-nativesdk = "${STAGING_DIR_TARGET}${libdir}/go"
-GOROOT = "${STAGING_LIBDIR}/go"
-export GOROOT
-export GOCACHE = "${B}/.cache"
-
-export GOARCH = "${TARGET_GOARCH}"
-export GOOS = "${TARGET_GOOS}"
-export GOHOSTARCH = "${BUILD_GOARCH}"
-export GOHOSTOS = "${BUILD_GOOS}"
-
-GOARM[export] = "0"
-GOARM:arm:class-target = "${TARGET_GOARM}"
-GOARM:arm:class-target[export] = "1"
-
-GO386[export] = "0"
-GO386:x86:class-target = "${TARGET_GO386}"
-GO386:x86:class-target[export] = "1"
-
-GOMIPS[export] = "0"
-GOMIPS:mips:class-target = "${TARGET_GOMIPS}"
-GOMIPS:mips:class-target[export] = "1"
-
-DEPENDS_GOLANG:class-target = "virtual/${TUNE_PKGARCH}-go virtual/${TARGET_PREFIX}go-runtime"
-DEPENDS_GOLANG:class-native = "go-native"
-DEPENDS_GOLANG:class-nativesdk = "virtual/${TARGET_PREFIX}go virtual/${TARGET_PREFIX}go-runtime"
-
-DEPENDS:append = " ${DEPENDS_GOLANG}"
-
-GO_LINKSHARED ?= "${@'-linkshared' if d.getVar('GO_DYNLINK') else ''}"
-GO_RPATH_LINK = "${@'-Wl,-rpath-link=${STAGING_DIR_TARGET}${libdir}/go/pkg/${TARGET_GOTUPLE}_dynlink' if d.getVar('GO_DYNLINK') else ''}"
-GO_RPATH = "${@'-r ${libdir}/go/pkg/${TARGET_GOTUPLE}_dynlink' if d.getVar('GO_DYNLINK') else ''}"
-GO_RPATH:class-native = "${@'-r ${STAGING_LIBDIR_NATIVE}/go/pkg/${TARGET_GOTUPLE}_dynlink' if d.getVar('GO_DYNLINK') else ''}"
-GO_RPATH_LINK:class-native = "${@'-Wl,-rpath-link=${STAGING_LIBDIR_NATIVE}/go/pkg/${TARGET_GOTUPLE}_dynlink' if d.getVar('GO_DYNLINK') else ''}"
-GO_EXTLDFLAGS ?= "${HOST_CC_ARCH}${TOOLCHAIN_OPTIONS} ${GO_RPATH_LINK} ${LDFLAGS}"
-GO_LINKMODE ?= ""
-GO_EXTRA_LDFLAGS ?= ""
-GO_LINUXLOADER ?= "-I ${@get_linuxloader(d)}"
-# Use system loader. If uninative is used, the uninative loader will be patched automatically
-GO_LINUXLOADER:class-native = ""
-GO_LDFLAGS ?= '-ldflags="${GO_RPATH} ${GO_LINKMODE} ${GO_LINUXLOADER} ${GO_EXTRA_LDFLAGS} -extldflags '${GO_EXTLDFLAGS}'"'
-export GOBUILDFLAGS ?= "-v ${GO_LDFLAGS} -trimpath"
-export GOPATH_OMIT_IN_ACTIONID ?= "1"
-export GOPTESTBUILDFLAGS ?= "${GOBUILDFLAGS} -c"
-export GOPTESTFLAGS ?= ""
-GOBUILDFLAGS:prepend:task-compile = "${GO_PARALLEL_BUILD} "
-
-export GO = "${HOST_PREFIX}go"
-GOTOOLDIR = "${STAGING_LIBDIR_NATIVE}/${TARGET_SYS}/go/pkg/tool/${BUILD_GOTUPLE}"
-GOTOOLDIR:class-native = "${STAGING_LIBDIR_NATIVE}/go/pkg/tool/${BUILD_GOTUPLE}"
-export GOTOOLDIR
-
-export CGO_ENABLED ?= "1"
-export CGO_CFLAGS ?= "${CFLAGS}"
-export CGO_CPPFLAGS ?= "${CPPFLAGS}"
-export CGO_CXXFLAGS ?= "${CXXFLAGS}"
-export CGO_LDFLAGS ?= "${LDFLAGS}"
-
-GO_INSTALL ?= "${GO_IMPORT}/..."
-GO_INSTALL_FILTEROUT ?= "${GO_IMPORT}/vendor/"
-
-B = "${WORKDIR}/build"
-export GOPATH = "${B}"
-export GOENV = "off"
-export GOPROXY ??= "https://proxy.golang.org,direct"
-export GOTMPDIR ?= "${WORKDIR}/build-tmp"
-GOTMPDIR[vardepvalue] = ""
-
-GO_SRCURI_DESTSUFFIX = "${@os.path.join(os.path.basename(d.getVar('S')), 'src', d.getVar('GO_IMPORT')) + '/'}"
-
-go_list_packages() {
-        ${GO} list -f '{{.ImportPath}}' ${GOBUILDFLAGS} ${GO_INSTALL} | \
-                egrep -v '${GO_INSTALL_FILTEROUT}'
-}
-
-go_list_package_tests() {
-        ${GO} list -f '{{.ImportPath}} {{.TestGoFiles}}' ${GOBUILDFLAGS} ${GO_INSTALL} | \
-                grep -v '\[\]$' | \
-                egrep -v '${GO_INSTALL_FILTEROUT}' | \
-                awk '{ print $1 }'
-}
-
-go_do_configure() {
-        ln -snf ${S}/src ${B}/
-}
-do_configure[dirs] =+ "${GOTMPDIR}"
-
-go_do_compile() {
-        export TMPDIR="${GOTMPDIR}"
-        if [ -n "${GO_INSTALL}" ]; then
-                if [ -n "${GO_LINKSHARED}" ]; then
-                        ${GO} install ${GOBUILDFLAGS} `go_list_packages`
-                        rm -rf ${B}/bin
-                fi
-                ${GO} install ${GO_LINKSHARED} ${GOBUILDFLAGS} `go_list_packages`
-        fi
-}
-do_compile[dirs] =+ "${GOTMPDIR}"
-do_compile[cleandirs] = "${B}/bin ${B}/pkg"
-
-go_do_install() {
-        install -d ${D}${libdir}/go/src/${GO_IMPORT}
-        tar -C ${S}/src/${GO_IMPORT} -cf - --exclude-vcs --exclude '*.test' --exclude 'testdata' . | \
-                tar -C ${D}${libdir}/go/src/${GO_IMPORT} --no-same-owner -xf -
-        tar -C ${B} -cf - --exclude-vcs --exclude '*.test' --exclude 'testdata' pkg | \
-                tar -C ${D}${libdir}/go --no-same-owner -xf -
-
-        if ls ${B}/${GO_BUILD_BINDIR}/* >/dev/null 2>/dev/null ; then
-                install -d ${D}${bindir}
-                install -m 0755 ${B}/${GO_BUILD_BINDIR}/* ${D}${bindir}/
-        fi
-}
-
-go_stage_testdata() {
-        oldwd="$PWD"
-        cd ${S}/src
-        find ${GO_IMPORT} -depth -type d -name testdata | while read d; do
-                if echo "$d" | grep -q '/vendor/'; then
-                        continue
-                fi
-                parent=`dirname $d`
-                install -d ${D}${PTEST_PATH}/$parent
-                cp --preserve=mode,timestamps -R $d ${D}${PTEST_PATH}/$parent/
-        done
-        cd "$oldwd"
-}
-
-EXPORT_FUNCTIONS do_configure do_compile do_install
-
-FILES:${PN}-dev = "${libdir}/go/src"
-FILES:${PN}-staticdev = "${libdir}/go/pkg"
-
-INSANE_SKIP:${PN} += "ldflags"
-
-# Add -buildmode=pie to GOBUILDFLAGS to satisfy "textrel" QA checking, but mips
-# doesn't support -buildmode=pie, so skip the QA checking for mips/rv32 and its
-# variants.
-python() {
-    if 'mips' in d.getVar('TARGET_ARCH') or 'riscv32' in d.getVar('TARGET_ARCH'):
-        d.appendVar('INSANE_SKIP:%s' % d.getVar('PN'), " textrel")
-    else:
-        d.appendVar('GOBUILDFLAGS', ' -buildmode=pie')
-}
diff --git a/meta/classes-recipe/goarch.bbclass b/meta/classes-recipe/goarch.bbclass
deleted file mode 100644
index 0e9ef3a6ec..0000000000
--- a/meta/classes-recipe/goarch.bbclass
+++ /dev/null
@@ -1,105 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-BUILD_GOOS = "${@go_map_os(d.getVar('BUILD_OS'), d)}"
-BUILD_GOARCH = "${@go_map_arch(d.getVar('BUILD_ARCH'), d)}"
-BUILD_GOTUPLE = "${BUILD_GOOS}_${BUILD_GOARCH}"
-HOST_GOOS = "${@go_map_os(d.getVar('HOST_OS'), d)}"
-HOST_GOARCH = "${@go_map_arch(d.getVar('HOST_ARCH'), d)}"
-HOST_GOARM = "${@go_map_arm(d.getVar('HOST_ARCH'), d)}"
-HOST_GO386 = "${@go_map_386(d.getVar('HOST_ARCH'), d.getVar('TUNE_FEATURES'), d)}"
-HOST_GOMIPS = "${@go_map_mips(d.getVar('HOST_ARCH'), d.getVar('TUNE_FEATURES'), d)}"
-HOST_GOARM:class-native = "7"
-HOST_GO386:class-native = "sse2"
-HOST_GOMIPS:class-native = "hardfloat"
-HOST_GOTUPLE = "${HOST_GOOS}_${HOST_GOARCH}"
-TARGET_GOOS = "${@go_map_os(d.getVar('TARGET_OS'), d)}"
-TARGET_GOARCH = "${@go_map_arch(d.getVar('TARGET_ARCH'), d)}"
-TARGET_GOARM = "${@go_map_arm(d.getVar('TARGET_ARCH'), d)}"
-TARGET_GO386 = "${@go_map_386(d.getVar('TARGET_ARCH'), d.getVar('TUNE_FEATURES'), d)}"
-TARGET_GOMIPS = "${@go_map_mips(d.getVar('TARGET_ARCH'), d.getVar('TUNE_FEATURES'), d)}"
-TARGET_GOARM:class-native = "7"
-TARGET_GO386:class-native = "sse2"
-TARGET_GOMIPS:class-native = "hardfloat"
-TARGET_GOARM:class-crosssdk = "7"
-TARGET_GO386:class-crosssdk = "sse2"
-TARGET_GOMIPS:class-crosssdk = "hardfloat"
-TARGET_GOTUPLE = "${TARGET_GOOS}_${TARGET_GOARCH}"
-GO_BUILD_BINDIR = "${@['bin/${HOST_GOTUPLE}','bin'][d.getVar('BUILD_GOTUPLE') == d.getVar('HOST_GOTUPLE')]}"
-
-# Use the MACHINEOVERRIDES to map ARM CPU architecture passed to GO via GOARM.
-# This is combined with *_ARCH to set HOST_GOARM and TARGET_GOARM.
-BASE_GOARM = ''
-BASE_GOARM:armv7ve = '7'
-BASE_GOARM:armv7a = '7'
-BASE_GOARM:armv6 = '6'
-BASE_GOARM:armv5 = '5'
-
-# Go supports dynamic linking on a limited set of architectures.
-# See the supportsDynlink function in go/src/cmd/compile/internal/gc/main.go
-GO_DYNLINK = ""
-GO_DYNLINK:arm ?= "1"
-GO_DYNLINK:aarch64 ?= "1"
-GO_DYNLINK:x86 ?= "1"
-GO_DYNLINK:x86-64 ?= "1"
-GO_DYNLINK:powerpc64 ?= "1"
-GO_DYNLINK:powerpc64le ?= "1"
-GO_DYNLINK:class-native ?= ""
-GO_DYNLINK:class-nativesdk = ""
-
-# define here because everybody inherits this class
-#
-COMPATIBLE_HOST:linux-gnux32 = "null"
-COMPATIBLE_HOST:linux-muslx32 = "null"
-COMPATIBLE_HOST:powerpc = "null"
-COMPATIBLE_HOST:powerpc64 = "null"
-COMPATIBLE_HOST:mipsarchn32 = "null"
-COMPATIBLE_HOST:riscv32 = "null"
-
-ARM_INSTRUCTION_SET:armv4 = "arm"
-ARM_INSTRUCTION_SET:armv5 = "arm"
-ARM_INSTRUCTION_SET:armv6 = "arm"
-
-TUNE_CCARGS:remove = "-march=mips32r2"
-SECURITY_NOPIE_CFLAGS ??= ""
-
-# go can't be built with ccache:
-# gcc: fatal error: no input files
-CCACHE_DISABLE ?= "1"
-
-def go_map_arch(a, d):
-    arch = oe.go.map_arch(a)
-    if not arch:
-        raise bb.parse.SkipRecipe("Unsupported CPU architecture: %s" % a)
-    return arch
-
-def go_map_arm(a, d):
-    if a.startswith("arm"):
-        return d.getVar('BASE_GOARM')
-    return ''
-
-def go_map_386(a, f, d):
-    import re
-    if re.match('i.86', a):
-        if ('core2' in f) or ('corei7' in f):
-            return 'sse2'
-        else:
-            return 'softfloat'
-    return ''
-
-def go_map_mips(a, f, d):
-    import re
-    if a == 'mips' or a == 'mipsel':
-        if 'fpu-hard' in f:
-            return 'hardfloat'
-        else:
-            return 'softfloat'
-    return ''
-
-def go_map_os(o, d):
-    if o.startswith('linux'):
-        return 'linux'
-    return o
diff --git a/meta/classes-recipe/gobject-introspection-data.bbclass b/meta/classes-recipe/gobject-introspection-data.bbclass
deleted file mode 100644
index aa04c70ca6..0000000000
--- a/meta/classes-recipe/gobject-introspection-data.bbclass
+++ /dev/null
@@ -1,13 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-# This variable is set to True if gobject-introspection-data is in
-# DISTRO_FEATURES and qemu-usermode is in MACHINE_FEATURES, and False otherwise.
-#
-# It should be used in recipes to determine whether introspection data should be built,
-# so that qemu use can be avoided when necessary.
-GI_DATA_ENABLED ?= "${@bb.utils.contains('DISTRO_FEATURES', 'gobject-introspection-data', \
-                      bb.utils.contains('MACHINE_FEATURES', 'qemu-usermode', 'True', 'False', d), 'False', d)}"
diff --git a/meta/classes-recipe/gobject-introspection.bbclass b/meta/classes-recipe/gobject-introspection.bbclass
deleted file mode 100644
index d0052cd623..0000000000
--- a/meta/classes-recipe/gobject-introspection.bbclass
+++ /dev/null
@@ -1,64 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-# Inherit this class in recipes to enable building their introspection files
-
-# python3native is inherited to prevent introspection tools being run with
-# host's python 3 (they need to be run with native python 3)
-#
-# This also sets up autoconf-based recipes to build introspection data (or not),
-# depending on distro and machine features (see gobject-introspection-data class).
-inherit python3native gobject-introspection-data
-
-# meson: default option name to enable/disable introspection. This matches most
-# project's configuration. In doubts - check meson_options.txt in project's
-# source path.
-GIR_MESON_OPTION ?= 'introspection'
-GIR_MESON_ENABLE_FLAG ?= 'true'
-GIR_MESON_DISABLE_FLAG ?= 'false'
-
-# Define g-i options such that they can be disabled completely when GIR_MESON_OPTION is empty
-GIRMESONTARGET = "-D${GIR_MESON_OPTION}=${@bb.utils.contains('GI_DATA_ENABLED', 'True', '${GIR_MESON_ENABLE_FLAG}', '${GIR_MESON_DISABLE_FLAG}', d)} "
-GIRMESONBUILD = "-D${GIR_MESON_OPTION}=${GIR_MESON_DISABLE_FLAG} "
-# Auto enable/disable based on GI_DATA_ENABLED
-EXTRA_OECONF:prepend:class-target = "${@bb.utils.contains('GI_DATA_ENABLED', 'True', '--enable-introspection', '--disable-introspection', d)} "
-EXTRA_OEMESON:prepend:class-target = "${@['', '${GIRMESONTARGET}'][d.getVar('GIR_MESON_OPTION') != '']}"
-# When building native recipes, disable introspection, as it is not necessary,
-# pulls in additional dependencies, and makes build times longer
-EXTRA_OECONF:prepend:class-native = "--disable-introspection "
-EXTRA_OECONF:prepend:class-nativesdk = "--disable-introspection "
-EXTRA_OEMESON:prepend:class-native = "${@['', '${GIRMESONBUILD}'][d.getVar('GIR_MESON_OPTION') != '']}"
-EXTRA_OEMESON:prepend:class-nativesdk = "${@['', '${GIRMESONBUILD}'][d.getVar('GIR_MESON_OPTION') != '']}"
-
-# Generating introspection data depends on a combination of native and target
-# introspection tools, and qemu to run the target tools.
-DEPENDS:append:class-target = " ${@bb.utils.contains('GI_DATA_ENABLED', 'True', 'gobject-introspection qemu-native', '', d)}"
-
-# Even when introspection is disabled, the gobject-introspection package is still needed for m4 macros.
-DEPENDS:append = " gobject-introspection-native"
-
-# This is used by introspection tools to find .gir includes
-export XDG_DATA_DIRS = "${STAGING_DATADIR}:${STAGING_LIBDIR}"
-
-do_configure:prepend:class-target () {
-    # introspection.m4 pre-packaged with upstream tarballs does not yet
-    # have our fixes
-    mkdir -p ${S}/m4
-    cp ${STAGING_DIR_NATIVE}/${datadir}/aclocal/introspection.m4 ${S}/m4
-}
-
-do_compile:prepend() {
-    # This prevents g-ir-scanner from writing cache data to $HOME
-    export GI_SCANNER_DISABLE_CACHE=1
-}
-
-# .typelib files are needed at runtime and so they go to the main package (so
-# they'll be together with libraries they support).
-FILES:${PN}:append = " ${libdir}/girepository-*/*.typelib" 
-    
-# .gir files go to dev package, as they're needed for developing (but not for
-# running) things that depends on introspection.
-FILES:${PN}-dev:append = " ${datadir}/gir-*/*.gir ${libdir}/gir-*/*.gir"
diff --git a/meta/classes-recipe/grub-efi-cfg.bbclass b/meta/classes-recipe/grub-efi-cfg.bbclass
deleted file mode 100644
index 9a5cb99c52..0000000000
--- a/meta/classes-recipe/grub-efi-cfg.bbclass
+++ /dev/null
@@ -1,128 +0,0 @@
-# grub-efi.bbclass
-# Copyright (c) 2011, Intel Corporation.
-#
-# SPDX-License-Identifier: MIT
-
-# Provide grub-efi specific functions for building bootable images.
-
-# External variables
-# ${INITRD} - indicates a list of filesystem images to concatenate and use as an initrd (optional)
-# ${ROOTFS} - indicates a filesystem image to include as the root filesystem (optional)
-# ${GRUB_GFXSERIAL} - set this to 1 to have graphics and serial in the boot menu
-# ${LABELS} - a list of targets for the automatic config
-# ${APPEND} - an override list of append strings for each label
-# ${GRUB_OPTS} - additional options to add to the config, ';' delimited # (optional)
-# ${GRUB_TIMEOUT} - timeout before executing the deault label (optional)
-# ${GRUB_ROOT} - grub's root device.
-
-GRUB_SERIAL ?= "console=ttyS0,115200"
-GRUB_CFG_VM = "${S}/grub_vm.cfg"
-GRUB_CFG_LIVE = "${S}/grub_live.cfg"
-GRUB_TIMEOUT ?= "10"
-#FIXME: build this from the machine config
-GRUB_OPTS ?= "serial --unit=0 --speed=115200 --word=8 --parity=no --stop=1"
-
-GRUB_ROOT ?= "${ROOT}"
-GRUB_TITLE ?= ""
-APPEND ?= ""
-
-# Uses MACHINE specific KERNEL_IMAGETYPE
-PACKAGE_ARCH = "${MACHINE_ARCH}"
-
-# Need UUID utility code.
-inherit fs-uuid
-
-python build_efi_cfg() {
-    import sys
-
-    workdir = d.getVar('WORKDIR')
-    if not workdir:
-        bb.error("WORKDIR not defined, unable to package")
-        return
-
-    gfxserial = d.getVar('GRUB_GFXSERIAL') or ""
-
-    labels = d.getVar('LABELS')
-    if not labels:
-        bb.debug(1, "LABELS not defined, nothing to do")
-        return
-
-    if labels == []:
-        bb.debug(1, "No labels, nothing to do")
-        return
-
-    cfile = d.getVar('GRUB_CFG')
-    if not cfile:
-        bb.fatal('Unable to read GRUB_CFG')
-
-    try:
-         cfgfile = open(cfile, 'w')
-    except OSError:
-        bb.fatal('Unable to open %s' % cfile)
-
-    cfgfile.write('# Automatically created by OE\n')
-
-    opts = d.getVar('GRUB_OPTS')
-    if opts:
-        for opt in opts.split(';'):
-            cfgfile.write('%s\n' % opt)
-
-    cfgfile.write('default=%s\n' % (labels.split()[0]))
-
-    timeout = d.getVar('GRUB_TIMEOUT')
-    if timeout:
-        cfgfile.write('timeout=%s\n' % timeout)
-    else:
-        cfgfile.write('timeout=50\n')
-
-    root = d.getVar('GRUB_ROOT')
-    if not root:
-        bb.fatal('GRUB_ROOT not defined')
-
-    if gfxserial == "1":
-        btypes = [ [ " graphics console", "" ],
-            [ " serial console", d.getVar('GRUB_SERIAL') or "" ] ]
-    else:
-        btypes = [ [ "", "" ] ]
-
-    for label in labels.split():
-        localdata = d.createCopy()
-
-        overrides = localdata.getVar('OVERRIDES')
-        if not overrides:
-            bb.fatal('OVERRIDES not defined')
-
-        localdata.need_overrides()
-        localdata.setVar('OVERRIDES', 'grub_' + label + ':' + overrides)
-
-        for btype in btypes:
-            title = localdata.getVar('GRUB_TITLE')
-            if not title or len(title) == 0:
-                title = label
-
-            cfgfile.write('\nmenuentry \'%s%s\'{\n' % (title, btype[0]))
-            lb = label
-            if label == "install":
-                lb = "install-efi"
-            kernel = localdata.getVar('KERNEL_IMAGETYPE')
-            cfgfile.write('linux /%s LABEL=%s' % (kernel, lb))
-
-            cfgfile.write(' %s' % replace_rootfs_uuid(d, root))
-
-            append = localdata.getVar('APPEND')
-            initrd = localdata.getVar('INITRD')
-
-            if append:
-                append = replace_rootfs_uuid(d, append)
-                cfgfile.write(' %s' % (append))
-
-            cfgfile.write(' %s' % btype[1])
-            cfgfile.write('\n')
-
-            if initrd:
-                cfgfile.write('initrd /initrd')
-            cfgfile.write('\n}\n')
-
-    cfgfile.close()
-}
-build_efi_cfg[vardepsexclude] += "OVERRIDES"
diff --git a/meta/classes-recipe/grub-efi.bbclass b/meta/classes-recipe/grub-efi.bbclass
deleted file mode 100644
index 34bcbc53e6..0000000000
--- a/meta/classes-recipe/grub-efi.bbclass
+++ /dev/null
@@ -1,17 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-inherit grub-efi-cfg
-require conf/image-uefi.conf
-
-# Assure the existence of grub-efi image in deploy dir
-do_bootimg[depends] += "grub-efi:do_deploy"
-
-efi_populate() {
-        efi_populate_common "$1" grub-efi
-
-        install -m 0644 ${GRUB_CFG} ${DEST}${EFIDIR}/grub.cfg
-}
diff --git a/meta/classes-recipe/gsettings.bbclass b/meta/classes-recipe/gsettings.bbclass
deleted file mode 100644
index adb027ea0a..0000000000
--- a/meta/classes-recipe/gsettings.bbclass
+++ /dev/null
@@ -1,48 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-# A bbclass to handle installed GSettings (glib) schemas, updated the compiled
-# form on package install and remove.
-#
-# The compiled schemas are platform-agnostic, so we can depend on
-# glib-2.0-native for the native tool and run the postinst script when the
-# rootfs builds to save a little time on first boot.
-
-# TODO use a trigger so that this runs once per package operation run
-
-GSETTINGS_PACKAGE ?= "${PN}"
-
-python __anonymous() {
-    pkg = d.getVar("GSETTINGS_PACKAGE")
-    if pkg:
-        d.appendVar("PACKAGE_WRITE_DEPS", " glib-2.0-native")
-        d.appendVar("RDEPENDS:" + pkg, " ${MLPREFIX}glib-2.0-utils")
-        d.appendVar("FILES:" + pkg, " ${datadir}/glib-2.0/schemas")
-}
-
-gsettings_postinstrm () {
-        glib-compile-schemas $D${datadir}/glib-2.0/schemas
-}
-
-python populate_packages:append () {
-    pkg = d.getVar('GSETTINGS_PACKAGE')
-    if pkg:
-        bb.note("adding gsettings postinst scripts to %s" % pkg)
-
-        postinst = d.getVar('pkg_postinst:%s' % pkg) or d.getVar('pkg_postinst')
-        if not postinst:
-            postinst = '#!/bin/sh\n'
-        postinst += d.getVar('gsettings_postinstrm')
-        d.setVar('pkg_postinst:%s' % pkg, postinst)
-
-        bb.note("adding gsettings postrm scripts to %s" % pkg)
-
-        postrm = d.getVar('pkg_postrm:%s' % pkg) or d.getVar('pkg_postrm')
-        if not postrm:
-            postrm = '#!/bin/sh\n'
-        postrm += d.getVar('gsettings_postinstrm')
-        d.setVar('pkg_postrm:%s' % pkg, postrm)
-}
diff --git a/meta/classes-recipe/gtk-doc.bbclass b/meta/classes-recipe/gtk-doc.bbclass
deleted file mode 100644
index 9d3911966b..0000000000
--- a/meta/classes-recipe/gtk-doc.bbclass
+++ /dev/null
@@ -1,72 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-# Helper class to pull in the right gtk-doc dependencies and configure
-# gtk-doc to enable or disable documentation building (which requries the
-# use of usermode qemu).
-
-# This variable is set to True if api-documentation is in
-# DISTRO_FEATURES and qemu-usermode is in MACHINE_FEATURES, and False otherwise.
-#
-# It should be used in recipes to determine whether gtk-doc based documentation should be built,
-# so that qemu use can be avoided when necessary.
-GTKDOC_ENABLED:class-native = "False"
-GTKDOC_ENABLED ?= "${@bb.utils.contains('DISTRO_FEATURES', 'api-documentation', \
-                      bb.utils.contains('MACHINE_FEATURES', 'qemu-usermode', 'True', 'False', d), 'False', d)}"
-
-# meson: default option name to enable/disable gtk-doc. This matches most
-# project's configuration. In doubts - check meson_options.txt in project's
-# source path.
-GTKDOC_MESON_OPTION ?= 'docs'
-GTKDOC_MESON_ENABLE_FLAG ?= 'true'
-GTKDOC_MESON_DISABLE_FLAG ?= 'false'
-
-# Auto enable/disable based on GTKDOC_ENABLED
-EXTRA_OECONF:prepend = "${@bb.utils.contains('GTKDOC_ENABLED', 'True', '--enable-gtk-doc --enable-gtk-doc-html --disable-gtk-doc-pdf', \
-                                                                                    '--disable-gtk-doc', d)} "
-EXTRA_OEMESON:prepend = "-D${GTKDOC_MESON_OPTION}=${@bb.utils.contains('GTKDOC_ENABLED', 'True', '${GTKDOC_MESON_ENABLE_FLAG}', '${GTKDOC_MESON_DISABLE_FLAG}', d)} "
-
-# Even though gtkdoc is disabled on -native, gtk-doc package is still
-# needed for m4 macros.
-DEPENDS:append = " gtk-doc-native"
-
-export STAGING_DIR_HOST
-
-inherit python3native pkgconfig qemu
-DEPENDS:append = "${@' qemu-native' if d.getVar('GTKDOC_ENABLED') == 'True' else ''}"
-
-do_compile:prepend:class-target () {
-    if [ ${GTKDOC_ENABLED} = True ]; then
-        # Write out a qemu wrapper that will be given to gtkdoc-scangobj so that it
-        # can run target helper binaries through that.
-        qemu_binary="${@qemu_wrapper_cmdline(d, '$STAGING_DIR_HOST', ['\\$GIR_EXTRA_LIBS_PATH','$STAGING_DIR_HOST/${libdir}','$STAGING_DIR_HOST/${base_libdir}'])}"
-        cat > ${B}/gtkdoc-qemuwrapper << EOF
-#!/bin/sh
-# Use a modules directory which doesn't exist so we don't load random things
-# which may then get deleted (or their dependencies) and potentially segfault
-export GIO_MODULE_DIR=${STAGING_LIBDIR}/gio/modules-dummy
-
-GIR_EXTRA_LIBS_PATH=\`find ${B} -name *.so -printf "%h\n"|sort|uniq| tr '\n' ':'\`\$GIR_EXTRA_LIBS_PATH
-GIR_EXTRA_LIBS_PATH=\`find ${B} -name .libs| tr '\n' ':'\`\$GIR_EXTRA_LIBS_PATH
-
-# meson sets this wrongly (only to libs in build-dir), qemu_wrapper_cmdline() and GIR_EXTRA_LIBS_PATH take care of it properly
-unset LD_LIBRARY_PATH
-
-if [ -d ".libs" ]; then
-    $qemu_binary ".libs/\$@"
-else
-    $qemu_binary "\$@"
-fi
-
-if [ \$? -ne 0 ]; then
-    echo "If the above error message is about missing .so libraries, then setting up GIR_EXTRA_LIBS_PATH in the recipe should help."
-    echo "(typically like this: GIR_EXTRA_LIBS_PATH=\"$""{B}/something/.libs\" )"
-    exit 1
-fi
-EOF
-        chmod +x ${B}/gtkdoc-qemuwrapper
-    fi
-}
diff --git a/meta/classes-recipe/gtk-icon-cache.bbclass b/meta/classes-recipe/gtk-icon-cache.bbclass
deleted file mode 100644
index fad8c4c65f..0000000000
--- a/meta/classes-recipe/gtk-icon-cache.bbclass
+++ /dev/null
@@ -1,95 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-FILES:${PN} += "${datadir}/icons/hicolor"
-
-GTKIC_VERSION ??= '3'
-
-GTKPN = "${@ 'gtk4' if d.getVar('GTKIC_VERSION') == '4' else 'gtk+3' }"
-GTKIC_CMD = "${@ 'gtk4-update-icon-cache' if d.getVar('GTKIC_VERSION') == '4' else 'gtk-update-icon-cache-3.0' }"
-
-#gtk+3/gtk4 require GTK3DISTROFEATURES, DEPENDS on it make all the
-#recipes inherit this class require GTK3DISTROFEATURES
-inherit features_check
-ANY_OF_DISTRO_FEATURES = "${GTK3DISTROFEATURES}"
-
-DEPENDS += "${@ '' if d.getVar('BPN') == 'hicolor-icon-theme' else 'hicolor-icon-theme' } \
-            ${@ '' if d.getVar('BPN') == 'gdk-pixbuf' else 'gdk-pixbuf' } \
-            ${@ '' if d.getVar('BPN') == d.getVar('GTKPN') else d.getVar('GTKPN') } \
-            ${GTKPN}-native \
-"
-
-PACKAGE_WRITE_DEPS += "${GTKPN}-native gdk-pixbuf-native"
-
-gtk_icon_cache_postinst() {
-if [ "x$D" != "x" ]; then
-        $INTERCEPT_DIR/postinst_intercept update_gtk_icon_cache ${PKG} \
-                mlprefix=${MLPREFIX} \
-                libdir_native=${libdir_native}
-else
-
-        # Update the pixbuf loaders in case they haven't been registered yet
-        ${libdir}/gdk-pixbuf-2.0/gdk-pixbuf-query-loaders --update-cache
-
-        for icondir in /usr/share/icons/* ; do
-                if [ -d $icondir ] ; then
-                        ${GTKIC_CMD} -fqt  $icondir
-                fi
-        done
-fi
-}
-
-gtk_icon_cache_postrm() {
-if [ "x$D" != "x" ]; then
-        $INTERCEPT_DIR/postinst_intercept update_gtk_icon_cache ${PKG} \
-                mlprefix=${MLPREFIX} \
-                libdir=${libdir}
-else
-        for icondir in /usr/share/icons/* ; do
-                if [ -d $icondir ] ; then
-                        ${GTKIC_CMD} -qt  $icondir
-                fi
-        done
-fi
-}
-
-python populate_packages:append () {
-    packages = d.getVar('PACKAGES').split()
-    pkgdest =  d.getVar('PKGDEST')
-    
-    for pkg in packages:
-        icon_dir = '%s/%s/%s/icons' % (pkgdest, pkg, d.getVar('datadir'))
-        if not os.path.exists(icon_dir):
-            continue
-
-        bb.note("adding hicolor-icon-theme dependency to %s" % pkg)
-        rdepends = ' ' + d.getVar('MLPREFIX', False) + "hicolor-icon-theme"
-        d.appendVar('RDEPENDS:%s' % pkg, rdepends)
-
-        #gtk_icon_cache_postinst depend on gdk-pixbuf and gtk+3/gtk4
-        bb.note("adding gdk-pixbuf dependency to %s" % pkg)
-        rdepends = ' ' + d.getVar('MLPREFIX', False) + "gdk-pixbuf"
-        d.appendVar('RDEPENDS:%s' % pkg, rdepends)
-
-        bb.note("adding %s dependency to %s" % (d.getVar('GTKPN'), pkg))
-        rdepends = ' ' + d.getVar('MLPREFIX', False) + d.getVar('GTKPN')
-        d.appendVar('RDEPENDS:%s' % pkg, rdepends)
-
-        bb.note("adding gtk-icon-cache postinst and postrm scripts to %s" % pkg)
-
-        postinst = d.getVar('pkg_postinst:%s' % pkg)
-        if not postinst:
-            postinst = '#!/bin/sh\n'
-        postinst += d.getVar('gtk_icon_cache_postinst')
-        d.setVar('pkg_postinst:%s' % pkg, postinst)
-
-        postrm = d.getVar('pkg_postrm:%s' % pkg)
-        if not postrm:
-            postrm = '#!/bin/sh\n'
-        postrm += d.getVar('gtk_icon_cache_postrm')
-        d.setVar('pkg_postrm:%s' % pkg, postrm)
-}
-
diff --git a/meta/classes-recipe/gtk-immodules-cache.bbclass b/meta/classes-recipe/gtk-immodules-cache.bbclass
deleted file mode 100644
index 585838c105..0000000000
--- a/meta/classes-recipe/gtk-immodules-cache.bbclass
+++ /dev/null
@@ -1,80 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-# This class will update the inputmethod module cache for virtual keyboards
-#
-# Usage: Set GTKIMMODULES_PACKAGES to the packages that needs to update the inputmethod modules
-
-PACKAGE_WRITE_DEPS += "qemuwrapper-cross"
-
-GTKIMMODULES_PACKAGES ?= "${PN}"
-
-gtk_immodule_cache_postinst() {
-if [ "x$D" != "x" ]; then
-    $INTERCEPT_DIR/postinst_intercept update_gtk_immodules_cache ${PKG} \
-            mlprefix=${MLPREFIX} \
-            binprefix=${MLPREFIX} \
-            libdir=${libdir} \
-            libexecdir=${libexecdir} \
-            base_libdir=${base_libdir} \
-            bindir=${bindir}
-else
-    if [ ! -z `which gtk-query-immodules-2.0` ]; then
-        gtk-query-immodules-2.0 > ${libdir}/gtk-2.0/2.10.0/immodules.cache
-    fi
-    if [ ! -z `which gtk-query-immodules-3.0` ]; then
-        mkdir -p ${libdir}/gtk-3.0/3.0.0
-        gtk-query-immodules-3.0 > ${libdir}/gtk-3.0/3.0.0/immodules.cache
-    fi
-fi
-}
-
-gtk_immodule_cache_postrm() {
-if [ "x$D" != "x" ]; then
-    $INTERCEPT_DIR/postinst_intercept update_gtk_immodules_cache ${PKG} \
-            mlprefix=${MLPREFIX} \
-            binprefix=${MLPREFIX} \
-            libdir=${libdir} \
-            libexecdir=${libexecdir} \
-            base_libdir=${base_libdir} \
-            bindir=${bindir}
-else
-    if [ ! -z `which gtk-query-immodules-2.0` ]; then
-        gtk-query-immodules-2.0 > ${libdir}/gtk-2.0/2.10.0/immodules.cache
-    fi
-    if [ ! -z `which gtk-query-immodules-3.0` ]; then
-        gtk-query-immodules-3.0 > ${libdir}/gtk-3.0/3.0.0/immodules.cache
-    fi
-fi
-}
-
-python populate_packages:append () {
-    gtkimmodules_pkgs = d.getVar('GTKIMMODULES_PACKAGES').split()
-
-    for pkg in gtkimmodules_pkgs:
-            bb.note("adding gtk-immodule-cache postinst and postrm scripts to %s" % pkg)
-
-            postinst = d.getVar('pkg_postinst:%s' % pkg)
-            if not postinst:
-                postinst = '#!/bin/sh\n'
-            postinst += d.getVar('gtk_immodule_cache_postinst')
-            d.setVar('pkg_postinst:%s' % pkg, postinst)
-
-            postrm = d.getVar('pkg_postrm:%s' % pkg)
-            if not postrm:
-                postrm = '#!/bin/sh\n'
-            postrm += d.getVar('gtk_immodule_cache_postrm')
-            d.setVar('pkg_postrm:%s' % pkg, postrm)
-}
-
-python __anonymous() {
-    if not bb.data.inherits_class('native', d) and not bb.data.inherits_class('cross', d):
-        gtkimmodules_check = d.getVar('GTKIMMODULES_PACKAGES', False)
-        if not gtkimmodules_check:
-            bb_filename = d.getVar('FILE', False)
-            bb.fatal("ERROR: %s inherits gtk-immodules-cache but doesn't set GTKIMMODULES_PACKAGES" % bb_filename)
-}
-
diff --git a/meta/classes-recipe/image-artifact-names.bbclass b/meta/classes-recipe/image-artifact-names.bbclass
deleted file mode 100644
index bc76ff0e16..0000000000
--- a/meta/classes-recipe/image-artifact-names.bbclass
+++ /dev/null
@@ -1,41 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-##################################################################
-# Specific image creation and rootfs population info.
-##################################################################
-
-IMAGE_BASENAME ?= "${PN}"
-IMAGE_VERSION_SUFFIX ?= "-${DATETIME}"
-IMAGE_VERSION_SUFFIX[vardepsexclude] += "DATETIME SOURCE_DATE_EPOCH"
-IMAGE_NAME ?= "${IMAGE_LINK_NAME}${IMAGE_VERSION_SUFFIX}"
-IMAGE_LINK_NAME ?= "${IMAGE_BASENAME}${IMAGE_MACHINE_SUFFIX}${IMAGE_NAME_SUFFIX}"
-
-# This needs to stay in sync with IMAGE_LINK_NAME, but with INITRAMFS_IMAGE instead of IMAGE_BASENAME
-# and without ${IMAGE_NAME_SUFFIX} which all initramfs images should set to empty
-INITRAMFS_IMAGE_NAME ?= "${@['${INITRAMFS_IMAGE}${IMAGE_MACHINE_SUFFIX}', ''][d.getVar('INITRAMFS_IMAGE') == '']}"
-
-# The default DEPLOY_DIR_IMAGE is ${MACHINE} directory:
-# meta/conf/bitbake.conf:DEPLOY_DIR_IMAGE ?= "${DEPLOY_DIR}/images/${MACHINE}"
-# so many people find it unnecessary to include this suffix to every image
-# stored there, but other people often fetch various images for different
-# MACHINEs to the same downloads directory and then the suffix is very helpful
-# add separate variable for projects to decide which scheme works best for them
-# without understanding the IMAGE_NAME/IMAGE_LINK_NAME structure.
-IMAGE_MACHINE_SUFFIX ??= "-${MACHINE}"
-
-# IMAGE_NAME is the base name for everything produced when building images.
-# The actual image that contains the rootfs has an additional suffix (.rootfs
-# by default) followed by additional suffices which describe the format (.ext4,
-# .ext4.xz, etc.).
-IMAGE_NAME_SUFFIX ??= ".rootfs"
-
-python () {
-    if bb.data.inherits_class('deploy', d) and d.getVar("IMAGE_VERSION_SUFFIX") == "-${DATETIME}":
-        import datetime
-        d.setVar("IMAGE_VERSION_SUFFIX", "-" + datetime.datetime.fromtimestamp(int(d.getVar("SOURCE_DATE_EPOCH")), datetime.timezone.utc).strftime('%Y%m%d%H%M%S'))
-        d.setVarFlag("IMAGE_VERSION_SUFFIX", "vardepvalue", "")
-}
diff --git a/meta/classes-recipe/image-combined-dbg.bbclass b/meta/classes-recipe/image-combined-dbg.bbclass
deleted file mode 100644
index 729313739c..0000000000
--- a/meta/classes-recipe/image-combined-dbg.bbclass
+++ /dev/null
@@ -1,15 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-IMAGE_PREPROCESS_COMMAND:append = " combine_dbg_image"
-
-combine_dbg_image () {
-        if [ "${IMAGE_GEN_DEBUGFS}" = "1" -a -e ${IMAGE_ROOTFS}-dbg ]; then
-                # copy target files into -dbg rootfs, so it can be used for
-                # debug purposes directly
-                tar -C ${IMAGE_ROOTFS} -cf - . | tar -C ${IMAGE_ROOTFS}-dbg -xf -
-        fi
-}
diff --git a/meta/classes-recipe/image-container.bbclass b/meta/classes-recipe/image-container.bbclass
deleted file mode 100644
index d24b030453..0000000000
--- a/meta/classes-recipe/image-container.bbclass
+++ /dev/null
@@ -1,27 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-ROOTFS_BOOTSTRAP_INSTALL = ""
-IMAGE_TYPES_MASKED += "container"
-IMAGE_TYPEDEP:container = "tar.bz2"
-
-python __anonymous() {
-    if "container" in d.getVar("IMAGE_FSTYPES") and \
-       d.getVar("IMAGE_CONTAINER_NO_DUMMY") != "1" and \
-       "linux-dummy" not in d.getVar("PREFERRED_PROVIDER_virtual/kernel"):
-        msg = '"container" is in IMAGE_FSTYPES, but ' \
-              'PREFERRED_PROVIDER_virtual/kernel is not "linux-dummy". ' \
-              'Unless a particular kernel is needed, using linux-dummy will ' \
-              'prevent a kernel from being built, which can reduce ' \
-              'build times. If you don\'t want to use "linux-dummy", set ' \
-              '"IMAGE_CONTAINER_NO_DUMMY" to "1".'
-
-        # Raising skip recipe was Paul's clever idea. It causes the error to
-        # only be shown for the recipes actually requested to build, rather
-        # than bb.fatal which would appear for all recipes inheriting the
-        # class.
-        raise bb.parse.SkipRecipe(msg)
-}
diff --git a/meta/classes-recipe/image-live.bbclass b/meta/classes-recipe/image-live.bbclass
deleted file mode 100644
index c3054be630..0000000000
--- a/meta/classes-recipe/image-live.bbclass
+++ /dev/null
@@ -1,267 +0,0 @@
-# Copyright (C) 2004, Advanced Micro Devices, Inc.
-#
-# SPDX-License-Identifier: MIT
-
-# Creates a bootable image using syslinux, your kernel and an optional
-# initrd
-
-#
-# End result is two things:
-#
-# 1. A .hddimg file which is an msdos filesystem containing syslinux, a kernel,
-# an initrd and a rootfs image. These can be written to harddisks directly and
-# also booted on USB flash disks (write them there with dd).
-#
-# 2. A CD .iso image
-
-# Boot process is that the initrd will boot and process which label was selected
-# in syslinux. Actions based on the label are then performed (e.g. installing to
-# an hdd)
-
-# External variables (also used by syslinux.bbclass)
-# ${INITRD} - indicates a list of filesystem images to concatenate and use as an initrd (optional)
-# ${HDDIMG_ID} - FAT image volume-id
-# ${ROOTFS} - indicates a filesystem image to include as the root filesystem (optional)
-
-inherit live-vm-common image-artifact-names
-
-do_bootimg[depends] += "dosfstools-native:do_populate_sysroot \
-                        mtools-native:do_populate_sysroot \
-                        cdrtools-native:do_populate_sysroot \
-                        virtual/kernel:do_deploy \
-                        ${MLPREFIX}syslinux:do_populate_sysroot \
-                        syslinux-native:do_populate_sysroot \
-                        ${@'%s:do_image_%s' % (d.getVar('PN'), d.getVar('LIVE_ROOTFS_TYPE').replace('-', '_').split('.')[0]) if d.getVar('ROOTFS') else ''} \
-                        "
-
-
-LABELS_LIVE ?= "boot install"
-ROOT_LIVE ?= "root=/dev/ram0"
-INITRD_IMAGE_LIVE ?= "${MLPREFIX}core-image-minimal-initramfs"
-INITRD_LIVE ?= "${DEPLOY_DIR_IMAGE}/${INITRD_IMAGE_LIVE}${IMAGE_MACHINE_SUFFIX}.${@d.getVar('INITRAMFS_FSTYPES').split()[0]}"
-
-LIVE_ROOTFS_TYPE ?= "ext4"
-ROOTFS ?= "${IMGDEPLOYDIR}/${IMAGE_LINK_NAME}.${LIVE_ROOTFS_TYPE}"
-
-IMAGE_TYPEDEP:live = "${LIVE_ROOTFS_TYPE}"
-IMAGE_TYPEDEP:iso = "${LIVE_ROOTFS_TYPE}"
-IMAGE_TYPEDEP:hddimg = "${LIVE_ROOTFS_TYPE}"
-IMAGE_TYPES_MASKED += "live hddimg iso"
-
-python() {
-    image_b = d.getVar('IMAGE_BASENAME')
-    initrd_i = d.getVar('INITRD_IMAGE_LIVE')
-    if image_b == initrd_i:
-        bb.error('INITRD_IMAGE_LIVE %s cannot use image live, hddimg or iso.' % initrd_i)
-        bb.fatal('Check IMAGE_FSTYPES and INITRAMFS_FSTYPES settings.')
-    elif initrd_i:
-        d.appendVarFlag('do_bootimg', 'depends', ' %s:do_image_complete' % initrd_i)
-}
-
-HDDDIR = "${S}/hddimg"
-ISODIR = "${S}/iso"
-EFIIMGDIR = "${S}/efi_img"
-COMPACT_ISODIR = "${S}/iso.z"
-
-ISOLINUXDIR ?= "/isolinux"
-ISO_BOOTIMG = "isolinux/isolinux.bin"
-ISO_BOOTCAT = "isolinux/boot.cat"
-MKISOFS_OPTIONS = "-no-emul-boot -boot-load-size 4 -boot-info-table"
-
-BOOTIMG_VOLUME_ID   ?= "boot"
-BOOTIMG_EXTRA_SPACE ?= "512"
-
-populate_live() {
-    populate_kernel $1
-        if [ -s "${ROOTFS}" ]; then
-                install -m 0644 ${ROOTFS} $1/rootfs.img
-        fi
-}
-
-build_iso() {
-        # Only create an ISO if we have an INITRD and the live or iso image type was selected
-        if [ -z "${INITRD}" ] || [ "${@bb.utils.contains_any('IMAGE_FSTYPES', 'live iso', '1', '0', d)}" != "1" ]; then
-                bbnote "ISO image will not be created."
-                return
-        fi
-        # ${INITRD} is a list of multiple filesystem images
-        for fs in ${INITRD}
-        do
-                if [ ! -s "$fs" ]; then
-                        bbwarn "ISO image will not be created. $fs is invalid."
-                        return
-                fi
-        done
-
-        populate_live ${ISODIR}
-
-        if [ "${PCBIOS}" = "1" ]; then
-                syslinux_iso_populate ${ISODIR}
-        fi
-        if [ "${EFI}" = "1" ]; then
-                efi_iso_populate ${ISODIR}
-                build_fat_img ${EFIIMGDIR} ${ISODIR}/efi.img
-        fi
-
-        # EFI only
-        if [ "${PCBIOS}" != "1" ] && [ "${EFI}" = "1" ] ; then
-                # Work around bug in isohybrid where it requires isolinux.bin
-                # In the boot catalog, even though it is not used
-                mkdir -p ${ISODIR}/${ISOLINUXDIR}
-                install -m 0644 ${STAGING_DATADIR}/syslinux/isolinux.bin ${ISODIR}${ISOLINUXDIR}
-        fi
-
-        # We used to have support for zisofs; this is a relic of that
-        mkisofs_compress_opts="-r"
-
-        # Check the size of ${ISODIR}/rootfs.img, use mkisofs -iso-level 3
-        # when it exceeds 3.8GB, the specification is 4G - 1 bytes, we need
-        # leave a few space for other files.
-        mkisofs_iso_level=""
-
-        if [ -n "${ROOTFS}" ] && [ -s "${ROOTFS}" ]; then
-                rootfs_img_size=`stat -c '%s' ${ISODIR}/rootfs.img`
-                # 4080218931 = 3.8 * 1024 * 1024 * 1024
-                if [ $rootfs_img_size -gt 4080218931 ]; then
-                        bbnote "${ISODIR}/rootfs.img execeeds 3.8GB, using '-iso-level 3' for mkisofs"
-                        mkisofs_iso_level="-iso-level 3"
-                fi
-        fi
-
-        if [ "${PCBIOS}" = "1" ] && [ "${EFI}" != "1" ] ; then
-                # PCBIOS only media
-                mkisofs -V ${BOOTIMG_VOLUME_ID} \
-                        -o ${IMGDEPLOYDIR}/${IMAGE_NAME}.iso \
-                        -b ${ISO_BOOTIMG} -c ${ISO_BOOTCAT} \
-                        $mkisofs_compress_opts \
-                        ${MKISOFS_OPTIONS} $mkisofs_iso_level ${ISODIR}
-        else
-                # EFI only OR EFI+PCBIOS
-                mkisofs -A ${BOOTIMG_VOLUME_ID} -V ${BOOTIMG_VOLUME_ID} \
-                        -o ${IMGDEPLOYDIR}/${IMAGE_NAME}.iso \
-                        -b ${ISO_BOOTIMG} -c ${ISO_BOOTCAT} \
-                        $mkisofs_compress_opts ${MKISOFS_OPTIONS} $mkisofs_iso_level \
-                        -eltorito-alt-boot -eltorito-platform efi \
-                        -b efi.img -no-emul-boot \
-                        ${ISODIR}
-                isohybrid_args="-u"
-        fi
-
-        # EFI only does not need isohybrid
-        if [ "${PCBIOS}" = "1" ]  || [ "${EFI}" != "1" ]; then
-                isohybrid $isohybrid_args ${IMGDEPLOYDIR}/${IMAGE_NAME}.iso
-        fi
-}
-
-build_fat_img() {
-        FATSOURCEDIR=$1
-        FATIMG=$2
-
-        # Calculate the size required for the final image including the
-        # data and filesystem overhead.
-        # Sectors: 512 bytes
-        #  Blocks: 1024 bytes
-
-        # Determine the sector count just for the data
-        SECTORS=$(expr $(du --apparent-size -ks ${FATSOURCEDIR} | cut -f 1) \* 2)
-
-        # Account for the filesystem overhead. This includes directory
-        # entries in the clusters as well as the FAT itself.
-        # Assumptions:
-        #   FAT32 (12 or 16 may be selected by mkdosfs, but the extra
-        #   padding will be minimal on those smaller images and not
-        #   worth the logic here to caclulate the smaller FAT sizes)
-        #   < 16 entries per directory
-        #   8.3 filenames only
-
-        # 32 bytes per dir entry
-        DIR_BYTES=$(expr $(find ${FATSOURCEDIR} | tail -n +2 | wc -l) \* 32)
-        # 32 bytes for every end-of-directory dir entry
-        DIR_BYTES=$(expr $DIR_BYTES + $(expr $(find ${FATSOURCEDIR} -type d | tail -n +2 | wc -l) \* 32))
-        # 4 bytes per FAT entry per sector of data
-        FAT_BYTES=$(expr $SECTORS \* 4)
-        # 4 bytes per FAT entry per end-of-cluster list
-        FAT_BYTES=$(expr $FAT_BYTES + $(expr $(find ${FATSOURCEDIR} -type d | tail -n +2 | wc -l) \* 4))
-
-        # Use a ceiling function to determine FS overhead in sectors
-        DIR_SECTORS=$(expr $(expr $DIR_BYTES + 511) / 512)
-        # There are two FATs on the image
-        FAT_SECTORS=$(expr $(expr $(expr $FAT_BYTES + 511) / 512) \* 2)
-        SECTORS=$(expr $SECTORS + $(expr $DIR_SECTORS + $FAT_SECTORS))
-
-        # Determine the final size in blocks accounting for some padding
-        BLOCKS=$(expr $(expr $SECTORS / 2) + ${BOOTIMG_EXTRA_SPACE})
-
-        # mkdosfs will sometimes use FAT16 when it is not appropriate,
-        # resulting in a boot failure from SYSLINUX. Use FAT32 for
-        # images larger than 512MB, otherwise let mkdosfs decide.
-        if [ $(expr $BLOCKS / 1024) -gt 512 ]; then
-                FATSIZE="-F 32"
-        fi
-
-        # mkdosfs will fail if ${FATIMG} exists. Since we are creating an
-        # new image, it is safe to delete any previous image.
-        if [ -e ${FATIMG} ]; then
-                rm ${FATIMG}
-        fi
-
-        if [ -z "${HDDIMG_ID}" ]; then
-                mkdosfs ${FATSIZE} -n ${BOOTIMG_VOLUME_ID} ${MKDOSFS_EXTRAOPTS} -C ${FATIMG} \
-                        ${BLOCKS}
-        else
-                mkdosfs ${FATSIZE} -n ${BOOTIMG_VOLUME_ID} ${MKDOSFS_EXTRAOPTS} -C ${FATIMG} \
-                ${BLOCKS} -i ${HDDIMG_ID}
-        fi
-
-        # Copy FATSOURCEDIR recursively into the image file directly
-        mcopy -i ${FATIMG} -s ${FATSOURCEDIR}/* ::/
-}
-
-build_hddimg() {
-        # Create an HDD image
-        if [ "${@bb.utils.contains_any('IMAGE_FSTYPES', 'live hddimg', '1', '0', d)}" = "1" ] ; then
-                populate_live ${HDDDIR}
-
-                if [ "${PCBIOS}" = "1" ]; then
-                        syslinux_hddimg_populate ${HDDDIR}
-                fi
-                if [ "${EFI}" = "1" ]; then
-                        efi_hddimg_populate ${HDDDIR}
-                fi
-
-                # Check the size of ${HDDDIR}/rootfs.img, error out if it
-                # exceeds 4GB, it is the single file's max size of FAT fs.
-                if [ -f ${HDDDIR}/rootfs.img ]; then
-                        rootfs_img_size=`stat -c '%s' ${HDDDIR}/rootfs.img`
-                        max_size=`expr 4 \* 1024 \* 1024 \* 1024`
-                        if [ $rootfs_img_size -ge $max_size ]; then
-                                bberror "${HDDDIR}/rootfs.img rootfs size is greather than or equal to 4GB,"
-                                bberror "and this doesn't work on a FAT filesystem. You can either:"
-                                bberror "1) Reduce the size of rootfs.img, or,"
-                                bbfatal "2) Use wic, vmdk,vhd, vhdx or vdi instead of hddimg\n"
-                        fi
-                fi
-
-                build_fat_img ${HDDDIR} ${IMGDEPLOYDIR}/${IMAGE_NAME}.hddimg
-
-                if [ "${PCBIOS}" = "1" ]; then
-                        syslinux_hddimg_install
-                fi
-
-                chmod 644 ${IMGDEPLOYDIR}/${IMAGE_NAME}.hddimg
-        fi
-}
-
-python do_bootimg() {
-    set_live_vm_vars(d, 'LIVE')
-    if d.getVar("PCBIOS") == "1":
-        bb.build.exec_func('build_syslinux_cfg', d)
-    if d.getVar("EFI") == "1":
-        bb.build.exec_func('build_efi_cfg', d)
-    bb.build.exec_func('build_hddimg', d)
-    bb.build.exec_func('build_iso', d)
-    bb.build.exec_func('create_symlinks', d)
-}
-do_bootimg[subimages] = "hddimg iso"
-
-addtask bootimg before do_image_complete after do_rootfs
diff --git a/meta/classes-recipe/image-postinst-intercepts.bbclass b/meta/classes-recipe/image-postinst-intercepts.bbclass
deleted file mode 100644
index fc15926384..0000000000
--- a/meta/classes-recipe/image-postinst-intercepts.bbclass
+++ /dev/null
@@ -1,29 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-# Gather existing and candidate postinst intercepts from BBPATH
-POSTINST_INTERCEPTS_DIR ?= "${COREBASE}/scripts/postinst-intercepts"
-POSTINST_INTERCEPTS_PATHS ?= "${@':'.join('%s/postinst-intercepts' % p for p in '${BBPATH}'.split(':'))}:${POSTINST_INTERCEPTS_DIR}"
-
-python find_intercepts() {
-    intercepts = {}
-    search_paths = []
-    paths = d.getVar('POSTINST_INTERCEPTS_PATHS').split(':')
-    overrides = (':' + d.getVar('FILESOVERRIDES')).split(':') + ['']
-    search_paths = [os.path.join(p, op) for p in paths for op in overrides]
-    searched = oe.path.which_wild('*', ':'.join(search_paths), candidates=True)
-    files, chksums = [], []
-    for pathname, candidates in searched:
-        if os.path.isfile(pathname):
-            files.append(pathname)
-            chksums.append('%s:True' % pathname)
-            chksums.extend('%s:False' % c for c in candidates[:-1])
-
-    d.setVar('POSTINST_INTERCEPT_CHECKSUMS', ' '.join(chksums))
-    d.setVar('POSTINST_INTERCEPTS', ' '.join(files))
-}
-find_intercepts[eventmask] += "bb.event.RecipePreFinalise"
-addhandler find_intercepts
diff --git a/meta/classes-recipe/image.bbclass b/meta/classes-recipe/image.bbclass
deleted file mode 100644
index ccad308b93..0000000000
--- a/meta/classes-recipe/image.bbclass
+++ /dev/null
@@ -1,705 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-IMAGE_CLASSES ??= ""
-
-# rootfs bootstrap install
-# warning -  image-container resets this
-ROOTFS_BOOTSTRAP_INSTALL = "run-postinsts"
-
-# Handle inherits of any of the image classes we need
-IMGCLASSES = "rootfs_${IMAGE_PKGTYPE} image_types ${IMAGE_CLASSES}"
-# Only Linux SDKs support populate_sdk_ext, fall back to populate_sdk_base
-# in the non-Linux SDK_OS case, such as mingw32
-inherit populate_sdk_base
-IMGCLASSES += "${@['', 'populate_sdk_ext']['linux' in d.getVar("SDK_OS")]}"
-IMGCLASSES += "${@bb.utils.contains_any('IMAGE_FSTYPES', 'live iso hddimg', 'image-live', '', d)}"
-IMGCLASSES += "${@bb.utils.contains('IMAGE_FSTYPES', 'container', 'image-container', '', d)}"
-IMGCLASSES += "image_types_wic"
-IMGCLASSES += "rootfs-postcommands"
-IMGCLASSES += "image-postinst-intercepts"
-IMGCLASSES += "overlayfs-etc"
-inherit_defer ${IMGCLASSES}
-
-TOOLCHAIN_TARGET_TASK += "${PACKAGE_INSTALL}"
-TOOLCHAIN_TARGET_TASK_ATTEMPTONLY += "${PACKAGE_INSTALL_ATTEMPTONLY}"
-POPULATE_SDK_POST_TARGET_COMMAND += "rootfs_sysroot_relativelinks"
-
-LICENSE ?= "MIT"
-PACKAGES = ""
-DEPENDS += "depmodwrapper-cross cross-localedef-native"
-RDEPENDS += "${PACKAGE_INSTALL} ${LINGUAS_INSTALL} ${IMAGE_INSTALL_DEBUGFS}"
-RRECOMMENDS += "${PACKAGE_INSTALL_ATTEMPTONLY}"
-PATH:prepend = "${@":".join(all_multilib_tune_values(d, 'STAGING_BINDIR_CROSS').split())}:"
-
-INHIBIT_DEFAULT_DEPS = "1"
-
-# IMAGE_FEATURES may contain any available package group
-IMAGE_FEATURES ?= ""
-IMAGE_FEATURES[type] = "list"
-IMAGE_FEATURES[validitems] += "read-only-rootfs read-only-rootfs-delayed-postinsts stateless-rootfs empty-root-password allow-empty-password allow-root-login serial-autologin-root post-install-logging overlayfs-etc"
-
-# Generate companion debugfs?
-IMAGE_GEN_DEBUGFS ?= "0"
-
-# These packages will be installed as additional into debug rootfs
-IMAGE_INSTALL_DEBUGFS ?= ""
-
-# These packages will be removed from a read-only rootfs after all other
-# packages have been installed
-ROOTFS_RO_UNNEEDED ??= "update-rc.d base-passwd shadow ${VIRTUAL-RUNTIME_update-alternatives} ${ROOTFS_BOOTSTRAP_INSTALL}"
-
-# packages to install from features
-FEATURE_INSTALL = "${@' '.join(oe.packagegroup.required_packages(oe.data.typed_value('IMAGE_FEATURES', d), d))}"
-FEATURE_INSTALL[vardepvalue] = "${FEATURE_INSTALL}"
-FEATURE_INSTALL_OPTIONAL = "${@' '.join(oe.packagegroup.optional_packages(oe.data.typed_value('IMAGE_FEATURES', d), d))}"
-FEATURE_INSTALL_OPTIONAL[vardepvalue] = "${FEATURE_INSTALL_OPTIONAL}"
-
-# Define some very basic feature package groups
-FEATURE_PACKAGES_package-management = "${ROOTFS_PKGMANAGE}"
-SPLASH ?= "${@bb.utils.contains("MACHINE_FEATURES", "screen", "psplash", "", d)}"
-FEATURE_PACKAGES_splash = "${SPLASH}"
-
-IMAGE_INSTALL_COMPLEMENTARY = '${@complementary_globs("IMAGE_FEATURES", d)}'
-
-def check_image_features(d):
-    valid_features = (d.getVarFlag('IMAGE_FEATURES', 'validitems') or "").split()
-    valid_features += d.getVarFlags('COMPLEMENTARY_GLOB').keys()
-    for var in d:
-       if var.startswith("FEATURE_PACKAGES_"):
-           valid_features.append(var[17:])
-    valid_features.sort()
-
-    features = set(oe.data.typed_value('IMAGE_FEATURES', d))
-    for feature in features:
-        if feature not in valid_features:
-            if bb.utils.contains('EXTRA_IMAGE_FEATURES', feature, True, False, d):
-                raise bb.parse.SkipRecipe("'%s' in IMAGE_FEATURES (added via EXTRA_IMAGE_FEATURES) is not a valid image feature. Valid features: %s" % (feature, ' '.join(valid_features)))
-            else:
-                raise bb.parse.SkipRecipe("'%s' in IMAGE_FEATURES is not a valid image feature. Valid features: %s" % (feature, ' '.join(valid_features)))
-
-IMAGE_INSTALL ?= ""
-IMAGE_INSTALL[type] = "list"
-export PACKAGE_INSTALL ?= "${IMAGE_INSTALL} ${ROOTFS_BOOTSTRAP_INSTALL} ${FEATURE_INSTALL}"
-PACKAGE_INSTALL_ATTEMPTONLY ?= "${FEATURE_INSTALL_OPTIONAL}"
-
-IMGDEPLOYDIR = "${WORKDIR}/deploy-${PN}-image-complete"
-
-IMGMANIFESTDIR = "${WORKDIR}/image-task-manifest"
-
-IMAGE_OUTPUT_MANIFEST_DIR = "${WORKDIR}/deploy-image-output-manifest"
-IMAGE_OUTPUT_MANIFEST = "${IMAGE_OUTPUT_MANIFEST_DIR}/manifest.json"
-
-# Images are generally built explicitly, do not need to be part of world.
-EXCLUDE_FROM_WORLD = "1"
-
-USE_DEVFS ?= "1"
-USE_DEPMOD ?= "1"
-
-PID = "${@os.getpid()}"
-
-PACKAGE_ARCH = "${MACHINE_ARCH}"
-SSTATE_ARCHS_TUNEPKG = "${@all_multilib_tune_values(d, 'TUNE_PKGARCH')}"
-
-LDCONFIGDEPEND ?= "ldconfig-native:do_populate_sysroot"
-LDCONFIGDEPEND:libc-musl = ""
-
-# This is needed to have depmod data in PKGDATA_DIR,
-# but if you're building small initramfs image
-# e.g. to include it in your kernel, you probably
-# don't want this dependency, which is causing dependency loop
-KERNELDEPMODDEPEND ?= "virtual/kernel:do_packagedata"
-
-do_rootfs[depends] += " \
-    makedevs-native:do_populate_sysroot virtual/fakeroot-native:do_populate_sysroot ${LDCONFIGDEPEND} \
-    virtual/update-alternatives-native:do_populate_sysroot update-rc.d-native:do_populate_sysroot \
-    ${KERNELDEPMODDEPEND} \
-"
-do_rootfs[recrdeptask] += "do_packagedata"
-
-def rootfs_command_variables(d):
-    return ['ROOTFS_POSTPROCESS_COMMAND','ROOTFS_PREPROCESS_COMMAND','ROOTFS_POSTINSTALL_COMMAND','ROOTFS_POSTUNINSTALL_COMMAND','OPKG_PREPROCESS_COMMANDS','OPKG_POSTPROCESS_COMMANDS','IMAGE_POSTPROCESS_COMMAND',
-            'IMAGE_PREPROCESS_COMMAND','RPM_PREPROCESS_COMMANDS','RPM_POSTPROCESS_COMMANDS','DEB_PREPROCESS_COMMANDS','DEB_POSTPROCESS_COMMANDS']
-
-python () {
-    variables = rootfs_command_variables(d)
-    for var in variables:
-        d.setVarFlag(var, 'vardeps', d.getVar(var))
-}
-
-def rootfs_variables(d):
-    from oe.rootfs import variable_depends
-    variables = ['IMAGE_DEVICE_TABLE','IMAGE_DEVICE_TABLES','BUILD_IMAGES_FROM_FEEDS','IMAGE_TYPES_MASKED','IMAGE_ROOTFS_ALIGNMENT','IMAGE_OVERHEAD_FACTOR','IMAGE_ROOTFS_SIZE','IMAGE_ROOTFS_EXTRA_SPACE',
-                 'IMAGE_ROOTFS_MAXSIZE','IMAGE_NAME','IMAGE_LINK_NAME','IMAGE_MANIFEST','DEPLOY_DIR_IMAGE','IMAGE_FSTYPES','IMAGE_INSTALL_COMPLEMENTARY','IMAGE_LINGUAS', 'IMAGE_LINGUAS_COMPLEMENTARY', 'IMAGE_LOCALES_ARCHIVE',
-                 'MULTILIBRE_ALLOW_REP','MULTILIB_TEMP_ROOTFS','MULTILIB_VARIANTS','MULTILIBS','ALL_MULTILIB_PACKAGE_ARCHS','MULTILIB_GLOBAL_VARIANTS','BAD_RECOMMENDATIONS','NO_RECOMMENDATIONS',
-                 'PACKAGE_ARCHS','PACKAGE_CLASSES','TARGET_VENDOR','TARGET_ARCH','TARGET_OS','OVERRIDES','BBEXTENDVARIANT','FEED_DEPLOYDIR_BASE_URI','INTERCEPT_DIR','USE_DEVFS',
-                 'CONVERSIONTYPES', 'IMAGE_GEN_DEBUGFS', 'ROOTFS_RO_UNNEEDED', 'IMGDEPLOYDIR', 'PACKAGE_EXCLUDE_COMPLEMENTARY', 'REPRODUCIBLE_TIMESTAMP_ROOTFS', 'IMAGE_INSTALL_DEBUGFS']
-    variables.extend(rootfs_command_variables(d))
-    variables.extend(variable_depends(d))
-    return " ".join(variables)
-
-do_rootfs[vardeps] += "${@rootfs_variables(d)}"
-
-# This is needed to have kernel image in DEPLOY_DIR.
-# This follows many common usecases and user expectations.
-# But if you are building an image which doesn't need the kernel image at all,
-# you can unset this variable manually.
-KERNEL_DEPLOY_DEPEND ?= "virtual/kernel:do_deploy"
-do_build[depends] += "${KERNEL_DEPLOY_DEPEND}"
-
-
-python () {
-    def extraimage_getdepends(task):
-        deps = ""
-        for dep in (d.getVar('EXTRA_IMAGEDEPENDS') or "").split():
-            if ":" in dep:
-                deps += " %s " % (dep)
-            else:
-                deps += " %s:%s" % (dep, task)
-        return deps
-
-    d.appendVarFlag('do_image_complete', 'depends', extraimage_getdepends('do_populate_sysroot'))
-
-    deps = " " + imagetypes_getdepends(d)
-    d.appendVarFlag('do_rootfs', 'depends', deps)
-
-    #process IMAGE_FEATURES, we must do this before runtime_mapping_rename
-    #Check for replaces image features
-    features = set(oe.data.typed_value('IMAGE_FEATURES', d))
-    remain_features = features.copy()
-    for feature in features:
-        replaces = set((d.getVar("IMAGE_FEATURES_REPLACES_%s" % feature) or "").split())
-        remain_features -= replaces
-
-    #Check for conflict image features
-    for feature in remain_features:
-        conflicts = set((d.getVar("IMAGE_FEATURES_CONFLICTS_%s" % feature) or "").split())
-        temp = conflicts & remain_features
-        if temp:
-            bb.fatal("%s contains conflicting IMAGE_FEATURES %s %s" % (d.getVar('PN'), feature, ' '.join(list(temp))))
-
-    d.setVar('IMAGE_FEATURES', ' '.join(sorted(list(remain_features))))
-
-    check_image_features(d)
-}
-
-IMAGE_POSTPROCESS_COMMAND ?= ""
-
-IMAGE_LINGUAS ??= ""
-
-LINGUAS_INSTALL ?= "${@" ".join(map(lambda s: "locale-base-%s" % s, d.getVar('IMAGE_LINGUAS').split()))}"
-
-# per default create a locale archive
-IMAGE_LOCALES_ARCHIVE ?= '1'
-
-# Prefer image, but use the fallback files for lookups if the image ones
-# aren't yet available.
-PSEUDO_PASSWD = "${IMAGE_ROOTFS}:${STAGING_DIR_NATIVE}"
-
-PACKAGE_EXCLUDE ??= ""
-PACKAGE_EXCLUDE[type] = "list"
-
-fakeroot python do_rootfs () {
-    from oe.rootfs import create_rootfs
-    from oe.manifest import create_manifest
-    import logging
-    import oe.packagedata
-
-    logger = d.getVar('BB_TASK_LOGGER', False)
-    if logger:
-        logcatcher = bb.utils.LogCatcher()
-        logger.addHandler(logcatcher)
-    else:
-        logcatcher = None
-
-    # NOTE: if you add, remove or significantly refactor the stages of this
-    # process then you should recalculate the weightings here. This is quite
-    # easy to do - just change the MultiStageProgressReporter line temporarily
-    # to pass debug=True as the last parameter and you'll get a printout of
-    # the weightings as well as a map to the lines where next_stage() was
-    # called. Of course this isn't critical, but it helps to keep the progress
-    # reporting accurate.
-    stage_weights = [1, 203, 354, 186, 65, 4228, 1, 353, 49, 330, 382, 23, 1]
-    progress_reporter = bb.progress.MultiStageProgressReporter(d, stage_weights)
-    progress_reporter.next_stage()
-
-    # Handle package exclusions
-    excl_pkgs = d.getVar("PACKAGE_EXCLUDE").split()
-    inst_pkgs = d.getVar("PACKAGE_INSTALL").split()
-    inst_attempt_pkgs = d.getVar("PACKAGE_INSTALL_ATTEMPTONLY").split()
-
-    d.setVar('PACKAGE_INSTALL_ORIG', ' '.join(inst_pkgs))
-    d.setVar('PACKAGE_INSTALL_ATTEMPTONLY', ' '.join(inst_attempt_pkgs))
-
-    for pkg in excl_pkgs:
-        if pkg in inst_pkgs:
-            bb.warn("Package %s, set to be excluded, is in %s PACKAGE_INSTALL (%s).  It will be removed from the list." % (pkg, d.getVar('PN'), inst_pkgs))
-            inst_pkgs.remove(pkg)
-
-        if pkg in inst_attempt_pkgs:
-            bb.warn("Package %s, set to be excluded, is in %s PACKAGE_INSTALL_ATTEMPTONLY (%s).  It will be removed from the list." % (pkg, d.getVar('PN'), inst_pkgs))
-            inst_attempt_pkgs.remove(pkg)
-
-    d.setVar("PACKAGE_INSTALL", ' '.join(inst_pkgs))
-    d.setVar("PACKAGE_INSTALL_ATTEMPTONLY", ' '.join(inst_attempt_pkgs))
-
-    # Ensure we handle package name remapping
-    # We have to delay the runtime_mapping_rename until just before rootfs runs
-    # otherwise, the multilib renaming could step in and squash any fixups that
-    # may have occurred.
-    pn = d.getVar('PN')
-    oe.packagedata.runtime_mapping_rename("PACKAGE_INSTALL", pn, d)
-    oe.packagedata.runtime_mapping_rename("PACKAGE_INSTALL_ATTEMPTONLY", pn, d)
-    oe.packagedata.runtime_mapping_rename("BAD_RECOMMENDATIONS", pn, d)
-
-    # Generate the initial manifest
-    create_manifest(d)
-
-    progress_reporter.next_stage()
-
-    # generate rootfs
-    d.setVarFlag('REPRODUCIBLE_TIMESTAMP_ROOTFS', 'export', '1')
-    create_rootfs(d, progress_reporter=progress_reporter, logcatcher=logcatcher)
-
-    progress_reporter.finish()
-}
-do_rootfs[dirs] = "${TOPDIR}"
-do_rootfs[cleandirs] += "${IMAGE_ROOTFS} ${IMGDEPLOYDIR} ${S}"
-do_rootfs[file-checksums] += "${POSTINST_INTERCEPT_CHECKSUMS}"
-addtask rootfs after do_prepare_recipe_sysroot
-
-fakeroot python do_image () {
-    from oe.utils import execute_pre_post_process
-
-    d.setVarFlag('REPRODUCIBLE_TIMESTAMP_ROOTFS', 'export', '1')
-    pre_process_cmds = d.getVar("IMAGE_PREPROCESS_COMMAND")
-
-    execute_pre_post_process(d, pre_process_cmds)
-}
-do_image[dirs] = "${TOPDIR}"
-do_image[cleandirs] += "${IMGMANIFESTDIR}"
-addtask do_image after do_rootfs
-
-fakeroot python do_image_complete () {
-    from oe.utils import execute_pre_post_process
-    from pathlib import Path
-    import json
-
-    post_process_cmds = d.getVar("IMAGE_POSTPROCESS_COMMAND")
-
-    execute_pre_post_process(d, post_process_cmds)
-
-    image_manifest_dir = Path(d.getVar('IMGMANIFESTDIR'))
-
-    data = []
-
-    for manifest_path in image_manifest_dir.glob("*.json"):
-        with manifest_path.open("r") as f:
-            data.extend(json.load(f))
-
-    with open(d.getVar("IMAGE_OUTPUT_MANIFEST"), "w") as f:
-        json.dump(data, f)
-}
-do_image_complete[dirs] = "${TOPDIR}"
-SSTATETASKS += "do_image_complete"
-SSTATE_SKIP_CREATION:task-image-complete = '1'
-do_image_complete[sstate-inputdirs] = "${IMGDEPLOYDIR}"
-do_image_complete[sstate-outputdirs] = "${DEPLOY_DIR_IMAGE}"
-do_image_complete[stamp-extra-info] = "${MACHINE_ARCH}"
-do_image_complete[sstate-plaindirs] += "${IMAGE_OUTPUT_MANIFEST_DIR}"
-do_image_complete[dirs] += "${IMAGE_OUTPUT_MANIFEST_DIR}"
-addtask do_image_complete after do_image before do_build
-python do_image_complete_setscene () {
-    sstate_setscene(d)
-}
-addtask do_image_complete_setscene
-
-# Add image-level QA/sanity checks to IMAGE_QA_COMMANDS
-#
-# IMAGE_QA_COMMANDS += " \
-#     image_check_everything_ok \
-# "
-#
-# This task runs all functions in IMAGE_QA_COMMANDS after the rootfs
-# construction has completed in order to validate the resulting image.
-#
-# The functions should use ${IMAGE_ROOTFS} to find the unpacked rootfs
-# directory, which if QA passes will be the basis for the images.
-#
-# The functions are expected to call oe.qa.handle_error() to report any
-# problems.
-fakeroot python do_image_qa () {
-    qa_cmds = (d.getVar('IMAGE_QA_COMMANDS') or '').split()
-
-    for cmd in qa_cmds:
-        bb.build.exec_func(cmd, d)
-
-    oe.qa.exit_if_errors(d)
-}
-addtask do_image_qa after do_rootfs before do_image
-
-SSTATETASKS += "do_image_qa"
-SSTATE_SKIP_CREATION:task-image-qa = '1'
-do_image_qa[sstate-inputdirs] = ""
-do_image_qa[sstate-outputdirs] = ""
-python do_image_qa_setscene () {
-    sstate_setscene(d)
-}
-addtask do_image_qa_setscene
-
-def setup_debugfs_variables(d):
-    d.appendVar('IMAGE_ROOTFS', '-dbg')
-    if d.getVar('IMAGE_LINK_NAME'):
-        d.appendVar('IMAGE_LINK_NAME', '-dbg')
-    d.appendVar('IMAGE_NAME','-dbg')
-    d.setVar('IMAGE_BUILDING_DEBUGFS', 'true')
-    debugfs_image_fstypes = d.getVar('IMAGE_FSTYPES_DEBUGFS')
-    if debugfs_image_fstypes:
-        d.setVar('IMAGE_FSTYPES', debugfs_image_fstypes)
-
-python setup_debugfs () {
-    setup_debugfs_variables(d)
-}
-
-python () {
-    vardeps = set()
-    # We allow CONVERSIONTYPES to have duplicates. That avoids breaking
-    # derived distros when OE-core or some other layer independently adds
-    # the same type. There is still only one command for each type, but
-    # presumably the commands will do the same when the type is the same,
-    # even when added in different places.
-    #
-    # Without de-duplication, gen_conversion_cmds() below
-    # would create the same compression command multiple times.
-    ctypes = set(d.getVar('CONVERSIONTYPES').split())
-    old_overrides = d.getVar('OVERRIDES', False)
-
-    def _image_base_type(type):
-        basetype = type
-        for ctype in ctypes:
-            if type.endswith("." + ctype):
-                basetype = type[:-len("." + ctype)]
-                break
-
-        if basetype != type:
-            # New base type itself might be generated by a conversion command.
-            basetype = _image_base_type(basetype)
-
-        return basetype
-
-    basetypes = {}
-    alltypes = d.getVar('IMAGE_FSTYPES').split()
-    typedeps = {}
-
-    if d.getVar('IMAGE_GEN_DEBUGFS') == "1":
-        debugfs_fstypes = d.getVar('IMAGE_FSTYPES_DEBUGFS').split()
-        for t in debugfs_fstypes:
-            alltypes.append("debugfs_" + t)
-
-    def _add_type(t):
-        baset = _image_base_type(t)
-        input_t = t
-        if baset not in basetypes:
-            basetypes[baset]= []
-        if t not in basetypes[baset]:
-            basetypes[baset].append(t)
-        debug = ""
-        if t.startswith("debugfs_"):
-            t = t[8:]
-            debug = "debugfs_"
-        deps = (d.getVar('IMAGE_TYPEDEP:' + t) or "").split()
-        vardeps.add('IMAGE_TYPEDEP:' + t)
-        if baset not in typedeps:
-            typedeps[baset] = set()
-        deps = [debug + dep for dep in deps]
-        for dep in deps:
-            if dep not in alltypes:
-                alltypes.append(dep)
-            _add_type(dep)
-            basedep = _image_base_type(dep)
-            typedeps[baset].add(basedep)
-
-        if baset != input_t:
-            _add_type(baset)
-
-    for t in alltypes[:]:
-        _add_type(t)
-
-    d.appendVarFlag('do_image', 'vardeps', ' '.join(vardeps))
-
-    maskedtypes = (d.getVar('IMAGE_TYPES_MASKED') or "").split()
-    maskedtypes = [dbg + t for t in maskedtypes for dbg in ("", "debugfs_")]
-
-    for t in basetypes:
-        vardeps = set()
-        cmds = []
-        subimages = []
-        realt = t
-
-        if t in maskedtypes:
-            continue
-
-        localdata = bb.data.createCopy(d)
-        debug = ""
-        if t.startswith("debugfs_"):
-            setup_debugfs_variables(localdata)
-            debug = "setup_debugfs "
-            realt = t[8:]
-        localdata.setVar('OVERRIDES', '%s:%s' % (realt, old_overrides))
-        localdata.setVar('type', realt)
-        # Delete DATETIME so we don't expand any references to it now
-        # This means the task's hash can be stable rather than having hardcoded
-        # date/time values. It will get expanded at execution time.
-        # Similarly TMPDIR since otherwise we see QA stamp comparision problems
-        # Expand PV else it can trigger get_srcrev which can fail due to these variables being unset
-        localdata.setVar('PV', d.getVar('PV'))
-        localdata.delVar('DATETIME')
-        localdata.delVar('DATE')
-        localdata.delVar('TMPDIR')
-        localdata.delVar('IMAGE_VERSION_SUFFIX')
-        vardepsexclude = (d.getVarFlag('IMAGE_CMD:' + realt, 'vardepsexclude') or '').split()
-        for dep in vardepsexclude:
-            localdata.delVar(dep)
-
-        image_cmd = localdata.getVar("IMAGE_CMD")
-        vardeps.add('IMAGE_CMD:' + realt)
-        if image_cmd:
-            cmds.append("\t" + image_cmd)
-        else:
-            bb.fatal("No IMAGE_CMD defined for IMAGE_FSTYPES entry '%s' - possibly invalid type name or missing support class" % t)
-        cmds.append(localdata.expand("\tcd ${IMGDEPLOYDIR}"))
-
-        # Since a copy of IMAGE_CMD:xxx will be inlined within do_image_xxx,
-        # prevent a redundant copy of IMAGE_CMD:xxx being emitted as a function.
-        d.delVarFlag('IMAGE_CMD:' + realt, 'func')
-
-        rm_tmp_images = set()
-        def gen_conversion_cmds(bt):
-            for ctype in sorted(ctypes):
-                if bt.endswith("." + ctype):
-                    type = bt[0:-len(ctype) - 1]
-                    original_type = type
-                    if type.startswith("debugfs_"):
-                        type = type[8:]
-                    # Create input image first.
-                    gen_conversion_cmds(type)
-                    localdata.setVar('type', type)
-                    cmd = "\t" + localdata.getVar("CONVERSION_CMD:" + ctype)
-                    if cmd not in cmds:
-                        cmds.append(cmd)
-                    vardeps.add('CONVERSION_CMD:' + ctype)
-                    subimage = type + "." + ctype
-                    if subimage not in subimages:
-                        subimages.append(subimage)
-                    if original_type not in alltypes:
-                        rm_tmp_images.add(localdata.expand("${IMAGE_NAME}.${type}"))
-
-        for bt in basetypes[t]:
-            gen_conversion_cmds(bt)
-
-        localdata.setVar('type', realt)
-        if t not in alltypes:
-            rm_tmp_images.add(localdata.expand("${IMAGE_NAME}.${type}"))
-        else:
-            subimages.append(realt)
-
-        # Clean up after applying all conversion commands. Some of them might
-        # use the same input, therefore we cannot delete sooner without applying
-        # some complex dependency analysis.
-        for image in sorted(rm_tmp_images):
-            cmds.append("\trm " + image)
-
-        after = 'do_image'
-        for dep in typedeps[t]:
-            after += ' do_image_%s' % dep.replace("-", "_").replace(".", "_")
-
-        task = "do_image_%s" % t.replace("-", "_").replace(".", "_")
-
-        d.setVar(task, '\n'.join(cmds))
-        d.setVarFlag(task, 'func', '1')
-        d.setVarFlag(task, 'fakeroot', '1')
-        d.setVarFlag(task, 'imagetype', t)
-
-        d.appendVarFlag(task, 'prefuncs', ' ' + debug + ' set_image_size')
-        d.prependVarFlag(task, 'postfuncs', 'create_symlinks ')
-        d.appendVarFlag(task, 'subimages', ' ' + ' '.join(subimages))
-        d.appendVarFlag(task, 'vardeps', ' ' + ' '.join(vardeps))
-        d.appendVarFlag(task, 'vardepsexclude', ' DATETIME DATE ' + ' '.join(vardepsexclude))
-        d.appendVarFlag(task, 'postfuncs', ' write_image_output_manifest')
-
-        bb.debug(2, "Adding task %s before %s, after %s" % (task, 'do_image_complete', after))
-        bb.build.addtask(task, 'do_image_complete', after, d)
-}
-
-#
-# Compute the rootfs size
-#
-def get_rootfs_size(d):
-    import subprocess, oe.utils
-
-    rootfs_alignment = int(d.getVar('IMAGE_ROOTFS_ALIGNMENT'))
-    overhead_factor = float(d.getVar('IMAGE_OVERHEAD_FACTOR'))
-    rootfs_req_size = int(d.getVar('IMAGE_ROOTFS_SIZE'))
-    rootfs_extra_space = eval(d.getVar('IMAGE_ROOTFS_EXTRA_SPACE'))
-    rootfs_maxsize = d.getVar('IMAGE_ROOTFS_MAXSIZE')
-    image_fstypes = d.getVar('IMAGE_FSTYPES') or ''
-    initramfs_fstypes = d.getVar('INITRAMFS_FSTYPES') or ''
-    initramfs_maxsize = d.getVar('INITRAMFS_MAXSIZE')
-
-    size_kb = oe.utils.directory_size(d.getVar("IMAGE_ROOTFS")) / 1024
-
-    base_size = size_kb * overhead_factor
-    bb.debug(1, '%f = %d * %f' % (base_size, size_kb, overhead_factor))
-    base_size2 = max(base_size, rootfs_req_size) + rootfs_extra_space
-    bb.debug(1, '%f = max(%f, %d)[%f] + %d' % (base_size2, base_size, rootfs_req_size, max(base_size, rootfs_req_size), rootfs_extra_space))
-
-    base_size = base_size2
-    if base_size != int(base_size):
-        base_size = int(base_size + 1)
-    else:
-        base_size = int(base_size)
-    bb.debug(1, '%f = int(%f)' % (base_size, base_size2))
-
-    base_size_saved = base_size
-    base_size += rootfs_alignment - 1
-    base_size -= base_size % rootfs_alignment
-    bb.debug(1, '%d = aligned(%d)' % (base_size, base_size_saved))
-
-    # Do not check image size of the debugfs image. This is not supposed
-    # to be deployed, etc. so it doesn't make sense to limit the size
-    # of the debug.
-    if (d.getVar('IMAGE_BUILDING_DEBUGFS') or "") == "true":
-        bb.debug(1, 'returning debugfs size %d' % (base_size))
-        return base_size
-
-    # Check the rootfs size against IMAGE_ROOTFS_MAXSIZE (if set)
-    if rootfs_maxsize:
-        rootfs_maxsize_int = int(rootfs_maxsize)
-        if base_size > rootfs_maxsize_int:
-            bb.fatal("The rootfs size %d(K) exceeds IMAGE_ROOTFS_MAXSIZE: %d(K)" % \
-                (base_size, rootfs_maxsize_int))
-
-    # Check the initramfs size against INITRAMFS_MAXSIZE (if set)
-    if image_fstypes == initramfs_fstypes != ''  and initramfs_maxsize:
-        initramfs_maxsize_int = int(initramfs_maxsize)
-        if base_size > initramfs_maxsize_int:
-            bb.error("The initramfs size %d(K) exceeds INITRAMFS_MAXSIZE: %d(K)" % \
-                (base_size, initramfs_maxsize_int))
-            bb.error("You can set INITRAMFS_MAXSIZE a larger value. Usually, it should")
-            bb.fatal("be less than 1/2 of ram size, or you may fail to boot it.\n")
-
-    bb.debug(1, 'returning %d' % (base_size))
-    return base_size
-
-python set_image_size () {
-        rootfs_size = get_rootfs_size(d)
-        d.setVar('ROOTFS_SIZE', str(rootfs_size))
-        d.setVarFlag('ROOTFS_SIZE', 'export', '1')
-}
-
-#
-# Create symlinks to the newly created image
-#
-python create_symlinks() {
-
-    deploy_dir = d.getVar('IMGDEPLOYDIR')
-    img_name = d.getVar('IMAGE_NAME')
-    link_name = d.getVar('IMAGE_LINK_NAME')
-    manifest_name = d.getVar('IMAGE_MANIFEST')
-    taskname = d.getVar("BB_CURRENTTASK")
-    subimages = (d.getVarFlag("do_" + taskname, 'subimages', False) or "").split()
-
-    if not link_name:
-        return
-    for type in subimages:
-        dst = os.path.join(deploy_dir, link_name + "." + type)
-        src = img_name + "." + type
-        if os.path.exists(os.path.join(deploy_dir, src)):
-            bb.note("Creating symlink: %s -> %s" % (dst, src))
-            if os.path.islink(dst):
-                os.remove(dst)
-            os.symlink(src, dst)
-        else:
-            bb.note("Skipping symlink, source does not exist: %s -> %s" % (dst, src))
-}
-
-python write_image_output_manifest() {
-    import json
-    from pathlib import Path
-
-    taskname = d.getVar("BB_CURRENTTASK")
-    image_deploy_dir = Path(d.getVar('IMGDEPLOYDIR'))
-    image_manifest_dir = Path(d.getVar('IMGMANIFESTDIR'))
-    manifest_path = image_manifest_dir / ("do_" + d.getVar("BB_CURRENTTASK") + ".json")
-
-    image_name = d.getVar("IMAGE_NAME")
-    image_basename = d.getVar("IMAGE_BASENAME")
-    machine = d.getVar("MACHINE")
-
-    subimages = (d.getVarFlag("do_" + taskname, 'subimages', False) or "").split()
-    imagetype = d.getVarFlag("do_" + taskname, 'imagetype', False)
-
-    data = {
-        "taskname": taskname,
-        "imagetype": imagetype,
-        "images": []
-    }
-
-    for type in subimages:
-        image_filename = image_name + "." + type
-        image_path = image_deploy_dir / image_filename
-        if not image_path.exists():
-            continue
-        data["images"].append({
-            "filename": image_filename,
-        })
-
-    with manifest_path.open("w") as f:
-        json.dump([data], f)
-}
-
-MULTILIBRE_ALLOW_REP += "${base_bindir} ${base_sbindir} ${bindir} ${sbindir} ${libexecdir} ${sysconfdir} ${nonarch_base_libdir}/udev /lib/modules/[^/]*/modules.*"
-MULTILIB_CHECK_FILE = "${WORKDIR}/multilib_check.py"
-MULTILIB_TEMP_ROOTFS = "${WORKDIR}/multilib"
-
-PSEUDO_INCLUDE_PATHS .= ",${MULTILIB_TEMP_ROOTFS}"
-
-do_fetch[noexec] = "1"
-do_unpack[noexec] = "1"
-do_patch[noexec] = "1"
-do_configure[noexec] = "1"
-do_compile[noexec] = "1"
-do_install[noexec] = "1"
-deltask do_populate_lic
-deltask do_populate_sysroot
-do_package[noexec] = "1"
-deltask do_package_qa
-deltask do_packagedata
-deltask do_package_write_ipk
-deltask do_package_write_deb
-deltask do_package_write_rpm
-
-create_merged_usr_symlinks_rootfs() {
-    create_merged_usr_symlinks ${IMAGE_ROOTFS}
-}
-
-ROOTFS_PREPROCESS_COMMAND += "${@bb.utils.contains('DISTRO_FEATURES', 'usrmerge', 'create_merged_usr_symlinks_rootfs', '',d)}"
-
-reproducible_final_image_task () {
-    if [ "$REPRODUCIBLE_TIMESTAMP_ROOTFS" = "" ]; then
-        REPRODUCIBLE_TIMESTAMP_ROOTFS=`git -C "${COREBASE}" log -1 --pretty=%ct 2>/dev/null` || true
-        if [ "$REPRODUCIBLE_TIMESTAMP_ROOTFS" = "" ]; then
-            REPRODUCIBLE_TIMESTAMP_ROOTFS=`stat -c%Y ${@bb.utils.which(d.getVar("BBPATH"), "conf/bitbake.conf")}`
-        fi
-    fi
-    # Set mtime of all files to a reproducible value
-    bbnote "reproducible_final_image_task: mtime set to $REPRODUCIBLE_TIMESTAMP_ROOTFS"
-    find  ${IMAGE_ROOTFS} -print0 | xargs -0 touch -h  --date=@$REPRODUCIBLE_TIMESTAMP_ROOTFS
-}
-
-IMAGE_PREPROCESS_COMMAND:append = " reproducible_final_image_task "
-
-CVE_PRODUCT = ""
diff --git a/meta/classes-recipe/image_types.bbclass b/meta/classes-recipe/image_types.bbclass
deleted file mode 100644
index e6ef0ce11e..0000000000
--- a/meta/classes-recipe/image_types.bbclass
+++ /dev/null
@@ -1,396 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-# The default aligment of the size of the rootfs is set to 1KiB. In case
-# you're using the SD card emulation of a QEMU system simulator you may
-# set this value to 2048 (2MiB alignment).
-IMAGE_ROOTFS_ALIGNMENT ?= "1"
-
-def imagetypes_getdepends(d):
-    def adddep(depstr, deps):
-        for d in (depstr or "").split():
-            # Add task dependency if not already present
-            if ":" not in d:
-                d += ":do_populate_sysroot"
-            deps.add(d)
-
-    # Take a type in the form of foo.bar.car and split it into the items
-    # needed for the image deps "foo", and the conversion deps ["bar", "car"]
-    def split_types(typestring):
-        types = typestring.split(".")
-        return types[0], types[1:]
-
-    fstypes = set((d.getVar('IMAGE_FSTYPES') or "").split())
-    fstypes |= set((d.getVar('IMAGE_FSTYPES_DEBUGFS') or "").split())
-
-    deprecated = set()
-    deps = set()
-    for typestring in fstypes:
-        basetype, resttypes = split_types(typestring)
-
-        var = "IMAGE_DEPENDS_%s" % basetype
-        if d.getVar(var) is not None:
-            deprecated.add(var)
-
-        for typedepends in (d.getVar("IMAGE_TYPEDEP:%s" % basetype) or "").split():
-            base, rest = split_types(typedepends)
-            resttypes += rest
-
-            var = "IMAGE_DEPENDS_%s" % base
-            if d.getVar(var) is not None:
-                deprecated.add(var)
-
-        for ctype in resttypes:
-            adddep(d.getVar("CONVERSION_DEPENDS_%s" % ctype), deps)
-            adddep(d.getVar("COMPRESS_DEPENDS_%s" % ctype), deps)
-
-    if deprecated:
-        bb.fatal('Deprecated variable(s) found: "%s". '
-                 'Use do_image_<type>[depends] += "<recipe>:<task>" instead' % ', '.join(deprecated))
-
-    # Sort the set so that ordering is consistant
-    return " ".join(sorted(deps))
-
-XZ_COMPRESSION_LEVEL ?= "-6"
-XZ_INTEGRITY_CHECK ?= "crc32"
-
-ZIP_COMPRESSION_LEVEL ?= "-9"
-
-7ZIP_COMPRESSION_LEVEL ?= "9"
-7ZIP_COMPRESSION_METHOD ?= "BZip2"
-7ZIP_EXTENSION ?= "7z"
-
-JFFS2_SUM_EXTRA_ARGS ?= ""
-IMAGE_CMD:jffs2 = "mkfs.jffs2 --root=${IMAGE_ROOTFS} --faketime --output=${IMGDEPLOYDIR}/${IMAGE_NAME}.jffs2 ${EXTRA_IMAGECMD}"
-
-IMAGE_CMD:cramfs = "mkfs.cramfs ${IMAGE_ROOTFS} ${IMGDEPLOYDIR}/${IMAGE_NAME}.cramfs ${EXTRA_IMAGECMD}"
-
-oe_mkext234fs () {
-        fstype=$1
-        extra_imagecmd=""
-
-        if [ $# -gt 1 ]; then
-                shift
-                extra_imagecmd=$@
-        fi
-
-        # If generating an empty image the size of the sparse block should be large
-        # enough to allocate an ext4 filesystem using 4096 bytes per inode, this is
-        # about 60K, so dd needs a minimum count of 60, with bs=1024 (bytes per IO)
-        eval local COUNT=\"0\"
-        eval local MIN_COUNT=\"60\"
-        if [ $ROOTFS_SIZE -lt $MIN_COUNT ]; then
-                eval COUNT=\"$MIN_COUNT\"
-        fi
-        # Create a sparse image block
-        bbdebug 1 Executing "dd if=/dev/zero of=${IMGDEPLOYDIR}/${IMAGE_NAME}.$fstype seek=$ROOTFS_SIZE count=$COUNT bs=1024"
-        dd if=/dev/zero of=${IMGDEPLOYDIR}/${IMAGE_NAME}.$fstype seek=$ROOTFS_SIZE count=$COUNT bs=1024
-        bbdebug 1 "Actual Rootfs size:  `du -s ${IMAGE_ROOTFS}`"
-        bbdebug 1 "Actual Partition size: `stat -c '%s' ${IMGDEPLOYDIR}/${IMAGE_NAME}.$fstype`"
-        bbdebug 1 Executing "mkfs.$fstype -F $extra_imagecmd ${IMGDEPLOYDIR}/${IMAGE_NAME}.$fstype -d ${IMAGE_ROOTFS}"
-        mkfs.$fstype -F $extra_imagecmd ${IMGDEPLOYDIR}/${IMAGE_NAME}.$fstype -d ${IMAGE_ROOTFS}
-        # Error codes 0-3 indicate successfull operation of fsck (no errors or errors corrected)
-        fsck.$fstype -pvfD ${IMGDEPLOYDIR}/${IMAGE_NAME}.$fstype || [ $? -le 3 ]
-}
-
-IMAGE_CMD:ext2 = "oe_mkext234fs ext2 ${EXTRA_IMAGECMD}"
-IMAGE_CMD:ext3 = "oe_mkext234fs ext3 ${EXTRA_IMAGECMD}"
-IMAGE_CMD:ext4 = "oe_mkext234fs ext4 ${EXTRA_IMAGECMD}"
-
-MIN_BTRFS_SIZE ?= "16384"
-IMAGE_CMD:btrfs () {
-        size=${ROOTFS_SIZE}
-        if [ ${size} -lt ${MIN_BTRFS_SIZE} ] ; then
-                size=${MIN_BTRFS_SIZE}
-                bbwarn "Rootfs size is too small for BTRFS. Filesystem will be extended to ${size}K"
-        fi
-        dd if=/dev/zero of=${IMGDEPLOYDIR}/${IMAGE_NAME}.btrfs seek=${size} count=0 bs=1024
-        mkfs.btrfs ${EXTRA_IMAGECMD} -r ${IMAGE_ROOTFS} ${IMGDEPLOYDIR}/${IMAGE_NAME}.btrfs
-}
-
-oe_mksquashfs () {
-    local comp=$1; shift
-    local extra_imagecmd="$@"
-
-    if [ "$comp" = "zstd" ]; then
-        suffix="zst"
-    fi
-
-    # Use the bitbake reproducible timestamp instead of the hardcoded squashfs one
-    export SOURCE_DATE_EPOCH=$(stat -c '%Y' ${IMAGE_ROOTFS})
-    mksquashfs ${IMAGE_ROOTFS} ${IMGDEPLOYDIR}/${IMAGE_NAME}.squashfs${comp:+-}${suffix:-$comp} -noappend ${comp:+-comp }$comp $extra_imagecmd
-}
-IMAGE_CMD:squashfs = "oe_mksquashfs '' ${EXTRA_IMAGECMD}"
-IMAGE_CMD:squashfs-xz = "oe_mksquashfs xz ${EXTRA_IMAGECMD}"
-IMAGE_CMD:squashfs-lzo = "oe_mksquashfs lzo ${EXTRA_IMAGECMD}"
-IMAGE_CMD:squashfs-lz4 = "oe_mksquashfs lz4 ${EXTRA_IMAGECMD}"
-IMAGE_CMD:squashfs-zst = "oe_mksquashfs zstd ${EXTRA_IMAGECMD}"
-
-IMAGE_CMD:erofs = "mkfs.erofs ${EXTRA_IMAGECMD} ${IMGDEPLOYDIR}/${IMAGE_NAME}.erofs ${IMAGE_ROOTFS}"
-IMAGE_CMD:erofs-lz4 = "mkfs.erofs -zlz4 ${EXTRA_IMAGECMD} ${IMGDEPLOYDIR}/${IMAGE_NAME}.erofs-lz4 ${IMAGE_ROOTFS}"
-IMAGE_CMD:erofs-lz4hc = "mkfs.erofs -zlz4hc ${EXTRA_IMAGECMD} ${IMGDEPLOYDIR}/${IMAGE_NAME}.erofs-lz4hc ${IMAGE_ROOTFS}"
-
-# Note that vfat can't handle all types of files that a real linux file system
-# can (e.g. device files, symlinks, etc.) and therefore it not suitable for all
-# use cases
-oe_mkvfatfs () {
-    mkfs.vfat $@ -C ${IMGDEPLOYDIR}/${IMAGE_NAME}.vfat ${ROOTFS_SIZE}
-    mcopy -i "${IMGDEPLOYDIR}/${IMAGE_NAME}.vfat" -vsmpQ ${IMAGE_ROOTFS}/* ::/
-}
-
-IMAGE_CMD:vfat = "oe_mkvfatfs ${EXTRA_IMAGECMD}"
-
-IMAGE_CMD_TAR ?= "tar"
-# ignore return code 1 "file changed as we read it" as other tasks(e.g. do_image_wic) may be hardlinking rootfs
-IMAGE_CMD:tar = "${IMAGE_CMD_TAR} --sort=name --format=posix --pax-option=delete=atime,delete=ctime --numeric-owner -cf ${IMGDEPLOYDIR}/${IMAGE_NAME}.tar -C ${IMAGE_ROOTFS} . || [ $? -eq 1 ]"
-SPDX_IMAGE_PURPOSE:tar = "archive"
-
-do_image_cpio[cleandirs] += "${WORKDIR}/cpio_append"
-IMAGE_CMD:cpio () {
-        (cd ${IMAGE_ROOTFS} && find . | sort | cpio --reproducible -o -H newc >${IMGDEPLOYDIR}/${IMAGE_NAME}.cpio)
-        # We only need the /init symlink if we're building the real
-        # image. The -dbg image doesn't need it! By being clever
-        # about this we also avoid 'touch' below failing, as it
-        # might be trying to touch /sbin/init on the host since both
-        # the normal and the -dbg image share the same WORKDIR
-        if [ "${IMAGE_BUILDING_DEBUGFS}" != "true" ]; then
-                if [ ! -L ${IMAGE_ROOTFS}/init ] && [ ! -e ${IMAGE_ROOTFS}/init ]; then
-                        if [ -L ${IMAGE_ROOTFS}/sbin/init ] || [ -e ${IMAGE_ROOTFS}/sbin/init ]; then
-                                ln -sf /sbin/init ${WORKDIR}/cpio_append/init
-                                touch -h -r ${IMAGE_ROOTFS}/sbin/init ${WORKDIR}/cpio_append/init
-                        else
-                                touch -r ${IMAGE_ROOTFS} ${WORKDIR}/cpio_append/init
-                        fi
-                        (cd  ${WORKDIR}/cpio_append && echo ./init | cpio --reproducible -oA -H newc -F ${IMGDEPLOYDIR}/${IMAGE_NAME}.cpio)
-                fi
-        fi
-}
-SPDX_IMAGE_PURPOSE:cpio = "archive"
-
-UBI_VOLNAME ?= "${MACHINE}-rootfs"
-UBI_VOLTYPE ?= "dynamic"
-UBI_IMGTYPE ?= "ubifs"
-
-write_ubi_config() {
-        local vname="$1"
-
-        cat <<EOF > ubinize${vname}-${IMAGE_NAME}.cfg
-[ubifs]
-mode=ubi
-image=${IMGDEPLOYDIR}/${IMAGE_NAME}${vname}.${UBI_IMGTYPE}
-vol_id=0
-vol_type=${UBI_VOLTYPE}
-vol_name=${UBI_VOLNAME}
-vol_flags=autoresize
-EOF
-}
-
-multiubi_mkfs() {
-        local mkubifs_args="$1"
-        local ubinize_args="$2"
-
-        # Added prompt error message for ubi and ubifs image creation.
-        if [ -z "$mkubifs_args" ] || [ -z "$ubinize_args" ]; then
-            bbfatal "MKUBIFS_ARGS and UBINIZE_ARGS have to be set, see http://www.linux-mtd.infradead.org/faq/ubifs.html for details"
-        fi
-
-        if [ -z "$3" ]; then
-                local vname=""
-        else
-                local vname="_$3"
-        fi
-        write_ubi_config "${vname}"
-
-        if [ -n "$vname" ]; then
-                mkfs.ubifs -r ${IMAGE_ROOTFS} -o ${IMGDEPLOYDIR}/${IMAGE_NAME}${vname}.ubifs ${mkubifs_args}
-        fi
-        ubinize -o ${IMGDEPLOYDIR}/${IMAGE_NAME}${vname}.ubi ${ubinize_args} ubinize${vname}-${IMAGE_NAME}.cfg
-
-        # Cleanup cfg file
-        mv ubinize${vname}-${IMAGE_NAME}.cfg ${IMGDEPLOYDIR}/
-
-        # Create own symlinks for 'named' volumes
-        if [ -n "$vname" ]; then
-                cd ${IMGDEPLOYDIR}
-                if [ -e ${IMAGE_NAME}${vname}.ubifs ]; then
-                        ln -sf ${IMAGE_NAME}${vname}.ubifs \
-                        ${IMAGE_LINK_NAME}${vname}.ubifs
-                fi
-                if [ -e ${IMAGE_NAME}${vname}.ubi ]; then
-                        ln -sf ${IMAGE_NAME}${vname}.ubi \
-                        ${IMAGE_LINK_NAME}${vname}.ubi
-                fi
-                cd -
-        fi
-}
-
-MULTIUBI_ARGS = "MKUBIFS_ARGS UBINIZE_ARGS"
-
-IMAGE_CMD:multiubi () {
-        ${@' '.join(['%s_%s="%s";' % (arg, name, d.getVar('%s_%s' % (arg, name))) for arg in d.getVar('MULTIUBI_ARGS').split() for name in d.getVar('MULTIUBI_BUILD').split()])}
-        # Split MKUBIFS_ARGS_<name> and UBINIZE_ARGS_<name>
-        for name in ${MULTIUBI_BUILD}; do
-                eval local mkubifs_args=\"\$MKUBIFS_ARGS_${name}\"
-                eval local ubinize_args=\"\$UBINIZE_ARGS_${name}\"
-
-                multiubi_mkfs "${mkubifs_args}" "${ubinize_args}" "${name}"
-        done
-}
-
-IMAGE_CMD:ubi () {
-        multiubi_mkfs "${MKUBIFS_ARGS}" "${UBINIZE_ARGS}"
-}
-IMAGE_TYPEDEP:ubi = "${UBI_IMGTYPE}"
-
-IMAGE_CMD:ubifs = "mkfs.ubifs -r ${IMAGE_ROOTFS} -o ${IMGDEPLOYDIR}/${IMAGE_NAME}.ubifs ${MKUBIFS_ARGS}"
-
-MIN_F2FS_SIZE ?= "524288"
-IMAGE_CMD:f2fs () {
-        # We need to add additional smarts here form devices smaller than 1.5G
-        # Need to scale appropriately between 40M -> 1.5G as the "overprovision
-        # ratio" goes down as the device gets bigger (70% -> 4.5%), below about
-        # 500M the standard IMAGE_OVERHEAD_FACTOR does not work, so add additional
-        # space here when under 500M
-        size=${ROOTFS_SIZE}
-        if [ ${size} -lt ${MIN_F2FS_SIZE} ] ; then
-                size=${MIN_F2FS_SIZE}
-                bbwarn "Rootfs size is too small for F2FS. Filesystem will be extended to ${size}K"
-        fi
-        dd if=/dev/zero of=${IMGDEPLOYDIR}/${IMAGE_NAME}.f2fs seek=${size} count=0 bs=1024
-        mkfs.f2fs ${EXTRA_IMAGECMD} ${IMGDEPLOYDIR}/${IMAGE_NAME}.f2fs
-        sload.f2fs -f ${IMAGE_ROOTFS} ${IMGDEPLOYDIR}/${IMAGE_NAME}.f2fs
-}
-
-EXTRA_IMAGECMD = ""
-
-inherit siteinfo kernel-arch image-artifact-names
-
-JFFS2_ENDIANNESS ?= "${@oe.utils.conditional('SITEINFO_ENDIANNESS', 'le', '-l', '-b', d)}"
-JFFS2_ERASEBLOCK ?= "0x40000"
-EXTRA_IMAGECMD:jffs2 ?= "--pad ${JFFS2_ENDIANNESS} --eraseblock=${JFFS2_ERASEBLOCK} --no-cleanmarkers"
-
-# Change these if you want default mkfs behavior (i.e. create minimal inode number)
-EXTRA_IMAGECMD:ext2 ?= "-i 4096"
-EXTRA_IMAGECMD:ext3 ?= "-i 4096"
-EXTRA_IMAGECMD:ext4 ?= "-i 4096"
-EXTRA_IMAGECMD:btrfs ?= "-n 4096 --shrink"
-EXTRA_IMAGECMD:f2fs ?= ""
-
-# If a specific FAT size is needed, set it here (e.g. "-F 32"/"-F 16"/"-F 12")
-# otherwise mkfs.vfat will automatically pick one.
-EXTRA_IMAGECMD:vfat ?= ""
-
-do_image_tar[depends] += "tar-replacement-native:do_populate_sysroot"
-do_image_cpio[depends] += "cpio-native:do_populate_sysroot"
-do_image_jffs2[depends] += "mtd-utils-native:do_populate_sysroot"
-do_image_cramfs[depends] += "util-linux-native:do_populate_sysroot"
-do_image_ext2[depends] += "e2fsprogs-native:do_populate_sysroot"
-do_image_ext3[depends] += "e2fsprogs-native:do_populate_sysroot"
-do_image_ext4[depends] += "e2fsprogs-native:do_populate_sysroot"
-do_image_btrfs[depends] += "btrfs-tools-native:do_populate_sysroot"
-do_image_squashfs[depends] += "squashfs-tools-native:do_populate_sysroot"
-do_image_squashfs_xz[depends] += "squashfs-tools-native:do_populate_sysroot"
-do_image_squashfs_lzo[depends] += "squashfs-tools-native:do_populate_sysroot"
-do_image_squashfs_lz4[depends] += "squashfs-tools-native:do_populate_sysroot"
-do_image_squashfs_zst[depends] += "squashfs-tools-native:do_populate_sysroot"
-do_image_ubi[depends] += "mtd-utils-native:do_populate_sysroot"
-do_image_ubifs[depends] += "mtd-utils-native:do_populate_sysroot"
-do_image_multiubi[depends] += "mtd-utils-native:do_populate_sysroot"
-do_image_f2fs[depends] += "f2fs-tools-native:do_populate_sysroot"
-do_image_erofs[depends] += "erofs-utils-native:do_populate_sysroot"
-do_image_erofs_lz4[depends] += "erofs-utils-native:do_populate_sysroot"
-do_image_erofs_lz4hc[depends] += "erofs-utils-native:do_populate_sysroot"
-do_image_vfat[depends] += "dosfstools-native:do_populate_sysroot mtools-native:do_populate_sysroot"
-
-# This variable is available to request which values are suitable for IMAGE_FSTYPES
-IMAGE_TYPES = " \
-    jffs2 jffs2.sum \
-    cramfs \
-    ext2 ext2.gz ext2.bz2 ext2.lzma \
-    ext3 ext3.gz \
-    ext4 ext4.gz \
-    btrfs \
-    vfat \
-    squashfs squashfs-xz squashfs-lzo squashfs-lz4 squashfs-zst \
-    ubi ubifs multiubi \
-    tar tar.gz tar.bz2 tar.xz tar.lz4 tar.zst \
-    cpio cpio.gz cpio.xz cpio.lzma cpio.lz4 cpio.zst \
-    wic wic.gz wic.bz2 wic.lzma wic.zst \
-    container \
-    f2fs \
-    erofs erofs-lz4 erofs-lz4hc \
-"
-# These image types are x86 specific as they need syslinux
-IMAGE_TYPES:append:x86 = " hddimg iso"
-IMAGE_TYPES:append:x86-64 = " hddimg iso"
-
-# Compression is a special case of conversion. The old variable
-# names are still supported for backward-compatibility. When defining
-# new compression or conversion commands, use CONVERSIONTYPES and
-# CONVERSION_CMD/DEPENDS.
-COMPRESSIONTYPES ?= ""
-
-CONVERSIONTYPES = "gz bz2 lzma xz lz4 lzo zip 7zip zst sum md5sum sha1sum sha224sum sha256sum sha384sum sha512sum bmap u-boot vmdk vhd vhdx vdi qcow2 base64 gzsync zsync ${COMPRESSIONTYPES}"
-CONVERSION_CMD:lzma = "lzma -k -f -7 ${IMAGE_NAME}.${type}"
-CONVERSION_CMD:gz = "gzip -f -9 -n -c --rsyncable ${IMAGE_NAME}.${type} > ${IMAGE_NAME}.${type}.gz"
-CONVERSION_CMD:bz2 = "pbzip2 -f -k ${IMAGE_NAME}.${type}"
-CONVERSION_CMD:xz = "xz -f -k -c ${XZ_COMPRESSION_LEVEL} ${XZ_DEFAULTS} --check=${XZ_INTEGRITY_CHECK} ${IMAGE_NAME}.${type} > ${IMAGE_NAME}.${type}.xz"
-CONVERSION_CMD:lz4 = "lz4 -f -9 -z -l ${IMAGE_NAME}.${type} ${IMAGE_NAME}.${type}.lz4"
-CONVERSION_CMD:lzo = "lzop -f -9 ${IMAGE_NAME}.${type}"
-CONVERSION_CMD:zip = "zip ${ZIP_COMPRESSION_LEVEL} ${IMAGE_NAME}.${type}.zip ${IMAGE_NAME}.${type}"
-CONVERSION_CMD:7zip = "7za a -mx=${7ZIP_COMPRESSION_LEVEL} -mm=${7ZIP_COMPRESSION_METHOD} ${IMAGE_NAME}.${type}.${7ZIP_EXTENSION} ${IMAGE_NAME}.${type}"
-CONVERSION_CMD:zst = "zstd -f -k -c ${ZSTD_DEFAULTS} ${IMAGE_NAME}.${type} > ${IMAGE_NAME}.${type}.zst"
-CONVERSION_CMD:sum = "sumtool -i ${IMAGE_NAME}.${type} -o ${IMAGE_NAME}.${type}.sum ${JFFS2_SUM_EXTRA_ARGS}"
-CONVERSION_CMD:md5sum = "md5sum ${IMAGE_NAME}.${type} > ${IMAGE_NAME}.${type}.md5sum"
-CONVERSION_CMD:sha1sum = "sha1sum ${IMAGE_NAME}.${type} > ${IMAGE_NAME}.${type}.sha1sum"
-CONVERSION_CMD:sha224sum = "sha224sum ${IMAGE_NAME}.${type} > ${IMAGE_NAME}.${type}.sha224sum"
-CONVERSION_CMD:sha256sum = "sha256sum ${IMAGE_NAME}.${type} > ${IMAGE_NAME}.${type}.sha256sum"
-CONVERSION_CMD:sha384sum = "sha384sum ${IMAGE_NAME}.${type} > ${IMAGE_NAME}.${type}.sha384sum"
-CONVERSION_CMD:sha512sum = "sha512sum ${IMAGE_NAME}.${type} > ${IMAGE_NAME}.${type}.sha512sum"
-CONVERSION_CMD:bmap = "bmaptool create ${IMAGE_NAME}.${type} -o ${IMAGE_NAME}.${type}.bmap"
-CONVERSION_CMD:u-boot = "mkimage -A ${UBOOT_ARCH} -O linux -T ramdisk -C none -n ${IMAGE_NAME} -d ${IMAGE_NAME}.${type} ${IMAGE_NAME}.${type}.u-boot"
-CONVERSION_CMD:vmdk = "qemu-img convert -O vmdk ${IMAGE_NAME}.${type} ${IMAGE_NAME}.${type}.vmdk"
-CONVERSION_CMD:vhdx = "qemu-img convert -O vhdx -o subformat=dynamic ${IMAGE_NAME}.${type} ${IMAGE_NAME}.${type}.vhdx"
-CONVERSION_CMD:vhd = "qemu-img convert -O vpc -o subformat=fixed ${IMAGE_NAME}.${type} ${IMAGE_NAME}.${type}.vhd"
-CONVERSION_CMD:vdi = "qemu-img convert -O vdi ${IMAGE_NAME}.${type} ${IMAGE_NAME}.${type}.vdi"
-CONVERSION_CMD:qcow2 = "qemu-img convert -O qcow2 ${IMAGE_NAME}.${type} ${IMAGE_NAME}.${type}.qcow2"
-CONVERSION_CMD:base64 = "base64 ${IMAGE_NAME}.${type} > ${IMAGE_NAME}.${type}.base64"
-CONVERSION_CMD:zsync = "zsyncmake_curl ${IMAGE_NAME}.${type}"
-CONVERSION_CMD:gzsync = "zsyncmake_curl -z ${IMAGE_NAME}.${type}"
-CONVERSION_DEPENDS_lzma = "xz-native"
-CONVERSION_DEPENDS_gz = "pigz-native"
-CONVERSION_DEPENDS_bz2 = "pbzip2-native"
-CONVERSION_DEPENDS_xz = "xz-native"
-CONVERSION_DEPENDS_lz4 = "lz4-native"
-CONVERSION_DEPENDS_lzo = "lzop-native"
-CONVERSION_DEPENDS_zip = "zip-native"
-CONVERSION_DEPENDS_7zip = "7zip-native"
-CONVERSION_DEPENDS_zst = "zstd-native"
-CONVERSION_DEPENDS_sum = "mtd-utils-native"
-CONVERSION_DEPENDS_bmap = "bmaptool-native"
-CONVERSION_DEPENDS_u-boot = "u-boot-tools-native"
-CONVERSION_DEPENDS_vmdk = "qemu-system-native"
-CONVERSION_DEPENDS_vdi = "qemu-system-native"
-CONVERSION_DEPENDS_qcow2 = "qemu-system-native"
-CONVERSION_DEPENDS_base64 = "coreutils-native"
-CONVERSION_DEPENDS_vhdx = "qemu-system-native"
-CONVERSION_DEPENDS_vhd = "qemu-system-native"
-CONVERSION_DEPENDS_zsync = "zsync-curl-native"
-CONVERSION_DEPENDS_gzsync = "zsync-curl-native"
-
-RUNNABLE_IMAGE_TYPES ?= "ext2 ext3 ext4"
-RUNNABLE_MACHINE_PATTERNS ?= "qemu"
-
-DEPLOYABLE_IMAGE_TYPES ?= "hddimg iso"
-
-# The IMAGE_TYPES_MASKED variable will be used to mask out from the IMAGE_FSTYPES,
-# images that will not be built at do_rootfs time: vmdk, vhd, vhdx, vdi, qcow2, hddimg, iso, etc.
-IMAGE_TYPES_MASKED ?= ""
-
-# bmap requires python3 to be in the PATH
-EXTRANATIVEPATH += "${@'python3-native' if d.getVar('IMAGE_FSTYPES').find('.bmap') else ''}"
-# reproducible tar requires our tar, not the host's
-EXTRANATIVEPATH += "${@'tar-native' if 'tar' in d.getVar('IMAGE_FSTYPES') else ''}"
diff --git a/meta/classes-recipe/image_types_wic.bbclass b/meta/classes-recipe/image_types_wic.bbclass
deleted file mode 100644
index 675aa97513..0000000000
--- a/meta/classes-recipe/image_types_wic.bbclass
+++ /dev/null
@@ -1,221 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-# The WICVARS variable is used to define list of bitbake variables used in wic code
-# variables from this list is written to <image>.env file
-WICVARS ?= "\
-        APPEND \
-        ASSUME_PROVIDED \
-        BBLAYERS \
-        DEPLOY_DIR_IMAGE \
-        FAKEROOTCMD \
-        HOSTTOOLS_DIR \
-        IMAGE_BASENAME \
-        IMAGE_BOOT_FILES \
-        IMAGE_CLASSES \
-        IMAGE_EFI_BOOT_FILES \
-        IMAGE_EXTRA_PARTITION_FILES \
-        IMAGE_LINK_NAME \
-        IMAGE_ROOTFS \
-        IMGDEPLOYDIR \
-        INITRAMFS_FSTYPES \
-        INITRAMFS_IMAGE \
-        INITRAMFS_IMAGE_BUNDLE \
-        INITRAMFS_LINK_NAME \
-        INITRD \
-        INITRD_LIVE \
-        ISODIR \
-        KERNEL_CONSOLE \
-        KERNEL_IMAGETYPE \
-        MACHINE \
-        PSEUDO_INCLUDE_PATHS \
-        RECIPE_SYSROOT_NATIVE \
-        ROOTFS_SIZE \
-        STAGING_DATADIR \
-        STAGING_DIR \
-        STAGING_DIR_HOST \
-        STAGING_LIBDIR \
-        TARGET_SYS \
-"
-
-inherit_defer ${@bb.utils.contains('INITRAMFS_IMAGE_BUNDLE', '1', 'kernel-artifact-names', '', d)}
-
-WKS_FILE ??= "${IMAGE_BASENAME}.${MACHINE}.wks"
-WKS_FILES ?= "${WKS_FILE} ${IMAGE_BASENAME}.wks"
-WKS_SEARCH_PATH ?= "${THISDIR}:${@':'.join('%s/wic' % p for p in '${BBPATH}'.split(':'))}:${@':'.join('%s/scripts/lib/wic/canned-wks' % l for l in '${BBPATH}:${COREBASE}'.split(':'))}"
-WKS_FULL_PATH = "${@wks_search(d.getVar('WKS_FILES').split(), d.getVar('WKS_SEARCH_PATH')) or ''}"
-
-def wks_search(files, search_path):
-    for f in files:
-        if os.path.isabs(f):
-            if os.path.exists(f):
-                return f
-        else:
-            searched = bb.utils.which(search_path, f)
-            if searched:
-                return searched
-
-def wks_checksums(files, search_path):
-    ret = ""
-    for f in files:
-        found, hist = bb.utils.which(search_path, f, history=True)
-        ret = ret + " " + " ".join(h + ":False" for h in hist[:-1])
-        if found:
-            ret = ret + " " + found + ":True"
-    return ret
-
-
-WIC_CREATE_EXTRA_ARGS ?= ""
-
-IMAGE_CMD:wic () {
-        out="${IMGDEPLOYDIR}/${IMAGE_NAME}"
-        build_wic="${WORKDIR}/build-wic"
-        tmp_wic="${WORKDIR}/tmp-wic"
-        wks="${WKS_FULL_PATH}"
-        if [ -e "$tmp_wic" ]; then
-                # Ensure we don't have any junk leftover from a previously interrupted
-                # do_image_wic execution
-                rm -rf "$tmp_wic"
-        fi
-        if [ -z "$wks" ]; then
-                bbfatal "No kickstart files from WKS_FILES were found: ${WKS_FILES}. Please set WKS_FILE or WKS_FILES appropriately."
-        fi
-        BUILDDIR="${TOPDIR}" PSEUDO_UNLOAD=1 wic create --debug "$wks" --vars "${STAGING_DIR}/${MACHINE}/imgdata/" -e "${IMAGE_BASENAME}" -o "$build_wic/" -w "$tmp_wic" ${WIC_CREATE_EXTRA_ARGS}
-
-        # look to see if the user specifies a custom imager
-        IMAGER=direct
-        eval set -- "${WIC_CREATE_EXTRA_ARGS} --"
-        while [ 1 ]; do
-                case "$1" in
-                        --imager|-i)
-                                shift
-                                IMAGER=$1
-                                ;;
-                        --)
-                                shift
-                                break
-                                ;;
-                esac
-                shift
-        done
-        mv "$build_wic/$(basename "${wks%.wks}")"*.${IMAGER} "$out.wic"
-}
-IMAGE_CMD:wic[vardepsexclude] = "WKS_FULL_PATH WKS_FILES TOPDIR"
-SPDX_IMAGE_PURPOSE:wic = "diskImage"
-do_image_wic[cleandirs] = "${WORKDIR}/build-wic"
-
-# Rebuild when the wks file or vars in WICVARS change
-USING_WIC = "${@bb.utils.contains_any('IMAGE_FSTYPES', 'wic ' + ' '.join('wic.%s' % c for c in '${CONVERSIONTYPES}'.split()), '1', '', d)}"
-WKS_FILE_CHECKSUM = "${@wks_checksums(d.getVar('WKS_FILES').split(), d.getVar('WKS_SEARCH_PATH')) if '${USING_WIC}' else ''}"
-do_image_wic[file-checksums] += "${WKS_FILE_CHECKSUM}"
-do_image_wic[depends] += "${@' '.join('%s-native:do_populate_sysroot' % r for r in ('parted', 'gptfdisk', 'dosfstools', 'mtools'))}"
-
-# We ensure all artfacts are deployed (e.g virtual/bootloader)
-do_image_wic[recrdeptask] += "do_deploy"
-do_image_wic[deptask] += "do_image_complete"
-
-WKS_FILE_DEPENDS_DEFAULT = '${@bb.utils.contains_any("BUILD_ARCH", [ 'x86_64', 'i686' ], "syslinux-native", "",d)}'
-WKS_FILE_DEPENDS_DEFAULT += "bmaptool-native cdrtools-native btrfs-tools-native squashfs-tools-native e2fsprogs-native erofs-utils-native"
-# Unified kernel images need objcopy
-WKS_FILE_DEPENDS_DEFAULT += "virtual/cross-binutils"
-WKS_FILE_DEPENDS_BOOTLOADERS = ""
-WKS_FILE_DEPENDS_BOOTLOADERS:aarch64 = "grub-efi systemd-boot"
-WKS_FILE_DEPENDS_BOOTLOADERS:arm = "systemd-boot"
-WKS_FILE_DEPENDS_BOOTLOADERS:x86 = "syslinux grub-efi systemd-boot"
-WKS_FILE_DEPENDS_BOOTLOADERS:x86-64 = "syslinux grub-efi systemd-boot"
-WKS_FILE_DEPENDS_BOOTLOADERS:x86-x32 = "syslinux grub-efi"
-
-WKS_FILE_DEPENDS ??= "${WKS_FILE_DEPENDS_DEFAULT} ${WKS_FILE_DEPENDS_BOOTLOADERS}"
-
-DEPENDS += "${@ '${WKS_FILE_DEPENDS}' if d.getVar('USING_WIC') else '' }"
-
-python do_write_wks_template () {
-    """Write out expanded template contents to WKS_FULL_PATH."""
-    import re
-
-    template_body = d.getVar('_WKS_TEMPLATE')
-
-    # Remove any remnant variable references left behind by the expansion
-    # due to undefined variables
-    expand_var_regexp = re.compile(r"\${[^{}@\n\t :]+}")
-    while True:
-        new_body = re.sub(expand_var_regexp, '', template_body)
-        if new_body == template_body:
-            break
-        else:
-            template_body = new_body
-
-    wks_file = d.getVar('WKS_FULL_PATH')
-    with open(wks_file, 'w') as f:
-        f.write(template_body)
-    f.close()
-    # Copy the finalized wks file to the deploy directory for later use
-    depdir = d.getVar('IMGDEPLOYDIR')
-    basename = d.getVar('IMAGE_BASENAME')
-    bb.utils.copyfile(wks_file, "%s/%s" % (depdir, basename + '-' + os.path.basename(wks_file)))
-}
-
-do_flush_pseudodb() {
-        ${FAKEROOTENV} ${FAKEROOTCMD} -S
-}
-
-python () {
-    if d.getVar('USING_WIC'):
-        wks_file_u = d.getVar('WKS_FULL_PATH', False)
-        wks_file = d.expand(wks_file_u)
-        base, ext = os.path.splitext(wks_file)
-        if ext == '.in' and os.path.exists(wks_file):
-            wks_out_file = os.path.join(d.getVar('WORKDIR'), os.path.basename(base))
-            d.setVar('WKS_FULL_PATH', wks_out_file)
-            d.setVar('WKS_TEMPLATE_PATH', wks_file_u)
-            d.setVar('WKS_FILE_CHECKSUM', '${WKS_TEMPLATE_PATH}:True')
-
-            # We need to re-parse each time the file changes, and bitbake
-            # needs to be told about that explicitly.
-            bb.parse.mark_dependency(d, wks_file)
-
-            try:
-                with open(wks_file, 'r') as f:
-                    body = f.read()
-            except (IOError, OSError) as exc:
-                pass
-            else:
-                # Previously, I used expandWithRefs to get the dependency list
-                # and add it to WICVARS, but there's no point re-parsing the
-                # file in process_wks_template as well, so just put it in
-                # a variable and let the metadata deal with the deps.
-                d.setVar('_WKS_TEMPLATE', body)
-                bb.build.addtask('do_write_wks_template', 'do_image_wic', 'do_image', d)
-        bb.build.addtask('do_image_wic', 'do_image_complete', None, d)
-}
-
-#
-# Write environment variables used by wic
-# to tmp/sysroots/<machine>/imgdata/<image>.env
-#
-python do_rootfs_wicenv () {
-    wicvars = d.getVar('WICVARS')
-    if not wicvars:
-        return
-
-    stdir = d.getVar('STAGING_DIR')
-    outdir = os.path.join(stdir, d.getVar('MACHINE'), 'imgdata')
-    bb.utils.mkdirhier(outdir)
-    basename = d.getVar('IMAGE_BASENAME')
-    with open(os.path.join(outdir, basename) + '.env', 'w') as envf:
-        for var in wicvars.split():
-            value = d.getVar(var)
-            if value:
-                envf.write('%s="%s"\n' % (var, value.strip()))
-    envf.close()
-    # Copy .env file to deploy directory for later use with stand alone wic
-    depdir = d.getVar('IMGDEPLOYDIR')
-    bb.utils.copyfile(os.path.join(outdir, basename) + '.env', os.path.join(depdir, basename) + '.env')
-}
-addtask do_flush_pseudodb after do_rootfs before do_image do_image_qa
-addtask do_rootfs_wicenv after do_image before do_image_wic
-do_rootfs_wicenv[vardeps] += "${WICVARS}"
-do_rootfs_wicenv[prefuncs] = 'set_image_size'
diff --git a/meta/classes-recipe/kernel-arch.bbclass b/meta/classes-recipe/kernel-arch.bbclass
deleted file mode 100644
index 7aea9cd3e8..0000000000
--- a/meta/classes-recipe/kernel-arch.bbclass
+++ /dev/null
@@ -1,84 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-#
-# set the ARCH environment variable for kernel compilation (including
-# modules). return value must match one of the architecture directories
-# in the kernel source "arch" directory
-#
-
-valid_archs = "alpha cris ia64 \
-               i386 x86 \
-               m68knommu m68k ppc powerpc powerpc64 ppc64  \
-               sparc sparc64 \
-               arm aarch64 \
-               m32r mips \
-               sh sh64 um h8300   \
-               parisc s390  v850 \
-               avr32 blackfin \
-               loongarch64 \
-               microblaze \
-               nios2 arc riscv xtensa"
-
-def map_kernel_arch(a, d):
-    import re
-
-    valid_archs = d.getVar('valid_archs').split()
-
-    if   re.match('(i.86|athlon|x86.64)$', a):  return 'x86'
-    elif re.match('arceb$', a):                 return 'arc'
-    elif re.match('armeb$', a):                 return 'arm'
-    elif re.match('aarch64$', a):               return 'arm64'
-    elif re.match('aarch64_be$', a):            return 'arm64'
-    elif re.match('aarch64_ilp32$', a):         return 'arm64'
-    elif re.match('aarch64_be_ilp32$', a):      return 'arm64'
-    elif re.match('loongarch(32|64|)$', a):     return 'loongarch'
-    elif re.match('mips(isa|)(32|64|)(r6|)(el|)$', a):      return 'mips'
-    elif re.match('mcf', a):                    return 'm68k'
-    elif re.match('riscv(32|64|)(eb|)$', a):    return 'riscv'
-    elif re.match('p(pc|owerpc)(|64)', a):      return 'powerpc'
-    elif re.match('sh(3|4)$', a):               return 'sh'
-    elif re.match('bfin', a):                   return 'blackfin'
-    elif re.match('microblazee[bl]', a):        return 'microblaze'
-    elif a in valid_archs:                      return a
-    else:
-        if not d.getVar("TARGET_OS").startswith("linux"):
-            return a
-        bb.error("cannot map '%s' to a linux kernel architecture" % a)
-
-export ARCH = "${@map_kernel_arch(d.getVar('TARGET_ARCH'), d)}"
-
-def map_uboot_arch(a, d):
-    import re
-
-    if   re.match('p(pc|owerpc)(|64)', a): return 'ppc'
-    elif re.match('i.86$', a): return 'x86'
-    return a
-
-export UBOOT_ARCH = "${@map_uboot_arch(d.getVar('ARCH'), d)}"
-
-# Set TARGET_??_KERNEL_ARCH in the machine .conf to set architecture
-# specific options necessary for building the kernel and modules.
-TARGET_CC_KERNEL_ARCH ?= ""
-HOST_CC_KERNEL_ARCH ?= "${TARGET_CC_KERNEL_ARCH}"
-TARGET_LD_KERNEL_ARCH ?= ""
-HOST_LD_KERNEL_ARCH ?= "${TARGET_LD_KERNEL_ARCH}"
-TARGET_AR_KERNEL_ARCH ?= ""
-HOST_AR_KERNEL_ARCH ?= "${TARGET_AR_KERNEL_ARCH}"
-TARGET_OBJCOPY_KERNEL_ARCH ?= ""
-HOST_OBJCOPY_KERNEL_ARCH ?= "${TARGET_OBJCOPY_KERNEL_ARCH}"
-
-KERNEL_CC = "${CCACHE}${HOST_PREFIX}gcc ${HOST_CC_KERNEL_ARCH} \
- -fuse-ld=bfd ${DEBUG_PREFIX_MAP} \
- -ffile-prefix-map=${STAGING_KERNEL_DIR}=${KERNEL_SRC_PATH} \
- -ffile-prefix-map=${STAGING_KERNEL_BUILDDIR}=${KERNEL_SRC_PATH} \
-"
-KERNEL_LD = "${HOST_PREFIX}ld.bfd ${HOST_LD_KERNEL_ARCH}"
-KERNEL_AR = "${HOST_PREFIX}ar ${HOST_AR_KERNEL_ARCH}"
-KERNEL_OBJCOPY = "${HOST_PREFIX}objcopy ${HOST_OBJCOPY_KERNEL_ARCH}"
-# Code in package.py can't handle options on KERNEL_STRIP
-KERNEL_STRIP = "${HOST_PREFIX}strip"
-TOOLCHAIN = "gcc"
diff --git a/meta/classes-recipe/kernel-artifact-names.bbclass b/meta/classes-recipe/kernel-artifact-names.bbclass
deleted file mode 100644
index 1a7611a15e..0000000000
--- a/meta/classes-recipe/kernel-artifact-names.bbclass
+++ /dev/null
@@ -1,37 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-##################################################################
-# Specific kernel creation info
-# for recipes/bbclasses which need to reuse some of the kernel
-# artifacts, but aren't kernel recipes themselves
-##################################################################
-
-inherit image-artifact-names
-
-KERNEL_ARTIFACT_NAME ?= "${PKGE}-${PKGV}-${PKGR}${IMAGE_MACHINE_SUFFIX}${IMAGE_VERSION_SUFFIX}"
-KERNEL_ARTIFACT_LINK_NAME ?= "${MACHINE}"
-KERNEL_ARTIFACT_BIN_EXT ?= ".bin"
-
-KERNEL_IMAGE_NAME ?= "${KERNEL_ARTIFACT_NAME}"
-KERNEL_IMAGE_LINK_NAME ?= "${KERNEL_ARTIFACT_LINK_NAME}"
-KERNEL_IMAGE_BIN_EXT ?= "${KERNEL_ARTIFACT_BIN_EXT}"
-KERNEL_IMAGETYPE_SYMLINK ?= "1"
-
-KERNEL_DTB_NAME ?= "${KERNEL_ARTIFACT_NAME}"
-KERNEL_DTB_LINK_NAME ?= "${KERNEL_ARTIFACT_LINK_NAME}"
-KERNEL_DTB_BIN_EXT ?= "${KERNEL_ARTIFACT_BIN_EXT}"
-
-KERNEL_FIT_NAME ?= "${KERNEL_ARTIFACT_NAME}"
-KERNEL_FIT_LINK_NAME ?= "${KERNEL_ARTIFACT_LINK_NAME}"
-KERNEL_FIT_BIN_EXT ?= "${KERNEL_ARTIFACT_BIN_EXT}"
-
-MODULE_TARBALL_NAME ?= "${KERNEL_ARTIFACT_NAME}"
-MODULE_TARBALL_LINK_NAME ?= "${KERNEL_ARTIFACT_LINK_NAME}"
-MODULE_TARBALL_DEPLOY ?= "1"
-
-INITRAMFS_NAME ?= "initramfs-${KERNEL_ARTIFACT_NAME}"
-INITRAMFS_LINK_NAME ?= "initramfs-${KERNEL_ARTIFACT_LINK_NAME}"
diff --git a/meta/classes-recipe/kernel-devicetree.bbclass b/meta/classes-recipe/kernel-devicetree.bbclass
deleted file mode 100644
index eff052b402..0000000000
--- a/meta/classes-recipe/kernel-devicetree.bbclass
+++ /dev/null
@@ -1,139 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-# Support for device tree generation
-python () {
-    if not bb.data.inherits_class('nopackages', d):
-        d.appendVar("PACKAGES", " ${KERNEL_PACKAGE_NAME}-devicetree")
-        if d.getVar('KERNEL_DEVICETREE_BUNDLE') == '1':
-            d.appendVar("PACKAGES", " ${KERNEL_PACKAGE_NAME}-image-zimage-bundle")
-}
-
-# recursivly search for devicetree files
-FILES:${KERNEL_PACKAGE_NAME}-devicetree = " \
-    /${KERNEL_DTBDEST}/**/*.dtb \
-    /${KERNEL_DTBDEST}/**/*.dtbo \
-"
-
-FILES:${KERNEL_PACKAGE_NAME}-image-zimage-bundle = "/${KERNEL_IMAGEDEST}/zImage-*.dtb.bin"
-
-# Generate kernel+devicetree bundle
-KERNEL_DEVICETREE_BUNDLE ?= "0"
-
-# dtc flags passed via DTC_FLAGS env variable
-KERNEL_DTC_FLAGS ?= ""
-
-normalize_dtb () {
-        dtb="$1"
-        if echo $dtb | grep -q '/dts/'; then
-                bbwarn "$dtb contains the full path to the the dts file, but only the dtb name should be used."
-                dtb=`basename $dtb | sed 's,\.dts$,.dtb,g'`
-        fi
-        echo "$dtb"
-}
-
-get_real_dtb_path_in_kernel () {
-        dtb="$1"
-        dtb_path="${B}/arch/${ARCH}/boot/dts/$dtb"
-        if [ ! -e "$dtb_path" ]; then
-                dtb_path="${B}/arch/${ARCH}/boot/$dtb"
-        fi
-        echo "$dtb_path"
-}
-
-do_configure:append() {
-        if [ "${KERNEL_DEVICETREE_BUNDLE}" = "1" ]; then
-                if echo ${KERNEL_IMAGETYPE_FOR_MAKE} | grep -q 'zImage'; then
-                        case "${ARCH}" in
-                                "arm")
-                                config="${B}/.config"
-                                if ! grep -q 'CONFIG_ARM_APPENDED_DTB=y' $config; then
-                                        bbwarn 'CONFIG_ARM_APPENDED_DTB is NOT enabled in the kernel. Enabling it to allow the kernel to boot with the Device Tree appended!'
-                                        sed -i "/CONFIG_ARM_APPENDED_DTB[ =]/d" $config
-                                        echo "CONFIG_ARM_APPENDED_DTB=y" >> $config
-                                        echo "# CONFIG_ARM_ATAG_DTB_COMPAT is not set" >> $config
-                                fi
-                                ;;
-                                *)
-                                bberror "KERNEL_DEVICETREE_BUNDLE is not supported for ${ARCH}. Currently it is only supported for 'ARM'."
-                        esac
-                else
-                        bberror 'The KERNEL_DEVICETREE_BUNDLE requires the KERNEL_IMAGETYPE to contain zImage.'
-                fi
-        fi
-}
-
-do_compile:append() {
-        if [ -n "${KERNEL_DTC_FLAGS}" ]; then
-                export DTC_FLAGS="${KERNEL_DTC_FLAGS}"
-        fi
-
-        for dtbf in ${KERNEL_DEVICETREE}; do
-                dtb=`normalize_dtb "$dtbf"`
-                oe_runmake $dtb CC="${KERNEL_CC} $cc_extra " LD="${KERNEL_LD}" OBJCOPY="${KERNEL_OBJCOPY}" STRIP="${KERNEL_STRIP}" ${KERNEL_EXTRA_ARGS}
-        done
-}
-
-do_install:append() {
-        install -d ${D}/${KERNEL_DTBDEST}
-        for dtbf in ${KERNEL_DEVICETREE}; do
-                dtb=`normalize_dtb "$dtbf"`
-                dtb_path=`get_real_dtb_path_in_kernel "$dtb"`
-                if "${@'false' if oe.types.boolean(d.getVar('KERNEL_DTBVENDORED')) else 'true'}"; then
-                        dtb_ext=${dtb##*.}
-                        dtb_base_name=`basename $dtb .$dtb_ext`
-                        dtb=$dtb_base_name.$dtb_ext
-                fi
-                install -Dm 0644 $dtb_path ${D}/${KERNEL_DTBDEST}/$dtb
-        done
-}
-
-do_deploy:append() {
-        for dtbf in ${KERNEL_DEVICETREE}; do
-                dtb=`normalize_dtb "$dtbf"`
-                dtb_ext=${dtb##*.}
-                dtb_base_name=`basename $dtb .$dtb_ext`
-                install -d $deployDir
-                if "${@'false' if oe.types.boolean(d.getVar('KERNEL_DTBVENDORED')) else 'true'}"; then
-                        dtb=$dtb_base_name.$dtb_ext
-                fi
-                install -m 0644 ${D}/${KERNEL_DTBDEST}/$dtb $deployDir/$dtb_base_name.$dtb_ext
-                if [ -n "${KERNEL_DTB_NAME}" ] ; then
-                        ln -sf $dtb_base_name.$dtb_ext $deployDir/$dtb_base_name-${KERNEL_DTB_NAME}.$dtb_ext
-                fi
-                if [ -n "${KERNEL_DTB_LINK_NAME}" ] ; then
-                        ln -sf $dtb_base_name.$dtb_ext $deployDir/$dtb_base_name-${KERNEL_DTB_LINK_NAME}.$dtb_ext
-                fi
-                for type in ${KERNEL_IMAGETYPE_FOR_MAKE}; do
-                        if [ "$type" = "zImage" ] && [ "${KERNEL_DEVICETREE_BUNDLE}" = "1" ]; then
-                                cat ${D}/${KERNEL_IMAGEDEST}/$type \
-                                        $deployDir/$dtb_base_name.$dtb_ext \
-                                        > $deployDir/$type-$dtb_base_name.$dtb_ext${KERNEL_DTB_BIN_EXT}
-                                if [ -n "${KERNEL_DTB_NAME}" ]; then
-                                        ln -sf $type-$dtb_base_name.$dtb_ext${KERNEL_DTB_BIN_EXT} \
-                                                $deployDir/$type-$dtb_base_name-${KERNEL_DTB_NAME}.$dtb_ext${KERNEL_DTB_BIN_EXT}
-                                fi
-                                if [ -n "${KERNEL_DTB_LINK_NAME}" ]; then
-                                        ln -sf $type-$dtb_base_name.$dtb_ext${KERNEL_DTB_BIN_EXT} \
-                                                $deployDir/$type-$dtb_base_name-${KERNEL_DTB_LINK_NAME}.$dtb_ext${KERNEL_DTB_BIN_EXT}
-                                fi
-                                if [ -e "${KERNEL_OUTPUT_DIR}/${type}.initramfs" ]; then
-                                        cat ${KERNEL_OUTPUT_DIR}/${type}.initramfs \
-                                                $deployDir/$dtb_base_name.$dtb_ext \
-                                                >  $deployDir/${type}-${INITRAMFS_NAME}-$dtb_base_name.$dtb_ext${KERNEL_DTB_BIN_EXT}
-                                        if [ -n "${KERNEL_DTB_NAME}" ]; then
-                                                ln -sf ${type}-${INITRAMFS_NAME}-$dtb_base_name.$dtb_ext${KERNEL_DTB_BIN_EXT} \
-                                                        $deployDir/${type}-${INITRAMFS_NAME}-$dtb_base_name-${KERNEL_DTB_NAME}.$dtb_ext${KERNEL_DTB_BIN_EXT}
-                                        fi
-                                        if [ -n "${KERNEL_DTB_LINK_NAME}" ]; then
-                                                ln -sf ${type}-${INITRAMFS_NAME}-$dtb_base_name.$dtb_ext${KERNEL_DTB_BIN_EXT} \
-                                                        $deployDir/${type}-${INITRAMFS_NAME}-$dtb_base_name-${KERNEL_DTB_LINK_NAME}.$dtb_ext${KERNEL_DTB_BIN_EXT}
-                                        fi
-                                fi
-                        fi
-                done
-        done
-}
diff --git a/meta/classes-recipe/kernel-fit-extra-artifacts.bbclass b/meta/classes-recipe/kernel-fit-extra-artifacts.bbclass
deleted file mode 100644
index 385fe9895a..0000000000
--- a/meta/classes-recipe/kernel-fit-extra-artifacts.bbclass
+++ /dev/null
@@ -1,19 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-# Generate and deploy additional artifacts required for FIT image creation.
-# To use this class, add it to the KERNEL_CLASSES variable.
-
-inherit kernel-uboot
-
-kernel_do_deploy:append() {
-        # Provide the kernel artifacts to post processing recipes e.g. for creating a FIT image
-        uboot_prep_kimage "$deployDir"
-        # For x86 a setup.bin needs to be include"d in a fitImage as well
-        if [ -e ${KERNEL_OUTPUT_DIR}/setup.bin ]; then
-                install -D "${B}/${KERNEL_OUTPUT_DIR}/setup.bin" "$deployDir/"
-        fi
-}
diff --git a/meta/classes-recipe/kernel-fit-image.bbclass b/meta/classes-recipe/kernel-fit-image.bbclass
deleted file mode 100644
index fd0d21ceee..0000000000
--- a/meta/classes-recipe/kernel-fit-image.bbclass
+++ /dev/null
@@ -1,193 +0,0 @@
-
-inherit kernel-arch kernel-artifact-names uboot-config deploy
-require conf/image-fitimage.conf
-
-S = "${UNPACKDIR}"
-
-PACKAGE_ARCH = "${MACHINE_ARCH}"
-
-# This bbclass requires KERNEL_CLASSES += "kernel-fit-extra-artifacts"
-EXCLUDE_FROM_WORLD = "1"
-
-DEPENDS += "\
-    u-boot-tools-native dtc-native \
-    ${@'kernel-signing-keys-native' if d.getVar('FIT_GENERATE_KEYS') == '1' else ''} \
-"
-
-python () {
-    image = d.getVar('INITRAMFS_IMAGE')
-    if image and d.getVar('INITRAMFS_IMAGE_BUNDLE') != '1':
-        if d.getVar('INITRAMFS_MULTICONFIG'):
-            mc = d.getVar('BB_CURRENT_MC')
-            d.appendVarFlag('do_compile', 'mcdepends', ' mc:' + mc + ':${INITRAMFS_MULTICONFIG}:${INITRAMFS_IMAGE}:do_image_complete')
-        else:
-            d.appendVarFlag('do_compile', 'depends', ' ${INITRAMFS_IMAGE}:do_image_complete')
-
-    #check if there are any dtb providers
-    providerdtb = d.getVar("PREFERRED_PROVIDER_virtual/dtb")
-    if providerdtb:
-        d.appendVarFlag('do_compile', 'depends', ' virtual/dtb:do_populate_sysroot')
-        d.setVar('EXTERNAL_KERNEL_DEVICETREE', "${RECIPE_SYSROOT}/boot/devicetree")
-}
-
-do_configure[noexec] = "1"
-
-UBOOT_MKIMAGE_KERNEL_TYPE ?= "kernel"
-KERNEL_IMAGEDEST ?= "/boot"
-
-FIT_KERNEL_SIGN_ENABLE ?= "${UBOOT_SIGN_ENABLE}"
-FIT_KERNEL_SIGN_KEYNAME ?= "${UBOOT_SIGN_KEYNAME}"
-FIT_KERNEL_SIGN_KEYDIR ?= "${UBOOT_SIGN_KEYDIR}"
-
-python do_compile() {
-    import shutil
-    import oe.fitimage
-
-    itsfile = "fit-image.its"
-    fitname = "fitImage"
-    kernel_deploydir = d.getVar('DEPLOY_DIR_IMAGE')
-    kernel_deploysubdir = d.getVar('KERNEL_DEPLOYSUBDIR')
-    if kernel_deploysubdir:
-        kernel_deploydir = os.path.join(kernel_deploydir, kernel_deploysubdir)
-
-    # Collect all the its nodes before the its file is generated and mkimage gets executed
-    root_node = oe.fitimage.ItsNodeRootKernel(
-        d.getVar("FIT_DESC"), d.getVar("FIT_ADDRESS_CELLS"),
-        d.getVar('HOST_PREFIX'), d.getVar('UBOOT_ARCH'),  d.getVar("FIT_CONF_PREFIX"),
-        oe.types.boolean(d.getVar('FIT_KERNEL_SIGN_ENABLE')), d.getVar("FIT_KERNEL_SIGN_KEYDIR"),
-        d.getVar("UBOOT_MKIMAGE"), d.getVar("UBOOT_MKIMAGE_DTCOPTS"),
-        d.getVar("UBOOT_MKIMAGE_SIGN"), d.getVar("UBOOT_MKIMAGE_SIGN_ARGS"),
-        d.getVar('FIT_HASH_ALG'), d.getVar('FIT_SIGN_ALG'), d.getVar('FIT_PAD_ALG'),
-        d.getVar('FIT_KERNEL_SIGN_KEYNAME'),
-        oe.types.boolean(d.getVar('FIT_SIGN_INDIVIDUAL')), d.getVar('UBOOT_SIGN_IMG_KEYNAME')
-    )
-
-    # Prepare a kernel image section.
-    shutil.copyfile(os.path.join(kernel_deploydir, "linux.bin"), "linux.bin")
-    with open(os.path.join(kernel_deploydir, "linux_comp")) as linux_comp_f:
-        linux_comp = linux_comp_f.read()
-    root_node.fitimage_emit_section_kernel("kernel-1", "linux.bin", linux_comp,
-        d.getVar('UBOOT_LOADADDRESS'), d.getVar('UBOOT_ENTRYPOINT'),
-        d.getVar('UBOOT_MKIMAGE_KERNEL_TYPE'), d.getVar("UBOOT_ENTRYSYMBOL"))
-
-    # Prepare a DTB image section
-    kernel_devicetree = d.getVar('KERNEL_DEVICETREE')
-    external_kernel_devicetree = d.getVar("EXTERNAL_KERNEL_DEVICETREE")
-    if kernel_devicetree:
-        for dtb in kernel_devicetree.split():
-            # In deploy_dir the DTBs are without sub-directories also with KERNEL_DTBVENDORED = "1"
-            dtb_name = os.path.basename(dtb)
-
-            # Skip DTB if it's also provided in EXTERNAL_KERNEL_DEVICETREE directory
-            if external_kernel_devicetree:
-                ext_dtb_path = os.path.join(external_kernel_devicetree, dtb_name)
-                if os.path.exists(ext_dtb_path) and os.path.getsize(ext_dtb_path) > 0:
-                    continue
-
-            # Copy the dtb or dtbo file into the FIT image assembly directory
-            shutil.copyfile(os.path.join(kernel_deploydir, dtb_name), dtb_name)
-            root_node.fitimage_emit_section_dtb(dtb_name, dtb_name,
-                d.getVar("UBOOT_DTB_LOADADDRESS"), d.getVar("UBOOT_DTBO_LOADADDRESS"))
-
-    if external_kernel_devicetree:
-        # iterate over all .dtb and .dtbo files in the external kernel devicetree directory
-        # and copy them to the FIT image assembly directory
-        for dtb_name in sorted(os.listdir(external_kernel_devicetree)):
-            if dtb_name.endswith('.dtb') or dtb_name.endswith('.dtbo'):
-                dtb_path = os.path.join(external_kernel_devicetree, dtb_name)
-
-                # For symlinks, add a configuration node that refers to the DTB image node to which the symlink points
-                symlink_target = oe.fitimage.symlink_points_below(dtb_name, external_kernel_devicetree)
-                if symlink_target:
-                    root_node.fitimage_emit_section_dtb_alias(dtb_name, symlink_target, True)
-                # For real DTB files add an image node and a configuration node
-                else:
-                    shutil.copyfile(dtb_path, dtb_name)
-                    root_node.fitimage_emit_section_dtb(dtb_name, dtb_name,
-                        d.getVar("UBOOT_DTB_LOADADDRESS"), d.getVar("UBOOT_DTBO_LOADADDRESS"), True)
-
-    # Prepare a u-boot script section
-    fit_uboot_env = d.getVar("FIT_UBOOT_ENV")
-    if fit_uboot_env:
-        root_node.fitimage_emit_section_boot_script("bootscr-"+fit_uboot_env , fit_uboot_env)
-
-    # Prepare a setup section (For x86)
-    setup_bin_path = os.path.join(kernel_deploydir, "setup.bin")
-    if os.path.exists(setup_bin_path):
-        shutil.copyfile(setup_bin_path, "setup.bin")
-        root_node.fitimage_emit_section_setup("setup-1", "setup.bin")
-
-    # Prepare a ramdisk section.
-    initramfs_image = d.getVar('INITRAMFS_IMAGE')
-    if initramfs_image and d.getVar("INITRAMFS_IMAGE_BUNDLE") != '1':
-        # Find and use the first initramfs image archive type we find
-        found = False
-        for img in d.getVar("FIT_SUPPORTED_INITRAMFS_FSTYPES").split():
-            initramfs_path = os.path.join(d.getVar("DEPLOY_DIR_IMAGE"), "%s.%s" % (d.getVar('INITRAMFS_IMAGE_NAME'), img))
-            if os.path.exists(initramfs_path):
-                bb.note("Found initramfs image: " + initramfs_path)
-                found = True
-                root_node.fitimage_emit_section_ramdisk("ramdisk-1", initramfs_path,
-                    initramfs_image,
-                    d.getVar("UBOOT_RD_LOADADDRESS"),
-                    d.getVar("UBOOT_RD_ENTRYPOINT"))
-                break
-            else:
-                bb.note("Did not find initramfs image: " + initramfs_path)
-
-        if not found:
-            bb.fatal("Could not find a valid initramfs type for %s, the supported types are: %s" % (d.getVar('INITRAMFS_IMAGE_NAME'), d.getVar('FIT_SUPPORTED_INITRAMFS_FSTYPES')))
-
-    # Generate the configuration section
-    root_node.fitimage_emit_section_config(d.getVar("FIT_CONF_DEFAULT_DTB"))
-
-    # Write the its file
-    root_node.write_its_file(itsfile)
-
-    # Assemble the FIT image
-    root_node.run_mkimage_assemble(itsfile, fitname)
-
-    # Sign the FIT image if required
-    root_node.run_mkimage_sign(fitname)
-}
-do_compile[depends] += "virtual/kernel:do_deploy"
-
-do_install() {
-    install -d "${D}/${KERNEL_IMAGEDEST}"
-    install -m 0644 "${B}/fitImage" "${D}/${KERNEL_IMAGEDEST}/fitImage"
-}
-
-FILES:${PN} = "${KERNEL_IMAGEDEST}"
-
-
-do_deploy() {
-    deploy_dir="${DEPLOYDIR}"
-    if [ -n "${KERNEL_DEPLOYSUBDIR}" ]; then
-        deploy_dir="${DEPLOYDIR}/${KERNEL_DEPLOYSUBDIR}"
-    fi
-    install -d "$deploy_dir"
-    install -m 0644 "${B}/fitImage" "$deploy_dir/fitImage"
-    install -m 0644 "${B}/fit-image.its" "$deploy_dir/fit-image.its"
-
-    if [ "${INITRAMFS_IMAGE_BUNDLE}" != "1" ]; then
-        ln -snf fit-image.its "$deploy_dir/fitImage-its-${KERNEL_FIT_NAME}.its"
-        if [ -n "${KERNEL_FIT_LINK_NAME}" ] ; then
-            ln -snf fit-image.its "$deploy_dir/fitImage-its-${KERNEL_FIT_LINK_NAME}"
-        fi
-    fi
-
-    if [ -n "${INITRAMFS_IMAGE}" ]; then
-        ln -snf fit-image.its "$deploy_dir/fitImage-its-${INITRAMFS_IMAGE_NAME}-${KERNEL_FIT_NAME}.its"
-        if [ -n "${KERNEL_FIT_LINK_NAME}" ]; then
-            ln -snf fit-image.its "$deploy_dir/fitImage-its-${INITRAMFS_IMAGE_NAME}-${KERNEL_FIT_LINK_NAME}"
-        fi
-
-        if [ "${INITRAMFS_IMAGE_BUNDLE}" != "1" ]; then
-            ln -snf fitImage "$deploy_dir/fitImage-${INITRAMFS_IMAGE_NAME}-${KERNEL_FIT_NAME}${KERNEL_FIT_BIN_EXT}"
-            if [ -n "${KERNEL_FIT_LINK_NAME}" ] ; then
-                ln -snf fitImage "$deploy_dir/fitImage-${INITRAMFS_IMAGE_NAME}-${KERNEL_FIT_LINK_NAME}"
-            fi
-        fi
-    fi
-}
-addtask deploy after do_compile before do_build
diff --git a/meta/classes-recipe/kernel-grub.bbclass b/meta/classes-recipe/kernel-grub.bbclass
deleted file mode 100644
index 2325e635e1..0000000000
--- a/meta/classes-recipe/kernel-grub.bbclass
+++ /dev/null
@@ -1,111 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-#
-# While installing a rpm to update kernel on a deployed target, it will update
-# the boot area and the boot menu with the kernel as the priority but allow
-# you to fall back to the original kernel as well.
-#
-# - In kernel-image's preinstall scriptlet, it backs up original kernel to avoid
-#   probable confliction with the new one.
-#
-# - In kernel-image's postinstall scriptlet, it modifies grub's config file to
-#   updates the new kernel as the boot priority.
-#
-
-python __anonymous () {
-    import re
-
-    preinst = '''
-        # Parsing confliction
-        [ -f "$D/boot/grub/menu.list" ] && grubcfg="$D/boot/grub/menu.list"
-        [ -f "$D/boot/grub/grub.cfg" ] && grubcfg="$D/boot/grub/grub.cfg"
-        if [ -n "$grubcfg" ]; then
-                # Dereference symlink to avoid confliction with new kernel name.
-                if grep -q "/KERNEL_IMAGETYPE \+root=" $grubcfg; then
-                        if [ -L "$D/boot/KERNEL_IMAGETYPE" ]; then
-                                kimage=`realpath $D/boot/KERNEL_IMAGETYPE 2>/dev/null`
-                                if [ -f "$D$kimage" ]; then
-                                        sed -i "s:KERNEL_IMAGETYPE \+root=:${kimage##*/} root=:" $grubcfg
-                                fi
-                        fi
-                fi
-
-                # Rename old kernel if it conflicts with new kernel name.
-                if grep -q "/KERNEL_IMAGETYPE-${KERNEL_VERSION} \+root=" $grubcfg; then
-                        if [ -f "$D/boot/KERNEL_IMAGETYPE-${KERNEL_VERSION}" ]; then
-                                timestamp=`date +%s`
-                                kimage="$D/boot/KERNEL_IMAGETYPE-${KERNEL_VERSION}-$timestamp-back"
-                                sed -i "s:KERNEL_IMAGETYPE-${KERNEL_VERSION} \+root=:${kimage##*/} root=:" $grubcfg
-                                mv "$D/boot/KERNEL_IMAGETYPE-${KERNEL_VERSION}" "$kimage"
-                        fi
-                fi
-        fi
-'''
-
-    postinst = '''
-        get_new_grub_cfg() {
-                grubcfg="$1"
-                old_image="$2"
-                title="Update KERNEL_IMAGETYPE-${KERNEL_VERSION}-${PV}"
-                if [ "${grubcfg##*/}" = "grub.cfg" ]; then
-                        rootfs=`grep " *linux \+[^ ]\+ \+root=" $grubcfg -m 1 | \
-                                 sed "s#${old_image}#${old_image%/*}/KERNEL_IMAGETYPE-${KERNEL_VERSION}#"`
-
-                        echo "menuentry \"$title\" {"
-                        echo "    set root=(hd0,1)"
-                        echo "$rootfs"
-                        echo "}"
-                elif [ "${grubcfg##*/}" = "menu.list" ]; then
-                        rootfs=`grep "kernel \+[^ ]\+ \+root=" $grubcfg -m 1 | \
-                                 sed "s#${old_image}#${old_image%/*}/KERNEL_IMAGETYPE-${KERNEL_VERSION}#"`
-
-                        echo "default 0"
-                        echo "timeout 30"
-                        echo "title $title"
-                        echo "root  (hd0,0)"
-                        echo "$rootfs"
-                fi
-        }
-
-        get_old_grub_cfg() {
-                grubcfg="$1"
-                if [ "${grubcfg##*/}" = "grub.cfg" ]; then
-                        cat "$grubcfg"
-                elif [ "${grubcfg##*/}" = "menu.list" ]; then
-                        sed -e '/^default/d' -e '/^timeout/d' "$grubcfg"
-                fi
-        }
-
-        if [ -f "$D/boot/grub/grub.cfg" ]; then
-                grubcfg="$D/boot/grub/grub.cfg"
-                old_image=`grep ' *linux \+[^ ]\+ \+root=' -m 1 "$grubcfg" | awk '{print $2}'`
-        elif [ -f "$D/boot/grub/menu.list" ]; then
-                grubcfg="$D/boot/grub/menu.list"
-                old_image=`grep '^kernel \+[^ ]\+ \+root=' -m 1 "$grubcfg" | awk '{print $2}'`
-        fi
-
-        # Don't update grubcfg at first install while old bzImage doesn't exist.
-        if [ -f "$D/boot/${old_image##*/}" ]; then
-                grubcfgtmp="$grubcfg.tmp"
-                get_new_grub_cfg "$grubcfg" "$old_image"  > $grubcfgtmp
-                get_old_grub_cfg "$grubcfg" >> $grubcfgtmp
-                mv $grubcfgtmp $grubcfg
-                echo "Caution! Update kernel may affect kernel-module!"
-        fi
-'''
-
-    imagetypes = d.getVar('KERNEL_IMAGETYPES')
-    imagetypes = re.sub(r'\.gz$', '', imagetypes)
-
-    for type in imagetypes.split():
-        typelower = type.lower()
-        preinst_append = preinst.replace('KERNEL_IMAGETYPE', type)
-        postinst_prepend = postinst.replace('KERNEL_IMAGETYPE', type)
-        d.setVar('pkg_preinst:kernel-image-' + typelower + ':append', preinst_append)
-        d.setVar('pkg_postinst:kernel-image-' + typelower + ':prepend', postinst_prepend)
-}
-
diff --git a/meta/classes-recipe/kernel-module-split.bbclass b/meta/classes-recipe/kernel-module-split.bbclass
deleted file mode 100644
index 75ed696b72..0000000000
--- a/meta/classes-recipe/kernel-module-split.bbclass
+++ /dev/null
@@ -1,245 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-pkg_postinst:modules () {
-if [ -z "$D" ]; then
-        depmod -a ${KERNEL_VERSION}
-else
-        # image.bbclass will call depmodwrapper after everything is installed,
-        # no need to do it here as well
-        :
-fi
-}
-
-pkg_postrm:modules () {
-if [ -z "$D" ]; then
-        depmod -a ${KERNEL_VERSION}
-else
-        depmodwrapper -a -b $D ${KERNEL_VERSION} ${KERNEL_PACKAGE_NAME}
-fi
-}
-
-autoload_postinst_fragment() {
-if [ x"$D" = "x" ]; then
-        modprobe %s || true
-fi
-}
-
-PACKAGE_WRITE_DEPS += "kmod-native depmodwrapper-cross"
-
-modulesloaddir ??= "${@bb.utils.contains('DISTRO_FEATURES', 'systemd', '${nonarch_libdir}', '${sysconfdir}', d)}/modules-load.d"
-modprobedir ??= "${@bb.utils.contains('DISTRO_FEATURES', 'systemd', '${nonarch_base_libdir}', '${sysconfdir}', d)}/modprobe.d"
-
-KERNEL_SPLIT_MODULES ?= "1"
-PACKAGESPLITFUNCS =+ "split_kernel_module_packages"
-
-KERNEL_MODULES_META_PACKAGE ?= "${@ d.getVar("KERNEL_PACKAGE_NAME") or "kernel" }-modules"
-
-KERNEL_MODULE_PACKAGE_PREFIX ?= ""
-KERNEL_MODULE_PACKAGE_SUFFIX ?= "-${KERNEL_VERSION}"
-KERNEL_MODULE_PROVIDE_VIRTUAL ?= "1"
-
-python split_kernel_module_packages () {
-    import re
-
-    modinfoexp = re.compile("([^=]+)=(.*)")
-
-    def extract_modinfo(file):
-        import tempfile, subprocess
-        tempfile.tempdir = d.getVar("WORKDIR")
-        compressed = re.match( r'.*\.(gz|xz|zst)$', file)
-        tf = tempfile.mkstemp()
-        tmpfile = tf[1]
-        if compressed:
-            tmpkofile = tmpfile + ".ko"
-            if compressed.group(1) == 'gz':
-                cmd = "gunzip -dc %s > %s" % (file, tmpkofile)
-                subprocess.check_call(cmd, shell=True)
-            elif compressed.group(1) == 'xz':
-                cmd = "xz -dc %s > %s" % (file, tmpkofile)
-                subprocess.check_call(cmd, shell=True)
-            elif compressed.group(1) == 'zst':
-                cmd = "zstd -dc %s > %s" % (file, tmpkofile)
-                subprocess.check_call(cmd, shell=True)
-            else:
-                msg = "Cannot decompress '%s'" % file
-                raise msg
-            cmd = "%s -j .modinfo -O binary %s %s" % (d.getVar("OBJCOPY"), tmpkofile, tmpfile)
-        else:
-            cmd = "%s -j .modinfo -O binary %s %s" % (d.getVar("OBJCOPY"), file, tmpfile)
-        subprocess.check_call(cmd, shell=True)
-        # errors='replace': Some old kernel versions contain invalid utf-8 characters in mod descriptions (like 0xf6, 'ö')
-        with open(tmpfile, errors='replace') as f:
-            l = f.read().split("\000")
-        os.close(tf[0])
-        os.unlink(tmpfile)
-        if compressed:
-            os.unlink(tmpkofile)
-        vals = {}
-        for i in l:
-            m = modinfoexp.match(i)
-            if not m:
-                continue
-            vals[m.group(1)] = m.group(2)
-        return vals
-
-    def handle_conf_files(d, basename, pkg):
-        # If autoloading is requested, output ${modulesloaddir}/<name>.conf and append
-        # appropriate modprobe commands to the postinst
-        autoloadlist = (d.getVar("KERNEL_MODULE_AUTOLOAD") or "").split()
-        autoload = d.getVar('module_autoload_%s' % basename)
-        if autoload and autoload == basename:
-            bb.warn("module_autoload_%s was replaced by KERNEL_MODULE_AUTOLOAD for cases where basename == module name, please drop it" % basename)
-        if autoload and basename not in autoloadlist:
-            bb.warn("module_autoload_%s is defined but '%s' isn't included in KERNEL_MODULE_AUTOLOAD, please add it there" % (basename, basename))
-
-        # The .conf file can either be installed by a recipe or generated from module_autoload_*
-        conf = '%s/%s.conf' % (d.getVar('modulesloaddir'), basename)
-        name = '%s%s' % (d.getVar('PKGD'), conf)
-        # If module name is in KERNEL_MODULE_AUTOLOAD, then generate the .conf file and write to `name`.
-        if basename in autoloadlist:
-            os.makedirs(os.path.dirname(name), exist_ok=True)
-            with open(name, 'w') as f:
-                if autoload:
-                    for m in autoload.split():
-                        f.write('%s\n' % m)
-                else:
-                    f.write('%s\n' % basename)
-        # If the .conf file exits, then add it to FILES:* and CONFFILES:* and add postinstall hook.
-        # It doesn't matter if it was generated from module_autoload_* or installed by the recipe.
-        if os.path.exists(name):
-            conf2append = ' %s' % conf
-            d.appendVar('FILES:%s' % pkg, conf2append)
-            d.appendVar('CONFFILES:%s' % pkg, conf2append)
-            postinst = d.getVar('pkg_postinst:%s' % pkg)
-            if not postinst:
-                postinst = d.getVar('pkg_postinst:modules')
-            postinst += d.getVar('autoload_postinst_fragment') % (autoload or basename)
-            d.setVar('pkg_postinst:%s' % pkg, postinst)
-
-        # Write out any modconf fragment
-        modconflist = (d.getVar("KERNEL_MODULE_PROBECONF") or "").split()
-        modconf = d.getVar('module_conf_%s' % basename)
-
-        # The .conf file can either be installed by a recipe or generated from module_conf_*
-        conf = '%s/%s.conf' % (d.getVar('modprobedir'), basename)
-        name = '%s%s' % (d.getVar('PKGD'), conf)
-        # If module name is in KERNEL_MODULE_PROBECONF, then generate the .conf file and write to `name`.
-        if modconf and basename in modconflist:
-            os.makedirs(os.path.dirname(name), exist_ok=True)
-            with open(name, 'w') as f:
-                f.write("%s\n" % modconf)
-        elif modconf:
-            bb.error("Please ensure module %s is listed in KERNEL_MODULE_PROBECONF since module_conf_%s is set" % (basename, basename))
-        # If the .conf file exits, then add it to FILES:* and CONFFILES:*.
-        # It doesn't matter if it was generated from module_conf_* or installed by the recipe.
-        if os.path.exists(name):
-            conf2append = ' %s' % conf
-            d.appendVar('FILES:%s' % pkg, conf2append)
-            d.appendVar('CONFFILES:%s' % pkg, conf2append)
-
-    def generate_conf_files(d, root, file_regex, output_pattern):
-        """
-        Arguments:
-        root           -- the path in which to search. Contains system lib path
-                          so needs expansion.
-        file_regex     -- regular expression to match searched files. Use
-                          parentheses () to mark the part of this expression
-                          that should be used to derive the module name (to be
-                          substituted where %s is used in other function
-                          arguments as noted below)
-        output_pattern -- pattern to use for the package names. Must include %s.
-        """
-        import re, stat
-
-        dvar = d.getVar('PKGD')
-        root = d.expand(root)
-
-        # if the root directory doesn't exist, it's fatal - exit from the current execution.
-        if not os.path.exists(dvar + root):
-            bb.fatal("kernel module root directory path does not exist")
-
-        # walk through kernel module directory. for each entry in the directory, check if it
-        # matches the desired regex pattern and file type. if it fullfills, process it to generate
-        # it's conf file based on its package name.
-        for walkroot, dirs, files in os.walk(dvar + root):
-            for file in files:
-                relpath = os.path.join(walkroot, file).replace(dvar + root + '/', '', 1)
-                if not relpath:
-                    continue
-                m = re.match(file_regex, os.path.basename(relpath))
-                if not m:
-                    continue
-                file_f = os.path.join(dvar + root, relpath)
-                mode = os.lstat(file_f).st_mode
-                if not (stat.S_ISREG(mode) or (allow_links and stat.S_ISLNK(mode)) or (allow_dirs and stat.S_ISDIR(mode))):
-                    continue
-
-                basename = m.group(1)
-                on = legitimize_package_name(basename)
-                pkg = output_pattern % on
-                handle_conf_files(d, basename, pkg)
-
-
-    def frob_metadata(file, pkg, pattern, format, basename):
-        vals = extract_modinfo(file)
-        dvar = d.getVar('PKGD')
-
-        handle_conf_files(d, basename, pkg)
-
-        if "description" in vals:
-            old_desc = d.getVar('DESCRIPTION:' + pkg) or ""
-            d.setVar('DESCRIPTION:' + pkg, old_desc + "; " + vals["description"])
-
-        rdepends = bb.utils.explode_dep_versions2(d.getVar('RDEPENDS:' + pkg) or "")
-        modinfo_deps = []
-        if "depends" in vals and vals["depends"] != "":
-            for dep in vals["depends"].split(","):
-                on = legitimize_package_name(dep)
-                dependency_pkg = format % on
-                modinfo_deps.append(dependency_pkg)
-        for dep in modinfo_deps:
-            if not dep in rdepends:
-                rdepends[dep] = []
-        d.setVar('RDEPENDS:' + pkg, bb.utils.join_deps(rdepends, commasep=False))
-
-        # Avoid automatic -dev recommendations for modules ending with -dev.
-        d.setVarFlag('RRECOMMENDS:' + pkg, 'nodeprrecs', 1)
-
-        # Provide virtual package without postfix
-        providevirt = d.getVar('KERNEL_MODULE_PROVIDE_VIRTUAL')
-        if providevirt == "1":
-           postfix = format.split('%s')[1]
-           d.setVar('RPROVIDES:' + pkg, pkg.replace(postfix, ''))
-
-    kernel_package_name = d.getVar("KERNEL_PACKAGE_NAME") or "kernel"
-    kernel_version = d.getVar("KERNEL_VERSION")
-
-    metapkg = d.getVar('KERNEL_MODULES_META_PACKAGE')
-    splitmods = d.getVar('KERNEL_SPLIT_MODULES')
-    postinst = d.getVar('pkg_postinst:modules')
-    postrm = d.getVar('pkg_postrm:modules')
-
-    module_regex = r'^(.*)\.k?o(?:\.(gz|xz|zst))?$'
-
-    module_pattern_prefix = d.getVar('KERNEL_MODULE_PACKAGE_PREFIX')
-    module_pattern_suffix = d.getVar('KERNEL_MODULE_PACKAGE_SUFFIX')
-    module_pattern = module_pattern_prefix + kernel_package_name + '-module-%s' + module_pattern_suffix
-
-    if splitmods != '1':
-        d.appendVar('FILES:' + metapkg, '%s %s %s/modules' %
-            (d.getVar('modulesloaddir'), d.getVar('modprobedir'), d.getVar("nonarch_base_libdir")))
-        d.appendVar('pkg_postinst:%s' % metapkg, postinst)
-        d.prependVar('pkg_postrm:%s' % metapkg, postrm)
-        generate_conf_files(d, root='${nonarch_base_libdir}/modules', file_regex=module_regex, output_pattern=module_pattern)
-        return
-
-    modules = do_split_packages(d, root='${nonarch_base_libdir}/modules', file_regex=module_regex, output_pattern=module_pattern, description='%s kernel module', postinst=postinst, postrm=postrm, recursive=True, hook=frob_metadata, extra_depends='%s-%s' % (kernel_package_name, kernel_version))
-    if modules:
-        d.appendVar('RDEPENDS:' + metapkg, ' '+' '.join(modules))
-}
-
-do_package[vardeps] += '${@" ".join(map(lambda s: "module_conf_" + s, (d.getVar("KERNEL_MODULE_PROBECONF") or "").split()))}'
diff --git a/meta/classes-recipe/kernel-uboot.bbclass b/meta/classes-recipe/kernel-uboot.bbclass
deleted file mode 100644
index 62974baaf0..0000000000
--- a/meta/classes-recipe/kernel-uboot.bbclass
+++ /dev/null
@@ -1,59 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-# fitImage kernel compression algorithm
-FIT_KERNEL_COMP_ALG ?= "gzip"
-FIT_KERNEL_COMP_ALG_EXTENSION ?= ".gz"
-
-# Kernel image type passed to mkimage (i.e. kernel kernel_noload...)
-UBOOT_MKIMAGE_KERNEL_TYPE ?= "kernel"
-
-uboot_prep_kimage() {
-        output_dir=$1
-        # For backward compatibility with kernel-fitimage.bbclass and kernel-uboot.bbclass
-        # support calling without parameter as well
-        if [ -z "$output_dir" ]; then
-                output_dir='.'
-        fi
-
-        linux_bin=$output_dir/linux.bin
-        if [ -e "arch/${ARCH}/boot/compressed/vmlinux" ]; then
-                vmlinux_path="arch/${ARCH}/boot/compressed/vmlinux"
-                linux_suffix=""
-                linux_comp="none"
-        elif [ -e "arch/${ARCH}/boot/vmlinuz.bin" ]; then
-                rm -f "$linux_bin"
-                cp -l "arch/${ARCH}/boot/vmlinuz.bin" "$linux_bin"
-                vmlinux_path=""
-                linux_suffix=""
-                linux_comp="none"
-        else
-                vmlinux_path="vmlinux"
-                # Use vmlinux.initramfs for $linux_bin when INITRAMFS_IMAGE_BUNDLE set
-                # As per the implementation in kernel.bbclass.
-                # See do_bundle_initramfs function
-                if [ "${INITRAMFS_IMAGE_BUNDLE}" = "1" ] && [ -e vmlinux.initramfs ]; then
-                        vmlinux_path="vmlinux.initramfs"
-                fi
-                linux_suffix="${FIT_KERNEL_COMP_ALG_EXTENSION}"
-                linux_comp="${FIT_KERNEL_COMP_ALG}"
-        fi
-
-        [ -n "$vmlinux_path" ] && ${KERNEL_OBJCOPY} -O binary -R .note -R .comment -S "$vmlinux_path" "$linux_bin"
-
-        if [ "$linux_comp" != "none" ] ; then
-                if [ "$linux_comp" = "gzip" ] ; then
-                        gzip -9 "$linux_bin"
-                elif [ "$linux_comp" = "lzo" ] ; then
-                        lzop -9 "$linux_bin"
-                elif [ "$linux_comp" = "lzma" ] ; then
-                        xz --format=lzma -f -6 "$linux_bin"
-                fi
-                mv -f "$linux_bin$linux_suffix" "$linux_bin"
-        fi
-
-        printf "$linux_comp" > "$output_dir/linux_comp"
-}
diff --git a/meta/classes-recipe/kernel-uimage.bbclass b/meta/classes-recipe/kernel-uimage.bbclass
deleted file mode 100644
index e353232a0e..0000000000
--- a/meta/classes-recipe/kernel-uimage.bbclass
+++ /dev/null
@@ -1,42 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-inherit kernel-uboot
-
-python __anonymous () {
-    if "uImage" in d.getVar('KERNEL_IMAGETYPES'):
-        depends = d.getVar("DEPENDS")
-        depends = "%s u-boot-tools-native" % depends
-        d.setVar("DEPENDS", depends)
-
-        # Override KERNEL_IMAGETYPE_FOR_MAKE variable, which is internal
-        # to kernel.bbclass . We override the variable here, since we need
-        # to build uImage using the kernel build system if and only if
-        # KEEPUIMAGE == yes. Otherwise, we pack compressed vmlinux into
-        # the uImage .
-        if d.getVar("KEEPUIMAGE") != 'yes':
-            typeformake = d.getVar("KERNEL_IMAGETYPE_FOR_MAKE") or ""
-            if "uImage" in typeformake.split():
-                d.setVar('KERNEL_IMAGETYPE_FOR_MAKE', typeformake.replace('uImage', 'vmlinux'))
-
-            # Enable building of uImage with mkimage
-            bb.build.addtask('do_uboot_mkimage', 'do_install', 'do_kernel_link_images', d)
-}
-
-do_uboot_mkimage[dirs] += "${B}"
-do_uboot_mkimage() {
-        uboot_prep_kimage
-        linux_comp="$(cat linux_comp)"
-
-        ENTRYPOINT=${UBOOT_ENTRYPOINT}
-        if [ -n "${UBOOT_ENTRYSYMBOL}" ]; then
-                ENTRYPOINT=`${HOST_PREFIX}nm ${B}/vmlinux | \
-                        awk '$3=="${UBOOT_ENTRYSYMBOL}" {print "0x"$1;exit}'`
-        fi
-
-        uboot-mkimage -A ${UBOOT_ARCH} -O linux -T ${UBOOT_MKIMAGE_KERNEL_TYPE} -C "$linux_comp" -a ${UBOOT_LOADADDRESS} -e $ENTRYPOINT -n "${DISTRO_NAME}/${PV}/${MACHINE}" -d linux.bin ${B}/arch/${ARCH}/boot/uImage
-        rm -f linux.bin
-}
diff --git a/meta/classes-recipe/kernel-yocto.bbclass b/meta/classes-recipe/kernel-yocto.bbclass
deleted file mode 100644
index e53bf15194..0000000000
--- a/meta/classes-recipe/kernel-yocto.bbclass
+++ /dev/null
@@ -1,778 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-# remove tasks that modify the source tree in case externalsrc is inherited
-SRCTREECOVEREDTASKS += "do_validate_branches do_kernel_configcheck do_kernel_checkout do_fetch do_unpack do_patch"
-PATCH_GIT_USER_EMAIL ?= "kernel-yocto@oe"
-PATCH_GIT_USER_NAME ?= "OpenEmbedded"
-
-# The distro or local.conf should set this, but if nobody cares...
-LINUX_KERNEL_TYPE ??= "standard"
-
-# KMETA ?= ""
-KBRANCH ?= "master"
-KMACHINE ?= "${MACHINE}"
-SRCREV_FORMAT ?= "meta_machine"
-
-# LEVELS:
-#   0: no reporting
-#   1: report options that are specified, but not in the final config
-#   2: report options that are not hardware related, but set by a BSP
-KCONF_AUDIT_LEVEL ?= "1"
-KCONF_BSP_AUDIT_LEVEL ?= "0"
-KMETA_AUDIT ?= "yes"
-KMETA_AUDIT_WERROR ?= ""
-KMETA_CONFIG_FEATURES ?= ""
-
-# returns local (absolute) path names for all valid patches in the
-# src_uri
-def find_patches(d,subdir):
-    patches = src_patches(d)
-    patch_list=[]
-    for p in patches:
-        _, _, local, _, _, parm = bb.fetch.decodeurl(p)
-        # if patchdir has been passed, we won't be able to apply it so skip
-        # the patch for now, and special processing happens later
-        patchdir = ''
-        if "patchdir" in parm:
-            patchdir = parm["patchdir"]
-        if subdir:
-            if subdir == patchdir:
-                patch_list.append(local)
-        else:
-            # skip the patch if a patchdir was supplied, it won't be handled
-            # properly
-            if not patchdir:
-                patch_list.append(local)
-
-    return patch_list
-
-# returns all the elements from the src uri that are .scc files
-def find_sccs(d):
-    sources=src_patches(d, True)
-    sources_list=[]
-    for s in sources:
-        base, ext = os.path.splitext(os.path.basename(s))
-        if ext and ext in [".scc", ".cfg"]:
-            sources_list.append(s)
-        elif base and 'defconfig' in base:
-            sources_list.append(s)
-
-    return sources_list
-
-# check the SRC_URI for "kmeta" type'd git repositories and directories. Return
-# the name of the repository or directory as it will be found in UNPACKDIR
-def find_kernel_feature_dirs(d):
-    feature_dirs=[]
-    fetch = bb.fetch2.Fetch([], d)
-    for url in fetch.urls:
-        urldata = fetch.ud[url]
-        parm = urldata.parm
-        type=""
-        destdir = ""
-        if "type" in parm:
-            type = parm["type"]
-        if "destsuffix" in parm:
-            destdir = parm["destsuffix"]
-        elif urldata.type == "file":
-            destdir = urldata.basepath
-        if type == "kmeta" and destdir:
-            feature_dirs.append(destdir)
-
-    return feature_dirs
-
-# find the master/machine source branch. In the same way that the fetcher proceses
-# git repositories in the SRC_URI we take the first repo found, first branch.
-def get_machine_branch(d, default):
-    fetch = bb.fetch2.Fetch([], d)
-    for url in fetch.urls:
-        urldata = fetch.ud[url]
-        parm = urldata.parm
-        if "branch" in parm:
-            branches = urldata.parm.get("branch").split(',')
-            btype = urldata.parm.get("type")
-            if btype != "kmeta":
-                return branches[0]
-            
-    return default
-
-# returns a list of all directories that are on FILESEXTRAPATHS (and
-# hence available to the build) that contain .scc or .cfg files
-def get_dirs_with_fragments(d):
-    extrapaths = []
-    extrafiles = []
-    extrapathsvalue = (d.getVar("FILESEXTRAPATHS") or "")
-    # Remove default flag which was used for checking
-    extrapathsvalue = extrapathsvalue.replace("__default:", "")
-    extrapaths = extrapathsvalue.split(":")
-    for path in extrapaths:
-        if path + ":True" not in extrafiles:
-            extrafiles.append(path + ":" + str(os.path.exists(path)))
-
-    return " ".join(extrafiles)
-
-do_kernel_metadata() {
-        set +e
-
-        if [ -n "$1" ]; then
-                mode="$1"
-        else
-                mode="patch"
-        fi
-
-        cd ${S}
-        export KMETA=${KMETA}
-
-        bbnote "do_kernel_metadata: for summary/debug, set KCONF_AUDIT_LEVEL > 0"
-
-        # if kernel tools are available in-tree, they are preferred
-        # and are placed on the path before any external tools. Unless
-        # the external tools flag is set, in that case we do nothing.
-        if [ -f "${S}/scripts/util/configme" ]; then
-                if [ -z "${EXTERNAL_KERNEL_TOOLS}" ]; then
-                        PATH=${S}/scripts/util:${PATH}
-                fi
-        fi
-
-        # In a similar manner to the kernel itself:
-        #
-        #   defconfig: $(obj)/conf
-        #   ifeq ($(KBUILD_DEFCONFIG),)
-        #       $< --defconfig $(Kconfig)
-        #   else
-        #       @echo "*** Default configuration is based on '$(KBUILD_DEFCONFIG)'"
-        #       $(Q)$< --defconfig=arch/$(SRCARCH)/configs/$(KBUILD_DEFCONFIG) $(Kconfig)
-        #   endif
-        #
-        # If a defconfig is specified via the KBUILD_DEFCONFIG variable, we copy it
-        # from the source tree, into a common location and normalized "defconfig" name,
-        # where the rest of the process will include and incoroporate it into the build
-        #
-        if [ -n "${KBUILD_DEFCONFIG}" ]; then
-                if [ -f "${S}/arch/${ARCH}/configs/${KBUILD_DEFCONFIG}" ]; then
-                        if [ -f "${UNPACKDIR}/defconfig" ]; then
-                                # If the two defconfig's are different, warn that we overwrote the
-                                # one already placed in UNPACKDIR
-                                cmp "${UNPACKDIR}/defconfig" "${S}/arch/${ARCH}/configs/${KBUILD_DEFCONFIG}"
-                                if [ $? -ne 0 ]; then
-                                        bbdebug 1 "detected SRC_URI or patched defconfig in UNPACKDIR. ${KBUILD_DEFCONFIG} copied over it"
-                                fi
-                        fi
-                        cp -f ${S}/arch/${ARCH}/configs/${KBUILD_DEFCONFIG} ${UNPACKDIR}/defconfig
-                        in_tree_defconfig="${UNPACKDIR}/defconfig"
-                else
-                        bbfatal "A KBUILD_DEFCONFIG '${KBUILD_DEFCONFIG}' was specified, but not present in the source tree (${S}/arch/${ARCH}/configs/)"
-                fi
-        fi
-
-        if [ "$mode" = "patch" ]; then
-                # was anyone trying to patch the kernel meta data ?, we need to do
-                # this here, since the scc commands migrate the .cfg fragments to the
-                # kernel source tree, where they'll be used later.
-                check_git_config
-                patches="${@" ".join(find_patches(d,'kernel-meta'))}"
-                if [ -n "$patches" ]; then
-                    (
-                            cd ${UNPACKDIR}/kernel-meta
-
-                            # take the SRC_URI patches, and create a series file
-                            # this is required to support some better processing
-                            # of issues with the patches
-                            rm -f series
-                            for p in $patches; do
-                                cp $p .
-                                echo "$(basename $p)" >> series
-                            done
-
-                            # process the series with kgit-s2q, which is what is
-                            # handling the rest of the kernel. This allows us
-                            # more flexibility for handling failures or advanced
-                            # mergeing functinoality
-                            message=$(kgit-s2q --gen -v --patches ${UNPACKDIR}/kernel-meta 2>&1)
-                            if [ $? -ne 0 ]; then
-                                # setup to try the patch again
-                                kgit-s2q --prev
-                                bberror "Problem applying patches to: ${UNPACKDIR}/kernel-meta"
-                                bbfatal_log "\n($message)"
-                            fi
-                        )
-                fi
-        fi
-
-        sccs_from_src_uri="${@" ".join(find_sccs(d))}"
-        patches="${@" ".join(find_patches(d,''))}"
-        feat_dirs="${@" ".join(find_kernel_feature_dirs(d))}"
-
-        # a quick check to make sure we don't have duplicate defconfigs If
-        # there's a defconfig in the SRC_URI, did we also have one from the
-        # KBUILD_DEFCONFIG processing above ?
-        src_uri_defconfig=$(echo $sccs_from_src_uri | awk '(match($0, "defconfig") != 0) { print $0 }' RS=' ')
-        # drop and defconfig's from the src_uri variable, we captured it just above here if it existed
-        sccs_from_src_uri=$(echo $sccs_from_src_uri | awk '(match($0, "defconfig") == 0) { print $0 }' RS=' ')
-
-        if [ -n "$in_tree_defconfig" ]; then
-                sccs_defconfig=$in_tree_defconfig
-                if [ -n "$src_uri_defconfig" ]; then
-                        bbwarn "[NOTE]: defconfig was supplied both via KBUILD_DEFCONFIG and SRC_URI. Dropping SRC_URI entry $src_uri_defconfig"
-                fi
-        else
-                # if we didn't have an in-tree one, make our defconfig the one
-                # from the src_uri. Note: there may not have been one from the
-                # src_uri, so this can be an empty variable.
-                sccs_defconfig=$src_uri_defconfig
-        fi
-        sccs="$sccs_from_src_uri"
-
-        # check for feature directories/repos/branches that were part of the
-        # SRC_URI. If they were supplied, we convert them into include directives
-        # for the update part of the process
-        for f in ${feat_dirs}; do
-                if [ -d "${UNPACKDIR}/$f/kernel-meta" ]; then
-                        includes="$includes -I${UNPACKDIR}/$f/kernel-meta"
-                elif [ -d "${UNPACKDIR}/$f" ]; then
-                        includes="$includes -I${UNPACKDIR}/$f"
-                fi
-        done
-        for s in ${sccs} ${patches}; do
-                sdir=$(dirname $s)
-                includes="$includes -I${sdir}"
-                # if a SRC_URI passed patch or .scc has a subdir of "kernel-meta",
-                # then we add it to the search path
-                if [ -d "${sdir}/kernel-meta" ]; then
-                        includes="$includes -I${sdir}/kernel-meta"
-                fi
-        done
-
-        # allow in-tree config fragments to be used in KERNEL_FEATURES
-        includes="$includes -I${S}/arch/${ARCH}/configs -I${S}/kernel/configs"
-
-        # expand kernel features into their full path equivalents
-        bsp_definition=$(spp ${includes} --find -DKMACHINE=${KMACHINE} -DKTYPE=${LINUX_KERNEL_TYPE})
-        if [ -z "$bsp_definition" ]; then
-                if [ -z "$sccs_defconfig" ]; then
-                        bbfatal_log "Could not locate BSP definition for ${KMACHINE}/${LINUX_KERNEL_TYPE} and no defconfig was provided"
-                fi
-        else
-                # if the bsp definition has "define KMETA_EXTERNAL_BSP t",
-                # then we need to set a flag that will instruct the next
-                # steps to use the BSP as both configuration and patches.
-                grep -q KMETA_EXTERNAL_BSP $bsp_definition
-                if [ $? -eq 0 ]; then
-                    KMETA_EXTERNAL_BSPS="t"
-                fi
-        fi
-        meta_dir=$(kgit --meta)
-
-        KERNEL_FEATURES_FINAL=""
-        if [ -n "${KERNEL_FEATURES}" ]; then
-                for feature in ${KERNEL_FEATURES}; do
-                        feature_as_specified="$feature"
-                        feature="$(echo $feature_as_specified | cut -d: -f1)"
-                        feature_specifier="$(echo $feature_as_specified | cut -d: -f2)"
-                        feature_found=f
-                        for d in $includes; do
-                                path_to_check=$(echo $d | sed 's/^-I//')
-                                if [ "$feature_found" = "f" ] && [ -e "$path_to_check/$feature" ]; then
-                                    feature_found=t
-                                fi
-                        done
-                        if [ "$feature_found" = "f" ]; then
-                                if [ -n "${KERNEL_DANGLING_FEATURES_WARN_ONLY}" ]; then
-                                    bbwarn "Feature '$feature' not found, but KERNEL_DANGLING_FEATURES_WARN_ONLY is set"
-                                    bbwarn "This may cause runtime issues, dropping feature and allowing configuration to continue"
-                                else
-                                    bberror "Feature '$feature' not found, this will cause configuration failures."
-                                    bberror "Check the SRC_URI for meta-data repositories or directories that may be missing"
-                                    bbfatal_log "Set KERNEL_DANGLING_FEATURES_WARN_ONLY to ignore this issue"
-                                fi
-                        else
-                                KERNEL_FEATURES_FINAL="$KERNEL_FEATURES_FINAL $feature_as_specified"
-                        fi
-                done
-        fi
-
-        if [ "$mode" = "config" ]; then
-                # run1: pull all the configuration fragments, no matter where they come from
-                elements="`echo -n ${bsp_definition} $sccs_defconfig ${sccs} ${patches} $KERNEL_FEATURES_FINAL`"
-                if [ -n "${elements}" ]; then
-                        echo "${bsp_definition}" > ${S}/${meta_dir}/bsp_definition
-                        echo "${KMETA_CONFIG_FEATURES}" | grep -q "prefer-modules"
-                        if [ $? -eq 0 ]; then
-                                scc_defines="-DMODULE_OR_Y=m"
-                        fi
-                        scc --force $scc_defines -o ${S}/${meta_dir}:cfg,merge,meta ${includes} $sccs_defconfig $bsp_definition $sccs $patches $KERNEL_FEATURES_FINAL
-                        if [ $? -ne 0 ]; then
-                                bbfatal_log "Could not generate configuration queue for ${KMACHINE}."
-                        fi
-                fi
-        fi
-
-        # if KMETA_EXTERNAL_BSPS has been set, or it has been detected from
-        # the bsp definition, then we inject the bsp_definition into the
-        # patch phase below.  we'll piggy back on the sccs variable.
-        if [ -n "${KMETA_EXTERNAL_BSPS}" ]; then
-                sccs="${bsp_definition} ${sccs}"
-        fi
-
-        if [ "$mode" = "patch" ]; then
-                # run2: only generate patches for elements that have been passed on the SRC_URI
-                elements="`echo -n ${sccs} ${patches} $KERNEL_FEATURES_FINAL`"
-                if [ -n "${elements}" ]; then
-                        scc --force -o ${S}/${meta_dir}:patch --cmds patch ${includes} ${sccs} ${patches} $KERNEL_FEATURES_FINAL
-                        if [ $? -ne 0 ]; then
-                                bbfatal_log "Could not generate configuration queue for ${KMACHINE}."
-                        fi
-                fi
-        fi
-
-        if [ ${KCONF_AUDIT_LEVEL} -gt 0 ]; then
-                bbnote "kernel meta data summary for ${KMACHINE} (${LINUX_KERNEL_TYPE}):"
-                bbnote "======================================================================"
-                if [ -n "${KMETA_EXTERNAL_BSPS}" ]; then
-                        bbnote "Non kernel-cache (external) bsp"
-                fi
-                bbnote "BSP entry point / definition: $bsp_definition"
-                if [ -n "$in_tree_defconfig" ]; then
-                        bbnote "KBUILD_DEFCONFIG: ${KBUILD_DEFCONFIG}"
-                fi
-                bbnote "Fragments from SRC_URI: $sccs_from_src_uri"
-                bbnote "KERNEL_FEATURES: $KERNEL_FEATURES_FINAL"
-                bbnote "Final scc/cfg list: $sccs_defconfig $bsp_definition $sccs $KERNEL_FEATURES_FINAL"
-        fi
-
-        set -e
-}
-
-do_patch() {
-        set +e
-        cd ${S}
-
-        check_git_config
-        if [ "${KERNEL_DEBUG_TIMESTAMPS}" != "1" ]; then
-                reproducible_git_committer_author
-        fi
-        meta_dir=$(kgit --meta)
-        (cd ${meta_dir}; ln -sf patch.queue series)
-        if [ -f "${meta_dir}/series" ]; then
-                kgit_extra_args=""
-                if [ "${KERNEL_DEBUG_TIMESTAMPS}" != "1" ]; then
-                    kgit_extra_args="--commit-sha author"
-                fi
-                kgit-s2q --gen -v $kgit_extra_args --patches .kernel-meta/
-                if [ $? -ne 0 ]; then
-                        bberror "Could not apply patches for ${KMACHINE}."
-                        bbfatal_log "Patch failures can be resolved in the linux source directory ${S})"
-                fi
-        fi
-
-        if [ -f "${meta_dir}/merge.queue" ]; then
-                # we need to merge all these branches
-                for b in $(cat ${meta_dir}/merge.queue); do
-                        git show-ref --verify --quiet refs/heads/${b}
-                        if [ $? -eq 0 ]; then
-                                bbnote "Merging branch ${b}"
-                                git merge -q --no-ff -m "Merge branch ${b}" ${b}
-                        else
-                                bbfatal "branch ${b} does not exist, cannot merge"
-                        fi
-                done
-        fi
-
-        set -e
-}
-
-do_kernel_checkout() {
-        set +e
-
-        source_dir=`echo ${S} | sed 's%/$%%'`
-        source_unpackdir="${UNPACKDIR}/${BB_GIT_DEFAULT_DESTSUFFIX}"
-        if [ -d "${source_unpackdir}" ]; then
-                # case: git repository
-                # if S is UNPACKDIR/BB_GIT_DEFAULT_DESTSUFFIX, then we shouldn't be moving or deleting the tree.
-                if [ "${source_dir}" != "${source_unpackdir}" ]; then
-                        if [ -d "${source_unpackdir}/.git" ]; then
-                                # regular git repository with .git
-                                rm -rf ${S}
-                                mv ${source_unpackdir} ${S}
-                        else
-                                # create source for bare cloned git repository
-                                git clone ${source_unpackdir} ${S}
-                                rm -rf ${source_unpackdir}
-                        fi
-                fi
-                cd ${S}
-
-                # convert any remote branches to local tracking ones
-                for i in `git branch -a --no-color | grep remotes | grep -v HEAD`; do
-                        b=`echo $i | cut -d' ' -f2 | sed 's%remotes/origin/%%'`;
-                        git show-ref --quiet --verify -- "refs/heads/$b"
-                        if [ $? -ne 0 ]; then
-                                git branch $b $i > /dev/null
-                        fi
-                done
-
-                # Create a working tree copy of the kernel by checking out a branch
-                machine_branch="${@ get_machine_branch(d, "${KBRANCH}" )}"
-
-                # checkout and clobber any unimportant files
-                git checkout -f ${machine_branch}
-        else
-                # case: we have no git repository at all. 
-                # To support low bandwidth options for building the kernel, we'll just 
-                # convert the tree to a git repo and let the rest of the process work unchanged
-                
-                # if ${S} hasn't been set to the proper subdirectory a default of "linux" is 
-                # used, but we can't initialize that empty directory. So check it and throw a
-                # clear error
-
-                cd ${S}
-                if [ ! -f "Makefile" ]; then
-                        bberror "S is not set to the linux source directory. Check "
-                        bbfatal "the recipe and set S to the proper extracted subdirectory"
-                fi
-                rm -f .gitignore
-                git init
-                check_git_config
-                if [ "${KERNEL_DEBUG_TIMESTAMPS}" != "1" ]; then
-                        reproducible_git_committer_author
-                fi
-                git add .
-                git commit -q -n -m "baseline commit: creating repo for ${PN}-${PV}"
-                git clean -d -f
-        fi
-
-        set -e
-}
-do_kernel_checkout[dirs] = "${S} ${UNPACKDIR}"
-
-addtask kernel_checkout before do_kernel_metadata after do_symlink_kernsrc
-addtask kernel_metadata after do_validate_branches do_unpack before do_patch
-do_kernel_metadata[depends] = "kern-tools-native:do_populate_sysroot"
-do_kernel_metadata[file-checksums] = " ${@get_dirs_with_fragments(d)}"
-do_validate_branches[depends] = "kern-tools-native:do_populate_sysroot"
-
-# ${S} doesn't exist for us at unpack
-do_qa_unpack() {
-    return
-}
-
-do_kernel_configme[depends] += "virtual/cross-binutils:do_populate_sysroot"
-do_kernel_configme[depends] += "virtual/cross-cc:do_populate_sysroot"
-do_kernel_configme[depends] += "bc-native:do_populate_sysroot bison-native:do_populate_sysroot"
-do_kernel_configme[depends] += "kern-tools-native:do_populate_sysroot"
-do_kernel_configme[dirs] += "${S} ${B}"
-do_kernel_configme() {
-        do_kernel_metadata config
-
-        # translate the kconfig_mode into something that merge_config.sh
-        # understands
-        case ${KCONFIG_MODE} in
-                *allnoconfig)
-                        config_flags="-n"
-                        ;;
-                *alldefconfig)
-                        config_flags=""
-                        ;;
-                *)
-                        if [ -f ${UNPACKDIR}/defconfig ]; then
-                                config_flags="-n"
-                        fi
-                        ;;
-        esac
-
-        cd ${S}
-
-        meta_dir=$(kgit --meta)
-        configs="$(scc --configs -o ${meta_dir})"
-        if [ $? -ne 0 ]; then
-                bberror "${configs}"
-                bbfatal_log "Could not find configuration queue (${meta_dir}/config.queue)"
-        fi
-
-        CFLAGS="${CFLAGS} ${TOOLCHAIN_OPTIONS}" HOSTCC="${BUILD_CC} ${BUILD_CFLAGS} ${BUILD_LDFLAGS}" HOSTCPP="${BUILD_CPP}" CC="${KERNEL_CC}" LD="${KERNEL_LD}" OBJCOPY="${KERNEL_OBJCOPY}" STRIP="${KERNEL_STRIP}" ARCH=${ARCH} merge_config.sh -O ${B} ${config_flags} ${configs} > ${meta_dir}/cfg/merge_config_build.log 2>&1
-        if [ $? -ne 0 -o ! -f ${B}/.config ]; then
-                bberror "Could not generate a .config for ${KMACHINE}-${LINUX_KERNEL_TYPE}"
-                if [ ${KCONF_AUDIT_LEVEL} -gt 1 ]; then
-                        bbfatal_log "`cat ${meta_dir}/cfg/merge_config_build.log`"
-                else
-                        bbfatal_log "Details can be found at: ${S}/${meta_dir}/cfg/merge_config_build.log"
-                fi
-        fi
-
-        if [ ! -z "${LINUX_VERSION_EXTENSION}" ]; then
-                echo "# Global settings from linux recipe" >> ${B}/.config
-                echo "CONFIG_LOCALVERSION="\"${LINUX_VERSION_EXTENSION}\" >> ${B}/.config
-        fi
-}
-
-addtask kernel_configme before do_configure after do_patch
-addtask config_analysis
-
-do_config_analysis[depends] = "virtual/kernel:do_configure"
-do_config_analysis[depends] += "kern-tools-native:do_populate_sysroot"
-
-CONFIG_AUDIT_FILE ?= "${WORKDIR}/config-audit.txt"
-CONFIG_ANALYSIS_FILE ?= "${WORKDIR}/config-analysis.txt"
-
-python do_config_analysis() {
-    import re, string, sys, subprocess
-
-    s = d.getVar('S')
-
-    env = os.environ.copy()
-    env['PATH'] = "%s:%s%s" % (d.getVar('PATH'), s, "/scripts/util/")
-    env['LD'] = d.getVar('KERNEL_LD')
-    env['CC'] = d.getVar('KERNEL_CC')
-    env['OBJCOPY'] = d.getVar('KERNEL_OBJCOPY')
-    env['STRIP'] = d.getVar('KERNEL_STRIP')
-    env['ARCH'] = d.getVar('ARCH')
-    env['srctree'] = s
-
-    # read specific symbols from the kernel recipe or from local.conf
-    # i.e.: CONFIG_ANALYSIS:pn-linux-yocto-dev = 'NF_CONNTRACK LOCALVERSION'
-    config = d.getVar( 'CONFIG_ANALYSIS' )
-    if not config:
-       config = [ "" ]
-    else:
-       config = config.split()
-
-    for c in config:
-        for action in ["analysis","audit"]:
-            if action == "analysis":
-                try:
-                    analysis = subprocess.check_output(['symbol_why.py', '--dotconfig',  '{}'.format( d.getVar('B') + '/.config' ), '--blame', c], cwd=s, env=env ).decode('utf-8')
-                except subprocess.CalledProcessError as e:
-                    bb.fatal( "config analysis failed when running '%s': %s" % (" ".join(e.cmd), e.output.decode('utf-8')))
-
-                outfile = d.getVar( 'CONFIG_ANALYSIS_FILE' )
-
-            if action == "audit":
-                try:
-                    analysis = subprocess.check_output(['symbol_why.py', '--dotconfig',  '{}'.format( d.getVar('B') + '/.config' ), '--summary', '--extended', '--sanity', c], cwd=s, env=env ).decode('utf-8')
-                except subprocess.CalledProcessError as e:
-                    bb.fatal( "config analysis failed when running '%s': %s" % (" ".join(e.cmd), e.output.decode('utf-8')))
-
-                outfile = d.getVar( 'CONFIG_AUDIT_FILE' )
-
-            if c:
-                outdir = os.path.dirname( outfile )
-                outname = os.path.basename( outfile )
-                outfile = outdir + '/'+ c + '-' + outname
-
-            if config and os.path.isfile(outfile):
-                os.remove(outfile)
-
-            with open(outfile, 'w+') as f:
-                f.write( analysis )
-
-            bb.warn( "Configuration {} executed, see: {} for details".format(action,outfile ))
-            if c:
-                bb.warn( analysis )
-}
-
-python do_kernel_configcheck() {
-    import re, string, sys, subprocess
-
-    audit_flag = d.getVar( "KMETA_AUDIT" )
-    if not audit_flag:
-       bb.note( "kernel config audit disabled, skipping .." )
-       return
-
-    s = d.getVar('S')
-
-    # if KMETA isn't set globally by a recipe using this routine, use kgit to
-    # locate or create the meta directory. Otherwise, kconf_check is not
-    # passed a valid meta-series for processing
-    kmeta = d.getVar("KMETA")
-    if not kmeta or not os.path.exists('{}/{}'.format(s,kmeta)):
-        kmeta = subprocess.check_output(['kgit', '--meta'], cwd=d.getVar('S')).decode('utf-8').rstrip()
-
-    env = os.environ.copy()
-    env['PATH'] = "%s:%s%s" % (d.getVar('PATH'), s, "/scripts/util/")
-    env['LD'] = d.getVar('KERNEL_LD')
-    env['CC'] = d.getVar('KERNEL_CC')
-    env['OBJCOPY'] = d.getVar('KERNEL_OBJCOPY')
-    env['STRIP'] = d.getVar('KERNEL_STRIP')
-    env['ARCH'] = d.getVar('ARCH')
-    env['srctree'] = s
-
-    try:
-        configs = subprocess.check_output(['scc', '--configs', '-o', s + '/.kernel-meta'], env=env).decode('utf-8')
-    except subprocess.CalledProcessError as e:
-        bb.fatal( "Cannot gather config fragments for audit: %s" % e.output.decode("utf-8") )
-
-    config_check_visibility = int(d.getVar("KCONF_AUDIT_LEVEL") or 0)
-    bsp_check_visibility = int(d.getVar("KCONF_BSP_AUDIT_LEVEL") or 0)
-    kmeta_audit_werror = d.getVar("KMETA_AUDIT_WERROR") or ""
-    warnings_detected = False
-
-    # if config check visibility is "1", that's the lowest level of audit. So
-    # we add the --classify option to the run, since classification will
-    # streamline the output to only report options that could be boot issues,
-    # or are otherwise required for proper operation.
-    extra_params = ""
-    if config_check_visibility == 1:
-       extra_params = "--classify"
-
-    # category #1: mismatches
-    try:
-        analysis = subprocess.check_output(['symbol_why.py', '--dotconfig',  '{}'.format( d.getVar('B') + '/.config' ), '--mismatches', extra_params], cwd=s, env=env ).decode('utf-8')
-    except subprocess.CalledProcessError as e:
-        bb.fatal( "config analysis failed when running '%s': %s" % (" ".join(e.cmd), e.output.decode('utf-8')))
-
-    if analysis:
-        outfile = "{}/{}/cfg/mismatch.txt".format( s, kmeta )
-        if os.path.isfile(outfile):
-           os.remove(outfile)
-        with open(outfile, 'w+') as f:
-            f.write( analysis )
-
-        if config_check_visibility and os.stat(outfile).st_size > 0:
-            with open (outfile, "r") as myfile:
-                results = myfile.read()
-                bb.warn( "[kernel config]: specified values did not make it into the kernel's final configuration:\n\n%s" % results)
-                warnings_detected = True
-
-    # category #2: invalid fragment elements
-    extra_params = ""
-    if bsp_check_visibility > 1:
-        extra_params = "--strict"
-    try:
-        analysis = subprocess.check_output(['symbol_why.py', '--dotconfig',  '{}'.format( d.getVar('B') + '/.config' ), '--invalid', extra_params], cwd=s, env=env ).decode('utf-8')
-    except subprocess.CalledProcessError as e:
-        bb.fatal( "config analysis failed when running '%s': %s" % (" ".join(e.cmd), e.output.decode('utf-8')))
-
-    if analysis:
-        outfile = "{}/{}/cfg/invalid.txt".format(s,kmeta)
-        if os.path.isfile(outfile):
-           os.remove(outfile)
-        with open(outfile, 'w+') as f:
-            f.write( analysis )
-
-        if bsp_check_visibility and os.stat(outfile).st_size > 0:
-            with open (outfile, "r") as myfile:
-                results = myfile.read()
-                bb.warn( "[kernel config]: This BSP contains fragments with warnings:\n\n%s" % results)
-                warnings_detected = True
-
-    # category #3: redefined options (this is pretty verbose and is debug only)
-    try:
-        analysis = subprocess.check_output(['symbol_why.py', '--dotconfig',  '{}'.format( d.getVar('B') + '/.config' ), '--sanity'], cwd=s, env=env ).decode('utf-8')
-    except subprocess.CalledProcessError as e:
-        bb.fatal( "config analysis failed when running '%s': %s" % (" ".join(e.cmd), e.output.decode('utf-8')))
-
-    if analysis:
-        outfile = "{}/{}/cfg/redefinition.txt".format(s,kmeta)
-        if os.path.isfile(outfile):
-           os.remove(outfile)
-        with open(outfile, 'w+') as f:
-            f.write( analysis )
-
-        # if the audit level is greater than two, we report if a fragment has overriden
-        # a value from a base fragment. This is really only used for new kernel introduction
-        if bsp_check_visibility > 2 and os.stat(outfile).st_size > 0:
-            with open (outfile, "r") as myfile:
-                results = myfile.read()
-                bb.warn( "[kernel config]: This BSP has configuration options defined in more than one config, with differing values:\n\n%s" % results)
-                warnings_detected = True
-
-    if warnings_detected and kmeta_audit_werror:
-        bb.fatal( "configuration warnings detected, werror is set, promoting to fatal" )
-}
-
-# Ensure that the branches (BSP and meta) are on the locations specified by
-# their SRCREV values. If they are NOT on the right commits, the branches
-# are corrected to the proper commit.
-do_validate_branches() {
-        set +e
-        cd ${S}
-
-        machine_branch="${@ get_machine_branch(d, "${KBRANCH}" )}"
-        machine_srcrev="${SRCREV_machine}"
-
-        # if SRCREV is AUTOREV it shows up as AUTOINC there's nothing to
-        # check and we can exit early
-        if [ "${machine_srcrev}" = "AUTOINC" ]; then
-            linux_yocto_dev='${@oe.utils.conditional("PREFERRED_PROVIDER_virtual/kernel", "linux-yocto-dev", "1", "", d)}'
-            if [ -n "$linux_yocto_dev" ]; then
-                git checkout -q -f ${machine_branch}
-                ver=$(grep "^VERSION =" ${S}/Makefile | sed s/.*=\ *//)
-                patchlevel=$(grep "^PATCHLEVEL =" ${S}/Makefile | sed s/.*=\ *//)
-                sublevel=$(grep "^SUBLEVEL =" ${S}/Makefile | sed s/.*=\ *//)
-                kver="$ver.$patchlevel"
-                bbnote "dev kernel: performing version -> branch -> SRCREV validation"
-                bbnote "dev kernel: recipe version ${LINUX_VERSION}, src version: $kver"
-                echo "${LINUX_VERSION}" | grep -q $kver
-                if [ $? -ne 0 ]; then
-                    version="$(echo ${LINUX_VERSION} | sed 's/\+.*$//g')"
-                    versioned_branch="v$version/$machine_branch"
-
-                    machine_branch=$versioned_branch
-                    force_srcrev="$(git rev-parse $machine_branch 2> /dev/null)"
-                    if [ $? -ne 0 ]; then
-                        bbfatal "kernel version mismatch detected, and no valid branch $machine_branch detected"
-                    fi
-
-                    bbnote "dev kernel: adjusting branch to $machine_branch, srcrev to: $force_srcrev"
-                fi
-            else
-                bbnote "SRCREV validation is not required for AUTOREV"
-            fi
-        elif [ "${machine_srcrev}" = "" ]; then
-                if [ "${SRCREV}" != "AUTOINC" ] && [ "${SRCREV}" != "INVALID" ]; then
-                       # SRCREV_machine_<MACHINE> was not set. This means that a custom recipe
-                       # that doesn't use the SRCREV_FORMAT "machine_meta" is being built. In
-                       # this case, we need to reset to the give SRCREV before heading to patching
-                       bbnote "custom recipe is being built, forcing SRCREV to ${SRCREV}"
-                       force_srcrev="${SRCREV}"
-                fi
-        else
-                git cat-file -t ${machine_srcrev} > /dev/null
-                if [ $? -ne 0 ]; then
-                        bberror "${machine_srcrev} is not a valid commit ID."
-                        bbfatal_log "The kernel source tree may be out of sync"
-                fi
-                force_srcrev=${machine_srcrev}
-        fi
-
-        git checkout -q -f ${machine_branch}
-        if [ -n "${force_srcrev}" ]; then
-                # see if the branch we are about to patch has been properly reset to the defined
-                # SRCREV .. if not, we reset it.
-                branch_head=`git rev-parse HEAD`
-                if [ "${force_srcrev}" != "${branch_head}" ]; then
-                        current_branch=`git rev-parse --abbrev-ref HEAD`
-                        git branch "$current_branch-orig"
-                        git reset --hard ${force_srcrev}
-                        # We've checked out HEAD, make sure we cleanup kgit-s2q fence post check
-                        # so the patches are applied as expected otherwise no patching
-                        # would be done in some corner cases.
-                        kgit-s2q --clean
-                fi
-        fi
-
-        set -e
-}
-
-OE_TERMINAL_EXPORTS += "KBUILD_OUTPUT"
-KBUILD_OUTPUT = "${B}"
-
-python () {
-    # If diffconfig is available, ensure it runs after kernel_configme
-    if 'do_diffconfig' in d:
-        bb.build.addtask('do_diffconfig', None, 'do_kernel_configme', d)
-
-    externalsrc = d.getVar('EXTERNALSRC')
-    if externalsrc:
-        # If we deltask do_patch, do_kernel_configme is left without
-        # dependencies and runs too early
-        d.setVarFlag('do_kernel_configme', 'deps', (d.getVarFlag('do_kernel_configme', 'deps', False) or []) + ['do_unpack'])
-}
-
-# extra tasks
-addtask kernel_version_sanity_check after do_kernel_metadata do_kernel_checkout before do_compile
-addtask validate_branches before do_patch after do_kernel_checkout
-addtask kernel_configcheck after do_configure before do_compile
diff --git a/meta/classes-recipe/kernel.bbclass b/meta/classes-recipe/kernel.bbclass
deleted file mode 100644
index 003a155e79..0000000000
--- a/meta/classes-recipe/kernel.bbclass
+++ /dev/null
@@ -1,868 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-inherit linux-kernel-base kernel-module-split features_check
-
-COMPATIBLE_HOST = ".*-linux"
-
-# Linux has a minimum ISA requires on riscv, see arch/riscv/Makefile
-REQUIRED_TUNE_FEATURES:riscv32 = "rv 32 i m a zicsr zifencei"
-REQUIRED_TUNE_FEATURES:riscv64 = "rv 64 i m a zicsr zifencei"
-
-KERNEL_PACKAGE_NAME ??= "kernel"
-KERNEL_DEPLOYSUBDIR ??= "${@ "" if (d.getVar("KERNEL_PACKAGE_NAME") == "kernel") else d.getVar("KERNEL_PACKAGE_NAME") }"
-
-PROVIDES += "virtual/kernel"
-DEPENDS += "virtual/cross-binutils virtual/cross-cc kmod-native bc-native bison-native"
-DEPENDS += "${@bb.utils.contains("INITRAMFS_FSTYPES", "cpio.lzo", "lzop-native", "", d)}"
-DEPENDS += "${@bb.utils.contains("INITRAMFS_FSTYPES", "cpio.lz4", "lz4-native", "", d)}"
-DEPENDS += "${@bb.utils.contains("INITRAMFS_FSTYPES", "cpio.zst", "zstd-native", "", d)}"
-DEPENDS += "${@bb.utils.contains("KERNEL_IMAGETYPES", "Image.lz4", "lz4-native", "", d)}"
-PACKAGE_WRITE_DEPS += "depmodwrapper-cross"
-
-do_deploy[depends] += "depmodwrapper-cross:do_populate_sysroot gzip-native:do_populate_sysroot"
-do_clean[depends] += "make-mod-scripts:do_clean"
-
-# CPE entries from NVD use linux_kernel, but the raw CVE entries from the kernel CNA have
-# vendor: linux and product: linux. Note that multiple distributions use "linux" as a product
-# name, so we need to fill vendor to avoid false positives
-CVE_PRODUCT ?= "linux_kernel linux:linux"
-
-S = "${STAGING_KERNEL_DIR}"
-B = "${WORKDIR}/build"
-KBUILD_OUTPUT = "${B}"
-OE_TERMINAL_EXPORTS += "KBUILD_OUTPUT"
-
-# we include gcc above, we dont need virtual/libc
-INHIBIT_DEFAULT_DEPS = "1"
-
-KERNEL_IMAGETYPE ?= "zImage"
-INITRAMFS_IMAGE ?= ""
-INITRAMFS_TASK ?= ""
-INITRAMFS_IMAGE_BUNDLE ?= ""
-INITRAMFS_DEPLOY_DIR_IMAGE ?= "${DEPLOY_DIR_IMAGE}"
-INITRAMFS_MULTICONFIG ?= ""
-
-# KERNEL_VERSION is extracted from source code. It is evaluated as
-# None for the first parsing, since the code has not been fetched.
-# After the code is fetched, it will be evaluated as real version
-# number and cause kernel to be rebuilt. To avoid this, make
-# KERNEL_VERSION_NAME and KERNEL_VERSION_PKG_NAME depend on
-# LINUX_VERSION which is a constant.
-KERNEL_VERSION_NAME = "${@d.getVar('KERNEL_VERSION') or ""}"
-KERNEL_VERSION_NAME[vardepvalue] = "${LINUX_VERSION}"
-KERNEL_VERSION_PKG_NAME = "${@legitimize_package_name(d.getVar('KERNEL_VERSION'))}"
-KERNEL_VERSION_PKG_NAME[vardepvalue] = "${LINUX_VERSION}"
-
-python __anonymous () {
-    pn = d.getVar("PN")
-    kpn = d.getVar("KERNEL_PACKAGE_NAME")
-
-    # XXX Remove this after bug 11905 is resolved
-    #  FILES:${KERNEL_PACKAGE_NAME}-dev doesn't expand correctly
-    if kpn == pn:
-        bb.warn("Some packages (E.g. *-dev) might be missing due to "
-                "bug 11905 (variable KERNEL_PACKAGE_NAME == PN)")
-
-    # The default kernel recipe builds in a shared location defined by
-    # bitbake/distro confs: STAGING_KERNEL_DIR and STAGING_KERNEL_BUILDDIR.
-    # Set these variables to directories under ${WORKDIR} in alternate
-    # kernel recipes (I.e. where KERNEL_PACKAGE_NAME != kernel) so that they
-    # may build in parallel with the default kernel without clobbering.
-    if kpn != "kernel":
-        workdir = d.getVar("WORKDIR")
-        sourceDir = os.path.join(workdir, 'kernel-source')
-        artifactsDir = os.path.join(workdir, 'kernel-build-artifacts')
-        d.setVar("STAGING_KERNEL_DIR", sourceDir)
-        d.setVar("STAGING_KERNEL_BUILDDIR", artifactsDir)
-
-    # Merge KERNEL_IMAGETYPE and KERNEL_ALT_IMAGETYPE into KERNEL_IMAGETYPES
-    type = d.getVar('KERNEL_IMAGETYPE') or ""
-    alttype = d.getVar('KERNEL_ALT_IMAGETYPE') or ""
-    types = d.getVar('KERNEL_IMAGETYPES') or ""
-    if type not in types.split():
-        types = (type + ' ' + types).strip()
-    if alttype not in types.split():
-        types = (alttype + ' ' + types).strip()
-    d.setVar('KERNEL_IMAGETYPES', types)
-
-    # Since kernel-fitimage.bbclass got replaced by kernel-fit-image.bbclass
-    if "fitImage" in types:
-        bb.error("fitImage is no longer supported as a KERNEL_IMAGETYPE(S). FIT images are built by the linux-yocto-fitimage recipe.")
-
-    # KERNEL_IMAGETYPES may contain a mixture of image types supported directly
-    # by the kernel build system and types which are created by post-processing
-    # the output of the kernel build system (e.g. compressing vmlinux ->
-    # vmlinux.gz in kernel_do_transform_kernel()).
-    # KERNEL_IMAGETYPE_FOR_MAKE should contain only image types supported
-    # directly by the kernel build system.
-    if not d.getVar('KERNEL_IMAGETYPE_FOR_MAKE'):
-        typeformake = set()
-        for type in types.split():
-            if type == 'vmlinux.gz':
-                type = 'vmlinux'
-            typeformake.add(type)
-
-        d.setVar('KERNEL_IMAGETYPE_FOR_MAKE', ' '.join(sorted(typeformake)))
-
-    kname = d.getVar('KERNEL_PACKAGE_NAME') or "kernel"
-    imagedest = d.getVar('KERNEL_IMAGEDEST')
-
-    for type in types.split():
-        if bb.data.inherits_class('nopackages', d):
-            continue
-        typelower = type.lower()
-        d.appendVar('PACKAGES', ' %s-image-%s' % (kname, typelower))
-        d.setVar('FILES:' + kname + '-image-' + typelower, '/' + imagedest + '/' + type + '-${KERNEL_VERSION_NAME}' + ' /' + imagedest + '/' + type)
-        d.appendVar('RDEPENDS:%s-image' % kname, ' %s-image-%s (= ${EXTENDPKGV})' % (kname, typelower))
-        splitmods = d.getVar("KERNEL_SPLIT_MODULES")
-        if splitmods != '1':
-            d.appendVar('RDEPENDS:%s-image' % kname, ' %s-modules (= ${EXTENDPKGV})' % kname)
-            d.appendVar('RDEPENDS:%s-image-%s' % (kname, typelower), ' %s-modules-${KERNEL_VERSION_PKG_NAME} (= ${EXTENDPKGV})' % kname)
-            d.setVar('PKG:%s-modules' % kname, '%s-modules-${KERNEL_VERSION_PKG_NAME}' % kname)
-            d.appendVar('RPROVIDES:%s-modules' % kname, ' %s-modules-${KERNEL_VERSION_PKG_NAME}' % kname)
-
-        d.setVar('PKG:%s-image-%s' % (kname,typelower), '%s-image-%s-${KERNEL_VERSION_PKG_NAME}' % (kname, typelower))
-        d.setVar('ALLOW_EMPTY:%s-image-%s' % (kname, typelower), '1')
-
-        if d.getVar('KERNEL_IMAGETYPE_SYMLINK') == '1':
-            d.prependVar('pkg_postinst:%s-image-%s' % (kname,typelower), """set +e
-if [ -n "$D" ]; then
-    ln -sf %s-${KERNEL_VERSION} $D/${KERNEL_IMAGEDEST}/%s > /dev/null 2>&1
-else
-    ln -sf %s-${KERNEL_VERSION} ${KERNEL_IMAGEDEST}/%s > /dev/null 2>&1
-    if [ $? -ne 0 ]; then
-        echo "Filesystem on ${KERNEL_IMAGEDEST}/ doesn't support symlinks, falling back to copied image (%s)."
-        install -m 0644 ${KERNEL_IMAGEDEST}/%s-${KERNEL_VERSION} ${KERNEL_IMAGEDEST}/%s
-    fi
-fi
-set -e
-""" % (type, type, type, type, type, type, type))
-            d.setVar('pkg_postrm:%s-image-%s' % (kname,typelower), """set +e
-if [ -f "${KERNEL_IMAGEDEST}/%s" -o -L "${KERNEL_IMAGEDEST}/%s" ]; then
-    rm -f ${KERNEL_IMAGEDEST}/%s  > /dev/null 2>&1
-fi
-set -e
-""" % (type, type, type))
-
-
-    image = d.getVar('INITRAMFS_IMAGE')
-    # If the INTIRAMFS_IMAGE is set but the INITRAMFS_IMAGE_BUNDLE is set to 0,
-    # the do_bundle_initramfs does nothing, but the INITRAMFS_IMAGE is built
-    # standalone for use by wic and other tools.
-    if image:
-        if d.getVar('INITRAMFS_MULTICONFIG'):
-            d.appendVarFlag('do_bundle_initramfs', 'mcdepends', ' mc:${BB_CURRENT_MC}:${INITRAMFS_MULTICONFIG}:${INITRAMFS_IMAGE}:do_image_complete')
-        else:
-            d.appendVarFlag('do_bundle_initramfs', 'depends', ' ${INITRAMFS_IMAGE}:do_image_complete')
-    if image and bb.utils.to_boolean(d.getVar('INITRAMFS_IMAGE_BUNDLE')):
-        bb.build.addtask('do_transform_bundled_initramfs', 'do_deploy', 'do_bundle_initramfs', d)
-
-    # NOTE: setting INITRAMFS_TASK is for backward compatibility
-    #       The preferred method is to set INITRAMFS_IMAGE, because
-    #       this INITRAMFS_TASK has circular dependency problems
-    #       if the initramfs requires kernel modules
-    image_task = d.getVar('INITRAMFS_TASK')
-    if image_task:
-        d.appendVarFlag('do_configure', 'depends', ' ${INITRAMFS_TASK}')
-}
-
-# Here we pull in all various kernel image types which we support.
-#
-# In case you're wondering why kernel.bbclass inherits the other image
-# types instead of the other way around, the reason for that is to
-# maintain compatibility with various currently existing meta-layers.
-# By pulling in the various kernel image types here, we retain the
-# original behavior of kernel.bbclass, so no meta-layers should get
-# broken.
-#
-# KERNEL_CLASSES by default pulls in kernel-uimage.bbclass, since this
-# used to be the default behavior when only uImage was supported. This
-# variable can be appended by users who implement support for new kernel
-# image types.
-
-KERNEL_CLASSES ?= " kernel-uimage "
-inherit_defer ${KERNEL_CLASSES}
-
-# Old style kernels may set ${S} = ${WORKDIR}/git for example
-# We need to move these over to STAGING_KERNEL_DIR. We can't just
-# create the symlink in advance as the git fetcher can't cope with
-# the symlink.
-do_unpack[cleandirs] += " ${S} ${STAGING_KERNEL_DIR} ${B} ${STAGING_KERNEL_BUILDDIR}"
-do_clean[cleandirs] += " ${S} ${STAGING_KERNEL_DIR} ${B} ${STAGING_KERNEL_BUILDDIR}"
-python do_symlink_kernsrc () {
-    s = d.getVar("S")
-    kernsrc = d.getVar("STAGING_KERNEL_DIR")
-    if s != kernsrc:
-        bb.utils.mkdirhier(kernsrc)
-        bb.utils.remove(kernsrc, recurse=True)
-        if s[-1] == '/':
-            # drop trailing slash, so that os.symlink(kernsrc, s) doesn't use s as
-            # directory name and fail
-            s = s[:-1]
-        if d.getVar("EXTERNALSRC"):
-            # With EXTERNALSRC S will not be wiped so we can symlink to it
-            os.symlink(s, kernsrc)
-        else:
-            import shutil
-            shutil.move(s, kernsrc)
-            os.symlink(kernsrc, s)
-}
-# do_patch is normally ordered before do_configure, but
-# externalsrc.bbclass deletes do_patch, breaking the dependency of
-# do_configure on do_symlink_kernsrc.
-addtask symlink_kernsrc before do_patch do_configure after do_unpack
-
-inherit kernel-arch deploy
-
-PACKAGES_DYNAMIC += "^${KERNEL_PACKAGE_NAME}-module-.*"
-PACKAGES_DYNAMIC += "^${KERNEL_PACKAGE_NAME}-image-.*"
-PACKAGES_DYNAMIC += "^${KERNEL_PACKAGE_NAME}-firmware-.*"
-
-export OS = "${TARGET_OS}"
-export CROSS_COMPILE = "${TARGET_PREFIX}"
-
-KERNEL_RELEASE ?= "${KERNEL_VERSION}"
-
-# The directory where built kernel lies in the kernel tree
-KERNEL_OUTPUT_DIR ?= "arch/${ARCH}/boot"
-KERNEL_IMAGEDEST ?= "boot"
-KERNEL_DTBDEST ?= "${KERNEL_IMAGEDEST}"
-KERNEL_DTBVENDORED ?= "0"
-
-#
-# configuration
-#
-KERNEL_VERSION = "${@get_kernelversion_headers('${B}')}"
-
-# kernels are generally machine specific
-PACKAGE_ARCH = "${MACHINE_ARCH}"
-
-# U-Boot support
-UBOOT_ENTRYPOINT ?= "0x20008000"
-UBOOT_LOADADDRESS ?= "${UBOOT_ENTRYPOINT}"
-
-# Some Linux kernel configurations need additional parameters on the command line
-KERNEL_EXTRA_ARGS ?= ""
-
-EXTRA_OEMAKE += ' CC="${KERNEL_CC}" LD="${KERNEL_LD}" OBJCOPY="${KERNEL_OBJCOPY}" STRIP="${KERNEL_STRIP}"'
-EXTRA_OEMAKE += ' HOSTCC="${BUILD_CC}" HOSTCFLAGS="${BUILD_CFLAGS}" HOSTLDFLAGS="${BUILD_LDFLAGS}" HOSTCPP="${BUILD_CPP}"'
-EXTRA_OEMAKE += ' HOSTCXX="${BUILD_CXX}" HOSTCXXFLAGS="${BUILD_CXXFLAGS}"'
-# Only for newer kernels (5.19+), native pkg-config variables are set for older kernels when building kernel and modules
-EXTRA_OEMAKE += ' HOSTPKG_CONFIG="pkg-config-native"'
-
-KERNEL_ALT_IMAGETYPE ??= ""
-
-copy_initramfs() {
-        echo "Copying initramfs into ./usr ..."
-        # In case the directory is not created yet from the first pass compile:
-        mkdir -p ${B}/usr
-        # Find and use the first initramfs image archive type we find
-        rm -f ${B}/usr/${INITRAMFS_IMAGE_NAME}.cpio
-        for img in cpio cpio.gz cpio.lz4 cpio.lzo cpio.lzma cpio.xz cpio.zst; do
-                if [ -e "${INITRAMFS_DEPLOY_DIR_IMAGE}/${INITRAMFS_IMAGE_NAME}.$img" ]; then
-                        cp ${INITRAMFS_DEPLOY_DIR_IMAGE}/${INITRAMFS_IMAGE_NAME}.$img ${B}/usr/.
-                        case $img in
-                        *gz)
-                                echo "gzip decompressing image"
-                                gunzip -f ${B}/usr/${INITRAMFS_IMAGE_NAME}.$img
-                                break
-                                ;;
-                        *lz4)
-                                echo "lz4 decompressing image"
-                                lz4 -df ${B}/usr/${INITRAMFS_IMAGE_NAME}.$img ${B}/usr/${INITRAMFS_IMAGE_NAME}.cpio
-                                break
-                                ;;
-                        *lzo)
-                                echo "lzo decompressing image"
-                                lzop -df ${B}/usr/${INITRAMFS_IMAGE_NAME}.$img
-                                break
-                                ;;
-                        *lzma)
-                                echo "lzma decompressing image"
-                                lzma -df ${B}/usr/${INITRAMFS_IMAGE_NAME}.$img
-                                break
-                                ;;
-                        *xz)
-                                echo "xz decompressing image"
-                                xz -df ${B}/usr/${INITRAMFS_IMAGE_NAME}.$img
-                                break
-                                ;;
-                        *zst)
-                                echo "zst decompressing image"
-                                zstd -df ${B}/usr/${INITRAMFS_IMAGE_NAME}.$img
-                                break
-                                ;;
-                        esac
-                        break
-                fi
-        done
-        # Verify that the above loop found a initramfs, fail otherwise
-        [ -f ${B}/usr/${INITRAMFS_IMAGE_NAME}.cpio ] && echo "Finished copy of initramfs into ./usr" || die "Could not find any ${INITRAMFS_DEPLOY_DIR_IMAGE}/${INITRAMFS_IMAGE_NAME}.cpio{.gz|.lz4|.lzo|.lzma|.xz|.zst) for bundling; INITRAMFS_IMAGE_NAME might be wrong."
-}
-
-do_bundle_initramfs () {
-        if [ ! -z "${INITRAMFS_IMAGE}" -a x"${INITRAMFS_IMAGE_BUNDLE}" = x1 ]; then
-                echo "Creating a kernel image with a bundled initramfs..."
-                copy_initramfs
-                # Backing up kernel image relies on its type(regular file or symbolic link)
-                tmp_path=""
-                for imageType in ${KERNEL_IMAGETYPE_FOR_MAKE} ; do
-                        if [ -h ${KERNEL_OUTPUT_DIR}/$imageType ] ; then
-                                linkpath=`readlink -n ${KERNEL_OUTPUT_DIR}/$imageType`
-                                realpath=`readlink -fn ${KERNEL_OUTPUT_DIR}/$imageType`
-                                mv -f $realpath $realpath.bak
-                                tmp_path=$tmp_path" "$imageType"#"$linkpath"#"$realpath
-                        elif [ -f ${KERNEL_OUTPUT_DIR}/$imageType ]; then
-                                mv -f ${KERNEL_OUTPUT_DIR}/$imageType ${KERNEL_OUTPUT_DIR}/$imageType.bak
-                                tmp_path=$tmp_path" "$imageType"##"
-                        fi
-                done
-                use_alternate_initrd=CONFIG_INITRAMFS_SOURCE=${B}/usr/${INITRAMFS_IMAGE_NAME}.cpio
-                kernel_do_compile
-                # Restoring kernel image
-                for tp in $tmp_path ; do
-                        imageType=`echo $tp|cut -d "#" -f 1`
-                        linkpath=`echo $tp|cut -d "#" -f 2`
-                        realpath=`echo $tp|cut -d "#" -f 3`
-                        if [ -n "$realpath" ]; then
-                                mv -f $realpath $realpath.initramfs
-                                mv -f $realpath.bak $realpath
-                                ln -sf $linkpath.initramfs ${B}/${KERNEL_OUTPUT_DIR}/$imageType.initramfs
-                        else
-                                mv -f ${KERNEL_OUTPUT_DIR}/$imageType ${KERNEL_OUTPUT_DIR}/$imageType.initramfs
-                                mv -f ${KERNEL_OUTPUT_DIR}/$imageType.bak ${KERNEL_OUTPUT_DIR}/$imageType
-                        fi
-                done
-        fi
-}
-do_bundle_initramfs[dirs] = "${B}"
-
-kernel_do_transform_bundled_initramfs() {
-        # vmlinux.gz is not built by kernel
-        if (echo "${KERNEL_IMAGETYPES}" | grep -wq "vmlinux\.gz"); then
-                gzip -9cn < ${KERNEL_OUTPUT_DIR}/vmlinux.initramfs > ${KERNEL_OUTPUT_DIR}/vmlinux.gz.initramfs
-        fi
-}
-do_transform_bundled_initramfs[dirs] = "${B}"
-
-python do_package:prepend () {
-    d.setVar('STRIP',  d.getVar('KERNEL_STRIP').strip())
-}
-
-python do_devshell:prepend () {
-    os.environ["LDFLAGS"] = ''
-}
-
-addtask bundle_initramfs after do_install before do_deploy
-
-KERNEL_DEBUG_TIMESTAMPS ??= "0"
-
-kernel_do_compile() {
-        unset CFLAGS CPPFLAGS CXXFLAGS LDFLAGS MACHINE
-
-        # setup native pkg-config variables (kconfig scripts call pkg-config directly, cannot generically be overriden to pkg-config-native)
-        export PKG_CONFIG_DIR="${STAGING_DIR_NATIVE}${libdir_native}/pkgconfig"
-        export PKG_CONFIG_PATH="$PKG_CONFIG_DIR:${STAGING_DATADIR_NATIVE}/pkgconfig"
-        export PKG_CONFIG_LIBDIR="$PKG_CONFIG_DIR"
-        export PKG_CONFIG_SYSROOT_DIR=""
-
-        if [ "${KERNEL_DEBUG_TIMESTAMPS}" != "1" ]; then
-                # kernel sources do not use do_unpack, so SOURCE_DATE_EPOCH may not
-                # be set....
-                if [ "${SOURCE_DATE_EPOCH}" = "" -o "${SOURCE_DATE_EPOCH}" = "0" ]; then
-                        # The source directory is not necessarily a git repository, so we
-                        # specify the git-dir to ensure that git does not query a
-                        # repository in any parent directory.
-                        SOURCE_DATE_EPOCH=`git --git-dir="${S}/.git" log -1 --pretty=%ct 2>/dev/null || echo "${REPRODUCIBLE_TIMESTAMP_ROOTFS}"`
-                fi
-
-                ts=`LC_ALL=C date -d @$SOURCE_DATE_EPOCH`
-                export KBUILD_BUILD_TIMESTAMP="$ts"
-                export KCONFIG_NOTIMESTAMP=1
-                bbnote "KBUILD_BUILD_TIMESTAMP: $ts"
-        else
-                ts=`LC_ALL=C date`
-                export KBUILD_BUILD_TIMESTAMP="$ts"
-                bbnote "KBUILD_BUILD_TIMESTAMP: $ts"
-        fi
-        # The $use_alternate_initrd is only set from
-        # do_bundle_initramfs() This variable is specifically for the
-        # case where we are making a second pass at the kernel
-        # compilation and we want to force the kernel build to use a
-        # different initramfs image.  The way to do that in the kernel
-        # is to specify:
-        # make ...args... CONFIG_INITRAMFS_SOURCE=some_other_initramfs.cpio
-        if [ "$use_alternate_initrd" = "" ] && [ "${INITRAMFS_TASK}" != "" ] ; then
-                # The old style way of copying an prebuilt image and building it
-                # is turned on via INTIRAMFS_TASK != ""
-                copy_initramfs
-                use_alternate_initrd=CONFIG_INITRAMFS_SOURCE=${B}/usr/${INITRAMFS_IMAGE_NAME}.cpio
-        fi
-        for typeformake in ${KERNEL_IMAGETYPE_FOR_MAKE} ; do
-                oe_runmake ${PARALLEL_MAKE} ${typeformake} ${KERNEL_EXTRA_ARGS} $use_alternate_initrd
-        done
-}
-
-kernel_do_transform_kernel() {
-        # vmlinux.gz is not built by kernel
-        if (echo "${KERNEL_IMAGETYPES}" | grep -wq "vmlinux\.gz"); then
-                mkdir -p "${KERNEL_OUTPUT_DIR}"
-                gzip -9cn < ${B}/vmlinux > "${KERNEL_OUTPUT_DIR}/vmlinux.gz"
-        fi
-}
-do_transform_kernel[dirs] = "${B}"
-addtask transform_kernel after do_compile before do_install
-
-do_compile_kernelmodules() {
-        unset CFLAGS CPPFLAGS CXXFLAGS LDFLAGS MACHINE
-
-        # setup native pkg-config variables (kconfig scripts call pkg-config directly, cannot generically be overriden to pkg-config-native)
-        export PKG_CONFIG_DIR="${STAGING_DIR_NATIVE}${libdir_native}/pkgconfig"
-        export PKG_CONFIG_PATH="$PKG_CONFIG_DIR:${STAGING_DATADIR_NATIVE}/pkgconfig"
-        export PKG_CONFIG_LIBDIR="$PKG_CONFIG_DIR"
-        export PKG_CONFIG_SYSROOT_DIR=""
-
-        if [ "${KERNEL_DEBUG_TIMESTAMPS}" != "1" ]; then
-                # kernel sources do not use do_unpack, so SOURCE_DATE_EPOCH may not
-                # be set....
-                if [ "${SOURCE_DATE_EPOCH}" = "" -o "${SOURCE_DATE_EPOCH}" = "0" ]; then
-                        # The source directory is not necessarily a git repository, so we
-                        # specify the git-dir to ensure that git does not query a
-                        # repository in any parent directory.
-                        SOURCE_DATE_EPOCH=`git --git-dir="${S}/.git" log -1 --pretty=%ct 2>/dev/null || echo "${REPRODUCIBLE_TIMESTAMP_ROOTFS}"`
-                fi
-
-                ts=`LC_ALL=C date -d @$SOURCE_DATE_EPOCH`
-                export KBUILD_BUILD_TIMESTAMP="$ts"
-                export KCONFIG_NOTIMESTAMP=1
-                bbnote "KBUILD_BUILD_TIMESTAMP: $ts"
-        else
-                ts=`LC_ALL=C date`
-                export KBUILD_BUILD_TIMESTAMP="$ts"
-                bbnote "KBUILD_BUILD_TIMESTAMP: $ts"
-        fi
-        if (grep -q -i -e '^CONFIG_MODULES=y$' ${B}/.config); then
-                oe_runmake -C ${B} ${PARALLEL_MAKE} modules ${KERNEL_EXTRA_ARGS}
-
-                # Module.symvers gets updated during the
-                # building of the kernel modules. We need to
-                # update this in the shared workdir since some
-                # external kernel modules has a dependency on
-                # other kernel modules and will look at this
-                # file to do symbol lookups
-                cp ${B}/Module.symvers ${STAGING_KERNEL_BUILDDIR}/
-                # 5.10+ kernels have module.lds that we need to copy for external module builds
-                if [ -e "${B}/scripts/module.lds" ]; then
-                        install -Dm 0644 ${B}/scripts/module.lds ${STAGING_KERNEL_BUILDDIR}/scripts/module.lds
-                fi
-        else
-                bbnote "no modules to compile"
-        fi
-}
-addtask compile_kernelmodules after do_compile before do_strip
-
-kernel_do_install() {
-        #
-        # First install the modules
-        #
-        unset CFLAGS CPPFLAGS CXXFLAGS LDFLAGS MACHINE
-        if (grep -q -i -e '^CONFIG_MODULES=y$' .config); then
-                oe_runmake DEPMOD=echo MODLIB=${D}${nonarch_base_libdir}/modules/${KERNEL_VERSION} INSTALL_FW_PATH=${D}${nonarch_base_libdir}/firmware modules_install
-                rm -f "${D}${nonarch_base_libdir}/modules/${KERNEL_VERSION}/build"
-                rm -f "${D}${nonarch_base_libdir}/modules/${KERNEL_VERSION}/source"
-                # Remove empty module directories to prevent QA issues
-                [ -d "${D}${nonarch_base_libdir}/modules/${KERNEL_VERSION}/kernel" ] && find "${D}${nonarch_base_libdir}/modules/${KERNEL_VERSION}/kernel" -type d -empty -delete
-        else
-                bbnote "no modules to install"
-        fi
-
-        #
-        # Install various kernel output (zImage, map file, config, module support files)
-        #
-        install -d ${D}/${KERNEL_IMAGEDEST}
-
-        #
-        # bundle_initramfs runs after do_install before do_deploy. do_deploy does what's needed therefore.
-        #
-        for imageType in ${KERNEL_IMAGETYPES} ; do
-                if [ "${INITRAMFS_IMAGE_BUNDLE}" != "1" ] ; then
-                        install -m 0644 ${KERNEL_OUTPUT_DIR}/$imageType ${D}/${KERNEL_IMAGEDEST}/$imageType-${KERNEL_VERSION}
-                fi
-        done
-
-        install -m 0644 System.map ${D}/${KERNEL_IMAGEDEST}/System.map-${KERNEL_VERSION}
-        install -m 0644 .config ${D}/${KERNEL_IMAGEDEST}/config-${KERNEL_VERSION}
-        install -m 0644 vmlinux ${D}/${KERNEL_IMAGEDEST}/vmlinux-${KERNEL_VERSION}
-        ! [ -e Module.symvers ] || install -m 0644 Module.symvers ${D}/${KERNEL_IMAGEDEST}/Module.symvers-${KERNEL_VERSION}
-}
-
-# Must be ran no earlier than after do_kernel_checkout or else Makefile won't be in ${S}/Makefile
-do_kernel_version_sanity_check() {
-        if [ "x${KERNEL_VERSION_SANITY_SKIP}" = "x1" ]; then
-                exit 0
-        fi
-
-        # The Makefile determines the kernel version shown at runtime
-        # Don't use KERNEL_VERSION because the headers it grabs the version from aren't generated until do_compile
-        VERSION=$(grep "^VERSION =" ${S}/Makefile | sed s/.*=\ *//)
-        PATCHLEVEL=$(grep "^PATCHLEVEL =" ${S}/Makefile | sed s/.*=\ *//)
-        SUBLEVEL=$(grep "^SUBLEVEL =" ${S}/Makefile | sed s/.*=\ *//)
-        EXTRAVERSION=$(grep "^EXTRAVERSION =" ${S}/Makefile | sed s/.*=\ *//)
-
-        # Build a string for regex and a plain version string
-        reg="^${VERSION}\.${PATCHLEVEL}"
-        vers="${VERSION}.${PATCHLEVEL}"
-        if [ -n "${SUBLEVEL}" ]; then
-                # Ignoring a SUBLEVEL of zero is fine
-                if [ "${SUBLEVEL}" = "0" ]; then
-                        reg="${reg}(\.${SUBLEVEL})?"
-                else
-                        reg="${reg}\.${SUBLEVEL}"
-                        vers="${vers}.${SUBLEVEL}"
-                fi
-        fi
-        vers="${vers}${EXTRAVERSION}"
-        reg="${reg}${EXTRAVERSION}"
-
-        if [ -z `echo ${PV} | grep -E "${reg}"` ]; then
-                bbfatal "Package Version (${PV}) does not match of kernel being built (${vers}). Please update the PV variable to match the kernel source or set KERNEL_VERSION_SANITY_SKIP=\"1\" in your recipe."
-        fi
-        exit 0
-}
-
-addtask shared_workdir after do_compile before do_compile_kernelmodules
-addtask shared_workdir_setscene
-
-do_shared_workdir_setscene () {
-        exit 1
-}
-
-emit_depmod_pkgdata() {
-        # Stash data for depmod
-        install -d ${PKGDESTWORK}/${KERNEL_PACKAGE_NAME}-depmod/
-        echo "${KERNEL_VERSION}" > ${PKGDESTWORK}/${KERNEL_PACKAGE_NAME}-depmod/${KERNEL_PACKAGE_NAME}-abiversion
-        cp ${B}/System.map ${PKGDESTWORK}/${KERNEL_PACKAGE_NAME}-depmod/System.map-${KERNEL_VERSION}
-}
-
-PACKAGEFUNCS += "emit_depmod_pkgdata"
-
-do_shared_workdir[cleandirs] += " ${STAGING_KERNEL_BUILDDIR}"
-do_shared_workdir () {
-        cd ${B}
-
-        kerneldir=${STAGING_KERNEL_BUILDDIR}
-        install -d $kerneldir
-
-        #
-        # Store the kernel version in sysroots for module-base.bbclass
-        #
-
-        echo "${KERNEL_VERSION}" > $kerneldir/${KERNEL_PACKAGE_NAME}-abiversion
-        echo "${KERNEL_LOCALVERSION}" > $kerneldir/${KERNEL_PACKAGE_NAME}-localversion
-
-        # Copy files required for module builds
-        cp System.map $kerneldir/System.map-${KERNEL_VERSION}
-        ! [ -e Module.symvers ] || cp Module.symvers $kerneldir/
-        cp .config $kerneldir/
-        mkdir -p $kerneldir/include/config
-        cp include/config/kernel.release $kerneldir/include/config/kernel.release
-        if [ -e certs/signing_key.x509 ]; then
-                # The signing_key.* files are stored in the certs/ dir in
-                # newer Linux kernels
-                mkdir -p $kerneldir/certs
-                cp certs/signing_key.* $kerneldir/certs/
-        elif [ -e signing_key.priv ]; then
-                cp signing_key.* $kerneldir/
-        fi
-
-        # We can also copy over all the generated files and avoid special cases
-        # like version.h, but we've opted to keep this small until file creep starts
-        # to happen
-        if [ -e include/linux/version.h ]; then
-                mkdir -p $kerneldir/include/linux
-                cp include/linux/version.h $kerneldir/include/linux/version.h
-        fi
-
-        # As of Linux kernel version 3.0.1, the clean target removes
-        # arch/powerpc/lib/crtsavres.o which is present in
-        # KBUILD_LDFLAGS_MODULE, making it required to build external modules.
-        if [ ${ARCH} = "powerpc" ]; then
-                if [ -e arch/powerpc/lib/crtsavres.o ]; then
-                        mkdir -p $kerneldir/arch/powerpc/lib/
-                        cp arch/powerpc/lib/crtsavres.o $kerneldir/arch/powerpc/lib/crtsavres.o
-                fi
-        fi
-
-        if [ -d include/generated ]; then
-                mkdir -p $kerneldir/include/generated/
-                cp -fR include/generated/* $kerneldir/include/generated/
-        fi
-
-        if [ -d arch/${ARCH}/include/generated ]; then
-                mkdir -p $kerneldir/arch/${ARCH}/include/generated/
-                cp -fR arch/${ARCH}/include/generated/* $kerneldir/arch/${ARCH}/include/generated/
-        fi
-
-        if (grep -q -i -e '^CONFIG_UNWINDER_ORC=y$' $kerneldir/.config); then
-                # With CONFIG_UNWINDER_ORC (the default in 4.14), objtool is required for
-                # out-of-tree modules to be able to generate object files.
-                if [ -x tools/objtool/objtool ]; then
-                        mkdir -p ${kerneldir}/tools/objtool
-                        cp tools/objtool/objtool ${kerneldir}/tools/objtool/
-                fi
-        fi
-
-        # When building with CONFIG_MODVERSIONS=y and CONFIG_RANDSTRUCT=y we need
-        # to copy the build assets generated for the randstruct seed to
-        # STAGING_KERNEL_BUILDDIR, otherwise the out-of-tree modules build will
-        # generate those assets which will result in a different
-        # RANDSTRUCT_HASHED_SEED
-        if [ -d scripts/basic ]; then
-                mkdir -p ${kerneldir}/scripts
-                cp -r scripts/basic ${kerneldir}/scripts
-        fi
-
-        if [ -d scripts/gcc-plugins ]; then
-                mkdir -p ${kerneldir}/scripts
-                cp -r scripts/gcc-plugins ${kerneldir}/scripts
-        fi
-
-}
-
-# We don't need to stage anything, not the modules/firmware since those would clash with linux-firmware
-SYSROOT_DIRS = ""
-
-KERNEL_CONFIG_COMMAND ?= "oe_runmake_call -C ${S} O=${B} olddefconfig || oe_runmake -C ${S} O=${B} oldnoconfig"
-
-python check_oldest_kernel() {
-    oldest_kernel = d.getVar('OLDEST_KERNEL')
-    kernel_version = d.getVar('KERNEL_VERSION')
-    tclibc = d.getVar('TCLIBC')
-    if tclibc == 'glibc':
-        kernel_version = kernel_version.split('-', 1)[0]
-        if oldest_kernel and kernel_version:
-            if bb.utils.vercmp_string(kernel_version, oldest_kernel) < 0:
-                bb.warn('%s: OLDEST_KERNEL is "%s" but the version of the kernel you are building is "%s" - therefore %s as built may not be compatible with this kernel. Either set OLDEST_KERNEL to an older version, or build a newer kernel.' % (d.getVar('PN'), oldest_kernel, kernel_version, tclibc))
-}
-
-check_oldest_kernel[vardepsexclude] += "OLDEST_KERNEL KERNEL_VERSION"
-do_compile[postfuncs] += "check_oldest_kernel"
-
-KERNEL_LOCALVERSION ??= ""
-
-# 6.3+ requires the variable LOCALVERSION to be set to not get a "+" in
-# the local version. Having it empty means nothing will be added, and any
-# value will be appended to the local kernel version. This replaces the
-# use of .scmversion file for setting a localversion without using
-# the CONFIG_LOCALVERSION option.
-#
-# Note: This class saves the value of localversion to a file
-# so other recipes like make-mod-scripts can restore it via the
-# helper function get_kernellocalversion_file
-export LOCALVERSION = "${KERNEL_LOCALVERSION}"
-
-kernel_do_configure() {
-        # fixes extra + in /lib/modules/2.6.37+
-        # $ scripts/setlocalversion . => +
-        # $ make kernelversion => 2.6.37
-        # $ make kernelrelease => 2.6.37+
-        # See kernel-arch.bbclass for post v6.3 removal of the extra
-        # + in localversion. .scmversion is no longer used, and the
-        # variable LOCALVERSION must be used
-        if [ ! -e ${B}/.scmversion -a ! -e ${S}/.scmversion ]; then
-                echo ${KERNEL_LOCALVERSION} > ${B}/.scmversion
-                echo ${KERNEL_LOCALVERSION} > ${S}/.scmversion
-        fi
-
-        if [ "${S}" != "${B}" ] && [ -f "${S}/.config" ] && [ ! -f "${B}/.config" ]; then
-                mv "${S}/.config" "${B}/.config"
-        fi
-
-        # Copy defconfig to .config if .config does not exist. This allows
-        # recipes to manage the .config themselves in do_configure:prepend().
-        if [ -f "${UNPACKDIR}/defconfig" ] && [ ! -f "${B}/.config" ]; then
-                cp "${UNPACKDIR}/defconfig" "${B}/.config"
-        fi
-
-        ${KERNEL_CONFIG_COMMAND}
-}
-
-inherit cml1 pkgconfig
-
-EXPORT_FUNCTIONS do_compile do_transform_kernel do_transform_bundled_initramfs do_install do_configure
-
-# kernel-base becomes kernel-${KERNEL_VERSION}
-# kernel-image becomes kernel-image-${KERNEL_VERSION}
-PACKAGES = "${KERNEL_PACKAGE_NAME} ${KERNEL_PACKAGE_NAME}-base ${KERNEL_PACKAGE_NAME}-vmlinux ${KERNEL_PACKAGE_NAME}-image ${KERNEL_PACKAGE_NAME}-dev ${KERNEL_PACKAGE_NAME}-modules ${KERNEL_PACKAGE_NAME}-dbg"
-FILES:${PN} = ""
-FILES:${KERNEL_PACKAGE_NAME}-base = "${nonarch_base_libdir}/modules/${KERNEL_VERSION}/modules.order ${nonarch_base_libdir}/modules/${KERNEL_VERSION}/modules.builtin ${nonarch_base_libdir}/modules/${KERNEL_VERSION}/modules.builtin.modinfo"
-FILES:${KERNEL_PACKAGE_NAME}-image = ""
-FILES:${KERNEL_PACKAGE_NAME}-dev = "/${KERNEL_IMAGEDEST}/System.map* /${KERNEL_IMAGEDEST}/Module.symvers* /${KERNEL_IMAGEDEST}/config* ${KERNEL_SRC_PATH} ${nonarch_base_libdir}/modules/${KERNEL_VERSION}/build"
-FILES:${KERNEL_PACKAGE_NAME}-vmlinux = "/${KERNEL_IMAGEDEST}/vmlinux-${KERNEL_VERSION_NAME}"
-FILES:${KERNEL_PACKAGE_NAME}-modules = ""
-FILES:${KERNEL_PACKAGE_NAME}-dbg = "/usr/lib/debug /usr/src/debug"
-RDEPENDS:${KERNEL_PACKAGE_NAME} = "${KERNEL_PACKAGE_NAME}-base (= ${EXTENDPKGV})"
-# Allow machines to override this dependency if kernel image files are
-# not wanted in images as standard
-RRECOMMENDS:${KERNEL_PACKAGE_NAME}-base ?= "${KERNEL_PACKAGE_NAME}-image (= ${EXTENDPKGV})"
-PKG:${KERNEL_PACKAGE_NAME}-image = "${KERNEL_PACKAGE_NAME}-image-${@legitimize_package_name(d.getVar('KERNEL_VERSION'))}"
-RPROVIDES:${KERNEL_PACKAGE_NAME}-image += "${KERNEL_PACKAGE_NAME}-image"
-RDEPENDS:${KERNEL_PACKAGE_NAME}-image += "${@oe.utils.conditional('KERNEL_IMAGETYPE', 'vmlinux', '${KERNEL_PACKAGE_NAME}-vmlinux (= ${EXTENDPKGV})', '', d)}"
-PKG:${KERNEL_PACKAGE_NAME}-base = "${KERNEL_PACKAGE_NAME}-${@legitimize_package_name(d.getVar('KERNEL_VERSION'))}"
-RPROVIDES:${KERNEL_PACKAGE_NAME}-base += "${KERNEL_PACKAGE_NAME}-${KERNEL_VERSION} ${KERNEL_PACKAGE_NAME}-base"
-ALLOW_EMPTY:${KERNEL_PACKAGE_NAME} = "1"
-ALLOW_EMPTY:${KERNEL_PACKAGE_NAME}-base = "1"
-ALLOW_EMPTY:${KERNEL_PACKAGE_NAME}-image = "1"
-ALLOW_EMPTY:${KERNEL_PACKAGE_NAME}-modules = "1"
-DESCRIPTION:${KERNEL_PACKAGE_NAME}-modules = "Kernel modules meta package"
-
-pkg_postinst:${KERNEL_PACKAGE_NAME}-base () {
-        if [ ! -e "$D/lib/modules/${KERNEL_VERSION}" ]; then
-                mkdir -p $D/lib/modules/${KERNEL_VERSION}
-        fi
-        if [ -n "$D" ]; then
-                depmodwrapper -a -b $D ${KERNEL_VERSION} ${KERNEL_PACKAGE_NAME}
-        else
-                depmod -a ${KERNEL_VERSION}
-        fi
-}
-
-PACKAGESPLITFUNCS =+ "split_kernel_packages"
-
-python split_kernel_packages () {
-    do_split_packages(d, root='${nonarch_base_libdir}/firmware', file_regex=r'^(.*)\.(bin|fw|cis|csp|dsp)$', output_pattern='${KERNEL_PACKAGE_NAME}-firmware-%s', description='Firmware for %s', recursive=True, extra_depends='')
-}
-
-# Many scripts want to look in arch/$arch/boot for the bootable
-# image. This poses a problem for vmlinux and vmlinuz based
-# booting. This task arranges to have vmlinux and vmlinuz appear
-# in the normalized directory location.
-do_kernel_link_images() {
-        if [ ! -d "${B}/arch/${ARCH}/boot" ]; then
-                mkdir ${B}/arch/${ARCH}/boot
-        fi
-        cd ${B}/arch/${ARCH}/boot
-        ln -sf ../../../vmlinux
-        if [ -f ../../../vmlinuz ]; then
-                ln -sf ../../../vmlinuz
-        fi
-        if [ -f ../../../vmlinuz.bin ]; then
-                ln -sf ../../../vmlinuz.bin
-        fi
-        if [ -f ../../../vmlinux.64 ]; then
-                ln -sf ../../../vmlinux.64
-        fi
-}
-addtask kernel_link_images after do_compile before do_strip
-
-python do_strip() {
-    import shutil
-
-    strip = d.getVar('KERNEL_STRIP')
-    extra_sections = d.getVar('KERNEL_IMAGE_STRIP_EXTRA_SECTIONS')
-    kernel_image = d.getVar('B') + "/" + d.getVar('KERNEL_OUTPUT_DIR') + "/vmlinux"
-
-    if (extra_sections and kernel_image.find(d.getVar('KERNEL_IMAGEDEST') + '/vmlinux') != -1):
-        kernel_image_stripped = kernel_image + ".stripped"
-        shutil.copy2(kernel_image, kernel_image_stripped)
-        oe.package.runstrip((kernel_image_stripped, 8, strip, extra_sections))
-        bb.debug(1, "KERNEL_IMAGE_STRIP_EXTRA_SECTIONS is set, stripping sections: " + \
-            extra_sections)
-}
-do_strip[dirs] = "${B}"
-
-addtask strip before do_sizecheck after do_kernel_link_images
-
-# Support checking the kernel size since some kernels need to reside in partitions
-# with a fixed length or there is a limit in transferring the kernel to memory.
-# If more than one image type is enabled, warn on any that don't fit but only fail
-# if none fit.
-do_sizecheck() {
-        if [ ! -z "${KERNEL_IMAGE_MAXSIZE}" ]; then
-                invalid=`echo ${KERNEL_IMAGE_MAXSIZE} | sed 's/[0-9]//g'`
-                if [ -n "$invalid" ]; then
-                        die "Invalid KERNEL_IMAGE_MAXSIZE: ${KERNEL_IMAGE_MAXSIZE}, should be an integer (The unit is Kbytes)"
-                fi
-                at_least_one_fits=
-                for imageType in ${KERNEL_IMAGETYPES} ; do
-                        size=`du -ks ${B}/${KERNEL_OUTPUT_DIR}/$imageType | awk '{print $1}'`
-                        if [ $size -gt ${KERNEL_IMAGE_MAXSIZE} ]; then
-                                bbwarn "This kernel $imageType (size=$size(K) > ${KERNEL_IMAGE_MAXSIZE}(K)) is too big for your device."
-                        else
-                                at_least_one_fits=y
-                        fi
-                done
-                if [ -z "$at_least_one_fits" ]; then
-                        die "All kernel images are too big for your device. Please reduce the size of the kernel by making more of it modular."
-                fi
-        fi
-}
-do_sizecheck[dirs] = "${B}"
-
-addtask sizecheck before do_install after do_strip
-
-inherit kernel-artifact-names
-
-kernel_do_deploy() {
-        deployDir="${DEPLOYDIR}"
-        if [ -n "${KERNEL_DEPLOYSUBDIR}" ]; then
-                deployDir="${DEPLOYDIR}/${KERNEL_DEPLOYSUBDIR}"
-                mkdir "$deployDir"
-        fi
-
-        for imageType in ${KERNEL_IMAGETYPES} ; do
-                baseName=$imageType-${KERNEL_IMAGE_NAME}
-
-                if [ -s ${KERNEL_OUTPUT_DIR}/$imageType.stripped ] ; then
-                        install -m 0644 ${KERNEL_OUTPUT_DIR}/$imageType.stripped $deployDir/$baseName${KERNEL_IMAGE_BIN_EXT}
-                else
-                        install -m 0644 ${KERNEL_OUTPUT_DIR}/$imageType $deployDir/$baseName${KERNEL_IMAGE_BIN_EXT}
-                fi
-                if [ -n "${KERNEL_IMAGE_LINK_NAME}" ] ; then
-                        ln -sf $baseName${KERNEL_IMAGE_BIN_EXT} $deployDir/$imageType-${KERNEL_IMAGE_LINK_NAME}${KERNEL_IMAGE_BIN_EXT}
-                fi
-                if [ "${KERNEL_IMAGETYPE_SYMLINK}" = "1" ] ; then
-                        ln -sf $baseName${KERNEL_IMAGE_BIN_EXT} $deployDir/$imageType
-                fi
-        done
-
-        if [ ${MODULE_TARBALL_DEPLOY} = "1" ] && (grep -q -i -e '^CONFIG_MODULES=y$' .config); then
-                mkdir -p ${D}${root_prefix}/lib
-                if [ -n "${SOURCE_DATE_EPOCH}" ]; then
-                        TAR_ARGS="--sort=name --clamp-mtime --mtime=@${SOURCE_DATE_EPOCH}"
-                else
-                        TAR_ARGS=""
-                fi
-                TAR_ARGS="$TAR_ARGS --owner=0 --group=0"
-                tar $TAR_ARGS -cv -C ${D}${root_prefix} lib | gzip -9n > $deployDir/modules-${MODULE_TARBALL_NAME}.tgz
-
-                if [ -n "${MODULE_TARBALL_LINK_NAME}" ] ; then
-                        ln -sf modules-${MODULE_TARBALL_NAME}.tgz $deployDir/modules-${MODULE_TARBALL_LINK_NAME}.tgz
-                fi
-        fi
-
-        if [ ! -z "${INITRAMFS_IMAGE}" -a x"${INITRAMFS_IMAGE_BUNDLE}" = x1 ]; then
-                for imageType in ${KERNEL_IMAGETYPES} ; do
-                        initramfsBaseName=$imageType-${INITRAMFS_NAME}
-                        install -m 0644 ${KERNEL_OUTPUT_DIR}/$imageType.initramfs $deployDir/$initramfsBaseName${KERNEL_IMAGE_BIN_EXT}
-                        if [ -n "${INITRAMFS_LINK_NAME}" ] ; then
-                                ln -sf $initramfsBaseName${KERNEL_IMAGE_BIN_EXT} $deployDir/$imageType-${INITRAMFS_LINK_NAME}${KERNEL_IMAGE_BIN_EXT}
-                        fi
-                done
-        fi
-}
-
-# We deploy to filenames that include PKGV and PKGR, read the saved data to
-# ensure we get the right values for both
-do_deploy[prefuncs] += "read_subpackage_metadata"
-
-addtask deploy after do_populate_sysroot do_packagedata
-
-EXPORT_FUNCTIONS do_deploy
-
-# Add using Device Tree support
-inherit kernel-devicetree
diff --git a/meta/classes-recipe/kernelsrc.bbclass b/meta/classes-recipe/kernelsrc.bbclass
deleted file mode 100644
index 9336184298..0000000000
--- a/meta/classes-recipe/kernelsrc.bbclass
+++ /dev/null
@@ -1,21 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-S = "${STAGING_KERNEL_DIR}"
-deltask do_fetch
-deltask do_unpack
-do_patch[depends] += "virtual/kernel:do_shared_workdir"
-do_patch[noexec] = "1"
-do_package[depends] += "virtual/kernel:do_populate_sysroot"
-KERNEL_VERSION = "${@get_kernelversion_file("${STAGING_KERNEL_BUILDDIR}")}"
-LOCAL_VERSION = "${@get_kernellocalversion_file("${STAGING_KERNEL_BUILDDIR}")}"
-
-inherit linux-kernel-base
-
-# The final packages get the kernel version instead of the default 1.0
-python do_package:prepend() {
-    d.setVar('PKGV', d.getVar("KERNEL_VERSION").split("-")[0])
-}
diff --git a/meta/classes-recipe/lib_package.bbclass b/meta/classes-recipe/lib_package.bbclass
deleted file mode 100644
index 6d110155e5..0000000000
--- a/meta/classes-recipe/lib_package.bbclass
+++ /dev/null
@@ -1,12 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-#
-# ${PN}-bin is defined in bitbake.conf
-#
-# We need to allow the other packages to be greedy with what they
-# want out of /usr/bin and /usr/sbin before ${PN}-bin gets greedy.
-# 
-PACKAGE_BEFORE_PN = "${PN}-bin"
diff --git a/meta/classes-recipe/libc-package.bbclass b/meta/classes-recipe/libc-package.bbclass
deleted file mode 100644
index c06a2ce90a..0000000000
--- a/meta/classes-recipe/libc-package.bbclass
+++ /dev/null
@@ -1,392 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-#
-# This class knows how to package up [e]glibc. Its shared since prebuild binary toolchains
-# may need packaging and its pointless to duplicate this code.
-#
-# Caller should set GLIBC_INTERNAL_USE_BINARY_LOCALE to one of:
-#  "compile" - Use QEMU to generate the binary locale files
-#  "precompiled" - The binary locale files are pregenerated and already present
-#  "ondevice" - The device will build the locale files upon first boot through the postinst
-
-GLIBC_INTERNAL_USE_BINARY_LOCALE ?= "ondevice"
-
-GLIBC_SPLIT_LC_PACKAGES ?= "0"
-
-python __anonymous () {
-    enabled = d.getVar("ENABLE_BINARY_LOCALE_GENERATION")
-
-    pn = d.getVar("PN")
-    if pn.endswith("-initial"):
-        enabled = False
-
-    if enabled and int(enabled):
-        import re
-
-        target_arch = d.getVar("TARGET_ARCH")
-        binary_arches = d.getVar("BINARY_LOCALE_ARCHES") or ""
-        use_cross_localedef = d.getVar("LOCALE_GENERATION_WITH_CROSS-LOCALEDEF") or ""
-
-        for regexp in binary_arches.split(" "):
-            r = re.compile(regexp)
-
-            if r.match(target_arch):
-                depends = d.getVar("DEPENDS")
-                if use_cross_localedef == "1" :
-                    depends = "%s cross-localedef-native" % depends
-                else:
-                    depends = "%s qemu-native" % depends
-                d.setVar("DEPENDS", depends)
-                d.setVar("GLIBC_INTERNAL_USE_BINARY_LOCALE", "compile")
-                break
-}
-
-# try to fix disable charsets/locales/locale-code compile fail
-PACKAGE_NO_GCONV ?= "0"
-
-OVERRIDES:append = ":${TARGET_ARCH}-${TARGET_OS}"
-
-locale_base_postinst_ontarget() {
-mkdir ${libdir}/locale
-localedef --inputfile=${datadir}/i18n/locales/%s --charmap=%s %s
-}
-
-locale_base_postrm() {
-#!/bin/sh
-localedef --delete-from-archive --inputfile=${datadir}/locales/%s --charmap=%s %s
-}
-
-LOCALETREESRC ?= "${PKGD}"
-
-do_prep_locale_tree() {
-        treedir=${WORKDIR}/locale-tree
-        rm -rf $treedir
-        mkdir -p $treedir/${base_bindir} $treedir/${base_libdir} $treedir/${datadir} $treedir/${localedir}
-        tar -cf - -C ${LOCALETREESRC}${datadir} -p i18n | tar -xf - -C $treedir/${datadir}
-        # unzip to avoid parsing errors
-        for i in $treedir/${datadir}/i18n/charmaps/*gz; do 
-                gunzip $i
-        done
-        # The extract pattern "./l*.so*" is carefully selected so that it will
-        # match ld*.so and lib*.so*, but not any files in the gconv directory
-        # (if it exists). This makes sure we only unpack the files we need.
-        # This is important in case usrmerge is set in DISTRO_FEATURES, which
-        # means ${base_libdir} == ${libdir}.
-        tar -cf - -C ${LOCALETREESRC}${base_libdir} -p . | tar -xf - -C $treedir/${base_libdir} --wildcards './l*.so*'
-        if [ -f ${STAGING_LIBDIR_NATIVE}/libgcc_s.* ]; then
-                tar -cf - -C ${STAGING_LIBDIR_NATIVE} -p libgcc_s.* | tar -xf - -C $treedir/${base_libdir}
-        fi
-        install -m 0755 ${LOCALETREESRC}${bindir}/localedef $treedir/${base_bindir}
-}
-
-do_collect_bins_from_locale_tree() {
-        treedir=${WORKDIR}/locale-tree
-
-        parent=$(dirname ${localedir})
-        mkdir -p ${PKGD}/$parent
-        tar -cf - -C $treedir/$parent -p $(basename ${localedir}) | tar -xf - -C ${PKGD}$parent
-
-        # Finalize tree by chaning all duplicate files into hard links
-        cross-localedef-hardlink -c -v ${WORKDIR}/locale-tree
-}
-
-inherit qemu
-
-python package_do_split_gconvs () {
-    import re
-    if (d.getVar('PACKAGE_NO_GCONV') == '1'):
-        bb.note("package requested not splitting gconvs")
-        return
-
-    if not d.getVar('PACKAGES'):
-        return
-
-    mlprefix = d.getVar("MLPREFIX") or ""
-
-    bpn = d.getVar('BPN')
-    libdir = d.getVar('libdir')
-    if not libdir:
-        bb.error("libdir not defined")
-        return
-    datadir = d.getVar('datadir')
-    if not datadir:
-        bb.error("datadir not defined")
-        return
-
-    gconv_libdir = oe.path.join(libdir, "gconv")
-    charmap_dir = oe.path.join(datadir, "i18n", "charmaps")
-    locales_dir = oe.path.join(datadir, "i18n", "locales")
-    binary_locales_dir = d.getVar('localedir')
-
-    def calc_gconv_deps(fn, pkg, file_regex, output_pattern, group):
-        deps = []
-        f = open(fn, "rb")
-        c_re = re.compile(r'^copy "(.*)"')
-        i_re = re.compile(r'^include "(\w+)".*')
-        for l in f.readlines():
-            l = l.decode("latin-1")
-            m = c_re.match(l) or i_re.match(l)
-            if m:
-                dp = legitimize_package_name('%s%s-gconv-%s' % (mlprefix, bpn, m.group(1)))
-                if not dp in deps:
-                    deps.append(dp)
-        f.close()
-        if deps != []:
-            d.setVar('RDEPENDS:%s' % pkg, " ".join(deps))
-        if bpn != 'glibc':
-            d.setVar('RPROVIDES:%s' % pkg, pkg.replace(bpn, 'glibc'))
-
-    do_split_packages(d, gconv_libdir, file_regex=r'^(.*)\.so$', output_pattern=bpn+'-gconv-%s', \
-        description='gconv module for character set %s', hook=calc_gconv_deps, \
-        extra_depends=bpn+'-gconv')
-
-    def calc_charmap_deps(fn, pkg, file_regex, output_pattern, group):
-        deps = []
-        f = open(fn, "rb")
-        c_re = re.compile(r'^copy "(.*)"')
-        i_re = re.compile(r'^include "(\w+)".*')
-        for l in f.readlines():
-            l = l.decode("latin-1")
-            m = c_re.match(l) or i_re.match(l)
-            if m:
-                dp = legitimize_package_name('%s%s-charmap-%s' % (mlprefix, bpn, m.group(1)))
-                if not dp in deps:
-                    deps.append(dp)
-        f.close()
-        if deps != []:
-            d.setVar('RDEPENDS:%s' % pkg, " ".join(deps))
-        if bpn != 'glibc':
-            d.setVar('RPROVIDES:%s' % pkg, pkg.replace(bpn, 'glibc'))
-
-    do_split_packages(d, charmap_dir, file_regex=r'^(.*)\.gz$', output_pattern=bpn+'-charmap-%s', \
-        description='character map for %s encoding', hook=calc_charmap_deps, extra_depends='')
-
-    def calc_locale_deps(fn, pkg, file_regex, output_pattern, group):
-        deps = []
-        f = open(fn, "rb")
-        c_re = re.compile(r'^copy "(.*)"')
-        i_re = re.compile(r'^include "(\w+)".*')
-        for l in f.readlines():
-            l = l.decode("latin-1")
-            m = c_re.match(l) or i_re.match(l)
-            if m:
-                dp = legitimize_package_name(mlprefix+bpn+'-localedata-%s' % m.group(1))
-                if not dp in deps:
-                    deps.append(dp)
-        f.close()
-        if deps != []:
-            d.setVar('RDEPENDS:%s' % pkg, " ".join(deps))
-        if bpn != 'glibc':
-            d.setVar('RPROVIDES:%s' % pkg, pkg.replace(bpn, 'glibc'))
-
-    do_split_packages(d, locales_dir, file_regex=r'(.*)', output_pattern=bpn+'-localedata-%s', \
-        description='locale definition for %s', hook=calc_locale_deps, extra_depends='')
-    d.setVar('PACKAGES', d.getVar('PACKAGES', False) + ' ' + d.getVar('MLPREFIX', False) + bpn + '-gconv')
-
-    use_bin = d.getVar("GLIBC_INTERNAL_USE_BINARY_LOCALE")
-
-    dot_re = re.compile(r"(.*)\.(.*)")
-
-    # Read in supported locales and associated encodings
-    supported = {}
-    with open(oe.path.join(d.getVar('WORKDIR'), "SUPPORTED")) as f:
-        for line in f.readlines():
-            try:
-                locale, charset = line.rstrip().split()
-            except ValueError:
-                continue
-            supported[locale] = charset
-
-    # GLIBC_GENERATE_LOCALES var specifies which locales to be generated. empty or "all" means all locales
-    to_generate = d.getVar('GLIBC_GENERATE_LOCALES')
-    if not to_generate or to_generate == 'all':
-        to_generate = sorted(supported.keys())
-    else:
-        to_generate = to_generate.split()
-        for locale in to_generate:
-            if locale not in supported:
-                if '.' in locale:
-                    charset = locale.split('.')[1]
-                else:
-                    charset = 'UTF-8'
-                    bb.warn("Unsupported locale '%s', assuming encoding '%s'" % (locale, charset))
-                supported[locale] = charset
-
-    def output_locale_source(name, pkgname, locale, encoding):
-        d.setVar('RDEPENDS:%s' % pkgname, '%slocaledef %s-localedata-%s %s-charmap-%s' % \
-        (mlprefix, mlprefix+bpn, legitimize_package_name(locale), mlprefix+bpn, legitimize_package_name(encoding)))
-        d.setVar('pkg_postinst_ontarget:%s' % pkgname, d.getVar('locale_base_postinst_ontarget') \
-        % (locale, encoding, locale))
-        d.setVar('pkg_postrm:%s' % pkgname, d.getVar('locale_base_postrm') % \
-        (locale, encoding, locale))
-
-    def output_locale_binary_rdepends(name, pkgname, locale, encoding):
-        dep = legitimize_package_name('%s-binary-localedata-%s' % (bpn, name))
-        lcsplit = d.getVar('GLIBC_SPLIT_LC_PACKAGES')
-        if lcsplit and int(lcsplit):
-            d.appendVar('PACKAGES', ' ' + dep)
-            d.setVar('ALLOW_EMPTY:%s' % dep, '1')
-        d.setVar('RDEPENDS:%s' % pkgname, mlprefix + dep)
-
-    commands = {}
-
-    def output_locale_binary(name, pkgname, locale, encoding):
-        treedir = oe.path.join(d.getVar("WORKDIR"), "locale-tree")
-        ldlibdir = oe.path.join(treedir, d.getVar("base_libdir"))
-        path = d.getVar("PATH")
-        i18npath = oe.path.join(treedir, datadir, "i18n")
-        gconvpath = oe.path.join(treedir, "iconvdata")
-        outputpath = oe.path.join(treedir, binary_locales_dir)
-
-        use_cross_localedef = d.getVar("LOCALE_GENERATION_WITH_CROSS-LOCALEDEF") or "0"
-        if use_cross_localedef == "1":
-            target_arch = d.getVar('TARGET_ARCH')
-            locale_arch_options = { \
-                "arc":     " --uint32-align=4 --little-endian ", \
-                "arceb":   " --uint32-align=4 --big-endian ",    \
-                "arm":     " --uint32-align=4 --little-endian ", \
-                "armeb":   " --uint32-align=4 --big-endian ",    \
-                "aarch64": " --uint32-align=4 --little-endian ",    \
-                "aarch64_be": " --uint32-align=4 --big-endian ",    \
-                "sh4":     " --uint32-align=4 --big-endian ",    \
-                "powerpc": " --uint32-align=4 --big-endian ",    \
-                "powerpc64": " --uint32-align=4 --big-endian ",  \
-                "powerpc64le": " --uint32-align=4 --little-endian ",  \
-                "mips":    " --uint32-align=4 --big-endian ",    \
-                "mipsisa32r6":    " --uint32-align=4 --big-endian ",    \
-                "mips64":  " --uint32-align=4 --big-endian ",    \
-                "mipsisa64r6":  " --uint32-align=4 --big-endian ",    \
-                "mipsel":  " --uint32-align=4 --little-endian ", \
-                "mipsisa32r6el":  " --uint32-align=4 --little-endian ", \
-                "mips64el":" --uint32-align=4 --little-endian ", \
-                "mipsisa64r6el":" --uint32-align=4 --little-endian ", \
-                "riscv64": " --uint32-align=4 --little-endian ", \
-                "riscv32": " --uint32-align=4 --little-endian ", \
-                "i586":    " --uint32-align=4 --little-endian ", \
-                "i686":    " --uint32-align=4 --little-endian ", \
-                "x86_64":  " --uint32-align=4 --little-endian ", \
-                "loongarch64": " --uint32-align=4 --little-endian "  }
-
-            if target_arch in locale_arch_options:
-                localedef_opts = locale_arch_options[target_arch]
-            else:
-                bb.error("locale_arch_options not found for target_arch=" + target_arch)
-                bb.fatal("unknown arch:" + target_arch + " for locale_arch_options")
-
-            localedef_opts += " --force --no-hard-links --no-archive --prefix=%s \
-                --inputfile=%s/%s/i18n/locales/%s --charmap=%s %s/%s --no-warnings=ascii" \
-                % (treedir, treedir, datadir, locale, encoding, outputpath, name)
-
-            cmd = "PATH=\"%s\" I18NPATH=\"%s\" GCONV_PATH=\"%s\" cross-localedef %s" % \
-                (path, i18npath, gconvpath, localedef_opts)
-        else: # earlier slower qemu way 
-            qemu = qemu_target_binary(d) 
-            localedef_opts = "--force --no-hard-links --no-archive --prefix=%s \
-                --inputfile=%s/i18n/locales/%s --charmap=%s %s" \
-                % (treedir, datadir, locale, encoding, name)
-
-            qemu_options = d.getVar('QEMU_OPTIONS')
-
-            cmd = "PSEUDO_RELOADED=YES PATH=\"%s\" I18NPATH=\"%s\" %s -L %s \
-                -E LD_LIBRARY_PATH=%s %s %s${base_bindir}/localedef %s" % \
-                (path, i18npath, qemu, treedir, ldlibdir, qemu_options, treedir, localedef_opts)
-
-        commands["%s/%s" % (outputpath, name)] = cmd
-
-        bb.note("generating locale %s (%s)" % (locale, encoding))
-
-    def output_locale(name, locale, encoding):
-        pkgname = d.getVar('MLPREFIX', False) + 'locale-base-' + legitimize_package_name(name)
-        d.setVar('ALLOW_EMPTY:%s' % pkgname, '1')
-        d.setVar('PACKAGES', '%s %s' % (pkgname, d.getVar('PACKAGES')))
-        rprovides = ' %svirtual-locale-%s' % (mlprefix, legitimize_package_name(name))
-        m = re.match(r"(.*)_(.*)", name)
-        if m:
-            rprovides += ' %svirtual-locale-%s' % (mlprefix, m.group(1))
-        d.setVar('RPROVIDES:%s' % pkgname, rprovides)
-
-        if use_bin == "compile":
-            output_locale_binary_rdepends(name, pkgname, locale, encoding)
-            output_locale_binary(name, pkgname, locale, encoding)
-        elif use_bin == "precompiled":
-            output_locale_binary_rdepends(name, pkgname, locale, encoding)
-        else:
-            output_locale_source(name, pkgname, locale, encoding)
-
-    if use_bin == "compile":
-        bb.note("preparing tree for binary locale generation")
-        bb.build.exec_func("do_prep_locale_tree", d)
-
-    utf8_only = int(d.getVar('LOCALE_UTF8_ONLY') or 0)
-    utf8_is_default = int(d.getVar('LOCALE_UTF8_IS_DEFAULT') or 0)
-
-    encodings = {}
-    for locale in to_generate:
-        charset = supported[locale]
-        if utf8_only and charset != 'UTF-8':
-            continue
-
-        m = dot_re.match(locale)
-        if m:
-            base = m.group(1)
-        else:
-            base = locale
-
-        # Non-precompiled locales may be renamed so that the default
-        # (non-suffixed) encoding is always UTF-8, i.e., instead of en_US and
-        # en_US.UTF-8, we have en_US and en_US.ISO-8859-1. This implicitly
-        # contradicts SUPPORTED.
-        if use_bin == "precompiled" or not utf8_is_default:
-            output_locale(locale, base, charset)
-        else:
-            if charset == 'UTF-8':
-                output_locale(base, base, charset)
-            else:
-                output_locale('%s.%s' % (base, charset), base, charset)
-
-    def metapkg_hook(file, pkg, pattern, format, basename):
-        name = basename.split('/', 1)[0]
-        metapkg = legitimize_package_name('%s-binary-localedata-%s' % (mlprefix+bpn, name))
-        d.appendVar('RDEPENDS:%s' % metapkg, ' ' + pkg)
-
-    if use_bin == "compile":
-        makefile = oe.path.join(d.getVar("WORKDIR"), "locale-tree", "Makefile")
-        with open(makefile, "w") as m:
-            m.write("all: %s\n\n" % " ".join(commands.keys()))
-            total = len(commands)
-            for i, (maketarget, makerecipe) in enumerate(commands.items()):
-                m.write(maketarget + ":\n")
-                m.write("\t@echo 'Progress %d/%d'\n" % (i, total))
-                m.write("\t" + makerecipe + "\n\n")
-        d.setVar("EXTRA_OEMAKE", "-C %s ${PARALLEL_MAKE}" % (os.path.dirname(makefile)))
-        d.setVarFlag("oe_runmake", "progress", r"outof:Progress\s(\d+)/(\d+)")
-        bb.note("Executing binary locale generation makefile")
-        bb.build.exec_func("oe_runmake", d)
-        bb.note("collecting binary locales from locale tree")
-        bb.build.exec_func("do_collect_bins_from_locale_tree", d)
-
-    if use_bin in ('compile', 'precompiled'):
-        lcsplit = d.getVar('GLIBC_SPLIT_LC_PACKAGES')
-        if lcsplit and int(lcsplit):
-            do_split_packages(d, binary_locales_dir, file_regex=r'^(.*/LC_\w+)', \
-                output_pattern=bpn+'-binary-localedata-%s', \
-                description='binary locale definition for %s', recursive=True,
-                hook=metapkg_hook, extra_depends='', allow_dirs=True, match_path=True)
-        else:
-            do_split_packages(d, binary_locales_dir, file_regex=r'(.*)', \
-                output_pattern=bpn+'-binary-localedata-%s', \
-                description='binary locale definition for %s', extra_depends='', allow_dirs=True)
-    else:
-        bb.note("generation of binary locales disabled. this may break i18n!")
-
-}
-
-# We want to do this indirection so that we can safely 'return'
-# from the called function even though we're prepending
-python populate_packages:prepend () {
-    bb.build.exec_func('package_do_split_gconvs', d)
-}
diff --git a/meta/classes-recipe/license_image.bbclass b/meta/classes-recipe/license_image.bbclass
deleted file mode 100644
index d2c5ab902c..0000000000
--- a/meta/classes-recipe/license_image.bbclass
+++ /dev/null
@@ -1,317 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-ROOTFS_LICENSE_DIR = "${IMAGE_ROOTFS}/usr/share/common-licenses"
-
-# This requires LICENSE_CREATE_PACKAGE=1 to work too
-COMPLEMENTARY_GLOB[lic-pkgs] = "*-lic"
-
-python() {
-    if not oe.data.typed_value('LICENSE_CREATE_PACKAGE', d):
-        features = set(oe.data.typed_value('IMAGE_FEATURES', d))
-        if 'lic-pkgs' in features:
-            bb.error("'lic-pkgs' in IMAGE_FEATURES but LICENSE_CREATE_PACKAGE not enabled to generate -lic packages")
-}
-
-python write_package_manifest() {
-    # Get list of installed packages
-    license_image_dir = d.expand('${LICENSE_DIRECTORY}/${SSTATE_PKGARCH}/${IMAGE_NAME}')
-    bb.utils.mkdirhier(license_image_dir)
-    from oe.rootfs import image_list_installed_packages
-    from oe.utils import format_pkg_list
-
-    pkgs = image_list_installed_packages(d)
-    output = format_pkg_list(pkgs)
-    with open(os.path.join(license_image_dir, 'package.manifest'), "w+") as package_manifest:
-        package_manifest.write(output)
-}
-
-python license_create_manifest() {
-    import oe.packagedata
-    from oe.rootfs import image_list_installed_packages
-
-    build_images_from_feeds = d.getVar('BUILD_IMAGES_FROM_FEEDS')
-    if build_images_from_feeds == "1":
-        return 0
-
-    pkg_dic = {}
-    for pkg in sorted(image_list_installed_packages(d)):
-        pkg_info = os.path.join(d.getVar('PKGDATA_DIR'),
-                                'runtime-reverse', pkg)
-        pkg_name = os.path.basename(os.readlink(pkg_info))
-
-        pkg_dic[pkg_name] = oe.packagedata.read_pkgdatafile(pkg_info)
-        if not "LICENSE" in pkg_dic[pkg_name].keys():
-            pkg_lic_name = "LICENSE:" + pkg_name
-            pkg_dic[pkg_name]["LICENSE"] = pkg_dic[pkg_name][pkg_lic_name]
-
-    rootfs_license_manifest = os.path.join(d.getVar('LICENSE_DIRECTORY'),
-                        d.getVar('SSTATE_PKGARCH'), d.getVar('IMAGE_NAME'), 'license.manifest')
-    write_license_files(d, rootfs_license_manifest, pkg_dic, rootfs=True)
-}
-
-def write_license_files(d, license_manifest, pkg_dic, rootfs=True):
-    import re
-    import stat
-
-    bad_licenses = (d.getVar("INCOMPATIBLE_LICENSE") or "").split()
-    bad_licenses = oe.license.expand_wildcard_licenses(d, bad_licenses)
-    pkgarchs = d.getVar("SSTATE_ARCHS").split()
-    pkgarchs.reverse()
-
-    exceptions = (d.getVar("INCOMPATIBLE_LICENSE_EXCEPTIONS") or "").split()
-    with open(license_manifest, "w") as license_file:
-        for pkg in sorted(pkg_dic):
-            remaining_bad_licenses = oe.license.apply_pkg_license_exception(pkg, bad_licenses, exceptions)
-            incompatible_licenses = oe.license.incompatible_pkg_license(d, remaining_bad_licenses, pkg_dic[pkg]["LICENSE"])
-            if incompatible_licenses:
-                bb.fatal("Package %s cannot be installed into the image because it has incompatible license(s): %s" %(pkg, ' '.join(incompatible_licenses)))
-            else:
-                incompatible_licenses = oe.license.incompatible_pkg_license(d, bad_licenses, pkg_dic[pkg]["LICENSE"])
-                if incompatible_licenses:
-                    oe.qa.handle_error('license-exception', "Including %s with incompatible license(s) %s into the image, because it has been allowed by exception list." %(pkg, ' '.join(incompatible_licenses)), d)
-            try:
-                (pkg_dic[pkg]["LICENSE"], pkg_dic[pkg]["LICENSES"]) = \
-                    oe.license.manifest_licenses(pkg_dic[pkg]["LICENSE"],
-                    remaining_bad_licenses, oe.license.canonical_license, d)
-            except oe.license.LicenseError as exc:
-                bb.fatal('%s: %s' % (d.getVar('P'), exc))
-
-            if not "IMAGE_MANIFEST" in pkg_dic[pkg]:
-                # Rootfs manifest
-                license_file.write("PACKAGE NAME: %s\n" % pkg)
-                license_file.write("PACKAGE VERSION: %s\n" % pkg_dic[pkg]["PV"])
-                license_file.write("RECIPE NAME: %s\n" % pkg_dic[pkg]["PN"])
-                license_file.write("LICENSE: %s\n\n" % pkg_dic[pkg]["LICENSE"])
-
-                # If the package doesn't contain any file, that is, its size is 0, the license
-                # isn't relevant as far as the final image is concerned. So doing license check
-                # doesn't make much sense, skip it.
-                if pkg_dic[pkg]["PKGSIZE:%s" % pkg] == "0":
-                    continue
-            else:
-                # Image manifest
-                license_file.write("RECIPE NAME: %s\n" % pkg_dic[pkg]["PN"])
-                license_file.write("VERSION: %s\n" % pkg_dic[pkg]["PV"])
-                license_file.write("LICENSE: %s\n" % pkg_dic[pkg]["LICENSE"])
-                license_file.write("FILES: %s\n\n" % pkg_dic[pkg]["FILES"])
-
-            for lic in pkg_dic[pkg]["LICENSES"]:
-                for pkgarch in pkgarchs:
-                    lic_file = os.path.join(d.getVar('LICENSE_DIRECTORY'),
-                                            pkgarch,
-                                            pkg_dic[pkg]["PN"], "generic_%s" %
-                                            re.sub(r'\+', '', lic))
-                    if os.path.exists(lic_file):
-                        break
-                # add explicity avoid of CLOSED license because isn't generic
-                if lic == "CLOSED":
-                   continue
-
-                if not os.path.exists(lic_file):
-                    oe.qa.handle_error('license-file-missing',
-                                       "The license listed %s was not in the "\
-                                       "licenses collected for recipe %s"
-                                       % (lic, pkg_dic[pkg]["PN"]), d)
-    oe.qa.exit_if_errors(d)
-
-    # Two options here:
-    # - Just copy the manifest
-    # - Copy the manifest and the license directories
-    # With both options set we see a .5 M increase in core-image-minimal
-    copy_lic_manifest = d.getVar('COPY_LIC_MANIFEST')
-    copy_lic_dirs = d.getVar('COPY_LIC_DIRS')
-    if rootfs and copy_lic_manifest == "1":
-        rootfs_license_dir = d.getVar('ROOTFS_LICENSE_DIR')
-        bb.utils.mkdirhier(rootfs_license_dir)
-        rootfs_license_manifest = os.path.join(rootfs_license_dir,
-                os.path.split(license_manifest)[1])
-        if not os.path.exists(rootfs_license_manifest):
-            oe.path.copyhardlink(license_manifest, rootfs_license_manifest)
-
-        if copy_lic_dirs == "1":
-            for pkg in sorted(pkg_dic):
-                pkg_rootfs_license_dir = os.path.join(rootfs_license_dir, pkg)
-                bb.utils.mkdirhier(pkg_rootfs_license_dir)
-                for pkgarch in pkgarchs:
-                    pkg_license_dir = os.path.join(d.getVar('LICENSE_DIRECTORY'),
-                                                   pkgarch, pkg_dic[pkg]["PN"])
-                    if os.path.exists(pkg_license_dir):
-                        break
-                if not os.path.exists(pkg_license_dir ):
-                    bb.fatal("Couldn't find license information for dependency %s" % pkg)
-
-                pkg_manifest_licenses = [oe.license.canonical_license(d, lic) \
-                        for lic in pkg_dic[pkg]["LICENSES"]]
-
-                licenses = os.listdir(pkg_license_dir)
-                for lic in licenses:
-                    pkg_license = os.path.join(pkg_license_dir, lic)
-                    pkg_rootfs_license = os.path.join(pkg_rootfs_license_dir, lic)
-
-                    if re.match(r"^generic_.*$", lic):
-                        generic_lic = oe.license.canonical_license(d,
-                                re.search(r"^generic_(.*)$", lic).group(1))
-
-                        # Do not copy generic license into package if isn't
-                        # declared into LICENSES of the package.
-                        if not re.sub(r'\+$', '', generic_lic) in \
-                                [re.sub(r'\+', '', lic) for lic in \
-                                 pkg_manifest_licenses]:
-                            continue
-
-                        if oe.license.license_ok(generic_lic,
-                                bad_licenses) == False:
-                            continue
-
-                        # Make sure we use only canonical name for the license file
-                        generic_lic_file = "generic_%s" % generic_lic
-                        rootfs_license = os.path.join(rootfs_license_dir, generic_lic_file)
-                        if not os.path.exists(rootfs_license):
-                            oe.path.copyhardlink(pkg_license, rootfs_license)
-
-                        if not os.path.exists(pkg_rootfs_license):
-                            os.symlink(os.path.join('..', generic_lic_file), pkg_rootfs_license)
-                    else:
-                        if (oe.license.license_ok(oe.license.canonical_license(d,
-                                lic), bad_licenses) == False or
-                                os.path.exists(pkg_rootfs_license)):
-                            continue
-
-                        oe.path.copyhardlink(pkg_license, pkg_rootfs_license)
-            # Fixup file ownership and permissions
-            for walkroot, dirs, files in os.walk(rootfs_license_dir):
-                for f in files:
-                    p = os.path.join(walkroot, f)
-                    os.lchown(p, 0, 0)
-                    if not os.path.islink(p):
-                        os.chmod(p, stat.S_IRUSR | stat.S_IWUSR | stat.S_IRGRP | stat.S_IROTH)
-                for dir in dirs:
-                    p = os.path.join(walkroot, dir)
-                    os.lchown(p, 0, 0)
-                    os.chmod(p, stat.S_IRWXU | stat.S_IRGRP | stat.S_IXGRP | stat.S_IROTH | stat.S_IXOTH)
-
-write_license_files[vardepsexclude] = "SSTATE_ARCHS"
-
-def license_deployed_manifest(d):
-    """
-    Write the license manifest for the deployed recipes.
-    The deployed recipes usually includes the bootloader
-    and extra files to boot the target.
-    """
-
-    dep_dic = {}
-    man_dic = {}
-    lic_dir = d.getVar("LICENSE_DIRECTORY")
-    pkgarchs = d.getVar("SSTATE_ARCHS").split()
-    pkgarchs.reverse()
-
-    dep_dic = get_deployed_dependencies(d)
-    for dep in dep_dic.keys():
-        man_dic[dep] = {}
-        # It is necessary to mark this will be used for image manifest
-        man_dic[dep]["IMAGE_MANIFEST"] = True
-        man_dic[dep]["PN"] = dep
-        man_dic[dep]["FILES"] = \
-            " ".join(get_deployed_files(dep_dic[dep]))
-
-        for pkgarch in pkgarchs:
-            licfile = os.path.join(lic_dir, pkgarch, dep, "recipeinfo")
-            if os.path.exists(licfile):
-                break
-        if not os.path.exists(licfile):
-            bb.fatal("Couldn't find license information for dependency %s" % dep)
-        with open(licfile, "r") as f:
-            for line in f.readlines():
-                key,val = line.split(": ", 1)
-                man_dic[dep][key] = val[:-1]
-
-    lic_manifest_dir = os.path.join(d.getVar('LICENSE_DIRECTORY'), d.getVar('SSTATE_PKGARCH'),
-                                    d.getVar('IMAGE_NAME'))
-    bb.utils.mkdirhier(lic_manifest_dir)
-    image_license_manifest = os.path.join(lic_manifest_dir, 'image_license.manifest')
-    write_license_files(d, image_license_manifest, man_dic, rootfs=False)
-
-    link_name = d.getVar('IMAGE_LINK_NAME')
-    if link_name:
-        lic_manifest_symlink_dir = os.path.join(d.getVar('LICENSE_DIRECTORY'), d.getVar('SSTATE_PKGARCH'),
-                                    link_name)
-        # remove old symlink
-        if os.path.islink(lic_manifest_symlink_dir):
-            os.unlink(lic_manifest_symlink_dir)
-
-        # create the image dir symlink
-        if lic_manifest_dir != lic_manifest_symlink_dir:
-            os.symlink(lic_manifest_dir, lic_manifest_symlink_dir)
-
-license_deployed_manifest[vardepsexclude] = "SSTATE_ARCHS"
-
-def get_deployed_dependencies(d):
-    """
-    Get all the deployed dependencies of an image
-    """
-
-    deploy = {}
-    # Get all the dependencies for the current task (rootfs).
-    taskdata = d.getVar("BB_TASKDEPDATA", False)
-    pn = d.getVar("PN")
-    depends = list(set([dep[0] for dep
-                    in list(taskdata.values())
-                    if not dep[0].endswith("-native") and not dep[0] == pn]))
-
-    # To verify what was deployed it checks the rootfs dependencies against
-    # the SSTATE_MANIFESTS for "deploy" task.
-    # The manifest file name contains the arch. Because we are not running
-    # in the recipe context it is necessary to check every arch used.
-    sstate_manifest_dir = d.getVar("SSTATE_MANIFESTS")
-    archs = list(set(d.getVar("SSTATE_ARCHS").split()))
-    for dep in depends:
-        for arch in archs:
-            sstate_manifest_file = os.path.join(sstate_manifest_dir,
-                    "manifest-%s-%s.deploy" % (arch, dep))
-            if os.path.exists(sstate_manifest_file):
-                deploy[dep] = sstate_manifest_file
-                break
-
-    return deploy
-get_deployed_dependencies[vardepsexclude] = "BB_TASKDEPDATA SSTATE_ARCHS"
-
-def get_deployed_files(man_file):
-    """
-    Get the files deployed from the sstate manifest
-    """
-
-    dep_files = []
-    excluded_files = []
-    with open(man_file, "r") as manifest:
-        all_files = manifest.read()
-    for f in all_files.splitlines():
-        if ((not (os.path.islink(f) or os.path.isdir(f))) and
-                not os.path.basename(f) in excluded_files):
-            dep_files.append(os.path.basename(f))
-    return dep_files
-
-ROOTFS_POSTPROCESS_COMMAND:prepend = "write_package_manifest license_create_manifest "
-do_rootfs[recrdeptask] += "do_populate_lic"
-
-python do_populate_lic_deploy() {
-    license_deployed_manifest(d)
-    oe.qa.exit_if_errors(d)
-}
-
-addtask populate_lic_deploy before do_build after do_image_complete
-do_populate_lic_deploy[recrdeptask] += "do_populate_lic do_deploy"
-
-python license_qa_dead_symlink() {
-    import os
-
-    for root, dirs, files in os.walk(d.getVar('ROOTFS_LICENSE_DIR')):
-        for file in files:
-            full_path = root + "/" + file
-            if os.path.islink(full_path) and not os.path.exists(full_path):
-                bb.error("broken symlink: " + full_path)
-}
-IMAGE_QA_COMMANDS += "license_qa_dead_symlink"
diff --git a/meta/classes-recipe/linux-dummy.bbclass b/meta/classes-recipe/linux-dummy.bbclass
deleted file mode 100644
index 9291533cf9..0000000000
--- a/meta/classes-recipe/linux-dummy.bbclass
+++ /dev/null
@@ -1,31 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-python __anonymous () {
-    if d.getVar('PREFERRED_PROVIDER_virtual/kernel') == 'linux-dummy':
-        # copy part codes from kernel.bbclass
-        kname = d.getVar('KERNEL_PACKAGE_NAME') or "kernel"
-
-        # set an empty package of kernel-devicetree
-        d.appendVar('PACKAGES', ' %s-devicetree' % kname)
-        d.setVar('ALLOW_EMPTY:%s-devicetree' % kname, '1')
-
-        # Merge KERNEL_IMAGETYPE and KERNEL_ALT_IMAGETYPE into KERNEL_IMAGETYPES
-        type = d.getVar('KERNEL_IMAGETYPE') or ""
-        alttype = d.getVar('KERNEL_ALT_IMAGETYPE') or ""
-        types = d.getVar('KERNEL_IMAGETYPES') or ""
-        if type not in types.split():
-            types = (type + ' ' + types).strip()
-        if alttype not in types.split():
-            types = (alttype + ' ' + types).strip()
-
-        # set empty packages of kernel-image-*
-        for type in types.split():
-            typelower = type.lower()
-            d.appendVar('PACKAGES', ' %s-image-%s' % (kname, typelower))
-            d.setVar('ALLOW_EMPTY:%s-image-%s' % (kname, typelower), '1')
-}
-
diff --git a/meta/classes-recipe/linux-kernel-base.bbclass b/meta/classes-recipe/linux-kernel-base.bbclass
deleted file mode 100644
index e2187a73f0..0000000000
--- a/meta/classes-recipe/linux-kernel-base.bbclass
+++ /dev/null
@@ -1,62 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-# parse kernel ABI version out of <linux/version.h>
-def get_kernelversion_headers(p):
-    import re
-
-    fn = p + '/include/linux/utsrelease.h'
-    if not os.path.isfile(fn):
-        # after 2.6.33-rc1
-        fn = p + '/include/generated/utsrelease.h'
-    if not os.path.isfile(fn):
-        fn = p + '/include/linux/version.h'
-
-    try:
-        f = open(fn, 'r')
-    except IOError:
-        return None
-
-    l = f.readlines()
-    f.close()
-    r = re.compile("#define UTS_RELEASE \"(.*)\"")
-    for s in l:
-        m = r.match(s)
-        if m:
-            return m.group(1)
-    return None
-
-
-def get_kernelversion_file(p):
-    fn = p + '/kernel-abiversion'
-
-    try:
-        with open(fn, 'r') as f:
-            return f.readlines()[0].strip()
-    except IOError:
-        return None
-
-def get_kernellocalversion_file(p):
-    fn = p + '/kernel-localversion'
-
-    try:
-        with open(fn, 'r') as f:
-            return f.readlines()[0].strip()
-    except IOError:
-        return ""
-
-    return ""
-
-def linux_module_packages(s, d):
-    suffix = ""
-    return " ".join(map(lambda s: "kernel-module-%s%s" % (s.lower().replace('_', '-').replace('@', '+'), suffix), s.split()))
-
-export KBUILD_BUILD_VERSION = "1"
-export KBUILD_BUILD_USER ?= "oe-user"
-export KBUILD_BUILD_HOST ?= "oe-host"
-
-# that's all
-
diff --git a/meta/classes-recipe/linuxloader.bbclass b/meta/classes-recipe/linuxloader.bbclass
deleted file mode 100644
index a2e8f9837b..0000000000
--- a/meta/classes-recipe/linuxloader.bbclass
+++ /dev/null
@@ -1,84 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-def get_musl_loader_arch(d):
-    import re
-    ldso_arch = "NotSupported"
-
-    targetarch = d.getVar("TARGET_ARCH")
-    if targetarch.startswith("microblaze"):
-        ldso_arch = "microblaze${@bb.utils.contains('TUNE_FEATURES', 'bigendian', '', 'el', d)}"
-    elif targetarch.startswith("mips"):
-        ldso_arch = "mips${ABIEXTENSION}${MIPSPKGSFX_BYTE}${MIPSPKGSFX_R6}${MIPSPKGSFX_ENDIAN}${@['', '-sf'][d.getVar('TARGET_FPU') == 'soft']}"
-    elif targetarch == "powerpc":
-        ldso_arch = "powerpc${@['', '-sf'][d.getVar('TARGET_FPU') == 'soft']}"
-    elif targetarch.startswith("powerpc64"):
-        ldso_arch = "powerpc64${@bb.utils.contains('TUNE_FEATURES', 'bigendian', '', 'le', d)}"
-    elif targetarch == "x86_64":
-        ldso_arch = "x86_64"
-    elif re.search("i.86", targetarch):
-        ldso_arch = "i386"
-    elif targetarch.startswith("arm"):
-        ldso_arch = "arm${ARMPKGSFX_ENDIAN}${ARMPKGSFX_EABI}"
-    elif targetarch.startswith("aarch64"):
-        ldso_arch = "aarch64${ARMPKGSFX_ENDIAN_64}"
-    elif targetarch.startswith("riscv64"):
-        ldso_arch = "riscv64${@['', '-sf'][d.getVar('TARGET_FPU') == 'soft']}"
-    elif targetarch.startswith("riscv32"):
-        ldso_arch = "riscv32${@['', '-sf'][d.getVar('TARGET_FPU') == 'soft']}"
-    return ldso_arch
-
-def get_musl_loader(d):
-    import re
-    return "/lib/ld-musl-" + get_musl_loader_arch(d) + ".so.1"
-
-def get_glibc_loader(d):
-    import re
-
-    dynamic_loader = "NotSupported"
-    targetarch = d.getVar("TARGET_ARCH")
-    if targetarch in ["powerpc", "microblaze"]:
-        dynamic_loader = "${base_libdir}/ld.so.1"
-    elif targetarch in ["mipsisa32r6el", "mipsisa32r6", "mipsisa64r6el", "mipsisa64r6"]:
-        dynamic_loader = "${base_libdir}/ld-linux-mipsn8.so.1"
-    elif targetarch.startswith("mips"):
-        dynamic_loader = "${base_libdir}/ld.so.1"
-    elif targetarch.startswith("loongarch64"):
-        dynamic_loader = "${base_libdir}/ld-linux-loongarch-lp64d.so.1"
-    elif targetarch == "powerpc64le":
-        dynamic_loader = "${base_libdir}/ld64.so.2"
-    elif targetarch == "powerpc64":
-        dynamic_loader = "${base_libdir}/ld64.so.1"
-    elif targetarch == "x86_64":
-        dynamic_loader = "${base_libdir}/ld-linux-x86-64.so.2"
-    elif re.search("i.86", targetarch):
-        dynamic_loader = "${base_libdir}/ld-linux.so.2"
-    elif targetarch == "arm":
-        dynamic_loader = "${base_libdir}/ld-linux${@['', '-armhf'][d.getVar('TARGET_FPU') == 'hard']}.so.3"
-    elif targetarch.startswith("aarch64"):
-        dynamic_loader = "${base_libdir}/ld-linux-aarch64${ARMPKGSFX_ENDIAN_64}.so.1"
-    elif targetarch.startswith("riscv64"):
-        dynamic_loader = "${base_libdir}/ld-linux-riscv64-lp64${@['d', ''][d.getVar('TARGET_FPU') == 'soft']}.so.1"
-    elif targetarch.startswith("riscv32"):
-        dynamic_loader = "${base_libdir}/ld-linux-riscv32-ilp32${@['d', ''][d.getVar('TARGET_FPU') == 'soft']}.so.1"
-    return dynamic_loader
-
-def get_linuxloader(d):
-    overrides = d.getVar("OVERRIDES").split(":")
-
-    if "libc-baremetal" in overrides:
-        return "NotSupported"
-
-    if "libc-musl" in overrides:
-        dynamic_loader = get_musl_loader(d)
-    else:
-        dynamic_loader = get_glibc_loader(d)
-    return dynamic_loader
-
-get_linuxloader[vardepvalue] = "${@get_linuxloader(d)}"
-get_musl_loader[vardepvalue] = "${@get_musl_loader(d)}"
-get_musl_loader_arch[vardepvalue] = "${@get_musl_loader_arch(d)}"
-get_glibc_loader[vardepvalue] = "${@get_glibc_loader(d)}"
diff --git a/meta/classes-recipe/live-vm-common.bbclass b/meta/classes-recipe/live-vm-common.bbclass
deleted file mode 100644
index d90cc67ebc..0000000000
--- a/meta/classes-recipe/live-vm-common.bbclass
+++ /dev/null
@@ -1,100 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-# Some of the vars for vm and live image are conflicted, this function
-# is used for fixing the problem.
-def set_live_vm_vars(d, suffix):
-    vars = ['GRUB_CFG', 'SYSLINUX_CFG', 'ROOT', 'LABELS', 'INITRD']
-    for var in vars:
-        var_with_suffix = var + '_' + suffix
-        if d.getVar(var):
-            bb.warn('Found potential conflicted var %s, please use %s rather than %s' % \
-                (var, var_with_suffix, var))
-        elif d.getVar(var_with_suffix):
-            d.setVar(var, d.getVar(var_with_suffix))
-
-
-EFI = "${@bb.utils.contains("MACHINE_FEATURES", "efi", "1", "0", d)}"
-EFI_PROVIDER ?= "grub-efi"
-EFI_CLASS = "${@bb.utils.contains("MACHINE_FEATURES", "efi", "${EFI_PROVIDER}", "", d)}"
-
-MKDOSFS_EXTRAOPTS ??= "-S 512"
-
-# Include legacy boot if MACHINE_FEATURES includes "pcbios" or if it does not
-# contain "efi". This way legacy is supported by default if neither is
-# specified, maintaining the original behavior.
-def pcbios(d):
-    pcbios = bb.utils.contains("MACHINE_FEATURES", "pcbios", "1", "0", d)
-    if pcbios == "0":
-        pcbios = bb.utils.contains("MACHINE_FEATURES", "efi", "0", "1", d)
-    return pcbios
-
-PCBIOS = "${@pcbios(d)}"
-PCBIOS_CLASS = "${@['','syslinux'][d.getVar('PCBIOS') == '1']}"
-
-# efi_populate_common DEST BOOTLOADER
-efi_populate_common() {
-        # DEST must be the root of the image so that EFIDIR is not
-        # nested under a top level directory.
-        DEST=$1
-
-        install -d ${DEST}${EFIDIR}
-
-        install -m 0644 ${DEPLOY_DIR_IMAGE}/$2-${EFI_BOOT_IMAGE} ${DEST}${EFIDIR}/${EFI_BOOT_IMAGE}
-        EFIPATH=$(echo "${EFIDIR}" | sed 's/\//\\/g')
-        printf 'fs0:%s\%s\n' "$EFIPATH" "${EFI_BOOT_IMAGE}" >${DEST}/startup.nsh
-}
-
-efi_iso_populate() {
-        iso_dir=$1
-        efi_populate $iso_dir
-        # Build a EFI directory to create efi.img
-        mkdir -p ${EFIIMGDIR}/${EFIDIR}
-        cp $iso_dir/${EFIDIR}/* ${EFIIMGDIR}${EFIDIR}
-        cp $iso_dir/${KERNEL_IMAGETYPE} ${EFIIMGDIR}
-
-        EFIPATH=$(echo "${EFIDIR}" | sed 's/\//\\/g')
-        printf 'fs0:%s\%s\n' "$EFIPATH" "${EFI_BOOT_IMAGE}" >${EFIIMGDIR}/startup.nsh
-
-        if [ -f "$iso_dir/initrd" ] ; then
-                cp $iso_dir/initrd ${EFIIMGDIR}
-        fi
-}
-
-efi_hddimg_populate() {
-        efi_populate $1
-}
-
-inherit_defer ${EFI_CLASS}
-inherit_defer ${PCBIOS_CLASS}
-
-populate_kernel() {
-        dest=$1
-        install -d $dest
-
-        # Install bzImage, initrd, and rootfs.img in DEST for all loaders to use.
-        bbnote "Trying to install ${DEPLOY_DIR_IMAGE}/${KERNEL_IMAGETYPE} as $dest/${KERNEL_IMAGETYPE}"
-        if [ -e ${DEPLOY_DIR_IMAGE}/${KERNEL_IMAGETYPE} ]; then
-                install -m 0644 ${DEPLOY_DIR_IMAGE}/${KERNEL_IMAGETYPE} $dest/${KERNEL_IMAGETYPE}
-        else
-                bbwarn "${DEPLOY_DIR_IMAGE}/${KERNEL_IMAGETYPE} doesn't exist"
-        fi
-
-        # initrd is made of concatenation of multiple filesystem images
-        if [ -n "${INITRD}" ]; then
-                rm -f $dest/initrd
-                for fs in ${INITRD}
-                do
-                        if [ -s "$fs" ]; then
-                                cat $fs >> $dest/initrd
-                        else
-                                bbfatal "$fs is invalid. initrd image creation failed."
-                        fi
-                done
-                chmod 0644 $dest/initrd
-        fi
-}
-
diff --git a/meta/classes-recipe/manpages.bbclass b/meta/classes-recipe/manpages.bbclass
deleted file mode 100644
index f3d034b046..0000000000
--- a/meta/classes-recipe/manpages.bbclass
+++ /dev/null
@@ -1,41 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-# Inherit this class to enable or disable building and installation of manpages
-# depending on whether 'api-documentation' is in DISTRO_FEATURES. Such building
-# tends to pull in the entire XML stack and other tools, so it's not enabled
-# by default.
-PACKAGECONFIG:append:class-target = " ${@bb.utils.contains('DISTRO_FEATURES', 'api-documentation', 'manpages', '', d)}"
-
-PACKAGE_WRITE_DEPS += "${@bb.utils.contains('DISTRO_FEATURES', 'api-documentation', 'qemuwrapper-cross', '', d)}"
-
-# usually manual files are packaged to ${PN}-doc except man-pages
-MAN_PKG ?= "${PN}-doc"
-
-# only add man-db to RDEPENDS when manual files are built and installed
-RDEPENDS:${MAN_PKG} += "${@bb.utils.contains('PACKAGECONFIG', 'manpages', 'man-db', '', d)}"
-
-pkg_postinst:${MAN_PKG}:append () {
-        # only update manual page index caches when manual files are built and installed
-        if ${@bb.utils.contains('PACKAGECONFIG', 'manpages', 'true', 'false', d)}; then
-                if test -n "$D"; then
-                        if ${@bb.utils.contains('MACHINE_FEATURES', 'qemu-usermode', 'true', 'false', d)}; then
-                                $INTERCEPT_DIR/postinst_intercept update_mandb ${PKG} mlprefix=${MLPREFIX} binprefix=${MLPREFIX} bindir=${bindir} sysconfdir=${sysconfdir} mandir=${mandir}
-                        else
-                                $INTERCEPT_DIR/postinst_intercept delay_to_first_boot ${PKG} mlprefix=${MLPREFIX}
-                        fi
-                else
-                        mandb -q
-                fi
-        fi
-}
-
-pkg_postrm:${MAN_PKG}:append () {
-        # only update manual page index caches when manual files are built and installed
-        if ${@bb.utils.contains('PACKAGECONFIG', 'manpages', 'true', 'false', d)}; then
-                mandb -q
-        fi
-}
diff --git a/meta/classes-recipe/meson-routines.bbclass b/meta/classes-recipe/meson-routines.bbclass
deleted file mode 100644
index a944a8fff1..0000000000
--- a/meta/classes-recipe/meson-routines.bbclass
+++ /dev/null
@@ -1,59 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-inherit siteinfo
-
-def meson_array(var, d):
-    items = d.getVar(var).split()
-    return repr(items[0] if len(items) == 1 else items)
-
-# Map our ARCH values to what Meson expects:
-# http://mesonbuild.com/Reference-tables.html#cpu-families
-def meson_cpu_family(var, d):
-    import re
-    arch = d.getVar(var)
-    if arch == 'powerpc':
-        return 'ppc'
-    elif arch == 'powerpc64' or arch == 'powerpc64le':
-        return 'ppc64'
-    elif arch == 'armeb':
-        return 'arm'
-    elif arch == 'aarch64_be':
-        return 'aarch64'
-    elif arch == 'loongarch64':
-        return 'loongarch64'
-    elif arch == 'mipsel':
-        return 'mips'
-    elif arch == 'mips64el':
-        return 'mips64'
-    elif re.match(r"i[3-6]86", arch):
-        return "x86"
-    elif arch == "microblazeel":
-        return "microblaze"
-    else:
-        return arch
-
-# Map our OS values to what Meson expects:
-# https://mesonbuild.com/Reference-tables.html#operating-system-names
-def meson_operating_system(var, d):
-    os = d.getVar(var)
-    if "mingw" in os:
-        return "windows"
-    # avoid e.g 'linux-gnueabi'
-    elif "linux" in os:
-        return "linux"
-    else:
-        return os
-
-def meson_endian(prefix, d):
-    arch, os = d.getVar(prefix + "_ARCH"), d.getVar(prefix + "_OS")
-    sitedata = siteinfo_data_for_machine(arch, os, d)
-    if "endian-little" in sitedata:
-        return "little"
-    elif "endian-big" in sitedata:
-        return "big"
-    else:
-        bb.fatal("Cannot determine endianism for %s-%s" % (arch, os))
diff --git a/meta/classes-recipe/meson.bbclass b/meta/classes-recipe/meson.bbclass
deleted file mode 100644
index c8b3e1ec29..0000000000
--- a/meta/classes-recipe/meson.bbclass
+++ /dev/null
@@ -1,203 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-inherit python3native meson-routines qemu
-
-DEPENDS:append = " meson-native ninja-native"
-
-EXEWRAPPER_ENABLED:class-native = "False"
-EXEWRAPPER_ENABLED ?= "${@bb.utils.contains('MACHINE_FEATURES', 'qemu-usermode', 'True', 'False', d)}"
-DEPENDS:append = "${@' qemu-native' if d.getVar('EXEWRAPPER_ENABLED') == 'True' else ''}"
-
-# As Meson enforces out-of-tree builds we can just use cleandirs
-B = "${WORKDIR}/build"
-do_configure[cleandirs] = "${B}"
-
-# Where the meson.build build configuration is
-MESON_SOURCEPATH = "${S}"
-
-# The target to build in do_compile. If unset the default targets are built.
-MESON_TARGET ?= ""
-
-# Since 0.60.0 you can specify custom tags to install
-MESON_INSTALL_TAGS ?= ""
-
-def noprefix(var, d):
-    return d.getVar(var).replace(d.getVar('prefix') + '/', '', 1)
-
-MESON_BUILDTYPE ?= "${@oe.utils.vartrue('DEBUG_BUILD', 'debug', 'plain', d)}"
-MESON_BUILDTYPE[vardeps] += "DEBUG_BUILD"
-MESONOPTS = " --prefix ${prefix} \
-              --buildtype ${MESON_BUILDTYPE} \
-              --bindir ${@noprefix('bindir', d)} \
-              --sbindir ${@noprefix('sbindir', d)} \
-              --datadir ${@noprefix('datadir', d)} \
-              --libdir ${@noprefix('libdir', d)} \
-              --libexecdir ${@noprefix('libexecdir', d)} \
-              --includedir ${@noprefix('includedir', d)} \
-              --mandir ${@noprefix('mandir', d)} \
-              --infodir ${@noprefix('infodir', d)} \
-              --sysconfdir ${sysconfdir} \
-              --localstatedir ${localstatedir} \
-              --sharedstatedir ${sharedstatedir} \
-              --wrap-mode nodownload \
-              --native-file ${WORKDIR}/meson.native"
-
-EXTRA_OEMESON:append = " ${PACKAGECONFIG_CONFARGS}"
-
-MESON_CROSS_FILE = ""
-MESON_CROSS_FILE:class-target = "--cross-file ${WORKDIR}/meson.cross"
-MESON_CROSS_FILE:class-nativesdk = "--cross-file ${WORKDIR}/meson.cross"
-
-# Needed to set up qemu wrapper below
-export STAGING_DIR_HOST
-
-def rust_tool(d, target_var):
-    rustc = d.getVar('RUSTC')
-    if not rustc:
-        return ""
-    cmd = [rustc, "--target", d.getVar(target_var)] + d.getVar("RUSTFLAGS").split()
-    return "rust = %s" % repr(cmd)
-
-def bindgen_args(d):
-    args = '${HOST_CC_ARCH}${TOOLCHAIN_OPTIONS} --target=${TARGET_SYS}'
-    # For SDK packages TOOLCHAIN_OPTIONS don't contain full sysroot path
-    if bb.data.inherits_class("nativesdk", d):
-        args += ' --sysroot=${STAGING_DIR_HOST}${SDKPATHNATIVE}${prefix_nativesdk}'
-    items = d.expand(args).split()
-    return repr(items[0] if len(items) == 1 else items)
-
-addtask write_config before do_configure
-do_write_config[vardeps] += "CC CXX AR NM STRIP READELF OBJCOPY CFLAGS CXXFLAGS LDFLAGS RUSTC RUSTFLAGS EXEWRAPPER_ENABLED"
-do_write_config() {
-    # This needs to be Py to split the args into single-element lists
-    cat >${WORKDIR}/meson.cross <<EOF
-[binaries]
-c = ${@meson_array('CC', d)}
-cpp = ${@meson_array('CXX', d)}
-cython = 'cython3'
-ar = ${@meson_array('AR', d)}
-nm = ${@meson_array('NM', d)}
-strip = ${@meson_array('STRIP', d)}
-readelf = ${@meson_array('READELF', d)}
-objcopy = ${@meson_array('OBJCOPY', d)}
-pkg-config = 'pkg-config'
-llvm-config = 'llvm-config'
-cups-config = 'cups-config'
-g-ir-scanner = '${STAGING_BINDIR}/g-ir-scanner-wrapper'
-g-ir-compiler = '${STAGING_BINDIR}/g-ir-compiler-wrapper'
-${@rust_tool(d, "RUST_HOST_SYS")}
-${@"exe_wrapper = '${WORKDIR}/meson-qemuwrapper'" if d.getVar('EXEWRAPPER_ENABLED') == 'True' else ""}
-
-[built-in options]
-c_args = ${@meson_array('CFLAGS', d)}
-c_link_args = ${@meson_array('LDFLAGS', d)}
-cpp_args = ${@meson_array('CXXFLAGS', d)}
-cpp_link_args = ${@meson_array('LDFLAGS', d)}
-
-[properties]
-needs_exe_wrapper = true
-sys_root = '${STAGING_DIR_HOST}'
-bindgen_clang_arguments = ${@bindgen_args(d)}
-
-[host_machine]
-system = '${@meson_operating_system('HOST_OS', d)}'
-cpu_family = '${@meson_cpu_family('HOST_ARCH', d)}'
-cpu = '${HOST_ARCH}'
-endian = '${@meson_endian('HOST', d)}'
-
-[target_machine]
-system = '${@meson_operating_system('TARGET_OS', d)}'
-cpu_family = '${@meson_cpu_family('TARGET_ARCH', d)}'
-cpu = '${TARGET_ARCH}'
-endian = '${@meson_endian('TARGET', d)}'
-EOF
-
-    cat >${WORKDIR}/meson.native <<EOF
-[binaries]
-c = ${@meson_array('BUILD_CC', d)}
-cpp = ${@meson_array('BUILD_CXX', d)}
-cython = 'cython3'
-ar = ${@meson_array('BUILD_AR', d)}
-nm = ${@meson_array('BUILD_NM', d)}
-strip = ${@meson_array('BUILD_STRIP', d)}
-readelf = ${@meson_array('BUILD_READELF', d)}
-objcopy = ${@meson_array('BUILD_OBJCOPY', d)}
-llvm-config = '${STAGING_BINDIR_NATIVE}/llvm-config'
-pkg-config = 'pkg-config-native'
-${@rust_tool(d, "RUST_BUILD_SYS")}
-
-[built-in options]
-c_args = ${@meson_array('BUILD_CFLAGS', d)}
-c_link_args = ${@meson_array('BUILD_LDFLAGS', d)}
-cpp_args = ${@meson_array('BUILD_CXXFLAGS', d)}
-cpp_link_args = ${@meson_array('BUILD_LDFLAGS', d)}
-EOF
-}
-
-write_qemuwrapper() {
-    # Write out a qemu wrapper that will be used as exe_wrapper so that meson
-    # can run target helper binaries through that.
-    qemu_binary="${@qemu_wrapper_cmdline(d, '$STAGING_DIR_HOST', ['$STAGING_DIR_HOST/${libdir}','$STAGING_DIR_HOST/${base_libdir}'])}"
-    cat > ${WORKDIR}/meson-qemuwrapper << EOF
-#!/bin/sh
-# Use a modules directory which doesn't exist so we don't load random things
-# which may then get deleted (or their dependencies) and potentially segfault
-export GIO_MODULE_DIR=${STAGING_LIBDIR}/gio/modules-dummy
-
-# meson sets this wrongly (only to libs in build-dir), qemu_wrapper_cmdline() and GIR_EXTRA_LIBS_PATH take care of it properly
-unset LD_LIBRARY_PATH
-
-$qemu_binary "\$@"
-EOF
-    chmod +x ${WORKDIR}/meson-qemuwrapper
-}
-
-do_write_config:append:class-target() {
-    write_qemuwrapper
-}
-
-do_write_config:append:class-nativesdk() {
-    write_qemuwrapper
-}
-
-# Tell externalsrc that changes to this file require a reconfigure
-CONFIGURE_FILES = "meson.build"
-
-meson_do_configure() {
-    # Meson requires this to be 'bfd, 'lld' or 'gold' from 0.53 onwards
-    # https://github.com/mesonbuild/meson/commit/ef9aeb188ea2bc7353e59916c18901cde90fa2b3
-    unset LD
-
-    bbnote Executing meson ${EXTRA_OEMESON}...
-    if ! meson setup ${MESONOPTS} "${MESON_SOURCEPATH}" "${B}" ${MESON_CROSS_FILE} ${EXTRA_OEMESON}; then
-        bbfatal_log meson failed
-    fi
-}
-
-python meson_do_qa_configure() {
-    import re
-    warn_re = re.compile(r"^WARNING: Cross property (.+) is using default value (.+)$", re.MULTILINE)
-    with open(d.expand("${B}/meson-logs/meson-log.txt")) as logfile:
-        log = logfile.read()
-    for (prop, value) in warn_re.findall(log):
-        bb.warn("Meson cross property %s used without explicit assignment, defaulting to %s" % (prop, value))
-}
-do_configure[postfuncs] += "meson_do_qa_configure"
-
-do_compile[progress] = "outof:^\[(\d+)/(\d+)\]\s+"
-meson_do_compile() {
-    meson compile -v ${PARALLEL_MAKE} ${MESON_TARGET}
-}
-
-meson_do_install() {
-    if [ "x${MESON_INSTALL_TAGS}" != "x" ] ; then
-        meson_install_tags="--tags ${MESON_INSTALL_TAGS}"
-    fi
-    meson install --destdir ${D} --no-rebuild $meson_install_tags
-}
-
-EXPORT_FUNCTIONS do_configure do_compile do_install
diff --git a/meta/classes-recipe/mime-xdg.bbclass b/meta/classes-recipe/mime-xdg.bbclass
deleted file mode 100644
index cbdcb4c7e9..0000000000
--- a/meta/classes-recipe/mime-xdg.bbclass
+++ /dev/null
@@ -1,78 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-# This class creates mime <-> application associations based on entry 
-# 'MimeType' in *.desktop files
-#
-
-DEPENDS += "desktop-file-utils"
-PACKAGE_WRITE_DEPS += "desktop-file-utils-native"
-DESKTOPDIR = "${datadir}/applications"
-
-# There are recipes out there installing their .desktop files as absolute
-# symlinks. For us these are dangling and cannot be introspected for "MimeType"
-# easily. By addding package-names to MIME_XDG_PACKAGES, packager can force
-# proper update-desktop-database handling. Note that all introspection is
-# skipped for MIME_XDG_PACKAGES not empty
-MIME_XDG_PACKAGES ?= ""
-
-mime_xdg_postinst() {
-if [ "x$D" != "x" ]; then
-        $INTERCEPT_DIR/postinst_intercept update_desktop_database ${PKG} \
-                mlprefix=${MLPREFIX} \
-                desktop_dir=${DESKTOPDIR}
-else
-        update-desktop-database $D${DESKTOPDIR}
-fi
-}
-
-mime_xdg_postrm() {
-if [ "x$D" != "x" ]; then
-        $INTERCEPT_DIR/postinst_intercept update_desktop_database ${PKG} \
-                mlprefix=${MLPREFIX} \
-                desktop_dir=${DESKTOPDIR}
-else
-        update-desktop-database $D${DESKTOPDIR}
-fi
-}
-
-python populate_packages:append () {
-    packages = d.getVar('PACKAGES').split()
-    pkgdest =  d.getVar('PKGDEST')
-    desktop_base = d.getVar('DESKTOPDIR')
-    forced_mime_xdg_pkgs = (d.getVar('MIME_XDG_PACKAGES') or '').split()
-
-    for pkg in packages:
-        desktops_with_mime_found = pkg in forced_mime_xdg_pkgs
-        if d.getVar('MIME_XDG_PACKAGES') == '':
-            desktop_dir = '%s/%s%s' % (pkgdest, pkg, desktop_base)
-            if os.path.exists(desktop_dir):
-                for df in os.listdir(desktop_dir):
-                    if df.endswith('.desktop'):
-                        try:
-                            with open(desktop_dir + '/'+ df, 'r') as f:
-                                for line in f.read().split('\n'):
-                                    if 'MimeType' in line:
-                                        desktops_with_mime_found = True
-                                        break;
-                        except:
-                            bb.warn('Could not open %s. Set MIME_XDG_PACKAGES in recipe or add mime-xdg to INSANE_SKIP.' % desktop_dir + '/'+ df)
-                    if desktops_with_mime_found:
-                        break
-        if desktops_with_mime_found:
-            bb.note("adding mime-xdg postinst and postrm scripts to %s" % pkg)
-            postinst = d.getVar('pkg_postinst:%s' % pkg)
-            if not postinst:
-                postinst = '#!/bin/sh\n'
-            postinst += d.getVar('mime_xdg_postinst')
-            d.setVar('pkg_postinst:%s' % pkg, postinst)
-            postrm = d.getVar('pkg_postrm:%s' % pkg)
-            if not postrm:
-                postrm = '#!/bin/sh\n'
-            postrm += d.getVar('mime_xdg_postrm')
-            d.setVar('pkg_postrm:%s' % pkg, postrm)
-            bb.note("adding desktop-file-utils dependency to %s" % pkg)
-            d.appendVar('RDEPENDS:' + pkg, " " + d.getVar('MLPREFIX')+"desktop-file-utils")
-}
diff --git a/meta/classes-recipe/mime.bbclass b/meta/classes-recipe/mime.bbclass
deleted file mode 100644
index 9b13f62bda..0000000000
--- a/meta/classes-recipe/mime.bbclass
+++ /dev/null
@@ -1,76 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-#
-# This class is used by recipes installing mime types
-#
-
-DEPENDS += "${@bb.utils.contains('BPN', 'shared-mime-info', '', 'shared-mime-info', d)}"
-PACKAGE_WRITE_DEPS += "shared-mime-info-native"
-MIMEDIR = "${datadir}/mime"
-
-mime_postinst() {
-if [ "x$D" != "x" ]; then
-        $INTERCEPT_DIR/postinst_intercept update_mime_database ${PKG} \
-                mlprefix=${MLPREFIX} \
-                mimedir=${MIMEDIR}
-else
-        echo "Updating MIME database... this may take a while."
-        update-mime-database $D${MIMEDIR}
-fi
-}
-
-mime_postrm() {
-if [ "x$D" != "x" ]; then
-        $INTERCEPT_DIR/postinst_intercept update_mime_database ${PKG} \
-                mlprefix=${MLPREFIX} \
-                mimedir=${MIMEDIR}
-else
-        echo "Updating MIME database... this may take a while."
-        # $D${MIMEDIR}/packages belong to package shared-mime-info-data,
-        # packages like libfm-mime depend on shared-mime-info-data.
-        # after shared-mime-info-data uninstalled, $D${MIMEDIR}/packages
-        # is removed, but update-mime-database need this dir to update
-        # database, workaround to create one and remove it later
-        if [ ! -d $D${MIMEDIR}/packages ]; then
-                mkdir -p $D${MIMEDIR}/packages
-                update-mime-database $D${MIMEDIR}
-                rmdir --ignore-fail-on-non-empty $D${MIMEDIR}/packages
-        else
-                update-mime-database $D${MIMEDIR}
-fi
-fi
-}
-
-python populate_packages:append () {
-    packages = d.getVar('PACKAGES').split()
-    pkgdest =  d.getVar('PKGDEST')
-    mimedir = d.getVar('MIMEDIR')
-
-    for pkg in packages:
-        mime_packages_dir = '%s/%s%s/packages' % (pkgdest, pkg, mimedir)
-        mimes_types_found = False
-        if os.path.exists(mime_packages_dir):
-            for f in os.listdir(mime_packages_dir):
-                if f.endswith('.xml'):
-                    mimes_types_found = True
-                    break
-        if mimes_types_found:
-            bb.note("adding mime postinst and postrm scripts to %s" % pkg)
-            postinst = d.getVar('pkg_postinst:%s' % pkg)
-            if not postinst:
-                postinst = '#!/bin/sh\n'
-            postinst += d.getVar('mime_postinst')
-            d.setVar('pkg_postinst:%s' % pkg, postinst)
-            postrm = d.getVar('pkg_postrm:%s' % pkg)
-            if not postrm:
-                postrm = '#!/bin/sh\n'
-            postrm += d.getVar('mime_postrm')
-            d.setVar('pkg_postrm:%s' % pkg, postrm)
-            if pkg != 'shared-mime-info-data':
-                bb.note("adding shared-mime-info-data dependency to %s" % pkg)
-                d.appendVar('RDEPENDS:' + pkg, " " + d.getVar('MLPREFIX')+"shared-mime-info-data")
-}
diff --git a/meta/classes-recipe/module-base.bbclass b/meta/classes-recipe/module-base.bbclass
deleted file mode 100644
index 2a225881ba..0000000000
--- a/meta/classes-recipe/module-base.bbclass
+++ /dev/null
@@ -1,28 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-inherit kernel-arch
-
-# We do the dependency this way because the output is not preserved
-# in sstate, so we must force do_compile to run (once).
-do_configure[depends] += "make-mod-scripts:do_compile"
-
-export OS = "${TARGET_OS}"
-export CROSS_COMPILE = "${TARGET_PREFIX}"
-
-# This points to the build artefacts from the main kernel build
-# such as .config and System.map
-# Confusingly it is not the module build output (which is ${B}) but
-# we didn't pick the name.
-export KBUILD_OUTPUT = "${STAGING_KERNEL_BUILDDIR}"
-
-export KERNEL_VERSION = "${@oe.utils.read_file('${STAGING_KERNEL_BUILDDIR}/kernel-abiversion')}"
-export LOCALVERSION = "${@oe.utils.read_file('${STAGING_KERNEL_BUILDDIR}/kernel-localversion')}"
-KERNEL_OBJECT_SUFFIX = ".ko"
-
-# kernel modules are generally machine specific
-PACKAGE_ARCH = "${MACHINE_ARCH}"
-
diff --git a/meta/classes-recipe/module.bbclass b/meta/classes-recipe/module.bbclass
deleted file mode 100644
index 4948e995c5..0000000000
--- a/meta/classes-recipe/module.bbclass
+++ /dev/null
@@ -1,89 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-inherit module-base kernel-module-split pkgconfig
-
-EXTRA_OEMAKE += "KERNEL_SRC=${STAGING_KERNEL_DIR}"
-
-MODULES_INSTALL_TARGET ?= "modules_install"
-MODULES_MODULE_SYMVERS_LOCATION ?= ""
-
-python __anonymous () {
-    depends = d.getVar('DEPENDS')
-    extra_symbols = []
-    for dep in depends.split():
-        if dep.startswith("kernel-module-"):
-            extra_symbols.append("${STAGING_INCDIR}/" + dep + "/Module.symvers")
-    d.setVar('KBUILD_EXTRA_SYMBOLS', " ".join(extra_symbols))
-}
-
-python do_package:prepend () {
-    os.environ['STRIP'] = d.getVar('KERNEL_STRIP')
-}
-
-python do_devshell:prepend () {
-    os.environ['CFLAGS'] = ''
-    os.environ['CPPFLAGS'] = ''
-    os.environ['CXXFLAGS'] = ''
-    os.environ['LDFLAGS'] = ''
-
-    os.environ['KERNEL_PATH'] = d.getVar('STAGING_KERNEL_DIR')
-    os.environ['KERNEL_SRC'] = d.getVar('STAGING_KERNEL_DIR')
-    os.environ['KERNEL_VERSION'] = d.getVar('KERNEL_VERSION')
-    os.environ['CC'] = d.getVar('KERNEL_CC')
-    os.environ['LD'] = d.getVar('KERNEL_LD')
-    os.environ['AR'] = d.getVar('KERNEL_AR')
-    os.environ['OBJCOPY'] = d.getVar('KERNEL_OBJCOPY')
-    os.environ['STRIP'] = d.getVar('KERNEL_STRIP')
-    os.environ['O'] = d.getVar('STAGING_KERNEL_BUILDDIR')
-    kbuild_extra_symbols = d.getVar('KBUILD_EXTRA_SYMBOLS')
-    if kbuild_extra_symbols:
-        os.environ['KBUILD_EXTRA_SYMBOLS'] = kbuild_extra_symbols
-    else:
-        os.environ['KBUILD_EXTRA_SYMBOLS'] = ''
-}
-
-module_do_compile() {
-        unset CFLAGS CPPFLAGS CXXFLAGS LDFLAGS
-        oe_runmake KERNEL_PATH=${STAGING_KERNEL_DIR}   \
-                   KERNEL_VERSION=${KERNEL_VERSION}    \
-                   CC="${KERNEL_CC}" LD="${KERNEL_LD}" \
-                   AR="${KERNEL_AR}" OBJCOPY="${KERNEL_OBJCOPY}" \
-                   STRIP="${KERNEL_STRIP}" \
-                   O=${STAGING_KERNEL_BUILDDIR} \
-                   KBUILD_EXTRA_SYMBOLS="${KBUILD_EXTRA_SYMBOLS}" \
-                   ${MAKE_TARGETS}
-}
-
-module_do_install() {
-        unset CFLAGS CPPFLAGS CXXFLAGS LDFLAGS
-        oe_runmake DEPMOD=echo MODLIB="${D}${nonarch_base_libdir}/modules/${KERNEL_VERSION}" \
-                   INSTALL_FW_PATH="${D}${nonarch_base_libdir}/firmware" \
-                   CC="${KERNEL_CC}" LD="${KERNEL_LD}" OBJCOPY="${KERNEL_OBJCOPY}" \
-                   STRIP="${KERNEL_STRIP}" \
-                   O=${STAGING_KERNEL_BUILDDIR} \
-                   KBUILD_EXTRA_SYMBOLS="${KBUILD_EXTRA_SYMBOLS}" \
-                   ${MODULES_INSTALL_TARGET}
-
-        if [ ! -e "${B}/${MODULES_MODULE_SYMVERS_LOCATION}/Module.symvers" ] ; then
-                bbwarn "Module.symvers not found in ${B}/${MODULES_MODULE_SYMVERS_LOCATION}"
-                bbwarn "Please consider setting MODULES_MODULE_SYMVERS_LOCATION to a"
-                bbwarn "directory below B to get correct inter-module dependencies"
-        else
-                install -Dm0644 "${B}/${MODULES_MODULE_SYMVERS_LOCATION}"/Module.symvers ${D}${includedir}/${BPN}/Module.symvers
-                # Module.symvers contains absolute path to the build directory.
-                # While it doesn't actually seem to matter which path is specified,
-                # clear them out to avoid confusion
-                sed -e 's:${B}/::g' -i ${D}${includedir}/${BPN}/Module.symvers
-        fi
-}
-
-EXPORT_FUNCTIONS do_compile do_install
-
-# add all splitted modules to PN RDEPENDS, PN can be empty now
-KERNEL_MODULES_META_PACKAGE = "${PN}"
-FILES:${PN} = ""
-ALLOW_EMPTY:${PN} = "1"
diff --git a/meta/classes-recipe/multilib_header.bbclass b/meta/classes-recipe/multilib_header.bbclass
deleted file mode 100644
index 33f7e027f0..0000000000
--- a/meta/classes-recipe/multilib_header.bbclass
+++ /dev/null
@@ -1,58 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-inherit siteinfo
-
-# If applicable on the architecture, this routine will rename the header and
-# add a unique identifier to the name for the ABI/bitsize that is being used.
-# A wrapper will be generated for the architecture that knows how to call
-# all of the ABI variants for that given architecture.
-#
-oe_multilib_header() {
-
-        case ${HOST_OS} in
-        *-musl*)
-                return
-                ;;
-        *)
-        esac
-        # For MIPS: "n32" is a special case, which needs to be
-        # distinct from both 64-bit and 32-bit.
-        case ${TARGET_ARCH} in
-        mips*)  case "${MIPSPKGSFX_ABI}" in
-                "-n32")
-                       ident=n32   
-                       ;;
-                *)     
-                       ident=${SITEINFO_BITS}
-                       ;;
-                esac
-                ;;
-        *)      ident=${SITEINFO_BITS}
-        esac
-        for each_header in "$@" ; do
-           if [ ! -f "${D}/${includedir}/$each_header" ]; then
-              bberror "oe_multilib_header: Unable to find header $each_header."
-              continue
-           fi
-           stem=$(echo $each_header | sed 's#\.h$##')
-           # if mips64/n32 set ident to n32
-           mv ${D}/${includedir}/$each_header ${D}/${includedir}/${stem}-${ident}.h
-
-           sed -e "s#ENTER_HEADER_FILENAME_HERE#${stem}#g" ${COREBASE}/scripts/multilib_header_wrapper.h > ${D}/${includedir}/$each_header
-        done
-}
-
-# Dependencies on arch variables like MIPSPKGSFX_ABI can be problematic.
-# We don't need multilib headers for native builds so brute force things.
-oe_multilib_header:class-native () {
-        return
-}
-
-# Nor do we need multilib headers for nativesdk builds.
-oe_multilib_header:class-nativesdk () {
-        return
-}
diff --git a/meta/classes-recipe/multilib_script.bbclass b/meta/classes-recipe/multilib_script.bbclass
deleted file mode 100644
index a7a08930b7..0000000000
--- a/meta/classes-recipe/multilib_script.bbclass
+++ /dev/null
@@ -1,39 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-#
-# Recipe needs to set MULTILIB_SCRIPTS in the form <pkgname>:<scriptname>, e.g.
-# MULTILIB_SCRIPTS = "${PN}-dev:${bindir}/file1 ${PN}:${base_bindir}/file2"
-# to indicate which script files to process from which packages.
-#
-
-inherit update-alternatives
-
-MULTILIB_SUFFIX = "${@d.getVar('base_libdir',1).split('/')[-1]}"
-
-PACKAGE_PREPROCESS_FUNCS += "multilibscript_rename"
-
-multilibscript_rename() {
-        :
-}
-
-python () {
-    # Do nothing if multilib isn't being used
-    if not d.getVar("MULTILIB_VARIANTS"):
-        return
-    # Do nothing for native/cross
-    if bb.data.inherits_class('native', d) or bb.data.inherits_class('cross', d):
-        return
-
-    for entry in (d.getVar("MULTILIB_SCRIPTS") or "").split():
-        pkg, script = entry.split(":", 1)
-        scriptname = os.path.basename(script)
-        d.appendVar("ALTERNATIVE:" + pkg, " " + scriptname + " ")
-        d.setVarFlag("ALTERNATIVE_LINK_NAME", scriptname, script)
-        d.setVarFlag("ALTERNATIVE_TARGET", scriptname, script + "-${MULTILIB_SUFFIX}")
-        d.appendVar("multilibscript_rename",  "\n       mv ${PKGD}" + script + " ${PKGD}" + script + "-${MULTILIB_SUFFIX}")
-        d.appendVar("FILES:" + pkg, " " + script + "-${MULTILIB_SUFFIX}")
-}
diff --git a/meta/classes-recipe/native.bbclass b/meta/classes-recipe/native.bbclass
deleted file mode 100644
index 7d1fe343fa..0000000000
--- a/meta/classes-recipe/native.bbclass
+++ /dev/null
@@ -1,229 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-# We want native packages to be relocatable
-inherit relocatable
-
-# Native packages are built indirectly via dependency,
-# no need for them to be a direct target of 'world'
-EXCLUDE_FROM_WORLD = "1"
-
-PACKAGE_ARCH = "${BUILD_ARCH}"
-
-# used by cmake class
-OECMAKE_RPATH = "${libdir}"
-OECMAKE_RPATH:class-native = "${libdir}"
-
-TARGET_ARCH = "${BUILD_ARCH}"
-TARGET_OS = "${BUILD_OS}"
-TARGET_VENDOR = "${BUILD_VENDOR}"
-TARGET_PREFIX = "${BUILD_PREFIX}"
-TARGET_CC_ARCH = "${BUILD_CC_ARCH}"
-TARGET_LD_ARCH = "${BUILD_LD_ARCH}"
-TARGET_AS_ARCH = "${BUILD_AS_ARCH}"
-TARGET_CPPFLAGS = "${BUILD_CPPFLAGS}"
-TARGET_CFLAGS = "${BUILD_CFLAGS}"
-TARGET_CXXFLAGS = "${BUILD_CXXFLAGS}"
-TARGET_LDFLAGS = "${BUILD_LDFLAGS}"
-TARGET_FPU = ""
-TUNE_FEATURES = ""
-ABIEXTENSION = ""
-
-HOST_ARCH = "${BUILD_ARCH}"
-HOST_OS = "${BUILD_OS}"
-HOST_VENDOR = "${BUILD_VENDOR}"
-HOST_PREFIX = "${BUILD_PREFIX}"
-HOST_CC_ARCH = "${BUILD_CC_ARCH}"
-HOST_LD_ARCH = "${BUILD_LD_ARCH}"
-HOST_AS_ARCH = "${BUILD_AS_ARCH}"
-
-STAGING_BINDIR = "${STAGING_BINDIR_NATIVE}"
-STAGING_BINDIR_CROSS = "${STAGING_BINDIR_NATIVE}"
-
-# native pkg doesn't need the TOOLCHAIN_OPTIONS.
-TOOLCHAIN_OPTIONS = ""
-
-# Don't build ptest natively
-PTEST_ENABLED = "0"
-
-# Don't use site files for native builds
-export CONFIG_SITE = "${COREBASE}/meta/site/native"
-
-# set the compiler as well. It could have been set to something else
-CC = "${BUILD_CC}"
-CXX = "${BUILD_CXX}"
-FC = "${BUILD_FC}"
-CPP = "${BUILD_CPP}"
-LD = "${BUILD_LD}"
-CCLD = "${BUILD_CCLD}"
-AR = "${BUILD_AR}"
-AS = "${BUILD_AS}"
-RANLIB = "${BUILD_RANLIB}"
-STRIP = "${BUILD_STRIP}"
-NM = "${BUILD_NM}"
-OBJCOPY = "${BUILD_OBJCOPY}"
-OBJDUMP = "${BUILD_OBJDUMP}"
-READELF = "${BUILD_READELF}"
-
-# Path prefixes
-base_prefix = "${STAGING_DIR_NATIVE}"
-prefix = "${STAGING_DIR_NATIVE}${prefix_native}"
-exec_prefix = "${STAGING_DIR_NATIVE}${prefix_native}"
-
-bindir = "${STAGING_BINDIR_NATIVE}"
-sbindir = "${STAGING_SBINDIR_NATIVE}"
-base_libdir = "${STAGING_BASE_LIBDIR_NATIVE}"
-libdir = "${STAGING_LIBDIR_NATIVE}"
-includedir = "${STAGING_INCDIR_NATIVE}"
-sysconfdir = "${STAGING_ETCDIR_NATIVE}"
-datadir = "${STAGING_DATADIR_NATIVE}"
-
-baselib = "lib"
-
-export lt_cv_sys_lib_dlsearch_path_spec = "${libdir} ${base_libdir} /lib /lib64 /usr/lib /usr/lib64"
-
-NATIVE_PACKAGE_PATH_SUFFIX ?= ""
-bindir .= "${NATIVE_PACKAGE_PATH_SUFFIX}"
-sbindir .= "${NATIVE_PACKAGE_PATH_SUFFIX}"
-base_libdir .= "${NATIVE_PACKAGE_PATH_SUFFIX}"
-libdir .= "${NATIVE_PACKAGE_PATH_SUFFIX}"
-libexecdir .= "${NATIVE_PACKAGE_PATH_SUFFIX}"
-
-do_populate_sysroot[sstate-inputdirs] = "${SYSROOT_DESTDIR}/${STAGING_DIR_NATIVE}/"
-do_populate_sysroot[sstate-outputdirs] = "${COMPONENTS_DIR}/${PACKAGE_ARCH}/${PN}"
-
-# Since we actually install these into situ there is no staging prefix
-STAGING_DIR_HOST = ""
-STAGING_DIR_TARGET = ""
-PKG_CONFIG_DIR = "${libdir}/pkgconfig"
-
-EXTRA_NATIVE_PKGCONFIG_PATH ?= ""
-PKG_CONFIG_PATH .= "${EXTRA_NATIVE_PKGCONFIG_PATH}"
-PKG_CONFIG_SYSROOT_DIR = ""
-PKG_CONFIG_SYSTEM_LIBRARY_PATH[unexport] = "1"
-PKG_CONFIG_SYSTEM_INCLUDE_PATH[unexport] = "1"
-
-# we dont want libc-*libc to kick in for native recipes
-LIBCOVERRIDE = ""
-CLASSOVERRIDE = "class-native"
-MACHINEOVERRIDES = ""
-MACHINE_FEATURES = ""
-
-PATH:prepend = "${COREBASE}/scripts/native-intercept:"
-
-# This class encodes staging paths into its scripts data so can only be
-# reused if we manipulate the paths.
-SSTATE_SCAN_CMD ?= "${SSTATE_SCAN_CMD_NATIVE}"
-
-# No strip sysroot when DEBUG_BUILD is enabled
-INHIBIT_SYSROOT_STRIP ?= "${@oe.utils.vartrue('DEBUG_BUILD', '1', '', d)}"
-
-python native_virtclass_handler () {
-    import re
-    pn = e.data.getVar("PN")
-    if not pn.endswith("-native"):
-        return
-    bpn = e.data.getVar("BPN")
-
-    # Set features here to prevent appends and distro features backfill
-    # from modifying native distro features
-    features = set(d.getVar("DISTRO_FEATURES_NATIVE").split())
-    filtered = set(bb.utils.filter("DISTRO_FEATURES", d.getVar("DISTRO_FEATURES_FILTER_NATIVE"), d).split())
-    d.setVar("DISTRO_FEATURES", " ".join(sorted(features | filtered)))
-
-    classextend = e.data.getVar('BBCLASSEXTEND') or ""
-    if "native" not in classextend:
-        return
-
-    def map_dependencies(varname, d, suffix, selfref=True, regex=False):
-        varname = varname + ":" + suffix
-        # Handle ${PN}-xxx -> ${BPN}-xxx-native
-        if suffix != "${PN}" and "${PN}" in suffix:
-            output_varname = varname.replace("${PN}", "${BPN}") + "-native"
-            d.renameVar(varname, output_varname)
-
-    d.setVarFilter("DEPENDS", "native_filter(val, '" + pn + "', '" + bpn + "', selfref=False)")
-
-    for varname in ["RDEPENDS", "RRECOMMENDS", "RSUGGESTS", "RPROVIDES", "RREPLACES"]:
-        d.setVarFilter(varname, "native_filter(val, '" + pn + "', '" + bpn + "')")
-
-    # We need to handle things like ${@bb.utils.contains('PTEST_ENABLED', '1', '${PN}-ptest', '', d)}
-    # and not pass ${PN}-test since in the native case it would be ignored. This does mean we ignore
-    # anonymous python derived PACKAGES entries.
-    for pkg in re.split(r"\${@(?:{.*?}|.)+?}|\s", d.getVar("PACKAGES", False)):
-        if not pkg:
-            continue
-        map_dependencies("RDEPENDS", e.data, pkg)
-        map_dependencies("RRECOMMENDS", e.data, pkg)
-        map_dependencies("RSUGGESTS", e.data, pkg)
-        map_dependencies("RPROVIDES", e.data, pkg)
-        map_dependencies("RREPLACES", e.data, pkg)
-
-    d.setVarFilter("PACKAGES", "native_filter(val, '" + pn + "', '" + bpn + "')")
-    d.setVarFilter("PACKAGES_DYNAMIC", "native_filter(val, '" + pn + "', '" + bpn + "', regex=True)")
-
-    provides = e.data.getVar("PROVIDES")
-    nprovides = []
-    for prov in provides.split():
-        if prov.find(pn) != -1:
-            nprovides.append(prov)
-        elif not prov.endswith("-native"):
-            nprovides.append(prov + "-native")
-        else:
-            nprovides.append(prov)
-    e.data.setVar("PROVIDES", ' '.join(nprovides))
-
-
-}
-
-addhandler native_virtclass_handler
-native_virtclass_handler[eventmask] = "bb.event.RecipePreFinalise"
-
-python do_addto_recipe_sysroot () {
-    bb.build.exec_func("extend_recipe_sysroot", d)
-}
-addtask addto_recipe_sysroot after do_populate_sysroot
-do_addto_recipe_sysroot[deptask] = "do_populate_sysroot"
-
-inherit nopackages
-
-do_packagedata[stamp-extra-info] = ""
-
-USE_NLS = "no"
-
-RECIPERDEPTASK = "do_populate_sysroot"
-do_populate_sysroot[rdeptask] = "${RECIPERDEPTASK}"
-
-#
-# Native task outputs are directly run on the target (host) system after being
-# built. Even if the output of this recipe doesn't change, a change in one of
-# its dependencies may cause a change in the output it generates (e.g. rpm
-# output depends on the output of its dependent zstd library).
-#
-# This can cause poor interactions with hash equivalence, since this recipes
-# output-changing dependency is "hidden" and downstream task only see that this
-# recipe has the same outhash and therefore is equivalent. This can result in
-# different output in different cases.
-#
-# To resolve this, unhide the output-changing dependency by adding its unihash
-# to this tasks outhash calculation. Unfortunately, don't know specifically
-# know which dependencies are output-changing, so we have to add all of them.
-#
-python native_add_do_populate_sysroot_deps () {
-    current_task = "do_" + d.getVar("BB_CURRENTTASK")
-    if current_task != "do_populate_sysroot":
-        return
-
-    taskdepdata = d.getVar("BB_TASKDEPDATA", False)
-    pn = d.getVar("PN")
-    deps = {
-        dep[0]:dep[6] for dep in taskdepdata.values() if
-            dep[1] == current_task and dep[0] != pn
-    }
-
-    d.setVar("HASHEQUIV_EXTRA_SIGDATA", "\n".join("%s: %s" % (k, deps[k]) for k in sorted(deps.keys())))
-}
-SSTATECREATEFUNCS += "native_add_do_populate_sysroot_deps"
diff --git a/meta/classes-recipe/nativesdk.bbclass b/meta/classes-recipe/nativesdk.bbclass
deleted file mode 100644
index 9838d5a54b..0000000000
--- a/meta/classes-recipe/nativesdk.bbclass
+++ /dev/null
@@ -1,123 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-# SDK packages are built either explicitly by the user,
-# or indirectly via dependency.  No need to be in 'world'.
-EXCLUDE_FROM_WORLD = "1"
-
-STAGING_BINDIR_TOOLCHAIN = "${STAGING_DIR_NATIVE}${bindir_native}/${SDK_ARCH}${SDK_VENDOR}-${SDK_OS}"
-
-# libc for the SDK can be different to that of the target
-NATIVESDKLIBC ?= "libc-glibc"
-LIBCOVERRIDE = ":${NATIVESDKLIBC}"
-CLASSOVERRIDE = "class-nativesdk"
-MACHINEOVERRIDES = ""
-
-MACHINE_FEATURES = "${SDK_MACHINE_FEATURES}"
-DISTRO_FEATURES_BACKFILL = ""
-MACHINE_FEATURES_BACKFILL = ""
-
-MULTILIBS = ""
-
-# we need consistent staging dir whether or not multilib is enabled
-STAGING_DIR_HOST = "${WORKDIR}/recipe-sysroot"
-STAGING_DIR_TARGET = "${WORKDIR}/recipe-sysroot"
-RECIPE_SYSROOT = "${WORKDIR}/recipe-sysroot"
-
-#
-# Update PACKAGE_ARCH and PACKAGE_ARCHS
-#
-PACKAGE_ARCH = "${SDK_ARCH}-${SDKPKGSUFFIX}"
-PACKAGE_ARCHS = "${SDK_PACKAGE_ARCHS}"
-TUNE_PKGARCH = "${SDK_ARCH}"
-
-#
-# We need chrpath >= 0.14 to ensure we can deal with 32 and 64 bit
-# binaries
-#
-DEPENDS:append = " chrpath-replacement-native"
-EXTRANATIVEPATH += "chrpath-native"
-
-PKGDATA_DIR = "${PKGDATA_DIR_SDK}"
-
-HOST_ARCH = "${SDK_ARCH}"
-HOST_VENDOR = "${SDK_VENDOR}"
-HOST_OS = "${SDK_OS}"
-HOST_PREFIX = "${SDK_PREFIX}"
-HOST_CC_ARCH = "${SDK_CC_ARCH}"
-HOST_LD_ARCH = "${SDK_LD_ARCH}"
-HOST_AS_ARCH = "${SDK_AS_ARCH}"
-#HOST_SYS = "${HOST_ARCH}${TARGET_VENDOR}-${HOST_OS}"
-
-TARGET_ARCH = "${SDK_ARCH}"
-TARGET_VENDOR = "${SDK_VENDOR}"
-TARGET_OS = "${SDK_OS}"
-TARGET_PREFIX = "${SDK_PREFIX}"
-TARGET_CC_ARCH = "${SDK_CC_ARCH}"
-TARGET_LD_ARCH = "${SDK_LD_ARCH}"
-TARGET_AS_ARCH = "${SDK_AS_ARCH}"
-TARGET_CPPFLAGS = "${BUILDSDK_CPPFLAGS}"
-TARGET_CFLAGS = "${BUILDSDK_CFLAGS}"
-TARGET_CXXFLAGS = "${BUILDSDK_CXXFLAGS}"
-TARGET_LDFLAGS = "${BUILDSDK_LDFLAGS}"
-TARGET_FPU = ""
-EXTRA_OECONF_GCC_FLOAT = ""
-TUNE_FEATURES = ""
-
-# Change to place files in SDKPATH
-base_prefix = "${SDKPATHNATIVE}"
-prefix = "${SDKPATHNATIVE}${prefix_nativesdk}"
-exec_prefix = "${SDKPATHNATIVE}${prefix_nativesdk}"
-baselib = "lib"
-sbindir = "${bindir}"
-
-export PKG_CONFIG_DIR = "${STAGING_DIR_HOST}${libdir}/pkgconfig"
-export PKG_CONFIG_SYSROOT_DIR = "${STAGING_DIR_HOST}"
-
-python nativesdk_virtclass_handler () {
-    pn = e.data.getVar("PN")
-    if not (pn.endswith("-nativesdk") or pn.startswith("nativesdk-")):
-        return
-
-    # Set features here to prevent appends and distro features backfill
-    # from modifying nativesdk distro features
-    features = set(d.getVar("DISTRO_FEATURES_NATIVESDK").split())
-    filtered = set(bb.utils.filter("DISTRO_FEATURES", d.getVar("DISTRO_FEATURES_FILTER_NATIVESDK"), d).split())
-    d.setVar("DISTRO_FEATURES", " ".join(sorted(features | filtered)))
-
-    e.data.setVar("MLPREFIX", "nativesdk-")
-    e.data.setVar("PN", "nativesdk-" + e.data.getVar("PN").replace("-nativesdk", "").replace("nativesdk-", ""))
-}
-
-python () {
-    pn = d.getVar("PN")
-    if not pn.startswith("nativesdk-"):
-        return
-
-    import oe.classextend
-
-    clsextend = oe.classextend.ClassExtender("nativesdk", [], d)
-    clsextend.rename_package_variables((d.getVar("PACKAGEVARS") or "").split())
-
-    clsextend.set_filter("DEPENDS", deps=True)
-    clsextend.set_filter("PACKAGE_WRITE_DEPS", deps=False)
-    clsextend.map_packagevars()
-    clsextend.set_filter("PROVIDES", deps=False)
-
-    d.setVar("LIBCEXTENSION", "")
-    d.setVar("ABIEXTENSION", "")
-}
-
-addhandler nativesdk_virtclass_handler
-nativesdk_virtclass_handler[eventmask] = "bb.event.RecipePreFinalise"
-
-do_packagedata[stamp-extra-info] = ""
-
-USE_NLS = "${SDKUSE_NLS}"
-
-OLDEST_KERNEL = "${SDK_OLDEST_KERNEL}"
-
-PATH:prepend = "${COREBASE}/scripts/nativesdk-intercept:"
diff --git a/meta/classes-recipe/nopackages.bbclass b/meta/classes-recipe/nopackages.bbclass
deleted file mode 100644
index 9ea7273530..0000000000
--- a/meta/classes-recipe/nopackages.bbclass
+++ /dev/null
@@ -1,19 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-deltask do_package
-deltask do_package_write_rpm
-deltask do_package_write_ipk
-deltask do_package_write_deb
-deltask do_package_write_tar
-deltask do_package_qa
-deltask do_packagedata
-deltask do_package_setscene
-deltask do_package_write_rpm_setscene
-deltask do_package_write_ipk_setscene
-deltask do_package_write_deb_setscene
-deltask do_package_qa_setscene
-deltask do_packagedata_setscene
diff --git a/meta/classes-recipe/nospdx.bbclass b/meta/classes-recipe/nospdx.bbclass
deleted file mode 100644
index b20e28218b..0000000000
--- a/meta/classes-recipe/nospdx.bbclass
+++ /dev/null
@@ -1,13 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-deltask do_collect_spdx_deps
-deltask do_create_spdx
-deltask do_create_spdx_runtime
-deltask do_create_package_spdx
-deltask do_create_rootfs_spdx
-deltask do_create_image_spdx
-deltask do_create_image_sbom
diff --git a/meta/classes-recipe/npm.bbclass b/meta/classes-recipe/npm.bbclass
deleted file mode 100644
index 344e8b4bec..0000000000
--- a/meta/classes-recipe/npm.bbclass
+++ /dev/null
@@ -1,357 +0,0 @@
-# Copyright (C) 2020 Savoir-Faire Linux
-#
-# SPDX-License-Identifier: GPL-2.0-only
-#
-# This bbclass builds and installs an npm package to the target. The package
-# sources files should be fetched in the calling recipe by using the SRC_URI
-# variable. The ${S} variable should be updated depending of your fetcher.
-#
-# Usage:
-#  SRC_URI = "..."
-#  inherit npm
-#
-# Optional variables:
-#  NPM_ARCH:
-#       Override the auto generated npm architecture.
-#
-#  NPM_INSTALL_DEV:
-#       Set to 1 to also install devDependencies.
-
-inherit python3native
-
-DEPENDS:prepend = "nodejs-native nodejs-oe-cache-native "
-RDEPENDS:${PN}:append:class-target = " nodejs"
-
-EXTRA_OENPM = ""
-
-NPM_INSTALL_DEV ?= "0"
-
-NPM_NODEDIR ?= "${RECIPE_SYSROOT_NATIVE}${prefix_native}"
-
-## must match mapping in nodejs.bb (openembedded-meta)
-def map_nodejs_arch(a, d):
-    import re
-
-    if   re.match('i.86$', a): return 'ia32'
-    elif re.match('x86_64$', a): return 'x64'
-    elif re.match('aarch64$', a): return 'arm64'
-    elif re.match('(powerpc64|powerpc64le|ppc64le)$', a): return 'ppc64'
-    elif re.match('powerpc$', a): return 'ppc'
-    return a
-
-NPM_ARCH ?= "${@map_nodejs_arch(d.getVar("TARGET_ARCH"), d)}"
-
-NPM_PACKAGE = "${WORKDIR}/npm-package"
-NPM_CACHE = "${WORKDIR}/npm-cache"
-NPM_BUILD = "${WORKDIR}/npm-build"
-NPM_REGISTRY = "${WORKDIR}/npm-registry"
-
-def npm_global_configs(d):
-    """Get the npm global configuration"""
-    configs = []
-    # Ensure no network access is done
-    configs.append(("offline", "true"))
-    configs.append(("proxy", "http://invalid"))
-    configs.append(("fund", False))
-    configs.append(("audit", False))
-    # Configure the cache directory
-    configs.append(("cache", d.getVar("NPM_CACHE")))
-    return configs
-
-## 'npm pack' runs 'prepare' and 'prepack' scripts. Support for
-## 'ignore-scripts' which prevents this behavior has been removed
-## from nodejs 16.  Use simple 'tar' instead of.
-def npm_pack(env, srcdir, workdir):
-    """Emulate 'npm pack' on a specified directory"""
-    import subprocess
-    import os
-    import json
-
-    src = os.path.join(srcdir, 'package.json')
-    with open(src) as f:
-        j = json.load(f)
-
-    # base does not really matter and is for documentation purposes
-    # only. But the 'version' part must exist because other parts of
-    # the bbclass rely on it.
-    if 'version' not in j:
-        j['version'] = '0.0.0-unknown'
-    base = j['name'].split('/')[-1]
-    tarball = os.path.join(workdir, "%s-%s.tgz" % (base, j['version']));
-
-    # TODO: real 'npm pack' does not include directories while 'tar'
-    # does.  But this does not seem to matter...
-    subprocess.run(['tar', 'czf', tarball,
-                    '--exclude', './node-modules',
-                    '--exclude-vcs',
-                    '--transform', r's,^\./,package/,',
-                    '--mtime', '1985-10-26T08:15:00.000Z',
-                    '.'],
-                   check = True, cwd = srcdir)
-
-    return (tarball, j)
-
-python npm_do_configure() {
-    """
-    Step one: configure the npm cache and the main npm package
-
-    Every dependencies have been fetched and patched in the source directory.
-    They have to be packed (this remove unneeded files) and added to the npm
-    cache to be available for the next step.
-
-    The main package and its associated manifest file and shrinkwrap file have
-    to be configured to take into account these cached dependencies.
-    """
-    import base64
-    import copy
-    import json
-    import re
-    import shlex
-    import stat
-    import tempfile
-    from bb.fetch2.npm import NpmEnvironment
-    from bb.fetch2.npm import npm_unpack
-    from bb.fetch2.npm import npm_package
-    from bb.fetch2.npmsw import foreach_dependencies
-    from bb.progress import OutOfProgressHandler
-    from oe.npm_registry import NpmRegistry
-
-    bb.utils.remove(d.getVar("NPM_CACHE"), recurse=True)
-    bb.utils.remove(d.getVar("NPM_PACKAGE"), recurse=True)
-
-    env = NpmEnvironment(d, configs=npm_global_configs(d))
-    registry = NpmRegistry(d.getVar('NPM_REGISTRY'), d.getVar('NPM_CACHE'))
-
-    def _npm_cache_add(tarball, pkg):
-        """Add tarball to local registry and register it in the
-           cache"""
-        registry.add_pkg(tarball, pkg)
-
-    def _npm_integrity(tarball):
-        """Return the npm integrity of a specified tarball"""
-        sha512 = bb.utils.sha512_file(tarball)
-        return "sha512-" + base64.b64encode(bytes.fromhex(sha512)).decode()
-
-    # Manage the manifest file and shrinkwrap files
-    orig_manifest_file = d.expand("${S}/package.json")
-    orig_shrinkwrap_file = d.expand("${S}/npm-shrinkwrap.json")
-    cached_manifest_file = d.expand("${NPM_PACKAGE}/package.json")
-    cached_shrinkwrap_file = d.expand("${NPM_PACKAGE}/npm-shrinkwrap.json")
-
-    with open(orig_manifest_file, "r") as f:
-        orig_manifest = json.load(f)
-
-    cached_manifest = copy.deepcopy(orig_manifest)
-    cached_manifest.pop("dependencies", None)
-    cached_manifest.pop("devDependencies", None)
-
-    has_shrinkwrap_file = True
-
-    try:
-        with open(orig_shrinkwrap_file, "r") as f:
-            orig_shrinkwrap = json.load(f)
-    except IOError:
-        has_shrinkwrap_file = False
-
-    if has_shrinkwrap_file:
-       if int(orig_shrinkwrap.get("lockfileVersion", 0)) < 2:
-           bb.fatal("%s: lockfileVersion version 2 or later is required" % orig_shrinkwrap_file)
-
-       cached_shrinkwrap = copy.deepcopy(orig_shrinkwrap)
-       for package in orig_shrinkwrap["packages"]:
-            if package != "":
-                cached_shrinkwrap["packages"].pop(package, None)
-       cached_shrinkwrap["packages"][""].pop("dependencies", None)
-       cached_shrinkwrap["packages"][""].pop("devDependencies", None)
-       cached_shrinkwrap["packages"][""].pop("peerDependencies", None)
-
-    # Manage the dependencies
-    progress = OutOfProgressHandler(d, r"^(\d+)/(\d+)$")
-    progress_total = 1 # also count the main package
-    progress_done = 0
-
-    def _count_dependency(name, params, destsuffix):
-        nonlocal progress_total
-        progress_total += 1
-
-    def _cache_dependency(name, params, destsuffix):
-        with tempfile.TemporaryDirectory() as tmpdir:
-            # Add the dependency to the npm cache
-            destdir = os.path.join(d.getVar("S"), destsuffix)
-            (tarball, pkg) = npm_pack(env, destdir, tmpdir)
-            _npm_cache_add(tarball, pkg)
-            # Add its signature to the cached shrinkwrap
-            dep = params
-            dep["version"] = pkg['version']
-            dep["integrity"] = _npm_integrity(tarball)
-            if params.get("dev", False):
-                dep["dev"] = True
-                if "devDependencies" not in cached_shrinkwrap["packages"][""]:
-                    cached_shrinkwrap["packages"][""]["devDependencies"] = {}
-                cached_shrinkwrap["packages"][""]["devDependencies"][name] = pkg['version']
-
-            else:
-                if "dependencies" not in cached_shrinkwrap["packages"][""]:
-                    cached_shrinkwrap["packages"][""]["dependencies"] = {}
-                cached_shrinkwrap["packages"][""]["dependencies"][name] = pkg['version']
-
-            cached_shrinkwrap["packages"][destsuffix] = dep
-            # Display progress
-            nonlocal progress_done
-            progress_done += 1
-            progress.write("%d/%d" % (progress_done, progress_total))
-
-    dev = bb.utils.to_boolean(d.getVar("NPM_INSTALL_DEV"), False)
-
-    if has_shrinkwrap_file:
-        foreach_dependencies(orig_shrinkwrap, _count_dependency, dev)
-        foreach_dependencies(orig_shrinkwrap, _cache_dependency, dev)
-    
-    # Manage Peer Dependencies
-    if has_shrinkwrap_file:
-        packages = orig_shrinkwrap.get("packages", {})
-        peer_deps = packages.get("", {}).get("peerDependencies", {})
-        package_runtime_dependencies = d.getVar("RDEPENDS:%s" % d.getVar("PN"))
-        
-        for peer_dep in peer_deps:
-            peer_dep_yocto_name = npm_package(peer_dep)
-            if peer_dep_yocto_name not in package_runtime_dependencies:
-                bb.warn(peer_dep + " is a peer dependencie that is not in RDEPENDS variable. " + 
-                "Please add this peer dependencie to the RDEPENDS variable as %s and generate its recipe with devtool"
-                % peer_dep_yocto_name)
-
-    # Configure the main package
-    with tempfile.TemporaryDirectory() as tmpdir:
-        (tarball, _) = npm_pack(env, d.getVar("S"), tmpdir)
-        npm_unpack(tarball, d.getVar("NPM_PACKAGE"), d)
-
-    # Configure the cached manifest file and cached shrinkwrap file
-    def _update_manifest(depkey):
-        for name in orig_manifest.get(depkey, {}):
-            version = cached_shrinkwrap["packages"][""][depkey][name]
-            if depkey not in cached_manifest:
-                cached_manifest[depkey] = {}
-            cached_manifest[depkey][name] = version
-
-    if has_shrinkwrap_file:
-        _update_manifest("dependencies")
-
-    if dev:
-        if has_shrinkwrap_file:
-            _update_manifest("devDependencies")
-
-    os.chmod(cached_manifest_file, os.stat(cached_manifest_file).st_mode | stat.S_IWUSR)
-    with open(cached_manifest_file, "w") as f:
-        json.dump(cached_manifest, f, indent=2)
-
-    if has_shrinkwrap_file:
-        with open(cached_shrinkwrap_file, "w") as f:
-            json.dump(cached_shrinkwrap, f, indent=2)
-}
-
-python npm_do_compile() {
-    """
-    Step two: install the npm package
-
-    Use the configured main package and the cached dependencies to run the
-    installation process. The installation is done in a directory which is
-    not the destination directory yet.
-
-    A combination of 'npm pack' and 'npm install' is used to ensure that the
-    installed files are actual copies instead of symbolic links (which is the
-    default npm behavior).
-    """
-    import shlex
-    import tempfile
-    from bb.fetch2.npm import NpmEnvironment
-
-    bb.utils.remove(d.getVar("NPM_BUILD"), recurse=True)
-
-    with tempfile.TemporaryDirectory() as tmpdir:
-        args = []
-        configs = npm_global_configs(d)
-
-        if bb.utils.to_boolean(d.getVar("NPM_INSTALL_DEV"), False):
-            configs.append(("also", "development"))
-        else:
-            configs.append(("only", "production"))
-
-        # Report as many logs as possible for debugging purpose
-        configs.append(("loglevel", "silly"))
-
-        # Configure the installation to be done globally in the build directory
-        configs.append(("global", "true"))
-        configs.append(("prefix", d.getVar("NPM_BUILD")))
-
-        # Add node-gyp configuration
-        configs.append(("arch", d.getVar("NPM_ARCH")))
-        configs.append(("release", "true"))
-        configs.append(("nodedir", d.getVar("NPM_NODEDIR")))
-        configs.append(("python", d.getVar("PYTHON")))
-
-        env = NpmEnvironment(d, configs)
-
-        # Add node-pre-gyp configuration
-        args.append(("target_arch", d.getVar("NPM_ARCH")))
-        args.append(("build-from-source", "true"))
-
-        # Don't install peer dependencies as they should be in RDEPENDS variable
-        args.append(("legacy-peer-deps", "true"))
-
-        # Pack and install the main package
-        (tarball, _) = npm_pack(env, d.getVar("NPM_PACKAGE"), tmpdir)
-        cmd = "npm install %s %s" % (shlex.quote(tarball), d.getVar("EXTRA_OENPM"))
-        env.run(cmd, args=args)
-}
-
-npm_do_install() {
-    # Step three: final install
-    #
-    # The previous installation have to be filtered to remove some extra files.
-
-    rm -rf ${D}
-
-    # Copy the entire lib and bin directories
-    install -d ${D}/${nonarch_libdir}
-    cp --no-preserve=ownership --recursive ${NPM_BUILD}/lib/. ${D}/${nonarch_libdir}
-
-    if [ -d "${NPM_BUILD}/bin" ]
-    then
-        install -d ${D}/${bindir}
-        cp --no-preserve=ownership --recursive ${NPM_BUILD}/bin/. ${D}/${bindir}
-    fi
-
-    # If the package (or its dependencies) uses node-gyp to build native addons,
-    # object files, static libraries or other temporary files can be hidden in
-    # the lib directory. To reduce the package size and to avoid QA issues
-    # (staticdev with static library files) these files must be removed.
-    local GYP_REGEX=".*/build/Release/[^/]*.node"
-
-    # Remove any node-gyp directory in ${D} to remove temporary build files
-    for GYP_D_FILE in $(find ${D} -regex "${GYP_REGEX}")
-    do
-        local GYP_D_DIR=${GYP_D_FILE%/Release/*}
-
-        rm --recursive --force ${GYP_D_DIR}
-    done
-
-    # Copy only the node-gyp release files
-    for GYP_B_FILE in $(find ${NPM_BUILD} -regex "${GYP_REGEX}")
-    do
-        local GYP_D_FILE=${D}/${prefix}/${GYP_B_FILE#${NPM_BUILD}}
-
-        install -d ${GYP_D_FILE%/*}
-        install -m 755 ${GYP_B_FILE} ${GYP_D_FILE}
-    done
-
-    # Remove the shrinkwrap file which does not need to be packed
-    rm -f ${D}/${nonarch_libdir}/node_modules/*/npm-shrinkwrap.json
-    rm -f ${D}/${nonarch_libdir}/node_modules/@*/*/npm-shrinkwrap.json
-}
-
-FILES:${PN} += " \
-    ${bindir} \
-    ${nonarch_libdir} \
-"
-
-EXPORT_FUNCTIONS do_configure do_compile do_install
diff --git a/meta/classes-recipe/overlayfs-etc.bbclass b/meta/classes-recipe/overlayfs-etc.bbclass
deleted file mode 100644
index d339fbbeee..0000000000
--- a/meta/classes-recipe/overlayfs-etc.bbclass
+++ /dev/null
@@ -1,88 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-# Class for setting up /etc in overlayfs
-#
-# In order to have /etc directory in overlayfs a special handling at early boot stage is required
-# The idea is to supply a custom init script that mounts /etc before launching actual init program,
-# because the latter already requires /etc to be mounted
-#
-# The configuration must be machine specific. You should at least set these three variables:
-#   OVERLAYFS_ETC_MOUNT_POINT ?= "/data"
-#   OVERLAYFS_ETC_FSTYPE ?= "ext4"
-#   OVERLAYFS_ETC_DEVICE ?= "/dev/mmcblk0p2"
-#
-# To control more mount options you should consider setting mount options:
-#   OVERLAYFS_ETC_MOUNT_OPTIONS ?= "defaults"
-#
-# The class provides two options for /sbin/init generation
-# 1. Default option is to rename original /sbin/init to /sbin/init.orig and place generated init under
-#    original name, i.e. /sbin/init. It has an advantage that you won't need to change any kernel
-#    parameters in order to make it work, but it poses a restriction that package-management can't
-#    be used, becaause updating init manager would remove generated script
-# 2. If you are would like to keep original init as is, you can set
-#    OVERLAYFS_ETC_USE_ORIG_INIT_NAME = "0"
-#    Then generated init will be named /sbin/preinit and you would need to extend you kernel parameters
-#    manually in your bootloader configuration.
-#
-# Regardless which mode you choose, update and migration strategy of configuration files under /etc
-# overlay is out of scope of this class
-
-ROOTFS_POSTPROCESS_COMMAND += '${@bb.utils.contains("IMAGE_FEATURES", "overlayfs-etc", "create_overlayfs_etc_preinit", "", d)}'
-IMAGE_FEATURES_CONFLICTS_overlayfs-etc = "${@ 'package-management' if bb.utils.to_boolean(d.getVar('OVERLAYFS_ETC_USE_ORIG_INIT_NAME'), True) else ''}"
-
-OVERLAYFS_ETC_MOUNT_POINT ??= ""
-OVERLAYFS_ETC_FSTYPE ??= ""
-OVERLAYFS_ETC_DEVICE ??= ""
-OVERLAYFS_ETC_USE_ORIG_INIT_NAME ??= "1"
-OVERLAYFS_ETC_MOUNT_OPTIONS ??= "defaults"
-OVERLAYFS_ETC_INIT_TEMPLATE ??= "${COREBASE}/meta/files/overlayfs-etc-preinit.sh.in"
-OVERLAYFS_ETC_EXPOSE_LOWER ??= "0"
-OVERLAYFS_ETC_CREATE_MOUNT_DIRS ??= "1"
-
-python create_overlayfs_etc_preinit() {
-    overlayEtcMountPoint = d.getVar("OVERLAYFS_ETC_MOUNT_POINT")
-    overlayEtcFsType = d.getVar("OVERLAYFS_ETC_FSTYPE")
-    overlayEtcDevice = d.getVar("OVERLAYFS_ETC_DEVICE")
-
-    if not overlayEtcMountPoint:
-        bb.fatal("OVERLAYFS_ETC_MOUNT_POINT must be set in your MACHINE configuration")
-    if not overlayEtcDevice:
-        bb.fatal("OVERLAYFS_ETC_DEVICE must be set in your MACHINE configuration")
-    if not overlayEtcFsType:
-        bb.fatal("OVERLAYFS_ETC_FSTYPE should contain a valid file system type on {0}".format(overlayEtcDevice))
-
-    with open(d.getVar("OVERLAYFS_ETC_INIT_TEMPLATE"), "r") as f:
-        PreinitTemplate = f.read()
-
-    useOrigInit = oe.types.boolean(d.getVar('OVERLAYFS_ETC_USE_ORIG_INIT_NAME'))
-    preinitPath = oe.path.join(d.getVar("IMAGE_ROOTFS"), d.getVar("base_sbindir"), "preinit")
-    initBaseName = oe.path.join(d.getVar("base_sbindir"), "init")
-    origInitNameSuffix = ".orig"
-    exposeLower = oe.types.boolean(d.getVar('OVERLAYFS_ETC_EXPOSE_LOWER'))
-    createMoundDirs = oe.types.boolean(d.getVar('OVERLAYFS_ETC_CREATE_MOUNT_DIRS'))
-
-    args = {
-        'OVERLAYFS_ETC_MOUNT_POINT': overlayEtcMountPoint,
-        'OVERLAYFS_ETC_MOUNT_OPTIONS': d.getVar('OVERLAYFS_ETC_MOUNT_OPTIONS'),
-        'OVERLAYFS_ETC_FSTYPE': overlayEtcFsType,
-        'OVERLAYFS_ETC_DEVICE': overlayEtcDevice,
-        'SBIN_INIT_NAME': initBaseName + origInitNameSuffix if useOrigInit else initBaseName,
-        'OVERLAYFS_ETC_EXPOSE_LOWER': "true" if exposeLower else "false",
-        'CREATE_MOUNT_DIRS': "true" if createMoundDirs else "false"
-    }
-
-    if useOrigInit:
-        # rename original /sbin/init
-        origInit = oe.path.join(d.getVar("IMAGE_ROOTFS"), initBaseName)
-        bb.debug(1, "rootfs path %s, init path %s, test %s" % (d.getVar('IMAGE_ROOTFS'), origInit, d.getVar("IMAGE_ROOTFS")))
-        bb.utils.rename(origInit, origInit + origInitNameSuffix)
-        preinitPath = origInit
-
-    with open(preinitPath, 'w') as f:
-        f.write(PreinitTemplate.format(**args))
-    os.chmod(preinitPath, 0o755)
-}
diff --git a/meta/classes-recipe/overlayfs.bbclass b/meta/classes-recipe/overlayfs.bbclass
deleted file mode 100644
index a82763ec10..0000000000
--- a/meta/classes-recipe/overlayfs.bbclass
+++ /dev/null
@@ -1,142 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-# Class for generation of overlayfs mount units
-#
-# It's often desired in Embedded System design to have a read-only rootfs.
-# But a lot of different applications might want to have a read-write access to
-# some parts of a filesystem. It can be especially useful when your update mechanism
-# overwrites the whole rootfs, but you want your application data to be preserved
-# between updates. This class provides a way to achieve that by means
-# of overlayfs and at the same time keeping the base rootfs read-only.
-#
-# Usage example.
-#
-# Set a mount point for a partition overlayfs is going to use as upper layer
-# in your machine configuration. Underlying file system can be anything that
-# is supported by overlayfs. This has to be done in your machine configuration.
-# QA check fails to catch file existence if you redefine this variable in your recipe!
-#
-#   OVERLAYFS_MOUNT_POINT[data] ?= "/data"
-#
-# Per default the class assumes you have a corresponding fstab entry or systemd
-# mount unit (data.mount in this case) for this mount point installed on the
-# image, for instance via a wks script or the systemd-machine-units recipe.
-#
-# If the mount point is handled somewhere else, e.g. custom boot or preinit
-# scripts or in a initramfs, then this QA check can be skipped by adding
-# mount-configured to the related OVERLAYFS_QA_SKIP flag:
-#
-#   OVERLAYFS_QA_SKIP[data] = "mount-configured"
-#
-# To use the overlayfs, you just have to specify writable directories inside
-# their recipe:
-#
-#   OVERLAYFS_WRITABLE_PATHS[data] = "/usr/share/my-custom-application"
-#
-# To support several mount points you can use a different variable flag. Assume we
-# want to have a writable location on the file system, but not interested where the data
-# survive a reboot. Then we could have a mnt-overlay.mount unit for a tmpfs file system:
-#
-#   OVERLAYFS_MOUNT_POINT[mnt-overlay] = "/mnt/overlay"
-#   OVERLAYFS_WRITABLE_PATHS[mnt-overlay] = "/usr/share/another-application"
-#
-# If your recipe deploys a systemd service, then it should require and be
-# started after the ${PN}-overlays.service to make sure that all overlays are
-# mounted beforehand.
-#
-# Note: the class does not support /etc directory itself, because systemd depends on it
-# For /etc directory use overlayfs-etc class
-
-REQUIRED_DISTRO_FEATURES += "systemd overlayfs"
-
-inherit systemd features_check
-
-OVERLAYFS_CREATE_DIRS_TEMPLATE ??= "${COREBASE}/meta/files/overlayfs-create-dirs.service.in"
-OVERLAYFS_MOUNT_UNIT_TEMPLATE ??= "${COREBASE}/meta/files/overlayfs-unit.mount.in"
-OVERLAYFS_ALL_OVERLAYS_TEMPLATE ??= "${COREBASE}/meta/files/overlayfs-all-overlays.service.in"
-
-python do_create_overlayfs_units() {
-    from oe.overlayfs import mountUnitName
-
-    with open(d.getVar("OVERLAYFS_CREATE_DIRS_TEMPLATE"), "r") as f:
-        CreateDirsUnitTemplate = f.read()
-    with open(d.getVar("OVERLAYFS_MOUNT_UNIT_TEMPLATE"), "r") as f:
-        MountUnitTemplate = f.read()
-    with open(d.getVar("OVERLAYFS_ALL_OVERLAYS_TEMPLATE"), "r") as f:
-        AllOverlaysTemplate = f.read()
-
-    def prepareUnits(data, lower):
-        from oe.overlayfs import helperUnitName
-
-        args = {
-            'DATA_MOUNT_POINT': data,
-            'DATA_MOUNT_UNIT': mountUnitName(data),
-            'CREATE_DIRS_SERVICE': helperUnitName(lower),
-            'LOWERDIR': lower,
-        }
-
-        bb.debug(1, "Generate systemd unit %s" % mountUnitName(lower))
-        with open(os.path.join(d.getVar('WORKDIR'), mountUnitName(lower)), 'w') as f:
-            f.write(MountUnitTemplate.format(**args))
-
-        bb.debug(1, "Generate helper systemd unit %s" % helperUnitName(lower))
-        with open(os.path.join(d.getVar('WORKDIR'), helperUnitName(lower)), 'w') as f:
-            f.write(CreateDirsUnitTemplate.format(**args))
-
-    def prepareGlobalUnit(dependentUnits):
-        from oe.overlayfs import allOverlaysUnitName
-        args = {
-            'ALL_OVERLAYFS_UNITS': " ".join(dependentUnits),
-            'PN': d.getVar('PN')
-        }
-
-        bb.debug(1, "Generate systemd unit with all overlays %s" % allOverlaysUnitName(d))
-        with open(os.path.join(d.getVar('WORKDIR'), allOverlaysUnitName(d)), 'w') as f:
-            f.write(AllOverlaysTemplate.format(**args))
-
-    mountUnitList = []
-    overlayMountPoints = d.getVarFlags("OVERLAYFS_MOUNT_POINT")
-    for mountPoint in overlayMountPoints:
-        bb.debug(1, "Process variable flag %s" % mountPoint)
-        lowerList = d.getVarFlag('OVERLAYFS_WRITABLE_PATHS', mountPoint)
-        if not lowerList:
-            bb.note("No mount points defined for %s flag, skipping" % (mountPoint))
-            continue
-        for lower in lowerList.split():
-            bb.debug(1, "Prepare mount unit for %s with data mount point %s" %
-                     (lower, d.getVarFlag('OVERLAYFS_MOUNT_POINT', mountPoint)))
-            prepareUnits(d.getVarFlag('OVERLAYFS_MOUNT_POINT', mountPoint), lower)
-            mountUnitList.append(mountUnitName(lower))
-
-    # set up one unit, which depends on all mount units, so users can set
-    # only one dependency in their units to make sure software starts
-    # when all overlays are mounted
-    prepareGlobalUnit(mountUnitList)
-}
-
-# we need to generate file names early during parsing stage
-python () {
-    from oe.overlayfs import strForBash, unitFileList
-
-    unitList = unitFileList(d)
-    for unit in unitList:
-        d.appendVar('SYSTEMD_SERVICE:' + d.getVar('PN'), ' ' + unit)
-        d.appendVar('FILES:' + d.getVar('PN'), ' ' +
-                d.getVar('systemd_system_unitdir') + '/' + strForBash(unit))
-
-    d.setVar('OVERLAYFS_UNIT_LIST', ' '.join([strForBash(s) for s in unitList]))
-}
-
-do_install:append() {
-    install -d ${D}${systemd_system_unitdir}
-    for unit in ${OVERLAYFS_UNIT_LIST}; do
-        install -m 0444 ${WORKDIR}/${unit} ${D}${systemd_system_unitdir}
-    done
-}
-
-do_create_overlayfs_units[vardeps] += "OVERLAYFS_WRITABLE_PATHS"
-addtask create_overlayfs_units before do_install
diff --git a/meta/classes-recipe/packagegroup.bbclass b/meta/classes-recipe/packagegroup.bbclass
deleted file mode 100644
index cf6fc354a8..0000000000
--- a/meta/classes-recipe/packagegroup.bbclass
+++ /dev/null
@@ -1,70 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-# Class for packagegroup (package group) recipes
-
-# By default, only the packagegroup package itself is in PACKAGES.
-# -dbg and -dev flavours are handled by the anonfunc below.
-# This means that packagegroup recipes used to build multiple packagegroup
-# packages have to modify PACKAGES after inheriting packagegroup.bbclass.
-PACKAGES = "${PN}"
-
-# By default, packagegroup packages do not depend on a certain architecture.
-# Only if dependencies are modified by MACHINE_FEATURES, packages
-# need to be set to MACHINE_ARCH before inheriting packagegroup.bbclass
-PACKAGE_ARCH ?= "all"
-
-# Fully expanded - so it applies the overrides as well
-PACKAGE_ARCH_EXPANDED := "${PACKAGE_ARCH}"
-
-LICENSE ?= "MIT"
-
-inherit_defer ${@oe.utils.ifelse(d.getVar('PACKAGE_ARCH_EXPANDED') == 'all', 'allarch', '')}
-
-# This automatically adds -dbg and -dev flavours of all PACKAGES
-# to the list. Their dependencies (RRECOMMENDS) are handled as usual
-# by package_depchains in a following step.
-# Also mark all packages as ALLOW_EMPTY
-python () {
-    packages = d.getVar('PACKAGES').split()
-    if d.getVar('PACKAGEGROUP_DISABLE_COMPLEMENTARY') != '1':
-        types = ['', '-dbg', '-dev']
-        if bb.utils.contains('DISTRO_FEATURES', 'ptest', True, False, d):
-            types.append('-ptest')
-        packages = [pkg + suffix for pkg in packages
-                    for suffix in types]
-        d.setVar('PACKAGES', ' '.join(packages))
-    for pkg in packages:
-        d.setVar('ALLOW_EMPTY:%s' % pkg, '1')
-}
-
-# We don't want to look at shared library dependencies for the
-# dbg packages
-DEPCHAIN_DBGDEFAULTDEPS = "1"
-
-# We only need the packaging tasks - disable the rest
-deltask do_fetch
-deltask do_unpack
-deltask do_patch
-deltask do_configure
-deltask do_compile
-deltask do_install
-deltask do_populate_sysroot
-
-do_create_runtime_spdx[deptask] = "do_create_spdx"
-do_create_runtime_spdx[rdeptask] = ""
-
-INHIBIT_DEFAULT_DEPS = "1"
-
-python () {
-    if bb.data.inherits_class('nativesdk', d):
-        return
-    initman = d.getVar("VIRTUAL-RUNTIME_init_manager")
-    if initman and initman in ['sysvinit', 'systemd'] and not bb.utils.contains('DISTRO_FEATURES', initman, True, False, d):
-        bb.fatal("Please ensure that your setting of VIRTUAL-RUNTIME_init_manager (%s) matches the entries enabled in DISTRO_FEATURES" % initman)
-}
-
-CVE_PRODUCT = ""
diff --git a/meta/classes-recipe/perl-version.bbclass b/meta/classes-recipe/perl-version.bbclass
deleted file mode 100644
index 74e33175d9..0000000000
--- a/meta/classes-recipe/perl-version.bbclass
+++ /dev/null
@@ -1,66 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-PERL_OWN_DIR = ""
-
-# Determine the staged version of perl from the perl configuration file
-# Assign vardepvalue, because otherwise signature is changed before and after
-# perl is built (from None to real version in config.sh).
-get_perl_version[vardepvalue] = "${PERL_OWN_DIR}"
-def get_perl_version(d):
-    import re
-    cfg = d.expand('${STAGING_LIBDIR}${PERL_OWN_DIR}/perl5/config.sh')
-    try:
-        f = open(cfg, 'r')
-    except IOError:
-        return None
-    l = f.readlines();
-    f.close();
-    r = re.compile(r"^version='(\d*\.\d*\.\d*)'")
-    for s in l:
-        m = r.match(s)
-        if m:
-            return m.group(1)
-    return None
-
-
-# Determine the staged arch of perl from the perl configuration file
-# Assign vardepvalue, because otherwise signature is changed before and after
-# perl is built (from None to real version in config.sh).
-def get_perl_arch(d):
-    import re
-    cfg = d.expand('${STAGING_LIBDIR}${PERL_OWN_DIR}/perl5/config.sh')
-    try:
-        f = open(cfg, 'r')
-    except IOError:
-        return None
-    l = f.readlines();
-    f.close();
-    r = re.compile("^archname='([^']*)'")
-    for s in l:
-        m = r.match(s)
-        if m:
-            return m.group(1)
-    return None
-
-# Determine the staged arch of perl-native from the perl configuration file
-# Assign vardepvalue, because otherwise signature is changed before and after
-# perl is built (from None to real version in config.sh).
-def get_perl_hostarch(d):
-    import re
-    cfg = d.expand('${STAGING_LIBDIR_NATIVE}/perl5/config.sh')
-    try:
-        f = open(cfg, 'r')
-    except IOError:
-        return None
-    l = f.readlines();
-    f.close();
-    r = re.compile("^archname='([^']*)'")
-    for s in l:
-        m = r.match(s)
-        if m:
-            return m.group(1)
-    return None
diff --git a/meta/classes-recipe/perlnative.bbclass b/meta/classes-recipe/perlnative.bbclass
deleted file mode 100644
index d56ec4ae72..0000000000
--- a/meta/classes-recipe/perlnative.bbclass
+++ /dev/null
@@ -1,9 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-EXTRANATIVEPATH += "perl-native"
-DEPENDS += "perl-native"
-OECMAKE_PERLNATIVE_DIR = "${STAGING_BINDIR_NATIVE}/perl-native"
diff --git a/meta/classes-recipe/pixbufcache.bbclass b/meta/classes-recipe/pixbufcache.bbclass
deleted file mode 100644
index c32673df55..0000000000
--- a/meta/classes-recipe/pixbufcache.bbclass
+++ /dev/null
@@ -1,66 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-#
-# This class will generate the proper postinst/postrm scriptlets for pixbuf
-# packages.
-#
-
-PIXBUF_PACKAGES ??= "${PN}"
-
-PACKAGE_WRITE_DEPS += "qemuwrapper-cross gdk-pixbuf-native"
-
-pixbufcache_common() {
-if [ "x$D" != "x" ]; then
-        $INTERCEPT_DIR/postinst_intercept update_pixbuf_cache ${PKG} mlprefix=${MLPREFIX} binprefix=${MLPREFIX} libdir=${libdir} \
-                bindir=${bindir} base_libdir=${base_libdir}
-else
-
-        # Update the pixbuf loaders in case they haven't been registered yet
-        ${libdir}/gdk-pixbuf-2.0/gdk-pixbuf-query-loaders --update-cache
-
-        if [ -x ${bindir}/gtk-update-icon-cache ] && [ -d ${datadir}/icons ]; then
-                for icondir in /usr/share/icons/*; do
-                        if [ -d ${icondir} ]; then
-                                gtk-update-icon-cache -t -q ${icondir}
-                        fi
-                done
-        fi
-fi
-}
-
-python populate_packages:append() {
-    pixbuf_pkgs = d.getVar('PIXBUF_PACKAGES').split()
-
-    for pkg in pixbuf_pkgs:
-        bb.note("adding pixbuf postinst and postrm scripts to %s" % pkg)
-        postinst = d.getVar('pkg_postinst:%s' % pkg) or d.getVar('pkg_postinst')
-        if not postinst:
-            postinst = '#!/bin/sh\n'
-        postinst += d.getVar('pixbufcache_common')
-        d.setVar('pkg_postinst:%s' % pkg, postinst)
-
-        postrm = d.getVar('pkg_postrm:%s' % pkg) or d.getVar('pkg_postrm')
-        if not postrm:
-            postrm = '#!/bin/sh\n'
-        postrm += d.getVar('pixbufcache_common')
-        d.setVar('pkg_postrm:%s' % pkg, postrm)
-}
-
-gdkpixbuf_complete() {
-GDK_PIXBUF_FATAL_LOADER=1 ${STAGING_LIBDIR_NATIVE}/gdk-pixbuf-2.0/gdk-pixbuf-query-loaders --update-cache || exit 1
-}
-
-DEPENDS:append:class-native = " gdk-pixbuf-native"
-SYSROOT_PREPROCESS_FUNCS:append:class-native = " pixbufcache_sstate_postinst"
-
-pixbufcache_sstate_postinst() {
-        mkdir -p ${SYSROOT_DESTDIR}${bindir}
-        dest=${SYSROOT_DESTDIR}${bindir}/postinst-${PN}
-        echo '#!/bin/sh' > $dest
-        echo "${gdkpixbuf_complete}" >> $dest
-        chmod 0755 $dest
-}
diff --git a/meta/classes-recipe/pkgconfig.bbclass b/meta/classes-recipe/pkgconfig.bbclass
deleted file mode 100644
index 1e1f3824dd..0000000000
--- a/meta/classes-recipe/pkgconfig.bbclass
+++ /dev/null
@@ -1,8 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-DEPENDS:prepend = "pkgconfig-native "
-
diff --git a/meta/classes-recipe/populate_sdk.bbclass b/meta/classes-recipe/populate_sdk.bbclass
deleted file mode 100644
index caeef5d2b2..0000000000
--- a/meta/classes-recipe/populate_sdk.bbclass
+++ /dev/null
@@ -1,13 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-# The majority of populate_sdk is located in populate_sdk_base
-# This chunk simply facilitates compatibility with SDK only recipes.
-
-inherit populate_sdk_base
-
-addtask populate_sdk after do_install before do_build
-
diff --git a/meta/classes-recipe/populate_sdk_base.bbclass b/meta/classes-recipe/populate_sdk_base.bbclass
deleted file mode 100644
index 8e671cf28f..0000000000
--- a/meta/classes-recipe/populate_sdk_base.bbclass
+++ /dev/null
@@ -1,437 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-SDK_CLASSES += "${@bb.utils.contains("IMAGE_CLASSES", "testimage", "testsdk", "", d)}"
-inherit_defer ${SDK_CLASSES}
-
-PACKAGES = ""
-
-# This exists as an optimization for SPDX processing to only run in image and
-# SDK processing context.  This class happens to be common to these usages.
-SPDX_MULTILIB_SSTATE_ARCHS = "${@all_multilib_tune_values(d, 'SSTATE_ARCHS')}"
-
-inherit image-postinst-intercepts image-artifact-names nopackages
-
-# Wildcards specifying complementary packages to install for every package that has been explicitly
-# installed into the rootfs
-COMPLEMENTARY_GLOB[dev-pkgs] = '*-dev'
-COMPLEMENTARY_GLOB[staticdev-pkgs] = '*-staticdev'
-COMPLEMENTARY_GLOB[doc-pkgs] = '*-doc'
-COMPLEMENTARY_GLOB[dbg-pkgs] = '*-dbg'
-COMPLEMENTARY_GLOB[src-pkgs] = '*-src'
-COMPLEMENTARY_GLOB[ptest-pkgs] = '*-ptest ${MLPREFIX}ptest-runner'
-COMPLEMENTARY_GLOB[bash-completion-pkgs] = '*-bash-completion'
-COMPLEMENTARY_GLOB[zsh-completion-pkgs] = '*-zsh-completion'
-
-def complementary_globs(featurevar, d):
-    all_globs = d.getVarFlags('COMPLEMENTARY_GLOB')
-    globs = []
-    features = set((d.getVar(featurevar) or '').split())
-    for name, glob in all_globs.items():
-        if name in features:
-            globs.append(glob)
-    return ' '.join(globs)
-
-SDKIMAGE_FEATURES ??= "dev-pkgs dbg-pkgs src-pkgs ${@bb.utils.contains('DISTRO_FEATURES', 'api-documentation', 'doc-pkgs', '', d)}"
-SDKIMAGE_INSTALL_COMPLEMENTARY = '${@complementary_globs("SDKIMAGE_FEATURES", d)}'
-SDKIMAGE_INSTALL_COMPLEMENTARY[vardeps] += "SDKIMAGE_FEATURES"
-
-PACKAGE_ARCHS:append:task-populate-sdk = " sdk-provides-dummy-target"
-SDK_PACKAGE_ARCHS += "sdk-provides-dummy-${SDKPKGSUFFIX}"
-
-# List of locales to install, or "all" for all of them, or unset for none.
-SDKIMAGE_LINGUAS ?= "all"
-
-inherit_defer rootfs_${IMAGE_PKGTYPE}
-
-SDK_DIR = "${WORKDIR}/sdk"
-SDK_OUTPUT = "${SDK_DIR}/image"
-SDK_DEPLOY = "${DEPLOY_DIR}/sdk"
-
-SDKDEPLOYDIR = "${WORKDIR}/${SDKMACHINE}-deploy-${PN}-populate-sdk"
-
-PSEUDO_INCLUDE_PATHS .= ",${SDK_DIR}"
-
-B:task-populate-sdk = "${SDK_DIR}"
-
-SDKTARGETSYSROOT = "${SDKPATH}/sysroots/${REAL_MULTIMACH_TARGET_SYS}"
-
-SDK_TOOLCHAIN_LANGS ??= ""
-SDK_TOOLCHAIN_LANGS:remove:sdkmingw32 = "rust"
-# libstd-rs doesn't build for mips n32 with compiler constraint errors
-SDK_TOOLCHAIN_LANGS:remove:mipsarchn32 = "rust"
-# go will not build for x86-x32 or mingw
-SDK_TOOLCHAIN_LANGS:remove:linux-gnux32 = "go"
-SDK_TOOLCHAIN_LANGS:remove:riscv32 = "go"
-SDK_TOOLCHAIN_LANGS:remove:sdkmingw32 = "go"
-SDK_TOOLCHAIN_LANGS:remove:powerpc = "go"
-
-TOOLCHAIN_HOST_TASK ?= " \
-    nativesdk-packagegroup-sdk-host \
-    packagegroup-cross-canadian-${MACHINE} \
-    ${@bb.utils.contains('SDK_TOOLCHAIN_LANGS', 'go', 'packagegroup-go-cross-canadian-${MACHINE}', '', d)} \
-    ${@bb.utils.contains('SDK_TOOLCHAIN_LANGS', 'rust', 'packagegroup-rust-cross-canadian-${MACHINE}', '', d)} \
-"
-TOOLCHAIN_HOST_TASK_ATTEMPTONLY ?= ""
-TOOLCHAIN_TARGET_TASK ?= " \
-    ${@multilib_pkg_extend(d, 'packagegroup-core-standalone-sdk-target')} \
-    ${@bb.utils.contains('SDK_TOOLCHAIN_LANGS', 'go', multilib_pkg_extend(d, 'packagegroup-go-sdk-target'), '', d)} \
-    ${@bb.utils.contains('SDK_TOOLCHAIN_LANGS', 'rust', multilib_pkg_extend(d, 'libstd-rs'), '', d)} \
-    target-sdk-provides-dummy \
-"
-TOOLCHAIN_TARGET_TASK_ATTEMPTONLY ?= ""
-TOOLCHAIN_OUTPUTNAME ?= "${SDK_NAME}-toolchain-${SDK_VERSION}"
-
-# Default archived SDK's suffix
-SDK_ARCHIVE_TYPE ?= "tar.xz"
-SDK_XZ_COMPRESSION_LEVEL ?= "-9"
-SDK_XZ_OPTIONS ?= "${XZ_DEFAULTS} ${SDK_XZ_COMPRESSION_LEVEL}"
-SDK_ZIP_OPTIONS ?= "-y"
-SDK_7ZIP_OPTIONS ?= "-mx=9 -mm=BZip2"
-SDK_7ZIP_TYPE ?= "7z"
-SDK_ZSTD_COMPRESSION_LEVEL = "-17"
-
-# To support different sdk type according to SDK_ARCHIVE_TYPE, now support zip and tar.xz
-python () {
-    if d.getVar('SDK_ARCHIVE_TYPE') == 'zip':
-       d.setVar('SDK_ARCHIVE_DEPENDS', 'zip-native')
-       # SDK_ARCHIVE_CMD used to generate archived sdk ${TOOLCHAIN_OUTPUTNAME}.${SDK_ARCHIVE_TYPE} from input dir ${SDK_OUTPUT}/${SDKPATH} to output dir ${SDKDEPLOYDIR}
-       # recommand to cd into input dir first to avoid archive with buildpath
-       d.setVar('SDK_ARCHIVE_CMD', 'cd ${SDK_OUTPUT}/${SDKPATH}; zip -r ${SDK_ZIP_OPTIONS} ${SDKDEPLOYDIR}/${TOOLCHAIN_OUTPUTNAME}.${SDK_ARCHIVE_TYPE} .')
-    elif d.getVar('SDK_ARCHIVE_TYPE') == '7zip':
-       d.setVar('SDK_ARCHIVE_DEPENDS', '7zip-native')
-       d.setVar('SDK_ARCHIVE_CMD', 'cd ${SDK_OUTPUT}/${SDKPATH}; 7za a -r ${SDK_7ZIP_OPTIONS} ${SDKDEPLOYDIR}/${TOOLCHAIN_OUTPUTNAME}.${SDK_7ZIP_TYPE} .')
-    elif d.getVar('SDK_ARCHIVE_TYPE') == 'tar.zst':
-       d.setVar('SDK_ARCHIVE_DEPENDS', 'zstd-native')
-       d.setVar('SDK_ARCHIVE_CMD',
-         'cd ${SDK_OUTPUT}/${SDKPATH}; tar ${SDKTAROPTS} -cf - . | zstd -f -k -T0 -c ${SDK_ZSTD_COMPRESSION_LEVEL} > ${SDKDEPLOYDIR}/${TOOLCHAIN_OUTPUTNAME}.${SDK_ARCHIVE_TYPE}')
-    elif d.getVar('SDK_ARCHIVE_TYPE') == 'tar.xz':
-       d.setVar('SDK_ARCHIVE_DEPENDS', 'xz-native')
-       d.setVar('SDK_ARCHIVE_CMD',
-         'cd ${SDK_OUTPUT}/${SDKPATH}; tar ${SDKTAROPTS} -cf - . | xz ${SDK_XZ_OPTIONS} > ${SDKDEPLOYDIR}/${TOOLCHAIN_OUTPUTNAME}.${SDK_ARCHIVE_TYPE}')
-    else:
-        bb.fatal("Invalid SDK_ARCHIVE_TYPE: %s, the supported SDK archive types are: zip, 7z, tar.xz, tar.zst" % d.getVar('SDK_ARCHIVE_TYPE'))
-}
-
-SDK_RDEPENDS = "${TOOLCHAIN_TARGET_TASK} ${TOOLCHAIN_HOST_TASK}"
-SDK_DEPENDS = "virtual/fakeroot-native ${SDK_ARCHIVE_DEPENDS} cross-localedef-native"
-PATH:prepend = "${WORKDIR}/recipe-sysroot/${SDKPATHNATIVE}${bindir}/crossscripts:${@":".join(all_multilib_tune_values(d, 'STAGING_BINDIR_CROSS').split())}:"
-SDK_DEPENDS += "nativesdk-glibc-locale"
-
-# We want the MULTIARCH_TARGET_SYS to point to the TUNE_PKGARCH, not PACKAGE_ARCH as it
-# could be set to the MACHINE_ARCH
-REAL_MULTIMACH_TARGET_SYS = "${TUNE_PKGARCH}${TARGET_VENDOR}-${TARGET_OS}"
-
-PID = "${@os.getpid()}"
-
-EXCLUDE_FROM_WORLD = "1"
-
-SDK_PACKAGING_FUNC ?= "create_shar"
-SDK_PRE_INSTALL_COMMAND ?= ""
-SDK_POST_INSTALL_COMMAND ?= ""
-SDK_RELOCATE_AFTER_INSTALL ?= "1"
-
-SDKEXTPATH ??= "~/${@d.getVar('DISTRO')}_sdk"
-SDK_TITLE ??= "${@d.getVar('DISTRO_NAME') or d.getVar('DISTRO')} SDK"
-
-SDK_TARGET_MANIFEST = "${SDKDEPLOYDIR}/${TOOLCHAIN_OUTPUTNAME}.target.manifest"
-SDK_HOST_MANIFEST = "${SDKDEPLOYDIR}/${TOOLCHAIN_OUTPUTNAME}.host.manifest"
-SDK_EXT_TARGET_MANIFEST = "${SDK_DEPLOY}/${TOOLCHAINEXT_OUTPUTNAME}.target.manifest"
-SDK_EXT_HOST_MANIFEST = "${SDK_DEPLOY}/${TOOLCHAINEXT_OUTPUTNAME}.host.manifest"
-
-SDK_PRUNE_SYSROOT_DIRS ?= "/dev"
-
-python write_target_sdk_manifest () {
-    from oe.sdk import sdk_list_installed_packages
-    from oe.utils import format_pkg_list
-    sdkmanifestdir = os.path.dirname(d.getVar("SDK_TARGET_MANIFEST"))
-    pkgs = sdk_list_installed_packages(d, True)
-    if not os.path.exists(sdkmanifestdir):
-        bb.utils.mkdirhier(sdkmanifestdir)
-    with open(d.getVar('SDK_TARGET_MANIFEST'), 'w') as output:
-        output.write(format_pkg_list(pkgs, 'ver'))
-}
-
-sdk_prune_dirs () {
-    for d in ${SDK_PRUNE_SYSROOT_DIRS}; do
-        rm -rf ${SDK_OUTPUT}${SDKTARGETSYSROOT}$d
-    done
-}
-
-python write_sdk_test_data() {
-    from oe.data import export2json
-    testdata = "%s/%s.testdata.json" % (d.getVar('SDKDEPLOYDIR'), d.getVar('TOOLCHAIN_OUTPUTNAME'))
-    bb.utils.mkdirhier(os.path.dirname(testdata))
-    export2json(d, testdata)
-}
-
-python write_host_sdk_manifest () {
-    from oe.sdk import sdk_list_installed_packages
-    from oe.utils import format_pkg_list
-    sdkmanifestdir = os.path.dirname(d.getVar("SDK_HOST_MANIFEST"))
-    pkgs = sdk_list_installed_packages(d, False)
-    if not os.path.exists(sdkmanifestdir):
-        bb.utils.mkdirhier(sdkmanifestdir)
-    with open(d.getVar('SDK_HOST_MANIFEST'), 'w') as output:
-        output.write(format_pkg_list(pkgs, 'ver'))
-}
-
-POPULATE_SDK_POST_TARGET_COMMAND:append = " write_sdk_test_data"
-POPULATE_SDK_POST_TARGET_COMMAND:append:task-populate-sdk  = " write_target_sdk_manifest sdk_prune_dirs"
-POPULATE_SDK_POST_HOST_COMMAND:append:task-populate-sdk = " write_host_sdk_manifest"
-
-# Prepare the root links to point to the /usr counterparts.
-create_merged_usr_symlinks() {
-    root="$1"
-    install -d $root${base_bindir} $root${base_sbindir} $root${base_libdir}
-    ln -rs $root${base_bindir} $root/bin
-    ln -rs $root${base_sbindir} $root/sbin
-    ln -rs $root${base_libdir} $root/${baselib}
-
-    if [ "${nonarch_base_libdir}" != "${base_libdir}" ]; then
-       install -d $root${nonarch_base_libdir}
-       ln -rs $root${nonarch_base_libdir} $root/lib
-    fi
-
-    # create base links for multilibs
-    multi_libdirs="${@d.getVar('MULTILIB_VARIANTS')}"
-    for d in $multi_libdirs; do
-        install -d $root${exec_prefix}/$d
-        ln -rs $root${exec_prefix}/$d $root/$d
-    done
-}
-
-create_merged_usr_symlinks_sdk() {
-    create_merged_usr_symlinks ${SDK_OUTPUT}${SDKTARGETSYSROOT}
-}
-
-POPULATE_SDK_PRE_TARGET_COMMAND += "${@bb.utils.contains('DISTRO_FEATURES', 'usrmerge', 'create_merged_usr_symlinks_sdk', '',d)}"
-
-SDK_PACKAGING_COMMAND = "${@'${SDK_PACKAGING_FUNC}' if '${SDK_PACKAGING_FUNC}' else ''}"
-SDK_POSTPROCESS_COMMAND = "create_sdk_files check_sdk_sysroots archive_sdk ${SDK_PACKAGING_COMMAND}"
-
-def populate_sdk_common(d):
-    from oe.sdk import populate_sdk
-    from oe.manifest import create_manifest, Manifest
-    import oe.packagedata
-
-    # Handle package exclusions
-    excl_pkgs = (d.getVar("PACKAGE_EXCLUDE") or "").split()
-    inst_pkgs = (d.getVar("PACKAGE_INSTALL") or "").split()
-    inst_attempt_pkgs = (d.getVar("PACKAGE_INSTALL_ATTEMPTONLY") or "").split()
-
-    d.setVar('PACKAGE_INSTALL_ORIG', ' '.join(inst_pkgs))
-    d.setVar('PACKAGE_INSTALL_ATTEMPTONLY', ' '.join(inst_attempt_pkgs))
-
-    for pkg in excl_pkgs:
-        if pkg in inst_pkgs:
-            bb.warn("Package %s, set to be excluded, is in %s PACKAGE_INSTALL (%s).  It will be removed from the list." % (pkg, d.getVar('PN'), inst_pkgs))
-            inst_pkgs.remove(pkg)
-
-        if pkg in inst_attempt_pkgs:
-            bb.warn("Package %s, set to be excluded, is in %s PACKAGE_INSTALL_ATTEMPTONLY (%s).  It will be removed from the list." % (pkg, d.getVar('PN'), inst_pkgs))
-            inst_attempt_pkgs.remove(pkg)
-
-    d.setVar("PACKAGE_INSTALL", ' '.join(inst_pkgs))
-    d.setVar("PACKAGE_INSTALL_ATTEMPTONLY", ' '.join(inst_attempt_pkgs))
-
-    pn = d.getVar('PN')
-    oe.packagedata.runtime_mapping_rename("TOOLCHAIN_TARGET_TASK", pn, d)
-    oe.packagedata.runtime_mapping_rename("TOOLCHAIN_TARGET_TASK_ATTEMPTONLY", pn, d)
-
-    ld = bb.data.createCopy(d)
-    ld.setVar("PKGDATA_DIR", "${STAGING_DIR}/${SDK_ARCH}-${SDKPKGSUFFIX}${SDK_VENDOR}-${SDK_OS}/pkgdata")
-    oe.packagedata.runtime_mapping_rename("TOOLCHAIN_HOST_TASK", pn, ld)
-    oe.packagedata.runtime_mapping_rename("TOOLCHAIN_HOST_TASK_ATTEMPTONLY", pn, ld)
-    d.setVar("TOOLCHAIN_HOST_TASK", ld.getVar("TOOLCHAIN_HOST_TASK"))
-    d.setVar("TOOLCHAIN_HOST_TASK_ATTEMPTONLY", ld.getVar("TOOLCHAIN_HOST_TASK_ATTEMPTONLY"))
-    
-    # create target/host SDK manifests
-    create_manifest(d, manifest_dir=d.getVar('SDK_DIR'),
-                    manifest_type=Manifest.MANIFEST_TYPE_SDK_HOST)
-    create_manifest(d, manifest_dir=d.getVar('SDK_DIR'),
-                    manifest_type=Manifest.MANIFEST_TYPE_SDK_TARGET)
-
-    populate_sdk(d)
-
-fakeroot python do_populate_sdk() {
-    populate_sdk_common(d)
-}
-SSTATETASKS += "do_populate_sdk"
-SSTATE_SKIP_CREATION:task-populate-sdk = '1'
-do_populate_sdk[cleandirs] += "${SDKDEPLOYDIR}"
-do_populate_sdk[sstate-inputdirs] = "${SDKDEPLOYDIR}"
-do_populate_sdk[sstate-outputdirs] = "${SDK_DEPLOY}"
-do_populate_sdk[stamp-extra-info] = "${MACHINE_ARCH}${SDKMACHINE}"
-python do_populate_sdk_setscene () {
-    sstate_setscene(d)
-}
-addtask do_populate_sdk_setscene
-
-fakeroot create_sdk_files() {
-        cp ${COREBASE}/scripts/relocate_sdk.py ${SDK_OUTPUT}/${SDKPATH}/
-
-        # Replace the ##DEFAULT_INSTALL_DIR## with the correct pattern.
-        # Escape special characters like '+' and '.' in the SDKPATH
-        escaped_sdkpath=$(echo ${SDKPATH} |sed -e "s:[\+\.]:\\\\\\\\\0:g")
-        sed -i -e "s:##DEFAULT_INSTALL_DIR##:$escaped_sdkpath:" ${SDK_OUTPUT}/${SDKPATH}/relocate_sdk.py
-
-       mkdir -p ${SDK_OUTPUT}/${SDKPATHNATIVE}${sysconfdir}/
-       echo '${SDKPATHNATIVE}${libdir_nativesdk}
-${SDKPATHNATIVE}${base_libdir_nativesdk}
-include /etc/ld.so.conf' > ${SDK_OUTPUT}/${SDKPATHNATIVE}${sysconfdir}/ld.so.conf
-}
-
-python check_sdk_sysroots() {
-    # Fails build if there are broken or dangling symlinks in SDK sysroots
-
-    if d.getVar('CHECK_SDK_SYSROOTS') != '1':
-        # disabled, bail out
-        return
-
-    def norm_path(path):
-        return os.path.abspath(path)
-
-    # Get scan root
-    SCAN_ROOT = norm_path("%s/%s/sysroots/" % (d.getVar('SDK_OUTPUT'),
-                                               d.getVar('SDKPATH')))
-
-    bb.note('Checking SDK sysroots at ' + SCAN_ROOT)
-
-    def check_symlink(linkPath):
-        if not os.path.islink(linkPath):
-            return
-
-        linkDirPath = os.path.dirname(linkPath)
-
-        targetPath = os.readlink(linkPath)
-        if not os.path.isabs(targetPath):
-            targetPath = os.path.join(linkDirPath, targetPath)
-        targetPath = norm_path(targetPath)
-
-        if SCAN_ROOT != os.path.commonprefix( [SCAN_ROOT, targetPath] ):
-            bb.error("Escaping symlink {0!s} --> {1!s}".format(linkPath, targetPath))
-            return
-
-        if not os.path.exists(targetPath):
-            bb.error("Broken symlink {0!s} --> {1!s}".format(linkPath, targetPath))
-            return
-
-        if os.path.isdir(targetPath):
-            dir_walk(targetPath)
-
-    def walk_error_handler(e):
-        bb.error(str(e))
-
-    def dir_walk(rootDir):
-        for dirPath,subDirEntries,fileEntries in os.walk(rootDir, followlinks=False, onerror=walk_error_handler):
-            entries = subDirEntries + fileEntries
-            for e in entries:
-                ePath = os.path.join(dirPath, e)
-                check_symlink(ePath)
-
-    # start
-    dir_walk(SCAN_ROOT)
-}
-
-SDKTAROPTS = "--owner=root --group=root --clamp-mtime --mtime=@${SOURCE_DATE_EPOCH}"
-
-fakeroot archive_sdk() {
-        # Package it up
-        mkdir -p ${SDKDEPLOYDIR}
-        ${SDK_ARCHIVE_CMD}
-}
-
-TOOLCHAIN_SHAR_EXT_TMPL ?= "${COREBASE}/meta/files/toolchain-shar-extract.sh"
-TOOLCHAIN_SHAR_REL_TMPL ?= "${COREBASE}/meta/files/toolchain-shar-relocate.sh"
-
-fakeroot create_shar() {
-        # copy in the template shar extractor script
-        cp ${TOOLCHAIN_SHAR_EXT_TMPL} ${SDKDEPLOYDIR}/${TOOLCHAIN_OUTPUTNAME}.sh
-
-        rm -f ${T}/pre_install_command ${T}/post_install_command
-
-        if [ "${SDK_RELOCATE_AFTER_INSTALL}" = "1" ] ; then
-                cp ${TOOLCHAIN_SHAR_REL_TMPL} ${T}/post_install_command
-        fi
-        cat << "EOF" >> ${T}/pre_install_command
-${SDK_PRE_INSTALL_COMMAND}
-EOF
-
-        cat << "EOF" >> ${T}/post_install_command
-${SDK_POST_INSTALL_COMMAND}
-EOF
-        sed -i -e '/@SDK_PRE_INSTALL_COMMAND@/r ${T}/pre_install_command' \
-                -e '/@SDK_POST_INSTALL_COMMAND@/r ${T}/post_install_command' \
-                ${SDKDEPLOYDIR}/${TOOLCHAIN_OUTPUTNAME}.sh
-
-        # substitute variables
-        sed -i -e 's#@SDK_ARCH@#${SDK_ARCH}#g' \
-                -e 's#@SDKPATH@#${SDKPATH}#g' \
-                -e 's#@SDKPATHINSTALL@#${SDKPATHINSTALL}#g' \
-                -e 's#@SDKEXTPATH@#${SDKEXTPATH}#g' \
-                -e 's#@OLDEST_KERNEL@#${SDK_OLDEST_KERNEL}#g' \
-                -e 's#@REAL_MULTIMACH_TARGET_SYS@#${REAL_MULTIMACH_TARGET_SYS}#g' \
-                -e 's#@SDK_TITLE@#${@d.getVar("SDK_TITLE").replace('&', '\\&')}#g' \
-                -e 's#@SDK_VERSION@#${SDK_VERSION}#g' \
-                -e '/@SDK_PRE_INSTALL_COMMAND@/d' \
-                -e '/@SDK_POST_INSTALL_COMMAND@/d' \
-                -e 's#@SDK_ARCHIVE_TYPE@#${SDK_ARCHIVE_TYPE}#g' \
-                ${SDKDEPLOYDIR}/${TOOLCHAIN_OUTPUTNAME}.sh
-
-        # add execution permission
-        chmod +x ${SDKDEPLOYDIR}/${TOOLCHAIN_OUTPUTNAME}.sh
-
-        # append the SDK tarball
-        cat ${SDKDEPLOYDIR}/${TOOLCHAIN_OUTPUTNAME}.${SDK_ARCHIVE_TYPE} >> ${SDKDEPLOYDIR}/${TOOLCHAIN_OUTPUTNAME}.sh
-
-        # delete the old tarball, we don't need it anymore
-        rm ${SDKDEPLOYDIR}/${TOOLCHAIN_OUTPUTNAME}.${SDK_ARCHIVE_TYPE}
-}
-
-populate_sdk_log_check() {
-        for target in $*
-        do
-                lf_path="`dirname ${BB_LOGFILE}`/log.do_$target.${PID}"
-
-                echo "log_check: Using $lf_path as logfile"
-
-                if [ -e "$lf_path" ]; then
-                        ${IMAGE_PKGTYPE}_log_check $target $lf_path
-                else
-                        echo "Cannot find logfile [$lf_path]"
-                fi
-                echo "Logfile is clean"
-        done
-}
-
-def sdk_command_variables(d):
-    return ['OPKG_PREPROCESS_COMMANDS','OPKG_POSTPROCESS_COMMANDS','POPULATE_SDK_POST_HOST_COMMAND','POPULATE_SDK_PRE_TARGET_COMMAND','POPULATE_SDK_POST_TARGET_COMMAND','SDK_POSTPROCESS_COMMAND','RPM_PREPROCESS_COMMANDS','RPM_POSTPROCESS_COMMANDS']
-
-def sdk_variables(d):
-    variables = ['BUILD_IMAGES_FROM_FEEDS','SDK_OS','SDK_OUTPUT','SDKPATHNATIVE','SDKTARGETSYSROOT','SDK_DIR','SDK_VENDOR','SDKIMAGE_INSTALL_COMPLEMENTARY','SDK_PACKAGE_ARCHS','SDK_OUTPUT',
-                 'SDKTARGETSYSROOT','MULTILIB_VARIANTS','MULTILIBS','ALL_MULTILIB_PACKAGE_ARCHS','MULTILIB_GLOBAL_VARIANTS','BAD_RECOMMENDATIONS','NO_RECOMMENDATIONS','PACKAGE_ARCHS',
-                 'PACKAGE_CLASSES','TARGET_VENDOR','TARGET_VENDOR','TARGET_ARCH','TARGET_OS','BBEXTENDVARIANT','FEED_DEPLOYDIR_BASE_URI', 'PACKAGE_EXCLUDE_COMPLEMENTARY', 'IMAGE_INSTALL_DEBUGFS']
-    variables.extend(sdk_command_variables(d))
-    return " ".join(variables)
-
-do_populate_sdk[vardeps] += "${@sdk_variables(d)}"
-
-python () {
-    variables = sdk_command_variables(d)
-    for var in variables:
-        d.setVarFlag(var, 'vardeps', d.getVar(var))
-}
-
-do_populate_sdk[file-checksums] += "${TOOLCHAIN_SHAR_REL_TMPL}:True \
-                                    ${TOOLCHAIN_SHAR_EXT_TMPL}:True"
-
-do_populate_sdk[dirs] = "${PKGDATA_DIR} ${TOPDIR}"
-do_populate_sdk[depends] += "${@' '.join([x + ':do_populate_sysroot' for x in d.getVar('SDK_DEPENDS').split()])}  ${@d.getVarFlag('do_rootfs', 'depends', False)}"
-do_populate_sdk[rdepends] = "${@' '.join([x + ':do_package_write_${IMAGE_PKGTYPE} ' + x + ':do_packagedata' for x in d.getVar('SDK_RDEPENDS').split()])}"
-do_populate_sdk[recrdeptask] += "do_packagedata do_package_write_rpm do_package_write_ipk do_package_write_deb do_package_qa"
-do_populate_sdk[file-checksums] += "${POSTINST_INTERCEPT_CHECKSUMS}"
-addtask populate_sdk
diff --git a/meta/classes-recipe/populate_sdk_ext.bbclass b/meta/classes-recipe/populate_sdk_ext.bbclass
deleted file mode 100644
index 2859320ddf..0000000000
--- a/meta/classes-recipe/populate_sdk_ext.bbclass
+++ /dev/null
@@ -1,854 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-# Extensible SDK
-
-inherit populate_sdk_base
-
-# Used to override TOOLCHAIN_HOST_TASK in the eSDK case
-TOOLCHAIN_HOST_TASK_ESDK = " \
-    meta-environment-extsdk-${MACHINE} \
-    "
-
-SDK_RELOCATE_AFTER_INSTALL:task-populate-sdk-ext = "0"
-
-SDK_EXT = ""
-SDK_EXT:task-populate-sdk-ext = "-ext"
-
-# Options are full or minimal
-SDK_EXT_TYPE ?= "full"
-SDK_INCLUDE_PKGDATA ?= "0"
-SDK_INCLUDE_TOOLCHAIN ?= "${@'1' if d.getVar('SDK_EXT_TYPE') == 'full' else '0'}"
-SDK_INCLUDE_NATIVESDK ?= "0"
-SDK_INCLUDE_BUILDTOOLS ?= '1'
-
-SDK_RECRDEP_TASKS ?= ""
-SDK_CUSTOM_TEMPLATECONF ?= "0"
-
-ESDK_LOCALCONF_ALLOW ?= ""
-ESDK_LOCALCONF_REMOVE ?= "CONF_VERSION \
-                             BB_NUMBER_THREADS \
-                             BB_NUMBER_PARSE_THREADS \
-                             PARALLEL_MAKE \
-                             PRSERV_HOST \
-                             SSTATE_MIRRORS \
-                             DL_DIR \
-                             SSTATE_DIR \
-                             TMPDIR \
-                             BB_SERVER_TIMEOUT \
-                            "
-ESDK_CLASS_INHERIT_DISABLE ?= "buildhistory"
-SDK_UPDATE_URL ?= ""
-
-SDK_TARGETS ?= "${PN}"
-
-def get_sdk_install_targets(d, images_only=False):
-    sdk_install_targets = ''
-    if images_only or d.getVar('SDK_EXT_TYPE') != 'minimal':
-        sdk_install_targets = d.getVar('SDK_TARGETS')
-
-        depd = d.getVar('BB_TASKDEPDATA', False)
-        tasklist = bb.build.tasksbetween('do_image_complete', 'do_build', d)
-        tasklist.remove('do_build')
-        for v in depd.values():
-            if v[1] in tasklist:
-                if v[0] not in sdk_install_targets:
-                    sdk_install_targets += ' {}'.format(v[0])
-
-    if not images_only:
-        if d.getVar('SDK_INCLUDE_PKGDATA') == '1':
-            sdk_install_targets += ' meta-world-pkgdata:do_allpackagedata'
-        if d.getVar('SDK_INCLUDE_TOOLCHAIN') == '1':
-            sdk_install_targets += ' meta-extsdk-toolchain:do_populate_sysroot'
-
-    return sdk_install_targets
-
-get_sdk_install_targets[vardepsexclude] = "BB_TASKDEPDATA"
-
-OE_INIT_ENV_SCRIPT ?= "oe-init-build-env"
-
-# The files from COREBASE that you want preserved in the COREBASE copied
-# into the sdk. This allows someone to have their own setup scripts in
-# COREBASE be preserved as well as untracked files.
-COREBASE_FILES ?= " \
-    oe-init-build-env \
-    scripts \
-    LICENSE \
-    .templateconf \
-"
-
-SDK_DIR:task-populate-sdk-ext = "${WORKDIR}/sdk-ext"
-B:task-populate-sdk-ext = "${SDK_DIR}"
-TOOLCHAINEXT_OUTPUTNAME ?= "${SDK_NAME}-toolchain-ext-${SDK_VERSION}"
-TOOLCHAIN_OUTPUTNAME:task-populate-sdk-ext = "${TOOLCHAINEXT_OUTPUTNAME}"
-
-SDK_EXT_TARGET_MANIFEST = "${SDK_DEPLOY}/${TOOLCHAINEXT_OUTPUTNAME}.target.manifest"
-SDK_EXT_HOST_MANIFEST = "${SDK_DEPLOY}/${TOOLCHAINEXT_OUTPUTNAME}.host.manifest"
-
-python write_target_sdk_ext_manifest () {
-    from oe.sdk import get_extra_sdkinfo
-    sstate_dir = d.expand('${SDK_OUTPUT}/${SDKPATH}/sstate-cache')
-    extra_info = get_extra_sdkinfo(sstate_dir)
-
-    target = d.getVar('TARGET_SYS')
-    target_multimach = d.getVar('MULTIMACH_TARGET_SYS')
-    real_target_multimach = d.getVar('REAL_MULTIMACH_TARGET_SYS')
-
-    pkgs = {}
-    os.makedirs(os.path.dirname(d.getVar('SDK_EXT_TARGET_MANIFEST')), exist_ok=True)
-    with open(d.getVar('SDK_EXT_TARGET_MANIFEST'), 'w') as f:
-        for fn in extra_info['filesizes']:
-            info = fn.split(':')
-            if info[2] in (target, target_multimach, real_target_multimach) \
-                    or info[5] == 'allarch':
-                if not info[1] in pkgs:
-                    f.write("%s %s %s\n" % (info[1], info[2], info[3]))
-                    pkgs[info[1]] = {}
-}
-python write_host_sdk_ext_manifest () {
-    from oe.sdk import get_extra_sdkinfo
-    sstate_dir = d.expand('${SDK_OUTPUT}/${SDKPATH}/sstate-cache')
-    extra_info = get_extra_sdkinfo(sstate_dir)
-    host = d.getVar('BUILD_SYS')
-    with open(d.getVar('SDK_EXT_HOST_MANIFEST'), 'w') as f:
-        for fn in extra_info['filesizes']:
-            info = fn.split(':')
-            if info[2] == host:
-                f.write("%s %s %s\n" % (info[1], info[2], info[3]))
-}
-
-SDK_POSTPROCESS_COMMAND:append:task-populate-sdk-ext = " write_target_sdk_ext_manifest write_host_sdk_ext_manifest"    
-
-SDK_TITLE:task-populate-sdk-ext = "${@d.getVar('DISTRO_NAME') or d.getVar('DISTRO')} Extensible SDK"
-
-def clean_esdk_builddir(d, sdkbasepath):
-    """Clean up traces of the fake build for create_filtered_tasklist()"""
-    import shutil
-    cleanpaths = ['cache', 'tmp']
-    for pth in cleanpaths:
-        fullpth = os.path.join(sdkbasepath, pth)
-        if os.path.isdir(fullpth):
-            shutil.rmtree(fullpth)
-        elif os.path.isfile(fullpth):
-            os.remove(fullpth)
-
-def create_filtered_tasklist(d, sdkbasepath, tasklistfile, conf_initpath):
-    """
-    Create a filtered list of tasks. Also double-checks that the build system
-    within the SDK basically works and required sstate artifacts are available.
-    """
-    import tempfile
-    import shutil
-    import oe.copy_buildsystem
-
-    # Create a temporary build directory that we can pass to the env setup script
-    shutil.copyfile(sdkbasepath + '/conf/local.conf', sdkbasepath + '/conf/local.conf.bak')
-    try:
-        with open(sdkbasepath + '/conf/local.conf', 'a') as f:
-            # Force the use of sstate from the build system
-            f.write('\nSSTATE_DIR:forcevariable = "%s"\n' % d.getVar('SSTATE_DIR'))
-            # Ensure TMPDIR is the default so that clean_esdk_builddir() can delete it
-            f.write('TMPDIR:forcevariable = "${TOPDIR}/tmp"\n')
-            # Drop uninative if the build isn't using it (or else NATIVELSBSTRING will
-            # be different and we won't be able to find our native sstate)
-            if not bb.data.inherits_class('uninative', d):
-                f.write('INHERIT:remove = "uninative"\n')
-
-        # Unfortunately the default SDKPATH (or even a custom value) may contain characters that bitbake
-        # will not allow in its COREBASE path, so we need to rename the directory temporarily
-        temp_sdkbasepath = d.getVar('SDK_OUTPUT') + '/tmp-renamed-sdk'
-        # Delete any existing temp dir
-        try:
-            shutil.rmtree(temp_sdkbasepath)
-        except FileNotFoundError:
-            pass
-        bb.utils.rename(sdkbasepath, temp_sdkbasepath)
-        cmdprefix = '. %s .; ' % conf_initpath
-        logfile = d.getVar('WORKDIR') + '/tasklist_bb_log.txt'
-        try:
-            oe.copy_buildsystem.check_sstate_task_list(d, get_sdk_install_targets(d), tasklistfile, cmdprefix=cmdprefix, cwd=temp_sdkbasepath, logfile=logfile)
-        except bb.process.ExecutionError as e:
-            msg = 'Failed to generate filtered task list for extensible SDK:\n%s' %  e.stdout.rstrip()
-            if 'attempted to execute unexpectedly and should have been setscened' in e.stdout:
-                msg += '\n----------\n\nNOTE: "attempted to execute unexpectedly and should have been setscened" errors indicate this may be caused by missing sstate artifacts that were likely produced in earlier builds, but have been subsequently deleted for some reason.\n'
-            bb.fatal(msg)
-        bb.utils.rename(temp_sdkbasepath, sdkbasepath)
-        # Clean out residue of running bitbake, which check_sstate_task_list()
-        # will effectively do
-        clean_esdk_builddir(d, sdkbasepath)
-    finally:
-        localconf = sdkbasepath + '/conf/local.conf'
-        if os.path.exists(localconf + '.bak'):
-            os.replace(localconf + '.bak', localconf)
-
-def copy_bitbake_and_layers(d, baseoutpath, derivative):
-    oe_init_env_script = d.getVar('OE_INIT_ENV_SCRIPT')
-
-    conf_bbpath = ''
-    conf_initpath = ''
-    core_meta_subdir = ''
-
-    # Copy in all metadata layers + bitbake (as repositories)
-    buildsystem = oe.copy_buildsystem.BuildSystem('extensible SDK', d)
-
-    if derivative:
-        workspace_name = 'orig-workspace'
-    else:
-        workspace_name = None
-
-    corebase, sdkbblayers = buildsystem.copy_bitbake_and_layers(baseoutpath + '/layers', workspace_name)
-    conf_bbpath = os.path.join('layers', corebase, 'bitbake')
-
-    for path in os.listdir(baseoutpath + '/layers'):
-        relpath = os.path.join('layers', path, oe_init_env_script)
-        if os.path.exists(os.path.join(baseoutpath, relpath)):
-            conf_initpath = relpath
-
-        relpath = os.path.join('layers', path, 'scripts', 'esdk-tools', 'devtool')
-        if os.path.exists(os.path.join(baseoutpath, relpath)):
-            esdk_tools_path = os.path.dirname(relpath)
-
-        relpath = os.path.join('layers', path, 'meta')
-        if os.path.exists(os.path.join(baseoutpath, relpath, 'lib', 'oe')):
-            core_meta_subdir = relpath
-
-    d.setVar('oe_init_build_env_path', conf_initpath)
-    d.setVar('esdk_tools_path', esdk_tools_path)
-
-    return (conf_initpath, conf_bbpath, core_meta_subdir, sdkbblayers)
-
-def write_devtool_config(d, baseoutpath, conf_bbpath, conf_initpath, core_meta_subdir):
-    # Write out config file for devtool
-    import configparser
-    config = configparser.ConfigParser()
-    config.add_section('General')
-    config.set('General', 'bitbake_subdir', conf_bbpath)
-    config.set('General', 'init_path', conf_initpath)
-    config.set('General', 'core_meta_subdir', core_meta_subdir)
-    config.add_section('SDK')
-    config.set('SDK', 'sdk_targets', d.getVar('SDK_TARGETS'))
-    updateurl = d.getVar('SDK_UPDATE_URL')
-    if updateurl:
-        config.set('SDK', 'updateserver', updateurl)
-    bb.utils.mkdirhier(os.path.join(baseoutpath, 'conf'))
-    with open(os.path.join(baseoutpath, 'conf', 'devtool.conf'), 'w') as f:
-        config.write(f)
-
-def write_unlocked_sigs(d, baseoutpath):
-    unlockedsigs =  os.path.join(baseoutpath, 'conf', 'unlocked-sigs.inc')
-    with open(unlockedsigs, 'w') as f:
-        pass
-
-def write_bblayers_conf(d, baseoutpath, sdkbblayers):
-    # Create a layer for new recipes / appends
-    bbpath = d.getVar('BBPATH')
-    env = os.environ.copy()
-    env['PYTHONDONTWRITEBYTECODE'] = '1'
-    bb.process.run(['devtool', '--bbpath', bbpath, '--basepath', baseoutpath, 'create-workspace', '--layerseries', d.getVar("LAYERSERIES_CORENAMES"), '--create-only', os.path.join(baseoutpath, 'workspace')], env=env)
-
-    # Create bblayers.conf
-    bb.utils.mkdirhier(baseoutpath + '/conf')
-    with open(baseoutpath + '/conf/bblayers.conf', 'w') as f:
-        f.write('# WARNING: this configuration has been automatically generated and in\n')
-        f.write('# most cases should not be edited. If you need more flexibility than\n')
-        f.write('# this configuration provides, it is strongly suggested that you set\n')
-        f.write('# up a proper instance of the full build system and use that instead.\n\n')
-
-        # LCONF_VERSION may not be set, for example when using meta-poky
-        # so don't error if it isn't found
-        lconf_version = d.getVar('LCONF_VERSION', False)
-        if lconf_version is not None:
-            f.write('LCONF_VERSION = "%s"\n\n' % lconf_version)
-
-        f.write('BBPATH = "$' + '{TOPDIR}"\n')
-        f.write('SDKBASEMETAPATH = "$' + '{TOPDIR}"\n')
-        f.write('BBLAYERS := " \\\n')
-        for layerrelpath in sdkbblayers:
-            f.write('    $' + '{SDKBASEMETAPATH}/layers/%s \\\n' % layerrelpath)
-        f.write('    $' + '{SDKBASEMETAPATH}/workspace \\\n')
-        f.write('    "\n')
-
-def copy_uninative(d, baseoutpath):
-    import shutil
-
-    uninative_checksum = None
-
-    # Copy uninative tarball
-    # For now this is where uninative.bbclass expects the tarball
-    if bb.data.inherits_class('uninative', d):
-        uninative_file = d.expand('${UNINATIVE_DLDIR}/' + d.getVarFlag("UNINATIVE_CHECKSUM", d.getVar("BUILD_ARCH")) + '/${UNINATIVE_TARBALL}')
-        uninative_checksum = bb.utils.sha256_file(uninative_file)
-        uninative_outdir = '%s/downloads/uninative/%s' % (baseoutpath, uninative_checksum)
-        bb.utils.mkdirhier(uninative_outdir)
-        shutil.copy(uninative_file, uninative_outdir)
-
-    return uninative_checksum
-
-def write_local_conf(d, baseoutpath, derivative, core_meta_subdir, uninative_checksum):
-    import shutil
-
-    #check if custome templateconf path is set
-    use_custom_templateconf = d.getVar('SDK_CUSTOM_TEMPLATECONF')
-
-    env_passthrough = (d.getVar('BB_ENV_PASSTHROUGH_ADDITIONS') or '').split()
-    env_passthrough_values = {}
-
-    # Create local.conf
-    builddir = d.getVar('TOPDIR')
-    if derivative and os.path.exists(builddir + '/conf/site.conf'):
-        shutil.copyfile(builddir + '/conf/site.conf', baseoutpath + '/conf/site.conf')
-    if derivative and os.path.exists(builddir + '/conf/auto.conf'):
-        shutil.copyfile(builddir + '/conf/auto.conf', baseoutpath + '/conf/auto.conf')
-    if derivative:
-        shutil.copyfile(builddir + '/conf/local.conf', baseoutpath + '/conf/local.conf')
-    else:
-        local_conf_allowed = (d.getVar('ESDK_LOCALCONF_ALLOW') or '').split()
-        local_conf_remove = (d.getVar('ESDK_LOCALCONF_REMOVE') or '').split()
-        def handle_var(varname, origvalue, op, newlines):
-            if varname in local_conf_remove or (origvalue.strip().startswith('/') and not varname in local_conf_allowed):
-                newlines.append('# Removed original setting of %s\n' % varname)
-                return None, op, 0, True
-            else:
-                if varname in env_passthrough:
-                    env_passthrough_values[varname] = origvalue
-                return origvalue, op, 0, True
-        varlist = ['[^#=+ ]*']
-        oldlines = []
-        for conffile in ['site.conf', 'auto.conf', 'toolcfg.conf', 'local.conf']:
-            if os.path.exists(builddir + '/conf/' + conffile):
-                with open(builddir + '/conf/' + conffile, 'r') as f:
-                    oldlines += f.readlines()
-        (updated, newlines) = bb.utils.edit_metadata(oldlines, varlist, handle_var)
-
-        with open(baseoutpath + '/conf/local.conf', 'w') as f:
-            f.write('# WARNING: this configuration has been automatically generated and in\n')
-            f.write('# most cases should not be edited. If you need more flexibility than\n')
-            f.write('# this configuration provides, it is strongly suggested that you set\n')
-            f.write('# up a proper instance of the full build system and use that instead.\n\n')
-            for line in newlines:
-                if line.strip() and not line.startswith('#'):
-                    f.write(line)
-            # Write a newline just in case there's none at the end of the original
-            f.write('\n')
-
-            f.write('TMPDIR = "${TOPDIR}/tmp"\n')
-            f.write('DL_DIR = "${TOPDIR}/downloads"\n')
-
-            if bb.data.inherits_class('uninative', d):
-               f.write('INHERIT += "%s"\n' % 'uninative')
-               f.write('UNINATIVE_CHECKSUM[%s] = "%s"\n\n' % (d.getVar('BUILD_ARCH'), uninative_checksum))
-
-            # CONF_VERSION may not be set, for example when using an empty local.conf
-            # generated with bitbake-setup, and it is not otherwise required to exist.
-            # Write it out only if it's defined.
-            conf_version = d.getVar('CONF_VERSION', False)
-            if conf_version is not None:
-                f.write('CONF_VERSION = "%s"\n\n' % conf_version)
-
-            # Some classes are not suitable for SDK, remove them from INHERIT
-            f.write('INHERIT:remove = "%s"\n' % d.getVar('ESDK_CLASS_INHERIT_DISABLE', False))
-
-            # Bypass the default connectivity check if any
-            f.write('CONNECTIVITY_CHECK_URIS = ""\n\n')
-
-            # This warning will come out if reverse dependencies for a task
-            # don't have sstate as well as the task itself. We already know
-            # this will be the case for the extensible sdk, so turn off the
-            # warning.
-            f.write('SIGGEN_LOCKEDSIGS_SSTATE_EXISTS_CHECK = "none"\n\n')
-
-            # Warn if the sigs in the locked-signature file don't match
-            # the sig computed from the metadata.
-            f.write('SIGGEN_LOCKEDSIGS_TASKSIG_CHECK = "warn"\n\n')
-
-            # We want to be able to set this without a full reparse
-            f.write('BB_HASHCONFIG_IGNORE_VARS:append = " SIGGEN_UNLOCKED_RECIPES"\n\n')
-
-            # Set up which tasks are ignored for run on install
-            f.write('BB_SETSCENE_ENFORCE_IGNORE_TASKS = "%:* *:do_shared_workdir *:do_rm_work wic-tools:* *:do_addto_recipe_sysroot"\n\n')
-
-            # Hide the config information from bitbake output (since it's fixed within the SDK)
-            f.write('BUILDCFG_HEADER = ""\n\n')
-
-            # Write METADATA_REVISION
-            # Needs distro override so it can override the value set in the bbclass code (later than local.conf)
-            f.write('METADATA_REVISION:%s = "%s"\n\n' % (d.getVar('DISTRO'), d.getVar('METADATA_REVISION')))
-
-            f.write('# Provide a flag to indicate we are in the EXT_SDK Context\n')
-            f.write('WITHIN_EXT_SDK = "1"\n\n')
-
-            if d.getVar("PRSERV_HOST"):
-                # Override this, we now include PR data, so it should only point ot the local database
-                f.write('PRSERV_HOST = "localhost:0"\n\n')
-
-            # Allow additional config through sdk-extra.conf
-            fn = bb.cookerdata.findConfigFile('sdk-extra.conf', d)
-            if fn:
-                with open(fn, 'r') as xf:
-                    for line in xf:
-                        f.write(line)
-
-            # If you define a sdk_extraconf() function then it can contain additional config
-            # (Though this is awkward; sdk-extra.conf should probably be used instead)
-            extraconf = (d.getVar('sdk_extraconf') or '').strip()
-            if extraconf:
-                # Strip off any leading / trailing spaces
-                for line in extraconf.splitlines():
-                    f.write(line.strip() + '\n')
-
-            f.write('require conf/locked-sigs.inc\n')
-            f.write('require conf/unlocked-sigs.inc\n')
-
-    # Copy multiple configurations if they exist in the users config directory
-    if d.getVar('BBMULTICONFIG') is not None:
-        bb.utils.mkdirhier(os.path.join(baseoutpath, 'conf', 'multiconfig'))
-        for mc in d.getVar('BBMULTICONFIG').split():
-            dest_stub = "/conf/multiconfig/%s.conf" % (mc,)
-            if os.path.exists(builddir + dest_stub):
-                shutil.copyfile(builddir + dest_stub, baseoutpath + dest_stub)
-
-    # If PR Service is in use, we need to export this as well
-    bb.note('Do we have a pr database?')
-    if d.getVar("PRSERV_HOST"):
-        bb.note('Writing PR database...')
-        # Based on the code in classes/prexport.bbclass
-        import oe.prservice
-        #dump meta info of tables
-        localdata = d.createCopy()
-        localdata.setVar('PRSERV_DUMPOPT_COL', "1")
-        localdata.setVar('PRSERV_DUMPDIR', os.path.join(baseoutpath, 'conf'))
-        localdata.setVar('PRSERV_DUMPFILE', '${PRSERV_DUMPDIR}/prserv.inc')
-
-        bb.note('PR Database write to %s' % (localdata.getVar('PRSERV_DUMPFILE')))
-
-        retval = oe.prservice.prserv_dump_db(localdata)
-        if not retval:
-            bb.error("prexport_handler: export failed!")
-            return
-        (metainfo, datainfo) = retval
-        oe.prservice.prserv_export_tofile(localdata, metainfo, datainfo, True)
-
-    # Use templateconf.cfg file from builddir if exists
-    if os.path.exists(builddir + '/conf/templateconf.cfg') and use_custom_templateconf == '1':
-        shutil.copyfile(builddir + '/conf/templateconf.cfg', baseoutpath + '/conf/templateconf.cfg')
-    else:
-        # Write a templateconf.cfg
-        with open(baseoutpath + '/conf/templateconf.cfg', 'w') as f:
-            f.write('meta/conf/templates/default\n')
-        os.makedirs(os.path.join(baseoutpath, core_meta_subdir, 'conf/templates/default'), exist_ok=True)
-
-    # Ensure any variables set from the external environment (by way of
-    # BB_ENV_PASSTHROUGH_ADDITIONS) are set in the SDK's configuration
-    extralines = []
-    for name, value in env_passthrough_values.items():
-        actualvalue = d.getVar(name) or ''
-        if value != actualvalue:
-            extralines.append('%s = "%s"\n' % (name, actualvalue))
-    if extralines:
-        with open(baseoutpath + '/conf/local.conf', 'a') as f:
-            f.write('\n')
-            f.write('# Extra settings from environment:\n')
-            for line in extralines:
-                f.write(line)
-            f.write('\n')
-
-def prepare_locked_cache(d, baseoutpath, derivative, conf_initpath):
-    import shutil
-
-    # Filter the locked signatures file to just the sstate tasks we are interested in
-    excluded_targets = get_sdk_install_targets(d, images_only=True)
-    sigfile = d.getVar('WORKDIR') + '/locked-sigs.inc'
-    lockedsigs_pruned = baseoutpath + '/conf/locked-sigs.inc'
-    #nativesdk-only sigfile to merge into locked-sigs.inc
-    sdk_include_nativesdk = (d.getVar("SDK_INCLUDE_NATIVESDK") == '1')
-    nativesigfile = d.getVar('WORKDIR') + '/locked-sigs_nativesdk.inc'
-    nativesigfile_pruned = d.getVar('WORKDIR') + '/locked-sigs_nativesdk_pruned.inc'
-
-    if sdk_include_nativesdk:
-        oe.copy_buildsystem.prune_lockedsigs([],
-                                             excluded_targets.split(),
-                                             nativesigfile,
-                                             True,
-                                             nativesigfile_pruned)
-
-        oe.copy_buildsystem.merge_lockedsigs([],
-                                             sigfile,
-                                             nativesigfile_pruned,
-                                             sigfile)
-
-    oe.copy_buildsystem.prune_lockedsigs([],
-                                         excluded_targets.split(),
-                                         sigfile,
-                                         False,
-                                         lockedsigs_pruned)
-
-    sstate_out = baseoutpath + '/sstate-cache'
-    bb.utils.remove(sstate_out, True)
-
-    # uninative.bbclass sets NATIVELSBSTRING to 'universal'
-    fixedlsbstring = "universal" if bb.data.inherits_class('uninative', d) else ""
-
-    sdk_include_toolchain = (d.getVar('SDK_INCLUDE_TOOLCHAIN') == '1')
-    sdk_ext_type = d.getVar('SDK_EXT_TYPE')
-    if (sdk_ext_type != 'minimal' or sdk_include_toolchain or derivative) and not sdk_include_nativesdk:
-        # Create the filtered task list used to generate the sstate cache shipped with the SDK
-        tasklistfn = d.getVar('WORKDIR') + '/tasklist.txt'
-        create_filtered_tasklist(d, baseoutpath, tasklistfn, conf_initpath)
-    else:
-        tasklistfn = None
-
-    # Add packagedata if enabled
-    if d.getVar('SDK_INCLUDE_PKGDATA') == '1':
-        lockedsigs_base = d.getVar('WORKDIR') + '/locked-sigs-base.inc'
-        lockedsigs_copy = d.getVar('WORKDIR') + '/locked-sigs-copy.inc'
-        shutil.move(lockedsigs_pruned, lockedsigs_base)
-        oe.copy_buildsystem.merge_lockedsigs(['do_packagedata'],
-                                             lockedsigs_base,
-                                             d.getVar('STAGING_DIR_HOST') + '/world-pkgdata/locked-sigs-pkgdata.inc',
-                                             lockedsigs_pruned,
-                                             lockedsigs_copy)
-
-    if sdk_include_toolchain:
-        lockedsigs_base = d.getVar('WORKDIR') + '/locked-sigs-base2.inc'
-        lockedsigs_toolchain = d.expand("${STAGING_DIR}/${TUNE_PKGARCH}/meta-extsdk-toolchain/locked-sigs/locked-sigs-extsdk-toolchain.inc")
-        shutil.move(lockedsigs_pruned, lockedsigs_base)
-        oe.copy_buildsystem.merge_lockedsigs([],
-                                             lockedsigs_base,
-                                             lockedsigs_toolchain,
-                                             lockedsigs_pruned)
-        oe.copy_buildsystem.create_locked_sstate_cache(lockedsigs_toolchain,
-                                                       d.getVar('SSTATE_DIR'),
-                                                       sstate_out, d,
-                                                       fixedlsbstring,
-                                                       filterfile=tasklistfn)
-
-    if sdk_ext_type == 'minimal':
-        if derivative:
-            # Assume the user is not going to set up an additional sstate
-            # mirror, thus we need to copy the additional artifacts (from
-            # workspace recipes) into the derivative SDK
-            lockedsigs_orig = d.getVar('TOPDIR') + '/conf/locked-sigs.inc'
-            if os.path.exists(lockedsigs_orig):
-                lockedsigs_extra = d.getVar('WORKDIR') + '/locked-sigs-extra.inc'
-                oe.copy_buildsystem.merge_lockedsigs(None,
-                                                     lockedsigs_orig,
-                                                     lockedsigs_pruned,
-                                                     None,
-                                                     lockedsigs_extra)
-                oe.copy_buildsystem.create_locked_sstate_cache(lockedsigs_extra,
-                                                               d.getVar('SSTATE_DIR'),
-                                                               sstate_out, d,
-                                                               fixedlsbstring,
-                                                               filterfile=tasklistfn)
-    else:
-        oe.copy_buildsystem.create_locked_sstate_cache(lockedsigs_pruned,
-                                                       d.getVar('SSTATE_DIR'),
-                                                       sstate_out, d,
-                                                       fixedlsbstring,
-                                                       filterfile=tasklistfn)
-
-    # We don't need sstate do_package files
-    for root, dirs, files in os.walk(sstate_out):
-        for name in files:
-            if name.endswith("_package.tar.zst"):
-                f = os.path.join(root, name)
-                os.remove(f)
-
-def write_manifest(d, baseoutpath):
-    import glob
-
-    # Write manifest file
-    # Note: at the moment we cannot include the env setup script here to keep
-    # it updated, since it gets modified during SDK installation (see
-    # sdk_ext_postinst() below) thus the checksum we take here would always
-    # be different.
-    manifest_file_list = ['conf/*']
-    if d.getVar('BBMULTICONFIG') is not None:
-        manifest_file_list.append('conf/multiconfig/*')
-
-    esdk_manifest_excludes = (d.getVar('ESDK_MANIFEST_EXCLUDES') or '').split()
-    esdk_manifest_excludes_list = []
-    for exclude_item in esdk_manifest_excludes:
-        esdk_manifest_excludes_list += glob.glob(os.path.join(baseoutpath, exclude_item))
-    manifest_file = os.path.join(baseoutpath, 'conf', 'sdk-conf-manifest')
-    with open(manifest_file, 'w') as f:
-        for item in manifest_file_list:
-            for fn in glob.glob(os.path.join(baseoutpath, item)):
-                if fn == manifest_file or os.path.isdir(fn):
-                    continue
-                if fn in esdk_manifest_excludes_list:
-                    continue
-                chksum = bb.utils.sha256_file(fn)
-                f.write('%s\t%s\n' % (chksum, os.path.relpath(fn, baseoutpath)))
-
-
-python copy_buildsystem () {
-    import oe.copy_buildsystem
-
-    baseoutpath = d.getVar('SDK_OUTPUT') + '/' + d.getVar('SDKPATH')
-
-    # Determine if we're building a derivative extensible SDK (from devtool build-sdk)
-    derivative = (d.getVar('SDK_DERIVATIVE') or '') == '1'
-
-    conf_initpath, conf_bbpath, core_meta_subdir, sdkbblayers = copy_bitbake_and_layers(d, baseoutpath, derivative)
-
-    write_devtool_config(d, baseoutpath, conf_bbpath, conf_initpath, core_meta_subdir)
-
-    write_unlocked_sigs(d, baseoutpath)
-
-    write_bblayers_conf(d, baseoutpath, sdkbblayers)
-
-    uninative_checksum = copy_uninative(d, baseoutpath)
-
-    write_local_conf(d, baseoutpath, derivative, core_meta_subdir, uninative_checksum)
-
-    prepare_locked_cache(d, baseoutpath, derivative, conf_initpath)
-
-    write_manifest(d, baseoutpath)
-
-}
-
-def get_current_buildtools(d):
-    """Get the file name of the current buildtools installer"""
-    import glob
-    btfiles = glob.glob(os.path.join(d.getVar('SDK_DEPLOY'), '*-buildtools-nativesdk-standalone-*.sh'))
-    btfiles.sort(key=os.path.getctime)
-    return os.path.basename(btfiles[-1])
-
-def get_sdk_required_utilities(buildtools_fn, d):
-    """Find required utilities that aren't provided by the buildtools"""
-    sanity_required_utilities = (d.getVar('SANITY_REQUIRED_UTILITIES') or '').split()
-    sanity_required_utilities.append(d.expand('${BUILD_PREFIX}gcc'))
-    sanity_required_utilities.append(d.expand('${BUILD_PREFIX}g++'))
-    if buildtools_fn:
-        buildtools_installer = os.path.join(d.getVar('SDK_DEPLOY'), buildtools_fn)
-        filelist, _ = bb.process.run('%s -l' % buildtools_installer)
-    else:
-        buildtools_installer = None
-        filelist = ""
-    localdata = bb.data.createCopy(d)
-    localdata.setVar('SDKPATH', '.')
-    sdkpathnative = localdata.getVar('SDKPATHNATIVE')
-    sdkbindirs = [localdata.getVar('bindir_nativesdk'),
-                  localdata.getVar('sbindir_nativesdk'),
-                  localdata.getVar('base_bindir_nativesdk'),
-                  localdata.getVar('base_sbindir_nativesdk')]
-    for line in filelist.splitlines():
-        splitline = line.split()
-        if len(splitline) > 5:
-            fn = splitline[5]
-            if not fn.startswith('./'):
-                fn = './%s' % fn
-            if fn.startswith(sdkpathnative):
-                relpth = '/' + os.path.relpath(fn, sdkpathnative)
-                for bindir in sdkbindirs:
-                    if relpth.startswith(bindir):
-                        relpth = os.path.relpath(relpth, bindir)
-                        if relpth in sanity_required_utilities:
-                            sanity_required_utilities.remove(relpth)
-                        break
-    return ' '.join(sanity_required_utilities)
-
-install_tools() {
-        touch ${SDK_OUTPUT}/${SDKPATH}/.devtoolbase
-
-        # find latest buildtools-tarball and install it
-        if [ -n "${SDK_BUILDTOOLS_INSTALLER}" ]; then
-                install ${SDK_DEPLOY}/${SDK_BUILDTOOLS_INSTALLER} ${SDK_OUTPUT}/${SDKPATH}
-        fi
-
-        install -m 0644 ${COREBASE}/meta/files/ext-sdk-prepare.py ${SDK_OUTPUT}/${SDKPATH}
-}
-do_populate_sdk_ext[file-checksums] += "${COREBASE}/meta/files/ext-sdk-prepare.py:True"
-
-sdk_ext_preinst() {
-        # Since bitbake won't run as root it doesn't make sense to try and install
-        # the extensible sdk as root.
-        if [ "`id -u`" = "0" ]; then
-                echo "ERROR: The extensible sdk cannot be installed as root."
-                exit 1
-        fi
-        if ! command -v locale > /dev/null; then
-                echo "ERROR: The installer requires the locale command, please install it first"
-                exit 1
-        fi
-        # Check setting of LC_ALL set above
-        canonicalised_locale=`echo $LC_ALL | sed 's/UTF-8/utf8/'`
-        if ! locale -a | grep -q $canonicalised_locale ; then
-                echo "ERROR: the installer requires the $LC_ALL locale to be installed (but not selected), please install it first"
-                exit 1
-        fi
-        # The relocation script used by buildtools installer requires python
-        if ! command -v python3 > /dev/null; then
-                echo "ERROR: The installer requires python3, please install it first"
-                exit 1
-        fi
-        missing_utils=""
-        for util in ${SDK_REQUIRED_UTILITIES}; do
-                if ! command -v $util > /dev/null; then
-                        missing_utils="$missing_utils $util"
-                fi
-        done
-        if [ -n "$missing_utils" ] ; then
-                echo "ERROR: the SDK requires the following missing utilities, please install them: $missing_utils"
-                exit 1
-        fi
-        SDK_EXTENSIBLE="1"
-        if [ "$publish" = "1" ] && [ "${SDK_EXT_TYPE}" = "minimal" ] ; then
-                EXTRA_TAR_OPTIONS="$EXTRA_TAR_OPTIONS --exclude=sstate-cache"
-        fi
-}
-SDK_PRE_INSTALL_COMMAND:task-populate-sdk-ext = "${sdk_ext_preinst}"
-
-# FIXME this preparation should be done as part of the SDK construction
-sdk_ext_postinst() {
-        printf "\nExtracting buildtools...\n"
-        cd $target_sdk_dir
-        env_setup_script="$target_sdk_dir/environment-setup-${REAL_MULTIMACH_TARGET_SYS}"
-        if [ -n "${SDK_BUILDTOOLS_INSTALLER}" ]; then
-                printf "buildtools\ny" | ./${SDK_BUILDTOOLS_INSTALLER} > buildtools.log || { printf 'ERROR: buildtools installation failed:\n' ; cat buildtools.log ; echo "printf 'ERROR: this SDK was not fully installed and needs reinstalling\n'" >> $env_setup_script ; exit 1 ; }
-
-                # Delete the buildtools tar file since it won't be used again
-                rm -f ./${SDK_BUILDTOOLS_INSTALLER}
-                # We don't need the log either since it succeeded
-                rm -f buildtools.log
-
-                # Make sure when the user sets up the environment, they also get
-                # the buildtools-tarball tools in their path.
-                echo "# Save and reset OECORE_NATIVE_SYSROOT as buildtools may change it" >> $env_setup_script
-                echo "SAVED=\"\$OECORE_NATIVE_SYSROOT\"" >> $env_setup_script
-                echo ". $target_sdk_dir/buildtools/environment-setup*" >> $env_setup_script
-                echo "export OECORE_NATIVE_SYSROOT=\"\$SAVED\"" >> $env_setup_script
-        fi
-
-        # Allow bitbake environment setup to be ran as part of this sdk.
-        echo "export OE_SKIP_SDK_CHECK=1" >> $env_setup_script
-        # Work around runqemu not knowing how to get this information within the eSDK
-        echo "export DEPLOY_DIR_IMAGE=$target_sdk_dir/tmp/${@os.path.relpath(d.getVar('DEPLOY_DIR_IMAGE'), d.getVar('TMPDIR'))}" >> $env_setup_script
-
-        # A bit of another hack, but we need this in the path only for devtool
-        # so put it at the end of $PATH.
-        echo "export PATH=\"$target_sdk_dir/${esdk_tools_path}:\$PATH\"" >> $env_setup_script
-
-        echo "printf 'SDK environment now set up; additionally you may now run devtool to perform development tasks.\nRun devtool --help for further details.\n'" >> $env_setup_script
-
-        # Warn if trying to use external bitbake and the ext SDK together
-        echo "(which bitbake > /dev/null 2>&1 && echo 'WARNING: attempting to use the extensible SDK in an environment set up to run bitbake - this may lead to unexpected results. Please source this script in a new shell session instead.') || true" >> $env_setup_script
-
-        if [ "$prepare_buildsystem" != "no" -a -n "${SDK_BUILDTOOLS_INSTALLER}" ]; then
-                printf "Preparing build system...\n"
-                # dash which is /bin/sh on Ubuntu will not preserve the
-                # current working directory when first ran, nor will it set $1 when
-                # sourcing a script. That is why this has to look so ugly.
-                LOGFILE="$target_sdk_dir/preparing_build_system.log"
-                sh -c ". buildtools/environment-setup* > $LOGFILE 2>&1 && cd $target_sdk_dir/`dirname ${oe_init_build_env_path}` && set $target_sdk_dir && . $target_sdk_dir/${oe_init_build_env_path} $target_sdk_dir >> $LOGFILE 2>&1 && python3 $target_sdk_dir/ext-sdk-prepare.py $LOGFILE '${SDK_INSTALL_TARGETS}'" || { echo "printf 'ERROR: this SDK was not fully installed and needs reinstalling\n'" >> $env_setup_script ; exit 1 ; }
-        fi
-        if [ -e $target_sdk_dir/ext-sdk-prepare.py ]; then
-                rm $target_sdk_dir/ext-sdk-prepare.py
-        fi
-        echo done
-}
-
-SDK_POST_INSTALL_COMMAND:task-populate-sdk-ext = "${sdk_ext_postinst}"
-
-SDK_POSTPROCESS_COMMAND:prepend:task-populate-sdk-ext = "copy_buildsystem install_tools "
-
-SDK_INSTALL_TARGETS = ""
-fakeroot python do_populate_sdk_ext() {
-    # FIXME hopefully we can remove this restriction at some point, but uninative
-    # currently forces this upon us
-    if d.getVar('SDK_ARCH') != d.getVar('BUILD_ARCH'):
-        bb.fatal('The extensible SDK can currently only be built for the same architecture as the machine being built on - SDK_ARCH is set to %s (likely via setting SDKMACHINE) which is different from the architecture of the build machine (%s). Unable to continue.' % (d.getVar('SDK_ARCH'), d.getVar('BUILD_ARCH')))
-
-    # FIXME hopefully we can remove this restriction at some point, but the eSDK
-    # can only be built for the primary (default) multiconfig
-    if d.getVar('BB_CURRENT_MC') != '':
-        bb.fatal('The extensible SDK can currently only be built for the default multiconfig.  Currently trying to build for %s.' % d.getVar('BB_CURRENT_MC'))
-
-    # eSDK dependencies don't use the traditional variables and things don't work properly if they are set
-    d.setVar("TOOLCHAIN_HOST_TASK", "${TOOLCHAIN_HOST_TASK_ESDK}")
-    d.setVar("TOOLCHAIN_TARGET_TASK", "")
-
-    d.setVar('SDK_INSTALL_TARGETS', get_sdk_install_targets(d))
-    if d.getVar('SDK_INCLUDE_BUILDTOOLS') == '1':
-        buildtools_fn = get_current_buildtools(d)
-    else:
-        buildtools_fn = None
-    d.setVar('SDK_REQUIRED_UTILITIES', get_sdk_required_utilities(buildtools_fn, d))
-    d.setVar('SDK_BUILDTOOLS_INSTALLER', buildtools_fn)
-    d.setVar('SDKDEPLOYDIR', '${SDKEXTDEPLOYDIR}')
-    # ESDKs have a libc from the buildtools so ensure we don't ship linguas twice
-    d.delVar('SDKIMAGE_LINGUAS')
-    if d.getVar("SDK_INCLUDE_NATIVESDK") == '1':
-        generate_nativesdk_lockedsigs(d)
-    populate_sdk_common(d)
-}
-
-def generate_nativesdk_lockedsigs(d):
-    import oe.copy_buildsystem
-    sigfile = d.getVar('WORKDIR') + '/locked-sigs_nativesdk.inc'
-    oe.copy_buildsystem.generate_locked_sigs(sigfile, d)
-
-def get_ext_sdk_depends(d):
-    # Note: the deps varflag is a list not a string, so we need to specify expand=False
-    deps = d.getVarFlag('do_image_complete', 'deps', False)
-    pn = d.getVar('PN')
-    deplist = ['%s:%s' % (pn, dep) for dep in deps]
-    tasklist = bb.build.tasksbetween('do_image_complete', 'do_build', d)
-    tasklist.append('do_rootfs')
-    for task in tasklist:
-        deplist.extend((d.getVarFlag(task, 'depends') or '').split())
-    return ' '.join(deplist)
-
-python do_sdk_depends() {
-    # We have to do this separately in its own task so we avoid recursing into
-    # dependencies we don't need to (e.g. buildtools-tarball) and bringing those
-    # into the SDK's sstate-cache
-    import oe.copy_buildsystem
-    sigfile = d.getVar('WORKDIR') + '/locked-sigs.inc'
-    oe.copy_buildsystem.generate_locked_sigs(sigfile, d)
-}
-addtask sdk_depends
-
-do_sdk_depends[dirs] = "${WORKDIR}"
-do_sdk_depends[depends] = "${@get_ext_sdk_depends(d)} meta-extsdk-toolchain:do_populate_sysroot"
-do_sdk_depends[recrdeptask] = "${@d.getVarFlag('do_populate_sdk', 'recrdeptask', False)}"
-do_sdk_depends[recrdeptask] += "do_populate_lic do_package_qa do_populate_sysroot do_deploy ${SDK_RECRDEP_TASKS}"
-do_sdk_depends[rdepends] = "${@' '.join([x + ':do_package_write_${IMAGE_PKGTYPE} ' + x + ':do_packagedata' for x in d.getVar('TOOLCHAIN_HOST_TASK_ESDK').split()])}"
-
-do_populate_sdk_ext[dirs] = "${@d.getVarFlag('do_populate_sdk', 'dirs', False)}"
-
-do_populate_sdk_ext[depends] = "${@d.getVarFlag('do_populate_sdk', 'depends', False)} \
-                                ${@'buildtools-tarball:do_populate_sdk' if d.getVar('SDK_INCLUDE_BUILDTOOLS') == '1' else ''} \
-                                ${@'meta-world-pkgdata:do_collect_packagedata' if d.getVar('SDK_INCLUDE_PKGDATA') == '1' else ''} \
-                                ${@'meta-extsdk-toolchain:do_locked_sigs' if d.getVar('SDK_INCLUDE_TOOLCHAIN') == '1' else ''}"
-
-# We must avoid depending on do_build here if rm_work.bbclass is active,
-# because otherwise do_rm_work may run before do_populate_sdk_ext itself.
-# We can't mark do_populate_sdk_ext and do_sdk_depends as having to
-# run before do_rm_work, because then they would also run as part
-# of normal builds.
-do_populate_sdk_ext[rdepends] += "${@' '.join([x + ':' + (d.getVar('RM_WORK_BUILD_WITHOUT') or 'do_build') for x in d.getVar('SDK_TARGETS').split()])}"
-
-# Make sure code changes can result in rebuild
-do_populate_sdk_ext[vardeps] += "copy_buildsystem \
-                                 sdk_ext_postinst"
-
-# Since any change in the metadata of any layer should cause a rebuild of the
-# sdk(since the layers are put in the sdk) set the task to nostamp so it
-# always runs.
-do_populate_sdk_ext[nostamp] = "1"
-
-SDKEXTDEPLOYDIR = "${WORKDIR}/deploy-${PN}-populate-sdk-ext"
-
-SSTATETASKS += "do_populate_sdk_ext"
-SSTATE_SKIP_CREATION:task-populate-sdk-ext = '1'
-do_populate_sdk_ext[cleandirs] = "${SDKEXTDEPLOYDIR}"
-do_populate_sdk_ext[sstate-inputdirs] = "${SDKEXTDEPLOYDIR}"
-do_populate_sdk_ext[sstate-outputdirs] = "${SDK_DEPLOY}"
-do_populate_sdk_ext[stamp-extra-info] = "${MACHINE_ARCH}"
-
-addtask populate_sdk_ext after do_sdk_depends
diff --git a/meta/classes-recipe/ptest-cargo.bbclass b/meta/classes-recipe/ptest-cargo.bbclass
deleted file mode 100644
index 30463e117b..0000000000
--- a/meta/classes-recipe/ptest-cargo.bbclass
+++ /dev/null
@@ -1,152 +0,0 @@
-inherit cargo ptest
-
-RUST_TEST_ARGS ??= ""
-RUST_TEST_ARGS[doc] = "Arguments to give to the test binaries (e.g. --shuffle)"
-
-# I didn't find a cleaner way to share data between compile and install tasks
-CARGO_TEST_BINARIES_FILES ?= "${B}/test_binaries_list"
-
-# Sadly, generated test binaries have no deterministic names (https://github.com/rust-lang/cargo/issues/1924)
-# This forces us to parse the cargo output in json format to find those test binaries.
-python do_compile_ptest_cargo() {
-    import subprocess
-    import json
-
-    cargo = bb.utils.which(d.getVar("PATH"), d.getVar("CARGO"))
-    cargo_build_flags = d.getVar("CARGO_BUILD_FLAGS")
-    packageconfig_confargs = d.getVar("PACKAGECONFIG_CONFARGS")
-    rust_flags = d.getVar("RUSTFLAGS")
-    manifest_path = d.getVar("CARGO_MANIFEST_PATH")
-    project_manifest_path = os.path.normpath(manifest_path)
-    manifest_dir = os.path.dirname(manifest_path)
-
-    env = os.environ.copy()
-    env['RUSTFLAGS'] = rust_flags
-    cmd = f"{cargo} build --tests --message-format json {cargo_build_flags} {packageconfig_confargs}"
-    bb.note(f"Building tests with cargo ({cmd})")
-
-    try:
-        proc = subprocess.Popen(cmd, shell=True, env=env, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True)
-    except subprocess.CalledProcessError as e:
-        bb.fatal(f"Cannot build test with cargo: {e}")
-
-    lines = []
-    for line in proc.stdout:
-        data = line.strip('\n')
-        lines.append(data)
-        bb.note(data)
-    proc.communicate()
-    if proc.returncode != 0:
-        bb.fatal(f"Unable to compile test with cargo, '{cmd}' failed")
-
-    # Definition of the format: https://doc.rust-lang.org/cargo/reference/external-tools.html#json-messages
-    test_bins = []
-    for line in lines:
-        try:
-            data = json.loads(line)
-        except json.JSONDecodeError:
-            # skip lines that are not a json
-            pass
-        else:
-            try:
-                # Filter the test packages coming from the current project:
-                #    - test binaries from the root manifest
-                #    - test binaries from sub manifest of the current project if any
-                current_manifest_path = os.path.normpath(data['manifest_path'])
-                common_path = os.path.commonpath([current_manifest_path, project_manifest_path])
-                if common_path in [manifest_dir, current_manifest_path]:
-                    if (data['target']['test'] or data['target']['doctest']) and data['executable']:
-                        test_bins.append(data['executable'])
-            except (KeyError, ValueError) as e:
-                # skip lines that do not meet the requirements
-                pass
-
-    # All rust project will generate at least one unit test binary
-    # It will just run a test suite with 0 tests, if the project didn't define some
-    # So it is not expected to have an empty list here
-    if not test_bins:
-        bb.fatal("Unable to find any test binaries")
-
-    cargo_test_binaries_file = d.getVar('CARGO_TEST_BINARIES_FILES')
-    bb.note(f"Found {len(test_bins)} tests, write their paths into {cargo_test_binaries_file}")
-    with open(cargo_test_binaries_file, "w") as f:
-        for test_bin in sorted(test_bins):
-            f.write(f"{test_bin}\n")
-
-}
-
-python do_install_ptest_cargo() {
-    import shutil
-    import textwrap
-
-    dest_dir = d.getVar("D")
-    pn = d.getVar("PN")
-    ptest_path = d.getVar("PTEST_PATH")
-    cargo_test_binaries_file = d.getVar('CARGO_TEST_BINARIES_FILES')
-    rust_test_args = d.getVar('RUST_TEST_ARGS') or ""
-
-    ptest_dir = os.path.join(dest_dir, ptest_path.lstrip('/'))
-    os.makedirs(ptest_dir, exist_ok=True)
-
-    test_bins = []
-    with open(cargo_test_binaries_file, "r") as f:
-        for line in f.readlines():
-            test_bins.append(line.strip('\n'))
-
-    test_paths = []
-    for test_bin in test_bins:
-        shutil.copy2(test_bin, ptest_dir)
-        test_paths.append(os.path.join(ptest_path, os.path.basename(test_bin)))
-
-    ptest_script = os.path.join(ptest_dir, "run-ptest")
-    script_exists = os.path.exists(ptest_script)
-    with open(ptest_script, "a") as f:
-        if not script_exists:
-            f.write("#!/bin/sh\n")
-        else:
-            f.write(f"\necho \"\"\n")
-            f.write(f"echo \"## starting to run rust tests ##\"\n")               
-        f.write("if [ -z \"$rc\" ]; then rc=0; fi\n")
-        for test_path in test_paths:
-            script = textwrap.dedent(f"""\
-                if ! {test_path} {rust_test_args}
-                then
-                    rc=1
-                    echo "FAIL: {test_path}"
-                else
-                    echo "PASS: {test_path}"
-                fi
-            """)
-            f.write(script)
-        
-        f.write("exit $rc\n")
-
-    if not script_exists:
-        os.chmod(ptest_script, 0o755)
-
-    # this is chown -R root:root ${D}${PTEST_PATH}
-    for root, dirs, files in os.walk(ptest_dir):
-        for d in dirs:
-            shutil.chown(os.path.join(root, d), "root", "root")
-        for f in files:
-            shutil.chown(os.path.join(root, f), "root", "root")
-}
-
-do_install_ptest_cargo[dirs] = "${B}"
-do_install_ptest_cargo[doc] = "Create or update the run-ptest script with rust test binaries generated"
-do_compile_ptest_cargo[dirs] = "${B}"
-do_compile_ptest_cargo[doc] = "Generate rust test binaries through cargo"
-
-addtask compile_ptest_cargo after do_compile            before do_compile_ptest_base
-addtask install_ptest_cargo after do_install_ptest_base before do_package
-
-python () {
-    if not bb.data.inherits_class('native', d) and not bb.data.inherits_class('cross', d):
-        d.setVarFlag('do_install_ptest_cargo', 'fakeroot', '1')
-        d.setVarFlag('do_install_ptest_cargo', 'umask', '022')
-
-    # Remove all '*ptest_cargo' tasks when ptest is not enabled
-    if not(d.getVar('PTEST_ENABLED') == "1"):
-        for i in ['do_compile_ptest_cargo', 'do_install_ptest_cargo']:
-            bb.build.deltask(i, d)
-}
diff --git a/meta/classes-recipe/ptest-gnome.bbclass b/meta/classes-recipe/ptest-gnome.bbclass
deleted file mode 100644
index d4ad22d85d..0000000000
--- a/meta/classes-recipe/ptest-gnome.bbclass
+++ /dev/null
@@ -1,14 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-inherit ptest
-
-EXTRA_OECONF:append = " ${@bb.utils.contains('PTEST_ENABLED', '1', '--enable-installed-tests', '--disable-installed-tests', d)}"
-
-FILES:${PN}-ptest += "${libexecdir}/installed-tests/ \
-                      ${datadir}/installed-tests/"
-
-RDEPENDS:${PN}-ptest += "gnome-desktop-testing"
diff --git a/meta/classes-recipe/ptest-perl.bbclass b/meta/classes-recipe/ptest-perl.bbclass
deleted file mode 100644
index a4a9d40d52..0000000000
--- a/meta/classes-recipe/ptest-perl.bbclass
+++ /dev/null
@@ -1,36 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-inherit ptest
-
-FILESEXTRAPATHS:prepend := "${COREBASE}/meta/files:"
-
-SRC_URI += "file://ptest-perl/run-ptest"
-
-do_install_ptest_perl() {
-        install -d ${D}${PTEST_PATH}
-        if [ ! -f ${D}${PTEST_PATH}/run-ptest ]; then
-                install -m 0755 ${UNPACKDIR}/ptest-perl/run-ptest ${D}${PTEST_PATH}
-        fi
-        cp -r ${B}/t ${D}${PTEST_PATH}
-        chown -R root:root ${D}${PTEST_PATH}
-}
-
-FILES:${PN}-ptest:prepend = "${PTEST_PATH}/t/* ${PTEST_PATH}/run-ptest "
-
-RDEPENDS:${PN}-ptest:prepend = "perl "
-
-addtask install_ptest_perl after do_install_ptest_base before do_package
-
-python () {
-    if not bb.data.inherits_class('native', d) and not bb.data.inherits_class('cross', d):
-        d.setVarFlag('do_install_ptest_perl', 'fakeroot', '1')
-
-    # Remove all '*ptest_perl' tasks when ptest is not enabled
-    if not(d.getVar('PTEST_ENABLED') == "1"):
-        for i in ['do_install_ptest_perl']:
-            bb.build.deltask(i, d)
-}
diff --git a/meta/classes-recipe/ptest-python-pytest.bbclass b/meta/classes-recipe/ptest-python-pytest.bbclass
deleted file mode 100644
index a4615e12bf..0000000000
--- a/meta/classes-recipe/ptest-python-pytest.bbclass
+++ /dev/null
@@ -1,37 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-inherit ptest
-
-# Overridable configuration for the directory within the source tree
-# containing the pytest files
-PTEST_PYTEST_DIR ?= "tests"
-
-do_install_ptest() {
-        # Check if the recipe provides its own version of run-ptest
-        # If nothing exists in the SRC_URI, dynamically create a 
-        # run-test script of "last resort" that has the default
-        # pytest behavior.
-        # 
-        # Users can override this behavior by simply including a
-        # custom script (run-ptest) in the source file list
-        if [ ! -f "${UNPACKDIR}/run-ptest" ]; then
-                cat > ${D}${PTEST_PATH}/run-ptest << EOF
-#!/bin/sh
-pytest --automake
-EOF
-                # Ensure the newly created script has the execute bit set
-                chmod 755 ${D}${PTEST_PATH}/run-ptest
-        fi
-        if [ -d "${S}/${PTEST_PYTEST_DIR}" ]; then
-                install -d ${D}${PTEST_PATH}/${PTEST_PYTEST_DIR}
-                cp -rf ${S}/${PTEST_PYTEST_DIR}/* ${D}${PTEST_PATH}/${PTEST_PYTEST_DIR}/
-        fi
-}
-
-FILES:${PN}-ptest:prepend = "${PTEST_PATH}/*"
-
-RDEPENDS:${PN}-ptest:prepend = "python3-pytest python3-unittest-automake-output "
diff --git a/meta/classes-recipe/ptest.bbclass b/meta/classes-recipe/ptest.bbclass
deleted file mode 100644
index 64c4bb9788..0000000000
--- a/meta/classes-recipe/ptest.bbclass
+++ /dev/null
@@ -1,142 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-SUMMARY:${PN}-ptest ?= "${SUMMARY} - Package test files"
-DESCRIPTION:${PN}-ptest ?= "${DESCRIPTION}  \
-This package contains a test directory ${PTEST_PATH} for package test purposes."
-
-PTEST_PATH ?= "${libdir}/${BPN}/ptest"
-PTEST_BUILD_HOST_FILES ?= "Makefile"
-PTEST_BUILD_HOST_PATTERN ?= ""
-PTEST_PARALLEL_MAKE ?= "${PARALLEL_MAKE}"
-PTEST_PARALLEL_MAKEINST ?= "${PARALLEL_MAKEINST}"
-EXTRA_OEMAKE:prepend:task-compile-ptest-base = "${PTEST_PARALLEL_MAKE} "
-EXTRA_OEMAKE:prepend:task-install-ptest-base = "${PTEST_PARALLEL_MAKEINST} "
-
-FILES:${PN}-ptest += "${PTEST_PATH}"
-SECTION:${PN}-ptest = "devel"
-ALLOW_EMPTY:${PN}-ptest = "1"
-PTEST_ENABLED = "${@bb.utils.contains('DISTRO_FEATURES', 'ptest', '1', '0', d)}"
-PTEST_ENABLED:class-native = ""
-PTEST_ENABLED:class-nativesdk = ""
-PTEST_ENABLED:class-cross-canadian = ""
-RDEPENDS:${PN}-ptest += "${PN}"
-RDEPENDS:${PN}-ptest:class-native = ""
-RDEPENDS:${PN}-ptest:class-nativesdk = ""
-RRECOMMENDS:${PN}-ptest += "ptest-runner"
-
-PACKAGES =+ "${@bb.utils.contains('PTEST_ENABLED', '1', '${PN}-ptest', '', d)}"
-
-require conf/distro/include/ptest-packagelists.inc
-
-do_configure_ptest() {
-    :
-}
-
-do_configure_ptest_base() {
-    do_configure_ptest
-}
-
-do_compile_ptest() {
-    :
-}
-
-do_compile_ptest_base() {
-    do_compile_ptest
-}
-
-do_install_ptest() {
-    :
-}
-
-do_install_ptest_base() {
-    if [ -f ${UNPACKDIR}/run-ptest ]; then
-        install -D ${UNPACKDIR}/run-ptest ${D}${PTEST_PATH}/run-ptest
-    fi
-
-    grep -q install-ptest: Makefile 2>/dev/null && oe_runmake DESTDIR=${D}${PTEST_PATH} install-ptest
-
-    do_install_ptest
-    chown -R root:root ${D}${PTEST_PATH}
-
-    # Strip build host paths from any installed Makefile
-    for filename in ${PTEST_BUILD_HOST_FILES}; do
-        for installed_ptest_file in $(find ${D}${PTEST_PATH} -type f -name $filename); do
-            bbnote "Stripping host paths from: $installed_ptest_file"
-            sed -e 's#${HOSTTOOLS_DIR}/*##g' \
-                -e 's#${WORKDIR}/*=#.=#g' \
-                -e 's#${WORKDIR}/*##g' \
-                -i $installed_ptest_file
-            if [ -n "${PTEST_BUILD_HOST_PATTERN}" ]; then
-               sed -E '/${PTEST_BUILD_HOST_PATTERN}/d' \
-                   -i $installed_ptest_file
-            fi
-        done
-    done
-}
-
-PTEST_BINDIR_PKGD_PATH = "${PKGD}${PTEST_PATH}/bin"
-
-# This function needs to run after apply_update_alternative_renames because the
-# aforementioned function will update the ALTERNATIVE_LINK_NAME flag. Append is
-# used here to make this function to run as late as possible.
-PACKAGE_PREPROCESS_FUNCS:append = "${@bb.utils.contains('PTEST_BINDIR', '1', \
-                                    bb.utils.contains('PTEST_ENABLED', '1', ' ptest_update_alternatives', '', d), '', d)}"
-
-python ptest_update_alternatives() {
-    """
-    This function will generate the symlinks in the PTEST_BINDIR_PKGD_PATH
-    to match the renamed binaries by update-alternatives.
-    """
-
-    if not bb.data.inherits_class('update-alternatives', d) \
-           or not update_alternatives_enabled(d):
-        return
-
-    bb.note("Generating symlinks for ptest")
-    bin_paths = { d.getVar("bindir"), d.getVar("base_bindir"),
-                   d.getVar("sbindir"), d.getVar("base_sbindir") }
-    ptest_bindir = d.getVar("PTEST_BINDIR_PKGD_PATH")
-    os.mkdir(ptest_bindir)
-    for pkg in (d.getVar('PACKAGES') or "").split():
-        alternatives = update_alternatives_alt_targets(d, pkg)
-        for alt_name, alt_link, alt_target, _ in alternatives:
-            # Some alternatives are for man pages,
-            # check if the alternative is in PATH
-            if os.path.dirname(alt_link) in bin_paths:
-                os.symlink(alt_target, os.path.join(ptest_bindir, alt_name))
-}
-
-do_configure_ptest_base[dirs] = "${B}"
-do_compile_ptest_base[dirs] = "${B}"
-do_install_ptest_base[dirs] = "${B}"
-do_install_ptest_base[cleandirs] = "${D}${PTEST_PATH}"
-
-addtask configure_ptest_base after do_configure before do_compile
-addtask compile_ptest_base   after do_compile   before do_install
-addtask install_ptest_base   after do_install   before do_package do_populate_sysroot
-
-python () {
-    if not bb.data.inherits_class('native', d) and not bb.data.inherits_class('cross', d):
-        d.setVarFlag('do_install_ptest_base', 'fakeroot', '1')
-        d.setVarFlag('do_install_ptest_base', 'umask', '022')
-
-    # Remove all '*ptest_base' tasks when ptest is not enabled
-    if not(d.getVar('PTEST_ENABLED') == "1"):
-        for i in ['do_configure_ptest_base', 'do_compile_ptest_base', 'do_install_ptest_base']:
-            bb.build.deltask(i, d)
-}
-
-QARECIPETEST[missing-ptest] = "package_qa_check_missing_ptest"
-def package_qa_check_missing_ptest(pn, d):
-    # This checks that ptest package is actually included
-    # in standard oe-core ptest images - only for oe-core recipes
-    if not 'meta/recipes' in d.getVar('FILE') or not(d.getVar('PTEST_ENABLED') == "1"):
-        return
-
-    enabled_ptests = " ".join([d.getVar('PTESTS_FAST'), d.getVar('PTESTS_SLOW'), d.getVar('PTESTS_PROBLEMS')]).split()
-    if pn.replace(d.getVar('MLPREFIX'), '') not in enabled_ptests:
-        oe.qa.handle_error("missing-ptest", "supports ptests but is not included in oe-core's ptest-packagelists.inc", d)
diff --git a/meta/classes-recipe/pypi.bbclass b/meta/classes-recipe/pypi.bbclass
deleted file mode 100644
index 1372d85e8d..0000000000
--- a/meta/classes-recipe/pypi.bbclass
+++ /dev/null
@@ -1,57 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-def pypi_package(d):
-    bpn = d.getVar('BPN')
-    if bpn.startswith('python-'):
-        return bpn[7:]
-    elif bpn.startswith('python3-'):
-        return bpn[8:]
-    return bpn
-
-# The PyPi package name (defaults to PN without the python3- prefix)
-PYPI_PACKAGE ?= "${@pypi_package(d)}"
-# The file extension of the source archive
-PYPI_PACKAGE_EXT ?= "tar.gz"
-# An optional prefix for the download file in the case of name collisions
-PYPI_ARCHIVE_NAME_PREFIX ?= ""
-
-def pypi_src_uri(d):
-    """
-    Construct a source URL as per https://warehouse.pypa.io/api-reference/integration-guide.html#predictable-urls.
-    """
-    package = d.getVar('PYPI_PACKAGE')
-    archive_name = d.expand('${PYPI_PACKAGE}-${PV}.${PYPI_PACKAGE_EXT}')
-    archive_downloadname = d.getVar('PYPI_ARCHIVE_NAME_PREFIX') + archive_name
-    return 'https://files.pythonhosted.org/packages/source/%s/%s/%s;downloadfilename=%s' % (package[0], package, archive_name, archive_downloadname)
-
-def pypi_normalize(d):
-    """"
-        Normalize the package names to match PEP625 (https://peps.python.org/pep-0625/).
-        For non-compliant packages, maintainers can set UPSTREAM_CHECK_PYPI_PACKAGE to override the normalization
-    """
-    import re
-    return re.sub(r"[-_.]+", "-", d.getVar('PYPI_PACKAGE')).lower()
-
-PYPI_SRC_URI ?= "${@pypi_src_uri(d)}"
-
-HOMEPAGE ?= "https://pypi.python.org/pypi/${PYPI_PACKAGE}/"
-SECTION = "devel/python"
-SRC_URI:prepend = "${PYPI_SRC_URI} "
-S = "${UNPACKDIR}/${PYPI_PACKAGE}-${PV}"
-
-# Replace any '_' characters in the pypi URI with '-'s to follow the PyPi website naming conventions
-UPSTREAM_CHECK_PYPI_PACKAGE ?= "${@pypi_normalize(d)}"
-
-# Use the simple repository API rather than the potentially unstable project URL
-# More information on the pypi API specification is avaialble here:
-# https://packaging.python.org/en/latest/specifications/simple-repository-api/
-#
-# NOTE: All URLs for the simple API MUST request canonical normalized URLs per the spec
-UPSTREAM_CHECK_URI ?= "https://pypi.org/simple/${@pypi_normalize(d)}/"
-UPSTREAM_CHECK_REGEX ?= "${UPSTREAM_CHECK_PYPI_PACKAGE}-(?P<pver>(\d+[\.\-_]*)+).(tar\.gz|tgz|zip|tar\.bz2)"
-
-CVE_PRODUCT ?= "python:${PYPI_PACKAGE}"
diff --git a/meta/classes-recipe/python3-dir.bbclass b/meta/classes-recipe/python3-dir.bbclass
deleted file mode 100644
index 0f4e7e7773..0000000000
--- a/meta/classes-recipe/python3-dir.bbclass
+++ /dev/null
@@ -1,11 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-PYTHON_BASEVERSION = "3.13"
-PYTHON_ABI = ""
-PYTHON_DIR = "python${PYTHON_BASEVERSION}"
-PYTHON_PN = "python3"
-PYTHON_SITEPACKAGES_DIR = "${libdir}/${PYTHON_DIR}/site-packages"
diff --git a/meta/classes-recipe/python3native.bbclass b/meta/classes-recipe/python3native.bbclass
deleted file mode 100644
index da1283d6b3..0000000000
--- a/meta/classes-recipe/python3native.bbclass
+++ /dev/null
@@ -1,30 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-inherit python3-dir
-
-PYTHON = "${STAGING_BINDIR_NATIVE}/python3-native/python3"
-EXTRANATIVEPATH += "python3-native"
-DEPENDS:append = " python3-native "
-
-# python-config and other scripts are using sysconfig modules
-# which we patch to access these variables
-export STAGING_INCDIR
-export STAGING_LIBDIR
-
-# Packages can use
-# find_package(PythonInterp REQUIRED)
-# find_package(PythonLibs REQUIRED)
-# which ends up using libs/includes from build host
-# Therefore pre-empt that effort
-export PYTHON_LIBRARY = "${STAGING_LIBDIR}/lib${PYTHON_DIR}${PYTHON_ABI}.so"
-export PYTHON_INCLUDE_DIR = "${STAGING_INCDIR}/${PYTHON_DIR}${PYTHON_ABI}"
-
-# suppress host user's site-packages dirs.
-export PYTHONNOUSERSITE = "1"
-
-# autoconf macros will use their internal default preference otherwise
-export PYTHON
diff --git a/meta/classes-recipe/python3targetconfig.bbclass b/meta/classes-recipe/python3targetconfig.bbclass
deleted file mode 100644
index 08bc619398..0000000000
--- a/meta/classes-recipe/python3targetconfig.bbclass
+++ /dev/null
@@ -1,41 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-inherit python3native
-
-EXTRA_PYTHON_DEPENDS ?= ""
-EXTRA_PYTHON_DEPENDS:class-target = "python3"
-DEPENDS:append = " ${EXTRA_PYTHON_DEPENDS}"
-
-setup_target_config() {
-        export _PYTHON_SYSCONFIGDATA_NAME="_sysconfigdata"
-        export PYTHONPATH=${STAGING_LIBDIR}/python-sysconfigdata:$PYTHONPATH
-        export PATH=${STAGING_EXECPREFIXDIR}/python-target-config/:$PATH
-}
-
-do_configure:prepend:class-target() {
-        setup_target_config
-}
-
-do_compile:prepend:class-target() {
-        setup_target_config
-}
-
-do_install:prepend:class-target() {
-        setup_target_config
-}
-
-do_configure:prepend:class-nativesdk() {
-        setup_target_config
-}
-
-do_compile:prepend:class-nativesdk() {
-        setup_target_config
-}
-
-do_install:prepend:class-nativesdk() {
-        setup_target_config
-}
diff --git a/meta/classes-recipe/python_flit_core.bbclass b/meta/classes-recipe/python_flit_core.bbclass
deleted file mode 100644
index cb40ab0faf..0000000000
--- a/meta/classes-recipe/python_flit_core.bbclass
+++ /dev/null
@@ -1,14 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-inherit python_pep517
-
-DEPENDS += "python3-flit-core-native"
-
-python_flit_core_do_manual_build () {
-    cd ${PEP517_SOURCE_PATH}
-    nativepython3 -m flit_core.wheel --outdir ${PEP517_WHEEL_PATH} .
-}
diff --git a/meta/classes-recipe/python_hatchling.bbclass b/meta/classes-recipe/python_hatchling.bbclass
deleted file mode 100644
index 6765ddbe8c..0000000000
--- a/meta/classes-recipe/python_hatchling.bbclass
+++ /dev/null
@@ -1,27 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-inherit python_pep517
-
-DEPENDS += "python3-hatchling-native"
-
-# delete nested, empty directories from the python site-packages path. Make
-# sure that we remove the native ones for target builds as well
-hatchling_rm_emptydirs:class-target () {
-        find ${STAGING_LIBDIR}/${PYTHON_DIR}/site-packages/* -depth -type d -empty -delete
-        find ${STAGING_LIBDIR_NATIVE}/${PYTHON_DIR}/site-packages/* -depth -type d -empty -delete
-}
-
-hatchling_rm_emptydirs:class-native () {
-        find ${STAGING_LIBDIR_NATIVE}/${PYTHON_DIR}/site-packages/* -depth -type d -empty -delete
-}
-
-# Define a default empty version of hatchling_rm_emptydirs to appease bitbake
-hatchling_rm_emptydirs () {
-        :
-}
-
-do_prepare_recipe_sysroot[postfuncs] += " hatchling_rm_emptydirs"
diff --git a/meta/classes-recipe/python_maturin.bbclass b/meta/classes-recipe/python_maturin.bbclass
deleted file mode 100644
index 5892bf5ecd..0000000000
--- a/meta/classes-recipe/python_maturin.bbclass
+++ /dev/null
@@ -1,17 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-inherit python_pyo3 python_pep517
-
-DEPENDS += "python3-maturin-native"
-
-python_maturin_do_configure() {
-    python_pyo3_do_configure
-    cargo_common_do_configure
-    python_pep517_do_configure
-}
-
-EXPORT_FUNCTIONS do_configure
diff --git a/meta/classes-recipe/python_mesonpy.bbclass b/meta/classes-recipe/python_mesonpy.bbclass
deleted file mode 100644
index 3613ea19c7..0000000000
--- a/meta/classes-recipe/python_mesonpy.bbclass
+++ /dev/null
@@ -1,46 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-inherit meson python_pep517
-
-# meson_do_qa_configure does the wrong thing here because
-# mesonpy runs "meson setup ..." in do_compile context.
-# Make it a dummy function.
-meson_do_qa_configure () {
-    :
-}
-
-# This prevents the meson error:
-# ERROR: Got argument buildtype as both -Dbuildtype and --buildtype. Pick one.
-MESONOPTS:remove = "--buildtype ${MESON_BUILDTYPE}"
-
-DEPENDS += "python3-wheel-native python3-meson-python-native"
-
-def mesonpy_get_args(d):
-    vars = ['MESONOPTS', 'MESON_CROSS_FILE', 'EXTRA_OEMESON']
-    varlist = []
-    for var in vars:
-        value = d.getVar(var)
-        vallist = value.split()
-        for elem in vallist:
-            varlist.append("-Csetup-args=" + elem)
-    return ' '.join(varlist)
-
-PEP517_BUILD_OPTS = "-Cbuilddir='${B}' ${@mesonpy_get_args(d)}"
-
-python_mesonpy_do_configure () {
-    python_pep517_do_configure
-}
-
-python_mesonpy_do_compile () {
-    python_pep517_do_compile
-}
-
-python_mesonpy_do_install () {
-    python_pep517_do_install
-}
-
-EXPORT_FUNCTIONS do_configure do_compile do_install
diff --git a/meta/classes-recipe/python_pdm.bbclass b/meta/classes-recipe/python_pdm.bbclass
deleted file mode 100644
index 9a34d98422..0000000000
--- a/meta/classes-recipe/python_pdm.bbclass
+++ /dev/null
@@ -1,9 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-inherit python_pep517
-
-DEPENDS += "python3-pdm-backend-native"
diff --git a/meta/classes-recipe/python_pep517.bbclass b/meta/classes-recipe/python_pep517.bbclass
deleted file mode 100644
index 128c943794..0000000000
--- a/meta/classes-recipe/python_pep517.bbclass
+++ /dev/null
@@ -1,68 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-# Common infrastructure for Python packages that use PEP-517 compliant packaging.
-# https://www.python.org/dev/peps/pep-0517/
-#
-# This class will build a wheel in do_compile, and use pypa/installer to install
-# it in do_install.
-
-inherit python3native python3-dir setuptools3-base
-
-DEPENDS:append = " python3-build-native python3-installer-native"
-
-# Where to execute the build process from
-PEP517_SOURCE_PATH ?= "${S}"
-
-# The directory where wheels will be written
-PEP517_WHEEL_PATH ?= "${WORKDIR}/dist"
-
-# Other options to pass to build
-PEP517_BUILD_OPTS ?= ""
-
-# The interpreter to use for installed scripts
-PEP517_INSTALL_PYTHON = "python3"
-PEP517_INSTALL_PYTHON:class-native = "nativepython3"
-
-# pypa/installer option to control the bytecode compilation
-INSTALL_WHEEL_COMPILE_BYTECODE ?= "--compile-bytecode=0"
-
-# PEP517 doesn't have a specific configure step, so set an empty do_configure to avoid
-# running base_do_configure.
-python_pep517_do_configure () {
-    :
-}
-
-# When we have Python 3.11 we can parse pyproject.toml to determine the build
-# API entry point directly
-python_pep517_do_compile () {
-    pyproject-build --no-isolation --wheel --outdir ${PEP517_WHEEL_PATH} ${PEP517_SOURCE_PATH} ${PEP517_BUILD_OPTS}
-}
-do_compile[cleandirs] += "${PEP517_WHEEL_PATH}"
-
-python_pep517_do_install () {
-    COUNT=$(find ${PEP517_WHEEL_PATH} -name '*.whl' -maxdepth 1 | wc -l)
-    if test $COUNT -eq 0; then
-        bbfatal No wheels found in ${PEP517_WHEEL_PATH}
-    elif test $COUNT -gt 1; then
-        bbfatal More than one wheel found in ${PEP517_WHEEL_PATH}, this should not happen
-    fi
-
-    nativepython3 -m installer ${INSTALL_WHEEL_COMPILE_BYTECODE} --interpreter "${USRBINPATH}/env ${PEP517_INSTALL_PYTHON}" --destdir=${D} ${PEP517_WHEEL_PATH}/*.whl
-
-    find ${D} -path *.dist-info/RECORD -delete
-}
-
-# A manual do_install that just uses unzip for bootstrapping purposes. Callers should DEPEND on unzip-native.
-python_pep517_do_bootstrap_install () {
-    install -d ${D}${PYTHON_SITEPACKAGES_DIR}
-    unzip -d ${D}${PYTHON_SITEPACKAGES_DIR} ${PEP517_WHEEL_PATH}/*.whl
-}
-
-EXPORT_FUNCTIONS do_configure do_compile do_install
-
-# Tell externalsrc this changing means it needs to reconfigure
-CONFIGURE_FILES += "pyproject.toml"
diff --git a/meta/classes-recipe/python_poetry_core.bbclass b/meta/classes-recipe/python_poetry_core.bbclass
deleted file mode 100644
index 35a2f137cb..0000000000
--- a/meta/classes-recipe/python_poetry_core.bbclass
+++ /dev/null
@@ -1,9 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-inherit python_pep517
-
-DEPENDS += "python3-poetry-core-native"
diff --git a/meta/classes-recipe/python_pyo3.bbclass b/meta/classes-recipe/python_pyo3.bbclass
deleted file mode 100644
index 7f5a00f584..0000000000
--- a/meta/classes-recipe/python_pyo3.bbclass
+++ /dev/null
@@ -1,36 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-#
-# This class helps make sure that Python extensions built with PyO3
-# and setuptools_rust properly set up the environment for cross compilation
-#
-
-inherit cargo python3-dir siteinfo
-
-export PYO3_CROSS = "1"
-export PYO3_CROSS_PYTHON_VERSION = "${PYTHON_BASEVERSION}"
-export PYO3_CROSS_LIB_DIR = "${STAGING_LIBDIR}"
-export CARGO_BUILD_TARGET = "${RUST_HOST_SYS}"
-export RUSTFLAGS
-export PYO3_PYTHON = "${PYTHON}"
-export PYO3_CONFIG_FILE = "${WORKDIR}/pyo3.config"
-
-python_pyo3_do_configure () {
-    cat > ${WORKDIR}/pyo3.config << EOF
-implementation=CPython
-version=${PYTHON_BASEVERSION}
-shared=true
-abi3=false
-lib_name=${PYTHON_DIR}
-lib_dir=${STAGING_LIBDIR}
-pointer_width=${SITEINFO_BITS}
-build_flags=WITH_THREAD
-suppress_build_script_link_lines=false
-EOF
-}
-
-EXPORT_FUNCTIONS do_configure
diff --git a/meta/classes-recipe/python_setuptools3_rust.bbclass b/meta/classes-recipe/python_setuptools3_rust.bbclass
deleted file mode 100644
index d3d7590cbe..0000000000
--- a/meta/classes-recipe/python_setuptools3_rust.bbclass
+++ /dev/null
@@ -1,17 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-inherit python_pyo3 python_setuptools_build_meta
-
-DEPENDS += "python3-setuptools-rust-native"
-
-python_setuptools3_rust_do_configure() {
-    python_pyo3_do_configure
-    cargo_common_do_configure
-    python_pep517_do_configure
-}
-
-EXPORT_FUNCTIONS do_configure
diff --git a/meta/classes-recipe/python_setuptools_build_meta.bbclass b/meta/classes-recipe/python_setuptools_build_meta.bbclass
deleted file mode 100644
index c7b12e5309..0000000000
--- a/meta/classes-recipe/python_setuptools_build_meta.bbclass
+++ /dev/null
@@ -1,9 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-inherit python_pep517
-
-DEPENDS += "python3-setuptools-native python3-wheel-native"
diff --git a/meta/classes-recipe/qemu.bbclass b/meta/classes-recipe/qemu.bbclass
deleted file mode 100644
index f83faf8049..0000000000
--- a/meta/classes-recipe/qemu.bbclass
+++ /dev/null
@@ -1,28 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-#
-# This class contains functions for recipes that need QEMU or test for its
-# existence.
-#
-
-def qemu_target_binary(data):
-    return oe.qemu.qemu_target_binary(data)
-
-def qemu_wrapper_cmdline(data, rootfs_path, library_paths):
-    return oe.qemu.qemu_wrapper_cmdline(data, rootfs_path, library_paths)
-
-def qemu_run_binary(data, rootfs_path, binary):
-    return oe.qemu.qemu_run_binary(data, rootfs_path, binary)
-
-# QEMU_EXTRAOPTIONS is not meant to be directly used, the extensions are
-# PACKAGE_ARCH, *NOT* overrides.
-# In some cases (e.g. ppc) simply being arch specific (apparently) isn't good
-# enough and a PACKAGE_ARCH specific -cpu option is needed (hence we have to do
-# this dance). For others (e.g. arm) a -cpu option is not necessary, since the
-# qemu-arm default CPU supports all required architecture levels.
-QEMU_OPTIONS = "-r ${OLDEST_KERNEL} ${@d.getVar("QEMU_EXTRAOPTIONS:tune-%s" % d.getVar('TUNE_PKGARCH')) or ""}"
-QEMU_OPTIONS[vardeps] += "QEMU_EXTRAOPTIONS:tune-${TUNE_PKGARCH}"
diff --git a/meta/classes-recipe/qemuboot.bbclass b/meta/classes-recipe/qemuboot.bbclass
deleted file mode 100644
index 69cd12ec54..0000000000
--- a/meta/classes-recipe/qemuboot.bbclass
+++ /dev/null
@@ -1,190 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-# Help runqemu boot target board, "QB" means Qemu Boot, the following
-# vars can be set in conf files, such as <bsp.conf> to make it can be
-# boot by runqemu:
-#
-# QB_SYSTEM_NAME: qemu name, e.g., "qemu-system-i386"
-#
-# QB_OPT_APPEND: options to append to qemu, e.g., "-device usb-mouse"
-#
-# QB_DEFAULT_KERNEL: default kernel to boot, e.g., "bzImage"
-#                                            e.g., "bzImage-initramfs-qemux86-64.bin" if INITRAMFS_IMAGE_BUNDLE is set to 1.
-#
-# QB_DEFAULT_FSTYPE: default FSTYPE to boot, e.g., "ext4"
-#
-# QB_MEM: memory, e.g., "-m 512"
-#
-# QB_MACHINE: qemu machine, e.g., "-machine virt"
-#
-# QB_CPU: qemu cpu, e.g., "-cpu qemu32"
-#
-# QB_CPU_KVM: the similar to QB_CPU, but used when kvm, e.g., '-cpu kvm64',
-#             set it when support kvm.
-#
-# QB_SMP: amount of CPU cores inside qemu guest, each mapped to a thread on the host,
-#             e.g. "-smp 8".
-#
-# QB_KERNEL_CMDLINE_APPEND: options to append to kernel's -append
-#                           option, e.g., "console=ttyS0 console=tty"
-#
-# QB_DTB: qemu dtb name
-#
-# QB_AUDIO_DRV: qemu audio driver, e.g., "alsa", set it when support audio
-#
-# QB_AUDIO_OPT: qemu audio option, e.g., "-device AC97", used
-#               when QB_AUDIO_DRV is set.
-#
-# QB_RNG: Pass-through for host random number generator, it can speedup boot
-#         in system mode, where system is experiencing entropy starvation
-#
-# QB_KERNEL_ROOT: kernel's root, e.g., /dev/vda
-#                 By default "/dev/vda rw" gets passed to the kernel.
-#                 To mount the rootfs read-only QB_KERNEL_ROOT can be set to e.g. "/dev/vda ro".
-#
-# QB_NETWORK_DEVICE: network device, e.g., "-device virtio-net-pci,netdev=net0,mac=@MAC@",
-#                    it needs work with QB_TAP_OPT and QB_SLIRP_OPT.
-#                    Note, runqemu will replace @MAC@ with a predefined mac, you can set
-#                    a custom one, but that may cause conflicts when multiple qemus are
-#                    running on the same host.
-#                    Note: If more than one interface of type -device virtio-net-device gets added,
-#                          QB_NETWORK_DEVICE:prepend might be used, since Qemu enumerates the eth*
-#                          devices in reverse order to -device arguments.
-#
-# QB_TAP_OPT: network option for 'tap' mode, e.g.,
-#             "-netdev tap,id=net0,ifname=@TAP@,script=no,downscript=no"
-#              Note, runqemu will replace "@TAP@" with the one which is used, such as tap0, tap1 ...
-#
-# QB_SLIRP_OPT: network option for SLIRP mode, e.g., -netdev user,id=net0"
-#
-# QB_CMDLINE_IP_SLIRP: If QB_NETWORK_DEVICE adds more than one network interface to qemu, usually the
-#                      ip= kernel command line argument needs to be changed accordingly. Details are documented
-#                      in the kernel documentation https://www.kernel.org/doc/Documentation/filesystems/nfs/nfsroot.txt
-#                      Example to configure only the first interface: "ip=eth0:dhcp"
-# QB_CMDLINE_IP_TAP: This parameter is similar to the QB_CMDLINE_IP_SLIRP parameter. Since the tap interface requires
-#                    static IP configuration @CLIENT@ and @GATEWAY@ place holders are replaced by the IP and the gateway
-#                    address of the qemu guest by runqemu.
-#                    Example: "ip=192.168.7.@CLIENT@::192.168.7.@GATEWAY@:255.255.255.0::eth0"
-#
-# QB_ROOTFS_OPT: used as rootfs, e.g.,
-#               "-drive id=disk0,file=@ROOTFS@,if=none,format=raw -device virtio-blk-device,drive=disk0"
-#              Note, runqemu will replace "@ROOTFS@" with the one which is used, such as core-image-minimal-qemuarm64.ext4.
-#
-# QB_SERIAL_OPT: serial port, e.g., "-serial mon:stdio"
-#
-# QB_TCPSERIAL_OPT: tcp serial port option, e.g.,
-#                   " -device virtio-serial-device -chardev socket,id=virtcon,port=@PORT@,host=127.0.0.1 -device virtconsole,chardev=virtcon"
-#                   Note, runqemu will replace "@PORT@" with the port number which is used.
-#
-# QB_ROOTFS_EXTRA_OPT: extra options to be appended to the rootfs device in case there is none specified by QB_ROOTFS_OPT.
-#                      Can be used to automatically determine the image from the other variables
-#                      but define things link 'bootindex' when booting from EFI or 'readonly' when using squashfs
-#                      without the need to specify a dedicated qemu configuration
-#
-# QB_GRAPHICS: QEMU video card type (e.g. "-vga std")
-# QB_NFSROOTFS_EXTRA_OPT: extra options to be appended to the nfs rootfs options in kernel boot arg, e.g.,
-#                         "wsize=4096,rsize=4096"
-#
-# Usage:
-# IMAGE_CLASSES += "qemuboot"
-# See "runqemu help" for more info
-
-QB_MEM ?= "-m 256"
-QB_SMP ?= ""
-QB_SERIAL_OPT ?= "-serial mon:stdio -serial null"
-QB_DEFAULT_KERNEL ?= "${@bb.utils.contains("INITRAMFS_IMAGE_BUNDLE", "1", "${KERNEL_IMAGETYPE}-${INITRAMFS_LINK_NAME}.bin", "${KERNEL_IMAGETYPE}", d)}"
-QB_DEFAULT_FSTYPE ?= "ext4.zst"
-QB_RNG ?= "-object rng-random,filename=/dev/urandom,id=rng0 -device virtio-rng-pci,rng=rng0"
-QB_OPT_APPEND ?= ""
-QB_NETWORK_DEVICE ?= "-device virtio-net-pci,netdev=net0,mac=@MAC@"
-
-# qemurunner needs ip information first, so append QB_NO_PNI
-#
-QB_NO_PNI ?= "${@bb.utils.contains('DISTRO_FEATURES', 'pni-names', '', 'net.ifnames=0', d)}"
-QB_CMDLINE_IP_SLIRP ?= "ip=dhcp"
-QB_CMDLINE_IP_TAP ?= "ip=192.168.7.@CLIENT@::192.168.7.@GATEWAY@:255.255.255.0::eth0:off:8.8.8.8 ${QB_NO_PNI}"
-
-QB_ROOTFS_EXTRA_OPT ?= ""
-QB_GRAPHICS ?= ""
-QB_NFSROOTFS_EXTRA_OPT ?= ""
-
-# With 6.5+ (specifically, if DMA_BOUNCE_UNALIGNED_KMALLOC is set) the SW IO TLB
-# is used, and it defaults to 64MB. This is too much when there's only 256MB of
-# RAM, so request 0 slabs and lets the kernel round up to the appropriate minimum
-# (1MB, typically). In virtual hardware there's very little need for these bounce
-# buffers, so the 64MB would be mostly wasted.
-QB_KERNEL_CMDLINE_APPEND:append = " swiotlb=0"
-
-# This should be kept align with ROOT_VM
-QB_DRIVE_TYPE ?= "/dev/sd"
-
-inherit image-artifact-names
-
-# Create qemuboot.conf
-addtask do_write_qemuboot_conf after do_rootfs before do_image
-
-def qemuboot_vars(d):
-    build_vars = ['MACHINE', 'TUNE_ARCH', 'DEPLOY_DIR_IMAGE',
-                'KERNEL_IMAGETYPE', 'KERNEL_IMAGE_NAME',
-                'KERNEL_IMAGE_BIN_EXT', 'IMAGE_NAME', 'IMAGE_LINK_NAME',
-                'STAGING_DIR_NATIVE', 'STAGING_BINDIR_NATIVE',
-                'STAGING_DIR_HOST', 'SERIAL_CONSOLES', 'UNINATIVE_LOADER']
-    return build_vars + [k for k in d.keys() if k.startswith('QB_')]
-
-do_write_qemuboot_conf[vardeps] += "${@' '.join(qemuboot_vars(d))}"
-do_write_qemuboot_conf[vardepsexclude] += "TOPDIR"
-python do_write_qemuboot_conf() {
-    import configparser
-
-    qemuboot = "%s/%s.qemuboot.conf" % (d.getVar('IMGDEPLOYDIR'), d.getVar('IMAGE_NAME'))
-    if d.getVar('IMAGE_LINK_NAME'):
-        qemuboot_link = "%s/%s.qemuboot.conf" % (d.getVar('IMGDEPLOYDIR'), d.getVar('IMAGE_LINK_NAME'))
-    else:
-        qemuboot_link = ""
-    finalpath = d.getVar("DEPLOY_DIR_IMAGE")
-    topdir = d.getVar('TOPDIR')
-    cf = configparser.ConfigParser()
-    cf.add_section('config_bsp')
-    for k in sorted(qemuboot_vars(d)):
-        if ":" in k:
-            continue
-        # qemu-helper-native sysroot is not removed by rm_work and
-        # contains all tools required by runqemu
-        if k == 'STAGING_BINDIR_NATIVE':
-            val = os.path.join(d.getVar('BASE_WORKDIR'), d.getVar('BUILD_SYS'),
-                               'qemu-helper-native/1.0/recipe-sysroot-native/usr/bin/')
-        else:
-            val = d.getVar(k)
-        if val is None:
-            continue
-        # we only want to write out relative paths so that we can relocate images
-        # and still run them
-        if val.startswith(topdir):
-            val = os.path.relpath(val, finalpath)
-        cf.set('config_bsp', k, '%s' % val)
-
-    # QB_DEFAULT_KERNEL's value of KERNEL_IMAGETYPE is the name of a symlink
-    # to the kernel file, which hinders relocatability of the qb conf.
-    # Read the link and replace it with the full filename of the target.
-    kernel_link = os.path.join(d.getVar('DEPLOY_DIR_IMAGE'), d.getVar('QB_DEFAULT_KERNEL'))
-    kernel = os.path.realpath(kernel_link)
-    # we only want to write out relative paths so that we can relocate images
-    # and still run them
-    kernel = os.path.relpath(kernel, finalpath)
-    cf.set('config_bsp', 'QB_DEFAULT_KERNEL', kernel)
-
-    bb.utils.mkdirhier(os.path.dirname(qemuboot))
-    with open(qemuboot, 'w') as f:
-        cf.write(f)
-
-    if qemuboot_link and qemuboot_link != qemuboot:
-        if os.path.lexists(qemuboot_link):
-           os.remove(qemuboot_link)
-        os.symlink(os.path.basename(qemuboot), qemuboot_link)
-}
-
-EXTRA_IMAGEDEPENDS += "qemu-system-native qemu-helper-native:do_addto_recipe_sysroot"
diff --git a/meta/classes-recipe/rootfs-postcommands.bbclass b/meta/classes-recipe/rootfs-postcommands.bbclass
deleted file mode 100644
index 8b5822a0b5..0000000000
--- a/meta/classes-recipe/rootfs-postcommands.bbclass
+++ /dev/null
@@ -1,566 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-# Zap the root password if empty-root-password feature is not enabled
-ROOTFS_POSTPROCESS_COMMAND += '${@bb.utils.contains("IMAGE_FEATURES", "empty-root-password", "", "zap_empty_root_password ",d)}'
-
-# Allow dropbear/openssh to accept logins from accounts with an empty password string if allow-empty-password is enabled
-ROOTFS_POSTPROCESS_COMMAND += '${@bb.utils.contains("IMAGE_FEATURES", "allow-empty-password", "ssh_allow_empty_password ", "",d)}'
-
-# Allow dropbear/openssh to accept root logins if allow-root-login is enabled
-ROOTFS_POSTPROCESS_COMMAND += '${@bb.utils.contains("IMAGE_FEATURES", "allow-root-login", "ssh_allow_root_login ", "",d)}'
-
-# Autologin the root user on the serial console, if empty-root-password and serial-autologin-root are active
-ROOTFS_POSTPROCESS_COMMAND += '${@bb.utils.contains("IMAGE_FEATURES", [ 'empty-root-password', 'serial-autologin-root' ], "serial_autologin_root ", "",d)}'
-
-# Enable postinst logging if post-install-logging is enabled
-ROOTFS_POSTPROCESS_COMMAND += '${@bb.utils.contains("IMAGE_FEATURES", "post-install-logging", "postinst_enable_logging ", "",d)}'
-
-# Create /etc/timestamp during image construction to give a reasonably sane default time setting
-ROOTFS_POSTPROCESS_COMMAND += "rootfs_update_timestamp "
-
-# Tweak files in /etc if read-only-rootfs is enabled
-ROOTFS_POSTPROCESS_COMMAND += '${@bb.utils.contains("IMAGE_FEATURES", "read-only-rootfs", "read_only_rootfs_hook ", "",d)}'
-
-# We also need to do the same for the kernel boot parameters,
-# otherwise kernel or initramfs end up mounting the rootfs read/write
-# (the default) if supported by the underlying storage.
-#
-# We do this with :append because the default value might get set later with ?=
-# and we don't want to disable such a default that by setting a value here.
-APPEND:append = '${@bb.utils.contains("IMAGE_FEATURES", "read-only-rootfs", " ro", "", d)}'
-
-# Generates test data file with data store variables expanded in json format
-ROOTFS_POSTPROCESS_COMMAND += "write_image_test_data "
-
-# Write manifest
-IMAGE_MANIFEST = "${IMGDEPLOYDIR}/${IMAGE_NAME}.manifest"
-ROOTFS_POSTUNINSTALL_COMMAND =+ "write_image_manifest"
-# Set default postinst log file
-POSTINST_LOGFILE ?= "${localstatedir}/log/postinstall.log"
-# Set default target for systemd images
-SYSTEMD_DEFAULT_TARGET ?= '${@bb.utils.contains_any("IMAGE_FEATURES", [ "x11-base", "weston" ], "graphical.target", "multi-user.target", d)}'
-ROOTFS_POSTPROCESS_COMMAND += '${@bb.utils.contains("DISTRO_FEATURES", "systemd", "set_systemd_default_target systemd_sysusers_check systemd_handle_machine_id", "", d)}'
-
-ROOTFS_POSTPROCESS_COMMAND += 'empty_var_volatile'
-
-ROOTFS_POSTPROCESS_COMMAND += '${@bb.utils.contains("DISTRO_FEATURES", "overlayfs", "overlayfs_qa_check overlayfs_postprocess", "", d)}'
-
-inherit image-artifact-names
-
-# Sort the user and group entries in /etc by ID in order to make the content
-# deterministic. Package installs are not deterministic, causing the ordering
-# of entries to change between builds. In case that this isn't desired,
-# the command can be overridden.
-SORT_PASSWD_POSTPROCESS_COMMAND ??= "tidy_shadowutils_files"
-ROOTFS_POSTPROCESS_COMMAND += '${SORT_PASSWD_POSTPROCESS_COMMAND}'
-
-#
-# Note that useradd-staticids.bbclass has to be used to ensure that
-# the numeric IDs of dynamically created entries remain stable.
-#
-ROOTFS_POSTPROCESS_COMMAND += 'rootfs_reproducible'
-
-# Resolve the ID as described in the sysusers.d(5) manual: ID can be a numeric
-# uid, a couple uid:gid or uid:groupname or it is '-' meaning leaving it
-# automatic or it can be a path. In the latter, the uid/gid matches the
-# user/group owner of that file.
-def resolve_sysusers_id(d, sid):
-    # If the id is a path, the uid/gid matchs to the target's uid/gid in the
-    # rootfs.
-    if '/' in sid:
-        try:
-            osstat = os.stat(os.path.join(d.getVar('IMAGE_ROOTFS'), sid))
-        except FileNotFoundError:
-            bb.error('sysusers.d: file %s is required but it does not exist in the rootfs', sid)
-            return ('-', '-')
-        return (osstat.st_uid, osstat.st_gid)
-    # Else it is a uid:gid or uid:groupname syntax
-    if ':' in sid:
-        return sid.split(':')
-    else:
-        return (sid, '-')
-
-# Check a user exists in the rootfs password file and return its properties
-def check_user_exists(d, uname=None, uid=None):
-    with open(os.path.join(d.getVar('IMAGE_ROOTFS'), 'etc/passwd'), 'r') as pwfile:
-        for line in pwfile:
-            (name, _, u_id, gid, comment, homedir, ushell) = line.strip().split(':')
-            if uname == name or uid == u_id:
-                return (name, u_id, gid, comment or '-', homedir or '/', ushell or '-')
-    return None
-
-# Check a group exists in the rootfs group file and return its properties
-def check_group_exists(d, gname=None, gid=None):
-    with open(os.path.join(d.getVar('IMAGE_ROOTFS'), 'etc/group'), 'r') as gfile:
-        for line in gfile:
-            (name, _, g_id, _) = line.strip().split(':')
-            if name == gname or g_id == gid:
-                return (name, g_id)
-    return None
-
-def compare_users(user, e_user):
-    # user and e_user must not have None values. Unset values must be '-'.
-    (name, uid, gid, comment, homedir, ushell) = user
-    (e_name, e_uid, e_gid, e_comment, e_homedir, e_ushell) = e_user
-    # Ignore 'uid', 'gid' or 'homedir' if they are not set
-    # Ignore 'shell' and 'ushell' if one is not set
-    return name == e_name \
-        and (uid == '-' or uid == e_uid) \
-        and (gid == '-' or gid == e_gid) \
-        and (homedir == '-' or e_homedir == '-' or homedir == e_homedir) \
-        and (ushell == '-' or e_ushell == '-' or ushell == e_ushell)
-
-# Open sysusers.d configuration files and parse each line to check the users and
-# groups are already defined in /etc/passwd and /etc/groups with similar
-# properties. Refer to the sysusers.d(5) manual for its syntax.
-python systemd_sysusers_check() {
-    import glob
-    import re
-
-    pattern_comment = r'(-|\"[^:\"]+\")'
-    pattern_word    = r'[^\s]+'
-    pattern_line   = r'(' + pattern_word + r')\s+(' + pattern_word + r')\s+(' + pattern_word + r')(\s+' \
-        + pattern_comment + r')?' + r'(\s+(' + pattern_word + r'))?' + r'(\s+(' + pattern_word + r'))?'
-
-    for conffile in glob.glob(os.path.join(d.getVar('IMAGE_ROOTFS'), 'usr/lib/sysusers.d/*.conf')):
-        with open(conffile, 'r') as f:
-            for line in f:
-                line = line.strip()
-                if not len(line) or line[0] == '#': continue
-                ret = re.fullmatch(pattern_line, line.strip())
-                if not ret: continue
-                (stype, sname, sid, _, scomment, _, shomedir, _, sshell) = ret.groups()
-                if stype == 'u':
-                    if sid:
-                        (suid, sgid) = resolve_sysusers_id(d, sid)
-                        if sgid.isalpha():
-                            sgid = check_group_exists(d, gname=sgid)
-                        elif sgid.isdigit():
-                            check_group_exists(d, gid=sgid)
-                        else:
-                            sgid = '-'
-                    else:
-                        suid = '-'
-                        sgid = '-'
-                    scomment = scomment.replace('"', '') if scomment else '-'
-                    shomedir = shomedir or '-'
-                    sshell = sshell or '-'
-                    e_user = check_user_exists(d, uname=sname)
-                    if not e_user:
-                        bb.warn('User %s has never been defined' % sname)
-                    elif not compare_users((sname, suid, sgid, scomment, shomedir, sshell), e_user):
-                        bb.warn('User %s has been defined as (%s) but sysusers.d expects it as (%s)'
-                                % (sname, ', '.join(e_user),
-                                ', '.join((sname, suid, sgid, scomment, shomedir, sshell))))
-                elif stype == 'g':
-                    gid = sid or '-'
-                    if '/' in gid:
-                        (_, gid) = resolve_sysusers_id(d, sid)
-                    e_group = check_group_exists(d, gname=sname)
-                    if not e_group:
-                        bb.warn('Group %s has never been defined' % sname)
-                    elif gid != '-':
-                        (_, e_gid) = e_group
-                        if gid != e_gid:
-                            bb.warn('Group %s has been defined with id (%s) but sysusers.d expects gid (%s)'
-                                    % (sname, e_gid, gid))
-                elif stype == 'm':
-                    check_user_exists(d, sname)
-                    check_group_exists(d, sid)
-}
-
-systemd_handle_machine_id() {
-    if ${@bb.utils.contains("IMAGE_FEATURES", "read-only-rootfs", "true", "false", d)}; then
-        # Create machine-id
-        # 20:12 < mezcalero> koen: you have three options: a) run systemd-machine-id-setup at install time, b) have / read-only and an empty file there (for stateless) and c) boot with / writable
-        touch ${IMAGE_ROOTFS}${sysconfdir}/machine-id
-    fi
-    # In order to be backward compatible with the previous OE-core specific (re)implementation of systemctl
-    # we need to touch machine-id when handling presets and when the rootfs is NOT stateless
-    if ${@ 'true' if not bb.utils.contains('IMAGE_FEATURES', 'stateless-rootfs', True, False, d) else 'false'}; then
-        touch ${IMAGE_ROOTFS}${sysconfdir}/machine-id
-        if [ -e ${IMAGE_ROOTFS}${root_prefix}/lib/systemd/systemd ]; then
-            systemctl --root="${IMAGE_ROOTFS}" --preset-mode=enable-only preset-all
-            systemctl --root="${IMAGE_ROOTFS}" --global --preset-mode=enable-only preset-all
-        fi
-    fi
-}
-
-#
-# A hook function to support read-only-rootfs IMAGE_FEATURES
-#
-read_only_rootfs_hook () {
-        # Tweak the mount option and fs_passno for rootfs in fstab
-        if [ -f ${IMAGE_ROOTFS}/etc/fstab ]; then
-                sed -i -e '/^[#[:space:]]*\/dev\/root/{s/defaults/ro/;s/\([[:space:]]*[[:digit:]]\)\([[:space:]]*\)[[:digit:]]$/\1\20/}' ${IMAGE_ROOTFS}/etc/fstab
-        fi
-
-        # Tweak the "mount -o remount,rw /" command in busybox-inittab inittab
-        if [ -f ${IMAGE_ROOTFS}/etc/inittab ]; then
-                sed -i 's|/bin/mount -o remount,rw /|/bin/mount -o remount,ro /|' ${IMAGE_ROOTFS}/etc/inittab
-        fi
-
-        # If we're using openssh and the /etc/ssh directory has no pre-generated keys,
-        # we should configure openssh to use the configuration file /etc/ssh/sshd_config_readonly
-        # and the keys under /var/run/ssh.
-        # If overlayfs-etc is used this is not done as /etc is treated as writable
-        # If stateless-rootfs is enabled this is always done as we don't want to save keys then
-        if ${@ 'true' if not bb.utils.contains('IMAGE_FEATURES', 'overlayfs-etc', True, False, d) or bb.utils.contains('IMAGE_FEATURES', 'stateless-rootfs', True, False, d) else 'false'}; then
-                if [ -d ${IMAGE_ROOTFS}/etc/ssh ]; then
-                        if [ -e ${IMAGE_ROOTFS}/etc/ssh/ssh_host_rsa_key ]; then
-                                echo "SYSCONFDIR=\${SYSCONFDIR:-/etc/ssh}" >> ${IMAGE_ROOTFS}/etc/default/ssh
-                                echo "SSHD_OPTS=" >> ${IMAGE_ROOTFS}/etc/default/ssh
-                        else
-                                echo "SYSCONFDIR=\${SYSCONFDIR:-/var/run/ssh}" >> ${IMAGE_ROOTFS}/etc/default/ssh
-                                echo "SSHD_OPTS='-f /etc/ssh/sshd_config_readonly'" >> ${IMAGE_ROOTFS}/etc/default/ssh
-                        fi
-                fi
-
-                # Also tweak the key location for dropbear in the same way.
-                if [ -d ${IMAGE_ROOTFS}/etc/dropbear ]; then
-                        if [ ! -e ${IMAGE_ROOTFS}/etc/dropbear/dropbear_rsa_host_key ]; then
-                                if ! grep -q "^DROPBEAR_RSAKEY_DIR=" ${IMAGE_ROOTFS}/etc/default/dropbear ; then
-                                        echo "DROPBEAR_RSAKEY_DIR=/var/lib/dropbear" >> ${IMAGE_ROOTFS}/etc/default/dropbear
-                                fi
-                        fi
-                fi
-        fi
-
-        if ${@bb.utils.contains("DISTRO_FEATURES", "sysvinit", "true", "false", d)}; then
-                # Change the value of ROOTFS_READ_ONLY in /etc/default/rcS to yes
-                if [ -e ${IMAGE_ROOTFS}/etc/default/rcS ]; then
-                        sed -i 's/ROOTFS_READ_ONLY=no/ROOTFS_READ_ONLY=yes/' ${IMAGE_ROOTFS}/etc/default/rcS
-                fi
-                # Run populate-volatile.sh at rootfs time to set up basic files
-                # and directories to support read-only rootfs.
-                if [ -x ${IMAGE_ROOTFS}/etc/init.d/populate-volatile.sh ]; then
-                        ${IMAGE_ROOTFS}/etc/init.d/populate-volatile.sh
-                fi
-        fi
-}
-
-#
-# This function disallows empty root passwords
-#
-zap_empty_root_password () {
-        if [ -e ${IMAGE_ROOTFS}/etc/shadow ]; then
-                sed --follow-symlinks -i 's%^root::%root:*:%' ${IMAGE_ROOTFS}/etc/shadow
-        fi
-        if [ -e ${IMAGE_ROOTFS}/etc/passwd ]; then
-                sed --follow-symlinks -i 's%^root::%root:*:%' ${IMAGE_ROOTFS}/etc/passwd
-        fi
-}
-
-#
-# allow dropbear/openssh to accept logins from accounts with an empty password string
-#
-ssh_allow_empty_password () {
-        for config in sshd_config sshd_config_readonly; do
-                if [ -e ${IMAGE_ROOTFS}${sysconfdir}/ssh/$config ]; then
-                        sed -i 's/^[#[:space:]]*PermitEmptyPasswords.*/PermitEmptyPasswords yes/' ${IMAGE_ROOTFS}${sysconfdir}/ssh/$config
-                fi
-        done
-
-        if [ -e ${IMAGE_ROOTFS}${sbindir}/dropbear ] ; then
-                if grep -q DROPBEAR_EXTRA_ARGS ${IMAGE_ROOTFS}${sysconfdir}/default/dropbear 2>/dev/null ; then
-                        if ! grep -q "DROPBEAR_EXTRA_ARGS=.*-B" ${IMAGE_ROOTFS}${sysconfdir}/default/dropbear ; then
-                                sed -i 's/^DROPBEAR_EXTRA_ARGS="*\([^"]*\)"*/DROPBEAR_EXTRA_ARGS="\1 -B"/' ${IMAGE_ROOTFS}${sysconfdir}/default/dropbear
-                        fi
-                else
-                        printf '\nDROPBEAR_EXTRA_ARGS="-B"\n' >> ${IMAGE_ROOTFS}${sysconfdir}/default/dropbear
-                fi
-        fi
-
-        if [ -d ${IMAGE_ROOTFS}${sysconfdir}/pam.d ] ; then
-                for f in `find ${IMAGE_ROOTFS}${sysconfdir}/pam.d/* -type f -exec test -e {} \; -print`
-                do
-                        sed -i 's/nullok_secure/nullok/' $f
-                done
-        fi
-}
-
-#
-# allow dropbear/openssh to accept root logins
-#
-ssh_allow_root_login () {
-        for config in sshd_config sshd_config_readonly; do
-                if [ -e ${IMAGE_ROOTFS}${sysconfdir}/ssh/$config ]; then
-                        sed -i 's/^[#[:space:]]*PermitRootLogin.*/PermitRootLogin yes/' ${IMAGE_ROOTFS}${sysconfdir}/ssh/$config
-                fi
-        done
-
-        if [ -e ${IMAGE_ROOTFS}${sbindir}/dropbear ] ; then
-                if grep -q DROPBEAR_EXTRA_ARGS ${IMAGE_ROOTFS}${sysconfdir}/default/dropbear 2>/dev/null ; then
-                        sed -i '/^DROPBEAR_EXTRA_ARGS=/ s/-w//' ${IMAGE_ROOTFS}${sysconfdir}/default/dropbear
-                        sed -i '/^# Disallow root/d' ${IMAGE_ROOTFS}${sysconfdir}/default/dropbear
-                fi
-        fi
-}
-
-#
-# Autologin the 'root' user on the serial terminal,
-# if empty-root-password' AND 'serial-autologin-root are enabled
-#
-serial_autologin_root () {
-        if ${@bb.utils.contains("DISTRO_FEATURES", "sysvinit", "true", "false", d)}; then
-                # add autologin option to util-linux getty only
-                sed -i 's/options="/&--autologin root /' \
-                        "${IMAGE_ROOTFS}${base_bindir}/start_getty"
-        elif ${@bb.utils.contains("DISTRO_FEATURES", "systemd", "true", "false", d)}; then
-                if [ -e ${IMAGE_ROOTFS}${systemd_system_unitdir}/serial-getty@.service ]; then
-                        sed -i '/^\s*ExecStart\b/ s/getty /&--autologin root /' \
-                                "${IMAGE_ROOTFS}${systemd_system_unitdir}/serial-getty@.service"
-                fi
-        fi
-}
-
-python tidy_shadowutils_files () {
-    import oe.rootfspostcommands
-    oe.rootfspostcommands.tidy_shadowutils_files(d.expand('${IMAGE_ROOTFS}${sysconfdir}'))
-}
-
-python sort_passwd () {
-    """
-    Deprecated in the favour of tidy_shadowutils_files.
-    """
-    import oe.rootfspostcommands
-    bb.warn('[sort_passwd] You are using a deprecated function for '
-        'SORT_PASSWD_POSTPROCESS_COMMAND. The default one is now called '
-        '"tidy_shadowutils_files".')
-    oe.rootfspostcommands.tidy_shadowutils_files(d.expand('${IMAGE_ROOTFS}${sysconfdir}'))
-}
-
-#
-# Enable postinst logging
-#
-postinst_enable_logging () {
-        mkdir -p ${IMAGE_ROOTFS}${sysconfdir}/default
-        echo "POSTINST_LOGGING=1" >> ${IMAGE_ROOTFS}${sysconfdir}/default/postinst
-        echo "LOGFILE=${POSTINST_LOGFILE}" >> ${IMAGE_ROOTFS}${sysconfdir}/default/postinst
-}
-
-#
-# Modify systemd default target
-#
-set_systemd_default_target () {
-        if [ -d ${IMAGE_ROOTFS}${sysconfdir}/systemd/system -a -e ${IMAGE_ROOTFS}${systemd_system_unitdir}/${SYSTEMD_DEFAULT_TARGET} ]; then
-                ln -sf ${systemd_system_unitdir}/${SYSTEMD_DEFAULT_TARGET} ${IMAGE_ROOTFS}${sysconfdir}/systemd/system/default.target
-        fi
-}
-
-# If /var/volatile is not empty, we have seen problems where programs such as the
-# journal make assumptions based on the contents of /var/volatile. The journal
-# would then write to /var/volatile before it was mounted, thus hiding the
-# items previously written.
-#
-# This change is to attempt to fix those types of issues in a way that doesn't
-# affect users that may not be using /var/volatile.
-empty_var_volatile () {
-        if [ -e ${IMAGE_ROOTFS}/etc/fstab ]; then
-                match=`awk '$1 !~ "#" && $2 ~ /\/var\/volatile/{print $2}' ${IMAGE_ROOTFS}/etc/fstab 2> /dev/null`
-                if [ -n "$match" ]; then
-                        find ${IMAGE_ROOTFS}/var/volatile -mindepth 1 -delete
-                fi
-        fi
-}
-
-# Turn any symbolic /sbin/init link into a file
-remove_init_link () {
-        if [ -h ${IMAGE_ROOTFS}/sbin/init ]; then
-                LINKFILE=${IMAGE_ROOTFS}`readlink ${IMAGE_ROOTFS}/sbin/init`
-                rm ${IMAGE_ROOTFS}/sbin/init
-                cp $LINKFILE ${IMAGE_ROOTFS}/sbin/init
-        fi
-}
-
-python write_image_manifest () {
-    from oe.rootfs import image_list_installed_packages
-    from oe.utils import format_pkg_list
-
-    deploy_dir = d.getVar('IMGDEPLOYDIR')
-    link_name = d.getVar('IMAGE_LINK_NAME')
-    manifest_name = d.getVar('IMAGE_MANIFEST')
-
-    if not manifest_name:
-        return
-
-    pkgs = image_list_installed_packages(d)
-    with open(manifest_name, 'w+') as image_manifest:
-        image_manifest.write(format_pkg_list(pkgs, "ver"))
-
-    if os.path.exists(manifest_name) and link_name:
-        manifest_link = deploy_dir + "/" + link_name + ".manifest"
-        if manifest_link != manifest_name:
-            if os.path.lexists(manifest_link):
-                os.remove(manifest_link)
-            os.symlink(os.path.basename(manifest_name), manifest_link)
-}
-
-# Can be used to create /etc/timestamp during image construction to give a reasonably
-# sane default time setting
-rootfs_update_timestamp () {
-        if [ "${REPRODUCIBLE_TIMESTAMP_ROOTFS}" != "" ]; then
-                # Convert UTC into %4Y%2m%2d%2H%2M%2S
-                sformatted=`date -u -d @${REPRODUCIBLE_TIMESTAMP_ROOTFS} +%4Y%2m%2d%2H%2M%2S`
-        else
-                sformatted=`date -u +%4Y%2m%2d%2H%2M%2S`
-        fi
-        echo $sformatted > ${IMAGE_ROOTFS}/etc/timestamp
-        bbnote "rootfs_update_timestamp: set /etc/timestamp to $sformatted"
-}
-
-# Prevent X from being started
-rootfs_no_x_startup () {
-        if [ -f ${IMAGE_ROOTFS}/etc/init.d/xserver-nodm ]; then
-                chmod a-x ${IMAGE_ROOTFS}/etc/init.d/xserver-nodm
-        fi
-}
-
-rootfs_trim_schemas () {
-        for schema in ${IMAGE_ROOTFS}/etc/gconf/schemas/*.schemas
-        do
-                # Need this in case no files exist
-                if [ -e $schema ]; then
-                        oe-trim-schemas $schema > $schema.new
-                        mv $schema.new $schema
-                fi
-        done
-}
-
-rootfs_check_host_user_contaminated () {
-        contaminated="${S}/host-user-contaminated.txt"
-        HOST_USER_UID="$(PSEUDO_UNLOAD=1 id -u)"
-        HOST_USER_GID="$(PSEUDO_UNLOAD=1 id -g)"
-
-        find "${IMAGE_ROOTFS}" -path "${IMAGE_ROOTFS}/home" -prune -o \
-            -user "$HOST_USER_UID" -print -o -group "$HOST_USER_GID" -print >"$contaminated"
-
-        sed -e "s,${IMAGE_ROOTFS},," $contaminated | while read line; do
-                bbwarn "Path in the rootfs is owned by the same user or group as the user running bitbake:" $line `ls -lan ${IMAGE_ROOTFS}/$line`
-        done
-
-        if [ -s "$contaminated" ]; then
-                bbwarn "/etc/passwd:" `cat ${IMAGE_ROOTFS}/etc/passwd`
-                bbwarn "/etc/group:" `cat ${IMAGE_ROOTFS}/etc/group`
-        fi
-}
-
-# Make any absolute links in a sysroot relative
-rootfs_sysroot_relativelinks () {
-        sysroot-relativelinks.py ${SDK_OUTPUT}/${SDKTARGETSYSROOT}
-}
-
-# Generated test data json file
-python write_image_test_data() {
-    from oe.data import export2json
-
-    deploy_dir = d.getVar('IMGDEPLOYDIR')
-    link_name = d.getVar('IMAGE_LINK_NAME')
-    testdata_name = os.path.join(deploy_dir, "%s.testdata.json" % d.getVar('IMAGE_NAME'))
-
-    searchString = "%s/"%(d.getVar("TOPDIR")).replace("//","/")
-    export2json(d, testdata_name, searchString=searchString, replaceString="")
-
-    if os.path.exists(testdata_name) and link_name:
-        testdata_link = os.path.join(deploy_dir, "%s.testdata.json" % link_name)
-        if testdata_link != testdata_name:
-            if os.path.lexists(testdata_link):
-                os.remove(testdata_link)
-            os.symlink(os.path.basename(testdata_name), testdata_link)
-}
-write_image_test_data[vardepsexclude] += "TOPDIR"
-
-# Check for unsatisfied recommendations (RRECOMMENDS)
-python rootfs_log_check_recommends() {
-    log_path = d.expand("${T}/log.do_rootfs")
-    with open(log_path, 'r') as log:
-        for line in log:
-            if 'log_check' in line:
-                continue
-
-            if 'unsatisfied recommendation for' in line:
-                bb.warn('[log_check] %s: %s' % (d.getVar('PN'), line))
-}
-
-# Perform any additional adjustments needed to make rootf binary reproducible
-rootfs_reproducible () {
-        if [ "${REPRODUCIBLE_TIMESTAMP_ROOTFS}" != "" ]; then
-                # Convert UTC into %4Y%2m%2d%2H%2M%2S
-                sformatted=`date -u -d @${REPRODUCIBLE_TIMESTAMP_ROOTFS} +%4Y%2m%2d%2H%2M%2S`
-                echo $sformatted > ${IMAGE_ROOTFS}/etc/version
-                bbnote "rootfs_reproducible: set /etc/version to $sformatted"
-
-                if [ -d ${IMAGE_ROOTFS}${sysconfdir}/gconf ]; then
-                        find ${IMAGE_ROOTFS}${sysconfdir}/gconf -name '%gconf.xml' -print0 | xargs -0r \
-                        sed -i -e 's@\bmtime="[0-9][0-9]*"@mtime="'${REPRODUCIBLE_TIMESTAMP_ROOTFS}'"@g'
-                fi
-
-                if [ -f ${IMAGE_ROOTFS}${localstatedir}/lib/opkg/status ]; then
-                        sed -i 's/^Installed-Time: .*/Installed-Time: ${REPRODUCIBLE_TIMESTAMP_ROOTFS}/' ${IMAGE_ROOTFS}${localstatedir}/lib/opkg/status
-                fi
-        fi
-}
-
-# Perform a dumb check for unit existence, not its validity
-python overlayfs_qa_check() {
-    from oe.overlayfs import mountUnitName
-
-    overlayMountPoints = d.getVarFlags("OVERLAYFS_MOUNT_POINT") or {}
-    imagepath = d.getVar("IMAGE_ROOTFS")
-    sysconfdir = d.getVar("sysconfdir")
-    searchpaths = [oe.path.join(imagepath, sysconfdir, "systemd", "system"),
-                   oe.path.join(imagepath, d.getVar("systemd_system_unitdir"))]
-    fstabpath = oe.path.join(imagepath, sysconfdir, "fstab")
-
-    if not any(os.path.exists(path) for path in [*searchpaths, fstabpath]):
-        return
-
-    fstabDevices = []
-    if os.path.isfile(fstabpath):
-        with open(fstabpath, 'r') as f:
-            for line in f:
-                if line[0] == '#':
-                    continue
-                path = line.split(maxsplit=2)
-                if len(path) > 2:
-                    fstabDevices.append(path[1])
-
-    allUnitExist = True;
-    for mountPoint in overlayMountPoints:
-        qaSkip = (d.getVarFlag("OVERLAYFS_QA_SKIP", mountPoint) or "").split()
-        if "mount-configured" in qaSkip:
-            continue
-
-        mountPath = d.getVarFlag('OVERLAYFS_MOUNT_POINT', mountPoint)
-        if mountPath in fstabDevices:
-            continue
-
-        mountUnit = mountUnitName(mountPath)
-        if any(os.path.isfile(oe.path.join(dirpath, mountUnit))
-               for dirpath in searchpaths):
-            continue
-
-        bb.warn(f'Mount path {mountPath} not found in fstab and unit '
-                f'{mountUnit} not found in systemd unit directories.')
-        bb.warn(f'Skip this check by setting OVERLAYFS_QA_SKIP[{mountPoint}] = '
-                '"mount-configured"')
-        allUnitExist = False;
-
-    if not allUnitExist:
-        bb.fatal('Not all mount paths and units are installed in the image')
-}
-
-python overlayfs_postprocess() {
-    import shutil
-
-    # install helper script
-    helperScriptName = "overlayfs-create-dirs.sh"
-    helperScriptSource = oe.path.join(d.getVar("COREBASE"), "meta/files", helperScriptName)
-    helperScriptDest = oe.path.join(d.getVar("IMAGE_ROOTFS"), "/usr/sbin/", helperScriptName)
-    shutil.copyfile(helperScriptSource, helperScriptDest)
-    os.chmod(helperScriptDest, 0o755)
-}
diff --git a/meta/classes-recipe/rootfs_deb.bbclass b/meta/classes-recipe/rootfs_deb.bbclass
deleted file mode 100644
index c5c6426abb..0000000000
--- a/meta/classes-recipe/rootfs_deb.bbclass
+++ /dev/null
@@ -1,41 +0,0 @@
-#
-# Copyright 2006-2007 Openedhand Ltd.
-#
-# SPDX-License-Identifier: MIT
-#
-
-ROOTFS_PKGMANAGE = "dpkg apt"
-
-do_rootfs[depends] += "dpkg-native:do_populate_sysroot apt-native:do_populate_sysroot"
-do_populate_sdk[depends] += "dpkg-native:do_populate_sysroot apt-native:do_populate_sysroot bzip2-native:do_populate_sysroot"
-do_rootfs[recrdeptask] += "do_package_write_deb do_package_qa"
-do_rootfs[vardeps] += "PACKAGE_FEED_URIS PACKAGE_FEED_BASE_PATHS PACKAGE_FEED_ARCHS"
-
-do_rootfs[lockfiles] += "${DEPLOY_DIR_DEB}/deb.lock"
-do_populate_sdk[lockfiles] += "${DEPLOY_DIR_DEB}/deb.lock"
-do_populate_sdk_ext[lockfiles] += "${DEPLOY_DIR_DEB}/deb.lock"
-
-python rootfs_deb_bad_recommendations() {
-    if d.getVar("BAD_RECOMMENDATIONS"):
-        bb.warn("Debian package install does not support BAD_RECOMMENDATIONS")
-}
-do_rootfs[prefuncs] += "rootfs_deb_bad_recommendations"
-
-DEB_POSTPROCESS_COMMANDS = ""
-
-opkglibdir = "${localstatedir}/lib/opkg"
-
-python () {
-    # Map TARGET_ARCH to Debian's ideas about architectures
-    darch = d.getVar('SDK_ARCH')
-    if darch in ["x86", "i486", "i586", "i686", "pentium"]:
-         d.setVar('DEB_SDK_ARCH', 'i386')
-    elif darch == "x86_64":
-         d.setVar('DEB_SDK_ARCH', 'amd64')
-    elif darch == "arm":
-         d.setVar('DEB_SDK_ARCH', 'armel')
-    elif darch == "aarch64":
-         d.setVar('DEB_SDK_ARCH', 'arm64')
-    else:
-         bb.fatal("Unhandled SDK_ARCH %s" % darch)
-}
diff --git a/meta/classes-recipe/rootfs_ipk.bbclass b/meta/classes-recipe/rootfs_ipk.bbclass
deleted file mode 100644
index 87fff53a58..0000000000
--- a/meta/classes-recipe/rootfs_ipk.bbclass
+++ /dev/null
@@ -1,44 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-#
-# Creates a root filesystem out of IPKs
-#
-# This rootfs can be mounted via root-nfs or it can be put into an cramfs/jffs etc.
-# See image.bbclass for a usage of this.
-#
-
-EXTRAOPKGCONFIG ?= ""
-ROOTFS_PKGMANAGE = "opkg ${EXTRAOPKGCONFIG}"
-
-do_rootfs[depends] += "opkg-native:do_populate_sysroot opkg-utils-native:do_populate_sysroot"
-do_populate_sdk[depends] += "opkg-native:do_populate_sysroot opkg-utils-native:do_populate_sysroot"
-do_rootfs[recrdeptask] += "do_package_write_ipk do_package_qa"
-do_rootfs[vardeps] += "PACKAGE_FEED_URIS PACKAGE_FEED_BASE_PATHS PACKAGE_FEED_ARCHS"
-
-do_rootfs[lockfiles] += "${WORKDIR}/ipk.lock"
-do_populate_sdk[lockfiles] += "${WORKDIR}/sdk-ipk.lock"
-do_populate_sdk_ext[lockfiles] += "${WORKDIR}/sdk-ipk.lock"
-
-OPKG_PREPROCESS_COMMANDS = ""
-
-OPKG_POSTPROCESS_COMMANDS = ""
-
-OPKGLIBDIR ??= "${localstatedir}/lib"
-
-MULTILIBRE_ALLOW_REP += "${OPKGLIBDIR}/opkg /usr/lib/opkg"
-
-python () {
-
-    if d.getVar('BUILD_IMAGES_FROM_FEEDS'):
-        flags = d.getVarFlag('do_rootfs', 'recrdeptask')
-        flags = flags.replace("do_package_write_ipk", "")
-        flags = flags.replace("do_deploy", "")
-        flags = flags.replace("do_populate_sysroot", "")
-        d.setVarFlag('do_rootfs', 'recrdeptask', flags)
-        d.setVar('OPKG_PREPROCESS_COMMANDS', "")
-        d.setVar('OPKG_POSTPROCESS_COMMANDS', '')
-}
diff --git a/meta/classes-recipe/rootfs_rpm.bbclass b/meta/classes-recipe/rootfs_rpm.bbclass
deleted file mode 100644
index 55f1cc92ca..0000000000
--- a/meta/classes-recipe/rootfs_rpm.bbclass
+++ /dev/null
@@ -1,43 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-#
-# Creates a root filesystem out of rpm packages
-#
-
-ROOTFS_PKGMANAGE = "rpm dnf"
-
-# dnf is using our custom sysconfig module, and so will fail without these
-export STAGING_INCDIR
-export STAGING_LIBDIR
-
-# Add 100Meg of extra space for dnf
-IMAGE_ROOTFS_EXTRA_SPACE:append = "${@bb.utils.contains("PACKAGE_INSTALL", "dnf", " + 102400", "", d)}"
-
-# Dnf is python based, so be sure python3-native is available to us.
-EXTRANATIVEPATH += "python3-native"
-
-RPMROOTFSDEPENDS = "rpm-native:do_populate_sysroot \
-    dnf-native:do_populate_sysroot \
-    createrepo-c-native:do_populate_sysroot"
-
-do_rootfs[depends] += "${RPMROOTFSDEPENDS}"
-do_populate_sdk[depends] += "${RPMROOTFSDEPENDS}"
-
-do_rootfs[recrdeptask] += "do_package_write_rpm do_package_qa"
-do_rootfs[vardeps] += "PACKAGE_FEED_URIS PACKAGE_FEED_BASE_PATHS PACKAGE_FEED_ARCHS"
-
-python () {
-    if d.getVar('BUILD_IMAGES_FROM_FEEDS'):
-        flags = d.getVarFlag('do_rootfs', 'recrdeptask')
-        flags = flags.replace("do_package_write_rpm", "")
-        flags = flags.replace("do_deploy", "")
-        flags = flags.replace("do_populate_sysroot", "")
-        d.setVarFlag('do_rootfs', 'recrdeptask', flags)
-        d.setVar('RPM_PREPROCESS_COMMANDS', '')
-        d.setVar('RPM_POSTPROCESS_COMMANDS', '')
-
-}
diff --git a/meta/classes-recipe/rootfsdebugfiles.bbclass b/meta/classes-recipe/rootfsdebugfiles.bbclass
deleted file mode 100644
index 4c2fc1de25..0000000000
--- a/meta/classes-recipe/rootfsdebugfiles.bbclass
+++ /dev/null
@@ -1,47 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-# This class installs additional files found on the build host
-# directly into the rootfs.
-#
-# One use case is to install a constant ssh host key in
-# an image that gets created for just one machine. This
-# solves two issues:
-# - host key generation on the device can stall when the
-#   kernel has not gathered enough entropy yet (seen in practice
-#   under qemu)
-# - ssh complains by default when the host key changes
-#
-# For dropbear, with the ssh host key store along side the local.conf:
-# 1. Extend local.conf:
-#    INHERIT += "rootfsdebugfiles"
-#    ROOTFS_DEBUG_FILES += "${TOPDIR}/conf/dropbear_rsa_host_key ${IMAGE_ROOTFS}/etc/dropbear/dropbear_rsa_host_key ;"
-# 2. Boot the image once, copy the dropbear_rsa_host_key from
-#    the device into your build conf directory.
-# 3. A optional parameter can be used to set file mode
-#    of the copied target, for instance:
-#    ROOTFS_DEBUG_FILES += "${TOPDIR}/conf/dropbear_rsa_host_key ${IMAGE_ROOTFS}/etc/dropbear/dropbear_rsa_host_key 0600;"
-#    in case they might be required to have a specific mode. (Shoundn't be too open, for example)
-#
-# Do not use for production images! It bypasses several
-# core build mechanisms (updating the image when one
-# of the files changes, license tracking in the image
-# manifest, ...).
-
-ROOTFS_DEBUG_FILES ?= ""
-ROOTFS_DEBUG_FILES[doc] = "Lists additional files or directories to be installed with 'cp -a' in the format 'source1 target1;source2 target2;...'"
-
-ROOTFS_POSTPROCESS_COMMAND += "rootfs_debug_files"
-rootfs_debug_files () {
-   #!/bin/sh -e
-   echo "${ROOTFS_DEBUG_FILES}" | sed -e 's/;/\n/g' | while read source target mode; do
-      if [ -e "$source" ]; then
-         mkdir -p $(dirname $target)
-         cp -a $source $target
-         [ -n "$mode" ] && chmod $mode $target
-      fi
-   done
-}
diff --git a/meta/classes-recipe/rust-common.bbclass b/meta/classes-recipe/rust-common.bbclass
deleted file mode 100644
index 31331c7a26..0000000000
--- a/meta/classes-recipe/rust-common.bbclass
+++ /dev/null
@@ -1,196 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-inherit python3native
-inherit rust-target-config
-
-# Common variables used by all Rust builds
-export rustlibdir = "${libdir}/rustlib/${RUST_HOST_SYS}/lib"
-FILES:${PN} += "${rustlibdir}/*.so"
-FILES:${PN}-dev += "${rustlibdir}/*.rlib ${rustlibdir}/*.rmeta"
-FILES:${PN}-dbg += "${rustlibdir}/.debug"
-
-RUSTLIB ?= "-L ${STAGING_DIR_HOST}${rustlibdir}"
-RUST_DEBUG_REMAP = "--remap-path-prefix=${WORKDIR}=${TARGET_DBGSRC_DIR}"
-RUSTFLAGS += "${RUSTLIB} ${RUST_DEBUG_REMAP}"
-RUSTLIB_DEP ??= "libstd-rs"
-RUST_PANIC_STRATEGY ??= "unwind"
-
-def target_is_armv7(d):
-    '''Determine if target is armv7'''
-    # TUNE_FEATURES may include arm* even if the target is not arm
-    # in the case of *-native packages
-    if d.getVar('TARGET_ARCH') != 'arm':
-        return False
-
-    feat = d.getVar('TUNE_FEATURES')
-    feat = frozenset(feat.split())
-    mach_overrides = d.getVar('MACHINEOVERRIDES')
-    mach_overrides = frozenset(mach_overrides.split(':'))
-
-    v7=frozenset(['armv7a', 'armv7r', 'armv7m', 'armv7ve'])
-    if mach_overrides.isdisjoint(v7) and feat.isdisjoint(v7):
-        return False
-    else:
-        return True
-target_is_armv7[vardepvalue] = "${@target_is_armv7(d)}"
-
-# Responsible for taking Yocto triples and converting it to Rust triples
-def rust_base_triple(d, thing):
-    '''
-    Mangle bitbake's *_SYS into something that rust might support (see
-    rust/mk/cfg/* for a list)
-
-    Note that os is assumed to be some linux form
-    '''
-
-    # The llvm-target for armv7 is armv7-unknown-linux-gnueabihf
-    if d.getVar('{}_ARCH'.format(thing)) == d.getVar('TARGET_ARCH') and target_is_armv7(d):
-        arch = "armv7"
-    else:
-        arch = oe.rust.arch_to_rust_arch(d.getVar('{}_ARCH'.format(thing)))
-
-    # Substituting "unknown" when vendor is empty will match rust's standard
-    # targets when building native recipes (including rust-native itself)
-    vendor = d.getVar('{}_VENDOR'.format(thing)) or "-unknown"
-
-    # Default to glibc
-    libc = "-gnu"
-    os = d.getVar('{}_OS'.format(thing))
-    # This catches ARM targets and appends the necessary hard float bits
-    if os == "linux-gnueabi" or os == "linux-musleabi":
-        libc = bb.utils.contains('TUNE_FEATURES', 'callconvention-hard', 'hf', '', d)
-    elif os == "linux-gnux32" or os == "linux-muslx32":
-        libc = ""
-    elif "musl" in os:
-        libc = "-musl"
-        os = "linux"
-    elif "elf" in os:
-        libc = "-elf"
-        os = "none"
-    elif "eabi" in os:
-        libc = "-eabi"
-        os = "none"
-
-    return arch + vendor + '-' + os + libc
-
-
-# In some cases uname and the toolchain differ on their idea of the arch name
-RUST_BUILD_ARCH = "${@oe.rust.arch_to_rust_arch(d.getVar('BUILD_ARCH'))}"
-
-# Naming explanation
-# Yocto
-# - BUILD_SYS - Yocto triple of the build environment
-# - HOST_SYS - What we're building for in Yocto
-# - TARGET_SYS - What we're building for in Yocto
-#
-# So when building '-native' packages BUILD_SYS == HOST_SYS == TARGET_SYS
-# When building packages for the image HOST_SYS == TARGET_SYS
-# This is a gross over simplification as there are other modes but
-# currently this is all that's supported.
-#
-# Rust
-# - TARGET - the system where the binary will run
-# - HOST - the system where the binary is being built
-#
-# Rust additionally will use two additional cases:
-# - undecorated (e.g. CC) - equivalent to TARGET
-# - triple suffix (e.g. CC:x86_64_unknown_linux_gnu) - both
-#   see: https://github.com/rust-lang/cc-rs
-# The way that Rust's internal triples and Yocto triples are mapped together
-# its likely best to not use the triple suffix due to potential confusion.
-
-RUST_BUILD_SYS = "${@rust_base_triple(d, 'BUILD')}"
-RUST_BUILD_SYS[vardepvalue] = "${RUST_BUILD_SYS}"
-RUST_HOST_SYS = "${@rust_base_triple(d, 'HOST')}"
-RUST_HOST_SYS[vardepvalue] = "${RUST_HOST_SYS}"
-RUST_TARGET_SYS = "${@rust_base_triple(d, 'TARGET')}"
-RUST_TARGET_SYS[vardepvalue] = "${RUST_TARGET_SYS}"
-
-# wrappers to get around the fact that Rust needs a single
-# binary but Yocto's compiler and linker commands have
-# arguments. Technically the archiver is always one command but
-# this is necessary for builds that determine the prefix and then
-# use those commands based on the prefix.
-WRAPPER_DIR = "${WORKDIR}/wrapper"
-RUST_BUILD_CC = "${WRAPPER_DIR}/build-rust-cc"
-RUST_BUILD_CXX = "${WRAPPER_DIR}/build-rust-cxx"
-RUST_BUILD_CCLD = "${WRAPPER_DIR}/build-rust-ccld"
-RUST_BUILD_AR = "${WRAPPER_DIR}/build-rust-ar"
-RUST_TARGET_CC = "${WRAPPER_DIR}/target-rust-cc"
-RUST_TARGET_CXX = "${WRAPPER_DIR}/target-rust-cxx"
-RUST_TARGET_CCLD = "${WRAPPER_DIR}/target-rust-ccld"
-RUST_TARGET_AR = "${WRAPPER_DIR}/target-rust-ar"
-
-create_wrapper_rust () {
-        file="$1"
-        shift
-        extras="$1"
-        shift
-        crate_cc_extras="$1"
-        shift
-
-        cat <<- EOF > "${file}"
-        #!/usr/bin/env python3
-        import os, sys
-        orig_binary = "$@"
-        extras = "${extras}"
-
-        # Apply a required subset of CC crate compiler flags
-        # when we build a target recipe for a non-bare-metal target.
-        # https://github.com/rust-lang/cc-rs/blob/main/src/lib.rs#L1614
-        if "CRATE_CC_NO_DEFAULTS" in os.environ.keys() and \
-           "TARGET" in os.environ.keys() and not "-none-" in os.environ["TARGET"]:
-            orig_binary += "${crate_cc_extras}"
-
-        binary = orig_binary.split()[0]
-        args = orig_binary.split() + sys.argv[1:]
-        if extras:
-            args.append(extras)
-        os.execvp(binary, args)
-        EOF
-        chmod +x "${file}"
-}
-
-WRAPPER_TARGET_CC = "${CC}"
-WRAPPER_TARGET_CXX = "${CXX}"
-WRAPPER_TARGET_CCLD = "${CCLD}"
-WRAPPER_TARGET_LDFLAGS = "${LDFLAGS}"
-WRAPPER_TARGET_EXTRALD = ""
-# see recipes-devtools/gcc/gcc/0018-Add-ssp_nonshared-to-link-commandline-for-musl-targe.patch
-# we need to link with ssp_nonshared on musl to avoid "undefined reference to `__stack_chk_fail_local'"
-# when building MACHINE=qemux86 for musl
-WRAPPER_TARGET_EXTRALD:libc-musl = "-lssp_nonshared"
-WRAPPER_TARGET_AR = "${AR}"
-
-# compiler is used by gcc-rs
-# linker is used by rustc/cargo
-# archiver is used by the build of libstd-rs
-do_rust_create_wrappers () {
-        mkdir -p "${WRAPPER_DIR}"
-
-        # Yocto Build / Rust Host C compiler
-        create_wrapper_rust "${RUST_BUILD_CC}" "" "${CRATE_CC_FLAGS}" "${BUILD_CC}" "${BUILD_LDFLAGS}"
-        # Yocto Build / Rust Host C++ compiler
-        create_wrapper_rust "${RUST_BUILD_CXX}" "" "${CRATE_CC_FLAGS}" "${BUILD_CXX}"
-        # Yocto Build / Rust Host linker
-        create_wrapper_rust "${RUST_BUILD_CCLD}" "" "" "${BUILD_CCLD}" "${BUILD_LDFLAGS}"
-        # Yocto Build / Rust Host archiver
-        create_wrapper_rust "${RUST_BUILD_AR}" "" "" "${BUILD_AR}"
-
-        # Yocto Target / Rust Target C compiler
-        create_wrapper_rust "${RUST_TARGET_CC}" "${WRAPPER_TARGET_EXTRALD}" "${CRATE_CC_FLAGS}" "${WRAPPER_TARGET_CC}" "${WRAPPER_TARGET_LDFLAGS}"
-        # Yocto Target / Rust Target C++ compiler
-        create_wrapper_rust "${RUST_TARGET_CXX}" "${WRAPPER_TARGET_EXTRALD}" "${CRATE_CC_FLAGS}" "${WRAPPER_TARGET_CXX}" "${CXXFLAGS}"
-        # Yocto Target / Rust Target linker
-        create_wrapper_rust "${RUST_TARGET_CCLD}" "${WRAPPER_TARGET_EXTRALD}" "" "${WRAPPER_TARGET_CCLD}" "${WRAPPER_TARGET_LDFLAGS}"
-        # Yocto Target / Rust Target archiver
-        create_wrapper_rust "${RUST_TARGET_AR}" "" "" "${WRAPPER_TARGET_AR}"
-
-}
-
-addtask rust_create_wrappers before do_configure after do_patch do_prepare_recipe_sysroot
-do_rust_create_wrappers[dirs] += "${WRAPPER_DIR}"
diff --git a/meta/classes-recipe/rust-target-config.bbclass b/meta/classes-recipe/rust-target-config.bbclass
deleted file mode 100644
index 9ce57843cf..0000000000
--- a/meta/classes-recipe/rust-target-config.bbclass
+++ /dev/null
@@ -1,468 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-# Right now this is focused on arm-specific tune features.
-# We get away with this for now as one can only use x86-64 as the build host
-# (not arm).
-# Note that TUNE_FEATURES is _always_ refering to the target, so we really
-# don't want to use this for the host/build.
-def llvm_features_from_tune(d):
-    f = []
-    feat = d.getVar('TUNE_FEATURES')
-    if not feat:
-        return []
-    feat = frozenset(feat.split())
-
-    mach_overrides = d.getVar('MACHINEOVERRIDES')
-    mach_overrides = frozenset(mach_overrides.split(':'))
-
-    if 'vfpv4' in feat:
-        f.append("+vfp4")
-    elif 'vfpv4d16' in feat:
-        f.append("+vfp4")
-        f.append("-d32")
-    elif 'vfpv3' in feat:
-        f.append("+vfp3")
-    elif 'vfpv3d16' in feat:
-        f.append("+vfp3")
-        f.append("-d32")
-    elif 'vfpv2' in feat or 'vfp' in feat:
-        f.append("+vfp2")
-
-    if 'neon' in feat:
-        f.append("+neon")
-    elif target_is_armv7(d):
-        f.append("-neon")
-
-    if 'mips32' in feat:
-        f.append("+mips32")
-
-    if 'mips32r2' in feat:
-        f.append("+mips32r2")
-
-    if target_is_armv7(d):
-        f.append('+v7')
-
-    if ('armv6' in mach_overrides) or ('armv6' in feat):
-        f.append("+v6")
-    if 'armv5te' in feat:
-        f.append("+strict-align")
-        f.append("+v5te")
-    elif 'armv5' in feat:
-        f.append("+strict-align")
-        f.append("+v5")
-
-    if ('armv4' in mach_overrides) or ('armv4' in feat):
-        f.append("+strict-align")
-
-    if 'dsp' in feat:
-        f.append("+dsp")
-
-    if 'thumb' in feat:
-        if d.getVar('ARM_THUMB_OPT') == "thumb":
-            if target_is_armv7(d):
-                f.append('+thumb2')
-            f.append("+thumb-mode")
-
-    if 'cortexa5' in feat:
-        f.append("+a5")
-    if 'cortexa7' in feat:
-        f.append("+a7")
-    if 'cortexa9' in feat:
-        f.append("+a9")
-    if 'cortexa15' in feat:
-        f.append("+a15")
-    if 'cortexa17' in feat:
-        f.append("+a17")
-    if 'rv' in feat:
-        if 'm' in feat:
-            f.append("+m")
-        if 'a' in feat:
-            f.append("+a")
-        if 'f' in feat:
-            f.append("+f")
-        if 'd' in feat:
-            f.append("+d")
-        if 'c' in feat:
-            f.append("+c")
-        if 'v' in feat:
-            f.append("+v")
-        if 'zicbom' in feat:
-            f.append("+zicbom")
-        if 'zicsr' in feat:
-            f.append("+zicsr")
-        if 'zifencei' in feat:
-            f.append("+zifencei")
-        if 'zba' in feat:
-            f.append("+zba")
-        if 'zbb' in feat:
-            f.append("+zbb")
-        if 'zbc' in feat:
-            f.append("+zbc")
-        if 'zbs' in feat:
-            f.append("+zbs")
-    return f
-llvm_features_from_tune[vardepvalue] = "${@llvm_features_from_tune(d)}"
-
-# TARGET_CC_ARCH changes from build/cross/target so it'll do the right thing
-# this should go away when https://github.com/rust-lang/rust/pull/31709 is
-# stable (1.9.0?)
-def llvm_features_from_cc_arch(d):
-    f = []
-    feat = d.getVar('TARGET_CC_ARCH')
-    if not feat:
-        return []
-    feat = frozenset(feat.split())
-
-    if '-mmmx' in feat:
-        f.append("+mmx")
-    if '-msse' in feat:
-        f.append("+sse")
-    if '-msse2' in feat:
-        f.append("+sse2")
-    if '-msse3' in feat:
-        f.append("+sse3")
-    if '-mssse3' in feat:
-        f.append("+ssse3")
-    if '-msse4.1' in feat:
-        f.append("+sse4.1")
-    if '-msse4.2' in feat:
-        f.append("+sse4.2")
-    if '-msse4a' in feat:
-        f.append("+sse4a")
-    if '-mavx' in feat:
-        f.append("+avx")
-    if '-mavx2' in feat:
-        f.append("+avx2")
-
-    return f
-
-def llvm_features_from_target_fpu(d):
-    # TARGET_FPU can be hard or soft. +soft-float tell llvm to use soft float
-    # ABI. There is no option for hard.
-
-    fpu = d.getVar('TARGET_FPU')
-    return ["+soft-float"] if fpu == "soft" else []
-
-def llvm_features(d):
-    return ','.join(llvm_features_from_tune(d) +
-                    llvm_features_from_cc_arch(d) +
-                    llvm_features_from_target_fpu(d))
-
-llvm_features[vardepvalue] = "${@llvm_features(d)}"
-
-## arm-unknown-linux-gnueabihf
-DATA_LAYOUT[arm-eabi] = "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64"
-TARGET_ENDIAN[arm-eabi] = "little"
-TARGET_POINTER_WIDTH[arm-eabi] = "32"
-TARGET_C_INT_WIDTH[arm-eabi] = "32"
-MAX_ATOMIC_WIDTH[arm-eabi] = "64"
-FEATURES[arm-eabi] = "+v6,+vfp2"
-
-## armv7-unknown-linux-gnueabihf
-DATA_LAYOUT[armv7-eabi] = "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64"
-TARGET_ENDIAN[armv7-eabi] = "little"
-TARGET_POINTER_WIDTH[armv7-eabi] = "32"
-TARGET_C_INT_WIDTH[armv7-eabi] = "32"
-MAX_ATOMIC_WIDTH[armv7-eabi] = "64"
-FEATURES[armv7-eabi] = "+v7,+vfp2,+thumb2"
-
-## aarch64-unknown-linux-{gnu, musl}
-DATA_LAYOUT[aarch64] = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128-Fn32"
-TARGET_ENDIAN[aarch64] = "little"
-TARGET_POINTER_WIDTH[aarch64] = "64"
-TARGET_C_INT_WIDTH[aarch64] = "32"
-MAX_ATOMIC_WIDTH[aarch64] = "128"
-
-## x86_64-unknown-linux-{gnu, musl}
-DATA_LAYOUT[x86_64] = "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:128-f80:128-n8:16:32:64-S128"
-TARGET_ENDIAN[x86_64] = "little"
-TARGET_POINTER_WIDTH[x86_64] = "64"
-TARGET_C_INT_WIDTH[x86_64] = "32"
-MAX_ATOMIC_WIDTH[x86_64] = "64"
-
-## x86_64-unknown-linux-gnux32
-DATA_LAYOUT[x86_64-x32] = "e-m:e-p:32:32-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:128-f80:128-n8:16:32:64-S128"
-TARGET_ENDIAN[x86_64-x32] = "little"
-TARGET_POINTER_WIDTH[x86_64-x32] = "32"
-TARGET_C_INT_WIDTH[x86_64-x32] = "32"
-MAX_ATOMIC_WIDTH[x86_64-x32] = "64"
-
-## i686-unknown-linux-{gnu, musl}
-DATA_LAYOUT[i686] = "e-m:e-p:32:32-p270:32:32-p271:32:32-p272:64:64-i128:128-f64:32:64-f80:32-n8:16:32-S128"
-TARGET_ENDIAN[i686] = "little"
-TARGET_POINTER_WIDTH[i686] = "32"
-TARGET_C_INT_WIDTH[i686] = "32"
-MAX_ATOMIC_WIDTH[i686] = "64"
-
-## XXX: a bit of a hack so qemux86 builds, clone of i686-unknown-linux-{gnu, musl} above
-DATA_LAYOUT[i586] = "e-m:e-p:32:32-p270:32:32-p271:32:32-p272:64:64-i128:128-f64:32:64-f80:32-n8:16:32-S128"
-TARGET_ENDIAN[i586] = "little"
-TARGET_POINTER_WIDTH[i586] = "32"
-TARGET_C_INT_WIDTH[i586] = "32"
-MAX_ATOMIC_WIDTH[i586] = "64"
-
-## mips-unknown-linux-{gnu, musl}
-DATA_LAYOUT[mips] = "E-m:m-p:32:32-i8:8:32-i16:16:32-i64:64-n32-S64"
-TARGET_ENDIAN[mips] = "big"
-TARGET_POINTER_WIDTH[mips] = "32"
-TARGET_C_INT_WIDTH[mips] = "32"
-MAX_ATOMIC_WIDTH[mips] = "32"
-
-## mipsel-unknown-linux-{gnu, musl}
-DATA_LAYOUT[mipsel] = "e-m:m-p:32:32-i8:8:32-i16:16:32-i64:64-n32-S64"
-TARGET_ENDIAN[mipsel] = "little"
-TARGET_POINTER_WIDTH[mipsel] = "32"
-TARGET_C_INT_WIDTH[mipsel] = "32"
-MAX_ATOMIC_WIDTH[mipsel] = "32"
-
-## mips64-unknown-linux-{gnu, musl}
-DATA_LAYOUT[mips64] = "E-m:e-i8:8:32-i16:16:32-i64:64-n32:64-S128"
-TARGET_ENDIAN[mips64] = "big"
-TARGET_POINTER_WIDTH[mips64] = "64"
-TARGET_C_INT_WIDTH[mips64] = "32"
-MAX_ATOMIC_WIDTH[mips64] = "64"
-
-## mips64-n32-unknown-linux-{gnu, musl}
-DATA_LAYOUT[mips64-n32] = "E-m:e-p:32:32-i8:8:32-i16:16:32-i64:64-n32:64-S128"
-TARGET_ENDIAN[mips64-n32] = "big"
-TARGET_POINTER_WIDTH[mips64-n32] = "32"
-TARGET_C_INT_WIDTH[mips64-n32] = "32"
-MAX_ATOMIC_WIDTH[mips64-n32] = "64"
-
-## mips64el-unknown-linux-{gnu, musl}
-DATA_LAYOUT[mips64el] = "e-m:e-i8:8:32-i16:16:32-i64:64-n32:64-S128"
-TARGET_ENDIAN[mips64el] = "little"
-TARGET_POINTER_WIDTH[mips64el] = "64"
-TARGET_C_INT_WIDTH[mips64el] = "32"
-MAX_ATOMIC_WIDTH[mips64el] = "64"
-
-## powerpc-unknown-linux-{gnu, musl}
-DATA_LAYOUT[powerpc] = "E-m:e-p:32:32-Fn32-i64:64-n32"
-TARGET_ENDIAN[powerpc] = "big"
-TARGET_POINTER_WIDTH[powerpc] = "32"
-TARGET_C_INT_WIDTH[powerpc] = "32"
-MAX_ATOMIC_WIDTH[powerpc] = "32"
-
-## powerpc64-unknown-linux-{gnu, musl}
-DATA_LAYOUT[powerpc64] = "E-m:e-Fi64-i64:64-i128:128-n32:64-S128-v256:256:256-v512:512:512"
-TARGET_ENDIAN[powerpc64] = "big"
-TARGET_POINTER_WIDTH[powerpc64] = "64"
-TARGET_C_INT_WIDTH[powerpc64] = "32"
-MAX_ATOMIC_WIDTH[powerpc64] = "64"
-
-## powerpc64le-unknown-linux-{gnu, musl}
-DATA_LAYOUT[powerpc64le] = "e-m:e-Fn32-i64:64-i128:128-n32:64-S128-v256:256:256-v512:512:512"
-TARGET_ENDIAN[powerpc64le] = "little"
-TARGET_POINTER_WIDTH[powerpc64le] = "64"
-TARGET_C_INT_WIDTH[powerpc64le] = "32"
-MAX_ATOMIC_WIDTH[powerpc64le] = "64"
-
-## riscv32-unknown-linux-{gnu, musl}
-DATA_LAYOUT[riscv32] = "e-m:e-p:32:32-i64:64-n32-S128"
-TARGET_ENDIAN[riscv32] = "little"
-TARGET_POINTER_WIDTH[riscv32] = "32"
-TARGET_C_INT_WIDTH[riscv32] = "32"
-MAX_ATOMIC_WIDTH[riscv32] = "32"
-
-## riscv64-unknown-linux-{gnu, musl}
-DATA_LAYOUT[riscv64] = "e-m:e-p:64:64-i64:64-i128:128-n32:64-S128"
-TARGET_ENDIAN[riscv64] = "little"
-TARGET_POINTER_WIDTH[riscv64] = "64"
-TARGET_C_INT_WIDTH[riscv64] = "32"
-MAX_ATOMIC_WIDTH[riscv64] = "64"
-
-## loongarch64-unknown-linux-{gnu, musl}
-DATA_LAYOUT[loongarch64] = "e-m:e-p:64:64-i64:64-i128:128-n32:64-S128"
-TARGET_ENDIAN[loongarch64] = "little"
-TARGET_POINTER_WIDTH[loongarch64] = "64"
-TARGET_C_INT_WIDTH[loongarch64] = "32"
-MAX_ATOMIC_WIDTH[loongarch64] = "64"
-FEATURES[loongarch64] = "+d"
-
-# Convert a normal arch (HOST_ARCH, TARGET_ARCH, BUILD_ARCH, etc) to something
-# rust's internals won't choke on.
-def arch_to_rust_target_arch(arch):
-    if arch == "i586" or arch == "i686":
-        return "x86"
-    elif arch == "mipsel":
-        return "mips"
-    elif arch == "mip64sel":
-        return "mips64"
-    elif arch == "armv7":
-        return "arm"
-    elif arch == "powerpc64le":
-        return "powerpc64"
-    else:
-        return arch
-
-# Convert a rust target string to a llvm-compatible triplet
-def rust_sys_to_llvm_target(sys):
-    return sys
-
-# generates our target CPU value
-def llvm_cpu(d):
-    cpu = d.getVar('PACKAGE_ARCH')
-    target = d.getVar('TRANSLATED_TARGET_ARCH')
-
-    trans = {}
-    trans['corei7-64'] = "corei7"
-    trans['core2-32'] = "core2"
-    trans['x86-64'] = "x86-64"
-    trans['i686'] = "i686"
-    trans['i586'] = "i586"
-    trans['mips64'] = "mips64"
-    trans['mips64el'] = "mips64"
-    trans['powerpc64le'] = "ppc64le"
-    trans['powerpc64'] = "ppc64"
-    trans['riscv64'] = "generic-rv64"
-    trans['riscv32'] = "generic-rv32"
-    trans['loongarch64'] = "la464"
-
-    if target in ["mips", "mipsel", "powerpc"]:
-        feat = frozenset(d.getVar('TUNE_FEATURES').split())
-        if "mips32r2" in feat:
-            trans['mipsel'] = "mips32r2"
-            trans['mips'] = "mips32r2"
-        elif "mips32" in feat:
-            trans['mipsel'] = "mips32"
-            trans['mips'] = "mips32"
-        elif "ppc7400" in feat:
-            trans['powerpc'] = "7400"
-
-    try:
-        return trans[cpu]
-    except:
-        return trans.get(target, "generic")
-
-llvm_cpu[vardepvalue] = "${@llvm_cpu(d)}"
-
-def rust_gen_target(d, thing, wd, arch):
-    import json
-
-    build_sys = d.getVar('BUILD_SYS')
-    target_sys = d.getVar('TARGET_SYS')
-
-    sys = d.getVar('{}_SYS'.format(thing))
-    prefix = d.getVar('{}_PREFIX'.format(thing))
-    rustsys = d.getVar('RUST_{}_SYS'.format(thing))
-    os = d.getVar('{}_OS'.format(thing))
-
-    abi = None
-    cpu = "generic"
-    features = ""
-
-    # Need to apply the target tuning consitently, only if the triplet applies to the target
-    # and not in the native case
-    if sys == target_sys and sys != build_sys:
-        abi = d.getVar('ABIEXTENSION')
-        cpu = llvm_cpu(d)
-        if bb.data.inherits_class('native', d):
-            features = ','.join(llvm_features_from_cc_arch(d))
-        else:
-            features = llvm_features(d) or ""
-        # arm and armv7 have different targets in llvm
-        if arch == "arm" and target_is_armv7(d):
-            arch = 'armv7'
-
-    rust_arch = oe.rust.arch_to_rust_arch(arch)
-
-    if abi:
-        arch_abi = "{}-{}".format(rust_arch, abi)
-    else:
-        arch_abi = rust_arch
-
-    features = features or d.getVarFlag('FEATURES', arch_abi) or ""
-    features = features.strip()
-
-    # build tspec
-    tspec = {}
-    tspec['llvm-target'] = rust_sys_to_llvm_target(rustsys)
-    tspec['data-layout'] = d.getVarFlag('DATA_LAYOUT', arch_abi)
-    if tspec['data-layout'] is None:
-        bb.fatal("No rust target defined for %s" % arch_abi)
-    tspec['max-atomic-width'] = int(d.getVarFlag('MAX_ATOMIC_WIDTH', arch_abi))
-    tspec['target-pointer-width'] = d.getVarFlag('TARGET_POINTER_WIDTH', arch_abi)
-    tspec['target-c-int-width'] = int(d.getVarFlag('TARGET_C_INT_WIDTH', arch_abi))
-    tspec['target-endian'] = d.getVarFlag('TARGET_ENDIAN', arch_abi)
-    tspec['arch'] = arch_to_rust_target_arch(rust_arch)
-    if "elf" in os:
-        tspec['os'] = "none"
-    else:
-        tspec['os'] = "linux"
-    if "musl" in tspec['llvm-target']:
-        tspec['env'] = "musl"
-    else:
-        tspec['env'] = "gnu"
-    if "riscv64" in tspec['llvm-target']:
-        tspec['llvm-abiname'] = d.getVar('TUNE_RISCV_ABI')
-    if "riscv32" in tspec['llvm-target']:
-        tspec['llvm-abiname'] = d.getVar('TUNE_RISCV_ABI')
-    if "loongarch64" in tspec['llvm-target']:
-        tspec['llvm-abiname'] = "lp64d"
-    if "powerpc64le" in tspec['llvm-target']:
-        tspec['llvm-abiname'] = "elfv2"
-    elif "powerpc64" in tspec['llvm-target']:
-        tspec['llvm-abiname'] = "elfv1"
-    tspec['vendor'] = "unknown"
-    tspec['target-family'] = "unix"
-    tspec['linker'] = "{}{}gcc".format(d.getVar('CCACHE'), prefix)
-    tspec['cpu'] = cpu
-    if features != "":
-        tspec['features'] = features
-    fpu = d.getVar('TARGET_FPU')
-    if fpu in ["soft", "softfp"]:
-        tspec['llvm-floatabi'] = "soft"
-    elif fpu == "hard":
-        tspec['llvm-floatabi'] = "hard"
-    tspec['dynamic-linking'] = True
-    tspec['executables'] = True
-    tspec['linker-is-gnu'] = True
-    tspec['linker-flavor'] = "gcc"
-    tspec['has-rpath'] = True
-    tspec['has-thread-local'] = True
-    tspec['position-independent-executables'] = True
-    tspec['panic-strategy'] = d.getVar("RUST_PANIC_STRATEGY")
-
-    # write out the target spec json file
-    with open(wd + rustsys + '.json', 'w') as f:
-        json.dump(tspec, f, indent=4)
-
-# These are accounted for in tmpdir path names so don't need to be in the task sig
-rust_gen_target[vardepsexclude] += "ABIEXTENSION llvm_cpu"
-
-do_rust_gen_targets[vardeps] += "DATA_LAYOUT TARGET_ENDIAN TARGET_POINTER_WIDTH TARGET_C_INT_WIDTH MAX_ATOMIC_WIDTH FEATURES"
-
-RUST_TARGETS_DIR = "${WORKDIR}/rust-targets/"
-export RUST_TARGET_PATH = "${RUST_TARGETS_DIR}"
-
-python do_rust_gen_targets () {
-    wd = d.getVar('RUST_TARGETS_DIR')
-    # Order of BUILD, HOST, TARGET is important in case the files overwrite, most specific last
-    rust_gen_target(d, 'BUILD', wd, d.getVar('BUILD_ARCH'))
-    rust_gen_target(d, 'HOST', wd, d.getVar('HOST_ARCH'))
-    rust_gen_target(d, 'TARGET', wd, d.getVar('TARGET_ARCH'))
-}
-
-addtask rust_gen_targets after do_patch before do_configure
-do_rust_gen_targets[dirs] += "${RUST_TARGETS_DIR}"
-
-# For building target C dependecies use only compiler parameters defined in OE
-# and ignore the CC crate defaults which conflicts with OE ones in some cases.
-# https://github.com/rust-lang/cc-rs#external-configuration-via-environment-variables
-# Some CC crate compiler flags are still required.
-# We apply them conditionally in rust wrappers.
-
-CRATE_CC_FLAGS:class-native = ""
-CRATE_CC_FLAGS:class-nativesdk = ""
-CRATE_CC_FLAGS:class-target = " -ffunction-sections -fdata-sections -fPIC"
-
-do_compile:prepend:class-target() {
-    export CRATE_CC_NO_DEFAULTS=1
-}
-do_install:prepend:class-target() {
-    export CRATE_CC_NO_DEFAULTS=1
-}
diff --git a/meta/classes-recipe/rust.bbclass b/meta/classes-recipe/rust.bbclass
deleted file mode 100644
index e727601679..0000000000
--- a/meta/classes-recipe/rust.bbclass
+++ /dev/null
@@ -1,51 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-inherit rust-common
-
-RUSTC = "rustc"
-
-RUSTC_ARCHFLAGS += "--target=${RUST_HOST_SYS} ${RUSTFLAGS}"
-
-def rust_base_dep(d):
-    # Taken from meta/classes/base.bbclass `base_dep_prepend` and modified to
-    # use rust instead of gcc
-    deps = ""
-    if not d.getVar('INHIBIT_DEFAULT_RUST_DEPS'):
-        if (d.getVar('HOST_SYS') != d.getVar('BUILD_SYS')):
-            deps += " rust-native ${RUSTLIB_DEP}"
-        else:
-            deps += " rust-native"
-    return deps
-
-DEPENDS:append = " ${@rust_base_dep(d)}"
-
-# BUILD_LDFLAGS
-#       ${STAGING_LIBDIR_NATIVE}
-#       ${STAGING_BASE_LIBDIR_NATIVE}
-# BUILDSDK_LDFLAGS
-#       ${STAGING_LIBDIR}
-#       #{STAGING_DIR_HOST}
-# TARGET_LDFLAGS ?????
-#RUSTC_BUILD_LDFLAGS = "\
-#       --sysroot ${STAGING_DIR_NATIVE} \
-#       -L${STAGING_LIBDIR_NATIVE}      \
-#       -L${STAGING_BASE_LIBDIR_NATIVE} \
-#"
-
-# XXX: for some reason bitbake sets BUILD_* & TARGET_* but uses the bare
-# variables for HOST. Alias things to make it easier for us.
-HOST_LDFLAGS  ?= "${LDFLAGS}"
-HOST_CFLAGS   ?= "${CFLAGS}"
-HOST_CXXFLAGS ?= "${CXXFLAGS}"
-HOST_CPPFLAGS ?= "${CPPFLAGS}"
-
-rustlib_suffix = "${TUNE_ARCH}${TARGET_VENDOR}-${TARGET_OS}/rustlib/${RUST_HOST_SYS}/lib"
-# Native sysroot standard library path
-rustlib_src = "${prefix}/lib/${rustlib_suffix}"
-# Host sysroot standard library path
-rustlib = "${libdir}/${rustlib_suffix}"
-rustlib:class-native = "${libdir}/rustlib/${BUILD_SYS}/lib"
diff --git a/meta/classes-recipe/scons.bbclass b/meta/classes-recipe/scons.bbclass
deleted file mode 100644
index 1cb375522d..0000000000
--- a/meta/classes-recipe/scons.bbclass
+++ /dev/null
@@ -1,40 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-inherit python3native
-
-DEPENDS += "python3-scons-native"
-
-EXTRA_OESCONS ?= ""
-# This value below is derived from $(getconf ARG_MAX)
-SCONS_MAXLINELENGTH ?= "MAXLINELENGTH=2097152"
-EXTRA_OESCONS:append = " ${SCONS_MAXLINELENGTH}"
-scons_do_configure() {
-        if [ -n "${CONFIGURESTAMPFILE}" -a "${S}" = "${B}" ]; then
-                if [ -e "${CONFIGURESTAMPFILE}" -a "`cat ${CONFIGURESTAMPFILE}`" != "${BB_TASKHASH}" -a "${CLEANBROKEN}" != "1" ]; then
-                        ${STAGING_BINDIR_NATIVE}/scons --directory=${S} --clean PREFIX=${prefix} prefix=${prefix} ${EXTRA_OESCONS}
-                fi
-
-                mkdir -p `dirname ${CONFIGURESTAMPFILE}`
-                echo ${BB_TASKHASH} > ${CONFIGURESTAMPFILE}
-        fi
-}
-
-scons_do_compile() {
-        ${STAGING_BINDIR_NATIVE}/scons --directory=${S} ${PARALLEL_MAKE} PREFIX=${prefix} prefix=${prefix} ${EXTRA_OESCONS} || \
-        die "scons build execution failed."
-}
-
-scons_do_install() {
-        ${STAGING_BINDIR_NATIVE}/scons --directory=${S} install_root=${D}${prefix} PREFIX=${prefix} prefix=${prefix} ${EXTRA_OESCONS} install || \
-        die "scons install execution failed."
-}
-
-do_configure[vardepsexclude] = "SCONS_MAXLINELENGTH"
-do_compile[vardepsexclude] = "SCONS_MAXLINELENGTH"
-do_install[vardepsexclude] = "SCONS_MAXLINELENGTH"
-
-EXPORT_FUNCTIONS do_configure do_compile do_install
diff --git a/meta/classes-recipe/setuptools3-base.bbclass b/meta/classes-recipe/setuptools3-base.bbclass
deleted file mode 100644
index 190d9e6e3a..0000000000
--- a/meta/classes-recipe/setuptools3-base.bbclass
+++ /dev/null
@@ -1,34 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-DEPENDS:append:class-target = " python3-native python3"
-DEPENDS:append:class-nativesdk = " python3-native python3"
-RDEPENDS:${PN}:append:class-target = " python3-core"
-
-export STAGING_INCDIR
-export STAGING_LIBDIR
-
-# LDSHARED is the ld *command* used to create shared library
-export LDSHARED  = "${CCLD} -shared"
-# LDXXSHARED is the ld *command* used to create shared library of C++
-# objects
-export LDCXXSHARED  = "${CXX} -shared"
-# CCSHARED are the C *flags* used to create objects to go into a shared
-# library (module)
-export CCSHARED  = "-fPIC -DPIC"
-# LINKFORSHARED are the flags passed to the $(CC) command that links
-# the python executable
-export LINKFORSHARED = "${SECURITY_CFLAGS} -Xlinker -export-dynamic"
-
-# The environment variable SETUPTOOLS_SCM_SUBPROCESS_TIMEOUT allows
-# to override the subprocess timeout.
-export SETUPTOOLS_SCM_SUBPROCESS_TIMEOUT ??= "600"
-
-FILES:${PN} += "${PYTHON_SITEPACKAGES_DIR}"
-FILES:${PN}-staticdev += "${PYTHON_SITEPACKAGES_DIR}/*.a"
-FILES:${PN}-dev += "${PYTHON_SITEPACKAGES_DIR}/*.la"
-
-inherit python3native python3targetconfig
diff --git a/meta/classes-recipe/setuptools3.bbclass b/meta/classes-recipe/setuptools3.bbclass
deleted file mode 100644
index 0bbe378023..0000000000
--- a/meta/classes-recipe/setuptools3.bbclass
+++ /dev/null
@@ -1,58 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-inherit setuptools3-base python_pep517
-
-DEPENDS += "python3-setuptools-native python3-wheel-native"
-
-SETUPTOOLS_BUILD_ARGS ?= ""
-
-SETUPTOOLS_SETUP_PATH ?= "${S}"
-
-python do_check_backend() {
-    import re
-    filename = d.expand("${SETUPTOOLS_SETUP_PATH}/pyproject.toml")
-    if os.path.exists(filename):
-        for line in open(filename):
-            match = re.match(r"build-backend\s*=\s*\W([\w.]+)\W", line)
-            if not match: continue
-
-            msg = f"inherits setuptools3 but has pyproject.toml with {match[1]}, use the correct class"
-            if "pep517-backend" not in (d.getVar("INSANE_SKIP") or "").split():
-                oe.qa.handle_error("pep517-backend", msg, d)
-    oe.qa.exit_if_errors(d)
-}
-addtask check_backend after do_patch before do_configure
-
-setuptools3_do_configure() {
-    :
-}
-# This isn't nice, but is the best solutions to ensure clean builds for now.
-# https://github.com/pypa/setuptools/issues/4732
-do_configure[cleandirs] = "${SETUPTOOLS_SETUP_PATH}/build"
-
-setuptools3_do_compile() {
-        cd ${SETUPTOOLS_SETUP_PATH}
-
-        export STAGING_INCDIR=${STAGING_INCDIR}
-        export STAGING_LIBDIR=${STAGING_LIBDIR}
-
-        nativepython3 setup.py --verbose \
-            build ${@oe.utils.parallel_make_argument(d, "-j %d")} \
-            bdist_wheel --dist-dir ${PEP517_WHEEL_PATH} \
-            ${SETUPTOOLS_BUILD_ARGS}
-}
-setuptools3_do_compile[vardepsexclude] = "MACHINE"
-do_compile[cleandirs] += "${PEP517_WHEEL_PATH}"
-
-# This could be removed in the future but some recipes in meta-oe still use it
-setuptools3_do_install() {
-        python_pep517_do_install
-}
-
-EXPORT_FUNCTIONS do_configure do_compile do_install
-
-export LDSHARED = "${CCLD} -shared"
diff --git a/meta/classes-recipe/setuptools3_legacy.bbclass b/meta/classes-recipe/setuptools3_legacy.bbclass
deleted file mode 100644
index 6b51b9796b..0000000000
--- a/meta/classes-recipe/setuptools3_legacy.bbclass
+++ /dev/null
@@ -1,98 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-# This class is for packages which use the deprecated setuptools behaviour,
-# specifically custom install tasks which don't work correctly with bdist_wheel.
-# This behaviour is deprecated in setuptools[1] and won't work in the future, so
-# all users of this should consider their options: pure Python modules can use a
-# modern Python tool such as build[2], or packages which are doing more (such as
-# installing init scripts) should use a fully-featured build system such as Meson.
-#
-# [1] https://setuptools.pypa.io/en/latest/history.html#id142
-# [2] https://pypi.org/project/build/
-
-inherit setuptools3-base
-
-B = "${WORKDIR}/build"
-do_configure[cleandirs] = "${B}"
-
-SETUPTOOLS_BUILD_ARGS ?= ""
-SETUPTOOLS_INSTALL_ARGS ?= "--root=${D} \
-    --prefix=${prefix} \
-    --install-lib=${PYTHON_SITEPACKAGES_DIR} \
-    --install-data=${datadir}"
-
-SETUPTOOLS_PYTHON = "python3"
-SETUPTOOLS_PYTHON:class-native = "nativepython3"
-
-SETUPTOOLS_SETUP_PATH ?= "${S}"
-
-python do_check_backend() {
-    import re
-    filename = d.expand("${SETUPTOOLS_SETUP_PATH}/pyproject.toml")
-    if os.path.exists(filename):
-        for line in open(filename):
-            match = re.match(r"build-backend\s*=\s*\W([\w.]+)\W", line)
-            if not match: continue
-
-            msg = f"inherits setuptools3_legacy but has pyproject.toml with {match[1]}, use the correct class"
-            if "pep517-backend" not in (d.getVar("INSANE_SKIP") or "").split():
-                oe.qa.handle_error("pep517-backend", msg, d)
-}
-addtask check_backend after do_patch before do_configure
-
-setuptools3_legacy_do_configure() {
-    :
-}
-
-setuptools3_legacy_do_compile() {
-        cd ${SETUPTOOLS_SETUP_PATH}
-        STAGING_INCDIR=${STAGING_INCDIR} \
-        STAGING_LIBDIR=${STAGING_LIBDIR} \
-        ${STAGING_BINDIR_NATIVE}/python3-native/python3 setup.py \
-        build --build-base=${B} ${SETUPTOOLS_BUILD_ARGS} || \
-        bbfatal_log "'python3 setup.py build ${SETUPTOOLS_BUILD_ARGS}' execution failed."
-}
-setuptools3_legacy_do_compile[vardepsexclude] = "MACHINE"
-
-setuptools3_legacy_do_install() {
-        cd ${SETUPTOOLS_SETUP_PATH}
-        install -d ${D}${PYTHON_SITEPACKAGES_DIR}
-        STAGING_INCDIR=${STAGING_INCDIR} \
-        STAGING_LIBDIR=${STAGING_LIBDIR} \
-        PYTHONPATH=${D}${PYTHON_SITEPACKAGES_DIR}:$PYTHONPATH \
-        ${STAGING_BINDIR_NATIVE}/python3-native/python3 setup.py \
-        build --build-base=${B} install --skip-build ${SETUPTOOLS_INSTALL_ARGS} || \
-        bbfatal_log "'python3 setup.py install ${SETUPTOOLS_INSTALL_ARGS}' execution failed."
-
-        # support filenames with *spaces*
-        find ${D} -name "*.py" -exec grep -q ${D} {} \; \
-                               -exec sed -i -e s:${D}::g {} \;
-
-        for i in ${D}${bindir}/* ${D}${sbindir}/*; do
-            if [ -f "$i" ]; then
-                sed -i -e s:${PYTHON}:${USRBINPATH}/env\ ${SETUPTOOLS_PYTHON}:g $i
-                sed -i -e s:${STAGING_BINDIR_NATIVE}:${bindir}:g $i
-            fi
-        done
-
-        rm -f ${D}${PYTHON_SITEPACKAGES_DIR}/easy-install.pth
-
-        #
-        # FIXME: Bandaid against wrong datadir computation
-        #
-        if [ -e ${D}${datadir}/share ]; then
-            mv -f ${D}${datadir}/share/* ${D}${datadir}/
-            rmdir ${D}${datadir}/share
-        fi
-}
-setuptools3_legacy_do_install[vardepsexclude] = "MACHINE"
-
-EXPORT_FUNCTIONS do_configure do_compile do_install
-
-export LDSHARED = "${CCLD} -shared"
-DEPENDS += "python3-setuptools-native"
-
diff --git a/meta/classes-recipe/siteinfo.bbclass b/meta/classes-recipe/siteinfo.bbclass
deleted file mode 100644
index 25b53d929a..0000000000
--- a/meta/classes-recipe/siteinfo.bbclass
+++ /dev/null
@@ -1,226 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-# This class exists to provide information about the targets that
-# may be needed by other classes and/or recipes. If you add a new
-# target this will probably need to be updated.
-
-#
-# Returns information about 'what' for the named target 'target'
-# where 'target' == "<arch>-<os>"
-#
-# 'what' can be one of
-# * target: Returns the target name ("<arch>-<os>")
-# * endianness: Return "be" for big endian targets, "le" for little endian
-# * bits: Returns the bit size of the target, either "32" or "64"
-# * libc: Returns the name of the c library used by the target
-#
-# It is an error for the target not to exist.
-# If 'what' doesn't exist then an empty value is returned
-#
-def siteinfo_data_for_machine(arch, os, d):
-    archinfo = {
-        "allarch": "endian-little bit-32", # bogus, but better than special-casing the checks below for allarch
-        "aarch64": "endian-little bit-64 arm-common arm-64",
-        "aarch64_be": "endian-big bit-64 arm-common arm-64",
-        "arc": "endian-little bit-32 arc-common",
-        "arceb": "endian-big bit-32 arc-common",
-        "arm": "endian-little bit-32 arm-common arm-32",
-        "armeb": "endian-big bit-32 arm-common arm-32",
-        "avr32": "endian-big bit-32 avr32-common",
-        "bfin": "endian-little bit-32 bfin-common",
-        "epiphany": "endian-little bit-32",
-        "i386": "endian-little bit-32 ix86-common",
-        "i486": "endian-little bit-32 ix86-common",
-        "i586": "endian-little bit-32 ix86-common",
-        "i686": "endian-little bit-32 ix86-common",
-        "ia64": "endian-little bit-64",
-        "lm32": "endian-big bit-32",
-        "loongarch32": "endian-little bit-32 loongarch",
-        "loongarch64": "endian-little bit-64 loongarch",
-        "m68k": "endian-big bit-32",
-        "microblaze": "endian-big bit-32 microblaze-common",
-        "microblazeel": "endian-little bit-32 microblaze-common",
-        "mips": "endian-big bit-32 mips-common",
-        "mips64": "endian-big bit-64 mips-common",
-        "mips64el": "endian-little bit-64 mips-common",
-        "mipsisa64r6": "endian-big bit-64 mips-common",
-        "mipsisa64r6el": "endian-little bit-64 mips-common",
-        "mipsel": "endian-little bit-32 mips-common",
-        "mipsisa32r6": "endian-big bit-32 mips-common",
-        "mipsisa32r6el": "endian-little bit-32 mips-common",
-        "powerpc": "endian-big bit-32 powerpc-common",
-        "powerpcle": "endian-little bit-32 powerpc-common",
-        "nios2": "endian-little bit-32 nios2-common",
-        "powerpc64": "endian-big bit-64 powerpc-common",
-        "powerpc64le": "endian-little bit-64 powerpc-common",
-        "ppc": "endian-big bit-32 powerpc-common",
-        "ppc64": "endian-big bit-64 powerpc-common",
-        "ppc64le" : "endian-little bit-64 powerpc-common",
-        "riscv32": "endian-little bit-32 riscv-common",
-        "riscv64": "endian-little bit-64 riscv-common",
-        "sh3": "endian-little bit-32 sh-common",
-        "sh3eb": "endian-big bit-32 sh-common",
-        "sh4": "endian-little bit-32 sh-common",
-        "sh4eb": "endian-big bit-32 sh-common",
-        "sparc": "endian-big bit-32",
-        "viac3": "endian-little bit-32 ix86-common",
-        "x86_64": "endian-little", # bitinfo specified in targetinfo
-    }
-    osinfo = {
-        "darwin": "common-darwin",
-        "darwin9": "common-darwin",
-        "darwin19": "common-darwin",
-        "darwin21": "common-darwin",
-        "linux": "common-linux common-glibc",
-        "linux-gnu": "common-linux common-glibc",
-        "linux-gnu_ilp32": "common-linux common-glibc",
-        "linux-gnux32": "common-linux common-glibc",
-        "linux-gnun32": "common-linux common-glibc",
-        "linux-gnueabi": "common-linux common-glibc",
-        "linux-gnuspe": "common-linux common-glibc",
-        "linux-musl": "common-linux common-musl",
-        "linux-muslx32": "common-linux common-musl",
-        "linux-musleabi": "common-linux common-musl",
-        "linux-muslspe": "common-linux common-musl",
-        "uclinux-uclibc": "common-uclibc",
-        "cygwin": "common-cygwin",
-        "mingw32": "common-mingw",
-    }
-    targetinfo = {
-        "aarch64-linux-gnu": "aarch64-linux",
-        "aarch64_be-linux-gnu": "aarch64_be-linux",
-        "aarch64-linux-gnu_ilp32": "bit-32 aarch64_be-linux arm-32",
-        "aarch64_be-linux-gnu_ilp32": "bit-32 aarch64_be-linux arm-32",
-        "aarch64-linux-musl": "aarch64-linux",
-        "aarch64_be-linux-musl": "aarch64_be-linux",
-        "arm-linux-gnueabi": "arm-linux",
-        "arm-linux-musleabi": "arm-linux",
-        "armeb-linux-gnueabi": "armeb-linux",
-        "armeb-linux-musleabi": "armeb-linux",
-        "loongarch32-linux": "loongarch32-linux",
-        "loongarch64-linux": "loongarch64-linux",
-        "microblazeel-linux" : "microblaze-linux",
-        "microblazeel-linux-musl" : "microblaze-linux",
-        "mips-linux-musl": "mips-linux",
-        "mipsel-linux-musl": "mipsel-linux",
-        "mips64-linux-musl": "mips64-linux",
-        "mips64el-linux-musl": "mips64el-linux",
-        "mips64-linux-gnun32": "mips-linux bit-32",
-        "mips64el-linux-gnun32": "mipsel-linux bit-32",
-        "mipsisa64r6-linux-gnun32": "mipsisa32r6-linux bit-32",
-        "mipsisa64r6el-linux-gnun32": "mipsisa32r6el-linux bit-32",
-        "powerpc-linux": "powerpc32-linux powerpc32-linux-glibc",
-        "powerpc-linux-musl": "powerpc-linux powerpc32-linux powerpc32-linux-musl",
-        "powerpcle-linux": "powerpc32-linux powerpc32-linux-glibc",
-        "powerpcle-linux-musl": "powerpc-linux powerpc32-linux powerpc32-linux-musl",
-        "powerpc-linux-gnuspe": "powerpc-linux powerpc32-linux powerpc32-linux-glibc",
-        "powerpc-linux-muslspe": "powerpc-linux powerpc32-linux powerpc32-linux-musl",
-        "powerpc64-linux-gnuspe": "powerpc-linux powerpc64-linux powerpc64-linux-glibc",
-        "powerpc64-linux-muslspe": "powerpc-linux powerpc64-linux powerpc64-linux-musl",
-        "powerpc64-linux": "powerpc-linux powerpc64-linux powerpc64-linux-glibc",
-        "powerpc64-linux-musl": "powerpc-linux powerpc64-linux powerpc64-linux-musl",
-        "powerpc64le-linux": "powerpc-linux powerpc64-linux powerpc64-linux-glibc",
-        "powerpc64le-linux-musl": "powerpc-linux powerpc64-linux powerpc64-linux-musl",
-        "riscv32-linux": "riscv32-linux",
-        "riscv32-linux-musl": "riscv32-linux",
-        "riscv64-linux": "riscv64-linux",
-        "riscv64-linux-musl": "riscv64-linux",
-        "x86_64-cygwin": "bit-64",
-        "x86_64-darwin": "bit-64",
-        "x86_64-darwin9": "bit-64",
-        "x86_64-darwin19": "bit-64",
-        "x86_64-darwin21": "bit-64",
-        "x86_64-linux": "bit-64",
-        "x86_64-linux-musl": "x86_64-linux bit-64",
-        "x86_64-linux-muslx32": "bit-32 ix86-common x32-linux",
-        "x86_64-elf": "bit-64",
-        "x86_64-linux-gnu": "bit-64 x86_64-linux",
-        "x86_64-linux-gnux32": "bit-32 ix86-common x32-linux",
-        "x86_64-mingw32": "bit-64",
-    }
-
-    # Add in any extra user supplied data which may come from a BSP layer, removing the
-    # need to always change this class directly
-    extra_siteinfo = (d.getVar("SITEINFO_EXTRA_DATAFUNCS") or "").split()
-    for m in extra_siteinfo:
-        call = m + "(archinfo, osinfo, targetinfo, d)"
-        locs = { "archinfo" : archinfo, "osinfo" : osinfo, "targetinfo" : targetinfo, "d" : d}
-        archinfo, osinfo, targetinfo = bb.utils.better_eval(call, locs)
-
-    target = "%s-%s" % (arch, os)
-
-    sitedata = []
-    if arch in archinfo:
-        sitedata.extend(archinfo[arch].split())
-    if os in osinfo:
-        sitedata.extend(osinfo[os].split())
-    if target in targetinfo:
-        sitedata.extend(targetinfo[target].split())
-    sitedata.append(target)
-    sitedata.append("common")
-
-    bb.debug(1, "SITE files %s" % sitedata);
-    return sitedata
-
-def siteinfo_data(d):
-    return siteinfo_data_for_machine(d.getVar("HOST_ARCH"), d.getVar("HOST_OS"), d)
-
-python () {
-    sitedata = set(siteinfo_data(d))
-    if "endian-little" in sitedata:
-        d.setVar("SITEINFO_ENDIANNESS", "le")
-    elif "endian-big" in sitedata:
-        d.setVar("SITEINFO_ENDIANNESS", "be")
-    else:
-        bb.error("Unable to determine endianness for architecture '%s'" %
-                 d.getVar("HOST_ARCH"))
-        bb.fatal("Please add your architecture to siteinfo.bbclass")
-
-    if "bit-32" in sitedata:
-        d.setVar("SITEINFO_BITS", "32")
-    elif "bit-64" in sitedata:
-        d.setVar("SITEINFO_BITS", "64")
-    else:
-        bb.error("Unable to determine bit size for architecture '%s'" %
-                 d.getVar("HOST_ARCH"))
-        bb.fatal("Please add your architecture to siteinfo.bbclass")
-}
-
-# Layers with siteconfig need to add a replacement path to this variable so the
-# sstate isn't path specific
-SITEINFO_PATHVARS = "COREBASE"
-
-def siteinfo_get_files(d, sysrootcache=False):
-    sitedata = siteinfo_data(d)
-    sitefiles = []
-    searched = []
-    for path in d.getVar("BBPATH").split(":"):
-        for element in sitedata:
-            filename = os.path.join(path, "site", element)
-            if os.path.exists(filename):
-                searched.append(filename + ":True")
-                sitefiles.append(filename)
-            else:
-                searched.append(filename + ":False")
-
-    # Have to parameterise out hardcoded paths such as COREBASE for the main site files
-    for var in d.getVar("SITEINFO_PATHVARS").split():
-        searched2 = []
-        replace = os.path.normpath(d.getVar(var))
-        for s in searched:
-            searched2.append(s.replace(replace, "${" + var + "}"))
-        searched = searched2
-
-    if bb.data.inherits_class('native', d) or bb.data.inherits_class('cross', d) or bb.data.inherits_class('crosssdk', d):
-        # We need sstate sigs for native/cross not to vary upon arch so we can't depend on the site files.
-        # In future we may want to depend upon all site files?
-        # This would show up as breaking sstatetests.SStateTests.test_sstate_32_64_same_hash for example
-        searched = []
-
-    return sitefiles, searched
-
-
diff --git a/meta/classes-recipe/sourceforge-releases.bbclass b/meta/classes-recipe/sourceforge-releases.bbclass
deleted file mode 100644
index 0b5e5d0711..0000000000
--- a/meta/classes-recipe/sourceforge-releases.bbclass
+++ /dev/null
@@ -1,2 +0,0 @@
-SOURCEFORGE_PROJECT ?= "${BPN}"
-UPSTREAM_CHECK_URI = "https://sourceforge.net/projects/${SOURCEFORGE_PROJECT}/files/"
diff --git a/meta/classes-recipe/syslinux.bbclass b/meta/classes-recipe/syslinux.bbclass
deleted file mode 100644
index be3b898b4d..0000000000
--- a/meta/classes-recipe/syslinux.bbclass
+++ /dev/null
@@ -1,194 +0,0 @@
-# syslinux.bbclass
-# Copyright (C) 2004-2006, Advanced Micro Devices, Inc.
-# SPDX-License-Identifier: MIT
-
-# Provide syslinux specific functions for building bootable images.
-
-# External variables
-# ${INITRD} - indicates a list of filesystem images to concatenate and use as an initrd (optional)
-# ${ROOTFS} - indicates a filesystem image to include as the root filesystem (optional)
-# ${AUTO_SYSLINUXMENU} - set this to 1 to enable creating an automatic menu
-# ${LABELS} - a list of targets for the automatic config
-# ${APPEND} - an override list of append strings for each label
-# ${SYSLINUX_OPTS} - additional options to add to the syslinux file ';' delimited
-# ${SYSLINUX_SPLASH} - A background for the vga boot menu if using the boot menu
-# ${SYSLINUX_DEFAULT_CONSOLE} - set to "console=ttyX" to change kernel boot default console
-# ${SYSLINUX_SERIAL} - Set an alternate serial port or turn off serial with empty string
-# ${SYSLINUX_SERIAL_TTY} - Set alternate console=tty... kernel boot argument
-# ${SYSLINUX_KERNEL_ARGS} - Add additional kernel arguments
-
-do_bootimg[depends] += "${MLPREFIX}syslinux:do_populate_sysroot \
-                        syslinux-native:do_populate_sysroot"
-
-ISOLINUXDIR ?= "/isolinux"
-SYSLINUXDIR = "/"
-# The kernel has an internal default console, which you can override with
-# a console=...some_tty...
-SYSLINUX_DEFAULT_CONSOLE ?= ""
-SYSLINUX_SERIAL ?= "0 115200"
-SYSLINUX_SERIAL_TTY ?= "console=ttyS0,115200"
-SYSLINUX_PROMPT ?= "0"
-SYSLINUX_TIMEOUT ?= "50"
-AUTO_SYSLINUXMENU ?= "1"
-SYSLINUX_ALLOWOPTIONS ?= "1"
-SYSLINUX_ROOT ?= "${ROOT}"
-SYSLINUX_CFG_VM  ?= "${S}/syslinux_vm.cfg"
-SYSLINUX_CFG_LIVE ?= "${S}/syslinux_live.cfg"
-APPEND ?= ""
-
-# Need UUID utility code.
-inherit fs-uuid
-
-syslinux_populate() {
-        DEST=$1
-        BOOTDIR=$2
-        CFGNAME=$3
-
-        install -d ${DEST}${BOOTDIR}
-
-        # Install the config files
-        install -m 0644 ${SYSLINUX_CFG} ${DEST}${BOOTDIR}/${CFGNAME}
-        if [ "${AUTO_SYSLINUXMENU}" = 1 ] ; then
-                install -m 0644 ${STAGING_DATADIR}/syslinux/vesamenu.c32 ${DEST}${BOOTDIR}/vesamenu.c32
-                install -m 0444 ${STAGING_DATADIR}/syslinux/libcom32.c32 ${DEST}${BOOTDIR}/libcom32.c32
-                install -m 0444 ${STAGING_DATADIR}/syslinux/libutil.c32 ${DEST}${BOOTDIR}/libutil.c32
-                if [ "${SYSLINUX_SPLASH}" != "" ] ; then
-                        install -m 0644 ${SYSLINUX_SPLASH} ${DEST}${BOOTDIR}/splash.lss
-                fi
-        fi
-}
-
-syslinux_iso_populate() {
-        iso_dir=$1
-        syslinux_populate $iso_dir ${ISOLINUXDIR} isolinux.cfg
-        install -m 0644 ${STAGING_DATADIR}/syslinux/isolinux.bin $iso_dir${ISOLINUXDIR}
-        install -m 0644 ${STAGING_DATADIR}/syslinux/ldlinux.c32 $iso_dir${ISOLINUXDIR}
-}
-
-syslinux_hddimg_populate() {
-        hdd_dir=$1
-        syslinux_populate $hdd_dir ${SYSLINUXDIR} syslinux.cfg
-        install -m 0444 ${STAGING_DATADIR}/syslinux/ldlinux.sys $hdd_dir${SYSLINUXDIR}/ldlinux.sys
-}
-
-syslinux_hddimg_install() {
-        syslinux ${IMGDEPLOYDIR}/${IMAGE_NAME}.hddimg
-}
-
-python build_syslinux_cfg () {
-    import copy
-    import sys
-
-    workdir = d.getVar('WORKDIR')
-    if not workdir:
-        bb.error("WORKDIR not defined, unable to package")
-        return
-        
-    labels = d.getVar('LABELS')
-    if not labels:
-        bb.debug(1, "LABELS not defined, nothing to do")
-        return
-    
-    if labels == []:
-        bb.debug(1, "No labels, nothing to do")
-        return
-
-    cfile = d.getVar('SYSLINUX_CFG')
-    if not cfile:
-        bb.fatal('Unable to read SYSLINUX_CFG')
-
-    try:
-        cfgfile = open(cfile, 'w')
-    except OSError:
-        bb.fatal('Unable to open %s' % cfile)
-
-    cfgfile.write('# Automatically created by OE\n')
-
-    opts = d.getVar('SYSLINUX_OPTS')
-
-    if opts:
-        for opt in opts.split(';'):
-            cfgfile.write('%s\n' % opt)
-
-    allowoptions = d.getVar('SYSLINUX_ALLOWOPTIONS')
-    if allowoptions:
-        cfgfile.write('ALLOWOPTIONS %s\n' % allowoptions)
-    else:
-        cfgfile.write('ALLOWOPTIONS 1\n')
-
-    syslinux_default_console = d.getVar('SYSLINUX_DEFAULT_CONSOLE')
-    syslinux_serial_tty = d.getVar('SYSLINUX_SERIAL_TTY')
-    syslinux_serial = d.getVar('SYSLINUX_SERIAL')
-    if syslinux_serial:
-        cfgfile.write('SERIAL %s\n' % syslinux_serial)
-
-    menu = (d.getVar('AUTO_SYSLINUXMENU') == "1")
-
-    if menu and syslinux_serial:
-        cfgfile.write('DEFAULT Graphics console %s\n' % (labels.split()[0]))
-    else:
-        cfgfile.write('DEFAULT %s\n' % (labels.split()[0]))
-
-    timeout = d.getVar('SYSLINUX_TIMEOUT')
-
-    if timeout:
-        cfgfile.write('TIMEOUT %s\n' % timeout)
-    else:
-        cfgfile.write('TIMEOUT 50\n')
-
-    prompt = d.getVar('SYSLINUX_PROMPT')
-    if prompt:
-        cfgfile.write('PROMPT %s\n' % prompt)
-    else:
-        cfgfile.write('PROMPT 1\n')
-
-    if menu:
-        cfgfile.write('ui vesamenu.c32\n')
-        cfgfile.write('menu title Select kernel options and boot kernel\n')
-        cfgfile.write('menu tabmsg Press [Tab] to edit, [Return] to select\n')
-        splash = d.getVar('SYSLINUX_SPLASH')
-        if splash:
-            cfgfile.write('menu background splash.lss\n')
-    
-    for label in labels.split():
-        localdata = bb.data.createCopy(d)
-
-        overrides = localdata.getVar('OVERRIDES')
-        if not overrides:
-            bb.fatal('OVERRIDES not defined')
-
-        localdata.setVar('OVERRIDES', label + ':' + overrides)
-    
-        btypes = [ [ "", syslinux_default_console ] ]
-        if menu and syslinux_serial:
-            btypes = [ [ "Graphics console ", syslinux_default_console  ],
-                [ "Serial console ", syslinux_serial_tty ] ]
-
-        root= d.getVar('SYSLINUX_ROOT')
-        if not root:
-            bb.fatal('SYSLINUX_ROOT not defined')
-
-        kernel = localdata.getVar('KERNEL_IMAGETYPE')
-        for btype in btypes:
-            cfgfile.write('LABEL %s%s\nKERNEL /%s\n' % (btype[0], label, kernel))
-
-            exargs = d.getVar('SYSLINUX_KERNEL_ARGS')
-            if exargs:
-                btype[1] += " " + exargs
-
-            append = localdata.getVar('APPEND')
-            initrd = localdata.getVar('INITRD')
-
-            append = root + " " + append
-            cfgfile.write('APPEND ')
-
-            if initrd:
-                cfgfile.write('initrd=/initrd ')
-
-            cfgfile.write('LABEL=%s '% (label))
-            append = replace_rootfs_uuid(d, append)
-            cfgfile.write('%s %s\n' % (append, btype[1]))
-
-    cfgfile.close()
-}
-build_syslinux_cfg[dirs] = "${S}"
diff --git a/meta/classes-recipe/systemd-boot-cfg.bbclass b/meta/classes-recipe/systemd-boot-cfg.bbclass
deleted file mode 100644
index 12da41ebad..0000000000
--- a/meta/classes-recipe/systemd-boot-cfg.bbclass
+++ /dev/null
@@ -1,77 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-SYSTEMD_BOOT_CFG ?= "${S}/loader.conf"
-SYSTEMD_BOOT_ENTRIES ?= ""
-SYSTEMD_BOOT_TIMEOUT ?= "10"
-
-# Uses MACHINE specific KERNEL_IMAGETYPE
-PACKAGE_ARCH = "${MACHINE_ARCH}"
-
-# Need UUID utility code.
-inherit fs-uuid
-
-python build_efi_cfg() {
-    s = d.getVar("S")
-    labels = d.getVar('LABELS')
-    if not labels:
-        bb.debug(1, "LABELS not defined, nothing to do")
-        return
-
-    if labels == []:
-        bb.debug(1, "No labels, nothing to do")
-        return
-
-    cfile = d.getVar('SYSTEMD_BOOT_CFG')
-    cdir = os.path.dirname(cfile)
-    if not os.path.exists(cdir):
-        os.makedirs(cdir)
-    try:
-         cfgfile = open(cfile, 'w')
-    except OSError:
-        bb.fatal('Unable to open %s' % cfile)
-
-    cfgfile.write('# Automatically created by OE\n')
-    cfgfile.write('default %s.conf\n' % (labels.split()[0]))
-    timeout = d.getVar('SYSTEMD_BOOT_TIMEOUT')
-    if timeout:
-        cfgfile.write('timeout %s\n' % timeout)
-    else:
-        cfgfile.write('timeout 10\n')
-    cfgfile.close()
-
-    for label in labels.split():
-        localdata = d.createCopy()
-
-        entryfile = "%s/%s.conf" % (s, label)
-        if not os.path.exists(s):
-            os.makedirs(s)
-        d.appendVar("SYSTEMD_BOOT_ENTRIES", " " + entryfile)
-        try:
-            entrycfg = open(entryfile, "w")
-        except OSError:
-            bb.fatal('Unable to open %s' % entryfile)
-
-        entrycfg.write('title %s\n' % label)
-
-        kernel = localdata.getVar("KERNEL_IMAGETYPE")
-        entrycfg.write('linux /%s\n' % kernel)
-
-        append = localdata.getVar('APPEND')
-        initrd = localdata.getVar('INITRD')
-
-        if initrd:
-            entrycfg.write('initrd /initrd\n')
-        lb = label
-        if label == "install":
-            lb = "install-efi"
-        entrycfg.write('options LABEL=%s ' % lb)
-        if append:
-            append = replace_rootfs_uuid(d, append)
-            entrycfg.write('%s' % append)
-        entrycfg.write('\n')
-        entrycfg.close()
-}
diff --git a/meta/classes-recipe/systemd-boot.bbclass b/meta/classes-recipe/systemd-boot.bbclass
deleted file mode 100644
index 5aa32dd997..0000000000
--- a/meta/classes-recipe/systemd-boot.bbclass
+++ /dev/null
@@ -1,35 +0,0 @@
-# Copyright (C) 2016 Intel Corporation
-#
-# SPDX-License-Identifier: MIT
-
-# systemd-boot.bbclass - The "systemd-boot" is essentially the gummiboot merged into systemd.
-#                        The original standalone gummiboot project is dead without any more
-#                        maintenance.
-#
-# Set EFI_PROVIDER = "systemd-boot" to use systemd-boot on your live images instead of grub-efi
-# (images built by image-live.bbclass)
-
-do_bootimg[depends] += "${MLPREFIX}systemd-boot:do_deploy"
-
-require conf/image-uefi.conf
-# Need UUID utility code.
-inherit fs-uuid
-
-efi_populate() {
-        efi_populate_common "$1" systemd
-
-        # systemd-boot requires these paths for configuration files
-        # they are not customizable so no point in new vars
-        install -d ${DEST}/loader
-        install -d ${DEST}/loader/entries
-        install -m 0644 ${SYSTEMD_BOOT_CFG} ${DEST}/loader/loader.conf
-        for i in ${SYSTEMD_BOOT_ENTRIES}; do
-            install -m 0644 ${i} ${DEST}/loader/entries
-        done
-}
-
-efi_iso_populate:append() {
-        cp -r $iso_dir/loader ${EFIIMGDIR}
-}
-
-inherit systemd-boot-cfg
diff --git a/meta/classes-recipe/systemd.bbclass b/meta/classes-recipe/systemd.bbclass
deleted file mode 100644
index 562e71fb56..0000000000
--- a/meta/classes-recipe/systemd.bbclass
+++ /dev/null
@@ -1,303 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-# The list of packages that should have systemd packaging scripts added.  For
-# each entry, optionally have a SYSTEMD_SERVICE:[package] that lists the service
-# files in this package.  If this variable isn't set, [package].service is used.
-SYSTEMD_PACKAGES ?= "${PN}"
-SYSTEMD_PACKAGES:class-native ?= ""
-SYSTEMD_PACKAGES:class-nativesdk ?= ""
-
-# Whether to enable or disable the services on installation.
-SYSTEMD_AUTO_ENABLE ??= "enable"
-
-# This class will be included in any recipe that supports systemd init scripts,
-# even if systemd is not in DISTRO_FEATURES.  As such don't make any changes
-# directly but check the DISTRO_FEATURES first.
-python __anonymous() {
-    # If the distro features have systemd but not sysvinit, inhibit update-rcd
-    # from doing any work so that pure-systemd images don't have redundant init
-    # files.
-    if bb.utils.contains('DISTRO_FEATURES', 'systemd', True, False, d):
-        d.appendVar("DEPENDS", " systemd-systemctl-native")
-        d.appendVar("PACKAGE_WRITE_DEPS", " systemd-systemctl-native")
-        if not bb.utils.contains('DISTRO_FEATURES', 'sysvinit', True, False, d):
-            d.setVar("INHIBIT_UPDATERCD_BBCLASS", "1")
-}
-
-systemd_postinst() {
-if type systemctl >/dev/null 2>/dev/null; then
-        OPTS=""
-
-        if [ -n "$D" ]; then
-                OPTS="--root=$D"
-        fi
-
-        if [ "${SYSTEMD_AUTO_ENABLE}" = "enable" ]; then
-                for service in ${@systemd_filter_services("${SYSTEMD_SERVICE_ESCAPED}", False, d)}; do
-                        systemctl ${OPTS} enable "$service"
-                done
-
-                for service in ${@systemd_filter_services("${SYSTEMD_SERVICE_ESCAPED}", True, d)}; do
-                        systemctl --global ${OPTS} enable "$service"
-                done
-        fi
-
-        if [ -z "$D" ] && systemctl >/dev/null 2>/dev/null; then
-                # Reload only system service manager
-                # --global for daemon-reload is not supported: https://github.com/systemd/systemd/issues/19284
-                systemctl daemon-reload
-                [ -n "${@systemd_filter_services("${SYSTEMD_SERVICE_ESCAPED}", False, d)}" ] && \
-                        systemctl preset ${@systemd_filter_services("${SYSTEMD_SERVICE_ESCAPED}", False, d)}
-
-                [ -n "${@systemd_filter_services("${SYSTEMD_SERVICE_ESCAPED}", True, d)}" ] && \
-                        systemctl --global preset ${@systemd_filter_services("${SYSTEMD_SERVICE_ESCAPED}", True, d)}
-
-                if [ "${SYSTEMD_AUTO_ENABLE}" = "enable" ]; then
-                        # --global flag for restart is not supported by systemd (see above)
-                        [ -n "${@systemd_filter_services("${SYSTEMD_SERVICE_ESCAPED}", False, d)}" ] && \
-                                systemctl --no-block restart ${@systemd_filter_services("${SYSTEMD_SERVICE_ESCAPED}", False, d)}
-                fi
-        fi
-fi
-}
-
-systemd_prerm() {
-if type systemctl >/dev/null 2>/dev/null; then
-        if [ -z "$D" ] && systemctl >/dev/null 2>/dev/null; then
-                if [ -n "${@systemd_filter_services("${SYSTEMD_SERVICE_ESCAPED}", False, d)}" ]; then
-                        systemctl stop ${@systemd_filter_services("${SYSTEMD_SERVICE_ESCAPED}", False, d)}
-                        systemctl disable ${@systemd_filter_services("${SYSTEMD_SERVICE_ESCAPED}", False, d)}
-                fi
-
-                # same as above, --global flag is not supported for stop so do disable only
-                if [ -n "${@systemd_filter_services("${SYSTEMD_SERVICE_ESCAPED}", True, d)}" ]; then
-                        systemctl --global disable ${@systemd_filter_services("${SYSTEMD_SERVICE_ESCAPED}", True, d)}
-                fi
-        fi
-fi
-}
-
-
-systemd_populate_packages[vardeps] += "systemd_prerm systemd_postinst"
-systemd_populate_packages[vardepsexclude] += "OVERRIDES"
-
-
-def systemd_service_path(service, searchpaths, d):
-    path_found = ''
-
-    # Deal with adding, for example, 'ifplugd@eth0.service' from
-    # 'ifplugd@.service'
-    base = None
-    at = service.find('@')
-    if at != -1:
-        ext = service.rfind('.')
-        base = service[:at] + '@' + service[ext:]
-
-    for path in searchpaths:
-        if os.path.lexists(oe.path.join(d.getVar("D"), path, service)):
-            path_found = path
-            break
-        elif base is not None:
-            if os.path.exists(oe.path.join(d.getVar("D"), path, base)):
-                path_found = path
-                break
-
-    return path_found, base
-
-def systemd_service_searchpaths(user, d):
-    if user:
-        return [
-            oe.path.join(d.getVar("sysconfdir"), "systemd", "user"),
-            d.getVar("systemd_user_unitdir"),
-        ]
-    else:
-        return [
-            oe.path.join(d.getVar("sysconfdir"), "systemd", "system"),
-            d.getVar("systemd_system_unitdir"),
-        ]
-
-def systemd_service_exists(service, user, d):
-    searchpaths = systemd_service_searchpaths(user, d)
-    path, _ = systemd_service_path(service, searchpaths, d)
-
-    return path != ''
-
-def systemd_filter_services(services, user, d):
-    return ' '.join(service for service in services.split() if systemd_service_exists(service, user, d))
-
-python systemd_populate_packages() {
-    import re
-    import shlex
-
-    if not bb.utils.contains('DISTRO_FEATURES', 'systemd', True, False, d):
-        return
-
-    def get_package_var(d, var, pkg):
-        val = (d.getVar('%s:%s' % (var, pkg)) or "").strip()
-        if val == "":
-            val = (d.getVar(var) or "").strip()
-        return val
-
-    # Check if systemd-packages already included in PACKAGES
-    def systemd_check_package(pkg_systemd):
-        packages = d.getVar('PACKAGES')
-        if not pkg_systemd in packages.split():
-            bb.error('%s is marked for packaging systemd scripts, but it does not appear in package list, please add it to PACKAGES or adjust SYSTEMD_PACKAGES accordingly' % pkg_systemd)
-
-
-    def systemd_generate_package_scripts(pkg):
-        bb.debug(1, 'adding systemd calls to postinst/postrm for %s' % pkg)
-
-        paths_escaped = ' '.join(shlex.quote(s) for s in d.getVar('SYSTEMD_SERVICE:' + pkg).split())
-        d.setVar('SYSTEMD_SERVICE_ESCAPED:' + pkg, paths_escaped)
-
-        # Add pkg to the overrides so that it finds the SYSTEMD_SERVICE:pkg
-        # variable.
-        localdata = d.createCopy()
-        localdata.prependVar("OVERRIDES", pkg + ":")
-
-        postinst = d.getVar('pkg_postinst:%s' % pkg)
-        if not postinst:
-            postinst = '#!/bin/sh\n'
-        postinst += localdata.getVar('systemd_postinst')
-        d.setVar('pkg_postinst:%s' % pkg, postinst)
-
-        prerm = d.getVar('pkg_prerm:%s' % pkg)
-        if not prerm:
-            prerm = '#!/bin/sh\n'
-        prerm += localdata.getVar('systemd_prerm')
-        d.setVar('pkg_prerm:%s' % pkg, prerm)
-
-
-    # Add files to FILES:*-systemd if existent and not already done
-    def systemd_append_file(pkg_systemd, file_append):
-        appended = False
-        if os.path.exists(oe.path.join(d.getVar("D"), file_append)):
-            var_name = "FILES:" + pkg_systemd
-            files = d.getVar(var_name, False) or ""
-            if file_append not in files.split():
-                d.appendVar(var_name, " " + file_append)
-                appended = True
-        return appended
-
-    # Add systemd files to FILES:*-systemd, parse for Also= and follow recursive
-    def systemd_add_files_and_parse(pkg_systemd, path, service):
-        # avoid infinite recursion
-        if systemd_append_file(pkg_systemd, oe.path.join(path, service)):
-            fullpath = oe.path.join(d.getVar("D"), path, service)
-            if service.find('.service') != -1:
-                # for *.service add *@.service
-                service_base = service.replace('.service', '')
-                systemd_add_files_and_parse(pkg_systemd, path, service_base + '@.service')
-                # Add the socket unit which is referred by the Also= in this service file to the same package.
-                with open(fullpath, 'r') as unit_f:
-                    for line in unit_f:
-                        if line.startswith('Also'):
-                            also_unit = line.split('=', 1)[1].strip()
-                            if also_unit.find('.socket') != -1:
-                                systemd_add_files_and_parse(pkg_systemd, path, also_unit)
-            if service.find('.socket') != -1:
-                # for *.socket add *.service and *@.service
-                service_base = service.replace('.socket', '')
-                systemd_add_files_and_parse(pkg_systemd, path, service_base + '.service')
-                systemd_add_files_and_parse(pkg_systemd, path, service_base + '@.service')
-
-    # Check service-files and call systemd_add_files_and_parse for each entry
-    def systemd_check_services():
-        searchpaths = systemd_service_searchpaths(False, d)
-        searchpaths.extend(systemd_service_searchpaths(True, d))
-
-        systemd_packages = d.getVar('SYSTEMD_PACKAGES')
-
-        # scan for all in SYSTEMD_SERVICE[]
-        for pkg_systemd in systemd_packages.split():
-            for service in get_package_var(d, 'SYSTEMD_SERVICE', pkg_systemd).split():
-                path_found, base = systemd_service_path(service, searchpaths, d)
-
-                if path_found != '':
-                    systemd_add_files_and_parse(pkg_systemd, path_found, service)
-                else:
-                    bb.fatal("Didn't find service unit '{0}', specified in SYSTEMD_SERVICE:{1}. {2}".format(
-                        service, pkg_systemd, "Also looked for service unit '{0}'.".format(base) if base is not None else ""))
-
-    def systemd_create_presets(pkg, action, user):
-        import re
-
-        # Check there is at least one service of given type (system/user), don't
-        # create empty files.
-        needs_preset = False
-        for service in d.getVar('SYSTEMD_SERVICE:%s' % pkg).split():
-            if systemd_service_exists(service, user, d):
-                needs_preset = True
-                break
-
-        if not needs_preset:
-            return
-
-        prefix = "user" if user else "system"
-        presetf = oe.path.join(d.getVar("PKGD"), d.getVar("systemd_unitdir"), "%s-preset/98-%s.preset" % (prefix, pkg))
-        bb.utils.mkdirhier(os.path.dirname(presetf))
-        with open(presetf, 'a') as fd:
-            template_services = {}
-            for service in d.getVar('SYSTEMD_SERVICE:%s' % pkg).split():
-                if not systemd_service_exists(service, user, d):
-                    continue
-                if '@' in service and '@.' not in service:
-                    (servicename, postfix) = service.split('@')
-                    (instance, service_type) = postfix.rsplit('.', 1)
-                    template_services.setdefault(servicename + '@.' + service_type, []).append(instance)
-                else:
-                    template_services.setdefault(service, [])
-            for template, instances in template_services.items():
-                if instances:
-                    fd.write("%s %s %s\n" % (action, template, ' '.join(instances)))
-                else:
-                    fd.write("%s %s\n" % (action, template))
-        d.appendVar("FILES:%s" % pkg, ' ' + oe.path.join(d.getVar("systemd_unitdir"), "%s-preset/98-%s.preset" % (prefix, pkg)))
-
-    # Run all modifications once when creating package
-    if os.path.exists(d.getVar("D")):
-        for pkg in d.getVar('SYSTEMD_PACKAGES').split():
-            systemd_check_package(pkg)
-            if d.getVar('SYSTEMD_SERVICE:' + pkg):
-                systemd_generate_package_scripts(pkg)
-                action = get_package_var(d, 'SYSTEMD_AUTO_ENABLE', pkg)
-                if action in ("enable", "disable"):
-                    systemd_create_presets(pkg, action, False)
-                    systemd_create_presets(pkg, action, True)
-                elif action not in ("mask", "preset"):
-                    bb.fatal("SYSTEMD_AUTO_ENABLE:%s '%s' is not 'enable', 'disable', 'mask' or 'preset'" % (pkg, action))
-        systemd_check_services()
-}
-
-PACKAGESPLITFUNCS =+ "systemd_populate_packages"
-
-rm_systemd_unitdir() {
-        rm -rf ${D}${systemd_unitdir}
-        # Change into ${D} and use a relative path with rmdir -p to avoid
-        # having it remove ${D} if it becomes empty.
-        (cd ${D} && rmdir -p $(dirname ${systemd_unitdir#/}) 2>/dev/null || :)
-}
-
-rm_sysvinit_initddir() {
-        local sysv_initddir=${INIT_D_DIR}
-        : ${sysv_initddir:=${sysconfdir}/init.d}
-
-        # If systemd_system_unitdir contains anything, delete sysv_initddir
-        if [ "$(ls -A ${D}${systemd_system_unitdir} 2>/dev/null)" ]; then
-                rm -rf ${D}$sysv_initddir
-                rmdir -p $(dirname ${D}$sysv_initddir) 2>/dev/null || :
-        fi
-}
-
-do_install[postfuncs] += "${RMINITDIR}"
-RMINITDIR = " \
-    ${@bb.utils.contains('DISTRO_FEATURES', 'systemd', '', 'rm_systemd_unitdir', d)} \
-    ${@'rm_sysvinit_initddir' if bb.utils.contains('DISTRO_FEATURES', 'systemd', True, False, d) and \
-                                 not bb.utils.contains('DISTRO_FEATURES', 'sysvinit', True, False, d) else ''} \
-"
-RMINITDIR:class-native = ""
diff --git a/meta/classes-recipe/testexport.bbclass b/meta/classes-recipe/testexport.bbclass
deleted file mode 100644
index 843d777e3b..0000000000
--- a/meta/classes-recipe/testexport.bbclass
+++ /dev/null
@@ -1,183 +0,0 @@
-# Copyright (C) 2016 Intel Corporation
-#
-# SPDX-License-Identifier: MIT
-#
-# testexport.bbclass allows to execute runtime test outside OE environment.
-# Most of the tests are commands run on target image over ssh.
-# To use it add testexport to global inherit and call your target image with -c testexport
-# You can try it out like this:
-# - First build an image. i.e. core-image-sato
-# - Add IMAGE_CLASSES += "testexport" in local.conf
-# - Then bitbake core-image-sato -c testexport. That will generate the directory structure
-#   to execute the runtime tests using runexported.py.
-#
-# For more information on TEST_SUITES check testimage class.
-
-inherit testimage
-
-TEST_LOG_DIR ?= "${WORKDIR}/testexport"
-TEST_EXPORT_DIR ?= "${TMPDIR}/testexport/${PN}"
-TEST_EXPORT_PACKAGED_DIR ?= "packages/packaged"
-TEST_EXPORT_EXTRACTED_DIR ?= "packages/extracted"
-
-TEST_TARGET ?= "simpleremote"
-TEST_TARGET_IP ?= ""
-TEST_SERVER_IP ?= ""
-
-require conf/testexport.conf
-
-TEST_EXPORT_SDK_ENABLED ?= "0"
-
-TEST_EXPORT_DEPENDS = ""
-TEST_EXPORT_DEPENDS += "${@bb.utils.contains('TEST_EXPORT_SDK_ENABLED', '1', 'testexport-tarball:do_populate_sdk', '', d)}"
-TEST_EXPORT_LOCK = "${TMPDIR}/testimage.lock"
-
-addtask testexport
-do_testexport[nostamp] = "1"
-do_testexport[depends] += "${TEST_EXPORT_DEPENDS} ${TESTIMAGEDEPENDS}"
-do_testexport[lockfiles] += "${TEST_EXPORT_LOCK}"
-
-python do_testexport() {
-    testexport_main(d)
-}
-
-def testexport_main(d):
-    import json
-    import logging
-
-    from oeqa.runtime.context import OERuntimeTestContext
-    from oeqa.runtime.context import OERuntimeTestContextExecutor
-
-    image_name = ("%s/%s" % (d.getVar('DEPLOY_DIR_IMAGE'),
-                             d.getVar('IMAGE_LINK_NAME') or d.getVar('IMAGE_NAME')))
-
-    tdname = "%s.testdata.json" % image_name
-    td = json.load(open(tdname, "r"))
-
-    logger = logging.getLogger("BitBake")
-
-    target_kwargs = { }
-    target_kwargs['machine'] = d.getVar("MACHINE") or None
-    target_kwargs['serialcontrol_cmd'] = d.getVar("TEST_SERIALCONTROL_CMD") or None
-    target_kwargs['serialcontrol_extra_args'] = d.getVar("TEST_SERIALCONTROL_EXTRA_ARGS") or ""
-    target_kwargs['serialcontrol_ps1'] = d.getVar("TEST_SERIALCONTROL_PS1") or None
-    target_kwargs['serialcontrol_connect_timeout'] = d.getVar("TEST_SERIALCONTROL_CONNECT_TIMEOUT") or None
-
-    target = OERuntimeTestContextExecutor.getTarget(
-        d.getVar("TEST_TARGET"), None, d.getVar("TEST_TARGET_IP"),
-        d.getVar("TEST_SERVER_IP"), **target_kwargs)
-
-    image_manifest = "%s.manifest" % image_name
-    image_packages = OERuntimeTestContextExecutor.readPackagesManifest(image_manifest)
-
-    extract_dir = d.getVar("TEST_EXTRACTED_DIR")
-
-    tc = OERuntimeTestContext(td, logger, target, image_packages, extract_dir)
-
-    copy_needed_files(d, tc)
-
-def copy_needed_files(d, tc):
-    import shutil
-    import oe.path
-
-    from oeqa.utils.package_manager import _get_json_file
-    from oeqa.core.utils.test import getSuiteCasesFiles
-
-    export_path = d.getVar('TEST_EXPORT_DIR')
-    corebase_path = d.getVar('COREBASE')
-    bblayers = d.getVar('BBLAYERS').split()
-
-    # Clean everything before starting
-    oe.path.remove(export_path)
-    bb.utils.mkdirhier(os.path.join(export_path, 'lib', 'oeqa'))
-
-    # The source of files to copy are relative to 'COREBASE' directory
-    # The destination is relative to 'TEST_EXPORT_DIR'
-    # core files/dirs first
-    core_files_to_copy = [ os.path.join('scripts', 'oe-test'),
-                      os.path.join('scripts', 'lib', 'argparse_oe.py'),
-                      os.path.join('scripts', 'lib', 'scriptutils.py'), ]
-    for f in core_files_to_copy:
-        src = os.path.join(corebase_path, f)
-        dst = os.path.join(export_path, f.split('/', 1)[-1])
-        if os.path.isdir(src):
-            oe.path.copytree(src, dst)
-        else:
-            shutil.copy2(src, dst)
-
-    # layer specific files/dirs
-    layer_files_to_copy = [ os.path.join('lib', 'oeqa', 'core'),
-                      os.path.join('lib', 'oeqa', 'runtime'),
-                      os.path.join('lib', 'oeqa', 'files'),
-                      os.path.join('lib', 'oeqa', 'utils'),]
-    for layer in bblayers:
-        meta = os.path.basename(layer)
-        for f in layer_files_to_copy:
-            src = os.path.join(layer, f)
-            dst = os.path.join(export_path, meta, f)
-            if os.path.exists(src):
-                if os.path.isdir(src):
-                    oe.path.copytree(src, dst)
-                else:
-                    shutil.copy2(src, dst)
-
-    # Copy test data
-    image_name = ("%s/%s" % (d.getVar('DEPLOY_DIR_IMAGE'),
-                            d.getVar('IMAGE_LINK_NAME')))
-    image_manifest = "%s.manifest" % image_name
-    tdname = "%s.testdata.json" % image_name
-    test_data_path = os.path.join(export_path, 'data')
-    bb.utils.mkdirhier(test_data_path)
-    shutil.copy2(image_manifest, os.path.join(test_data_path, 'manifest'))
-    shutil.copy2(tdname, os.path.join(test_data_path, 'testdata.json'))
-
-    for subdir, dirs, files in os.walk(export_path):
-        for dir in dirs:
-            if dir == '__pycache__':
-                shutil.rmtree(os.path.join(subdir, dir))
-
-    # Create tar file for common parts of testexport
-    testexport_create_tarball(d, "testexport.tar.gz", d.getVar("TEST_EXPORT_DIR"))
-
-    # Copy packages needed for runtime testing
-    test_paths = get_runtime_paths(d)
-    test_modules = d.getVar('TEST_SUITES').split()
-    tc.loadTests(test_paths, modules=test_modules)
-    package_extraction(d, tc.suites)
-    test_pkg_dir = d.getVar("TEST_NEEDED_PACKAGES_DIR")
-    if os.path.isdir(test_pkg_dir) and os.listdir(test_pkg_dir):
-        export_pkg_dir = os.path.join(d.getVar("TEST_EXPORT_DIR"), "packages")
-        oe.path.copytree(test_pkg_dir, export_pkg_dir)
-        # Create tar file for packages needed by the DUT
-        testexport_create_tarball(d, "testexport_packages_%s.tar.gz" % d.getVar("MACHINE"), export_pkg_dir)
-
-    # Copy SDK
-    if d.getVar("TEST_EXPORT_SDK_ENABLED") == "1":
-        sdk_deploy = d.getVar("SDK_DEPLOY")
-        tarball_name = "%s.sh" % d.getVar("TEST_EXPORT_SDK_NAME")
-        tarball_path = os.path.join(sdk_deploy, tarball_name)
-        export_sdk_dir = os.path.join(d.getVar("TEST_EXPORT_DIR"),
-                                      d.getVar("TEST_EXPORT_SDK_DIR"))
-        bb.utils.mkdirhier(export_sdk_dir)
-        shutil.copy2(tarball_path, export_sdk_dir)
-
-        # Create tar file for the sdk
-        testexport_create_tarball(d, "testexport_sdk_%s.tar.gz" % d.getVar("SDK_ARCH"), export_sdk_dir)
-
-    bb.plain("Exported tests to: %s" % export_path)
-
-def testexport_create_tarball(d, tar_name, src_dir):
-
-    import tarfile
-
-    tar_path = os.path.join(d.getVar("TEST_EXPORT_DIR"), tar_name)
-    current_dir = os.getcwd()
-    src_dir = src_dir.rstrip('/')
-    dir_name = os.path.dirname(src_dir)
-    base_name = os.path.basename(src_dir)
-
-    os.chdir(dir_name)
-    tar = tarfile.open(tar_path, "w:gz")
-    tar.add(base_name)
-    tar.close()
-    os.chdir(current_dir)
diff --git a/meta/classes-recipe/testimage.bbclass b/meta/classes-recipe/testimage.bbclass
deleted file mode 100644
index 847a6f18a8..0000000000
--- a/meta/classes-recipe/testimage.bbclass
+++ /dev/null
@@ -1,488 +0,0 @@
-# Copyright (C) 2013 Intel Corporation
-#
-# SPDX-License-Identifier: MIT
-
-inherit metadata_scm
-inherit image-artifact-names
-
-# testimage.bbclass enables testing of qemu images using python unittests.
-# Most of the tests are commands run on target image over ssh.
-# To use it add testimage to global inherit and call your target image with -c testimage
-# You can try it out like this:
-# - first add IMAGE_CLASSES += "testimage" in local.conf
-# - build a qemu core-image-sato
-# - then bitbake core-image-sato -c testimage. That will run a standard suite of tests.
-#
-# The tests can be run automatically each time an image is built if you set
-# TESTIMAGE_AUTO = "1"
-
-TESTIMAGE_AUTO ??= "0"
-
-# When any test fails, TESTIMAGE_FAILED_QA ARTIFACTS will be parsed and for
-# each entry in it, if artifact pointed by path description exists on target,
-# it will be retrieved onto host
-
-TESTIMAGE_FAILED_QA_ARTIFACTS = "\
-    ${localstatedir}/log \
-    ${localstatedir}/volatile/log \
-    ${sysconfdir}/version \
-    ${sysconfdir}/os-release \
-    ${nonarch_libdir}/os-release \
-"
-
-# If some ptests are run and fail, retrieve corresponding directories
-TESTIMAGE_FAILED_QA_ARTIFACTS += "${@bb.utils.contains('DISTRO_FEATURES', 'ptest', '${libdir}/*/ptest', '', d)}"
-
-# You can set (or append to) TEST_SUITES in local.conf to select the tests
-# which you want to run for your target.
-# The test names are the module names in meta/lib/oeqa/runtime/cases.
-# Each name in TEST_SUITES represents a required test for the image. (no skipping allowed)
-# Appending "auto" means that it will try to run all tests that are suitable for the image (each test decides that on it's own).
-# Note that order in TEST_SUITES is relevant: tests are run in an order such that
-# tests mentioned in @skipUnlessPassed run before the tests that depend on them,
-# but without such dependencies, tests run in the order in which they are listed
-# in TEST_SUITES.
-#
-# A layer can add its own tests in lib/oeqa/runtime, provided it extends BBPATH as normal in its layer.conf.
-
-# TEST_LOG_DIR contains a command ssh log and may contain infromation about what command is running, output and return codes and for qemu a boot log till login.
-# Booting is handled by this class, and it's not a test in itself.
-# TEST_QEMUBOOT_TIMEOUT can be used to set the maximum time in seconds the launch code will wait for the login prompt.
-# TEST_OVERALL_TIMEOUT can be used to set the maximum time in seconds the tests will be allowed to run (defaults to no limit).
-# TEST_QEMUPARAMS can be used to pass extra parameters to qemu, e.g. "-m 1024" for setting the amount of ram to 1 GB.
-# TEST_RUNQEMUPARAMS can be used to pass extra parameters to runqemu, e.g. "gl" to enable OpenGL acceleration.
-# QEMU_USE_KVM can be set to "" to disable the use of kvm (by default it is enabled if target_arch == build_arch or both of them are x86 archs)
-
-# TESTIMAGE_BOOT_PATTERNS can be used to override certain patterns used to communicate with the target when booting,
-# if a pattern is not specifically present on this variable a default will be used when booting the target.
-# TESTIMAGE_BOOT_PATTERNS[<flag>] overrides the pattern used for that specific flag, where flag comes from a list of accepted flags
-# e.g. normally the system boots and waits for a login prompt (login:), after that it sends the command: "root\n" to log as the root user
-# if we wanted to log in as the hypothetical "webserver" user for example we could set the following:
-# TESTIMAGE_BOOT_PATTERNS = "send_login_user search_login_succeeded"
-# TESTIMAGE_BOOT_PATTERNS[send_login_user] = "webserver\n"
-# TESTIMAGE_BOOT_PATTERNS[search_login_succeeded] = "webserver@[a-zA-Z0-9\-]+:~#"
-# The accepted flags are the following: search_reached_prompt, send_login_user, search_login_succeeded, search_cmd_finished.
-# They are prefixed with either search/send, to differentiate if the pattern is meant to be sent or searched to/from the target terminal
-
-TEST_LOG_DIR ?= "${WORKDIR}/testimage"
-
-TEST_EXPORT_DIR ?= "${TMPDIR}/testimage/${PN}"
-TEST_INSTALL_TMP_DIR ?= "${WORKDIR}/testimage/install_tmp"
-TEST_NEEDED_PACKAGES_DIR ?= "${WORKDIR}/testimage/packages"
-TEST_EXTRACTED_DIR ?= "${TEST_NEEDED_PACKAGES_DIR}/extracted"
-TEST_PACKAGED_DIR ?= "${TEST_NEEDED_PACKAGES_DIR}/packaged"
-
-BASICTESTSUITE = "\
-    ping date df ssh scp python perl gi ptest parselogs \
-    logrotate connman systemd oe_syslog pam stap ldd xorg \
-    kernelmodule gcc buildcpio buildlzip buildgalculator \
-    dnf rpm opkg apt weston go rust"
-
-DEFAULT_TEST_SUITES = "${BASICTESTSUITE}"
-
-# musl doesn't support systemtap
-DEFAULT_TEST_SUITES:remove:libc-musl = "stap"
-
-# qemumips is quite slow and has reached the timeout limit several times on the YP build cluster,
-# mitigate this by removing build tests for qemumips machines.
-MIPSREMOVE ??= "buildcpio buildlzip buildgalculator"
-DEFAULT_TEST_SUITES:remove:qemumips = "${MIPSREMOVE}"
-DEFAULT_TEST_SUITES:remove:qemumips64 = "${MIPSREMOVE}"
-
-TEST_SUITES ?= "${DEFAULT_TEST_SUITES}"
-
-QEMU_USE_KVM ?= "1"
-TEST_QEMUBOOT_TIMEOUT ?= "1000"
-TEST_OVERALL_TIMEOUT ?= ""
-TEST_TARGET ?= "qemu"
-TEST_QEMUPARAMS ?= ""
-TEST_RUNQEMUPARAMS ?= ""
-
-TESTIMAGE_BOOT_PATTERNS ?= ""
-
-TESTIMAGEDEPENDS = ""
-TESTIMAGEDEPENDS:append:qemuall = " qemu-native:do_populate_sysroot qemu-helper-native:do_populate_sysroot qemu-helper-native:do_addto_recipe_sysroot"
-TESTIMAGEDEPENDS += "${@bb.utils.contains('IMAGE_PKGTYPE', 'rpm', 'dnf-native:do_populate_sysroot', '', d)}"
-TESTIMAGEDEPENDS += "${@bb.utils.contains('IMAGE_PKGTYPE', 'rpm', 'createrepo-c-native:do_populate_sysroot', '', d)}"
-TESTIMAGEDEPENDS += "${@bb.utils.contains('IMAGE_PKGTYPE', 'ipk', 'opkg-utils-native:do_populate_sysroot package-index:do_package_index', '', d)}"
-TESTIMAGEDEPENDS += "${@bb.utils.contains('IMAGE_PKGTYPE', 'deb', 'apt-native:do_populate_sysroot  package-index:do_package_index', '', d)}"
-
-TESTIMAGELOCK = "${TMPDIR}/testimage.lock"
-TESTIMAGELOCK:qemuall = ""
-
-TESTIMAGE_DUMP_DIR ?= "${LOG_DIR}/runtime-hostdump/"
-
-TESTIMAGE_UPDATE_VARS ?= "DL_DIR WORKDIR DEPLOY_DIR_IMAGE IMAGE_LINK_NAME IMAGE_NAME"
-
-testimage_dump_monitor () {
-    query-status
-    query-block
-    dump-guest-memory {"paging":false,"protocol":"file:%s.img"}
-}
-
-python do_testimage() {
-    testimage_main(d)
-}
-
-addtask testimage
-do_testimage[nostamp] = "1"
-do_testimage[network] = "1"
-do_testimage[depends] += "${TESTIMAGEDEPENDS}"
-do_testimage[lockfiles] += "${TESTIMAGELOCK}"
-
-def testimage_sanity(d):
-    if (d.getVar('TEST_TARGET') == 'simpleremote'
-        and (not d.getVar('TEST_TARGET_IP')
-             or not d.getVar('TEST_SERVER_IP'))):
-        bb.fatal('When TEST_TARGET is set to "simpleremote" '
-                 'TEST_TARGET_IP and TEST_SERVER_IP are needed too.')
-
-def get_testimage_configuration(d, test_type, machine):
-    import platform
-    from oeqa.utils.metadata import get_layers
-    configuration = {'TEST_TYPE': test_type,
-                    'MACHINE': machine,
-                    'DISTRO': d.getVar("DISTRO"),
-                    'IMAGE_BASENAME': d.getVar("IMAGE_BASENAME"),
-                    'IMAGE_PKGTYPE': d.getVar("IMAGE_PKGTYPE"),
-                    'STARTTIME': d.getVar("DATETIME"),
-                    'HOST_DISTRO': oe.lsb.distro_identifier().replace(' ', '-'),
-                    'LAYERS': get_layers(d.getVar("BBLAYERS"))}
-    return configuration
-get_testimage_configuration[vardepsexclude] = "DATETIME"
-
-def get_testimage_result_id(configuration):
-    return '%s_%s_%s_%s' % (configuration['TEST_TYPE'], configuration['IMAGE_BASENAME'], configuration['MACHINE'], configuration['STARTTIME'])
-
-def get_testimage_boot_patterns(d):
-    from collections import defaultdict
-    boot_patterns = defaultdict(str)
-    # Only accept certain values
-    accepted_patterns = ['search_reached_prompt', 'send_login_user', 'search_login_succeeded', 'search_cmd_finished']
-    # Not all patterns need to be overriden, e.g. perhaps we only want to change the user
-    boot_patterns_flags = d.getVarFlags('TESTIMAGE_BOOT_PATTERNS') or {}
-    if boot_patterns_flags:
-        patterns_set = [p for p in boot_patterns_flags.items() if p[0] in d.getVar('TESTIMAGE_BOOT_PATTERNS').split()]
-        for flag, flagval in patterns_set:
-                if flag not in accepted_patterns:
-                    bb.fatal('Testimage: The only accepted boot patterns are: search_reached_prompt,send_login_user, \
-                    search_login_succeeded,search_cmd_finished\n Make sure your TESTIMAGE_BOOT_PATTERNS=%s \
-                    contains an accepted flag.' % d.getVar('TESTIMAGE_BOOT_PATTERNS'))
-                    return
-                boot_patterns[flag] = flagval.encode().decode('unicode-escape')
-    return boot_patterns
-
-def testimage_main(d):
-    import os
-    import json
-    import signal
-    import logging
-    import shutil
-
-    from bb.utils import export_proxies
-    from oeqa.runtime.context import OERuntimeTestContext
-    from oeqa.runtime.context import OERuntimeTestContextExecutor
-    from oeqa.core.target.qemu import supported_fstypes
-    from oeqa.core.utils.test import getSuiteCases
-    from oeqa.utils import make_logger_bitbake_compatible
-    from oeqa.utils import get_json_result_dir
-    from oeqa.utils.postactions import run_failed_tests_post_actions
-
-    def sigterm_exception(signum, stackframe):
-        """
-        Catch SIGTERM from worker in order to stop qemu.
-        """
-        os.kill(os.getpid(), signal.SIGINT)
-
-    def handle_test_timeout(timeout):
-        bb.warn("Global test timeout reached (%s seconds), stopping the tests." %(timeout))
-        os.kill(os.getpid(), signal.SIGINT)
-
-    testimage_sanity(d)
-
-    if (d.getVar('IMAGE_PKGTYPE') == 'rpm'
-       and ('dnf' in d.getVar('TEST_SUITES') or 'auto' in d.getVar('TEST_SUITES'))):
-        create_rpm_index(d)
-
-    logger = make_logger_bitbake_compatible(logging.getLogger("BitBake"))
-    pn = d.getVar("PN")
-
-    bb.utils.mkdirhier(d.getVar("TEST_LOG_DIR"))
-
-    image_name = ("%s/%s" % (d.getVar('DEPLOY_DIR_IMAGE'),
-                             d.getVar('IMAGE_LINK_NAME') or d.getVar('IMAGE_NAME')))
-
-    tdname = "%s.testdata.json" % image_name
-    try:
-        with open(tdname, "r") as f:
-            td = json.load(f)
-    except FileNotFoundError as err:
-        bb.fatal('File %s not found (%s).\nHave you built the image with IMAGE_CLASSES += "testimage" in the conf/local.conf?' % (tdname, err))
-
-    # Some variables need to be updates (mostly paths) with the
-    # ones of the current environment because some tests require them.
-    for var in d.getVar('TESTIMAGE_UPDATE_VARS').split():
-        td[var] = d.getVar(var)
-    td['ORIGPATH'] = d.getVar("BB_ORIGENV").getVar("PATH")
-
-    image_manifest = "%s.manifest" % image_name
-    image_packages = OERuntimeTestContextExecutor.readPackagesManifest(image_manifest)
-
-    extract_dir = d.getVar("TEST_EXTRACTED_DIR")
-
-    # Get machine
-    machine = d.getVar("MACHINE")
-
-    # Get rootfs
-    fstypes = d.getVar('IMAGE_FSTYPES').split()
-    if d.getVar("TEST_TARGET") == "qemu":
-        fstypes = [fs for fs in fstypes if fs in supported_fstypes]
-        if not fstypes:
-            bb.fatal('Unsupported image type built. Add a compatible image to '
-                     'IMAGE_FSTYPES. Supported types: %s' %
-                     ', '.join(supported_fstypes))
-    elif d.getVar("TEST_TARGET") == "serial":
-        bb.fatal('Serial target is currently only supported in testexport.')
-    qfstype = fstypes[0]
-    qdeffstype = d.getVar("QB_DEFAULT_FSTYPE")
-    if qdeffstype:
-        qfstype = qdeffstype
-    rootfs = '%s.%s' % (image_name, qfstype)
-
-    # Get tmpdir (not really used, just for compatibility)
-    tmpdir = d.getVar("TMPDIR")
-
-    # Get deploy_dir_image (not really used, just for compatibility)
-    dir_image = d.getVar("DEPLOY_DIR_IMAGE")
-
-    # Get bootlog
-    bootlog = os.path.join(d.getVar("TEST_LOG_DIR"),
-                           'qemu_boot_log.%s' % d.getVar('DATETIME'))
-
-    # Get display
-    display = d.getVar("BB_ORIGENV").getVar("DISPLAY")
-
-    # Get kernel
-    kernel_name = ('%s-%s.bin' % (d.getVar("KERNEL_IMAGETYPE"), machine))
-    kernel = os.path.join(d.getVar("DEPLOY_DIR_IMAGE"), kernel_name)
-
-    # Get boottime
-    boottime = int(d.getVar("TEST_QEMUBOOT_TIMEOUT"))
-
-    # Get use_kvm
-    kvm = oe.types.qemu_use_kvm(d.getVar('QEMU_USE_KVM'), d.getVar('TARGET_ARCH'))
-
-    # Get OVMF
-    ovmf = d.getVar("QEMU_USE_OVMF")
-
-    slirp = False
-    if bb.utils.contains('TEST_RUNQEMUPARAMS', 'slirp', True, False, d):
-        slirp = True
-
-    # TODO: We use the current implementation of qemu runner because of
-    # time constrains, qemu runner really needs a refactor too.
-    target_kwargs = { 'machine'     : machine,
-                      'rootfs'      : rootfs,
-                      'tmpdir'      : tmpdir,
-                      'dir_image'   : dir_image,
-                      'display'     : display,
-                      'kernel'      : kernel,
-                      'boottime'    : boottime,
-                      'bootlog'     : bootlog,
-                      'kvm'         : kvm,
-                      'slirp'       : slirp,
-                      'dump_dir'    : d.getVar("TESTIMAGE_DUMP_DIR"),
-                      'serial_ports': len(d.getVar("SERIAL_CONSOLES").split()),
-                      'ovmf'        : ovmf,
-                      'tmpfsdir'    : d.getVar("RUNQEMU_TMPFS_DIR"),
-                    }
-
-    if d.getVar("TESTIMAGE_BOOT_PATTERNS"):
-        target_kwargs['boot_patterns'] = get_testimage_boot_patterns(d)
-
-    # hardware controlled targets might need further access
-    target_kwargs['powercontrol_cmd'] = d.getVar("TEST_POWERCONTROL_CMD") or None
-    target_kwargs['powercontrol_extra_args'] = d.getVar("TEST_POWERCONTROL_EXTRA_ARGS") or ""
-    target_kwargs['serialcontrol_cmd'] = d.getVar("TEST_SERIALCONTROL_CMD") or None
-    target_kwargs['serialcontrol_extra_args'] = d.getVar("TEST_SERIALCONTROL_EXTRA_ARGS") or ""
-    target_kwargs['testimage_dump_monitor'] = d.getVar("testimage_dump_monitor") or ""
-
-    def export_ssh_agent(d):
-        import os
-
-        variables = ['SSH_AGENT_PID', 'SSH_AUTH_SOCK']
-        for v in variables:
-            if v not in os.environ.keys():
-                val = d.getVar(v)
-                if val is not None:
-                    os.environ[v] = val
-
-    export_ssh_agent(d)
-
-    # runtime use network for download projects for build
-    export_proxies(d)
-
-    if slirp:
-        # Default to 127.0.0.1 and let the runner identify the port forwarding
-        # (as OEQemuTarget does), but allow overriding.
-        target_ip = d.getVar("TEST_TARGET_IP") or "127.0.0.1"
-        # Default to 10.0.2.2 as this is the IP that the guest has with the
-        # default qemu slirp networking configuration, but allow overriding.
-        server_ip = d.getVar("TEST_SERVER_IP") or "10.0.2.2"
-    else:
-        target_ip = d.getVar("TEST_TARGET_IP")
-        server_ip = d.getVar("TEST_SERVER_IP")
-
-    # the robot dance
-    target = OERuntimeTestContextExecutor.getTarget(
-        d.getVar("TEST_TARGET"), logger, target_ip,
-        server_ip, **target_kwargs)
-
-    # test context
-    tc = OERuntimeTestContext(td, logger, target, image_packages, extract_dir)
-
-    # Load tests before starting the target
-    test_paths = get_runtime_paths(d)
-    test_modules = d.getVar('TEST_SUITES').split()
-    if not test_modules:
-        bb.fatal('Empty test suite, please verify TEST_SUITES variable')
-
-    tc.loadTests(test_paths, modules=test_modules)
-
-    suitecases = getSuiteCases(tc.suites)
-    if not suitecases:
-        bb.fatal('Empty test suite, please verify TEST_SUITES variable')
-    else:
-        bb.debug(2, 'test suites:\n\t%s' % '\n\t'.join([str(c) for c in suitecases]))
-
-    package_extraction(d, tc.suites)
-
-    results = None
-    complete = False
-    orig_sigterm_handler = signal.signal(signal.SIGTERM, sigterm_exception)
-    try:
-        # We need to check if runqemu ends unexpectedly
-        # or if the worker send us a SIGTERM
-        tc.target.start(params=d.getVar("TEST_QEMUPARAMS"), runqemuparams=d.getVar("TEST_RUNQEMUPARAMS"))
-        import threading
-        try:
-            threading.Timer(int(d.getVar("TEST_OVERALL_TIMEOUT")), handle_test_timeout, (int(d.getVar("TEST_OVERALL_TIMEOUT")),)).start()
-        except ValueError:
-            pass
-        results = tc.runTests()
-        complete = True
-        if results.hasAnyFailingTest():
-            run_failed_tests_post_actions(d, tc)
-    except (KeyboardInterrupt, BlockingIOError) as err:
-        if isinstance(err, KeyboardInterrupt):
-            bb.error('testimage interrupted, shutting down...')
-        else:
-            bb.error('runqemu failed, shutting down...')
-        if results:
-            results.stop()
-    finally:
-        signal.signal(signal.SIGTERM, orig_sigterm_handler)
-        tc.target.stop()
-
-    # Show results (if we have them)
-    if results:
-        configuration = get_testimage_configuration(d, 'runtime', machine)
-        results.logDetails(get_json_result_dir(d),
-                        configuration,
-                        get_testimage_result_id(configuration),
-                        dump_streams=d.getVar('TESTREPORT_FULLLOGS'))
-        results.logSummary(pn)
-
-    # Copy additional logs to tmp/log/oeqa so it's easier to find them
-    targetdir = os.path.join(get_json_result_dir(d), d.getVar("PN"))
-    os.makedirs(targetdir, exist_ok=True)
-    os.symlink(bootlog, os.path.join(targetdir, os.path.basename(bootlog)))
-    os.symlink(d.getVar("BB_LOGFILE"), os.path.join(targetdir, os.path.basename(d.getVar("BB_LOGFILE") + "." + d.getVar('DATETIME'))))
-
-    if not results or not complete:
-        bb.error('%s - FAILED - tests were interrupted during execution, check the logs in %s' % (pn, d.getVar("LOG_DIR")), forcelog=True)
-    if results and not results.wasSuccessful():
-        bb.error('%s - FAILED - also check the logs in %s' % (pn, d.getVar("LOG_DIR")), forcelog=True)
-
-def get_runtime_paths(d):
-    """
-    Returns a list of paths where runtime test must reside.
-
-    Runtime tests are expected in <LAYER_DIR>/lib/oeqa/runtime/cases/
-    """
-    paths = []
-
-    for layer in d.getVar('BBLAYERS').split():
-        path = os.path.join(layer, 'lib/oeqa/runtime/cases')
-        if os.path.isdir(path):
-            paths.append(path)
-    return paths
-
-def create_index(arg):
-    import subprocess
-
-    index_cmd = arg
-    try:
-        bb.note("Executing '%s' ..." % index_cmd)
-        result = subprocess.check_output(index_cmd,
-                                        stderr=subprocess.STDOUT,
-                                        shell=True)
-        result = result.decode('utf-8')
-    except subprocess.CalledProcessError as e:
-        return("Index creation command '%s' failed with return code "
-               '%d:\n%s' % (e.cmd, e.returncode, e.output.decode("utf-8")))
-    if result:
-        bb.note(result)
-    return None
-
-def create_rpm_index(d):
-    import glob
-    # Index RPMs
-    rpm_createrepo = bb.utils.which(os.getenv('PATH'), "createrepo_c")
-    index_cmds = []
-    archs = (d.getVar('ALL_MULTILIB_PACKAGE_ARCHS') or '').replace('-', '_')
-
-    for arch in archs.split():
-        rpm_dir = os.path.join(d.getVar('DEPLOY_DIR_RPM'), arch)
-        idx_path = os.path.join(d.getVar('WORKDIR'), 'oe-testimage-repo', arch)
-
-        if not os.path.isdir(rpm_dir):
-            continue
-
-        lockfilename = os.path.join(d.getVar('DEPLOY_DIR_RPM'), 'rpm.lock')
-        lf = bb.utils.lockfile(lockfilename, False)
-        oe.path.copyhardlinktree(rpm_dir, idx_path)
-        # Full indexes overload a 256MB image so reduce the number of rpms
-        # in the feed by filtering to specific packages needed by the tests.
-        package_list = glob.glob(idx_path + "*/*.rpm")
-
-        for pkg in package_list:
-            if not os.path.basename(pkg).startswith(("dnf-test-", "busybox", "update-alternatives", "libc6", "musl")):
-                bb.utils.remove(pkg)
-
-        bb.utils.unlockfile(lf)
-        cmd = '%s --update -q %s' % (rpm_createrepo, idx_path)
-
-        # Create repodata
-        result = create_index(cmd)
-        if result:
-            bb.fatal('%s' % ('\n'.join(result)))
-
-def package_extraction(d, test_suites):
-    from oeqa.utils.package_manager import find_packages_to_extract
-    from oeqa.utils.package_manager import extract_packages
-
-    bb.utils.remove(d.getVar("TEST_NEEDED_PACKAGES_DIR"), recurse=True)
-    packages = find_packages_to_extract(test_suites)
-    if packages:
-        bb.utils.mkdirhier(d.getVar("TEST_INSTALL_TMP_DIR"))
-        bb.utils.mkdirhier(d.getVar("TEST_PACKAGED_DIR"))
-        bb.utils.mkdirhier(d.getVar("TEST_EXTRACTED_DIR"))
-        extract_packages(d, packages)
-
-testimage_main[vardepsexclude] += "BB_ORIGENV DATETIME"
-
-python () {
-    if oe.types.boolean(d.getVar("TESTIMAGE_AUTO") or "False"):
-        bb.build.addtask("testimage", "do_build", "do_image_complete", d)
-}
diff --git a/meta/classes-recipe/testsdk.bbclass b/meta/classes-recipe/testsdk.bbclass
deleted file mode 100644
index b1c4fa67e6..0000000000
--- a/meta/classes-recipe/testsdk.bbclass
+++ /dev/null
@@ -1,56 +0,0 @@
-# Copyright (C) 2013 - 2016 Intel Corporation
-#
-# SPDX-License-Identifier: MIT
-
-# testsdk.bbclass enables testing for SDK and Extensible SDK
-#
-# To run SDK tests, run the commands:
-# $ bitbake <image-name> -c populate_sdk
-# $ bitbake <image-name> -c testsdk
-#
-# To run eSDK tests, run the commands:
-# $ bitbake <image-name> -c populate_sdk_ext
-# $ bitbake <image-name> -c testsdkext
-#
-# where "<image-name>" is an image like core-image-sato.
-
-# List of test modules to run, or run all that can be found if unset
-TESTSDK_SUITES ?= ""
-
-TESTSDK_CLASS_NAME ?= "oeqa.sdk.testsdk.TestSDK"
-TESTSDKEXT_CLASS_NAME ?= "oeqa.sdkext.testsdk.TestSDKExt"
-TESTSDK_CASE_DIRS ?= "sdk"
-
-def import_and_run(name, d):
-    import importlib
-
-    class_name = d.getVar(name)
-    if class_name:
-        module, cls = class_name.rsplit('.', 1)
-        m = importlib.import_module(module)
-        c = getattr(m, cls)()
-        c.run(d)
-    else:
-        bb.warn('No tests were run because %s did not define a class' % name)
-
-import_and_run[vardepsexclude] = "DATETIME BB_ORIGENV"
-
-python do_testsdk() {
-    import_and_run('TESTSDK_CLASS_NAME', d)
-}
-addtask testsdk
-do_testsdk[nostamp] = "1"
-do_testsdk[network] = "1"
-
-python do_testsdkext() {
-    import_and_run('TESTSDKEXT_CLASS_NAME', d)
-}
-addtask testsdkext
-do_testsdkext[nostamp] = "1"
-do_testsdkext[network] = "1"
-
-python () {
-    if oe.types.boolean(d.getVar("TESTIMAGE_AUTO") or "False"):
-        bb.build.addtask("testsdk", None, "do_populate_sdk", d)
-        bb.build.addtask("testsdkext", None, "do_populate_sdk_ext", d)
-}
diff --git a/meta/classes-recipe/texinfo.bbclass b/meta/classes-recipe/texinfo.bbclass
deleted file mode 100644
index 380247faf5..0000000000
--- a/meta/classes-recipe/texinfo.bbclass
+++ /dev/null
@@ -1,24 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-# This class is inherited by recipes whose upstream packages invoke the
-# texinfo utilities at build-time. Native and cross recipes are made to use the
-# dummy scripts provided by texinfo-dummy-native, for improved performance.
-# Target architecture recipes use the genuine Texinfo utilities. By default,
-# they use the Texinfo utilities on the host system. If you want to use the
-# Texinfo recipe, you can remove texinfo-native from ASSUME_PROVIDED and
-# makeinfo from SANITY_REQUIRED_UTILITIES.
-
-TEXDEP = "${@bb.utils.contains('DISTRO_FEATURES', 'api-documentation', 'texinfo-replacement-native', 'texinfo-dummy-native', d)}"
-TEXDEP:class-native = "texinfo-dummy-native"
-TEXDEP:class-cross = "texinfo-dummy-native"
-TEXDEP:class-crosssdk = "texinfo-dummy-native"
-TEXDEP:class-cross-canadian = "texinfo-dummy-native"
-DEPENDS:append = " ${TEXDEP}"
-
-# libtool-cross doesn't inherit cross
-TEXDEP:pn-libtool-cross = "texinfo-dummy-native"
-
diff --git a/meta/classes-recipe/toolchain-scripts-base.bbclass b/meta/classes-recipe/toolchain-scripts-base.bbclass
deleted file mode 100644
index d24a986e02..0000000000
--- a/meta/classes-recipe/toolchain-scripts-base.bbclass
+++ /dev/null
@@ -1,17 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-#This function create a version information file
-toolchain_create_sdk_version () {
-        local versionfile=$1
-        rm -f $versionfile
-        touch $versionfile
-        echo 'Distro: ${DISTRO}' >> $versionfile
-        echo 'Distro Version: ${DISTRO_VERSION}' >> $versionfile
-        echo 'Metadata Revision: ${METADATA_REVISION}' >> $versionfile
-        echo 'Timestamp: ${DATETIME}' >> $versionfile
-}
-toolchain_create_sdk_version[vardepsexclude] = "DATETIME"
diff --git a/meta/classes-recipe/toolchain-scripts.bbclass b/meta/classes-recipe/toolchain-scripts.bbclass
deleted file mode 100644
index 8c062ef0e7..0000000000
--- a/meta/classes-recipe/toolchain-scripts.bbclass
+++ /dev/null
@@ -1,249 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-inherit toolchain-scripts-base siteinfo kernel-arch meson-routines
-
-# We want to be able to change the value of MULTIMACH_TARGET_SYS, because it
-# doesn't always match our expectations... but we default to the stock value
-REAL_MULTIMACH_TARGET_SYS ?= "${MULTIMACH_TARGET_SYS}"
-TARGET_CC_ARCH:append:toolchain-gcc:libc-musl = " -mmusl"
-
-# default debug prefix map isn't valid in the SDK
-DEBUG_PREFIX_MAP = ""
-
-EXPORT_SDK_PS1 = "${@ 'export PS1=\\"%s\\"' % d.getVar('SDK_PS1') if d.getVar('SDK_PS1') else ''}"
-
-def siteinfo_with_prefix(d, prefix):
-    # Return a prefixed value from siteinfo
-    for item in siteinfo_data_for_machine(d.getVar("TARGET_ARCH"), d.getVar("TARGET_OS"), d):
-        if item.startswith(prefix):
-            return item.replace(prefix, "")
-    raise KeyError
-
-# This function creates an environment-setup-script for use in a deployable SDK
-toolchain_create_sdk_env_script () {
-        # Create environment setup script.  Remember that $SDKTARGETSYSROOT should
-        # only be expanded on the target at runtime.
-        base_sbindir=${10:-${base_sbindir_nativesdk}}
-        base_bindir=${9:-${base_bindir_nativesdk}}
-        sbindir=${8:-${sbindir_nativesdk}}
-        sdkpathnative=${7:-${SDKPATHNATIVE}}
-        prefix=${6:-${prefix_nativesdk}}
-        bindir=${5:-${bindir_nativesdk}}
-        libdir=${4:-${libdir}}
-        sysroot=${3:-${SDKTARGETSYSROOT}}
-        multimach_target_sys=${2:-${REAL_MULTIMACH_TARGET_SYS}}
-        script=${1:-${SDK_OUTPUT}/${SDKPATH}/environment-setup-$multimach_target_sys}
-        rm -f $script
-        touch $script
-
-        echo '# Check for LD_LIBRARY_PATH being set, which can break SDK and generally is a bad practice' >> $script
-        echo '# http://tldp.org/HOWTO/Program-Library-HOWTO/shared-libraries.html#AEN80' >> $script
-        echo '# http://xahlee.info/UnixResource_dir/_/ldpath.html' >> $script
-        echo '# Only disable this check if you are absolutely know what you are doing!' >> $script
-        echo 'if [ ! -z "${LD_LIBRARY_PATH:-}" ]; then' >> $script
-        echo "    echo \"Your environment is misconfigured, you probably need to 'unset LD_LIBRARY_PATH'\"" >> $script
-        echo "    echo \"but please check why this was set in the first place and that it's safe to unset.\"" >> $script
-        echo '    echo "The SDK will not operate correctly in most cases when LD_LIBRARY_PATH is set."' >> $script
-        echo '    echo "For more references see:"' >> $script
-        echo '    echo "  http://tldp.org/HOWTO/Program-Library-HOWTO/shared-libraries.html#AEN80"' >> $script
-        echo '    echo "  http://xahlee.info/UnixResource_dir/_/ldpath.html"' >> $script
-        echo '    return 1' >> $script
-        echo 'fi' >> $script
-
-        echo "${EXPORT_SDK_PS1}" >> $script
-        echo 'export SDKTARGETSYSROOT='"$sysroot" >> $script
-        EXTRAPATH=""
-        for i in ${CANADIANEXTRAOS}; do
-                EXTRAPATH="$EXTRAPATH:$sdkpathnative$bindir/${TARGET_ARCH}${TARGET_VENDOR}-$i"
-        done
-        echo "export PATH=$sdkpathnative$bindir:$sdkpathnative$sbindir:$sdkpathnative$base_bindir:$sdkpathnative$base_sbindir:$sdkpathnative$bindir/../${HOST_SYS}/bin:$sdkpathnative$bindir/${TARGET_SYS}"$EXTRAPATH':"$PATH"' >> $script
-        echo 'export PKG_CONFIG_SYSROOT_DIR=$SDKTARGETSYSROOT' >> $script
-        echo 'export PKG_CONFIG_PATH=$SDKTARGETSYSROOT'"$libdir"'/pkgconfig:$SDKTARGETSYSROOT'"$prefix"'/share/pkgconfig' >> $script
-        echo 'export CONFIG_SITE=${SDKPATH}/site-config-'"${multimach_target_sys}" >> $script
-        echo "export OECORE_NATIVE_SYSROOT=\"$sdkpathnative\"" >> $script
-        echo 'export OECORE_TARGET_SYSROOT="$SDKTARGETSYSROOT"' >> $script
-        echo "export OECORE_ACLOCAL_OPTS=\"-I $sdkpathnative/usr/share/aclocal\"" >> $script
-        echo 'export OECORE_BASELIB="${baselib}"' >> $script
-        echo 'export OECORE_TARGET_ARCH="${TARGET_ARCH}"' >>$script
-        echo 'export OECORE_TARGET_OS="${TARGET_OS}"' >>$script
-        echo 'export OECORE_TARGET_BITS="${@siteinfo_with_prefix(d, 'bit-')}"' >>$script
-        echo 'export OECORE_TARGET_ENDIAN="${@siteinfo_with_prefix(d, 'endian-')}"' >>$script
-        echo 'export OECORE_MESON_HOST_SYSTEM="${@meson_operating_system('TARGET_OS', d)}"' >>$script
-        echo 'export OECORE_MESON_HOST_CPU_FAMILY="${@meson_cpu_family('TARGET_ARCH', d)}"' >>$script
-        echo 'export OECORE_MESON_HOST_CPU="${TARGET_ARCH}"' >>$script
-        echo 'export OECORE_MESON_HOST_ENDIAN="${@meson_endian('TARGET', d)}"' >>$script
-
-        echo 'unset command_not_found_handle' >> $script
-
-        toolchain_shared_env_script
-}
-
-# This function creates an environment-setup-script in B which enables
-# a OE-core IDE to integrate with the build tree
-# Caller must ensure CONFIG_SITE is setup
-toolchain_create_tree_env_script () {
-        script=${B}/environment-setup-${REAL_MULTIMACH_TARGET_SYS}
-        bitbakedir=$(readlink -f ${BITBAKEPATH}/..)
-        rm -f $script
-        touch $script
-        echo 'standalone_sysroot_target="${STAGING_DIR}/${MACHINE}"' >> $script
-        echo 'standalone_sysroot_native="${STAGING_DIR}/${BUILD_ARCH}"' >> $script
-        echo "orig=`pwd`; cd ${COREBASE}; set ${TOPDIR} $bitbakedir; . ./oe-init-build-env; cd \$orig" >> $script
-        echo 'export PATH=$standalone_sysroot_native/${bindir_native}:$standalone_sysroot_native/${bindir_native}/${TARGET_SYS}:$PATH' >> $script
-        echo 'export PKG_CONFIG_SYSROOT_DIR=$standalone_sysroot_target' >> $script
-        echo 'export PKG_CONFIG_PATH=$standalone_sysroot_target'"$libdir"'/pkgconfig:$standalone_sysroot_target'"$prefix"'/share/pkgconfig' >> $script
-        echo 'export CONFIG_SITE="${CONFIG_SITE}"' >> $script
-        echo 'export SDKTARGETSYSROOT=$standalone_sysroot_target' >> $script
-        echo 'export OECORE_NATIVE_SYSROOT=$standalone_sysroot_native' >> $script
-        echo 'export OECORE_TARGET_SYSROOT=$standalone_sysroot_target' >> $script
-        echo 'export OECORE_ACLOCAL_OPTS="-I $standalone_sysroot_native/usr/share/aclocal"' >> $script
-        echo 'export OECORE_BASELIB="${baselib}"' >> $script
-        echo 'export OECORE_TARGET_ARCH="${TARGET_ARCH}"' >>$script
-        echo 'export OECORE_TARGET_OS="${TARGET_OS}"' >>$script
-        echo 'export OECORE_TARGET_BITS="${@siteinfo_with_prefix(d, 'bit-')}"' >>$script
-        echo 'export OECORE_TARGET_ENDIAN="${@siteinfo_with_prefix(d, 'endian-')}"' >>$script
-        echo 'export OECORE_MESON_HOST_SYSTEM="${@meson_operating_system('TARGET_OS', d)}"' >>$script
-        echo 'export OECORE_MESON_HOST_CPU_FAMILY="${@meson_cpu_family('TARGET_ARCH', d)}"' >>$script
-        echo 'export OECORE_MESON_HOST_CPU="${TARGET_ARCH}"' >>$script
-        echo 'export OECORE_MESON_HOST_ENDIAN="${@meson_endian('TARGET', d)}"' >>$script
-
-        toolchain_shared_env_script
-
-        cat >> $script <<EOF
-
-if [ -d "\$OECORE_NATIVE_SYSROOT/${datadir}/post-relocate-setup.d/" ]; then
-        for s in \$OECORE_NATIVE_SYSROOT/${datadir}/post-relocate-setup.d/*; do
-                if [ ! -x \$s ]; then
-                        continue
-                fi
-                \$s "\$1"
-                status=\$?
-                if [ \$status != 0 ]; then
-                        echo "post-relocate command \"\$s \$1\" failed with status \$status" >&2
-                        exit \$status
-                fi
-        done
-fi
-EOF
-}
-
-toolchain_shared_env_script () {
-        echo 'export CC="${TARGET_PREFIX}gcc ${TARGET_CC_ARCH} --sysroot=$SDKTARGETSYSROOT"' >> $script
-        echo 'export CXX="${TARGET_PREFIX}g++ ${TARGET_CC_ARCH} --sysroot=$SDKTARGETSYSROOT"' >> $script
-        echo 'export CPP="${TARGET_PREFIX}gcc -E ${TARGET_CC_ARCH} --sysroot=$SDKTARGETSYSROOT"' >> $script
-        echo 'export AS="${TARGET_PREFIX}as ${TARGET_AS_ARCH}"' >> $script
-        echo 'export LD="${TARGET_PREFIX}ld ${TARGET_LD_ARCH} --sysroot=$SDKTARGETSYSROOT"' >> $script
-        echo 'export GDB=${TARGET_PREFIX}gdb' >> $script
-        echo 'export STRIP=${TARGET_PREFIX}strip' >> $script
-        echo 'export RANLIB=${TARGET_PREFIX}ranlib' >> $script
-        echo 'export OBJCOPY=${TARGET_PREFIX}objcopy' >> $script
-        echo 'export OBJDUMP=${TARGET_PREFIX}objdump' >> $script
-        echo 'export READELF=${TARGET_PREFIX}readelf' >> $script
-        echo 'export AR=${TARGET_PREFIX}ar' >> $script
-        echo 'export NM=${TARGET_PREFIX}nm' >> $script
-        echo 'export M4=m4' >> $script
-        echo 'export TARGET_PREFIX=${TARGET_PREFIX}' >> $script
-        echo 'export CONFIGURE_FLAGS="--target=${TARGET_SYS} --host=${TARGET_SYS} --build=${SDK_ARCH}-linux --with-libtool-sysroot=$SDKTARGETSYSROOT"' >> $script
-        echo 'export CFLAGS="${TARGET_CFLAGS}"' >> $script
-        echo 'export CXXFLAGS="${TARGET_CXXFLAGS}"' >> $script
-        echo 'export LDFLAGS="${TARGET_LDFLAGS}"' >> $script
-        echo 'export CPPFLAGS="${TARGET_CPPFLAGS}"' >> $script
-        echo 'export KCFLAGS="--sysroot=$SDKTARGETSYSROOT"' >> $script
-        echo 'export OECORE_DISTRO_VERSION="${DISTRO_VERSION}"' >> $script
-        echo 'export OECORE_SDK_VERSION="${SDK_VERSION}"' >> $script
-        echo 'export ARCH=${ARCH}' >> $script
-        echo 'export CROSS_COMPILE=${TARGET_PREFIX}' >> $script
-        echo 'export OECORE_TUNE_CCARGS="${TUNE_CCARGS}"' >> $script
-
-    cat >> $script <<EOF
-
-# Append environment subscripts
-if [ -d "\$OECORE_TARGET_SYSROOT/environment-setup.d" ]; then
-    for envfile in \$OECORE_TARGET_SYSROOT/environment-setup.d/*.sh; do
-            . \$envfile
-    done
-fi
-if [ -d "\$OECORE_NATIVE_SYSROOT/environment-setup.d" ]; then
-    for envfile in \$OECORE_NATIVE_SYSROOT/environment-setup.d/*.sh; do
-            . \$envfile
-    done
-fi
-EOF
-}
-
-toolchain_create_post_relocate_script() {
-        relocate_script=$1
-        env_dir=$2
-        rm -f $relocate_script
-        touch $relocate_script
-
-        cat >> $relocate_script <<EOF
-if [ -d "${SDKPATHNATIVE}/post-relocate-setup.d/" ]; then
-        # Source top-level SDK env scripts in case they are needed for the relocate
-        # scripts.
-        for env_setup_script in ${env_dir}/environment-setup-*; do
-                . \$env_setup_script
-                status=\$?
-                if [ \$status != 0 ]; then
-                        echo "\$0: Failed to source \$env_setup_script with status \$status"
-                        exit \$status
-                fi
-
-                for s in ${SDKPATHNATIVE}/post-relocate-setup.d/*; do
-                        if [ ! -x \$s ]; then
-                                continue
-                        fi
-                        \$s "\$1"
-                        status=\$?
-                        if [ \$status != 0 ]; then
-                                echo "post-relocate command \"\$s \$1\" failed with status \$status" >&2
-                                exit \$status
-                        fi
-                done
-        done
-        rm -rf "${SDKPATHNATIVE}/post-relocate-setup.d"
-fi
-EOF
-}
-
-#we get the cached site config in the runtime
-TOOLCHAIN_CONFIGSITE_NOCACHE = "${@' '.join(siteinfo_get_files(d)[0])}"
-TOOLCHAIN_NEED_CONFIGSITE_CACHE ??= "virtual/${MLPREFIX}libc ncurses"
-DEPENDS += "${TOOLCHAIN_NEED_CONFIGSITE_CACHE}"
-
-#This function create a site config file
-toolchain_create_sdk_siteconfig () {
-        local siteconfig=$1
-
-        rm -f $siteconfig
-        touch $siteconfig
-
-        for sitefile in ${TOOLCHAIN_CONFIGSITE_NOCACHE} ; do
-                cat $sitefile >> $siteconfig
-        done
-
-        #get cached site config
-        for sitefile in ${TOOLCHAIN_NEED_CONFIGSITE_CACHE}; do
-                # Resolve virtual/* names to the real recipe name using sysroot-providers info
-                case $sitefile in virtual/*)
-                        sitefile=`echo $sitefile | tr / _`
-                        sitefile=`cat ${STAGING_DIR_TARGET}/sysroot-providers/$sitefile`
-                esac
-        done
-}
-
-python __anonymous () {
-    import oe.classextend
-    deps = ""
-    prefixes = (d.getVar("MULTILIB_VARIANTS") or "").split()
-    for dep in (d.getVar('TOOLCHAIN_NEED_CONFIGSITE_CACHE') or "").split():
-        deps += " %s:do_populate_sysroot" % dep
-        for variant in (d.getVar('MULTILIB_VARIANTS') or "").split():
-            newdep = oe.classextend.add_suffix(dep, variant, prefixes)
-            deps += " %s:do_populate_sysroot" % newdep
-    d.appendVarFlag('do_configure', 'depends', deps)
-}
diff --git a/meta/classes-recipe/uboot-config.bbclass b/meta/classes-recipe/uboot-config.bbclass
deleted file mode 100644
index fd6c045142..0000000000
--- a/meta/classes-recipe/uboot-config.bbclass
+++ /dev/null
@@ -1,167 +0,0 @@
-# Handle U-Boot config for a machine
-#
-# The format to specify it, in the machine, is:
-#
-# UBOOT_CONFIG ??= <default>
-# UBOOT_CONFIG[foo] = "config,images,binary"
-#
-# or
-#
-# UBOOT_MACHINE = "config"
-#
-# Copyright 2013, 2014 (C) O.S. Systems Software LTDA.
-#
-# SPDX-License-Identifier: MIT
-
-
-def removesuffix(s, suffix):
-    if suffix and s.endswith(suffix):
-        return s[:-len(suffix)]
-    return s
-
-UBOOT_ENTRYPOINT ?= "0x20008000"
-UBOOT_LOADADDRESS ?= "${UBOOT_ENTRYPOINT}"
-
-# When naming the files we install/deploy, the package version and revision
-# are part of the filename.  Create a single variable to represent this and
-# allow it to be customized if desired.
-UBOOT_VERSION ?= "${PV}-${PR}"
-
-# Some versions of u-boot use .bin and others use .img.  By default use .bin
-# but enable individual recipes to change this value.
-UBOOT_SUFFIX ??= "bin"
-UBOOT_BINARY ?= "u-boot.${UBOOT_SUFFIX}"
-UBOOT_BINARYNAME ?= "${@os.path.splitext(d.getVar("UBOOT_BINARY"))[0]}"
-UBOOT_IMAGE ?= "${UBOOT_BINARYNAME}-${MACHINE}-${UBOOT_VERSION}.${UBOOT_SUFFIX}"
-UBOOT_SYMLINK ?= "${UBOOT_BINARYNAME}-${MACHINE}.${UBOOT_SUFFIX}"
-UBOOT_MAKE_TARGET ?= "all"
-UBOOT_MAKE_OPTS ?= ""
-
-# Output the ELF generated. Some platforms can use the ELF file and directly
-# load it (JTAG booting, QEMU) additionally the ELF can be used for debugging
-# purposes.
-UBOOT_ELF ?= ""
-UBOOT_ELF_SUFFIX ?= "elf"
-UBOOT_ELF_IMAGE ?= "u-boot-${MACHINE}-${UBOOT_VERSION}.${UBOOT_ELF_SUFFIX}"
-UBOOT_ELF_BINARY ?= "u-boot.${UBOOT_ELF_SUFFIX}"
-UBOOT_ELF_SYMLINK ?= "u-boot-${MACHINE}.${UBOOT_ELF_SUFFIX}"
-
-# Some versions of u-boot build an SPL (Second Program Loader) image that
-# should be packaged along with the u-boot binary as well as placed in the
-# deploy directory.  For those versions they can set the following variables
-# to allow packaging the SPL.
-SPL_SUFFIX ?= ""
-SPL_BINARY ?= ""
-SPL_DELIMITER  ?= "${@'.' if d.getVar("SPL_SUFFIX") else ''}"
-SPL_BINARYFILE ?= "${@os.path.basename(d.getVar("SPL_BINARY"))}"
-SPL_BINARYNAME ?= "${@removesuffix(d.getVar("SPL_BINARYFILE"), "." + d.getVar("SPL_SUFFIX"))}"
-SPL_IMAGE ?= "${SPL_BINARYNAME}-${MACHINE}-${UBOOT_VERSION}${SPL_DELIMITER}${SPL_SUFFIX}"
-SPL_SYMLINK ?= "${SPL_BINARYNAME}-${MACHINE}${SPL_DELIMITER}${SPL_SUFFIX}"
-
-# Additional environment variables or a script can be installed alongside
-# u-boot to be used automatically on boot.  This file, typically 'uEnv.txt'
-# or 'boot.scr', should be packaged along with u-boot as well as placed in the
-# deploy directory.  Machine configurations needing one of these files should
-# include it in the SRC_URI and set the UBOOT_ENV parameter.
-UBOOT_ENV_SUFFIX ?= "txt"
-UBOOT_ENV ?= ""
-UBOOT_ENV_SRC_SUFFIX ?= "cmd"
-UBOOT_ENV_SRC ?= "${UBOOT_ENV}.${UBOOT_ENV_SRC_SUFFIX}"
-UBOOT_ENV_BINARY ?= "${UBOOT_ENV}.${UBOOT_ENV_SUFFIX}"
-UBOOT_ENV_IMAGE ?= "${UBOOT_ENV}-${MACHINE}-${UBOOT_VERSION}.${UBOOT_ENV_SUFFIX}"
-UBOOT_ENV_SYMLINK ?= "${UBOOT_ENV}-${MACHINE}.${UBOOT_ENV_SUFFIX}"
-
-# U-Boot EXTLINUX variables. U-Boot searches for /boot/extlinux/extlinux.conf
-# to find EXTLINUX conf file.
-UBOOT_EXTLINUX_INSTALL_DIR ?= "/boot/extlinux"
-UBOOT_EXTLINUX_CONF_NAME ?= "extlinux.conf"
-UBOOT_EXTLINUX_SYMLINK ?= "${UBOOT_EXTLINUX_CONF_NAME}-${MACHINE}-${UBOOT_VERSION}"
-
-# Options for the device tree compiler passed to mkimage '-D' feature:
-UBOOT_MKIMAGE_DTCOPTS ??= ""
-SPL_MKIMAGE_DTCOPTS ??= ""
-
-# mkimage command
-UBOOT_MKIMAGE ?= "uboot-mkimage"
-UBOOT_MKIMAGE_SIGN ?= "${UBOOT_MKIMAGE}"
-
-# Signature activation
-UBOOT_SIGN_ENABLE ?= "0"
-
-# Arguments passed to mkimage for signing
-UBOOT_MKIMAGE_SIGN_ARGS ?= ""
-SPL_MKIMAGE_SIGN_ARGS ?= ""
-
-# Options to deploy the u-boot device tree
-UBOOT_DTB ?= ""
-UBOOT_DTB_BINARY ??= ""
-
-# uboot-fit_check_sign command
-UBOOT_FIT_CHECK_SIGN ?= "uboot-fit_check_sign"
-
-python () {
-    ubootmachine = d.getVar("UBOOT_MACHINE")
-    ubootconfigflags = d.getVarFlags('UBOOT_CONFIG')
-    ubootbinary = d.getVar('UBOOT_BINARY')
-    ubootbinaries = d.getVar('UBOOT_BINARIES')
-    ubootconfigmakeopts = d.getVar('UBOOT_CONFIG_MAKE_OPTS')
-    # The "doc" varflag is special, we don't want to see it here
-    ubootconfigflags.pop('doc', None)
-    ubootconfig = (d.getVar('UBOOT_CONFIG') or "").split()
-    recipename = d.getVar("PN")
-
-    if not ubootmachine and not ubootconfig:
-        FILE = os.path.basename(d.getVar("FILE"))
-        bb.debug(1, "To build %s, see %s for instructions on \
-                 setting up your machine config" % (recipename, FILE))
-        raise bb.parse.SkipRecipe("Either UBOOT_MACHINE or UBOOT_CONFIG must be set in the %s machine configuration." % d.getVar("MACHINE"))
-
-    if ubootmachine and ubootconfig:
-        raise bb.parse.SkipRecipe("You cannot use UBOOT_MACHINE and UBOOT_CONFIG at the same time.")
-
-    if ubootconfigflags and ubootbinaries:
-        raise bb.parse.SkipRecipe("You cannot use UBOOT_BINARIES as it is internal to uboot_config.bbclass.")
-
-    if ubootconfigflags and ubootconfigmakeopts:
-        raise bb.parse.SkipRecipe("You cannot use UBOOT_CONFIG_MAKE_OPTS as it is internal to uboot_config.bbclass.")
-
-    if len(ubootconfig) > 0:
-        for config in ubootconfig:
-            found = False
-            for f, v in ubootconfigflags.items():
-                if config == f: 
-                    found = True
-                    items = v.split(',')
-                    if items[0] and len(items) > 4:
-                        raise bb.parse.SkipRecipe('Only config,images,binary,make_opts can be specified!')
-                    d.appendVar('UBOOT_MACHINE', ' ' + items[0])
-                    # IMAGE_FSTYPES appending
-                    if len(items) > 1 and items[1]:
-                        bb.debug(1, "Appending '%s' to IMAGE_FSTYPES." % items[1])
-                        d.appendVar('IMAGE_FSTYPES', ' ' + items[1])
-                    if len(items) > 2 and items[2]:
-                        bb.debug(1, "Appending '%s' to UBOOT_BINARIES." % items[2])
-                        d.appendVar('UBOOT_BINARIES', ' ' + items[2])
-                    else:
-                        bb.debug(1, "Appending '%s' to UBOOT_BINARIES." % ubootbinary)
-                        d.appendVar('UBOOT_BINARIES', ' ' + ubootbinary)
-                    if len(items) > 3 and items[3]:
-                        bb.debug(1, "Appending '%s' to UBOOT_CONFIG_MAKE_OPTS." % items[3])
-                        d.appendVar('UBOOT_CONFIG_MAKE_OPTS', items[3] + " ? ")
-                    else:
-                        bb.debug(1, "Appending '%s' to UBOOT_CONFIG_MAKE_OPTS." % "")
-                        d.appendVar('UBOOT_CONFIG_MAKE_OPTS', " ? ")
-                    break
-
-            if not found:
-                raise bb.parse.SkipRecipe("The selected UBOOT_CONFIG key %s has no match in %s." % (ubootconfig, ubootconfigflags.keys()))
-
-            # This recipe might be inherited e.g. by the kernel recipe via kernel-fitimage.bbclass
-            # Ensure the uboot specific menuconfig settings do not leak into other recipes
-            if 'u-boot' in recipename:
-                if len(ubootconfig) == 1:
-                    d.setVar('KCONFIG_CONFIG_ROOTDIR', os.path.join("${B}", d.getVar("UBOOT_MACHINE").strip()))
-                else:
-                    # Disable menuconfig for multiple configs
-                    d.setVar('KCONFIG_CONFIG_ENABLE_MENUCONFIG', "false")
-}
diff --git a/meta/classes-recipe/uboot-extlinux-config.bbclass b/meta/classes-recipe/uboot-extlinux-config.bbclass
deleted file mode 100644
index 099476f5d6..0000000000
--- a/meta/classes-recipe/uboot-extlinux-config.bbclass
+++ /dev/null
@@ -1,169 +0,0 @@
-# uboot-extlinux-config.bbclass
-#
-# This class allow the extlinux.conf generation for U-Boot use. The
-# U-Boot support for it is given to allow the Generic Distribution
-# Configuration specification use by OpenEmbedded-based products.
-#
-# External variables:
-#
-# UBOOT_EXTLINUX                   - Set to "1" to enable generation
-#                                    of extlinux.conf using this class.
-# UBOOT_EXTLINUX_CONSOLE           - Set to "console=ttyX" to change kernel boot
-#                                    default console.
-# UBOOT_EXTLINUX_LABELS            - A list of targets for the automatic config.
-# UBOOT_EXTLINUX_KERNEL_ARGS       - Add additional kernel arguments.
-# UBOOT_EXTLINUX_KERNEL_IMAGE      - Kernel image name.
-# UBOOT_EXTLINUX_FDTDIR            - Device tree directory.
-# UBOOT_EXTLINUX_FDT               - Device tree file.
-# UBOOT_EXTLINUX_FDTOVERLAYS       - Device tree overlay files. Space-separated list.
-# UBOOT_EXTLINUX_INITRD            - Indicates a list of filesystem images to
-#                                    concatenate and use as an initrd (optional).
-# UBOOT_EXTLINUX_MENU_DESCRIPTION  - Name to use as description.
-# UBOOT_EXTLINUX_ROOT              - Root kernel cmdline.
-# UBOOT_EXTLINUX_TIMEOUT           - Timeout before DEFAULT selection is made.
-#                                    Measured in 1/10 of a second.
-# UBOOT_EXTLINUX_DEFAULT_LABEL     - Target to be selected by default after
-#                                    the timeout period.
-# UBOOT_EXTLINUX_MENU_TITLE        - Menu title. If empty, MENU TITLE entry
-#                                    will not be added to the output file.
-# UBOOT_EXTLINUX_CONFIG            - Output file.
-#
-# If there's only one label system will boot automatically and menu won't be
-# created. If you want to use more than one labels, e.g linux and alternate,
-# use overrides to set menu description, console and others variables.
-#
-# Ex:
-#
-# UBOOT_EXTLINUX_LABELS ??= "default fallback"
-#
-# UBOOT_EXTLINUX_DEFAULT_LABEL ??= "Linux Default"
-# UBOOT_EXTLINUX_TIMEOUT ??= "30"
-#
-# UBOOT_EXTLINUX_KERNEL_IMAGE:default ??= "../zImage"
-# UBOOT_EXTLINUX_MENU_DESCRIPTION:default ??= "Linux Default"
-#
-# UBOOT_EXTLINUX_KERNEL_IMAGE:fallback ??= "../zImage-fallback"
-# UBOOT_EXTLINUX_MENU_DESCRIPTION:fallback ??= "Linux Fallback"
-#
-# Results:
-#
-# menu title Select the boot mode
-# TIMEOUT 30
-# DEFAULT Linux Default
-# LABEL Linux Default
-#   KERNEL ../zImage
-#   FDTDIR ../
-#   APPEND root=/dev/mmcblk2p2 rootwait rw console=${console}
-# LABEL Linux Fallback
-#   KERNEL ../zImage-fallback
-#   FDTDIR ../
-#   APPEND root=/dev/mmcblk2p2 rootwait rw console=${console}
-#
-# Copyright (C) 2016, O.S. Systems Software LTDA.  All Rights Reserved
-# SPDX-License-Identifier: MIT
-#
-# The kernel has an internal default console, which you can override with
-# a console=...some_tty...
-UBOOT_EXTLINUX_CONSOLE ??= "console=${console},${baudrate}"
-UBOOT_EXTLINUX_LABELS ??= "linux"
-UBOOT_EXTLINUX_FDT ??= ""
-UBOOT_EXTLINUX_FDTOVERLAYS ??= ""
-UBOOT_EXTLINUX_FDTDIR ??= "../"
-UBOOT_EXTLINUX_KERNEL_IMAGE ??= "../${KERNEL_IMAGETYPE}"
-UBOOT_EXTLINUX_KERNEL_ARGS ??= "rootwait rw"
-UBOOT_EXTLINUX_MENU_DESCRIPTION:linux ??= "${DISTRO_NAME}"
-UBOOT_EXTLINUX_MENU_TITLE ??= "Select the boot mode"
-
-UBOOT_EXTLINUX_CONFIG = "${B}/extlinux.conf"
-
-python do_create_extlinux_config() {
-    if d.getVar("UBOOT_EXTLINUX") != "1":
-      return
-
-    if not d.getVar('WORKDIR'):
-        bb.error("WORKDIR not defined, unable to package")
-
-    labels = d.getVar('UBOOT_EXTLINUX_LABELS')
-    if not labels:
-        bb.fatal("UBOOT_EXTLINUX_LABELS not defined, nothing to do")
-
-    if not labels.strip():
-        bb.fatal("No labels, nothing to do")
-
-    cfile = d.getVar('UBOOT_EXTLINUX_CONFIG')
-    if not cfile:
-        bb.fatal('Unable to read UBOOT_EXTLINUX_CONFIG')
-
-    localdata = bb.data.createCopy(d)
-
-    try:
-        with open(cfile, 'w') as cfgfile:
-            cfgfile.write('# Generic Distro Configuration file generated by OpenEmbedded\n')
-
-            menu_title = localdata.getVar('UBOOT_EXTLINUX_MENU_TITLE')
-            if len(labels.split()) > 1 and menu_title:
-                cfgfile.write('MENU TITLE %s\n' % (menu_title))
-
-            timeout = localdata.getVar('UBOOT_EXTLINUX_TIMEOUT')
-            if timeout:
-                cfgfile.write('TIMEOUT %s\n' % (timeout))
-
-            if len(labels.split()) > 1:
-                default = localdata.getVar('UBOOT_EXTLINUX_DEFAULT_LABEL')
-                if default:
-                    cfgfile.write('DEFAULT %s\n' % (default))
-
-            # Need to deconflict the labels with existing overrides
-            label_overrides = labels.split()
-            default_overrides = localdata.getVar('OVERRIDES').split(':')
-            # We're keeping all the existing overrides that aren't used as a label
-            # an override for that label will be added back in while we're processing that label
-            keep_overrides = list(filter(lambda x: x not in label_overrides, default_overrides))
-
-            for label in labels.split():
-
-                localdata.setVar('OVERRIDES', ':'.join(keep_overrides + [label]))
-
-                extlinux_console = localdata.getVar('UBOOT_EXTLINUX_CONSOLE')
-
-                menu_description = localdata.getVar('UBOOT_EXTLINUX_MENU_DESCRIPTION')
-                if not menu_description:
-                    menu_description = label
-
-                root = localdata.getVar('UBOOT_EXTLINUX_ROOT')
-                if not root:
-                    bb.fatal('UBOOT_EXTLINUX_ROOT not defined')
-
-                kernel_image = localdata.getVar('UBOOT_EXTLINUX_KERNEL_IMAGE')
-                fdtdir = localdata.getVar('UBOOT_EXTLINUX_FDTDIR')
-
-                fdt = localdata.getVar('UBOOT_EXTLINUX_FDT')
-                fdtoverlays = localdata.getVar('UBOOT_EXTLINUX_FDTOVERLAYS')
-
-                cfgfile.write('LABEL %s\n\tKERNEL %s\n' % (menu_description, kernel_image))
-
-                if fdt:
-                    cfgfile.write('\tFDT %s\n' % (fdt))
-                elif fdtdir:
-                    cfgfile.write('\tFDTDIR %s\n' % (fdtdir))
-
-                if fdtoverlays:
-                    cfgfile.write('\tFDTOVERLAYS %s\n' % (' '.join(fdtoverlays.split())))
-
-                kernel_args = localdata.getVar('UBOOT_EXTLINUX_KERNEL_ARGS')
-
-                initrd = localdata.getVar('UBOOT_EXTLINUX_INITRD')
-                if initrd:
-                    cfgfile.write('\tINITRD %s\n'% initrd)
-
-                kernel_args = root + " " + kernel_args
-                cfgfile.write('\tAPPEND %s %s\n' % (kernel_args, extlinux_console))
-
-    except OSError:
-        bb.fatal('Unable to open %s' % (cfile))
-}
-UBOOT_EXTLINUX_VARS = "CONSOLE MENU_DESCRIPTION ROOT KERNEL_IMAGE FDTDIR FDT FDTOVERLAYS KERNEL_ARGS INITRD"
-do_create_extlinux_config[vardeps] += "${@' '.join(['UBOOT_EXTLINUX_%s:%s' % (v, l) for v in d.getVar('UBOOT_EXTLINUX_VARS').split() for l in d.getVar('UBOOT_EXTLINUX_LABELS').split()])}"
-do_create_extlinux_config[vardepsexclude] += "OVERRIDES"
-
-addtask create_extlinux_config before do_install do_deploy after do_compile
diff --git a/meta/classes-recipe/uboot-sign.bbclass b/meta/classes-recipe/uboot-sign.bbclass
deleted file mode 100644
index 66b9698c1d..0000000000
--- a/meta/classes-recipe/uboot-sign.bbclass
+++ /dev/null
@@ -1,631 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-# This file is part of U-Boot verified boot support and is intended to be
-# inherited from the u-boot recipe.
-#
-# The signature procedure requires the user to generate an RSA key and
-# certificate in a directory and to define the following variable:
-#
-#   UBOOT_SIGN_KEYDIR = "/keys/directory"
-#   UBOOT_SIGN_KEYNAME = "dev" # keys name in keydir (eg. "dev.crt", "dev.key")
-#   UBOOT_MKIMAGE_DTCOPTS = "-I dts -O dtb -p 2000"
-#   UBOOT_SIGN_ENABLE = "1"
-#
-# As verified boot depends on fitImage generation, following is also required:
-#
-#   KERNEL_CLASSES ?= " kernel-fitimage "
-#   KERNEL_IMAGETYPE ?= "fitImage"
-#
-# The signature support is limited to the use of CONFIG_OF_SEPARATE in U-Boot.
-#
-# For more details on signature process, please refer to U-Boot documentation.
-
-# We need some variables from u-boot-config
-inherit uboot-config
-require conf/image-fitimage.conf
-
-# Enable use of a U-Boot fitImage
-UBOOT_FITIMAGE_ENABLE ?= "0"
-
-# Signature activation - this requires UBOOT_FITIMAGE_ENABLE = "1"
-SPL_SIGN_ENABLE ?= "0"
-
-# Default value for deployment filenames.
-UBOOT_DTB_IMAGE ?= "u-boot-${MACHINE}-${PV}-${PR}.dtb"
-UBOOT_DTB_BINARY ?= "u-boot.dtb"
-UBOOT_DTB_SIGNED ?= "${UBOOT_DTB_BINARY}-signed"
-UBOOT_DTB_SYMLINK ?= "u-boot-${MACHINE}.dtb"
-UBOOT_NODTB_IMAGE ?= "u-boot-nodtb-${MACHINE}-${PV}-${PR}.bin"
-UBOOT_NODTB_BINARY ?= "u-boot-nodtb.bin"
-UBOOT_NODTB_SYMLINK ?= "u-boot-nodtb-${MACHINE}.bin"
-UBOOT_ITS_IMAGE ?= "u-boot-its-${MACHINE}-${PV}-${PR}"
-UBOOT_ITS ?= "u-boot.its"
-UBOOT_ITS_SYMLINK ?= "u-boot-its-${MACHINE}"
-UBOOT_FITIMAGE_IMAGE ?= "u-boot-fitImage-${MACHINE}-${PV}-${PR}"
-UBOOT_FITIMAGE_BINARY ?= "u-boot-fitImage"
-UBOOT_FITIMAGE_SYMLINK ?= "u-boot-fitImage-${MACHINE}"
-SPL_DIR ?= "spl"
-SPL_DTB_IMAGE ?= "u-boot-spl-${MACHINE}-${PV}-${PR}.dtb"
-# When SPL is not used, set SPL_DTB_BINARY ?= "" to explicitly indicate
-# that no SPL DTB should be created or signed.
-SPL_DTB_BINARY ?= "u-boot-spl.dtb"
-SPL_DTB_SIGNED ?= "${SPL_DTB_BINARY}-signed"
-SPL_DTB_SYMLINK ?= "u-boot-spl-${MACHINE}.dtb"
-SPL_NODTB_IMAGE ?= "u-boot-spl-nodtb-${MACHINE}-${PV}-${PR}.bin"
-SPL_NODTB_BINARY ?= "u-boot-spl-nodtb.bin"
-SPL_NODTB_SYMLINK ?= "u-boot-spl-nodtb-${MACHINE}.bin"
-
-# U-Boot fitImage description
-UBOOT_FIT_DESC ?= "U-Boot fitImage for ${DISTRO_NAME}/${PV}/${MACHINE}"
-
-# U-Boot fitImage Hash Algo
-UBOOT_FIT_HASH_ALG ?= "sha256"
-
-# U-Boot fitImage Signature Algo
-UBOOT_FIT_SIGN_ALG ?= "rsa2048"
-
-# Generate keys for signing U-Boot fitImage
-UBOOT_FIT_GENERATE_KEYS ?= "0"
-
-# Size of private keys in number of bits
-UBOOT_FIT_SIGN_NUMBITS ?= "2048"
-
-# args to openssl genrsa (Default is just the public exponent)
-UBOOT_FIT_KEY_GENRSA_ARGS ?= "-F4"
-
-# args to openssl req (Default is -batch for non interactive mode and
-# -new for new certificate)
-UBOOT_FIT_KEY_REQ_ARGS ?= "-batch -new"
-
-# Standard format for public key certificate
-UBOOT_FIT_KEY_SIGN_PKCS ?= "-x509"
-
-# length of address in number of <u32> cells
-# ex: 1 32bits address, 2 64bits address
-UBOOT_FIT_ADDRESS_CELLS ?= "1"
-
-# ARM Trusted Firmware(ATF) is a reference implementation of secure world
-# software for Arm A-Profile architectures, (Armv8-A and Armv7-A), including
-# an Exception Level 3 (EL3) Secure Monitor.
-UBOOT_FIT_ARM_TRUSTED_FIRMWARE ?= "0"
-UBOOT_FIT_ARM_TRUSTED_FIRMWARE_IMAGE ?= "bl31.bin"
-
-# A Trusted Execution Environment(TEE) is an environment for executing code,
-# in which those executing the code can have high levels of trust in the asset
-# management of that surrounding environment.
-UBOOT_FIT_TEE ?= "0"
-UBOOT_FIT_TEE_IMAGE ?= "tee-raw.bin"
-
-# User specific settings
-UBOOT_FIT_USER_SETTINGS ?= ""
-
-# Sets the firmware property to select the image to boot first.
-# If not set, the first entry in "loadables" is used instead.
-UBOOT_FIT_CONF_FIRMWARE ?= ""
-
-# Unit name containing a list of users additional binaries to be loaded.
-# It is a comma-separated list of strings.
-UBOOT_FIT_CONF_USER_LOADABLES ?= ''
-
-UBOOT_FIT_UBOOT_LOADADDRESS ?= "${UBOOT_LOADADDRESS}"
-UBOOT_FIT_UBOOT_ENTRYPOINT ?= "${UBOOT_ENTRYPOINT}"
-
-
-DEPENDS:append = " ${@'kernel-signing-keys-native' if d.getVar('FIT_GENERATE_KEYS') == '1' else ''}"
-
-python() {
-    # We need u-boot-tools-native if we're creating a U-Boot fitImage
-    sign = d.getVar('UBOOT_SIGN_ENABLE') == '1'
-    if d.getVar('UBOOT_FITIMAGE_ENABLE') == '1' or sign:
-        d.appendVar('DEPENDS', " u-boot-tools-native dtc-native")
-}
-
-concat_dtb() {
-        type="$1"
-        binary="$2"
-
-        if [ -e "${UBOOT_DTB_BINARY}" ]; then
-                # Signing individual images is not recommended as that
-                # makes fitImage susceptible to mix-and-match attack.
-                #
-                # OE FIT_SIGN_INDIVIDUAL is implemented in an unusual manner,
-                # where the resulting signed fitImage contains both signed
-                # images and signed configurations. This is redundant. In
-                # order to prevent mix-and-match attack, it is sufficient
-                # to sign configurations. The FIT_SIGN_INDIVIDUAL = "1"
-                # support is kept to avoid breakage of existing layers, but
-                # it is highly recommended to avoid FIT_SIGN_INDIVIDUAL = "1",
-                # i.e. set FIT_SIGN_INDIVIDUAL = "0" .
-                if [ "${FIT_SIGN_INDIVIDUAL}" = "1" ] ; then
-                        # Sign dummy image images in order to
-                        # add the image signing keys to our dtb
-                        ${UBOOT_MKIMAGE_SIGN} \
-                                ${@'-D "${UBOOT_MKIMAGE_DTCOPTS}"' if len('${UBOOT_MKIMAGE_DTCOPTS}') else ''} \
-                                -f auto \
-                                -k "${UBOOT_SIGN_KEYDIR}" \
-                                -o "${FIT_HASH_ALG},${FIT_SIGN_ALG}" \
-                                -g "${UBOOT_SIGN_IMG_KEYNAME}" \
-                                -K "${UBOOT_DTB_BINARY}" \
-                                -d /dev/null \
-                                -r ${B}/unused.itb \
-                                ${UBOOT_MKIMAGE_SIGN_ARGS}
-                fi
-
-                # Sign dummy image configurations in order to
-                # add the configuration signing keys to our dtb
-                ${UBOOT_MKIMAGE_SIGN} \
-                        ${@'-D "${UBOOT_MKIMAGE_DTCOPTS}"' if len('${UBOOT_MKIMAGE_DTCOPTS}') else ''} \
-                        -f auto-conf \
-                        -k "${UBOOT_SIGN_KEYDIR}" \
-                        -o "${FIT_HASH_ALG},${FIT_SIGN_ALG}" \
-                        -g "${UBOOT_SIGN_KEYNAME}" \
-                        -K "${UBOOT_DTB_BINARY}" \
-                        -d /dev/null \
-                        -r ${B}/unused.itb \
-                        ${UBOOT_MKIMAGE_SIGN_ARGS}
-
-                # Verify the dummy fitImage signature against u-boot.dtb
-                # augmented using public key material.
-                #
-                # This only works for FIT_SIGN_INDIVIDUAL = "0", because
-                # mkimage -f auto-conf does not support -F to extend the
-                # existing unused.itb , and instead rewrites unused.itb
-                # from scratch.
-                #
-                # Using two separate unused.itb for mkimage -f auto and
-                # mkimage -f auto-conf invocation above would not help, as
-                # the signature verification process below checks whether
-                # all keys inserted into u-boot.dtb /signature node pass
-                # the verification. Separate unused.itb would each miss one
-                # of the signatures.
-                #
-                # The FIT_SIGN_INDIVIDUAL = "1" support is kept to avoid
-                # breakage of existing layers, but it is highly recommended
-                # to not use FIT_SIGN_INDIVIDUAL = "1", i.e. set
-                # FIT_SIGN_INDIVIDUAL = "0" .
-                if [ "${FIT_SIGN_INDIVIDUAL}" != "1" ] ; then
-                        ${UBOOT_FIT_CHECK_SIGN} \
-                                -k "${UBOOT_DTB_BINARY}" \
-                                -f ${B}/unused.itb
-                fi
-                cp ${UBOOT_DTB_BINARY} ${UBOOT_DTB_SIGNED}
-        fi
-
-        # If we're not using a signed u-boot fit, concatenate SPL w/o DTB & U-Boot DTB
-        # with public key (otherwise U-Boot will be packaged by uboot_fitimage_assemble)
-        if [ "${SPL_SIGN_ENABLE}" != "1" ] ; then
-                if [ ! -e "${UBOOT_DTB_BINARY}" ]; then
-                        bbwarn "Failure while adding public key to u-boot binary. Verified boot won't be available."
-                        return
-                fi
-
-                if [ "x${UBOOT_SUFFIX}" = "ximg" ] || [ "x${UBOOT_SUFFIX}" = "xrom" ]; then
-                        oe_runmake EXT_DTB="${UBOOT_DTB_SIGNED}" ${UBOOT_MAKE_TARGET}
-                        if [ -n "${binary}" ]; then
-                                cp ${binary} ${UBOOT_BINARYNAME}-${type}.${UBOOT_SUFFIX}
-                        fi
-                elif [ -e "${UBOOT_NODTB_BINARY}" ]; then
-                        if [ -n "${binary}" ]; then
-                                cat ${UBOOT_NODTB_BINARY} ${UBOOT_DTB_SIGNED} | tee ${binary} > \
-                                        ${UBOOT_BINARYNAME}-${type}.${UBOOT_SUFFIX}
-                        else
-                                cat ${UBOOT_NODTB_BINARY} ${UBOOT_DTB_SIGNED} > ${UBOOT_BINARY}
-                        fi
-                fi
-        fi
-}
-
-deploy_dtb() {
-        type="$1"
-
-        if [ -n "${type}" ]; then
-                uboot_dtb_binary="u-boot-${type}-${PV}-${PR}.dtb"
-                uboot_nodtb_binary="u-boot-nodtb-${type}-${PV}-${PR}.bin"
-        else
-                uboot_dtb_binary="${UBOOT_DTB_IMAGE}"
-                uboot_nodtb_binary="${UBOOT_NODTB_IMAGE}"
-        fi
-
-        if [ -e "${UBOOT_DTB_SIGNED}" ]; then
-                install -Dm644 ${UBOOT_DTB_SIGNED} ${DEPLOYDIR}/${uboot_dtb_binary}
-                if [ -n "${type}" ]; then
-                        ln -sf ${uboot_dtb_binary} ${DEPLOYDIR}/${UBOOT_DTB_IMAGE}
-                fi
-        fi
-
-        if [ -f "${UBOOT_NODTB_BINARY}" ]; then
-                install -Dm644 ${UBOOT_NODTB_BINARY} ${DEPLOYDIR}/${uboot_nodtb_binary}
-                if [ -n "${type}" ]; then
-                        ln -sf ${uboot_nodtb_binary} ${DEPLOYDIR}/${UBOOT_NODTB_IMAGE}
-                fi
-        fi
-}
-
-concat_spl_dtb() {
-        if [ -e "${SPL_DIR}/${SPL_NODTB_BINARY}" ] && [ -e "${SPL_DIR}/${SPL_DTB_BINARY}" ] ; then
-                cat ${SPL_DIR}/${SPL_NODTB_BINARY} ${SPL_DIR}/${SPL_DTB_SIGNED} > "${SPL_BINARY}"
-        else
-                bbwarn "Failure while adding public key to spl binary. Verified U-Boot boot won't be available."
-        fi
-}
-
-deploy_spl_dtb() {
-        type="$1"
-
-        if [ -n "${type}" ]; then
-                spl_dtb_binary="u-boot-spl-${type}-${PV}-${PR}.dtb"
-                spl_nodtb_binary="u-boot-spl-nodtb-${type}-${PV}-${PR}.bin"
-        else
-                spl_dtb_binary="${SPL_DTB_IMAGE}"
-                spl_nodtb_binary="${SPL_NODTB_IMAGE}"
-        fi
-
-        if [ -e "${SPL_DIR}/${SPL_DTB_SIGNED}" ] ; then
-                install -Dm644 ${SPL_DIR}/${SPL_DTB_SIGNED} ${DEPLOYDIR}/${spl_dtb_binary}
-                if [ -n "${type}" ]; then
-                        ln -sf ${spl_dtb_binary} ${DEPLOYDIR}/${SPL_DTB_IMAGE}
-                fi
-        fi
-
-        if [ -f "${SPL_DIR}/${SPL_NODTB_BINARY}" ] ; then
-                install -Dm644 ${SPL_DIR}/${SPL_NODTB_BINARY} ${DEPLOYDIR}/${spl_nodtb_binary}
-                if [ -n "${type}" ]; then
-                        ln -sf ${spl_nodtb_binary} ${DEPLOYDIR}/${SPL_NODTB_IMAGE}
-                fi
-        fi
-
-        # For backwards compatibility...
-        install -Dm644 ${SPL_BINARY} ${DEPLOYDIR}/${SPL_IMAGE}
-}
-
-do_uboot_generate_rsa_keys() {
-        if [ "${SPL_SIGN_ENABLE}" = "0" ] && [ "${UBOOT_FIT_GENERATE_KEYS}" = "1" ]; then
-                bbwarn "UBOOT_FIT_GENERATE_KEYS is set to 1 eventhough SPL_SIGN_ENABLE is set to 0. The keys will not be generated as they won't be used."
-        fi
-
-        if [ "${SPL_SIGN_ENABLE}" = "1" ] && [ "${UBOOT_FIT_GENERATE_KEYS}" = "1" ]; then
-
-                # Generate keys only if they don't already exist
-                if [ ! -f "${SPL_SIGN_KEYDIR}/${SPL_SIGN_KEYNAME}".key ] || \
-                        [ ! -f "${SPL_SIGN_KEYDIR}/${SPL_SIGN_KEYNAME}".crt ]; then
-
-                        # make directory if it does not already exist
-                        mkdir -p "${SPL_SIGN_KEYDIR}"
-
-                        echo "Generating RSA private key for signing U-Boot fitImage"
-                        openssl genrsa ${UBOOT_FIT_KEY_GENRSA_ARGS} -out \
-                                "${SPL_SIGN_KEYDIR}/${SPL_SIGN_KEYNAME}".key \
-                                "${UBOOT_FIT_SIGN_NUMBITS}"
-
-                        echo "Generating certificate for signing U-Boot fitImage"
-                        openssl req ${UBOOT_FIT_KEY_REQ_ARGS} "${UBOOT_FIT_KEY_SIGN_PKCS}" \
-                                -key "${SPL_SIGN_KEYDIR}/${SPL_SIGN_KEYNAME}".key \
-                                -out "${SPL_SIGN_KEYDIR}/${SPL_SIGN_KEYNAME}".crt
-                fi
-        fi
-
-}
-
-addtask uboot_generate_rsa_keys before do_uboot_assemble_fitimage after do_compile
-
-# Create a ITS file for the atf
-uboot_fitimage_atf() {
-        cat << EOF >> ${UBOOT_ITS}
-        atf {
-            description = "ARM Trusted Firmware";
-            data = /incbin/("${UBOOT_FIT_ARM_TRUSTED_FIRMWARE_IMAGE}");
-            type = "firmware";
-            arch = "${UBOOT_ARCH}";
-            os = "arm-trusted-firmware";
-            load = <${UBOOT_FIT_ARM_TRUSTED_FIRMWARE_LOADADDRESS}>;
-            entry = <${UBOOT_FIT_ARM_TRUSTED_FIRMWARE_ENTRYPOINT}>;
-            compression = "none";
-EOF
-        if [ "${SPL_SIGN_ENABLE}" = "1" ] ; then
-                cat << EOF >> ${UBOOT_ITS}
-            signature {
-                algo = "${UBOOT_FIT_HASH_ALG},${UBOOT_FIT_SIGN_ALG}";
-                key-name-hint = "${SPL_SIGN_KEYNAME}";
-            };
-EOF
-        fi
-
-        cat << EOF >> ${UBOOT_ITS}
-        };
-EOF
-}
-
-# Create a ITS file for the tee
-uboot_fitimage_tee() {
-        cat << EOF >> ${UBOOT_ITS}
-        tee {
-            description = "Trusted Execution Environment";
-            data = /incbin/("${UBOOT_FIT_TEE_IMAGE}");
-            type = "tee";
-            arch = "${UBOOT_ARCH}";
-            os = "tee";
-            load = <${UBOOT_FIT_TEE_LOADADDRESS}>;
-            entry = <${UBOOT_FIT_TEE_ENTRYPOINT}>;
-            compression = "none";
-EOF
-        if [ "${SPL_SIGN_ENABLE}" = "1" ] ; then
-                cat << EOF >> ${UBOOT_ITS}
-            signature {
-                algo = "${UBOOT_FIT_HASH_ALG},${UBOOT_FIT_SIGN_ALG}";
-                key-name-hint = "${SPL_SIGN_KEYNAME}";
-            };
-EOF
-        fi
-
-        cat << EOF >> ${UBOOT_ITS}
-        };
-EOF
-}
-
-# Create a ITS file for the U-boot FIT, for use when
-# we want to sign it so that the SPL can verify it
-uboot_fitimage_assemble() {
-        conf_loadables="\"uboot\""
-        conf_firmware=""
-        rm -f ${UBOOT_ITS} ${UBOOT_FITIMAGE_BINARY}
-
-        # First we create the ITS script
-        cat << EOF >> ${UBOOT_ITS}
-/dts-v1/;
-
-/ {
-    description = "${UBOOT_FIT_DESC}";
-    #address-cells = <${UBOOT_FIT_ADDRESS_CELLS}>;
-
-    images {
-        uboot {
-            description = "U-Boot image";
-            data = /incbin/("${UBOOT_NODTB_BINARY}");
-            type = "standalone";
-            os = "u-boot";
-            arch = "${UBOOT_ARCH}";
-            compression = "none";
-            load = <${UBOOT_FIT_UBOOT_LOADADDRESS}>;
-            entry = <${UBOOT_FIT_UBOOT_ENTRYPOINT}>;
-EOF
-
-        if [ "${SPL_SIGN_ENABLE}" = "1" ] ; then
-                cat << EOF >> ${UBOOT_ITS}
-            signature {
-                algo = "${UBOOT_FIT_HASH_ALG},${UBOOT_FIT_SIGN_ALG}";
-                key-name-hint = "${SPL_SIGN_KEYNAME}";
-            };
-EOF
-        fi
-
-        cat << EOF >> ${UBOOT_ITS}
-        };
-        fdt {
-            description = "U-Boot FDT";
-            data = /incbin/("${UBOOT_DTB_BINARY}");
-            type = "flat_dt";
-            arch = "${UBOOT_ARCH}";
-            compression = "none";
-EOF
-
-        if [ "${SPL_SIGN_ENABLE}" = "1" ] ; then
-                cat << EOF >> ${UBOOT_ITS}
-            signature {
-                algo = "${UBOOT_FIT_HASH_ALG},${UBOOT_FIT_SIGN_ALG}";
-                key-name-hint = "${SPL_SIGN_KEYNAME}";
-            };
-EOF
-        fi
-
-        cat << EOF >> ${UBOOT_ITS}
-        };
-EOF
-        if [ "${UBOOT_FIT_TEE}" = "1" ] ; then
-                conf_loadables="\"tee\", ${conf_loadables}"
-                uboot_fitimage_tee
-        fi
-
-        if [ "${UBOOT_FIT_ARM_TRUSTED_FIRMWARE}" = "1" ] ; then
-                conf_loadables="\"atf\", ${conf_loadables}"
-                uboot_fitimage_atf
-        fi
-
-        if [ -n "${UBOOT_FIT_USER_SETTINGS}" ] ; then
-                printf "%b" "${UBOOT_FIT_USER_SETTINGS}" >> ${UBOOT_ITS}
-        fi
-
-        if [ -n "${UBOOT_FIT_CONF_USER_LOADABLES}" ] ; then
-                conf_loadables="${conf_loadables}${UBOOT_FIT_CONF_USER_LOADABLES}"
-        fi
-
-        if [ -n "${UBOOT_FIT_CONF_FIRMWARE}" ] ; then
-                conf_firmware="firmware = \"${UBOOT_FIT_CONF_FIRMWARE}\";"
-        fi
-
-        cat << EOF >> ${UBOOT_ITS}
-    };
-
-    configurations {
-        default = "conf";
-        conf {
-            description = "Boot with signed U-Boot FIT";
-            ${conf_firmware}
-            loadables = ${conf_loadables};
-            fdt = "fdt";
-        };
-    };
-};
-EOF
-
-        #
-        # Assemble the U-boot FIT image
-        #
-        ${UBOOT_MKIMAGE} \
-                ${@'-D "${SPL_MKIMAGE_DTCOPTS}"' if len('${SPL_MKIMAGE_DTCOPTS}') else ''} \
-                -f ${UBOOT_ITS} \
-                ${UBOOT_FITIMAGE_BINARY}
-
-        if [ "${SPL_SIGN_ENABLE}" = "1" ] ; then
-                if [ -n "${SPL_DTB_BINARY}" ] ; then
-                        #
-                        # Sign the U-boot FIT image and add public key to SPL dtb
-                        #
-                        ${UBOOT_MKIMAGE_SIGN} \
-                                ${@'-D "${SPL_MKIMAGE_DTCOPTS}"' if len('${SPL_MKIMAGE_DTCOPTS}') else ''} \
-                                -F -k "${SPL_SIGN_KEYDIR}" \
-                                -K "${SPL_DIR}/${SPL_DTB_BINARY}" \
-                                -r ${UBOOT_FITIMAGE_BINARY} \
-                                ${SPL_MKIMAGE_SIGN_ARGS}
-
-                        # Verify the U-boot FIT image and SPL dtb
-                        ${UBOOT_FIT_CHECK_SIGN} \
-                                -k "${SPL_DIR}/${SPL_DTB_BINARY}" \
-                                -f ${UBOOT_FITIMAGE_BINARY}
-
-                        cp ${SPL_DIR}/${SPL_DTB_BINARY} ${SPL_DIR}/${SPL_DTB_SIGNED}
-                else
-                        # Sign the U-boot FIT image
-                        ${UBOOT_MKIMAGE_SIGN} \
-                                ${@'-D "${SPL_MKIMAGE_DTCOPTS}"' if len('${SPL_MKIMAGE_DTCOPTS}') else ''} \
-                                -F -k "${SPL_SIGN_KEYDIR}" \
-                                -r ${UBOOT_FITIMAGE_BINARY} \
-                                ${SPL_MKIMAGE_SIGN_ARGS}
-                fi
-        fi
-}
-
-uboot_assemble_fitimage_helper() {
-        type="$1"
-        binary="$2"
-
-        if [ "${UBOOT_SIGN_ENABLE}" = "1" ] && [ -n "${UBOOT_DTB_BINARY}" ] ; then
-                concat_dtb "$type" "$binary"
-        fi
-
-        if [ "${UBOOT_FITIMAGE_ENABLE}" = "1" ]; then
-                uboot_fitimage_assemble
-        fi
-
-        if [ "${SPL_SIGN_ENABLE}" = "1" ] && [ -n "${SPL_DTB_BINARY}" ] ; then
-                concat_spl_dtb
-        fi
-}
-
-do_uboot_assemble_fitimage() {
-        if [ -n "${UBOOT_CONFIG}" ]; then
-                unset i
-                for config in ${UBOOT_MACHINE}; do
-                        unset j k
-                        i=$(expr $i + 1);
-                        for type in ${UBOOT_CONFIG}; do
-                                j=$(expr $j + 1);
-                                if [ $j -eq $i ]; then
-                                        break;
-                                fi
-                        done
-
-                        builddir="${config}-${type}"
-
-                        for binary in ${UBOOT_BINARIES}; do
-                                k=$(expr $k + 1);
-                                if [ $k -eq $i ]; then
-                                        break;
-                                fi
-                        done
-
-                        cd ${B}/${builddir}
-                        uboot_assemble_fitimage_helper ${type} ${binary}
-                done
-        else
-                cd ${B}
-                uboot_assemble_fitimage_helper "" ${UBOOT_BINARY}
-        fi
-}
-
-addtask uboot_assemble_fitimage before do_install do_deploy after do_compile
-
-deploy_helper() {
-        type="$1"
-
-        if [ "${UBOOT_SIGN_ENABLE}" = "1" ] && [ -n "${UBOOT_DTB_SIGNED}" ] ; then
-                deploy_dtb $type
-        fi
-
-        if [ "${UBOOT_FITIMAGE_ENABLE}" = "1" ]; then
-                if [ -n "${type}" ]; then
-                        uboot_its_image="u-boot-its-${type}-${PV}-${PR}"
-                        uboot_fitimage_image="u-boot-fitImage-${type}-${PV}-${PR}"
-                else
-                        uboot_its_image="${UBOOT_ITS_IMAGE}"
-                        uboot_fitimage_image="${UBOOT_FITIMAGE_IMAGE}"
-                fi
-
-                install -Dm644 ${UBOOT_FITIMAGE_BINARY} ${DEPLOYDIR}/$uboot_fitimage_image
-                install -Dm644 ${UBOOT_ITS} ${DEPLOYDIR}/$uboot_its_image
-
-                if [ -n "${type}" ]; then
-                        ln -sf $uboot_its_image ${DEPLOYDIR}/${UBOOT_ITS_IMAGE}
-                        ln -sf $uboot_fitimage_image ${DEPLOYDIR}/${UBOOT_FITIMAGE_IMAGE}
-                fi
-        fi
-
-        if [ "${SPL_SIGN_ENABLE}" = "1" ] && [ -n "${SPL_DTB_BINARY}" ] ; then
-                deploy_spl_dtb $type
-        fi
-}
-
-do_deploy:prepend() {
-        if [ -n "${UBOOT_CONFIG}" ]; then
-                unset i j k
-                for config in ${UBOOT_MACHINE}; do
-                        i=$(expr $i + 1);
-                        for type in ${UBOOT_CONFIG}; do
-                                j=$(expr $j + 1);
-                                if [ $j -eq $i ]; then
-                                        builddir="${config}-${type}"
-                                        cd ${B}/${builddir}
-                                        deploy_helper ${type}
-                                fi
-                        done
-                        unset j
-                done
-                unset i
-        else
-                cd ${B}
-                deploy_helper ""
-        fi
-
-        if [ "${UBOOT_SIGN_ENABLE}" = "1" ] && [ -n "${UBOOT_DTB_BINARY}" ] ; then
-                ln -sf ${UBOOT_DTB_IMAGE} ${DEPLOYDIR}/${UBOOT_DTB_BINARY}
-                ln -sf ${UBOOT_DTB_IMAGE} ${DEPLOYDIR}/${UBOOT_DTB_SYMLINK}
-                ln -sf ${UBOOT_NODTB_IMAGE} ${DEPLOYDIR}/${UBOOT_NODTB_SYMLINK}
-                ln -sf ${UBOOT_NODTB_IMAGE} ${DEPLOYDIR}/${UBOOT_NODTB_BINARY}
-        fi
-
-        if [ "${UBOOT_FITIMAGE_ENABLE}" = "1" ] ; then
-                ln -sf ${UBOOT_ITS_IMAGE} ${DEPLOYDIR}/${UBOOT_ITS}
-                ln -sf ${UBOOT_ITS_IMAGE} ${DEPLOYDIR}/${UBOOT_ITS_SYMLINK}
-                ln -sf ${UBOOT_FITIMAGE_IMAGE} ${DEPLOYDIR}/${UBOOT_FITIMAGE_BINARY}
-                ln -sf ${UBOOT_FITIMAGE_IMAGE} ${DEPLOYDIR}/${UBOOT_FITIMAGE_SYMLINK}
-        fi
-
-        if [ "${SPL_SIGN_ENABLE}" = "1" ] && [ -n "${SPL_DTB_BINARY}" ] ; then
-                ln -sf ${SPL_DTB_IMAGE} ${DEPLOYDIR}/${SPL_DTB_SYMLINK}
-                ln -sf ${SPL_DTB_IMAGE} ${DEPLOYDIR}/${SPL_DTB_BINARY}
-                ln -sf ${SPL_NODTB_IMAGE} ${DEPLOYDIR}/${SPL_NODTB_SYMLINK}
-                ln -sf ${SPL_NODTB_IMAGE} ${DEPLOYDIR}/${SPL_NODTB_BINARY}
-        fi
-}
-
-do_deploy:append() {
-        # If we're creating a u-boot fitImage, point u-boot.bin
-        # symlink since it might get used by image recipes
-        if [ "${UBOOT_FITIMAGE_ENABLE}" = "1" ] ; then
-                ln -sf ${UBOOT_FITIMAGE_IMAGE} ${DEPLOYDIR}/${UBOOT_BINARY}
-                ln -sf ${UBOOT_FITIMAGE_IMAGE} ${DEPLOYDIR}/${UBOOT_SYMLINK}
-        fi
-}
diff --git a/meta/classes-recipe/uki.bbclass b/meta/classes-recipe/uki.bbclass
deleted file mode 100644
index fedff222c6..0000000000
--- a/meta/classes-recipe/uki.bbclass
+++ /dev/null
@@ -1,194 +0,0 @@
-# Unified kernel image (UKI) class
-#
-# This bbclass merges kernel, initrd etc as a UKI standard UEFI binary,
-# to be loaded with UEFI firmware and systemd-boot on target HW.
-# TPM PCR pre-calculation is not supported since systemd-measure tooling
-# is meant to run on target, not in cross compile environment.
-#
-# See:
-# https://www.freedesktop.org/software/systemd/man/latest/ukify.html
-# https://uapi-group.org/specifications/specs/unified_kernel_image/
-#
-# The UKI contains:
-#
-#   - UEFI stub
-#     The linux kernel can generate a UEFI stub, however the one from systemd-boot can fetch
-#     the command line from a separate section of the EFI application, avoiding the need to
-#     rebuild the kernel.
-#   - kernel
-#   - initramfs
-#   - kernel command line
-#   - uname -r kernel version
-#   - /etc/os-release to create a boot menu with version details
-#   - optionally secure boot signature(s)
-#   - other metadata (e.g. TPM PCR measurements)
-#
-# Usage instructions:
-#
-#   - requires UEFI compatible firmware on target, e.g. qemuarm64-secureboot u-boot based
-#     from meta-arm or qemux86 ovmf/edk2 based firmware for x86_64
-#
-#   - Distro/build config:
-#
-#     INIT_MANAGER = "systemd"
-#     MACHINE_FEATURES:append = " efi"
-#     EFI_PROVIDER = "systemd-boot"
-#     INITRAMFS_IMAGE = "core-image-minimal-initramfs"
-#
-#   - image recipe:
-#
-#     inherit uki
-#
-#   - qemuboot/runqemu changes in image recipe or build config:
-#
-#     # Kernel command line must be inside the signed uki
-#     QB_KERNEL_ROOT = ""
-#     # kernel is in the uki image, not loaded separately
-#     QB_DEFAULT_KERNEL = "none"
-#
-#   - for UEFI secure boot, systemd-boot and uki (including kernel) can
-#     be signed but require sbsign-tool-native (recipe available from meta-secure-core,
-#     see also qemuarm64-secureboot from meta-arm). Set variable
-#     UKI_SB_KEY to path of private key and UKI_SB_CERT for certificate.
-#     Note that systemd-boot also need to be signed with the same key.
-#
-#   - at runtime, UEFI firmware will load and boot systemd-boot which
-#     creates a menu from all detected uki binaries. No need to manually
-#     setup boot menu entries.
-#
-#   - see efi-uki-bootdisk.wks.in how to create ESP partition which hosts systemd-boot,
-#     config file(s) for systemd-boot and the UKI binaries.
-#
-
-DEPENDS += "\
-    os-release \
-    systemd-boot \
-    systemd-boot-native \
-    virtual/cross-binutils \
-    virtual/kernel \
-"
-
-inherit image-artifact-names
-require ../conf/image-uefi.conf
-
-INITRAMFS_IMAGE ?= "core-image-minimal-initramfs"
-
-INITRD_ARCHIVE ?= "${INITRAMFS_IMAGE}-${MACHINE}.${INITRAMFS_FSTYPES}"
-
-do_image_complete[depends] += "${INITRAMFS_IMAGE}:do_image_complete"
-
-UKIFY_CMD ?= "ukify build"
-UKI_CONFIG_FILE ?= "${UNPACKDIR}/uki.conf"
-UKI_FILENAME ?= "uki.efi"
-UKI_KERNEL_FILENAME ?= "${KERNEL_IMAGETYPE}"
-UKI_CMDLINE ?= "rootwait root=LABEL=root"
-# secure boot keys and cert, needs sbsign-tools-native (meta-secure-core)
-#UKI_SB_KEY ?= ""
-#UKI_SB_CERT ?= ""
-
-IMAGE_EFI_BOOT_FILES ?= "${UKI_FILENAME};EFI/Linux/${UKI_FILENAME}"
-
-do_uki[depends] += " \
-                        systemd-boot:do_deploy \
-                        virtual/kernel:do_deploy \
-                     "
-do_uki[depends] += "${@ '${INITRAMFS_IMAGE}:do_image_complete' if d.getVar('INITRAMFS_IMAGE') else ''}"
-
-# ensure that the build directory is empty everytime we generate a newly-created uki
-do_uki[cleandirs] = "${B}"
-# influence the build directory at the start of the builds
-do_uki[dirs] = "${B}"
-
-# we want to allow specifying files in SRC_URI, such as for signing the UKI
-python () {
-    d.delVarFlag("do_fetch","noexec")
-    d.delVarFlag("do_unpack","noexec")
-}
-
-# main task
-python do_uki() {
-    import glob
-    import bb.process
-
-    # base ukify command, can be extended if needed
-    ukify_cmd = d.getVar('UKIFY_CMD')
-
-    deploy_dir_image = d.getVar('DEPLOY_DIR_IMAGE')
-
-    # architecture
-    target_arch = d.getVar('EFI_ARCH')
-    if target_arch:
-        ukify_cmd += " --efi-arch %s" % (target_arch)
-
-    # systemd stubs
-    stub = "%s/linux%s.efi.stub" % (d.getVar('DEPLOY_DIR_IMAGE'), target_arch)
-    if not os.path.exists(stub):
-        bb.fatal(f"ERROR: cannot find {stub}.")
-    ukify_cmd += " --stub %s" % (stub)
-
-    # initrd
-    initramfs_image = "%s" % (d.getVar('INITRD_ARCHIVE'))
-    ukify_cmd += " --initrd=%s" % (os.path.join(deploy_dir_image, initramfs_image))
-
-    # kernel
-    kernel_filename = d.getVar('UKI_KERNEL_FILENAME') or None
-    if kernel_filename:
-        kernel = "%s/%s" % (deploy_dir_image, kernel_filename)
-        if not os.path.exists(kernel):
-            bb.fatal(f"ERROR: cannot find %s" % (kernel))
-        ukify_cmd += " --linux=%s" % (kernel)
-        # not always needed, ukify can detect version from kernel binary
-        kernel_version = d.getVar('KERNEL_VERSION')
-        if kernel_version:
-            ukify_cmd += "--uname %s" % (kernel_version)
-    else:
-        bb.fatal("ERROR - UKI_KERNEL_FILENAME not set")
-
-    # command line
-    cmdline = d.getVar('UKI_CMDLINE')
-    if cmdline:
-        ukify_cmd += " --cmdline='%s'" % (cmdline)
-
-    # dtb
-    if d.getVar('KERNEL_DEVICETREE'):
-        for dtb in d.getVar('KERNEL_DEVICETREE').split():
-            dtb_path = "%s/%s" % (deploy_dir_image, dtb)
-            if not os.path.exists(dtb_path):
-                bb.fatal(f"ERROR: cannot find {dtb_path}.")
-            ukify_cmd += " --devicetree %s" % (dtb_path)
-
-    # custom config for ukify
-    if os.path.exists(d.getVar('UKI_CONFIG_FILE')):
-        ukify_cmd += " --config=%s" % (d.getVar('UKI_CONFIG_FILE'))
-
-    # systemd tools
-    ukify_cmd += " --tools=%s%s/lib/systemd/tools" % \
-        (d.getVar("RECIPE_SYSROOT_NATIVE"), d.getVar("prefix"))
-
-    # version
-    ukify_cmd += " --os-release=@%s%s/lib/os-release" % \
-        (d.getVar("RECIPE_SYSROOT"), d.getVar("prefix"))
-
-    # TODO: tpm2 measure for secure boot, depends on systemd-native and TPM tooling
-    # needed in systemd > 254 to fulfill ConditionSecurity=measured-uki
-    # Requires TPM device on build host, thus not supported at build time.
-    #ukify_cmd += " --measure"
-
-    # securebooot signing, also for kernel
-    key = d.getVar('UKI_SB_KEY')
-    if key:
-        ukify_cmd += " --sign-kernel --secureboot-private-key='%s'" % (key)
-    cert = d.getVar('UKI_SB_CERT')
-    if cert:
-        ukify_cmd += " --secureboot-certificate='%s'" % (cert)
-
-    # custom output UKI filename
-    output = " --output=%s/%s" % (d.getVar('DEPLOY_DIR_IMAGE'), d.getVar('UKI_FILENAME'))
-    ukify_cmd += " %s" % (output)
-
-    # Run the ukify command
-    bb.debug(2, "uki: running command: %s" % (ukify_cmd))
-    out, err = bb.process.run(ukify_cmd, shell=True)
-    bb.debug(2, "%s\n%s" % (out, err))
-}
-addtask uki after do_rootfs before do_deploy do_image_complete do_image_wic
diff --git a/meta/classes-recipe/update-alternatives.bbclass b/meta/classes-recipe/update-alternatives.bbclass
deleted file mode 100644
index 5f40dc23ea..0000000000
--- a/meta/classes-recipe/update-alternatives.bbclass
+++ /dev/null
@@ -1,319 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-# This class is used to help the alternatives system which is useful when
-# multiple sources provide the same command. You can use update-alternatives
-# command directly in your recipe, but in most cases this class simplifies
-# that job.
-#
-# To use this class a number of variables should be defined:
-#
-# List all of the alternatives needed by a package:
-# ALTERNATIVE:<pkg> = "name1 name2 name3 ..."
-#
-#   i.e. ALTERNATIVE:busybox = "sh sed test bracket"
-#
-# The pathname of the link
-# ALTERNATIVE_LINK_NAME[name] = "target"
-#
-#   This is the name of the binary once it's been installed onto the runtime.
-#   This name is global to all split packages in this recipe, and should match
-#   other recipes with the same functionality.
-#   i.e. ALTERNATIVE_LINK_NAME[bracket] = "/usr/bin/["
-#
-# NOTE: If ALTERNATIVE_LINK_NAME is not defined, it defaults to ${bindir}/name
-#
-# The default link to create for all targets
-# ALTERNATIVE_TARGET = "target"
-#
-#   This is useful in a multicall binary case
-#   i.e. ALTERNATIVE_TARGET = "/bin/busybox"
-#
-# A non-default link to create for a target
-# ALTERNATIVE_TARGET[name] = "target"
-#
-#   This is the name of the binary as it's been installed by do_install
-#   i.e. ALTERNATIVE_TARGET[sh] = "/bin/bash"
-#
-# A package specific link for a target
-# ALTERNATIVE_TARGET_<pkg>[name] = "target"
-#
-#   This is useful when a recipe provides multiple alternatives for the
-#   same item.
-#
-# NOTE: If ALTERNATIVE_TARGET is not defined, it will inherit the value
-# from ALTERNATIVE_LINK_NAME.
-#
-# NOTE: If the ALTERNATIVE_LINK_NAME and ALTERNATIVE_TARGET are the same,
-# ALTERNATIVE_TARGET will have '.{BPN}' appended to it.  If the file
-# referenced has not been renamed, it will also be renamed.  (This avoids
-# the need to rename alternative files in the do_install step, but still
-# supports it if necessary for some reason.)
-#
-# The default priority for any alternatives
-# ALTERNATIVE_PRIORITY = "priority"
-#
-#   i.e. default is ALTERNATIVE_PRIORITY = "10"
-#
-# The non-default priority for a specific target
-# ALTERNATIVE_PRIORITY[name] = "priority"
-#
-# The package priority for a specific target
-# ALTERNATIVE_PRIORITY_<pkg>[name] = "priority"
-
-ALTERNATIVE_PRIORITY = "10"
-
-# We need special processing for vardeps because it can not work on
-# modified flag values.  So we aggregate the flags into a new variable
-# and include that variable in the set.
-UPDALTVARS  = "ALTERNATIVE ALTERNATIVE_LINK_NAME ALTERNATIVE_TARGET ALTERNATIVE_PRIORITY"
-
-PACKAGE_WRITE_DEPS += "virtual/update-alternatives-native"
-
-def ua_extend_depends(d):
-    if not 'virtual/update-alternatives' in d.getVar('PROVIDES'):
-        d.appendVar('DEPENDS', ' virtual/${MLPREFIX}update-alternatives')
-
-def update_alternatives_enabled(d):
-    # Update Alternatives only works on target packages...
-    if bb.data.inherits_class('native', d) or \
-       bb.data.inherits_class('cross', d) or bb.data.inherits_class('crosssdk', d) or \
-       bb.data.inherits_class('cross-canadian', d):
-        return False
-
-    # Disable when targeting mingw32 (no target support)
-    if d.getVar("TARGET_OS") == "mingw32":
-        return False
-
-    return True
-
-python __anonymous() {
-    if not update_alternatives_enabled(d):
-        return
-
-    # extend the depends to include virtual/update-alternatives
-    ua_extend_depends(d)
-}
-
-def gen_updatealternativesvars(d):
-    ret = []
-    pkgs = (d.getVar("PACKAGES") or "").split()
-    vars = (d.getVar("UPDALTVARS") or "").split()
-
-    # First compute them for non_pkg versions
-    for v in vars:
-        for flag in sorted((d.getVarFlags(v) or {}).keys()):
-            if flag == "doc" or flag == "vardeps" or flag == "vardepsexp":
-                continue
-            ret.append(v + "[" + flag + "]")
-
-    for p in pkgs:
-        for v in vars:
-            for flag in sorted((d.getVarFlags("%s:%s" % (v,p)) or {}).keys()):
-                if flag == "doc" or flag == "vardeps" or flag == "vardepsexp":
-                    continue
-                ret.append('%s:%s' % (v,p) + "[" + flag + "]")
-
-    return " ".join(ret)
-
-# Now the new stuff, we use a custom function to generate the right values
-populate_packages[vardeps] += "${UPDALTVARS} ${@gen_updatealternativesvars(d)}"
-
-# We need to do the rename after the image creation step, but before
-# the split and strip steps..  PACKAGE_PREPROCESS_FUNCS is the right
-# place for that.
-PACKAGE_PREPROCESS_FUNCS += "apply_update_alternative_renames"
-python apply_update_alternative_renames () {
-    if not update_alternatives_enabled(d):
-       return
-
-    import re
-
-    def update_files(alt_target, alt_target_rename, pkg, d):
-        f = d.getVar('FILES:' + pkg)
-        if f:
-            f = re.sub(r'(^|\s)%s(\s|$)' % re.escape (alt_target), r'\1%s\2' % alt_target_rename, f)
-            d.setVar('FILES:' + pkg, f)
-
-    # Check for deprecated usage...
-    pn = d.getVar('BPN')
-    if d.getVar('ALTERNATIVE_LINKS') != None:
-        bb.fatal('%s: Use of ALTERNATIVE_LINKS/ALTERNATIVE_PATH/ALTERNATIVE_NAME is no longer supported, please convert to the updated syntax, see update-alternatives.bbclass for more info.' % pn)
-
-    # Do actual update alternatives processing
-    pkgdest = d.getVar('PKGD')
-    for pkg in (d.getVar('PACKAGES') or "").split():
-        # If the src == dest, we know we need to rename the dest by appending ${BPN}
-        link_rename = []
-        for alt_name in (d.getVar('ALTERNATIVE:%s' % pkg) or "").split():
-            alt_link     = d.getVarFlag('ALTERNATIVE_LINK_NAME', alt_name)
-            if not alt_link:
-                alt_link = "%s/%s" % (d.getVar('bindir'), alt_name)
-                d.setVarFlag('ALTERNATIVE_LINK_NAME', alt_name, alt_link)
-            if alt_link.startswith(os.path.join(d.getVar('sysconfdir'), 'init.d')):
-                # Managing init scripts does not work (bug #10433), foremost
-                # because of a race with update-rc.d
-                bb.fatal("Using update-alternatives for managing SysV init scripts is not supported")
-
-            alt_target   = d.getVarFlag('ALTERNATIVE_TARGET_%s' % pkg, alt_name) or d.getVarFlag('ALTERNATIVE_TARGET', alt_name)
-            alt_target   = alt_target or d.getVar('ALTERNATIVE_TARGET_%s' % pkg) or d.getVar('ALTERNATIVE_TARGET') or alt_link
-            # Sometimes alt_target is specified as relative to the link name.
-            alt_target   = os.path.join(os.path.dirname(alt_link), alt_target)
-
-            # If the link and target are the same name, we need to rename the target.
-            if alt_link == alt_target:
-                src = '%s/%s' % (pkgdest, alt_target)
-                alt_target_rename = '%s.%s' % (alt_target, pn)
-                dest = '%s/%s' % (pkgdest, alt_target_rename)
-                if os.path.lexists(dest):
-                    bb.note('%s: Already renamed: %s' % (pn, alt_target_rename))
-                elif os.path.lexists(src):
-                    if os.path.islink(src):
-                        # Delay rename of links
-                        link_rename.append((alt_target, alt_target_rename))
-                    else:
-                        bb.note('%s: Rename %s -> %s' % (pn, alt_target, alt_target_rename))
-                        bb.utils.rename(src, dest)
-                        update_files(alt_target, alt_target_rename, pkg, d)
-                else:
-                    bb.warn("%s: alternative target (%s or %s) does not exist, skipping..." % (pn, alt_target, alt_target_rename))
-                    continue
-                d.setVarFlag('ALTERNATIVE_TARGET_%s' % pkg, alt_name, alt_target_rename)
-
-        # Process delayed link names
-        # Do these after other renames so we can correct broken links
-        for (alt_target, alt_target_rename) in link_rename:
-            src = '%s/%s' % (pkgdest, alt_target)
-            dest = '%s/%s' % (pkgdest, alt_target_rename)
-            link_target = oe.path.realpath(src, pkgdest, True)
-
-            if os.path.lexists(link_target):
-                # Ok, the link_target exists, we can rename
-                bb.note('%s: Rename (link) %s -> %s' % (pn, alt_target, alt_target_rename))
-                bb.utils.rename(src, dest)
-            else:
-                # Try to resolve the broken link to link.${BPN}
-                link_maybe = '%s.%s' % (os.readlink(src), pn)
-                if os.path.lexists(os.path.join(os.path.dirname(src), link_maybe)):
-                    # Ok, the renamed link target exists.. create a new link, and remove the original
-                    bb.note('%s: Creating new link %s -> %s' % (pn, alt_target_rename, link_maybe))
-                    os.symlink(link_maybe, dest)
-                    os.unlink(src)
-                else:
-                    bb.warn('%s: Unable to resolve dangling symlink: %s' % (pn, alt_target))
-                    continue
-            update_files(alt_target, alt_target_rename, pkg, d)
-}
-
-def update_alternatives_alt_targets(d, pkg):
-    """
-    Returns the update-alternatives metadata for a package.
-
-    The returned format is a list of tuples where the tuple contains:
-    alt_name:     The binary name
-    alt_link:     The path for the binary (Shared by different packages)
-    alt_target:   The path for the renamed binary (Unique per package)
-    alt_priority: The priority of the alt_target
-
-    All the alt_targets will be installed into the sysroot. The alt_link is
-    a symlink pointing to the alt_target with the highest priority.
-    """
-
-    pn = d.getVar('BPN')
-    pkgdest = d.getVar('PKGD')
-    updates = list()
-    for alt_name in (d.getVar('ALTERNATIVE:%s' % pkg) or "").split():
-        alt_link     = d.getVarFlag('ALTERNATIVE_LINK_NAME', alt_name)
-        alt_target   = d.getVarFlag('ALTERNATIVE_TARGET_%s' % pkg, alt_name) or \
-                       d.getVarFlag('ALTERNATIVE_TARGET', alt_name) or \
-                       d.getVar('ALTERNATIVE_TARGET_%s' % pkg) or \
-                       d.getVar('ALTERNATIVE_TARGET') or \
-                       alt_link
-        alt_priority = d.getVarFlag('ALTERNATIVE_PRIORITY_%s' % pkg,  alt_name) or \
-                       d.getVarFlag('ALTERNATIVE_PRIORITY',  alt_name) or \
-                       d.getVar('ALTERNATIVE_PRIORITY_%s' % pkg) or  \
-                       d.getVar('ALTERNATIVE_PRIORITY')
-
-        # This shouldn't trigger, as it should have been resolved earlier!
-        if alt_link == alt_target:
-            bb.note('alt_link == alt_target: %s == %s -- correcting, this should not happen!' % (alt_link, alt_target))
-            alt_target = '%s.%s' % (alt_target, pn)
-
-        if not os.path.lexists('%s/%s' % (pkgdest, alt_target)):
-            bb.warn('%s: NOT adding alternative provide %s: %s does not exist' % (pn, alt_link, alt_target))
-            continue
-
-        alt_target = os.path.normpath(alt_target)
-        updates.append( (alt_name, alt_link, alt_target, alt_priority) )
-
-    return updates
-
-PACKAGESPLITFUNCS =+ "populate_packages_updatealternatives"
-
-python populate_packages_updatealternatives () {
-    if not update_alternatives_enabled(d):
-        return
-
-    # Do actual update alternatives processing
-    for pkg in (d.getVar('PACKAGES') or "").split():
-        # Create post install/removal scripts
-        alt_setup_links = ""
-        alt_remove_links = ""
-        updates = update_alternatives_alt_targets(d, pkg)
-        for alt_name, alt_link, alt_target, alt_priority in updates:
-            alt_setup_links  += '\tupdate-alternatives --install %s %s %s %s\n' % (alt_link, alt_name, alt_target, alt_priority)
-            alt_remove_links += '\tupdate-alternatives --remove  %s %s\n' % (alt_name, alt_target)
-
-        if alt_setup_links:
-            # RDEPENDS setup
-            provider = d.getVar('VIRTUAL-RUNTIME_update-alternatives')
-            if provider:
-                #bb.note('adding runtime requirement for update-alternatives for %s' % pkg)
-                d.appendVar('RDEPENDS:%s' % pkg, ' ' + d.getVar('MLPREFIX', False) + provider)
-
-            bb.note('adding update-alternatives calls to postinst/prerm for %s' % pkg)
-            bb.note('%s' % alt_setup_links)
-            postinst = d.getVar('pkg_postinst:%s' % pkg)
-            if postinst:
-                postinst = alt_setup_links + postinst
-            else:
-                postinst = '#!/bin/sh\n' + alt_setup_links
-            d.setVar('pkg_postinst:%s' % pkg, postinst)
-
-            bb.note('%s' % alt_remove_links)
-            prerm = d.getVar('pkg_prerm:%s' % pkg) or '#!/bin/sh\n'
-            prerm += alt_remove_links
-            d.setVar('pkg_prerm:%s' % pkg, prerm)
-}
-
-python package_do_filedeps:append () {
-    if update_alternatives_enabled(d):
-        apply_update_alternative_provides(d)
-}
-
-def apply_update_alternative_provides(d):
-    pn = d.getVar('BPN')
-    pkgdest = d.getVar('PKGDEST')
-
-    for pkg in d.getVar('PACKAGES').split():
-        for alt_name in (d.getVar('ALTERNATIVE:%s' % pkg) or "").split():
-            alt_link     = d.getVarFlag('ALTERNATIVE_LINK_NAME', alt_name)
-            alt_target   = d.getVarFlag('ALTERNATIVE_TARGET_%s' % pkg, alt_name) or d.getVarFlag('ALTERNATIVE_TARGET', alt_name)
-            alt_target   = alt_target or d.getVar('ALTERNATIVE_TARGET_%s' % pkg) or d.getVar('ALTERNATIVE_TARGET') or alt_link
-
-            if alt_link == alt_target:
-                bb.warn('%s: alt_link == alt_target: %s == %s' % (pn, alt_link, alt_target))
-                alt_target = '%s.%s' % (alt_target, pn)
-
-            if not os.path.lexists('%s/%s/%s' % (pkgdest, pkg, alt_target)):
-                continue
-
-            # Add file provide
-            trans_target = oe.package.file_translate(alt_target)
-            d.appendVar('FILERPROVIDES:%s:%s' % (trans_target, pkg), " " + alt_link)
-            if not trans_target in (d.getVar('FILERPROVIDESFLIST:%s' % pkg) or ""):
-                d.appendVar('FILERPROVIDESFLIST:%s' % pkg, " " + trans_target)
-
diff --git a/meta/classes-recipe/update-rc.d.bbclass b/meta/classes-recipe/update-rc.d.bbclass
deleted file mode 100644
index a19e704741..0000000000
--- a/meta/classes-recipe/update-rc.d.bbclass
+++ /dev/null
@@ -1,129 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-UPDATERCPN ?= "${PN}"
-
-DEPENDS:append:class-target = "${@bb.utils.contains('DISTRO_FEATURES', 'sysvinit', ' update-rc.d initscripts', '', d)}"
-
-UPDATERCD = "update-rc.d"
-UPDATERCD:class-cross = ""
-UPDATERCD:class-native = ""
-UPDATERCD:class-nativesdk = ""
-
-INITSCRIPT_PARAMS ?= "defaults"
-
-INIT_D_DIR = "${sysconfdir}/init.d"
-
-def use_updatercd(d):
-    # If the distro supports both sysvinit and systemd, and the current recipe
-    # supports systemd, only call update-rc.d on rootfs creation or if systemd
-    # is not running. That's because systemctl enable/disable will already call
-    # update-rc.d if it detects initscripts.
-    if bb.utils.contains('DISTRO_FEATURES', 'systemd', True, False, d) and bb.data.inherits_class('systemd', d):
-        return '[ -n "$D" -o ! -d /run/systemd/system ]'
-    return 'true'
-
-PACKAGE_WRITE_DEPS += "update-rc.d-native"
-
-updatercd_postinst() {
-if ${@use_updatercd(d)} && type update-rc.d >/dev/null 2>/dev/null; then
-        if [ -n "$D" ]; then
-                OPT="-r $D"
-        else
-                OPT="-s"
-        fi
-        update-rc.d $OPT ${INITSCRIPT_NAME} ${INITSCRIPT_PARAMS}
-fi
-}
-
-updatercd_prerm() {
-if ${@use_updatercd(d)} && [ -z "$D" -a -x "${INIT_D_DIR}/${INITSCRIPT_NAME}" ]; then
-        ${INIT_D_DIR}/${INITSCRIPT_NAME} stop || :
-fi
-}
-
-updatercd_postrm() {
-if ${@use_updatercd(d)} && type update-rc.d >/dev/null 2>/dev/null; then
-        if [ -n "$D" ]; then
-                OPT="-f -r $D"
-        else
-                OPT="-f"
-        fi
-        update-rc.d $OPT ${INITSCRIPT_NAME} remove
-fi
-}
-
-
-def update_rc_after_parse(d):
-    if d.getVar('INITSCRIPT_PACKAGES', False) == None:
-        if d.getVar('INITSCRIPT_NAME', False) == None:
-            bb.fatal("%s inherits update-rc.d but doesn't set INITSCRIPT_NAME" % d.getVar('FILE', False))
-        if d.getVar('INITSCRIPT_PARAMS', False) == None:
-            bb.fatal("%s inherits update-rc.d but doesn't set INITSCRIPT_PARAMS" % d.getVar('FILE', False))
-
-python __anonymous() {
-    update_rc_after_parse(d)
-}
-
-PACKAGESPLITFUNCS =+ "${@bb.utils.contains('DISTRO_FEATURES', 'sysvinit', 'populate_packages_updatercd', '', d)}"
-PACKAGESPLITFUNCS:remove:class-nativesdk = "populate_packages_updatercd"
-
-populate_packages_updatercd[vardeps] += "updatercd_prerm updatercd_postrm updatercd_postinst"
-populate_packages_updatercd[vardepsexclude] += "OVERRIDES"
-
-python populate_packages_updatercd () {
-    def update_rcd_auto_depend(pkg):
-        import subprocess
-        import os
-        path = d.expand("${D}${INIT_D_DIR}/${INITSCRIPT_NAME}")
-        if not os.path.exists(path):
-            return
-        statement = "grep -q -w '/etc/init.d/functions' %s" % path
-        if subprocess.call(statement, shell=True) == 0:
-            mlprefix = d.getVar('MLPREFIX') or ""
-            d.appendVar('RDEPENDS:' + pkg, ' %sinitd-functions' % (mlprefix))
-
-    def update_rcd_package(pkg):
-        bb.debug(1, 'adding update-rc.d calls to postinst/prerm/postrm for %s' % pkg)
-
-        localdata = bb.data.createCopy(d)
-        overrides = localdata.getVar("OVERRIDES")
-        localdata.setVar("OVERRIDES", "%s:%s" % (pkg, overrides))
-
-        update_rcd_auto_depend(pkg)
-
-        postinst = d.getVar('pkg_postinst:%s' % pkg)
-        if not postinst:
-            postinst = '#!/bin/sh\n'
-        postinst += localdata.getVar('updatercd_postinst')
-        d.setVar('pkg_postinst:%s' % pkg, postinst)
-
-        prerm = d.getVar('pkg_prerm:%s' % pkg)
-        if not prerm:
-            prerm = '#!/bin/sh\n'
-        prerm += localdata.getVar('updatercd_prerm')
-        d.setVar('pkg_prerm:%s' % pkg, prerm)
-
-        postrm = d.getVar('pkg_postrm:%s' % pkg)
-        if not postrm:
-                postrm = '#!/bin/sh\n'
-        postrm += localdata.getVar('updatercd_postrm')
-        d.setVar('pkg_postrm:%s' % pkg, postrm)
-
-        d.appendVar('RRECOMMENDS:' + pkg, " ${MLPREFIX}${UPDATERCD}")
-
-    # Check that this class isn't being inhibited (generally, by
-    # systemd.bbclass) before doing any work.
-    if not d.getVar("INHIBIT_UPDATERCD_BBCLASS"):
-        pkgs = d.getVar('INITSCRIPT_PACKAGES')
-        if pkgs == None:
-            pkgs = d.getVar('UPDATERCPN')
-            packages = (d.getVar('PACKAGES') or "").split()
-            if not pkgs in packages and packages != []:
-                pkgs = packages[0]
-        for pkg in pkgs.split():
-            update_rcd_package(pkg)
-}
diff --git a/meta/classes-recipe/upstream-version-is-even.bbclass b/meta/classes-recipe/upstream-version-is-even.bbclass
deleted file mode 100644
index 19587cb12c..0000000000
--- a/meta/classes-recipe/upstream-version-is-even.bbclass
+++ /dev/null
@@ -1,11 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-# This class ensures that the upstream version check only
-# accepts even minor versions (i.e. 3.0.x, 3.2.x, 3.4.x, etc.)
-# This scheme is used by Gnome and a number of other projects
-# to signify stable releases vs development releases.
-UPSTREAM_CHECK_REGEX = "[^\d\.](?P<pver>\d+\.(\d*[02468])+(\.\d+)+)\.tar"
diff --git a/meta/classes-recipe/vala.bbclass b/meta/classes-recipe/vala.bbclass
deleted file mode 100644
index 460ddb36f0..0000000000
--- a/meta/classes-recipe/vala.bbclass
+++ /dev/null
@@ -1,30 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-# Everyone needs vala-native and targets need vala, too,
-# because that is where target builds look for .vapi files.
-#
-VALADEPENDS = ""
-VALADEPENDS:class-target = "vala"
-DEPENDS:append = " vala-native ${VALADEPENDS}"
-
-# Our patched version of Vala looks in STAGING_DATADIR for .vapi files
-export STAGING_DATADIR
-# Upstream Vala >= 0.11 looks in XDG_DATA_DIRS for .vapi files
-export XDG_DATA_DIRS = "${STAGING_DATADIR}:${STAGING_LIBDIR}"
-
-# Package additional files
-FILES:${PN}-dev += "\
-    ${datadir}/vala/vapi/*.vapi \
-    ${datadir}/vala/vapi/*.deps \
-    ${datadir}/gir-1.0 \
-"
-
-# Remove vapigen.m4 that is bundled with tarballs
-# because it does not yet have our cross-compile fixes
-do_configure:prepend() {
-        rm -f ${S}/m4/vapigen.m4
-}
diff --git a/meta/classes-recipe/waf.bbclass b/meta/classes-recipe/waf.bbclass
deleted file mode 100644
index 01707c8e2c..0000000000
--- a/meta/classes-recipe/waf.bbclass
+++ /dev/null
@@ -1,94 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-# avoids build breaks when using no-static-libs.inc
-DISABLE_STATIC = ""
-
-# What Python interpretter to use.  Defaults to Python 3 but can be
-# overridden if required.
-WAF_PYTHON ?= "python3"
-
-B = "${WORKDIR}/build"
-do_configure[cleandirs] += "${B}"
-
-EXTRA_OECONF:append = " ${PACKAGECONFIG_CONFARGS}"
-
-EXTRA_OEWAF_BUILD ??= ""
-# In most cases, you want to pass the same arguments to `waf build` and `waf
-# install`, but you can override it if necessary
-EXTRA_OEWAF_INSTALL ??= "${EXTRA_OEWAF_BUILD}"
-
-def waflock_hash(d):
-    # Calculates the hash used for the waf lock file. This should include
-    # all of the user controllable inputs passed to waf configure. Note
-    # that the full paths for ${B} and ${S} are used; this is OK and desired
-    # because a change to either of these should create a unique lock file
-    # to prevent collisions.
-    import hashlib
-    h = hashlib.sha512()
-    def update(name):
-        val = d.getVar(name)
-        if val is not None:
-            h.update(val.encode('utf-8'))
-    update('S')
-    update('B')
-    update('prefix')
-    update('EXTRA_OECONF')
-    return h.hexdigest()
-
-# Use WAFLOCK to specify a separate lock file. The build is already
-# sufficiently isolated by setting the output directory, this ensures that
-# bitbake won't step on toes of any other configured context in the source
-# directory (e.g. if the source is coming from externalsrc and was previously
-# configured elsewhere).
-export WAFLOCK = ".lock-waf_oe_${@waflock_hash(d)}_build"
-BB_BASEHASH_IGNORE_VARS += "WAFLOCK"
-
-python waf_preconfigure() {
-    import subprocess
-    subsrcdir = d.getVar('S')
-    python = d.getVar('WAF_PYTHON')
-    wafbin = os.path.join(subsrcdir, 'waf')
-    try:
-        result = subprocess.check_output([python, wafbin, '--version'], cwd=subsrcdir, stderr=subprocess.STDOUT)
-        # Output looks like:
-        #  # output from lower modules (e.g. warnings, ...)
-        #  waf X.Y.Z ...
-        # So, look for the line starting with "waf "
-        version = None
-        for line in result.decode('utf-8').split("\n"):
-            if line.startswith("waf "):
-                version = line.split()[1]
-                break
-
-        if not version or not bb.utils.is_semver(version):
-            bb.warn("Unable to parse \"waf --version\" output. Assuming waf version without bindir/libdir support.")
-            bb.warn("waf·--version·output = \n%s" % result.decode('utf-8'))
-        elif bb.utils.vercmp_string_op(version, "1.8.7", ">="):
-            bb.note("waf version is high enough to add --bindir and --libdir")
-            d.setVar("WAF_EXTRA_CONF", "--bindir=${bindir} --libdir=${libdir}")
-    except subprocess.CalledProcessError as e:
-        bb.warn("Unable to execute waf --version, exit code %d. Assuming waf version without bindir/libdir support." % e.returncode)
-    except FileNotFoundError:
-        bb.fatal("waf does not exist in %s" % subsrcdir)
-}
-
-do_configure[prefuncs] += "waf_preconfigure"
-
-waf_do_configure() {
-        (cd ${S} && ${WAF_PYTHON} ./waf configure -o ${B} --prefix=${prefix} ${WAF_EXTRA_CONF} ${EXTRA_OECONF})
-}
-
-do_compile[progress] = "outof:^\[\s*(\d+)/\s*(\d+)\]\s+"
-waf_do_compile()  {
-        (cd ${S} && ${WAF_PYTHON} ./waf build ${@oe.utils.parallel_make_argument(d, '-j%d', limit=64)} ${EXTRA_OEWAF_BUILD})
-}
-
-waf_do_install() {
-        (cd ${S} && ${WAF_PYTHON} ./waf install --destdir=${D} ${EXTRA_OEWAF_INSTALL})
-}
-
-EXPORT_FUNCTIONS do_configure do_compile do_install
diff --git a/meta/classes-recipe/xmlcatalog.bbclass b/meta/classes-recipe/xmlcatalog.bbclass
deleted file mode 100644
index d3ef7ff43c..0000000000
--- a/meta/classes-recipe/xmlcatalog.bbclass
+++ /dev/null
@@ -1,36 +0,0 @@
-#
-# Copyright OpenEmbedded Contributors
-#
-# SPDX-License-Identifier: MIT
-#
-
-# Note that this recipe only handles XML catalogues in the native sysroot, and doesn't
-# yet support catalogue management in the target sysroot or on the target itself.
-# (https://bugzilla.yoctoproject.org/13271)
-
-# A whitespace-separated list of XML catalogs to be registered, for example
-# "${sysconfdir}/xml/docbook-xml.xml".
-XMLCATALOGS ?= ""
-
-DEPENDS:append = " libxml2-native"
-
-SYSROOT_PREPROCESS_FUNCS:append:class-native = " xmlcatalog_sstate_postinst"
-
-xmlcatalog_complete() {
-        ROOTCATALOG="${STAGING_ETCDIR_NATIVE}/xml/catalog"
-        if [ ! -f $ROOTCATALOG ]; then
-                mkdir --parents $(dirname $ROOTCATALOG)
-                xmlcatalog --noout --create $ROOTCATALOG
-        fi
-        for CATALOG in ${XMLCATALOGS}; do
-                xmlcatalog --noout --add nextCatalog unused file://$CATALOG $ROOTCATALOG
-        done
-}
-
-xmlcatalog_sstate_postinst() {
-        mkdir -p ${SYSROOT_DESTDIR}${bindir}
-        dest=${SYSROOT_DESTDIR}${bindir}/postinst-${PN}-xmlcatalog
-        echo '#!/bin/sh' > $dest
-        echo '${xmlcatalog_complete}' >> $dest
-        chmod 0755 $dest
-}