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