Merge branch 'for-2.6.37/barrier' of git://git.kernel.dk/linux-2.6-block

* 'for-2.6.37/barrier' of git://git.kernel.dk/linux-2.6-block: (46 commits)
  xen-blkfront: disable barrier/flush write support
  Added blk-lib.c and blk-barrier.c was renamed to blk-flush.c
  block: remove BLKDEV_IFL_WAIT
  aic7xxx_old: removed unused 'req' variable
  block: remove the BH_Eopnotsupp flag
  block: remove the BLKDEV_IFL_BARRIER flag
  block: remove the WRITE_BARRIER flag
  swap: do not send discards as barriers
  fat: do not send discards as barriers
  ext4: do not send discards as barriers
  jbd2: replace barriers with explicit flush / FUA usage
  jbd2: Modify ASYNC_COMMIT code to not rely on queue draining on barrier
  jbd: replace barriers with explicit flush / FUA usage
  nilfs2: replace barriers with explicit flush / FUA usage
  reiserfs: replace barriers with explicit flush / FUA usage
  gfs2: replace barriers with explicit flush / FUA usage
  btrfs: replace barriers with explicit flush / FUA usage
  xfs: replace barriers with explicit flush / FUA usage
  block: pass gfp_mask and flags to sb_issue_discard
  dm: convey that all flushes are processed as empty
  ...

1 files changed, 39 insertions, 33 deletions

diff --git a/block/blk-core.c b/block/blk-core.c
index 500eb859886e..45141469e89e 100644
--- a/block/blk-core.c
+++ b/block/blk-core.c
@@ -139,7 +139,7 @@ static void req_bio_endio(struct request *rq, struct bio *bio,
 {
         struct request_queue *q = rq->q;
 
-        if (&q->bar_rq != rq) {
+        if (&q->flush_rq != rq) {
                 if (error)
                         clear_bit(BIO_UPTODATE, &bio->bi_flags);
                 else if (!test_bit(BIO_UPTODATE, &bio->bi_flags))
@@ -163,13 +163,12 @@ static void req_bio_endio(struct request *rq, struct bio *bio,
                 if (bio->bi_size == 0)
                         bio_endio(bio, error);
         } else {
-
                 /*
-                 * Okay, this is the barrier request in progress, just
-                 * record the error;
+                 * Okay, this is the sequenced flush request in
+                 * progress, just record the error;
                  */
-                if (error && !q->orderr)
-                        q->orderr = error;
+                if (error && !q->flush_err)
+                        q->flush_err = error;
         }
 }
 
@@ -531,6 +530,7 @@ struct request_queue *blk_alloc_queue_node(gfp_t gfp_mask, int node_id)
         init_timer(&q->unplug_timer);
         setup_timer(&q->timeout, blk_rq_timed_out_timer, (unsigned long) q);
         INIT_LIST_HEAD(&q->timeout_list);
+        INIT_LIST_HEAD(&q->pending_flushes);
         INIT_WORK(&q->unplug_work, blk_unplug_work);
 
         kobject_init(&q->kobj, &blk_queue_ktype);
@@ -1053,22 +1053,6 @@ void blk_insert_request(struct request_queue *q, struct request *rq,
 }
 EXPORT_SYMBOL(blk_insert_request);
 
-/*
- * add-request adds a request to the linked list.
- * queue lock is held and interrupts disabled, as we muck with the
- * request queue list.
- */
-static inline void add_request(struct request_queue *q, struct request *req)
-{
-        drive_stat_acct(req, 1);
-
-        /*
-         * elevator indicated where it wants this request to be
-         * inserted at elevator_merge time
-         */
-        __elv_add_request(q, req, ELEVATOR_INSERT_SORT, 0);
-}
-
 static void part_round_stats_single(int cpu, struct hd_struct *part,
                                     unsigned long now)
 {
@@ -1217,13 +1201,16 @@ static int __make_request(struct request_queue *q, struct bio *bio)
         const bool sync = !!(bio->bi_rw & REQ_SYNC);
         const bool unplug = !!(bio->bi_rw & REQ_UNPLUG);
         const unsigned long ff = bio->bi_rw & REQ_FAILFAST_MASK;
+        int where = ELEVATOR_INSERT_SORT;
         int rw_flags;
 
-        if ((bio->bi_rw & REQ_HARDBARRIER) &&
-            (q->next_ordered == QUEUE_ORDERED_NONE)) {
+        /* REQ_HARDBARRIER is no more */
+        if (WARN_ONCE(bio->bi_rw & REQ_HARDBARRIER,
+                "block: HARDBARRIER is deprecated, use FLUSH/FUA instead\n")) {
                 bio_endio(bio, -EOPNOTSUPP);
                 return 0;
         }
+
         /*
          * low level driver can indicate that it wants pages above a
          * certain limit bounced to low memory (ie for highmem, or even
@@ -1233,7 +1220,12 @@ static int __make_request(struct request_queue *q, struct bio *bio)
 
         spin_lock_irq(q->queue_lock);
 
-        if (unlikely((bio->bi_rw & REQ_HARDBARRIER)) || elv_queue_empty(q))
+        if (bio->bi_rw & (REQ_FLUSH | REQ_FUA)) {
+                where = ELEVATOR_INSERT_FRONT;
+                goto get_rq;
+        }
+
+        if (elv_queue_empty(q))
                 goto get_rq;
 
         el_ret = elv_merge(q, &req, bio);
@@ -1330,7 +1322,10 @@ get_rq:
                 req->cpu = blk_cpu_to_group(smp_processor_id());
         if (queue_should_plug(q) && elv_queue_empty(q))
                 blk_plug_device(q);
-        add_request(q, req);
+
+        /* insert the request into the elevator */
+        drive_stat_acct(req, 1);
+        __elv_add_request(q, req, where, 0);
 out:
         if (unplug || !queue_should_plug(q))
                 __generic_unplug_device(q);
@@ -1530,6 +1525,19 @@ static inline void __generic_make_request(struct bio *bio)
                 if (bio_check_eod(bio, nr_sectors))
                         goto end_io;
 
+                /*
+                 * Filter flush bio's early so that make_request based
+                 * drivers without flush support don't have to worry
+                 * about them.
+                 */
+                if ((bio->bi_rw & (REQ_FLUSH | REQ_FUA)) && !q->flush_flags) {
+                        bio->bi_rw &= ~(REQ_FLUSH | REQ_FUA);
+                        if (!nr_sectors) {
+                                err = 0;
+                                goto end_io;
+                        }
+                }
+
                 if ((bio->bi_rw & REQ_DISCARD) &&
                     (!blk_queue_discard(q) ||
                      ((bio->bi_rw & REQ_SECURE) &&
@@ -1794,11 +1802,11 @@ static void blk_account_io_completion(struct request *req, unsigned int bytes)
 static void blk_account_io_done(struct request *req)
 {
         /*
-         * Account IO completion.  bar_rq isn't accounted as a normal
-         * IO on queueing nor completion.  Accounting the containing
-         * request is enough.
+         * Account IO completion.  flush_rq isn't accounted as a
+         * normal IO on queueing nor completion.  Accounting the
+         * containing request is enough.
          */
-        if (blk_do_io_stat(req) && req != &req->q->bar_rq) {
+        if (blk_do_io_stat(req) && req != &req->q->flush_rq) {
                 unsigned long duration = jiffies - req->start_time;
                 const int rw = rq_data_dir(req);
                 struct hd_struct *part;
@@ -2523,9 +2531,7 @@ EXPORT_SYMBOL_GPL(blk_rq_unprep_clone);
 static void __blk_rq_prep_clone(struct request *dst, struct request *src)
 {
         dst->cpu = src->cpu;
-        dst->cmd_flags = (rq_data_dir(src) | REQ_NOMERGE);
-        if (src->cmd_flags & REQ_DISCARD)
-                dst->cmd_flags |= REQ_DISCARD;
+        dst->cmd_flags = (src->cmd_flags & REQ_CLONE_MASK) | REQ_NOMERGE;
         dst->cmd_type = src->cmd_type;
         dst->__sector = blk_rq_pos(src);
         dst->__data_len = blk_rq_bytes(src);