Commit 44abff2c authored by Christoph Hellwig's avatar Christoph Hellwig Committed by Jens Axboe
Browse files

block: decouple REQ_OP_SECURE_ERASE from REQ_OP_DISCARD 



Secure erase is a very different operation from discard in that it is
a data integrity operation vs hint.  Fully split the limits and helper
infrastructure to make the separation more clear.

Signed-off-by: default avatarChristoph Hellwig <hch@lst.de>
Reviewed-by: default avatarMartin K. Petersen <martin.petersen@oracle.com>
Acked-by: Christoph Böhmwalder <christoph.boehmwalder@linbit.com> [drbd]
Acked-by: Ryusuke Konishi <konishi.ryusuke@gmail.com> [nifs2]
Acked-by: Jaegeuk Kim <jaegeuk@kernel.org> [f2fs]
Acked-by: Coly Li <colyli@suse.de> [bcache]
Acked-by: David Sterba <dsterba@suse.com> [btrfs]
Acked-by: default avatarChao Yu <chao@kernel.org>
Reviewed-by: default avatarChaitanya Kulkarni <kch@nvidia.com>
Link: https://lore.kernel.org/r/20220415045258.199825-27-hch@lst.de


Signed-off-by: default avatarJens Axboe <axboe@kernel.dk>
parent 7b47ef52

block/blk-core.c

+1 −1
Original line number Diff line number Diff line
@@ -824,7 +824,7 @@ void submit_bio_noacct(struct bio *bio) 
			goto not_supported;

		break;

	case REQ_OP_SECURE_ERASE:

		if (!blk_queue_secure_erase(q))

		if (!bdev_max_secure_erase_sectors(bdev))

			goto not_supported;

		break;

	case REQ_OP_ZONE_APPEND:

block/blk-lib.c

+45 −19
Original line number Diff line number Diff line
@@ -36,26 +36,15 @@ static sector_t bio_discard_limit(struct block_device *bdev, sector_t sector) 
}



int __blkdev_issue_discard(struct block_device *bdev, sector_t sector,

		sector_t nr_sects, gfp_t gfp_mask, int flags,

		struct bio **biop)

		sector_t nr_sects, gfp_t gfp_mask, struct bio **biop)

{

	struct request_queue *q = bdev_get_queue(bdev);

	struct bio *bio = *biop;

	unsigned int op;

	sector_t bs_mask;



	if (bdev_read_only(bdev))

		return -EPERM;



	if (flags & BLKDEV_DISCARD_SECURE) {

		if (!blk_queue_secure_erase(q))

			return -EOPNOTSUPP;

		op = REQ_OP_SECURE_ERASE;

	} else {

	if (!bdev_max_discard_sectors(bdev))

		return -EOPNOTSUPP;

		op = REQ_OP_DISCARD;

	}



	/* In case the discard granularity isn't set by buggy device driver */

	if (WARN_ON_ONCE(!bdev_discard_granularity(bdev))) {
@@ -77,7 +66,7 @@ int __blkdev_issue_discard(struct block_device *bdev, sector_t sector, 
		sector_t req_sects =

			min(nr_sects, bio_discard_limit(bdev, sector));



		bio = blk_next_bio(bio, bdev, 0, op, gfp_mask);

		bio = blk_next_bio(bio, bdev, 0, REQ_OP_DISCARD, gfp_mask);

		bio->bi_iter.bi_sector = sector;

		bio->bi_iter.bi_size = req_sects << 9;

		sector += req_sects;
@@ -103,21 +92,19 @@ EXPORT_SYMBOL(__blkdev_issue_discard); 
 * @sector:	start sector

 * @nr_sects:	number of sectors to discard

 * @gfp_mask:	memory allocation flags (for bio_alloc)

 * @flags:	BLKDEV_DISCARD_* 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, unsigned long flags)

		sector_t nr_sects, gfp_t gfp_mask)

{

	struct bio *bio = NULL;

	struct blk_plug plug;

	int ret;



	blk_start_plug(&plug);

	ret = __blkdev_issue_discard(bdev, sector, nr_sects, gfp_mask, flags,

			&bio);

	ret = __blkdev_issue_discard(bdev, sector, nr_sects, gfp_mask, &bio);

	if (!ret && bio) {

		ret = submit_bio_wait(bio);

		if (ret == -EOPNOTSUPP)
@@ -314,3 +301,42 @@ int blkdev_issue_zeroout(struct block_device *bdev, sector_t sector, 
	return ret;

}

EXPORT_SYMBOL(blkdev_issue_zeroout);



int blkdev_issue_secure_erase(struct block_device *bdev, sector_t sector,

		sector_t nr_sects, gfp_t gfp)

{

	sector_t bs_mask = (bdev_logical_block_size(bdev) >> 9) - 1;

	unsigned int max_sectors = bdev_max_secure_erase_sectors(bdev);

	struct bio *bio = NULL;

	struct blk_plug plug;

	int ret = 0;



	if (max_sectors == 0)

		return -EOPNOTSUPP;

	if ((sector | nr_sects) & bs_mask)

		return -EINVAL;

	if (bdev_read_only(bdev))

		return -EPERM;



	blk_start_plug(&plug);

	for (;;) {

		unsigned int len = min_t(sector_t, nr_sects, max_sectors);



		bio = blk_next_bio(bio, bdev, 0, REQ_OP_SECURE_ERASE, gfp);

		bio->bi_iter.bi_sector = sector;

		bio->bi_iter.bi_size = len;



		sector += len << SECTOR_SHIFT;

		nr_sects -= len << SECTOR_SHIFT;

		if (!nr_sects) {

			ret = submit_bio_wait(bio);

			bio_put(bio);

			break;

		}

		cond_resched();

	}

	blk_finish_plug(&plug);



	return ret;

}

EXPORT_SYMBOL(blkdev_issue_secure_erase);

block/blk-mq-debugfs.c

+0 −1
Original line number Diff line number Diff line
@@ -115,7 +115,6 @@ static const char *const blk_queue_flag_name[] = { 
	QUEUE_FLAG_NAME(IO_STAT),

	QUEUE_FLAG_NAME(NOXMERGES),

	QUEUE_FLAG_NAME(ADD_RANDOM),

	QUEUE_FLAG_NAME(SECERASE),

	QUEUE_FLAG_NAME(SAME_FORCE),

	QUEUE_FLAG_NAME(DEAD),

	QUEUE_FLAG_NAME(INIT_DONE),

block/blk-settings.c

+15 −1
Original line number Diff line number Diff line
@@ -46,6 +46,7 @@ void blk_set_default_limits(struct queue_limits *lim) 
	lim->max_zone_append_sectors = 0;

	lim->max_discard_sectors = 0;

	lim->max_hw_discard_sectors = 0;

	lim->max_secure_erase_sectors = 0;

	lim->discard_granularity = 0;

	lim->discard_alignment = 0;

	lim->discard_misaligned = 0;
@@ -176,6 +177,18 @@ void blk_queue_max_discard_sectors(struct request_queue *q, 
}

EXPORT_SYMBOL(blk_queue_max_discard_sectors);



/**

 * blk_queue_max_secure_erase_sectors - set max sectors for a secure erase

 * @q:  the request queue for the device

 * @max_sectors: maximum number of sectors to secure_erase

 **/

void blk_queue_max_secure_erase_sectors(struct request_queue *q,

		unsigned int max_sectors)

{

	q->limits.max_secure_erase_sectors = max_sectors;

}

EXPORT_SYMBOL(blk_queue_max_secure_erase_sectors);



/**

 * blk_queue_max_write_zeroes_sectors - set max sectors for a single

 *                                      write zeroes
@@ -661,7 +674,8 @@ int blk_stack_limits(struct queue_limits *t, struct queue_limits *b, 
		t->discard_alignment = lcm_not_zero(t->discard_alignment, alignment) %

			t->discard_granularity;

	}



	t->max_secure_erase_sectors = min_not_zero(t->max_secure_erase_sectors,

						   b->max_secure_erase_sectors);

	t->zone_write_granularity = max(t->zone_write_granularity,

					b->zone_write_granularity);

	t->zoned = max(t->zoned, b->zoned);

block/fops.c

+1 −1
Original line number Diff line number Diff line
@@ -677,7 +677,7 @@ static long blkdev_fallocate(struct file *file, int mode, loff_t start, 
		break;

	case FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE | FALLOC_FL_NO_HIDE_STALE:

		error = blkdev_issue_discard(bdev, start >> SECTOR_SHIFT,

					     len >> SECTOR_SHIFT, GFP_KERNEL, 0);

					     len >> SECTOR_SHIFT, GFP_KERNEL);

		break;

	default:

		error = -EOPNOTSUPP;