Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit c888a8f9 authored by Jens Axboe's avatar Jens Axboe
Browse files

block: kill off q->flush_flags 



Now that we converted everything to the newer block write cache
interface, kill off the queue flush_flags and queueable flush
entries.

Signed-off-by: default avatarJens Axboe <axboe@fb.com>
parent c875a709

block/blk-core.c

+2 −1
Original line number Diff line number Diff line
@@ -1964,7 +1964,8 @@ generic_make_request_checks(struct bio *bio) 
	 * drivers without flush support don't have to worry

	 * about them.

	 */

	if ((bio->bi_rw & (REQ_FLUSH | REQ_FUA)) && !q->flush_flags) {

	if ((bio->bi_rw & (REQ_FLUSH | REQ_FUA)) &&

	    !test_bit(QUEUE_FLAG_WC, &q->queue_flags)) {

		bio->bi_rw &= ~(REQ_FLUSH | REQ_FUA);

		if (!nr_sectors) {

			err = 0;

block/blk-flush.c

+6 −5
Original line number Diff line number Diff line
@@ -95,17 +95,18 @@ enum { 
static bool blk_kick_flush(struct request_queue *q,

			   struct blk_flush_queue *fq);



static unsigned int blk_flush_policy(unsigned int fflags, struct request *rq)

static unsigned int blk_flush_policy(unsigned long fflags, struct request *rq)

{

	unsigned int policy = 0;



	if (blk_rq_sectors(rq))

		policy |= REQ_FSEQ_DATA;



	if (fflags & REQ_FLUSH) {

	if (fflags & (1UL << QUEUE_FLAG_WC)) {

		if (rq->cmd_flags & REQ_FLUSH)

			policy |= REQ_FSEQ_PREFLUSH;

		if (!(fflags & REQ_FUA) && (rq->cmd_flags & REQ_FUA))

		if (!(fflags & (1UL << QUEUE_FLAG_FUA)) &&

		    (rq->cmd_flags & REQ_FUA))

			policy |= REQ_FSEQ_POSTFLUSH;

	}

	return policy;
@@ -384,7 +385,7 @@ static void mq_flush_data_end_io(struct request *rq, int error) 
void blk_insert_flush(struct request *rq)

{

	struct request_queue *q = rq->q;

	unsigned int fflags = q->flush_flags;	/* may change, cache */

	unsigned long fflags = q->queue_flags;	/* may change, cache */

	unsigned int policy = blk_flush_policy(fflags, rq);

	struct blk_flush_queue *fq = blk_get_flush_queue(q, rq->mq_ctx);
@@ -393,7 +394,7 @@ void blk_insert_flush(struct request *rq) 
	 * REQ_FLUSH and FUA for the driver.

	 */

	rq->cmd_flags &= ~REQ_FLUSH;

	if (!(fflags & REQ_FUA))

	if (!(fflags & (1UL << QUEUE_FLAG_FUA)))

		rq->cmd_flags &= ~REQ_FUA;



	/*

block/blk-settings.c

+10 −8
Original line number Diff line number Diff line
@@ -822,7 +822,12 @@ EXPORT_SYMBOL(blk_queue_update_dma_alignment); 


void blk_queue_flush_queueable(struct request_queue *q, bool queueable)

{

	q->flush_not_queueable = !queueable;

	spin_lock_irq(q->queue_lock);

	if (queueable)

		clear_bit(QUEUE_FLAG_FLUSH_NQ, &q->queue_flags);

	else

		set_bit(QUEUE_FLAG_FLUSH_NQ, &q->queue_flags);

	spin_unlock_irq(q->queue_lock);

}

EXPORT_SYMBOL_GPL(blk_queue_flush_queueable);
@@ -837,16 +842,13 @@ EXPORT_SYMBOL_GPL(blk_queue_flush_queueable); 
void blk_queue_write_cache(struct request_queue *q, bool wc, bool fua)

{

	spin_lock_irq(q->queue_lock);

	if (wc) {

	if (wc)

		queue_flag_set(QUEUE_FLAG_WC, q);

		q->flush_flags = REQ_FLUSH;

	} else

	else

		queue_flag_clear(QUEUE_FLAG_WC, q);

	if (fua) {

		if (wc)

			q->flush_flags |= REQ_FUA;

	if (fua)

		queue_flag_set(QUEUE_FLAG_FUA, q);

	} else

	else

		queue_flag_clear(QUEUE_FLAG_FUA, q);

	spin_unlock_irq(q->queue_lock);

}

drivers/block/xen-blkback/xenbus.c

+1 −1
Original line number Diff line number Diff line
@@ -477,7 +477,7 @@ static int xen_vbd_create(struct xen_blkif *blkif, blkif_vdev_t handle, 
		vbd->type |= VDISK_REMOVABLE;



	q = bdev_get_queue(bdev);

	if (q && q->flush_flags)

	if (q && test_bit(QUEUE_FLAG_WC, &q->queue_flags))

		vbd->flush_support = true;



	if (q && blk_queue_secdiscard(q))

drivers/md/dm-table.c

+6 −6
Original line number Diff line number Diff line
@@ -1348,13 +1348,13 @@ static void dm_table_verify_integrity(struct dm_table *t) 
static int device_flush_capable(struct dm_target *ti, struct dm_dev *dev,

				sector_t start, sector_t len, void *data)

{

	unsigned flush = (*(unsigned *)data);

	unsigned long flush = (unsigned long) data;

	struct request_queue *q = bdev_get_queue(dev->bdev);



	return q && (q->flush_flags & flush);

	return q && (q->queue_flags & flush);

}



static bool dm_table_supports_flush(struct dm_table *t, unsigned flush)

static bool dm_table_supports_flush(struct dm_table *t, unsigned long flush)

{

	struct dm_target *ti;

	unsigned i = 0;
@@ -1375,7 +1375,7 @@ static bool dm_table_supports_flush(struct dm_table *t, unsigned flush) 
			return true;



		if (ti->type->iterate_devices &&

		    ti->type->iterate_devices(ti, device_flush_capable, &flush))

		    ti->type->iterate_devices(ti, device_flush_capable, (void *) flush))

			return true;

	}
@@ -1518,9 +1518,9 @@ void dm_table_set_restrictions(struct dm_table *t, struct request_queue *q, 
	else

		queue_flag_set_unlocked(QUEUE_FLAG_DISCARD, q);



	if (dm_table_supports_flush(t, REQ_FLUSH)) {

	if (dm_table_supports_flush(t, (1UL << QUEUE_FLAG_WC))) {

		wc = true;

		if (dm_table_supports_flush(t, REQ_FUA))

		if (dm_table_supports_flush(t, (1UL << QUEUE_FLAG_FUA)))

			fua = true;

	}

	blk_queue_write_cache(q, wc, fua);