}
}
- td->o.cpumask_set = 1;
return 0;
}
}
free(p);
- if (!ret)
- td->o.cpumask_set = 1;
return ret;
}
static int str_cpus_allowed_cb(void *data, const char *input)
{
struct thread_data *td = data;
- int ret;
if (parse_dryrun())
return 0;
- ret = set_cpus_allowed(td, &td->o.cpumask, input);
- if (!ret)
- td->o.cpumask_set = 1;
-
- return ret;
+ return set_cpus_allowed(td, &td->o.cpumask, input);
}
static int str_verify_cpus_allowed_cb(void *data, const char *input)
{
struct thread_data *td = data;
- int ret;
-
- ret = set_cpus_allowed(td, &td->o.verify_cpumask, input);
- if (!ret)
- td->o.verify_cpumask_set = 1;
- return ret;
+ return set_cpus_allowed(td, &td->o.verify_cpumask, input);
}
#endif
numa_free_nodemask(verify_bitmask);
td->o.numa_cpunodes = strdup(input);
- td->o.numa_cpumask_set = 1;
return 0;
}
break;
}
- td->o.numa_memmask_set = 1;
return 0;
-
out:
return 1;
}
&td->o.buffer_pattern_bytes);
if (!ret && td->o.buffer_pattern_bytes) {
- td->o.refill_buffers = 0;
+ if (!td->o.compress_percentage)
+ td->o.refill_buffers = 0;
td->o.scramble_buffers = 0;
td->o.zero_buffers = 0;
} else {
.lname = "Size",
.type = FIO_OPT_STR_VAL,
.cb = str_size_cb,
+ .off1 = td_var_offset(size),
.help = "Total size of device or files",
.interval = 1024 * 1024,
.category = FIO_OPT_C_IO,
.lname = "Block size split",
.type = FIO_OPT_STR,
.cb = str_bssplit_cb,
+ .off1 = td_var_offset(bssplit),
.help = "Set a specific mix of block sizes",
.parent = "rw",
.hide = 1,
.lname = "Verify pattern",
.type = FIO_OPT_STR,
.cb = str_verify_pattern_cb,
+ .off1 = td_var_offset(verify_pattern),
.help = "Fill pattern for IO buffers",
.parent = "verify",
.hide = 1,
.lname = "Async verify CPUs",
.type = FIO_OPT_STR,
.cb = str_verify_cpus_allowed_cb,
+ .off1 = td_var_offset(verify_cpumask),
.help = "Set CPUs allowed for async verify threads",
.parent = "verify_async",
.hide = 1,
.lname = "Read/write mix read",
.type = FIO_OPT_INT,
.cb = str_rwmix_read_cb,
+ .off1 = td_var_offset(rwmix[DDIR_READ]),
.maxval = 100,
.help = "Percentage of mixed workload that is reads",
.def = "50",
.lname = "Read/write mix write",
.type = FIO_OPT_INT,
.cb = str_rwmix_write_cb,
+ .off1 = td_var_offset(rwmix[DDIR_WRITE]),
.maxval = 100,
.help = "Percentage of mixed workload that is writes",
.def = "50",
.lname = "CPU mask",
.type = FIO_OPT_INT,
.cb = str_cpumask_cb,
+ .off1 = td_var_offset(cpumask),
.help = "CPU affinity mask",
.category = FIO_OPT_C_GENERAL,
.group = FIO_OPT_G_CRED,
.lname = "CPUs allowed",
.type = FIO_OPT_STR,
.cb = str_cpus_allowed_cb,
+ .off1 = td_var_offset(cpumask),
.help = "Set CPUs allowed",
.category = FIO_OPT_C_GENERAL,
.group = FIO_OPT_G_CRED,
.name = "numa_cpu_nodes",
.type = FIO_OPT_STR,
.cb = str_numa_cpunodes_cb,
+ .off1 = td_var_offset(numa_cpunodes),
.help = "NUMA CPU nodes bind",
.category = FIO_OPT_C_GENERAL,
.group = FIO_OPT_G_INVALID,
.name = "numa_mem_policy",
.type = FIO_OPT_STR,
.cb = str_numa_mpol_cb,
+ .off1 = td_var_offset(numa_memnodes),
.help = "NUMA memory policy setup",
.category = FIO_OPT_C_GENERAL,
.group = FIO_OPT_G_INVALID,
.lname = "Buffer pattern",
.type = FIO_OPT_STR,
.cb = str_buffer_pattern_cb,
+ .off1 = td_var_offset(buffer_pattern),
.help = "Fill pattern for IO buffers",
.category = FIO_OPT_C_IO,
.group = FIO_OPT_G_IO_BUF,
.lname = "Buffer compression percentage",
.type = FIO_OPT_INT,
.cb = str_buffer_compress_cb,
+ .off1 = td_var_offset(compress_percentage),
.maxval = 100,
.minval = 0,
.help = "How compressible the buffer is (approximately)",
.lname = "Dedupe percentage",
.type = FIO_OPT_INT,
.cb = str_dedupe_cb,
+ .off1 = td_var_offset(dedupe_percentage),
.maxval = 100,
.minval = 0,
.help = "Percentage of buffers that are dedupable",
.name = "ignore_error",
.type = FIO_OPT_STR,
.cb = str_ignore_error_cb,
+ .off1 = td_var_offset(ignore_error_nr),
.help = "Set a specific list of errors to ignore",
.parent = "rw",
.category = FIO_OPT_C_GENERAL,
return opts_copy;
}
+static void show_closest_option(const char *opt)
+{
+ int best_option, best_distance;
+ int i, distance;
+ char *name;
+
+ if (!strlen(opt))
+ return;
+
+ name = strdup(opt);
+ i = 0;
+ while (name[i] != '\0' && name[i] != '=')
+ i++;
+ name[i] = '\0';
+
+ best_option = -1;
+ best_distance = INT_MAX;
+ i = 0;
+ while (fio_options[i].name) {
+ distance = string_distance(name, fio_options[i].name);
+ if (distance < best_distance) {
+ best_distance = distance;
+ best_option = i;
+ }
+ i++;
+ }
+
+ if (best_option != -1)
+ log_err("Did you mean %s?\n", fio_options[best_option].name);
+
+ free(name);
+}
+
int fio_options_parse(struct thread_data *td, char **opts, int num_opts,
int dump_cmdline)
{
int newret = parse_option(opts_copy[i], opts[i], fio_options,
&o, td, dump_cmdline);
+ if (!newret && o)
+ fio_option_mark_set(&td->o, o);
+
if (opts_copy[i]) {
if (newret && !o) {
unknown++;
for (i = 0; i < num_opts; i++) {
struct fio_option *o = NULL;
int newret = 1;
+
if (!opts_copy[i])
continue;
td->eo, dump_cmdline);
ret |= newret;
- if (!o)
+ if (!o) {
log_err("Bad option <%s>\n", opts[i]);
-
+ show_closest_option(opts[i]);
+ }
free(opts_copy[i]);
opts_copy[i] = NULL;
}
int fio_cmd_option_parse(struct thread_data *td, const char *opt, char *val)
{
- return parse_cmd_option(opt, val, fio_options, td);
+ int ret;
+
+ ret = parse_cmd_option(opt, val, fio_options, td);
+ if (!ret) {
+ struct fio_option *o;
+
+ o = find_option(fio_options, opt);
+ if (o)
+ fio_option_mark_set(&td->o, o);
+ }
+
+ return ret;
}
int fio_cmd_ioengine_option_parse(struct thread_data *td, const char *opt,
return find_option(fio_options, name);
}
+int __fio_option_is_set(struct thread_options *o, unsigned int off1)
+{
+ unsigned int opt_off, index, offset;
+ struct fio_option *opt = NULL;
+ int i;
+
+ for (i = 0; fio_options[i].name; i++) {
+ if (off1 == fio_options[i].off1) {
+ opt = &fio_options[i];
+ break;
+ }
+ }
+
+ if (!opt) {
+ log_err("fio: no option found at offset %u\n", off1);
+ return 0;
+ }
+
+ opt_off = opt - &fio_options[0];
+ index = opt_off / (8 * sizeof(uint64_t));
+ offset = opt_off & ((8 * sizeof(uint64_t)) - 1);
+ return (o->set_options[index] & (1UL << offset)) != 0;
+}
+
+void fio_option_mark_set(struct thread_options *o, struct fio_option *opt)
+{
+ unsigned int opt_off, index, offset;
+
+ opt_off = opt - &fio_options[0];
+ index = opt_off / (8 * sizeof(uint64_t));
+ offset = opt_off & ((8 * sizeof(uint64_t)) - 1);
+ o->set_options[index] |= 1UL << offset;
+}