zfs_2_4: add FIDEDUPERANGE patch

Implements REMAP_FILE_DEDUP so userspace dedup tools can use
FIDEDUPERANGE for race-free compare-and-clone instead of getting
EOPNOTSUPP. Sent upstream.

Author: Mic92

pkgs/os-specific/linux/zfs/2_4.nix

@@ -25,6 +25,11 @@ callPackage ./generic.nix args {
     inherit (nixosTests.zfs) installer;
   };
 
+  extraPatches = [
+    # FIDEDUPERANGE support, sent upstream
+    ./fideduperange.patch
+  ];
+
   maintainers = with lib.maintainers; [
     adamcstephens
     amarshall

pkgs/os-specific/linux/zfs/fideduperange.patch

@@ -0,0 +1,215 @@
+From ed0fc9a36698667cbf2065059b31e06fc43ae309 Mon Sep 17 00:00:00 2001
+From: =?UTF-8?q?J=C3=B6rg=20Thalheim?= <joerg@thalheim.io>
+Date: Fri, 15 May 2026 10:51:24 +0200
+Subject: [PATCH 1/2] Linux: extract a locked clone helper from
+ zpl_clone_file_range_impl
+MIME-Version: 1.0
+Content-Type: text/plain; charset=UTF-8
+Content-Transfer-Encoding: 8bit
+
+Pull the block-cloning capability check and the zfs_clone_range() call
+into separate helpers, leaving zpl_clone_file_range_impl() as a thin
+wrapper that only takes the inode locks. No behavior change.
+
+A FIDEDUPERANGE implementation will need to take its own locks across
+both a compare and a clone, so it cannot reuse a helper that locks
+internally.
+
+Signed-off-by: Joerg Thalheim <joerg@thalheim.io>
+Signed-off-by: Jörg Thalheim <joerg@thalheim.io>
+---
+ module/os/linux/zfs/zpl_file_range.c | 57 ++++++++++++++++++----------
+ 1 file changed, 38 insertions(+), 19 deletions(-)
+
+diff --git a/module/os/linux/zfs/zpl_file_range.c b/module/os/linux/zfs/zpl_file_range.c
+index c40dde046..61a2214e5 100644
+--- a/module/os/linux/zfs/zpl_file_range.c
++++ b/module/os/linux/zfs/zpl_file_range.c
+@@ -36,17 +36,16 @@
+ #include <sys/zfeature.h>
+ 
+ /*
+- * Clone part of a file via block cloning.
++ * Clone part of a file via block cloning. Both inodes must already be
++ * locked by the caller.
+  *
+  * Note that we are not required to update file offsets; the kernel will take
+  * care of that depending on how it was called.
+  */
+ static ssize_t
+-zpl_clone_file_range_impl(struct file *src_file, loff_t src_off,
+-    struct file *dst_file, loff_t dst_off, size_t len)
++zpl_clone_file_range_locked(struct inode *src_i, loff_t src_off,
++    struct inode *dst_i, loff_t dst_off, size_t len)
+ {
+-	struct inode *src_i = file_inode(src_file);
+-	struct inode *dst_i = file_inode(dst_file);
+ 	uint64_t src_off_o = (uint64_t)src_off;
+ 	uint64_t dst_off_o = (uint64_t)dst_off;
+ 	uint64_t len_o = (uint64_t)len;
+@@ -54,34 +53,54 @@ zpl_clone_file_range_impl(struct file *src_file, loff_t src_off,
+ 	fstrans_cookie_t cookie;
+ 	int err;
+ 
+-	if (!zfs_bclone_enabled)
+-		return (-EOPNOTSUPP);
++	crhold(cr);
++	cookie = spl_fstrans_mark();
++
++	err = -zfs_clone_range(ITOZ(src_i), &src_off_o, ITOZ(dst_i),
++	    &dst_off_o, &len_o, cr);
+ 
++	spl_fstrans_unmark(cookie);
++	crfree(cr);
++
++	if (err < 0)
++		return (err);
++
++	return ((ssize_t)len_o);
++}
++
++static boolean_t
++zpl_clone_supported(struct inode *dst_i)
++{
++	if (!zfs_bclone_enabled)
++		return (B_FALSE);
+ 	if (!spa_feature_is_enabled(
+ 	    dmu_objset_spa(ITOZSB(dst_i)->z_os), SPA_FEATURE_BLOCK_CLONING))
++		return (B_FALSE);
++	return (B_TRUE);
++}
++
++static ssize_t
++zpl_clone_file_range_impl(struct file *src_file, loff_t src_off,
++    struct file *dst_file, loff_t dst_off, size_t len)
++{
++	struct inode *src_i = file_inode(src_file);
++	struct inode *dst_i = file_inode(dst_file);
++	ssize_t ret;
++
++	if (!zpl_clone_supported(dst_i))
+ 		return (-EOPNOTSUPP);
+ 
+ 	if (src_i != dst_i)
+ 		spl_inode_lock_shared(src_i);
+ 	spl_inode_lock(dst_i);
+ 
+-	crhold(cr);
+-	cookie = spl_fstrans_mark();
+-
+-	err = -zfs_clone_range(ITOZ(src_i), &src_off_o, ITOZ(dst_i),
+-	    &dst_off_o, &len_o, cr);
+-
+-	spl_fstrans_unmark(cookie);
+-	crfree(cr);
++	ret = zpl_clone_file_range_locked(src_i, src_off, dst_i, dst_off, len);
+ 
+ 	spl_inode_unlock(dst_i);
+ 	if (src_i != dst_i)
+ 		spl_inode_unlock_shared(src_i);
+ 
+-	if (err < 0)
+-		return (err);
+-
+-	return ((ssize_t)len_o);
++	return (ret);
+ }
+ 
+ /*
+-- 
+2.53.0
+
+
+From 078d462cc49907e00dad1da85cc72a41043a1499 Mon Sep 17 00:00:00 2001
+From: =?UTF-8?q?J=C3=B6rg=20Thalheim?= <joerg@thalheim.io>
+Date: Fri, 15 May 2026 10:51:29 +0200
+Subject: [PATCH 2/2] Linux: implement REMAP_FILE_DEDUP (FIDEDUPERANGE)
+MIME-Version: 1.0
+Content-Type: text/plain; charset=UTF-8
+Content-Transfer-Encoding: 8bit
+
+ZFS only handled FICLONE/FICLONERANGE; REMAP_FILE_DEDUP returned
+EOPNOTSUPP. Userspace dedup tools therefore had to compare ranges
+themselves and call FICLONERANGE, leaving a window between compare
+and clone where a concurrent write is silently lost.
+
+Hold both inodes locked, let generic_remap_file_range_prep() do the
+page-cache compare via zpl_read_folio(), and call zfs_clone_range()
+without dropping the locks. zfs_clone_range() still rejects ranges
+that are not blocksize-aligned, as it does for FICLONERANGE.
+
+lock_two_nondirectories() orders the inode locks by address so
+concurrent A<->B dedup operations cannot deadlock.
+
+Signed-off-by: Joerg Thalheim <joerg@thalheim.io>
+Signed-off-by: Jörg Thalheim <joerg@thalheim.io>
+---
+ module/os/linux/zfs/zpl_file_range.c | 44 ++++++++++++++++++++++++++--
+ 1 file changed, 42 insertions(+), 2 deletions(-)
+
+diff --git a/module/os/linux/zfs/zpl_file_range.c b/module/os/linux/zfs/zpl_file_range.c
+index 61a2214e5..142f91458 100644
+--- a/module/os/linux/zfs/zpl_file_range.c
++++ b/module/os/linux/zfs/zpl_file_range.c
+@@ -103,6 +103,46 @@ zpl_clone_file_range_impl(struct file *src_file, loff_t src_off,
+ 	return (ret);
+ }
+ 
++#ifdef HAVE_VFS_REMAP_FILE_RANGE
++/*
++ * FIDEDUPERANGE: clone src over dst only if the ranges are byte-identical.
++ * generic_remap_file_range_prep() does the compare via the page cache;
++ * both inodes stay locked across compare and clone to exclude writers.
++ */
++static loff_t
++zpl_dedupe_file_range_impl(struct file *src_file, loff_t src_off,
++    struct file *dst_file, loff_t dst_off, loff_t len, unsigned int flags)
++{
++	struct inode *src_i = file_inode(src_file);
++	struct inode *dst_i = file_inode(dst_file);
++	loff_t ret;
++
++	if (!zpl_clone_supported(dst_i))
++		return (-EOPNOTSUPP);
++
++	/*
++	 * vfs_dedupe_file_range_one() ensures src and dst share a
++	 * superblock (same dataset) but does not lock the inodes.
++	 * lock_two_nondirectories() orders by address so concurrent
++	 * A<->B dedup ops cannot ABBA-deadlock.
++	 */
++	lock_two_nondirectories(src_i, dst_i);
++
++	ret = generic_remap_file_range_prep(src_file, src_off, dst_file,
++	    dst_off, &len, flags);
++	if (ret < 0 || len == 0)
++		goto out;
++
++	ret = zpl_clone_file_range_locked(src_i, src_off, dst_i, dst_off,
++	    len);
++
++out:
++	unlock_two_nondirectories(src_i, dst_i);
++
++	return (ret);
++}
++#endif /* HAVE_VFS_REMAP_FILE_RANGE */
++
+ /*
+  * Entry point for copy_file_range(). Copy len bytes from src_off in src_file
+  * to dst_off in dst_file. We are permitted to do this however we like, so we
+@@ -178,9 +218,9 @@ zpl_remap_file_range(struct file *src_file, loff_t src_off,
+ 	if (flags & ~(REMAP_FILE_DEDUP | REMAP_FILE_CAN_SHORTEN))
+ 		return (-EINVAL);
+ 
+-	/* No support for dedup yet */
+ 	if (flags & REMAP_FILE_DEDUP)
+-		return (-EOPNOTSUPP);
++		return (zpl_dedupe_file_range_impl(src_file, src_off,
++		    dst_file, dst_off, len, flags));
+ 
+ 	/* Zero length means to clone everything to the end of the file */
+ 	if (len == 0)
+-- 
+2.53.0
+