X-Git-Url: https://git.kernel.dk/?p=fio.git;a=blobdiff_plain;f=options.c;h=055fbab7a14180a91062635a4176a9603b0fd8d2;hp=04ed548d97b5a992cf6e50e220f64c9d5b43075c;hb=564ca97254984165e06d5fd4b1270bac95ca55fb;hpb=c3edbdba748e25eb14f3efc648ac0678995f3432 diff --git a/options.c b/options.c index 04ed548d..055fbab7 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 @@ -203,6 +320,52 @@ 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) +{ + struct thread_data *td = data; + + if (*off && *off < sizeof(struct verify_header)) { + log_err("fio: verify_offset too small\n"); + return 1; + } + + td->o.verify_offset = *off; + return 0; +} + +static int str_verify_cb(void *data, const char *mem) +{ + struct thread_data *td = data; + unsigned int nr, msb; + char *pat; + + if (td->o.verify != VERIFY_PATTERN) + return 0; + + pat = get_opt_postfix(mem); + if (!pat) { + log_err("fio: missing pattern\n"); + return 1; + } + + if (strstr(pat, "0x") || strstr(pat, "0X")) + nr = strtol(pat, NULL, 16); + else + nr = strtol(pat, NULL, 16); + + msb = fls(nr); + 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 = nr; + return 0; +} #define __stringify_1(x) #x #define __stringify(x) __stringify_1(x) @@ -279,13 +442,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, @@ -296,6 +452,9 @@ static struct fio_option options[] = { { .ival = "sync", .help = "Use read/write", }, + { .ival = "psync", + .help = "Use pread/pwrite", + }, #ifdef FIO_HAVE_LIBAIO { .ival = "libaio", .help = "Linux native asynchronous IO", @@ -351,6 +510,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", }, { @@ -358,12 +518,14 @@ 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", }, { .name = "iodepth_low", .type = FIO_OPT_INT, .off1 = td_var_offset(iodepth_low), .help = "Low water mark for queuing depth", + .parent = "iodepth", }, { .name = "size", @@ -380,6 +542,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", @@ -389,6 +559,7 @@ static struct fio_option options[] = { .minval = 1, .help = "Block size unit", .def = "4k", + .parent = "rw", }, { .name = "bsrange", @@ -400,6 +571,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", @@ -407,13 +586,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", @@ -421,12 +594,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", @@ -458,6 +633,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", @@ -562,6 +745,7 @@ static struct fio_option options[] = { .name = "verify", .type = FIO_OPT_STR, .off1 = td_var_offset(verify), + .cb = str_verify_cb, .help = "Verify data written", .def = "0", .posval = { @@ -569,13 +753,41 @@ static struct fio_option options[] = { .oval = VERIFY_NONE, .help = "Don't do IO verification", }, + { .ival = "md5", + .oval = VERIFY_MD5, + .help = "Use md5 checksums for verification", + }, + { .ival = "crc64", + .oval = VERIFY_CRC64, + .help = "Use crc64 checksums for verification", + }, { .ival = "crc32", .oval = VERIFY_CRC32, .help = "Use crc32 checksums for verification", }, - { .ival = "md5", - .oval = VERIFY_MD5, - .help = "Use md5 checksums for verification", + { .ival = "crc16", + .oval = VERIFY_CRC16, + .help = "Use crc16 checksums for verification", + }, + { .ival = "crc7", + .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 = "pattern", + .oval = VERIFY_PATTERN, + .help = "Verify a specific buffer pattern", }, { .ival = "null", @@ -584,12 +796,45 @@ 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 = "verify_interval", + .type = FIO_OPT_STR_VAL_INT, + .off1 = td_var_offset(verify_interval), + .minval = 2 * sizeof(struct verify_header), + .help = "Store verify buffer header every N bytes", + .parent = "verify", + }, + { + .name = "verify_offset", + .type = FIO_OPT_STR_VAL_INT, + .help = "Offset verify header location by N bytes", + .def = "0", + .cb = str_verify_offset_cb, + .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", @@ -644,13 +889,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, @@ -667,6 +905,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, @@ -707,6 +953,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", @@ -714,6 +961,7 @@ static struct fio_option options[] = { .off1 = td_var_offset(thinktime_blocks), .help = "IO buffer period between 'thinktime'", .def = "1", + .parent = "thinktime", }, { .name = "rate", @@ -726,6 +974,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", @@ -738,6 +987,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", @@ -745,6 +995,7 @@ static struct fio_option options[] = { .off1 = td_var_offset(ratecycle), .help = "Window average for rate limits (msec)", .def = "1000", + .parent = "rate", }, { .name = "invalidate", @@ -759,6 +1010,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", @@ -793,6 +1045,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 {