engines/posixaio.c

   1 /*
   2  * posixaio engine
   3  *
   4  * IO engine that uses the posix defined aio interface.
   5  *
   6  */
   7 #include <stdio.h>
   8 #include <stdlib.h>
   9 #include <unistd.h>
  10 #include <errno.h>
  11 #include <fcntl.h>
  12
  13 #include "../fio.h"
  14
  15 #ifdef FIO_HAVE_POSIXAIO
  16
  17 struct posixaio_data {
  18         struct io_u **aio_events;
  19         unsigned int queued;
  20 };
  21
  22 static int fill_timespec(struct timespec *ts)
  23 {
  24 #ifdef _POSIX_TIMERS
  25         if (!clock_gettime(CLOCK_MONOTONIC, ts))
  26                 return 0;
  27
  28         perror("clock_gettime");
  29 #endif
  30         return 1;
  31 }
  32
  33 static unsigned long long ts_utime_since_now(struct timespec *t)
  34 {
  35         long long sec, nsec;
  36         struct timespec now;
  37
  38         if (fill_timespec(&now))
  39                 return 0;
  40
  41         sec = now.tv_sec - t->tv_sec;
  42         nsec = now.tv_nsec - t->tv_nsec;
  43         if (sec > 0 && nsec < 0) {
  44                 sec--;
  45                 nsec += 1000000000;
  46         }
  47
  48         sec *= 1000000;
  49         nsec /= 1000;
  50         return sec + nsec;
  51 }
  52
  53 static int fio_posixaio_cancel(struct thread_data fio_unused *td,
  54                                struct io_u *io_u)
  55 {
  56         struct fio_file *f = io_u->file;
  57         int r = aio_cancel(f->fd, &io_u->aiocb);
  58
  59         if (r == AIO_ALLDONE || r == AIO_CANCELED)
  60                 return 0;
  61
  62         return 1;
  63 }
  64
  65 static int fio_posixaio_prep(struct thread_data fio_unused *td,
  66                              struct io_u *io_u)
  67 {
  68         struct aiocb *aiocb = &io_u->aiocb;
  69         struct fio_file *f = io_u->file;
  70
  71         aiocb->aio_fildes = f->fd;
  72         aiocb->aio_buf = io_u->xfer_buf;
  73         aiocb->aio_nbytes = io_u->xfer_buflen;
  74         aiocb->aio_offset = io_u->offset;
  75         aiocb->aio_sigevent.sigev_notify = SIGEV_NONE;
  76
  77         io_u->seen = 0;
  78         return 0;
  79 }
  80
  81 #define SUSPEND_ENTRIES 8
  82
  83 static int fio_posixaio_getevents(struct thread_data *td, unsigned int min,
  84                                   unsigned int max, struct timespec *t)
  85 {
  86         struct posixaio_data *pd = td->io_ops->data;
  87         struct aiocb *suspend_list[SUSPEND_ENTRIES];
  88         struct flist_head *entry;
  89         struct timespec start;
  90         int have_timeout = 0;
  91         int suspend_entries = 0;
  92         unsigned int r;
  93
  94         if (t && !fill_timespec(&start))
  95                 have_timeout = 1;
  96
  97         r = 0;
  98         memset(suspend_list, 0, sizeof(*suspend_list));
  99 restart:
 100         flist_for_each(entry, &td->io_u_busylist) {
 101                 struct io_u *io_u = flist_entry(entry, struct io_u, list);
 102                 int err;
 103
 104                 if (io_u->seen)
 105                         continue;
 106
 107                 err = aio_error(&io_u->aiocb);
 108                 if (err == EINPROGRESS) {
 109                         if (suspend_entries < SUSPEND_ENTRIES) {
 110                                 suspend_list[suspend_entries] = &io_u->aiocb;
 111                                 suspend_entries++;
 112                         }
 113                         continue;
 114                 }
 115
 116                 io_u->seen = 1;
 117                 pd->queued--;
 118                 pd->aio_events[r++] = io_u;
 119
 120                 if (err == ECANCELED)
 121                         io_u->resid = io_u->xfer_buflen;
 122                 else if (!err) {
 123                         ssize_t retval = aio_return(&io_u->aiocb);
 124
 125                         io_u->resid = io_u->xfer_buflen - retval;
 126                 } else
 127                         io_u->error = err;
 128         }
 129
 130         if (r >= min)
 131                 return r;
 132
 133         if (have_timeout) {
 134                 unsigned long long usec;
 135
 136                 usec = (t->tv_sec * 1000000) + (t->tv_nsec / 1000);
 137                 if (ts_utime_since_now(&start) > usec)
 138                         return r;
 139         }
 140
 141         /*
 142          * must have some in-flight, wait for at least one
 143          */
 144         aio_suspend((const struct aiocb * const *)suspend_list,
 145                                                         suspend_entries, t);
 146         goto restart;
 147 }
 148
 149 static struct io_u *fio_posixaio_event(struct thread_data *td, int event)
 150 {
 151         struct posixaio_data *pd = td->io_ops->data;
 152
 153         return pd->aio_events[event];
 154 }
 155
 156 static int fio_posixaio_queue(struct thread_data *td,
 157                               struct io_u *io_u)
 158 {
 159         struct posixaio_data *pd = td->io_ops->data;
 160         struct aiocb *aiocb = &io_u->aiocb;
 161         int ret;
 162
 163         fio_ro_check(td, io_u);
 164
 165         if (io_u->ddir == DDIR_READ)
 166                 ret = aio_read(aiocb);
 167         else if (io_u->ddir == DDIR_WRITE)
 168                 ret = aio_write(aiocb);
 169         else if (io_u->ddir == DDIR_TRIM) {
 170                 if (pd->queued)
 171                         return FIO_Q_BUSY;
 172
 173                 do_io_u_trim(td, io_u);
 174                 return FIO_Q_COMPLETED;
 175         } else {
 176 #ifdef FIO_HAVE_POSIXAIO_FSYNC
 177                 ret = aio_fsync(O_SYNC, aiocb);
 178 #else
 179                 if (pd->queued)
 180                         return FIO_Q_BUSY;
 181
 182                 do_io_u_sync(td, io_u);
 183                 return FIO_Q_COMPLETED;
 184 #endif
 185         }
 186
 187         if (ret) {
 188                 /*
 189                  * At least OSX has a very low limit on the number of pending
 190                  * IOs, so if it returns EAGAIN, we are out of resources
 191                  * to queue more. Just return FIO_Q_BUSY to naturally
 192                  * drop off at this depth.
 193                  */
 194                 if (errno == EAGAIN)
 195                         return FIO_Q_BUSY;
 196
 197                 io_u->error = errno;
 198                 td_verror(td, io_u->error, "xfer");
 199                 return FIO_Q_COMPLETED;
 200         }
 201
 202         pd->queued++;
 203         return FIO_Q_QUEUED;
 204 }
 205
 206 static void fio_posixaio_cleanup(struct thread_data *td)
 207 {
 208         struct posixaio_data *pd = td->io_ops->data;
 209
 210         if (pd) {
 211                 free(pd->aio_events);
 212                 free(pd);
 213         }
 214 }
 215
 216 static int fio_posixaio_init(struct thread_data *td)
 217 {
 218         struct posixaio_data *pd = malloc(sizeof(*pd));
 219
 220         memset(pd, 0, sizeof(*pd));
 221         pd->aio_events = malloc(td->o.iodepth * sizeof(struct io_u *));
 222         memset(pd->aio_events, 0, td->o.iodepth * sizeof(struct io_u *));
 223
 224         td->io_ops->data = pd;
 225         return 0;
 226 }
 227
 228 static struct ioengine_ops ioengine = {
 229         .name           = "posixaio",
 230         .version        = FIO_IOOPS_VERSION,
 231         .init           = fio_posixaio_init,
 232         .prep           = fio_posixaio_prep,
 233         .queue          = fio_posixaio_queue,
 234         .cancel         = fio_posixaio_cancel,
 235         .getevents      = fio_posixaio_getevents,
 236         .event          = fio_posixaio_event,
 237         .cleanup        = fio_posixaio_cleanup,
 238         .open_file      = generic_open_file,
 239         .close_file     = generic_close_file,
 240         .get_file_size  = generic_get_file_size,
 241 };
 242
 243 #else /* FIO_HAVE_POSIXAIO */
 244
 245 /*
 246  * When we have a proper configure system in place, we simply wont build
 247  * and install this io engine. For now install a crippled version that
 248  * just complains and fails to load.
 249  */
 250 static int fio_posixaio_init(struct thread_data fio_unused *td)
 251 {
 252         log_err("fio: posixaio not available\n");
 253         return 1;
 254 }
 255
 256 static struct ioengine_ops ioengine = {
 257         .name           = "posixaio",
 258         .version        = FIO_IOOPS_VERSION,
 259         .init           = fio_posixaio_init,
 260 };
 261
 262 #endif
 263
 264 static void fio_init fio_posixaio_register(void)
 265 {
 266         register_ioengine(&ioengine);
 267 }
 268
 269 static void fio_exit fio_posixaio_unregister(void)
 270 {
 271         unregister_ioengine(&ioengine);
 272 }