1 files changed, 20 insertions, 1 deletions

diff --git a/block/blk.h b/block/blk.h
index 61263463e38e..1f798b5a6f19 100644
--- a/block/blk.h
+++ b/block/blk.h
@@ -61,7 +61,26 @@ static inline struct request *__elv_next_request(struct request_queue *q)
                         rq = list_entry_rq(q->queue_head.next);
                         return rq;
                 }
-
+                /*
+                 * Flush request is running and flush request isn't queueable
+                 * in the drive, we can hold the queue till flush request is
+                 * finished. Even we don't do this, driver can't dispatch next
+                 * requests and will requeue them. And this can improve
+                 * throughput too. For example, we have request flush1, write1,
+                 * flush 2. flush1 is dispatched, then queue is hold, write1
+                 * isn't inserted to queue. After flush1 is finished, flush2
+                 * will be dispatched. Since disk cache is already clean,
+                 * flush2 will be finished very soon, so looks like flush2 is
+                 * folded to flush1.
+                 * Since the queue is hold, a flag is set to indicate the queue
+                 * should be restarted later. Please see flush_end_io() for
+                 * details.
+                 */
+                if (q->flush_pending_idx != q->flush_running_idx &&
+                                !queue_flush_queueable(q)) {
+                        q->flush_queue_delayed = 1;
+                        return NULL;
+                }
                 if (!q->elevator->ops->elevator_dispatch_fn(q, 0))
                         return NULL;
         }