static int root_warn;
+static inline void clear_error(struct thread_data *td)
+{
+ td->error = 0;
+ td->verror[0] = '\0';
+}
+
/*
* Leaves f->fd open on success, caller must close
*/
if (!new_layout)
goto done;
- dprint(FD_FILE, "truncate file %s, size %llu\n", f->file_name,
+ /*
+ * The size will be -1ULL when fill_device is used, so don't truncate
+ * or fallocate this file, just write it
+ */
+ if (!td->o.fill_device) {
+ dprint(FD_FILE, "truncate file %s, size %llu\n", f->file_name,
f->real_file_size);
- if (ftruncate(f->fd, f->real_file_size) == -1) {
- td_verror(td, errno, "ftruncate");
- goto err;
- }
+ if (ftruncate(f->fd, f->real_file_size) == -1) {
+ td_verror(td, errno, "ftruncate");
+ goto err;
+ }
#ifdef FIO_HAVE_FALLOCATE
- dprint(FD_FILE, "fallocate file %s, size %llu\n", f->file_name,
+ dprint(FD_FILE, "fallocate file %s, size %llu\n", f->file_name,
f->real_file_size);
- r = posix_fallocate(f->fd, 0, f->real_file_size);
- if (r < 0)
- log_err("fio: posix_fallocate fails: %s\n", strerror(-r));
+ r = posix_fallocate(f->fd, 0, f->real_file_size);
+ if (r < 0) {
+ log_err("fio: posix_fallocate fails: %s\n",
+ strerror(-r));
+ }
#endif
+ }
b = malloc(td->o.max_bs[DDIR_WRITE]);
memset(b, 0, td->o.max_bs[DDIR_WRITE]);
r = write(f->fd, b, bs);
- if (r == (int) bs) {
- left -= bs;
+ if (r > 0) {
+ left -= r;
continue;
} else {
- if (r < 0)
+ if (r < 0) {
+ int __e = errno;
+
+ if (__e == ENOSPC) {
+ if (td->o.fill_device)
+ break;
+ log_info("fio: ENOSPC on laying out "
+ "file, stopping\n");
+ break;
+ }
td_verror(td, errno, "write");
- else
+ } else
td_verror(td, EIO, "write");
break;
goto err;
}
}
+ if (td->o.fill_device && !td_write(td)) {
+ fio_file_clear_size_known(f);
+ if (td_io_get_file_size(td, f))
+ goto err;
+ if (f->io_size > f->real_file_size)
+ f->io_size = f->real_file_size;
+ }
free(b);
done:
return 1;
}
+static int pre_read_file(struct thread_data *td, struct fio_file *f)
+{
+ int r, did_open = 0, old_runstate;
+ unsigned long long left;
+ unsigned int bs;
+ char *b;
+
+ if (!fio_file_open(f)) {
+ if (td->io_ops->open_file(td, f)) {
+ log_err("fio: cannot pre-read, failed to open file\n");
+ return 1;
+ }
+ did_open = 1;
+ }
+
+ old_runstate = td->runstate;
+ td_set_runstate(td, TD_PRE_READING);
+
+ bs = td->o.max_bs[DDIR_READ];
+ b = malloc(bs);
+ memset(b, 0, bs);
+
+ lseek(f->fd, f->file_offset, SEEK_SET);
+ left = f->io_size;
+
+ while (left && !td->terminate) {
+ if (bs > left)
+ bs = left;
+
+ r = read(f->fd, b, bs);
+
+ if (r == (int) bs) {
+ left -= bs;
+ continue;
+ } else {
+ td_verror(td, EIO, "pre_read");
+ break;
+ }
+ }
+
+ td_set_runstate(td, old_runstate);
+
+ if (did_open)
+ td->io_ops->close_file(td, f);
+ free(b);
+ return 0;
+}
+
static unsigned long long get_rand_file_size(struct thread_data *td)
{
unsigned long long ret, sized;
{
int ret = 0;
- if (f->flags & FIO_SIZE_KNOWN)
+ if (fio_file_size_known(f))
return 0;
if (f->filetype == FIO_TYPE_FILE)
return 1;
}
- f->flags |= FIO_SIZE_KNOWN;
+ fio_file_set_size_known(f);
return 0;
}
if (off == -1ULL)
off = f->file_offset;
+ if (len == -1ULL || off == -1ULL)
+ return 0;
+
dprint(FD_IO, "invalidate cache %s: %llu/%llu\n", f->file_name, off,
len);
/*
* FIXME: add blockdev flushing too
*/
- if (f->mmap)
- ret = madvise(f->mmap, len, MADV_DONTNEED);
+ if (f->mmap_ptr)
+ ret = madvise(f->mmap_ptr, f->mmap_sz, MADV_DONTNEED);
else if (f->filetype == FIO_TYPE_FILE) {
ret = fadvise(f->fd, off, len, POSIX_FADV_DONTNEED);
} else if (f->filetype == FIO_TYPE_BD) {
int file_invalidate_cache(struct thread_data *td, struct fio_file *f)
{
- if (!(f->flags & FIO_FILE_OPEN))
+ if (!fio_file_open(f))
return 0;
- return __file_invalidate_cache(td, f, -1, -1);
+ return __file_invalidate_cache(td, f, -1ULL, -1ULL);
}
int generic_close_file(struct thread_data fio_unused *td, struct fio_file *f)
extend_size += (f->io_size + f->file_offset);
} else
f->real_file_size = f->io_size + f->file_offset;
- f->flags |= FIO_FILE_EXTEND;
+ fio_file_set_extend(f);
}
}
extend_size >> 20);
for_each_file(td, f, i) {
- unsigned long long old_len, extend_len;
+ unsigned long long old_len = -1ULL, extend_len = -1ULL;
- if (!(f->flags & FIO_FILE_EXTEND))
+ if (!fio_file_extend(f))
continue;
assert(f->filetype == FIO_TYPE_FILE);
- f->flags &= ~FIO_FILE_EXTEND;
- old_len = f->real_file_size;
- extend_len = f->io_size + f->file_offset - old_len;
+ fio_file_clear_extend(f);
+ if (!td->o.fill_device) {
+ old_len = f->real_file_size;
+ extend_len = f->io_size + f->file_offset - old_len;
+ }
f->real_file_size = (f->io_size + f->file_offset);
err = extend_file(td, f);
if (err)
break;
-
+
err = __file_invalidate_cache(td, f, old_len,
extend_len);
close(f->fd);
return 1;
}
+int pre_read_files(struct thread_data *td)
+{
+ struct fio_file *f;
+ unsigned int i;
+
+ dprint(FD_FILE, "pre_read files\n");
+
+ for_each_file(td, f, i) {
+ pre_read_file(td, f);
+ }
+
+ return 1;
+}
+
int init_random_map(struct thread_data *td)
{
unsigned long long blocks, num_maps;
void get_file(struct fio_file *f)
{
dprint(FD_FILE, "get file %s, ref=%d\n", f->file_name, f->references);
- assert(f->flags & FIO_FILE_OPEN);
+ assert(fio_file_open(f));
f->references++;
}
dprint(FD_FILE, "put file %s, ref=%d\n", f->file_name, f->references);
- if (!(f->flags & FIO_FILE_OPEN))
+ if (!fio_file_open(f))
return 0;
assert(f->references);
ret = f_ret;
td->nr_open_files--;
- f->flags &= ~FIO_FILE_OPEN;
+ fio_file_clear_open(f);
return ret;
}
projects / fio.git / blobdiff