UbiquitousOS
/
OpenCloudOS-Kernel
mirror of https://gitee.com/OpenCloudOS/OpenCloudOS-Kernel.git
11
0
Fork 0
Code Issues Projects Releases Wiki Activity

jbd2: move the clearing of b_modified flag to the journal_unmap_buffer() 

There is no need to delay the clearing of b_modified flag to the
transaction committing time when unmapping the journalled buffer, so
just move it to the journal_unmap_buffer().

Link: https://lore.kernel.org/r/20200213063821.30455-2-yi.zhang@huawei.com
Reviewed-by: Jan Kara <jack@suse.cz>
Signed-off-by: zhangyi (F) <yi.zhang@huawei.com>
Signed-off-by: Theodore Ts'o <tytso@mit.edu>
Cc: stable@kernel.org
This commit is contained in:
zhangyi (F) 2020-02-13 14:38:20 +08:00 committed by Theodore Ts'o
parent af133ade9a
commit 6a66a7ded1
2 changed files with 21 additions and 32 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

43
fs/jbd2/commit.c
View File

@ -976,34 +976,21 @@ restart_loop:
* it. */ * it. */
/* /*
* A buffer which has been freed while still being journaled by * A buffer which has been freed while still being journaled
* a previous transaction. * by a previous transaction, refile the buffer to BJ_Forget of
*/ * the running transaction. If the just committed transaction
if (buffer_freed(bh)) { * contains "add to orphan" operation, we can completely
/* * invalidate the buffer now. We are rather through in that
* If the running transaction is the one containing * since the buffer may be still accessible when blocksize <
* "add to orphan" operation (b_next_transaction != * pagesize and it is attached to the last partial page.
* NULL), we have to wait for that transaction to */
* commit before we can really get rid of the buffer. if (buffer_freed(bh) && !jh->b_next_transaction) {
* So just clear b_modified to not confuse transaction clear_buffer_freed(bh);
* credit accounting and refile the buffer to clear_buffer_jbddirty(bh);
* BJ_Forget of the running transaction. If the just clear_buffer_mapped(bh);
* committed transaction contains "add to orphan" clear_buffer_new(bh);
* operation, we can completely invalidate the buffer clear_buffer_req(bh);
* now. We are rather through in that since the bh->b_bdev = NULL;
* buffer may be still accessible when blocksize <
* pagesize and it is attached to the last partial
* page.
*/
jh->b_modified = 0;
if (!jh->b_next_transaction) {
clear_buffer_freed(bh);
clear_buffer_jbddirty(bh);
clear_buffer_mapped(bh);
clear_buffer_new(bh);
clear_buffer_req(bh);
bh->b_bdev = NULL;
}
} }
if (buffer_jbddirty(bh)) { if (buffer_jbddirty(bh)) {

10
fs/jbd2/transaction.c
View File

@ -2329,14 +2329,16 @@ static int journal_unmap_buffer(journal_t *journal, struct buffer_head *bh,
return -EBUSY; return -EBUSY;
} }
/* /*
* OK, buffer won't be reachable after truncate. We just set * OK, buffer won't be reachable after truncate. We just clear
* j_next_transaction to the running transaction (if there is * b_modified to not confuse transaction credit accounting, and
* one) and mark buffer as freed so that commit code knows it * set j_next_transaction to the running transaction (if there
* should clear dirty bits when it is done with the buffer. * is one) and mark buffer as freed so that commit code knows
* it should clear dirty bits when it is done with the buffer.
*/ */
set_buffer_freed(bh); set_buffer_freed(bh);
if (journal->j_running_transaction && buffer_jbddirty(bh)) if (journal->j_running_transaction && buffer_jbddirty(bh))
jh->b_next_transaction = journal->j_running_transaction; jh->b_next_transaction = journal->j_running_transaction;
jh->b_modified = 0;
spin_unlock(&journal->j_list_lock); spin_unlock(&journal->j_list_lock);
spin_unlock(&jh->b_state_lock); spin_unlock(&jh->b_state_lock);
write_unlock(&journal->j_state_lock); write_unlock(&journal->j_state_lock);