Add generated flag to filesystem struct to block copy_file_range
Subsystems (11)
cover Add generated flag to filesystem struct to block copy_file_range
We hit an issue when upgrading Go compiler from 1.13 to 1.15 [1], as we use Go's io.Copy to copy the content of /sys/kernel/debug/tracing/trace to a temporary file.
Under the hood, Go 1.15 uses copy_file_range syscall to optimize the copy operation. However, that fails to copy any content when the input file is from tracefs, with an apparent size of 0 (but there is still content when you cat it, of course).
From discussions in [2][3], it is clear that copy_file_range cannot be properly implemented on filesystems where the content is generated at runtime: the file size is incorrect (because it is unknown before the content is generated), and seeking in such files (as required by partial writes) is unlikely to work correctly.
With this patch, Go's io.Copy gracefully falls back to a normal read/write file copy.
I'm not 100% sure which stable tree this should go in, I'd say at least >=5.3 since this is what introduced support for cross-filesystem copy_file_range (and where most users are somewhat likely to hit this issue). But let's discuss the patch series first.
[1] http://issuetracker.google.com/issues/178332739
[2] https://lkml.org/lkml/2021/1/25/64
[3] https://lkml.org/lkml/2021/1/26/1736
Nicolas Boichat (6):
fs: Add flag to file_system_type to indicate content is generated
proc: Add FS_GENERATED_CONTENT to filesystem flags
sysfs: Add FS_GENERATED_CONTENT to filesystem flags
debugfs: Add FS_GENERATED_CONTENT to filesystem flags
tracefs: Add FS_GENERATED_CONTENT to filesystem flags
vfs: Disallow copy_file_range on generated file systems
fs/debugfs/inode.c | 1 + fs/proc/root.c | 2 +- fs/read_write.c | 3 +++ fs/sysfs/mount.c | 2 +- fs/tracefs/inode.c | 1 + include/linux/fs.h | 1 + 6 files changed, 8 insertions(+), 2 deletions(-)
Signature · 1 line
2.30.0.478.g8a0d178c01-goog
PATCH 1/6 fs: Add flag to file_system_type to indicate content is generated
Filesystems such as procfs and sysfs generate their content at runtime. This implies the file sizes do not usually match the amount of data that can be read from the file, and that seeking may not work as intended.
This will be useful to disallow copy_file_range with input files from such filesystems.
---
I first thought of adding a new field to struct file_operations, but that doesn't quite scale as every single file creation operation would need to be modified.
include/linux/fs.h | 1 + 1 file changed, 1 insertion(+)
include/linux/fs.h +1 -0
@@ -2335,6 +2335,7 @@ struct file_system_type {#define FS_ALLOW_IDMAP 32/* FS has been updated to handle vfs idmappings. */ #define FS_THP_SUPPORT 8192/* Remove once all fs converted */ #define FS_RENAME_DOES_D_MOVE 32768/* FS will handle d_move() during rename() internally. */ +#define FS_GENERATED_CONTENT 65536/* FS contains generated content */ int (*init_fs_context)(struct fs_context *);const struct fs_parameter_spec *parameters; struct dentry *(*mount) (struct file_system_type *, int,
Signature · 1 line
2.30.0.478.g8a0d178c01-goog
Greg KH
maintainerRe: [PATCH 1/6] fs: Add flag to file_system_type to indicate content is generated
Quoted 5 lines · Nicolas Boichat
Filesystems such as procfs and sysfs generate their content at runtime. This implies the file sizes do not usually match the amount of data that can be read from the file, and that seeking may not work as intended.
Quoted 8 lines
This will be useful to disallow
copy_file_rangewith input files from such filesystems.Signed-off-by Nicolas Boichat <[email protected]>---
I first thought of adding a new field to structfile_operations, but that doesn't quite scale as every single file creation operation would need to be modified.
Even so, you missed a load of filesystems in the kernel with this patch series, what makes the ones you did mark here different from the "internal" filesystems that you did not?
This feels wrong, why is userspace suddenly breaking? What changed in the kernel that caused this? Procfs has been around for a _very_ long time :)
thanks,
greg k-h
Re: [PATCH 1/6] fs: Add flag to file_system_type to indicate content is generated
Quoted 16 lines · Greg KH
Quoted 5 lines · Nicolas Boichat
Filesystems such as procfs and sysfs generate their content at runtime. This implies the file sizes do not usually match the amount of data that can be read from the file, and that seeking may not work as intended.
Quoted 8 lines
This will be useful to disallow
copy_file_rangewith input files from such filesystems.Signed-off-by Nicolas Boichat <[email protected]>---
I first thought of adding a new field to structfile_operations, but that doesn't quite scale as every single file creation operation would need to be modified.
Quoted 3 lines
Even so, you missed a load of filesystems in the kernel with this patch series, what makes the ones you did mark here different from the "internal" filesystems that you did not?
Which ones did I miss? (apart from configfs, see the conversation on patch 6/6). Anyway, hopefully auditing all filesystems is an order of magnitude easier task, and easier to maintain in the longer run ,-)
Quoted 3 lines
This feels wrong, why is userspace suddenly breaking? What changed in the kernel that caused this? Procfs has been around for a _very_ long time :)
Some of this is covered in the cover letter 0/6. To expand a bit:copy_file_range has only supported cross-filesystem copies since 5.3 [1], before that the kernel would return EXDEV and userspace application would fall back to a read/write based copy. After 5.3, copy_file_range copies no data as it thinks the input file is empty.
[1] I think it makes little sense to try to use copy_file_range between 2 files in /proc, but technically, I think that has been broken since copy_file_range fallback to do_splice_direct was introduced (eac70053a141 ("vfs: Add vfs_copy_file_range() support for pagecache copies", ~4.4).
Quoted 4 lines
thanks,
greg k-h
Greg KH
maintainerRe: [PATCH 1/6] fs: Add flag to file_system_type to indicate content is generated
Quoted 17 lines · Nicolas Boichat
Quoted 16 lines · Greg KH
Quoted 13 lines · Nicolas Boichat
Filesystems such as procfs and sysfs generate their content at runtime. This implies the file sizes do not usually match the amount of data that can be read from the file, and that seeking may not work as intended.
This will be useful to disallow
copy_file_rangewith input files from such filesystems.Signed-off-by Nicolas Boichat <[email protected]>---
I first thought of adding a new field to structfile_operations, but that doesn't quite scale as every single file creation operation would need to be modified.
Quoted 7 lines
Quoted 3 lines
Even so, you missed a load of filesystems in the kernel with this patch series, what makes the ones you did mark here different from the "internal" filesystems that you did not?
Which ones did I miss? (apart from configfs, see the conversation on patch 6/6). Anyway, hopefully auditing all filesystems is an order of magnitude easier task, and easier to maintain in the longer run ,-)
Are you going to be the one to add this to each new filesystem that is added to the kernel?
I see filesystems in drivers/char/mem.c and drivers/infiniband/hw/qib/qib_fs.c and drivers/misc/ibmasm/ibmasmfs.c and loads of other driver-specific filesystems. Do all of those "just work" somehow?
Quoted 9 lines
Quoted 3 lines
This feels wrong, why is userspace suddenly breaking? What changed in the kernel that caused this? Procfs has been around for a _very_ long time :)
Some of this is covered in the cover letter 0/6. To expand a bit:
copy_file_rangehas only supported cross-filesystem copies since 5.3 [1], before that the kernel would return EXDEV and userspace application would fall back to a read/write based copy. After 5.3,copy_file_rangecopies no data as it thinks the input file is empty.
So older kernels work fine with this system call on procfs, but newer ones do not? If so, that's a regression that should be fixed in the original area, but should not require a new filesystem flag for every individual one out there. That way lies madness and constant auditing that I do not see anyone signing up for for the next 20 years, right?
Quoted 5 lines
[1] I think it makes little sense to try to use
copy_file_rangebetween 2 files in /proc, but technically, I think that has been broken sincecopy_file_rangefallback todo_splice_directwas introduced (eac70053a141("vfs: Addvfs_copy_file_range()support for pagecache copies", ~4.4).
Why are people trying to use copy_file_range on simple /proc and /sys files in the first place? They can not seek (well most can not), so that feels like a "oh look, a new syscall, let's use it everywhere!" problem that userspace should not do.
thanks,
greg k-h
Re: [PATCH 1/6] fs: Add flag to file_system_type to indicate content is generated
Quoted 5 lines · Greg KH
Why are people trying to use
copy_file_rangeon simple /proc and /sys files in the first place? They can not seek (well most can not), so that feels like a "oh look, a new syscall, let's use it everywhere!" problem that userspace should not do.
This may have been covered elsewhere, but it's not that people are saying "let's use copy_file_range on files in /proc." It's that the Go language standard library provides an interface to operating system files. When Go code uses the standard library function io.Copy to copy the contents of one open file to another open file, then on Linux kernels 5.3 and greater the Go standard library will use the copy_file_range system call. That seems to be exactly what copy_file_range is intended for. Unfortunately it appears that when people writing Go code open a file in /proc and use io.Copy the contents to another open file, copy_file_range does nothing and reports success. There isn't anything on the copy_file_range man page explaining this limitation, and there isn't any documented way to know that the Go standard library should not use copy_file_range on certain files.
So ideally the kernel will report EOPNOTSUPP or EINVAL when using copy_file_range on a file in /proc or some other file system that fails (and, minor side note, the copy_file_range man page should document that it can return EOPNOTSUPP or EINVAL in some cases, which does already happen on at least some kernel versions using at least some file systems). Or, less ideally, there will be some documented way that the Go standard library can determine that copy_file_range will fail before trying to use it. If neither of those can be done, then I think the only option is for the Go standard library to never use copy_file_range, as even though it will almost always work and work well, in some unpredictable number of cases it will fail silently.
Thanks.
Ian
Greg KH
maintainerRe: [PATCH 1/6] fs: Add flag to file_system_type to indicate content is generated
Quoted 7 lines · Ian Lance Taylor
Quoted 5 lines · Greg KH
Why are people trying to use
copy_file_rangeon simple /proc and /sys files in the first place? They can not seek (well most can not), so that feels like a "oh look, a new syscall, let's use it everywhere!" problem that userspace should not do.
Quoted 14 lines
This may have been covered elsewhere, but it's not that people are saying "let's use
copy_file_rangeon files in /proc." It's that the Go language standard library provides an interface to operating system files. When Go code uses the standard library function io.Copy to copy the contents of one open file to another open file, then on Linux kernels 5.3 and greater the Go standard library will use thecopy_file_rangesystem call. That seems to be exactly whatcopy_file_rangeis intended for. Unfortunately it appears that when people writing Go code open a file in /proc and use io.Copy the contents to another open file,copy_file_rangedoes nothing and reports success. There isn't anything on thecopy_file_rangeman page explaining this limitation, and there isn't any documented way to know that the Go standard library should not usecopy_file_rangeon certain files.
But, is this a bug in the kernel in that the syscall being made is not working properly, or a bug in that Go decided to do this for all types of files not knowing that some types of files can not handle this?
If the kernel has always worked this way, I would say that Go is doing the wrong thing here. If the kernel used to work properly, and then changed, then it's a regression on the kernel side.
So which is it?
Quoted 6 lines
So ideally the kernel will report EOPNOTSUPP or EINVAL when using
copy_file_rangeon a file in /proc or some other file system that fails (and, minor side note, thecopy_file_rangeman page should document that it can return EOPNOTSUPP or EINVAL in some cases, which does already happen on at least some kernel versions using at least some file systems).
Documentation is good, but what the kernel does is the true "definition" of what is going right or wrong here.
thanks,
greg k-h
Re: [PATCH 1/6] fs: Add flag to file_system_type to indicate content is generated
Quoted 28 lines · Greg KH
Quoted 7 lines · Ian Lance Taylor
Quoted 5 lines · Greg KH
Why are people trying to use
copy_file_rangeon simple /proc and /sys files in the first place? They can not seek (well most can not), so that feels like a "oh look, a new syscall, let's use it everywhere!" problem that userspace should not do.Quoted 14 lines
This may have been covered elsewhere, but it's not that people are saying "let's use
copy_file_rangeon files in /proc." It's that the Go language standard library provides an interface to operating system files. When Go code uses the standard library function io.Copy to copy the contents of one open file to another open file, then on Linux kernels 5.3 and greater the Go standard library will use thecopy_file_rangesystem call. That seems to be exactly whatcopy_file_rangeis intended for. Unfortunately it appears that when people writing Go code open a file in /proc and use io.Copy the contents to another open file,copy_file_rangedoes nothing and reports success. There isn't anything on thecopy_file_rangeman page explaining this limitation, and there isn't any documented way to know that the Go standard library should not usecopy_file_rangeon certain files.But, is this a bug in the kernel in that the syscall being made is not working properly, or a bug in that Go decided to do this for all types of files not knowing that some types of files can not handle this?
Quoted 5 lines
If the kernel has always worked this way, I would say that Go is doing the wrong thing here. If the kernel used to work properly, and then changed, then it's a regression on the kernel side.
So which is it?
I don't work on the kernel, so I can't tell you which it is. You will have to decide.
From my perspective, as a kernel user rather than a kernel developer, a system call that silently fails for certain files and that provides no way to determine either 1) ahead of time that the system call will fail, or 2) after the call that the system call did fail, is a useless system call. I can never use that system call, because I don't know whether or not it will work. So as a kernel user I would say that you should fix the system call to report failure, or document some way to know whether the system call will fail, or you should remove the system call. But I'm not a kernel developer, I don't have all the information, and it's obviously your call.
I'll note that to the best of my knowledge this failure started happening with the 5.3 kernel, as before 5.3 the problematic calls would report a failure (EXDEV). Since 5.3 isn't all that old I personally wouldn't say that the kernel "has always worked this way." But I may be mistaken about this.
Quoted 9 lines
Quoted 6 lines
So ideally the kernel will report EOPNOTSUPP or EINVAL when using
copy_file_rangeon a file in /proc or some other file system that fails (and, minor side note, thecopy_file_rangeman page should document that it can return EOPNOTSUPP or EINVAL in some cases, which does already happen on at least some kernel versions using at least some file systems).Documentation is good, but what the kernel does is the true "definition" of what is going right or wrong here.
Sure. The documentation comment was just a side note. I hope that we can all agree that accurate man pages are better than inaccurate ones.
Ian
Greg KH
maintainerRe: [PATCH 1/6] fs: Add flag to file_system_type to indicate content is generated
Quoted 29 lines · Ian Lance Taylor
Quoted 28 lines · Greg KH
Quoted 7 lines · Ian Lance Taylor
Quoted 5 lines · Greg KH
Why are people trying to use
copy_file_rangeon simple /proc and /sys files in the first place? They can not seek (well most can not), so that feels like a "oh look, a new syscall, let's use it everywhere!" problem that userspace should not do.Quoted 14 lines
This may have been covered elsewhere, but it's not that people are saying "let's use
copy_file_rangeon files in /proc." It's that the Go language standard library provides an interface to operating system files. When Go code uses the standard library function io.Copy to copy the contents of one open file to another open file, then on Linux kernels 5.3 and greater the Go standard library will use thecopy_file_rangesystem call. That seems to be exactly whatcopy_file_rangeis intended for. Unfortunately it appears that when people writing Go code open a file in /proc and use io.Copy the contents to another open file,copy_file_rangedoes nothing and reports success. There isn't anything on thecopy_file_rangeman page explaining this limitation, and there isn't any documented way to know that the Go standard library should not usecopy_file_rangeon certain files.But, is this a bug in the kernel in that the syscall being made is not working properly, or a bug in that Go decided to do this for all types of files not knowing that some types of files can not handle this?
Quoted 8 lines
Quoted 5 lines
If the kernel has always worked this way, I would say that Go is doing the wrong thing here. If the kernel used to work properly, and then changed, then it's a regression on the kernel side.
So which is it?
I don't work on the kernel, so I can't tell you which it is. You will have to decide.
As you have the userspace code, it should be easier for you to test this on an older kernel. I don't have your userspace code...
Quoted 5 lines
From my perspective, as a kernel user rather than a kernel developer, a system call that silently fails for certain files and that provides no way to determine either 1) ahead of time that the system call will fail, or 2) after the call that the system call did fail, is a useless system call.
Great, then don't use copy_file_range() yet as it seems like it fits that category at the moment :)
Quoted 6 lines
I can never use that system call, because I don't know whether or not it will work. So as a kernel user I would say that you should fix the system call to report failure, or document some way to know whether the system call will fail, or you should remove the system call. But I'm not a kernel developer, I don't have all the information, and it's obviously your call.
That's up to the authors of that syscall, I don't know what they intended this to be used for. It feels like you are using this in a very generic "all file i/o works for this" way, while that is not what the authors of the syscall intended it for, as is evident by the failures that older kernels would report for you.
Quoted 5 lines
I'll note that to the best of my knowledge this failure started happening with the 5.3 kernel, as before 5.3 the problematic calls would report a failure (EXDEV). Since 5.3 isn't all that old I personally wouldn't say that the kernel "has always worked this way." But I may be mistaken about this.
Testing would be good, as regressions are more serious than "it would be nice if it would work like this instead!" type of issues.
thanks,
greg k-h
Re: [PATCH 1/6] fs: Add flag to file_system_type to indicate content is generated
Quoted 35 lines · Greg KH
Quoted 33 lines · Ian Lance Taylor
Quoted 32 lines · Greg KH
Quoted 7 lines · Ian Lance Taylor
Quoted 5 lines · Greg KH
Why are people trying to use
copy_file_rangeon simple /proc and /sys files in the first place? They can not seek (well most can not), so that feels like a "oh look, a new syscall, let's use it everywhere!" problem that userspace should not do.Quoted 14 lines
This may have been covered elsewhere, but it's not that people are saying "let's use
copy_file_rangeon files in /proc." It's that the Go language standard library provides an interface to operating system files. When Go code uses the standard library function io.Copy to copy the contents of one open file to another open file, then on Linux kernels 5.3 and greater the Go standard library will use thecopy_file_rangesystem call. That seems to be exactly whatcopy_file_rangeis intended for. Unfortunately it appears that when people writing Go code open a file in /proc and use io.Copy the contents to another open file,copy_file_rangedoes nothing and reports success. There isn't anything on thecopy_file_rangeman page explaining this limitation, and there isn't any documented way to know that the Go standard library should not usecopy_file_rangeon certain files.But, is this a bug in the kernel in that the syscall being made is not working properly, or a bug in that Go decided to do this for all types of files not knowing that some types of files can not handle this?
If the kernel has always worked this way, I would say that Go is doing the wrong thing here. If the kernel used to work properly, and then changed, then it's a regression on the kernel side.
Quoted 7 lines
Quoted 4 lines
Quoted 1 line
So which is it?
I don't work on the kernel, so I can't tell you which it is. You will have to decide.
As you have the userspace code, it should be easier for you to test this on an older kernel. I don't have your userspace code...
Sorry, I'm not sure what you are asking.
I've attached a sample Go program. On kernel version 2.6.32 this program exits 0. On kernel version 5.7.17 it prints
got "" want "./foo\x00"
and exits with status 1.
This program hardcodes the string "/proc/self/cmdline" for convenience, but of course the same results would happen if this were a generic copy program that somebody invoked with /proc/self/cmdline as a command line option.
I could write the same program in C easily enough, by explicitly calling copy_file_range. Would it help to see a sample C program?
Quoted 8 lines
Quoted 5 lines
From my perspective, as a kernel user rather than a kernel developer, a system call that silently fails for certain files and that provides no way to determine either 1) ahead of time that the system call will fail, or 2) after the call that the system call did fail, is a useless system call.
Great, then don't use
copy_file_range()yet as it seems like it fits that category at the moment :)
That seems like an unfortunate result, but if that is the determining opinion then I guess that is what we will have to do in the Go standard library.
Ian
package main
import (
"bytes" "fmt" "io" "io/ioutil" "os"
)
func main() {
tmpfile, err := ioutil.TempFile("", "copy_file_range")
if err != nil {
fmt.Fprint(os.Stderr, err)
os.Exit(1)
}
status := copy(tmpfile)
os.Remove(tmpfile.Name())
os.Exit(status)
}func copy(tmpfile *os.File) int {
cmdline, err := os.Open("/proc/self/cmdline")
if err != nil {
fmt.Fprintln(os.Stderr, err)
return 1
}
defer cmdline.Close()
if _, err := io.Copy(tmpfile, cmdline); err != nil {
fmt.Fprintf(os.Stderr, "copy failed: %v\n", err)
return 1
}
if err := tmpfile.Close(); err != nil {
fmt.Fprintln(os.Stderr, err)
return 1
}
old, err := ioutil.ReadFile("/proc/self/cmdline")
if err != nil {
fmt.Fprintln(os.Stderr, err)
return 1
}
new, err := ioutil.ReadFile(tmpfile.Name())
if err != nil {
fmt.Fprintln(os.Stderr, err)
return 1
}
if !bytes.Equal(old, new) {
fmt.Fprintf(os.Stderr, "got %q want %q\n", new, old)
return 1
}
return 0
}Re: [PATCH 1/6] fs: Add flag to file_system_type to indicate content is generated
In reply to Greg KHQuoted 27 lines · Greg KH
Quoted 7 lines · Ian Lance Taylor
Quoted 5 lines · Greg KH
Why are people trying to use
copy_file_rangeon simple /proc and /sys files in the first place? They can not seek (well most can not), so that feels like a "oh look, a new syscall, let's use it everywhere!" problem that userspace should not do.Quoted 14 lines
This may have been covered elsewhere, but it's not that people are saying "let's use
copy_file_rangeon files in /proc." It's that the Go language standard library provides an interface to operating system files. When Go code uses the standard library function io.Copy to copy the contents of one open file to another open file, then on Linux kernels 5.3 and greater the Go standard library will use thecopy_file_rangesystem call. That seems to be exactly whatcopy_file_rangeis intended for. Unfortunately it appears that when people writing Go code open a file in /proc and use io.Copy the contents to another open file,copy_file_rangedoes nothing and reports success. There isn't anything on thecopy_file_rangeman page explaining this limitation, and there isn't any documented way to know that the Go standard library should not usecopy_file_rangeon certain files.But, is this a bug in the kernel in that the syscall being made is not working properly, or a bug in that Go decided to do this for all types of files not knowing that some types of files can not handle this?
Quoted 5 lines
If the kernel has always worked this way, I would say that Go is doing the wrong thing here. If the kernel used to work properly, and then changed, then it's a regression on the kernel side.
So which is it?
Both Al Viro and myself have said "copy file range is not a generic method for copying data between two file descriptors". It is a targetted solution for *regular files only* on filesystems that store persistent data and can accelerate the data copy in some way (e.g. clone, server side offload, hardware offlead, etc). It is not intended as a copy mechanism for copying data from one random file descriptor to another.
The use of it as a general file copy mechanism in the Go system library is incorrect and wrong. It is a userspace bug. Userspace has done the wrong thing, userspace needs to be fixed.
-Dave.
Signature · 2 lines
Dave Chinner [email protected]
Re: [PATCH 1/6] fs: Add flag to file_system_type to indicate content is generated
Quoted 43 lines · Dave Chinner
Quoted 27 lines · Greg KH
Quoted 7 lines · Ian Lance Taylor
Quoted 5 lines · Greg KH
Why are people trying to use
copy_file_rangeon simple /proc and /sys files in the first place? They can not seek (well most can not), so that feels like a "oh look, a new syscall, let's use it everywhere!" problem that userspace should not do.Quoted 14 lines
This may have been covered elsewhere, but it's not that people are saying "let's use
copy_file_rangeon files in /proc." It's that the Go language standard library provides an interface to operating system files. When Go code uses the standard library function io.Copy to copy the contents of one open file to another open file, then on Linux kernels 5.3 and greater the Go standard library will use thecopy_file_rangesystem call. That seems to be exactly whatcopy_file_rangeis intended for. Unfortunately it appears that when people writing Go code open a file in /proc and use io.Copy the contents to another open file,copy_file_rangedoes nothing and reports success. There isn't anything on thecopy_file_rangeman page explaining this limitation, and there isn't any documented way to know that the Go standard library should not usecopy_file_rangeon certain files.But, is this a bug in the kernel in that the syscall being made is not working properly, or a bug in that Go decided to do this for all types of files not knowing that some types of files can not handle this?
Quoted 5 lines
If the kernel has always worked this way, I would say that Go is doing the wrong thing here. If the kernel used to work properly, and then changed, then it's a regression on the kernel side.
So which is it?
Both Al Viro and myself have said "copy file range is not a generic method for copying data between two file descriptors". It is a targetted solution for *regular files only* on filesystems that store persistent data and can accelerate the data copy in some way (e.g. clone, server side offload, hardware offlead, etc). It is not intended as a copy mechanism for copying data from one random file descriptor to another.
Quoted 3 lines
The use of it as a general file copy mechanism in the Go system library is incorrect and wrong. It is a userspace bug. Userspace has done the wrong thing, userspace needs to be fixed.
OK, we'll take it out.
I'll just make one last plea that I think that copy_file_range could be much more useful if there were some way that a program could know whether it would work or not. It's pretty unfortunate that we can't use it in the Go standard library, or, indeed, in any general purpose code, in any language, that is intended to support arbitrary file names. To be pedantically clear, I'm not saying that copy_file_range should work on all file systems. I'm only saying that on file systems for which it doesn't work it should fail rather than silently returning success without doing anything.
Ian
Re: [PATCH 1/6] fs: Add flag to file_system_type to indicate content is generated
Quoted 48 lines · Ian Lance Taylor
Quoted 43 lines · Dave Chinner
Quoted 27 lines · Greg KH
Quoted 7 lines · Ian Lance Taylor
Quoted 5 lines · Greg KH
Why are people trying to use
copy_file_rangeon simple /proc and /sys files in the first place? They can not seek (well most can not), so that feels like a "oh look, a new syscall, let's use it everywhere!" problem that userspace should not do.Quoted 14 lines
This may have been covered elsewhere, but it's not that people are saying "let's use
copy_file_rangeon files in /proc." It's that the Go language standard library provides an interface to operating system files. When Go code uses the standard library function io.Copy to copy the contents of one open file to another open file, then on Linux kernels 5.3 and greater the Go standard library will use thecopy_file_rangesystem call. That seems to be exactly whatcopy_file_rangeis intended for. Unfortunately it appears that when people writing Go code open a file in /proc and use io.Copy the contents to another open file,copy_file_rangedoes nothing and reports success. There isn't anything on thecopy_file_rangeman page explaining this limitation, and there isn't any documented way to know that the Go standard library should not usecopy_file_rangeon certain files.But, is this a bug in the kernel in that the syscall being made is not working properly, or a bug in that Go decided to do this for all types of files not knowing that some types of files can not handle this?
Quoted 5 lines
If the kernel has always worked this way, I would say that Go is doing the wrong thing here. If the kernel used to work properly, and then changed, then it's a regression on the kernel side.
So which is it?
Both Al Viro and myself have said "copy file range is not a generic method for copying data between two file descriptors". It is a targetted solution for *regular files only* on filesystems that store persistent data and can accelerate the data copy in some way (e.g. clone, server side offload, hardware offlead, etc). It is not intended as a copy mechanism for copying data from one random file descriptor to another.
Quoted 3 lines
The use of it as a general file copy mechanism in the Go system library is incorrect and wrong. It is a userspace bug. Userspace has done the wrong thing, userspace needs to be fixed.
Quoted 5 lines
OK, we'll take it out.
I'll just make one last plea that I think that
copy_file_rangecould be much more useful if there were some way that a program could know whether it would work or not.
If you can't tell from userspace that a file has data in it other than by calling read() on it, then you can't use cfr on it.
Cheers,
Dave.
Signature · 2 lines
Dave Chinner [email protected]
Re: [PATCH 1/6] fs: Add flag to file_system_type to indicate content is generated
Quoted 49 lines · Dave Chinner
Quoted 48 lines · Ian Lance Taylor
Quoted 46 lines · Dave Chinner
Quoted 27 lines · Greg KH
Quoted 7 lines · Ian Lance Taylor
Quoted 5 lines · Greg KH
Why are people trying to use
copy_file_rangeon simple /proc and /sys files in the first place? They can not seek (well most can not), so that feels like a "oh look, a new syscall, let's use it everywhere!" problem that userspace should not do.Quoted 14 lines
This may have been covered elsewhere, but it's not that people are saying "let's use
copy_file_rangeon files in /proc." It's that the Go language standard library provides an interface to operating system files. When Go code uses the standard library function io.Copy to copy the contents of one open file to another open file, then on Linux kernels 5.3 and greater the Go standard library will use thecopy_file_rangesystem call. That seems to be exactly whatcopy_file_rangeis intended for. Unfortunately it appears that when people writing Go code open a file in /proc and use io.Copy the contents to another open file,copy_file_rangedoes nothing and reports success. There isn't anything on thecopy_file_rangeman page explaining this limitation, and there isn't any documented way to know that the Go standard library should not usecopy_file_rangeon certain files.But, is this a bug in the kernel in that the syscall being made is not working properly, or a bug in that Go decided to do this for all types of files not knowing that some types of files can not handle this?
Quoted 5 lines
If the kernel has always worked this way, I would say that Go is doing the wrong thing here. If the kernel used to work properly, and then changed, then it's a regression on the kernel side.
So which is it?
Both Al Viro and myself have said "copy file range is not a generic method for copying data between two file descriptors". It is a targetted solution for *regular files only* on filesystems that store persistent data and can accelerate the data copy in some way (e.g. clone, server side offload, hardware offlead, etc). It is not intended as a copy mechanism for copying data from one random file descriptor to another.
The use of it as a general file copy mechanism in the Go system library is incorrect and wrong. It is a userspace bug. Userspace has done the wrong thing, userspace needs to be fixed.
Quoted 5 lines
Quoted 5 lines
OK, we'll take it out.
I'll just make one last plea that I think that
copy_file_rangecould be much more useful if there were some way that a program could know whether it would work or not.
Well... we could always implement a CFR_DRYRUN flag that would run through all the parameter validation and return 0 just before actually starting any real copying logic. But that wouldn't itself solve the problem that there are very old virtual filesystems in Linux that have zero-length regular files that behave like a pipe.
Quoted 2 lines
If you can't tell from userspace that a file has data in it other than by calling
read()on it, then you can't use cfr on it.
I don't know how to do that, Dave. :)
Frankly I'm with the Go developers on this -- one should detect c_f_r by calling it and if it errors out then fall back to the usual userspace buffer copy strategy.
That still means we need to fix the kernel WRT these weird old filesystems. One of...
1. Get rid of the generic fallback completely, since splice only copies 64k at a time and ... yay? I guess it at least passes generic/521 and generic/522 these days.
2. Keep it, but change c_f_r to require that both files have a ->copy_file_range implementation. If they're the same then we'll call the function pointer, if not, we call the generic fallback. This at least gets us back to the usual behavior which is that filesystems have to opt in to new functionality (== we assume they QA'd all the wunnerful combinations).
3. #2, but fix the generic fallback to not suck so badly. That sounds like someone (else's) 2yr project. :P
--D
Quoted 6 lines
Cheers,
Dave.
Signature · 2 lines
Dave Chinner [email protected]
Re: [PATCH 1/6] fs: Add flag to file_system_type to indicate content is generated
Quoted 62 lines · Darrick J. Wong
Quoted 49 lines · Dave Chinner
Quoted 48 lines · Ian Lance Taylor
Quoted 46 lines · Dave Chinner
Quoted 27 lines · Greg KH
Quoted 7 lines · Ian Lance Taylor
Quoted 5 lines · Greg KH
Why are people trying to use
copy_file_rangeon simple /proc and /sys files in the first place? They can not seek (well most can not), so that feels like a "oh look, a new syscall, let's use it everywhere!" problem that userspace should not do.Quoted 14 lines
This may have been covered elsewhere, but it's not that people are saying "let's use
copy_file_rangeon files in /proc." It's that the Go language standard library provides an interface to operating system files. When Go code uses the standard library function io.Copy to copy the contents of one open file to another open file, then on Linux kernels 5.3 and greater the Go standard library will use thecopy_file_rangesystem call. That seems to be exactly whatcopy_file_rangeis intended for. Unfortunately it appears that when people writing Go code open a file in /proc and use io.Copy the contents to another open file,copy_file_rangedoes nothing and reports success. There isn't anything on thecopy_file_rangeman page explaining this limitation, and there isn't any documented way to know that the Go standard library should not usecopy_file_rangeon certain files.But, is this a bug in the kernel in that the syscall being made is not working properly, or a bug in that Go decided to do this for all types of files not knowing that some types of files can not handle this?
Quoted 5 lines
If the kernel has always worked this way, I would say that Go is doing the wrong thing here. If the kernel used to work properly, and then changed, then it's a regression on the kernel side.
So which is it?
Both Al Viro and myself have said "copy file range is not a generic method for copying data between two file descriptors". It is a targetted solution for *regular files only* on filesystems that store persistent data and can accelerate the data copy in some way (e.g. clone, server side offload, hardware offlead, etc). It is not intended as a copy mechanism for copying data from one random file descriptor to another.
The use of it as a general file copy mechanism in the Go system library is incorrect and wrong. It is a userspace bug. Userspace has done the wrong thing, userspace needs to be fixed.
Quoted 5 lines
Quoted 5 lines
OK, we'll take it out.
I'll just make one last plea that I think that
copy_file_rangecould be much more useful if there were some way that a program could know whether it would work or not.Well... we could always implement a
CFR_DRYRUNflag that would run through all the parameter validation and return 0 just before actually starting any real copying logic. But that wouldn't itself solve the problem that there are very old virtual filesystems in Linux that have zero-length regular files that behave like a pipe.
Quoted 4 lines
Quoted 2 lines
If you can't tell from userspace that a file has data in it other than by calling
read()on it, then you can't use cfr on it.I don't know how to do that, Dave. :)
If stat returns a non-zero size, then userspace knows it has at least that much data in it, whether it be zeros or previously written data. cfr will copy that data. The special zero length regular pipe files fail this simple "how much data is there to copy in this file" check...
Quoted 6 lines
Frankly I'm with the Go developers on this -- one should detect
c_f_rby calling it and if it errors out then fall back to the usual userspace buffer copy strategy.That still means we need to fix the kernel WRT these weird old filesystems. One of...
And that is the whole problem here, not that cfr is failing. cfr is behaving correctly and consistently as the filesystem is telling the kernel there is no data in the file (i.e. size = 0).
Quoted 3 lines
1. Get rid of the generic fallback completely, since splice only copies 64k at a time and ... yay? I guess it at least passes generic/521 and generic/522 these days.
I've had a few people ask me for cfr to not fall back to a manual copy because they only want it to do something if it can accelerate the copy to be faster than userspace can copy the data itself. If the filesystem can't optimise the copy in some way, they want to know so they can do something else of their own chosing.
Hence this seems like the sane option to take here...
Quoted 6 lines
2. Keep it, but change
c_f_rto require that both files have a ->copy_file_range implementation. If they're the same then we'll call the function pointer, if not, we call the generic fallback. This at least gets us back to the usual behavior which is that filesystems have to opt in to new functionality (== we assume they QA'd all the wunnerful combinations).
That doesn't address the "write failure turns into short read" problem with the splice path...
Quoted 2 lines
3. #2, but fix the generic fallback to not suck so badly. That sounds like someone (else's) 2yr project. :P
Not mine, either.
Cheers,
Dave.
Signature · 2 lines
Dave Chinner [email protected]
Re: [PATCH 1/6] fs: Add flag to file_system_type to indicate content is generated
Quoted 7 lines · Dave Chinner
Quoted 5 lines · Darrick J. Wong
Quoted 2 lines · Dave Chinner
If you can't tell from userspace that a file has data in it other than by calling
read()on it, then you can't use cfr on it.
Quoted 7 lines
Quoted 1 line
I don't know how to do that, Dave. :)
If stat returns a non-zero size, then userspace knows it has at least that much data in it, whether it be zeros or previously written data. cfr will copy that data. The special zero length regular pipe files fail this simple "how much data is there to copy in this file" check...
This suggests that if the Go standard library sees that copy_file_range reads zero bytes, we should assume that it failed, and should use the fallback path as though copy_file_range returned EOPNOTSUPP or EINVAL. This will cause an extra system call for an empty file, but as long as copy_file_range does not return an error for cases that it does not support we are going to need an extra system call anyhow.
Does that seem like a possible mitigation? That is, are there cases where copy_file_range will fail to do a correct copy, and will return success, and will not return zero?
Ian
Re: [PATCH 1/6] fs: Add flag to file_system_type to indicate content is generated
Quoted 25 lines · Ian Lance Taylor
Quoted 7 lines · Dave Chinner
Quoted 5 lines · Darrick J. Wong
Quoted 2 lines · Dave Chinner
If you can't tell from userspace that a file has data in it other than by calling
read()on it, then you can't use cfr on it.Quoted 7 lines
Quoted 1 line
I don't know how to do that, Dave. :)
If stat returns a non-zero size, then userspace knows it has at least that much data in it, whether it be zeros or previously written data. cfr will copy that data. The special zero length regular pipe files fail this simple "how much data is there to copy in this file" check...
This suggests that if the Go standard library sees that
copy_file_rangereads zero bytes, we should assume that it failed, and should use the fallback path as thoughcopy_file_rangereturned EOPNOTSUPP or EINVAL. This will cause an extra system call for an empty file, but as long ascopy_file_rangedoes not return an error for cases that it does not support we are going to need an extra system call anyhow.
Quoted 3 lines
Does that seem like a possible mitigation? That is, are there cases where
copy_file_rangewill fail to do a correct copy, and will return success, and will not return zero?
I'm a bit worried about the sysfs files that report a 4096 bytes file size, for 2 reasons:
- I'm not sure if the content _can_ actually be longer (I couldn't
find a counterexample)
- If you're unlucky enough to have a partial write in the output
filesystem, you'll get a non-zero return value and probably corrupted content.
Quoted 2 lines
Ian
Re: [PATCH 1/6] fs: Add flag to file_system_type to indicate content is generated
Quoted 31 lines · Nicolas Boichat
Quoted 25 lines · Ian Lance Taylor
Quoted 7 lines · Dave Chinner
Quoted 5 lines · Darrick J. Wong
Quoted 2 lines · Dave Chinner
If you can't tell from userspace that a file has data in it other than by calling
read()on it, then you can't use cfr on it.Quoted 7 lines
Quoted 1 line
I don't know how to do that, Dave. :)
If stat returns a non-zero size, then userspace knows it has at least that much data in it, whether it be zeros or previously written data. cfr will copy that data. The special zero length regular pipe files fail this simple "how much data is there to copy in this file" check...
This suggests that if the Go standard library sees that
copy_file_rangereads zero bytes, we should assume that it failed, and should use the fallback path as thoughcopy_file_rangereturned EOPNOTSUPP or EINVAL. This will cause an extra system call for an empty file, but as long ascopy_file_rangedoes not return an error for cases that it does not support we are going to need an extra system call anyhow.Quoted 3 lines
Does that seem like a possible mitigation? That is, are there cases where
copy_file_rangewill fail to do a correct copy, and will return success, and will not return zero?
Quoted 8 lines
I'm a bit worried about the sysfs files that report a 4096 bytes file size, for 2 reasons:
- I'm not sure if the content _can_ actually be longer (I couldn't
find a counterexample)
- If you're unlucky enough to have a partial write in the output
filesystem, you'll get a non-zero return value and probably corrupted content.
First of all, I am in favor of fixing the regression in the kernel caused by the change of behavior in v5.3.
Having said that, I don't think it is a good idea to use ANY tool to copy a zero size pseudo file.
rsync doesn't copy any data either if you try to use it to copy tracing into a temp file.
I think it is perfectly sane for any tool to check file size before trying to read/copy.
w.r.t. short write/short read, did you consider using the off_in/off_out arguments? I *think* current kernel CFR should be safe to use as long as the tool:
1. Checks file size before copy
2. Does not try to copy a range beyond EOF
3. Pass off_in/off_out args and verify that off_in/off_out advances as expected
Thanks,
Amir.
Greg KH
maintainerRe: [PATCH 1/6] fs: Add flag to file_system_type to indicate content is generated
In reply to Nicolas BoichatQuoted 26 lines · Nicolas Boichat
Quoted 25 lines · Ian Lance Taylor
Quoted 7 lines · Dave Chinner
Quoted 5 lines · Darrick J. Wong
Quoted 2 lines · Dave Chinner
If you can't tell from userspace that a file has data in it other than by calling
read()on it, then you can't use cfr on it.Quoted 7 lines
Quoted 1 line
I don't know how to do that, Dave. :)
If stat returns a non-zero size, then userspace knows it has at least that much data in it, whether it be zeros or previously written data. cfr will copy that data. The special zero length regular pipe files fail this simple "how much data is there to copy in this file" check...
This suggests that if the Go standard library sees that
copy_file_rangereads zero bytes, we should assume that it failed, and should use the fallback path as thoughcopy_file_rangereturned EOPNOTSUPP or EINVAL. This will cause an extra system call for an empty file, but as long ascopy_file_rangedoes not return an error for cases that it does not support we are going to need an extra system call anyhow.
Quoted 8 lines
Quoted 3 lines
Does that seem like a possible mitigation? That is, are there cases where
copy_file_rangewill fail to do a correct copy, and will return success, and will not return zero?I'm a bit worried about the sysfs files that report a 4096 bytes file size, for 2 reasons:
- I'm not sure if the content _can_ actually be longer (I couldn't
find a counterexample)
There are quite a few, look for binary sysfs files that are pipes from hardware/firmware resources to userspace. /sys/firmware/efi/efivars/ has a number of them if you want to play around with it.
thanks,
greg k-h
Re: [PATCH 1/6] fs: Add flag to file_system_type to indicate content is generated
In reply to Greg KHQuoted 16 lines · Greg KH
Quoted 5 lines · Nicolas Boichat
Filesystems such as procfs and sysfs generate their content at runtime. This implies the file sizes do not usually match the amount of data that can be read from the file, and that seeking may not work as intended.
Quoted 8 lines
This will be useful to disallow
copy_file_rangewith input files from such filesystems.Signed-off-by Nicolas Boichat <[email protected]>---
I first thought of adding a new field to structfile_operations, but that doesn't quite scale as every single file creation operation would need to be modified.
Quoted 7 lines
Even so, you missed a load of filesystems in the kernel with this patch series, what makes the ones you did mark here different from the "internal" filesystems that you did not?
This feels wrong, why is userspace suddenly breaking? What changed in the kernel that caused this? Procfs has been around for a _very_ long time :)
That would be because of (v5.3):
5dae222a5ff0 vfs: allow copy_file_range to copy across devices
The intention of this change (series) was to allow server side copy for nfs and cifs via copy_file_range().
This is mostly work by Dave Chinner that I picked up following requests from the NFS folks.
But the above change also includes this generic change:
- /* this could be relaxed once a method supports cross-fs copies */
- if (file_inode(file_in)->i_sb != file_inode(file_out)->i_sb)
- return -EXDEV;
-
The change of behavior was documented in the commit message. It was also documented in:
88e75e2c5 copy_file_range.2: Kernel v5.3 updates
I think our rationale for the generic change was:
"Why not? What could go wrong? (TM)"
I am not sure if any workload really gained something from this kernel cross-fs CFR.
In retrospect, I think it would have been safer to allow cross-fs CFR only to the filesystems that implement ->{copy,remap}_file_range()...
Our option now are:
- Restore the cross-fs restriction into generic_copy_file_range()
- Explicitly opt-out of CFR per-fs and/or per-file as Nicolas' patch does
Preference anyone?
Thanks,
Amir.
Greg KH
maintainerRe: [PATCH 1/6] fs: Add flag to file_system_type to indicate content is generated
Quoted 44 lines · Amir Goldstein
Quoted 16 lines · Greg KH
Quoted 5 lines · Nicolas Boichat
Filesystems such as procfs and sysfs generate their content at runtime. This implies the file sizes do not usually match the amount of data that can be read from the file, and that seeking may not work as intended.
Quoted 8 lines
This will be useful to disallow
copy_file_rangewith input files from such filesystems.Signed-off-by Nicolas Boichat <[email protected]>---
I first thought of adding a new field to structfile_operations, but that doesn't quite scale as every single file creation operation would need to be modified.Quoted 7 lines
Even so, you missed a load of filesystems in the kernel with this patch series, what makes the ones you did mark here different from the "internal" filesystems that you did not?
This feels wrong, why is userspace suddenly breaking? What changed in the kernel that caused this? Procfs has been around for a _very_ long time :)
That would be because of (v5.3):
5dae222a5ff0vfs: allowcopy_file_rangeto copy across devicesThe intention of this change (series) was to allow server side copy for nfs and cifs via
copy_file_range().
This is mostly work by Dave Chinner that I picked up following requests from the NFS folks.But the above change also includes this generic change:
(quoted diff) +0
-4- /* this could be relaxed once a method supports cross-fs copies */ - if (file_inode(file_in)->i_sb != file_inode(file_out)->i_sb) - return -EXDEV; -The change of behavior was documented in the commit message. It was also documented in:
Quoted 6 lines
88e75e2c5copy_file_range.2: Kernel v5.3 updatesI think our rationale for the generic change was:
"Why not? What could go wrong? (TM)"
I am not sure if any workload really gained something from this kernel cross-fs CFR.
Why not put that check back?
Quoted 2 lines
In retrospect, I think it would have been safer to allow cross-fs CFR only to the filesystems that implement ->{copy,remap}_file_range()...
Why not make this change? That seems easier and should fix this for everyone, right?
Quoted 2 lines
Our option now are:
- Restore the cross-fs restriction intogeneric_copy_file_range()
Yes.
Quoted 1 line
- Explicitly opt-out of CFR per-fs and/or per-file as Nicolas' patch does
No. That way lies constant auditing and someone being "vigilant" for the next 30+ years. Which will not happen.
thanks,
greg k-h
Re: [PATCH 1/6] fs: Add flag to file_system_type to indicate content is generated
Quoted 57 lines · Greg KH
Quoted 44 lines · Amir Goldstein
Quoted 16 lines · Greg KH
Quoted 5 lines · Nicolas Boichat
Filesystems such as procfs and sysfs generate their content at runtime. This implies the file sizes do not usually match the amount of data that can be read from the file, and that seeking may not work as intended.
Quoted 8 lines
This will be useful to disallow
copy_file_rangewith input files from such filesystems.Signed-off-by Nicolas Boichat <[email protected]>---
I first thought of adding a new field to structfile_operations, but that doesn't quite scale as every single file creation operation would need to be modified.Quoted 7 lines
Even so, you missed a load of filesystems in the kernel with this patch series, what makes the ones you did mark here different from the "internal" filesystems that you did not?
This feels wrong, why is userspace suddenly breaking? What changed in the kernel that caused this? Procfs has been around for a _very_ long time :)
That would be because of (v5.3):
5dae222a5ff0vfs: allowcopy_file_rangeto copy across devicesThe intention of this change (series) was to allow server side copy for nfs and cifs via
copy_file_range().
This is mostly work by Dave Chinner that I picked up following requests from the NFS folks.But the above change also includes this generic change:
(quoted diff) +0
-4- /* this could be relaxed once a method supports cross-fs copies */ - if (file_inode(file_in)->i_sb != file_inode(file_out)->i_sb) - return -EXDEV; -The change of behavior was documented in the commit message. It was also documented in:
Quoted 6 lines
88e75e2c5copy_file_range.2: Kernel v5.3 updatesI think our rationale for the generic change was:
"Why not? What could go wrong? (TM)"
I am not sure if any workload really gained something from this kernel cross-fs CFR.Why not put that check back?
Quoted 2 lines
In retrospect, I think it would have been safer to allow cross-fs CFR only to the filesystems that implement ->{copy,remap}_file_range()...
Quoted 8 lines
Why not make this change? That seems easier and should fix this for everyone, right?
Quoted 2 lines
Our option now are:
- Restore the cross-fs restriction intogeneric_copy_file_range()Yes.
Restoring this restriction will actually change the current cephfs CFR behaviour. Since that commit we have allowed doing remote copies between different filesystems within the same ceph cluster. See commit 6fd4e6348352 ("ceph: allow object copies across different filesystems in the same cluster").
Although I'm not aware of any current users for this scenario, the performance impact can actually be huge as it's the difference between asking the OSDs for copying a file and doing a full read+write on the client side.
Cheers,
Signature · 1 line
Luis
Quoted 8 lines
Quoted 1 line
- Explicitly opt-out of CFR per-fs and/or per-file as Nicolas' patch does
No. That way lies constant auditing and someone being "vigilant" for the next 30+ years. Which will not happen.
thanks,
greg k-h
Greg KH
maintainerRe: [PATCH 1/6] fs: Add flag to file_system_type to indicate content is generated
Quoted 74 lines · Luis Henriques
Quoted 57 lines · Greg KH
Quoted 44 lines · Amir Goldstein
Quoted 16 lines · Greg KH
Quoted 5 lines · Nicolas Boichat
Filesystems such as procfs and sysfs generate their content at runtime. This implies the file sizes do not usually match the amount of data that can be read from the file, and that seeking may not work as intended.
Quoted 8 lines
This will be useful to disallow
copy_file_rangewith input files from such filesystems.Signed-off-by Nicolas Boichat <[email protected]>---
I first thought of adding a new field to structfile_operations, but that doesn't quite scale as every single file creation operation would need to be modified.Quoted 7 lines
Even so, you missed a load of filesystems in the kernel with this patch series, what makes the ones you did mark here different from the "internal" filesystems that you did not?
This feels wrong, why is userspace suddenly breaking? What changed in the kernel that caused this? Procfs has been around for a _very_ long time :)
That would be because of (v5.3):
5dae222a5ff0vfs: allowcopy_file_rangeto copy across devicesThe intention of this change (series) was to allow server side copy for nfs and cifs via
copy_file_range().
This is mostly work by Dave Chinner that I picked up following requests from the NFS folks.But the above change also includes this generic change:
(quoted diff) +0
-4- /* this could be relaxed once a method supports cross-fs copies */ - if (file_inode(file_in)->i_sb != file_inode(file_out)->i_sb) - return -EXDEV; -The change of behavior was documented in the commit message. It was also documented in:
Quoted 6 lines
88e75e2c5copy_file_range.2: Kernel v5.3 updatesI think our rationale for the generic change was:
"Why not? What could go wrong? (TM)"
I am not sure if any workload really gained something from this kernel cross-fs CFR.Why not put that check back?
Quoted 2 lines
In retrospect, I think it would have been safer to allow cross-fs CFR only to the filesystems that implement ->{copy,remap}_file_range()...
Quoted 8 lines
Why not make this change? That seems easier and should fix this for everyone, right?
Quoted 2 lines
Our option now are:
- Restore the cross-fs restriction intogeneric_copy_file_range()Yes.
Restoring this restriction will actually change the current cephfs CFR behaviour. Since that commit we have allowed doing remote copies between different filesystems within the same ceph cluster. See commit
6fd4e6348352("ceph: allow object copies across different filesystems in the same cluster").
Quoted 4 lines
Although I'm not aware of any current users for this scenario, the performance impact can actually be huge as it's the difference between asking the OSDs for copying a file and doing a full read+write on the client side.
Regression in performance is ok if it fixes a regression for things that used to work just fine in the past :)
First rule, make it work.
thanks,
greg k-h
Re: [PATCH 1/6] fs: Add flag to file_system_type to indicate content is generated
Quoted 80 lines · Greg KH
Quoted 74 lines · Luis Henriques
Quoted 57 lines · Greg KH
Quoted 44 lines · Amir Goldstein
Quoted 16 lines · Greg KH
Quoted 5 lines · Nicolas Boichat
Filesystems such as procfs and sysfs generate their content at runtime. This implies the file sizes do not usually match the amount of data that can be read from the file, and that seeking may not work as intended.
Quoted 8 lines
This will be useful to disallow
copy_file_rangewith input files from such filesystems.Signed-off-by Nicolas Boichat <[email protected]>---
I first thought of adding a new field to structfile_operations, but that doesn't quite scale as every single file creation operation would need to be modified.Quoted 7 lines
Even so, you missed a load of filesystems in the kernel with this patch series, what makes the ones you did mark here different from the "internal" filesystems that you did not?
This feels wrong, why is userspace suddenly breaking? What changed in the kernel that caused this? Procfs has been around for a _very_ long time :)
That would be because of (v5.3):
5dae222a5ff0vfs: allowcopy_file_rangeto copy across devicesThe intention of this change (series) was to allow server side copy for nfs and cifs via
copy_file_range().
This is mostly work by Dave Chinner that I picked up following requests from the NFS folks.But the above change also includes this generic change:
(quoted diff) +0
-4- /* this could be relaxed once a method supports cross-fs copies */ - if (file_inode(file_in)->i_sb != file_inode(file_out)->i_sb) - return -EXDEV; -The change of behavior was documented in the commit message. It was also documented in:
Quoted 6 lines
88e75e2c5copy_file_range.2: Kernel v5.3 updatesI think our rationale for the generic change was:
"Why not? What could go wrong? (TM)"
I am not sure if any workload really gained something from this kernel cross-fs CFR.Why not put that check back?
Quoted 2 lines
In retrospect, I think it would have been safer to allow cross-fs CFR only to the filesystems that implement ->{copy,remap}_file_range()...
Quoted 8 lines
Why not make this change? That seems easier and should fix this for everyone, right?
Quoted 2 lines
Our option now are:
- Restore the cross-fs restriction intogeneric_copy_file_range()Yes.
Restoring this restriction will actually change the current cephfs CFR behaviour. Since that commit we have allowed doing remote copies between different filesystems within the same ceph cluster. See commit
6fd4e6348352("ceph: allow object copies across different filesystems in the same cluster").Quoted 4 lines
Although I'm not aware of any current users for this scenario, the performance impact can actually be huge as it's the difference between asking the OSDs for copying a file and doing a full read+write on the client side.
Quoted 4 lines
Regression in performance is ok if it fixes a regression for things that used to work just fine in the past :)
First rule, make it work.
Sure, I just wanted to point out that *maybe* there are other options than simply reverting that commit :-)
Something like the patch below (completely untested!) should revert to the old behaviour in filesystems that don't implement the CFR syscall.
Cheers,
Signature · 1 line
Luis
fs/read_write.c +5 -2
@@ -1406,8 +1406,11 @@ static ssize_t do_copy_file_range(struct file *file_in, loff_t pos_in, file_out, pos_out, len, flags); -return generic_copy_file_range (file_in, pos_in, file_out, pos_out, len, - flags); +if (file_inode (file_in)->i_sb !=file_inode (file_out)->i_sb) +return -EXDEV ; +else +generic_copy_file_range (file_in, pos_in, file_out, pos_out, len, + flags); }/*
Greg KH
maintainerRe: [PATCH 1/6] fs: Add flag to file_system_type to indicate content is generated
Quoted 105 lines · Luis Henriques
Quoted 80 lines · Greg KH
Quoted 74 lines · Luis Henriques
Quoted 57 lines · Greg KH
Quoted 44 lines · Amir Goldstein
Quoted 16 lines · Greg KH
Quoted 5 lines · Nicolas Boichat
Filesystems such as procfs and sysfs generate their content at runtime. This implies the file sizes do not usually match the amount of data that can be read from the file, and that seeking may not work as intended.
Quoted 8 lines
This will be useful to disallow
copy_file_rangewith input files from such filesystems.Signed-off-by Nicolas Boichat <[email protected]>---
I first thought of adding a new field to structfile_operations, but that doesn't quite scale as every single file creation operation would need to be modified.Quoted 7 lines
Even so, you missed a load of filesystems in the kernel with this patch series, what makes the ones you did mark here different from the "internal" filesystems that you did not?
This feels wrong, why is userspace suddenly breaking? What changed in the kernel that caused this? Procfs has been around for a _very_ long time :)
That would be because of (v5.3):
5dae222a5ff0vfs: allowcopy_file_rangeto copy across devicesThe intention of this change (series) was to allow server side copy for nfs and cifs via
copy_file_range().
This is mostly work by Dave Chinner that I picked up following requests from the NFS folks.But the above change also includes this generic change:
(quoted diff) +0
-4- /* this could be relaxed once a method supports cross-fs copies */ - if (file_inode(file_in)->i_sb != file_inode(file_out)->i_sb) - return -EXDEV; -The change of behavior was documented in the commit message. It was also documented in:
Quoted 6 lines
88e75e2c5copy_file_range.2: Kernel v5.3 updatesI think our rationale for the generic change was:
"Why not? What could go wrong? (TM)"
I am not sure if any workload really gained something from this kernel cross-fs CFR.Why not put that check back?
Quoted 2 lines
In retrospect, I think it would have been safer to allow cross-fs CFR only to the filesystems that implement ->{copy,remap}_file_range()...
Quoted 8 lines
Why not make this change? That seems easier and should fix this for everyone, right?
Quoted 2 lines
Our option now are:
- Restore the cross-fs restriction intogeneric_copy_file_range()Yes.
Restoring this restriction will actually change the current cephfs CFR behaviour. Since that commit we have allowed doing remote copies between different filesystems within the same ceph cluster. See commit
6fd4e6348352("ceph: allow object copies across different filesystems in the same cluster").Quoted 4 lines
Although I'm not aware of any current users for this scenario, the performance impact can actually be huge as it's the difference between asking the OSDs for copying a file and doing a full read+write on the client side.
Quoted 4 lines
Regression in performance is ok if it fixes a regression for things that used to work just fine in the past :)
First rule, make it work.
Sure, I just wanted to point out that *maybe* there are other options than simply reverting that commit :-)
Something like the patch below (completely untested!) should revert to the old behaviour in filesystems that don't implement the CFR syscall.
Cheers,
Signature · 1 line
Luisfs/read_write.c +0
-0@@ -1406,8 +1406,11 @@ static ssize_t do_copy_file_range(struct file *file_in, loff_t pos_in, file_out, pos_out, len, flags);
fs/read_write.c static ssize_t do_copy_file_range(struct file *file_in, loff_t pos_in, · line 1416
Quoted 10 lines
fs/read_write.c +5
-2-return generic_copy_file_range (file_in, pos_in, file_out, pos_out, len, - flags); +if (file_inode (file_in)->i_sb !=file_inode (file_out)->i_sb) +return -EXDEV ; +else +generic_copy_file_range (file_in, pos_in, file_out, pos_out, len, + flags); }/*
That would make much more sense to me.
Re: [PATCH 1/6] fs: Add flag to file_system_type to indicate content is generated
Quoted 2 lines · Greg KH
Quoted 1 line · Luis Henriques
Greg KH <[email protected]> writes:
...
Quoted 49 lines
Quoted 49 lines
Quoted 17 lines
Quoted 12 lines
Quoted 5 lines
Quoted 2 lines
Our option now are:
- Restore the cross-fs restriction intogeneric_copy_file_range()Yes.
Restoring this restriction will actually change the current cephfs CFR behaviour. Since that commit we have allowed doing remote copies between different filesystems within the same ceph cluster. See commit
6fd4e6348352("ceph: allow object copies across different filesystems in the same cluster").Quoted 4 lines
Although I'm not aware of any current users for this scenario, the performance impact can actually be huge as it's the difference between asking the OSDs for copying a file and doing a full read+write on the client side.
Quoted 4 lines
Regression in performance is ok if it fixes a regression for things that used to work just fine in the past :)
First rule, make it work.
Sure, I just wanted to point out that *maybe* there are other options than simply reverting that commit :-)
Something like the patch below (completely untested!) should revert to the old behaviour in filesystems that don't implement the CFR syscall.
Cheers,
Signature · 1 line
Luisfs/read_write.c +5
-2@@ -1406,8 +1406,11 @@ static ssize_t do_copy_file_range(struct file *file_in, loff_t pos_in, file_out, pos_out, len, flags); -return generic_copy_file_range (file_in, pos_in, file_out, pos_out, len, - flags); +if (file_inode (file_in)->i_sb !=file_inode (file_out)->i_sb) +return -EXDEV ; +else +generic_copy_file_range (file_in, pos_in, file_out, pos_out, len, + flags); }
Quoted 3 lines
fs/read_write.c static ssize_t do_copy_file_range(struct file *file_in, loff_t pos_in, · line 1416
Quoted 1 line
fs/read_write.c +0
-0/* That would make much more sense to me.
Great. I can send a proper patch with changelog, if this is the really what we want. But I would rather hear from others first. I guess that at least the NFS devs have something to say here.
Cheers,
Signature · 1 line
Luis
Re: [PATCH 1/6] fs: Add flag to file_system_type to indicate content is generated
In reply to Luis HenriquesQuoted 105 lines · Luis Henriques
Quoted 80 lines · Greg KH
Quoted 74 lines · Luis Henriques
Quoted 57 lines · Greg KH
Quoted 44 lines · Amir Goldstein
Quoted 16 lines · Greg KH
Quoted 5 lines · Nicolas Boichat
Filesystems such as procfs and sysfs generate their content at runtime. This implies the file sizes do not usually match the amount of data that can be read from the file, and that seeking may not work as intended.
Quoted 8 lines
This will be useful to disallow
copy_file_rangewith input files from such filesystems.Signed-off-by Nicolas Boichat <[email protected]>---
I first thought of adding a new field to structfile_operations, but that doesn't quite scale as every single file creation operation would need to be modified.Quoted 7 lines
Even so, you missed a load of filesystems in the kernel with this patch series, what makes the ones you did mark here different from the "internal" filesystems that you did not?
This feels wrong, why is userspace suddenly breaking? What changed in the kernel that caused this? Procfs has been around for a _very_ long time :)
That would be because of (v5.3):
5dae222a5ff0vfs: allowcopy_file_rangeto copy across devicesThe intention of this change (series) was to allow server side copy for nfs and cifs via
copy_file_range().
This is mostly work by Dave Chinner that I picked up following requests from the NFS folks.But the above change also includes this generic change:
(quoted diff) +0
-4- /* this could be relaxed once a method supports cross-fs copies */ - if (file_inode(file_in)->i_sb != file_inode(file_out)->i_sb) - return -EXDEV; -The change of behavior was documented in the commit message. It was also documented in:
Quoted 6 lines
88e75e2c5copy_file_range.2: Kernel v5.3 updatesI think our rationale for the generic change was:
"Why not? What could go wrong? (TM)"
I am not sure if any workload really gained something from this kernel cross-fs CFR.Why not put that check back?
Quoted 2 lines
In retrospect, I think it would have been safer to allow cross-fs CFR only to the filesystems that implement ->{copy,remap}_file_range()...
Quoted 8 lines
Why not make this change? That seems easier and should fix this for everyone, right?
Quoted 2 lines
Our option now are:
- Restore the cross-fs restriction intogeneric_copy_file_range()Yes.
Restoring this restriction will actually change the current cephfs CFR behaviour. Since that commit we have allowed doing remote copies between different filesystems within the same ceph cluster. See commit
6fd4e6348352("ceph: allow object copies across different filesystems in the same cluster").Quoted 4 lines
Although I'm not aware of any current users for this scenario, the performance impact can actually be huge as it's the difference between asking the OSDs for copying a file and doing a full read+write on the client side.
Quoted 4 lines
Regression in performance is ok if it fixes a regression for things that used to work just fine in the past :)
First rule, make it work.
Sure, I just wanted to point out that *maybe* there are other options than simply reverting that commit :-)
Something like the patch below (completely untested!) should revert to the old behaviour in filesystems that don't implement the CFR syscall.
Cheers,
--
Luisfs/read_write.c +0
-0@@ -1406,8 +1406,11 @@ static ssize_t do_copy_file_range(struct file *file_in, loff_t pos_in, file_out, pos_out, len, flags);
fs/read_write.c static ssize_t do_copy_file_range(struct file *file_in, loff_t pos_in, · line 1415
Quoted 10 lines
fs/read_write.c +5
-2-return generic_copy_file_range (file_in, pos_in, file_out, pos_out, len, - flags); +if (file_inode (file_in)->i_sb !=file_inode (file_out)->i_sb) +return -EXDEV ; +else +generic_copy_file_range (file_in, pos_in, file_out, pos_out, len, + flags); }
Which kernel is this patch based on?
At this point, I am with Dave and Darrick on not falling back to generic_copy_file_range() at all.
We do not have proof of any workload that benefits from it and the above patch does not protect from a wierd use case of trying to copy a file from sysfs to sysfs.
I am indecisive about what should be done with generic_copy_file_range() called as fallback from within filesystems.
I think the wise choice is to not do the fallback in any case, but this is up to the specific filesystem maintainers to decide.
Thanks,
Amir.
Re: [PATCH 1/6] fs: Add flag to file_system_type to indicate content is generated
Quoted 1 line · Amir Goldstein
On Fri, Feb 12, 2021 at 2:40 PM Luis Henriques <[email protected]> wrote:
...
Quoted 18 lines
Quoted 18 lines
Sure, I just wanted to point out that *maybe* there are other options than simply reverting that commit :-)
Something like the patch below (completely untested!) should revert to the old behaviour in filesystems that don't implement the CFR syscall.
Cheers,
--
Luisfs/read_write.c +0
-0@@ -1406,8 +1406,11 @@ static ssize_t do_copy_file_range(struct file *file_in, loff_t pos_in, file_out, pos_out, len, flags);
Quoted 11 lines
fs/read_write.c static ssize_t do_copy_file_range(struct file *file_in, loff_t pos_in, · line 1415
Quoted 9 lines
fs/read_write.c +5
-2-return generic_copy_file_range (file_in, pos_in, file_out, pos_out, len, - flags); +if (file_inode (file_in)->i_sb !=file_inode (file_out)->i_sb) +return -EXDEV ; +else +generic_copy_file_range (file_in, pos_in, file_out, pos_out, len, + flags); }Which kernel is this patch based on?
It was v5.11-rc7.
Quoted 7 lines
At this point, I am with Dave and Darrick on not falling back to
generic_copy_file_range()at all.We do not have proof of any workload that benefits from it and the above patch does not protect from a wierd use case of trying to copy a file from sysfs to sysfs.
Ok, cool. I can post a new patch doing just that. I guess that function do_copy_file_range() can be dropped in that case.
Quoted 5 lines
I am indecisive about what should be done with
generic_copy_file_range()called as fallback from within filesystems.I think the wise choice is to not do the fallback in any case, but this is up to the specific filesystem maintainers to decide.
I see what you mean. You're suggesting to have userspace handle all the -EOPNOTSUPP and -EXDEV errors. Would you rather have a patch that also removes all the calls to generic_copy_file_range() function? And that function can also be deleted too, of course.
Cheers,
Signature · 1 line
Luis
Re: [PATCH 1/6] fs: Add flag to file_system_type to indicate content is generated
Quoted 50 lines · Luis Henriques
Quoted 1 line · Amir Goldstein
On Fri, Feb 12, 2021 at 2:40 PM Luis Henriques <[email protected]> wrote:
...
Quoted 18 lines
Quoted 18 lines
Sure, I just wanted to point out that *maybe* there are other options than simply reverting that commit :-)
Something like the patch below (completely untested!) should revert to the old behaviour in filesystems that don't implement the CFR syscall.
Cheers,
--
Luisfs/read_write.c +0
-0@@ -1406,8 +1406,11 @@ static ssize_t do_copy_file_range(struct file *file_in, loff_t pos_in, file_out, pos_out, len, flags);Quoted 11 lines
fs/read_write.c static ssize_t do_copy_file_range(struct file *file_in, loff_t pos_in, · line 1415
Quoted 9 lines
fs/read_write.c +5
-2-return generic_copy_file_range (file_in, pos_in, file_out, pos_out, len, - flags); +if (file_inode (file_in)->i_sb !=file_inode (file_out)->i_sb) +return -EXDEV ; +else +generic_copy_file_range (file_in, pos_in, file_out, pos_out, len, + flags); }Which kernel is this patch based on?
It was v5.11-rc7.
Quoted 7 lines
At this point, I am with Dave and Darrick on not falling back to
generic_copy_file_range()at all.We do not have proof of any workload that benefits from it and the above patch does not protect from a wierd use case of trying to copy a file from sysfs to sysfs.
Ok, cool. I can post a new patch doing just that. I guess that function
do_copy_file_range()can be dropped in that case.Quoted 3 lines
I am indecisive about what should be done with
generic_copy_file_range()called as fallback from within filesystems.
Quoted 7 lines
Quoted 2 lines
I think the wise choice is to not do the fallback in any case, but this is up to the specific filesystem maintainers to decide.
I see what you mean. You're suggesting to have userspace handle all the
-EOPNOTSUPPand-EXDEVerrors. Would you rather have a patch that also removes all the calls togeneric_copy_file_range()function? And that function can also be deleted too, of course.
Here's a first stab at this patch. Hopefully I didn't forgot anything here. Let me know if you prefer the more conservative approach, i.e. not touching any of the filesystems and let them use generic_copy_file_range.
Once everyone agrees on the final solution, I can follow-up with the manpages update.
Cheers,
Signature · 27 lines
Luis From e1b37e80b12601d56f792bd19377d3e5208188ef Mon Sep 17 00:00:00 2001 From: Luis Henriques <[email protected]> Date: Fri, 12 Feb 2021 18:03:23 +0000 Subject: [PATCH] vfs: prevent copy_file_range to copy across devices Nicolas Boichat reported an issue when trying to use the copy_file_range syscall on a tracefs file. It failed silently because the file content is generated on-the-fly (reporting a size of zero) and copy_file_range needs to know in advance how much data is present. This commit effectively reverts 5dae222a5ff0 ("vfs: allow copy_file_range to copy across devices"). Now the copy is done only if the filesystems for source and destination files are the same and they implement this syscall. Fixes: 5dae222a5ff0 ("vfs: allow copy_file_range to copy across devices") Cc: Nicolas Boichat <[email protected]> Signed-off-by: Luis Henriques <[email protected]> --- fs/ceph/file.c | 21 +++------------ fs/cifs/cifsfs.c | 3 --- fs/fuse/file.c | 21 +++------------ fs/nfs/nfs4file.c | 20 +++----------- fs/read_write.c | 65 ++++++++-------------------------------------- include/linux/fs.h | 3 --- 6 files changed, 20 insertions(+), 113 deletions(-)
fs/ceph/file.c +3 -18
@@ -2261,9 +2261,9 @@ static ssize_t ceph_do_objects_copy(struct ceph_inode_info *src_ci, u64 *src_offreturn bytes; } -static ssize_t __ceph_copy_file_range (struct file *src_file,loff_t src_off, -struct file *dst_file,loff_t dst_off, -size_t len,unsigned int flags) +static ssize_t ceph_copy_file_range (struct file *src_file,loff_t src_off, +struct file *dst_file,loff_t dst_off, +size_t len,unsigned int flags) {struct inode *src_inode =file_inode (src_file);struct inode *dst_inode =file_inode (dst_file);
@@ -2456,21 +2456,6 @@ static ssize_t __ceph_copy_file_range(struct file *src_file, loff_t src_off,return ret; } -static ssize_t ceph_copy_file_range (struct file *src_file,loff_t src_off, -struct file *dst_file,loff_t dst_off, -size_t len,unsigned int flags) -{ -ssize_t ret; - - ret =__ceph_copy_file_range (src_file, src_off, dst_file, dst_off, - len, flags); - -if (ret == -EOPNOTSUPP || ret == -EXDEV ) - ret =generic_copy_file_range (src_file, src_off, dst_file, - dst_off, len, flags); -return ret; -} -const struct file_operations ceph_file_fops = { .open = ceph_open, .release = ceph_release,
fs/cifs/cifsfs.c +0 -3
@@ -1229,9 +1229,6 @@ static ssize_t cifs_copy_file_range(struct file *src_file, loff_t off, len, flags);free_xid (xid); -if (rc == -EOPNOTSUPP || rc == -EXDEV ) - rc =generic_copy_file_range (src_file, off, dst_file, - destoff, len, flags);return rc; }
fs/fuse/file.c +3 -18
@@ -3330,9 +3330,9 @@ static long fuse_file_fallocate(struct file *file, int mode, loff_t offset,return err; } -static ssize_t __fuse_copy_file_range (struct file *file_in,loff_t pos_in, -struct file *file_out,loff_t pos_out, -size_t len,unsigned int flags) +static ssize_t fuse_copy_file_range (struct file *file_in,loff_t pos_in, +struct file *file_out,loff_t pos_out, +size_t len,unsigned int flags) {struct fuse_file *ff_in = file_in->private_data;struct fuse_file *ff_out = file_out->private_data;
@@ -3439,21 +3439,6 @@ static ssize_t __fuse_copy_file_range(struct file *file_in, loff_t pos_in,return err; } -static ssize_t fuse_copy_file_range (struct file *src_file,loff_t src_off, -struct file *dst_file,loff_t dst_off, -size_t len,unsigned int flags) -{ -ssize_t ret; - - ret =__fuse_copy_file_range (src_file, src_off, dst_file, dst_off, - len, flags); - -if (ret == -EOPNOTSUPP || ret == -EXDEV ) - ret =generic_copy_file_range (src_file, src_off, dst_file, - dst_off, len, flags); -return ret; -} -static const struct file_operations fuse_file_operations = { .llseek = fuse_file_llseek, .read_iter = fuse_file_read_iter,
fs/nfs/nfs4file.c +3 -17
@@ -133,9 +133,9 @@ nfs4_file_flush(struct file *file, fl_owner_t id) }#ifdef CONFIG_NFS_V4_2 -static ssize_t __nfs4_copy_file_range (struct file *file_in,loff_t pos_in, -struct file *file_out,loff_t pos_out, -size_t count,unsigned int flags) +static ssize_t nfs4_copy_file_range (struct file *file_in,loff_t pos_in, +struct file *file_out,loff_t pos_out, +size_t count,unsigned int flags) {struct nfs42_copy_notify_res *cn_resp =NULL ;struct nl4_server *nss =NULL ;
@@ -189,20 +189,6 @@ static ssize_t __nfs4_copy_file_range(struct file *file_in, loff_t pos_in,return ret; } -static ssize_t nfs4_copy_file_range (struct file *file_in,loff_t pos_in, -struct file *file_out,loff_t pos_out, -size_t count,unsigned int flags) -{ -ssize_t ret; - - ret =__nfs4_copy_file_range (file_in, pos_in, file_out, pos_out, count, - flags); -if (ret == -EOPNOTSUPP || ret == -EXDEV ) - ret =generic_copy_file_range (file_in, pos_in, file_out, - pos_out, count, flags); -return ret; -} -static loff_t nfs4_file_llseek (struct file *filep,loff_t offset,int whence) {loff_t ret;
fs/read_write.c +11 -54
83 lines not on this page · raw message
include/linux/fs.h +0 -3
@@ -1910,9 +1910,6 @@ extern ssize_t vfs_read(struct file *, char __user *, size_t, loff_t *);extern ssize_t vfs_write (struct file *,const char __user *,size_t ,loff_t *);extern ssize_t vfs_copy_file_range (struct file *,loff_t ,struct file *,loff_t ,size_t ,unsigned int ); -extern ssize_t generic_copy_file_range (struct file *file_in,loff_t pos_in, -struct file *file_out,loff_t pos_out, -size_t len,unsigned int flags); extern int generic_remap_file_range_prep(struct file *file_in, loff_t pos_in, struct file *file_out, loff_t pos_out, loff_t *count,
Re: [PATCH 1/6] fs: Add flag to file_system_type to indicate content is generated
Quoted 56 lines · Luis Henriques
Quoted 53 lines · Luis Henriques
Quoted 1 line · Amir Goldstein
On Fri, Feb 12, 2021 at 2:40 PM Luis Henriques <[email protected]> wrote:
...
Quoted 18 lines
Quoted 18 lines
Sure, I just wanted to point out that *maybe* there are other options than simply reverting that commit :-)
Something like the patch below (completely untested!) should revert to the old behaviour in filesystems that don't implement the CFR syscall.
Cheers,
--
Luisfs/read_write.c +0
-0@@ -1406,8 +1406,11 @@ static ssize_t do_copy_file_range(struct file *file_in, loff_t pos_in, file_out, pos_out, len, flags);Quoted 11 lines
fs/read_write.c static ssize_t do_copy_file_range(struct file *file_in, loff_t pos_in, · line 1415
Quoted 9 lines
fs/read_write.c +5
-2-return generic_copy_file_range (file_in, pos_in, file_out, pos_out, len, - flags); +if (file_inode (file_in)->i_sb !=file_inode (file_out)->i_sb) +return -EXDEV ; +else +generic_copy_file_range (file_in, pos_in, file_out, pos_out, len, + flags); }Which kernel is this patch based on?
It was v5.11-rc7.
Quoted 7 lines
At this point, I am with Dave and Darrick on not falling back to
generic_copy_file_range()at all.We do not have proof of any workload that benefits from it and the above patch does not protect from a wierd use case of trying to copy a file from sysfs to sysfs.
Ok, cool. I can post a new patch doing just that. I guess that function
do_copy_file_range()can be dropped in that case.Quoted 5 lines
I am indecisive about what should be done with
generic_copy_file_range()called as fallback from within filesystems.I think the wise choice is to not do the fallback in any case, but this is up to the specific filesystem maintainers to decide.
Quoted 9 lines
Quoted 4 lines
I see what you mean. You're suggesting to have userspace handle all the
-EOPNOTSUPPand-EXDEVerrors. Would you rather have a patch that also removes all the calls togeneric_copy_file_range()function? And that function can also be deleted too, of course.Here's a first stab at this patch. Hopefully I didn't forgot anything here. Let me know if you prefer the more conservative approach, i.e. not touching any of the filesystems and let them use
generic_copy_file_range.
I'm fine with this one (modulu my comment below).
CC'ing fuse/cifs/nfs maintainers.
Though I don't think the FS maintainers should mind removing the fallback. It was added by "us" (64bf5ff58dff "vfs: no fallback for ->copy_file_range()")
Quoted 12 lines
Once everyone agrees on the final solution, I can follow-up with the manpages update.
Cheers,
--
LuisFrom
e1b37e80b12601d56f792bd19377d3e5208188efMon Sep 17 00:00:00 2001
From: Luis Henriques <[email protected]>
Date: Fri, 12 Feb 2021 18:03:23 +0000
Subject: [PATCH] vfs: preventcopy_file_rangeto copy across devices
Quoted 8 lines
Nicolas Boichat reported an issue when trying to use the
copy_file_rangesyscall on a tracefs file. It failed silently because the file content is generated on-the-fly (reporting a size of zero) andcopy_file_rangeneeds to know in advance how much data is present.This commit effectively reverts
5dae222a5ff0("vfs: allowcopy_file_rangeto copy across devices"). Now the copy is done only if the filesystems for source and destination files are the same and they implement this syscall.
This paragraph is not true and confusing.
This is not a revert and it does not revert the important part of cross-fs copy for which the original commit was for.
Either rephrase this paragraph or remove it.
Quoted 2 lines
Fixes 5dae222a5ff0 ("vfs: allow copy_file_range to copy across devices")
Please add a Link: to this discussion in lore.
Quoted 189 lines
Cc Nicolas Boichat <[email protected]>Signed-off-by Luis Henriques <[email protected]>--- fs/ceph/file.c | 21 +++------------ fs/cifs/cifsfs.c | 3 --- fs/fuse/file.c | 21 +++------------ fs/nfs/nfs4file.c | 20 +++----------- fs/read_write.c | 65 ++++++++-------------------------------------- include/linux/fs.h | 3 --- 6 files changed, 20 insertions(+), 113 deletions(-)fs/ceph/file.c +3
-18@@ -2261,9 +2261,9 @@ static ssize_t ceph_do_objects_copy(struct ceph_inode_info *src_ci, u64 *src_offreturn bytes; } -static ssize_t __ceph_copy_file_range (struct file *src_file,loff_t src_off, -struct file *dst_file,loff_t dst_off, -size_t len,unsigned int flags) +static ssize_t ceph_copy_file_range (struct file *src_file,loff_t src_off, +struct file *dst_file,loff_t dst_off, +size_t len,unsigned int flags) {struct inode *src_inode =file_inode (src_file);struct inode *dst_inode =file_inode (dst_file);@@ -2456,21 +2456,6 @@ static ssize_t __ceph_copy_file_range(struct file *src_file, loff_t src_off,return ret; } -static ssize_t ceph_copy_file_range (struct file *src_file,loff_t src_off, -struct file *dst_file,loff_t dst_off, -size_t len,unsigned int flags) -{ -ssize_t ret; - - ret =__ceph_copy_file_range (src_file, src_off, dst_file, dst_off, - len, flags); - -if (ret == -EOPNOTSUPP || ret == -EXDEV ) - ret =generic_copy_file_range (src_file, src_off, dst_file, - dst_off, len, flags); -return ret; -} -const struct file_operations ceph_file_fops = { .open = ceph_open, .release = ceph_release,fs/cifs/cifsfs.c +0
-3@@ -1229,9 +1229,6 @@ static ssize_t cifs_copy_file_range(struct file *src_file, loff_t off, len, flags);free_xid (xid); -if (rc == -EOPNOTSUPP || rc == -EXDEV ) - rc =generic_copy_file_range (src_file, off, dst_file, - destoff, len, flags);return rc; }fs/fuse/file.c +3
-18@@ -3330,9 +3330,9 @@ static long fuse_file_fallocate(struct file *file, int mode, loff_t offset,return err; } -static ssize_t __fuse_copy_file_range (struct file *file_in,loff_t pos_in, -struct file *file_out,loff_t pos_out, -size_t len,unsigned int flags) +static ssize_t fuse_copy_file_range (struct file *file_in,loff_t pos_in, +struct file *file_out,loff_t pos_out, +size_t len,unsigned int flags) {struct fuse_file *ff_in = file_in->private_data;struct fuse_file *ff_out = file_out->private_data;@@ -3439,21 +3439,6 @@ static ssize_t __fuse_copy_file_range(struct file *file_in, loff_t pos_in,return err; } -static ssize_t fuse_copy_file_range (struct file *src_file,loff_t src_off, -struct file *dst_file,loff_t dst_off, -size_t len,unsigned int flags) -{ -ssize_t ret; - - ret =__fuse_copy_file_range (src_file, src_off, dst_file, dst_off, - len, flags); - -if (ret == -EOPNOTSUPP || ret == -EXDEV ) - ret =generic_copy_file_range (src_file, src_off, dst_file, - dst_off, len, flags); -return ret; -} -static const struct file_operations fuse_file_operations = { .llseek = fuse_file_llseek, .read_iter = fuse_file_read_iter,fs/nfs/nfs4file.c +3
-17@@ -133,9 +133,9 @@ nfs4_file_flush(struct file *file, fl_owner_t id) }#ifdef CONFIG_NFS_V4_2 -static ssize_t __nfs4_copy_file_range (struct file *file_in,loff_t pos_in, -struct file *file_out,loff_t pos_out, -size_t count,unsigned int flags) +static ssize_t nfs4_copy_file_range (struct file *file_in,loff_t pos_in, +struct file *file_out,loff_t pos_out, +size_t count,unsigned int flags) {struct nfs42_copy_notify_res *cn_resp =NULL ;struct nl4_server *nss =NULL ;@@ -189,20 +189,6 @@ static ssize_t __nfs4_copy_file_range(struct file *file_in, loff_t pos_in,return ret; } -static ssize_t nfs4_copy_file_range (struct file *file_in,loff_t pos_in, -struct file *file_out,loff_t pos_out, -size_t count,unsigned int flags) -{ -ssize_t ret; - - ret =__nfs4_copy_file_range (file_in, pos_in, file_out, pos_out, count, - flags); -if (ret == -EOPNOTSUPP || ret == -EXDEV ) - ret =generic_copy_file_range (file_in, pos_in, file_out, - pos_out, count, flags); -return ret; -} -static loff_t nfs4_file_llseek (struct file *filep,loff_t offset,int whence) {loff_t ret;fs/read_write.c +0
-40@@ -1358,58 +1358,6 @@ COMPAT_SYSCALL_DEFINE4(sendfile64, int, out_fd, int, in_fd, }#endif -/** -* generic_copy_file_range - copy data between two files -* @file_in: file structure to read from -* @pos_in: file offset to read from -* @file_out: file structure to write data to -* @pos_out: file offset to write data to -* @len: amount of data to copy -* @flags: copy flags -* -* This is a generic filesystem helper to copy data from one file to another. -* It has no constraints on the source or destination file owners - the files -* can belong to different superblocks and different filesystem types. Short -* copies are allowed. -* -* This should be called from the @file_out filesystem, as per the -* ->copy_file_range() method. -* -* Returns the number of bytes copied or a negative error indicating the -* failure. -*/ - -ssize_t generic_copy_file_range (struct file *file_in,loff_t pos_in, -struct file *file_out,loff_t pos_out, -size_t len,unsigned int flags) -{ -return do_splice_direct (file_in, &pos_in, file_out, &pos_out, - len >MAX_RW_COUNT ?MAX_RW_COUNT : len,0 ); -} -EXPORT_SYMBOL (generic_copy_file_range); - -static ssize_t do_copy_file_range (struct file *file_in,loff_t pos_in, -struct file *file_out,loff_t pos_out, -size_t len,unsigned int flags) -{ -/* -* Although we now allow filesystems to handle cross sb copy, passing -* a file of the wrong filesystem type to filesystem driver can result -* in an attempt to dereference the wrong type of ->private_data, so -* avoid doing that until we really have a good reason. NFS defines -* several different file_system_type structures, but they all end up
fs/read_write.c COMPAT_SYSCALL_DEFINE4(sendfile64, int, out_fd, int, in_fd, · line 1410
Quoted 10 lines
fs/read_write.c +0
-10-* using the same ->copy_file_range() function pointer. -*/ -if (file_out->f_op->copy_file_range && - file_out->f_op->copy_file_range == file_in->f_op->copy_file_range) -return file_out->f_op->copy_file_range (file_in, pos_in, - file_out, pos_out, - len, flags); - -return generic_copy_file_range (file_in, pos_in, file_out, pos_out, len, - flags);
Please do not remove the big comment above - it is there for a reason.
The case of !file_out->f_op->copy_file_range should return -EOPNOTSUPP because the outcome of -EXDEV for copy to/from the same fs is confusing.
Either leave this helper and only remove generic_copy_file_range() or open code the same logic (including comment) in the caller.
fs/read_write.c ssize_t vfs_copy_file_range(struct file *file_in, loff_t pos_in, · line 1428
Quoted 13 lines
fs/read_write.c +4
-2-} -/* * Performs necessary checks before doing a file copy * @@ -1474,6 +1422,14 @@ ssize_t vfs_copy_file_range(struct file *file_in, loff_t pos_in, {ssize_t ret; +/* +* Allow the copy only if the filesystems for file_in and file_out are +* the same, and copy_file_range is implemented. +*/
This comment is wrong. See the big fat comment above to understand why. Also this check is in the wrong place because it misses the case of file_in->f_op->remap_file_range && !file_out->f_op->copy_file_range
As I wrote above either leave the helper do_copy_file_range() or open code it in its current location.
Quoted 8 lines
fs/read_write.c +4
-0+if (!file_out->f_op->copy_file_range || + (file_out->f_op->copy_file_range != file_in->f_op->copy_file_range)) +return -EXDEV ; +if (flags !=0 )return -EINVAL ;
fs/read_write.c ssize_t vfs_copy_file_range(struct file *file_in, loff_t pos_in, · line 1475
Quoted 9 lines
fs/read_write.c +3
-2@@ -1513,8 +1469,9 @@ ssize_t vfs_copy_file_range(struct file *file_in, loff_t pos_in, } } - ret =do_copy_file_range (file_in, pos_in, file_out, pos_out, len, - flags); + ret = file_out->f_op->copy_file_range (file_in, pos_in, + file_out, pos_out, + len, flags);WARN_ON_ONCE (ret == -EOPNOTSUPP );
Please remove this line.
filesystem ops can now return -EOPNOTSUPP.
Thanks,
Amir.
Re: [PATCH 1/6] fs: Add flag to file_system_type to indicate content is generated
Quoted 67 lines · Amir Goldstein
Quoted 56 lines · Luis Henriques
Quoted 53 lines · Luis Henriques
Quoted 1 line · Amir Goldstein
On Fri, Feb 12, 2021 at 2:40 PM Luis Henriques <[email protected]> wrote:
...
Quoted 18 lines
Quoted 18 lines
Sure, I just wanted to point out that *maybe* there are other options than simply reverting that commit :-)
Something like the patch below (completely untested!) should revert to the old behaviour in filesystems that don't implement the CFR syscall.
Cheers,
--
Luisfs/read_write.c +0
-0@@ -1406,8 +1406,11 @@ static ssize_t do_copy_file_range(struct file *file_in, loff_t pos_in, file_out, pos_out, len, flags);Quoted 11 lines
fs/read_write.c static ssize_t do_copy_file_range(struct file *file_in, loff_t pos_in, · line 1415
Quoted 9 lines
fs/read_write.c +5
-2-return generic_copy_file_range (file_in, pos_in, file_out, pos_out, len, - flags); +if (file_inode (file_in)->i_sb !=file_inode (file_out)->i_sb) +return -EXDEV ; +else +generic_copy_file_range (file_in, pos_in, file_out, pos_out, len, + flags); }Which kernel is this patch based on?
It was v5.11-rc7.
Quoted 7 lines
At this point, I am with Dave and Darrick on not falling back to
generic_copy_file_range()at all.We do not have proof of any workload that benefits from it and the above patch does not protect from a wierd use case of trying to copy a file from sysfs to sysfs.
Ok, cool. I can post a new patch doing just that. I guess that function
do_copy_file_range()can be dropped in that case.Quoted 5 lines
I am indecisive about what should be done with
generic_copy_file_range()called as fallback from within filesystems.I think the wise choice is to not do the fallback in any case, but this is up to the specific filesystem maintainers to decide.
Quoted 9 lines
Quoted 4 lines
I see what you mean. You're suggesting to have userspace handle all the
-EOPNOTSUPPand-EXDEVerrors. Would you rather have a patch that also removes all the calls togeneric_copy_file_range()function? And that function can also be deleted too, of course.Here's a first stab at this patch. Hopefully I didn't forgot anything here. Let me know if you prefer the more conservative approach, i.e. not touching any of the filesystems and let them use
generic_copy_file_range.
Quoted 4 lines
I'm fine with this one (modulu my comment below).
CC'ing fuse/cifs/nfs maintainers.
Though I don't think the FS maintainers should mind removing the fallback. It was added by "us" (64bf5ff58dff"vfs: no fallback for ->copy_file_range()")
Thanks for your review, Amir. I'll be posting v2 shortly.
Cheers,
Signature · 1 line
Luis
Quoted 283 lines
Quoted 12 lines
Once everyone agrees on the final solution, I can follow-up with the manpages update.
Cheers,
--
LuisFrom
e1b37e80b12601d56f792bd19377d3e5208188efMon Sep 17 00:00:00 2001
From: Luis Henriques <[email protected]>
Date: Fri, 12 Feb 2021 18:03:23 +0000
Subject: [PATCH] vfs: preventcopy_file_rangeto copy across devicesQuoted 8 lines
Nicolas Boichat reported an issue when trying to use the
copy_file_rangesyscall on a tracefs file. It failed silently because the file content is generated on-the-fly (reporting a size of zero) andcopy_file_rangeneeds to know in advance how much data is present.This commit effectively reverts
5dae222a5ff0("vfs: allowcopy_file_rangeto copy across devices"). Now the copy is done only if the filesystems for source and destination files are the same and they implement this syscall.This paragraph is not true and confusing.
This is not a revert and it does not revert the important part of cross-fs copy for which the original commit was for.
Either rephrase this paragraph or remove it.Quoted 2 lines
Fixes 5dae222a5ff0 ("vfs: allow copy_file_range to copy across devices")Please add a Link: to this discussion in lore.
Quoted 189 lines
Cc Nicolas Boichat <[email protected]>Signed-off-by Luis Henriques <[email protected]>--- fs/ceph/file.c | 21 +++------------ fs/cifs/cifsfs.c | 3 --- fs/fuse/file.c | 21 +++------------ fs/nfs/nfs4file.c | 20 +++----------- fs/read_write.c | 65 ++++++++-------------------------------------- include/linux/fs.h | 3 --- 6 files changed, 20 insertions(+), 113 deletions(-)fs/ceph/file.c +3
-18@@ -2261,9 +2261,9 @@ static ssize_t ceph_do_objects_copy(struct ceph_inode_info *src_ci, u64 *src_offreturn bytes; } -static ssize_t __ceph_copy_file_range (struct file *src_file,loff_t src_off, -struct file *dst_file,loff_t dst_off, -size_t len,unsigned int flags) +static ssize_t ceph_copy_file_range (struct file *src_file,loff_t src_off, +struct file *dst_file,loff_t dst_off, +size_t len,unsigned int flags) {struct inode *src_inode =file_inode (src_file);struct inode *dst_inode =file_inode (dst_file);@@ -2456,21 +2456,6 @@ static ssize_t __ceph_copy_file_range(struct file *src_file, loff_t src_off,return ret; } -static ssize_t ceph_copy_file_range (struct file *src_file,loff_t src_off, -struct file *dst_file,loff_t dst_off, -size_t len,unsigned int flags) -{ -ssize_t ret; - - ret =__ceph_copy_file_range (src_file, src_off, dst_file, dst_off, - len, flags); - -if (ret == -EOPNOTSUPP || ret == -EXDEV ) - ret =generic_copy_file_range (src_file, src_off, dst_file, - dst_off, len, flags); -return ret; -} -const struct file_operations ceph_file_fops = { .open = ceph_open, .release = ceph_release,fs/cifs/cifsfs.c +0
-3@@ -1229,9 +1229,6 @@ static ssize_t cifs_copy_file_range(struct file *src_file, loff_t off, len, flags);free_xid (xid); -if (rc == -EOPNOTSUPP || rc == -EXDEV ) - rc =generic_copy_file_range (src_file, off, dst_file, - destoff, len, flags);return rc; }fs/fuse/file.c +3
-18@@ -3330,9 +3330,9 @@ static long fuse_file_fallocate(struct file *file, int mode, loff_t offset,return err; } -static ssize_t __fuse_copy_file_range (struct file *file_in,loff_t pos_in, -struct file *file_out,loff_t pos_out, -size_t len,unsigned int flags) +static ssize_t fuse_copy_file_range (struct file *file_in,loff_t pos_in, +struct file *file_out,loff_t pos_out, +size_t len,unsigned int flags) {struct fuse_file *ff_in = file_in->private_data;struct fuse_file *ff_out = file_out->private_data;@@ -3439,21 +3439,6 @@ static ssize_t __fuse_copy_file_range(struct file *file_in, loff_t pos_in,return err; } -static ssize_t fuse_copy_file_range (struct file *src_file,loff_t src_off, -struct file *dst_file,loff_t dst_off, -size_t len,unsigned int flags) -{ -ssize_t ret; - - ret =__fuse_copy_file_range (src_file, src_off, dst_file, dst_off, - len, flags); - -if (ret == -EOPNOTSUPP || ret == -EXDEV ) - ret =generic_copy_file_range (src_file, src_off, dst_file, - dst_off, len, flags); -return ret; -} -static const struct file_operations fuse_file_operations = { .llseek = fuse_file_llseek, .read_iter = fuse_file_read_iter,fs/nfs/nfs4file.c +3
-17@@ -133,9 +133,9 @@ nfs4_file_flush(struct file *file, fl_owner_t id) }#ifdef CONFIG_NFS_V4_2 -static ssize_t __nfs4_copy_file_range (struct file *file_in,loff_t pos_in, -struct file *file_out,loff_t pos_out, -size_t count,unsigned int flags) +static ssize_t nfs4_copy_file_range (struct file *file_in,loff_t pos_in, +struct file *file_out,loff_t pos_out, +size_t count,unsigned int flags) {struct nfs42_copy_notify_res *cn_resp =NULL ;struct nl4_server *nss =NULL ;@@ -189,20 +189,6 @@ static ssize_t __nfs4_copy_file_range(struct file *file_in, loff_t pos_in,return ret; } -static ssize_t nfs4_copy_file_range (struct file *file_in,loff_t pos_in, -struct file *file_out,loff_t pos_out, -size_t count,unsigned int flags) -{ -ssize_t ret; - - ret =__nfs4_copy_file_range (file_in, pos_in, file_out, pos_out, count, - flags); -if (ret == -EOPNOTSUPP || ret == -EXDEV ) - ret =generic_copy_file_range (file_in, pos_in, file_out, - pos_out, count, flags); -return ret; -} -static loff_t nfs4_file_llseek (struct file *filep,loff_t offset,int whence) {loff_t ret;fs/read_write.c +0
-40@@ -1358,58 +1358,6 @@ COMPAT_SYSCALL_DEFINE4(sendfile64, int, out_fd, int, in_fd, }#endif -/** -* generic_copy_file_range - copy data between two files -* @file_in: file structure to read from -* @pos_in: file offset to read from -* @file_out: file structure to write data to -* @pos_out: file offset to write data to -* @len: amount of data to copy -* @flags: copy flags -* -* This is a generic filesystem helper to copy data from one file to another. -* It has no constraints on the source or destination file owners - the files -* can belong to different superblocks and different filesystem types. Short -* copies are allowed. -* -* This should be called from the @file_out filesystem, as per the -* ->copy_file_range() method. -* -* Returns the number of bytes copied or a negative error indicating the -* failure. -*/ - -ssize_t generic_copy_file_range (struct file *file_in,loff_t pos_in, -struct file *file_out,loff_t pos_out, -size_t len,unsigned int flags) -{ -return do_splice_direct (file_in, &pos_in, file_out, &pos_out, - len >MAX_RW_COUNT ?MAX_RW_COUNT : len,0 ); -} -EXPORT_SYMBOL (generic_copy_file_range); - -static ssize_t do_copy_file_range (struct file *file_in,loff_t pos_in, -struct file *file_out,loff_t pos_out, -size_t len,unsigned int flags) -{ -/* -* Although we now allow filesystems to handle cross sb copy, passing -* a file of the wrong filesystem type to filesystem driver can result -* in an attempt to dereference the wrong type of ->private_data, so -* avoid doing that until we really have a good reason. NFS defines -* several different file_system_type structures, but they all end up fs/read_write.c COMPAT_SYSCALL_DEFINE4(sendfile64, int, out_fd, int, in_fd, · line 1410
Quoted 10 lines
fs/read_write.c +0
-10-* using the same ->copy_file_range() function pointer. -*/ -if (file_out->f_op->copy_file_range && - file_out->f_op->copy_file_range == file_in->f_op->copy_file_range) -return file_out->f_op->copy_file_range (file_in, pos_in, - file_out, pos_out, - len, flags); - -return generic_copy_file_range (file_in, pos_in, file_out, pos_out, len, - flags);Please do not remove the big comment above - it is there for a reason.
The case of !file_out->f_op->copy_file_range should return
-EOPNOTSUPPbecause the outcome of-EXDEVfor copy to/from the same fs is confusing.Either leave this helper and only remove
generic_copy_file_range()or open code the same logic (including comment) in the caller.fs/read_write.c ssize_t vfs_copy_file_range(struct file *file_in, loff_t pos_in, · line 1428
Quoted 13 lines
fs/read_write.c +4
-2-} -/* * Performs necessary checks before doing a file copy * @@ -1474,6 +1422,14 @@ ssize_t vfs_copy_file_range(struct file *file_in, loff_t pos_in, {ssize_t ret; +/* +* Allow the copy only if the filesystems for file_in and file_out are +* the same, and copy_file_range is implemented. +*/ This comment is wrong. See the big fat comment above to understand why. Also this check is in the wrong place because it misses the case of
file_in->f_op->remap_file_range&& !file_out->f_op->copy_file_rangeAs I wrote above either leave the helper
do_copy_file_range()or open code it in its current location.Quoted 8 lines
fs/read_write.c +4
-0+if (!file_out->f_op->copy_file_range || + (file_out->f_op->copy_file_range != file_in->f_op->copy_file_range)) +return -EXDEV ; +if (flags !=0 )return -EINVAL ;fs/read_write.c ssize_t vfs_copy_file_range(struct file *file_in, loff_t pos_in, · line 1475
Quoted 9 lines
fs/read_write.c +3
-2@@ -1513,8 +1469,9 @@ ssize_t vfs_copy_file_range(struct file *file_in, loff_t pos_in, } } - ret =do_copy_file_range (file_in, pos_in, file_out, pos_out, len, - flags); + ret = file_out->f_op->copy_file_range (file_in, pos_in, + file_out, pos_out, + len, flags);WARN_ON_ONCE (ret == -EOPNOTSUPP );Please remove this line.
filesystem ops can now return-EOPNOTSUPP.Thanks,
Amir.
PATCH v2 1/1 vfs: prevent copy_file_range to copy across devices
In reply to Amir GoldsteinNicolas Boichat reported an issue when trying to use the copy_file_range syscall on a tracefs file. It failed silently because the file content is generated on-the-fly (reporting a size of zero) and copy_file_range needs to know in advance how much data is present.
This commit restores the cross-fs restrictions that existed prior to 5dae222a5ff0 ("vfs: allow copy_file_range to copy across devices") and removes generic_copy_file_range() calls from ceph, cifs, fuse, and nfs.
---
Changes since v1 (after Amir review)
- restored do_copy_file_range() helper
- return -EOPNOTSUPP if fs doesn't implement CFR
- updated commit description
fs/ceph/file.c | 21 +++----------------- fs/cifs/cifsfs.c | 3 --- fs/fuse/file.c | 21 +++----------------- fs/nfs/nfs4file.c | 20 +++---------------- fs/read_write.c | 49 ++++++++++------------------------------------ include/linux/fs.h | 3 --- 6 files changed, 19 insertions(+), 98 deletions(-)
fs/ceph/file.c +3 -18
@@ -2261,9 +2261,9 @@ static ssize_t ceph_do_objects_copy(struct ceph_inode_info *src_ci, u64 *src_offreturn bytes; } -static ssize_t __ceph_copy_file_range (struct file *src_file,loff_t src_off, -struct file *dst_file,loff_t dst_off, -size_t len,unsigned int flags) +static ssize_t ceph_copy_file_range (struct file *src_file,loff_t src_off, +struct file *dst_file,loff_t dst_off, +size_t len,unsigned int flags) {struct inode *src_inode =file_inode (src_file);struct inode *dst_inode =file_inode (dst_file);
@@ -2456,21 +2456,6 @@ static ssize_t __ceph_copy_file_range(struct file *src_file, loff_t src_off,return ret; } -static ssize_t ceph_copy_file_range (struct file *src_file,loff_t src_off, -struct file *dst_file,loff_t dst_off, -size_t len,unsigned int flags) -{ -ssize_t ret; - - ret =__ceph_copy_file_range (src_file, src_off, dst_file, dst_off, - len, flags); - -if (ret == -EOPNOTSUPP || ret == -EXDEV ) - ret =generic_copy_file_range (src_file, src_off, dst_file, - dst_off, len, flags); -return ret; -} -const struct file_operations ceph_file_fops = { .open = ceph_open, .release = ceph_release,
fs/cifs/cifsfs.c +0 -3
@@ -1229,9 +1229,6 @@ static ssize_t cifs_copy_file_range(struct file *src_file, loff_t off, len, flags);free_xid (xid); -if (rc == -EOPNOTSUPP || rc == -EXDEV ) - rc =generic_copy_file_range (src_file, off, dst_file, - destoff, len, flags);return rc; }
fs/fuse/file.c +3 -18
@@ -3330,9 +3330,9 @@ static long fuse_file_fallocate(struct file *file, int mode, loff_t offset,return err; } -static ssize_t __fuse_copy_file_range (struct file *file_in,loff_t pos_in, -struct file *file_out,loff_t pos_out, -size_t len,unsigned int flags) +static ssize_t fuse_copy_file_range (struct file *file_in,loff_t pos_in, +struct file *file_out,loff_t pos_out, +size_t len,unsigned int flags) {struct fuse_file *ff_in = file_in->private_data;struct fuse_file *ff_out = file_out->private_data;
@@ -3439,21 +3439,6 @@ static ssize_t __fuse_copy_file_range(struct file *file_in, loff_t pos_in,return err; } -static ssize_t fuse_copy_file_range (struct file *src_file,loff_t src_off, -struct file *dst_file,loff_t dst_off, -size_t len,unsigned int flags) -{ -ssize_t ret; - - ret =__fuse_copy_file_range (src_file, src_off, dst_file, dst_off, - len, flags); - -if (ret == -EOPNOTSUPP || ret == -EXDEV ) - ret =generic_copy_file_range (src_file, src_off, dst_file, - dst_off, len, flags); -return ret; -} -static const struct file_operations fuse_file_operations = { .llseek = fuse_file_llseek, .read_iter = fuse_file_read_iter,
fs/nfs/nfs4file.c +3 -17
@@ -133,9 +133,9 @@ nfs4_file_flush(struct file *file, fl_owner_t id) }#ifdef CONFIG_NFS_V4_2 -static ssize_t __nfs4_copy_file_range (struct file *file_in,loff_t pos_in, -struct file *file_out,loff_t pos_out, -size_t count,unsigned int flags) +static ssize_t nfs4_copy_file_range (struct file *file_in,loff_t pos_in, +struct file *file_out,loff_t pos_out, +size_t count,unsigned int flags) {struct nfs42_copy_notify_res *cn_resp =NULL ;struct nl4_server *nss =NULL ;
@@ -189,20 +189,6 @@ static ssize_t __nfs4_copy_file_range(struct file *file_in, loff_t pos_in,return ret; } -static ssize_t nfs4_copy_file_range (struct file *file_in,loff_t pos_in, -struct file *file_out,loff_t pos_out, -size_t count,unsigned int flags) -{ -ssize_t ret; - - ret =__nfs4_copy_file_range (file_in, pos_in, file_out, pos_out, count, - flags); -if (ret == -EOPNOTSUPP || ret == -EXDEV ) - ret =generic_copy_file_range (file_in, pos_in, file_out, - pos_out, count, flags); -return ret; -} -static loff_t nfs4_file_llseek (struct file *filep,loff_t offset,int whence) {loff_t ret;
fs/read_write.c +10 -39
72 lines not on this page · raw message
include/linux/fs.h +0 -3
@@ -1910,9 +1910,6 @@ extern ssize_t vfs_read(struct file *, char __user *, size_t, loff_t *);extern ssize_t vfs_write (struct file *,const char __user *,size_t ,loff_t *);extern ssize_t vfs_copy_file_range (struct file *,loff_t ,struct file *,loff_t ,size_t ,unsigned int ); -extern ssize_t generic_copy_file_range (struct file *file_in,loff_t pos_in, -struct file *file_out,loff_t pos_out, -size_t len,unsigned int flags); extern int generic_remap_file_range_prep(struct file *file_in, loff_t pos_in, struct file *file_out, loff_t pos_out, loff_t *count,
Re: [PATCH v2] vfs: prevent copy_file_range to copy across devices
Quoted 7 lines · Luis Henriques
Nicolas Boichat reported an issue when trying to use the
copy_file_range
syscall on a tracefs file. It failed silently because the file content is
generated on-the-fly (reporting a size of zero) andcopy_file_rangeneeds
to know in advance how much data is present.
That explanation makes no sense whatsoever. copy_file_range is a non- atomic operation and so the file can change while being copied. Any determination of 'how much data is present' that is made in advance would therefore be a flaw in the copy process being used (i.e. do_splice_direct()). Does sendfile() also 'issue' in the same way?
Signature · 3 lines
Trond Myklebust Linux NFS client maintainer, Hammerspace [email protected]
Re: [PATCH v2] vfs: prevent copy_file_range to copy across devices
Quoted 10 lines · Trond Myklebust
Quoted 7 lines · Luis Henriques
Nicolas Boichat reported an issue when trying to use the
copy_file_range
syscall on a tracefs file. It failed silently because the file content is
generated on-the-fly (reporting a size of zero) andcopy_file_rangeneeds
to know in advance how much data is present.
Quoted 5 lines
That explanation makes no sense whatsoever.
copy_file_rangeis a non- atomic operation and so the file can change while being copied. Any determination of 'how much data is present' that is made in advance would therefore be a flaw in the copy process being used (i.e.do_splice_direct()). Doessendfile()also 'issue' in the same way?
I agree that the explanation of the tracefs problem motivating this patch doesn't make sense.
Signature · 3 lines
Thanks, Steve
Re: [PATCH v2] vfs: prevent copy_file_range to copy across devices
In reply to Luis HenriquesQuoted 6 lines · Luis Henriques
Nicolas Boichat reported an issue when trying to use the
copy_file_rangesyscall on a tracefs file. It failed silently because the file content is generated on-the-fly (reporting a size of zero) andcopy_file_rangeneeds to know in advance how much data is present.
Quoted 8 lines
This commit restores the cross-fs restrictions that existed prior to
5dae222a5ff0("vfs: allowcopy_file_rangeto copy across devices") and removesgeneric_copy_file_range()calls from ceph, cifs, fuse, and nfs.Fixes 5dae222a5ff0 ("vfs: allow copy_file_range to copy across devices")Cc Nicolas Boichat <[email protected]>Signed-off-by Luis Henriques <[email protected]>
Code looks ok.
You may add:
I agree with Trond that the first paragraph of the commit message could be improved.
The purpose of this change is to fix the change of behavior that caused the regression.
Before v5.3, behavior was -EXDEV and userspace could fallback to read. After v5.3, behavior is zero size copy.
It does not matter so much what makes sense for CFR to do in this case (generic cross-fs copy). What matters is that nobody asked for this change and that it caused problems.
Thanks,
Amir.
Re: [PATCH v2] vfs: prevent copy_file_range to copy across devices
Quoted 36 lines · Amir Goldstein
Quoted 16 lines · Luis Henriques
Nicolas Boichat reported an issue when trying to use the
copy_file_range
syscall on a tracefs file. It failed silently because the file content is
generated on-the-fly (reporting a size of zero) andcopy_file_rangeneeds
to know in advance how much data is present.This commit restores the cross-fs restrictions that existed prior to
5dae222a5ff0("vfs: allowcopy_file_rangeto copy across devices") and
removesgeneric_copy_file_range()calls from ceph, cifs, fuse, and nfs.Quoted 6 lines
Fixes 5dae222a5ff0 ("vfs: allow copy_file_range to copy acrossdevices")
Link:
https://lore.kernel.org/linux-fsdevel/[email protected]/Cc Nicolas Boichat <[email protected]>Signed-off-by Luis Henriques <[email protected]>Code looks ok.
You may add:Reviewed-by Amir Goldstein <[email protected]>I agree with Trond that the first paragraph of the commit message could
be improved.
The purpose of this change is to fix the change of behavior that caused the regression.
Quoted 8 lines
Before v5.3, behavior was
-EXDEVand userspace could fallback to read.
After v5.3, behavior is zero size copy.It does not matter so much what makes sense for CFR to do in this case (generic cross-fs copy). What matters is that nobody asked for this change and that it caused problems.
No. I'm saying that this patch should be NACKed unless there is a real explanation for why we give crap about this tracefs corner case and why it can't be fixed.
There are plenty of reasons why copy offload across filesystems makes sense, and particularly when you're doing NAS. Clone just doesn't cut it when it comes to disaster recovery (whereas backup to a different storage unit does). If the client has to do the copy, then you're effectively doubling the load on the server, and you're adding potentially unnecessary network traffic (or at the very least you are doubling that traffic).
Signature · 3 lines
Trond Myklebust Linux NFS client maintainer, Hammerspace [email protected]
Re: [PATCH v2] vfs: prevent copy_file_range to copy across devices
Quoted 51 lines · Trond Myklebust
Quoted 36 lines · Amir Goldstein
Quoted 16 lines · Luis Henriques
Nicolas Boichat reported an issue when trying to use the
copy_file_range
syscall on a tracefs file. It failed silently because the file content is
generated on-the-fly (reporting a size of zero) andcopy_file_rangeneeds
to know in advance how much data is present.This commit restores the cross-fs restrictions that existed prior to
5dae222a5ff0("vfs: allowcopy_file_rangeto copy across devices") and
removesgeneric_copy_file_range()calls from ceph, cifs, fuse, and nfs.Quoted 6 lines
Fixes 5dae222a5ff0 ("vfs: allow copy_file_range to copy acrossdevices")
Link:
https://lore.kernel.org/linux-fsdevel/[email protected]/Cc Nicolas Boichat <[email protected]>Signed-off-by Luis Henriques <[email protected]>Code looks ok.
You may add:Reviewed-by Amir Goldstein <[email protected]>I agree with Trond that the first paragraph of the commit message could
be improved.
The purpose of this change is to fix the change of behavior that caused the regression.Quoted 8 lines
Before v5.3, behavior was
-EXDEVand userspace could fallback to read.
After v5.3, behavior is zero size copy.It does not matter so much what makes sense for CFR to do in this case (generic cross-fs copy). What matters is that nobody asked for this change and that it caused problems.
No. I'm saying that this patch should be NACKed unless there is a real explanation for why we give crap about this tracefs corner case and why it can't be fixed.
Quoted 8 lines
There are plenty of reasons why copy offload across filesystems makes sense, and particularly when you're doing NAS. Clone just doesn't cut it when it comes to disaster recovery (whereas backup to a different storage unit does). If the client has to do the copy, then you're effectively doubling the load on the server, and you're adding potentially unnecessary network traffic (or at the very least you are doubling that traffic).
I don't understand the use case you are describing.
Which filesystem types are you talking about for source and target of copy_file_range()?
To be clear, the original change was done to support NFS/CIFS server-side copy and those should not be affected by this change.
Thanks,
Amir.
Re: [PATCH v2] vfs: prevent copy_file_range to copy across devices
Quoted 74 lines · Amir Goldstein
Quoted 59 lines · Trond Myklebust
Quoted 41 lines · Amir Goldstein
Quoted 20 lines · Luis Henriques
Nicolas Boichat reported an issue when trying to use the
copy_file_range
syscall on a tracefs file. It failed silently because the file content is
generated on-the-fly (reporting a size of zero) andcopy_file_range
needs
to know in advance how much data is present.This commit restores the cross-fs restrictions that existed prior
to5dae222a5ff0("vfs: allowcopy_file_rangeto copy across devices")
and
removesgeneric_copy_file_range()calls from ceph, cifs, fuse, and
nfs.Quoted 6 lines
Fixes 5dae222a5ff0 ("vfs: allow copy_file_range to copy acrossdevices")
Link:
https://lore.kernel.org/linux-fsdevel/[email protected]/Cc Nicolas Boichat <[email protected]>Signed-off-by Luis Henriques <[email protected]>Code looks ok.
You may add:Reviewed-by Amir Goldstein <[email protected]>I agree with Trond that the first paragraph of the commit message could
be improved.
The purpose of this change is to fix the change of behavior that caused the regression.Quoted 9 lines
Before v5.3, behavior was
-EXDEVand userspace could fallback to read.
After v5.3, behavior is zero size copy.It does not matter so much what makes sense for CFR to do in this case (generic cross-fs copy). What matters is that nobody asked for
this change and that it caused problems.No. I'm saying that this patch should be NACKed unless there is a real
explanation for why we give crap about this tracefs corner case and why
it can't be fixed.Quoted 12 lines
There are plenty of reasons why copy offload across filesystems makes
sense, and particularly when you're doing NAS. Clone just doesn't cut
it when it comes to disaster recovery (whereas backup to a different
storage unit does). If the client has to do the copy, then you're effectively doubling the load on the server, and you're adding potentially unnecessary network traffic (or at the very least you are
doubling that traffic).
Quoted 9 lines
I don't understand the use case you are describing.
Which filesystem types are you talking about for source and target of
copy_file_range()?To be clear, the original change was done to support NFS/CIFS server- side
copy and those should not be affected by this change.
That is incorrect:
ssize_t nfsd_copy_file_range(struct file *src, u64 src_pos, struct file *dst,
u64 dst_pos, u64 count)
{
/*
* Limit copy to 4MB to prevent indefinitely blocking an nfsd
* thread and client rpc slot. The choice of 4MB is somewhat
* arbitrary. We might instead base this on r/wsize, or make it
* tunable, or use a time instead of a byte limit, or implement
* asynchronous copy. In theory a client could also recognize a
* limit like this and pipeline multiple COPY requests. */
count = min_t(u64, count, 1 << 22);
return vfs_copy_file_range(src, src_pos, dst, dst_pos, count, 0);
}
You are now explicitly changing the behaviour of knfsd when the source and destination filesystem differ.
For one thing, you are disallowing the NFSv4.2 copy offload use case of copying from a local filesystem to a remote NFS server. However you are also disallowing the copy from, say, an XFS formatted partition to an ext4 partition.
Signature · 3 lines
Trond Myklebust Linux NFS client maintainer, Hammerspace [email protected]
Re: [PATCH v2] vfs: prevent copy_file_range to copy across devices
Quoted 105 lines · Trond Myklebust
Quoted 74 lines · Amir Goldstein
Quoted 59 lines · Trond Myklebust
Quoted 41 lines · Amir Goldstein
Quoted 20 lines · Luis Henriques
Nicolas Boichat reported an issue when trying to use the
copy_file_range
syscall on a tracefs file. It failed silently because the file content is
generated on-the-fly (reporting a size of zero) andcopy_file_range
needs
to know in advance how much data is present.This commit restores the cross-fs restrictions that existed prior
to5dae222a5ff0("vfs: allowcopy_file_rangeto copy across devices")
and
removesgeneric_copy_file_range()calls from ceph, cifs, fuse, and
nfs.Quoted 6 lines
Fixes 5dae222a5ff0 ("vfs: allow copy_file_range to copy acrossdevices")
Link:
https://lore.kernel.org/linux-fsdevel/[email protected]/Cc Nicolas Boichat <[email protected]>Signed-off-by Luis Henriques <[email protected]>Code looks ok.
You may add:Reviewed-by Amir Goldstein <[email protected]>I agree with Trond that the first paragraph of the commit message could
be improved.
The purpose of this change is to fix the change of behavior that caused the regression.Quoted 9 lines
Before v5.3, behavior was
-EXDEVand userspace could fallback to read.
After v5.3, behavior is zero size copy.It does not matter so much what makes sense for CFR to do in this case (generic cross-fs copy). What matters is that nobody asked for
this change and that it caused problems.No. I'm saying that this patch should be NACKed unless there is a real
explanation for why we give crap about this tracefs corner case and why
it can't be fixed.Quoted 12 lines
There are plenty of reasons why copy offload across filesystems makes
sense, and particularly when you're doing NAS. Clone just doesn't cut
it when it comes to disaster recovery (whereas backup to a different
storage unit does). If the client has to do the copy, then you're effectively doubling the load on the server, and you're adding potentially unnecessary network traffic (or at the very least you are
doubling that traffic).Quoted 9 lines
I don't understand the use case you are describing.
Which filesystem types are you talking about for source and target of
copy_file_range()?To be clear, the original change was done to support NFS/CIFS server- side
copy and those should not be affected by this change.That is incorrect:
ssize_tnfsd_copy_file_range(struct file *src, u64src_pos, struct file *dst,
u64dst_pos, u64 count)
{/*
* Limit copy to 4MB to prevent indefinitely blocking an nfsd
* thread and client rpc slot. The choice of 4MB is somewhat
* arbitrary. We might instead base this on r/wsize, or make it
* tunable, or use a time instead of a byte limit, or implement
* asynchronous copy. In theory a client could also recognize a
* limit like this and pipeline multiple COPY requests. */
count =min_t(u64, count, 1 << 22);
returnvfs_copy_file_range(src, src_pos, dst, dst_pos, count, 0);
}
Quoted 8 lines
You are now explicitly changing the behaviour of knfsd when the source and destination filesystem differ.
For one thing, you are disallowing the NFSv4.2 copy offload use case of copying from a local filesystem to a remote NFS server. However you are also disallowing the copy from, say, an XFS formatted partition to an ext4 partition.
Got it.
This is easy to solve with a flag COPY_FILE_SPLICE (or something) that is internal to kernel users.
FWIW, you may want to look at the loop in ovl_copy_up_data() for improvements to nfsd_copy_file_range().
We can move the check out to copy_file_range syscall:
if (flags != 0)
return -EINVAL;Leave the fallback from all filesystems and check for the COPY_FILE_SPLICE flag inside generic_copy_file_range().
Thanks,
Amir.
Re: [PATCH v2] vfs: prevent copy_file_range to copy across devices
Quoted 109 lines · Amir Goldstein
Quoted 108 lines · Trond Myklebust
Quoted 74 lines · Amir Goldstein
Quoted 59 lines · Trond Myklebust
Quoted 41 lines · Amir Goldstein
Quoted 20 lines · Luis Henriques
Nicolas Boichat reported an issue when trying to use the
copy_file_range
syscall on a tracefs file. It failed silently because the file content is
generated on-the-fly (reporting a size of zero) andcopy_file_range
needs
to know in advance how much data is present.This commit restores the cross-fs restrictions that existed prior
to5dae222a5ff0("vfs: allowcopy_file_rangeto copy across devices")
and
removesgeneric_copy_file_range()calls from ceph, cifs, fuse, and
nfs.Quoted 6 lines
Fixes 5dae222a5ff0 ("vfs: allow copy_file_range to copy acrossdevices")
Link:
https://lore.kernel.org/linux-fsdevel/[email protected]/Cc Nicolas Boichat <[email protected]>Signed-off-by Luis Henriques <[email protected]>Code looks ok.
You may add:Reviewed-by Amir Goldstein <[email protected]>I agree with Trond that the first paragraph of the commit message could
be improved.
The purpose of this change is to fix the change of behavior that caused the regression.Quoted 9 lines
Before v5.3, behavior was
-EXDEVand userspace could fallback to read.
After v5.3, behavior is zero size copy.It does not matter so much what makes sense for CFR to do in this case (generic cross-fs copy). What matters is that nobody asked for
this change and that it caused problems.No. I'm saying that this patch should be NACKed unless there is a real
explanation for why we give crap about this tracefs corner case and why
it can't be fixed.Quoted 12 lines
There are plenty of reasons why copy offload across filesystems makes
sense, and particularly when you're doing NAS. Clone just doesn't cut
it when it comes to disaster recovery (whereas backup to a different
storage unit does). If the client has to do the copy, then you're effectively doubling the load on the server, and you're adding potentially unnecessary network traffic (or at the very least you are
doubling that traffic).Quoted 9 lines
I don't understand the use case you are describing.
Which filesystem types are you talking about for source and target of
copy_file_range()?To be clear, the original change was done to support NFS/CIFS server- side
copy and those should not be affected by this change.That is incorrect:
ssize_tnfsd_copy_file_range(struct file *src, u64src_pos, struct file *dst,
u64dst_pos, u64 count)
{/*
* Limit copy to 4MB to prevent indefinitely blocking an nfsd
* thread and client rpc slot. The choice of 4MB is somewhat
* arbitrary. We might instead base this on r/wsize, or make it
* tunable, or use a time instead of a byte limit, or implement
* asynchronous copy. In theory a client could also recognize a
* limit like this and pipeline multiple COPY requests. */
count =min_t(u64, count, 1 << 22);
returnvfs_copy_file_range(src, src_pos, dst, dst_pos, count, 0);
}You are now explicitly changing the behaviour of knfsd when the source and destination filesystem differ.
Quoted 7 lines
Quoted 5 lines
For one thing, you are disallowing the NFSv4.2 copy offload use case of copying from a local filesystem to a remote NFS server. However you are also disallowing the copy from, say, an XFS formatted partition to an ext4 partition.
Got it.
Ugh. And I guess overlayfs may have a similar problem.
Quoted 6 lines
This is easy to solve with a flag
COPY_FILE_SPLICE(or something) that is internal to kernel users.FWIW, you may want to look at the loop in
ovl_copy_up_data()for improvements tonfsd_copy_file_range().
Quoted 7 lines
We can move the check out to
copy_file_rangesyscall:if (flags != 0) return -EINVAL;Leave the fallback from all filesystems and check for the
COPY_FILE_SPLICEflag insidegeneric_copy_file_range().
Ok, the diff bellow is just to make sure I understood your suggestion.
The patch will also need to:
- change nfs and overlayfs calls to vfs_copy_file_range() so that they use the new flag.
- check flags in generic_copy_file_checks() to make sure only valid flags are used (COPY_FILE_SPLICE at the moment).
Also, where should this flag be defined? include/uapi/linux/fs.h?
Cheers,
Signature · 1 line
Luis
fs/read_write.c +7 -3
@@ -1383,6 +1383,13 @@ ssize_t generic_copy_file_range(struct file *file_in, loff_t pos_in, struct file *file_out, loff_t pos_out, size_t len, unsigned int flags) { + if (!(flags & COPY_FILE_SPLICE)) { + if (!file_out->f_op->copy_file_range) + return -EOPNOTSUPP; + else if (file_out->f_op->copy_file_range != + file_in->f_op->copy_file_range) + return -EXDEV; + }return do_splice_direct (file_in, &pos_in, file_out, &pos_out, len >MAX_RW_COUNT ?MAX_RW_COUNT : len,0 ); }
@@ -1474,9 +1481,6 @@ ssize_t vfs_copy_file_range(struct file *file_in, loff_t pos_in, {ssize_t ret; -if (flags !=0 ) -return -EINVAL ; - ret =generic_copy_file_checks (file_in, pos_in, file_out, pos_out, &len, flags);if (unlikely (ret))
[email protected]
maintainerRe: [PATCH v2] vfs: prevent copy_file_range to copy across devices
Quoted 139 lines · Luis Henriques
Quoted 109 lines · Amir Goldstein
Quoted 108 lines · Trond Myklebust
Quoted 74 lines · Amir Goldstein
Quoted 59 lines · Trond Myklebust
Quoted 41 lines · Amir Goldstein
Quoted 20 lines · Luis Henriques
Nicolas Boichat reported an issue when trying to use the
copy_file_range
syscall on a tracefs file. It failed silently because the file content is
generated on-the-fly (reporting a size of zero) andcopy_file_range
needs
to know in advance how much data is present.This commit restores the cross-fs restrictions that existed prior
to5dae222a5ff0("vfs: allowcopy_file_rangeto copy across devices")
and
removesgeneric_copy_file_range()calls from ceph, cifs, fuse, and
nfs.Quoted 6 lines
Fixes 5dae222a5ff0 ("vfs: allow copy_file_range to copy acrossdevices")
Link:
https://lore.kernel.org/linux-fsdevel/[email protected]/Cc Nicolas Boichat <[email protected]>Signed-off-by Luis Henriques <[email protected]>Code looks ok.
You may add:Reviewed-by Amir Goldstein <[email protected]>I agree with Trond that the first paragraph of the commit message could
be improved.
The purpose of this change is to fix the change of behavior that caused the regression.Quoted 9 lines
Before v5.3, behavior was
-EXDEVand userspace could fallback to read.
After v5.3, behavior is zero size copy.It does not matter so much what makes sense for CFR to do in this case (generic cross-fs copy). What matters is that nobody asked for
this change and that it caused problems.No. I'm saying that this patch should be NACKed unless there is a real
explanation for why we give crap about this tracefs corner case and why
it can't be fixed.Quoted 12 lines
There are plenty of reasons why copy offload across filesystems makes
sense, and particularly when you're doing NAS. Clone just doesn't cut
it when it comes to disaster recovery (whereas backup to a different
storage unit does). If the client has to do the copy, then you're effectively doubling the load on the server, and you're adding potentially unnecessary network traffic (or at the very least you are
doubling that traffic).Quoted 9 lines
I don't understand the use case you are describing.
Which filesystem types are you talking about for source and target of
copy_file_range()?To be clear, the original change was done to support NFS/CIFS server- side
copy and those should not be affected by this change.That is incorrect:
ssize_tnfsd_copy_file_range(struct file *src, u64src_pos, struct file *dst,
u64dst_pos, u64 count)
{/*
* Limit copy to 4MB to prevent indefinitely blocking an nfsd
* thread and client rpc slot. The choice of 4MB is somewhat
* arbitrary. We might instead base this on r/wsize, or make it
* tunable, or use a time instead of a byte limit, or implement
* asynchronous copy. In theory a client could also recognize a
* limit like this and pipeline multiple COPY requests. */
count =min_t(u64, count, 1 << 22);
returnvfs_copy_file_range(src, src_pos, dst, dst_pos, count, 0);
}You are now explicitly changing the behaviour of knfsd when the source and destination filesystem differ.
Quoted 7 lines
Quoted 5 lines
For one thing, you are disallowing the NFSv4.2 copy offload use case of copying from a local filesystem to a remote NFS server. However you are also disallowing the copy from, say, an XFS formatted partition to an ext4 partition.
Got it.
Ugh. And I guess overlayfs may have a similar problem.
Quoted 6 lines
This is easy to solve with a flag
COPY_FILE_SPLICE(or something) that is internal to kernel users.FWIW, you may want to look at the loop in
ovl_copy_up_data()for improvements tonfsd_copy_file_range().Quoted 7 lines
We can move the check out to
copy_file_rangesyscall:if (flags != 0) return -EINVAL;Leave the fallback from all filesystems and check for the
COPY_FILE_SPLICEflag insidegeneric_copy_file_range().Ok, the diff bellow is just to make sure I understood your suggestion.
The patch will also need to:
Quoted 7 lines
- change nfs and overlayfs calls to
vfs_copy_file_range()so that they use the new flag.- check flags in
generic_copy_file_checks()to make sure only valid flags are used (COPY_FILE_SPLICEat the moment).Also, where should this flag be defined?
include/uapi/linux/fs.h?
Why would userspace want/need this flag?
Re: [PATCH v2] vfs: prevent copy_file_range to copy across devices
Quoted 143 lines · "[email protected]" <[email protected]> writes:
Quoted 142 lines · Luis Henriques
Quoted 109 lines · Amir Goldstein
Quoted 108 lines · Trond Myklebust
Quoted 74 lines · Amir Goldstein
Quoted 59 lines · Trond Myklebust
Quoted 41 lines · Amir Goldstein
Quoted 20 lines · Luis Henriques
Nicolas Boichat reported an issue when trying to use the
copy_file_range
syscall on a tracefs file. It failed silently because the file content is
generated on-the-fly (reporting a size of zero) andcopy_file_range
needs
to know in advance how much data is present.This commit restores the cross-fs restrictions that existed prior
to5dae222a5ff0("vfs: allowcopy_file_rangeto copy across devices")
and
removesgeneric_copy_file_range()calls from ceph, cifs, fuse, and
nfs.Quoted 6 lines
Fixes 5dae222a5ff0 ("vfs: allow copy_file_range to copy acrossdevices")
Link:
https://lore.kernel.org/linux-fsdevel/[email protected]/Cc Nicolas Boichat <[email protected]>Signed-off-by Luis Henriques <[email protected]>Code looks ok.
You may add:Reviewed-by Amir Goldstein <[email protected]>I agree with Trond that the first paragraph of the commit message could
be improved.
The purpose of this change is to fix the change of behavior that caused the regression.Quoted 9 lines
Before v5.3, behavior was
-EXDEVand userspace could fallback to read.
After v5.3, behavior is zero size copy.It does not matter so much what makes sense for CFR to do in this case (generic cross-fs copy). What matters is that nobody asked for
this change and that it caused problems.No. I'm saying that this patch should be NACKed unless there is a real
explanation for why we give crap about this tracefs corner case and why
it can't be fixed.Quoted 12 lines
There are plenty of reasons why copy offload across filesystems makes
sense, and particularly when you're doing NAS. Clone just doesn't cut
it when it comes to disaster recovery (whereas backup to a different
storage unit does). If the client has to do the copy, then you're effectively doubling the load on the server, and you're adding potentially unnecessary network traffic (or at the very least you are
doubling that traffic).Quoted 9 lines
I don't understand the use case you are describing.
Which filesystem types are you talking about for source and target of
copy_file_range()?To be clear, the original change was done to support NFS/CIFS server- side
copy and those should not be affected by this change.That is incorrect:
ssize_tnfsd_copy_file_range(struct file *src, u64src_pos, struct file *dst,
u64dst_pos, u64 count)
{/*
* Limit copy to 4MB to prevent indefinitely blocking an nfsd
* thread and client rpc slot. The choice of 4MB is somewhat
* arbitrary. We might instead base this on r/wsize, or make it
* tunable, or use a time instead of a byte limit, or implement
* asynchronous copy. In theory a client could also recognize a
* limit like this and pipeline multiple COPY requests. */
count =min_t(u64, count, 1 << 22);
returnvfs_copy_file_range(src, src_pos, dst, dst_pos, count, 0);
}You are now explicitly changing the behaviour of knfsd when the source and destination filesystem differ.
Quoted 7 lines
Quoted 5 lines
For one thing, you are disallowing the NFSv4.2 copy offload use case of copying from a local filesystem to a remote NFS server. However you are also disallowing the copy from, say, an XFS formatted partition to an ext4 partition.
Got it.
Ugh. And I guess overlayfs may have a similar problem.
Quoted 6 lines
This is easy to solve with a flag
COPY_FILE_SPLICE(or something) that is internal to kernel users.FWIW, you may want to look at the loop in
ovl_copy_up_data()for improvements tonfsd_copy_file_range().Quoted 7 lines
We can move the check out to
copy_file_rangesyscall:if (flags != 0) return -EINVAL;Leave the fallback from all filesystems and check for the
COPY_FILE_SPLICEflag insidegeneric_copy_file_range().Ok, the diff bellow is just to make sure I understood your suggestion.
The patch will also need to:
- change nfs and overlayfs calls to
vfs_copy_file_range()so that they use the new flag.
Quoted 6 lines
Quoted 4 lines
- check flags in
generic_copy_file_checks()to make sure only valid flags are used (COPY_FILE_SPLICEat the moment).Also, where should this flag be defined?
include/uapi/linux/fs.h?Why would userspace want/need this flag?
In fact, my question sort of implied yours :-)
What I wanted to know was whether we would like to allow userspace to _explicitly_ revert to the current behaviour (i.e. use the flag to allow cross-fs copies) or to continue to return -EINVAL to userspace if flags are != 0 (in which case this check would need to move to the syscall definition).
Cheers,
Signature · 1 line
Luis
Greg KH
maintainerRe: [PATCH v2] vfs: prevent copy_file_range to copy across devices
Quoted 152 lines · Luis Henriques
Quoted 143 lines · "[email protected]" <[email protected]> writes:
Quoted 142 lines · Luis Henriques
Quoted 109 lines · Amir Goldstein
Quoted 108 lines · Trond Myklebust
Quoted 74 lines · Amir Goldstein
Quoted 59 lines · Trond Myklebust
Quoted 41 lines · Amir Goldstein
Quoted 20 lines · Luis Henriques
Nicolas Boichat reported an issue when trying to use the
copy_file_range
syscall on a tracefs file. It failed silently because the file content is
generated on-the-fly (reporting a size of zero) andcopy_file_range
needs
to know in advance how much data is present.This commit restores the cross-fs restrictions that existed prior
to5dae222a5ff0("vfs: allowcopy_file_rangeto copy across devices")
and
removesgeneric_copy_file_range()calls from ceph, cifs, fuse, and
nfs.Quoted 6 lines
Fixes 5dae222a5ff0 ("vfs: allow copy_file_range to copy acrossdevices")
Link:
https://lore.kernel.org/linux-fsdevel/[email protected]/Cc Nicolas Boichat <[email protected]>Signed-off-by Luis Henriques <[email protected]>Code looks ok.
You may add:Reviewed-by Amir Goldstein <[email protected]>I agree with Trond that the first paragraph of the commit message could
be improved.
The purpose of this change is to fix the change of behavior that caused the regression.Quoted 9 lines
Before v5.3, behavior was
-EXDEVand userspace could fallback to read.
After v5.3, behavior is zero size copy.It does not matter so much what makes sense for CFR to do in this case (generic cross-fs copy). What matters is that nobody asked for
this change and that it caused problems.No. I'm saying that this patch should be NACKed unless there is a real
explanation for why we give crap about this tracefs corner case and why
it can't be fixed.Quoted 12 lines
There are plenty of reasons why copy offload across filesystems makes
sense, and particularly when you're doing NAS. Clone just doesn't cut
it when it comes to disaster recovery (whereas backup to a different
storage unit does). If the client has to do the copy, then you're effectively doubling the load on the server, and you're adding potentially unnecessary network traffic (or at the very least you are
doubling that traffic).Quoted 9 lines
I don't understand the use case you are describing.
Which filesystem types are you talking about for source and target of
copy_file_range()?To be clear, the original change was done to support NFS/CIFS server- side
copy and those should not be affected by this change.That is incorrect:
ssize_tnfsd_copy_file_range(struct file *src, u64src_pos, struct file *dst,
u64dst_pos, u64 count)
{/*
* Limit copy to 4MB to prevent indefinitely blocking an nfsd
* thread and client rpc slot. The choice of 4MB is somewhat
* arbitrary. We might instead base this on r/wsize, or make it
* tunable, or use a time instead of a byte limit, or implement
* asynchronous copy. In theory a client could also recognize a
* limit like this and pipeline multiple COPY requests. */
count =min_t(u64, count, 1 << 22);
returnvfs_copy_file_range(src, src_pos, dst, dst_pos, count, 0);
}You are now explicitly changing the behaviour of knfsd when the source and destination filesystem differ.
Quoted 7 lines
Quoted 5 lines
For one thing, you are disallowing the NFSv4.2 copy offload use case of copying from a local filesystem to a remote NFS server. However you are also disallowing the copy from, say, an XFS formatted partition to an ext4 partition.
Got it.
Ugh. And I guess overlayfs may have a similar problem.
Quoted 6 lines
This is easy to solve with a flag
COPY_FILE_SPLICE(or something) that is internal to kernel users.FWIW, you may want to look at the loop in
ovl_copy_up_data()for improvements tonfsd_copy_file_range().Quoted 7 lines
We can move the check out to
copy_file_rangesyscall:if (flags != 0) return -EINVAL;Leave the fallback from all filesystems and check for the
COPY_FILE_SPLICEflag insidegeneric_copy_file_range().Ok, the diff bellow is just to make sure I understood your suggestion.
The patch will also need to:
- change nfs and overlayfs calls to
vfs_copy_file_range()so that they use the new flag.Quoted 6 lines
Quoted 4 lines
- check flags in
generic_copy_file_checks()to make sure only valid flags are used (COPY_FILE_SPLICEat the moment).Also, where should this flag be defined?
include/uapi/linux/fs.h?Why would userspace want/need this flag?
Quoted 7 lines
In fact, my question sort of implied yours :-)
What I wanted to know was whether we would like to allow userspace to _explicitly_ revert to the current behaviour (i.e. use the flag to allow cross-fs copies) or to continue to return
-EINVALto userspace if flags are != 0 (in which case this check would need to move to the syscall definition).
No, don't try to mess with userspace that way, the kernel should "just work". Well, in this case "work as best as it can, not always successful...", it's an odd syscall.
thanks,
greg k-h
Re: [PATCH v2] vfs: prevent copy_file_range to copy across devices
In reply to Luis HenriquesQuoted 1 line
Ugh. And I guess overlayfs may have a similar problem.
Not exactly.
Generally speaking, overlayfs should call vfs_copy_file_range() with the flags it got from layer above, so if called from nfsd it will allow cross fs copy and when called from syscall it won't.
There are some corner cases where overlayfs could benefit from COPY_FILE_SPLICE (e.g. copy from lower file to upper file), but let's leave those for now. Just leave overlayfs code as is.
Quoted 19 lines
Quoted 7 lines
This is easy to solve with a flag
COPY_FILE_SPLICE(or something) that is internal to kernel users.FWIW, you may want to look at the loop in
ovl_copy_up_data()for improvements tonfsd_copy_file_range().Quoted 7 lines
We can move the check out to
copy_file_rangesyscall:if (flags != 0) return -EINVAL;Leave the fallback from all filesystems and check for the
COPY_FILE_SPLICEflag insidegeneric_copy_file_range().Ok, the diff bellow is just to make sure I understood your suggestion.
The patch will also need to:
Quoted 7 lines
- change nfs and overlayfs calls to
vfs_copy_file_range()so that they use the new flag.- check flags in
generic_copy_file_checks()to make sure only valid flags are used (COPY_FILE_SPLICEat the moment).Also, where should this flag be defined?
include/uapi/linux/fs.h?
Grep for REMAP_FILE_
Same header file, same Documentation rst file.
Quoted 10 lines
Cheers,
--
Luisfs/read_write.c +0
-0
fs/read_write.c ssize_t generic_copy_file_range(struct file *file_in, loff_t pos_in, · line 1392
Quoted 10 lines
fs/read_write.c +7
-0@@ -1383,6 +1383,13 @@ ssize_t generic_copy_file_range(struct file *file_in, loff_t pos_in, struct file *file_out, loff_t pos_out, size_t len, unsigned int flags) { + if (!(flags & COPY_FILE_SPLICE)) { + if (!file_out->f_op->copy_file_range) + return -EOPNOTSUPP; + else if (file_out->f_op->copy_file_range != + file_in->f_op->copy_file_range) + return -EXDEV; + }
That looks strange, because you are duplicating the logic in do_copy_file_range(). Maybe better:
if (WARN_ON_ONCE(flags & ~COPY_FILE_SPLICE))
return -EINVAL;
if (flags & COPY_FILE_SPLICE)
return do_splice_direct(file_in, &pos_in, file_out, &pos_out,
len > MAX_RW_COUNT ? MAX_RW_COUNT : len, 0);
if (!file_out->f_op->copy_file_range)
return -EOPNOTSUPP;
return -EXDEV;
fs/read_write.c ssize_t vfs_copy_file_range(struct file *file_in, loff_t pos_in, · line 1479
Quoted 8 lines
fs/read_write.c +0
-3}@@ -1474,9 +1481,6 @@ ssize_t vfs_copy_file_range(struct file *file_in, loff_t pos_in, {ssize_t ret; -if (flags !=0 ) -return -EINVAL ; -
This needs to move to the beginning of SYSCALL_DEFINE6(copy_file_range,...
Thanks,
Amir.
Re: [PATCH v2] vfs: prevent copy_file_range to copy across devices
Quoted 10 lines · Amir Goldstein
Quoted 1 line
Ugh. And I guess overlayfs may have a similar problem.
Not exactly.
Generally speaking, overlayfs should callvfs_copy_file_range()with the flags it got from layer above, so if called from nfsd it will allow cross fs copy and when called from syscall it won't.There are some corner cases where overlayfs could benefit from
COPY_FILE_SPLICE(e.g. copy from lower file to upper file), but let's leave those for now. Just leave overlayfs code as is.
Got it, thanks for clarifying.
Quoted 53 lines
Quoted 18 lines
Quoted 6 lines
This is easy to solve with a flag
COPY_FILE_SPLICE(or something) that is internal to kernel users.FWIW, you may want to look at the loop in
ovl_copy_up_data()for improvements tonfsd_copy_file_range().Quoted 7 lines
We can move the check out to
copy_file_rangesyscall:if (flags != 0) return -EINVAL;Leave the fallback from all filesystems and check for the
COPY_FILE_SPLICEflag insidegeneric_copy_file_range().Ok, the diff bellow is just to make sure I understood your suggestion.
The patch will also need to:
Quoted 7 lines
- change nfs and overlayfs calls to
vfs_copy_file_range()so that they use the new flag.- check flags in
generic_copy_file_checks()to make sure only valid flags are used (COPY_FILE_SPLICEat the moment).Also, where should this flag be defined?
include/uapi/linux/fs.h?Grep for
REMAP_FILE_
Same header file, same Documentation rst file.Quoted 10 lines
Cheers,
--
Luisfs/read_write.c +0
-0fs/read_write.c ssize_t generic_copy_file_range(struct file *file_in, loff_t pos_in, · line 1392
Quoted 10 lines
fs/read_write.c +7
-0@@ -1383,6 +1383,13 @@ ssize_t generic_copy_file_range(struct file *file_in, loff_t pos_in, struct file *file_out, loff_t pos_out, size_t len, unsigned int flags) { + if (!(flags & COPY_FILE_SPLICE)) { + if (!file_out->f_op->copy_file_range) + return -EOPNOTSUPP; + else if (file_out->f_op->copy_file_range != + file_in->f_op->copy_file_range) + return -EXDEV; + }That looks strange, because you are duplicating the logic in
do_copy_file_range(). Maybe better:
Quoted 5 lines
if (
WARN_ON_ONCE(flags & ~COPY_FILE_SPLICE))return -EINVAL;if (flags &
COPY_FILE_SPLICE)
return do_splice_direct(file_in,&pos_in,file_out,&pos_out,
len >MAX_RW_COUNT?MAX_RW_COUNT: len, 0);
My initial reasoning for duplicating the logic in do_copy_file_range() was to allow the generic_copy_file_range() callers to be left unmodified and allow the filesystems to default to this implementation.
With this change, I guess that the calls to generic_copy_file_range() from the different filesystems can be dropped, as in my initial patch, as they will always get -EINVAL. The other option would be to set the COPY_FILE_SPLICE flag in those calls, but that would get us back to the problem we're trying to solve.
Quoted 9 lines
if (!file_out->f_op->copy_file_range)
return -EOPNOTSUPP;return
-EXDEV;Quoted 5 lines
fs/read_write.c +0
-0}@@ -1474,9 +1481,6 @@ ssize_t vfs_copy_file_range(struct file *file_in, loff_t pos_in, {ssize_t ret;
Quoted 5 lines
fs/read_write.c ssize_t vfs_copy_file_range(struct file *file_in, loff_t pos_in, · line 1479
Quoted 3 lines
fs/read_write.c +0
-3-if (flags !=0 ) -return -EINVAL ; -This needs to move to the beginning of SYSCALL_DEFINE6(copy_file_range,...
Yep, I didn't included that change in my diff as I wasn't sure if you'd like to have the flag visible in userspace.
Anyway, thanks for your patience!
Cheers,
Signature · 1 line
Luis
Re: [PATCH v2] vfs: prevent copy_file_range to copy across devices
Quoted 79 lines · Luis Henriques
Quoted 10 lines · Amir Goldstein
Quoted 1 line
Ugh. And I guess overlayfs may have a similar problem.
Not exactly.
Generally speaking, overlayfs should callvfs_copy_file_range()with the flags it got from layer above, so if called from nfsd it will allow cross fs copy and when called from syscall it won't.There are some corner cases where overlayfs could benefit from
COPY_FILE_SPLICE(e.g. copy from lower file to upper file), but let's leave those for now. Just leave overlayfs code as is.Got it, thanks for clarifying.
Quoted 53 lines
Quoted 18 lines
Quoted 6 lines
This is easy to solve with a flag
COPY_FILE_SPLICE(or something) that is internal to kernel users.FWIW, you may want to look at the loop in
ovl_copy_up_data()for improvements tonfsd_copy_file_range().Quoted 7 lines
We can move the check out to
copy_file_rangesyscall:if (flags != 0) return -EINVAL;Leave the fallback from all filesystems and check for the
COPY_FILE_SPLICEflag insidegeneric_copy_file_range().Ok, the diff bellow is just to make sure I understood your suggestion.
The patch will also need to:
Quoted 7 lines
- change nfs and overlayfs calls to
vfs_copy_file_range()so that they use the new flag.- check flags in
generic_copy_file_checks()to make sure only valid flags are used (COPY_FILE_SPLICEat the moment).Also, where should this flag be defined?
include/uapi/linux/fs.h?Grep for
REMAP_FILE_
Same header file, same Documentation rst file.Quoted 10 lines
Cheers,
--
Luisfs/read_write.c +0
-0fs/read_write.c ssize_t generic_copy_file_range(struct file *file_in, loff_t pos_in, · line 1392
Quoted 10 lines
fs/read_write.c +7
-0@@ -1383,6 +1383,13 @@ ssize_t generic_copy_file_range(struct file *file_in, loff_t pos_in, struct file *file_out, loff_t pos_out, size_t len, unsigned int flags) { + if (!(flags & COPY_FILE_SPLICE)) { + if (!file_out->f_op->copy_file_range) + return -EOPNOTSUPP; + else if (file_out->f_op->copy_file_range != + file_in->f_op->copy_file_range) + return -EXDEV; + }That looks strange, because you are duplicating the logic in
do_copy_file_range(). Maybe better:Quoted 5 lines
if (
WARN_ON_ONCE(flags & ~COPY_FILE_SPLICE))return -EINVAL;if (flags &
COPY_FILE_SPLICE)
return do_splice_direct(file_in,&pos_in,file_out,&pos_out,
len >MAX_RW_COUNT?MAX_RW_COUNT: len, 0);My initial reasoning for duplicating the logic in
do_copy_file_range()was to allow thegeneric_copy_file_range()callers to be left unmodified and allow the filesystems to default to this implementation.
Quoted 5 lines
With this change, I guess that the calls to
generic_copy_file_range()from the different filesystems can be dropped, as in my initial patch, as they will always get-EINVAL. The other option would be to set theCOPY_FILE_SPLICEflag in those calls, but that would get us back to the problem we're trying to solve.
I don't understand the problem.
What exactly is wrong with the code I suggested?
Why should any filesystem be changed?
Maybe I am missing something.
Thanks,
Amir.
Re: [PATCH v2] vfs: prevent copy_file_range to copy across devices
Quoted 86 lines · Amir Goldstein
Quoted 79 lines · Luis Henriques
Quoted 10 lines · Amir Goldstein
Quoted 1 line
Ugh. And I guess overlayfs may have a similar problem.
Not exactly.
Generally speaking, overlayfs should callvfs_copy_file_range()with the flags it got from layer above, so if called from nfsd it will allow cross fs copy and when called from syscall it won't.There are some corner cases where overlayfs could benefit from
COPY_FILE_SPLICE(e.g. copy from lower file to upper file), but let's leave those for now. Just leave overlayfs code as is.Got it, thanks for clarifying.
Quoted 53 lines
Quoted 18 lines
Quoted 6 lines
This is easy to solve with a flag
COPY_FILE_SPLICE(or something) that is internal to kernel users.FWIW, you may want to look at the loop in
ovl_copy_up_data()for improvements tonfsd_copy_file_range().Quoted 7 lines
We can move the check out to
copy_file_rangesyscall:if (flags != 0) return -EINVAL;Leave the fallback from all filesystems and check for the
COPY_FILE_SPLICEflag insidegeneric_copy_file_range().Ok, the diff bellow is just to make sure I understood your suggestion.
The patch will also need to:
Quoted 7 lines
- change nfs and overlayfs calls to
vfs_copy_file_range()so that they use the new flag.- check flags in
generic_copy_file_checks()to make sure only valid flags are used (COPY_FILE_SPLICEat the moment).Also, where should this flag be defined?
include/uapi/linux/fs.h?Grep for
REMAP_FILE_
Same header file, same Documentation rst file.Quoted 10 lines
Cheers,
--
Luisfs/read_write.c +0
-0fs/read_write.c ssize_t generic_copy_file_range(struct file *file_in, loff_t pos_in, · line 1392
Quoted 10 lines
fs/read_write.c +7
-0@@ -1383,6 +1383,13 @@ ssize_t generic_copy_file_range(struct file *file_in, loff_t pos_in, struct file *file_out, loff_t pos_out, size_t len, unsigned int flags) { + if (!(flags & COPY_FILE_SPLICE)) { + if (!file_out->f_op->copy_file_range) + return -EOPNOTSUPP; + else if (file_out->f_op->copy_file_range != + file_in->f_op->copy_file_range) + return -EXDEV; + }That looks strange, because you are duplicating the logic in
do_copy_file_range(). Maybe better:Quoted 5 lines
if (
WARN_ON_ONCE(flags & ~COPY_FILE_SPLICE))return -EINVAL;if (flags &
COPY_FILE_SPLICE)
return do_splice_direct(file_in,&pos_in,file_out,&pos_out,
len >MAX_RW_COUNT?MAX_RW_COUNT: len, 0);My initial reasoning for duplicating the logic in
do_copy_file_range()was to allow thegeneric_copy_file_range()callers to be left unmodified and allow the filesystems to default to this implementation.Quoted 5 lines
With this change, I guess that the calls to
generic_copy_file_range()from the different filesystems can be dropped, as in my initial patch, as they will always get-EINVAL. The other option would be to set theCOPY_FILE_SPLICEflag in those calls, but that would get us back to the problem we're trying to solve.
Quoted 6 lines
I don't understand the problem.
What exactly is wrong with the code I suggested?
Why should any filesystem be changed?Maybe I am missing something.
Ok, I have to do a full brain reboot and start all over.
Before that, I picked the code you suggested and tested it. I've mounted a cephfs filesystem and used xfs_io to execute a 'copy_range' command using /sys/kernel/debug/sched_features as source. The result was a 0-sized file in cephfs. And the reason is thevfs_copy_file_range() early exit in:
if (len == 0) return 0;
'len' is set in generic_copy_file_checks().
This means that we're not solving the original problem anymore (probably since v1 of this patch, haven't checked).
Also, re-reading Trond's emails, I read: "... also disallowing the copy from, say, an XFS formatted partition to an ext4 partition". Isn't that *exactly* what we're trying to do here? I.e. _prevent_ these copies from happening so that tracefs files can't be CFR'ed?
/me stops now and waits to see if the morning brings some sun :-)
Cheers,
Signature · 1 line
Luis
Re: [PATCH v2] vfs: prevent copy_file_range to copy across devices
Quoted 104 lines · Luis Henriques
Quoted 86 lines · Amir Goldstein
Quoted 79 lines · Luis Henriques
Quoted 10 lines · Amir Goldstein
Quoted 1 line
Ugh. And I guess overlayfs may have a similar problem.
Not exactly.
Generally speaking, overlayfs should callvfs_copy_file_range()with the flags it got from layer above, so if called from nfsd it will allow cross fs copy and when called from syscall it won't.There are some corner cases where overlayfs could benefit from
COPY_FILE_SPLICE(e.g. copy from lower file to upper file), but let's leave those for now. Just leave overlayfs code as is.Got it, thanks for clarifying.
Quoted 53 lines
Quoted 18 lines
Quoted 6 lines
This is easy to solve with a flag
COPY_FILE_SPLICE(or something) that is internal to kernel users.FWIW, you may want to look at the loop in
ovl_copy_up_data()for improvements tonfsd_copy_file_range().Quoted 7 lines
We can move the check out to
copy_file_rangesyscall:if (flags != 0) return -EINVAL;Leave the fallback from all filesystems and check for the
COPY_FILE_SPLICEflag insidegeneric_copy_file_range().Ok, the diff bellow is just to make sure I understood your suggestion.
The patch will also need to:
Quoted 7 lines
- change nfs and overlayfs calls to
vfs_copy_file_range()so that they use the new flag.- check flags in
generic_copy_file_checks()to make sure only valid flags are used (COPY_FILE_SPLICEat the moment).Also, where should this flag be defined?
include/uapi/linux/fs.h?Grep for
REMAP_FILE_
Same header file, same Documentation rst file.Quoted 10 lines
Cheers,
--
Luisfs/read_write.c +0
-0fs/read_write.c ssize_t generic_copy_file_range(struct file *file_in, loff_t pos_in, · line 1392
Quoted 10 lines
fs/read_write.c +7
-0@@ -1383,6 +1383,13 @@ ssize_t generic_copy_file_range(struct file *file_in, loff_t pos_in, struct file *file_out, loff_t pos_out, size_t len, unsigned int flags) { + if (!(flags & COPY_FILE_SPLICE)) { + if (!file_out->f_op->copy_file_range) + return -EOPNOTSUPP; + else if (file_out->f_op->copy_file_range != + file_in->f_op->copy_file_range) + return -EXDEV; + }That looks strange, because you are duplicating the logic in
do_copy_file_range(). Maybe better:Quoted 5 lines
if (
WARN_ON_ONCE(flags & ~COPY_FILE_SPLICE))return -EINVAL;if (flags &
COPY_FILE_SPLICE)
return do_splice_direct(file_in,&pos_in,file_out,&pos_out,
len >MAX_RW_COUNT?MAX_RW_COUNT: len, 0);My initial reasoning for duplicating the logic in
do_copy_file_range()was to allow thegeneric_copy_file_range()callers to be left unmodified and allow the filesystems to default to this implementation.Quoted 5 lines
With this change, I guess that the calls to
generic_copy_file_range()from the different filesystems can be dropped, as in my initial patch, as they will always get-EINVAL. The other option would be to set theCOPY_FILE_SPLICEflag in those calls, but that would get us back to the problem we're trying to solve.Quoted 6 lines
I don't understand the problem.
What exactly is wrong with the code I suggested?
Why should any filesystem be changed?Maybe I am missing something.
Ok, I have to do a full brain reboot and start all over.
Before that, I picked the code you suggested and tested it. I've mounted a cephfs filesystem and used
xfs_ioto execute a 'copy_range' command using/sys/kernel/debug/sched_featuresas source. The result was a 0-sized file in cephfs. And the reason isthevfs_copy_file_range()early exit in:
Quoted 4 lines
if (len == 0) return 0;'len' is set in
generic_copy_file_checks().
Good point.. I guess we will need to do all the checks earlier in generic_copy_file_checks() including the logic of:
if (file_in->f_op->remap_file_range &&
file_inode(file_in)->i_sb == file_inode(file_out)->i_sb)Quoted 9 lines
This means that we're not solving the original problem anymore (probably since v1 of this patch, haven't checked).
Also, re-reading Trond's emails, I read: "... also disallowing the copy from, say, an XFS formatted partition to an ext4 partition". Isn't that *exactly* what we're trying to do here? I.e. _prevent_ these copies from happening so that tracefs files can't be CFR'ed?
We want to address the report which means calls coming from copy_file_range() syscall.
Trond's use case is vfs_copy_file_range() coming from nfsd. When he writes about copy from XFS to ext4, he means an
NFS client is issuing server side copy (on same or different NFS mounts) and the NFS server is executing nfsd_copy_file_range() on a source file that happens to be on XFS and destination happens to be on ext4.
We can undo the copy_file_range() syscall change of behavior from v5.3 without regressing the NFS use case.
We just need to be careful and look at all the affected code paths.
Thanks,
Amir.
Re: [PATCH v2] vfs: prevent copy_file_range to copy across devices
Quoted 128 lines · Amir Goldstein
Quoted 104 lines · Luis Henriques
Quoted 86 lines · Amir Goldstein
Quoted 79 lines · Luis Henriques
Quoted 10 lines · Amir Goldstein
Quoted 1 line
Ugh. And I guess overlayfs may have a similar problem.
Not exactly.
Generally speaking, overlayfs should callvfs_copy_file_range()with the flags it got from layer above, so if called from nfsd it will allow cross fs copy and when called from syscall it won't.There are some corner cases where overlayfs could benefit from
COPY_FILE_SPLICE(e.g. copy from lower file to upper file), but let's leave those for now. Just leave overlayfs code as is.Got it, thanks for clarifying.
Quoted 53 lines
Quoted 18 lines
Quoted 6 lines
This is easy to solve with a flag
COPY_FILE_SPLICE(or something) that is internal to kernel users.FWIW, you may want to look at the loop in
ovl_copy_up_data()for improvements tonfsd_copy_file_range().Quoted 7 lines
We can move the check out to
copy_file_rangesyscall:if (flags != 0) return -EINVAL;Leave the fallback from all filesystems and check for the
COPY_FILE_SPLICEflag insidegeneric_copy_file_range().Ok, the diff bellow is just to make sure I understood your suggestion.
The patch will also need to:
Quoted 7 lines
- change nfs and overlayfs calls to
vfs_copy_file_range()so that they use the new flag.- check flags in
generic_copy_file_checks()to make sure only valid flags are used (COPY_FILE_SPLICEat the moment).Also, where should this flag be defined?
include/uapi/linux/fs.h?Grep for
REMAP_FILE_
Same header file, same Documentation rst file.Quoted 10 lines
Cheers,
--
Luisfs/read_write.c +0
-0fs/read_write.c ssize_t generic_copy_file_range(struct file *file_in, loff_t pos_in, · line 1392
Quoted 10 lines
fs/read_write.c +7
-0@@ -1383,6 +1383,13 @@ ssize_t generic_copy_file_range(struct file *file_in, loff_t pos_in, struct file *file_out, loff_t pos_out, size_t len, unsigned int flags) { + if (!(flags & COPY_FILE_SPLICE)) { + if (!file_out->f_op->copy_file_range) + return -EOPNOTSUPP; + else if (file_out->f_op->copy_file_range != + file_in->f_op->copy_file_range) + return -EXDEV; + }That looks strange, because you are duplicating the logic in
do_copy_file_range(). Maybe better:Quoted 5 lines
if (
WARN_ON_ONCE(flags & ~COPY_FILE_SPLICE))return -EINVAL;if (flags &
COPY_FILE_SPLICE)
return do_splice_direct(file_in,&pos_in,file_out,&pos_out,
len >MAX_RW_COUNT?MAX_RW_COUNT: len, 0);My initial reasoning for duplicating the logic in
do_copy_file_range()was to allow thegeneric_copy_file_range()callers to be left unmodified and allow the filesystems to default to this implementation.Quoted 5 lines
With this change, I guess that the calls to
generic_copy_file_range()from the different filesystems can be dropped, as in my initial patch, as they will always get-EINVAL. The other option would be to set theCOPY_FILE_SPLICEflag in those calls, but that would get us back to the problem we're trying to solve.Quoted 6 lines
I don't understand the problem.
What exactly is wrong with the code I suggested?
Why should any filesystem be changed?Maybe I am missing something.
Ok, I have to do a full brain reboot and start all over.
Before that, I picked the code you suggested and tested it. I've mounted a cephfs filesystem and used
xfs_ioto execute a 'copy_range' command using/sys/kernel/debug/sched_featuresas source. The result was a 0-sized file in cephfs. And the reason isthevfs_copy_file_range()early exit in:Quoted 4 lines
if (len == 0) return 0;'len' is set in
generic_copy_file_checks().Good point.. I guess we will need to do all the checks earlier in
generic_copy_file_checks()including the logic of:if (file_in->f_op->remap_file_range && file_inode(file_in)->i_sb == file_inode(file_out)->i_sb)Quoted 9 lines
This means that we're not solving the original problem anymore (probably since v1 of this patch, haven't checked).
Also, re-reading Trond's emails, I read: "... also disallowing the copy from, say, an XFS formatted partition to an ext4 partition". Isn't that *exactly* what we're trying to do here? I.e. _prevent_ these copies from happening so that tracefs files can't be CFR'ed?
Quoted 8 lines
We want to address the report which means calls coming from
copy_file_range()syscall.Trond's use case is
vfs_copy_file_range()coming from nfsd. When he writes about copy from XFS to ext4, he means an
NFS client is issuing server side copy (on same or different NFS mounts) and the NFS server is executingnfsd_copy_file_range()on a source file that happens to be on XFS and destination happens to be on ext4.
NFS also supports a server-to-server copy where the destination server mounts the source server and reads the data to be copied. Please don't break that either :)
Anna
Quoted 8 lines
We can undo the
copy_file_range()syscall change of behavior from v5.3 without regressing the NFS use case.We just need to be careful and look at all the affected code paths.
Thanks,
Amir.
Re: [PATCH v2] vfs: prevent copy_file_range to copy across devices
Quoted 139 lines · Anna Schumaker
Quoted 128 lines · Amir Goldstein
Quoted 104 lines · Luis Henriques
Quoted 86 lines · Amir Goldstein
Quoted 79 lines · Luis Henriques
Quoted 10 lines · Amir Goldstein
Quoted 1 line
Ugh. And I guess overlayfs may have a similar problem.
Not exactly.
Generally speaking, overlayfs should callvfs_copy_file_range()with the flags it got from layer above, so if called from nfsd it will allow cross fs copy and when called from syscall it won't.There are some corner cases where overlayfs could benefit from
COPY_FILE_SPLICE(e.g. copy from lower file to upper file), but let's leave those for now. Just leave overlayfs code as is.Got it, thanks for clarifying.
Quoted 53 lines
Quoted 18 lines
Quoted 6 lines
This is easy to solve with a flag
COPY_FILE_SPLICE(or something) that is internal to kernel users.FWIW, you may want to look at the loop in
ovl_copy_up_data()for improvements tonfsd_copy_file_range().Quoted 7 lines
We can move the check out to
copy_file_rangesyscall:if (flags != 0) return -EINVAL;Leave the fallback from all filesystems and check for the
COPY_FILE_SPLICEflag insidegeneric_copy_file_range().Ok, the diff bellow is just to make sure I understood your suggestion.
The patch will also need to:
Quoted 7 lines
- change nfs and overlayfs calls to
vfs_copy_file_range()so that they use the new flag.- check flags in
generic_copy_file_checks()to make sure only valid flags are used (COPY_FILE_SPLICEat the moment).Also, where should this flag be defined?
include/uapi/linux/fs.h?Grep for
REMAP_FILE_
Same header file, same Documentation rst file.Quoted 10 lines
Cheers,
--
Luisfs/read_write.c +0
-0fs/read_write.c ssize_t generic_copy_file_range(struct file *file_in, loff_t pos_in, · line 1392
Quoted 10 lines
fs/read_write.c +7
-0@@ -1383,6 +1383,13 @@ ssize_t generic_copy_file_range(struct file *file_in, loff_t pos_in, struct file *file_out, loff_t pos_out, size_t len, unsigned int flags) { + if (!(flags & COPY_FILE_SPLICE)) { + if (!file_out->f_op->copy_file_range) + return -EOPNOTSUPP; + else if (file_out->f_op->copy_file_range != + file_in->f_op->copy_file_range) + return -EXDEV; + }That looks strange, because you are duplicating the logic in
do_copy_file_range(). Maybe better:Quoted 5 lines
if (
WARN_ON_ONCE(flags & ~COPY_FILE_SPLICE))return -EINVAL;if (flags &
COPY_FILE_SPLICE)
return do_splice_direct(file_in,&pos_in,file_out,&pos_out,
len >MAX_RW_COUNT?MAX_RW_COUNT: len, 0);My initial reasoning for duplicating the logic in
do_copy_file_range()was to allow thegeneric_copy_file_range()callers to be left unmodified and allow the filesystems to default to this implementation.Quoted 5 lines
With this change, I guess that the calls to
generic_copy_file_range()from the different filesystems can be dropped, as in my initial patch, as they will always get-EINVAL. The other option would be to set theCOPY_FILE_SPLICEflag in those calls, but that would get us back to the problem we're trying to solve.Quoted 6 lines
I don't understand the problem.
What exactly is wrong with the code I suggested?
Why should any filesystem be changed?Maybe I am missing something.
Ok, I have to do a full brain reboot and start all over.
Before that, I picked the code you suggested and tested it. I've mounted a cephfs filesystem and used
xfs_ioto execute a 'copy_range' command using/sys/kernel/debug/sched_featuresas source. The result was a 0-sized file in cephfs. And the reason isthevfs_copy_file_range()early exit in:Quoted 4 lines
if (len == 0) return 0;'len' is set in
generic_copy_file_checks().Good point.. I guess we will need to do all the checks earlier in
generic_copy_file_checks()including the logic of:if (file_in->f_op->remap_file_range && file_inode(file_in)->i_sb == file_inode(file_out)->i_sb)Quoted 9 lines
This means that we're not solving the original problem anymore (probably since v1 of this patch, haven't checked).
Also, re-reading Trond's emails, I read: "... also disallowing the copy from, say, an XFS formatted partition to an ext4 partition". Isn't that *exactly* what we're trying to do here? I.e. _prevent_ these copies from happening so that tracefs files can't be CFR'ed?
Quoted 8 lines
We want to address the report which means calls coming from
copy_file_range()syscall.Trond's use case is
vfs_copy_file_range()coming from nfsd. When he writes about copy from XFS to ext4, he means an
NFS client is issuing server side copy (on same or different NFS mounts) and the NFS server is executingnfsd_copy_file_range()on a source file that happens to be on XFS and destination happens to be on ext4.
Quoted 3 lines
NFS also supports a server-to-server copy where the destination server mounts the source server and reads the data to be copied. Please don't break that either :)
This is a case we will eventually need to support for cifs (SMB3) as well.
Signature · 3 lines
Thanks, Steve
Re: [PATCH v2] vfs: prevent copy_file_range to copy across devices
Quoted 142 lines · Steve French
Quoted 139 lines · Anna Schumaker
Quoted 136 lines · Amir Goldstein
Quoted 104 lines · Luis Henriques
Quoted 86 lines · Amir Goldstein
Quoted 79 lines · Luis Henriques
Quoted 10 lines · Amir Goldstein
Quoted 1 line
Ugh. And I guess overlayfs may have a similar problem.
Not exactly.
Generally speaking, overlayfs should callvfs_copy_file_range()with the flags it got from layer above, so if called from nfsd it will allow cross fs copy and when called from syscall it won't.There are some corner cases where overlayfs could benefit from
COPY_FILE_SPLICE(e.g. copy from lower file to upper file), but let's leave those for now. Just leave overlayfs code as is.Got it, thanks for clarifying.
Quoted 53 lines
Quoted 18 lines
Quoted 6 lines
This is easy to solve with a flag
COPY_FILE_SPLICE(or something) that is internal to kernel users.FWIW, you may want to look at the loop in
ovl_copy_up_data()for improvements tonfsd_copy_file_range().Quoted 7 lines
We can move the check out to
copy_file_rangesyscall:if (flags != 0) return -EINVAL;Leave the fallback from all filesystems and check for the
COPY_FILE_SPLICEflag insidegeneric_copy_file_range().Ok, the diff bellow is just to make sure I understood your suggestion.
The patch will also need to:
Quoted 7 lines
- change nfs and overlayfs calls to
vfs_copy_file_range()so that they use the new flag.- check flags in
generic_copy_file_checks()to make sure only valid flags are used (COPY_FILE_SPLICEat the moment).Also, where should this flag be defined?
include/uapi/linux/fs.h?Grep for
REMAP_FILE_
Same header file, same Documentation rst file.Quoted 10 lines
Cheers,
--
Luisfs/read_write.c +0
-0fs/read_write.c ssize_t generic_copy_file_range(struct file *file_in, loff_t pos_in, · line 1392
Quoted 10 lines
fs/read_write.c +7
-0@@ -1383,6 +1383,13 @@ ssize_t generic_copy_file_range(struct file *file_in, loff_t pos_in, struct file *file_out, loff_t pos_out, size_t len, unsigned int flags) { + if (!(flags & COPY_FILE_SPLICE)) { + if (!file_out->f_op->copy_file_range) + return -EOPNOTSUPP; + else if (file_out->f_op->copy_file_range != + file_in->f_op->copy_file_range) + return -EXDEV; + }That looks strange, because you are duplicating the logic in
do_copy_file_range(). Maybe better:Quoted 5 lines
if (
WARN_ON_ONCE(flags & ~COPY_FILE_SPLICE))return -EINVAL;if (flags &
COPY_FILE_SPLICE)
return do_splice_direct(file_in,&pos_in,file_out,&pos_out,
len >MAX_RW_COUNT?MAX_RW_COUNT: len, 0);My initial reasoning for duplicating the logic in
do_copy_file_range()was to allow thegeneric_copy_file_range()callers to be left unmodified and allow the filesystems to default to this implementation.Quoted 5 lines
With this change, I guess that the calls to
generic_copy_file_range()from the different filesystems can be dropped, as in my initial patch, as they will always get-EINVAL. The other option would be to set theCOPY_FILE_SPLICEflag in those calls, but that would get us back to the problem we're trying to solve.Quoted 6 lines
I don't understand the problem.
What exactly is wrong with the code I suggested?
Why should any filesystem be changed?Maybe I am missing something.
Ok, I have to do a full brain reboot and start all over.
Before that, I picked the code you suggested and tested it. I've mounted a cephfs filesystem and used
xfs_ioto execute a 'copy_range' command using/sys/kernel/debug/sched_featuresas source. The result was a 0-sized file in cephfs. And the reason isthevfs_copy_file_range()early exit in:Quoted 4 lines
if (len == 0) return 0;'len' is set in
generic_copy_file_checks().Good point.. I guess we will need to do all the checks earlier in
generic_copy_file_checks()including the logic of:if (file_in->f_op->remap_file_range && file_inode(file_in)->i_sb == file_inode(file_out)->i_sb)Quoted 9 lines
This means that we're not solving the original problem anymore (probably since v1 of this patch, haven't checked).
Also, re-reading Trond's emails, I read: "... also disallowing the copy from, say, an XFS formatted partition to an ext4 partition". Isn't that *exactly* what we're trying to do here? I.e. _prevent_ these copies from happening so that tracefs files can't be CFR'ed?
We want to address the report which means calls coming from
copy_file_range()syscall.Trond's use case is
vfs_copy_file_range()coming from nfsd. When he writes about copy from XFS to ext4, he means an
NFS client is issuing server side copy (on same or different NFS mounts) and the NFS server is executingnfsd_copy_file_range()on a source file that happens to be on XFS and destination happens to be on ext4.
Quoted 4 lines
Quoted 3 lines
NFS also supports a server-to-server copy where the destination server mounts the source server and reads the data to be copied. Please don't break that either :)
As long as the copy is via nfsd_copy_file_range() and not from the syscall it should not regress.
Quoted 2 lines
This is a case we will eventually need to support for cifs (SMB3) as well.
samba already does server side copy very well without needing any support from the kernel.
nfsd also doesn't *need* to use vfs_copy_file_range() it can use kernel APIs like the loop in ovl_copy_up_data(). But it does, so we should not regress it.
samba/nfsd can try to use copy_file_range() and it will work if the source/target
fs support it. Otherwise, the server can perfectly well do the copy via other available interfaces, just like userspace copy tools.
Thanks,
Amir.
Re: [PATCH v2] vfs: prevent copy_file_range to copy across devices
Quoted 158 lines · Amir Goldstein
Quoted 142 lines · Steve French
Quoted 139 lines · Anna Schumaker
Quoted 136 lines · Amir Goldstein
Quoted 104 lines · Luis Henriques
Quoted 86 lines · Amir Goldstein
Quoted 79 lines · Luis Henriques
Quoted 10 lines · Amir Goldstein
Quoted 1 line
Ugh. And I guess overlayfs may have a similar problem.
Not exactly.
Generally speaking, overlayfs should callvfs_copy_file_range()with the flags it got from layer above, so if called from nfsd it will allow cross fs copy and when called from syscall it won't.There are some corner cases where overlayfs could benefit from
COPY_FILE_SPLICE(e.g. copy from lower file to upper file), but let's leave those for now. Just leave overlayfs code as is.Got it, thanks for clarifying.
Quoted 53 lines
Quoted 18 lines
Quoted 6 lines
This is easy to solve with a flag
COPY_FILE_SPLICE(or something) that is internal to kernel users.FWIW, you may want to look at the loop in
ovl_copy_up_data()for improvements tonfsd_copy_file_range().Quoted 7 lines
We can move the check out to
copy_file_rangesyscall:if (flags != 0) return -EINVAL;Leave the fallback from all filesystems and check for the
COPY_FILE_SPLICEflag insidegeneric_copy_file_range().Ok, the diff bellow is just to make sure I understood your suggestion.
The patch will also need to:
Quoted 7 lines
- change nfs and overlayfs calls to
vfs_copy_file_range()so that they use the new flag.- check flags in
generic_copy_file_checks()to make sure only valid flags are used (COPY_FILE_SPLICEat the moment).Also, where should this flag be defined?
include/uapi/linux/fs.h?Grep for
REMAP_FILE_
Same header file, same Documentation rst file.Quoted 10 lines
Cheers,
--
Luisfs/read_write.c +0
-0fs/read_write.c ssize_t generic_copy_file_range(struct file *file_in, loff_t pos_in, · line 1392
Quoted 10 lines
fs/read_write.c +7
-0@@ -1383,6 +1383,13 @@ ssize_t generic_copy_file_range(struct file *file_in, loff_t pos_in, struct file *file_out, loff_t pos_out, size_t len, unsigned int flags) { + if (!(flags & COPY_FILE_SPLICE)) { + if (!file_out->f_op->copy_file_range) + return -EOPNOTSUPP; + else if (file_out->f_op->copy_file_range != + file_in->f_op->copy_file_range) + return -EXDEV; + }That looks strange, because you are duplicating the logic in
do_copy_file_range(). Maybe better:Quoted 5 lines
if (
WARN_ON_ONCE(flags & ~COPY_FILE_SPLICE))return -EINVAL;if (flags &
COPY_FILE_SPLICE)
return do_splice_direct(file_in,&pos_in,file_out,&pos_out,
len >MAX_RW_COUNT?MAX_RW_COUNT: len, 0);My initial reasoning for duplicating the logic in
do_copy_file_range()was to allow thegeneric_copy_file_range()callers to be left unmodified and allow the filesystems to default to this implementation.Quoted 5 lines
With this change, I guess that the calls to
generic_copy_file_range()from the different filesystems can be dropped, as in my initial patch, as they will always get-EINVAL. The other option would be to set theCOPY_FILE_SPLICEflag in those calls, but that would get us back to the problem we're trying to solve.Quoted 6 lines
I don't understand the problem.
What exactly is wrong with the code I suggested?
Why should any filesystem be changed?Maybe I am missing something.
Ok, I have to do a full brain reboot and start all over.
Before that, I picked the code you suggested and tested it. I've mounted a cephfs filesystem and used
xfs_ioto execute a 'copy_range' command using/sys/kernel/debug/sched_featuresas source. The result was a 0-sized file in cephfs. And the reason isthevfs_copy_file_range()early exit in:Quoted 4 lines
if (len == 0) return 0;'len' is set in
generic_copy_file_checks().Good point.. I guess we will need to do all the checks earlier in
generic_copy_file_checks()including the logic of:if (file_in->f_op->remap_file_range && file_inode(file_in)->i_sb == file_inode(file_out)->i_sb)Quoted 9 lines
This means that we're not solving the original problem anymore (probably since v1 of this patch, haven't checked).
Also, re-reading Trond's emails, I read: "... also disallowing the copy from, say, an XFS formatted partition to an ext4 partition". Isn't that *exactly* what we're trying to do here? I.e. _prevent_ these copies from happening so that tracefs files can't be CFR'ed?
We want to address the report which means calls coming from
copy_file_range()syscall.Trond's use case is
vfs_copy_file_range()coming from nfsd. When he writes about copy from XFS to ext4, he means an
NFS client is issuing server side copy (on same or different NFS mounts) and the NFS server is executingnfsd_copy_file_range()on a source file that happens to be on XFS and destination happens to be on ext4.Quoted 4 lines
Quoted 3 lines
NFS also supports a server-to-server copy where the destination server mounts the source server and reads the data to be copied. Please don't break that either :)
As long as the copy is via
nfsd_copy_file_range()and not from the syscall it should not regress.Quoted 2 lines
This is a case we will eventually need to support for cifs (SMB3) as well.
samba already does server side copy very well without needing any support from the kernel.
Quoted 7 lines
nfsd also doesn't *need* to use
vfs_copy_file_range()it can use kernel APIs like the loop inovl_copy_up_data(). But it does, so we should not regress it.samba/nfsd can try to use
copy_file_range()and it will work if the source/target
fs support it. Otherwise, the server can perfectly well do the copy via other available interfaces, just like userspace copy tools.
I was thinking about cifsd ("ksmbd") the kernel server from Namjae/Sergey etc. which is making excellent progress.
Signature · 3 lines
Thanks, Steve
Re: [PATCH v2] vfs: prevent copy_file_range to copy across devices
Quoted 163 lines · Steve French
Quoted 161 lines · Amir Goldstein
Quoted 142 lines · Steve French
Quoted 139 lines · Anna Schumaker
Quoted 136 lines · Amir Goldstein
Quoted 104 lines · Luis Henriques
Quoted 86 lines · Amir Goldstein
Quoted 79 lines · Luis Henriques
Quoted 10 lines · Amir Goldstein
Quoted 1 line
Ugh. And I guess overlayfs may have a similar problem.
Not exactly.
Generally speaking, overlayfs should callvfs_copy_file_range()with the flags it got from layer above, so if called from nfsd it will allow cross fs copy and when called from syscall it won't.There are some corner cases where overlayfs could benefit from
COPY_FILE_SPLICE(e.g. copy from lower file to upper file), but let's leave those for now. Just leave overlayfs code as is.Got it, thanks for clarifying.
Quoted 53 lines
Quoted 18 lines
Quoted 6 lines
This is easy to solve with a flag
COPY_FILE_SPLICE(or something) that is internal to kernel users.FWIW, you may want to look at the loop in
ovl_copy_up_data()for improvements tonfsd_copy_file_range().Quoted 7 lines
We can move the check out to
copy_file_rangesyscall:if (flags != 0) return -EINVAL;Leave the fallback from all filesystems and check for the
COPY_FILE_SPLICEflag insidegeneric_copy_file_range().Ok, the diff bellow is just to make sure I understood your suggestion.
The patch will also need to:
Quoted 7 lines
- change nfs and overlayfs calls to
vfs_copy_file_range()so that they use the new flag.- check flags in
generic_copy_file_checks()to make sure only valid flags are used (COPY_FILE_SPLICEat the moment).Also, where should this flag be defined?
include/uapi/linux/fs.h?Grep for
REMAP_FILE_
Same header file, same Documentation rst file.Quoted 10 lines
Cheers,
--
Luisfs/read_write.c +0
-0fs/read_write.c ssize_t generic_copy_file_range(struct file *file_in, loff_t pos_in, · line 1392
Quoted 10 lines
fs/read_write.c +7
-0@@ -1383,6 +1383,13 @@ ssize_t generic_copy_file_range(struct file *file_in, loff_t pos_in, struct file *file_out, loff_t pos_out, size_t len, unsigned int flags) { + if (!(flags & COPY_FILE_SPLICE)) { + if (!file_out->f_op->copy_file_range) + return -EOPNOTSUPP; + else if (file_out->f_op->copy_file_range != + file_in->f_op->copy_file_range) + return -EXDEV; + }That looks strange, because you are duplicating the logic in
do_copy_file_range(). Maybe better:Quoted 5 lines
if (
WARN_ON_ONCE(flags & ~COPY_FILE_SPLICE))return -EINVAL;if (flags &
COPY_FILE_SPLICE)
return do_splice_direct(file_in,&pos_in,file_out,&pos_out,
len >MAX_RW_COUNT?MAX_RW_COUNT: len, 0);My initial reasoning for duplicating the logic in
do_copy_file_range()was to allow thegeneric_copy_file_range()callers to be left unmodified and allow the filesystems to default to this implementation.Quoted 5 lines
With this change, I guess that the calls to
generic_copy_file_range()from the different filesystems can be dropped, as in my initial patch, as they will always get-EINVAL. The other option would be to set theCOPY_FILE_SPLICEflag in those calls, but that would get us back to the problem we're trying to solve.Quoted 6 lines
I don't understand the problem.
What exactly is wrong with the code I suggested?
Why should any filesystem be changed?Maybe I am missing something.
Ok, I have to do a full brain reboot and start all over.
Before that, I picked the code you suggested and tested it. I've mounted a cephfs filesystem and used
xfs_ioto execute a 'copy_range' command using/sys/kernel/debug/sched_featuresas source. The result was a 0-sized file in cephfs. And the reason isthevfs_copy_file_range()early exit in:Quoted 4 lines
if (len == 0) return 0;'len' is set in
generic_copy_file_checks().Good point.. I guess we will need to do all the checks earlier in
generic_copy_file_checks()including the logic of:if (file_in->f_op->remap_file_range && file_inode(file_in)->i_sb == file_inode(file_out)->i_sb)Quoted 9 lines
This means that we're not solving the original problem anymore (probably since v1 of this patch, haven't checked).
Also, re-reading Trond's emails, I read: "... also disallowing the copy from, say, an XFS formatted partition to an ext4 partition". Isn't that *exactly* what we're trying to do here? I.e. _prevent_ these copies from happening so that tracefs files can't be CFR'ed?
We want to address the report which means calls coming from
copy_file_range()syscall.Trond's use case is
vfs_copy_file_range()coming from nfsd. When he writes about copy from XFS to ext4, he means an
NFS client is issuing server side copy (on same or different NFS mounts) and the NFS server is executingnfsd_copy_file_range()on a source file that happens to be on XFS and destination happens to be on ext4.Quoted 4 lines
Quoted 3 lines
NFS also supports a server-to-server copy where the destination server mounts the source server and reads the data to be copied. Please don't break that either :)
As long as the copy is via
nfsd_copy_file_range()and not from the syscall it should not regress.Quoted 2 lines
This is a case we will eventually need to support for cifs (SMB3) as well.
samba already does server side copy very well without needing any support from the kernel.
nfsd also doesn't *need* to use
vfs_copy_file_range()it can use kernel APIs like the loop inovl_copy_up_data(). But it does, so we should not regress it.
Quoted 8 lines
Quoted 4 lines
samba/nfsd can try to use
copy_file_range()and it will work if the source/target
fs support it. Otherwise, the server can perfectly well do the copy via other available interfaces, just like userspace copy tools.I was thinking about cifsd ("ksmbd") the kernel server from Namjae/Sergey etc. which is making excellent progress.
You are missing my point.
Never mind which server. The server does not *need* to rely on vfs_copy_file_range() to copy files from XFS to ext4.
The server is very capable of implementing the fallback generic copy in case source/target fs do not support native {copy,remap}_file_range().
w.r.t semantics of copy_file_range() syscall vs. the fallback to userespace 'cp' tool (check source file size before copy or not), please note that the semantics of CIFS_IOC_COPYCHUNK_FILE are that of the former:
rc = cifs_file_copychunk_range(xid, src_file.file, 0, dst_file, 0,
src_inode->i_size, 0);
It will copy zero bytes if advertised source file size if zero.
NFS server side copy semantics are currently de-facto the same because both the client and the server will have to pass through this line in vfs_copy_file_range():
if (len == 0)
return 0;IMO, and this opinion was voiced by several other filesystem developers, the shortend copy semantics are the correct semantics for copy_file_range() syscall as well as for vfs_copy_file_range() for internal kernel users.
I guess what this means is that if the 'cp' tool ever tries an opportunistic copy_file_range() syscall (e.g. --cfr=auto), it may result in zero size copy.
Thanks,
Amir.
PATCH v3 1/1 vfs: fix copy_file_range regression in cross-fs copies
A regression has been reported by Nicolas Boichat, found while using the copy_file_range syscall to copy a tracefs file. Before commit 5dae222a5ff0 ("vfs: allow copy_file_range to copy across devices") the kernel would return -EXDEV to userspace when trying to copy a file across different filesystems. After this commit, the syscall doesn't fail anymore and instead returns zero (zero bytes copied), as this file's content is generated on-the-fly and thus reports a size of zero.
This patch restores some cross-filesystems copy restrictions that existed prior to commit 5dae222a5ff0 ("vfs: allow copy_file_range to copy across devices"). It also introduces a flag (COPY_FILE_SPLICE) that can be used by filesystems calling directly into the vfs copy_file_range to override these restrictions. Right now, only NFS needs to set this flag.
---
Ok, I've tried to address all the issues and comments. Hopefully this v3 is a bit closer to the final fix.
Changes since v2
- do all the required checks earlier, in generic_copy_file_checks(), adding new checks for ->remap_file_range
- new COPY_FILE_SPLICE flag
- don't remove filesystem's fallback to generic_copy_file_range()
- updated commit changelog (and subject)
Changes since v1 (after Amir review)
- restored do_copy_file_range() helper
- return -EOPNOTSUPP if fs doesn't implement CFR
- updated commit description
fs/nfsd/vfs.c | 3 ++- fs/read_write.c | 44 +++++++++++++++++++++++++++++++++++++++++--- include/linux/fs.h | 7 +++++++ 3 files changed, 50 insertions(+), 4 deletions(-)
fs/nfsd/vfs.c +2 -1
@@ -578,7 +578,8 @@ ssize_t nfsd_copy_file_range(struct file *src, u64 src_pos, struct file *dst,* limit like this and pipeline multiple COPY requests. */ count =min_t (u64, count,1 <<22 ); -return vfs_copy_file_range (src, src_pos, dst, dst_pos, count,0 ); +return vfs_copy_file_range (src, src_pos, dst, dst_pos, count, +COPY_FILE_SPLICE ); } __be32 nfsd4_vfs_fallocate(struct svc_rqst *rqstp, struct svc_fh *fhp,
fs/read_write.c +41 -3
74 lines not on this page · raw message
include/linux/fs.h +7 -0
@@ -1815,6 +1815,13 @@ struct dir_context {*/ #define REMAP_FILE_ADVISORY (REMAP_FILE_CAN_SHORTEN) +/* +* This flag control the behavior of copy_file_range from internal (kernel) +* users. It can be used to override the policy of forbidding copies when +* source and destination filesystems are different. +*/ +#define COPY_FILE_SPLICE (1 << 0) +struct iov_iter ;struct file_operations {
Re: [PATCH v3] vfs: fix copy_file_range regression in cross-fs copies
Quoted 71 lines · Luis Henriques
A regression has been reported by Nicolas Boichat, found while using the
copy_file_rangesyscall to copy a tracefs file. Before commit5dae222a5ff0("vfs: allowcopy_file_rangeto copy across devices") the kernel would return-EXDEVto userspace when trying to copy a file across different filesystems. After this commit, the syscall doesn't fail anymore and instead returns zero (zero bytes copied), as this file's content is generated on-the-fly and thus reports a size of zero.This patch restores some cross-filesystems copy restrictions that existed prior to commit
5dae222a5ff0("vfs: allowcopy_file_rangeto copy across devices"). It also introduces a flag (COPY_FILE_SPLICE) that can be used by filesystems calling directly into the vfscopy_file_rangeto override these restrictions. Right now, only NFS needs to set this flag.Fixes 5dae222a5ff0 ("vfs: allow copy_file_range to copy across devices")Link https://lore.kernel.org/linux-fsdevel/CANMq1KDZuxir2LM5jOTm0xx+BnvW=ZmpsG47CyHFJwnw7zSX6Q@mail.gmail.com/ open hereLink https://lore.kernel.org/linux-fsdevel/20210126135012.1.If45b7cdc3ff707bc1efa17f5366057d60603c45f@changeid/ open hereReported-by Nicolas Boichat <[email protected]>Signed-off-by Luis Henriques <[email protected]>---
Ok, I've tried to address all the issues and comments. Hopefully this v3 is a bit closer to the final fix.Changes since v2
- do all the required checks earlier, ingeneric_copy_file_checks(), adding new checks for ->remap_file_range
- newCOPY_FILE_SPLICEflag
- don't remove filesystem's fallback togeneric_copy_file_range()
- updated commit changelog (and subject)
Changes since v1 (after Amir review)
- restoreddo_copy_file_range()helper
- return-EOPNOTSUPPif fs doesn't implement CFR
- updated commit descriptionfs/nfsd/vfs.c | 3 ++- fs/read_write.c | 44 +++++++++++++++++++++++++++++++++++++++++--- include/linux/fs.h | 7 +++++++ 3 files changed, 50 insertions(+), 4 deletions(-)fs/nfsd/vfs.c +2
-1@@ -578,7 +578,8 @@ ssize_t nfsd_copy_file_range(struct file *src, u64 src_pos, struct file *dst,* limit like this and pipeline multiple COPY requests. */ count =min_t (u64, count,1 <<22 ); -return vfs_copy_file_range (src, src_pos, dst, dst_pos, count,0 ); +return vfs_copy_file_range (src, src_pos, dst, dst_pos, count, +COPY_FILE_SPLICE ); } __be32 nfsd4_vfs_fallocate(struct svc_rqst *rqstp, struct svc_fh *fhp,fs/read_write.c +8
-0@@ -1410,6 +1410,33 @@ static ssize_t do_copy_file_range(struct file *file_in, loff_t pos_in, flags); } +/* +* This helper function checks whether copy_file_range can actually be used, +* depending on the source and destination filesystems being the same. +* +* In-kernel callers may set COPY_FILE_SPLICE to override these checks. +*/ +static int fops_copy_file_checks (struct file *file_in,struct file *file_out, +unsigned int flags)
fs/read_write.c static ssize_t do_copy_file_range(struct file *file_in, loff_t pos_in, · line 1430
Quoted 10 lines
fs/read_write.c +10
-0+{ +if (WARN_ON_ONCE (flags & ~COPY_FILE_SPLICE )) +return -EINVAL ; + +if (flags ©_FILE_SPLICE ) +return 0 ; +/* +* We got here from userspace, so forbid copies if copy_file_range isn't +* implemented or if we're doing a cross-fs copy. +*/
Suggest:
if (!file_in->f_op->copy_file_range) {
if (file_in->f_op->copy_file_range !=
file_out->f_op->copy_file_range)
return -EXDEV;
} else if (file_in->f_op->remap_file_range) {
if (file_inode(file_in)->i_sb != file_inode(file_out)->i_sb)
return -EXDEV;
} else {
return -EOPNOTSUPP;
}
return 0;
}Quoted 6 lines
fs/read_write.c +1
-0+/* * Performs necessary checks before doing a file copy * @@ -1427,6 +1454,14 @@ static int generic_copy_file_checks(struct file *file_in, loff_t pos_in,loff_t size_in;
fs/read_write.c static int generic_copy_file_checks(struct file *file_in, loff_t pos_in, · line 1464
Quoted 10 lines
fs/read_write.c +8
-0int ret; +/* Only check f_ops if we're not trying to clone */ +if (!file_in->f_op->remap_file_range || + (file_inode (file_in)->i_sb ==file_inode (file_out)->i_sb)) { + ret =fops_copy_file_checks (file_in, file_out, flags); +if (ret) +return ret; + } +
and then you don't need this special casing of clone here.
Quoted 14 lines
fs/read_write.c +0
-3ret =generic_file_rw_checks (file_in, file_out);if (ret)return ret;@@ -1474,9 +1509,6 @@ ssize_t vfs_copy_file_range(struct file *file_in, loff_t pos_in, {ssize_t ret; -if (flags !=0 ) -return -EINVAL ; - ret =generic_copy_file_checks (file_in, pos_in, file_out, pos_out, &len, flags);if (unlikely (ret))
fs/read_write.c ssize_t vfs_copy_file_range(struct file *file_in, loff_t pos_in, · line 1548
Quoted 6 lines
fs/read_write.c +3
-0@@ -1511,6 +1543,9 @@ ssize_t vfs_copy_file_range(struct file *file_in, loff_t pos_in, ret = cloned; goto done; } + ret =fops_copy_file_checks (file_in, file_out, flags); +if (ret) +return ret;
and you don't need this here (right?)
and you can remove the checks for same i_sb and same copy_file_range op that were already tested from vfs_copy_file_range().
Hope I am not missing anything.
Thanks,
Amir.
Re: [PATCH v3] vfs: fix copy_file_range regression in cross-fs copies
In reply to Luis HenriquesQuoted 9 lines · Luis Henriques
A regression has been reported by Nicolas Boichat, found while using the
copy_file_rangesyscall to copy a tracefs file. Before commit5dae222a5ff0("vfs: allowcopy_file_rangeto copy across devices") the kernel would return-EXDEVto userspace when trying to copy a file across different filesystems. After this commit, the syscall doesn't fail anymore and instead returns zero (zero bytes copied), as this file's content is generated on-the-fly and thus reports a size of zero.
Quoted 3 lines
This patch restores some cross-filesystems copy restrictions that existed prior to commit
5dae222a5ff0("vfs: allowcopy_file_rangeto copy across devices").
Note that you also fix intra-filesystem copy_file_range on these generated filesystems. This is IMHO great, but needs to be mentioned in the commit message.
Quoted 5 lines
It also introduces a flag (
COPY_FILE_SPLICE) that can be used
by filesystems calling directly into the vfscopy_file_rangeto override these restrictions. Right now, only NFS needs to set this flag.Fixes 5dae222a5ff0 ("vfs: allow copy_file_range to copy across devices")
So technically this fixes something much older, presumably ever since copy_file_range was introduced.
Quoted 4 lines
but I guess you should not add to the next revision, I'll keep testing further revisions ,-)
Quoted 40 lines
Signed-off-by Luis Henriques <[email protected]>---
Ok, I've tried to address all the issues and comments. Hopefully this v3 is a bit closer to the final fix.Changes since v2
- do all the required checks earlier, ingeneric_copy_file_checks(), adding new checks for ->remap_file_range
- newCOPY_FILE_SPLICEflag
- don't remove filesystem's fallback togeneric_copy_file_range()
- updated commit changelog (and subject)
Changes since v1 (after Amir review)
- restoreddo_copy_file_range()helper
- return-EOPNOTSUPPif fs doesn't implement CFR
- updated commit descriptionfs/nfsd/vfs.c | 3 ++- fs/read_write.c | 44 +++++++++++++++++++++++++++++++++++++++++--- include/linux/fs.h | 7 +++++++ 3 files changed, 50 insertions(+), 4 deletions(-)fs/nfsd/vfs.c +2
-1@@ -578,7 +578,8 @@ ssize_t nfsd_copy_file_range(struct file *src, u64 src_pos, struct file *dst,* limit like this and pipeline multiple COPY requests. */ count =min_t (u64, count,1 <<22 ); -return vfs_copy_file_range (src, src_pos, dst, dst_pos, count,0 ); +return vfs_copy_file_range (src, src_pos, dst, dst_pos, count, +COPY_FILE_SPLICE ); } __be32 nfsd4_vfs_fallocate(struct svc_rqst *rqstp, struct svc_fh *fhp,fs/read_write.c +0
-0
fs/read_write.c static ssize_t do_copy_file_range(struct file *file_in, loff_t pos_in, · line 1419
Quoted 10 lines
fs/read_write.c +7
-0@@ -1410,6 +1410,33 @@ static ssize_t do_copy_file_range(struct file *file_in, loff_t pos_in, flags); } +/* +* This helper function checks whether copy_file_range can actually be used, +* depending on the source and destination filesystems being the same. +* +* In-kernel callers may set COPY_FILE_SPLICE to override these checks. +*/ +static int fops_copy_file_checks(struct file *file_in, struct file *file_out,
fops_copy_file_range_checks ?
fs/read_write.c static ssize_t do_copy_file_range(struct file *file_in, loff_t pos_in, · line 1432
Quoted 13 lines
fs/read_write.c +13
-0+ unsigned int flags) +{ +if (WARN_ON_ONCE (flags & ~COPY_FILE_SPLICE )) +return -EINVAL ; + +if (flags ©_FILE_SPLICE ) +return 0 ; +/* +* We got here from userspace, so forbid copies if copy_file_range isn't +* implemented or if we're doing a cross-fs copy. +*/ +if (!file_out->f_op->copy_file_range) +return -EOPNOTSUPP ;
After this is merged, should this be added as an error code to the man page?
fs/read_write.c static ssize_t do_copy_file_range(struct file *file_in, loff_t pos_in, · line 1434
Quoted 2 lines
fs/read_write.c +2
-0+else if (file_out->f_op->copy_file_range != + file_in->f_op->copy_file_range)
Just note, this could be a cross-fs copy (just not a cross-fs_type copy).
Quoted 58 lines
fs/read_write.c +19
-3+return -EXDEV ; + +return 0 ; +} +/* * Performs necessary checks before doing a file copy * @@ -1427,6 +1454,14 @@ static int generic_copy_file_checks(struct file *file_in, loff_t pos_in,loff_t size_in;int ret; +/* Only check f_ops if we're not trying to clone */ +if (!file_in->f_op->remap_file_range || + (file_inode (file_in)->i_sb ==file_inode (file_out)->i_sb)) { + ret =fops_copy_file_checks (file_in, file_out, flags); +if (ret) +return ret; + } + ret =generic_file_rw_checks (file_in, file_out);if (ret)return ret;@@ -1474,9 +1509,6 @@ ssize_t vfs_copy_file_range(struct file *file_in, loff_t pos_in, {ssize_t ret; -if (flags !=0 ) -return -EINVAL ; - ret =generic_copy_file_checks (file_in, pos_in, file_out, pos_out, &len, flags);if (unlikely (ret))@@ -1511,6 +1543,9 @@ ssize_t vfs_copy_file_range(struct file *file_in, loff_t pos_in, ret = cloned; goto done; } + ret =fops_copy_file_checks (file_in, file_out, flags); +if (ret) +return ret; } ret = do_copy_file_range(file_in, pos_in, file_out, pos_out, len,@@ -1543,6 +1578,9 @@ SYSCALL_DEFINE6(copy_file_range, int, fd_in, loff_t __user *, off_in,struct fd f_out;ssize_t ret = -EBADF ; +if (flags !=0 ) +return -EINVAL ; + f_in =fdget (fd_in);if (!f_in.file) goto out2;include/linux/fs.h +0
-0
include/linux/fs.h struct dir_context { · line 1823
Quoted 9 lines
include/linux/fs.h +6
-0@@ -1815,6 +1815,13 @@ struct dir_context {*/ #define REMAP_FILE_ADVISORY (REMAP_FILE_CAN_SHORTEN) +/* +* This flag control the behavior of copy_file_range from internal (kernel) +* users. It can be used to override the policy of forbidding copies when +* source and destination filesystems are different. +*/ +#define COPY_FILE_SPLICE (1 << 0)
nit: BIT(0) ?
Quoted 4 lines
include/linux/fs.h +1
-0+struct iov_iter ;struct file_operations {
Re: [PATCH v3] vfs: fix copy_file_range regression in cross-fs copies
In reply to Luis HenriquesQuoted 25 lines · Luis Henriques
A regression has been reported by Nicolas Boichat, found while using the
copy_file_rangesyscall to copy a tracefs file. Before commit5dae222a5ff0("vfs: allowcopy_file_rangeto copy across devices") the kernel would return-EXDEVto userspace when trying to copy a file across different filesystems. After this commit, the syscall doesn't fail anymore and instead returns zero (zero bytes copied), as this file's content is generated on-the-fly and thus reports a size of zero.This patch restores some cross-filesystems copy restrictions that existed prior to commit
5dae222a5ff0("vfs: allowcopy_file_rangeto copy across devices"). It also introduces a flag (COPY_FILE_SPLICE) that can be used by filesystems calling directly into the vfscopy_file_rangeto override these restrictions. Right now, only NFS needs to set this flag.Fixes 5dae222a5ff0 ("vfs: allow copy_file_range to copy across devices")Link https://lore.kernel.org/linux-fsdevel/CANMq1KDZuxir2LM5jOTm0xx+BnvW=ZmpsG47CyHFJwnw7zSX6Q@mail.gmail.com/ open hereLink https://lore.kernel.org/linux-fsdevel/20210126135012.1.If45b7cdc3ff707bc1efa17f5366057d60603c45f@changeid/ open hereReported-by Nicolas Boichat <[email protected]>Signed-off-by Luis Henriques <[email protected]>---
Ok, I've tried to address all the issues and comments. Hopefully this v3 is a bit closer to the final fix.
Quoted 10 lines
Changes since v2
- do all the required checks earlier, ingeneric_copy_file_checks(), adding new checks for ->remap_file_range
- newCOPY_FILE_SPLICEflag
- don't remove filesystem's fallback togeneric_copy_file_range()
- updated commit changelog (and subject)
Changes since v1 (after Amir review)
- restoreddo_copy_file_range()helper
- return-EOPNOTSUPPif fs doesn't implement CFR
- updated commit description
In my testing, this patch breaks NFS server-to-server copy file.
Quoted 121 lines
fs/nfsd/vfs.c | 3 ++- fs/read_write.c | 44 +++++++++++++++++++++++++++++++++++++++++--- include/linux/fs.h | 7 +++++++ 3 files changed, 50 insertions(+), 4 deletions(-)fs/nfsd/vfs.c +2
-1@@ -578,7 +578,8 @@ ssize_t nfsd_copy_file_range(struct file *src, u64 src_pos, struct file *dst,* limit like this and pipeline multiple COPY requests. */ count =min_t (u64, count,1 <<22 ); -return vfs_copy_file_range (src, src_pos, dst, dst_pos, count,0 ); +return vfs_copy_file_range (src, src_pos, dst, dst_pos, count, +COPY_FILE_SPLICE ); } __be32 nfsd4_vfs_fallocate(struct svc_rqst *rqstp, struct svc_fh *fhp,fs/read_write.c +41
-3@@ -1410,6 +1410,33 @@ static ssize_t do_copy_file_range(struct file *file_in, loff_t pos_in, flags); } +/* +* This helper function checks whether copy_file_range can actually be used, +* depending on the source and destination filesystems being the same. +* +* In-kernel callers may set COPY_FILE_SPLICE to override these checks. +*/ +static int fops_copy_file_checks (struct file *file_in,struct file *file_out, +unsigned int flags) +{ +if (WARN_ON_ONCE (flags & ~COPY_FILE_SPLICE )) +return -EINVAL ; + +if (flags ©_FILE_SPLICE ) +return 0 ; +/* +* We got here from userspace, so forbid copies if copy_file_range isn't +* implemented or if we're doing a cross-fs copy. +*/ +if (!file_out->f_op->copy_file_range) +return -EOPNOTSUPP ; +else if (file_out->f_op->copy_file_range != + file_in->f_op->copy_file_range) +return -EXDEV ; + +return 0 ; +} +/* * Performs necessary checks before doing a file copy * @@ -1427,6 +1454,14 @@ static int generic_copy_file_checks(struct file *file_in, loff_t pos_in,loff_t size_in;int ret; +/* Only check f_ops if we're not trying to clone */ +if (!file_in->f_op->remap_file_range || + (file_inode (file_in)->i_sb ==file_inode (file_out)->i_sb)) { + ret =fops_copy_file_checks (file_in, file_out, flags); +if (ret) +return ret; + } + ret =generic_file_rw_checks (file_in, file_out);if (ret)return ret;@@ -1474,9 +1509,6 @@ ssize_t vfs_copy_file_range(struct file *file_in, loff_t pos_in, {ssize_t ret; -if (flags !=0 ) -return -EINVAL ; - ret =generic_copy_file_checks (file_in, pos_in, file_out, pos_out, &len, flags);if (unlikely (ret))@@ -1511,6 +1543,9 @@ ssize_t vfs_copy_file_range(struct file *file_in, loff_t pos_in, ret = cloned; goto done; } + ret =fops_copy_file_checks (file_in, file_out, flags); +if (ret) +return ret; } ret = do_copy_file_range(file_in, pos_in, file_out, pos_out, len,@@ -1543,6 +1578,9 @@ SYSCALL_DEFINE6(copy_file_range, int, fd_in, loff_t __user *, off_in,struct fd f_out;ssize_t ret = -EBADF ; +if (flags !=0 ) +return -EINVAL ; + f_in =fdget (fd_in);if (!f_in.file) goto out2;include/linux/fs.h +7
-0@@ -1815,6 +1815,13 @@ struct dir_context {*/ #define REMAP_FILE_ADVISORY (REMAP_FILE_CAN_SHORTEN) +/* +* This flag control the behavior of copy_file_range from internal (kernel) +* users. It can be used to override the policy of forbidding copies when +* source and destination filesystems are different. +*/ +#define COPY_FILE_SPLICE (1 << 0) +struct iov_iter ;struct file_operations {
Re: [PATCH v3] vfs: fix copy_file_range regression in cross-fs copies
Quoted 38 lines · Olga Kornievskaia
Quoted 25 lines · Luis Henriques
A regression has been reported by Nicolas Boichat, found while using the
copy_file_rangesyscall to copy a tracefs file. Before commit5dae222a5ff0("vfs: allowcopy_file_rangeto copy across devices") the kernel would return-EXDEVto userspace when trying to copy a file across different filesystems. After this commit, the syscall doesn't fail anymore and instead returns zero (zero bytes copied), as this file's content is generated on-the-fly and thus reports a size of zero.This patch restores some cross-filesystems copy restrictions that existed prior to commit
5dae222a5ff0("vfs: allowcopy_file_rangeto copy across devices"). It also introduces a flag (COPY_FILE_SPLICE) that can be used by filesystems calling directly into the vfscopy_file_rangeto override these restrictions. Right now, only NFS needs to set this flag.Fixes 5dae222a5ff0 ("vfs: allow copy_file_range to copy across devices")Link https://lore.kernel.org/linux-fsdevel/CANMq1KDZuxir2LM5jOTm0xx+BnvW=ZmpsG47CyHFJwnw7zSX6Q@mail.gmail.com/ open hereLink https://lore.kernel.org/linux-fsdevel/20210126135012.1.If45b7cdc3ff707bc1efa17f5366057d60603c45f@changeid/ open hereReported-by Nicolas Boichat <[email protected]>Signed-off-by Luis Henriques <[email protected]>---
Ok, I've tried to address all the issues and comments. Hopefully this v3 is a bit closer to the final fix.Quoted 10 lines
Changes since v2
- do all the required checks earlier, ingeneric_copy_file_checks(), adding new checks for ->remap_file_range
- newCOPY_FILE_SPLICEflag
- don't remove filesystem's fallback togeneric_copy_file_range()
- updated commit changelog (and subject)
Changes since v1 (after Amir review)
- restoreddo_copy_file_range()helper
- return-EOPNOTSUPPif fs doesn't implement CFR
- updated commit description
Quoted 1 line
In my testing, this patch breaks NFS server-to-server copy file.
Hi Olga,
Can you please provide more details on the failed tests.
Does it fail on the client between two nfs mounts or does it fail on the server? If the latter, between which two filesystems on the server?
Thanks,
Amir.
Re: [PATCH v3] vfs: fix copy_file_range regression in cross-fs copies
Quoted 40 lines · Amir Goldstein
Quoted 38 lines · Olga Kornievskaia
Quoted 35 lines · Luis Henriques
A regression has been reported by Nicolas Boichat, found while using the
copy_file_rangesyscall to copy a tracefs file. Before commit5dae222a5ff0("vfs: allowcopy_file_rangeto copy across devices") the kernel would return-EXDEVto userspace when trying to copy a file across different filesystems. After this commit, the syscall doesn't fail anymore and instead returns zero (zero bytes copied), as this file's content is generated on-the-fly and thus reports a size of zero.This patch restores some cross-filesystems copy restrictions that existed prior to commit
5dae222a5ff0("vfs: allowcopy_file_rangeto copy across devices"). It also introduces a flag (COPY_FILE_SPLICE) that can be used by filesystems calling directly into the vfscopy_file_rangeto override these restrictions. Right now, only NFS needs to set this flag.Fixes 5dae222a5ff0 ("vfs: allow copy_file_range to copy across devices")Link https://lore.kernel.org/linux-fsdevel/CANMq1KDZuxir2LM5jOTm0xx+BnvW=ZmpsG47CyHFJwnw7zSX6Q@mail.gmail.com/ open hereLink https://lore.kernel.org/linux-fsdevel/20210126135012.1.If45b7cdc3ff707bc1efa17f5366057d60603c45f@changeid/ open hereReported-by Nicolas Boichat <[email protected]>Signed-off-by Luis Henriques <[email protected]>---
Ok, I've tried to address all the issues and comments. Hopefully this v3 is a bit closer to the final fix.Changes since v2
- do all the required checks earlier, ingeneric_copy_file_checks(), adding new checks for ->remap_file_range
- newCOPY_FILE_SPLICEflag
- don't remove filesystem's fallback togeneric_copy_file_range()
- updated commit changelog (and subject)
Changes since v1 (after Amir review)
- restoreddo_copy_file_range()helper
- return-EOPNOTSUPPif fs doesn't implement CFR
- updated commit description
Quoted 9 lines
Quoted 1 line
In my testing, this patch breaks NFS server-to-server copy file.
Hi Olga,
Can you please provide more details on the failed tests.
Does it fail on the client between two nfs mounts or does it fail on the server? If the latter, between which two filesystems on the server?
It was a pilot error. V3 worked. I'm having some other issues with server to server copy code but they seem to be unrelated to this. I will test the new v6 versions when it comes out.
Quoted 2 lines
Thanks,
Amir.
Re: [PATCH v3] vfs: fix copy_file_range regression in cross-fs copies
In reply to Luis HenriquesQuoted 8 lines · Luis Henriques
A regression has been reported by Nicolas Boichat, found while using the
copy_file_rangesyscall to copy a tracefs file. Before commit5dae222a5ff0("vfs: allowcopy_file_rangeto copy across devices") the kernel would return-EXDEVto userspace when trying to copy a file across different filesystems. After this commit, the syscall doesn't fail anymore and instead returns zero (zero bytes copied), as this file's content is generated on-the-fly and thus reports a size of zero.
Quoted 5 lines
This patch restores some cross-filesystems copy restrictions that existed prior to commit
5dae222a5ff0("vfs: allowcopy_file_rangeto copy across devices"). It also introduces a flag (COPY_FILE_SPLICE) that can be used by filesystems calling directly into the vfscopy_file_rangeto override these restrictions. Right now, only NFS needs to set this flag.
No need for the flag. Jyst fall back to splicing in the only caller that wants it.
Re: [PATCH v2] vfs: prevent copy_file_range to copy across devices
In reply to Amir GoldsteinQuoted 23 lines · Amir Goldstein
You are missing my point.
Never mind which server. The server does not *need* to rely onvfs_copy_file_range()to copy files from XFS to ext4.
The server is very capable of implementing the fallback generic copy in case source/target fs do not support native {copy,remap}_file_range().w.r.t semantics of
copy_file_range()syscall vs. the fallback to userespace 'cp' tool (check source file size before copy or not), please note that the semantics ofCIFS_IOC_COPYCHUNK_FILEare that of the former:rc = cifs_file_copychunk_range(xid, src_file.file, 0,
dst_file, 0,
src_inode->i_size, 0);It will copy zero bytes if advertised source file size if zero.
NFS server side copy semantics are currently de-facto the same because both the client and the server will have to pass through this line in
vfs_copy_file_range():if (len == 0) return 0;
Quoted 6 lines
IMO, and this opinion was voiced by several other filesystem developers, the shortend copy semantics are the correct semantics for
copy_file_range()syscall as well as forvfs_copy_file_range()for internal kernel users.I guess what this means is that if the 'cp' tool ever tries an opportunistic
copy_file_range()syscall (e.g. --cfr=auto), it may result in zero size copy.
Having a syscall that does the "wrong thing" when called on two files doesn't make sense. Expecting userspace to check whether source/target files supports CFR is also not practical. This is trivial for the kernel to determine and return -EOPNOTSUPP to the caller if the source file (procfs/sysfs/etc) does not work with CFR properly.
Applications must already handle -EOPNOTSUPP with a fallback, but expecting all applications that may call copy_file_range() to be properly coded to handle corner cases is just asking for trouble. That is doubly true given that an existing widely-used tool like cp and mv are using this syscall if it is available in the kernel.
Cheers, Andreas
[email protected]
maintainerRe: [PATCH v2] vfs: prevent copy_file_range to copy across devices
Quoted 28 lines · Andreas Dilger
Quoted 27 lines · Amir Goldstein
You are missing my point.
Never mind which server. The server does not *need* to rely onvfs_copy_file_range()to copy files from XFS to ext4.
The server is very capable of implementing the fallback generic copy in case source/target fs do not support native {copy,remap}_file_range().w.r.t semantics of
copy_file_range()syscall vs. the fallback to userespace 'cp' tool (check source file size before copy or not), please note that the semantics ofCIFS_IOC_COPYCHUNK_FILEare that of the former:rc = cifs_file_copychunk_range(xid, src_file.file, 0,
dst_file, 0,
src_inode->i_size, 0);It will copy zero bytes if advertised source file size if zero.
NFS server side copy semantics are currently de-facto the same because both the client and the server will have to pass through this line in
vfs_copy_file_range():if (len == 0) return 0;IMO, and this opinion was voiced by several other filesystem developers, the shortend copy semantics are the correct semantics for
copy_file_range()syscall as well as forvfs_copy_file_range()for internal kernel users.
Quoted 8 lines
Quoted 2 lines
I guess what this means is that if the 'cp' tool ever tries an opportunistic
copy_file_range()syscall (e.g. --cfr=auto), it may result in zero size copy.Having a syscall that does the "wrong thing" when called on two files doesn't make sense. Expecting userspace to check whether source/target files supports CFR is also not practical. This is trivial for the kernel to determine and return
-EOPNOTSUPPto the caller if the source file (procfs/sysfs/etc) does not work with CFR properly.
How does the kernel "know" that a specific file in a specific filesystem will not work with CFR "properly"? That goes back to the original patch which tried to label each and every filesystem type with a "supported/not supported" type of flag, which was going to be a mess, especially as it seems that this might be a file-specific thing, not a filesystem-specific thing.
The goal of the patch _should_ be that the kernel figure it out itself, but so far no one seems to be able to explain how that can be done :(
So, any hints?
thanks,
greg k-h
Re: [PATCH v2] vfs: prevent copy_file_range to copy across devices
In reply to Amir GoldsteinQuoted 50 lines · Amir Goldstein
Quoted 36 lines
Quoted 7 lines
This is easy to solve with a flag
COPY_FILE_SPLICE(or something) that is internal to kernel users.FWIW, you may want to look at the loop in
ovl_copy_up_data()for improvements tonfsd_copy_file_range().Quoted 7 lines
We can move the check out to
copy_file_rangesyscall:if (flags != 0) return -EINVAL;Leave the fallback from all filesystems and check for the
COPY_FILE_SPLICEflag insidegeneric_copy_file_range().Ok, the diff bellow is just to make sure I understood your suggestion.
The patch will also need to:
- change nfs and overlayfs calls to
vfs_copy_file_range()so that they use the new flag.- check flags in
generic_copy_file_checks()to make sure only valid flags are used (COPY_FILE_SPLICEat the moment).Also, where should this flag be defined?
include/uapi/linux/fs.h?Cheers,
--
Luisfs/read_write.c +0
-0fs/read_write.c ssize_t generic_copy_file_range(struct file *file_in, loff_t pos_in, · line 1392
Quoted 10 lines
fs/read_write.c +7
-0@@ -1383,6 +1383,13 @@ ssize_t generic_copy_file_range(struct file *file_in, loff_t pos_in, struct file *file_out, loff_t pos_out, size_t len, unsigned int flags) { + if (!(flags & COPY_FILE_SPLICE)) { + if (!file_out->f_op->copy_file_range) + return -EOPNOTSUPP; + else if (file_out->f_op->copy_file_range != + file_in->f_op->copy_file_range) + return -EXDEV; + }That looks strange, because you are duplicating the logic in
do_copy_file_range(). Maybe better:
Quoted 8 lines
if (
WARN_ON_ONCE(flags & ~COPY_FILE_SPLICE))return -EINVAL;if (flags &
COPY_FILE_SPLICE)
return do_splice_direct(file_in,&pos_in,file_out,&pos_out,
len >MAX_RW_COUNT?MAX_RW_COUNT: len, 0);
if (!file_out->f_op->copy_file_range)return -EOPNOTSUPP;return
-EXDEV;
This shouldn't return -EINVAL to userspace if the flag is not set.
That implies there *is* some valid way for userspace to call this function, which is AFAICS not possible if COPY_FILE_SPLICE is only available to in-kernel callers. Instead, it should continue to return -EOPNOTSUPP to userspace if copy_file_range() is not valid for this combination of file descriptors, so that applications will fall back to the non-CFR implementation.
The WARN_ON_ONCE(ret == -EOPNOTSUPP) in vfs_copy_file_range() would also need to be removed if this will be triggered from userspace.
Cheers, Andreas
Re: [PATCH v2] vfs: prevent copy_file_range to copy across devices
In reply to Luis HenriquesQuoted 5 lines · Luis Henriques
Nicolas Boichat reported an issue when trying to use the
copy_file_rangesyscall on a tracefs file. It failed silently because the file content is generated on-the-fly (reporting a size of zero) andcopy_file_rangeneeds to know in advance how much data is present.
Not sure if you have the whole history, these links and discussion can
help if you want to expand on the commit message:
[1] http://issuetracker.google.com/issues/178332739
[2] https://lkml.org/lkml/2021/1/25/64
[3] https://lkml.org/lkml/2021/1/26/1736
[4] https://patchwork.kernel.org/project/linux-fsdevel/cover/[email protected]/
Quoted 3 lines
This commit restores the cross-fs restrictions that existed prior to
5dae222a5ff0("vfs: allowcopy_file_rangeto copy across devices") and removesgeneric_copy_file_range()calls from ceph, cifs, fuse, and nfs.
It goes beyond that, I think this also prevents copies within the same FS if copy_file_range is not implemented. Which is IMHO a good thing since this has been broken on procfs and friends ever since copy_file_range was implemented (but I assume that nobody ever hit that before cross-fs became available).
Quoted 4 lines
Fixes 5dae222a5ff0 ("vfs: allow copy_file_range to copy across devices")Cc Nicolas Boichat <[email protected]>
You could replace that with Reported-by: Nicolas Boichat <[email protected]>
Quoted 15 lines
Signed-off-by Luis Henriques <[email protected]>---
Changes since v1 (after Amir review)
- restoreddo_copy_file_range()helper
- return-EOPNOTSUPPif fs doesn't implement CFR
- updated commit descriptionfs/ceph/file.c | 21 +++----------------- fs/cifs/cifsfs.c | 3 --- fs/fuse/file.c | 21 +++----------------- fs/nfs/nfs4file.c | 20 +++---------------- fs/read_write.c | 49 ++++++++++------------------------------------ include/linux/fs.h | 3 --- 6 files changed, 19 insertions(+), 98 deletions(-)
[snip]
Quoted 48 lines
fs/read_write.c +2
-30@@ -1358,40 +1358,12 @@ COMPAT_SYSCALL_DEFINE4(sendfile64, int, out_fd, int, in_fd, }#endif -/** -* generic_copy_file_range - copy data between two files -* @file_in: file structure to read from -* @pos_in: file offset to read from -* @file_out: file structure to write data to -* @pos_out: file offset to write data to -* @len: amount of data to copy -* @flags: copy flags -* -* This is a generic filesystem helper to copy data from one file to another. -* It has no constraints on the source or destination file owners - the files -* can belong to different superblocks and different filesystem types. Short -* copies are allowed. -* -* This should be called from the @file_out filesystem, as per the -* ->copy_file_range() method. -* -* Returns the number of bytes copied or a negative error indicating the -* failure. -*/ - -ssize_t generic_copy_file_range (struct file *file_in,loff_t pos_in, -struct file *file_out,loff_t pos_out, -size_t len,unsigned int flags) -{ -return do_splice_direct (file_in, &pos_in, file_out, &pos_out, - len >MAX_RW_COUNT ?MAX_RW_COUNT : len,0 ); -} -EXPORT_SYMBOL (generic_copy_file_range); -static ssize_t do_copy_file_range (struct file *file_in,loff_t pos_in,struct file *file_out,loff_t pos_out,size_t len,unsigned int flags) { +ssize_t ret = -EXDEV ; +/* * Although we now allow filesystems to handle cross sb copy, passing * a file of the wrong filesystem type to filesystem driver can result
fs/read_write.c static ssize_t do_copy_file_range(struct file *file_in, loff_t pos_in, · line 1376
Quoted 10 lines
fs/read_write.c +2
-5@@ -1400,14 +1372,14 @@ static ssize_t do_copy_file_range(struct file *file_in, loff_t pos_in,* several different file_system_type structures, but they all end up * using the same ->copy_file_range() function pointer. */ -if (file_out->f_op->copy_file_range && - file_out->f_op->copy_file_range == file_in->f_op->copy_file_range) -return file_out->f_op->copy_file_range (file_in, pos_in, - file_out, pos_out, - len, flags); +if (!file_out->f_op->copy_file_range) + ret = -EOPNOTSUPP ;
This doesn't work as the 0-filesize check is done before that in vfs_copy_file_range (so the syscall still returns 0, works fine if you comment out if (len == 0)).
Also, you need to check for file_in->f_op->copy_file_range instead, the problem is if the _input_ filesystem doesn't report sizes or can't seek properly.
Quoted 21 lines
fs/read_write.c +6
-4+else if (file_out->f_op->copy_file_range == file_in->f_op->copy_file_range) + ret = file_out->f_op->copy_file_range (file_in, pos_in, + file_out, pos_out, + len, flags); -return generic_copy_file_range (file_in, pos_in, file_out, pos_out, len, - flags); +return ret; }/* @@ -1514,8 +1486,7 @@ ssize_t vfs_copy_file_range(struct file *file_in, loff_t pos_in, } ret =do_copy_file_range (file_in, pos_in, file_out, pos_out, len, - flags); -WARN_ON_ONCE (ret == -EOPNOTSUPP ); + flags); done:if (ret >0 ) {fsnotify_access (file_in);
Re: [PATCH v2] vfs: prevent copy_file_range to copy across devices
In reply to Luis HenriquesLooks good:
This whole idea of cross-device copie has always been a horrible idea, and I've been arguing against it since the patches were posted.
Re: [PATCH v2] vfs: prevent copy_file_range to copy across devices
Quoted 7 lines · Christoph Hellwig
Looks good:
Reviewed-by Christoph Hellwig <[email protected]>This whole idea of cross-device copie has always been a horrible idea, and I've been arguing against it since the patches were posted.
Ok. I'm good with this v2 as well, but need to add the fallback to do_splice_direct()
in nfsd_copy_file_range(), because this patch breaks it.
And the commit message of v3 is better in describing the reported issue.
Thanks,
Amir.
Re: [PATCH v2] vfs: prevent copy_file_range to copy across devices
Quoted 6 lines · Amir Goldstein
Quoted 5 lines · Christoph Hellwig
Looks good:
Reviewed-by Christoph Hellwig <[email protected]>
Quoted 8 lines
Quoted 2 lines
This whole idea of cross-device copie has always been a horrible idea, and I've been arguing against it since the patches were posted.
Ok. I'm good with this v2 as well, but need to add the fallback to
do_splice_direct()
innfsd_copy_file_range(), because this patch breaks it.And the commit message of v3 is better in describing the reported issue.
Except that, as I said in a previous email, v2 doesn't really fix the
issue: all the checks need to be done earlier in generic_copy_file_checks().
I'll work on getting v4, based on v2 and but moving the checks and implementing your review suggestions to v3 (plus this nfs change).
Cheers,
Signature · 1 line
Luis
Re: [PATCH v2] vfs: prevent copy_file_range to copy across devices
Quoted 15 lines · Luis Henriques
Quoted 13 lines · Amir Goldstein
Quoted 7 lines · Christoph Hellwig
Looks good:
Reviewed-by Christoph Hellwig <[email protected]>This whole idea of cross-device copie has always been a horrible idea, and I've been arguing against it since the patches were posted.
Ok. I'm good with this v2 as well, but need to add the fallback to
do_splice_direct()
innfsd_copy_file_range(), because this patch breaks it.
Quoted 7 lines
Quoted 1 line
And the commit message of v3 is better in describing the reported issue.
Except that, as I said in a previous email, v2 doesn't really fix the
issue: all the checks need to be done earlier ingeneric_copy_file_checks().I'll work on getting v4, based on v2 and but moving the checks and implementing your review suggestions to v3 (plus this nfs change).
There's something else:
The filesystems (nfs, ceph, cifs, fuse) rely on the fallback to generic_copy_file_range() if something's wrong. And this "something's wrong" is fs specific. For example: in ceph it is possible to offload the file copy to the OSDs even if the files are in different filesystems as long as these filesystems are on the *same* ceph cluster. If the copy being done is across two different clusters, then the copy reverts to splice. This means that the boilerplate code being removed in v2 of this patch needs to be restored and replace by:
ret = __ceph_copy_file_range(src_file, src_off, dst_file, dst_off, len, flags); if (ret == -EOPNOTSUPP || ret == -EXDEV) ret = do_splice_direct(src_file, &src_off, dst_file, &dst_off, len > MAX_RW_COUNT ? MAX_RW_COUNT : len, flags); return ret;
A quick look at the other filesystems code indicate similar patterns. Since at this point we've gone through all the syscall checks already, calling do_splice_direct() shouldn't be a huge change. But I may be missing something. Again. Which is quite likely :-)
Cheers,
Signature · 1 line
Luis
Re: [PATCH v2] vfs: prevent copy_file_range to copy across devices
Quoted 37 lines · Luis Henriques
Quoted 15 lines · Luis Henriques
Quoted 13 lines · Amir Goldstein
Quoted 7 lines · Christoph Hellwig
Looks good:
Reviewed-by Christoph Hellwig <[email protected]>This whole idea of cross-device copie has always been a horrible idea, and I've been arguing against it since the patches were posted.
Ok. I'm good with this v2 as well, but need to add the fallback to
do_splice_direct()
innfsd_copy_file_range(), because this patch breaks it.Quoted 7 lines
Quoted 1 line
And the commit message of v3 is better in describing the reported issue.
Except that, as I said in a previous email, v2 doesn't really fix the
issue: all the checks need to be done earlier ingeneric_copy_file_checks().I'll work on getting v4, based on v2 and but moving the checks and implementing your review suggestions to v3 (plus this nfs change).
There's something else:
The filesystems (nfs, ceph, cifs, fuse) rely on the fallback to
generic_copy_file_range()if something's wrong. And this "something's wrong" is fs specific. For example: in ceph it is possible to offload the file copy to the OSDs even if the files are in different filesystems as long as these filesystems are on the *same* ceph cluster. If the copy being done is across two different clusters, then the copy reverts to splice. This means that the boilerplate code being removed in v2 of this patch needs to be restored and replace by:
Quoted 9 lines
ret = __ceph_copy_file_range(src_file, src_off, dst_file, dst_off,
len, flags);
if (ret == -EOPNOTSUPP || ret == -EXDEV)
ret = do_splice_direct(src_file, &src_off, dst_file, &dst_off,
len > MAX_RW_COUNT ? MAX_RW_COUNT : len,
flags);
return ret;Why not leave the filesystem code as is and leave the generic_copy_file_range() helper? Less churn.
Then nfsd_copy_file_range() can also fallback to generic_copy_file_range().
Thanks,
Amir.
PATCH v4 1/1 vfs: fix copy_file_range regression in cross-fs copies
A regression has been reported by Nicolas Boichat, found while using the copy_file_range syscall to copy a tracefs file. Before commit 5dae222a5ff0 ("vfs: allow copy_file_range to copy across devices") the kernel would return -EXDEV to userspace when trying to copy a file across different filesystems. After this commit, the syscall doesn't fail anymore and instead returns zero (zero bytes copied), as this file's content is generated on-the-fly and thus reports a size of zero.
This patch restores some cross-filesystem copy restrictions that existed prior to commit 5dae222a5ff0 ("vfs: allow copy_file_range to copy across devices"). Filesystems are still allowed to fall-back to the VFS generic_copy_file_range() implementation, but that has now to be done explicitly.
nfsd is also modified to use generic_copy_file_range() instead of vfs_copy_file_range() so that it can still fall-back to splice without going through all the checks.
---
And here's v4. I'd like to request help for testing. I know Nicolas is doing that (thanks! and thanks for the reviews). But it would be great to get at least the nfs code tested. Olga, can you help here?
Changes since v3
- dropped the COPY_FILE_SPLICE flag
- kept the f_op's checks early in generic_copy_file_checks, implementing Amir's suggestions
- modified nfsd to use generic_copy_file_range()
Changes since v2
- do all the required checks earlier, in generic_copy_file_checks(), adding new checks for ->remap_file_range
- new COPY_FILE_SPLICE flag
- don't remove filesystem's fallback to generic_copy_file_range()
- updated commit changelog (and subject)
Changes since v1 (after Amir review)
- restored do_copy_file_range() helper
- return -EOPNOTSUPP if fs doesn't implement CFR
- updated commit description
fs/nfsd/vfs.c | 2 +- fs/read_write.c | 50 +++++++++++++++++++++++-------------------------- 2 files changed, 24 insertions(+), 28 deletions(-)
fs/nfsd/vfs.c +1 -1
@@ -578,7 +578,7 @@ ssize_t nfsd_copy_file_range(struct file *src, u64 src_pos, struct file *dst,* limit like this and pipeline multiple COPY requests. */ count =min_t (u64, count,1 <<22 ); -return vfs_copy_file_range (src, src_pos, dst, dst_pos, count,0 ); +return generic_copy_file_range (src, src_pos, dst, dst_pos, count,0 ); } __be32 nfsd4_vfs_fallocate(struct svc_rqst *rqstp, struct svc_fh *fhp,
fs/read_write.c +23 -27
74 lines not on this page · raw message
Re: [PATCH v4] vfs: fix copy_file_range regression in cross-fs copies
Quoted 55 lines · Luis Henriques
A regression has been reported by Nicolas Boichat, found while using the
copy_file_rangesyscall to copy a tracefs file. Before commit5dae222a5ff0("vfs: allowcopy_file_rangeto copy across devices") the kernel would return-EXDEVto userspace when trying to copy a file across different filesystems. After this commit, the syscall doesn't fail anymore and instead returns zero (zero bytes copied), as this file's content is generated on-the-fly and thus reports a size of zero.This patch restores some cross-filesystem copy restrictions that existed prior to commit
5dae222a5ff0("vfs: allowcopy_file_rangeto copy across devices"). Filesystems are still allowed to fall-back to the VFSgeneric_copy_file_range()implementation, but that has now to be done explicitly.nfsd is also modified to use
generic_copy_file_range()instead ofvfs_copy_file_range()so that it can still fall-back to splice without going through all the checks.Fixes 5dae222a5ff0 ("vfs: allow copy_file_range to copy across devices")Link https://lore.kernel.org/linux-fsdevel/CANMq1KDZuxir2LM5jOTm0xx+BnvW=ZmpsG47CyHFJwnw7zSX6Q@mail.gmail.com/ open hereLink https://lore.kernel.org/linux-fsdevel/20210126135012.1.If45b7cdc3ff707bc1efa17f5366057d60603c45f@changeid/ open hereReported-by Nicolas Boichat <[email protected]>Signed-off-by Luis Henriques <[email protected]>---
And here's v4. I'd like to request help for testing. I know Nicolas is doing that (thanks! and thanks for the reviews). But it would be great to get at least the nfs code tested. Olga, can you help here?Changes since v3
- dropped theCOPY_FILE_SPLICEflag
- kept the f_op's checks early ingeneric_copy_file_checks, implementing Amir's suggestions
- modified nfsd to usegeneric_copy_file_range()
Changes since v2
- do all the required checks earlier, ingeneric_copy_file_checks(), adding new checks for ->remap_file_range
- newCOPY_FILE_SPLICEflag
- don't remove filesystem's fallback togeneric_copy_file_range()
- updated commit changelog (and subject)
Changes since v1 (after Amir review)
- restoreddo_copy_file_range()helper
- return-EOPNOTSUPPif fs doesn't implement CFR
- updated commit descriptionfs/nfsd/vfs.c | 2 +- fs/read_write.c | 50 +++++++++++++++++++++++-------------------------- 2 files changed, 24 insertions(+), 28 deletions(-)fs/nfsd/vfs.c +0
-0
fs/nfsd/vfs.c ssize_t nfsd_copy_file_range(struct file *src, u64 src_pos, struct file *dst, · line 581
Quoted 5 lines
fs/nfsd/vfs.c +1
-1@@ -578,7 +578,7 @@ ssize_t nfsd_copy_file_range(struct file *src, u64 src_pos, struct file *dst,* limit like this and pipeline multiple COPY requests. */ count =min_t (u64, count,1 <<22 ); -return vfs_copy_file_range (src, src_pos, dst, dst_pos, count,0 ); +return generic_copy_file_range (src, src_pos, dst, dst_pos, count,0 );
That is not the desired change.
It should try vfs_copy_file_range() and fallback to generic_copy_file_range() for EXDEV and EOPNOTSUPP.
I will explain why.
This code runs on nfs server.
The nfs client requested remote server side copy offload using nfs4_copy_file_range() and remote request is handled here.
It is not enough to generic_copy_file_range() on the server because the source and destination themselves can be on yet another remote location (cifs/ceph/nfs), so this is why calling vfs_copy_file_range() here is important.
At least that is my understanding.
Unlike userspace copy fallback, if the server returns -EXDEV the client will need to transfer the data over the network.
That is why the generic_copy_file_range() fallback is important.
Quoted 73 lines
fs/nfsd/vfs.c +0
-0} __be32 nfsd4_vfs_fallocate(struct svc_rqst *rqstp, struct svc_fh *fhp,fs/read_write.c +20
-24@@ -1388,28 +1388,6 @@ ssize_t generic_copy_file_range(struct file *file_in, loff_t pos_in, }EXPORT_SYMBOL (generic_copy_file_range); -static ssize_t do_copy_file_range (struct file *file_in,loff_t pos_in, -struct file *file_out,loff_t pos_out, -size_t len,unsigned int flags) -{ -/* -* Although we now allow filesystems to handle cross sb copy, passing -* a file of the wrong filesystem type to filesystem driver can result -* in an attempt to dereference the wrong type of ->private_data, so -* avoid doing that until we really have a good reason. NFS defines -* several different file_system_type structures, but they all end up -* using the same ->copy_file_range() function pointer. -*/ -if (file_out->f_op->copy_file_range && - file_out->f_op->copy_file_range == file_in->f_op->copy_file_range) -return file_out->f_op->copy_file_range (file_in, pos_in, - file_out, pos_out, - len, flags); - -return generic_copy_file_range (file_in, pos_in, file_out, pos_out, len, - flags); -} -/* * Performs necessary checks before doing a file copy * @@ -1427,6 +1405,25 @@ static int generic_copy_file_checks(struct file *file_in, loff_t pos_in,loff_t size_in;int ret; +/* +* Although we now allow filesystems to handle cross sb copy, passing +* a file of the wrong filesystem type to filesystem driver can result +* in an attempt to dereference the wrong type of ->private_data, so +* avoid doing that until we really have a good reason. NFS defines +* several different file_system_type structures, but they all end up +* using the same ->copy_file_range() function pointer. +*/ +if (file_out->f_op->copy_file_range) { +if (file_in->f_op->copy_file_range != + file_out->f_op->copy_file_range) +return -EXDEV ; + }else if (file_in->f_op->remap_file_range) { +if (file_inode (file_in)->i_sb !=file_inode (file_out)->i_sb) +return -EXDEV ; + }else { +return -EOPNOTSUPP ; + } + ret =generic_file_rw_checks (file_in, file_out);if (ret)return ret;@@ -1499,8 +1496,7 @@ ssize_t vfs_copy_file_range(struct file *file_in, loff_t pos_in,* Try cloning first, this is supported by more file systems, and * more efficient if both clone and copy are supported (e.g. NFS). */ -if (file_in->f_op->remap_file_range && -file_inode (file_in)->i_sb ==file_inode (file_out)->i_sb) { +if (file_in->f_op->remap_file_range) {loff_t cloned; cloned = file_in->f_op->remap_file_range(file_in, pos_in,
fs/read_write.c ssize_t vfs_copy_file_range(struct file *file_in, loff_t pos_in, · line 1514
Quoted 9 lines
fs/read_write.c +3
-3@@ -1513,9 +1509,9 @@ ssize_t vfs_copy_file_range(struct file *file_in, loff_t pos_in, } } - ret =do_copy_file_range (file_in, pos_in, file_out, pos_out, len, - flags); -WARN_ON_ONCE (ret == -EOPNOTSUPP ); + ret = file_out->f_op->copy_file_range (file_in, pos_in, + file_out, pos_out, + len, flags);
I see you have made an assumption here that if we did not clone then file_out->f_op->copy_file_range must be valid.
It is not true.file_out->f_op->copy_file_range could be NULL and we got here becauses remap_file_range was attempted and failed.
So you still need to check for non-NULL file_out->f_op->copy_file_range here just like it was before the regressing commit.
Otherwise, looks ok to me, but without NFS testing we won't know for sure It's a tricky one...
Thanks,
Amir.
PATCH v5 1/1 vfs: fix copy_file_range regression in cross-fs copies
A regression has been reported by Nicolas Boichat, found while using the copy_file_range syscall to copy a tracefs file. Before commit 5dae222a5ff0 ("vfs: allow copy_file_range to copy across devices") the kernel would return -EXDEV to userspace when trying to copy a file across different filesystems. After this commit, the syscall doesn't fail anymore and instead returns zero (zero bytes copied), as this file's content is generated on-the-fly and thus reports a size of zero.
This patch restores some cross-filesystem copy restrictions that existed prior to commit 5dae222a5ff0 ("vfs: allow copy_file_range to copy across devices"). Filesystems are still allowed to fall-back to the VFS generic_copy_file_range() implementation, but that has now to be done explicitly.
nfsd is also modified to fall-back into generic_copy_file_range() in case vfs_copy_file_range() fails with -EOPNOTSUPP or -EXDEV.
---
And v5! Sorry. Sure, it makes sense to go through the all the vfs_cfr() checks first.
Again, here's my request for testing.
Changes since v4
- nfsd falls-back to generic_copy_file_range() only *if* it gets -EOPNOTSUPP or -EXDEV.
Changes since v3
- dropped the COPY_FILE_SPLICE flag
- kept the f_op's checks early in generic_copy_file_checks, implementing Amir's suggestions
- modified nfsd to use generic_copy_file_range()
Changes since v2
- do all the required checks earlier, in generic_copy_file_checks(), adding new checks for ->remap_file_range
- new COPY_FILE_SPLICE flag
- don't remove filesystem's fallback to generic_copy_file_range()
- updated commit changelog (and subject)
Changes since v1 (after Amir review)
- restored do_copy_file_range() helper
- return -EOPNOTSUPP if fs doesn't implement CFR
- updated commit description
fs/nfsd/vfs.c | 8 +++++++- fs/read_write.c | 50 +++++++++++++++++++++++-------------------------- 2 files changed, 30 insertions(+), 28 deletions(-)
fs/nfsd/vfs.c +7 -1
@@ -568,6 +568,7 @@ __be32 nfsd4_clone_file_range(struct nfsd_file *nf_src, u64 src_pos,ssize_t nfsd_copy_file_range (struct file *src,u64 src_pos,struct file *dst,u64 dst_pos,u64 count) { +ssize_t ret;/* * Limit copy to 4MB to prevent indefinitely blocking an nfsd
@@ -578,7 +579,12 @@ ssize_t nfsd_copy_file_range(struct file *src, u64 src_pos, struct file *dst,* limit like this and pipeline multiple COPY requests. */ count =min_t (u64, count,1 <<22 ); -return vfs_copy_file_range (src, src_pos, dst, dst_pos, count,0 ); + ret =vfs_copy_file_range (src, src_pos, dst, dst_pos, count,0 ); + +if (ret == -EOPNOTSUPP || ret == -EXDEV ) + ret =generic_copy_file_range (src, src_pos, dst, dst_pos, + count,0 ); +return ret; } __be32 nfsd4_vfs_fallocate(struct svc_rqst *rqstp, struct svc_fh *fhp,
fs/read_write.c +23 -27
74 lines not on this page · raw message
Re: [PATCH v5] vfs: fix copy_file_range regression in cross-fs copies
Quoted 24 lines · Luis Henriques
A regression has been reported by Nicolas Boichat, found while using the
copy_file_rangesyscall to copy a tracefs file. Before commit5dae222a5ff0("vfs: allowcopy_file_rangeto copy across devices") the kernel would return-EXDEVto userspace when trying to copy a file across different filesystems. After this commit, the syscall doesn't fail anymore and instead returns zero (zero bytes copied), as this file's content is generated on-the-fly and thus reports a size of zero.This patch restores some cross-filesystem copy restrictions that existed prior to commit
5dae222a5ff0("vfs: allowcopy_file_rangeto copy across devices"). Filesystems are still allowed to fall-back to the VFSgeneric_copy_file_range()implementation, but that has now to be done explicitly.nfsd is also modified to fall-back into
generic_copy_file_range()in casevfs_copy_file_range()fails with-EOPNOTSUPPor-EXDEV.Fixes 5dae222a5ff0 ("vfs: allow copy_file_range to copy across devices")Link https://lore.kernel.org/linux-fsdevel/CANMq1KDZuxir2LM5jOTm0xx+BnvW=ZmpsG47CyHFJwnw7zSX6Q@mail.gmail.com/ open hereLink https://lore.kernel.org/linux-fsdevel/20210126135012.1.If45b7cdc3ff707bc1efa17f5366057d60603c45f@changeid/ open hereReported-by Nicolas Boichat <[email protected]>Signed-off-by Luis Henriques <[email protected]>
Quoted 3 lines
---
And v5! Sorry. Sure, it makes sense to go through the all thevfs_cfr()checks first.
You missed my other comment on v4...
not checking NULL copy_file_range case.
Thanks,
Amir.
Re: [PATCH v5] vfs: fix copy_file_range regression in cross-fs copies
Quoted 29 lines · Amir Goldstein
Quoted 24 lines · Luis Henriques
A regression has been reported by Nicolas Boichat, found while using the
copy_file_rangesyscall to copy a tracefs file. Before commit5dae222a5ff0("vfs: allowcopy_file_rangeto copy across devices") the kernel would return-EXDEVto userspace when trying to copy a file across different filesystems. After this commit, the syscall doesn't fail anymore and instead returns zero (zero bytes copied), as this file's content is generated on-the-fly and thus reports a size of zero.This patch restores some cross-filesystem copy restrictions that existed prior to commit
5dae222a5ff0("vfs: allowcopy_file_rangeto copy across devices"). Filesystems are still allowed to fall-back to the VFSgeneric_copy_file_range()implementation, but that has now to be done explicitly.nfsd is also modified to fall-back into
generic_copy_file_range()in casevfs_copy_file_range()fails with-EOPNOTSUPPor-EXDEV.Fixes 5dae222a5ff0 ("vfs: allow copy_file_range to copy across devices")Link https://lore.kernel.org/linux-fsdevel/CANMq1KDZuxir2LM5jOTm0xx+BnvW=ZmpsG47CyHFJwnw7zSX6Q@mail.gmail.com/ open hereLink https://lore.kernel.org/linux-fsdevel/20210126135012.1.If45b7cdc3ff707bc1efa17f5366057d60603c45f@changeid/ open hereReported-by Nicolas Boichat <[email protected]>Signed-off-by Luis Henriques <[email protected]>Quoted 3 lines
---
And v5! Sorry. Sure, it makes sense to go through the all thevfs_cfr()checks first.
Quoted 3 lines
You missed my other comment on v4...
not checking NULL
copy_file_rangecase.
Ah, yeah I did missed it. I'll follow up with yet another revision.
Cheers,
Signature · 1 line
Luis
PATCH v6 1/1 vfs: fix copy_file_range regression in cross-fs copies
A regression has been reported by Nicolas Boichat, found while using the copy_file_range syscall to copy a tracefs file. Before commit 5dae222a5ff0 ("vfs: allow copy_file_range to copy across devices") the kernel would return -EXDEV to userspace when trying to copy a file across different filesystems. After this commit, the syscall doesn't fail anymore and instead returns zero (zero bytes copied), as this file's content is generated on-the-fly and thus reports a size of zero.
This patch restores some cross-filesystem copy restrictions that existed prior to commit 5dae222a5ff0 ("vfs: allow copy_file_range to copy across devices"). Filesystems are still allowed to fall-back to the VFS generic_copy_file_range() implementation, but that has now to be done explicitly.
nfsd is also modified to fall-back into generic_copy_file_range() in case vfs_copy_file_range() fails with -EOPNOTSUPP or -EXDEV.
---
And v6 is upon us. Behold!
Changes since v5
- check if ->copy_file_range is NULL before calling it
Changes since v4
- nfsd falls-back to generic_copy_file_range() only *if* it gets -EOPNOTSUPP or -EXDEV.
Changes since v3
- dropped the COPY_FILE_SPLICE flag
- kept the f_op's checks early in generic_copy_file_checks, implementing Amir's suggestions
- modified nfsd to use generic_copy_file_range()
Changes since v2
- do all the required checks earlier, in generic_copy_file_checks(), adding new checks for ->remap_file_range
- new COPY_FILE_SPLICE flag
- don't remove filesystem's fallback to generic_copy_file_range()
- updated commit changelog (and subject)
Changes since v1 (after Amir review)
- restored do_copy_file_range() helper
- return -EOPNOTSUPP if fs doesn't implement CFR
- updated commit description
fs/nfsd/vfs.c | 8 +++++++- fs/read_write.c | 53 ++++++++++++++++++++++++------------------------- 2 files changed, 33 insertions(+), 28 deletions(-)
fs/nfsd/vfs.c +7 -1
@@ -568,6 +568,7 @@ __be32 nfsd4_clone_file_range(struct nfsd_file *nf_src, u64 src_pos,ssize_t nfsd_copy_file_range (struct file *src,u64 src_pos,struct file *dst,u64 dst_pos,u64 count) { +ssize_t ret;/* * Limit copy to 4MB to prevent indefinitely blocking an nfsd
@@ -578,7 +579,12 @@ ssize_t nfsd_copy_file_range(struct file *src, u64 src_pos, struct file *dst,* limit like this and pipeline multiple COPY requests. */ count =min_t (u64, count,1 <<22 ); -return vfs_copy_file_range (src, src_pos, dst, dst_pos, count,0 ); + ret =vfs_copy_file_range (src, src_pos, dst, dst_pos, count,0 ); + +if (ret == -EOPNOTSUPP || ret == -EXDEV ) + ret =generic_copy_file_range (src, src_pos, dst, dst_pos, + count,0 ); +return ret; } __be32 nfsd4_vfs_fallocate(struct svc_rqst *rqstp, struct svc_fh *fhp,
fs/read_write.c +26 -27
79 lines not on this page · raw message
Re: [PATCH v6] vfs: fix copy_file_range regression in cross-fs copies
Quoted 139 lines · Luis Henriques
A regression has been reported by Nicolas Boichat, found while using the
copy_file_rangesyscall to copy a tracefs file. Before commit5dae222a5ff0("vfs: allowcopy_file_rangeto copy across devices") the kernel would return-EXDEVto userspace when trying to copy a file across different filesystems. After this commit, the syscall doesn't fail anymore and instead returns zero (zero bytes copied), as this file's content is generated on-the-fly and thus reports a size of zero.This patch restores some cross-filesystem copy restrictions that existed prior to commit
5dae222a5ff0("vfs: allowcopy_file_rangeto copy across devices"). Filesystems are still allowed to fall-back to the VFSgeneric_copy_file_range()implementation, but that has now to be done explicitly.nfsd is also modified to fall-back into
generic_copy_file_range()in casevfs_copy_file_range()fails with-EOPNOTSUPPor-EXDEV.Fixes 5dae222a5ff0 ("vfs: allow copy_file_range to copy across devices")Link https://lore.kernel.org/linux-fsdevel/CANMq1KDZuxir2LM5jOTm0xx+BnvW=ZmpsG47CyHFJwnw7zSX6Q@mail.gmail.com/ open hereLink https://lore.kernel.org/linux-fsdevel/20210126135012.1.If45b7cdc3ff707bc1efa17f5366057d60603c45f@changeid/ open hereReported-by Nicolas Boichat <[email protected]>Signed-off-by Luis Henriques <[email protected]>---
And v6 is upon us. Behold!Changes since v5
- check if ->copy_file_range is NULL before calling it
Changes since v4
- nfsd falls-back togeneric_copy_file_range()only *if* it gets-EOPNOTSUPPor-EXDEV.
Changes since v3
- dropped theCOPY_FILE_SPLICEflag
- kept the f_op's checks early ingeneric_copy_file_checks, implementing Amir's suggestions
- modified nfsd to usegeneric_copy_file_range()
Changes since v2
- do all the required checks earlier, ingeneric_copy_file_checks(), adding new checks for ->remap_file_range
- newCOPY_FILE_SPLICEflag
- don't remove filesystem's fallback togeneric_copy_file_range()
- updated commit changelog (and subject)
Changes since v1 (after Amir review)
- restoreddo_copy_file_range()helper
- return-EOPNOTSUPPif fs doesn't implement CFR
- updated commit descriptionfs/nfsd/vfs.c | 8 +++++++- fs/read_write.c | 53 ++++++++++++++++++++++++------------------------- 2 files changed, 33 insertions(+), 28 deletions(-)fs/nfsd/vfs.c +7
-1@@ -568,6 +568,7 @@ __be32 nfsd4_clone_file_range(struct nfsd_file *nf_src, u64 src_pos,ssize_t nfsd_copy_file_range (struct file *src,u64 src_pos,struct file *dst,u64 dst_pos,u64 count) { +ssize_t ret;/* * Limit copy to 4MB to prevent indefinitely blocking an nfsd @@ -578,7 +579,12 @@ ssize_t nfsd_copy_file_range(struct file *src, u64 src_pos, struct file *dst,* limit like this and pipeline multiple COPY requests. */ count =min_t (u64, count,1 <<22 ); -return vfs_copy_file_range (src, src_pos, dst, dst_pos, count,0 ); + ret =vfs_copy_file_range (src, src_pos, dst, dst_pos, count,0 ); + +if (ret == -EOPNOTSUPP || ret == -EXDEV ) + ret =generic_copy_file_range (src, src_pos, dst, dst_pos, + count,0 ); +return ret; } __be32 nfsd4_vfs_fallocate(struct svc_rqst *rqstp, struct svc_fh *fhp,fs/read_write.c +19
-22@@ -1388,28 +1388,6 @@ ssize_t generic_copy_file_range(struct file *file_in, loff_t pos_in, }EXPORT_SYMBOL (generic_copy_file_range); -static ssize_t do_copy_file_range (struct file *file_in,loff_t pos_in, -struct file *file_out,loff_t pos_out, -size_t len,unsigned int flags) -{ -/* -* Although we now allow filesystems to handle cross sb copy, passing -* a file of the wrong filesystem type to filesystem driver can result -* in an attempt to dereference the wrong type of ->private_data, so -* avoid doing that until we really have a good reason. NFS defines -* several different file_system_type structures, but they all end up -* using the same ->copy_file_range() function pointer. -*/ -if (file_out->f_op->copy_file_range && - file_out->f_op->copy_file_range == file_in->f_op->copy_file_range) -return file_out->f_op->copy_file_range (file_in, pos_in, - file_out, pos_out, - len, flags); - -return generic_copy_file_range (file_in, pos_in, file_out, pos_out, len, - flags); -} -/* * Performs necessary checks before doing a file copy * @@ -1427,6 +1405,25 @@ static int generic_copy_file_checks(struct file *file_in, loff_t pos_in,loff_t size_in;int ret; +/* +* Although we now allow filesystems to handle cross sb copy, passing +* a file of the wrong filesystem type to filesystem driver can result +* in an attempt to dereference the wrong type of ->private_data, so +* avoid doing that until we really have a good reason. NFS defines +* several different file_system_type structures, but they all end up +* using the same ->copy_file_range() function pointer. +*/ +if (file_out->f_op->copy_file_range) { +if (file_in->f_op->copy_file_range != + file_out->f_op->copy_file_range) +return -EXDEV ; + }else if (file_in->f_op->remap_file_range) { +if (file_inode (file_in)->i_sb !=file_inode (file_out)->i_sb) +return -EXDEV ; + }else { +return -EOPNOTSUPP ; + } + ret =generic_file_rw_checks (file_in, file_out);if (ret)return ret;
fs/read_write.c ssize_t vfs_copy_file_range(struct file *file_in, loff_t pos_in, · line 1500
Quoted 7 lines
fs/read_write.c +1
-2@@ -1499,8 +1496,7 @@ ssize_t vfs_copy_file_range(struct file *file_in, loff_t pos_in,* Try cloning first, this is supported by more file systems, and * more efficient if both clone and copy are supported (e.g. NFS). */ -if (file_in->f_op->remap_file_range && -file_inode (file_in)->i_sb ==file_inode (file_out)->i_sb) { +if (file_in->f_op->remap_file_range) {loff_t cloned;
This chunk breaks NFS. You are removing the check that the source and destination for the CLONE operation are the same superblock and that leads to the fact that when NFS does a copy between 2 different NFS servers, it would try CLONE first which is not allowed. NFS relied on this check to be done by the VFS layer. Either don't remove it or, otherwise, fix the NFS clone's code to not send the CLONE and error accordingly so that the COPY is done as it should have been.
Quoted 19 lines
fs/read_write.c +6
-3cloned = file_in->f_op->remap_file_range(file_in, pos_in,@@ -1511,11 +1507,14 @@ ssize_t vfs_copy_file_range(struct file *file_in, loff_t pos_in, ret = cloned; goto done; } +/* Resort to copy_file_range if implemented. */ + ret = -EOPNOTSUPP ; } - ret =do_copy_file_range (file_in, pos_in, file_out, pos_out, len, - flags); -WARN_ON_ONCE (ret == -EOPNOTSUPP ); +if (file_out->f_op->copy_file_range) + ret = file_out->f_op->copy_file_range (file_in, pos_in, + file_out, pos_out, + len, flags); done:if (ret >0 ) {fsnotify_access (file_in);
Re: [PATCH v6] vfs: fix copy_file_range regression in cross-fs copies
Quoted 149 lines · Olga Kornievskaia
Quoted 139 lines · Luis Henriques
A regression has been reported by Nicolas Boichat, found while using the
copy_file_rangesyscall to copy a tracefs file. Before commit5dae222a5ff0("vfs: allowcopy_file_rangeto copy across devices") the kernel would return-EXDEVto userspace when trying to copy a file across different filesystems. After this commit, the syscall doesn't fail anymore and instead returns zero (zero bytes copied), as this file's content is generated on-the-fly and thus reports a size of zero.This patch restores some cross-filesystem copy restrictions that existed prior to commit
5dae222a5ff0("vfs: allowcopy_file_rangeto copy across devices"). Filesystems are still allowed to fall-back to the VFSgeneric_copy_file_range()implementation, but that has now to be done explicitly.nfsd is also modified to fall-back into
generic_copy_file_range()in casevfs_copy_file_range()fails with-EOPNOTSUPPor-EXDEV.Fixes 5dae222a5ff0 ("vfs: allow copy_file_range to copy across devices")Link https://lore.kernel.org/linux-fsdevel/CANMq1KDZuxir2LM5jOTm0xx+BnvW=ZmpsG47CyHFJwnw7zSX6Q@mail.gmail.com/ open hereLink https://lore.kernel.org/linux-fsdevel/20210126135012.1.If45b7cdc3ff707bc1efa17f5366057d60603c45f@changeid/ open hereReported-by Nicolas Boichat <[email protected]>Signed-off-by Luis Henriques <[email protected]>---
And v6 is upon us. Behold!Changes since v5
- check if ->copy_file_range is NULL before calling it
Changes since v4
- nfsd falls-back togeneric_copy_file_range()only *if* it gets-EOPNOTSUPPor-EXDEV.
Changes since v3
- dropped theCOPY_FILE_SPLICEflag
- kept the f_op's checks early ingeneric_copy_file_checks, implementing Amir's suggestions
- modified nfsd to usegeneric_copy_file_range()
Changes since v2
- do all the required checks earlier, ingeneric_copy_file_checks(), adding new checks for ->remap_file_range
- newCOPY_FILE_SPLICEflag
- don't remove filesystem's fallback togeneric_copy_file_range()
- updated commit changelog (and subject)
Changes since v1 (after Amir review)
- restoreddo_copy_file_range()helper
- return-EOPNOTSUPPif fs doesn't implement CFR
- updated commit descriptionfs/nfsd/vfs.c | 8 +++++++- fs/read_write.c | 53 ++++++++++++++++++++++++------------------------- 2 files changed, 33 insertions(+), 28 deletions(-)fs/nfsd/vfs.c +7
-1@@ -568,6 +568,7 @@ __be32 nfsd4_clone_file_range(struct nfsd_file *nf_src, u64 src_pos,ssize_t nfsd_copy_file_range (struct file *src,u64 src_pos,struct file *dst,u64 dst_pos,u64 count) { +ssize_t ret;/* * Limit copy to 4MB to prevent indefinitely blocking an nfsd @@ -578,7 +579,12 @@ ssize_t nfsd_copy_file_range(struct file *src, u64 src_pos, struct file *dst,* limit like this and pipeline multiple COPY requests. */ count =min_t (u64, count,1 <<22 ); -return vfs_copy_file_range (src, src_pos, dst, dst_pos, count,0 ); + ret =vfs_copy_file_range (src, src_pos, dst, dst_pos, count,0 ); + +if (ret == -EOPNOTSUPP || ret == -EXDEV ) + ret =generic_copy_file_range (src, src_pos, dst, dst_pos, + count,0 ); +return ret; } __be32 nfsd4_vfs_fallocate(struct svc_rqst *rqstp, struct svc_fh *fhp,fs/read_write.c +19
-22@@ -1388,28 +1388,6 @@ ssize_t generic_copy_file_range(struct file *file_in, loff_t pos_in, }EXPORT_SYMBOL (generic_copy_file_range); -static ssize_t do_copy_file_range (struct file *file_in,loff_t pos_in, -struct file *file_out,loff_t pos_out, -size_t len,unsigned int flags) -{ -/* -* Although we now allow filesystems to handle cross sb copy, passing -* a file of the wrong filesystem type to filesystem driver can result -* in an attempt to dereference the wrong type of ->private_data, so -* avoid doing that until we really have a good reason. NFS defines -* several different file_system_type structures, but they all end up -* using the same ->copy_file_range() function pointer. -*/ -if (file_out->f_op->copy_file_range && - file_out->f_op->copy_file_range == file_in->f_op->copy_file_range) -return file_out->f_op->copy_file_range (file_in, pos_in, - file_out, pos_out, - len, flags); - -return generic_copy_file_range (file_in, pos_in, file_out, pos_out, len, - flags); -} -/* * Performs necessary checks before doing a file copy * @@ -1427,6 +1405,25 @@ static int generic_copy_file_checks(struct file *file_in, loff_t pos_in,loff_t size_in;int ret; +/* +* Although we now allow filesystems to handle cross sb copy, passing +* a file of the wrong filesystem type to filesystem driver can result +* in an attempt to dereference the wrong type of ->private_data, so +* avoid doing that until we really have a good reason. NFS defines +* several different file_system_type structures, but they all end up +* using the same ->copy_file_range() function pointer. +*/ +if (file_out->f_op->copy_file_range) { +if (file_in->f_op->copy_file_range != + file_out->f_op->copy_file_range) +return -EXDEV ; + }else if (file_in->f_op->remap_file_range) { +if (file_inode (file_in)->i_sb !=file_inode (file_out)->i_sb) +return -EXDEV ; + }else { +return -EOPNOTSUPP ; + } + ret =generic_file_rw_checks (file_in, file_out);if (ret)return ret;fs/read_write.c ssize_t vfs_copy_file_range(struct file *file_in, loff_t pos_in, · line 1500
Quoted 7 lines
fs/read_write.c +1
-2@@ -1499,8 +1496,7 @@ ssize_t vfs_copy_file_range(struct file *file_in, loff_t pos_in,* Try cloning first, this is supported by more file systems, and * more efficient if both clone and copy are supported (e.g. NFS). */ -if (file_in->f_op->remap_file_range && -file_inode (file_in)->i_sb ==file_inode (file_out)->i_sb) { +if (file_in->f_op->remap_file_range) {loff_t cloned;
Quoted 8 lines
This chunk breaks NFS. You are removing the check that the source and destination for the CLONE operation are the same superblock and that leads to the fact that when NFS does a copy between 2 different NFS servers, it would try CLONE first which is not allowed. NFS relied on this check to be done by the VFS layer. Either don't remove it or, otherwise, fix the NFS clone's code to not send the CLONE and error accordingly so that the COPY is done as it should have been.
Right, we need to add this check back (not only for NFS).
However, I was looking at the change that introduced this opportunistic call for clone_file_range() into copy_file_range():
commit a76b5b04375f974579c83433b06466758c0c552c
Author: Christoph Hellwig <[email protected]> Date: Fri Dec 9 16:17:19 2016 -0800
fs: try to clone files first in vfs_copy_file_range
A clone is a perfectly fine implementation of a file copy, so most file systems just implement the copy that way. Instead of duplicating this logic move it to the VFS. Currently btrfs and XFS implement copies the same way as clones and there is no behavior change for them, cifs only implements clones and grow support for copy_file_range with this patch. NFS implements both, so this will allow copy_file_range to work on servers that only implement CLONE and be lot more efficient on servers that implements CLONE and COPY.
And I was thinking to myself that like the change that brought us here ("vfs: allow copy_file_range to copy across devices"), this change was done for a certain purpose (serve copy_file_range() by fs that implement CLONE), but that last part (prefer CLONE over COPY) also sounds like an optimization that nobody asked for and could lead to unexpected behavior down the road.
I think that if a filesystem implements both methods (COPY and CLONE) and user called to COPY API, we need to call the more specialized COPY method and not try the CLONE method, because filesystem should be very capable of making this optimization internally.
This could have been a hypothetical question, but there are actually two filesystems that implement both COPY and CLONE, so let's ask the developers what they think VFS should call.
Olga, Trond, Steve, which methods of your filesystem do you think that vfs_copy_file_range() should call?
1. Only copy_file_range()?
2. Both copy_file_range() and remap_file_range()?
3. CLONE before COPY or the other way around?
Thanks,
Amir.
PATCH v7 1/1 vfs: fix copy_file_range regression in cross-fs copies
In reply to Olga KornievskaiaA regression has been reported by Nicolas Boichat, found while using the copy_file_range syscall to copy a tracefs file. Before commit 5dae222a5ff0 ("vfs: allow copy_file_range to copy across devices") the kernel would return -EXDEV to userspace when trying to copy a file across different filesystems. After this commit, the syscall doesn't fail anymore and instead returns zero (zero bytes copied), as this file's content is generated on-the-fly and thus reports a size of zero.
This patch restores some cross-filesystem copy restrictions that existed prior to commit 5dae222a5ff0 ("vfs: allow copy_file_range to copy across devices"). Filesystems are still allowed to fall-back to the VFS generic_copy_file_range() implementation, but that has now to be done explicitly.
nfsd is also modified to fall-back into generic_copy_file_range() in case vfs_copy_file_range() fails with -EOPNOTSUPP or -EXDEV.
---
Changes since v6
- restored i_sb checks for the clone operation
Changes since v5
- check if ->copy_file_range is NULL before calling it
Changes since v4
- nfsd falls-back to generic_copy_file_range() only *if* it gets -EOPNOTSUPP or -EXDEV.
Changes since v3
- dropped the COPY_FILE_SPLICE flag
- kept the f_op's checks early in generic_copy_file_checks, implementing Amir's suggestions
- modified nfsd to use generic_copy_file_range()
Changes since v2
- do all the required checks earlier, in generic_copy_file_checks(), adding new checks for ->remap_file_range
- new COPY_FILE_SPLICE flag
- don't remove filesystem's fallback to generic_copy_file_range()
- updated commit changelog (and subject)
Changes since v1 (after Amir review)
- restored do_copy_file_range() helper
- return -EOPNOTSUPP if fs doesn't implement CFR
- updated commit description
fs/nfsd/vfs.c | 8 +++++++- fs/read_write.c | 50 ++++++++++++++++++++++++------------------------- 2 files changed, 32 insertions(+), 26 deletions(-)
fs/nfsd/vfs.c +7 -1
@@ -568,6 +568,7 @@ __be32 nfsd4_clone_file_range(struct nfsd_file *nf_src, u64 src_pos,ssize_t nfsd_copy_file_range (struct file *src,u64 src_pos,struct file *dst,u64 dst_pos,u64 count) { +ssize_t ret;/* * Limit copy to 4MB to prevent indefinitely blocking an nfsd
@@ -578,7 +579,12 @@ ssize_t nfsd_copy_file_range(struct file *src, u64 src_pos, struct file *dst,* limit like this and pipeline multiple COPY requests. */ count =min_t (u64, count,1 <<22 ); -return vfs_copy_file_range (src, src_pos, dst, dst_pos, count,0 ); + ret =vfs_copy_file_range (src, src_pos, dst, dst_pos, count,0 ); + +if (ret == -EOPNOTSUPP || ret == -EXDEV ) + ret =generic_copy_file_range (src, src_pos, dst, dst_pos, + count,0 ); +return ret; } __be32 nfsd4_vfs_fallocate(struct svc_rqst *rqstp, struct svc_fh *fhp,
fs/read_write.c +25 -25
70 lines not on this page · raw message
Re: [PATCH v7] vfs: fix copy_file_range regression in cross-fs copies
Quoted 15 lines · Luis Henriques
A regression has been reported by Nicolas Boichat, found while using the
copy_file_rangesyscall to copy a tracefs file. Before commit5dae222a5ff0("vfs: allowcopy_file_rangeto copy across devices") the kernel would return-EXDEVto userspace when trying to copy a file across different filesystems. After this commit, the syscall doesn't fail anymore and instead returns zero (zero bytes copied), as this file's content is generated on-the-fly and thus reports a size of zero.This patch restores some cross-filesystem copy restrictions that existed prior to commit
5dae222a5ff0("vfs: allowcopy_file_rangeto copy across devices"). Filesystems are still allowed to fall-back to the VFSgeneric_copy_file_range()implementation, but that has now to be done explicitly.
Quoted 8 lines
nfsd is also modified to fall-back into
generic_copy_file_range()in casevfs_copy_file_range()fails with-EOPNOTSUPPor-EXDEV.Fixes 5dae222a5ff0 ("vfs: allow copy_file_range to copy across devices")Link https://lore.kernel.org/linux-fsdevel/CANMq1KDZuxir2LM5jOTm0xx+BnvW=ZmpsG47CyHFJwnw7zSX6Q@mail.gmail.com/ open hereLink https://lore.kernel.org/linux-fsdevel/20210126135012.1.If45b7cdc3ff707bc1efa17f5366057d60603c45f@changeid/ open hereReported-by Nicolas Boichat <[email protected]>
Quoted 29 lines
Signed-off-by Luis Henriques <[email protected]>---
Changes since v6
- restoredi_sbchecks for the clone operation
Changes since v5
- check if ->copy_file_range is NULL before calling it
Changes since v4
- nfsd falls-back togeneric_copy_file_range()only *if* it gets-EOPNOTSUPPor-EXDEV.
Changes since v3
- dropped theCOPY_FILE_SPLICEflag
- kept the f_op's checks early ingeneric_copy_file_checks, implementing Amir's suggestions
- modified nfsd to usegeneric_copy_file_range()
Changes since v2
- do all the required checks earlier, ingeneric_copy_file_checks(), adding new checks for ->remap_file_range
- newCOPY_FILE_SPLICEflag
- don't remove filesystem's fallback togeneric_copy_file_range()
- updated commit changelog (and subject)
Changes since v1 (after Amir review)
- restoreddo_copy_file_range()helper
- return-EOPNOTSUPPif fs doesn't implement CFR
- updated commit descriptionfs/nfsd/vfs.c | 8 +++++++- fs/read_write.c | 50 ++++++++++++++++++++++++------------------------- 2 files changed, 32 insertions(+), 26 deletions(-)[snip]
PATCH v8 1/1 vfs: fix copy_file_range regression in cross-fs copies
In reply to Luis HenriquesA regression has been reported by Nicolas Boichat, found while using the copy_file_range syscall to copy a tracefs file. Before commit 5dae222a5ff0 ("vfs: allow copy_file_range to copy across devices") the kernel would return -EXDEV to userspace when trying to copy a file across different filesystems. After this commit, the syscall doesn't fail anymore and instead returns zero (zero bytes copied), as this file's content is generated on-the-fly and thus reports a size of zero.
This patch restores some cross-filesystem copy restrictions that existed prior to commit 5dae222a5ff0 ("vfs: allow copy_file_range to copy across devices"). Filesystems are still allowed to fall-back to the VFS generic_copy_file_range() implementation, but that has now to be done explicitly.
nfsd is also modified to fall-back into generic_copy_file_range() in case vfs_copy_file_range() fails with -EOPNOTSUPP or -EXDEV.
---
Changes since v7
- set 'ret' to '-EOPNOTSUPP' before the clone 'if' statement so that the error returned is always related to the 'copy' operation
Changes since v6
- restored i_sb checks for the clone operation
Changes since v5
- check if ->copy_file_range is NULL before calling it
Changes since v4
- nfsd falls-back to generic_copy_file_range() only *if* it gets -EOPNOTSUPP or -EXDEV.
Changes since v3
- dropped the COPY_FILE_SPLICE flag
- kept the f_op's checks early in generic_copy_file_checks, implementing Amir's suggestions
- modified nfsd to use generic_copy_file_range()
Changes since v2
- do all the required checks earlier, in generic_copy_file_checks(), adding new checks for ->remap_file_range
- new COPY_FILE_SPLICE flag
- don't remove filesystem's fallback to generic_copy_file_range()
- updated commit changelog (and subject)
Changes since v1 (after Amir review)
- restored do_copy_file_range() helper
- return -EOPNOTSUPP if fs doesn't implement CFR
- updated commit description
fs/nfsd/vfs.c | 8 +++++++- fs/read_write.c | 49 ++++++++++++++++++++++++------------------------- 2 files changed, 31 insertions(+), 26 deletions(-)
fs/nfsd/vfs.c +7 -1
@@ -568,6 +568,7 @@ __be32 nfsd4_clone_file_range(struct nfsd_file *nf_src, u64 src_pos,ssize_t nfsd_copy_file_range (struct file *src,u64 src_pos,struct file *dst,u64 dst_pos,u64 count) { +ssize_t ret;/* * Limit copy to 4MB to prevent indefinitely blocking an nfsd
@@ -578,7 +579,12 @@ ssize_t nfsd_copy_file_range(struct file *src, u64 src_pos, struct file *dst,* limit like this and pipeline multiple COPY requests. */ count =min_t (u64, count,1 <<22 ); -return vfs_copy_file_range (src, src_pos, dst, dst_pos, count,0 ); + ret =vfs_copy_file_range (src, src_pos, dst, dst_pos, count,0 ); + +if (ret == -EOPNOTSUPP || ret == -EXDEV ) + ret =generic_copy_file_range (src, src_pos, dst, dst_pos, + count,0 ); +return ret; } __be32 nfsd4_vfs_fallocate(struct svc_rqst *rqstp, struct svc_fh *fhp,
fs/read_write.c +24 -25
73 lines not on this page · raw message
Re: [PATCH v8] vfs: fix copy_file_range regression in cross-fs copies
Quoted 18 lines · Luis Henriques
A regression has been reported by Nicolas Boichat, found while using the
copy_file_rangesyscall to copy a tracefs file. Before commit5dae222a5ff0("vfs: allowcopy_file_rangeto copy across devices") the kernel would return-EXDEVto userspace when trying to copy a file across different filesystems. After this commit, the syscall doesn't fail anymore and instead returns zero (zero bytes copied), as this file's content is generated on-the-fly and thus reports a size of zero.This patch restores some cross-filesystem copy restrictions that existed prior to commit
5dae222a5ff0("vfs: allowcopy_file_rangeto copy across devices"). Filesystems are still allowed to fall-back to the VFSgeneric_copy_file_range()implementation, but that has now to be done explicitly.nfsd is also modified to fall-back into
generic_copy_file_range()in casevfs_copy_file_range()fails with-EOPNOTSUPPor-EXDEV.
Quoted 7 lines
Fixes 5dae222a5ff0 ("vfs: allow copy_file_range to copy across devices")Link https://lore.kernel.org/linux-fsdevel/CANMq1KDZuxir2LM5jOTm0xx+BnvW=ZmpsG47CyHFJwnw7zSX6Q@mail.gmail.com/ open hereLink https://lore.kernel.org/linux-fsdevel/20210126135012.1.If45b7cdc3ff707bc1efa17f5366057d60603c45f@changeid/ open hereReported-by Nicolas Boichat <[email protected]>Signed-off-by Luis Henriques <[email protected]>---
Thanks,
Amir.
[email protected]
reviewerRe: [PATCH v8] vfs: fix copy_file_range regression in cross-fs copies
In reply to Luis HenriquesQuoted 122 lines · Luis Henriques
A regression has been reported by Nicolas Boichat, found while using the
copy_file_rangesyscall to copy a tracefs file. Before commit5dae222a5ff0("vfs: allowcopy_file_rangeto copy across devices") the kernel would return-EXDEVto userspace when trying to copy a file across different filesystems. After this commit, the syscall doesn't fail anymore and instead returns zero (zero bytes copied), as this file's content is generated on-the-fly and thus reports a size of zero.This patch restores some cross-filesystem copy restrictions that existed prior to commit
5dae222a5ff0("vfs: allowcopy_file_rangeto copy across devices"). Filesystems are still allowed to fall-back to the VFSgeneric_copy_file_range()implementation, but that has now to be done explicitly.nfsd is also modified to fall-back into
generic_copy_file_range()in casevfs_copy_file_range()fails with-EOPNOTSUPPor-EXDEV.Fixes 5dae222a5ff0 ("vfs: allow copy_file_range to copy across devices")Reported-by Nicolas Boichat <[email protected]>Signed-off-by Luis Henriques <[email protected]>---
Changes since v7
- set 'ret' to '-EOPNOTSUPP' before the clone 'if' statement so that the error returned is always related to the 'copy' operation
Changes since v6
- restoredi_sbchecks for the clone operation
Changes since v5
- check if ->copy_file_range is NULL before calling it
Changes since v4
- nfsd falls-back togeneric_copy_file_range()only *if* it gets-EOPNOTSUPPor-EXDEV.
Changes since v3
- dropped theCOPY_FILE_SPLICEflag
- kept the f_op's checks early ingeneric_copy_file_checks, implementing Amir's suggestions
- modified nfsd to usegeneric_copy_file_range()
Changes since v2
- do all the required checks earlier, ingeneric_copy_file_checks(), adding new checks for ->remap_file_range
- newCOPY_FILE_SPLICEflag
- don't remove filesystem's fallback togeneric_copy_file_range()
- updated commit changelog (and subject)
Changes since v1 (after Amir review)
- restoreddo_copy_file_range()helper
- return-EOPNOTSUPPif fs doesn't implement CFR
- updated commit descriptionfs/nfsd/vfs.c | 8 +++++++- fs/read_write.c | 49 ++++++++++++++++++++++++------------------------- 2 files changed, 31 insertions(+), 26 deletions(-)fs/nfsd/vfs.c +7
-1@@ -568,6 +568,7 @@ __be32 nfsd4_clone_file_range(struct nfsd_file *nf_src, u64 src_pos,ssize_t nfsd_copy_file_range (struct file *src,u64 src_pos,struct file *dst,u64 dst_pos,u64 count) { +ssize_t ret;/* * Limit copy to 4MB to prevent indefinitely blocking an nfsd @@ -578,7 +579,12 @@ ssize_t nfsd_copy_file_range(struct file *src, u64 src_pos, struct file *dst,* limit like this and pipeline multiple COPY requests. */ count =min_t (u64, count,1 <<22 ); -return vfs_copy_file_range (src, src_pos, dst, dst_pos, count,0 ); + ret =vfs_copy_file_range (src, src_pos, dst, dst_pos, count,0 ); + +if (ret == -EOPNOTSUPP || ret == -EXDEV ) + ret =generic_copy_file_range (src, src_pos, dst, dst_pos, + count,0 ); +return ret; } __be32 nfsd4_vfs_fallocate(struct svc_rqst *rqstp, struct svc_fh *fhp,fs/read_write.c +5
-22@@ -1388,28 +1388,6 @@ ssize_t generic_copy_file_range(struct file *file_in, loff_t pos_in, }EXPORT_SYMBOL (generic_copy_file_range); -static ssize_t do_copy_file_range (struct file *file_in,loff_t pos_in, -struct file *file_out,loff_t pos_out, -size_t len,unsigned int flags) -{ -/* -* Although we now allow filesystems to handle cross sb copy, passing -* a file of the wrong filesystem type to filesystem driver can result -* in an attempt to dereference the wrong type of ->private_data, so -* avoid doing that until we really have a good reason. NFS defines -* several different file_system_type structures, but they all end up -* using the same ->copy_file_range() function pointer. -*/ -if (file_out->f_op->copy_file_range && - file_out->f_op->copy_file_range == file_in->f_op->copy_file_range) -return file_out->f_op->copy_file_range (file_in, pos_in, - file_out, pos_out, - len, flags); - -return generic_copy_file_range (file_in, pos_in, file_out, pos_out, len, - flags); -} -/* * Performs necessary checks before doing a file copy * @@ -1427,6 +1405,25 @@ static int generic_copy_file_checks(struct file *file_in, loff_t pos_in,loff_t size_in;int ret; +/* +* Although we now allow filesystems to handle cross sb copy, passing +* a file of the wrong filesystem type to filesystem driver can result +* in an attempt to dereference the wrong type of ->private_data, so +* avoid doing that until we really have a good reason. NFS defines
fs/read_write.c static int generic_copy_file_checks(struct file *file_in, loff_t pos_in, · line 1422
Quoted 10 lines
fs/read_write.c +10
-0+* several different file_system_type structures, but they all end up +* using the same ->copy_file_range() function pointer. +*/ +if (file_out->f_op->copy_file_range) { +if (file_in->f_op->copy_file_range != + file_out->f_op->copy_file_range) +return -EXDEV ; + }else if (file_in->f_op->remap_file_range) { +if (file_inode (file_in)->i_sb !=file_inode (file_out)->i_sb) +return -EXDEV ;
I think this check is redundant, it's done in vfs_copy_file_range. If this check is removed then the else clause below should be removed also. Once this check and the else clause are removed then might as well move the the check of copy_file_range from here to vfs_copy_file_range.
-Dai
Quoted 29 lines
fs/read_write.c +9
-3+ }else { +return -EOPNOTSUPP ; + } + ret =generic_file_rw_checks (file_in, file_out);if (ret)return ret;@@ -1495,6 +1492,7 @@ ssize_t vfs_copy_file_range(struct file *file_in, loff_t pos_in,file_start_write (file_out); + ret = -EOPNOTSUPP ;/* * Try cloning first, this is supported by more file systems, and * more efficient if both clone and copy are supported (e.g. NFS). @@ -1513,9 +1511,10 @@ ssize_t vfs_copy_file_range(struct file *file_in, loff_t pos_in, } } - ret =do_copy_file_range (file_in, pos_in, file_out, pos_out, len, - flags); -WARN_ON_ONCE (ret == -EOPNOTSUPP ); +if (file_out->f_op->copy_file_range) + ret = file_out->f_op->copy_file_range (file_in, pos_in, + file_out, pos_out, + len, flags); done:if (ret >0 ) {fsnotify_access (file_in);
Re: [PATCH v8] vfs: fix copy_file_range regression in cross-fs copies
Quoted 127 lines · On Mon, Feb 22, 2021 at 08:25:27AM -0800, [email protected] wrote:
Quoted 125 lines · Luis Henriques
A regression has been reported by Nicolas Boichat, found while using the
copy_file_rangesyscall to copy a tracefs file. Before commit5dae222a5ff0("vfs: allowcopy_file_rangeto copy across devices") the kernel would return-EXDEVto userspace when trying to copy a file across different filesystems. After this commit, the syscall doesn't fail anymore and instead returns zero (zero bytes copied), as this file's content is generated on-the-fly and thus reports a size of zero.This patch restores some cross-filesystem copy restrictions that existed prior to commit
5dae222a5ff0("vfs: allowcopy_file_rangeto copy across devices"). Filesystems are still allowed to fall-back to the VFSgeneric_copy_file_range()implementation, but that has now to be done explicitly.nfsd is also modified to fall-back into
generic_copy_file_range()in casevfs_copy_file_range()fails with-EOPNOTSUPPor-EXDEV.Fixes 5dae222a5ff0 ("vfs: allow copy_file_range to copy across devices")Reported-by Nicolas Boichat <[email protected]>Signed-off-by Luis Henriques <[email protected]>---
Changes since v7
- set 'ret' to '-EOPNOTSUPP' before the clone 'if' statement so that the error returned is always related to the 'copy' operation
Changes since v6
- restoredi_sbchecks for the clone operation
Changes since v5
- check if ->copy_file_range is NULL before calling it
Changes since v4
- nfsd falls-back togeneric_copy_file_range()only *if* it gets-EOPNOTSUPPor-EXDEV.
Changes since v3
- dropped theCOPY_FILE_SPLICEflag
- kept the f_op's checks early ingeneric_copy_file_checks, implementing Amir's suggestions
- modified nfsd to usegeneric_copy_file_range()
Changes since v2
- do all the required checks earlier, ingeneric_copy_file_checks(), adding new checks for ->remap_file_range
- newCOPY_FILE_SPLICEflag
- don't remove filesystem's fallback togeneric_copy_file_range()
- updated commit changelog (and subject)
Changes since v1 (after Amir review)
- restoreddo_copy_file_range()helper
- return-EOPNOTSUPPif fs doesn't implement CFR
- updated commit descriptionfs/nfsd/vfs.c | 8 +++++++- fs/read_write.c | 49 ++++++++++++++++++++++++------------------------- 2 files changed, 31 insertions(+), 26 deletions(-)fs/nfsd/vfs.c +7
-1@@ -568,6 +568,7 @@ __be32 nfsd4_clone_file_range(struct nfsd_file *nf_src, u64 src_pos,ssize_t nfsd_copy_file_range (struct file *src,u64 src_pos,struct file *dst,u64 dst_pos,u64 count) { +ssize_t ret;/* * Limit copy to 4MB to prevent indefinitely blocking an nfsd @@ -578,7 +579,12 @@ ssize_t nfsd_copy_file_range(struct file *src, u64 src_pos, struct file *dst,* limit like this and pipeline multiple COPY requests. */ count =min_t (u64, count,1 <<22 ); -return vfs_copy_file_range (src, src_pos, dst, dst_pos, count,0 ); + ret =vfs_copy_file_range (src, src_pos, dst, dst_pos, count,0 ); + +if (ret == -EOPNOTSUPP || ret == -EXDEV ) + ret =generic_copy_file_range (src, src_pos, dst, dst_pos, + count,0 ); +return ret; } __be32 nfsd4_vfs_fallocate(struct svc_rqst *rqstp, struct svc_fh *fhp,fs/read_write.c +12
-22@@ -1388,28 +1388,6 @@ ssize_t generic_copy_file_range(struct file *file_in, loff_t pos_in, }EXPORT_SYMBOL (generic_copy_file_range); -static ssize_t do_copy_file_range (struct file *file_in,loff_t pos_in, -struct file *file_out,loff_t pos_out, -size_t len,unsigned int flags) -{ -/* -* Although we now allow filesystems to handle cross sb copy, passing -* a file of the wrong filesystem type to filesystem driver can result -* in an attempt to dereference the wrong type of ->private_data, so -* avoid doing that until we really have a good reason. NFS defines -* several different file_system_type structures, but they all end up -* using the same ->copy_file_range() function pointer. -*/ -if (file_out->f_op->copy_file_range && - file_out->f_op->copy_file_range == file_in->f_op->copy_file_range) -return file_out->f_op->copy_file_range (file_in, pos_in, - file_out, pos_out, - len, flags); - -return generic_copy_file_range (file_in, pos_in, file_out, pos_out, len, - flags); -} -/* * Performs necessary checks before doing a file copy * @@ -1427,6 +1405,25 @@ static int generic_copy_file_checks(struct file *file_in, loff_t pos_in,loff_t size_in;int ret; +/* +* Although we now allow filesystems to handle cross sb copy, passing +* a file of the wrong filesystem type to filesystem driver can result +* in an attempt to dereference the wrong type of ->private_data, so +* avoid doing that until we really have a good reason. NFS defines +* several different file_system_type structures, but they all end up +* using the same ->copy_file_range() function pointer. +*/ +if (file_out->f_op->copy_file_range) { +if (file_in->f_op->copy_file_range != + file_out->f_op->copy_file_range) +return -EXDEV ;
Quoted 9 lines
fs/read_write.c static int generic_copy_file_checks(struct file *file_in, loff_t pos_in, · line 1422
Quoted 3 lines
fs/read_write.c +3
-0+ }else if (file_in->f_op->remap_file_range) { +if (file_inode (file_in)->i_sb !=file_inode (file_out)->i_sb) +return -EXDEV ;I think this check is redundant, it's done in
vfs_copy_file_range. If this check is removed then the else clause below should be removed also. Once this check and the else clause are removed then might as well move the the check ofcopy_file_rangefrom here tovfs_copy_file_range.
I don't think it's really redundant, although I agree is messy due to the fact we try to clone first instead of copying them.
So, in the clone path, this is the only place where we return -EXDEV if:
1) we don't have ->copy_file_range *and*
2) we have ->remap_file_range but the i_sb are different.
The check in vfs_copy_file_range() is only executed if:
1) we have *valid* ->copy_file_range ops and/or
2) we have *valid* ->remap_file_range
So... if we remove the check in generic_copy_file_checks() as you suggest and:
- we don't have ->copy_file_range,
- we have ->remap_file_range but
- the i_sb are different
we'll return the -EOPNOTSUPP (the one set in line "ret = -EOPNOTSUPP;" in function vfs_copy_file_range() ) instead of -EXDEV.
But I may have got it all wrong. I've looked so many times at this code that I'm probably useless at finding problems in it :-)
Cheers,
--
Luís
Quoted 28 lines
-Dai
Quoted 26 lines
fs/read_write.c +9
-3+ }else { +return -EOPNOTSUPP ; + } + ret =generic_file_rw_checks (file_in, file_out);if (ret)return ret;@@ -1495,6 +1492,7 @@ ssize_t vfs_copy_file_range(struct file *file_in, loff_t pos_in,file_start_write (file_out); + ret = -EOPNOTSUPP ;/* * Try cloning first, this is supported by more file systems, and * more efficient if both clone and copy are supported (e.g. NFS). @@ -1513,9 +1511,10 @@ ssize_t vfs_copy_file_range(struct file *file_in, loff_t pos_in, } } - ret =do_copy_file_range (file_in, pos_in, file_out, pos_out, len, - flags); -WARN_ON_ONCE (ret == -EOPNOTSUPP ); +if (file_out->f_op->copy_file_range) + ret = file_out->f_op->copy_file_range (file_in, pos_in, + file_out, pos_out, + len, flags); done:if (ret >0 ) {fsnotify_access (file_in);
Re: [PATCH v8] vfs: fix copy_file_range regression in cross-fs copies
Quoted 139 lines · Luis Henriques
Quoted 127 lines · On Mon, Feb 22, 2021 at 08:25:27AM -0800, [email protected] wrote:
Quoted 125 lines · Luis Henriques
A regression has been reported by Nicolas Boichat, found while using the
copy_file_rangesyscall to copy a tracefs file. Before commit5dae222a5ff0("vfs: allowcopy_file_rangeto copy across devices") the kernel would return-EXDEVto userspace when trying to copy a file across different filesystems. After this commit, the syscall doesn't fail anymore and instead returns zero (zero bytes copied), as this file's content is generated on-the-fly and thus reports a size of zero.This patch restores some cross-filesystem copy restrictions that existed prior to commit
5dae222a5ff0("vfs: allowcopy_file_rangeto copy across devices"). Filesystems are still allowed to fall-back to the VFSgeneric_copy_file_range()implementation, but that has now to be done explicitly.nfsd is also modified to fall-back into
generic_copy_file_range()in casevfs_copy_file_range()fails with-EOPNOTSUPPor-EXDEV.Fixes 5dae222a5ff0 ("vfs: allow copy_file_range to copy across devices")Reported-by Nicolas Boichat <[email protected]>Signed-off-by Luis Henriques <[email protected]>---
Changes since v7
- set 'ret' to '-EOPNOTSUPP' before the clone 'if' statement so that the error returned is always related to the 'copy' operation
Changes since v6
- restoredi_sbchecks for the clone operation
Changes since v5
- check if ->copy_file_range is NULL before calling it
Changes since v4
- nfsd falls-back togeneric_copy_file_range()only *if* it gets-EOPNOTSUPPor-EXDEV.
Changes since v3
- dropped theCOPY_FILE_SPLICEflag
- kept the f_op's checks early ingeneric_copy_file_checks, implementing Amir's suggestions
- modified nfsd to usegeneric_copy_file_range()
Changes since v2
- do all the required checks earlier, ingeneric_copy_file_checks(), adding new checks for ->remap_file_range
- newCOPY_FILE_SPLICEflag
- don't remove filesystem's fallback togeneric_copy_file_range()
- updated commit changelog (and subject)
Changes since v1 (after Amir review)
- restoreddo_copy_file_range()helper
- return-EOPNOTSUPPif fs doesn't implement CFR
- updated commit descriptionfs/nfsd/vfs.c | 8 +++++++- fs/read_write.c | 49 ++++++++++++++++++++++++------------------------- 2 files changed, 31 insertions(+), 26 deletions(-)fs/nfsd/vfs.c +7
-1@@ -568,6 +568,7 @@ __be32 nfsd4_clone_file_range(struct nfsd_file *nf_src, u64 src_pos,ssize_t nfsd_copy_file_range (struct file *src,u64 src_pos,struct file *dst,u64 dst_pos,u64 count) { +ssize_t ret;/* * Limit copy to 4MB to prevent indefinitely blocking an nfsd @@ -578,7 +579,12 @@ ssize_t nfsd_copy_file_range(struct file *src, u64 src_pos, struct file *dst,* limit like this and pipeline multiple COPY requests. */ count =min_t (u64, count,1 <<22 ); -return vfs_copy_file_range (src, src_pos, dst, dst_pos, count,0 ); + ret =vfs_copy_file_range (src, src_pos, dst, dst_pos, count,0 ); + +if (ret == -EOPNOTSUPP || ret == -EXDEV ) + ret =generic_copy_file_range (src, src_pos, dst, dst_pos, + count,0 ); +return ret; } __be32 nfsd4_vfs_fallocate(struct svc_rqst *rqstp, struct svc_fh *fhp,fs/read_write.c +12
-22@@ -1388,28 +1388,6 @@ ssize_t generic_copy_file_range(struct file *file_in, loff_t pos_in, }EXPORT_SYMBOL (generic_copy_file_range); -static ssize_t do_copy_file_range (struct file *file_in,loff_t pos_in, -struct file *file_out,loff_t pos_out, -size_t len,unsigned int flags) -{ -/* -* Although we now allow filesystems to handle cross sb copy, passing -* a file of the wrong filesystem type to filesystem driver can result -* in an attempt to dereference the wrong type of ->private_data, so -* avoid doing that until we really have a good reason. NFS defines -* several different file_system_type structures, but they all end up -* using the same ->copy_file_range() function pointer. -*/ -if (file_out->f_op->copy_file_range && - file_out->f_op->copy_file_range == file_in->f_op->copy_file_range) -return file_out->f_op->copy_file_range (file_in, pos_in, - file_out, pos_out, - len, flags); - -return generic_copy_file_range (file_in, pos_in, file_out, pos_out, len, - flags); -} -/* * Performs necessary checks before doing a file copy * @@ -1427,6 +1405,25 @@ static int generic_copy_file_checks(struct file *file_in, loff_t pos_in,loff_t size_in;int ret; +/* +* Although we now allow filesystems to handle cross sb copy, passing +* a file of the wrong filesystem type to filesystem driver can result +* in an attempt to dereference the wrong type of ->private_data, so +* avoid doing that until we really have a good reason. NFS defines +* several different file_system_type structures, but they all end up +* using the same ->copy_file_range() function pointer. +*/ +if (file_out->f_op->copy_file_range) { +if (file_in->f_op->copy_file_range != + file_out->f_op->copy_file_range) +return -EXDEV ;Quoted 9 lines
fs/read_write.c static int generic_copy_file_checks(struct file *file_in, loff_t pos_in, · line 1422
Quoted 3 lines
fs/read_write.c +3
-0+ }else if (file_in->f_op->remap_file_range) { +if (file_inode (file_in)->i_sb !=file_inode (file_out)->i_sb) +return -EXDEV ;I think this check is redundant, it's done in
vfs_copy_file_range. If this check is removed then the else clause below should be removed also. Once this check and the else clause are removed then might as well move the the check ofcopy_file_rangefrom here tovfs_copy_file_range.
Quoted 3 lines
I don't think it's really redundant, although I agree is messy due to the fact we try to clone first instead of copying them.
It was put here in early checks on purpose before the check for zero size file.
I'm pretty sure this wasn't the case in earlier versions of the path and then it did not solve the reported problem.
Thanks,
Amir.
[email protected]
reviewerRe: [PATCH v8] vfs: fix copy_file_range regression in cross-fs copies
In reply to Luis HenriquesQuoted 148 lines · Luis Henriques
Quoted 125 lines · On Mon, Feb 22, 2021 at 08:25:27AM -0800, [email protected] wrote:
Quoted 124 lines · Luis Henriques
A regression has been reported by Nicolas Boichat, found while using the
copy_file_rangesyscall to copy a tracefs file. Before commit5dae222a5ff0("vfs: allowcopy_file_rangeto copy across devices") the kernel would return-EXDEVto userspace when trying to copy a file across different filesystems. After this commit, the syscall doesn't fail anymore and instead returns zero (zero bytes copied), as this file's content is generated on-the-fly and thus reports a size of zero.This patch restores some cross-filesystem copy restrictions that existed prior to commit
5dae222a5ff0("vfs: allowcopy_file_rangeto copy across devices"). Filesystems are still allowed to fall-back to the VFSgeneric_copy_file_range()implementation, but that has now to be done explicitly.nfsd is also modified to fall-back into
generic_copy_file_range()in casevfs_copy_file_range()fails with-EOPNOTSUPPor-EXDEV.Fixes 5dae222a5ff0 ("vfs: allow copy_file_range to copy across devices")Reported-by Nicolas Boichat <[email protected]>Signed-off-by Luis Henriques <[email protected]>---
Changes since v7
- set 'ret' to '-EOPNOTSUPP' before the clone 'if' statement so that the error returned is always related to the 'copy' operation
Changes since v6
- restoredi_sbchecks for the clone operation
Changes since v5
- check if ->copy_file_range is NULL before calling it
Changes since v4
- nfsd falls-back togeneric_copy_file_range()only *if* it gets-EOPNOTSUPPor-EXDEV.
Changes since v3
- dropped theCOPY_FILE_SPLICEflag
- kept the f_op's checks early ingeneric_copy_file_checks, implementing Amir's suggestions
- modified nfsd to usegeneric_copy_file_range()
Changes since v2
- do all the required checks earlier, ingeneric_copy_file_checks(),adding new checks for ->remap_file_range- new
COPY_FILE_SPLICEflag
- don't remove filesystem's fallback togeneric_copy_file_range()
- updated commit changelog (and subject)
Changes since v1 (after Amir review)
- restoreddo_copy_file_range()helper
- return-EOPNOTSUPPif fs doesn't implement CFR
- updated commit descriptionfs/nfsd/vfs.c | 8 +++++++- fs/read_write.c | 49 ++++++++++++++++++++++++------------------------- 2 files changed, 31 insertions(+), 26 deletions(-)fs/nfsd/vfs.c +7
-1@@ -568,6 +568,7 @@ __be32 nfsd4_clone_file_range(struct nfsd_file *nf_src, u64 src_pos,ssize_t nfsd_copy_file_range (struct file *src,u64 src_pos,struct file *dst,u64 dst_pos,u64 count) { +ssize_t ret;/* * Limit copy to 4MB to prevent indefinitely blocking an nfsd @@ -578,7 +579,12 @@ ssize_t nfsd_copy_file_range(struct file *src, u64 src_pos, struct file *dst,* limit like this and pipeline multiple COPY requests. */ count =min_t (u64, count,1 <<22 ); -return vfs_copy_file_range (src, src_pos, dst, dst_pos, count,0 ); + ret =vfs_copy_file_range (src, src_pos, dst, dst_pos, count,0 ); + +if (ret == -EOPNOTSUPP || ret == -EXDEV ) + ret =generic_copy_file_range (src, src_pos, dst, dst_pos, + count,0 ); +return ret; } __be32 nfsd4_vfs_fallocate(struct svc_rqst *rqstp, struct svc_fh *fhp,fs/read_write.c +11
-22@@ -1388,28 +1388,6 @@ ssize_t generic_copy_file_range(struct file *file_in, loff_t pos_in, }EXPORT_SYMBOL (generic_copy_file_range); -static ssize_t do_copy_file_range (struct file *file_in,loff_t pos_in, -struct file *file_out,loff_t pos_out, -size_t len,unsigned int flags) -{ -/* -* Although we now allow filesystems to handle cross sb copy, passing -* a file of the wrong filesystem type to filesystem driver can result -* in an attempt to dereference the wrong type of ->private_data, so -* avoid doing that until we really have a good reason. NFS defines -* several different file_system_type structures, but they all end up -* using the same ->copy_file_range() function pointer. -*/ -if (file_out->f_op->copy_file_range && - file_out->f_op->copy_file_range == file_in->f_op->copy_file_range) -return file_out->f_op->copy_file_range (file_in, pos_in, - file_out, pos_out, - len, flags); - -return generic_copy_file_range (file_in, pos_in, file_out, pos_out, len, - flags); -} -/* * Performs necessary checks before doing a file copy * @@ -1427,6 +1405,25 @@ static int generic_copy_file_checks(struct file *file_in, loff_t pos_in,loff_t size_in;int ret; +/* +* Although we now allow filesystems to handle cross sb copy, passing +* a file of the wrong filesystem type to filesystem driver can result +* in an attempt to dereference the wrong type of ->private_data, so +* avoid doing that until we really have a good reason. NFS defines +* several different file_system_type structures, but they all end up +* using the same ->copy_file_range() function pointer. +*/ +if (file_out->f_op->copy_file_range) { +if (file_in->f_op->copy_file_range != + file_out->f_op->copy_file_range)Quoted 9 lines
fs/read_write.c static int generic_copy_file_checks(struct file *file_in, loff_t pos_in, · line 1422
Quoted 4 lines
fs/read_write.c +4
-0+return -EXDEV ; + }else if (file_in->f_op->remap_file_range) { +if (file_inode (file_in)->i_sb !=file_inode (file_out)->i_sb) +return -EXDEV ;I think this check is redundant, it's done in
vfs_copy_file_range. If this check is removed then the else clause below should be removed also. Once this check and the else clause are removed then might as well move the the check ofcopy_file_rangefrom here tovfs_copy_file_range.I don't think it's really redundant, although I agree is messy due to the fact we try to clone first instead of copying them.
So, in the clone path, this is the only place where we return
-EXDEVif:1) we don't have ->copy_file_range *and*
2) we have ->remap_file_range but thei_sbare different.The check in
vfs_copy_file_range()is only executed if:1) we have *valid* ->copy_file_range ops and/or
2) we have *valid* ->remap_file_range
Quoted 8 lines
So... if we remove the check in
generic_copy_file_checks()as you suggest and:
- we don't have ->copy_file_range,
- we have ->remap_file_range but
- thei_sbare differentwe'll return the
-EOPNOTSUPP(the one set in line "ret =-EOPNOTSUPP;" in functionvfs_copy_file_range()) instead of-EXDEV.
Yes, this is the different.The NFS code handles both -EOPNOTSUPP and -EXDEVV by doing generic_copy_file_range. Do any other consumers of vfs_copy_file_range rely on -EXDEV and not -EOPNOTSUPP and which is the correct error code for this case? It seems to me that -EOPNOTSUPP is more appropriate than EXDEV when (sb1 != sb2).
Quoted 3 lines
But I may have got it all wrong. I've looked so many times at this code that I'm probably useless at finding problems in it :-)
You're not alone, we all try to do the right thing :-)
-Dai
Quoted 33 lines
Cheers,
--
LuísQuoted 28 lines
-Dai
Quoted 26 lines
fs/read_write.c +9
-3+ }else { +return -EOPNOTSUPP ; + } + ret =generic_file_rw_checks (file_in, file_out);if (ret)return ret;@@ -1495,6 +1492,7 @@ ssize_t vfs_copy_file_range(struct file *file_in, loff_t pos_in,file_start_write (file_out); + ret = -EOPNOTSUPP ;/* * Try cloning first, this is supported by more file systems, and * more efficient if both clone and copy are supported (e.g. NFS). @@ -1513,9 +1511,10 @@ ssize_t vfs_copy_file_range(struct file *file_in, loff_t pos_in, } } - ret =do_copy_file_range (file_in, pos_in, file_out, pos_out, len, - flags); -WARN_ON_ONCE (ret == -EOPNOTSUPP ); +if (file_out->f_op->copy_file_range) + ret = file_out->f_op->copy_file_range (file_in, pos_in, + file_out, pos_out, + len, flags); done:if (ret >0 ) {fsnotify_access (file_in);
[email protected]
reviewerRe: [PATCH v8] vfs: fix copy_file_range regression in cross-fs copies
Quoted 181 lines · On 2/23/21 7:29 AM, [email protected] wrote:
Quoted 175 lines · Luis Henriques
Quoted 146 lines · On Mon, Feb 22, 2021 at 08:25:27AM -0800, [email protected] wrote:
Quoted 145 lines · Luis Henriques
A regression has been reported by Nicolas Boichat, found while using the
copy_file_rangesyscall to copy a tracefs file. Before commit5dae222a5ff0("vfs: allowcopy_file_rangeto copy across devices") the kernel would return-EXDEVto userspace when trying to copy a file across different filesystems. After this commit, the syscall doesn't fail anymore and instead returns zero (zero bytes copied), as this file's content is generated on-the-fly and thus reports a size of zero.This patch restores some cross-filesystem copy restrictions that existed prior to commit
5dae222a5ff0("vfs: allowcopy_file_rangeto copy across devices"). Filesystems are still allowed to fall-back to the VFSgeneric_copy_file_range()implementation, but that has now to be done explicitly.nfsd is also modified to fall-back into
generic_copy_file_range()in casevfs_copy_file_range()fails with-EOPNOTSUPPor-EXDEV.Fixes 5dae222a5ff0 ("vfs: allow copy_file_range to copy across devices")Reported-by Nicolas Boichat <[email protected]>Signed-off-by Luis Henriques <[email protected]>---
Changes since v7
- set 'ret' to '-EOPNOTSUPP' before the clone 'if' statement so that the
error returned is always related to the 'copy' operation Changes since v6
- restoredi_sbchecks for the clone operation
Changes since v5
- check if ->copy_file_range is NULL before calling it Changes since v4
- nfsd falls-back togeneric_copy_file_range()only *if* it gets-EOPNOTSUPP
or-EXDEV.
Changes since v3
- dropped theCOPY_FILE_SPLICEflag
- kept the f_op's checks early ingeneric_copy_file_checks, implementing
Amir's suggestions
- modified nfsd to usegeneric_copy_file_range()
Changes since v2
- do all the required checks earlier, ingeneric_copy_file_checks(), adding new checks for ->remap_file_range
- newCOPY_FILE_SPLICEflag
- don't remove filesystem's fallback togeneric_copy_file_range()
- updated commit changelog (and subject)
Changes since v1 (after Amir review)
- restoreddo_copy_file_range()helper
- return-EOPNOTSUPPif fs doesn't implement CFR
- updated commit descriptionfs/nfsd/vfs.c | 8 +++++++-
fs/read_write.c| 49
++++++++++++++++++++++++-------------------------2 files changed, 31 insertions(+), 26 deletions(-)fs/nfsd/vfs.c +7
-1@@ -568,6 +568,7 @@ __be32 nfsd4_clone_file_range(struct nfsd_file *nf_src, u64 src_pos, ssize_t nfsd_copy_file_range(struct file *src, u64 src_pos, struct file *dst, u64 dst_pos, u64 count) { + ssize_t ret; /** Limit copy to 4MB to prevent indefinitely blocking an nfsd @@ -578,7 +579,12 @@ ssize_t nfsd_copy_file_range(struct file *src,u64 src_pos, struct file *dst, * limit like this and pipeline multiple COPY requests. */ count = min_t(u64, count, 1 << 22); - return vfs_copy_file_range(src, src_pos, dst, dst_pos, count, 0); + ret = vfs_copy_file_range(src, src_pos, dst, dst_pos, count, 0); + + if (ret == -EOPNOTSUPP || ret == -EXDEV) + ret = generic_copy_file_range(src, src_pos, dst, dst_pos, + count, 0); + return ret; } __be32 nfsd4_vfs_fallocate(struct svc_rqst *rqstp, struct svc_fh *fhp,fs/read_write.c +0
-6@@ -1388,28 +1388,6 @@ ssize_t generic_copy_file_range(struct file *file_in, loff_t pos_in, } EXPORT_SYMBOL(generic_copy_file_range); -static ssize_t do_copy_file_range (struct file *file_in,loff_t pos_in, - struct file *file_out, loff_t pos_out, - size_t len, unsigned int flags) -{ - /* -* Although we now allow filesystems to handle cross sb copy, passing
- * a file of the wrong filesystem type to filesystem driver can result
- * in an attempt to dereference the wrong type of ->private_data, so
- * avoid doing that until we really have a good reason. NFS defines
- * several differentfile_system_typestructures, but they all end up
- * using the same ->copy_file_range() function pointer. - */
- if (file_out->f_op->copy_file_range&&
-file_out->f_op->copy_file_range==file_in->f_op->copy_file_range)
- return file_out->f_op->copy_file_range(file_in,pos_in, -file_out,pos_out,
- len, flags);
-
- return generic_copy_file_range(file_in,pos_in,file_out,pos_out, len,
- flags);fs/read_write.c +0
-2-} -/*
* Performs necessary checks before doing a file copy *fs/read_write.c +2
-0@@ -1427,6 +1405,25 @@ static int generic_copy_file_checks(struct file *file_in, loff_t pos_in, loff_t size_in; int ret; + /* +* Although we now allow filesystems to handle cross sb copy, passing
+ * a file of the wrong filesystem type to filesystem driver can result
+ * in an attempt to dereference the wrong type of ->private_data, so
+ * avoid doing that until we really have a good reason. NFS defines
+ * several differentfile_system_typestructures, but they all end up
+ * using the same ->copy_file_range() function pointer. + */
+ if (file_out->f_op->copy_file_range) {
+ if (file_in->f_op->copy_file_range!=
+file_out->f_op->copy_file_range)Quoted 9 lines
Quoted 4 lines
+ return
-EXDEV;
+ } else if (file_in->f_op->remap_file_range) {
+ if (file_inode(file_in)->i_sb != file_inode(file_out)->i_sb) + return-EXDEV;I think this check is redundant, it's done in
vfs_copy_file_range. If this check is removed then the else clause below should be removed also. Once this check and the else clause are removed then might as well move the the check ofcopy_file_rangefrom here tovfs_copy_file_range.I don't think it's really redundant, although I agree is messy due to the fact we try to clone first instead of copying them.
So, in the clone path, this is the only place where we return
-EXDEVif:1) we don't have ->copy_file_range *and*
2) we have ->remap_file_range but thei_sbare different.The check in
vfs_copy_file_range()is only executed if:1) we have *valid* ->copy_file_range ops and/or
2) we have *valid* ->remap_file_rangeSo... if we remove the check in
generic_copy_file_checks()as you suggest and:
- we don't have ->copy_file_range,
- we have ->remap_file_range but
- thei_sbare differentQuoted 3 lines
we'll return the
-EOPNOTSUPP(the one set in line "ret =-EOPNOTSUPP;" in
functionvfs_copy_file_range()) instead of-EXDEV.
Quoted 5 lines
Yes, this is the different.The NFS code handles both
-EOPNOTSUPPand-EXDEVVby doing generic_copy_file_range. Do any other consumers ofvfs_copy_file_rangerely on-EXDEVand not-EOPNOTSUPPand which is the correct error code for this case? It seems to me that-EOPNOTSUPPis more appropriate than EXDEV when (sb1 != sb2).
So with the current patch, for a clone operation across 2 filesystems:
. if src and dst filesystem support both copy_file_range and
map_file_range then the code returns -ENOTSUPPORT.
. if the filesystems only support map_file_range then the
code returns -EXDEV
This seems confusing, shouldn't only 1 error code returned for this case?
-Dai
Quoted 44 lines
Quoted 4 lines
But I may have got it all wrong. I've looked so many times at this code that I'm probably useless at finding problems in it :-)
You're not alone, we all try to do the right thing :-)
-Dai
Quoted 35 lines
Cheers,
Signature · 1 line
LuísQuoted 30 lines
-Dai
Quoted 28 lines
+ } else {
+ return-EOPNOTSUPP;
+ }
+
ret =generic_file_rw_checks(file_in, file_out); if (ret)
return ret;fs/read_write.c +5
-3@@ -1495,6 +1492,7 @@ ssize_t vfs_copy_file_range(struct file *file_in, loff_t pos_in, file_start_write(file_out); + ret = -EOPNOTSUPP; /** Try cloning first, this is supported by more file systems, and * more efficient if both clone and copy are supported (e.g. NFS). @@ -1513,9 +1511,10 @@ ssize_t vfs_copy_file_range(struct file *file_in, loff_t pos_in, } } - ret = do_copy_file_range(file_in, pos_in, file_out, pos_out, len, - flags); - WARN_ON_ONCE(ret == -EOPNOTSUPP); + if (file_out->f_op->copy_file_range) + ret = file_out->f_op->copy_file_range(file_in, pos_in, + file_out, pos_out, + len, flags);done:
if (ret > 0) {
fsnotify_access(file_in);
Re: [PATCH v8] vfs: fix copy_file_range regression in cross-fs copies
Quoted 200 lines · On Tue, Feb 23, 2021 at 6:02 PM <[email protected]> wrote:
Quoted 197 lines · On 2/23/21 7:29 AM, [email protected] wrote:
Quoted 194 lines · Luis Henriques
Quoted 160 lines · On Mon, Feb 22, 2021 at 08:25:27AM -0800, [email protected] wrote:
Quoted 159 lines · Luis Henriques
A regression has been reported by Nicolas Boichat, found while using the
copy_file_rangesyscall to copy a tracefs file. Before commit5dae222a5ff0("vfs: allowcopy_file_rangeto copy across devices") the kernel would return-EXDEVto userspace when trying to copy a file across
different filesystems. After this commit, the syscall doesn't fail anymore
and instead returns zero (zero bytes copied), as this file's content is
generated on-the-fly and thus reports a size of zero.This patch restores some cross-filesystem copy restrictions that existed
prior to commit5dae222a5ff0("vfs: allowcopy_file_rangeto copy across
devices"). Filesystems are still allowed to fall-back to the VFSgeneric_copy_file_range()implementation, but that has now to be done explicitly.nfsd is also modified to fall-back into
generic_copy_file_range()in casevfs_copy_file_range()fails with-EOPNOTSUPPor-EXDEV.Fixes 5dae222a5ff0 ("vfs: allow copy_file_range to copy acrossdevices")
Link:
https://urldefense.com/v3/__https://lore.kernel.org/linux-fsdevel/[email protected]/__;!!GqivPVa7Brio!P1UWThiSkxbjfjFQWNYJmCxGEkiLFyvHjH6cS-G1ZTt1z-TeqwGQgQmi49dC6w$
Link:
https://urldefense.com/v3/__https://lore.kernel.org/linux-fsdevel/CANMq1KDZuxir2LM5jOTm0xx*[email protected]/__;Kw!!GqivPVa7Brio!P1UWThiSkxbjfjFQWNYJmCxGEkiLFyvHjH6cS-G1ZTt1z-TeqwGQgQmgCmMHzA$
Link:
https://urldefense.com/v3/__https://lore.kernel.org/linux-fsdevel/20210126135012.1.If45b7cdc3ff707bc1efa17f5366057d60603c45f@changeid/__;!!GqivPVa7Brio!P1UWThiSkxbjfjFQWNYJmCxGEkiLFyvHjH6cS-G1ZTt1z-TeqwGQgQmzqItkrQ$Reported-by Nicolas Boichat <[email protected]>Signed-off-by Luis Henriques <[email protected]>---
Changes since v7
- set 'ret' to '-EOPNOTSUPP' before the clone 'if' statement so that the
error returned is always related to the 'copy' operation
Changes since v6
- restoredi_sbchecks for the clone operation
Changes since v5
- check if ->copy_file_range is NULL before calling it Changes since v4
- nfsd falls-back togeneric_copy_file_range()only *if* it gets-EOPNOTSUPP
or-EXDEV.
Changes since v3
- dropped theCOPY_FILE_SPLICEflag
- kept the f_op's checks early ingeneric_copy_file_checks, implementing
Amir's suggestions
- modified nfsd to usegeneric_copy_file_range()
Changes since v2
- do all the required checks earlier, ingeneric_copy_file_checks(),adding new checks for ->remap_file_range- new
COPY_FILE_SPLICEflag
- don't remove filesystem's fallback togeneric_copy_file_range()
- updated commit changelog (and subject)
Changes since v1 (after Amir review)
- restoreddo_copy_file_range()helper
- return-EOPNOTSUPPif fs doesn't implement CFR
- updated commit descriptionfs/nfsd/vfs.c | 8 +++++++- fs/read_write.c | 49 ++++++++++++++++++++++++------------------------- 2 files changed, 31 insertions(+), 26 deletions(-)fs/nfsd/vfs.c +1
-0@@ -568,6 +568,7 @@ __be32 nfsd4_clone_file_range(struct nfsd_file *nf_src, u64 src_pos, ssize_t nfsd_copy_file_range(struct file *src, u64 src_pos, struct file *dst, u64 dst_pos, u64 count) { +ssize_t ret;/* * Limit copy to 4MB to prevent indefinitely blocking an nfsd
fs/nfsd/vfs.c +6
-1@@ -578,7 +579,12 @@ ssize_t nfsd_copy_file_range(struct file *src,u64 src_pos, struct file *dst, * limit like this and pipeline multiple COPY requests. */ count =min_t (u64, count,1 <<22 ); -return vfs_copy_file_range (src, src_pos, dst, dst_pos, count,0 ); + ret =vfs_copy_file_range (src, src_pos, dst, dst_pos, count,0 ); + +if (ret == -EOPNOTSUPP || ret == -EXDEV ) + ret =generic_copy_file_range (src, src_pos, dst, dst_pos, + count,0 ); +return ret; } __be32 nfsd4_vfs_fallocate(struct svc_rqst *rqstp, struct svc_fh*fhp,
fs/read_write.c +0
-6@@ -1388,28 +1388,6 @@ ssize_t generic_copy_file_range(struct file *file_in, loff_t pos_in, }EXPORT_SYMBOL (generic_copy_file_range); -static ssize_t do_copy_file_range (struct file *file_in,loff_t pos_in, -struct file *file_out,loff_t pos_out, -size_t len,unsigned int flags) -{ -/* -* Although we now allow filesystems to handle cross sb copy, passing
- * a file of the wrong filesystem type to filesystem driver
can resultfs/read_write.c +0
-3- * in an attempt to dereference the wrong type of ->private_data, so - * avoid doing that until we really have a good reason. NFSdefines
- * several differentfile_system_typestructures, but they all
end upfs/read_write.c +0
-4-* using the same ->copy_file_range() function pointer. -*/ -if (file_out->f_op->copy_file_range && - file_out->f_op->copy_file_range ==
file_in->f_op->copy_file_range)fs/read_write.c +0
-5-return file_out->f_op->copy_file_range (file_in, pos_in, - file_out, pos_out, - len, flags); - - return generic_copy_file_range(file_in, pos_in, file_out,
pos_out, len,fs/read_write.c +2
-3- flags); -} -/* * Performs necessary checks before doing a file copy * @@ -1427,6 +1405,25 @@ static int generic_copy_file_checks(struct file *file_in, loff_t pos_in, loff_t size_in;int ret; +/* +* Although we now allow filesystems to handle cross sb copy, passing
+ * a file of the wrong filesystem type to filesystem driver
can resultfs/read_write.c +2
-1+* in an attempt to dereference the wrong type of ->private_data, so +* avoid doing that until we really have a good reason. NFS defines
+ * several differentfile_system_typestructures, but they all
end upfs/read_write.c +6
-0+* using the same ->copy_file_range() function pointer. +*/ +if (file_out->f_op->copy_file_range) { +if (file_in->f_op->copy_file_range != + file_out->f_op->copy_file_range) +return -EXDEV ;Quoted 9 lines
fs/read_write.c static int generic_copy_file_checks(struct file *file_in, loff_t pos_in, · line 1422
Quoted 3 lines
fs/read_write.c +3
-0+ }else if (file_in->f_op->remap_file_range) { +if (file_inode (file_in)->i_sb !=file_inode (file_out)->i_sb) +return -EXDEV ;I think this check is redundant, it's done in
vfs_copy_file_range. If this check is removed then the else clause below should be removed also. Once this check and the else clause are removed then might as well move the the check ofcopy_file_rangefrom here tovfs_copy_file_range.I don't think it's really redundant, although I agree is messy due to the
fact we try to clone first instead of copying them.So, in the clone path, this is the only place where we return
-EXDEVif:1) we don't have ->copy_file_range *and*
2) we have ->remap_file_range but thei_sbare different.The check in
vfs_copy_file_range()is only executed if:1) we have *valid* ->copy_file_range ops and/or
2) we have *valid* ->remap_file_rangeSo... if we remove the check in
generic_copy_file_checks()as you suggest
and:
- we don't have ->copy_file_range,
- we have ->remap_file_range but
- thei_sbare differentwe'll return the
-EOPNOTSUPP(the one set in line "ret =-EOPNOTSUPP;" in
functionvfs_copy_file_range()) instead of-EXDEV.
Quoted 6 lines
Quoted 5 lines
Yes, this is the different.The NFS code handles both
-EOPNOTSUPPand-EXDEVVby doinggeneric_copy_file_range. Do any other consumers ofvfs_copy_file_rangerely on-EXDEVand not-EOPNOTSUPPand which is the correct error code for this case? It seems to me that-EOPNOTSUPPis more appropriate than EXDEV when (sb1 != sb2).
EXDEV is the right code for:
filesystem supports the operation but not for sb1 != sb1.
Quoted 5 lines
So with the current patch, for a clone operation across 2 filesystems:
. if src and dst filesystem support both
copy_file_rangeand
map_file_rangethen the code returns-ENOTSUPPORT.
Why do you say that?
Which code are you referring to exactly?
Did you see this behavior in a test?
Quoted 5 lines
. if the filesystems only support
map_file_rangethen the
code returns-EXDEVThis seems confusing, shouldn't only 1 error code returned for this case?
From my read of the code, user will get -EXDEV in both the cases you listed.
Thanks,
Amir.
[email protected]
reviewerRe: [PATCH v8] vfs: fix copy_file_range regression in cross-fs copies
Quoted 206 lines · Amir Goldstein
Quoted 194 lines · On Tue, Feb 23, 2021 at 6:02 PM <[email protected]> wrote:
Quoted 192 lines · On 2/23/21 7:29 AM, [email protected] wrote:
Quoted 191 lines · Luis Henriques
Quoted 160 lines · On Mon, Feb 22, 2021 at 08:25:27AM -0800, [email protected] wrote:
Quoted 159 lines · Luis Henriques
A regression has been reported by Nicolas Boichat, found while using the
copy_file_rangesyscall to copy a tracefs file. Before commit5dae222a5ff0("vfs: allowcopy_file_rangeto copy across devices") the kernel would return-EXDEVto userspace when trying to copy a file across
different filesystems. After this commit, the syscall doesn't fail anymore
and instead returns zero (zero bytes copied), as this file's content is
generated on-the-fly and thus reports a size of zero.This patch restores some cross-filesystem copy restrictions that existed
prior to commit5dae222a5ff0("vfs: allowcopy_file_rangeto copy across
devices"). Filesystems are still allowed to fall-back to the VFSgeneric_copy_file_range()implementation, but that has now to be done explicitly.nfsd is also modified to fall-back into
generic_copy_file_range()in casevfs_copy_file_range()fails with-EOPNOTSUPPor-EXDEV.Fixes 5dae222a5ff0 ("vfs: allow copy_file_range to copy acrossdevices")
Link:
https://urldefense.com/v3/__https://lore.kernel.org/linux-fsdevel/[email protected]/__;!!GqivPVa7Brio!P1UWThiSkxbjfjFQWNYJmCxGEkiLFyvHjH6cS-G1ZTt1z-TeqwGQgQmi49dC6w$
Link:
https://urldefense.com/v3/__https://lore.kernel.org/linux-fsdevel/CANMq1KDZuxir2LM5jOTm0xx*[email protected]/__;Kw!!GqivPVa7Brio!P1UWThiSkxbjfjFQWNYJmCxGEkiLFyvHjH6cS-G1ZTt1z-TeqwGQgQmgCmMHzA$
Link:
https://urldefense.com/v3/__https://lore.kernel.org/linux-fsdevel/20210126135012.1.If45b7cdc3ff707bc1efa17f5366057d60603c45f@changeid/__;!!GqivPVa7Brio!P1UWThiSkxbjfjFQWNYJmCxGEkiLFyvHjH6cS-G1ZTt1z-TeqwGQgQmzqItkrQ$Reported-by Nicolas Boichat <[email protected]>Signed-off-by Luis Henriques <[email protected]>---
Changes since v7
- set 'ret' to '-EOPNOTSUPP' before the clone 'if' statement so that the
error returned is always related to the 'copy' operation
Changes since v6
- restoredi_sbchecks for the clone operation
Changes since v5
- check if ->copy_file_range is NULL before calling it Changes since v4
- nfsd falls-back togeneric_copy_file_range()only *if* it gets-EOPNOTSUPP
or-EXDEV.
Changes since v3
- dropped theCOPY_FILE_SPLICEflag
- kept the f_op's checks early ingeneric_copy_file_checks, implementing
Amir's suggestions
- modified nfsd to usegeneric_copy_file_range()
Changes since v2
- do all the required checks earlier, ingeneric_copy_file_checks(),adding new checks for ->remap_file_range- new
COPY_FILE_SPLICEflag
- don't remove filesystem's fallback togeneric_copy_file_range()
- updated commit changelog (and subject)
Changes since v1 (after Amir review)
- restoreddo_copy_file_range()helper
- return-EOPNOTSUPPif fs doesn't implement CFR
- updated commit descriptionfs/nfsd/vfs.c | 8 +++++++- fs/read_write.c | 49 ++++++++++++++++++++++++------------------------- 2 files changed, 31 insertions(+), 26 deletions(-)fs/nfsd/vfs.c +1
-0@@ -568,6 +568,7 @@ __be32 nfsd4_clone_file_range(struct nfsd_file *nf_src, u64 src_pos, ssize_t nfsd_copy_file_range(struct file *src, u64 src_pos, struct file *dst, u64 dst_pos, u64 count) { +ssize_t ret;/* * Limit copy to 4MB to prevent indefinitely blocking an nfsd
fs/nfsd/vfs.c +6
-1@@ -578,7 +579,12 @@ ssize_t nfsd_copy_file_range(struct file *src,u64 src_pos, struct file *dst, * limit like this and pipeline multiple COPY requests. */ count =min_t (u64, count,1 <<22 ); -return vfs_copy_file_range (src, src_pos, dst, dst_pos, count,0 ); + ret =vfs_copy_file_range (src, src_pos, dst, dst_pos, count,0 ); + +if (ret == -EOPNOTSUPP || ret == -EXDEV ) + ret =generic_copy_file_range (src, src_pos, dst, dst_pos, + count,0 ); +return ret; } __be32 nfsd4_vfs_fallocate(struct svc_rqst *rqstp, struct svc_fh*fhp,
fs/read_write.c +0
-6@@ -1388,28 +1388,6 @@ ssize_t generic_copy_file_range(struct file *file_in, loff_t pos_in, }EXPORT_SYMBOL (generic_copy_file_range); -static ssize_t do_copy_file_range (struct file *file_in,loff_t pos_in, -struct file *file_out,loff_t pos_out, -size_t len,unsigned int flags) -{ -/* -* Although we now allow filesystems to handle cross sb copy, passing
- * a file of the wrong filesystem type to filesystem driver
can resultfs/read_write.c +0
-3- * in an attempt to dereference the wrong type of ->private_data, so - * avoid doing that until we really have a good reason. NFSdefines
- * several differentfile_system_typestructures, but they all
end upfs/read_write.c +0
-4-* using the same ->copy_file_range() function pointer. -*/ -if (file_out->f_op->copy_file_range && - file_out->f_op->copy_file_range ==
file_in->f_op->copy_file_range)fs/read_write.c +0
-5-return file_out->f_op->copy_file_range (file_in, pos_in, - file_out, pos_out, - len, flags); - - return generic_copy_file_range(file_in, pos_in, file_out,
pos_out, len,fs/read_write.c +2
-3- flags); -} -/* * Performs necessary checks before doing a file copy * @@ -1427,6 +1405,25 @@ static int generic_copy_file_checks(struct file *file_in, loff_t pos_in, loff_t size_in;int ret; +/* +* Although we now allow filesystems to handle cross sb copy, passing
+ * a file of the wrong filesystem type to filesystem driver
can resultfs/read_write.c +2
-1+* in an attempt to dereference the wrong type of ->private_data, so +* avoid doing that until we really have a good reason. NFS defines
+ * several differentfile_system_typestructures, but they all
end upfs/read_write.c +6
-0+* using the same ->copy_file_range() function pointer. +*/ +if (file_out->f_op->copy_file_range) { +if (file_in->f_op->copy_file_range != + file_out->f_op->copy_file_range) +return -EXDEV ;Quoted 9 lines
fs/read_write.c static int generic_copy_file_checks(struct file *file_in, loff_t pos_in, · line 1422
Quoted 3 lines
fs/read_write.c +3
-0+ }else if (file_in->f_op->remap_file_range) { +if (file_inode (file_in)->i_sb !=file_inode (file_out)->i_sb) +return -EXDEV ;I think this check is redundant, it's done in
vfs_copy_file_range. If this check is removed then the else clause below should be removed also. Once this check and the else clause are removed then might as well move the the check ofcopy_file_rangefrom here tovfs_copy_file_range.I don't think it's really redundant, although I agree is messy due to the
fact we try to clone first instead of copying them.So, in the clone path, this is the only place where we return
-EXDEVif:1) we don't have ->copy_file_range *and*
2) we have ->remap_file_range but thei_sbare different.The check in
vfs_copy_file_range()is only executed if:1) we have *valid* ->copy_file_range ops and/or
2) we have *valid* ->remap_file_rangeSo... if we remove the check in
generic_copy_file_checks()as you suggest
and:
- we don't have ->copy_file_range,
- we have ->remap_file_range but
- thei_sbare differentQuoted 8 lines
Quoted 8 lines
Quoted 3 lines
we'll return the
-EOPNOTSUPP(the one set in line "ret =-EOPNOTSUPP;" in
functionvfs_copy_file_range()) instead of-EXDEV.Yes, this is the different.The NFS code handles both
-EOPNOTSUPPand-EXDEVVby doinggeneric_copy_file_range. Do any other consumers ofvfs_copy_file_rangerely on-EXDEVand not-EOPNOTSUPPand which is the correct error code for this case? It seems to me that-EOPNOTSUPPis more appropriate than EXDEV when (sb1 != sb2).EXDEV is the right code for:
filesystem supports the operation but not for sb1 != sb1.
Quoted 7 lines
Quoted 5 lines
So with the current patch, for a clone operation across 2 filesystems:
. if src and dst filesystem support both
copy_file_rangeand
map_file_rangethen the code returns-ENOTSUPPORT.Why do you say that?
Which code are you referring to exactly?
If the filesystems support both copy_file_range and map_file_range, it passes the check in generic_file_check but it fails with the check in vfs_copy_file_range and returns -ENOTSUPPORT (added by the v8 patch)
-Dai
Quoted 12 lines
Did you see this behavior in a test?
Quoted 5 lines
. if the filesystems only support
map_file_rangethen the
code returns-EXDEVThis seems confusing, shouldn't only 1 error code returned for this case?
From my read of the code, user will get
-EXDEVin both the cases you
listed.Thanks,
Amir.
A message that is not in the archive (sent off-list or not yet received): [email protected]
Re: [PATCH v8] vfs: fix copy_file_range regression in cross-fs copies
Quoted 234 lines · On Tue, Feb 23, 2021 at 7:31 PM <[email protected]> wrote:
On 2/23/21 8:57 AM, [email protected] wrote:
On 2/23/21 8:47 AM, Amir Goldstein wrote:
On Tue, Feb 23, 2021 at 6:02 PM <[email protected]> wrote:
On 2/23/21 7:29 AM, [email protected] wrote:
On 2/23/21 2:32 AM, Luis Henriques wrote:
On Mon, Feb 22, 2021 at 08:25:27AM -0800, [email protected] wrote:
On 2/22/21 2:24 AM, Luis Henriques wrote:
A regression has been reported by Nicolas Boichat, found while using the
copy_file_rangesyscall to copy a tracefs file. Before commit5dae222a5ff0("vfs: allowcopy_file_rangeto copy across devices") the kernel would return-EXDEVto userspace when trying to copy a file across
different filesystems. After this commit, the syscall doesn't fail anymore
and instead returns zero (zero bytes copied), as this file's content is
generated on-the-fly and thus reports a size of zero.This patch restores some cross-filesystem copy restrictions that existed
prior to commit5dae222a5ff0("vfs: allowcopy_file_rangeto copy across
devices"). Filesystems are still allowed to fall-back to the VFSgeneric_copy_file_range()implementation, but that has now to be done explicitly.nfsd is also modified to fall-back into
generic_copy_file_range()in casevfs_copy_file_range()fails with-EOPNOTSUPPor-EXDEV.Fixes 5dae222a5ff0 ("vfs: allow copy_file_range to copy acrossdevices")
Link:
https://urldefense.com/v3/__https://lore.kernel.org/linux-fsdevel/[email protected]/__;!!GqivPVa7Brio!P1UWThiSkxbjfjFQWNYJmCxGEkiLFyvHjH6cS-G1ZTt1z-TeqwGQgQmi49dC6w$
Link:
https://urldefense.com/v3/__https://lore.kernel.org/linux-fsdevel/CANMq1KDZuxir2LM5jOTm0xx*[email protected]/__;Kw!!GqivPVa7Brio!P1UWThiSkxbjfjFQWNYJmCxGEkiLFyvHjH6cS-G1ZTt1z-TeqwGQgQmgCmMHzA$
Link:
https://urldefense.com/v3/__https://lore.kernel.org/linux-fsdevel/20210126135012.1.If45b7cdc3ff707bc1efa17f5366057d60603c45f@changeid/__;!!GqivPVa7Brio!P1UWThiSkxbjfjFQWNYJmCxGEkiLFyvHjH6cS-G1ZTt1z-TeqwGQgQmzqItkrQ$Reported-by Nicolas Boichat <[email protected]>Signed-off-by Luis Henriques <[email protected]>---
Changes since v7
- set 'ret' to '-EOPNOTSUPP' before the clone 'if' statement so that the
error returned is always related to the 'copy' operation
Changes since v6
- restoredi_sbchecks for the clone operation
Changes since v5
- check if ->copy_file_range is NULL before calling it Changes since v4
- nfsd falls-back togeneric_copy_file_range()only *if* it gets-EOPNOTSUPP
or-EXDEV.
Changes since v3
- dropped theCOPY_FILE_SPLICEflag
- kept the f_op's checks early ingeneric_copy_file_checks, implementing
Amir's suggestions
- modified nfsd to usegeneric_copy_file_range()
Changes since v2
- do all the required checks earlier, ingeneric_copy_file_checks(),adding new checks for ->remap_file_range- new
COPY_FILE_SPLICEflag
- don't remove filesystem's fallback togeneric_copy_file_range()
- updated commit changelog (and subject)
Changes since v1 (after Amir review)
- restoreddo_copy_file_range()helper
- return-EOPNOTSUPPif fs doesn't implement CFR
- updated commit descriptionfs/nfsd/vfs.c | 8 +++++++- fs/read_write.c | 49 ++++++++++++++++++++++++------------------------- 2 files changed, 31 insertions(+), 26 deletions(-)fs/nfsd/vfs.c +1
-0@@ -568,6 +568,7 @@ __be32 nfsd4_clone_file_range(struct nfsd_file *nf_src, u64 src_pos, ssize_t nfsd_copy_file_range(struct file *src, u64 src_pos, struct file *dst, u64 dst_pos, u64 count) { +ssize_t ret;/* * Limit copy to 4MB to prevent indefinitely blocking an nfsd
fs/nfsd/vfs.c +6
-1@@ -578,7 +579,12 @@ ssize_t nfsd_copy_file_range(struct file *src,u64 src_pos, struct file *dst, * limit like this and pipeline multiple COPY requests. */ count =min_t (u64, count,1 <<22 ); -return vfs_copy_file_range (src, src_pos, dst, dst_pos, count,0 ); + ret =vfs_copy_file_range (src, src_pos, dst, dst_pos, count,0 ); + +if (ret == -EOPNOTSUPP || ret == -EXDEV ) + ret =generic_copy_file_range (src, src_pos, dst, dst_pos, + count,0 ); +return ret; } __be32 nfsd4_vfs_fallocate(struct svc_rqst *rqstp, struct svc_fh*fhp,
fs/read_write.c +0
-6@@ -1388,28 +1388,6 @@ ssize_t generic_copy_file_range(struct file *file_in, loff_t pos_in, }EXPORT_SYMBOL (generic_copy_file_range); -static ssize_t do_copy_file_range (struct file *file_in,loff_t pos_in, -struct file *file_out,loff_t pos_out, -size_t len,unsigned int flags) -{ -/* -* Although we now allow filesystems to handle cross sb copy, passing
- * a file of the wrong filesystem type to filesystem driver
can resultfs/read_write.c +0
-3- * in an attempt to dereference the wrong type of ->private_data, so - * avoid doing that until we really have a good reason. NFSdefines
- * several differentfile_system_typestructures, but they all
end upfs/read_write.c +0
-4-* using the same ->copy_file_range() function pointer. -*/ -if (file_out->f_op->copy_file_range && - file_out->f_op->copy_file_range ==
file_in->f_op->copy_file_range)fs/read_write.c +0
-5-return file_out->f_op->copy_file_range (file_in, pos_in, - file_out, pos_out, - len, flags); - - return generic_copy_file_range(file_in, pos_in, file_out,
pos_out, len,fs/read_write.c +2
-3- flags); -} -/* * Performs necessary checks before doing a file copy * @@ -1427,6 +1405,25 @@ static int generic_copy_file_checks(struct file *file_in, loff_t pos_in, loff_t size_in;int ret; +/* +* Although we now allow filesystems to handle cross sb copy, passing
+ * a file of the wrong filesystem type to filesystem driver
can resultfs/read_write.c +2
-1+* in an attempt to dereference the wrong type of ->private_data, so +* avoid doing that until we really have a good reason. NFS defines
+ * several differentfile_system_typestructures, but they all
end upfs/read_write.c +9
-0+* using the same ->copy_file_range() function pointer. +*/ +if (file_out->f_op->copy_file_range) { +if (file_in->f_op->copy_file_range != + file_out->f_op->copy_file_range) +return -EXDEV ; + }else if (file_in->f_op->remap_file_range) { +if (file_inode (file_in)->i_sb !=file_inode (file_out)->i_sb) +return -EXDEV ;I think this check is redundant, it's done in
vfs_copy_file_range. If this check is removed then the else clause below should be removed also. Once this check and the else clause are removed then might as well move the the check ofcopy_file_rangefrom here tovfs_copy_file_range.I don't think it's really redundant, although I agree is messy due to the
fact we try to clone first instead of copying them.So, in the clone path, this is the only place where we return
-EXDEVif:1) we don't have ->copy_file_range *and*
2) we have ->remap_file_range but thei_sbare different.The check in
vfs_copy_file_range()is only executed if:1) we have *valid* ->copy_file_range ops and/or
2) we have *valid* ->remap_file_rangeSo... if we remove the check in
generic_copy_file_checks()as you suggest
and:
- we don't have ->copy_file_range,
- we have ->remap_file_range but
- thei_sbare differentwe'll return the
-EOPNOTSUPP(the one set in line "ret =-EOPNOTSUPP;" in
functionvfs_copy_file_range()) instead of-EXDEV.Yes, this is the different.The NFS code handles both
-EOPNOTSUPPand-EXDEVVby doinggeneric_copy_file_range. Do any other consumers ofvfs_copy_file_rangerely on-EXDEVand not-EOPNOTSUPPand which is the correct error code for this case? It seems to me that-EOPNOTSUPPis more appropriate than EXDEV when (sb1 != sb2).EXDEV is the right code for:
filesystem supports the operation but not for sb1 != sb1.So with the current patch, for a clone operation across 2 filesystems:
. if src and dst filesystem support both
copy_file_rangeand
map_file_rangethen the code returns-ENOTSUPPORT.Why do you say that?
Which code are you referring to exactly?If the filesystems support both
copy_file_rangeandmap_file_range, it passes the check ingeneric_file_checkbut it fails with the check invfs_copy_file_rangeand returns-ENOTSUPPORT(added by the v8 patch)
Quoted 8 lines
Ok, I misread the code here. If it passes the check in
generic_copy_file_checksand it fails the sb check invfs_copy_file_rangethen it triescopy_file_rangeso it's ok.I think having the check in both
generic_copy_file_checksandvfs_copy_file_rangemaking the code hard to read. What's the reason not to do the check only invfs_copy_file_range?
You are going in circles.
I already answered that.
Please re-read the entire thread on all patch versions before commenting.
Thanks,
Amir.
[email protected]
reviewerRe: [PATCH v8] vfs: fix copy_file_range regression in cross-fs copies
Quoted 238 lines · Amir Goldstein
Quoted 237 lines · On Tue, Feb 23, 2021 at 7:31 PM <[email protected]> wrote:
On 2/23/21 8:57 AM, [email protected] wrote:
On 2/23/21 8:47 AM, Amir Goldstein wrote:
On Tue, Feb 23, 2021 at 6:02 PM <[email protected]> wrote:
On 2/23/21 7:29 AM, [email protected] wrote:
On 2/23/21 2:32 AM, Luis Henriques wrote:
On Mon, Feb 22, 2021 at 08:25:27AM -0800, [email protected] wrote:
On 2/22/21 2:24 AM, Luis Henriques wrote:
A regression has been reported by Nicolas Boichat, found while using the
copy_file_rangesyscall to copy a tracefs file. Before commit5dae222a5ff0("vfs: allowcopy_file_rangeto copy across devices") the kernel would return-EXDEVto userspace when trying to copy a file across
different filesystems. After this commit, the syscall doesn't fail anymore
and instead returns zero (zero bytes copied), as this file's content is
generated on-the-fly and thus reports a size of zero.This patch restores some cross-filesystem copy restrictions that existed
prior to commit5dae222a5ff0("vfs: allowcopy_file_rangeto copy across
devices"). Filesystems are still allowed to fall-back to the VFSgeneric_copy_file_range()implementation, but that has now to be done explicitly.nfsd is also modified to fall-back into
generic_copy_file_range()in casevfs_copy_file_range()fails with-EOPNOTSUPPor-EXDEV.Fixes 5dae222a5ff0 ("vfs: allow copy_file_range to copy acrossdevices")
Link:
https://urldefense.com/v3/__https://lore.kernel.org/linux-fsdevel/[email protected]/__;!!GqivPVa7Brio!P1UWThiSkxbjfjFQWNYJmCxGEkiLFyvHjH6cS-G1ZTt1z-TeqwGQgQmi49dC6w$
Link:
https://urldefense.com/v3/__https://lore.kernel.org/linux-fsdevel/CANMq1KDZuxir2LM5jOTm0xx*[email protected]/__;Kw!!GqivPVa7Brio!P1UWThiSkxbjfjFQWNYJmCxGEkiLFyvHjH6cS-G1ZTt1z-TeqwGQgQmgCmMHzA$
Link:
https://urldefense.com/v3/__https://lore.kernel.org/linux-fsdevel/20210126135012.1.If45b7cdc3ff707bc1efa17f5366057d60603c45f@changeid/__;!!GqivPVa7Brio!P1UWThiSkxbjfjFQWNYJmCxGEkiLFyvHjH6cS-G1ZTt1z-TeqwGQgQmzqItkrQ$Reported-by Nicolas Boichat <[email protected]>Signed-off-by Luis Henriques <[email protected]>---
Changes since v7
- set 'ret' to '-EOPNOTSUPP' before the clone 'if' statement so that the
error returned is always related to the 'copy' operation
Changes since v6
- restoredi_sbchecks for the clone operation
Changes since v5
- check if ->copy_file_range is NULL before calling it Changes since v4
- nfsd falls-back togeneric_copy_file_range()only *if* it gets-EOPNOTSUPP
or-EXDEV.
Changes since v3
- dropped theCOPY_FILE_SPLICEflag
- kept the f_op's checks early ingeneric_copy_file_checks, implementing
Amir's suggestions
- modified nfsd to usegeneric_copy_file_range()
Changes since v2
- do all the required checks earlier, ingeneric_copy_file_checks(),adding new checks for ->remap_file_range- new
COPY_FILE_SPLICEflag
- don't remove filesystem's fallback togeneric_copy_file_range()
- updated commit changelog (and subject)
Changes since v1 (after Amir review)
- restoreddo_copy_file_range()helper
- return-EOPNOTSUPPif fs doesn't implement CFR
- updated commit descriptionfs/nfsd/vfs.c | 8 +++++++- fs/read_write.c | 49 ++++++++++++++++++++++++------------------------- 2 files changed, 31 insertions(+), 26 deletions(-)fs/nfsd/vfs.c +1
-0@@ -568,6 +568,7 @@ __be32 nfsd4_clone_file_range(struct nfsd_file *nf_src, u64 src_pos, ssize_t nfsd_copy_file_range(struct file *src, u64 src_pos, struct file *dst, u64 dst_pos, u64 count) { +ssize_t ret;/* * Limit copy to 4MB to prevent indefinitely blocking an nfsd
fs/nfsd/vfs.c +6
-1@@ -578,7 +579,12 @@ ssize_t nfsd_copy_file_range(struct file *src,u64 src_pos, struct file *dst, * limit like this and pipeline multiple COPY requests. */ count =min_t (u64, count,1 <<22 ); -return vfs_copy_file_range (src, src_pos, dst, dst_pos, count,0 ); + ret =vfs_copy_file_range (src, src_pos, dst, dst_pos, count,0 ); + +if (ret == -EOPNOTSUPP || ret == -EXDEV ) + ret =generic_copy_file_range (src, src_pos, dst, dst_pos, + count,0 ); +return ret; } __be32 nfsd4_vfs_fallocate(struct svc_rqst *rqstp, struct svc_fh*fhp,
fs/read_write.c +0
-6@@ -1388,28 +1388,6 @@ ssize_t generic_copy_file_range(struct file *file_in, loff_t pos_in, }EXPORT_SYMBOL (generic_copy_file_range); -static ssize_t do_copy_file_range (struct file *file_in,loff_t pos_in, -struct file *file_out,loff_t pos_out, -size_t len,unsigned int flags) -{ -/* -* Although we now allow filesystems to handle cross sb copy, passing
- * a file of the wrong filesystem type to filesystem driver
can resultfs/read_write.c +0
-3- * in an attempt to dereference the wrong type of ->private_data, so - * avoid doing that until we really have a good reason. NFSdefines
- * several differentfile_system_typestructures, but they all
end upfs/read_write.c +0
-4-* using the same ->copy_file_range() function pointer. -*/ -if (file_out->f_op->copy_file_range && - file_out->f_op->copy_file_range ==
file_in->f_op->copy_file_range)fs/read_write.c +0
-5-return file_out->f_op->copy_file_range (file_in, pos_in, - file_out, pos_out, - len, flags); - - return generic_copy_file_range(file_in, pos_in, file_out,
pos_out, len,fs/read_write.c +2
-3- flags); -} -/* * Performs necessary checks before doing a file copy * @@ -1427,6 +1405,25 @@ static int generic_copy_file_checks(struct file *file_in, loff_t pos_in, loff_t size_in;int ret; +/* +* Although we now allow filesystems to handle cross sb copy, passing
+ * a file of the wrong filesystem type to filesystem driver
can resultfs/read_write.c +2
-1+* in an attempt to dereference the wrong type of ->private_data, so +* avoid doing that until we really have a good reason. NFS defines
+ * several differentfile_system_typestructures, but they all
end upfs/read_write.c +9
-0+* using the same ->copy_file_range() function pointer. +*/ +if (file_out->f_op->copy_file_range) { +if (file_in->f_op->copy_file_range != + file_out->f_op->copy_file_range) +return -EXDEV ; + }else if (file_in->f_op->remap_file_range) { +if (file_inode (file_in)->i_sb !=file_inode (file_out)->i_sb) +return -EXDEV ;I think this check is redundant, it's done in
vfs_copy_file_range. If this check is removed then the else clause below should be removed also. Once this check and the else clause are removed then might as well move the the check ofcopy_file_rangefrom here tovfs_copy_file_range.I don't think it's really redundant, although I agree is messy due to the
fact we try to clone first instead of copying them.So, in the clone path, this is the only place where we return
-EXDEVif:1) we don't have ->copy_file_range *and*
2) we have ->remap_file_range but thei_sbare different.The check in
vfs_copy_file_range()is only executed if:1) we have *valid* ->copy_file_range ops and/or
2) we have *valid* ->remap_file_rangeSo... if we remove the check in
generic_copy_file_checks()as you suggest
and:
- we don't have ->copy_file_range,
- we have ->remap_file_range but
- thei_sbare differentwe'll return the
-EOPNOTSUPP(the one set in line "ret =-EOPNOTSUPP;" in
functionvfs_copy_file_range()) instead of-EXDEV.Yes, this is the different.The NFS code handles both
-EOPNOTSUPPand-EXDEVVby doinggeneric_copy_file_range. Do any other consumers ofvfs_copy_file_rangerely on-EXDEVand not-EOPNOTSUPPand which is the correct error code for this case? It seems to me that-EOPNOTSUPPis more appropriate than EXDEV when (sb1 != sb2).EXDEV is the right code for:
filesystem supports the operation but not for sb1 != sb1.So with the current patch, for a clone operation across 2 filesystems:
. if src and dst filesystem support both
copy_file_rangeand
map_file_rangethen the code returns-ENOTSUPPORT.Why do you say that?
Which code are you referring to exactly?If the filesystems support both
copy_file_rangeandmap_file_range, it passes the check ingeneric_file_checkbut it fails with the check invfs_copy_file_rangeand returns-ENOTSUPPORT(added by the v8 patch)Ok, I misread the code here. If it passes the check in
generic_copy_file_checksand it fails the sb check invfs_copy_file_rangethen it triescopy_file_rangeso it's ok.
Quoted 7 lines
Quoted 4 lines
I think having the check in both
generic_copy_file_checksandvfs_copy_file_rangemaking the code hard to read. What's the reason not to do the check only invfs_copy_file_range?You are going in circles.
I already answered that.
Please re-read the entire thread on all patch versions before commenting.
I'm fine with the patch as it is, as long as it does not break NFS.
I just think it's easier to read if the checks are done in vfs_copy_file_range such as:
@@ -1495,6 +1473,11 @@ ssize_t vfs_copy_file_range(struct file *file_in, loff_t pos_in,
file_start_write(file_out);
+ if (file_out->f_op->copy_file_range == NULL &&
+ file_in->f_op->remap_file_range == NULL)
+ return -EOPNOTSUPP; /* not sure this error is needed */
+
+ ret = -EXDEV;
/*
* Try cloning first, this is supported by more file systems, and
* more efficient if both clone and copy are supported (e.g. NFS).
@@ -1513,9 +1496,10 @@ ssize_t vfs_copy_file_range(struct file *file_in, loff_t pos_in,
}
}- ret = do_copy_file_range(file_in, pos_in, file_out, pos_out, len,
- flags);
- WARN_ON_ONCE(ret == -EOPNOTSUPP);
+ if (file_out->f_op->copy_file_range &&
+ file_out->f_op->copy_file_range == file_in->f_op->copy_file_range) {
+ ret = file_out->f_op->copy_file_range(file_in, pos_in,
+ file_out, pos_out, len, flags);
done:
if (ret > 0) {
fsnotify_access(file_in);Thanks,
-Dai
Quoted 3 lines
Thanks,
Amir.
Re: [PATCH v8] vfs: fix copy_file_range regression in cross-fs copies
In reply to [email protected]Quoted 213 lines · On Tue, Feb 23, 2021 at 08:57:38AM -0800, [email protected] wrote:
Quoted 211 lines · Amir Goldstein
Quoted 194 lines · On Tue, Feb 23, 2021 at 6:02 PM <[email protected]> wrote:
Quoted 192 lines · On 2/23/21 7:29 AM, [email protected] wrote:
Quoted 191 lines · Luis Henriques
Quoted 160 lines · On Mon, Feb 22, 2021 at 08:25:27AM -0800, [email protected] wrote:
Quoted 159 lines · Luis Henriques
A regression has been reported by Nicolas Boichat, found while using the
copy_file_rangesyscall to copy a tracefs file. Before commit5dae222a5ff0("vfs: allowcopy_file_rangeto copy across devices") the kernel would return-EXDEVto userspace when trying to copy a file across
different filesystems. After this commit, the syscall doesn't fail anymore
and instead returns zero (zero bytes copied), as this file's content is
generated on-the-fly and thus reports a size of zero.This patch restores some cross-filesystem copy restrictions that existed
prior to commit5dae222a5ff0("vfs: allowcopy_file_rangeto copy across
devices"). Filesystems are still allowed to fall-back to the VFSgeneric_copy_file_range()implementation, but that has now to be done explicitly.nfsd is also modified to fall-back into
generic_copy_file_range()in casevfs_copy_file_range()fails with-EOPNOTSUPPor-EXDEV.Fixes 5dae222a5ff0 ("vfs: allow copy_file_range to copy acrossdevices")
Link:
https://urldefense.com/v3/__https://lore.kernel.org/linux-fsdevel/[email protected]/__;!!GqivPVa7Brio!P1UWThiSkxbjfjFQWNYJmCxGEkiLFyvHjH6cS-G1ZTt1z-TeqwGQgQmi49dC6w$
Link:
https://urldefense.com/v3/__https://lore.kernel.org/linux-fsdevel/CANMq1KDZuxir2LM5jOTm0xx*[email protected]/__;Kw!!GqivPVa7Brio!P1UWThiSkxbjfjFQWNYJmCxGEkiLFyvHjH6cS-G1ZTt1z-TeqwGQgQmgCmMHzA$
Link:
https://urldefense.com/v3/__https://lore.kernel.org/linux-fsdevel/20210126135012.1.If45b7cdc3ff707bc1efa17f5366057d60603c45f@changeid/__;!!GqivPVa7Brio!P1UWThiSkxbjfjFQWNYJmCxGEkiLFyvHjH6cS-G1ZTt1z-TeqwGQgQmzqItkrQ$Reported-by Nicolas Boichat <[email protected]>Signed-off-by Luis Henriques <[email protected]>---
Changes since v7
- set 'ret' to '-EOPNOTSUPP' before the clone 'if' statement so that the
error returned is always related to the 'copy' operation
Changes since v6
- restoredi_sbchecks for the clone operation
Changes since v5
- check if ->copy_file_range is NULL before calling it Changes since v4
- nfsd falls-back togeneric_copy_file_range()only *if* it gets-EOPNOTSUPP
or-EXDEV.
Changes since v3
- dropped theCOPY_FILE_SPLICEflag
- kept the f_op's checks early ingeneric_copy_file_checks, implementing
Amir's suggestions
- modified nfsd to usegeneric_copy_file_range()
Changes since v2
- do all the required checks earlier, ingeneric_copy_file_checks(),adding new checks for ->remap_file_range- new
COPY_FILE_SPLICEflag
- don't remove filesystem's fallback togeneric_copy_file_range()
- updated commit changelog (and subject)
Changes since v1 (after Amir review)
- restoreddo_copy_file_range()helper
- return-EOPNOTSUPPif fs doesn't implement CFR
- updated commit descriptionfs/nfsd/vfs.c | 8 +++++++- fs/read_write.c | 49 ++++++++++++++++++++++++------------------------- 2 files changed, 31 insertions(+), 26 deletions(-)fs/nfsd/vfs.c +1
-0@@ -568,6 +568,7 @@ __be32 nfsd4_clone_file_range(struct nfsd_file *nf_src, u64 src_pos, ssize_t nfsd_copy_file_range(struct file *src, u64 src_pos, struct file *dst, u64 dst_pos, u64 count) { +ssize_t ret;/* * Limit copy to 4MB to prevent indefinitely blocking an nfsd
fs/nfsd/vfs.c +6
-1@@ -578,7 +579,12 @@ ssize_t nfsd_copy_file_range(struct file *src,u64 src_pos, struct file *dst, * limit like this and pipeline multiple COPY requests. */ count =min_t (u64, count,1 <<22 ); -return vfs_copy_file_range (src, src_pos, dst, dst_pos, count,0 ); + ret =vfs_copy_file_range (src, src_pos, dst, dst_pos, count,0 ); + +if (ret == -EOPNOTSUPP || ret == -EXDEV ) + ret =generic_copy_file_range (src, src_pos, dst, dst_pos, + count,0 ); +return ret; } __be32 nfsd4_vfs_fallocate(struct svc_rqst *rqstp, struct svc_fh*fhp,
fs/read_write.c +0
-6@@ -1388,28 +1388,6 @@ ssize_t generic_copy_file_range(struct file *file_in, loff_t pos_in, }EXPORT_SYMBOL (generic_copy_file_range); -static ssize_t do_copy_file_range (struct file *file_in,loff_t pos_in, -struct file *file_out,loff_t pos_out, -size_t len,unsigned int flags) -{ -/* -* Although we now allow filesystems to handle cross sb copy, passing
- * a file of the wrong filesystem type to filesystem driver
can resultfs/read_write.c +0
-3- * in an attempt to dereference the wrong type of ->private_data, so - * avoid doing that until we really have a good reason. NFSdefines
- * several differentfile_system_typestructures, but they all
end upfs/read_write.c +0
-4-* using the same ->copy_file_range() function pointer. -*/ -if (file_out->f_op->copy_file_range && - file_out->f_op->copy_file_range ==
file_in->f_op->copy_file_range)fs/read_write.c +0
-5-return file_out->f_op->copy_file_range (file_in, pos_in, - file_out, pos_out, - len, flags); - - return generic_copy_file_range(file_in, pos_in, file_out,
pos_out, len,fs/read_write.c +2
-3- flags); -} -/* * Performs necessary checks before doing a file copy * @@ -1427,6 +1405,25 @@ static int generic_copy_file_checks(struct file *file_in, loff_t pos_in, loff_t size_in;int ret; +/* +* Although we now allow filesystems to handle cross sb copy, passing
+ * a file of the wrong filesystem type to filesystem driver
can resultfs/read_write.c +2
-1+* in an attempt to dereference the wrong type of ->private_data, so +* avoid doing that until we really have a good reason. NFS defines
+ * several differentfile_system_typestructures, but they all
end upfs/read_write.c +6
-0+* using the same ->copy_file_range() function pointer. +*/ +if (file_out->f_op->copy_file_range) { +if (file_in->f_op->copy_file_range != + file_out->f_op->copy_file_range) +return -EXDEV ;Quoted 9 lines
fs/read_write.c
Quoted 3 lines
fs/read_write.c +3
-0+ }else if (file_in->f_op->remap_file_range) { +if (file_inode (file_in)->i_sb !=file_inode (file_out)->i_sb) +return -EXDEV ;I think this check is redundant, it's done in
vfs_copy_file_range. If this check is removed then the else clause below should be removed also. Once this check and the else clause are removed then might as well move the the check ofcopy_file_rangefrom here tovfs_copy_file_range.I don't think it's really redundant, although I agree is messy due to the
fact we try to clone first instead of copying them.So, in the clone path, this is the only place where we return
-EXDEVif:1) we don't have ->copy_file_range *and*
2) we have ->remap_file_range but thei_sbare different.The check in
vfs_copy_file_range()is only executed if:1) we have *valid* ->copy_file_range ops and/or
2) we have *valid* ->remap_file_rangeSo... if we remove the check in
generic_copy_file_checks()as you suggest
and:
- we don't have ->copy_file_range,
- we have ->remap_file_range but
- thei_sbare differentQuoted 8 lines
Quoted 8 lines
Quoted 3 lines
we'll return the
-EOPNOTSUPP(the one set in line "ret =-EOPNOTSUPP;" in
functionvfs_copy_file_range()) instead of-EXDEV.Yes, this is the different.The NFS code handles both
-EOPNOTSUPPand-EXDEVVby doinggeneric_copy_file_range. Do any other consumers ofvfs_copy_file_rangerely on-EXDEVand not-EOPNOTSUPPand which is the correct error code for this case? It seems to me that-EOPNOTSUPPis more appropriate than EXDEV when (sb1 != sb2).EXDEV is the right code for:
filesystem supports the operation but not for sb1 != sb1.Quoted 5 lines
So with the current patch, for a clone operation across 2 filesystems:
. if src and dst filesystem support both
copy_file_rangeand
map_file_rangethen the code returns-ENOTSUPPORT.
Quoted 7 lines
Quoted 2 lines
Why do you say that?
Which code are you referring to exactly?If the filesystems support both
copy_file_rangeandmap_file_range, it passes the check ingeneric_file_checkbut it fails with the check invfs_copy_file_rangeand returns-ENOTSUPPORT(added by the v8 patch)
I'm sorry but I can't simply see where this can happen. If both syscalls are present (and all other checks pass), the code will first try the ->map_file_range. If that succeeds, it bails out; if that fails, it tries the ->copy_file_range. The -ENOTSUPPORT is just there for the case the ->map_file_range fails and ->copy_file_range isn't implemented.
[ <sigh> It would be so much easier if we didn't attempt to clone. ]
But as I said previously, I'm way beyond embarrassment now as I failed to see too many obvious mistakes in previous versions :-)
Cheers,
--
Luís
Re: [PATCH v8] vfs: fix copy_file_range regression in cross-fs copies
In reply to [email protected]Quoted 200 lines · On Tue, Feb 23, 2021 at 11:03 AM <[email protected]> wrote:
Quoted 197 lines · On 2/23/21 7:29 AM, [email protected] wrote:
Quoted 194 lines · Luis Henriques
Quoted 160 lines · On Mon, Feb 22, 2021 at 08:25:27AM -0800, [email protected] wrote:
Quoted 159 lines · Luis Henriques
A regression has been reported by Nicolas Boichat, found while using the
copy_file_rangesyscall to copy a tracefs file. Before commit5dae222a5ff0("vfs: allowcopy_file_rangeto copy across devices") the kernel would return-EXDEVto userspace when trying to copy a file across
different filesystems. After this commit, the syscall doesn't fail anymore
and instead returns zero (zero bytes copied), as this file's content is
generated on-the-fly and thus reports a size of zero.This patch restores some cross-filesystem copy restrictions that existed
prior to commit5dae222a5ff0("vfs: allowcopy_file_rangeto copy across
devices"). Filesystems are still allowed to fall-back to the VFSgeneric_copy_file_range()implementation, but that has now to be done explicitly.nfsd is also modified to fall-back into
generic_copy_file_range()in casevfs_copy_file_range()fails with-EOPNOTSUPPor-EXDEV.Fixes 5dae222a5ff0 ("vfs: allow copy_file_range to copy acrossdevices")
Link:
https://urldefense.com/v3/__https://lore.kernel.org/linux-fsdevel/[email protected]/__;!!GqivPVa7Brio!P1UWThiSkxbjfjFQWNYJmCxGEkiLFyvHjH6cS-G1ZTt1z-TeqwGQgQmi49dC6w$
Link:
https://urldefense.com/v3/__https://lore.kernel.org/linux-fsdevel/CANMq1KDZuxir2LM5jOTm0xx*[email protected]/__;Kw!!GqivPVa7Brio!P1UWThiSkxbjfjFQWNYJmCxGEkiLFyvHjH6cS-G1ZTt1z-TeqwGQgQmgCmMHzA$
Link:
https://urldefense.com/v3/__https://lore.kernel.org/linux-fsdevel/20210126135012.1.If45b7cdc3ff707bc1efa17f5366057d60603c45f@changeid/__;!!GqivPVa7Brio!P1UWThiSkxbjfjFQWNYJmCxGEkiLFyvHjH6cS-G1ZTt1z-TeqwGQgQmzqItkrQ$Reported-by Nicolas Boichat <[email protected]>Signed-off-by Luis Henriques <[email protected]>---
Changes since v7
- set 'ret' to '-EOPNOTSUPP' before the clone 'if' statement so that the
error returned is always related to the 'copy' operation
Changes since v6
- restoredi_sbchecks for the clone operation
Changes since v5
- check if ->copy_file_range is NULL before calling it Changes since v4
- nfsd falls-back togeneric_copy_file_range()only *if* it gets-EOPNOTSUPP
or-EXDEV.
Changes since v3
- dropped theCOPY_FILE_SPLICEflag
- kept the f_op's checks early ingeneric_copy_file_checks, implementing
Amir's suggestions
- modified nfsd to usegeneric_copy_file_range()
Changes since v2
- do all the required checks earlier, ingeneric_copy_file_checks(),adding new checks for ->remap_file_range- new
COPY_FILE_SPLICEflag
- don't remove filesystem's fallback togeneric_copy_file_range()
- updated commit changelog (and subject)
Changes since v1 (after Amir review)
- restoreddo_copy_file_range()helper
- return-EOPNOTSUPPif fs doesn't implement CFR
- updated commit descriptionfs/nfsd/vfs.c | 8 +++++++- fs/read_write.c | 49 ++++++++++++++++++++++++------------------------- 2 files changed, 31 insertions(+), 26 deletions(-)fs/nfsd/vfs.c +1
-0@@ -568,6 +568,7 @@ __be32 nfsd4_clone_file_range(struct nfsd_file *nf_src, u64 src_pos, ssize_t nfsd_copy_file_range(struct file *src, u64 src_pos, struct file *dst, u64 dst_pos, u64 count) { +ssize_t ret;/* * Limit copy to 4MB to prevent indefinitely blocking an nfsd
fs/nfsd/vfs.c +6
-1@@ -578,7 +579,12 @@ ssize_t nfsd_copy_file_range(struct file *src,u64 src_pos, struct file *dst, * limit like this and pipeline multiple COPY requests. */ count =min_t (u64, count,1 <<22 ); -return vfs_copy_file_range (src, src_pos, dst, dst_pos, count,0 ); + ret =vfs_copy_file_range (src, src_pos, dst, dst_pos, count,0 ); + +if (ret == -EOPNOTSUPP || ret == -EXDEV ) + ret =generic_copy_file_range (src, src_pos, dst, dst_pos, + count,0 ); +return ret; } __be32 nfsd4_vfs_fallocate(struct svc_rqst *rqstp, struct svc_fh*fhp,
fs/read_write.c +0
-6@@ -1388,28 +1388,6 @@ ssize_t generic_copy_file_range(struct file *file_in, loff_t pos_in, }EXPORT_SYMBOL (generic_copy_file_range); -static ssize_t do_copy_file_range (struct file *file_in,loff_t pos_in, -struct file *file_out,loff_t pos_out, -size_t len,unsigned int flags) -{ -/* -* Although we now allow filesystems to handle cross sb copy, passing
- * a file of the wrong filesystem type to filesystem driver
can resultfs/read_write.c +0
-3- * in an attempt to dereference the wrong type of ->private_data, so - * avoid doing that until we really have a good reason. NFSdefines
- * several differentfile_system_typestructures, but they all
end upfs/read_write.c +0
-4-* using the same ->copy_file_range() function pointer. -*/ -if (file_out->f_op->copy_file_range && - file_out->f_op->copy_file_range ==
file_in->f_op->copy_file_range)fs/read_write.c +0
-5-return file_out->f_op->copy_file_range (file_in, pos_in, - file_out, pos_out, - len, flags); - - return generic_copy_file_range(file_in, pos_in, file_out,
pos_out, len,fs/read_write.c +2
-3- flags); -} -/* * Performs necessary checks before doing a file copy * @@ -1427,6 +1405,25 @@ static int generic_copy_file_checks(struct file *file_in, loff_t pos_in, loff_t size_in;int ret; +/* +* Although we now allow filesystems to handle cross sb copy, passing
+ * a file of the wrong filesystem type to filesystem driver
can resultfs/read_write.c +2
-1+* in an attempt to dereference the wrong type of ->private_data, so +* avoid doing that until we really have a good reason. NFS defines
+ * several differentfile_system_typestructures, but they all
end upfs/read_write.c +6
-0+* using the same ->copy_file_range() function pointer. +*/ +if (file_out->f_op->copy_file_range) { +if (file_in->f_op->copy_file_range != + file_out->f_op->copy_file_range) +return -EXDEV ;Quoted 9 lines
fs/read_write.c static int generic_copy_file_checks(struct file *file_in, loff_t pos_in, · line 1422
Quoted 3 lines
fs/read_write.c +3
-0+ }else if (file_in->f_op->remap_file_range) { +if (file_inode (file_in)->i_sb !=file_inode (file_out)->i_sb) +return -EXDEV ;I think this check is redundant, it's done in
vfs_copy_file_range. If this check is removed then the else clause below should be removed also. Once this check and the else clause are removed then might as well move the the check ofcopy_file_rangefrom here tovfs_copy_file_range.I don't think it's really redundant, although I agree is messy due to the
fact we try to clone first instead of copying them.So, in the clone path, this is the only place where we return
-EXDEVif:1) we don't have ->copy_file_range *and*
2) we have ->remap_file_range but thei_sbare different.The check in
vfs_copy_file_range()is only executed if:1) we have *valid* ->copy_file_range ops and/or
2) we have *valid* ->remap_file_rangeSo... if we remove the check in
generic_copy_file_checks()as you suggest
and:
- we don't have ->copy_file_range,
- we have ->remap_file_range but
- thei_sbare differentwe'll return the
-EOPNOTSUPP(the one set in line "ret =-EOPNOTSUPP;" in
functionvfs_copy_file_range()) instead of-EXDEV.
Quoted 7 lines
Quoted 5 lines
Yes, this is the different.The NFS code handles both
-EOPNOTSUPPand-EXDEVVby doinggeneric_copy_file_range. Do any other consumers ofvfs_copy_file_rangerely on-EXDEVand not-EOPNOTSUPPand which is the correct error code for this case? It seems to me that-EOPNOTSUPPis more appropriate than EXDEV when (sb1 != sb2).So with the current patch, for a clone operation across 2 filesystems:
Wait, I can't get passed "a clone operation across 2 filesystems", I thought there are not any options. It's not allowed? Then we go do try the copy. Those are two different steps so errors code might be different.
Quoted 56 lines
. if src and dst filesystem support both
copy_file_rangeand
map_file_rangethen the code returns-ENOTSUPPORT.. if the filesystems only support
map_file_rangethen the
code returns-EXDEVThis seems confusing, shouldn't only 1 error code returned for this case?
-Dai
Quoted 46 lines
Quoted 4 lines
But I may have got it all wrong. I've looked so many times at this code that I'm probably useless at finding problems in it :-)
You're not alone, we all try to do the right thing :-)
-Dai
Quoted 37 lines
Cheers,
--
LuísQuoted 32 lines
-Dai
Quoted 30 lines
fs/read_write.c +5
-0+ }else { +return -EOPNOTSUPP ; + } + ret =generic_file_rw_checks (file_in, file_out);if (ret)return ret;@@ -1495,6 +1492,7 @@ ssize_t vfs_copy_file_range(struct file *file_in, loff_t pos_in,file_start_write (file_out); + ret = -EOPNOTSUPP ;/* * Try cloning first, this is supported by more file systems, and
* more efficient if both clone and copy are supported (e.g.
NFS).fs/read_write.c +4
-3@@ -1513,9 +1511,10 @@ ssize_t vfs_copy_file_range(struct file *file_in, loff_t pos_in, } } - ret =do_copy_file_range (file_in, pos_in, file_out, pos_out, len, - flags); -WARN_ON_ONCE (ret == -EOPNOTSUPP ); +if (file_out->f_op->copy_file_range) + ret = file_out->f_op->copy_file_range (file_in, pos_in, + file_out, pos_out, + len, flags); done:if (ret >0 ) {fsnotify_access (file_in);
Re: [PATCH v8] vfs: fix copy_file_range regression in cross-fs copies
In reply to Luis HenriquesQuoted 18 lines · Luis Henriques
A regression has been reported by Nicolas Boichat, found while using the
copy_file_rangesyscall to copy a tracefs file. Before commit5dae222a5ff0("vfs: allowcopy_file_rangeto copy across devices") the kernel would return-EXDEVto userspace when trying to copy a file across different filesystems. After this commit, the syscall doesn't fail anymore and instead returns zero (zero bytes copied), as this file's content is generated on-the-fly and thus reports a size of zero.This patch restores some cross-filesystem copy restrictions that existed prior to commit
5dae222a5ff0("vfs: allowcopy_file_rangeto copy across devices"). Filesystems are still allowed to fall-back to the VFSgeneric_copy_file_range()implementation, but that has now to be done explicitly.nfsd is also modified to fall-back into
generic_copy_file_range()in casevfs_copy_file_range()fails with-EOPNOTSUPPor-EXDEV.
Quoted 6 lines
Fixes 5dae222a5ff0 ("vfs: allow copy_file_range to copy across devices")Link https://lore.kernel.org/linux-fsdevel/CANMq1KDZuxir2LM5jOTm0xx+BnvW=ZmpsG47CyHFJwnw7zSX6Q@mail.gmail.com/ open hereLink https://lore.kernel.org/linux-fsdevel/20210126135012.1.If45b7cdc3ff707bc1efa17f5366057d60603c45f@changeid/ open hereReported-by Nicolas Boichat <[email protected]>Signed-off-by Luis Henriques <[email protected]>
I tested v8 and I believe it works for NFS.
Quoted 138 lines
---
Changes since v7
- set 'ret' to '-EOPNOTSUPP' before the clone 'if' statement so that the error returned is always related to the 'copy' operation
Changes since v6
- restoredi_sbchecks for the clone operation
Changes since v5
- check if ->copy_file_range is NULL before calling it
Changes since v4
- nfsd falls-back togeneric_copy_file_range()only *if* it gets-EOPNOTSUPPor-EXDEV.
Changes since v3
- dropped theCOPY_FILE_SPLICEflag
- kept the f_op's checks early ingeneric_copy_file_checks, implementing Amir's suggestions
- modified nfsd to usegeneric_copy_file_range()
Changes since v2
- do all the required checks earlier, ingeneric_copy_file_checks(), adding new checks for ->remap_file_range
- newCOPY_FILE_SPLICEflag
- don't remove filesystem's fallback togeneric_copy_file_range()
- updated commit changelog (and subject)
Changes since v1 (after Amir review)
- restoreddo_copy_file_range()helper
- return-EOPNOTSUPPif fs doesn't implement CFR
- updated commit descriptionfs/nfsd/vfs.c | 8 +++++++- fs/read_write.c | 49 ++++++++++++++++++++++++------------------------- 2 files changed, 31 insertions(+), 26 deletions(-)fs/nfsd/vfs.c +7
-1@@ -568,6 +568,7 @@ __be32 nfsd4_clone_file_range(struct nfsd_file *nf_src, u64 src_pos,ssize_t nfsd_copy_file_range (struct file *src,u64 src_pos,struct file *dst,u64 dst_pos,u64 count) { +ssize_t ret;/* * Limit copy to 4MB to prevent indefinitely blocking an nfsd @@ -578,7 +579,12 @@ ssize_t nfsd_copy_file_range(struct file *src, u64 src_pos, struct file *dst,* limit like this and pipeline multiple COPY requests. */ count =min_t (u64, count,1 <<22 ); -return vfs_copy_file_range (src, src_pos, dst, dst_pos, count,0 ); + ret =vfs_copy_file_range (src, src_pos, dst, dst_pos, count,0 ); + +if (ret == -EOPNOTSUPP || ret == -EXDEV ) + ret =generic_copy_file_range (src, src_pos, dst, dst_pos, + count,0 ); +return ret; } __be32 nfsd4_vfs_fallocate(struct svc_rqst *rqstp, struct svc_fh *fhp,fs/read_write.c +24
-25@@ -1388,28 +1388,6 @@ ssize_t generic_copy_file_range(struct file *file_in, loff_t pos_in, }EXPORT_SYMBOL (generic_copy_file_range); -static ssize_t do_copy_file_range (struct file *file_in,loff_t pos_in, -struct file *file_out,loff_t pos_out, -size_t len,unsigned int flags) -{ -/* -* Although we now allow filesystems to handle cross sb copy, passing -* a file of the wrong filesystem type to filesystem driver can result -* in an attempt to dereference the wrong type of ->private_data, so -* avoid doing that until we really have a good reason. NFS defines -* several different file_system_type structures, but they all end up -* using the same ->copy_file_range() function pointer. -*/ -if (file_out->f_op->copy_file_range && - file_out->f_op->copy_file_range == file_in->f_op->copy_file_range) -return file_out->f_op->copy_file_range (file_in, pos_in, - file_out, pos_out, - len, flags); - -return generic_copy_file_range (file_in, pos_in, file_out, pos_out, len, - flags); -} -/* * Performs necessary checks before doing a file copy * @@ -1427,6 +1405,25 @@ static int generic_copy_file_checks(struct file *file_in, loff_t pos_in,loff_t size_in;int ret; +/* +* Although we now allow filesystems to handle cross sb copy, passing +* a file of the wrong filesystem type to filesystem driver can result +* in an attempt to dereference the wrong type of ->private_data, so +* avoid doing that until we really have a good reason. NFS defines +* several different file_system_type structures, but they all end up +* using the same ->copy_file_range() function pointer. +*/ +if (file_out->f_op->copy_file_range) { +if (file_in->f_op->copy_file_range != + file_out->f_op->copy_file_range) +return -EXDEV ; + }else if (file_in->f_op->remap_file_range) { +if (file_inode (file_in)->i_sb !=file_inode (file_out)->i_sb) +return -EXDEV ; + }else { +return -EOPNOTSUPP ; + } + ret =generic_file_rw_checks (file_in, file_out);if (ret)return ret;@@ -1495,6 +1492,7 @@ ssize_t vfs_copy_file_range(struct file *file_in, loff_t pos_in,file_start_write (file_out); + ret = -EOPNOTSUPP ;/* * Try cloning first, this is supported by more file systems, and * more efficient if both clone and copy are supported (e.g. NFS). @@ -1513,9 +1511,10 @@ ssize_t vfs_copy_file_range(struct file *file_in, loff_t pos_in, } } - ret =do_copy_file_range (file_in, pos_in, file_out, pos_out, len, - flags); -WARN_ON_ONCE (ret == -EOPNOTSUPP ); +if (file_out->f_op->copy_file_range) + ret = file_out->f_op->copy_file_range (file_in, pos_in, + file_out, pos_out, + len, flags); done:if (ret >0 ) {fsnotify_access (file_in);
Re: [PATCH v8] vfs: fix copy_file_range regression in cross-fs copies
Quoted 19 lines · Olga Kornievskaia
Quoted 18 lines · Luis Henriques
A regression has been reported by Nicolas Boichat, found while using the
copy_file_rangesyscall to copy a tracefs file. Before commit5dae222a5ff0("vfs: allowcopy_file_rangeto copy across devices") the kernel would return-EXDEVto userspace when trying to copy a file across different filesystems. After this commit, the syscall doesn't fail anymore and instead returns zero (zero bytes copied), as this file's content is generated on-the-fly and thus reports a size of zero.This patch restores some cross-filesystem copy restrictions that existed prior to commit
5dae222a5ff0("vfs: allowcopy_file_rangeto copy across devices"). Filesystems are still allowed to fall-back to the VFSgeneric_copy_file_range()implementation, but that has now to be done explicitly.nfsd is also modified to fall-back into
generic_copy_file_range()in casevfs_copy_file_range()fails with-EOPNOTSUPPor-EXDEV.
Quoted 8 lines
Quoted 6 lines
Fixes 5dae222a5ff0 ("vfs: allow copy_file_range to copy across devices")Link https://lore.kernel.org/linux-fsdevel/CANMq1KDZuxir2LM5jOTm0xx+BnvW=ZmpsG47CyHFJwnw7zSX6Q@mail.gmail.com/ open hereLink https://lore.kernel.org/linux-fsdevel/20210126135012.1.If45b7cdc3ff707bc1efa17f5366057d60603c45f@changeid/ open hereReported-by Nicolas Boichat <[email protected]>Signed-off-by Luis Henriques <[email protected]>I tested v8 and I believe it works for NFS.
Thanks a lot for the testing. And to everyone else for reviews, feedback,... and patience.
I'll now go look into the manpage and see what needs to be changed.
Cheers,
--
Luís
Nicolas Boichat
Tested-byRe: [PATCH v8] vfs: fix copy_file_range regression in cross-fs copies
Quoted 28 lines · Luis Henriques
Quoted 26 lines · Olga Kornievskaia
Quoted 24 lines · Luis Henriques
A regression has been reported by Nicolas Boichat, found while using the
copy_file_rangesyscall to copy a tracefs file. Before commit5dae222a5ff0("vfs: allowcopy_file_rangeto copy across devices") the kernel would return-EXDEVto userspace when trying to copy a file across different filesystems. After this commit, the syscall doesn't fail anymore and instead returns zero (zero bytes copied), as this file's content is generated on-the-fly and thus reports a size of zero.This patch restores some cross-filesystem copy restrictions that existed prior to commit
5dae222a5ff0("vfs: allowcopy_file_rangeto copy across devices"). Filesystems are still allowed to fall-back to the VFSgeneric_copy_file_range()implementation, but that has now to be done explicitly.nfsd is also modified to fall-back into
generic_copy_file_range()in casevfs_copy_file_range()fails with-EOPNOTSUPPor-EXDEV.Fixes 5dae222a5ff0 ("vfs: allow copy_file_range to copy across devices")Link https://lore.kernel.org/linux-fsdevel/CANMq1KDZuxir2LM5jOTm0xx+BnvW=ZmpsG47CyHFJwnw7zSX6Q@mail.gmail.com/ open hereLink https://lore.kernel.org/linux-fsdevel/20210126135012.1.If45b7cdc3ff707bc1efa17f5366057d60603c45f@changeid/ open hereReported-by Nicolas Boichat <[email protected]>Signed-off-by Luis Henriques <[email protected]>
Quoted 4 lines
Quoted 1 line
I tested v8 and I believe it works for NFS.
Thanks a lot for the testing. And to everyone else for reviews, feedback,... and patience.
Thanks so much to you!!!
Works here, you can add my
Quoted 6 lines
I'll now go look into the manpage and see what needs to be changed.
Cheers,
--
Luís
Re: [PATCH v8] vfs: fix copy_file_range regression in cross-fs copies
Quoted 32 lines · Nicolas Boichat
Quoted 30 lines · Luis Henriques
Quoted 27 lines · Olga Kornievskaia
Quoted 18 lines · Luis Henriques
A regression has been reported by Nicolas Boichat, found while using the
copy_file_rangesyscall to copy a tracefs file. Before commit5dae222a5ff0("vfs: allowcopy_file_rangeto copy across devices") the kernel would return-EXDEVto userspace when trying to copy a file across different filesystems. After this commit, the syscall doesn't fail anymore and instead returns zero (zero bytes copied), as this file's content is generated on-the-fly and thus reports a size of zero.This patch restores some cross-filesystem copy restrictions that existed prior to commit
5dae222a5ff0("vfs: allowcopy_file_rangeto copy across devices"). Filesystems are still allowed to fall-back to the VFSgeneric_copy_file_range()implementation, but that has now to be done explicitly.nfsd is also modified to fall-back into
generic_copy_file_range()in casevfs_copy_file_range()fails with-EOPNOTSUPPor-EXDEV.Quoted 6 lines
Fixes 5dae222a5ff0 ("vfs: allow copy_file_range to copy across devices")Link https://lore.kernel.org/linux-fsdevel/CANMq1KDZuxir2LM5jOTm0xx+BnvW=ZmpsG47CyHFJwnw7zSX6Q@mail.gmail.com/ open hereLink https://lore.kernel.org/linux-fsdevel/20210126135012.1.If45b7cdc3ff707bc1efa17f5366057d60603c45f@changeid/ open hereReported-by Nicolas Boichat <[email protected]>Signed-off-by Luis Henriques <[email protected]>I tested v8 and I believe it works for NFS.
Quoted 7 lines
Quoted 2 lines
Thanks a lot for the testing. And to everyone else for reviews, feedback,... and patience.
Thanks so much to you!!!
Works here, you can add my
Tested-by Nicolas Boichat <[email protected]>
What happened to this patch? It does not seem to have been picked up yet? Any reason why?
Quoted 6 lines
Quoted 6 lines
I'll now go look into the manpage and see what needs to be changed.
Cheers,
--
Luís
Re: [PATCH v8] vfs: fix copy_file_range regression in cross-fs copies
Quoted 36 lines · Nicolas Boichat
Quoted 35 lines · Nicolas Boichat
Quoted 32 lines · Luis Henriques
Quoted 19 lines · Olga Kornievskaia
Quoted 18 lines · Luis Henriques
A regression has been reported by Nicolas Boichat, found while using the
copy_file_rangesyscall to copy a tracefs file. Before commit5dae222a5ff0("vfs: allowcopy_file_rangeto copy across devices") the kernel would return-EXDEVto userspace when trying to copy a file across different filesystems. After this commit, the syscall doesn't fail anymore and instead returns zero (zero bytes copied), as this file's content is generated on-the-fly and thus reports a size of zero.This patch restores some cross-filesystem copy restrictions that existed prior to commit
5dae222a5ff0("vfs: allowcopy_file_rangeto copy across devices"). Filesystems are still allowed to fall-back to the VFSgeneric_copy_file_range()implementation, but that has now to be done explicitly.nfsd is also modified to fall-back into
generic_copy_file_range()in casevfs_copy_file_range()fails with-EOPNOTSUPPor-EXDEV.Quoted 8 lines
Quoted 6 lines
Fixes 5dae222a5ff0 ("vfs: allow copy_file_range to copy across devices")Link https://lore.kernel.org/linux-fsdevel/CANMq1KDZuxir2LM5jOTm0xx+BnvW=ZmpsG47CyHFJwnw7zSX6Q@mail.gmail.com/ open hereLink https://lore.kernel.org/linux-fsdevel/20210126135012.1.If45b7cdc3ff707bc1efa17f5366057d60603c45f@changeid/ open hereReported-by Nicolas Boichat <[email protected]>Signed-off-by Luis Henriques <[email protected]>I tested v8 and I believe it works for NFS.
Thanks a lot for the testing. And to everyone else for reviews, feedback,... and patience.
Quoted 7 lines
Quoted 4 lines
Thanks so much to you!!!
Works here, you can add my
Tested-by Nicolas Boichat <[email protected]>What happened to this patch? It does not seem to have been picked up yet? Any reason why?
Hmm... good question. I'm not actually sure who would be picking it. Al, maybe...?
Cheers,
Signature · 1 line
Luis
Quoted 7 lines
Quoted 7 lines
Quoted 7 lines
I'll now go look into the manpage and see what needs to be changed.
Cheers,
--
Luís
Re: [PATCH v8] vfs: fix copy_file_range regression in cross-fs copies
Quoted 41 lines · Luis Henriques
Quoted 38 lines · Nicolas Boichat
Quoted 37 lines · Nicolas Boichat
Quoted 28 lines · Luis Henriques
Quoted 26 lines · Olga Kornievskaia
Quoted 24 lines · Luis Henriques
A regression has been reported by Nicolas Boichat, found while using the
copy_file_rangesyscall to copy a tracefs file. Before commit5dae222a5ff0("vfs: allowcopy_file_rangeto copy across devices") the kernel would return-EXDEVto userspace when trying to copy a file across different filesystems. After this commit, the syscall doesn't fail anymore and instead returns zero (zero bytes copied), as this file's content is generated on-the-fly and thus reports a size of zero.This patch restores some cross-filesystem copy restrictions that existed prior to commit
5dae222a5ff0("vfs: allowcopy_file_rangeto copy across devices"). Filesystems are still allowed to fall-back to the VFSgeneric_copy_file_range()implementation, but that has now to be done explicitly.nfsd is also modified to fall-back into
generic_copy_file_range()in casevfs_copy_file_range()fails with-EOPNOTSUPPor-EXDEV.Fixes 5dae222a5ff0 ("vfs: allow copy_file_range to copy across devices")Link https://lore.kernel.org/linux-fsdevel/CANMq1KDZuxir2LM5jOTm0xx+BnvW=ZmpsG47CyHFJwnw7zSX6Q@mail.gmail.com/ open hereLink https://lore.kernel.org/linux-fsdevel/20210126135012.1.If45b7cdc3ff707bc1efa17f5366057d60603c45f@changeid/ open hereReported-by Nicolas Boichat <[email protected]>Signed-off-by Luis Henriques <[email protected]>Quoted 4 lines
Quoted 1 line
I tested v8 and I believe it works for NFS.
Thanks a lot for the testing. And to everyone else for reviews, feedback,... and patience.
Thanks so much to you!!!
Quoted 9 lines
Quoted 5 lines
Quoted 2 lines
Works here, you can add my
Tested-by Nicolas Boichat <[email protected]>What happened to this patch? It does not seem to have been picked up yet? Any reason why?
Hmm... good question. I'm not actually sure who would be picking it. Al, maybe...?
Darrick,
Would you mind taking this through your tree in case Al doesn't pick it up?
Thanks,
Amir.
Re: [PATCH v8] vfs: fix copy_file_range regression in cross-fs copies
Quoted 49 lines · Amir Goldstein
Quoted 47 lines · Luis Henriques
Quoted 43 lines · Nicolas Boichat
Quoted 32 lines · Nicolas Boichat
Quoted 30 lines · Luis Henriques
Quoted 27 lines · Olga Kornievskaia
Quoted 18 lines · Luis Henriques
A regression has been reported by Nicolas Boichat, found while using the
copy_file_rangesyscall to copy a tracefs file. Before commit5dae222a5ff0("vfs: allowcopy_file_rangeto copy across devices") the kernel would return-EXDEVto userspace when trying to copy a file across different filesystems. After this commit, the syscall doesn't fail anymore and instead returns zero (zero bytes copied), as this file's content is generated on-the-fly and thus reports a size of zero.This patch restores some cross-filesystem copy restrictions that existed prior to commit
5dae222a5ff0("vfs: allowcopy_file_rangeto copy across devices"). Filesystems are still allowed to fall-back to the VFSgeneric_copy_file_range()implementation, but that has now to be done explicitly.nfsd is also modified to fall-back into
generic_copy_file_range()in casevfs_copy_file_range()fails with-EOPNOTSUPPor-EXDEV.Quoted 6 lines
Fixes 5dae222a5ff0 ("vfs: allow copy_file_range to copy across devices")Link https://lore.kernel.org/linux-fsdevel/CANMq1KDZuxir2LM5jOTm0xx+BnvW=ZmpsG47CyHFJwnw7zSX6Q@mail.gmail.com/ open hereLink https://lore.kernel.org/linux-fsdevel/20210126135012.1.If45b7cdc3ff707bc1efa17f5366057d60603c45f@changeid/ open hereReported-by Nicolas Boichat <[email protected]>Signed-off-by Luis Henriques <[email protected]>I tested v8 and I believe it works for NFS.
Quoted 7 lines
Quoted 2 lines
Thanks a lot for the testing. And to everyone else for reviews, feedback,... and patience.
Thanks so much to you!!!
Works here, you can add my
Tested-by Nicolas Boichat <[email protected]>What happened to this patch? It does not seem to have been picked up yet? Any reason why?
Quoted 7 lines
Quoted 3 lines
Hmm... good question. I'm not actually sure who would be picking it. Al, maybe...?
Darrick,
Would you mind taking this through your tree in case Al doesn't pick it up?
Err, sorry for yet another ping... but it would be good to move forward with those patches ,-P
Thanks!
Quoted 2 lines
Thanks,
Amir.
Re: [PATCH v8] vfs: fix copy_file_range regression in cross-fs copies
Quoted 54 lines · Nicolas Boichat
Quoted 53 lines · Amir Goldstein
Quoted 50 lines · Luis Henriques
Quoted 36 lines · Nicolas Boichat
Quoted 35 lines · Nicolas Boichat
Quoted 32 lines · Luis Henriques
Quoted 19 lines · Olga Kornievskaia
Quoted 18 lines · Luis Henriques
A regression has been reported by Nicolas Boichat, found while using the
copy_file_rangesyscall to copy a tracefs file. Before commit5dae222a5ff0("vfs: allowcopy_file_rangeto copy across devices") the kernel would return-EXDEVto userspace when trying to copy a file across different filesystems. After this commit, the syscall doesn't fail anymore and instead returns zero (zero bytes copied), as this file's content is generated on-the-fly and thus reports a size of zero.This patch restores some cross-filesystem copy restrictions that existed prior to commit
5dae222a5ff0("vfs: allowcopy_file_rangeto copy across devices"). Filesystems are still allowed to fall-back to the VFSgeneric_copy_file_range()implementation, but that has now to be done explicitly.nfsd is also modified to fall-back into
generic_copy_file_range()in casevfs_copy_file_range()fails with-EOPNOTSUPPor-EXDEV.Quoted 8 lines
Quoted 6 lines
Fixes 5dae222a5ff0 ("vfs: allow copy_file_range to copy across devices")Link https://lore.kernel.org/linux-fsdevel/CANMq1KDZuxir2LM5jOTm0xx+BnvW=ZmpsG47CyHFJwnw7zSX6Q@mail.gmail.com/ open hereLink https://lore.kernel.org/linux-fsdevel/20210126135012.1.If45b7cdc3ff707bc1efa17f5366057d60603c45f@changeid/ open hereReported-by Nicolas Boichat <[email protected]>Signed-off-by Luis Henriques <[email protected]>I tested v8 and I believe it works for NFS.
Thanks a lot for the testing. And to everyone else for reviews, feedback,... and patience.
Quoted 7 lines
Quoted 4 lines
Thanks so much to you!!!
Works here, you can add my
Tested-by Nicolas Boichat <[email protected]>What happened to this patch? It does not seem to have been picked up yet? Any reason why?
Hmm... good question. I'm not actually sure who would be picking it. Al, maybe...?
Quoted 6 lines
Quoted 3 lines
Darrick,
Would you mind taking this through your tree in case Al doesn't pick it up?
Err, sorry for yet another ping... but it would be good to move forward with those patches ,-P
Yeah, I'm not sure what else to do, or who else to bug regarding this :-/
Cheers,
Signature · 1 line
Luis
Re: [PATCH v8] vfs: fix copy_file_range regression in cross-fs copies
Quoted 57 lines · Luis Henriques
Quoted 54 lines · Nicolas Boichat
Quoted 53 lines · Amir Goldstein
Quoted 50 lines · Luis Henriques
Quoted 36 lines · Nicolas Boichat
Quoted 35 lines · Nicolas Boichat
Quoted 32 lines · Luis Henriques
Quoted 19 lines · Olga Kornievskaia
Quoted 18 lines · Luis Henriques
A regression has been reported by Nicolas Boichat, found while using the
copy_file_rangesyscall to copy a tracefs file. Before commit5dae222a5ff0("vfs: allowcopy_file_rangeto copy across devices") the kernel would return-EXDEVto userspace when trying to copy a file across different filesystems. After this commit, the syscall doesn't fail anymore and instead returns zero (zero bytes copied), as this file's content is generated on-the-fly and thus reports a size of zero.This patch restores some cross-filesystem copy restrictions that existed prior to commit
5dae222a5ff0("vfs: allowcopy_file_rangeto copy across devices"). Filesystems are still allowed to fall-back to the VFSgeneric_copy_file_range()implementation, but that has now to be done explicitly.nfsd is also modified to fall-back into
generic_copy_file_range()in casevfs_copy_file_range()fails with-EOPNOTSUPPor-EXDEV.Quoted 8 lines
Quoted 6 lines
Fixes 5dae222a5ff0 ("vfs: allow copy_file_range to copy across devices")Link https://lore.kernel.org/linux-fsdevel/CANMq1KDZuxir2LM5jOTm0xx+BnvW=ZmpsG47CyHFJwnw7zSX6Q@mail.gmail.com/ open hereLink https://lore.kernel.org/linux-fsdevel/20210126135012.1.If45b7cdc3ff707bc1efa17f5366057d60603c45f@changeid/ open hereReported-by Nicolas Boichat <[email protected]>Signed-off-by Luis Henriques <[email protected]>I tested v8 and I believe it works for NFS.
Thanks a lot for the testing. And to everyone else for reviews, feedback,... and patience.
Quoted 7 lines
Quoted 4 lines
Thanks so much to you!!!
Works here, you can add my
Tested-by Nicolas Boichat <[email protected]>What happened to this patch? It does not seem to have been picked up yet? Any reason why?
Hmm... good question. I'm not actually sure who would be picking it. Al, maybe...?
Quoted 9 lines
Quoted 6 lines
Quoted 3 lines
Darrick,
Would you mind taking this through your tree in case Al doesn't pick it up?
Err, sorry for yet another ping... but it would be good to move forward with those patches ,-P
Yeah, I'm not sure what else to do, or who else to bug regarding this :-/
Luis,
I suggest that you post v9 with my Reviewed-by and Olga's Tested-by and address your patch to the VFS maintainer and fsdevel list without the entire world and LKML in CC.
Al,
Would you mind picking this patch?
Linus,
There have been some voices on the discussion saying maybe this is not a kernel regression that needs to be fixed, but a UAPI that is not being used correctly by userspace.
The proposed change reminds me a bit of recent changes to splice() from special files. Since this specific UAPI discussion is a bit subtle and because we got this UAPI wrong at least two times already, it would be great to get your ACK on this proposed UAPI change.
Thanks,
Amir.
Latest v8 tested and reviewed by several developers on CC list:
https://lore.kernel.org/linux-fsdevel/[email protected]/
Proposed man page update:
https://lore.kernel.org/linux-fsdevel/[email protected]/
Re: [PATCH v8] vfs: fix copy_file_range regression in cross-fs copies
Quoted 1 line · Amir Goldstein
On Mon, May 3, 2021 at 11:52 AM Luis Henriques <[email protected]> wrote:
<...>
Quoted 5 lines
Luis,
I suggest that you post v9 with my Reviewed-by and Olga's Tested-by and address your patch to the VFS maintainer and fsdevel list without the entire world and LKML in CC.
Ok, v9 sent out according to your proposal:
https://lore.kernel.org/linux-fsdevel/[email protected]/
Thanks, Amir.
Cheers,
Signature · 1 line
Luis
Quoted 24 lines
Al,
Would you mind picking this patch?
Linus,
There have been some voices on the discussion saying maybe this is not a kernel regression that needs to be fixed, but a UAPI that is not being used correctly by userspace.
The proposed change reminds me a bit of recent changes to
splice()from special files. Since this specific UAPI discussion is a bit subtle and because we got this UAPI wrong at least two times already, it would be great to get your ACK on this proposed UAPI change.Thanks,
Amir.Latest v8 tested and reviewed by several developers on CC list:
https://lore.kernel.org/linux-fsdevel/[email protected]/Proposed man page update:
https://lore.kernel.org/linux-fsdevel/[email protected]/