Commit 4913efe4 authored by Tejun Heo's avatar Tejun Heo Committed by Jens Axboe
Browse files

block: deprecate barrier and replace blk_queue_ordered() with blk_queue_flush() 



Barrier is deemed too heavy and will soon be replaced by FLUSH/FUA
requests.  Deprecate barrier.  All REQ_HARDBARRIERs are failed with
-EOPNOTSUPP and blk_queue_ordered() is replaced with simpler
blk_queue_flush().

blk_queue_flush() takes combinations of REQ_FLUSH and FUA.  If a
device has write cache and can flush it, it should set REQ_FLUSH.  If
the device can handle FUA writes, it should also set REQ_FUA.

All blk_queue_ordered() users are converted.

* ORDERED_DRAIN is mapped to 0 which is the default value.
* ORDERED_DRAIN_FLUSH is mapped to REQ_FLUSH.
* ORDERED_DRAIN_FLUSH_FUA is mapped to REQ_FLUSH | REQ_FUA.

Signed-off-by: default avatarTejun Heo <tj@kernel.org>
Acked-by: default avatarBoaz Harrosh <bharrosh@panasas.com>
Cc: Christoph Hellwig <hch@infradead.org>
Cc: Nick Piggin <npiggin@kernel.dk>
Cc: Michael S. Tsirkin <mst@redhat.com>
Cc: Jeremy Fitzhardinge <jeremy@xensource.com>
Cc: Chris Wright <chrisw@sous-sol.org>
Cc: FUJITA Tomonori <fujita.tomonori@lab.ntt.co.jp>
Cc: Geert Uytterhoeven <Geert.Uytterhoeven@sonycom.com>
Cc: David S. Miller <davem@davemloft.net>
Cc: Alasdair G Kergon <agk@redhat.com>
Cc: Pierre Ossman <drzeus@drzeus.cx>
Cc: Stefan Weinhuber <wein@de.ibm.com>
Signed-off-by: default avatarJens Axboe <jaxboe@fusionio.com>
parent 6958f145

block/blk-barrier.c

+0 −29
Original line number Diff line number Diff line
@@ -9,35 +9,6 @@ 


#include "blk.h"



/**

 * blk_queue_ordered - does this queue support ordered writes

 * @q:        the request queue

 * @ordered:  one of QUEUE_ORDERED_*

 *

 * 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)

{

	if (ordered != QUEUE_ORDERED_NONE &&

	    ordered != QUEUE_ORDERED_DRAIN &&

	    ordered != QUEUE_ORDERED_DRAIN_FLUSH &&

	    ordered != QUEUE_ORDERED_DRAIN_FUA) {

		printk(KERN_ERR "blk_queue_ordered: bad value %d\n", ordered);

		return -EINVAL;

	}



	q->ordered = ordered;

	q->next_ordered = ordered;



	return 0;

}

EXPORT_SYMBOL(blk_queue_ordered);



/*

 * Cache flushing for ordered writes handling

 */

block/blk-core.c

+4 −2
Original line number Diff line number Diff line
@@ -1203,11 +1203,13 @@ static int __make_request(struct request_queue *q, struct bio *bio) 
	const unsigned int ff = bio->bi_rw & REQ_FAILFAST_MASK;

	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

block/blk-settings.c

+20 −0
Original line number Diff line number Diff line
@@ -794,6 +794,26 @@ void blk_queue_update_dma_alignment(struct request_queue *q, int mask) 
}

EXPORT_SYMBOL(blk_queue_update_dma_alignment);



/**

 * blk_queue_flush - configure queue's cache flush capability

 * @q:		the request queue for the device

 * @flush:	0, REQ_FLUSH or REQ_FLUSH | REQ_FUA

 *

 * Tell block layer cache flush capability of @q.  If it supports

 * flushing, REQ_FLUSH should be set.  If it supports bypassing

 * write cache for individual writes, REQ_FUA should be set.

 */

void blk_queue_flush(struct request_queue *q, unsigned int flush)

{

	WARN_ON_ONCE(flush & ~(REQ_FLUSH | REQ_FUA));



	if (WARN_ON_ONCE(!(flush & REQ_FLUSH) && (flush & REQ_FUA)))

		flush &= ~REQ_FUA;



	q->flush_flags = flush & (REQ_FLUSH | REQ_FUA);

}

EXPORT_SYMBOL_GPL(blk_queue_flush);



static int __init blk_settings_init(void)

{

	blk_max_low_pfn = max_low_pfn - 1;

drivers/block/brd.c

+0 −1
Original line number Diff line number Diff line
@@ -482,7 +482,6 @@ static struct brd_device *brd_alloc(int i) 
	if (!brd->brd_queue)

		goto out_free_dev;

	blk_queue_make_request(brd->brd_queue, brd_make_request);

	blk_queue_ordered(brd->brd_queue, QUEUE_ORDERED_DRAIN);

	blk_queue_max_hw_sectors(brd->brd_queue, 1024);

	blk_queue_bounce_limit(brd->brd_queue, BLK_BOUNCE_ANY);

drivers/block/loop.c

+1 −1
Original line number Diff line number Diff line
@@ -832,7 +832,7 @@ static int loop_set_fd(struct loop_device *lo, fmode_t mode, 
	lo->lo_queue->unplug_fn = loop_unplug;



	if (!(lo_flags & LO_FLAGS_READ_ONLY) && file->f_op->fsync)

		blk_queue_ordered(lo->lo_queue, QUEUE_ORDERED_DRAIN_FLUSH);

		blk_queue_flush(lo->lo_queue, REQ_FLUSH);



	set_capacity(lo->lo_disk, size);

	bd_set_size(bdev, size << 9);

CRA Git | Maintained and supported by SUSTech CRA and CCSE