X-Git-Url: https://git.kernel.dk/?p=fio.git;a=blobdiff_plain;f=ioengines.c;h=93e763124c1b18f56bdfc6eb54e912f0b0f11788;hp=0e8953404f7e4339572f44aad104f58b2c1a052e;hb=3fd9efbc3e986697c68975f5ee629040b35e8cd0;hpb=44f29692cfba246981bb3c1b894333a6d2209f51 diff --git a/ioengines.c b/ioengines.c index 0e895340..93e76312 100644 --- a/ioengines.c +++ b/ioengines.c @@ -14,6 +14,7 @@ #include #include #include +#include #include #include "fio.h" @@ -103,7 +104,9 @@ static struct ioengine_ops *dlopen_ioengine(struct thread_data *td, * Unlike the included modules, external engines should have a * non-static ioengine structure that we can reference. */ - ops = dlsym(dlhandle, "ioengine"); + ops = dlsym(dlhandle, engine_lib); + if (!ops) + ops = dlsym(dlhandle, "ioengine"); if (!ops) { td_vmsg(td, -1, dlerror(), "dlsym"); dlclose(dlhandle); @@ -151,13 +154,17 @@ struct ioengine_ops *load_ioengine(struct thread_data *td, const char *name) return ret; } -void close_ioengine(struct thread_data *td) +/* + * For cleaning up an ioengine which never made it to init(). + */ +void free_ioengine(struct thread_data *td) { - dprint(FD_IO, "close ioengine %s\n", td->io_ops->name); + dprint(FD_IO, "free ioengine %s\n", td->io_ops->name); - if (td->io_ops->cleanup) { - td->io_ops->cleanup(td); - td->io_ops->data = NULL; + if (td->eo && td->io_ops->options) { + options_free(td->io_ops->options, td->eo); + free(td->eo); + td->eo = NULL; } if (td->io_ops->dlhandle) @@ -167,6 +174,18 @@ void close_ioengine(struct thread_data *td) td->io_ops = NULL; } +void close_ioengine(struct thread_data *td) +{ + dprint(FD_IO, "close ioengine %s\n", td->io_ops->name); + + if (td->io_ops->cleanup) { + td->io_ops->cleanup(td); + td->io_ops->data = NULL; + } + + free_ioengine(td); +} + int td_io_prep(struct thread_data *td, struct io_u *io_u) { dprint_io_u(io_u, "prep"); @@ -191,6 +210,16 @@ int td_io_getevents(struct thread_data *td, unsigned int min, unsigned int max, { int r = 0; + /* + * For ioengine=rdma one side operation RDMA_WRITE or RDMA_READ, + * server side gets a message from the client + * side that the task is finished, and + * td->done is set to 1 after td_io_commit(). In this case, + * there is no need to reap complete event in server side. + */ + if (td->done) + return 0; + if (min > 0 && td->io_ops->commit) { r = td->io_ops->commit(td); if (r < 0) @@ -205,8 +234,16 @@ int td_io_getevents(struct thread_data *td, unsigned int min, unsigned int max, if (max && td->io_ops->getevents) r = td->io_ops->getevents(td, min, max, t); out: - if (r >= 0) + if (r >= 0) { + /* + * Reflect that our submitted requests were retrieved with + * whatever OS async calls are in the underlying engine. + */ + td->io_u_in_flight -= r; io_u_mark_complete(td, r); + } else + td_verror(td, r, "get_events"); + dprint(FD_IO, "getevents: %d\n", r); return r; } @@ -223,6 +260,11 @@ int td_io_queue(struct thread_data *td, struct io_u *io_u) assert(fio_file_open(io_u->file)); + /* + * If using a write iolog, store this entry. + */ + log_io_u(td, io_u); + io_u->error = 0; io_u->resid = 0; @@ -238,8 +280,8 @@ int td_io_queue(struct thread_data *td, struct io_u *io_u) sizeof(struct timeval)); } - if (!ddir_sync(io_u->ddir)) - td->io_issues[io_u->ddir]++; + if (ddir_rw(acct_ddir(io_u))) + td->io_issues[acct_ddir(io_u)]++; ret = td->io_ops->queue(td, io_u); @@ -251,26 +293,27 @@ int td_io_queue(struct thread_data *td, struct io_u *io_u) * IO, then it's likely an alignment problem or because the host fs * does not support O_DIRECT */ - if (io_u->error == EINVAL && td->io_issues[io_u->ddir] == 1 && + if (io_u->error == EINVAL && td->io_issues[io_u->ddir & 1] == 1 && td->o.odirect) { + log_info("fio: first direct IO errored. File system may not " "support direct IO, or iomem_align= is bad.\n"); } - if (!td->io_ops->commit) { + if (!td->io_ops->commit || ddir_trim(io_u->ddir)) { io_u_mark_submit(td, 1); io_u_mark_complete(td, 1); } if (ret == FIO_Q_COMPLETED) { - if (!ddir_sync(io_u->ddir)) { + if (ddir_rw(io_u->ddir)) { io_u_mark_depth(td, 1); td->ts.total_io_u[io_u->ddir]++; } } else if (ret == FIO_Q_QUEUED) { int r; - if (!ddir_sync(io_u->ddir)) { + if (ddir_rw(io_u->ddir)) { td->io_u_queued++; td->ts.total_io_u[io_u->ddir]++; } @@ -307,6 +350,8 @@ int td_io_init(struct thread_data *td) log_err("fio: io engine init failed. Perhaps try" " reducing io depth?\n"); } + if (!td->error) + td->error = ret; } return ret; @@ -314,16 +359,26 @@ int td_io_init(struct thread_data *td) int td_io_commit(struct thread_data *td) { + int ret; + dprint(FD_IO, "calling ->commit(), depth %d\n", td->cur_depth); if (!td->cur_depth || !td->io_u_queued) return 0; io_u_mark_depth(td, td->io_u_queued); - td->io_u_queued = 0; - if (td->io_ops->commit) - return td->io_ops->commit(td); + if (td->io_ops->commit) { + ret = td->io_ops->commit(td); + if (ret) + td_verror(td, -ret, "io commit"); + } + + /* + * Reflect that events were submitted as async IO requests. + */ + td->io_u_in_flight += td->io_u_queued; + td->io_u_queued = 0; return 0; } @@ -347,7 +402,7 @@ int td_io_open_file(struct thread_data *td, struct fio_file *f) return 1; } - fio_file_reset(f); + fio_file_reset(td, f); fio_file_set_open(f); fio_file_clear_closing(f); disk_util_inc(f->du); @@ -377,7 +432,7 @@ int td_io_open_file(struct thread_data *td, struct fio_file *f) else flags = POSIX_FADV_SEQUENTIAL; - if (fadvise(f->fd, f->file_offset, f->io_size, flags) < 0) { + if (posix_fadvise(f->fd, f->file_offset, f->io_size, flags) < 0) { td_verror(td, errno, "fadvise"); goto err; } @@ -393,6 +448,7 @@ int td_io_open_file(struct thread_data *td, struct fio_file *f) if (ret) { td_verror(td, ret, "fio_set_odirect"); + log_err("fio: the file system does not seem to support direct IO\n"); goto err; } } @@ -419,7 +475,9 @@ int td_io_close_file(struct thread_data *td, struct fio_file *f) fio_file_set_closing(f); disk_util_dec(f->du); - unlock_file_all(td, f); + + if (td->o.file_lock_mode != FILE_LOCK_NONE) + unlock_file_all(td, f); return put_file(td, f); } @@ -432,15 +490,99 @@ int td_io_get_file_size(struct thread_data *td, struct fio_file *f) return td->io_ops->get_file_size(td, f); } -int do_sync_file_range(struct thread_data *td, struct fio_file *f) +static int do_sync_file_range(struct thread_data *td, struct fio_file *f) { off64_t offset, nbytes; offset = f->first_write; nbytes = f->last_write - f->first_write; - if (nbytes) - return sync_file_range(f->fd, offset, nbytes, 0); + if (!nbytes) + return 0; + + return sync_file_range(f->fd, offset, nbytes, td->o.sync_file_range); +} + +int do_io_u_sync(struct thread_data *td, struct io_u *io_u) +{ + int ret; + if (io_u->ddir == DDIR_SYNC) { + ret = fsync(io_u->file->fd); + } else if (io_u->ddir == DDIR_DATASYNC) { +#ifdef CONFIG_FDATASYNC + ret = fdatasync(io_u->file->fd); +#else + ret = io_u->xfer_buflen; + io_u->error = EINVAL; +#endif + } else if (io_u->ddir == DDIR_SYNC_FILE_RANGE) + ret = do_sync_file_range(td, io_u->file); + else { + ret = io_u->xfer_buflen; + io_u->error = EINVAL; + } + + if (ret < 0) + io_u->error = errno; + + return ret; +} + +int do_io_u_trim(struct thread_data *td, struct io_u *io_u) +{ +#ifndef FIO_HAVE_TRIM + io_u->error = EINVAL; return 0; +#else + struct fio_file *f = io_u->file; + int ret; + + ret = os_trim(f->fd, io_u->offset, io_u->xfer_buflen); + if (!ret) + return io_u->xfer_buflen; + + io_u->error = ret; + return 0; +#endif +} + +int fio_show_ioengine_help(const char *engine) +{ + struct flist_head *entry; + struct thread_data td; + char *sep; + int ret = 1; + + if (!engine || !*engine) { + log_info("Available IO engines:\n"); + flist_for_each(entry, &engine_list) { + td.io_ops = flist_entry(entry, struct ioengine_ops, + list); + log_info("\t%s\n", td.io_ops->name); + } + return 0; + } + sep = strchr(engine, ','); + if (sep) { + *sep = 0; + sep++; + } + + memset(&td, 0, sizeof(td)); + + td.io_ops = load_ioengine(&td, engine); + if (!td.io_ops) { + log_info("IO engine %s not found\n", engine); + return 1; + } + + if (td.io_ops->options) + ret = show_cmd_help(td.io_ops->options, sep); + else + log_info("IO engine %s has no options\n", td.io_ops->name); + + free_ioengine(&td); + + return ret; }