X-Git-Url: https://git.kernel.dk/?p=fio.git;a=blobdiff_plain;f=filesetup.c;h=f721c36abbb045ca7b4e4a618c64b0199d5148e3;hp=cf8ae94c86b83c516411396b336f720e5ab03931;hb=e391c70489d9f63612bce419d7fa0df5d15abf16;hpb=2378826d96532b390bd4cb08d3946b497a9b0e51 diff --git a/filesetup.c b/filesetup.c index cf8ae94c..f721c36a 100644 --- a/filesetup.c +++ b/filesetup.c @@ -264,14 +264,16 @@ error: return ret; } -static unsigned long long get_rand_file_size(struct thread_data *td) +unsigned long long get_rand_file_size(struct thread_data *td) { unsigned long long ret, sized; + uint64_t frand_max; unsigned long r; + frand_max = rand_max(&td->file_size_state); r = __rand(&td->file_size_state); sized = td->o.file_size_high - td->o.file_size_low; - ret = (unsigned long long) ((double) sized * (r / (FRAND_MAX + 1.0))); + ret = (unsigned long long) ((double) sized * (r / (frand_max + 1.0))); ret += td->o.file_size_low; ret -= (ret % td->o.rw_min_bs); return ret; @@ -389,7 +391,7 @@ static int __file_invalidate_cache(struct thread_data *td, struct fio_file *f, unsigned long long off, unsigned long long len) { - int ret = 0; + int errval = 0, ret = 0; #ifdef CONFIG_ESX return 0; @@ -406,12 +408,28 @@ static int __file_invalidate_cache(struct thread_data *td, struct fio_file *f, dprint(FD_IO, "invalidate cache %s: %llu/%llu\n", f->file_name, off, len); - if (td->io_ops->invalidate) + if (td->io_ops->invalidate) { ret = td->io_ops->invalidate(td, f); - else if (f->filetype == FIO_TYPE_FILE) + if (ret < 0) + errval = ret; + } else if (f->filetype == FIO_TYPE_FILE) { ret = posix_fadvise(f->fd, off, len, POSIX_FADV_DONTNEED); - else if (f->filetype == FIO_TYPE_BD) { + if (ret) + errval = ret; + } else if (f->filetype == FIO_TYPE_BD) { + int retry_count = 0; + ret = blockdev_invalidate_cache(f); + while (ret < 0 && errno == EAGAIN && retry_count++ < 25) { + /* + * Linux multipath devices reject ioctl while + * the maps are being updated. That window can + * last tens of milliseconds; we'll try up to + * a quarter of a second. + */ + usleep(10000); + ret = blockdev_invalidate_cache(f); + } if (ret < 0 && errno == EACCES && geteuid()) { if (!root_warn) { log_err("fio: only root may flush block " @@ -420,6 +438,8 @@ static int __file_invalidate_cache(struct thread_data *td, struct fio_file *f, } ret = 0; } + if (ret < 0) + errval = errno; } else if (f->filetype == FIO_TYPE_CHAR || f->filetype == FIO_TYPE_PIPE) ret = 0; @@ -429,10 +449,8 @@ static int __file_invalidate_cache(struct thread_data *td, struct fio_file *f, * function to flush eg block device caches. So just warn and * continue on our way. */ - if (ret) { - log_info("fio: cache invalidation of %s failed: %s\n", f->file_name, strerror(errno)); - ret = 0; - } + if (errval) + log_info("fio: cache invalidation of %s failed: %s\n", f->file_name, strerror(errval)); return 0; @@ -730,7 +748,7 @@ static unsigned long long get_fs_free_counts(struct thread_data *td) fm = flist_entry(n, struct fio_mount, list); flist_del(&fm->list); - sz = get_fs_size(fm->base); + sz = get_fs_free_size(fm->base); if (sz && sz != -1ULL) ret += sz; @@ -743,12 +761,16 @@ static unsigned long long get_fs_free_counts(struct thread_data *td) uint64_t get_start_offset(struct thread_data *td, struct fio_file *f) { struct thread_options *o = &td->o; + uint64_t offset; if (o->file_append && f->filetype == FIO_TYPE_FILE) return f->real_file_size; - return td->o.start_offset + - td->subjob_number * td->o.offset_increment; + offset = td->o.start_offset + td->subjob_number * td->o.offset_increment; + if (offset % td_max_bs(td)) + offset -= (offset % td_max_bs(td)); + + return offset; } /* @@ -791,6 +813,7 @@ int setup_files(struct thread_data *td) */ total_size = 0; for_each_file(td, f, i) { + f->fileno = i; if (f->real_file_size == -1ULL) total_size = -1ULL; else @@ -871,8 +894,10 @@ int setup_files(struct thread_data *td) if (f->io_size == -1ULL) total_size = -1ULL; else { - if (o->size_percent) - f->io_size = (f->io_size * o->size_percent) / 100; + if (o->size_percent) { + f->io_size = (f->io_size * o->size_percent) / 100; + f->io_size -= (f->io_size % td_min_bs(td)); + } total_size += f->io_size; } @@ -903,7 +928,7 @@ int setup_files(struct thread_data *td) } td->ts.nr_block_infos = len; - for (int i = 0; i < len; i++) + for (i = 0; i < len; i++) td->ts.block_infos[i] = BLOCK_INFO(0, BLOCK_STATE_UNINIT); } else @@ -922,7 +947,7 @@ int setup_files(struct thread_data *td) */ if (need_extend) { temp_stall_ts = 1; - if (output_format == FIO_OUTPUT_NORMAL) + if (output_format & FIO_OUTPUT_NORMAL) log_info("%s: Laying out IO file(s) (%u file(s) /" " %lluMB)\n", o->name, need_extend, extend_size >> 20); @@ -1049,6 +1074,43 @@ static int init_rand_distribution(struct thread_data *td) return 1; } +/* + * Check if the number of blocks exceeds the randomness capability of + * the selected generator. Tausworthe is 32-bit, the others are fullly + * 64-bit capable. + */ +static int check_rand_gen_limits(struct thread_data *td, struct fio_file *f, + uint64_t blocks) +{ + if (blocks <= FRAND32_MAX) + return 0; + if (td->o.random_generator != FIO_RAND_GEN_TAUSWORTHE) + return 0; + + /* + * If the user hasn't specified a random generator, switch + * to tausworthe64 with informational warning. If the user did + * specify one, just warn. + */ + log_info("fio: file %s exceeds 32-bit tausworthe random generator.\n", + f->file_name); + + if (!fio_option_is_set(&td->o, random_generator)) { + log_info("fio: Switching to tausworthe64. Use the " + "random_generator= option to get rid of this " + " warning.\n"); + td->o.random_generator = FIO_RAND_GEN_TAUSWORTHE64; + return 0; + } + + /* + * Just make this information to avoid breaking scripts. + */ + log_info("fio: Use the random_generator= option to switch to lfsr or " + "tausworthe64.\n"); + return 0; +} + int init_random_map(struct thread_data *td) { unsigned long long blocks; @@ -1065,6 +1127,9 @@ int init_random_map(struct thread_data *td) blocks = fsize / (unsigned long long) td->o.rw_min_bs; + if (check_rand_gen_limits(td, f, blocks)) + return 1; + if (td->o.random_generator == FIO_RAND_GEN_LFSR) { unsigned long seed;