diff --git a/meta-openembedded/meta-oe/conf/layer.conf b/meta-openembedded/meta-oe/conf/layer.conf
index a1f5087..b17add6 100644
--- a/meta-openembedded/meta-oe/conf/layer.conf
+++ b/meta-openembedded/meta-oe/conf/layer.conf
@@ -34,6 +34,8 @@
     gnome-layer:${LAYERDIR}/dynamic-layers/gnome-layer/recipes-*/*/*.bbappend \
     perl-layer:${LAYERDIR}/dynamic-layers/perl-layer/recipes-*/*/*.bb \
     perl-layer:${LAYERDIR}/dynamic-layers/perl-layer/recipes-*/*/*.bbappend \
+    selinux:${LAYERDIR}/dynamic-layers/selinux/recipes-*/*/*.bb \
+    selinux:${LAYERDIR}/dynamic-layers/selinux/recipes-*/*/*.bbappend \
 "
 
 # This should only be incremented on significant changes that will
@@ -50,6 +52,8 @@
 PREFERRED_PROVIDER_android-tools-conf ?= "android-tools-conf"
 # Configures whether coreutils or uutils-coreutils is used.
 PREFERRED_PROVIDER_coreutils = "coreutils"
+PREFERRED_PROVIDER_virtual/opencl-icd ?= "opencl-icd-loader"
+PREFERRED_RPROVIDER_virtual/opencl-icd ?= "opencl-icd-loader"
 
 SIGGEN_EXCLUDERECIPES_ABISAFE += " \
   fbset-modes \
diff --git a/meta-openembedded/meta-oe/dynamic-layers/meta-python/recipes-connectivity/lirc/lirc/0001-Unbolt-ubuntu-hack.patch b/meta-openembedded/meta-oe/dynamic-layers/meta-python/recipes-connectivity/lirc/lirc/0001-Unbolt-ubuntu-hack.patch
new file mode 100644
index 0000000..e58a93b
--- /dev/null
+++ b/meta-openembedded/meta-oe/dynamic-layers/meta-python/recipes-connectivity/lirc/lirc/0001-Unbolt-ubuntu-hack.patch
@@ -0,0 +1,26 @@
+From ca126a2832aaff0deef3ba7eaf411dd0dc43b068 Mon Sep 17 00:00:00 2001
+From: Khem Raj <raj.khem@gmail.com>
+Date: Thu, 16 Mar 2023 11:31:14 -0700
+Subject: [PATCH] Unbolt ubuntu hack
+
+This bites during cross compiling where the target is different than
+build host and build host might be ubuntu but that does not matter in
+cross compilation case. This fails builds when usrmerge feature is used
+
+Upstream-Status: Inappropriates [ Cross-compile specific ]
+Signed-off-by: Khem Raj <raj.khem@gmail.com>
+---
+ configure.ac | 2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+--- a/configure.ac
++++ b/configure.ac
+@@ -429,7 +429,7 @@ AC_CHECK_LIB([udev], [udev_device_new_fr
+ ])
+ 
+ dnl Ubuntu's systemd pkg-config seems broken beyond repair. So:
+-kernelversion=`cat /proc/version || echo "non-linux"`
++kernelversion="cross-compiled"
+ AS_CASE([$kernelversion],
+   [*Ubuntu*],[
+     AC_MSG_NOTICE([Hardwiring Ubuntu systemd setup])
diff --git a/meta-openembedded/meta-oe/dynamic-layers/meta-python/recipes-connectivity/lirc/lirc_0.10.2.bb b/meta-openembedded/meta-oe/dynamic-layers/meta-python/recipes-connectivity/lirc/lirc_0.10.2.bb
index 458d9d7..88e3f04 100644
--- a/meta-openembedded/meta-oe/dynamic-layers/meta-python/recipes-connectivity/lirc/lirc_0.10.2.bb
+++ b/meta-openembedded/meta-oe/dynamic-layers/meta-python/recipes-connectivity/lirc/lirc_0.10.2.bb
@@ -21,6 +21,7 @@
            file://lirc_options.conf \
            file://lirc.tmpfiles \
            file://0001-Makefile.am-do-not-clobber-PYTHONPATH-from-build-env.patch \
+           file://0001-Unbolt-ubuntu-hack.patch \
            "
 SRC_URI[sha256sum] = "3d44ec8274881cf262f160805641f0827ffcc20ade0d85e7e6f3b90e0d3d222a"
 
diff --git a/meta-openembedded/meta-oe/dynamic-layers/meta-python/recipes-connectivity/netplan/netplan_0.106.bb b/meta-openembedded/meta-oe/dynamic-layers/meta-python/recipes-connectivity/netplan/netplan_0.106.bb
index b7fe7ae..8c1eaa5 100644
--- a/meta-openembedded/meta-oe/dynamic-layers/meta-python/recipes-connectivity/netplan/netplan_0.106.bb
+++ b/meta-openembedded/meta-oe/dynamic-layers/meta-python/recipes-connectivity/netplan/netplan_0.106.bb
@@ -26,7 +26,7 @@
 
 PACKAGECONFIG[tests] = ",,,python3-nose python3-coverage python3-netifaces python3-pycodestyle python3-pyflakes python3-pyyaml"
 
-RDEPENDS:${PN} = "python3 python3-core python3-netifaces python3-pyyaml util-linux-libuuid libnetplan"
+RDEPENDS:${PN} = "python3 python3-core python3-netifaces python3-pyyaml util-linux-libuuid libnetplan python3-dbus python3-rich"
 
 inherit pkgconfig systemd
 
diff --git a/meta-openembedded/meta-oe/dynamic-layers/meta-python/recipes-core/packagegroups/packagegroup-meta-oe.bbappend b/meta-openembedded/meta-oe/dynamic-layers/meta-python/recipes-core/packagegroups/packagegroup-meta-oe.bbappend
index 51197c2..c3d4cbc 100644
--- a/meta-openembedded/meta-oe/dynamic-layers/meta-python/recipes-core/packagegroups/packagegroup-meta-oe.bbappend
+++ b/meta-openembedded/meta-oe/dynamic-layers/meta-python/recipes-core/packagegroups/packagegroup-meta-oe.bbappend
@@ -3,10 +3,10 @@
     rwmem \
     mongodb \
 "
-packagegroup-meta-oe-devtools:remove:riscv64 = "mongodb"
-packagegroup-meta-oe-devtools:remove:riscv32 = "mongodb"
-packagegroup-meta-oe-devtools:remove:mipsarch = "mongodb"
-packagegroup-meta-oe-devtools:remove:powerpc = "mongodb"
+RDEPENDS:packagegroup-meta-oe-devtools:remove:riscv64 = "mongodb"
+RDEPENDS:packagegroup-meta-oe-devtools:remove:riscv32 = "mongodb"
+RDEPENDS:packagegroup-meta-oe-devtools:remove:mipsarch = "mongodb"
+RDEPENDS:packagegroup-meta-oe-devtools:remove:powerpc = "mongodb"
 
 RDEPENDS:packagegroup-meta-oe-connectivity += "\
     lirc \
diff --git a/meta-openembedded/meta-oe/dynamic-layers/meta-python/recipes-dbs/mongodb/mongodb/0001-Fix-type-mismatch-on-32bit-arches.patch b/meta-openembedded/meta-oe/dynamic-layers/meta-python/recipes-dbs/mongodb/mongodb/0001-Fix-type-mismatch-on-32bit-arches.patch
new file mode 100644
index 0000000..def1799
--- /dev/null
+++ b/meta-openembedded/meta-oe/dynamic-layers/meta-python/recipes-dbs/mongodb/mongodb/0001-Fix-type-mismatch-on-32bit-arches.patch
@@ -0,0 +1,33 @@
+From 81eabea4e4da55cddfe8bcfcbc3759fa90948254 Mon Sep 17 00:00:00 2001
+From: Khem Raj <raj.khem@gmail.com>
+Date: Fri, 3 Mar 2023 14:13:29 -0800
+Subject: [PATCH] Fix type mismatch on 32bit arches
+
+std::set::size returns an unsigned integral type.
+std::max call therefore gets (unsigned int, unsigned long) here.
+Type of both arguments is not same, so its ambigous
+and there is no matching std::max implementation for mismatching
+arguments. std::max expects both input variables to be of
+same type, max(int,int) etc..
+
+Fixes
+src/mongo/util/processinfo_linux.cpp:424:16: error: no matching function for call to 'max'
+        return std::max(socketIds.size(), 1ul);
+
+Upstream-Status: Submitted [https://jira.mongodb.org/browse/SERVER-74633]
+Signed-off-by: Khem Raj <raj.khem@gmail.com>
+---
+ src/mongo/util/processinfo_linux.cpp | 2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+--- a/src/mongo/util/processinfo_linux.cpp
++++ b/src/mongo/util/processinfo_linux.cpp
+@@ -421,7 +421,7 @@ public:
+ 
+         // On ARM64, the "physical id" field is unpopulated, causing there to be 0 sockets found. In
+         // this case, we default to 1.
+-        return std::max(socketIds.size(), 1ul);
++        return std::max(static_cast<unsigned long>(socketIds.size()), 1ul);
+     }
+ 
+     /**
diff --git a/meta-openembedded/meta-oe/dynamic-layers/meta-python/recipes-dbs/mongodb/mongodb/0001-apply-msvc-workaround-for-clang-16.patch b/meta-openembedded/meta-oe/dynamic-layers/meta-python/recipes-dbs/mongodb/mongodb/0001-apply-msvc-workaround-for-clang-16.patch
new file mode 100644
index 0000000..0962693
--- /dev/null
+++ b/meta-openembedded/meta-oe/dynamic-layers/meta-python/recipes-dbs/mongodb/mongodb/0001-apply-msvc-workaround-for-clang-16.patch
@@ -0,0 +1,32 @@
+From 03047c81b2601362bcf79cae67e06d1fba0a6101 Mon Sep 17 00:00:00 2001
+From: Khem Raj <raj.khem@gmail.com>
+Date: Thu, 2 Mar 2023 20:17:57 -0800
+Subject: [PATCH] apply msvc workaround for clang >= 16
+
+This avoids a new Werror found with clang16
+
+boost-1.70.0/boost/mpl/aux_/integral_wrapper.hpp:73:31: error: integer value -1 is outside the valid range of values [0, 3] for this enumeration type [-Wenum-constexpr-conversion]
+    typedef AUX_WRAPPER_INST( BOOST_MPL_AUX_STATIC_CAST(AUX_WRAPPER_VALUE_TYPE, (value - 1)) ) prior;
+
+Upstream-Status: Pending
+Signed-off-by: Khem Raj <raj.khem@gmail.com>
+---
+ .../boost-1.70.0/boost/mpl/aux_/integral_wrapper.hpp            | 2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+diff --git a/src/third_party/boost-1.70.0/boost/mpl/aux_/integral_wrapper.hpp b/src/third_party/boost-1.70.0/boost/mpl/aux_/integral_wrapper.hpp
+index 6bc05f7e96e..6bb8d24c9ce 100644
+--- a/src/third_party/boost-1.70.0/boost/mpl/aux_/integral_wrapper.hpp
++++ b/src/third_party/boost-1.70.0/boost/mpl/aux_/integral_wrapper.hpp
+@@ -56,7 +56,7 @@ struct AUX_WRAPPER_NAME
+ // have to #ifdef here: some compilers don't like the 'N + 1' form (MSVC),
+ // while some other don't like 'value + 1' (Borland), and some don't like
+ // either
+-#if BOOST_WORKAROUND(__EDG_VERSION__, <= 243)
++#if BOOST_WORKAROUND(__EDG_VERSION__, <= 243) || __clang_major__ > 15
+  private:
+     BOOST_STATIC_CONSTANT(AUX_WRAPPER_VALUE_TYPE, next_value = BOOST_MPL_AUX_STATIC_CAST(AUX_WRAPPER_VALUE_TYPE, (N + 1)));
+     BOOST_STATIC_CONSTANT(AUX_WRAPPER_VALUE_TYPE, prior_value = BOOST_MPL_AUX_STATIC_CAST(AUX_WRAPPER_VALUE_TYPE, (N - 1)));
+-- 
+2.39.2
+
diff --git a/meta-openembedded/meta-oe/dynamic-layers/meta-python/recipes-dbs/mongodb/mongodb_git.bb b/meta-openembedded/meta-oe/dynamic-layers/meta-python/recipes-dbs/mongodb/mongodb_git.bb
index 253187e..7b85bdd 100644
--- a/meta-openembedded/meta-oe/dynamic-layers/meta-python/recipes-dbs/mongodb/mongodb_git.bb
+++ b/meta-openembedded/meta-oe/dynamic-layers/meta-python/recipes-dbs/mongodb/mongodb_git.bb
@@ -11,9 +11,9 @@
 
 inherit scons dos2unix siteinfo python3native systemd useradd
 
-PV = "4.4.18"
+PV = "4.4.19"
 #v4.4.18
-SRCREV = "8ed32b5c2c68ebe7f8ae2ebe8d23f36037a17dea"
+SRCREV = "9a996e0ad993148b9650dc402e6d3b1804ad3b8a"
 SRC_URI = "git://github.com/mongodb/mongo.git;branch=v4.4;protocol=https \
            file://0001-Tell-scons-to-use-build-settings-from-environment-va.patch \
            file://0001-Use-long-long-instead-of-int64_t.patch \
@@ -34,6 +34,8 @@
            file://0001-server-Adjust-the-cache-alignment-assumptions.patch \
            file://0001-The-std-lib-unary-binary_function-base-classes-are-d.patch \
            file://0001-free_mon-Include-missing-cstdint.patch \
+           file://0001-apply-msvc-workaround-for-clang-16.patch \
+           file://0001-Fix-type-mismatch-on-32bit-arches.patch \
            "
 SRC_URI:append:libc-musl ="\
            file://0001-Mark-one-of-strerror_r-implementation-glibc-specific.patch \
diff --git a/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools-conf-configfs/10-adbd-configfs.conf b/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools-conf-configfs/10-adbd-configfs.conf
new file mode 100644
index 0000000..ddf155a
--- /dev/null
+++ b/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools-conf-configfs/10-adbd-configfs.conf
@@ -0,0 +1,4 @@
+[Service]
+ExecStartPre=/usr/bin/android-gadget-setup
+ExecStartPost=/usr/bin/android-gadget-start
+ExecStopPost=/usr/bin/android-gadget-cleanup
diff --git a/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools-conf-configfs/android-gadget-cleanup b/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools-conf-configfs/android-gadget-cleanup
new file mode 100644
index 0000000..517227d
--- /dev/null
+++ b/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools-conf-configfs/android-gadget-cleanup
@@ -0,0 +1,24 @@
+#!/bin/sh
+
+[ -d /sys/kernel/config/usb_gadget ] || exit 0
+
+cd /sys/kernel/config/usb_gadget
+
+cd adb
+
+echo "" > UDC || true
+
+killall adbd || true
+
+umount /dev/usb-ffs/adb
+
+rm configs/c.1/ffs.usb0
+
+rmdir configs/c.1/strings/0x409
+rmdir configs/c.1
+
+rmdir functions/ffs.usb0
+rmdir strings/0x409
+
+cd ..
+rmdir adb
diff --git a/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools-conf-configfs/android-gadget-setup b/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools-conf-configfs/android-gadget-setup
new file mode 100644
index 0000000..e44d1ba
--- /dev/null
+++ b/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools-conf-configfs/android-gadget-setup
@@ -0,0 +1,35 @@
+#!/bin/sh
+
+set -e
+
+manufacturer=RPB
+model="Android device"
+serial=0123456789ABCDEF
+
+if [ -r /etc/android-gadget-setup.machine ] ; then
+	. /etc/android-gadget-setup.machine
+fi
+
+[ -d /sys/kernel/config/usb_gadget ] || modprobe libcomposite
+
+cd /sys/kernel/config/usb_gadget
+
+[ -d adb ] && /usr/bin/android-gadget-cleanup || true
+
+mkdir adb
+cd adb
+
+mkdir configs/c.1
+mkdir functions/ffs.usb0
+mkdir strings/0x409
+mkdir configs/c.1/strings/0x409
+echo 0x18d1 > idVendor
+echo 0xd002 > idProduct
+echo "$serial" > strings/0x409/serialnumber
+echo "$manufacturer" > strings/0x409/manufacturer
+echo "$model" > strings/0x409/product
+echo "Conf 1" > configs/c.1/strings/0x409/configuration
+ln -s functions/ffs.usb0 configs/c.1
+
+mkdir -p /dev/usb-ffs/adb
+mount -t functionfs usb0 /dev/usb-ffs/adb
diff --git a/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools-conf-configfs/android-gadget-start b/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools-conf-configfs/android-gadget-start
new file mode 100644
index 0000000..ca6c3df
--- /dev/null
+++ b/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools-conf-configfs/android-gadget-start
@@ -0,0 +1,7 @@
+#!/bin/sh
+
+set -e
+
+sleep 3
+
+ls /sys/class/udc/ > /sys/kernel/config/usb_gadget/adb/UDC
diff --git a/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools-conf-configfs_1.0.bb b/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools-conf-configfs_1.0.bb
new file mode 100644
index 0000000..1c26c72
--- /dev/null
+++ b/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools-conf-configfs_1.0.bb
@@ -0,0 +1,35 @@
+DESCRIPTION = "Various utilities from Android - corresponding configuration files for using ConfigFS"
+SECTION = "console/utils"
+LICENSE = "MIT"
+LIC_FILES_CHKSUM = "file://${COMMON_LICENSE_DIR}/MIT;md5=0835ade698e0bcf8506ecda2f7b4f302"
+
+SRC_URI = " \
+    file://android-gadget-setup \
+    file://android-gadget-start \
+    file://android-gadget-cleanup \
+    file://10-adbd-configfs.conf \
+"
+
+PACKAGE_ARCH = "${MACHINE_ARCH}"
+
+do_install() {
+    install -d ${D}${bindir}
+    install -m 0755 ${WORKDIR}/android-gadget-setup ${D}${bindir}
+    install -m 0755 ${WORKDIR}/android-gadget-start ${D}${bindir}
+    install -m 0755 ${WORKDIR}/android-gadget-cleanup ${D}${bindir}
+
+    if [ -r ${WORKDIR}/android-gadget-setup.machine ] ; then
+	install -d ${D}${sysconfdir}
+	install -m 0644 ${WORKDIR}/android-gadget-setup.machine ${D}${sysconfdir}
+    fi
+
+    install -d ${D}${systemd_unitdir}/system/android-tools-adbd.service.d
+    install -m 0644 ${WORKDIR}/10-adbd-configfs.conf ${D}${systemd_unitdir}/system/android-tools-adbd.service.d
+}
+
+FILES:${PN} += " \
+    ${systemd_unitdir}/system/ \
+"
+
+PROVIDES += "android-tools-conf"
+RPROVIDES:${PN} = "android-tools-conf"
diff --git a/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools-conf/android-gadget-setup b/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools-conf/android-gadget-setup
new file mode 100644
index 0000000..26cf30e
--- /dev/null
+++ b/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools-conf/android-gadget-setup
@@ -0,0 +1,37 @@
+#!/bin/sh
+
+[ ! -e /dev/pts ] && mkdir -p /dev/pts
+[ ! -e /dev/pts/0 ] && mount devpts /dev/pts -t devpts
+
+# TODO enable the lines below once we have support for getprop
+# retrieve the product info from Android
+# manufacturer=$(getprop ro.product.manufacturer Android)
+# model=$(getprop ro.product.model Android)
+# serial=$(getprop ro.serialno 0123456789ABCDEF)
+
+#below are now needed in order to use FunctionFS for ADB, tested to work with 3.4+ kernels
+if grep -q functionfs /proc/filesystems; then
+    mkdir -p /dev/usb-ffs/adb
+    mount -t functionfs adb /dev/usb-ffs/adb
+    #android-gadget-setup doesn't provide below 2 and without them it won't work, so we provide them here.
+    echo adb > /sys/class/android_usb/android0/f_ffs/aliases
+    echo ffs > /sys/class/android_usb/android0/functions
+fi
+
+manufacturer="$(cat /system/build.prop | grep -o 'ro.product.manufacturer=.*' | cut -d'=' -f 2)"
+model="$(cat /system/build.prop | grep -o 'ro.product.model=.*' | cut -d'=' -f 2)"
+# get the device serial number from /proc/cmdline directly(since we have no getprop on
+# GNU/Linux)
+serial="$(cat /proc/cmdline | sed 's/.*androidboot.serialno=//' | sed 's/ .*//')"
+
+echo $serial > /sys/class/android_usb/android0/iSerial
+echo $manufacturer > /sys/class/android_usb/android0/iManufacturer
+echo $model > /sys/class/android_usb/android0/iProduct
+
+echo "0" > /sys/class/android_usb/android0/enable
+echo "18d1" > /sys/class/android_usb/android0/idVendor
+echo "D002" > /sys/class/android_usb/android0/idProduct
+echo "adb" > /sys/class/android_usb/android0/functions
+echo "1" >  /sys/class/android_usb/android0/enable
+
+sleep 4
diff --git a/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools-conf_1.0.bb b/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools-conf_1.0.bb
new file mode 100644
index 0000000..b63ccbb
--- /dev/null
+++ b/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools-conf_1.0.bb
@@ -0,0 +1,18 @@
+DESCRIPTION = "Different utilities from Android - corresponding configuration files"
+SECTION = "console/utils"
+LICENSE = "MIT"
+LIC_FILES_CHKSUM = "file://${COMMON_LICENSE_DIR}/MIT;md5=0835ade698e0bcf8506ecda2f7b4f302"
+
+SRC_URI = "file://android-gadget-setup"
+
+do_install() {
+    install -d ${D}${bindir}
+    install -m 0755 ${WORKDIR}/android-gadget-setup ${D}${bindir}
+}
+
+python () {
+    pn = d.getVar('PN')
+    profprov = d.getVar("PREFERRED_PROVIDER_" + pn)
+    if profprov and pn != profprov:
+        raise bb.parse.SkipRecipe("PREFERRED_PROVIDER_%s set to %s, not %s" % (pn, profprov, pn))
+}
diff --git a/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/0001-Fixes-for-yocto-build.patch b/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/0001-Fixes-for-yocto-build.patch
new file mode 100644
index 0000000..dcf27d8
--- /dev/null
+++ b/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/0001-Fixes-for-yocto-build.patch
@@ -0,0 +1,162 @@
+From 5de85f8273c7284aa93e35c40f025d4d43d42df9 Mon Sep 17 00:00:00 2001
+From: Etienne Cordonnier <ecordonnier@snap.com>
+Date: Thu, 16 Mar 2023 18:59:35 +0100
+Subject: [PATCH] Fixes for yocto build
+
+Signed-off-by: JJ Robertson <jrobertson@snapchat.com>
+[rebased on version 29]
+Signed-off-by: Etienne Cordonnier <ecordonnier@snap.com>
+
+---
+ system/core/adb/daemon/file_sync_service.cpp | 4 ++--
+ system/core/adb/daemon/framebuffer_service.h | 2 --
+ system/core/adb/daemon/main.cpp              | 5 +++--
+ system/core/adb/daemon/restart_service.h     | 2 --
+ system/core/adb/daemon/services.cpp          | 6 ++----
+ system/core/adb/daemon/shell_service.cpp     | 5 ++++-
+ system/core/adb/types.h                      | 1 +
+ 7 files changed, 12 insertions(+), 13 deletions(-)
+
+diff --git a/system/core/adb/daemon/file_sync_service.cpp b/system/core/adb/daemon/file_sync_service.cpp
+index d6af7087..92e7087a 100644
+--- a/system/core/adb/daemon/file_sync_service.cpp
++++ b/system/core/adb/daemon/file_sync_service.cpp
+@@ -111,7 +111,7 @@ static bool secure_mkdirs(const std::string& path) {
+         partial_path += path_component;
+ 
+         if (should_use_fs_config(partial_path)) {
+-            fs_config(partial_path.c_str(), 1, nullptr, &uid, &gid, &mode, &capabilities);
++            // fs_config(partial_path.c_str(), 1, nullptr, &uid, &gid, &mode, &capabilities);
+         }
+         if (adb_mkdir(partial_path.c_str(), mode) == -1) {
+             if (errno != EEXIST) {
+@@ -469,7 +469,7 @@ static bool do_send(int s, const std::string& spec, std::vector<char>& buffer) {
+         uint64_t capabilities = 0;
+         if (should_use_fs_config(path)) {
+             unsigned int broken_api_hack = mode;
+-            fs_config(path.c_str(), 0, nullptr, &uid, &gid, &broken_api_hack, &capabilities);
++            // fs_config(path.c_str(), 0, nullptr, &uid, &gid, &broken_api_hack, &capabilities);
+             mode = broken_api_hack;
+         }
+ 
+diff --git a/system/core/adb/daemon/framebuffer_service.h b/system/core/adb/daemon/framebuffer_service.h
+index bab44be3..264da597 100644
+--- a/system/core/adb/daemon/framebuffer_service.h
++++ b/system/core/adb/daemon/framebuffer_service.h
+@@ -18,6 +18,4 @@
+ 
+ #include "adb_unique_fd.h"
+ 
+-#if defined(__ANDROID__)
+ void framebuffer_service(unique_fd fd);
+-#endif
+diff --git a/system/core/adb/daemon/main.cpp b/system/core/adb/daemon/main.cpp
+index 3322574c..e807d13d 100644
+--- a/system/core/adb/daemon/main.cpp
++++ b/system/core/adb/daemon/main.cpp
+@@ -208,6 +208,9 @@ int adbd_main(int server_port) {
+     umask(0);
+ 
+     signal(SIGPIPE, SIG_IGN);
++    signal(SIGINT, SIG_DFL);
++    signal(SIGQUIT, SIG_DFL);
++
+ 
+ #if defined(__BIONIC__)
+     auto fdsan_level = android_fdsan_get_error_level();
+@@ -254,13 +257,11 @@ int adbd_main(int server_port) {
+ 
+     bool is_usb = false;
+ 
+-#if defined(__ANDROID__)
+     if (access(USB_FFS_ADB_EP0, F_OK) == 0) {
+         // Listen on USB.
+         usb_init();
+         is_usb = true;
+     }
+-#endif
+ 
+     // If one of these properties is set, also listen on that port.
+     // If one of the properties isn't set and we couldn't listen on usb, listen
+diff --git a/system/core/adb/daemon/restart_service.h b/system/core/adb/daemon/restart_service.h
+index 19840bd5..7a97614b 100644
+--- a/system/core/adb/daemon/restart_service.h
++++ b/system/core/adb/daemon/restart_service.h
+@@ -18,9 +18,7 @@
+ 
+ #include "adb_unique_fd.h"
+ 
+-#if defined(__ANDROID__)
+ void restart_root_service(unique_fd fd);
+ void restart_unroot_service(unique_fd fd);
+ void restart_tcp_service(unique_fd fd, int port);
+ void restart_usb_service(unique_fd fd);
+-#endif
+diff --git a/system/core/adb/daemon/services.cpp b/system/core/adb/daemon/services.cpp
+index 4ec90d27..d8541c23 100644
+--- a/system/core/adb/daemon/services.cpp
++++ b/system/core/adb/daemon/services.cpp
+@@ -156,7 +156,7 @@ static void spin_service(unique_fd fd) {
+     }
+ #endif
+     // Fall through
+-    std::string cmd = "/system/bin/reboot ";
++    std::string cmd = "/sbin/reboot ";
+     cmd += name;
+     return StartSubprocess(cmd, nullptr, SubprocessType::kRaw, SubprocessProtocol::kNone);
+ }
+@@ -265,11 +265,10 @@ unique_fd daemon_service_to_fd(std::string_view name, atransport* transport) {
+     }
+ #endif
+ 
+-#if defined(__ANDROID__)
+     if (name.starts_with("framebuffer:")) {
+         return create_service_thread("fb", framebuffer_service);
+     } else if (android::base::ConsumePrefix(&name, "remount:")) {
+-        std::string cmd = "/system/bin/remount ";
++        std::string cmd = "/sbin/remount ";
+         cmd += name;
+         return StartSubprocess(cmd, nullptr, SubprocessType::kRaw, SubprocessProtocol::kNone);
+     } else if (android::base::ConsumePrefix(&name, "reboot:")) {
+@@ -303,7 +302,6 @@ unique_fd daemon_service_to_fd(std::string_view name, atransport* transport) {
+     } else if (name.starts_with("usb:")) {
+         return create_service_thread("usb", restart_usb_service);
+     }
+-#endif
+ 
+     if (android::base::ConsumePrefix(&name, "dev:")) {
+         return unique_fd{unix_open(name, O_RDWR | O_CLOEXEC)};
+diff --git a/system/core/adb/daemon/shell_service.cpp b/system/core/adb/daemon/shell_service.cpp
+index f62032d0..ebcfe18d 100644
+--- a/system/core/adb/daemon/shell_service.cpp
++++ b/system/core/adb/daemon/shell_service.cpp
+@@ -273,13 +273,16 @@ bool Subprocess::ForkAndExec(std::string* error) {
+         env["HOSTNAME"] = GetHostName();
+         env["LOGNAME"] = pw->pw_name;
+         env["SHELL"] = pw->pw_shell;
+-        env["TMPDIR"] = "/data/local/tmp";
+         env["USER"] = pw->pw_name;
+     }
+ 
+     if (!terminal_type_.empty()) {
+         env["TERM"] = terminal_type_;
+     }
++    if (env.find("PS1") == env.end()) {
++        env["PS1"] = "\\h:\\w\\$ ";
++    }
++
+ 
+     std::vector<std::string> joined_env;
+     for (const auto& it : env) {
+diff --git a/system/core/adb/types.h b/system/core/adb/types.h
+index c619fffc..f8e0f521 100644
+--- a/system/core/adb/types.h
++++ b/system/core/adb/types.h
+@@ -22,6 +22,7 @@
+ #include <memory>
+ #include <utility>
+ #include <vector>
++#include <string.h>
+ 
+ #include <android-base/logging.h>
+ 
diff --git a/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/0002-android-tools-modifications-to-make-it-build-in-yoct.patch b/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/0002-android-tools-modifications-to-make-it-build-in-yoct.patch
new file mode 100644
index 0000000..2b95ad2
--- /dev/null
+++ b/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/0002-android-tools-modifications-to-make-it-build-in-yoct.patch
@@ -0,0 +1,366 @@
+From fe211cbc305a9316c1d4da2f086d6a50f1c92188 Mon Sep 17 00:00:00 2001
+From: Etienne Cordonnier <ecordonnier@snap.com>
+Date: Fri, 17 Mar 2023 10:33:11 +0100
+Subject: [PATCH] android-tools: modifications to make it build in yocto
+
+- Fix relocation errors on aarch64, e.g.:
+"relocation R_AARCH64_ADR_PREL_PG_HI21 against symbol `_ZTV19SparseFileBufSource' which may bind externally can not be used when making a shared object; recompile with -fPIC"
+
+- use ln -f to avoid error "File exists" on incremental builds
+
+- fix missing headers
+
+Signed-off-by: Etienne Cordonnier <ecordonnier@snap.com>
+
+---
+ debian/external/boringssl/libcrypto.mk         |  1 +
+ debian/system/core/append2simg.mk              |  2 +-
+ debian/system/core/fastboot.mk                 |  2 +-
+ debian/system/core/img2simg.mk                 |  2 +-
+ debian/system/core/libbacktrace.mk             |  8 ++++----
+ debian/system/core/libbase.mk                  |  5 +++--
+ debian/system/core/libcutils.mk                |  5 +++--
+ debian/system/core/liblog.mk                   |  3 ++-
+ debian/system/core/libsparse.mk                |  5 +++--
+ debian/system/core/libutils.mk                 |  2 +-
+ debian/system/core/libziparchive.mk            |  5 +++--
+ debian/system/core/simg2img.mk                 |  2 +-
+ debian/system/core/simg2simg.mk                |  2 +-
+ frameworks/native/libs/adbd_auth/adbd_auth.cpp |  2 ++
+ system/core/adb/adb_listeners.cpp              | 12 ++++++------
+ system/core/adb/transport_local.cpp            |  2 +-
+ 16 files changed, 34 insertions(+), 26 deletions(-)
+
+diff --git a/debian/external/boringssl/libcrypto.mk b/debian/external/boringssl/libcrypto.mk
+index c0ea54f4..b3a77bfd 100644
+--- a/debian/external/boringssl/libcrypto.mk
++++ b/debian/external/boringssl/libcrypto.mk
+@@ -27,6 +27,7 @@ CPPFLAGS += \
+   -DBORINGSSL_IMPLEMENTATION \
+   -DBORINGSSL_SHARED_LIBRARY \
+   -DOPENSSL_SMALL \
++  -DOPENSSL_NO_ASM \
+   -Iexternal/boringssl/src/crypto \
+   -Iexternal/boringssl/src/include \
+ 
+diff --git a/debian/system/core/append2simg.mk b/debian/system/core/append2simg.mk
+index 1599bdb8..598c751d 100644
+--- a/debian/system/core/append2simg.mk
++++ b/debian/system/core/append2simg.mk
+@@ -11,7 +11,7 @@ CPPFLAGS += \
+ 
+ LDFLAGS += \
+   -Ldebian/out/system/core \
+-  -Wl,-rpath=/usr/lib/$(DEB_HOST_MULTIARCH)/android \
++  -Wl,-rpath='$$ORIGIN/../lib/android' \
+   -lbase \
+   -llog \
+   -lpthread \
+diff --git a/debian/system/core/fastboot.mk b/debian/system/core/fastboot.mk
+index d5c9a285..a59ba1a4 100644
+--- a/debian/system/core/fastboot.mk
++++ b/debian/system/core/fastboot.mk
+@@ -49,7 +49,7 @@ CPPFLAGS += \
+ 
+ LDFLAGS += \
+   -Ldebian/out/system/core \
+-  -Wl,-rpath=/usr/lib/$(DEB_HOST_MULTIARCH)/android \
++  -Wl,-rpath='$$ORIGIN/../lib/android' \
+   -fuse-ld=gold \
+   -lbase \
+   -lcutils \
+diff --git a/debian/system/core/img2simg.mk b/debian/system/core/img2simg.mk
+index 11adf014..8baf5ba5 100644
+--- a/debian/system/core/img2simg.mk
++++ b/debian/system/core/img2simg.mk
+@@ -11,7 +11,7 @@ CPPFLAGS += \
+ 
+ LDFLAGS += \
+   -Ldebian/out/system/core \
+-  -Wl,-rpath=/usr/lib/$(DEB_HOST_MULTIARCH)/android \
++  -Wl,-rpath='$$ORIGIN/../lib/android' \
+   -lbase \
+   -llog \
+   -lpthread \
+diff --git a/debian/system/core/libbacktrace.mk b/debian/system/core/libbacktrace.mk
+index e3411d76..86e69874 100644
+--- a/debian/system/core/libbacktrace.mk
++++ b/debian/system/core/libbacktrace.mk
+@@ -1,3 +1,4 @@
++include rules_yocto.mk
+ include /usr/share/dpkg/architecture.mk
+ 
+ NAME = libbacktrace
+@@ -83,10 +84,9 @@ CPPFLAGS += \
+ LDFLAGS += \
+   -L/usr/lib/p7zip \
+   -Ldebian/out/system/core \
+-  -Wl,-rpath=/usr/lib/p7zip \
+-  -Wl,-rpath=/usr/lib/$(DEB_HOST_MULTIARCH)/android \
++  -Wl,-rpath='$$ORIGIN' \
+   -Wl,-soname,$(NAME).so.0 \
+-  -l:7z.so \
++  -l7z \
+   -lbase \
+   -llog \
+   -lpthread \
+@@ -101,7 +101,7 @@ endif
+ build: $(OBJECTS_CXX) $(OBJECTS_ASSEMBLY) debian/out/external/libunwind/libunwind.a
+ 	mkdir -p debian/out/system/core
+ 	$(CXX) $^ -o debian/out/system/core/$(NAME).so.0 $(LDFLAGS)
+-	cd debian/out/system/core && ln -s $(NAME).so.0 $(NAME).so
++	cd debian/out/system/core && ln -sf $(NAME).so.0 $(NAME).so
+ 
+ $(OBJECTS_CXX): %.o: %.cpp
+ 	$(CXX) -c -o $@ $< $(CXXFLAGS) $(CPPFLAGS)
+diff --git a/debian/system/core/libbase.mk b/debian/system/core/libbase.mk
+index d2b074ba..8a90d6de 100644
+--- a/debian/system/core/libbase.mk
++++ b/debian/system/core/libbase.mk
+@@ -1,3 +1,4 @@
++include rules_yocto.mk
+ NAME = libbase
+ 
+ SOURCES = \
+@@ -30,7 +31,7 @@ CPPFLAGS += \
+ 
+ LDFLAGS += \
+   -Ldebian/out/system/core \
+-  -Wl,-rpath=/usr/lib/$(DEB_HOST_MULTIARCH)/android \
++  -Wl,-rpath='$$ORIGIN' \
+   -Wl,-soname,$(NAME).so.0 \
+   -llog \
+   -lpthread \
+@@ -44,7 +45,7 @@ endif
+ 
+ build: $(OBJECTS)
+ 	$(CXX) $^ -o debian/out/system/core/$(NAME).so.0 $(LDFLAGS)
+-	cd debian/out/system/core && ln -s $(NAME).so.0 $(NAME).so
++	cd debian/out/system/core && ln -sf $(NAME).so.0 $(NAME).so
+ 
+ $(OBJECTS): %.o: %.cpp
+ 	$(CXX) -c -o $@ $< $(CXXFLAGS) $(CPPFLAGS)
+diff --git a/debian/system/core/libcutils.mk b/debian/system/core/libcutils.mk
+index 9d928b56..c22b0965 100644
+--- a/debian/system/core/libcutils.mk
++++ b/debian/system/core/libcutils.mk
+@@ -1,3 +1,4 @@
++include rules_yocto.mk
+ NAME = libcutils
+ 
+ libcutils_nonwindows_sources = \
+@@ -47,7 +48,7 @@ CPPFLAGS += \
+ 
+ LDFLAGS += \
+   -Ldebian/out/system/core \
+-  -Wl,-rpath=/usr/lib/$(DEB_HOST_MULTIARCH)/android \
++  -Wl,-rpath='$$ORIGIN' \
+   -Wl,-soname,$(NAME).so.0 \
+   -lbase \
+   -llog \
+@@ -56,7 +57,7 @@ LDFLAGS += \
+ 
+ build: $(OBJECTS_C) $(OBJECTS_CXX)
+ 	$(CXX) $^ -o debian/out/system/core/$(NAME).so.0 $(LDFLAGS)
+-	cd debian/out/system/core && ln -s $(NAME).so.0 $(NAME).so
++	cd debian/out/system/core && ln -sf $(NAME).so.0 $(NAME).so
+ 
+ $(OBJECTS_C): %.o: %.c
+ 	$(CC) -c -o $@ $< $(CFLAGS) $(CPPFLAGS)
+diff --git a/debian/system/core/liblog.mk b/debian/system/core/liblog.mk
+index f8c3d7fe..34a07341 100644
+--- a/debian/system/core/liblog.mk
++++ b/debian/system/core/liblog.mk
+@@ -1,3 +1,4 @@
++include rules_yocto.mk
+ NAME = liblog
+ 
+ liblog_sources = \
+@@ -35,7 +36,7 @@ LDFLAGS += \
+ build: $(OBJECTS)
+ 	mkdir -p debian/out/system/core
+ 	$(CXX) $^ -o debian/out/system/core/$(NAME).so.0 $(LDFLAGS)
+-	cd debian/out/system/core && ln -s $(NAME).so.0 $(NAME).so
++	cd debian/out/system/core && ln -sf $(NAME).so.0 $(NAME).so
+ 
+ $(OBJECTS): %.o: %.cpp
+ 	$(CXX) -c -o $@ $< $(CXXFLAGS) $(CPPFLAGS)
+diff --git a/debian/system/core/libsparse.mk b/debian/system/core/libsparse.mk
+index c2b2694c..2da12b8e 100644
+--- a/debian/system/core/libsparse.mk
++++ b/debian/system/core/libsparse.mk
+@@ -1,3 +1,4 @@
++include rules_yocto.mk
+ NAME = libsparse
+ 
+ SOURCES = \
+@@ -19,7 +20,7 @@ CPPFLAGS += \
+ 
+ LDFLAGS += \
+   -Ldebian/out/system/core \
+-  -Wl,-rpath=/usr/lib/$(DEB_HOST_MULTIARCH)/android \
++  -Wl,-rpath='$$ORIGIN' \
+   -Wl,-soname,$(NAME).so.0 \
+   -lbase \
+   -lz \
+@@ -27,7 +28,7 @@ LDFLAGS += \
+ 
+ build: $(OBJECTS)
+ 	$(CXX) $^ -o debian/out/system/core/$(NAME).so.0 $(LDFLAGS)
+-	cd debian/out/system/core && ln -s $(NAME).so.0 $(NAME).so
++	cd debian/out/system/core && ln -sf $(NAME).so.0 $(NAME).so
+ 
+ $(OBJECTS): %.o: %.cpp
+ 	$(CXX) -c -o $@ $< $(CXXFLAGS) $(CPPFLAGS)
+diff --git a/debian/system/core/libutils.mk b/debian/system/core/libutils.mk
+index c37b1d2d..332492c1 100644
+--- a/debian/system/core/libutils.mk
++++ b/debian/system/core/libutils.mk
+@@ -41,7 +41,7 @@ CPPFLAGS += \
+ 
+ LDFLAGS += \
+   -Ldebian/out/system/core \
+-  -Wl,-rpath=/usr/lib/$(DEB_HOST_MULTIARCH)/android \
++  -Wl,-rpath='$$ORIGIN' \
+   -Wl,-soname,$(NAME).so.0 \
+   -lbacktrace \
+   -lcutils \
+diff --git a/debian/system/core/libziparchive.mk b/debian/system/core/libziparchive.mk
+index 1b286b4e..1b7499be 100644
+--- a/debian/system/core/libziparchive.mk
++++ b/debian/system/core/libziparchive.mk
+@@ -1,3 +1,4 @@
++include rules_yocto.mk
+ NAME = libziparchive
+ 
+ SOURCES = \
+@@ -19,7 +20,7 @@ CPPFLAGS += \
+ 
+ LDFLAGS += \
+   -Ldebian/out/system/core \
+-  -Wl,-rpath=/usr/lib/$(DEB_HOST_MULTIARCH)/android \
++  -Wl,-rpath='$$ORIGIN' \
+   -Wl,-soname,$(NAME).so.0 \
+   -lbase \
+   -llog \
+@@ -29,7 +30,7 @@ LDFLAGS += \
+ 
+ build: $(OBJECTS)
+ 	$(CXX) $^ -o debian/out/system/core/$(NAME).so.0 $(LDFLAGS)
+-	cd debian/out/system/core && ln -s $(NAME).so.0 $(NAME).so
++	cd debian/out/system/core && ln -sf $(NAME).so.0 $(NAME).so
+ 
+ $(OBJECTS): %.o: %.cc
+ 	$(CXX) -c -o $@ $< $(CXXFLAGS) $(CPPFLAGS)
+diff --git a/debian/system/core/simg2img.mk b/debian/system/core/simg2img.mk
+index f6e3f59d..df4f44f3 100644
+--- a/debian/system/core/simg2img.mk
++++ b/debian/system/core/simg2img.mk
+@@ -13,7 +13,7 @@ CPPFLAGS += \
+ 
+ LDFLAGS += \
+   -Ldebian/out/system/core \
+-  -Wl,-rpath=/usr/lib/$(DEB_HOST_MULTIARCH)/android \
++  -Wl,-rpath='$$ORIGIN/../lib/android' \
+   -lbase \
+   -llog \
+   -lpthread \
+diff --git a/debian/system/core/simg2simg.mk b/debian/system/core/simg2simg.mk
+index ed53b04c..646ab030 100644
+--- a/debian/system/core/simg2simg.mk
++++ b/debian/system/core/simg2simg.mk
+@@ -13,7 +13,7 @@ CPPFLAGS += \
+ 
+ LDFLAGS += \
+   -Ldebian/out/system/core \
+-  -Wl,-rpath=/usr/lib/$(DEB_HOST_MULTIARCH)/android \
++  -Wl,-rpath='$$ORIGIN/../lib/android' \
+   -lbase \
+   -llog \
+   -lpthread \
+diff --git a/frameworks/native/libs/adbd_auth/adbd_auth.cpp b/frameworks/native/libs/adbd_auth/adbd_auth.cpp
+index a9c23110..6ca334ba 100644
+--- a/frameworks/native/libs/adbd_auth/adbd_auth.cpp
++++ b/frameworks/native/libs/adbd_auth/adbd_auth.cpp
+@@ -23,8 +23,10 @@
+ #include <sys/eventfd.h>
+ #include <sys/uio.h>
+ 
++#include <atomic>
+ #include <chrono>
+ #include <deque>
++#include <optional>
+ #include <string>
+ #include <string_view>
+ #include <tuple>
+diff --git a/system/core/adb/adb_listeners.cpp b/system/core/adb/adb_listeners.cpp
+index 29909a55..440cdbd4 100644
+--- a/system/core/adb/adb_listeners.cpp
++++ b/system/core/adb/adb_listeners.cpp
+@@ -109,7 +109,7 @@ static void listener_event_func(int _fd, unsigned ev, void* _l)
+ }
+ 
+ // Called as a transport disconnect function. |arg| is the raw alistener*.
+-static void listener_disconnect(void* arg, atransport*) EXCLUDES(listener_list_mutex) {
++static void listener_disconnect(void* arg, atransport*) {
+     std::lock_guard<std::mutex> lock(listener_list_mutex);
+     for (auto iter = listener_list.begin(); iter != listener_list.end(); ++iter) {
+         if (iter->get() == arg) {
+@@ -121,7 +121,7 @@ static void listener_disconnect(void* arg, atransport*) EXCLUDES(listener_list_m
+ }
+ 
+ // Write the list of current listeners (network redirections) into a string.
+-std::string format_listeners() EXCLUDES(listener_list_mutex) {
++std::string format_listeners() {
+     std::lock_guard<std::mutex> lock(listener_list_mutex);
+     std::string result;
+     for (auto& l : listener_list) {
+@@ -140,7 +140,7 @@ std::string format_listeners() EXCLUDES(listener_list_mutex) {
+ }
+ 
+ InstallStatus remove_listener(const char* local_name, atransport* transport)
+-    EXCLUDES(listener_list_mutex) {
++{
+     std::lock_guard<std::mutex> lock(listener_list_mutex);
+     for (auto iter = listener_list.begin(); iter != listener_list.end(); ++iter) {
+         if (local_name == (*iter)->local_name) {
+@@ -151,7 +151,7 @@ InstallStatus remove_listener(const char* local_name, atransport* transport)
+     return INSTALL_STATUS_LISTENER_NOT_FOUND;
+ }
+ 
+-void remove_all_listeners() EXCLUDES(listener_list_mutex) {
++void remove_all_listeners() {
+     std::lock_guard<std::mutex> lock(listener_list_mutex);
+     auto iter = listener_list.begin();
+     while (iter != listener_list.end()) {
+@@ -164,7 +164,7 @@ void remove_all_listeners() EXCLUDES(listener_list_mutex) {
+     }
+ }
+ 
+-void close_smartsockets() EXCLUDES(listener_list_mutex) {
++void close_smartsockets() {
+     std::lock_guard<std::mutex> lock(listener_list_mutex);
+     auto pred = [](const std::unique_ptr<alistener>& listener) {
+         return listener->local_name == "*smartsocket*";
+@@ -174,7 +174,7 @@ void close_smartsockets() EXCLUDES(listener_list_mutex) {
+ 
+ InstallStatus install_listener(const std::string& local_name, const char* connect_to,
+                                atransport* transport, int no_rebind, int* resolved_tcp_port,
+-                               std::string* error) EXCLUDES(listener_list_mutex) {
++                               std::string* error) {
+     std::lock_guard<std::mutex> lock(listener_list_mutex);
+     for (auto& l : listener_list) {
+         if (local_name == l->local_name) {
+diff --git a/system/core/adb/transport_local.cpp b/system/core/adb/transport_local.cpp
+index c7261860..5988ec4d 100644
+--- a/system/core/adb/transport_local.cpp
++++ b/system/core/adb/transport_local.cpp
+@@ -333,7 +333,7 @@ struct EmulatorConnection : public FdConnection {
+ 
+ /* Only call this function if you already hold local_transports_lock. */
+ static atransport* find_emulator_transport_by_adb_port_locked(int adb_port)
+-    REQUIRES(local_transports_lock) {
++{
+     auto it = local_transports.find(adb_port);
+     if (it == local_transports.end()) {
+         return nullptr;
diff --git a/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/0003-Update-usage-of-usbdevfs_urb-to-match-new-kernel-UAP.patch b/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/0003-Update-usage-of-usbdevfs_urb-to-match-new-kernel-UAP.patch
new file mode 100644
index 0000000..7ea040c
--- /dev/null
+++ b/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/0003-Update-usage-of-usbdevfs_urb-to-match-new-kernel-UAP.patch
@@ -0,0 +1,126 @@
+From 02b6b6977d80af4b9b806054fadb5a06cedf011d Mon Sep 17 00:00:00 2001
+From: Etienne Cordonnier <ecordonnier@snap.com>
+Date: Tue, 14 Mar 2023 11:33:50 +0100
+Subject: [PATCH] Update usage of usbdevfs_urb to match new kernel UAPI
+MIME-Version: 1.0
+Content-Type: text/plain; charset=UTF-8
+Content-Transfer-Encoding: 8bit
+
+Linux kernel API has been changed by commit 94dfc73e7cf4 ("treewide: uapi: Replace zero-length arrays with flexible-array members")
+where zero-length array iso_frame_desc in struct usbdevfs_urb was replaced with a proper flexible-array member.
+
+Current USB API usage causes a compilation error at Linux 6.0:
+
+In file included from /home/mae/.cache/kiss/proc/121205/build/android-tools/vendor/adb/client/usb_linux.cpp:28:
+/usr/include/linux/usbdevice_fs.h:134:41: error: flexible array member ‘usbdevfs_urb::iso_frame_desc’ not at end of ‘struct usb_handle’
+  134 |         struct usbdevfs_iso_packet_desc iso_frame_desc[];
+      |                                         ^~~~~~~~~~~~~~
+/home/mae/.cache/kiss/proc/121205/build/android-tools/vendor/adb/client/usb_linux.cpp:76:18: note: next member ‘usbdevfs_urb usb_handle::urb_out’ declared here
+   76 |     usbdevfs_urb urb_out;
+      |                  ^~~~~~~
+/home/mae/.cache/kiss/proc/121205/build/android-tools/vendor/adb/client/usb_linux.cpp:61:8: note: in the definition of ‘struct usb_handle’
+   61 | struct usb_handle {
+      |        ^~~~~~~~~~
+
+Fix it by using pointers to a struct with flexible-array members.
+Current fix works both with the old and the new API.
+
+See https://github.com/nmeum/android-tools/issues/74 for more context.
+
+Tested: built on Linux against kernel 5.19 and 6.0; 'adb shell' over USB
+cable
+Acked-by: Gustavo A. R. Silva gustavoars@kernel.org
+Change-Id: I7f0f7b35d9a3ab980d3520b541b60c7857a6b101
+Signed-off-by: Anatol Pomozov <anatol.pomozov@gmail.com>
+
+[Backported on version 10]
+Signed-off-by: Etienne Cordonnier <ecordonnier@snap.com>
+
+---
+ system/core/adb/client/usb_linux.cpp | 24 ++++++++++++++----------
+ 1 file changed, 14 insertions(+), 10 deletions(-)
+
+diff --git a/system/core/adb/client/usb_linux.cpp b/system/core/adb/client/usb_linux.cpp
+index 343e7b59..6a4479f3 100644
+--- a/system/core/adb/client/usb_linux.cpp
++++ b/system/core/adb/client/usb_linux.cpp
+@@ -71,8 +71,8 @@ struct usb_handle : public ::usb_handle {
+     unsigned zero_mask;
+     unsigned writeable = 1;
+ 
+-    usbdevfs_urb urb_in;
+-    usbdevfs_urb urb_out;
++    usbdevfs_urb *urb_in;
++    usbdevfs_urb *urb_out;
+ 
+     bool urb_in_busy = false;
+     bool urb_out_busy = false;
+@@ -305,7 +305,7 @@ static int usb_bulk_write(usb_handle* h, const void* data, int len) {
+     std::unique_lock<std::mutex> lock(h->mutex);
+     D("++ usb_bulk_write ++");
+ 
+-    usbdevfs_urb* urb = &h->urb_out;
++    usbdevfs_urb* urb = h->urb_out;
+     memset(urb, 0, sizeof(*urb));
+     urb->type = USBDEVFS_URB_TYPE_BULK;
+     urb->endpoint = h->ep_out;
+@@ -344,7 +344,7 @@ static int usb_bulk_read(usb_handle* h, void* data, int len) {
+     std::unique_lock<std::mutex> lock(h->mutex);
+     D("++ usb_bulk_read ++");
+ 
+-    usbdevfs_urb* urb = &h->urb_in;
++    usbdevfs_urb* urb = h->urb_in;
+     memset(urb, 0, sizeof(*urb));
+     urb->type = USBDEVFS_URB_TYPE_BULK;
+     urb->endpoint = h->ep_in;
+@@ -389,7 +389,7 @@ static int usb_bulk_read(usb_handle* h, void* data, int len) {
+         }
+         D("[ urb @%p status = %d, actual = %d ]", out, out->status, out->actual_length);
+ 
+-        if (out == &h->urb_in) {
++        if (out == h->urb_in) {
+             D("[ reap urb - IN complete ]");
+             h->urb_in_busy = false;
+             if (urb->status != 0) {
+@@ -398,7 +398,7 @@ static int usb_bulk_read(usb_handle* h, void* data, int len) {
+             }
+             return urb->actual_length;
+         }
+-        if (out == &h->urb_out) {
++        if (out == h->urb_out) {
+             D("[ reap urb - OUT compelete ]");
+             h->urb_out_busy = false;
+             h->cv.notify_all();
+@@ -502,10 +502,10 @@ void usb_kick(usb_handle* h) {
+             ** but this ensures that a reader blocked on REAPURB
+             ** will get unblocked
+             */
+-            ioctl(h->fd, USBDEVFS_DISCARDURB, &h->urb_in);
+-            ioctl(h->fd, USBDEVFS_DISCARDURB, &h->urb_out);
+-            h->urb_in.status = -ENODEV;
+-            h->urb_out.status = -ENODEV;
++            ioctl(h->fd, USBDEVFS_DISCARDURB, h->urb_in);
++            ioctl(h->fd, USBDEVFS_DISCARDURB, h->urb_out);
++            h->urb_in->status = -ENODEV;
++            h->urb_out->status = -ENODEV;
+             h->urb_in_busy = false;
+             h->urb_out_busy = false;
+             h->cv.notify_all();
+@@ -521,6 +521,8 @@ int usb_close(usb_handle* h) {
+ 
+     D("-- usb close %p (fd = %d) --", h, h->fd);
+ 
++    delete h->urb_in;
++    delete h->urb_out;
+     delete h;
+ 
+     return 0;
+@@ -556,6 +558,8 @@ static void register_device(const char* dev_name, const char* dev_path, unsigned
+     usb->ep_out = ep_out;
+     usb->zero_mask = zero_mask;
+     usb->max_packet_size = max_packet_size;
++    usb->urb_in = new usbdevfs_urb;
++    usb->urb_out = new usbdevfs_urb;
+ 
+     // Initialize mark so we don't get garbage collected after the device scan.
+     usb->mark = true;
diff --git a/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/0004-adb-Fix-build-on-big-endian-systems.patch b/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/0004-adb-Fix-build-on-big-endian-systems.patch
new file mode 100644
index 0000000..83fe447
--- /dev/null
+++ b/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/0004-adb-Fix-build-on-big-endian-systems.patch
@@ -0,0 +1,48 @@
+From e4a29888cb52c1eafd3ab57a6e220b38147ecfbe Mon Sep 17 00:00:00 2001
+From: Etienne Cordonnier <ecordonnier@snap.com>
+Date: Tue, 14 Mar 2023 13:39:23 +0100
+Subject: [PATCH] adb: Fix build on big endian systems
+
+The usb_linux_client.c file defines cpu_to_le16/32 by using the C
+library htole16/32 function calls. However, cpu_to_le16/32 are used
+when initializing structures, i.e in a context where a function call
+is not allowed.
+
+It works fine on little endian systems because htole16/32 are defined
+by the C library as no-ops. But on big-endian systems, they are
+actually doing something, which might involve calling a function,
+causing build failures.
+
+To solve this, we simply open-code cpu_to_le16/32 in a way that allows
+them to be used when initializing structures.
+
+Signed-off-by: Thomas Petazzoni <thomas.petazzoni@free-electrons.com>
+[Forward-ported to version 29]
+Signed-off-by: Etienne Cordonnier <ecordonnier@snap.com>
+
+---
+ system/core/adb/daemon/usb_ffs.cpp | 11 +++++++++--
+ 1 file changed, 9 insertions(+), 2 deletions(-)
+
+diff --git a/system/core/adb/daemon/usb_ffs.cpp b/system/core/adb/daemon/usb_ffs.cpp
+index b19fa5d5..ef2291ca 100644
+--- a/system/core/adb/daemon/usb_ffs.cpp
++++ b/system/core/adb/daemon/usb_ffs.cpp
+@@ -39,8 +39,15 @@
+ 
+ #define USB_EXT_PROP_UNICODE 1
+ 
+-#define cpu_to_le16(x) htole16(x)
+-#define cpu_to_le32(x) htole32(x)
++#if __BYTE_ORDER == __LITTLE_ENDIAN
++# define cpu_to_le16(x) (x)
++# define cpu_to_le32(x) (x)
++#else
++# define cpu_to_le16(x) ((((x) >> 8) & 0xffu) | (((x) & 0xffu) << 8))
++# define cpu_to_le32(x) \
++	((((x) & 0xff000000u) >> 24) | (((x) & 0x00ff0000u) >>  8) | \
++	 (((x) & 0x0000ff00u) <<  8) | (((x) & 0x000000ffu) << 24))
++#endif
+ 
+ // clang-format off
+ struct func_desc {
diff --git a/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/0005-adb-Allow-adbd-to-be-run-as-root.patch b/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/0005-adb-Allow-adbd-to-be-run-as-root.patch
new file mode 100644
index 0000000..3fbdcd4
--- /dev/null
+++ b/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/0005-adb-Allow-adbd-to-be-run-as-root.patch
@@ -0,0 +1,23 @@
+From 4ef35041ba5c02df48c31f2382e7c3c4316ad936 Mon Sep 17 00:00:00 2001
+From: Etienne Cordonnier <ecordonnier@snap.com>
+Date: Tue, 14 Mar 2023 13:53:51 +0100
+Subject: [PATCH] adb: Allow adbd to be run as root
+
+Signed-off-by: Etienne Cordonnier <ecordonnier@snap.com>
+
+---
+ system/core/adb/daemon/main.cpp | 1 +
+ 1 file changed, 1 insertion(+)
+
+diff --git a/system/core/adb/daemon/main.cpp b/system/core/adb/daemon/main.cpp
+index e807d13d..309663a2 100644
+--- a/system/core/adb/daemon/main.cpp
++++ b/system/core/adb/daemon/main.cpp
+@@ -75,6 +75,7 @@ static bool should_drop_capabilities_bounding_set() {
+ }
+ 
+ static bool should_drop_privileges() {
++    return true;
+     // "adb root" not allowed, always drop privileges.
+     if (!ALLOW_ADBD_ROOT && !is_device_unlocked()) return true;
+ 
diff --git a/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/adbd.mk b/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/adbd.mk
new file mode 100644
index 0000000..3282216
--- /dev/null
+++ b/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/adbd.mk
@@ -0,0 +1,87 @@
+include rules_yocto.mk
+NAME = adbd
+
+SOURCES = \
+	adb/adbconnection/adbconnection_server.cpp \
+	adb/daemon/auth.cpp \
+	adb/daemon/file_sync_service.cpp \
+	adb/daemon/file_sync_service.h \
+	adb/daemon/framebuffer_service.cpp \
+	adb/daemon/framebuffer_service.h \
+	adb/daemon/jdwp_service.cpp \
+	adb/daemon/main.cpp \
+	adb/daemon/restart_service.cpp \
+	adb/daemon/restart_service.h \
+	adb/daemon/services.cpp \
+	adb/daemon/shell_service.cpp \
+	adb/daemon/shell_service.h \
+	adb/daemon/usb_ffs.cpp \
+	adb/daemon/usb_legacy.cpp \
+	adb/daemon/usb.cpp \
+	adb/shell_service_protocol.cpp \
+	adb/adb.cpp \
+	adb/adb_io.cpp \
+	adb/adb_listeners.cpp \
+	adb/adb_trace.cpp \
+	adb/adb_unique_fd.cpp \
+	adb/adb_utils.cpp \
+	adb/fdevent/fdevent.cpp \
+	adb/fdevent/fdevent_epoll.cpp \
+	adb/services.cpp \
+	adb/sockets.cpp \
+	adb/socket_spec.cpp \
+	adb/sysdeps/errno.cpp \
+	adb/sysdeps/posix/network.cpp \
+	adb/sysdeps_unix.cpp \
+	adb/transport.cpp \
+	adb/transport_fd.cpp \
+	adb/transport_local.cpp \
+	adb/transport_usb.cpp \
+	adb/types.cpp \
+	diagnose_usb/diagnose_usb.cpp \
+	libasyncio/AsyncIO.cpp \
+
+SOURCES := $(foreach source, $(SOURCES), system/core/$(source))
+
+SOURCES += \
+    frameworks/native/libs/adbd_auth/adbd_auth.cpp
+
+CXXFLAGS += -std=gnu++20
+CPPFLAGS += -Isystem/coreinclude -Isystem/core/adb -Isystem/core/base/include  -Idebian/out/system/core -Isystem/tools/mkbootimg/include/bootimg -Isystem/core/fs_mgr/include \
+	    -Isystem/core/fs_mgr/include_fstab \
+            -DADB_VERSION='"$(DEB_VERSION)"' -D_GNU_SOURCE
+LDFLAGS += -Wl,-rpath='$$ORIGIN/../lib/android' -Wl,-rpath-link='$$ORIGIN/../lib/android' \
+           -lpthread -Ldebian/out/system/core -Ldebian/out/external/boringssl -lbase -lcrypto_utils -l:libcrypto.a -lcutils -llog -lresolv
+
+PAGE_SIZE ?= 4096
+
+CXXFLAGS += -UADB_HOST
+CXXFLAGS +=	-DADB_HOST=0
+CXXFLAGS += -DALLOW_ADBD_DISABLE_VERITY
+CXXFLAGS += -DALLOW_ADBD_NO_AUTH
+CXXFLAGS += -DPLATFORM_TOOLS_VERSION='"28.0.2"' 
+CXXFLAGS += -Isystem/core/diagnose_usb/include 
+CXXFLAGS += -Isystem/core/adb/daemon/include
+CXXFLAGS += -Isystem/core/adb/adbconnection/include
+CXXFLAGS += -Isystem/core/libasyncio/include
+CXXFLAGS += -Isystem/core/libcutils/include
+CXXFLAGS += -Isystem/core/libcrypto_utils/include
+CXXFLAGS += -Isystem/core/liblog/include/
+CXXFLAGS += -Isystem/core/libutils/include
+CXXFLAGS += -Iframeworks/native/libs/adbd_auth/include
+CXXFLAGS += -Wno-c++11-narrowing 
+CXXFLAGS += -DPAGE_SIZE=$(PAGE_SIZE)
+
+
+# -latomic should be the last library specified
+# https://github.com/android/ndk/issues/589
+ifneq ($(filter armel mipsel,$(DEB_HOST_ARCH)),)
+  LDFLAGS += -latomic
+endif
+
+build: $(SOURCES)
+	mkdir --parents debian/out/system/core
+	$(CXX) $^ -o debian/out/system/core/adbd $(CXXFLAGS) $(CPPFLAGS) $(LDFLAGS)
+
+clean:
+	$(RM) debian/out/system/core/adbd
diff --git a/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/android-tools-adbd.service b/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/android-tools-adbd.service
new file mode 100644
index 0000000..ddf8d7f
--- /dev/null
+++ b/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/android-tools-adbd.service
@@ -0,0 +1,13 @@
+[Unit]
+Description=Android Debug Bridge
+ConditionPathExists=/var/usb-debugging-enabled
+Before=android-system.service
+
+[Service]
+Type=simple
+Restart=on-failure
+ExecStartPre=-/usr/bin/android-gadget-setup adb
+ExecStart=/usr/bin/adbd
+
+[Install]
+WantedBy=basic.target
diff --git a/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/debian/Add-riscv64-support.patch b/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/debian/Add-riscv64-support.patch
new file mode 100644
index 0000000..4669f89
--- /dev/null
+++ b/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/debian/Add-riscv64-support.patch
@@ -0,0 +1,651 @@
+From: Guo Ren <guoren@linux.alibaba.com>
+Date: Wed, 29 Jun 2022 16:46:46 +0800
+Subject: Add riscv64 support
+
+This patch contains the dwarf unwind support for 64bit risc-v.
+
+    * DwarfCfa.cpp (cfa_def_cfa_register): setup register if CFA_REG is
+    not setup for riscv64
+    * Elf.cpp (GetRelPc): convert offset to virtual address for riscv64.
+    * ElfInterface.cpp (GetVirtAddrFromOffset): New for riscv64.
+    * RegsRiscv64.cpp (StepIfSignalHandler): Fix signal frame check.
+    libunwindstack/include/unwindstack/
+    * ElfInterface.h (GetVirtAddrFromOffset): New for riscv64.
+    libunwindstack/tests/
+    * DwarfCfaTest.cpp (cfa_def_cfa_register): ok for riscv64.
+    * RegsStepIfSignalHandlerTest.cpp (riscv64_step_if_signal_handler): Fix
+    testcase for riscv64
+
+Test: Builds.
+Test: All unit tests pass.
+
+Signed-off-by: Guo Ren <guoren@linux.alibaba.com>
+Signed-off-by: Lifang Xia <lifang_xia@linux.alibaba.com>
+Signed-off-by: Mao Han <han_mao@linux.alibaba.com>
+Change-Id: Ib21ddf23cc83f332af202df7bffcaceec16063e0
+---
+ system/core/libunwindstack/Android.bp              |   1 +
+ system/core/libunwindstack/Elf.cpp                 |   2 +
+ system/core/libunwindstack/Regs.cpp                |  10 ++
+ system/core/libunwindstack/RegsRiscv64.cpp         | 156 +++++++++++++++++++++
+ .../core/libunwindstack/include/unwindstack/Elf.h  |   5 +
+ .../include/unwindstack/MachineRiscv64.h           |  59 ++++++++
+ .../include/unwindstack/RegsGetLocal.h             |  43 ++++++
+ .../include/unwindstack/RegsRiscv64.h              |  59 ++++++++
+ .../include/unwindstack/UcontextRiscv64.h          |  80 +++++++++++
+ .../include/unwindstack/UserRiscv64.h              |  37 +++++
+ system/core/libunwindstack/tools/unwind.cpp        |   3 +
+ .../core/libunwindstack/tools/unwind_symbols.cpp   |   3 +
+ 12 files changed, 458 insertions(+)
+ create mode 100644 system/core/libunwindstack/RegsRiscv64.cpp
+ create mode 100644 system/core/libunwindstack/include/unwindstack/MachineRiscv64.h
+ create mode 100644 system/core/libunwindstack/include/unwindstack/RegsRiscv64.h
+ create mode 100644 system/core/libunwindstack/include/unwindstack/UcontextRiscv64.h
+ create mode 100644 system/core/libunwindstack/include/unwindstack/UserRiscv64.h
+
+diff --git a/system/core/libunwindstack/Android.bp b/system/core/libunwindstack/Android.bp
+index 3695f72..f1f9c68 100644
+--- a/system/core/libunwindstack/Android.bp
++++ b/system/core/libunwindstack/Android.bp
+@@ -70,6 +70,7 @@ cc_library {
+         "RegsArm64.cpp",
+         "RegsX86.cpp",
+         "RegsX86_64.cpp",
++        "RegsRiscv64.cpp",
+         "RegsMips.cpp",
+         "RegsMips64.cpp",
+         "Unwinder.cpp",
+diff --git a/system/core/libunwindstack/Elf.cpp b/system/core/libunwindstack/Elf.cpp
+index f01b092..3c2088b 100644
+--- a/system/core/libunwindstack/Elf.cpp
++++ b/system/core/libunwindstack/Elf.cpp
+@@ -290,6 +290,8 @@ ElfInterface* Elf::CreateInterfaceFromMemory(Memory* memory) {
+       arch_ = ARCH_X86_64;
+     } else if (e_machine == EM_MIPS) {
+       arch_ = ARCH_MIPS64;
++    } else if (e_machine == EM_RISCV) {
++      arch_ = ARCH_RISCV64;
+     } else {
+       // Unsupported.
+       ALOGI("64 bit elf that is neither aarch64 nor x86_64 nor mips64: e_machine = %d\n",
+diff --git a/system/core/libunwindstack/Regs.cpp b/system/core/libunwindstack/Regs.cpp
+index c7dec52..447a554 100644
+--- a/system/core/libunwindstack/Regs.cpp
++++ b/system/core/libunwindstack/Regs.cpp
+@@ -27,12 +27,14 @@
+ #include <unwindstack/RegsArm64.h>
+ #include <unwindstack/RegsMips.h>
+ #include <unwindstack/RegsMips64.h>
++#include <unwindstack/RegsRiscv64.h>
+ #include <unwindstack/RegsX86.h>
+ #include <unwindstack/RegsX86_64.h>
+ #include <unwindstack/UserArm.h>
+ #include <unwindstack/UserArm64.h>
+ #include <unwindstack/UserMips.h>
+ #include <unwindstack/UserMips64.h>
++#include <unwindstack/UserRiscv64.h>
+ #include <unwindstack/UserX86.h>
+ #include <unwindstack/UserX86_64.h>
+ 
+@@ -67,6 +69,8 @@ Regs* Regs::RemoteGet(pid_t pid) {
+     return RegsMips::Read(buffer.data());
+   case sizeof(mips64_user_regs):
+     return RegsMips64::Read(buffer.data());
++  case sizeof(riscv64_user_regs):
++    return RegsRiscv64::Read(buffer.data());
+   }
+   return nullptr;
+ }
+@@ -85,6 +89,8 @@ Regs* Regs::CreateFromUcontext(ArchEnum arch, void* ucontext) {
+       return RegsMips::CreateFromUcontext(ucontext);
+     case ARCH_MIPS64:
+       return RegsMips64::CreateFromUcontext(ucontext);
++    case ARCH_RISCV64:
++      return RegsRiscv64::CreateFromUcontext(ucontext);
+     case ARCH_UNKNOWN:
+     default:
+       return nullptr;
+@@ -104,6 +110,8 @@ ArchEnum Regs::CurrentArch() {
+   return ARCH_MIPS;
+ #elif defined(__mips__) && defined(__LP64__)
+   return ARCH_MIPS64;
++#elif defined(__riscv)
++  return ARCH_RISCV64;
+ #else
+   abort();
+ #endif
+@@ -123,6 +131,8 @@ Regs* Regs::CreateFromLocal() {
+   regs = new RegsMips();
+ #elif defined(__mips__) && defined(__LP64__)
+   regs = new RegsMips64();
++#elif defined(__riscv)
++  regs = new RegsRiscv64();
+ #else
+   abort();
+ #endif
+diff --git a/system/core/libunwindstack/RegsRiscv64.cpp b/system/core/libunwindstack/RegsRiscv64.cpp
+new file mode 100644
+index 0000000..887762a
+--- /dev/null
++++ b/system/core/libunwindstack/RegsRiscv64.cpp
+@@ -0,0 +1,156 @@
++/*
++ * Copyright (C) 2022 The Android Open Source Project
++ *
++ * Licensed under the Apache License, Version 2.0 (the "License");
++ * you may not use this file except in compliance with the License.
++ * You may obtain a copy of the License at
++ *
++ *      http://www.apache.org/licenses/LICENSE-2.0
++ *
++ * Unless required by applicable law or agreed to in writing, software
++ * distributed under the License is distributed on an "AS IS" BASIS,
++ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
++ * See the License for the specific language governing permissions and
++ * limitations under the License.
++ */
++
++#include <stdint.h>
++#include <string.h>
++
++#include <functional>
++
++#include <unwindstack/Elf.h>
++#include <unwindstack/MachineRiscv64.h>
++#include <unwindstack/MapInfo.h>
++#include <unwindstack/Memory.h>
++#include <unwindstack/RegsRiscv64.h>
++#include <unwindstack/UcontextRiscv64.h>
++#include <unwindstack/UserRiscv64.h>
++
++namespace unwindstack {
++
++RegsRiscv64::RegsRiscv64()
++    : RegsImpl<uint64_t>(RISCV64_REG_MAX, Location(LOCATION_REGISTER, RISCV64_REG_RA)) {}
++
++ArchEnum RegsRiscv64::Arch() {
++  return ARCH_RISCV64;
++}
++
++uint64_t RegsRiscv64::pc() {
++  return regs_[RISCV64_REG_PC];
++}
++
++uint64_t RegsRiscv64::sp() {
++  return regs_[RISCV64_REG_SP];
++}
++
++void RegsRiscv64::set_pc(uint64_t pc) {
++  regs_[RISCV64_REG_PC] = pc;
++}
++
++void RegsRiscv64::set_sp(uint64_t sp) {
++  regs_[RISCV64_REG_SP] = sp;
++}
++
++uint64_t RegsRiscv64::GetPcAdjustment(uint64_t rel_pc, Elf*) {
++  if (rel_pc < 8) {
++    return 0;
++  }
++  // For now, just assume no compact branches
++  return 8;
++}
++
++bool RegsRiscv64::SetPcFromReturnAddress(Memory*) {
++  uint64_t ra = regs_[RISCV64_REG_RA];
++  if (regs_[RISCV64_REG_PC] == ra) {
++    return false;
++  }
++
++  regs_[RISCV64_REG_PC] = ra;
++  return true;
++}
++
++void RegsRiscv64::IterateRegisters(std::function<void(const char*, uint64_t)> fn) {
++  fn("pc", regs_[RISCV64_REG_PC]);
++  fn("ra", regs_[RISCV64_REG_RA]);
++  fn("sp", regs_[RISCV64_REG_SP]);
++  fn("gp", regs_[RISCV64_REG_GP]);
++  fn("tp", regs_[RISCV64_REG_TP]);
++  fn("t0", regs_[RISCV64_REG_T0]);
++  fn("t1", regs_[RISCV64_REG_T1]);
++  fn("t2", regs_[RISCV64_REG_T2]);
++  fn("t3", regs_[RISCV64_REG_T3]);
++  fn("t4", regs_[RISCV64_REG_T4]);
++  fn("t5", regs_[RISCV64_REG_T5]);
++  fn("t6", regs_[RISCV64_REG_T6]);
++  fn("s0", regs_[RISCV64_REG_S0]);
++  fn("s1", regs_[RISCV64_REG_S1]);
++  fn("s2", regs_[RISCV64_REG_S2]);
++  fn("s3", regs_[RISCV64_REG_S3]);
++  fn("s4", regs_[RISCV64_REG_S4]);
++  fn("s5", regs_[RISCV64_REG_S5]);
++  fn("s6", regs_[RISCV64_REG_S6]);
++  fn("s7", regs_[RISCV64_REG_S7]);
++  fn("s8", regs_[RISCV64_REG_S8]);
++  fn("s9", regs_[RISCV64_REG_S9]);
++  fn("s10", regs_[RISCV64_REG_S10]);
++  fn("s11", regs_[RISCV64_REG_S11]);
++  fn("a0", regs_[RISCV64_REG_A0]);
++  fn("a1", regs_[RISCV64_REG_A1]);
++  fn("a2", regs_[RISCV64_REG_A2]);
++  fn("a3", regs_[RISCV64_REG_A3]);
++  fn("a4", regs_[RISCV64_REG_A4]);
++  fn("a5", regs_[RISCV64_REG_A5]);
++  fn("a6", regs_[RISCV64_REG_A6]);
++  fn("a7", regs_[RISCV64_REG_A7]);
++}
++
++Regs* RegsRiscv64::Read(void* remote_data) {
++  riscv64_user_regs* user = reinterpret_cast<riscv64_user_regs*>(remote_data);
++
++  RegsRiscv64* regs = new RegsRiscv64();
++  memcpy(regs->RawData(), &user->regs[0], RISCV64_REG_MAX * sizeof(uint64_t));
++  // uint64_t* reg_data = reinterpret_cast<uint64_t*>(regs->RawData());
++  return regs;
++}
++
++Regs* RegsRiscv64::CreateFromUcontext(void* ucontext) {
++  riscv64_ucontext_t* riscv64_ucontext = reinterpret_cast<riscv64_ucontext_t*>(ucontext);
++
++  RegsRiscv64* regs = new RegsRiscv64();
++  memcpy(regs->RawData(), &riscv64_ucontext->uc_mcontext.__gregs[0],
++         RISCV64_REG_MAX * sizeof(uint64_t));
++  return regs;
++}
++
++bool RegsRiscv64::StepIfSignalHandler(uint64_t elf_offset, Elf* elf, Memory* process_memory) {
++  uint64_t data;
++  Memory* elf_memory = elf->memory();
++  // Read from elf memory since it is usually more expensive to read from
++  // process memory.
++  if (!elf_memory->ReadFully(elf_offset, &data, sizeof(data))) {
++    return false;
++  }
++  // Look for the kernel sigreturn function.
++  // __kernel_rt_sigreturn:
++  // li a7, __NR_rt_sigreturn
++  // scall
++
++  const uint8_t li_scall[] = {0x93, 0x08, 0xb0, 0x08, 0x73, 0x00, 0x00, 0x00};
++  if (memcmp(&data, &li_scall, 8) != 0) {
++    return false;
++  }
++
++  // SP + sizeof(siginfo_t) + uc_mcontext offset + PC offset.
++  if (!process_memory->ReadFully(regs_[RISCV64_REG_SP] + 0x80 + 0xb0 + 0x00, regs_.data(),
++                                 sizeof(uint64_t) * (RISCV64_REG_MAX))) {
++    return false;
++  }
++  return true;
++}
++
++Regs* RegsRiscv64::Clone() {
++  return new RegsRiscv64(*this);
++}
++
++}  // namespace unwindstack
+diff --git a/system/core/libunwindstack/include/unwindstack/Elf.h b/system/core/libunwindstack/include/unwindstack/Elf.h
+index 472ed92..88fa0ff 100644
+--- a/system/core/libunwindstack/include/unwindstack/Elf.h
++++ b/system/core/libunwindstack/include/unwindstack/Elf.h
+@@ -32,6 +32,10 @@
+ #define EM_AARCH64 183
+ #endif
+ 
++#if !defined(EM_RISCV)
++#define EM_RISCV 243
++#endif
++
+ namespace unwindstack {
+ 
+ // Forward declaration.
+@@ -46,6 +50,7 @@ enum ArchEnum : uint8_t {
+   ARCH_X86_64,
+   ARCH_MIPS,
+   ARCH_MIPS64,
++  ARCH_RISCV64,
+ };
+ 
+ class Elf {
+diff --git a/system/core/libunwindstack/include/unwindstack/MachineRiscv64.h b/system/core/libunwindstack/include/unwindstack/MachineRiscv64.h
+new file mode 100644
+index 0000000..397e680
+--- /dev/null
++++ b/system/core/libunwindstack/include/unwindstack/MachineRiscv64.h
+@@ -0,0 +1,59 @@
++/*
++ * Copyright (C) 2022 The Android Open Source Project
++ *
++ * Licensed under the Apache License, Version 2.0 (the "License");
++ * you may not use this file except in compliance with the License.
++ * You may obtain a copy of the License at
++ *
++ *      http://www.apache.org/licenses/LICENSE-2.0
++ *
++ * Unless required by applicable law or agreed to in writing, software
++ * distributed under the License is distributed on an "AS IS" BASIS,
++ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
++ * See the License for the specific language governing permissions and
++ * limitations under the License.
++ */
++
++#pragma once
++
++#include <stdint.h>
++
++namespace unwindstack {
++
++enum Riscv64Reg : uint16_t {
++  RISCV64_REG_PC,
++  RISCV64_REG_RA,
++  RISCV64_REG_SP,
++  RISCV64_REG_GP,
++  RISCV64_REG_TP,
++  RISCV64_REG_T0,
++  RISCV64_REG_T1,
++  RISCV64_REG_T2,
++  RISCV64_REG_S0,
++  RISCV64_REG_S1,
++  RISCV64_REG_A0,
++  RISCV64_REG_A1,
++  RISCV64_REG_A2,
++  RISCV64_REG_A3,
++  RISCV64_REG_A4,
++  RISCV64_REG_A5,
++  RISCV64_REG_A6,
++  RISCV64_REG_A7,
++  RISCV64_REG_S2,
++  RISCV64_REG_S3,
++  RISCV64_REG_S4,
++  RISCV64_REG_S5,
++  RISCV64_REG_S6,
++  RISCV64_REG_S7,
++  RISCV64_REG_S8,
++  RISCV64_REG_S9,
++  RISCV64_REG_S10,
++  RISCV64_REG_S11,
++  RISCV64_REG_T3,
++  RISCV64_REG_T4,
++  RISCV64_REG_T5,
++  RISCV64_REG_T6,
++  RISCV64_REG_MAX,
++};
++
++}  // namespace unwindstack
+diff --git a/system/core/libunwindstack/include/unwindstack/RegsGetLocal.h b/system/core/libunwindstack/include/unwindstack/RegsGetLocal.h
+index f0b5e3a..698eba2 100644
+--- a/system/core/libunwindstack/include/unwindstack/RegsGetLocal.h
++++ b/system/core/libunwindstack/include/unwindstack/RegsGetLocal.h
+@@ -81,6 +81,49 @@ inline __attribute__((__always_inline__)) void AsmGetRegs(void* reg_data) {
+       : "x12", "x13", "memory");
+ }
+ 
++#elif defined(__riscv)
++
++inline __attribute__((__always_inline__)) void AsmGetRegs(void* reg_data) {
++  asm volatile(
++      "1:\n"
++      "sd ra, 8(%[base])\n"
++      "sd sp, 16(%[base])\n"
++      "sd gp, 24(%[base])\n"
++      "sd tp, 32(%[base])\n"
++      "sd t0, 40(%[base])\n"
++      "sd t1, 48(%[base])\n"
++      "sd t2, 56(%[base])\n"
++      "sd s0, 64(%[base])\n"
++      "sd s1, 72(%[base])\n"
++      "sd a0, 80(%[base])\n"
++      "sd a1, 88(%[base])\n"
++      "sd a2, 96(%[base])\n"
++      "sd a3, 104(%[base])\n"
++      "sd a4, 112(%[base])\n"
++      "sd a5, 120(%[base])\n"
++      "sd a6, 128(%[base])\n"
++      "sd a7, 136(%[base])\n"
++      "sd s2, 144(%[base])\n"
++      "sd s3, 152(%[base])\n"
++      "sd s4, 160(%[base])\n"
++      "sd s5, 168(%[base])\n"
++      "sd s6, 176(%[base])\n"
++      "sd s7, 184(%[base])\n"
++      "sd s8, 192(%[base])\n"
++      "sd s9, 200(%[base])\n"
++      "sd s10, 208(%[base])\n"
++      "sd s11, 216(%[base])\n"
++      "sd t3, 224(%[base])\n"
++      "sd t4, 232(%[base])\n"
++      "sd t5, 240(%[base])\n"
++      "sd t6, 248(%[base])\n"
++      "la t1, 1b\n"
++      "sd t1, 0(%[base])\n"
++      : [base] "+r"(reg_data)
++      :
++      : "t1", "memory");
++}
++
+ #elif defined(__i386__) || defined(__x86_64__) || defined(__mips__)
+ 
+ extern "C" void AsmGetRegs(void* regs);
+diff --git a/system/core/libunwindstack/include/unwindstack/RegsRiscv64.h b/system/core/libunwindstack/include/unwindstack/RegsRiscv64.h
+new file mode 100644
+index 0000000..eb09397
+--- /dev/null
++++ b/system/core/libunwindstack/include/unwindstack/RegsRiscv64.h
+@@ -0,0 +1,59 @@
++/*
++ * Copyright (C) 2022 The Android Open Source Project
++ *
++ * Licensed under the Apache License, Version 2.0 (the "License");
++ * you may not use this file except in compliance with the License.
++ * You may obtain a copy of the License at
++ *
++ *      http://www.apache.org/licenses/LICENSE-2.0
++ *
++ * Unless required by applicable law or agreed to in writing, software
++ * distributed under the License is distributed on an "AS IS" BASIS,
++ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
++ * See the License for the specific language governing permissions and
++ * limitations under the License.
++ */
++
++#pragma once
++
++#include <stdint.h>
++
++#include <functional>
++
++#include <unwindstack/Elf.h>
++#include <unwindstack/Regs.h>
++
++namespace unwindstack {
++
++// Forward declarations.
++class Memory;
++
++class RegsRiscv64 : public RegsImpl<uint64_t> {
++ public:
++  RegsRiscv64();
++  virtual ~RegsRiscv64() = default;
++
++  ArchEnum Arch() override final;
++
++  uint64_t GetPcAdjustment(uint64_t rel_pc, Elf* elf) override;
++
++  bool SetPcFromReturnAddress(Memory* process_memory) override;
++
++  bool StepIfSignalHandler(uint64_t elf_offset, Elf* elf, Memory* process_memory) override;
++
++  void IterateRegisters(std::function<void(const char*, uint64_t)>) override final;
++
++  uint64_t pc() override;
++  uint64_t sp() override;
++
++  void set_pc(uint64_t pc) override;
++  void set_sp(uint64_t sp) override;
++
++  Regs* Clone() override final;
++
++  static Regs* Read(void* data);
++
++  static Regs* CreateFromUcontext(void* ucontext);
++};
++
++}  // namespace unwindstack
+diff --git a/system/core/libunwindstack/include/unwindstack/UcontextRiscv64.h b/system/core/libunwindstack/include/unwindstack/UcontextRiscv64.h
+new file mode 100644
+index 0000000..c6c82b1
+--- /dev/null
++++ b/system/core/libunwindstack/include/unwindstack/UcontextRiscv64.h
+@@ -0,0 +1,80 @@
++/*
++ * Copyright (C) 2014 The Android Open Source Project
++ * All rights reserved.
++ *
++ * Redistribution and use in source and binary forms, with or without
++ * modification, are permitted provided that the following conditions
++ * are met:
++ *  * Redistributions of source code must retain the above copyright
++ *    notice, this list of conditions and the following disclaimer.
++ *  * Redistributions in binary form must reproduce the above copyright
++ *    notice, this list of conditions and the following disclaimer in
++ *    the documentation and/or other materials provided with the
++ *    distribution.
++ *
++ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
++ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
++ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
++ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
++ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
++ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
++ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
++ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
++ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
++ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
++ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
++ * SUCH DAMAGE.
++ */
++
++#pragma once
++
++#include <sys/cdefs.h>
++
++typedef uint64_t __riscv_mc_gp_state[32];  // unsigned long
++
++struct __riscv_mc_f_ext_state {
++  uint32_t __f[32];
++  uint32_t __fcsr;
++};
++
++struct __riscv_mc_d_ext_state {
++  uint64_t __f[32];
++  uint32_t __fcsr;
++};
++
++struct __riscv_mc_q_ext_state {
++  uint64_t __f[64] __attribute__((__aligned__(16)));
++  uint32_t __fcsr;
++  uint32_t __reserved[3];
++};
++
++union __riscv_mc_fp_state {
++  struct __riscv_mc_f_ext_state __f;
++  struct __riscv_mc_d_ext_state __d;
++  struct __riscv_mc_q_ext_state __q;
++};
++
++struct __riscv_stack_t {
++  uint64_t ss_sp;
++  int32_t ss_flags;
++  uint64_t ss_size;
++};
++
++struct riscv64_sigset_t {
++  uint64_t sig;  // unsigned long
++};
++
++struct riscv64_mcontext_t {
++  __riscv_mc_gp_state __gregs;
++  union __riscv_mc_fp_state __fpregs;
++};
++
++struct riscv64_ucontext_t {
++  uint64_t uc_flags;  // unsigned long
++  struct riscv64_ucontext_t* uc_link;
++  __riscv_stack_t uc_stack;
++  riscv64_sigset_t uc_sigmask;
++  /* The kernel adds extra padding here to allow sigset_t to grow. */
++  int8_t __padding[128 - sizeof(riscv64_sigset_t)];  // char
++  riscv64_mcontext_t uc_mcontext;
++};
+diff --git a/system/core/libunwindstack/include/unwindstack/UserRiscv64.h b/system/core/libunwindstack/include/unwindstack/UserRiscv64.h
+new file mode 100644
+index 0000000..1e91228
+--- /dev/null
++++ b/system/core/libunwindstack/include/unwindstack/UserRiscv64.h
+@@ -0,0 +1,37 @@
++/*
++ * Copyright (C) 2016 The Android Open Source Project
++ * All rights reserved.
++ *
++ * Redistribution and use in source and binary forms, with or without
++ * modification, are permitted provided that the following conditions
++ * are met:
++ *  * Redistributions of source code must retain the above copyright
++ *    notice, this list of conditions and the following disclaimer.
++ *  * Redistributions in binary form must reproduce the above copyright
++ *    notice, this list of conditions and the following disclaimer in
++ *    the documentation and/or other materials provided with the
++ *    distribution.
++ *
++ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
++ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
++ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
++ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
++ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
++ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
++ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
++ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
++ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
++ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
++ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
++ * SUCH DAMAGE.
++ */
++
++#pragma once
++
++namespace unwindstack {
++
++struct riscv64_user_regs {
++  uint64_t regs[32];
++};
++
++}  // namespace unwindstack
+diff --git a/system/core/libunwindstack/tools/unwind.cpp b/system/core/libunwindstack/tools/unwind.cpp
+index 1812e50..ae20891 100644
+--- a/system/core/libunwindstack/tools/unwind.cpp
++++ b/system/core/libunwindstack/tools/unwind.cpp
+@@ -83,6 +83,9 @@ void DoUnwind(pid_t pid) {
+     case unwindstack::ARCH_MIPS64:
+       printf("mips64");
+       break;
++    case unwindstack::ARCH_RISCV64:
++      printf("riscv64");
++      break;
+     default:
+       printf("unknown\n");
+       return;
+diff --git a/system/core/libunwindstack/tools/unwind_symbols.cpp b/system/core/libunwindstack/tools/unwind_symbols.cpp
+index 8df2284..976db56 100644
+--- a/system/core/libunwindstack/tools/unwind_symbols.cpp
++++ b/system/core/libunwindstack/tools/unwind_symbols.cpp
+@@ -77,6 +77,9 @@ int main(int argc, char** argv) {
+     case EM_AARCH64:
+       printf("ABI: arm64\n");
+       break;
++    case EM_RISCV:
++      printf("ABI: riscv64\n");
++      break;
+     case EM_386:
+       printf("ABI: x86\n");
+       break;
diff --git a/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/debian/Added-missing-headers.patch b/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/debian/Added-missing-headers.patch
new file mode 100644
index 0000000..c07e936
--- /dev/null
+++ b/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/debian/Added-missing-headers.patch
@@ -0,0 +1,44 @@
+Description: Added missing headers causing compile errors
+Author: Umang Parmar <umangjparmar@gmail.com>
+Forwarded: not-needed
+
+--- a/system/core/adb/sysdeps/posix/network.cpp
++++ b/system/core/adb/sysdeps/posix/network.cpp
+@@ -22,6 +22,7 @@
+ #include <sys/socket.h>
+ 
+ #include <string>
++#include <cstring>
+ 
+ #include <android-base/logging.h>
+ #include <android-base/stringprintf.h>
+--- a/system/core/base/file.cpp
++++ b/system/core/base/file.cpp
+@@ -26,6 +26,7 @@
+ #include <sys/stat.h>
+ #include <sys/types.h>
+ #include <unistd.h>
++#include <cstring>
+ 
+ #include <memory>
+ #include <mutex>
+--- a/system/core/libbacktrace/BacktraceMap.cpp
++++ b/system/core/libbacktrace/BacktraceMap.cpp
+@@ -21,6 +21,7 @@
+ #include <stdint.h>
+ #include <sys/types.h>
+ #include <unistd.h>
++#include <algorithm>
+ 
+ #include <log/log.h>
+ 
+--- a/system/core/libbacktrace/UnwindStackMap.cpp
++++ b/system/core/libbacktrace/UnwindStackMap.cpp
+@@ -20,6 +20,7 @@
+ 
+ #include <string>
+ #include <vector>
++#include <algorithm>
+ 
+ #include <backtrace/BacktraceMap.h>
+ #include <unwindstack/Elf.h>
diff --git a/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/debian/Nonnull.patch b/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/debian/Nonnull.patch
new file mode 100644
index 0000000..8d1408a
--- /dev/null
+++ b/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/debian/Nonnull.patch
@@ -0,0 +1,20 @@
+Description: Bring Clang's _Nonnull keyword to GCC
+Author: Kai-Chung Yan
+Forwarded: not-needed
+--- a/system/core/adb/sysdeps.h
++++ b/system/core/adb/sysdeps.h
+@@ -40,11 +40,12 @@
+ #include "sysdeps/network.h"
+ #include "sysdeps/stat.h"
+ 
++#define _Nonnull
++#define _Nullable
++
+ #ifdef _WIN32
+ 
+ // Clang-only nullability specifiers
+-#define _Nonnull
+-#define _Nullable
+ 
+ #include <ctype.h>
+ #include <direct.h>
diff --git a/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/debian/Vector-cast.patch b/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/debian/Vector-cast.patch
new file mode 100644
index 0000000..b32d5f6
--- /dev/null
+++ b/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/debian/Vector-cast.patch
@@ -0,0 +1,14 @@
+Description: Fix the weird error by GCC7 that fails to match the correct parent method.
+Author: Kai-Chung Yan
+Forwarded: not-needed
+--- a/system/core/libutils/include/utils/Vector.h
++++ b/system/core/libutils/include/utils/Vector.h
+@@ -256,7 +256,7 @@
+ 
+ template<class TYPE> inline
+ const Vector<TYPE>& Vector<TYPE>::operator = (const Vector<TYPE>& rhs) const {
+-    VectorImpl::operator = (static_cast<const VectorImpl&>(rhs));
++    VectorImpl::operator = (rhs);
+     return *this;
+ }
+ 
diff --git a/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/debian/add-missing-headers.patch b/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/debian/add-missing-headers.patch
new file mode 100644
index 0000000..49d3ece
--- /dev/null
+++ b/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/debian/add-missing-headers.patch
@@ -0,0 +1,41 @@
+Forwarded: not-needed
+--- a/system/core/fs_mgr/liblp/reader.cpp
++++ b/system/core/fs_mgr/liblp/reader.cpp
+@@ -22,6 +22,7 @@
+ #include <unistd.h>
+ 
+ #include <functional>
++#include <cstring>
+ 
+ #include <android-base/file.h>
+ #include <android-base/unique_fd.h>
+--- a/system/core/fs_mgr/liblp/writer.cpp
++++ b/system/core/fs_mgr/liblp/writer.cpp
+@@ -21,6 +21,7 @@
+ #include <unistd.h>
+ 
+ #include <string>
++#include <cstring>
+ 
+ #include <android-base/file.h>
+ #include <android-base/unique_fd.h>
+--- a/system/core/liblog/logger_write.cpp
++++ b/system/core/liblog/logger_write.cpp
+@@ -27,6 +27,7 @@
+ #include <android/set_abort_message.h>
+ #endif
+ 
++#include <mutex>
+ #include <shared_mutex>
+ 
+ #include <android-base/errno_restorer.h>
+--- a/system/core/libziparchive/zip_archive_stream_entry.cc
++++ b/system/core/libziparchive/zip_archive_stream_entry.cc
+@@ -23,6 +23,7 @@
+ #include <sys/types.h>
+ #include <unistd.h>
+ 
++#include <limits>
+ #include <memory>
+ #include <vector>
+ 
diff --git a/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/debian/external/libunwind/20150704-CVE-2015-3239_dwarf_i.h.patch b/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/debian/external/libunwind/20150704-CVE-2015-3239_dwarf_i.h.patch
new file mode 100644
index 0000000..b926edd
--- /dev/null
+++ b/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/debian/external/libunwind/20150704-CVE-2015-3239_dwarf_i.h.patch
@@ -0,0 +1,13 @@
+Description: Off-by-one error in the dwarf_to_unw_regnum function in include/dwarf_i.h in
+libunwind 1.1 allows local users to have unspecified impact via invalid dwarf opcodes.
+--- a/external/libunwind/include/dwarf_i.h
++++ b/external/libunwind/include/dwarf_i.h
+@@ -20,7 +20,7 @@
+ extern const uint8_t dwarf_to_unw_regnum_map[DWARF_REGNUM_MAP_LENGTH];
+ /* REG is evaluated multiple times; it better be side-effects free!  */
+ # define dwarf_to_unw_regnum(reg)					  \
+-  (((reg) <= DWARF_REGNUM_MAP_LENGTH) ? dwarf_to_unw_regnum_map[reg] : 0)
++  (((reg) < DWARF_REGNUM_MAP_LENGTH) ? dwarf_to_unw_regnum_map[reg] : 0)
+ #endif
+ 
+ #ifdef UNW_LOCAL_ONLY
diff --git a/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/debian/external/libunwind/legacy_built-in_sync_functions.patch b/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/debian/external/libunwind/legacy_built-in_sync_functions.patch
new file mode 100644
index 0000000..ce1d4e5
--- /dev/null
+++ b/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/debian/external/libunwind/legacy_built-in_sync_functions.patch
@@ -0,0 +1,26 @@
+Description: Replace the legacy __sync built-in functions with __atomic ones
+ libunwind uses the built-in __sync_* functions which are deprecated by GCC and
+ should be replaced by __atomic_* ones. See the official manuals [1].
+ .
+ The legacy __sync functions do not require to specify the memory order but
+ __atomic ones do, so we choose the strongest one: __ATOMIC_SEQ_CST.
+ .
+ We do this because __sync_fetch_and_add() is not supported on armel.
+ .
+ [1]: https://gcc.gnu.org/onlinedocs/gcc/_005f_005fsync-Builtins.html
+Author: Kai-Chung Yan ()
+Last-Update: 2016-10-04
+Forwarded: not-needed
+--- a/external/libunwind/include/libunwind_i.h
++++ b/external/libunwind/include/libunwind_i.h
+@@ -155,8 +155,8 @@ cmpxchg_ptr (void *addr, void *old, void
+   u.vp = addr;
+   return __sync_bool_compare_and_swap(u.vlp, (long) old, (long) new);
+ }
+-# define fetch_and_add1(_ptr)		__sync_fetch_and_add(_ptr, 1)
+-# define fetch_and_add(_ptr, value)	__sync_fetch_and_add(_ptr, value)
++# define fetch_and_add1(_ptr) __atomic_fetch_add(_ptr, 1, __ATOMIC_SEQ_CST)
++# define fetch_and_add(_ptr, value) __atomic_fetch_add(_ptr, value, __ATOMIC_SEQ_CST)
+ # define HAVE_CMPXCHG
+ # define HAVE_FETCH_AND_ADD
+ #endif
diff --git a/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/debian/external/libunwind/user_pt_regs.patch b/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/debian/external/libunwind/user_pt_regs.patch
new file mode 100644
index 0000000..600471f
--- /dev/null
+++ b/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/debian/external/libunwind/user_pt_regs.patch
@@ -0,0 +1,24 @@
+Author: Kai-Chung Yan <seamlikok@gmail.com>
+Last-Update: 2016-08-24
+Description: Manual definition of struct user_pt_regs
+ On ARM64, libunwind uses struct user_pt_regs which is not defined in
+ anywhere, which causes FTBFS.
+Forwarded: not-needed
+--- a/external/libunwind/src/ptrace/_UPT_access_reg.c
++++ b/external/libunwind/src/ptrace/_UPT_access_reg.c
+@@ -26,6 +26,15 @@ WITH THE SOFTWARE OR THE USE OR OTHER DE
+ 
+ #include "_UPT_internal.h"
+ 
++#if defined(__aarch64__)
++  struct user_pt_regs {
++    __u64		regs[31];
++    __u64		sp;
++    __u64		pc;
++    __u64		pstate;
++  };
++#endif
++
+ #if UNW_TARGET_IA64
+ # include <elf.h>
+ # ifdef HAVE_ASM_PTRACE_OFFSETS_H
diff --git a/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/debian/fix-attribute-issue-with-gcc.patch b/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/debian/fix-attribute-issue-with-gcc.patch
new file mode 100644
index 0000000..e0b4275
--- /dev/null
+++ b/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/debian/fix-attribute-issue-with-gcc.patch
@@ -0,0 +1,17 @@
+Description: remove clang-ism
+Forwarded: not-needed
+
+--- a/system/core/base/include/android-base/logging.h
++++ b/system/core/base/include/android-base/logging.h
+@@ -451,10 +451,7 @@
+ //       -Wno-user-defined-warnings to CPPFLAGS.
+ #pragma clang diagnostic push
+ #pragma clang diagnostic ignored "-Wgcc-compat"
+-#define OSTREAM_STRING_POINTER_USAGE_WARNING \
+-    __attribute__((diagnose_if(true, "Unexpected logging of string pointer", "warning")))
+-inline OSTREAM_STRING_POINTER_USAGE_WARNING
+-std::ostream& operator<<(std::ostream& stream, const std::string* string_pointer) {
++inline std::ostream& operator<<(std::ostream& stream, const std::string* string_pointer) {
+   return stream << static_cast<const void*>(string_pointer);
+ }
+ #pragma clang diagnostic pop
diff --git a/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/debian/fix-build-on-non-x86.patch b/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/debian/fix-build-on-non-x86.patch
new file mode 100644
index 0000000..98a5078
--- /dev/null
+++ b/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/debian/fix-build-on-non-x86.patch
@@ -0,0 +1,24 @@
+Description: non-x86 arches do not have PAGE_SIZE
+Forwarded: not-needed
+--- a/system/core/base/cmsg.cpp
++++ b/system/core/base/cmsg.cpp
+@@ -33,7 +33,8 @@
+                                  const std::vector<int>& fds) {
+   size_t cmsg_space = CMSG_SPACE(sizeof(int) * fds.size());
+   size_t cmsg_len = CMSG_LEN(sizeof(int) * fds.size());
+-  if (cmsg_space >= PAGE_SIZE) {
++  size_t pagesize = static_cast<size_t>(sysconf(_SC_PAGE_SIZE));
++  if (cmsg_space >= pagesize) {
+     errno = ENOMEM;
+     return -1;
+   }
+@@ -75,7 +76,8 @@
+   fds->clear();
+ 
+   size_t cmsg_space = CMSG_SPACE(sizeof(int) * max_fds);
+-  if (cmsg_space >= PAGE_SIZE) {
++  size_t pagesize = static_cast<size_t>(sysconf(_SC_PAGE_SIZE));
++  if (cmsg_space >= pagesize) {
+     errno = ENOMEM;
+     return -1;
+   }
diff --git a/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/debian/fix-gettid-exception-declaration.patch b/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/debian/fix-gettid-exception-declaration.patch
new file mode 100644
index 0000000..7fd228b
--- /dev/null
+++ b/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/debian/fix-gettid-exception-declaration.patch
@@ -0,0 +1,24 @@
+Description: get libcutils building
+Forwarded: not-needed
+--- a/system/core/libcutils/include/cutils/threads.h
++++ b/system/core/libcutils/include/cutils/threads.h
+@@ -33,7 +33,7 @@
+ // Deprecated: use android::base::GetThreadId instead, which doesn't truncate on Mac/Windows.
+ //
+ 
+-extern pid_t gettid();
++extern pid_t gettid(void) __THROW;
+ 
+ //
+ // Deprecated: use `_Thread_local` in C or `thread_local` in C++.
+--- a/system/core/libcutils/threads.cpp
++++ b/system/core/libcutils/threads.cpp
+@@ -33,7 +33,7 @@
+ 
+ // No definition needed for Android because we'll just pick up bionic's copy.
+ #ifndef __ANDROID__
+-pid_t gettid() {
++pid_t gettid(void) __THROW {
+ #if defined(__APPLE__)
+   uint64_t tid;
+   pthread_threadid_np(NULL, &tid);
diff --git a/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/debian/fix-standard-namespace-errors.patch b/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/debian/fix-standard-namespace-errors.patch
new file mode 100644
index 0000000..e41a357
--- /dev/null
+++ b/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/debian/fix-standard-namespace-errors.patch
@@ -0,0 +1,22 @@
+Description: Add missing 'std::' scope identifiers.
+Forwarded: not-needed
+--- a/system/core/libunwindstack/include/unwindstack/DwarfMemory.h
++++ b/system/core/libunwindstack/include/unwindstack/DwarfMemory.h
+@@ -29,7 +29,7 @@
+   DwarfMemory(Memory* memory) : memory_(memory) {}
+   virtual ~DwarfMemory() = default;
+ 
+-  bool ReadBytes(void* dst, size_t num_bytes);
++  bool ReadBytes(void* dst, std::size_t num_bytes);
+ 
+   template <typename SignedType>
+   bool ReadSigned(uint64_t* value);
+@@ -39,7 +39,7 @@
+   bool ReadSLEB128(int64_t* value);
+ 
+   template <typename AddressType>
+-  size_t GetEncodedSize(uint8_t encoding);
++  std::size_t GetEncodedSize(uint8_t encoding);
+ 
+   bool AdjustEncodedValue(uint8_t encoding, uint64_t* value);
+ 
diff --git a/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/debian/hard-code-build-number.patch b/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/debian/hard-code-build-number.patch
new file mode 100644
index 0000000..2a332eb
--- /dev/null
+++ b/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/debian/hard-code-build-number.patch
@@ -0,0 +1,44 @@
+Description: just hard code rather than deal with circular deps
+Forwarded: not-needed
+--- a/system/core/adb/adb.cpp
++++ b/system/core/adb/adb.cpp
+@@ -44,8 +44,6 @@
+ #include <android-base/parsenetaddress.h>
+ #include <android-base/stringprintf.h>
+ #include <android-base/strings.h>
+-#include <build/version.h>
+-#include <platform_tools_version.h>
+ 
+ #include "adb_auth.h"
+ #include "adb_io.h"
+@@ -69,7 +67,7 @@
+         "Version %s-%s\n"
+         "Installed as %s\n",
+         ADB_VERSION_MAJOR, ADB_VERSION_MINOR, ADB_SERVER_VERSION,
+-        PLATFORM_TOOLS_VERSION, android::build::GetBuildNumber().c_str(),
++        PLATFORM_TOOLS_VERSION, "debian",
+         android::base::GetExecutablePath().c_str());
+ }
+ 
+--- a/system/core/fastboot/fastboot.cpp
++++ b/system/core/fastboot/fastboot.cpp
+@@ -59,10 +59,8 @@
+ #include <android-base/stringprintf.h>
+ #include <android-base/strings.h>
+ #include <android-base/unique_fd.h>
+-#include <build/version.h>
+ #include <libavb/libavb.h>
+ #include <liblp/liblp.h>
+-#include <platform_tools_version.h>
+ #include <sparse/sparse.h>
+ #include <ziparchive/zip_archive.h>
+ 
+@@ -1680,7 +1678,7 @@
+                 setvbuf(stdout, nullptr, _IONBF, 0);
+                 setvbuf(stderr, nullptr, _IONBF, 0);
+             } else if (name == "version") {
+-                fprintf(stdout, "fastboot version %s-%s\n", PLATFORM_TOOLS_VERSION, android::build::GetBuildNumber().c_str());
++                fprintf(stdout, "fastboot version %s-%s\n", PLATFORM_TOOLS_VERSION, "debian");
+                 fprintf(stdout, "Installed as %s\n", android::base::GetExecutablePath().c_str());
+                 return 0;
+ #if !defined(_WIN32)
diff --git a/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/debian/libusb-header-path.patch b/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/debian/libusb-header-path.patch
new file mode 100644
index 0000000..1663aae
--- /dev/null
+++ b/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/debian/libusb-header-path.patch
@@ -0,0 +1,16 @@
+Description: libusb.h comes from different location
+Author: Umang Parmar <umangjparmar@gmail.com>
+Forwarded: not-needed
+Last-Update: 2018-05-26
+
+--- a/system/core/adb/client/usb_libusb.cpp
++++ b/system/core/adb/client/usb_libusb.cpp
+@@ -30,7 +30,7 @@
+ #include <thread>
+ #include <unordered_map>
+ 
+-#include <libusb/libusb.h>
++#include <libusb-1.0/libusb.h>
+ 
+ #include <android-base/file.h>
+ #include <android-base/logging.h>
diff --git a/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/debian/move-log-file-to-proper-dir.patch b/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/debian/move-log-file-to-proper-dir.patch
new file mode 100644
index 0000000..006564b
--- /dev/null
+++ b/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/debian/move-log-file-to-proper-dir.patch
@@ -0,0 +1,18 @@
+Description: Update log file directory.
+Author: Umang Parmar <umangjparmar@gmail.com>
+Last Updated: 2018-05-17
+
+--- a/system/core/adb/adb_utils.cpp
++++ b/system/core/adb/adb_utils.cpp
+@@ -339,6 +339,11 @@
+ 
+     return temp_path_utf8 + log_name;
+ #else
++    std::string log_dir = android::base::StringPrintf("/run/user/%u/adb.log", getuid());
++    struct stat st = {0};
++    if (stat(log_dir.c_str(), &st) == 0) {
++      return log_dir;
++    }
+     const char* tmp_dir = getenv("TMPDIR");
+     if (tmp_dir == nullptr) tmp_dir = "/tmp";
+     return android::base::StringPrintf("%s/adb.%u.log", tmp_dir, getuid());
diff --git a/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/debian/simg_dump-python3.patch b/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/debian/simg_dump-python3.patch
new file mode 100644
index 0000000..e6933ef
--- /dev/null
+++ b/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/debian/simg_dump-python3.patch
@@ -0,0 +1,62 @@
+Description: Port simg_dump to Python 3.
+Author: Antonio Russo <antonio.e.russo@gmail.com>
+Forwarded: not-needed
+Last-Update: 2019-01-05
+Origin: https://bugs.debian.org/945646
+
+---
+Index: android-platform-tools/system/core/libsparse/simg_dump.py
+===================================================================
+--- android-platform-tools.orig/system/core/libsparse/simg_dump.py
++++ android-platform-tools/system/core/libsparse/simg_dump.py
+@@ -1,4 +1,4 @@
+-#! /usr/bin/env python
++#! /usr/bin/env python3
+ 
+ # Copyright (C) 2012 The Android Open Source Project
+ #
+@@ -14,7 +14,7 @@
+ # See the License for the specific language governing permissions and
+ # limitations under the License.
+ 
+-from __future__ import print_function
++
+ import csv
+ import getopt
+ import hashlib
+@@ -47,7 +47,7 @@ def main():
+     opts, args = getopt.getopt(sys.argv[1:],
+                                "vsc:",
+                                ["verbose", "showhash", "csvfile"])
+-  except getopt.GetoptError, e:
++  except getopt.GetoptError as e:
+     print(e)
+     usage(me)
+   for o, a in opts:
+@@ -66,7 +66,7 @@ def main():
+     usage(me)
+ 
+   if csvfilename:
+-    csvfile = open(csvfilename, "wb")
++    csvfile = open(csvfilename, "w", newline='')
+     csvwriter = csv.writer(csvfile)
+ 
+   output = verbose or csvfilename or showhash
+@@ -121,7 +121,7 @@ def main():
+                           "output offset", "output blocks", "type", "hash"])
+ 
+     offset = 0
+-    for i in xrange(1, total_chunks + 1):
++    for i in range(1, total_chunks + 1):
+       header_bin = FH.read(12)
+       header = struct.unpack("<2H2I", header_bin)
+       chunk_type = header[0]
+@@ -160,7 +160,7 @@ def main():
+           if showhash:
+             h = hashlib.sha1()
+             data = fill_bin * (blk_sz / 4);
+-            for block in xrange(chunk_sz):
++            for block in range(chunk_sz):
+               h.update(data)
+             curhash = h.hexdigest()
+       elif chunk_type == 0xCAC3:
diff --git a/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/debian/stdatomic.patch b/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/debian/stdatomic.patch
new file mode 100644
index 0000000..ea3711d
--- /dev/null
+++ b/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/debian/stdatomic.patch
@@ -0,0 +1,64 @@
+Description: Fix incompatibility between <stdatomic.h> and <atomic>
+ This 2 headers combined will cause errors for both GCC and Clang. This patch
+ makes sure only one of them is present at any time.
+Bug: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=60932
+Bug: https://reviews.llvm.org/D45470
+--- a/system/core/libcutils/include/cutils/trace.h
++++ b/system/core/libcutils/include/cutils/trace.h
+@@ -18,7 +18,14 @@
+ #define _LIBS_CUTILS_TRACE_H
+ 
+ #include <inttypes.h>
++#ifdef __cplusplus
++#include <atomic>
++using std::atomic_bool;
++using std::atomic_load_explicit;
++using std::memory_order_acquire;
++#else
+ #include <stdatomic.h>
++#endif
+ #include <stdbool.h>
+ #include <stdint.h>
+ #include <stdio.h>
+--- a/system/core/libcutils/include/cutils/atomic.h
++++ b/system/core/libcutils/include/cutils/atomic.h
+@@ -19,7 +19,23 @@
+ 
+ #include <stdint.h>
+ #include <sys/types.h>
++#ifdef __cplusplus
++#include <atomic>
++using std::atomic_compare_exchange_strong_explicit;
++using std::atomic_fetch_add_explicit;
++using std::atomic_fetch_or_explicit;
++using std::atomic_fetch_sub_explicit;
++using std::atomic_int_least32_t;
++using std::atomic_load_explicit;
++using std::atomic_store_explicit;
++using std::atomic_thread_fence;
++using std::memory_order::memory_order_acquire;
++using std::memory_order::memory_order_relaxed;
++using std::memory_order::memory_order_release;
++using std::memory_order::memory_order_seq_cst;
++#else
+ #include <stdatomic.h>
++#endif
+ 
+ #ifndef ANDROID_ATOMIC_INLINE
+ #define ANDROID_ATOMIC_INLINE static inline
+--- a/system/core/liblog/logger.h
++++ b/system/core/liblog/logger.h
+@@ -16,7 +16,13 @@
+ 
+ #pragma once
+ 
++#ifdef __cplusplus
++#include <atomic>
++using std::atomic_int;
++using std::atomic_uintptr_t;
++#else
+ #include <stdatomic.h>
++#endif
+ #include <sys/cdefs.h>
+ 
+ #include <log/log.h>
diff --git a/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/debian/stub-out-fastdeploy.patch b/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/debian/stub-out-fastdeploy.patch
new file mode 100644
index 0000000..d2426a7
--- /dev/null
+++ b/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/debian/stub-out-fastdeploy.patch
@@ -0,0 +1,93 @@
+Description: Defer packaging fastdeploy with adb for 29.x.x tags.
+Forwarded: not-needed
+--- a/system/core/adb/client/commandline.cpp
++++ b/system/core/adb/client/commandline.cpp
+@@ -59,7 +59,6 @@
+ #include "bugreport.h"
+ #include "client/file_sync_client.h"
+ #include "commandline.h"
+-#include "fastdeploy.h"
+ #include "services.h"
+ #include "shell_protocol.h"
+ #include "sysdeps/chrono.h"
+--- a/system/core/adb/client/adb_install.cpp
++++ b/system/core/adb/client/adb_install.cpp
+@@ -35,7 +35,6 @@
+ #include "adb_utils.h"
+ #include "client/file_sync_client.h"
+ #include "commandline.h"
+-#include "fastdeploy.h"
+ 
+ static constexpr int kFastDeployMinApi = 24;
+ 
+@@ -167,14 +166,6 @@
+     }
+ 
+     if (use_fastdeploy) {
+-        auto metadata = extract_metadata(file);
+-        if (metadata.has_value()) {
+-            // pass all but 1st (command) and last (apk path) parameters through to pm for
+-            // session creation
+-            std::vector<const char*> pm_args{argv + 1, argv + argc - 1};
+-            auto patchFd = install_patch(pm_args.size(), pm_args.data());
+-            return stream_patch(file, std::move(metadata.value()), std::move(patchFd));
+-        }
+     }
+ 
+     struct stat sb;
+@@ -267,16 +258,6 @@
+     argv[last_apk] = apk_dest.c_str(); /* destination name, not source location */
+ 
+     if (use_fastdeploy) {
+-        auto metadata = extract_metadata(apk_file[0]);
+-        if (metadata.has_value()) {
+-            auto patchFd = apply_patch_on_device(apk_dest.c_str());
+-            int status = stream_patch(apk_file[0], std::move(metadata.value()), std::move(patchFd));
+-
+-            result = pm_command(argc, argv);
+-            delete_device_file(apk_dest);
+-
+-            return status;
+-        }
+     }
+ 
+     if (do_sync_push(apk_file, apk_dest.c_str(), false)) {
+@@ -292,7 +273,6 @@
+     InstallMode installMode = INSTALL_DEFAULT;
+     bool use_fastdeploy = false;
+     bool is_reinstall = false;
+-    FastDeploy_AgentUpdateStrategy agent_update_strategy = FastDeploy_AgentUpdateDifferentVersion;
+ 
+     for (int i = 1; i < argc; i++) {
+         if (!strcmp(argv[i], "--streaming")) {
+@@ -313,13 +293,10 @@
+             use_fastdeploy = false;
+         } else if (!strcmp(argv[i], "--force-agent")) {
+             processedArgIndicies.push_back(i);
+-            agent_update_strategy = FastDeploy_AgentUpdateAlways;
+         } else if (!strcmp(argv[i], "--date-check-agent")) {
+             processedArgIndicies.push_back(i);
+-            agent_update_strategy = FastDeploy_AgentUpdateNewerTimeStamp;
+         } else if (!strcmp(argv[i], "--version-check-agent")) {
+             processedArgIndicies.push_back(i);
+-            agent_update_strategy = FastDeploy_AgentUpdateDifferentVersion;
+         }
+     }
+ 
+@@ -331,13 +308,11 @@
+         error_exit("Attempting to use streaming install on unsupported device");
+     }
+ 
+-    if (use_fastdeploy && get_device_api_level() < kFastDeployMinApi) {
+-        printf("Fast Deploy is only compatible with devices of API version %d or higher, "
+-               "ignoring.\n",
+-               kFastDeployMinApi);
++    if (use_fastdeploy) {
++        printf("Fast Deploy is unavailable in this build of adb, "
++               "ignoring.\n");
+         use_fastdeploy = false;
+     }
+-    fastdeploy_set_agent_update_strategy(agent_update_strategy);
+ 
+     std::vector<const char*> passthrough_argv;
+     for (int i = 0; i < argc; i++) {
diff --git a/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/debian/system/core/Add-riscv64-support.patch b/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/debian/system/core/Add-riscv64-support.patch
new file mode 100644
index 0000000..4669f89
--- /dev/null
+++ b/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/debian/system/core/Add-riscv64-support.patch
@@ -0,0 +1,651 @@
+From: Guo Ren <guoren@linux.alibaba.com>
+Date: Wed, 29 Jun 2022 16:46:46 +0800
+Subject: Add riscv64 support
+
+This patch contains the dwarf unwind support for 64bit risc-v.
+
+    * DwarfCfa.cpp (cfa_def_cfa_register): setup register if CFA_REG is
+    not setup for riscv64
+    * Elf.cpp (GetRelPc): convert offset to virtual address for riscv64.
+    * ElfInterface.cpp (GetVirtAddrFromOffset): New for riscv64.
+    * RegsRiscv64.cpp (StepIfSignalHandler): Fix signal frame check.
+    libunwindstack/include/unwindstack/
+    * ElfInterface.h (GetVirtAddrFromOffset): New for riscv64.
+    libunwindstack/tests/
+    * DwarfCfaTest.cpp (cfa_def_cfa_register): ok for riscv64.
+    * RegsStepIfSignalHandlerTest.cpp (riscv64_step_if_signal_handler): Fix
+    testcase for riscv64
+
+Test: Builds.
+Test: All unit tests pass.
+
+Signed-off-by: Guo Ren <guoren@linux.alibaba.com>
+Signed-off-by: Lifang Xia <lifang_xia@linux.alibaba.com>
+Signed-off-by: Mao Han <han_mao@linux.alibaba.com>
+Change-Id: Ib21ddf23cc83f332af202df7bffcaceec16063e0
+---
+ system/core/libunwindstack/Android.bp              |   1 +
+ system/core/libunwindstack/Elf.cpp                 |   2 +
+ system/core/libunwindstack/Regs.cpp                |  10 ++
+ system/core/libunwindstack/RegsRiscv64.cpp         | 156 +++++++++++++++++++++
+ .../core/libunwindstack/include/unwindstack/Elf.h  |   5 +
+ .../include/unwindstack/MachineRiscv64.h           |  59 ++++++++
+ .../include/unwindstack/RegsGetLocal.h             |  43 ++++++
+ .../include/unwindstack/RegsRiscv64.h              |  59 ++++++++
+ .../include/unwindstack/UcontextRiscv64.h          |  80 +++++++++++
+ .../include/unwindstack/UserRiscv64.h              |  37 +++++
+ system/core/libunwindstack/tools/unwind.cpp        |   3 +
+ .../core/libunwindstack/tools/unwind_symbols.cpp   |   3 +
+ 12 files changed, 458 insertions(+)
+ create mode 100644 system/core/libunwindstack/RegsRiscv64.cpp
+ create mode 100644 system/core/libunwindstack/include/unwindstack/MachineRiscv64.h
+ create mode 100644 system/core/libunwindstack/include/unwindstack/RegsRiscv64.h
+ create mode 100644 system/core/libunwindstack/include/unwindstack/UcontextRiscv64.h
+ create mode 100644 system/core/libunwindstack/include/unwindstack/UserRiscv64.h
+
+diff --git a/system/core/libunwindstack/Android.bp b/system/core/libunwindstack/Android.bp
+index 3695f72..f1f9c68 100644
+--- a/system/core/libunwindstack/Android.bp
++++ b/system/core/libunwindstack/Android.bp
+@@ -70,6 +70,7 @@ cc_library {
+         "RegsArm64.cpp",
+         "RegsX86.cpp",
+         "RegsX86_64.cpp",
++        "RegsRiscv64.cpp",
+         "RegsMips.cpp",
+         "RegsMips64.cpp",
+         "Unwinder.cpp",
+diff --git a/system/core/libunwindstack/Elf.cpp b/system/core/libunwindstack/Elf.cpp
+index f01b092..3c2088b 100644
+--- a/system/core/libunwindstack/Elf.cpp
++++ b/system/core/libunwindstack/Elf.cpp
+@@ -290,6 +290,8 @@ ElfInterface* Elf::CreateInterfaceFromMemory(Memory* memory) {
+       arch_ = ARCH_X86_64;
+     } else if (e_machine == EM_MIPS) {
+       arch_ = ARCH_MIPS64;
++    } else if (e_machine == EM_RISCV) {
++      arch_ = ARCH_RISCV64;
+     } else {
+       // Unsupported.
+       ALOGI("64 bit elf that is neither aarch64 nor x86_64 nor mips64: e_machine = %d\n",
+diff --git a/system/core/libunwindstack/Regs.cpp b/system/core/libunwindstack/Regs.cpp
+index c7dec52..447a554 100644
+--- a/system/core/libunwindstack/Regs.cpp
++++ b/system/core/libunwindstack/Regs.cpp
+@@ -27,12 +27,14 @@
+ #include <unwindstack/RegsArm64.h>
+ #include <unwindstack/RegsMips.h>
+ #include <unwindstack/RegsMips64.h>
++#include <unwindstack/RegsRiscv64.h>
+ #include <unwindstack/RegsX86.h>
+ #include <unwindstack/RegsX86_64.h>
+ #include <unwindstack/UserArm.h>
+ #include <unwindstack/UserArm64.h>
+ #include <unwindstack/UserMips.h>
+ #include <unwindstack/UserMips64.h>
++#include <unwindstack/UserRiscv64.h>
+ #include <unwindstack/UserX86.h>
+ #include <unwindstack/UserX86_64.h>
+ 
+@@ -67,6 +69,8 @@ Regs* Regs::RemoteGet(pid_t pid) {
+     return RegsMips::Read(buffer.data());
+   case sizeof(mips64_user_regs):
+     return RegsMips64::Read(buffer.data());
++  case sizeof(riscv64_user_regs):
++    return RegsRiscv64::Read(buffer.data());
+   }
+   return nullptr;
+ }
+@@ -85,6 +89,8 @@ Regs* Regs::CreateFromUcontext(ArchEnum arch, void* ucontext) {
+       return RegsMips::CreateFromUcontext(ucontext);
+     case ARCH_MIPS64:
+       return RegsMips64::CreateFromUcontext(ucontext);
++    case ARCH_RISCV64:
++      return RegsRiscv64::CreateFromUcontext(ucontext);
+     case ARCH_UNKNOWN:
+     default:
+       return nullptr;
+@@ -104,6 +110,8 @@ ArchEnum Regs::CurrentArch() {
+   return ARCH_MIPS;
+ #elif defined(__mips__) && defined(__LP64__)
+   return ARCH_MIPS64;
++#elif defined(__riscv)
++  return ARCH_RISCV64;
+ #else
+   abort();
+ #endif
+@@ -123,6 +131,8 @@ Regs* Regs::CreateFromLocal() {
+   regs = new RegsMips();
+ #elif defined(__mips__) && defined(__LP64__)
+   regs = new RegsMips64();
++#elif defined(__riscv)
++  regs = new RegsRiscv64();
+ #else
+   abort();
+ #endif
+diff --git a/system/core/libunwindstack/RegsRiscv64.cpp b/system/core/libunwindstack/RegsRiscv64.cpp
+new file mode 100644
+index 0000000..887762a
+--- /dev/null
++++ b/system/core/libunwindstack/RegsRiscv64.cpp
+@@ -0,0 +1,156 @@
++/*
++ * Copyright (C) 2022 The Android Open Source Project
++ *
++ * Licensed under the Apache License, Version 2.0 (the "License");
++ * you may not use this file except in compliance with the License.
++ * You may obtain a copy of the License at
++ *
++ *      http://www.apache.org/licenses/LICENSE-2.0
++ *
++ * Unless required by applicable law or agreed to in writing, software
++ * distributed under the License is distributed on an "AS IS" BASIS,
++ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
++ * See the License for the specific language governing permissions and
++ * limitations under the License.
++ */
++
++#include <stdint.h>
++#include <string.h>
++
++#include <functional>
++
++#include <unwindstack/Elf.h>
++#include <unwindstack/MachineRiscv64.h>
++#include <unwindstack/MapInfo.h>
++#include <unwindstack/Memory.h>
++#include <unwindstack/RegsRiscv64.h>
++#include <unwindstack/UcontextRiscv64.h>
++#include <unwindstack/UserRiscv64.h>
++
++namespace unwindstack {
++
++RegsRiscv64::RegsRiscv64()
++    : RegsImpl<uint64_t>(RISCV64_REG_MAX, Location(LOCATION_REGISTER, RISCV64_REG_RA)) {}
++
++ArchEnum RegsRiscv64::Arch() {
++  return ARCH_RISCV64;
++}
++
++uint64_t RegsRiscv64::pc() {
++  return regs_[RISCV64_REG_PC];
++}
++
++uint64_t RegsRiscv64::sp() {
++  return regs_[RISCV64_REG_SP];
++}
++
++void RegsRiscv64::set_pc(uint64_t pc) {
++  regs_[RISCV64_REG_PC] = pc;
++}
++
++void RegsRiscv64::set_sp(uint64_t sp) {
++  regs_[RISCV64_REG_SP] = sp;
++}
++
++uint64_t RegsRiscv64::GetPcAdjustment(uint64_t rel_pc, Elf*) {
++  if (rel_pc < 8) {
++    return 0;
++  }
++  // For now, just assume no compact branches
++  return 8;
++}
++
++bool RegsRiscv64::SetPcFromReturnAddress(Memory*) {
++  uint64_t ra = regs_[RISCV64_REG_RA];
++  if (regs_[RISCV64_REG_PC] == ra) {
++    return false;
++  }
++
++  regs_[RISCV64_REG_PC] = ra;
++  return true;
++}
++
++void RegsRiscv64::IterateRegisters(std::function<void(const char*, uint64_t)> fn) {
++  fn("pc", regs_[RISCV64_REG_PC]);
++  fn("ra", regs_[RISCV64_REG_RA]);
++  fn("sp", regs_[RISCV64_REG_SP]);
++  fn("gp", regs_[RISCV64_REG_GP]);
++  fn("tp", regs_[RISCV64_REG_TP]);
++  fn("t0", regs_[RISCV64_REG_T0]);
++  fn("t1", regs_[RISCV64_REG_T1]);
++  fn("t2", regs_[RISCV64_REG_T2]);
++  fn("t3", regs_[RISCV64_REG_T3]);
++  fn("t4", regs_[RISCV64_REG_T4]);
++  fn("t5", regs_[RISCV64_REG_T5]);
++  fn("t6", regs_[RISCV64_REG_T6]);
++  fn("s0", regs_[RISCV64_REG_S0]);
++  fn("s1", regs_[RISCV64_REG_S1]);
++  fn("s2", regs_[RISCV64_REG_S2]);
++  fn("s3", regs_[RISCV64_REG_S3]);
++  fn("s4", regs_[RISCV64_REG_S4]);
++  fn("s5", regs_[RISCV64_REG_S5]);
++  fn("s6", regs_[RISCV64_REG_S6]);
++  fn("s7", regs_[RISCV64_REG_S7]);
++  fn("s8", regs_[RISCV64_REG_S8]);
++  fn("s9", regs_[RISCV64_REG_S9]);
++  fn("s10", regs_[RISCV64_REG_S10]);
++  fn("s11", regs_[RISCV64_REG_S11]);
++  fn("a0", regs_[RISCV64_REG_A0]);
++  fn("a1", regs_[RISCV64_REG_A1]);
++  fn("a2", regs_[RISCV64_REG_A2]);
++  fn("a3", regs_[RISCV64_REG_A3]);
++  fn("a4", regs_[RISCV64_REG_A4]);
++  fn("a5", regs_[RISCV64_REG_A5]);
++  fn("a6", regs_[RISCV64_REG_A6]);
++  fn("a7", regs_[RISCV64_REG_A7]);
++}
++
++Regs* RegsRiscv64::Read(void* remote_data) {
++  riscv64_user_regs* user = reinterpret_cast<riscv64_user_regs*>(remote_data);
++
++  RegsRiscv64* regs = new RegsRiscv64();
++  memcpy(regs->RawData(), &user->regs[0], RISCV64_REG_MAX * sizeof(uint64_t));
++  // uint64_t* reg_data = reinterpret_cast<uint64_t*>(regs->RawData());
++  return regs;
++}
++
++Regs* RegsRiscv64::CreateFromUcontext(void* ucontext) {
++  riscv64_ucontext_t* riscv64_ucontext = reinterpret_cast<riscv64_ucontext_t*>(ucontext);
++
++  RegsRiscv64* regs = new RegsRiscv64();
++  memcpy(regs->RawData(), &riscv64_ucontext->uc_mcontext.__gregs[0],
++         RISCV64_REG_MAX * sizeof(uint64_t));
++  return regs;
++}
++
++bool RegsRiscv64::StepIfSignalHandler(uint64_t elf_offset, Elf* elf, Memory* process_memory) {
++  uint64_t data;
++  Memory* elf_memory = elf->memory();
++  // Read from elf memory since it is usually more expensive to read from
++  // process memory.
++  if (!elf_memory->ReadFully(elf_offset, &data, sizeof(data))) {
++    return false;
++  }
++  // Look for the kernel sigreturn function.
++  // __kernel_rt_sigreturn:
++  // li a7, __NR_rt_sigreturn
++  // scall
++
++  const uint8_t li_scall[] = {0x93, 0x08, 0xb0, 0x08, 0x73, 0x00, 0x00, 0x00};
++  if (memcmp(&data, &li_scall, 8) != 0) {
++    return false;
++  }
++
++  // SP + sizeof(siginfo_t) + uc_mcontext offset + PC offset.
++  if (!process_memory->ReadFully(regs_[RISCV64_REG_SP] + 0x80 + 0xb0 + 0x00, regs_.data(),
++                                 sizeof(uint64_t) * (RISCV64_REG_MAX))) {
++    return false;
++  }
++  return true;
++}
++
++Regs* RegsRiscv64::Clone() {
++  return new RegsRiscv64(*this);
++}
++
++}  // namespace unwindstack
+diff --git a/system/core/libunwindstack/include/unwindstack/Elf.h b/system/core/libunwindstack/include/unwindstack/Elf.h
+index 472ed92..88fa0ff 100644
+--- a/system/core/libunwindstack/include/unwindstack/Elf.h
++++ b/system/core/libunwindstack/include/unwindstack/Elf.h
+@@ -32,6 +32,10 @@
+ #define EM_AARCH64 183
+ #endif
+ 
++#if !defined(EM_RISCV)
++#define EM_RISCV 243
++#endif
++
+ namespace unwindstack {
+ 
+ // Forward declaration.
+@@ -46,6 +50,7 @@ enum ArchEnum : uint8_t {
+   ARCH_X86_64,
+   ARCH_MIPS,
+   ARCH_MIPS64,
++  ARCH_RISCV64,
+ };
+ 
+ class Elf {
+diff --git a/system/core/libunwindstack/include/unwindstack/MachineRiscv64.h b/system/core/libunwindstack/include/unwindstack/MachineRiscv64.h
+new file mode 100644
+index 0000000..397e680
+--- /dev/null
++++ b/system/core/libunwindstack/include/unwindstack/MachineRiscv64.h
+@@ -0,0 +1,59 @@
++/*
++ * Copyright (C) 2022 The Android Open Source Project
++ *
++ * Licensed under the Apache License, Version 2.0 (the "License");
++ * you may not use this file except in compliance with the License.
++ * You may obtain a copy of the License at
++ *
++ *      http://www.apache.org/licenses/LICENSE-2.0
++ *
++ * Unless required by applicable law or agreed to in writing, software
++ * distributed under the License is distributed on an "AS IS" BASIS,
++ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
++ * See the License for the specific language governing permissions and
++ * limitations under the License.
++ */
++
++#pragma once
++
++#include <stdint.h>
++
++namespace unwindstack {
++
++enum Riscv64Reg : uint16_t {
++  RISCV64_REG_PC,
++  RISCV64_REG_RA,
++  RISCV64_REG_SP,
++  RISCV64_REG_GP,
++  RISCV64_REG_TP,
++  RISCV64_REG_T0,
++  RISCV64_REG_T1,
++  RISCV64_REG_T2,
++  RISCV64_REG_S0,
++  RISCV64_REG_S1,
++  RISCV64_REG_A0,
++  RISCV64_REG_A1,
++  RISCV64_REG_A2,
++  RISCV64_REG_A3,
++  RISCV64_REG_A4,
++  RISCV64_REG_A5,
++  RISCV64_REG_A6,
++  RISCV64_REG_A7,
++  RISCV64_REG_S2,
++  RISCV64_REG_S3,
++  RISCV64_REG_S4,
++  RISCV64_REG_S5,
++  RISCV64_REG_S6,
++  RISCV64_REG_S7,
++  RISCV64_REG_S8,
++  RISCV64_REG_S9,
++  RISCV64_REG_S10,
++  RISCV64_REG_S11,
++  RISCV64_REG_T3,
++  RISCV64_REG_T4,
++  RISCV64_REG_T5,
++  RISCV64_REG_T6,
++  RISCV64_REG_MAX,
++};
++
++}  // namespace unwindstack
+diff --git a/system/core/libunwindstack/include/unwindstack/RegsGetLocal.h b/system/core/libunwindstack/include/unwindstack/RegsGetLocal.h
+index f0b5e3a..698eba2 100644
+--- a/system/core/libunwindstack/include/unwindstack/RegsGetLocal.h
++++ b/system/core/libunwindstack/include/unwindstack/RegsGetLocal.h
+@@ -81,6 +81,49 @@ inline __attribute__((__always_inline__)) void AsmGetRegs(void* reg_data) {
+       : "x12", "x13", "memory");
+ }
+ 
++#elif defined(__riscv)
++
++inline __attribute__((__always_inline__)) void AsmGetRegs(void* reg_data) {
++  asm volatile(
++      "1:\n"
++      "sd ra, 8(%[base])\n"
++      "sd sp, 16(%[base])\n"
++      "sd gp, 24(%[base])\n"
++      "sd tp, 32(%[base])\n"
++      "sd t0, 40(%[base])\n"
++      "sd t1, 48(%[base])\n"
++      "sd t2, 56(%[base])\n"
++      "sd s0, 64(%[base])\n"
++      "sd s1, 72(%[base])\n"
++      "sd a0, 80(%[base])\n"
++      "sd a1, 88(%[base])\n"
++      "sd a2, 96(%[base])\n"
++      "sd a3, 104(%[base])\n"
++      "sd a4, 112(%[base])\n"
++      "sd a5, 120(%[base])\n"
++      "sd a6, 128(%[base])\n"
++      "sd a7, 136(%[base])\n"
++      "sd s2, 144(%[base])\n"
++      "sd s3, 152(%[base])\n"
++      "sd s4, 160(%[base])\n"
++      "sd s5, 168(%[base])\n"
++      "sd s6, 176(%[base])\n"
++      "sd s7, 184(%[base])\n"
++      "sd s8, 192(%[base])\n"
++      "sd s9, 200(%[base])\n"
++      "sd s10, 208(%[base])\n"
++      "sd s11, 216(%[base])\n"
++      "sd t3, 224(%[base])\n"
++      "sd t4, 232(%[base])\n"
++      "sd t5, 240(%[base])\n"
++      "sd t6, 248(%[base])\n"
++      "la t1, 1b\n"
++      "sd t1, 0(%[base])\n"
++      : [base] "+r"(reg_data)
++      :
++      : "t1", "memory");
++}
++
+ #elif defined(__i386__) || defined(__x86_64__) || defined(__mips__)
+ 
+ extern "C" void AsmGetRegs(void* regs);
+diff --git a/system/core/libunwindstack/include/unwindstack/RegsRiscv64.h b/system/core/libunwindstack/include/unwindstack/RegsRiscv64.h
+new file mode 100644
+index 0000000..eb09397
+--- /dev/null
++++ b/system/core/libunwindstack/include/unwindstack/RegsRiscv64.h
+@@ -0,0 +1,59 @@
++/*
++ * Copyright (C) 2022 The Android Open Source Project
++ *
++ * Licensed under the Apache License, Version 2.0 (the "License");
++ * you may not use this file except in compliance with the License.
++ * You may obtain a copy of the License at
++ *
++ *      http://www.apache.org/licenses/LICENSE-2.0
++ *
++ * Unless required by applicable law or agreed to in writing, software
++ * distributed under the License is distributed on an "AS IS" BASIS,
++ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
++ * See the License for the specific language governing permissions and
++ * limitations under the License.
++ */
++
++#pragma once
++
++#include <stdint.h>
++
++#include <functional>
++
++#include <unwindstack/Elf.h>
++#include <unwindstack/Regs.h>
++
++namespace unwindstack {
++
++// Forward declarations.
++class Memory;
++
++class RegsRiscv64 : public RegsImpl<uint64_t> {
++ public:
++  RegsRiscv64();
++  virtual ~RegsRiscv64() = default;
++
++  ArchEnum Arch() override final;
++
++  uint64_t GetPcAdjustment(uint64_t rel_pc, Elf* elf) override;
++
++  bool SetPcFromReturnAddress(Memory* process_memory) override;
++
++  bool StepIfSignalHandler(uint64_t elf_offset, Elf* elf, Memory* process_memory) override;
++
++  void IterateRegisters(std::function<void(const char*, uint64_t)>) override final;
++
++  uint64_t pc() override;
++  uint64_t sp() override;
++
++  void set_pc(uint64_t pc) override;
++  void set_sp(uint64_t sp) override;
++
++  Regs* Clone() override final;
++
++  static Regs* Read(void* data);
++
++  static Regs* CreateFromUcontext(void* ucontext);
++};
++
++}  // namespace unwindstack
+diff --git a/system/core/libunwindstack/include/unwindstack/UcontextRiscv64.h b/system/core/libunwindstack/include/unwindstack/UcontextRiscv64.h
+new file mode 100644
+index 0000000..c6c82b1
+--- /dev/null
++++ b/system/core/libunwindstack/include/unwindstack/UcontextRiscv64.h
+@@ -0,0 +1,80 @@
++/*
++ * Copyright (C) 2014 The Android Open Source Project
++ * All rights reserved.
++ *
++ * Redistribution and use in source and binary forms, with or without
++ * modification, are permitted provided that the following conditions
++ * are met:
++ *  * Redistributions of source code must retain the above copyright
++ *    notice, this list of conditions and the following disclaimer.
++ *  * Redistributions in binary form must reproduce the above copyright
++ *    notice, this list of conditions and the following disclaimer in
++ *    the documentation and/or other materials provided with the
++ *    distribution.
++ *
++ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
++ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
++ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
++ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
++ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
++ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
++ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
++ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
++ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
++ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
++ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
++ * SUCH DAMAGE.
++ */
++
++#pragma once
++
++#include <sys/cdefs.h>
++
++typedef uint64_t __riscv_mc_gp_state[32];  // unsigned long
++
++struct __riscv_mc_f_ext_state {
++  uint32_t __f[32];
++  uint32_t __fcsr;
++};
++
++struct __riscv_mc_d_ext_state {
++  uint64_t __f[32];
++  uint32_t __fcsr;
++};
++
++struct __riscv_mc_q_ext_state {
++  uint64_t __f[64] __attribute__((__aligned__(16)));
++  uint32_t __fcsr;
++  uint32_t __reserved[3];
++};
++
++union __riscv_mc_fp_state {
++  struct __riscv_mc_f_ext_state __f;
++  struct __riscv_mc_d_ext_state __d;
++  struct __riscv_mc_q_ext_state __q;
++};
++
++struct __riscv_stack_t {
++  uint64_t ss_sp;
++  int32_t ss_flags;
++  uint64_t ss_size;
++};
++
++struct riscv64_sigset_t {
++  uint64_t sig;  // unsigned long
++};
++
++struct riscv64_mcontext_t {
++  __riscv_mc_gp_state __gregs;
++  union __riscv_mc_fp_state __fpregs;
++};
++
++struct riscv64_ucontext_t {
++  uint64_t uc_flags;  // unsigned long
++  struct riscv64_ucontext_t* uc_link;
++  __riscv_stack_t uc_stack;
++  riscv64_sigset_t uc_sigmask;
++  /* The kernel adds extra padding here to allow sigset_t to grow. */
++  int8_t __padding[128 - sizeof(riscv64_sigset_t)];  // char
++  riscv64_mcontext_t uc_mcontext;
++};
+diff --git a/system/core/libunwindstack/include/unwindstack/UserRiscv64.h b/system/core/libunwindstack/include/unwindstack/UserRiscv64.h
+new file mode 100644
+index 0000000..1e91228
+--- /dev/null
++++ b/system/core/libunwindstack/include/unwindstack/UserRiscv64.h
+@@ -0,0 +1,37 @@
++/*
++ * Copyright (C) 2016 The Android Open Source Project
++ * All rights reserved.
++ *
++ * Redistribution and use in source and binary forms, with or without
++ * modification, are permitted provided that the following conditions
++ * are met:
++ *  * Redistributions of source code must retain the above copyright
++ *    notice, this list of conditions and the following disclaimer.
++ *  * Redistributions in binary form must reproduce the above copyright
++ *    notice, this list of conditions and the following disclaimer in
++ *    the documentation and/or other materials provided with the
++ *    distribution.
++ *
++ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
++ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
++ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
++ * FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
++ * COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
++ * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
++ * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
++ * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
++ * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
++ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
++ * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
++ * SUCH DAMAGE.
++ */
++
++#pragma once
++
++namespace unwindstack {
++
++struct riscv64_user_regs {
++  uint64_t regs[32];
++};
++
++}  // namespace unwindstack
+diff --git a/system/core/libunwindstack/tools/unwind.cpp b/system/core/libunwindstack/tools/unwind.cpp
+index 1812e50..ae20891 100644
+--- a/system/core/libunwindstack/tools/unwind.cpp
++++ b/system/core/libunwindstack/tools/unwind.cpp
+@@ -83,6 +83,9 @@ void DoUnwind(pid_t pid) {
+     case unwindstack::ARCH_MIPS64:
+       printf("mips64");
+       break;
++    case unwindstack::ARCH_RISCV64:
++      printf("riscv64");
++      break;
+     default:
+       printf("unknown\n");
+       return;
+diff --git a/system/core/libunwindstack/tools/unwind_symbols.cpp b/system/core/libunwindstack/tools/unwind_symbols.cpp
+index 8df2284..976db56 100644
+--- a/system/core/libunwindstack/tools/unwind_symbols.cpp
++++ b/system/core/libunwindstack/tools/unwind_symbols.cpp
+@@ -77,6 +77,9 @@ int main(int argc, char** argv) {
+     case EM_AARCH64:
+       printf("ABI: arm64\n");
+       break;
++    case EM_RISCV:
++      printf("ABI: riscv64\n");
++      break;
+     case EM_386:
+       printf("ABI: x86\n");
+       break;
diff --git a/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/debian/system/core/Added-missing-headers.patch b/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/debian/system/core/Added-missing-headers.patch
new file mode 100644
index 0000000..c07e936
--- /dev/null
+++ b/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/debian/system/core/Added-missing-headers.patch
@@ -0,0 +1,44 @@
+Description: Added missing headers causing compile errors
+Author: Umang Parmar <umangjparmar@gmail.com>
+Forwarded: not-needed
+
+--- a/system/core/adb/sysdeps/posix/network.cpp
++++ b/system/core/adb/sysdeps/posix/network.cpp
+@@ -22,6 +22,7 @@
+ #include <sys/socket.h>
+ 
+ #include <string>
++#include <cstring>
+ 
+ #include <android-base/logging.h>
+ #include <android-base/stringprintf.h>
+--- a/system/core/base/file.cpp
++++ b/system/core/base/file.cpp
+@@ -26,6 +26,7 @@
+ #include <sys/stat.h>
+ #include <sys/types.h>
+ #include <unistd.h>
++#include <cstring>
+ 
+ #include <memory>
+ #include <mutex>
+--- a/system/core/libbacktrace/BacktraceMap.cpp
++++ b/system/core/libbacktrace/BacktraceMap.cpp
+@@ -21,6 +21,7 @@
+ #include <stdint.h>
+ #include <sys/types.h>
+ #include <unistd.h>
++#include <algorithm>
+ 
+ #include <log/log.h>
+ 
+--- a/system/core/libbacktrace/UnwindStackMap.cpp
++++ b/system/core/libbacktrace/UnwindStackMap.cpp
+@@ -20,6 +20,7 @@
+ 
+ #include <string>
+ #include <vector>
++#include <algorithm>
+ 
+ #include <backtrace/BacktraceMap.h>
+ #include <unwindstack/Elf.h>
diff --git a/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/debian/system/core/Nonnull.patch b/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/debian/system/core/Nonnull.patch
new file mode 100644
index 0000000..8d1408a
--- /dev/null
+++ b/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/debian/system/core/Nonnull.patch
@@ -0,0 +1,20 @@
+Description: Bring Clang's _Nonnull keyword to GCC
+Author: Kai-Chung Yan
+Forwarded: not-needed
+--- a/system/core/adb/sysdeps.h
++++ b/system/core/adb/sysdeps.h
+@@ -40,11 +40,12 @@
+ #include "sysdeps/network.h"
+ #include "sysdeps/stat.h"
+ 
++#define _Nonnull
++#define _Nullable
++
+ #ifdef _WIN32
+ 
+ // Clang-only nullability specifiers
+-#define _Nonnull
+-#define _Nullable
+ 
+ #include <ctype.h>
+ #include <direct.h>
diff --git a/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/debian/system/core/Vector-cast.patch b/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/debian/system/core/Vector-cast.patch
new file mode 100644
index 0000000..b32d5f6
--- /dev/null
+++ b/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/debian/system/core/Vector-cast.patch
@@ -0,0 +1,14 @@
+Description: Fix the weird error by GCC7 that fails to match the correct parent method.
+Author: Kai-Chung Yan
+Forwarded: not-needed
+--- a/system/core/libutils/include/utils/Vector.h
++++ b/system/core/libutils/include/utils/Vector.h
+@@ -256,7 +256,7 @@
+ 
+ template<class TYPE> inline
+ const Vector<TYPE>& Vector<TYPE>::operator = (const Vector<TYPE>& rhs) const {
+-    VectorImpl::operator = (static_cast<const VectorImpl&>(rhs));
++    VectorImpl::operator = (rhs);
+     return *this;
+ }
+ 
diff --git a/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/debian/system/core/add-missing-headers.patch b/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/debian/system/core/add-missing-headers.patch
new file mode 100644
index 0000000..49d3ece
--- /dev/null
+++ b/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/debian/system/core/add-missing-headers.patch
@@ -0,0 +1,41 @@
+Forwarded: not-needed
+--- a/system/core/fs_mgr/liblp/reader.cpp
++++ b/system/core/fs_mgr/liblp/reader.cpp
+@@ -22,6 +22,7 @@
+ #include <unistd.h>
+ 
+ #include <functional>
++#include <cstring>
+ 
+ #include <android-base/file.h>
+ #include <android-base/unique_fd.h>
+--- a/system/core/fs_mgr/liblp/writer.cpp
++++ b/system/core/fs_mgr/liblp/writer.cpp
+@@ -21,6 +21,7 @@
+ #include <unistd.h>
+ 
+ #include <string>
++#include <cstring>
+ 
+ #include <android-base/file.h>
+ #include <android-base/unique_fd.h>
+--- a/system/core/liblog/logger_write.cpp
++++ b/system/core/liblog/logger_write.cpp
+@@ -27,6 +27,7 @@
+ #include <android/set_abort_message.h>
+ #endif
+ 
++#include <mutex>
+ #include <shared_mutex>
+ 
+ #include <android-base/errno_restorer.h>
+--- a/system/core/libziparchive/zip_archive_stream_entry.cc
++++ b/system/core/libziparchive/zip_archive_stream_entry.cc
+@@ -23,6 +23,7 @@
+ #include <sys/types.h>
+ #include <unistd.h>
+ 
++#include <limits>
+ #include <memory>
+ #include <vector>
+ 
diff --git a/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/debian/system/core/fix-attribute-issue-with-gcc.patch b/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/debian/system/core/fix-attribute-issue-with-gcc.patch
new file mode 100644
index 0000000..e0b4275
--- /dev/null
+++ b/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/debian/system/core/fix-attribute-issue-with-gcc.patch
@@ -0,0 +1,17 @@
+Description: remove clang-ism
+Forwarded: not-needed
+
+--- a/system/core/base/include/android-base/logging.h
++++ b/system/core/base/include/android-base/logging.h
+@@ -451,10 +451,7 @@
+ //       -Wno-user-defined-warnings to CPPFLAGS.
+ #pragma clang diagnostic push
+ #pragma clang diagnostic ignored "-Wgcc-compat"
+-#define OSTREAM_STRING_POINTER_USAGE_WARNING \
+-    __attribute__((diagnose_if(true, "Unexpected logging of string pointer", "warning")))
+-inline OSTREAM_STRING_POINTER_USAGE_WARNING
+-std::ostream& operator<<(std::ostream& stream, const std::string* string_pointer) {
++inline std::ostream& operator<<(std::ostream& stream, const std::string* string_pointer) {
+   return stream << static_cast<const void*>(string_pointer);
+ }
+ #pragma clang diagnostic pop
diff --git a/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/debian/system/core/fix-build-on-non-x86.patch b/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/debian/system/core/fix-build-on-non-x86.patch
new file mode 100644
index 0000000..98a5078
--- /dev/null
+++ b/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/debian/system/core/fix-build-on-non-x86.patch
@@ -0,0 +1,24 @@
+Description: non-x86 arches do not have PAGE_SIZE
+Forwarded: not-needed
+--- a/system/core/base/cmsg.cpp
++++ b/system/core/base/cmsg.cpp
+@@ -33,7 +33,8 @@
+                                  const std::vector<int>& fds) {
+   size_t cmsg_space = CMSG_SPACE(sizeof(int) * fds.size());
+   size_t cmsg_len = CMSG_LEN(sizeof(int) * fds.size());
+-  if (cmsg_space >= PAGE_SIZE) {
++  size_t pagesize = static_cast<size_t>(sysconf(_SC_PAGE_SIZE));
++  if (cmsg_space >= pagesize) {
+     errno = ENOMEM;
+     return -1;
+   }
+@@ -75,7 +76,8 @@
+   fds->clear();
+ 
+   size_t cmsg_space = CMSG_SPACE(sizeof(int) * max_fds);
+-  if (cmsg_space >= PAGE_SIZE) {
++  size_t pagesize = static_cast<size_t>(sysconf(_SC_PAGE_SIZE));
++  if (cmsg_space >= pagesize) {
+     errno = ENOMEM;
+     return -1;
+   }
diff --git a/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/debian/system/core/fix-gettid-exception-declaration.patch b/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/debian/system/core/fix-gettid-exception-declaration.patch
new file mode 100644
index 0000000..7fd228b
--- /dev/null
+++ b/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/debian/system/core/fix-gettid-exception-declaration.patch
@@ -0,0 +1,24 @@
+Description: get libcutils building
+Forwarded: not-needed
+--- a/system/core/libcutils/include/cutils/threads.h
++++ b/system/core/libcutils/include/cutils/threads.h
+@@ -33,7 +33,7 @@
+ // Deprecated: use android::base::GetThreadId instead, which doesn't truncate on Mac/Windows.
+ //
+ 
+-extern pid_t gettid();
++extern pid_t gettid(void) __THROW;
+ 
+ //
+ // Deprecated: use `_Thread_local` in C or `thread_local` in C++.
+--- a/system/core/libcutils/threads.cpp
++++ b/system/core/libcutils/threads.cpp
+@@ -33,7 +33,7 @@
+ 
+ // No definition needed for Android because we'll just pick up bionic's copy.
+ #ifndef __ANDROID__
+-pid_t gettid() {
++pid_t gettid(void) __THROW {
+ #if defined(__APPLE__)
+   uint64_t tid;
+   pthread_threadid_np(NULL, &tid);
diff --git a/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/debian/system/core/fix-standard-namespace-errors.patch b/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/debian/system/core/fix-standard-namespace-errors.patch
new file mode 100644
index 0000000..e41a357
--- /dev/null
+++ b/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/debian/system/core/fix-standard-namespace-errors.patch
@@ -0,0 +1,22 @@
+Description: Add missing 'std::' scope identifiers.
+Forwarded: not-needed
+--- a/system/core/libunwindstack/include/unwindstack/DwarfMemory.h
++++ b/system/core/libunwindstack/include/unwindstack/DwarfMemory.h
+@@ -29,7 +29,7 @@
+   DwarfMemory(Memory* memory) : memory_(memory) {}
+   virtual ~DwarfMemory() = default;
+ 
+-  bool ReadBytes(void* dst, size_t num_bytes);
++  bool ReadBytes(void* dst, std::size_t num_bytes);
+ 
+   template <typename SignedType>
+   bool ReadSigned(uint64_t* value);
+@@ -39,7 +39,7 @@
+   bool ReadSLEB128(int64_t* value);
+ 
+   template <typename AddressType>
+-  size_t GetEncodedSize(uint8_t encoding);
++  std::size_t GetEncodedSize(uint8_t encoding);
+ 
+   bool AdjustEncodedValue(uint8_t encoding, uint64_t* value);
+ 
diff --git a/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/debian/system/core/hard-code-build-number.patch b/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/debian/system/core/hard-code-build-number.patch
new file mode 100644
index 0000000..2a332eb
--- /dev/null
+++ b/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/debian/system/core/hard-code-build-number.patch
@@ -0,0 +1,44 @@
+Description: just hard code rather than deal with circular deps
+Forwarded: not-needed
+--- a/system/core/adb/adb.cpp
++++ b/system/core/adb/adb.cpp
+@@ -44,8 +44,6 @@
+ #include <android-base/parsenetaddress.h>
+ #include <android-base/stringprintf.h>
+ #include <android-base/strings.h>
+-#include <build/version.h>
+-#include <platform_tools_version.h>
+ 
+ #include "adb_auth.h"
+ #include "adb_io.h"
+@@ -69,7 +67,7 @@
+         "Version %s-%s\n"
+         "Installed as %s\n",
+         ADB_VERSION_MAJOR, ADB_VERSION_MINOR, ADB_SERVER_VERSION,
+-        PLATFORM_TOOLS_VERSION, android::build::GetBuildNumber().c_str(),
++        PLATFORM_TOOLS_VERSION, "debian",
+         android::base::GetExecutablePath().c_str());
+ }
+ 
+--- a/system/core/fastboot/fastboot.cpp
++++ b/system/core/fastboot/fastboot.cpp
+@@ -59,10 +59,8 @@
+ #include <android-base/stringprintf.h>
+ #include <android-base/strings.h>
+ #include <android-base/unique_fd.h>
+-#include <build/version.h>
+ #include <libavb/libavb.h>
+ #include <liblp/liblp.h>
+-#include <platform_tools_version.h>
+ #include <sparse/sparse.h>
+ #include <ziparchive/zip_archive.h>
+ 
+@@ -1680,7 +1678,7 @@
+                 setvbuf(stdout, nullptr, _IONBF, 0);
+                 setvbuf(stderr, nullptr, _IONBF, 0);
+             } else if (name == "version") {
+-                fprintf(stdout, "fastboot version %s-%s\n", PLATFORM_TOOLS_VERSION, android::build::GetBuildNumber().c_str());
++                fprintf(stdout, "fastboot version %s-%s\n", PLATFORM_TOOLS_VERSION, "debian");
+                 fprintf(stdout, "Installed as %s\n", android::base::GetExecutablePath().c_str());
+                 return 0;
+ #if !defined(_WIN32)
diff --git a/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/debian/system/core/libusb-header-path.patch b/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/debian/system/core/libusb-header-path.patch
new file mode 100644
index 0000000..1663aae
--- /dev/null
+++ b/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/debian/system/core/libusb-header-path.patch
@@ -0,0 +1,16 @@
+Description: libusb.h comes from different location
+Author: Umang Parmar <umangjparmar@gmail.com>
+Forwarded: not-needed
+Last-Update: 2018-05-26
+
+--- a/system/core/adb/client/usb_libusb.cpp
++++ b/system/core/adb/client/usb_libusb.cpp
+@@ -30,7 +30,7 @@
+ #include <thread>
+ #include <unordered_map>
+ 
+-#include <libusb/libusb.h>
++#include <libusb-1.0/libusb.h>
+ 
+ #include <android-base/file.h>
+ #include <android-base/logging.h>
diff --git a/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/debian/system/core/move-log-file-to-proper-dir.patch b/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/debian/system/core/move-log-file-to-proper-dir.patch
new file mode 100644
index 0000000..006564b
--- /dev/null
+++ b/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/debian/system/core/move-log-file-to-proper-dir.patch
@@ -0,0 +1,18 @@
+Description: Update log file directory.
+Author: Umang Parmar <umangjparmar@gmail.com>
+Last Updated: 2018-05-17
+
+--- a/system/core/adb/adb_utils.cpp
++++ b/system/core/adb/adb_utils.cpp
+@@ -339,6 +339,11 @@
+ 
+     return temp_path_utf8 + log_name;
+ #else
++    std::string log_dir = android::base::StringPrintf("/run/user/%u/adb.log", getuid());
++    struct stat st = {0};
++    if (stat(log_dir.c_str(), &st) == 0) {
++      return log_dir;
++    }
+     const char* tmp_dir = getenv("TMPDIR");
+     if (tmp_dir == nullptr) tmp_dir = "/tmp";
+     return android::base::StringPrintf("%s/adb.%u.log", tmp_dir, getuid());
diff --git a/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/debian/system/core/simg_dump-python3.patch b/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/debian/system/core/simg_dump-python3.patch
new file mode 100644
index 0000000..e6933ef
--- /dev/null
+++ b/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/debian/system/core/simg_dump-python3.patch
@@ -0,0 +1,62 @@
+Description: Port simg_dump to Python 3.
+Author: Antonio Russo <antonio.e.russo@gmail.com>
+Forwarded: not-needed
+Last-Update: 2019-01-05
+Origin: https://bugs.debian.org/945646
+
+---
+Index: android-platform-tools/system/core/libsparse/simg_dump.py
+===================================================================
+--- android-platform-tools.orig/system/core/libsparse/simg_dump.py
++++ android-platform-tools/system/core/libsparse/simg_dump.py
+@@ -1,4 +1,4 @@
+-#! /usr/bin/env python
++#! /usr/bin/env python3
+ 
+ # Copyright (C) 2012 The Android Open Source Project
+ #
+@@ -14,7 +14,7 @@
+ # See the License for the specific language governing permissions and
+ # limitations under the License.
+ 
+-from __future__ import print_function
++
+ import csv
+ import getopt
+ import hashlib
+@@ -47,7 +47,7 @@ def main():
+     opts, args = getopt.getopt(sys.argv[1:],
+                                "vsc:",
+                                ["verbose", "showhash", "csvfile"])
+-  except getopt.GetoptError, e:
++  except getopt.GetoptError as e:
+     print(e)
+     usage(me)
+   for o, a in opts:
+@@ -66,7 +66,7 @@ def main():
+     usage(me)
+ 
+   if csvfilename:
+-    csvfile = open(csvfilename, "wb")
++    csvfile = open(csvfilename, "w", newline='')
+     csvwriter = csv.writer(csvfile)
+ 
+   output = verbose or csvfilename or showhash
+@@ -121,7 +121,7 @@ def main():
+                           "output offset", "output blocks", "type", "hash"])
+ 
+     offset = 0
+-    for i in xrange(1, total_chunks + 1):
++    for i in range(1, total_chunks + 1):
+       header_bin = FH.read(12)
+       header = struct.unpack("<2H2I", header_bin)
+       chunk_type = header[0]
+@@ -160,7 +160,7 @@ def main():
+           if showhash:
+             h = hashlib.sha1()
+             data = fill_bin * (blk_sz / 4);
+-            for block in xrange(chunk_sz):
++            for block in range(chunk_sz):
+               h.update(data)
+             curhash = h.hexdigest()
+       elif chunk_type == 0xCAC3:
diff --git a/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/debian/system/core/stdatomic.patch b/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/debian/system/core/stdatomic.patch
new file mode 100644
index 0000000..ea3711d
--- /dev/null
+++ b/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/debian/system/core/stdatomic.patch
@@ -0,0 +1,64 @@
+Description: Fix incompatibility between <stdatomic.h> and <atomic>
+ This 2 headers combined will cause errors for both GCC and Clang. This patch
+ makes sure only one of them is present at any time.
+Bug: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=60932
+Bug: https://reviews.llvm.org/D45470
+--- a/system/core/libcutils/include/cutils/trace.h
++++ b/system/core/libcutils/include/cutils/trace.h
+@@ -18,7 +18,14 @@
+ #define _LIBS_CUTILS_TRACE_H
+ 
+ #include <inttypes.h>
++#ifdef __cplusplus
++#include <atomic>
++using std::atomic_bool;
++using std::atomic_load_explicit;
++using std::memory_order_acquire;
++#else
+ #include <stdatomic.h>
++#endif
+ #include <stdbool.h>
+ #include <stdint.h>
+ #include <stdio.h>
+--- a/system/core/libcutils/include/cutils/atomic.h
++++ b/system/core/libcutils/include/cutils/atomic.h
+@@ -19,7 +19,23 @@
+ 
+ #include <stdint.h>
+ #include <sys/types.h>
++#ifdef __cplusplus
++#include <atomic>
++using std::atomic_compare_exchange_strong_explicit;
++using std::atomic_fetch_add_explicit;
++using std::atomic_fetch_or_explicit;
++using std::atomic_fetch_sub_explicit;
++using std::atomic_int_least32_t;
++using std::atomic_load_explicit;
++using std::atomic_store_explicit;
++using std::atomic_thread_fence;
++using std::memory_order::memory_order_acquire;
++using std::memory_order::memory_order_relaxed;
++using std::memory_order::memory_order_release;
++using std::memory_order::memory_order_seq_cst;
++#else
+ #include <stdatomic.h>
++#endif
+ 
+ #ifndef ANDROID_ATOMIC_INLINE
+ #define ANDROID_ATOMIC_INLINE static inline
+--- a/system/core/liblog/logger.h
++++ b/system/core/liblog/logger.h
+@@ -16,7 +16,13 @@
+ 
+ #pragma once
+ 
++#ifdef __cplusplus
++#include <atomic>
++using std::atomic_int;
++using std::atomic_uintptr_t;
++#else
+ #include <stdatomic.h>
++#endif
+ #include <sys/cdefs.h>
+ 
+ #include <log/log.h>
diff --git a/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/debian/system/core/stub-out-fastdeploy.patch b/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/debian/system/core/stub-out-fastdeploy.patch
new file mode 100644
index 0000000..d2426a7
--- /dev/null
+++ b/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/debian/system/core/stub-out-fastdeploy.patch
@@ -0,0 +1,93 @@
+Description: Defer packaging fastdeploy with adb for 29.x.x tags.
+Forwarded: not-needed
+--- a/system/core/adb/client/commandline.cpp
++++ b/system/core/adb/client/commandline.cpp
+@@ -59,7 +59,6 @@
+ #include "bugreport.h"
+ #include "client/file_sync_client.h"
+ #include "commandline.h"
+-#include "fastdeploy.h"
+ #include "services.h"
+ #include "shell_protocol.h"
+ #include "sysdeps/chrono.h"
+--- a/system/core/adb/client/adb_install.cpp
++++ b/system/core/adb/client/adb_install.cpp
+@@ -35,7 +35,6 @@
+ #include "adb_utils.h"
+ #include "client/file_sync_client.h"
+ #include "commandline.h"
+-#include "fastdeploy.h"
+ 
+ static constexpr int kFastDeployMinApi = 24;
+ 
+@@ -167,14 +166,6 @@
+     }
+ 
+     if (use_fastdeploy) {
+-        auto metadata = extract_metadata(file);
+-        if (metadata.has_value()) {
+-            // pass all but 1st (command) and last (apk path) parameters through to pm for
+-            // session creation
+-            std::vector<const char*> pm_args{argv + 1, argv + argc - 1};
+-            auto patchFd = install_patch(pm_args.size(), pm_args.data());
+-            return stream_patch(file, std::move(metadata.value()), std::move(patchFd));
+-        }
+     }
+ 
+     struct stat sb;
+@@ -267,16 +258,6 @@
+     argv[last_apk] = apk_dest.c_str(); /* destination name, not source location */
+ 
+     if (use_fastdeploy) {
+-        auto metadata = extract_metadata(apk_file[0]);
+-        if (metadata.has_value()) {
+-            auto patchFd = apply_patch_on_device(apk_dest.c_str());
+-            int status = stream_patch(apk_file[0], std::move(metadata.value()), std::move(patchFd));
+-
+-            result = pm_command(argc, argv);
+-            delete_device_file(apk_dest);
+-
+-            return status;
+-        }
+     }
+ 
+     if (do_sync_push(apk_file, apk_dest.c_str(), false)) {
+@@ -292,7 +273,6 @@
+     InstallMode installMode = INSTALL_DEFAULT;
+     bool use_fastdeploy = false;
+     bool is_reinstall = false;
+-    FastDeploy_AgentUpdateStrategy agent_update_strategy = FastDeploy_AgentUpdateDifferentVersion;
+ 
+     for (int i = 1; i < argc; i++) {
+         if (!strcmp(argv[i], "--streaming")) {
+@@ -313,13 +293,10 @@
+             use_fastdeploy = false;
+         } else if (!strcmp(argv[i], "--force-agent")) {
+             processedArgIndicies.push_back(i);
+-            agent_update_strategy = FastDeploy_AgentUpdateAlways;
+         } else if (!strcmp(argv[i], "--date-check-agent")) {
+             processedArgIndicies.push_back(i);
+-            agent_update_strategy = FastDeploy_AgentUpdateNewerTimeStamp;
+         } else if (!strcmp(argv[i], "--version-check-agent")) {
+             processedArgIndicies.push_back(i);
+-            agent_update_strategy = FastDeploy_AgentUpdateDifferentVersion;
+         }
+     }
+ 
+@@ -331,13 +308,11 @@
+         error_exit("Attempting to use streaming install on unsupported device");
+     }
+ 
+-    if (use_fastdeploy && get_device_api_level() < kFastDeployMinApi) {
+-        printf("Fast Deploy is only compatible with devices of API version %d or higher, "
+-               "ignoring.\n",
+-               kFastDeployMinApi);
++    if (use_fastdeploy) {
++        printf("Fast Deploy is unavailable in this build of adb, "
++               "ignoring.\n");
+         use_fastdeploy = false;
+     }
+-    fastdeploy_set_agent_update_strategy(agent_update_strategy);
+ 
+     std::vector<const char*> passthrough_argv;
+     for (int i = 0; i < argc; i++) {
diff --git a/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/debian/system/core/throw-exception-on-unknown-os.patch b/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/debian/system/core/throw-exception-on-unknown-os.patch
new file mode 100644
index 0000000..6b07f17
--- /dev/null
+++ b/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/debian/system/core/throw-exception-on-unknown-os.patch
@@ -0,0 +1,16 @@
+Description: Turn #error into exceptions
+ So the library can be built on non-Linux platforms too, although can't
+ guarauntee its functionality regarding that piece of code.
+Forwarded: not-needed
+--- a/system/core/base/file.cpp
++++ b/system/core/base/file.cpp
+@@ -422,7 +422,8 @@
+   path[PATH_MAX - 1] = 0;
+   return path;
+ #else
+-#error unknown OS
++#include <stdexcept>
++  throw std::runtime_error(std::string("Unknown OS!"));
+ #endif
+ }
+ 
diff --git a/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/debian/throw-exception-on-unknown-os.patch b/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/debian/throw-exception-on-unknown-os.patch
new file mode 100644
index 0000000..6b07f17
--- /dev/null
+++ b/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/debian/throw-exception-on-unknown-os.patch
@@ -0,0 +1,16 @@
+Description: Turn #error into exceptions
+ So the library can be built on non-Linux platforms too, although can't
+ guarauntee its functionality regarding that piece of code.
+Forwarded: not-needed
+--- a/system/core/base/file.cpp
++++ b/system/core/base/file.cpp
+@@ -422,7 +422,8 @@
+   path[PATH_MAX - 1] = 0;
+   return path;
+ #else
+-#error unknown OS
++#include <stdexcept>
++  throw std::runtime_error(std::string("Unknown OS!"));
+ #endif
+ }
+ 
diff --git a/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/remount b/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/remount
new file mode 100644
index 0000000..751c350
--- /dev/null
+++ b/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/remount
@@ -0,0 +1,2 @@
+#!/bin/sh
+mount -o remount,rw /
diff --git a/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/rules_yocto.mk b/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/rules_yocto.mk
new file mode 100644
index 0000000..2c808d3
--- /dev/null
+++ b/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools/rules_yocto.mk
@@ -0,0 +1 @@
+CPPFLAGS += -fPIC
diff --git a/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools_29.0.6.r14.bb b/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools_29.0.6.r14.bb
new file mode 100644
index 0000000..75e837f
--- /dev/null
+++ b/meta-openembedded/meta-oe/dynamic-layers/selinux/recipes-devtool/android-tools/android-tools_29.0.6.r14.bb
@@ -0,0 +1,194 @@
+DESCRIPTION = "Various utilities from Android"
+SECTION = "console/utils"
+LICENSE = "Apache-2.0 & GPL-2.0-only & BSD-2-Clause & BSD-3-Clause"
+LIC_FILES_CHKSUM = " \
+    file://${COMMON_LICENSE_DIR}/Apache-2.0;md5=89aea4e17d99a7cacdbeed46a0096b10 \
+    file://${COMMON_LICENSE_DIR}/GPL-2.0-only;md5=801f80980d171dd6425610833a22dbe6 \
+    file://${COMMON_LICENSE_DIR}/BSD-2-Clause;md5=cb641bc04cda31daea161b1bc15da69f \
+    file://${COMMON_LICENSE_DIR}/BSD-3-Clause;md5=550794465ba0ec5312d6919e203a55f9 \
+"
+DEPENDS = "libbsd libpcre zlib libcap libusb squashfs-tools p7zip libselinux googletest"
+
+SRCREV_core = "abfd66fafcbb691d7860df059f1df1c9b1ef29da"
+
+SRC_URI = " \
+    git://salsa.debian.org/android-tools-team/android-platform-tools;name=core;protocol=https;nobranch=1 \
+"
+
+# Patches copied from android-platform-tools/debian/patches
+# and applied in the order defined by the file debian/patches/series
+SRC_URI += " \
+    file://debian/external/libunwind/user_pt_regs.patch \
+    file://debian/external/libunwind/legacy_built-in_sync_functions.patch \
+    file://debian/external/libunwind/20150704-CVE-2015-3239_dwarf_i.h.patch \
+    \
+    file://debian/system/core/move-log-file-to-proper-dir.patch \
+    file://debian/system/core/Added-missing-headers.patch \
+    file://debian/system/core/libusb-header-path.patch \
+    file://debian/system/core/stdatomic.patch \
+    file://debian/system/core/Nonnull.patch \
+    file://debian/system/core/Vector-cast.patch \
+    file://debian/system/core/throw-exception-on-unknown-os.patch \
+    file://debian/system/core/simg_dump-python3.patch \
+    file://debian/system/core/fix-attribute-issue-with-gcc.patch \
+    file://debian/system/core/fix-gettid-exception-declaration.patch \
+    file://debian/system/core/fix-build-on-non-x86.patch \
+    file://debian/system/core/add-missing-headers.patch \
+    file://debian/system/core/hard-code-build-number.patch \
+    file://debian/system/core/stub-out-fastdeploy.patch \
+    file://debian/system/core/fix-standard-namespace-errors.patch \
+    file://debian/system/core/Add-riscv64-support.patch \
+    \
+"
+
+# patches which don't come from debian
+SRC_URI += " \
+    file://rules_yocto.mk;subdir=git \
+    file://android-tools-adbd.service \
+    file://adbd.mk;subdir=git/debian/system/core \
+    file://remount \
+    file://0001-Fixes-for-yocto-build.patch \
+    file://0002-android-tools-modifications-to-make-it-build-in-yoct.patch \
+    file://0003-Update-usage-of-usbdevfs_urb-to-match-new-kernel-UAP.patch \
+    file://0004-adb-Fix-build-on-big-endian-systems.patch \
+    file://0005-adb-Allow-adbd-to-be-run-as-root.patch \
+"
+
+S = "${WORKDIR}/git"
+B = "${WORKDIR}/${BPN}"
+
+# http://errors.yoctoproject.org/Errors/Details/1debian881/
+ARM_INSTRUCTION_SET:armv4 = "arm"
+ARM_INSTRUCTION_SET:armv5 = "arm"
+
+COMPATIBLE_HOST:powerpc = "(null)"
+COMPATIBLE_HOST:powerpc64 = "(null)"
+COMPATIBLE_HOST:powerpc64le = "(null)"
+
+inherit systemd
+
+SYSTEMD_SERVICE:${PN} = "android-tools-adbd.service"
+
+# Find libbsd headers during native builds
+CC:append:class-native = " -I${STAGING_INCDIR}"
+CC:append:class-nativesdk = " -I${STAGING_INCDIR}"
+
+PREREQUISITE_core = "liblog libbase libsparse liblog libcutils"
+TOOLS_TO_BUILD = "libcrypto_utils libadb libziparchive fastboot adb img2simg simg2img libbacktrace"
+TOOLS_TO_BUILD:append:class-target = " adbd"
+
+do_compile() {
+
+    case "${HOST_ARCH}" in
+      arm)
+        export android_arch=linux-arm
+        cpu=arm
+        deb_host_arch=arm
+      ;;
+      aarch64)
+        export android_arch=linux-arm64
+        cpu=arm64
+        deb_host_arch=arm64
+      ;;
+      riscv64)
+        export android_arch=linux-riscv64
+      ;;
+      mips|mipsel)
+        export android_arch=linux-mips
+        cpu=mips
+        deb_host_arch=mips
+      ;;
+      mips64|mips64el)
+        export android_arch=linux-mips64
+        cpu=mips64
+        deb_host_arch=mips64
+      ;;
+      powerpc|powerpc64)
+        export android_arch=linux-ppc
+      ;;
+      i586|i686|x86_64)
+        export android_arch=linux-x86
+        cpu=x86_64
+        deb_host_arch=amd64
+      ;;
+    esac
+
+    export SRCDIR=${S}
+
+    oe_runmake -f ${S}/debian/external/boringssl/libcrypto.mk -C ${S}
+    oe_runmake -f ${S}/debian/external/libunwind/libunwind.mk -C ${S} CPU=${cpu}
+
+    for tool in ${PREREQUISITE_core}; do
+      oe_runmake -f ${S}/debian/system/core/${tool}.mk -C ${S}
+    done
+
+    for i in `find ${S}/debian/system/extras/ -name "*.mk"`; do
+        oe_runmake -f $i -C ${S}
+    done
+
+    for tool in ${TOOLS_TO_BUILD}; do
+        if [ "$tool" = "libbacktrace" ]; then
+            oe_runmake -f ${S}/debian/system/core/${tool}.mk -C ${S} DEB_HOST_ARCH=${deb_host_arch}
+        else
+            oe_runmake -f ${S}/debian/system/core/${tool}.mk -C ${S}
+        fi
+    done
+
+}
+
+do_install() {
+    install -d ${D}${base_sbindir}
+    install -m 0755 ${S}/../remount -D ${D}${base_sbindir}/remount
+
+    for tool in img2simg simg2img fastboot adbd; do
+        if echo ${TOOLS_TO_BUILD} | grep -q "$tool" ; then
+            install -D -p -m0755 ${S}/debian/out/system/core/$tool ${D}${bindir}/$tool
+        fi
+    done
+
+    # grep adb also matches adbd, so handle adb separately from other tools
+    if echo ${TOOLS_TO_BUILD} | grep -q "adb " ; then
+        install -d ${D}${bindir}
+        install -m0755 ${S}/debian/out/system/core/adb ${D}${bindir}
+    fi
+
+    # Outside the if statement to avoid errors during do_package
+    install -D -p -m0644 ${WORKDIR}/android-tools-adbd.service \
+      ${D}${systemd_unitdir}/system/android-tools-adbd.service
+
+    install -d  ${D}${libdir}/android/
+    install -m0755 ${S}/debian/out/system/core/*.so.* ${D}${libdir}/android/
+    if echo ${TOOLS_TO_BUILD} | grep -q "mkbootimg" ; then
+        install -d ${D}${bindir}
+        install -m0755 ${B}/mkbootimg/mkbootimg ${D}${bindir}
+    fi
+}
+
+PACKAGES =+ "${PN}-fstools ${PN}-adbd"
+
+RDEPENDS:${BPN} = "${BPN}-conf p7zip"
+
+FILES:${PN}-adbd = "\
+    ${bindir}/adbd \
+    ${systemd_unitdir}/system/android-tools-adbd.service \
+"
+
+FILES:${PN}-fstools = "\
+    ${bindir}/ext2simg \
+    ${bindir}/ext4fixup \
+    ${bindir}/img2simg \
+    ${bindir}/make_ext4fs \
+    ${bindir}/simg2img \
+    ${bindir}/simg2simg \
+    ${bindir}/simg_dump \
+    ${bindir}/mkuserimg \
+"
+FILES:${PN} += "${libdir}/android ${libdir}/android/*"
+
+BBCLASSEXTEND = "native"
+
+android_tools_enable_devmode() {
+    touch ${IMAGE_ROOTFS}/var/usb-debugging-enabled
+}
+
+ROOTFS_POSTPROCESS_COMMAND_${PN}-adbd += "${@bb.utils.contains("USB_DEBUGGING_ENABLED", "1", "android_tools_enable_devmode;", "", d)}"
diff --git a/meta-openembedded/meta-oe/recipes-benchmark/iperf3/iperf3_3.12.bb b/meta-openembedded/meta-oe/recipes-benchmark/iperf3/iperf3_3.13.bb
similarity index 89%
rename from meta-openembedded/meta-oe/recipes-benchmark/iperf3/iperf3_3.12.bb
rename to meta-openembedded/meta-oe/recipes-benchmark/iperf3/iperf3_3.13.bb
index 8c5ce36..62a95b3 100644
--- a/meta-openembedded/meta-oe/recipes-benchmark/iperf3/iperf3_3.12.bb
+++ b/meta-openembedded/meta-oe/recipes-benchmark/iperf3/iperf3_3.13.bb
@@ -11,14 +11,14 @@
 AUTHOR = "ESNET <info@es.net>, Lawrence Berkeley National Laboratory <websupport@lbl.gov>"
 
 LICENSE = "BSD-3-Clause"
-LIC_FILES_CHKSUM = "file://LICENSE;md5=68ae8cfc577a2c8c51bb51e9628e80b7"
+LIC_FILES_CHKSUM = "file://LICENSE;md5=dc6301c8256ceb8f71c9e3c2ae9096b9"
 
 SRC_URI = "git://github.com/esnet/iperf.git;branch=master;protocol=https \
            file://0002-Remove-pg-from-profile_CFLAGS.patch \
            file://0001-configure.ac-check-for-CPP-prog.patch \
            "
 
-SRCREV = "e61aaf8c95df956cefbc54fab7b3d78914664180"
+SRCREV = "f48e7fa92b8932814f3d92f36986d51be9efe6e0"
 
 S = "${WORKDIR}/git"
 
diff --git a/meta-openembedded/meta-oe/recipes-connectivity/libmbim/libmbim_1.28.2.bb b/meta-openembedded/meta-oe/recipes-connectivity/libmbim/libmbim_1.28.4.bb
similarity index 93%
rename from meta-openembedded/meta-oe/recipes-connectivity/libmbim/libmbim_1.28.2.bb
rename to meta-openembedded/meta-oe/recipes-connectivity/libmbim/libmbim_1.28.4.bb
index a549bde..a35d989 100644
--- a/meta-openembedded/meta-oe/recipes-connectivity/libmbim/libmbim_1.28.2.bb
+++ b/meta-openembedded/meta-oe/recipes-connectivity/libmbim/libmbim_1.28.4.bb
@@ -11,7 +11,7 @@
 
 inherit meson pkgconfig bash-completion gobject-introspection
 
-SRCREV = "c94b858d1c5a98238adf0e6006e453c984c8e5d5"
+SRCREV = "7f1c7907c4654ba5c619a635cef5475ca161d027"
 SRC_URI = "git://gitlab.freedesktop.org/mobile-broadband/libmbim.git;protocol=https;branch=mbim-1-28"
 
 S = "${WORKDIR}/git"
diff --git a/meta-openembedded/meta-oe/recipes-connectivity/libqmi/libqmi_1.32.2.bb b/meta-openembedded/meta-oe/recipes-connectivity/libqmi/libqmi_1.32.4.bb
similarity index 94%
rename from meta-openembedded/meta-oe/recipes-connectivity/libqmi/libqmi_1.32.2.bb
rename to meta-openembedded/meta-oe/recipes-connectivity/libqmi/libqmi_1.32.4.bb
index 3a91a5b..7b7a3b2 100644
--- a/meta-openembedded/meta-oe/recipes-connectivity/libqmi/libqmi_1.32.2.bb
+++ b/meta-openembedded/meta-oe/recipes-connectivity/libqmi/libqmi_1.32.4.bb
@@ -12,7 +12,7 @@
 
 inherit meson pkgconfig bash-completion gobject-introspection
 
-SRCREV = "c6b38cc2752873c0c6c1f8c472d9ddea2b34ec72"
+SRCREV = "6e248aceb66f53b467b343bca1c467a8211dd30d"
 SRC_URI = "git://gitlab.freedesktop.org/mobile-broadband/libqmi.git;protocol=https;branch=qmi-1-32"
 
 S = "${WORKDIR}/git"
diff --git a/meta-openembedded/meta-oe/recipes-connectivity/modemmanager/modemmanager_1.20.4.bb b/meta-openembedded/meta-oe/recipes-connectivity/modemmanager/modemmanager_1.20.6.bb
similarity index 97%
rename from meta-openembedded/meta-oe/recipes-connectivity/modemmanager/modemmanager_1.20.4.bb
rename to meta-openembedded/meta-oe/recipes-connectivity/modemmanager/modemmanager_1.20.6.bb
index fe44ef9..ba82d21 100644
--- a/meta-openembedded/meta-oe/recipes-connectivity/modemmanager/modemmanager_1.20.4.bb
+++ b/meta-openembedded/meta-oe/recipes-connectivity/modemmanager/modemmanager_1.20.6.bb
@@ -12,7 +12,7 @@
 
 DEPENDS = "glib-2.0 libgudev libxslt-native dbus"
 
-SRCREV = "6926459500fd927e7cceb589a9e4113d4edb04e6"
+SRCREV = "6aa0ff583d04aea88b4da7a1c20049f57062dab6"
 SRC_URI = "git://gitlab.freedesktop.org/mobile-broadband/ModemManager.git;protocol=https;branch=mm-1-20"
 
 S = "${WORKDIR}/git"
diff --git a/meta-openembedded/meta-oe/recipes-connectivity/rabbitmq-c/rabbitmq-c_0.11.0.bb b/meta-openembedded/meta-oe/recipes-connectivity/rabbitmq-c/rabbitmq-c_0.13.0.bb
similarity index 76%
rename from meta-openembedded/meta-oe/recipes-connectivity/rabbitmq-c/rabbitmq-c_0.11.0.bb
rename to meta-openembedded/meta-oe/recipes-connectivity/rabbitmq-c/rabbitmq-c_0.13.0.bb
index 304171c..f9c2b2c 100644
--- a/meta-openembedded/meta-oe/recipes-connectivity/rabbitmq-c/rabbitmq-c_0.11.0.bb
+++ b/meta-openembedded/meta-oe/recipes-connectivity/rabbitmq-c/rabbitmq-c_0.13.0.bb
@@ -1,11 +1,11 @@
 DESCRIPTION = "A C-language AMQP client library for use with v2.0+ of the RabbitMQ broker"
 HOMEPAGE = "https://github.com/alanxz/rabbitmq-c"
-LIC_FILES_CHKSUM = "file://LICENSE-MIT;md5=6b7424f9db80cfb11fdd5c980b583f53"
+LIC_FILES_CHKSUM = "file://LICENSE;md5=7e12f6e40e662e039e2f02b4893011ec"
 LICENSE = "MIT"
 
 SRC_URI = "git://github.com/alanxz/rabbitmq-c.git;branch=master;protocol=https"
-# v0.11.0-master
-SRCREV = "a64c08c68aff34d49a2ac152f04988cd921084f9"
+# v0.13.0-master
+SRCREV = "974d71adceae6d742ae20a4c880d99c131f1460a"
 
 S = "${WORKDIR}/git"
 
diff --git a/meta-openembedded/meta-oe/recipes-core/opencl/ocl-icd_2.3.1.bb b/meta-openembedded/meta-oe/recipes-core/opencl/ocl-icd_2.3.1.bb
index 250cb68..b1980e3 100644
--- a/meta-openembedded/meta-oe/recipes-core/opencl/ocl-icd_2.3.1.bb
+++ b/meta-openembedded/meta-oe/recipes-core/opencl/ocl-icd_2.3.1.bb
@@ -14,5 +14,7 @@
 inherit autotools
 
 DEPENDS = "ruby-native"
+PROVIDES = "virtual/opencl-icd"
+RPROVIDES:${PN} = "virtual/opencl-icd"
 
 BBCLASSEXTEND = "native nativesdk"
diff --git a/meta-openembedded/meta-oe/recipes-core/opencl/opencl-headers_git.bb b/meta-openembedded/meta-oe/recipes-core/opencl/opencl-headers_git.bb
index 6374f45..83ea652 100644
--- a/meta-openembedded/meta-oe/recipes-core/opencl/opencl-headers_git.bb
+++ b/meta-openembedded/meta-oe/recipes-core/opencl/opencl-headers_git.bb
@@ -5,8 +5,8 @@
 SECTION = "base"
 
 S = "${WORKDIR}/git"
-PV = "2022.09.30"
-SRCREV = "a51354a85f41d203e755124ad51ae3425933df45"
+PV = "2023.02.06"
+SRCREV = "4c82e9cfaaad18c340f48af3cf5d09ff33e8c1b7"
 SRC_URI = "git://github.com/KhronosGroup/OpenCL-Headers.git;branch=main;protocol=https"
 
 do_configure[noexec] = "1"
diff --git a/meta-openembedded/meta-oe/recipes-core/opencl/opencl-icd-loader_git.bb b/meta-openembedded/meta-oe/recipes-core/opencl/opencl-icd-loader_git.bb
index 6743773..fc04cb5 100644
--- a/meta-openembedded/meta-oe/recipes-core/opencl/opencl-icd-loader_git.bb
+++ b/meta-openembedded/meta-oe/recipes-core/opencl/opencl-icd-loader_git.bb
@@ -9,6 +9,7 @@
 DEPENDS += "opencl-headers"
 
 PROVIDES = "virtual/opencl-icd"
+RPROVIDES:${PN} = "virtual/opencl-icd"
 
 S = "${WORKDIR}/git"
 PV = "v2022.01.04+git${SRCPV}"
diff --git a/meta-openembedded/meta-oe/recipes-core/packagegroups/packagegroup-meta-oe.bb b/meta-openembedded/meta-oe/recipes-core/packagegroups/packagegroup-meta-oe.bb
index 73465de..3188725 100644
--- a/meta-openembedded/meta-oe/recipes-core/packagegroups/packagegroup-meta-oe.bb
+++ b/meta-openembedded/meta-oe/recipes-core/packagegroups/packagegroup-meta-oe.bb
@@ -448,8 +448,8 @@
 RDEPENDS:packagegroup-meta-oe-extended:remove:powerpc = "upm mraa minifi-cpp"
 RDEPENDS:packagegroup-meta-oe-extended:remove:powerpc64 = "upm mraa minifi-cpp"
 RDEPENDS:packagegroup-meta-oe-extended:remove:powerpc64le = "upm mraa sysdig"
-RDEPENDS:packagegroup-meta-oe-extended:remove:riscv64 = "upm libleak libyang mraa sysdig tiptop"
-RDEPENDS:packagegroup-meta-oe-extended:remove:riscv32 = "upm libleak libyang mraa sysdig tiptop"
+RDEPENDS:packagegroup-meta-oe-extended:remove:riscv64 = "upm libleak mraa sysdig tiptop"
+RDEPENDS:packagegroup-meta-oe-extended:remove:riscv32 = "upm libleak mraa sysdig tiptop"
 
 RDEPENDS:packagegroup-meta-oe-extended-python2 ="\
     ${@bb.utils.contains("BBFILE_COLLECTIONS", "meta-python2", bb.utils.contains('I_SWEAR_TO_MIGRATE_TO_PYTHON3', 'yes', 'openlmi-tools', '', d), "", d)} \
diff --git a/meta-openembedded/meta-oe/recipes-core/uutils-coreutils/README.txt b/meta-openembedded/meta-oe/recipes-core/uutils-coreutils/README.txt
deleted file mode 100644
index cfd7b05..0000000
--- a/meta-openembedded/meta-oe/recipes-core/uutils-coreutils/README.txt
+++ /dev/null
@@ -1,19 +0,0 @@
-How to generate/update the file uutils-coreutils_XXX.bb:
-
-cargo with version > 1.60 is needed so cargo from Ubuntu's apt will not work
-(because of https://github.com/rust-lang/cargo/issues/10623):
-This package is needed (tested on Ubuntu 22.04):
-sudo apt-get -y install librust-cargo+openssl-dev
-
-Then install cargo-bitbake with:
-$ cargo install --locked cargo-bitbake
-
-You can now update coreutils:
-$ git clone https://github.com/uutils/coreutils.git
-$ cd coreutils
-$ git tag
-$ git checkout 0.0.XXX
-$ cargo-bitbake bitbake
-Wrote: coreutils_0.0.15.bb
-
-Verify manual changes in the bb file (rename coreutils.inc to uutils-coreutils.inc)
diff --git a/meta-openembedded/meta-oe/recipes-core/uutils-coreutils/uutils-coreutils-crates.inc b/meta-openembedded/meta-oe/recipes-core/uutils-coreutils/uutils-coreutils-crates.inc
new file mode 100644
index 0000000..4bdb7b2
--- /dev/null
+++ b/meta-openembedded/meta-oe/recipes-core/uutils-coreutils/uutils-coreutils-crates.inc
@@ -0,0 +1,269 @@
+SRC_URI += " \
+    crate://crates.io/Inflector/0.11.4 \
+    crate://crates.io/adler/1.0.2 \
+    crate://crates.io/ahash/0.7.6 \
+    crate://crates.io/aho-corasick/0.7.19 \
+    crate://crates.io/aliasable/0.1.3 \
+    crate://crates.io/android_system_properties/0.1.5 \
+    crate://crates.io/arrayref/0.3.6 \
+    crate://crates.io/arrayvec/0.7.2 \
+    crate://crates.io/atty/0.2.14 \
+    crate://crates.io/autocfg/1.1.0 \
+    crate://crates.io/bigdecimal/0.3.0 \
+    crate://crates.io/binary-heap-plus/0.5.0 \
+    crate://crates.io/bindgen/0.62.0 \
+    crate://crates.io/bitflags/1.3.2 \
+    crate://crates.io/blake2b_simd/1.0.0 \
+    crate://crates.io/blake3/1.3.2 \
+    crate://crates.io/block-buffer/0.10.3 \
+    crate://crates.io/bstr/1.0.1 \
+    crate://crates.io/bumpalo/3.11.1 \
+    crate://crates.io/bytecount/0.6.3 \
+    crate://crates.io/byteorder/1.4.3 \
+    crate://crates.io/cc/1.0.77 \
+    crate://crates.io/cexpr/0.6.0 \
+    crate://crates.io/cfg-if/1.0.0 \
+    crate://crates.io/chrono/0.4.23 \
+    crate://crates.io/clang-sys/1.4.0 \
+    crate://crates.io/clap/4.0.26 \
+    crate://crates.io/clap_complete/4.0.6 \
+    crate://crates.io/clap_lex/0.3.0 \
+    crate://crates.io/codespan-reporting/0.11.1 \
+    crate://crates.io/compare/0.1.0 \
+    crate://crates.io/console/0.15.2 \
+    crate://crates.io/constant_time_eq/0.1.5 \
+    crate://crates.io/constant_time_eq/0.2.4 \
+    crate://crates.io/conv/0.3.3 \
+    crate://crates.io/core-foundation-sys/0.8.3 \
+    crate://crates.io/coz/0.1.3 \
+    crate://crates.io/cpp/0.5.7 \
+    crate://crates.io/cpp_build/0.5.7 \
+    crate://crates.io/cpp_common/0.5.7 \
+    crate://crates.io/cpp_macros/0.5.7 \
+    crate://crates.io/cpufeatures/0.2.5 \
+    crate://crates.io/crc32fast/1.3.2 \
+    crate://crates.io/crossbeam-channel/0.5.6 \
+    crate://crates.io/crossbeam-deque/0.8.2 \
+    crate://crates.io/crossbeam-epoch/0.9.12 \
+    crate://crates.io/crossbeam-utils/0.8.13 \
+    crate://crates.io/crossterm/0.25.0 \
+    crate://crates.io/crossterm_winapi/0.9.0 \
+    crate://crates.io/crunchy/0.2.2 \
+    crate://crates.io/crypto-common/0.1.6 \
+    crate://crates.io/ctor/0.1.26 \
+    crate://crates.io/ctrlc/3.2.3 \
+    crate://crates.io/custom_derive/0.1.7 \
+    crate://crates.io/cxx-build/1.0.82 \
+    crate://crates.io/cxx/1.0.82 \
+    crate://crates.io/cxxbridge-flags/1.0.82 \
+    crate://crates.io/cxxbridge-macro/1.0.82 \
+    crate://crates.io/data-encoding-macro-internal/0.1.10 \
+    crate://crates.io/data-encoding-macro/0.1.12 \
+    crate://crates.io/data-encoding/2.3.2 \
+    crate://crates.io/diff/0.1.13 \
+    crate://crates.io/digest/0.10.6 \
+    crate://crates.io/dlv-list/0.3.0 \
+    crate://crates.io/dns-lookup/1.0.8 \
+    crate://crates.io/dunce/1.0.3 \
+    crate://crates.io/either/1.8.0 \
+    crate://crates.io/encode_unicode/0.3.6 \
+    crate://crates.io/env_logger/0.8.4 \
+    crate://crates.io/errno-dragonfly/0.1.2 \
+    crate://crates.io/errno/0.2.8 \
+    crate://crates.io/exacl/0.9.0 \
+    crate://crates.io/fastrand/1.8.0 \
+    crate://crates.io/file_diff/1.0.0 \
+    crate://crates.io/filetime/0.2.18 \
+    crate://crates.io/flate2/1.0.24 \
+    crate://crates.io/fnv/1.0.7 \
+    crate://crates.io/fs_extra/1.2.0 \
+    crate://crates.io/fsevent-sys/4.1.0 \
+    crate://crates.io/fts-sys/0.2.3 \
+    crate://crates.io/futures-channel/0.3.25 \
+    crate://crates.io/futures-core/0.3.25 \
+    crate://crates.io/futures-executor/0.3.25 \
+    crate://crates.io/futures-io/0.3.25 \
+    crate://crates.io/futures-macro/0.3.25 \
+    crate://crates.io/futures-sink/0.3.25 \
+    crate://crates.io/futures-task/0.3.25 \
+    crate://crates.io/futures-timer/3.0.2 \
+    crate://crates.io/futures-util/0.3.25 \
+    crate://crates.io/futures/0.3.25 \
+    crate://crates.io/gcd/2.1.0 \
+    crate://crates.io/generic-array/0.14.6 \
+    crate://crates.io/getrandom/0.2.8 \
+    crate://crates.io/glob/0.3.0 \
+    crate://crates.io/half/2.1.0 \
+    crate://crates.io/hashbrown/0.12.3 \
+    crate://crates.io/heck/0.4.0 \
+    crate://crates.io/hermit-abi/0.1.19 \
+    crate://crates.io/hex-literal/0.3.4 \
+    crate://crates.io/hex/0.4.3 \
+    crate://crates.io/hostname/0.3.1 \
+    crate://crates.io/iana-time-zone-haiku/0.1.1 \
+    crate://crates.io/iana-time-zone/0.1.53 \
+    crate://crates.io/indicatif/0.17.2 \
+    crate://crates.io/inotify-sys/0.1.5 \
+    crate://crates.io/inotify/0.9.6 \
+    crate://crates.io/instant/0.1.12 \
+    crate://crates.io/io-lifetimes/0.7.5 \
+    crate://crates.io/itertools/0.10.5 \
+    crate://crates.io/itoa/1.0.4 \
+    crate://crates.io/js-sys/0.3.60 \
+    crate://crates.io/keccak/0.1.3 \
+    crate://crates.io/kqueue-sys/1.0.3 \
+    crate://crates.io/kqueue/1.0.7 \
+    crate://crates.io/lazy_static/1.4.0 \
+    crate://crates.io/lazycell/1.3.0 \
+    crate://crates.io/libc/0.2.137 \
+    crate://crates.io/libloading/0.7.4 \
+    crate://crates.io/link-cplusplus/1.0.7 \
+    crate://crates.io/linux-raw-sys/0.0.46 \
+    crate://crates.io/lock_api/0.4.9 \
+    crate://crates.io/log/0.4.17 \
+    crate://crates.io/lscolors/0.13.0 \
+    crate://crates.io/match_cfg/0.1.0 \
+    crate://crates.io/md-5/0.10.5 \
+    crate://crates.io/memchr/2.5.0 \
+    crate://crates.io/memmap2/0.5.8 \
+    crate://crates.io/memoffset/0.6.5 \
+    crate://crates.io/memoffset/0.7.1 \
+    crate://crates.io/minimal-lexical/0.2.1 \
+    crate://crates.io/miniz_oxide/0.5.4 \
+    crate://crates.io/mio/0.8.5 \
+    crate://crates.io/nix/0.25.0 \
+    crate://crates.io/nom/7.1.1 \
+    crate://crates.io/notify/5.0.0 \
+    crate://crates.io/nu-ansi-term/0.46.0 \
+    crate://crates.io/num-bigint/0.4.3 \
+    crate://crates.io/num-integer/0.1.45 \
+    crate://crates.io/num-traits/0.2.15 \
+    crate://crates.io/num_cpus/1.14.0 \
+    crate://crates.io/num_threads/0.1.6 \
+    crate://crates.io/number_prefix/0.4.0 \
+    crate://crates.io/once_cell/1.16.0 \
+    crate://crates.io/onig/6.4.0 \
+    crate://crates.io/onig_sys/69.8.1 \
+    crate://crates.io/ordered-multimap/0.4.3 \
+    crate://crates.io/os_display/0.1.3 \
+    crate://crates.io/os_str_bytes/6.4.1 \
+    crate://crates.io/ouroboros/0.15.5 \
+    crate://crates.io/ouroboros_macro/0.15.5 \
+    crate://crates.io/output_vt100/0.1.3 \
+    crate://crates.io/overload/0.1.1 \
+    crate://crates.io/parking_lot/0.12.1 \
+    crate://crates.io/parking_lot_core/0.9.4 \
+    crate://crates.io/paste/1.0.9 \
+    crate://crates.io/peeking_take_while/0.1.2 \
+    crate://crates.io/phf/0.11.1 \
+    crate://crates.io/phf_codegen/0.11.1 \
+    crate://crates.io/phf_generator/0.11.1 \
+    crate://crates.io/phf_shared/0.11.1 \
+    crate://crates.io/pin-project-lite/0.2.9 \
+    crate://crates.io/pin-utils/0.1.0 \
+    crate://crates.io/pkg-config/0.3.26 \
+    crate://crates.io/platform-info/1.0.2 \
+    crate://crates.io/portable-atomic/0.3.15 \
+    crate://crates.io/ppv-lite86/0.2.17 \
+    crate://crates.io/pretty_assertions/1.3.0 \
+    crate://crates.io/proc-macro-error-attr/1.0.4 \
+    crate://crates.io/proc-macro-error/1.0.4 \
+    crate://crates.io/proc-macro2/1.0.47 \
+    crate://crates.io/procfs/0.14.1 \
+    crate://crates.io/quick-error/2.0.1 \
+    crate://crates.io/quickcheck/1.0.3 \
+    crate://crates.io/quote/1.0.21 \
+    crate://crates.io/rand/0.8.5 \
+    crate://crates.io/rand_chacha/0.3.1 \
+    crate://crates.io/rand_core/0.6.4 \
+    crate://crates.io/rand_pcg/0.3.1 \
+    crate://crates.io/rayon-core/1.10.1 \
+    crate://crates.io/rayon/1.6.0 \
+    crate://crates.io/redox_syscall/0.2.16 \
+    crate://crates.io/reference-counted-singleton/0.1.2 \
+    crate://crates.io/regex-automata/0.1.10 \
+    crate://crates.io/regex-syntax/0.6.28 \
+    crate://crates.io/regex/1.7.0 \
+    crate://crates.io/remove_dir_all/0.5.3 \
+    crate://crates.io/remove_dir_all/0.7.0 \
+    crate://crates.io/retain_mut/0.1.7 \
+    crate://crates.io/rlimit/0.8.3 \
+    crate://crates.io/rstest/0.16.0 \
+    crate://crates.io/rstest_macros/0.16.0 \
+    crate://crates.io/rust-ini/0.18.0 \
+    crate://crates.io/rustc-hash/1.1.0 \
+    crate://crates.io/rustc_version/0.4.0 \
+    crate://crates.io/rustix/0.35.13 \
+    crate://crates.io/rustversion/1.0.9 \
+    crate://crates.io/same-file/1.0.6 \
+    crate://crates.io/scopeguard/1.1.0 \
+    crate://crates.io/scratch/1.0.2 \
+    crate://crates.io/selinux-sys/0.6.1 \
+    crate://crates.io/selinux/0.3.1 \
+    crate://crates.io/semver/1.0.14 \
+    crate://crates.io/serde/1.0.147 \
+    crate://crates.io/sha1/0.10.5 \
+    crate://crates.io/sha2/0.10.6 \
+    crate://crates.io/sha3/0.10.6 \
+    crate://crates.io/shlex/1.1.0 \
+    crate://crates.io/signal-hook-mio/0.2.3 \
+    crate://crates.io/signal-hook-registry/1.4.0 \
+    crate://crates.io/signal-hook/0.3.14 \
+    crate://crates.io/siphasher/0.3.10 \
+    crate://crates.io/slab/0.4.7 \
+    crate://crates.io/smallvec/1.10.0 \
+    crate://crates.io/smawk/0.3.1 \
+    crate://crates.io/socket2/0.4.7 \
+    crate://crates.io/strsim/0.10.0 \
+    crate://crates.io/strum/0.24.1 \
+    crate://crates.io/strum_macros/0.24.3 \
+    crate://crates.io/subtle/2.4.1 \
+    crate://crates.io/syn/1.0.103 \
+    crate://crates.io/tempfile/3.3.0 \
+    crate://crates.io/term_grid/0.1.7 \
+    crate://crates.io/termcolor/1.1.3 \
+    crate://crates.io/terminal_size/0.1.17 \
+    crate://crates.io/terminal_size/0.2.2 \
+    crate://crates.io/textwrap/0.16.0 \
+    crate://crates.io/thiserror-impl/1.0.37 \
+    crate://crates.io/thiserror/1.0.37 \
+    crate://crates.io/time-core/0.1.0 \
+    crate://crates.io/time-macros/0.2.6 \
+    crate://crates.io/time/0.3.17 \
+    crate://crates.io/typenum/1.15.0 \
+    crate://crates.io/unicode-ident/1.0.5 \
+    crate://crates.io/unicode-linebreak/0.1.4 \
+    crate://crates.io/unicode-segmentation/1.10.0 \
+    crate://crates.io/unicode-width/0.1.10 \
+    crate://crates.io/unicode-xid/0.2.4 \
+    crate://crates.io/unindent/0.1.10 \
+    crate://crates.io/users/0.11.0 \
+    crate://crates.io/utf-8/0.7.6 \
+    crate://crates.io/uuid/1.2.2 \
+    crate://crates.io/version_check/0.9.4 \
+    crate://crates.io/walkdir/2.3.2 \
+    crate://crates.io/wasi/0.11.0+wasi-snapshot-preview1 \
+    crate://crates.io/wasm-bindgen-backend/0.2.83 \
+    crate://crates.io/wasm-bindgen-macro-support/0.2.83 \
+    crate://crates.io/wasm-bindgen-macro/0.2.83 \
+    crate://crates.io/wasm-bindgen-shared/0.2.83 \
+    crate://crates.io/wasm-bindgen/0.2.83 \
+    crate://crates.io/which/4.3.0 \
+    crate://crates.io/wild/2.1.0 \
+    crate://crates.io/winapi-i686-pc-windows-gnu/0.4.0 \
+    crate://crates.io/winapi-util/0.1.5 \
+    crate://crates.io/winapi-x86_64-pc-windows-gnu/0.4.0 \
+    crate://crates.io/winapi/0.3.9 \
+    crate://crates.io/windows-sys/0.42.0 \
+    crate://crates.io/windows_aarch64_gnullvm/0.42.0 \
+    crate://crates.io/windows_aarch64_msvc/0.42.0 \
+    crate://crates.io/windows_i686_gnu/0.42.0 \
+    crate://crates.io/windows_i686_msvc/0.42.0 \
+    crate://crates.io/windows_x86_64_gnu/0.42.0 \
+    crate://crates.io/windows_x86_64_gnullvm/0.42.0 \
+    crate://crates.io/windows_x86_64_msvc/0.42.0 \
+    crate://crates.io/xattr/0.2.3 \
+    crate://crates.io/yansi/0.5.1 \
+    crate://crates.io/z85/3.0.5 \
+    crate://crates.io/zip/0.6.3 \
+"
diff --git a/meta-openembedded/meta-oe/recipes-core/uutils-coreutils/uutils-coreutils_0.0.17.bb b/meta-openembedded/meta-oe/recipes-core/uutils-coreutils/uutils-coreutils_0.0.17.bb
index 61d7c8c..4d3c2f7 100644
--- a/meta-openembedded/meta-oe/recipes-core/uutils-coreutils/uutils-coreutils_0.0.17.bb
+++ b/meta-openembedded/meta-oe/recipes-core/uutils-coreutils/uutils-coreutils_0.0.17.bb
@@ -1,303 +1,14 @@
-# Auto-Generated by cargo-bitbake 0.3.16
-#
-inherit cargo
-
-# If this is git based prefer versioned ones if they exist
-# DEFAULT_PREFERENCE = "-1"
-
-# how to get coreutils could be as easy as but default to a git checkout:
-# SRC_URI += "crate://crates.io/coreutils/0.0.17"
-SRC_URI += "git://github.com/uutils/coreutils.git;protocol=https;nobranch=1"
-SRCREV = "7e127005afbd6c3632d74ad8082340ccb8329d67"
-S = "${WORKDIR}/git"
-CARGO_SRC_DIR = ""
-
-
-# please note if you have entries that do not begin with crate://
-# you must change them to how that package can be fetched
-SRC_URI += " \
-    crate://crates.io/Inflector/0.11.4 \
-    crate://crates.io/adler/1.0.2 \
-    crate://crates.io/ahash/0.7.6 \
-    crate://crates.io/aho-corasick/0.7.19 \
-    crate://crates.io/aliasable/0.1.3 \
-    crate://crates.io/android_system_properties/0.1.5 \
-    crate://crates.io/arrayref/0.3.6 \
-    crate://crates.io/arrayvec/0.7.2 \
-    crate://crates.io/atty/0.2.14 \
-    crate://crates.io/autocfg/1.1.0 \
-    crate://crates.io/bigdecimal/0.3.0 \
-    crate://crates.io/binary-heap-plus/0.5.0 \
-    crate://crates.io/bindgen/0.62.0 \
-    crate://crates.io/bitflags/1.3.2 \
-    crate://crates.io/blake2b_simd/1.0.0 \
-    crate://crates.io/blake3/1.3.2 \
-    crate://crates.io/block-buffer/0.10.3 \
-    crate://crates.io/bstr/1.0.1 \
-    crate://crates.io/bumpalo/3.11.1 \
-    crate://crates.io/bytecount/0.6.3 \
-    crate://crates.io/byteorder/1.4.3 \
-    crate://crates.io/cc/1.0.77 \
-    crate://crates.io/cexpr/0.6.0 \
-    crate://crates.io/cfg-if/1.0.0 \
-    crate://crates.io/chrono/0.4.23 \
-    crate://crates.io/clang-sys/1.4.0 \
-    crate://crates.io/clap/4.0.26 \
-    crate://crates.io/clap_complete/4.0.6 \
-    crate://crates.io/clap_lex/0.3.0 \
-    crate://crates.io/codespan-reporting/0.11.1 \
-    crate://crates.io/compare/0.1.0 \
-    crate://crates.io/console/0.15.2 \
-    crate://crates.io/constant_time_eq/0.1.5 \
-    crate://crates.io/constant_time_eq/0.2.4 \
-    crate://crates.io/conv/0.3.3 \
-    crate://crates.io/core-foundation-sys/0.8.3 \
-    crate://crates.io/coz/0.1.3 \
-    crate://crates.io/cpp/0.5.7 \
-    crate://crates.io/cpp_build/0.5.7 \
-    crate://crates.io/cpp_common/0.5.7 \
-    crate://crates.io/cpp_macros/0.5.7 \
-    crate://crates.io/cpufeatures/0.2.5 \
-    crate://crates.io/crc32fast/1.3.2 \
-    crate://crates.io/crossbeam-channel/0.5.6 \
-    crate://crates.io/crossbeam-deque/0.8.2 \
-    crate://crates.io/crossbeam-epoch/0.9.12 \
-    crate://crates.io/crossbeam-utils/0.8.13 \
-    crate://crates.io/crossterm/0.25.0 \
-    crate://crates.io/crossterm_winapi/0.9.0 \
-    crate://crates.io/crunchy/0.2.2 \
-    crate://crates.io/crypto-common/0.1.6 \
-    crate://crates.io/ctor/0.1.26 \
-    crate://crates.io/ctrlc/3.2.3 \
-    crate://crates.io/custom_derive/0.1.7 \
-    crate://crates.io/cxx-build/1.0.82 \
-    crate://crates.io/cxx/1.0.82 \
-    crate://crates.io/cxxbridge-flags/1.0.82 \
-    crate://crates.io/cxxbridge-macro/1.0.82 \
-    crate://crates.io/data-encoding-macro-internal/0.1.10 \
-    crate://crates.io/data-encoding-macro/0.1.12 \
-    crate://crates.io/data-encoding/2.3.2 \
-    crate://crates.io/diff/0.1.13 \
-    crate://crates.io/digest/0.10.6 \
-    crate://crates.io/dlv-list/0.3.0 \
-    crate://crates.io/dns-lookup/1.0.8 \
-    crate://crates.io/dunce/1.0.3 \
-    crate://crates.io/either/1.8.0 \
-    crate://crates.io/encode_unicode/0.3.6 \
-    crate://crates.io/env_logger/0.8.4 \
-    crate://crates.io/errno-dragonfly/0.1.2 \
-    crate://crates.io/errno/0.2.8 \
-    crate://crates.io/exacl/0.9.0 \
-    crate://crates.io/fastrand/1.8.0 \
-    crate://crates.io/file_diff/1.0.0 \
-    crate://crates.io/filetime/0.2.18 \
-    crate://crates.io/flate2/1.0.24 \
-    crate://crates.io/fnv/1.0.7 \
-    crate://crates.io/fs_extra/1.2.0 \
-    crate://crates.io/fsevent-sys/4.1.0 \
-    crate://crates.io/fts-sys/0.2.3 \
-    crate://crates.io/futures-channel/0.3.25 \
-    crate://crates.io/futures-core/0.3.25 \
-    crate://crates.io/futures-executor/0.3.25 \
-    crate://crates.io/futures-io/0.3.25 \
-    crate://crates.io/futures-macro/0.3.25 \
-    crate://crates.io/futures-sink/0.3.25 \
-    crate://crates.io/futures-task/0.3.25 \
-    crate://crates.io/futures-timer/3.0.2 \
-    crate://crates.io/futures-util/0.3.25 \
-    crate://crates.io/futures/0.3.25 \
-    crate://crates.io/gcd/2.1.0 \
-    crate://crates.io/generic-array/0.14.6 \
-    crate://crates.io/getrandom/0.2.8 \
-    crate://crates.io/glob/0.3.0 \
-    crate://crates.io/half/2.1.0 \
-    crate://crates.io/hashbrown/0.12.3 \
-    crate://crates.io/heck/0.4.0 \
-    crate://crates.io/hermit-abi/0.1.19 \
-    crate://crates.io/hex-literal/0.3.4 \
-    crate://crates.io/hex/0.4.3 \
-    crate://crates.io/hostname/0.3.1 \
-    crate://crates.io/iana-time-zone-haiku/0.1.1 \
-    crate://crates.io/iana-time-zone/0.1.53 \
-    crate://crates.io/indicatif/0.17.2 \
-    crate://crates.io/inotify-sys/0.1.5 \
-    crate://crates.io/inotify/0.9.6 \
-    crate://crates.io/instant/0.1.12 \
-    crate://crates.io/io-lifetimes/0.7.5 \
-    crate://crates.io/itertools/0.10.5 \
-    crate://crates.io/itoa/1.0.4 \
-    crate://crates.io/js-sys/0.3.60 \
-    crate://crates.io/keccak/0.1.3 \
-    crate://crates.io/kqueue-sys/1.0.3 \
-    crate://crates.io/kqueue/1.0.7 \
-    crate://crates.io/lazy_static/1.4.0 \
-    crate://crates.io/lazycell/1.3.0 \
-    crate://crates.io/libc/0.2.137 \
-    crate://crates.io/libloading/0.7.4 \
-    crate://crates.io/link-cplusplus/1.0.7 \
-    crate://crates.io/linux-raw-sys/0.0.46 \
-    crate://crates.io/lock_api/0.4.9 \
-    crate://crates.io/log/0.4.17 \
-    crate://crates.io/lscolors/0.13.0 \
-    crate://crates.io/match_cfg/0.1.0 \
-    crate://crates.io/md-5/0.10.5 \
-    crate://crates.io/memchr/2.5.0 \
-    crate://crates.io/memmap2/0.5.8 \
-    crate://crates.io/memoffset/0.6.5 \
-    crate://crates.io/memoffset/0.7.1 \
-    crate://crates.io/minimal-lexical/0.2.1 \
-    crate://crates.io/miniz_oxide/0.5.4 \
-    crate://crates.io/mio/0.8.5 \
-    crate://crates.io/nix/0.25.0 \
-    crate://crates.io/nom/7.1.1 \
-    crate://crates.io/notify/5.0.0 \
-    crate://crates.io/nu-ansi-term/0.46.0 \
-    crate://crates.io/num-bigint/0.4.3 \
-    crate://crates.io/num-integer/0.1.45 \
-    crate://crates.io/num-traits/0.2.15 \
-    crate://crates.io/num_cpus/1.14.0 \
-    crate://crates.io/num_threads/0.1.6 \
-    crate://crates.io/number_prefix/0.4.0 \
-    crate://crates.io/once_cell/1.16.0 \
-    crate://crates.io/onig/6.4.0 \
-    crate://crates.io/onig_sys/69.8.1 \
-    crate://crates.io/ordered-multimap/0.4.3 \
-    crate://crates.io/os_display/0.1.3 \
-    crate://crates.io/os_str_bytes/6.4.1 \
-    crate://crates.io/ouroboros/0.15.5 \
-    crate://crates.io/ouroboros_macro/0.15.5 \
-    crate://crates.io/output_vt100/0.1.3 \
-    crate://crates.io/overload/0.1.1 \
-    crate://crates.io/parking_lot/0.12.1 \
-    crate://crates.io/parking_lot_core/0.9.4 \
-    crate://crates.io/paste/1.0.9 \
-    crate://crates.io/peeking_take_while/0.1.2 \
-    crate://crates.io/phf/0.11.1 \
-    crate://crates.io/phf_codegen/0.11.1 \
-    crate://crates.io/phf_generator/0.11.1 \
-    crate://crates.io/phf_shared/0.11.1 \
-    crate://crates.io/pin-project-lite/0.2.9 \
-    crate://crates.io/pin-utils/0.1.0 \
-    crate://crates.io/pkg-config/0.3.26 \
-    crate://crates.io/platform-info/1.0.2 \
-    crate://crates.io/portable-atomic/0.3.15 \
-    crate://crates.io/ppv-lite86/0.2.17 \
-    crate://crates.io/pretty_assertions/1.3.0 \
-    crate://crates.io/proc-macro-error-attr/1.0.4 \
-    crate://crates.io/proc-macro-error/1.0.4 \
-    crate://crates.io/proc-macro2/1.0.47 \
-    crate://crates.io/procfs/0.14.1 \
-    crate://crates.io/quick-error/2.0.1 \
-    crate://crates.io/quickcheck/1.0.3 \
-    crate://crates.io/quote/1.0.21 \
-    crate://crates.io/rand/0.8.5 \
-    crate://crates.io/rand_chacha/0.3.1 \
-    crate://crates.io/rand_core/0.6.4 \
-    crate://crates.io/rand_pcg/0.3.1 \
-    crate://crates.io/rayon-core/1.10.1 \
-    crate://crates.io/rayon/1.6.0 \
-    crate://crates.io/redox_syscall/0.2.16 \
-    crate://crates.io/reference-counted-singleton/0.1.2 \
-    crate://crates.io/regex-automata/0.1.10 \
-    crate://crates.io/regex-syntax/0.6.28 \
-    crate://crates.io/regex/1.7.0 \
-    crate://crates.io/remove_dir_all/0.5.3 \
-    crate://crates.io/remove_dir_all/0.7.0 \
-    crate://crates.io/retain_mut/0.1.7 \
-    crate://crates.io/rlimit/0.8.3 \
-    crate://crates.io/rstest/0.16.0 \
-    crate://crates.io/rstest_macros/0.16.0 \
-    crate://crates.io/rust-ini/0.18.0 \
-    crate://crates.io/rustc-hash/1.1.0 \
-    crate://crates.io/rustc_version/0.4.0 \
-    crate://crates.io/rustix/0.35.13 \
-    crate://crates.io/rustversion/1.0.9 \
-    crate://crates.io/same-file/1.0.6 \
-    crate://crates.io/scopeguard/1.1.0 \
-    crate://crates.io/scratch/1.0.2 \
-    crate://crates.io/selinux-sys/0.6.1 \
-    crate://crates.io/selinux/0.3.1 \
-    crate://crates.io/semver/1.0.14 \
-    crate://crates.io/serde/1.0.147 \
-    crate://crates.io/sha1/0.10.5 \
-    crate://crates.io/sha2/0.10.6 \
-    crate://crates.io/sha3/0.10.6 \
-    crate://crates.io/shlex/1.1.0 \
-    crate://crates.io/signal-hook-mio/0.2.3 \
-    crate://crates.io/signal-hook-registry/1.4.0 \
-    crate://crates.io/signal-hook/0.3.14 \
-    crate://crates.io/siphasher/0.3.10 \
-    crate://crates.io/slab/0.4.7 \
-    crate://crates.io/smallvec/1.10.0 \
-    crate://crates.io/smawk/0.3.1 \
-    crate://crates.io/socket2/0.4.7 \
-    crate://crates.io/strsim/0.10.0 \
-    crate://crates.io/strum/0.24.1 \
-    crate://crates.io/strum_macros/0.24.3 \
-    crate://crates.io/subtle/2.4.1 \
-    crate://crates.io/syn/1.0.103 \
-    crate://crates.io/tempfile/3.3.0 \
-    crate://crates.io/term_grid/0.1.7 \
-    crate://crates.io/termcolor/1.1.3 \
-    crate://crates.io/terminal_size/0.1.17 \
-    crate://crates.io/terminal_size/0.2.2 \
-    crate://crates.io/textwrap/0.16.0 \
-    crate://crates.io/thiserror-impl/1.0.37 \
-    crate://crates.io/thiserror/1.0.37 \
-    crate://crates.io/time-core/0.1.0 \
-    crate://crates.io/time-macros/0.2.6 \
-    crate://crates.io/time/0.3.17 \
-    crate://crates.io/typenum/1.15.0 \
-    crate://crates.io/unicode-ident/1.0.5 \
-    crate://crates.io/unicode-linebreak/0.1.4 \
-    crate://crates.io/unicode-segmentation/1.10.0 \
-    crate://crates.io/unicode-width/0.1.10 \
-    crate://crates.io/unicode-xid/0.2.4 \
-    crate://crates.io/unindent/0.1.10 \
-    crate://crates.io/users/0.11.0 \
-    crate://crates.io/utf-8/0.7.6 \
-    crate://crates.io/uuid/1.2.2 \
-    crate://crates.io/version_check/0.9.4 \
-    crate://crates.io/walkdir/2.3.2 \
-    crate://crates.io/wasi/0.11.0+wasi-snapshot-preview1 \
-    crate://crates.io/wasm-bindgen-backend/0.2.83 \
-    crate://crates.io/wasm-bindgen-macro-support/0.2.83 \
-    crate://crates.io/wasm-bindgen-macro/0.2.83 \
-    crate://crates.io/wasm-bindgen-shared/0.2.83 \
-    crate://crates.io/wasm-bindgen/0.2.83 \
-    crate://crates.io/which/4.3.0 \
-    crate://crates.io/wild/2.1.0 \
-    crate://crates.io/winapi-i686-pc-windows-gnu/0.4.0 \
-    crate://crates.io/winapi-util/0.1.5 \
-    crate://crates.io/winapi-x86_64-pc-windows-gnu/0.4.0 \
-    crate://crates.io/winapi/0.3.9 \
-    crate://crates.io/windows-sys/0.42.0 \
-    crate://crates.io/windows_aarch64_gnullvm/0.42.0 \
-    crate://crates.io/windows_aarch64_msvc/0.42.0 \
-    crate://crates.io/windows_i686_gnu/0.42.0 \
-    crate://crates.io/windows_i686_msvc/0.42.0 \
-    crate://crates.io/windows_x86_64_gnu/0.42.0 \
-    crate://crates.io/windows_x86_64_gnullvm/0.42.0 \
-    crate://crates.io/windows_x86_64_msvc/0.42.0 \
-    crate://crates.io/xattr/0.2.3 \
-    crate://crates.io/yansi/0.5.1 \
-    crate://crates.io/z85/3.0.5 \
-    crate://crates.io/zip/0.6.3 \
-"
-
-
-
-# FIXME: update generateme with the real MD5 of the license file
-LIC_FILES_CHKSUM = " \
-    file://LICENSE;md5=41f7469eaacac62c67d5664fff2c062d \
-"
-
 SUMMARY = "coreutils ~ GNU coreutils (updated); implemented as universal (cross-platform) utils, written in Rust"
 HOMEPAGE = "https://github.com/uutils/coreutils"
 LICENSE = "MIT"
+LIC_FILES_CHKSUM = "file://LICENSE;md5=41f7469eaacac62c67d5664fff2c062d"
 
-# includes this file if it exists but does not fail
-# this is useful for anything you may want to override from
-# what cargo-bitbake generates.
-include uutils-coreutils-${PV}.inc
+inherit cargo cargo-update-recipe-crates
+
+SRC_URI += "git://github.com/uutils/coreutils.git;protocol=https;nobranch=1"
+SRCREV = "7e127005afbd6c3632d74ad8082340ccb8329d67"
+S = "${WORKDIR}/git"
+
+require ${BPN}-crates.inc
+
 include uutils-coreutils.inc
diff --git a/meta-openembedded/meta-oe/recipes-crypto/cryptsetup/cryptsetup/0001-Replace-off64_t-with-off_t.patch b/meta-openembedded/meta-oe/recipes-crypto/cryptsetup/cryptsetup/0001-Replace-off64_t-with-off_t.patch
deleted file mode 100644
index 23aa86c..0000000
--- a/meta-openembedded/meta-oe/recipes-crypto/cryptsetup/cryptsetup/0001-Replace-off64_t-with-off_t.patch
+++ /dev/null
@@ -1,101 +0,0 @@
-From 683d0c525765415be34c269edf9cc066276f9f65 Mon Sep 17 00:00:00 2001
-From: Khem Raj <raj.khem@gmail.com>
-Date: Sun, 18 Dec 2022 13:53:51 -0800
-Subject: [PATCH] Replace off64_t with off_t
-
-AC_SYS_LARGEFILE autoconf macro is in use in configure script which will
-add needed feature macros on commandline to enable 64bit off_t.
-
-Also replace lseek64 with lseek, since it will be same when
-_FILE_OFFSET_BITS=64 is defined on relevant platforms via AC_SYS_LARGEFILE
-
-Upstream-Status: Submitted [https://gitlab.com/cryptsetup/cryptsetup/-/merge_requests/467]
-Signed-off-by: Khem Raj <raj.khem@gmail.com>
----
- lib/utils.c                 |  4 ++--
- lib/utils_wipe.c            |  4 ++--
- src/utils_reencrypt_luks1.c | 12 ++++++------
- 3 files changed, 10 insertions(+), 10 deletions(-)
-
-diff --git a/lib/utils.c b/lib/utils.c
-index 9d79ee29..be5f5287 100644
---- a/lib/utils.c
-+++ b/lib/utils.c
-@@ -102,9 +102,9 @@ static int keyfile_seek(int fd, uint64_t bytes)
- 	char tmp[BUFSIZ];
- 	size_t next_read;
- 	ssize_t bytes_r;
--	off64_t r;
-+	off_t r;
- 
--	r = lseek64(fd, bytes, SEEK_CUR);
-+	r = lseek(fd, bytes, SEEK_CUR);
- 	if (r > 0)
- 		return 0;
- 	if (r < 0 && errno != ESPIPE)
-diff --git a/lib/utils_wipe.c b/lib/utils_wipe.c
-index 285a9e77..0c376f44 100644
---- a/lib/utils_wipe.c
-+++ b/lib/utils_wipe.c
-@@ -150,7 +150,7 @@ static int wipe_block(struct crypt_device *cd, int devfd, crypt_wipe_pattern pat
- 	if (blockdev && pattern == CRYPT_WIPE_ZERO &&
- 	    !wipe_zeroout(cd, devfd, offset, wipe_block_size)) {
- 		/* zeroout ioctl does not move offset */
--		if (lseek64(devfd, offset + wipe_block_size, SEEK_SET) < 0) {
-+		if (lseek(devfd, offset + wipe_block_size, SEEK_SET) < 0) {
- 			log_err(cd, _("Cannot seek to device offset."));
- 			return -EINVAL;
- 		}
-@@ -221,7 +221,7 @@ int crypt_wipe_device(struct crypt_device *cd,
- 	if (r)
- 		goto out;
- 
--	if (lseek64(devfd, offset, SEEK_SET) < 0) {
-+	if (lseek(devfd, offset, SEEK_SET) < 0) {
- 		log_err(cd, _("Cannot seek to device offset."));
- 		r = -EINVAL;
- 		goto out;
-diff --git a/src/utils_reencrypt_luks1.c b/src/utils_reencrypt_luks1.c
-index 96368bdb..d83a1da4 100644
---- a/src/utils_reencrypt_luks1.c
-+++ b/src/utils_reencrypt_luks1.c
-@@ -729,8 +729,8 @@ static int copy_data_forward(struct reenc_ctx *rc, int fd_old, int fd_new,
- 
- 	log_dbg("Reencrypting in forward direction.");
- 
--	if (lseek64(fd_old, rc->device_offset, SEEK_SET) < 0 ||
--	    lseek64(fd_new, rc->device_offset, SEEK_SET) < 0) {
-+	if (lseek(fd_old, rc->device_offset, SEEK_SET) < 0 ||
-+	    lseek(fd_new, rc->device_offset, SEEK_SET) < 0) {
- 		log_err(_("Cannot seek to device offset."));
- 		goto out;
- 	}
-@@ -788,7 +788,7 @@ static int copy_data_backward(struct reenc_ctx *rc, int fd_old, int fd_new,
- 			      size_t block_size, void *buf, uint64_t *bytes)
- {
- 	ssize_t s1, s2, working_block;
--	off64_t working_offset;
-+	off_t working_offset;
- 	int r = -EIO;
- 	char *backing_file = NULL;
- 	struct tools_progress_params prog_parms = {
-@@ -827,8 +827,8 @@ static int copy_data_backward(struct reenc_ctx *rc, int fd_old, int fd_new,
- 			working_block = block_size;
- 		}
- 
--		if (lseek64(fd_old, working_offset, SEEK_SET) < 0 ||
--		    lseek64(fd_new, working_offset, SEEK_SET) < 0) {
-+		if (lseek(fd_old, working_offset, SEEK_SET) < 0 ||
-+		    lseek(fd_new, working_offset, SEEK_SET) < 0) {
- 			log_err(_("Cannot seek to device offset."));
- 			goto out;
- 		}
-@@ -874,7 +874,7 @@ static void zero_rest_of_device(int fd, size_t block_size, void *buf,
- 
- 	log_dbg("Zeroing rest of device.");
- 
--	if (lseek64(fd, offset, SEEK_SET) < 0) {
-+	if (lseek(fd, offset, SEEK_SET) < 0) {
- 		log_dbg("Cannot seek to device offset.");
- 		return;
- 	}
diff --git a/meta-openembedded/meta-oe/recipes-crypto/cryptsetup/cryptsetup_2.6.0.bb b/meta-openembedded/meta-oe/recipes-crypto/cryptsetup/cryptsetup_2.6.1.bb
similarity index 96%
rename from meta-openembedded/meta-oe/recipes-crypto/cryptsetup/cryptsetup_2.6.0.bb
rename to meta-openembedded/meta-oe/recipes-crypto/cryptsetup/cryptsetup_2.6.1.bb
index 1d4f440..2935221 100644
--- a/meta-openembedded/meta-oe/recipes-crypto/cryptsetup/cryptsetup_2.6.0.bb
+++ b/meta-openembedded/meta-oe/recipes-crypto/cryptsetup/cryptsetup_2.6.1.bb
@@ -19,10 +19,8 @@
 DEPENDS:append:libc-musl = " argp-standalone"
 LDFLAGS:append:libc-musl = " -largp"
 
-SRC_URI = "${KERNELORG_MIRROR}/linux/utils/${BPN}/v${@d.getVar('PV').split('.')[0]}.${@d.getVar('PV').split('.')[1]}/${BP}.tar.xz \
-           file://0001-Replace-off64_t-with-off_t.patch \
-           "
-SRC_URI[sha256sum] = "44397ba76e75a9cde5b02177bc63cd7af428a785788e3a7067733e7761842735"
+SRC_URI = "${KERNELORG_MIRROR}/linux/utils/${BPN}/v${@d.getVar('PV').split('.')[0]}.${@d.getVar('PV').split('.')[1]}/${BP}.tar.xz"
+SRC_URI[sha256sum] = "410ded65a1072ab9c8e41added37b9729c087fef4d2db02bb4ef529ad6da4693"
 
 inherit autotools gettext pkgconfig
 
diff --git a/meta-openembedded/meta-oe/recipes-crypto/pkcs11-helper/pkcs11-helper_1.29.0.bb b/meta-openembedded/meta-oe/recipes-crypto/pkcs11-helper/pkcs11-helper_1.29.0.bb
index a34a4b9..d17ac1e 100644
--- a/meta-openembedded/meta-oe/recipes-crypto/pkcs11-helper/pkcs11-helper_1.29.0.bb
+++ b/meta-openembedded/meta-oe/recipes-crypto/pkcs11-helper/pkcs11-helper_1.29.0.bb
@@ -18,8 +18,9 @@
 SRC_URI = "git://github.com/OpenSC/${BPN}.git;branch=master;protocol=https"
 
 S = "${WORKDIR}/git"
-# v1.27
-SRCREV = "2306f896c2f3c147792300155316fd65825aabad"
+# master
+SRCREV = "f23911037d9790a3f3a3447a78d31a6362358e21"
+PV .= "+1.30.0+git${SRCPV}"
 
 UPSTREAM_CHECK_GITTAGREGEX = "pkcs11-helper-(?P<pver>\d+(\.\d+)+)"
 
diff --git a/meta-openembedded/meta-oe/recipes-dbs/postgresql/files/0001-postgresql-fix-ptest-failure-of-sysviews.patch b/meta-openembedded/meta-oe/recipes-dbs/postgresql/files/0001-postgresql-fix-ptest-failure-of-sysviews.patch
new file mode 100644
index 0000000..4db36d2
--- /dev/null
+++ b/meta-openembedded/meta-oe/recipes-dbs/postgresql/files/0001-postgresql-fix-ptest-failure-of-sysviews.patch
@@ -0,0 +1,42 @@
+From 9f81377dddfe32d950844d7053020a36b40fce08 Mon Sep 17 00:00:00 2001
+From: Manoj Saun <manojsingh.saun@windriver.com>
+Date: Wed, 22 Mar 2023 08:07:26 +0000
+Subject: [PATCH] postgresql: fix ptest failure of sysviews
+
+The patch "0001-config_info.c-not-expose-build-info.patch" hides the debug info
+in pg_config table which reduces the count of rows from pg_config and leads to
+sysviews test failure.
+To fix it we need to reduce the count of parameters in sysviews test.
+Also we need to reduce the row count in expected result of sysview test
+to make the test output shown as pass.
+
+Upstream-Status: Inappropriate [oe specific]
+
+Signed-off-by: Manoj Saun <manojsingh.saun@windriver.com>
+---
+ src/test/regress/expected/sysviews.out | 2 +-
+ src/test/regress/sql/sysviews.sql      | 2 +-
+ 2 files changed, 2 insertions(+), 2 deletions(-)
+
+--- a/src/test/regress/expected/sysviews.out
++++ b/src/test/regress/expected/sysviews.out
+@@ -29,7 +29,7 @@ select name, ident, parent, level, total
+ (1 row)
+ 
+ -- At introduction, pg_config had 23 entries; it may grow
+-select count(*) > 20 as ok from pg_config;
++select count(*) > 13 as ok from pg_config;
+  ok 
+ ----
+  t
+--- a/src/test/regress/sql/sysviews.sql
++++ b/src/test/regress/sql/sysviews.sql
+@@ -18,7 +18,7 @@ select name, ident, parent, level, total
+   from pg_backend_memory_contexts where level = 0;
+ 
+ -- At introduction, pg_config had 23 entries; it may grow
+-select count(*) > 20 as ok from pg_config;
++select count(*) > 13 as ok from pg_config;
+ 
+ -- We expect no cursors in this test; see also portals.sql
+ select count(*) = 0 as ok from pg_cursors;
diff --git a/meta-openembedded/meta-oe/recipes-dbs/postgresql/postgresql.inc b/meta-openembedded/meta-oe/recipes-dbs/postgresql/postgresql.inc
index 60d44ce..15ecdee 100644
--- a/meta-openembedded/meta-oe/recipes-dbs/postgresql/postgresql.inc
+++ b/meta-openembedded/meta-oe/recipes-dbs/postgresql/postgresql.inc
@@ -36,7 +36,7 @@
 # LDFLAGS for shared libraries
 export LDFLAGS_SL = "${LDFLAGS}"
 
-inherit autotools pkgconfig perlnative python3native python3targetconfig useradd update-rc.d systemd gettext cpan-base
+inherit autotools pkgconfig perlnative python3native python3targetconfig useradd update-rc.d systemd gettext cpan-base multilib_header
 
 CFLAGS += "-I${STAGING_INCDIR}/${PYTHON_DIR} -I${STAGING_INCDIR}/tcl8.6"
 
@@ -183,6 +183,7 @@
 do_install:append() {
     # install contrib
     oe_runmake DESTDIR=${D} -C contrib install
+    oe_multilib_header pg_config.h pg_config_ext.h ecpg_config.h postgresql/server/pg_config.h postgresql/server/pg_config_ext.h
     # install tutorial
     install -d -m 0755 ${D}${libdir}/${BPN}/tutorial
     install ${B}/src/tutorial/* ${D}${libdir}/${BPN}/tutorial
diff --git a/meta-openembedded/meta-oe/recipes-dbs/postgresql/postgresql_15.2.bb b/meta-openembedded/meta-oe/recipes-dbs/postgresql/postgresql_15.2.bb
index befb0ca..5c95e4d 100644
--- a/meta-openembedded/meta-oe/recipes-dbs/postgresql/postgresql_15.2.bb
+++ b/meta-openembedded/meta-oe/recipes-dbs/postgresql/postgresql_15.2.bb
@@ -8,6 +8,7 @@
    file://0001-Improve-reproducibility.patch \
    file://0001-configure.ac-bypass-autoconf-2.69-version-check.patch \
    file://0001-config_info.c-not-expose-build-info.patch \
+   file://0001-postgresql-fix-ptest-failure-of-sysviews.patch \
 "
 
 SRC_URI[sha256sum] = "99a2171fc3d6b5b5f56b757a7a3cb85d509a38e4273805def23941ed2b8468c7"
diff --git a/meta-openembedded/meta-oe/recipes-devtools/abseil-cpp/abseil-cpp_git.bb b/meta-openembedded/meta-oe/recipes-devtools/abseil-cpp/abseil-cpp_git.bb
index f7f8fc8..08f2e26 100644
--- a/meta-openembedded/meta-oe/recipes-devtools/abseil-cpp/abseil-cpp_git.bb
+++ b/meta-openembedded/meta-oe/recipes-devtools/abseil-cpp/abseil-cpp_git.bb
@@ -7,9 +7,9 @@
 LICENSE = "Apache-2.0"
 LIC_FILES_CHKSUM = "file://LICENSE;md5=df52c6edb7adc22e533b2bacc3bd3915"
 
-PV = "20221014.0"
-SRCREV = "5fa65f28e46e86c44966a1ca8a727a329d9c1ff8"
-BRANCH = "master"
+PV = "20230125.1"
+SRCREV = "c8a2f92586fe9b4e1aff049108f5db8064924d8e"
+BRANCH = "lts_2023_01_25"
 SRC_URI = "git://github.com/abseil/abseil-cpp;branch=${BRANCH};protocol=https \
            file://0001-absl-always-use-asm-sgidefs.h.patch             \
            file://0002-Remove-maes-option-from-cross-compilation.patch \
@@ -28,6 +28,7 @@
 EXTRA_OECMAKE = "-DBUILD_SHARED_LIBS=ON \
                  -DBUILD_TESTING=OFF    \
                  -DCMAKE_CXX_STANDARD=14 \
+                 -DABSL_ENABLE_INSTALL=ON \
                 "
 
 BBCLASSEXTEND = "native nativesdk"
diff --git a/meta-openembedded/meta-oe/recipes-devtools/ctags/ctags_6.0.20230212.0.bb b/meta-openembedded/meta-oe/recipes-devtools/ctags/ctags_6.0.20230319.0.bb
similarity index 95%
rename from meta-openembedded/meta-oe/recipes-devtools/ctags/ctags_6.0.20230212.0.bb
rename to meta-openembedded/meta-oe/recipes-devtools/ctags/ctags_6.0.20230319.0.bb
index 8a49776..feee721 100644
--- a/meta-openembedded/meta-oe/recipes-devtools/ctags/ctags_6.0.20230212.0.bb
+++ b/meta-openembedded/meta-oe/recipes-devtools/ctags/ctags_6.0.20230319.0.bb
@@ -14,7 +14,7 @@
 
 inherit autotools-brokensep pkgconfig manpages
 
-SRCREV = "c74bf5a7ce99797dfebda2e1cab65d1086614278"
+SRCREV = "6e720ab5591d24cd401b720a63110bc224780f6f"
 SRC_URI = "git://github.com/universal-ctags/ctags;branch=master;protocol=https"
 
 S = "${WORKDIR}/git"
diff --git a/meta-openembedded/meta-oe/recipes-devtools/makeself/makeself_2.4.5.bb b/meta-openembedded/meta-oe/recipes-devtools/makeself/makeself_2.5.0.bb
similarity index 93%
rename from meta-openembedded/meta-oe/recipes-devtools/makeself/makeself_2.4.5.bb
rename to meta-openembedded/meta-oe/recipes-devtools/makeself/makeself_2.5.0.bb
index 4cfe2ec..f94025d 100644
--- a/meta-openembedded/meta-oe/recipes-devtools/makeself/makeself_2.4.5.bb
+++ b/meta-openembedded/meta-oe/recipes-devtools/makeself/makeself_2.5.0.bb
@@ -12,7 +12,7 @@
     git://github.com/megastep/${BPN}.git;protocol=https;branch=master \
 "
 
-SRCREV = "5742be6410bfad2c619fb1e98bf795e8fa0913c7"
+SRCREV = "09488c50c6bdc40aec8e3a9b23a539c5054a634c"
 
 S = "${WORKDIR}/git"
 
diff --git a/meta-openembedded/meta-oe/recipes-devtools/nodejs/nodejs-oe-cache-18.12/oe-npm-cache b/meta-openembedded/meta-oe/recipes-devtools/nodejs/nodejs-oe-cache-18.14/oe-npm-cache
similarity index 100%
rename from meta-openembedded/meta-oe/recipes-devtools/nodejs/nodejs-oe-cache-18.12/oe-npm-cache
rename to meta-openembedded/meta-oe/recipes-devtools/nodejs/nodejs-oe-cache-18.14/oe-npm-cache
diff --git a/meta-openembedded/meta-oe/recipes-devtools/nodejs/nodejs-oe-cache-native_18.12.bb b/meta-openembedded/meta-oe/recipes-devtools/nodejs/nodejs-oe-cache-native_18.14.bb
similarity index 100%
rename from meta-openembedded/meta-oe/recipes-devtools/nodejs/nodejs-oe-cache-native_18.12.bb
rename to meta-openembedded/meta-oe/recipes-devtools/nodejs/nodejs-oe-cache-native_18.14.bb
diff --git a/meta-openembedded/meta-oe/recipes-devtools/nodejs/nodejs/0001-Disable-running-gyp-files-for-bundled-deps.patch b/meta-openembedded/meta-oe/recipes-devtools/nodejs/nodejs/0001-Disable-running-gyp-files-for-bundled-deps.patch
index e949c63..356c98d 100644
--- a/meta-openembedded/meta-oe/recipes-devtools/nodejs/nodejs/0001-Disable-running-gyp-files-for-bundled-deps.patch
+++ b/meta-openembedded/meta-oe/recipes-devtools/nodejs/nodejs/0001-Disable-running-gyp-files-for-bundled-deps.patch
@@ -33,16 +33,14 @@
  Makefile | 2 +-
  1 file changed, 1 insertion(+), 1 deletion(-)
 
-diff --git a/Makefile b/Makefile
-index 93d63110..79caaec2 100644
 --- a/Makefile
 +++ b/Makefile
-@@ -138,7 +138,7 @@ with-code-cache test-code-cache:
+@@ -169,7 +169,7 @@ with-code-cache test-code-cache:
  	$(warning '$@' target is a noop)
  
  out/Makefile: config.gypi common.gypi node.gyp \
 -	deps/uv/uv.gyp deps/llhttp/llhttp.gyp deps/zlib/zlib.gyp \
 +	deps/llhttp/llhttp.gyp \
+ 	deps/simdutf/simdutf.gyp \
  	tools/v8_gypfiles/toolchain.gypi tools/v8_gypfiles/features.gypi \
  	tools/v8_gypfiles/inspector.gypi tools/v8_gypfiles/v8.gyp
- 	$(PYTHON) tools/gyp_node.py -f make
diff --git a/meta-openembedded/meta-oe/recipes-devtools/nodejs/nodejs/gcc13.patch b/meta-openembedded/meta-oe/recipes-devtools/nodejs/nodejs/gcc13.patch
deleted file mode 100644
index be82c33..0000000
--- a/meta-openembedded/meta-oe/recipes-devtools/nodejs/nodejs/gcc13.patch
+++ /dev/null
@@ -1,70 +0,0 @@
-From 0be1c5728173ea9ac42843058e26b6268568acf0 Mon Sep 17 00:00:00 2001
-From: Jiawen Geng <technicalcute@gmail.com>
-Date: Fri, 14 Oct 2022 09:54:33 +0800
-Subject: [PATCH] deps: V8: cherry-pick c2792e58035f
-MIME-Version: 1.0
-Content-Type: text/plain; charset=UTF-8
-Content-Transfer-Encoding: 8bit
-
-Original commit message:
-
-    [base] Fix build with gcc-13
-
-    See https://gcc.gnu.org/gcc-13/porting_to.html#header-dep-changes.
-
-    Also see Gentoo Linux bug report: https://bugs.gentoo.org/865981
-
-    Change-Id: I421f396b02ba37e12ee70048ee33e034f8113566
-    Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/3934140
-    Reviewed-by: Clemens Backes <clemensb@chromium.org>
-    Reviewed-by: Simon Zünd <szuend@chromium.org>
-    Commit-Queue: Clemens Backes <clemensb@chromium.org>
-    Cr-Commit-Position: refs/heads/main@{#83587}
-
-Refs: https://github.com/v8/v8/commit/c2792e58035fcbaa16d0cb70998852fbeb5df4cc
-PR-URL: https://github.com/nodejs/node/pull/44961
-Fixes: https://github.com/nodejs/node/issues/43642
-Reviewed-By: Michaël Zasso <targos@protonmail.com>
-Reviewed-By: Richard Lau <rlau@redhat.com>
-Reviewed-By: Luigi Pinca <luigipinca@gmail.com>
-Reviewed-By: Colin Ihrig <cjihrig@gmail.com>
-
-Upstream-Status: Backport [https://github.com/nodejs/node/commit/0be1c5728173ea9ac42843058e26b6268568acf0]
-Signed-off-by: Khem Raj <raj.khem@gmail.com>
----
- common.gypi                                   | 2 +-
- deps/v8/AUTHORS                               | 1 +
- deps/v8/src/base/logging.h                    | 1 +
- deps/v8/src/inspector/v8-string-conversions.h | 1 +
- 4 files changed, 4 insertions(+), 1 deletion(-)
-
---- a/deps/v8/AUTHORS
-+++ b/deps/v8/AUTHORS
-@@ -247,6 +247,7 @@ Vlad Burlik <vladbph@gmail.com>
- Vladimir Krivosheev <develar@gmail.com>
- Vladimir Shutoff <vovan@shutoff.ru>
- Wael Almattar <waelsy123@gmail.com>
-+WANG Xuerui <git@xen0n.name>
- Wei Wu <lazyparser@gmail.com>
- Wenlu Wang <kingwenlu@gmail.com>
- Wenming Yang <yangwenming@bytedance.com>
---- a/deps/v8/src/base/logging.h
-+++ b/deps/v8/src/base/logging.h
-@@ -5,6 +5,7 @@
- #ifndef V8_BASE_LOGGING_H_
- #define V8_BASE_LOGGING_H_
- 
-+#include <cstdint>
- #include <cstring>
- #include <sstream>
- #include <string>
---- a/deps/v8/src/inspector/v8-string-conversions.h
-+++ b/deps/v8/src/inspector/v8-string-conversions.h
-@@ -5,6 +5,7 @@
- #ifndef V8_INSPECTOR_V8_STRING_CONVERSIONS_H_
- #define V8_INSPECTOR_V8_STRING_CONVERSIONS_H_
- 
-+#include <cstdint>
- #include <string>
- 
- // Conversion routines between UT8 and UTF16, used by string-16.{h,cc}. You may
diff --git a/meta-openembedded/meta-oe/recipes-devtools/nodejs/nodejs/run-ptest b/meta-openembedded/meta-oe/recipes-devtools/nodejs/nodejs/run-ptest
new file mode 100755
index 0000000..07a8f2a
--- /dev/null
+++ b/meta-openembedded/meta-oe/recipes-devtools/nodejs/nodejs/run-ptest
@@ -0,0 +1,3 @@
+#!/bin/sh
+
+./cctest
diff --git a/meta-openembedded/meta-oe/recipes-devtools/nodejs/nodejs_18.12.1.bb b/meta-openembedded/meta-oe/recipes-devtools/nodejs/nodejs_18.14.2.bb
similarity index 94%
rename from meta-openembedded/meta-oe/recipes-devtools/nodejs/nodejs_18.12.1.bb
rename to meta-openembedded/meta-oe/recipes-devtools/nodejs/nodejs_18.14.2.bb
index 802c419..19df7d5 100644
--- a/meta-openembedded/meta-oe/recipes-devtools/nodejs/nodejs_18.12.1.bb
+++ b/meta-openembedded/meta-oe/recipes-devtools/nodejs/nodejs_18.14.2.bb
@@ -1,11 +1,11 @@
 DESCRIPTION = "nodeJS Evented I/O for V8 JavaScript"
 HOMEPAGE = "http://nodejs.org"
-LICENSE = "MIT & ISC & BSD-2-Clause & BSD-3-Clause & Artistic-2.0"
-LIC_FILES_CHKSUM = "file://LICENSE;md5=dfd7ae796baf5326016a3865ee1dc632"
+LICENSE = "MIT & ISC & BSD-2-Clause & BSD-3-Clause & Artistic-2.0 & Apache-2.0"
+LIC_FILES_CHKSUM = "file://LICENSE;md5=2dff1ccca11e333f1388e34f7e2d1de3"
 
 CVE_PRODUCT = "nodejs node.js"
 
-DEPENDS = "openssl"
+DEPENDS = "openssl file-replacement-native"
 DEPENDS:append:class-target = " qemu-native"
 DEPENDS:append:class-native = " c-ares-native"
 
@@ -27,7 +27,7 @@
            file://system-c-ares.patch \
            file://0001-liftoff-Correct-function-signatures.patch \
            file://0001-mips-Use-32bit-cast-for-operand-on-mips32.patch \
-           file://gcc13.patch \
+           file://run-ptest \
            "
 
 SRC_URI:append:class-target = " \
@@ -39,7 +39,7 @@
 SRC_URI:append:toolchain-clang:powerpc64le = " \
            file://0001-ppc64-Do-not-use-mminimal-toc-with-clang.patch \
            "
-SRC_URI[sha256sum] = "4fa406451bc52659a290e52cfdb2162a760bd549da4b8bbebe6a29f296d938df"
+SRC_URI[sha256sum] = "fbc364dd25fee2cacc0f2033db2d86115fc07575310ea0e64408b8170d09c685"
 
 S = "${WORKDIR}/node-v${PV}"
 
@@ -89,6 +89,8 @@
     builddir_name=./ \
 "
 
+EXTRANATIVEPATH += "file-native"
+
 python prune_sources() {
     import shutil
 
@@ -173,7 +175,7 @@
 }
 
 PACKAGES =+ "${PN}-npm"
-FILES:${PN}-npm = "${nonarch_libdir}/node_modules ${bindir}/npm ${bindir}/npx"
+FILES:${PN}-npm = "${nonarch_libdir}/node_modules ${bindir}/npm ${bindir}/npx ${bindir}/corepack"
 RDEPENDS:${PN}-npm = "bash python3-core python3-shell python3-datetime \
     python3-misc python3-multiprocessing"
 
diff --git a/meta-openembedded/meta-oe/recipes-devtools/pahole/files/0001-CMakeList.txt-make-python-optional.patch b/meta-openembedded/meta-oe/recipes-devtools/pahole/files/0001-CMakeList.txt-make-python-optional.patch
deleted file mode 100644
index d64cba1..0000000
--- a/meta-openembedded/meta-oe/recipes-devtools/pahole/files/0001-CMakeList.txt-make-python-optional.patch
+++ /dev/null
@@ -1,44 +0,0 @@
-From f6ca8c930d0fbd2491b3cc77169e32806a14e5e9 Mon Sep 17 00:00:00 2001
-From: Matteo Croce <mcroce@microsoft.com>
-Date: Mon, 30 Aug 2021 16:25:56 +0200
-Subject: [PATCH] CMakeList.txt: make python optional
-
-Upstream-Status: Backport [https://git.kernel.org/pub/scm/devel/pahole/pahole.git/commit/?id=88431099950ab3e8bc1645353508d7978a6cad35]
-
-ostra-cg, which requires python, is installed in the destination dir.
-Make it optional for embedded distributions which doesn't have the
-python interpreter available.
-
-Signed-off-by: Matteo Croce <mcroce@microsoft.com>
----
- CMakeLists.txt | 7 +++++--
- 1 file changed, 5 insertions(+), 2 deletions(-)
-
-diff --git a/CMakeLists.txt b/CMakeLists.txt
-index 4140574..8523bce 100644
---- a/CMakeLists.txt
-+++ b/CMakeLists.txt
-@@ -61,6 +61,7 @@ find_package(DWARF REQUIRED)
- find_package(ZLIB REQUIRED)
- find_package(argp REQUIRED)
- find_package(obstack REQUIRED)
-+find_package(Python3 QUIET)
- 
- # make sure git submodule(s) are checked out
- find_package(Git QUIET)
-@@ -185,8 +186,10 @@ install(FILES dwarves.h dwarves_emit.h dwarves_reorganize.h
- 	      elfcreator.h elf_symtab.h hash.h libctf.h
- 	DESTINATION ${CMAKE_INSTALL_PREFIX}/include/dwarves/)
- install(FILES man-pages/pahole.1 DESTINATION ${CMAKE_INSTALL_PREFIX}/share/man/man1/)
--install(PROGRAMS ostra/ostra-cg DESTINATION ${CMAKE_INSTALL_PREFIX}/bin)
-+if(Python3_FOUND)
-+	install(PROGRAMS ostra/ostra-cg DESTINATION ${CMAKE_INSTALL_PREFIX}/bin)
-+	install(FILES ostra/python/ostra.py DESTINATION ${CMAKE_INSTALL_PREFIX}/share/dwarves/runtime/python)
-+endif()
- install(PROGRAMS btfdiff fullcircle DESTINATION ${CMAKE_INSTALL_PREFIX}/bin)
--install(FILES ostra/python/ostra.py DESTINATION ${CMAKE_INSTALL_PREFIX}/share/dwarves/runtime/python)
- install(FILES lib/Makefile lib/ctracer_relay.c lib/ctracer_relay.h lib/linux.blacklist.cu
- 	DESTINATION ${CMAKE_INSTALL_PREFIX}/share/dwarves/runtime)
--- 
-2.31.1
-
diff --git a/meta-openembedded/meta-oe/recipes-devtools/pahole/files/0003-CMakeList.txt-don-t-download-libbpf-source-when-syst.patch b/meta-openembedded/meta-oe/recipes-devtools/pahole/files/0003-CMakeList.txt-don-t-download-libbpf-source-when-syst.patch
deleted file mode 100644
index 3d491e2..0000000
--- a/meta-openembedded/meta-oe/recipes-devtools/pahole/files/0003-CMakeList.txt-don-t-download-libbpf-source-when-syst.patch
+++ /dev/null
@@ -1,34 +0,0 @@
-From 3d20210d84f61ee2189927e2d9de9ce3e5a0a9c5 Mon Sep 17 00:00:00 2001
-From: Matteo Croce <mcroce@microsoft.com>
-Date: Mon, 20 Sep 2021 18:44:52 +0200
-Subject: [PATCH] CMakeList.txt: Don't download libbpf source when system
- library is used
-
-Upstream-Status: Backport [https://git.kernel.org/pub/scm/devel/pahole/pahole.git/commit/?id=3d20210d84f61ee2189927e2d9de9ce3e5a0a9c5]
-
-The build system always download the libbpf submodule, regardless if
-we're using the embedded or the system version.
-Download the libbpf source only if we're using the embedded one.
-
-Signed-off-by: Matteo Croce <mcroce@microsoft.com>
-Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>
----
- CMakeLists.txt | 2 +-
- 1 file changed, 1 insertion(+), 1 deletion(-)
-
-diff --git a/CMakeLists.txt b/CMakeLists.txt
-index 8523bce..2ab66e4 100644
---- a/CMakeLists.txt
-+++ b/CMakeLists.txt
-@@ -65,7 +65,7 @@ find_package(Python3 QUIET)
- 
- # make sure git submodule(s) are checked out
- find_package(Git QUIET)
--if(GIT_FOUND AND EXISTS "${PROJECT_SOURCE_DIR}/.git")
-+if(LIBBPF_EMBEDDED AND GIT_FOUND AND EXISTS "${PROJECT_SOURCE_DIR}/.git")
- 	# Update submodules as needed
- 	option(GIT_SUBMODULE "Check submodules during build" ON)
- 	if(GIT_SUBMODULE)
--- 
-2.31.1
-
diff --git a/meta-openembedded/meta-oe/recipes-devtools/pahole/pahole_1.22.bb b/meta-openembedded/meta-oe/recipes-devtools/pahole/pahole_1.24.bb
similarity index 80%
rename from meta-openembedded/meta-oe/recipes-devtools/pahole/pahole_1.22.bb
rename to meta-openembedded/meta-oe/recipes-devtools/pahole/pahole_1.24.bb
index 449508a..b7f1f8b 100644
--- a/meta-openembedded/meta-oe/recipes-devtools/pahole/pahole_1.22.bb
+++ b/meta-openembedded/meta-oe/recipes-devtools/pahole/pahole_1.24.bb
@@ -9,11 +9,10 @@
 PACKAGE_ARCH = "${MACHINE_ARCH}"
 COMPATIBLE_HOST = "(x86_64|i.86|aarch64).*-linux"
 
-SRCREV = "f02af2553ea58ae1186226af0d0ec835a248358f"
+PV .= "+1.25+git${SRCPV}"
+SRCREV = "a9498899109d3be14f17abbc322a8f55a1067bee"
 SRC_URI = "git://git.kernel.org/pub/scm/devel/pahole/pahole.git;branch=master \
-           file://0001-CMakeList.txt-make-python-optional.patch \
-           file://0002-Use-usr-bin-env-python3-instead-of-just-usr-bin-pyth.patch \
-           file://0003-CMakeList.txt-don-t-download-libbpf-source-when-syst.patch"
+           file://0002-Use-usr-bin-env-python3-instead-of-just-usr-bin-pyth.patch"
 
 S = "${WORKDIR}/git"
 
diff --git a/meta-openembedded/meta-oe/recipes-devtools/php/php_8.1.11.bb b/meta-openembedded/meta-oe/recipes-devtools/php/php_8.2.4.bb
similarity index 98%
rename from meta-openembedded/meta-oe/recipes-devtools/php/php_8.1.11.bb
rename to meta-openembedded/meta-oe/recipes-devtools/php/php_8.2.4.bb
index dca482a..aec222b 100644
--- a/meta-openembedded/meta-oe/recipes-devtools/php/php_8.1.11.bb
+++ b/meta-openembedded/meta-oe/recipes-devtools/php/php_8.2.4.bb
@@ -3,7 +3,7 @@
 SECTION = "console/network"
 
 LICENSE = "PHP-3.0"
-LIC_FILES_CHKSUM = "file://LICENSE;md5=99532e0f6620bc9bca34f12fadaee33c"
+LIC_FILES_CHKSUM = "file://LICENSE;md5=5ebd5be8e2a89f634486445bd164bef0"
 
 BBCLASSEXTEND = "native"
 DEPENDS = "zlib bzip2 libxml2 virtual/libiconv php-native lemon-native"
@@ -33,7 +33,7 @@
           "
 
 S = "${WORKDIR}/php-${PV}"
-SRC_URI[sha256sum] = "af6250b18b4403b6eeff9b4a02786ac86a12a208141f6f65478f79256f47f246"
+SRC_URI[sha256sum] = "79186f94bd510db86e31e535dd448277a1eb92a87878303a1ead44602d8b1197"
 
 CVE_CHECK_IGNORE += "\
     CVE-2007-2728 \
diff --git a/meta-openembedded/meta-oe/recipes-devtools/python/python3-apt_2.5.2.bb b/meta-openembedded/meta-oe/recipes-devtools/python/python3-apt_2.5.3.bb
similarity index 90%
rename from meta-openembedded/meta-oe/recipes-devtools/python/python3-apt_2.5.2.bb
rename to meta-openembedded/meta-oe/recipes-devtools/python/python3-apt_2.5.3.bb
index d95c60f..1d54b9f 100644
--- a/meta-openembedded/meta-oe/recipes-devtools/python/python3-apt_2.5.2.bb
+++ b/meta-openembedded/meta-oe/recipes-devtools/python/python3-apt_2.5.3.bb
@@ -5,7 +5,7 @@
 
 SRC_URI = "git://salsa.debian.org/apt-team/python-apt.git;protocol=https;branch=main"
 
-SRCREV = "e78d37eec72fe3afd28db17d5ea7a705bb4e3ce9"
+SRCREV = "3252935b6224b3bd2e2250894b9559b47c61b2e1"
 
 S = "${WORKDIR}/git"
 
diff --git a/meta-openembedded/meta-oe/recipes-devtools/tcltk/tk_8.6.10.bb b/meta-openembedded/meta-oe/recipes-devtools/tcltk/tk_8.6.10.bb
index efab961..f3cab4e 100644
--- a/meta-openembedded/meta-oe/recipes-devtools/tcltk/tk_8.6.10.bb
+++ b/meta-openembedded/meta-oe/recipes-devtools/tcltk/tk_8.6.10.bb
@@ -34,7 +34,7 @@
 VER = "${@os.path.splitext(d.getVar('PV'))[0]}"
 
 LDFLAGS += "-Wl,-rpath,${libdir}/tcltk/${PV}/lib"
-inherit autotools features_check
+inherit autotools features_check pkgconfig
 # depends on virtual/libx11
 REQUIRED_DISTRO_FEATURES = "x11"
 
diff --git a/meta-openembedded/meta-oe/recipes-extended/byacc/byacc_20230201.bb b/meta-openembedded/meta-oe/recipes-extended/byacc/byacc_20230219.bb
similarity index 82%
rename from meta-openembedded/meta-oe/recipes-extended/byacc/byacc_20230201.bb
rename to meta-openembedded/meta-oe/recipes-extended/byacc/byacc_20230219.bb
index 409212e..614bcaf 100644
--- a/meta-openembedded/meta-oe/recipes-extended/byacc/byacc_20230201.bb
+++ b/meta-openembedded/meta-oe/recipes-extended/byacc/byacc_20230219.bb
@@ -7,4 +7,4 @@
 LIC_FILES_CHKSUM = "file://package/debian/copyright;md5=b56b7454f5f865de2e6e35ee2185b461"
 require byacc.inc
 
-SRC_URI[sha256sum] = "576cc9d9ae5e22503ed5e3582498cf2cccacef401969106420547b4d05c87d76"
+SRC_URI[sha256sum] = "36b972a6d4ae97584dd186925fbbc397d26cb20632a76c2f52ac7653cd081b58"
diff --git a/meta-openembedded/meta-oe/recipes-extended/fluentbit/fluentbit/0007-cmake-Do-not-check-for-upstart-on-build-host.patch b/meta-openembedded/meta-oe/recipes-extended/fluentbit/fluentbit/0007-cmake-Do-not-check-for-upstart-on-build-host.patch
new file mode 100644
index 0000000..71bdd34
--- /dev/null
+++ b/meta-openembedded/meta-oe/recipes-extended/fluentbit/fluentbit/0007-cmake-Do-not-check-for-upstart-on-build-host.patch
@@ -0,0 +1,46 @@
+From c41653e856d05ed430d22f8b311714ff756a0e0b Mon Sep 17 00:00:00 2001
+From: Khem Raj <raj.khem@gmail.com>
+Date: Thu, 23 Mar 2023 18:05:27 -0700
+Subject: [PATCH] cmake: Do not check for upstart on build host
+
+Some ubuntu distros might have this directory /usr/share/upstart around
+and yocto based distros not using systemd will process this piece of
+code and falsely assume that target supports upstart, which may not be
+true in case of cross-compilation.
+
+This also can end up in configure errors e.g.
+
+| CMake Error at src/CMakeLists.txt:496 (install):
+|   install DIRECTORY given unknown argument "/etc/td-agent-bit/".
+|
+|
+| -- Configuring incomplete, errors occurred!
+
+Upstream-Status: Inappropriate [ Cross-compile Specific ]
+Signed-off-by: Khem Raj <raj.khem@gmail.com>
+---
+ src/CMakeLists.txt | 8 --------
+ 1 file changed, 8 deletions(-)
+
+diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
+index bb30b2a..c63b6d8 100644
+--- a/src/CMakeLists.txt
++++ b/src/CMakeLists.txt
+@@ -486,14 +486,6 @@ if(FLB_BINARY)
+       )
+     install(FILES ${FLB_SYSTEMD_SCRIPT} COMPONENT binary DESTINATION ${SYSTEMD_UNITDIR})
+     install(DIRECTORY DESTINATION ${FLB_INSTALL_CONFDIR} COMPONENT binary)
+-  elseif(IS_DIRECTORY /usr/share/upstart)
+-    set(FLB_UPSTART_SCRIPT "${PROJECT_SOURCE_DIR}/init/${FLB_OUT_NAME}.conf")
+-    configure_file(
+-      "${PROJECT_SOURCE_DIR}/init/upstart.in"
+-      ${FLB_UPSTART_SCRIPT}
+-      )
+-    install(FILES ${FLB_UPSTART_SCRIPT} COMPONENT binary DESTINATION /etc/init)
+-    install(DIRECTORY DESTINATION COMPONENT binary ${FLB_INSTALL_CONFDIR})
+   else()
+     # FIXME: should we support Sysv init script ?
+   endif()
+-- 
+2.40.0
+
diff --git a/meta-openembedded/meta-oe/recipes-extended/fluentbit/fluentbit_1.9.7.bb b/meta-openembedded/meta-oe/recipes-extended/fluentbit/fluentbit_1.9.7.bb
index 814d4b9..26238e5 100644
--- a/meta-openembedded/meta-oe/recipes-extended/fluentbit/fluentbit_1.9.7.bb
+++ b/meta-openembedded/meta-oe/recipes-extended/fluentbit/fluentbit_1.9.7.bb
@@ -11,7 +11,7 @@
 LIC_FILES_CHKSUM = "file://LICENSE;md5=2ee41112a44fe7014dce33e26468ba93"
 SECTION = "net"
 
-SRC_URI = "https://releases.fluentbit.io/1.9/source-${PV}.tar.gz;subdir=fluent-bit-${PV} \
+SRC_URI = "https://releases.fluentbit.io/1.9/source-${PV}.tar.gz;subdir=fluent-bit-${PV};downloadfilename=${BPN}-${PV}.tar.gz \
            file://0001-CMakeLists.txt-Do-not-use-private-makefile-target.patch \
            file://0002-flb_info.h.in-Do-not-hardcode-compilation-directorie.patch \
            file://0003-mbedtls-Do-not-overwrite-CFLAGS.patch \
@@ -22,6 +22,7 @@
            file://0004-Use-correct-type-to-store-return-from-flb_kv_item_cr.patch \
            file://0005-stackdriver-Fix-return-type-mismatch.patch \
            file://0006-monkey-Fix-TLS-detection-testcase.patch \
+           file://0007-cmake-Do-not-check-for-upstart-on-build-host.patch \
            "
 SRC_URI:remove:x86 = "file://0002-mbedtls-Remove-unused-variable.patch"
 SRC_URI:append:libc-musl = "\
diff --git a/meta-openembedded/meta-oe/recipes-extended/hplip/hplip_3.22.10.bb b/meta-openembedded/meta-oe/recipes-extended/hplip/hplip_3.22.10.bb
index d8e249f..23cc519 100644
--- a/meta-openembedded/meta-oe/recipes-extended/hplip/hplip_3.22.10.bb
+++ b/meta-openembedded/meta-oe/recipes-extended/hplip/hplip_3.22.10.bb
@@ -72,7 +72,7 @@
         python3-resource \
         python3-terminal \
 "
-RDEPENDS:${PN}-filter += "perl"
+RDEPENDS:${PN}-filter += "perl ghostscript"
 
 # need to snag the debug file or OE will fail on backend package
 FILES:${PN}-dbg += "\
diff --git a/meta-openembedded/meta-oe/recipes-extended/libidn/libidn/0001-idn-format-security-warnings.patch b/meta-openembedded/meta-oe/recipes-extended/libidn/libidn/0001-idn-format-security-warnings.patch
deleted file mode 100644
index d5fb8e7..0000000
--- a/meta-openembedded/meta-oe/recipes-extended/libidn/libidn/0001-idn-format-security-warnings.patch
+++ /dev/null
@@ -1,180 +0,0 @@
-Subject: [PATCH] idn: fix printf() format security warnings
-MIME-Version: 1.0
-Content-Type: text/plain; charset=UTF-8
-Content-Transfer-Encoding: 8bit
-
-| ../../libidn-1.32/src/idn.c: In function 'main':
-| ../../libidn-1.32/src/idn.c:172:7: error: format not a string literal and no format arguments [-Werror=format-security]
-|        error (0, 0, _("only one of -s, -e, -d, -a, -u or -n can be specified"));
-|        ^~~~~
-| ../../libidn-1.32/src/idn.c:187:5: error: format not a string literal and no format arguments [-Werror=format-security]
-|      fprintf (stderr, _("Type each input string on a line by itself, "
-|      ^~~~~~~
-| ../../libidn-1.32/src/idn.c:202:4: error: format not a string literal and no format arguments [-Werror=format-security]
-|     error (EXIT_FAILURE, errno, _("input error"));
-|     ^~~~~
-| ../../libidn-1.32/src/idn.c:220:8: error: format not a string literal and no format arguments [-Werror=format-security]
-|         _("could not convert from UTF-8 to UCS-4"));
-|         ^
-| ../../libidn-1.32/src/idn.c:245:8: error: format not a string literal and no format arguments [-Werror=format-security]
-|         _("could not convert from UTF-8 to UCS-4"));
-|         ^
-| ../../libidn-1.32/src/idn.c:281:6: error: format not a string literal and no format arguments [-Werror=format-security]
-|       _("could not convert from UTF-8 to UCS-4"));
-|       ^
-| ../../libidn-1.32/src/idn.c:340:6: error: format not a string literal and no format arguments [-Werror=format-security]
-|       _("could not convert from UCS-4 to UTF-8"));
-|       ^
-| ../../libidn-1.32/src/idn.c:364:6: error: format not a string literal and no format arguments [-Werror=format-security]
-|       _("could not convert from UCS-4 to UTF-8"));
-|       ^
-| ../../libidn-1.32/src/idn.c:442:8: error: format not a string literal and no format arguments [-Werror=format-security]
-|         _("could not convert from UCS-4 to UTF-8"));
-|         ^
-| ../../libidn-1.32/src/idn.c:498:6: error: format not a string literal and no format arguments [-Werror=format-security]
-|       _("could not convert from UTF-8 to UCS-4"));
-|       ^
-| ../../libidn-1.32/src/idn.c:527:5: error: format not a string literal and no format arguments [-Werror=format-security]
-|      _("could not convert from UTF-8 to UCS-4"));
-|      ^
-| ../../libidn-1.32/src/idn.c:540:6: error: format not a string literal and no format arguments [-Werror=format-security]
-|       error (EXIT_FAILURE, 0, _("could not do NFKC normalization"));
-|       ^~~~~
-| ../../libidn-1.32/src/idn.c:551:5: error: format not a string literal and no format arguments [-Werror=format-security]
-|      _("could not convert from UTF-8 to UCS-4"));
-|      ^
-
-Signed-off-by: André Draszik <adraszik@tycoint.com>
-Signed-off-by: Zang Ruochen <zangrc.fnst@cn.fujitsu.com>
-
-Upstream-Status: Pending
-
----
- src/idn.c | 27 ++++++++++++++-------------
- 1 file changed, 14 insertions(+), 13 deletions(-)
-
-diff --git a/src/idn.c b/src/idn.c
-index f2fee11..c6e5caa 100644
---- a/src/idn.c
-+++ b/src/idn.c
-@@ -169,7 +169,7 @@ main (int argc, char *argv[])
-       (args_info.idna_to_unicode_given ? 1 : 0) +
-       (args_info.nfkc_given ? 1 : 0) != 1)
-     {
--      error (0, 0,
-+      error (0, 0, "%s",
- 	     _("only one of -s, -e, -d, -a, -u or -n can be specified"));
-       usage (EXIT_FAILURE);
-     }
-@@ -183,7 +183,7 @@ main (int argc, char *argv[])
- 
-   if (!args_info.quiet_given
-       && args_info.inputs_num == 0 && isatty (fileno (stdin)))
--    fprintf (stderr, _("Type each input string on a line by itself, "
-+    fprintf (stderr, "%s", _("Type each input string on a line by itself, "
- 		       "terminated by a newline character.\n"));
- 
-   do
-@@ -195,7 +195,7 @@ main (int argc, char *argv[])
- 	  if (feof (stdin))
- 	    break;
- 
--	  error (EXIT_FAILURE, errno, _("input error"));
-+	  error (EXIT_FAILURE, errno, "%s", _("input error"));
- 	}
- 
-       if (strlen (line) > 0)
-@@ -213,7 +213,7 @@ main (int argc, char *argv[])
- 	  if (!q)
- 	    {
- 	      free (p);
--	      error (EXIT_FAILURE, 0,
-+	      error (EXIT_FAILURE, 0, "%s",
- 		     _("could not convert from UTF-8 to UCS-4"));
- 	    }
- 
-@@ -238,7 +238,7 @@ main (int argc, char *argv[])
- 	  if (!q)
- 	    {
- 	      free (r);
--	      error (EXIT_FAILURE, 0,
-+	      error (EXIT_FAILURE, 0, "%s",
- 		     _("could not convert from UTF-8 to UCS-4"));
- 	    }
- 
-@@ -275,7 +275,7 @@ main (int argc, char *argv[])
- 	  q = stringprep_utf8_to_ucs4 (p, -1, &len);
- 	  free (p);
- 	  if (!q)
--	    error (EXIT_FAILURE, 0,
-+	    error (EXIT_FAILURE, 0, "%s",
- 		   _("could not convert from UTF-8 to UCS-4"));
- 
- 	  if (args_info.debug_given)
-@@ -334,7 +334,7 @@ main (int argc, char *argv[])
- 	  r = stringprep_ucs4_to_utf8 (q, -1, NULL, NULL);
- 	  free (q);
- 	  if (!r)
--	    error (EXIT_FAILURE, 0,
-+	    error (EXIT_FAILURE, 0, "%s",
- 		   _("could not convert from UCS-4 to UTF-8"));
- 
- 	  p = stringprep_utf8_to_locale (r);
-@@ -358,7 +358,7 @@ main (int argc, char *argv[])
- 	  q = stringprep_utf8_to_ucs4 (p, -1, NULL);
- 	  free (p);
- 	  if (!q)
--	    error (EXIT_FAILURE, 0,
-+	    error (EXIT_FAILURE, 0, "%s",
- 		   _("could not convert from UCS-4 to UTF-8"));
- 
- 	  if (args_info.debug_given)
-@@ -436,7 +436,7 @@ main (int argc, char *argv[])
- 	  if (!q)
- 	    {
- 	      free (p);
--	      error (EXIT_FAILURE, 0,
-+	      error (EXIT_FAILURE, 0, "%s",
- 		     _("could not convert from UCS-4 to UTF-8"));
- 	    }
- 
-@@ -492,7 +492,7 @@ main (int argc, char *argv[])
- 	  r = stringprep_ucs4_to_utf8 (q, -1, NULL, NULL);
- 	  free (q);
- 	  if (!r)
--	    error (EXIT_FAILURE, 0,
-+	    error (EXIT_FAILURE, 0, "%s",
- 		   _("could not convert from UTF-8 to UCS-4"));
- 
- 	  p = stringprep_utf8_to_locale (r);
-@@ -521,7 +521,7 @@ main (int argc, char *argv[])
- 	      if (!q)
- 		{
- 		  free (p);
--		  error (EXIT_FAILURE, 0,
-+		  error (EXIT_FAILURE, 0, "%s",
- 			 _("could not convert from UTF-8 to UCS-4"));
- 		}
- 
-@@ -535,7 +535,8 @@ main (int argc, char *argv[])
- 	  r = stringprep_utf8_nfkc_normalize (p, -1);
- 	  free (p);
- 	  if (!r)
--	    error (EXIT_FAILURE, 0, _("could not do NFKC normalization"));
-+	    error (EXIT_FAILURE, 0, "%s",
-+		   _("could not do NFKC normalization"));
- 
- 	  if (args_info.debug_given)
- 	    {
-@@ -545,7 +546,7 @@ main (int argc, char *argv[])
- 	      if (!q)
- 		{
- 		  free (r);
--		  error (EXIT_FAILURE, 0,
-+		  error (EXIT_FAILURE, 0, "%s",
- 			 _("could not convert from UTF-8 to UCS-4"));
- 		}
- 
--- 
-2.25.1
-
diff --git a/meta-openembedded/meta-oe/recipes-extended/libidn/libidn/dont-depend-on-help2man.patch b/meta-openembedded/meta-oe/recipes-extended/libidn/libidn/dont-depend-on-help2man.patch
index 0863530..46938bc 100644
--- a/meta-openembedded/meta-oe/recipes-extended/libidn/libidn/dont-depend-on-help2man.patch
+++ b/meta-openembedded/meta-oe/recipes-extended/libidn/libidn/dont-depend-on-help2man.patch
@@ -1,23 +1,23 @@
 Upstream-Status: Inappropriate [disable feature]
 
 Signed-off-by: Marko Lindqvist <cazfi74@gmail.com>
-diff -Nurdd libidn-1.26/doc/Makefile.am libidn-1.26/doc/Makefile.am
---- libidn-1.26/doc/Makefile.am	2012-09-18 11:25:45.000000000 +0300
-+++ libidn-1.26/doc/Makefile.am	2013-02-08 07:41:24.591431462 +0200
-@@ -49,15 +49,9 @@
-
+--- libidn-1.41.orig/doc/Makefile.am
++++ libidn-1.41/doc/Makefile.am
+@@ -73,16 +73,9 @@ BUILT_SOURCES = example.txt example2.txt
+ 
  # Man pages.
-
+ 
 -dist_man_MANS = idn.1 $(gdoc_MANS)
 +dist_man_MANS = $(gdoc_MANS)
  MAINTAINERCLEANFILES = $(dist_man_MANS)
-
--idn.1: $(top_srcdir)/src/idn.c $(top_srcdir)/src/idn.ggo \
--		$(top_srcdir)/configure.ac
--	$(HELP2MAN) \
+ 
+-idn.1: $(top_srcdir)/src/idn.c $(top_srcdir)/src/idn.ggo $(top_srcdir)/.version
+-	$(MAKE) -C ../lib
+-	$(MAKE) -C ../src
+-	$(AM_V_GEN)$(HELP2MAN) \
 -		--name="Internationalized Domain Names command line tool" \
 -		--output=$@ $(top_builddir)/src/idn$(EXEEXT)
 -
  # GDOC
-
- GDOC_BIN = $(srcdir)/gdoc
+ 
+ gdoc_TEXINFOS =
diff --git a/meta-openembedded/meta-oe/recipes-extended/libidn/libidn_1.36.bb b/meta-openembedded/meta-oe/recipes-extended/libidn/libidn_1.41.bb
similarity index 66%
rename from meta-openembedded/meta-oe/recipes-extended/libidn/libidn_1.36.bb
rename to meta-openembedded/meta-oe/recipes-extended/libidn/libidn_1.41.bb
index 0dea4af..b4303a1 100644
--- a/meta-openembedded/meta-oe/recipes-extended/libidn/libidn_1.36.bb
+++ b/meta-openembedded/meta-oe/recipes-extended/libidn/libidn_1.41.bb
@@ -3,24 +3,26 @@
 HOMEPAGE = "http://www.gnu.org/software/libidn/"
 SECTION = "libs"
 LICENSE = "(LGPL-2.1-or-later | LGPL-3.0-only) & GPL-3.0-or-later"
-LIC_FILES_CHKSUM = "file://COPYING;md5=df4be47940a91ee69556f5f71eed4aec \
+LIC_FILES_CHKSUM = "file://COPYING;md5=f95a3dc99fecfa9a0c4e726d4b5d822f \
                     file://COPYING.LESSERv2;md5=4fbd65380cdd255951079008b364516c \
                     file://COPYING.LESSERv3;md5=e6a600fd5e1d9cbde2d983680233ad02 \
                     file://COPYINGv2;md5=b234ee4d69f5fce4486a80fdaf4a4263 \
-                    file://COPYINGv3;md5=d32239bcb673463ab874e80d47fae504 \
-                    file://lib/idna.h;endline=21;md5=c381d797e2d7fbdace7c147b1285d076 \
-                    file://src/idn.c;endline=20;md5=7d88aa87b0494d690bdf7748fe08d536"
+                    file://COPYINGv3;md5=11cc2d3ee574f9d6b7ee797bdce4d423 \
+                    file://lib/idna.h;endline=21;md5=176de4fe1d98e59d743d3b12a850e4cb \
+                    file://src/idn.c;endline=20;md5=dd17b9093355bf669e2ea108d2defbd0 \
+                   "
+                   
 DEPENDS = "virtual/libiconv autoconf-archive"
 
 inherit pkgconfig autotools gettext texinfo gtk-doc
 
 SRC_URI = "${GNU_MIRROR}/libidn/${BPN}-${PV}.tar.gz \
            file://dont-depend-on-help2man.patch \
-           file://0001-idn-format-security-warnings.patch \
            "
 
-SRC_URI[md5sum] = "813c7b268d1051ca02c3610986126f38"
-SRC_URI[sha256sum] = "14b67108344d81ba844631640df77c9071d9fb0659b080326ff5424e86b14038"
+#SRC_URI[md5sum] = "813c7b268d1051ca02c3610986126f38"
+#SRC_URI[sha256sum] = "14b67108344d81ba844631640df77c9071d9fb0659b080326ff5424e86b14038"
+SRC_URI[sha256sum] = "884d706364b81abdd17bee9686d8ff2ae7431c5a14651047c68adf8b31fd8945"
 
 # command tool is under GPLv3+, while libidn itself is under LGPLv2.1+ or LGPLv3
 # so package command into a separate package
diff --git a/meta-openembedded/meta-oe/recipes-extended/liblockfile/liblockfile/0001-Makefile.in-add-DESTDIR.patch b/meta-openembedded/meta-oe/recipes-extended/liblockfile/liblockfile/0001-Makefile.in-add-DESTDIR.patch
index ea415dd..2533b3a 100644
--- a/meta-openembedded/meta-oe/recipes-extended/liblockfile/liblockfile/0001-Makefile.in-add-DESTDIR.patch
+++ b/meta-openembedded/meta-oe/recipes-extended/liblockfile/liblockfile/0001-Makefile.in-add-DESTDIR.patch
@@ -1,4 +1,4 @@
-From 67843dabe1177840697839b916fd899218893ec7 Mon Sep 17 00:00:00 2001
+From 8e370a2f35d0c3472ddc9068fab19d0077434c61 Mon Sep 17 00:00:00 2001
 From: Mingli Yu <mingli.yu@windriver.com>
 Date: Thu, 19 Jul 2018 00:25:23 -0700
 Subject: [PATCH] Makefile.in: add DESTDIR
@@ -29,7 +29,7 @@
  1 file changed, 5 insertions(+), 5 deletions(-)
 
 diff --git a/Makefile.in b/Makefile.in
-index 36a6d23..1e4130e 100644
+index 9c74b35..8cbda1d 100644
 --- a/Makefile.in
 +++ b/Makefile.in
 @@ -12,11 +12,11 @@ CC		= @CC@
@@ -50,5 +50,5 @@
  MAILGROUP	= @MAILGROUP@
  
 -- 
-2.17.1
+2.25.1
 
diff --git a/meta-openembedded/meta-oe/recipes-extended/liblockfile/liblockfile/0001-Makefile.in-Don-t-try-to-run-ldconfig.patch b/meta-openembedded/meta-oe/recipes-extended/liblockfile/liblockfile/0001-Makefile.in-fix-install-failure-on-host-without-ldco.patch
similarity index 60%
rename from meta-openembedded/meta-oe/recipes-extended/liblockfile/liblockfile/0001-Makefile.in-Don-t-try-to-run-ldconfig.patch
rename to meta-openembedded/meta-oe/recipes-extended/liblockfile/liblockfile/0001-Makefile.in-fix-install-failure-on-host-without-ldco.patch
index 5a1d9a9..1fd5c82 100644
--- a/meta-openembedded/meta-oe/recipes-extended/liblockfile/liblockfile/0001-Makefile.in-Don-t-try-to-run-ldconfig.patch
+++ b/meta-openembedded/meta-oe/recipes-extended/liblockfile/liblockfile/0001-Makefile.in-fix-install-failure-on-host-without-ldco.patch
@@ -1,10 +1,12 @@
-From 5876bd17caac96df70ef400bfeebb155c0bd7359 Mon Sep 17 00:00:00 2001
+From 8b3a5916fff4004b5b2f1e8a1d3a051346ba3901 Mon Sep 17 00:00:00 2001
 From: Changqing Li <changqing.li@windriver.com>
-Date: Wed, 8 Feb 2023 10:34:45 +0800
-Subject: [PATCH] Makefile.in: Don't try to run ldconfig
+Date: Fri, 10 Mar 2023 08:59:39 +0800
+Subject: [PATCH] Makefile.in: fix install failure on host without ldconfig
 
-when ldconfig is not installed on the build host, do_install
-will failed with error:
+fix syntax error when ldconfig is not installed on host
+
+when ldconfig is not installed on the build host, install will failed with
+error:
 ln -sf nfslock.so.0.1 /mnt/tmp-glibc/work/core2-64-wrs-linux/liblockfile/1.14-r0/image/usr/lib64/nfslock.so.0
 install -m 644 lockfile.h maillock.h /mnt/tmp-glibc/work/core2-64-wrs-linux/liblockfile/1.14-r0/image/usr/include
 if test "/mnt/tmp-glibc/work/core2-64-wrs-linux/liblockfile/1.14-r0/image" = ""; then ; fi
@@ -16,36 +18,46 @@
 /bin/sh: -c: line 1: syntax error near unexpected token `;'
 /bin/sh: -c: line 1: `if test "/mnt/tmp-glibc/work/core2-64-wrs-linux/liblockfile/1.14-r0/image" = ""; then ; fi'
 
-Deleted line is not needed for OE, as it is cross-compile. And
-it can also fix above error
-
-Upstream-Status: Inappropriate [oe specific]
+Upstream-Status: Submitted [https://github.com/miquels/liblockfile/pull/20]
 
 Signed-off-by: Changqing Li <changqing.li@windriver.com>
 ---
- Makefile.in | 2 --
- 1 file changed, 2 deletions(-)
+ Makefile.in | 8 ++++++--
+ 1 file changed, 6 insertions(+), 2 deletions(-)
 
 diff --git a/Makefile.in b/Makefile.in
-index bfa0acb..ae5be56 100644
+index e02d75e..5fc5b5a 100644
 --- a/Makefile.in
 +++ b/Makefile.in
-@@ -58,7 +58,6 @@ install_shared:	shared install_static install_common
+@@ -9,6 +9,10 @@ NFSVER		= 0.1
+ CFLAGS		= @CFLAGS@ -I.
+ LDFLAGS		= @LDFLAGS@
+ CC		= @CC@
++LDCONFIG       = @LDCONFIG@
++ifeq ($(LDCONFIG),)
++    LDCONFIG = ":"
++endif
+ 
+ prefix		= $(DESTDIR)@prefix@
+ exec_prefix	= @exec_prefix@
+@@ -69,7 +73,7 @@ install_shared:	shared install_static install_common
  			$(libdir)/liblockfile.so.$(SOVER)
  		ln -s liblockfile.so.$(SOVER) $(libdir)/liblockfile.so.$(MAJOR)
  		ln -s liblockfile.so.$(SOVER) $(libdir)/liblockfile.so
 -		if test "$(DESTDIR)" = ""; then @LDCONFIG@; fi
++		if test "$(DESTDIR)" = ""; then $(LDCONFIG); fi
  
  install_common:
  		install -d -m 755 -g root -p $(includedir)
-@@ -79,7 +78,6 @@ install_nfslib:	nfslib
+@@ -90,7 +94,7 @@ install_nfslib:	nfslib
  		install -m 755 nfslock.so.$(NFSVER) $(nfslockdir)
  		ln -sf nfslock.so.$(NFSVER) $(libdir)/nfslock.so
  		ln -sf nfslock.so.$(NFSVER) $(libdir)/nfslock.so.0
 -		if test "$(DESTDIR)" = ""; then @LDCONFIG@; fi
++		if test "$(DESTDIR)" = ""; then $(LDCONFIG); fi
  
- clean:
- 		rm -f *.a *.o *.so *.so.* dotlockfile
+ test:		test-stamp
+ 		@:
 -- 
 2.25.1
 
diff --git a/meta-openembedded/meta-oe/recipes-extended/liblockfile/liblockfile/0001-Makefile.in-install-nfslock-libs.patch b/meta-openembedded/meta-oe/recipes-extended/liblockfile/liblockfile/0001-Makefile.in-install-nfslock-libs.patch
index a6b297b..f99ac2b 100644
--- a/meta-openembedded/meta-oe/recipes-extended/liblockfile/liblockfile/0001-Makefile.in-install-nfslock-libs.patch
+++ b/meta-openembedded/meta-oe/recipes-extended/liblockfile/liblockfile/0001-Makefile.in-install-nfslock-libs.patch
@@ -1,4 +1,4 @@
-From 631d46efff2a6d8970e202ba5422ebedd17a8d2f Mon Sep 17 00:00:00 2001
+From 0f34d1d91d641c3d5c5bb2eb11bd6eec7cfaf738 Mon Sep 17 00:00:00 2001
 From: Mingli Yu <mingli.yu@windriver.com>
 Date: Thu, 19 Jul 2018 01:00:10 -0700
 Subject: [PATCH] Makefile.in: install nfslock.so and nfslock.so.0
@@ -14,10 +14,10 @@
  1 file changed, 2 insertions(+)
 
 diff --git a/Makefile.in b/Makefile.in
-index 1e4130e..0f1b506 100644
+index 8cbda1d..3a74811 100644
 --- a/Makefile.in
 +++ b/Makefile.in
-@@ -77,6 +77,8 @@ install_common:
+@@ -88,6 +88,8 @@ install_common:
  install_nfslib:	nfslib
  		install -d -m 755 -g root -p $(nfslockdir)
  		install -m 755 nfslock.so.$(NFSVER) $(nfslockdir)
@@ -25,7 +25,7 @@
 +		ln -sf nfslock.so.$(NFSVER) $(libdir)/nfslock.so.0
  		if test "$(DESTDIR)" = ""; then @LDCONFIG@; fi
  
- clean:
+ test:		test-stamp
 -- 
-2.17.1
+2.25.1
 
diff --git a/meta-openembedded/meta-oe/recipes-extended/liblockfile/liblockfile/0001-Makefile.in-redefine-LOCKPROG.patch b/meta-openembedded/meta-oe/recipes-extended/liblockfile/liblockfile/0001-Makefile.in-redefine-LOCKPROG.patch
index 35549ff..c387db1 100644
--- a/meta-openembedded/meta-oe/recipes-extended/liblockfile/liblockfile/0001-Makefile.in-redefine-LOCKPROG.patch
+++ b/meta-openembedded/meta-oe/recipes-extended/liblockfile/liblockfile/0001-Makefile.in-redefine-LOCKPROG.patch
@@ -1,4 +1,4 @@
-From 9beb650712d448ad9c0899de9d98e9b623f9c249 Mon Sep 17 00:00:00 2001
+From 05227e74b732f13ed5a2a98232676f98bba028e6 Mon Sep 17 00:00:00 2001
 From: Mingli Yu <mingli.yu@windriver.com>
 Date: Fri, 12 Aug 2022 11:18:15 +0800
 Subject: [PATCH] Makefile.in: redefine LOCKPROG
@@ -11,23 +11,41 @@
 Upstream-Status: Inappropriate [oe specific]
 
 Signed-off-by: Mingli Yu <mingli.yu@windriver.com>
+
+Update patch for 1.17, also redefine LOCKPROG in other lines
+Signed-off-by: Changqing Li <changqing.li@windriver.com>
 ---
- Makefile.in | 2 +-
- 1 file changed, 1 insertion(+), 1 deletion(-)
+ Makefile.in | 8 ++++----
+ 1 file changed, 4 insertions(+), 4 deletions(-)
 
 diff --git a/Makefile.in b/Makefile.in
-index 6e53179..bfa0acb 100644
+index e447cb2..e02d75e 100644
 --- a/Makefile.in
 +++ b/Makefile.in
-@@ -42,7 +42,7 @@ dotlockfile:	dotlockfile.o xlockfile.o
- 		$(CC) $(LDFLAGS) -o dotlockfile dotlockfile.o xlockfile.o
+@@ -44,19 +44,19 @@ dotlockfile:	dotlockfile.o dlockfile.o
+ 		$(CC) $(LDFLAGS) -o dotlockfile dotlockfile.o dlockfile.o
+ 
+ dotlockfile.o:	dotlockfile.c
+-		$(CC) $(CFLAGS) -DLOCKPROG=\"$(bindir)/dotlockfile\" \
++		$(CC) $(CFLAGS) -DLOCKPROG=\"/usr/bin/dotlockfile\" \
+ 			-c dotlockfile.c
  
  lockfile.o:	lockfile.c
 -		$(CC) $(CFLAGS) -DLIB -DLOCKPROG=\"$(bindir)/dotlockfile\" \
 +		$(CC) $(CFLAGS) -DLIB -DLOCKPROG=\"/usr/bin/dotlockfile\" \
- 			-c lockfile.c
+ 			-DSTATIC -c lockfile.c
  
- xlockfile.o:	lockfile.c
+ solockfile.o:	lockfile.c
+-		$(CC) $(CFLAGS) -DLIB -DLOCKPROG=\"$(bindir)/dotlockfile\" \
++		$(CC) $(CFLAGS) -DLIB -DLOCKPROG=\"/usr/bin/dotlockfile\" \
+ 			-c lockfile.c -o solockfile.o
+ 
+ dlockfile.o:	lockfile.c
+-		$(CC) $(CFLAGS) -DLOCKPROG=\"$(bindir)/dotlockfile\" \
++		$(CC) $(CFLAGS) -DLOCKPROG=\"/usr/bin/dotlockfile\" \
+ 			-c lockfile.c -o dlockfile.o
+ 
+ install_static:	static install_common
 -- 
 2.25.1
 
diff --git a/meta-openembedded/meta-oe/recipes-extended/liblockfile/liblockfile/configure.patch b/meta-openembedded/meta-oe/recipes-extended/liblockfile/liblockfile/configure.patch
index ea13e11..56f2d05 100644
--- a/meta-openembedded/meta-oe/recipes-extended/liblockfile/liblockfile/configure.patch
+++ b/meta-openembedded/meta-oe/recipes-extended/liblockfile/liblockfile/configure.patch
@@ -1,10 +1,17 @@
+From fd3fce8c1a3d0c70a0ffd461fbbe7e2ef71dd3a7 Mon Sep 17 00:00:00 2001
+From: Changqing Li <changqing.li@windriver.com>
+Date: Tue, 7 Mar 2023 11:05:45 +0800
+Subject: [PATCH] Update patch for 1.17
 
-#
-# Patch managed by http://www.mn-logistik.de/unsupported/pxa250/patcher
-#
+Signed-off-by: Changqing Li <changqing.li@windriver.com>
+---
+ configure.ac | 8 +++++---
+ 1 file changed, 5 insertions(+), 3 deletions(-)
 
---- liblockfile-1.05/./configure.in~configure
-+++ liblockfile-1.05/./configure.in
+diff --git a/configure.ac b/configure.ac
+index df26cee..76e9165 100644
+--- a/configure.ac
++++ b/configure.ac
 @@ -1,4 +1,5 @@
 -AC_INIT(lockfile.c)
 +AC_INIT
@@ -12,7 +19,7 @@
  AC_CONFIG_HEADER(autoconf.h)
  AC_REVISION($Revision: 1.0 $)dnl
  
-@@ -111,7 +112,8 @@
+@@ -111,7 +112,8 @@ AC_SUBST(TARGETS)
  AC_SUBST(INSTALL_TARGETS)
  AC_SUBST(nfslockdir)
  
@@ -23,3 +30,6 @@
 -)
 +])
 +AC_OUTPUT
+-- 
+2.25.1
+
diff --git a/meta-openembedded/meta-oe/recipes-extended/liblockfile/liblockfile/liblockfile-fix-install-so-to-man-dir.patch b/meta-openembedded/meta-oe/recipes-extended/liblockfile/liblockfile/liblockfile-fix-install-so-to-man-dir.patch
index da25033..046cd8e 100644
--- a/meta-openembedded/meta-oe/recipes-extended/liblockfile/liblockfile/liblockfile-fix-install-so-to-man-dir.patch
+++ b/meta-openembedded/meta-oe/recipes-extended/liblockfile/liblockfile/liblockfile-fix-install-so-to-man-dir.patch
@@ -1,4 +1,4 @@
-From 363eb1aaeca914c7d36a2cdaf1417e4f87af4c22 Mon Sep 17 00:00:00 2001
+From 079d04c187800e22f18723c74e41c4e46eef67f8 Mon Sep 17 00:00:00 2001
 From: Mingli Yu <mingli.yu@windriver.com>
 Date: Thu, 19 Jul 2018 01:12:47 -0700
 Subject: [PATCH] Makefile.in: define dotlockfile.1 installed to man
@@ -16,10 +16,10 @@
  1 file changed, 1 insertion(+), 1 deletion(-)
 
 diff --git a/Makefile.in b/Makefile.in
-index 0f1b506..6e53179 100644
+index 3a74811..e447cb2 100644
 --- a/Makefile.in
 +++ b/Makefile.in
-@@ -71,7 +71,7 @@ install_common:
+@@ -82,7 +82,7 @@ install_common:
  		else \
  		  install -g root -m 755 dotlockfile $(bindir); \
  		fi
@@ -29,5 +29,5 @@
  
  install_nfslib:	nfslib
 -- 
-2.17.1
+2.25.1
 
diff --git a/meta-openembedded/meta-oe/recipes-extended/liblockfile/liblockfile_1.14.bb b/meta-openembedded/meta-oe/recipes-extended/liblockfile/liblockfile_1.17.bb
similarity index 67%
rename from meta-openembedded/meta-oe/recipes-extended/liblockfile/liblockfile_1.14.bb
rename to meta-openembedded/meta-oe/recipes-extended/liblockfile/liblockfile_1.17.bb
index e07dab3..b094337 100644
--- a/meta-openembedded/meta-oe/recipes-extended/liblockfile/liblockfile_1.14.bb
+++ b/meta-openembedded/meta-oe/recipes-extended/liblockfile/liblockfile_1.17.bb
@@ -4,23 +4,20 @@
 LICENSE = "LGPL-2.0-or-later & GPL-2.0-or-later"
 LIC_FILES_CHKSUM = "file://COPYRIGHT;md5=f4ba6ad04fcb05cc30a4cfa5062c55a3"
 
-SRC_URI = "${DEBIAN_MIRROR}/main/libl/liblockfile/liblockfile_1.14.orig.tar.gz \
-    ${DEBIAN_MIRROR}/main/libl/liblockfile/liblockfile_1.14-1.debian.tar.bz2;name=1.14-1 \
+SRC_URI = "${DEBIAN_MIRROR}/main/libl/liblockfile/liblockfile_1.17.orig.tar.gz \
+    ${DEBIAN_MIRROR}/main/libl/liblockfile/liblockfile_1.17-1.debian.tar.bz2;name=1.17-1 \
     file://configure.patch \
     file://0001-Makefile.in-add-DESTDIR.patch \
     file://0001-Makefile.in-install-nfslock-libs.patch \
     file://liblockfile-fix-install-so-to-man-dir.patch \
     file://0001-Makefile.in-redefine-LOCKPROG.patch \
-    file://0001-Makefile.in-Don-t-try-to-run-ldconfig.patch \
+    file://0001-Makefile.in-fix-install-failure-on-host-without-ldco.patch \
 "
 
-SRC_URI[md5sum] = "420c056ba0cc4d1477e402f70ba2f5eb"
-SRC_URI[sha256sum] = "ab40d4a3e8cbc204f7e87fea637a4e4ddf9a1149aaa0a723a4267febd0b1d060"
+SRC_URI[sha256sum] = "6e937f3650afab4aac198f348b89b1ca42edceb17fb6bb0918f642143ccfd15e"
+SRC_URI[1.17-1.sha256sum] = "e3657c0e3facfeccb58900c0b48d56cd68ad5f9f24d1b4c6eaa69c26490fb673"
 
-SRC_URI[1.14-1.md5sum] = "f9a44928c3477d218c56252712ebc479"
-SRC_URI[1.14-1.sha256sum] = "73f9be769e602149391588c28f0f4f5cda131e30fb94c0777dbb23d811ac21ff"
-
-S = "${WORKDIR}/${BPN}"
+S = "${WORKDIR}/${BP}"
 
 inherit autotools-brokensep
 
diff --git a/meta-openembedded/meta-oe/recipes-extended/libreport/files/0001-Makefile.am-remove-doc-and-apidoc.patch b/meta-openembedded/meta-oe/recipes-extended/libreport/files/0001-Makefile.am-remove-doc-and-apidoc.patch
index 1ee0dd2..934dd17 100644
--- a/meta-openembedded/meta-oe/recipes-extended/libreport/files/0001-Makefile.am-remove-doc-and-apidoc.patch
+++ b/meta-openembedded/meta-oe/recipes-extended/libreport/files/0001-Makefile.am-remove-doc-and-apidoc.patch
@@ -1,28 +1,32 @@
-From 1f7d106c7d982fe055addc8d883b161202233175 Mon Sep 17 00:00:00 2001
+From 73dc0c2cd942e30f5f7cb40cb5828895b96f0fb1 Mon Sep 17 00:00:00 2001
 From: Hongxu Jia <hongxu.jia@windriver.com>
 Date: Wed, 26 Apr 2017 03:47:58 -0400
-Subject: [PATCH 1/4] Makefile.am: remove doc and apidoc
+Subject: [PATCH] Makefile.am: remove doc and apidoc
 
 There was a failure at do_install time, so remove doc to workaround.
 
 Upstream-Status: Inappropriate [workaround]
 
 Signed-off-by: Hongxu Jia <hongxu.jia@windriver.com>
+
+Context modified to apply to v2.17.8.
+
+Signed-off-by: Joe Slater <joe.slater@windriver.com>
 ---
  Makefile.am | 2 +-
  1 file changed, 1 insertion(+), 1 deletion(-)
 
 diff --git a/Makefile.am b/Makefile.am
-index 9ad827c..34364a8 100644
+index 4ff2f5c5..d4e30bc2 100644
 --- a/Makefile.am
 +++ b/Makefile.am
 @@ -1,5 +1,5 @@
  ACLOCAL_AMFLAGS = -I m4
--SUBDIRS = po src tests doc apidoc
-+SUBDIRS = po src tests
+-SUBDIRS = data po src tests doc apidoc
++SUBDIRS = data po src tests
  
  EXTRA_DIST = \
      libreport.pc.in \
 -- 
-2.7.4
+2.25.1
 
diff --git a/meta-openembedded/meta-oe/recipes-extended/libreport/files/0002-configure.ac-remove-prog-test-of-xmlto-and-asciidoc.patch b/meta-openembedded/meta-oe/recipes-extended/libreport/files/0002-configure.ac-remove-prog-test-of-xmlto-and-asciidoc.patch
index 2e691e9..4fdf69c 100644
--- a/meta-openembedded/meta-oe/recipes-extended/libreport/files/0002-configure.ac-remove-prog-test-of-xmlto-and-asciidoc.patch
+++ b/meta-openembedded/meta-oe/recipes-extended/libreport/files/0002-configure.ac-remove-prog-test-of-xmlto-and-asciidoc.patch
@@ -1,7 +1,7 @@
-From 9beadcdfca9198548f06bf18f3f26e1d11542e53 Mon Sep 17 00:00:00 2001
+From 276c45d0663124c9ccab0ddc8b97fb5cdc8b3867 Mon Sep 17 00:00:00 2001
 From: Hongxu Jia <hongxu.jia@windriver.com>
 Date: Tue, 31 Jul 2018 16:53:04 +0800
-Subject: [PATCH 2/4] configure.ac: remove prog test of xmlto and asciidoc
+Subject: [PATCH] configure.ac: remove prog test of xmlto and asciidoc
 
 The prog of xmlto and asciidoc were used to generate documents,
 and since the doc module has already been disabled, so we should
@@ -10,15 +10,19 @@
 Upstream-Status: Inappropriate [workaround]
 
 Signed-off-by: Hongxu Jia <hongxu.jia@windriver.com>
+
+Modify to apply to v 2.17.8.
+
+Signed-off-by: Joe Slater <joe.slater@windriver.com>
 ---
  configure.ac | 18 ------------------
  1 file changed, 18 deletions(-)
 
 diff --git a/configure.ac b/configure.ac
-index feafc28..aceccf4 100644
+index da8cf898..17ece200 100644
 --- a/configure.ac
 +++ b/configure.ac
-@@ -56,24 +56,6 @@ IT_PROG_INTLTOOL([0.35.0])
+@@ -57,24 +57,6 @@ IT_PROG_INTLTOOL([0.35.0])
  
  dnl ****** END ****************************************
  
@@ -42,7 +46,7 @@
 -
  AC_ARG_WITH(bugzilla,
  AS_HELP_STRING([--with-bugzilla],[use Bugzilla plugin (default is YES)]),
- LIBREPORT_PARSE_WITH([bugzilla]))
+ LIBREPORT_PARSE_WITH([bugzilla]),
 -- 
-2.7.4
+2.25.1
 
diff --git a/meta-openembedded/meta-oe/recipes-extended/libreport/files/0003-without-build-plugins.patch b/meta-openembedded/meta-oe/recipes-extended/libreport/files/0003-without-build-plugins.patch
index c331677..f6ff860 100644
--- a/meta-openembedded/meta-oe/recipes-extended/libreport/files/0003-without-build-plugins.patch
+++ b/meta-openembedded/meta-oe/recipes-extended/libreport/files/0003-without-build-plugins.patch
@@ -1,26 +1,30 @@
-From 41bce1de2fd2a0f79c266f245ae3e3720ccaf46a Mon Sep 17 00:00:00 2001
+From f46610901dbac56d9631df012374c600db08453e Mon Sep 17 00:00:00 2001
 From: Hongxu Jia <hongxu.jia@windriver.com>
 Date: Wed, 26 Apr 2017 03:51:03 -0400
-Subject: [PATCH 3/4] without build plugins
+Subject: [PATCH] without build plugins
 
 Upstream-Status: Inappropriate [workaround]
 
 Rebase to 2.9.1
 Signed-off-by: Hongxu Jia <hongxu.jia@windriver.com>
+
+Modify to apply to v2.17.8.
+
+Signed-off-by: Joe Slater <joe.slater@windriver.com>
 ---
  src/Makefile.am | 2 +-
  1 file changed, 1 insertion(+), 1 deletion(-)
 
 diff --git a/src/Makefile.am b/src/Makefile.am
-index c15928c..bac02b1 100644
+index 410bfcb0..bac02b16 100644
 --- a/src/Makefile.am
 +++ b/src/Makefile.am
 @@ -8,4 +8,4 @@ if BUILD_NEWT
  sub_dirs += report-newt
  endif
  
--SUBDIRS = include lib plugins report-python cli client-python workflows $(sub_dirs)
+-SUBDIRS = include lib report-python cli client-python plugins workflows $(sub_dirs)
 +SUBDIRS = include lib report-python cli client-python workflows $(sub_dirs)
 -- 
-2.7.4
+2.25.1
 
diff --git a/meta-openembedded/meta-oe/recipes-extended/libreport/files/0004-configure.ac-remove-prog-test-of-augparse.patch b/meta-openembedded/meta-oe/recipes-extended/libreport/files/0004-configure.ac-remove-prog-test-of-augparse.patch
index 986e7ec..998ae6b 100644
--- a/meta-openembedded/meta-oe/recipes-extended/libreport/files/0004-configure.ac-remove-prog-test-of-augparse.patch
+++ b/meta-openembedded/meta-oe/recipes-extended/libreport/files/0004-configure.ac-remove-prog-test-of-augparse.patch
@@ -1,25 +1,29 @@
-From c1c301502a8f69b9889197744b301a136082f09d Mon Sep 17 00:00:00 2001
+From 62c922f43b54585d25ba89be36c10612b479270b Mon Sep 17 00:00:00 2001
 From: Hongxu Jia <hongxu.jia@windriver.com>
 Date: Thu, 27 Apr 2017 02:15:02 -0400
-Subject: [PATCH 4/4] configure.ac: remove prog test of augparse
+Subject: [PATCH] configure.ac: remove prog test of augparse
 
 The build time does not require it.
 
 Upstream-Status: Inappropriate [workaround]
 
 Signed-off-by: Hongxu Jia <hongxu.jia@windriver.com>
+
+Modify to apply to v2.17.8.
+
+Signed-off-by: Joe Slater <joe.slater@windriver.com>
 ---
- configure.ac | 8 --------
- 1 file changed, 8 deletions(-)
+ configure.ac | 9 ---------
+ 1 file changed, 9 deletions(-)
 
 diff --git a/configure.ac b/configure.ac
-index aceccf4..83c101b 100644
+index 17ece200..89b463a4 100644
 --- a/configure.ac
 +++ b/configure.ac
-@@ -350,14 +350,6 @@ AC_ARG_WITH(augeaslenslibdir,
-                            [Directory for librepor lens (default: /usr/share/augeas/lenses)])],
-             [], [with_augeaslenslibdir="/usr/share/augeas/lenses"])
- AC_SUBST([AUGEAS_LENS_LIB_DIR], [$with_augeaslenslibdir])
+@@ -287,15 +287,6 @@ AC_ARG_WITH(largedatatmpdir,
+             [], [with_largedatatmpdir="/var/tmp"])
+ AC_SUBST([LARGE_DATA_TMP_DIR], [$with_largedatatmpdir])
+ 
 -AC_PATH_PROG(AUGPARSE, augparse, no)
 -[if test "$AUGPARSE" = "no"]
 -[then]
@@ -28,9 +32,10 @@
 -    [echo "Then run configure again before attempting to build libreport."]
 -    [exit 1]
 -[fi]
- 
+-
  AC_ARG_WITH([defaultdumpdirmode],
              AS_HELP_STRING([--with-defaultdumpdirmode=OCTAL-MODE],
+                            [Default dump dir mode (default: 0x1A0 (0640))]),
 -- 
-2.7.4
+2.25.1
 
diff --git a/meta-openembedded/meta-oe/recipes-extended/libreport/libreport_2.10.0.bb b/meta-openembedded/meta-oe/recipes-extended/libreport/libreport_2.17.8.bb
similarity index 93%
rename from meta-openembedded/meta-oe/recipes-extended/libreport/libreport_2.10.0.bb
rename to meta-openembedded/meta-oe/recipes-extended/libreport/libreport_2.17.8.bb
index 35ef692..a8d1db6 100644
--- a/meta-openembedded/meta-oe/recipes-extended/libreport/libreport_2.10.0.bb
+++ b/meta-openembedded/meta-oe/recipes-extended/libreport/libreport_2.17.8.bb
@@ -17,7 +17,9 @@
             file://0003-without-build-plugins.patch \
             file://0004-configure.ac-remove-prog-test-of-augparse.patch \
 "
-SRCREV = "eaff08f38d771d9362923765bb404b1514c5ca0a"
+
+# 2.17.8
+SRCREV = "46a99a14adba7276e5697b7c613d918796792345"
 
 UPSTREAM_CHECK_GITTAGREGEX = "(?P<pver>\d+(\.\d+)+)"
 
@@ -31,7 +33,7 @@
 PACKAGECONFIG ??= "${@bb.utils.contains('DISTRO_FEATURES','x11','gtk','',d)}"
 PACKAGECONFIG[gtk] = "--with-gtk, --without-gtk, gtk+3,"
 
-EXTRA_OECONF += "--without-python2 --with-python3"
+EXTRA_OECONF += "--with-python3"
 
 RDEPENDS:python3-libreport += "${PN}"
 
diff --git a/meta-openembedded/meta-oe/recipes-extended/libx86-1/libx86-1.1/0001-Define-CARD32-as-uint-as-it-is-32-bit.patch b/meta-openembedded/meta-oe/recipes-extended/libx86-1/libx86-1.1/0001-Define-CARD32-as-uint-as-it-is-32-bit.patch
new file mode 100644
index 0000000..aef521b
--- /dev/null
+++ b/meta-openembedded/meta-oe/recipes-extended/libx86-1/libx86-1.1/0001-Define-CARD32-as-uint-as-it-is-32-bit.patch
@@ -0,0 +1,42 @@
+From 592c915df252932961a4151c891da58c48a8db90 Mon Sep 17 00:00:00 2001
+From: Khem Raj <raj.khem@gmail.com>
+Date: Thu, 2 Mar 2023 18:47:40 -0800
+Subject: [PATCH] Define CARD32 as uint as it is 32-bit
+
+long can be 64bit on LP64 systems and none of systems we support need int < 32-bits
+therefore use NUM32 to be int always if the system is linux
+
+Fixes build with clang-16
+thunk.c:147:3: error: incompatible function pointer types initializing 'x86emuu32 (*)(X86EMU_pioAddr)' (aka 'unsigned int (*)(unsigned short)') with an expression of type 'unsigned long (*)(unsigned short)' [-Wincompatible-function-pointer-types]
+                (&x_inl),
+                ^~~~~~~~
+
+Upstream-Status: Pending
+Signed-off-by: Khem Raj <raj.khem@gmail.com>
+---
+ x86emu/include/xf86int10.h | 2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+--- a/x86emu/include/xf86int10.h
++++ b/x86emu/include/xf86int10.h
+@@ -18,7 +18,7 @@
+ 
+ #define CARD8  unsigned char
+ #define CARD16 unsigned short
+-#define CARD32 unsigned long
++#define CARD32 unsigned int
+ #define pointer void *
+ #define IOADDRESS void *
+ #define Bool int
+--- a/x86emu/include/types.h
++++ b/x86emu/include/types.h
+@@ -77,7 +77,8 @@
+     defined(__s390x__) || \
+     (defined(__hppa__) && defined(__LP64)) || \
+     defined(__amd64__) || defined(amd64) || \
+-    (defined(__sgi) && (_MIPS_SZLONG == 64))
++    (defined(__sgi) && (_MIPS_SZLONG == 64)) || \
++    defined(__linux__)
+ #define NUM32 int
+ #else
+ #define NUM32 long
diff --git a/meta-openembedded/meta-oe/recipes-extended/libx86-1/libx86-1_1.1.bb b/meta-openembedded/meta-oe/recipes-extended/libx86-1/libx86-1_1.1.bb
index 9dc91f3..b646162 100644
--- a/meta-openembedded/meta-oe/recipes-extended/libx86-1/libx86-1_1.1.bb
+++ b/meta-openembedded/meta-oe/recipes-extended/libx86-1/libx86-1_1.1.bb
@@ -12,6 +12,7 @@
            file://0001-assume-zero-is-valid-address.patch \
            file://makefile-add-ldflags.patch \
            file://0001-Fix-type-of-the-void-pointer-assignment.patch \
+           file://0001-Define-CARD32-as-uint-as-it-is-32-bit.patch \
 "
 
 SRC_URI[md5sum] = "41bee1f8e22b82d82b5f7d7ba51abc2a"
diff --git a/meta-openembedded/meta-oe/recipes-extended/libyang/libyang/0001-test_context-skip-test-case-test_searchdirs.patch b/meta-openembedded/meta-oe/recipes-extended/libyang/libyang/0001-test_context-skip-test-case-test_searchdirs.patch
new file mode 100644
index 0000000..3c6aee9
--- /dev/null
+++ b/meta-openembedded/meta-oe/recipes-extended/libyang/libyang/0001-test_context-skip-test-case-test_searchdirs.patch
@@ -0,0 +1,29 @@
+From 5de24e1b39c09adb0c5bf4bb4228bd1bb935542a Mon Sep 17 00:00:00 2001
+From: Yi Zhao <yi.zhao@windriver.com>
+Date: Wed, 22 Mar 2023 16:03:56 +0800
+Subject: [PATCH] test_context: skip test case test_searchdirs
+
+Skip test case test_searchdirs as it searchs the source code directory.
+
+Upstream-Status: Inappropriate [embedded specific]
+
+Signed-off-by: Yi Zhao <yi.zhao@windriver.com>
+---
+ tests/utests/basic/test_context.c | 1 -
+ 1 file changed, 1 deletion(-)
+
+diff --git a/tests/utests/basic/test_context.c b/tests/utests/basic/test_context.c
+index cfba1d30f..8c3bb7ad6 100644
+--- a/tests/utests/basic/test_context.c
++++ b/tests/utests/basic/test_context.c
+@@ -1061,7 +1061,6 @@ int
+ main(void)
+ {
+     const struct CMUnitTest tests[] = {
+-        UTEST(test_searchdirs),
+         UTEST(test_options),
+         UTEST(test_models),
+         UTEST(test_imports),
+-- 
+2.25.1
+
diff --git a/meta-openembedded/meta-oe/recipes-extended/libyang/libyang/libyang-add-stdint-h.patch b/meta-openembedded/meta-oe/recipes-extended/libyang/libyang/libyang-add-stdint-h.patch
deleted file mode 100644
index d357411..0000000
--- a/meta-openembedded/meta-oe/recipes-extended/libyang/libyang/libyang-add-stdint-h.patch
+++ /dev/null
@@ -1,35 +0,0 @@
-From c7f3e2a8fe530beec6103cb9071ccc41458879aa Mon Sep 17 00:00:00 2001
-From: Tony Tascioglu <tony.tascioglu@windriver.com>
-Date: Mon, 21 Jun 2021 12:34:22 -0400
-Subject: [PATCH] libyang: fix initial build errors
-
-This patch addresses build errors seen when integrating libyang as a
-recipe.
-
-There is a missing include statement for stdint.h in utests.h which
-causes build problems. stdint.h is required to be imported by cmocka.h
-prior to the cmocka file. Adding the stdint allows it to build the
-tests correctly
-
-Upstream-Status: Submitted [ https://github.com/CESNET/libyang/pull/1819 ]
-
-Signed-off-by: Tony Tascioglu <tony.tascioglu@windriver.com>
-Signed-off-by: Randy MacLeod <randy.macleod@windriver.com>
----
- tests/utests/utests.h | 1 +
- 1 file changed, 1 insertion(+)
-
-diff --git a/tests/utests/utests.h b/tests/utests/utests.h
-index 7e85a66e..8eee26ce 100644
---- a/tests/utests/utests.h
-+++ b/tests/utests/utests.h
-@@ -22,6 +22,7 @@
- #include <stdarg.h>
- #include <stddef.h>
- #include <stdlib.h>
-+#include <stdint.h>
- 
- #include <cmocka.h>
- 
--- 
-2.32.0
diff --git a/meta-openembedded/meta-oe/recipes-extended/libyang/libyang/run-ptest b/meta-openembedded/meta-oe/recipes-extended/libyang/libyang/run-ptest
index 1c9f8f4..c507afb 100644
--- a/meta-openembedded/meta-oe/recipes-extended/libyang/libyang/run-ptest
+++ b/meta-openembedded/meta-oe/recipes-extended/libyang/libyang/run-ptest
@@ -1,46 +1,18 @@
 #!/bin/sh
-# Valid tests to run
-tests="utest_binary \
-       utest_bits \
-       utest_common \
-       utest_hash_table \
-       utest_inet_types \
-       utest_int8 \
-       utest_json \
-       utest_list \
-       utest_merge \
-       utest_metadata \
-       utest_parser_yang \
-       utest_parser_yin \
-       utest_pattern \
-       utest_printer_yang \
-       utest_printer_yin \
-       utest_range \
-       utest_schema \
-       utest_set \
-       utest_string \
-       utest_tree_data \
-       utest_tree_schema_compile \
-       utest_types \
-       utest_xml \
-       utest_xpath \
-       utest_yang_types \
-       utest_yanglib"
 
 # cd into right directory
 ptestdir=$(dirname "$(readlink -f "$0")")
 cd "$ptestdir"/tests || exit
 
-# Run specified tests
+tests=$(find * -type f -name 'utest_*')
+
 for f in $tests
 do
-    if test -e ./"$f"; then
+    if test -x ./"$f"; then
         if ./"$f" > ./"$f".out 2> ./"$f".err; then
             echo "PASS: $f"
         else
             echo "FAIL: $f"
         fi
-    else
-        echo "SKIP: $f"
     fi
 done
diff --git a/meta-openembedded/meta-oe/recipes-extended/libyang/libyang_2.0.194.bb b/meta-openembedded/meta-oe/recipes-extended/libyang/libyang_2.0.194.bb
deleted file mode 100644
index 548dcdd..0000000
--- a/meta-openembedded/meta-oe/recipes-extended/libyang/libyang_2.0.194.bb
+++ /dev/null
@@ -1,37 +0,0 @@
-SUMMARY = "YANG data modeling language library"
-DESCRIPTION = "libyang is a YANG data modelling language parser and toolkit written (and providing API) in C."
-HOMEPAGE = "https://github.com/CESNET/libyang"
-SECTION = "libs"
-LICENSE = "BSD-3-Clause"
-
-LIC_FILES_CHKSUM = "file://LICENSE;md5=f3916d7d8d42a6508d0ea418cfff10ad"
-
-SRCREV = "87375f15159545a87a1e0de200f5d9d67e9091d7"
-
-SRC_URI = "git://github.com/CESNET/libyang.git;branch=master;protocol=https \
-           file://libyang-add-stdint-h.patch \
-           file://run-ptest \
-           "
-
-S = "${WORKDIR}/git"
-
-# Due to valgrind not supported on these arches:
-COMPATIBLE_HOST:riscv32 = "null"
-COMPATIBLE_HOST:armv5 = "null"
-COMPATIBLE_HOST:riscv64 = "null"
-
-# Main dependencies
-inherit cmake pkgconfig lib_package ptest
-DEPENDS = "libpcre2"
-DEPENDS += "${@bb.utils.contains('PTEST_ENABLED', '1', 'cmocka', '', d)}"
-
-# Ptest dependencies
-RDEPENDS:${PN}-ptest += "valgrind"
-
-EXTRA_OECMAKE = "-DCMAKE_BUILD_TYPE=Release"
-EXTRA_OECMAKE += " ${@bb.utils.contains('PTEST_ENABLED', '1', '-DENABLE_TESTS=ON', '', d)}"
-
-do_install_ptest () {
-    cp -fR ${B}/tests/ ${D}${PTEST_PATH}/
-}
-
diff --git a/meta-openembedded/meta-oe/recipes-extended/libyang/libyang_2.1.55.bb b/meta-openembedded/meta-oe/recipes-extended/libyang/libyang_2.1.55.bb
new file mode 100644
index 0000000..b1438c3
--- /dev/null
+++ b/meta-openembedded/meta-oe/recipes-extended/libyang/libyang_2.1.55.bb
@@ -0,0 +1,41 @@
+SUMMARY = "YANG data modeling language library"
+DESCRIPTION = "libyang is a YANG data modelling language parser and toolkit written (and providing API) in C."
+HOMEPAGE = "https://github.com/CESNET/libyang"
+SECTION = "libs"
+LICENSE = "BSD-3-Clause"
+
+LIC_FILES_CHKSUM = "file://LICENSE;md5=f3916d7d8d42a6508d0ea418cfff10ad"
+
+SRCREV = "9a4e5b2ce30b9696116d6e654ee55caab5aafed8"
+
+SRC_URI = "git://github.com/CESNET/libyang.git;branch=master;protocol=https \
+           file://0001-test_context-skip-test-case-test_searchdirs.patch \
+           file://run-ptest \
+           "
+
+S = "${WORKDIR}/git"
+
+# Main dependencies
+inherit cmake pkgconfig lib_package ptest
+DEPENDS = "libpcre2"
+DEPENDS += "${@bb.utils.contains('PTEST_ENABLED', '1', 'cmocka', '', d)}"
+
+EXTRA_OECMAKE = "-DCMAKE_BUILD_TYPE=Release"
+EXTRA_OECMAKE += " ${@bb.utils.contains('PTEST_ENABLED', '1', '-DENABLE_TESTS=ON -DENABLE_VALGRIND_TESTS=OFF', '', d)}"
+
+do_compile:prepend () {
+    if [ ${PTEST_ENABLED} = "1" ]; then
+        sed -i -e 's|${S}|${PTEST_PATH}|g' ${B}/tests/tests_config.h
+        sed -i -e 's|${B}|${PTEST_PATH}|g' ${B}/tests/tests_config.h
+    fi
+}
+
+do_install_ptest () {
+    install -d ${D}${PTEST_PATH}/tests
+    cp -f ${B}/tests/utest_* ${D}${PTEST_PATH}/tests/
+    cp -fR ${S}/tests/modules ${D}${PTEST_PATH}/tests/
+    install -d ${D}${PTEST_PATH}/tests/plugins
+    cp -f ${B}/tests/plugins/plugin_*.so ${D}${PTEST_PATH}/tests/plugins/
+}
+
+FILES:${PN} += "${datadir}/yang/*"
diff --git a/meta-openembedded/meta-oe/recipes-extended/logwatch/logwatch_7.7.bb b/meta-openembedded/meta-oe/recipes-extended/logwatch/logwatch_7.8.bb
similarity index 96%
rename from meta-openembedded/meta-oe/recipes-extended/logwatch/logwatch_7.7.bb
rename to meta-openembedded/meta-oe/recipes-extended/logwatch/logwatch_7.8.bb
index 37a9466..187e794 100644
--- a/meta-openembedded/meta-oe/recipes-extended/logwatch/logwatch_7.7.bb
+++ b/meta-openembedded/meta-oe/recipes-extended/logwatch/logwatch_7.8.bb
@@ -12,7 +12,7 @@
 RDEPENDS:${PN} = "perl"
 
 SRC_URI = "http://jaist.dl.sourceforge.net/project/${BPN}/${BP}/${BP}.tar.gz"
-SRC_URI[sha256sum] = "2a10c2c73f85d2ec9d8e9be3f553b7b5849cf795b89a1c1379c99cc36a06adbd"
+SRC_URI[sha256sum] = "b1df31779306c2c87d595816305c89c19c382edf9ebbfce03143f567e580be42"
 
 do_install() {
     install -m 0755 -d ${D}${sysconfdir}/logwatch/scripts
diff --git a/meta-openembedded/meta-oe/recipes-extended/pmdk/pmdk/0001-pmempool-Match-function-prototypes-of-enum_to_str_fn.patch b/meta-openembedded/meta-oe/recipes-extended/pmdk/pmdk/0001-pmempool-Match-function-prototypes-of-enum_to_str_fn.patch
new file mode 100644
index 0000000..b16b633
--- /dev/null
+++ b/meta-openembedded/meta-oe/recipes-extended/pmdk/pmdk/0001-pmempool-Match-function-prototypes-of-enum_to_str_fn.patch
@@ -0,0 +1,43 @@
+From de6425acaa50426883e85a599001ae5e927aec5b Mon Sep 17 00:00:00 2001
+From: Khem Raj <raj.khem@gmail.com>
+Date: Thu, 2 Mar 2023 16:23:56 -0800
+Subject: [PATCH] pmempool: Match function prototypes of enum_to_str_fn
+ function pointer
+
+This is flagged by clang 16+
+common.c:844:4: error: cast from 'const char *(*)(enum chunk_type)' to 'enum_to_str_fn' (aka 'const char *(*)(int)') converts to incompatible function type [-Werror,-Wcast-function-type-strict]
+                        (enum_to_str_fn)out_get_chunk_type_str);
+                        ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+1 error generated.
+
+Upstream-Status: Submitted [https://github.com/pmem/pmdk/pull/5543]
+Signed-off-by: Khem Raj <raj.khem@gmail.com>
+---
+ src/tools/pmempool/common.c | 4 ++--
+ 1 file changed, 2 insertions(+), 2 deletions(-)
+
+diff --git a/src/tools/pmempool/common.c b/src/tools/pmempool/common.c
+index 5e7e472cc..4b7e9b95f 100644
+--- a/src/tools/pmempool/common.c
++++ b/src/tools/pmempool/common.c
+@@ -41,7 +41,7 @@
+ 
+ #define REQ_BUFF_SIZE	2048U
+ #define Q_BUFF_SIZE	8192
+-typedef const char *(*enum_to_str_fn)(int);
++typedef const char *(*enum_to_str_fn)(enum chunk_type);
+ 
+ /*
+  * pmem_pool_type -- return pool type based on first two pages.
+@@ -790,7 +790,7 @@ util_parse_enum(const char *str, int first, int max, uint64_t *bitmap,
+ 		enum_to_str_fn enum_to_str)
+ {
+ 	for (int i = first; i < max; i++) {
+-		if (strcmp(str, enum_to_str(i)) == 0) {
++		if (strcmp(str, enum_to_str((enum chunk_type)i)) == 0) {
+ 			*bitmap |= (uint64_t)1<<i;
+ 			return 0;
+ 		}
+-- 
+2.39.2
+
diff --git a/meta-openembedded/meta-oe/recipes-extended/pmdk/pmdk/0001-use-daxctl-libdaxctl.h-instead-of-ndctl-libdaxctl.h.patch b/meta-openembedded/meta-oe/recipes-extended/pmdk/pmdk/0001-use-daxctl-libdaxctl.h-instead-of-ndctl-libdaxctl.h.patch
deleted file mode 100644
index 0b03ffd..0000000
--- a/meta-openembedded/meta-oe/recipes-extended/pmdk/pmdk/0001-use-daxctl-libdaxctl.h-instead-of-ndctl-libdaxctl.h.patch
+++ /dev/null
@@ -1,69 +0,0 @@
-From 932252c0ba54a51c8bcf58b747656e29cdebfa6a Mon Sep 17 00:00:00 2001
-From: Khem Raj <raj.khem@gmail.com>
-Date: Sat, 26 Mar 2022 13:06:50 -0700
-Subject: [PATCH] use daxctl/libdaxctl.h instead of ndctl/libdaxctl.h
-
-Upstream-Status: Submitted [https://github.com/pmem/pmdk/pull/5413]
-Signed-off-by: Khem Raj <raj.khem@gmail.com>
----
- src/libpmem2/badblocks_ndctl.c        | 2 +-
- src/libpmem2/region_namespace_ndctl.c | 2 +-
- src/libpmem2/usc_ndctl.c              | 2 +-
- src/tools/daxio/daxio.c               | 2 +-
- 4 files changed, 4 insertions(+), 4 deletions(-)
-
-diff --git a/src/libpmem2/badblocks_ndctl.c b/src/libpmem2/badblocks_ndctl.c
-index 9a5910bba..cc637f7f4 100644
---- a/src/libpmem2/badblocks_ndctl.c
-+++ b/src/libpmem2/badblocks_ndctl.c
-@@ -16,7 +16,7 @@
- #include <sys/sysmacros.h>
- #include <fcntl.h>
- #include <ndctl/libndctl.h>
--#include <ndctl/libdaxctl.h>
-+#include <daxctl/libdaxctl.h>
- 
- #include "libpmem2.h"
- #include "pmem2_utils.h"
-diff --git a/src/libpmem2/region_namespace_ndctl.c b/src/libpmem2/region_namespace_ndctl.c
-index 1383796a9..e31185984 100644
---- a/src/libpmem2/region_namespace_ndctl.c
-+++ b/src/libpmem2/region_namespace_ndctl.c
-@@ -6,7 +6,7 @@
-  */
- 
- #include <ndctl/libndctl.h>
--#include <ndctl/libdaxctl.h>
-+#include <daxctl/libdaxctl.h>
- #include <sys/sysmacros.h>
- #include <fcntl.h>
- 
-diff --git a/src/libpmem2/usc_ndctl.c b/src/libpmem2/usc_ndctl.c
-index be63e879b..c58032a83 100644
---- a/src/libpmem2/usc_ndctl.c
-+++ b/src/libpmem2/usc_ndctl.c
-@@ -5,7 +5,7 @@
-  * usc_ndctl.c -- pmem2 usc function for platforms using ndctl
-  */
- #include <ndctl/libndctl.h>
--#include <ndctl/libdaxctl.h>
-+#include <daxctl/libdaxctl.h>
- #include <sys/types.h>
- #include <sys/sysmacros.h>
- #include <fcntl.h>
-diff --git a/src/tools/daxio/daxio.c b/src/tools/daxio/daxio.c
-index 66cd0b7ae..7f2c89d48 100644
---- a/src/tools/daxio/daxio.c
-+++ b/src/tools/daxio/daxio.c
-@@ -21,7 +21,7 @@
- #include <string.h>
- 
- #include <ndctl/libndctl.h>
--#include <ndctl/libdaxctl.h>
-+#include <daxctl/libdaxctl.h>
- #include <libpmem.h>
- 
- #include "util.h"
--- 
-2.35.1
-
diff --git a/meta-openembedded/meta-oe/recipes-extended/pmdk/pmdk_1.11.1.bb b/meta-openembedded/meta-oe/recipes-extended/pmdk/pmdk_1.12.1.bb
similarity index 85%
rename from meta-openembedded/meta-oe/recipes-extended/pmdk/pmdk_1.11.1.bb
rename to meta-openembedded/meta-oe/recipes-extended/pmdk/pmdk_1.12.1.bb
index 33d0409..5261922 100644
--- a/meta-openembedded/meta-oe/recipes-extended/pmdk/pmdk_1.11.1.bb
+++ b/meta-openembedded/meta-oe/recipes-extended/pmdk/pmdk_1.12.1.bb
@@ -4,16 +4,16 @@
 SECTION = "libs"
 LICENSE = "BSD-3-Clause"
 LIC_FILES_CHKSUM = "file://LICENSE;md5=b44ee63f162f9cdb18fff1224877aafd"
-DEPENDS = "ndctl"
+DEPENDS = "ndctl cmake-native"
 
 # Required to have the fts.h header for musl
 DEPENDS:append:libc-musl = " fts"
 
 S = "${WORKDIR}/git"
 
-SRC_URI = "git://github.com/pmem/pmdk.git;branch=stable-1.11;protocol=https \
-           file://0001-use-daxctl-libdaxctl.h-instead-of-ndctl-libdaxctl.h.patch"
-SRCREV = "5b21904a257eff47f2e87fcbf2de46111f03ddd8"
+SRC_URI = "git://github.com/pmem/pmdk.git;branch=stable-1.12;protocol=https \
+           file://0001-pmempool-Match-function-prototypes-of-enum_to_str_fn.patch"
+SRCREV = "786098a024c6fe60e746f2cb1041bcfcd21386c9"
 
 inherit autotools-brokensep pkgconfig
 
diff --git a/meta-openembedded/meta-oe/recipes-extended/redis/redis-7/init-redis-server b/meta-openembedded/meta-oe/recipes-extended/redis/redis-7/init-redis-server
index 6014d70..c5f335f 100755
--- a/meta-openembedded/meta-oe/recipes-extended/redis/redis-7/init-redis-server
+++ b/meta-openembedded/meta-oe/recipes-extended/redis/redis-7/init-redis-server
@@ -27,6 +27,37 @@
     restart)
         echo "Stopping redis-server..."
         start-stop-daemon --stop --quiet --exec /usr/bin/redis-server
+
+        # Since busybox implementation ignores --retry arguments repeatedly check
+        # if the process is still running and try another signal after a timeout,
+        # efectively simulating a stop with --retry=TERM/5/KILL/5 schedule.
+        waitAfterTerm=5000000 # us / 5000 ms / 5 s
+        waitAfterKill=5000000 # us / 5000 ms / 5 s
+        waitStep=100000 # us / 100 ms / 0.1 s
+        waited=0
+        start-stop-daemon --stop --test --quiet --exec /usr/bin/redis-server
+        processOff=$?
+        while [ $processOff -eq 0 ] && [ $waited -le $waitAfterTerm ] ; do
+            usleep ${waitStep}
+            ((waited+=${waitStep}))
+            start-stop-daemon --stop --test --quiet --exec /usr/bin/redis-server
+            processOff=$?
+        done
+        if [ $processOff -eq 0 ] ; then
+            start-stop-daemon --stop --signal KILL --exec /usr/bin/redis-server
+            start-stop-daemon --stop --test --quiet --exec /usr/bin/redis-server
+            processOff=$?
+        fi
+        waited=0
+        while [ $processOff -eq 0 ] && [ $waited -le $waitAfterKill ] ; do
+            usleep ${waitStep}
+            ((waited+=${waitStep}))
+            start-stop-daemon --stop --test --quiet --exec /usr/bin/redis-server
+            processOff=$?
+        done
+        # Here $processOff will indicate if waiting and retrying according to
+        # the schedule ended in a successfull stop or not.
+
 	echo "Starting redis-server..."
         start-stop-daemon --start --quiet --exec /usr/bin/redis-server -- $ARGS
 	;;
diff --git a/meta-openembedded/meta-oe/recipes-extended/redis/redis/init-redis-server b/meta-openembedded/meta-oe/recipes-extended/redis/redis/init-redis-server
index 6014d70..c5f335f 100755
--- a/meta-openembedded/meta-oe/recipes-extended/redis/redis/init-redis-server
+++ b/meta-openembedded/meta-oe/recipes-extended/redis/redis/init-redis-server
@@ -27,6 +27,37 @@
     restart)
         echo "Stopping redis-server..."
         start-stop-daemon --stop --quiet --exec /usr/bin/redis-server
+
+        # Since busybox implementation ignores --retry arguments repeatedly check
+        # if the process is still running and try another signal after a timeout,
+        # efectively simulating a stop with --retry=TERM/5/KILL/5 schedule.
+        waitAfterTerm=5000000 # us / 5000 ms / 5 s
+        waitAfterKill=5000000 # us / 5000 ms / 5 s
+        waitStep=100000 # us / 100 ms / 0.1 s
+        waited=0
+        start-stop-daemon --stop --test --quiet --exec /usr/bin/redis-server
+        processOff=$?
+        while [ $processOff -eq 0 ] && [ $waited -le $waitAfterTerm ] ; do
+            usleep ${waitStep}
+            ((waited+=${waitStep}))
+            start-stop-daemon --stop --test --quiet --exec /usr/bin/redis-server
+            processOff=$?
+        done
+        if [ $processOff -eq 0 ] ; then
+            start-stop-daemon --stop --signal KILL --exec /usr/bin/redis-server
+            start-stop-daemon --stop --test --quiet --exec /usr/bin/redis-server
+            processOff=$?
+        fi
+        waited=0
+        while [ $processOff -eq 0 ] && [ $waited -le $waitAfterKill ] ; do
+            usleep ${waitStep}
+            ((waited+=${waitStep}))
+            start-stop-daemon --stop --test --quiet --exec /usr/bin/redis-server
+            processOff=$?
+        done
+        # Here $processOff will indicate if waiting and retrying according to
+        # the schedule ended in a successfull stop or not.
+
 	echo "Starting redis-server..."
         start-stop-daemon --start --quiet --exec /usr/bin/redis-server -- $ARGS
 	;;
diff --git a/meta-openembedded/meta-oe/recipes-extended/redis/redis_6.2.9.bb b/meta-openembedded/meta-oe/recipes-extended/redis/redis_6.2.11.bb
similarity index 95%
rename from meta-openembedded/meta-oe/recipes-extended/redis/redis_6.2.9.bb
rename to meta-openembedded/meta-oe/recipes-extended/redis/redis_6.2.11.bb
index 100c2a2..5a410bf 100644
--- a/meta-openembedded/meta-oe/recipes-extended/redis/redis_6.2.9.bb
+++ b/meta-openembedded/meta-oe/recipes-extended/redis/redis_6.2.11.bb
@@ -17,7 +17,7 @@
            file://GNU_SOURCE.patch \
            file://0006-Define-correct-gregs-for-RISCV32.patch \
            "
-SRC_URI[sha256sum] = "9661b2c6b1cc9bf2999471b37a4d759fa5e747d408142c18af8792ebd8384a2a"
+SRC_URI[sha256sum] = "8c75fb9cdd01849e92c23f30cb7fe205ea0032a38d11d46af191014e9acc3098"
 
 inherit autotools-brokensep update-rc.d systemd useradd
 
diff --git a/meta-openembedded/meta-oe/recipes-extended/redis/redis_7.0.8.bb b/meta-openembedded/meta-oe/recipes-extended/redis/redis_7.0.10.bb
similarity index 96%
rename from meta-openembedded/meta-oe/recipes-extended/redis/redis_7.0.8.bb
rename to meta-openembedded/meta-oe/recipes-extended/redis/redis_7.0.10.bb
index fe1db9f..5d21f7e 100644
--- a/meta-openembedded/meta-oe/recipes-extended/redis/redis_7.0.8.bb
+++ b/meta-openembedded/meta-oe/recipes-extended/redis/redis_7.0.10.bb
@@ -19,7 +19,7 @@
            file://GNU_SOURCE-7.patch \
            file://0006-Define-correct-gregs-for-RISCV32.patch \
            "
-SRC_URI[sha256sum] = "06a339e491306783dcf55b97f15a5dbcbdc01ccbde6dc23027c475cab735e914"
+SRC_URI[sha256sum] = "1dee4c6487341cae7bd6432ff7590906522215a061fdef87c7d040a0cb600131"
 
 inherit autotools-brokensep update-rc.d systemd useradd
 
diff --git a/meta-openembedded/meta-oe/recipes-extended/rsyslog/librelp_1.11.0.bb b/meta-openembedded/meta-oe/recipes-extended/rsyslog/librelp_1.11.0.bb
index da3e9a1..e7b79ad 100644
--- a/meta-openembedded/meta-oe/recipes-extended/rsyslog/librelp_1.11.0.bb
+++ b/meta-openembedded/meta-oe/recipes-extended/rsyslog/librelp_1.11.0.bb
@@ -14,3 +14,7 @@
 S = "${WORKDIR}/git"
 
 inherit autotools pkgconfig
+
+DEBUG_OPTIMIZATION:append = " -Wno-error=inline"
+
+
diff --git a/meta-openembedded/meta-oe/recipes-extended/rsyslog/rsyslog_8.2212.0.bb b/meta-openembedded/meta-oe/recipes-extended/rsyslog/rsyslog_8.2302.0.bb
similarity index 96%
rename from meta-openembedded/meta-oe/recipes-extended/rsyslog/rsyslog_8.2212.0.bb
rename to meta-openembedded/meta-oe/recipes-extended/rsyslog/rsyslog_8.2302.0.bb
index ed65bed..39d9516 100644
--- a/meta-openembedded/meta-oe/recipes-extended/rsyslog/rsyslog_8.2212.0.bb
+++ b/meta-openembedded/meta-oe/recipes-extended/rsyslog/rsyslog_8.2302.0.bb
@@ -31,7 +31,7 @@
     file://0001-Include-sys-time-h.patch \
 "
 
-SRC_URI[sha256sum] = "53b59a872e3dc7384cdc149abe9744916776f7057d905f3df6722d2eb1b04f35"
+SRC_URI[sha256sum] = "25415f85b662615ce3c83077d53758029e8743cb5929044bfd3564e3d626a3b9"
 
 UPSTREAM_CHECK_URI = "https://github.com/rsyslog/rsyslog/releases"
 UPSTREAM_CHECK_REGEX = "(?P<pver>\d+(\.\d+)+)"
@@ -76,6 +76,8 @@
 PACKAGECONFIG[mysql] = "--enable-mysql,--disable-mysql,mysql5,"
 PACKAGECONFIG[postgresql] = "--enable-pgsql,--disable-pgsql,postgresql,"
 PACKAGECONFIG[libdbi] = "--enable-libdbi,--disable-libdbi,libdbi,"
+# For libcap-ng, see commit log and  https://github.com/rsyslog/rsyslog/issues/5091
+PACKAGECONFIG[libcap-ng] = "--enable-libcap-ng,--disable-libcap-ng,libcap-ng,"
 PACKAGECONFIG[mail] = "--enable-mail,--disable-mail,,"
 PACKAGECONFIG[valgrind] = ",--without-valgrind-testbench,valgrind,"
 PACKAGECONFIG[imhttp] = "--enable-imhttp,--disable-imhttp,civetweb,"
diff --git a/meta-openembedded/meta-oe/recipes-extended/socketcan/can-utils_git.bb b/meta-openembedded/meta-oe/recipes-extended/socketcan/can-utils_2023.03.bb
similarity index 94%
rename from meta-openembedded/meta-oe/recipes-extended/socketcan/can-utils_git.bb
rename to meta-openembedded/meta-oe/recipes-extended/socketcan/can-utils_2023.03.bb
index 07b80a5..ca6cb7d 100644
--- a/meta-openembedded/meta-oe/recipes-extended/socketcan/can-utils_git.bb
+++ b/meta-openembedded/meta-oe/recipes-extended/socketcan/can-utils_2023.03.bb
@@ -6,9 +6,7 @@
 
 SRC_URI = "git://github.com/linux-can/${BPN}.git;protocol=https;branch=master"
 
-SRCREV = "3615bac17e539a06835dcb90855eae844ee18053"
-
-PV = "2021.08.0"
+SRCREV = "cfe41963f3425e9adb01a70cfaddedf5e5982720"
 
 S = "${WORKDIR}/git"
 
diff --git a/meta-openembedded/meta-oe/recipes-gnome/libjcat/libjcat_0.1.12.bb b/meta-openembedded/meta-oe/recipes-gnome/libjcat/libjcat_0.1.13.bb
similarity index 94%
rename from meta-openembedded/meta-oe/recipes-gnome/libjcat/libjcat_0.1.12.bb
rename to meta-openembedded/meta-oe/recipes-gnome/libjcat/libjcat_0.1.13.bb
index ff573ff..2f8cf1b 100644
--- a/meta-openembedded/meta-oe/recipes-gnome/libjcat/libjcat_0.1.12.bb
+++ b/meta-openembedded/meta-oe/recipes-gnome/libjcat/libjcat_0.1.13.bb
@@ -11,7 +11,7 @@
     git://github.com/hughsie/libjcat.git;branch=main;protocol=https \
     file://run-ptest \
 "
-SRCREV = "898b80468288bc6278b73210783ba1f7c0219c71"
+SRCREV = "f089d7ff9081bb6f211cdd712cddd159f8f63199"
 S = "${WORKDIR}/git"
 
 inherit gobject-introspection gtk-doc meson ptest-gnome vala lib_package
diff --git a/meta-openembedded/meta-oe/recipes-gnome/libpeas/libpeas_1.34.0.bb b/meta-openembedded/meta-oe/recipes-gnome/libpeas/libpeas_1.36.0.bb
similarity index 88%
rename from meta-openembedded/meta-oe/recipes-gnome/libpeas/libpeas_1.34.0.bb
rename to meta-openembedded/meta-oe/recipes-gnome/libpeas/libpeas_1.36.0.bb
index 1bf6752..1282e93 100644
--- a/meta-openembedded/meta-oe/recipes-gnome/libpeas/libpeas_1.34.0.bb
+++ b/meta-openembedded/meta-oe/recipes-gnome/libpeas/libpeas_1.36.0.bb
@@ -12,7 +12,7 @@
 
 ANY_OF_DISTRO_FEATURES = "${GTK3DISTROFEATURES}"
 
-SRC_URI[archive.sha256sum] = "4305f715dab4b5ad3e8007daec316625e7065a94e63e25ef55eb1efb964a7bf0"
+SRC_URI[archive.sha256sum] = "297cb9c2cccd8e8617623d1a3e8415b4530b8e5a893e3527bbfd1edd13237b4c"
 
 PACKAGECONFIG[python3] = "-Dpython3=true,-Dpython3=false,python3-pygobject"
 
diff --git a/meta-openembedded/meta-oe/recipes-graphics/freeglut/freeglut_3.4.0.bb b/meta-openembedded/meta-oe/recipes-graphics/freeglut/freeglut_3.4.0.bb
index 86b9414..b433900 100644
--- a/meta-openembedded/meta-oe/recipes-graphics/freeglut/freeglut_3.4.0.bb
+++ b/meta-openembedded/meta-oe/recipes-graphics/freeglut/freeglut_3.4.0.bb
@@ -16,8 +16,9 @@
 PACKAGECONFIG[wayland] = "-DFREEGLUT_WAYLAND=ON,-DFREEGLUT_WAYLAND=OFF,libxkbcommon"
 PACKAGECONFIG[demos] = "-DFREEGLUT_BUILD_DEMOS=ON,-DFREEGLUT_BUILD_DEMOS=OFF,"
 PACKAGECONFIG[x11] = ",,virtual/libx11 libice libxmu libglu libxrandr libxext"
-# Do not use -fno-common, check back when upgrading to new version it might not be needed
-CFLAGS += "-fcommon"
+# Add -Wno-implicit-function-declaration since it might be otherwise treated at
+# error by clang16+ and this is not really a problem
+CFLAGS += "-Wno-implicit-function-declaration"
 
 PROVIDES += "mesa-glut"
 
diff --git a/meta-openembedded/meta-oe/recipes-graphics/glm/glm/0001-Do-not-use-Werror-with-clang.patch b/meta-openembedded/meta-oe/recipes-graphics/glm/glm/0001-Do-not-use-Werror-with-clang.patch
new file mode 100644
index 0000000..7b3e005
--- /dev/null
+++ b/meta-openembedded/meta-oe/recipes-graphics/glm/glm/0001-Do-not-use-Werror-with-clang.patch
@@ -0,0 +1,30 @@
+From ee405855bca7d6399ff1a1aef952010056c84ff6 Mon Sep 17 00:00:00 2001
+From: Khem Raj <raj.khem@gmail.com>
+Date: Wed, 1 Mar 2023 21:08:09 -0800
+Subject: [PATCH] Do not use -Werror with clang
+
+Too many warnings to handle for a distro build
+
+Signed-off-by: Khem Raj <raj.khem@gmail.com>
+---
+ test/CMakeLists.txt | 4 ----
+ 1 file changed, 4 deletions(-)
+
+diff --git a/test/CMakeLists.txt b/test/CMakeLists.txt
+index e7f85f19..0b6fd980 100644
+--- a/test/CMakeLists.txt
++++ b/test/CMakeLists.txt
+@@ -197,10 +197,6 @@ if(CMAKE_CXX_COMPILER_ID MATCHES "Clang")
+ 		message("GLM: Clang - ${CMAKE_CXX_COMPILER_ID} compiler")
+ 	endif()
+ 
+-	add_compile_options(-Werror -Weverything)
+-	add_compile_options(-Wno-c++98-compat -Wno-c++98-compat-pedantic -Wno-c++11-long-long -Wno-padded -Wno-gnu-anonymous-struct -Wno-nested-anon-types)
+-	add_compile_options(-Wno-undefined-reinterpret-cast -Wno-sign-conversion -Wno-unused-variable -Wno-missing-prototypes -Wno-unreachable-code -Wno-missing-variable-declarations -Wno-sign-compare -Wno-global-constructors -Wno-unused-macros -Wno-format-nonliteral)
+-
+ elseif(CMAKE_CXX_COMPILER_ID MATCHES "GNU")
+ 	if(NOT GLM_QUIET)
+ 		message("GLM: GCC - ${CMAKE_CXX_COMPILER_ID} compiler")
+-- 
+2.39.2
+
diff --git a/meta-openembedded/meta-oe/recipes-graphics/glm/glm/0001-Silence-clang-warnings.patch b/meta-openembedded/meta-oe/recipes-graphics/glm/glm/0001-Silence-clang-warnings.patch
index 3a62fff..10692dd 100644
--- a/meta-openembedded/meta-oe/recipes-graphics/glm/glm/0001-Silence-clang-warnings.patch
+++ b/meta-openembedded/meta-oe/recipes-graphics/glm/glm/0001-Silence-clang-warnings.patch
@@ -26,8 +26,6 @@
  test/gtx/gtx_fast_trigonometry.cpp | 30 ++++++++++++------------------
  3 files changed, 14 insertions(+), 20 deletions(-)
 
-diff --git a/glm/ext/quaternion_common.inl b/glm/ext/quaternion_common.inl
-index 0e4a3bb2..6f99f52d 100644
 --- a/glm/ext/quaternion_common.inl
 +++ b/glm/ext/quaternion_common.inl
 @@ -104,7 +104,7 @@ namespace glm
@@ -39,21 +37,6 @@
              return (sin(angle - a * phi)* x + sin(a * phi) * z) / sin(angle);
          }
      }
-diff --git a/glm/gtc/random.inl b/glm/gtc/random.inl
-index 70485098..a4af2a06 100644
---- a/glm/gtc/random.inl
-+++ b/glm/gtc/random.inl
-@@ -22,7 +22,7 @@ namespace detail
- 		GLM_FUNC_QUALIFIER static vec<1, uint8, P> call()
- 		{
- 			return vec<1, uint8, P>(
--				std::rand() % std::numeric_limits<uint8>::max());
-+				static_cast<uint8>(std::rand()) % std::numeric_limits<uint8>::max());
- 		}
- 	};
- 
-diff --git a/test/gtx/gtx_fast_trigonometry.cpp b/test/gtx/gtx_fast_trigonometry.cpp
-index 8bf86ba0..ddaa708b 100644
 --- a/test/gtx/gtx_fast_trigonometry.cpp
 +++ b/test/gtx/gtx_fast_trigonometry.cpp
 @@ -19,15 +19,14 @@ namespace fastCos
@@ -160,6 +143,3 @@
  		const std::clock_t timestamp3 = std::clock();
  		const std::clock_t time_fast = timestamp2 - timestamp1;
  		const std::clock_t time_default = timestamp3 - timestamp2;
--- 
-2.31.1
-
diff --git a/meta-openembedded/meta-oe/recipes-graphics/glm/glm_0.9.9.8.bb b/meta-openembedded/meta-oe/recipes-graphics/glm/glm_0.9.9.8.bb
index 9edcb2b..3797314 100644
--- a/meta-openembedded/meta-oe/recipes-graphics/glm/glm_0.9.9.8.bb
+++ b/meta-openembedded/meta-oe/recipes-graphics/glm/glm_0.9.9.8.bb
@@ -11,19 +11,19 @@
 SRC_URI = " \
     git://github.com/g-truc/glm;branch=master;protocol=https \
     file://0001-Silence-clang-warnings.patch \
+    file://0001-Do-not-use-Werror-with-clang.patch \
     file://glmConfig.cmake.in \
     file://glmConfigVersion.cmake.in \
     file://glm.pc.in \
     file://glmTargets.cmake \
 "
-SRCREV = "bf71a834948186f4097caa076cd2663c69a10e1e"
+SRCREV = "efec5db081e3aad807d0731e172ac597f6a39447"
+PV .= "+0.9.9.9+git${SRCPV}"
 
 S = "${WORKDIR}/git"
 
 inherit cmake
 
-CXXFLAGS:append:toolchain-clang = " -Wno-error=invalid-utf8 -Wno-error=disabled-macro-expansion -Wno-error=reserved-identifier"
-
 do_install() {
     install -d ${D}${includedir} ${D}${docdir}/glm ${D}${libdir}/pkgconfig ${D}${libdir}/cmake/glm
     cp -R --no-dereference --preserve=mode,links ${S}/glm ${D}${includedir}
diff --git a/meta-openembedded/meta-oe/recipes-graphics/gphoto2/gphoto2/0001-Match-prototypes-of-callbacks-with-libgphoto.patch b/meta-openembedded/meta-oe/recipes-graphics/gphoto2/gphoto2/0001-Match-prototypes-of-callbacks-with-libgphoto.patch
new file mode 100644
index 0000000..abe38e1
--- /dev/null
+++ b/meta-openembedded/meta-oe/recipes-graphics/gphoto2/gphoto2/0001-Match-prototypes-of-callbacks-with-libgphoto.patch
@@ -0,0 +1,50 @@
+From 366930ccc1a261c3eb883da2bf3c655162ccd75f Mon Sep 17 00:00:00 2001
+From: Khem Raj <raj.khem@gmail.com>
+Date: Wed, 1 Mar 2023 22:58:37 -0800
+Subject: [PATCH] Match prototypes of callbacks with libgphoto
+
+In https://github.com/gphoto/gphoto2/pull/535/commits/ccc4c1f092bd21ebc713f4d7b9be85be49f92f1e
+we tried to fix by using pthread_t but it also needs to make changes in
+libgphoto and these changes can be invasive, therefore lets revert to
+older types and to fix musl problem fix it via type casts
+
+Upstream-Status: Submitted [https://github.com/gphoto/gphoto2/pull/569]
+Signed-off-by: Khem Raj <raj.khem@gmail.com>
+---
+ gphoto2/main.c | 8 ++++----
+ 1 file changed, 4 insertions(+), 4 deletions(-)
+
+diff --git a/gphoto2/main.c b/gphoto2/main.c
+index 0dac947..cd3c990 100644
+--- a/gphoto2/main.c
++++ b/gphoto2/main.c
+@@ -1198,7 +1198,7 @@ thread_func (void *data)
+ 	pthread_cleanup_pop (1);
+ }
+ 
+-static pthread_t
++static unsigned int
+ start_timeout_func (Camera *camera, unsigned int timeout,
+ 		    CameraTimeoutFunc func, void __unused__ *data)
+ {
+@@ -1215,14 +1215,14 @@ start_timeout_func (Camera *camera, unsigned int timeout,
+ 
+ 	pthread_create (&tid, NULL, thread_func, td);
+ 
+-	return (tid);
++	return (unsigned int)tid;
+ }
+ 
+ static void
+-stop_timeout_func (Camera __unused__ *camera, pthread_t id,
++stop_timeout_func (Camera __unused__ *camera, unsigned int id,
+ 		   void __unused__ *data)
+ {
+-	pthread_t tid = id;
++	pthread_t tid = (pthread_t)id;
+ 
+ 	pthread_cancel (tid);
+ 	pthread_join (tid, NULL);
+-- 
+2.39.2
+
diff --git a/meta-openembedded/meta-oe/recipes-graphics/gphoto2/gphoto2_2.5.28.bb b/meta-openembedded/meta-oe/recipes-graphics/gphoto2/gphoto2_2.5.28.bb
index fe33940..5138451 100644
--- a/meta-openembedded/meta-oe/recipes-graphics/gphoto2/gphoto2_2.5.28.bb
+++ b/meta-openembedded/meta-oe/recipes-graphics/gphoto2/gphoto2_2.5.28.bb
@@ -9,6 +9,7 @@
 SRC_URI = "${SOURCEFORGE_MIRROR}/gphoto/gphoto2-${PV}.tar.bz2;name=gphoto2 \
            file://0001-configure.ac-remove-AM_PO_SUBDIRS.patch \
            file://0001-gphoto2-Use-pthread_t-abstract-type-for-thead-IDs.patch \
+           file://0001-Match-prototypes-of-callbacks-with-libgphoto.patch \
 "
 SRC_URI[gphoto2.sha256sum] = "2a648dcdf12da19e208255df4ebed3e7d2a02f905be4165f2443c984cf887375"
 
diff --git a/meta-openembedded/meta-oe/recipes-graphics/libsdl/libsdl-image/0001-png-img-Fix-prototypes-of-callbacks.patch b/meta-openembedded/meta-oe/recipes-graphics/libsdl/libsdl-image/0001-png-img-Fix-prototypes-of-callbacks.patch
new file mode 100644
index 0000000..1bbfa99
--- /dev/null
+++ b/meta-openembedded/meta-oe/recipes-graphics/libsdl/libsdl-image/0001-png-img-Fix-prototypes-of-callbacks.patch
@@ -0,0 +1,52 @@
+From 41791738221fdb7574fc8e23f84214910cdce098 Mon Sep 17 00:00:00 2001
+From: Khem Raj <raj.khem@gmail.com>
+Date: Wed, 1 Mar 2023 21:51:40 -0800
+Subject: [PATCH] png-img: Fix prototypes of callbacks
+
+Clang-16 is flagging function pointer mismatches
+
+Upstream-Status: Inappropriate [No upstream]
+Signed-off-by: Khem Raj <raj.khem@gmail.com>
+---
+ IMG_png.c | 16 ++++++++--------
+ 1 file changed, 8 insertions(+), 8 deletions(-)
+
+diff --git a/IMG_png.c b/IMG_png.c
+index 5f91f15..4d5bdb6 100644
+--- a/IMG_png.c
++++ b/IMG_png.c
+@@ -78,15 +78,15 @@
+ static struct {
+ 	int loaded;
+ 	void *handle;
+-	png_infop (*png_create_info_struct) (png_structp png_ptr);
++	png_infop (*png_create_info_struct) (png_const_structp png_ptr);
+ 	png_structp (*png_create_read_struct) (png_const_charp user_png_ver, png_voidp error_ptr, png_error_ptr error_fn, png_error_ptr warn_fn);
+ 	void (*png_destroy_read_struct) (png_structpp png_ptr_ptr, png_infopp info_ptr_ptr, png_infopp end_info_ptr_ptr);
+-	png_uint_32 (*png_get_IHDR) (png_structp png_ptr, png_infop info_ptr, png_uint_32 *width, png_uint_32 *height, int *bit_depth, int *color_type, int *interlace_method, int *compression_method, int *filter_method);
+-	png_voidp (*png_get_io_ptr) (png_structp png_ptr);
+-	png_byte (*png_get_channels) (png_structp png_ptr, png_infop info_ptr);
+-	png_uint_32 (*png_get_PLTE) (png_structp png_ptr, png_infop info_ptr, png_colorp *palette, int *num_palette);
+-	png_uint_32 (*png_get_tRNS) (png_structp png_ptr, png_infop info_ptr, png_bytep *trans, int *num_trans, png_color_16p *trans_values);
+-	png_uint_32 (*png_get_valid) (png_structp png_ptr, png_infop info_ptr, png_uint_32 flag);
++	png_uint_32 (*png_get_IHDR) (png_const_structp png_ptr, png_const_infop info_ptr, png_uint_32 *width, png_uint_32 *height, int *bit_depth, int *color_type, int *interlace_method, int *compression_method, int *filter_method);
++	png_voidp (*png_get_io_ptr) (png_const_structp png_ptr);
++	png_byte (*png_get_channels) (png_const_structp png_ptr, png_const_infop info_ptr);
++	png_uint_32 (*png_get_PLTE) (png_const_structp png_ptr, png_infop info_ptr, png_colorp *palette, int *num_palette);
++	png_uint_32 (*png_get_tRNS) (png_const_structp png_ptr, png_infop info_ptr, png_bytep *trans, int *num_trans, png_color_16p *trans_values);
++	png_uint_32 (*png_get_valid) (png_const_structp png_ptr, png_const_infop info_ptr, png_uint_32 flag);
+ 	void (*png_read_image) (png_structp png_ptr, png_bytepp image);
+ 	void (*png_read_info) (png_structp png_ptr, png_infop info_ptr);
+ 	void (*png_read_update_info) (png_structp png_ptr, png_infop info_ptr);
+@@ -95,7 +95,7 @@ static struct {
+ 	void (*png_set_packing) (png_structp png_ptr);
+ 	void (*png_set_read_fn) (png_structp png_ptr, png_voidp io_ptr, png_rw_ptr read_data_fn);
+ 	void (*png_set_strip_16) (png_structp png_ptr);
+-	int (*png_sig_cmp) (png_bytep sig, png_size_t start, png_size_t num_to_check);
++	int (*png_sig_cmp) (png_const_bytep sig, png_size_t start, png_size_t num_to_check);
+ #ifndef LIBPNG_VERSION_12
+ 	jmp_buf* (*png_set_longjmp_fn) (png_structp, png_longjmp_ptr, size_t);
+ #endif
+-- 
+2.39.2
+
diff --git a/meta-openembedded/meta-oe/recipes-graphics/libsdl/libsdl-image_1.2.12.bb b/meta-openembedded/meta-oe/recipes-graphics/libsdl/libsdl-image_1.2.12.bb
index 5a93dc1..01137bb 100644
--- a/meta-openembedded/meta-oe/recipes-graphics/libsdl/libsdl-image_1.2.12.bb
+++ b/meta-openembedded/meta-oe/recipes-graphics/libsdl/libsdl-image_1.2.12.bb
@@ -7,8 +7,8 @@
 DEPENDS = "tiff zlib libpng jpeg libsdl"
 
 SRC_URI = "http://www.libsdl.org/projects/SDL_image/release/SDL_image-${PV}.tar.gz \
+           file://0001-png-img-Fix-prototypes-of-callbacks.patch \
            file://configure.patch"
-SRC_URI[md5sum] = "a0f9098ebe5400f0bdc9b62e60797ecb"
 SRC_URI[sha256sum] = "0b90722984561004de84847744d566809dbb9daf732a9e503b91a1b5a84e5699"
 
 S = "${WORKDIR}/SDL_image-${PV}"
diff --git a/meta-openembedded/meta-oe/recipes-graphics/libsdl/libsdl2-ttf/0001-freetype-Fix-function-signatures-to-match-without-ca.patch b/meta-openembedded/meta-oe/recipes-graphics/libsdl/libsdl2-ttf/0001-freetype-Fix-function-signatures-to-match-without-ca.patch
new file mode 100644
index 0000000..8cb76c3
--- /dev/null
+++ b/meta-openembedded/meta-oe/recipes-graphics/libsdl/libsdl2-ttf/0001-freetype-Fix-function-signatures-to-match-without-ca.patch
@@ -0,0 +1,69 @@
+From 6c52693d264ca3dc8e15a92f56cf3a636639bb6c Mon Sep 17 00:00:00 2001
+From: =?UTF-8?q?Martin=20Storsj=C3=B6?= <martin@martin.st>
+Date: Fri, 28 Oct 2022 22:17:15 +0300
+Subject: [PATCH] freetype: Fix function signatures to match without casts
+
+Clang 16 has got a new stricter warning for casts of function types
+(see https://github.com/llvm/llvm-project/commit/1aad641c793090b4d036c03e737df2ebe2c32c57).
+
+This new warning gets included as part of the existing error
+diagnostic setting of -Wcast-function-type.
+
+This fixes errors like these:
+
+../src/hb-ft.cc:1011:34: error: cast from 'void (*)(FT_Face)' (aka 'void (*)(FT_FaceRec_ *)') to 'FT_Generic_Finalizer' (aka 'void (*)(void *)') converts to incompatible function type [-Werror,-Wcast-function-type-strict]
+    ft_face->generic.finalizer = (FT_Generic_Finalizer) hb_ft_face_finalize;
+                                 ^~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Upstream-Status: Backport [https://github.com/harfbuzz/harfbuzz/commit/d88269c827895b38f99f7cf741fa60210d4d5169]
+---
+ src/hb-ft.cc | 10 ++++++----
+ 1 file changed, 6 insertions(+), 4 deletions(-)
+
+diff --git a/src/hb-ft.cc b/src/hb-ft.cc
+index a6beb9f0f..a35e75b18 100644
+--- a/src/hb-ft.cc
++++ b/src/hb-ft.cc
+@@ -729,8 +729,9 @@ hb_ft_face_create_referenced (FT_Face ft_face)
+ }
+ 
+ static void
+-hb_ft_face_finalize (FT_Face ft_face)
++hb_ft_face_finalize (void *arg)
+ {
++  FT_Face ft_face = (FT_Face) arg;
+   hb_face_destroy ((hb_face_t *) ft_face->generic.data);
+ }
+ 
+@@ -762,7 +763,7 @@ hb_ft_face_create_cached (FT_Face ft_face)
+       ft_face->generic.finalizer (ft_face);
+ 
+     ft_face->generic.data = hb_ft_face_create (ft_face, nullptr);
+-    ft_face->generic.finalizer = (FT_Generic_Finalizer) hb_ft_face_finalize;
++    ft_face->generic.finalizer = hb_ft_face_finalize;
+   }
+ 
+   return hb_face_reference ((hb_face_t *) ft_face->generic.data);
+@@ -949,8 +950,9 @@ get_ft_library ()
+ }
+ 
+ static void
+-_release_blob (FT_Face ft_face)
++_release_blob (void *arg)
+ {
++  FT_Face ft_face = (FT_Face) arg;
+   hb_blob_destroy ((hb_blob_t *) ft_face->generic.data);
+ }
+ 
+@@ -1032,7 +1034,7 @@ hb_ft_font_set_funcs (hb_font_t *font)
+ #endif
+ 
+   ft_face->generic.data = blob;
+-  ft_face->generic.finalizer = (FT_Generic_Finalizer) _release_blob;
++  ft_face->generic.finalizer = _release_blob;
+ 
+   _hb_ft_font_set_funcs (font, ft_face, true);
+   hb_ft_font_set_load_flags (font, FT_LOAD_DEFAULT | FT_LOAD_NO_HINTING);
+-- 
+2.39.2
+
diff --git a/meta-openembedded/meta-oe/recipes-graphics/libsdl/libsdl2-ttf_2.20.1.bb b/meta-openembedded/meta-oe/recipes-graphics/libsdl/libsdl2-ttf_2.20.2.bb
similarity index 76%
rename from meta-openembedded/meta-oe/recipes-graphics/libsdl/libsdl2-ttf_2.20.1.bb
rename to meta-openembedded/meta-oe/recipes-graphics/libsdl/libsdl2-ttf_2.20.2.bb
index b8732b4..7d352f4 100644
--- a/meta-openembedded/meta-oe/recipes-graphics/libsdl/libsdl2-ttf_2.20.1.bb
+++ b/meta-openembedded/meta-oe/recipes-graphics/libsdl/libsdl2-ttf_2.20.2.bb
@@ -2,17 +2,18 @@
 SECTION = "libs"
 DEPENDS = "libsdl2 freetype virtual/egl"
 LICENSE = "Zlib"
-LIC_FILES_CHKSUM = "file://LICENSE.txt;md5=771dca8728b18d39b130e19b36514371"
+LIC_FILES_CHKSUM = "file://LICENSE.txt;md5=a41cbf59bdea749fe34c1af6d3615f68"
 
 SRC_URI = " \
     git://github.com/libsdl-org/SDL_ttf.git;branch=release-2.20.x;protocol=https \
     git://github.com/libsdl-org/freetype.git;branch=VER-2-12-1-SDL;destsuffix=git/external/freetype;name=freetype;protocol=https \
     git://github.com/libsdl-org/harfbuzz.git;branch=2.9.1-SDL;destsuffix=git/external/harfbuzz;name=harfbuzz;protocol=https \
+    file://0001-freetype-Fix-function-signatures-to-match-without-ca.patch;patchdir=external/harfbuzz \
     file://automake_foreign.patch \
 "
-SRCREV = "0a652b598625d16ea7016665095cb1e9bce9ef4f"
+SRCREV = "89d1692fd8fe91a679bb943d377bfbd709b52c23"
 SRCREV_freetype = "6fc77cee03e078e97afcee0c0e06a2d3274b9a29"
-SRCREV_harfbuzz = "6022fe2f68d028ee178284f297b3902ffdf65b03"
+SRCREV_harfbuzz = "43931e3e596c04044861770b831c8f9452e2d3b0"
 
 S = "${WORKDIR}/git"
 
diff --git a/meta-openembedded/meta-oe/recipes-graphics/wayland/waylandpp_1.0.0.bb b/meta-openembedded/meta-oe/recipes-graphics/wayland/waylandpp_1.0.0.bb
index 5ba5aa7..eb8ec4f 100644
--- a/meta-openembedded/meta-oe/recipes-graphics/wayland/waylandpp_1.0.0.bb
+++ b/meta-openembedded/meta-oe/recipes-graphics/wayland/waylandpp_1.0.0.bb
@@ -13,7 +13,7 @@
 
 inherit cmake pkgconfig features_check
 
-REQUIRED_DISTRO_FEATURES = "opengl"
+REQUIRED_DISTRO_FEATURES:class-target = "opengl"
 
 EXTRA_OECMAKE:class-native = " \
 	-DBUILD_SCANNER=ON \
diff --git a/meta-openembedded/meta-oe/recipes-graphics/xorg-app/xterm/0001-Add-configure-time-check-for-setsid.patch b/meta-openembedded/meta-oe/recipes-graphics/xorg-app/xterm/0001-Add-configure-time-check-for-setsid.patch
index 92ecdac..a6cf16e 100644
--- a/meta-openembedded/meta-oe/recipes-graphics/xorg-app/xterm/0001-Add-configure-time-check-for-setsid.patch
+++ b/meta-openembedded/meta-oe/recipes-graphics/xorg-app/xterm/0001-Add-configure-time-check-for-setsid.patch
@@ -1,4 +1,4 @@
-From 3730a38efad969fb6f8227df07eb4461a078f5a3 Mon Sep 17 00:00:00 2001
+From b23d38f1216c4d70738edaa367cf9ecd2dd4b660 Mon Sep 17 00:00:00 2001
 From: Khem Raj <raj.khem@gmail.com>
 Date: Fri, 13 Dec 2019 12:59:26 -0800
 Subject: [PATCH] Add configure time check for setsid
@@ -7,18 +7,19 @@
 
 Upstream-Status: Pending
 Signed-off-by: Khem Raj <raj.khem@gmail.com>
+
 ---
  configure    | 1 +
  configure.in | 1 +
  main.c       | 4 ++--
  xtermcfg.hin | 1 +
- 5 files changed, 6 insertions(+), 2 deletions(-)
+ 4 files changed, 5 insertions(+), 2 deletions(-)
 
 diff --git a/configure b/configure
-index 0aafefc..03e8df0 100755
+index 72342c7..c2ec2ac 100755
 --- a/configure
 +++ b/configure
-@@ -5605,6 +5605,7 @@ for ac_func in \
+@@ -5803,6 +5803,7 @@ for ac_func in \
  	unsetenv \
  	sched_yield \
  	setpgid \
@@ -27,7 +28,7 @@
  	tcgetattr \
  	waitpid \
 diff --git a/configure.in b/configure.in
-index d2fee88..74d65df 100644
+index 56dbc25..0608c80 100644
 --- a/configure.in
 +++ b/configure.in
 @@ -99,6 +99,7 @@ AC_CHECK_FUNCS( \
@@ -39,10 +40,10 @@
  	tcgetattr \
  	waitpid \
 diff --git a/main.c b/main.c
-index 5e60589..b81d2be 100644
+index 24da0eb..332174c 100644
 --- a/main.c
 +++ b/main.c
-@@ -2903,7 +2903,7 @@ main(int argc, char *argv[]ENVP_ARG)
+@@ -2956,7 +2956,7 @@ main(int argc, char *argv[]ENVP_ARG)
      }
  }
  
@@ -51,7 +52,7 @@
  #define USE_OPENPTY 1
  static int opened_tty = -1;
  #endif
-@@ -4074,7 +4074,7 @@ spawnXTerm(XtermWidget xw, unsigned line_speed)
+@@ -4205,7 +4205,7 @@ spawnXTerm(XtermWidget xw, unsigned line_speed)
  	    /*
  	     * now in child process
  	     */
@@ -61,17 +62,14 @@
  #else
  	    int pgrp = getpid();
 diff --git a/xtermcfg.hin b/xtermcfg.hin
-index 1dbc3b8..4f3ff5b 100644
+index 19048cd..e54d2cd 100644
 --- a/xtermcfg.hin
 +++ b/xtermcfg.hin
-@@ -95,6 +95,7 @@
- #undef HAVE_PUTENV		/* AC_CHECK_FUNCS(putenv) */
+@@ -98,6 +98,7 @@
  #undef HAVE_SCHED_YIELD		/* AC_CHECK_FUNCS(sched_yield) */
+ #undef HAVE_SETITIMER		/* CF_SETITIMER */
  #undef HAVE_SETPGID		/* AC_CHECK_FUNCS(setpgid) */
 +#undef HAVE_SETSID		/* AC_CHECK_FUNCS(setsid) */
  #undef HAVE_STDINT_H		/* AC_PROG_CC_STDC */
  #undef HAVE_STDLIB_H		/* AC_CHECK_HEADERS(stdlib.h) */
  #undef HAVE_STDNORETURN_H	/* CF_C11_NORETURN */
--- 
-2.24.1
-
diff --git a/meta-openembedded/meta-oe/recipes-graphics/xorg-app/xterm_378.bb b/meta-openembedded/meta-oe/recipes-graphics/xorg-app/xterm_379.bb
similarity index 94%
rename from meta-openembedded/meta-oe/recipes-graphics/xorg-app/xterm_378.bb
rename to meta-openembedded/meta-oe/recipes-graphics/xorg-app/xterm_379.bb
index c82042b..1c32b5d 100644
--- a/meta-openembedded/meta-oe/recipes-graphics/xorg-app/xterm_378.bb
+++ b/meta-openembedded/meta-oe/recipes-graphics/xorg-app/xterm_379.bb
@@ -8,7 +8,7 @@
            file://0001-Add-configure-time-check-for-setsid.patch \
           "
 
-SRC_URI[sha256sum] = "649dfbfd5edd0ed9e47cf8e4d953b4b0d3c30bc280166dfc4ffd14973fec3e92"
+SRC_URI[sha256sum] = "a7ddf274ee84b97fb1283675009d53ca2d02a0ffd5ce5a5118dafc3623ebb310"
 
 PACKAGECONFIG ?= ""
 PACKAGECONFIG[xft] = "--enable-freetype,--disable-freetype,libxft fontconfig freetype-native"
diff --git a/meta-openembedded/meta-oe/recipes-graphics/xorg-driver/xf86-video-amdgpu_22.0.0.bb b/meta-openembedded/meta-oe/recipes-graphics/xorg-driver/xf86-video-amdgpu_23.0.0.bb
similarity index 82%
rename from meta-openembedded/meta-oe/recipes-graphics/xorg-driver/xf86-video-amdgpu_22.0.0.bb
rename to meta-openembedded/meta-oe/recipes-graphics/xorg-driver/xf86-video-amdgpu_23.0.0.bb
index 3082e2e..c417e95 100644
--- a/meta-openembedded/meta-oe/recipes-graphics/xorg-driver/xf86-video-amdgpu_22.0.0.bb
+++ b/meta-openembedded/meta-oe/recipes-graphics/xorg-driver/xf86-video-amdgpu_23.0.0.bb
@@ -6,8 +6,7 @@
 
 DESCRIPTION = "Xorg driver for AMD Radeon GPUs using the amdgpu kernel driver"
 
-SRC_URI[md5sum] = "73efb437f5eb29b2c52a9d82c7e15d72"
-SRC_URI[sha256sum] = "bc47a1a8854e790270fa5de2fb9dfe8558139b03d8f68ac1057dcd235d572dcc"
+SRC_URI[sha256sum] = "08c38287d39b999fd61ecb6e7b23d5079762e2b4b2179b3567973ed9aaf71222"
 
 XORG_DRIVER_COMPRESSOR = ".tar.gz"
 DEPENDS += "virtual/libx11 libdrm virtual/libgbm xorgproto"
diff --git a/meta-openembedded/meta-oe/recipes-kernel/crash/crash/0001-cross_add_configure_option.patch b/meta-openembedded/meta-oe/recipes-kernel/crash/crash/0001-cross_add_configure_option.patch
index 26a34e5..fc5cc3d 100644
--- a/meta-openembedded/meta-oe/recipes-kernel/crash/crash/0001-cross_add_configure_option.patch
+++ b/meta-openembedded/meta-oe/recipes-kernel/crash/crash/0001-cross_add_configure_option.patch
@@ -1,27 +1,27 @@
-From 73269df4d8196abe81112acaa2613155b308a8b8 Mon Sep 17 00:00:00 2001
+From e3ba432243d9be4e845daabc78a0ae7c03c680f5 Mon Sep 17 00:00:00 2001
 From: Lei Maohui <leimaohui@cn.fujitsu.com>
 Date: Fri, 9 Jan 2015 11:51:18 +0900
-Subject: [PATCH 1/9] cross_add_configure_option
+Subject: [PATCH] cross_add_configure_option
 
-%% original patch: 0001-cross_add_configure_option.patch
+
 ---
  Makefile | 4 ++--
  1 file changed, 2 insertions(+), 2 deletions(-)
 
 diff --git a/Makefile b/Makefile
-index a2baec1..f1972c8 100644
+index 7266e305..390fc0ef 100644
 --- a/Makefile
 +++ b/Makefile
-@@ -232,7 +232,7 @@ gdb_merge: force
+@@ -260,7 +260,7 @@ gdb_merge: force
  	@echo "../../${PROGRAM} ../../${PROGRAM}lib.a" > ${GDB}/gdb/mergeobj
  	@rm -f ${PROGRAM}
  	@if [ ! -f ${GDB}/config.status ]; then \
 -	  (cd ${GDB}; ./configure ${GDB_CONF_FLAGS} --with-separate-debug-dir=/usr/lib/debug \
 +	  (cd ${GDB}; ./configure --host=${GDB_TARGET} --build=${GDB_HOST} --with-separate-debug-dir=/usr/lib/debug \
  	    --with-bugurl="" --with-expat=no --with-python=no --disable-sim; \
- 	  make --no-print-directory CRASH_TARGET=${TARGET}; echo ${TARGET} > crash.target) \
- 	else make --no-print-directory rebuild; fi
-@@ -283,7 +283,7 @@ force:
+ 	  $(MAKE) CRASH_TARGET=${TARGET}; echo ${TARGET} > crash.target) \
+ 	else $(MAKE) rebuild; fi
+@@ -306,7 +306,7 @@ force:
  
  make_configure: force
  	@rm -f configure
@@ -30,6 +30,3 @@
  
  clean: make_configure
  	@./configure ${CONF_TARGET_FLAG} -q -b
--- 
-2.8.1
-
diff --git a/meta-openembedded/meta-oe/recipes-kernel/crash/crash/7003cross_ranlib.patch b/meta-openembedded/meta-oe/recipes-kernel/crash/crash/7003cross_ranlib.patch
index d567fa0..a0d87f1 100644
--- a/meta-openembedded/meta-oe/recipes-kernel/crash/crash/7003cross_ranlib.patch
+++ b/meta-openembedded/meta-oe/recipes-kernel/crash/crash/7003cross_ranlib.patch
@@ -1,8 +1,19 @@
---- crash-5.1.8/Makefile.orig	2011-12-27 11:21:58.220652105 +0900
-+++ crash-5.1.8/Makefile	2011-12-27 11:22:29.563651593 +0900
-@@ -285,6 +285,7 @@
+From 2f200ceed289f935b5e7ec230454a22dd76e42b0 Mon Sep 17 00:00:00 2001
+From: leimaohui <leimaohui@cn.fujitsu.com>
+Date: Mon, 12 Jan 2015 11:52:35 +0800
+Subject: [PATCH] crash: add new recipe
+
+---
+ Makefile | 1 +
+ 1 file changed, 1 insertion(+)
+
+diff --git a/Makefile b/Makefile
+index 79aef176..7266e305 100644
+--- a/Makefile
++++ b/Makefile
+@@ -295,6 +295,7 @@ gdb_patch:
  
- library: make_build_data ${OBJECT_FILES}
+ library: ${OBJECT_FILES}
  	ar -rs ${PROGRAM}lib.a ${OBJECT_FILES}
 +	${RANLIB} ${PROGRAM}lib.a 
  
diff --git a/meta-openembedded/meta-oe/recipes-kernel/crash/crash/donnot-extract-gdb-during-do-compile.patch b/meta-openembedded/meta-oe/recipes-kernel/crash/crash/donnot-extract-gdb-during-do-compile.patch
index 7133cf0..1638287 100644
--- a/meta-openembedded/meta-oe/recipes-kernel/crash/crash/donnot-extract-gdb-during-do-compile.patch
+++ b/meta-openembedded/meta-oe/recipes-kernel/crash/crash/donnot-extract-gdb-during-do-compile.patch
@@ -1,33 +1,45 @@
+From 8b882650b730cb6e025d47d65574f43549b7a1a3 Mon Sep 17 00:00:00 2001
+From: Mingli Yu <mingli.yu@windriver.com>
+Date: Thu, 9 Mar 2023 10:28:28 +0800
+Subject: [PATCH] Makefile: Put gdb source tarball in SRC_URI
+
 Put gdb source tarball in SRC_URI and don't fetch and extract it during
 do_compile.
 
 Upstream-Status: Inappropriate [embedded specific]
 
 Signed-off-by: Kai Kang <kai.kang@windriver.com>
+Signed-off-by: Mingli Yu <mingli.yu@windriver.com>
 ---
+ Makefile | 8 +-------
+ 1 file changed, 1 insertion(+), 7 deletions(-)
+
 diff --git a/Makefile b/Makefile
-index bb0a34e..5eb7604 100644
+index 79aef17..146da6a 100644
 --- a/Makefile
 +++ b/Makefile
-@@ -228,7 +228,7 @@ all: make_configure
- #	@make --no-print-directory extensions
+@@ -254,7 +254,7 @@ all: make_configure
+ #	@$(MAKE) extensions
  
  gdb_merge: force
 -	@if [ ! -f ${GDB}/README ]; then \
 +	@if [ ! -f ${GDB}/${GDB}.patch ]; then \
- 	  make --no-print-directory gdb_unzip; fi
+ 	  $(MAKE) gdb_unzip; fi
  	@echo "${LDFLAGS} -lz -ldl -rdynamic" > ${GDB}/gdb/mergelibs
  	@echo "../../${PROGRAM} ../../${PROGRAM}lib.a" > ${GDB}/gdb/mergeobj
-@@ -255,12 +255,6 @@ gdb_unzip:
-	@rm -f gdb.files
-	@for FILE in ${GDB_FILES} dummy; do\
-	  echo $$FILE >> gdb.files; done
+@@ -281,12 +281,6 @@ gdb_unzip:
+ 	@rm -f gdb.files
+ 	@for FILE in ${GDB_FILES} dummy; do\
+ 	  echo $$FILE >> gdb.files; done
 -	@if [ ! -f ${GDB}.tar.gz ] && [ ! -f /usr/bin/wget ]; then \
 -	  echo /usr/bin/wget is required to download ${GDB}.tar.gz; echo; exit 1; fi
 -	@if [ ! -f ${GDB}.tar.gz ] && [ -f /usr/bin/wget ]; then \
 -	  [ ! -t 2 ] && WGET_OPTS="--progress=dot:mega"; \
 -	  wget $$WGET_OPTS http://ftp.gnu.org/gnu/gdb/${GDB}.tar.gz; fi
 -	@tar --exclude-from gdb.files -xzmf ${GDB}.tar.gz
-	@make --no-print-directory gdb_patch
-
+ 	@$(MAKE) gdb_patch
+ 
  gdb_patch:
+-- 
+2.25.1
+
diff --git a/meta-openembedded/meta-oe/recipes-kernel/crash/crash/gdb_build_jobs_and_not_write_crash_target.patch b/meta-openembedded/meta-oe/recipes-kernel/crash/crash/gdb_build_jobs_and_not_write_crash_target.patch
index aa5f44d..257b4dd 100644
--- a/meta-openembedded/meta-oe/recipes-kernel/crash/crash/gdb_build_jobs_and_not_write_crash_target.patch
+++ b/meta-openembedded/meta-oe/recipes-kernel/crash/crash/gdb_build_jobs_and_not_write_crash_target.patch
@@ -1,3 +1,8 @@
+From af49d8df559aa18f97d14ab7971f211238a16041 Mon Sep 17 00:00:00 2001
+From: Mingli Yu <mingli.yu@windriver.com>
+Date: Thu, 9 Mar 2023 10:50:10 +0800
+Subject: [PATCH] Makefile: Don't write ${TARGET} to crash.target
+
 This enables parallel building (multiple jobs in gdb) by reading the
 value from GDB_MAKE_JOBS.
 
@@ -8,19 +13,26 @@
 Don't write ${TARGET} to crash.target which causes rebuild fails.
 
 Signed-off-by: Kai Kang <kai.kang@windriver.com>
---
+Signed-off-by: Mingli Yu <mingli.yu@windriver.com>
+---
+ Makefile | 4 ++--
+ 1 file changed, 2 insertions(+), 2 deletions(-)
+
 diff --git a/Makefile b/Makefile
-index 27a1d47..bcf2d2f 100644
+index cd25c7d..d61c4c5 100644
 --- a/Makefile
 +++ b/Makefile
-@@ -232,8 +232,8 @@ gdb_merge: force
+@@ -262,8 +262,8 @@ gdb_merge: force
  	@if [ ! -f ${GDB}/config.status ]; then \
  	  (cd ${GDB}; ./configure --host=${GDB_TARGET} --build=${GDB_HOST} --with-separate-debug-dir=/usr/lib/debug \
  	    --with-bugurl="" --with-expat=no --with-python=no --disable-sim; \
--	  make --no-print-directory CRASH_TARGET=${TARGET}; echo ${TARGET} > crash.target) \
--	else make --no-print-directory rebuild; fi
-+	  make --no-print-directory CRASH_TARGET=${TARGET} ${GDB_MAKE_JOBS}; ) \
-+	else make --no-print-directory ${GDB_MAKE_JOBS} rebuild; fi
+-	  $(MAKE) CRASH_TARGET=${TARGET}; echo ${TARGET} > crash.target) \
+-	else $(MAKE) rebuild; fi
++	  $(MAKE) CRASH_TARGET=${TARGET} ${GDB_MAKE_JOBS}; ) \
++	else $(MAKE) ${GDB_MAKE_JOBS} rebuild; fi
  	@if [ ! -f ${PROGRAM} ]; then \
  	  echo; echo "${PROGRAM} build failed"; \
  	  echo; exit 1; fi
+-- 
+2.25.1
+
diff --git a/meta-openembedded/meta-oe/recipes-kernel/crash/crash_8.0.0.bb b/meta-openembedded/meta-oe/recipes-kernel/crash/crash_8.0.2.bb
similarity index 98%
rename from meta-openembedded/meta-oe/recipes-kernel/crash/crash_8.0.0.bb
rename to meta-openembedded/meta-oe/recipes-kernel/crash/crash_8.0.2.bb
index 55de6a6..f58bb6e 100644
--- a/meta-openembedded/meta-oe/recipes-kernel/crash/crash_8.0.0.bb
+++ b/meta-openembedded/meta-oe/recipes-kernel/crash/crash_8.0.2.bb
@@ -21,7 +21,7 @@
            file://donnot-extract-gdb-during-do-compile.patch \
            file://gdb_build_jobs_and_not_write_crash_target.patch \
            "
-SRCREV = "ec568e2ea515b66343d3488d5d4b9a625d55b7ae"
+SRCREV = "f1cd581d1c4afa5b8ffdfaa6a3ea9f545fe4ec91"
 
 SRC_URI[gdb.sha256sum] = "b33ad58d687487a821ec8d878daab0f716be60d0936f2e3ac5cf08419ce70350"
 
diff --git a/meta-openembedded/meta-oe/recipes-kernel/libbpf/libbpf_0.8.0.bb b/meta-openembedded/meta-oe/recipes-kernel/libbpf/libbpf_1.1.0.bb
similarity index 92%
rename from meta-openembedded/meta-oe/recipes-kernel/libbpf/libbpf_0.8.0.bb
rename to meta-openembedded/meta-oe/recipes-kernel/libbpf/libbpf_1.1.0.bb
index 3aea7c0..1aee51f 100644
--- a/meta-openembedded/meta-oe/recipes-kernel/libbpf/libbpf_0.8.0.bb
+++ b/meta-openembedded/meta-oe/recipes-kernel/libbpf/libbpf_1.1.0.bb
@@ -9,7 +9,7 @@
 DEPENDS = "zlib elfutils"
 
 SRC_URI = "git://github.com/libbpf/libbpf.git;protocol=https;branch=master"
-SRCREV = "86eb09863c1c0177e99c2c703092042d3cdba910"
+SRCREV = "6597330c45d185381900037f0130712cd326ae59"
 
 PACKAGE_ARCH = "${MACHINE_ARCH}"
 COMPATIBLE_HOST = "(x86_64|i.86|aarch64|riscv64|powerpc64).*-linux"
diff --git a/meta-openembedded/meta-oe/recipes-multimedia/libass/libass_0.17.0.bb b/meta-openembedded/meta-oe/recipes-multimedia/libass/libass_0.17.1.bb
similarity index 92%
rename from meta-openembedded/meta-oe/recipes-multimedia/libass/libass_0.17.0.bb
rename to meta-openembedded/meta-oe/recipes-multimedia/libass/libass_0.17.1.bb
index c052239..800ad1b 100644
--- a/meta-openembedded/meta-oe/recipes-multimedia/libass/libass_0.17.0.bb
+++ b/meta-openembedded/meta-oe/recipes-multimedia/libass/libass_0.17.1.bb
@@ -7,8 +7,8 @@
 
 DEPENDS = "fontconfig freetype fribidi harfbuzz"
 
-SRC_URI = "git://github.com/libass/libass.git;protocol=https;branch=master"
-SRCREV = "bef4b43ef1882b77f789f611d9cd24271ccdd65b"
+SRC_URI = "git://github.com/libass/libass.git;protocol=https;branch=0.17.1-branch"
+SRCREV = "e8ad72accd3a84268275a9385beb701c9284e5b3"
 S = "${WORKDIR}/git"
 
 inherit autotools pkgconfig
diff --git a/meta-openembedded/meta-oe/recipes-multimedia/webm/libvpx_1.12.0.bb b/meta-openembedded/meta-oe/recipes-multimedia/webm/libvpx_1.13.0.bb
similarity index 96%
rename from meta-openembedded/meta-oe/recipes-multimedia/webm/libvpx_1.12.0.bb
rename to meta-openembedded/meta-oe/recipes-multimedia/webm/libvpx_1.13.0.bb
index e9e3e93..79b330c 100644
--- a/meta-openembedded/meta-oe/recipes-multimedia/webm/libvpx_1.12.0.bb
+++ b/meta-openembedded/meta-oe/recipes-multimedia/webm/libvpx_1.13.0.bb
@@ -7,7 +7,7 @@
 
 LIC_FILES_CHKSUM = "file://LICENSE;md5=d5b04755015be901744a78cc30d390d4"
 
-SRCREV = "03265cd42b3783532de72f2ded5436652e6f5ce3"
+SRCREV = "d6eb9696aa72473c1a11d34d928d35a3acc0c9a9"
 SRC_URI += "git://chromium.googlesource.com/webm/libvpx;protocol=https;branch=main \
            file://libvpx-configure-support-blank-prefix.patch \
            "
diff --git a/meta-openembedded/meta-oe/recipes-printing/cups/cups-filters_1.28.17.bb b/meta-openembedded/meta-oe/recipes-printing/cups/cups-filters_1.28.17.bb
index 22de3d5..fd82bb3 100644
--- a/meta-openembedded/meta-oe/recipes-printing/cups/cups-filters_1.28.17.bb
+++ b/meta-openembedded/meta-oe/recipes-printing/cups/cups-filters_1.28.17.bb
@@ -6,7 +6,7 @@
 
 SECTION = "console/utils"
 
-DEPENDS = "cups glib-2.0 glib-2.0-native dbus dbus-glib lcms ghostscript poppler qpdf libpng libexif"
+DEPENDS = "cups glib-2.0 glib-2.0-native dbus dbus-glib lcms poppler qpdf libpng libexif"
 DEPENDS:class-native = "poppler-native glib-2.0-native dbus-native pkgconfig-native gettext-native libpng-native"
 
 SRC_URI = "https://github.com/OpenPrinting/${BPN}/releases/download/${PV}/${BP}.tar.xz \
@@ -15,7 +15,7 @@
 
 inherit autotools-brokensep gettext pkgconfig github-releases
 
-EXTRA_OECONF += " --enable-ghostscript --disable-ldap \
+EXTRA_OECONF += " --disable-ldap \
                        --with-pdftops=hybrid --enable-imagefilters \
                        --enable-ghostscript --with-gs-path=${bindir}/gs \
                        --with-pdftops-path=${bindir}/gs \
@@ -51,6 +51,7 @@
 FILES:${PN}-gst = "\
 	${libexecdir}/cups/filter/gsto* \
 	"
+RDEPENDS:${PN}-gst += "ghostscript"
 
 FILES:${PN}-data = "\
 	${datadir}/cups/data \
@@ -71,6 +72,8 @@
         ${datadir}/cups/ppdc \
         ${datadir}/cups/banners \
 "
+RDEPENDS:${PN} += "bash"
+RDEPENDS:${PN} += "ghostscript"
 
 do_install:append() {
 	# remove braille dir
@@ -79,5 +82,3 @@
 	# remove sysroot path contamination from pkgconfig file
 	sed -i -e 's:${STAGING_DIR_TARGET}::' ${D}/${libdir}/pkgconfig/libcupsfilters.pc
 }
-
-RDEPENDS:${PN} += "bash"
diff --git a/meta-openembedded/meta-oe/recipes-security/audit/audit/0001-Add-substitue-functions-for-strndupa-rawmemchr.patch b/meta-openembedded/meta-oe/recipes-security/audit/audit/0001-Add-substitue-functions-for-strndupa-rawmemchr.patch
deleted file mode 100644
index ed1c0e2..0000000
--- a/meta-openembedded/meta-oe/recipes-security/audit/audit/0001-Add-substitue-functions-for-strndupa-rawmemchr.patch
+++ /dev/null
@@ -1,133 +0,0 @@
-From d5a4b800a696b8b8d2c0f0bad098b1a8ff94333f Mon Sep 17 00:00:00 2001
-From: Steve Grubb <sgrubb@redhat.com>
-Date: Tue, 26 Feb 2019 18:33:33 -0500
-Subject: [PATCH] Add substitue functions for strndupa & rawmemchr
-
-Upstream-Status: Backport
-[https://github.com/linux-audit/audit-userspace/commit/d579a08bb1cde71f939c13ac6b2261052ae9f77e]
----
- auparse/auparse.c   | 12 +++++++++++-
- auparse/interpret.c |  9 ++++++++-
- configure.ac        | 14 +++++++++++++-
- src/ausearch-lol.c  | 12 +++++++++++-
- 4 files changed, 43 insertions(+), 4 deletions(-)
-
-diff --git a/auparse/auparse.c b/auparse/auparse.c
-index 650db02..2e1c737 100644
---- a/auparse/auparse.c
-+++ b/auparse/auparse.c
-@@ -1,5 +1,5 @@
- /* auparse.c --
-- * Copyright 2006-08,2012-17 Red Hat Inc., Durham, North Carolina.
-+ * Copyright 2006-08,2012-19 Red Hat Inc., Durham, North Carolina.
-  * All Rights Reserved.
-  *
-  * This library is free software; you can redistribute it and/or
-@@ -1118,6 +1118,16 @@ static int str2event(char *s, au_event_t *e)
- 	return 0;
- }
- 
-+#ifndef HAVE_STRNDUPA
-+static inline char *strndupa(const char *old, size_t n)
-+{
-+	size_t len = strnlen(old, n);
-+	char *tmp = alloca(len + 1);
-+	tmp[len] = 0;
-+	return memcpy(tmp, old, len);
-+}
-+#endif
-+
- /* Returns 0 on success and 1 on error */
- static int extract_timestamp(const char *b, au_event_t *e)
- {
-diff --git a/auparse/interpret.c b/auparse/interpret.c
-index 51c4a5e..67b7b77 100644
---- a/auparse/interpret.c
-+++ b/auparse/interpret.c
-@@ -853,6 +853,13 @@ err_out:
- 		return print_escaped(id->val);
- }
- 
-+// rawmemchr is faster. Let's use it if we have it.
-+#ifdef HAVE_RAWMEMCHR
-+#define STRCHR rawmemchr
-+#else
-+#define STRCHR strchr
-+#endif
-+
- static const char *print_proctitle(const char *val)
- {
- 	char *out = (char *)print_escaped(val);
-@@ -863,7 +870,7 @@ static const char *print_proctitle(const char *val)
- 		// Proctitle has arguments separated by NUL bytes
- 		// We need to write over the NUL bytes with a space
- 		// so that we can see the arguments
--		while ((ptr  = rawmemchr(ptr, '\0'))) {
-+		while ((ptr  = STRCHR(ptr, '\0'))) {
- 			if (ptr >= end)
- 				break;
- 			*ptr = ' ';
-diff --git a/configure.ac b/configure.ac
-index 6e345f1..6f3007e 100644
---- a/configure.ac
-+++ b/configure.ac
-@@ -1,7 +1,7 @@
- dnl
- define([AC_INIT_NOTICE],
- [### Generated automatically using autoconf version] AC_ACVERSION [
--### Copyright 2005-18 Steve Grubb <sgrubb@redhat.com>
-+### Copyright 2005-19 Steve Grubb <sgrubb@redhat.com>
- ###
- ### Permission is hereby granted, free of charge, to any person obtaining a
- ### copy of this software and associated documentation files (the "Software"),
-@@ -72,6 +72,18 @@ dnl; posix_fallocate is used in audisp-remote
- AC_CHECK_FUNCS([posix_fallocate])
- dnl; signalfd is needed for libev
- AC_CHECK_FUNC([signalfd], [], [ AC_MSG_ERROR([The signalfd system call is necessary for auditd]) ])
-+dnl; check if rawmemchr is available
-+AC_CHECK_FUNCS([rawmemchr])
-+dnl; check if strndupa is available
-+AC_LINK_IFELSE(
-+  [AC_LANG_SOURCE(
-+    [[
-+      #define _GNU_SOURCE
-+      #include <string.h>
-+      int main() { (void) strndupa("test", 10); return 0; }]])],
-+ [AC_DEFINE(HAVE_STRNDUPA, 1, [Let us know if we have it or not])],
-+ []
-+)
- 
- ALLWARNS=""
- ALLDEBUG="-g"
-diff --git a/src/ausearch-lol.c b/src/ausearch-lol.c
-index 5d17a72..758c33e 100644
---- a/src/ausearch-lol.c
-+++ b/src/ausearch-lol.c
-@@ -1,6 +1,6 @@
- /*
- * ausearch-lol.c - linked list of linked lists library
--* Copyright (c) 2008,2010,2014,2016 Red Hat Inc., Durham, North Carolina.
-+* Copyright (c) 2008,2010,2014,2016,2019 Red Hat Inc., Durham, North Carolina.
- * All Rights Reserved. 
- *
- * This software may be freely redistributed and/or modified under the
-@@ -152,6 +152,16 @@ static int compare_event_time(event *e1, event *e2)
- 	return 0;
- }
- 
-+#ifndef HAVE_STRNDUPA
-+static inline char *strndupa(const char *old, size_t n)
-+{
-+	size_t len = strnlen(old, n);
-+	char *tmp = alloca(len + 1);
-+	tmp[len] = 0;
-+	return memcpy(tmp, old, len);
-+}
-+#endif
-+
- /*
-  * This function will look at the line and pick out pieces of it.
-  */
--- 
-2.17.1
-
diff --git a/meta-openembedded/meta-oe/recipes-security/audit/audit/0001-Make-IPX-packet-interpretation-dependent-on-the-ipx-header.patch b/meta-openembedded/meta-oe/recipes-security/audit/audit/0001-Make-IPX-packet-interpretation-dependent-on-the-ipx-header.patch
deleted file mode 100644
index 054f50a..0000000
--- a/meta-openembedded/meta-oe/recipes-security/audit/audit/0001-Make-IPX-packet-interpretation-dependent-on-the-ipx-header.patch
+++ /dev/null
@@ -1,65 +0,0 @@
-From 6b09724c69d91668418ddb3af00da6db6755208c Mon Sep 17 00:00:00 2001
-From: Steve Grubb <sgrubb@redhat.com>
-Date: Thu, 2 Sep 2021 15:01:12 -0400
-Subject: [PATCH] Make IPX packet interpretation dependent on the ipx header
- file existing
-
-Upstream-Status: Backport [https://github.com/linux-audit/audit-userspace/commit/6b09724c69d91668418ddb3af00da6db6755208c.patch]
-Comment: Remove one hunk from changelog file and refresh rest hunks as per codebase of audit_2.8.5
-Signed-off-by: Akash Hadke <akash.hadke@kpit.com>
----
- auparse/interpret.c | 8 ++++++--
- configure.ac        | 6 ++++++
- 2 files changed, 12 insertions(+), 2 deletions(-)
-
-diff --git a/auparse/interpret.c b/auparse/interpret.c
-index 63829aa0e..6c316456d 100644
---- a/auparse/interpret.c	2022-10-14 11:22:20.833880000 +0200
-+++ b/auparse/interpret.c	2022-10-14 11:35:13.196455950 +0200
-@@ -44,8 +44,10 @@
- #include <linux/ax25.h>
- #include <linux/atm.h>
- #include <linux/x25.h>
--#include <linux/if.h>   // FIXME: remove when ipx.h is fixed
--#include <linux/ipx.h>
-+#ifdef HAVE_IPX_HEADERS
-+  #include <linux/if.h>   // FIXME: remove when ipx.h is fixed
-+  #include <linux/ipx.h>
-+#endif
- #include <linux/capability.h>
- #include <sys/personality.h>
- #include <sys/prctl.h>
-@@ -1158,6 +1160,7 @@
- 					      x->sax25_call.ax25_call[6]);
-                         }
-                         break;
-+#ifdef HAVE_IPX_HEADERS
-                 case AF_IPX:
-                         {
-                                 const struct sockaddr_ipx *ip =
-@@ -1167,6 +1170,7 @@
- 					str, ip->sipx_port, ip->sipx_network);
-                         }
-                         break;
-+#endif
-                 case AF_ATMPVC:
-                         {
-                                 const struct sockaddr_atmpvc* at =
-diff --git a/configure.ac b/configure.ac
-index 8f541e4c0..005eb0b5b 100644
---- a/configure.ac	2022-10-14 11:22:20.833880000 +0200
-+++ b/configure.ac	2022-10-14 11:36:32.391044084 +0200
-@@ -414,6 +414,12 @@
- 	AC_DEFINE_UNQUOTED(HAVE_LIBWRAP, [], Define if tcp_wrappers support is enabled )
- fi
- 
-+# linux/ipx.h - deprecated in 2018
-+AC_CHECK_HEADER(linux/ipx.h, ipx_headers=yes, ipx_headers=no)
-+if test $ipx_headers = yes ; then
-+	AC_DEFINE(HAVE_IPX_HEADERS,1,[IPX packet interpretation])
-+fi
-+
- # See if we want to support lower capabilities for plugins
- LIBCAP_NG_PATH
- 
-
diff --git a/meta-openembedded/meta-oe/recipes-security/audit/audit/0002-Fixed-swig-host-contamination-issue.patch b/meta-openembedded/meta-oe/recipes-security/audit/audit/0002-Fixed-swig-host-contamination-issue.patch
deleted file mode 100644
index 39a090c..0000000
--- a/meta-openembedded/meta-oe/recipes-security/audit/audit/0002-Fixed-swig-host-contamination-issue.patch
+++ /dev/null
@@ -1,62 +0,0 @@
-From 3467abce1f3cfc96f9bdace7c09d95218cbcaeb1 Mon Sep 17 00:00:00 2001
-From: Li xin <lixin.fnst@cn.fujitsu.com>
-Date: Sun, 19 Jul 2015 02:42:58 +0900
-Subject: [PATCH] audit: Fixed swig host contamination issue
-
-The audit build uses swig to generate a python wrapper.
-Unfortunately, the swig info file references host include
-directories.  Some of these were previously noticed and
-eliminated, but the one fixed here was not.
-
-Upstream-Status: Inappropriate [embedded specific]
-
-Signed-off-by: Anders Hedlund <anders.hedlund@windriver.com>
-Signed-off-by: Joe Slater <jslater@windriver.com>
-Signed-off-by: Yi Zhao <yi.zhao@windriver.com>
-
-Comment: Refresh hunk from auditswig.i to fix build with linux 5.17+
-Reference-Commit: ee3c680c3 audit: Upgrade to 3.0.8 and fix build with linux 5.17+
-Signed-off-by: Akash Hadke <akash.hadke@kpit.com>
-Signed-off-by: Akash Hadke <hadkeakash4@gmail.com>
----
- bindings/swig/python3/Makefile.am | 3 ++-
- bindings/swig/src/auditswig.i     | 2 +-
- 2 files changed, 3 insertions(+), 2 deletions(-)
-
-diff --git a/bindings/swig/python3/Makefile.am b/bindings/swig/python3/Makefile.am
-index 9938418..fa46aac 100644
---- a/bindings/swig/python3/Makefile.am
-+++ b/bindings/swig/python3/Makefile.am
-@@ -22,6 +22,7 @@
- CONFIG_CLEAN_FILES = *.loT *.rej *.orig
- AM_CFLAGS = -fPIC -DPIC -fno-strict-aliasing $(PYTHON3_CFLAGS)
- AM_CPPFLAGS = -I. -I$(top_builddir) -I${top_srcdir}/lib $(PYTHON3_INCLUDES)
-+STDINC ?= /usr/include
- LIBS = $(top_builddir)/lib/libaudit.la
- SWIG_FLAGS = -python -py3 -modern
- SWIG_INCLUDES = -I. -I$(top_builddir) -I${top_srcdir}/lib $(PYTHON3_INCLUDES)
-@@ -37,7 +38,7 @@ _audit_la_DEPENDENCIES =${top_srcdir}/lib/libaudit.h ${top_builddir}/lib/libaudi
- _audit_la_LIBADD = ${top_builddir}/lib/libaudit.la
- nodist__audit_la_SOURCES  = audit_wrap.c
- audit.py audit_wrap.c: ${srcdir}/../src/auditswig.i 
--	swig -o audit_wrap.c ${SWIG_FLAGS} ${SWIG_INCLUDES} ${srcdir}/../src/auditswig.i 
-+	swig -o audit_wrap.c ${SWIG_FLAGS} ${SWIG_INCLUDES} -I$(STDINC) ${srcdir}/../src/auditswig.i
- 
- CLEANFILES = audit.py* audit_wrap.c *~
- 
-diff --git a/bindings/swig/src/auditswig.i b/bindings/swig/src/auditswig.i
-index 7ebb373..424fb68 100644
---- a/bindings/swig/src/auditswig.i
-+++ b/bindings/swig/src/auditswig.i
-@@ -39,7 +39,7 @@
- #define __attribute(X) /*nothing*/
- typedef unsigned __u32;
- typedef unsigned uid_t;
--%include "/usr/include/linux/audit.h"
-+%include "../lib/audit.h"
- #define __extension__ /*nothing*/
- #include <stdint.h>
- %include "../lib/libaudit.h"
--- 
-2.17.1
-
diff --git a/meta-openembedded/meta-oe/recipes-security/audit/audit/0003-Header-definitions-need-to-be-external-when-building.patch b/meta-openembedded/meta-oe/recipes-security/audit/audit/0003-Header-definitions-need-to-be-external-when-building.patch
deleted file mode 100644
index f209e56..0000000
--- a/meta-openembedded/meta-oe/recipes-security/audit/audit/0003-Header-definitions-need-to-be-external-when-building.patch
+++ /dev/null
@@ -1,30 +0,0 @@
-From 2938f46d318df4a09565db837b60bafd0300f858 Mon Sep 17 00:00:00 2001
-From: Steve Grubb <sgrubb@redhat.com>
-Date: Fri, 10 Jan 2020 21:13:50 -0500
-Subject: [PATCH] Header definitions need to be external when building with
- -fno-common (which is default in GCC 10) - Tony Jones
-
-Upstream-Status: Backport
-[https://github.com/linux-audit/audit-userspace/commit/017e6c6ab95df55f34e339d2139def83e5dada1f]
-
-Signed-off-by: Alex Kiernan <alex.kiernan@gmail.com>
----
- src/ausearch-common.h | 2 +-
- 1 file changed, 1 insertion(+), 1 deletion(-)
-
-diff --git a/src/ausearch-common.h b/src/ausearch-common.h
-index 6669203..3040547 100644
---- a/src/ausearch-common.h
-+++ b/src/ausearch-common.h
-@@ -50,7 +50,7 @@ extern pid_t event_pid;
- extern int event_exact_match;
- extern uid_t event_uid, event_euid, event_loginuid;
- extern const char *event_tuid, *event_teuid, *event_tauid;
--slist *event_node_list;
-+extern slist *event_node_list;
- extern const char *event_comm;
- extern const char *event_filename;
- extern const char *event_hostname;
--- 
-2.17.1
-
diff --git a/meta-openembedded/meta-oe/recipes-security/audit/audit_2.8.5.bb b/meta-openembedded/meta-oe/recipes-security/audit/audit_2.8.5.bb
deleted file mode 100644
index f846b27..0000000
--- a/meta-openembedded/meta-oe/recipes-security/audit/audit_2.8.5.bb
+++ /dev/null
@@ -1,115 +0,0 @@
-SUMMARY = "User space tools for kernel auditing"
-DESCRIPTION = "The audit package contains the user space utilities for \
-storing and searching the audit records generated by the audit subsystem \
-in the Linux kernel."
-HOMEPAGE = "http://people.redhat.com/sgrubb/audit/"
-SECTION = "base"
-LICENSE = "GPL-2.0-or-later & LGPL-2.0-or-later"
-LIC_FILES_CHKSUM = "file://COPYING;md5=94d55d512a9ba36caa9b7df079bae19f"
-
-SRC_URI = "git://github.com/linux-audit/${BPN}-userspace.git;branch=2.8_maintenance;protocol=https \
-           file://0001-Add-substitue-functions-for-strndupa-rawmemchr.patch \
-           file://0002-Fixed-swig-host-contamination-issue.patch \
-           file://0003-Header-definitions-need-to-be-external-when-building.patch \
-           file://auditd \
-           file://auditd.service \
-           file://audit-volatile.conf \
-           file://0001-Make-IPX-packet-interpretation-dependent-on-the-ipx-header.patch \
-"
-
-S = "${WORKDIR}/git"
-SRCREV = "5fae55c1ad15b3cefe6890eba7311af163e9133c"
-
-inherit autotools python3native update-rc.d systemd
-
-UPDATERCPN = "auditd"
-INITSCRIPT_NAME = "auditd"
-INITSCRIPT_PARAMS = "defaults"
-
-SYSTEMD_PACKAGES = "auditd"
-SYSTEMD_SERVICE:auditd = "auditd.service"
-
-DEPENDS = "python3 tcp-wrappers libcap-ng linux-libc-headers swig-native"
-
-EXTRA_OECONF = "--without-prelude \
-        --with-libwrap \
-        --enable-gssapi-krb5=no \
-        --with-libcap-ng=yes \
-        --with-python3=yes \
-        --libdir=${base_libdir} \
-        --sbindir=${base_sbindir} \
-        --without-python \
-        --without-golang \
-        --disable-zos-remote \
-        --with-arm=yes \
-        --with-aarch64=yes \
-        "
-
-EXTRA_OEMAKE = "PYLIBVER='python${PYTHON_BASEVERSION}' \
-	PYINC='${STAGING_INCDIR}/$(PYLIBVER)' \
-	pyexecdir=${libdir}/python${PYTHON_BASEVERSION}/site-packages \
-	STDINC='${STAGING_INCDIR}' \
-	pkgconfigdir=${libdir}/pkgconfig \
-	"
-
-SUMMARY:audispd-plugins = "Plugins for the audit event dispatcher"
-DESCRIPTION:audispd-plugins = "The audispd-plugins package provides plugins for the real-time \
-interface to the audit system, audispd. These plugins can do things \
-like relay events to remote machines or analyze events for suspicious \
-behavior."
-
-PACKAGES =+ "audispd-plugins"
-PACKAGES += "auditd ${PN}-python"
-
-FILES:${PN} = "${sysconfdir}/libaudit.conf ${base_libdir}/libaudit.so.1* ${base_libdir}/libauparse.so.*"
-FILES:auditd = "${bindir}/* ${base_sbindir}/* ${sysconfdir}/*"
-FILES:audispd-plugins = "${sysconfdir}/audisp/audisp-remote.conf \
-	${sysconfdir}/audisp/plugins.d/au-remote.conf \
-	${base_sbindir}/audisp-remote ${localstatedir}/spool/audit \
-	"
-FILES:${PN}-dbg += "${libdir}/python${PYTHON_BASEVERSION}/*/.debug"
-FILES:${PN}-python = "${libdir}/python${PYTHON_BASEVERSION}"
-
-CONFFILES:auditd = "${sysconfdir}/audit/audit.rules"
-RDEPENDS:auditd = "bash"
-
-do_configure:prepend() {
-        sed -e 's|buf\[];|buf[0];|g'  ${STAGING_INCDIR}/linux/audit.h > ${S}/lib/audit.h
-        sed -i -e 's|#include <linux/audit.h>|#include "audit.h"|g' ${S}/lib/libaudit.h
-}
-
-do_install:append() {
-	rm -f ${D}/${libdir}/python${PYTHON_BASEVERSION}/site-packages/*.a
-	rm -f ${D}/${libdir}/python${PYTHON_BASEVERSION}/site-packages/*.la
-
-	# reuse auditd config
-	[ ! -e ${D}/etc/default ] && mkdir ${D}/etc/default
-	mv ${D}/etc/sysconfig/auditd ${D}/etc/default
-	rmdir ${D}/etc/sysconfig/
-
-	# replace init.d
-	install -D -m 0755 ${WORKDIR}/auditd ${D}/etc/init.d/auditd
-	rm -rf ${D}/etc/rc.d
-
-	if ${@bb.utils.contains('DISTRO_FEATURES', 'systemd', 'true', 'false', d)}; then
-		# install systemd unit files
-		install -d ${D}${systemd_unitdir}/system
-		install -m 0644 ${WORKDIR}/auditd.service ${D}${systemd_unitdir}/system
-
-		install -d ${D}${sysconfdir}/tmpfiles.d/
-		install -m 0644 ${WORKDIR}/audit-volatile.conf ${D}${sysconfdir}/tmpfiles.d/
-	fi
-
-	# audit-2.5 doesn't install any rules by default, so we do that here
-	mkdir -p ${D}/etc/audit ${D}/etc/audit/rules.d
-	cp ${S}/rules/10-base-config.rules ${D}/etc/audit/rules.d/audit.rules
-
-	chmod 750 ${D}/etc/audit ${D}/etc/audit/rules.d
-	chmod 640 ${D}/etc/audit/auditd.conf ${D}/etc/audit/rules.d/audit.rules
-
-	# Based on the audit.spec "Copy default rules into place on new installation"
-	cp ${D}/etc/audit/rules.d/audit.rules ${D}/etc/audit/audit.rules
-
-	# Create /var/spool/audit directory for audisp-remote
-	install -m 0700 -d ${D}${localstatedir}/spool/audit
-}
diff --git a/meta-openembedded/meta-oe/recipes-security/audit/audit_3.0.9.bb b/meta-openembedded/meta-oe/recipes-security/audit/audit_3.1.bb
similarity index 92%
rename from meta-openembedded/meta-oe/recipes-security/audit/audit_3.0.9.bb
rename to meta-openembedded/meta-oe/recipes-security/audit/audit_3.1.bb
index 9621d9e..8bd8179 100644
--- a/meta-openembedded/meta-oe/recipes-security/audit/audit_3.0.9.bb
+++ b/meta-openembedded/meta-oe/recipes-security/audit/audit_3.1.bb
@@ -16,9 +16,9 @@
 "
 
 S = "${WORKDIR}/git"
-SRCREV = "81fa28e0e8b4be83ddba03de8b816a3df510c17e"
+SRCREV = "81c813fc4ebb11bf1eca8b8bdb5b253dff31e68e"
 
-inherit autotools python3native python3targetconfig update-rc.d systemd
+inherit autotools python3targetconfig update-rc.d systemd
 
 UPDATERCPN = "auditd"
 INITSCRIPT_NAME = "auditd"
@@ -74,11 +74,11 @@
 
 do_configure:prepend() {
 	sed -e 's|buf\[];|buf[0];|g'  ${STAGING_INCDIR}/linux/audit.h > ${S}/lib/audit.h
-        sed -i -e 's|#include <linux/audit.h>|#include "audit.h"|g' ${S}/lib/libaudit.h
+	sed -i -e 's|#include <linux/audit.h>|#include "audit.h"|g' ${S}/lib/libaudit.h
 }
 
 do_install:append() {
-        sed -i -e 's|#include "audit.h"|#include <linux/audit.h>|g' ${D}${includedir}/libaudit.h
+	sed -i -e 's|#include "audit.h"|#include <linux/audit.h>|g' ${D}${includedir}/libaudit.h
 
 	rm -f ${D}/${libdir}/python${PYTHON_BASEVERSION}/site-packages/*.a
 	rm -f ${D}/${libdir}/python${PYTHON_BASEVERSION}/site-packages/*.la
diff --git a/meta-openembedded/meta-oe/recipes-security/bubblewrap/bubblewrap_0.7.0.bb b/meta-openembedded/meta-oe/recipes-security/bubblewrap/bubblewrap_0.8.0.bb
similarity index 90%
rename from meta-openembedded/meta-oe/recipes-security/bubblewrap/bubblewrap_0.7.0.bb
rename to meta-openembedded/meta-oe/recipes-security/bubblewrap/bubblewrap_0.8.0.bb
index 4d053b5..06c42ad 100644
--- a/meta-openembedded/meta-oe/recipes-security/bubblewrap/bubblewrap_0.7.0.bb
+++ b/meta-openembedded/meta-oe/recipes-security/bubblewrap/bubblewrap_0.8.0.bb
@@ -6,7 +6,7 @@
 DEPENDS = "libcap"
 
 SRC_URI = "https://github.com/containers/${BPN}/releases/download/v${PV}/${BP}.tar.xz"
-SRC_URI[sha256sum] = "764ab7100bd037ea53d440d362e099d7a425966bc62d1f00ab26b8fbb882a9dc"
+SRC_URI[sha256sum] = "957ad1149db9033db88e988b12bcebe349a445e1efc8a9b59ad2939a113d333a"
 
 inherit autotools bash-completion github-releases manpages pkgconfig
 
diff --git a/meta-openembedded/meta-oe/recipes-shells/tcsh/tcsh/0001-Enable-system-malloc-on-all-linux.patch b/meta-openembedded/meta-oe/recipes-shells/tcsh/tcsh/0001-Enable-system-malloc-on-all-linux.patch
index ff2f6a3..f32d6e1 100644
--- a/meta-openembedded/meta-oe/recipes-shells/tcsh/tcsh/0001-Enable-system-malloc-on-all-linux.patch
+++ b/meta-openembedded/meta-oe/recipes-shells/tcsh/tcsh/0001-Enable-system-malloc-on-all-linux.patch
@@ -13,18 +13,18 @@
  1 file changed, 1 insertion(+), 1 deletion(-)
 
 diff --git a/config_f.h b/config_f.h
-index 6a632a5..0a66960 100644
+index fb9e69b..c207c25 100644
 --- a/config_f.h
 +++ b/config_f.h
-@@ -139,7 +139,7 @@
+@@ -147,7 +147,7 @@
   *		This can be much slower and no memory statistics will be
   *		provided.
   */
--#if defined(__MACHTEN__) || defined(PURIFY) || defined(MALLOC_TRACE) || defined(_OSD_POSIX) || defined(__MVS__) || defined (__CYGWIN__) || defined(__GLIBC__) || defined(__OpenBSD__) || defined(__APPLE__) || defined (__ANDROID__)
-+#if defined(__MACHTEN__) || defined(PURIFY) || defined(MALLOC_TRACE) || defined(_OSD_POSIX) || defined(__MVS__) || defined (__CYGWIN__) || defined(__linux__) || defined(__OpenBSD__) || defined(__APPLE__)
+-#if defined(__MACHTEN__) || defined(PURIFY) || defined(MALLOC_TRACE) || defined(_OSD_POSIX) || defined(__MVS__) || defined (__CYGWIN__) || defined(__GLIBC__) || defined(__OpenBSD__) || defined(__APPLE__) || defined (__ANDROID__) || defined(__NetBSD__) || !defined(HAVE_WORKING_SBRK)
++#if defined(__MACHTEN__) || defined(PURIFY) || defined(MALLOC_TRACE) || defined(_OSD_POSIX) || defined(__MVS__) || defined (__CYGWIN__) || defined(__linux__) || defined(__OpenBSD__) || defined(__APPLE__) || defined (__ANDROID__) || defined(__NetBSD__) || !defined(HAVE_WORKING_SBRK)
  # define SYSMALLOC
  #else
  # undef SYSMALLOC
 -- 
-2.12.1
+2.34.1
 
diff --git a/meta-openembedded/meta-oe/recipes-shells/tcsh/tcsh_6.22.04.bb b/meta-openembedded/meta-oe/recipes-shells/tcsh/tcsh_6.24.07.bb
similarity index 91%
rename from meta-openembedded/meta-oe/recipes-shells/tcsh/tcsh_6.22.04.bb
rename to meta-openembedded/meta-oe/recipes-shells/tcsh/tcsh_6.24.07.bb
index 49d7c3f..f136c06 100644
--- a/meta-openembedded/meta-oe/recipes-shells/tcsh/tcsh_6.22.04.bb
+++ b/meta-openembedded/meta-oe/recipes-shells/tcsh/tcsh_6.24.07.bb
@@ -13,8 +13,7 @@
     file://0001-Enable-system-malloc-on-all-linux.patch \
     file://0002-Add-debian-csh-scripts.patch \
 "
-SRC_URI[md5sum] = "fa2b347fa9ae866eb036e6e4bb85fe1a"
-SRC_URI[sha256sum] = "eb16356243218c32f39e07258d72bf8b21e62ce94bb0e8a95e318b151397e231"
+SRC_URI[sha256sum] = "74e4e9805cbd9413ed34b4ffa1d72fc8d0ef81a5b79476854091416ce9336995"
 
 EXTRA_OEMAKE += "CC_FOR_GETHOST='${BUILD_CC}'"
 inherit autotools
diff --git a/meta-openembedded/meta-oe/recipes-support/c-ares/c-ares_1.18.1.bb b/meta-openembedded/meta-oe/recipes-support/c-ares/c-ares_1.19.0.bb
similarity index 91%
rename from meta-openembedded/meta-oe/recipes-support/c-ares/c-ares_1.18.1.bb
rename to meta-openembedded/meta-oe/recipes-support/c-ares/c-ares_1.19.0.bb
index 2cd00cb..bb19ff1 100644
--- a/meta-openembedded/meta-oe/recipes-support/c-ares/c-ares_1.18.1.bb
+++ b/meta-openembedded/meta-oe/recipes-support/c-ares/c-ares_1.19.0.bb
@@ -6,7 +6,7 @@
 LIC_FILES_CHKSUM = "file://LICENSE.md;md5=fb997454c8d62aa6a47f07a8cd48b006"
 
 SRC_URI = "git://github.com/c-ares/c-ares.git;branch=main;protocol=https"
-SRCREV = "2aa086f822aad5017a6f2061ef656f237a62d0ed"
+SRCREV = "fddf01938d3789e06cc1c3774e4cd0c7d2a89976"
 
 UPSTREAM_CHECK_GITTAGREGEX = "cares-(?P<pver>\d+_(\d_?)+)"
 
diff --git a/meta-openembedded/meta-oe/recipes-support/cli11/cli11_2.3.2.bb b/meta-openembedded/meta-oe/recipes-support/cli11/cli11_2.3.2.bb
index 3139733..b9ff914 100644
--- a/meta-openembedded/meta-oe/recipes-support/cli11/cli11_2.3.2.bb
+++ b/meta-openembedded/meta-oe/recipes-support/cli11/cli11_2.3.2.bb
@@ -23,3 +23,5 @@
 
 # cli11 is a header only C++ library, so the main package will be empty.
 RDEPENDS:${PN}-dev = ""
+
+BBCLASSEXTEND = "native nativesdk"
diff --git a/meta-openembedded/meta-oe/recipes-support/consolation/consolation_0.0.8.bb b/meta-openembedded/meta-oe/recipes-support/consolation/consolation_0.0.9.bb
similarity index 86%
rename from meta-openembedded/meta-oe/recipes-support/consolation/consolation_0.0.8.bb
rename to meta-openembedded/meta-oe/recipes-support/consolation/consolation_0.0.9.bb
index 0936b1a..17981b6 100644
--- a/meta-openembedded/meta-oe/recipes-support/consolation/consolation_0.0.8.bb
+++ b/meta-openembedded/meta-oe/recipes-support/consolation/consolation_0.0.9.bb
@@ -6,7 +6,7 @@
 HOMEPAGE = "https://salsa.debian.org/consolation-team/consolation"
 SECTION = "console/utils"
 LICENSE = "GPL-2.0-or-later"
-LIC_FILES_CHKSUM = "file://LICENSE;md5=73ca626e1d9048abfc7d599370650827"
+LIC_FILES_CHKSUM = "file://LICENSE;md5=7df9eea2f4dfdda489c116099e6fc062"
 
 DEPENDS = " \
     libevdev \
@@ -15,7 +15,7 @@
 "
 
 SRC_URI = "git://salsa.debian.org/consolation-team/consolation.git;branch=master"
-SRCREV = "4581eaece6e49fa2b687efbdbe23b2de452e7902"
+SRCREV = "5ef08f0cd6ede62de14de477b74fc3611108c676"
 
 S = "${WORKDIR}/git"
 
diff --git a/meta-openembedded/meta-oe/recipes-support/farsight/libnice_0.1.18.bb b/meta-openembedded/meta-oe/recipes-support/farsight/libnice_0.1.21.bb
similarity index 93%
rename from meta-openembedded/meta-oe/recipes-support/farsight/libnice_0.1.18.bb
rename to meta-openembedded/meta-oe/recipes-support/farsight/libnice_0.1.21.bb
index e7eaf03..210d4d8 100644
--- a/meta-openembedded/meta-oe/recipes-support/farsight/libnice_0.1.18.bb
+++ b/meta-openembedded/meta-oe/recipes-support/farsight/libnice_0.1.21.bb
@@ -9,7 +9,7 @@
 "
 
 SRC_URI = "http://nice.freedesktop.org/releases/libnice-${PV}.tar.gz"
-SRC_URI[sha256sum] = "5eabd25ba2b54e817699832826269241abaa1cf78f9b240d1435f936569273f4"
+SRC_URI[sha256sum] = "72e73a2acf20f59093e21d5601606e405873503eb35f346fa621de23e99b3b39"
 
 DEPENDS = "glib-2.0 gnutls"
 
diff --git a/meta-openembedded/meta-oe/recipes-support/freerdp/freerdp/0001-Fix-incompatible-function-pointer-types.patch b/meta-openembedded/meta-oe/recipes-support/freerdp/freerdp/0001-Fix-incompatible-function-pointer-types.patch
deleted file mode 100644
index ce230db..0000000
--- a/meta-openembedded/meta-oe/recipes-support/freerdp/freerdp/0001-Fix-incompatible-function-pointer-types.patch
+++ /dev/null
@@ -1,32 +0,0 @@
-From 9c785ca0535d9c24e6699ee1243b427c1407acb5 Mon Sep 17 00:00:00 2001
-From: Khem Raj <raj.khem@gmail.com>
-Date: Tue, 17 Jan 2023 19:31:17 -0800
-Subject: [PATCH] Fix incompatible function pointer types
-
-clang 16+ is flagging the function pointer prototype mismatches,
-therefore fix it.
-
-Fixes Issue #8487
-
-Upstream-Status: Submitted [https://github.com/FreeRDP/FreeRDP/pull/8622]
-Signed-off-by: Khem Raj <raj.khem@gmail.com>
----
- client/X11/xf_disp.c | 2 +-
- 1 file changed, 1 insertion(+), 1 deletion(-)
-
-diff --git a/client/X11/xf_disp.c b/client/X11/xf_disp.c
-index 32ddb626c..ef0cb93ff 100644
---- a/client/X11/xf_disp.c
-+++ b/client/X11/xf_disp.c
-@@ -248,7 +248,7 @@ static void xf_disp_OnTimer(void* context, TimerEventArgs* e)
- 	xf_disp_sendResize(xfDisp);
- }
- 
--static void xf_disp_OnWindowStateChange(void* context, const WindowStateChangeEventArgs* e)
-+static void xf_disp_OnWindowStateChange(void* context, WindowStateChangeEventArgs* e)
- {
- 	xfContext* xfc;
- 	xfDispContext* xfDisp;
--- 
-2.39.1
-
diff --git a/meta-openembedded/meta-oe/recipes-support/freerdp/freerdp_2.9.0.bb b/meta-openembedded/meta-oe/recipes-support/freerdp/freerdp_2.10.0.bb
similarity index 94%
rename from meta-openembedded/meta-oe/recipes-support/freerdp/freerdp_2.9.0.bb
rename to meta-openembedded/meta-oe/recipes-support/freerdp/freerdp_2.10.0.bb
index 3b8fee0..a1bf67c 100644
--- a/meta-openembedded/meta-oe/recipes-support/freerdp/freerdp_2.9.0.bb
+++ b/meta-openembedded/meta-oe/recipes-support/freerdp/freerdp_2.10.0.bb
@@ -13,11 +13,10 @@
 PE = "1"
 PKGV = "${GITPKGVTAG}"
 
-SRCREV = "fa8e1b1c765a4466030ac52240f052c0b440a4d1"
+SRCREV = "7471ae383e7b7a613f275e19f7b54958a193c891"
 SRC_URI = "git://github.com/FreeRDP/FreeRDP.git;branch=stable-2.0;protocol=https \
-    file://winpr-makecert-Build-with-install-RPATH.patch \
-    file://0001-Fix-incompatible-function-pointer-types.patch \
-"
+           file://winpr-makecert-Build-with-install-RPATH.patch \
+           "
 
 S = "${WORKDIR}/git"
 
diff --git a/meta-openembedded/meta-oe/recipes-support/glog/glog_0.6.0.bb b/meta-openembedded/meta-oe/recipes-support/glog/glog_0.6.0.bb
index 89b7cfd..5d12ba6 100644
--- a/meta-openembedded/meta-oe/recipes-support/glog/glog_0.6.0.bb
+++ b/meta-openembedded/meta-oe/recipes-support/glog/glog_0.6.0.bb
@@ -20,7 +20,7 @@
 
 PACKAGECONFIG ?= "shared unwind 64bit-atomics"
 PACKAGECONFIG:remove:riscv64 = "unwind"
-PACKAGECONFIG:remove:riscv32 = "unwind"
+PACKAGECONFIG:remove:riscv32 = "unwind 64bit-atomics"
 PACKAGECONFIG:remove:mipsarch = "64bit-atomics"
 
 PACKAGECONFIG:append:libc-musl:riscv64 = " execinfo"
diff --git a/meta-openembedded/meta-oe/recipes-support/gsoap/gsoap/0001-Simplify-check-for-gethostbyname_r.patch b/meta-openembedded/meta-oe/recipes-support/gsoap/gsoap/0001-Simplify-check-for-gethostbyname_r.patch
new file mode 100644
index 0000000..3d12f73
--- /dev/null
+++ b/meta-openembedded/meta-oe/recipes-support/gsoap/gsoap/0001-Simplify-check-for-gethostbyname_r.patch
@@ -0,0 +1,94 @@
+From fa923a50790c907725c822b2fc7d63b2da62b4ad Mon Sep 17 00:00:00 2001
+From: Khem Raj <raj.khem@gmail.com>
+Date: Sun, 12 Mar 2023 13:34:55 -0700
+Subject: [PATCH] Simplify check for gethostbyname_r()
+
+This helps build fix with musl.
+
+Imported from Alpine: https://git.alpinelinux.org/aports/tree/community/gsoap/musl-fixes.patch
+
+Signed-off-by: Khem Raj <raj.khem@gmail.com>
+---
+ gsoap/stdsoap2.c   |  6 ++----
+ gsoap/stdsoap2.cpp | 10 ++--------
+ 2 files changed, 4 insertions(+), 12 deletions(-)
+
+diff --git a/gsoap/stdsoap2.c b/gsoap/stdsoap2.c
+index 654a1e1..fa31d02 100644
+--- a/gsoap/stdsoap2.c
++++ b/gsoap/stdsoap2.c
+@@ -5463,7 +5463,7 @@ tcp_gethostbyname(struct soap *soap, const char *addr, struct hostent *hostent,
+     hostent = NULL;
+     soap->errnum = h_errno;
+   }
+-#elif (!defined(_GNU_SOURCE) || (!(~_GNU_SOURCE+1) && !defined(_POSIX_C_SOURCE) && !defined(_XOPEN_SOURCE)) || _POSIX_C_SOURCE >= 200112L || _XOPEN_SOURCE >= 600 || defined(__ANDROID__) || defined(FREEBSD) || defined(__FreeBSD__)) && !defined(SUN_OS) && defined(HAVE_GETHOSTBYNAME_R)
++#elif defined(HAVE_GETHOSTBYNAME_R)
+   while ((r = gethostbyname_r(addr, hostent, tmpbuf, tmplen, &hostent, &soap->errnum)) < 0)
+   {
+     if (tmpbuf != soap->tmpbuf)
+@@ -5478,8 +5478,6 @@ tcp_gethostbyname(struct soap *soap, const char *addr, struct hostent *hostent,
+     if (!tmpbuf)
+       break;
+   }
+-#elif defined(HAVE_GETHOSTBYNAME_R)
+-  hostent = gethostbyname_r(addr, hostent, tmpbuf, tmplen, &soap->errnum);
+ #elif defined(VXWORKS)
+   /* vxWorks compatible */
+   /* If the DNS resolver library resolvLib has been configured in the vxWorks
+@@ -23112,7 +23110,7 @@ soap_strerror(struct soap *soap)
+   {
+ #ifndef WIN32
+ # ifdef HAVE_STRERROR_R
+-#  if !defined(_GNU_SOURCE) || (!(~_GNU_SOURCE+1) && ((!defined(_POSIX_C_SOURCE) && !defined(_XOPEN_SOURCE)) || (_POSIX_C_SOURCE >= 200112L || _XOPEN_SOURCE >= 600)))
++#  if 1
+     err = strerror_r(err, soap->msgbuf, sizeof(soap->msgbuf)); /* XSI-compliant */
+     if (err != 0)
+       soap_strcpy(soap->msgbuf, sizeof(soap->msgbuf), "unknown error");
+diff --git a/gsoap/stdsoap2.cpp b/gsoap/stdsoap2.cpp
+index 654a1e1..5fd5fd6 100644
+--- a/gsoap/stdsoap2.cpp
++++ b/gsoap/stdsoap2.cpp
+@@ -5430,7 +5430,7 @@ tcp_gethostbyname(struct soap *soap, const char *addr, struct hostent *hostent,
+ {
+ #if (defined(_AIX43) || defined(TRU64) || defined(HP_UX)) && defined(HAVE_GETHOSTBYNAME_R)
+   struct hostent_data ht_data;
+-#elif (!defined(_GNU_SOURCE) || (!(~_GNU_SOURCE+1) && !defined(_POSIX_C_SOURCE) && !defined(_XOPEN_SOURCE)) || _POSIX_C_SOURCE >= 200112L || _XOPEN_SOURCE >= 600 || defined(__ANDROID__) || defined(FREEBSD) || defined(__FreeBSD__)) && defined(HAVE_GETHOSTBYNAME_R)
++#elif defined(HAVE_GETHOSTBYNAME_R)
+   int r;
+   char *tmpbuf = soap->tmpbuf;
+   size_t tmplen = sizeof(soap->tmpbuf);
+@@ -5463,7 +5463,7 @@ tcp_gethostbyname(struct soap *soap, const char *addr, struct hostent *hostent,
+     hostent = NULL;
+     soap->errnum = h_errno;
+   }
+-#elif (!defined(_GNU_SOURCE) || (!(~_GNU_SOURCE+1) && !defined(_POSIX_C_SOURCE) && !defined(_XOPEN_SOURCE)) || _POSIX_C_SOURCE >= 200112L || _XOPEN_SOURCE >= 600 || defined(__ANDROID__) || defined(FREEBSD) || defined(__FreeBSD__)) && !defined(SUN_OS) && defined(HAVE_GETHOSTBYNAME_R)
++#elif defined(HAVE_GETHOSTBYNAME_R)
+   while ((r = gethostbyname_r(addr, hostent, tmpbuf, tmplen, &hostent, &soap->errnum)) < 0)
+   {
+     if (tmpbuf != soap->tmpbuf)
+@@ -5478,8 +5478,6 @@ tcp_gethostbyname(struct soap *soap, const char *addr, struct hostent *hostent,
+     if (!tmpbuf)
+       break;
+   }
+-#elif defined(HAVE_GETHOSTBYNAME_R)
+-  hostent = gethostbyname_r(addr, hostent, tmpbuf, tmplen, &soap->errnum);
+ #elif defined(VXWORKS)
+   /* vxWorks compatible */
+   /* If the DNS resolver library resolvLib has been configured in the vxWorks
+@@ -23112,13 +23110,9 @@ soap_strerror(struct soap *soap)
+   {
+ #ifndef WIN32
+ # ifdef HAVE_STRERROR_R
+-#  if !defined(_GNU_SOURCE) || (!(~_GNU_SOURCE+1) && ((!defined(_POSIX_C_SOURCE) && !defined(_XOPEN_SOURCE)) || (_POSIX_C_SOURCE >= 200112L || _XOPEN_SOURCE >= 600)))
+     err = strerror_r(err, soap->msgbuf, sizeof(soap->msgbuf)); /* XSI-compliant */
+     if (err != 0)
+       soap_strcpy(soap->msgbuf, sizeof(soap->msgbuf), "unknown error");
+-#  else
+-    return strerror_r(err, soap->msgbuf, sizeof(soap->msgbuf)); /* GNU-specific */
+-#  endif
+ # else
+     return strerror(err);
+ # endif
+-- 
+2.39.2
+
diff --git a/meta-openembedded/meta-oe/recipes-support/gsoap/gsoap_2.8.106.bb b/meta-openembedded/meta-oe/recipes-support/gsoap/gsoap_2.8.126.bb
similarity index 78%
rename from meta-openembedded/meta-oe/recipes-support/gsoap/gsoap_2.8.106.bb
rename to meta-openembedded/meta-oe/recipes-support/gsoap/gsoap_2.8.126.bb
index 15c0f6f..6d8b53d 100644
--- a/meta-openembedded/meta-oe/recipes-support/gsoap/gsoap_2.8.106.bb
+++ b/meta-openembedded/meta-oe/recipes-support/gsoap/gsoap_2.8.126.bb
@@ -5,10 +5,9 @@
 LIC_FILES_CHKSUM = "file://LICENSE.txt;md5=4f40a941379143186f9602242c3fb729 \
                     file://GPLv2_license.txt;md5=a33672dbe491b6517750a0389063508b"
 
-SRC_URI = "${SOURCEFORGE_MIRROR}/${BPN}2/${BPN}_${PV}.zip \
-           "
-SRC_URI[md5sum] = "0925d25bc455047b01d4fe9814d30173"
-SRC_URI[sha256sum] = "4e74838baf5437e95ae17aa3efb48bd0621f483bff4424f6255fcf327ff80765"
+SRC_URI = "https://prdownloads.sourceforge.net/${BPN}2/${BPN}_${PV}.zip"
+SRC_URI:append:libc-musl = " file://0001-Simplify-check-for-gethostbyname_r.patch"
+SRC_URI[sha256sum] = "b65190ebf8c2517d6fafbdc2000bc7bc650d921a02f4aa53eb1e3df267592c4a"
 
 inherit autotools
 
@@ -16,6 +15,7 @@
 
 S = "${WORKDIR}/${BPN}-2.8"
 
+EXTRA_OECONF += "--enable-ipv6 --enable-c-locale"
 PARALLEL_MAKE = ""
 
 EXTRA_OEMAKE:class-target = "SOAP=${STAGING_BINDIR_NATIVE}/soapcpp2"
diff --git a/meta-openembedded/meta-oe/recipes-support/hdf5/files/0001-cmake-remove-build-flags.patch b/meta-openembedded/meta-oe/recipes-support/hdf5/files/0001-cmake-remove-build-flags.patch
index 642d7d1..a8050cc 100644
--- a/meta-openembedded/meta-oe/recipes-support/hdf5/files/0001-cmake-remove-build-flags.patch
+++ b/meta-openembedded/meta-oe/recipes-support/hdf5/files/0001-cmake-remove-build-flags.patch
@@ -15,7 +15,7 @@
 
 --- a/config/cmake/libh5cc.in
 +++ b/config/cmake/libh5cc.in
-@@ -45,7 +45,7 @@ for arg in $@ ; do
+@@ -44,7 +44,7 @@ for arg in $@ ; do
        exit $status
        ;;
      *)
@@ -45,8 +45,8 @@
                      H5_CPPFLAGS: @H5_CPPFLAGS@
                      AM_CPPFLAGS: @AM_CPPFLAGS@
                           CFLAGS: @CMAKE_C_FLAGS@
-@@ -52,8 +52,8 @@ Languages:
- @BUILD_FORTRAN_CONDITIONAL_TRUE@         Static Fortran Library: @H5_ENABLE_STATIC_LIB@
+@@ -53,8 +53,8 @@ Languages:
+ @BUILD_FORTRAN_CONDITIONAL_TRUE@               Module Directory: @CMAKE_Fortran_MODULE_DIRECTORY@
  
                              C++: @HDF5_BUILD_CPP_LIB@
 -@BUILD_CXX_CONDITIONAL_TRUE@                   C++ Compiler: @CMAKE_CXX_COMPILER@ @CMAKE_CXX_COMPILER_VERSION@
diff --git a/meta-openembedded/meta-oe/recipes-support/hdf5/files/0002-Remove-suffix-shared-from-shared-library-name.patch b/meta-openembedded/meta-oe/recipes-support/hdf5/files/0002-Remove-suffix-shared-from-shared-library-name.patch
index de05245..f0eb05a 100644
--- a/meta-openembedded/meta-oe/recipes-support/hdf5/files/0002-Remove-suffix-shared-from-shared-library-name.patch
+++ b/meta-openembedded/meta-oe/recipes-support/hdf5/files/0002-Remove-suffix-shared-from-shared-library-name.patch
@@ -12,7 +12,7 @@
 
 --- a/CMakeLists.txt
 +++ b/CMakeLists.txt
-@@ -196,19 +196,19 @@ set (HDF5_HL_F90_C_LIB_TARGET     "${HDF
+@@ -191,19 +191,19 @@ set (HDF5_HL_F90_C_LIB_TARGET     "${HDF
  set (HDF5_JAVA_JNI_LIB_TARGET     "${HDF5_JAVA_JNI_LIB_CORENAME}")
  set (HDF5_JAVA_HDF5_LIB_TARGET    "${HDF5_JAVA_HDF5_LIB_CORENAME}")
  set (HDF5_JAVA_TEST_LIB_TARGET    "${HDF5_JAVA_TEST_LIB_CORENAME}")
diff --git a/meta-openembedded/meta-oe/recipes-support/hdf5/hdf5_1.13.2.bb b/meta-openembedded/meta-oe/recipes-support/hdf5/hdf5_1.14.0.bb
similarity index 91%
rename from meta-openembedded/meta-oe/recipes-support/hdf5/hdf5_1.13.2.bb
rename to meta-openembedded/meta-oe/recipes-support/hdf5/hdf5_1.14.0.bb
index 80611c6..4feec61 100644
--- a/meta-openembedded/meta-oe/recipes-support/hdf5/hdf5_1.13.2.bb
+++ b/meta-openembedded/meta-oe/recipes-support/hdf5/hdf5_1.14.0.bb
@@ -12,11 +12,11 @@
 DEPENDS += "qemu-native"
 
 SRC_URI = " \
-    https://support.hdfgroup.org/ftp/HDF5/releases/hdf5-1.13/hdf5-${PV}/src/${BPN}-${PV}.tar.bz2 \
+    https://support.hdfgroup.org/ftp/HDF5/releases/hdf5-1.14/hdf5-${PV}/src/${BPN}-${PV}.tar.bz2 \
     file://0002-Remove-suffix-shared-from-shared-library-name.patch \
     file://0001-cmake-remove-build-flags.patch \
 "
-SRC_URI[sha256sum] = "9c51b3da426977ec622a43dca8adaf4e81eabf838c1ff80c6225ad1d3ed54b5c"
+SRC_URI[sha256sum] = "e4e79433450edae2865a4c6328188bb45391b29d74f8c538ee699f0b116c2ba0"
 
 FILES:${PN} += "${libdir}/libhdf5.settings ${datadir}/*"
 
diff --git a/meta-openembedded/meta-oe/recipes-support/hwdata/hwdata_0.367.bb b/meta-openembedded/meta-oe/recipes-support/hwdata/hwdata_0.368.bb
similarity index 91%
rename from meta-openembedded/meta-oe/recipes-support/hwdata/hwdata_0.367.bb
rename to meta-openembedded/meta-oe/recipes-support/hwdata/hwdata_0.368.bb
index 9d27833..786cc00 100644
--- a/meta-openembedded/meta-oe/recipes-support/hwdata/hwdata_0.367.bb
+++ b/meta-openembedded/meta-oe/recipes-support/hwdata/hwdata_0.368.bb
@@ -5,7 +5,7 @@
 LICENSE = "GPL-2.0-or-later | XFree86-1.0"
 LIC_FILES_CHKSUM = "file://LICENSE;md5=1556547711e8246992b999edd9445a57"
 
-SRCREV = "15c9d3bc939848e5f8b86cf9496f991de48c861f"
+SRCREV = "0e25d93ac6433791edbb9d28b3f8eae0cf5e46ff"
 SRC_URI = "git://github.com/vcrhonek/${BPN}.git;branch=master;protocol=https"
 
 S = "${WORKDIR}/git"
diff --git a/meta-openembedded/meta-oe/recipes-support/lcms/lcms_2.14.bb b/meta-openembedded/meta-oe/recipes-support/lcms/lcms_2.15.bb
similarity index 79%
rename from meta-openembedded/meta-oe/recipes-support/lcms/lcms_2.14.bb
rename to meta-openembedded/meta-oe/recipes-support/lcms/lcms_2.15.bb
index eb67144..3656e1c 100644
--- a/meta-openembedded/meta-oe/recipes-support/lcms/lcms_2.14.bb
+++ b/meta-openembedded/meta-oe/recipes-support/lcms/lcms_2.15.bb
@@ -4,7 +4,7 @@
 LIC_FILES_CHKSUM = "file://COPYING;md5=ac638b4bc6b67582a11379cfbaeb93dd"
 
 SRC_URI = "${SOURCEFORGE_MIRROR}/lcms/lcms2-${PV}.tar.gz"
-SRC_URI[sha256sum] = "28474ea6f6591c4d4cee972123587001a4e6e353412a41b3e9e82219818d5740"
+SRC_URI[sha256sum] = "b20cbcbd0f503433be2a4e81462106fa61050a35074dc24a4e356792d971ab39"
 
 DEPENDS = "tiff"
 
diff --git a/meta-openembedded/meta-oe/recipes-support/libgpiod/libgpiod-2.0-rc3/run-ptest b/meta-openembedded/meta-oe/recipes-support/libgpiod/libgpiod-2.0/run-ptest
similarity index 100%
rename from meta-openembedded/meta-oe/recipes-support/libgpiod/libgpiod-2.0-rc3/run-ptest
rename to meta-openembedded/meta-oe/recipes-support/libgpiod/libgpiod-2.0/run-ptest
diff --git a/meta-openembedded/meta-oe/recipes-support/libgpiod/libgpiod_2.0-rc3.bb b/meta-openembedded/meta-oe/recipes-support/libgpiod/libgpiod_2.0.bb
similarity index 90%
rename from meta-openembedded/meta-oe/recipes-support/libgpiod/libgpiod_2.0-rc3.bb
rename to meta-openembedded/meta-oe/recipes-support/libgpiod/libgpiod_2.0.bb
index e56459b..becc9ad 100644
--- a/meta-openembedded/meta-oe/recipes-support/libgpiod/libgpiod_2.0-rc3.bb
+++ b/meta-openembedded/meta-oe/recipes-support/libgpiod/libgpiod_2.0.bb
@@ -7,7 +7,7 @@
     file://LICENSES/CC-BY-SA-4.0.txt;md5=fba3b94d88bfb9b81369b869a1e9a20f \
 "
 
-SRC_URI[sha256sum] = "1d1756d465525deb668526571dc6ed7e08f7b8e7745b10fc028208a22fb7adf8"
+SRC_URI[sha256sum] = "f74cbf82038b3cb98ebeb25bce55ee2553be28194002d2a9889b9268cce2dd07"
 
 S = "${WORKDIR}/libgpiod-2.0"
 
diff --git a/meta-openembedded/meta-oe/recipes-support/libiodbc/libiodbc_3.52.15.bb b/meta-openembedded/meta-oe/recipes-support/libiodbc/libiodbc_3.52.15.bb
index ced16d9..ff976ed 100644
--- a/meta-openembedded/meta-oe/recipes-support/libiodbc/libiodbc_3.52.15.bb
+++ b/meta-openembedded/meta-oe/recipes-support/libiodbc/libiodbc_3.52.15.bb
@@ -18,6 +18,7 @@
 inherit autotools
 
 EXTRA_OECONF += " --prefix=/usr/local \
+		--includedir=/usr/include/iodbc \
 		--with-iodbc-inidir=/etc \
 		--enable-odbc3 \
 		--enable-pthreads \
diff --git a/meta-openembedded/meta-oe/recipes-support/librsync/librsync_2.3.2.bb b/meta-openembedded/meta-oe/recipes-support/librsync/librsync_2.3.4.bb
similarity index 89%
rename from meta-openembedded/meta-oe/recipes-support/librsync/librsync_2.3.2.bb
rename to meta-openembedded/meta-oe/recipes-support/librsync/librsync_2.3.4.bb
index ccc6896..cb30f4c 100644
--- a/meta-openembedded/meta-oe/recipes-support/librsync/librsync_2.3.2.bb
+++ b/meta-openembedded/meta-oe/recipes-support/librsync/librsync_2.3.4.bb
@@ -5,7 +5,7 @@
 LIC_FILES_CHKSUM = "file://COPYING;md5=d8045f3b8f929c1cb29a1e3fd737b499"
 
 SRC_URI = "git://github.com/librsync/librsync.git;branch=master;protocol=https"
-SRCREV = "42b636d2a65ab6914ea7cac50886da28192aaf9b"
+SRCREV = "e364852674780e43d578e4239128ff7014190ed3"
 S = "${WORKDIR}/git"
 
 DEPENDS = "popt"
diff --git a/meta-openembedded/meta-oe/recipes-support/libssh/libssh/0001-libgcrypt.c-Fix-prototype-of-des3_encrypt-des3_decry.patch b/meta-openembedded/meta-oe/recipes-support/libssh/libssh/0001-libgcrypt.c-Fix-prototype-of-des3_encrypt-des3_decry.patch
new file mode 100644
index 0000000..19775fa
--- /dev/null
+++ b/meta-openembedded/meta-oe/recipes-support/libssh/libssh/0001-libgcrypt.c-Fix-prototype-of-des3_encrypt-des3_decry.patch
@@ -0,0 +1,46 @@
+From 0cade4573334571055127a2d4fe3641e2397948d Mon Sep 17 00:00:00 2001
+From: Khem Raj <raj.khem@gmail.com>
+Date: Mon, 20 Mar 2023 21:59:19 -0700
+Subject: [PATCH] libgcrypt.c: Fix prototype of des3_encrypt/des3_decrypt
+
+This is to match the prototype for callback functions which are now emitted as
+errors by clang16
+
+Fixes
+
+TOPDIR/build/tmp/work/cortexa15t2hf-neon-yoe-linux-gnueabi/libssh/0.10.4-r0/git/src/libgcrypt.c:903:20: error: incompatible function pointer types initializing 'void (*)(struct ssh_cipher_struct *, void *, void *, size_t)' (aka 'void (*)(struct ssh_cipher_struct *, void *, void *, unsigned int)') with an expression of type 'void (struct ssh_cipher_struct *, void *, void *, unsigned long)' [-Wincompatible-function-pointer-types]
+    .encrypt     = des3_encrypt,
+                   ^~~~~~~~~~~~
+TOPDIR/build/tmp/work/cortexa15t2hf-neon-yoe-linux-gnueabi/libssh/0.10.4-r0/git/src/libgcrypt.c:904:20: error: incompatible function pointer types initializing 'void (*)(struct ssh_cipher_struct *, void *, void *, size_t)' (aka 'void (*)(struct ssh_cipher_struct *, void *, void *, unsigned int)') with an expression of type 'void (struct ssh_cipher_struct *, void *, void *, unsigned long)' [-Wincompatible-function-pointer-types]
+    .decrypt     = des3_decrypt
+                   ^~~~~~~~~~~~
+
+Upstream-Status: Pending
+
+Signed-off-by: Khem Raj <raj.khem@gmail.com>
+---
+ src/libgcrypt.c | 4 ++--
+ 1 file changed, 2 insertions(+), 2 deletions(-)
+
+diff --git a/src/libgcrypt.c b/src/libgcrypt.c
+index da5588ad..e482b654 100644
+--- a/src/libgcrypt.c
++++ b/src/libgcrypt.c
+@@ -469,12 +469,12 @@ static int des3_set_key(struct ssh_cipher_struct *cipher, void *key, void *IV) {
+ }
+ 
+ static void des3_encrypt(struct ssh_cipher_struct *cipher, void *in,
+-    void *out, unsigned long len) {
++    void *out, size_t len) {
+   gcry_cipher_encrypt(cipher->key[0], out, len, in, len);
+ }
+ 
+ static void des3_decrypt(struct ssh_cipher_struct *cipher, void *in,
+-    void *out, unsigned long len) {
++    void *out, size_t len) {
+   gcry_cipher_decrypt(cipher->key[0], out, len, in, len);
+ }
+ 
+-- 
+2.40.0
+
diff --git a/meta-openembedded/meta-oe/recipes-support/libssh/libssh/0001-tests-CMakeLists.txt-do-not-search-ssh-sshd-commands.patch b/meta-openembedded/meta-oe/recipes-support/libssh/libssh/0001-tests-CMakeLists.txt-do-not-search-ssh-sshd-commands.patch
new file mode 100644
index 0000000..0c7f530
--- /dev/null
+++ b/meta-openembedded/meta-oe/recipes-support/libssh/libssh/0001-tests-CMakeLists.txt-do-not-search-ssh-sshd-commands.patch
@@ -0,0 +1,38 @@
+From d2525ba0bc7b11de12c54ea1a3d1eb862537136d Mon Sep 17 00:00:00 2001
+From: Yi Zhao <yi.zhao@windriver.com>
+Date: Wed, 15 Mar 2023 16:51:58 +0800
+Subject: [PATCH] tests/CMakeLists.txt: do not search ssh/sshd commands on host
+
+It will search ssh/sshd commands on host when configure. Since they are
+not required by unittests, we can skip the search.
+
+Upstream-Status: Inappropriate [embedded specific]
+
+Signed-off-by: Yi Zhao <yi.zhao@windriver.com>
+---
+ tests/CMakeLists.txt | 2 ++
+ 1 file changed, 2 insertions(+)
+
+diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
+index 22a36f37..aa32ca2e 100644
+--- a/tests/CMakeLists.txt
++++ b/tests/CMakeLists.txt
+@@ -86,6 +86,7 @@ set(TEST_TARGET_LIBRARIES
+ 
+ add_subdirectory(unittests)
+ 
++if (CLIENT_TESTING OR SERVER_TESTING)
+ # OpenSSH Capabilities are required for all unit tests
+ find_program(SSH_EXECUTABLE NAMES ssh)
+ if (SSH_EXECUTABLE)
+@@ -293,6 +294,7 @@ if (CLIENT_TESTING OR SERVER_TESTING)
+ 
+     message(STATUS "TORTURE_ENVIRONMENT=${TORTURE_ENVIRONMENT}")
+ endif ()
++endif ()
+ 
+ configure_file(tests_config.h.cmake ${CMAKE_CURRENT_BINARY_DIR}/tests_config.h)
+ 
+-- 
+2.25.1
+
diff --git a/meta-openembedded/meta-oe/recipes-support/libssh/libssh/run-ptest b/meta-openembedded/meta-oe/recipes-support/libssh/libssh/run-ptest
new file mode 100644
index 0000000..159994e
--- /dev/null
+++ b/meta-openembedded/meta-oe/recipes-support/libssh/libssh/run-ptest
@@ -0,0 +1,53 @@
+#!/bin/sh
+
+# Valid tests to run
+tests="torture_bind_config \
+       torture_buffer \
+       torture_bytearray \
+       torture_callbacks \
+       torture_channel \
+       torture_config \
+       torture_crypto \
+       torture_hashes \
+       torture_init \
+       torture_isipaddr \
+       torture_keyfiles \
+       torture_knownhosts_parsing \
+       torture_list \
+       torture_misc \
+       torture_moduli \
+       torture_options \
+       torture_packet \
+       torture_packet_filter \
+       torture_pki \
+       torture_pki_ecdsa \
+       torture_pki_ed25519 \
+       torture_pki_rsa \
+       torture_push_pop_dir \
+       torture_rand \
+       torture_session_keys \
+       torture_temp_dir \
+       torture_temp_file \
+       torture_threads_buffer \
+       torture_threads_crypto \
+       torture_threads_init \
+       torture_threads_pki_rsa \
+       torture_tokens \
+	  "
+
+ptestdir=$(dirname "$(readlink -f "$0")")
+cd "$ptestdir"/tests || exit
+
+# Run specified tests
+for f in $tests
+do
+    if test -e ./"$f"; then
+        if ./"$f" > ./"$f".out 2> ./"$f".err; then
+            echo "PASS: $f"
+        else
+            echo "FAIL: $f"
+        fi
+    else
+        echo "SKIP: $f"
+    fi
+done
diff --git a/meta-openembedded/meta-oe/recipes-support/libssh/libssh_0.10.4.bb b/meta-openembedded/meta-oe/recipes-support/libssh/libssh_0.10.4.bb
new file mode 100644
index 0000000..4b2ced5
--- /dev/null
+++ b/meta-openembedded/meta-oe/recipes-support/libssh/libssh_0.10.4.bb
@@ -0,0 +1,45 @@
+SUMMARY = "Multiplatform C library implementing the SSHv2 and SSHv1 protocol"
+HOMEPAGE = "http://www.libssh.org"
+SECTION = "libs"
+LICENSE = "LGPL-2.1-only"
+LIC_FILES_CHKSUM = "file://COPYING;md5=dabb4958b830e5df11d2b0ed8ea255a0"
+
+DEPENDS = "zlib openssl"
+
+SRC_URI = "git://git.libssh.org/projects/libssh.git;protocol=https;branch=stable-0.10 \
+           file://0001-tests-CMakeLists.txt-do-not-search-ssh-sshd-commands.patch \
+           file://0001-libgcrypt.c-Fix-prototype-of-des3_encrypt-des3_decry.patch \
+           file://run-ptest \
+          "
+SRCREV = "e8322817a9e5aaef0698d779ddd467a209a85d85"
+
+S = "${WORKDIR}/git"
+
+inherit cmake ptest
+
+PACKAGECONFIG ??= "gcrypt ${@bb.utils.contains('PTEST_ENABLED', '1', 'tests', '', d)}"
+PACKAGECONFIG[gssapi] = "-DWITH_GSSAPI=1, -DWITH_GSSAPI=0, krb5, "
+PACKAGECONFIG[gcrypt] = "-DWITH_GCRYPT=1, -DWITH_GCRYPT=0, libgcrypt, "
+PACKAGECONFIG[tests] = "-DUNIT_TESTING=1, -DUNIT_TESTING=0, cmocka"
+
+ARM_INSTRUCTION_SET:armv5 = "arm"
+
+EXTRA_OECMAKE = " \
+    -DWITH_PCAP=1 \
+    -DWITH_SFTP=1 \
+    -DWITH_ZLIB=1 \
+    -DWITH_EXAMPLES=0 \
+    "
+
+do_compile:prepend () {
+    if [ ${PTEST_ENABLED} = "1" ]; then
+        sed -i -e 's|${B}|${PTEST_PATH}|g' ${B}/config.h
+    fi
+}
+
+do_install_ptest () {
+    install -d ${D}${PTEST_PATH}/tests
+    cp -f ${B}/tests/unittests/torture_* ${D}${PTEST_PATH}/tests/
+}
+
+BBCLASSEXTEND = "native nativesdk"
diff --git a/meta-openembedded/meta-oe/recipes-support/libssh/libssh_0.8.9.bb b/meta-openembedded/meta-oe/recipes-support/libssh/libssh_0.8.9.bb
deleted file mode 100644
index c7e9c33..0000000
--- a/meta-openembedded/meta-oe/recipes-support/libssh/libssh_0.8.9.bb
+++ /dev/null
@@ -1,37 +0,0 @@
-SUMMARY = "Multiplatform C library implementing the SSHv2 and SSHv1 protocol"
-HOMEPAGE = "http://www.libssh.org"
-SECTION = "libs"
-LICENSE = "LGPL-2.1-only"
-LIC_FILES_CHKSUM = "file://COPYING;md5=dabb4958b830e5df11d2b0ed8ea255a0"
-
-DEPENDS = "zlib openssl"
-
-SRC_URI = "git://git.libssh.org/projects/libssh.git;protocol=https;branch=stable-0.8"
-SRCREV = "04685a74df9ce1db1bc116a83a0da78b4f4fa1f8"
-
-S = "${WORKDIR}/git"
-
-inherit cmake
-
-PACKAGECONFIG ??= "gcrypt"
-PACKAGECONFIG[gssapi] = "-DWITH_GSSAPI=1, -DWITH_GSSAPI=0, krb5, "
-PACKAGECONFIG[gcrypt] = "-DWITH_GCRYPT=1, -DWITH_GCRYPT=0, libgcrypt, "
-
-ARM_INSTRUCTION_SET:armv5 = "arm"
-
-EXTRA_OECMAKE = " \
-    -DWITH_PCAP=1 \
-    -DWITH_SFTP=1 \
-    -DWITH_ZLIB=1 \
-    -DLIB_SUFFIX=${@d.getVar('baselib').replace('lib', '')} \
-    "
-
-do_configure:prepend () {
-    # Disable building of examples
-    sed -i -e '/add_subdirectory(examples)/s/^/#DONOTWANT/' ${S}/CMakeLists.txt \
-        || bbfatal "Failed to disable examples"
-}
-
-TOOLCHAIN = "gcc"
-
-BBCLASSEXTEND = "native nativesdk"
diff --git a/meta-openembedded/meta-oe/recipes-support/libusb/libusb-compat/0002-automake-make-example-programs-installable.patch b/meta-openembedded/meta-oe/recipes-support/libusb/libusb-compat/0002-automake-make-example-programs-installable.patch
new file mode 100644
index 0000000..faf532c
--- /dev/null
+++ b/meta-openembedded/meta-oe/recipes-support/libusb/libusb-compat/0002-automake-make-example-programs-installable.patch
@@ -0,0 +1,24 @@
+From 9dcdfa716e3c3831d9b70472b39dab2fd370f503 Mon Sep 17 00:00:00 2001
+From: Yoann Congal <yoann.congal@smile.fr>
+Date: Sun, 26 Feb 2023 16:04:35 +0100
+Subject: [PATCH] automake: make example programs installable
+
+The example programs are used as tests for ptest, so we need a way to
+install them on the rootfs.
+
+Upstream-Status: Inappropriate [oe-core specific]
+---
+ examples/Makefile.am | 2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+diff --git a/examples/Makefile.am b/examples/Makefile.am
+index 9bd3efc..f4324c2 100644
+--- a/examples/Makefile.am
++++ b/examples/Makefile.am
+@@ -1,5 +1,5 @@
+ AM_CPPFLAGS = -I$(top_srcdir)/libusb
+-noinst_PROGRAMS = lsusb testlibusb
++bin_PROGRAMS = lsusb testlibusb
+ 
+ lsusb_SOURCES = lsusb.c
+ lsusb_LDADD = ../libusb/libusb.la
diff --git a/meta-openembedded/meta-oe/recipes-support/libusb/libusb-compat/run-ptest b/meta-openembedded/meta-oe/recipes-support/libusb/libusb-compat/run-ptest
new file mode 100644
index 0000000..901662d
--- /dev/null
+++ b/meta-openembedded/meta-oe/recipes-support/libusb/libusb-compat/run-ptest
@@ -0,0 +1,14 @@
+#!/bin/sh
+
+rc=0
+for TEST in lsusb testlibusb; do
+	if ! ./$TEST ; then
+		echo "FAIL: $TEST"
+		rc=$((rc + 1))
+	else
+		echo "PASS: $TEST"
+	fi
+done
+
+# return number of failed tests
+exit $rc
diff --git a/meta-openembedded/meta-oe/recipes-support/libusb/libusb-compat_0.1.8.bb b/meta-openembedded/meta-oe/recipes-support/libusb/libusb-compat_0.1.8.bb
index 869e98f..57f1f54 100644
--- a/meta-openembedded/meta-oe/recipes-support/libusb/libusb-compat_0.1.8.bb
+++ b/meta-openembedded/meta-oe/recipes-support/libusb/libusb-compat_0.1.8.bb
@@ -9,6 +9,9 @@
 LIC_FILES_CHKSUM = "file://LICENSE;md5=f2ac5f3ac4835e8f91324a26a590a423"
 DEPENDS = "libusb1"
 
+# libusb-compat dlopen() libusb1 so we need to explicitly RDEPENDS on it
+RDEPENDS:${PN} += "libusb1"
+
 # Few packages are known not to work with libusb-compat (e.g. libmtp-1.0.0),
 # so here libusb-0.1 is removed completely instead of adding virtual/libusb0.
 # Besides, libusb-0.1 uses a per 1ms polling that hurts a lot to power
@@ -21,21 +24,24 @@
 SRC_URI = " \
     git://github.com/libusb/libusb-compat-0.1.git;protocol=https;branch=master \
     file://0001-usb.h-Include-sys-types.h.patch \
+    file://0002-automake-make-example-programs-installable.patch \
+    file://run-ptest \
 "
-SRCREV = "88740f0fe497b473c8ef40093ab7daeebfb40eb6"
+SRCREV = "c497eff1ae8c4cfd4fdff370f04c78fa0584f4f3"
 S = "${WORKDIR}/git"
 
 UPSTREAM_CHECK_URI = "https://github.com/libusb/libusb-compat-0.1/releases"
 
 BINCONFIG = "${bindir}/libusb-config"
 
-inherit autotools pkgconfig binconfig-disabled lib_package
+inherit autotools pkgconfig binconfig-disabled lib_package ptest
 
-EXTRA_OECONF = "--libdir=${base_libdir}"
+# examples are used as ptest so enable them at configuration if needed
+EXTRA_OECONF += "${@bb.utils.contains('PTEST_ENABLED', '1', '--enable-examples-build', '', d)}"
 
-do_install:append() {
-	install -d ${D}${libdir}
-	if [ ! ${D}${libdir} -ef ${D}${base_libdir} ]; then
-		mv ${D}${base_libdir}/pkgconfig ${D}${libdir}
-	fi
+# Move test binaries out of bindir to avoid clashing with a "real" lsusb.
+do_install_ptest() {
+    for bin in lsusb testlibusb; do
+       mv ${D}${bindir}/$bin ${D}${PTEST_PATH}
+    done
 }
diff --git a/meta-openembedded/meta-oe/recipes-support/mcelog/mcelog_189.bb b/meta-openembedded/meta-oe/recipes-support/mcelog/mcelog_191.bb
similarity index 95%
rename from meta-openembedded/meta-oe/recipes-support/mcelog/mcelog_189.bb
rename to meta-openembedded/meta-oe/recipes-support/mcelog/mcelog_191.bb
index 2f8af9a..e713433 100644
--- a/meta-openembedded/meta-oe/recipes-support/mcelog/mcelog_189.bb
+++ b/meta-openembedded/meta-oe/recipes-support/mcelog/mcelog_191.bb
@@ -11,7 +11,7 @@
     file://run-ptest \
 "
 
-SRCREV = "b8dfb1fa34eb627a03adfb315326a29ec51214b3"
+SRCREV = "a3552acad43ac1f47d3acba1c79462bdece4ea17"
 
 LICENSE = "GPL-2.0-only"
 LIC_FILES_CHKSUM = "file://LICENSE;md5=b234ee4d69f5fce4486a80fdaf4a4263"
diff --git a/meta-openembedded/meta-oe/recipes-support/monit/monit_5.32.0.bb b/meta-openembedded/meta-oe/recipes-support/monit/monit_5.33.0.bb
similarity index 94%
rename from meta-openembedded/meta-oe/recipes-support/monit/monit_5.32.0.bb
rename to meta-openembedded/meta-oe/recipes-support/monit/monit_5.33.0.bb
index e4ec9d5..66d4079 100644
--- a/meta-openembedded/meta-oe/recipes-support/monit/monit_5.32.0.bb
+++ b/meta-openembedded/meta-oe/recipes-support/monit/monit_5.33.0.bb
@@ -15,7 +15,7 @@
 	file://monitrc \
 "
 
-SRC_URI[sha256sum] = "1077052d4c4e848ac47d14f9b37754d46419aecbe8c9a07e1f869c914faf3216"
+SRC_URI[sha256sum] = "1ace889c0183473a9d70160df6533bb6e1338dc1354f5928507803e1e2a863b5"
 
 DEPENDS = "zlib bison-native libnsl2 flex-native openssl virtual/crypt"
 
diff --git a/meta-openembedded/meta-oe/recipes-support/opencv/opencv/0001-Add-missing-header-for-LIBAVCODEC_VERSION_INT.patch b/meta-openembedded/meta-oe/recipes-support/opencv/opencv/0001-Add-missing-header-for-LIBAVCODEC_VERSION_INT.patch
deleted file mode 100644
index 59da6ab..0000000
--- a/meta-openembedded/meta-oe/recipes-support/opencv/opencv/0001-Add-missing-header-for-LIBAVCODEC_VERSION_INT.patch
+++ /dev/null
@@ -1,26 +0,0 @@
-From d6bdd0a91eb0ed57688c0af5ba5088cf0afdc0a0 Mon Sep 17 00:00:00 2001
-From: Jochen Sprickerhof <jspricke@debian.org>
-Date: Mon, 8 Aug 2022 21:10:13 +0200
-Subject: [PATCH] Add missing header for LIBAVCODEC_VERSION_INT
-
-Upstream-Status: Backport [https://github.com/opencv/opencv/pull/22357]
-Signed-off-by: Khem Raj <raj.khem@gmail.com>
----
- modules/videoio/src/ffmpeg_codecs.hpp | 1 +
- 1 file changed, 1 insertion(+)
-
-diff --git a/modules/videoio/src/ffmpeg_codecs.hpp b/modules/videoio/src/ffmpeg_codecs.hpp
-index 61788e0345..faad2596ed 100644
---- a/modules/videoio/src/ffmpeg_codecs.hpp
-+++ b/modules/videoio/src/ffmpeg_codecs.hpp
-@@ -60,6 +60,7 @@ extern "C" {
- #include <errno.h>
- #endif
- 
-+#include <libavcodec/version.h>
- #include <libavformat/avformat.h>
- 
- #ifdef __cplusplus
--- 
-2.38.1
-
diff --git a/meta-openembedded/meta-oe/recipes-support/opencv/opencv_4.6.0.bb b/meta-openembedded/meta-oe/recipes-support/opencv/opencv_4.7.0.bb
similarity index 97%
rename from meta-openembedded/meta-oe/recipes-support/opencv/opencv_4.6.0.bb
rename to meta-openembedded/meta-oe/recipes-support/opencv/opencv_4.7.0.bb
index 1e4c354..361b004 100644
--- a/meta-openembedded/meta-oe/recipes-support/opencv/opencv_4.6.0.bb
+++ b/meta-openembedded/meta-oe/recipes-support/opencv/opencv_4.7.0.bb
@@ -10,8 +10,8 @@
 
 DEPENDS = "libtool swig-native bzip2 zlib glib-2.0 libwebp"
 
-SRCREV_opencv = "b0dc474160e389b9c9045da5db49d03ae17c6a6b"
-SRCREV_contrib = "7b77c355a8fdc97667b3fa1e7a0d37e4973fc868"
+SRCREV_opencv = "725e440d278aca07d35a5e8963ef990572b07316"
+SRCREV_contrib = "e247b680a6bd396f110274b6c214406a93171350"
 SRCREV_boostdesc = "34e4206aef44d50e6bbcd0ab06354b52e7466d26"
 SRCREV_vgg = "fccf7cd6a4b12079f73bbfb21745f9babcd4eb1d"
 SRCREV_face = "8afa57abc8229d611c4937165d20e2a2d9fc5a12"
@@ -30,7 +30,6 @@
            file://0001-Dont-use-isystem.patch \
            file://download.patch \
            file://0001-Make-ts-module-external.patch \
-           file://0001-Add-missing-header-for-LIBAVCODEC_VERSION_INT.patch \
            file://0008-Do-not-embed-build-directory-in-binaries.patch \
            "
 SRC_URI:append:riscv64 = " file://0001-Use-Os-to-compile-tinyxml2.cpp.patch;patchdir=contrib"
@@ -111,6 +110,7 @@
 PACKAGECONFIG[libav] = "-DWITH_FFMPEG=ON,-DWITH_FFMPEG=OFF,libav,"
 PACKAGECONFIG[libv4l] = "-DWITH_LIBV4L=ON,-DWITH_LIBV4L=OFF,v4l-utils,"
 PACKAGECONFIG[opencl] = "-DWITH_OPENCL=ON,-DWITH_OPENCL=OFF,opencl-headers virtual/opencl-icd,"
+PACKAGECONFIG[openvino] = "-DWITH_OPENVINO=ON,-DWITH_OPENVINO=OFF,openvino-inference-engine,openvino-inference-engine"
 PACKAGECONFIG[oracle-java] = "-DJAVA_INCLUDE_PATH=${ORACLE_JAVA_HOME}/include -DJAVA_INCLUDE_PATH2=${ORACLE_JAVA_HOME}/include/linux -DJAVA_AWT_INCLUDE_PATH=${ORACLE_JAVA_HOME}/include -DJAVA_AWT_LIBRARY=${ORACLE_JAVA_HOME}/lib/amd64/libjawt.so -DJAVA_JVM_LIBRARY=${ORACLE_JAVA_HOME}/lib/amd64/server/libjvm.so,,ant-native oracle-jse-jdk oracle-jse-jdk-native,"
 PACKAGECONFIG[png] = "-DWITH_PNG=ON,-DWITH_PNG=OFF,libpng,"
 PACKAGECONFIG[python2] = "-DPYTHON2_NUMPY_INCLUDE_DIRS:PATH=${STAGING_LIBDIR}/${PYTHON_DIR}/site-packages/numpy/core/include,,python-numpy,"
diff --git a/meta-openembedded/meta-oe/recipes-support/poppler/poppler_23.02.0.bb b/meta-openembedded/meta-oe/recipes-support/poppler/poppler_23.03.0.bb
similarity index 96%
rename from meta-openembedded/meta-oe/recipes-support/poppler/poppler_23.02.0.bb
rename to meta-openembedded/meta-oe/recipes-support/poppler/poppler_23.03.0.bb
index 3752c90..165e155 100644
--- a/meta-openembedded/meta-oe/recipes-support/poppler/poppler_23.02.0.bb
+++ b/meta-openembedded/meta-oe/recipes-support/poppler/poppler_23.03.0.bb
@@ -8,7 +8,7 @@
            file://basename-include.patch \
            file://0001-cmake-Do-not-use-isystem.patch \
            "
-SRC_URI[sha256sum] = "3315dda270fe2b35cf1f41d275948c39652fa863b90de0766f6b293d9a558fc9"
+SRC_URI[sha256sum] = "b04148bf849c1965ada7eff6be4685130e3a18a84e0cce73bf9bc472ec32f2b4"
 
 DEPENDS = "fontconfig zlib cairo lcms glib-2.0"
 
diff --git a/meta-openembedded/meta-oe/recipes-support/raptor2/files/0001-Match-reutrn-type-from-RAPTOR_ASSERT_OBJECT_POINTER_.patch b/meta-openembedded/meta-oe/recipes-support/raptor2/files/0001-Match-reutrn-type-from-RAPTOR_ASSERT_OBJECT_POINTER_.patch
deleted file mode 100644
index 4c1afb4..0000000
--- a/meta-openembedded/meta-oe/recipes-support/raptor2/files/0001-Match-reutrn-type-from-RAPTOR_ASSERT_OBJECT_POINTER_.patch
+++ /dev/null
@@ -1,47 +0,0 @@
-From 97b5dcaa6b221eb403cc92e953225d38aee18f70 Mon Sep 17 00:00:00 2001
-From: Khem Raj <raj.khem@gmail.com>
-Date: Thu, 1 Sep 2022 14:48:39 -0700
-Subject: [PATCH] Match reutrn type from
- RAPTOR_ASSERT_OBJECT_POINTER_RETURN_VALUE
-
-This ensures that integer type 0 is returned and not NULL
-Fixes
-raptor_serialize.c:243:66: error: incompatible pointer to integer conversion returning 'void *' from a function with result type 'int' [-Wint-conversion]
-  RAPTOR_ASSERT_OBJECT_POINTER_RETURN_VALUE(world, raptor_world, NULL);
-                                                                 ^~~~
-Upstream-Status: Pending
-Signed-off-by: Khem Raj <raj.khem@gmail.com>
----
- src/raptor_parse.c     | 2 +-
- src/raptor_serialize.c | 2 +-
- 2 files changed, 2 insertions(+), 2 deletions(-)
-
-diff --git a/src/raptor_parse.c b/src/raptor_parse.c
-index 26911f4..0091e1e 100644
---- a/src/raptor_parse.c
-+++ b/src/raptor_parse.c
-@@ -257,7 +257,7 @@ raptor_world_get_parser_factory(raptor_world *world, const char *name)
- int
- raptor_world_get_parsers_count(raptor_world* world)
- {
--  RAPTOR_ASSERT_OBJECT_POINTER_RETURN_VALUE(world, raptor_world, NULL);
-+  RAPTOR_ASSERT_OBJECT_POINTER_RETURN_VALUE(world, raptor_world, 0);
- 
-   raptor_world_open(world);
- 
-diff --git a/src/raptor_serialize.c b/src/raptor_serialize.c
-index a1f29d7..2bf4ab2 100644
---- a/src/raptor_serialize.c
-+++ b/src/raptor_serialize.c
-@@ -240,7 +240,7 @@ raptor_get_serializer_factory(raptor_world* world, const char *name)
- int
- raptor_world_get_serializers_count(raptor_world* world)
- {
--  RAPTOR_ASSERT_OBJECT_POINTER_RETURN_VALUE(world, raptor_world, NULL);
-+  RAPTOR_ASSERT_OBJECT_POINTER_RETURN_VALUE(world, raptor_world, 0);
- 
-   raptor_world_open(world);
- 
--- 
-2.37.3
-
diff --git a/meta-openembedded/meta-oe/recipes-support/raptor2/files/0001-configure.ac-do-additional-checks-on-libxml2-also-wh.patch b/meta-openembedded/meta-oe/recipes-support/raptor2/files/0001-configure.ac-do-additional-checks-on-libxml2-also-wh.patch
deleted file mode 100644
index 490b61f..0000000
--- a/meta-openembedded/meta-oe/recipes-support/raptor2/files/0001-configure.ac-do-additional-checks-on-libxml2-also-wh.patch
+++ /dev/null
@@ -1,32 +0,0 @@
-From 3f97aac5a1f43ef57b02fb9ccdcadd41a6b69fa9 Mon Sep 17 00:00:00 2001
-From: =?UTF-8?q?Andreas=20M=C3=BCller?= <schnitzeltony@googlemail.com>
-Date: Tue, 27 Oct 2015 10:21:24 +0100
-Subject: [PATCH] configure.ac: do additional checks on libxml2 also when
- detected by pkg-config
-MIME-Version: 1.0
-Content-Type: text/plain; charset=UTF-8
-Content-Transfer-Encoding: 8bit
-
-Upstream-Status: Backport [https://github.com/dajobe/raptor/commit/e75b1dbb7f2a6514b8d391b200c45a2bec6268bf]
-
-Signed-off-by: Andreas Müller <schnitzeltony@googlemail.com>
----
- configure.ac | 2 +-
- 1 file changed, 1 insertion(+), 1 deletion(-)
-
-diff --git a/configure.ac b/configure.ac
-index 10ff870..35fa08e 100644
---- a/configure.ac
-+++ b/configure.ac
-@@ -601,7 +601,7 @@ have_libxml=0
- need_libxml=0
- 
- oCPPFLAGS="$CPPFLAGS"
--if test "X$XML_CONFIG" != X; then
-+if test "X$libxml_source" != X; then
-   CPPFLAGS="$LIBXML_CFLAGS $CPPFLAGS"
-   LIBS="$LIBS $LIBXML_LIBS"
-   AC_CHECK_FUNC(xmlCreatePushParserCtxt, have_xmlCreatePushParserCtxt=yes, have_xmlCreatePushParserCtxt=no)
--- 
-2.1.0
-
diff --git a/meta-openembedded/meta-oe/recipes-support/raptor2/raptor2_2.0.15.bb b/meta-openembedded/meta-oe/recipes-support/raptor2/raptor2_2.0.16.bb
similarity index 61%
rename from meta-openembedded/meta-oe/recipes-support/raptor2/raptor2_2.0.15.bb
rename to meta-openembedded/meta-oe/recipes-support/raptor2/raptor2_2.0.16.bb
index 22306a5..1699112 100644
--- a/meta-openembedded/meta-oe/recipes-support/raptor2/raptor2_2.0.15.bb
+++ b/meta-openembedded/meta-oe/recipes-support/raptor2/raptor2_2.0.16.bb
@@ -1,7 +1,7 @@
 SUMMARY = "Library for parsing and serializing RDF syntaxes"
 LICENSE = "GPL-2.0-only | LGPL-2.1-only | Apache-2.0"
 LIC_FILES_CHKSUM = " \
-    file://LICENSE.txt;md5=b840e5ae3aeb897f45b473341348cd9c \
+    file://LICENSE.txt;md5=f7fed8b6ab9289b77f5c14f3f79572cc \
     file://COPYING;md5=751419260aa954499f7abaabaa882bbe \
     file://COPYING.LIB;md5=2d5025d4aa3495befef8f17206a5b0a1 \
     file://LICENSE-2.0.txt;md5=3b83ef96387f14655fc854ddc3c6bd57 \
@@ -11,11 +11,8 @@
 
 SRC_URI = " \
     http://download.librdf.org/source/${BPN}-${PV}.tar.gz \
-    file://0001-configure.ac-do-additional-checks-on-libxml2-also-wh.patch \
-    file://0001-Match-reutrn-type-from-RAPTOR_ASSERT_OBJECT_POINTER_.patch \
 "
-SRC_URI[md5sum] = "a39f6c07ddb20d7dd2ff1f95fa21e2cd"
-SRC_URI[sha256sum] = "ada7f0ba54787b33485d090d3d2680533520cd4426d2f7fb4782dd4a6a1480ed"
+SRC_URI[sha256sum] = "089db78d7ac982354bdbf39d973baf09581e6904ac4c92a98c5caadb3de44680"
 
 inherit autotools pkgconfig
 
diff --git a/meta-openembedded/meta-oe/recipes-support/re2/re2_2020.11.01.bb b/meta-openembedded/meta-oe/recipes-support/re2/re2_2023.03.01.bb
similarity index 80%
rename from meta-openembedded/meta-oe/recipes-support/re2/re2_2020.11.01.bb
rename to meta-openembedded/meta-oe/recipes-support/re2/re2_2023.03.01.bb
index 5ec1c6b..78bf695 100644
--- a/meta-openembedded/meta-oe/recipes-support/re2/re2_2020.11.01.bb
+++ b/meta-openembedded/meta-oe/recipes-support/re2/re2_2023.03.01.bb
@@ -3,7 +3,8 @@
 LICENSE = "BSD-3-Clause"
 LIC_FILES_CHKSUM = "file://LICENSE;md5=3b5c31eb512bdf3cb11ffd5713963760"
 
-SRCREV = "166dbbeb3b0ab7e733b278e8f42a84f6882b8a25"
+# tag 2023-03-01
+SRCREV = "241e2e430836e80f93d704d1f06cd3e7fe3100f5"
 
 SRC_URI = "git://github.com/google/re2.git;branch=main;protocol=https"
 
@@ -16,8 +17,11 @@
 	-DRE2_BUILD_TESTING=OFF \
 "
 
-# Don't include so files in dev package
+# ignore .so in /usr/lib64
 FILES:${PN} = "${libdir}"
+INSANE_SKIP:${PN} += "dev-so"
+
+# Don't include so files in dev package
 FILES:${PN}-dev = "${includedir} ${libdir}/cmake"
 
 BBCLASSEXTEND = "native nativesdk"
diff --git a/meta-openembedded/meta-oe/recipes-support/reboot-mode/reboot-mode_git.bb b/meta-openembedded/meta-oe/recipes-support/reboot-mode/reboot-mode_git.bb
new file mode 100644
index 0000000..20e77c6
--- /dev/null
+++ b/meta-openembedded/meta-oe/recipes-support/reboot-mode/reboot-mode_git.bb
@@ -0,0 +1,18 @@
+SUMMARY = "Reboot the device to a specific mode."
+AUTHOR = "Daniele Debernardi <drebrez@gmail.com>"
+
+LICENSE = "GPL-3.0-or-later"
+LIC_FILES_CHKSUM = "file://LICENSE;md5=84dcc94da3adb52b53ae4fa38fe49e5d"
+
+SRC_URI = "git://gitlab.com/postmarketOS/reboot-mode.git;protocol=http;branch=master"
+SRCREV = "84831b20512abd9033414ca5f5a023f333525335"
+
+S = "${WORKDIR}/git"
+
+do_compile() {
+    ${CC} ${CFLAGS} ${LDFLAGS} reboot-mode.c -o reboot-mode
+}
+
+do_install() {
+    install -D -m 0755 ${S}/reboot-mode ${D}${bindir}/reboot-mode
+}
diff --git a/meta-openembedded/meta-oe/recipes-support/satyr/satyr_0.40.bb b/meta-openembedded/meta-oe/recipes-support/satyr/satyr_0.42.bb
similarity index 94%
rename from meta-openembedded/meta-oe/recipes-support/satyr/satyr_0.40.bb
rename to meta-openembedded/meta-oe/recipes-support/satyr/satyr_0.42.bb
index 1ce28f1..62cdad6 100644
--- a/meta-openembedded/meta-oe/recipes-support/satyr/satyr_0.40.bb
+++ b/meta-openembedded/meta-oe/recipes-support/satyr/satyr_0.42.bb
@@ -10,7 +10,7 @@
 SRC_URI = "git://github.com/abrt/satyr.git;branch=master;protocol=https \
            file://0002-fix-compile-failure-against-musl-C-library.patch \
            "
-SRCREV = "61addf12d15ef9d0bff5e3cc26e08d08a4f88094"
+SRCREV = "23483cebb238df86cda8b6529e3c58080dc2029d"
 S = "${WORKDIR}/git"
 
 LIC_FILES_CHKSUM = "file://COPYING;md5=751419260aa954499f7abaabaa882bbe"
diff --git a/meta-openembedded/meta-oe/recipes-support/sg3-utils/sg3-utils/0001-sg_dd.c-Use-off_t-instead-of-uint.patch b/meta-openembedded/meta-oe/recipes-support/sg3-utils/sg3-utils/0001-sg_dd.c-Use-off_t-instead-of-uint.patch
new file mode 100644
index 0000000..317876f
--- /dev/null
+++ b/meta-openembedded/meta-oe/recipes-support/sg3-utils/sg3-utils/0001-sg_dd.c-Use-off_t-instead-of-uint.patch
@@ -0,0 +1,36 @@
+From 9a8ede03ef61cdf527ce3a80771150a7452e4603 Mon Sep 17 00:00:00 2001
+From: Khem Raj <raj.khem@gmail.com>
+Date: Sat, 11 Mar 2023 22:56:17 -0800
+Subject: [PATCH] sg_dd.c: Use off_t instead of uint
+
+uint is not available on every platform e.g. linux/musl systems. Use
+uint32_t instead to represent 'off' variable, Fixes
+
+sg_dd.c:2402:17: error: use of undeclared identifier 'uint'; did you mean 'int'?
+                uint off;
+                ^~~~
+                int
+1 error generated.
+
+Upstream-Status: Pending
+Signed-off-by: Khem Raj <raj.khem@gmail.com>
+---
+ src/sg_dd.c | 2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+diff --git a/src/sg_dd.c b/src/sg_dd.c
+index 9d05c93..35e2423 100644
+--- a/src/sg_dd.c
++++ b/src/sg_dd.c
+@@ -2399,7 +2399,7 @@ main(int argc, char * argv[])
+             res = blocks * blk_sz;
+             if (iflag.zero && iflag.ff && (blk_sz >= 4)) {
+                 uint32_t pos = (uint32_t)skip;
+-                uint off;
++                uint32_t off;
+ 
+                 for (k = 0, off = 0; k < blocks; ++k, off += blk_sz, ++pos) {
+                     for (j = 0; j < (blk_sz - 3); j += 4)
+-- 
+2.39.2
+
diff --git a/meta-openembedded/meta-oe/recipes-support/sg3-utils/sg3-utils_1.45.bb b/meta-openembedded/meta-oe/recipes-support/sg3-utils/sg3-utils_1.47.bb
similarity index 71%
rename from meta-openembedded/meta-oe/recipes-support/sg3-utils/sg3-utils_1.45.bb
rename to meta-openembedded/meta-oe/recipes-support/sg3-utils/sg3-utils_1.47.bb
index ac12f95..1aa65e6 100644
--- a/meta-openembedded/meta-oe/recipes-support/sg3-utils/sg3-utils_1.45.bb
+++ b/meta-openembedded/meta-oe/recipes-support/sg3-utils/sg3-utils_1.47.bb
@@ -6,16 +6,15 @@
 SECTION = "console/admin"
 
 LICENSE = "GPL-2.0-or-later & BSD-2-Clause"
-LIC_FILES_CHKSUM = "file://COPYING;md5=f90da7fc52172599dbf082d7620f18ca"
+LIC_FILES_CHKSUM = "file://COPYING;md5=f685699d3ac82f108aa880043fa3feb7"
 
 SRC_URI = "http://sg.danny.cz/sg/p/sg3_utils-${PV}.tgz \
-"
+           file://0001-sg_dd.c-Use-off_t-instead-of-uint.patch"
 MIRRORS += "http://sg.danny.cz/sg/p https://fossies.org/linux/misc"
 
 UPSTREAM_CHECK_REGEX = "sg3_utils-(?P<pver>\d+(\.\d+)+)\.tgz"
 
-SRC_URI[md5sum] = "2e71d7cd925dcc48acb24afaaaac7990"
-SRC_URI[sha256sum] = "0b87c971af52af7cebebcce343eac6bd3d73febb3c72af9ce41a4552f1605a61"
+SRC_URI[sha256sum] = "8673c7faca849b6b34764332d2aa91f72db05bff7382bb836d0688795199c3e1"
 
 inherit autotools-brokensep
 
diff --git a/meta-openembedded/meta-oe/recipes-support/syslog-ng/files/0001-Fix-buildpaths-warning.patch b/meta-openembedded/meta-oe/recipes-support/syslog-ng/files/0001-Fix-buildpaths-warning.patch
new file mode 100644
index 0000000..c7bb4a6
--- /dev/null
+++ b/meta-openembedded/meta-oe/recipes-support/syslog-ng/files/0001-Fix-buildpaths-warning.patch
@@ -0,0 +1,55 @@
+From d85a7a3ae2bb9f5267b2af43784633ae8f011f21 Mon Sep 17 00:00:00 2001
+From: Changqing Li <changqing.li@windriver.com>
+Date: Mon, 13 Mar 2023 09:50:15 +0800
+Subject: [PATCH] Fix buildpaths warning
+
+Fix buildpath warning:
+WARNING: syslog-ng-4.0.1-r0 do_package_qa: QA Issue: File /usr/include/syslog-ng/syslog-ng-config-64.h in package syslog-ng-dev contains reference to TMPDIR [buildpaths]
+WARNING: syslog-ng-4.0.1-r0 do_package_qa: QA Issue: File /usr/bin/syslog-ng-update-virtualenv in package syslog-ng contains reference to TMPDIR
+File /usr/bin/pdbtool in package syslog-ng contains reference to TMPDIR [buildpaths]
+WARNING: syslog-ng-4.0.1-r0 do_package_qa: QA Issue: File /usr/lib/syslog-ng/libdbparser.so in package syslog-ng-libs contains reference to TMPDIR [buildpaths]
+
+* SYSLOG_NG_PATH_TOPSRC_DIR is /yocto/build/tmp/work/core2-64-poky-linux/syslog-ng/4.0.1-r0,
+  which is used to get xsd dir in build SYSLOG_NG_PATH_TOPSRC_DIR/doc/xsd, 
+  which is not suitable for target, set it to "/source" for fixing this buildpath warning
+
+* SYSTEM_PYTHON is /yocto/build/tmp/hosttools/python3, set to python3
+  for target.
+
+Upstream-Status: Inappropriate [oe specific]
+
+Signed-off-by: Changqing Li <changqing.li@windriver.com>
+---
+ configure.ac                           | 2 +-
+ scripts/syslog-ng-update-virtualenv.in | 2 +-
+ 2 files changed, 2 insertions(+), 2 deletions(-)
+
+diff --git a/configure.ac b/configure.ac
+index 79a1502..1ad6508 100644
+--- a/configure.ac
++++ b/configure.ac
+@@ -1930,7 +1930,7 @@ AC_DEFINE_UNQUOTED(PYTHON_SYSCONF_MODULE_DIR, "$python_sysconf_moduledir", [Pyth
+ AC_DEFINE_UNQUOTED(PATH_LOGGENPLUGINDIR, "$loggenplugindir", [loggenplugin installation directory])
+ AC_DEFINE_UNQUOTED(MODULE_PATH, "$module_path", [module search path])
+ AC_DEFINE_UNQUOTED(JAVA_MODULE_PATH, "$java_module_path", [java module search path])
+-AC_DEFINE_UNQUOTED(PATH_TOPSRC_DIR, "$abs_topsrcdir", [self-defined top_srcdir path])
++AC_DEFINE_UNQUOTED(PATH_TOPSRC_DIR, "/source", [self-defined top_srcdir path])
+ AC_DEFINE_UNQUOTED(PACKAGE_NAME, "$PACKAGE_NAME", [package name])
+ 
+ 
+diff --git a/scripts/syslog-ng-update-virtualenv.in b/scripts/syslog-ng-update-virtualenv.in
+index ed85baf..b1a9e34 100755
+--- a/scripts/syslog-ng-update-virtualenv.in
++++ b/scripts/syslog-ng-update-virtualenv.in
+@@ -62,7 +62,7 @@ done
+ set -e
+ 
+ REQUIREMENTS_FILE=${python_moduledir}/requirements.txt
+-SYSTEM_PYTHON=@PYTHON@
++SYSTEM_PYTHON=python3
+ VENV_PYTHON=${python_venvdir}/bin/python
+ 
+ if [ "$display_prompt" -ne 0 ]; then
+-- 
+2.25.1
+
diff --git a/meta-openembedded/meta-oe/recipes-support/syslog-ng/syslog-ng_3.38.1.bb b/meta-openembedded/meta-oe/recipes-support/syslog-ng/syslog-ng_4.0.1.bb
similarity index 97%
rename from meta-openembedded/meta-oe/recipes-support/syslog-ng/syslog-ng_3.38.1.bb
rename to meta-openembedded/meta-oe/recipes-support/syslog-ng/syslog-ng_4.0.1.bb
index 182a253..4521593 100644
--- a/meta-openembedded/meta-oe/recipes-support/syslog-ng/syslog-ng_3.38.1.bb
+++ b/meta-openembedded/meta-oe/recipes-support/syslog-ng/syslog-ng_4.0.1.bb
@@ -22,10 +22,11 @@
            file://volatiles.03_syslog-ng \
            file://syslog-ng-tmp.conf \
            file://syslog-ng.service-the-syslog-ng-service.patch \
+           file://0001-Fix-buildpaths-warning.patch \
 "
 SRC_URI:append:powerpc64le = " file://0001-plugin.c-workaround-powerpc64le-segfaults-error.patch"
 
-SRC_URI[sha256sum] = "5491f686d0b829b69b2e0fc0d66a62f51991aafaee005475bfa38fab399441f7"
+SRC_URI[sha256sum] = "c16eafe447191c079f471846182876b7919d3d789af8c1f9fe55ab14521ceb2c"
 
 UPSTREAM_CHECK_URI = "https://github.com/balabit/syslog-ng/releases"
 
diff --git a/meta-openembedded/meta-oe/recipes-support/unixodbc/unixodbc_2.3.11.bb b/meta-openembedded/meta-oe/recipes-support/unixodbc/unixodbc_2.3.11.bb
index c7d23d1..3911258 100644
--- a/meta-openembedded/meta-oe/recipes-support/unixodbc/unixodbc_2.3.11.bb
+++ b/meta-openembedded/meta-oe/recipes-support/unixodbc/unixodbc_2.3.11.bb
@@ -15,7 +15,7 @@
 
 UPSTREAM_CHECK_REGEX = "unixODBC-(?P<pver>\d+(\.\d+)+)\.tar"
 
-inherit autotools-brokensep
+inherit autotools-brokensep multilib_header
 
 S = "${WORKDIR}/unixODBC-${PV}"
 
@@ -26,3 +26,7 @@
     rm -rf m4/*
     rm -fr libltdl
 }
+
+do_install:append() {
+    oe_multilib_header unixodbc.h unixODBC/config.h unixODBC/unixodbc_conf.h
+}
diff --git a/meta-openembedded/meta-oe/recipes-support/xdg-dbus-proxy/xdg-dbus-proxy_0.1.4.bb b/meta-openembedded/meta-oe/recipes-support/xdg-dbus-proxy/xdg-dbus-proxy_0.1.4.bb
new file mode 100644
index 0000000..35dee63
--- /dev/null
+++ b/meta-openembedded/meta-oe/recipes-support/xdg-dbus-proxy/xdg-dbus-proxy_0.1.4.bb
@@ -0,0 +1,19 @@
+SUMMARY = "xdg-dbus-proxy is a filtering proxy for D-Bus connections"
+HOMEPAGE = "https://github.com/flatpak/xdg-dbus-proxy"
+LICENSE = "LGPL-2.1-only"
+LIC_FILES_CHKSUM = "file://COPYING;md5=4fbd65380cdd255951079008b364516c"
+
+DEPENDS = " \
+    glib-2.0 \
+    libxslt-native \
+    docbook-xsl-stylesheets-native \
+"
+
+inherit meson pkgconfig
+
+SRC_URI = "git://github.com/flatpak/xdg-dbus-proxy.git;protocol=https;branch=main"
+
+S = "${WORKDIR}/git"
+SRCREV = "6bfe8c32ab23f8c1d80af7a70b3d318a79a17652"
+
+BBCLASSEXTEND = "native"
diff --git a/meta-openembedded/meta-oe/recipes-support/xdg-desktop-portal/xdg-desktop-portal_1.16.0.bb b/meta-openembedded/meta-oe/recipes-support/xdg-desktop-portal/xdg-desktop-portal_1.16.0.bb
index e16f9f3..0b3a93a 100644
--- a/meta-openembedded/meta-oe/recipes-support/xdg-desktop-portal/xdg-desktop-portal_1.16.0.bb
+++ b/meta-openembedded/meta-oe/recipes-support/xdg-desktop-portal/xdg-desktop-portal_1.16.0.bb
@@ -13,7 +13,6 @@
     pipewire \
     dbus-native \
     fuse3 \
-    bubblewrap-native \
     xmlto-native \
     flatpak \
     python3-dbus-native \
@@ -37,3 +36,12 @@
 SRCREV = "88af6c8ca4106fcf70925355350a669848e9fd5a"
 
 FILES:${PN} += "${libdir}/systemd ${datadir}/dbus-1"
+
+EXTRA_OEMESON += "--cross-file=${WORKDIR}/meson-${PN}.cross"
+
+do_write_config:append() {
+    cat >${WORKDIR}/meson-${PN}.cross <<EOF
+[binaries]
+bwrap = '${bindir}/bwrap'
+EOF
+}
diff --git a/meta-openembedded/meta-oe/recipes-test/bats/bats_1.8.2.bb b/meta-openembedded/meta-oe/recipes-test/bats/bats_1.9.0.bb
similarity index 94%
rename from meta-openembedded/meta-oe/recipes-test/bats/bats_1.8.2.bb
rename to meta-openembedded/meta-oe/recipes-test/bats/bats_1.9.0.bb
index 74e683e..a642d7c 100644
--- a/meta-openembedded/meta-oe/recipes-test/bats/bats_1.8.2.bb
+++ b/meta-openembedded/meta-oe/recipes-test/bats/bats_1.9.0.bb
@@ -10,8 +10,8 @@
   git://github.com/bats-core/bats-core.git;branch=master;protocol=https \
   "
 
-# v1.7.0
-SRCREV = "e8c840b58f0833e23461c682655fe540aa923f85"
+# v1.9.0
+SRCREV = "6636e2c2ef5ffe361535cb45fc61682c5ef46b71"
 
 S = "${WORKDIR}/git"
 
diff --git a/meta-openembedded/meta-oe/recipes-test/cmocka/cmocka_1.1.5.bb b/meta-openembedded/meta-oe/recipes-test/cmocka/cmocka_1.1.7.bb
similarity index 90%
rename from meta-openembedded/meta-oe/recipes-test/cmocka/cmocka_1.1.5.bb
rename to meta-openembedded/meta-oe/recipes-test/cmocka/cmocka_1.1.7.bb
index 554d582..44077a0 100644
--- a/meta-openembedded/meta-oe/recipes-test/cmocka/cmocka_1.1.5.bb
+++ b/meta-openembedded/meta-oe/recipes-test/cmocka/cmocka_1.1.7.bb
@@ -6,9 +6,10 @@
 LICENSE = "Apache-2.0"
 LIC_FILES_CHKSUM = "file://COPYING;md5=3b83ef96387f14655fc854ddc3c6bd57"
 
-SRCREV = "a4fc3dd7705c277e3a57432895e9852ea105dac9"
+SRCREV = "a01cc69ee9536f90e57c61a198f2d1944d3d4313"
 PV .= "+git${SRCPV}"
-SRC_URI = "git://git.cryptomilk.org/projects/cmocka.git;protocol=https;branch=master \
+SRC_URI = "git://git.cryptomilk.org/projects/cmocka.git;protocol=https;branch=stable-1.1 \
+           file://0001-include-Check-for-previous-declaration-of-uintptr_t.patch \
            file://run-ptest \
           "
 
diff --git a/meta-openembedded/meta-oe/recipes-test/cmocka/files/0001-include-Check-for-previous-declaration-of-uintptr_t.patch b/meta-openembedded/meta-oe/recipes-test/cmocka/files/0001-include-Check-for-previous-declaration-of-uintptr_t.patch
new file mode 100644
index 0000000..65d30ea
--- /dev/null
+++ b/meta-openembedded/meta-oe/recipes-test/cmocka/files/0001-include-Check-for-previous-declaration-of-uintptr_t.patch
@@ -0,0 +1,43 @@
+From a54e035f802e79e3292d8ad39a14bd7c060eb7b1 Mon Sep 17 00:00:00 2001
+From: Breno Leitao <breno.leitao@gmail.com>
+Date: Tue, 21 Mar 2023 21:58:28 -0700
+Subject: [PATCH] include: Check for previous declaration of uintptr_t
+
+Adding a extra check before declaring uintptr_t. Currently musl uses
+macro __DEFINED_uintptr_t once it defines uintptr_t type. Checking
+this macro before defining it, and, defining it when uintptr_t is
+defined.
+
+Taken from Alpine
+
+Upstream-Status: Pending
+Signed-off-by: Breno Leitao <breno.leitao@gmail.com>
+Signed-off-by: Khem Raj <raj.khem@gmail.com>
+---
+ include/cmocka.h | 3 ++-
+ 1 file changed, 2 insertions(+), 1 deletion(-)
+
+diff --git a/include/cmocka.h b/include/cmocka.h
+index a21d965..f540793 100644
+--- a/include/cmocka.h
++++ b/include/cmocka.h
+@@ -121,7 +121,7 @@ typedef uintmax_t LargestIntegralType;
+     ((LargestIntegralType)(value))
+ 
+ /* Smallest integral type capable of holding a pointer. */
+-#if !defined(_UINTPTR_T) && !defined(_UINTPTR_T_DEFINED) && !defined(HAVE_UINTPTR_T)
++#if !defined(_UINTPTR_T) && !defined(_UINTPTR_T_DEFINED) && !defined(HAVE_UINTPTR_T) && !defined(__DEFINED_uintptr_t)
+ # if defined(_WIN32)
+     /* WIN32 is an ILP32 platform */
+     typedef unsigned int uintptr_t;
+@@ -147,6 +147,7 @@ typedef uintmax_t LargestIntegralType;
+ 
+ # define _UINTPTR_T
+ # define _UINTPTR_T_DEFINED
++# define __DEFINED_uintptr_t
+ #endif /* !defined(_UINTPTR_T) || !defined(_UINTPTR_T_DEFINED) */
+ 
+ /* Perform an unsigned cast to uintptr_t. */
+-- 
+2.40.0
+
diff --git a/meta-openembedded/meta-oe/recipes-test/cukinia/cukinia_0.6.0.bb b/meta-openembedded/meta-oe/recipes-test/cukinia/cukinia_0.6.1.bb
similarity index 92%
rename from meta-openembedded/meta-oe/recipes-test/cukinia/cukinia_0.6.0.bb
rename to meta-openembedded/meta-oe/recipes-test/cukinia/cukinia_0.6.1.bb
index 229aee6..9bd2301 100644
--- a/meta-openembedded/meta-oe/recipes-test/cukinia/cukinia_0.6.0.bb
+++ b/meta-openembedded/meta-oe/recipes-test/cukinia/cukinia_0.6.1.bb
@@ -9,7 +9,7 @@
 
 SRC_URI = "git://github.com/savoirfairelinux/cukinia.git;protocol=https;branch=master"
 
-SRCREV = "3fd9db9838ef3de20965aa5f7657c363b679a995"
+SRCREV = "b074be54a1379ae1243ae1187f892aeb39b7c083"
 
 S = "${WORKDIR}/git"
 
diff --git a/meta-openembedded/meta-oe/recipes-test/googletest/googletest_git.bb b/meta-openembedded/meta-oe/recipes-test/googletest/googletest_1.13.0.bb
similarity index 86%
rename from meta-openembedded/meta-oe/recipes-test/googletest/googletest_git.bb
rename to meta-openembedded/meta-oe/recipes-test/googletest/googletest_1.13.0.bb
index edca0bc..2327f85 100644
--- a/meta-openembedded/meta-oe/recipes-test/googletest/googletest_git.bb
+++ b/meta-openembedded/meta-oe/recipes-test/googletest/googletest_1.13.0.bb
@@ -4,13 +4,11 @@
 LICENSE = "BSD-3-Clause"
 LIC_FILES_CHKSUM = "file://LICENSE;md5=cbbd27594afd089daa160d3a16dd515a"
 
-PV = "1.12.1"
-
 PROVIDES += "gmock gtest"
 
 S = "${WORKDIR}/git"
-SRCREV = "58d77fa8070e8cec2dc1ed015d66b454c8d78850"
-SRC_URI = "git://github.com/google/googletest.git;branch=v1.12.x;protocol=https"
+SRCREV = "b796f7d44681514f58a683a3a71ff17c94edb0c1"
+SRC_URI = "git://github.com/google/googletest.git;branch=main;protocol=https"
 
 inherit cmake
 
