Fix issue with openfiles= and file sizing

[fio.git] / filesetup.c

diff --git a/filesetup.c b/filesetup.c
index 9f186fb46436a4d46998709a787050be24905316..bae60929df32f7f80f1dfa4ba00ab3ffbb9514b0 100644 (file)
--- a/filesetup.c
+++ b/filesetup.c
@@ -121,13 +121,14 @@ static int extend_file(struct thread_data *td, struct fio_file *f)
                dprint(FD_FILE, "truncate file %s, size %llu\n", f->file_name,
                                        (unsigned long long) f->real_file_size);
                if (ftruncate(f->fd, f->real_file_size) == -1) {
-                       td_verror(td, errno, "ftruncate");
-                       goto err;
+                       if (errno != EFBIG) {
+                               td_verror(td, errno, "ftruncate");
+                               goto err;
+                       }
                }
        }
 
        b = malloc(td->o.max_bs[DDIR_WRITE]);
-       memset(b, 0, td->o.max_bs[DDIR_WRITE]);
 
        left = f->real_file_size;
        while (left && !td->terminate) {
@@ -135,6 +136,8 @@ static int extend_file(struct thread_data *td, struct fio_file *f)
                if (bs > left)
                        bs = left;
 
+               fill_io_buffer(td, b, bs, bs);
+
                r = write(f->fd, b, bs);
 
                if (r > 0) {
@@ -387,7 +390,8 @@ static int __file_invalidate_cache(struct thread_data *td, struct fio_file *f,
        if (f->mmap_ptr) {
                ret = posix_madvise(f->mmap_ptr, f->mmap_sz, POSIX_MADV_DONTNEED);
 #ifdef FIO_MADV_FREE
-               (void) posix_madvise(f->mmap_ptr, f->mmap_sz, FIO_MADV_FREE);
+               if (f->filetype == FIO_TYPE_BD)
+                       (void) posix_madvise(f->mmap_ptr, f->mmap_sz, FIO_MADV_FREE);
 #endif
        } else if (f->filetype == FIO_TYPE_FILE) {
                ret = posix_fadvise(f->fd, off, len, POSIX_FADV_DONTNEED);
@@ -442,6 +446,7 @@ int generic_close_file(struct thread_data fio_unused *td, struct fio_file *f)
                f->shadow_fd = -1;
        }
 
+       f->engine_data = 0;
        return ret;
 }
 
@@ -516,6 +521,13 @@ int generic_open_file(struct thread_data *td, struct fio_file *f)
                goto skip_flags;
        if (td->o.odirect)
                flags |= OS_O_DIRECT;
+       if (td->o.oatomic) {
+               if (!FIO_O_ATOMIC) {
+                       td_verror(td, EINVAL, "OS does not support atomic IO");
+                       return 1;
+               }
+               flags |= OS_O_DIRECT | FIO_O_ATOMIC;
+       }
        if (td->o.sync_io)
                flags |= O_SYNC;
        if (td->o.create_on_open)
@@ -581,7 +593,7 @@ open_again:
                         * work-around a "feature" on Linux, where a close of
                         * an fd that has been opened for write will trigger
                         * udev to call blkid to check partitions, fs id, etc.
-                        * That polutes the device cache, which can slow down
+                        * That pollutes the device cache, which can slow down
                         * unbuffered accesses.
                         */
                        if (f->shadow_fd == -1)
@@ -722,9 +734,11 @@ int setup_files(struct thread_data *td)
        unsigned long long total_size, extend_size;
        struct thread_options *o = &td->o;
        struct fio_file *f;
-       unsigned int i;
+       unsigned int i, nr_fs_extra = 0;
        int err = 0, need_extend;
        int old_state;
+       const unsigned int bs = td_min_bs(td);
+       uint64_t fs = 0;
 
        dprint(FD_FILE, "setup files\n");
 
@@ -773,6 +787,20 @@ int setup_files(struct thread_data *td)
                goto err_out;
        }
 
+       /*
+        * Calculate per-file size and potential extra size for the
+        * first files, if needed.
+        */
+       if (!o->file_size_low) {
+               uint64_t all_fs;
+
+               fs = o->size / o->nr_files;
+               all_fs = fs * o->nr_files;
+
+               if (all_fs < o->size)
+                       nr_fs_extra = (o->size - all_fs) / bs;
+       }
+
        /*
         * now file sizes are known, so we can set ->io_size. if size= is
         * not given, ->io_size is just equal to ->real_file_size. if size
@@ -786,10 +814,17 @@ int setup_files(struct thread_data *td)
                if (!o->file_size_low) {
                        /*
                         * no file size range given, file size is equal to
-                        * total size divided by number of files. if that is
-                        * zero, set it to the real file size.
+                        * total size divided by number of files. If that is
+                        * zero, set it to the real file size. If the size
+                        * doesn't divide nicely with the min blocksize,
+                        * make the first files bigger.
                         */
-                       f->io_size = o->size / o->nr_files;
+                       f->io_size = fs;
+                       if (nr_fs_extra) {
+                               nr_fs_extra--;
+                               f->io_size += bs;
+                       }
+
                        if (!f->io_size)
                                f->io_size = f->real_file_size - f->file_offset;
                } else if (f->real_file_size < o->file_size_low ||
@@ -1038,6 +1073,7 @@ void close_and_free_files(struct thread_data *td)
        td->files_index = 0;
        td->files = NULL;
        td->file_locks = NULL;
+       td->o.file_lock_mode = FILE_LOCK_NONE;
        td->o.nr_files = 0;
 }
 
@@ -1230,6 +1266,8 @@ void unlock_file(struct thread_data *td, struct fio_file *f)
 
 void unlock_file_all(struct thread_data *td, struct fio_file *f)
 {
+       if (td->o.file_lock_mode == FILE_LOCK_NONE)
+               return;
        if (td->file_locks[f->fileno] != FILE_LOCK_NONE)
                unlock_file(td, f);
 }
@@ -1328,6 +1366,11 @@ void dup_files(struct thread_data *td, struct thread_data *org)
                        __f->filetype = f->filetype;
                }
 
+               if (td->o.file_lock_mode == FILE_LOCK_EXCLUSIVE)
+                       __f->lock = f->lock;
+               else if (td->o.file_lock_mode == FILE_LOCK_READWRITE)
+                       __f->rwlock = f->rwlock;
+
                td->files[i] = __f;
        }
 }
@@ -1366,3 +1409,15 @@ void fio_file_reset(struct thread_data *td, struct fio_file *f)
        if (td->o.random_generator == FIO_RAND_GEN_LFSR)
                lfsr_reset(&f->lfsr, td->rand_seeds[FIO_RAND_BLOCK_OFF]);
 }
+
+int fio_files_done(struct thread_data *td)
+{
+       struct fio_file *f;
+       unsigned int i;
+
+       for_each_file(td, f, i)
+               if (!fio_file_done(f))
+                       return 0;
+
+       return 1;
+}