[RFC PATCH v2 3/8] iomap: don't ask for a buffered fallback for dma-buf iterators

From: Mengmeng Zhao

Date: Fri Nov 13 2026 - 05:44:11 EST


From: Mengmeng Zhao <zhaomengmeng@xxxxxxxxxx>

-ENOTBLK tells the caller to retry with buffered I/O. A dma-buf iterator
has no pages to copy, so the callers refuse that fallback, which would
turn the error into a successful transfer of zero bytes.

Report the reason instead: a busy folio becomes -EAGAIN, which the caller
can retry, any other invalidation failure keeps its error code, and
-ENOTBLK from ->iomap_begin() becomes -EOPNOTSUPP when nothing was
transferred. A partial direct I/O still reports its progress. Both
branches are reachable only through a file that opted into dma-buf I/O,
which ext4 does in the last patch.

Signed-off-by: Mengmeng Zhao <zhaomengmeng@xxxxxxxxxx>
Signed-off-by: Li Wang <liwang@xxxxxxxxxx>
---
.../filesystems/iomap/operations.rst | 3 +++
fs/iomap/direct-io.c | 20 +++++++++++++++++--
2 files changed, 21 insertions(+), 2 deletions(-)

diff --git a/Documentation/filesystems/iomap/operations.rst b/Documentation/filesystems/iomap/operations.rst
index da982ca7e413..ca59716d225c 100644
--- a/Documentation/filesystems/iomap/operations.rst
+++ b/Documentation/filesystems/iomap/operations.rst
@@ -513,6 +513,9 @@ Return Values
cache before issuing the I/O to storage.
The ``->iomap_begin`` or ``->iomap_end`` functions may also return
this value.
+ A dma-buf iterator cannot fall back to buffered I/O, so it gets
+ ``-EAGAIN`` when the failure is retryable and ``-EOPNOTSUPP`` when no
+ data could be transferred.

* ``-EIOCBQUEUED``: The asynchronous direct I/O request has been
queued and will be completed separately.
diff --git a/fs/iomap/direct-io.c b/fs/iomap/direct-io.c
index 4a2b0f9df5a7..83fda6973bb9 100644
--- a/fs/iomap/direct-io.c
+++ b/fs/iomap/direct-io.c
@@ -706,7 +706,9 @@ static int iomap_dio_iter(struct iomap_iter *iter, struct iomap_dio *dio)
* completing partial requests asynchronously.
*
* Returns -ENOTBLK In case of a page invalidation invalidation failure for
- * writes. The callers needs to fall back to buffered I/O in this case.
+ * writes. The callers needs to fall back to buffered I/O in this case. A
+ * dma-buf iterator cannot use that fallback, so it gets -EAGAIN when the
+ * failure is retryable and -EOPNOTSUPP when nothing was transferred.
*/
struct iomap_dio *
__iomap_dio_rw(struct kiocb *iocb, struct iov_iter *iter,
@@ -806,7 +808,7 @@ __iomap_dio_rw(struct kiocb *iocb, struct iov_iter *iter,
/*
* Try to invalidate cache pages for the range we are writing.
* If this invalidation fails, let the caller fall back to
- * buffered I/O.
+ * buffered I/O unless the iterator cannot be handled there.
*/
ret = kiocb_invalidate_pages(iocb, iomi.len);
if (ret) {
@@ -820,6 +822,14 @@ __iomap_dio_rw(struct kiocb *iocb, struct iov_iter *iter,
* the caller tries again.
*/
ret = -EAGAIN;
+ } else if (iov_iter_is_dmabuf_map(iter)) {
+ /*
+ * A dma-buf iterator has no buffered
+ * fallback, so -ENOTBLK would hide the
+ * real failure. A busy folio is retryable.
+ */
+ if (ret == -EBUSY)
+ ret = -EAGAIN;
} else {
/* fall back to buffered write */
ret = -ENOTBLK;
@@ -867,6 +877,12 @@ __iomap_dio_rw(struct kiocb *iocb, struct iov_iter *iter,
if (ret == -ENOTBLK) {
wait_for_completion = true;
ret = 0;
+ /*
+ * A dma-buf iterator cannot use that fallback. Anything
+ * already transferred is still reported as a short I/O.
+ */
+ if (!dio->size && iov_iter_is_dmabuf_map(iter))
+ ret = -EOPNOTSUPP;
}
if (ret < 0)
iomap_dio_set_error(dio, ret);
--
2.43.0