X-Git-Url: https://git.kernel.dk/?p=fio.git;a=blobdiff_plain;f=options.c;h=bb77683d06c0cbba39cdfa7069f7d1b22d1b400a;hp=01d23865a968952606006e3a57dd3e3a21d323d5;hb=4d4e80f2b4260f2c8b37a8612ce655502a799f7a;hpb=819a968068aae65bca68ddc7805c01669707b880 diff --git a/options.c b/options.c index 01d23865..bb77683d 100644 --- a/options.c +++ b/options.c @@ -8,6 +8,7 @@ #include "fio.h" #include "parse.h" +#include "fls.h" #define td_var_offset(var) ((size_t) &((struct thread_options *)0)->var) @@ -27,6 +28,120 @@ static char *get_opt_postfix(const char *str) return strdup(p); } +static int bs_cmp(const void *p1, const void *p2) +{ + const struct bssplit *bsp1 = p1; + const struct bssplit *bsp2 = p2; + + return bsp1->perc < bsp2->perc; +} + +static int str_bssplit_cb(void *data, const char *input) +{ + struct thread_data *td = data; + char *fname, *str, *p; + unsigned int i, perc, perc_missing; + unsigned int max_bs, min_bs; + long long val; + + p = str = strdup(input); + + strip_blank_front(&str); + strip_blank_end(str); + + td->o.bssplit_nr = 4; + td->o.bssplit = malloc(4 * sizeof(struct bssplit)); + + i = 0; + max_bs = 0; + min_bs = -1; + while ((fname = strsep(&str, ":")) != NULL) { + char *perc_str; + + if (!strlen(fname)) + break; + + /* + * grow struct buffer, if needed + */ + if (i == td->o.bssplit_nr) { + td->o.bssplit_nr <<= 1; + td->o.bssplit = realloc(td->o.bssplit, td->o.bssplit_nr * sizeof(struct bssplit)); + } + + perc_str = strstr(fname, "/"); + if (perc_str) { + *perc_str = '\0'; + perc_str++; + perc = atoi(perc_str); + if (perc > 100) + perc = 100; + else if (!perc) + perc = -1; + } else + perc = -1; + + if (str_to_decimal(fname, &val, 1)) { + log_err("fio: bssplit conversion failed\n"); + free(td->o.bssplit); + return 1; + } + + if (val > max_bs) + max_bs = val; + if (val < min_bs) + min_bs = val; + + td->o.bssplit[i].bs = val; + td->o.bssplit[i].perc = perc; + i++; + } + + td->o.bssplit_nr = i; + + /* + * Now check if the percentages add up, and how much is missing + */ + perc = perc_missing = 0; + for (i = 0; i < td->o.bssplit_nr; i++) { + struct bssplit *bsp = &td->o.bssplit[i]; + + if (bsp->perc == (unsigned char) -1) + perc_missing++; + else + perc += bsp->perc; + } + + if (perc > 100) { + log_err("fio: bssplit percentages add to more than 100%%\n"); + free(td->o.bssplit); + return 1; + } + /* + * If values didn't have a percentage set, divide the remains between + * them. + */ + if (perc_missing) { + for (i = 0; i < td->o.bssplit_nr; i++) { + struct bssplit *bsp = &td->o.bssplit[i]; + + if (bsp->perc == (unsigned char) -1) + bsp->perc = (100 - perc) / perc_missing; + } + } + + td->o.min_bs[DDIR_READ] = td->o.min_bs[DDIR_WRITE] = min_bs; + td->o.max_bs[DDIR_READ] = td->o.max_bs[DDIR_WRITE] = max_bs; + + /* + * now sort based on percentages, for ease of lookup + */ + qsort(td->o.bssplit, td->o.bssplit_nr, sizeof(struct bssplit), bs_cmp); + + free(p); + return 0; +} + static int str_rw_cb(void *data, const char *str) { struct thread_data *td = data; @@ -73,6 +188,7 @@ static int str_prioclass_cb(void *data, unsigned int *val) td->ioprio &= mask; td->ioprio |= *val << IOPRIO_CLASS_SHIFT; + td->ioprio_set = 1; return 0; } @@ -88,6 +204,7 @@ static int str_prio_cb(void *data, unsigned int *val) if ((td->ioprio >> IOPRIO_CLASS_SHIFT) == 0) td->ioprio |= IOPRIO_CLASS_BE << IOPRIO_CLASS_SHIFT; + td->ioprio_set = 1; return 0; } #endif @@ -134,7 +251,6 @@ static int str_cpus_allowed_cb(void *data, const char *input) free(p); td->o.cpumask_set = 1; - exit(0); return 0; } #endif @@ -203,17 +319,49 @@ static int str_opendir_cb(void *data, const char fio_unused *str) return add_dir_files(td, td->o.opendir); } -static int str_header_offset_cb(void *data, unsigned int *off) +static int str_verify_offset_cb(void *data, unsigned int *off) { struct thread_data *td = data; + if (*off && *off < sizeof(struct verify_header)) { - log_err("fio: header_offset too small\n"); + log_err("fio: verify_offset too small\n"); return 1; } - td->o.header_offset = *off; + + td->o.verify_offset = *off; return 0; } +static int str_verify_pattern_cb(void *data, unsigned int *off) +{ + struct thread_data *td = data; + unsigned int msb; + + msb = fls(*off); + if (msb <= 8) + td->o.verify_pattern_bytes = 1; + else if (msb <= 16) + td->o.verify_pattern_bytes = 2; + else if (msb <= 24) + td->o.verify_pattern_bytes = 3; + else + td->o.verify_pattern_bytes = 4; + + td->o.verify_pattern = *off; + return 0; +} + +static int str_lockfile_cb(void *data, const char *str) +{ + struct thread_data *td = data; + char *nr = get_opt_postfix(str); + + td->o.lockfile_batch = 1; + if (nr) + td->o.lockfile_batch = atoi(nr); + + return 0; +} #define __stringify_1(x) #x #define __stringify(x) __stringify_1(x) @@ -248,6 +396,30 @@ static struct fio_option options[] = { .cb = str_filename_cb, .help = "File(s) to use for the workload", }, + { + .name = "lockfile", + .type = FIO_OPT_STR, + .cb = str_lockfile_cb, + .off1 = td_var_offset(file_lock_mode), + .help = "Lock file when doing IO to it", + .parent = "filename", + .def = "none", + .posval = { + { .ival = "none", + .oval = FILE_LOCK_NONE, + .help = "No file locking", + }, + { .ival = "exclusive", + .oval = FILE_LOCK_EXCLUSIVE, + .help = "Exclusive file lock", + }, + { + .ival = "readwrite", + .oval = FILE_LOCK_READWRITE, + .help = "Read vs write lock", + }, + }, + }, { .name = "opendir", .type = FIO_OPT_STR_STORE, @@ -290,13 +462,6 @@ static struct fio_option options[] = { }, }, }, - { - .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", - }, { .name = "ioengine", .type = FIO_OPT_STR_STORE, @@ -307,6 +472,12 @@ static struct fio_option options[] = { { .ival = "sync", .help = "Use read/write", }, + { .ival = "psync", + .help = "Use pread/pwrite", + }, + { .ival = "vsync", + .help = "Use readv/writev", + }, #ifdef FIO_HAVE_LIBAIO { .ival = "libaio", .help = "Linux native asynchronous IO", @@ -362,6 +533,7 @@ static struct fio_option options[] = { .type = FIO_OPT_INT, .off1 = td_var_offset(iodepth), .help = "Amount of IO buffers to keep in flight", + .minval = 1, .def = "1", }, { @@ -369,12 +541,16 @@ static struct fio_option options[] = { .type = FIO_OPT_INT, .off1 = td_var_offset(iodepth_batch), .help = "Number of IO to submit in one go", + .parent = "iodepth", + .minval = 1, + .def = "1", }, { .name = "iodepth_low", .type = FIO_OPT_INT, .off1 = td_var_offset(iodepth_low), .help = "Low water mark for queuing depth", + .parent = "iodepth", }, { .name = "size", @@ -383,6 +559,13 @@ static struct fio_option options[] = { .minval = 1, .help = "Total size of device or files", }, + { + .name = "fill_device", + .type = FIO_OPT_BOOL, + .off1 = td_var_offset(fill_device), + .help = "Write until an ENOSPC error occurs", + .def = "0", + }, { .name = "filesize", .type = FIO_OPT_STR_VAL, @@ -391,6 +574,14 @@ static struct fio_option options[] = { .minval = 1, .help = "Size of individual files", }, + { + .name = "offset", + .alias = "fileoffset", + .type = FIO_OPT_STR_VAL, + .off1 = td_var_offset(start_offset), + .help = "Start IO from this offset", + .def = "0", + }, { .name = "bs", .alias = "blocksize", @@ -400,6 +591,7 @@ static struct fio_option options[] = { .minval = 1, .help = "Block size unit", .def = "4k", + .parent = "rw", }, { .name = "bsrange", @@ -411,6 +603,14 @@ static struct fio_option options[] = { .off4 = td_var_offset(max_bs[DDIR_WRITE]), .minval = 1, .help = "Set block size range (in more detail than bs)", + .parent = "rw", + }, + { + .name = "bssplit", + .type = FIO_OPT_STR, + .cb = str_bssplit_cb, + .help = "Set a specific mix of block sizes", + .parent = "rw", }, { .name = "bs_unaligned", @@ -418,13 +618,7 @@ static struct fio_option options[] = { .type = FIO_OPT_STR_SET, .off1 = td_var_offset(bs_unaligned), .help = "Don't sector align IO buffer sizes", - }, - { - .name = "offset", - .type = FIO_OPT_STR_VAL, - .off1 = td_var_offset(start_offset), - .help = "Start IO from this offset", - .def = "0", + .parent = "rw", }, { .name = "randrepeat", @@ -432,12 +626,14 @@ static struct fio_option options[] = { .off1 = td_var_offset(rand_repeatable), .help = "Use repeatable random IO pattern", .def = "1", + .parent = "rw", }, { .name = "norandommap", .type = FIO_OPT_STR_SET, .off1 = td_var_offset(norandommap), .help = "Accept potential duplicate random blocks", + .parent = "rw", }, { .name = "nrfiles", @@ -469,6 +665,14 @@ static struct fio_option options[] = { .help = "Round robin select files", }, }, + .parent = "nrfiles", + }, + { + .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", }, { .name = "fsync", @@ -600,6 +804,18 @@ static struct fio_option options[] = { .oval = VERIFY_CRC7, .help = "Use crc7 checksums for verification", }, + { .ival = "sha256", + .oval = VERIFY_SHA256, + .help = "Use sha256 checksums for verification", + }, + { .ival = "sha512", + .oval = VERIFY_SHA512, + .help = "Use sha512 checksums for verification", + }, + { .ival = "meta", + .oval = VERIFY_META, + .help = "Use io information", + }, { .ival = "null", .oval = VERIFY_NULL, @@ -607,26 +823,52 @@ static struct fio_option options[] = { }, }, }, + { + .name = "do_verify", + .type = FIO_OPT_BOOL, + .off1 = td_var_offset(do_verify), + .help = "Run verification stage after write", + .def = "1", + .parent = "verify", + }, { .name = "verifysort", .type = FIO_OPT_BOOL, .off1 = td_var_offset(verifysort), .help = "Sort written verify blocks for read back", .def = "1", + .parent = "verify", }, { - .name = "header_interval", + .name = "verify_interval", .type = FIO_OPT_STR_VAL_INT, - .off1 = td_var_offset(header_interval), + .off1 = td_var_offset(verify_interval), .minval = 2 * sizeof(struct verify_header), - .help = "Store buffer header every N bytes", + .help = "Store verify buffer header every N bytes", + .parent = "verify", }, { - .name = "header_offset", + .name = "verify_offset", .type = FIO_OPT_STR_VAL_INT, - .help = "Offset header location by N bytes", + .help = "Offset verify header location by N bytes", .def = "0", - .cb = str_header_offset_cb, + .cb = str_verify_offset_cb, + .parent = "verify", + }, + { + .name = "verify_pattern", + .type = FIO_OPT_INT, + .cb = str_verify_pattern_cb, + .help = "Fill pattern for IO buffers", + .parent = "verify", + }, + { + .name = "verify_fatal", + .type = FIO_OPT_BOOL, + .off1 = td_var_offset(verify_fatal), + .def = "0", + .help = "Exit on a single verify failure, don't continue", + .parent = "verify", }, { .name = "write_iolog", @@ -681,13 +923,6 @@ static struct fio_option options[] = { .help = "Lock down this amount of memory", .def = "0", }, - { - .name = "rwmixcycle", - .type = FIO_OPT_INT, - .off1 = td_var_offset(rwmixcycle), - .help = "Cycle period for mixed read/write workloads (msec)", - .def = "500", - }, { .name = "rwmixread", .type = FIO_OPT_INT, @@ -704,6 +939,14 @@ static struct fio_option options[] = { .help = "Percentage of mixed workload that is writes", .def = "50", }, + { + .name = "rwmixcycle", + .type = FIO_OPT_INT, + .off1 = td_var_offset(rwmixcycle), + .help = "Cycle period for mixed read/write workloads (msec)", + .def = "500", + .parent = "rwmixread", + }, { .name = "nice", .type = FIO_OPT_INT, @@ -744,6 +987,7 @@ static struct fio_option options[] = { .off1 = td_var_offset(thinktime_spin), .help = "Start think time by spinning this amount (usec)", .def = "0", + .parent = "thinktime", }, { .name = "thinktime_blocks", @@ -751,6 +995,7 @@ static struct fio_option options[] = { .off1 = td_var_offset(thinktime_blocks), .help = "IO buffer period between 'thinktime'", .def = "1", + .parent = "thinktime", }, { .name = "rate", @@ -763,6 +1008,7 @@ static struct fio_option options[] = { .type = FIO_OPT_INT, .off1 = td_var_offset(ratemin), .help = "Job must meet this rate or it will be shutdown", + .parent = "rate", }, { .name = "rate_iops", @@ -775,6 +1021,7 @@ static struct fio_option options[] = { .type = FIO_OPT_INT, .off1 = td_var_offset(rate_iops_min), .help = "Job must meet this rate or it will be shutdown", + .parent = "rate_iops", }, { .name = "ratecycle", @@ -782,6 +1029,7 @@ static struct fio_option options[] = { .off1 = td_var_offset(ratecycle), .help = "Window average for rate limits (msec)", .def = "1000", + .parent = "rate", }, { .name = "invalidate", @@ -796,6 +1044,7 @@ static struct fio_option options[] = { .off1 = td_var_offset(sync_io), .help = "Use O_SYNC for buffered writes", .def = "0", + .parent = "buffered", }, { .name = "bwavgtime", @@ -830,6 +1079,7 @@ static struct fio_option options[] = { .off1 = td_var_offset(cpucycle), .help = "Length of the CPU burn cycles (usecs)", .def = "50000", + .parent = "cpuload", }, #ifdef FIO_HAVE_CPU_AFFINITY { @@ -904,7 +1154,7 @@ static struct fio_option options[] = { }, { .name = "hugepage-size", - .type = FIO_OPT_STR_VAL, + .type = FIO_OPT_STR_VAL_INT, .off1 = td_var_offset(hugepage_size), .help = "When using hugepages, specify size of each page", .def = __stringify(FIO_HUGE_PAGE),