X-Git-Url: https://git.kernel.dk/?p=fio.git;a=blobdiff_plain;f=options.c;h=6bd745553644283681c095853bca80483671c975;hp=17d7245f5490cc762153ea48d3960605cc0d5909;hb=fd98fb689d5ad7e9977461e961fff3fdd37f9cb8;hpb=9109883a1c20c2cbadd2d2cb8ca80d03835eaa66 diff --git a/options.c b/options.c index 17d7245f..6bd74555 100644 --- a/options.c +++ b/options.c @@ -52,13 +52,12 @@ static int bs_cmp(const void *p1, const void *p2) struct split { unsigned int nr; - unsigned int val1[ZONESPLIT_MAX]; + unsigned long long val1[ZONESPLIT_MAX]; unsigned long long val2[ZONESPLIT_MAX]; }; static int split_parse_ddir(struct thread_options *o, struct split *split, - enum fio_ddir ddir, char *str, bool absolute, - unsigned int max_splits) + char *str, bool absolute, unsigned int max_splits) { unsigned long long perc; unsigned int i; @@ -120,12 +119,12 @@ static int bssplit_ddir(struct thread_options *o, enum fio_ddir ddir, char *str, bool data) { unsigned int i, perc, perc_missing; - unsigned int max_bs, min_bs; + unsigned long long max_bs, min_bs; struct split split; memset(&split, 0, sizeof(split)); - if (split_parse_ddir(o, &split, ddir, str, data, BSSPLIT_MAX)) + if (split_parse_ddir(o, &split, str, data, BSSPLIT_MAX)) return 1; if (!split.nr) return 0; @@ -342,6 +341,43 @@ static int ignore_error_type(struct thread_data *td, enum error_type_bit etype, } +static int str_replay_skip_cb(void *data, const char *input) +{ + struct thread_data *td = cb_data_to_td(data); + char *str, *p, *n; + int ret = 0; + + if (parse_dryrun()) + return 0; + + p = str = strdup(input); + + strip_blank_front(&str); + strip_blank_end(str); + + while (p) { + n = strchr(p, ','); + if (n) + *n++ = '\0'; + if (!strcmp(p, "read")) + td->o.replay_skip |= 1u << DDIR_READ; + else if (!strcmp(p, "write")) + td->o.replay_skip |= 1u << DDIR_WRITE; + else if (!strcmp(p, "trim")) + td->o.replay_skip |= 1u << DDIR_TRIM; + else if (!strcmp(p, "sync")) + td->o.replay_skip |= 1u << DDIR_SYNC; + else { + log_err("Unknown skip type: %s\n", p); + ret = 1; + break; + } + p = n; + } + free(str); + return ret; +} + static int str_ignore_error_cb(void *data, const char *input) { struct thread_data *td = cb_data_to_td(data); @@ -845,7 +881,7 @@ static int zone_split_ddir(struct thread_options *o, enum fio_ddir ddir, memset(&split, 0, sizeof(split)); - if (split_parse_ddir(o, &split, ddir, str, absolute, ZONESPLIT_MAX)) + if (split_parse_ddir(o, &split, str, absolute, ZONESPLIT_MAX)) return 1; if (!split.nr) return 0; @@ -923,48 +959,6 @@ static int zone_split_ddir(struct thread_options *o, enum fio_ddir ddir, return 0; } -static void __td_zone_gen_index(struct thread_data *td, enum fio_ddir ddir) -{ - unsigned int i, j, sprev, aprev; - uint64_t sprev_sz; - - td->zone_state_index[ddir] = malloc(sizeof(struct zone_split_index) * 100); - - sprev_sz = sprev = aprev = 0; - for (i = 0; i < td->o.zone_split_nr[ddir]; i++) { - struct zone_split *zsp = &td->o.zone_split[ddir][i]; - - for (j = aprev; j < aprev + zsp->access_perc; j++) { - struct zone_split_index *zsi = &td->zone_state_index[ddir][j]; - - zsi->size_perc = sprev + zsp->size_perc; - zsi->size_perc_prev = sprev; - - zsi->size = sprev_sz + zsp->size; - zsi->size_prev = sprev_sz; - } - - aprev += zsp->access_perc; - sprev += zsp->size_perc; - sprev_sz += zsp->size; - } -} - -/* - * Generate state table for indexes, so we don't have to do it inline from - * the hot IO path - */ -static void td_zone_gen_index(struct thread_data *td) -{ - int i; - - td->zone_state_index = malloc(DDIR_RWDIR_CNT * - sizeof(struct zone_split_index *)); - - for (i = 0; i < DDIR_RWDIR_CNT; i++) - __td_zone_gen_index(td, i); -} - static int parse_zoned_distribution(struct thread_data *td, const char *input, bool absolute) { @@ -1010,8 +1004,6 @@ static int parse_zoned_distribution(struct thread_data *td, const char *input, } if (parse_dryrun()) { - int i; - for (i = 0; i < DDIR_RWDIR_CNT; i++) { free(td->o.zone_split[i]); td->o.zone_split[i] = NULL; @@ -1021,9 +1013,7 @@ static int parse_zoned_distribution(struct thread_data *td, const char *input, return ret; } - if (!ret) - td_zone_gen_index(td); - else { + if (ret) { for (i = 0; i < DDIR_RWDIR_CNT; i++) td->o.zone_split_nr[i] = 0; } @@ -1250,6 +1240,23 @@ int set_name_idx(char *target, size_t tlen, char *input, int index, return len; } +char* get_name_by_idx(char *input, int index) +{ + unsigned int cur_idx; + char *fname, *str, *p; + + p = str = strdup(input); + + index %= get_max_name_idx(input); + for (cur_idx = 0; cur_idx <= index; cur_idx++) + fname = get_next_name(&str); + + fname = strdup(fname); + free(p); + + return fname; +} + static int str_filename_cb(void *data, const char *input) { struct thread_data *td = cb_data_to_td(data); @@ -1521,9 +1528,9 @@ static int rw_verify(const struct fio_option *o, void *data) { struct thread_data *td = cb_data_to_td(data); - if (read_only && td_write(td)) { - log_err("fio: job <%s> has write bit set, but fio is in" - " read-only mode\n", td->o.name); + if (read_only && (td_write(td) || td_trim(td))) { + log_err("fio: job <%s> has write or trim bit set, but" + " fio is in read-only mode\n", td->o.name); return 1; } @@ -1816,21 +1823,11 @@ struct fio_option fio_options[FIO_MAX_OPTS] = { .help = "GUASI IO engine", }, #endif -#ifdef FIO_HAVE_BINJECT - { .ival = "binject", - .help = "binject direct inject block engine", - }, -#endif #ifdef CONFIG_RDMA { .ival = "rdma", .help = "RDMA IO engine", }, #endif -#ifdef CONFIG_FUSION_AW - { .ival = "fusion-aw-sync", - .help = "Fusion-io atomic write engine", - }, -#endif #ifdef CONFIG_LINUX_EXT4_MOVE_EXTENT { .ival = "e4defrag", .help = "ext4 defrag engine", @@ -1856,10 +1853,21 @@ struct fio_option fio_options[FIO_MAX_OPTS] = { #endif #ifdef CONFIG_PMEMBLK { .ival = "pmemblk", - .help = "NVML libpmemblk based IO engine", + .help = "PMDK libpmemblk based IO engine", }, #endif +#ifdef CONFIG_IME + { .ival = "ime_psync", + .help = "DDN's IME synchronous IO engine", + }, + { .ival = "ime_psyncv", + .help = "DDN's IME synchronous IO engine using iovecs", + }, + { .ival = "ime_aio", + .help = "DDN's IME asynchronous IO engine", + }, +#endif #ifdef CONFIG_LINUX_DEVDAX { .ival = "dev-dax", .help = "DAX Device based IO engine", @@ -1875,7 +1883,12 @@ struct fio_option fio_options[FIO_MAX_OPTS] = { }, #ifdef CONFIG_LIBPMEM { .ival = "libpmem", - .help = "NVML libpmem based IO engine", + .help = "PMDK libpmem based IO engine", + }, +#endif +#ifdef CONFIG_HTTP + { .ival = "http", + .help = "HTTP (WebDAV/S3) IO engine", }, #endif }, @@ -2083,7 +2096,7 @@ struct fio_option fio_options[FIO_MAX_OPTS] = { .name = "bs", .lname = "Block size", .alias = "blocksize", - .type = FIO_OPT_INT, + .type = FIO_OPT_ULL, .off1 = offsetof(struct thread_options, bs[DDIR_READ]), .off2 = offsetof(struct thread_options, bs[DDIR_WRITE]), .off3 = offsetof(struct thread_options, bs[DDIR_TRIM]), @@ -2100,7 +2113,7 @@ struct fio_option fio_options[FIO_MAX_OPTS] = { .name = "ba", .lname = "Block size align", .alias = "blockalign", - .type = FIO_OPT_INT, + .type = FIO_OPT_ULL, .off1 = offsetof(struct thread_options, ba[DDIR_READ]), .off2 = offsetof(struct thread_options, ba[DDIR_WRITE]), .off3 = offsetof(struct thread_options, ba[DDIR_TRIM]), @@ -2134,7 +2147,7 @@ struct fio_option fio_options[FIO_MAX_OPTS] = { { .name = "bssplit", .lname = "Block size split", - .type = FIO_OPT_STR, + .type = FIO_OPT_STR_ULL, .cb = str_bssplit_cb, .off1 = offsetof(struct thread_options, bssplit), .help = "Set a specific mix of block sizes", @@ -2851,25 +2864,14 @@ struct fio_option fio_options[FIO_MAX_OPTS] = { { .name = "verifysort", .lname = "Verify sort", - .type = FIO_OPT_BOOL, - .off1 = offsetof(struct thread_options, verifysort), - .help = "Sort written verify blocks for read back", - .def = "1", - .parent = "verify", - .hide = 1, + .type = FIO_OPT_SOFT_DEPRECATED, .category = FIO_OPT_C_IO, .group = FIO_OPT_G_VERIFY, }, { .name = "verifysort_nr", .lname = "Verify Sort Nr", - .type = FIO_OPT_INT, - .off1 = offsetof(struct thread_options, verifysort_nr), - .help = "Pre-load and sort verify blocks for a read workload", - .minval = 0, - .maxval = 131072, - .def = "1024", - .parent = "verify", + .type = FIO_OPT_SOFT_DEPRECATED, .category = FIO_OPT_C_IO, .group = FIO_OPT_G_VERIFY, }, @@ -3116,6 +3118,17 @@ struct fio_option fio_options[FIO_MAX_OPTS] = { .category = FIO_OPT_C_IO, .group = FIO_OPT_G_IOLOG, }, + { + .name = "read_iolog_chunked", + .lname = "Read I/O log in parts", + .type = FIO_OPT_BOOL, + .off1 = offsetof(struct thread_options, read_iolog_chunked), + .def = "0", + .parent = "read_iolog", + .help = "Parse IO pattern in chunks", + .category = FIO_OPT_C_IO, + .group = FIO_OPT_G_IOLOG, + }, { .name = "replay_no_stall", .lname = "Don't stall on replay", @@ -3161,6 +3174,30 @@ struct fio_option fio_options[FIO_MAX_OPTS] = { .group = FIO_OPT_G_IOLOG, .pow2 = 1, }, + { + .name = "replay_time_scale", + .lname = "Replay Time Scale", + .type = FIO_OPT_INT, + .off1 = offsetof(struct thread_options, replay_time_scale), + .def = "100", + .minval = 1, + .parent = "read_iolog", + .hide = 1, + .help = "Scale time for replay events", + .category = FIO_OPT_C_IO, + .group = FIO_OPT_G_IOLOG, + }, + { + .name = "replay_skip", + .lname = "Replay Skip", + .type = FIO_OPT_STR, + .cb = str_replay_skip_cb, + .off1 = offsetof(struct thread_options, replay_skip), + .parent = "read_iolog", + .help = "Skip certain IO types (read,write,trim,flush)", + .category = FIO_OPT_C_IO, + .group = FIO_OPT_G_IOLOG, + }, { .name = "exec_prerun", .lname = "Pre-execute runnable", @@ -3197,6 +3234,30 @@ struct fio_option fio_options[FIO_MAX_OPTS] = { .help = "Your platform does not support IO scheduler switching", }, #endif + { + .name = "zonemode", + .lname = "Zone mode", + .help = "Mode for the zonesize, zonerange and zoneskip parameters", + .type = FIO_OPT_STR, + .off1 = offsetof(struct thread_options, zone_mode), + .def = "none", + .category = FIO_OPT_C_IO, + .group = FIO_OPT_G_ZONE, + .posval = { + { .ival = "none", + .oval = ZONE_MODE_NONE, + .help = "no zoning", + }, + { .ival = "strided", + .oval = ZONE_MODE_STRIDED, + .help = "strided mode - random I/O is restricted to a single zone", + }, + { .ival = "zbd", + .oval = ZONE_MODE_ZBD, + .help = "zoned block device mode - random I/O selects one of multiple zones randomly", + }, + }, + }, { .name = "zonesize", .lname = "Zone size", @@ -3230,6 +3291,52 @@ struct fio_option fio_options[FIO_MAX_OPTS] = { .category = FIO_OPT_C_IO, .group = FIO_OPT_G_ZONE, }, + { + .name = "read_beyond_wp", + .lname = "Allow reads beyond the zone write pointer", + .type = FIO_OPT_BOOL, + .off1 = offsetof(struct thread_options, read_beyond_wp), + .help = "Allow reads beyond the zone write pointer", + .def = "0", + .category = FIO_OPT_C_IO, + .group = FIO_OPT_G_INVALID, + }, + { + .name = "max_open_zones", + .lname = "Maximum number of open zones", + .type = FIO_OPT_INT, + .off1 = offsetof(struct thread_options, max_open_zones), + .maxval = FIO_MAX_OPEN_ZBD_ZONES, + .help = "Limit random writes to SMR drives to the specified" + " number of sequential zones", + .def = "0", + .category = FIO_OPT_C_IO, + .group = FIO_OPT_G_INVALID, + }, + { + .name = "zone_reset_threshold", + .lname = "Zone reset threshold", + .help = "Zoned block device reset threshold", + .type = FIO_OPT_FLOAT_LIST, + .maxlen = 1, + .off1 = offsetof(struct thread_options, zrt), + .minfp = 0, + .maxfp = 1, + .category = FIO_OPT_C_IO, + .group = FIO_OPT_G_ZONE, + }, + { + .name = "zone_reset_frequency", + .lname = "Zone reset frequency", + .help = "Zoned block device zone reset frequency in HZ", + .type = FIO_OPT_FLOAT_LIST, + .maxlen = 1, + .off1 = offsetof(struct thread_options, zrf), + .minfp = 0, + .maxfp = 1, + .category = FIO_OPT_C_IO, + .group = FIO_OPT_G_ZONE, + }, { .name = "lockmem", .lname = "Lock memory", @@ -4428,15 +4535,15 @@ struct fio_option fio_options[FIO_MAX_OPTS] = { .prio = 1, .posval = { { .ival = "0", - .oval = 0, + .oval = N2S_NONE, .help = "Auto-detect", }, { .ival = "8", - .oval = 8, + .oval = N2S_BYTEPERSEC, .help = "Normal (byte based)", }, { .ival = "1", - .oval = 1, + .oval = N2S_BITPERSEC, .help = "Bit based", }, }, @@ -4748,7 +4855,7 @@ static char *bc_calc(char *str) * substitution always occurs, even if VARNAME is empty or the corresponding * environment variable undefined. */ -static char *option_dup_subs(const char *opt) +char *fio_option_dup_subs(const char *opt) { char out[OPT_LEN_MAX+1]; char in[OPT_LEN_MAX+1]; @@ -4853,7 +4960,7 @@ 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]); + opts_copy[i] = fio_option_dup_subs(opts[i]); if (!opts_copy[i]) continue; opts_copy[i] = fio_keyword_replace(opts_copy[i]); @@ -5117,8 +5224,7 @@ struct fio_option *fio_option_find(const char *name) return find_option(fio_options, name); } -static struct fio_option *find_next_opt(struct thread_options *o, - struct fio_option *from, +static struct fio_option *find_next_opt(struct fio_option *from, unsigned int off1) { struct fio_option *opt; @@ -5155,7 +5261,7 @@ bool __fio_option_is_set(struct thread_options *o, unsigned int off1) struct fio_option *opt, *next; next = NULL; - while ((opt = find_next_opt(o, next, off1)) != NULL) { + while ((opt = find_next_opt(next, off1)) != NULL) { if (opt_is_set(o, opt)) return true;