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