mirror of https://lore.kernel.org/lkml/
 help / color / mirror / Atom feed
From: Joseph Qi <joseph.qi@linux.alibaba.com>
To: Heming Zhao <heming.zhao@suse.com>
Cc: mark@fasheh.com, jlbec@evilplan.org, hch@lst.de,
	ocfs2-devel@lists.linux.dev, linux-kernel@vger.kernel.org
Subject: Re: [RFC PATCH v9 2/3] ocfs2: switch DIO read path from buffer_head to iomap
Date: Sun, 22 Nov 2026 22:41:12 +0800	[thread overview]
Message-ID: <77d9e06a-9111-44d8-b09d-c91bab908327@linux.alibaba.com> (raw)
In-Reply-To: <20261120060014.12087-3-heming.zhao@suse.com>



On 11/20/26 2:00 PM, Heming Zhao wrote:
> Migrates the DIO read path from the legacy buffer_head infrastructure
> to the modern and more efficient iomap framework.
> 
> Under the current code, ocfs2 holds a cluster lock during DIO via
> ocfs2_iocb_set_rw_locked(), and releases the cluster lock in
> ocfs2_dio_end_io() via ocfs2_iocb_clear_rw_locked(). The lock level is
> stashed in iocb->private.
> 
> However, iomap DIO owns that field (it stores a bio there for polled I/O
> and unconditionally clears it before calling ->end_io). Any side-channel
> state packed into iocb->private is corrupted, which trips the end_io
> lock-state check.
> 
> Instead, encode the unlock level by passing distinct iomap_dio_ops methods
> (ocfs2_iomap_dio_ops_pr for PRMODE or ocfs2_iomap_dio_ops_ex for EXMODE).

The code only defines ocfs2_iomap_dio_ops_r_pr, and ocfs2_iomap_dio_ops_w_pr /
ocfs2_iomap_dio_ops_w_ex are defined in next commit.

> Additionally, the *_iter() functions use the split __iomap_dio_rw() +
> iomap_dio_complete() API so they can determine unambiguously, from the
> return value, whether the completion handler already dropped the lock
> (real I/O, sync or -EIOCBQUEUED) or whether the caller must drop it
> (no I/O issued, or buffered fallback).
> 
> The new function ocfs2_iomap_begin() performs a similar role to
> ocfs2_get_block(). While ocfs2_get_block() retrieves only one block per
> call, ocfs2_iomap_begin() can handle multiple blocks at once. Limit the
> map offset and length in ocfs2_iomap_begin() to OCFS2_MAX_LOGICAL_BLOCK
> to avoid overflow issues.
> 
It seems OCFS2_MAX_LOGICAL_BLOCK not defined.

> Co-developed-by: Joseph Qi <joseph.qi@linux.alibaba.com>
> Signed-off-by: Joseph Qi <joseph.qi@linux.alibaba.com>
> Signed-off-by: Heming Zhao <heming.zhao@suse.com>
> ---
>  fs/ocfs2/Kconfig |   1 +
>  fs/ocfs2/aops.c  | 107 +++++++++++++++++++++++++++++++++++++++++++++--
>  fs/ocfs2/aops.h  |   5 +++
>  fs/ocfs2/file.c  |  60 ++++++++++++++++++++++----
>  4 files changed, 161 insertions(+), 12 deletions(-)
> 
> diff --git a/fs/ocfs2/Kconfig b/fs/ocfs2/Kconfig
> index 2514d36cbe01..bf1678a5eb01 100644
> --- a/fs/ocfs2/Kconfig
> +++ b/fs/ocfs2/Kconfig
> @@ -7,6 +7,7 @@ config OCFS2_FS
>  	select CRC32
>  	select QUOTA
>  	select QUOTA_TREE
> +	select FS_IOMAP
>  	select FS_POSIX_ACL
>  	select LEGACY_DIRECT_IO
>  	help
> diff --git a/fs/ocfs2/aops.c b/fs/ocfs2/aops.c
> index 64fcf6eb3d89..21cdc5c29331 100644
> --- a/fs/ocfs2/aops.c
> +++ b/fs/ocfs2/aops.c
> @@ -4,6 +4,7 @@
>   */
>  
>  #include <linux/fs.h>
> +#include <linux/iomap.h>
>  #include <linux/slab.h>
>  #include <linux/highmem.h>
>  #include <linux/pagemap.h>
> @@ -126,6 +127,19 @@ static int ocfs2_lock_get_block(struct inode *inode, sector_t iblock,
>  	return ret;
>  }
>  
> +static int ocfs2_lock_map_blocks(struct inode *inode,
> +				 struct ocfs2_map_block *map, int flags)
> +{
> +	int ret = 0;
> +	struct ocfs2_inode_info *oi = OCFS2_I(inode);
> +
> +	down_read(&oi->ip_alloc_sem);
> +	ret = ocfs2_map_blocks(inode, map, flags);
> +	up_read(&oi->ip_alloc_sem);
> +
> +	return ret;
> +}
> +
>  /* ocfs2 never allocates in this function */
>  int ocfs2_map_blocks(struct inode *inode, struct ocfs2_map_block *map,
>  		    int flags)
> @@ -171,8 +185,11 @@ int ocfs2_map_blocks(struct inode *inode, struct ocfs2_map_block *map,
>  			map->flags |= OCFS2_MAP_MAPPED;
>  	}
>  
> +	past_eof = ocfs2_blocks_for_bytes(inode->i_sb, i_size_read(inode));
> +
>  	if (!ocfs2_sparse_alloc(osb)) {
> -		if (map->pblk == 0) {
> +		/* detected a hole (unallocated extent) in a file */
> +		if (map->pblk == 0 && map->lblk < past_eof) {
>  			err = -EIO;
>  			mlog(ML_ERROR,
>  			     "iblock = %llu p_blkno = %llu blkno=(%llu)\n",
> @@ -187,8 +204,6 @@ int ocfs2_map_blocks(struct inode *inode, struct ocfs2_map_block *map,
>  		}
>  	}
>  
> -	past_eof = ocfs2_blocks_for_bytes(inode->i_sb, i_size_read(inode));
> -
>  	if (create && (map->lblk >= past_eof))
>  		map->flags |= OCFS2_MAP_NEW;
>  
> @@ -2532,6 +2547,92 @@ static ssize_t ocfs2_direct_IO(struct kiocb *iocb, struct iov_iter *iter)
>  				    ocfs2_dio_end_io, 0);
>  }
>  
> +static int ocfs2_iomap_begin(struct inode *inode, loff_t offset, loff_t length,
> +		unsigned int flags, struct iomap *iomap, struct iomap *srcmap)
> +{
> +	int ret;
> +	struct ocfs2_map_block map;
> +	u8 blkbits = inode->i_blkbits;
> +	u64 max_lblk = (inode->i_sb->s_maxbytes - 1) >> blkbits;
> +
> +	if ((offset >> blkbits) > max_lblk)
> +		return -EINVAL;
> +
> +	/*
> +	 * Calculate the first and last logical blocks respectively.
> +	 */
> +	map.lblk = offset >> blkbits;
> +	map.len = min_t(loff_t, (offset + length - 1) >> blkbits,
> +			max_lblk) - map.lblk + 1;
> +	map.flags = 0;
> +
> +	if (flags & IOMAP_WRITE) {
> +		return -EOPNOTSUPP;
> +	}
> +
> +	ret = ocfs2_lock_map_blocks(inode, &map, 0);
> +	if (ret < 0)
> +		return ret;
> +
> +	iomap->bdev = inode->i_sb->s_bdev;
> +	iomap->offset = (u64)map.lblk << blkbits;
> +	iomap->length = (u64)map.len << blkbits;
> +
> +	if (map.pblk == 0) {
> +		iomap->type = IOMAP_HOLE;
> +		iomap->addr = IOMAP_NULL_ADDR;
> +	} else {
> +		if (map.flags & OCFS2_MAP_UNWRITTEN) {
> +			iomap->type = IOMAP_UNWRITTEN;
> +		} else if (map.flags & OCFS2_MAP_MAPPED) {
> +			iomap->type = IOMAP_MAPPED;
> +		} else {
> +			WARN_ON_ONCE(1);
> +			return -EIO;
> +		}
> +		iomap->addr = (sector_t)map.pblk << blkbits;
> +	}
> +
> +	if (map.flags & OCFS2_MAP_NEW)
> +		iomap->flags |= IOMAP_F_NEW;
> +
> +	return 0;
> +}
> +
> +int ocfs2_iomap_next(const struct iomap_iter *iter, struct iomap *iomap,
> +			    struct iomap *srcmap)
> +{
> +	int ret;
> +
> +	if (iomap->length) {
> +		ret = iomap_iter_continue(iter, iomap, srcmap, 0);
> +		if (ret <= 0)
> +			return ret;
> +	}
> +
> +	ret = ocfs2_iomap_begin(iter->inode, iter->pos, iter->len, iter->flags,
> +				iomap, srcmap);
> +	return ret < 0 ? ret : 1;
> +}
> +
> +static int ocfs2_dio_end_io_r_pr(struct kiocb *iocb, ssize_t size,
> +				int error, unsigned int flags)
> +{
> +	struct inode *inode = file_inode(iocb->ki_filp);
> +
> +	if (error)
> +		mlog_ratelimited(ML_ERROR, "Direct IO failed, bytes = %lld errno:%d",
> +				 (long long)size, error);
> +
> +	ocfs2_rw_unlock(inode, 0);
> +
> +	return error;
> +}
> +
> +const struct iomap_dio_ops ocfs2_iomap_dio_ops_r_pr = {
> +	.end_io = ocfs2_dio_end_io_r_pr,
> +};
> +
>  const struct address_space_operations ocfs2_aops = {
>  	.dirty_folio		= block_dirty_folio,
>  	.read_folio		= ocfs2_read_folio,
> diff --git a/fs/ocfs2/aops.h b/fs/ocfs2/aops.h
> index 8dd6edd7c1a1..72de1e764a57 100644
> --- a/fs/ocfs2/aops.h
> +++ b/fs/ocfs2/aops.h
> @@ -7,6 +7,11 @@
>  #define OCFS2_AOPS_H
>  
>  #include <linux/fs.h>
> +#include <linux/iomap.h>
> +
> +extern const struct iomap_dio_ops ocfs2_iomap_dio_ops_r_pr;
> +int ocfs2_iomap_next(const struct iomap_iter *iter, struct iomap *iomap,
> +			    struct iomap *srcmap);
>  
>  int ocfs2_map_folio_blocks(struct folio *folio, u64 *p_blkno,
>  			  struct inode *inode, unsigned int from,
> diff --git a/fs/ocfs2/file.c b/fs/ocfs2/file.c
> index 82c88fa8e98f..e309ff9a56e5 100644
> --- a/fs/ocfs2/file.c
> +++ b/fs/ocfs2/file.c
> @@ -9,6 +9,7 @@
>  
>  #include <linux/capability.h>
>  #include <linux/fs.h>
> +#include <linux/iomap.h>
>  #include <linux/types.h>
>  #include <linux/slab.h>
>  #include <linux/highmem.h>
> @@ -2399,6 +2400,26 @@ static int ocfs2_prepare_inode_for_write(struct file *file,
>  	return ret;
>  }
>  
> +static bool ocfs2_should_use_dio(struct kiocb *iocb, struct iov_iter *iter,
> +				struct inode *inode)
> +{
> +	struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
> +
> +	/*
> +	 * Fallback to buffered I/O if we see an inode without
> +	 * extents.
> +	 */
> +	if (OCFS2_I(inode)->ip_dyn_features & OCFS2_INLINE_DATA_FL)
> +		return false;
> +
> +	/* Fallback to buffered I/O if we do not support append dio. */
> +	if (iocb->ki_pos + iter->count > i_size_read(inode) &&
> +	    !ocfs2_supports_append_dio(osb))
> +		return false;
> +
> +	return true;
> +}
> +
>  static ssize_t ocfs2_file_write_iter(struct kiocb *iocb,
>  				    struct iov_iter *from)
>  {
> @@ -2588,7 +2609,8 @@ static ssize_t ocfs2_file_read_iter(struct kiocb *iocb,
>  	if (!direct_io && nowait)
>  		return -EOPNOTSUPP;
>  
> -	ocfs2_iocb_init_rw_locked(iocb);
> +	if (!iov_iter_count(to))
> +		return 0; /* skip atime */
>  
>  	/*
>  	 * buffered reads protect themselves in ->read_folio().  O_DIRECT reads
> @@ -2606,8 +2628,6 @@ static ssize_t ocfs2_file_read_iter(struct kiocb *iocb,
>  			goto bail;
>  		}
>  		rw_level = 0;
> -		/* communicate with ocfs2_dio_end_io */
> -		ocfs2_iocb_set_rw_locked(iocb, rw_level);
>  	}
>  
>  	/*
> @@ -2628,17 +2648,39 @@ static ssize_t ocfs2_file_read_iter(struct kiocb *iocb,
>  	}
>  	ocfs2_inode_unlock(inode, lock_level);
>  
> -	ret = generic_file_read_iter(iocb, to);
> +	if (direct_io && ocfs2_should_use_dio(iocb, to, inode)) {
> +		/*
> +		 * Use the split iomap DIO API so we can tell who owns the
> +		 * rw_lock on return; reads always hold it at PR level, dropped
> +		 * by ocfs2_iomap_dio_ops_r_pr(). Call it directly rather than
> +		 * through generic_file_read_iter(): iomap advances iocb->ki_pos
> +		 * itself, so the generic helper would advance ki_pos twice.
> +		 */
> +		struct iomap_dio *dio;
> +
> +		dio = __iomap_dio_rw(iocb, to, ocfs2_iomap_next,
> +				&ocfs2_iomap_dio_ops_r_pr, 0, NULL, 0);
> +		if (dio == NULL) {
> +			/* No I/O issued; rw_lock still held. */
> +			ret = 0;
> +		} else if (IS_ERR(dio)) {
> +			ret = PTR_ERR(dio);
> +			if (ret == -EIOCBQUEUED)
> +				rw_level = -1;
> +		} else {
> +			ret = iomap_dio_complete(dio);
> +			rw_level = -1;
> +		}
> +		/* never fall back to buffered read */
> +	} else {
> +		iocb->ki_flags &= ~IOCB_DIRECT;
> +		ret = generic_file_read_iter(iocb, to);
> +	}
>  	trace_generic_file_read_iter_ret(ret);
>  
>  	/* buffered aio wouldn't have proper lock coverage today */
>  	BUG_ON(ret == -EIOCBQUEUED && !direct_io);
>  
> -	/* see ocfs2_file_write_iter */
> -	if (ret == -EIOCBQUEUED || !ocfs2_iocb_is_rw_locked(iocb)) {
> -		rw_level = -1;
> -	}
> -
>  bail:
>  	if (rw_level != -1)
>  		ocfs2_rw_unlock(inode, rw_level);


  parent reply	other threads:[~2026-11-22 14:41 UTC|newest]

Thread overview: 10+ messages / expand[flat|nested]  mbox.gz  Atom feed  top
2026-11-20  6:00 [RFC PATCH v9 0/3] migrate ocfs2 DIO " Heming Zhao
2026-11-20  6:00 ` [RFC PATCH v9 1/3] ocfs2: Add new ocfs2_map_blocks() to introduce iomap feature Heming Zhao
2026-11-20 18:34   ` Christoph Hellwig
2026-11-22 14:29     ` Joseph Qi
2026-11-20  6:00 ` [RFC PATCH v9 2/3] ocfs2: switch DIO read path from buffer_head to iomap Heming Zhao
2026-11-20 18:35   ` Christoph Hellwig
2026-11-22 14:41   ` Joseph Qi [this message]
2026-11-20  6:00 ` [RFC PATCH v9 3/3] ocfs2: switch dio write " Heming Zhao
2026-11-22 14:48   ` Joseph Qi
2026-11-21  1:12 ` [RFC PATCH v9 0/3] migrate ocfs2 DIO " Joseph Qi

Reply instructions:

You may reply publicly to this message via plain-text email
using any one of the following methods:

* Save the following mbox file, import it into your mail client,
  and reply-to-all from there: mbox

  Avoid top-posting and favor interleaved quoting:
  https://en.wikipedia.org/wiki/Posting_style#Interleaved_style

* Reply using the --to, --cc, and --in-reply-to
  switches of git-send-email(1):

  git send-email \
    --in-reply-to=77d9e06a-9111-44d8-b09d-c91bab908327@linux.alibaba.com \
    --to=joseph.qi@linux.alibaba.com \
    --cc=hch@lst.de \
    --cc=heming.zhao@suse.com \
    --cc=jlbec@evilplan.org \
    --cc=linux-kernel@vger.kernel.org \
    --cc=mark@fasheh.com \
    --cc=ocfs2-devel@lists.linux.dev \
    /path/to/YOUR_REPLY

  https://kernel.org/pub/software/scm/git/docs/git-send-email.html

* If your mail client supports setting the In-Reply-To header
  via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line before the message body.
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®