4 * The contents of this file are subject to the terms of the
5 * Common Development and Distribution License (the "License").
6 * You may not use this file except in compliance with the License.
8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9 * or https://opensource.org/licenses/CDDL-1.0.
10 * See the License for the specific language governing permissions
11 * and limitations under the License.
13 * When distributing Covered Code, include this CDDL HEADER in each
14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15 * If applicable, add the following below this CDDL HEADER, with the
16 * fields enclosed by brackets "[]" replaced with your own identifying
17 * information: Portions Copyright [yyyy] [name of copyright owner]
22 * Copyright (c) 2023, Klara Inc.
26 #include <linux/compat.h>
30 #include <sys/zfs_znode.h>
31 #include <sys/zfs_vnops.h>
32 #include <sys/zfeature.h>
35 * Clone part of a file via block cloning.
37 * Note that we are not required to update file offsets; the kernel will take
38 * care of that depending on how it was called.
41 __zpl_clone_file_range(struct file
*src_file
, loff_t src_off
,
42 struct file
*dst_file
, loff_t dst_off
, size_t len
)
44 struct inode
*src_i
= file_inode(src_file
);
45 struct inode
*dst_i
= file_inode(dst_file
);
46 uint64_t src_off_o
= (uint64_t)src_off
;
47 uint64_t dst_off_o
= (uint64_t)dst_off
;
48 uint64_t len_o
= (uint64_t)len
;
50 fstrans_cookie_t cookie
;
53 if (!spa_feature_is_enabled(
54 dmu_objset_spa(ITOZSB(dst_i
)->z_os
), SPA_FEATURE_BLOCK_CLONING
))
58 spl_inode_lock_shared(src_i
);
59 spl_inode_lock(dst_i
);
62 cookie
= spl_fstrans_mark();
64 err
= -zfs_clone_range(ITOZ(src_i
), &src_off_o
, ITOZ(dst_i
),
65 &dst_off_o
, &len_o
, cr
);
67 spl_fstrans_unmark(cookie
);
70 spl_inode_unlock(dst_i
);
72 spl_inode_unlock_shared(src_i
);
77 return ((ssize_t
)len_o
);
80 #if defined(HAVE_VFS_COPY_FILE_RANGE) || \
81 defined(HAVE_VFS_FILE_OPERATIONS_EXTEND)
83 * Entry point for copy_file_range(). Copy len bytes from src_off in src_file
84 * to dst_off in dst_file. We are permitted to do this however we like, so we
85 * try to just clone the blocks, and if we can't support it, fall back to the
86 * kernel's generic byte copy function.
89 zpl_copy_file_range(struct file
*src_file
, loff_t src_off
,
90 struct file
*dst_file
, loff_t dst_off
, size_t len
, unsigned int flags
)
97 /* Try to do it via zfs_clone_range() */
98 ret
= __zpl_clone_file_range(src_file
, src_off
,
99 dst_file
, dst_off
, len
);
101 #ifdef HAVE_VFS_GENERIC_COPY_FILE_RANGE
103 * Since Linux 5.3 the filesystem driver is responsible for executing
104 * an appropriate fallback, and a generic fallback function is provided.
106 if (ret
== -EOPNOTSUPP
|| ret
== -EXDEV
)
107 ret
= generic_copy_file_range(src_file
, src_off
, dst_file
,
108 dst_off
, len
, flags
);
111 * Before Linux 5.3 the filesystem has to return -EOPNOTSUPP to signal
112 * to the kernel that it should fallback to a content copy.
116 #endif /* HAVE_VFS_GENERIC_COPY_FILE_RANGE */
120 #endif /* HAVE_VFS_COPY_FILE_RANGE || HAVE_VFS_FILE_OPERATIONS_EXTEND */
122 #ifdef HAVE_VFS_REMAP_FILE_RANGE
124 * Entry point for FICLONE/FICLONERANGE/FIDEDUPERANGE.
126 * FICLONE and FICLONERANGE are basically the same as copy_file_range(), except
127 * that they must clone - they cannot fall back to copying. FICLONE is exactly
128 * FICLONERANGE, for the entire file. We don't need to try to tell them apart;
129 * the kernel will sort that out for us.
131 * FIDEDUPERANGE is for turning a non-clone into a clone, that is, compare the
132 * range in both files and if they're the same, arrange for them to be backed
133 * by the same storage.
136 zpl_remap_file_range(struct file
*src_file
, loff_t src_off
,
137 struct file
*dst_file
, loff_t dst_off
, loff_t len
, unsigned int flags
)
139 if (flags
& ~(REMAP_FILE_DEDUP
| REMAP_FILE_CAN_SHORTEN
))
143 * REMAP_FILE_CAN_SHORTEN lets us know we can clone less than the given
144 * range if we want. Its designed for filesystems that make data past
145 * EOF available, and don't want it to be visible in both files. ZFS
146 * doesn't do that, so we just turn the flag off.
148 flags
&= ~REMAP_FILE_CAN_SHORTEN
;
150 if (flags
& REMAP_FILE_DEDUP
)
151 /* No support for dedup yet */
152 return (-EOPNOTSUPP
);
154 /* Zero length means to clone everything to the end of the file */
156 len
= i_size_read(file_inode(src_file
)) - src_off
;
158 return (__zpl_clone_file_range(src_file
, src_off
,
159 dst_file
, dst_off
, len
));
161 #endif /* HAVE_VFS_REMAP_FILE_RANGE */
163 #if defined(HAVE_VFS_CLONE_FILE_RANGE) || \
164 defined(HAVE_VFS_FILE_OPERATIONS_EXTEND)
166 * Entry point for FICLONE and FICLONERANGE, before Linux 4.20.
169 zpl_clone_file_range(struct file
*src_file
, loff_t src_off
,
170 struct file
*dst_file
, loff_t dst_off
, uint64_t len
)
172 /* Zero length means to clone everything to the end of the file */
174 len
= i_size_read(file_inode(src_file
)) - src_off
;
176 return (__zpl_clone_file_range(src_file
, src_off
,
177 dst_file
, dst_off
, len
));
179 #endif /* HAVE_VFS_CLONE_FILE_RANGE || HAVE_VFS_FILE_OPERATIONS_EXTEND */
181 #ifdef HAVE_VFS_DEDUPE_FILE_RANGE
183 * Entry point for FIDEDUPERANGE, before Linux 4.20.
186 zpl_dedupe_file_range(struct file
*src_file
, loff_t src_off
,
187 struct file
*dst_file
, loff_t dst_off
, uint64_t len
)
189 /* No support for dedup yet */
190 return (-EOPNOTSUPP
);
192 #endif /* HAVE_VFS_DEDUPE_FILE_RANGE */
194 /* Entry point for FICLONE, before Linux 4.5. */
196 zpl_ioctl_ficlone(struct file
*dst_file
, void *arg
)
198 unsigned long sfd
= (unsigned long)arg
;
200 struct file
*src_file
= fget(sfd
);
201 if (src_file
== NULL
)
204 if (dst_file
->f_op
!= src_file
->f_op
)
207 size_t len
= i_size_read(file_inode(src_file
));
210 __zpl_clone_file_range(src_file
, 0, dst_file
, 0, len
);
215 if (ret
== -EOPNOTSUPP
)
226 /* Entry point for FICLONERANGE, before Linux 4.5. */
228 zpl_ioctl_ficlonerange(struct file
*dst_file
, void __user
*arg
)
230 zfs_ioc_compat_file_clone_range_t fcr
;
232 if (copy_from_user(&fcr
, arg
, sizeof (fcr
)))
235 struct file
*src_file
= fget(fcr
.fcr_src_fd
);
236 if (src_file
== NULL
)
239 if (dst_file
->f_op
!= src_file
->f_op
)
242 size_t len
= fcr
.fcr_src_length
;
244 len
= i_size_read(file_inode(src_file
)) - fcr
.fcr_src_offset
;
246 ssize_t ret
= __zpl_clone_file_range(src_file
, fcr
.fcr_src_offset
,
247 dst_file
, fcr
.fcr_dest_offset
, len
);
252 if (ret
== -EOPNOTSUPP
)
263 /* Entry point for FIDEDUPERANGE, before Linux 4.5. */
265 zpl_ioctl_fideduperange(struct file
*filp
, void *arg
)
269 /* No support for dedup yet */