Merge tag 'v2.6.37' of git://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux-2.6

[mv-sheeva.git] / fs / reiserfs / journal.c

diff --git a/fs/reiserfs/journal.c b/fs/reiserfs/journal.c
index 812e2c05aa29eeda01bf94323234cdf260344353..d31bce1a9f908e1df4c8046f371bec748c215440 100644 (file)
--- a/fs/reiserfs/journal.c
+++ b/fs/reiserfs/journal.c
@@ -43,7 +43,6 @@
 #include <linux/fcntl.h>
 #include <linux/stat.h>
 #include <linux/string.h>
-#include <linux/smp_lock.h>
 #include <linux/buffer_head.h>
 #include <linux/workqueue.h>
 #include <linux/writeback.h>
@@ -138,13 +137,6 @@ static int reiserfs_clean_and_file_buffer(struct buffer_head *bh)
        return 0;
 }
 
-static void disable_barrier(struct super_block *s)
-{
-       REISERFS_SB(s)->s_mount_opt &= ~(1 << REISERFS_BARRIER_FLUSH);
-       printk("reiserfs: disabling flush barriers on %s\n",
-              reiserfs_bdevname(s));
-}
-
 static struct reiserfs_bitmap_node *allocate_bitmap_node(struct super_block
                                                         *sb)
 {
@@ -677,30 +669,6 @@ static void submit_ordered_buffer(struct buffer_head *bh)
        submit_bh(WRITE, bh);
 }
 
-static int submit_barrier_buffer(struct buffer_head *bh)
-{
-       get_bh(bh);
-       bh->b_end_io = reiserfs_end_ordered_io;
-       clear_buffer_dirty(bh);
-       if (!buffer_uptodate(bh))
-               BUG();
-       return submit_bh(WRITE_BARRIER, bh);
-}
-
-static void check_barrier_completion(struct super_block *s,
-                                    struct buffer_head *bh)
-{
-       if (buffer_eopnotsupp(bh)) {
-               clear_buffer_eopnotsupp(bh);
-               disable_barrier(s);
-               set_buffer_uptodate(bh);
-               set_buffer_dirty(bh);
-               reiserfs_write_unlock(s);
-               sync_dirty_buffer(bh);
-               reiserfs_write_lock(s);
-       }
-}
-
 #define CHUNK_SIZE 32
 struct buffer_chunk {
        struct buffer_head *bh[CHUNK_SIZE];
@@ -1009,7 +977,6 @@ static int flush_commit_list(struct super_block *s,
        struct buffer_head *tbh = NULL;
        unsigned int trans_id = jl->j_trans_id;
        struct reiserfs_journal *journal = SB_JOURNAL(s);
-       int barrier = 0;
        int retval = 0;
        int write_len;
 
@@ -1094,24 +1061,6 @@ static int flush_commit_list(struct super_block *s,
        }
        atomic_dec(&journal->j_async_throttle);
 
-       /* We're skipping the commit if there's an error */
-       if (retval || reiserfs_is_journal_aborted(journal))
-               barrier = 0;
-
-       /* wait on everything written so far before writing the commit
-        * if we are in barrier mode, send the commit down now
-        */
-       barrier = reiserfs_barrier_flush(s);
-       if (barrier) {
-               int ret;
-               lock_buffer(jl->j_commit_bh);
-               ret = submit_barrier_buffer(jl->j_commit_bh);
-               if (ret == -EOPNOTSUPP) {
-                       set_buffer_uptodate(jl->j_commit_bh);
-                       disable_barrier(s);
-                       barrier = 0;
-               }
-       }
        for (i = 0; i < (jl->j_len + 1); i++) {
                bn = SB_ONDISK_JOURNAL_1st_BLOCK(s) +
                    (jl->j_start + i) % SB_ONDISK_JOURNAL_SIZE(s);
@@ -1143,27 +1092,22 @@ static int flush_commit_list(struct super_block *s,
 
        BUG_ON(atomic_read(&(jl->j_commit_left)) != 1);
 
-       if (!barrier) {
-               /* If there was a write error in the journal - we can't commit
-                * this transaction - it will be invalid and, if successful,
-                * will just end up propagating the write error out to
-                * the file system. */
-               if (likely(!retval && !reiserfs_is_journal_aborted (journal))) {
-                       if (buffer_dirty(jl->j_commit_bh))
-                               BUG();
-                       mark_buffer_dirty(jl->j_commit_bh) ;
-                       reiserfs_write_unlock(s);
-                       sync_dirty_buffer(jl->j_commit_bh) ;
-                       reiserfs_write_lock(s);
-               }
-       } else {
+       /* If there was a write error in the journal - we can't commit
+        * this transaction - it will be invalid and, if successful,
+        * will just end up propagating the write error out to
+        * the file system. */
+       if (likely(!retval && !reiserfs_is_journal_aborted (journal))) {
+               if (buffer_dirty(jl->j_commit_bh))
+                       BUG();
+               mark_buffer_dirty(jl->j_commit_bh) ;
                reiserfs_write_unlock(s);
-               wait_on_buffer(jl->j_commit_bh);
+               if (reiserfs_barrier_flush(s))
+                       __sync_dirty_buffer(jl->j_commit_bh, WRITE_FLUSH_FUA);
+               else
+                       sync_dirty_buffer(jl->j_commit_bh);
                reiserfs_write_lock(s);
        }
 
-       check_barrier_completion(s, jl->j_commit_bh);
-
        /* If there was a write error in the journal - we can't commit this
         * transaction - it will be invalid and, if successful, will just end
         * up propagating the write error out to the filesystem. */
@@ -1319,26 +1263,15 @@ static int _update_journal_header_block(struct super_block *sb,
                jh->j_first_unflushed_offset = cpu_to_le32(offset);
                jh->j_mount_id = cpu_to_le32(journal->j_mount_id);
 
-               if (reiserfs_barrier_flush(sb)) {
-                       int ret;
-                       lock_buffer(journal->j_header_bh);
-                       ret = submit_barrier_buffer(journal->j_header_bh);
-                       if (ret == -EOPNOTSUPP) {
-                               set_buffer_uptodate(journal->j_header_bh);
-                               disable_barrier(sb);
-                               goto sync;
-                       }
-                       reiserfs_write_unlock(sb);
-                       wait_on_buffer(journal->j_header_bh);
-                       reiserfs_write_lock(sb);
-                       check_barrier_completion(sb, journal->j_header_bh);
-               } else {
-                     sync:
-                       set_buffer_dirty(journal->j_header_bh);
-                       reiserfs_write_unlock(sb);
+               set_buffer_dirty(journal->j_header_bh);
+               reiserfs_write_unlock(sb);
+
+               if (reiserfs_barrier_flush(sb))
+                       __sync_dirty_buffer(journal->j_header_bh, WRITE_FLUSH_FUA);
+               else
                        sync_dirty_buffer(journal->j_header_bh);
-                       reiserfs_write_lock(sb);
-               }
+
+               reiserfs_write_lock(sb);
                if (!buffer_uptodate(journal->j_header_bh)) {
                        reiserfs_warning(sb, "journal-837",
                                         "IO error during journal replay");