return 0;
}
-#ifdef FIO_HAVE_LIBAIO
-static int str_libaio_cb(void *data, const char *str)
-{
- struct thread_data *td = data;
-
- if (!strcmp(str, "userspace_reap")) {
- td->o.userspace_libaio_reap = 1;
- return 0;
- }
-
- log_err("fio: bad libaio sub-option: %s\n", str);
- return 1;
-}
-#endif
-
static int str_mem_cb(void *data, const char *mem)
{
struct thread_data *td = data;
}
}
}
+
+ /*
+ * Fill the pattern all the way to the end. This greatly reduces
+ * the number of memcpy's we have to do when verifying the IO.
+ */
+ while (i > 1 && i * 2 <= MAX_PATTERN_SIZE) {
+ memcpy(&td->o.verify_pattern[i], &td->o.verify_pattern[0], i);
+ i *= 2;
+ }
+ if (i == 1) {
+ /*
+ * The code in verify_io_u_pattern assumes a single byte pattern
+ * fills the whole verify pattern buffer.
+ */
+ memset(td->o.verify_pattern, td->o.verify_pattern[0],
+ MAX_PATTERN_SIZE);
+ }
+
td->o.verify_pattern_bytes = i;
+
/*
* VERIFY_META could already be set
*/
if (td->o.verify == VERIFY_NONE)
td->o.verify = VERIFY_PATTERN;
+
return 0;
}
return 0;
}
+static int str_write_iops_log_cb(void *data, const char *str)
+{
+ struct thread_data *td = data;
+
+ if (str)
+ td->o.iops_log_file = strdup(str);
+
+ td->o.write_iops_log = 1;
+ return 0;
+}
+
static int str_gtod_reduce_cb(void *data, int *il)
{
struct thread_data *td = data;
td->o.disable_clat = !!val;
td->o.disable_slat = !!val;
td->o.disable_bw = !!val;
+ td->o.clat_percentiles = !val;
if (val)
td->tv_cache_mask = 63;
#ifdef FIO_HAVE_LIBAIO
{ .ival = "libaio",
.help = "Linux native asynchronous IO",
- .cb = str_libaio_cb,
},
#endif
#ifdef FIO_HAVE_POSIXAIO
#ifdef FIO_HAVE_WINDOWSAIO
{ .ival = "windowsaio",
.help = "Windows native asynchronous IO"
- },
+ },
#endif
{ .ival = "mmap",
.help = "Memory mapped IO"
.name = "verify_dump",
.type = FIO_OPT_BOOL,
.off1 = td_var_offset(verify_dump),
- .def = "1",
+ .def = "0",
.help = "Dump contents of good and bad blocks on failure",
.parent = "verify",
},
.name = "zonesize",
.type = FIO_OPT_STR_VAL,
.off1 = td_var_offset(zone_size),
+ .help = "Amount of data to read per zone",
+ .def = "0",
+ },
+ {
+ .name = "zonerange",
+ .type = FIO_OPT_STR_VAL,
+ .off1 = td_var_offset(zone_range),
.help = "Give size of an IO zone",
.def = "0",
},
.help = "Time window over which to calculate bandwidth"
" (msec)",
.def = "500",
+ .parent = "write_bw_log",
+ },
+ {
+ .name = "iopsavgtime",
+ .type = FIO_OPT_INT,
+ .off1 = td_var_offset(iops_avg_time),
+ .help = "Time window over which to calculate IOPS (msec)",
+ .def = "500",
+ .parent = "write_iops_log",
},
{
.name = "create_serialize",
.cb = str_write_lat_log_cb,
.help = "Write log of latency during run",
},
+ {
+ .name = "write_iops_log",
+ .type = FIO_OPT_STR,
+ .off1 = td_var_offset(write_iops_log),
+ .cb = str_write_iops_log_cb,
+ .help = "Write log of IOPS during run",
+ },
+ {
+ .name = "log_avg_msec",
+ .type = FIO_OPT_INT,
+ .off1 = td_var_offset(log_avg_msec),
+ .help = "Average bw/iops/lat logs over this period of time",
+ .def = "0",
+ },
{
.name = "hugepage-size",
.type = FIO_OPT_INT,
.type = FIO_OPT_BOOL,
.off1 = td_var_offset(clat_percentiles),
.help = "Enable the reporting of completion latency percentiles",
- .def = "0",
+ .def = "1",
},
{
.name = "percentile_list",
},
{
.name = "continue_on_error",
- .type = FIO_OPT_BOOL,
+ .type = FIO_OPT_STR,
.off1 = td_var_offset(continue_on_error),
.help = "Continue on non-fatal errors during IO",
- .def = "0",
+ .def = "none",
+ .posval = {
+ { .ival = "none",
+ .oval = ERROR_TYPE_NONE,
+ .help = "Exit when an error is encountered",
+ },
+ { .ival = "read",
+ .oval = ERROR_TYPE_READ,
+ .help = "Continue on read errors only",
+ },
+ { .ival = "write",
+ .oval = ERROR_TYPE_WRITE,
+ .help = "Continue on write errors only",
+ },
+ { .ival = "io",
+ .oval = ERROR_TYPE_READ | ERROR_TYPE_WRITE,
+ .help = "Continue on any IO errors",
+ },
+ { .ival = "verify",
+ .oval = ERROR_TYPE_VERIFY,
+ .help = "Continue on verify errors only",
+ },
+ { .ival = "all",
+ .oval = ERROR_TYPE_ANY,
+ .help = "Continue on all io and verify errors",
+ },
+ { .ival = "0",
+ .oval = ERROR_TYPE_NONE,
+ .help = "Alias for 'none'",
+ },
+ { .ival = "1",
+ .oval = ERROR_TYPE_ANY,
+ .help = "Alias for 'all'",
+ },
+ },
},
{
.name = "profile",
};
static void add_to_lopt(struct option *lopt, struct fio_option *o,
- const char *name)
+ const char *name, int val)
{
lopt->name = (char *) name;
- lopt->val = FIO_GETOPT_JOB;
+ lopt->val = val;
if (o->type == FIO_OPT_STR_SET)
lopt->has_arg = no_argument;
else
lopt->has_arg = required_argument;
}
-void fio_options_dup_and_init(struct option *long_options)
+static void options_to_lopts(struct fio_option *opts,
+ struct option *long_options,
+ int i, int option_type)
{
- struct fio_option *o;
- unsigned int i;
-
- options_init(options);
-
- i = 0;
- while (long_options[i].name)
- i++;
-
- o = &options[0];
+ struct fio_option *o = &opts[0];
while (o->name) {
- add_to_lopt(&long_options[i], o, o->name);
+ add_to_lopt(&long_options[i], o, o->name, option_type);
if (o->alias) {
i++;
- add_to_lopt(&long_options[i], o, o->alias);
+ add_to_lopt(&long_options[i], o, o->alias, option_type);
}
i++;
}
}
+void fio_options_set_ioengine_opts(struct option *long_options,
+ struct thread_data *td)
+{
+ unsigned int i;
+
+ i = 0;
+ while (long_options[i].name) {
+ if (long_options[i].val == FIO_GETOPT_IOENGINE) {
+ memset(&long_options[i], 0, sizeof(*long_options));
+ break;
+ }
+ i++;
+ }
+
+ /*
+ * Just clear out the prior ioengine options.
+ */
+ if (!td || !td->eo)
+ return;
+
+ options_to_lopts(td->io_ops->options, long_options, i,
+ FIO_GETOPT_IOENGINE);
+}
+
+void fio_options_dup_and_init(struct option *long_options)
+{
+ unsigned int i;
+
+ options_init(options);
+
+ i = 0;
+ while (long_options[i].name)
+ i++;
+
+ options_to_lopts(options, long_options, i, FIO_GETOPT_JOB);
+}
+
struct fio_keyword {
const char *word;
const char *desc;
static char *bc_calc(char *str)
{
- char *buf, *tmp, opt[80];
+ char buf[128], *tmp;
FILE *f;
int ret;
/*
* No math, just return string
*/
- if (!strchr(str, '+') && !strchr(str, '-') && !strchr(str, '*') &&
- !strchr(str, '/'))
+ if ((!strchr(str, '+') && !strchr(str, '-') && !strchr(str, '*') &&
+ !strchr(str, '/')) || strchr(str, '\''))
return str;
/*
return str;
tmp++;
- memset(opt, 0, sizeof(opt));
- strncpy(opt, str, tmp - str);
- buf = malloc(128);
+ /*
+ * Prevent buffer overflows; such a case isn't reasonable anyway
+ */
+ if (strlen(str) >= 128 || strlen(tmp) > 100)
+ return str;
sprintf(buf, "which %s > /dev/null", BC_APP);
if (system(buf)) {
log_err("fio: bc is needed for performing math\n");
- free(buf);
return NULL;
}
- sprintf(buf, "echo %s | %s", tmp, BC_APP);
+ sprintf(buf, "echo '%s' | %s", tmp, BC_APP);
f = popen(buf, "r");
if (!f) {
- free(buf);
return NULL;
}
- ret = fread(buf, 1, 128, f);
+ ret = fread(&buf[tmp - str], 1, 128 - (tmp - str), f);
if (ret <= 0) {
- free(buf);
return NULL;
}
- buf[ret - 1] = '\0';
- strcat(opt, buf);
- strcpy(buf, opt);
pclose(f);
+ buf[(tmp - str) + ret - 1] = '\0';
+ memcpy(buf, str, tmp - str);
free(str);
- return buf;
+ return strdup(buf);
+}
+
+/*
+ * Return a copy of the input string with substrings of the form ${VARNAME}
+ * substituted with the value of the environment variable VARNAME. The
+ * substitution always occurs, even if VARNAME is empty or the corresponding
+ * environment variable undefined.
+ */
+static char *option_dup_subs(const char *opt)
+{
+ char out[OPT_LEN_MAX+1];
+ char in[OPT_LEN_MAX+1];
+ char *outptr = out;
+ char *inptr = in;
+ char *ch1, *ch2, *env;
+ ssize_t nchr = OPT_LEN_MAX;
+ size_t envlen;
+
+ if (strlen(opt) + 1 > OPT_LEN_MAX) {
+ log_err("OPT_LEN_MAX (%d) is too small\n", OPT_LEN_MAX);
+ return NULL;
+ }
+
+ in[OPT_LEN_MAX] = '\0';
+ strncpy(in, opt, OPT_LEN_MAX);
+
+ while (*inptr && nchr > 0) {
+ if (inptr[0] == '$' && inptr[1] == '{') {
+ ch2 = strchr(inptr, '}');
+ if (ch2 && inptr+1 < ch2) {
+ ch1 = inptr+2;
+ inptr = ch2+1;
+ *ch2 = '\0';
+
+ env = getenv(ch1);
+ if (env) {
+ envlen = strlen(env);
+ if (envlen <= nchr) {
+ memcpy(outptr, env, envlen);
+ outptr += envlen;
+ nchr -= envlen;
+ }
+ }
+
+ continue;
+ }
+ }
+
+ *outptr++ = *inptr++;
+ --nchr;
+ }
+
+ *outptr = '\0';
+ return strdup(out);
}
/*
{
char *s;
int i;
+ int docalc = 0;
for (i = 0; fio_keywords[i].word != NULL; i++) {
struct fio_keyword *kw = &fio_keywords[i];
* replace opt and free the old opt
*/
opt = new;
- //free(o_org);
+ free(o_org);
- /*
- * Check for potential math and invoke bc, if possible
- */
- opt = bc_calc(opt);
+ docalc = 1;
}
}
+ /*
+ * Check for potential math and invoke bc, if possible
+ */
+ if (docalc)
+ opt = bc_calc(opt);
+
return opt;
}
+static char **dup_and_sub_options(char **opts, int num_opts)
+{
+ int i;
+ char **opts_copy = malloc(num_opts * sizeof(*opts));
+ for (i = 0; i < num_opts; i++) {
+ opts_copy[i] = option_dup_subs(opts[i]);
+ if (!opts_copy[i])
+ continue;
+ opts_copy[i] = fio_keyword_replace(opts_copy[i]);
+ }
+ return opts_copy;
+}
+
int fio_options_parse(struct thread_data *td, char **opts, int num_opts)
{
- int i, ret;
+ int i, ret, unknown;
+ char **opts_copy;
sort_options(opts, options, num_opts);
+ opts_copy = dup_and_sub_options(opts, num_opts);
+
+ for (ret = 0, i = 0, unknown = 0; i < num_opts; i++) {
+ struct fio_option *o;
+ int newret = parse_option(opts_copy[i], opts[i], options, &o,
+ td);
- for (ret = 0, i = 0; i < num_opts; i++) {
- opts[i] = fio_keyword_replace(opts[i]);
- ret |= parse_option(opts[i], options, td);
+ if (opts_copy[i]) {
+ if (newret && !o) {
+ unknown++;
+ continue;
+ }
+ free(opts_copy[i]);
+ opts_copy[i] = NULL;
+ }
+
+ ret |= newret;
}
+ if (unknown) {
+ ret |= ioengine_load(td);
+ if (td->eo) {
+ sort_options(opts_copy, td->io_ops->options, num_opts);
+ opts = opts_copy;
+ }
+ for (i = 0; i < num_opts; i++) {
+ struct fio_option *o = NULL;
+ int newret = 1;
+ if (!opts_copy[i])
+ continue;
+
+ if (td->eo)
+ newret = parse_option(opts_copy[i], opts[i],
+ td->io_ops->options, &o,
+ td->eo);
+
+ ret |= newret;
+ if (!o)
+ log_err("Bad option <%s>\n", opts[i]);
+
+ free(opts_copy[i]);
+ opts_copy[i] = NULL;
+ }
+ }
+
+ free(opts_copy);
return ret;
}
return parse_cmd_option(opt, val, options, td);
}
+int fio_cmd_ioengine_option_parse(struct thread_data *td, const char *opt,
+ char *val)
+{
+ return parse_cmd_option(opt, val, td->io_ops->options, td);
+}
+
void fio_fill_default_options(struct thread_data *td)
{
fill_default_options(td, options);
return show_cmd_help(options, opt);
}
-static void __options_mem(struct thread_data *td, int alloc)
+void options_mem_dupe(void *data, struct fio_option *options)
{
- struct thread_options *o = &td->o;
- struct fio_option *opt;
+ struct fio_option *o;
char **ptr;
- int i;
- for (i = 0, opt = &options[0]; opt->name; i++, opt = &options[i]) {
- if (opt->type != FIO_OPT_STR_STORE)
+ for (o = &options[0]; o->name; o++) {
+ if (o->type != FIO_OPT_STR_STORE)
continue;
- ptr = (void *) o + opt->off1;
- if (*ptr) {
- if (alloc)
- *ptr = strdup(*ptr);
- else {
- free(*ptr);
- *ptr = NULL;
- }
- }
+ ptr = td_var(data, o->off1);
+ if (*ptr)
+ *ptr = strdup(*ptr);
}
}
/*
* dupe FIO_OPT_STR_STORE options
*/
-void options_mem_dupe(struct thread_data *td)
+void fio_options_mem_dupe(struct thread_data *td)
{
- __options_mem(td, 1);
-}
+ options_mem_dupe(&td->o, options);
-void options_mem_free(struct thread_data fio_unused *td)
-{
-#if 0
- __options_mem(td, 0);
-#endif
+ if (td->eo && td->io_ops) {
+ void *oldeo = td->eo;
+
+ td->eo = malloc(td->io_ops->option_struct_size);
+ memcpy(td->eo, oldeo, td->io_ops->option_struct_size);
+ options_mem_dupe(td->eo, td->io_ops->options);
+ }
}
unsigned int fio_get_kb_base(void *data)
o->posval[i].help = NULL;
}
}
+
+void fio_options_free(struct thread_data *td)
+{
+ options_free(options, td);
+ if (td->eo && td->io_ops && td->io_ops->options) {
+ options_free(td->io_ops->options, td->eo);
+ free(td->eo);
+ td->eo = NULL;
+ }
+}
projects / fio.git / blobdiff