X-Git-Url: https://git.kernel.dk/?a=blobdiff_plain;f=engines%2Fposixaio.c;h=bddb1ec3f2697e43dff46dcc726ed31e419f27f0;hb=785e49c659023df1735bff195ad4ba133ebd23a7;hp=88dc0e90a654f2d49f372194a3caf6fe575684de;hpb=808a63b8d2d5f6d3a4ec83e718495f09588aef7e;p=fio.git diff --git a/engines/posixaio.c b/engines/posixaio.c index 88dc0e90..bddb1ec3 100644 --- a/engines/posixaio.c +++ b/engines/posixaio.c @@ -8,26 +8,36 @@ #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) @@ -56,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; @@ -65,43 +75,59 @@ 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->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, const struct timespec *t) { - struct posixaio_data *pd = td->io_ops->data; - struct list_head *entry; + struct posixaio_data *pd = td->io_ops_data; + 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); - if (err == EINPROGRESS) + if (err == EINPROGRESS) { + if (suspend_entries < SUSPEND_ENTRIES) { + suspend_list[suspend_entries] = &io_u->aiocb; + suspend_entries++; + } continue; + } io_u->seen = 1; + pd->queued--; pd->aio_events[r++] = io_u; if (err == ECANCELED) @@ -112,9 +138,6 @@ restart: io_u->resid = io_u->xfer_buflen - retval; } else io_u->error = err; - - if (r >= max) - break; } if (r >= min) @@ -129,50 +152,79 @@ 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; } static struct io_u *fio_posixaio_event(struct thread_data *td, int event) { - struct posixaio_data *pd = td->io_ops->data; + struct posixaio_data *pd = td->io_ops_data; 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; + + do_io_u_sync(td, io_u); + return FIO_Q_COMPLETED; +#endif + } if (ret) { - io_u->error = errno; + int aio_err = errno; + + /* + * 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 (aio_err == EAGAIN) + return FIO_Q_BUSY; + + io_u->error = aio_err; 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) { - struct posixaio_data *pd = td->io_ops->data; + struct posixaio_data *pd = td->io_ops_data; if (pd) { free(pd->aio_events); free(pd); - td->io_ops->data = NULL; } } @@ -181,10 +233,10 @@ 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; + td->io_ops_data = pd; return 0; } @@ -200,29 +252,9 @@ static struct ioengine_ops ioengine = { .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);