2 * Copyright (C) 2019 Western Digital Corporation or its affiliates.
4 * This file is released under the GPL.
7 * IO engine using libzbc library to talk to SMR disks.
12 #include <libzbc/zbc.h>
16 #include "zbd_types.h"
20 struct zbc_device *zdev;
21 enum zbc_dev_model model;
23 uint32_t max_open_seq_req;
26 static int libzbc_get_dev_info(struct libzbc_data *ld, struct fio_file *f)
28 struct zbc_device_info *zinfo;
30 zinfo = calloc(1, sizeof(*zinfo));
34 zbc_get_device_info(ld->zdev, zinfo);
35 ld->model = zinfo->zbd_model;
36 ld->nr_sectors = zinfo->zbd_sectors;
37 ld->max_open_seq_req = zinfo->zbd_max_nr_open_seq_req;
39 dprint(FD_ZBD, "%s: vendor_id:%s, type: %s, model: %s\n",
40 f->file_name, zinfo->zbd_vendor_id,
41 zbc_device_type_str(zinfo->zbd_type),
42 zbc_device_model_str(zinfo->zbd_model));
49 static int libzbc_open_dev(struct thread_data *td, struct fio_file *f,
50 struct libzbc_data **p_ld)
52 struct libzbc_data *ld = td->io_ops_data;
53 int ret, flags = OS_O_DIRECT;
61 if (f->filetype != FIO_TYPE_BLOCK && f->filetype != FIO_TYPE_CHAR) {
62 td_verror(td, EINVAL, "wrong file type");
63 log_err("ioengine libzbc only works on block or character devices\n");
67 if (td_write(td) || td_trim(td)) {
70 } else if (td_read(td)) {
74 ld = calloc(1, sizeof(*ld));
78 ret = zbc_open(f->file_name,
79 flags | ZBC_O_DRV_SCSI | ZBC_O_DRV_ATA,
82 log_err("%s: zbc_open() failed, err=%d\n",
87 ret = libzbc_get_dev_info(ld, f);
105 static int libzbc_close_dev(struct thread_data *td)
107 struct libzbc_data *ld = td->io_ops_data;
110 td->io_ops_data = NULL;
113 ret = zbc_close(ld->zdev);
119 static int libzbc_open_file(struct thread_data *td, struct fio_file *f)
121 return libzbc_open_dev(td, f, NULL);
124 static int libzbc_close_file(struct thread_data *td, struct fio_file *f)
128 ret = libzbc_close_dev(td);
130 log_err("%s: close device failed err %d\n",
136 static void libzbc_cleanup(struct thread_data *td)
138 libzbc_close_dev(td);
141 static int libzbc_invalidate(struct thread_data *td, struct fio_file *f)
143 /* Passthrough IO do not cache data. Nothing to do */
147 static int libzbc_get_file_size(struct thread_data *td, struct fio_file *f)
149 struct libzbc_data *ld;
152 if (fio_file_size_known(f))
155 ret = libzbc_open_dev(td, f, &ld);
159 f->real_file_size = ld->nr_sectors << 9;
160 fio_file_set_size_known(f);
165 static int libzbc_get_zoned_model(struct thread_data *td, struct fio_file *f,
166 enum zbd_zoned_model *model)
168 struct libzbc_data *ld;
171 if (f->filetype != FIO_TYPE_BLOCK && f->filetype != FIO_TYPE_CHAR)
174 ret = libzbc_open_dev(td, f, &ld);
179 case ZBC_DM_HOST_AWARE:
180 *model = ZBD_HOST_AWARE;
182 case ZBC_DM_HOST_MANAGED:
183 *model = ZBD_HOST_MANAGED;
193 static int libzbc_report_zones(struct thread_data *td, struct fio_file *f,
194 uint64_t offset, struct zbd_zone *zbdz,
195 unsigned int nr_zones)
197 struct libzbc_data *ld;
198 uint64_t sector = offset >> 9;
199 struct zbc_zone *zones;
203 ret = libzbc_open_dev(td, f, &ld);
207 if (sector >= ld->nr_sectors)
210 zones = calloc(nr_zones, sizeof(struct zbc_zone));
216 ret = zbc_report_zones(ld->zdev, sector, ZBC_RO_ALL, zones, &nr_zones);
218 log_err("%s: zbc_report_zones failed, err=%d\n",
223 for (i = 0; i < nr_zones; i++, zbdz++) {
224 zbdz->start = zones[i].zbz_start << 9;
225 zbdz->len = zones[i].zbz_length << 9;
226 zbdz->wp = zones[i].zbz_write_pointer << 9;
228 * ZBC/ZAC do not define zone capacity, so use the zone size as
231 zbdz->capacity = zbdz->len;
233 switch (zones[i].zbz_type) {
234 case ZBC_ZT_CONVENTIONAL:
235 zbdz->type = ZBD_ZONE_TYPE_CNV;
237 case ZBC_ZT_SEQUENTIAL_REQ:
238 zbdz->type = ZBD_ZONE_TYPE_SWR;
240 case ZBC_ZT_SEQUENTIAL_PREF:
241 zbdz->type = ZBD_ZONE_TYPE_SWP;
244 td_verror(td, errno, "invalid zone type");
245 log_err("%s: invalid type for zone at sector %llu.\n",
246 f->file_name, (unsigned long long)zbdz->start);
251 switch (zones[i].zbz_condition) {
253 zbdz->cond = ZBD_ZONE_COND_NOT_WP;
256 zbdz->cond = ZBD_ZONE_COND_EMPTY;
258 case ZBC_ZC_IMP_OPEN:
259 zbdz->cond = ZBD_ZONE_COND_IMP_OPEN;
261 case ZBC_ZC_EXP_OPEN:
262 zbdz->cond = ZBD_ZONE_COND_EXP_OPEN;
265 zbdz->cond = ZBD_ZONE_COND_CLOSED;
268 zbdz->cond = ZBD_ZONE_COND_FULL;
273 /* Treat all these conditions as offline (don't use!) */
274 zbdz->cond = ZBD_ZONE_COND_OFFLINE;
275 zbdz->wp = zbdz->start;
285 static int libzbc_reset_wp(struct thread_data *td, struct fio_file *f,
286 uint64_t offset, uint64_t length)
288 struct libzbc_data *ld = td->io_ops_data;
289 uint64_t sector = offset >> 9;
290 uint64_t end_sector = (offset + length) >> 9;
291 unsigned int nr_zones;
292 struct zbc_errno err;
298 nr_zones = (length + td->o.zone_size - 1) / td->o.zone_size;
299 if (!sector && end_sector >= ld->nr_sectors) {
300 /* Reset all zones */
301 ret = zbc_reset_zone(ld->zdev, 0, ZBC_OP_ALL_ZONES);
308 for (i = 0; i < nr_zones; i++, sector += td->o.zone_size >> 9) {
309 ret = zbc_reset_zone(ld->zdev, sector, 0);
317 zbc_errno(ld->zdev, &err);
318 td_verror(td, errno, "zbc_reset_zone failed");
320 log_err("%s: reset wp failed %s:%s\n",
322 zbc_sk_str(err.sk), zbc_asc_ascq_str(err.asc_ascq));
326 static int libzbc_finish_zone(struct thread_data *td, struct fio_file *f,
327 uint64_t offset, uint64_t length)
329 struct libzbc_data *ld = td->io_ops_data;
330 uint64_t sector = offset >> 9;
331 unsigned int nr_zones;
332 struct zbc_errno err;
338 nr_zones = (length + td->o.zone_size - 1) / td->o.zone_size;
339 assert(nr_zones > 0);
341 for (i = 0; i < nr_zones; i++, sector += td->o.zone_size >> 9) {
342 ret = zbc_finish_zone(ld->zdev, sector, 0);
350 zbc_errno(ld->zdev, &err);
351 td_verror(td, errno, "zbc_finish_zone failed");
353 log_err("%s: finish zone failed %s:%s\n",
355 zbc_sk_str(err.sk), zbc_asc_ascq_str(err.asc_ascq));
359 static int libzbc_get_max_open_zones(struct thread_data *td, struct fio_file *f,
360 unsigned int *max_open_zones)
362 struct libzbc_data *ld;
365 ret = libzbc_open_dev(td, f, &ld);
369 if (ld->max_open_seq_req == ZBC_NO_LIMIT)
372 *max_open_zones = ld->max_open_seq_req;
377 ssize_t libzbc_rw(struct thread_data *td, struct io_u *io_u)
379 struct libzbc_data *ld = td->io_ops_data;
380 struct fio_file *f = io_u->file;
381 uint64_t sector = io_u->offset >> 9;
382 size_t count = io_u->xfer_buflen >> 9;
383 struct zbc_errno err;
386 if (io_u->ddir == DDIR_WRITE)
387 ret = zbc_pwrite(ld->zdev, io_u->xfer_buf, count, sector);
389 ret = zbc_pread(ld->zdev, io_u->xfer_buf, count, sector);
394 log_err("Short %s, len=%zu, ret=%zd\n",
395 io_u->ddir == DDIR_READ ? "read" : "write",
396 count << 9, ret << 9);
401 zbc_errno(ld->zdev, &err);
402 td_verror(td, errno, "libzbc i/o failed");
404 log_err("%s: op %u offset %llu+%llu failed (%s:%s), err %zd\n",
405 f->file_name, io_u->ddir,
406 io_u->offset, io_u->xfer_buflen,
408 zbc_asc_ascq_str(err.asc_ascq), ret);
410 log_err("%s: op %u offset %llu+%llu failed, err %zd\n",
411 f->file_name, io_u->ddir,
412 io_u->offset, io_u->xfer_buflen, ret);
418 static enum fio_q_status libzbc_queue(struct thread_data *td, struct io_u *io_u)
420 struct libzbc_data *ld = td->io_ops_data;
421 struct fio_file *f = io_u->file;
424 fio_ro_check(td, io_u);
426 dprint(FD_ZBD, "%p:%s: libzbc queue %llu\n",
427 td, f->file_name, io_u->offset);
429 if (io_u->ddir == DDIR_READ || io_u->ddir == DDIR_WRITE) {
430 ret = libzbc_rw(td, io_u);
431 } else if (ddir_sync(io_u->ddir)) {
432 ret = zbc_flush(ld->zdev);
434 log_err("zbc_flush error %zd\n", ret);
435 } else if (io_u->ddir == DDIR_TRIM) {
436 ret = zbd_do_io_u_trim(td, io_u);
440 log_err("Unsupported operation %u\n", io_u->ddir);
446 return FIO_Q_COMPLETED;
449 FIO_STATIC struct ioengine_ops ioengine = {
451 .version = FIO_IOOPS_VERSION,
452 .open_file = libzbc_open_file,
453 .close_file = libzbc_close_file,
454 .cleanup = libzbc_cleanup,
455 .invalidate = libzbc_invalidate,
456 .get_file_size = libzbc_get_file_size,
457 .get_zoned_model = libzbc_get_zoned_model,
458 .report_zones = libzbc_report_zones,
459 .reset_wp = libzbc_reset_wp,
460 .get_max_open_zones = libzbc_get_max_open_zones,
461 .finish_zone = libzbc_finish_zone,
462 .queue = libzbc_queue,
463 .flags = FIO_SYNCIO | FIO_NOEXTEND | FIO_RAWIO,
466 static void fio_init fio_libzbc_register(void)
468 register_ioengine(&ioengine);
471 static void fio_exit fio_libzbc_unregister(void)
473 unregister_ioengine(&ioengine);