X-Git-Url: https://git.kernel.dk/?p=fio.git;a=blobdiff_plain;f=engines%2Fposixaio.c;h=a2b53873124b49cdcc6e14b9d7e508b948265091;hp=4aa7420c020dffbfff36a77d74c3d15b7fb6dc3b;hb=954cd73a9a93102c24afa869fbe67ac38af6e416;hpb=2dc1bbeb58edc85f2829eed6729862c438ea2353 diff --git a/engines/posixaio.c b/engines/posixaio.c index 4aa7420c..a2b53873 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, 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); - 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,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; } @@ -143,25 +166,53 @@ 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; + do_io_u_sync(td, io_u); + return FIO_Q_COMPLETED; +#endif + } + 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; } @@ -172,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; } } @@ -200,29 +250,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);