X-Git-Url: https://git.kernel.dk/?p=fio.git;a=blobdiff_plain;f=ioengines.c;h=ba02952b1f0f8d0c8ae9bebe31e091a0302046aa;hp=6e135af42c4e8ecccba555b18b7e1fbb13074ac2;hb=83742c72e3d69b2d5c8a890b3803042b5fd1aae0;hpb=2c0795e8803650b7e4b989917b721d03286fa92b diff --git a/ioengines.c b/ioengines.c index 6e135af4..ba02952b 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); } @@ -123,26 +121,52 @@ static struct ioengine_ops *dlopen_ioengine(struct thread_data *td, return ops; } -struct ioengine_ops *load_ioengine(struct thread_data *td, const char *name) +static struct ioengine_ops *__load_ioengine(const char *name) { - struct ioengine_ops *ops; char engine[64]; - dprint(FD_IO, "load ioengine %s\n", name); - engine[sizeof(engine) - 1] = '\0'; strncpy(engine, name, sizeof(engine) - 1); /* * 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) || !strncmp(engine, "aio", 3)) { + dprint(FD_IO, "converting ioengine name: %s -> libaio\n", name); strcpy(engine, "libaio"); + } - ops = find_ioengine(engine); + dprint(FD_IO, "load ioengine %s\n", engine); + return find_ioengine(engine); +} + +struct ioengine_ops *load_ioengine(struct thread_data *td) +{ + struct ioengine_ops *ops = NULL; + const char *name; + + /* + * 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); + /* + * 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; @@ -170,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; } @@ -198,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; @@ -250,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); @@ -285,12 +312,18 @@ 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); + if (ret != FIO_Q_BUSY && io_u->post_submit) { + io_u->post_submit(io_u, io_u->error == 0); + io_u->post_submit = NULL; + } unlock_file(td, io_u->file); @@ -318,33 +351,35 @@ 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); } 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)) { @@ -382,14 +417,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); @@ -404,14 +439,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) @@ -468,8 +510,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 @@ -495,29 +537,8 @@ int td_io_open_file(struct thread_data *td, struct fio_file *f) } #endif -#ifdef FIO_OS_DIRECTIO - /* - * Some OS's have a distinct call to mark the file non-buffered, - * instead of using O_DIRECT (Solaris) - */ - if (td->o.odirect) { - int ret = fio_set_odirect(f->fd); - - if (ret) { - td_verror(td, ret, "fio_set_odirect"); -#if defined(__sun__) - if (ret == ENOTTY) { /* ENOTTY suggests RAW device or ZFS */ - log_err("fio: doing directIO to RAW devices or ZFS not supported\n"); - } else { - log_err("fio: the file system does not seem to support direct IO\n"); - } -#else - log_err("fio: the file system does not seem to support direct IO\n"); -#endif - goto err; - } - } -#endif + if (td->o.odirect && !OS_O_DIRECT && fio_set_directio(td, f)) + goto err; done: log_file(td, f, FIO_LOG_OPEN_FILE); @@ -539,11 +560,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); } @@ -592,9 +608,10 @@ int fio_show_ioengine_help(const char *engine) sep++; } - memset(&td, 0, sizeof(td)); + memset(&td, 0, sizeof(struct thread_data)); + td.o.ioengine = (char *)engine; + io_ops = load_ioengine(&td); - io_ops = load_ioengine(&td, engine); if (!io_ops) { log_info("IO engine %s not found\n", engine); return 1; @@ -606,6 +623,5 @@ int fio_show_ioengine_help(const char *engine) log_info("IO engine %s has no options\n", io_ops->name); free_ioengine(&td); - return ret; }