* [PATCH] fs: shorten I/O that would extend past the maximum file offset
@ 2026-11-20 18:42 Matteo Croce
2026-11-20 20:03 ` Paul Eggert
0 siblings, 1 reply; 3+ messages in thread
From: Matteo Croce @ 2026-11-20 18:42 UTC (permalink / raw)
To: linux-fsdevel, Christian Brauner, Alexander Viro, Ding Feng
Cc: Paul Eggert, LKML
rw_verify_area() fails with -EINVAL any read or write where
pos + count would exceed LLONG_MAX, even when pos itself is valid.
Such a request should not fail: a read should return the bytes that
are there up to the maximum offset, or 0 at end of file, and a write
should write what fits and return a short count.
This breaks ordinary programs that pass a large count, such as
coreutils, which uses SSIZE_MAX as the count for copy_file_range() and
falls back to read() at the end. For example, both of these fail with
EINVAL:
$ truncate -s $((2**63 - 1)) hugefile
$ dd if=hugefile bs=1M skip=$((2**43 - 2))
dd: error reading 'hugefile': Invalid argument
$ dd if=hugefile bs=1 skip=$((2**63 - 1)) | cat
cat: -: Invalid argument
and on a 100-byte file:
preadv2(fd, 200 bytes, pos = LLONG_MAX - 50) = -1 EINVAL
preadv2(fd, 50 bytes, pos = LLONG_MAX - 50) = 0
splice(), sendfile(), aio and io_uring fail in the same way.
Add rw_clamp_count(), which shortens the count so that the range ends
at LLONG_MAX, and call it before rw_verify_area() in the read and write
paths of the VFS, splice, aio and io_uring. Where the I/O is described
by an iov_iter, truncate the iterator. This is what filemap_read()
already does for s_maxbytes. In io_uring, also save the iterator state
again after truncating it, so that the short read retry loop does not
restore the full length.
rw_verify_area() keeps its check, so callers that are not converted
behave as before. rw_clamp_count() leaves alone negative positions,
counts above SSIZE_MAX, files with FOP_UNSIGNED_OFFSET and writes that
start at LLONG_MAX, so these still fail in rw_verify_area().
copy_file_range() already clamps the range in generic_copy_file_checks()
and is not changed.
Reported-by: Ding Feng <dingf3ng@gmail.com>
Closes: https://lore.kernel.org/linux-fsdevel/20261120051457.47753-1-dingf3ng@gmail.com/
Suggested-by: Paul Eggert <eggert@cs.ucla.edu>
Link: https://lists.gnu.org/archive/html/coreutils/2025-12/msg00097.html
Link: https://lore.kernel.org/linux-fsdevel/20251219125250.65245-1-teknoraver@meta.com/
Signed-off-by: Matteo Croce <technoboy85@gmail.com>
---
fs/aio.c | 4 ++++
fs/read_write.c | 18 ++++++++++++++++++
fs/splice.c | 3 +++
include/linux/fs.h | 38 ++++++++++++++++++++++++++++++++++++++
io_uring/rw.c | 16 ++++++++++++++++
5 files changed, 79 insertions(+)
diff --git a/fs/aio.c b/fs/aio.c
index d78acc69f487..abd17f75faaa 100644
--- a/fs/aio.c
+++ b/fs/aio.c
@@ -1651,6 +1651,8 @@ static int aio_read(struct kiocb *req, const struct iocb *iocb,
ret = aio_setup_rw(ITER_DEST, iocb, &iovec, vectored, compat, &iter);
if (ret < 0)
return ret;
+ iov_iter_truncate(&iter, rw_clamp_count(READ, file, &req->ki_pos,
+ iov_iter_count(&iter)));
ret = rw_verify_area(READ, file, &req->ki_pos, iov_iter_count(&iter));
if (!ret)
aio_rw_done(req, file->f_op->read_iter(req, &iter));
@@ -1679,6 +1681,8 @@ static int aio_write(struct kiocb *req, const struct iocb *iocb,
ret = aio_setup_rw(ITER_SOURCE, iocb, &iovec, vectored, compat, &iter);
if (ret < 0)
return ret;
+ iov_iter_truncate(&iter, rw_clamp_count(WRITE, file, &req->ki_pos,
+ iov_iter_count(&iter)));
ret = rw_verify_area(WRITE, file, &req->ki_pos, iov_iter_count(&iter));
if (!ret) {
if (S_ISREG(file_inode(file)->i_mode))
diff --git a/fs/read_write.c b/fs/read_write.c
index e8c14e2760b2..0a6cf9b5b02e 100644
--- a/fs/read_write.c
+++ b/fs/read_write.c
@@ -544,6 +544,7 @@ ssize_t kernel_read(struct file *file, void *buf, size_t count, loff_t *pos)
{
ssize_t ret;
+ count = rw_clamp_count(READ, file, pos, count);
ret = rw_verify_area(READ, file, pos, count);
if (ret)
return ret;
@@ -562,6 +563,7 @@ ssize_t vfs_read(struct file *file, char __user *buf, size_t count, loff_t *pos)
if (unlikely(!access_ok(buf, count)))
return -EFAULT;
+ count = rw_clamp_count(READ, file, pos, count);
ret = rw_verify_area(READ, file, pos, count);
if (ret)
return ret;
@@ -653,6 +655,7 @@ ssize_t kernel_write(struct file *file, const void *buf, size_t count,
{
ssize_t ret;
+ count = rw_clamp_count(WRITE, file, pos, count);
ret = rw_verify_area(WRITE, file, pos, count);
if (ret)
return ret;
@@ -675,6 +678,7 @@ ssize_t vfs_write(struct file *file, const char __user *buf, size_t count, loff_
if (unlikely(!access_ok(buf, count)))
return -EFAULT;
+ count = rw_clamp_count(WRITE, file, pos, count);
ret = rw_verify_area(WRITE, file, pos, count);
if (ret)
return ret;
@@ -879,6 +883,8 @@ ssize_t vfs_iocb_iter_read(struct file *file, struct kiocb *iocb,
if (!(file->f_mode & FMODE_CAN_READ))
return -EINVAL;
+ iov_iter_truncate(iter, rw_clamp_count(READ, file, &iocb->ki_pos,
+ iov_iter_count(iter)));
tot_len = iov_iter_count(iter);
if (!tot_len)
goto out;
@@ -907,6 +913,8 @@ ssize_t vfs_iter_read(struct file *file, struct iov_iter *iter, loff_t *ppos,
if (!(file->f_mode & FMODE_CAN_READ))
return -EINVAL;
+ iov_iter_truncate(iter, rw_clamp_count(READ, file, ppos,
+ iov_iter_count(iter)));
tot_len = iov_iter_count(iter);
if (!tot_len)
goto out;
@@ -939,6 +947,8 @@ ssize_t vfs_iocb_iter_write(struct file *file, struct kiocb *iocb,
if (!(file->f_mode & FMODE_CAN_WRITE))
return -EINVAL;
+ iov_iter_truncate(iter, rw_clamp_count(WRITE, file, &iocb->ki_pos,
+ iov_iter_count(iter)));
tot_len = iov_iter_count(iter);
if (!tot_len)
return 0;
@@ -970,6 +980,8 @@ ssize_t vfs_iter_write(struct file *file, struct iov_iter *iter, loff_t *ppos,
if (!file->f_op->write_iter)
return -EINVAL;
+ iov_iter_truncate(iter, rw_clamp_count(WRITE, file, ppos,
+ iov_iter_count(iter)));
tot_len = iov_iter_count(iter);
if (!tot_len)
return 0;
@@ -1007,6 +1019,8 @@ static ssize_t vfs_readv(struct file *file, const struct iovec __user *vec,
if (ret < 0)
return ret;
+ iov_iter_truncate(&iter, rw_clamp_count(READ, file, pos,
+ iov_iter_count(&iter)));
tot_len = iov_iter_count(&iter);
if (!tot_len)
goto out;
@@ -1045,6 +1059,8 @@ static ssize_t vfs_writev(struct file *file, const struct iovec __user *vec,
if (ret < 0)
return ret;
+ iov_iter_truncate(&iter, rw_clamp_count(WRITE, file, pos,
+ iov_iter_count(&iter)));
tot_len = iov_iter_count(&iter);
if (!tot_len)
goto out;
@@ -1325,6 +1341,7 @@ static ssize_t do_sendfile(int out_fd, int in_fd, loff_t *ppos,
if (!(fd_file(in)->f_mode & FMODE_PREAD))
return -ESPIPE;
}
+ count = rw_clamp_count(READ, fd_file(in), &pos, count);
retval = rw_verify_area(READ, fd_file(in), &pos, count);
if (retval < 0)
return retval;
@@ -1365,6 +1382,7 @@ static ssize_t do_sendfile(int out_fd, int in_fd, loff_t *ppos,
#endif
opipe = get_pipe_info(fd_file(out), true);
if (!opipe) {
+ count = rw_clamp_count(WRITE, fd_file(out), &out_pos, count);
retval = rw_verify_area(WRITE, fd_file(out), &out_pos, count);
if (retval < 0)
return retval;
diff --git a/fs/splice.c b/fs/splice.c
index 9d8f63e2fd1a..7a889274f9d6 100644
--- a/fs/splice.c
+++ b/fs/splice.c
@@ -1001,6 +1001,7 @@ ssize_t vfs_splice_read(struct file *in, loff_t *ppos,
{
ssize_t ret;
+ len = rw_clamp_count(READ, in, ppos, len);
ret = rw_verify_area(READ, in, ppos, len);
if (unlikely(ret < 0))
return ret;
@@ -1338,6 +1339,7 @@ ssize_t do_splice(struct file *in, loff_t *off_in, struct file *out,
if (unlikely(out->f_flags & O_APPEND))
return -EINVAL;
+ len = rw_clamp_count(WRITE, out, &offset, len);
ret = rw_verify_area(WRITE, out, &offset, len);
if (unlikely(ret < 0))
return ret;
@@ -1364,6 +1366,7 @@ ssize_t do_splice(struct file *in, loff_t *off_in, struct file *out,
offset = in->f_pos;
}
+ len = rw_clamp_count(READ, in, &offset, len);
ret = rw_verify_area(READ, in, &offset, len);
if (unlikely(ret < 0))
return ret;
diff --git a/include/linux/fs.h b/include/linux/fs.h
index deb411e86661..990d8fa0b2bb 100644
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -3128,6 +3128,44 @@ extern loff_t fixed_size_llseek(struct file *file, loff_t offset,
extern loff_t no_seek_end_llseek_size(struct file *, loff_t, int, loff_t);
extern loff_t no_seek_end_llseek(struct file *, loff_t, int);
int rw_verify_area(int, struct file *, const loff_t *, size_t);
+
+/**
+ * rw_clamp_count - shorten an I/O so it does not extend past LLONG_MAX
+ * @read_write: READ or WRITE
+ * @file: file the I/O is done on
+ * @ppos: file position of the I/O, or NULL for stream files
+ * @count: number of bytes requested
+ *
+ * A read or write that starts at a valid file position but would end past
+ * the maximum file offset should transfer the bytes up to that offset and
+ * return a short count, rather than fail. rw_verify_area() rejects such a
+ * range, so callers clamp @count with this helper before verifying it.
+ *
+ * Out-of-range positions and counts are left alone so that
+ * rw_verify_area() still rejects them. So is a write starting at
+ * LLONG_MAX, which cannot transfer anything. A read starting there is
+ * clamped to zero bytes and reports end of file.
+ *
+ * Return: the possibly shortened count.
+ */
+static inline size_t rw_clamp_count(int read_write, struct file *file,
+ const loff_t *ppos, size_t count)
+{
+ loff_t pos;
+
+ if (!ppos)
+ return count;
+
+ pos = *ppos;
+ if (likely(pos < 0 || (ssize_t)count < 0 || count <= LLONG_MAX - pos))
+ return count;
+ if (file->f_op->fop_flags & FOP_UNSIGNED_OFFSET)
+ return count;
+ if (read_write == WRITE && pos == LLONG_MAX)
+ return count;
+
+ return LLONG_MAX - pos;
+}
extern int generic_file_open(struct inode * inode, struct file * filp);
extern int nonseekable_open(struct inode * inode, struct file * filp);
extern int stream_open(struct inode * inode, struct file * filp);
diff --git a/io_uring/rw.c b/io_uring/rw.c
index 432820f86251..6c01290aa2fb 100644
--- a/io_uring/rw.c
+++ b/io_uring/rw.c
@@ -918,6 +918,7 @@ static int __io_read(struct io_kiocb *req, struct io_br_sel *sel,
struct io_async_rw *io = req->async_data;
struct kiocb *kiocb = &rw->kiocb;
ssize_t ret;
+ size_t count;
loff_t *ppos;
if (req->flags & REQ_F_IMPORT_BUFFER) {
@@ -946,6 +947,13 @@ static int __io_read(struct io_kiocb *req, struct io_br_sel *sel,
ppos = io_kiocb_update_pos(req);
+ count = rw_clamp_count(READ, req->file, ppos, req->cqe.res);
+ if (unlikely(count != req->cqe.res)) {
+ iov_iter_truncate(&io->iter, count);
+ iov_iter_save_state(&io->iter, &io->iter_state);
+ req->cqe.res = count;
+ }
+
ret = rw_verify_area(READ, req->file, ppos, req->cqe.res);
if (unlikely(ret))
return ret;
@@ -1134,6 +1142,7 @@ int io_write(struct io_kiocb *req, unsigned int issue_flags)
struct io_async_rw *io = req->async_data;
struct kiocb *kiocb = &rw->kiocb;
ssize_t ret, ret2;
+ size_t count;
loff_t *ppos;
if (req->flags & REQ_F_IMPORT_BUFFER) {
@@ -1166,6 +1175,13 @@ int io_write(struct io_kiocb *req, unsigned int issue_flags)
ppos = io_kiocb_update_pos(req);
+ count = rw_clamp_count(WRITE, req->file, ppos, req->cqe.res);
+ if (unlikely(count != req->cqe.res)) {
+ iov_iter_truncate(&io->iter, count);
+ iov_iter_save_state(&io->iter, &io->iter_state);
+ req->cqe.res = count;
+ }
+
ret = rw_verify_area(WRITE, req->file, ppos, req->cqe.res);
if (unlikely(ret))
return ret;
--
2.56.1
^ permalink raw reply related [flat|nested] 3+ messages in thread
* Re: [PATCH] fs: shorten I/O that would extend past the maximum file offset
2026-11-20 18:42 [PATCH] fs: shorten I/O that would extend past the maximum file offset Matteo Croce
@ 2026-11-20 20:03 ` Paul Eggert
2026-11-20 20:46 ` Matteo Croce
0 siblings, 1 reply; 3+ messages in thread
From: Paul Eggert @ 2026-11-20 20:03 UTC (permalink / raw)
To: Matteo Croce
Cc: LKML, linux-fsdevel, Christian Brauner, Alexander Viro, Ding Feng
On 2026-11-20 10:42, Matteo Croce wrote:
> + if (file->f_op->fop_flags & FOP_UNSIGNED_OFFSET)
> + return count;
This means there's still a problem when reading past the maximum file offset of /dev/mem and other files with FOP_UNSIGNED_OFFSET, right? If FOP_UNSIGNED_OFFSET is set, are the file's own read/write methods expected to shorten I/O requests in this situation?
Thanks for looking into this, by the way.
^ permalink raw reply [flat|nested] 3+ messages in thread
* Re: [PATCH] fs: shorten I/O that would extend past the maximum file offset
2026-11-20 20:03 ` Paul Eggert
@ 2026-11-20 20:46 ` Matteo Croce
0 siblings, 0 replies; 3+ messages in thread
From: Matteo Croce @ 2026-11-20 20:46 UTC (permalink / raw)
To: Paul Eggert
Cc: LKML, linux-fsdevel, Christian Brauner, Alexander Viro, Ding Feng
Il giorno ven 20 nov 2026 alle ore 21:03 Paul Eggert
<eggert@cs.ucla.edu> ha scritto:
>
> On 2026-11-20 10:42, Matteo Croce wrote:
> > + if (file->f_op->fop_flags & FOP_UNSIGNED_OFFSET)
> > + return count;
>
> This means there's still a problem when reading past the maximum file offset of /dev/mem and other files with FOP_UNSIGNED_OFFSET, right? If FOP_UNSIGNED_OFFSET is set, are the file's own read/write methods expected to shorten I/O requests in this situation?
>
> Thanks for looking into this, by the way.
Right. For files with FOP_UNSIGNED_OFFSET the limit is the unsigned
one, 2^64 - 1, and crossing LLONG_MAX is already allowed for them.
At that limit rw_verify_area() still returns -EOVERFLOW instead of
shortening the request, and this patch deliberately leaves them
untouched.
As things stand the VFS only guarantees that pos + count doesn't wrap
past 2^64, and everything else is up to the file's own methods. They
don't behave consistently: /dev/mem returns -EFAULT for a range that
goes past the end of RAM, while /proc/pid/mem returns a short count
at the first page it can't access.
I can extend rw_clamp_count() to shorten the count so the range ends
at 2^64 - 1 for these files too, so that the behaviour is the same at
both limits. In practice none of these files has data near 2^64, so it
would only be for consistency. I'll do it in v2 if you think it's
worth it.
Thanks for the review.
One correction to the commit message. The second reproducer is wrong
as written: with "dd ... | cat" it is dd itself that does the read at
LLONG_MAX and fails, not cat. The intended example has dd only move
the shared file offset of stdin, so that cat then reads from
LLONG_MAX:
$ (dd bs=1 skip=$((2**63 - 1)) count=0 status=none; cat) < hugefile
cat: -: Invalid argument
The code is not affected. If you apply this version, could you please
replace that example while applying? Otherwise I'll fix it in v2.
Regards,
--
per aspera ad upstream
^ permalink raw reply [flat|nested] 3+ messages in thread
end of thread, other threads:[~2026-11-20 20:47 UTC | newest]
Thread overview: 3+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2026-11-20 18:42 [PATCH] fs: shorten I/O that would extend past the maximum file offset Matteo Croce
2026-11-20 20:03 ` Paul Eggert
2026-11-20 20:46 ` Matteo Croce
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox