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