jbd2/ext4/ocfs2: lockless jinode dirty range
Subsystems (3)
v4 cover jbd2/ext4/ocfs2: lockless jinode dirty range
This series makes the jbd2_inode dirty range tracking safe for lockless reads in jbd2 and filesystem callbacks used by ext4 and ocfs2.
Some paths access jinode fields without holding journal->j_list_lock (e.g. fast commit helpers and ordered truncate helpers). v1 used READ_ONCE() on i_dirty_start/end, but Matthew pointed out that loff_t can be torn on 32-bit platforms, and Jan suggested storing the dirty range in PAGE_SIZE units as pgoff_t.
With this series, jbd2 stores the dirty range as page indexes and uses READ_ONCE()/WRITE_ONCE() for lockless access. ext4 and ocfs2 use the new jbd2_jinode_get_dirty_range() accessor which converts the page-based range back to byte offsets for writeback.
This is based on Jan's suggestion in the review of the ext4 jinode publication race fix. [1]
Changes since v3:
- Store i_dirty_end_page as an exclusive end page and drop the sentinel.
- Publish end_page before start_page and treat start_page >= end_page as empty.
Changes since v2:
- Add jbd2_jinode_get_dirty_range() accessor and convert ext4/ocfs2 to use it before switching the underlying representation (per Andreas).
- Rename the dirty range fields to i_dirty_start_page/end_page to make the PAGE_SIZE units explicit and avoid silent unit mismatches when bisecting.
Changes since v1:
- Store i_dirty_start/end in PAGE_SIZE units (pgoff_t) to avoid torn loads on 32-bit (pointed out by Matthew, suggested by Jan).
- Use WRITE_ONCE() for i_dirty_* / i_flags updates in jbd2 (per Jan).
- Drop pointless READ_ONCE() on i_vfs_inode in jbd2_wait_inode_data (per Jan).
- Convert ext4/ocfs2 callbacks to translate page range to byte offsets.
[1]: https://lore.kernel.org/all/4jxwogttddiaoqbstlgou5ox6zs27ngjjz5ukrxafm2z5ijxod@so4eqnykiegj/
v3: https://lore.kernel.org/all/[email protected]/
v2: https://lore.kernel.org/all/[email protected]/
v1: https://lore.kernel.org/all/[email protected]/
Li Chen (4):
jbd2: add jinode dirty range accessors
ext4: use jbd2 jinode dirty range accessor
ocfs2: use jbd2 jinode dirty range accessor
jbd2: store jinode dirty range in PAGE_SIZE units
fs/ext4/inode.c | 10 ++++++-- fs/ext4/super.c | 16 +++++++++---- fs/jbd2/commit.c | 55 +++++++++++++++++++++++++++++++++---------- fs/jbd2/journal.c | 5 ++-- fs/jbd2/transaction.c | 21 +++++++++++------ fs/ocfs2/journal.c | 9 +++++-- include/linux/jbd2.h | 38 ++++++++++++++++++++++++------ 7 files changed, 115 insertions(+), 39 deletions(-)
Signature · 1 line
2.53.0
PATCH v4 1/4 jbd2: add jinode dirty range accessors
Provide a helper to fetch jinode dirty ranges in bytes. This lets filesystem callbacks avoid depending on the internal representation, preparing for a later conversion to page units.
---
Changes since v3:
- Add Reviewed-by: Jan Kara.
Changes since v2:
- New patch: add jbd2_jinode_get_dirty_range() helper.
include/linux/jbd2.h | 14 ++++++++++++++ 1 file changed, 14 insertions(+)
include/linux/jbd2.h +14 -0
@@ -445,6 +445,20 @@ struct jbd2_inode {loff_t i_dirty_end; }; +static inline bool jbd2_jinode_get_dirty_range (const struct jbd2_inode *jinode, +loff_t *start,loff_t *end) +{ +loff_t start_byte = jinode->i_dirty_start; +loff_t end_byte = jinode->i_dirty_end; + +if (!end_byte) +return false; + + *start = start_byte; + *end = end_byte; +return true; +} +struct jbd2_revoke_table_s ;/**
Signature · 1 line
2.53.0
PATCH v4 2/4 ext4: use jbd2 jinode dirty range accessor
In reply to Li Chenext4 journal commit callbacks access jbd2_inode dirty range fields without holding journal->j_list_lock.
Use jbd2_jinode_get_dirty_range() to get the range in bytes, and read i_transaction with READ_ONCE() in the redirty check.
---
Changes since v3:
- No changes.
Changes since v2:
- Use jbd2_jinode_get_dirty_range() instead of direct i_dirty_* reads.
- Drop per-caller page->byte conversion (now handled by the accessor).
Changes since v1:
- Convert the jinode dirty range from PAGE_SIZE units (pgoff_t) back to byte offsets before passing it to writeback.
fs/ext4/inode.c | 10 ++++++++-- fs/ext4/super.c | 16 +++++++++++----- 2 files changed, 19 insertions(+), 7 deletions(-)
fs/ext4/inode.c +8 -2
@@ -3031,17 +3031,23 @@ static int ext4_writepages(struct address_space *mapping,int ext4_normal_submit_inode_data_buffers (struct jbd2_inode *jinode) { +loff_t range_start, range_end;struct writeback_control wbc = { .sync_mode =WB_SYNC_ALL , .nr_to_write =LONG_MAX , - .range_start = jinode->i_dirty_start, - .range_end = jinode->i_dirty_end, };struct mpage_da_data mpd = { .inode = jinode->i_vfs_inode, .wbc = &wbc, .can_map =0 , }; + +if (!jbd2_jinode_get_dirty_range (jinode, &range_start, &range_end)) +return 0 ; + + wbc.range_start = range_start; + wbc.range_end = range_end; +return ext4_do_writepages (&mpd); }
fs/ext4/super.c +11 -5
@@ -521,6 +521,7 @@ static bool ext4_journalled_writepage_needs_redirty(struct jbd2_inode *jinode, {struct buffer_head *bh, *head;struct journal_head *jh; +transaction_t *trans =READ_ONCE (jinode->i_transaction); bh = head =folio_buffers (folio); do {
@@ -539,7 +540,7 @@ static bool ext4_journalled_writepage_needs_redirty(struct jbd2_inode *jinode,*/ jh =bh2jh (bh);if (buffer_dirty (bh) || - (jh && (jh->b_transaction != jinode->i_transaction || + (jh && (jh->b_transaction != trans || jh->b_next_transaction)))return true; }while ((bh = bh->b_this_page) != head);
@@ -550,15 +551,20 @@ static bool ext4_journalled_writepage_needs_redirty(struct jbd2_inode *jinode,static int ext4_journalled_submit_inode_data_buffers (struct jbd2_inode *jinode) {struct address_space *mapping = jinode->i_vfs_inode->i_mapping; +loff_t range_start, range_end;struct writeback_control wbc = { - .sync_mode =WB_SYNC_ALL , + .sync_mode =WB_SYNC_ALL , .nr_to_write =LONG_MAX , - .range_start = jinode->i_dirty_start, - .range_end = jinode->i_dirty_end, - }; + };struct folio *folio =NULL ;int error; +if (!jbd2_jinode_get_dirty_range (jinode, &range_start, &range_end)) +return 0 ; + + wbc.range_start = range_start; + wbc.range_end = range_end; +/* * writeback_iter() already checks for dirty pages and calls * folio_clear_dirty_for_io(), which we want to write protect the
Signature · 1 line
2.53.0
PATCH v4 3/4 ocfs2: use jbd2 jinode dirty range accessor
In reply to Li Chenocfs2 journal commit callback reads jbd2_inode dirty range fields without holding journal->j_list_lock.
Use jbd2_jinode_get_dirty_range() to get the range in bytes.
---
Changes since v3:
- Add Reviewed-by: Jan Kara.
Changes since v2:
- Use jbd2_jinode_get_dirty_range() instead of direct i_dirty_* reads.
- Drop per-caller page->byte conversion (now handled by the accessor).
fs/ocfs2/journal.c | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-)
fs/ocfs2/journal.c +7 -2
@@ -902,8 +902,13 @@ int ocfs2_journal_alloc(struct ocfs2_super *osb)static int ocfs2_journal_submit_inode_data_buffers (struct jbd2_inode *jinode) { -return filemap_fdatawrite_range (jinode->i_vfs_inode->i_mapping, - jinode->i_dirty_start, jinode->i_dirty_end); +struct address_space *mapping = jinode->i_vfs_inode->i_mapping; +loff_t range_start, range_end; + +if (!jbd2_jinode_get_dirty_range (jinode, &range_start, &range_end)) +return 0 ; + +return filemap_fdatawrite_range (mapping, range_start, range_end); }int ocfs2_journal_init (struct ocfs2_super *osb,int *dirty)
Signature · 1 line
2.53.0
PATCH v4 4/4 jbd2: store jinode dirty range in PAGE_SIZE units
In reply to Li Chenjbd2_inode fields are updated under journal->j_list_lock, but some paths read them without holding the lock (e.g. fast commit helpers and ordered truncate helpers).
READ_ONCE() alone is not sufficient for the dirty range fields when they are stored as loff_t because 32-bit platforms can observe torn loads. Store the dirty range in PAGE_SIZE units as pgoff_t instead.
Represent the dirty range end as an exclusive end page. This avoids a special sentinel value and keeps MAX_LFS_FILESIZE on 32-bit representable.
Publish a new dirty range by updating end_page before start_page, and treat start_page >= end_page as empty in the accessor for robustness.
Use READ_ONCE() on the read side and WRITE_ONCE() on the write side for the dirty range and i_flags to match the existing lockless access pattern.
---
Changes since v3:
- Store i_dirty_end_page as an exclusive end page and drop the sentinel.
- Publish end_page before start_page and treat start_page >= end_page as empty in the accessor.
- Document the empty-range encoding and publication ordering in comments.
Changes since v2:
- Rename i_dirty_start/end to i_dirty_start_page/end_page.
- Use jbd2_jinode_get_dirty_range() for byte conversions in commit paths.
fs/jbd2/commit.c | 55 +++++++++++++++++++++++++++++++++---------- fs/jbd2/journal.c | 5 ++-- fs/jbd2/transaction.c | 21 +++++++++++------ include/linux/jbd2.h | 34 ++++++++++++++++---------- 4 files changed, 80 insertions(+), 35 deletions(-)
fs/jbd2/commit.c +42 -13
@@ -180,7 +180,13 @@ static int journal_wait_on_commit_record(journal_t *journal,/* Send all the data buffers related to an inode */ int jbd2_submit_inode_data (journal_t *journal,struct jbd2_inode *jinode) { -if (!jinode || !(jinode->i_flags &JI_WRITE_DATA )) +unsigned long flags; + +if (!jinode) +return 0 ; + + flags =READ_ONCE (jinode->i_flags); +if (!(flags &JI_WRITE_DATA ))return 0 ;trace_jbd2_submit_inode_data (jinode->i_vfs_inode);
@@ -191,12 +197,30 @@ EXPORT_SYMBOL(jbd2_submit_inode_data);int jbd2_wait_inode_data (journal_t *journal,struct jbd2_inode *jinode) { -if (!jinode || !(jinode->i_flags &JI_WAIT_DATA ) || - !jinode->i_vfs_inode || !jinode->i_vfs_inode->i_mapping) +struct address_space *mapping; +struct inode *inode; +unsigned long flags; +loff_t start_byte, end_byte; + +if (!jinode) +return 0 ; + + flags =READ_ONCE (jinode->i_flags); +if (!(flags &JI_WAIT_DATA )) +return 0 ; + + inode = jinode->i_vfs_inode; +if (!inode) +return 0 ; + + mapping = inode->i_mapping; +if (!mapping) +return 0 ; + +if (!jbd2_jinode_get_dirty_range (jinode, &start_byte, &end_byte))return 0 ;return filemap_fdatawait_range_keep_errors ( - jinode->i_vfs_inode->i_mapping, jinode->i_dirty_start, - jinode->i_dirty_end); + mapping, start_byte, end_byte); }EXPORT_SYMBOL (jbd2_wait_inode_data);
@@ -218,7 +242,8 @@ static int journal_submit_data_buffers(journal_t *journal,list_for_each_entry (jinode, &commit_transaction->t_inode_list, i_list) {if (!(jinode->i_flags &JI_WRITE_DATA ))continue ; - jinode->i_flags |=JI_COMMIT_RUNNING ; +WRITE_ONCE (jinode->i_flags, + jinode->i_flags |JI_COMMIT_RUNNING );spin_unlock (&journal->j_list_lock);/* submit the inode data buffers. */ trace_jbd2_submit_inode_data (jinode->i_vfs_inode);
@@ -229,7 +254,8 @@ static int journal_submit_data_buffers(journal_t *journal, }spin_lock (&journal->j_list_lock);J_ASSERT (jinode->i_transaction == commit_transaction); - jinode->i_flags &= ~JI_COMMIT_RUNNING ; +WRITE_ONCE (jinode->i_flags, + jinode->i_flags & ~JI_COMMIT_RUNNING );smp_mb ();wake_up_bit (&jinode->i_flags, __JI_COMMIT_RUNNING); }
@@ -240,10 +266,13 @@ static int journal_submit_data_buffers(journal_t *journal,int jbd2_journal_finish_inode_data_buffers (struct jbd2_inode *jinode) {struct address_space *mapping = jinode->i_vfs_inode->i_mapping; +loff_t start_byte, end_byte; + +if (!jbd2_jinode_get_dirty_range (jinode, &start_byte, &end_byte)) +return 0 ;return filemap_fdatawait_range_keep_errors (mapping, - jinode->i_dirty_start, - jinode->i_dirty_end); + start_byte, end_byte); }/*
@@ -262,7 +291,7 @@ static int journal_finish_inode_data_buffers(journal_t *journal,list_for_each_entry (jinode, &commit_transaction->t_inode_list, i_list) {if (!(jinode->i_flags &JI_WAIT_DATA ))continue ; - jinode->i_flags |=JI_COMMIT_RUNNING ; +WRITE_ONCE (jinode->i_flags, jinode->i_flags |JI_COMMIT_RUNNING );spin_unlock (&journal->j_list_lock);/* wait for the inode data buffers writeout. */ if (journal->j_finish_inode_data_buffers) {
@@ -272,7 +301,7 @@ static int journal_finish_inode_data_buffers(journal_t *journal, }cond_resched ();spin_lock (&journal->j_list_lock); - jinode->i_flags &= ~JI_COMMIT_RUNNING ; +WRITE_ONCE (jinode->i_flags, jinode->i_flags & ~JI_COMMIT_RUNNING );smp_mb ();wake_up_bit (&jinode->i_flags, __JI_COMMIT_RUNNING); }
@@ -288,8 +317,8 @@ static int journal_finish_inode_data_buffers(journal_t *journal, &jinode->i_transaction->t_inode_list); }else { jinode->i_transaction =NULL ; - jinode->i_dirty_start =0 ; - jinode->i_dirty_end =0 ; +WRITE_ONCE (jinode->i_dirty_start_page,0 ); +WRITE_ONCE (jinode->i_dirty_end_page,0 ); } }spin_unlock (&journal->j_list_lock);
fs/jbd2/journal.c +2 -3
@@ -3020,8 +3020,8 @@ void jbd2_journal_init_jbd_inode(struct jbd2_inode *jinode, struct inode *inode) jinode->i_next_transaction =NULL ; jinode->i_vfs_inode = inode; jinode->i_flags =0 ; - jinode->i_dirty_start =0 ; - jinode->i_dirty_end =0 ; + jinode->i_dirty_start_page =0 ; + jinode->i_dirty_end_page =0 ;INIT_LIST_HEAD (&jinode->i_list); }
@@ -3178,4 +3178,3 @@ MODULE_DESCRIPTION("Generic filesystem journal-writing module");MODULE_LICENSE ("GPL" );module_init (journal_init);module_exit (journal_exit); -
fs/jbd2/transaction.c +14 -7
@@ -2646,6 +2646,7 @@ static int jbd2_journal_file_inode(handle_t *handle, struct jbd2_inode *jinode, {transaction_t *transaction = handle->h_transaction;journal_t *journal; +pgoff_t start_page, end_page;if (is_handle_aborted (handle))return -EROFS ;
@@ -2654,15 +2655,21 @@ static int jbd2_journal_file_inode(handle_t *handle, struct jbd2_inode *jinode,jbd2_debug (4 ,"Adding inode %lu, tid:%d\n" , jinode->i_vfs_inode->i_ino, transaction->t_tid); + start_page = (pgoff_t)(start_byte >>PAGE_SHIFT ); + end_page = (pgoff_t)(end_byte >>PAGE_SHIFT ) +1 ; +spin_lock (&journal->j_list_lock); - jinode->i_flags |= flags; +WRITE_ONCE (jinode->i_flags, jinode->i_flags | flags); -if (jinode->i_dirty_end) { - jinode->i_dirty_start =min (jinode->i_dirty_start, start_byte); - jinode->i_dirty_end =max (jinode->i_dirty_end, end_byte); +if (jinode->i_dirty_start_page != jinode->i_dirty_end_page) { +WRITE_ONCE (jinode->i_dirty_start_page, +min (jinode->i_dirty_start_page, start_page)); +WRITE_ONCE (jinode->i_dirty_end_page, +max (jinode->i_dirty_end_page, end_page)); }else { - jinode->i_dirty_start = start_byte; - jinode->i_dirty_end = end_byte; +/* Publish a new non-empty range by making end visible first. */ +WRITE_ONCE (jinode->i_dirty_end_page, end_page); +WRITE_ONCE (jinode->i_dirty_start_page, start_page); }/* Is inode already attached where we need it? */
@@ -2739,7 +2746,7 @@ int jbd2_journal_begin_ordered_truncate(journal_t *journal,int ret =0 ;/* This is a quick check to avoid locking if not necessary */ -if (!jinode->i_transaction) +if (!READ_ONCE (jinode->i_transaction)) goto out;/* Locks are here just to force reading of recent values, it is * enough that the transaction was not committing before we started
include/linux/jbd2.h +22 -12
@@ -429,33 +429,43 @@ struct jbd2_inode {unsigned long i_flags;/** -* @i_dirty_start: +* @i_dirty_start_page: +* +* Dirty range start in PAGE_SIZE units. +* +* The dirty range is empty if @i_dirty_start_page is greater than or +* equal to @i_dirty_end_page. * -* Offset in bytes where the dirty range for this inode starts. * [j_list_lock] */ -loff_t i_dirty_start; +pgoff_t i_dirty_start_page;/** -* @i_dirty_end: +* @i_dirty_end_page: +* +* Dirty range end in PAGE_SIZE units (exclusive). * -* Inclusive offset in bytes where the dirty range for this inode -* ends. [j_list_lock] +* [j_list_lock] */ -loff_t i_dirty_end; +pgoff_t i_dirty_end_page; }; +/* +* Lockless readers treat start_page >= end_page as an empty range. +* Writers publish a new non-empty range by storing i_dirty_end_page before +* i_dirty_start_page. +*/ static inline bool jbd2_jinode_get_dirty_range (const struct jbd2_inode *jinode,loff_t *start,loff_t *end) { -loff_t start_byte = jinode->i_dirty_start; -loff_t end_byte = jinode->i_dirty_end; +pgoff_t start_page =READ_ONCE (jinode->i_dirty_start_page); +pgoff_t end_page =READ_ONCE (jinode->i_dirty_end_page); -if (!end_byte) +if (start_page >= end_page)return false; - *start = start_byte; - *end = end_byte; + *start = (loff_t )start_page <<PAGE_SHIFT ; + *end = ((loff_t )end_page <<PAGE_SHIFT ) -1 ;return true; }
Signature · 1 line
2.53.0
Hi,
Just a gentle ping on this series posted on March 6, 2026.
The current v4 has Reviewed-by tags from Jan on all four patches. If there are no further concerns, could you please consider it for merging?
I'm happy to resend if that would help.
Thanks,
Li
Hi,
One more note: if there are any remaining concerns or comments on the series, please let me know and I'll address them promptly.
Thanks,
Li
Quoted 10 lines · Li Chen
This series makes the
jbd2_inodedirty range tracking safe for lockless reads in jbd2 and filesystem callbacks used by ext4 and ocfs2.Some paths access jinode fields without holding
journal->j_list_lock(e.g. fast commit helpers and ordered truncate helpers). v1 usedREAD_ONCE()on i_dirty_start/end, but Matthew pointed out thatloff_tcan be torn on 32-bit platforms, and Jan suggested storing the dirty range inPAGE_SIZEunits aspgoff_t.[...]
Applied, thanks!
[1/4] jbd2: add jinode dirty range accessors
commit: 5267f6ef49cb5fba426f2d286817b1355fde31da
[2/4] ext4: use jbd2 jinode dirty range accessor
commit: 660d23669982202c99798658e2a15ccdd001f82b
[3/4] ocfs2: use jbd2 jinode dirty range accessor
commit: be81084e032c2d74f51173e30f687ce13476cb73
[4/4] jbd2: store jinode dirty range in PAGE_SIZE units
commit: 4edafa81a1d6020272d0c6eb68faeb810dd083c1Best regards,
Signature · 1 line
Theodore Ts'o <[email protected]>