* [PATCH v2] fs: shorten I/O that would extend past the maximum file offset
@ 2026-11-21 0:33 Matteo Croce
2026-11-21 0:49 ` Matteo Croce
0 siblings, 1 reply; 3+ messages in thread
From: Matteo Croce @ 2026-11-21 0:33 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 read a file up to an end at or near
LLONG_MAX, even with ordinary buffer sizes. For example, dd fails on
the last block, where it should get a short read, and cat fails where
it should get end of file:
$ truncate -s $((2**63 - 1)) hugefile
$ dd if=hugefile of=/dev/null bs=1M skip=$((2**43 - 2))
dd: error reading 'hugefile': Invalid argument
1+0 records in
1+0 records out
1048576 bytes (1,0 MB, 1,0 MiB) copied, 0,103536 s, 10,1 MB/s
$ (dd bs=1 skip=$((2**63 - 1)) count=0 status=none; cat) < hugefile
cat: -: Invalid argument
The same happens on a 100-byte file:
preadv2(fd, 200 bytes, pos = LLONG_MAX - 50) = -1 EINVAL
preadv2(fd, 50 bytes, pos = LLONG_MAX - 50) = 0
With a large count, the range crosses LLONG_MAX even far from it:
splice() of a 20 MB file with a count of 0x7FFFFFFFFF000000 fails once
the position reaches 16 MB. sendfile(), aio and io_uring fail in the
same way as read() and splice().
Files with FOP_UNSIGNED_OFFSET, such as /dev/mem and /proc/pid/mem,
have the same problem at U64_MAX, their maximum offset: a read or
write that starts below U64_MAX but would end past it fails with
-EOVERFLOW.
Add rw_clamp_count(), which shortens the count so that the range ends
at the maximum offset, LLONG_MAX or U64_MAX for files with
FOP_UNSIGNED_OFFSET, 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.
A read that starts at the maximum offset returns 0. A write that starts
there cannot transfer anything and still fails in rw_verify_area(), as
do negative positions on files without FOP_UNSIGNED_OFFSET and counts
above SSIZE_MAX. For files with FOP_UNSIGNED_OFFSET, the file's own
read and write methods still decide how much of the shortened range
they can actually transfer.
rw_verify_area() keeps its check, so callers that are not converted
behave as before. 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>
---
v2:
- Also shorten I/O on files with FOP_UNSIGNED_OFFSET, so that the range
ends at U64_MAX (Paul Eggert).
- Fix readv() and writev() returning the requested length instead of 0
when the count is shortened to zero.
- Commit message: fix the cat reproducer, add the splice() case.
v1: https://lore.kernel.org/linux-fsdevel/20261120184225.257554-1-technoboy85@gmail.com/
fs/aio.c | 4 ++++
fs/read_write.c | 26 ++++++++++++++++++++++++--
fs/splice.c | 3 +++
include/linux/fs.h | 45 +++++++++++++++++++++++++++++++++++++++++++++
io_uring/rw.c | 16 ++++++++++++++++
5 files changed, 92 insertions(+), 2 deletions(-)
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..03b8b0f351b2 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,9 +1019,13 @@ 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)
+ if (!tot_len) {
+ ret = 0;
goto out;
+ }
ret = rw_verify_area(READ, file, pos, tot_len);
if (ret < 0)
@@ -1045,9 +1061,13 @@ 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)
+ if (!tot_len) {
+ ret = 0;
goto out;
+ }
ret = rw_verify_area(WRITE, file, pos, tot_len);
if (ret < 0)
@@ -1325,6 +1345,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 +1386,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..708d211d14de 100644
--- a/include/linux/fs.h
+++ b/include/linux/fs.h
@@ -3128,6 +3128,51 @@ 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 the maximum offset
+ * @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.
+ *
+ * The maximum offset is LLONG_MAX, or U64_MAX for files with
+ * FOP_UNSIGNED_OFFSET, whose positions are unsigned.
+ *
+ * Out-of-range positions and counts are left alone so that
+ * rw_verify_area() still rejects them. So is a write starting at the
+ * maximum offset, 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)
+{
+ u64 pos, max = LLONG_MAX;
+
+ if (!ppos || unlikely((ssize_t)count < 0))
+ return count;
+
+ pos = *ppos;
+ if (unlikely(file->f_op->fop_flags & FOP_UNSIGNED_OFFSET))
+ max = U64_MAX;
+ else if (unlikely(*ppos < 0))
+ return count;
+
+ if (likely(count <= max - pos))
+ return count;
+ if (read_write == WRITE && pos == max)
+ return count;
+
+ return 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 [flat|nested] 3+ messages in thread* Re: [PATCH v2] fs: shorten I/O that would extend past the maximum file offset
2026-11-21 0:33 [PATCH v2] fs: shorten I/O that would extend past the maximum file offset Matteo Croce
@ 2026-11-21 0:49 ` Matteo Croce
2026-11-21 21:59 ` Jens Axboe
0 siblings, 1 reply; 3+ messages in thread
From: Matteo Croce @ 2026-11-21 0:49 UTC (permalink / raw)
To: linux-fsdevel, Christian Brauner, Alexander Viro, Ding Feng, Jens Axboe
Cc: Paul Eggert, LKML, io-uring
Il giorno sab 21 nov 2026 alle ore 01:34 Matteo Croce
<technoboy85@gmail.com> ha scritto:
>
> 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 read a file up to an end at or near
> LLONG_MAX, even with ordinary buffer sizes. For example, dd fails on
> the last block, where it should get a short read, and cat fails where
> it should get end of file:
>
> $ truncate -s $((2**63 - 1)) hugefile
> $ dd if=hugefile of=/dev/null bs=1M skip=$((2**43 - 2))
> dd: error reading 'hugefile': Invalid argument
> 1+0 records in
> 1+0 records out
> 1048576 bytes (1,0 MB, 1,0 MiB) copied, 0,103536 s, 10,1 MB/s
>
> $ (dd bs=1 skip=$((2**63 - 1)) count=0 status=none; cat) < hugefile
> cat: -: Invalid argument
>
> The same happens on a 100-byte file:
>
> preadv2(fd, 200 bytes, pos = LLONG_MAX - 50) = -1 EINVAL
> preadv2(fd, 50 bytes, pos = LLONG_MAX - 50) = 0
>
> With a large count, the range crosses LLONG_MAX even far from it:
> splice() of a 20 MB file with a count of 0x7FFFFFFFFF000000 fails once
> the position reaches 16 MB. sendfile(), aio and io_uring fail in the
> same way as read() and splice().
>
> Files with FOP_UNSIGNED_OFFSET, such as /dev/mem and /proc/pid/mem,
> have the same problem at U64_MAX, their maximum offset: a read or
> write that starts below U64_MAX but would end past it fails with
> -EOVERFLOW.
>
> Add rw_clamp_count(), which shortens the count so that the range ends
> at the maximum offset, LLONG_MAX or U64_MAX for files with
> FOP_UNSIGNED_OFFSET, 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.
>
> A read that starts at the maximum offset returns 0. A write that starts
> there cannot transfer anything and still fails in rw_verify_area(), as
> do negative positions on files without FOP_UNSIGNED_OFFSET and counts
> above SSIZE_MAX. For files with FOP_UNSIGNED_OFFSET, the file's own
> read and write methods still decide how much of the shortened range
> they can actually transfer.
>
> rw_verify_area() keeps its check, so callers that are not converted
> behave as before. 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>
Forgot to re-run get_maintainer.pl after the io_uring change
Regards,
--
per aspera ad upstream
^ permalink raw reply [flat|nested] 3+ messages in thread
* Re: [PATCH v2] fs: shorten I/O that would extend past the maximum file offset
2026-11-21 0:49 ` Matteo Croce
@ 2026-11-21 21:59 ` Jens Axboe
0 siblings, 0 replies; 3+ messages in thread
From: Jens Axboe @ 2026-11-21 21:59 UTC (permalink / raw)
To: Matteo Croce, linux-fsdevel, Christian Brauner, Alexander Viro,
Ding Feng
Cc: Paul Eggert, LKML, io-uring
On 11/20/26 5:49 PM, Matteo Croce wrote:
> Il giorno sab 21 nov 2026 alle ore 01:34 Matteo Croce
> <technoboy85@gmail.com> ha scritto:
>>
>> 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 read a file up to an end at or near
>> LLONG_MAX, even with ordinary buffer sizes. For example, dd fails on
>> the last block, where it should get a short read, and cat fails where
>> it should get end of file:
>>
>> $ truncate -s $((2**63 - 1)) hugefile
>> $ dd if=hugefile of=/dev/null bs=1M skip=$((2**43 - 2))
>> dd: error reading 'hugefile': Invalid argument
>> 1+0 records in
>> 1+0 records out
>> 1048576 bytes (1,0 MB, 1,0 MiB) copied, 0,103536 s, 10,1 MB/s
>>
>> $ (dd bs=1 skip=$((2**63 - 1)) count=0 status=none; cat) < hugefile
>> cat: -: Invalid argument
>>
>> The same happens on a 100-byte file:
>>
>> preadv2(fd, 200 bytes, pos = LLONG_MAX - 50) = -1 EINVAL
>> preadv2(fd, 50 bytes, pos = LLONG_MAX - 50) = 0
>>
>> With a large count, the range crosses LLONG_MAX even far from it:
>> splice() of a 20 MB file with a count of 0x7FFFFFFFFF000000 fails once
>> the position reaches 16 MB. sendfile(), aio and io_uring fail in the
>> same way as read() and splice().
>>
>> Files with FOP_UNSIGNED_OFFSET, such as /dev/mem and /proc/pid/mem,
>> have the same problem at U64_MAX, their maximum offset: a read or
>> write that starts below U64_MAX but would end past it fails with
>> -EOVERFLOW.
>>
>> Add rw_clamp_count(), which shortens the count so that the range ends
>> at the maximum offset, LLONG_MAX or U64_MAX for files with
>> FOP_UNSIGNED_OFFSET, 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.
>>
>> A read that starts at the maximum offset returns 0. A write that starts
>> there cannot transfer anything and still fails in rw_verify_area(), as
>> do negative positions on files without FOP_UNSIGNED_OFFSET and counts
>> above SSIZE_MAX. For files with FOP_UNSIGNED_OFFSET, the file's own
>> read and write methods still decide how much of the shortened range
>> they can actually transfer.
>>
>> rw_verify_area() keeps its check, so callers that are not converted
>> behave as before. 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>
>
> Forgot to re-run get_maintainer.pl after the io_uring change
Maybe send it again then if it's something we shoudl see. You cut the
patch out of this reply...
--
Jens Axboe
^ permalink raw reply [flat|nested] 3+ messages in thread
end of thread, other threads:[~2026-11-21 21:59 UTC | newest]
Thread overview: 3+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2026-11-21 0:33 [PATCH v2] fs: shorten I/O that would extend past the maximum file offset Matteo Croce
2026-11-21 0:49 ` Matteo Croce
2026-11-21 21:59 ` Jens Axboe
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox
all inboxes | Powered by JetHome®