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"
19 struct zbc_device *zdev;
20 enum zbc_dev_model model;
24 static int libzbc_get_dev_info(struct libzbc_data *ld, struct fio_file *f)
26 struct zbc_device_info *zinfo;
28 zinfo = calloc(1, sizeof(*zinfo));
32 zbc_get_device_info(ld->zdev, zinfo);
33 ld->model = zinfo->zbd_model;
34 ld->nr_sectors = zinfo->zbd_sectors;
36 dprint(FD_ZBD, "%s: vendor_id:%s, type: %s, model: %s\n",
37 f->file_name, zinfo->zbd_vendor_id,
38 zbc_device_type_str(zinfo->zbd_type),
39 zbc_device_model_str(zinfo->zbd_model));
46 static int libzbc_open_dev(struct thread_data *td, struct fio_file *f,
47 struct libzbc_data **p_ld)
49 struct libzbc_data *ld = td->io_ops_data;
50 int ret, flags = OS_O_DIRECT;
58 if (f->filetype != FIO_TYPE_BLOCK && f->filetype != FIO_TYPE_CHAR) {
59 td_verror(td, EINVAL, "wrong file type");
60 log_err("ioengine libzbc only works on block or character devices\n");
67 } else if (td_read(td)) {
68 if (f->filetype == FIO_TYPE_CHAR && !read_only)
72 } else if (td_trim(td)) {
73 td_verror(td, EINVAL, "libzbc does not support trim");
74 log_err("%s: libzbc does not support trim\n",
80 td_verror(td, EINVAL, "libzbc does not support O_ATOMIC");
81 log_err("%s: libzbc does not support O_ATOMIC\n",
86 ld = calloc(1, sizeof(*ld));
90 ret = zbc_open(f->file_name,
91 flags | ZBC_O_DRV_SCSI | ZBC_O_DRV_ATA, &ld->zdev);
93 log_err("%s: zbc_open() failed, err=%d\n",
98 ret = libzbc_get_dev_info(ld, f);
105 td->io_ops_data = ld;
113 static int libzbc_close_dev(struct thread_data *td)
115 struct libzbc_data *ld = td->io_ops_data;
118 td->io_ops_data = NULL;
121 ret = zbc_close(ld->zdev);
127 static int libzbc_open_file(struct thread_data *td, struct fio_file *f)
129 return libzbc_open_dev(td, f, NULL);
132 static int libzbc_close_file(struct thread_data *td, struct fio_file *f)
136 ret = libzbc_close_dev(td);
138 log_err("%s: close device failed err %d\n",
144 static void libzbc_cleanup(struct thread_data *td)
146 libzbc_close_dev(td);
149 static int libzbc_invalidate(struct thread_data *td, struct fio_file *f)
151 /* Passthrough IO do not cache data. Nothing to do */
155 static int libzbc_get_file_size(struct thread_data *td, struct fio_file *f)
157 struct libzbc_data *ld;
160 if (fio_file_size_known(f))
163 ret = libzbc_open_dev(td, f, &ld);
167 f->real_file_size = ld->nr_sectors << 9;
168 fio_file_set_size_known(f);
173 static int libzbc_get_zoned_model(struct thread_data *td, struct fio_file *f,
174 enum zbd_zoned_model *model)
176 struct libzbc_data *ld;
179 if (f->filetype != FIO_TYPE_BLOCK && f->filetype != FIO_TYPE_CHAR) {
184 ret = libzbc_open_dev(td, f, &ld);
189 case ZBC_DM_HOST_AWARE:
190 *model = ZBD_HOST_AWARE;
192 case ZBC_DM_HOST_MANAGED:
193 *model = ZBD_HOST_MANAGED;
203 static int libzbc_report_zones(struct thread_data *td, struct fio_file *f,
204 uint64_t offset, struct zbd_zone *zbdz,
205 unsigned int nr_zones)
207 struct libzbc_data *ld;
208 uint64_t sector = offset >> 9;
209 struct zbc_zone *zones;
213 ret = libzbc_open_dev(td, f, &ld);
217 if (sector >= ld->nr_sectors)
220 zones = calloc(nr_zones, sizeof(struct zbc_zone));
226 ret = zbc_report_zones(ld->zdev, sector, ZBC_RO_ALL, zones, &nr_zones);
228 log_err("%s: zbc_report_zones failed, err=%d\n",
233 for (i = 0; i < nr_zones; i++, zbdz++) {
234 zbdz->start = zones[i].zbz_start << 9;
235 zbdz->len = zones[i].zbz_length << 9;
236 zbdz->wp = zones[i].zbz_write_pointer << 9;
238 switch (zones[i].zbz_type) {
239 case ZBC_ZT_CONVENTIONAL:
240 zbdz->type = ZBD_ZONE_TYPE_CNV;
242 case ZBC_ZT_SEQUENTIAL_REQ:
243 zbdz->type = ZBD_ZONE_TYPE_SWR;
245 case ZBC_ZT_SEQUENTIAL_PREF:
246 zbdz->type = ZBD_ZONE_TYPE_SWP;
249 td_verror(td, errno, "invalid zone type");
250 log_err("%s: invalid type for zone at sector %llu.\n",
251 f->file_name, (unsigned long long)zbdz->start);
256 switch (zones[i].zbz_condition) {
258 zbdz->cond = ZBD_ZONE_COND_NOT_WP;
261 zbdz->cond = ZBD_ZONE_COND_EMPTY;
263 case ZBC_ZC_IMP_OPEN:
264 zbdz->cond = ZBD_ZONE_COND_IMP_OPEN;
266 case ZBC_ZC_EXP_OPEN:
267 zbdz->cond = ZBD_ZONE_COND_EXP_OPEN;
270 zbdz->cond = ZBD_ZONE_COND_CLOSED;
273 zbdz->cond = ZBD_ZONE_COND_FULL;
278 /* Treat all these conditions as offline (don't use!) */
279 zbdz->cond = ZBD_ZONE_COND_OFFLINE;
290 static int libzbc_reset_wp(struct thread_data *td, struct fio_file *f,
291 uint64_t offset, uint64_t length)
293 struct libzbc_data *ld = td->io_ops_data;
294 uint64_t sector = offset >> 9;
295 uint64_t end_sector = (offset + length) >> 9;
296 unsigned int nr_zones;
297 struct zbc_errno err;
303 nr_zones = (length + td->o.zone_size - 1) / td->o.zone_size;
304 if (!sector && end_sector >= ld->nr_sectors) {
305 /* Reset all zones */
306 ret = zbc_reset_zone(ld->zdev, 0, ZBC_OP_ALL_ZONES);
313 for (i = 0; i < nr_zones; i++, sector += td->o.zone_size >> 9) {
314 ret = zbc_reset_zone(ld->zdev, sector, 0);
322 zbc_errno(ld->zdev, &err);
323 td_verror(td, errno, "zbc_reset_zone failed");
325 log_err("%s: reset wp failed %s:%s\n",
327 zbc_sk_str(err.sk), zbc_asc_ascq_str(err.asc_ascq));
331 ssize_t libzbc_rw(struct thread_data *td, struct io_u *io_u)
333 struct libzbc_data *ld = td->io_ops_data;
334 struct fio_file *f = io_u->file;
335 uint64_t sector = io_u->offset >> 9;
336 size_t count = io_u->xfer_buflen >> 9;
337 struct zbc_errno err;
340 if (io_u->ddir == DDIR_WRITE)
341 ret = zbc_pwrite(ld->zdev, io_u->xfer_buf, count, sector);
343 ret = zbc_pread(ld->zdev, io_u->xfer_buf, count, sector);
348 log_err("Short %s, len=%zu, ret=%zd\n",
349 io_u->ddir == DDIR_READ ? "read" : "write",
350 count << 9, ret << 9);
355 zbc_errno(ld->zdev, &err);
356 td_verror(td, errno, "libzbc i/o failed");
358 log_err("%s: op %u offset %llu+%llu failed (%s:%s), err %zd\n",
359 f->file_name, io_u->ddir,
360 io_u->offset, io_u->xfer_buflen,
362 zbc_asc_ascq_str(err.asc_ascq), ret);
364 log_err("%s: op %u offset %llu+%llu failed, err %zd\n",
365 f->file_name, io_u->ddir,
366 io_u->offset, io_u->xfer_buflen, ret);
372 static enum fio_q_status libzbc_queue(struct thread_data *td, struct io_u *io_u)
374 struct libzbc_data *ld = td->io_ops_data;
375 struct fio_file *f = io_u->file;
378 fio_ro_check(td, io_u);
380 dprint(FD_ZBD, "%p:%s: libzbc queue %llu\n",
381 td, f->file_name, io_u->offset);
383 if (io_u->ddir == DDIR_READ || io_u->ddir == DDIR_WRITE) {
384 ret = libzbc_rw(td, io_u);
385 } else if (ddir_sync(io_u->ddir)) {
386 ret = zbc_flush(ld->zdev);
388 log_err("zbc_flush error %zd\n", ret);
389 } else if (io_u->ddir != DDIR_TRIM) {
390 log_err("Unsupported operation %u\n", io_u->ddir);
396 return FIO_Q_COMPLETED;
399 static struct ioengine_ops ioengine = {
401 .version = FIO_IOOPS_VERSION,
402 .open_file = libzbc_open_file,
403 .close_file = libzbc_close_file,
404 .cleanup = libzbc_cleanup,
405 .invalidate = libzbc_invalidate,
406 .get_file_size = libzbc_get_file_size,
407 .get_zoned_model = libzbc_get_zoned_model,
408 .report_zones = libzbc_report_zones,
409 .reset_wp = libzbc_reset_wp,
410 .queue = libzbc_queue,
411 .flags = FIO_SYNCIO | FIO_NOEXTEND | FIO_RAWIO,
414 static void fio_init fio_libzbc_register(void)
416 register_ioengine(&ioengine);
419 static void fio_exit fio_libzbc_unregister(void)
421 unregister_ioengine(&ioengine);