X-Git-Url: https://git.kernel.dk/?p=fio.git;a=blobdiff_plain;f=engines%2Flibaio.c;h=871c5a4785d727a72471499ffca93344ff660b1c;hp=acc125f48e46df799c7d7fdcf0c42daea9694145;hb=317b95d07d4921d2594a1be6e014c9c2d062fe75;hpb=8d714a60ae956c5758fe4b5a75aa6cc31ce7e9eb diff --git a/engines/libaio.c b/engines/libaio.c index acc125f4..871c5a47 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,7 +19,9 @@ struct libaio_data { io_context_t aio_ctx; struct io_event *aio_events; - struct io_u *sync_io_u; + 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) @@ -40,15 +43,21 @@ 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; - if (ld->sync_io_u) { - struct io_u *ret = ld->sync_io_u; + ev = ld->aio_events + event; + io_u = ev_to_iou(ev); - ld->sync_io_u = NULL; - return ret; - } + 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, @@ -57,9 +66,6 @@ static int fio_libaio_getevents(struct thread_data *td, int min, int max, struct libaio_data *ld = td->io_ops->data; long r; - if (ld->sync_io_u) - return 1; - do { r = io_getevents(ld->aio_ctx, min, max, ld->aio_events, t); if (r >= min) @@ -73,48 +79,90 @@ static int fio_libaio_getevents(struct thread_data *td, int min, int max, break; } while (1); - if (r < 0) - r = -r; - - return (int) r; + return r; } 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; + 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; + + 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, iocbs_nr; + + if (!ld->iocbs_nr) + return 0; + + iocbs_nr = ld->iocbs_nr; + io_us = ld->io_us; + iocbs = ld->iocbs; do { - ret = io_submit(ld->aio_ctx, 1, &iocb); - if (ret == 1) - return 0; - else if (ret == -EAGAIN || !ret) + ret = io_submit(ld->aio_ctx, iocbs_nr, iocbs); + if (ret == iocbs_nr) { + fio_libaio_queued(td, io_us, ret); + ret = 0; + break; + } else if (ret > 0) { + fio_libaio_queued(td, io_us, ret); + io_us += ret; + iocbs += ret; + iocbs_nr -= ret; + continue; + } 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. - */ - ret = fsync(io_u->file->fd); - ld->sync_io_u = io_u; - break; - } else + else break; } while (1); - if (ret <= 0) { - io_u->resid = io_u->xfer_buflen; - io_u->error = -ret; - return 1; - } + if (!ret) + ld->iocbs_nr = 0; - return 0; + return ret; } static int fio_libaio_cancel(struct thread_data *td, struct io_u *io_u) @@ -130,9 +178,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; } @@ -141,16 +189,25 @@ 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)); + int err; 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"); 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; } @@ -161,10 +218,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 */