X-Git-Url: https://git.kernel.dk/?p=fio.git;a=blobdiff_plain;f=options.c;h=93f7f477acc8dafd214c03ec910e53052997d3e1;hp=5b882558177c106028141ac076ecbb71587db639;hb=20eb06bd2aef37fa8dd314a110bb81c733115e15;hpb=0e92f873a3d542d2b237d68fd9391c92a85fa0b8 diff --git a/options.c b/options.c index 5b882558..93f7f477 100644 --- a/options.c +++ b/options.c @@ -3,7 +3,6 @@ #include #include #include -#include #include #include #include @@ -14,8 +13,9 @@ #include "verify.h" #include "parse.h" #include "lib/fls.h" +#include "options.h" -#define td_var_offset(var) ((size_t) &((struct thread_options *)0)->var) +#include "crc/crc32c.h" /* * Check if mmap/mmaphuge has a :/foo/bar/file at the end. If so, return that. @@ -160,7 +160,6 @@ static int bssplit_ddir(struct thread_data *td, int ddir, char *str) qsort(bssplit, td->o.bssplit_nr[ddir], sizeof(struct bssplit), bs_cmp); td->o.bssplit[ddir] = bssplit; return 0; - } static int str_bssplit_cb(void *data, const char *input) @@ -202,12 +201,27 @@ static int str_rw_cb(void *data, const char *str) struct thread_data *td = data; char *nr = get_opt_postfix(str); - td->o.ddir_nr = 1; - if (nr) { - td->o.ddir_nr = atoi(nr); - free(nr); + td->o.ddir_seq_nr = 1; + td->o.ddir_seq_add = 0; + + if (!nr) + return 0; + + if (td_random(td)) + td->o.ddir_seq_nr = atoi(nr); + else { + long long val; + + if (str_to_decimal(nr, &val, 1, td)) { + log_err("fio: rw postfix parsing failed\n"); + free(nr); + return 1; + } + + td->o.ddir_seq_add = val; } + free(nr); return 0; } @@ -226,13 +240,34 @@ static int str_mem_cb(void *data, const char *mem) return 0; } -static int str_lockmem_cb(void fio_unused *data, unsigned long *val) +static int str_verify_cb(void *data, const char *mem) +{ + struct thread_data *td = data; + + if (td->o.verify == VERIFY_CRC32C_INTEL || + td->o.verify == VERIFY_CRC32C) { + crc32c_intel_probe(); + } + + return 0; +} + +static int fio_clock_source_cb(void *data, const char *str) +{ + struct thread_data *td = data; + + fio_clock_source = td->o.clocksource; + fio_time_init(); + return 0; +} + +static int str_lockmem_cb(void fio_unused *data, unsigned long long *val) { mlock_size = *val; return 0; } -static int str_rwmix_read_cb(void *data, unsigned int *val) +static int str_rwmix_read_cb(void *data, unsigned long long *val) { struct thread_data *td = data; @@ -241,7 +276,7 @@ static int str_rwmix_read_cb(void *data, unsigned int *val) return 0; } -static int str_rwmix_write_cb(void *data, unsigned int *val) +static int str_rwmix_write_cb(void *data, unsigned long long *val) { struct thread_data *td = data; @@ -251,7 +286,7 @@ static int str_rwmix_write_cb(void *data, unsigned int *val) } #ifdef FIO_HAVE_IOPRIO -static int str_prioclass_cb(void *data, unsigned int *val) +static int str_prioclass_cb(void *data, unsigned long long *val) { struct thread_data *td = data; unsigned short mask; @@ -267,7 +302,7 @@ static int str_prioclass_cb(void *data, unsigned int *val) return 0; } -static int str_prio_cb(void *data, unsigned int *val) +static int str_prio_cb(void *data, unsigned long long *val) { struct thread_data *td = data; @@ -291,7 +326,7 @@ static int str_exitall_cb(void) } #ifdef FIO_HAVE_CPU_AFFINITY -static int str_cpumask_cb(void *data, unsigned int *val) +static int str_cpumask_cb(void *data, unsigned long long *val) { struct thread_data *td = data; unsigned int i; @@ -305,7 +340,7 @@ static int str_cpumask_cb(void *data, unsigned int *val) return 1; } - max_cpu = sysconf(_SC_NPROCESSORS_ONLN); + max_cpu = cpus_online(); for (i = 0; i < sizeof(int) * 8; i++) { if ((1 << i) & *val) { @@ -342,7 +377,7 @@ static int set_cpus_allowed(struct thread_data *td, os_cpu_mask_t *mask, strip_blank_front(&str); strip_blank_end(str); - max_cpu = sysconf(_SC_NPROCESSORS_ONLN); + max_cpu = cpus_online(); while ((cpu = strsep(&str, ",")) != NULL) { char *str2, *cpu2; @@ -416,6 +451,16 @@ static int str_verify_cpus_allowed_cb(void *data, const char *input) } #endif +#ifdef FIO_HAVE_TRIM +static int str_verify_trim_cb(void *data, unsigned long long *val) +{ + struct thread_data *td = data; + + td->o.trim_percentage = *val; + return 0; +} +#endif + static int str_fst_cb(void *data, const char *str) { struct thread_data *td = data; @@ -430,8 +475,25 @@ static int str_fst_cb(void *data, const char *str) return 0; } +#ifdef FIO_HAVE_SYNC_FILE_RANGE +static int str_sfr_cb(void *data, const char *str) +{ + struct thread_data *td = data; + char *nr = get_opt_postfix(str); + + td->sync_file_range_nr = 1; + if (nr) { + td->sync_file_range_nr = atoi(nr); + free(nr); + } + + return 0; +} +#endif + static int check_dir(struct thread_data *td, char *fname) { +#if 0 char file[PATH_MAX], *dir; int elen = 0; @@ -444,7 +506,6 @@ static int check_dir(struct thread_data *td, char *fname) sprintf(file + elen, "%s", fname); dir = dirname(file); -#if 0 { struct stat sb; /* @@ -573,7 +634,7 @@ static int str_opendir_cb(void *data, const char fio_unused *str) return add_dir_files(td, td->o.opendir); } -static int str_verify_offset_cb(void *data, unsigned int *off) +static int str_verify_offset_cb(void *data, unsigned long long *off) { struct thread_data *td = data; @@ -624,7 +685,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; } @@ -664,21 +750,34 @@ static int str_write_lat_log_cb(void *data, const char *str) 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; int val = *il; + td->o.disable_lat = !!val; 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; return 0; } -static int str_gtod_cpu_cb(void *data, int *il) +static int str_gtod_cpu_cb(void *data, long long *il) { struct thread_data *td = data; int val = *il; @@ -688,6 +787,20 @@ static int str_gtod_cpu_cb(void *data, int *il) return 0; } +static int str_size_cb(void *data, unsigned long long *__val) +{ + struct thread_data *td = data; + unsigned long long v = *__val; + + if (parse_is_percent(v)) { + td->o.size = 0; + td->o.size_percent = -1ULL - v; + } else + td->o.size = v; + + return 0; +} + static int rw_verify(struct fio_option *o, void *data) { struct thread_data *td = data; @@ -729,24 +842,124 @@ static int kb_base_verify(struct fio_option *o, void *data) return 0; } -#define __stringify_1(x) #x -#define __stringify(x) __stringify_1(x) +/* + * Option grouping + */ +static struct opt_group fio_opt_groups[] = { + { + .name = "Description", + .mask = FIO_OPT_G_DESC, + }, + { + .name = "File", + .mask = FIO_OPT_G_FILE, + }, + { + .name = "Misc", + .mask = FIO_OPT_G_MISC, + }, + { + .name = "IO (main)", + .mask = FIO_OPT_G_IO, + }, + { + .name = "IO direction", + .mask = FIO_OPT_G_IO_DDIR, + }, + { + .name = "IO buffer", + .mask = FIO_OPT_G_IO_BUF, + }, + { + .name = "IO engine", + .mask = FIO_OPT_G_IO_ENG, + }, + { + .name = "Random", + .mask = FIO_OPT_G_RAND, + }, + { + .name = "OS", + .mask = FIO_OPT_G_OS, + }, + { + .name = "Memory", + .mask = FIO_OPT_G_MEM, + }, + { + .name = "Verify", + .mask = FIO_OPT_G_VERIFY, + }, + { + .name = "CPU", + .mask = FIO_OPT_G_CPU, + }, + { + .name = "Log", + .mask = FIO_OPT_G_LOG, + }, + { + .name = "Zone", + .mask = FIO_OPT_G_ZONE, + }, + { + .name = "Cache", + .mask = FIO_OPT_G_CACHE, + }, + { + .name = "Stat", + .mask = FIO_OPT_G_STAT, + }, + { + .name = "Error", + .mask = FIO_OPT_G_ERR, + }, + { + .name = "Job", + .mask = FIO_OPT_G_JOB, + }, + { + .name = NULL, + }, +}; + +struct opt_group *opt_group_from_mask(unsigned int *mask) +{ + struct opt_group *og; + int i; + + if (*mask == FIO_OPT_G_INVALID) + return NULL; + + for (i = 0; fio_opt_groups[i].name; i++) { + og = &fio_opt_groups[i]; + + if (*mask & og->mask) { + *mask &= ~(og->mask); + return og; + } + } + + return NULL; +} /* * Map of job/command line options */ -static struct fio_option options[] = { +struct fio_option fio_options[FIO_MAX_OPTS] = { { .name = "description", .type = FIO_OPT_STR_STORE, .off1 = td_var_offset(description), .help = "Text job description", + .category = FIO_OPT_G_DESC, }, { .name = "name", .type = FIO_OPT_STR_STORE, .off1 = td_var_offset(name), .help = "Name of this job", + .category = FIO_OPT_G_DESC, }, { .name = "directory", @@ -754,6 +967,7 @@ static struct fio_option options[] = { .off1 = td_var_offset(directory), .cb = str_directory_cb, .help = "Directory to store files in", + .category = FIO_OPT_G_FILE, }, { .name = "filename", @@ -762,6 +976,7 @@ static struct fio_option options[] = { .cb = str_filename_cb, .prio = -1, /* must come after "directory" */ .help = "File(s) to use for the workload", + .category = FIO_OPT_G_FILE, }, { .name = "kb_base", @@ -771,6 +986,7 @@ static struct fio_option options[] = { .prio = 1, .def = "1024", .help = "How many bytes per KB for reporting (1000 or 1024)", + .category = FIO_OPT_G_MISC, }, { .name = "lockfile", @@ -780,6 +996,7 @@ static struct fio_option options[] = { .help = "Lock file when doing IO to it", .parent = "filename", .def = "none", + .category = FIO_OPT_G_FILE, .posval = { { .ival = "none", .oval = FILE_LOCK_NONE, @@ -802,6 +1019,7 @@ static struct fio_option options[] = { .off1 = td_var_offset(opendir), .cb = str_opendir_cb, .help = "Recursively add files from this directory and down", + .category = FIO_OPT_G_FILE, }, { .name = "rw", @@ -812,6 +1030,7 @@ static struct fio_option options[] = { .help = "IO direction", .def = "read", .verify = rw_verify, + .category = FIO_OPT_G_IO_DDIR, .posval = { { .ival = "read", .oval = TD_DDIR_READ, @@ -839,12 +1058,32 @@ static struct fio_option options[] = { }, }, }, + { + .name = "rw_sequencer", + .type = FIO_OPT_STR, + .off1 = td_var_offset(rw_seq), + .help = "IO offset generator modifier", + .def = "sequential", + .category = FIO_OPT_G_IO_DDIR, + .posval = { + { .ival = "sequential", + .oval = RW_SEQ_SEQ, + .help = "Generate sequential offsets", + }, + { .ival = "identical", + .oval = RW_SEQ_IDENT, + .help = "Generate identical offsets", + }, + }, + }, + { .name = "ioengine", .type = FIO_OPT_STR_STORE, .off1 = td_var_offset(ioengine), .help = "IO engine to use", - .def = "sync", + .def = FIO_PREFERRED_ENGINE, + .category = FIO_OPT_G_IO, .posval = { { .ival = "sync", .help = "Use read/write", @@ -853,7 +1092,7 @@ static struct fio_option options[] = { .help = "Use pread/pwrite", }, { .ival = "vsync", - .help = "Use readv/writev", + .help = "Use readv/writev", }, #ifdef FIO_HAVE_LIBAIO { .ival = "libaio", @@ -869,9 +1108,14 @@ static struct fio_option options[] = { { .ival = "solarisaio", .help = "Solaris native asynchronous IO", }, +#endif +#ifdef FIO_HAVE_WINDOWSAIO + { .ival = "windowsaio", + .help = "Windows native asynchronous IO" + }, #endif { .ival = "mmap", - .help = "Memory mapped IO", + .help = "Memory mapped IO" }, #ifdef FIO_HAVE_SPLICE { .ival = "splice", @@ -898,12 +1142,22 @@ static struct fio_option options[] = { }, #endif { .ival = "cpuio", - .help = "CPU cycler burner engine", + .help = "CPU cycle burner engine", }, #ifdef FIO_HAVE_GUASI { .ival = "guasi", .help = "GUASI IO engine", }, +#endif +#ifdef FIO_HAVE_BINJECT + { .ival = "binject", + .help = "binject direct inject block engine", + }, +#endif +#ifdef FIO_HAVE_RDMA + { .ival = "rdma", + .help = "RDMA IO engine", + }, #endif { .ival = "external", .help = "Load external engine (append name)", @@ -914,9 +1168,11 @@ static struct fio_option options[] = { .name = "iodepth", .type = FIO_OPT_INT, .off1 = td_var_offset(iodepth), - .help = "Amount of IO buffers to keep in flight", + .help = "Number of IO buffers to keep in flight", .minval = 1, + .interval = 1, .def = "1", + .category = FIO_OPT_G_IO, }, { .name = "iodepth_batch", @@ -926,7 +1182,9 @@ static struct fio_option options[] = { .help = "Number of IO buffers to submit in one go", .parent = "iodepth", .minval = 1, + .interval = 1, .def = "1", + .category = FIO_OPT_G_IO, }, { .name = "iodepth_batch_complete", @@ -935,7 +1193,9 @@ static struct fio_option options[] = { .help = "Number of IO buffers to retrieve in one go", .parent = "iodepth", .minval = 0, + .interval = 1, .def = "1", + .category = FIO_OPT_G_IO, }, { .name = "iodepth_low", @@ -943,20 +1203,25 @@ static struct fio_option options[] = { .off1 = td_var_offset(iodepth_low), .help = "Low water mark for queuing depth", .parent = "iodepth", + .interval = 1, + .category = FIO_OPT_G_IO, }, { .name = "size", .type = FIO_OPT_STR_VAL, - .off1 = td_var_offset(size), - .minval = 1, + .cb = str_size_cb, .help = "Total size of device or files", + .interval = 1024 * 1024, + .category = FIO_OPT_G_IO, }, { .name = "fill_device", + .alias = "fill_fs", .type = FIO_OPT_BOOL, .off1 = td_var_offset(fill_device), .help = "Write until an ENOSPC error occurs", .def = "0", + .category = FIO_OPT_G_IO, }, { .name = "filesize", @@ -965,6 +1230,8 @@ static struct fio_option options[] = { .off2 = td_var_offset(file_size_high), .minval = 1, .help = "Size of individual files", + .interval = 1024 * 1024, + .category = FIO_OPT_G_IO | FIO_OPT_G_FILE, }, { .name = "offset", @@ -973,6 +1240,18 @@ static struct fio_option options[] = { .off1 = td_var_offset(start_offset), .help = "Start IO from this offset", .def = "0", + .interval = 1024 * 1024, + .category = FIO_OPT_G_IO, + }, + { + .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", + .interval = 1024 * 1024, + .category = FIO_OPT_G_IO, }, { .name = "bs", @@ -984,6 +1263,8 @@ static struct fio_option options[] = { .help = "Block size unit", .def = "4k", .parent = "rw", + .interval = 512, + .category = FIO_OPT_G_IO, }, { .name = "ba", @@ -994,6 +1275,8 @@ static struct fio_option options[] = { .minval = 1, .help = "IO block offset alignment", .parent = "rw", + .interval = 512, + .category = FIO_OPT_G_IO | FIO_OPT_G_IO_BUF, }, { .name = "bsrange", @@ -1006,6 +1289,8 @@ static struct fio_option options[] = { .minval = 1, .help = "Set block size range (in more detail than bs)", .parent = "rw", + .interval = 4096, + .category = FIO_OPT_G_IO, }, { .name = "bssplit", @@ -1013,6 +1298,7 @@ static struct fio_option options[] = { .cb = str_bssplit_cb, .help = "Set a specific mix of block sizes", .parent = "rw", + .category = FIO_OPT_G_IO, }, { .name = "bs_unaligned", @@ -1021,6 +1307,7 @@ static struct fio_option options[] = { .off1 = td_var_offset(bs_unaligned), .help = "Don't sector align IO buffer sizes", .parent = "rw", + .category = FIO_OPT_G_IO, }, { .name = "randrepeat", @@ -1029,6 +1316,16 @@ static struct fio_option options[] = { .help = "Use repeatable random IO pattern", .def = "1", .parent = "rw", + .category = FIO_OPT_G_IO | FIO_OPT_G_RAND, + }, + { + .name = "use_os_rand", + .type = FIO_OPT_BOOL, + .off1 = td_var_offset(use_os_rand), + .help = "Set to use OS random generator", + .def = "0", + .parent = "rw", + .category = FIO_OPT_G_RAND, }, { .name = "norandommap", @@ -1036,6 +1333,7 @@ static struct fio_option options[] = { .off1 = td_var_offset(norandommap), .help = "Accept potential duplicate random blocks", .parent = "rw", + .category = FIO_OPT_G_RAND, }, { .name = "softrandommap", @@ -1044,19 +1342,24 @@ static struct fio_option options[] = { .help = "Set norandommap if randommap allocation fails", .parent = "norandommap", .def = "0", + .category = FIO_OPT_G_RAND, }, { .name = "nrfiles", + .alias = "nr_files", .type = FIO_OPT_INT, .off1 = td_var_offset(nr_files), .help = "Split job workload between this number of files", .def = "1", + .interval = 1, + .category = FIO_OPT_G_FILE, }, { .name = "openfiles", .type = FIO_OPT_INT, .off1 = td_var_offset(open_files), .help = "Number of files to keep open at the same time", + .category = FIO_OPT_G_FILE, }, { .name = "file_service_type", @@ -1065,6 +1368,7 @@ static struct fio_option options[] = { .off1 = td_var_offset(file_service_type), .help = "How to select which file to service next", .def = "roundrobin", + .category = FIO_OPT_G_FILE, .posval = { { .ival = "random", .oval = FIO_FSERVICE_RANDOM, @@ -1081,12 +1385,48 @@ static struct fio_option options[] = { }, .parent = "nrfiles", }, +#ifdef FIO_HAVE_FALLOCATE + { + .name = "fallocate", + .type = FIO_OPT_STR, + .off1 = td_var_offset(fallocate_mode), + .help = "Whether pre-allocation is performed when laying out files", + .def = "posix", + .category = FIO_OPT_G_FILE, + .posval = { + { .ival = "none", + .oval = FIO_FALLOCATE_NONE, + .help = "Do not pre-allocate space", + }, + { .ival = "posix", + .oval = FIO_FALLOCATE_POSIX, + .help = "Use posix_fallocate()", + }, +#ifdef FIO_HAVE_LINUX_FALLOCATE + { .ival = "keep", + .oval = FIO_FALLOCATE_KEEP_SIZE, + .help = "Use fallocate(..., FALLOC_FL_KEEP_SIZE, ...)", + }, +#endif + /* Compatibility with former boolean values */ + { .ival = "0", + .oval = FIO_FALLOCATE_NONE, + .help = "Alias for 'none'", + }, + { .ival = "1", + .oval = FIO_FALLOCATE_POSIX, + .help = "Alias for 'posix'", + }, + }, + }, +#endif /* FIO_HAVE_FALLOCATE */ { .name = "fadvise_hint", .type = FIO_OPT_BOOL, .off1 = td_var_offset(fadvise_hint), .help = "Use fadvise() to advise the kernel on IO pattern", .def = "1", + .category = FIO_OPT_G_FILE, }, { .name = "fsync", @@ -1094,6 +1434,8 @@ static struct fio_option options[] = { .off1 = td_var_offset(fsync_blocks), .help = "Issue fsync for writes every given number of blocks", .def = "0", + .interval = 1, + .category = FIO_OPT_G_FILE, }, { .name = "fdatasync", @@ -1101,13 +1443,53 @@ static struct fio_option options[] = { .off1 = td_var_offset(fdatasync_blocks), .help = "Issue fdatasync for writes every given number of blocks", .def = "0", + .interval = 1, + .category = FIO_OPT_G_FILE, }, + { + .name = "write_barrier", + .type = FIO_OPT_INT, + .off1 = td_var_offset(barrier_blocks), + .help = "Make every Nth write a barrier write", + .def = "0", + .interval = 1, + .category = FIO_OPT_G_IO, + }, +#ifdef FIO_HAVE_SYNC_FILE_RANGE + { + .name = "sync_file_range", + .posval = { + { .ival = "wait_before", + .oval = SYNC_FILE_RANGE_WAIT_BEFORE, + .help = "SYNC_FILE_RANGE_WAIT_BEFORE", + .or = 1, + }, + { .ival = "write", + .oval = SYNC_FILE_RANGE_WRITE, + .help = "SYNC_FILE_RANGE_WRITE", + .or = 1, + }, + { + .ival = "wait_after", + .oval = SYNC_FILE_RANGE_WAIT_AFTER, + .help = "SYNC_FILE_RANGE_WAIT_AFTER", + .or = 1, + }, + }, + .type = FIO_OPT_STR_MULTI, + .cb = str_sfr_cb, + .off1 = td_var_offset(sync_file_range), + .help = "Use sync_file_range()", + .category = FIO_OPT_G_FILE, + }, +#endif { .name = "direct", .type = FIO_OPT_BOOL, .off1 = td_var_offset(odirect), .help = "Use O_DIRECT IO (negates buffered)", .def = "0", + .category = FIO_OPT_G_IO, }, { .name = "buffered", @@ -1116,6 +1498,7 @@ static struct fio_option options[] = { .neg = 1, .help = "Use buffered IO (negates direct)", .def = "1", + .category = FIO_OPT_G_IO, }, { .name = "overwrite", @@ -1123,6 +1506,7 @@ static struct fio_option options[] = { .off1 = td_var_offset(overwrite), .help = "When writing, set whether to overwrite current data", .def = "0", + .category = FIO_OPT_G_IO | FIO_OPT_G_FILE, }, { .name = "loops", @@ -1130,6 +1514,8 @@ static struct fio_option options[] = { .off1 = td_var_offset(loops), .help = "Number of times to run the job", .def = "1", + .interval = 1, + .category = FIO_OPT_G_MISC, }, { .name = "numjobs", @@ -1137,13 +1523,16 @@ static struct fio_option options[] = { .off1 = td_var_offset(numjobs), .help = "Duplicate this job this many times", .def = "1", + .interval = 1, + .category = FIO_OPT_G_MISC, }, { .name = "startdelay", - .type = FIO_OPT_INT, + .type = FIO_OPT_STR_VAL_TIME, .off1 = td_var_offset(start_delay), .help = "Only start job when this period has passed", .def = "0", + .category = FIO_OPT_G_MISC, }, { .name = "runtime", @@ -1152,18 +1541,45 @@ static struct fio_option options[] = { .off1 = td_var_offset(timeout), .help = "Stop workload when this amount of time has passed", .def = "0", + .category = FIO_OPT_G_MISC, }, { .name = "time_based", .type = FIO_OPT_STR_SET, .off1 = td_var_offset(time_based), .help = "Keep running until runtime/timeout is met", + .category = FIO_OPT_G_MISC, }, { .name = "ramp_time", .type = FIO_OPT_STR_VAL_TIME, .off1 = td_var_offset(ramp_time), .help = "Ramp up time before measuring performance", + .category = FIO_OPT_G_MISC, + }, + { + .name = "clocksource", + .type = FIO_OPT_STR, + .cb = fio_clock_source_cb, + .off1 = td_var_offset(clocksource), + .help = "What type of timing source to use", + .category = FIO_OPT_G_OS, + .posval = { + { .ival = "gettimeofday", + .oval = CS_GTOD, + .help = "Use gettimeofday(2) for timing", + }, + { .ival = "clock_gettime", + .oval = CS_CGETTIME, + .help = "Use clock_gettime(2) for timing", + }, +#ifdef ARCH_HAVE_CPU_CLOCK + { .ival = "cpu", + .oval = CS_CPUCLOCK, + .help = "Use CPU private clock", + }, +#endif + }, }, { .name = "mem", @@ -1173,6 +1589,7 @@ static struct fio_option options[] = { .off1 = td_var_offset(mem_type), .help = "Backing type for IO buffers", .def = "malloc", + .category = FIO_OPT_G_IO_BUF | FIO_OPT_G_MEM, .posval = { { .ival = "malloc", .oval = MEM_MALLOC, @@ -1209,13 +1626,16 @@ static struct fio_option options[] = { .help = "IO memory buffer offset alignment", .def = "0", .parent = "iomem", + .category = FIO_OPT_G_IO_BUF | FIO_OPT_G_MEM, }, { .name = "verify", .type = FIO_OPT_STR, .off1 = td_var_offset(verify), .help = "Verify data written", + .cb = str_verify_cb, .def = "0", + .category = FIO_OPT_G_IO | FIO_OPT_G_VERIFY, .posval = { { .ival = "0", .oval = VERIFY_NONE, @@ -1234,12 +1654,12 @@ static struct fio_option options[] = { .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, @@ -1279,6 +1699,7 @@ static struct fio_option options[] = { .help = "Run verification stage after write", .def = "1", .parent = "verify", + .category = FIO_OPT_G_IO | FIO_OPT_G_VERIFY, }, { .name = "verifysort", @@ -1287,6 +1708,7 @@ static struct fio_option options[] = { .help = "Sort written verify blocks for read back", .def = "1", .parent = "verify", + .category = FIO_OPT_G_IO | FIO_OPT_G_VERIFY, }, { .name = "verify_interval", @@ -1295,6 +1717,8 @@ static struct fio_option options[] = { .minval = 2 * sizeof(struct verify_header), .help = "Store verify buffer header every N bytes", .parent = "verify", + .interval = 2 * sizeof(struct verify_header), + .category = FIO_OPT_G_IO | FIO_OPT_G_VERIFY, }, { .name = "verify_offset", @@ -1303,6 +1727,7 @@ static struct fio_option options[] = { .def = "0", .cb = str_verify_offset_cb, .parent = "verify", + .category = FIO_OPT_G_IO | FIO_OPT_G_VERIFY, }, { .name = "verify_pattern", @@ -1310,6 +1735,7 @@ static struct fio_option options[] = { .cb = str_verify_pattern_cb, .help = "Fill pattern for IO buffers", .parent = "verify", + .category = FIO_OPT_G_IO | FIO_OPT_G_VERIFY, }, { .name = "verify_fatal", @@ -1318,6 +1744,16 @@ static struct fio_option options[] = { .def = "0", .help = "Exit on a single verify failure, don't continue", .parent = "verify", + .category = FIO_OPT_G_IO | FIO_OPT_G_VERIFY | FIO_OPT_G_ERR, + }, + { + .name = "verify_dump", + .type = FIO_OPT_BOOL, + .off1 = td_var_offset(verify_dump), + .def = "0", + .help = "Dump contents of good and bad blocks on failure", + .parent = "verify", + .category = FIO_OPT_G_IO | FIO_OPT_G_VERIFY | FIO_OPT_G_ERR, }, { .name = "verify_async", @@ -1326,6 +1762,23 @@ static struct fio_option options[] = { .def = "0", .help = "Number of async verifier threads to use", .parent = "verify", + .category = FIO_OPT_G_IO | FIO_OPT_G_VERIFY, + }, + { + .name = "verify_backlog", + .type = FIO_OPT_STR_VAL, + .off1 = td_var_offset(verify_backlog), + .help = "Verify after this number of blocks are written", + .parent = "verify", + .category = FIO_OPT_G_IO | FIO_OPT_G_VERIFY, + }, + { + .name = "verify_backlog_batch", + .type = FIO_OPT_INT, + .off1 = td_var_offset(verify_batch), + .help = "Verify this number of IO blocks", + .parent = "verify", + .category = FIO_OPT_G_IO | FIO_OPT_G_VERIFY, }, #ifdef FIO_HAVE_CPU_AFFINITY { @@ -1334,6 +1787,48 @@ static struct fio_option options[] = { .cb = str_verify_cpus_allowed_cb, .help = "Set CPUs allowed for async verify threads", .parent = "verify_async", + .category = FIO_OPT_G_OS | FIO_OPT_G_CPU | FIO_OPT_G_VERIFY, + }, +#endif +#ifdef FIO_HAVE_TRIM + { + .name = "trim_percentage", + .type = FIO_OPT_INT, + .cb = str_verify_trim_cb, + .minval = 0, + .maxval = 100, + .help = "Number of verify blocks to discard/trim", + .parent = "verify", + .def = "0", + .interval = 1, + .category = FIO_OPT_G_IO, + }, + { + .name = "trim_verify_zero", + .type = FIO_OPT_BOOL, + .help = "Verify that trim/discarded blocks are returned as zeroes", + .off1 = td_var_offset(trim_zero), + .parent = "trim_percentage", + .def = "1", + .category = FIO_OPT_G_IO, + }, + { + .name = "trim_backlog", + .type = FIO_OPT_STR_VAL, + .off1 = td_var_offset(trim_backlog), + .help = "Trim after this number of blocks are written", + .parent = "trim_percentage", + .interval = 1, + .category = FIO_OPT_G_IO, + }, + { + .name = "trim_backlog_batch", + .type = FIO_OPT_INT, + .off1 = td_var_offset(trim_batch), + .help = "Trim this number of IO blocks", + .parent = "trim_percentage", + .interval = 1, + .category = FIO_OPT_G_IO, }, #endif { @@ -1341,24 +1836,45 @@ static struct fio_option options[] = { .type = FIO_OPT_STR_STORE, .off1 = td_var_offset(write_iolog_file), .help = "Store IO pattern to file", + .category = FIO_OPT_G_IO | FIO_OPT_G_LOG, }, { .name = "read_iolog", .type = FIO_OPT_STR_STORE, .off1 = td_var_offset(read_iolog_file), .help = "Playback IO pattern from file", + .category = FIO_OPT_G_IO | FIO_OPT_G_LOG, + }, + { + .name = "replay_no_stall", + .type = FIO_OPT_BOOL, + .off1 = td_var_offset(no_stall), + .def = "0", + .parent = "read_iolog", + .help = "Playback IO pattern file as fast as possible without stalls", + .category = FIO_OPT_G_IO | FIO_OPT_G_LOG, + }, + { + .name = "replay_redirect", + .type = FIO_OPT_STR_STORE, + .off1 = td_var_offset(replay_redirect), + .parent = "read_iolog", + .help = "Replay all I/O onto this device, regardless of trace device", + .category = FIO_OPT_G_IO | FIO_OPT_G_LOG, }, { .name = "exec_prerun", .type = FIO_OPT_STR_STORE, .off1 = td_var_offset(exec_prerun), .help = "Execute this file prior to running job", + .category = FIO_OPT_G_MISC | FIO_OPT_G_OS, }, { .name = "exec_postrun", .type = FIO_OPT_STR_STORE, .off1 = td_var_offset(exec_postrun), .help = "Execute this file after running job", + .category = FIO_OPT_G_MISC | FIO_OPT_G_OS, }, #ifdef FIO_HAVE_IOSCHED_SWITCH { @@ -1366,14 +1882,26 @@ static struct fio_option options[] = { .type = FIO_OPT_STR_STORE, .off1 = td_var_offset(ioscheduler), .help = "Use this IO scheduler on the backing device", + .category = FIO_OPT_G_OS | FIO_OPT_G_IO, }, #endif { .name = "zonesize", .type = FIO_OPT_STR_VAL, .off1 = td_var_offset(zone_size), + .help = "Amount of data to read per zone", + .def = "0", + .interval = 1024 * 1024, + .category = FIO_OPT_G_IO | FIO_OPT_G_ZONE, + }, + { + .name = "zonerange", + .type = FIO_OPT_STR_VAL, + .off1 = td_var_offset(zone_range), .help = "Give size of an IO zone", .def = "0", + .interval = 1024 * 1024, + .category = FIO_OPT_G_IO | FIO_OPT_G_ZONE, }, { .name = "zoneskip", @@ -1381,6 +1909,8 @@ static struct fio_option options[] = { .off1 = td_var_offset(zone_skip), .help = "Space between IO zones", .def = "0", + .interval = 1024 * 1024, + .category = FIO_OPT_G_IO | FIO_OPT_G_ZONE, }, { .name = "lockmem", @@ -1388,6 +1918,8 @@ static struct fio_option options[] = { .cb = str_lockmem_cb, .help = "Lock down this amount of memory", .def = "0", + .interval = 1024 * 1024, + .category = FIO_OPT_G_OS | FIO_OPT_G_MEM, }, { .name = "rwmixread", @@ -1396,6 +1928,8 @@ static struct fio_option options[] = { .maxval = 100, .help = "Percentage of mixed workload that is reads", .def = "50", + .interval = 5, + .category = FIO_OPT_G_IO, }, { .name = "rwmixwrite", @@ -1404,10 +1938,13 @@ static struct fio_option options[] = { .maxval = 100, .help = "Percentage of mixed workload that is writes", .def = "50", + .interval = 5, + .category = FIO_OPT_G_IO, }, { .name = "rwmixcycle", .type = FIO_OPT_DEPRECATED, + .category = FIO_OPT_G_IO, }, { .name = "nice", @@ -1417,6 +1954,8 @@ static struct fio_option options[] = { .minval = -19, .maxval = 20, .def = "0", + .interval = 1, + .category = FIO_OPT_G_OS | FIO_OPT_G_CPU, }, #ifdef FIO_HAVE_IOPRIO { @@ -1426,6 +1965,8 @@ static struct fio_option options[] = { .help = "Set job IO priority value", .minval = 0, .maxval = 7, + .interval = 1, + .category = FIO_OPT_G_OS | FIO_OPT_G_CPU, }, { .name = "prioclass", @@ -1434,6 +1975,8 @@ static struct fio_option options[] = { .help = "Set job IO priority class", .minval = 0, .maxval = 3, + .interval = 1, + .category = FIO_OPT_G_OS | FIO_OPT_G_CPU, }, #endif { @@ -1442,6 +1985,7 @@ static struct fio_option options[] = { .off1 = td_var_offset(thinktime), .help = "Idle time between IO buffers (usec)", .def = "0", + .category = FIO_OPT_G_MISC, }, { .name = "thinktime_spin", @@ -1450,6 +1994,7 @@ static struct fio_option options[] = { .help = "Start think time by spinning this amount (usec)", .def = "0", .parent = "thinktime", + .category = FIO_OPT_G_MISC, }, { .name = "thinktime_blocks", @@ -1458,6 +2003,7 @@ static struct fio_option options[] = { .help = "IO buffer period between 'thinktime'", .def = "1", .parent = "thinktime", + .category = FIO_OPT_G_MISC, }, { .name = "rate", @@ -1465,6 +2011,7 @@ static struct fio_option options[] = { .off1 = td_var_offset(rate[0]), .off2 = td_var_offset(rate[1]), .help = "Set bandwidth rate", + .category = FIO_OPT_G_IO, }, { .name = "ratemin", @@ -1473,6 +2020,7 @@ static struct fio_option options[] = { .off2 = td_var_offset(ratemin[1]), .help = "Job must meet this rate or it will be shutdown", .parent = "rate", + .category = FIO_OPT_G_IO, }, { .name = "rate_iops", @@ -1480,14 +2028,16 @@ static struct fio_option options[] = { .off1 = td_var_offset(rate_iops[0]), .off2 = td_var_offset(rate_iops[1]), .help = "Limit IO used to this number of IO operations/sec", + .category = FIO_OPT_G_IO, }, { .name = "rate_iops_min", .type = FIO_OPT_INT, .off1 = td_var_offset(rate_iops_min[0]), .off2 = td_var_offset(rate_iops_min[1]), - .help = "Job must meet this rate or it will be shutdown", + .help = "Job must meet this rate or it will be shut down", .parent = "rate_iops", + .category = FIO_OPT_G_IO, }, { .name = "ratecycle", @@ -1496,6 +2046,7 @@ static struct fio_option options[] = { .help = "Window average for rate limits (msec)", .def = "1000", .parent = "rate", + .category = FIO_OPT_G_IO, }, { .name = "invalidate", @@ -1503,6 +2054,7 @@ static struct fio_option options[] = { .off1 = td_var_offset(invalidate_cache), .help = "Invalidate buffer/page cache prior to running job", .def = "1", + .category = FIO_OPT_G_IO | FIO_OPT_G_CACHE, }, { .name = "sync", @@ -1511,6 +2063,7 @@ static struct fio_option options[] = { .help = "Use O_SYNC for buffered writes", .def = "0", .parent = "buffered", + .category = FIO_OPT_G_IO | FIO_OPT_G_FILE, }, { .name = "bwavgtime", @@ -1519,6 +2072,19 @@ static struct fio_option options[] = { .help = "Time window over which to calculate bandwidth" " (msec)", .def = "500", + .parent = "write_bw_log", + .interval = 100, + .category = FIO_OPT_G_LOG | FIO_OPT_G_STAT, + }, + { + .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", + .interval = 100, + .category = FIO_OPT_G_LOG | FIO_OPT_G_STAT, }, { .name = "create_serialize", @@ -1526,13 +2092,15 @@ static struct fio_option options[] = { .off1 = td_var_offset(create_serialize), .help = "Serialize creating of job files", .def = "1", + .category = FIO_OPT_G_FILE, }, { .name = "create_fsync", .type = FIO_OPT_BOOL, .off1 = td_var_offset(create_fsync), - .help = "Fsync file after creation", + .help = "fsync file after creation", .def = "1", + .category = FIO_OPT_G_FILE, }, { .name = "create_on_open", @@ -1540,19 +2108,22 @@ static struct fio_option options[] = { .off1 = td_var_offset(create_on_open), .help = "Create files when they are opened for IO", .def = "0", + .category = FIO_OPT_G_FILE, }, { .name = "pre_read", .type = FIO_OPT_BOOL, .off1 = td_var_offset(pre_read), - .help = "Preread files before starting official testing", + .help = "Pre-read files before starting official testing", .def = "0", + .category = FIO_OPT_G_FILE | FIO_OPT_G_CACHE, }, { .name = "cpuload", .type = FIO_OPT_INT, .off1 = td_var_offset(cpuload), .help = "Use this percentage of CPU", + .category = FIO_OPT_G_CPU, }, { .name = "cpuchunks", @@ -1561,6 +2132,7 @@ static struct fio_option options[] = { .help = "Length of the CPU burn cycles (usecs)", .def = "50000", .parent = "cpuload", + .category = FIO_OPT_G_CPU, }, #ifdef FIO_HAVE_CPU_AFFINITY { @@ -1568,12 +2140,14 @@ static struct fio_option options[] = { .type = FIO_OPT_INT, .cb = str_cpumask_cb, .help = "CPU affinity mask", + .category = FIO_OPT_G_CPU | FIO_OPT_G_OS, }, { .name = "cpus_allowed", .type = FIO_OPT_STR, .cb = str_cpus_allowed_cb, .help = "Set CPUs allowed", + .category = FIO_OPT_G_CPU | FIO_OPT_G_OS, }, #endif { @@ -1582,6 +2156,7 @@ static struct fio_option options[] = { .off1 = td_var_offset(end_fsync), .help = "Include fsync at the end of job", .def = "0", + .category = FIO_OPT_G_FILE, }, { .name = "fsync_on_close", @@ -1589,6 +2164,7 @@ static struct fio_option options[] = { .off1 = td_var_offset(fsync_on_close), .help = "fsync files on close", .def = "0", + .category = FIO_OPT_G_FILE, }, { .name = "unlink", @@ -1596,30 +2172,36 @@ static struct fio_option options[] = { .off1 = td_var_offset(unlink), .help = "Unlink created files after job has completed", .def = "0", + .category = FIO_OPT_G_FILE, }, { .name = "exitall", .type = FIO_OPT_STR_SET, .cb = str_exitall_cb, .help = "Terminate all jobs when one exits", + .category = FIO_OPT_G_MISC | FIO_OPT_G_JOB, }, { .name = "stonewall", + .alias = "wait_for_previous", .type = FIO_OPT_STR_SET, .off1 = td_var_offset(stonewall), .help = "Insert a hard barrier between this job and previous", + .category = FIO_OPT_G_MISC | FIO_OPT_G_JOB, }, { .name = "new_group", .type = FIO_OPT_STR_SET, .off1 = td_var_offset(new_group), .help = "Mark the start of a new group (for reporting)", + .category = FIO_OPT_G_MISC | FIO_OPT_G_JOB, }, { .name = "thread", .type = FIO_OPT_STR_SET, .off1 = td_var_offset(use_thread), - .help = "Use threads instead of forks", + .help = "Use threads instead of processes", + .category = FIO_OPT_G_MISC | FIO_OPT_G_OS | FIO_OPT_G_JOB, }, { .name = "write_bw_log", @@ -1627,6 +2209,7 @@ static struct fio_option options[] = { .off1 = td_var_offset(write_bw_log), .cb = str_write_bw_log_cb, .help = "Write log of bandwidth during run", + .category = FIO_OPT_G_LOG, }, { .name = "write_lat_log", @@ -1634,32 +2217,101 @@ static struct fio_option options[] = { .off1 = td_var_offset(write_lat_log), .cb = str_write_lat_log_cb, .help = "Write log of latency during run", + .category = FIO_OPT_G_LOG, + }, + { + .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", + .category = FIO_OPT_G_LOG, + }, + { + .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", + .category = FIO_OPT_G_LOG, }, { .name = "hugepage-size", .type = FIO_OPT_INT, .off1 = td_var_offset(hugepage_size), .help = "When using hugepages, specify size of each page", - .def = __stringify(FIO_HUGE_PAGE), + .def = __fio_stringify(FIO_HUGE_PAGE), + .interval = 1024 * 1024, + .category = FIO_OPT_G_OS | FIO_OPT_G_MEM, }, { .name = "group_reporting", .type = FIO_OPT_STR_SET, .off1 = td_var_offset(group_reporting), .help = "Do reporting on a per-group basis", + .category = FIO_OPT_G_MISC, }, { .name = "zero_buffers", .type = FIO_OPT_STR_SET, .off1 = td_var_offset(zero_buffers), .help = "Init IO buffers to all zeroes", + .category = FIO_OPT_G_IO_BUF, }, { .name = "refill_buffers", .type = FIO_OPT_STR_SET, .off1 = td_var_offset(refill_buffers), .help = "Refill IO buffers on every IO submit", + .category = FIO_OPT_G_IO_BUF, }, + { + .name = "scramble_buffers", + .type = FIO_OPT_BOOL, + .off1 = td_var_offset(scramble_buffers), + .help = "Slightly scramble buffers on every IO submit", + .def = "1", + .category = FIO_OPT_G_IO_BUF, + }, + { + .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)", + .interval = 5, + .category = FIO_OPT_G_IO_BUF, + }, + { + .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", + .interval = 256, + .category = FIO_OPT_G_IO_BUF, + }, + { + .name = "clat_percentiles", + .type = FIO_OPT_BOOL, + .off1 = td_var_offset(clat_percentiles), + .help = "Enable the reporting of completion latency percentiles", + .def = "1", + .category = FIO_OPT_G_STAT, + }, + { + .name = "percentile_list", + .type = FIO_OPT_FLOAT_LIST, + .off1 = td_var_offset(percentile_list), + .off2 = td_var_offset(overwrite_plist), + .help = "Specify a custom list of percentiles to report", + .maxlen = FIO_IO_U_LIST_MAX_LEN, + .minfp = 0.0, + .maxfp = 100.0, + .category = FIO_OPT_G_STAT, + }, + #ifdef FIO_HAVE_DISK_UTIL { .name = "disk_util", @@ -1667,6 +2319,7 @@ static struct fio_option options[] = { .off1 = td_var_offset(do_disk_util), .help = "Log disk utilization statistics", .def = "1", + .category = FIO_OPT_G_OS | FIO_OPT_G_STAT, }, #endif { @@ -1675,6 +2328,16 @@ static struct fio_option options[] = { .help = "Greatly reduce number of gettimeofday() calls", .cb = str_gtod_reduce_cb, .def = "0", + .category = FIO_OPT_G_OS | FIO_OPT_G_MISC | FIO_OPT_G_STAT, + }, + { + .name = "disable_lat", + .type = FIO_OPT_BOOL, + .off1 = td_var_offset(disable_lat), + .help = "Disable latency numbers", + .parent = "gtod_reduce", + .def = "0", + .category = FIO_OPT_G_OS | FIO_OPT_G_MISC | FIO_OPT_G_STAT, }, { .name = "disable_clat", @@ -1683,14 +2346,16 @@ static struct fio_option options[] = { .help = "Disable completion latency numbers", .parent = "gtod_reduce", .def = "0", + .category = FIO_OPT_G_OS | FIO_OPT_G_MISC | FIO_OPT_G_STAT, }, { .name = "disable_slat", .type = FIO_OPT_BOOL, .off1 = td_var_offset(disable_slat), - .help = "Disable submissionn latency numbers", + .help = "Disable submission latency numbers", .parent = "gtod_reduce", .def = "0", + .category = FIO_OPT_G_OS | FIO_OPT_G_MISC | FIO_OPT_G_STAT, }, { .name = "disable_bw_measurement", @@ -1699,50 +2364,210 @@ static struct fio_option options[] = { .help = "Disable bandwidth logging", .parent = "gtod_reduce", .def = "0", + .category = FIO_OPT_G_OS | FIO_OPT_G_MISC | FIO_OPT_G_STAT, }, { .name = "gtod_cpu", .type = FIO_OPT_INT, .cb = str_gtod_cpu_cb, - .help = "Setup dedicated gettimeofday() thread on this CPU", + .help = "Set up dedicated gettimeofday() thread on this CPU", .verify = gtod_cpu_verify, + .category = FIO_OPT_G_OS | FIO_OPT_G_MISC | FIO_OPT_G_STAT, }, { .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 I/O", + .help = "Continue on non-fatal errors during IO", + .def = "none", + .category = FIO_OPT_G_MISC | FIO_OPT_G_ERR, + .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", + .type = FIO_OPT_STR_STORE, + .off1 = td_var_offset(profile), + .help = "Select a specific builtin performance test", + .category = FIO_OPT_G_MISC | FIO_OPT_G_JOB, + }, + { + .name = "cgroup", + .type = FIO_OPT_STR_STORE, + .off1 = td_var_offset(cgroup), + .help = "Add job to cgroup of this name", + .category = FIO_OPT_G_MISC | FIO_OPT_G_OS, + }, + { + .name = "cgroup_weight", + .type = FIO_OPT_INT, + .off1 = td_var_offset(cgroup_weight), + .help = "Use given weight for cgroup", + .minval = 100, + .maxval = 1000, + .category = FIO_OPT_G_MISC | FIO_OPT_G_OS, + }, + { + .name = "cgroup_nodelete", + .type = FIO_OPT_BOOL, + .off1 = td_var_offset(cgroup_nodelete), + .help = "Do not delete cgroups after job completion", .def = "0", + .category = FIO_OPT_G_MISC | FIO_OPT_G_OS, + }, + { + .name = "uid", + .type = FIO_OPT_INT, + .off1 = td_var_offset(uid), + .help = "Run job with this user ID", + .category = FIO_OPT_G_OS | FIO_OPT_G_JOB, + }, + { + .name = "gid", + .type = FIO_OPT_INT, + .off1 = td_var_offset(gid), + .help = "Run job with this group ID", + .category = FIO_OPT_G_OS | FIO_OPT_G_JOB, + }, + { + .name = "flow_id", + .type = FIO_OPT_INT, + .off1 = td_var_offset(flow_id), + .help = "The flow index ID to use", + .def = "0", + .category = FIO_OPT_G_IO, + }, + { + .name = "flow", + .type = FIO_OPT_INT, + .off1 = td_var_offset(flow), + .help = "Weight for flow control of this job", + .parent = "flow_id", + .def = "0", + .category = FIO_OPT_G_IO, + }, + { + .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", + .category = FIO_OPT_G_IO, + }, + { + .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", + .category = FIO_OPT_G_IO, }, { .name = NULL, }, }; +static void add_to_lopt(struct option *lopt, struct fio_option *o, + const char *name, int val) +{ + lopt->name = (char *) name; + lopt->val = val; + if (o->type == FIO_OPT_STR_SET) + lopt->has_arg = no_argument; + else + lopt->has_arg = required_argument; +} + +static void options_to_lopts(struct fio_option *opts, + struct option *long_options, + int i, int option_type) +{ + struct fio_option *o = &opts[0]; + while (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, option_type); + } + + i++; + o++; + assert(i < FIO_NR_OPTIONS); + } +} + +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) { - struct fio_option *o; unsigned int i; - options_init(options); + options_init(fio_options); i = 0; while (long_options[i].name) i++; - o = &options[0]; - while (o->name) { - long_options[i].name = (char *) o->name; - long_options[i].val = FIO_GETOPT_JOB; - if (o->type == FIO_OPT_STR_SET) - long_options[i].has_arg = no_argument; - else - long_options[i].has_arg = required_argument; - - i++; - o++; - assert(i < FIO_NR_OPTIONS); - } + options_to_lopts(fio_options, long_options, i, FIO_GETOPT_JOB); } struct fio_keyword { @@ -1771,23 +2596,130 @@ static struct fio_keyword fio_keywords[] = { void fio_keywords_init(void) { - unsigned long mb_memory; + unsigned long long mb_memory; char buf[128]; long l; sprintf(buf, "%lu", page_size); fio_keywords[0].replace = strdup(buf); - l = sysconf(_SC_PHYS_PAGES); - mb_memory = l * (page_size / 1024UL); - sprintf(buf, "%lu", mb_memory); + mb_memory = os_phys_mem() / (1024 * 1024); + sprintf(buf, "%llu", mb_memory); fio_keywords[1].replace = strdup(buf); - l = sysconf(_SC_NPROCESSORS_ONLN); + l = cpus_online(); sprintf(buf, "%lu", l); fio_keywords[2].replace = strdup(buf); } +#define BC_APP "bc" + +static char *bc_calc(char *str) +{ + char buf[128], *tmp; + FILE *f; + int ret; + + /* + * No math, just return string + */ + if ((!strchr(str, '+') && !strchr(str, '-') && !strchr(str, '*') && + !strchr(str, '/')) || strchr(str, '\'')) + return str; + + /* + * Split option from value, we only need to calculate the value + */ + tmp = strchr(str, '='); + if (!tmp) + return str; + + tmp++; + + /* + * 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"); + return NULL; + } + + sprintf(buf, "echo '%s' | %s", tmp, BC_APP); + f = popen(buf, "r"); + if (!f) { + return NULL; + } + + ret = fread(&buf[tmp - str], 1, 128 - (tmp - str), f); + if (ret <= 0) { + return NULL; + } + + pclose(f); + buf[(tmp - str) + ret - 1] = '\0'; + memcpy(buf, str, tmp - str); + free(str); + 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); +} + /* * Look for reserved variable names and replace them with real values */ @@ -1795,6 +2727,7 @@ static char *fio_keyword_replace(char *opt) { char *s; int i; + int docalc = 0; for (i = 0; fio_keywords[i].word != NULL; i++) { struct fio_keyword *kw = &fio_keywords[i]; @@ -1825,77 +2758,138 @@ static char *fio_keyword_replace(char *opt) */ opt = new; free(o_org); + + 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, fio_options, num_opts); + opts_copy = dup_and_sub_options(opts, num_opts); - sort_options(opts, options, 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); - 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; } int fio_cmd_option_parse(struct thread_data *td, const char *opt, char *val) { - return parse_cmd_option(opt, val, options, td); + return parse_cmd_option(opt, val, fio_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); + fill_default_options(td, fio_options); } int fio_show_option_help(const char *opt) { - return show_cmd_help(options, opt); + return show_cmd_help(fio_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, fio_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) @@ -1910,3 +2904,81 @@ unsigned int fio_get_kb_base(void *data) return kb_base; } + +int add_option(struct fio_option *o) +{ + struct fio_option *__o; + int opt_index = 0; + + __o = fio_options; + while (__o->name) { + opt_index++; + __o++; + } + + memcpy(&fio_options[opt_index], o, sizeof(*o)); + return 0; +} + +void invalidate_profile_options(const char *prof_name) +{ + struct fio_option *o; + + o = fio_options; + while (o->name) { + if (o->prof_name && !strcmp(o->prof_name, prof_name)) { + o->type = FIO_OPT_INVALID; + o->prof_name = NULL; + } + o++; + } +} + +void add_opt_posval(const char *optname, const char *ival, const char *help) +{ + struct fio_option *o; + unsigned int i; + + o = find_option(fio_options, optname); + if (!o) + return; + + for (i = 0; i < PARSE_MAX_VP; i++) { + if (o->posval[i].ival) + continue; + + o->posval[i].ival = ival; + o->posval[i].help = help; + break; + } +} + +void del_opt_posval(const char *optname, const char *ival) +{ + struct fio_option *o; + unsigned int i; + + o = find_option(fio_options, optname); + if (!o) + return; + + for (i = 0; i < PARSE_MAX_VP; i++) { + if (!o->posval[i].ival) + continue; + if (strcmp(o->posval[i].ival, ival)) + continue; + + o->posval[i].ival = NULL; + o->posval[i].help = NULL; + } +} + +void fio_options_free(struct thread_data *td) +{ + options_free(fio_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; + } +}