X-Git-Url: https://git.kernel.dk/?p=fio.git;a=blobdiff_plain;f=engines%2Flibaio.c;h=7ef3ff8074d005be36a3ef5d90926dc1cc683a0e;hp=cb488efb1b5acbbd524bbc25914f40b86ea772e7;hb=75de55acafe8663389449517621da67347354d62;hpb=22819ec237297fc39435ed566bee01a4225bfb39;ds=sidebyside diff --git a/engines/libaio.c b/engines/libaio.c index cb488efb..7ef3ff80 100644 --- a/engines/libaio.c +++ b/engines/libaio.c @@ -1,5 +1,7 @@ /* - * native linux aio io engine + * libaio engine + * + * IO engine using the Linux native aio interface. * */ #include @@ -9,7 +11,6 @@ #include #include "../fio.h" -#include "../os.h" #ifdef FIO_HAVE_LIBAIO @@ -18,6 +19,9 @@ struct libaio_data { io_context_t aio_ctx; struct io_event *aio_events; + struct iocb **iocbs; + struct io_u **io_us; + int iocbs_nr; }; static int fio_libaio_prep(struct thread_data fio_unused *td, struct io_u *io_u) @@ -39,12 +43,25 @@ static int fio_libaio_prep(struct thread_data fio_unused *td, struct io_u *io_u) static struct io_u *fio_libaio_event(struct thread_data *td, int event) { struct libaio_data *ld = td->io_ops->data; + struct io_event *ev; + struct io_u *io_u; + + ev = ld->aio_events + event; + io_u = ev_to_iou(ev); + + if (ev->res != io_u->xfer_buflen) { + if (ev->res > io_u->xfer_buflen) + io_u->error = -ev->res; + else + io_u->resid = io_u->xfer_buflen - ev->res; + } else + io_u->error = 0; - return ev_to_iou(ld->aio_events + event); + return io_u; } -static int fio_libaio_getevents(struct thread_data *td, int min, int max, - struct timespec *t) +static int fio_libaio_getevents(struct thread_data *td, unsigned int min, + unsigned int max, struct timespec *t) { struct libaio_data *ld = td->io_ops->data; long r; @@ -68,41 +85,75 @@ static int fio_libaio_getevents(struct thread_data *td, int min, int max, static int fio_libaio_queue(struct thread_data *td, struct io_u *io_u) { struct libaio_data *ld = td->io_ops->data; - struct iocb *iocb = &io_u->iocb; - long ret; - do { - ret = io_submit(ld->aio_ctx, 1, &iocb); - if (ret == 1) - return FIO_Q_QUEUED; - else if (ret == -EAGAIN || !ret) - usleep(100); - else if (ret == -EINTR) - continue; - else if (ret == -EINVAL && io_u->ddir == DDIR_SYNC) { - /* - * the async fsync doesn't currently seem to be - * supported, so just fsync if we fail with EINVAL - * for a sync. since buffered io is also sync - * with libaio (still), we don't have pending - * requests to flush first. - */ - if (fsync(io_u->file->fd) < 0) - ret = -errno; - else - ret = FIO_Q_COMPLETED; - break; - } else - break; - } while (1); + fio_ro_check(td, io_u); + + if (ld->iocbs_nr == (int) td->o.iodepth) + return FIO_Q_BUSY; + + /* + * fsync is tricky, since it can fail and we need to do it + * serialized with other io. the reason is that linux doesn't + * support aio fsync yet. So return busy for the case where we + * have pending io, to let fio complete those first. + */ + if (io_u->ddir == DDIR_SYNC) { + if (ld->iocbs_nr) + return FIO_Q_BUSY; + if (fsync(io_u->file->fd) < 0) + io_u->error = errno; - if (ret <= 0) { - io_u->resid = io_u->xfer_buflen; - io_u->error = -ret; - td_verror(td, io_u->error); return FIO_Q_COMPLETED; } + ld->iocbs[ld->iocbs_nr] = &io_u->iocb; + ld->io_us[ld->iocbs_nr] = io_u; + ld->iocbs_nr++; + return FIO_Q_QUEUED; +} + +static void fio_libaio_queued(struct thread_data *td, struct io_u **io_us, + unsigned int nr) +{ + struct timeval now; + unsigned int i; + + fio_gettime(&now, NULL); + + for (i = 0; i < nr; i++) { + struct io_u *io_u = io_us[i]; + + memcpy(&io_u->issue_time, &now, sizeof(now)); + io_u_queued(td, io_u); + } +} + +static int fio_libaio_commit(struct thread_data *td) +{ + struct libaio_data *ld = td->io_ops->data; + struct iocb **iocbs; + struct io_u **io_us; + int ret; + + if (!ld->iocbs_nr) + return 0; + + io_us = ld->io_us; + iocbs = ld->iocbs; + do { + ret = io_submit(ld->aio_ctx, ld->iocbs_nr, iocbs); + if (ret > 0) { + fio_libaio_queued(td, io_us, ret); + ld->iocbs_nr -= ret; + io_us += ret; + iocbs += ret; + ret = 0; + } else if (!ret || ret == -EAGAIN || ret == -EINTR) + continue; + else + break; + } while (ld->iocbs_nr); + return ret; } @@ -119,9 +170,9 @@ static void fio_libaio_cleanup(struct thread_data *td) if (ld) { io_destroy(ld->aio_ctx); - if (ld->aio_events) - free(ld->aio_events); - + free(ld->aio_events); + free(ld->iocbs); + free(ld->io_us); free(ld); td->io_ops->data = NULL; } @@ -130,16 +181,32 @@ static void fio_libaio_cleanup(struct thread_data *td) static int fio_libaio_init(struct thread_data *td) { struct libaio_data *ld = malloc(sizeof(*ld)); + static int warn_print; + int err; + + if (td->o.iodepth > 1 && !td->o.odirect && !warn_print) { + log_info("fio: libaio engine is only async for non-buffered IO\n"); + warn_print = 1; + } memset(ld, 0, sizeof(*ld)); - if (io_queue_init(td->iodepth, &ld->aio_ctx)) { - td_verror(td, errno); + + err = io_queue_init(td->o.iodepth, &ld->aio_ctx); + if (err) { + td_verror(td, -err, "io_queue_init"); + log_err("fio: check /proc/sys/fs/aio-max-nr\n"); free(ld); return 1; } - ld->aio_events = malloc(td->iodepth * sizeof(struct io_event)); - memset(ld->aio_events, 0, td->iodepth * sizeof(struct io_event)); + ld->aio_events = malloc(td->o.iodepth * sizeof(struct io_event)); + memset(ld->aio_events, 0, td->o.iodepth * sizeof(struct io_event)); + ld->iocbs = malloc(td->o.iodepth * sizeof(struct iocb *)); + memset(ld->iocbs, 0, sizeof(struct iocb *)); + ld->io_us = malloc(td->o.iodepth * sizeof(struct io_u *)); + memset(ld->io_us, 0, td->o.iodepth * sizeof(struct io_u *)); + ld->iocbs_nr = 0; + td->io_ops->data = ld; return 0; } @@ -150,10 +217,13 @@ static struct ioengine_ops ioengine = { .init = fio_libaio_init, .prep = fio_libaio_prep, .queue = fio_libaio_queue, + .commit = fio_libaio_commit, .cancel = fio_libaio_cancel, .getevents = fio_libaio_getevents, .event = fio_libaio_event, .cleanup = fio_libaio_cleanup, + .open_file = generic_open_file, + .close_file = generic_close_file, }; #else /* FIO_HAVE_LIBAIO */