Recent changes (master)
The following changes since commit 07c8fe21021681f86fbfd3c3d63b88a5ebd4e557:
Merge branch 'master' of https://github.com/bvanassche/fio (2022-11-14 08:47:00 -0500)
are available in the Git repository at:
git://git.kernel.dk/fio.git master
for you to fetch changes up to ede04c27b618842e32b2a3349672f6b59a1697e1:
test: add large pattern test (2022-11-18 19:36:10 -0500)
----------------------------------------------------------------
Logan Gunthorpe (6):
cconv: Support pattern buffers of arbitrary size lib/pattern: Support NULL output buffer in parse_and_fill_pattern() lib/pattern: Support short repeated read calls when loading from file
options: Support arbitrarily long pattern buffers lib/pattern: Support binary pattern buffers on windows
test: add large pattern test
Shin'ichiro Kawasaki (13):
oslib: blkzoned: add blkzoned_finish_zone() helper function engines/libzbc: add libzbc_finish_zone() helper function
zbd: add zbd_zone_remainder() helper function
zbd: finish zones with remainder smaller than minimum write block size
zbd: allow block size not divisor of zone size
zbd, verify: verify before zone reset for zone_reset_threshold/frequency
zbd: fix zone reset condition for verify
zbd: prevent experimental verify with zonemode=zbd
t/zbd: fix test case #33 for block size unaligned to zone size t/zbd: modify test case #34 for block size unaligned to zone size t/zbd: add test case to check zone_reset_threshold/frequency with verify t/zbd: remove experimental_verify option from test case #54 t/zbd: add test case to check experimental_verify option
cconv.c | 86 +++++++++++++++++------- client.c | 17 +++-- engines/libzbc.c | 34 ++++++++++ gclient.c | 12 +++- ioengines.h | 2 + lib/pattern.c | 100 +++++++++++++++++++++++----- lib/pattern.h | 21 ++++-- options.c | 10 +-- oslib/blkzoned.h | 8 +++ oslib/linux-blkzoned.c | 37 +++++++++++ server.c | 23 ++++--- server.h | 2 +- stat.h | 1 - t/jobs/t0027.fio | 14 ++++ t/run-fio-tests.py | 29 ++++++++ t/zbd/test-zbd-support | 60 +++++++++++++---- thread_options.h | 15 +++-- verify.c | 6 +- zbd.c | 175 +++++++++++++++++++++++++++++++++---------------- zbd.h | 2 - 20 files changed, 507 insertions(+), 147 deletions(-) create mode 100644 t/jobs/t0027.fio
---
Diff of recent changes:
cconv.c +63 -23
@@ -48,14 +48,24 @@ static void free_thread_options_to_cpu(struct thread_options *o)free (o->profile);free (o->cgroup); +free (o->verify_pattern); +free (o->buffer_pattern); +for (i =0 ; i <DDIR_RWDIR_CNT ; i++) {free (o->bssplit[i]);free (o->zone_split[i]); } } -void convert_thread_options_to_cpu (struct thread_options *o, -struct thread_options_pack *top) +size_t thread_options_pack_size (struct thread_options *o) +{ +return sizeof (struct thread_options_pack ) + o->verify_pattern_bytes + + o->buffer_pattern_bytes; +} + +int convert_thread_options_to_cpu (struct thread_options *o, +struct thread_options_pack *top, +size_t top_sz) {int i, j;
@@ -171,10 +181,21 @@ void convert_thread_options_to_cpu(struct thread_options *o, o->verify_interval =le32_to_cpu (top->verify_interval); o->verify_offset =le32_to_cpu (top->verify_offset); -memcpy (o->verify_pattern, top->verify_pattern,MAX_PATTERN_SIZE ); -memcpy (o->buffer_pattern, top->buffer_pattern,MAX_PATTERN_SIZE ); - o->verify_pattern_bytes =le32_to_cpu (top->verify_pattern_bytes); + o->buffer_pattern_bytes =le32_to_cpu (top->buffer_pattern_bytes); +if (o->verify_pattern_bytes >=MAX_PATTERN_SIZE || + o->buffer_pattern_bytes >=MAX_PATTERN_SIZE || +thread_options_pack_size (o) > top_sz) +return -EINVAL ; + + o->verify_pattern =realloc (o->verify_pattern, + o->verify_pattern_bytes); + o->buffer_pattern =realloc (o->buffer_pattern, + o->buffer_pattern_bytes); +memcpy (o->verify_pattern, top->patterns, o->verify_pattern_bytes); +memcpy (o->buffer_pattern, &top->patterns[o->verify_pattern_bytes], + o->buffer_pattern_bytes); + o->verify_fatal =le32_to_cpu (top->verify_fatal); o->verify_dump =le32_to_cpu (top->verify_dump); o->verify_async =le32_to_cpu (top->verify_async);
@@ -268,7 +289,6 @@ void convert_thread_options_to_cpu(struct thread_options *o, o->zero_buffers =le32_to_cpu (top->zero_buffers); o->refill_buffers =le32_to_cpu (top->refill_buffers); o->scramble_buffers =le32_to_cpu (top->scramble_buffers); - o->buffer_pattern_bytes =le32_to_cpu (top->buffer_pattern_bytes); o->time_based =le32_to_cpu (top->time_based); o->disable_lat =le32_to_cpu (top->disable_lat); o->disable_clat =le32_to_cpu (top->disable_clat);
@@ -334,6 +354,8 @@ void convert_thread_options_to_cpu(struct thread_options *o,uint8_t verify_cpumask[FIO_TOP_STR_MAX ];uint8_t log_gz_cpumask[FIO_TOP_STR_MAX ];#endif + +return 0 ; } void convert_thread_options_to_net(struct thread_options_pack *top,
@@ -572,8 +594,9 @@ void convert_thread_options_to_net(struct thread_options_pack *top, top->max_latency[i] =__cpu_to_le64 (o->max_latency[i]); } -memcpy (top->verify_pattern, o->verify_pattern,MAX_PATTERN_SIZE ); -memcpy (top->buffer_pattern, o->buffer_pattern,MAX_PATTERN_SIZE ); +memcpy (top->patterns, o->verify_pattern, o->verify_pattern_bytes); +memcpy (&top->patterns[o->verify_pattern_bytes], o->buffer_pattern, + o->buffer_pattern_bytes); top->size =__cpu_to_le64 (o->size); top->io_size =__cpu_to_le64 (o->io_size);
@@ -620,7 +643,6 @@ void convert_thread_options_to_net(struct thread_options_pack *top,uint8_t verify_cpumask[FIO_TOP_STR_MAX ];uint8_t log_gz_cpumask[FIO_TOP_STR_MAX ];#endif - }/*
@@ -630,18 +652,36 @@ void convert_thread_options_to_net(struct thread_options_pack *top,*/ int fio_test_cconv (struct thread_options *__o) { -struct thread_options o; -struct thread_options_pack top1, top2; - -memset (&top1,0 ,sizeof (top1)); -memset (&top2,0 ,sizeof (top2)); - -convert_thread_options_to_net (&top1, __o); -memset (&o,0 ,sizeof (o)); -convert_thread_options_to_cpu (&o, &top1); -convert_thread_options_to_net (&top2, &o); - -free_thread_options_to_cpu (&o); - -return memcmp (&top1, &top2,sizeof (top1)); +struct thread_options o1 = *__o, o2; +struct thread_options_pack *top1, *top2; +size_t top_sz; +int ret; + + o1.verify_pattern_bytes =61 ; + o1.verify_pattern =malloc (o1.verify_pattern_bytes); +memset (o1.verify_pattern,'V' , o1.verify_pattern_bytes); + o1.buffer_pattern_bytes =15 ; + o1.buffer_pattern =malloc (o1.buffer_pattern_bytes); +memset (o1.buffer_pattern,'B' , o1.buffer_pattern_bytes); + + top_sz =thread_options_pack_size (&o1); + top1 =calloc (1 , top_sz); + top2 =calloc (1 , top_sz); + +convert_thread_options_to_net (top1, &o1); +memset (&o2,0 ,sizeof (o2)); + ret =convert_thread_options_to_cpu (&o2, top1, top_sz); +if (ret) + goto out; + +convert_thread_options_to_net (top2, &o2); + ret =memcmp (top1, top2, top_sz); + +out: +free_thread_options_to_cpu (&o2); +free (top2); +free (top1); +free (o1.buffer_pattern); +free (o1.verify_pattern); +return ret; }
client.c +12 -5
@@ -922,13 +922,20 @@ int fio_clients_send_ini(const char *filename)int fio_client_update_options (struct fio_client *client,struct thread_options *o,uint64_t *tag) { -struct cmd_add_job_pdu pdu; +size_t cmd_sz = offsetof(struct cmd_add_job_pdu , top) + +thread_options_pack_size (o); +struct cmd_add_job_pdu *pdu; +int ret; - pdu.thread_number =cpu_to_le32 (client->thread_number); - pdu.groupid =cpu_to_le32 (client->groupid); -convert_thread_options_to_net (&pdu.top, o); + pdu =malloc (cmd_sz); + pdu->thread_number =cpu_to_le32 (client->thread_number); + pdu->groupid =cpu_to_le32 (client->groupid); +convert_thread_options_to_net (&pdu->top, o); -return fio_net_send_cmd (client->fd,FIO_NET_CMD_UPDATE_JOB , &pdu,sizeof (pdu), tag, &client->cmd_list); + ret =fio_net_send_cmd (client->fd,FIO_NET_CMD_UPDATE_JOB , pdu, + cmd_sz, tag, &client->cmd_list); +free (pdu); +return ret; }static void convert_io_stat (struct io_stat *dst,struct io_stat *src)
engines/libzbc.c +34 -0
@@ -332,6 +332,39 @@ err:return -ret; } +static int libzbc_finish_zone (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 ; +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; +assert (nr_zones >0 ); + +for (i =0 ; i < nr_zones; i++, sector += td->o.zone_size >>9 ) { + ret =zbc_finish_zone (ld->zdev, sector,0 ); +if (ret) + goto err; + } + +return 0 ; + +err: +zbc_errno (ld->zdev, &err); +td_verror (td, errno,"zbc_finish_zone failed" ); +if (err.sk) +log_err ("%s: finish zone 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) {
@@ -434,6 +467,7 @@ FIO_STATIC struct ioengine_ops ioengine = { .report_zones = libzbc_report_zones, .reset_wp = libzbc_reset_wp, .get_max_open_zones = libzbc_get_max_open_zones, + .finish_zone = libzbc_finish_zone, .queue = libzbc_queue, .flags = FIO_SYNCIO | FIO_NOEXTEND | FIO_RAWIO, };
gclient.c +9 -3
@@ -553,12 +553,15 @@ static void gfio_quit_op(struct fio_client *client, struct fio_net_cmd *cmd) }static struct thread_options *gfio_client_add_job (struct gfio_client *gc, -struct thread_options_pack *top) +struct thread_options_pack *top,size_t top_sz) {struct gfio_client_options *gco; gco =calloc (1 ,sizeof (*gco)); -convert_thread_options_to_cpu (&gco->o, top); +if (convert_thread_options_to_cpu (&gco->o, top, top_sz)) { +dprint (FD_NET ,"client: failed parsing add_job command\n" ); +return NULL ; + }INIT_FLIST_HEAD (&gco->list);flist_add_tail (&gco->list, &gc->o_list); gc->o_list_nr =1 ;
@@ -577,7 +580,10 @@ static void gfio_add_job_op(struct fio_client *client, struct fio_net_cmd *cmd) p->thread_number =le32_to_cpu (p->thread_number); p->groupid =le32_to_cpu (p->groupid); - o =gfio_client_add_job (gc, &p->top); + o =gfio_client_add_job (gc, &p->top, + cmd->pdu_len - offsetof(struct cmd_add_job_pdu , top)); +if (o ==NULL ) +return ;gdk_threads_enter ();
ioengines.h +2 -0
@@ -61,6 +61,8 @@ struct ioengine_ops { uint64_t, uint64_t);int (*get_max_open_zones)(struct thread_data *,struct fio_file *,unsigned int *); +int (*finish_zone)(struct thread_data *,struct fio_file *, +uint64_t ,uint64_t );int option_struct_size;struct fio_option *options; };
lib/pattern.c +84 -16
166 lines not on this page · raw message
lib/pattern.h +16 -5
@@ -1,6 +1,19 @@#ifndef FIO_PARSE_PATTERN_H #define FIO_PARSE_PATTERN_H +/* +* The pattern is dynamically allocated, but that doesn't mean there +* are not limits. The network protocol has a limit of +* FIO_SERVER_MAX_CMD_MB and potentially two patterns must fit in there. +* There's also a need to verify the incoming data from the network and +* this provides a sensible check. +* +* 128MiB is an arbitrary limit that meets these criteria. The patterns +* tend to be truncated at the IO size anyway and IO sizes that large +* aren't terribly practical. +*/ +#define MAX_PATTERN_SIZE (128 << 20) +/** * Pattern format description. The input for 'parse_pattern'. * Describes format with its name and callback, which should
@@ -21,11 +34,9 @@ struct pattern_fmt {const struct pattern_fmt_desc *desc; }; -int parse_and_fill_pattern (const char *in,unsigned int in_len, -char *out,unsigned int out_len, -const struct pattern_fmt_desc *fmt_desc, -struct pattern_fmt *fmt, -unsigned int *fmt_sz_out); +int parse_and_fill_pattern_alloc (const char *in,unsigned int in_len, +char **out,const struct pattern_fmt_desc *fmt_desc, +struct pattern_fmt *fmt,unsigned int *fmt_sz_out); int paste_format_inplace(char *pattern, unsigned int pattern_len, struct pattern_fmt *fmt, unsigned int fmt_sz,
options.c +5 -5
@@ -1488,8 +1488,8 @@ static int str_buffer_pattern_cb(void *data, const char *input)int ret;/* FIXME: for now buffer pattern does not support formats */ - ret =parse_and_fill_pattern (input,strlen (input), td->o.buffer_pattern, -MAX_PATTERN_SIZE ,NULL ,NULL ,NULL ); + ret =parse_and_fill_pattern_alloc (input,strlen (input), + &td->o.buffer_pattern,NULL ,NULL ,NULL );if (ret <0 )return 1 ;
@@ -1537,9 +1537,9 @@ static int str_verify_pattern_cb(void *data, const char *input)int ret; td->o.verify_fmt_sz =FIO_ARRAY_SIZE (td->o.verify_fmt); - ret =parse_and_fill_pattern (input,strlen (input), td->o.verify_pattern, -MAX_PATTERN_SIZE , fmt_desc, - td->o.verify_fmt, &td->o.verify_fmt_sz); + ret =parse_and_fill_pattern_alloc (input,strlen (input), + &td->o.verify_pattern, fmt_desc, td->o.verify_fmt, + &td->o.verify_fmt_sz);if (ret <0 )return 1 ;
oslib/blkzoned.h +8 -0
@@ -18,6 +18,8 @@ extern int blkzoned_reset_wp(struct thread_data *td, struct fio_file *f, uint64_t offset, uint64_t length);extern int blkzoned_get_max_open_zones (struct thread_data *td,struct fio_file *f,unsigned int *max_open_zones); +extern int blkzoned_finish_zone (struct thread_data *td,struct fio_file *f, +uint64_t offset,uint64_t length);#else /* * Define stubs for systems that do not have zoned block device support.
@@ -51,6 +53,12 @@ static inline int blkzoned_get_max_open_zones(struct thread_data *td, struct fio {return -EIO ; } +static inline int blkzoned_finish_zone (struct thread_data *td, +struct fio_file *f, +uint64_t offset,uint64_t length) +{ +return -EIO ; +}#endif #endif /* FIO_BLKZONED_H */
oslib/linux-blkzoned.c +37 -0
@@ -308,3 +308,40 @@ int blkzoned_reset_wp(struct thread_data *td, struct fio_file *f,return ret; } + +int blkzoned_finish_zone (struct thread_data *td,struct fio_file *f, +uint64_t offset,uint64_t length) +{ +#ifdef BLKFINISHZONE +struct blk_zone_range zr = { + .sector = offset >>9 , + .nr_sectors = length >>9 , + }; +int 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; + } + +if (ioctl (fd,BLKFINISHZONE , &zr) <0 ) + ret = -errno; + +if (f->fd <0 ) +close (fd); + +return ret; +#else +/* +* Kernel versions older than 5.5 does not support BLKFINISHZONE. These +* old kernels assumed zones are closed automatically at max_open_zones +* limit. Also they did not support max_active_zones limit. Then there +* was no need to finish zones to avoid errors caused by max_open_zones +* or max_active_zones. For those old versions, just do nothing. +*/ +return 0 ; +#endif +}
server.c +14 -9
@@ -1082,6 +1082,7 @@ static int handle_update_job_cmd(struct fio_net_cmd *cmd)struct cmd_add_job_pdu *pdu = (struct cmd_add_job_pdu *) cmd->payload;struct thread_data *td;uint32_t tnumber; +int ret; tnumber =le32_to_cpu (pdu->thread_number);
@@ -1093,8 +1094,9 @@ static int handle_update_job_cmd(struct fio_net_cmd *cmd) } td =tnumber_to_td (tnumber); -convert_thread_options_to_cpu (&td->o, &pdu->top); -send_update_job_reply (cmd->tag,0 ); + ret =convert_thread_options_to_cpu (&td->o, &pdu->top, + cmd->pdu_len - offsetof(struct cmd_add_job_pdu , top)); +send_update_job_reply (cmd->tag, ret);return 0 ; }
@@ -2323,15 +2325,18 @@ int fio_send_iolog(struct thread_data *td, struct io_log *log, const char *name)void fio_server_send_add_job (struct thread_data *td) { -struct cmd_add_job_pdu pdu = { - .thread_number =cpu_to_le32 (td->thread_number), - .groupid =cpu_to_le32 (td->groupid), - }; +struct cmd_add_job_pdu *pdu; +size_t cmd_sz = offsetof(struct cmd_add_job_pdu , top) + +thread_options_pack_size (&td->o); -convert_thread_options_to_net (&pdu.top, &td->o); + pdu =malloc (cmd_sz); + pdu->thread_number =cpu_to_le32 (td->thread_number); + pdu->groupid =cpu_to_le32 (td->groupid); -fio_net_queue_cmd (FIO_NET_CMD_ADD_JOB , &pdu,sizeof (pdu),NULL , -SK_F_COPY ); +convert_thread_options_to_net (&pdu->top, &td->o); + +fio_net_queue_cmd (FIO_NET_CMD_ADD_JOB , pdu, cmd_sz,NULL ,SK_F_COPY ); +free (pdu); }void fio_server_send_start (struct thread_data *td)
server.h +1 -1
@@ -51,7 +51,7 @@ struct fio_net_cmd_reply { };enum { -FIO_SERVER_VER =97 , +FIO_SERVER_VER =98 ,FIO_SERVER_MAX_FRAGMENT_PDU =1024 ,FIO_SERVER_MAX_CMD_MB =2048 ,
stat.h +0 -1
@@ -142,7 +142,6 @@ enum block_info_state { BLOCK_STATE_COUNT, }; -#define MAX_PATTERN_SIZE 512#define FIO_JOBNAME_SIZE 128#define FIO_JOBDESC_SIZE 256#define FIO_VERROR_SIZE 128
t/jobs/t0027.fio new file +14 -0
@@ -0,0 +1,14 @@ +[global] +filename=t0027file +size=16k +bs=16k + +[write_job] +readwrite=write +buffer_pattern='t0027.pattern' + +[read_job] +stonewall=1 +readwrite=read +verify=pattern +verify_pattern='t0027.pattern'
t/run-fio-tests.py +29 -0
@@ -799,6 +799,26 @@ class FioJobTest_t0025(FioJobTest): if self.json_data['jobs'][0]['read']['io_kbytes'] != 128: self.passed = False +class FioJobTest_t0027(FioJobTest): + def setup(self, *args, **kws): + super(FioJobTest_t0027, self).setup(*args, **kws) + self.pattern_file = os.path.join(self.test_dir, "t0027.pattern") + self.output_file = os.path.join(self.test_dir, "t0027file") + self.pattern = os.urandom(16 << 10) + with open(self.pattern_file, "wb") as f: + f.write(self.pattern) + + def check_result(self): + super(FioJobTest_t0027, self).check_result() + + if not self.passed: + return + + with open(self.output_file, "rb") as f: + data = f.read() + + if data != self.pattern: + self.passed = False class FioJobTest_iops_rate(FioJobTest): """Test consists of fio test job t0009
@@ -1214,6 +1234,15 @@ TEST_LIST = [ 'pre_success': None, 'requirements': [Requirements.not_windows], }, + { + 'test_id': 27, + 'test_class': FioJobTest_t0027, + 'job': 't0027.fio', + 'success': SUCCESS_DEFAULT, + 'pre_job': None, + 'pre_success': None, + 'requirements': [], + }, { 'test_id': 1000, 'test_class': FioExeTest,
t/zbd/test-zbd-support +48 -12
88 lines not on this page · raw message
thread_options.h +10 -5
@@ -144,7 +144,7 @@ struct thread_options {unsigned int do_verify;unsigned int verify_interval;unsigned int verify_offset; -char verify_pattern[MAX_PATTERN_SIZE ]; +char *verify_pattern;unsigned int verify_pattern_bytes;struct pattern_fmt verify_fmt[8 ];unsigned int verify_fmt_sz;
@@ -256,7 +256,7 @@ struct thread_options {unsigned int zero_buffers;unsigned int refill_buffers;unsigned int scramble_buffers; -char buffer_pattern[MAX_PATTERN_SIZE ]; +char *buffer_pattern;unsigned int buffer_pattern_bytes;unsigned int compress_percentage;unsigned int compress_chunk;
@@ -464,7 +464,6 @@ struct thread_options_pack {uint32_t do_verify;uint32_t verify_interval;uint32_t verify_offset; -uint8_t verify_pattern[MAX_PATTERN_SIZE ];uint32_t verify_pattern_bytes;uint32_t verify_fatal;uint32_t verify_dump;
@@ -572,7 +571,6 @@ struct thread_options_pack {uint32_t zero_buffers;uint32_t refill_buffers;uint32_t scramble_buffers; -uint8_t buffer_pattern[MAX_PATTERN_SIZE ];uint32_t buffer_pattern_bytes;uint32_t compress_percentage;uint32_t compress_chunk;
@@ -699,9 +697,16 @@ struct thread_options_pack {uint32_t log_entries;uint32_t log_prio; + +/* +* verify_pattern followed by buffer_pattern from the unpacked struct +*/ +uint8_t patterns[]; } __attribute__((packed)); -extern void convert_thread_options_to_cpu (struct thread_options *o,struct thread_options_pack *top); +extern int convert_thread_options_to_cpu (struct thread_options *o, +struct thread_options_pack *top,size_t top_sz); +extern size_t thread_options_pack_size (struct thread_options *o);extern void convert_thread_options_to_net (struct thread_options_pack *top,struct thread_options *);extern int fio_test_cconv (struct thread_options *);extern void options_default_fill (struct thread_options *o);
verify.c +4 -2
@@ -917,9 +917,11 @@ int verify_io_u(struct thread_data *td, struct io_u **io_u_ptr) hdr = p;/* -* Make rand_seed check pass when have verify_backlog. +* Make rand_seed check pass when have verify_backlog or +* zone reset frequency for zonemode=zbd. */ -if (!td_rw (td) || (td->flags &TD_F_VER_BACKLOG )) +if (!td_rw (td) || (td->flags &TD_F_VER_BACKLOG ) || + td->o.zrf.u.f) io_u->rand_seed = hdr->rand_seed;if (td->o.verify !=VERIFY_PATTERN_NO_HDR ) {
zbd.c +117 -58
278 lines not on this page · raw message
zbd.h +0 -2
@@ -25,7 +25,6 @@ enum io_u_action {* @start: zone start location (bytes) * @wp: zone write pointer location (bytes) * @capacity: maximum size usable from the start of a zone (bytes) -* @verify_block: number of blocks that have been verified for this zone * @mutex: protects the modifiable members in this structure * @type: zone type (BLK_ZONE_TYPE_*) * @cond: zone state (BLK_ZONE_COND_*)
@@ -39,7 +38,6 @@ struct fio_zone_info {uint64_t start;uint64_t wp;uint64_t capacity; -uint32_t verify_block; enum zbd_zone_type type:2; enum zbd_zone_cond cond:4; unsigned int has_wp:1;