Add section 9 to HOWTO table of contents.
[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_lockmem_cb(void fio_unused *data, unsigned long long *val)
214e1eca
JA
374{
375 mlock_size = *val;
376 return 0;
377}
378
85bc833b 379static int str_rwmix_read_cb(void *data, unsigned long long *val)
cb499fc4
JA
380{
381 struct thread_data *td = data;
382
383 td->o.rwmix[DDIR_READ] = *val;
384 td->o.rwmix[DDIR_WRITE] = 100 - *val;
385 return 0;
386}
387
85bc833b 388static int str_rwmix_write_cb(void *data, unsigned long long *val)
cb499fc4
JA
389{
390 struct thread_data *td = data;
391
392 td->o.rwmix[DDIR_WRITE] = *val;
393 td->o.rwmix[DDIR_READ] = 100 - *val;
394 return 0;
395}
396
214e1eca 397#ifdef FIO_HAVE_IOPRIO
85bc833b 398static int str_prioclass_cb(void *data, unsigned long long *val)
214e1eca
JA
399{
400 struct thread_data *td = data;
6cefbe33
JA
401 unsigned short mask;
402
403 /*
404 * mask off old class bits, str_prio_cb() may have set a default class
405 */
406 mask = (1 << IOPRIO_CLASS_SHIFT) - 1;
407 td->ioprio &= mask;
214e1eca
JA
408
409 td->ioprio |= *val << IOPRIO_CLASS_SHIFT;
ac684785 410 td->ioprio_set = 1;
214e1eca
JA
411 return 0;
412}
413
85bc833b 414static int str_prio_cb(void *data, unsigned long long *val)
214e1eca
JA
415{
416 struct thread_data *td = data;
417
418 td->ioprio |= *val;
6cefbe33
JA
419
420 /*
421 * If no class is set, assume BE
422 */
423 if ((td->ioprio >> IOPRIO_CLASS_SHIFT) == 0)
424 td->ioprio |= IOPRIO_CLASS_BE << IOPRIO_CLASS_SHIFT;
425
ac684785 426 td->ioprio_set = 1;
214e1eca
JA
427 return 0;
428}
429#endif
430
431static int str_exitall_cb(void)
432{
433 exitall_on_terminate = 1;
434 return 0;
435}
436
214e1eca 437#ifdef FIO_HAVE_CPU_AFFINITY
85bc833b 438static int str_cpumask_cb(void *data, unsigned long long *val)
d2e268b0
JA
439{
440 struct thread_data *td = data;
214e1eca 441 unsigned int i;
b03daafb 442 long max_cpu;
d2ce18b5
JA
443 int ret;
444
445 ret = fio_cpuset_init(&td->o.cpumask);
446 if (ret < 0) {
447 log_err("fio: cpuset_init failed\n");
448 td_verror(td, ret, "fio_cpuset_init");
449 return 1;
450 }
214e1eca 451
c00a2289 452 max_cpu = cpus_online();
214e1eca 453
62a7273d
JA
454 for (i = 0; i < sizeof(int) * 8; i++) {
455 if ((1 << i) & *val) {
b03daafb
JA
456 if (i > max_cpu) {
457 log_err("fio: CPU %d too large (max=%ld)\n", i,
458 max_cpu);
459 return 1;
460 }
62a7273d 461 dprint(FD_PARSE, "set cpu allowed %d\n", i);
6d459ee7 462 fio_cpu_set(&td->o.cpumask, i);
62a7273d
JA
463 }
464 }
d2e268b0
JA
465
466 td->o.cpumask_set = 1;
467 return 0;
214e1eca
JA
468}
469
e8462bd8
JA
470static int set_cpus_allowed(struct thread_data *td, os_cpu_mask_t *mask,
471 const char *input)
214e1eca 472{
d2e268b0 473 char *cpu, *str, *p;
b03daafb 474 long max_cpu;
19608d6c 475 int ret = 0;
d2e268b0 476
e8462bd8 477 ret = fio_cpuset_init(mask);
d2ce18b5
JA
478 if (ret < 0) {
479 log_err("fio: cpuset_init failed\n");
480 td_verror(td, ret, "fio_cpuset_init");
481 return 1;
482 }
d2e268b0
JA
483
484 p = str = strdup(input);
214e1eca 485
d2e268b0
JA
486 strip_blank_front(&str);
487 strip_blank_end(str);
488
c00a2289 489 max_cpu = cpus_online();
b03daafb 490
d2e268b0 491 while ((cpu = strsep(&str, ",")) != NULL) {
62a7273d
JA
492 char *str2, *cpu2;
493 int icpu, icpu2;
494
d2e268b0
JA
495 if (!strlen(cpu))
496 break;
62a7273d
JA
497
498 str2 = cpu;
499 icpu2 = -1;
500 while ((cpu2 = strsep(&str2, "-")) != NULL) {
501 if (!strlen(cpu2))
502 break;
503
504 icpu2 = atoi(cpu2);
505 }
506
507 icpu = atoi(cpu);
508 if (icpu2 == -1)
509 icpu2 = icpu;
510 while (icpu <= icpu2) {
6d459ee7 511 if (icpu >= FIO_MAX_CPUS) {
19608d6c 512 log_err("fio: your OS only supports up to"
6d459ee7 513 " %d CPUs\n", (int) FIO_MAX_CPUS);
19608d6c
JA
514 ret = 1;
515 break;
516 }
b03daafb
JA
517 if (icpu > max_cpu) {
518 log_err("fio: CPU %d too large (max=%ld)\n",
519 icpu, max_cpu);
520 ret = 1;
521 break;
522 }
0b9d69ec 523
62a7273d 524 dprint(FD_PARSE, "set cpu allowed %d\n", icpu);
e8462bd8 525 fio_cpu_set(mask, icpu);
62a7273d
JA
526 icpu++;
527 }
19608d6c
JA
528 if (ret)
529 break;
d2e268b0
JA
530 }
531
532 free(p);
19608d6c
JA
533 if (!ret)
534 td->o.cpumask_set = 1;
535 return ret;
214e1eca 536}
e8462bd8
JA
537
538static int str_cpus_allowed_cb(void *data, const char *input)
539{
540 struct thread_data *td = data;
541 int ret;
542
543 ret = set_cpus_allowed(td, &td->o.cpumask, input);
544 if (!ret)
545 td->o.cpumask_set = 1;
546
547 return ret;
548}
549
550static int str_verify_cpus_allowed_cb(void *data, const char *input)
551{
552 struct thread_data *td = data;
553 int ret;
554
555 ret = set_cpus_allowed(td, &td->o.verify_cpumask, input);
556 if (!ret)
557 td->o.verify_cpumask_set = 1;
558
559 return ret;
560}
d2e268b0 561#endif
214e1eca 562
67bf9823 563#ifdef CONFIG_LIBNUMA
d0b937ed
YR
564static int str_numa_cpunodes_cb(void *data, char *input)
565{
566 struct thread_data *td = data;
567
568 /* numa_parse_nodestring() parses a character string list
569 * of nodes into a bit mask. The bit mask is allocated by
570 * numa_allocate_nodemask(), so it should be freed by
571 * numa_free_nodemask().
572 */
573 td->o.numa_cpunodesmask = numa_parse_nodestring(input);
574 if (td->o.numa_cpunodesmask == NULL) {
575 log_err("fio: numa_parse_nodestring failed\n");
576 td_verror(td, 1, "str_numa_cpunodes_cb");
577 return 1;
578 }
579
580 td->o.numa_cpumask_set = 1;
581 return 0;
582}
583
584static int str_numa_mpol_cb(void *data, char *input)
585{
586 struct thread_data *td = data;
587 const char * const policy_types[] =
588 { "default", "prefer", "bind", "interleave", "local" };
589 int i;
590
591 char *nodelist = strchr(input, ':');
592 if (nodelist) {
593 /* NUL-terminate mode */
594 *nodelist++ = '\0';
595 }
596
597 for (i = 0; i <= MPOL_LOCAL; i++) {
598 if (!strcmp(input, policy_types[i])) {
599 td->o.numa_mem_mode = i;
600 break;
601 }
602 }
603 if (i > MPOL_LOCAL) {
604 log_err("fio: memory policy should be: default, prefer, bind, interleave, local\n");
605 goto out;
606 }
607
608 switch (td->o.numa_mem_mode) {
609 case MPOL_PREFERRED:
610 /*
611 * Insist on a nodelist of one node only
612 */
613 if (nodelist) {
614 char *rest = nodelist;
615 while (isdigit(*rest))
616 rest++;
617 if (*rest) {
618 log_err("fio: one node only for \'prefer\'\n");
619 goto out;
620 }
621 } else {
622 log_err("fio: one node is needed for \'prefer\'\n");
623 goto out;
624 }
625 break;
626 case MPOL_INTERLEAVE:
627 /*
628 * Default to online nodes with memory if no nodelist
629 */
630 if (!nodelist)
631 nodelist = strdup("all");
632 break;
633 case MPOL_LOCAL:
634 case MPOL_DEFAULT:
635 /*
636 * Don't allow a nodelist
637 */
638 if (nodelist) {
639 log_err("fio: NO nodelist for \'local\'\n");
640 goto out;
641 }
642 break;
643 case MPOL_BIND:
644 /*
645 * Insist on a nodelist
646 */
647 if (!nodelist) {
648 log_err("fio: a nodelist is needed for \'bind\'\n");
649 goto out;
650 }
651 break;
652 }
653
654
655 /* numa_parse_nodestring() parses a character string list
656 * of nodes into a bit mask. The bit mask is allocated by
657 * numa_allocate_nodemask(), so it should be freed by
658 * numa_free_nodemask().
659 */
660 switch (td->o.numa_mem_mode) {
661 case MPOL_PREFERRED:
662 td->o.numa_mem_prefer_node = atoi(nodelist);
663 break;
664 case MPOL_INTERLEAVE:
665 case MPOL_BIND:
666 td->o.numa_memnodesmask = numa_parse_nodestring(nodelist);
667 if (td->o.numa_memnodesmask == NULL) {
668 log_err("fio: numa_parse_nodestring failed\n");
669 td_verror(td, 1, "str_numa_memnodes_cb");
670 return 1;
671 }
672 break;
673 case MPOL_LOCAL:
674 case MPOL_DEFAULT:
675 default:
676 break;
677 }
678
679 td->o.numa_memmask_set = 1;
680 return 0;
681
682out:
683 return 1;
684}
685#endif
686
0d29de83
JA
687#ifdef FIO_HAVE_TRIM
688static int str_verify_trim_cb(void *data, unsigned long long *val)
689{
690 struct thread_data *td = data;
691
692 td->o.trim_percentage = *val;
693 return 0;
694}
695#endif
696
214e1eca
JA
697static int str_fst_cb(void *data, const char *str)
698{
699 struct thread_data *td = data;
700 char *nr = get_opt_postfix(str);
701
702 td->file_service_nr = 1;
182ec6ee 703 if (nr) {
214e1eca 704 td->file_service_nr = atoi(nr);
182ec6ee
JA
705 free(nr);
706 }
214e1eca
JA
707
708 return 0;
709}
710
67bf9823 711#ifdef CONFIG_SYNC_FILE_RANGE
44f29692
JA
712static int str_sfr_cb(void *data, const char *str)
713{
714 struct thread_data *td = data;
715 char *nr = get_opt_postfix(str);
716
717 td->sync_file_range_nr = 1;
718 if (nr) {
719 td->sync_file_range_nr = atoi(nr);
720 free(nr);
721 }
722
723 return 0;
724}
3ae06371 725#endif
44f29692 726
e25839d4
JA
727static int str_random_distribution_cb(void *data, const char *str)
728{
729 struct thread_data *td = data;
730 double val;
731 char *nr;
732
925fee33
JA
733 if (td->o.random_distribution == FIO_RAND_DIST_ZIPF)
734 val = 1.1;
735 else if (td->o.random_distribution == FIO_RAND_DIST_PARETO)
736 val = 0.2;
737 else
e25839d4
JA
738 return 0;
739
740 nr = get_opt_postfix(str);
925fee33 741 if (nr && !str_to_float(nr, &val)) {
e25839d4
JA
742 log_err("fio: random postfix parsing failed\n");
743 free(nr);
744 return 1;
745 }
746
078189c1
JA
747 free(nr);
748
18ded917
JA
749 if (td->o.random_distribution == FIO_RAND_DIST_ZIPF) {
750 if (val == 1.00) {
751 log_err("fio: zipf theta must different than 1.0\n");
752 return 1;
753 }
925fee33 754 td->o.zipf_theta = val;
18ded917 755 } else {
078189c1
JA
756 if (val <= 0.00 || val >= 1.00) {
757 log_err("fio: pareto input out of range (0 < input < 1.0)\n");
758 return 1;
759 }
925fee33 760 td->o.pareto_h = val;
078189c1 761 }
925fee33 762
e25839d4
JA
763 return 0;
764}
765
921c766f
JA
766static int check_dir(struct thread_data *td, char *fname)
767{
3f0ca9b9 768#if 0
921c766f 769 char file[PATH_MAX], *dir;
bc838919 770 int elen = 0;
921c766f 771
bc838919
JA
772 if (td->o.directory) {
773 strcpy(file, td->o.directory);
fcef0b35 774 strcat(file, "/");
bc838919
JA
775 elen = strlen(file);
776 }
777
fcef0b35 778 sprintf(file + elen, "%s", fname);
921c766f
JA
779 dir = dirname(file);
780
fcef0b35
JA
781 {
782 struct stat sb;
783 /*
784 * We can't do this on FIO_DISKLESSIO engines. The engine isn't loaded
785 * yet, so we can't do this check right here...
786 */
921c766f
JA
787 if (lstat(dir, &sb) < 0) {
788 int ret = errno;
789
790 log_err("fio: %s is not a directory\n", dir);
791 td_verror(td, ret, "lstat");
792 return 1;
793 }
794
795 if (!S_ISDIR(sb.st_mode)) {
796 log_err("fio: %s is not a directory\n", dir);
797 return 1;
798 }
fcef0b35
JA
799 }
800#endif
921c766f
JA
801
802 return 0;
803}
804
8e827d35
JA
805/*
806 * Return next file in the string. Files are separated with ':'. If the ':'
807 * is escaped with a '\', then that ':' is part of the filename and does not
808 * indicate a new file.
809 */
810static char *get_next_file_name(char **ptr)
811{
812 char *str = *ptr;
813 char *p, *start;
814
815 if (!str || !strlen(str))
816 return NULL;
817
818 start = str;
819 do {
820 /*
821 * No colon, we are done
822 */
823 p = strchr(str, ':');
824 if (!p) {
825 *ptr = NULL;
826 break;
827 }
828
829 /*
830 * We got a colon, but it's the first character. Skip and
831 * continue
832 */
833 if (p == start) {
834 str = ++start;
835 continue;
836 }
837
838 if (*(p - 1) != '\\') {
839 *p = '\0';
840 *ptr = p + 1;
841 break;
842 }
843
844 memmove(p - 1, p, strlen(p) + 1);
845 str = p;
846 } while (1);
847
848 return start;
849}
850
214e1eca
JA
851static int str_filename_cb(void *data, const char *input)
852{
853 struct thread_data *td = data;
854 char *fname, *str, *p;
855
856 p = str = strdup(input);
857
858 strip_blank_front(&str);
859 strip_blank_end(str);
860
861 if (!td->files_index)
2dc1bbeb 862 td->o.nr_files = 0;
214e1eca 863
8e827d35 864 while ((fname = get_next_file_name(&str)) != NULL) {
214e1eca
JA
865 if (!strlen(fname))
866 break;
921c766f
JA
867 if (check_dir(td, fname)) {
868 free(p);
869 return 1;
870 }
214e1eca 871 add_file(td, fname);
2dc1bbeb 872 td->o.nr_files++;
214e1eca
JA
873 }
874
875 free(p);
876 return 0;
877}
878
879static int str_directory_cb(void *data, const char fio_unused *str)
880{
881 struct thread_data *td = data;
882 struct stat sb;
883
2dc1bbeb 884 if (lstat(td->o.directory, &sb) < 0) {
921c766f
JA
885 int ret = errno;
886
2dc1bbeb 887 log_err("fio: %s is not a directory\n", td->o.directory);
921c766f 888 td_verror(td, ret, "lstat");
214e1eca
JA
889 return 1;
890 }
891 if (!S_ISDIR(sb.st_mode)) {
2dc1bbeb 892 log_err("fio: %s is not a directory\n", td->o.directory);
214e1eca
JA
893 return 1;
894 }
895
896 return 0;
897}
898
899static int str_opendir_cb(void *data, const char fio_unused *str)
900{
901 struct thread_data *td = data;
902
903 if (!td->files_index)
2dc1bbeb 904 td->o.nr_files = 0;
214e1eca 905
2dc1bbeb 906 return add_dir_files(td, td->o.opendir);
214e1eca
JA
907}
908
85bc833b 909static int str_verify_offset_cb(void *data, unsigned long long *off)
546a9142
SL
910{
911 struct thread_data *td = data;
a59e170d 912
546a9142 913 if (*off && *off < sizeof(struct verify_header)) {
a59e170d 914 log_err("fio: verify_offset too small\n");
546a9142
SL
915 return 1;
916 }
a59e170d
JA
917
918 td->o.verify_offset = *off;
546a9142
SL
919 return 0;
920}
921
0e92f873 922static int str_verify_pattern_cb(void *data, const char *input)
90059d65
JA
923{
924 struct thread_data *td = data;
0e92f873
RR
925 long off;
926 int i = 0, j = 0, len, k, base = 10;
927 char* loc1, * loc2;
928
929 loc1 = strstr(input, "0x");
930 loc2 = strstr(input, "0X");
931 if (loc1 || loc2)
932 base = 16;
933 off = strtol(input, NULL, base);
934 if (off != LONG_MAX || errno != ERANGE) {
935 while (off) {
936 td->o.verify_pattern[i] = off & 0xff;
937 off >>= 8;
938 i++;
939 }
940 } else {
941 len = strlen(input);
942 k = len - 1;
943 if (base == 16) {
944 if (loc1)
945 j = loc1 - input + 2;
946 else
947 j = loc2 - input + 2;
948 } else
949 return 1;
950 if (len - j < MAX_PATTERN_SIZE * 2) {
951 while (k >= j) {
952 off = converthexchartoint(input[k--]);
953 if (k >= j)
954 off += (converthexchartoint(input[k--])
955 * 16);
956 td->o.verify_pattern[i++] = (char) off;
957 }
958 }
959 }
efcd9dcc
SL
960
961 /*
962 * Fill the pattern all the way to the end. This greatly reduces
963 * the number of memcpy's we have to do when verifying the IO.
964 */
965 while (i > 1 && i * 2 <= MAX_PATTERN_SIZE) {
966 memcpy(&td->o.verify_pattern[i], &td->o.verify_pattern[0], i);
967 i *= 2;
968 }
9a2a86d0
SL
969 if (i == 1) {
970 /*
971 * The code in verify_io_u_pattern assumes a single byte pattern
972 * fills the whole verify pattern buffer.
973 */
974 memset(td->o.verify_pattern, td->o.verify_pattern[0],
975 MAX_PATTERN_SIZE);
976 }
efcd9dcc 977
0e92f873 978 td->o.verify_pattern_bytes = i;
efcd9dcc 979
92bf48d5
JA
980 /*
981 * VERIFY_META could already be set
982 */
983 if (td->o.verify == VERIFY_NONE)
984 td->o.verify = VERIFY_PATTERN;
efcd9dcc 985
90059d65
JA
986 return 0;
987}
214e1eca 988
4d4e80f2
JA
989static int str_lockfile_cb(void *data, const char *str)
990{
991 struct thread_data *td = data;
992 char *nr = get_opt_postfix(str);
993
994 td->o.lockfile_batch = 1;
182ec6ee 995 if (nr) {
4d4e80f2 996 td->o.lockfile_batch = atoi(nr);
182ec6ee
JA
997 free(nr);
998 }
4d4e80f2
JA
999
1000 return 0;
1001}
1002
e3cedca7
JA
1003static int str_write_bw_log_cb(void *data, const char *str)
1004{
1005 struct thread_data *td = data;
1006
1007 if (str)
1008 td->o.bw_log_file = strdup(str);
1009
1010 td->o.write_bw_log = 1;
1011 return 0;
1012}
1013
1014static int str_write_lat_log_cb(void *data, const char *str)
1015{
1016 struct thread_data *td = data;
1017
1018 if (str)
1019 td->o.lat_log_file = strdup(str);
1020
1021 td->o.write_lat_log = 1;
1022 return 0;
1023}
1024
c8eeb9df
JA
1025static int str_write_iops_log_cb(void *data, const char *str)
1026{
1027 struct thread_data *td = data;
1028
1029 if (str)
1030 td->o.iops_log_file = strdup(str);
1031
1032 td->o.write_iops_log = 1;
1033 return 0;
1034}
1035
993bf48b
JA
1036static int str_gtod_reduce_cb(void *data, int *il)
1037{
1038 struct thread_data *td = data;
1039 int val = *il;
1040
02af0988 1041 td->o.disable_lat = !!val;
993bf48b
JA
1042 td->o.disable_clat = !!val;
1043 td->o.disable_slat = !!val;
1044 td->o.disable_bw = !!val;
0dc1bc03 1045 td->o.clat_percentiles = !val;
993bf48b
JA
1046 if (val)
1047 td->tv_cache_mask = 63;
1048
1049 return 0;
1050}
1051
85bc833b 1052static int str_gtod_cpu_cb(void *data, long long *il)
be4ecfdf
JA
1053{
1054 struct thread_data *td = data;
1055 int val = *il;
1056
1057 td->o.gtod_cpu = val;
1058 td->o.gtod_offload = 1;
1059 return 0;
1060}
1061
7bb59102
JA
1062static int str_size_cb(void *data, unsigned long long *__val)
1063{
1064 struct thread_data *td = data;
1065 unsigned long long v = *__val;
1066
1067 if (parse_is_percent(v)) {
1068 td->o.size = 0;
1069 td->o.size_percent = -1ULL - v;
1070 } else
1071 td->o.size = v;
1072
1073 return 0;
1074}
1075
896cac2a
JA
1076static int rw_verify(struct fio_option *o, void *data)
1077{
1078 struct thread_data *td = data;
1079
1080 if (read_only && td_write(td)) {
1081 log_err("fio: job <%s> has write bit set, but fio is in"
1082 " read-only mode\n", td->o.name);
1083 return 1;
1084 }
1085
1086 return 0;
1087}
1088
276ca4f7 1089static int gtod_cpu_verify(struct fio_option *o, void *data)
29d43ff9 1090{
276ca4f7 1091#ifndef FIO_HAVE_CPU_AFFINITY
29d43ff9
JA
1092 struct thread_data *td = data;
1093
29d43ff9
JA
1094 if (td->o.gtod_cpu) {
1095 log_err("fio: platform must support CPU affinity for"
1096 "gettimeofday() offloading\n");
1097 return 1;
1098 }
1099#endif
1100
1101 return 0;
1102}
1103
90fef2d1
JA
1104static int kb_base_verify(struct fio_option *o, void *data)
1105{
1106 struct thread_data *td = data;
1107
1108 if (td->o.kb_base != 1024 && td->o.kb_base != 1000) {
1109 log_err("fio: kb_base set to nonsensical value: %u\n",
1110 td->o.kb_base);
1111 return 1;
1112 }
1113
1114 return 0;
1115}
1116
214e1eca
JA
1117/*
1118 * Map of job/command line options
1119 */
07b3232d 1120static struct fio_option options[FIO_MAX_OPTS] = {
214e1eca
JA
1121 {
1122 .name = "description",
1123 .type = FIO_OPT_STR_STORE,
1124 .off1 = td_var_offset(description),
1125 .help = "Text job description",
1126 },
1127 {
1128 .name = "name",
1129 .type = FIO_OPT_STR_STORE,
1130 .off1 = td_var_offset(name),
1131 .help = "Name of this job",
1132 },
1133 {
1134 .name = "directory",
1135 .type = FIO_OPT_STR_STORE,
1136 .off1 = td_var_offset(directory),
1137 .cb = str_directory_cb,
1138 .help = "Directory to store files in",
1139 },
1140 {
1141 .name = "filename",
1142 .type = FIO_OPT_STR_STORE,
1143 .off1 = td_var_offset(filename),
1144 .cb = str_filename_cb,
f0d524b0 1145 .prio = -1, /* must come after "directory" */
214e1eca
JA
1146 .help = "File(s) to use for the workload",
1147 },
90fef2d1
JA
1148 {
1149 .name = "kb_base",
1150 .type = FIO_OPT_INT,
1151 .off1 = td_var_offset(kb_base),
90fef2d1 1152 .verify = kb_base_verify,
a639f0bb 1153 .prio = 1,
90fef2d1 1154 .def = "1024",
a639f0bb 1155 .help = "How many bytes per KB for reporting (1000 or 1024)",
90fef2d1 1156 },
29c1349f
JA
1157 {
1158 .name = "lockfile",
4d4e80f2
JA
1159 .type = FIO_OPT_STR,
1160 .cb = str_lockfile_cb,
1161 .off1 = td_var_offset(file_lock_mode),
29c1349f
JA
1162 .help = "Lock file when doing IO to it",
1163 .parent = "filename",
4d4e80f2
JA
1164 .def = "none",
1165 .posval = {
1166 { .ival = "none",
1167 .oval = FILE_LOCK_NONE,
1168 .help = "No file locking",
1169 },
1170 { .ival = "exclusive",
1171 .oval = FILE_LOCK_EXCLUSIVE,
1172 .help = "Exclusive file lock",
1173 },
1174 {
1175 .ival = "readwrite",
1176 .oval = FILE_LOCK_READWRITE,
1177 .help = "Read vs write lock",
1178 },
1179 },
29c1349f 1180 },
214e1eca
JA
1181 {
1182 .name = "opendir",
1183 .type = FIO_OPT_STR_STORE,
1184 .off1 = td_var_offset(opendir),
1185 .cb = str_opendir_cb,
1186 .help = "Recursively add files from this directory and down",
1187 },
1188 {
1189 .name = "rw",
d3aad8f2 1190 .alias = "readwrite",
214e1eca 1191 .type = FIO_OPT_STR,
211097b2 1192 .cb = str_rw_cb,
214e1eca
JA
1193 .off1 = td_var_offset(td_ddir),
1194 .help = "IO direction",
1195 .def = "read",
896cac2a 1196 .verify = rw_verify,
214e1eca
JA
1197 .posval = {
1198 { .ival = "read",
1199 .oval = TD_DDIR_READ,
1200 .help = "Sequential read",
1201 },
1202 { .ival = "write",
1203 .oval = TD_DDIR_WRITE,
1204 .help = "Sequential write",
1205 },
6eaf09d6
SL
1206 { .ival = "trim",
1207 .oval = TD_DDIR_TRIM,
1208 .help = "Sequential trim",
1209 },
214e1eca
JA
1210 { .ival = "randread",
1211 .oval = TD_DDIR_RANDREAD,
1212 .help = "Random read",
1213 },
1214 { .ival = "randwrite",
1215 .oval = TD_DDIR_RANDWRITE,
1216 .help = "Random write",
1217 },
6eaf09d6
SL
1218 { .ival = "randtrim",
1219 .oval = TD_DDIR_RANDTRIM,
1220 .help = "Random trim",
1221 },
214e1eca
JA
1222 { .ival = "rw",
1223 .oval = TD_DDIR_RW,
1224 .help = "Sequential read and write mix",
1225 },
10b023db
JA
1226 { .ival = "readwrite",
1227 .oval = TD_DDIR_RW,
1228 .help = "Sequential read and write mix",
1229 },
214e1eca
JA
1230 { .ival = "randrw",
1231 .oval = TD_DDIR_RANDRW,
1232 .help = "Random read and write mix"
1233 },
1234 },
1235 },
38dad62d
JA
1236 {
1237 .name = "rw_sequencer",
1238 .type = FIO_OPT_STR,
1239 .off1 = td_var_offset(rw_seq),
1240 .help = "IO offset generator modifier",
1241 .def = "sequential",
1242 .posval = {
1243 { .ival = "sequential",
1244 .oval = RW_SEQ_SEQ,
1245 .help = "Generate sequential offsets",
1246 },
1247 { .ival = "identical",
1248 .oval = RW_SEQ_IDENT,
1249 .help = "Generate identical offsets",
1250 },
1251 },
1252 },
1253
214e1eca
JA
1254 {
1255 .name = "ioengine",
1256 .type = FIO_OPT_STR_STORE,
1257 .off1 = td_var_offset(ioengine),
1258 .help = "IO engine to use",
58483fa4 1259 .def = FIO_PREFERRED_ENGINE,
214e1eca
JA
1260 .posval = {
1261 { .ival = "sync",
1262 .help = "Use read/write",
1263 },
a31041ea 1264 { .ival = "psync",
1265 .help = "Use pread/pwrite",
1266 },
1d2af02a 1267 { .ival = "vsync",
03e20d68 1268 .help = "Use readv/writev",
1d2af02a 1269 },
67bf9823 1270#ifdef CONFIG_LIBAIO
214e1eca
JA
1271 { .ival = "libaio",
1272 .help = "Linux native asynchronous IO",
1273 },
1274#endif
67bf9823 1275#ifdef CONFIG_POSIXAIO
214e1eca
JA
1276 { .ival = "posixaio",
1277 .help = "POSIX asynchronous IO",
1278 },
417f0068 1279#endif
997843cb 1280#ifdef CONFIG_SOLARISAIO
417f0068
JA
1281 { .ival = "solarisaio",
1282 .help = "Solaris native asynchronous IO",
1283 },
214e1eca 1284#endif
4700b234 1285#ifdef CONFIG_WINDOWSAIO
03e20d68 1286 { .ival = "windowsaio",
3be80071 1287 .help = "Windows native asynchronous IO"
de890a1e 1288 },
3be80071 1289#endif
214e1eca 1290 { .ival = "mmap",
03e20d68 1291 .help = "Memory mapped IO"
214e1eca 1292 },
67bf9823 1293#ifdef CONFIG_LINUX_SPLICE
214e1eca
JA
1294 { .ival = "splice",
1295 .help = "splice/vmsplice based IO",
1296 },
9cce02e8
JA
1297 { .ival = "netsplice",
1298 .help = "splice/vmsplice to/from the network",
1299 },
214e1eca
JA
1300#endif
1301#ifdef FIO_HAVE_SGIO
1302 { .ival = "sg",
1303 .help = "SCSI generic v3 IO",
1304 },
1305#endif
1306 { .ival = "null",
1307 .help = "Testing engine (no data transfer)",
1308 },
1309 { .ival = "net",
1310 .help = "Network IO",
1311 },
214e1eca 1312 { .ival = "cpuio",
03e20d68 1313 .help = "CPU cycle burner engine",
214e1eca 1314 },
67bf9823 1315#ifdef CONFIG_GUASI
b8c82a46
JA
1316 { .ival = "guasi",
1317 .help = "GUASI IO engine",
1318 },
79a43187
JA
1319#endif
1320#ifdef FIO_HAVE_BINJECT
1321 { .ival = "binject",
1322 .help = "binject direct inject block engine",
1323 },
21b8aee8 1324#endif
67bf9823 1325#ifdef CONFIG_RDMA
21b8aee8 1326 { .ival = "rdma",
1327 .help = "RDMA IO engine",
1328 },
8200b8c7 1329#endif
67bf9823 1330#ifdef CONFIG_FUSION_AW
8200b8c7
JA
1331 { .ival = "fusion-aw-sync",
1332 .help = "Fusion-io atomic write engine",
1333 },
1ecc95ca 1334#endif
997843cb 1335#ifdef CONFIG_LINUX_EXT4_MOVE_EXTENT
1ecc95ca
JA
1336 { .ival = "e4defrag",
1337 .help = "ext4 defrag engine",
1338 },
1339#endif
997843cb 1340#ifdef CONFIG_LINUX_FALLOCATE
1ecc95ca
JA
1341 { .ival = "falloc",
1342 .help = "fallocate() file based engine",
1343 },
b8c82a46 1344#endif
214e1eca
JA
1345 { .ival = "external",
1346 .help = "Load external engine (append name)",
1347 },
1348 },
1349 },
1350 {
1351 .name = "iodepth",
1352 .type = FIO_OPT_INT,
1353 .off1 = td_var_offset(iodepth),
03e20d68 1354 .help = "Number of IO buffers to keep in flight",
757aff4f 1355 .minval = 1,
214e1eca
JA
1356 .def = "1",
1357 },
1358 {
1359 .name = "iodepth_batch",
4950421a 1360 .alias = "iodepth_batch_submit",
214e1eca
JA
1361 .type = FIO_OPT_INT,
1362 .off1 = td_var_offset(iodepth_batch),
d65db441 1363 .help = "Number of IO buffers to submit in one go",
afdf9352 1364 .parent = "iodepth",
a2e6f8ac
JA
1365 .minval = 1,
1366 .def = "1",
4950421a
JA
1367 },
1368 {
1369 .name = "iodepth_batch_complete",
1370 .type = FIO_OPT_INT,
1371 .off1 = td_var_offset(iodepth_batch_complete),
d65db441 1372 .help = "Number of IO buffers to retrieve in one go",
4950421a
JA
1373 .parent = "iodepth",
1374 .minval = 0,
1375 .def = "1",
214e1eca
JA
1376 },
1377 {
1378 .name = "iodepth_low",
1379 .type = FIO_OPT_INT,
1380 .off1 = td_var_offset(iodepth_low),
1381 .help = "Low water mark for queuing depth",
afdf9352 1382 .parent = "iodepth",
214e1eca
JA
1383 },
1384 {
1385 .name = "size",
1386 .type = FIO_OPT_STR_VAL,
7bb59102 1387 .cb = str_size_cb,
214e1eca
JA
1388 .help = "Total size of device or files",
1389 },
aa31f1f1
SL
1390 {
1391 .name = "fill_device",
74586c1e 1392 .alias = "fill_fs",
aa31f1f1
SL
1393 .type = FIO_OPT_BOOL,
1394 .off1 = td_var_offset(fill_device),
1395 .help = "Write until an ENOSPC error occurs",
1396 .def = "0",
1397 },
214e1eca
JA
1398 {
1399 .name = "filesize",
1400 .type = FIO_OPT_STR_VAL,
1401 .off1 = td_var_offset(file_size_low),
1402 .off2 = td_var_offset(file_size_high),
c3edbdba 1403 .minval = 1,
214e1eca
JA
1404 .help = "Size of individual files",
1405 },
67a1000f
JA
1406 {
1407 .name = "offset",
1408 .alias = "fileoffset",
1409 .type = FIO_OPT_STR_VAL,
1410 .off1 = td_var_offset(start_offset),
1411 .help = "Start IO from this offset",
1412 .def = "0",
1413 },
2d7cd868
JA
1414 {
1415 .name = "offset_increment",
1416 .type = FIO_OPT_STR_VAL,
1417 .off1 = td_var_offset(offset_increment),
1418 .help = "What is the increment from one offset to the next",
1419 .parent = "offset",
1420 .def = "0",
1421 },
214e1eca
JA
1422 {
1423 .name = "bs",
d3aad8f2 1424 .alias = "blocksize",
e01b22b8 1425 .type = FIO_OPT_INT,
214e1eca
JA
1426 .off1 = td_var_offset(bs[DDIR_READ]),
1427 .off2 = td_var_offset(bs[DDIR_WRITE]),
6eaf09d6 1428 .off3 = td_var_offset(bs[DDIR_TRIM]),
c3edbdba 1429 .minval = 1,
214e1eca
JA
1430 .help = "Block size unit",
1431 .def = "4k",
67a1000f 1432 .parent = "rw",
214e1eca 1433 },
2b7a01d0
JA
1434 {
1435 .name = "ba",
1436 .alias = "blockalign",
e01b22b8 1437 .type = FIO_OPT_INT,
2b7a01d0
JA
1438 .off1 = td_var_offset(ba[DDIR_READ]),
1439 .off2 = td_var_offset(ba[DDIR_WRITE]),
6eaf09d6 1440 .off3 = td_var_offset(ba[DDIR_TRIM]),
2b7a01d0
JA
1441 .minval = 1,
1442 .help = "IO block offset alignment",
1443 .parent = "rw",
1444 },
214e1eca
JA
1445 {
1446 .name = "bsrange",
d3aad8f2 1447 .alias = "blocksize_range",
214e1eca
JA
1448 .type = FIO_OPT_RANGE,
1449 .off1 = td_var_offset(min_bs[DDIR_READ]),
1450 .off2 = td_var_offset(max_bs[DDIR_READ]),
1451 .off3 = td_var_offset(min_bs[DDIR_WRITE]),
1452 .off4 = td_var_offset(max_bs[DDIR_WRITE]),
6eaf09d6
SL
1453 .off5 = td_var_offset(min_bs[DDIR_TRIM]),
1454 .off6 = td_var_offset(max_bs[DDIR_TRIM]),
c3edbdba 1455 .minval = 1,
214e1eca 1456 .help = "Set block size range (in more detail than bs)",
67a1000f 1457 .parent = "rw",
214e1eca 1458 },
564ca972
JA
1459 {
1460 .name = "bssplit",
1461 .type = FIO_OPT_STR,
1462 .cb = str_bssplit_cb,
1463 .help = "Set a specific mix of block sizes",
1464 .parent = "rw",
1465 },
214e1eca
JA
1466 {
1467 .name = "bs_unaligned",
d3aad8f2 1468 .alias = "blocksize_unaligned",
214e1eca
JA
1469 .type = FIO_OPT_STR_SET,
1470 .off1 = td_var_offset(bs_unaligned),
1471 .help = "Don't sector align IO buffer sizes",
67a1000f 1472 .parent = "rw",
214e1eca
JA
1473 },
1474 {
1475 .name = "randrepeat",
1476 .type = FIO_OPT_BOOL,
1477 .off1 = td_var_offset(rand_repeatable),
1478 .help = "Use repeatable random IO pattern",
1479 .def = "1",
67a1000f 1480 .parent = "rw",
214e1eca 1481 },
2615cc4b
JA
1482 {
1483 .name = "use_os_rand",
1484 .type = FIO_OPT_BOOL,
1485 .off1 = td_var_offset(use_os_rand),
1486 .help = "Set to use OS random generator",
1487 .def = "0",
1488 .parent = "rw",
1489 },
214e1eca
JA
1490 {
1491 .name = "norandommap",
1492 .type = FIO_OPT_STR_SET,
1493 .off1 = td_var_offset(norandommap),
1494 .help = "Accept potential duplicate random blocks",
67a1000f 1495 .parent = "rw",
214e1eca 1496 },
2b386d25
JA
1497 {
1498 .name = "softrandommap",
1499 .type = FIO_OPT_BOOL,
1500 .off1 = td_var_offset(softrandommap),
f66ab3c8 1501 .help = "Set norandommap if randommap allocation fails",
2b386d25
JA
1502 .parent = "norandommap",
1503 .def = "0",
1504 },
8055e41d
JA
1505 {
1506 .name = "random_generator",
1507 .type = FIO_OPT_STR,
1508 .off1 = td_var_offset(random_generator),
1509 .help = "Type of random number generator to use",
1510 .def = "tausworthe",
1511 .posval = {
1512 { .ival = "tausworthe",
1513 .oval = FIO_RAND_GEN_TAUSWORTHE,
1514 .help = "Strong Tausworthe generator",
1515 },
1516 { .ival = "lfsr",
1517 .oval = FIO_RAND_GEN_LFSR,
1518 .help = "Variable length LFSR",
1519 },
1520 },
1521 },
e25839d4
JA
1522 {
1523 .name = "random_distribution",
1524 .type = FIO_OPT_STR,
1525 .off1 = td_var_offset(random_distribution),
1526 .cb = str_random_distribution_cb,
1527 .help = "Random offset distribution generator",
1528 .def = "random",
1529 .posval = {
1530 { .ival = "random",
1531 .oval = FIO_RAND_DIST_RANDOM,
1532 .help = "Completely random",
1533 },
1534 { .ival = "zipf",
1535 .oval = FIO_RAND_DIST_ZIPF,
1536 .help = "Zipf distribution",
1537 },
925fee33
JA
1538 { .ival = "pareto",
1539 .oval = FIO_RAND_DIST_PARETO,
1540 .help = "Pareto distribution",
1541 },
e25839d4
JA
1542 },
1543 },
214e1eca
JA
1544 {
1545 .name = "nrfiles",
d7c8be03 1546 .alias = "nr_files",
214e1eca
JA
1547 .type = FIO_OPT_INT,
1548 .off1 = td_var_offset(nr_files),
1549 .help = "Split job workload between this number of files",
1550 .def = "1",
1551 },
1552 {
1553 .name = "openfiles",
1554 .type = FIO_OPT_INT,
1555 .off1 = td_var_offset(open_files),
1556 .help = "Number of files to keep open at the same time",
1557 },
1558 {
1559 .name = "file_service_type",
1560 .type = FIO_OPT_STR,
1561 .cb = str_fst_cb,
1562 .off1 = td_var_offset(file_service_type),
1563 .help = "How to select which file to service next",
1564 .def = "roundrobin",
1565 .posval = {
1566 { .ival = "random",
1567 .oval = FIO_FSERVICE_RANDOM,
1568 .help = "Choose a file at random",
1569 },
1570 { .ival = "roundrobin",
1571 .oval = FIO_FSERVICE_RR,
1572 .help = "Round robin select files",
1573 },
a086c257
JA
1574 { .ival = "sequential",
1575 .oval = FIO_FSERVICE_SEQ,
1576 .help = "Finish one file before moving to the next",
1577 },
214e1eca 1578 },
67a1000f
JA
1579 .parent = "nrfiles",
1580 },
97ac992c 1581#ifdef CONFIG_POSIX_FALLOCATE
7bc8c2cf
JA
1582 {
1583 .name = "fallocate",
a596f047
EG
1584 .type = FIO_OPT_STR,
1585 .off1 = td_var_offset(fallocate_mode),
1586 .help = "Whether pre-allocation is performed when laying out files",
1587 .def = "posix",
1588 .posval = {
1589 { .ival = "none",
1590 .oval = FIO_FALLOCATE_NONE,
1591 .help = "Do not pre-allocate space",
1592 },
1593 { .ival = "posix",
1594 .oval = FIO_FALLOCATE_POSIX,
1595 .help = "Use posix_fallocate()",
1596 },
97ac992c 1597#ifdef CONFIG_LINUX_FALLOCATE
a596f047
EG
1598 { .ival = "keep",
1599 .oval = FIO_FALLOCATE_KEEP_SIZE,
1600 .help = "Use fallocate(..., FALLOC_FL_KEEP_SIZE, ...)",
1601 },
7bc8c2cf 1602#endif
a596f047
EG
1603 /* Compatibility with former boolean values */
1604 { .ival = "0",
1605 .oval = FIO_FALLOCATE_NONE,
1606 .help = "Alias for 'none'",
1607 },
1608 { .ival = "1",
1609 .oval = FIO_FALLOCATE_POSIX,
1610 .help = "Alias for 'posix'",
1611 },
1612 },
1613 },
97ac992c 1614#endif /* CONFIG_POSIX_FALLOCATE */
67a1000f
JA
1615 {
1616 .name = "fadvise_hint",
1617 .type = FIO_OPT_BOOL,
1618 .off1 = td_var_offset(fadvise_hint),
1619 .help = "Use fadvise() to advise the kernel on IO pattern",
1620 .def = "1",
214e1eca
JA
1621 },
1622 {
1623 .name = "fsync",
1624 .type = FIO_OPT_INT,
1625 .off1 = td_var_offset(fsync_blocks),
1626 .help = "Issue fsync for writes every given number of blocks",
1627 .def = "0",
1628 },
5f9099ea
JA
1629 {
1630 .name = "fdatasync",
1631 .type = FIO_OPT_INT,
1632 .off1 = td_var_offset(fdatasync_blocks),
1633 .help = "Issue fdatasync for writes every given number of blocks",
1634 .def = "0",
1635 },
1ef2b6be
JA
1636 {
1637 .name = "write_barrier",
1638 .type = FIO_OPT_INT,
1639 .off1 = td_var_offset(barrier_blocks),
1640 .help = "Make every Nth write a barrier write",
1641 .def = "0",
1642 },
67bf9823 1643#ifdef CONFIG_SYNC_FILE_RANGE
44f29692
JA
1644 {
1645 .name = "sync_file_range",
1646 .posval = {
1647 { .ival = "wait_before",
1648 .oval = SYNC_FILE_RANGE_WAIT_BEFORE,
1649 .help = "SYNC_FILE_RANGE_WAIT_BEFORE",
3843deb3 1650 .or = 1,
44f29692
JA
1651 },
1652 { .ival = "write",
1653 .oval = SYNC_FILE_RANGE_WRITE,
1654 .help = "SYNC_FILE_RANGE_WRITE",
3843deb3 1655 .or = 1,
44f29692
JA
1656 },
1657 {
1658 .ival = "wait_after",
1659 .oval = SYNC_FILE_RANGE_WAIT_AFTER,
1660 .help = "SYNC_FILE_RANGE_WAIT_AFTER",
3843deb3 1661 .or = 1,
44f29692
JA
1662 },
1663 },
3843deb3 1664 .type = FIO_OPT_STR_MULTI,
44f29692
JA
1665 .cb = str_sfr_cb,
1666 .off1 = td_var_offset(sync_file_range),
1667 .help = "Use sync_file_range()",
1668 },
1669#endif
214e1eca
JA
1670 {
1671 .name = "direct",
1672 .type = FIO_OPT_BOOL,
1673 .off1 = td_var_offset(odirect),
1674 .help = "Use O_DIRECT IO (negates buffered)",
1675 .def = "0",
1676 },
1677 {
1678 .name = "buffered",
1679 .type = FIO_OPT_BOOL,
1680 .off1 = td_var_offset(odirect),
1681 .neg = 1,
1682 .help = "Use buffered IO (negates direct)",
1683 .def = "1",
1684 },
1685 {
1686 .name = "overwrite",
1687 .type = FIO_OPT_BOOL,
1688 .off1 = td_var_offset(overwrite),
1689 .help = "When writing, set whether to overwrite current data",
1690 .def = "0",
1691 },
1692 {
1693 .name = "loops",
1694 .type = FIO_OPT_INT,
1695 .off1 = td_var_offset(loops),
1696 .help = "Number of times to run the job",
1697 .def = "1",
1698 },
1699 {
1700 .name = "numjobs",
1701 .type = FIO_OPT_INT,
1702 .off1 = td_var_offset(numjobs),
1703 .help = "Duplicate this job this many times",
1704 .def = "1",
1705 },
1706 {
1707 .name = "startdelay",
a5737c93 1708 .type = FIO_OPT_STR_VAL_TIME,
214e1eca
JA
1709 .off1 = td_var_offset(start_delay),
1710 .help = "Only start job when this period has passed",
1711 .def = "0",
1712 },
1713 {
1714 .name = "runtime",
1715 .alias = "timeout",
1716 .type = FIO_OPT_STR_VAL_TIME,
1717 .off1 = td_var_offset(timeout),
1718 .help = "Stop workload when this amount of time has passed",
1719 .def = "0",
1720 },
cf4464ca
JA
1721 {
1722 .name = "time_based",
1723 .type = FIO_OPT_STR_SET,
1724 .off1 = td_var_offset(time_based),
1725 .help = "Keep running until runtime/timeout is met",
1726 },
721938ae
JA
1727 {
1728 .name = "ramp_time",
1729 .type = FIO_OPT_STR_VAL_TIME,
1730 .off1 = td_var_offset(ramp_time),
1731 .help = "Ramp up time before measuring performance",
1732 },
c223da83
JA
1733 {
1734 .name = "clocksource",
1735 .type = FIO_OPT_STR,
1736 .cb = fio_clock_source_cb,
1737 .off1 = td_var_offset(clocksource),
1738 .help = "What type of timing source to use",
c223da83 1739 .posval = {
67bf9823 1740#ifdef CONFIG_GETTIMEOFDAY
c223da83
JA
1741 { .ival = "gettimeofday",
1742 .oval = CS_GTOD,
1743 .help = "Use gettimeofday(2) for timing",
1744 },
67bf9823
JA
1745#endif
1746#ifdef CONFIG_CLOCK_GETTIME
c223da83
JA
1747 { .ival = "clock_gettime",
1748 .oval = CS_CGETTIME,
1749 .help = "Use clock_gettime(2) for timing",
1750 },
67bf9823 1751#endif
c223da83
JA
1752#ifdef ARCH_HAVE_CPU_CLOCK
1753 { .ival = "cpu",
1754 .oval = CS_CPUCLOCK,
1755 .help = "Use CPU private clock",
1756 },
1757#endif
1758 },
1759 },
214e1eca
JA
1760 {
1761 .name = "mem",
d3aad8f2 1762 .alias = "iomem",
214e1eca
JA
1763 .type = FIO_OPT_STR,
1764 .cb = str_mem_cb,
1765 .off1 = td_var_offset(mem_type),
1766 .help = "Backing type for IO buffers",
1767 .def = "malloc",
1768 .posval = {
1769 { .ival = "malloc",
1770 .oval = MEM_MALLOC,
1771 .help = "Use malloc(3) for IO buffers",
1772 },
37c8cdfe
JA
1773 { .ival = "shm",
1774 .oval = MEM_SHM,
1775 .help = "Use shared memory segments for IO buffers",
1776 },
214e1eca
JA
1777#ifdef FIO_HAVE_HUGETLB
1778 { .ival = "shmhuge",
1779 .oval = MEM_SHMHUGE,
1780 .help = "Like shm, but use huge pages",
1781 },
b370e46a 1782#endif
37c8cdfe
JA
1783 { .ival = "mmap",
1784 .oval = MEM_MMAP,
1785 .help = "Use mmap(2) (file or anon) for IO buffers",
1786 },
214e1eca
JA
1787#ifdef FIO_HAVE_HUGETLB
1788 { .ival = "mmaphuge",
1789 .oval = MEM_MMAPHUGE,
1790 .help = "Like mmap, but use huge pages",
1791 },
1792#endif
1793 },
1794 },
d529ee19
JA
1795 {
1796 .name = "iomem_align",
1797 .alias = "mem_align",
1798 .type = FIO_OPT_INT,
1799 .off1 = td_var_offset(mem_align),
1800 .minval = 0,
1801 .help = "IO memory buffer offset alignment",
1802 .def = "0",
1803 .parent = "iomem",
1804 },
214e1eca
JA
1805 {
1806 .name = "verify",
1807 .type = FIO_OPT_STR,
1808 .off1 = td_var_offset(verify),
1809 .help = "Verify data written",
5d7c5d34 1810 .cb = str_verify_cb,
214e1eca
JA
1811 .def = "0",
1812 .posval = {
1813 { .ival = "0",
1814 .oval = VERIFY_NONE,
1815 .help = "Don't do IO verification",
1816 },
fcca4b58
JA
1817 { .ival = "md5",
1818 .oval = VERIFY_MD5,
1819 .help = "Use md5 checksums for verification",
1820 },
d77a7af3
JA
1821 { .ival = "crc64",
1822 .oval = VERIFY_CRC64,
1823 .help = "Use crc64 checksums for verification",
1824 },
214e1eca
JA
1825 { .ival = "crc32",
1826 .oval = VERIFY_CRC32,
1827 .help = "Use crc32 checksums for verification",
1828 },
af497e6a 1829 { .ival = "crc32c-intel",
e3aaafc4
JA
1830 .oval = VERIFY_CRC32C,
1831 .help = "Use crc32c checksums for verification (hw assisted, if available)",
af497e6a 1832 },
bac39e0e
JA
1833 { .ival = "crc32c",
1834 .oval = VERIFY_CRC32C,
e3aaafc4 1835 .help = "Use crc32c checksums for verification (hw assisted, if available)",
bac39e0e 1836 },
969f7ed3
JA
1837 { .ival = "crc16",
1838 .oval = VERIFY_CRC16,
1839 .help = "Use crc16 checksums for verification",
1840 },
1e154bdb
JA
1841 { .ival = "crc7",
1842 .oval = VERIFY_CRC7,
1843 .help = "Use crc7 checksums for verification",
1844 },
7c353ceb
JA
1845 { .ival = "sha1",
1846 .oval = VERIFY_SHA1,
1847 .help = "Use sha1 checksums for verification",
1848 },
cd14cc10
JA
1849 { .ival = "sha256",
1850 .oval = VERIFY_SHA256,
1851 .help = "Use sha256 checksums for verification",
1852 },
1853 { .ival = "sha512",
1854 .oval = VERIFY_SHA512,
1855 .help = "Use sha512 checksums for verification",
1856 },
7437ee87
SL
1857 { .ival = "meta",
1858 .oval = VERIFY_META,
1859 .help = "Use io information",
1860 },
36690c9b
JA
1861 {
1862 .ival = "null",
1863 .oval = VERIFY_NULL,
1864 .help = "Pretend to verify",
1865 },
214e1eca
JA
1866 },
1867 },
005c565a
JA
1868 {
1869 .name = "do_verify",
68e1f29a 1870 .type = FIO_OPT_BOOL,
005c565a
JA
1871 .off1 = td_var_offset(do_verify),
1872 .help = "Run verification stage after write",
1873 .def = "1",
1874 .parent = "verify",
1875 },
160b966d
JA
1876 {
1877 .name = "verifysort",
1878 .type = FIO_OPT_BOOL,
1879 .off1 = td_var_offset(verifysort),
1880 .help = "Sort written verify blocks for read back",
1881 .def = "1",
c83f2df1 1882 .parent = "verify",
160b966d 1883 },
1ae83d45
JA
1884 {
1885 .name = "verifysort_nr",
1886 .type = FIO_OPT_INT,
1887 .off1 = td_var_offset(verifysort_nr),
1888 .help = "Pre-load and sort verify blocks for a read workload",
1889 .minval = 0,
1890 .maxval = 131072,
1891 .def = "1024",
1892 .parent = "verify",
1893 },
3f9f4e26 1894 {
a59e170d 1895 .name = "verify_interval",
e01b22b8 1896 .type = FIO_OPT_INT,
a59e170d 1897 .off1 = td_var_offset(verify_interval),
819a9680 1898 .minval = 2 * sizeof(struct verify_header),
a59e170d 1899 .help = "Store verify buffer header every N bytes",
afdf9352 1900 .parent = "verify",
3f9f4e26 1901 },
546a9142 1902 {
a59e170d 1903 .name = "verify_offset",
e01b22b8 1904 .type = FIO_OPT_INT,
a59e170d 1905 .help = "Offset verify header location by N bytes",
546a9142 1906 .def = "0",
5ec10eaa 1907 .cb = str_verify_offset_cb,
afdf9352 1908 .parent = "verify",
546a9142 1909 },
e28218f3
SL
1910 {
1911 .name = "verify_pattern",
0e92f873 1912 .type = FIO_OPT_STR,
e28218f3
SL
1913 .cb = str_verify_pattern_cb,
1914 .help = "Fill pattern for IO buffers",
1915 .parent = "verify",
1916 },
a12a3b4d
JA
1917 {
1918 .name = "verify_fatal",
68e1f29a 1919 .type = FIO_OPT_BOOL,
a12a3b4d
JA
1920 .off1 = td_var_offset(verify_fatal),
1921 .def = "0",
1922 .help = "Exit on a single verify failure, don't continue",
1923 .parent = "verify",
1924 },
b463e936
JA
1925 {
1926 .name = "verify_dump",
1927 .type = FIO_OPT_BOOL,
1928 .off1 = td_var_offset(verify_dump),
ef71e317 1929 .def = "0",
b463e936
JA
1930 .help = "Dump contents of good and bad blocks on failure",
1931 .parent = "verify",
1932 },
e8462bd8
JA
1933 {
1934 .name = "verify_async",
1935 .type = FIO_OPT_INT,
1936 .off1 = td_var_offset(verify_async),
1937 .def = "0",
1938 .help = "Number of async verifier threads to use",
1939 .parent = "verify",
1940 },
9e144189
JA
1941 {
1942 .name = "verify_backlog",
1943 .type = FIO_OPT_STR_VAL,
1944 .off1 = td_var_offset(verify_backlog),
1945 .help = "Verify after this number of blocks are written",
1946 .parent = "verify",
1947 },
1948 {
1949 .name = "verify_backlog_batch",
1950 .type = FIO_OPT_INT,
1951 .off1 = td_var_offset(verify_batch),
1952 .help = "Verify this number of IO blocks",
0d29de83 1953 .parent = "verify",
9e144189 1954 },
e8462bd8
JA
1955#ifdef FIO_HAVE_CPU_AFFINITY
1956 {
1957 .name = "verify_async_cpus",
1958 .type = FIO_OPT_STR,
1959 .cb = str_verify_cpus_allowed_cb,
1960 .help = "Set CPUs allowed for async verify threads",
1961 .parent = "verify_async",
1962 },
0d29de83 1963#endif
51aa2da8
JA
1964 {
1965 .name = "experimental_verify",
1966 .off1 = td_var_offset(experimental_verify),
1967 .type = FIO_OPT_BOOL,
b31eaac9 1968 .help = "Enable experimental verification",
51aa2da8 1969 },
0d29de83
JA
1970#ifdef FIO_HAVE_TRIM
1971 {
1972 .name = "trim_percentage",
1973 .type = FIO_OPT_INT,
1974 .cb = str_verify_trim_cb,
1975 .maxval = 100,
1976 .help = "Number of verify blocks to discard/trim",
1977 .parent = "verify",
1978 .def = "0",
1979 },
1980 {
1981 .name = "trim_verify_zero",
1982 .type = FIO_OPT_INT,
1983 .help = "Verify that trim/discarded blocks are returned as zeroes",
1984 .off1 = td_var_offset(trim_zero),
1985 .parent = "trim_percentage",
1986 .def = "1",
1987 },
1988 {
1989 .name = "trim_backlog",
1990 .type = FIO_OPT_STR_VAL,
1991 .off1 = td_var_offset(trim_backlog),
1992 .help = "Trim after this number of blocks are written",
1993 .parent = "trim_percentage",
1994 },
1995 {
1996 .name = "trim_backlog_batch",
1997 .type = FIO_OPT_INT,
1998 .off1 = td_var_offset(trim_batch),
1999 .help = "Trim this number of IO blocks",
2000 .parent = "trim_percentage",
2001 },
e8462bd8 2002#endif
214e1eca
JA
2003 {
2004 .name = "write_iolog",
2005 .type = FIO_OPT_STR_STORE,
2006 .off1 = td_var_offset(write_iolog_file),
2007 .help = "Store IO pattern to file",
2008 },
2009 {
2010 .name = "read_iolog",
2011 .type = FIO_OPT_STR_STORE,
2012 .off1 = td_var_offset(read_iolog_file),
2013 .help = "Playback IO pattern from file",
2014 },
64bbb865
DN
2015 {
2016 .name = "replay_no_stall",
2017 .type = FIO_OPT_INT,
2018 .off1 = td_var_offset(no_stall),
2019 .def = "0",
87e7a972 2020 .parent = "read_iolog",
64bbb865
DN
2021 .help = "Playback IO pattern file as fast as possible without stalls",
2022 },
d1c46c04
DN
2023 {
2024 .name = "replay_redirect",
2025 .type = FIO_OPT_STR_STORE,
2026 .off1 = td_var_offset(replay_redirect),
2027 .parent = "read_iolog",
2028 .help = "Replay all I/O onto this device, regardless of trace device",
2029 },
214e1eca
JA
2030 {
2031 .name = "exec_prerun",
2032 .type = FIO_OPT_STR_STORE,
2033 .off1 = td_var_offset(exec_prerun),
2034 .help = "Execute this file prior to running job",
2035 },
2036 {
2037 .name = "exec_postrun",
2038 .type = FIO_OPT_STR_STORE,
2039 .off1 = td_var_offset(exec_postrun),
2040 .help = "Execute this file after running job",
2041 },
2042#ifdef FIO_HAVE_IOSCHED_SWITCH
2043 {
2044 .name = "ioscheduler",
2045 .type = FIO_OPT_STR_STORE,
2046 .off1 = td_var_offset(ioscheduler),
2047 .help = "Use this IO scheduler on the backing device",
2048 },
2049#endif
2050 {
2051 .name = "zonesize",
2052 .type = FIO_OPT_STR_VAL,
2053 .off1 = td_var_offset(zone_size),
ed335855
SN
2054 .help = "Amount of data to read per zone",
2055 .def = "0",
2056 },
2057 {
2058 .name = "zonerange",
2059 .type = FIO_OPT_STR_VAL,
2060 .off1 = td_var_offset(zone_range),
214e1eca
JA
2061 .help = "Give size of an IO zone",
2062 .def = "0",
2063 },
2064 {
2065 .name = "zoneskip",
2066 .type = FIO_OPT_STR_VAL,
2067 .off1 = td_var_offset(zone_skip),
2068 .help = "Space between IO zones",
2069 .def = "0",
2070 },
2071 {
2072 .name = "lockmem",
2073 .type = FIO_OPT_STR_VAL,
2074 .cb = str_lockmem_cb,
2075 .help = "Lock down this amount of memory",
2076 .def = "0",
2077 },
214e1eca
JA
2078 {
2079 .name = "rwmixread",
2080 .type = FIO_OPT_INT,
cb499fc4 2081 .cb = str_rwmix_read_cb,
214e1eca
JA
2082 .maxval = 100,
2083 .help = "Percentage of mixed workload that is reads",
2084 .def = "50",
2085 },
2086 {
2087 .name = "rwmixwrite",
2088 .type = FIO_OPT_INT,
cb499fc4 2089 .cb = str_rwmix_write_cb,
214e1eca
JA
2090 .maxval = 100,
2091 .help = "Percentage of mixed workload that is writes",
2092 .def = "50",
2093 },
afdf9352
JA
2094 {
2095 .name = "rwmixcycle",
15ca150e 2096 .type = FIO_OPT_DEPRECATED,
afdf9352 2097 },
214e1eca
JA
2098 {
2099 .name = "nice",
2100 .type = FIO_OPT_INT,
2101 .off1 = td_var_offset(nice),
2102 .help = "Set job CPU nice value",
2103 .minval = -19,
2104 .maxval = 20,
2105 .def = "0",
2106 },
2107#ifdef FIO_HAVE_IOPRIO
2108 {
2109 .name = "prio",
2110 .type = FIO_OPT_INT,
2111 .cb = str_prio_cb,
2112 .help = "Set job IO priority value",
2113 .minval = 0,
2114 .maxval = 7,
2115 },
2116 {
2117 .name = "prioclass",
2118 .type = FIO_OPT_INT,
2119 .cb = str_prioclass_cb,
2120 .help = "Set job IO priority class",
2121 .minval = 0,
2122 .maxval = 3,
2123 },
2124#endif
2125 {
2126 .name = "thinktime",
2127 .type = FIO_OPT_INT,
2128 .off1 = td_var_offset(thinktime),
2129 .help = "Idle time between IO buffers (usec)",
2130 .def = "0",
2131 },
2132 {
2133 .name = "thinktime_spin",
2134 .type = FIO_OPT_INT,
2135 .off1 = td_var_offset(thinktime_spin),
2136 .help = "Start think time by spinning this amount (usec)",
2137 .def = "0",
afdf9352 2138 .parent = "thinktime",
214e1eca
JA
2139 },
2140 {
2141 .name = "thinktime_blocks",
2142 .type = FIO_OPT_INT,
2143 .off1 = td_var_offset(thinktime_blocks),
2144 .help = "IO buffer period between 'thinktime'",
2145 .def = "1",
afdf9352 2146 .parent = "thinktime",
214e1eca
JA
2147 },
2148 {
2149 .name = "rate",
e01b22b8 2150 .type = FIO_OPT_INT,
6eaf09d6
SL
2151 .off1 = td_var_offset(rate[DDIR_READ]),
2152 .off2 = td_var_offset(rate[DDIR_WRITE]),
2153 .off3 = td_var_offset(rate[DDIR_TRIM]),
214e1eca
JA
2154 .help = "Set bandwidth rate",
2155 },
2156 {
2157 .name = "ratemin",
e01b22b8 2158 .type = FIO_OPT_INT,
6eaf09d6
SL
2159 .off1 = td_var_offset(ratemin[DDIR_READ]),
2160 .off2 = td_var_offset(ratemin[DDIR_WRITE]),
2161 .off3 = td_var_offset(ratemin[DDIR_TRIM]),
4e991c23 2162 .help = "Job must meet this rate or it will be shutdown",
afdf9352 2163 .parent = "rate",
4e991c23
JA
2164 },
2165 {
2166 .name = "rate_iops",
e01b22b8 2167 .type = FIO_OPT_INT,
6eaf09d6
SL
2168 .off1 = td_var_offset(rate_iops[DDIR_READ]),
2169 .off2 = td_var_offset(rate_iops[DDIR_WRITE]),
2170 .off3 = td_var_offset(rate_iops[DDIR_TRIM]),
4e991c23
JA
2171 .help = "Limit IO used to this number of IO operations/sec",
2172 },
2173 {
2174 .name = "rate_iops_min",
e01b22b8 2175 .type = FIO_OPT_INT,
6eaf09d6
SL
2176 .off1 = td_var_offset(rate_iops_min[DDIR_READ]),
2177 .off2 = td_var_offset(rate_iops_min[DDIR_WRITE]),
2178 .off3 = td_var_offset(rate_iops_min[DDIR_TRIM]),
03e20d68 2179 .help = "Job must meet this rate or it will be shut down",
afdf9352 2180 .parent = "rate_iops",
214e1eca
JA
2181 },
2182 {
2183 .name = "ratecycle",
2184 .type = FIO_OPT_INT,
2185 .off1 = td_var_offset(ratecycle),
2186 .help = "Window average for rate limits (msec)",
2187 .def = "1000",
afdf9352 2188 .parent = "rate",
214e1eca 2189 },
15501535
JA
2190 {
2191 .name = "max_latency",
2192 .type = FIO_OPT_INT,
2193 .off1 = td_var_offset(max_latency),
2194 .help = "Maximum tolerated IO latency (usec)",
2195 },
214e1eca
JA
2196 {
2197 .name = "invalidate",
2198 .type = FIO_OPT_BOOL,
2199 .off1 = td_var_offset(invalidate_cache),
2200 .help = "Invalidate buffer/page cache prior to running job",
2201 .def = "1",
2202 },
2203 {
2204 .name = "sync",
2205 .type = FIO_OPT_BOOL,
2206 .off1 = td_var_offset(sync_io),
2207 .help = "Use O_SYNC for buffered writes",
2208 .def = "0",
67a1000f 2209 .parent = "buffered",
214e1eca
JA
2210 },
2211 {
2212 .name = "bwavgtime",
2213 .type = FIO_OPT_INT,
2214 .off1 = td_var_offset(bw_avg_time),
5ec10eaa
JA
2215 .help = "Time window over which to calculate bandwidth"
2216 " (msec)",
214e1eca 2217 .def = "500",
c8eeb9df
JA
2218 .parent = "write_bw_log",
2219 },
2220 {
2221 .name = "iopsavgtime",
2222 .type = FIO_OPT_INT,
2223 .off1 = td_var_offset(iops_avg_time),
2224 .help = "Time window over which to calculate IOPS (msec)",
2225 .def = "500",
2226 .parent = "write_iops_log",
214e1eca
JA
2227 },
2228 {
2229 .name = "create_serialize",
2230 .type = FIO_OPT_BOOL,
2231 .off1 = td_var_offset(create_serialize),
2232 .help = "Serialize creating of job files",
2233 .def = "1",
2234 },
2235 {
2236 .name = "create_fsync",
2237 .type = FIO_OPT_BOOL,
2238 .off1 = td_var_offset(create_fsync),
03e20d68 2239 .help = "fsync file after creation",
214e1eca
JA
2240 .def = "1",
2241 },
814452bd
JA
2242 {
2243 .name = "create_on_open",
2244 .type = FIO_OPT_BOOL,
2245 .off1 = td_var_offset(create_on_open),
2246 .help = "Create files when they are opened for IO",
2247 .def = "0",
2248 },
25460cf6
JA
2249 {
2250 .name = "create_only",
2251 .type = FIO_OPT_BOOL,
2252 .off1 = td_var_offset(create_only),
2253 .help = "Only perform file creation phase",
2254 .def = "0",
2255 },
0b9d69ec 2256 {
afad68f7
ZY
2257 .name = "pre_read",
2258 .type = FIO_OPT_BOOL,
2259 .off1 = td_var_offset(pre_read),
03e20d68 2260 .help = "Pre-read files before starting official testing",
afad68f7
ZY
2261 .def = "0",
2262 },
214e1eca
JA
2263 {
2264 .name = "cpuload",
2265 .type = FIO_OPT_INT,
2266 .off1 = td_var_offset(cpuload),
2267 .help = "Use this percentage of CPU",
2268 },
2269 {
2270 .name = "cpuchunks",
2271 .type = FIO_OPT_INT,
2272 .off1 = td_var_offset(cpucycle),
2273 .help = "Length of the CPU burn cycles (usecs)",
2274 .def = "50000",
67a1000f 2275 .parent = "cpuload",
214e1eca
JA
2276 },
2277#ifdef FIO_HAVE_CPU_AFFINITY
2278 {
2279 .name = "cpumask",
2280 .type = FIO_OPT_INT,
2281 .cb = str_cpumask_cb,
2282 .help = "CPU affinity mask",
2283 },
d2e268b0
JA
2284 {
2285 .name = "cpus_allowed",
2286 .type = FIO_OPT_STR,
2287 .cb = str_cpus_allowed_cb,
2288 .help = "Set CPUs allowed",
2289 },
d0b937ed 2290#endif
67bf9823 2291#ifdef CONFIG_LIBNUMA
d0b937ed
YR
2292 {
2293 .name = "numa_cpu_nodes",
2294 .type = FIO_OPT_STR,
2295 .cb = str_numa_cpunodes_cb,
2296 .help = "NUMA CPU nodes bind",
2297 },
2298 {
2299 .name = "numa_mem_policy",
2300 .type = FIO_OPT_STR,
2301 .cb = str_numa_mpol_cb,
2302 .help = "NUMA memory policy setup",
2303 },
214e1eca
JA
2304#endif
2305 {
2306 .name = "end_fsync",
2307 .type = FIO_OPT_BOOL,
2308 .off1 = td_var_offset(end_fsync),
2309 .help = "Include fsync at the end of job",
2310 .def = "0",
2311 },
2312 {
2313 .name = "fsync_on_close",
2314 .type = FIO_OPT_BOOL,
2315 .off1 = td_var_offset(fsync_on_close),
2316 .help = "fsync files on close",
2317 .def = "0",
2318 },
2319 {
2320 .name = "unlink",
2321 .type = FIO_OPT_BOOL,
2322 .off1 = td_var_offset(unlink),
2323 .help = "Unlink created files after job has completed",
2324 .def = "0",
2325 },
2326 {
2327 .name = "exitall",
2328 .type = FIO_OPT_STR_SET,
2329 .cb = str_exitall_cb,
2330 .help = "Terminate all jobs when one exits",
2331 },
2332 {
2333 .name = "stonewall",
d392365e 2334 .alias = "wait_for_previous",
214e1eca
JA
2335 .type = FIO_OPT_STR_SET,
2336 .off1 = td_var_offset(stonewall),
2337 .help = "Insert a hard barrier between this job and previous",
2338 },
b3d62a75
JA
2339 {
2340 .name = "new_group",
2341 .type = FIO_OPT_STR_SET,
2342 .off1 = td_var_offset(new_group),
2343 .help = "Mark the start of a new group (for reporting)",
2344 },
214e1eca
JA
2345 {
2346 .name = "thread",
2347 .type = FIO_OPT_STR_SET,
2348 .off1 = td_var_offset(use_thread),
2349 .help = "Use threads instead of forks",
2350 },
2351 {
2352 .name = "write_bw_log",
e3cedca7 2353 .type = FIO_OPT_STR,
214e1eca 2354 .off1 = td_var_offset(write_bw_log),
e3cedca7 2355 .cb = str_write_bw_log_cb,
214e1eca
JA
2356 .help = "Write log of bandwidth during run",
2357 },
2358 {
2359 .name = "write_lat_log",
e3cedca7 2360 .type = FIO_OPT_STR,
214e1eca 2361 .off1 = td_var_offset(write_lat_log),
e3cedca7 2362 .cb = str_write_lat_log_cb,
214e1eca
JA
2363 .help = "Write log of latency during run",
2364 },
c8eeb9df
JA
2365 {
2366 .name = "write_iops_log",
2367 .type = FIO_OPT_STR,
2368 .off1 = td_var_offset(write_iops_log),
2369 .cb = str_write_iops_log_cb,
2370 .help = "Write log of IOPS during run",
2371 },
b8bc8cba
JA
2372 {
2373 .name = "log_avg_msec",
2374 .type = FIO_OPT_INT,
2375 .off1 = td_var_offset(log_avg_msec),
2376 .help = "Average bw/iops/lat logs over this period of time",
2377 .def = "0",
2378 },
214e1eca
JA
2379 {
2380 .name = "hugepage-size",
e01b22b8 2381 .type = FIO_OPT_INT,
214e1eca
JA
2382 .off1 = td_var_offset(hugepage_size),
2383 .help = "When using hugepages, specify size of each page",
81179eec 2384 .def = __fio_stringify(FIO_HUGE_PAGE),
214e1eca
JA
2385 },
2386 {
2387 .name = "group_reporting",
2388 .type = FIO_OPT_STR_SET,
2389 .off1 = td_var_offset(group_reporting),
2390 .help = "Do reporting on a per-group basis",
2391 },
e9459e5a
JA
2392 {
2393 .name = "zero_buffers",
2394 .type = FIO_OPT_STR_SET,
2395 .off1 = td_var_offset(zero_buffers),
2396 .help = "Init IO buffers to all zeroes",
2397 },
5973cafb
JA
2398 {
2399 .name = "refill_buffers",
2400 .type = FIO_OPT_STR_SET,
2401 .off1 = td_var_offset(refill_buffers),
2402 .help = "Refill IO buffers on every IO submit",
2403 },
fd68418e
JA
2404 {
2405 .name = "scramble_buffers",
2406 .type = FIO_OPT_BOOL,
2407 .off1 = td_var_offset(scramble_buffers),
2408 .help = "Slightly scramble buffers on every IO submit",
2409 .def = "1",
2410 },
9c42684e
JA
2411 {
2412 .name = "buffer_compress_percentage",
2413 .type = FIO_OPT_INT,
2414 .off1 = td_var_offset(compress_percentage),
2415 .maxval = 100,
2416 .minval = 1,
2417 .help = "How compressible the buffer is (approximately)",
2418 },
f97a43a1
JA
2419 {
2420 .name = "buffer_compress_chunk",
2421 .type = FIO_OPT_INT,
2422 .off1 = td_var_offset(compress_chunk),
207b18e4 2423 .parent = "buffer_compress_percentage",
f97a43a1
JA
2424 .help = "Size of compressible region in buffer",
2425 },
83349190
YH
2426 {
2427 .name = "clat_percentiles",
2428 .type = FIO_OPT_BOOL,
2429 .off1 = td_var_offset(clat_percentiles),
2430 .help = "Enable the reporting of completion latency percentiles",
467b35ed 2431 .def = "1",
83349190
YH
2432 },
2433 {
2434 .name = "percentile_list",
2435 .type = FIO_OPT_FLOAT_LIST,
2436 .off1 = td_var_offset(percentile_list),
435d195a 2437 .off2 = td_var_offset(percentile_precision),
83349190 2438 .help = "Specify a custom list of percentiles to report",
fd112d34 2439 .def = "1:5:10:20:30:40:50:60:70:80:90:95:99:99.5:99.9:99.95:99.99",
83349190
YH
2440 .maxlen = FIO_IO_U_LIST_MAX_LEN,
2441 .minfp = 0.0,
2442 .maxfp = 100.0,
2443 },
2444
0a839f30
JA
2445#ifdef FIO_HAVE_DISK_UTIL
2446 {
2447 .name = "disk_util",
2448 .type = FIO_OPT_BOOL,
2449 .off1 = td_var_offset(do_disk_util),
f66ab3c8 2450 .help = "Log disk utilization statistics",
0a839f30
JA
2451 .def = "1",
2452 },
2453#endif
993bf48b
JA
2454 {
2455 .name = "gtod_reduce",
2456 .type = FIO_OPT_BOOL,
2457 .help = "Greatly reduce number of gettimeofday() calls",
2458 .cb = str_gtod_reduce_cb,
2459 .def = "0",
2460 },
02af0988
JA
2461 {
2462 .name = "disable_lat",
2463 .type = FIO_OPT_BOOL,
2464 .off1 = td_var_offset(disable_lat),
2465 .help = "Disable latency numbers",
2466 .parent = "gtod_reduce",
2467 .def = "0",
2468 },
9520ebb9
JA
2469 {
2470 .name = "disable_clat",
2471 .type = FIO_OPT_BOOL,
2472 .off1 = td_var_offset(disable_clat),
2473 .help = "Disable completion latency numbers",
993bf48b 2474 .parent = "gtod_reduce",
9520ebb9
JA
2475 .def = "0",
2476 },
2477 {
2478 .name = "disable_slat",
2479 .type = FIO_OPT_BOOL,
2480 .off1 = td_var_offset(disable_slat),
03e20d68 2481 .help = "Disable submission latency numbers",
993bf48b 2482 .parent = "gtod_reduce",
9520ebb9
JA
2483 .def = "0",
2484 },
2485 {
2486 .name = "disable_bw_measurement",
2487 .type = FIO_OPT_BOOL,
2488 .off1 = td_var_offset(disable_bw),
2489 .help = "Disable bandwidth logging",
993bf48b 2490 .parent = "gtod_reduce",
9520ebb9
JA
2491 .def = "0",
2492 },
be4ecfdf
JA
2493 {
2494 .name = "gtod_cpu",
2495 .type = FIO_OPT_INT,
2496 .cb = str_gtod_cpu_cb,
03e20d68 2497 .help = "Set up dedicated gettimeofday() thread on this CPU",
29d43ff9 2498 .verify = gtod_cpu_verify,
be4ecfdf 2499 },
771e58be
JA
2500 {
2501 .name = "unified_rw_reporting",
2502 .type = FIO_OPT_BOOL,
2503 .off1 = td_var_offset(unified_rw_rep),
2504 .help = "Unify reporting across data direction",
2505 .def = "0",
2506 },
f2bba182
RR
2507 {
2508 .name = "continue_on_error",
06842027 2509 .type = FIO_OPT_STR,
f2bba182 2510 .off1 = td_var_offset(continue_on_error),
03e20d68 2511 .help = "Continue on non-fatal errors during IO",
06842027
SL
2512 .def = "none",
2513 .posval = {
2514 { .ival = "none",
2515 .oval = ERROR_TYPE_NONE,
2516 .help = "Exit when an error is encountered",
2517 },
2518 { .ival = "read",
2519 .oval = ERROR_TYPE_READ,
2520 .help = "Continue on read errors only",
2521 },
2522 { .ival = "write",
2523 .oval = ERROR_TYPE_WRITE,
2524 .help = "Continue on write errors only",
2525 },
2526 { .ival = "io",
2527 .oval = ERROR_TYPE_READ | ERROR_TYPE_WRITE,
2528 .help = "Continue on any IO errors",
2529 },
2530 { .ival = "verify",
2531 .oval = ERROR_TYPE_VERIFY,
2532 .help = "Continue on verify errors only",
2533 },
2534 { .ival = "all",
2535 .oval = ERROR_TYPE_ANY,
2536 .help = "Continue on all io and verify errors",
2537 },
2538 { .ival = "0",
2539 .oval = ERROR_TYPE_NONE,
2540 .help = "Alias for 'none'",
2541 },
2542 { .ival = "1",
2543 .oval = ERROR_TYPE_ANY,
2544 .help = "Alias for 'all'",
2545 },
2546 },
f2bba182 2547 },
8b28bd41
DM
2548 {
2549 .name = "ignore_error",
2550 .type = FIO_OPT_STR,
2551 .cb = str_ignore_error_cb,
2552 .help = "Set a specific list of errors to ignore",
2553 .parent = "rw",
2554 },
2555 {
2556 .name = "error_dump",
2557 .type = FIO_OPT_BOOL,
2558 .off1 = td_var_offset(error_dump),
2559 .def = "0",
2560 .help = "Dump info on each error",
2561 },
2562
9ac8a797
JA
2563 {
2564 .name = "profile",
79d16311 2565 .type = FIO_OPT_STR_STORE,
9ac8a797 2566 .off1 = td_var_offset(profile),
9ac8a797
JA
2567 .help = "Select a specific builtin performance test",
2568 },
a696fa2a
JA
2569 {
2570 .name = "cgroup",
2571 .type = FIO_OPT_STR_STORE,
2572 .off1 = td_var_offset(cgroup),
2573 .help = "Add job to cgroup of this name",
2574 },
2575 {
2576 .name = "cgroup_weight",
2577 .type = FIO_OPT_INT,
2578 .off1 = td_var_offset(cgroup_weight),
2579 .help = "Use given weight for cgroup",
2580 .minval = 100,
2581 .maxval = 1000,
a696fa2a 2582 },
7de87099
VG
2583 {
2584 .name = "cgroup_nodelete",
2585 .type = FIO_OPT_BOOL,
2586 .off1 = td_var_offset(cgroup_nodelete),
2587 .help = "Do not delete cgroups after job completion",
2588 .def = "0",
2589 },
e0b0d892
JA
2590 {
2591 .name = "uid",
2592 .type = FIO_OPT_INT,
2593 .off1 = td_var_offset(uid),
2594 .help = "Run job with this user ID",
2595 },
2596 {
2597 .name = "gid",
2598 .type = FIO_OPT_INT,
2599 .off1 = td_var_offset(gid),
2600 .help = "Run job with this group ID",
2601 },
9e684a49
DE
2602 {
2603 .name = "flow_id",
2604 .type = FIO_OPT_INT,
2605 .off1 = td_var_offset(flow_id),
2606 .help = "The flow index ID to use",
2607 .def = "0",
2608 },
2609 {
2610 .name = "flow",
2611 .type = FIO_OPT_INT,
2612 .off1 = td_var_offset(flow),
2613 .help = "Weight for flow control of this job",
2614 .parent = "flow_id",
2615 .def = "0",
2616 },
2617 {
2618 .name = "flow_watermark",
2619 .type = FIO_OPT_INT,
2620 .off1 = td_var_offset(flow_watermark),
2621 .help = "High watermark for flow control. This option"
2622 " should be set to the same value for all threads"
2623 " with non-zero flow.",
2624 .parent = "flow_id",
2625 .def = "1024",
2626 },
2627 {
2628 .name = "flow_sleep",
2629 .type = FIO_OPT_INT,
2630 .off1 = td_var_offset(flow_sleep),
2631 .help = "How many microseconds to sleep after being held"
2632 " back by the flow control mechanism",
2633 .parent = "flow_id",
2634 .def = "0",
2635 },
214e1eca
JA
2636 {
2637 .name = NULL,
2638 },
2639};
2640
17af15d4 2641static void add_to_lopt(struct option *lopt, struct fio_option *o,
de890a1e 2642 const char *name, int val)
9f81736c 2643{
17af15d4 2644 lopt->name = (char *) name;
de890a1e 2645 lopt->val = val;
9f81736c
JA
2646 if (o->type == FIO_OPT_STR_SET)
2647 lopt->has_arg = no_argument;
2648 else
2649 lopt->has_arg = required_argument;
2650}
2651
de890a1e
SL
2652static void options_to_lopts(struct fio_option *opts,
2653 struct option *long_options,
2654 int i, int option_type)
214e1eca 2655{
de890a1e 2656 struct fio_option *o = &opts[0];
214e1eca 2657 while (o->name) {
de890a1e 2658 add_to_lopt(&long_options[i], o, o->name, option_type);
17af15d4
JA
2659 if (o->alias) {
2660 i++;
de890a1e 2661 add_to_lopt(&long_options[i], o, o->alias, option_type);
17af15d4 2662 }
214e1eca
JA
2663
2664 i++;
2665 o++;
2666 assert(i < FIO_NR_OPTIONS);
2667 }
2668}
2669
de890a1e
SL
2670void fio_options_set_ioengine_opts(struct option *long_options,
2671 struct thread_data *td)
2672{
2673 unsigned int i;
2674
2675 i = 0;
2676 while (long_options[i].name) {
2677 if (long_options[i].val == FIO_GETOPT_IOENGINE) {
2678 memset(&long_options[i], 0, sizeof(*long_options));
2679 break;
2680 }
2681 i++;
2682 }
2683
2684 /*
2685 * Just clear out the prior ioengine options.
2686 */
2687 if (!td || !td->eo)
2688 return;
2689
2690 options_to_lopts(td->io_ops->options, long_options, i,
2691 FIO_GETOPT_IOENGINE);
2692}
2693
2694void fio_options_dup_and_init(struct option *long_options)
2695{
2696 unsigned int i;
2697
2698 options_init(options);
2699
2700 i = 0;
2701 while (long_options[i].name)
2702 i++;
2703
2704 options_to_lopts(options, long_options, i, FIO_GETOPT_JOB);
2705}
2706
74929ac2
JA
2707struct fio_keyword {
2708 const char *word;
2709 const char *desc;
2710 char *replace;
2711};
2712
2713static struct fio_keyword fio_keywords[] = {
2714 {
2715 .word = "$pagesize",
2716 .desc = "Page size in the system",
2717 },
2718 {
2719 .word = "$mb_memory",
2720 .desc = "Megabytes of memory online",
2721 },
2722 {
2723 .word = "$ncpus",
2724 .desc = "Number of CPUs online in the system",
2725 },
2726 {
2727 .word = NULL,
2728 },
2729};
2730
2731void fio_keywords_init(void)
2732{
3b2e1464 2733 unsigned long long mb_memory;
74929ac2
JA
2734 char buf[128];
2735 long l;
2736
a4cfc477 2737 sprintf(buf, "%lu", (unsigned long) page_size);
74929ac2
JA
2738 fio_keywords[0].replace = strdup(buf);
2739
8eb016d3 2740 mb_memory = os_phys_mem() / (1024 * 1024);
3b2e1464 2741 sprintf(buf, "%llu", mb_memory);
74929ac2
JA
2742 fio_keywords[1].replace = strdup(buf);
2743
c00a2289 2744 l = cpus_online();
74929ac2
JA
2745 sprintf(buf, "%lu", l);
2746 fio_keywords[2].replace = strdup(buf);
2747}
2748
892a6ffc
JA
2749#define BC_APP "bc"
2750
2751static char *bc_calc(char *str)
2752{
d0c814ec 2753 char buf[128], *tmp;
892a6ffc
JA
2754 FILE *f;
2755 int ret;
2756
2757 /*
2758 * No math, just return string
2759 */
d0c814ec
SL
2760 if ((!strchr(str, '+') && !strchr(str, '-') && !strchr(str, '*') &&
2761 !strchr(str, '/')) || strchr(str, '\''))
892a6ffc
JA
2762 return str;
2763
2764 /*
2765 * Split option from value, we only need to calculate the value
2766 */
2767 tmp = strchr(str, '=');
2768 if (!tmp)
2769 return str;
2770
2771 tmp++;
892a6ffc 2772
d0c814ec
SL
2773 /*
2774 * Prevent buffer overflows; such a case isn't reasonable anyway
2775 */
2776 if (strlen(str) >= 128 || strlen(tmp) > 100)
2777 return str;
892a6ffc
JA
2778
2779 sprintf(buf, "which %s > /dev/null", BC_APP);
2780 if (system(buf)) {
2781 log_err("fio: bc is needed for performing math\n");
892a6ffc
JA
2782 return NULL;
2783 }
2784
d0c814ec 2785 sprintf(buf, "echo '%s' | %s", tmp, BC_APP);
892a6ffc
JA
2786 f = popen(buf, "r");
2787 if (!f) {
892a6ffc
JA
2788 return NULL;
2789 }
2790
d0c814ec 2791 ret = fread(&buf[tmp - str], 1, 128 - (tmp - str), f);
892a6ffc 2792 if (ret <= 0) {
892a6ffc
JA
2793 return NULL;
2794 }
2795
892a6ffc 2796 pclose(f);
d0c814ec
SL
2797 buf[(tmp - str) + ret - 1] = '\0';
2798 memcpy(buf, str, tmp - str);
892a6ffc 2799 free(str);
d0c814ec
SL
2800 return strdup(buf);
2801}
2802
2803/*
2804 * Return a copy of the input string with substrings of the form ${VARNAME}
2805 * substituted with the value of the environment variable VARNAME. The
2806 * substitution always occurs, even if VARNAME is empty or the corresponding
2807 * environment variable undefined.
2808 */
2809static char *option_dup_subs(const char *opt)
2810{
2811 char out[OPT_LEN_MAX+1];
2812 char in[OPT_LEN_MAX+1];
2813 char *outptr = out;
2814 char *inptr = in;
2815 char *ch1, *ch2, *env;
2816 ssize_t nchr = OPT_LEN_MAX;
2817 size_t envlen;
2818
2819 if (strlen(opt) + 1 > OPT_LEN_MAX) {
2820 log_err("OPT_LEN_MAX (%d) is too small\n", OPT_LEN_MAX);
2821 return NULL;
2822 }
2823
2824 in[OPT_LEN_MAX] = '\0';
2825 strncpy(in, opt, OPT_LEN_MAX);
2826
2827 while (*inptr && nchr > 0) {
2828 if (inptr[0] == '$' && inptr[1] == '{') {
2829 ch2 = strchr(inptr, '}');
2830 if (ch2 && inptr+1 < ch2) {
2831 ch1 = inptr+2;
2832 inptr = ch2+1;
2833 *ch2 = '\0';
2834
2835 env = getenv(ch1);
2836 if (env) {
2837 envlen = strlen(env);
2838 if (envlen <= nchr) {
2839 memcpy(outptr, env, envlen);
2840 outptr += envlen;
2841 nchr -= envlen;
2842 }
2843 }
2844
2845 continue;
2846 }
2847 }
2848
2849 *outptr++ = *inptr++;
2850 --nchr;
2851 }
2852
2853 *outptr = '\0';
2854 return strdup(out);
892a6ffc
JA
2855}
2856
74929ac2
JA
2857/*
2858 * Look for reserved variable names and replace them with real values
2859 */
2860static char *fio_keyword_replace(char *opt)
2861{
2862 char *s;
2863 int i;
d0c814ec 2864 int docalc = 0;
74929ac2
JA
2865
2866 for (i = 0; fio_keywords[i].word != NULL; i++) {
2867 struct fio_keyword *kw = &fio_keywords[i];
2868
2869 while ((s = strstr(opt, kw->word)) != NULL) {
2870 char *new = malloc(strlen(opt) + 1);
2871 char *o_org = opt;
2872 int olen = s - opt;
2873 int len;
2874
2875 /*
2876 * Copy part of the string before the keyword and
2877 * sprintf() the replacement after it.
2878 */
2879 memcpy(new, opt, olen);
2880 len = sprintf(new + olen, "%s", kw->replace);
2881
2882 /*
2883 * If there's more in the original string, copy that
2884 * in too
2885 */
2886 opt += strlen(kw->word) + olen;
2887 if (strlen(opt))
2888 memcpy(new + olen + len, opt, opt - o_org - 1);
2889
2890 /*
2891 * replace opt and free the old opt
2892 */
2893 opt = new;
d0c814ec 2894 free(o_org);
7a958bd5 2895
d0c814ec 2896 docalc = 1;
74929ac2
JA
2897 }
2898 }
2899
d0c814ec
SL
2900 /*
2901 * Check for potential math and invoke bc, if possible
2902 */
2903 if (docalc)
2904 opt = bc_calc(opt);
2905
7a958bd5 2906 return opt;
74929ac2
JA
2907}
2908
d0c814ec
SL
2909static char **dup_and_sub_options(char **opts, int num_opts)
2910{
2911 int i;
2912 char **opts_copy = malloc(num_opts * sizeof(*opts));
2913 for (i = 0; i < num_opts; i++) {
2914 opts_copy[i] = option_dup_subs(opts[i]);
2915 if (!opts_copy[i])
2916 continue;
2917 opts_copy[i] = fio_keyword_replace(opts_copy[i]);
2918 }
2919 return opts_copy;
2920}
2921
3b8b7135 2922int fio_options_parse(struct thread_data *td, char **opts, int num_opts)
214e1eca 2923{
de890a1e 2924 int i, ret, unknown;
d0c814ec 2925 char **opts_copy;
3b8b7135
JA
2926
2927 sort_options(opts, options, num_opts);
d0c814ec 2928 opts_copy = dup_and_sub_options(opts, num_opts);
3b8b7135 2929
de890a1e
SL
2930 for (ret = 0, i = 0, unknown = 0; i < num_opts; i++) {
2931 struct fio_option *o;
2932 int newret = parse_option(opts_copy[i], opts[i], options, &o,
2933 td);
d0c814ec 2934
de890a1e
SL
2935 if (opts_copy[i]) {
2936 if (newret && !o) {
2937 unknown++;
2938 continue;
2939 }
d0c814ec 2940 free(opts_copy[i]);
de890a1e
SL
2941 opts_copy[i] = NULL;
2942 }
2943
2944 ret |= newret;
2945 }
2946
2947 if (unknown) {
2948 ret |= ioengine_load(td);
2949 if (td->eo) {
2950 sort_options(opts_copy, td->io_ops->options, num_opts);
2951 opts = opts_copy;
2952 }
2953 for (i = 0; i < num_opts; i++) {
2954 struct fio_option *o = NULL;
2955 int newret = 1;
2956 if (!opts_copy[i])
2957 continue;
2958
2959 if (td->eo)
2960 newret = parse_option(opts_copy[i], opts[i],
2961 td->io_ops->options, &o,
2962 td->eo);
2963
2964 ret |= newret;
2965 if (!o)
2966 log_err("Bad option <%s>\n", opts[i]);
2967
2968 free(opts_copy[i]);
2969 opts_copy[i] = NULL;
2970 }
74929ac2 2971 }
3b8b7135 2972
d0c814ec 2973 free(opts_copy);
3b8b7135 2974 return ret;
214e1eca
JA
2975}
2976
2977int fio_cmd_option_parse(struct thread_data *td, const char *opt, char *val)
2978{
07b3232d 2979 return parse_cmd_option(opt, val, options, td);
214e1eca
JA
2980}
2981
de890a1e
SL
2982int fio_cmd_ioengine_option_parse(struct thread_data *td, const char *opt,
2983 char *val)
2984{
2985 return parse_cmd_option(opt, val, td->io_ops->options, td);
2986}
2987
214e1eca
JA
2988void fio_fill_default_options(struct thread_data *td)
2989{
2990 fill_default_options(td, options);
2991}
2992
2993int fio_show_option_help(const char *opt)
2994{
07b3232d 2995 return show_cmd_help(options, opt);
214e1eca 2996}
d23bb327 2997
de890a1e 2998void options_mem_dupe(void *data, struct fio_option *options)
d23bb327 2999{
de890a1e 3000 struct fio_option *o;
d23bb327 3001 char **ptr;
d23bb327 3002
de890a1e
SL
3003 for (o = &options[0]; o->name; o++) {
3004 if (o->type != FIO_OPT_STR_STORE)
d23bb327
JA
3005 continue;
3006
de890a1e 3007 ptr = td_var(data, o->off1);
7e356b2d
JA
3008 if (*ptr)
3009 *ptr = strdup(*ptr);
d23bb327
JA
3010 }
3011}
3012
de890a1e
SL
3013/*
3014 * dupe FIO_OPT_STR_STORE options
3015 */
3016void fio_options_mem_dupe(struct thread_data *td)
3017{
3018 options_mem_dupe(&td->o, options);
1647f592
JA
3019
3020 if (td->eo && td->io_ops) {
de890a1e 3021 void *oldeo = td->eo;
1647f592 3022
de890a1e
SL
3023 td->eo = malloc(td->io_ops->option_struct_size);
3024 memcpy(td->eo, oldeo, td->io_ops->option_struct_size);
3025 options_mem_dupe(td->eo, td->io_ops->options);
3026 }
3027}
3028
d6978a32
JA
3029unsigned int fio_get_kb_base(void *data)
3030{
3031 struct thread_data *td = data;
3032 unsigned int kb_base = 0;
3033
3034 if (td)
3035 kb_base = td->o.kb_base;
3036 if (!kb_base)
3037 kb_base = 1024;
3038
3039 return kb_base;
3040}
9f988e2e 3041
07b3232d 3042int add_option(struct fio_option *o)
9f988e2e 3043{
07b3232d
JA
3044 struct fio_option *__o;
3045 int opt_index = 0;
3046
3047 __o = options;
3048 while (__o->name) {
3049 opt_index++;
3050 __o++;
3051 }
3052
3053 memcpy(&options[opt_index], o, sizeof(*o));
3054 return 0;
9f988e2e 3055}
e2de69da 3056
07b3232d 3057void invalidate_profile_options(const char *prof_name)
e2de69da 3058{
07b3232d 3059 struct fio_option *o;
e2de69da 3060
07b3232d
JA
3061 o = options;
3062 while (o->name) {
3063 if (o->prof_name && !strcmp(o->prof_name, prof_name)) {
3064 o->type = FIO_OPT_INVALID;
3065 o->prof_name = NULL;
3066 }
3067 o++;
e2de69da
JA
3068 }
3069}
f5b6bb85
JA
3070
3071void add_opt_posval(const char *optname, const char *ival, const char *help)
3072{
3073 struct fio_option *o;
3074 unsigned int i;
3075
3076 o = find_option(options, optname);
3077 if (!o)
3078 return;
3079
3080 for (i = 0; i < PARSE_MAX_VP; i++) {
3081 if (o->posval[i].ival)
3082 continue;
3083
3084 o->posval[i].ival = ival;
3085 o->posval[i].help = help;
3086 break;
3087 }
3088}
3089
3090void del_opt_posval(const char *optname, const char *ival)
3091{
3092 struct fio_option *o;
3093 unsigned int i;
3094
3095 o = find_option(options, optname);
3096 if (!o)
3097 return;
3098
3099 for (i = 0; i < PARSE_MAX_VP; i++) {
3100 if (!o->posval[i].ival)
3101 continue;
3102 if (strcmp(o->posval[i].ival, ival))
3103 continue;
3104
3105 o->posval[i].ival = NULL;
3106 o->posval[i].help = NULL;
3107 }
3108}
7e356b2d
JA
3109
3110void fio_options_free(struct thread_data *td)
3111{
3112 options_free(options, td);
de890a1e
SL
3113 if (td->eo && td->io_ops && td->io_ops->options) {
3114 options_free(td->io_ops->options, td->eo);
3115 free(td->eo);
3116 td->eo = NULL;
3117 }
7e356b2d 3118}