[fio.git] / engines / nvme.c

/*
 * nvme structure declarations and helper functions for the
 * io_uring_cmd engine.
 */

#include "nvme.h"

int fio_nvme_uring_cmd_prep(struct nvme_uring_cmd *cmd, struct io_u *io_u,
			    struct iovec *iov)
{
	struct nvme_data *data = FILE_ENG_DATA(io_u->file);
	__u64 slba;
	__u32 nlb;

	memset(cmd, 0, sizeof(struct nvme_uring_cmd));

	if (io_u->ddir == DDIR_READ)
		cmd->opcode = nvme_cmd_read;
	else if (io_u->ddir == DDIR_WRITE)
		cmd->opcode = nvme_cmd_write;
	else
		return -ENOTSUP;

	if (data->lba_ext) {
		slba = io_u->offset / data->lba_ext;
		nlb = (io_u->xfer_buflen / data->lba_ext) - 1;
	} else {
		slba = io_u->offset >> data->lba_shift;
		nlb = (io_u->xfer_buflen >> data->lba_shift) - 1;
	}

	/* cdw10 and cdw11 represent starting lba */
	cmd->cdw10 = slba & 0xffffffff;
	cmd->cdw11 = slba >> 32;
	/* cdw12 represent number of lba's for read/write */
	cmd->cdw12 = nlb | (io_u->dtype << 20);
	cmd->cdw13 = io_u->dspec << 16;
	if (iov) {
		iov->iov_base = io_u->xfer_buf;
		iov->iov_len = io_u->xfer_buflen;
		cmd->addr = (__u64)(uintptr_t)iov;
		cmd->data_len = 1;
	} else {
		cmd->addr = (__u64)(uintptr_t)io_u->xfer_buf;
		cmd->data_len = io_u->xfer_buflen;
	}
	cmd->nsid = data->nsid;
	return 0;
}

static int nvme_trim(int fd, __u32 nsid, __u32 nr_range, __u32 data_len,
		     void *data)
{
	struct nvme_passthru_cmd cmd = {
		.opcode		= nvme_cmd_dsm,
		.nsid		= nsid,
		.addr		= (__u64)(uintptr_t)data,
		.data_len 	= data_len,
		.cdw10		= nr_range - 1,
		.cdw11		= NVME_ATTRIBUTE_DEALLOCATE,
	};

	return ioctl(fd, NVME_IOCTL_IO_CMD, &cmd);
}

int fio_nvme_trim(const struct thread_data *td, struct fio_file *f,
		  unsigned long long offset, unsigned long long len)
{
	struct nvme_data *data = FILE_ENG_DATA(f);
	struct nvme_dsm_range dsm;
	int ret;

	if (data->lba_ext) {
		dsm.nlb = len / data->lba_ext;
		dsm.slba = offset / data->lba_ext;
	} else {
		dsm.nlb = len >> data->lba_shift;
		dsm.slba = offset >> data->lba_shift;
	}

	ret = nvme_trim(f->fd, data->nsid, 1, sizeof(struct nvme_dsm_range),
			&dsm);
	if (ret)
		log_err("%s: nvme_trim failed for offset %llu and len %llu, err=%d\n",
			f->file_name, offset, len, ret);

	return ret;
}

static int nvme_identify(int fd, __u32 nsid, enum nvme_identify_cns cns,
			 enum nvme_csi csi, void *data)
{
	struct nvme_passthru_cmd cmd = {
		.opcode         = nvme_admin_identify,
		.nsid           = nsid,
		.addr           = (__u64)(uintptr_t)data,
		.data_len       = NVME_IDENTIFY_DATA_SIZE,
		.cdw10          = cns,
		.cdw11          = csi << NVME_IDENTIFY_CSI_SHIFT,
		.timeout_ms     = NVME_DEFAULT_IOCTL_TIMEOUT,
	};

	return ioctl(fd, NVME_IOCTL_ADMIN_CMD, &cmd);
}

int fio_nvme_get_info(struct fio_file *f, __u32 *nsid, __u32 *lba_sz,
		      __u32 *ms, __u64 *nlba)
{
	struct nvme_id_ns ns;
	int namespace_id;
	int fd, err;
	__u32 format_idx;

	if (f->filetype != FIO_TYPE_CHAR) {
		log_err("ioengine io_uring_cmd only works with nvme ns "
			"generic char devices (/dev/ngXnY)\n");
		return 1;
	}

	fd = open(f->file_name, O_RDONLY);
	if (fd < 0)
		return -errno;

	namespace_id = ioctl(fd, NVME_IOCTL_ID);
	if (namespace_id < 0) {
		err = -errno;
		log_err("%s: failed to fetch namespace-id\n", f->file_name);
		goto out;
	}

	/*
	 * Identify namespace to get namespace-id, namespace size in LBA's
	 * and LBA data size.
	 */
	err = nvme_identify(fd, namespace_id, NVME_IDENTIFY_CNS_NS,
				NVME_CSI_NVM, &ns);
	if (err) {
		log_err("%s: failed to fetch identify namespace\n",
			f->file_name);
		close(fd);
		return err;
	}

	*nsid = namespace_id;

	/*
	 * 16 or 64 as maximum number of supported LBA formats.
	 * From flbas bit 0-3 indicates lsb and bit 5-6 indicates msb
	 * of the format index used to format the namespace.
	 */
	if (ns.nlbaf < 16)
		format_idx = ns.flbas & 0xf;
	else
		format_idx = (ns.flbas & 0xf) + (((ns.flbas >> 5) & 0x3) << 4);

	*lba_sz = 1 << ns.lbaf[format_idx].ds;

	/*
	 * Only extended LBA can be supported.
	 * Bit 4 for flbas indicates if metadata is transferred at the end of
	 * logical block creating an extended LBA.
	 */
	*ms = le16_to_cpu(ns.lbaf[format_idx].ms);
	if (*ms && !((ns.flbas >> 4) & 0x1)) {
		log_err("%s: only extended logical block can be supported\n",
			f->file_name);
		err = -ENOTSUP;
		goto out;
	}

	/* Check for end to end data protection support */
	if (ns.dps & 0x3) {
		log_err("%s: end to end data protection not supported\n",
			f->file_name);
		err = -ENOTSUP;
		goto out;
	}
	*nlba = ns.nsze;

out:
	close(fd);
	return err;
}

int fio_nvme_get_zoned_model(struct thread_data *td, struct fio_file *f,
			     enum zbd_zoned_model *model)
{
	struct nvme_data *data = FILE_ENG_DATA(f);
	struct nvme_id_ns ns;
	struct nvme_passthru_cmd cmd;
	int fd, ret = 0;

	if (f->filetype != FIO_TYPE_CHAR)
		return -EINVAL;

	/* File is not yet opened */
	fd = open(f->file_name, O_RDONLY | O_LARGEFILE);
	if (fd < 0)
		return -errno;

	/* Using nvme_id_ns for data as sizes are same */
	ret = nvme_identify(fd, data->nsid, NVME_IDENTIFY_CNS_CSI_CTRL,
				NVME_CSI_ZNS, &ns);
	if (ret) {
		*model = ZBD_NONE;
		goto out;
	}

	memset(&cmd, 0, sizeof(struct nvme_passthru_cmd));

	/* Using nvme_id_ns for data as sizes are same */
	ret = nvme_identify(fd, data->nsid, NVME_IDENTIFY_CNS_CSI_NS,
				NVME_CSI_ZNS, &ns);
	if (ret) {
		*model = ZBD_NONE;
		goto out;
	}

	*model = ZBD_HOST_MANAGED;
out:
	close(fd);
	return 0;
}

static int nvme_report_zones(int fd, __u32 nsid, __u64 slba, __u32 zras_feat,
			     __u32 data_len, void *data)
{
	struct nvme_passthru_cmd cmd = {
		.opcode         = nvme_zns_cmd_mgmt_recv,
		.nsid           = nsid,
		.addr           = (__u64)(uintptr_t)data,
		.data_len       = data_len,
		.cdw10          = slba & 0xffffffff,
		.cdw11          = slba >> 32,
		.cdw12		= (data_len >> 2) - 1,
		.cdw13		= NVME_ZNS_ZRA_REPORT_ZONES | zras_feat,
		.timeout_ms     = NVME_DEFAULT_IOCTL_TIMEOUT,
	};

	return ioctl(fd, NVME_IOCTL_IO_CMD, &cmd);
}

int fio_nvme_report_zones(struct thread_data *td, struct fio_file *f,
			  uint64_t offset, struct zbd_zone *zbdz,
			  unsigned int nr_zones)
{
	struct nvme_data *data = FILE_ENG_DATA(f);
	struct nvme_zone_report *zr;
	struct nvme_zns_id_ns zns_ns;
	struct nvme_id_ns ns;
	unsigned int i = 0, j, zones_fetched = 0;
	unsigned int max_zones, zones_chunks = 1024;
	int fd, ret = 0;
	__u32 zr_len;
	__u64 zlen;

	/* File is not yet opened */
	fd = open(f->file_name, O_RDONLY | O_LARGEFILE);
	if (fd < 0)
		return -errno;

	zones_fetched = 0;
	zr_len = sizeof(*zr) + (zones_chunks * sizeof(struct nvme_zns_desc));
	zr = calloc(1, zr_len);
	if (!zr) {
		close(fd);
		return -ENOMEM;
	}

	ret = nvme_identify(fd, data->nsid, NVME_IDENTIFY_CNS_NS,
				NVME_CSI_NVM, &ns);
	if (ret) {
		log_err("%s: nvme_identify_ns failed, err=%d\n", f->file_name,
			ret);
		goto out;
	}

	ret = nvme_identify(fd, data->nsid, NVME_IDENTIFY_CNS_CSI_NS,
				NVME_CSI_ZNS, &zns_ns);
	if (ret) {
		log_err("%s: nvme_zns_identify_ns failed, err=%d\n",
			f->file_name, ret);
		goto out;
	}
	zlen = zns_ns.lbafe[ns.flbas & 0x0f].zsze << data->lba_shift;

	max_zones = (f->real_file_size - offset) / zlen;
	if (max_zones < nr_zones)
		nr_zones = max_zones;

	if (nr_zones < zones_chunks)
		zones_chunks = nr_zones;

	while (zones_fetched < nr_zones) {
		if (zones_fetched + zones_chunks >= nr_zones) {
			zones_chunks = nr_zones - zones_fetched;
			zr_len = sizeof(*zr) + (zones_chunks * sizeof(struct nvme_zns_desc));
		}
		ret = nvme_report_zones(fd, data->nsid, offset >> data->lba_shift,
					NVME_ZNS_ZRAS_FEAT_ERZ, zr_len, (void *)zr);
		if (ret) {
			log_err("%s: nvme_zns_report_zones failed, err=%d\n",
				f->file_name, ret);
			goto out;
		}

		/* Transform the zone-report */
		for (j = 0; j < zr->nr_zones; j++, i++) {
			struct nvme_zns_desc *desc = (struct nvme_zns_desc *)&(zr->entries[j]);

			zbdz[i].start = desc->zslba << data->lba_shift;
			zbdz[i].len = zlen;
			zbdz[i].wp = desc->wp << data->lba_shift;
			zbdz[i].capacity = desc->zcap << data->lba_shift;

			/* Zone Type is stored in first 4 bits. */
			switch (desc->zt & 0x0f) {
			case NVME_ZONE_TYPE_SEQWRITE_REQ:
				zbdz[i].type = ZBD_ZONE_TYPE_SWR;
				break;
			default:
				log_err("%s: invalid type for zone at offset %llu.\n",
					f->file_name, (unsigned long long) desc->zslba);
				ret = -EIO;
				goto out;
			}

			/* Zone State is stored in last 4 bits. */
			switch (desc->zs >> 4) {
			case NVME_ZNS_ZS_EMPTY:
				zbdz[i].cond = ZBD_ZONE_COND_EMPTY;
				break;
			case NVME_ZNS_ZS_IMPL_OPEN:
				zbdz[i].cond = ZBD_ZONE_COND_IMP_OPEN;
				break;
			case NVME_ZNS_ZS_EXPL_OPEN:
				zbdz[i].cond = ZBD_ZONE_COND_EXP_OPEN;
				break;
			case NVME_ZNS_ZS_CLOSED:
				zbdz[i].cond = ZBD_ZONE_COND_CLOSED;
				break;
			case NVME_ZNS_ZS_FULL:
				zbdz[i].cond = ZBD_ZONE_COND_FULL;
				break;
			case NVME_ZNS_ZS_READ_ONLY:
			case NVME_ZNS_ZS_OFFLINE:
			default:
				/* Treat all these conditions as offline (don't use!) */
				zbdz[i].cond = ZBD_ZONE_COND_OFFLINE;
				zbdz[i].wp = zbdz[i].start;
			}
		}
		zones_fetched += zr->nr_zones;
		offset += zr->nr_zones * zlen;
	}

	ret = zones_fetched;
out:
	free(zr);
	close(fd);

	return ret;
}

int fio_nvme_reset_wp(struct thread_data *td, struct fio_file *f,
		      uint64_t offset, uint64_t length)
{
	struct nvme_data *data = FILE_ENG_DATA(f);
	unsigned int nr_zones;
	unsigned long long zslba;
	int i, fd, ret = 0;

	/* If the file is not yet opened, open it for this function. */
	fd = f->fd;
	if (fd < 0) {
		fd = open(f->file_name, O_RDWR | O_LARGEFILE);
		if (fd < 0)
			return -errno;
	}

	zslba = offset >> data->lba_shift;
	nr_zones = (length + td->o.zone_size - 1) / td->o.zone_size;

	for (i = 0; i < nr_zones; i++, zslba += (td->o.zone_size >> data->lba_shift)) {
		struct nvme_passthru_cmd cmd = {
			.opcode         = nvme_zns_cmd_mgmt_send,
			.nsid           = data->nsid,
			.cdw10          = zslba & 0xffffffff,
			.cdw11          = zslba >> 32,
			.cdw13          = NVME_ZNS_ZSA_RESET,
			.addr           = (__u64)(uintptr_t)NULL,
			.data_len       = 0,
			.timeout_ms     = NVME_DEFAULT_IOCTL_TIMEOUT,
		};

		ret = ioctl(fd, NVME_IOCTL_IO_CMD, &cmd);
	}

	if (f->fd < 0)
		close(fd);
	return -ret;
}

int fio_nvme_get_max_open_zones(struct thread_data *td, struct fio_file *f,
				unsigned int *max_open_zones)
{
	struct nvme_data *data = FILE_ENG_DATA(f);
	struct nvme_zns_id_ns zns_ns;
	int fd, ret = 0;

	fd = open(f->file_name, O_RDONLY | O_LARGEFILE);
	if (fd < 0)
		return -errno;

	ret = nvme_identify(fd, data->nsid, NVME_IDENTIFY_CNS_CSI_NS,
				NVME_CSI_ZNS, &zns_ns);
	if (ret) {
		log_err("%s: nvme_zns_identify_ns failed, err=%d\n",
			f->file_name, ret);
		goto out;
	}

	*max_open_zones = zns_ns.mor + 1;
out:
	close(fd);
	return ret;
}

static inline int nvme_fdp_reclaim_unit_handle_status(int fd, __u32 nsid,
						      __u32 data_len, void *data)
{
	struct nvme_passthru_cmd cmd = {
		.opcode		= nvme_cmd_io_mgmt_recv,
		.nsid		= nsid,
		.addr		= (__u64)(uintptr_t)data,
		.data_len 	= data_len,
		.cdw10		= 1,
		.cdw11		= (data_len >> 2) - 1,
	};

	return ioctl(fd, NVME_IOCTL_IO_CMD, &cmd);
}

int fio_nvme_iomgmt_ruhs(struct thread_data *td, struct fio_file *f,
			 struct nvme_fdp_ruh_status *ruhs, __u32 bytes)
{
	struct nvme_data *data = FILE_ENG_DATA(f);
	int fd, ret;

	fd = open(f->file_name, O_RDONLY | O_LARGEFILE);
	if (fd < 0)
		return -errno;

	ret = nvme_fdp_reclaim_unit_handle_status(fd, data->nsid, bytes, ruhs);
	if (ret) {
		log_err("%s: nvme_fdp_reclaim_unit_handle_status failed, err=%d\n",
			f->file_name, ret);
		errno = ENOTSUP;
	} else
		errno = 0;

	ret = -errno;
	close(fd);
	return ret;
}
Commit	Line	Data
b3d5e3fd AK	1	/*
	2	* nvme structure declarations and helper functions for the
	3	* io_uring_cmd engine.
	4	*/
	5
	6	#include "nvme.h"
	7
	8	int fio_nvme_uring_cmd_prep(struct nvme_uring_cmd cmd, struct io_u io_u,
	9	struct iovec *iov)
	10	{
	11	struct nvme_data *data = FILE_ENG_DATA(io_u->file);
	12	__u64 slba;
	13	__u32 nlb;
	14
	15	memset(cmd, 0, sizeof(struct nvme_uring_cmd));
	16
	17	if (io_u->ddir == DDIR_READ)
	18	cmd->opcode = nvme_cmd_read;
	19	else if (io_u->ddir == DDIR_WRITE)
	20	cmd->opcode = nvme_cmd_write;
	21	else
	22	return -ENOTSUP;
	23
345fa8fd AK	24	if (data->lba_ext) {
	25	slba = io_u->offset / data->lba_ext;
	26	nlb = (io_u->xfer_buflen / data->lba_ext) - 1;
	27	} else {
	28	slba = io_u->offset >> data->lba_shift;
	29	nlb = (io_u->xfer_buflen >> data->lba_shift) - 1;
	30	}
b3d5e3fd AK	31
	32	/* cdw10 and cdw11 represent starting lba */
	33	cmd->cdw10 = slba & 0xffffffff;
	34	cmd->cdw11 = slba >> 32;
	35	/* cdw12 represent number of lba's for read/write */
a7e8aae0 KB	36	cmd->cdw12 = nlb \| (io_u->dtype << 20);
a7e8aae0 KB	37	cmd->cdw13 = io_u->dspec << 16;
b3d5e3fd AK	38	if (iov) {
	39	iov->iov_base = io_u->xfer_buf;
	40	iov->iov_len = io_u->xfer_buflen;
	41	cmd->addr = (__u64)(uintptr_t)iov;
	42	cmd->data_len = 1;
	43	} else {
	44	cmd->addr = (__u64)(uintptr_t)io_u->xfer_buf;
	45	cmd->data_len = io_u->xfer_buflen;
	46	}
	47	cmd->nsid = data->nsid;
	48	return 0;
	49	}
	50
16be6037 AK	51	static int nvme_trim(int fd, __u32 nsid, __u32 nr_range, __u32 data_len,
	52	void *data)
	53	{
	54	struct nvme_passthru_cmd cmd = {
	55	.opcode = nvme_cmd_dsm,
	56	.nsid = nsid,
	57	.addr = (__u64)(uintptr_t)data,
	58	.data_len = data_len,
	59	.cdw10 = nr_range - 1,
	60	.cdw11 = NVME_ATTRIBUTE_DEALLOCATE,
	61	};
	62
	63	return ioctl(fd, NVME_IOCTL_IO_CMD, &cmd);
	64	}
	65
	66	int fio_nvme_trim(const struct thread_data td, struct fio_file f,
	67	unsigned long long offset, unsigned long long len)
	68	{
	69	struct nvme_data *data = FILE_ENG_DATA(f);
	70	struct nvme_dsm_range dsm;
	71	int ret;
	72
345fa8fd AK	73	if (data->lba_ext) {
	74	dsm.nlb = len / data->lba_ext;
	75	dsm.slba = offset / data->lba_ext;
	76	} else {
	77	dsm.nlb = len >> data->lba_shift;
	78	dsm.slba = offset >> data->lba_shift;
	79	}
16be6037 AK	80
	81	ret = nvme_trim(f->fd, data->nsid, 1, sizeof(struct nvme_dsm_range),
	82	&dsm);
	83	if (ret)
	84	log_err("%s: nvme_trim failed for offset %llu and len %llu, err=%d\n",
	85	f->file_name, offset, len, ret);
	86
	87	return ret;
	88	}
	89
b3d5e3fd AK	90	static int nvme_identify(int fd, __u32 nsid, enum nvme_identify_cns cns,
	91	enum nvme_csi csi, void *data)
	92	{
	93	struct nvme_passthru_cmd cmd = {
	94	.opcode = nvme_admin_identify,
	95	.nsid = nsid,
	96	.addr = (__u64)(uintptr_t)data,
	97	.data_len = NVME_IDENTIFY_DATA_SIZE,
	98	.cdw10 = cns,
	99	.cdw11 = csi << NVME_IDENTIFY_CSI_SHIFT,
	100	.timeout_ms = NVME_DEFAULT_IOCTL_TIMEOUT,
	101	};
	102
	103	return ioctl(fd, NVME_IOCTL_ADMIN_CMD, &cmd);
	104	}
	105
	106	int fio_nvme_get_info(struct fio_file f, __u32 nsid, __u32 *lba_sz,
345fa8fd	107	__u32 ms, __u64 nlba)
b3d5e3fd AK	108	{
b3d5e3fd AK	109	struct nvme_id_ns ns;
37a0881f	110	int namespace_id;
b3d5e3fd	111	int fd, err;
01a7d384	112	__u32 format_idx;
b3d5e3fd AK	113
	114	if (f->filetype != FIO_TYPE_CHAR) {
	115	log_err("ioengine io_uring_cmd only works with nvme ns "
	116	"generic char devices (/dev/ngXnY)\n");
	117	return 1;
	118	}
	119
	120	fd = open(f->file_name, O_RDONLY);
	121	if (fd < 0)
	122	return -errno;
	123
	124	namespace_id = ioctl(fd, NVME_IOCTL_ID);
	125	if (namespace_id < 0) {
af10f514	126	err = -errno;
345fa8fd AK	127	log_err("%s: failed to fetch namespace-id\n", f->file_name);
345fa8fd AK	128	goto out;
b3d5e3fd AK	129	}
	130
	131	/*
	132	* Identify namespace to get namespace-id, namespace size in LBA's
	133	* and LBA data size.
	134	*/
	135	err = nvme_identify(fd, namespace_id, NVME_IDENTIFY_CNS_NS,
	136	NVME_CSI_NVM, &ns);
	137	if (err) {
345fa8fd AK	138	log_err("%s: failed to fetch identify namespace\n",
345fa8fd AK	139	f->file_name);
b3d5e3fd AK	140	close(fd);
	141	return err;
	142	}
	143
	144	*nsid = namespace_id;
01a7d384 AK	145
	146	/*
	147	* 16 or 64 as maximum number of supported LBA formats.
	148	* From flbas bit 0-3 indicates lsb and bit 5-6 indicates msb
	149	* of the format index used to format the namespace.
	150	*/
	151	if (ns.nlbaf < 16)
	152	format_idx = ns.flbas & 0xf;
	153	else
	154	format_idx = (ns.flbas & 0xf) + (((ns.flbas >> 5) & 0x3) << 4);
	155
	156	*lba_sz = 1 << ns.lbaf[format_idx].ds;
345fa8fd AK	157
	158	/*
	159	* Only extended LBA can be supported.
	160	* Bit 4 for flbas indicates if metadata is transferred at the end of
	161	* logical block creating an extended LBA.
	162	*/
	163	*ms = le16_to_cpu(ns.lbaf[format_idx].ms);
	164	if (*ms && !((ns.flbas >> 4) & 0x1)) {
	165	log_err("%s: only extended logical block can be supported\n",
	166	f->file_name);
	167	err = -ENOTSUP;
	168	goto out;
	169	}
	170
	171	/* Check for end to end data protection support */
	172	if (ns.dps & 0x3) {
	173	log_err("%s: end to end data protection not supported\n",
	174	f->file_name);
	175	err = -ENOTSUP;
	176	goto out;
	177	}
b3d5e3fd AK	178	*nlba = ns.nsze;
b3d5e3fd AK	179
345fa8fd	180	out:
b3d5e3fd	181	close(fd);
345fa8fd	182	return err;
b3d5e3fd	183	}
3d05e0ff AK	184
	185	int fio_nvme_get_zoned_model(struct thread_data td, struct fio_file f,
	186	enum zbd_zoned_model *model)
	187	{
	188	struct nvme_data *data = FILE_ENG_DATA(f);
	189	struct nvme_id_ns ns;
	190	struct nvme_passthru_cmd cmd;
	191	int fd, ret = 0;
	192
	193	if (f->filetype != FIO_TYPE_CHAR)
	194	return -EINVAL;
	195
	196	/* File is not yet opened */
	197	fd = open(f->file_name, O_RDONLY \| O_LARGEFILE);
	198	if (fd < 0)
	199	return -errno;
	200
	201	/* Using nvme_id_ns for data as sizes are same */
	202	ret = nvme_identify(fd, data->nsid, NVME_IDENTIFY_CNS_CSI_CTRL,
	203	NVME_CSI_ZNS, &ns);
	204	if (ret) {
	205	*model = ZBD_NONE;
	206	goto out;
	207	}
	208
	209	memset(&cmd, 0, sizeof(struct nvme_passthru_cmd));
	210
	211	/* Using nvme_id_ns for data as sizes are same */
	212	ret = nvme_identify(fd, data->nsid, NVME_IDENTIFY_CNS_CSI_NS,
	213	NVME_CSI_ZNS, &ns);
	214	if (ret) {
	215	*model = ZBD_NONE;
	216	goto out;
	217	}
	218
	219	*model = ZBD_HOST_MANAGED;
	220	out:
	221	close(fd);
	222	return 0;
	223	}
	224
	225	static int nvme_report_zones(int fd, __u32 nsid, __u64 slba, __u32 zras_feat,
	226	__u32 data_len, void *data)
	227	{
	228	struct nvme_passthru_cmd cmd = {
	229	.opcode = nvme_zns_cmd_mgmt_recv,
	230	.nsid = nsid,
	231	.addr = (__u64)(uintptr_t)data,
	232	.data_len = data_len,
	233	.cdw10 = slba & 0xffffffff,
	234	.cdw11 = slba >> 32,
	235	.cdw12 = (data_len >> 2) - 1,
	236	.cdw13 = NVME_ZNS_ZRA_REPORT_ZONES \| zras_feat,
	237	.timeout_ms = NVME_DEFAULT_IOCTL_TIMEOUT,
	238	};
	239
	240	return ioctl(fd, NVME_IOCTL_IO_CMD, &cmd);
	241	}
	242
	243	int fio_nvme_report_zones(struct thread_data td, struct fio_file f,
	244	uint64_t offset, struct zbd_zone *zbdz,
	245	unsigned int nr_zones)
	246	{
	247	struct nvme_data *data = FILE_ENG_DATA(f);
248	struct nvme_zone_report *zr;
249	struct nvme_zns_id_ns zns_ns;
250	struct nvme_id_ns ns;
251	unsigned int i = 0, j, zones_fetched = 0;
252	unsigned int max_zones, zones_chunks = 1024;
253	int fd, ret = 0;
254	__u32 zr_len;
255	__u64 zlen;
256
257	/* File is not yet opened */
258	fd = open(f->file_name, O_RDONLY \| O_LARGEFILE);
259	if (fd < 0)
260	return -errno;
261
262	zones_fetched = 0;
263	zr_len = sizeof(zr) + (zones_chunks sizeof(struct nvme_zns_desc));
264	zr = calloc(1, zr_len);
3efcb23f JA	265	if (!zr) {
3efcb23f JA	266	close(fd);
3d05e0ff	267	return -ENOMEM;
3efcb23f	268	}
3d05e0ff AK	269
	270	ret = nvme_identify(fd, data->nsid, NVME_IDENTIFY_CNS_NS,
	271	NVME_CSI_NVM, &ns);
	272	if (ret) {
	273	log_err("%s: nvme_identify_ns failed, err=%d\n", f->file_name,
	274	ret);
	275	goto out;
	276	}
	277
	278	ret = nvme_identify(fd, data->nsid, NVME_IDENTIFY_CNS_CSI_NS,
	279	NVME_CSI_ZNS, &zns_ns);
	280	if (ret) {
	281	log_err("%s: nvme_zns_identify_ns failed, err=%d\n",
	282	f->file_name, ret);
	283	goto out;
	284	}
	285	zlen = zns_ns.lbafe[ns.flbas & 0x0f].zsze << data->lba_shift;
	286
	287	max_zones = (f->real_file_size - offset) / zlen;
	288	if (max_zones < nr_zones)
	289	nr_zones = max_zones;
	290
	291	if (nr_zones < zones_chunks)
	292	zones_chunks = nr_zones;
	293
	294	while (zones_fetched < nr_zones) {
	295	if (zones_fetched + zones_chunks >= nr_zones) {
	296	zones_chunks = nr_zones - zones_fetched;
	297	zr_len = sizeof(zr) + (zones_chunks sizeof(struct nvme_zns_desc));
	298	}
	299	ret = nvme_report_zones(fd, data->nsid, offset >> data->lba_shift,
	300	NVME_ZNS_ZRAS_FEAT_ERZ, zr_len, (void *)zr);
	301	if (ret) {
	302	log_err("%s: nvme_zns_report_zones failed, err=%d\n",
	303	f->file_name, ret);
	304	goto out;
	305	}
	306
	307	/* Transform the zone-report */
	308	for (j = 0; j < zr->nr_zones; j++, i++) {
	309	struct nvme_zns_desc desc = (struct nvme_zns_desc )&(zr->entries[j]);
	310
	311	zbdz[i].start = desc->zslba << data->lba_shift;
	312	zbdz[i].len = zlen;
	313	zbdz[i].wp = desc->wp << data->lba_shift;
	314	zbdz[i].capacity = desc->zcap << data->lba_shift;
	315
	316	/* Zone Type is stored in first 4 bits. */
	317	switch (desc->zt & 0x0f) {
	318	case NVME_ZONE_TYPE_SEQWRITE_REQ:
	319	zbdz[i].type = ZBD_ZONE_TYPE_SWR;
	320	break;
	321	default:
	322	log_err("%s: invalid type for zone at offset %llu.\n",
2fa0ab21	323	f->file_name, (unsigned long long) desc->zslba);
3d05e0ff AK	324	ret = -EIO;
	325	goto out;
	326	}
	327
	328	/* Zone State is stored in last 4 bits. */
	329	switch (desc->zs >> 4) {
	330	case NVME_ZNS_ZS_EMPTY:
	331	zbdz[i].cond = ZBD_ZONE_COND_EMPTY;
	332	break;
	333	case NVME_ZNS_ZS_IMPL_OPEN:
	334	zbdz[i].cond = ZBD_ZONE_COND_IMP_OPEN;
	335	break;
	336	case NVME_ZNS_ZS_EXPL_OPEN:
	337	zbdz[i].cond = ZBD_ZONE_COND_EXP_OPEN;
	338	break;
	339	case NVME_ZNS_ZS_CLOSED:
	340	zbdz[i].cond = ZBD_ZONE_COND_CLOSED;
	341	break;
	342	case NVME_ZNS_ZS_FULL:
	343	zbdz[i].cond = ZBD_ZONE_COND_FULL;
	344	break;
	345	case NVME_ZNS_ZS_READ_ONLY:
	346	case NVME_ZNS_ZS_OFFLINE:
	347	default:
	348	/* Treat all these conditions as offline (don't use!) */
	349	zbdz[i].cond = ZBD_ZONE_COND_OFFLINE;
	350	zbdz[i].wp = zbdz[i].start;
	351	}
	352	}
	353	zones_fetched += zr->nr_zones;
	354	offset += zr->nr_zones * zlen;
	355	}
	356
	357	ret = zones_fetched;
	358	out:
	359	free(zr);
	360	close(fd);
	361
	362	return ret;
	363	}
	364
	365	int fio_nvme_reset_wp(struct thread_data td, struct fio_file f,
	366	uint64_t offset, uint64_t length)
	367	{
	368	struct nvme_data *data = FILE_ENG_DATA(f);
	369	unsigned int nr_zones;
	370	unsigned long long zslba;
	371	int i, fd, ret = 0;
	372
	373	/* If the file is not yet opened, open it for this function. */
	374	fd = f->fd;
	375	if (fd < 0) {
	376	fd = open(f->file_name, O_RDWR \| O_LARGEFILE);
	377	if (fd < 0)
	378	return -errno;
	379	}
	380
	381	zslba = offset >> data->lba_shift;
	382	nr_zones = (length + td->o.zone_size - 1) / td->o.zone_size;
	383
	384	for (i = 0; i < nr_zones; i++, zslba += (td->o.zone_size >> data->lba_shift)) {
	385	struct nvme_passthru_cmd cmd = {
	386	.opcode = nvme_zns_cmd_mgmt_send,
	387	.nsid = data->nsid,
388	.cdw10 = zslba & 0xffffffff,
389	.cdw11 = zslba >> 32,
390	.cdw13 = NVME_ZNS_ZSA_RESET,
391	.addr = (__u64)(uintptr_t)NULL,
392	.data_len = 0,
393	.timeout_ms = NVME_DEFAULT_IOCTL_TIMEOUT,
394	};
395
396	ret = ioctl(fd, NVME_IOCTL_IO_CMD, &cmd);
397	}
398
399	if (f->fd < 0)
400	close(fd);
401	return -ret;
402	}
403
404	int fio_nvme_get_max_open_zones(struct thread_data td, struct fio_file f,
405	unsigned int *max_open_zones)
406	{
407	struct nvme_data *data = FILE_ENG_DATA(f);
408	struct nvme_zns_id_ns zns_ns;
409	int fd, ret = 0;
410
411	fd = open(f->file_name, O_RDONLY \| O_LARGEFILE);
412	if (fd < 0)
413	return -errno;
414
415	ret = nvme_identify(fd, data->nsid, NVME_IDENTIFY_CNS_CSI_NS,
416	NVME_CSI_ZNS, &zns_ns);
417	if (ret) {
418	log_err("%s: nvme_zns_identify_ns failed, err=%d\n",
419	f->file_name, ret);
420	goto out;
421	}
422
423	*max_open_zones = zns_ns.mor + 1;
424	out:
425	close(fd);
426	return ret;
427	}
a7e8aae0 KB	428
	429	static inline int nvme_fdp_reclaim_unit_handle_status(int fd, __u32 nsid,
	430	__u32 data_len, void *data)
	431	{
	432	struct nvme_passthru_cmd cmd = {
	433	.opcode = nvme_cmd_io_mgmt_recv,
	434	.nsid = nsid,
	435	.addr = (__u64)(uintptr_t)data,
	436	.data_len = data_len,
	437	.cdw10 = 1,
	438	.cdw11 = (data_len >> 2) - 1,
	439	};
	440
	441	return ioctl(fd, NVME_IOCTL_IO_CMD, &cmd);
	442	}
	443
	444	int fio_nvme_iomgmt_ruhs(struct thread_data td, struct fio_file f,
	445	struct nvme_fdp_ruh_status *ruhs, __u32 bytes)
	446	{
	447	struct nvme_data *data = FILE_ENG_DATA(f);
	448	int fd, ret;
	449
	450	fd = open(f->file_name, O_RDONLY \| O_LARGEFILE);
	451	if (fd < 0)
	452	return -errno;
	453
	454	ret = nvme_fdp_reclaim_unit_handle_status(fd, data->nsid, bytes, ruhs);
	455	if (ret) {
	456	log_err("%s: nvme_fdp_reclaim_unit_handle_status failed, err=%d\n",
	457	f->file_name, ret);
	458	errno = ENOTSUP;
	459	} else
	460	errno = 0;
	461
af10f514	462	ret = -errno;
a7e8aae0	463	close(fd);
af10f514	464	return ret;
a7e8aae0	465	}