FAILED: patch "[PATCH] splice: avoid stale f_pos writeback on error" failed to apply to 5.10-stable tree
Subsystems (2)
Sasha Levin
maintainerThe patch below does not apply to the 5.10-stable tree.
If someone wants it applied there, or to any other stable or longterm tree, then please email the backport, including the original git commit id to <[email protected]>.
To reproduce the conflict and resubmit, you may use the following commands:
git fetch https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git/ linux-5.10.y
git checkout FETCH_HEAD
git cherry-pick -x 79b496ebe382866e3a05090b7dc9ae95e85e65b2
# <resolve conflicts, build, test, etc.>
git commit -s
git send-email --to '<[email protected]>' --in-reply-to '[email protected]' --subject-prefix 'PATCH 5.10.y' 'HEAD^..'
Thanks,
Sasha
------------------ original commit in Linus's tree ------------------
From 79b496ebe382866e3a05090b7dc9ae95e85e65b2 Mon Sep 17 00:00:00 2001
From: Daehyeon Ko <[email protected]>
Date: Sun, 18 Oct 2026 14:17:08 +0900
Subject: [PATCH] splice: avoid stale f_pos writeback on error
do_splice() snapshots an implicit file position before calling the splice helper. Since splice does not take f_pos_lock, another operation on the same open file description can update f_pos while the helper is blocked. If the helper then fails, the unconditional writeback restores the stale snapshot.
For a directory without ->splice_read, a file-to-pipe splice fails with -EINVAL. A concurrent directory mutation and getdents() call can advance f_pos and refresh the filesystem's revalidation cookie before that failure restores only the old position. The next ext2 readdir can then trust an offset inside a directory entry and copy data from the adjacent page to userspace.
Only update an implicit file position when splice returns a non-negative result, matching read and write. Keep explicit offset updates unchanged.
--- fs/splice.c | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-)
fs/splice.c +6 -6
@@ -1377,10 +1377,10 @@ ssize_t do_splice(struct file *in, loff_t *off_in, struct file *out, ret =do_splice_from (ipipe, out, &offset, len, flags);file_end_write (out); -if (!off_out) - out->f_pos = offset; -else +if (off_out) *off_out = offset; +else if (ret >=0 ) + out->f_pos = offset; }else if (opipe) {if (off_out)return -ESPIPE ;
@@ -1401,10 +1401,10 @@ ssize_t do_splice(struct file *in, loff_t *off_in, struct file *out, ret =splice_file_to_pipe (in, opipe, &offset, len, flags); -if (!off_in) - in->f_pos = offset; -else +if (off_in) *off_in = offset; +else if (ret >=0 ) + in->f_pos = offset; }else { ret = -EINVAL ; }
Signature · 1 line
2.53.0
Sasha Levin
maintainerPATCH 1/5 do_splice_to(): move the logics for limiting the read length in
From: Al Viro <[email protected]>
[ Upstream commit 313d64a35d36b4bb00edde418179ff1a5f342070 ]
Both callers have the identical logics limiting the amount of data we try to read into pipe - no more than would fit into that pipe. Move that into do_splice_to() itself.
Stable-dep-of: 79b496ebe382 ("splice: avoid stale f_pos writeback on error")
--- fs/splice.c | 21 +++++++-------------- 1 file changed, 7 insertions(+), 14 deletions(-)
fs/splice.c +7 -14
@@ -774,11 +774,16 @@ static long do_splice_to(struct file *in, loff_t *ppos, struct pipe_inode_info *pipe, size_t len, unsigned int flags) { + unsigned int p_space;int ret;if (unlikely (!(in->f_mode &FMODE_READ )))return -EBADF ; +/* Don't try to read more the pipe has space for. */ + p_space = pipe->max_usage -pipe_occupancy (pipe->head, pipe->tail); + len =min_t (size_t, len, p_space <<PAGE_SHIFT ); + ret =rw_verify_area (READ , in, ppos, len);if (unlikely (ret <0 ))return ret;
@@ -859,15 +864,10 @@ ssize_t splice_direct_to_actor(struct file *in, struct splice_desc *sd,WARN_ON_ONCE (!pipe_empty (pipe->head, pipe->tail));while (len) { -unsigned int p_space;size_t read_len;loff_t pos = sd->pos, prev_pos = pos; -/* Don't try to read more the pipe has space for. */ - p_space = pipe->max_usage - -pipe_occupancy (pipe->head, pipe->tail); - read_len =min_t (size_t, len, p_space <<PAGE_SHIFT ); - ret =do_splice_to (in, &pos, pipe, read_len, flags); + ret =do_splice_to (in, &pos, pipe, len, flags);if (unlikely (ret <=0 )) goto out_release;
@@ -1086,15 +1086,8 @@ long do_splice(struct file *in, loff_t *off_in, struct file *out,pipe_lock (opipe); ret =wait_for_space (opipe, flags); -if (!ret) { -unsigned int p_space; - -/* Don't try to read more the pipe has space for. */ - p_space = opipe->max_usage -pipe_occupancy (opipe->head, opipe->tail); - len =min_t (size_t, len, p_space <<PAGE_SHIFT ); - +if (!ret) ret =do_splice_to (in, &offset, opipe, len, flags); - }pipe_unlock (opipe);if (ret >0 )wakeup_pipe_readers (opipe);
Signature · 1 line
2.53.0
Sasha Levin
maintainerPATCH 2/5 take the guts of file-to-pipe splice into a helper function
From: Al Viro <[email protected]>
[ Upstream commit faa97c48c33454ac0107db930a491b692dd1dff1 ]
Stable-dep-of: 79b496ebe382 ("splice: avoid stale f_pos writeback on error")
--- fs/splice.c | 25 ++++++++++++++++++------- 1 file changed, 18 insertions(+), 7 deletions(-)
fs/splice.c +18 -7
@@ -1005,6 +1005,23 @@ static int splice_pipe_to_pipe(struct pipe_inode_info *ipipe,struct pipe_inode_info *opipe, size_t len, unsigned int flags); +static long splice_file_to_pipe (struct file *in, +struct pipe_inode_info *opipe, +loff_t *offset, +size_t len,unsigned int flags) +{ +long ret; + +pipe_lock (opipe); + ret =wait_for_space (opipe, flags); +if (!ret) + ret =do_splice_to (in, offset, opipe, len, flags); +pipe_unlock (opipe); +if (ret >0 ) +wakeup_pipe_readers (opipe); +return ret; +} +/* * Determine where to splice to/from. */
@@ -1084,13 +1101,7 @@ long do_splice(struct file *in, loff_t *off_in, struct file *out,if (out->f_flags &O_NONBLOCK ) flags |=SPLICE_F_NONBLOCK ; -pipe_lock (opipe); - ret =wait_for_space (opipe, flags); -if (!ret) - ret =do_splice_to (in, &offset, opipe, len, flags); -pipe_unlock (opipe); -if (ret >0 ) -wakeup_pipe_readers (opipe); + ret =splice_file_to_pipe (in, opipe, &offset, len, flags);if (!off_in) in->f_pos = offset;else
Signature · 1 line
2.53.0
Sasha Levin
maintainerPATCH 3/5 splice: report related fsnotify events
In reply to Sasha LevinFrom: Chung-Chiang Cheng <[email protected]>
[ Upstream commit 983652c691990b3257a07f67f4263eb847baa82d ]
The fsnotify ACCESS and MODIFY event are missing when manipulating a file with splice(2).
Message-Id: <[email protected]>
Stable-dep-of: 79b496ebe382 ("splice: avoid stale f_pos writeback on error")
--- fs/splice.c | 8 ++++++++ 1 file changed, 8 insertions(+)
fs/splice.c +8 -0
@@ -30,6 +30,7 @@#include <linux/export.h> #include <linux/syscalls.h> #include <linux/uio.h> +#include <linux/fsnotify.h> #include <linux/security.h> #include <linux/gfp.h> #include <linux/socket.h>
@@ -1079,6 +1080,9 @@ long do_splice(struct file *in, loff_t *off_in, struct file *out, ret =do_splice_from (ipipe, out, &offset, len, flags);file_end_write (out); +if (ret >0 ) +fsnotify_modify (out); +if (!off_out) out->f_pos = offset;else
@@ -1102,6 +1106,10 @@ long do_splice(struct file *in, loff_t *off_in, struct file *out, flags |=SPLICE_F_NONBLOCK ; ret =splice_file_to_pipe (in, opipe, &offset, len, flags); + +if (ret >0 ) +fsnotify_access (in); +if (!off_in) in->f_pos = offset;else
Signature · 1 line
2.53.0
Sasha Levin
maintainerPATCH 4/5 splice: always fsnotify_access(in), fsnotify_modify(out) on success
In reply to Sasha LevinFrom: Ahelenia Ziemiańska <[email protected]>
[ Upstream commit 12ee4b66af34f8e72f3b2fd93a946a955efe7c86 ]
The current behaviour caused an asymmetry where some write APIs (write, sendfile) would notify the written-to/read-from objects, but splice wouldn't.
This affected userspace which uses inotify, most notably coreutils tail -f, to monitor pipes.
If the pipe buffer had been filled by a splice-family function:
* tail wouldn't know and thus wouldn't service the pipe, and
* all writes to the pipe would block because it's full,
thus service was denied.
(For the particular case of tail -f this could be worked around
with ---disable-inotify.)
Message-Id: <604ec704d933e0e0121d9e107ce914512e045fad.1688393619.git.nabijaczleweli@nabijaczleweli.xyz>
Stable-dep-of: 79b496ebe382 ("splice: avoid stale f_pos writeback on error")
--- fs/splice.c | 32 +++++++++++++++----------------- 1 file changed, 15 insertions(+), 17 deletions(-)
fs/splice.c +15 -17
@@ -1052,10 +1052,8 @@ long do_splice(struct file *in, loff_t *off_in, struct file *out,if ((in->f_flags | out->f_flags) &O_NONBLOCK ) flags |=SPLICE_F_NONBLOCK ; -return splice_pipe_to_pipe (ipipe, opipe, len, flags); - } - -if (ipipe) { + ret =splice_pipe_to_pipe (ipipe, opipe, len, flags); + }else if (ipipe) {if (off_in)return -ESPIPE ;if (off_out) {
@@ -1080,18 +1078,11 @@ long do_splice(struct file *in, loff_t *off_in, struct file *out, ret =do_splice_from (ipipe, out, &offset, len, flags);file_end_write (out); -if (ret >0 ) -fsnotify_modify (out); -if (!off_out) out->f_pos = offset;else *off_out = offset; - -return ret; - } - -if (opipe) { + }else if (opipe) {if (off_out)return -ESPIPE ;if (off_in) {
@@ -1107,18 +1098,25 @@ long do_splice(struct file *in, loff_t *off_in, struct file *out, ret =splice_file_to_pipe (in, opipe, &offset, len, flags); -if (ret >0 ) -fsnotify_access (in); -if (!off_in) in->f_pos = offset;else *off_in = offset; + }else { + ret = -EINVAL ; + } -return ret; +if (ret >0 ) { +/* +* Generate modify out before access in: +* do_splice_from() may've already sent modify out, +* and this ensures the events get merged. +*/ +fsnotify_modify (out); +fsnotify_access (in); } -return -EINVAL ; +return ret; } static long __do_splice(struct file *in, loff_t __user *off_in,
Signature · 1 line
2.53.0
Sasha Levin
maintainerPATCH 5/5 splice: avoid stale f_pos writeback on error
In reply to Sasha LevinFrom: Daehyeon Ko <[email protected]>
[ Upstream commit 79b496ebe382866e3a05090b7dc9ae95e85e65b2 ]
do_splice() snapshots an implicit file position before calling the splice helper. Since splice does not take f_pos_lock, another operation on the same open file description can update f_pos while the helper is blocked. If the helper then fails, the unconditional writeback restores the stale snapshot.
For a directory without ->splice_read, a file-to-pipe splice fails with -EINVAL. A concurrent directory mutation and getdents() call can advance f_pos and refresh the filesystem's revalidation cookie before that failure restores only the old position. The next ext2 readdir can then trust an offset inside a directory entry and copy data from the adjacent page to userspace.
Only update an implicit file position when splice returns a non-negative result, matching read and write. Keep explicit offset updates unchanged.
--- fs/splice.c | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-)
fs/splice.c +6 -6
@@ -1078,10 +1078,10 @@ long do_splice(struct file *in, loff_t *off_in, struct file *out, ret =do_splice_from (ipipe, out, &offset, len, flags);file_end_write (out); -if (!off_out) - out->f_pos = offset; -else +if (off_out) *off_out = offset; +else if (ret >=0 ) + out->f_pos = offset; }else if (opipe) {if (off_out)return -ESPIPE ;
@@ -1098,10 +1098,10 @@ long do_splice(struct file *in, loff_t *off_in, struct file *out, ret =splice_file_to_pipe (in, opipe, &offset, len, flags); -if (!off_in) - in->f_pos = offset; -else +if (off_in) *off_in = offset; +else if (ret >=0 ) + in->f_pos = offset; }else { ret = -EINVAL ; }
Signature · 1 line
2.53.0