From mboxrd@z Thu Jan 1 00:00:00 1970 Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.remote-ip=209.85.208.171 ARC-Seal: i=1; d=subspace.kernel.org; s=arc20261015; a=rsa-sha256; cv=none; t=1794927673; b=Kgnhg9UatAwtAG+zrAHHxXnpdVYeSL3THF80GguQ1XaftAciIun+JHKq/qGe2/vVhTDr HQC2OBZjsALRWuDSSi+AZSTp2nHBJGJkMUYeH1yS486dh3+f5e/F86wErAnJUMtY9WKkh PpNWI11loDq/abdovPXFLG9yT3hTU6TznVZhW+3K3ePFK4fTbs4/2xX1eWhRycLw5AC1c BgaDHnvYaFXr8TFekq/FqCY90wdy8RNu705ns+dzgN70XnpiNyUFt4Ez36YKYpli1dsDf xA2M+3/bbok3UWZEZxKKCgC31chWaZS384P9jMXV1ykR0Ma9vmx1r778YRTg/xANPRg== ARC-Message-Signature: i=1; d=subspace.kernel.org; s=arc20261015; a=rsa-sha256; c=relaxed/relaxed; t=1794927673; h=DMARC-Filter:Received:DKIM-Signature:X-Google-DKIM-Signature: X-Forwarded-Encrypted:X-Gm-Message-State:X-Gm-Gg:X-Received:Received: From:To:Cc:Subject:Date:Message-ID:X-Mailer:In-Reply-To:References: MIME-Version:Content-Transfer-Encoding; bh=Y+AMRdczw9/yzmKxjNzGoCNND5U8YTxpA2P7UKTJXJI=; b=AFoRc1tAayBSOo1BBk7EgCCDZlNVQ/ANE9LQPHgsLiH4RZjxBj4ixlN3njRCjod0rg6Y rORLtc1KCcF3Cxoeaio2P2jenBP9tMeKCLuwpaUKakxrck6BYbSQngoOaBp55ptDrqIgk fH6x/1P3sQoWjqwYGNjBhsX82izBhfwDdggm/7GdhWh0UpVR/+LO5RBbgg6AQs4zzfQkn Q/siBXrDjuhRlb3tWvjeD42cREzvyhPKoDp0ALrwpBuAuKfSDVV1BkoF0UhZ97aRMikaD 6YxiGsEdPxfaDWTD16LMqLhHxPLBoi560/G89QytICb9TVJEWXBlkNVpT6ymfY2EUSQ== ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass header.from=suse.com; spf=pass smtp.mailfrom=suse.com; dkim=pass header.d=suse.com header.i=@suse.com header.a=rsa-sha256 header.s=google header.b=XLYg2VE2; arc=none smtp.remote-ip=209.85.208.171 Received: from mail-lj1-f171.google.com (mail-lj1-f171.google.com [209.85.208.171]) (using TLSv1.3 with cipher TLS_AES_128_GCM_SHA256 (128/128 bits) key-exchange X25519 server-signature ECDSA (prime256v1) server-digest SHA256) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id F09C4606A32F for ; Tue, 17 Nov 2026 15:01:12 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.4.2 smtp.subspace.kernel.org F09C4606A32F Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=quarantine dis=none) header.from=suse.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=suse.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=suse.com header.i=@suse.com header.a=rsa-sha256 header.s=google header.b=XLYg2VE2 Received: by mail-lj1-f171.google.com with SMTP id 38308e7fff4ca-3ab43d1dbceso8136121fa.1 for ; Tue, 17 Nov 2026 07:01:12 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=suse.com; s=google; t=1794927671; x=1795532471; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to:content-type; bh=Y+AMRdczw9/yzmKxjNzGoCNND5U8YTxpA2P7UKTJXJI=; b=XLYg2VE21SSmW4AoWl46jKO6saknV8c+tVLLjpgM9TsWjKWQw693m1RE8+tcyNO8Pk emt5QyBAhCq5g3ilvctoStkQgCfpfIJSYXAJiKQNjEBkztSNAh5DRZjPI4NL2ltth8BS rDIr8WEd/j3kWuU94/MPmIh1nNUvCSuqkogiDJbNRIK/BCiQWAu8xSED5kTMnn24jfEG XYIRKEClRpfFWEPeFJr1gY89YY0nLLJ/i9Pe9S0n9rH6PcI4XVS88/gXMr18y6YafmZP 6XqgcmnhjgeWYTRTJ8wSTzW/ngH1sNKvP6FstJnezR0BbcP0IPiibclnwQZLLT5nYoHn r0lg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20260707; t=1794927671; x=1795532471; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-gg:x-gm-message-state:from :to:cc:subject:date:message-id:reply-to:content-type; bh=Y+AMRdczw9/yzmKxjNzGoCNND5U8YTxpA2P7UKTJXJI=; b=BYOeUIcixfW6S19d8unpuo2A/jVpYnc6DZhZtLiAYyU3yHcT6S9hSDHEd6/sx/PBoo zm+nhuDB0ZfyFkY8DgBN088JnHMbE6Jg10i6TYCLF2kYkQ03xarCqYj5MVAAczGLJlr1 qVZs3sGcxZ6D6iLZF8ng3MIBOfcrVrVA6qNRVT5GTVYI4AvXu3remILJ/tsEH5s5YoS/ ssbWBEfhxgrJIFNg7Y55wepXXOXTdsrZZhyjiCNNXUk0JMEJ+JX46CKOeinTVguAQfYq yorAN2kmfdYptRjkqLmFsYSVcxrDzBWOfUhTc7ZMXePZ+Hi33WCVTLramlGiuDcjxvoP laJg== X-Forwarded-Encrypted: i=1; AL+hErFy+FbJy+vdeg8wcpxIA2grclMvPBGYT6qmFo2jE9EWURtzcAVj5d0yfEeNnl9aV1CNRbpdjGEpqaNppos=@vger.kernel.org X-Gm-Message-State: APuU4Z8Q4K+DLjU+lR3iIA1GlkXXUq6IP1o0IB/Izc6CXrvtFFJ7ST9d GEulPAerJuxrl01XIcpk0PEa1SOFqy+pk17DMYnVU3oAhG2YqIbEwFomAcxUXU2TCQo= X-Gm-Gg: AYBFou3Ls2wpo77gEOd+EKiPcy9dSFryaLpfZFNUAuGS4jdWAWiT3qdmWERad8Zvck5 +azAP20vJTGyWDOpxku+HnBA5VCdAL5UgB1J3hJPWE+7EtE5iKyC86AdKY23F+LFIv3hJ4QKKcb ZQzXERDWt1w5oTCmLFwB/k5KnqeJRXof9ouCxkpOzzZ0VWxICbfMugUr2YIzmLtd/l/zBv9jlym AfzTh4Jy06VKVggyovwq1PV1tfilK2vy8bGTpe/i0tTWSTElr/OONkEXtl7LkHyt4EaSW0uG1ds PYgA2TbBzP3VbZQM6D5Fkr73PTrz7/wfN85k6gLggMJ0TjWytw5m3pzkFyo18f1K/s/fflXMTfR pSeIfgXQF4zAkol+ebqsQtMwuRT12RVrmccODazO2j3p14+SDWYXuB5jgQGgTJkZb4fFUWT2BQZ nxNmv2NsPLDxlcCh3SRvjpZLuZx1Y1fDJuUTGSgNehs6nacRh53Jup4u6HiWkXD+0yXxKTz1owH Op0TjOv3AePD1IzwvmU1A5Hifo40GWC+F9Gfkc0EpPgI3WD71GLiO9+TcaoKdMhBgsql0QijMDi T2jE4DpYkIYtuJamnPTHzb0HsY9/ohKHTqPUDmJV7SI= X-Received: by 2002:a05:651c:e112:20b0:3ab:1d67:caf with SMTP id 38308e7fff4ca-3ae2b394355mr36927401fa.0.1794927671013; Tue, 17 Nov 2026 07:01:11 -0800 (PST) Received: from localhost.localdomain ([202.127.77.110]) by smtp.gmail.com with ESMTPSA id a92af1059eb24-1b50309b2b5sm35904028c88.1.2026.11.17.07.01.07 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 17 Nov 2026 07:01:09 -0800 (PST) From: Heming Zhao To: joseph.qi@linux.alibaba.com, mark@fasheh.com, jlbec@evilplan.org, hch@lst.de Cc: Heming Zhao , ocfs2-devel@lists.linux.dev, linux-kernel@vger.kernel.org Subject: [RFC PATCH v7 2/3] ocfs2: switch DIO read path from buffer_head to iomap Date: Tue, 17 Nov 2026 23:00:51 +0800 Message-ID: <20261117150053.18417-3-heming.zhao@suse.com> X-Mailer: git-send-email 2.55.0 In-Reply-To: <20261117150053.18417-1-heming.zhao@suse.com> References: <20261117150053.18417-1-heming.zhao@suse.com> X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Post: List-Help: List-Subscribe: List-Unsubscribe: List-Owner: Precedence: list MIME-Version: 1.0 Content-Transfer-Encoding: 8bit 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). 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. Co-developed-by: Joseph Qi Signed-off-by: Joseph Qi Signed-off-by: Heming Zhao --- fs/ocfs2/Kconfig | 1 + fs/ocfs2/aops.c | 110 +++++++++++++++++++++++++++++++++++++++++++++-- fs/ocfs2/aops.h | 5 +++ fs/ocfs2/file.c | 60 ++++++++++++++++++++++---- 4 files changed, 164 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..1412bfe6e5da 100644 --- a/fs/ocfs2/aops.c +++ b/fs/ocfs2/aops.c @@ -4,6 +4,7 @@ */ #include +#include #include #include #include @@ -39,6 +40,9 @@ #define OCFS2_DIO_MARK_EXTENT_BATCH 200 +int ocfs2_map_blocks(struct inode *inode, struct ocfs2_map_block *map, + int flags); + static int ocfs2_symlink_get_block(struct inode *inode, sector_t iblock, struct buffer_head *bh_result, int create) { @@ -126,6 +130,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 +188,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->pblk < past_eof) { err = -EIO; mlog(ML_ERROR, "iblock = %llu p_blkno = %llu blkno=(%llu)\n", @@ -187,8 +207,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 +2550,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, iter->private); + 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 +#include + +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..ae1950bd318d 100644 --- a/fs/ocfs2/file.c +++ b/fs/ocfs2/file.c @@ -9,6 +9,7 @@ #include #include +#include #include #include #include @@ -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_end_io_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); -- 2.55.0