summarylogtreecommitdiffstats
diff options
context:
space:
mode:
authorArchzfs Buildbot2024-03-18 15:11:39 +0000
committerArchzfs Buildbot2024-03-18 15:11:39 +0000
commit2031c108c56e30a2b85911b951b5e6f526d42212 (patch)
tree5c67b3a26438e58134242a5b891d32faa6384648
parent077aa9c1b24a8f83fd8f05295911127ece5946a8 (diff)
downloadaur-zfs-linux.tar.gz
Semi-automated update for kernel 6.8.1.arch1-1 + zfs 2.2.3
-rw-r--r--.SRCINFO12
-rw-r--r--PKGBUILD14
-rw-r--r--enforce-kernel-max-version.patch300
-rw-r--r--kernel-6.8-meta.patch9
-rw-r--r--linux-6.8-compat.patch130
5 files changed, 458 insertions, 7 deletions
diff --git a/.SRCINFO b/.SRCINFO
index ec2f741635a1..c350c96b7d9e 100644
--- a/.SRCINFO
+++ b/.SRCINFO
@@ -1,15 +1,21 @@
pkgbase = zfs-linux
- pkgver = 2.2.3_6.7.8.arch1.1
+ pkgver = 2.2.3_6.8.1.arch1.1
pkgrel = 1
url = https://openzfs.org/
arch = x86_64
license = CDDL
- makedepends = linux-headers=6.7.8.arch1-1
+ makedepends = linux-headers=6.8.1.arch1-1
depends = kmod
depends = zfs-utils=2.2.3
- depends = linux=6.7.8.arch1-1
+ depends = linux=6.8.1.arch1-1
source = https://github.com/openzfs/zfs/releases/download/zfs-2.2.3/zfs-2.2.3.tar.gz
+ source = enforce-kernel-max-version.patch
+ source = linux-6.8-compat.patch
+ source = kernel-6.8-meta.patch
sha256sums = 30a512f34ec5c841b8b2b32cc9c1a03fd49391b26c9164d3fb30573fb5d81ac3
+ sha256sums = c5a9f546638c706844d5aff99f40366db1684679c3318d3a4093e0746748a711
+ sha256sums = b875c877069a4c75c7b2b4b22d048e66f415b86f862ef6b3b83d3524694cc973
+ sha256sums = 1bc3b2e79e481b1bf41e78f9d142de8e97326288ecdc97f8db65496b7c4fd63b
pkgname = zfs-linux
pkgdesc = Kernel modules for the Zettabyte File System.
diff --git a/PKGBUILD b/PKGBUILD
index 11fbc0cd47ed..725c7aca340c 100644
--- a/PKGBUILD
+++ b/PKGBUILD
@@ -18,8 +18,8 @@
pkgbase="zfs-linux"
pkgname=("zfs-linux" "zfs-linux-headers")
_zfsver="2.2.3"
-_kernelver="6.7.8.arch1-1"
-_kernelver_full="6.7.8.arch1-1"
+_kernelver="6.8.1.arch1-1"
+_kernelver_full="6.8.1.arch1-1"
_extramodules="${_kernelver_full/.arch/-arch}"
pkgver="${_zfsver}_$(echo ${_kernelver} | sed s/-/./g)"
@@ -27,10 +27,16 @@ pkgrel=1
makedepends=("linux-headers=${_kernelver}")
arch=("x86_64")
url="https://openzfs.org/"
-source=("https://github.com/openzfs/zfs/releases/download/zfs-${_zfsver}/zfs-${_zfsver}.tar.gz")
-sha256sums=("30a512f34ec5c841b8b2b32cc9c1a03fd49391b26c9164d3fb30573fb5d81ac3")
+source=("https://github.com/openzfs/zfs/releases/download/zfs-${_zfsver}/zfs-${_zfsver}.tar.gz" "enforce-kernel-max-version.patch" "linux-6.8-compat.patch" "kernel-6.8-meta.patch")
+sha256sums=("30a512f34ec5c841b8b2b32cc9c1a03fd49391b26c9164d3fb30573fb5d81ac3" "c5a9f546638c706844d5aff99f40366db1684679c3318d3a4093e0746748a711" "b875c877069a4c75c7b2b4b22d048e66f415b86f862ef6b3b83d3524694cc973" "1bc3b2e79e481b1bf41e78f9d142de8e97326288ecdc97f8db65496b7c4fd63b")
license=("CDDL")
depends=("kmod" "zfs-utils=${_zfsver}" "linux=${_kernelver}")
+prepare() {
+ cd "${srcdir}/zfs-${_zfsver}"
+ patch -Np1 -i ${srcdir}/enforce-kernel-max-version.patch
+ patch -Np1 -i ${srcdir}/linux-6.8-compat.patch
+ patch -Np1 -i ${srcdir}/kernel-6.8-meta.patch
+}
build() {
cd "${srcdir}/zfs-${_zfsver}"
diff --git a/enforce-kernel-max-version.patch b/enforce-kernel-max-version.patch
new file mode 100644
index 000000000000..7fd0c6e1f064
--- /dev/null
+++ b/enforce-kernel-max-version.patch
@@ -0,0 +1,300 @@
+From 2b481b5477d3a95d0eab723c6639f7114e146ae1 Mon Sep 17 00:00:00 2001
+From: Rob Norris <robn@despairlabs.com>
+Date: Tue, 12 Mar 2024 20:38:12 +1100
+Subject: [PATCH] config/kernel: enforce kernel max version, with escape hatch
+
+It's possible for OpenZFS to build correctly against a newer kernel than
+it is supported for, but then not work correctly. This invariably
+results in disappointment, confusion and/or anger.
+
+Sometimes however we do actually want to compile against a newer kernel
+than is supported, usually when testing a pre-release kernel. Add the
+deliberately-verbose `--disable-supported-linux-version-check` option to
+disable this check. This is lots to type, and so hopefully can be taken
+as a very explicit signal that the user knows what they're doing.
+
+Finally, if an unsupported kernel is used and the option is used, a big
+warning message is displayed at the end of the configure run to really
+try and make the point.
+
+Signed-off-by: Rob Norris <robn@despairlabs.com>
+Sponsored-by: https://despairlabs.com/sponsor/
+---
+ config/ax_compare_version.m4 | 177 +++++++++++++++++++++++++++++++++++
+ config/kernel.m4 | 59 +++++++++++-
+ configure.ac | 2 +
+ 3 files changed, 236 insertions(+), 2 deletions(-)
+ create mode 100644 config/ax_compare_version.m4
+
+diff --git a/config/ax_compare_version.m4 b/config/ax_compare_version.m4
+new file mode 100644
+index 000000000000..ffb4997e8b14
+--- /dev/null
++++ b/config/ax_compare_version.m4
+@@ -0,0 +1,177 @@
++# ===========================================================================
++# https://www.gnu.org/software/autoconf-archive/ax_compare_version.html
++# ===========================================================================
++#
++# SYNOPSIS
++#
++# AX_COMPARE_VERSION(VERSION_A, OP, VERSION_B, [ACTION-IF-TRUE], [ACTION-IF-FALSE])
++#
++# DESCRIPTION
++#
++# This macro compares two version strings. Due to the various number of
++# minor-version numbers that can exist, and the fact that string
++# comparisons are not compatible with numeric comparisons, this is not
++# necessarily trivial to do in a autoconf script. This macro makes doing
++# these comparisons easy.
++#
++# The six basic comparisons are available, as well as checking equality
++# limited to a certain number of minor-version levels.
++#
++# The operator OP determines what type of comparison to do, and can be one
++# of:
++#
++# eq - equal (test A == B)
++# ne - not equal (test A != B)
++# le - less than or equal (test A <= B)
++# ge - greater than or equal (test A >= B)
++# lt - less than (test A < B)
++# gt - greater than (test A > B)
++#
++# Additionally, the eq and ne operator can have a number after it to limit
++# the test to that number of minor versions.
++#
++# eq0 - equal up to the length of the shorter version
++# ne0 - not equal up to the length of the shorter version
++# eqN - equal up to N sub-version levels
++# neN - not equal up to N sub-version levels
++#
++# When the condition is true, shell commands ACTION-IF-TRUE are run,
++# otherwise shell commands ACTION-IF-FALSE are run. The environment
++# variable 'ax_compare_version' is always set to either 'true' or 'false'
++# as well.
++#
++# Examples:
++#
++# AX_COMPARE_VERSION([3.15.7],[lt],[3.15.8])
++# AX_COMPARE_VERSION([3.15],[lt],[3.15.8])
++#
++# would both be true.
++#
++# AX_COMPARE_VERSION([3.15.7],[eq],[3.15.8])
++# AX_COMPARE_VERSION([3.15],[gt],[3.15.8])
++#
++# would both be false.
++#
++# AX_COMPARE_VERSION([3.15.7],[eq2],[3.15.8])
++#
++# would be true because it is only comparing two minor versions.
++#
++# AX_COMPARE_VERSION([3.15.7],[eq0],[3.15])
++#
++# would be true because it is only comparing the lesser number of minor
++# versions of the two values.
++#
++# Note: The characters that separate the version numbers do not matter. An
++# empty string is the same as version 0. OP is evaluated by autoconf, not
++# configure, so must be a string, not a variable.
++#
++# The author would like to acknowledge Guido Draheim whose advice about
++# the m4_case and m4_ifvaln functions make this macro only include the
++# portions necessary to perform the specific comparison specified by the
++# OP argument in the final configure script.
++#
++# LICENSE
++#
++# Copyright (c) 2008 Tim Toolan <toolan@ele.uri.edu>
++#
++# Copying and distribution of this file, with or without modification, are
++# permitted in any medium without royalty provided the copyright notice
++# and this notice are preserved. This file is offered as-is, without any
++# warranty.
++
++#serial 13
++
++dnl #########################################################################
++AC_DEFUN([AX_COMPARE_VERSION], [
++ AC_REQUIRE([AC_PROG_AWK])
++
++ # Used to indicate true or false condition
++ ax_compare_version=false
++
++ # Convert the two version strings to be compared into a format that
++ # allows a simple string comparison. The end result is that a version
++ # string of the form 1.12.5-r617 will be converted to the form
++ # 0001001200050617. In other words, each number is zero padded to four
++ # digits, and non digits are removed.
++ AS_VAR_PUSHDEF([A],[ax_compare_version_A])
++ A=`echo "$1" | sed -e 's/\([[0-9]]*\)/Z\1Z/g' \
++ -e 's/Z\([[0-9]]\)Z/Z0\1Z/g' \
++ -e 's/Z\([[0-9]][[0-9]]\)Z/Z0\1Z/g' \
++ -e 's/Z\([[0-9]][[0-9]][[0-9]]\)Z/Z0\1Z/g' \
++ -e 's/[[^0-9]]//g'`
++
++ AS_VAR_PUSHDEF([B],[ax_compare_version_B])
++ B=`echo "$3" | sed -e 's/\([[0-9]]*\)/Z\1Z/g' \
++ -e 's/Z\([[0-9]]\)Z/Z0\1Z/g' \
++ -e 's/Z\([[0-9]][[0-9]]\)Z/Z0\1Z/g' \
++ -e 's/Z\([[0-9]][[0-9]][[0-9]]\)Z/Z0\1Z/g' \
++ -e 's/[[^0-9]]//g'`
++
++ dnl # In the case of le, ge, lt, and gt, the strings are sorted as necessary
++ dnl # then the first line is used to determine if the condition is true.
++ dnl # The sed right after the echo is to remove any indented white space.
++ m4_case(m4_tolower($2),
++ [lt],[
++ ax_compare_version=`echo "x$A
++x$B" | sed 's/^ *//' | sort -r | sed "s/x${A}/false/;s/x${B}/true/;1q"`
++ ],
++ [gt],[
++ ax_compare_version=`echo "x$A
++x$B" | sed 's/^ *//' | sort | sed "s/x${A}/false/;s/x${B}/true/;1q"`
++ ],
++ [le],[
++ ax_compare_version=`echo "x$A
++x$B" | sed 's/^ *//' | sort | sed "s/x${A}/true/;s/x${B}/false/;1q"`
++ ],
++ [ge],[
++ ax_compare_version=`echo "x$A
++x$B" | sed 's/^ *//' | sort -r | sed "s/x${A}/true/;s/x${B}/false/;1q"`
++ ],[
++ dnl Split the operator from the subversion count if present.
++ m4_bmatch(m4_substr($2,2),
++ [0],[
++ # A count of zero means use the length of the shorter version.
++ # Determine the number of characters in A and B.
++ ax_compare_version_len_A=`echo "$A" | $AWK '{print(length)}'`
++ ax_compare_version_len_B=`echo "$B" | $AWK '{print(length)}'`
++
++ # Set A to no more than B's length and B to no more than A's length.
++ A=`echo "$A" | sed "s/\(.\{$ax_compare_version_len_B\}\).*/\1/"`
++ B=`echo "$B" | sed "s/\(.\{$ax_compare_version_len_A\}\).*/\1/"`
++ ],
++ [[0-9]+],[
++ # A count greater than zero means use only that many subversions
++ A=`echo "$A" | sed "s/\(\([[0-9]]\{4\}\)\{m4_substr($2,2)\}\).*/\1/"`
++ B=`echo "$B" | sed "s/\(\([[0-9]]\{4\}\)\{m4_substr($2,2)\}\).*/\1/"`
++ ],
++ [.+],[
++ AC_WARNING(
++ [invalid OP numeric parameter: $2])
++ ],[])
++
++ # Pad zeros at end of numbers to make same length.
++ ax_compare_version_tmp_A="$A`echo $B | sed 's/./0/g'`"
++ B="$B`echo $A | sed 's/./0/g'`"
++ A="$ax_compare_version_tmp_A"
++
++ # Check for equality or inequality as necessary.
++ m4_case(m4_tolower(m4_substr($2,0,2)),
++ [eq],[
++ test "x$A" = "x$B" && ax_compare_version=true
++ ],
++ [ne],[
++ test "x$A" != "x$B" && ax_compare_version=true
++ ],[
++ AC_WARNING([invalid OP parameter: $2])
++ ])
++ ])
++
++ AS_VAR_POPDEF([A])dnl
++ AS_VAR_POPDEF([B])dnl
++
++ dnl # Execute ACTION-IF-TRUE / ACTION-IF-FALSE.
++ if test "$ax_compare_version" = "true" ; then
++ m4_ifvaln([$4],[$4],[:])dnl
++ m4_ifvaln([$5],[else $5])dnl
++ fi
++]) dnl AX_COMPARE_VERSION
+diff --git a/config/kernel.m4 b/config/kernel.m4
+index e3f8645774c5..a3f8efc48e88 100644
+--- a/config/kernel.m4
++++ b/config/kernel.m4
+@@ -497,10 +497,39 @@ AC_DEFUN([ZFS_AC_KERNEL], [
+
+ AC_MSG_RESULT([$kernsrcver])
+
+- AS_VERSION_COMPARE([$kernsrcver], [$ZFS_META_KVER_MIN], [
+- AC_MSG_ERROR([
++ AC_ARG_ENABLE([supported-linux-version-check],
++ AS_HELP_STRING([--disable-supported-linux-version-check],
++ [Do not check if building against a supported Linux version]))
++
++ AX_COMPARE_VERSION([$kernsrcver], [ge], [$ZFS_META_KVER_MIN], [
++ kern_min_version_ok=yes
++ ], [
++ kern_min_version_ok=no
++ ])
++
++ AX_COMPARE_VERSION([$kernsrcver], [ge], [$ZFS_META_KVER_MAX], [
++ AX_COMPARE_VERSION([$kernsrcver], [eq2], [$ZFS_META_KVER_MAX], [
++ kern_max_version_ok=yes
++ ], [
++ kern_max_version_ok=no
++ ])
++ ], [
++ kern_max_version_ok=yes
++ ])
++
++ AS_IF([test "x$enable_supported_linux_version_check" != "xno"], [
++ AS_IF([test "x$kern_min_version_ok" != "xyes"], [
++ AC_MSG_ERROR([
+ *** Cannot build against kernel version $kernsrcver.
+ *** The minimum supported kernel version is $ZFS_META_KVER_MIN.
++ ])
++ ])
++
++ AS_IF([test "x$kern_max_version_ok" != "xyes"], [
++ AC_MSG_ERROR([
++ *** Cannot build against kernel version $kernsrcver.
++ *** The maximum supported kernel version is $ZFS_META_KVER_MAX.
++ ])
+ ])
+ ])
+
+@@ -513,6 +542,32 @@ AC_DEFUN([ZFS_AC_KERNEL], [
+ AC_SUBST(LINUX_VERSION)
+ ])
+
++AC_DEFUN([ZFS_AC_KERNEL_VERSION_WARNING], [
++ AS_IF([test "x$enable_supported_linux_version_check" = "xno"], [
++ AS_IF([test "x$kern_min_version_ok" != "xyes" || \
++ test "x$kern_max_version_ok" != "xyes"], [
++ AC_MSG_WARN([
++
++ You are building OpenZFS against Linux version $kernsrcver.
++
++ This combination IS NOT SUPPORTED by the OpenZFS project. Even if it
++ appears to build and run correctly, there may be bugs that can cause
++ SERIOUS DATA LOSS.
++
++ YOU HAVE BEEN WARNED!
++
++ If you choose to continue, we'd appreciate if you could report your
++ results on the OpenZFS issue tracker at:
++
++ https://github.com/openzfs/zfs/issues/new
++
++ Your feedback will help us prepare a new OpenZFS release that supports
++ this version of Linux.
++ ])
++ ])
++ ])
++])
++
+ dnl #
+ dnl # Detect the QAT module to be built against, QAT provides hardware
+ dnl # acceleration for data compression:
+diff --git a/configure.ac b/configure.ac
+index 2ce049c58219..9e043862ed1f 100644
+--- a/configure.ac
++++ b/configure.ac
+@@ -87,3 +87,5 @@ AC_CONFIG_FILES([
+
+
+ AC_OUTPUT
++
++ZFS_AC_KERNEL_VERSION_WARNING
diff --git a/kernel-6.8-meta.patch b/kernel-6.8-meta.patch
new file mode 100644
index 000000000000..34eeefac947a
--- /dev/null
+++ b/kernel-6.8-meta.patch
@@ -0,0 +1,9 @@
+--- a/META
++++ b/META
+@@ -6,5 +6,5 @@ Release: 1
+ Release-Tags: relext
+ License: CDDL
+ Author: OpenZFS
+-Linux-Maximum: 6.7
++Linux-Maximum: 6.8
+ Linux-Minimum: 3.10
diff --git a/linux-6.8-compat.patch b/linux-6.8-compat.patch
new file mode 100644
index 000000000000..0214c3b651a2
--- /dev/null
+++ b/linux-6.8-compat.patch
@@ -0,0 +1,130 @@
+From a24f6e17c8cf75b5f551eb43019d41747c08891f Mon Sep 17 00:00:00 2001
+From: Rob Norris <robn@despairlabs.com>
+Date: Sat, 24 Feb 2024 14:24:42 +1100
+Subject: [PATCH] Linux 6.8 compat: use splice_copy_file_range() for fallback
+
+Linux 6.8 removes generic_copy_file_range(), which had been reduced to a
+simple wrapper around splice_copy_file_range(). Detect that function
+directly and use it if generic_ is not available.
+
+Signed-off-by: Rob Norris <robn@despairlabs.com>
+Sponsored-by: https://despairlabs.com/sponsor/
+---
+ config/kernel-vfs-file_range.m4 | 27 +++++++++++++++++++++++++++
+ config/kernel.m4 | 2 ++
+ module/os/linux/zfs/zpl_file_range.c | 16 ++++++++++++++--
+ 3 files changed, 43 insertions(+), 2 deletions(-)
+
+diff --git a/config/kernel-vfs-file_range.m4 b/config/kernel-vfs-file_range.m4
+index cc96404d8bbe..8a5cbe2eeeed 100644
+--- a/config/kernel-vfs-file_range.m4
++++ b/config/kernel-vfs-file_range.m4
+@@ -16,6 +16,9 @@ dnl #
+ dnl # 5.3: VFS copy_file_range() expected to do its own fallback,
+ dnl # generic_copy_file_range() added to support it
+ dnl #
++dnl # 6.8: generic_copy_file_range() removed, replaced by
++dnl # splice_copy_file_range()
++dnl #
+ AC_DEFUN([ZFS_AC_KERNEL_SRC_VFS_COPY_FILE_RANGE], [
+ ZFS_LINUX_TEST_SRC([vfs_copy_file_range], [
+ #include <linux/fs.h>
+@@ -72,6 +75,30 @@ AC_DEFUN([ZFS_AC_KERNEL_VFS_GENERIC_COPY_FILE_RANGE], [
+ ])
+ ])
+
++AC_DEFUN([ZFS_AC_KERNEL_SRC_VFS_SPLICE_COPY_FILE_RANGE], [
++ ZFS_LINUX_TEST_SRC([splice_copy_file_range], [
++ #include <linux/splice.h>
++ ], [
++ struct file *src_file __attribute__ ((unused)) = NULL;
++ loff_t src_off __attribute__ ((unused)) = 0;
++ struct file *dst_file __attribute__ ((unused)) = NULL;
++ loff_t dst_off __attribute__ ((unused)) = 0;
++ size_t len __attribute__ ((unused)) = 0;
++ splice_copy_file_range(src_file, src_off, dst_file, dst_off,
++ len);
++ ])
++])
++AC_DEFUN([ZFS_AC_KERNEL_VFS_SPLICE_COPY_FILE_RANGE], [
++ AC_MSG_CHECKING([whether splice_copy_file_range() is available])
++ ZFS_LINUX_TEST_RESULT([splice_copy_file_range], [
++ AC_MSG_RESULT(yes)
++ AC_DEFINE(HAVE_VFS_SPLICE_COPY_FILE_RANGE, 1,
++ [splice_copy_file_range() is available])
++ ],[
++ AC_MSG_RESULT(no)
++ ])
++])
++
+ AC_DEFUN([ZFS_AC_KERNEL_SRC_VFS_CLONE_FILE_RANGE], [
+ ZFS_LINUX_TEST_SRC([vfs_clone_file_range], [
+ #include <linux/fs.h>
+diff --git a/config/kernel.m4 b/config/kernel.m4
+index e3f8645774c5..1d0c5a27fc7f 100644
+--- a/config/kernel.m4
++++ b/config/kernel.m4
+@@ -118,6 +118,7 @@ AC_DEFUN([ZFS_AC_KERNEL_TEST_SRC], [
+ ZFS_AC_KERNEL_SRC_VFS_IOV_ITER
+ ZFS_AC_KERNEL_SRC_VFS_COPY_FILE_RANGE
+ ZFS_AC_KERNEL_SRC_VFS_GENERIC_COPY_FILE_RANGE
++ ZFS_AC_KERNEL_SRC_VFS_SPLICE_COPY_FILE_RANGE
+ ZFS_AC_KERNEL_SRC_VFS_REMAP_FILE_RANGE
+ ZFS_AC_KERNEL_SRC_VFS_CLONE_FILE_RANGE
+ ZFS_AC_KERNEL_SRC_VFS_DEDUPE_FILE_RANGE
+@@ -266,6 +267,7 @@ AC_DEFUN([ZFS_AC_KERNEL_TEST_RESULT], [
+ ZFS_AC_KERNEL_VFS_IOV_ITER
+ ZFS_AC_KERNEL_VFS_COPY_FILE_RANGE
+ ZFS_AC_KERNEL_VFS_GENERIC_COPY_FILE_RANGE
++ ZFS_AC_KERNEL_VFS_SPLICE_COPY_FILE_RANGE
+ ZFS_AC_KERNEL_VFS_REMAP_FILE_RANGE
+ ZFS_AC_KERNEL_VFS_CLONE_FILE_RANGE
+ ZFS_AC_KERNEL_VFS_DEDUPE_FILE_RANGE
+diff --git a/module/os/linux/zfs/zpl_file_range.c b/module/os/linux/zfs/zpl_file_range.c
+index 3065d54fa9da..64728fdb1187 100644
+--- a/module/os/linux/zfs/zpl_file_range.c
++++ b/module/os/linux/zfs/zpl_file_range.c
+@@ -26,6 +26,9 @@
+ #include <linux/compat.h>
+ #endif
+ #include <linux/fs.h>
++#ifdef HAVE_VFS_SPLICE_COPY_FILE_RANGE
++#include <linux/splice.h>
++#endif
+ #include <sys/file.h>
+ #include <sys/zfs_znode.h>
+ #include <sys/zfs_vnops.h>
+@@ -102,7 +105,7 @@ zpl_copy_file_range(struct file *src_file, loff_t src_off,
+ ret = zpl_clone_file_range_impl(src_file, src_off,
+ dst_file, dst_off, len);
+
+-#ifdef HAVE_VFS_GENERIC_COPY_FILE_RANGE
++#if defined(HAVE_VFS_GENERIC_COPY_FILE_RANGE)
+ /*
+ * Since Linux 5.3 the filesystem driver is responsible for executing
+ * an appropriate fallback, and a generic fallback function is provided.
+@@ -111,6 +114,15 @@ zpl_copy_file_range(struct file *src_file, loff_t src_off,
+ ret == -EAGAIN)
+ ret = generic_copy_file_range(src_file, src_off, dst_file,
+ dst_off, len, flags);
++#elif defined(HAVE_VFS_SPLICE_COPY_FILE_RANGE)
++ /*
++ * Since 6.8 the fallback function is called splice_copy_file_range
++ * and has a slightly different signature.
++ */
++ if (ret == -EOPNOTSUPP || ret == -EINVAL || ret == -EXDEV ||
++ ret == -EAGAIN)
++ ret = splice_copy_file_range(src_file, src_off, dst_file,
++ dst_off, len);
+ #else
+ /*
+ * Before Linux 5.3 the filesystem has to return -EOPNOTSUPP to signal
+@@ -118,7 +130,7 @@ zpl_copy_file_range(struct file *src_file, loff_t src_off,
+ */
+ if (ret == -EINVAL || ret == -EXDEV || ret == -EAGAIN)
+ ret = -EOPNOTSUPP;
+-#endif /* HAVE_VFS_GENERIC_COPY_FILE_RANGE */
++#endif /* HAVE_VFS_GENERIC_COPY_FILE_RANGE || HAVE_VFS_SPLICE_COPY_FILE_RANGE */
+
+ return (ret);
+ } \ No newline at end of file