Commit 8446fe92 authored by Christoph Hellwig's avatar Christoph Hellwig Committed by Jens Axboe
Browse files

block: switch partition lookup to use struct block_device 



Use struct block_device to lookup partitions on a disk.  This removes
all usage of struct hd_struct from the I/O path.

Signed-off-by: default avatarChristoph Hellwig <hch@lst.de>
Reviewed-by: default avatarJan Kara <jack@suse.cz>
Reviewed-by: default avatarHannes Reinecke <hare@suse.de>
Acked-by: Coly Li <colyli@suse.de>			[bcache]
Acked-by: Chao Yu <yuchao0@huawei.com>			[f2fs]
Signed-off-by: default avatarJens Axboe <axboe@kernel.dk>
parent cb8432d6

block/bio.c

+2 −2
Original line number Diff line number Diff line
@@ -608,12 +608,12 @@ void bio_truncate(struct bio *bio, unsigned new_size) 
void guard_bio_eod(struct bio *bio)

{

	sector_t maxsector;

	struct hd_struct *part;

	struct block_device *part;



	rcu_read_lock();

	part = __disk_get_part(bio->bi_disk, bio->bi_partno);

	if (part)

		maxsector = bdev_nr_sectors(part->bdev);

		maxsector = bdev_nr_sectors(part);

	else	

		maxsector = get_capacity(bio->bi_disk);

	rcu_read_unlock();

block/blk-core.c

+30 −36
Original line number Diff line number Diff line
@@ -666,10 +666,9 @@ static int __init setup_fail_make_request(char *str) 
}

__setup("fail_make_request=", setup_fail_make_request);



static bool should_fail_request(struct hd_struct *part, unsigned int bytes)

static bool should_fail_request(struct block_device *part, unsigned int bytes)

{

	return part->bdev->bd_make_it_fail &&

		should_fail(&fail_make_request, bytes);

	return part->bd_make_it_fail && should_fail(&fail_make_request, bytes);

}



static int __init fail_make_request_debugfs(void)
@@ -684,7 +683,7 @@ late_initcall(fail_make_request_debugfs); 


#else /* CONFIG_FAIL_MAKE_REQUEST */



static inline bool should_fail_request(struct hd_struct *part,

static inline bool should_fail_request(struct block_device *part,

					unsigned int bytes)

{

	return false;
@@ -692,11 +691,11 @@ static inline bool should_fail_request(struct hd_struct *part, 


#endif /* CONFIG_FAIL_MAKE_REQUEST */



static inline bool bio_check_ro(struct bio *bio, struct hd_struct *part)

static inline bool bio_check_ro(struct bio *bio, struct block_device *part)

{

	const int op = bio_op(bio);



	if (part->bdev->bd_read_only && op_is_write(op)) {

	if (part->bd_read_only && op_is_write(op)) {

		char b[BDEVNAME_SIZE];



		if (op_is_flush(bio->bi_opf) && !bio_sectors(bio))
@@ -704,7 +703,7 @@ static inline bool bio_check_ro(struct bio *bio, struct hd_struct *part) 


		WARN_ONCE(1,

		       "Trying to write to read-only block-device %s (partno %d)\n",

			bio_devname(bio, b), part->partno);

			bio_devname(bio, b), part->bd_partno);

		/* Older lvm-tools actually trigger this */

		return false;

	}
@@ -714,8 +713,7 @@ static inline bool bio_check_ro(struct bio *bio, struct hd_struct *part) 


static noinline int should_fail_bio(struct bio *bio)

{

	if (should_fail_request(bio->bi_disk->part0->bd_part,

			bio->bi_iter.bi_size))

	if (should_fail_request(bio->bi_disk->part0, bio->bi_iter.bi_size))

		return -EIO;

	return 0;

}
@@ -744,7 +742,7 @@ static inline int bio_check_eod(struct bio *bio, sector_t maxsector) 
 */

static inline int blk_partition_remap(struct bio *bio)

{

	struct hd_struct *p;

	struct block_device *p;

	int ret = -EIO;



	rcu_read_lock();
@@ -757,12 +755,12 @@ static inline int blk_partition_remap(struct bio *bio) 
		goto out;



	if (bio_sectors(bio)) {

		if (bio_check_eod(bio, bdev_nr_sectors(p->bdev)))

		if (bio_check_eod(bio, bdev_nr_sectors(p)))

			goto out;

		bio->bi_iter.bi_sector += p->bdev->bd_start_sect;

		trace_block_bio_remap(bio->bi_disk->queue, bio, part_devt(p),

		bio->bi_iter.bi_sector += p->bd_start_sect;

		trace_block_bio_remap(bio->bi_disk->queue, bio, p->bd_dev,

				      bio->bi_iter.bi_sector -

				      p->bdev->bd_start_sect);

				      p->bd_start_sect);

	}

	bio->bi_partno = 0;

	ret = 0;
@@ -832,7 +830,7 @@ static noinline_for_stack bool submit_bio_checks(struct bio *bio) 
		if (unlikely(blk_partition_remap(bio)))

			goto end_io;

	} else {

		if (unlikely(bio_check_ro(bio, bio->bi_disk->part0->bd_part)))

		if (unlikely(bio_check_ro(bio, bio->bi_disk->part0)))

			goto end_io;

		if (unlikely(bio_check_eod(bio, get_capacity(bio->bi_disk))))

			goto end_io;
@@ -1204,7 +1202,7 @@ blk_status_t blk_insert_cloned_request(struct request_queue *q, struct request * 
		return ret;



	if (rq->rq_disk &&

	    should_fail_request(rq->rq_disk->part0->bd_part, blk_rq_bytes(rq)))

	    should_fail_request(rq->rq_disk->part0, blk_rq_bytes(rq)))

		return BLK_STS_IOERR;



	if (blk_crypto_insert_cloned_request(rq))
@@ -1263,17 +1261,18 @@ unsigned int blk_rq_err_bytes(const struct request *rq) 
}

EXPORT_SYMBOL_GPL(blk_rq_err_bytes);



static void update_io_ticks(struct hd_struct *part, unsigned long now, bool end)

static void update_io_ticks(struct block_device *part, unsigned long now,

		bool end)

{

	unsigned long stamp;

again:

	stamp = READ_ONCE(part->bdev->bd_stamp);

	stamp = READ_ONCE(part->bd_stamp);

	if (unlikely(stamp != now)) {

		if (likely(cmpxchg(&part->bdev->bd_stamp, stamp, now) == stamp))

		if (likely(cmpxchg(&part->bd_stamp, stamp, now) == stamp))

			__part_stat_add(part, io_ticks, end ? now - stamp : 1);

	}

	if (part->partno) {

		part = part_to_disk(part)->part0->bd_part;

	if (part->bd_partno) {

		part = bdev_whole(part);

		goto again;

	}

}
@@ -1282,11 +1281,9 @@ static void blk_account_io_completion(struct request *req, unsigned int bytes) 
{

	if (req->part && blk_do_io_stat(req)) {

		const int sgrp = op_stat_group(req_op(req));

		struct hd_struct *part;



		part_stat_lock();

		part = req->part;

		part_stat_add(part, sectors[sgrp], bytes >> 9);

		part_stat_add(req->part, sectors[sgrp], bytes >> 9);

		part_stat_unlock();

	}

}
@@ -1301,14 +1298,11 @@ void blk_account_io_done(struct request *req, u64 now) 
	if (req->part && blk_do_io_stat(req) &&

	    !(req->rq_flags & RQF_FLUSH_SEQ)) {

		const int sgrp = op_stat_group(req_op(req));

		struct hd_struct *part;



		part_stat_lock();

		part = req->part;



		update_io_ticks(part, jiffies, true);

		part_stat_inc(part, ios[sgrp]);

		part_stat_add(part, nsecs[sgrp], now - req->start_time_ns);

		update_io_ticks(req->part, jiffies, true);

		part_stat_inc(req->part, ios[sgrp]);

		part_stat_add(req->part, nsecs[sgrp], now - req->start_time_ns);

		part_stat_unlock();

	}

}
@@ -1325,7 +1319,7 @@ void blk_account_io_start(struct request *rq) 
	part_stat_unlock();

}



static unsigned long __part_start_io_acct(struct hd_struct *part,

static unsigned long __part_start_io_acct(struct block_device *part,

					  unsigned int sectors, unsigned int op)

{

	const int sgrp = op_stat_group(op);
@@ -1341,7 +1335,7 @@ static unsigned long __part_start_io_acct(struct hd_struct *part, 
	return now;

}



unsigned long part_start_io_acct(struct gendisk *disk, struct hd_struct **part,

unsigned long part_start_io_acct(struct gendisk *disk, struct block_device **part,

				 struct bio *bio)

{

	*part = disk_map_sector_rcu(disk, bio->bi_iter.bi_sector);
@@ -1353,11 +1347,11 @@ EXPORT_SYMBOL_GPL(part_start_io_acct); 
unsigned long disk_start_io_acct(struct gendisk *disk, unsigned int sectors,

				 unsigned int op)

{

	return __part_start_io_acct(disk->part0->bd_part, sectors, op);

	return __part_start_io_acct(disk->part0, sectors, op);

}

EXPORT_SYMBOL(disk_start_io_acct);



static void __part_end_io_acct(struct hd_struct *part, unsigned int op,

static void __part_end_io_acct(struct block_device *part, unsigned int op,

			       unsigned long start_time)

{

	const int sgrp = op_stat_group(op);
@@ -1371,7 +1365,7 @@ static void __part_end_io_acct(struct hd_struct *part, unsigned int op, 
	part_stat_unlock();

}



void part_end_io_acct(struct hd_struct *part, struct bio *bio,

void part_end_io_acct(struct block_device *part, struct bio *bio,

		      unsigned long start_time)

{

	__part_end_io_acct(part, bio_op(bio), start_time);
@@ -1381,7 +1375,7 @@ EXPORT_SYMBOL_GPL(part_end_io_acct); 
void disk_end_io_acct(struct gendisk *disk, unsigned int op,

		      unsigned long start_time)

{

	__part_end_io_acct(disk->part0->bd_part, op, start_time);

	__part_end_io_acct(disk->part0, op, start_time);

}

EXPORT_SYMBOL(disk_end_io_acct);

block/blk-flush.c

+1 −1
Original line number Diff line number Diff line
@@ -139,7 +139,7 @@ static void blk_flush_queue_rq(struct request *rq, bool add_front) 


static void blk_account_io_flush(struct request *rq)

{

	struct hd_struct *part = rq->rq_disk->part0->bd_part;

	struct block_device *part = rq->rq_disk->part0;



	part_stat_lock();

	part_stat_inc(part, ios[STAT_FLUSH]);

block/blk-mq.c

+5 −4
Original line number Diff line number Diff line
@@ -95,7 +95,7 @@ static void blk_mq_hctx_clear_pending(struct blk_mq_hw_ctx *hctx, 
}



struct mq_inflight {

	struct hd_struct *part;

	struct block_device *part;

	unsigned int inflight[2];

};
@@ -111,7 +111,8 @@ static bool blk_mq_check_inflight(struct blk_mq_hw_ctx *hctx, 
	return true;

}



unsigned int blk_mq_in_flight(struct request_queue *q, struct hd_struct *part)

unsigned int blk_mq_in_flight(struct request_queue *q,

		struct block_device *part)

{

	struct mq_inflight mi = { .part = part };
@@ -120,7 +121,7 @@ unsigned int blk_mq_in_flight(struct request_queue *q, struct hd_struct *part) 
	return mi.inflight[0] + mi.inflight[1];

}



void blk_mq_in_flight_rw(struct request_queue *q, struct hd_struct *part,

void blk_mq_in_flight_rw(struct request_queue *q, struct block_device *part,

		unsigned int inflight[2])

{

	struct mq_inflight mi = { .part = part };

block/blk-mq.h

+4 −3
Original line number Diff line number Diff line
@@ -182,8 +182,9 @@ static inline bool blk_mq_hw_queue_mapped(struct blk_mq_hw_ctx *hctx) 
	return hctx->nr_ctx && hctx->tags;

}



unsigned int blk_mq_in_flight(struct request_queue *q, struct hd_struct *part);

void blk_mq_in_flight_rw(struct request_queue *q, struct hd_struct *part,

unsigned int blk_mq_in_flight(struct request_queue *q,

		struct block_device *part);

void blk_mq_in_flight_rw(struct request_queue *q, struct block_device *part,

		unsigned int inflight[2]);



static inline void blk_mq_put_dispatch_budget(struct request_queue *q)