Re: [PATCHv4 5/5] nvme: support for zoned namespaces

[Himanshu Madhani <himanshu.madhani@oracle.com>]

> On Jun 29, 2020, at 2:06 PM, Keith Busch <kbusch@kernel.org> wrote:
> 
> From: Keith Busch <keith.busch@wdc.com>
> 
> Add support for NVM Express Zoned Namespaces (ZNS) Command Set defined
> in NVM Express TP4053. Zoned namespaces are discovered based on their
> Command Set Identifier reported in the namespaces Namespace
> Identification Descriptor list. A successfully discovered Zoned
> Namespace will be registered with the block layer as a host managed
> zoned block device with Zone Append command support. A namespace that
> does not support append is not supported by the driver.
> 
> Reviewed-by: Martin K. Petersen <martin.petersen@oracle.com>
> Reviewed-by: Johannes Thumshirn <johannes.thumshirn@wdc.com>
> Reviewed-by: Hannes Reinecke <hare@suse.de>
> Reviewed-by: Sagi Grimberg <sagi@grimberg.me>
> Reviewed-by: Javier González <javier.gonz@samsung.com>
> Signed-off-by: Hans Holmberg <hans.holmberg@wdc.com>
> Signed-off-by: Dmitry Fomichev <dmitry.fomichev@wdc.com>
> Signed-off-by: Ajay Joshi <ajay.joshi@wdc.com>
> Signed-off-by: Aravind Ramesh <aravind.ramesh@wdc.com>
> Signed-off-by: Niklas Cassel <niklas.cassel@wdc.com>
> Signed-off-by: Matias Bjørling <matias.bjorling@wdc.com>
> Signed-off-by: Damien Le Moal <damien.lemoal@wdc.com>
> Signed-off-by: Keith Busch <keith.busch@wdc.com>
> ---
> block/Kconfig              |   5 +-
> drivers/nvme/host/Makefile |   1 +
> drivers/nvme/host/core.c   |  97 ++++++++++++--
> drivers/nvme/host/nvme.h   |  39 ++++++
> drivers/nvme/host/zns.c    | 253 +++++++++++++++++++++++++++++++++++++
> include/linux/nvme.h       | 111 ++++++++++++++++
> 6 files changed, 491 insertions(+), 15 deletions(-)
> create mode 100644 drivers/nvme/host/zns.c
> 
> diff --git a/block/Kconfig b/block/Kconfig
> index 9357d7302398..bbad5e8bbffe 100644
> --- a/block/Kconfig
> +++ b/block/Kconfig
> @@ -86,9 +86,10 @@ config BLK_DEV_ZONED
> 	select MQ_IOSCHED_DEADLINE
> 	help
> 	Block layer zoned block device support. This option enables
> -	support for ZAC/ZBC host-managed and host-aware zoned block devices.
> +	support for ZAC/ZBC/ZNS host-managed and host-aware zoned block
> +	devices.
> 
> -	Say yes here if you have a ZAC or ZBC storage device.
> +	Say yes here if you have a ZAC, ZBC, or ZNS storage device.
> 
> config BLK_DEV_THROTTLING
> 	bool "Block layer bio throttling support"
> diff --git a/drivers/nvme/host/Makefile b/drivers/nvme/host/Makefile
> index fc7b26be692d..d7f6a87687b8 100644
> --- a/drivers/nvme/host/Makefile
> +++ b/drivers/nvme/host/Makefile
> @@ -13,6 +13,7 @@ nvme-core-y				:= core.o
> nvme-core-$(CONFIG_TRACING)		+= trace.o
> nvme-core-$(CONFIG_NVME_MULTIPATH)	+= multipath.o
> nvme-core-$(CONFIG_NVM)			+= lightnvm.o
> +nvme-core-$(CONFIG_BLK_DEV_ZONED)	+= zns.o
> nvme-core-$(CONFIG_FAULT_INJECTION_DEBUG_FS)	+= fault_inject.o
> nvme-core-$(CONFIG_NVME_HWMON)		+= hwmon.o
> 
> diff --git a/drivers/nvme/host/core.c b/drivers/nvme/host/core.c
> index a4a61d7e793d..02b4273a0b10 100644
> --- a/drivers/nvme/host/core.c
> +++ b/drivers/nvme/host/core.c
> @@ -89,7 +89,7 @@ static dev_t nvme_chr_devt;
> static struct class *nvme_class;
> static struct class *nvme_subsys_class;
> 
> -static int nvme_revalidate_disk(struct gendisk *disk);
> +static int _nvme_revalidate_disk(struct gendisk *disk);
> static void nvme_put_subsystem(struct nvme_subsystem *subsys);
> static void nvme_remove_invalid_namespaces(struct nvme_ctrl *ctrl,
> 					   unsigned nsid);
> @@ -287,6 +287,10 @@ void nvme_complete_rq(struct request *req)
> 			nvme_retry_req(req);
> 			return;
> 		}
> +	} else if (IS_ENABLED(CONFIG_BLK_DEV_ZONED) &&
> +		   req_op(req) == REQ_OP_ZONE_APPEND) {
> +		req->__sector = nvme_lba_to_sect(req->q->queuedata,
> +			le64_to_cpu(nvme_req(req)->result.u64));
> 	}
> 
> 	nvme_trace_bio_complete(req, status);
> @@ -673,7 +677,8 @@ static inline blk_status_t nvme_setup_write_zeroes(struct nvme_ns *ns,
> }
> 
> static inline blk_status_t nvme_setup_rw(struct nvme_ns *ns,
> -		struct request *req, struct nvme_command *cmnd)
> +		struct request *req, struct nvme_command *cmnd,
> +		enum nvme_opcode op)
> {
> 	struct nvme_ctrl *ctrl = ns->ctrl;
> 	u16 control = 0;
> @@ -687,7 +692,7 @@ static inline blk_status_t nvme_setup_rw(struct nvme_ns *ns,
> 	if (req->cmd_flags & REQ_RAHEAD)
> 		dsmgmt |= NVME_RW_DSM_FREQ_PREFETCH;
> 
> -	cmnd->rw.opcode = (rq_data_dir(req) ? nvme_cmd_write : nvme_cmd_read);
> +	cmnd->rw.opcode = op;
> 	cmnd->rw.nsid = cpu_to_le32(ns->head->ns_id);
> 	cmnd->rw.slba = cpu_to_le64(nvme_sect_to_lba(ns, blk_rq_pos(req)));
> 	cmnd->rw.length = cpu_to_le16((blk_rq_bytes(req) >> ns->lba_shift) - 1);
> @@ -716,6 +721,8 @@ static inline blk_status_t nvme_setup_rw(struct nvme_ns *ns,
> 		case NVME_NS_DPS_PI_TYPE2:
> 			control |= NVME_RW_PRINFO_PRCHK_GUARD |
> 					NVME_RW_PRINFO_PRCHK_REF;
> +			if (op == nvme_cmd_zone_append)
> +				control |= NVME_RW_APPEND_PIREMAP;
> 			cmnd->rw.reftag = cpu_to_le32(t10_pi_ref_tag(req));
> 			break;
> 		}
> @@ -756,6 +763,19 @@ blk_status_t nvme_setup_cmd(struct nvme_ns *ns, struct request *req,
> 	case REQ_OP_FLUSH:
> 		nvme_setup_flush(ns, cmd);
> 		break;
> +	case REQ_OP_ZONE_RESET_ALL:
> +	case REQ_OP_ZONE_RESET:
> +		ret = nvme_setup_zone_mgmt_send(ns, req, cmd, NVME_ZONE_RESET);
> +		break;
> +	case REQ_OP_ZONE_OPEN:
> +		ret = nvme_setup_zone_mgmt_send(ns, req, cmd, NVME_ZONE_OPEN);
> +		break;
> +	case REQ_OP_ZONE_CLOSE:
> +		ret = nvme_setup_zone_mgmt_send(ns, req, cmd, NVME_ZONE_CLOSE);
> +		break;
> +	case REQ_OP_ZONE_FINISH:
> +		ret = nvme_setup_zone_mgmt_send(ns, req, cmd, NVME_ZONE_FINISH);
> +		break;
> 	case REQ_OP_WRITE_ZEROES:
> 		ret = nvme_setup_write_zeroes(ns, req, cmd);
> 		break;
> @@ -763,8 +783,13 @@ blk_status_t nvme_setup_cmd(struct nvme_ns *ns, struct request *req,
> 		ret = nvme_setup_discard(ns, req, cmd);
> 		break;
> 	case REQ_OP_READ:
> +		ret = nvme_setup_rw(ns, req, cmd, nvme_cmd_read);
> +		break;
> 	case REQ_OP_WRITE:
> -		ret = nvme_setup_rw(ns, req, cmd);
> +		ret = nvme_setup_rw(ns, req, cmd, nvme_cmd_write);
> +		break;
> +	case REQ_OP_ZONE_APPEND:
> +		ret = nvme_setup_rw(ns, req, cmd, nvme_cmd_zone_append);
> 		break;
> 	default:
> 		WARN_ON_ONCE(1);
> @@ -1398,14 +1423,23 @@ static u32 nvme_passthru_start(struct nvme_ctrl *ctrl, struct nvme_ns *ns,
> 	return effects;
> }
> 
> -static void nvme_update_formats(struct nvme_ctrl *ctrl)
> +static void nvme_update_formats(struct nvme_ctrl *ctrl, u32 *effects)
> {
> 	struct nvme_ns *ns;
> 
> 	down_read(&ctrl->namespaces_rwsem);
> 	list_for_each_entry(ns, &ctrl->namespaces, list)
> -		if (ns->disk && nvme_revalidate_disk(ns->disk))
> +		if (ns->disk && _nvme_revalidate_disk(ns->disk))
> 			nvme_set_queue_dying(ns);
> +		else if (blk_queue_is_zoned(ns->disk->queue)) {
> +			/*
> +			 * IO commands are required to fully revalidate a zoned
> +			 * device. Force the command effects to trigger rescan
> +			 * work so report zones can run in a context with
> +			 * unfrozen IO queues.
> +			 */
> +			*effects |= NVME_CMD_EFFECTS_NCC;
> +		}
> 	up_read(&ctrl->namespaces_rwsem);
> }
> 
> @@ -1417,7 +1451,7 @@ static void nvme_passthru_end(struct nvme_ctrl *ctrl, u32 effects)
> 	 * this command.
> 	 */
> 	if (effects & NVME_CMD_EFFECTS_LBCC)
> -		nvme_update_formats(ctrl);
> +		nvme_update_formats(ctrl, &effects);
> 	if (effects & (NVME_CMD_EFFECTS_LBCC | NVME_CMD_EFFECTS_CSE_MASK)) {
> 		nvme_unfreeze(ctrl);
> 		nvme_mpath_unfreeze(ctrl->subsys);
> @@ -1532,7 +1566,7 @@ static int nvme_user_cmd64(struct nvme_ctrl *ctrl, struct nvme_ns *ns,
>  * Issue ioctl requests on the first available path.  Note that unlike normal
>  * block layer requests we will not retry failed request on another controller.
>  */
> -static struct nvme_ns *nvme_get_ns_from_disk(struct gendisk *disk,
> +struct nvme_ns *nvme_get_ns_from_disk(struct gendisk *disk,
> 		struct nvme_ns_head **head, int *srcu_idx)
> {
> #ifdef CONFIG_NVME_MULTIPATH
> @@ -1552,7 +1586,7 @@ static struct nvme_ns *nvme_get_ns_from_disk(struct gendisk *disk,
> 	return disk->private_data;
> }
> 
> -static void nvme_put_ns_from_disk(struct nvme_ns_head *head, int idx)
> +void nvme_put_ns_from_disk(struct nvme_ns_head *head, int idx)
> {
> 	if (head)
> 		srcu_read_unlock(&head->srcu, idx);
> @@ -1945,23 +1979,34 @@ static void nvme_update_disk_info(struct gendisk *disk,
> 
> static int __nvme_revalidate_disk(struct gendisk *disk, struct nvme_id_ns *id)
> {
> +	unsigned lbaf = id->flbas & NVME_NS_FLBAS_LBA_MASK;
> 	struct nvme_ns *ns = disk->private_data;
> 	struct nvme_ctrl *ctrl = ns->ctrl;
> +	int ret;
> 	u32 iob;
> 
> 	/*
> 	 * If identify namespace failed, use default 512 byte block size so
> 	 * block layer can use before failing read/write for 0 capacity.
> 	 */
> -	ns->lba_shift = id->lbaf[id->flbas & NVME_NS_FLBAS_LBA_MASK].ds;
> +	ns->lba_shift = id->lbaf[lbaf].ds;
> 	if (ns->lba_shift == 0)
> 		ns->lba_shift = 9;
> 
> 	switch (ns->head->ids.csi) {
> 	case NVME_CSI_NVM:
> 		break;
> +	case NVME_CSI_ZNS:
> +		ret = nvme_update_zone_info(disk, ns, lbaf);
> +		if (ret) {
> +			dev_warn(ctrl->device,
> +				"failed to add zoned namespace:%u ret:%d\n",
> +				ns->head->ns_id, ret);
> +			return ret;
> +		}
> +		break;
> 	default:
> -		dev_warn(ctrl->device, "unknown csi:%d ns:%d\n",
> +		dev_warn(ctrl->device, "unknown csi:%u ns:%u\n",
> 			ns->head->ids.csi, ns->head->ns_id);
> 		return -ENODEV;
> 	}
> @@ -1973,7 +2018,7 @@ static int __nvme_revalidate_disk(struct gendisk *disk, struct nvme_id_ns *id)
> 		iob = nvme_lba_to_sect(ns, le16_to_cpu(id->noiob));
> 
> 	ns->features = 0;
> -	ns->ms = le16_to_cpu(id->lbaf[id->flbas & NVME_NS_FLBAS_LBA_MASK].ms);
> +	ns->ms = le16_to_cpu(id->lbaf[lbaf].ms);
> 	/* the PI implementation requires metadata equal t10 pi tuple size */
> 	if (ns->ms == sizeof(struct t10_pi_tuple))
> 		ns->pi_type = id->dps & NVME_NS_DPS_PI_MASK;
> @@ -2015,7 +2060,7 @@ static int __nvme_revalidate_disk(struct gendisk *disk, struct nvme_id_ns *id)
> 	return 0;
> }
> 
> -static int nvme_revalidate_disk(struct gendisk *disk)
> +static int _nvme_revalidate_disk(struct gendisk *disk)
> {
> 	struct nvme_ns *ns = disk->private_data;
> 	struct nvme_ctrl *ctrl = ns->ctrl;
> @@ -2063,6 +2108,28 @@ static int nvme_revalidate_disk(struct gendisk *disk)
> 	return ret;
> }
> 
> +static int nvme_revalidate_disk(struct gendisk *disk)
> +{
> +	int ret;
> +
> +	ret = _nvme_revalidate_disk(disk);
> +	if (ret)
> +		return ret;
> +
> +#ifdef CONFIG_BLK_DEV_ZONED
> +	if (blk_queue_is_zoned(disk->queue)) {
> +		struct nvme_ns *ns = disk->private_data;
> +		struct nvme_ctrl *ctrl = ns->ctrl;
> +
> +		ret = blk_revalidate_disk_zones(disk, NULL);
> +		if (!ret)
> +			blk_queue_max_zone_append_sectors(disk->queue,
> +							  ctrl->max_zone_append);
> +	}
> +#endif
> +	return ret;
> +}
> +
> static char nvme_pr_type(enum pr_type type)
> {
> 	switch (type) {
> @@ -2193,6 +2260,7 @@ static const struct block_device_operations nvme_fops = {
> 	.release	= nvme_release,
> 	.getgeo		= nvme_getgeo,
> 	.revalidate_disk= nvme_revalidate_disk,
> +	.report_zones	= nvme_report_zones,
> 	.pr_ops		= &nvme_pr_ops,
> };
> 
> @@ -2218,6 +2286,7 @@ const struct block_device_operations nvme_ns_head_ops = {
> 	.ioctl		= nvme_ioctl,
> 	.compat_ioctl	= nvme_compat_ioctl,
> 	.getgeo		= nvme_getgeo,
> +	.report_zones	= nvme_report_zones,
> 	.pr_ops		= &nvme_pr_ops,
> };
> #endif /* CONFIG_NVME_MULTIPATH */
> @@ -4445,6 +4514,8 @@ static inline void _nvme_check_size(void)
> 	BUILD_BUG_ON(sizeof(struct nvme_command) != 64);
> 	BUILD_BUG_ON(sizeof(struct nvme_id_ctrl) != NVME_IDENTIFY_DATA_SIZE);
> 	BUILD_BUG_ON(sizeof(struct nvme_id_ns) != NVME_IDENTIFY_DATA_SIZE);
> +	BUILD_BUG_ON(sizeof(struct nvme_id_ns_zns) != NVME_IDENTIFY_DATA_SIZE);
> +	BUILD_BUG_ON(sizeof(struct nvme_id_ctrl_zns) != NVME_IDENTIFY_DATA_SIZE);
> 	BUILD_BUG_ON(sizeof(struct nvme_lba_range_type) != 64);
> 	BUILD_BUG_ON(sizeof(struct nvme_smart_log) != 512);
> 	BUILD_BUG_ON(sizeof(struct nvme_dbbuf) != 64);
> diff --git a/drivers/nvme/host/nvme.h b/drivers/nvme/host/nvme.h
> index dd24a94c42ff..ed10bfff91e1 100644
> --- a/drivers/nvme/host/nvme.h
> +++ b/drivers/nvme/host/nvme.h
> @@ -238,6 +238,9 @@ struct nvme_ctrl {
> 	u32 max_hw_sectors;
> 	u32 max_segments;
> 	u32 max_integrity_segments;
> +#ifdef CONFIG_BLK_DEV_ZONED
> +	u32 max_zone_append;
> +#endif
> 	u16 crdt[3];
> 	u16 oncs;
> 	u16 oacs;
> @@ -404,6 +407,9 @@ struct nvme_ns {
> 	u16 sgs;
> 	u32 sws;
> 	u8 pi_type;
> +#ifdef CONFIG_BLK_DEV_ZONED
> +	u64 zsze;
> +#endif
> 	unsigned long features;
> 	unsigned long flags;
> #define NVME_NS_REMOVING	0
> @@ -571,6 +577,9 @@ int nvme_delete_ctrl(struct nvme_ctrl *ctrl);
> 
> int nvme_get_log(struct nvme_ctrl *ctrl, u32 nsid, u8 log_page, u8 lsp, u8 csi,
> 		void *log, size_t size, u64 offset);
> +struct nvme_ns *nvme_get_ns_from_disk(struct gendisk *disk,
> +		struct nvme_ns_head **head, int *srcu_idx);
> +void nvme_put_ns_from_disk(struct nvme_ns_head *head, int idx);
> 
> extern const struct attribute_group *nvme_ns_id_attr_groups[];
> extern const struct block_device_operations nvme_ns_head_ops;
> @@ -692,6 +701,36 @@ static inline void nvme_mpath_start_freeze(struct nvme_subsystem *subsys)
> }
> #endif /* CONFIG_NVME_MULTIPATH */
> 
> +#ifdef CONFIG_BLK_DEV_ZONED
> +int nvme_update_zone_info(struct gendisk *disk, struct nvme_ns *ns,
> +			  unsigned lbaf);
> +
> +int nvme_report_zones(struct gendisk *disk, sector_t sector,
> +		      unsigned int nr_zones, report_zones_cb cb, void *data);
> +
> +blk_status_t nvme_setup_zone_mgmt_send(struct nvme_ns *ns, struct request *req,
> +				       struct nvme_command *cmnd,
> +				       enum nvme_zone_mgmt_action action);
> +#else
> +#define nvme_report_zones NULL
> +
> +static inline blk_status_t nvme_setup_zone_mgmt_send(struct nvme_ns *ns,
> +		struct request *req, struct nvme_command *cmnd,
> +		enum nvme_zone_mgmt_action action)
> +{
> +	return BLK_STS_NOTSUPP;
> +}
> +
> +static inline int nvme_update_zone_info(struct gendisk *disk,
> +					struct nvme_ns *ns,
> +					unsigned lbaf)
> +{
> +	dev_warn(ns->ctrl->device,
> +		 "Please enable CONFIG_BLK_DEV_ZONED to support ZNS devices\n");
> +	return -EPROTONOSUPPORT;
> +}
> +#endif
> +
> #ifdef CONFIG_NVM
> int nvme_nvm_register(struct nvme_ns *ns, char *disk_name, int node);
> void nvme_nvm_unregister(struct nvme_ns *ns);
> diff --git a/drivers/nvme/host/zns.c b/drivers/nvme/host/zns.c
> new file mode 100644
> index 000000000000..c033c60ce751
> --- /dev/null
> +++ b/drivers/nvme/host/zns.c
> @@ -0,0 +1,253 @@
> +// SPDX-License-Identifier: GPL-2.0
> +/*
> + * Copyright (C) 2020 Western Digital Corporation or its affiliates.
> + */
> +
> +#include <linux/blkdev.h>
> +#include <linux/vmalloc.h>
> +#include "nvme.h"
> +
> +static int nvme_set_max_append(struct nvme_ctrl *ctrl)
> +{
> +	struct nvme_command c = { };
> +	struct nvme_id_ctrl_zns *id;
> +	int status;
> +
> +	id = kzalloc(sizeof(*id), GFP_KERNEL);
> +	if (!id)
> +		return -ENOMEM;
> +
> +	c.identify.opcode = nvme_admin_identify;
> +	c.identify.cns = NVME_ID_CNS_CS_CTRL;
> +	c.identify.csi = NVME_CSI_ZNS;
> +
> +	status = nvme_submit_sync_cmd(ctrl->admin_q, &c, id, sizeof(*id));
> +	if (status) {
> +		kfree(id);
> +		return status;
> +	}
> +
> +	if (id->zasl)
> +		ctrl->max_zone_append = 1 << (id->zasl + 3);
> +	else
> +		ctrl->max_zone_append = ctrl->max_hw_sectors;
> +	kfree(id);
> +	return 0;
> +}
> +
> +int nvme_update_zone_info(struct gendisk *disk, struct nvme_ns *ns,
> +			  unsigned lbaf)
> +{
> +	struct nvme_effects_log *log = ns->head->effects;
> +	struct request_queue *q = disk->queue;
> +	struct nvme_command c = { };
> +	struct nvme_id_ns_zns *id;
> +	int status;
> +
> +	/* Driver requires zone append support */
> +	if (!(log->iocs[nvme_cmd_zone_append] & NVME_CMD_EFFECTS_CSUPP)) {
> +		dev_warn(ns->ctrl->device,
> +			"append not supported for zoned namespace:%d\n",
> +			ns->head->ns_id);
> +		return -EINVAL;
> +	}
> +
> +	/* Lazily query controller append limit for the first zoned namespace */
> +	if (!ns->ctrl->max_zone_append) {
> +		status = nvme_set_max_append(ns->ctrl);
> +		if (status)
> +			return status;
> +	}
> +
> +	id = kzalloc(sizeof(*id), GFP_KERNEL);
> +	if (!id)
> +		return -ENOMEM;
> +
> +	c.identify.opcode = nvme_admin_identify;
> +	c.identify.nsid = cpu_to_le32(ns->head->ns_id);
> +	c.identify.cns = NVME_ID_CNS_CS_NS;
> +	c.identify.csi = NVME_CSI_ZNS;
> +
> +	status = nvme_submit_sync_cmd(ns->ctrl->admin_q, &c, id, sizeof(*id));
> +	if (status)
> +		goto free_data;
> +
> +	/*
> +	 * We currently do not handle devices requiring any of the zoned
> +	 * operation characteristics.
> +	 */
> +	if (id->zoc) {
> +		dev_warn(ns->ctrl->device,
> +			"zone operations:%x not supported for namespace:%u\n",
> +			le16_to_cpu(id->zoc), ns->head->ns_id);
> +		status = -EINVAL;
> +		goto free_data;
> +	}
> +
> +	ns->zsze = nvme_lba_to_sect(ns, le64_to_cpu(id->lbafe[lbaf].zsze));
> +	if (!is_power_of_2(ns->zsze)) {
> +		dev_warn(ns->ctrl->device,
> +			"invalid zone size:%llu for namespace:%u\n",
> +			ns->zsze, ns->head->ns_id);
> +		status = -EINVAL;
> +		goto free_data;
> +	}
> +
> +	q->limits.zoned = BLK_ZONED_HM;
> +	blk_queue_flag_set(QUEUE_FLAG_ZONE_RESETALL, q);
> +free_data:
> +	kfree(id);
> +	return status;
> +}
> +
> +static void *nvme_zns_alloc_report_buffer(struct nvme_ns *ns,
> +					  unsigned int nr_zones, size_t *buflen)
> +{
> +	struct request_queue *q = ns->disk->queue;
> +	size_t bufsize;
> +	void *buf;
> +
> +	const size_t min_bufsize = sizeof(struct nvme_zone_report) +
> +				   sizeof(struct nvme_zone_descriptor);
> +
> +	nr_zones = min_t(unsigned int, nr_zones,
> +			 get_capacity(ns->disk) >> ilog2(ns->zsze));
> +
> +	bufsize = sizeof(struct nvme_zone_report) +
> +		nr_zones * sizeof(struct nvme_zone_descriptor);
> +	bufsize = min_t(size_t, bufsize,
> +			queue_max_hw_sectors(q) << SECTOR_SHIFT);
> +	bufsize = min_t(size_t, bufsize, queue_max_segments(q) << PAGE_SHIFT);
> +
> +	while (bufsize >= min_bufsize) {
> +		buf = __vmalloc(bufsize, GFP_KERNEL | __GFP_NORETRY);
> +		if (buf) {
> +			*buflen = bufsize;
> +			return buf;
> +		}
> +		bufsize >>= 1;
> +	}
> +	return NULL;
> +}
> +
> +static int __nvme_ns_report_zones(struct nvme_ns *ns, sector_t sector,
> +				  struct nvme_zone_report *report,
> +				  size_t buflen)
> +{
> +	struct nvme_command c = { };
> +	int ret;
> +
> +	c.zmr.opcode = nvme_cmd_zone_mgmt_recv;
> +	c.zmr.nsid = cpu_to_le32(ns->head->ns_id);
> +	c.zmr.slba = cpu_to_le64(nvme_sect_to_lba(ns, sector));
> +	c.zmr.numd = cpu_to_le32(nvme_bytes_to_numd(buflen));
> +	c.zmr.zra = NVME_ZRA_ZONE_REPORT;
> +	c.zmr.zrasf = NVME_ZRASF_ZONE_REPORT_ALL;
> +	c.zmr.pr = NVME_REPORT_ZONE_PARTIAL;
> +
> +	ret = nvme_submit_sync_cmd(ns->queue, &c, report, buflen);
> +	if (ret)
> +		return ret;
> +
> +	return le64_to_cpu(report->nr_zones);
> +}
> +
> +static int nvme_zone_parse_entry(struct nvme_ns *ns,
> +				 struct nvme_zone_descriptor *entry,
> +				 unsigned int idx, report_zones_cb cb,
> +				 void *data)
> +{
> +	struct blk_zone zone = { };
> +
> +	if ((entry->zt & 0xf) != NVME_ZONE_TYPE_SEQWRITE_REQ) {
> +		dev_err(ns->ctrl->device, "invalid zone type %#x\n",
> +				entry->zt);
> +		return -EINVAL;
> +	}
> +
> +	zone.type = BLK_ZONE_TYPE_SEQWRITE_REQ;
> +	zone.cond = entry->zs >> 4;
> +	zone.len = ns->zsze;
> +	zone.capacity = nvme_lba_to_sect(ns, le64_to_cpu(entry->zcap));
> +	zone.start = nvme_lba_to_sect(ns, le64_to_cpu(entry->zslba));
> +	zone.wp = nvme_lba_to_sect(ns, le64_to_cpu(entry->wp));
> +
> +	return cb(&zone, idx, data);
> +}
> +
> +static int nvme_ns_report_zones(struct nvme_ns *ns, sector_t sector,
> +			unsigned int nr_zones, report_zones_cb cb, void *data)
> +{
> +	struct nvme_zone_report *report;
> +	int ret, zone_idx = 0;
> +	unsigned int nz, i;
> +	size_t buflen;
> +
> +	report = nvme_zns_alloc_report_buffer(ns, nr_zones, &buflen);
> +	if (!report)
> +		return -ENOMEM;
> +
> +	sector &= ~(ns->zsze - 1);
> +	while (zone_idx < nr_zones && sector < get_capacity(ns->disk)) {
> +		memset(report, 0, buflen);
> +		ret = __nvme_ns_report_zones(ns, sector, report, buflen);
> +		if (ret < 0)
> +			goto out_free;
> +
> +		nz = min_t(unsigned int, ret, nr_zones);
> +		if (!nz)
> +			break;
> +
> +		for (i = 0; i < nz && zone_idx < nr_zones; i++) {
> +			ret = nvme_zone_parse_entry(ns, &report->entries[i],
> +						    zone_idx, cb, data);
> +			if (ret)
> +				goto out_free;
> +			zone_idx++;
> +		}
> +
> +		sector += ns->zsze * nz;
> +	}
> +
> +	if (zone_idx > 0)
> +		ret = zone_idx;
> +	else
> +		ret = -EINVAL;
> +out_free:
> +	kvfree(report);
> +	return ret;
> +}
> +
> +int nvme_report_zones(struct gendisk *disk, sector_t sector,
> +		      unsigned int nr_zones, report_zones_cb cb, void *data)
> +{
> +	struct nvme_ns_head *head = NULL;
> +	struct nvme_ns *ns;
> +	int srcu_idx, ret;
> +
> +	ns = nvme_get_ns_from_disk(disk, &head, &srcu_idx);
> +	if (unlikely(!ns))
> +		return -EWOULDBLOCK;
> +
> +	if (ns->head->ids.csi == NVME_CSI_ZNS)
> +		ret = nvme_ns_report_zones(ns, sector, nr_zones, cb, data);
> +	else
> +		ret = -EINVAL;
> +	nvme_put_ns_from_disk(head, srcu_idx);
> +
> +	return ret;
> +}
> +
> +blk_status_t nvme_setup_zone_mgmt_send(struct nvme_ns *ns, struct request *req,
> +		struct nvme_command *c, enum nvme_zone_mgmt_action action)
> +{
> +	c->zms.opcode = nvme_cmd_zone_mgmt_send;
> +	c->zms.nsid = cpu_to_le32(ns->head->ns_id);
> +	c->zms.slba = cpu_to_le64(nvme_sect_to_lba(ns, blk_rq_pos(req)));
> +	c->zms.zsa = action;
> +
> +	if (req_op(req) == REQ_OP_ZONE_RESET_ALL)
> +		c->zms.select_all = 1;
> +
> +	return BLK_STS_OK;
> +}
> diff --git a/include/linux/nvme.h b/include/linux/nvme.h
> index 95cd03e240a1..1643005d21e3 100644
> --- a/include/linux/nvme.h
> +++ b/include/linux/nvme.h
> @@ -374,6 +374,30 @@ struct nvme_id_ns {
> 	__u8			vs[3712];
> };
> 
> +struct nvme_zns_lbafe {
> +	__le64			zsze;
> +	__u8			zdes;
> +	__u8			rsvd9[7];
> +};
> +
> +struct nvme_id_ns_zns {
> +	__le16			zoc;
> +	__le16			ozcs;
> +	__le32			mar;
> +	__le32			mor;
> +	__le32			rrl;
> +	__le32			frl;
> +	__u8			rsvd20[2796];
> +	struct nvme_zns_lbafe	lbafe[16];
> +	__u8			rsvd3072[768];
> +	__u8			vs[256];
> +};
> +
> +struct nvme_id_ctrl_zns {
> +	__u8	zasl;
> +	__u8	rsvd1[4095];
> +};
> +
> enum {
> 	NVME_ID_CNS_NS			= 0x00,
> 	NVME_ID_CNS_CTRL		= 0x01,
> @@ -392,6 +416,7 @@ enum {
> 
> enum {
> 	NVME_CSI_NVM			= 0,
> +	NVME_CSI_ZNS			= 2,
> };
> 
> enum {
> @@ -532,6 +557,27 @@ struct nvme_ana_rsp_hdr {
> 	__le16	rsvd10[3];
> };
> 
> +struct nvme_zone_descriptor {
> +	__u8		zt;
> +	__u8		zs;
> +	__u8		za;
> +	__u8		rsvd3[5];
> +	__le64		zcap;
> +	__le64		zslba;
> +	__le64		wp;
> +	__u8		rsvd32[32];
> +};
> +
> +enum {
> +	NVME_ZONE_TYPE_SEQWRITE_REQ	= 0x2,
> +};
> +
> +struct nvme_zone_report {
> +	__le64		nr_zones;
> +	__u8		resv8[56];
> +	struct nvme_zone_descriptor entries[];
> +};
> +
> enum {
> 	NVME_SMART_CRIT_SPARE		= 1 << 0,
> 	NVME_SMART_CRIT_TEMPERATURE	= 1 << 1,
> @@ -626,6 +672,9 @@ enum nvme_opcode {
> 	nvme_cmd_resv_report	= 0x0e,
> 	nvme_cmd_resv_acquire	= 0x11,
> 	nvme_cmd_resv_release	= 0x15,
> +	nvme_cmd_zone_mgmt_send	= 0x79,
> +	nvme_cmd_zone_mgmt_recv	= 0x7a,
> +	nvme_cmd_zone_append	= 0x7d,
> };
> 
> #define nvme_opcode_name(opcode)	{ opcode, #opcode }
> @@ -764,6 +813,7 @@ struct nvme_rw_command {
> enum {
> 	NVME_RW_LR			= 1 << 15,
> 	NVME_RW_FUA			= 1 << 14,
> +	NVME_RW_APPEND_PIREMAP		= 1 << 9,
> 	NVME_RW_DSM_FREQ_UNSPEC		= 0,
> 	NVME_RW_DSM_FREQ_TYPICAL	= 1,
> 	NVME_RW_DSM_FREQ_RARE		= 2,
> @@ -829,6 +879,53 @@ struct nvme_write_zeroes_cmd {
> 	__le16			appmask;
> };
> 
> +enum nvme_zone_mgmt_action {
> +	NVME_ZONE_CLOSE		= 0x1,
> +	NVME_ZONE_FINISH	= 0x2,
> +	NVME_ZONE_OPEN		= 0x3,
> +	NVME_ZONE_RESET		= 0x4,
> +	NVME_ZONE_OFFLINE	= 0x5,
> +	NVME_ZONE_SET_DESC_EXT	= 0x10,
> +};
> +
> +struct nvme_zone_mgmt_send_cmd {
> +	__u8			opcode;
> +	__u8			flags;
> +	__u16			command_id;
> +	__le32			nsid;
> +	__le32			cdw2[2];
> +	__le64			metadata;
> +	union nvme_data_ptr	dptr;
> +	__le64			slba;
> +	__le32			cdw12;
> +	__u8			zsa;
> +	__u8			select_all;
> +	__u8			rsvd13[2];
> +	__le32			cdw14[2];
> +};
> +
> +struct nvme_zone_mgmt_recv_cmd {
> +	__u8			opcode;
> +	__u8			flags;
> +	__u16			command_id;
> +	__le32			nsid;
> +	__le64			rsvd2[2];
> +	union nvme_data_ptr	dptr;
> +	__le64			slba;
> +	__le32			numd;
> +	__u8			zra;
> +	__u8			zrasf;
> +	__u8			pr;
> +	__u8			rsvd13;
> +	__le32			cdw14[2];
> +};
> +
> +enum {
> +	NVME_ZRA_ZONE_REPORT		= 0,
> +	NVME_ZRASF_ZONE_REPORT_ALL	= 0,
> +	NVME_REPORT_ZONE_PARTIAL	= 1,
> +};
> +
> /* Features */
> 
> enum {
> @@ -1300,6 +1397,8 @@ struct nvme_command {
> 		struct nvme_format_cmd format;
> 		struct nvme_dsm_cmd dsm;
> 		struct nvme_write_zeroes_cmd write_zeroes;
> +		struct nvme_zone_mgmt_send_cmd zms;
> +		struct nvme_zone_mgmt_recv_cmd zmr;
> 		struct nvme_abort_cmd abort;
> 		struct nvme_get_log_page_command get_log_page;
> 		struct nvmf_common_command fabrics;
> @@ -1433,6 +1532,18 @@ enum {
> 	NVME_SC_DISCOVERY_RESTART	= 0x190,
> 	NVME_SC_AUTH_REQUIRED		= 0x191,
> 
> +	/*
> +	 * I/O Command Set Specific - Zoned commands:
> +	 */
> +	NVME_SC_ZONE_BOUNDARY_ERROR	= 0x1b8,
> +	NVME_SC_ZONE_FULL		= 0x1b9,
> +	NVME_SC_ZONE_READ_ONLY		= 0x1ba,
> +	NVME_SC_ZONE_OFFLINE		= 0x1bb,
> +	NVME_SC_ZONE_INVALID_WRITE	= 0x1bc,
> +	NVME_SC_ZONE_TOO_MANY_ACTIVE	= 0x1bd,
> +	NVME_SC_ZONE_TOO_MANY_OPEN	= 0x1be,
> +	NVME_SC_ZONE_INVALID_TRANSITION	= 0x1bf,
> +
> 	/*
> 	 * Media and Data Integrity Errors:
> 	 */
> -- 
> 2.24.1
> 

Reviewed-by: Himanshu Madhani <himanshu.madhani@oracle.com>

--
Himanshu Madhani	Oracle Linux Engineering






_______________________________________________
Linux-nvme mailing list
Linux-nvme@lists.infradead.org
http://lists.infradead.org/mailman/listinfo/linux-nvme