diff --git a/meta-openembedded/meta-filesystems/recipes-filesystems/burnia/libisoburn_1.5.4.bb b/meta-openembedded/meta-filesystems/recipes-filesystems/burnia/libisoburn_1.5.6.bb
similarity index 89%
rename from meta-openembedded/meta-filesystems/recipes-filesystems/burnia/libisoburn_1.5.4.bb
rename to meta-openembedded/meta-filesystems/recipes-filesystems/burnia/libisoburn_1.5.6.bb
index f263b51..3982eae 100644
--- a/meta-openembedded/meta-filesystems/recipes-filesystems/burnia/libisoburn_1.5.4.bb
+++ b/meta-openembedded/meta-filesystems/recipes-filesystems/burnia/libisoburn_1.5.6.bb
@@ -6,7 +6,7 @@
                     file://COPYRIGHT;md5=43cfe25a7e4a65f722d6253fa0649bb1"
 
 SRC_URI = "http://files.libburnia-project.org/releases/libisoburn-${PV}.tar.gz"
-SRC_URI[sha256sum] = "2d89846d43880f17fa591c53b3bea42ffb803628e4e630c680fc2c9184f79132"
+SRC_URI[sha256sum] = "2b80a6f73dd633a5d243facbe97a15e5c9a07644a5e1a242c219b9375a45f71b"
 
 DEPENDS = "libisofs libburn"
 # This replaces the xorriso recipe
diff --git a/meta-openembedded/meta-filesystems/recipes-filesystems/burnia/libisofs_1.5.4.bb b/meta-openembedded/meta-filesystems/recipes-filesystems/burnia/libisofs_1.5.6.bb
similarity index 82%
rename from meta-openembedded/meta-filesystems/recipes-filesystems/burnia/libisofs_1.5.4.bb
rename to meta-openembedded/meta-filesystems/recipes-filesystems/burnia/libisofs_1.5.6.bb
index 1754db7..0add377 100644
--- a/meta-openembedded/meta-filesystems/recipes-filesystems/burnia/libisofs_1.5.4.bb
+++ b/meta-openembedded/meta-filesystems/recipes-filesystems/burnia/libisofs_1.5.6.bb
@@ -6,7 +6,7 @@
                     file://COPYRIGHT;md5=1c1e5a960562d65f6449bb1d21e1dffc"
 
 SRC_URI = "http://files.libburnia-project.org/releases/${BP}.tar.gz"
-SRC_URI[sha256sum] = "aaa0ed80a7501979316f505b0b017f29cba0ea5463b751143bad2c360215a88e"
+SRC_URI[sha256sum] = "0152d66a9d340b659fe9c880eb9190f3570fb477ac07cf52e8bcd134a1d30d70"
 
 DEPENDS = "acl zlib"
 
diff --git a/meta-openembedded/meta-filesystems/recipes-filesystems/fuse-exfat/fuse-exfat_1.3.0.bb b/meta-openembedded/meta-filesystems/recipes-filesystems/fuse-exfat/fuse-exfat_1.4.0.bb
similarity index 83%
rename from meta-openembedded/meta-filesystems/recipes-filesystems/fuse-exfat/fuse-exfat_1.3.0.bb
rename to meta-openembedded/meta-filesystems/recipes-filesystems/fuse-exfat/fuse-exfat_1.4.0.bb
index ac18fe9..48e3d7a 100644
--- a/meta-openembedded/meta-filesystems/recipes-filesystems/fuse-exfat/fuse-exfat_1.3.0.bb
+++ b/meta-openembedded/meta-filesystems/recipes-filesystems/fuse-exfat/fuse-exfat_1.4.0.bb
@@ -16,7 +16,6 @@
 
 inherit autotools pkgconfig
 
-SRC_URI[md5sum] = "846b8c36bfa4684719f9e08e9d3a6bff"
-SRC_URI[sha256sum] = "07652136064da5e4d32df5555f88c138ffa4835a23b88a5bae2015f21006e0d3"
+SRC_URI[sha256sum] = "a1cfedc55e0e7a12c184605aa0f0bf44b24a3fb272449b20b2c8bbe6edb3001e"
 
 EXTRA_OECONF += "sbindir=${base_sbindir}"
diff --git a/meta-openembedded/meta-filesystems/recipes-filesystems/unionfs-fuse/files/0001-support-cross-compiling.patch b/meta-openembedded/meta-filesystems/recipes-filesystems/unionfs-fuse/files/0001-support-cross-compiling.patch
index bf363ca..13e782f 100644
--- a/meta-openembedded/meta-filesystems/recipes-filesystems/unionfs-fuse/files/0001-support-cross-compiling.patch
+++ b/meta-openembedded/meta-filesystems/recipes-filesystems/unionfs-fuse/files/0001-support-cross-compiling.patch
@@ -1,32 +1,29 @@
-From 449cec34c123b86b792627553c6ec7471d2ee7ed Mon Sep 17 00:00:00 2001
-From: Hongxu Jia <hongxu.jia@windriver.com>
-Date: Fri, 30 Jun 2017 14:46:51 +0800
+From 6e794a36564a2639a07d8720260e33d7c9435aa4 Mon Sep 17 00:00:00 2001
+From: Alper Ak <alperyasinak1@gmail.com>
+Date: Fri, 10 Nov 2023 20:50:48 +0300
 Subject: [PATCH] support cross compiling
 
 Do not override OE CMAKE variables
 
-Upstream-Status: Pending
-
 Signed-off-by: Hongxu Jia <hongxu.jia@windriver.com>
+Signed-off-by: Alper Ak <alperyasinak1@gmail.com>
 ---
- CMakeLists.txt | 4 ++--
+ src/CMakeLists.txt | 4 ++--
  1 file changed, 2 insertions(+), 2 deletions(-)
 
-diff --git a/CMakeLists.txt b/CMakeLists.txt
---- a/CMakeLists.txt
-+++ b/CMakeLists.txt
-@@ -10,9 +10,9 @@ IF(NOT CMAKE_CONFIGURATION_TYPES AND NOT CMAKE_BUILD_TYPE)
- ENDIF(NOT CMAKE_CONFIGURATION_TYPES AND NOT CMAKE_BUILD_TYPE)
+diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt
+index f549496..ab71fb2 100644
+--- a/src/CMakeLists.txt
++++ b/src/CMakeLists.txt
+@@ -4,9 +4,9 @@ set(UNIONFS_SRCS unionfs.c opts.c debug.c findbranch.c readdir.c
+     fuse_ops.c)
+ set(UNIONFSCTL_SRCS unionfsctl.c)
  
- # Select flags.
--SET(CMAKE_C_FLAGS "-pipe -W -Wall -DFORTIFY_SOURCE=2")
-+SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -pipe -W -Wall -DFORTIFY_SOURCE=2")
+-SET(CMAKE_C_FLAGS "-pipe -W -Wall -D_FORTIFY_SOURCE=2")
++SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -pipe -W -Wall -D_FORTIFY_SOURCE=2")
  SET(CMAKE_C_FLAGS_RELWITHDEBINFO "-O2 -g")
 -SET(CMAKE_C_FLAGS_RELEASE "-O2")
 +SET(CMAKE_C_FLAGS_RELEASE "${CMAKE_C_FLAGS_RELEASE} -O2")
  SET(CMAKE_C_FLAGS_DEBUG "-O0 -g -DDEBUG")
  
- if (UNIX AND APPLE)
--- 
-2.8.1
-
+ add_executable(unionfs ${UNIONFS_SRCS} ${HASHTABLE_SRCS})
diff --git a/meta-openembedded/meta-filesystems/recipes-filesystems/unionfs-fuse/unionfs-fuse_2.2.bb b/meta-openembedded/meta-filesystems/recipes-filesystems/unionfs-fuse/unionfs-fuse_3.4.bb
similarity index 84%
rename from meta-openembedded/meta-filesystems/recipes-filesystems/unionfs-fuse/unionfs-fuse_2.2.bb
rename to meta-openembedded/meta-filesystems/recipes-filesystems/unionfs-fuse/unionfs-fuse_3.4.bb
index 03ae418..e8fda05 100644
--- a/meta-openembedded/meta-filesystems/recipes-filesystems/unionfs-fuse/unionfs-fuse_2.2.bb
+++ b/meta-openembedded/meta-filesystems/recipes-filesystems/unionfs-fuse/unionfs-fuse_3.4.bb
@@ -9,9 +9,10 @@
 SRC_URI = "git://github.com/rpodgorny/${BPN}.git;branch=master;protocol=https \
            file://0001-support-cross-compiling.patch \
            "
-SRCREV = "b0e3805d3d84d44ddf3e4e5238ae0332145d8157"
+SRCREV = "773f1853b043eeb64b7459f903a2c65bd096f9d9"
 
-DEPENDS = "fuse"
+DEPENDS = "fuse3"
+RDEPENDS:${PN} = "bash"
 
 S = "${WORKDIR}/git"
 
diff --git a/meta-openembedded/meta-filesystems/recipes-support/fuse/fuse3_3.15.1.bb b/meta-openembedded/meta-filesystems/recipes-support/fuse/fuse3_3.16.2.bb
similarity index 96%
rename from meta-openembedded/meta-filesystems/recipes-support/fuse/fuse3_3.15.1.bb
rename to meta-openembedded/meta-filesystems/recipes-support/fuse/fuse3_3.16.2.bb
index de2996d..66c3501 100644
--- a/meta-openembedded/meta-filesystems/recipes-support/fuse/fuse3_3.15.1.bb
+++ b/meta-openembedded/meta-filesystems/recipes-support/fuse/fuse3_3.16.2.bb
@@ -13,7 +13,7 @@
 
 SRC_URI = "https://github.com/libfuse/libfuse/releases/download/fuse-${PV}/fuse-${PV}.tar.gz \
 "
-SRC_URI[sha256sum] = "13ef77cda531a21c2131f9576042970e98035c0a5f019abf661506efd2d38a4e"
+SRC_URI[sha256sum] = "f797055d9296b275e981f5f62d4e32e089614fc253d1ef2985851025b8a0ce87"
 
 S = "${WORKDIR}/fuse-${PV}"
 
diff --git a/meta-openembedded/meta-filesystems/recipes-utils/binfs/bindfs_1.17.6.bb b/meta-openembedded/meta-filesystems/recipes-utils/binfs/bindfs_1.17.6.bb
new file mode 100644
index 0000000..673198e
--- /dev/null
+++ b/meta-openembedded/meta-filesystems/recipes-utils/binfs/bindfs_1.17.6.bb
@@ -0,0 +1,15 @@
+SUMMARY = "A FUSE filesystem for mounting a directory to another location"
+DESCRIPTION = "bindfs is a FUSE filesystem for mounting a directory to another location, similarly to mount --bind."
+HOMEPAGE = "https://bindfs.org/"
+LICENSE = "GPL-2.0-only"
+LIC_FILES_CHKSUM = "file://COPYING;md5=94d55d512a9ba36caa9b7df079bae19f"
+
+DEPENDS = "fuse"
+RDEPENDS:${PN} = "fuse"
+
+SRC_URI = "git://github.com/mpartel/bindfs;protocol=https;branch=master"
+SRCREV = "b982aee1161307cdd0e90f7f9597b11872440efc"
+
+S = "${WORKDIR}/git"
+
+inherit autotools pkgconfig gettext
diff --git a/meta-openembedded/meta-filesystems/recipes-utils/exfatprogs/exfatprogs_1.2.1.bb b/meta-openembedded/meta-filesystems/recipes-utils/exfatprogs/exfatprogs_1.2.2.bb
similarity index 91%
rename from meta-openembedded/meta-filesystems/recipes-utils/exfatprogs/exfatprogs_1.2.1.bb
rename to meta-openembedded/meta-filesystems/recipes-utils/exfatprogs/exfatprogs_1.2.2.bb
index 3767ec4..0dd5d8f 100644
--- a/meta-openembedded/meta-filesystems/recipes-utils/exfatprogs/exfatprogs_1.2.1.bb
+++ b/meta-openembedded/meta-filesystems/recipes-utils/exfatprogs/exfatprogs_1.2.2.bb
@@ -12,7 +12,7 @@
 LIC_FILES_CHKSUM = "file://COPYING;md5=b234ee4d69f5fce4486a80fdaf4a4263"
 
 SRC_URI = "https://github.com/${BPN}/${BPN}/releases/download/${PV}/${BP}.tar.xz"
-SRC_URI[sha256sum] = "a6f3b1fb4bd37835c8f8cb421aac4eb75b880a51342b29850c4063973162227b"
+SRC_URI[sha256sum] = "61d517231f8ec177eeb5955fd6edb89748d3f88ba412c48bcb32741b430e359a"
 
 UPSTREAM_CHECK_URI = "https://github.com/${BPN}/${BPN}/releases"
 UPSTREAM_CHECK_REGEX = "${BPN}-(?P<pver>\d+(\.\d+)+)"
diff --git a/meta-openembedded/meta-filesystems/recipes-utils/ufs-utils/ufs-utils_3.12.3.bb b/meta-openembedded/meta-filesystems/recipes-utils/ufs-utils/ufs-utils_4.13.5.bb
similarity index 92%
rename from meta-openembedded/meta-filesystems/recipes-utils/ufs-utils/ufs-utils_3.12.3.bb
rename to meta-openembedded/meta-filesystems/recipes-utils/ufs-utils/ufs-utils_4.13.5.bb
index 342661c..7126684 100644
--- a/meta-openembedded/meta-filesystems/recipes-utils/ufs-utils/ufs-utils_3.12.3.bb
+++ b/meta-openembedded/meta-filesystems/recipes-utils/ufs-utils/ufs-utils_4.13.5.bb
@@ -4,7 +4,7 @@
 
 BRANCH ?= "dev"
 
-SRCREV = "40c0bdfa7f4e922a4bcdf431ef72b321648d2d9f"
+SRCREV = "18c0a8454ca1cf8969170049f8c628d88627beec"
 
 SRC_URI = "git://github.com/westerndigitalcorporation/ufs-utils.git;protocol=https;branch=${BRANCH} \
           "
diff --git a/meta-openembedded/meta-filesystems/recipes-utils/xfsprogs/xfsprogs_6.1.1.bb b/meta-openembedded/meta-filesystems/recipes-utils/xfsprogs/xfsprogs_6.5.0.bb
similarity index 96%
rename from meta-openembedded/meta-filesystems/recipes-utils/xfsprogs/xfsprogs_6.1.1.bb
rename to meta-openembedded/meta-filesystems/recipes-utils/xfsprogs/xfsprogs_6.5.0.bb
index 6267fd9..fd27979 100644
--- a/meta-openembedded/meta-filesystems/recipes-utils/xfsprogs/xfsprogs_6.1.1.bb
+++ b/meta-openembedded/meta-filesystems/recipes-utils/xfsprogs/xfsprogs_6.5.0.bb
@@ -13,7 +13,7 @@
            file://0004-configure-Use-AC_SYS_LARGERFILE-autoconf-macro.patch \
            file://0005-Replace-off64_t-stat64-with-off_t-stat.patch \
            "
-SRC_URI[sha256sum] = "05e8a137870db1d6182df72dda98ab7a7100deb376947e854b9d59c914c2c7bb"
+SRC_URI[sha256sum] = "8db81712b32756b97d89dd9a681ac5e325bbb75e585382cd4863fab7f9d021c6"
 inherit autotools-brokensep pkgconfig
 
 PACKAGES =+ "${PN}-fsck ${PN}-mkfs ${PN}-repair libhandle"
diff --git a/meta-openembedded/meta-filesystems/recipes-utils/xfstests/xfstests/0001-Add-a-return-type-to-aio_rw.patch b/meta-openembedded/meta-filesystems/recipes-utils/xfstests/xfstests/0001-Add-a-return-type-to-aio_rw.patch
deleted file mode 100644
index e0a04c9..0000000
--- a/meta-openembedded/meta-filesystems/recipes-utils/xfstests/xfstests/0001-Add-a-return-type-to-aio_rw.patch
+++ /dev/null
@@ -1,28 +0,0 @@
-From f172ea004d34b00aa7bd5baff9422b2ab80df6e7 Mon Sep 17 00:00:00 2001
-From: Khem Raj <raj.khem@gmail.com>
-Date: Sun, 14 Aug 2022 13:32:10 -0700
-Subject: [PATCH 1/2] Add a return type to aio_rw
-
-Compilers complain about the function prototype otherwise
-
-Upstream-Status: Pending
-Signed-off-by: Khem Raj <raj.khem@gmail.com>
----
- ltp/fsx.c | 1 +
- 1 file changed, 1 insertion(+)
-
-diff --git a/ltp/fsx.c b/ltp/fsx.c
-index 12c2cc33..55b4e9b6 100644
---- a/ltp/fsx.c
-+++ b/ltp/fsx.c
-@@ -2429,6 +2429,7 @@ out_error:
- 	return -1;
- }
- #else
-+int
- aio_rw(int rw, int fd, char *buf, unsigned len, unsigned offset)
- {
- 	fprintf(stderr, "io_rw: need AIO support!\n");
--- 
-2.37.2
-
diff --git a/meta-openembedded/meta-filesystems/recipes-utils/xfstests/xfstests/0001-add-missing-FTW_-macros-when-not-available-in-libc.patch b/meta-openembedded/meta-filesystems/recipes-utils/xfstests/xfstests/0001-add-missing-FTW_-macros-when-not-available-in-libc.patch
new file mode 100644
index 0000000..5e230e2
--- /dev/null
+++ b/meta-openembedded/meta-filesystems/recipes-utils/xfstests/xfstests/0001-add-missing-FTW_-macros-when-not-available-in-libc.patch
@@ -0,0 +1,41 @@
+From 5facddc332c5ff8330f93c0a7e1b7f6d7bbd24a3 Mon Sep 17 00:00:00 2001
+From: Khem Raj <raj.khem@gmail.com>
+Date: Sun, 5 Nov 2023 08:31:21 -0800
+Subject: [PATCH] add missing FTW_ macros when not available in libc
+
+Fixes build with musl
+
+| xfsfind.c:176:13: error: use of undeclared identifier 'FTW_STOP'
+|   176 |                         retval = FTW_STOP;
+|       |                                  ^
+
+Upstream-Status: Pending
+Signed-off-by: Khem Raj <raj.khem@gmail.com>
+---
+ src/global.h | 12 ++++++++++++
+ 1 file changed, 12 insertions(+)
+
+diff --git a/src/global.h b/src/global.h
+index 49570ef1..1c247488 100644
+--- a/src/global.h
++++ b/src/global.h
+@@ -190,4 +190,16 @@ roundup_64(unsigned long long x, unsigned int y)
+ 	return rounddown_64(x + y - 1, y);
+ }
+ 
++#ifndef FTW_ACTIONRETVAL
++#define FTW_ACTIONRETVAL 16
++#endif
++
++#ifndef FTW_CONTINUE
++#define FTW_CONTINUE 0
++#endif
++
++#ifndef FTW_STOP
++#define FTW_STOP 1
++#endif
++
+ #endif /* GLOBAL_H */
+-- 
+2.42.1
+
diff --git a/meta-openembedded/meta-filesystems/recipes-utils/xfstests/xfstests/0001-ltp-fsx.h-Explicitly-use-int-for-return-type-for-aio.patch b/meta-openembedded/meta-filesystems/recipes-utils/xfstests/xfstests/0001-ltp-fsx.h-Explicitly-use-int-for-return-type-for-aio.patch
new file mode 100644
index 0000000..5e9e9d9
--- /dev/null
+++ b/meta-openembedded/meta-filesystems/recipes-utils/xfstests/xfstests/0001-ltp-fsx.h-Explicitly-use-int-for-return-type-for-aio.patch
@@ -0,0 +1,30 @@
+From 0927d0def968ea7e19905c7e39182f65961c11cf Mon Sep 17 00:00:00 2001
+From: Khem Raj <raj.khem@gmail.com>
+Date: Sun, 5 Nov 2023 01:17:52 -0700
+Subject: [PATCH] ltp/fsx.h: Explicitly use int for return type for aio_rw()
+
+Fixes build with clang-17+
+error: type specifier missing, defaults to 'int'; ISO C99 and later do not support implicit int [-Wimplicit-int]
+
+Upstream-Status: Submitted [https://marc.info/?l=fstests&m=169917222008646&w=2]
+Signed-off-by: Khem Raj <raj.khem@gmail.com>
+---
+ ltp/fsx.c | 2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
+
+diff --git a/ltp/fsx.c b/ltp/fsx.c
+index ee4b8fe4..c0aec23f 100644
+--- a/ltp/fsx.c
++++ b/ltp/fsx.c
+@@ -2581,7 +2581,7 @@ out_error:
+ 	return -1;
+ }
+ #else
+-aio_rw(int rw, int fd, char *buf, unsigned len, unsigned offset)
++int aio_rw(int rw, int fd, char *buf, unsigned len, unsigned offset)
+ {
+ 	fprintf(stderr, "io_rw: need AIO support!\n");
+ 	exit(111);
+-- 
+2.42.1
+
diff --git a/meta-openembedded/meta-filesystems/recipes-utils/xfstests/xfstests/0001-m4-Check-for-FTW_ACTIONRETVAL-along-with-nftw.patch b/meta-openembedded/meta-filesystems/recipes-utils/xfstests/xfstests/0001-m4-Check-for-FTW_ACTIONRETVAL-along-with-nftw.patch
deleted file mode 100644
index fd34989..0000000
--- a/meta-openembedded/meta-filesystems/recipes-utils/xfstests/xfstests/0001-m4-Check-for-FTW_ACTIONRETVAL-along-with-nftw.patch
+++ /dev/null
@@ -1,34 +0,0 @@
-From 2a4fed8331f996421e65db446559991a854e2ad3 Mon Sep 17 00:00:00 2001
-From: Khem Raj <raj.khem@gmail.com>
-Date: Fri, 24 Mar 2023 18:23:01 -0700
-Subject: [PATCH] m4: Check for FTW_ACTIONRETVAL along with nftw
-
-FTW_ACTIONRETVAL is glibc specific extention which is used to implement
-xfsfind but it may not be available on other C library implementations on Linux
-e.g. musl. Therefore ensure that these defines are available before declaring
-nftw() to be usable
-
-Upstream-Status: Submitted [https://lore.kernel.org/fstests/20230325012858.587801-1-raj.khem@gmail.com/T/#u]
-Signed-off-by: Khem Raj <raj.khem@gmail.com>
-Cc: Darrick J. Wong <djwong@kernel.org>
-Cc: Zorro Lang <zlang@redhat.com>
----
- m4/package_libcdev.m4 | 2 +-
- 1 file changed, 1 insertion(+), 1 deletion(-)
-
-diff --git a/m4/package_libcdev.m4 b/m4/package_libcdev.m4
-index b41c087b..7f731044 100644
---- a/m4/package_libcdev.m4
-+++ b/m4/package_libcdev.m4
-@@ -132,7 +132,7 @@ AC_DEFUN([AC_HAVE_NFTW],
- #include <stddef.h>
- #include <ftw.h>
-     ]], [[
--         nftw("/", (int (*)(const char *, const struct stat *, int, struct FTW *))1, 0, 0);
-+         nftw("/", (int (*)(const char *, const struct stat *, int, struct FTW *))1, 0, FTW_ACTIONRETVAL);
-     ]])],[have_nftw=yes
-        AC_MSG_RESULT(yes)],[AC_MSG_RESULT(no)])
-     AC_SUBST(have_nftw)
--- 
-2.40.0
-
diff --git a/meta-openembedded/meta-filesystems/recipes-utils/xfstests/xfstests/0002-Drop-detached_mounts_propagation-and-remove-sys-moun.patch b/meta-openembedded/meta-filesystems/recipes-utils/xfstests/xfstests/0002-Drop-detached_mounts_propagation-and-remove-sys-moun.patch
index a594b73..856fd27 100644
--- a/meta-openembedded/meta-filesystems/recipes-utils/xfstests/xfstests/0002-Drop-detached_mounts_propagation-and-remove-sys-moun.patch
+++ b/meta-openembedded/meta-filesystems/recipes-utils/xfstests/xfstests/0002-Drop-detached_mounts_propagation-and-remove-sys-moun.patch
@@ -1,8 +1,8 @@
-From dd43cbc7f50266cdc6210f2b920d7f648a83bdd6 Mon Sep 17 00:00:00 2001
+From 559f685f83d12d11bf9ec6c6ce924ee4d0702a2a Mon Sep 17 00:00:00 2001
 From: Khem Raj <raj.khem@gmail.com>
 Date: Sun, 14 Aug 2022 13:33:05 -0700
-Subject: [PATCH 2/2] Drop detached_mounts_propagation and remove sys/mount.h
- from vfs/utils.c
+Subject: [PATCH] Drop detached_mounts_propagation and remove sys/mount.h from
+ vfs/utils.c
 
 with glibc 2.36+ sys/mount.h conflicts with linux/mount.h and here
 linux/mount.h is included via xfs/xfs.h header and we need sys/mount.h
@@ -12,16 +12,16 @@
 Upstream-Status: Inappropriate [Libc specific Workaround]
 
 Signed-off-by: Khem Raj <raj.khem@gmail.com>
+
 ---
- src/Makefile    | 2 +-
- src/vfs/utils.c | 1 -
- 2 files changed, 1 insertion(+), 2 deletions(-)
+ src/Makefile | 2 +-
+ 1 file changed, 1 insertion(+), 1 deletion(-)
 
 diff --git a/src/Makefile b/src/Makefile
-index 665edcf9..7debcbbd 100644
+index 2815f919..448fccc9 100644
 --- a/src/Makefile
 +++ b/src/Makefile
-@@ -31,7 +31,7 @@ LINUX_TARGETS = xfsctl bstat t_mtab getdevicesize preallo_rw_pattern_reader \
+@@ -32,7 +32,7 @@ LINUX_TARGETS = xfsctl bstat t_mtab getdevicesize preallo_rw_pattern_reader \
  	dio-invalidate-cache stat_test t_encrypted_d_revalidate \
  	attr_replace_test swapon mkswap t_attr_corruption t_open_tmpfiles \
  	fscrypt-crypt-util bulkstat_null_ocount splice-test chprojid_fail \
@@ -30,18 +30,3 @@
  	uuid_ioctl
  
  EXTRA_EXECS = dmerror fill2attr fill2fs fill2fs_check scaleread.sh \
-diff --git a/src/vfs/utils.c b/src/vfs/utils.c
-index 1388edda..aacd6c0a 100644
---- a/src/vfs/utils.c
-+++ b/src/vfs/utils.c
-@@ -10,7 +10,6 @@
- #include <stdlib.h>
- #include <sys/eventfd.h>
- #include <sys/fsuid.h>
--#include <sys/mount.h>
- #include <sys/prctl.h>
- #include <sys/socket.h>
- #include <sys/stat.h>
--- 
-2.37.2
-
diff --git a/meta-openembedded/meta-filesystems/recipes-utils/xfstests/xfstests_2023.03.05.bb b/meta-openembedded/meta-filesystems/recipes-utils/xfstests/xfstests_2023.10.29.bb
similarity index 88%
rename from meta-openembedded/meta-filesystems/recipes-utils/xfstests/xfstests_2023.03.05.bb
rename to meta-openembedded/meta-filesystems/recipes-utils/xfstests/xfstests_2023.10.29.bb
index cfb6e4f..4e8e318 100644
--- a/meta-openembedded/meta-filesystems/recipes-utils/xfstests/xfstests_2023.03.05.bb
+++ b/meta-openembedded/meta-filesystems/recipes-utils/xfstests/xfstests_2023.10.29.bb
@@ -2,13 +2,14 @@
 LICENSE = "GPL-2.0-only"
 LIC_FILES_CHKSUM = "file://LICENSES/GPL-2.0;md5=74274e8a218423e49eefdea80bc55038"
 
+SRCREV = "11914614784735c504f43b5b6baabaa713375984"
 SRCREV_FORMAT = "xfstests_unionmount"
 
-SRC_URI = "git://git.kernel.org/pub/scm/fs/xfs/xfstests-dev.git;branch=master;name=xfstests \
+SRC_URI = "git://git.kernel.org/pub/scm/fs/xfs/xfstests-dev.git;branch=for-next;name=xfstests \
            git://github.com/amir73il/unionmount-testsuite.git;branch=master;protocol=https;name=unionmount;destsuffix=unionmount-testsuite \
-           file://0001-Add-a-return-type-to-aio_rw.patch \
+           file://0001-ltp-fsx.h-Explicitly-use-int-for-return-type-for-aio.patch \
            file://0002-Drop-detached_mounts_propagation-and-remove-sys-moun.patch \
-           file://0001-m4-Check-for-FTW_ACTIONRETVAL-along-with-nftw.patch \
+           file://0001-add-missing-FTW_-macros-when-not-available-in-libc.patch \
            "
 
 SRCREV_xfstests = "f7765774a1b5cb98c2f21a892e82b3421f40e791"
