jbd: clear revoked flag on buffers before a new transaction started
Yongqiang Yang [Sat, 19 Nov 2011 09:34:29 +0000 (17:34 +0800)]
Currently, we clear revoked flag only when a block is reused.  However,
this can tigger a false journal error.  Consider a situation when a block
is used as a meta block and is deleted(revoked) in ordered mode, then the
block is allocated as a data block to a file.  At this moment, user changes
the file's journal mode from ordered to journaled and truncates the file.
The block will be considered re-revoked by journal because it has revoked
flag still pending from the last transaction and an assertion triggers.

We fix the problem by keeping the revoked status more uptodate - we clear
revoked flag when switching revoke tables to reflect there is no revoked
buffers in current transaction any more.

Signed-off-by: Yongqiang Yang <xiaoqiangnk@gmail.com>
Signed-off-by: Jan Kara <jack@suse.cz>

fs/jbd/commit.c
fs/jbd/revoke.c
include/linux/jbd.h

index 8799207..f2b9a57 100644 (file)
@@ -392,6 +392,12 @@ void journal_commit_transaction(journal_t *journal)
        jbd_debug (3, "JBD: commit phase 1\n");
 
        /*
+        * Clear revoked flag to reflect there is no revoked buffers
+        * in the next transaction which is going to be started.
+        */
+       journal_clear_buffer_revoked_flags(journal);
+
+       /*
         * Switch to a new revoke table.
         */
        journal_switch_revoke_table(journal);
index 305a907..25c713e 100644 (file)
  *   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
@@ -479,6 +483,36 @@ int journal_cancel_revoke(handle_t *handle, struct journal_head *jh)
        return did_revoke;
 }
 
+/*
+ * journal_clear_revoked_flags clears revoked flag of buffers in
+ * revoke table to reflect there is no revoked buffer in the next
+ * transaction which is going to be started.
+ */
+void journal_clear_buffer_revoked_flags(journal_t *journal)
+{
+       struct jbd_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 jbd_revoke_record_s *record;
+                       struct buffer_head *bh;
+                       record = (struct jbd_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
index c7acdde..492cc12 100644 (file)
@@ -913,6 +913,7 @@ extern int  journal_set_revoke(journal_t *, unsigned int, tid_t);
 extern int     journal_test_revoke(journal_t *, unsigned int, tid_t);
 extern void    journal_clear_revoke(journal_t *);
 extern void    journal_switch_revoke_table(journal_t *journal);
+extern void    journal_clear_buffer_revoked_flags(journal_t *journal);
 
 /*
  * The log thread user interface: