options: clean number of zones if we fail parsing
[fio.git] / options.c
CommitLineData
214e1eca
JA
1#include <stdio.h>
2#include <stdlib.h>
3#include <unistd.h>
4#include <ctype.h>
5#include <string.h>
214e1eca 6#include <assert.h>
921c766f 7#include <libgen.h>
5921e80c
JA
8#include <fcntl.h>
9#include <sys/types.h>
10#include <sys/stat.h>
e13c3b50 11#include <netinet/in.h>
214e1eca
JA
12
13#include "fio.h"
4f5af7b2 14#include "verify.h"
214e1eca 15#include "parse.h"
eef32359 16#include "lib/fls.h"
61b9861d 17#include "lib/pattern.h"
9f988e2e 18#include "options.h"
d220c761 19#include "optgroup.h"
214e1eca 20
e13c3b50 21char client_sockaddr_str[INET6_ADDRSTRLEN] = { 0 };
72a703da 22
214e1eca
JA
23/*
24 * Check if mmap/mmaphuge has a :/foo/bar/file at the end. If so, return that.
25 */
26static char *get_opt_postfix(const char *str)
27{
28 char *p = strstr(str, ":");
29
30 if (!p)
31 return NULL;
32
33 p++;
34 strip_blank_front(&p);
35 strip_blank_end(p);
36 return strdup(p);
37}
38
564ca972
JA
39static int bs_cmp(const void *p1, const void *p2)
40{
41 const struct bssplit *bsp1 = p1;
42 const struct bssplit *bsp2 = p2;
43
a7cd478d 44 return (int) bsp1->perc - (int) bsp2->perc;
564ca972
JA
45}
46
83ea422a 47static int bssplit_ddir(struct thread_options *o, int ddir, char *str)
564ca972 48{
720e84ad 49 struct bssplit *bssplit;
564ca972
JA
50 unsigned int i, perc, perc_missing;
51 unsigned int max_bs, min_bs;
52 long long val;
720e84ad 53 char *fname;
564ca972 54
83ea422a 55 o->bssplit_nr[ddir] = 4;
720e84ad 56 bssplit = malloc(4 * sizeof(struct bssplit));
564ca972
JA
57
58 i = 0;
59 max_bs = 0;
60 min_bs = -1;
61 while ((fname = strsep(&str, ":")) != NULL) {
62 char *perc_str;
63
64 if (!strlen(fname))
65 break;
66
67 /*
68 * grow struct buffer, if needed
69 */
83ea422a
JA
70 if (i == o->bssplit_nr[ddir]) {
71 o->bssplit_nr[ddir] <<= 1;
72 bssplit = realloc(bssplit, o->bssplit_nr[ddir]
5ec10eaa 73 * sizeof(struct bssplit));
564ca972
JA
74 }
75
76 perc_str = strstr(fname, "/");
77 if (perc_str) {
78 *perc_str = '\0';
79 perc_str++;
80 perc = atoi(perc_str);
81 if (perc > 100)
82 perc = 100;
83 else if (!perc)
d711cce5 84 perc = -1U;
564ca972 85 } else
d711cce5 86 perc = -1U;
564ca972 87
88038bc7 88 if (str_to_decimal(fname, &val, 1, o, 0, 0)) {
564ca972 89 log_err("fio: bssplit conversion failed\n");
d8b97c8e 90 free(bssplit);
564ca972
JA
91 return 1;
92 }
93
94 if (val > max_bs)
95 max_bs = val;
96 if (val < min_bs)
97 min_bs = val;
98
720e84ad
JA
99 bssplit[i].bs = val;
100 bssplit[i].perc = perc;
564ca972
JA
101 i++;
102 }
103
83ea422a 104 o->bssplit_nr[ddir] = i;
564ca972
JA
105
106 /*
107 * Now check if the percentages add up, and how much is missing
108 */
109 perc = perc_missing = 0;
83ea422a 110 for (i = 0; i < o->bssplit_nr[ddir]; i++) {
720e84ad 111 struct bssplit *bsp = &bssplit[i];
564ca972 112
d711cce5 113 if (bsp->perc == -1U)
564ca972
JA
114 perc_missing++;
115 else
116 perc += bsp->perc;
117 }
118
40bafa33 119 if (perc > 100 && perc_missing > 1) {
564ca972 120 log_err("fio: bssplit percentages add to more than 100%%\n");
720e84ad 121 free(bssplit);
564ca972
JA
122 return 1;
123 }
d711cce5 124
564ca972
JA
125 /*
126 * If values didn't have a percentage set, divide the remains between
127 * them.
128 */
129 if (perc_missing) {
d711cce5 130 if (perc_missing == 1 && o->bssplit_nr[ddir] == 1)
40bafa33 131 perc = 100;
83ea422a 132 for (i = 0; i < o->bssplit_nr[ddir]; i++) {
720e84ad 133 struct bssplit *bsp = &bssplit[i];
564ca972 134
d711cce5 135 if (bsp->perc == -1U)
564ca972
JA
136 bsp->perc = (100 - perc) / perc_missing;
137 }
138 }
139
83ea422a
JA
140 o->min_bs[ddir] = min_bs;
141 o->max_bs[ddir] = max_bs;
564ca972
JA
142
143 /*
144 * now sort based on percentages, for ease of lookup
145 */
83ea422a
JA
146 qsort(bssplit, o->bssplit_nr[ddir], sizeof(struct bssplit), bs_cmp);
147 o->bssplit[ddir] = bssplit;
720e84ad 148 return 0;
720e84ad
JA
149}
150
151static int str_bssplit_cb(void *data, const char *input)
152{
153 struct thread_data *td = data;
6eaf09d6 154 char *str, *p, *odir, *ddir;
720e84ad
JA
155 int ret = 0;
156
52c0cea3
JA
157 if (parse_dryrun())
158 return 0;
159
720e84ad
JA
160 p = str = strdup(input);
161
162 strip_blank_front(&str);
163 strip_blank_end(str);
164
165 odir = strchr(str, ',');
166 if (odir) {
6eaf09d6
SL
167 ddir = strchr(odir + 1, ',');
168 if (ddir) {
d79db122 169 ret = bssplit_ddir(&td->o, DDIR_TRIM, ddir + 1);
6eaf09d6
SL
170 if (!ret)
171 *ddir = '\0';
172 } else {
173 char *op;
174
175 op = strdup(odir + 1);
d79db122 176 ret = bssplit_ddir(&td->o, DDIR_TRIM, op);
6eaf09d6
SL
177
178 free(op);
179 }
d79db122
JA
180 if (!ret)
181 ret = bssplit_ddir(&td->o, DDIR_WRITE, odir + 1);
720e84ad
JA
182 if (!ret) {
183 *odir = '\0';
83ea422a 184 ret = bssplit_ddir(&td->o, DDIR_READ, str);
720e84ad
JA
185 }
186 } else {
187 char *op;
188
189 op = strdup(str);
d79db122 190 ret = bssplit_ddir(&td->o, DDIR_WRITE, op);
6eaf09d6 191 free(op);
720e84ad 192
6eaf09d6
SL
193 if (!ret) {
194 op = strdup(str);
d79db122 195 ret = bssplit_ddir(&td->o, DDIR_TRIM, op);
6eaf09d6
SL
196 free(op);
197 }
f0c9c217
JA
198 if (!ret)
199 ret = bssplit_ddir(&td->o, DDIR_READ, str);
720e84ad 200 }
564ca972
JA
201
202 free(p);
720e84ad 203 return ret;
564ca972
JA
204}
205
8b28bd41
DM
206static int str2error(char *str)
207{
a94eb99a 208 const char *err[] = { "EPERM", "ENOENT", "ESRCH", "EINTR", "EIO",
8b28bd41
DM
209 "ENXIO", "E2BIG", "ENOEXEC", "EBADF",
210 "ECHILD", "EAGAIN", "ENOMEM", "EACCES",
211 "EFAULT", "ENOTBLK", "EBUSY", "EEXIST",
212 "EXDEV", "ENODEV", "ENOTDIR", "EISDIR",
213 "EINVAL", "ENFILE", "EMFILE", "ENOTTY",
214 "ETXTBSY","EFBIG", "ENOSPC", "ESPIPE",
a94eb99a 215 "EROFS","EMLINK", "EPIPE", "EDOM", "ERANGE" };
8b28bd41
DM
216 int i = 0, num = sizeof(err) / sizeof(void *);
217
a94eb99a 218 while (i < num) {
8b28bd41
DM
219 if (!strcmp(err[i], str))
220 return i + 1;
221 i++;
222 }
223 return 0;
224}
225
226static int ignore_error_type(struct thread_data *td, int etype, char *str)
227{
228 unsigned int i;
229 int *error;
230 char *fname;
231
232 if (etype >= ERROR_TYPE_CNT) {
233 log_err("Illegal error type\n");
234 return 1;
235 }
236
237 td->o.ignore_error_nr[etype] = 4;
238 error = malloc(4 * sizeof(struct bssplit));
239
240 i = 0;
241 while ((fname = strsep(&str, ":")) != NULL) {
242
243 if (!strlen(fname))
244 break;
245
246 /*
247 * grow struct buffer, if needed
248 */
249 if (i == td->o.ignore_error_nr[etype]) {
250 td->o.ignore_error_nr[etype] <<= 1;
251 error = realloc(error, td->o.ignore_error_nr[etype]
252 * sizeof(int));
253 }
254 if (fname[0] == 'E') {
255 error[i] = str2error(fname);
256 } else {
257 error[i] = atoi(fname);
258 if (error[i] < 0)
1616e025 259 error[i] = -error[i];
8b28bd41
DM
260 }
261 if (!error[i]) {
262 log_err("Unknown error %s, please use number value \n",
263 fname);
0fddbf7a 264 free(error);
8b28bd41
DM
265 return 1;
266 }
267 i++;
268 }
269 if (i) {
270 td->o.continue_on_error |= 1 << etype;
271 td->o.ignore_error_nr[etype] = i;
272 td->o.ignore_error[etype] = error;
c7b086be
JA
273 } else
274 free(error);
275
8b28bd41
DM
276 return 0;
277
278}
279
280static int str_ignore_error_cb(void *data, const char *input)
281{
282 struct thread_data *td = data;
283 char *str, *p, *n;
284 int type = 0, ret = 1;
52c0cea3
JA
285
286 if (parse_dryrun())
287 return 0;
288
8b28bd41
DM
289 p = str = strdup(input);
290
291 strip_blank_front(&str);
292 strip_blank_end(str);
293
294 while (p) {
295 n = strchr(p, ',');
296 if (n)
297 *n++ = '\0';
298 ret = ignore_error_type(td, type, p);
299 if (ret)
300 break;
301 p = n;
302 type++;
303 }
304 free(str);
305 return ret;
306}
307
211097b2
JA
308static int str_rw_cb(void *data, const char *str)
309{
310 struct thread_data *td = data;
83ea422a 311 struct thread_options *o = &td->o;
27ca949f 312 char *nr;
211097b2 313
52c0cea3
JA
314 if (parse_dryrun())
315 return 0;
316
83ea422a
JA
317 o->ddir_seq_nr = 1;
318 o->ddir_seq_add = 0;
059b0802 319
27ca949f 320 nr = get_opt_postfix(str);
059b0802
JA
321 if (!nr)
322 return 0;
323
324 if (td_random(td))
83ea422a 325 o->ddir_seq_nr = atoi(nr);
059b0802
JA
326 else {
327 long long val;
328
88038bc7 329 if (str_to_decimal(nr, &val, 1, o, 0, 0)) {
059b0802
JA
330 log_err("fio: rw postfix parsing failed\n");
331 free(nr);
332 return 1;
333 }
334
83ea422a 335 o->ddir_seq_add = val;
182ec6ee 336 }
211097b2 337
059b0802 338 free(nr);
211097b2
JA
339 return 0;
340}
341
214e1eca
JA
342static int str_mem_cb(void *data, const char *mem)
343{
344 struct thread_data *td = data;
345
217b0f1d
LG
346 if (td->o.mem_type == MEM_MMAPHUGE || td->o.mem_type == MEM_MMAP ||
347 td->o.mem_type == MEM_MMAPSHARED)
836fcc0f 348 td->o.mmapfile = get_opt_postfix(mem);
214e1eca
JA
349
350 return 0;
351}
352
c223da83
JA
353static int fio_clock_source_cb(void *data, const char *str)
354{
355 struct thread_data *td = data;
356
357 fio_clock_source = td->o.clocksource;
fa80feae 358 fio_clock_source_set = 1;
01423eae 359 fio_clock_init();
c223da83
JA
360 return 0;
361}
362
85bc833b 363static int str_rwmix_read_cb(void *data, unsigned long long *val)
cb499fc4
JA
364{
365 struct thread_data *td = data;
366
367 td->o.rwmix[DDIR_READ] = *val;
368 td->o.rwmix[DDIR_WRITE] = 100 - *val;
369 return 0;
370}
371
85bc833b 372static int str_rwmix_write_cb(void *data, unsigned long long *val)
cb499fc4
JA
373{
374 struct thread_data *td = data;
375
376 td->o.rwmix[DDIR_WRITE] = *val;
377 td->o.rwmix[DDIR_READ] = 100 - *val;
378 return 0;
379}
380
214e1eca
JA
381static int str_exitall_cb(void)
382{
383 exitall_on_terminate = 1;
384 return 0;
385}
386
214e1eca 387#ifdef FIO_HAVE_CPU_AFFINITY
50b5860b 388int fio_cpus_split(os_cpu_mask_t *mask, unsigned int cpu_index)
c2acfbac 389{
50b5860b 390 unsigned int i, index, cpus_in_mask;
c2acfbac 391 const long max_cpu = cpus_online();
c2acfbac 392
50b5860b
JA
393 cpus_in_mask = fio_cpu_count(mask);
394 cpu_index = cpu_index % cpus_in_mask;
395
396 index = 0;
c2acfbac 397 for (i = 0; i < max_cpu; i++) {
50b5860b 398 if (!fio_cpu_isset(mask, i))
c2acfbac 399 continue;
50b5860b
JA
400
401 if (cpu_index != index)
402 fio_cpu_clear(mask, i);
403
404 index++;
c2acfbac
JA
405 }
406
407 return fio_cpu_count(mask);
408}
409
85bc833b 410static int str_cpumask_cb(void *data, unsigned long long *val)
d2e268b0
JA
411{
412 struct thread_data *td = data;
214e1eca 413 unsigned int i;
b03daafb 414 long max_cpu;
d2ce18b5
JA
415 int ret;
416
52c0cea3
JA
417 if (parse_dryrun())
418 return 0;
419
d2ce18b5
JA
420 ret = fio_cpuset_init(&td->o.cpumask);
421 if (ret < 0) {
422 log_err("fio: cpuset_init failed\n");
423 td_verror(td, ret, "fio_cpuset_init");
424 return 1;
425 }
214e1eca 426
c00a2289 427 max_cpu = cpus_online();
214e1eca 428
62a7273d
JA
429 for (i = 0; i < sizeof(int) * 8; i++) {
430 if ((1 << i) & *val) {
b8411399 431 if (i >= max_cpu) {
b03daafb 432 log_err("fio: CPU %d too large (max=%ld)\n", i,
b8411399 433 max_cpu - 1);
b03daafb
JA
434 return 1;
435 }
62a7273d 436 dprint(FD_PARSE, "set cpu allowed %d\n", i);
6d459ee7 437 fio_cpu_set(&td->o.cpumask, i);
62a7273d
JA
438 }
439 }
d2e268b0 440
d2e268b0 441 return 0;
214e1eca
JA
442}
443
e8462bd8
JA
444static int set_cpus_allowed(struct thread_data *td, os_cpu_mask_t *mask,
445 const char *input)
214e1eca 446{
d2e268b0 447 char *cpu, *str, *p;
b03daafb 448 long max_cpu;
19608d6c 449 int ret = 0;
d2e268b0 450
e8462bd8 451 ret = fio_cpuset_init(mask);
d2ce18b5
JA
452 if (ret < 0) {
453 log_err("fio: cpuset_init failed\n");
454 td_verror(td, ret, "fio_cpuset_init");
455 return 1;
456 }
d2e268b0
JA
457
458 p = str = strdup(input);
214e1eca 459
d2e268b0
JA
460 strip_blank_front(&str);
461 strip_blank_end(str);
462
c00a2289 463 max_cpu = cpus_online();
b03daafb 464
d2e268b0 465 while ((cpu = strsep(&str, ",")) != NULL) {
62a7273d
JA
466 char *str2, *cpu2;
467 int icpu, icpu2;
468
d2e268b0
JA
469 if (!strlen(cpu))
470 break;
62a7273d
JA
471
472 str2 = cpu;
473 icpu2 = -1;
474 while ((cpu2 = strsep(&str2, "-")) != NULL) {
475 if (!strlen(cpu2))
476 break;
477
478 icpu2 = atoi(cpu2);
479 }
480
481 icpu = atoi(cpu);
482 if (icpu2 == -1)
483 icpu2 = icpu;
484 while (icpu <= icpu2) {
6d459ee7 485 if (icpu >= FIO_MAX_CPUS) {
19608d6c 486 log_err("fio: your OS only supports up to"
6d459ee7 487 " %d CPUs\n", (int) FIO_MAX_CPUS);
19608d6c
JA
488 ret = 1;
489 break;
490 }
9e986889 491 if (icpu >= max_cpu) {
b03daafb 492 log_err("fio: CPU %d too large (max=%ld)\n",
9e986889 493 icpu, max_cpu - 1);
b03daafb
JA
494 ret = 1;
495 break;
496 }
0b9d69ec 497
62a7273d 498 dprint(FD_PARSE, "set cpu allowed %d\n", icpu);
e8462bd8 499 fio_cpu_set(mask, icpu);
62a7273d
JA
500 icpu++;
501 }
19608d6c
JA
502 if (ret)
503 break;
d2e268b0
JA
504 }
505
506 free(p);
19608d6c 507 return ret;
214e1eca 508}
e8462bd8
JA
509
510static int str_cpus_allowed_cb(void *data, const char *input)
511{
512 struct thread_data *td = data;
e8462bd8 513
52c0cea3
JA
514 if (parse_dryrun())
515 return 0;
516
b2a9e649 517 return set_cpus_allowed(td, &td->o.cpumask, input);
e8462bd8
JA
518}
519
520static int str_verify_cpus_allowed_cb(void *data, const char *input)
521{
522 struct thread_data *td = data;
e8462bd8 523
466155e2
JA
524 if (parse_dryrun())
525 return 0;
526
b2a9e649 527 return set_cpus_allowed(td, &td->o.verify_cpumask, input);
e8462bd8 528}
c08f9fe2 529
105157ad 530#ifdef CONFIG_ZLIB
c08f9fe2
JA
531static int str_log_cpus_allowed_cb(void *data, const char *input)
532{
533 struct thread_data *td = data;
534
535 if (parse_dryrun())
536 return 0;
537
538 return set_cpus_allowed(td, &td->o.log_gz_cpumask, input);
539}
105157ad 540#endif /* CONFIG_ZLIB */
c08f9fe2 541
105157ad 542#endif /* FIO_HAVE_CPU_AFFINITY */
214e1eca 543
67bf9823 544#ifdef CONFIG_LIBNUMA
d0b937ed
YR
545static int str_numa_cpunodes_cb(void *data, char *input)
546{
547 struct thread_data *td = data;
43522848 548 struct bitmask *verify_bitmask;
d0b937ed 549
52c0cea3
JA
550 if (parse_dryrun())
551 return 0;
552
d0b937ed
YR
553 /* numa_parse_nodestring() parses a character string list
554 * of nodes into a bit mask. The bit mask is allocated by
555 * numa_allocate_nodemask(), so it should be freed by
556 * numa_free_nodemask().
557 */
43522848
DG
558 verify_bitmask = numa_parse_nodestring(input);
559 if (verify_bitmask == NULL) {
d0b937ed
YR
560 log_err("fio: numa_parse_nodestring failed\n");
561 td_verror(td, 1, "str_numa_cpunodes_cb");
562 return 1;
563 }
43522848 564 numa_free_nodemask(verify_bitmask);
d0b937ed 565
43522848 566 td->o.numa_cpunodes = strdup(input);
d0b937ed
YR
567 return 0;
568}
569
570static int str_numa_mpol_cb(void *data, char *input)
571{
572 struct thread_data *td = data;
573 const char * const policy_types[] =
05d6f44b 574 { "default", "prefer", "bind", "interleave", "local", NULL };
d0b937ed 575 int i;
52c0cea3 576 char *nodelist;
43522848 577 struct bitmask *verify_bitmask;
52c0cea3
JA
578
579 if (parse_dryrun())
580 return 0;
d0b937ed 581
52c0cea3 582 nodelist = strchr(input, ':');
d0b937ed
YR
583 if (nodelist) {
584 /* NUL-terminate mode */
585 *nodelist++ = '\0';
586 }
587
588 for (i = 0; i <= MPOL_LOCAL; i++) {
589 if (!strcmp(input, policy_types[i])) {
590 td->o.numa_mem_mode = i;
591 break;
592 }
593 }
594 if (i > MPOL_LOCAL) {
595 log_err("fio: memory policy should be: default, prefer, bind, interleave, local\n");
596 goto out;
597 }
598
599 switch (td->o.numa_mem_mode) {
600 case MPOL_PREFERRED:
601 /*
602 * Insist on a nodelist of one node only
603 */
604 if (nodelist) {
605 char *rest = nodelist;
606 while (isdigit(*rest))
607 rest++;
608 if (*rest) {
609 log_err("fio: one node only for \'prefer\'\n");
610 goto out;
611 }
612 } else {
613 log_err("fio: one node is needed for \'prefer\'\n");
614 goto out;
615 }
616 break;
617 case MPOL_INTERLEAVE:
618 /*
619 * Default to online nodes with memory if no nodelist
620 */
621 if (!nodelist)
622 nodelist = strdup("all");
623 break;
624 case MPOL_LOCAL:
625 case MPOL_DEFAULT:
626 /*
627 * Don't allow a nodelist
628 */
629 if (nodelist) {
630 log_err("fio: NO nodelist for \'local\'\n");
631 goto out;
632 }
633 break;
634 case MPOL_BIND:
635 /*
636 * Insist on a nodelist
637 */
638 if (!nodelist) {
639 log_err("fio: a nodelist is needed for \'bind\'\n");
640 goto out;
641 }
642 break;
643 }
644
645
646 /* numa_parse_nodestring() parses a character string list
647 * of nodes into a bit mask. The bit mask is allocated by
648 * numa_allocate_nodemask(), so it should be freed by
649 * numa_free_nodemask().
650 */
651 switch (td->o.numa_mem_mode) {
652 case MPOL_PREFERRED:
653 td->o.numa_mem_prefer_node = atoi(nodelist);
654 break;
655 case MPOL_INTERLEAVE:
656 case MPOL_BIND:
43522848
DG
657 verify_bitmask = numa_parse_nodestring(nodelist);
658 if (verify_bitmask == NULL) {
d0b937ed
YR
659 log_err("fio: numa_parse_nodestring failed\n");
660 td_verror(td, 1, "str_numa_memnodes_cb");
661 return 1;
662 }
43522848
DG
663 td->o.numa_memnodes = strdup(nodelist);
664 numa_free_nodemask(verify_bitmask);
b74e419e 665
d0b937ed
YR
666 break;
667 case MPOL_LOCAL:
668 case MPOL_DEFAULT:
669 default:
670 break;
671 }
672
d0b937ed 673 return 0;
d0b937ed
YR
674out:
675 return 1;
676}
677#endif
678
214e1eca
JA
679static int str_fst_cb(void *data, const char *str)
680{
681 struct thread_data *td = data;
682 char *nr = get_opt_postfix(str);
683
684 td->file_service_nr = 1;
182ec6ee 685 if (nr) {
214e1eca 686 td->file_service_nr = atoi(nr);
182ec6ee
JA
687 free(nr);
688 }
214e1eca
JA
689
690 return 0;
691}
692
67bf9823 693#ifdef CONFIG_SYNC_FILE_RANGE
44f29692
JA
694static int str_sfr_cb(void *data, const char *str)
695{
696 struct thread_data *td = data;
697 char *nr = get_opt_postfix(str);
698
699 td->sync_file_range_nr = 1;
700 if (nr) {
701 td->sync_file_range_nr = atoi(nr);
702 free(nr);
703 }
704
705 return 0;
706}
3ae06371 707#endif
44f29692 708
e0a04ac1
JA
709static int zone_cmp(const void *p1, const void *p2)
710{
711 const struct zone_split *zsp1 = p1;
712 const struct zone_split *zsp2 = p2;
713
714 return (int) zsp2->access_perc - (int) zsp1->access_perc;
715}
716
717static int zone_split_ddir(struct thread_options *o, int ddir, char *str)
718{
719 struct zone_split *zsplit;
720 unsigned int i, perc, perc_missing, sperc, sperc_missing;
721 long long val;
722 char *fname;
723
724 o->zone_split_nr[ddir] = 4;
725 zsplit = malloc(4 * sizeof(struct zone_split));
726
727 i = 0;
728 while ((fname = strsep(&str, ":")) != NULL) {
729 char *perc_str;
730
731 if (!strlen(fname))
732 break;
733
734 /*
735 * grow struct buffer, if needed
736 */
737 if (i == o->zone_split_nr[ddir]) {
738 o->zone_split_nr[ddir] <<= 1;
739 zsplit = realloc(zsplit, o->zone_split_nr[ddir]
740 * sizeof(struct zone_split));
741 }
742
743 perc_str = strstr(fname, "/");
744 if (perc_str) {
745 *perc_str = '\0';
746 perc_str++;
747 perc = atoi(perc_str);
748 if (perc > 100)
749 perc = 100;
750 else if (!perc)
751 perc = -1U;
752 } else
753 perc = -1U;
754
755 if (str_to_decimal(fname, &val, 1, o, 0, 0)) {
756 log_err("fio: zone_split conversion failed\n");
757 free(zsplit);
758 return 1;
759 }
760
761 zsplit[i].access_perc = val;
762 zsplit[i].size_perc = perc;
763 i++;
764 }
765
766 o->zone_split_nr[ddir] = i;
767
768 /*
769 * Now check if the percentages add up, and how much is missing
770 */
771 perc = perc_missing = 0;
772 sperc = sperc_missing = 0;
773 for (i = 0; i < o->zone_split_nr[ddir]; i++) {
774 struct zone_split *zsp = &zsplit[i];
775
776 if (zsp->access_perc == (uint8_t) -1U)
777 perc_missing++;
778 else
779 perc += zsp->access_perc;
780
781 if (zsp->size_perc == (uint8_t) -1U)
782 sperc_missing++;
783 else
784 sperc += zsp->size_perc;
785
786 }
787
788 if (perc > 100 || sperc > 100) {
789 log_err("fio: zone_split percentages add to more than 100%%\n");
790 free(zsplit);
791 return 1;
792 }
793 if (perc < 100) {
794 log_err("fio: access percentage don't add up to 100 for zoned "
795 "random distribution (got=%u)\n", perc);
796 free(zsplit);
797 return 1;
798 }
799
800 /*
801 * If values didn't have a percentage set, divide the remains between
802 * them.
803 */
804 if (perc_missing) {
805 if (perc_missing == 1 && o->zone_split_nr[ddir] == 1)
806 perc = 100;
807 for (i = 0; i < o->zone_split_nr[ddir]; i++) {
808 struct zone_split *zsp = &zsplit[i];
809
810 if (zsp->access_perc == (uint8_t) -1U)
811 zsp->access_perc = (100 - perc) / perc_missing;
812 }
813 }
814 if (sperc_missing) {
815 if (sperc_missing == 1 && o->zone_split_nr[ddir] == 1)
816 sperc = 100;
817 for (i = 0; i < o->zone_split_nr[ddir]; i++) {
818 struct zone_split *zsp = &zsplit[i];
819
820 if (zsp->size_perc == (uint8_t) -1U)
821 zsp->size_perc = (100 - sperc) / sperc_missing;
822 }
823 }
824
825 /*
826 * now sort based on percentages, for ease of lookup
827 */
828 qsort(zsplit, o->zone_split_nr[ddir], sizeof(struct zone_split), zone_cmp);
829 o->zone_split[ddir] = zsplit;
830 return 0;
831}
832
833static void __td_zone_gen_index(struct thread_data *td, enum fio_ddir ddir)
834{
835 unsigned int i, j, sprev, aprev;
836
837 td->zone_state_index[ddir] = malloc(sizeof(struct zone_split_index) * 100);
838
839 sprev = aprev = 0;
840 for (i = 0; i < td->o.zone_split_nr[ddir]; i++) {
841 struct zone_split *zsp = &td->o.zone_split[ddir][i];
842
843 for (j = aprev; j < aprev + zsp->access_perc; j++) {
844 struct zone_split_index *zsi = &td->zone_state_index[ddir][j];
845
846 zsi->size_perc = sprev + zsp->size_perc;
847 zsi->size_perc_prev = sprev;
848 }
849
850 aprev += zsp->access_perc;
851 sprev += zsp->size_perc;
852 }
853}
854
855/*
856 * Generate state table for indexes, so we don't have to do it inline from
857 * the hot IO path
858 */
859static void td_zone_gen_index(struct thread_data *td)
860{
861 int i;
862
863 td->zone_state_index = malloc(DDIR_RWDIR_CNT *
864 sizeof(struct zone_split_index *));
865
866 for (i = 0; i < DDIR_RWDIR_CNT; i++)
867 __td_zone_gen_index(td, i);
868}
869
e0a04ac1
JA
870static int parse_zoned_distribution(struct thread_data *td, const char *input)
871{
872 char *str, *p, *odir, *ddir;
873 int i, ret = 0;
874
875 p = str = strdup(input);
876
877 strip_blank_front(&str);
878 strip_blank_end(str);
879
880 /* We expect it to start like that, bail if not */
881 if (strncmp(str, "zoned:", 6)) {
882 log_err("fio: mismatch in zoned input <%s>\n", str);
883 free(p);
884 return 1;
885 }
886 str += strlen("zoned:");
887
888 odir = strchr(str, ',');
889 if (odir) {
890 ddir = strchr(odir + 1, ',');
891 if (ddir) {
892 ret = zone_split_ddir(&td->o, DDIR_TRIM, ddir + 1);
893 if (!ret)
894 *ddir = '\0';
895 } else {
896 char *op;
897
898 op = strdup(odir + 1);
899 ret = zone_split_ddir(&td->o, DDIR_TRIM, op);
900
901 free(op);
902 }
903 if (!ret)
904 ret = zone_split_ddir(&td->o, DDIR_WRITE, odir + 1);
905 if (!ret) {
906 *odir = '\0';
907 ret = zone_split_ddir(&td->o, DDIR_READ, str);
908 }
909 } else {
910 char *op;
911
912 op = strdup(str);
913 ret = zone_split_ddir(&td->o, DDIR_WRITE, op);
914 free(op);
915
916 if (!ret) {
917 op = strdup(str);
918 ret = zone_split_ddir(&td->o, DDIR_TRIM, op);
919 free(op);
920 }
921 if (!ret)
922 ret = zone_split_ddir(&td->o, DDIR_READ, str);
923 }
924
925 free(p);
926
927 for (i = 0; i < DDIR_RWDIR_CNT; i++) {
928 int j;
929
930 dprint(FD_PARSE, "zone ddir %d (nr=%u): \n", i, td->o.zone_split_nr[i]);
931
932 for (j = 0; j < td->o.zone_split_nr[i]; j++) {
933 struct zone_split *zsp = &td->o.zone_split[i][j];
934
935 dprint(FD_PARSE, "\t%d: %u/%u\n", j, zsp->access_perc,
936 zsp->size_perc);
937 }
938 }
939
940 if (!ret)
941 td_zone_gen_index(td);
dc4bffb8
JA
942 else {
943 for (i = 0; i < DDIR_RWDIR_CNT; i++)
944 td->o.zone_split_nr[i] = 0;
945 }
e0a04ac1
JA
946
947 return ret;
948}
949
e25839d4
JA
950static int str_random_distribution_cb(void *data, const char *str)
951{
952 struct thread_data *td = data;
953 double val;
954 char *nr;
955
52c0cea3
JA
956 if (parse_dryrun())
957 return 0;
958
925fee33 959 if (td->o.random_distribution == FIO_RAND_DIST_ZIPF)
c95f9404 960 val = FIO_DEF_ZIPF;
925fee33 961 else if (td->o.random_distribution == FIO_RAND_DIST_PARETO)
c95f9404 962 val = FIO_DEF_PARETO;
56d9fa4b
JA
963 else if (td->o.random_distribution == FIO_RAND_DIST_GAUSS)
964 val = 0.0;
e0a04ac1
JA
965 else if (td->o.random_distribution == FIO_RAND_DIST_ZONED)
966 return parse_zoned_distribution(td, str);
925fee33 967 else
e25839d4
JA
968 return 0;
969
970 nr = get_opt_postfix(str);
88038bc7 971 if (nr && !str_to_float(nr, &val, 0)) {
e25839d4
JA
972 log_err("fio: random postfix parsing failed\n");
973 free(nr);
974 return 1;
975 }
976
078189c1
JA
977 free(nr);
978
18ded917
JA
979 if (td->o.random_distribution == FIO_RAND_DIST_ZIPF) {
980 if (val == 1.00) {
981 log_err("fio: zipf theta must different than 1.0\n");
982 return 1;
983 }
1e5324e7 984 td->o.zipf_theta.u.f = val;
56d9fa4b 985 } else if (td->o.random_distribution == FIO_RAND_DIST_PARETO) {
078189c1
JA
986 if (val <= 0.00 || val >= 1.00) {
987 log_err("fio: pareto input out of range (0 < input < 1.0)\n");
988 return 1;
989 }
1e5324e7 990 td->o.pareto_h.u.f = val;
3cdb8cf3
JA
991 } else {
992 if (val <= 0.00 || val >= 100.0) {
993 log_err("fio: normal deviation out of range (0 < input < 100.0)\n");
994 return 1;
995 }
f88cd222 996 td->o.gauss_dev.u.f = val;
3cdb8cf3 997 }
921c766f
JA
998
999 return 0;
1000}
1001
8e827d35 1002/*
bcbfeefa 1003 * Return next name in the string. Files are separated with ':'. If the ':'
8e827d35
JA
1004 * is escaped with a '\', then that ':' is part of the filename and does not
1005 * indicate a new file.
1006 */
bcbfeefa 1007static char *get_next_name(char **ptr)
8e827d35
JA
1008{
1009 char *str = *ptr;
1010 char *p, *start;
1011
1012 if (!str || !strlen(str))
1013 return NULL;
1014
1015 start = str;
1016 do {
1017 /*
1018 * No colon, we are done
1019 */
1020 p = strchr(str, ':');
1021 if (!p) {
1022 *ptr = NULL;
1023 break;
1024 }
1025
1026 /*
1027 * We got a colon, but it's the first character. Skip and
1028 * continue
1029 */
1030 if (p == start) {
1031 str = ++start;
1032 continue;
1033 }
1034
1035 if (*(p - 1) != '\\') {
1036 *p = '\0';
1037 *ptr = p + 1;
1038 break;
1039 }
1040
1041 memmove(p - 1, p, strlen(p) + 1);
1042 str = p;
1043 } while (1);
1044
1045 return start;
1046}
1047
bcbfeefa
CE
1048
1049static int get_max_name_idx(char *input)
1050{
1051 unsigned int cur_idx;
1052 char *str, *p;
1053
1054 p = str = strdup(input);
1055 for (cur_idx = 0; ; cur_idx++)
1056 if (get_next_name(&str) == NULL)
1057 break;
1058
1059 free(p);
1060 return cur_idx;
1061}
1062
1063/*
1064 * Returns the directory at the index, indexes > entires will be
1065 * assigned via modulo division of the index
1066 */
e13c3b50 1067int set_name_idx(char *target, size_t tlen, char *input, int index)
bcbfeefa
CE
1068{
1069 unsigned int cur_idx;
1070 int len;
1071 char *fname, *str, *p;
1072
1073 p = str = strdup(input);
1074
1075 index %= get_max_name_idx(input);
1076 for (cur_idx = 0; cur_idx <= index; cur_idx++)
1077 fname = get_next_name(&str);
1078
72a703da 1079 if (client_sockaddr_str[0]) {
e13c3b50
JA
1080 len = snprintf(target, tlen, "%s/%s.", fname,
1081 client_sockaddr_str);
1082 } else
1083 len = snprintf(target, tlen, "%s/", fname);
72a703da 1084
e13c3b50 1085 target[tlen - 1] = '\0';
bcbfeefa
CE
1086 free(p);
1087
1088 return len;
1089}
1090
214e1eca
JA
1091static int str_filename_cb(void *data, const char *input)
1092{
1093 struct thread_data *td = data;
1094 char *fname, *str, *p;
1095
1096 p = str = strdup(input);
1097
1098 strip_blank_front(&str);
1099 strip_blank_end(str);
1100
1101 if (!td->files_index)
2dc1bbeb 1102 td->o.nr_files = 0;
214e1eca 1103
bcbfeefa 1104 while ((fname = get_next_name(&str)) != NULL) {
214e1eca
JA
1105 if (!strlen(fname))
1106 break;
5903e7b7 1107 add_file(td, fname, 0, 1);
214e1eca
JA
1108 }
1109
1110 free(p);
1111 return 0;
1112}
1113
bcbfeefa 1114static int str_directory_cb(void *data, const char fio_unused *unused)
214e1eca
JA
1115{
1116 struct thread_data *td = data;
1117 struct stat sb;
bcbfeefa
CE
1118 char *dirname, *str, *p;
1119 int ret = 0;
214e1eca 1120
f9633d72
JA
1121 if (parse_dryrun())
1122 return 0;
1123
bcbfeefa
CE
1124 p = str = strdup(td->o.directory);
1125 while ((dirname = get_next_name(&str)) != NULL) {
1126 if (lstat(dirname, &sb) < 0) {
1127 ret = errno;
921c766f 1128
bcbfeefa
CE
1129 log_err("fio: %s is not a directory\n", dirname);
1130 td_verror(td, ret, "lstat");
1131 goto out;
1132 }
1133 if (!S_ISDIR(sb.st_mode)) {
1134 log_err("fio: %s is not a directory\n", dirname);
1135 ret = 1;
1136 goto out;
1137 }
214e1eca
JA
1138 }
1139
bcbfeefa
CE
1140out:
1141 free(p);
1142 return ret;
214e1eca
JA
1143}
1144
1145static int str_opendir_cb(void *data, const char fio_unused *str)
1146{
1147 struct thread_data *td = data;
1148
52c0cea3
JA
1149 if (parse_dryrun())
1150 return 0;
1151
214e1eca 1152 if (!td->files_index)
2dc1bbeb 1153 td->o.nr_files = 0;
214e1eca 1154
2dc1bbeb 1155 return add_dir_files(td, td->o.opendir);
214e1eca
JA
1156}
1157
ce35b1ec
JA
1158static int str_buffer_pattern_cb(void *data, const char *input)
1159{
1160 struct thread_data *td = data;
1161 int ret;
1162
61b9861d
RP
1163 /* FIXME: for now buffer pattern does not support formats */
1164 ret = parse_and_fill_pattern(input, strlen(input), td->o.buffer_pattern,
1165 MAX_PATTERN_SIZE, NULL, 0, NULL, NULL);
1166 if (ret < 0)
1167 return 1;
ce35b1ec 1168
61b9861d
RP
1169 assert(ret != 0);
1170 td->o.buffer_pattern_bytes = ret;
1171 if (!td->o.compress_percentage)
1172 td->o.refill_buffers = 0;
1173 td->o.scramble_buffers = 0;
1174 td->o.zero_buffers = 0;
efcd9dcc 1175
61b9861d 1176 return 0;
ce35b1ec
JA
1177}
1178
bedc9dc2
JA
1179static int str_buffer_compress_cb(void *data, unsigned long long *il)
1180{
1181 struct thread_data *td = data;
1182
1183 td->flags |= TD_F_COMPRESS;
1184 td->o.compress_percentage = *il;
1185 return 0;
1186}
1187
5c94b008
JA
1188static int str_dedupe_cb(void *data, unsigned long long *il)
1189{
1190 struct thread_data *td = data;
1191
1192 td->flags |= TD_F_COMPRESS;
1193 td->o.dedupe_percentage = *il;
1194 td->o.refill_buffers = 1;
1195 return 0;
1196}
1197
ce35b1ec
JA
1198static int str_verify_pattern_cb(void *data, const char *input)
1199{
5f3bd0fd
JA
1200 struct pattern_fmt_desc fmt_desc[] = {
1201 {
1202 .fmt = "%o",
1203 .len = FIELD_SIZE(struct io_u *, offset),
1204 .paste = paste_blockoff
1205 }
1206 };
ce35b1ec
JA
1207 struct thread_data *td = data;
1208 int ret;
1209
61b9861d
RP
1210 td->o.verify_fmt_sz = ARRAY_SIZE(td->o.verify_fmt);
1211 ret = parse_and_fill_pattern(input, strlen(input), td->o.verify_pattern,
5f3bd0fd
JA
1212 MAX_PATTERN_SIZE, fmt_desc, sizeof(fmt_desc),
1213 td->o.verify_fmt, &td->o.verify_fmt_sz);
61b9861d
RP
1214 if (ret < 0)
1215 return 1;
efcd9dcc 1216
61b9861d
RP
1217 assert(ret != 0);
1218 td->o.verify_pattern_bytes = ret;
92bf48d5 1219 /*
b638d82f 1220 * VERIFY_* could already be set
92bf48d5 1221 */
61b9861d 1222 if (!fio_option_is_set(&td->o, verify))
92bf48d5 1223 td->o.verify = VERIFY_PATTERN;
efcd9dcc 1224
61b9861d 1225 return 0;
90059d65 1226}
214e1eca 1227
993bf48b
JA
1228static int str_gtod_reduce_cb(void *data, int *il)
1229{
1230 struct thread_data *td = data;
1231 int val = *il;
1232
02af0988 1233 td->o.disable_lat = !!val;
993bf48b
JA
1234 td->o.disable_clat = !!val;
1235 td->o.disable_slat = !!val;
1236 td->o.disable_bw = !!val;
0dc1bc03 1237 td->o.clat_percentiles = !val;
993bf48b
JA
1238 if (val)
1239 td->tv_cache_mask = 63;
1240
1241 return 0;
1242}
1243
7bb59102
JA
1244static int str_size_cb(void *data, unsigned long long *__val)
1245{
1246 struct thread_data *td = data;
1247 unsigned long long v = *__val;
1248
1249 if (parse_is_percent(v)) {
1250 td->o.size = 0;
1251 td->o.size_percent = -1ULL - v;
1252 } else
1253 td->o.size = v;
1254
1255 return 0;
1256}
1257
896cac2a
JA
1258static int rw_verify(struct fio_option *o, void *data)
1259{
1260 struct thread_data *td = data;
1261
1262 if (read_only && td_write(td)) {
1263 log_err("fio: job <%s> has write bit set, but fio is in"
1264 " read-only mode\n", td->o.name);
1265 return 1;
1266 }
1267
1268 return 0;
1269}
1270
276ca4f7 1271static int gtod_cpu_verify(struct fio_option *o, void *data)
29d43ff9 1272{
276ca4f7 1273#ifndef FIO_HAVE_CPU_AFFINITY
29d43ff9
JA
1274 struct thread_data *td = data;
1275
29d43ff9
JA
1276 if (td->o.gtod_cpu) {
1277 log_err("fio: platform must support CPU affinity for"
1278 "gettimeofday() offloading\n");
1279 return 1;
1280 }
1281#endif
1282
1283 return 0;
1284}
1285
214e1eca
JA
1286/*
1287 * Map of job/command line options
1288 */
9af4a244 1289struct fio_option fio_options[FIO_MAX_OPTS] = {
214e1eca
JA
1290 {
1291 .name = "description",
e8b0e958 1292 .lname = "Description of job",
214e1eca
JA
1293 .type = FIO_OPT_STR_STORE,
1294 .off1 = td_var_offset(description),
1295 .help = "Text job description",
e8b0e958 1296 .category = FIO_OPT_C_GENERAL,
0626037e 1297 .group = FIO_OPT_G_DESC,
214e1eca
JA
1298 },
1299 {
1300 .name = "name",
e8b0e958 1301 .lname = "Job name",
214e1eca
JA
1302 .type = FIO_OPT_STR_STORE,
1303 .off1 = td_var_offset(name),
1304 .help = "Name of this job",
e8b0e958 1305 .category = FIO_OPT_C_GENERAL,
0626037e 1306 .group = FIO_OPT_G_DESC,
214e1eca 1307 },
9cc8cb91
AK
1308 {
1309 .name = "wait_for",
1310 .lname = "Waitee name",
1311 .type = FIO_OPT_STR_STORE,
1312 .off1 = td_var_offset(wait_for),
1313 .help = "Name of the job this one wants to wait for before starting",
1314 .category = FIO_OPT_C_GENERAL,
1315 .group = FIO_OPT_G_DESC,
1316 },
214e1eca
JA
1317 {
1318 .name = "filename",
e8b0e958 1319 .lname = "Filename(s)",
214e1eca
JA
1320 .type = FIO_OPT_STR_STORE,
1321 .off1 = td_var_offset(filename),
1322 .cb = str_filename_cb,
f0d524b0 1323 .prio = -1, /* must come after "directory" */
214e1eca 1324 .help = "File(s) to use for the workload",
e8b0e958 1325 .category = FIO_OPT_C_FILE,
0626037e 1326 .group = FIO_OPT_G_FILENAME,
214e1eca 1327 },
90fef2d1 1328 {
e8b0e958
JA
1329 .name = "directory",
1330 .lname = "Directory",
1331 .type = FIO_OPT_STR_STORE,
1332 .off1 = td_var_offset(directory),
1333 .cb = str_directory_cb,
1334 .help = "Directory to store files in",
1335 .category = FIO_OPT_C_FILE,
0626037e 1336 .group = FIO_OPT_G_FILENAME,
90fef2d1 1337 },
de98bd30
JA
1338 {
1339 .name = "filename_format",
1340 .type = FIO_OPT_STR_STORE,
1341 .off1 = td_var_offset(filename_format),
1342 .prio = -1, /* must come after "directory" */
1343 .help = "Override default $jobname.$jobnum.$filenum naming",
1344 .def = "$jobname.$jobnum.$filenum",
93bb626a
JA
1345 .category = FIO_OPT_C_FILE,
1346 .group = FIO_OPT_G_FILENAME,
ad705bcb 1347 },
29c1349f
JA
1348 {
1349 .name = "lockfile",
e8b0e958 1350 .lname = "Lockfile",
4d4e80f2 1351 .type = FIO_OPT_STR,
4d4e80f2 1352 .off1 = td_var_offset(file_lock_mode),
29c1349f 1353 .help = "Lock file when doing IO to it",
bc6a0a5d 1354 .prio = 1,
29c1349f 1355 .parent = "filename",
d71c154c 1356 .hide = 0,
4d4e80f2 1357 .def = "none",
e8b0e958 1358 .category = FIO_OPT_C_FILE,
0626037e 1359 .group = FIO_OPT_G_FILENAME,
4d4e80f2
JA
1360 .posval = {
1361 { .ival = "none",
1362 .oval = FILE_LOCK_NONE,
1363 .help = "No file locking",
1364 },
1365 { .ival = "exclusive",
1366 .oval = FILE_LOCK_EXCLUSIVE,
1367 .help = "Exclusive file lock",
1368 },
1369 {
1370 .ival = "readwrite",
1371 .oval = FILE_LOCK_READWRITE,
1372 .help = "Read vs write lock",
1373 },
1374 },
29c1349f 1375 },
214e1eca
JA
1376 {
1377 .name = "opendir",
e8b0e958 1378 .lname = "Open directory",
214e1eca
JA
1379 .type = FIO_OPT_STR_STORE,
1380 .off1 = td_var_offset(opendir),
1381 .cb = str_opendir_cb,
1382 .help = "Recursively add files from this directory and down",
e8b0e958 1383 .category = FIO_OPT_C_FILE,
0626037e 1384 .group = FIO_OPT_G_FILENAME,
214e1eca
JA
1385 },
1386 {
1387 .name = "rw",
e8b0e958 1388 .lname = "Read/write",
d3aad8f2 1389 .alias = "readwrite",
214e1eca 1390 .type = FIO_OPT_STR,
211097b2 1391 .cb = str_rw_cb,
214e1eca
JA
1392 .off1 = td_var_offset(td_ddir),
1393 .help = "IO direction",
1394 .def = "read",
896cac2a 1395 .verify = rw_verify,
e8b0e958 1396 .category = FIO_OPT_C_IO,
0626037e 1397 .group = FIO_OPT_G_IO_BASIC,
214e1eca
JA
1398 .posval = {
1399 { .ival = "read",
1400 .oval = TD_DDIR_READ,
1401 .help = "Sequential read",
1402 },
1403 { .ival = "write",
1404 .oval = TD_DDIR_WRITE,
1405 .help = "Sequential write",
1406 },
6eaf09d6
SL
1407 { .ival = "trim",
1408 .oval = TD_DDIR_TRIM,
1409 .help = "Sequential trim",
1410 },
214e1eca
JA
1411 { .ival = "randread",
1412 .oval = TD_DDIR_RANDREAD,
1413 .help = "Random read",
1414 },
1415 { .ival = "randwrite",
1416 .oval = TD_DDIR_RANDWRITE,
1417 .help = "Random write",
1418 },
6eaf09d6
SL
1419 { .ival = "randtrim",
1420 .oval = TD_DDIR_RANDTRIM,
1421 .help = "Random trim",
1422 },
214e1eca
JA
1423 { .ival = "rw",
1424 .oval = TD_DDIR_RW,
1425 .help = "Sequential read and write mix",
1426 },
10b023db
JA
1427 { .ival = "readwrite",
1428 .oval = TD_DDIR_RW,
1429 .help = "Sequential read and write mix",
1430 },
214e1eca
JA
1431 { .ival = "randrw",
1432 .oval = TD_DDIR_RANDRW,
1433 .help = "Random read and write mix"
1434 },
82a90686
JA
1435 { .ival = "trimwrite",
1436 .oval = TD_DDIR_TRIMWRITE,
1437 .help = "Trim and write mix, trims preceding writes"
0e4dd95c 1438 },
214e1eca
JA
1439 },
1440 },
38dad62d
JA
1441 {
1442 .name = "rw_sequencer",
e8b0e958 1443 .lname = "RW Sequencer",
38dad62d
JA
1444 .type = FIO_OPT_STR,
1445 .off1 = td_var_offset(rw_seq),
1446 .help = "IO offset generator modifier",
1447 .def = "sequential",
e8b0e958 1448 .category = FIO_OPT_C_IO,
0626037e 1449 .group = FIO_OPT_G_IO_BASIC,
38dad62d
JA
1450 .posval = {
1451 { .ival = "sequential",
1452 .oval = RW_SEQ_SEQ,
1453 .help = "Generate sequential offsets",
1454 },
1455 { .ival = "identical",
1456 .oval = RW_SEQ_IDENT,
1457 .help = "Generate identical offsets",
1458 },
1459 },
1460 },
1461
214e1eca
JA
1462 {
1463 .name = "ioengine",
e8b0e958 1464 .lname = "IO Engine",
214e1eca
JA
1465 .type = FIO_OPT_STR_STORE,
1466 .off1 = td_var_offset(ioengine),
1467 .help = "IO engine to use",
58483fa4 1468 .def = FIO_PREFERRED_ENGINE,
e8b0e958 1469 .category = FIO_OPT_C_IO,
0626037e 1470 .group = FIO_OPT_G_IO_BASIC,
214e1eca
JA
1471 .posval = {
1472 { .ival = "sync",
1473 .help = "Use read/write",
1474 },
a31041ea 1475 { .ival = "psync",
1476 .help = "Use pread/pwrite",
1477 },
1d2af02a 1478 { .ival = "vsync",
03e20d68 1479 .help = "Use readv/writev",
1d2af02a 1480 },
07fc0acd
JA
1481#ifdef CONFIG_PWRITEV
1482 { .ival = "pvsync",
1483 .help = "Use preadv/pwritev",
1484 },
1485#endif
2cafffbe
JA
1486#ifdef CONFIG_PWRITEV
1487 { .ival = "pvsync2",
1488 .help = "Use preadv2/pwritev2",
1489 },
1490#endif
67bf9823 1491#ifdef CONFIG_LIBAIO
214e1eca
JA
1492 { .ival = "libaio",
1493 .help = "Linux native asynchronous IO",
1494 },
1495#endif
67bf9823 1496#ifdef CONFIG_POSIXAIO
214e1eca
JA
1497 { .ival = "posixaio",
1498 .help = "POSIX asynchronous IO",
1499 },
417f0068 1500#endif
997843cb 1501#ifdef CONFIG_SOLARISAIO
417f0068
JA
1502 { .ival = "solarisaio",
1503 .help = "Solaris native asynchronous IO",
1504 },
214e1eca 1505#endif
4700b234 1506#ifdef CONFIG_WINDOWSAIO
03e20d68 1507 { .ival = "windowsaio",
3be80071 1508 .help = "Windows native asynchronous IO"
de890a1e 1509 },
fc5c0345
DG
1510#endif
1511#ifdef CONFIG_RBD
1512 { .ival = "rbd",
1513 .help = "Rados Block Device asynchronous IO"
1514 },
3be80071 1515#endif
214e1eca 1516 { .ival = "mmap",
03e20d68 1517 .help = "Memory mapped IO"
214e1eca 1518 },
67bf9823 1519#ifdef CONFIG_LINUX_SPLICE
214e1eca
JA
1520 { .ival = "splice",
1521 .help = "splice/vmsplice based IO",
1522 },
9cce02e8
JA
1523 { .ival = "netsplice",
1524 .help = "splice/vmsplice to/from the network",
1525 },
214e1eca
JA
1526#endif
1527#ifdef FIO_HAVE_SGIO
1528 { .ival = "sg",
1529 .help = "SCSI generic v3 IO",
1530 },
1531#endif
1532 { .ival = "null",
1533 .help = "Testing engine (no data transfer)",
1534 },
1535 { .ival = "net",
1536 .help = "Network IO",
1537 },
214e1eca 1538 { .ival = "cpuio",
03e20d68 1539 .help = "CPU cycle burner engine",
214e1eca 1540 },
67bf9823 1541#ifdef CONFIG_GUASI
b8c82a46
JA
1542 { .ival = "guasi",
1543 .help = "GUASI IO engine",
1544 },
79a43187
JA
1545#endif
1546#ifdef FIO_HAVE_BINJECT
1547 { .ival = "binject",
1548 .help = "binject direct inject block engine",
1549 },
21b8aee8 1550#endif
67bf9823 1551#ifdef CONFIG_RDMA
21b8aee8 1552 { .ival = "rdma",
1553 .help = "RDMA IO engine",
1554 },
8200b8c7 1555#endif
67bf9823 1556#ifdef CONFIG_FUSION_AW
8200b8c7
JA
1557 { .ival = "fusion-aw-sync",
1558 .help = "Fusion-io atomic write engine",
1559 },
1ecc95ca 1560#endif
997843cb 1561#ifdef CONFIG_LINUX_EXT4_MOVE_EXTENT
1ecc95ca
JA
1562 { .ival = "e4defrag",
1563 .help = "ext4 defrag engine",
1564 },
1565#endif
997843cb 1566#ifdef CONFIG_LINUX_FALLOCATE
1ecc95ca
JA
1567 { .ival = "falloc",
1568 .help = "fallocate() file based engine",
1569 },
b8c82a46 1570#endif
a7c386f4 1571#ifdef CONFIG_GFAPI
1572 { .ival = "gfapi",
cc47f094 1573 .help = "Glusterfs libgfapi(sync) based engine"
1574 },
1575 { .ival = "gfapi_async",
1576 .help = "Glusterfs libgfapi(async) based engine"
a7c386f4 1577 },
1578#endif
1b10477b 1579#ifdef CONFIG_LIBHDFS
b74e419e 1580 { .ival = "libhdfs",
1b10477b
MM
1581 .help = "Hadoop Distributed Filesystem (HDFS) engine"
1582 },
1583#endif
214e1eca
JA
1584 { .ival = "external",
1585 .help = "Load external engine (append name)",
1586 },
1587 },
1588 },
1589 {
1590 .name = "iodepth",
e8b0e958 1591 .lname = "IO Depth",
214e1eca
JA
1592 .type = FIO_OPT_INT,
1593 .off1 = td_var_offset(iodepth),
03e20d68 1594 .help = "Number of IO buffers to keep in flight",
757aff4f 1595 .minval = 1,
20eb06bd 1596 .interval = 1,
214e1eca 1597 .def = "1",
e8b0e958 1598 .category = FIO_OPT_C_IO,
0626037e 1599 .group = FIO_OPT_G_IO_BASIC,
214e1eca
JA
1600 },
1601 {
1602 .name = "iodepth_batch",
e8b0e958 1603 .lname = "IO Depth batch",
4950421a 1604 .alias = "iodepth_batch_submit",
214e1eca
JA
1605 .type = FIO_OPT_INT,
1606 .off1 = td_var_offset(iodepth_batch),
d65db441 1607 .help = "Number of IO buffers to submit in one go",
afdf9352 1608 .parent = "iodepth",
d71c154c 1609 .hide = 1,
a2e6f8ac 1610 .minval = 1,
20eb06bd 1611 .interval = 1,
a2e6f8ac 1612 .def = "1",
e8b0e958 1613 .category = FIO_OPT_C_IO,
0626037e 1614 .group = FIO_OPT_G_IO_BASIC,
4950421a
JA
1615 },
1616 {
82407585
RP
1617 .name = "iodepth_batch_complete_min",
1618 .lname = "Min IO depth batch complete",
1619 .alias = "iodepth_batch_complete",
4950421a 1620 .type = FIO_OPT_INT,
82407585
RP
1621 .off1 = td_var_offset(iodepth_batch_complete_min),
1622 .help = "Min number of IO buffers to retrieve in one go",
4950421a 1623 .parent = "iodepth",
d71c154c 1624 .hide = 1,
4950421a 1625 .minval = 0,
20eb06bd 1626 .interval = 1,
4950421a 1627 .def = "1",
e8b0e958 1628 .category = FIO_OPT_C_IO,
0626037e 1629 .group = FIO_OPT_G_IO_BASIC,
214e1eca 1630 },
82407585
RP
1631 {
1632 .name = "iodepth_batch_complete_max",
1633 .lname = "Max IO depth batch complete",
1634 .type = FIO_OPT_INT,
1635 .off1 = td_var_offset(iodepth_batch_complete_max),
1636 .help = "Max number of IO buffers to retrieve in one go",
1637 .parent = "iodepth",
1638 .hide = 1,
1639 .minval = 0,
1640 .interval = 1,
1641 .category = FIO_OPT_C_IO,
1642 .group = FIO_OPT_G_IO_BASIC,
1643 },
214e1eca
JA
1644 {
1645 .name = "iodepth_low",
e8b0e958 1646 .lname = "IO Depth batch low",
214e1eca
JA
1647 .type = FIO_OPT_INT,
1648 .off1 = td_var_offset(iodepth_low),
1649 .help = "Low water mark for queuing depth",
afdf9352 1650 .parent = "iodepth",
d71c154c 1651 .hide = 1,
20eb06bd 1652 .interval = 1,
e8b0e958 1653 .category = FIO_OPT_C_IO,
0626037e 1654 .group = FIO_OPT_G_IO_BASIC,
214e1eca 1655 },
a9da8ab2
JA
1656 {
1657 .name = "io_submit_mode",
1658 .lname = "IO submit mode",
1659 .type = FIO_OPT_STR,
1660 .off1 = td_var_offset(io_submit_mode),
1661 .help = "How IO submissions and completions are done",
1662 .def = "inline",
1663 .category = FIO_OPT_C_IO,
1664 .group = FIO_OPT_G_IO_BASIC,
1665 .posval = {
1666 { .ival = "inline",
1667 .oval = IO_MODE_INLINE,
1668 .help = "Submit and complete IO inline",
1669 },
1670 { .ival = "offload",
1671 .oval = IO_MODE_OFFLOAD,
1672 .help = "Offload submit and complete to threads",
1673 },
1674 },
1675 },
214e1eca
JA
1676 {
1677 .name = "size",
e8b0e958 1678 .lname = "Size",
214e1eca 1679 .type = FIO_OPT_STR_VAL,
7bb59102 1680 .cb = str_size_cb,
a8523a6a 1681 .off1 = td_var_offset(size),
214e1eca 1682 .help = "Total size of device or files",
20eb06bd 1683 .interval = 1024 * 1024,
e8b0e958
JA
1684 .category = FIO_OPT_C_IO,
1685 .group = FIO_OPT_G_INVALID,
214e1eca 1686 },
77731b29 1687 {
a4d3b4db
JA
1688 .name = "io_size",
1689 .alias = "io_limit",
1690 .lname = "IO Size",
77731b29
JA
1691 .type = FIO_OPT_STR_VAL,
1692 .off1 = td_var_offset(io_limit),
1693 .interval = 1024 * 1024,
1694 .category = FIO_OPT_C_IO,
1695 .group = FIO_OPT_G_INVALID,
1696 },
aa31f1f1
SL
1697 {
1698 .name = "fill_device",
e8b0e958 1699 .lname = "Fill device",
74586c1e 1700 .alias = "fill_fs",
aa31f1f1
SL
1701 .type = FIO_OPT_BOOL,
1702 .off1 = td_var_offset(fill_device),
1703 .help = "Write until an ENOSPC error occurs",
1704 .def = "0",
e8b0e958
JA
1705 .category = FIO_OPT_C_FILE,
1706 .group = FIO_OPT_G_INVALID,
aa31f1f1 1707 },
214e1eca
JA
1708 {
1709 .name = "filesize",
e8b0e958 1710 .lname = "File size",
214e1eca
JA
1711 .type = FIO_OPT_STR_VAL,
1712 .off1 = td_var_offset(file_size_low),
1713 .off2 = td_var_offset(file_size_high),
c3edbdba 1714 .minval = 1,
214e1eca 1715 .help = "Size of individual files",
20eb06bd 1716 .interval = 1024 * 1024,
e8b0e958
JA
1717 .category = FIO_OPT_C_FILE,
1718 .group = FIO_OPT_G_INVALID,
214e1eca 1719 },
bedc9dc2
JA
1720 {
1721 .name = "file_append",
1722 .lname = "File append",
1723 .type = FIO_OPT_BOOL,
1724 .off1 = td_var_offset(file_append),
1725 .help = "IO will start at the end of the file(s)",
1726 .def = "0",
1727 .category = FIO_OPT_C_FILE,
1728 .group = FIO_OPT_G_INVALID,
1729 },
67a1000f
JA
1730 {
1731 .name = "offset",
e8b0e958 1732 .lname = "IO offset",
67a1000f
JA
1733 .alias = "fileoffset",
1734 .type = FIO_OPT_STR_VAL,
1735 .off1 = td_var_offset(start_offset),
1736 .help = "Start IO from this offset",
1737 .def = "0",
20eb06bd 1738 .interval = 1024 * 1024,
e8b0e958
JA
1739 .category = FIO_OPT_C_IO,
1740 .group = FIO_OPT_G_INVALID,
67a1000f 1741 },
2d7cd868
JA
1742 {
1743 .name = "offset_increment",
e8b0e958 1744 .lname = "IO offset increment",
2d7cd868
JA
1745 .type = FIO_OPT_STR_VAL,
1746 .off1 = td_var_offset(offset_increment),
1747 .help = "What is the increment from one offset to the next",
1748 .parent = "offset",
d71c154c 1749 .hide = 1,
2d7cd868 1750 .def = "0",
20eb06bd 1751 .interval = 1024 * 1024,
e8b0e958
JA
1752 .category = FIO_OPT_C_IO,
1753 .group = FIO_OPT_G_INVALID,
2d7cd868 1754 },
ddf24e42
JA
1755 {
1756 .name = "number_ios",
1757 .lname = "Number of IOs to perform",
1758 .type = FIO_OPT_STR_VAL,
1759 .off1 = td_var_offset(number_ios),
be3fec7d 1760 .help = "Force job completion after this number of IOs",
ddf24e42
JA
1761 .def = "0",
1762 .category = FIO_OPT_C_IO,
1763 .group = FIO_OPT_G_INVALID,
1764 },
214e1eca
JA
1765 {
1766 .name = "bs",
e8b0e958 1767 .lname = "Block size",
d3aad8f2 1768 .alias = "blocksize",
e01b22b8 1769 .type = FIO_OPT_INT,
214e1eca
JA
1770 .off1 = td_var_offset(bs[DDIR_READ]),
1771 .off2 = td_var_offset(bs[DDIR_WRITE]),
6eaf09d6 1772 .off3 = td_var_offset(bs[DDIR_TRIM]),
c3edbdba 1773 .minval = 1,
214e1eca
JA
1774 .help = "Block size unit",
1775 .def = "4k",
67a1000f 1776 .parent = "rw",
d71c154c 1777 .hide = 1,
20eb06bd 1778 .interval = 512,
e8b0e958
JA
1779 .category = FIO_OPT_C_IO,
1780 .group = FIO_OPT_G_INVALID,
214e1eca 1781 },
2b7a01d0
JA
1782 {
1783 .name = "ba",
e8b0e958 1784 .lname = "Block size align",
2b7a01d0 1785 .alias = "blockalign",
e01b22b8 1786 .type = FIO_OPT_INT,
2b7a01d0
JA
1787 .off1 = td_var_offset(ba[DDIR_READ]),
1788 .off2 = td_var_offset(ba[DDIR_WRITE]),
6eaf09d6 1789 .off3 = td_var_offset(ba[DDIR_TRIM]),
2b7a01d0
JA
1790 .minval = 1,
1791 .help = "IO block offset alignment",
1792 .parent = "rw",
d71c154c 1793 .hide = 1,
20eb06bd 1794 .interval = 512,
e8b0e958
JA
1795 .category = FIO_OPT_C_IO,
1796 .group = FIO_OPT_G_INVALID,
2b7a01d0 1797 },
214e1eca
JA
1798 {
1799 .name = "bsrange",
e8b0e958 1800 .lname = "Block size range",
d3aad8f2 1801 .alias = "blocksize_range",
214e1eca
JA
1802 .type = FIO_OPT_RANGE,
1803 .off1 = td_var_offset(min_bs[DDIR_READ]),
1804 .off2 = td_var_offset(max_bs[DDIR_READ]),
1805 .off3 = td_var_offset(min_bs[DDIR_WRITE]),
1806 .off4 = td_var_offset(max_bs[DDIR_WRITE]),
6eaf09d6
SL
1807 .off5 = td_var_offset(min_bs[DDIR_TRIM]),
1808 .off6 = td_var_offset(max_bs[DDIR_TRIM]),
c3edbdba 1809 .minval = 1,
214e1eca 1810 .help = "Set block size range (in more detail than bs)",
67a1000f 1811 .parent = "rw",
d71c154c 1812 .hide = 1,
20eb06bd 1813 .interval = 4096,
e8b0e958
JA
1814 .category = FIO_OPT_C_IO,
1815 .group = FIO_OPT_G_INVALID,
214e1eca 1816 },
564ca972
JA
1817 {
1818 .name = "bssplit",
e8b0e958 1819 .lname = "Block size split",
564ca972
JA
1820 .type = FIO_OPT_STR,
1821 .cb = str_bssplit_cb,
a8523a6a 1822 .off1 = td_var_offset(bssplit),
564ca972
JA
1823 .help = "Set a specific mix of block sizes",
1824 .parent = "rw",
d71c154c 1825 .hide = 1,
e8b0e958
JA
1826 .category = FIO_OPT_C_IO,
1827 .group = FIO_OPT_G_INVALID,
564ca972 1828 },
214e1eca
JA
1829 {
1830 .name = "bs_unaligned",
e8b0e958 1831 .lname = "Block size unaligned",
d3aad8f2 1832 .alias = "blocksize_unaligned",
214e1eca
JA
1833 .type = FIO_OPT_STR_SET,
1834 .off1 = td_var_offset(bs_unaligned),
1835 .help = "Don't sector align IO buffer sizes",
67a1000f 1836 .parent = "rw",
d71c154c 1837 .hide = 1,
e8b0e958
JA
1838 .category = FIO_OPT_C_IO,
1839 .group = FIO_OPT_G_INVALID,
214e1eca 1840 },
6aca9b3d
JA
1841 {
1842 .name = "bs_is_seq_rand",
1843 .lname = "Block size division is seq/random (not read/write)",
1844 .type = FIO_OPT_BOOL,
1845 .off1 = td_var_offset(bs_is_seq_rand),
86d59660 1846 .help = "Consider any blocksize setting to be sequential,random",
6aca9b3d
JA
1847 .def = "0",
1848 .parent = "blocksize",
1849 .category = FIO_OPT_C_IO,
1850 .group = FIO_OPT_G_INVALID,
1851 },
214e1eca
JA
1852 {
1853 .name = "randrepeat",
e8b0e958 1854 .lname = "Random repeatable",
214e1eca
JA
1855 .type = FIO_OPT_BOOL,
1856 .off1 = td_var_offset(rand_repeatable),
1857 .help = "Use repeatable random IO pattern",
1858 .def = "1",
67a1000f 1859 .parent = "rw",
d71c154c 1860 .hide = 1,
e8b0e958 1861 .category = FIO_OPT_C_IO,
3ceb458f 1862 .group = FIO_OPT_G_RANDOM,
214e1eca 1863 },
04778baf
JA
1864 {
1865 .name = "randseed",
1866 .lname = "The random generator seed",
363cffa7 1867 .type = FIO_OPT_STR_VAL,
04778baf
JA
1868 .off1 = td_var_offset(rand_seed),
1869 .help = "Set the random generator seed value",
40fe5e7b 1870 .def = "0x89",
04778baf
JA
1871 .parent = "rw",
1872 .category = FIO_OPT_C_IO,
1873 .group = FIO_OPT_G_RANDOM,
1874 },
2615cc4b
JA
1875 {
1876 .name = "use_os_rand",
e8b0e958 1877 .lname = "Use OS random",
54a21917
JA
1878 .type = FIO_OPT_DEPRECATED,
1879 .off1 = td_var_offset(dep_use_os_rand),
e8b0e958 1880 .category = FIO_OPT_C_IO,
3ceb458f 1881 .group = FIO_OPT_G_RANDOM,
2615cc4b 1882 },
214e1eca
JA
1883 {
1884 .name = "norandommap",
e8b0e958 1885 .lname = "No randommap",
214e1eca
JA
1886 .type = FIO_OPT_STR_SET,
1887 .off1 = td_var_offset(norandommap),
1888 .help = "Accept potential duplicate random blocks",
67a1000f 1889 .parent = "rw",
d71c154c 1890 .hide = 1,
b2452a43 1891 .hide_on_set = 1,
e8b0e958 1892 .category = FIO_OPT_C_IO,
3ceb458f 1893 .group = FIO_OPT_G_RANDOM,
214e1eca 1894 },
2b386d25
JA
1895 {
1896 .name = "softrandommap",
e8b0e958 1897 .lname = "Soft randommap",
2b386d25
JA
1898 .type = FIO_OPT_BOOL,
1899 .off1 = td_var_offset(softrandommap),
f66ab3c8 1900 .help = "Set norandommap if randommap allocation fails",
2b386d25 1901 .parent = "norandommap",
d71c154c 1902 .hide = 1,
2b386d25 1903 .def = "0",
e8b0e958 1904 .category = FIO_OPT_C_IO,
3ceb458f 1905 .group = FIO_OPT_G_RANDOM,
2b386d25 1906 },
8055e41d
JA
1907 {
1908 .name = "random_generator",
1909 .type = FIO_OPT_STR,
1910 .off1 = td_var_offset(random_generator),
1911 .help = "Type of random number generator to use",
1912 .def = "tausworthe",
1913 .posval = {
1914 { .ival = "tausworthe",
1915 .oval = FIO_RAND_GEN_TAUSWORTHE,
1916 .help = "Strong Tausworthe generator",
1917 },
1918 { .ival = "lfsr",
1919 .oval = FIO_RAND_GEN_LFSR,
1920 .help = "Variable length LFSR",
1921 },
c3546b53
JA
1922 {
1923 .ival = "tausworthe64",
1924 .oval = FIO_RAND_GEN_TAUSWORTHE64,
1925 .help = "64-bit Tausworthe variant",
1926 },
8055e41d 1927 },
48107598
JA
1928 .category = FIO_OPT_C_IO,
1929 .group = FIO_OPT_G_RANDOM,
8055e41d 1930 },
e25839d4
JA
1931 {
1932 .name = "random_distribution",
1933 .type = FIO_OPT_STR,
1934 .off1 = td_var_offset(random_distribution),
1935 .cb = str_random_distribution_cb,
1936 .help = "Random offset distribution generator",
1937 .def = "random",
1938 .posval = {
1939 { .ival = "random",
1940 .oval = FIO_RAND_DIST_RANDOM,
1941 .help = "Completely random",
1942 },
1943 { .ival = "zipf",
1944 .oval = FIO_RAND_DIST_ZIPF,
1945 .help = "Zipf distribution",
1946 },
925fee33
JA
1947 { .ival = "pareto",
1948 .oval = FIO_RAND_DIST_PARETO,
1949 .help = "Pareto distribution",
1950 },
56d9fa4b
JA
1951 { .ival = "normal",
1952 .oval = FIO_RAND_DIST_GAUSS,
1953 .help = "Normal (gaussian) distribution",
1954 },
e0a04ac1
JA
1955 { .ival = "zoned",
1956 .oval = FIO_RAND_DIST_ZONED,
1957 .help = "Zoned random distribution",
1958 },
1959
e25839d4 1960 },
48107598
JA
1961 .category = FIO_OPT_C_IO,
1962 .group = FIO_OPT_G_RANDOM,
e25839d4 1963 },
211c9b89
JA
1964 {
1965 .name = "percentage_random",
1966 .lname = "Percentage Random",
1967 .type = FIO_OPT_INT,
d9472271
JA
1968 .off1 = td_var_offset(perc_rand[DDIR_READ]),
1969 .off2 = td_var_offset(perc_rand[DDIR_WRITE]),
1970 .off3 = td_var_offset(perc_rand[DDIR_TRIM]),
211c9b89
JA
1971 .maxval = 100,
1972 .help = "Percentage of seq/random mix that should be random",
d9472271 1973 .def = "100,100,100",
211c9b89
JA
1974 .interval = 5,
1975 .inverse = "percentage_sequential",
1976 .category = FIO_OPT_C_IO,
1977 .group = FIO_OPT_G_RANDOM,
1978 },
1979 {
1980 .name = "percentage_sequential",
1981 .lname = "Percentage Sequential",
d9472271 1982 .type = FIO_OPT_DEPRECATED,
211c9b89
JA
1983 .category = FIO_OPT_C_IO,
1984 .group = FIO_OPT_G_RANDOM,
1985 },
56e2a5fc
CE
1986 {
1987 .name = "allrandrepeat",
1988 .type = FIO_OPT_BOOL,
1989 .off1 = td_var_offset(allrand_repeatable),
1990 .help = "Use repeatable random numbers for everything",
1991 .def = "0",
a869d9c6
JA
1992 .category = FIO_OPT_C_IO,
1993 .group = FIO_OPT_G_RANDOM,
56e2a5fc 1994 },
214e1eca
JA
1995 {
1996 .name = "nrfiles",
e8b0e958 1997 .lname = "Number of files",
d7c8be03 1998 .alias = "nr_files",
214e1eca
JA
1999 .type = FIO_OPT_INT,
2000 .off1 = td_var_offset(nr_files),
2001 .help = "Split job workload between this number of files",
2002 .def = "1",
20eb06bd 2003 .interval = 1,
e8b0e958
JA
2004 .category = FIO_OPT_C_FILE,
2005 .group = FIO_OPT_G_INVALID,
214e1eca
JA
2006 },
2007 {
2008 .name = "openfiles",
e8b0e958 2009 .lname = "Number of open files",
214e1eca
JA
2010 .type = FIO_OPT_INT,
2011 .off1 = td_var_offset(open_files),
2012 .help = "Number of files to keep open at the same time",
e8b0e958
JA
2013 .category = FIO_OPT_C_FILE,
2014 .group = FIO_OPT_G_INVALID,
214e1eca
JA
2015 },
2016 {
2017 .name = "file_service_type",
e8b0e958 2018 .lname = "File service type",
214e1eca
JA
2019 .type = FIO_OPT_STR,
2020 .cb = str_fst_cb,
2021 .off1 = td_var_offset(file_service_type),
2022 .help = "How to select which file to service next",
2023 .def = "roundrobin",
e8b0e958
JA
2024 .category = FIO_OPT_C_FILE,
2025 .group = FIO_OPT_G_INVALID,
214e1eca
JA
2026 .posval = {
2027 { .ival = "random",
2028 .oval = FIO_FSERVICE_RANDOM,
2029 .help = "Choose a file at random",
2030 },
2031 { .ival = "roundrobin",
2032 .oval = FIO_FSERVICE_RR,
2033 .help = "Round robin select files",
2034 },
a086c257
JA
2035 { .ival = "sequential",
2036 .oval = FIO_FSERVICE_SEQ,
2037 .help = "Finish one file before moving to the next",
2038 },
214e1eca 2039 },
67a1000f 2040 .parent = "nrfiles",
d71c154c 2041 .hide = 1,
67a1000f 2042 },
97ac992c 2043#ifdef CONFIG_POSIX_FALLOCATE
7bc8c2cf
JA
2044 {
2045 .name = "fallocate",
e8b0e958 2046 .lname = "Fallocate",
a596f047
EG
2047 .type = FIO_OPT_STR,
2048 .off1 = td_var_offset(fallocate_mode),
2049 .help = "Whether pre-allocation is performed when laying out files",
2050 .def = "posix",
e8b0e958
JA
2051 .category = FIO_OPT_C_FILE,
2052 .group = FIO_OPT_G_INVALID,
a596f047
EG
2053 .posval = {
2054 { .ival = "none",
2055 .oval = FIO_FALLOCATE_NONE,
2056 .help = "Do not pre-allocate space",
2057 },
2058 { .ival = "posix",
2059 .oval = FIO_FALLOCATE_POSIX,
2060 .help = "Use posix_fallocate()",
2061 },
97ac992c 2062#ifdef CONFIG_LINUX_FALLOCATE
a596f047
EG
2063 { .ival = "keep",
2064 .oval = FIO_FALLOCATE_KEEP_SIZE,
2065 .help = "Use fallocate(..., FALLOC_FL_KEEP_SIZE, ...)",
2066 },
7bc8c2cf 2067#endif
a596f047
EG
2068 /* Compatibility with former boolean values */
2069 { .ival = "0",
2070 .oval = FIO_FALLOCATE_NONE,
2071 .help = "Alias for 'none'",
2072 },
2073 { .ival = "1",
2074 .oval = FIO_FALLOCATE_POSIX,
2075 .help = "Alias for 'posix'",
2076 },
2077 },
2078 },
97ac992c 2079#endif /* CONFIG_POSIX_FALLOCATE */
67a1000f
JA
2080 {
2081 .name = "fadvise_hint",
e8b0e958 2082 .lname = "Fadvise hint",
67a1000f
JA
2083 .type = FIO_OPT_BOOL,
2084 .off1 = td_var_offset(fadvise_hint),
2085 .help = "Use fadvise() to advise the kernel on IO pattern",
2086 .def = "1",
e8b0e958
JA
2087 .category = FIO_OPT_C_FILE,
2088 .group = FIO_OPT_G_INVALID,
214e1eca 2089 },
37659335
JA
2090#ifdef FIO_HAVE_STREAMID
2091 {
2092 .name = "fadvise_stream",
2093 .lname = "Fadvise stream",
2094 .type = FIO_OPT_INT,
2095 .off1 = td_var_offset(fadvise_stream),
2096 .help = "Use fadvise() to set stream ID",
2097 .category = FIO_OPT_C_FILE,
2098 .group = FIO_OPT_G_INVALID,
2099 },
2100#endif
214e1eca
JA
2101 {
2102 .name = "fsync",
e8b0e958 2103 .lname = "Fsync",
214e1eca
JA
2104 .type = FIO_OPT_INT,
2105 .off1 = td_var_offset(fsync_blocks),
2106 .help = "Issue fsync for writes every given number of blocks",
2107 .def = "0",
20eb06bd 2108 .interval = 1,
e8b0e958
JA
2109 .category = FIO_OPT_C_FILE,
2110 .group = FIO_OPT_G_INVALID,
214e1eca 2111 },
5f9099ea
JA
2112 {
2113 .name = "fdatasync",
e8b0e958 2114 .lname = "Fdatasync",
5f9099ea
JA
2115 .type = FIO_OPT_INT,
2116 .off1 = td_var_offset(fdatasync_blocks),
2117 .help = "Issue fdatasync for writes every given number of blocks",
2118 .def = "0",
20eb06bd 2119 .interval = 1,
e8b0e958
JA
2120 .category = FIO_OPT_C_FILE,
2121 .group = FIO_OPT_G_INVALID,
5f9099ea 2122 },
1ef2b6be
JA
2123 {
2124 .name = "write_barrier",
e8b0e958 2125 .lname = "Write barrier",
1ef2b6be
JA
2126 .type = FIO_OPT_INT,
2127 .off1 = td_var_offset(barrier_blocks),
2128 .help = "Make every Nth write a barrier write",
2129 .def = "0",
20eb06bd 2130 .interval = 1,
e8b0e958
JA
2131 .category = FIO_OPT_C_IO,
2132 .group = FIO_OPT_G_INVALID,
1ef2b6be 2133 },
67bf9823 2134#ifdef CONFIG_SYNC_FILE_RANGE
44f29692
JA
2135 {
2136 .name = "sync_file_range",
e8b0e958 2137 .lname = "Sync file range",
44f29692
JA
2138 .posval = {
2139 { .ival = "wait_before",
2140 .oval = SYNC_FILE_RANGE_WAIT_BEFORE,
2141 .help = "SYNC_FILE_RANGE_WAIT_BEFORE",
ebadc0ce 2142 .orval = 1,
44f29692
JA
2143 },
2144 { .ival = "write",
2145 .oval = SYNC_FILE_RANGE_WRITE,
2146 .help = "SYNC_FILE_RANGE_WRITE",
ebadc0ce 2147 .orval = 1,
44f29692
JA
2148 },
2149 {
2150 .ival = "wait_after",
2151 .oval = SYNC_FILE_RANGE_WAIT_AFTER,
2152 .help = "SYNC_FILE_RANGE_WAIT_AFTER",
ebadc0ce 2153 .orval = 1,
44f29692
JA
2154 },
2155 },
3843deb3 2156 .type = FIO_OPT_STR_MULTI,
44f29692
JA
2157 .cb = str_sfr_cb,
2158 .off1 = td_var_offset(sync_file_range),
2159 .help = "Use sync_file_range()",
e8b0e958
JA
2160 .category = FIO_OPT_C_FILE,
2161 .group = FIO_OPT_G_INVALID,
44f29692
JA
2162 },
2163#endif
214e1eca
JA
2164 {
2165 .name = "direct",
e8b0e958 2166 .lname = "Direct I/O",
214e1eca
JA
2167 .type = FIO_OPT_BOOL,
2168 .off1 = td_var_offset(odirect),
2169 .help = "Use O_DIRECT IO (negates buffered)",
2170 .def = "0",
a01a1bc5 2171 .inverse = "buffered",
e8b0e958 2172 .category = FIO_OPT_C_IO,
3ceb458f 2173 .group = FIO_OPT_G_IO_TYPE,
214e1eca 2174 },
d01612f3
CM
2175 {
2176 .name = "atomic",
2177 .lname = "Atomic I/O",
2178 .type = FIO_OPT_BOOL,
2179 .off1 = td_var_offset(oatomic),
2180 .help = "Use Atomic IO with O_DIRECT (implies O_DIRECT)",
2181 .def = "0",
2182 .category = FIO_OPT_C_IO,
2183 .group = FIO_OPT_G_IO_TYPE,
2184 },
214e1eca
JA
2185 {
2186 .name = "buffered",
e8b0e958 2187 .lname = "Buffered I/O",
214e1eca
JA
2188 .type = FIO_OPT_BOOL,
2189 .off1 = td_var_offset(odirect),
2190 .neg = 1,
2191 .help = "Use buffered IO (negates direct)",
2192 .def = "1",
a01a1bc5 2193 .inverse = "direct",
e8b0e958 2194 .category = FIO_OPT_C_IO,
3ceb458f 2195 .group = FIO_OPT_G_IO_TYPE,
214e1eca
JA
2196 },
2197 {
2198 .name = "overwrite",
e8b0e958 2199 .lname = "Overwrite",
214e1eca
JA
2200 .type = FIO_OPT_BOOL,
2201 .off1 = td_var_offset(overwrite),
2202 .help = "When writing, set whether to overwrite current data",
2203 .def = "0",
e8b0e958
JA
2204 .category = FIO_OPT_C_FILE,
2205 .group = FIO_OPT_G_INVALID,
214e1eca
JA
2206 },
2207 {
2208 .name = "loops",
e8b0e958 2209 .lname = "Loops",
214e1eca
JA
2210 .type = FIO_OPT_INT,
2211 .off1 = td_var_offset(loops),
2212 .help = "Number of times to run the job",
2213 .def = "1",
20eb06bd 2214 .interval = 1,
e8b0e958 2215 .category = FIO_OPT_C_GENERAL,
a1f6afec 2216 .group = FIO_OPT_G_RUNTIME,
214e1eca
JA
2217 },
2218 {
2219 .name = "numjobs",
e8b0e958 2220 .lname = "Number of jobs",
214e1eca
JA
2221 .type = FIO_OPT_INT,
2222 .off1 = td_var_offset(numjobs),
2223 .help = "Duplicate this job this many times",
2224 .def = "1",
20eb06bd 2225 .interval = 1,
e8b0e958 2226 .category = FIO_OPT_C_GENERAL,
a1f6afec 2227 .group = FIO_OPT_G_RUNTIME,
214e1eca
JA
2228 },
2229 {
2230 .name = "startdelay",
e8b0e958 2231 .lname = "Start delay",
a5737c93 2232 .type = FIO_OPT_STR_VAL_TIME,
214e1eca 2233 .off1 = td_var_offset(start_delay),
23ed19b0 2234 .off2 = td_var_offset(start_delay_high),
214e1eca
JA
2235 .help = "Only start job when this period has passed",
2236 .def = "0",
0de5b26f 2237 .is_seconds = 1,
88038bc7 2238 .is_time = 1,
e8b0e958 2239 .category = FIO_OPT_C_GENERAL,
a1f6afec 2240 .group = FIO_OPT_G_RUNTIME,
214e1eca
JA
2241 },
2242 {
2243 .name = "runtime",
e8b0e958 2244 .lname = "Runtime",
214e1eca
JA
2245 .alias = "timeout",
2246 .type = FIO_OPT_STR_VAL_TIME,
2247 .off1 = td_var_offset(timeout),
2248 .help = "Stop workload when this amount of time has passed",
2249 .def = "0",
0de5b26f 2250 .is_seconds = 1,
88038bc7 2251 .is_time = 1,
e8b0e958 2252 .category = FIO_OPT_C_GENERAL,
a1f6afec 2253 .group = FIO_OPT_G_RUNTIME,
214e1eca 2254 },
cf4464ca
JA
2255 {
2256 .name = "time_based",
e8b0e958 2257 .lname = "Time based",
cf4464ca
JA
2258 .type = FIO_OPT_STR_SET,
2259 .off1 = td_var_offset(time_based),
2260 .help = "Keep running until runtime/timeout is met",
e8b0e958 2261 .category = FIO_OPT_C_GENERAL,
a1f6afec 2262 .group = FIO_OPT_G_RUNTIME,
cf4464ca 2263 },
62167762
JC
2264 {
2265 .name = "verify_only",
2266 .lname = "Verify only",
2267 .type = FIO_OPT_STR_SET,
2268 .off1 = td_var_offset(verify_only),
2269 .help = "Verifies previously written data is still valid",
2270 .category = FIO_OPT_C_GENERAL,
2271 .group = FIO_OPT_G_RUNTIME,
2272 },
721938ae
JA
2273 {
2274 .name = "ramp_time",
e8b0e958 2275 .lname = "Ramp time",
721938ae
JA
2276 .type = FIO_OPT_STR_VAL_TIME,
2277 .off1 = td_var_offset(ramp_time),
2278 .help = "Ramp up time before measuring performance",
0de5b26f 2279 .is_seconds = 1,
88038bc7 2280 .is_time = 1,
e8b0e958 2281 .category = FIO_OPT_C_GENERAL,
a1f6afec 2282 .group = FIO_OPT_G_RUNTIME,
721938ae 2283 },
c223da83
JA
2284 {
2285 .name = "clocksource",
e8b0e958 2286 .lname = "Clock source",
c223da83
JA
2287 .type = FIO_OPT_STR,
2288 .cb = fio_clock_source_cb,
2289 .off1 = td_var_offset(clocksource),
2290 .help = "What type of timing source to use",
e8b0e958 2291 .category = FIO_OPT_C_GENERAL,
10860056 2292 .group = FIO_OPT_G_CLOCK,
c223da83 2293 .posval = {
67bf9823 2294#ifdef CONFIG_GETTIMEOFDAY
c223da83
JA
2295 { .ival = "gettimeofday",
2296 .oval = CS_GTOD,
2297 .help = "Use gettimeofday(2) for timing",
2298 },
67bf9823
JA
2299#endif
2300#ifdef CONFIG_CLOCK_GETTIME
c223da83
JA
2301 { .ival = "clock_gettime",
2302 .oval = CS_CGETTIME,
2303 .help = "Use clock_gettime(2) for timing",
2304 },
67bf9823 2305#endif
c223da83
JA
2306#ifdef ARCH_HAVE_CPU_CLOCK
2307 { .ival = "cpu",
2308 .oval = CS_CPUCLOCK,
2309 .help = "Use CPU private clock",
2310 },
2311#endif
2312 },
2313 },
214e1eca
JA
2314 {
2315 .name = "mem",
d3aad8f2 2316 .alias = "iomem",
e8b0e958 2317 .lname = "I/O Memory",
214e1eca
JA
2318 .type = FIO_OPT_STR,
2319 .cb = str_mem_cb,
2320 .off1 = td_var_offset(mem_type),
2321 .help = "Backing type for IO buffers",
2322 .def = "malloc",
e8b0e958
JA
2323 .category = FIO_OPT_C_IO,
2324 .group = FIO_OPT_G_INVALID,
214e1eca
JA
2325 .posval = {
2326 { .ival = "malloc",
2327 .oval = MEM_MALLOC,
2328 .help = "Use malloc(3) for IO buffers",
2329 },
c8931876 2330#ifndef CONFIG_NO_SHM
37c8cdfe
JA
2331 { .ival = "shm",
2332 .oval = MEM_SHM,
2333 .help = "Use shared memory segments for IO buffers",
2334 },
214e1eca
JA
2335#ifdef FIO_HAVE_HUGETLB
2336 { .ival = "shmhuge",
2337 .oval = MEM_SHMHUGE,
2338 .help = "Like shm, but use huge pages",
2339 },
c8931876 2340#endif
b370e46a 2341#endif
37c8cdfe
JA
2342 { .ival = "mmap",
2343 .oval = MEM_MMAP,
2344 .help = "Use mmap(2) (file or anon) for IO buffers",
2345 },
217b0f1d
LG
2346 { .ival = "mmapshared",
2347 .oval = MEM_MMAPSHARED,
2348 .help = "Like mmap, but use the shared flag",
2349 },
214e1eca
JA
2350#ifdef FIO_HAVE_HUGETLB
2351 { .ival = "mmaphuge",
2352 .oval = MEM_MMAPHUGE,
2353 .help = "Like mmap, but use huge pages",
2354 },
2355#endif
2356 },
2357 },
d529ee19
JA
2358 {
2359 .name = "iomem_align",
2360 .alias = "mem_align",
e8b0e958 2361 .lname = "I/O memory alignment",
d529ee19
JA
2362 .type = FIO_OPT_INT,
2363 .off1 = td_var_offset(mem_align),
2364 .minval = 0,
2365 .help = "IO memory buffer offset alignment",
2366 .def = "0",
2367 .parent = "iomem",
d71c154c 2368 .hide = 1,
e8b0e958
JA
2369 .category = FIO_OPT_C_IO,
2370 .group = FIO_OPT_G_INVALID,
d529ee19 2371 },
214e1eca
JA
2372 {
2373 .name = "verify",
e8b0e958 2374 .lname = "Verify",
214e1eca
JA
2375 .type = FIO_OPT_STR,
2376 .off1 = td_var_offset(verify),
2377 .help = "Verify data written",
2378 .def = "0",
e8b0e958 2379 .category = FIO_OPT_C_IO,
3ceb458f 2380 .group = FIO_OPT_G_VERIFY,
214e1eca
JA
2381 .posval = {
2382 { .ival = "0",
2383 .oval = VERIFY_NONE,
2384 .help = "Don't do IO verification",
2385 },
fcca4b58
JA
2386 { .ival = "md5",
2387 .oval = VERIFY_MD5,
2388 .help = "Use md5 checksums for verification",
2389 },
d77a7af3
JA
2390 { .ival = "crc64",
2391 .oval = VERIFY_CRC64,
2392 .help = "Use crc64 checksums for verification",
2393 },
214e1eca
JA
2394 { .ival = "crc32",
2395 .oval = VERIFY_CRC32,
2396 .help = "Use crc32 checksums for verification",
2397 },
af497e6a 2398 { .ival = "crc32c-intel",
e3aaafc4
JA
2399 .oval = VERIFY_CRC32C,
2400 .help = "Use crc32c checksums for verification (hw assisted, if available)",
af497e6a 2401 },
bac39e0e
JA
2402 { .ival = "crc32c",
2403 .oval = VERIFY_CRC32C,
e3aaafc4 2404 .help = "Use crc32c checksums for verification (hw assisted, if available)",
bac39e0e 2405 },
969f7ed3
JA
2406 { .ival = "crc16",
2407 .oval = VERIFY_CRC16,
2408 .help = "Use crc16 checksums for verification",
2409 },
1e154bdb
JA
2410 { .ival = "crc7",
2411 .oval = VERIFY_CRC7,
2412 .help = "Use crc7 checksums for verification",
2413 },
7c353ceb
JA
2414 { .ival = "sha1",
2415 .oval = VERIFY_SHA1,
2416 .help = "Use sha1 checksums for verification",
2417 },
cd14cc10
JA
2418 { .ival = "sha256",
2419 .oval = VERIFY_SHA256,
2420 .help = "Use sha256 checksums for verification",
2421 },
2422 { .ival = "sha512",
2423 .oval = VERIFY_SHA512,
2424 .help = "Use sha512 checksums for verification",
2425 },
844ea602
JA
2426 { .ival = "xxhash",
2427 .oval = VERIFY_XXHASH,
2428 .help = "Use xxhash checksums for verification",
2429 },
b638d82f
RP
2430 /* Meta information was included into verify_header,
2431 * 'meta' verification is implied by default. */
7437ee87 2432 { .ival = "meta",
b638d82f
RP
2433 .oval = VERIFY_HDR_ONLY,
2434 .help = "Use io information for verification. "
2435 "Now is implied by default, thus option is obsolete, "
2436 "don't use it",
7437ee87 2437 },
59245381
JA
2438 { .ival = "pattern",
2439 .oval = VERIFY_PATTERN_NO_HDR,
2440 .help = "Verify strict pattern",
2441 },
36690c9b
JA
2442 {
2443 .ival = "null",
2444 .oval = VERIFY_NULL,
2445 .help = "Pretend to verify",
2446 },
214e1eca
JA
2447 },
2448 },
005c565a
JA
2449 {
2450 .name = "do_verify",
e8b0e958 2451 .lname = "Perform verify step",
68e1f29a 2452 .type = FIO_OPT_BOOL,
005c565a
JA
2453 .off1 = td_var_offset(do_verify),
2454 .help = "Run verification stage after write",
2455 .def = "1",
2456 .parent = "verify",
d71c154c 2457 .hide = 1,
e8b0e958
JA
2458 .category = FIO_OPT_C_IO,
2459 .group = FIO_OPT_G_VERIFY,
005c565a 2460 },
160b966d
JA
2461 {
2462 .name = "verifysort",
e8b0e958 2463 .lname = "Verify sort",
160b966d
JA
2464 .type = FIO_OPT_BOOL,
2465 .off1 = td_var_offset(verifysort),
2466 .help = "Sort written verify blocks for read back",
2467 .def = "1",
c83f2df1 2468 .parent = "verify",
d71c154c 2469 .hide = 1,
e8b0e958
JA
2470 .category = FIO_OPT_C_IO,
2471 .group = FIO_OPT_G_VERIFY,
160b966d 2472 },
1ae83d45
JA
2473 {
2474 .name = "verifysort_nr",
2475 .type = FIO_OPT_INT,
2476 .off1 = td_var_offset(verifysort_nr),
2477 .help = "Pre-load and sort verify blocks for a read workload",
2478 .minval = 0,
2479 .maxval = 131072,
2480 .def = "1024",
2481 .parent = "verify",
836fcc0f
JA
2482 .category = FIO_OPT_C_IO,
2483 .group = FIO_OPT_G_VERIFY,
1ae83d45 2484 },
3f9f4e26 2485 {
a59e170d 2486 .name = "verify_interval",
e8b0e958 2487 .lname = "Verify interval",
e01b22b8 2488 .type = FIO_OPT_INT,
a59e170d 2489 .off1 = td_var_offset(verify_interval),
819a9680 2490 .minval = 2 * sizeof(struct verify_header),
a59e170d 2491 .help = "Store verify buffer header every N bytes",
afdf9352 2492 .parent = "verify",
d71c154c 2493 .hide = 1,
20eb06bd 2494 .interval = 2 * sizeof(struct verify_header),
e8b0e958
JA
2495 .category = FIO_OPT_C_IO,
2496 .group = FIO_OPT_G_VERIFY,
3f9f4e26 2497 },
546a9142 2498 {
a59e170d 2499 .name = "verify_offset",
e8b0e958 2500 .lname = "Verify offset",
e01b22b8 2501 .type = FIO_OPT_INT,
a59e170d 2502 .help = "Offset verify header location by N bytes",
203160d5
JA
2503 .off1 = td_var_offset(verify_offset),
2504 .minval = sizeof(struct verify_header),
afdf9352 2505 .parent = "verify",
d71c154c 2506 .hide = 1,
e8b0e958
JA
2507 .category = FIO_OPT_C_IO,
2508 .group = FIO_OPT_G_VERIFY,
546a9142 2509 },
e28218f3
SL
2510 {
2511 .name = "verify_pattern",
e8b0e958 2512 .lname = "Verify pattern",
0e92f873 2513 .type = FIO_OPT_STR,
e28218f3 2514 .cb = str_verify_pattern_cb,
a8523a6a 2515 .off1 = td_var_offset(verify_pattern),
e28218f3
SL
2516 .help = "Fill pattern for IO buffers",
2517 .parent = "verify",
d71c154c 2518 .hide = 1,
e8b0e958
JA
2519 .category = FIO_OPT_C_IO,
2520 .group = FIO_OPT_G_VERIFY,
e28218f3 2521 },
a12a3b4d
JA
2522 {
2523 .name = "verify_fatal",
e8b0e958 2524 .lname = "Verify fatal",
68e1f29a 2525 .type = FIO_OPT_BOOL,
a12a3b4d
JA
2526 .off1 = td_var_offset(verify_fatal),
2527 .def = "0",
2528 .help = "Exit on a single verify failure, don't continue",
2529 .parent = "verify",
d71c154c 2530 .hide = 1,
e8b0e958
JA
2531 .category = FIO_OPT_C_IO,
2532 .group = FIO_OPT_G_VERIFY,
a12a3b4d 2533 },
b463e936
JA
2534 {
2535 .name = "verify_dump",
e8b0e958 2536 .lname = "Verify dump",
b463e936
JA
2537 .type = FIO_OPT_BOOL,
2538 .off1 = td_var_offset(verify_dump),
ef71e317 2539 .def = "0",
b463e936
JA
2540 .help = "Dump contents of good and bad blocks on failure",
2541 .parent = "verify",
d71c154c 2542 .hide = 1,
e8b0e958
JA
2543 .category = FIO_OPT_C_IO,
2544 .group = FIO_OPT_G_VERIFY,
b463e936 2545 },
e8462bd8
JA
2546 {
2547 .name = "verify_async",
e8b0e958 2548 .lname = "Verify asynchronously",
e8462bd8
JA
2549 .type = FIO_OPT_INT,
2550 .off1 = td_var_offset(verify_async),
2551 .def = "0",
2552 .help = "Number of async verifier threads to use",
2553 .parent = "verify",
d71c154c 2554 .hide = 1,
e8b0e958
JA
2555 .category = FIO_OPT_C_IO,
2556 .group = FIO_OPT_G_VERIFY,
e8462bd8 2557 },
9e144189
JA
2558 {
2559 .name = "verify_backlog",
e8b0e958 2560 .lname = "Verify backlog",
9e144189
JA
2561 .type = FIO_OPT_STR_VAL,
2562 .off1 = td_var_offset(verify_backlog),
2563 .help = "Verify after this number of blocks are written",
2564 .parent = "verify",
d71c154c 2565 .hide = 1,
e8b0e958
JA
2566 .category = FIO_OPT_C_IO,
2567 .group = FIO_OPT_G_VERIFY,
9e144189
JA
2568 },
2569 {
2570 .name = "verify_backlog_batch",
e8b0e958 2571 .lname = "Verify backlog batch",
9e144189
JA
2572 .type = FIO_OPT_INT,
2573 .off1 = td_var_offset(verify_batch),
2574 .help = "Verify this number of IO blocks",
0d29de83 2575 .parent = "verify",
d71c154c 2576 .hide = 1,
e8b0e958
JA
2577 .category = FIO_OPT_C_IO,
2578 .group = FIO_OPT_G_VERIFY,
9e144189 2579 },
e8462bd8
JA
2580#ifdef FIO_HAVE_CPU_AFFINITY
2581 {
2582 .name = "verify_async_cpus",
e8b0e958 2583 .lname = "Async verify CPUs",
e8462bd8
JA
2584 .type = FIO_OPT_STR,
2585 .cb = str_verify_cpus_allowed_cb,
a8523a6a 2586 .off1 = td_var_offset(verify_cpumask),
e8462bd8
JA
2587 .help = "Set CPUs allowed for async verify threads",
2588 .parent = "verify_async",
d71c154c 2589 .hide = 1,
e8b0e958
JA
2590 .category = FIO_OPT_C_IO,
2591 .group = FIO_OPT_G_VERIFY,
e8462bd8 2592 },
0d29de83 2593#endif
51aa2da8
JA
2594 {
2595 .name = "experimental_verify",
2596 .off1 = td_var_offset(experimental_verify),
2597 .type = FIO_OPT_BOOL,
b31eaac9 2598 .help = "Enable experimental verification",
ca09be4b
JA
2599 .parent = "verify",
2600 .category = FIO_OPT_C_IO,
2601 .group = FIO_OPT_G_VERIFY,
2602 },
2603 {
2604 .name = "verify_state_load",
2605 .lname = "Load verify state",
2606 .off1 = td_var_offset(verify_state),
2607 .type = FIO_OPT_BOOL,
2608 .help = "Load verify termination state",
2609 .parent = "verify",
2610 .category = FIO_OPT_C_IO,
2611 .group = FIO_OPT_G_VERIFY,
2612 },
2613 {
2614 .name = "verify_state_save",
2615 .lname = "Save verify state",
2616 .off1 = td_var_offset(verify_state_save),
2617 .type = FIO_OPT_BOOL,
2618 .def = "1",
2619 .help = "Save verify state on termination",
2620 .parent = "verify",
836fcc0f
JA
2621 .category = FIO_OPT_C_IO,
2622 .group = FIO_OPT_G_VERIFY,
51aa2da8 2623 },
0d29de83
JA
2624#ifdef FIO_HAVE_TRIM
2625 {
2626 .name = "trim_percentage",
e8b0e958 2627 .lname = "Trim percentage",
0d29de83 2628 .type = FIO_OPT_INT,
203160d5 2629 .off1 = td_var_offset(trim_percentage),
20eb06bd 2630 .minval = 0,
0d29de83
JA
2631 .maxval = 100,
2632 .help = "Number of verify blocks to discard/trim",
2633 .parent = "verify",
2634 .def = "0",
20eb06bd 2635 .interval = 1,
d71c154c 2636 .hide = 1,
e8b0e958
JA
2637 .category = FIO_OPT_C_IO,
2638 .group = FIO_OPT_G_TRIM,
0d29de83
JA
2639 },
2640 {
2641 .name = "trim_verify_zero",
e8b0e958 2642 .lname = "Verify trim zero",
20eb06bd 2643 .type = FIO_OPT_BOOL,
0d29de83
JA
2644 .help = "Verify that trim/discarded blocks are returned as zeroes",
2645 .off1 = td_var_offset(trim_zero),
2646 .parent = "trim_percentage",
d71c154c 2647 .hide = 1,
0d29de83 2648 .def = "1",
e8b0e958
JA
2649 .category = FIO_OPT_C_IO,
2650 .group = FIO_OPT_G_TRIM,
0d29de83
JA
2651 },
2652 {
2653 .name = "trim_backlog",
e8b0e958 2654 .lname = "Trim backlog",
0d29de83
JA
2655 .type = FIO_OPT_STR_VAL,
2656 .off1 = td_var_offset(trim_backlog),
2657 .help = "Trim after this number of blocks are written",
2658 .parent = "trim_percentage",
d71c154c 2659 .hide = 1,
20eb06bd 2660 .interval = 1,
e8b0e958
JA
2661 .category = FIO_OPT_C_IO,
2662 .group = FIO_OPT_G_TRIM,
0d29de83
JA
2663 },
2664 {
2665 .name = "trim_backlog_batch",
e8b0e958 2666 .lname = "Trim backlog batch",
0d29de83
JA
2667 .type = FIO_OPT_INT,
2668 .off1 = td_var_offset(trim_batch),
2669 .help = "Trim this number of IO blocks",
2670 .parent = "trim_percentage",
d71c154c 2671 .hide = 1,
20eb06bd 2672 .interval = 1,
e8b0e958
JA
2673 .category = FIO_OPT_C_IO,
2674 .group = FIO_OPT_G_TRIM,
0d29de83 2675 },
e8462bd8 2676#endif
214e1eca
JA
2677 {
2678 .name = "write_iolog",
e8b0e958 2679 .lname = "Write I/O log",
214e1eca
JA
2680 .type = FIO_OPT_STR_STORE,
2681 .off1 = td_var_offset(write_iolog_file),
2682 .help = "Store IO pattern to file",
e8b0e958
JA
2683 .category = FIO_OPT_C_IO,
2684 .group = FIO_OPT_G_IOLOG,
214e1eca
JA
2685 },
2686 {
2687 .name = "read_iolog",
e8b0e958 2688 .lname = "Read I/O log",
214e1eca
JA
2689 .type = FIO_OPT_STR_STORE,
2690 .off1 = td_var_offset(read_iolog_file),
2691 .help = "Playback IO pattern from file",
e8b0e958
JA
2692 .category = FIO_OPT_C_IO,
2693 .group = FIO_OPT_G_IOLOG,
214e1eca 2694 },
64bbb865
DN
2695 {
2696 .name = "replay_no_stall",
e8b0e958 2697 .lname = "Don't stall on replay",
20eb06bd 2698 .type = FIO_OPT_BOOL,
64bbb865
DN
2699 .off1 = td_var_offset(no_stall),
2700 .def = "0",
87e7a972 2701 .parent = "read_iolog",
d71c154c 2702 .hide = 1,
64bbb865 2703 .help = "Playback IO pattern file as fast as possible without stalls",
e8b0e958
JA
2704 .category = FIO_OPT_C_IO,
2705 .group = FIO_OPT_G_IOLOG,
64bbb865 2706 },
d1c46c04
DN
2707 {
2708 .name = "replay_redirect",
e8b0e958 2709 .lname = "Redirect device for replay",
d1c46c04
DN
2710 .type = FIO_OPT_STR_STORE,
2711 .off1 = td_var_offset(replay_redirect),
2712 .parent = "read_iolog",
d71c154c 2713 .hide = 1,
d1c46c04 2714 .help = "Replay all I/O onto this device, regardless of trace device",
e8b0e958
JA
2715 .category = FIO_OPT_C_IO,
2716 .group = FIO_OPT_G_IOLOG,
d1c46c04 2717 },
0c63576e
JA
2718 {
2719 .name = "replay_scale",
2720 .lname = "Replace offset scale factor",
2721 .type = FIO_OPT_INT,
2722 .off1 = td_var_offset(replay_scale),
2723 .parent = "read_iolog",
2724 .def = "1",
2725 .help = "Align offsets to this blocksize",
2726 .category = FIO_OPT_C_IO,
2727 .group = FIO_OPT_G_IOLOG,
2728 },
2729 {
2730 .name = "replay_align",
2731 .lname = "Replace alignment",
2732 .type = FIO_OPT_INT,
2733 .off1 = td_var_offset(replay_align),
2734 .parent = "read_iolog",
2735 .help = "Scale offset down by this factor",
2736 .category = FIO_OPT_C_IO,
2737 .group = FIO_OPT_G_IOLOG,
2738 .pow2 = 1,
2739 },
214e1eca
JA
2740 {
2741 .name = "exec_prerun",
e8b0e958 2742 .lname = "Pre-execute runnable",
214e1eca
JA
2743 .type = FIO_OPT_STR_STORE,
2744 .off1 = td_var_offset(exec_prerun),
2745 .help = "Execute this file prior to running job",
e8b0e958
JA
2746 .category = FIO_OPT_C_GENERAL,
2747 .group = FIO_OPT_G_INVALID,
214e1eca
JA
2748 },
2749 {
2750 .name = "exec_postrun",
e8b0e958 2751 .lname = "Post-execute runnable",
214e1eca
JA
2752 .type = FIO_OPT_STR_STORE,
2753 .off1 = td_var_offset(exec_postrun),
2754 .help = "Execute this file after running job",
e8b0e958
JA
2755 .category = FIO_OPT_C_GENERAL,
2756 .group = FIO_OPT_G_INVALID,
214e1eca
JA
2757 },
2758#ifdef FIO_HAVE_IOSCHED_SWITCH
2759 {
2760 .name = "ioscheduler",
e8b0e958 2761 .lname = "I/O scheduler",
214e1eca
JA
2762 .type = FIO_OPT_STR_STORE,
2763 .off1 = td_var_offset(ioscheduler),
2764 .help = "Use this IO scheduler on the backing device",
e8b0e958
JA
2765 .category = FIO_OPT_C_FILE,
2766 .group = FIO_OPT_G_INVALID,
214e1eca
JA
2767 },
2768#endif
2769 {
2770 .name = "zonesize",
e8b0e958 2771 .lname = "Zone size",
214e1eca
JA
2772 .type = FIO_OPT_STR_VAL,
2773 .off1 = td_var_offset(zone_size),
ed335855
SN
2774 .help = "Amount of data to read per zone",
2775 .def = "0",
20eb06bd 2776 .interval = 1024 * 1024,
e8b0e958
JA
2777 .category = FIO_OPT_C_IO,
2778 .group = FIO_OPT_G_ZONE,
ed335855
SN
2779 },
2780 {
2781 .name = "zonerange",
e8b0e958 2782 .lname = "Zone range",
ed335855
SN
2783 .type = FIO_OPT_STR_VAL,
2784 .off1 = td_var_offset(zone_range),
214e1eca
JA
2785 .help = "Give size of an IO zone",
2786 .def = "0",
20eb06bd 2787 .interval = 1024 * 1024,
e8b0e958
JA
2788 .category = FIO_OPT_C_IO,
2789 .group = FIO_OPT_G_ZONE,
214e1eca
JA
2790 },
2791 {
2792 .name = "zoneskip",
e8b0e958 2793 .lname = "Zone skip",
214e1eca
JA
2794 .type = FIO_OPT_STR_VAL,
2795 .off1 = td_var_offset(zone_skip),
2796 .help = "Space between IO zones",
2797 .def = "0",
20eb06bd 2798 .interval = 1024 * 1024,
e8b0e958
JA
2799 .category = FIO_OPT_C_IO,
2800 .group = FIO_OPT_G_ZONE,
214e1eca
JA
2801 },
2802 {
2803 .name = "lockmem",
e8b0e958 2804 .lname = "Lock memory",
214e1eca 2805 .type = FIO_OPT_STR_VAL,
1b79a070 2806 .off1 = td_var_offset(lockmem),
81c6b6cd 2807 .help = "Lock down this amount of memory (per worker)",
214e1eca 2808 .def = "0",
20eb06bd 2809 .interval = 1024 * 1024,
e8b0e958
JA
2810 .category = FIO_OPT_C_GENERAL,
2811 .group = FIO_OPT_G_INVALID,
214e1eca 2812 },
214e1eca
JA
2813 {
2814 .name = "rwmixread",
e8b0e958 2815 .lname = "Read/write mix read",
214e1eca 2816 .type = FIO_OPT_INT,
cb499fc4 2817 .cb = str_rwmix_read_cb,
a8523a6a 2818 .off1 = td_var_offset(rwmix[DDIR_READ]),
214e1eca
JA
2819 .maxval = 100,
2820 .help = "Percentage of mixed workload that is reads",
2821 .def = "50",
20eb06bd 2822 .interval = 5,
90265353 2823 .inverse = "rwmixwrite",
e8b0e958
JA
2824 .category = FIO_OPT_C_IO,
2825 .group = FIO_OPT_G_RWMIX,
214e1eca
JA
2826 },
2827 {
2828 .name = "rwmixwrite",
e8b0e958 2829 .lname = "Read/write mix write",
214e1eca 2830 .type = FIO_OPT_INT,
cb499fc4 2831 .cb = str_rwmix_write_cb,
a8523a6a 2832 .off1 = td_var_offset(rwmix[DDIR_WRITE]),
214e1eca
JA
2833 .maxval = 100,
2834 .help = "Percentage of mixed workload that is writes",
2835 .def = "50",
20eb06bd 2836 .interval = 5,
90265353 2837 .inverse = "rwmixread",
e8b0e958
JA
2838 .category = FIO_OPT_C_IO,
2839 .group = FIO_OPT_G_RWMIX,
214e1eca 2840 },
afdf9352
JA
2841 {
2842 .name = "rwmixcycle",
e8b0e958 2843 .lname = "Read/write mix cycle",
15ca150e 2844 .type = FIO_OPT_DEPRECATED,
e8b0e958
JA
2845 .category = FIO_OPT_C_IO,
2846 .group = FIO_OPT_G_RWMIX,
afdf9352 2847 },
214e1eca
JA
2848 {
2849 .name = "nice",
e8b0e958 2850 .lname = "Nice",
214e1eca
JA
2851 .type = FIO_OPT_INT,
2852 .off1 = td_var_offset(nice),
2853 .help = "Set job CPU nice value",
2854 .minval = -19,
2855 .maxval = 20,
2856 .def = "0",
20eb06bd 2857 .interval = 1,
e8b0e958 2858 .category = FIO_OPT_C_GENERAL,
10860056 2859 .group = FIO_OPT_G_CRED,
214e1eca
JA
2860 },
2861#ifdef FIO_HAVE_IOPRIO
2862 {
2863 .name = "prio",
e8b0e958 2864 .lname = "I/O nice priority",
214e1eca 2865 .type = FIO_OPT_INT,
28727df7 2866 .off1 = td_var_offset(ioprio),
214e1eca
JA
2867 .help = "Set job IO priority value",
2868 .minval = 0,
2869 .maxval = 7,
20eb06bd 2870 .interval = 1,
e8b0e958 2871 .category = FIO_OPT_C_GENERAL,
10860056 2872 .group = FIO_OPT_G_CRED,
214e1eca
JA
2873 },
2874 {
2875 .name = "prioclass",
e8b0e958 2876 .lname = "I/O nice priority class",
214e1eca 2877 .type = FIO_OPT_INT,
28727df7 2878 .off1 = td_var_offset(ioprio_class),
214e1eca
JA
2879 .help = "Set job IO priority class",
2880 .minval = 0,
2881 .maxval = 3,
20eb06bd 2882 .interval = 1,
e8b0e958 2883 .category = FIO_OPT_C_GENERAL,
10860056 2884 .group = FIO_OPT_G_CRED,
214e1eca
JA
2885 },
2886#endif
2887 {
2888 .name = "thinktime",
e8b0e958 2889 .lname = "Thinktime",
214e1eca
JA
2890 .type = FIO_OPT_INT,
2891 .off1 = td_var_offset(thinktime),
2892 .help = "Idle time between IO buffers (usec)",
2893 .def = "0",
88038bc7 2894 .is_time = 1,
e8b0e958 2895 .category = FIO_OPT_C_IO,
3ceb458f 2896 .group = FIO_OPT_G_THINKTIME,
214e1eca
JA
2897 },
2898 {
2899 .name = "thinktime_spin",
e8b0e958 2900 .lname = "Thinktime spin",
214e1eca
JA
2901 .type = FIO_OPT_INT,
2902 .off1 = td_var_offset(thinktime_spin),
2903 .help = "Start think time by spinning this amount (usec)",
2904 .def = "0",
88038bc7 2905 .is_time = 1,
afdf9352 2906 .parent = "thinktime",
d71c154c 2907 .hide = 1,
e8b0e958 2908 .category = FIO_OPT_C_IO,
3ceb458f 2909 .group = FIO_OPT_G_THINKTIME,
214e1eca
JA
2910 },
2911 {
2912 .name = "thinktime_blocks",
e8b0e958 2913 .lname = "Thinktime blocks",
214e1eca
JA
2914 .type = FIO_OPT_INT,
2915 .off1 = td_var_offset(thinktime_blocks),
2916 .help = "IO buffer period between 'thinktime'",
2917 .def = "1",
afdf9352 2918 .parent = "thinktime",
d71c154c 2919 .hide = 1,
e8b0e958 2920 .category = FIO_OPT_C_IO,
3ceb458f 2921 .group = FIO_OPT_G_THINKTIME,
214e1eca
JA
2922 },
2923 {
2924 .name = "rate",
e8b0e958 2925 .lname = "I/O rate",
e01b22b8 2926 .type = FIO_OPT_INT,
6eaf09d6
SL
2927 .off1 = td_var_offset(rate[DDIR_READ]),
2928 .off2 = td_var_offset(rate[DDIR_WRITE]),
2929 .off3 = td_var_offset(rate[DDIR_TRIM]),
214e1eca 2930 .help = "Set bandwidth rate",
e8b0e958
JA
2931 .category = FIO_OPT_C_IO,
2932 .group = FIO_OPT_G_RATE,
214e1eca
JA
2933 },
2934 {
6d428bcd
JA
2935 .name = "rate_min",
2936 .alias = "ratemin",
e8b0e958 2937 .lname = "I/O min rate",
e01b22b8 2938 .type = FIO_OPT_INT,
6eaf09d6
SL
2939 .off1 = td_var_offset(ratemin[DDIR_READ]),
2940 .off2 = td_var_offset(ratemin[DDIR_WRITE]),
2941 .off3 = td_var_offset(ratemin[DDIR_TRIM]),
4e991c23 2942 .help = "Job must meet this rate or it will be shutdown",
afdf9352 2943 .parent = "rate",
d71c154c 2944 .hide = 1,
e8b0e958
JA
2945 .category = FIO_OPT_C_IO,
2946 .group = FIO_OPT_G_RATE,
4e991c23
JA
2947 },
2948 {
2949 .name = "rate_iops",
e8b0e958 2950 .lname = "I/O rate IOPS",
e01b22b8 2951 .type = FIO_OPT_INT,
6eaf09d6
SL
2952 .off1 = td_var_offset(rate_iops[DDIR_READ]),
2953 .off2 = td_var_offset(rate_iops[DDIR_WRITE]),
2954 .off3 = td_var_offset(rate_iops[DDIR_TRIM]),
4e991c23 2955 .help = "Limit IO used to this number of IO operations/sec",
d71c154c 2956 .hide = 1,
e8b0e958
JA
2957 .category = FIO_OPT_C_IO,
2958 .group = FIO_OPT_G_RATE,
4e991c23
JA
2959 },
2960 {
2961 .name = "rate_iops_min",
e8b0e958 2962 .lname = "I/O min rate IOPS",
e01b22b8 2963 .type = FIO_OPT_INT,
6eaf09d6
SL
2964 .off1 = td_var_offset(rate_iops_min[DDIR_READ]),
2965 .off2 = td_var_offset(rate_iops_min[DDIR_WRITE]),
2966 .off3 = td_var_offset(rate_iops_min[DDIR_TRIM]),
03e20d68 2967 .help = "Job must meet this rate or it will be shut down",
afdf9352 2968 .parent = "rate_iops",
d71c154c 2969 .hide = 1,
e8b0e958
JA
2970 .category = FIO_OPT_C_IO,
2971 .group = FIO_OPT_G_RATE,
214e1eca 2972 },
ff6bb260 2973 {
6de65959
JA
2974 .name = "rate_process",
2975 .lname = "Rate Process",
2976 .type = FIO_OPT_STR,
2977 .off1 = td_var_offset(rate_process),
2978 .help = "What process controls how rated IO is managed",
2979 .def = "linear",
ff6bb260
SL
2980 .category = FIO_OPT_C_IO,
2981 .group = FIO_OPT_G_RATE,
6de65959
JA
2982 .posval = {
2983 { .ival = "linear",
2984 .oval = RATE_PROCESS_LINEAR,
2985 .help = "Linear rate of IO",
2986 },
2987 {
2988 .ival = "poisson",
2989 .oval = RATE_PROCESS_POISSON,
2990 .help = "Rate follows Poisson process",
2991 },
2992 },
2993 .parent = "rate",
ff6bb260 2994 },
214e1eca 2995 {
6d428bcd
JA
2996 .name = "rate_cycle",
2997 .alias = "ratecycle",
e8b0e958 2998 .lname = "I/O rate cycle",
214e1eca
JA
2999 .type = FIO_OPT_INT,
3000 .off1 = td_var_offset(ratecycle),
3001 .help = "Window average for rate limits (msec)",
3002 .def = "1000",
afdf9352 3003 .parent = "rate",
d71c154c 3004 .hide = 1,
e8b0e958
JA
3005 .category = FIO_OPT_C_IO,
3006 .group = FIO_OPT_G_RATE,
214e1eca 3007 },
15501535
JA
3008 {
3009 .name = "max_latency",
3010 .type = FIO_OPT_INT,
3011 .off1 = td_var_offset(max_latency),
3012 .help = "Maximum tolerated IO latency (usec)",
88038bc7 3013 .is_time = 1,
1e5324e7 3014 .category = FIO_OPT_C_IO,
3e260a46
JA
3015 .group = FIO_OPT_G_LATPROF,
3016 },
3017 {
3018 .name = "latency_target",
3019 .lname = "Latency Target (usec)",
3020 .type = FIO_OPT_STR_VAL_TIME,
3021 .off1 = td_var_offset(latency_target),
3022 .help = "Ramp to max queue depth supporting this latency",
88038bc7 3023 .is_time = 1,
3e260a46
JA
3024 .category = FIO_OPT_C_IO,
3025 .group = FIO_OPT_G_LATPROF,
3026 },
3027 {
3028 .name = "latency_window",
3029 .lname = "Latency Window (usec)",
3030 .type = FIO_OPT_STR_VAL_TIME,
3031 .off1 = td_var_offset(latency_window),
3032 .help = "Time to sustain latency_target",
88038bc7 3033 .is_time = 1,
3e260a46
JA
3034 .category = FIO_OPT_C_IO,
3035 .group = FIO_OPT_G_LATPROF,
3036 },
3037 {
3038 .name = "latency_percentile",
3039 .lname = "Latency Percentile",
3040 .type = FIO_OPT_FLOAT_LIST,
3041 .off1 = td_var_offset(latency_percentile),
3042 .help = "Percentile of IOs must be below latency_target",
3043 .def = "100",
3044 .maxlen = 1,
3045 .minfp = 0.0,
3046 .maxfp = 100.0,
3047 .category = FIO_OPT_C_IO,
3048 .group = FIO_OPT_G_LATPROF,
15501535 3049 },
214e1eca
JA
3050 {
3051 .name = "invalidate",
e8b0e958 3052 .lname = "Cache invalidate",
214e1eca
JA
3053 .type = FIO_OPT_BOOL,
3054 .off1 = td_var_offset(invalidate_cache),
3055 .help = "Invalidate buffer/page cache prior to running job",
3056 .def = "1",
e8b0e958 3057 .category = FIO_OPT_C_IO,
3ceb458f 3058 .group = FIO_OPT_G_IO_TYPE,
214e1eca
JA
3059 },
3060 {
3061 .name = "sync",
e8b0e958 3062 .lname = "Synchronous I/O",
214e1eca
JA
3063 .type = FIO_OPT_BOOL,
3064 .off1 = td_var_offset(sync_io),
3065 .help = "Use O_SYNC for buffered writes",
3066 .def = "0",
67a1000f 3067 .parent = "buffered",
d71c154c 3068 .hide = 1,
e8b0e958 3069 .category = FIO_OPT_C_IO,
3ceb458f 3070 .group = FIO_OPT_G_IO_TYPE,
214e1eca 3071 },
214e1eca
JA
3072 {
3073 .name = "create_serialize",
e8b0e958 3074 .lname = "Create serialize",
214e1eca
JA
3075 .type = FIO_OPT_BOOL,
3076 .off1 = td_var_offset(create_serialize),
3077 .help = "Serialize creating of job files",
3078 .def = "1",
e8b0e958
JA
3079 .category = FIO_OPT_C_FILE,
3080 .group = FIO_OPT_G_INVALID,
214e1eca
JA
3081 },
3082 {
3083 .name = "create_fsync",
e8b0e958 3084 .lname = "Create fsync",
214e1eca
JA
3085 .type = FIO_OPT_BOOL,
3086 .off1 = td_var_offset(create_fsync),
03e20d68 3087 .help = "fsync file after creation",
214e1eca 3088 .def = "1",
e8b0e958
JA
3089 .category = FIO_OPT_C_FILE,
3090 .group = FIO_OPT_G_INVALID,
214e1eca 3091 },
814452bd
JA
3092 {
3093 .name = "create_on_open",
e8b0e958 3094 .lname = "Create on open",
814452bd
JA
3095 .type = FIO_OPT_BOOL,
3096 .off1 = td_var_offset(create_on_open),
3097 .help = "Create files when they are opened for IO",
3098 .def = "0",
e8b0e958
JA
3099 .category = FIO_OPT_C_FILE,
3100 .group = FIO_OPT_G_INVALID,
814452bd 3101 },
25460cf6
JA
3102 {
3103 .name = "create_only",
3104 .type = FIO_OPT_BOOL,
3105 .off1 = td_var_offset(create_only),
3106 .help = "Only perform file creation phase",
d17fda71 3107 .category = FIO_OPT_C_FILE,
25460cf6
JA
3108 .def = "0",
3109 },
2378826d
JA
3110 {
3111 .name = "allow_file_create",
e81ecca3 3112 .lname = "Allow file create",
2378826d
JA
3113 .type = FIO_OPT_BOOL,
3114 .off1 = td_var_offset(allow_create),
3115 .help = "Permit fio to create files, if they don't exist",
3116 .def = "1",
3117 .category = FIO_OPT_C_FILE,
3118 .group = FIO_OPT_G_FILENAME,
3119 },
e81ecca3
JA
3120 {
3121 .name = "allow_mounted_write",
3122 .lname = "Allow mounted write",
3123 .type = FIO_OPT_BOOL,
3124 .off1 = td_var_offset(allow_mounted_write),
3125 .help = "Allow writes to a mounted partition",
3126 .def = "0",
3127 .category = FIO_OPT_C_FILE,
3128 .group = FIO_OPT_G_FILENAME,
3129 },
0b9d69ec 3130 {
afad68f7 3131 .name = "pre_read",
e8b0e958 3132 .lname = "Pre-read files",
afad68f7
ZY
3133 .type = FIO_OPT_BOOL,
3134 .off1 = td_var_offset(pre_read),
03e20d68 3135 .help = "Pre-read files before starting official testing",
afad68f7 3136 .def = "0",
e8b0e958
JA
3137 .category = FIO_OPT_C_FILE,
3138 .group = FIO_OPT_G_INVALID,
afad68f7 3139 },
214e1eca
JA
3140#ifdef FIO_HAVE_CPU_AFFINITY
3141 {
3142 .name = "cpumask",
e8b0e958 3143 .lname = "CPU mask",
214e1eca
JA
3144 .type = FIO_OPT_INT,
3145 .cb = str_cpumask_cb,
a8523a6a 3146 .off1 = td_var_offset(cpumask),
214e1eca 3147 .help = "CPU affinity mask",
e8b0e958 3148 .category = FIO_OPT_C_GENERAL,
10860056 3149 .group = FIO_OPT_G_CRED,
214e1eca 3150 },
d2e268b0
JA
3151 {
3152 .name = "cpus_allowed",
e8b0e958 3153 .lname = "CPUs allowed",
d2e268b0
JA
3154 .type = FIO_OPT_STR,
3155 .cb = str_cpus_allowed_cb,
a8523a6a 3156 .off1 = td_var_offset(cpumask),
d2e268b0 3157 .help = "Set CPUs allowed",
e8b0e958 3158 .category = FIO_OPT_C_GENERAL,
10860056 3159 .group = FIO_OPT_G_CRED,
d2e268b0 3160 },
c2acfbac
JA
3161 {
3162 .name = "cpus_allowed_policy",
3163 .lname = "CPUs allowed distribution policy",
3164 .type = FIO_OPT_STR,
3165 .off1 = td_var_offset(cpus_allowed_policy),
3166 .help = "Distribution policy for cpus_allowed",
3167 .parent = "cpus_allowed",
3168 .prio = 1,
3169 .posval = {
3170 { .ival = "shared",
3171 .oval = FIO_CPUS_SHARED,
3172 .help = "Mask shared between threads",
3173 },
3174 { .ival = "split",
3175 .oval = FIO_CPUS_SPLIT,
3176 .help = "Mask split between threads",
3177 },
3178 },
3179 .category = FIO_OPT_C_GENERAL,
3180 .group = FIO_OPT_G_CRED,
3181 },
d0b937ed 3182#endif
67bf9823 3183#ifdef CONFIG_LIBNUMA
d0b937ed
YR
3184 {
3185 .name = "numa_cpu_nodes",
3186 .type = FIO_OPT_STR,
3187 .cb = str_numa_cpunodes_cb,
b2a9e649 3188 .off1 = td_var_offset(numa_cpunodes),
d0b937ed 3189 .help = "NUMA CPU nodes bind",
6be54b2d
JA
3190 .category = FIO_OPT_C_GENERAL,
3191 .group = FIO_OPT_G_INVALID,
d0b937ed
YR
3192 },
3193 {
3194 .name = "numa_mem_policy",
3195 .type = FIO_OPT_STR,
3196 .cb = str_numa_mpol_cb,
b2a9e649 3197 .off1 = td_var_offset(numa_memnodes),
d0b937ed 3198 .help = "NUMA memory policy setup",
6be54b2d
JA
3199 .category = FIO_OPT_C_GENERAL,
3200 .group = FIO_OPT_G_INVALID,
d0b937ed 3201 },
214e1eca
JA
3202#endif
3203 {
3204 .name = "end_fsync",
e8b0e958 3205 .lname = "End fsync",
214e1eca
JA
3206 .type = FIO_OPT_BOOL,
3207 .off1 = td_var_offset(end_fsync),
3208 .help = "Include fsync at the end of job",
3209 .def = "0",
e8b0e958
JA
3210 .category = FIO_OPT_C_FILE,
3211 .group = FIO_OPT_G_INVALID,
214e1eca
JA
3212 },
3213 {
3214 .name = "fsync_on_close",
e8b0e958 3215 .lname = "Fsync on close",
214e1eca
JA
3216 .type = FIO_OPT_BOOL,
3217 .off1 = td_var_offset(fsync_on_close),
3218 .help = "fsync files on close",
3219 .def = "0",
e8b0e958
JA
3220 .category = FIO_OPT_C_FILE,
3221 .group = FIO_OPT_G_INVALID,
214e1eca
JA
3222 },
3223 {
3224 .name = "unlink",
e8b0e958 3225 .lname = "Unlink file",
214e1eca
JA
3226 .type = FIO_OPT_BOOL,
3227 .off1 = td_var_offset(unlink),
3228 .help = "Unlink created files after job has completed",
3229 .def = "0",
e8b0e958
JA
3230 .category = FIO_OPT_C_FILE,
3231 .group = FIO_OPT_G_INVALID,
214e1eca
JA
3232 },
3233 {
3234 .name = "exitall",
e8b0e958 3235 .lname = "Exit-all on terminate",
214e1eca
JA
3236 .type = FIO_OPT_STR_SET,
3237 .cb = str_exitall_cb,
3238 .help = "Terminate all jobs when one exits",
e8b0e958 3239 .category = FIO_OPT_C_GENERAL,
a1f6afec 3240 .group = FIO_OPT_G_PROCESS,
214e1eca 3241 },
f9cafb12
JA
3242 {
3243 .name = "exitall_on_error",
3244 .lname = "Exit-all on terminate in error",
3245 .type = FIO_OPT_BOOL,
3246 .off1 = td_var_offset(unlink),
3247 .help = "Terminate all jobs when one exits in error",
3248 .category = FIO_OPT_C_GENERAL,
3249 .group = FIO_OPT_G_PROCESS,
3250 },
214e1eca
JA
3251 {
3252 .name = "stonewall",
e8b0e958 3253 .lname = "Wait for previous",
d392365e 3254 .alias = "wait_for_previous",
214e1eca
JA
3255 .type = FIO_OPT_STR_SET,
3256 .off1 = td_var_offset(stonewall),
3257 .help = "Insert a hard barrier between this job and previous",
e8b0e958 3258 .category = FIO_OPT_C_GENERAL,
a1f6afec 3259 .group = FIO_OPT_G_PROCESS,
214e1eca 3260 },
b3d62a75
JA
3261 {
3262 .name = "new_group",
e8b0e958 3263 .lname = "New group",
b3d62a75
JA
3264 .type = FIO_OPT_STR_SET,
3265 .off1 = td_var_offset(new_group),
3266 .help = "Mark the start of a new group (for reporting)",
e8b0e958 3267 .category = FIO_OPT_C_GENERAL,
a1f6afec 3268 .group = FIO_OPT_G_PROCESS,
b3d62a75 3269 },
214e1eca
JA
3270 {
3271 .name = "thread",
e8b0e958 3272 .lname = "Thread",
214e1eca
JA
3273 .type = FIO_OPT_STR_SET,
3274 .off1 = td_var_offset(use_thread),
20eb06bd 3275 .help = "Use threads instead of processes",
c8931876
JA
3276#ifdef CONFIG_NO_SHM
3277 .def = "1",
3278 .no_warn_def = 1,
3279#endif
e8b0e958 3280 .category = FIO_OPT_C_GENERAL,
a1f6afec 3281 .group = FIO_OPT_G_PROCESS,
214e1eca 3282 },
3a5db920
JA
3283 {
3284 .name = "per_job_logs",
3285 .type = FIO_OPT_BOOL,
3286 .off1 = td_var_offset(per_job_logs),
3287 .help = "Include job number in generated log files or not",
3288 .def = "1",
3289 .category = FIO_OPT_C_LOG,
3290 .group = FIO_OPT_G_INVALID,
3291 },
214e1eca
JA
3292 {
3293 .name = "write_bw_log",
e8b0e958 3294 .lname = "Write bandwidth log",
203160d5
JA
3295 .type = FIO_OPT_STR_STORE,
3296 .off1 = td_var_offset(bw_log_file),
214e1eca 3297 .help = "Write log of bandwidth during run",
e8b0e958
JA
3298 .category = FIO_OPT_C_LOG,
3299 .group = FIO_OPT_G_INVALID,
214e1eca
JA
3300 },
3301 {
3302 .name = "write_lat_log",
e8b0e958 3303 .lname = "Write latency log",
203160d5
JA
3304 .type = FIO_OPT_STR_STORE,
3305 .off1 = td_var_offset(lat_log_file),
214e1eca 3306 .help = "Write log of latency during run",
e8b0e958
JA
3307 .category = FIO_OPT_C_LOG,
3308 .group = FIO_OPT_G_INVALID,
214e1eca 3309 },
c8eeb9df
JA
3310 {
3311 .name = "write_iops_log",
e8b0e958 3312 .lname = "Write IOPS log",
577c83bd 3313 .type = FIO_OPT_STR_STORE,
203160d5 3314 .off1 = td_var_offset(iops_log_file),
c8eeb9df 3315 .help = "Write log of IOPS during run",
e8b0e958
JA
3316 .category = FIO_OPT_C_LOG,
3317 .group = FIO_OPT_G_INVALID,
c8eeb9df 3318 },
b8bc8cba
JA
3319 {
3320 .name = "log_avg_msec",
e8b0e958 3321 .lname = "Log averaging (msec)",
b8bc8cba
JA
3322 .type = FIO_OPT_INT,
3323 .off1 = td_var_offset(log_avg_msec),
3324 .help = "Average bw/iops/lat logs over this period of time",
3325 .def = "0",
e8b0e958
JA
3326 .category = FIO_OPT_C_LOG,
3327 .group = FIO_OPT_G_INVALID,
b8bc8cba 3328 },
e6989e10
JA
3329 {
3330 .name = "log_max_value",
3331 .lname = "Log maximum instead of average",
3332 .type = FIO_OPT_BOOL,
3333 .off1 = td_var_offset(log_max),
3334 .help = "Log max sample in a window instead of average",
3335 .def = "0",
3336 .category = FIO_OPT_C_LOG,
3337 .group = FIO_OPT_G_INVALID,
3338 },
ae588852
JA
3339 {
3340 .name = "log_offset",
3341 .lname = "Log offset of IO",
3342 .type = FIO_OPT_BOOL,
3343 .off1 = td_var_offset(log_offset),
3344 .help = "Include offset of IO for each log entry",
3345 .def = "0",
3346 .category = FIO_OPT_C_LOG,
3347 .group = FIO_OPT_G_INVALID,
3348 },
aee2ab67
JA
3349#ifdef CONFIG_ZLIB
3350 {
3351 .name = "log_compression",
3352 .lname = "Log compression",
3353 .type = FIO_OPT_INT,
3354 .off1 = td_var_offset(log_gz),
3355 .help = "Log in compressed chunks of this size",
9919b27b 3356 .minval = 1024ULL,
aee2ab67
JA
3357 .maxval = 512 * 1024 * 1024ULL,
3358 .category = FIO_OPT_C_LOG,
3359 .group = FIO_OPT_G_INVALID,
3360 },
c08f9fe2
JA
3361#ifdef FIO_HAVE_CPU_AFFINITY
3362 {
3363 .name = "log_compression_cpus",
3364 .lname = "Log Compression CPUs",
3365 .type = FIO_OPT_STR,
3366 .cb = str_log_cpus_allowed_cb,
3367 .off1 = td_var_offset(log_gz_cpumask),
3368 .parent = "log_compression",
3369 .help = "Limit log compression to these CPUs",
3370 .category = FIO_OPT_C_LOG,
3371 .group = FIO_OPT_G_INVALID,
3372 },
3373#endif
b26317c9
JA
3374 {
3375 .name = "log_store_compressed",
3376 .lname = "Log store compressed",
3377 .type = FIO_OPT_BOOL,
3378 .off1 = td_var_offset(log_gz_store),
3379 .help = "Store logs in a compressed format",
3380 .category = FIO_OPT_C_LOG,
3381 .group = FIO_OPT_G_INVALID,
3382 },
aee2ab67 3383#endif
66347cfa
DE
3384 {
3385 .name = "block_error_percentiles",
3386 .lname = "Block error percentiles",
3387 .type = FIO_OPT_BOOL,
3388 .off1 = td_var_offset(block_error_hist),
3389 .help = "Record trim block errors and make a histogram",
3390 .def = "0",
3391 .category = FIO_OPT_C_LOG,
3392 .group = FIO_OPT_G_INVALID,
3393 },
c504ee55
JA
3394 {
3395 .name = "bwavgtime",
3396 .lname = "Bandwidth average time",
3397 .type = FIO_OPT_INT,
3398 .off1 = td_var_offset(bw_avg_time),
3399 .help = "Time window over which to calculate bandwidth"
3400 " (msec)",
3401 .def = "500",
3402 .parent = "write_bw_log",
3403 .hide = 1,
3404 .interval = 100,
3405 .category = FIO_OPT_C_LOG,
3406 .group = FIO_OPT_G_INVALID,
3407 },
3408 {
3409 .name = "iopsavgtime",
3410 .lname = "IOPS average time",
3411 .type = FIO_OPT_INT,
3412 .off1 = td_var_offset(iops_avg_time),
3413 .help = "Time window over which to calculate IOPS (msec)",
3414 .def = "500",
3415 .parent = "write_iops_log",
3416 .hide = 1,
3417 .interval = 100,
3418 .category = FIO_OPT_C_LOG,
3419 .group = FIO_OPT_G_INVALID,
3420 },
214e1eca
JA
3421 {
3422 .name = "group_reporting",
e8b0e958 3423 .lname = "Group reporting",
d2507043 3424 .type = FIO_OPT_STR_SET,
214e1eca
JA
3425 .off1 = td_var_offset(group_reporting),
3426 .help = "Do reporting on a per-group basis",
10860056 3427 .category = FIO_OPT_C_STAT,
e8b0e958 3428 .group = FIO_OPT_G_INVALID,
214e1eca 3429 },
e9459e5a
JA
3430 {
3431 .name = "zero_buffers",
e8b0e958 3432 .lname = "Zero I/O buffers",
e9459e5a
JA
3433 .type = FIO_OPT_STR_SET,
3434 .off1 = td_var_offset(zero_buffers),
3435 .help = "Init IO buffers to all zeroes",
e8b0e958 3436 .category = FIO_OPT_C_IO,
3ceb458f 3437 .group = FIO_OPT_G_IO_BUF,
e9459e5a 3438 },
5973cafb
JA
3439 {
3440 .name = "refill_buffers",
e8b0e958 3441 .lname = "Refill I/O buffers",
5973cafb
JA
3442 .type = FIO_OPT_STR_SET,
3443 .off1 = td_var_offset(refill_buffers),
3444 .help = "Refill IO buffers on every IO submit",
e8b0e958 3445 .category = FIO_OPT_C_IO,
3ceb458f 3446 .group = FIO_OPT_G_IO_BUF,
5973cafb 3447 },
fd68418e
JA
3448 {
3449 .name = "scramble_buffers",
e8b0e958 3450 .lname = "Scramble I/O buffers",
fd68418e
JA
3451 .type = FIO_OPT_BOOL,
3452 .off1 = td_var_offset(scramble_buffers),
3453 .help = "Slightly scramble buffers on every IO submit",
3454 .def = "1",
e8b0e958 3455 .category = FIO_OPT_C_IO,
3ceb458f 3456 .group = FIO_OPT_G_IO_BUF,
fd68418e 3457 },
ce35b1ec
JA
3458 {
3459 .name = "buffer_pattern",
3460 .lname = "Buffer pattern",
3461 .type = FIO_OPT_STR,
3462 .cb = str_buffer_pattern_cb,
a8523a6a 3463 .off1 = td_var_offset(buffer_pattern),
ce35b1ec
JA
3464 .help = "Fill pattern for IO buffers",
3465 .category = FIO_OPT_C_IO,
3466 .group = FIO_OPT_G_IO_BUF,
3467 },
9c42684e
JA
3468 {
3469 .name = "buffer_compress_percentage",
e8b0e958 3470 .lname = "Buffer compression percentage",
9c42684e 3471 .type = FIO_OPT_INT,
bedc9dc2 3472 .cb = str_buffer_compress_cb,
a8523a6a 3473 .off1 = td_var_offset(compress_percentage),
9c42684e 3474 .maxval = 100,
e7f5de90 3475 .minval = 0,
9c42684e 3476 .help = "How compressible the buffer is (approximately)",
20eb06bd 3477 .interval = 5,
e8b0e958 3478 .category = FIO_OPT_C_IO,
3ceb458f 3479 .group = FIO_OPT_G_IO_BUF,
9c42684e 3480 },
f97a43a1
JA
3481 {
3482 .name = "buffer_compress_chunk",
e8b0e958 3483 .lname = "Buffer compression chunk size",
f97a43a1
JA
3484 .type = FIO_OPT_INT,
3485 .off1 = td_var_offset(compress_chunk),
207b18e4 3486 .parent = "buffer_compress_percentage",
d71c154c 3487 .hide = 1,
f97a43a1 3488 .help = "Size of compressible region in buffer",
20eb06bd 3489 .interval = 256,
e8b0e958 3490 .category = FIO_OPT_C_IO,
3ceb458f 3491 .group = FIO_OPT_G_IO_BUF,
f97a43a1 3492 },
5c94b008
JA
3493 {
3494 .name = "dedupe_percentage",
3495 .lname = "Dedupe percentage",
3496 .type = FIO_OPT_INT,
3497 .cb = str_dedupe_cb,
a8523a6a 3498 .off1 = td_var_offset(dedupe_percentage),
5c94b008
JA
3499 .maxval = 100,
3500 .minval = 0,
3501 .help = "Percentage of buffers that are dedupable",
3502 .interval = 1,
3503 .category = FIO_OPT_C_IO,
3504 .group = FIO_OPT_G_IO_BUF,
3505 },
83349190
YH
3506 {
3507 .name = "clat_percentiles",
e8b0e958 3508 .lname = "Completion latency percentiles",
83349190
YH
3509 .type = FIO_OPT_BOOL,
3510 .off1 = td_var_offset(clat_percentiles),
3511 .help = "Enable the reporting of completion latency percentiles",
467b35ed 3512 .def = "1",
e8b0e958
JA
3513 .category = FIO_OPT_C_STAT,
3514 .group = FIO_OPT_G_INVALID,
83349190
YH
3515 },
3516 {
3517 .name = "percentile_list",
66347cfa 3518 .lname = "Percentile list",
83349190
YH
3519 .type = FIO_OPT_FLOAT_LIST,
3520 .off1 = td_var_offset(percentile_list),
435d195a 3521 .off2 = td_var_offset(percentile_precision),
66347cfa
DE
3522 .help = "Specify a custom list of percentiles to report for "
3523 "completion latency and block errors",
fd112d34 3524 .def = "1:5:10:20:30:40:50:60:70:80:90:95:99:99.5:99.9:99.95:99.99",
83349190
YH
3525 .maxlen = FIO_IO_U_LIST_MAX_LEN,
3526 .minfp = 0.0,
3527 .maxfp = 100.0,
e8b0e958
JA
3528 .category = FIO_OPT_C_STAT,
3529 .group = FIO_OPT_G_INVALID,
83349190
YH
3530 },
3531
0a839f30
JA
3532#ifdef FIO_HAVE_DISK_UTIL
3533 {
3534 .name = "disk_util",
e8b0e958 3535 .lname = "Disk utilization",
0a839f30
JA
3536 .type = FIO_OPT_BOOL,
3537 .off1 = td_var_offset(do_disk_util),
f66ab3c8 3538 .help = "Log disk utilization statistics",
0a839f30 3539 .def = "1",
e8b0e958
JA
3540 .category = FIO_OPT_C_STAT,
3541 .group = FIO_OPT_G_INVALID,
0a839f30
JA
3542 },
3543#endif
993bf48b
JA
3544 {
3545 .name = "gtod_reduce",
e8b0e958 3546 .lname = "Reduce gettimeofday() calls",
993bf48b
JA
3547 .type = FIO_OPT_BOOL,
3548 .help = "Greatly reduce number of gettimeofday() calls",
3549 .cb = str_gtod_reduce_cb,
3550 .def = "0",
a4ed77fe 3551 .hide_on_set = 1,
e8b0e958
JA
3552 .category = FIO_OPT_C_STAT,
3553 .group = FIO_OPT_G_INVALID,
993bf48b 3554 },
02af0988
JA
3555 {
3556 .name = "disable_lat",
e8b0e958 3557 .lname = "Disable all latency stats",
02af0988
JA
3558 .type = FIO_OPT_BOOL,
3559 .off1 = td_var_offset(disable_lat),
3560 .help = "Disable latency numbers",
3561 .parent = "gtod_reduce",
d71c154c 3562 .hide = 1,
02af0988 3563 .def = "0",
e8b0e958
JA
3564 .category = FIO_OPT_C_STAT,
3565 .group = FIO_OPT_G_INVALID,
02af0988 3566 },
9520ebb9
JA
3567 {
3568 .name = "disable_clat",
e8b0e958 3569 .lname = "Disable completion latency stats",
9520ebb9
JA
3570 .type = FIO_OPT_BOOL,
3571 .off1 = td_var_offset(disable_clat),