block,fs: use REQ_* flags directly

Remove the WRITE_* and READ_SYNC wrappers, and just use the flags
directly.  Where applicable this also drops usage of the
bio_set_op_attrs wrapper.

Signed-off-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Jens Axboe <axboe@fb.com>

1 files changed, 8 insertions, 7 deletions

diff --git a/fs/jbd2/journal.c b/fs/jbd2/journal.c
index 927da4956a89..8ed971eeab44 100644
--- a/fs/jbd2/journal.c
+++ b/fs/jbd2/journal.c
@@ -913,7 +913,7 @@ int __jbd2_update_log_tail(journal_t *journal, tid_t tid, unsigned long block)
          * space and if we lose sb update during power failure we'd replay
          * old transaction with possibly newly overwritten data.
          */
-        ret = jbd2_journal_update_sb_log_tail(journal, tid, block, WRITE_FUA);
+        ret = jbd2_journal_update_sb_log_tail(journal, tid, block, REQ_FUA);
         if (ret)
                 goto out;
 
@@ -1306,7 +1306,7 @@ static int journal_reset(journal_t *journal)
                 /* Lock here to make assertions happy... */
                 mutex_lock(&journal->j_checkpoint_mutex);
                 /*
-                 * Update log tail information. We use WRITE_FUA since new
+                 * Update log tail information. We use REQ_FUA since new
                  * transaction will start reusing journal space and so we
                  * must make sure information about current log tail is on
                  * disk before that.
@@ -1314,7 +1314,7 @@ static int journal_reset(journal_t *journal)
                 jbd2_journal_update_sb_log_tail(journal,
                                                 journal->j_tail_sequence,
                                                 journal->j_tail,
-                                                WRITE_FUA);
+                                                REQ_FUA);
                 mutex_unlock(&journal->j_checkpoint_mutex);
         }
         return jbd2_journal_start_thread(journal);
@@ -1454,7 +1454,7 @@ void jbd2_journal_update_sb_errno(journal_t *journal)
         sb->s_errno    = cpu_to_be32(journal->j_errno);
         read_unlock(&journal->j_state_lock);
 
-        jbd2_write_superblock(journal, WRITE_FUA);
+        jbd2_write_superblock(journal, REQ_FUA);
 }
 EXPORT_SYMBOL(jbd2_journal_update_sb_errno);
 
@@ -1720,7 +1720,8 @@ int jbd2_journal_destroy(journal_t *journal)
                                 ++journal->j_transaction_sequence;
                         write_unlock(&journal->j_state_lock);
 
-                        jbd2_mark_journal_empty(journal, WRITE_FLUSH_FUA);
+                        jbd2_mark_journal_empty(journal,
+                                        REQ_PREFLUSH | REQ_FUA);
                         mutex_unlock(&journal->j_checkpoint_mutex);
                 } else
                         err = -EIO;
@@ -1979,7 +1980,7 @@ int jbd2_journal_flush(journal_t *journal)
          * the magic code for a fully-recovered superblock.  Any future
          * commits of data to the journal will restore the current
          * s_start value. */
-        jbd2_mark_journal_empty(journal, WRITE_FUA);
+        jbd2_mark_journal_empty(journal, REQ_FUA);
         mutex_unlock(&journal->j_checkpoint_mutex);
         write_lock(&journal->j_state_lock);
         J_ASSERT(!journal->j_running_transaction);
@@ -2025,7 +2026,7 @@ int jbd2_journal_wipe(journal_t *journal, int write)
         if (write) {
                 /* Lock to make assertions happy... */
                 mutex_lock(&journal->j_checkpoint_mutex);
-                jbd2_mark_journal_empty(journal, WRITE_FUA);
+                jbd2_mark_journal_empty(journal, REQ_FUA);
                 mutex_unlock(&journal->j_checkpoint_mutex);
         }