engines/solarisaio.c

   1 /*
   2  * Native Solaris async IO engine
   3  *
   4  */
   5 #include <stdio.h>
   6 #include <stdlib.h>
   7 #include <unistd.h>
   8 #include <signal.h>
   9 #include <errno.h>
  10
  11 #include "../fio.h"
  12
  13 #ifdef FIO_HAVE_SOLARISAIO
  14
  15 #include <sys/asynch.h>
  16
  17 struct solarisaio_data {
  18         struct io_u **aio_events;
  19         unsigned int aio_pending;
  20         unsigned int nr;
  21         unsigned int max_depth;
  22 };
  23
  24 static int fio_solarisaio_cancel(struct thread_data fio_unused *td,
  25                                struct io_u *io_u)
  26 {
  27         return aiocancel(&io_u->resultp);
  28 }
  29
  30 static int fio_solarisaio_prep(struct thread_data fio_unused *td,
  31                             struct io_u *io_u)
  32 {
  33         struct solarisaio_data *sd = td->io_ops->data;
  34
  35         io_u->resultp.aio_return = AIO_INPROGRESS;
  36         io_u->engine_data = sd;
  37         return 0;
  38 }
  39
  40 static void wait_for_event(struct timeval *tv)
  41 {
  42         struct solarisaio_data *sd;
  43         struct io_u *io_u;
  44         aio_result_t *res;
  45
  46         res = aiowait(tv);
  47         if (res == (aio_result_t *) -1) {
  48                 int err = errno;
  49
  50                 if (err != EINVAL) {
  51                         log_err("fio: solarisaio got %d in aiowait\n", err);
  52                         exit(err);
  53                 }
  54                 return;
  55         } else if (!res)
  56                 return;
  57
  58         io_u = container_of(res, struct io_u, resultp);
  59         sd = io_u->engine_data;
  60
  61         if (io_u->resultp.aio_return >= 0) {
  62                 io_u->resid = io_u->xfer_buflen - io_u->resultp.aio_return;
  63                 io_u->error = 0;
  64         } else
  65                 io_u->error = io_u->resultp.aio_return;
  66
  67         /*
  68          * For SIGIO, we need a write barrier between the two, so that
  69          * the ->aio_pending store is seen after the ->aio_events store
  70          */
  71         sd->aio_events[sd->aio_pending] = io_u;
  72         write_barrier();
  73         sd->aio_pending++;
  74         sd->nr--;
  75 }
  76
  77 static int fio_solarisaio_getevents(struct thread_data *td, unsigned int min,
  78                                     unsigned int max, struct timespec *t)
  79 {
  80         struct solarisaio_data *sd = td->io_ops->data;
  81         struct timeval tv;
  82         int ret;
  83
  84         if (!min || !t) {
  85                 tv.tv_sec = 0;
  86                 tv.tv_usec = 0;
  87         } else {
  88                 tv.tv_sec = t->tv_sec;
  89                 tv.tv_usec = t->tv_nsec / 1000;
  90         }
  91
  92         while (sd->aio_pending < min)
  93                 wait_for_event(&tv);
  94
  95         /*
  96          * should be OK without locking, as int operations should be atomic
  97          */
  98         ret = sd->aio_pending;
  99         sd->aio_pending -= ret;
 100         return ret;
 101 }
 102
 103 static struct io_u *fio_solarisaio_event(struct thread_data *td, int event)
 104 {
 105         struct solarisaio_data *sd = td->io_ops->data;
 106
 107         return sd->aio_events[event];
 108 }
 109
 110 static int fio_solarisaio_queue(struct thread_data fio_unused *td,
 111                               struct io_u *io_u)
 112 {
 113         struct solarisaio_data *sd = td->io_ops->data;
 114         struct fio_file *f = io_u->file;
 115         off_t off;
 116         int ret;
 117
 118         fio_ro_check(td, io_u);
 119
 120         if (io_u->ddir == DDIR_SYNC) {
 121                 if (sd->nr)
 122                         return FIO_Q_BUSY;
 123                 if (fsync(f->fd) < 0)
 124                         io_u->error = errno;
 125
 126                 return FIO_Q_COMPLETED;
 127         }
 128
 129         if (io_u->ddir == DDIR_DATASYNC) {
 130                 if (sd->nr)
 131                         return FIO_Q_BUSY;
 132                 if (fdatasync(f->fd) < 0)
 133                         io_u->error = errno;
 134
 135                 return FIO_Q_COMPLETED;
 136         }
 137
 138         if (sd->nr == sd->max_depth)
 139                 return FIO_Q_BUSY;
 140
 141         off = io_u->offset;
 142         if (io_u->ddir == DDIR_READ)
 143                 ret = aioread(f->fd, io_u->xfer_buf, io_u->xfer_buflen, off,
 144                                         SEEK_SET, &io_u->resultp);
 145         else
 146                 ret = aiowrite(f->fd, io_u->xfer_buf, io_u->xfer_buflen, off,
 147                                         SEEK_SET, &io_u->resultp);
 148         if (ret) {
 149                 io_u->error = errno;
 150                 td_verror(td, io_u->error, "xfer");
 151                 return FIO_Q_COMPLETED;
 152         }
 153
 154         sd->nr++;
 155         return FIO_Q_QUEUED;
 156 }
 157
 158 static void fio_solarisaio_cleanup(struct thread_data *td)
 159 {
 160         struct solarisaio_data *sd = td->io_ops->data;
 161
 162         if (sd) {
 163                 free(sd->aio_events);
 164                 free(sd);
 165         }
 166 }
 167
 168 /*
 169  * Set USE_SIGNAL_COMPLETIONS to use SIGIO as completion events.
 170  */
 171 #ifdef USE_SIGNAL_COMPLETIONS
 172 static void fio_solarisaio_sigio(int sig)
 173 {
 174         wait_for_event(NULL);
 175 }
 176
 177 static void fio_solarisaio_init_sigio(void)
 178 {
 179         struct sigaction act;
 180
 181         memset(&act, 0, sizeof(act));
 182         act.sa_handler = fio_solarisaio_sigio;
 183         act.sa_flags = SA_RESTART;
 184         sigaction(SIGIO, &act, NULL);
 185 }
 186 #endif
 187
 188 static int fio_solarisaio_init(struct thread_data *td)
 189 {
 190         struct solarisaio_data *sd = malloc(sizeof(*sd));
 191         unsigned int max_depth;
 192
 193         max_depth = td->o.iodepth;
 194         if (max_depth > MAXASYNCHIO) {
 195                 max_depth = MAXASYNCHIO;
 196                 log_info("fio: lower depth to %d due to OS constraints\n",
 197                                                         max_depth);
 198         }
 199
 200         memset(sd, 0, sizeof(*sd));
 201         sd->aio_events = malloc(max_depth * sizeof(struct io_u *));
 202         memset(sd->aio_events, 0, max_depth * sizeof(struct io_u *));
 203         sd->max_depth = max_depth;
 204
 205 #ifdef USE_SIGNAL_COMPLETIONS
 206         fio_solarisaio_init_sigio();
 207 #endif
 208
 209         td->io_ops->data = sd;
 210         return 0;
 211 }
 212
 213 static struct ioengine_ops ioengine = {
 214         .name           = "solarisaio",
 215         .version        = FIO_IOOPS_VERSION,
 216         .init           = fio_solarisaio_init,
 217         .prep           = fio_solarisaio_prep,
 218         .queue          = fio_solarisaio_queue,
 219         .cancel         = fio_solarisaio_cancel,
 220         .getevents      = fio_solarisaio_getevents,
 221         .event          = fio_solarisaio_event,
 222         .cleanup        = fio_solarisaio_cleanup,
 223         .open_file      = generic_open_file,
 224         .close_file     = generic_close_file,
 225         .get_file_size  = generic_get_file_size,
 226 };
 227
 228 #else /* FIO_HAVE_SOLARISAIO */
 229
 230 /*
 231  * When we have a proper configure system in place, we simply wont build
 232  * and install this io engine. For now install a crippled version that
 233  * just complains and fails to load.
 234  */
 235 static int fio_solarisaio_init(struct thread_data fio_unused *td)
 236 {
 237         fprintf(stderr, "fio: solarisaio not available\n");
 238         return 1;
 239 }
 240
 241 static struct ioengine_ops ioengine = {
 242         .name           = "solarisaio",
 243         .version        = FIO_IOOPS_VERSION,
 244         .init           = fio_solarisaio_init,
 245 };
 246
 247 #endif
 248
 249 static void fio_init fio_solarisaio_register(void)
 250 {
 251         register_ioengine(&ioengine);
 252 }
 253
 254 static void fio_exit fio_solarisaio_unregister(void)
 255 {
 256         unregister_ioengine(&ioengine);
 257 }