[fio.git] / engines / libzbc.c

/*
 * Copyright (C) 2019 Western Digital Corporation or its affiliates.
 *
 * This file is released under the GPL.
 *
 * libzbc engine
 * IO engine using libzbc library to talk to SMR disks.
 */
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <libzbc/zbc.h>

#include "fio.h"
#include "err.h"
#include "zbd_types.h"

struct libzbc_data {
	struct zbc_device	*zdev;
	enum zbc_dev_model	model;
	uint64_t		nr_sectors;
	uint32_t		max_open_seq_req;
};

static int libzbc_get_dev_info(struct libzbc_data *ld, struct fio_file *f)
{
	struct zbc_device_info *zinfo;

	zinfo = calloc(1, sizeof(*zinfo));
	if (!zinfo)
		return -ENOMEM;

	zbc_get_device_info(ld->zdev, zinfo);
	ld->model = zinfo->zbd_model;
	ld->nr_sectors = zinfo->zbd_sectors;
	ld->max_open_seq_req = zinfo->zbd_max_nr_open_seq_req;

	dprint(FD_ZBD, "%s: vendor_id:%s, type: %s, model: %s\n",
	       f->file_name, zinfo->zbd_vendor_id,
	       zbc_device_type_str(zinfo->zbd_type),
	       zbc_device_model_str(zinfo->zbd_model));

	free(zinfo);

	return 0;
}

static int libzbc_open_dev(struct thread_data *td, struct fio_file *f,
			   struct libzbc_data **p_ld)
{
	struct libzbc_data *ld = td->io_ops_data;
	int ret, flags = OS_O_DIRECT;

	if (ld) {
		/* Already open */
		assert(ld->zdev);
		goto out;
	}

	if (f->filetype != FIO_TYPE_BLOCK && f->filetype != FIO_TYPE_CHAR) {
		td_verror(td, EINVAL, "wrong file type");
		log_err("ioengine libzbc only works on block or character devices\n");
		return -EINVAL;
	}

	if (td_write(td)) {
		if (!read_only)
			flags |= O_RDWR;
	} else if (td_read(td)) {
		if (f->filetype == FIO_TYPE_CHAR && !read_only)
			flags |= O_RDWR;
		else
			flags |= O_RDONLY;
	} else if (td_trim(td)) {
		td_verror(td, EINVAL, "libzbc does not support trim");
		log_err("%s: libzbc does not support trim\n", f->file_name);
		return -EINVAL;
	}

	if (td->o.oatomic) {
		td_verror(td, EINVAL, "libzbc does not support O_ATOMIC");
		log_err("%s: libzbc does not support O_ATOMIC\n", f->file_name);
		return -EINVAL;
	}

	ld = calloc(1, sizeof(*ld));
	if (!ld)
		return -ENOMEM;

	ret = zbc_open(f->file_name,
		       flags | ZBC_O_DRV_BLOCK | ZBC_O_DRV_SCSI | ZBC_O_DRV_ATA,
		       &ld->zdev);
	if (ret) {
		log_err("%s: zbc_open() failed, err=%d\n",
			f->file_name, ret);
		goto err;
	}

	ret = libzbc_get_dev_info(ld, f);
	if (ret)
		goto err_close;

	td->io_ops_data = ld;
out:
	if (p_ld)
		*p_ld = ld;

	return 0;

err_close:
	zbc_close(ld->zdev);
err:
	free(ld);
	return ret;
}

static int libzbc_close_dev(struct thread_data *td)
{
	struct libzbc_data *ld = td->io_ops_data;
	int ret = 0;

	td->io_ops_data = NULL;
	if (ld) {
		if (ld->zdev)
			ret = zbc_close(ld->zdev);
		free(ld);
	}

	return ret;
}
static int libzbc_open_file(struct thread_data *td, struct fio_file *f)
{
	return libzbc_open_dev(td, f, NULL);
}

static int libzbc_close_file(struct thread_data *td, struct fio_file *f)
{
	int ret;

	ret = libzbc_close_dev(td);
	if (ret)
		log_err("%s: close device failed err %d\n",
			f->file_name, ret);

	return ret;
}

static void libzbc_cleanup(struct thread_data *td)
{
	libzbc_close_dev(td);
}

static int libzbc_invalidate(struct thread_data *td, struct fio_file *f)
{
	/* Passthrough IO do not cache data. Nothing to do */
	return 0;
}

static int libzbc_get_file_size(struct thread_data *td, struct fio_file *f)
{
	struct libzbc_data *ld;
	int ret;

	if (fio_file_size_known(f))
		return 0;

	ret = libzbc_open_dev(td, f, &ld);
	if (ret)
		return ret;

	f->real_file_size = ld->nr_sectors << 9;
	fio_file_set_size_known(f);

	return 0;
}

static int libzbc_get_zoned_model(struct thread_data *td, struct fio_file *f,
				  enum zbd_zoned_model *model)
{
	struct libzbc_data *ld;
	int ret;

	if (f->filetype != FIO_TYPE_BLOCK && f->filetype != FIO_TYPE_CHAR) {
		*model = ZBD_IGNORE;
		return 0;
	}

	ret = libzbc_open_dev(td, f, &ld);
	if (ret)
		return ret;

	switch (ld->model) {
	case ZBC_DM_HOST_AWARE:
		*model = ZBD_HOST_AWARE;
		break;
	case ZBC_DM_HOST_MANAGED:
		*model = ZBD_HOST_MANAGED;
		break;
	default:
		*model = ZBD_NONE;
		break;
	}

	return 0;
}

static int libzbc_report_zones(struct thread_data *td, struct fio_file *f,
			       uint64_t offset, struct zbd_zone *zbdz,
			       unsigned int nr_zones)
{
	struct libzbc_data *ld;
	uint64_t sector = offset >> 9;
	struct zbc_zone *zones;
	unsigned int i;
	int ret;

	ret = libzbc_open_dev(td, f, &ld);
	if (ret)
		return ret;

	if (sector >= ld->nr_sectors)
		return 0;

	zones = calloc(nr_zones, sizeof(struct zbc_zone));
	if (!zones) {
		ret = -ENOMEM;
		goto out;
	}

	ret = zbc_report_zones(ld->zdev, sector, ZBC_RO_ALL, zones, &nr_zones);
	if (ret < 0) {
		log_err("%s: zbc_report_zones failed, err=%d\n",
			f->file_name, ret);
		goto out;
	}

	for (i = 0; i < nr_zones; i++, zbdz++) {
		zbdz->start = zones[i].zbz_start << 9;
		zbdz->len = zones[i].zbz_length << 9;
		zbdz->wp = zones[i].zbz_write_pointer << 9;
		/*
		 * ZBC/ZAC do not define zone capacity, so use the zone size as
		 * the zone capacity.
		 */
		zbdz->capacity = zbdz->len;

		switch (zones[i].zbz_type) {
		case ZBC_ZT_CONVENTIONAL:
			zbdz->type = ZBD_ZONE_TYPE_CNV;
			break;
		case ZBC_ZT_SEQUENTIAL_REQ:
			zbdz->type = ZBD_ZONE_TYPE_SWR;
			break;
		case ZBC_ZT_SEQUENTIAL_PREF:
			zbdz->type = ZBD_ZONE_TYPE_SWP;
			break;
		default:
			td_verror(td, errno, "invalid zone type");
			log_err("%s: invalid type for zone at sector %llu.\n",
				f->file_name, (unsigned long long)zbdz->start);
			ret = -EIO;
			goto out;
		}

		switch (zones[i].zbz_condition) {
		case ZBC_ZC_NOT_WP:
			zbdz->cond = ZBD_ZONE_COND_NOT_WP;
			break;
		case ZBC_ZC_EMPTY:
			zbdz->cond = ZBD_ZONE_COND_EMPTY;
			break;
		case ZBC_ZC_IMP_OPEN:
			zbdz->cond = ZBD_ZONE_COND_IMP_OPEN;
			break;
		case ZBC_ZC_EXP_OPEN:
			zbdz->cond = ZBD_ZONE_COND_EXP_OPEN;
			break;
		case ZBC_ZC_CLOSED:
			zbdz->cond = ZBD_ZONE_COND_CLOSED;
			break;
		case ZBC_ZC_FULL:
			zbdz->cond = ZBD_ZONE_COND_FULL;
			break;
		case ZBC_ZC_RDONLY:
		case ZBC_ZC_OFFLINE:
		default:
			/* Treat all these conditions as offline (don't use!) */
			zbdz->cond = ZBD_ZONE_COND_OFFLINE;
			zbdz->wp = zbdz->start;
		}
	}

	ret = nr_zones;
out:
	free(zones);
	return ret;
}

static int libzbc_reset_wp(struct thread_data *td, struct fio_file *f,
			   uint64_t offset, uint64_t length)
{
	struct libzbc_data *ld = td->io_ops_data;
	uint64_t sector = offset >> 9;
	uint64_t end_sector = (offset + length) >> 9;
	unsigned int nr_zones;
	struct zbc_errno err;
	int i, ret;

	assert(ld);
	assert(ld->zdev);

	nr_zones = (length + td->o.zone_size - 1) / td->o.zone_size;
	if (!sector && end_sector >= ld->nr_sectors) {
		/* Reset all zones */
		ret = zbc_reset_zone(ld->zdev, 0, ZBC_OP_ALL_ZONES);
		if (ret)
			goto err;

		return 0;
	}

	for (i = 0; i < nr_zones; i++, sector += td->o.zone_size >> 9) {
		ret = zbc_reset_zone(ld->zdev, sector, 0);
		if (ret)
			goto err;
	}

	return 0;

err:
	zbc_errno(ld->zdev, &err);
	td_verror(td, errno, "zbc_reset_zone failed");
	if (err.sk)
		log_err("%s: reset wp failed %s:%s\n",
			f->file_name,
			zbc_sk_str(err.sk), zbc_asc_ascq_str(err.asc_ascq));
	return -ret;
}

static int libzbc_get_max_open_zones(struct thread_data *td, struct fio_file *f,
				     unsigned int *max_open_zones)
{
	struct libzbc_data *ld;
	int ret;

	ret = libzbc_open_dev(td, f, &ld);
	if (ret)
		return ret;

	if (ld->max_open_seq_req == ZBC_NO_LIMIT)
		*max_open_zones = 0;
	else
		*max_open_zones = ld->max_open_seq_req;

	return 0;
}

ssize_t libzbc_rw(struct thread_data *td, struct io_u *io_u)
{
	struct libzbc_data *ld = td->io_ops_data;
	struct fio_file *f = io_u->file;
	uint64_t sector = io_u->offset >> 9;
	size_t count = io_u->xfer_buflen >> 9;
	struct zbc_errno err;
	ssize_t ret;

	if (io_u->ddir == DDIR_WRITE)
		ret = zbc_pwrite(ld->zdev, io_u->xfer_buf, count, sector);
	else
		ret = zbc_pread(ld->zdev, io_u->xfer_buf, count, sector);
	if (ret == count)
		return ret;

	if (ret > 0) {
		log_err("Short %s, len=%zu, ret=%zd\n",
			io_u->ddir == DDIR_READ ? "read" : "write",
			count << 9, ret << 9);
		return -EIO;
	}

	/* I/O error */
	zbc_errno(ld->zdev, &err);
	td_verror(td, errno, "libzbc i/o failed");
	if (err.sk) {
		log_err("%s: op %u offset %llu+%llu failed (%s:%s), err %zd\n",
			f->file_name, io_u->ddir,
			io_u->offset, io_u->xfer_buflen,
			zbc_sk_str(err.sk),
			zbc_asc_ascq_str(err.asc_ascq), ret);
	} else {
		log_err("%s: op %u offset %llu+%llu failed, err %zd\n",
			f->file_name, io_u->ddir,
			io_u->offset, io_u->xfer_buflen, ret);
	}

	return -EIO;
}

static enum fio_q_status libzbc_queue(struct thread_data *td, struct io_u *io_u)
{
	struct libzbc_data *ld = td->io_ops_data;
	struct fio_file *f = io_u->file;
	ssize_t ret = 0;

	fio_ro_check(td, io_u);

	dprint(FD_ZBD, "%p:%s: libzbc queue %llu\n",
	       td, f->file_name, io_u->offset);

	if (io_u->ddir == DDIR_READ || io_u->ddir == DDIR_WRITE) {
		ret = libzbc_rw(td, io_u);
	} else if (ddir_sync(io_u->ddir)) {
		ret = zbc_flush(ld->zdev);
		if (ret)
			log_err("zbc_flush error %zd\n", ret);
	} else if (io_u->ddir != DDIR_TRIM) {
		log_err("Unsupported operation %u\n", io_u->ddir);
		ret = -EINVAL;
	}
	if (ret < 0)
		io_u->error = -ret;

	return FIO_Q_COMPLETED;
}

FIO_STATIC struct ioengine_ops ioengine = {
	.name			= "libzbc",
	.version		= FIO_IOOPS_VERSION,
	.open_file		= libzbc_open_file,
	.close_file		= libzbc_close_file,
	.cleanup		= libzbc_cleanup,
	.invalidate		= libzbc_invalidate,
	.get_file_size		= libzbc_get_file_size,
	.get_zoned_model	= libzbc_get_zoned_model,
	.report_zones		= libzbc_report_zones,
	.reset_wp		= libzbc_reset_wp,
	.get_max_open_zones	= libzbc_get_max_open_zones,
	.queue			= libzbc_queue,
	.flags			= FIO_SYNCIO | FIO_NOEXTEND | FIO_RAWIO,
};

static void fio_init fio_libzbc_register(void)
{
	register_ioengine(&ioengine);
}

static void fio_exit fio_libzbc_unregister(void)
{
	unregister_ioengine(&ioengine);
}
Commit	Line	Data
56a19325 DF	1	/*
	2	* Copyright (C) 2019 Western Digital Corporation or its affiliates.
	3	*
	4	* This file is released under the GPL.
	5	*
	6	* libzbc engine
	7	* IO engine using libzbc library to talk to SMR disks.
	8	*/
	9	#include <stdlib.h>
	10	#include <unistd.h>
	11	#include <errno.h>
	12	#include <libzbc/zbc.h>
	13
	14	#include "fio.h"
	15	#include "err.h"
	16	#include "zbd_types.h"
	17
	18	struct libzbc_data {
	19	struct zbc_device *zdev;
	20	enum zbc_dev_model model;
	21	uint64_t nr_sectors;
e8267436	22	uint32_t max_open_seq_req;
56a19325 DF	23	};
	24
	25	static int libzbc_get_dev_info(struct libzbc_data ld, struct fio_file f)
	26	{
	27	struct zbc_device_info *zinfo;
	28
	29	zinfo = calloc(1, sizeof(*zinfo));
	30	if (!zinfo)
	31	return -ENOMEM;
	32
	33	zbc_get_device_info(ld->zdev, zinfo);
	34	ld->model = zinfo->zbd_model;
	35	ld->nr_sectors = zinfo->zbd_sectors;
e8267436	36	ld->max_open_seq_req = zinfo->zbd_max_nr_open_seq_req;
56a19325 DF	37
	38	dprint(FD_ZBD, "%s: vendor_id:%s, type: %s, model: %s\n",
	39	f->file_name, zinfo->zbd_vendor_id,
	40	zbc_device_type_str(zinfo->zbd_type),
	41	zbc_device_model_str(zinfo->zbd_model));
	42
	43	free(zinfo);
	44
	45	return 0;
	46	}
	47
	48	static int libzbc_open_dev(struct thread_data td, struct fio_file f,
	49	struct libzbc_data **p_ld)
	50	{
	51	struct libzbc_data *ld = td->io_ops_data;
976fb54e	52	int ret, flags = OS_O_DIRECT;
56a19325 DF	53
	54	if (ld) {
	55	/* Already open */
	56	assert(ld->zdev);
	57	goto out;
	58	}
	59
	60	if (f->filetype != FIO_TYPE_BLOCK && f->filetype != FIO_TYPE_CHAR) {
	61	td_verror(td, EINVAL, "wrong file type");
	62	log_err("ioengine libzbc only works on block or character devices\n");
	63	return -EINVAL;
	64	}
	65
976fb54e	66	if (td_write(td)) {
56a19325 DF	67	if (!read_only)
	68	flags \|= O_RDWR;
	69	} else if (td_read(td)) {
	70	if (f->filetype == FIO_TYPE_CHAR && !read_only)
	71	flags \|= O_RDWR;
	72	else
	73	flags \|= O_RDONLY;
	74	} else if (td_trim(td)) {
	75	td_verror(td, EINVAL, "libzbc does not support trim");
976fb54e DF	76	log_err("%s: libzbc does not support trim\n", f->file_name);
976fb54e DF	77	return -EINVAL;
56a19325 DF	78	}
56a19325 DF	79
976fb54e	80	if (td->o.oatomic) {
56a19325	81	td_verror(td, EINVAL, "libzbc does not support O_ATOMIC");
976fb54e DF	82	log_err("%s: libzbc does not support O_ATOMIC\n", f->file_name);
	83	return -EINVAL;
	84	}
56a19325 DF	85
	86	ld = calloc(1, sizeof(*ld));
	87	if (!ld)
	88	return -ENOMEM;
	89
	90	ret = zbc_open(f->file_name,
ed2eb875 DF	91	flags \| ZBC_O_DRV_BLOCK \| ZBC_O_DRV_SCSI \| ZBC_O_DRV_ATA,
ed2eb875 DF	92	&ld->zdev);
56a19325 DF	93	if (ret) {
	94	log_err("%s: zbc_open() failed, err=%d\n",
	95	f->file_name, ret);
891660e4	96	goto err;
56a19325 DF	97	}
	98
	99	ret = libzbc_get_dev_info(ld, f);
891660e4 DF	100	if (ret)
891660e4 DF	101	goto err_close;
56a19325 DF	102
	103	td->io_ops_data = ld;
	104	out:
	105	if (p_ld)
	106	*p_ld = ld;
	107
	108	return 0;
891660e4 DF	109
	110	err_close:
	111	zbc_close(ld->zdev);
	112	err:
	113	free(ld);
	114	return ret;
56a19325 DF	115	}
	116
	117	static int libzbc_close_dev(struct thread_data *td)
	118	{
	119	struct libzbc_data *ld = td->io_ops_data;
	120	int ret = 0;
	121
	122	td->io_ops_data = NULL;
	123	if (ld) {
	124	if (ld->zdev)
	125	ret = zbc_close(ld->zdev);
	126	free(ld);
	127	}
	128
	129	return ret;
	130	}
	131	static int libzbc_open_file(struct thread_data td, struct fio_file f)
	132	{
	133	return libzbc_open_dev(td, f, NULL);
	134	}
	135
	136	static int libzbc_close_file(struct thread_data td, struct fio_file f)
	137	{
	138	int ret;
	139
	140	ret = libzbc_close_dev(td);
	141	if (ret)
	142	log_err("%s: close device failed err %d\n",
	143	f->file_name, ret);
	144
	145	return ret;
	146	}
	147
	148	static void libzbc_cleanup(struct thread_data *td)
	149	{
	150	libzbc_close_dev(td);
	151	}
	152
	153	static int libzbc_invalidate(struct thread_data td, struct fio_file f)
	154	{
	155	/* Passthrough IO do not cache data. Nothing to do */
	156	return 0;
	157	}
	158
	159	static int libzbc_get_file_size(struct thread_data td, struct fio_file f)
	160	{
	161	struct libzbc_data *ld;
	162	int ret;
	163
	164	if (fio_file_size_known(f))
	165	return 0;
	166
	167	ret = libzbc_open_dev(td, f, &ld);
	168	if (ret)
	169	return ret;
	170
	171	f->real_file_size = ld->nr_sectors << 9;
	172	fio_file_set_size_known(f);
	173
	174	return 0;
	175	}
	176
	177	static int libzbc_get_zoned_model(struct thread_data td, struct fio_file f,
	178	enum zbd_zoned_model *model)
179	{
180	struct libzbc_data *ld;
181	int ret;
182
183	if (f->filetype != FIO_TYPE_BLOCK && f->filetype != FIO_TYPE_CHAR) {
184	*model = ZBD_IGNORE;
185	return 0;
186	}
187
188	ret = libzbc_open_dev(td, f, &ld);
189	if (ret)
190	return ret;
191
192	switch (ld->model) {
193	case ZBC_DM_HOST_AWARE:
194	*model = ZBD_HOST_AWARE;
195	break;
196	case ZBC_DM_HOST_MANAGED:
197	*model = ZBD_HOST_MANAGED;
198	break;
199	default:
200	*model = ZBD_NONE;
201	break;
202	}
203
204	return 0;
205	}
206
207	static int libzbc_report_zones(struct thread_data td, struct fio_file f,
208	uint64_t offset, struct zbd_zone *zbdz,
209	unsigned int nr_zones)
210	{
211	struct libzbc_data *ld;
212	uint64_t sector = offset >> 9;
213	struct zbc_zone *zones;
214	unsigned int i;
215	int ret;
216
217	ret = libzbc_open_dev(td, f, &ld);
218	if (ret)
219	return ret;
220
221	if (sector >= ld->nr_sectors)
222	return 0;
223
224	zones = calloc(nr_zones, sizeof(struct zbc_zone));
225	if (!zones) {
226	ret = -ENOMEM;
227	goto out;
228	}
229
230	ret = zbc_report_zones(ld->zdev, sector, ZBC_RO_ALL, zones, &nr_zones);
231	if (ret < 0) {
232	log_err("%s: zbc_report_zones failed, err=%d\n",
233	f->file_name, ret);
234	goto out;
235	}
236
237	for (i = 0; i < nr_zones; i++, zbdz++) {
238	zbdz->start = zones[i].zbz_start << 9;
239	zbdz->len = zones[i].zbz_length << 9;
240	zbdz->wp = zones[i].zbz_write_pointer << 9;
236d23a8 SK	241	/*
	242	* ZBC/ZAC do not define zone capacity, so use the zone size as
	243	* the zone capacity.
	244	*/
	245	zbdz->capacity = zbdz->len;
56a19325 DF	246
	247	switch (zones[i].zbz_type) {
	248	case ZBC_ZT_CONVENTIONAL:
	249	zbdz->type = ZBD_ZONE_TYPE_CNV;
	250	break;
	251	case ZBC_ZT_SEQUENTIAL_REQ:
	252	zbdz->type = ZBD_ZONE_TYPE_SWR;
	253	break;
	254	case ZBC_ZT_SEQUENTIAL_PREF:
	255	zbdz->type = ZBD_ZONE_TYPE_SWP;
	256	break;
	257	default:
	258	td_verror(td, errno, "invalid zone type");
	259	log_err("%s: invalid type for zone at sector %llu.\n",
	260	f->file_name, (unsigned long long)zbdz->start);
	261	ret = -EIO;
	262	goto out;
	263	}
	264
	265	switch (zones[i].zbz_condition) {
	266	case ZBC_ZC_NOT_WP:
	267	zbdz->cond = ZBD_ZONE_COND_NOT_WP;
	268	break;
	269	case ZBC_ZC_EMPTY:
	270	zbdz->cond = ZBD_ZONE_COND_EMPTY;
	271	break;
	272	case ZBC_ZC_IMP_OPEN:
	273	zbdz->cond = ZBD_ZONE_COND_IMP_OPEN;
	274	break;
	275	case ZBC_ZC_EXP_OPEN:
	276	zbdz->cond = ZBD_ZONE_COND_EXP_OPEN;
	277	break;
	278	case ZBC_ZC_CLOSED:
	279	zbdz->cond = ZBD_ZONE_COND_CLOSED;
	280	break;
	281	case ZBC_ZC_FULL:
	282	zbdz->cond = ZBD_ZONE_COND_FULL;
	283	break;
	284	case ZBC_ZC_RDONLY:
	285	case ZBC_ZC_OFFLINE:
	286	default:
	287	/* Treat all these conditions as offline (don't use!) */
	288	zbdz->cond = ZBD_ZONE_COND_OFFLINE;
59b67452	289	zbdz->wp = zbdz->start;
56a19325 DF	290	}
	291	}
	292
	293	ret = nr_zones;
	294	out:
	295	free(zones);
	296	return ret;
	297	}
	298
	299	static int libzbc_reset_wp(struct thread_data td, struct fio_file f,
	300	uint64_t offset, uint64_t length)
	301	{
	302	struct libzbc_data *ld = td->io_ops_data;
	303	uint64_t sector = offset >> 9;
	304	uint64_t end_sector = (offset + length) >> 9;
	305	unsigned int nr_zones;
	306	struct zbc_errno err;
	307	int i, ret;
	308
	309	assert(ld);
	310	assert(ld->zdev);
	311
	312	nr_zones = (length + td->o.zone_size - 1) / td->o.zone_size;
	313	if (!sector && end_sector >= ld->nr_sectors) {
	314	/* Reset all zones */
	315	ret = zbc_reset_zone(ld->zdev, 0, ZBC_OP_ALL_ZONES);
	316	if (ret)
	317	goto err;
	318
	319	return 0;
	320	}
	321
	322	for (i = 0; i < nr_zones; i++, sector += td->o.zone_size >> 9) {
	323	ret = zbc_reset_zone(ld->zdev, sector, 0);
	324	if (ret)
	325	goto err;
	326	}
	327
	328	return 0;
	329
	330	err:
	331	zbc_errno(ld->zdev, &err);
	332	td_verror(td, errno, "zbc_reset_zone failed");
	333	if (err.sk)
	334	log_err("%s: reset wp failed %s:%s\n",
	335	f->file_name,
	336	zbc_sk_str(err.sk), zbc_asc_ascq_str(err.asc_ascq));
	337	return -ret;
	338	}
	339
e8267436 NC	340	static int libzbc_get_max_open_zones(struct thread_data td, struct fio_file f,
	341	unsigned int *max_open_zones)
	342	{
	343	struct libzbc_data *ld;
	344	int ret;
	345
	346	ret = libzbc_open_dev(td, f, &ld);
	347	if (ret)
	348	return ret;
	349
	350	if (ld->max_open_seq_req == ZBC_NO_LIMIT)
	351	*max_open_zones = 0;
	352	else
	353	*max_open_zones = ld->max_open_seq_req;
	354
	355	return 0;
	356	}
	357
56a19325 DF	358	ssize_t libzbc_rw(struct thread_data td, struct io_u io_u)
	359	{
	360	struct libzbc_data *ld = td->io_ops_data;
	361	struct fio_file *f = io_u->file;
	362	uint64_t sector = io_u->offset >> 9;
	363	size_t count = io_u->xfer_buflen >> 9;
	364	struct zbc_errno err;
	365	ssize_t ret;
	366
	367	if (io_u->ddir == DDIR_WRITE)
	368	ret = zbc_pwrite(ld->zdev, io_u->xfer_buf, count, sector);
	369	else
	370	ret = zbc_pread(ld->zdev, io_u->xfer_buf, count, sector);
	371	if (ret == count)
	372	return ret;
	373
	374	if (ret > 0) {
	375	log_err("Short %s, len=%zu, ret=%zd\n",
	376	io_u->ddir == DDIR_READ ? "read" : "write",
	377	count << 9, ret << 9);
	378	return -EIO;
	379	}
	380
	381	/* I/O error */
	382	zbc_errno(ld->zdev, &err);
	383	td_verror(td, errno, "libzbc i/o failed");
	384	if (err.sk) {
	385	log_err("%s: op %u offset %llu+%llu failed (%s:%s), err %zd\n",
	386	f->file_name, io_u->ddir,
	387	io_u->offset, io_u->xfer_buflen,
	388	zbc_sk_str(err.sk),
	389	zbc_asc_ascq_str(err.asc_ascq), ret);
	390	} else {
	391	log_err("%s: op %u offset %llu+%llu failed, err %zd\n",
	392	f->file_name, io_u->ddir,
	393	io_u->offset, io_u->xfer_buflen, ret);
	394	}
	395
	396	return -EIO;
	397	}
	398
	399	static enum fio_q_status libzbc_queue(struct thread_data td, struct io_u io_u)
	400	{
	401	struct libzbc_data *ld = td->io_ops_data;
	402	struct fio_file *f = io_u->file;
	403	ssize_t ret = 0;
	404
	405	fio_ro_check(td, io_u);
	406
	407	dprint(FD_ZBD, "%p:%s: libzbc queue %llu\n",
	408	td, f->file_name, io_u->offset);
	409
	410	if (io_u->ddir == DDIR_READ \|\| io_u->ddir == DDIR_WRITE) {
	411	ret = libzbc_rw(td, io_u);
	412	} else if (ddir_sync(io_u->ddir)) {
	413	ret = zbc_flush(ld->zdev);
	414	if (ret)
	415	log_err("zbc_flush error %zd\n", ret);
	416	} else if (io_u->ddir != DDIR_TRIM) {
	417	log_err("Unsupported operation %u\n", io_u->ddir);
	418	ret = -EINVAL;
	419	}
	420	if (ret < 0)
	421	io_u->error = -ret;
422
423	return FIO_Q_COMPLETED;
424	}
425
5a8a6a03	426	FIO_STATIC struct ioengine_ops ioengine = {
56a19325 DF	427	.name = "libzbc",
	428	.version = FIO_IOOPS_VERSION,
	429	.open_file = libzbc_open_file,
	430	.close_file = libzbc_close_file,
	431	.cleanup = libzbc_cleanup,
	432	.invalidate = libzbc_invalidate,
	433	.get_file_size = libzbc_get_file_size,
	434	.get_zoned_model = libzbc_get_zoned_model,
	435	.report_zones = libzbc_report_zones,
	436	.reset_wp = libzbc_reset_wp,
e8267436	437	.get_max_open_zones = libzbc_get_max_open_zones,
56a19325 DF	438	.queue = libzbc_queue,
	439	.flags = FIO_SYNCIO \| FIO_NOEXTEND \| FIO_RAWIO,
	440	};
	441
	442	static void fio_init fio_libzbc_register(void)
	443	{
	444	register_ioengine(&ioengine);
	445	}
	446
	447	static void fio_exit fio_libzbc_unregister(void)
	448	{
	449	unregister_ioengine(&ioengine);
	450	}