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

Commit 7b6d91da authored by Christoph Hellwig's avatar Christoph Hellwig Committed by Jens Axboe
Browse files

block: unify flags for struct bio and struct request 



Remove the current bio flags and reuse the request flags for the bio, too.
This allows to more easily trace the type of I/O from the filesystem
down to the block driver.  There were two flags in the bio that were
missing in the requests:  BIO_RW_UNPLUG and BIO_RW_AHEAD.  Also I've
renamed two request flags that had a superflous RW in them.

Note that the flags are in bio.h despite having the REQ_ name - as
blkdev.h includes bio.h that is the only way to go for now.

Signed-off-by: default avatarChristoph Hellwig <hch@lst.de>
Signed-off-by: default avatarJens Axboe <jaxboe@fusionio.com>
parent 33659ebb

block/blk-barrier.c

+1 −1
Original line number Diff line number Diff line
@@ -203,7 +203,7 @@ static inline bool start_ordered(struct request_queue *q, struct request **rqp) 
		/* 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;

			rq->cmd_flags |= REQ_WRITE;

		if (q->ordered & QUEUE_ORDERED_DO_FUA)

			rq->cmd_flags |= REQ_FUA;

		init_request_from_bio(rq, q->orig_bar_rq->bio);

block/blk-core.c

+10 −27
Original line number Diff line number Diff line
@@ -1140,25 +1140,9 @@ void init_request_from_bio(struct request *req, struct bio *bio) 
	req->cpu = bio->bi_comp_cpu;

	req->cmd_type = REQ_TYPE_FS;



	/*

	 * Inherit FAILFAST from bio (for read-ahead, and explicit

	 * FAILFAST).  FAILFAST flags are identical for req and bio.

	 */

	if (bio_rw_flagged(bio, BIO_RW_AHEAD))

	req->cmd_flags |= bio->bi_rw & REQ_COMMON_MASK;

	if (bio->bi_rw & REQ_RAHEAD)

		req->cmd_flags |= REQ_FAILFAST_MASK;

	else

		req->cmd_flags |= bio->bi_rw & REQ_FAILFAST_MASK;



	if (bio_rw_flagged(bio, BIO_RW_DISCARD))

		req->cmd_flags |= REQ_DISCARD;

	if (bio_rw_flagged(bio, BIO_RW_BARRIER))

		req->cmd_flags |= REQ_HARDBARRIER;

	if (bio_rw_flagged(bio, BIO_RW_SYNCIO))

		req->cmd_flags |= REQ_RW_SYNC;

	if (bio_rw_flagged(bio, BIO_RW_META))

		req->cmd_flags |= REQ_RW_META;

	if (bio_rw_flagged(bio, BIO_RW_NOIDLE))

		req->cmd_flags |= REQ_NOIDLE;



	req->errors = 0;

	req->__sector = bio->bi_sector;
@@ -1181,12 +1165,12 @@ static int __make_request(struct request_queue *q, struct bio *bio) 
	int el_ret;

	unsigned int bytes = bio->bi_size;

	const unsigned short prio = bio_prio(bio);

	const bool sync = bio_rw_flagged(bio, BIO_RW_SYNCIO);

	const bool unplug = bio_rw_flagged(bio, BIO_RW_UNPLUG);

	const bool sync = (bio->bi_rw & REQ_SYNC);

	const bool unplug = (bio->bi_rw & REQ_UNPLUG);

	const unsigned int ff = bio->bi_rw & REQ_FAILFAST_MASK;

	int rw_flags;



	if (bio_rw_flagged(bio, BIO_RW_BARRIER) &&

	if ((bio->bi_rw & REQ_HARDBARRIER) &&

	    (q->next_ordered == QUEUE_ORDERED_NONE)) {

		bio_endio(bio, -EOPNOTSUPP);

		return 0;
@@ -1200,7 +1184,7 @@ static int __make_request(struct request_queue *q, struct bio *bio) 


	spin_lock_irq(q->queue_lock);



	if (unlikely(bio_rw_flagged(bio, BIO_RW_BARRIER)) || elv_queue_empty(q))

	if (unlikely((bio->bi_rw & REQ_HARDBARRIER)) || elv_queue_empty(q))

		goto get_rq;



	el_ret = elv_merge(q, &req, bio);
@@ -1275,7 +1259,7 @@ static int __make_request(struct request_queue *q, struct bio *bio) 
	 */

	rw_flags = bio_data_dir(bio);

	if (sync)

		rw_flags |= REQ_RW_SYNC;

		rw_flags |= REQ_SYNC;



	/*

	 * Grab a free request. This is might sleep but can not fail.
@@ -1464,7 +1448,7 @@ static inline void __generic_make_request(struct bio *bio) 
			goto end_io;

		}



		if (unlikely(!bio_rw_flagged(bio, BIO_RW_DISCARD) &&

		if (unlikely(!(bio->bi_rw & REQ_DISCARD) &&

			     nr_sectors > queue_max_hw_sectors(q))) {

			printk(KERN_ERR "bio too big device %s (%u > %u)\n",

			       bdevname(bio->bi_bdev, b),
@@ -1497,8 +1481,7 @@ static inline void __generic_make_request(struct bio *bio) 
		if (bio_check_eod(bio, nr_sectors))

			goto end_io;



		if (bio_rw_flagged(bio, BIO_RW_DISCARD) &&

		    !blk_queue_discard(q)) {

		if ((bio->bi_rw & REQ_DISCARD) && !blk_queue_discard(q)) {

			err = -EOPNOTSUPP;

			goto end_io;

		}
@@ -2365,7 +2348,7 @@ void blk_rq_bio_prep(struct request_queue *q, struct request *rq, 
		     struct bio *bio)

{

	/* Bit 0 (R/W) is identical in rq->cmd_flags and bio->bi_rw */

	rq->cmd_flags |= bio->bi_rw & REQ_RW;

	rq->cmd_flags |= bio->bi_rw & REQ_WRITE;



	if (bio_has_data(bio)) {

		rq->nr_phys_segments = bio_phys_segments(q, bio);

block/blk-map.c

+1 −1
Original line number Diff line number Diff line
@@ -307,7 +307,7 @@ int blk_rq_map_kern(struct request_queue *q, struct request *rq, void *kbuf, 
		return PTR_ERR(bio);



	if (rq_data_dir(rq) == WRITE)

		bio->bi_rw |= (1 << BIO_RW);

		bio->bi_rw |= (1 << REQ_WRITE);



	if (do_copy)

		rq->cmd_flags |= REQ_COPY_USER;

block/blk-merge.c

+1 −1
Original line number Diff line number Diff line
@@ -180,7 +180,7 @@ int blk_rq_map_sg(struct request_queue *q, struct request *rq, 
	}



	if (q->dma_drain_size && q->dma_drain_needed(rq)) {

		if (rq->cmd_flags & REQ_RW)

		if (rq->cmd_flags & REQ_WRITE)

			memset(q->dma_drain_buffer, 0, q->dma_drain_size);



		sg->page_link &= ~0x02;

block/cfq-iosched.c

+7 −7
Original line number Diff line number Diff line
@@ -458,7 +458,7 @@ static inline struct cfq_data *cic_to_cfqd(struct cfq_io_context *cic) 
 */

static inline bool cfq_bio_sync(struct bio *bio)

{

	return bio_data_dir(bio) == READ || bio_rw_flagged(bio, BIO_RW_SYNCIO);

	return bio_data_dir(bio) == READ || (bio->bi_rw & REQ_SYNC);

}



/*
@@ -646,10 +646,10 @@ cfq_choose_req(struct cfq_data *cfqd, struct request *rq1, struct request *rq2, 
		return rq1;

	else if (rq_is_sync(rq2) && !rq_is_sync(rq1))

		return rq2;

	if ((rq1->cmd_flags & REQ_RW_META) && !(rq2->cmd_flags & REQ_RW_META))

	if ((rq1->cmd_flags & REQ_META) && !(rq2->cmd_flags & REQ_META))

		return rq1;

	else if ((rq2->cmd_flags & REQ_RW_META) &&

		 !(rq1->cmd_flags & REQ_RW_META))

	else if ((rq2->cmd_flags & REQ_META) &&

		 !(rq1->cmd_flags & REQ_META))

		return rq2;



	s1 = blk_rq_pos(rq1);
@@ -1485,7 +1485,7 @@ static void cfq_remove_request(struct request *rq) 
	cfqq->cfqd->rq_queued--;

	cfq_blkiocg_update_io_remove_stats(&(RQ_CFQG(rq))->blkg,

					rq_data_dir(rq), rq_is_sync(rq));

	if (rq->cmd_flags & REQ_RW_META) {

	if (rq->cmd_flags & REQ_META) {

		WARN_ON(!cfqq->meta_pending);

		cfqq->meta_pending--;

	}
@@ -3177,7 +3177,7 @@ cfq_should_preempt(struct cfq_data *cfqd, struct cfq_queue *new_cfqq, 
	 * So both queues are sync. Let the new request get disk time if

	 * it's a metadata request and the current queue is doing regular IO.

	 */

	if ((rq->cmd_flags & REQ_RW_META) && !cfqq->meta_pending)

	if ((rq->cmd_flags & REQ_META) && !cfqq->meta_pending)

		return true;



	/*
@@ -3231,7 +3231,7 @@ cfq_rq_enqueued(struct cfq_data *cfqd, struct cfq_queue *cfqq, 
	struct cfq_io_context *cic = RQ_CIC(rq);



	cfqd->rq_queued++;

	if (rq->cmd_flags & REQ_RW_META)

	if (rq->cmd_flags & REQ_META)

		cfqq->meta_pending++;



	cfq_update_io_thinktime(cfqd, cic);