X-Git-Url: https://git.kernel.dk/?p=fio.git;a=blobdiff_plain;f=options.c;h=8fa50a8f5d987ebfa73098b0c5a17de5e2969940;hp=6352f0a8827bc8c8902f376aab677fbec4768d81;hb=8200b8c711cfabca65ce32e84f5985a2307a1ea9;hpb=de890a1e48d40238dac69f302708dde8719de240;ds=sidebyside diff --git a/options.c b/options.c index 6352f0a8..8fa50a8f 100644 --- a/options.c +++ b/options.c @@ -166,7 +166,7 @@ static int bssplit_ddir(struct thread_data *td, int ddir, char *str) static int str_bssplit_cb(void *data, const char *input) { struct thread_data *td = data; - char *str, *p, *odir; + char *str, *p, *odir, *ddir; int ret = 0; p = str = strdup(input); @@ -176,7 +176,21 @@ static int str_bssplit_cb(void *data, const char *input) odir = strchr(str, ','); if (odir) { - ret = bssplit_ddir(td, DDIR_WRITE, odir + 1); + ddir = strchr(odir + 1, ','); + if (ddir) { + ret = bssplit_ddir(td, DDIR_TRIM, ddir + 1); + if (!ret) + *ddir = '\0'; + } else { + char *op; + + op = strdup(odir + 1); + ret = bssplit_ddir(td, DDIR_TRIM, op); + + free(op); + } + if (!ret) + ret = bssplit_ddir(td, DDIR_WRITE, odir + 1); if (!ret) { *odir = '\0'; ret = bssplit_ddir(td, DDIR_READ, str); @@ -185,12 +199,15 @@ static int str_bssplit_cb(void *data, const char *input) char *op; op = strdup(str); + ret = bssplit_ddir(td, DDIR_WRITE, op); + free(op); + if (!ret) { + op = strdup(str); + ret = bssplit_ddir(td, DDIR_TRIM, op); + free(op); + } ret = bssplit_ddir(td, DDIR_READ, str); - if (!ret) - ret = bssplit_ddir(td, DDIR_WRITE, op); - - free(op); } free(p); @@ -245,12 +262,9 @@ static int str_verify_cb(void *data, const char *mem) { struct thread_data *td = data; - if (td->o.verify != VERIFY_CRC32C_INTEL) - return 0; - - if (!crc32c_intel_works()) { - log_info("fio: System does not support hw accelerated crc32c. Falling back to sw crc32c.\n"); - td->o.verify = VERIFY_CRC32C; + if (td->o.verify == VERIFY_CRC32C_INTEL || + td->o.verify == VERIFY_CRC32C) { + crc32c_intel_probe(); } return 0; @@ -689,12 +703,32 @@ static int str_verify_pattern_cb(void *data, const char *input) } } } + + /* + * 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; } @@ -915,6 +949,10 @@ static struct fio_option options[FIO_MAX_OPTS] = { .oval = TD_DDIR_WRITE, .help = "Sequential write", }, + { .ival = "trim", + .oval = TD_DDIR_TRIM, + .help = "Sequential trim", + }, { .ival = "randread", .oval = TD_DDIR_RANDREAD, .help = "Random read", @@ -923,10 +961,18 @@ static struct fio_option options[FIO_MAX_OPTS] = { .oval = TD_DDIR_RANDWRITE, .help = "Random write", }, + { .ival = "randtrim", + .oval = TD_DDIR_RANDTRIM, + .help = "Random trim", + }, { .ival = "rw", .oval = TD_DDIR_RW, .help = "Sequential read and write mix", }, + { .ival = "readwrite", + .oval = TD_DDIR_RW, + .help = "Sequential read and write mix", + }, { .ival = "randrw", .oval = TD_DDIR_RANDRW, .help = "Random read and write mix" @@ -1031,6 +1077,11 @@ static struct fio_option options[FIO_MAX_OPTS] = { { .ival = "rdma", .help = "RDMA IO engine", }, +#endif +#ifdef FIO_HAVE_FUSION_AW + { .ival = "fusion-aw-sync", + .help = "Fusion-io atomic write engine", + }, #endif { .ival = "external", .help = "Load external engine (append name)", @@ -1101,12 +1152,21 @@ static struct fio_option options[FIO_MAX_OPTS] = { .help = "Start IO from this offset", .def = "0", }, + { + .name = "offset_increment", + .type = FIO_OPT_STR_VAL, + .off1 = td_var_offset(offset_increment), + .help = "What is the increment from one offset to the next", + .parent = "offset", + .def = "0", + }, { .name = "bs", .alias = "blocksize", .type = FIO_OPT_INT, .off1 = td_var_offset(bs[DDIR_READ]), .off2 = td_var_offset(bs[DDIR_WRITE]), + .off3 = td_var_offset(bs[DDIR_TRIM]), .minval = 1, .help = "Block size unit", .def = "4k", @@ -1118,6 +1178,7 @@ static struct fio_option options[FIO_MAX_OPTS] = { .type = FIO_OPT_INT, .off1 = td_var_offset(ba[DDIR_READ]), .off2 = td_var_offset(ba[DDIR_WRITE]), + .off3 = td_var_offset(ba[DDIR_TRIM]), .minval = 1, .help = "IO block offset alignment", .parent = "rw", @@ -1130,6 +1191,8 @@ static struct fio_option options[FIO_MAX_OPTS] = { .off2 = td_var_offset(max_bs[DDIR_READ]), .off3 = td_var_offset(min_bs[DDIR_WRITE]), .off4 = td_var_offset(max_bs[DDIR_WRITE]), + .off5 = td_var_offset(min_bs[DDIR_TRIM]), + .off6 = td_var_offset(max_bs[DDIR_TRIM]), .minval = 1, .help = "Set block size range (in more detail than bs)", .parent = "rw", @@ -1462,12 +1525,12 @@ static struct fio_option options[FIO_MAX_OPTS] = { .help = "Use crc32 checksums for verification", }, { .ival = "crc32c-intel", - .oval = VERIFY_CRC32C_INTEL, - .help = "Use hw crc32c checksums for verification", + .oval = VERIFY_CRC32C, + .help = "Use crc32c checksums for verification (hw assisted, if available)", }, { .ival = "crc32c", .oval = VERIFY_CRC32C, - .help = "Use crc32c checksums for verification", + .help = "Use crc32c checksums for verification (hw assisted, if available)", }, { .ival = "crc16", .oval = VERIFY_CRC16, @@ -1670,6 +1733,13 @@ static struct fio_option options[FIO_MAX_OPTS] = { .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", }, @@ -1760,30 +1830,34 @@ static struct fio_option options[FIO_MAX_OPTS] = { { .name = "rate", .type = FIO_OPT_INT, - .off1 = td_var_offset(rate[0]), - .off2 = td_var_offset(rate[1]), + .off1 = td_var_offset(rate[DDIR_READ]), + .off2 = td_var_offset(rate[DDIR_WRITE]), + .off3 = td_var_offset(rate[DDIR_TRIM]), .help = "Set bandwidth rate", }, { .name = "ratemin", .type = FIO_OPT_INT, - .off1 = td_var_offset(ratemin[0]), - .off2 = td_var_offset(ratemin[1]), + .off1 = td_var_offset(ratemin[DDIR_READ]), + .off2 = td_var_offset(ratemin[DDIR_WRITE]), + .off3 = td_var_offset(ratemin[DDIR_TRIM]), .help = "Job must meet this rate or it will be shutdown", .parent = "rate", }, { .name = "rate_iops", .type = FIO_OPT_INT, - .off1 = td_var_offset(rate_iops[0]), - .off2 = td_var_offset(rate_iops[1]), + .off1 = td_var_offset(rate_iops[DDIR_READ]), + .off2 = td_var_offset(rate_iops[DDIR_WRITE]), + .off3 = td_var_offset(rate_iops[DDIR_TRIM]), .help = "Limit IO used to this number of IO operations/sec", }, { .name = "rate_iops_min", .type = FIO_OPT_INT, - .off1 = td_var_offset(rate_iops_min[0]), - .off2 = td_var_offset(rate_iops_min[1]), + .off1 = td_var_offset(rate_iops_min[DDIR_READ]), + .off2 = td_var_offset(rate_iops_min[DDIR_WRITE]), + .off3 = td_var_offset(rate_iops_min[DDIR_TRIM]), .help = "Job must meet this rate or it will be shut down", .parent = "rate_iops", }, @@ -1848,6 +1922,13 @@ static struct fio_option options[FIO_MAX_OPTS] = { .help = "Create files when they are opened for IO", .def = "0", }, + { + .name = "create_only", + .type = FIO_OPT_BOOL, + .off1 = td_var_offset(create_only), + .help = "Only perform file creation phase", + .def = "0", + }, { .name = "pre_read", .type = FIO_OPT_BOOL, @@ -1950,6 +2031,13 @@ static struct fio_option options[FIO_MAX_OPTS] = { .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, @@ -1982,6 +2070,21 @@ static struct fio_option options[FIO_MAX_OPTS] = { .help = "Slightly scramble buffers on every IO submit", .def = "1", }, + { + .name = "buffer_compress_percentage", + .type = FIO_OPT_INT, + .off1 = td_var_offset(compress_percentage), + .maxval = 100, + .minval = 1, + .help = "How compressible the buffer is (approximately)", + }, + { + .name = "buffer_compress_chunk", + .type = FIO_OPT_INT, + .off1 = td_var_offset(compress_chunk), + .parent = "buffer_compress_percentage", + .help = "Size of compressible region in buffer", + }, { .name = "clat_percentiles", .type = FIO_OPT_BOOL, @@ -2057,10 +2160,44 @@ static struct fio_option options[FIO_MAX_OPTS] = { }, { .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", @@ -2101,6 +2238,40 @@ static struct fio_option options[FIO_MAX_OPTS] = { .off1 = td_var_offset(gid), .help = "Run job with this group ID", }, + { + .name = "flow_id", + .type = FIO_OPT_INT, + .off1 = td_var_offset(flow_id), + .help = "The flow index ID to use", + .def = "0", + }, + { + .name = "flow", + .type = FIO_OPT_INT, + .off1 = td_var_offset(flow), + .help = "Weight for flow control of this job", + .parent = "flow_id", + .def = "0", + }, + { + .name = "flow_watermark", + .type = FIO_OPT_INT, + .off1 = td_var_offset(flow_watermark), + .help = "High watermark for flow control. This option" + " should be set to the same value for all threads" + " with non-zero flow.", + .parent = "flow_id", + .def = "1024", + }, + { + .name = "flow_sleep", + .type = FIO_OPT_INT, + .off1 = td_var_offset(flow_sleep), + .help = "How many microseconds to sleep after being held" + " back by the flow control mechanism", + .parent = "flow_id", + .def = "0", + }, { .name = NULL, }, @@ -2484,8 +2655,10 @@ void options_mem_dupe(void *data, struct fio_option *options) void fio_options_mem_dupe(struct thread_data *td) { options_mem_dupe(&td->o, options); - if (td->eo) { + + 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);