[RFC PATCH v2 8/8] ext4: support dma-buf registered buffers for direct I/O

From: Mengmeng Zhao

Date: Fri Nov 13 2026 - 02:34:22 EST


From: Mengmeng Zhao <zhaomengmeng@xxxxxxxxxx>

Advertise FMODE_CAN_DMABUF_IO for inodes that can support dma-buf I/O
and implement ->init_dma_buf_io_ctx() by registering the buffer against
the filesystem's block device. The capability follows
ext4_dio_alignment(), so an inode that can never do direct I/O -
fs-verity, data=journal or inline data - is refused at open, and
encrypted inodes are refused on the inode flag, which is set even
without CONFIG_FS_ENCRYPTION. The inode is rechecked at registration
because DAX can be enabled after the file was opened.

A dma-buf iterator has no pages to copy from, so it must never reach the
page cache. ext4_buffered_read_iter() and ext4_buffered_write_iter() are
the single sinks of the buffered fallbacks and refuse it there; a short
direct I/O write still reports its progress, and the DAX write path
refuses at its entry instead of after starting a journal handle.

Signed-off-by: Mengmeng Zhao <zhaomengmeng@xxxxxxxxxx>
Signed-off-by: Li Wang <liwang@xxxxxxxxxx>
---
fs/ext4/ext4.h | 11 +++++++++++
fs/ext4/file.c | 44 +++++++++++++++++++++++++++++++++++++++++---
2 files changed, 52 insertions(+), 3 deletions(-)

diff --git a/fs/ext4/ext4.h b/fs/ext4/ext4.h
index f38fec3167fb..028b2e5ddc8b 100644
--- a/fs/ext4/ext4.h
+++ b/fs/ext4/ext4.h
@@ -4135,6 +4135,17 @@ static inline bool ext4_inode_can_atomic_write(struct inode *inode)
EXT4_SB(inode->i_sb)->s_awu_min > 0;
}

+/*
+ * dma-buf I/O needs an inode that supports direct I/O without the page cache.
+ * IS_ENCRYPTED() tests the inode flag, which is set even without
+ * CONFIG_FS_ENCRYPTION.
+ */
+static inline bool ext4_inode_can_dmabuf_io(struct inode *inode)
+{
+ return !IS_DAX(inode) && !IS_ENCRYPTED(inode) &&
+ ext4_dio_alignment(inode) != 0;
+}
+
extern int ext4_block_write_begin(handle_t *handle, struct folio *folio,
loff_t pos, unsigned len,
get_block_t *get_block);
diff --git a/fs/ext4/file.c b/fs/ext4/file.c
index 50d3c92709c8..5a8481637da5 100644
--- a/fs/ext4/file.c
+++ b/fs/ext4/file.c
@@ -30,6 +30,7 @@
#include <linux/uio.h>
#include <linux/mman.h>
#include <linux/backing-dev.h>
+#include <linux/blkdev.h>
#include "ext4.h"
#include "ext4_jbd2.h"
#include "xattr.h"
@@ -66,6 +67,15 @@ static bool ext4_should_use_dio(struct kiocb *iocb, struct iov_iter *iter)
return IS_ALIGNED(iocb->ki_pos | iov_iter_alignment(iter), dio_align);
}

+static ssize_t ext4_buffered_read_iter(struct kiocb *iocb, struct iov_iter *to)
+{
+ /* a dma-buf iterator has no pages for the page cache to copy into */
+ if (iov_iter_is_dmabuf_map(to))
+ return -EOPNOTSUPP;
+
+ return generic_file_read_iter(iocb, to);
+}
+
static ssize_t ext4_dio_read_iter(struct kiocb *iocb, struct iov_iter *to)
{
ssize_t ret;
@@ -88,7 +98,7 @@ static ssize_t ext4_dio_read_iter(struct kiocb *iocb, struct iov_iter *to)
* taken.
*/
iocb->ki_flags &= ~IOCB_DIRECT;
- return generic_file_read_iter(iocb, to);
+ return ext4_buffered_read_iter(iocb, to);
}

ret = iomap_dio_read_simple(iocb, to, ext4_iomap_begin);
@@ -119,7 +129,7 @@ static ssize_t ext4_dax_read_iter(struct kiocb *iocb, struct iov_iter *to)
if (!IS_DAX(inode)) {
inode_unlock_shared(inode);
/* Fallback to buffered IO in case we cannot support DAX */
- return generic_file_read_iter(iocb, to);
+ return ext4_buffered_read_iter(iocb, to);
}
ret = dax_iomap_rw(iocb, to, &ext4_iomap_ops);
inode_unlock_shared(inode);
@@ -146,7 +156,7 @@ static ssize_t ext4_file_read_iter(struct kiocb *iocb, struct iov_iter *to)
if (iocb->ki_flags & IOCB_DIRECT)
return ext4_dio_read_iter(iocb, to);

- return generic_file_read_iter(iocb, to);
+ return ext4_buffered_read_iter(iocb, to);
}

static ssize_t ext4_file_splice_read(struct file *in, loff_t *ppos,
@@ -354,6 +364,10 @@ static ssize_t ext4_buffered_write_iter(struct kiocb *iocb,
if (iocb->ki_flags & IOCB_NOWAIT)
return -EOPNOTSUPP;

+ /* a dma-buf iterator cannot be handled by buffered I/O */
+ if (iov_iter_is_dmabuf_map(from))
+ return -EOPNOTSUPP;
+
inode_lock(inode);

/*
@@ -688,6 +702,10 @@ static ssize_t ext4_dio_write_iter(struct kiocb *iocb, struct iov_iter *from)
ssize_t err;
loff_t endbyte;

+ /* a dma-buf iterator cannot fall back to buffered I/O */
+ if (iov_iter_is_dmabuf_map(from))
+ return ret;
+
/*
* There is no support for atomic writes on buffered-io yet,
* we should never fallback to buffered-io for DIO atomic
@@ -731,6 +749,10 @@ ext4_dax_write_iter(struct kiocb *iocb, struct iov_iter *from)
bool extend = false;
struct inode *inode = file_inode(iocb->ki_filp);

+ /* a dma-buf iterator cannot be handled by DAX either */
+ if (iov_iter_is_dmabuf_map(from))
+ return -EOPNOTSUPP;
+
if (iocb->ki_flags & IOCB_NOWAIT) {
if (!inode_trylock(inode))
return -EAGAIN;
@@ -1014,6 +1036,8 @@ static int ext4_file_open(struct inode *inode, struct file *filp)
filp->f_mode |= FMODE_CAN_ATOMIC_WRITE;

filp->f_mode |= FMODE_NOWAIT | FMODE_CAN_ODIRECT;
+ if (ext4_inode_can_dmabuf_io(inode))
+ filp->f_mode |= FMODE_CAN_DMABUF_IO;
return dquot_file_open(inode, filp);
}

@@ -1050,10 +1074,24 @@ loff_t ext4_llseek(struct file *file, loff_t offset, int whence)
return vfs_setpos(file, offset, maxbytes);
}

+static int ext4_file_init_dma_buf_io_ctx(struct file *file,
+ struct dma_buf_io_ctx *ctx)
+{
+ struct inode *inode = file_inode(file);
+
+ /* DAX can be enabled after the file was opened */
+ if (!ext4_inode_can_dmabuf_io(inode))
+ return -EOPNOTSUPP;
+
+ /* all file data lives on s_bdev, which never changes for ext4 */
+ return bdev_init_dma_buf_io_ctx(inode->i_sb->s_bdev, ctx);
+}
+
const struct file_operations ext4_file_operations = {
.llseek = ext4_llseek,
.read_iter = ext4_file_read_iter,
.write_iter = ext4_file_write_iter,
+ .init_dma_buf_io_ctx = ext4_file_init_dma_buf_io_ctx,
.iopoll = iocb_bio_iopoll,
.unlocked_ioctl = ext4_ioctl,
#ifdef CONFIG_COMPAT
--
2.43.0