X-Git-Url: https://git.kernel.dk/?p=fio.git;a=blobdiff_plain;f=options.c;h=b1b6c8e969381cc44cdde496fbcb4ad174c84a84;hp=1816d0be74eb090fa8742e71924a75c76356df2a;hb=3c78a83fe8098489706c992d431e466222d94e4c;hpb=6aca9b3d1042bef94958ebee0656755a91695f4b diff --git a/options.c b/options.c index 1816d0be..b1b6c8e9 100644 --- a/options.c +++ b/options.c @@ -104,7 +104,7 @@ static int bssplit_ddir(struct thread_options *o, int ddir, char *str) if (str_to_decimal(fname, &val, 1, o)) { log_err("fio: bssplit conversion failed\n"); - free(o->bssplit); + free(bssplit); return 1; } @@ -168,6 +168,9 @@ static int str_bssplit_cb(void *data, const char *input) char *str, *p, *odir, *ddir; int ret = 0; + if (parse_dryrun()) + return 0; + p = str = strdup(input); strip_blank_front(&str); @@ -290,6 +293,10 @@ static int str_ignore_error_cb(void *data, const char *input) struct thread_data *td = data; char *str, *p, *n; int type = 0, ret = 1; + + if (parse_dryrun()) + return 0; + p = str = strdup(input); strip_blank_front(&str); @@ -315,6 +322,9 @@ static int str_rw_cb(void *data, const char *str) struct thread_options *o = &td->o; char *nr = get_opt_postfix(str); + if (parse_dryrun()) + return 0; + o->ddir_seq_nr = 1; o->ddir_seq_add = 0; @@ -391,6 +401,9 @@ static int str_cpumask_cb(void *data, unsigned long long *val) long max_cpu; int ret; + if (parse_dryrun()) + return 0; + ret = fio_cpuset_init(&td->o.cpumask); if (ret < 0) { log_err("fio: cpuset_init failed\n"); @@ -489,6 +502,9 @@ 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; @@ -514,6 +530,9 @@ static int str_numa_cpunodes_cb(void *data, char *input) { struct thread_data *td = data; + if (parse_dryrun()) + return 0; + /* numa_parse_nodestring() parses a character string list * of nodes into a bit mask. The bit mask is allocated by * numa_allocate_nodemask(), so it should be freed by @@ -536,8 +555,12 @@ static int str_numa_mpol_cb(void *data, char *input) const char * const policy_types[] = { "default", "prefer", "bind", "interleave", "local", NULL }; int i; + char *nodelist; - char *nodelist = strchr(input, ':'); + if (parse_dryrun()) + return 0; + + nodelist = strchr(input, ':'); if (nodelist) { /* NUL-terminate mode */ *nodelist++ = '\0'; @@ -669,6 +692,9 @@ static int str_random_distribution_cb(void *data, const char *str) double val; char *nr; + if (parse_dryrun()) + return 0; + if (td->o.random_distribution == FIO_RAND_DIST_ZIPF) val = 1.1; else if (td->o.random_distribution == FIO_RAND_DIST_PARETO) @@ -777,6 +803,9 @@ static int str_directory_cb(void *data, const char fio_unused *str) struct thread_data *td = data; struct stat sb; + if (parse_dryrun()) + return 0; + if (lstat(td->o.directory, &sb) < 0) { int ret = errno; @@ -796,17 +825,21 @@ static int str_opendir_cb(void *data, const char fio_unused *str) { struct thread_data *td = data; + if (parse_dryrun()) + return 0; + if (!td->files_index) td->o.nr_files = 0; return add_dir_files(td, td->o.opendir); } -static int str_verify_pattern_cb(void *data, const char *input) +static int pattern_cb(char *pattern, unsigned int max_size, + const char *input, unsigned int *pattern_bytes) { - struct thread_data *td = data; long off; - int i = 0, j = 0, len, k, base = 10, pattern_length; + int i = 0, j = 0, len, k, base = 10; + uint32_t pattern_length; char *loc1, *loc2; loc1 = strstr(input, "0x"); @@ -816,7 +849,7 @@ static int str_verify_pattern_cb(void *data, const char *input) off = strtol(input, NULL, base); if (off != LONG_MAX || errno != ERANGE) { while (off) { - td->o.verify_pattern[i] = off & 0xff; + pattern[i] = off & 0xff; off >>= 8; i++; } @@ -830,13 +863,13 @@ static int str_verify_pattern_cb(void *data, const char *input) j = loc2 - input + 2; } else return 1; - if (len - j < MAX_PATTERN_SIZE * 2) { + if (len - j < max_size * 2) { while (k >= j) { off = converthexchartoint(input[k--]); if (k >= j) off += (converthexchartoint(input[k--]) * 16); - td->o.verify_pattern[i++] = (char) off; + pattern[i++] = (char) off; } } } @@ -846,19 +879,19 @@ static int str_verify_pattern_cb(void *data, const char *input) * the number of memcpy's we have to do when verifying the IO. */ pattern_length = i; - while (i > 1 && i * 2 <= MAX_PATTERN_SIZE) { - memcpy(&td->o.verify_pattern[i], &td->o.verify_pattern[0], i); + while (i > 1 && i * 2 <= max_size) { + memcpy(&pattern[i], &pattern[0], i); i *= 2; } /* * Fill remainder, if the pattern multiple ends up not being - * MAX_PATTERN_SIZE. + * max_size. */ - while (i > 1 && i < MAX_PATTERN_SIZE) { - unsigned int b = min(pattern_length, MAX_PATTERN_SIZE - i); + while (i > 1 && i < max_size) { + unsigned int b = min(pattern_length, max_size - i); - memcpy(&td->o.verify_pattern[i], &td->o.verify_pattern[0], b); + memcpy(&pattern[i], &pattern[0], b); i += b; } @@ -867,19 +900,45 @@ static int str_verify_pattern_cb(void *data, const char *input) * 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); + memset(pattern, pattern[0], max_size); } - td->o.verify_pattern_bytes = i; + *pattern_bytes = i; + return 0; +} + +static int str_buffer_pattern_cb(void *data, const char *input) +{ + struct thread_data *td = data; + int ret; + + ret = pattern_cb(td->o.buffer_pattern, MAX_PATTERN_SIZE, input, + &td->o.buffer_pattern_bytes); + + if (!ret) { + td->o.refill_buffers = 0; + td->o.scramble_buffers = 0; + td->o.zero_buffers = 0; + } + + return ret; +} + +static int str_verify_pattern_cb(void *data, const char *input) +{ + struct thread_data *td = data; + int ret; + + ret = pattern_cb(td->o.verify_pattern, MAX_PATTERN_SIZE, input, + &td->o.verify_pattern_bytes); /* * VERIFY_META could already be set */ - if (td->o.verify == VERIFY_NONE) + if (!ret && td->o.verify == VERIFY_NONE) td->o.verify = VERIFY_PATTERN; - return 0; + return ret; } static int str_gtod_reduce_cb(void *data, int *il) @@ -1010,6 +1069,10 @@ struct opt_group *opt_group_from_mask(unsigned int *mask) } static struct opt_group fio_opt_cat_groups[] = { + { + .name = "Latency profiling", + .mask = FIO_OPT_G_LATPROF, + }, { .name = "Rate", .mask = FIO_OPT_G_RATE, @@ -1482,6 +1545,16 @@ struct fio_option fio_options[FIO_MAX_OPTS] = { .category = FIO_OPT_C_IO, .group = FIO_OPT_G_INVALID, }, + { + .name = "number_ios", + .lname = "Number of IOs to perform", + .type = FIO_OPT_STR_VAL, + .off1 = td_var_offset(number_ios), + .help = "Force job completion of this number of IOs", + .def = "0", + .category = FIO_OPT_C_IO, + .group = FIO_OPT_G_INVALID, + }, { .name = "bs", .lname = "Block size", @@ -1580,6 +1653,16 @@ struct fio_option fio_options[FIO_MAX_OPTS] = { .category = FIO_OPT_C_IO, .group = FIO_OPT_G_RANDOM, }, + { + .name = "randseed", + .lname = "The random generator seed", + .type = FIO_OPT_INT, + .off1 = td_var_offset(rand_seed), + .help = "Set the random generator seed value", + .parent = "rw", + .category = FIO_OPT_C_IO, + .group = FIO_OPT_G_RANDOM, + }, { .name = "use_os_rand", .lname = "Use OS random", @@ -1850,6 +1933,16 @@ struct fio_option fio_options[FIO_MAX_OPTS] = { .category = FIO_OPT_C_IO, .group = FIO_OPT_G_IO_TYPE, }, + { + .name = "atomic", + .lname = "Atomic I/O", + .type = FIO_OPT_BOOL, + .off1 = td_var_offset(oatomic), + .help = "Use Atomic IO with O_DIRECT (implies O_DIRECT)", + .def = "0", + .category = FIO_OPT_C_IO, + .group = FIO_OPT_G_IO_TYPE, + }, { .name = "buffered", .lname = "Buffered I/O", @@ -2571,7 +2664,38 @@ struct fio_option fio_options[FIO_MAX_OPTS] = { .off1 = td_var_offset(max_latency), .help = "Maximum tolerated IO latency (usec)", .category = FIO_OPT_C_IO, - .group = FIO_OPT_G_RATE, + .group = FIO_OPT_G_LATPROF, + }, + { + .name = "latency_target", + .lname = "Latency Target (usec)", + .type = FIO_OPT_STR_VAL_TIME, + .off1 = td_var_offset(latency_target), + .help = "Ramp to max queue depth supporting this latency", + .category = FIO_OPT_C_IO, + .group = FIO_OPT_G_LATPROF, + }, + { + .name = "latency_window", + .lname = "Latency Window (usec)", + .type = FIO_OPT_STR_VAL_TIME, + .off1 = td_var_offset(latency_window), + .help = "Time to sustain latency_target", + .category = FIO_OPT_C_IO, + .group = FIO_OPT_G_LATPROF, + }, + { + .name = "latency_percentile", + .lname = "Latency Percentile", + .type = FIO_OPT_FLOAT_LIST, + .off1 = td_var_offset(latency_percentile), + .help = "Percentile of IOs must be below latency_target", + .def = "100", + .maxlen = 1, + .minfp = 0.0, + .maxfp = 100.0, + .category = FIO_OPT_C_IO, + .group = FIO_OPT_G_LATPROF, }, { .name = "invalidate", @@ -2849,6 +2973,15 @@ struct fio_option fio_options[FIO_MAX_OPTS] = { .category = FIO_OPT_C_IO, .group = FIO_OPT_G_IO_BUF, }, + { + .name = "buffer_pattern", + .lname = "Buffer pattern", + .type = FIO_OPT_STR, + .cb = str_buffer_pattern_cb, + .help = "Fill pattern for IO buffers", + .category = FIO_OPT_C_IO, + .group = FIO_OPT_G_IO_BUF, + }, { .name = "buffer_compress_percentage", .lname = "Buffer compression percentage", @@ -3225,7 +3358,7 @@ static void add_to_lopt(struct option *lopt, struct fio_option *o, lopt->name = (char *) name; lopt->val = val; if (o->type == FIO_OPT_STR_SET) - lopt->has_arg = no_argument; + lopt->has_arg = optional_argument; else lopt->has_arg = required_argument; } @@ -3498,7 +3631,8 @@ static char **dup_and_sub_options(char **opts, int num_opts) return opts_copy; } -int fio_options_parse(struct thread_data *td, char **opts, int num_opts) +int fio_options_parse(struct thread_data *td, char **opts, int num_opts, + int dump_cmdline) { int i, ret, unknown; char **opts_copy; @@ -3509,7 +3643,7 @@ int fio_options_parse(struct thread_data *td, char **opts, int 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], fio_options, - &o, td); + &o, td, dump_cmdline); if (opts_copy[i]) { if (newret && !o) { @@ -3538,7 +3672,7 @@ int fio_options_parse(struct thread_data *td, char **opts, int num_opts) if (td->eo) newret = parse_option(opts_copy[i], opts[i], td->io_ops->options, &o, - td->eo); + td->eo, dump_cmdline); ret |= newret; if (!o) @@ -3561,7 +3695,7 @@ int fio_cmd_option_parse(struct thread_data *td, const char *opt, char *val) 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); + return parse_cmd_option(opt, val, td->io_ops->options, td->eo); } void fio_fill_default_options(struct thread_data *td)