jbd2: remove bh_state lock from checkpointing code

[GitHub/mt8127/android_kernel_alcatel_ttab.git] / fs / jbd2 / revoke.c

diff --git a/fs/jbd2/revoke.c b/fs/jbd2/revoke.c
index 69fd93588118027961923d26685b8edecfe3c268..6973705d6a3d9db1c96ed67f55c97c8a13ee2f6d 100644 (file)
--- a/fs/jbd2/revoke.c
+++ b/fs/jbd2/revoke.c
@@ -47,6 +47,10 @@
  *   overwriting the new data.  We don't even need to clear the revoke
  *   bit here.
  *
+ * We cache revoke status of a buffer in the current transaction in b_states
+ * bits.  As the name says, revokevalid flag indicates that the cached revoke
+ * status of a buffer is valid and we can rely on the cached status.
+ *
  * Revoke information on buffers is a tri-state value:
  *
  * RevokeValid clear:  no cached revoke status, need to look it up
@@ -204,17 +208,13 @@ int __init jbd2_journal_init_revoke_caches(void)
        J_ASSERT(!jbd2_revoke_record_cache);
        J_ASSERT(!jbd2_revoke_table_cache);
 
-       jbd2_revoke_record_cache = kmem_cache_create("jbd2_revoke_record",
-                                          sizeof(struct jbd2_revoke_record_s),
-                                          0,
-                                          SLAB_HWCACHE_ALIGN|SLAB_TEMPORARY,
-                                          NULL);
+       jbd2_revoke_record_cache = KMEM_CACHE(jbd2_revoke_record_s,
+                                       SLAB_HWCACHE_ALIGN|SLAB_TEMPORARY);
        if (!jbd2_revoke_record_cache)
                goto record_cache_failure;
 
-       jbd2_revoke_table_cache = kmem_cache_create("jbd2_revoke_table",
-                                          sizeof(struct jbd2_revoke_table_s),
-                                          0, SLAB_TEMPORARY, NULL);
+       jbd2_revoke_table_cache = KMEM_CACHE(jbd2_revoke_table_s,
+                                            SLAB_TEMPORARY);
        if (!jbd2_revoke_table_cache)
                goto table_cache_failure;
        return 0;
@@ -478,6 +478,36 @@ int jbd2_journal_cancel_revoke(handle_t *handle, struct journal_head *jh)
        return did_revoke;
 }
 
+/*
+ * journal_clear_revoked_flag clears revoked flag of buffers in
+ * revoke table to reflect there is no revoked buffers in the next
+ * transaction which is going to be started.
+ */
+void jbd2_clear_buffer_revoked_flags(journal_t *journal)
+{
+       struct jbd2_revoke_table_s *revoke = journal->j_revoke;
+       int i = 0;
+
+       for (i = 0; i < revoke->hash_size; i++) {
+               struct list_head *hash_list;
+               struct list_head *list_entry;
+               hash_list = &revoke->hash_table[i];
+
+               list_for_each(list_entry, hash_list) {
+                       struct jbd2_revoke_record_s *record;
+                       struct buffer_head *bh;
+                       record = (struct jbd2_revoke_record_s *)list_entry;
+                       bh = __find_get_block(journal->j_fs_dev,
+                                             record->blocknr,
+                                             journal->j_blocksize);
+                       if (bh) {
+                               clear_buffer_revoked(bh);
+                               __brelse(bh);
+                       }
+               }
+       }
+}
+
 /* journal_switch_revoke table select j_revoke for next transaction
  * we do not want to suspend any processing until all revokes are
  * written -bzzz