X-Git-Url: https://git.kernel.dk/?p=fio.git;a=blobdiff_plain;f=filesetup.c;h=08c365d916fecfa70e4422f6381e39d27e6575c4;hp=f64c7a119d66cbf43173e894873b357e33dae768;hb=9efef3c4bd6a032a2a9f7a9aab1c29436525d781;hpb=7bb48f84ac78cac1f90e3e04d0220d90d6a64a6b diff --git a/filesetup.c b/filesetup.c index f64c7a11..08c365d9 100644 --- a/filesetup.c +++ b/filesetup.c @@ -8,33 +8,63 @@ #include #include "fio.h" -#include "os.h" +#include "smalloc.h" +#include "filehash.h" + +static int root_warn; static int extend_file(struct thread_data *td, struct fio_file *f) { + int r, new_layout = 0, unlink_file = 0, flags; unsigned long long left; unsigned int bs; char *b; - int r; - if (f->flags & FIO_FILE_EXISTS) { - if (unlink(f->file_name) < 0) { + if (read_only) { + log_err("fio: refusing extend of file due to read-only\n"); + return 0; + } + + /* + * check if we need to lay the file out complete again. fio + * does that for operations involving reads, or for writes + * where overwrite is set + */ + if (td_read(td) || (td_write(td) && td->o.overwrite)) + new_layout = 1; + if (td_write(td) && !td->o.overwrite) + unlink_file = 1; + + if (unlink_file || new_layout) { + if ((unlink(f->file_name) < 0) && (errno != ENOENT)) { td_verror(td, errno, "unlink"); return 1; } } - f->fd = open(f->file_name, O_WRONLY | O_CREAT | O_TRUNC, 0644); + flags = O_WRONLY | O_CREAT; + if (new_layout) + flags |= O_TRUNC; + + dprint(FD_FILE, "open file %s, flags %x\n", f->file_name, flags); + f->fd = open(f->file_name, flags, 0644); if (f->fd < 0) { td_verror(td, errno, "open"); return 1; } + if (!new_layout) + goto done; + + 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; } + dprint(FD_FILE, "fallocate file %s, size %llu\n", f->file_name, + f->real_file_size); if (posix_fallocate(f->fd, 0, f->real_file_size) < 0) { td_verror(td, errno, "posix_fallocate"); goto err; @@ -70,6 +100,7 @@ static int extend_file(struct thread_data *td, struct fio_file *f) fsync(f->fd); free(b); +done: close(f->fd); f->fd = -1; return 0; @@ -85,7 +116,7 @@ static unsigned long long get_rand_file_size(struct thread_data *td) long r; r = os_random_long(&td->file_size_state); - ret = td->o.file_size_low + (unsigned long long) ((double) td->o.file_size_high * (r / (RAND_MAX + 1.0))); + ret = td->o.file_size_low + (unsigned long long) ((double) (td->o.file_size_high - td->o.file_size_low) * (r / (RAND_MAX + 1.0))); ret -= (ret % td->o.rw_min_bs); return ret; } @@ -122,6 +153,9 @@ static int get_file_size(struct thread_data *td, struct fio_file *f) { int ret = 0; + if (f->flags & FIO_SIZE_KNOWN) + return 0; + if (f->filetype == FIO_TYPE_FILE) ret = file_size(td, f); else if (f->filetype == FIO_TYPE_BD) @@ -137,6 +171,7 @@ static int get_file_size(struct thread_data *td, struct fio_file *f) return 1; } + f->flags |= FIO_SIZE_KNOWN; return 0; } @@ -144,6 +179,8 @@ int file_invalidate_cache(struct thread_data *td, struct fio_file *f) { int ret = 0; + dprint(FD_IO, "invalidate cache (%d)\n", td->o.odirect); + if (td->o.odirect) return 0; @@ -157,10 +194,13 @@ int file_invalidate_cache(struct thread_data *td, struct fio_file *f) else if (f->filetype == FIO_TYPE_BD) { ret = blockdev_invalidate_cache(f->fd); if (ret < 0 && errno == EACCES && geteuid()) { - log_err("fio: only root may flush block devices. Cache flush bypassed!\n"); + if (!root_warn) { + log_err("fio: only root may flush block devices. Cache flush bypassed!\n"); + root_warn = 1; + } ret = 0; } - } else if (f->filetype == FIO_TYPE_CHAR) + } else if (f->filetype == FIO_TYPE_CHAR || f->filetype == FIO_TYPE_PIPE) ret = 0; if (ret < 0) { @@ -171,41 +211,111 @@ int file_invalidate_cache(struct thread_data *td, struct fio_file *f) return ret; } -void generic_close_file(struct thread_data fio_unused *td, struct fio_file *f) +int generic_close_file(struct thread_data fio_unused *td, struct fio_file *f) { - close(f->fd); + int ret = 0; + + dprint(FD_FILE, "fd close %s\n", f->file_name); + + remove_file_hash(f); + + if (close(f->fd) < 0) + ret = errno; + f->fd = -1; + return ret; +} + +static int file_lookup_open(struct fio_file *f, int flags) +{ + struct fio_file *__f; + int from_hash; + + __f = lookup_file_hash(f->file_name); + if (__f) { + dprint(FD_FILE, "found file in hash %s\n", f->file_name); + /* + * racy, need the __f->lock locked + */ + f->lock = __f->lock; + f->lock_owner = __f->lock_owner; + f->lock_batch = __f->lock_batch; + f->lock_ddir = __f->lock_ddir; + f->fd = dup(__f->fd); + f->references++; + from_hash = 1; + } else { + dprint(FD_FILE, "file not found in hash %s\n", f->file_name); + f->fd = open(f->file_name, flags, 0600); + from_hash = 0; + } + + return from_hash; } int generic_open_file(struct thread_data *td, struct fio_file *f) { + int is_std = 0; int flags = 0; + int from_hash = 0; + + dprint(FD_FILE, "fd open %s\n", f->file_name); + + if (!strcmp(f->file_name, "-")) { + if (td_rw(td)) { + log_err("fio: can't read/write to stdin/out\n"); + return 1; + } + is_std = 1; + + /* + * move output logging to stderr, if we are writing to stdout + */ + if (td_write(td)) + f_out = stderr; + } if (td->o.odirect) flags |= OS_O_DIRECT; if (td->o.sync_io) flags |= O_SYNC; + if (f->filetype != FIO_TYPE_FILE) + flags |= O_NOATIME; + +open_again: + if (td_write(td)) { + assert(!read_only); - if (td_write(td) || td_rw(td)) { flags |= O_RDWR; if (f->filetype == FIO_TYPE_FILE) flags |= O_CREAT; - f->fd = open(f->file_name, flags, 0600); + if (is_std) + f->fd = dup(STDOUT_FILENO); + else + from_hash = file_lookup_open(f, flags); } else { - if (f->filetype == FIO_TYPE_CHAR) + if (f->filetype == FIO_TYPE_CHAR && !read_only) flags |= O_RDWR; else flags |= O_RDONLY; - f->fd = open(f->file_name, flags); + if (is_std) + f->fd = dup(STDIN_FILENO); + else + from_hash = file_lookup_open(f, flags); } if (f->fd == -1) { char buf[FIO_VERROR_SIZE]; int __e = errno; + if (errno == EPERM && (flags & O_NOATIME)) { + flags &= ~O_NOATIME; + goto open_again; + } + snprintf(buf, sizeof(buf) - 1, "open(%s)", f->file_name); td_verror(td, __e, buf); @@ -214,18 +324,15 @@ int generic_open_file(struct thread_data *td, struct fio_file *f) if (get_file_size(td, f)) goto err; - if (td->o.invalidate_cache && file_invalidate_cache(td, f)) - goto err; - - if (td->o.fadvise_hint) { - if (td_random(td)) - flags = POSIX_FADV_RANDOM; - else - flags = POSIX_FADV_SEQUENTIAL; + if (!from_hash && f->fd != -1) { + if (add_file_hash(f)) { + int ret; - if (fadvise(f->fd, f->file_offset, f->io_size, flags) < 0) { - td_verror(td, errno, "fadvise"); - goto err; + /* + * OK to ignore, we haven't done anything with it + */ + ret = generic_close_file(td, f); + goto open_again; } } @@ -241,10 +348,19 @@ int open_files(struct thread_data *td) unsigned int i; int err = 0; + dprint(FD_FILE, "open files\n"); + for_each_file(td, f, i) { err = td_io_open_file(td, f); - if (err) + if (err) { + if (td->error == EMFILE) { + log_err("fio: limited open files to: %d\n", td->nr_open_files); + td->o.open_files = td->nr_open_files; + err = 0; + clear_error(td); + } break; + } if (td->o.open_files == td->nr_open_files) break; @@ -269,15 +385,21 @@ static int get_file_sizes(struct thread_data *td) int err = 0; for_each_file(td, f, i) { - err = td->io_ops->open_file(td, f); - if (err) { - td->error = 0; - memset(td->verror, 0, sizeof(td->verror)); - err = 0; - continue; + dprint(FD_FILE, "get file size for %p/%d/%p\n", f, i, f->file_name); + + if (td->io_ops->open_file(td, f)) { + if (td->error != ENOENT) { + log_err("%s\n", td->verror); + err = 1; + } + clear_error(td); + } else { + if (td->io_ops->close_file) + td->io_ops->close_file(td, f); } - td->io_ops->close_file(td, f); + if (f->real_file_size == -1ULL && td->o.size) + f->real_file_size = td->o.size / td->o.nr_files; } return err; @@ -291,7 +413,9 @@ int setup_files(struct thread_data *td) unsigned long long total_size, extend_size; struct fio_file *f; unsigned int i; - int err, need_extend; + int err = 0, need_extend; + + dprint(FD_FILE, "setup files\n"); /* * if ioengine defines a setup() method, it's responsible for @@ -321,7 +445,8 @@ int setup_files(struct thread_data *td) /* * device/file sizes are zero and no size given, punt */ - if (!total_size && !td->o.size) { + if ((!total_size || total_size == -1ULL) && !td->o.size && + !(td->io_ops->flags & FIO_NOIO) && !td->o.fill_device) { log_err("%s: you need to specify size=\n", td->o.name); td_verror(td, EINVAL, "total_file_size"); return 1; @@ -335,6 +460,8 @@ int setup_files(struct thread_data *td) extend_size = total_size = 0; need_extend = 0; for_each_file(td, f, i) { + f->file_offset = td->o.start_offset; + if (!td->o.file_size_low) { /* * no file size range given, file size is equal to @@ -343,19 +470,21 @@ int setup_files(struct thread_data *td) */ f->io_size = td->o.size / td->o.nr_files; if (!f->io_size) - f->io_size = f->real_file_size; + f->io_size = f->real_file_size - f->file_offset; } else if (f->real_file_size < td->o.file_size_low || f->real_file_size > td->o.file_size_high) { + if (f->file_offset > td->o.file_size_low) + goto err_offset; /* * file size given. if it's fixed, use that. if it's a * range, generate a random size in-between. */ if (td->o.file_size_low == td->o.file_size_high) - f->io_size = td->o.file_size_low; + f->io_size = td->o.file_size_low - f->file_offset; else - f->io_size = get_rand_file_size(td); + f->io_size = get_rand_file_size(td) - f->file_offset; } else - f->io_size = f->real_file_size; + f->io_size = f->real_file_size - f->file_offset; if (f->io_size == -1ULL) total_size = -1ULL; @@ -363,15 +492,15 @@ int setup_files(struct thread_data *td) total_size += f->io_size; if (f->filetype == FIO_TYPE_FILE && - f->io_size > f->real_file_size && + (f->io_size + f->file_offset) > f->real_file_size && !(td->io_ops->flags & FIO_DISKLESSIO)) { need_extend++; - extend_size += f->io_size; + extend_size += (f->io_size + f->file_offset); f->flags |= FIO_FILE_EXTEND; - } + } } - if (!td->o.size) + if (!td->o.size || td->o.size > total_size) td->o.size = total_size; /* @@ -379,15 +508,16 @@ int setup_files(struct thread_data *td) */ if (need_extend) { temp_stall_ts = 1; - log_info("%s: Laying out IO file(s) (%u files / %LuMiB)\n", + log_info("%s: Laying out IO file(s) (%u file(s) / %LuMiB)\n", td->o.name, need_extend, extend_size >> 20); for_each_file(td, f, i) { if (!(f->flags & FIO_FILE_EXTEND)) continue; + assert(f->filetype == FIO_TYPE_FILE); f->flags &= ~FIO_FILE_EXTEND; - f->real_file_size = f->io_size; + f->real_file_size = (f->io_size + f->file_offset); err = extend_file(td, f); if (err) break; @@ -401,29 +531,36 @@ int setup_files(struct thread_data *td) if (!td->o.zone_size) td->o.zone_size = td->o.size; - td->total_io_size = td->o.size * td->o.loops; + /* + * iolog already set the total io size, if we read back + * stored entries. + */ + if (!td->o.read_iolog_file) + td->total_io_size = td->o.size * td->o.loops; return 0; +err_offset: + log_err("%s: you need to specify valid offset=\n", td->o.name); + return 1; } int init_random_map(struct thread_data *td) { - int num_maps, blocks; + unsigned long long blocks, num_maps; struct fio_file *f; unsigned int i; - if (td->o.norandommap) + if (td->o.norandommap || !td_random(td)) return 0; for_each_file(td, f, i) { - blocks = (f->real_file_size + td->o.rw_min_bs - 1) / td->o.rw_min_bs; - num_maps = (blocks + BLOCKS_PER_MAP-1)/ BLOCKS_PER_MAP; - f->file_map = malloc(num_maps * sizeof(long)); + blocks = (f->real_file_size + td->o.rw_min_bs - 1) / (unsigned long long) td->o.rw_min_bs; + num_maps = (blocks + BLOCKS_PER_MAP-1)/ (unsigned long long) BLOCKS_PER_MAP; + f->file_map = smalloc(num_maps * sizeof(long)); if (!f->file_map) { log_err("fio: failed allocating random map. If running a large number of jobs, try the 'norandommap' option\n"); return 1; } f->num_maps = num_maps; - memset(f->file_map, 0, num_maps * sizeof(long)); } return 0; @@ -434,24 +571,36 @@ void close_files(struct thread_data *td) struct fio_file *f; unsigned int i; + for_each_file(td, f, i) + td_io_close_file(td, f); +} + +void close_and_free_files(struct thread_data *td) +{ + struct fio_file *f; + unsigned int i; + + dprint(FD_FILE, "close files\n"); + for_each_file(td, f, i) { - if ((f->flags & FIO_FILE_UNLINK) && - f->filetype == FIO_TYPE_FILE) + if (td->o.unlink && f->filetype == FIO_TYPE_FILE) unlink(f->file_name); td_io_close_file(td, f); - free(f->file_name); + sfree(f->file_name); f->file_name = NULL; if (f->file_map) { - free(f->file_map); + sfree(f->file_map); f->file_map = NULL; } + sfree(f); } td->o.filename = NULL; free(td->files); + td->files_index = 0; td->files = NULL; td->o.nr_files = 0; } @@ -460,63 +609,162 @@ static void get_file_type(struct fio_file *f) { struct stat sb; - f->filetype = FIO_TYPE_FILE; + if (!strcmp(f->file_name, "-")) + f->filetype = FIO_TYPE_PIPE; + else + f->filetype = FIO_TYPE_FILE; if (!lstat(f->file_name, &sb)) { if (S_ISBLK(sb.st_mode)) f->filetype = FIO_TYPE_BD; else if (S_ISCHR(sb.st_mode)) f->filetype = FIO_TYPE_CHAR; + else if (S_ISFIFO(sb.st_mode)) + f->filetype = FIO_TYPE_PIPE; } } -void add_file(struct thread_data *td, const char *fname) +int add_file(struct thread_data *td, const char *fname) { int cur_files = td->files_index; char file_name[PATH_MAX]; struct fio_file *f; int len = 0; - td->files = realloc(td->files, (cur_files + 1) * sizeof(*f)); + dprint(FD_FILE, "add file %s\n", fname); - f = &td->files[cur_files]; - memset(f, 0, sizeof(*f)); + f = smalloc(sizeof(*f)); f->fd = -1; + dprint(FD_FILE, "resize file array to %d files\n", cur_files + 1); + + td->files = realloc(td->files, (cur_files + 1) * sizeof(f)); + td->files[cur_files] = f; + + /* + * init function, io engine may not be loaded yet + */ + if (td->io_ops && (td->io_ops->flags & FIO_DISKLESSIO)) + f->real_file_size = -1ULL; + if (td->o.directory) len = sprintf(file_name, "%s/", td->o.directory); sprintf(file_name + len, "%s", fname); - f->file_name = strdup(file_name); + f->file_name = smalloc_strdup(file_name); get_file_type(f); + switch (td->o.file_lock_mode) { + case FILE_LOCK_NONE: + break; + case FILE_LOCK_READWRITE: + f->lock = fio_mutex_rw_init(); + break; + case FILE_LOCK_EXCLUSIVE: + f->lock = fio_mutex_init(1); + break; + default: + log_err("fio: unknown lock mode: %d\n", td->o.file_lock_mode); + assert(0); + } + td->files_index++; if (f->filetype == FIO_TYPE_FILE) td->nr_normal_files++; + + dprint(FD_FILE, "file %p \"%s\" added at %d\n", f, f->file_name, cur_files); + + return cur_files; } 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); f->references++; } -void put_file(struct thread_data *td, struct fio_file *f) +int put_file(struct thread_data *td, struct fio_file *f) { + int ret = 0; + + dprint(FD_FILE, "put file %s, ref=%d\n", f->file_name, f->references); + if (!(f->flags & FIO_FILE_OPEN)) - return; + return 0; assert(f->references); if (--f->references) - return; + return 0; if (should_fsync(td) && td->o.fsync_on_close) fsync(f->fd); if (td->io_ops->close_file) - td->io_ops->close_file(td, f); + ret = td->io_ops->close_file(td, f); + td->nr_open_files--; f->flags &= ~FIO_FILE_OPEN; + return ret; +} + +void lock_file(struct thread_data *td, struct fio_file *f, enum fio_ddir ddir) +{ + if (!f->lock || td->o.file_lock_mode == FILE_LOCK_NONE) + return; + + if (f->lock_owner == td && f->lock_batch--) + return; + + if (td->o.file_lock_mode == FILE_LOCK_READWRITE) { + if (ddir == DDIR_READ) + fio_mutex_down_read(f->lock); + else + fio_mutex_down_write(f->lock); + } else if (td->o.file_lock_mode == FILE_LOCK_EXCLUSIVE) + fio_mutex_down(f->lock); + + f->lock_owner = td; + f->lock_batch = td->o.lockfile_batch; + f->lock_ddir = ddir; +} + +void unlock_file(struct thread_data *td, struct fio_file *f) +{ + if (!f->lock || td->o.file_lock_mode == FILE_LOCK_NONE) + return; + if (f->lock_batch) + return; + + if (td->o.file_lock_mode == FILE_LOCK_READWRITE) { + const int is_read = f->lock_ddir == DDIR_READ; + int val = fio_mutex_getval(f->lock); + + if ((is_read && val == 1) || (!is_read && val == -1)) + f->lock_owner = NULL; + + if (is_read) + fio_mutex_up_read(f->lock); + else + fio_mutex_up_write(f->lock); + } else if (td->o.file_lock_mode == FILE_LOCK_EXCLUSIVE) { + int val = fio_mutex_getval(f->lock); + + if (val == 0) + f->lock_owner = NULL; + + fio_mutex_up(f->lock); + } +} + +void unlock_file_all(struct thread_data *td, struct fio_file *f) +{ + if (f->lock_owner != td) + return; + + f->lock_batch = 0; + unlock_file(td, f); } static int recurse_dir(struct thread_data *td, const char *dirname) @@ -527,7 +775,10 @@ static int recurse_dir(struct thread_data *td, const char *dirname) D = opendir(dirname); if (!D) { - td_verror(td, errno, "opendir"); + char buf[FIO_VERROR_SIZE]; + + snprintf(buf, FIO_VERROR_SIZE - 1, "opendir(%s)", dirname); + td_verror(td, errno, buf); return 1; } @@ -552,6 +803,8 @@ static int recurse_dir(struct thread_data *td, const char *dirname) td->o.nr_files++; continue; } + if (!S_ISDIR(sb.st_mode)) + continue; if ((ret = recurse_dir(td, full_path)) != 0) break; @@ -563,24 +816,59 @@ static int recurse_dir(struct thread_data *td, const char *dirname) int add_dir_files(struct thread_data *td, const char *path) { - return recurse_dir(td, path); + int ret = recurse_dir(td, path); + + if (!ret) + log_info("fio: opendir added %d files\n", td->o.nr_files); + + return ret; } void dup_files(struct thread_data *td, struct thread_data *org) { struct fio_file *f; unsigned int i; - size_t bytes; + + dprint(FD_FILE, "dup files: %d\n", org->files_index); if (!org->files) return; - bytes = org->files_index * sizeof(*f); - td->files = malloc(bytes); - memcpy(td->files, org->files, bytes); + td->files = malloc(org->files_index * sizeof(f)); + + for_each_file(org, f, i) { + struct fio_file *__f; + + __f = smalloc(sizeof(*__f)); - for_each_file(td, f, i) { if (f->file_name) - f->file_name = strdup(f->file_name); + __f->file_name = smalloc_strdup(f->file_name); + + td->files[i] = __f; } } + +/* + * Returns the index that matches the filename, or -1 if not there + */ +int get_fileno(struct thread_data *td, const char *fname) +{ + struct fio_file *f; + unsigned int i; + + for_each_file(td, f, i) + if (!strcmp(f->file_name, fname)) + return i; + + return -1; +} + +/* + * For log usage, where we add/open/close files automatically + */ +void free_release_files(struct thread_data *td) +{ + close_files(td); + td->files_index = 0; + td->nr_normal_files = 0; +}