[linux.git] / block / blk-zoned.c

/*
 * Zoned block device handling
 *
 * Copyright (c) 2015, Hannes Reinecke
 * Copyright (c) 2015, SUSE Linux GmbH
 *
 * Copyright (c) 2016, Damien Le Moal
 * Copyright (c) 2016, Western Digital
 */

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/rbtree.h>
#include <linux/blkdev.h>

static inline sector_t blk_zone_start(struct request_queue *q,
				      sector_t sector)
{
	sector_t zone_mask = blk_queue_zone_sectors(q) - 1;

	return sector & ~zone_mask;
}

/*
 * Check that a zone report belongs to the partition.
 * If yes, fix its start sector and write pointer, copy it in the
 * zone information array and return true. Return false otherwise.
 */
static bool blkdev_report_zone(struct block_device *bdev,
			       struct blk_zone *rep,
			       struct blk_zone *zone)
{
	sector_t offset = get_start_sect(bdev);

	if (rep->start < offset)
		return false;

	rep->start -= offset;
	if (rep->start + rep->len > bdev->bd_part->nr_sects)
		return false;

	if (rep->type == BLK_ZONE_TYPE_CONVENTIONAL)
		rep->wp = rep->start + rep->len;
	else
		rep->wp -= offset;
	memcpy(zone, rep, sizeof(struct blk_zone));

	return true;
}

/**
 * blkdev_report_zones - Get zones information
 * @bdev:	Target block device
 * @sector:	Sector from which to report zones
 * @zones:	Array of zone structures where to return the zones information
 * @nr_zones:	Number of zone structures in the zone array
 * @gfp_mask:	Memory allocation flags (for bio_alloc)
 *
 * Description:
 *    Get zone information starting from the zone containing @sector.
 *    The number of zone information reported may be less than the number
 *    requested by @nr_zones. The number of zones actually reported is
 *    returned in @nr_zones.
 */
int blkdev_report_zones(struct block_device *bdev,
			sector_t sector,
			struct blk_zone *zones,
			unsigned int *nr_zones,
			gfp_t gfp_mask)
{
	struct request_queue *q = bdev_get_queue(bdev);
	struct blk_zone_report_hdr *hdr;
	unsigned int nrz = *nr_zones;
	struct page *page;
	unsigned int nr_rep;
	size_t rep_bytes;
	unsigned int nr_pages;
	struct bio *bio;
	struct bio_vec *bv;
	unsigned int i, n, nz;
	unsigned int ofst;
	void *addr;
	int ret;

	if (!q)
		return -ENXIO;

	if (!blk_queue_is_zoned(q))
		return -EOPNOTSUPP;

	if (!nrz)
		return 0;

	if (sector > bdev->bd_part->nr_sects) {
		*nr_zones = 0;
		return 0;
	}

	/*
	 * The zone report has a header. So make room for it in the
	 * payload. Also make sure that the report fits in a single BIO
	 * that will not be split down the stack.
	 */
	rep_bytes = sizeof(struct blk_zone_report_hdr) +
		sizeof(struct blk_zone) * nrz;
	rep_bytes = (rep_bytes + PAGE_SIZE - 1) & PAGE_MASK;
	if (rep_bytes > (queue_max_sectors(q) << 9))
		rep_bytes = queue_max_sectors(q) << 9;

	nr_pages = min_t(unsigned int, BIO_MAX_PAGES,
			 rep_bytes >> PAGE_SHIFT);
	nr_pages = min_t(unsigned int, nr_pages,
			 queue_max_segments(q));

	bio = bio_alloc(gfp_mask, nr_pages);
	if (!bio)
		return -ENOMEM;

	bio_set_dev(bio, bdev);
	bio->bi_iter.bi_sector = blk_zone_start(q, sector);
	bio_set_op_attrs(bio, REQ_OP_ZONE_REPORT, 0);

	for (i = 0; i < nr_pages; i++) {
		page = alloc_page(gfp_mask);
		if (!page) {
			ret = -ENOMEM;
			goto out;
		}
		if (!bio_add_page(bio, page, PAGE_SIZE, 0)) {
			__free_page(page);
			break;
		}
	}

	if (i == 0)
		ret = -ENOMEM;
	else
		ret = submit_bio_wait(bio);
	if (ret)
		goto out;

	/*
	 * Process the report result: skip the header and go through the
	 * reported zones to fixup and fixup the zone information for
	 * partitions. At the same time, return the zone information into
	 * the zone array.
	 */
	n = 0;
	nz = 0;
	nr_rep = 0;
	bio_for_each_segment_all(bv, bio, i) {

		if (!bv->bv_page)
			break;

		addr = kmap_atomic(bv->bv_page);

		/* Get header in the first page */
		ofst = 0;
		if (!nr_rep) {
			hdr = (struct blk_zone_report_hdr *) addr;
			nr_rep = hdr->nr_zones;
			ofst = sizeof(struct blk_zone_report_hdr);
		}

		/* Fixup and report zones */
		while (ofst < bv->bv_len &&
		       n < nr_rep && nz < nrz) {
			if (blkdev_report_zone(bdev, addr + ofst, &zones[nz]))
				nz++;
			ofst += sizeof(struct blk_zone);
			n++;
		}

		kunmap_atomic(addr);

		if (n >= nr_rep || nz >= nrz)
			break;

	}

	*nr_zones = nz;
out:
	bio_for_each_segment_all(bv, bio, i)
		__free_page(bv->bv_page);
	bio_put(bio);

	return ret;
}
EXPORT_SYMBOL_GPL(blkdev_report_zones);

/**
 * blkdev_reset_zones - Reset zones write pointer
 * @bdev:	Target block device
 * @sector:	Start sector of the first zone to reset
 * @nr_sectors:	Number of sectors, at least the length of one zone
 * @gfp_mask:	Memory allocation flags (for bio_alloc)
 *
 * Description:
 *    Reset the write pointer of the zones contained in the range
 *    @sector..@sector+@nr_sectors. Specifying the entire disk sector range
 *    is valid, but the specified range should not contain conventional zones.
 */
int blkdev_reset_zones(struct block_device *bdev,
		       sector_t sector, sector_t nr_sectors,
		       gfp_t gfp_mask)
{
	struct request_queue *q = bdev_get_queue(bdev);
	sector_t zone_sectors;
	sector_t end_sector = sector + nr_sectors;
	struct bio *bio;
	int ret;

	if (!q)
		return -ENXIO;

	if (!blk_queue_is_zoned(q))
		return -EOPNOTSUPP;

	if (end_sector > bdev->bd_part->nr_sects)
		/* Out of range */
		return -EINVAL;

	/* Check alignment (handle eventual smaller last zone) */
	zone_sectors = blk_queue_zone_sectors(q);
	if (sector & (zone_sectors - 1))
		return -EINVAL;

	if ((nr_sectors & (zone_sectors - 1)) &&
	    end_sector != bdev->bd_part->nr_sects)
		return -EINVAL;

	while (sector < end_sector) {

		bio = bio_alloc(gfp_mask, 0);
		bio->bi_iter.bi_sector = sector;
		bio_set_dev(bio, bdev);
		bio_set_op_attrs(bio, REQ_OP_ZONE_RESET, 0);

		ret = submit_bio_wait(bio);
		bio_put(bio);

		if (ret)
			return ret;

		sector += zone_sectors;

		/* This may take a while, so be nice to others */
		cond_resched();

	}

	return 0;
}
EXPORT_SYMBOL_GPL(blkdev_reset_zones);

/**
 * BLKREPORTZONE ioctl processing.
 * Called from blkdev_ioctl.
 */
int blkdev_report_zones_ioctl(struct block_device *bdev, fmode_t mode,
			      unsigned int cmd, unsigned long arg)
{
	void __user *argp = (void __user *)arg;
	struct request_queue *q;
	struct blk_zone_report rep;
	struct blk_zone *zones;
	int ret;

	if (!argp)
		return -EINVAL;

	q = bdev_get_queue(bdev);
	if (!q)
		return -ENXIO;

	if (!blk_queue_is_zoned(q))
		return -ENOTTY;

	if (!capable(CAP_SYS_ADMIN))
		return -EACCES;

	if (copy_from_user(&rep, argp, sizeof(struct blk_zone_report)))
		return -EFAULT;

	if (!rep.nr_zones)
		return -EINVAL;

	zones = kcalloc(rep.nr_zones, sizeof(struct blk_zone), GFP_KERNEL);
	if (!zones)
		return -ENOMEM;

	ret = blkdev_report_zones(bdev, rep.sector,
				  zones, &rep.nr_zones,
				  GFP_KERNEL);
	if (ret)
		goto out;

	if (copy_to_user(argp, &rep, sizeof(struct blk_zone_report))) {
		ret = -EFAULT;
		goto out;
	}

	if (rep.nr_zones) {
		if (copy_to_user(argp + sizeof(struct blk_zone_report), zones,
				 sizeof(struct blk_zone) * rep.nr_zones))
			ret = -EFAULT;
	}

 out:
	kfree(zones);

	return ret;
}

/**
 * BLKRESETZONE ioctl processing.
 * Called from blkdev_ioctl.
 */
int blkdev_reset_zones_ioctl(struct block_device *bdev, fmode_t mode,
			     unsigned int cmd, unsigned long arg)
{
	void __user *argp = (void __user *)arg;
	struct request_queue *q;
	struct blk_zone_range zrange;

	if (!argp)
		return -EINVAL;

	q = bdev_get_queue(bdev);
	if (!q)
		return -ENXIO;

	if (!blk_queue_is_zoned(q))
		return -ENOTTY;

	if (!capable(CAP_SYS_ADMIN))
		return -EACCES;

	if (!(mode & FMODE_WRITE))
		return -EBADF;

	if (copy_from_user(&zrange, argp, sizeof(struct blk_zone_range)))
		return -EFAULT;

	return blkdev_reset_zones(bdev, zrange.sector, zrange.nr_sectors,
				  GFP_KERNEL);
}
Commit	Line	Data
6a0cb1bc HR	1	/*
	2	* Zoned block device handling
	3	*
	4	* Copyright (c) 2015, Hannes Reinecke
	5	* Copyright (c) 2015, SUSE Linux GmbH
	6	*
	7	* Copyright (c) 2016, Damien Le Moal
	8	* Copyright (c) 2016, Western Digital
	9	*/
	10
	11	#include <linux/kernel.h>
	12	#include <linux/module.h>
	13	#include <linux/rbtree.h>
	14	#include <linux/blkdev.h>
	15
	16	static inline sector_t blk_zone_start(struct request_queue *q,
	17	sector_t sector)
	18	{
f99e8648	19	sector_t zone_mask = blk_queue_zone_sectors(q) - 1;
6a0cb1bc HR	20
	21	return sector & ~zone_mask;
	22	}
	23
	24	/*
	25	* Check that a zone report belongs to the partition.
	26	* If yes, fix its start sector and write pointer, copy it in the
	27	* zone information array and return true. Return false otherwise.
	28	*/
	29	static bool blkdev_report_zone(struct block_device *bdev,
	30	struct blk_zone *rep,
	31	struct blk_zone *zone)
	32	{
	33	sector_t offset = get_start_sect(bdev);
	34
	35	if (rep->start < offset)
	36	return false;
	37
	38	rep->start -= offset;
	39	if (rep->start + rep->len > bdev->bd_part->nr_sects)
	40	return false;
	41
	42	if (rep->type == BLK_ZONE_TYPE_CONVENTIONAL)
	43	rep->wp = rep->start + rep->len;
	44	else
	45	rep->wp -= offset;
	46	memcpy(zone, rep, sizeof(struct blk_zone));
	47
	48	return true;
	49	}
	50
	51	/**
	52	* blkdev_report_zones - Get zones information
	53	* @bdev: Target block device
	54	* @sector: Sector from which to report zones
	55	* @zones: Array of zone structures where to return the zones information
	56	* @nr_zones: Number of zone structures in the zone array
	57	* @gfp_mask: Memory allocation flags (for bio_alloc)
	58	*
	59	* Description:
	60	* Get zone information starting from the zone containing @sector.
	61	* The number of zone information reported may be less than the number
	62	* requested by @nr_zones. The number of zones actually reported is
	63	* returned in @nr_zones.
	64	*/
	65	int blkdev_report_zones(struct block_device *bdev,
	66	sector_t sector,
	67	struct blk_zone *zones,
	68	unsigned int *nr_zones,
	69	gfp_t gfp_mask)
	70	{
	71	struct request_queue *q = bdev_get_queue(bdev);
	72	struct blk_zone_report_hdr *hdr;
	73	unsigned int nrz = *nr_zones;
	74	struct page *page;
	75	unsigned int nr_rep;
	76	size_t rep_bytes;
	77	unsigned int nr_pages;
	78	struct bio *bio;
	79	struct bio_vec *bv;
	80	unsigned int i, n, nz;
	81	unsigned int ofst;
	82	void *addr;
3c4da758	83	int ret;
6a0cb1bc HR	84
	85	if (!q)
	86	return -ENXIO;
	87
	88	if (!blk_queue_is_zoned(q))
	89	return -EOPNOTSUPP;
	90
	91	if (!nrz)
	92	return 0;
	93
	94	if (sector > bdev->bd_part->nr_sects) {
	95	*nr_zones = 0;
	96	return 0;
	97	}
	98
	99	/*
	100	* The zone report has a header. So make room for it in the
	101	* payload. Also make sure that the report fits in a single BIO
	102	* that will not be split down the stack.
	103	*/
	104	rep_bytes = sizeof(struct blk_zone_report_hdr) +
	105	sizeof(struct blk_zone) * nrz;
	106	rep_bytes = (rep_bytes + PAGE_SIZE - 1) & PAGE_MASK;
	107	if (rep_bytes > (queue_max_sectors(q) << 9))
	108	rep_bytes = queue_max_sectors(q) << 9;
	109
	110	nr_pages = min_t(unsigned int, BIO_MAX_PAGES,
	111	rep_bytes >> PAGE_SHIFT);
	112	nr_pages = min_t(unsigned int, nr_pages,
	113	queue_max_segments(q));
	114
	115	bio = bio_alloc(gfp_mask, nr_pages);
	116	if (!bio)
	117	return -ENOMEM;
	118
74d46992	119	bio_set_dev(bio, bdev);
6a0cb1bc HR	120	bio->bi_iter.bi_sector = blk_zone_start(q, sector);
	121	bio_set_op_attrs(bio, REQ_OP_ZONE_REPORT, 0);
	122
	123	for (i = 0; i < nr_pages; i++) {
	124	page = alloc_page(gfp_mask);
	125	if (!page) {
	126	ret = -ENOMEM;
	127	goto out;
	128	}
	129	if (!bio_add_page(bio, page, PAGE_SIZE, 0)) {
	130	__free_page(page);
	131	break;
	132	}
	133	}
	134
	135	if (i == 0)
	136	ret = -ENOMEM;
	137	else
	138	ret = submit_bio_wait(bio);
	139	if (ret)
	140	goto out;
	141
	142	/*
	143	* Process the report result: skip the header and go through the
	144	* reported zones to fixup and fixup the zone information for
	145	* partitions. At the same time, return the zone information into
	146	* the zone array.
	147	*/
	148	n = 0;
	149	nz = 0;
	150	nr_rep = 0;
	151	bio_for_each_segment_all(bv, bio, i) {
	152
	153	if (!bv->bv_page)
	154	break;
	155
	156	addr = kmap_atomic(bv->bv_page);
	157
	158	/* Get header in the first page */
	159	ofst = 0;
	160	if (!nr_rep) {
	161	hdr = (struct blk_zone_report_hdr *) addr;
	162	nr_rep = hdr->nr_zones;
	163	ofst = sizeof(struct blk_zone_report_hdr);
	164	}
	165
	166	/* Fixup and report zones */
	167	while (ofst < bv->bv_len &&
	168	n < nr_rep && nz < nrz) {
	169	if (blkdev_report_zone(bdev, addr + ofst, &zones[nz]))
	170	nz++;
	171	ofst += sizeof(struct blk_zone);
	172	n++;
	173	}
	174
	175	kunmap_atomic(addr);
	176
	177	if (n >= nr_rep \|\| nz >= nrz)
	178	break;
	179
	180	}
	181
3c4da758	182	*nr_zones = nz;
6a0cb1bc HR	183	out:
	184	bio_for_each_segment_all(bv, bio, i)
	185	__free_page(bv->bv_page);
	186	bio_put(bio);
	187
6a0cb1bc HR	188	return ret;
	189	}
	190	EXPORT_SYMBOL_GPL(blkdev_report_zones);
	191
	192	/**
	193	* blkdev_reset_zones - Reset zones write pointer
	194	* @bdev: Target block device
	195	* @sector: Start sector of the first zone to reset
	196	* @nr_sectors: Number of sectors, at least the length of one zone
	197	* @gfp_mask: Memory allocation flags (for bio_alloc)
	198	*
	199	* Description:
	200	* Reset the write pointer of the zones contained in the range
	201	* @sector..@sector+@nr_sectors. Specifying the entire disk sector range
	202	* is valid, but the specified range should not contain conventional zones.
	203	*/
	204	int blkdev_reset_zones(struct block_device *bdev,
	205	sector_t sector, sector_t nr_sectors,
	206	gfp_t gfp_mask)
	207	{
	208	struct request_queue *q = bdev_get_queue(bdev);
	209	sector_t zone_sectors;
	210	sector_t end_sector = sector + nr_sectors;
	211	struct bio *bio;
	212	int ret;
	213
	214	if (!q)
	215	return -ENXIO;
	216
	217	if (!blk_queue_is_zoned(q))
	218	return -EOPNOTSUPP;
	219
	220	if (end_sector > bdev->bd_part->nr_sects)
	221	/* Out of range */
	222	return -EINVAL;
	223
	224	/* Check alignment (handle eventual smaller last zone) */
f99e8648	225	zone_sectors = blk_queue_zone_sectors(q);
6a0cb1bc HR	226	if (sector & (zone_sectors - 1))
	227	return -EINVAL;
	228
	229	if ((nr_sectors & (zone_sectors - 1)) &&
	230	end_sector != bdev->bd_part->nr_sects)
	231	return -EINVAL;
	232
	233	while (sector < end_sector) {
	234
	235	bio = bio_alloc(gfp_mask, 0);
	236	bio->bi_iter.bi_sector = sector;
74d46992	237	bio_set_dev(bio, bdev);
6a0cb1bc HR	238	bio_set_op_attrs(bio, REQ_OP_ZONE_RESET, 0);
	239
	240	ret = submit_bio_wait(bio);
	241	bio_put(bio);
	242
	243	if (ret)
	244	return ret;
	245
	246	sector += zone_sectors;
	247
	248	/* This may take a while, so be nice to others */
	249	cond_resched();
	250
	251	}
	252
	253	return 0;
	254	}
	255	EXPORT_SYMBOL_GPL(blkdev_reset_zones);
3ed05a98 ST	256
	257	/**
	258	* BLKREPORTZONE ioctl processing.
	259	* Called from blkdev_ioctl.
	260	*/
	261	int blkdev_report_zones_ioctl(struct block_device *bdev, fmode_t mode,
	262	unsigned int cmd, unsigned long arg)
	263	{
	264	void __user argp = (void __user )arg;
	265	struct request_queue *q;
	266	struct blk_zone_report rep;
	267	struct blk_zone *zones;
	268	int ret;
	269
	270	if (!argp)
	271	return -EINVAL;
	272
	273	q = bdev_get_queue(bdev);
	274	if (!q)
	275	return -ENXIO;
	276
	277	if (!blk_queue_is_zoned(q))
	278	return -ENOTTY;
	279
	280	if (!capable(CAP_SYS_ADMIN))
	281	return -EACCES;
	282
	283	if (copy_from_user(&rep, argp, sizeof(struct blk_zone_report)))
	284	return -EFAULT;
	285
	286	if (!rep.nr_zones)
	287	return -EINVAL;
	288
	289	zones = kcalloc(rep.nr_zones, sizeof(struct blk_zone), GFP_KERNEL);
	290	if (!zones)
	291	return -ENOMEM;
	292
	293	ret = blkdev_report_zones(bdev, rep.sector,
	294	zones, &rep.nr_zones,
	295	GFP_KERNEL);
	296	if (ret)
	297	goto out;
	298
	299	if (copy_to_user(argp, &rep, sizeof(struct blk_zone_report))) {
	300	ret = -EFAULT;
	301	goto out;
	302	}
	303
	304	if (rep.nr_zones) {
	305	if (copy_to_user(argp + sizeof(struct blk_zone_report), zones,
	306	sizeof(struct blk_zone) * rep.nr_zones))
	307	ret = -EFAULT;
	308	}
	309
	310	out:
	311	kfree(zones);
	312
	313	return ret;
	314	}
	315
	316	/**
	317	* BLKRESETZONE ioctl processing.
	318	* Called from blkdev_ioctl.
	319	*/
320	int blkdev_reset_zones_ioctl(struct block_device *bdev, fmode_t mode,
321	unsigned int cmd, unsigned long arg)
322	{
323	void __user argp = (void __user )arg;
324	struct request_queue *q;
325	struct blk_zone_range zrange;
326
327	if (!argp)
328	return -EINVAL;
329
330	q = bdev_get_queue(bdev);
331	if (!q)
332	return -ENXIO;
333
334	if (!blk_queue_is_zoned(q))
335	return -ENOTTY;
336
337	if (!capable(CAP_SYS_ADMIN))
338	return -EACCES;
339
340	if (!(mode & FMODE_WRITE))
341	return -EBADF;
342
343	if (copy_from_user(&zrange, argp, sizeof(struct blk_zone_range)))
344	return -EFAULT;
345
346	return blkdev_reset_zones(bdev, zrange.sector, zrange.nr_sectors,
347	GFP_KERNEL);
348	}