From: Mengmeng Zhao <[email protected]> -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 <[email protected]> Signed-off-by: Li Wang <[email protected]> --- .../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
