X-Git-Url: https://git.kernel.dk/?p=fio.git;a=blobdiff_plain;f=engines%2Fposixaio.c;h=a2b53873124b49cdcc6e14b9d7e508b948265091;hp=ef4d78ebe8a58c03465eb33cdc58aa7f90b52d7c;hb=954cd73a9a93102c24afa869fbe67ac38af6e416;hpb=f8fe35e8c9e88dd681ea151251d75f6116a958b4 diff --git a/engines/posixaio.c b/engines/posixaio.c index ef4d78eb..a2b53873 100644 --- a/engines/posixaio.c +++ b/engines/posixaio.c @@ -1,31 +1,43 @@ /* - * posix aio io engine + * posixaio engine + * + * IO engine that uses the posix defined aio interface. * */ #include #include #include #include -#include +#include #include "../fio.h" -#include "../os.h" - -#ifdef FIO_HAVE_POSIXAIO struct posixaio_data { struct io_u **aio_events; + unsigned int queued; }; static int fill_timespec(struct timespec *ts) { -#ifdef _POSIX_TIMERS - if (!clock_gettime(CLOCK_MONOTONIC, ts)) +#ifdef CONFIG_CLOCK_GETTIME +#ifdef CONFIG_CLOCK_MONOTONIC + clockid_t clk = CLOCK_MONOTONIC; +#else + clockid_t clk = CLOCK_REALTIME; +#endif + if (!clock_gettime(clk, ts)) return 0; perror("clock_gettime"); -#endif return 1; +#else + struct timeval tv; + + gettimeofday(&tv, NULL); + ts->tv_sec = tv.tv_sec; + ts->tv_nsec = tv.tv_usec * 1000; + return 0; +#endif } static unsigned long long ts_utime_since_now(struct timespec *t) @@ -54,7 +66,7 @@ static int fio_posixaio_cancel(struct thread_data fio_unused *td, struct fio_file *f = io_u->file; int r = aio_cancel(f->fd, &io_u->aiocb); - if (r == 1 || r == AIO_CANCELED) + if (r == AIO_ALLDONE || r == AIO_CANCELED) return 0; return 1; @@ -63,53 +75,69 @@ static int fio_posixaio_cancel(struct thread_data fio_unused *td, static int fio_posixaio_prep(struct thread_data fio_unused *td, struct io_u *io_u) { - struct aiocb *aiocb = &io_u->aiocb; + os_aiocb_t *aiocb = &io_u->aiocb; struct fio_file *f = io_u->file; aiocb->aio_fildes = f->fd; - aiocb->aio_buf = io_u->buf; - aiocb->aio_nbytes = io_u->buflen; + aiocb->aio_buf = io_u->xfer_buf; + aiocb->aio_nbytes = io_u->xfer_buflen; aiocb->aio_offset = io_u->offset; + aiocb->aio_sigevent.sigev_notify = SIGEV_NONE; io_u->seen = 0; return 0; } -static int fio_posixaio_getevents(struct thread_data *td, int min, int max, - struct timespec *t) +#define SUSPEND_ENTRIES 8 + +static int fio_posixaio_getevents(struct thread_data *td, unsigned int min, + unsigned int max, struct timespec *t) { struct posixaio_data *pd = td->io_ops->data; - struct list_head *entry; + os_aiocb_t *suspend_list[SUSPEND_ENTRIES]; struct timespec start; - int r, have_timeout = 0; + int have_timeout = 0; + int suspend_entries; + struct io_u *io_u; + unsigned int r; + int i; if (t && !fill_timespec(&start)) have_timeout = 1; + else + memset(&start, 0, sizeof(start)); r = 0; restart: - list_for_each(entry, &td->io_u_busylist) { - struct io_u *io_u = list_entry(entry, struct io_u, list); + memset(suspend_list, 0, sizeof(*suspend_list)); + suspend_entries = 0; + io_u_qiter(&td->io_u_all, io_u, i) { int err; - if (io_u->seen) + if (io_u->seen || !(io_u->flags & IO_U_F_FLIGHT)) continue; err = aio_error(&io_u->aiocb); - switch (err) { - default: - io_u->error = err; - case ECANCELED: - case 0: - pd->aio_events[r++] = io_u; - io_u->seen = 1; - break; - case EINPROGRESS: - break; + if (err == EINPROGRESS) { + if (suspend_entries < SUSPEND_ENTRIES) { + suspend_list[suspend_entries] = &io_u->aiocb; + suspend_entries++; + } + continue; } - if (r >= max) - break; + io_u->seen = 1; + pd->queued--; + pd->aio_events[r++] = io_u; + + if (err == ECANCELED) + io_u->resid = io_u->xfer_buflen; + else if (!err) { + ssize_t retval = aio_return(&io_u->aiocb); + + io_u->resid = io_u->xfer_buflen - retval; + } else + io_u->error = err; } if (r >= min) @@ -124,10 +152,10 @@ restart: } /* - * hrmpf, we need to wait for more. we should use aio_suspend, for - * now just sleep a little and recheck status of busy-and-not-seen + * must have some in-flight, wait for at least one */ - usleep(1000); + aio_suspend((const os_aiocb_t * const *)suspend_list, + suspend_entries, t); goto restart; } @@ -138,23 +166,54 @@ static struct io_u *fio_posixaio_event(struct thread_data *td, int event) return pd->aio_events[event]; } -static int fio_posixaio_queue(struct thread_data fio_unused *td, +static int fio_posixaio_queue(struct thread_data *td, struct io_u *io_u) { - struct aiocb *aiocb = &io_u->aiocb; + struct posixaio_data *pd = td->io_ops->data; + os_aiocb_t *aiocb = &io_u->aiocb; int ret; + fio_ro_check(td, io_u); + if (io_u->ddir == DDIR_READ) ret = aio_read(aiocb); else if (io_u->ddir == DDIR_WRITE) ret = aio_write(aiocb); - else + else if (io_u->ddir == DDIR_TRIM) { + if (pd->queued) + return FIO_Q_BUSY; + + do_io_u_trim(td, io_u); + return FIO_Q_COMPLETED; + } else { +#ifdef CONFIG_POSIXAIO_FSYNC ret = aio_fsync(O_SYNC, aiocb); +#else + if (pd->queued) + return FIO_Q_BUSY; - if (ret) - io_u->error = errno; + do_io_u_sync(td, io_u); + return FIO_Q_COMPLETED; +#endif + } - return io_u->error; + if (ret) { + /* + * At least OSX has a very low limit on the number of pending + * IOs, so if it returns EAGAIN, we are out of resources + * to queue more. Just return FIO_Q_BUSY to naturally + * drop off at this depth. + */ + if (errno == EAGAIN) + return FIO_Q_BUSY; + + io_u->error = errno; + td_verror(td, io_u->error, "xfer"); + return FIO_Q_COMPLETED; + } + + pd->queued++; + return FIO_Q_QUEUED; } static void fio_posixaio_cleanup(struct thread_data *td) @@ -164,7 +223,6 @@ static void fio_posixaio_cleanup(struct thread_data *td) if (pd) { free(pd->aio_events); free(pd); - td->io_ops->data = NULL; } } @@ -173,8 +231,8 @@ static int fio_posixaio_init(struct thread_data *td) struct posixaio_data *pd = malloc(sizeof(*pd)); memset(pd, 0, sizeof(*pd)); - pd->aio_events = malloc(td->iodepth * sizeof(struct io_u *)); - memset(pd->aio_events, 0, td->iodepth * sizeof(struct io_u *)); + pd->aio_events = malloc(td->o.iodepth * sizeof(struct io_u *)); + memset(pd->aio_events, 0, td->o.iodepth * sizeof(struct io_u *)); td->io_ops->data = pd; return 0; @@ -190,29 +248,11 @@ static struct ioengine_ops ioengine = { .getevents = fio_posixaio_getevents, .event = fio_posixaio_event, .cleanup = fio_posixaio_cleanup, + .open_file = generic_open_file, + .close_file = generic_close_file, + .get_file_size = generic_get_file_size, }; -#else /* FIO_HAVE_POSIXAIO */ - -/* - * When we have a proper configure system in place, we simply wont build - * and install this io engine. For now install a crippled version that - * just complains and fails to load. - */ -static int fio_posixaio_init(struct thread_data fio_unused *td) -{ - fprintf(stderr, "fio: posixaio not available\n"); - return 1; -} - -static struct ioengine_ops ioengine = { - .name = "posixaio", - .version = FIO_IOOPS_VERSION, - .init = fio_posixaio_init, -}; - -#endif - static void fio_init fio_posixaio_register(void) { register_ioengine(&ioengine);