X-Git-Url: https://git.kernel.dk/?p=fio.git;a=blobdiff_plain;f=ioengines.c;h=7e5a50cc81ba328875b605a55f1fde8c16122cec;hp=e78b4f79acadc87a30808e54a7e78b55155318f6;hb=e39863e3cb61bb750f5e7d87fcf11c2bf4651996;hpb=97bb54c9606c6a84a6d779d89258b67a65f87047 diff --git a/ioengines.c b/ioengines.c index e78b4f79..7e5a50cc 100644 --- a/ioengines.c +++ b/ioengines.c @@ -9,7 +9,6 @@ * generic io engine that could be used for other projects. * */ -#include #include #include #include @@ -19,6 +18,7 @@ #include "fio.h" #include "diskutil.h" +#include "zbd.h" static FLIST_HEAD(engine_list); @@ -52,14 +52,12 @@ static bool check_engine_ops(struct ioengine_ops *ops) void unregister_ioengine(struct ioengine_ops *ops) { dprint(FD_IO, "ioengine %s unregistered\n", ops->name); - flist_del(&ops->list); - INIT_FLIST_HEAD(&ops->list); + flist_del_init(&ops->list); } void register_ioengine(struct ioengine_ops *ops) { dprint(FD_IO, "ioengine %s registered\n", ops->name); - INIT_FLIST_HEAD(&ops->list); flist_add_tail(&ops->list, &engine_list); } @@ -133,8 +131,10 @@ static struct ioengine_ops *__load_ioengine(const char *name) /* * linux libaio has alias names, so convert to what we want */ - if (!strncmp(engine, "linuxaio", 8) || !strncmp(engine, "aio", 3)) + if (!strncmp(engine, "linuxaio", 8)) { + dprint(FD_IO, "converting ioengine name: %s -> libaio\n", name); strcpy(engine, "libaio"); + } dprint(FD_IO, "load ioengine %s\n", engine); return find_ioengine(engine); @@ -143,17 +143,30 @@ static struct ioengine_ops *__load_ioengine(const char *name) struct ioengine_ops *load_ioengine(struct thread_data *td) { struct ioengine_ops *ops = NULL; - const char *name = NULL; + const char *name; - if (strcmp(td->o.ioengine, "external")) { - name = td->o.ioengine; - ops = __load_ioengine(name); - } else if (td->o.ioengine_so_path) { - name = td->o.ioengine_so_path; + /* + * Use ->ioengine_so_path if an external ioengine path is specified. + * In this case, ->ioengine is "external" which also means the prefix + * for external ioengines "external:" is properly used. + */ + name = td->o.ioengine_so_path ?: td->o.ioengine; + + /* + * Try to load ->ioengine first, and if failed try to dlopen(3) either + * ->ioengine or ->ioengine_so_path. This is redundant for an external + * ioengine with prefix, and also leaves the possibility of unexpected + * behavior (e.g. if the "external" ioengine exists), but we do this + * so as not to break job files not using the prefix. + */ + ops = __load_ioengine(td->o.ioengine); + if (!ops) ops = dlopen_ioengine(td, name); - } else - log_err("fio: missing external ioengine path\n"); + /* + * If ops is NULL, we failed to load ->ioengine, and also failed to + * dlopen(3) either ->ioengine or ->ioengine_so_path as a path. + */ if (!ops) { log_err("fio: engine %s not loadable\n", name); return NULL; @@ -181,8 +194,10 @@ void free_ioengine(struct thread_data *td) td->eo = NULL; } - if (td->io_ops_dlhandle) + if (td->io_ops_dlhandle) { dlclose(td->io_ops_dlhandle); + td->io_ops_dlhandle = NULL; + } td->io_ops = NULL; } @@ -209,7 +224,8 @@ int td_io_prep(struct thread_data *td, struct io_u *io_u) if (td->io_ops->prep) { int ret = td->io_ops->prep(td, io_u); - dprint(FD_IO, "->prep(%p)=%d\n", io_u, ret); + dprint(FD_IO, "prep: io_u %p: ret=%d\n", io_u, ret); + if (ret) unlock_file(td, io_u->file); return ret; @@ -261,11 +277,11 @@ out: return r; } -int td_io_queue(struct thread_data *td, struct io_u *io_u) +enum fio_q_status td_io_queue(struct thread_data *td, struct io_u *io_u) { const enum fio_ddir ddir = acct_ddir(io_u); - unsigned long buflen = io_u->xfer_buflen; - int ret; + unsigned long long buflen = io_u->xfer_buflen; + enum fio_q_status ret; dprint_io_u(io_u, "queue"); fio_ro_check(td, io_u); @@ -273,6 +289,15 @@ int td_io_queue(struct thread_data *td, struct io_u *io_u) assert((io_u->flags & IO_U_F_FLIGHT) == 0); io_u_set(td, io_u, IO_U_F_FLIGHT); + /* + * If overlap checking was enabled in offload mode we + * can release this lock that was acquired when we + * started the overlap check because the IO_U_F_FLIGHT + * flag is now set + */ + if (td_offload_overlap(td)) + pthread_mutex_unlock(&overlap_check); + assert(fio_file_open(io_u->file)); /* @@ -296,12 +321,15 @@ int td_io_queue(struct thread_data *td, struct io_u *io_u) } if (ddir_rw(ddir)) { - td->io_issues[ddir]++; - td->io_issue_bytes[ddir] += buflen; + if (!(io_u->flags & IO_U_F_VER_LIST)) { + td->io_issues[ddir]++; + td->io_issue_bytes[ddir] += buflen; + } td->rate_io_issue_bytes[ddir] += buflen; } ret = td->io_ops->queue(td, io_u); + zbd_queue_io_u(io_u, ret); unlock_file(td, io_u->file); @@ -329,33 +357,36 @@ int td_io_queue(struct thread_data *td, struct io_u *io_u) td->o.odirect) { log_info("fio: first direct IO errored. File system may not " - "support direct IO, or iomem_align= is bad. Try " - "setting direct=0.\n"); + "support direct IO, or iomem_align= is bad, or " + "invalid block size. Try setting direct=0.\n"); } - if (!td->io_ops->commit || io_u->ddir == DDIR_TRIM) { + if (zbd_unaligned_write(io_u->error) && + td->io_issues[io_u->ddir & 1] == 1 && + td->o.zone_mode != ZONE_MODE_ZBD) { + log_info("fio: first I/O failed. If %s is a zoned block device, consider --zonemode=zbd\n", + io_u->file->file_name); + } + + if (!td->io_ops->commit) { io_u_mark_submit(td, 1); io_u_mark_complete(td, 1); + zbd_put_io_u(io_u); } if (ret == FIO_Q_COMPLETED) { - if (ddir_rw(io_u->ddir)) { + if (ddir_rw(io_u->ddir) || ddir_sync(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; - td->io_u_queued++; - if (ddir_rw(io_u->ddir)) + if (ddir_rw(io_u->ddir) || ddir_sync(io_u->ddir)) td->ts.total_io_u[io_u->ddir]++; - if (td->io_u_queued >= td->o.iodepth_batch) { - r = td_io_commit(td); - if (r < 0) - return r; - } + if (td->io_u_queued >= td->o.iodepth_batch) + td_io_commit(td); } if (!td_ioengine_flagged(td, FIO_SYNCIO)) { @@ -393,14 +424,14 @@ int td_io_init(struct thread_data *td) return ret; } -int td_io_commit(struct thread_data *td) +void 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; + return; io_u_mark_depth(td, td->io_u_queued); @@ -415,14 +446,21 @@ int td_io_commit(struct thread_data *td) */ td->io_u_in_flight += td->io_u_queued; td->io_u_queued = 0; - - return 0; } int td_io_open_file(struct thread_data *td, struct fio_file *f) { + if (fio_file_closing(f)) { + /* + * Open translates to undo closing. + */ + fio_file_clear_closing(f); + get_file(f); + return 0; + } assert(!fio_file_open(f)); assert(f->fd == -1); + assert(td->io_ops->open_file); if (td->io_ops->open_file(td, f)) { if (td->error == EINVAL && td->o.odirect) @@ -479,8 +517,8 @@ int td_io_open_file(struct thread_data *td, struct fio_file *f) } if (posix_fadvise(f->fd, f->file_offset, f->io_size, flags) < 0) { - td_verror(td, errno, "fadvise"); - goto err; + if (!fio_did_warn(FIO_WARN_FADVISE)) + log_err("fio: fadvise hint failed\n"); } } #ifdef FIO_HAVE_WRITE_HINT @@ -529,11 +567,6 @@ int td_io_close_file(struct thread_data *td, struct fio_file *f) */ fio_file_set_closing(f); - disk_util_dec(f->du); - - if (td->o.file_lock_mode != FILE_LOCK_NONE) - unlock_file_all(td, f); - return put_file(td, f); } @@ -563,6 +596,7 @@ int td_io_get_file_size(struct thread_data *td, struct fio_file *f) int fio_show_ioengine_help(const char *engine) { struct flist_head *entry; + struct thread_data td; struct ioengine_ops *io_ops; char *sep; int ret = 1; @@ -581,7 +615,10 @@ int fio_show_ioengine_help(const char *engine) sep++; } - io_ops = __load_ioengine(engine); + memset(&td, 0, sizeof(struct thread_data)); + td.o.ioengine = (char *)engine; + io_ops = load_ioengine(&td); + if (!io_ops) { log_info("IO engine %s not found\n", engine); return 1; @@ -592,5 +629,6 @@ int fio_show_ioengine_help(const char *engine) else log_info("IO engine %s has no options\n", io_ops->name); + free_ioengine(&td); return ret; }