From 72f76191882601772a68d7c0343ddb99138ff349 Mon Sep 17 00:00:00 2001 From: Theodore Ts'o Date: Thu, 18 Sep 2014 01:01:54 -0400 Subject: [PATCH] add patch simplify-calling-convention-around-jbd2_journal_clean_checkpoint_list --- series | 1 + ...ntion-around-jbd2_journal_clean_checkpoint_list | 140 +++++++++++++++++++++ timestamps | 7 +- 3 files changed, 145 insertions(+), 3 deletions(-) create mode 100644 simplify-calling-convention-around-jbd2_journal_clean_checkpoint_list diff --git a/series b/series index 1728710d..6669c6df 100644 --- a/series +++ b/series @@ -56,6 +56,7 @@ jbd2_log_wait_for_space-improve-error-detection explicit-inform-user-about-orphan-list-cleanup avoid-pointless-scanning-of-checkpoint-lists +simplify-calling-convention-around-jbd2_journal_clean_checkpoint_list ########################################## # unstable patches diff --git a/simplify-calling-convention-around-jbd2_journal_clean_checkpoint_list b/simplify-calling-convention-around-jbd2_journal_clean_checkpoint_list new file mode 100644 index 00000000..3cf59d18 --- /dev/null +++ b/simplify-calling-convention-around-jbd2_journal_clean_checkpoint_list @@ -0,0 +1,140 @@ +jbd2: simplify calling convention around __jbd2_journal_clean_checkpoint_list + +From: Jan Kara + +__jbd2_journal_clean_checkpoint_list() returns number of buffers it +freed but noone was using the value so just stop doing that. This +also allows for simplifying the calling convention for +journal_clean_once_cp_list(). + +Signed-off-by: Jan Kara +Signed-off-by: Theodore Ts'o +--- + fs/jbd2/checkpoint.c | 56 ++++++++++++++++++++++++-------------------------------- + include/linux/jbd2.h | 2 +- + 2 files changed, 25 insertions(+), 33 deletions(-) + +diff --git a/fs/jbd2/checkpoint.c b/fs/jbd2/checkpoint.c +index 3ab4c5e..988b32e 100644 +--- a/fs/jbd2/checkpoint.c ++++ b/fs/jbd2/checkpoint.c +@@ -421,16 +421,15 @@ int jbd2_cleanup_journal_tail(journal_t *journal) + * release them. + * + * Called with j_list_lock held. +- * Returns number of buffers reaped (for debug) ++ * Returns 1 if we freed the transaction, 0 otherwise. + */ +- +-static int journal_clean_one_cp_list(struct journal_head *jh, int *released) ++static int journal_clean_one_cp_list(struct journal_head *jh) + { + struct journal_head *last_jh; + struct journal_head *next_jh = jh; +- int ret, freed = 0; ++ int ret; ++ int freed = 0; + +- *released = 0; + if (!jh) + return 0; + +@@ -441,11 +440,9 @@ static int journal_clean_one_cp_list(struct journal_head *jh, int *released) + ret = __try_to_free_cp_buf(jh); + if (!ret) + return freed; +- freed++; +- if (ret == 2) { +- *released = 1; +- return freed; +- } ++ if (ret == 2) ++ return 1; ++ freed = 1; + /* + * This function only frees up some memory + * if possible so we dont have an obligation +@@ -465,53 +462,48 @@ static int journal_clean_one_cp_list(struct journal_head *jh, int *released) + * Find all the written-back checkpoint buffers in the journal and release them. + * + * Called with j_list_lock held. +- * Returns number of buffers reaped (for debug) + */ +- +-int __jbd2_journal_clean_checkpoint_list(journal_t *journal) ++void __jbd2_journal_clean_checkpoint_list(journal_t *journal) + { + transaction_t *transaction, *last_transaction, *next_transaction; + int ret; +- int freed = 0; +- int released; + + transaction = journal->j_checkpoint_transactions; + if (!transaction) +- goto out; ++ return; + + last_transaction = transaction->t_cpprev; + next_transaction = transaction; + do { + transaction = next_transaction; + next_transaction = transaction->t_cpnext; +- ret = journal_clean_one_cp_list(transaction-> +- t_checkpoint_list, &released); ++ ret = journal_clean_one_cp_list(transaction->t_checkpoint_list); + /* + * This function only frees up some memory if possible so we + * dont have an obligation to finish processing. Bail out if + * preemption requested: + */ +- if (need_resched()) { +- freed += ret; +- goto out; +- } +- if (released) { +- freed += ret; ++ if (need_resched()) ++ return; ++ if (ret) + continue; +- } + /* + * It is essential that we are as careful as in the case of + * t_checkpoint_list with removing the buffer from the list as + * we can possibly see not yet submitted buffers on io_list + */ +- ret += journal_clean_one_cp_list(transaction-> +- t_checkpoint_io_list, &released); +- freed += ret; +- if (need_resched() || !ret) +- goto out; ++ ret = journal_clean_one_cp_list(transaction-> ++ t_checkpoint_io_list); ++ if (need_resched()) ++ return; ++ /* ++ * Stop scanning if we couldn't free the transaction. This ++ * avoids pointless scanning of transactions which still ++ * weren't checkpointed. ++ */ ++ if (!ret) ++ return; + } while (transaction != last_transaction); +-out: +- return freed; + } + + /* +diff --git a/include/linux/jbd2.h b/include/linux/jbd2.h +index 0dae71e..704b9a5 100644 +--- a/include/linux/jbd2.h ++++ b/include/linux/jbd2.h +@@ -1042,7 +1042,7 @@ void jbd2_update_log_tail(journal_t *journal, tid_t tid, unsigned long block); + extern void jbd2_journal_commit_transaction(journal_t *); + + /* Checkpoint list management */ +-int __jbd2_journal_clean_checkpoint_list(journal_t *journal); ++void __jbd2_journal_clean_checkpoint_list(journal_t *journal); + int __jbd2_journal_remove_checkpoint(struct journal_head *); + void __jbd2_journal_insert_checkpoint(struct journal_head *, transaction_t *); + diff --git a/timestamps b/timestamps index 81758aaa..f87d596a 100755 --- a/timestamps +++ b/timestamps @@ -86,6 +86,7 @@ touch -d @1410893804 use-a-list-to-track-all-reclaimable-objects-for-extent-stat touch -d @1410893864 use-a-garbage-collection-algorithm-to-manage-object touch -d @1410893872 add-fallocate-mode-blocking-for-debugging touch -d @1411015336 avoid-pointless-scanning-of-checkpoint-lists -touch -d @1411015504 series -touch -d @1411015508 status -touch -d @1411015932 timestamps +touch -d @1411016249 series +touch -d @1411016292 simplify-calling-convention-around-jbd2_journal_clean_checkpoint_list +touch -d @1411016292 status +touch -d @1411016465 timestamps -- 2.11.4.GIT