projects / fio.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
Merge branch 'nvme/support-sync-fua-for-iouring-v2' of https://github.com/minwooim/fio
[fio.git] / options.c
... / ...
CommitLineData
1#include <stdio.h>
2#include <stdlib.h>
3#include <unistd.h>
4#include <ctype.h>
5#include <string.h>
6#include <assert.h>
7#include <sys/stat.h>
8#include <netinet/in.h>
9
10#include "fio.h"
11#include "verify.h"
12#include "parse.h"
13#include "lib/pattern.h"
14#include "options.h"
15#include "optgroup.h"
16#include "zbd.h"
17
18char client_sockaddr_str[INET6_ADDRSTRLEN] = { 0 };
19
20#define cb_data_to_td(data) container_of(data, struct thread_data, o)
21
22static const struct pattern_fmt_desc fmt_desc[] = {
23 {
24 .fmt = "%o",
25 .len = FIO_FIELD_SIZE(struct io_u *, offset),
26 .paste = paste_blockoff
27 },
28 { }
29};
30
31/*
32 * Check if mmap/mmaphuge has a :/foo/bar/file at the end. If so, return that.
33 */
34static char *get_opt_postfix(const char *str)
35{
36 char *p = strstr(str, ":");
37
38 if (!p)
39 return NULL;
40
41 p++;
42 strip_blank_front(&p);
43 strip_blank_end(p);
44 return strdup(p);
45}
46
47static bool split_parse_distr(const char *str, double *val, double *center)
48{
49 char *cp, *p;
50 bool r;
51
52 p = strdup(str);
53 if (!p)
54 return false;
55
56 cp = strstr(p, ":");
57 r = true;
58 if (cp) {
59 *cp = '\0';
60 cp++;
61 r = str_to_float(cp, center, 0);
62 }
63 r = r && str_to_float(p, val, 0);
64 free(p);
65 return r;
66}
67
68static int bs_cmp(const void *p1, const void *p2)
69{
70 const struct bssplit *bsp1 = p1;
71 const struct bssplit *bsp2 = p2;
72
73 return (int) bsp1->perc - (int) bsp2->perc;
74}
75
76int split_parse_ddir(struct thread_options *o, struct split *split,
77 char *str, bool absolute, unsigned int max_splits)
78{
79 unsigned long long perc;
80 unsigned int i;
81 long long val;
82 char *fname;
83
84 split->nr = 0;
85
86 i = 0;
87 while ((fname = strsep(&str, ":")) != NULL) {
88 char *perc_str;
89
90 if (!strlen(fname))
91 break;
92
93 perc_str = strstr(fname, "/");
94 if (perc_str) {
95 *perc_str = '\0';
96 perc_str++;
97 if (absolute) {
98 if (str_to_decimal(perc_str, &val, 1, o, 0, 0)) {
99 log_err("fio: split conversion failed\n");
100 return 1;
101 }
102 perc = val;
103 } else {
104 perc = atoi(perc_str);
105 if (perc > 100)
106 perc = 100;
107 else if (!perc)
108 perc = -1U;
109 }
110 } else {
111 if (absolute)
112 perc = 0;
113 else
114 perc = -1U;
115 }
116
117 if (str_to_decimal(fname, &val, 1, o, 0, 0)) {
118 log_err("fio: split conversion failed\n");
119 return 1;
120 }
121
122 split->val1[i] = val;
123 split->val2[i] = perc;
124 i++;
125 if (i == max_splits) {
126 log_err("fio: hit max of %d split entries\n", i);
127 break;
128 }
129 }
130
131 split->nr = i;
132 return 0;
133}
134
135static int bssplit_ddir(struct thread_options *o, void *eo,
136 enum fio_ddir ddir, char *str, bool data)
137{
138 unsigned int i, perc, perc_missing;
139 unsigned long long max_bs, min_bs;
140 struct split split;
141
142 memset(&split, 0, sizeof(split));
143
144 if (split_parse_ddir(o, &split, str, data, BSSPLIT_MAX))
145 return 1;
146 if (!split.nr)
147 return 0;
148
149 max_bs = 0;
150 min_bs = -1;
151 o->bssplit[ddir] = malloc(split.nr * sizeof(struct bssplit));
152 o->bssplit_nr[ddir] = split.nr;
153 for (i = 0; i < split.nr; i++) {
154 if (split.val1[i] > max_bs)
155 max_bs = split.val1[i];
156 if (split.val1[i] < min_bs)
157 min_bs = split.val1[i];
158
159 o->bssplit[ddir][i].bs = split.val1[i];
160 o->bssplit[ddir][i].perc =split.val2[i];
161 }
162
163 /*
164 * Now check if the percentages add up, and how much is missing
165 */
166 perc = perc_missing = 0;
167 for (i = 0; i < o->bssplit_nr[ddir]; i++) {
168 struct bssplit *bsp = &o->bssplit[ddir][i];
169
170 if (bsp->perc == -1U)
171 perc_missing++;
172 else
173 perc += bsp->perc;
174 }
175
176 if (perc > 100 && perc_missing > 1) {
177 log_err("fio: bssplit percentages add to more than 100%%\n");
178 free(o->bssplit[ddir]);
179 o->bssplit[ddir] = NULL;
180 return 1;
181 }
182
183 /*
184 * If values didn't have a percentage set, divide the remains between
185 * them.
186 */
187 if (perc_missing) {
188 if (perc_missing == 1 && o->bssplit_nr[ddir] == 1)
189 perc = 100;
190 for (i = 0; i < o->bssplit_nr[ddir]; i++) {
191 struct bssplit *bsp = &o->bssplit[ddir][i];
192
193 if (bsp->perc == -1U)
194 bsp->perc = (100 - perc) / perc_missing;
195 }
196 }
197
198 o->min_bs[ddir] = min_bs;
199 o->max_bs[ddir] = max_bs;
200
201 /*
202 * now sort based on percentages, for ease of lookup
203 */
204 qsort(o->bssplit[ddir], o->bssplit_nr[ddir], sizeof(struct bssplit), bs_cmp);
205 return 0;
206}
207
208int str_split_parse(struct thread_data *td, char *str,
209 split_parse_fn *fn, void *eo, bool data)
210{
211 char *odir, *ddir;
212 int ret = 0;
213
214 odir = strchr(str, ',');
215 if (odir) {
216 ddir = strchr(odir + 1, ',');
217 if (ddir) {
218 ret = fn(&td->o, eo, DDIR_TRIM, ddir + 1, data);
219 if (!ret)
220 *ddir = '\0';
221 } else {
222 char *op;
223
224 op = strdup(odir + 1);
225 ret = fn(&td->o, eo, DDIR_TRIM, op, data);
226
227 free(op);
228 }
229 if (!ret)
230 ret = fn(&td->o, eo, DDIR_WRITE, odir + 1, data);
231 if (!ret) {
232 *odir = '\0';
233 ret = fn(&td->o, eo, DDIR_READ, str, data);
234 }
235 } else {
236 char *op;
237
238 op = strdup(str);
239 ret = fn(&td->o, eo, DDIR_WRITE, op, data);
240 free(op);
241
242 if (!ret) {
243 op = strdup(str);
244 ret = fn(&td->o, eo, DDIR_TRIM, op, data);
245 free(op);
246 }
247 if (!ret)
248 ret = fn(&td->o, eo, DDIR_READ, str, data);
249 }
250
251 return ret;
252}
253
254static int str_bssplit_cb(void *data, const char *input)
255{
256 struct thread_data *td = cb_data_to_td(data);
257 char *str, *p;
258 int ret = 0;
259
260 p = str = strdup(input);
261
262 strip_blank_front(&str);
263 strip_blank_end(str);
264
265 ret = str_split_parse(td, str, bssplit_ddir, NULL, false);
266
267 if (parse_dryrun()) {
268 int i;
269
270 for (i = 0; i < DDIR_RWDIR_CNT; i++) {
271 free(td->o.bssplit[i]);
272 td->o.bssplit[i] = NULL;
273 td->o.bssplit_nr[i] = 0;
274 }
275 }
276
277 free(p);
278 return ret;
279}
280
281static int parse_cmdprio_bssplit_entry(struct thread_options *o,
282 struct split_prio *entry, char *str)
283{
284 int matches = 0;
285 char *bs_str = NULL;
286 long long bs_val;
287 unsigned int perc = 0, class, level;
288
289 /*
290 * valid entry formats:
291 * bs/ - %s/ - set perc to 0, prio to -1.
292 * bs/perc - %s/%u - set prio to -1.
293 * bs/perc/class/level - %s/%u/%u/%u
294 */
295 matches = sscanf(str, "%m[^/]/%u/%u/%u", &bs_str, &perc, &class, &level);
296 if (matches < 1) {
297 log_err("fio: invalid cmdprio_bssplit format\n");
298 return 1;
299 }
300
301 if (str_to_decimal(bs_str, &bs_val, 1, o, 0, 0)) {
302 log_err("fio: split conversion failed\n");
303 free(bs_str);
304 return 1;
305 }
306 free(bs_str);
307
308 entry->bs = bs_val;
309 entry->perc = min(perc, 100u);
310 entry->prio = -1;
311 switch (matches) {
312 case 1: /* bs/ case */
313 case 2: /* bs/perc case */
314 break;
315 case 4: /* bs/perc/class/level case */
316 class = min(class, (unsigned int) IOPRIO_MAX_PRIO_CLASS);
317 level = min(level, (unsigned int) IOPRIO_MAX_PRIO);
318 entry->prio = ioprio_value(class, level);
319 break;
320 default:
321 log_err("fio: invalid cmdprio_bssplit format\n");
322 return 1;
323 }
324
325 return 0;
326}
327
328/*
329 * Returns a negative integer if the first argument should be before the second
330 * argument in the sorted list. A positive integer if the first argument should
331 * be after the second argument in the sorted list. A zero if they are equal.
332 */
333static int fio_split_prio_cmp(const void *p1, const void *p2)
334{
335 const struct split_prio *tmp1 = p1;
336 const struct split_prio *tmp2 = p2;
337
338 if (tmp1->bs > tmp2->bs)
339 return 1;
340 if (tmp1->bs < tmp2->bs)
341 return -1;
342 return 0;
343}
344
345int split_parse_prio_ddir(struct thread_options *o, struct split_prio **entries,
346 int *nr_entries, char *str)
347{
348 struct split_prio *tmp_entries;
349 unsigned int nr_bssplits;
350 char *str_cpy, *p, *fname;
351
352 /* strsep modifies the string, dup it so that we can use strsep twice */
353 p = str_cpy = strdup(str);
354 if (!p)
355 return 1;
356
357 nr_bssplits = 0;
358 while ((fname = strsep(&str_cpy, ":")) != NULL) {
359 if (!strlen(fname))
360 break;
361 nr_bssplits++;
362 }
363 free(p);
364
365 if (nr_bssplits > BSSPLIT_MAX) {
366 log_err("fio: too many cmdprio_bssplit entries\n");
367 return 1;
368 }
369
370 tmp_entries = calloc(nr_bssplits, sizeof(*tmp_entries));
371 if (!tmp_entries)
372 return 1;
373
374 nr_bssplits = 0;
375 while ((fname = strsep(&str, ":")) != NULL) {
376 struct split_prio *entry;
377
378 if (!strlen(fname))
379 break;
380
381 entry = &tmp_entries[nr_bssplits];
382
383 if (parse_cmdprio_bssplit_entry(o, entry, fname)) {
384 log_err("fio: failed to parse cmdprio_bssplit entry\n");
385 free(tmp_entries);
386 return 1;
387 }
388
389 /* skip zero perc entries, they provide no useful information */
390 if (entry->perc)
391 nr_bssplits++;
392 }
393
394 qsort(tmp_entries, nr_bssplits, sizeof(*tmp_entries),
395 fio_split_prio_cmp);
396
397 *entries = tmp_entries;
398 *nr_entries = nr_bssplits;
399
400 return 0;
401}
402
403static int str2error(char *str)
404{
405 const char *err[] = { "EPERM", "ENOENT", "ESRCH", "EINTR", "EIO",
406 "ENXIO", "E2BIG", "ENOEXEC", "EBADF",
407 "ECHILD", "EAGAIN", "ENOMEM", "EACCES",
408 "EFAULT", "ENOTBLK", "EBUSY", "EEXIST",
409 "EXDEV", "ENODEV", "ENOTDIR", "EISDIR",
410 "EINVAL", "ENFILE", "EMFILE", "ENOTTY",
411 "ETXTBSY","EFBIG", "ENOSPC", "ESPIPE",
412 "EROFS","EMLINK", "EPIPE", "EDOM", "ERANGE" };
413 int i = 0, num = sizeof(err) / sizeof(char *);
414
415 while (i < num) {
416 if (!strcmp(err[i], str))
417 return i + 1;
418 i++;
419 }
420 return 0;
421}
422
423static int ignore_error_type(struct thread_data *td, enum error_type_bit etype,
424 char *str)
425{
426 unsigned int i;
427 int *error;
428 char *fname;
429
430 if (etype >= ERROR_TYPE_CNT) {
431 log_err("Illegal error type\n");
432 return 1;
433 }
434
435 td->o.ignore_error_nr[etype] = 4;
436 error = calloc(4, sizeof(int));
437
438 i = 0;
439 while ((fname = strsep(&str, ":")) != NULL) {
440
441 if (!strlen(fname))
442 break;
443
444 /*
445 * grow struct buffer, if needed
446 */
447 if (i == td->o.ignore_error_nr[etype]) {
448 td->o.ignore_error_nr[etype] <<= 1;
449 error = realloc(error, td->o.ignore_error_nr[etype]
450 * sizeof(int));
451 }
452 if (fname[0] == 'E') {
453 error[i] = str2error(fname);
454 } else {
455 error[i] = atoi(fname);
456 if (error[i] < 0)
457 error[i] = -error[i];
458 }
459 if (!error[i]) {
460 log_err("Unknown error %s, please use number value\n",
461 fname);
462 td->o.ignore_error_nr[etype] = 0;
463 free(error);
464 return 1;
465 }
466 i++;
467 }
468 if (i) {
469 td->o.continue_on_error |= 1 << etype;
470 td->o.ignore_error_nr[etype] = i;
471 td->o.ignore_error[etype] = error;
472 } else {
473 td->o.ignore_error_nr[etype] = 0;
474 free(error);
475 }
476
477 return 0;
478
479}
480
481static int str_replay_skip_cb(void *data, const char *input)
482{
483 struct thread_data *td = cb_data_to_td(data);
484 char *str, *p, *n;
485 int ret = 0;
486
487 if (parse_dryrun())
488 return 0;
489
490 p = str = strdup(input);
491
492 strip_blank_front(&str);
493 strip_blank_end(str);
494
495 while (p) {
496 n = strchr(p, ',');
497 if (n)
498 *n++ = '\0';
499 if (!strcmp(p, "read"))
500 td->o.replay_skip |= 1u << DDIR_READ;
501 else if (!strcmp(p, "write"))
502 td->o.replay_skip |= 1u << DDIR_WRITE;
503 else if (!strcmp(p, "trim"))
504 td->o.replay_skip |= 1u << DDIR_TRIM;
505 else if (!strcmp(p, "sync"))
506 td->o.replay_skip |= 1u << DDIR_SYNC;
507 else {
508 log_err("Unknown skip type: %s\n", p);
509 ret = 1;
510 break;
511 }
512 p = n;
513 }
514 free(str);
515 return ret;
516}
517
518static int str_ignore_error_cb(void *data, const char *input)
519{
520 struct thread_data *td = cb_data_to_td(data);
521 char *str, *p, *n;
522 int ret = 1;
523 enum error_type_bit type = 0;
524
525 if (parse_dryrun())
526 return 0;
527
528 p = str = strdup(input);
529
530 strip_blank_front(&str);
531 strip_blank_end(str);
532
533 while (p) {
534 n = strchr(p, ',');
535 if (n)
536 *n++ = '\0';
537 ret = ignore_error_type(td, type, p);
538 if (ret)
539 break;
540 p = n;
541 type++;
542 }
543 free(str);
544 return ret;
545}
546
547static int str_rw_cb(void *data, const char *str)
548{
549 struct thread_data *td = cb_data_to_td(data);
550 struct thread_options *o = &td->o;
551 char *nr;
552
553 if (parse_dryrun())
554 return 0;
555
556 o->ddir_seq_nr = 1;
557 o->ddir_seq_add = 0;
558
559 nr = get_opt_postfix(str);
560 if (!nr)
561 return 0;
562
563 if (td_random(td))
564 o->ddir_seq_nr = atoi(nr);
565 else {
566 long long val;
567
568 if (str_to_decimal(nr, &val, 1, o, 0, 0)) {
569 log_err("fio: rw postfix parsing failed\n");
570 free(nr);
571 return 1;
572 }
573
574 o->ddir_seq_add = val;
575 }
576
577 free(nr);
578 return 0;
579}
580
581static int str_mem_cb(void *data, const char *mem)
582{
583 struct thread_data *td = cb_data_to_td(data);
584
585 if (td->o.mem_type == MEM_MMAPHUGE || td->o.mem_type == MEM_MMAP ||
586 td->o.mem_type == MEM_MMAPSHARED)
587 td->o.mmapfile = get_opt_postfix(mem);
588
589 return 0;
590}
591
592static int fio_clock_source_cb(void *data, const char *str)
593{
594 struct thread_data *td = cb_data_to_td(data);
595
596 fio_clock_source = td->o.clocksource;
597 fio_clock_source_set = 1;
598 fio_clock_init();
599 return 0;
600}
601
602static int str_rwmix_read_cb(void *data, unsigned long long *val)
603{
604 struct thread_data *td = cb_data_to_td(data);
605
606 td->o.rwmix[DDIR_READ] = *val;
607 td->o.rwmix[DDIR_WRITE] = 100 - *val;
608 return 0;
609}
610
611static int str_rwmix_write_cb(void *data, unsigned long long *val)
612{
613 struct thread_data *td = cb_data_to_td(data);
614
615 td->o.rwmix[DDIR_WRITE] = *val;
616 td->o.rwmix[DDIR_READ] = 100 - *val;
617 return 0;
618}
619
620static int str_exitall_cb(void)
621{
622 exitall_on_terminate = true;
623 return 0;
624}
625
626#ifdef FIO_HAVE_CPU_AFFINITY
627int fio_cpus_split(os_cpu_mask_t *mask, unsigned int cpu_index)
628{
629 unsigned int i, index, cpus_in_mask;
630 const long max_cpu = cpus_online();
631
632 cpus_in_mask = fio_cpu_count(mask);
633 if (!cpus_in_mask)
634 return 0;
635
636 cpu_index = cpu_index % cpus_in_mask;
637
638 index = 0;
639 for (i = 0; i < max_cpu; i++) {
640 if (!fio_cpu_isset(mask, i))
641 continue;
642
643 if (cpu_index != index)
644 fio_cpu_clear(mask, i);
645
646 index++;
647 }
648
649 return fio_cpu_count(mask);
650}
651
652static int str_cpumask_cb(void *data, unsigned long long *val)
653{
654 struct thread_data *td = cb_data_to_td(data);
655 unsigned int i;
656 long max_cpu;
657 int ret;
658
659 if (parse_dryrun())
660 return 0;
661
662 ret = fio_cpuset_init(&td->o.cpumask);
663 if (ret < 0) {
664 log_err("fio: cpuset_init failed\n");
665 td_verror(td, ret, "fio_cpuset_init");
666 return 1;
667 }
668
669 max_cpu = cpus_online();
670
671 for (i = 0; i < sizeof(int) * 8; i++) {
672 if ((1 << i) & *val) {
673 if (i >= max_cpu) {
674 log_err("fio: CPU %d too large (max=%ld)\n", i,
675 max_cpu - 1);
676 return 1;
677 }
678 dprint(FD_PARSE, "set cpu allowed %d\n", i);
679 fio_cpu_set(&td->o.cpumask, i);
680 }
681 }
682
683 return 0;
684}
685
686static int set_cpus_allowed(struct thread_data *td, os_cpu_mask_t *mask,
687 const char *input)
688{
689 char *cpu, *str, *p;
690 long max_cpu;
691 int ret = 0;
692
693 ret = fio_cpuset_init(mask);
694 if (ret < 0) {
695 log_err("fio: cpuset_init failed\n");
696 td_verror(td, ret, "fio_cpuset_init");
697 return 1;
698 }
699
700 p = str = strdup(input);
701
702 strip_blank_front(&str);
703 strip_blank_end(str);
704
705 max_cpu = cpus_online();
706
707 while ((cpu = strsep(&str, ",")) != NULL) {
708 char *str2, *cpu2;
709 int icpu, icpu2;
710
711 if (!strlen(cpu))
712 break;
713
714 str2 = cpu;
715 icpu2 = -1;
716 while ((cpu2 = strsep(&str2, "-")) != NULL) {
717 if (!strlen(cpu2))
718 break;
719
720 icpu2 = atoi(cpu2);
721 }
722
723 icpu = atoi(cpu);
724 if (icpu2 == -1)
725 icpu2 = icpu;
726 while (icpu <= icpu2) {
727 if (icpu >= FIO_MAX_CPUS) {
728 log_err("fio: your OS only supports up to"
729 " %d CPUs\n", (int) FIO_MAX_CPUS);
730 ret = 1;
731 break;
732 }
733 if (icpu >= max_cpu) {
734 log_err("fio: CPU %d too large (max=%ld)\n",
735 icpu, max_cpu - 1);
736 ret = 1;
737 break;
738 }
739
740 dprint(FD_PARSE, "set cpu allowed %d\n", icpu);
741 fio_cpu_set(mask, icpu);
742 icpu++;
743 }
744 if (ret)
745 break;
746 }
747
748 free(p);
749 return ret;
750}
751
752static int str_cpus_allowed_cb(void *data, const char *input)
753{
754 struct thread_data *td = cb_data_to_td(data);
755
756 if (parse_dryrun())
757 return 0;
758
759 return set_cpus_allowed(td, &td->o.cpumask, input);
760}
761
762static int str_verify_cpus_allowed_cb(void *data, const char *input)
763{
764 struct thread_data *td = cb_data_to_td(data);
765
766 if (parse_dryrun())
767 return 0;
768
769 return set_cpus_allowed(td, &td->o.verify_cpumask, input);
770}
771
772#ifdef CONFIG_ZLIB
773static int str_log_cpus_allowed_cb(void *data, const char *input)
774{
775 struct thread_data *td = cb_data_to_td(data);
776
777 if (parse_dryrun())
778 return 0;
779
780 return set_cpus_allowed(td, &td->o.log_gz_cpumask, input);
781}
782#endif /* CONFIG_ZLIB */
783
784#endif /* FIO_HAVE_CPU_AFFINITY */
785
786#ifdef CONFIG_LIBNUMA
787static int str_numa_cpunodes_cb(void *data, char *input)
788{
789 struct thread_data *td = cb_data_to_td(data);
790 struct bitmask *verify_bitmask;
791
792 if (parse_dryrun())
793 return 0;
794
795 /* numa_parse_nodestring() parses a character string list
796 * of nodes into a bit mask. The bit mask is allocated by
797 * numa_allocate_nodemask(), so it should be freed by
798 * numa_free_nodemask().
799 */
800 verify_bitmask = numa_parse_nodestring(input);
801 if (verify_bitmask == NULL) {
802 log_err("fio: numa_parse_nodestring failed\n");
803 td_verror(td, 1, "str_numa_cpunodes_cb");
804 return 1;
805 }
806 numa_free_nodemask(verify_bitmask);
807
808 td->o.numa_cpunodes = strdup(input);
809 return 0;
810}
811
812static int str_numa_mpol_cb(void *data, char *input)
813{
814 struct thread_data *td = cb_data_to_td(data);
815 const char * const policy_types[] =
816 { "default", "prefer", "bind", "interleave", "local", NULL };
817 int i;
818 char *nodelist;
819 struct bitmask *verify_bitmask;
820
821 if (parse_dryrun())
822 return 0;
823
824 nodelist = strchr(input, ':');
825 if (nodelist) {
826 /* NUL-terminate mode */
827 *nodelist++ = '\0';
828 }
829
830 for (i = 0; i <= MPOL_LOCAL; i++) {
831 if (!strcmp(input, policy_types[i])) {
832 td->o.numa_mem_mode = i;
833 break;
834 }
835 }
836 if (i > MPOL_LOCAL) {
837 log_err("fio: memory policy should be: default, prefer, bind, interleave, local\n");
838 goto out;
839 }
840
841 switch (td->o.numa_mem_mode) {
842 case MPOL_PREFERRED:
843 /*
844 * Insist on a nodelist of one node only
845 */
846 if (nodelist) {
847 char *rest = nodelist;
848 while (isdigit(*rest))
849 rest++;
850 if (*rest) {
851 log_err("fio: one node only for \'prefer\'\n");
852 goto out;
853 }
854 } else {
855 log_err("fio: one node is needed for \'prefer\'\n");
856 goto out;
857 }
858 break;
859 case MPOL_INTERLEAVE:
860 /*
861 * Default to online nodes with memory if no nodelist
862 */
863 if (!nodelist)
864 nodelist = strdup("all");
865 break;
866 case MPOL_LOCAL:
867 case MPOL_DEFAULT:
868 /*
869 * Don't allow a nodelist
870 */
871 if (nodelist) {
872 log_err("fio: NO nodelist for \'local\'\n");
873 goto out;
874 }
875 break;
876 case MPOL_BIND:
877 /*
878 * Insist on a nodelist
879 */
880 if (!nodelist) {
881 log_err("fio: a nodelist is needed for \'bind\'\n");
882 goto out;
883 }
884 break;
885 }
886
887
888 /* numa_parse_nodestring() parses a character string list
889 * of nodes into a bit mask. The bit mask is allocated by
890 * numa_allocate_nodemask(), so it should be freed by
891 * numa_free_nodemask().
892 */
893 switch (td->o.numa_mem_mode) {
894 case MPOL_PREFERRED:
895 td->o.numa_mem_prefer_node = atoi(nodelist);
896 break;
897 case MPOL_INTERLEAVE:
898 case MPOL_BIND:
899 verify_bitmask = numa_parse_nodestring(nodelist);
900 if (verify_bitmask == NULL) {
901 log_err("fio: numa_parse_nodestring failed\n");
902 td_verror(td, 1, "str_numa_memnodes_cb");
903 return 1;
904 }
905 td->o.numa_memnodes = strdup(nodelist);
906 numa_free_nodemask(verify_bitmask);
907
908 break;
909 case MPOL_LOCAL:
910 case MPOL_DEFAULT:
911 default:
912 break;
913 }
914
915 return 0;
916out:
917 return 1;
918}
919#endif
920
921static int str_fst_cb(void *data, const char *str)
922{
923 struct thread_data *td = cb_data_to_td(data);
924 double val;
925 double center = -1;
926 bool done = false;
927 char *nr;
928
929 td->file_service_nr = 1;
930
931 switch (td->o.file_service_type) {
932 case FIO_FSERVICE_RANDOM:
933 case FIO_FSERVICE_RR:
934 case FIO_FSERVICE_SEQ:
935 nr = get_opt_postfix(str);
936 if (nr) {
937 td->file_service_nr = atoi(nr);
938 free(nr);
939 }
940 done = true;
941 break;
942 case FIO_FSERVICE_ZIPF:
943 val = FIO_DEF_ZIPF;
944 break;
945 case FIO_FSERVICE_PARETO:
946 val = FIO_DEF_PARETO;
947 break;
948 case FIO_FSERVICE_GAUSS:
949 val = 0.0;
950 break;
951 default:
952 log_err("fio: bad file service type: %d\n", td->o.file_service_type);
953 return 1;
954 }
955
956 if (done)
957 return 0;
958
959 nr = get_opt_postfix(str);
960 if (nr && !split_parse_distr(nr, &val, &center)) {
961 log_err("fio: file service type random postfix parsing failed\n");
962 free(nr);
963 return 1;
964 }
965
966 free(nr);
967
968 if (center != -1 && (center < 0.00 || center > 1.00)) {
969 log_err("fio: distribution center out of range (0 <= center <= 1.0)\n");
970 return 1;
971 }
972 td->random_center = center;
973
974 switch (td->o.file_service_type) {
975 case FIO_FSERVICE_ZIPF:
976 if (val == 1.00) {
977 log_err("fio: zipf theta must be different than 1.0\n");
978 return 1;
979 }
980 if (parse_dryrun())
981 return 0;
982 td->zipf_theta = val;
983 break;
984 case FIO_FSERVICE_PARETO:
985 if (val <= 0.00 || val >= 1.00) {
986 log_err("fio: pareto input out of range (0 < input < 1.0)\n");
987 return 1;
988 }
989 if (parse_dryrun())
990 return 0;
991 td->pareto_h = val;
992 break;
993 case FIO_FSERVICE_GAUSS:
994 if (val < 0.00 || val >= 100.00) {
995 log_err("fio: normal deviation out of range (0 <= input < 100.0)\n");
996 return 1;
997 }
998 if (parse_dryrun())
999 return 0;
1000 td->gauss_dev = val;
1001 break;
1002 }
1003
1004 return 0;
1005}
1006
1007#ifdef CONFIG_SYNC_FILE_RANGE
1008static int str_sfr_cb(void *data, const char *str)
1009{
1010 struct thread_data *td = cb_data_to_td(data);
1011 char *nr = get_opt_postfix(str);
1012
1013 td->sync_file_range_nr = 1;
1014 if (nr) {
1015 td->sync_file_range_nr = atoi(nr);
1016 free(nr);
1017 }
1018
1019 return 0;
1020}
1021#endif
1022
1023static int zone_split_ddir(struct thread_options *o, void *eo,
1024 enum fio_ddir ddir, char *str, bool absolute)
1025{
1026 unsigned int i, perc, perc_missing, sperc, sperc_missing;
1027 struct split split;
1028
1029 memset(&split, 0, sizeof(split));
1030
1031 if (split_parse_ddir(o, &split, str, absolute, ZONESPLIT_MAX))
1032 return 1;
1033 if (!split.nr)
1034 return 0;
1035
1036 o->zone_split[ddir] = malloc(split.nr * sizeof(struct zone_split));
1037 o->zone_split_nr[ddir] = split.nr;
1038 for (i = 0; i < split.nr; i++) {
1039 o->zone_split[ddir][i].access_perc = split.val1[i];
1040 if (absolute)
1041 o->zone_split[ddir][i].size = split.val2[i];
1042 else
1043 o->zone_split[ddir][i].size_perc = split.val2[i];
1044 }
1045
1046 /*
1047 * Now check if the percentages add up, and how much is missing
1048 */
1049 perc = perc_missing = 0;
1050 sperc = sperc_missing = 0;
1051 for (i = 0; i < o->zone_split_nr[ddir]; i++) {
1052 struct zone_split *zsp = &o->zone_split[ddir][i];
1053
1054 if (zsp->access_perc == (uint8_t) -1U)
1055 perc_missing++;
1056 else
1057 perc += zsp->access_perc;
1058
1059 if (!absolute) {
1060 if (zsp->size_perc == (uint8_t) -1U)
1061 sperc_missing++;
1062 else
1063 sperc += zsp->size_perc;
1064 }
1065 }
1066
1067 if (perc > 100 || sperc > 100) {
1068 log_err("fio: zone_split percentages add to more than 100%%\n");
1069 free(o->zone_split[ddir]);
1070 o->zone_split[ddir] = NULL;
1071 return 1;
1072 }
1073 if (perc < 100) {
1074 log_err("fio: access percentage don't add up to 100 for zoned "
1075 "random distribution (got=%u)\n", perc);
1076 free(o->zone_split[ddir]);
1077 o->zone_split[ddir] = NULL;
1078 return 1;
1079 }
1080
1081 /*
1082 * If values didn't have a percentage set, divide the remains between
1083 * them.
1084 */
1085 if (perc_missing) {
1086 if (perc_missing == 1 && o->zone_split_nr[ddir] == 1)
1087 perc = 100;
1088 for (i = 0; i < o->zone_split_nr[ddir]; i++) {
1089 struct zone_split *zsp = &o->zone_split[ddir][i];
1090
1091 if (zsp->access_perc == (uint8_t) -1U)
1092 zsp->access_perc = (100 - perc) / perc_missing;
1093 }
1094 }
1095 if (sperc_missing) {
1096 if (sperc_missing == 1 && o->zone_split_nr[ddir] == 1)
1097 sperc = 100;
1098 for (i = 0; i < o->zone_split_nr[ddir]; i++) {
1099 struct zone_split *zsp = &o->zone_split[ddir][i];
1100
1101 if (zsp->size_perc == (uint8_t) -1U)
1102 zsp->size_perc = (100 - sperc) / sperc_missing;
1103 }
1104 }
1105
1106 return 0;
1107}
1108
1109static int parse_zoned_distribution(struct thread_data *td, const char *input,
1110 bool absolute)
1111{
1112 const char *pre = absolute ? "zoned_abs:" : "zoned:";
1113 char *str, *p;
1114 int i, ret = 0;
1115
1116 p = str = strdup(input);
1117
1118 strip_blank_front(&str);
1119 strip_blank_end(str);
1120
1121 /* We expect it to start like that, bail if not */
1122 if (strncmp(str, pre, strlen(pre))) {
1123 log_err("fio: mismatch in zoned input <%s>\n", str);
1124 free(p);
1125 return 1;
1126 }
1127 str += strlen(pre);
1128
1129 ret = str_split_parse(td, str, zone_split_ddir, NULL, absolute);
1130
1131 free(p);
1132
1133 for (i = 0; i < DDIR_RWDIR_CNT; i++) {
1134 int j;
1135
1136 dprint(FD_PARSE, "zone ddir %d (nr=%u): \n", i, td->o.zone_split_nr[i]);
1137
1138 for (j = 0; j < td->o.zone_split_nr[i]; j++) {
1139 struct zone_split *zsp = &td->o.zone_split[i][j];
1140
1141 if (absolute) {
1142 dprint(FD_PARSE, "\t%d: %u/%llu\n", j,
1143 zsp->access_perc,
1144 (unsigned long long) zsp->size);
1145 } else {
1146 dprint(FD_PARSE, "\t%d: %u/%u\n", j,
1147 zsp->access_perc,
1148 zsp->size_perc);
1149 }
1150 }
1151 }
1152
1153 if (parse_dryrun()) {
1154 for (i = 0; i < DDIR_RWDIR_CNT; i++) {
1155 free(td->o.zone_split[i]);
1156 td->o.zone_split[i] = NULL;
1157 td->o.zone_split_nr[i] = 0;
1158 }
1159
1160 return ret;
1161 }
1162
1163 if (ret) {
1164 for (i = 0; i < DDIR_RWDIR_CNT; i++)
1165 td->o.zone_split_nr[i] = 0;
1166 }
1167
1168 return ret;
1169}
1170
1171static int str_random_distribution_cb(void *data, const char *str)
1172{
1173 struct thread_data *td = cb_data_to_td(data);
1174 double val;
1175 double center = -1;
1176 char *nr;
1177
1178 if (td->o.random_distribution == FIO_RAND_DIST_ZIPF)
1179 val = FIO_DEF_ZIPF;
1180 else if (td->o.random_distribution == FIO_RAND_DIST_PARETO)
1181 val = FIO_DEF_PARETO;
1182 else if (td->o.random_distribution == FIO_RAND_DIST_GAUSS)
1183 val = 0.0;
1184 else if (td->o.random_distribution == FIO_RAND_DIST_ZONED)
1185 return parse_zoned_distribution(td, str, false);
1186 else if (td->o.random_distribution == FIO_RAND_DIST_ZONED_ABS)
1187 return parse_zoned_distribution(td, str, true);
1188 else
1189 return 0;
1190
1191 nr = get_opt_postfix(str);
1192 if (nr && !split_parse_distr(nr, &val, &center)) {
1193 log_err("fio: random postfix parsing failed\n");
1194 free(nr);
1195 return 1;
1196 }
1197
1198 free(nr);
1199
1200 if (center != -1 && (center < 0.00 || center > 1.00)) {
1201 log_err("fio: distribution center out of range (0 <= center <= 1.0)\n");
1202 return 1;
1203 }
1204 td->o.random_center.u.f = center;
1205
1206 if (td->o.random_distribution == FIO_RAND_DIST_ZIPF) {
1207 if (val == 1.00) {
1208 log_err("fio: zipf theta must different than 1.0\n");
1209 return 1;
1210 }
1211 if (parse_dryrun())
1212 return 0;
1213 td->o.zipf_theta.u.f = val;
1214 } else if (td->o.random_distribution == FIO_RAND_DIST_PARETO) {
1215 if (val <= 0.00 || val >= 1.00) {
1216 log_err("fio: pareto input out of range (0 < input < 1.0)\n");
1217 return 1;
1218 }
1219 if (parse_dryrun())
1220 return 0;
1221 td->o.pareto_h.u.f = val;
1222 } else {
1223 if (val < 0.00 || val >= 100.0) {
1224 log_err("fio: normal deviation out of range (0 <= input < 100.0)\n");
1225 return 1;
1226 }
1227 if (parse_dryrun())
1228 return 0;
1229 td->o.gauss_dev.u.f = val;
1230 }
1231
1232 return 0;
1233}
1234
1235static int str_steadystate_cb(void *data, const char *str)
1236{
1237 struct thread_data *td = cb_data_to_td(data);
1238 double val;
1239 char *nr;
1240 char *pct;
1241 long long ll;
1242
1243 if (td->o.ss_state != FIO_SS_IOPS && td->o.ss_state != FIO_SS_IOPS_SLOPE &&
1244 td->o.ss_state != FIO_SS_BW && td->o.ss_state != FIO_SS_BW_SLOPE) {
1245 /* should be impossible to get here */
1246 log_err("fio: unknown steady state criterion\n");
1247 return 1;
1248 }
1249
1250 nr = get_opt_postfix(str);
1251 if (!nr) {
1252 log_err("fio: steadystate threshold must be specified in addition to criterion\n");
1253 free(nr);
1254 return 1;
1255 }
1256
1257 /* ENHANCEMENT Allow fio to understand size=10.2% and use here */
1258 pct = strstr(nr, "%");
1259 if (pct) {
1260 *pct = '\0';
1261 strip_blank_end(nr);
1262 if (!str_to_float(nr, &val, 0)) {
1263 log_err("fio: could not parse steadystate threshold percentage\n");
1264 free(nr);
1265 return 1;
1266 }
1267
1268 dprint(FD_PARSE, "set steady state threshold to %f%%\n", val);
1269 free(nr);
1270 if (parse_dryrun())
1271 return 0;
1272
1273 td->o.ss_state |= FIO_SS_PCT;
1274 td->o.ss_limit.u.f = val;
1275 } else if (td->o.ss_state & FIO_SS_IOPS) {
1276 if (!str_to_float(nr, &val, 0)) {
1277 log_err("fio: steadystate IOPS threshold postfix parsing failed\n");
1278 free(nr);
1279 return 1;
1280 }
1281
1282 dprint(FD_PARSE, "set steady state IOPS threshold to %f\n", val);
1283 free(nr);
1284 if (parse_dryrun())
1285 return 0;
1286
1287 td->o.ss_limit.u.f = val;
1288 } else { /* bandwidth criterion */
1289 if (str_to_decimal(nr, &ll, 1, td, 0, 0)) {
1290 log_err("fio: steadystate BW threshold postfix parsing failed\n");
1291 free(nr);
1292 return 1;
1293 }
1294
1295 dprint(FD_PARSE, "set steady state BW threshold to %lld\n", ll);
1296 free(nr);
1297 if (parse_dryrun())
1298 return 0;
1299
1300 td->o.ss_limit.u.f = (double) ll;
1301 }
1302
1303 td->ss.state = td->o.ss_state;
1304 return 0;
1305}
1306
1307/*
1308 * Return next name in the string. Files are separated with ':'. If the ':'
1309 * is escaped with a '\', then that ':' is part of the filename and does not
1310 * indicate a new file.
1311 */
1312char *get_next_str(char **ptr)
1313{
1314 char *str = *ptr;
1315 char *p, *start;
1316
1317 if (!str || !strlen(str))
1318 return NULL;
1319
1320 start = str;
1321 do {
1322 /*
1323 * No colon, we are done
1324 */
1325 p = strchr(str, ':');
1326 if (!p) {
1327 *ptr = NULL;
1328 break;
1329 }
1330
1331 /*
1332 * We got a colon, but it's the first character. Skip and
1333 * continue
1334 */
1335 if (p == start) {
1336 str = ++start;
1337 continue;
1338 }
1339
1340 if (*(p - 1) != '\\') {
1341 *p = '\0';
1342 *ptr = p + 1;
1343 break;
1344 }
1345
1346 memmove(p - 1, p, strlen(p) + 1);
1347 str = p;
1348 } while (1);
1349
1350 return start;
1351}
1352
1353
1354int get_max_str_idx(char *input)
1355{
1356 unsigned int cur_idx;
1357 char *str, *p;
1358
1359 p = str = strdup(input);
1360 for (cur_idx = 0; ; cur_idx++)
1361 if (get_next_str(&str) == NULL)
1362 break;
1363
1364 free(p);
1365 return cur_idx;
1366}
1367
1368/*
1369 * Returns the directory at the index, indexes > entries will be
1370 * assigned via modulo division of the index
1371 */
1372int set_name_idx(char *target, size_t tlen, char *input, int index,
1373 bool unique_filename)
1374{
1375 unsigned int cur_idx;
1376 int len;
1377 char *fname, *str, *p;
1378
1379 p = str = strdup(input);
1380
1381 index %= get_max_str_idx(input);
1382 for (cur_idx = 0; cur_idx <= index; cur_idx++)
1383 fname = get_next_str(&str);
1384
1385 if (client_sockaddr_str[0] && unique_filename) {
1386 len = snprintf(target, tlen, "%s/%s.", fname,
1387 client_sockaddr_str);
1388 } else
1389 len = snprintf(target, tlen, "%s%c", fname,
1390 FIO_OS_PATH_SEPARATOR);
1391
1392 target[tlen - 1] = '\0';
1393 free(p);
1394
1395 return len;
1396}
1397
1398char* get_name_by_idx(char *input, int index)
1399{
1400 unsigned int cur_idx;
1401 char *fname, *str, *p;
1402
1403 p = str = strdup(input);
1404
1405 index %= get_max_str_idx(input);
1406 for (cur_idx = 0; cur_idx <= index; cur_idx++)
1407 fname = get_next_str(&str);
1408
1409 fname = strdup(fname);
1410 free(p);
1411
1412 return fname;
1413}
1414
1415static int str_filename_cb(void *data, const char *input)
1416{
1417 struct thread_data *td = cb_data_to_td(data);
1418 char *fname, *str, *p;
1419
1420 p = str = strdup(input);
1421
1422 strip_blank_front(&str);
1423 strip_blank_end(str);
1424
1425 /*
1426 * Ignore what we may already have from nrfiles option.
1427 */
1428 if (!td->files_index)
1429 td->o.nr_files = 0;
1430
1431 while ((fname = get_next_str(&str)) != NULL) {
1432 if (!strlen(fname))
1433 break;
1434 add_file(td, fname, 0, 1);
1435 }
1436
1437 free(p);
1438 return 0;
1439}
1440
1441static int str_directory_cb(void *data, const char fio_unused *unused)
1442{
1443 struct thread_data *td = cb_data_to_td(data);
1444 struct stat sb;
1445 char *dirname, *str, *p;
1446 int ret = 0;
1447
1448 if (parse_dryrun())
1449 return 0;
1450
1451 p = str = strdup(td->o.directory);
1452 while ((dirname = get_next_str(&str)) != NULL) {
1453 if (lstat(dirname, &sb) < 0) {
1454 ret = errno;
1455
1456 log_err("fio: %s is not a directory\n", dirname);
1457 td_verror(td, ret, "lstat");
1458 goto out;
1459 }
1460 if (!S_ISDIR(sb.st_mode)) {
1461 log_err("fio: %s is not a directory\n", dirname);
1462 ret = 1;
1463 goto out;
1464 }
1465 }
1466
1467out:
1468 free(p);
1469 return ret;
1470}
1471
1472static int str_opendir_cb(void *data, const char fio_unused *str)
1473{
1474 struct thread_data *td = cb_data_to_td(data);
1475
1476 if (parse_dryrun())
1477 return 0;
1478
1479 if (!td->files_index)
1480 td->o.nr_files = 0;
1481
1482 return add_dir_files(td, td->o.opendir);
1483}
1484
1485static int str_buffer_pattern_cb(void *data, const char *input)
1486{
1487 struct thread_data *td = cb_data_to_td(data);
1488 int ret;
1489
1490 /* FIXME: for now buffer pattern does not support formats */
1491 ret = parse_and_fill_pattern(input, strlen(input), td->o.buffer_pattern,
1492 MAX_PATTERN_SIZE, NULL, NULL, NULL);
1493 if (ret < 0)
1494 return 1;
1495
1496 assert(ret != 0);
1497 td->o.buffer_pattern_bytes = ret;
1498
1499 /*
1500 * If this job is doing any reading or has compression set,
1501 * ensure that we refill buffers for writes or we could be
1502 * invalidating the pattern through reads.
1503 */
1504 if (!td->o.compress_percentage && !td_read(td))
1505 td->o.refill_buffers = 0;
1506 else
1507 td->o.refill_buffers = 1;
1508
1509 td->o.scramble_buffers = 0;
1510 td->o.zero_buffers = 0;
1511
1512 return 0;
1513}
1514
1515static int str_buffer_compress_cb(void *data, unsigned long long *il)
1516{
1517 struct thread_data *td = cb_data_to_td(data);
1518
1519 td->flags |= TD_F_COMPRESS;
1520 td->o.compress_percentage = *il;
1521 return 0;
1522}
1523
1524static int str_dedupe_cb(void *data, unsigned long long *il)
1525{
1526 struct thread_data *td = cb_data_to_td(data);
1527
1528 td->flags |= TD_F_COMPRESS;
1529 td->o.dedupe_percentage = *il;
1530 td->o.refill_buffers = 1;
1531 return 0;
1532}
1533
1534static int str_verify_pattern_cb(void *data, const char *input)
1535{
1536 struct thread_data *td = cb_data_to_td(data);
1537 int ret;
1538
1539 td->o.verify_fmt_sz = FIO_ARRAY_SIZE(td->o.verify_fmt);
1540 ret = parse_and_fill_pattern(input, strlen(input), td->o.verify_pattern,
1541 MAX_PATTERN_SIZE, fmt_desc,
1542 td->o.verify_fmt, &td->o.verify_fmt_sz);
1543 if (ret < 0)
1544 return 1;
1545
1546 assert(ret != 0);
1547 td->o.verify_pattern_bytes = ret;
1548 /*
1549 * VERIFY_* could already be set
1550 */
1551 if (!fio_option_is_set(&td->o, verify))
1552 td->o.verify = VERIFY_PATTERN;
1553
1554 return 0;
1555}
1556
1557static int str_gtod_reduce_cb(void *data, int *il)
1558{
1559 struct thread_data *td = cb_data_to_td(data);
1560 int val = *il;
1561
1562 /*
1563 * Only modify options if gtod_reduce==1
1564 * Otherwise leave settings alone.
1565 */
1566 if (val) {
1567 td->o.disable_lat = 1;
1568 td->o.disable_clat = 1;
1569 td->o.disable_slat = 1;
1570 td->o.disable_bw = 1;
1571 td->o.clat_percentiles = 0;
1572 td->o.lat_percentiles = 0;
1573 td->o.slat_percentiles = 0;
1574 td->ts_cache_mask = 63;
1575 }
1576
1577 return 0;
1578}
1579
1580static int str_offset_cb(void *data, unsigned long long *__val)
1581{
1582 struct thread_data *td = cb_data_to_td(data);
1583 unsigned long long v = *__val;
1584
1585 if (parse_is_percent(v)) {
1586 td->o.start_offset = 0;
1587 td->o.start_offset_percent = -1ULL - v;
1588 td->o.start_offset_nz = 0;
1589 dprint(FD_PARSE, "SET start_offset_percent %d\n",
1590 td->o.start_offset_percent);
1591 } else if (parse_is_zone(v)) {
1592 td->o.start_offset = 0;
1593 td->o.start_offset_percent = 0;
1594 td->o.start_offset_nz = v - ZONE_BASE_VAL;
1595 } else
1596 td->o.start_offset = v;
1597
1598 return 0;
1599}
1600
1601static int str_offset_increment_cb(void *data, unsigned long long *__val)
1602{
1603 struct thread_data *td = cb_data_to_td(data);
1604 unsigned long long v = *__val;
1605
1606 if (parse_is_percent(v)) {
1607 td->o.offset_increment = 0;
1608 td->o.offset_increment_percent = -1ULL - v;
1609 td->o.offset_increment_nz = 0;
1610 dprint(FD_PARSE, "SET offset_increment_percent %d\n",
1611 td->o.offset_increment_percent);
1612 } else if (parse_is_zone(v)) {
1613 td->o.offset_increment = 0;
1614 td->o.offset_increment_percent = 0;
1615 td->o.offset_increment_nz = v - ZONE_BASE_VAL;
1616 } else
1617 td->o.offset_increment = v;
1618
1619 return 0;
1620}
1621
1622static int str_size_cb(void *data, unsigned long long *__val)
1623{
1624 struct thread_data *td = cb_data_to_td(data);
1625 unsigned long long v = *__val;
1626
1627 if (parse_is_percent(v)) {
1628 td->o.size = 0;
1629 td->o.size_percent = -1ULL - v;
1630 dprint(FD_PARSE, "SET size_percent %d\n",
1631 td->o.size_percent);
1632 } else if (parse_is_zone(v)) {
1633 td->o.size = 0;
1634 td->o.size_percent = 0;
1635 td->o.size_nz = v - ZONE_BASE_VAL;
1636 } else
1637 td->o.size = v;
1638
1639 return 0;
1640}
1641
1642static int str_io_size_cb(void *data, unsigned long long *__val)
1643{
1644 struct thread_data *td = cb_data_to_td(data);
1645 unsigned long long v = *__val;
1646
1647 if (parse_is_percent_uncapped(v)) {
1648 td->o.io_size = 0;
1649 td->o.io_size_percent = -1ULL - v;
1650 if (td->o.io_size_percent > 100) {
1651 log_err("fio: io_size values greater than 100%% aren't supported\n");
1652 return 1;
1653 }
1654 dprint(FD_PARSE, "SET io_size_percent %d\n",
1655 td->o.io_size_percent);
1656 } else if (parse_is_zone(v)) {
1657 td->o.io_size = 0;
1658 td->o.io_size_percent = 0;
1659 td->o.io_size_nz = v - ZONE_BASE_VAL;
1660 } else
1661 td->o.io_size = v;
1662
1663 return 0;
1664}
1665
1666static int str_zoneskip_cb(void *data, unsigned long long *__val)
1667{
1668 struct thread_data *td = cb_data_to_td(data);
1669 unsigned long long v = *__val;
1670
1671 if (parse_is_zone(v)) {
1672 td->o.zone_skip = 0;
1673 td->o.zone_skip_nz = v - ZONE_BASE_VAL;
1674 } else
1675 td->o.zone_skip = v;
1676
1677 return 0;
1678}
1679
1680static int str_write_bw_log_cb(void *data, const char *str)
1681{
1682 struct thread_data *td = cb_data_to_td(data);
1683
1684 if (str)
1685 td->o.bw_log_file = strdup(str);
1686
1687 td->o.write_bw_log = 1;
1688 return 0;
1689}
1690
1691static int str_write_lat_log_cb(void *data, const char *str)
1692{
1693 struct thread_data *td = cb_data_to_td(data);
1694
1695 if (str)
1696 td->o.lat_log_file = strdup(str);
1697
1698 td->o.write_lat_log = 1;
1699 return 0;
1700}
1701
1702static int str_write_iops_log_cb(void *data, const char *str)
1703{
1704 struct thread_data *td = cb_data_to_td(data);
1705
1706 if (str)
1707 td->o.iops_log_file = strdup(str);
1708
1709 td->o.write_iops_log = 1;
1710 return 0;
1711}
1712
1713static int str_write_hist_log_cb(void *data, const char *str)
1714{
1715 struct thread_data *td = cb_data_to_td(data);
1716
1717 if (str)
1718 td->o.hist_log_file = strdup(str);
1719
1720 td->o.write_hist_log = 1;
1721 return 0;
1722}
1723
1724/*
1725 * str is supposed to be a substring of the strdup'd original string,
1726 * and is valid only if it's a regular file path.
1727 * This function keeps the pointer to the path as needed later.
1728 *
1729 * "external:/path/to/so\0" <- original pointer updated with strdup'd
1730 * "external\0" <- above pointer after parsed, i.e. ->ioengine
1731 * "/path/to/so\0" <- str argument, i.e. ->ioengine_so_path
1732 */
1733static int str_ioengine_external_cb(void *data, const char *str)
1734{
1735 struct thread_data *td = cb_data_to_td(data);
1736 struct stat sb;
1737 char *p;
1738
1739 if (!str) {
1740 log_err("fio: null external ioengine path\n");
1741 return 1;
1742 }
1743
1744 p = (char *)str; /* str is mutable */
1745 strip_blank_front(&p);
1746 strip_blank_end(p);
1747
1748 if (stat(p, &sb) || !S_ISREG(sb.st_mode)) {
1749 log_err("fio: invalid external ioengine path \"%s\"\n", p);
1750 return 1;
1751 }
1752
1753 td->o.ioengine_so_path = p;
1754 return 0;
1755}
1756
1757static int rw_verify(const struct fio_option *o, void *data)
1758{
1759 struct thread_data *td = cb_data_to_td(data);
1760
1761 if (read_only && (td_write(td) || td_trim(td))) {
1762 log_err("fio: job <%s> has write or trim bit set, but"
1763 " fio is in read-only mode\n", td->o.name);
1764 return 1;
1765 }
1766
1767 return 0;
1768}
1769
1770static int gtod_cpu_verify(const struct fio_option *o, void *data)
1771{
1772#ifndef FIO_HAVE_CPU_AFFINITY
1773 struct thread_data *td = cb_data_to_td(data);
1774
1775 if (td->o.gtod_cpu) {
1776 log_err("fio: platform must support CPU affinity for"
1777 "gettimeofday() offloading\n");
1778 return 1;
1779 }
1780#endif
1781
1782 return 0;
1783}
1784
1785/*
1786 * Map of job/command line options
1787 */
1788struct fio_option fio_options[FIO_MAX_OPTS] = {
1789 {
1790 .name = "description",
1791 .lname = "Description of job",
1792 .type = FIO_OPT_STR_STORE,
1793 .off1 = offsetof(struct thread_options, description),
1794 .help = "Text job description",
1795 .category = FIO_OPT_C_GENERAL,
1796 .group = FIO_OPT_G_DESC,
1797 },
1798 {
1799 .name = "name",
1800 .lname = "Job name",
1801 .type = FIO_OPT_STR_STORE,
1802 .off1 = offsetof(struct thread_options, name),
1803 .help = "Name of this job",
1804 .category = FIO_OPT_C_GENERAL,
1805 .group = FIO_OPT_G_DESC,
1806 },
1807 {
1808 .name = "wait_for",
1809 .lname = "Waitee name",
1810 .type = FIO_OPT_STR_STORE,
1811 .off1 = offsetof(struct thread_options, wait_for),
1812 .help = "Name of the job this one wants to wait for before starting",
1813 .category = FIO_OPT_C_GENERAL,
1814 .group = FIO_OPT_G_DESC,
1815 },
1816 {
1817 .name = "filename",
1818 .lname = "Filename(s)",
1819 .type = FIO_OPT_STR_STORE,
1820 .off1 = offsetof(struct thread_options, filename),
1821 .maxlen = PATH_MAX,
1822 .cb = str_filename_cb,
1823 .prio = -1, /* must come after "directory" */
1824 .help = "File(s) to use for the workload",
1825 .category = FIO_OPT_C_FILE,
1826 .group = FIO_OPT_G_FILENAME,
1827 },
1828 {
1829 .name = "directory",
1830 .lname = "Directory",
1831 .type = FIO_OPT_STR_STORE,
1832 .off1 = offsetof(struct thread_options, directory),
1833 .cb = str_directory_cb,
1834 .help = "Directory to store files in",
1835 .category = FIO_OPT_C_FILE,
1836 .group = FIO_OPT_G_FILENAME,
1837 },
1838 {
1839 .name = "filename_format",
1840 .lname = "Filename Format",
1841 .type = FIO_OPT_STR_STORE,
1842 .off1 = offsetof(struct thread_options, filename_format),
1843 .prio = -1, /* must come after "directory" */
1844 .help = "Override default $jobname.$jobnum.$filenum naming",
1845 .def = "$jobname.$jobnum.$filenum",
1846 .category = FIO_OPT_C_FILE,
1847 .group = FIO_OPT_G_FILENAME,
1848 },
1849 {
1850 .name = "unique_filename",
1851 .lname = "Unique Filename",
1852 .type = FIO_OPT_BOOL,
1853 .off1 = offsetof(struct thread_options, unique_filename),
1854 .help = "For network clients, prefix file with source IP",
1855 .def = "1",
1856 .category = FIO_OPT_C_FILE,
1857 .group = FIO_OPT_G_FILENAME,
1858 },
1859 {
1860 .name = "lockfile",
1861 .lname = "Lockfile",
1862 .type = FIO_OPT_STR,
1863 .off1 = offsetof(struct thread_options, file_lock_mode),
1864 .help = "Lock file when doing IO to it",
1865 .prio = 1,
1866 .parent = "filename",
1867 .hide = 0,
1868 .def = "none",
1869 .category = FIO_OPT_C_FILE,
1870 .group = FIO_OPT_G_FILENAME,
1871 .posval = {
1872 { .ival = "none",
1873 .oval = FILE_LOCK_NONE,
1874 .help = "No file locking",
1875 },
1876 { .ival = "exclusive",
1877 .oval = FILE_LOCK_EXCLUSIVE,
1878 .help = "Exclusive file lock",
1879 },
1880 {
1881 .ival = "readwrite",
1882 .oval = FILE_LOCK_READWRITE,
1883 .help = "Read vs write lock",
1884 },
1885 },
1886 },
1887 {
1888 .name = "opendir",
1889 .lname = "Open directory",
1890 .type = FIO_OPT_STR_STORE,
1891 .off1 = offsetof(struct thread_options, opendir),
1892 .cb = str_opendir_cb,
1893 .help = "Recursively add files from this directory and down",
1894 .category = FIO_OPT_C_FILE,
1895 .group = FIO_OPT_G_FILENAME,
1896 },
1897 {
1898 .name = "rw",
1899 .lname = "Read/write",
1900 .alias = "readwrite",
1901 .type = FIO_OPT_STR,
1902 .cb = str_rw_cb,
1903 .off1 = offsetof(struct thread_options, td_ddir),
1904 .help = "IO direction",
1905 .def = "read",
1906 .verify = rw_verify,
1907 .category = FIO_OPT_C_IO,
1908 .group = FIO_OPT_G_IO_BASIC,
1909 .posval = {
1910 { .ival = "read",
1911 .oval = TD_DDIR_READ,
1912 .help = "Sequential read",
1913 },
1914 { .ival = "write",
1915 .oval = TD_DDIR_WRITE,
1916 .help = "Sequential write",
1917 },
1918 { .ival = "trim",
1919 .oval = TD_DDIR_TRIM,
1920 .help = "Sequential trim",
1921 },
1922 { .ival = "randread",
1923 .oval = TD_DDIR_RANDREAD,
1924 .help = "Random read",
1925 },
1926 { .ival = "randwrite",
1927 .oval = TD_DDIR_RANDWRITE,
1928 .help = "Random write",
1929 },
1930 { .ival = "randtrim",
1931 .oval = TD_DDIR_RANDTRIM,
1932 .help = "Random trim",
1933 },
1934 { .ival = "rw",
1935 .oval = TD_DDIR_RW,
1936 .help = "Sequential read and write mix",
1937 },
1938 { .ival = "readwrite",
1939 .oval = TD_DDIR_RW,
1940 .help = "Sequential read and write mix",
1941 },
1942 { .ival = "randrw",
1943 .oval = TD_DDIR_RANDRW,
1944 .help = "Random read and write mix"
1945 },
1946 { .ival = "trimwrite",
1947 .oval = TD_DDIR_TRIMWRITE,
1948 .help = "Trim and write mix, trims preceding writes"
1949 },
1950 },
1951 },
1952 {
1953 .name = "rw_sequencer",
1954 .lname = "RW Sequencer",
1955 .type = FIO_OPT_STR,
1956 .off1 = offsetof(struct thread_options, rw_seq),
1957 .help = "IO offset generator modifier",
1958 .def = "sequential",
1959 .category = FIO_OPT_C_IO,
1960 .group = FIO_OPT_G_IO_BASIC,
1961 .posval = {
1962 { .ival = "sequential",
1963 .oval = RW_SEQ_SEQ,
1964 .help = "Generate sequential offsets",
1965 },
1966 { .ival = "identical",
1967 .oval = RW_SEQ_IDENT,
1968 .help = "Generate identical offsets",
1969 },
1970 },
1971 },
1972
1973 {
1974 .name = "ioengine",
1975 .lname = "IO Engine",
1976 .type = FIO_OPT_STR_STORE,
1977 .off1 = offsetof(struct thread_options, ioengine),
1978 .help = "IO engine to use",
1979 .def = FIO_PREFERRED_ENGINE,
1980 .category = FIO_OPT_C_IO,
1981 .group = FIO_OPT_G_IO_BASIC,
1982 .posval = {
1983 { .ival = "sync",
1984 .help = "Use read/write",
1985 },
1986 { .ival = "psync",
1987 .help = "Use pread/pwrite",
1988 },
1989 { .ival = "vsync",
1990 .help = "Use readv/writev",
1991 },
1992#ifdef CONFIG_PWRITEV
1993 { .ival = "pvsync",
1994 .help = "Use preadv/pwritev",
1995 },
1996#endif
1997#ifdef FIO_HAVE_PWRITEV2
1998 { .ival = "pvsync2",
1999 .help = "Use preadv2/pwritev2",
2000 },
2001#endif
2002#ifdef CONFIG_LIBAIO
2003 { .ival = "libaio",
2004 .help = "Linux native asynchronous IO",
2005 },
2006#endif
2007#ifdef ARCH_HAVE_IOURING
2008 { .ival = "io_uring",
2009 .help = "Fast Linux native aio",
2010 },
2011#endif
2012#ifdef CONFIG_POSIXAIO
2013 { .ival = "posixaio",
2014 .help = "POSIX asynchronous IO",
2015 },
2016#endif
2017#ifdef CONFIG_SOLARISAIO
2018 { .ival = "solarisaio",
2019 .help = "Solaris native asynchronous IO",
2020 },
2021#endif
2022#ifdef CONFIG_WINDOWSAIO
2023 { .ival = "windowsaio",
2024 .help = "Windows native asynchronous IO"
2025 },
2026#endif
2027#ifdef CONFIG_RBD
2028 { .ival = "rbd",
2029 .help = "Rados Block Device asynchronous IO"
2030 },
2031#endif
2032 { .ival = "mmap",
2033 .help = "Memory mapped IO"
2034 },
2035#ifdef CONFIG_LINUX_SPLICE
2036 { .ival = "splice",
2037 .help = "splice/vmsplice based IO",
2038 },
2039 { .ival = "netsplice",
2040 .help = "splice/vmsplice to/from the network",
2041 },
2042#endif
2043#ifdef FIO_HAVE_SGIO
2044 { .ival = "sg",
2045 .help = "SCSI generic v3 IO",
2046 },
2047#endif
2048 { .ival = "null",
2049 .help = "Testing engine (no data transfer)",
2050 },
2051 { .ival = "net",
2052 .help = "Network IO",
2053 },
2054 { .ival = "cpuio",
2055 .help = "CPU cycle burner engine",
2056 },
2057#ifdef CONFIG_RDMA
2058 { .ival = "rdma",
2059 .help = "RDMA IO engine",
2060 },
2061#endif
2062#ifdef CONFIG_LIBRPMA_APM
2063 { .ival = "librpma_apm",
2064 .help = "librpma IO engine in APM mode",
2065 },
2066#endif
2067#ifdef CONFIG_LIBRPMA_GPSPM
2068 { .ival = "librpma_gpspm",
2069 .help = "librpma IO engine in GPSPM mode",
2070 },
2071#endif
2072#ifdef CONFIG_LINUX_EXT4_MOVE_EXTENT
2073 { .ival = "e4defrag",
2074 .help = "ext4 defrag engine",
2075 },
2076#endif
2077#ifdef CONFIG_LINUX_FALLOCATE
2078 { .ival = "falloc",
2079 .help = "fallocate() file based engine",
2080 },
2081#endif
2082#ifdef CONFIG_GFAPI
2083 { .ival = "gfapi",
2084 .help = "Glusterfs libgfapi(sync) based engine"
2085 },
2086 { .ival = "gfapi_async",
2087 .help = "Glusterfs libgfapi(async) based engine"
2088 },
2089#endif
2090#ifdef CONFIG_LIBHDFS
2091 { .ival = "libhdfs",
2092 .help = "Hadoop Distributed Filesystem (HDFS) engine"
2093 },
2094#endif
2095#ifdef CONFIG_PMEMBLK
2096 { .ival = "pmemblk",
2097 .help = "PMDK libpmemblk based IO engine",
2098 },
2099
2100#endif
2101#ifdef CONFIG_IME
2102 { .ival = "ime_psync",
2103 .help = "DDN's IME synchronous IO engine",
2104 },
2105 { .ival = "ime_psyncv",
2106 .help = "DDN's IME synchronous IO engine using iovecs",
2107 },
2108 { .ival = "ime_aio",
2109 .help = "DDN's IME asynchronous IO engine",
2110 },
2111#endif
2112#ifdef CONFIG_LINUX_DEVDAX
2113 { .ival = "dev-dax",
2114 .help = "DAX Device based IO engine",
2115 },
2116#endif
2117 {
2118 .ival = "filecreate",
2119 .help = "File creation engine",
2120 },
2121 { .ival = "external",
2122 .help = "Load external engine (append name)",
2123 .cb = str_ioengine_external_cb,
2124 },
2125#ifdef CONFIG_LIBPMEM
2126 { .ival = "libpmem",
2127 .help = "PMDK libpmem based IO engine",
2128 },
2129#endif
2130#ifdef CONFIG_HTTP
2131 { .ival = "http",
2132 .help = "HTTP (WebDAV/S3) IO engine",
2133 },
2134#endif
2135 { .ival = "nbd",
2136 .help = "Network Block Device (NBD) IO engine"
2137 },
2138#ifdef CONFIG_DFS
2139 { .ival = "dfs",
2140 .help = "DAOS File System (dfs) IO engine",
2141 },
2142#endif
2143#ifdef CONFIG_LIBNFS
2144 { .ival = "nfs",
2145 .help = "NFS IO engine",
2146 },
2147#endif
2148#ifdef CONFIG_LIBXNVME
2149 { .ival = "xnvme",
2150 .help = "XNVME IO engine",
2151 },
2152#endif
2153 },
2154 },
2155 {
2156 .name = "iodepth",
2157 .lname = "IO Depth",
2158 .type = FIO_OPT_INT,
2159 .off1 = offsetof(struct thread_options, iodepth),
2160 .help = "Number of IO buffers to keep in flight",
2161 .minval = 1,
2162 .interval = 1,
2163 .def = "1",
2164 .category = FIO_OPT_C_IO,
2165 .group = FIO_OPT_G_IO_BASIC,
2166 },
2167 {
2168 .name = "iodepth_batch",
2169 .lname = "IO Depth batch",
2170 .alias = "iodepth_batch_submit",
2171 .type = FIO_OPT_INT,
2172 .off1 = offsetof(struct thread_options, iodepth_batch),
2173 .help = "Number of IO buffers to submit in one go",
2174 .parent = "iodepth",
2175 .hide = 1,
2176 .interval = 1,
2177 .def = "1",
2178 .category = FIO_OPT_C_IO,
2179 .group = FIO_OPT_G_IO_BASIC,
2180 },
2181 {
2182 .name = "iodepth_batch_complete_min",
2183 .lname = "Min IO depth batch complete",
2184 .alias = "iodepth_batch_complete",
2185 .type = FIO_OPT_INT,
2186 .off1 = offsetof(struct thread_options, iodepth_batch_complete_min),
2187 .help = "Min number of IO buffers to retrieve in one go",
2188 .parent = "iodepth",
2189 .hide = 1,
2190 .minval = 0,
2191 .interval = 1,
2192 .def = "1",
2193 .category = FIO_OPT_C_IO,
2194 .group = FIO_OPT_G_IO_BASIC,
2195 },
2196 {
2197 .name = "iodepth_batch_complete_max",
2198 .lname = "Max IO depth batch complete",
2199 .type = FIO_OPT_INT,
2200 .off1 = offsetof(struct thread_options, iodepth_batch_complete_max),
2201 .help = "Max number of IO buffers to retrieve in one go",
2202 .parent = "iodepth",
2203 .hide = 1,
2204 .minval = 0,
2205 .interval = 1,
2206 .category = FIO_OPT_C_IO,
2207 .group = FIO_OPT_G_IO_BASIC,
2208 },
2209 {
2210 .name = "iodepth_low",
2211 .lname = "IO Depth batch low",
2212 .type = FIO_OPT_INT,
2213 .off1 = offsetof(struct thread_options, iodepth_low),
2214 .help = "Low water mark for queuing depth",
2215 .parent = "iodepth",
2216 .hide = 1,
2217 .interval = 1,
2218 .category = FIO_OPT_C_IO,
2219 .group = FIO_OPT_G_IO_BASIC,
2220 },
2221 {
2222 .name = "serialize_overlap",
2223 .lname = "Serialize overlap",
2224 .off1 = offsetof(struct thread_options, serialize_overlap),
2225 .type = FIO_OPT_BOOL,
2226 .help = "Wait for in-flight IOs that collide to complete",
2227 .parent = "iodepth",
2228 .def = "0",
2229 .category = FIO_OPT_C_IO,
2230 .group = FIO_OPT_G_IO_BASIC,
2231 },
2232 {
2233 .name = "io_submit_mode",
2234 .lname = "IO submit mode",
2235 .type = FIO_OPT_STR,
2236 .off1 = offsetof(struct thread_options, io_submit_mode),
2237 .help = "How IO submissions and completions are done",
2238 .def = "inline",
2239 .category = FIO_OPT_C_IO,
2240 .group = FIO_OPT_G_IO_BASIC,
2241 .posval = {
2242 { .ival = "inline",
2243 .oval = IO_MODE_INLINE,
2244 .help = "Submit and complete IO inline",
2245 },
2246 { .ival = "offload",
2247 .oval = IO_MODE_OFFLOAD,
2248 .help = "Offload submit and complete to threads",
2249 },
2250 },
2251 },
2252 {
2253 .name = "size",
2254 .lname = "Size",
2255 .type = FIO_OPT_STR_VAL_ZONE,
2256 .cb = str_size_cb,
2257 .off1 = offsetof(struct thread_options, size),
2258 .help = "Total size of device or files",
2259 .category = FIO_OPT_C_IO,
2260 .group = FIO_OPT_G_INVALID,
2261 },
2262 {
2263 .name = "io_size",
2264 .alias = "io_limit",
2265 .lname = "IO Size",
2266 .type = FIO_OPT_STR_VAL_ZONE,
2267 .cb = str_io_size_cb,
2268 .off1 = offsetof(struct thread_options, io_size),
2269 .help = "Total size of I/O to be performed",
2270 .category = FIO_OPT_C_IO,
2271 .group = FIO_OPT_G_INVALID,
2272 },
2273 {
2274 .name = "fill_device",
2275 .lname = "Fill device",
2276 .alias = "fill_fs",
2277 .type = FIO_OPT_BOOL,
2278 .off1 = offsetof(struct thread_options, fill_device),
2279 .help = "Write until an ENOSPC error occurs",
2280 .def = "0",
2281 .category = FIO_OPT_C_FILE,
2282 .group = FIO_OPT_G_INVALID,
2283 },
2284 {
2285 .name = "filesize",
2286 .lname = "File size",
2287 .type = FIO_OPT_STR_VAL,
2288 .off1 = offsetof(struct thread_options, file_size_low),
2289 .off2 = offsetof(struct thread_options, file_size_high),
2290 .minval = 1,
2291 .help = "Size of individual files",
2292 .interval = 1024 * 1024,
2293 .category = FIO_OPT_C_FILE,
2294 .group = FIO_OPT_G_INVALID,
2295 },
2296 {
2297 .name = "file_append",
2298 .lname = "File append",
2299 .type = FIO_OPT_BOOL,
2300 .off1 = offsetof(struct thread_options, file_append),
2301 .help = "IO will start at the end of the file(s)",
2302 .def = "0",
2303 .category = FIO_OPT_C_FILE,
2304 .group = FIO_OPT_G_INVALID,
2305 },
2306 {
2307 .name = "offset",
2308 .lname = "IO offset",
2309 .alias = "fileoffset",
2310 .type = FIO_OPT_STR_VAL_ZONE,
2311 .cb = str_offset_cb,
2312 .off1 = offsetof(struct thread_options, start_offset),
2313 .help = "Start IO from this offset",
2314 .def = "0",
2315 .category = FIO_OPT_C_IO,
2316 .group = FIO_OPT_G_INVALID,
2317 },
2318 {
2319 .name = "offset_align",
2320 .lname = "IO offset alignment",
2321 .type = FIO_OPT_INT,
2322 .off1 = offsetof(struct thread_options, start_offset_align),
2323 .help = "Start IO from this offset alignment",
2324 .def = "0",
2325 .interval = 512,
2326 .category = FIO_OPT_C_IO,
2327 .group = FIO_OPT_G_INVALID,
2328 },
2329 {
2330 .name = "offset_increment",
2331 .lname = "IO offset increment",
2332 .type = FIO_OPT_STR_VAL_ZONE,
2333 .cb = str_offset_increment_cb,
2334 .off1 = offsetof(struct thread_options, offset_increment),
2335 .help = "What is the increment from one offset to the next",
2336 .parent = "offset",
2337 .hide = 1,
2338 .def = "0",
2339 .category = FIO_OPT_C_IO,
2340 .group = FIO_OPT_G_INVALID,
2341 },
2342 {
2343 .name = "number_ios",
2344 .lname = "Number of IOs to perform",
2345 .type = FIO_OPT_STR_VAL,
2346 .off1 = offsetof(struct thread_options, number_ios),
2347 .help = "Force job completion after this number of IOs",
2348 .def = "0",
2349 .category = FIO_OPT_C_IO,
2350 .group = FIO_OPT_G_INVALID,
2351 },
2352 {
2353 .name = "bs",
2354 .lname = "Block size",
2355 .alias = "blocksize",
2356 .type = FIO_OPT_ULL,
2357 .off1 = offsetof(struct thread_options, bs[DDIR_READ]),
2358 .off2 = offsetof(struct thread_options, bs[DDIR_WRITE]),
2359 .off3 = offsetof(struct thread_options, bs[DDIR_TRIM]),
2360 .minval = 1,
2361 .help = "Block size unit",
2362 .def = "4096",
2363 .parent = "rw",
2364 .hide = 1,
2365 .interval = 512,
2366 .category = FIO_OPT_C_IO,
2367 .group = FIO_OPT_G_INVALID,
2368 },
2369 {
2370 .name = "ba",
2371 .lname = "Block size align",
2372 .alias = "blockalign",
2373 .type = FIO_OPT_ULL,
2374 .off1 = offsetof(struct thread_options, ba[DDIR_READ]),
2375 .off2 = offsetof(struct thread_options, ba[DDIR_WRITE]),
2376 .off3 = offsetof(struct thread_options, ba[DDIR_TRIM]),
2377 .minval = 1,
2378 .help = "IO block offset alignment",
2379 .parent = "rw",
2380 .hide = 1,
2381 .interval = 512,
2382 .category = FIO_OPT_C_IO,
2383 .group = FIO_OPT_G_INVALID,
2384 },
2385 {
2386 .name = "bsrange",
2387 .lname = "Block size range",
2388 .alias = "blocksize_range",
2389 .type = FIO_OPT_RANGE,
2390 .off1 = offsetof(struct thread_options, min_bs[DDIR_READ]),
2391 .off2 = offsetof(struct thread_options, max_bs[DDIR_READ]),
2392 .off3 = offsetof(struct thread_options, min_bs[DDIR_WRITE]),
2393 .off4 = offsetof(struct thread_options, max_bs[DDIR_WRITE]),
2394 .off5 = offsetof(struct thread_options, min_bs[DDIR_TRIM]),
2395 .off6 = offsetof(struct thread_options, max_bs[DDIR_TRIM]),
2396 .minval = 1,
2397 .help = "Set block size range (in more detail than bs)",
2398 .parent = "rw",
2399 .hide = 1,
2400 .interval = 4096,
2401 .category = FIO_OPT_C_IO,
2402 .group = FIO_OPT_G_INVALID,
2403 },
2404 {
2405 .name = "bssplit",
2406 .lname = "Block size split",
2407 .type = FIO_OPT_STR_ULL,
2408 .cb = str_bssplit_cb,
2409 .off1 = offsetof(struct thread_options, bssplit),
2410 .help = "Set a specific mix of block sizes",
2411 .parent = "rw",
2412 .hide = 1,
2413 .category = FIO_OPT_C_IO,
2414 .group = FIO_OPT_G_INVALID,
2415 },
2416 {
2417 .name = "bs_unaligned",
2418 .lname = "Block size unaligned",
2419 .alias = "blocksize_unaligned",
2420 .type = FIO_OPT_STR_SET,
2421 .off1 = offsetof(struct thread_options, bs_unaligned),
2422 .help = "Don't sector align IO buffer sizes",
2423 .parent = "rw",
2424 .hide = 1,
2425 .category = FIO_OPT_C_IO,
2426 .group = FIO_OPT_G_INVALID,
2427 },
2428 {
2429 .name = "bs_is_seq_rand",
2430 .lname = "Block size division is seq/random (not read/write)",
2431 .type = FIO_OPT_BOOL,
2432 .off1 = offsetof(struct thread_options, bs_is_seq_rand),
2433 .help = "Consider any blocksize setting to be sequential,random",
2434 .def = "0",
2435 .parent = "blocksize",
2436 .category = FIO_OPT_C_IO,
2437 .group = FIO_OPT_G_INVALID,
2438 },
2439 {
2440 .name = "randrepeat",
2441 .lname = "Random repeatable",
2442 .type = FIO_OPT_BOOL,
2443 .off1 = offsetof(struct thread_options, rand_repeatable),
2444 .help = "Use repeatable random IO pattern",
2445 .def = "1",
2446 .parent = "rw",
2447 .hide = 1,
2448 .category = FIO_OPT_C_IO,
2449 .group = FIO_OPT_G_RANDOM,
2450 },
2451 {
2452 .name = "randseed",
2453 .lname = "The random generator seed",
2454 .type = FIO_OPT_STR_VAL,
2455 .off1 = offsetof(struct thread_options, rand_seed),
2456 .help = "Set the random generator seed value",
2457 .def = "0x89",
2458 .parent = "rw",
2459 .category = FIO_OPT_C_IO,
2460 .group = FIO_OPT_G_RANDOM,
2461 },
2462 {
2463 .name = "norandommap",
2464 .lname = "No randommap",
2465 .type = FIO_OPT_STR_SET,
2466 .off1 = offsetof(struct thread_options, norandommap),
2467 .help = "Accept potential duplicate random blocks",
2468 .parent = "rw",
2469 .hide = 1,
2470 .hide_on_set = 1,
2471 .category = FIO_OPT_C_IO,
2472 .group = FIO_OPT_G_RANDOM,
2473 },
2474 {
2475 .name = "softrandommap",
2476 .lname = "Soft randommap",
2477 .type = FIO_OPT_BOOL,
2478 .off1 = offsetof(struct thread_options, softrandommap),
2479 .help = "Set norandommap if randommap allocation fails",
2480 .parent = "norandommap",
2481 .hide = 1,
2482 .def = "0",
2483 .category = FIO_OPT_C_IO,
2484 .group = FIO_OPT_G_RANDOM,
2485 },
2486 {
2487 .name = "random_generator",
2488 .lname = "Random Generator",
2489 .type = FIO_OPT_STR,
2490 .off1 = offsetof(struct thread_options, random_generator),
2491 .help = "Type of random number generator to use",
2492 .def = "tausworthe",
2493 .posval = {
2494 { .ival = "tausworthe",
2495 .oval = FIO_RAND_GEN_TAUSWORTHE,
2496 .help = "Strong Tausworthe generator",
2497 },
2498 { .ival = "lfsr",
2499 .oval = FIO_RAND_GEN_LFSR,
2500 .help = "Variable length LFSR",
2501 },
2502 {
2503 .ival = "tausworthe64",
2504 .oval = FIO_RAND_GEN_TAUSWORTHE64,
2505 .help = "64-bit Tausworthe variant",
2506 },
2507 },
2508 .category = FIO_OPT_C_IO,
2509 .group = FIO_OPT_G_RANDOM,
2510 },
2511 {
2512 .name = "random_distribution",
2513 .lname = "Random Distribution",
2514 .type = FIO_OPT_STR,
2515 .off1 = offsetof(struct thread_options, random_distribution),
2516 .cb = str_random_distribution_cb,
2517 .help = "Random offset distribution generator",
2518 .def = "random",
2519 .posval = {
2520 { .ival = "random",
2521 .oval = FIO_RAND_DIST_RANDOM,
2522 .help = "Completely random",
2523 },
2524 { .ival = "zipf",
2525 .oval = FIO_RAND_DIST_ZIPF,
2526 .help = "Zipf distribution",
2527 },
2528 { .ival = "pareto",
2529 .oval = FIO_RAND_DIST_PARETO,
2530 .help = "Pareto distribution",
2531 },
2532 { .ival = "normal",
2533 .oval = FIO_RAND_DIST_GAUSS,
2534 .help = "Normal (Gaussian) distribution",
2535 },
2536 { .ival = "zoned",
2537 .oval = FIO_RAND_DIST_ZONED,
2538 .help = "Zoned random distribution",
2539 },
2540 { .ival = "zoned_abs",
2541 .oval = FIO_RAND_DIST_ZONED_ABS,
2542 .help = "Zoned absolute random distribution",
2543 },
2544 },
2545 .category = FIO_OPT_C_IO,
2546 .group = FIO_OPT_G_RANDOM,
2547 },
2548 {
2549 .name = "percentage_random",
2550 .lname = "Percentage Random",
2551 .type = FIO_OPT_INT,
2552 .off1 = offsetof(struct thread_options, perc_rand[DDIR_READ]),
2553 .off2 = offsetof(struct thread_options, perc_rand[DDIR_WRITE]),
2554 .off3 = offsetof(struct thread_options, perc_rand[DDIR_TRIM]),
2555 .maxval = 100,
2556 .help = "Percentage of seq/random mix that should be random",
2557 .def = "100,100,100",
2558 .interval = 5,
2559 .inverse = "percentage_sequential",
2560 .category = FIO_OPT_C_IO,
2561 .group = FIO_OPT_G_RANDOM,
2562 },
2563 {
2564 .name = "percentage_sequential",
2565 .lname = "Percentage Sequential",
2566 .type = FIO_OPT_DEPRECATED,
2567 .category = FIO_OPT_C_IO,
2568 .group = FIO_OPT_G_RANDOM,
2569 },
2570 {
2571 .name = "allrandrepeat",
2572 .lname = "All Random Repeat",
2573 .type = FIO_OPT_BOOL,
2574 .off1 = offsetof(struct thread_options, allrand_repeatable),
2575 .help = "Use repeatable random numbers for everything",
2576 .def = "0",
2577 .category = FIO_OPT_C_IO,
2578 .group = FIO_OPT_G_RANDOM,
2579 },
2580 {
2581 .name = "nrfiles",
2582 .lname = "Number of files",
2583 .alias = "nr_files",
2584 .type = FIO_OPT_INT,
2585 .off1 = offsetof(struct thread_options, nr_files),
2586 .help = "Split job workload between this number of files",
2587 .def = "1",
2588 .interval = 1,
2589 .category = FIO_OPT_C_FILE,
2590 .group = FIO_OPT_G_INVALID,
2591 },
2592 {
2593 .name = "openfiles",
2594 .lname = "Number of open files",
2595 .type = FIO_OPT_INT,
2596 .off1 = offsetof(struct thread_options, open_files),
2597 .help = "Number of files to keep open at the same time",
2598 .category = FIO_OPT_C_FILE,
2599 .group = FIO_OPT_G_INVALID,
2600 },
2601 {
2602 .name = "file_service_type",
2603 .lname = "File service type",
2604 .type = FIO_OPT_STR,
2605 .cb = str_fst_cb,
2606 .off1 = offsetof(struct thread_options, file_service_type),
2607 .help = "How to select which file to service next",
2608 .def = "roundrobin",
2609 .category = FIO_OPT_C_FILE,
2610 .group = FIO_OPT_G_INVALID,
2611 .posval = {
2612 { .ival = "random",
2613 .oval = FIO_FSERVICE_RANDOM,
2614 .help = "Choose a file at random (uniform)",
2615 },
2616 { .ival = "zipf",
2617 .oval = FIO_FSERVICE_ZIPF,
2618 .help = "Zipf randomized",
2619 },
2620 { .ival = "pareto",
2621 .oval = FIO_FSERVICE_PARETO,
2622 .help = "Pareto randomized",
2623 },
2624 { .ival = "normal",
2625 .oval = FIO_FSERVICE_GAUSS,
2626 .help = "Normal (Gaussian) randomized",
2627 },
2628 { .ival = "gauss",
2629 .oval = FIO_FSERVICE_GAUSS,
2630 .help = "Alias for normal",
2631 },
2632 { .ival = "roundrobin",
2633 .oval = FIO_FSERVICE_RR,
2634 .help = "Round robin select files",
2635 },
2636 { .ival = "sequential",
2637 .oval = FIO_FSERVICE_SEQ,
2638 .help = "Finish one file before moving to the next",
2639 },
2640 },
2641 .parent = "nrfiles",
2642 .hide = 1,
2643 },
2644 {
2645 .name = "fallocate",
2646 .lname = "Fallocate",
2647 .type = FIO_OPT_STR,
2648 .off1 = offsetof(struct thread_options, fallocate_mode),
2649 .help = "Whether pre-allocation is performed when laying out files",
2650#ifdef FIO_HAVE_DEFAULT_FALLOCATE
2651 .def = "native",
2652#else
2653 .def = "none",
2654#endif
2655 .category = FIO_OPT_C_FILE,
2656 .group = FIO_OPT_G_INVALID,
2657 .posval = {
2658 { .ival = "none",
2659 .oval = FIO_FALLOCATE_NONE,
2660 .help = "Do not pre-allocate space",
2661 },
2662 { .ival = "native",
2663 .oval = FIO_FALLOCATE_NATIVE,
2664 .help = "Use native pre-allocation if possible",
2665 },
2666#ifdef CONFIG_POSIX_FALLOCATE
2667 { .ival = "posix",
2668 .oval = FIO_FALLOCATE_POSIX,
2669 .help = "Use posix_fallocate()",
2670 },
2671#endif
2672#ifdef CONFIG_LINUX_FALLOCATE
2673 { .ival = "keep",
2674 .oval = FIO_FALLOCATE_KEEP_SIZE,
2675 .help = "Use fallocate(..., FALLOC_FL_KEEP_SIZE, ...)",
2676 },
2677#endif
2678 { .ival = "truncate",
2679 .oval = FIO_FALLOCATE_TRUNCATE,
2680 .help = "Truncate file to final size instead of allocating"
2681 },
2682 /* Compatibility with former boolean values */
2683 { .ival = "0",
2684 .oval = FIO_FALLOCATE_NONE,
2685 .help = "Alias for 'none'",
2686 },
2687#ifdef CONFIG_POSIX_FALLOCATE
2688 { .ival = "1",
2689 .oval = FIO_FALLOCATE_POSIX,
2690 .help = "Alias for 'posix'",
2691 },
2692#endif
2693 },
2694 },
2695 {
2696 .name = "fadvise_hint",
2697 .lname = "Fadvise hint",
2698 .type = FIO_OPT_STR,
2699 .off1 = offsetof(struct thread_options, fadvise_hint),
2700 .posval = {
2701 { .ival = "0",
2702 .oval = F_ADV_NONE,
2703 .help = "Don't issue fadvise/madvise",
2704 },
2705 { .ival = "1",
2706 .oval = F_ADV_TYPE,
2707 .help = "Advise using fio IO pattern",
2708 },
2709 { .ival = "random",
2710 .oval = F_ADV_RANDOM,
2711 .help = "Advise using FADV_RANDOM",
2712 },
2713 { .ival = "sequential",
2714 .oval = F_ADV_SEQUENTIAL,
2715 .help = "Advise using FADV_SEQUENTIAL",
2716 },
2717 },
2718 .help = "Use fadvise() to advise the kernel on IO pattern",
2719 .def = "1",
2720 .category = FIO_OPT_C_FILE,
2721 .group = FIO_OPT_G_INVALID,
2722 },
2723 {
2724 .name = "fsync",
2725 .lname = "Fsync",
2726 .type = FIO_OPT_INT,
2727 .off1 = offsetof(struct thread_options, fsync_blocks),
2728 .help = "Issue fsync for writes every given number of blocks",
2729 .def = "0",
2730 .interval = 1,
2731 .category = FIO_OPT_C_FILE,
2732 .group = FIO_OPT_G_INVALID,
2733 },
2734 {
2735 .name = "fdatasync",
2736 .lname = "Fdatasync",
2737 .type = FIO_OPT_INT,
2738 .off1 = offsetof(struct thread_options, fdatasync_blocks),
2739 .help = "Issue fdatasync for writes every given number of blocks",
2740 .def = "0",
2741 .interval = 1,
2742 .category = FIO_OPT_C_FILE,
2743 .group = FIO_OPT_G_INVALID,
2744 },
2745 {
2746 .name = "write_barrier",
2747 .lname = "Write barrier",
2748 .type = FIO_OPT_INT,
2749 .off1 = offsetof(struct thread_options, barrier_blocks),
2750 .help = "Make every Nth write a barrier write",
2751 .def = "0",
2752 .interval = 1,
2753 .category = FIO_OPT_C_IO,
2754 .group = FIO_OPT_G_INVALID,
2755 },
2756#ifdef CONFIG_SYNC_FILE_RANGE
2757 {
2758 .name = "sync_file_range",
2759 .lname = "Sync file range",
2760 .posval = {
2761 { .ival = "wait_before",
2762 .oval = SYNC_FILE_RANGE_WAIT_BEFORE,
2763 .help = "SYNC_FILE_RANGE_WAIT_BEFORE",
2764 .orval = 1,
2765 },
2766 { .ival = "write",
2767 .oval = SYNC_FILE_RANGE_WRITE,
2768 .help = "SYNC_FILE_RANGE_WRITE",
2769 .orval = 1,
2770 },
2771 {
2772 .ival = "wait_after",
2773 .oval = SYNC_FILE_RANGE_WAIT_AFTER,
2774 .help = "SYNC_FILE_RANGE_WAIT_AFTER",
2775 .orval = 1,
2776 },
2777 },
2778 .type = FIO_OPT_STR_MULTI,
2779 .cb = str_sfr_cb,
2780 .off1 = offsetof(struct thread_options, sync_file_range),
2781 .help = "Use sync_file_range()",
2782 .category = FIO_OPT_C_FILE,
2783 .group = FIO_OPT_G_INVALID,
2784 },
2785#else
2786 {
2787 .name = "sync_file_range",
2788 .lname = "Sync file range",
2789 .type = FIO_OPT_UNSUPPORTED,
2790 .help = "Your platform does not support sync_file_range",
2791 },
2792#endif
2793 {
2794 .name = "direct",
2795 .lname = "Direct I/O",
2796 .type = FIO_OPT_BOOL,
2797 .off1 = offsetof(struct thread_options, odirect),
2798 .help = "Use O_DIRECT IO (negates buffered)",
2799 .def = "0",
2800 .inverse = "buffered",
2801 .category = FIO_OPT_C_IO,
2802 .group = FIO_OPT_G_IO_TYPE,
2803 },
2804 {
2805 .name = "atomic",
2806 .lname = "Atomic I/O",
2807 .type = FIO_OPT_BOOL,
2808 .off1 = offsetof(struct thread_options, oatomic),
2809 .help = "Use Atomic IO with O_DIRECT (implies O_DIRECT)",
2810 .def = "0",
2811 .category = FIO_OPT_C_IO,
2812 .group = FIO_OPT_G_IO_TYPE,
2813 },
2814 {
2815 .name = "buffered",
2816 .lname = "Buffered I/O",
2817 .type = FIO_OPT_BOOL,
2818 .off1 = offsetof(struct thread_options, odirect),
2819 .neg = 1,
2820 .help = "Use buffered IO (negates direct)",
2821 .def = "1",
2822 .inverse = "direct",
2823 .category = FIO_OPT_C_IO,
2824 .group = FIO_OPT_G_IO_TYPE,
2825 },
2826 {
2827 .name = "overwrite",
2828 .lname = "Overwrite",
2829 .type = FIO_OPT_BOOL,
2830 .off1 = offsetof(struct thread_options, overwrite),
2831 .help = "When writing, set whether to overwrite current data",
2832 .def = "0",
2833 .category = FIO_OPT_C_FILE,
2834 .group = FIO_OPT_G_INVALID,
2835 },
2836 {
2837 .name = "loops",
2838 .lname = "Loops",
2839 .type = FIO_OPT_INT,
2840 .off1 = offsetof(struct thread_options, loops),
2841 .help = "Number of times to run the job",
2842 .def = "1",
2843 .interval = 1,
2844 .category = FIO_OPT_C_GENERAL,
2845 .group = FIO_OPT_G_RUNTIME,
2846 },
2847 {
2848 .name = "numjobs",
2849 .lname = "Number of jobs",
2850 .type = FIO_OPT_INT,
2851 .off1 = offsetof(struct thread_options, numjobs),
2852 .help = "Duplicate this job this many times",
2853 .def = "1",
2854 .interval = 1,
2855 .category = FIO_OPT_C_GENERAL,
2856 .group = FIO_OPT_G_RUNTIME,
2857 },
2858 {
2859 .name = "startdelay",
2860 .lname = "Start delay",
2861 .type = FIO_OPT_STR_VAL_TIME,
2862 .off1 = offsetof(struct thread_options, start_delay),
2863 .off2 = offsetof(struct thread_options, start_delay_high),
2864 .help = "Only start job when this period has passed",
2865 .def = "0",
2866 .is_seconds = 1,
2867 .is_time = 1,
2868 .category = FIO_OPT_C_GENERAL,
2869 .group = FIO_OPT_G_RUNTIME,
2870 },
2871 {
2872 .name = "runtime",
2873 .lname = "Runtime",
2874 .alias = "timeout",
2875 .type = FIO_OPT_STR_VAL_TIME,
2876 .off1 = offsetof(struct thread_options, timeout),
2877 .help = "Stop workload when this amount of time has passed",
2878 .def = "0",
2879 .is_seconds = 1,
2880 .is_time = 1,
2881 .category = FIO_OPT_C_GENERAL,
2882 .group = FIO_OPT_G_RUNTIME,
2883 },
2884 {
2885 .name = "time_based",
2886 .lname = "Time based",
2887 .type = FIO_OPT_STR_SET,
2888 .off1 = offsetof(struct thread_options, time_based),
2889 .help = "Keep running until runtime/timeout is met",
2890 .category = FIO_OPT_C_GENERAL,
2891 .group = FIO_OPT_G_RUNTIME,
2892 },
2893 {
2894 .name = "verify_only",
2895 .lname = "Verify only",
2896 .type = FIO_OPT_STR_SET,
2897 .off1 = offsetof(struct thread_options, verify_only),
2898 .help = "Verifies previously written data is still valid",
2899 .category = FIO_OPT_C_GENERAL,
2900 .group = FIO_OPT_G_RUNTIME,
2901 },
2902 {
2903 .name = "ramp_time",
2904 .lname = "Ramp time",
2905 .type = FIO_OPT_STR_VAL_TIME,
2906 .off1 = offsetof(struct thread_options, ramp_time),
2907 .help = "Ramp up time before measuring performance",
2908 .is_seconds = 1,
2909 .is_time = 1,
2910 .category = FIO_OPT_C_GENERAL,
2911 .group = FIO_OPT_G_RUNTIME,
2912 },
2913 {
2914 .name = "clocksource",
2915 .lname = "Clock source",
2916 .type = FIO_OPT_STR,
2917 .cb = fio_clock_source_cb,
2918 .off1 = offsetof(struct thread_options, clocksource),
2919 .help = "What type of timing source to use",
2920 .category = FIO_OPT_C_GENERAL,
2921 .group = FIO_OPT_G_CLOCK,
2922 .posval = {
2923#ifdef CONFIG_GETTIMEOFDAY
2924 { .ival = "gettimeofday",
2925 .oval = CS_GTOD,
2926 .help = "Use gettimeofday(2) for timing",
2927 },
2928#endif
2929#ifdef CONFIG_CLOCK_GETTIME
2930 { .ival = "clock_gettime",
2931 .oval = CS_CGETTIME,
2932 .help = "Use clock_gettime(2) for timing",
2933 },
2934#endif
2935#ifdef ARCH_HAVE_CPU_CLOCK
2936 { .ival = "cpu",
2937 .oval = CS_CPUCLOCK,
2938 .help = "Use CPU private clock",
2939 },
2940#endif
2941 },
2942 },
2943 {
2944 .name = "mem",
2945 .alias = "iomem",
2946 .lname = "I/O Memory",
2947 .type = FIO_OPT_STR,
2948 .cb = str_mem_cb,
2949 .off1 = offsetof(struct thread_options, mem_type),
2950 .help = "Backing type for IO buffers",
2951 .def = "malloc",
2952 .category = FIO_OPT_C_IO,
2953 .group = FIO_OPT_G_INVALID,
2954 .posval = {
2955 { .ival = "malloc",
2956 .oval = MEM_MALLOC,
2957 .help = "Use malloc(3) for IO buffers",
2958 },
2959#ifndef CONFIG_NO_SHM
2960 { .ival = "shm",
2961 .oval = MEM_SHM,
2962 .help = "Use shared memory segments for IO buffers",
2963 },
2964#ifdef FIO_HAVE_HUGETLB
2965 { .ival = "shmhuge",
2966 .oval = MEM_SHMHUGE,
2967 .help = "Like shm, but use huge pages",
2968 },
2969#endif
2970#endif
2971 { .ival = "mmap",
2972 .oval = MEM_MMAP,
2973 .help = "Use mmap(2) (file or anon) for IO buffers",
2974 },
2975 { .ival = "mmapshared",
2976 .oval = MEM_MMAPSHARED,
2977 .help = "Like mmap, but use the shared flag",
2978 },
2979#ifdef FIO_HAVE_HUGETLB
2980 { .ival = "mmaphuge",
2981 .oval = MEM_MMAPHUGE,
2982 .help = "Like mmap, but use huge pages",
2983 },
2984#endif
2985#ifdef CONFIG_CUDA
2986 { .ival = "cudamalloc",
2987 .oval = MEM_CUDA_MALLOC,
2988 .help = "Allocate GPU device memory for GPUDirect RDMA",
2989 },
2990#endif
2991 },
2992 },
2993 {
2994 .name = "iomem_align",
2995 .alias = "mem_align",
2996 .lname = "I/O memory alignment",
2997 .type = FIO_OPT_INT,
2998 .off1 = offsetof(struct thread_options, mem_align),
2999 .minval = 0,
3000 .help = "IO memory buffer offset alignment",
3001 .def = "0",
3002 .parent = "iomem",
3003 .hide = 1,
3004 .category = FIO_OPT_C_IO,
3005 .group = FIO_OPT_G_INVALID,
3006 },
3007 {
3008 .name = "verify",
3009 .lname = "Verify",
3010 .type = FIO_OPT_STR,
3011 .off1 = offsetof(struct thread_options, verify),
3012 .help = "Verify data written",
3013 .def = "0",
3014 .category = FIO_OPT_C_IO,
3015 .group = FIO_OPT_G_VERIFY,
3016 .posval = {
3017 { .ival = "0",
3018 .oval = VERIFY_NONE,
3019 .help = "Don't do IO verification",
3020 },
3021 { .ival = "md5",
3022 .oval = VERIFY_MD5,
3023 .help = "Use md5 checksums for verification",
3024 },
3025 { .ival = "crc64",
3026 .oval = VERIFY_CRC64,
3027 .help = "Use crc64 checksums for verification",
3028 },
3029 { .ival = "crc32",
3030 .oval = VERIFY_CRC32,
3031 .help = "Use crc32 checksums for verification",
3032 },
3033 { .ival = "crc32c-intel",
3034 .oval = VERIFY_CRC32C,
3035 .help = "Use crc32c checksums for verification (hw assisted, if available)",
3036 },
3037 { .ival = "crc32c",
3038 .oval = VERIFY_CRC32C,
3039 .help = "Use crc32c checksums for verification (hw assisted, if available)",
3040 },
3041 { .ival = "crc16",
3042 .oval = VERIFY_CRC16,
3043 .help = "Use crc16 checksums for verification",
3044 },
3045 { .ival = "crc7",
3046 .oval = VERIFY_CRC7,
3047 .help = "Use crc7 checksums for verification",
3048 },
3049 { .ival = "sha1",
3050 .oval = VERIFY_SHA1,
3051 .help = "Use sha1 checksums for verification",
3052 },
3053 { .ival = "sha256",
3054 .oval = VERIFY_SHA256,
3055 .help = "Use sha256 checksums for verification",
3056 },
3057 { .ival = "sha512",
3058 .oval = VERIFY_SHA512,
3059 .help = "Use sha512 checksums for verification",
3060 },
3061 { .ival = "sha3-224",
3062 .oval = VERIFY_SHA3_224,
3063 .help = "Use sha3-224 checksums for verification",
3064 },
3065 { .ival = "sha3-256",
3066 .oval = VERIFY_SHA3_256,
3067 .help = "Use sha3-256 checksums for verification",
3068 },
3069 { .ival = "sha3-384",
3070 .oval = VERIFY_SHA3_384,
3071 .help = "Use sha3-384 checksums for verification",
3072 },
3073 { .ival = "sha3-512",
3074 .oval = VERIFY_SHA3_512,
3075 .help = "Use sha3-512 checksums for verification",
3076 },
3077 { .ival = "xxhash",
3078 .oval = VERIFY_XXHASH,
3079 .help = "Use xxhash checksums for verification",
3080 },
3081 /* Meta information was included into verify_header,
3082 * 'meta' verification is implied by default. */
3083 { .ival = "meta",
3084 .oval = VERIFY_HDR_ONLY,
3085 .help = "Use io information for verification. "
3086 "Now is implied by default, thus option is obsolete, "
3087 "don't use it",
3088 },
3089 { .ival = "pattern",
3090 .oval = VERIFY_PATTERN_NO_HDR,
3091 .help = "Verify strict pattern",
3092 },
3093 {
3094 .ival = "null",
3095 .oval = VERIFY_NULL,
3096 .help = "Pretend to verify",
3097 },
3098 },
3099 },
3100 {
3101 .name = "do_verify",
3102 .lname = "Perform verify step",
3103 .type = FIO_OPT_BOOL,
3104 .off1 = offsetof(struct thread_options, do_verify),
3105 .help = "Run verification stage after write",
3106 .def = "1",
3107 .parent = "verify",
3108 .hide = 1,
3109 .category = FIO_OPT_C_IO,
3110 .group = FIO_OPT_G_VERIFY,
3111 },
3112 {
3113 .name = "verifysort",
3114 .lname = "Verify sort",
3115 .type = FIO_OPT_SOFT_DEPRECATED,
3116 .category = FIO_OPT_C_IO,
3117 .group = FIO_OPT_G_VERIFY,
3118 },
3119 {
3120 .name = "verifysort_nr",
3121 .lname = "Verify Sort Nr",
3122 .type = FIO_OPT_SOFT_DEPRECATED,
3123 .category = FIO_OPT_C_IO,
3124 .group = FIO_OPT_G_VERIFY,
3125 },
3126 {
3127 .name = "verify_interval",
3128 .lname = "Verify interval",
3129 .type = FIO_OPT_INT,
3130 .off1 = offsetof(struct thread_options, verify_interval),
3131 .minval = 2 * sizeof(struct verify_header),
3132 .help = "Store verify buffer header every N bytes",
3133 .parent = "verify",
3134 .hide = 1,
3135 .interval = 2 * sizeof(struct verify_header),
3136 .category = FIO_OPT_C_IO,
3137 .group = FIO_OPT_G_VERIFY,
3138 },
3139 {
3140 .name = "verify_offset",
3141 .lname = "Verify offset",
3142 .type = FIO_OPT_INT,
3143 .help = "Offset verify header location by N bytes",
3144 .off1 = offsetof(struct thread_options, verify_offset),
3145 .minval = sizeof(struct verify_header),
3146 .parent = "verify",
3147 .hide = 1,
3148 .category = FIO_OPT_C_IO,
3149 .group = FIO_OPT_G_VERIFY,
3150 },
3151 {
3152 .name = "verify_pattern",
3153 .lname = "Verify pattern",
3154 .type = FIO_OPT_STR,
3155 .cb = str_verify_pattern_cb,
3156 .off1 = offsetof(struct thread_options, verify_pattern),
3157 .help = "Fill pattern for IO buffers",
3158 .parent = "verify",
3159 .hide = 1,
3160 .category = FIO_OPT_C_IO,
3161 .group = FIO_OPT_G_VERIFY,
3162 },
3163 {
3164 .name = "verify_fatal",
3165 .lname = "Verify fatal",
3166 .type = FIO_OPT_BOOL,
3167 .off1 = offsetof(struct thread_options, verify_fatal),
3168 .def = "0",
3169 .help = "Exit on a single verify failure, don't continue",
3170 .parent = "verify",
3171 .hide = 1,
3172 .category = FIO_OPT_C_IO,
3173 .group = FIO_OPT_G_VERIFY,
3174 },
3175 {
3176 .name = "verify_dump",
3177 .lname = "Verify dump",
3178 .type = FIO_OPT_BOOL,
3179 .off1 = offsetof(struct thread_options, verify_dump),
3180 .def = "0",
3181 .help = "Dump contents of good and bad blocks on failure",
3182 .parent = "verify",
3183 .hide = 1,
3184 .category = FIO_OPT_C_IO,
3185 .group = FIO_OPT_G_VERIFY,
3186 },
3187 {
3188 .name = "verify_async",
3189 .lname = "Verify asynchronously",
3190 .type = FIO_OPT_INT,
3191 .off1 = offsetof(struct thread_options, verify_async),
3192 .def = "0",
3193 .help = "Number of async verifier threads to use",
3194 .parent = "verify",
3195 .hide = 1,
3196 .category = FIO_OPT_C_IO,
3197 .group = FIO_OPT_G_VERIFY,
3198 },
3199 {
3200 .name = "verify_backlog",
3201 .lname = "Verify backlog",
3202 .type = FIO_OPT_STR_VAL,
3203 .off1 = offsetof(struct thread_options, verify_backlog),
3204 .help = "Verify after this number of blocks are written",
3205 .parent = "verify",
3206 .hide = 1,
3207 .category = FIO_OPT_C_IO,
3208 .group = FIO_OPT_G_VERIFY,
3209 },
3210 {
3211 .name = "verify_backlog_batch",
3212 .lname = "Verify backlog batch",
3213 .type = FIO_OPT_INT,
3214 .off1 = offsetof(struct thread_options, verify_batch),
3215 .help = "Verify this number of IO blocks",
3216 .parent = "verify",
3217 .hide = 1,
3218 .category = FIO_OPT_C_IO,
3219 .group = FIO_OPT_G_VERIFY,
3220 },
3221#ifdef FIO_HAVE_CPU_AFFINITY
3222 {
3223 .name = "verify_async_cpus",
3224 .lname = "Async verify CPUs",
3225 .type = FIO_OPT_STR,
3226 .cb = str_verify_cpus_allowed_cb,
3227 .off1 = offsetof(struct thread_options, verify_cpumask),
3228 .help = "Set CPUs allowed for async verify threads",
3229 .parent = "verify_async",
3230 .hide = 1,
3231 .category = FIO_OPT_C_IO,
3232 .group = FIO_OPT_G_VERIFY,
3233 },
3234#else
3235 {
3236 .name = "verify_async_cpus",
3237 .lname = "Async verify CPUs",
3238 .type = FIO_OPT_UNSUPPORTED,
3239 .help = "Your platform does not support CPU affinities",
3240 },
3241#endif
3242 {
3243 .name = "experimental_verify",
3244 .lname = "Experimental Verify",
3245 .off1 = offsetof(struct thread_options, experimental_verify),
3246 .type = FIO_OPT_BOOL,
3247 .help = "Enable experimental verification",
3248 .parent = "verify",
3249 .category = FIO_OPT_C_IO,
3250 .group = FIO_OPT_G_VERIFY,
3251 },
3252 {
3253 .name = "verify_state_load",
3254 .lname = "Load verify state",
3255 .off1 = offsetof(struct thread_options, verify_state),
3256 .type = FIO_OPT_BOOL,
3257 .help = "Load verify termination state",
3258 .parent = "verify",
3259 .category = FIO_OPT_C_IO,
3260 .group = FIO_OPT_G_VERIFY,
3261 },
3262 {
3263 .name = "verify_state_save",
3264 .lname = "Save verify state",
3265 .off1 = offsetof(struct thread_options, verify_state_save),
3266 .type = FIO_OPT_BOOL,
3267 .def = "1",
3268 .help = "Save verify state on termination",
3269 .parent = "verify",
3270 .category = FIO_OPT_C_IO,
3271 .group = FIO_OPT_G_VERIFY,
3272 },
3273#ifdef FIO_HAVE_TRIM
3274 {
3275 .name = "trim_percentage",
3276 .lname = "Trim percentage",
3277 .type = FIO_OPT_INT,
3278 .off1 = offsetof(struct thread_options, trim_percentage),
3279 .minval = 0,
3280 .maxval = 100,
3281 .help = "Number of verify blocks to trim (i.e., discard)",
3282 .parent = "verify",
3283 .def = "0",
3284 .interval = 1,
3285 .hide = 1,
3286 .category = FIO_OPT_C_IO,
3287 .group = FIO_OPT_G_TRIM,
3288 },
3289 {
3290 .name = "trim_verify_zero",
3291 .lname = "Verify trim zero",
3292 .type = FIO_OPT_BOOL,
3293 .help = "Verify that trimmed (i.e., discarded) blocks are returned as zeroes",
3294 .off1 = offsetof(struct thread_options, trim_zero),
3295 .parent = "trim_percentage",
3296 .hide = 1,
3297 .def = "1",
3298 .category = FIO_OPT_C_IO,
3299 .group = FIO_OPT_G_TRIM,
3300 },
3301 {
3302 .name = "trim_backlog",
3303 .lname = "Trim backlog",
3304 .type = FIO_OPT_STR_VAL,
3305 .off1 = offsetof(struct thread_options, trim_backlog),
3306 .help = "Trim after this number of blocks are written",
3307 .parent = "trim_percentage",
3308 .hide = 1,
3309 .interval = 1,
3310 .category = FIO_OPT_C_IO,
3311 .group = FIO_OPT_G_TRIM,
3312 },
3313 {
3314 .name = "trim_backlog_batch",
3315 .lname = "Trim backlog batch",
3316 .type = FIO_OPT_INT,
3317 .off1 = offsetof(struct thread_options, trim_batch),
3318 .help = "Trim this number of IO blocks",
3319 .parent = "trim_percentage",
3320 .hide = 1,
3321 .interval = 1,
3322 .category = FIO_OPT_C_IO,
3323 .group = FIO_OPT_G_TRIM,
3324 },
3325#else
3326 {
3327 .name = "trim_percentage",
3328 .lname = "Trim percentage",
3329 .type = FIO_OPT_UNSUPPORTED,
3330 .help = "Fio does not support TRIM on your platform",
3331 },
3332 {
3333 .name = "trim_verify_zero",
3334 .lname = "Verify trim zero",
3335 .type = FIO_OPT_UNSUPPORTED,
3336 .help = "Fio does not support TRIM on your platform",
3337 },
3338 {
3339 .name = "trim_backlog",
3340 .lname = "Trim backlog",
3341 .type = FIO_OPT_UNSUPPORTED,
3342 .help = "Fio does not support TRIM on your platform",
3343 },
3344 {
3345 .name = "trim_backlog_batch",
3346 .lname = "Trim backlog batch",
3347 .type = FIO_OPT_UNSUPPORTED,
3348 .help = "Fio does not support TRIM on your platform",
3349 },
3350#endif
3351 {
3352 .name = "write_iolog",
3353 .lname = "Write I/O log",
3354 .type = FIO_OPT_STR_STORE,
3355 .off1 = offsetof(struct thread_options, write_iolog_file),
3356 .help = "Store IO pattern to file",
3357 .category = FIO_OPT_C_IO,
3358 .group = FIO_OPT_G_IOLOG,
3359 },
3360 {
3361 .name = "read_iolog",
3362 .lname = "Read I/O log",
3363 .type = FIO_OPT_STR_STORE,
3364 .off1 = offsetof(struct thread_options, read_iolog_file),
3365 .help = "Playback IO pattern from file",
3366 .category = FIO_OPT_C_IO,
3367 .group = FIO_OPT_G_IOLOG,
3368 },
3369 {
3370 .name = "read_iolog_chunked",
3371 .lname = "Read I/O log in parts",
3372 .type = FIO_OPT_BOOL,
3373 .off1 = offsetof(struct thread_options, read_iolog_chunked),
3374 .def = "0",
3375 .parent = "read_iolog",
3376 .help = "Parse IO pattern in chunks",
3377 .category = FIO_OPT_C_IO,
3378 .group = FIO_OPT_G_IOLOG,
3379 },
3380 {
3381 .name = "replay_no_stall",
3382 .lname = "Don't stall on replay",
3383 .type = FIO_OPT_BOOL,
3384 .off1 = offsetof(struct thread_options, no_stall),
3385 .def = "0",
3386 .parent = "read_iolog",
3387 .hide = 1,
3388 .help = "Playback IO pattern file as fast as possible without stalls",
3389 .category = FIO_OPT_C_IO,
3390 .group = FIO_OPT_G_IOLOG,
3391 },
3392 {
3393 .name = "replay_redirect",
3394 .lname = "Redirect device for replay",
3395 .type = FIO_OPT_STR_STORE,
3396 .off1 = offsetof(struct thread_options, replay_redirect),
3397 .parent = "read_iolog",
3398 .hide = 1,
3399 .help = "Replay all I/O onto this device, regardless of trace device",
3400 .category = FIO_OPT_C_IO,
3401 .group = FIO_OPT_G_IOLOG,
3402 },
3403 {
3404 .name = "replay_scale",
3405 .lname = "Replace offset scale factor",
3406 .type = FIO_OPT_INT,
3407 .off1 = offsetof(struct thread_options, replay_scale),
3408 .parent = "read_iolog",
3409 .def = "1",
3410 .help = "Align offsets to this blocksize",
3411 .category = FIO_OPT_C_IO,
3412 .group = FIO_OPT_G_IOLOG,
3413 },
3414 {
3415 .name = "replay_align",
3416 .lname = "Replace alignment",
3417 .type = FIO_OPT_INT,
3418 .off1 = offsetof(struct thread_options, replay_align),
3419 .parent = "read_iolog",
3420 .help = "Scale offset down by this factor",
3421 .category = FIO_OPT_C_IO,
3422 .group = FIO_OPT_G_IOLOG,
3423 .pow2 = 1,
3424 },
3425 {
3426 .name = "replay_time_scale",
3427 .lname = "Replay Time Scale",
3428 .type = FIO_OPT_INT,
3429 .off1 = offsetof(struct thread_options, replay_time_scale),
3430 .def = "100",
3431 .minval = 1,
3432 .parent = "read_iolog",
3433 .hide = 1,
3434 .help = "Scale time for replay events",
3435 .category = FIO_OPT_C_IO,
3436 .group = FIO_OPT_G_IOLOG,
3437 },
3438 {
3439 .name = "replay_skip",
3440 .lname = "Replay Skip",
3441 .type = FIO_OPT_STR,
3442 .cb = str_replay_skip_cb,
3443 .off1 = offsetof(struct thread_options, replay_skip),
3444 .parent = "read_iolog",
3445 .help = "Skip certain IO types (read,write,trim,flush)",
3446 .category = FIO_OPT_C_IO,
3447 .group = FIO_OPT_G_IOLOG,
3448 },
3449 {
3450 .name = "merge_blktrace_file",
3451 .lname = "Merged blktrace output filename",
3452 .type = FIO_OPT_STR_STORE,
3453 .off1 = offsetof(struct thread_options, merge_blktrace_file),
3454 .help = "Merged blktrace output filename",
3455 .category = FIO_OPT_C_IO,
3456 .group = FIO_OPT_G_IOLOG,
3457 },
3458 {
3459 .name = "merge_blktrace_scalars",
3460 .lname = "Percentage to scale each trace",
3461 .type = FIO_OPT_FLOAT_LIST,
3462 .off1 = offsetof(struct thread_options, merge_blktrace_scalars),
3463 .maxlen = FIO_IO_U_LIST_MAX_LEN,
3464 .help = "Percentage to scale each trace",
3465 .category = FIO_OPT_C_IO,
3466 .group = FIO_OPT_G_IOLOG,
3467 },
3468 {
3469 .name = "merge_blktrace_iters",
3470 .lname = "Number of iterations to run per trace",
3471 .type = FIO_OPT_FLOAT_LIST,
3472 .off1 = offsetof(struct thread_options, merge_blktrace_iters),
3473 .maxlen = FIO_IO_U_LIST_MAX_LEN,
3474 .help = "Number of iterations to run per trace",
3475 .category = FIO_OPT_C_IO,
3476 .group = FIO_OPT_G_IOLOG,
3477 },
3478 {
3479 .name = "exec_prerun",
3480 .lname = "Pre-execute runnable",
3481 .type = FIO_OPT_STR_STORE,
3482 .off1 = offsetof(struct thread_options, exec_prerun),
3483 .help = "Execute this file prior to running job",
3484 .category = FIO_OPT_C_GENERAL,
3485 .group = FIO_OPT_G_INVALID,
3486 },
3487 {
3488 .name = "exec_postrun",
3489 .lname = "Post-execute runnable",
3490 .type = FIO_OPT_STR_STORE,
3491 .off1 = offsetof(struct thread_options, exec_postrun),
3492 .help = "Execute this file after running job",
3493 .category = FIO_OPT_C_GENERAL,
3494 .group = FIO_OPT_G_INVALID,
3495 },
3496#ifdef FIO_HAVE_IOSCHED_SWITCH
3497 {
3498 .name = "ioscheduler",
3499 .lname = "I/O scheduler",
3500 .type = FIO_OPT_STR_STORE,
3501 .off1 = offsetof(struct thread_options, ioscheduler),
3502 .help = "Use this IO scheduler on the backing device",
3503 .category = FIO_OPT_C_FILE,
3504 .group = FIO_OPT_G_INVALID,
3505 },
3506#else
3507 {
3508 .name = "ioscheduler",
3509 .lname = "I/O scheduler",
3510 .type = FIO_OPT_UNSUPPORTED,
3511 .help = "Your platform does not support IO scheduler switching",
3512 },
3513#endif
3514 {
3515 .name = "zonemode",
3516 .lname = "Zone mode",
3517 .help = "Mode for the zonesize, zonerange and zoneskip parameters",
3518 .type = FIO_OPT_STR,
3519 .off1 = offsetof(struct thread_options, zone_mode),
3520 .def = "none",
3521 .category = FIO_OPT_C_IO,
3522 .group = FIO_OPT_G_ZONE,
3523 .posval = {
3524 { .ival = "none",
3525 .oval = ZONE_MODE_NONE,
3526 .help = "no zoning",
3527 },
3528 { .ival = "strided",
3529 .oval = ZONE_MODE_STRIDED,
3530 .help = "strided mode - random I/O is restricted to a single zone",
3531 },
3532 { .ival = "zbd",
3533 .oval = ZONE_MODE_ZBD,
3534 .help = "zoned block device mode - random I/O selects one of multiple zones randomly",
3535 },
3536 },
3537 },
3538 {
3539 .name = "zonesize",
3540 .lname = "Zone size",
3541 .type = FIO_OPT_STR_VAL,
3542 .off1 = offsetof(struct thread_options, zone_size),
3543 .help = "Amount of data to read per zone",
3544 .def = "0",
3545 .interval = 1024 * 1024,
3546 .category = FIO_OPT_C_IO,
3547 .group = FIO_OPT_G_ZONE,
3548 },
3549 {
3550 .name = "zonecapacity",
3551 .lname = "Zone capacity",
3552 .type = FIO_OPT_STR_VAL,
3553 .off1 = offsetof(struct thread_options, zone_capacity),
3554 .help = "Capacity per zone",
3555 .def = "0",
3556 .interval = 1024 * 1024,
3557 .category = FIO_OPT_C_IO,
3558 .group = FIO_OPT_G_ZONE,
3559 },
3560 {
3561 .name = "zonerange",
3562 .lname = "Zone range",
3563 .type = FIO_OPT_STR_VAL,
3564 .off1 = offsetof(struct thread_options, zone_range),
3565 .help = "Give size of an IO zone",
3566 .def = "0",
3567 .interval = 1024 * 1024,
3568 .category = FIO_OPT_C_IO,
3569 .group = FIO_OPT_G_ZONE,
3570 },
3571 {
3572 .name = "zoneskip",
3573 .lname = "Zone skip",
3574 .type = FIO_OPT_STR_VAL_ZONE,
3575 .cb = str_zoneskip_cb,
3576 .off1 = offsetof(struct thread_options, zone_skip),
3577 .help = "Space between IO zones",
3578 .def = "0",
3579 .category = FIO_OPT_C_IO,
3580 .group = FIO_OPT_G_ZONE,
3581 },
3582 {
3583 .name = "read_beyond_wp",
3584 .lname = "Allow reads beyond the zone write pointer",
3585 .type = FIO_OPT_BOOL,
3586 .off1 = offsetof(struct thread_options, read_beyond_wp),
3587 .help = "Allow reads beyond the zone write pointer",
3588 .def = "0",
3589 .category = FIO_OPT_C_IO,
3590 .group = FIO_OPT_G_INVALID,
3591 },
3592 {
3593 .name = "max_open_zones",
3594 .lname = "Per device/file maximum number of open zones",
3595 .type = FIO_OPT_INT,
3596 .off1 = offsetof(struct thread_options, max_open_zones),
3597 .maxval = ZBD_MAX_OPEN_ZONES,
3598 .help = "Limit on the number of simultaneously opened sequential write zones with zonemode=zbd",
3599 .def = "0",
3600 .category = FIO_OPT_C_IO,
3601 .group = FIO_OPT_G_INVALID,
3602 },
3603 {
3604 .name = "job_max_open_zones",
3605 .lname = "Job maximum number of open zones",
3606 .type = FIO_OPT_INT,
3607 .off1 = offsetof(struct thread_options, job_max_open_zones),
3608 .maxval = ZBD_MAX_OPEN_ZONES,
3609 .help = "Limit on the number of simultaneously opened sequential write zones with zonemode=zbd by one thread/process",
3610 .def = "0",
3611 .category = FIO_OPT_C_IO,
3612 .group = FIO_OPT_G_INVALID,
3613 },
3614 {
3615 .name = "ignore_zone_limits",
3616 .lname = "Ignore zone resource limits",
3617 .type = FIO_OPT_BOOL,
3618 .off1 = offsetof(struct thread_options, ignore_zone_limits),
3619 .def = "0",
3620 .help = "Ignore the zone resource limits (max open/active zones) reported by the device",
3621 .category = FIO_OPT_C_IO,
3622 .group = FIO_OPT_G_INVALID,
3623 },
3624 {
3625 .name = "zone_reset_threshold",
3626 .lname = "Zone reset threshold",
3627 .help = "Zoned block device reset threshold",
3628 .type = FIO_OPT_FLOAT_LIST,
3629 .maxlen = 1,
3630 .off1 = offsetof(struct thread_options, zrt),
3631 .minfp = 0,
3632 .maxfp = 1,
3633 .category = FIO_OPT_C_IO,
3634 .group = FIO_OPT_G_ZONE,
3635 },
3636 {
3637 .name = "zone_reset_frequency",
3638 .lname = "Zone reset frequency",
3639 .help = "Zoned block device zone reset frequency in HZ",
3640 .type = FIO_OPT_FLOAT_LIST,
3641 .maxlen = 1,
3642 .off1 = offsetof(struct thread_options, zrf),
3643 .minfp = 0,
3644 .maxfp = 1,
3645 .category = FIO_OPT_C_IO,
3646 .group = FIO_OPT_G_ZONE,
3647 },
3648 {
3649 .name = "lockmem",
3650 .lname = "Lock memory",
3651 .type = FIO_OPT_STR_VAL,
3652 .off1 = offsetof(struct thread_options, lockmem),
3653 .help = "Lock down this amount of memory (per worker)",
3654 .def = "0",
3655 .interval = 1024 * 1024,
3656 .category = FIO_OPT_C_GENERAL,
3657 .group = FIO_OPT_G_INVALID,
3658 },
3659 {
3660 .name = "rwmixread",
3661 .lname = "Read/write mix read",
3662 .type = FIO_OPT_INT,
3663 .cb = str_rwmix_read_cb,
3664 .off1 = offsetof(struct thread_options, rwmix[DDIR_READ]),
3665 .maxval = 100,
3666 .help = "Percentage of mixed workload that is reads",
3667 .def = "50",
3668 .interval = 5,
3669 .inverse = "rwmixwrite",
3670 .category = FIO_OPT_C_IO,
3671 .group = FIO_OPT_G_RWMIX,
3672 },
3673 {
3674 .name = "rwmixwrite",
3675 .lname = "Read/write mix write",
3676 .type = FIO_OPT_INT,
3677 .cb = str_rwmix_write_cb,
3678 .off1 = offsetof(struct thread_options, rwmix[DDIR_WRITE]),
3679 .maxval = 100,
3680 .help = "Percentage of mixed workload that is writes",
3681 .def = "50",
3682 .interval = 5,
3683 .inverse = "rwmixread",
3684 .category = FIO_OPT_C_IO,
3685 .group = FIO_OPT_G_RWMIX,
3686 },
3687 {
3688 .name = "rwmixcycle",
3689 .lname = "Read/write mix cycle",
3690 .type = FIO_OPT_DEPRECATED,
3691 .category = FIO_OPT_C_IO,
3692 .group = FIO_OPT_G_RWMIX,
3693 },
3694 {
3695 .name = "nice",
3696 .lname = "Nice",
3697 .type = FIO_OPT_INT,
3698 .off1 = offsetof(struct thread_options, nice),
3699 .help = "Set job CPU nice value",
3700 .minval = -20,
3701 .maxval = 19,
3702 .def = "0",
3703 .interval = 1,
3704 .category = FIO_OPT_C_GENERAL,
3705 .group = FIO_OPT_G_CRED,
3706 },
3707#ifdef FIO_HAVE_IOPRIO
3708 {
3709 .name = "prio",
3710 .lname = "I/O nice priority",
3711 .type = FIO_OPT_INT,
3712 .off1 = offsetof(struct thread_options, ioprio),
3713 .help = "Set job IO priority value",
3714 .minval = IOPRIO_MIN_PRIO,
3715 .maxval = IOPRIO_MAX_PRIO,
3716 .interval = 1,
3717 .category = FIO_OPT_C_GENERAL,
3718 .group = FIO_OPT_G_CRED,
3719 },
3720#else
3721 {
3722 .name = "prio",
3723 .lname = "I/O nice priority",
3724 .type = FIO_OPT_UNSUPPORTED,
3725 .help = "Your platform does not support IO priorities",
3726 },
3727#endif
3728#ifdef FIO_HAVE_IOPRIO_CLASS
3729#ifndef FIO_HAVE_IOPRIO
3730#error "FIO_HAVE_IOPRIO_CLASS requires FIO_HAVE_IOPRIO"
3731#endif
3732 {
3733 .name = "prioclass",
3734 .lname = "I/O nice priority class",
3735 .type = FIO_OPT_INT,
3736 .off1 = offsetof(struct thread_options, ioprio_class),
3737 .help = "Set job IO priority class",
3738 .minval = IOPRIO_MIN_PRIO_CLASS,
3739 .maxval = IOPRIO_MAX_PRIO_CLASS,
3740 .interval = 1,
3741 .category = FIO_OPT_C_GENERAL,
3742 .group = FIO_OPT_G_CRED,
3743 },
3744#else
3745 {
3746 .name = "prioclass",
3747 .lname = "I/O nice priority class",
3748 .type = FIO_OPT_UNSUPPORTED,
3749 .help = "Your platform does not support IO priority classes",
3750 },
3751#endif
3752 {
3753 .name = "thinktime",
3754 .lname = "Thinktime",
3755 .type = FIO_OPT_INT,
3756 .off1 = offsetof(struct thread_options, thinktime),
3757 .help = "Idle time between IO buffers (usec)",
3758 .def = "0",
3759 .is_time = 1,
3760 .category = FIO_OPT_C_IO,
3761 .group = FIO_OPT_G_THINKTIME,
3762 },
3763 {
3764 .name = "thinktime_spin",
3765 .lname = "Thinktime spin",
3766 .type = FIO_OPT_INT,
3767 .off1 = offsetof(struct thread_options, thinktime_spin),
3768 .help = "Start think time by spinning this amount (usec)",
3769 .def = "0",
3770 .is_time = 1,
3771 .parent = "thinktime",
3772 .hide = 1,
3773 .category = FIO_OPT_C_IO,
3774 .group = FIO_OPT_G_THINKTIME,
3775 },
3776 {
3777 .name = "thinktime_blocks",
3778 .lname = "Thinktime blocks",
3779 .type = FIO_OPT_INT,
3780 .off1 = offsetof(struct thread_options, thinktime_blocks),
3781 .help = "IO buffer period between 'thinktime'",
3782 .def = "1",
3783 .parent = "thinktime",
3784 .hide = 1,
3785 .category = FIO_OPT_C_IO,
3786 .group = FIO_OPT_G_THINKTIME,
3787 },
3788 {
3789 .name = "thinktime_blocks_type",
3790 .lname = "Thinktime blocks type",
3791 .type = FIO_OPT_STR,
3792 .off1 = offsetof(struct thread_options, thinktime_blocks_type),
3793 .help = "How thinktime_blocks takes effect",
3794 .def = "complete",
3795 .category = FIO_OPT_C_IO,
3796 .group = FIO_OPT_G_THINKTIME,
3797 .posval = {
3798 { .ival = "complete",
3799 .oval = THINKTIME_BLOCKS_TYPE_COMPLETE,
3800 .help = "thinktime_blocks takes effect at the completion side",
3801 },
3802 {
3803 .ival = "issue",
3804 .oval = THINKTIME_BLOCKS_TYPE_ISSUE,
3805 .help = "thinktime_blocks takes effect at the issue side",
3806 },
3807 },
3808 .parent = "thinktime",
3809 },
3810 {
3811 .name = "thinktime_iotime",
3812 .lname = "Thinktime interval",
3813 .type = FIO_OPT_INT,
3814 .off1 = offsetof(struct thread_options, thinktime_iotime),
3815 .help = "IO time interval between 'thinktime'",
3816 .def = "0",
3817 .parent = "thinktime",
3818 .hide = 1,
3819 .is_seconds = 1,
3820 .is_time = 1,
3821 .category = FIO_OPT_C_IO,
3822 .group = FIO_OPT_G_THINKTIME,
3823 },
3824 {
3825 .name = "rate",
3826 .lname = "I/O rate",
3827 .type = FIO_OPT_ULL,
3828 .off1 = offsetof(struct thread_options, rate[DDIR_READ]),
3829 .off2 = offsetof(struct thread_options, rate[DDIR_WRITE]),
3830 .off3 = offsetof(struct thread_options, rate[DDIR_TRIM]),
3831 .help = "Set bandwidth rate",
3832 .category = FIO_OPT_C_IO,
3833 .group = FIO_OPT_G_RATE,
3834 },
3835 {
3836 .name = "rate_min",
3837 .alias = "ratemin",
3838 .lname = "I/O min rate",
3839 .type = FIO_OPT_ULL,
3840 .off1 = offsetof(struct thread_options, ratemin[DDIR_READ]),
3841 .off2 = offsetof(struct thread_options, ratemin[DDIR_WRITE]),
3842 .off3 = offsetof(struct thread_options, ratemin[DDIR_TRIM]),
3843 .help = "Job must meet this rate or it will be shutdown",
3844 .parent = "rate",
3845 .hide = 1,
3846 .category = FIO_OPT_C_IO,
3847 .group = FIO_OPT_G_RATE,
3848 },
3849 {
3850 .name = "rate_iops",
3851 .lname = "I/O rate IOPS",
3852 .type = FIO_OPT_INT,
3853 .off1 = offsetof(struct thread_options, rate_iops[DDIR_READ]),
3854 .off2 = offsetof(struct thread_options, rate_iops[DDIR_WRITE]),
3855 .off3 = offsetof(struct thread_options, rate_iops[DDIR_TRIM]),
3856 .help = "Limit IO used to this number of IO operations/sec",
3857 .hide = 1,
3858 .category = FIO_OPT_C_IO,
3859 .group = FIO_OPT_G_RATE,
3860 },
3861 {
3862 .name = "rate_iops_min",
3863 .lname = "I/O min rate IOPS",
3864 .type = FIO_OPT_INT,
3865 .off1 = offsetof(struct thread_options, rate_iops_min[DDIR_READ]),
3866 .off2 = offsetof(struct thread_options, rate_iops_min[DDIR_WRITE]),
3867 .off3 = offsetof(struct thread_options, rate_iops_min[DDIR_TRIM]),
3868 .help = "Job must meet this rate or it will be shut down",
3869 .parent = "rate_iops",
3870 .hide = 1,
3871 .category = FIO_OPT_C_IO,
3872 .group = FIO_OPT_G_RATE,
3873 },
3874 {
3875 .name = "rate_process",
3876 .lname = "Rate Process",
3877 .type = FIO_OPT_STR,
3878 .off1 = offsetof(struct thread_options, rate_process),
3879 .help = "What process controls how rated IO is managed",
3880 .def = "linear",
3881 .category = FIO_OPT_C_IO,
3882 .group = FIO_OPT_G_RATE,
3883 .posval = {
3884 { .ival = "linear",
3885 .oval = RATE_PROCESS_LINEAR,
3886 .help = "Linear rate of IO",
3887 },
3888 {
3889 .ival = "poisson",
3890 .oval = RATE_PROCESS_POISSON,
3891 .help = "Rate follows Poisson process",
3892 },
3893 },
3894 .parent = "rate",
3895 },
3896 {
3897 .name = "rate_cycle",
3898 .alias = "ratecycle",
3899 .lname = "I/O rate cycle",
3900 .type = FIO_OPT_INT,
3901 .off1 = offsetof(struct thread_options, ratecycle),
3902 .help = "Window average for rate limits (msec)",
3903 .def = "1000",
3904 .parent = "rate",
3905 .hide = 1,
3906 .category = FIO_OPT_C_IO,
3907 .group = FIO_OPT_G_RATE,
3908 },
3909 {
3910 .name = "rate_ignore_thinktime",
3911 .lname = "Rate ignore thinktime",
3912 .type = FIO_OPT_BOOL,
3913 .off1 = offsetof(struct thread_options, rate_ign_think),
3914 .help = "Rated IO ignores thinktime settings",
3915 .parent = "rate",
3916 .category = FIO_OPT_C_IO,
3917 .group = FIO_OPT_G_RATE,
3918 },
3919 {
3920 .name = "max_latency",
3921 .lname = "Max Latency (usec)",
3922 .type = FIO_OPT_ULL,
3923 .off1 = offsetof(struct thread_options, max_latency[DDIR_READ]),
3924 .off2 = offsetof(struct thread_options, max_latency[DDIR_WRITE]),
3925 .off3 = offsetof(struct thread_options, max_latency[DDIR_TRIM]),
3926 .help = "Maximum tolerated IO latency (usec)",
3927 .is_time = 1,
3928 .category = FIO_OPT_C_IO,
3929 .group = FIO_OPT_G_LATPROF,
3930 },
3931 {
3932 .name = "latency_target",
3933 .lname = "Latency Target (usec)",
3934 .type = FIO_OPT_STR_VAL_TIME,
3935 .off1 = offsetof(struct thread_options, latency_target),
3936 .help = "Ramp to max queue depth supporting this latency",
3937 .is_time = 1,
3938 .category = FIO_OPT_C_IO,
3939 .group = FIO_OPT_G_LATPROF,
3940 },
3941 {
3942 .name = "latency_window",
3943 .lname = "Latency Window (usec)",
3944 .type = FIO_OPT_STR_VAL_TIME,
3945 .off1 = offsetof(struct thread_options, latency_window),
3946 .help = "Time to sustain latency_target",
3947 .is_time = 1,
3948 .category = FIO_OPT_C_IO,
3949 .group = FIO_OPT_G_LATPROF,
3950 },
3951 {
3952 .name = "latency_percentile",
3953 .lname = "Latency Percentile",
3954 .type = FIO_OPT_FLOAT_LIST,
3955 .off1 = offsetof(struct thread_options, latency_percentile),
3956 .help = "Percentile of IOs must be below latency_target",
3957 .def = "100",
3958 .maxlen = 1,
3959 .minfp = 0.0,
3960 .maxfp = 100.0,
3961 .category = FIO_OPT_C_IO,
3962 .group = FIO_OPT_G_LATPROF,
3963 },
3964 {
3965 .name = "latency_run",
3966 .lname = "Latency Run",
3967 .type = FIO_OPT_BOOL,
3968 .off1 = offsetof(struct thread_options, latency_run),
3969 .help = "Keep adjusting queue depth to match latency_target",
3970 .def = "0",
3971 .category = FIO_OPT_C_IO,
3972 .group = FIO_OPT_G_LATPROF,
3973 },
3974 {
3975 .name = "invalidate",
3976 .lname = "Cache invalidate",
3977 .type = FIO_OPT_BOOL,
3978 .off1 = offsetof(struct thread_options, invalidate_cache),
3979 .help = "Invalidate buffer/page cache prior to running job",
3980 .def = "1",
3981 .category = FIO_OPT_C_IO,
3982 .group = FIO_OPT_G_IO_TYPE,
3983 },
3984 {
3985 .name = "sync",
3986 .lname = "Synchronous I/O",
3987 .type = FIO_OPT_STR,
3988 .off1 = offsetof(struct thread_options, sync_io),
3989 .help = "Use synchronous write IO",
3990 .def = "none",
3991 .hide = 1,
3992 .category = FIO_OPT_C_IO,
3993 .group = FIO_OPT_G_IO_TYPE,
3994 .posval = {
3995 { .ival = "none",
3996 .oval = 0,
3997 },
3998 { .ival = "0",
3999 .oval = 0,
4000 },
4001 { .ival = "sync",
4002 .oval = O_SYNC,
4003 },
4004 { .ival = "1",
4005 .oval = O_SYNC,
4006 },
4007#ifdef O_DSYNC
4008 { .ival = "dsync",
4009 .oval = O_DSYNC,
4010 },
4011#endif
4012 },
4013 },
4014#ifdef FIO_HAVE_WRITE_HINT
4015 {
4016 .name = "write_hint",
4017 .lname = "Write hint",
4018 .type = FIO_OPT_STR,
4019 .off1 = offsetof(struct thread_options, write_hint),
4020 .help = "Set expected write life time",
4021 .category = FIO_OPT_C_ENGINE,
4022 .group = FIO_OPT_G_INVALID,
4023 .posval = {
4024 { .ival = "none",
4025 .oval = RWH_WRITE_LIFE_NONE,
4026 },
4027 { .ival = "short",
4028 .oval = RWH_WRITE_LIFE_SHORT,
4029 },
4030 { .ival = "medium",
4031 .oval = RWH_WRITE_LIFE_MEDIUM,
4032 },
4033 { .ival = "long",
4034 .oval = RWH_WRITE_LIFE_LONG,
4035 },
4036 { .ival = "extreme",
4037 .oval = RWH_WRITE_LIFE_EXTREME,
4038 },
4039 },
4040 },
4041#endif
4042 {
4043 .name = "create_serialize",
4044 .lname = "Create serialize",
4045 .type = FIO_OPT_BOOL,
4046 .off1 = offsetof(struct thread_options, create_serialize),
4047 .help = "Serialize creation of job files",
4048 .def = "1",
4049 .category = FIO_OPT_C_FILE,
4050 .group = FIO_OPT_G_INVALID,
4051 },
4052 {
4053 .name = "create_fsync",
4054 .lname = "Create fsync",
4055 .type = FIO_OPT_BOOL,
4056 .off1 = offsetof(struct thread_options, create_fsync),
4057 .help = "fsync file after creation",
4058 .def = "1",
4059 .category = FIO_OPT_C_FILE,
4060 .group = FIO_OPT_G_INVALID,
4061 },
4062 {
4063 .name = "create_on_open",
4064 .lname = "Create on open",
4065 .type = FIO_OPT_BOOL,
4066 .off1 = offsetof(struct thread_options, create_on_open),
4067 .help = "Create files when they are opened for IO",
4068 .def = "0",
4069 .category = FIO_OPT_C_FILE,
4070 .group = FIO_OPT_G_INVALID,
4071 },
4072 {
4073 .name = "create_only",
4074 .lname = "Create Only",
4075 .type = FIO_OPT_BOOL,
4076 .off1 = offsetof(struct thread_options, create_only),
4077 .help = "Only perform file creation phase",
4078 .category = FIO_OPT_C_FILE,
4079 .def = "0",
4080 },
4081 {
4082 .name = "allow_file_create",
4083 .lname = "Allow file create",
4084 .type = FIO_OPT_BOOL,
4085 .off1 = offsetof(struct thread_options, allow_create),
4086 .help = "Permit fio to create files, if they don't exist",
4087 .def = "1",
4088 .category = FIO_OPT_C_FILE,
4089 .group = FIO_OPT_G_FILENAME,
4090 },
4091 {
4092 .name = "allow_mounted_write",
4093 .lname = "Allow mounted write",
4094 .type = FIO_OPT_BOOL,
4095 .off1 = offsetof(struct thread_options, allow_mounted_write),
4096 .help = "Allow writes to a mounted partition",
4097 .def = "0",
4098 .category = FIO_OPT_C_FILE,
4099 .group = FIO_OPT_G_FILENAME,
4100 },
4101 {
4102 .name = "pre_read",
4103 .lname = "Pre-read files",
4104 .type = FIO_OPT_BOOL,
4105 .off1 = offsetof(struct thread_options, pre_read),
4106 .help = "Pre-read files before starting official testing",
4107 .def = "0",
4108 .category = FIO_OPT_C_FILE,
4109 .group = FIO_OPT_G_INVALID,
4110 },
4111#ifdef FIO_HAVE_CPU_AFFINITY
4112 {
4113 .name = "cpumask",
4114 .lname = "CPU mask",
4115 .type = FIO_OPT_INT,
4116 .cb = str_cpumask_cb,
4117 .off1 = offsetof(struct thread_options, cpumask),
4118 .help = "CPU affinity mask",
4119 .category = FIO_OPT_C_GENERAL,
4120 .group = FIO_OPT_G_CRED,
4121 },
4122 {
4123 .name = "cpus_allowed",
4124 .lname = "CPUs allowed",
4125 .type = FIO_OPT_STR,
4126 .cb = str_cpus_allowed_cb,
4127 .off1 = offsetof(struct thread_options, cpumask),
4128 .help = "Set CPUs allowed",
4129 .category = FIO_OPT_C_GENERAL,
4130 .group = FIO_OPT_G_CRED,
4131 },
4132 {
4133 .name = "cpus_allowed_policy",
4134 .lname = "CPUs allowed distribution policy",
4135 .type = FIO_OPT_STR,
4136 .off1 = offsetof(struct thread_options, cpus_allowed_policy),
4137 .help = "Distribution policy for cpus_allowed",
4138 .parent = "cpus_allowed",
4139 .prio = 1,
4140 .posval = {
4141 { .ival = "shared",
4142 .oval = FIO_CPUS_SHARED,
4143 .help = "Mask shared between threads",
4144 },
4145 { .ival = "split",
4146 .oval = FIO_CPUS_SPLIT,
4147 .help = "Mask split between threads",
4148 },
4149 },
4150 .category = FIO_OPT_C_GENERAL,
4151 .group = FIO_OPT_G_CRED,
4152 },
4153#else
4154 {
4155 .name = "cpumask",
4156 .lname = "CPU mask",
4157 .type = FIO_OPT_UNSUPPORTED,
4158 .help = "Your platform does not support CPU affinities",
4159 },
4160 {
4161 .name = "cpus_allowed",
4162 .lname = "CPUs allowed",
4163 .type = FIO_OPT_UNSUPPORTED,
4164 .help = "Your platform does not support CPU affinities",
4165 },
4166 {
4167 .name = "cpus_allowed_policy",
4168 .lname = "CPUs allowed distribution policy",
4169 .type = FIO_OPT_UNSUPPORTED,
4170 .help = "Your platform does not support CPU affinities",
4171 },
4172#endif
4173#ifdef CONFIG_LIBNUMA
4174 {
4175 .name = "numa_cpu_nodes",
4176 .lname = "NUMA CPU Nodes",
4177 .type = FIO_OPT_STR,
4178 .cb = str_numa_cpunodes_cb,
4179 .off1 = offsetof(struct thread_options, numa_cpunodes),
4180 .help = "NUMA CPU nodes bind",
4181 .category = FIO_OPT_C_GENERAL,
4182 .group = FIO_OPT_G_INVALID,
4183 },
4184 {
4185 .name = "numa_mem_policy",
4186 .lname = "NUMA Memory Policy",
4187 .type = FIO_OPT_STR,
4188 .cb = str_numa_mpol_cb,
4189 .off1 = offsetof(struct thread_options, numa_memnodes),
4190 .help = "NUMA memory policy setup",
4191 .category = FIO_OPT_C_GENERAL,
4192 .group = FIO_OPT_G_INVALID,
4193 },
4194#else
4195 {
4196 .name = "numa_cpu_nodes",
4197 .lname = "NUMA CPU Nodes",
4198 .type = FIO_OPT_UNSUPPORTED,
4199 .help = "Build fio with libnuma-dev(el) to enable this option",
4200 },
4201 {
4202 .name = "numa_mem_policy",
4203 .lname = "NUMA Memory Policy",
4204 .type = FIO_OPT_UNSUPPORTED,
4205 .help = "Build fio with libnuma-dev(el) to enable this option",
4206 },
4207#endif
4208#ifdef CONFIG_CUDA
4209 {
4210 .name = "gpu_dev_id",
4211 .lname = "GPU device ID",
4212 .type = FIO_OPT_INT,
4213 .off1 = offsetof(struct thread_options, gpu_dev_id),
4214 .help = "Set GPU device ID for GPUDirect RDMA",
4215 .def = "0",
4216 .category = FIO_OPT_C_GENERAL,
4217 .group = FIO_OPT_G_INVALID,
4218 },
4219#endif
4220 {
4221 .name = "end_fsync",
4222 .lname = "End fsync",
4223 .type = FIO_OPT_BOOL,
4224 .off1 = offsetof(struct thread_options, end_fsync),
4225 .help = "Include fsync at the end of job",
4226 .def = "0",
4227 .category = FIO_OPT_C_FILE,
4228 .group = FIO_OPT_G_INVALID,
4229 },
4230 {
4231 .name = "fsync_on_close",
4232 .lname = "Fsync on close",
4233 .type = FIO_OPT_BOOL,
4234 .off1 = offsetof(struct thread_options, fsync_on_close),
4235 .help = "fsync files on close",
4236 .def = "0",
4237 .category = FIO_OPT_C_FILE,
4238 .group = FIO_OPT_G_INVALID,
4239 },
4240 {
4241 .name = "unlink",
4242 .lname = "Unlink file",
4243 .type = FIO_OPT_BOOL,
4244 .off1 = offsetof(struct thread_options, unlink),
4245 .help = "Unlink created files after job has completed",
4246 .def = "0",
4247 .category = FIO_OPT_C_FILE,
4248 .group = FIO_OPT_G_INVALID,
4249 },
4250 {
4251 .name = "unlink_each_loop",
4252 .lname = "Unlink file after each loop of a job",
4253 .type = FIO_OPT_BOOL,
4254 .off1 = offsetof(struct thread_options, unlink_each_loop),
4255 .help = "Unlink created files after each loop in a job has completed",
4256 .def = "0",
4257 .category = FIO_OPT_C_FILE,
4258 .group = FIO_OPT_G_INVALID,
4259 },
4260 {
4261 .name = "exitall",
4262 .lname = "Exit-all on terminate",
4263 .type = FIO_OPT_STR_SET,
4264 .cb = str_exitall_cb,
4265 .help = "Terminate all jobs when one exits",
4266 .category = FIO_OPT_C_GENERAL,
4267 .group = FIO_OPT_G_PROCESS,
4268 },
4269 {
4270 .name = "exit_what",
4271 .lname = "What jobs to quit on terminate",
4272 .type = FIO_OPT_STR,
4273 .off1 = offsetof(struct thread_options, exit_what),
4274 .help = "Fine-grained control for exitall",
4275 .def = "group",
4276 .category = FIO_OPT_C_GENERAL,
4277 .group = FIO_OPT_G_PROCESS,
4278 .posval = {
4279 { .ival = "group",
4280 .oval = TERMINATE_GROUP,
4281 .help = "exit_all=1 default behaviour",
4282 },
4283 { .ival = "stonewall",
4284 .oval = TERMINATE_STONEWALL,
4285 .help = "quit all currently running jobs; continue with next stonewall",
4286 },
4287 { .ival = "all",
4288 .oval = TERMINATE_ALL,
4289 .help = "Quit everything",
4290 },
4291 },
4292 },
4293 {
4294 .name = "exitall_on_error",
4295 .lname = "Exit-all on terminate in error",
4296 .type = FIO_OPT_STR_SET,
4297 .off1 = offsetof(struct thread_options, exitall_error),
4298 .help = "Terminate all jobs when one exits in error",
4299 .category = FIO_OPT_C_GENERAL,
4300 .group = FIO_OPT_G_PROCESS,
4301 },
4302 {
4303 .name = "stonewall",
4304 .lname = "Wait for previous",
4305 .alias = "wait_for_previous",
4306 .type = FIO_OPT_STR_SET,
4307 .off1 = offsetof(struct thread_options, stonewall),
4308 .help = "Insert a hard barrier between this job and previous",
4309 .category = FIO_OPT_C_GENERAL,
4310 .group = FIO_OPT_G_PROCESS,
4311 },
4312 {
4313 .name = "new_group",
4314 .lname = "New group",
4315 .type = FIO_OPT_STR_SET,
4316 .off1 = offsetof(struct thread_options, new_group),
4317 .help = "Mark the start of a new group (for reporting)",
4318 .category = FIO_OPT_C_GENERAL,
4319 .group = FIO_OPT_G_PROCESS,
4320 },
4321 {
4322 .name = "thread",
4323 .lname = "Thread",
4324 .type = FIO_OPT_STR_SET,
4325 .off1 = offsetof(struct thread_options, use_thread),
4326 .help = "Use threads instead of processes",
4327#ifdef CONFIG_NO_SHM
4328 .def = "1",
4329 .no_warn_def = 1,
4330#endif
4331 .category = FIO_OPT_C_GENERAL,
4332 .group = FIO_OPT_G_PROCESS,
4333 },
4334 {
4335 .name = "per_job_logs",
4336 .lname = "Per Job Logs",
4337 .type = FIO_OPT_BOOL,
4338 .off1 = offsetof(struct thread_options, per_job_logs),
4339 .help = "Include job number in generated log files or not",
4340 .def = "1",
4341 .category = FIO_OPT_C_LOG,
4342 .group = FIO_OPT_G_INVALID,
4343 },
4344 {
4345 .name = "write_bw_log",
4346 .lname = "Write bandwidth log",
4347 .type = FIO_OPT_STR,
4348 .off1 = offsetof(struct thread_options, bw_log_file),
4349 .cb = str_write_bw_log_cb,
4350 .help = "Write log of bandwidth during run",
4351 .category = FIO_OPT_C_LOG,
4352 .group = FIO_OPT_G_INVALID,
4353 },
4354 {
4355 .name = "write_lat_log",
4356 .lname = "Write latency log",
4357 .type = FIO_OPT_STR,
4358 .off1 = offsetof(struct thread_options, lat_log_file),
4359 .cb = str_write_lat_log_cb,
4360 .help = "Write log of latency during run",
4361 .category = FIO_OPT_C_LOG,
4362 .group = FIO_OPT_G_INVALID,
4363 },
4364 {
4365 .name = "write_iops_log",
4366 .lname = "Write IOPS log",
4367 .type = FIO_OPT_STR,
4368 .off1 = offsetof(struct thread_options, iops_log_file),
4369 .cb = str_write_iops_log_cb,
4370 .help = "Write log of IOPS during run",
4371 .category = FIO_OPT_C_LOG,
4372 .group = FIO_OPT_G_INVALID,
4373 },
4374 {
4375 .name = "log_entries",
4376 .lname = "Log entries",
4377 .type = FIO_OPT_INT,
4378 .off1 = offsetof(struct thread_options, log_entries),
4379 .help = "Initial number of entries in a job IO log",
4380 .def = __fio_stringify(DEF_LOG_ENTRIES),
4381 .minval = DEF_LOG_ENTRIES,
4382 .maxval = MAX_LOG_ENTRIES,
4383 .category = FIO_OPT_C_LOG,
4384 .group = FIO_OPT_G_INVALID,
4385 },
4386 {
4387 .name = "log_avg_msec",
4388 .lname = "Log averaging (msec)",
4389 .type = FIO_OPT_INT,
4390 .off1 = offsetof(struct thread_options, log_avg_msec),
4391 .help = "Average bw/iops/lat logs over this period of time",
4392 .def = "0",
4393 .category = FIO_OPT_C_LOG,
4394 .group = FIO_OPT_G_INVALID,
4395 },
4396 {
4397 .name = "log_hist_msec",
4398 .lname = "Log histograms (msec)",
4399 .type = FIO_OPT_INT,
4400 .off1 = offsetof(struct thread_options, log_hist_msec),
4401 .help = "Dump completion latency histograms at frequency of this time value",
4402 .def = "0",
4403 .category = FIO_OPT_C_LOG,
4404 .group = FIO_OPT_G_INVALID,
4405 },
4406 {
4407 .name = "log_hist_coarseness",
4408 .lname = "Histogram logs coarseness",
4409 .type = FIO_OPT_INT,
4410 .off1 = offsetof(struct thread_options, log_hist_coarseness),
4411 .help = "Integer in range [0,6]. Higher coarseness outputs"
4412 " fewer histogram bins per sample. The number of bins for"
4413 " these are [1216, 608, 304, 152, 76, 38, 19] respectively.",
4414 .def = "0",
4415 .category = FIO_OPT_C_LOG,
4416 .group = FIO_OPT_G_INVALID,
4417 },
4418 {
4419 .name = "write_hist_log",
4420 .lname = "Write latency histogram logs",
4421 .type = FIO_OPT_STR,
4422 .off1 = offsetof(struct thread_options, hist_log_file),
4423 .cb = str_write_hist_log_cb,
4424 .help = "Write log of latency histograms during run",
4425 .category = FIO_OPT_C_LOG,
4426 .group = FIO_OPT_G_INVALID,
4427 },
4428 {
4429 .name = "log_max_value",
4430 .lname = "Log maximum instead of average",
4431 .type = FIO_OPT_BOOL,
4432 .off1 = offsetof(struct thread_options, log_max),
4433 .help = "Log max sample in a window instead of average",
4434 .def = "0",
4435 .category = FIO_OPT_C_LOG,
4436 .group = FIO_OPT_G_INVALID,
4437 },
4438 {
4439 .name = "log_offset",
4440 .lname = "Log offset of IO",
4441 .type = FIO_OPT_BOOL,
4442 .off1 = offsetof(struct thread_options, log_offset),
4443 .help = "Include offset of IO for each log entry",
4444 .def = "0",
4445 .category = FIO_OPT_C_LOG,
4446 .group = FIO_OPT_G_INVALID,
4447 },
4448 {
4449 .name = "log_prio",
4450 .lname = "Log priority of IO",
4451 .type = FIO_OPT_BOOL,
4452 .off1 = offsetof(struct thread_options, log_prio),
4453 .help = "Include priority value of IO for each log entry",
4454 .def = "0",
4455 .category = FIO_OPT_C_LOG,
4456 .group = FIO_OPT_G_INVALID,
4457 },
4458#ifdef CONFIG_ZLIB
4459 {
4460 .name = "log_compression",
4461 .lname = "Log compression",
4462 .type = FIO_OPT_INT,
4463 .off1 = offsetof(struct thread_options, log_gz),
4464 .help = "Log in compressed chunks of this size",
4465 .minval = 1024ULL,
4466 .maxval = 512 * 1024 * 1024ULL,
4467 .category = FIO_OPT_C_LOG,
4468 .group = FIO_OPT_G_INVALID,
4469 },
4470#ifdef FIO_HAVE_CPU_AFFINITY
4471 {
4472 .name = "log_compression_cpus",
4473 .lname = "Log Compression CPUs",
4474 .type = FIO_OPT_STR,
4475 .cb = str_log_cpus_allowed_cb,
4476 .off1 = offsetof(struct thread_options, log_gz_cpumask),
4477 .parent = "log_compression",
4478 .help = "Limit log compression to these CPUs",
4479 .category = FIO_OPT_C_LOG,
4480 .group = FIO_OPT_G_INVALID,
4481 },
4482#else
4483 {
4484 .name = "log_compression_cpus",
4485 .lname = "Log Compression CPUs",
4486 .type = FIO_OPT_UNSUPPORTED,
4487 .help = "Your platform does not support CPU affinities",
4488 },
4489#endif
4490 {
4491 .name = "log_store_compressed",
4492 .lname = "Log store compressed",
4493 .type = FIO_OPT_BOOL,
4494 .off1 = offsetof(struct thread_options, log_gz_store),
4495 .help = "Store logs in a compressed format",
4496 .category = FIO_OPT_C_LOG,
4497 .group = FIO_OPT_G_INVALID,
4498 },
4499#else
4500 {
4501 .name = "log_compression",
4502 .lname = "Log compression",
4503 .type = FIO_OPT_UNSUPPORTED,
4504 .help = "Install libz-dev(el) to get compression support",
4505 },
4506 {
4507 .name = "log_store_compressed",
4508 .lname = "Log store compressed",
4509 .type = FIO_OPT_UNSUPPORTED,
4510 .help = "Install libz-dev(el) to get compression support",
4511 },
4512#endif
4513 {
4514 .name = "log_unix_epoch",
4515 .lname = "Log epoch unix",
4516 .type = FIO_OPT_BOOL,
4517 .off1 = offsetof(struct thread_options, log_unix_epoch),
4518 .help = "Use Unix time in log files",
4519 .category = FIO_OPT_C_LOG,
4520 .group = FIO_OPT_G_INVALID,
4521 },
4522 {
4523 .name = "log_alternate_epoch",
4524 .lname = "Log epoch alternate",
4525 .type = FIO_OPT_BOOL,
4526 .off1 = offsetof(struct thread_options, log_alternate_epoch),
4527 .help = "Use alternate epoch time in log files. Uses the same epoch as that is used by clock_gettime with specified log_alternate_epoch_clock_id.",
4528 .category = FIO_OPT_C_LOG,
4529 .group = FIO_OPT_G_INVALID,
4530 },
4531 {
4532 .name = "log_alternate_epoch_clock_id",
4533 .lname = "Log alternate epoch clock_id",
4534 .type = FIO_OPT_INT,
4535 .off1 = offsetof(struct thread_options, log_alternate_epoch_clock_id),
4536 .help = "If log_alternate_epoch or log_unix_epoch is true, this option specifies the clock_id from clock_gettime whose epoch should be used. If neither of those is true, this option has no effect. Default value is 0, or CLOCK_REALTIME",
4537 .category = FIO_OPT_C_LOG,
4538 .group = FIO_OPT_G_INVALID,
4539 },
4540 {
4541 .name = "block_error_percentiles",
4542 .lname = "Block error percentiles",
4543 .type = FIO_OPT_BOOL,
4544 .off1 = offsetof(struct thread_options, block_error_hist),
4545 .help = "Record trim block errors and make a histogram",
4546 .def = "0",
4547 .category = FIO_OPT_C_LOG,
4548 .group = FIO_OPT_G_INVALID,
4549 },
4550 {
4551 .name = "bwavgtime",
4552 .lname = "Bandwidth average time",
4553 .type = FIO_OPT_INT,
4554 .off1 = offsetof(struct thread_options, bw_avg_time),
4555 .help = "Time window over which to calculate bandwidth"
4556 " (msec)",
4557 .def = "500",
4558 .parent = "write_bw_log",
4559 .hide = 1,
4560 .interval = 100,
4561 .category = FIO_OPT_C_LOG,
4562 .group = FIO_OPT_G_INVALID,
4563 },
4564 {
4565 .name = "iopsavgtime",
4566 .lname = "IOPS average time",
4567 .type = FIO_OPT_INT,
4568 .off1 = offsetof(struct thread_options, iops_avg_time),
4569 .help = "Time window over which to calculate IOPS (msec)",
4570 .def = "500",
4571 .parent = "write_iops_log",
4572 .hide = 1,
4573 .interval = 100,
4574 .category = FIO_OPT_C_LOG,
4575 .group = FIO_OPT_G_INVALID,
4576 },
4577 {
4578 .name = "group_reporting",
4579 .lname = "Group reporting",
4580 .type = FIO_OPT_STR_SET,
4581 .off1 = offsetof(struct thread_options, group_reporting),
4582 .help = "Do reporting on a per-group basis",
4583 .category = FIO_OPT_C_STAT,
4584 .group = FIO_OPT_G_INVALID,
4585 },
4586 {
4587 .name = "stats",
4588 .lname = "Stats",
4589 .type = FIO_OPT_BOOL,
4590 .off1 = offsetof(struct thread_options, stats),
4591 .help = "Enable collection of stats",
4592 .def = "1",
4593 .category = FIO_OPT_C_STAT,
4594 .group = FIO_OPT_G_INVALID,
4595 },
4596 {
4597 .name = "zero_buffers",
4598 .lname = "Zero I/O buffers",
4599 .type = FIO_OPT_STR_SET,
4600 .off1 = offsetof(struct thread_options, zero_buffers),
4601 .help = "Init IO buffers to all zeroes",
4602 .category = FIO_OPT_C_IO,
4603 .group = FIO_OPT_G_IO_BUF,
4604 },
4605 {
4606 .name = "refill_buffers",
4607 .lname = "Refill I/O buffers",
4608 .type = FIO_OPT_STR_SET,
4609 .off1 = offsetof(struct thread_options, refill_buffers),
4610 .help = "Refill IO buffers on every IO submit",
4611 .category = FIO_OPT_C_IO,
4612 .group = FIO_OPT_G_IO_BUF,
4613 },
4614 {
4615 .name = "scramble_buffers",
4616 .lname = "Scramble I/O buffers",
4617 .type = FIO_OPT_BOOL,
4618 .off1 = offsetof(struct thread_options, scramble_buffers),
4619 .help = "Slightly scramble buffers on every IO submit",
4620 .def = "1",
4621 .category = FIO_OPT_C_IO,
4622 .group = FIO_OPT_G_IO_BUF,
4623 },
4624 {
4625 .name = "buffer_pattern",
4626 .lname = "Buffer pattern",
4627 .type = FIO_OPT_STR,
4628 .cb = str_buffer_pattern_cb,
4629 .off1 = offsetof(struct thread_options, buffer_pattern),
4630 .help = "Fill pattern for IO buffers",
4631 .category = FIO_OPT_C_IO,
4632 .group = FIO_OPT_G_IO_BUF,
4633 },
4634 {
4635 .name = "buffer_compress_percentage",
4636 .lname = "Buffer compression percentage",
4637 .type = FIO_OPT_INT,
4638 .cb = str_buffer_compress_cb,
4639 .off1 = offsetof(struct thread_options, compress_percentage),
4640 .maxval = 100,
4641 .minval = 0,
4642 .help = "How compressible the buffer is (approximately)",
4643 .interval = 5,
4644 .category = FIO_OPT_C_IO,
4645 .group = FIO_OPT_G_IO_BUF,
4646 },
4647 {
4648 .name = "buffer_compress_chunk",
4649 .lname = "Buffer compression chunk size",
4650 .type = FIO_OPT_INT,
4651 .off1 = offsetof(struct thread_options, compress_chunk),
4652 .parent = "buffer_compress_percentage",
4653 .hide = 1,
4654 .help = "Size of compressible region in buffer",
4655 .def = "512",
4656 .interval = 256,
4657 .category = FIO_OPT_C_IO,
4658 .group = FIO_OPT_G_IO_BUF,
4659 },
4660 {
4661 .name = "dedupe_percentage",
4662 .lname = "Dedupe percentage",
4663 .type = FIO_OPT_INT,
4664 .cb = str_dedupe_cb,
4665 .off1 = offsetof(struct thread_options, dedupe_percentage),
4666 .maxval = 100,
4667 .minval = 0,
4668 .help = "Percentage of buffers that are dedupable",
4669 .interval = 1,
4670 .category = FIO_OPT_C_IO,
4671 .group = FIO_OPT_G_IO_BUF,
4672 },
4673 {
4674 .name = "dedupe_global",
4675 .lname = "Global deduplication",
4676 .type = FIO_OPT_BOOL,
4677 .off1 = offsetof(struct thread_options, dedupe_global),
4678 .help = "Share deduplication buffers across jobs",
4679 .def = "0",
4680 .category = FIO_OPT_C_IO,
4681 .group = FIO_OPT_G_IO_BUF,
4682 },
4683 {
4684 .name = "dedupe_mode",
4685 .lname = "Dedupe mode",
4686 .help = "Mode for the deduplication buffer generation",
4687 .type = FIO_OPT_STR,
4688 .off1 = offsetof(struct thread_options, dedupe_mode),
4689 .parent = "dedupe_percentage",
4690 .def = "repeat",
4691 .category = FIO_OPT_C_IO,
4692 .group = FIO_OPT_G_IO_BUF,
4693 .posval = {
4694 { .ival = "repeat",
4695 .oval = DEDUPE_MODE_REPEAT,
4696 .help = "repeat previous page",
4697 },
4698 { .ival = "working_set",
4699 .oval = DEDUPE_MODE_WORKING_SET,
4700 .help = "choose a page randomly from limited working set defined in dedupe_working_set_percentage",
4701 },
4702 },
4703 },
4704 {
4705 .name = "dedupe_working_set_percentage",
4706 .lname = "Dedupe working set percentage",
4707 .help = "Dedupe working set size in percentages from file or device size used to generate dedupe patterns from",
4708 .type = FIO_OPT_INT,
4709 .off1 = offsetof(struct thread_options, dedupe_working_set_percentage),
4710 .parent = "dedupe_percentage",
4711 .def = "5",
4712 .maxval = 100,
4713 .minval = 0,
4714 .category = FIO_OPT_C_IO,
4715 .group = FIO_OPT_G_IO_BUF,
4716 },
4717 {
4718 .name = "clat_percentiles",
4719 .lname = "Completion latency percentiles",
4720 .type = FIO_OPT_BOOL,
4721 .off1 = offsetof(struct thread_options, clat_percentiles),
4722 .help = "Enable the reporting of completion latency percentiles",
4723 .def = "1",
4724 .category = FIO_OPT_C_STAT,
4725 .group = FIO_OPT_G_INVALID,
4726 },
4727 {
4728 .name = "lat_percentiles",
4729 .lname = "IO latency percentiles",
4730 .type = FIO_OPT_BOOL,
4731 .off1 = offsetof(struct thread_options, lat_percentiles),
4732 .help = "Enable the reporting of IO latency percentiles",
4733 .def = "0",
4734 .category = FIO_OPT_C_STAT,
4735 .group = FIO_OPT_G_INVALID,
4736 },
4737 {
4738 .name = "slat_percentiles",
4739 .lname = "Submission latency percentiles",
4740 .type = FIO_OPT_BOOL,
4741 .off1 = offsetof(struct thread_options, slat_percentiles),
4742 .help = "Enable the reporting of submission latency percentiles",
4743 .def = "0",
4744 .category = FIO_OPT_C_STAT,
4745 .group = FIO_OPT_G_INVALID,
4746 },
4747 {
4748 .name = "percentile_list",
4749 .lname = "Percentile list",
4750 .type = FIO_OPT_FLOAT_LIST,
4751 .off1 = offsetof(struct thread_options, percentile_list),
4752 .off2 = offsetof(struct thread_options, percentile_precision),
4753 .help = "Specify a custom list of percentiles to report for "
4754 "completion latency and block errors",
4755 .def = "1:5:10:20:30:40:50:60:70:80:90:95:99:99.5:99.9:99.95:99.99",
4756 .maxlen = FIO_IO_U_LIST_MAX_LEN,
4757 .minfp = 0.0,
4758 .maxfp = 100.0,
4759 .category = FIO_OPT_C_STAT,
4760 .group = FIO_OPT_G_INVALID,
4761 },
4762 {
4763 .name = "significant_figures",
4764 .lname = "Significant figures",
4765 .type = FIO_OPT_INT,
4766 .off1 = offsetof(struct thread_options, sig_figs),
4767 .maxval = 10,
4768 .minval = 1,
4769 .help = "Significant figures for output-format set to normal",
4770 .def = "4",
4771 .interval = 1,
4772 .category = FIO_OPT_C_STAT,
4773 .group = FIO_OPT_G_INVALID,
4774 },
4775
4776#ifdef FIO_HAVE_DISK_UTIL
4777 {
4778 .name = "disk_util",
4779 .lname = "Disk utilization",
4780 .type = FIO_OPT_BOOL,
4781 .off1 = offsetof(struct thread_options, do_disk_util),
4782 .help = "Log disk utilization statistics",
4783 .def = "1",
4784 .category = FIO_OPT_C_STAT,
4785 .group = FIO_OPT_G_INVALID,
4786 },
4787#else
4788 {
4789 .name = "disk_util",
4790 .lname = "Disk utilization",
4791 .type = FIO_OPT_UNSUPPORTED,
4792 .help = "Your platform does not support disk utilization",
4793 },
4794#endif
4795 {
4796 .name = "gtod_reduce",
4797 .lname = "Reduce gettimeofday() calls",
4798 .type = FIO_OPT_BOOL,
4799 .help = "Greatly reduce number of gettimeofday() calls",
4800 .cb = str_gtod_reduce_cb,
4801 .def = "0",
4802 .hide_on_set = 1,
4803 .category = FIO_OPT_C_STAT,
4804 .group = FIO_OPT_G_INVALID,
4805 },
4806 {
4807 .name = "disable_lat",
4808 .lname = "Disable all latency stats",
4809 .type = FIO_OPT_BOOL,
4810 .off1 = offsetof(struct thread_options, disable_lat),
4811 .help = "Disable latency numbers",
4812 .parent = "gtod_reduce",
4813 .hide = 1,
4814 .def = "0",
4815 .category = FIO_OPT_C_STAT,
4816 .group = FIO_OPT_G_INVALID,
4817 },
4818 {
4819 .name = "disable_clat",
4820 .lname = "Disable completion latency stats",
4821 .type = FIO_OPT_BOOL,
4822 .off1 = offsetof(struct thread_options, disable_clat),
4823 .help = "Disable completion latency numbers",
4824 .parent = "gtod_reduce",
4825 .hide = 1,
4826 .def = "0",
4827 .category = FIO_OPT_C_STAT,
4828 .group = FIO_OPT_G_INVALID,
4829 },
4830 {
4831 .name = "disable_slat",
4832 .lname = "Disable submission latency stats",
4833 .type = FIO_OPT_BOOL,
4834 .off1 = offsetof(struct thread_options, disable_slat),
4835 .help = "Disable submission latency numbers",
4836 .parent = "gtod_reduce",
4837 .hide = 1,
4838 .def = "0",
4839 .category = FIO_OPT_C_STAT,
4840 .group = FIO_OPT_G_INVALID,
4841 },
4842 {
4843 .name = "disable_bw_measurement",
4844 .alias = "disable_bw",
4845 .lname = "Disable bandwidth stats",
4846 .type = FIO_OPT_BOOL,
4847 .off1 = offsetof(struct thread_options, disable_bw),
4848 .help = "Disable bandwidth logging",
4849 .parent = "gtod_reduce",
4850 .hide = 1,
4851 .def = "0",
4852 .category = FIO_OPT_C_STAT,
4853 .group = FIO_OPT_G_INVALID,
4854 },
4855 {
4856 .name = "gtod_cpu",
4857 .lname = "Dedicated gettimeofday() CPU",
4858 .type = FIO_OPT_INT,
4859 .off1 = offsetof(struct thread_options, gtod_cpu),
4860 .help = "Set up dedicated gettimeofday() thread on this CPU",
4861 .verify = gtod_cpu_verify,
4862 .category = FIO_OPT_C_GENERAL,
4863 .group = FIO_OPT_G_CLOCK,
4864 },
4865 {
4866 .name = "unified_rw_reporting",
4867 .lname = "Unified RW Reporting",
4868 .type = FIO_OPT_STR,
4869 .off1 = offsetof(struct thread_options, unified_rw_rep),
4870 .help = "Unify reporting across data direction",
4871 .def = "none",
4872 .category = FIO_OPT_C_GENERAL,
4873 .group = FIO_OPT_G_INVALID,
4874 .posval = {
4875 { .ival = "none",
4876 .oval = UNIFIED_SPLIT,
4877 .help = "Normal statistics reporting",
4878 },
4879 { .ival = "mixed",
4880 .oval = UNIFIED_MIXED,
4881 .help = "Statistics are summed per data direction and reported together",
4882 },
4883 { .ival = "both",
4884 .oval = UNIFIED_BOTH,
4885 .help = "Statistics are reported normally, followed by the mixed statistics"
4886 },
4887 /* Compatibility with former boolean values */
4888 { .ival = "0",
4889 .oval = UNIFIED_SPLIT,
4890 .help = "Alias for 'none'",
4891 },
4892 { .ival = "1",
4893 .oval = UNIFIED_MIXED,
4894 .help = "Alias for 'mixed'",
4895 },
4896 { .ival = "2",
4897 .oval = UNIFIED_BOTH,
4898 .help = "Alias for 'both'",
4899 },
4900 },
4901 },
4902 {
4903 .name = "continue_on_error",
4904 .lname = "Continue on error",
4905 .type = FIO_OPT_STR,
4906 .off1 = offsetof(struct thread_options, continue_on_error),
4907 .help = "Continue on non-fatal errors during IO",
4908 .def = "none",
4909 .category = FIO_OPT_C_GENERAL,
4910 .group = FIO_OPT_G_ERR,
4911 .posval = {
4912 { .ival = "none",
4913 .oval = ERROR_TYPE_NONE,
4914 .help = "Exit when an error is encountered",
4915 },
4916 { .ival = "read",
4917 .oval = ERROR_TYPE_READ,
4918 .help = "Continue on read errors only",
4919 },
4920 { .ival = "write",
4921 .oval = ERROR_TYPE_WRITE,
4922 .help = "Continue on write errors only",
4923 },
4924 { .ival = "io",
4925 .oval = ERROR_TYPE_READ | ERROR_TYPE_WRITE,
4926 .help = "Continue on any IO errors",
4927 },
4928 { .ival = "verify",
4929 .oval = ERROR_TYPE_VERIFY,
4930 .help = "Continue on verify errors only",
4931 },
4932 { .ival = "all",
4933 .oval = ERROR_TYPE_ANY,
4934 .help = "Continue on all io and verify errors",
4935 },
4936 { .ival = "0",
4937 .oval = ERROR_TYPE_NONE,
4938 .help = "Alias for 'none'",
4939 },
4940 { .ival = "1",
4941 .oval = ERROR_TYPE_ANY,
4942 .help = "Alias for 'all'",
4943 },
4944 },
4945 },
4946 {
4947 .name = "ignore_error",
4948 .lname = "Ignore Error",
4949 .type = FIO_OPT_STR,
4950 .cb = str_ignore_error_cb,
4951 .off1 = offsetof(struct thread_options, ignore_error_nr),
4952 .help = "Set a specific list of errors to ignore",
4953 .parent = "rw",
4954 .category = FIO_OPT_C_GENERAL,
4955 .group = FIO_OPT_G_ERR,
4956 },
4957 {
4958 .name = "error_dump",
4959 .lname = "Error Dump",
4960 .type = FIO_OPT_BOOL,
4961 .off1 = offsetof(struct thread_options, error_dump),
4962 .def = "0",
4963 .help = "Dump info on each error",
4964 .category = FIO_OPT_C_GENERAL,
4965 .group = FIO_OPT_G_ERR,
4966 },
4967 {
4968 .name = "profile",
4969 .lname = "Profile",
4970 .type = FIO_OPT_STR_STORE,
4971 .off1 = offsetof(struct thread_options, profile),
4972 .help = "Select a specific builtin performance test",
4973 .category = FIO_OPT_C_PROFILE,
4974 .group = FIO_OPT_G_INVALID,
4975 },
4976 {
4977 .name = "cgroup",
4978 .lname = "Cgroup",
4979 .type = FIO_OPT_STR_STORE,
4980 .off1 = offsetof(struct thread_options, cgroup),
4981 .help = "Add job to cgroup of this name",
4982 .category = FIO_OPT_C_GENERAL,
4983 .group = FIO_OPT_G_CGROUP,
4984 },
4985 {
4986 .name = "cgroup_nodelete",
4987 .lname = "Cgroup no-delete",
4988 .type = FIO_OPT_BOOL,
4989 .off1 = offsetof(struct thread_options, cgroup_nodelete),
4990 .help = "Do not delete cgroups after job completion",
4991 .def = "0",
4992 .parent = "cgroup",
4993 .category = FIO_OPT_C_GENERAL,
4994 .group = FIO_OPT_G_CGROUP,
4995 },
4996 {
4997 .name = "cgroup_weight",
4998 .lname = "Cgroup weight",
4999 .type = FIO_OPT_INT,
5000 .off1 = offsetof(struct thread_options, cgroup_weight),
5001 .help = "Use given weight for cgroup",
5002 .minval = 100,
5003 .maxval = 1000,
5004 .parent = "cgroup",
5005 .category = FIO_OPT_C_GENERAL,
5006 .group = FIO_OPT_G_CGROUP,
5007 },
5008 {
5009 .name = "uid",
5010 .lname = "User ID",
5011 .type = FIO_OPT_INT,
5012 .off1 = offsetof(struct thread_options, uid),
5013 .help = "Run job with this user ID",
5014 .category = FIO_OPT_C_GENERAL,
5015 .group = FIO_OPT_G_CRED,
5016 },
5017 {
5018 .name = "gid",
5019 .lname = "Group ID",
5020 .type = FIO_OPT_INT,
5021 .off1 = offsetof(struct thread_options, gid),
5022 .help = "Run job with this group ID",
5023 .category = FIO_OPT_C_GENERAL,
5024 .group = FIO_OPT_G_CRED,
5025 },
5026 {
5027 .name = "kb_base",
5028 .lname = "KB Base",
5029 .type = FIO_OPT_STR,
5030 .off1 = offsetof(struct thread_options, kb_base),
5031 .prio = 1,
5032 .def = "1024",
5033 .posval = {
5034 { .ival = "1024",
5035 .oval = 1024,
5036 .help = "Inputs invert IEC and SI prefixes (for compatibility); outputs prefer binary",
5037 },
5038 { .ival = "1000",
5039 .oval = 1000,
5040 .help = "Inputs use IEC and SI prefixes; outputs prefer SI",
5041 },
5042 },
5043 .help = "Unit prefix interpretation for quantities of data (IEC and SI)",
5044 .category = FIO_OPT_C_GENERAL,
5045 .group = FIO_OPT_G_INVALID,
5046 },
5047 {
5048 .name = "unit_base",
5049 .lname = "Unit for quantities of data (Bits or Bytes)",
5050 .type = FIO_OPT_STR,
5051 .off1 = offsetof(struct thread_options, unit_base),
5052 .prio = 1,
5053 .posval = {
5054 { .ival = "0",
5055 .oval = N2S_NONE,
5056 .help = "Auto-detect",
5057 },
5058 { .ival = "8",
5059 .oval = N2S_BYTEPERSEC,
5060 .help = "Normal (byte based)",
5061 },
5062 { .ival = "1",
5063 .oval = N2S_BITPERSEC,
5064 .help = "Bit based",
5065 },
5066 },
5067 .help = "Bit multiple of result summary data (8 for byte, 1 for bit)",
5068 .category = FIO_OPT_C_GENERAL,
5069 .group = FIO_OPT_G_INVALID,
5070 },
5071 {
5072 .name = "hugepage-size",
5073 .lname = "Hugepage size",
5074 .type = FIO_OPT_INT,
5075 .off1 = offsetof(struct thread_options, hugepage_size),
5076 .help = "When using hugepages, specify size of each page",
5077 .def = __fio_stringify(FIO_HUGE_PAGE),
5078 .interval = 1024 * 1024,
5079 .category = FIO_OPT_C_GENERAL,
5080 .group = FIO_OPT_G_INVALID,
5081 },
5082 {
5083 .name = "flow_id",
5084 .lname = "I/O flow ID",
5085 .type = FIO_OPT_INT,
5086 .off1 = offsetof(struct thread_options, flow_id),
5087 .help = "The flow index ID to use",
5088 .def = "0",
5089 .category = FIO_OPT_C_IO,
5090 .group = FIO_OPT_G_IO_FLOW,
5091 },
5092 {
5093 .name = "flow",
5094 .lname = "I/O flow weight",
5095 .type = FIO_OPT_INT,
5096 .off1 = offsetof(struct thread_options, flow),
5097 .help = "Weight for flow control of this job",
5098 .parent = "flow_id",
5099 .hide = 1,
5100 .def = "0",
5101 .maxval = FLOW_MAX_WEIGHT,
5102 .category = FIO_OPT_C_IO,
5103 .group = FIO_OPT_G_IO_FLOW,
5104 },
5105 {
5106 .name = "flow_watermark",
5107 .lname = "I/O flow watermark",
5108 .type = FIO_OPT_SOFT_DEPRECATED,
5109 .category = FIO_OPT_C_IO,
5110 .group = FIO_OPT_G_IO_FLOW,
5111 },
5112 {
5113 .name = "flow_sleep",
5114 .lname = "I/O flow sleep",
5115 .type = FIO_OPT_INT,
5116 .off1 = offsetof(struct thread_options, flow_sleep),
5117 .help = "How many microseconds to sleep after being held"
5118 " back by the flow control mechanism",
5119 .parent = "flow_id",
5120 .hide = 1,
5121 .def = "0",
5122 .category = FIO_OPT_C_IO,
5123 .group = FIO_OPT_G_IO_FLOW,
5124 },
5125 {
5126 .name = "steadystate",
5127 .lname = "Steady state threshold",
5128 .alias = "ss",
5129 .type = FIO_OPT_STR,
5130 .off1 = offsetof(struct thread_options, ss_state),
5131 .cb = str_steadystate_cb,
5132 .help = "Define the criterion and limit to judge when a job has reached steady state",
5133 .def = "iops_slope:0.01%",
5134 .posval = {
5135 { .ival = "iops",
5136 .oval = FIO_SS_IOPS,
5137 .help = "maximum mean deviation of IOPS measurements",
5138 },
5139 { .ival = "iops_slope",
5140 .oval = FIO_SS_IOPS_SLOPE,
5141 .help = "slope calculated from IOPS measurements",
5142 },
5143 { .ival = "bw",
5144 .oval = FIO_SS_BW,
5145 .help = "maximum mean deviation of bandwidth measurements",
5146 },
5147 {
5148 .ival = "bw_slope",
5149 .oval = FIO_SS_BW_SLOPE,
5150 .help = "slope calculated from bandwidth measurements",
5151 },
5152 },
5153 .category = FIO_OPT_C_GENERAL,
5154 .group = FIO_OPT_G_RUNTIME,
5155 },
5156 {
5157 .name = "steadystate_duration",
5158 .lname = "Steady state duration",
5159 .alias = "ss_dur",
5160 .parent = "steadystate",
5161 .type = FIO_OPT_STR_VAL_TIME,
5162 .off1 = offsetof(struct thread_options, ss_dur),
5163 .help = "Stop workload upon attaining steady state for specified duration",
5164 .def = "0",
5165 .is_seconds = 1,
5166 .is_time = 1,
5167 .category = FIO_OPT_C_GENERAL,
5168 .group = FIO_OPT_G_RUNTIME,
5169 },
5170 {
5171 .name = "steadystate_ramp_time",
5172 .lname = "Steady state ramp time",
5173 .alias = "ss_ramp",
5174 .parent = "steadystate",
5175 .type = FIO_OPT_STR_VAL_TIME,
5176 .off1 = offsetof(struct thread_options, ss_ramp_time),
5177 .help = "Delay before initiation of data collection for steady state job termination testing",
5178 .def = "0",
5179 .is_seconds = 1,
5180 .is_time = 1,
5181 .category = FIO_OPT_C_GENERAL,
5182 .group = FIO_OPT_G_RUNTIME,
5183 },
5184 {
5185 .name = NULL,
5186 },
5187};
5188
5189static void add_to_lopt(struct option *lopt, struct fio_option *o,
5190 const char *name, int val)
5191{
5192 lopt->name = (char *) name;
5193 lopt->val = val;
5194 if (o->type == FIO_OPT_STR_SET)
5195 lopt->has_arg = optional_argument;
5196 else
5197 lopt->has_arg = required_argument;
5198}
5199
5200static void options_to_lopts(struct fio_option *opts,
5201 struct option *long_options,
5202 int i, int option_type)
5203{
5204 struct fio_option *o = &opts[0];
5205 while (o->name) {
5206 add_to_lopt(&long_options[i], o, o->name, option_type);
5207 if (o->alias) {
5208 i++;
5209 add_to_lopt(&long_options[i], o, o->alias, option_type);
5210 }
5211
5212 i++;
5213 o++;
5214 assert(i < FIO_NR_OPTIONS);
5215 }
5216}
5217
5218void fio_options_set_ioengine_opts(struct option *long_options,
5219 struct thread_data *td)
5220{
5221 unsigned int i;
5222
5223 i = 0;
5224 while (long_options[i].name) {
5225 if (long_options[i].val == FIO_GETOPT_IOENGINE) {
5226 memset(&long_options[i], 0, sizeof(*long_options));
5227 break;
5228 }
5229 i++;
5230 }
5231
5232 /*
5233 * Just clear out the prior ioengine options.
5234 */
5235 if (!td || !td->eo)
5236 return;
5237
5238 options_to_lopts(td->io_ops->options, long_options, i,
5239 FIO_GETOPT_IOENGINE);
5240}
5241
5242void fio_options_dup_and_init(struct option *long_options)
5243{
5244 unsigned int i;
5245
5246 options_init(fio_options);
5247
5248 i = 0;
5249 while (long_options[i].name)
5250 i++;
5251
5252 options_to_lopts(fio_options, long_options, i, FIO_GETOPT_JOB);
5253}
5254
5255struct fio_keyword {
5256 const char *word;
5257 const char *desc;
5258 char *replace;
5259};
5260
5261static struct fio_keyword fio_keywords[] = {
5262 {
5263 .word = "$pagesize",
5264 .desc = "Page size in the system",
5265 },
5266 {
5267 .word = "$mb_memory",
5268 .desc = "Megabytes of memory online",
5269 },
5270 {
5271 .word = "$ncpus",
5272 .desc = "Number of CPUs online in the system",
5273 },
5274 {
5275 .word = NULL,
5276 },
5277};
5278
5279void fio_keywords_exit(void)
5280{
5281 struct fio_keyword *kw;
5282
5283 kw = &fio_keywords[0];
5284 while (kw->word) {
5285 free(kw->replace);
5286 kw->replace = NULL;
5287 kw++;
5288 }
5289}
5290
5291void fio_keywords_init(void)
5292{
5293 unsigned long long mb_memory;
5294 char buf[128];
5295 long l;
5296
5297 sprintf(buf, "%lu", (unsigned long) page_size);
5298 fio_keywords[0].replace = strdup(buf);
5299
5300 mb_memory = os_phys_mem() / (1024 * 1024);
5301 sprintf(buf, "%llu", mb_memory);
5302 fio_keywords[1].replace = strdup(buf);
5303
5304 l = cpus_online();
5305 sprintf(buf, "%lu", l);
5306 fio_keywords[2].replace = strdup(buf);
5307}
5308
5309#define BC_APP "bc"
5310
5311static char *bc_calc(char *str)
5312{
5313 char buf[128], *tmp;
5314 FILE *f;
5315 int ret;
5316
5317 /*
5318 * No math, just return string
5319 */
5320 if ((!strchr(str, '+') && !strchr(str, '-') && !strchr(str, '*') &&
5321 !strchr(str, '/')) || strchr(str, '\''))
5322 return str;
5323
5324 /*
5325 * Split option from value, we only need to calculate the value
5326 */
5327 tmp = strchr(str, '=');
5328 if (!tmp)
5329 return str;
5330
5331 tmp++;
5332
5333 /*
5334 * Prevent buffer overflows; such a case isn't reasonable anyway
5335 */
5336 if (strlen(str) >= 128 || strlen(tmp) > 100)
5337 return str;
5338
5339 sprintf(buf, "which %s > /dev/null", BC_APP);
5340 if (system(buf)) {
5341 log_err("fio: bc is needed for performing math\n");
5342 return NULL;
5343 }
5344
5345 sprintf(buf, "echo '%s' | %s", tmp, BC_APP);
5346 f = popen(buf, "r");
5347 if (!f)
5348 return NULL;
5349
5350 ret = fread(&buf[tmp - str], 1, 128 - (tmp - str), f);
5351 if (ret <= 0) {
5352 pclose(f);
5353 return NULL;
5354 }
5355
5356 pclose(f);
5357 buf[(tmp - str) + ret - 1] = '\0';
5358 memcpy(buf, str, tmp - str);
5359 free(str);
5360 return strdup(buf);
5361}
5362
5363/*
5364 * Return a copy of the input string with substrings of the form ${VARNAME}
5365 * substituted with the value of the environment variable VARNAME. The
5366 * substitution always occurs, even if VARNAME is empty or the corresponding
5367 * environment variable undefined.
5368 */
5369char *fio_option_dup_subs(const char *opt)
5370{
5371 char out[OPT_LEN_MAX+1];
5372 char in[OPT_LEN_MAX+1];
5373 char *outptr = out;
5374 char *inptr = in;
5375 char *ch1, *ch2, *env;
5376 ssize_t nchr = OPT_LEN_MAX;
5377 size_t envlen;
5378
5379 if (strlen(opt) + 1 > OPT_LEN_MAX) {
5380 log_err("OPT_LEN_MAX (%d) is too small\n", OPT_LEN_MAX);
5381 return NULL;
5382 }
5383
5384 snprintf(in, sizeof(in), "%s", opt);
5385
5386 while (*inptr && nchr > 0) {
5387 if (inptr[0] == '$' && inptr[1] == '{') {
5388 ch2 = strchr(inptr, '}');
5389 if (ch2 && inptr+1 < ch2) {
5390 ch1 = inptr+2;
5391 inptr = ch2+1;
5392 *ch2 = '\0';
5393
5394 env = getenv(ch1);
5395 if (env) {
5396 envlen = strlen(env);
5397 if (envlen <= nchr) {
5398 memcpy(outptr, env, envlen);
5399 outptr += envlen;
5400 nchr -= envlen;
5401 }
5402 }
5403
5404 continue;
5405 }
5406 }
5407
5408 *outptr++ = *inptr++;
5409 --nchr;
5410 }
5411
5412 *outptr = '\0';
5413 return strdup(out);
5414}
5415
5416/*
5417 * Look for reserved variable names and replace them with real values
5418 */
5419static char *fio_keyword_replace(char *opt)
5420{
5421 char *s;
5422 int i;
5423 int docalc = 0;
5424
5425 for (i = 0; fio_keywords[i].word != NULL; i++) {
5426 struct fio_keyword *kw = &fio_keywords[i];
5427
5428 while ((s = strstr(opt, kw->word)) != NULL) {
5429 char *new = calloc(strlen(opt) + 1, 1);
5430 char *o_org = opt;
5431 int olen = s - opt;
5432 int len;
5433
5434 /*
5435 * Copy part of the string before the keyword and
5436 * sprintf() the replacement after it.
5437 */
5438 memcpy(new, opt, olen);
5439 len = sprintf(new + olen, "%s", kw->replace);
5440
5441 /*
5442 * If there's more in the original string, copy that
5443 * in too
5444 */
5445 opt += olen + strlen(kw->word);
5446 /* keeps final zero thanks to calloc */
5447 if (strlen(opt))
5448 memcpy(new + olen + len, opt, strlen(opt));
5449
5450 /*
5451 * replace opt and free the old opt
5452 */
5453 opt = new;
5454 free(o_org);
5455
5456 docalc = 1;
5457 }
5458 }
5459
5460 /*
5461 * Check for potential math and invoke bc, if possible
5462 */
5463 if (docalc)
5464 opt = bc_calc(opt);
5465
5466 return opt;
5467}
5468
5469static char **dup_and_sub_options(char **opts, int num_opts)
5470{
5471 int i;
5472 char **opts_copy = malloc(num_opts * sizeof(*opts));
5473 for (i = 0; i < num_opts; i++) {
5474 opts_copy[i] = fio_option_dup_subs(opts[i]);
5475 if (!opts_copy[i])
5476 continue;
5477 opts_copy[i] = fio_keyword_replace(opts_copy[i]);
5478 }
5479 return opts_copy;
5480}
5481
5482static void show_closest_option(const char *opt)
5483{
5484 int best_option, best_distance;
5485 int i, distance;
5486 char *name;
5487
5488 if (!strlen(opt))
5489 return;
5490
5491 name = strdup(opt);
5492 i = 0;
5493 while (name[i] != '\0' && name[i] != '=')
5494 i++;
5495 name[i] = '\0';
5496
5497 best_option = -1;
5498 best_distance = INT_MAX;
5499 i = 0;
5500 while (fio_options[i].name) {
5501 distance = string_distance(name, fio_options[i].name);
5502 if (distance < best_distance) {
5503 best_distance = distance;
5504 best_option = i;
5505 }
5506 i++;
5507 }
5508
5509 if (best_option != -1 && string_distance_ok(name, best_distance) &&
5510 fio_options[best_option].type != FIO_OPT_UNSUPPORTED)
5511 log_err("Did you mean %s?\n", fio_options[best_option].name);
5512
5513 free(name);
5514}
5515
5516int fio_options_parse(struct thread_data *td, char **opts, int num_opts)
5517{
5518 int i, ret, unknown;
5519 char **opts_copy;
5520
5521 sort_options(opts, fio_options, num_opts);
5522 opts_copy = dup_and_sub_options(opts, num_opts);
5523
5524 for (ret = 0, i = 0, unknown = 0; i < num_opts; i++) {
5525 const struct fio_option *o;
5526 int newret = parse_option(opts_copy[i], opts[i], fio_options,
5527 &o, &td->o, &td->opt_list);
5528
5529 if (!newret && o)
5530 fio_option_mark_set(&td->o, o);
5531
5532 if (opts_copy[i]) {
5533 if (newret && !o) {
5534 unknown++;
5535 continue;
5536 }
5537 free(opts_copy[i]);
5538 opts_copy[i] = NULL;
5539 }
5540
5541 ret |= newret;
5542 }
5543
5544 if (unknown) {
5545 ret |= ioengine_load(td);
5546 if (td->eo) {
5547 sort_options(opts_copy, td->io_ops->options, num_opts);
5548 opts = opts_copy;
5549 }
5550 for (i = 0; i < num_opts; i++) {
5551 const struct fio_option *o = NULL;
5552 int newret = 1;
5553
5554 if (!opts_copy[i])
5555 continue;
5556
5557 if (td->eo)
5558 newret = parse_option(opts_copy[i], opts[i],
5559 td->io_ops->options, &o,
5560 td->eo, &td->opt_list);
5561
5562 ret |= newret;
5563 if (!o) {
5564 log_err("Bad option <%s>\n", opts[i]);
5565 show_closest_option(opts[i]);
5566 }
5567 free(opts_copy[i]);
5568 opts_copy[i] = NULL;
5569 }
5570 }
5571
5572 free(opts_copy);
5573 return ret;
5574}
5575
5576int fio_cmd_option_parse(struct thread_data *td, const char *opt, char *val)
5577{
5578 int ret;
5579
5580 ret = parse_cmd_option(opt, val, fio_options, &td->o, &td->opt_list);
5581 if (!ret) {
5582 const struct fio_option *o;
5583
5584 o = find_option_c(fio_options, opt);
5585 if (o)
5586 fio_option_mark_set(&td->o, o);
5587 }
5588
5589 return ret;
5590}
5591
5592int fio_cmd_ioengine_option_parse(struct thread_data *td, const char *opt,
5593 char *val)
5594{
5595 return parse_cmd_option(opt, val, td->io_ops->options, td->eo,
5596 &td->opt_list);
5597}
5598
5599void fio_fill_default_options(struct thread_data *td)
5600{
5601 td->o.magic = OPT_MAGIC;
5602 fill_default_options(&td->o, fio_options);
5603}
5604
5605int fio_show_option_help(const char *opt)
5606{
5607 return show_cmd_help(fio_options, opt);
5608}
5609
5610/*
5611 * dupe FIO_OPT_STR_STORE options
5612 */
5613void fio_options_mem_dupe(struct thread_data *td)
5614{
5615 options_mem_dupe(fio_options, &td->o);
5616
5617 if (td->eo && td->io_ops) {
5618 void *oldeo = td->eo;
5619
5620 td->eo = malloc(td->io_ops->option_struct_size);
5621 memcpy(td->eo, oldeo, td->io_ops->option_struct_size);
5622 options_mem_dupe(td->io_ops->options, td->eo);
5623 }
5624}
5625
5626unsigned int fio_get_kb_base(void *data)
5627{
5628 struct thread_data *td = cb_data_to_td(data);
5629 struct thread_options *o = &td->o;
5630 unsigned int kb_base = 0;
5631
5632 /*
5633 * This is a hack... For private options, *data is not holding
5634 * a pointer to the thread_options, but to private data. This means
5635 * we can't safely dereference it, but magic is first so mem wise
5636 * it is valid. But this also means that if the job first sets
5637 * kb_base and expects that to be honored by private options,
5638 * it will be disappointed. We will return the global default
5639 * for this.
5640 */
5641 if (o && o->magic == OPT_MAGIC)
5642 kb_base = o->kb_base;
5643 if (!kb_base)
5644 kb_base = 1024;
5645
5646 return kb_base;
5647}
5648
5649int add_option(const struct fio_option *o)
5650{
5651 struct fio_option *__o;
5652 int opt_index = 0;
5653
5654 __o = fio_options;
5655 while (__o->name) {
5656 opt_index++;
5657 __o++;
5658 }
5659
5660 if (opt_index + 1 == FIO_MAX_OPTS) {
5661 log_err("fio: FIO_MAX_OPTS is too small\n");
5662 return 1;
5663 }
5664
5665 memcpy(&fio_options[opt_index], o, sizeof(*o));
5666 fio_options[opt_index + 1].name = NULL;
5667 return 0;
5668}
5669
5670void invalidate_profile_options(const char *prof_name)
5671{
5672 struct fio_option *o;
5673
5674 o = fio_options;
5675 while (o->name) {
5676 if (o->prof_name && !strcmp(o->prof_name, prof_name)) {
5677 o->type = FIO_OPT_INVALID;
5678 o->prof_name = NULL;
5679 }
5680 o++;
5681 }
5682}
5683
5684void add_opt_posval(const char *optname, const char *ival, const char *help)
5685{
5686 struct fio_option *o;
5687 unsigned int i;
5688
5689 o = find_option(fio_options, optname);
5690 if (!o)
5691 return;
5692
5693 for (i = 0; i < PARSE_MAX_VP; i++) {
5694 if (o->posval[i].ival)
5695 continue;
5696
5697 o->posval[i].ival = ival;
5698 o->posval[i].help = help;
5699 break;
5700 }
5701}
5702
5703void del_opt_posval(const char *optname, const char *ival)
5704{
5705 struct fio_option *o;
5706 unsigned int i;
5707
5708 o = find_option(fio_options, optname);
5709 if (!o)
5710 return;
5711
5712 for (i = 0; i < PARSE_MAX_VP; i++) {
5713 if (!o->posval[i].ival)
5714 continue;
5715 if (strcmp(o->posval[i].ival, ival))
5716 continue;
5717
5718 o->posval[i].ival = NULL;
5719 o->posval[i].help = NULL;
5720 }
5721}
5722
5723void fio_options_free(struct thread_data *td)
5724{
5725 options_free(fio_options, &td->o);
5726 if (td->eo && td->io_ops && td->io_ops->options) {
5727 options_free(td->io_ops->options, td->eo);
5728 free(td->eo);
5729 td->eo = NULL;
5730 }
5731}
5732
5733void fio_dump_options_free(struct thread_data *td)
5734{
5735 while (!flist_empty(&td->opt_list)) {
5736 struct print_option *p;
5737
5738 p = flist_first_entry(&td->opt_list, struct print_option, list);
5739 flist_del_init(&p->list);
5740 free(p->name);
5741 free(p->value);
5742 free(p);
5743 }
5744}
5745
5746struct fio_option *fio_option_find(const char *name)
5747{
5748 return find_option(fio_options, name);
5749}
5750
5751static struct fio_option *find_next_opt(struct fio_option *from,
5752 unsigned int off1)
5753{
5754 struct fio_option *opt;
5755
5756 if (!from)
5757 from = &fio_options[0];
5758 else
5759 from++;
5760
5761 opt = NULL;
5762 do {
5763 if (off1 == from->off1) {
5764 opt = from;
5765 break;
5766 }
5767 from++;
5768 } while (from->name);
5769
5770 return opt;
5771}
5772
5773static int opt_is_set(struct thread_options *o, struct fio_option *opt)
5774{
5775 unsigned int opt_off, index, offset;
5776
5777 opt_off = opt - &fio_options[0];
5778 index = opt_off / (8 * sizeof(uint64_t));
5779 offset = opt_off & ((8 * sizeof(uint64_t)) - 1);
5780 return (o->set_options[index] & ((uint64_t)1 << offset)) != 0;
5781}
5782
5783bool __fio_option_is_set(struct thread_options *o, unsigned int off1)
5784{
5785 struct fio_option *opt, *next;
5786
5787 next = NULL;
5788 while ((opt = find_next_opt(next, off1)) != NULL) {
5789 if (opt_is_set(o, opt))
5790 return true;
5791
5792 next = opt;
5793 }
5794
5795 return false;
5796}
5797
5798void fio_option_mark_set(struct thread_options *o, const struct fio_option *opt)
5799{
5800 unsigned int opt_off, index, offset;
5801
5802 opt_off = opt - &fio_options[0];
5803 index = opt_off / (8 * sizeof(uint64_t));
5804 offset = opt_off & ((8 * sizeof(uint64_t)) - 1);
5805 o->set_options[index] |= (uint64_t)1 << offset;
5806}
fio - Flexible IO Tester