block/blk-barrier.c - kernel/prism - Git at Google

 /*
  * Functions related to barrier IO handling
  */
 #include <linux/kernel.h>
 #include <linux/module.h>
 #include <linux/bio.h>
 #include <linux/blkdev.h>

 #include "blk.h"

 /**
  * blk_queue_ordered - does this queue support ordered writes
  * @q:        the request queue
  * @ordered:  one of QUEUE_ORDERED_*
  * @prepare_flush_fn: rq setup helper for cache flush ordered writes
  *
  * Description:
  *   For journalled file systems, doing ordered writes on a commit
  *   block instead of explicitly doing wait_on_buffer (which is bad
  *   for performance) can be a big win. Block drivers supporting this
  *   feature should call this function and indicate so.
  *
  **/
 int blk_queue_ordered(struct request_queue *q, unsigned ordered,
 		      prepare_flush_fn *prepare_flush_fn)
 {
 	if (!prepare_flush_fn && (ordered & (QUEUE_ORDERED_DO_PREFLUSH |
 					     QUEUE_ORDERED_DO_POSTFLUSH))) {
 		printk(KERN_ERR "%s: prepare_flush_fn required\n", __func__);
 		return -EINVAL;
 	}

 	if (ordered != QUEUE_ORDERED_NONE &&
 	    ordered != QUEUE_ORDERED_DRAIN &&
 	    ordered != QUEUE_ORDERED_DRAIN_FLUSH &&
 	    ordered != QUEUE_ORDERED_DRAIN_FUA &&
 	    ordered != QUEUE_ORDERED_TAG &&
 	    ordered != QUEUE_ORDERED_TAG_FLUSH &&
 	    ordered != QUEUE_ORDERED_TAG_FUA) {
 		printk(KERN_ERR "blk_queue_ordered: bad value %d\n", ordered);
 		return -EINVAL;
 	}

 	q->ordered = ordered;
 	q->next_ordered = ordered;
 	q->prepare_flush_fn = prepare_flush_fn;

 	return 0;
 }
 EXPORT_SYMBOL(blk_queue_ordered);

 /*
  * Cache flushing for ordered writes handling
  */
 unsigned blk_ordered_cur_seq(struct request_queue *q)
 {
 	if (!q->ordseq)
 		return 0;
 	return 1 << ffz(q->ordseq);
 }

 unsigned blk_ordered_req_seq(struct request *rq)
 {
 	struct request_queue *q = rq->q;

 	BUG_ON(q->ordseq == 0);

 	if (rq == &q->pre_flush_rq)
 		return QUEUE_ORDSEQ_PREFLUSH;
 	if (rq == &q->bar_rq)
 		return QUEUE_ORDSEQ_BAR;
 	if (rq == &q->post_flush_rq)
 		return QUEUE_ORDSEQ_POSTFLUSH;

 	/*
 	 * !fs requests don't need to follow barrier ordering.  Always
 	 * put them at the front.  This fixes the following deadlock.
 	 *
 	 * http://thread.gmane.org/gmane.linux.kernel/537473
 	 */
 	if (!blk_fs_request(rq))
 		return QUEUE_ORDSEQ_DRAIN;

 	if ((rq->cmd_flags & REQ_ORDERED_COLOR) ==
 	    (q->orig_bar_rq->cmd_flags & REQ_ORDERED_COLOR))
 		return QUEUE_ORDSEQ_DRAIN;
 	else
 		return QUEUE_ORDSEQ_DONE;
 }

 bool blk_ordered_complete_seq(struct request_queue *q, unsigned seq, int error)
 {
 	struct request *rq;

 	if (error && !q->orderr)
 		q->orderr = error;

 	BUG_ON(q->ordseq & seq);
 	q->ordseq |= seq;

 	if (blk_ordered_cur_seq(q) != QUEUE_ORDSEQ_DONE)
 		return false;

 	/*
 	 * Okay, sequence complete.
 	 */
 	q->ordseq = 0;
 	rq = q->orig_bar_rq;
 	__blk_end_request_all(rq, q->orderr);
 	return true;
 }

 static void pre_flush_end_io(struct request *rq, int error)
 {
 	elv_completed_request(rq->q, rq);
 	blk_ordered_complete_seq(rq->q, QUEUE_ORDSEQ_PREFLUSH, error);
 }

 static void bar_end_io(struct request *rq, int error)
 {
 	elv_completed_request(rq->q, rq);
 	blk_ordered_complete_seq(rq->q, QUEUE_ORDSEQ_BAR, error);
 }

 static void post_flush_end_io(struct request *rq, int error)
 {
 	elv_completed_request(rq->q, rq);
 	blk_ordered_complete_seq(rq->q, QUEUE_ORDSEQ_POSTFLUSH, error);
 }

 static void queue_flush(struct request_queue *q, unsigned which)
 {
 	struct request *rq;
 	rq_end_io_fn *end_io;

 	if (which == QUEUE_ORDERED_DO_PREFLUSH) {
 		rq = &q->pre_flush_rq;
 		end_io = pre_flush_end_io;
 	} else {
 		rq = &q->post_flush_rq;
 		end_io = post_flush_end_io;
 	}

 	blk_rq_init(q, rq);
 	rq->cmd_flags = REQ_HARDBARRIER;
 	rq->rq_disk = q->bar_rq.rq_disk;
 	rq->end_io = end_io;
 	q->prepare_flush_fn(q, rq);

 	elv_insert(q, rq, ELEVATOR_INSERT_FRONT);
 }

 static inline bool start_ordered(struct request_queue *q, struct request **rqp)
 {
 	struct request *rq = *rqp;
 	unsigned skip = 0;

 	q->orderr = 0;
 	q->ordered = q->next_ordered;
 	q->ordseq |= QUEUE_ORDSEQ_STARTED;

 	/*
 	 * For an empty barrier, there's no actual BAR request, which
 	 * in turn makes POSTFLUSH unnecessary.  Mask them off.
 	 */
 	if (!blk_rq_sectors(rq)) {
 		q->ordered &= ~(QUEUE_ORDERED_DO_BAR |
 				QUEUE_ORDERED_DO_POSTFLUSH);
 		/*
 		 * Empty barrier on a write-through device w/ ordered
 		 * tag has no command to issue and without any command
 		 * to issue, ordering by tag can't be used.  Drain
 		 * instead.
 		 */
 		if ((q->ordered & QUEUE_ORDERED_BY_TAG) &&
 		    !(q->ordered & QUEUE_ORDERED_DO_PREFLUSH)) {
 			q->ordered &= ~QUEUE_ORDERED_BY_TAG;
 			q->ordered |= QUEUE_ORDERED_BY_DRAIN;
 		}
 	}

 	/* stash away the original request */
 	blk_dequeue_request(rq);
 	q->orig_bar_rq = rq;
 	rq = NULL;

 	/*
 	 * Queue ordered sequence.  As we stack them at the head, we
 	 * need to queue in reverse order.  Note that we rely on that
 	 * no fs request uses ELEVATOR_INSERT_FRONT and thus no fs
 	 * request gets inbetween ordered sequence.
 	 */
 	if (q->ordered & QUEUE_ORDERED_DO_POSTFLUSH) {
 		queue_flush(q, QUEUE_ORDERED_DO_POSTFLUSH);
 		rq = &q->post_flush_rq;
 	} else
 		skip |= QUEUE_ORDSEQ_POSTFLUSH;

 	if (q->ordered & QUEUE_ORDERED_DO_BAR) {
 		rq = &q->bar_rq;

 		/* initialize proxy request and queue it */
 		blk_rq_init(q, rq);
 		if (bio_data_dir(q->orig_bar_rq->bio) == WRITE)
 			rq->cmd_flags |= REQ_RW;
 		if (q->ordered & QUEUE_ORDERED_DO_FUA)
 			rq->cmd_flags |= REQ_FUA;
 		init_request_from_bio(rq, q->orig_bar_rq->bio);
 		rq->end_io = bar_end_io;

 		elv_insert(q, rq, ELEVATOR_INSERT_FRONT);
 	} else
 		skip |= QUEUE_ORDSEQ_BAR;

 	if (q->ordered & QUEUE_ORDERED_DO_PREFLUSH) {
 		queue_flush(q, QUEUE_ORDERED_DO_PREFLUSH);
 		rq = &q->pre_flush_rq;
 	} else
 		skip |= QUEUE_ORDSEQ_PREFLUSH;

 	if ((q->ordered & QUEUE_ORDERED_BY_DRAIN) && queue_in_flight(q))
 		rq = NULL;
 	else
 		skip |= QUEUE_ORDSEQ_DRAIN;

 	*rqp = rq;

 	/*
 	 * Complete skipped sequences.  If whole sequence is complete,
 	 * return false to tell elevator that this request is gone.
 	 */
 	return !blk_ordered_complete_seq(q, skip, 0);
 }

 bool blk_do_ordered(struct request_queue *q, struct request **rqp)
 {
 	struct request *rq = *rqp;
 	const int is_barrier = blk_fs_request(rq) && blk_barrier_rq(rq);

 	if (!q->ordseq) {
 		if (!is_barrier)
 			return true;

 		if (q->next_ordered != QUEUE_ORDERED_NONE)
 			return start_ordered(q, rqp);
 		else {
 			/*
 			 * Queue ordering not supported.  Terminate
 			 * with prejudice.
 			 */
 			blk_dequeue_request(rq);
 			__blk_end_request_all(rq, -EOPNOTSUPP);
 			*rqp = NULL;
 			return false;
 		}
 	}

 	/*
 	 * Ordered sequence in progress
 	 */

 	/* Special requests are not subject to ordering rules. */
 	if (!blk_fs_request(rq) &&
 	    rq != &q->pre_flush_rq && rq != &q->post_flush_rq)
 		return true;

 	if (q->ordered & QUEUE_ORDERED_BY_TAG) {
 		/* Ordered by tag.  Blocking the next barrier is enough. */
 		if (is_barrier && rq != &q->bar_rq)
 			*rqp = NULL;
 	} else {
 		/* Ordered by draining.  Wait for turn. */
 		WARN_ON(blk_ordered_req_seq(rq) < blk_ordered_cur_seq(q));
 		if (blk_ordered_req_seq(rq) > blk_ordered_cur_seq(q))
 			*rqp = NULL;
 	}

 	return true;
 }

 static void bio_end_empty_barrier(struct bio *bio, int err)
 {
 	if (err) {
 		if (err == -EOPNOTSUPP)
 			set_bit(BIO_EOPNOTSUPP, &bio->bi_flags);
 		clear_bit(BIO_UPTODATE, &bio->bi_flags);
 	}

 	complete(bio->bi_private);
 }

 /**
  * blkdev_issue_flush - queue a flush
  * @bdev:	blockdev to issue flush for
  * @error_sector:	error sector
  *
  * Description:
  *    Issue a flush for the block device in question. Caller can supply
  *    room for storing the error offset in case of a flush error, if they
  *    wish to.
  */
 int blkdev_issue_flush(struct block_device *bdev, sector_t *error_sector)
 {
 	DECLARE_COMPLETION_ONSTACK(wait);
 	struct request_queue *q;
 	struct bio *bio;
 	int ret;

 	if (bdev->bd_disk == NULL)
 		return -ENXIO;

 	q = bdev_get_queue(bdev);
 	if (!q)
 		return -ENXIO;

 	bio = bio_alloc(GFP_KERNEL, 0);
 	bio->bi_end_io = bio_end_empty_barrier;
 	bio->bi_private = &wait;
 	bio->bi_bdev = bdev;
 	submit_bio(WRITE_BARRIER, bio);

 	wait_for_completion(&wait);

 	/*
 	 * The driver must store the error location in ->bi_sector, if
 	 * it supports it. For non-stacked drivers, this should be copied
 	 * from blk_rq_pos(rq).
 	 */
 	if (error_sector)
 		*error_sector = bio->bi_sector;

 	ret = 0;
 	if (bio_flagged(bio, BIO_EOPNOTSUPP))
 		ret = -EOPNOTSUPP;
 	else if (!bio_flagged(bio, BIO_UPTODATE))
 		ret = -EIO;

 	bio_put(bio);
 	return ret;
 }
 EXPORT_SYMBOL(blkdev_issue_flush);

 static void blkdev_discard_end_io(struct bio *bio, int err)
 {
 	if (err) {
 		if (err == -EOPNOTSUPP)
 			set_bit(BIO_EOPNOTSUPP, &bio->bi_flags);
 		clear_bit(BIO_UPTODATE, &bio->bi_flags);
 	}

 	if (bio->bi_private)
 		complete(bio->bi_private);
 	__free_page(bio_page(bio));

 	bio_put(bio);
 }

 /**
  * blkdev_issue_discard - queue a discard
  * @bdev:	blockdev to issue discard for
  * @sector:	start sector
  * @nr_sects:	number of sectors to discard
  * @gfp_mask:	memory allocation flags (for bio_alloc)
  * @flags:	DISCARD_FL_* flags to control behaviour
  *
  * Description:
  *    Issue a discard request for the sectors in question.
  */
 int blkdev_issue_discard(struct block_device *bdev, sector_t sector,
 		sector_t nr_sects, gfp_t gfp_mask, int flags)
 {
 	DECLARE_COMPLETION_ONSTACK(wait);
 	struct request_queue *q = bdev_get_queue(bdev);
 	int type = flags & DISCARD_FL_BARRIER ?
 		DISCARD_BARRIER : DISCARD_NOBARRIER;
 	struct bio *bio;
 	struct page *page;
 	int ret = 0;

 	if (!q)
 		return -ENXIO;

 	if (!blk_queue_discard(q))
 		return -EOPNOTSUPP;

 	while (nr_sects && !ret) {
 		unsigned int sector_size = q->limits.logical_block_size;
 		unsigned int max_discard_sectors =
 			min(q->limits.max_discard_sectors, UINT_MAX >> 9);

 		bio = bio_alloc(gfp_mask, 1);
 		if (!bio)
 			goto out;
 		bio->bi_sector = sector;
 		bio->bi_end_io = blkdev_discard_end_io;
 		bio->bi_bdev = bdev;
 		if (flags & DISCARD_FL_WAIT)
 			bio->bi_private = &wait;

 		/*
 		 * Add a zeroed one-sector payload as that's what
 		 * our current implementations need.  If we'll ever need
 		 * more the interface will need revisiting.
 		 */
 		page = alloc_page(GFP_KERNEL | __GFP_ZERO);
 		if (!page)
 			goto out_free_bio;
 		if (bio_add_pc_page(q, bio, page, sector_size, 0) < sector_size)
 			goto out_free_page;

 		/*
 		 * And override the bio size - the way discard works we
 		 * touch many more blocks on disk than the actual payload
 		 * length.
 		 */
 		if (nr_sects > max_discard_sectors) {
 			bio->bi_size = max_discard_sectors << 9;
 			nr_sects -= max_discard_sectors;
 			sector += max_discard_sectors;
 		} else {
 			bio->bi_size = nr_sects << 9;
 			nr_sects = 0;
 		}

 		bio_get(bio);
 		submit_bio(type, bio);

 		if (flags & DISCARD_FL_WAIT)
 			wait_for_completion(&wait);

 		if (bio_flagged(bio, BIO_EOPNOTSUPP))
 			ret = -EOPNOTSUPP;
 		else if (!bio_flagged(bio, BIO_UPTODATE))
 			ret = -EIO;
 		bio_put(bio);
 	}
 	return ret;
 out_free_page:
 	__free_page(page);
 out_free_bio:
 	bio_put(bio);
 out:
 	return -ENOMEM;
 }
 EXPORT_SYMBOL(blkdev_issue_discard);
	/*
	* Functions related to barrier IO handling
	*/
	#include <linux/kernel.h>
	#include <linux/module.h>
	#include <linux/bio.h>
	#include <linux/blkdev.h>

	#include "blk.h"

	/**
	* blk_queue_ordered - does this queue support ordered writes
	* @q: the request queue
	* @ordered: one of QUEUE_ORDERED_*
	* @prepare_flush_fn: rq setup helper for cache flush ordered writes
	*
	* Description:
	* For journalled file systems, doing ordered writes on a commit
	* block instead of explicitly doing wait_on_buffer (which is bad
	* for performance) can be a big win. Block drivers supporting this
	* feature should call this function and indicate so.
	*
	**/
	int blk_queue_ordered(struct request_queue *q, unsigned ordered,
	prepare_flush_fn *prepare_flush_fn)
	{
	if (!prepare_flush_fn && (ordered & (QUEUE_ORDERED_DO_PREFLUSH \|
	QUEUE_ORDERED_DO_POSTFLUSH))) {
	printk(KERN_ERR "%s: prepare_flush_fn required\n", __func__);
	return -EINVAL;
	}

	if (ordered != QUEUE_ORDERED_NONE &&
	ordered != QUEUE_ORDERED_DRAIN &&
	ordered != QUEUE_ORDERED_DRAIN_FLUSH &&
	ordered != QUEUE_ORDERED_DRAIN_FUA &&
	ordered != QUEUE_ORDERED_TAG &&
	ordered != QUEUE_ORDERED_TAG_FLUSH &&
	ordered != QUEUE_ORDERED_TAG_FUA) {
	printk(KERN_ERR "blk_queue_ordered: bad value %d\n", ordered);
	return -EINVAL;
	}

	q->ordered = ordered;
	q->next_ordered = ordered;
	q->prepare_flush_fn = prepare_flush_fn;

	return 0;
	}
	EXPORT_SYMBOL(blk_queue_ordered);

	/*
	* Cache flushing for ordered writes handling
	*/
	unsigned blk_ordered_cur_seq(struct request_queue *q)
	{
	if (!q->ordseq)
	return 0;
	return 1 << ffz(q->ordseq);
	}

	unsigned blk_ordered_req_seq(struct request *rq)
	{
	struct request_queue *q = rq->q;

	BUG_ON(q->ordseq == 0);

	if (rq == &q->pre_flush_rq)
	return QUEUE_ORDSEQ_PREFLUSH;
	if (rq == &q->bar_rq)
	return QUEUE_ORDSEQ_BAR;
	if (rq == &q->post_flush_rq)
	return QUEUE_ORDSEQ_POSTFLUSH;

	/*
	* !fs requests don't need to follow barrier ordering. Always
	* put them at the front. This fixes the following deadlock.
	*
	* http://thread.gmane.org/gmane.linux.kernel/537473
	*/
	if (!blk_fs_request(rq))
	return QUEUE_ORDSEQ_DRAIN;

	if ((rq->cmd_flags & REQ_ORDERED_COLOR) ==
	(q->orig_bar_rq->cmd_flags & REQ_ORDERED_COLOR))
	return QUEUE_ORDSEQ_DRAIN;
	else
	return QUEUE_ORDSEQ_DONE;
	}

	bool blk_ordered_complete_seq(struct request_queue *q, unsigned seq, int error)
	{
	struct request *rq;

	if (error && !q->orderr)
	q->orderr = error;

	BUG_ON(q->ordseq & seq);
	q->ordseq \|= seq;

	if (blk_ordered_cur_seq(q) != QUEUE_ORDSEQ_DONE)
	return false;

	/*
	* Okay, sequence complete.
	*/
	q->ordseq = 0;
	rq = q->orig_bar_rq;
	__blk_end_request_all(rq, q->orderr);
	return true;
	}

	static void pre_flush_end_io(struct request *rq, int error)
	{
	elv_completed_request(rq->q, rq);
	blk_ordered_complete_seq(rq->q, QUEUE_ORDSEQ_PREFLUSH, error);
	}

	static void bar_end_io(struct request *rq, int error)
	{
	elv_completed_request(rq->q, rq);
	blk_ordered_complete_seq(rq->q, QUEUE_ORDSEQ_BAR, error);
	}

	static void post_flush_end_io(struct request *rq, int error)
	{
	elv_completed_request(rq->q, rq);
	blk_ordered_complete_seq(rq->q, QUEUE_ORDSEQ_POSTFLUSH, error);
	}

	static void queue_flush(struct request_queue *q, unsigned which)
	{
	struct request *rq;
	rq_end_io_fn *end_io;

	if (which == QUEUE_ORDERED_DO_PREFLUSH) {
	rq = &q->pre_flush_rq;
	end_io = pre_flush_end_io;
	} else {
	rq = &q->post_flush_rq;
	end_io = post_flush_end_io;
	}

	blk_rq_init(q, rq);
	rq->cmd_flags = REQ_HARDBARRIER;
	rq->rq_disk = q->bar_rq.rq_disk;
	rq->end_io = end_io;
	q->prepare_flush_fn(q, rq);

	elv_insert(q, rq, ELEVATOR_INSERT_FRONT);
	}

	static inline bool start_ordered(struct request_queue q, struct request *rqp)
	{
	struct request rq = rqp;
	unsigned skip = 0;

	q->orderr = 0;
	q->ordered = q->next_ordered;
	q->ordseq \|= QUEUE_ORDSEQ_STARTED;

	/*
	* For an empty barrier, there's no actual BAR request, which
	* in turn makes POSTFLUSH unnecessary. Mask them off.
	*/
	if (!blk_rq_sectors(rq)) {
	q->ordered &= ~(QUEUE_ORDERED_DO_BAR \|
	QUEUE_ORDERED_DO_POSTFLUSH);
	/*
	* Empty barrier on a write-through device w/ ordered
	* tag has no command to issue and without any command
	* to issue, ordering by tag can't be used. Drain
	* instead.
	*/
	if ((q->ordered & QUEUE_ORDERED_BY_TAG) &&
	!(q->ordered & QUEUE_ORDERED_DO_PREFLUSH)) {
	q->ordered &= ~QUEUE_ORDERED_BY_TAG;
	q->ordered \|= QUEUE_ORDERED_BY_DRAIN;
	}
	}

	/* stash away the original request */
	blk_dequeue_request(rq);
	q->orig_bar_rq = rq;
	rq = NULL;

	/*
	* Queue ordered sequence. As we stack them at the head, we
	* need to queue in reverse order. Note that we rely on that
	* no fs request uses ELEVATOR_INSERT_FRONT and thus no fs
	* request gets inbetween ordered sequence.
	*/
	if (q->ordered & QUEUE_ORDERED_DO_POSTFLUSH) {
	queue_flush(q, QUEUE_ORDERED_DO_POSTFLUSH);
	rq = &q->post_flush_rq;
	} else
	skip \|= QUEUE_ORDSEQ_POSTFLUSH;

	if (q->ordered & QUEUE_ORDERED_DO_BAR) {
	rq = &q->bar_rq;

	/* initialize proxy request and queue it */
	blk_rq_init(q, rq);
	if (bio_data_dir(q->orig_bar_rq->bio) == WRITE)
	rq->cmd_flags \|= REQ_RW;
	if (q->ordered & QUEUE_ORDERED_DO_FUA)
	rq->cmd_flags \|= REQ_FUA;
	init_request_from_bio(rq, q->orig_bar_rq->bio);
	rq->end_io = bar_end_io;

	elv_insert(q, rq, ELEVATOR_INSERT_FRONT);
	} else
	skip \|= QUEUE_ORDSEQ_BAR;

	if (q->ordered & QUEUE_ORDERED_DO_PREFLUSH) {
	queue_flush(q, QUEUE_ORDERED_DO_PREFLUSH);
	rq = &q->pre_flush_rq;
	} else
	skip \|= QUEUE_ORDSEQ_PREFLUSH;

	if ((q->ordered & QUEUE_ORDERED_BY_DRAIN) && queue_in_flight(q))
	rq = NULL;
	else
	skip \|= QUEUE_ORDSEQ_DRAIN;

	*rqp = rq;

	/*
	* Complete skipped sequences. If whole sequence is complete,
	* return false to tell elevator that this request is gone.
	*/
	return !blk_ordered_complete_seq(q, skip, 0);
	}

	bool blk_do_ordered(struct request_queue q, struct request *rqp)
	{
	struct request rq = rqp;
	const int is_barrier = blk_fs_request(rq) && blk_barrier_rq(rq);

	if (!q->ordseq) {
	if (!is_barrier)
	return true;

	if (q->next_ordered != QUEUE_ORDERED_NONE)
	return start_ordered(q, rqp);
	else {
	/*
	* Queue ordering not supported. Terminate
	* with prejudice.
	*/
	blk_dequeue_request(rq);
	__blk_end_request_all(rq, -EOPNOTSUPP);
	*rqp = NULL;
	return false;
	}
	}

	/*
	* Ordered sequence in progress
	*/

	/* Special requests are not subject to ordering rules. */
	if (!blk_fs_request(rq) &&
	rq != &q->pre_flush_rq && rq != &q->post_flush_rq)
	return true;

	if (q->ordered & QUEUE_ORDERED_BY_TAG) {
	/* Ordered by tag. Blocking the next barrier is enough. */
	if (is_barrier && rq != &q->bar_rq)
	*rqp = NULL;
	} else {
	/* Ordered by draining. Wait for turn. */
	WARN_ON(blk_ordered_req_seq(rq) < blk_ordered_cur_seq(q));
	if (blk_ordered_req_seq(rq) > blk_ordered_cur_seq(q))
	*rqp = NULL;
	}

	return true;
	}

	static void bio_end_empty_barrier(struct bio *bio, int err)
	{
	if (err) {
	if (err == -EOPNOTSUPP)
	set_bit(BIO_EOPNOTSUPP, &bio->bi_flags);
	clear_bit(BIO_UPTODATE, &bio->bi_flags);
	}

	complete(bio->bi_private);
	}

	/**
	* blkdev_issue_flush - queue a flush
	* @bdev: blockdev to issue flush for
	* @error_sector: error sector
	*
	* Description:
	* Issue a flush for the block device in question. Caller can supply
	* room for storing the error offset in case of a flush error, if they
	* wish to.
	*/
	int blkdev_issue_flush(struct block_device bdev, sector_t error_sector)
	{
	DECLARE_COMPLETION_ONSTACK(wait);
	struct request_queue *q;
	struct bio *bio;
	int ret;

	if (bdev->bd_disk == NULL)
	return -ENXIO;

	q = bdev_get_queue(bdev);
	if (!q)
	return -ENXIO;

	bio = bio_alloc(GFP_KERNEL, 0);
	bio->bi_end_io = bio_end_empty_barrier;
	bio->bi_private = &wait;
	bio->bi_bdev = bdev;
	submit_bio(WRITE_BARRIER, bio);

	wait_for_completion(&wait);

	/*
	* The driver must store the error location in ->bi_sector, if
	* it supports it. For non-stacked drivers, this should be copied
	* from blk_rq_pos(rq).
	*/
	if (error_sector)
	*error_sector = bio->bi_sector;

	ret = 0;
	if (bio_flagged(bio, BIO_EOPNOTSUPP))
	ret = -EOPNOTSUPP;
	else if (!bio_flagged(bio, BIO_UPTODATE))
	ret = -EIO;

	bio_put(bio);
	return ret;
	}
	EXPORT_SYMBOL(blkdev_issue_flush);

	static void blkdev_discard_end_io(struct bio *bio, int err)
	{
	if (err) {
	if (err == -EOPNOTSUPP)
	set_bit(BIO_EOPNOTSUPP, &bio->bi_flags);
	clear_bit(BIO_UPTODATE, &bio->bi_flags);
	}

	if (bio->bi_private)
	complete(bio->bi_private);
	__free_page(bio_page(bio));

	bio_put(bio);
	}

	/**
	* blkdev_issue_discard - queue a discard
	* @bdev: blockdev to issue discard for
	* @sector: start sector
	* @nr_sects: number of sectors to discard
	* @gfp_mask: memory allocation flags (for bio_alloc)
	* @flags: DISCARD_FL_* flags to control behaviour
	*
	* Description:
	* Issue a discard request for the sectors in question.
	*/
	int blkdev_issue_discard(struct block_device *bdev, sector_t sector,
	sector_t nr_sects, gfp_t gfp_mask, int flags)
	{
	DECLARE_COMPLETION_ONSTACK(wait);
	struct request_queue *q = bdev_get_queue(bdev);
	int type = flags & DISCARD_FL_BARRIER ?
	DISCARD_BARRIER : DISCARD_NOBARRIER;
	struct bio *bio;
	struct page *page;
	int ret = 0;

	if (!q)
	return -ENXIO;

	if (!blk_queue_discard(q))
	return -EOPNOTSUPP;

	while (nr_sects && !ret) {
	unsigned int sector_size = q->limits.logical_block_size;
	unsigned int max_discard_sectors =
	min(q->limits.max_discard_sectors, UINT_MAX >> 9);

	bio = bio_alloc(gfp_mask, 1);
	if (!bio)
	goto out;
	bio->bi_sector = sector;
	bio->bi_end_io = blkdev_discard_end_io;
	bio->bi_bdev = bdev;
	if (flags & DISCARD_FL_WAIT)
	bio->bi_private = &wait;

	/*
	* Add a zeroed one-sector payload as that's what
	* our current implementations need. If we'll ever need
	* more the interface will need revisiting.
	*/
	page = alloc_page(GFP_KERNEL \| __GFP_ZERO);
	if (!page)
	goto out_free_bio;
	if (bio_add_pc_page(q, bio, page, sector_size, 0) < sector_size)
	goto out_free_page;

	/*
	* And override the bio size - the way discard works we
	* touch many more blocks on disk than the actual payload
	* length.
	*/
	if (nr_sects > max_discard_sectors) {
	bio->bi_size = max_discard_sectors << 9;
	nr_sects -= max_discard_sectors;
	sector += max_discard_sectors;
	} else {
	bio->bi_size = nr_sects << 9;
	nr_sects = 0;
	}

	bio_get(bio);
	submit_bio(type, bio);

	if (flags & DISCARD_FL_WAIT)
	wait_for_completion(&wait);

	if (bio_flagged(bio, BIO_EOPNOTSUPP))
	ret = -EOPNOTSUPP;
	else if (!bio_flagged(bio, BIO_UPTODATE))
	ret = -EIO;
	bio_put(bio);
	}
	return ret;
	out_free_page:
	__free_page(page);
	out_free_bio:
	bio_put(bio);
	out:
	return -ENOMEM;
	}
	EXPORT_SYMBOL(blkdev_issue_discard);