3 files changed, 46 insertions, 0 deletions

diff --git a/fs/jbd2/commit.c b/fs/jbd2/commit.c
index b89ef84786a7..1dfcb207ea69 100644
--- a/fs/jbd2/commit.c
+++ b/fs/jbd2/commit.c
@@ -331,6 +331,10 @@ void jbd2_journal_commit_transaction(journal_t *journal)
         struct buffer_head *cbh = NULL; /* For transactional checksums */
         __u32 crc32_sum = ~0;
         struct blk_plug plug;
+        /* Tail of the journal */
+        unsigned long first_block;
+        tid_t first_tid;
+        int update_tail;
 
         /*
          * First job: lock down the current transaction and wait for
@@ -688,10 +692,30 @@ start_journal_io:
                 err = 0;
         }
 
+        /*
+         * Get current oldest transaction in the log before we issue flush
+         * to the filesystem device. After the flush we can be sure that
+         * blocks of all older transactions are checkpointed to persistent
+         * storage and we will be safe to update journal start in the
+         * superblock with the numbers we get here.
+         */
+        update_tail =
+                jbd2_journal_get_log_tail(journal, &first_tid, &first_block);
+
         write_lock(&journal->j_state_lock);
+        if (update_tail) {
+                long freed = first_block - journal->j_tail;
+
+                if (first_block < journal->j_tail)
+                        freed += journal->j_last - journal->j_first;
+                /* Update tail only if we free significant amount of space */
+                if (freed < journal->j_maxlen / 4)
+                        update_tail = 0;
+        }
         J_ASSERT(commit_transaction->t_state == T_COMMIT);
         commit_transaction->t_state = T_COMMIT_DFLUSH;
         write_unlock(&journal->j_state_lock);
+
         /* 
          * If the journal is not located on the file system device,
          * then we must flush the file system device before we issue
@@ -842,6 +866,14 @@ wait_for_iobuf:
         if (err)
                 jbd2_journal_abort(journal, err);
 
+        /*
+         * Now disk caches for filesystem device are flushed so we are safe to
+         * erase checkpointed transactions from the log by updating journal
+         * superblock.
+         */
+        if (update_tail)
+                jbd2_update_log_tail(journal, first_tid, first_block);
+
         /* End of a transaction!  Finally, we can do checkpoint
            processing: any buffers committed as a result of this
            transaction can be removed from any checkpoint list it was on
diff --git a/fs/jbd2/journal.c b/fs/jbd2/journal.c
index c5ff177400ff..bda564f63864 100644
--- a/fs/jbd2/journal.c
+++ b/fs/jbd2/journal.c
@@ -821,6 +821,19 @@ void __jbd2_update_log_tail(journal_t *journal, tid_t tid, unsigned long block)
         write_unlock(&journal->j_state_lock);
 }
 
+/*
+ * This is a variaon of __jbd2_update_log_tail which checks for validity of
+ * provided log tail and locks j_checkpoint_mutex. So it is safe against races
+ * with other threads updating log tail.
+ */
+void jbd2_update_log_tail(journal_t *journal, tid_t tid, unsigned long block)
+{
+        mutex_lock(&journal->j_checkpoint_mutex);
+        if (tid_gt(tid, journal->j_tail_sequence))
+                __jbd2_update_log_tail(journal, tid, block);
+        mutex_unlock(&journal->j_checkpoint_mutex);
+}
+
 struct jbd2_stats_proc_session {
         journal_t *journal;
         struct transaction_stats_s *stats;
diff --git a/include/linux/jbd2.h b/include/linux/jbd2.h
index 876a7d87192b..912c30a8ddb1 100644
--- a/include/linux/jbd2.h
+++ b/include/linux/jbd2.h
@@ -974,6 +974,7 @@ int jbd2_journal_next_log_block(journal_t *, unsigned long long *);
 int jbd2_journal_get_log_tail(journal_t *journal, tid_t *tid,
                               unsigned long *block);
 void __jbd2_update_log_tail(journal_t *journal, tid_t tid, unsigned long block);
+void jbd2_update_log_tail(journal_t *journal, tid_t tid, unsigned long block);
 
 /* Commit management */
 extern void jbd2_journal_commit_transaction(journal_t *);