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