block: Implement support for zoned block devices (6a0cb1bc) · Commits · 戴 / test

block/Kconfig

+8 −0

Original line number	Diff line number	Diff line
		@@ -89,6 +89,14 @@ config BLK_DEV_INTEGRITY
		T10/SCSI Data Integrity Field or the T13/ATA External Path
		Protection. If in doubt, say N.

		config BLK_DEV_ZONED
		bool "Zoned block device support"
		---help---
		Block layer zoned block device support. This option enables
		support for ZAC/ZBC host-managed and host-aware zoned block devices.

		Say yes here if you have a ZAC or ZBC storage device.

		config BLK_DEV_THROTTLING
		bool "Block layer bio throttling support"
		depends on BLK_CGROUP=y

block/Makefile

+1 −0

Original line number	Diff line number	Diff line
		@@ -23,3 +23,4 @@ obj-$(CONFIG_BLOCK_COMPAT) += compat_ioctl.o
		obj-$(CONFIG_BLK_CMDLINE_PARSER) += cmdline-parser.o
		obj-$(CONFIG_BLK_DEV_INTEGRITY) += bio-integrity.o blk-integrity.o t10-pi.o
		obj-$(CONFIG_BLK_MQ_PCI) += blk-mq-pci.o
		obj-$(CONFIG_BLK_DEV_ZONED) += blk-zoned.o

block/blk-zoned.c

0 → 100644

+257 −0

Original line number	Diff line number	Diff line
		/*
		* 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_size(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 = 0;

		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->bi_bdev = 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;

		}

		out:
		bio_for_each_segment_all(bv, bio, i)
		__free_page(bv->bv_page);
		bio_put(bio);

		if (ret == 0)
		*nr_zones = nz;

		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_size(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->bi_bdev = 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);

include/linux/blkdev.h

+31 −0

Original line number	Diff line number	Diff line
		@@ -24,6 +24,7 @@
		#include <linux/rcupdate.h>
		#include <linux/percpu-refcount.h>
		#include <linux/scatterlist.h>
		#include <linux/blkzoned.h>

		struct module;
		struct scsi_ioctl_command;
		@@ -302,6 +303,21 @@ struct queue_limits {
		enum blk_zoned_model zoned;
		};

		#ifdef CONFIG_BLK_DEV_ZONED

		struct blk_zone_report_hdr {
		unsigned int nr_zones;
		u8 padding[60];
		};

		extern int blkdev_report_zones(struct block_device *bdev,
		sector_t sector, struct blk_zone *zones,
		unsigned int *nr_zones, gfp_t gfp_mask);
		extern int blkdev_reset_zones(struct block_device *bdev, sector_t sectors,
		sector_t nr_sectors, gfp_t gfp_mask);

		#endif /* CONFIG_BLK_DEV_ZONED */

		struct request_queue {
		/*
		* Together with queue_head for cacheline sharing
		@@ -654,6 +670,11 @@ static inline bool blk_queue_is_zoned(struct request_queue *q)
		}
		}

		static inline unsigned int blk_queue_zone_size(struct request_queue *q)
		{
		return blk_queue_is_zoned(q) ? q->limits.chunk_sectors : 0;
		}

		/*
		* We regard a request as sync, if either a read or a sync write
		*/
		@@ -1401,6 +1422,16 @@ static inline bool bdev_is_zoned(struct block_device *bdev)
		return false;
		}

		static inline unsigned int bdev_zone_size(struct block_device *bdev)
		{
		struct request_queue *q = bdev_get_queue(bdev);

		if (q)
		return blk_queue_zone_size(q);

		return 0;
		}

		static inline int queue_dma_alignment(struct request_queue *q)
		{
		return q ? q->dma_alignment : 511;

include/uapi/linux/Kbuild

+1 −0

Original line number	Diff line number	Diff line
		@@ -70,6 +70,7 @@ header-y += bfs_fs.h
		header-y += binfmts.h
		header-y += blkpg.h
		header-y += blktrace_api.h
		header-y += blkzoned.h
		header-y += bpf_common.h
		header-y += bpf_perf_event.h
		header-y += bpf.h

Admin message