engines/syslet-rw.c

   1 /*
   2  * read/write() engine that uses syslet to be async
   3  *
   4  */
   5 #include <stdio.h>
   6 #include <stdlib.h>
   7 #include <unistd.h>
   8 #include <errno.h>
   9 #include <assert.h>
  10
  11 #include "../fio.h"
  12 #include "../os.h"
  13
  14 #ifdef FIO_HAVE_SYSLET
  15
  16 struct syslet_data {
  17         struct io_u **events;
  18         unsigned int nr_events;
  19
  20         struct async_head_user *ahu;
  21         struct syslet_uatom **ring;
  22         unsigned int ring_index;
  23 };
  24
  25 /*
  26  * Inspect the ring to see if we have completed events
  27  */
  28 static void fio_syslet_complete(struct thread_data *td)
  29 {
  30         struct syslet_data *sd = td->io_ops->data;
  31
  32         do {
  33                 struct syslet_uatom *atom;
  34                 struct io_u *io_u;
  35                 long ret;
  36
  37                 atom = sd->ring[sd->ring_index];
  38                 if (!atom)
  39                         break;
  40
  41                 sd->ring[sd->ring_index] = NULL;
  42                 if (++sd->ring_index == td->iodepth)
  43                         sd->ring_index = 0;
  44
  45                 io_u = atom->private;
  46                 ret = *atom->ret_ptr;
  47                 if (ret > 0)
  48                         io_u->resid = io_u->xfer_buflen - ret;
  49                 else if (ret < 0)
  50                         io_u->error = ret;
  51
  52                 sd->events[sd->nr_events++] = io_u;
  53         } while (1);
  54 }
  55
  56 static int fio_syslet_getevents(struct thread_data *td, int min,
  57                                 int fio_unused max,
  58                                 struct timespec fio_unused *t)
  59 {
  60         struct syslet_data *sd = td->io_ops->data;
  61         int get_events;
  62         long ret;
  63
  64         do {
  65                 fio_syslet_complete(td);
  66
  67                 /*
  68                  * do we have enough immediate completions?
  69                  */
  70                 if (sd->nr_events >= (unsigned int) min)
  71                         break;
  72
  73                 /*
  74                  * OK, we need to wait for some events...
  75                  */
  76                 get_events = min - sd->nr_events;
  77                 ret = async_wait(get_events);
  78                 if (ret < 0)
  79                         return errno;
  80         } while (1);
  81
  82         ret = sd->nr_events;
  83         sd->nr_events = 0;
  84         return ret;
  85 }
  86
  87 static struct io_u *fio_syslet_event(struct thread_data *td, int event)
  88 {
  89         struct syslet_data *sd = td->io_ops->data;
  90
  91         return sd->events[event];
  92 }
  93
  94 static void init_atom(struct syslet_uatom *atom, int nr, void *arg0,
  95                       void *arg1, void *arg2, void *arg3, void *ret_ptr,
  96                       unsigned long flags, void *priv)
  97 {
  98         atom->flags = flags;
  99         atom->nr = nr;
 100         atom->ret_ptr = ret_ptr;
 101         atom->next = NULL;
 102         atom->arg_ptr[0] = arg0;
 103         atom->arg_ptr[1] = arg1;
 104         atom->arg_ptr[2] = arg2;
 105         atom->arg_ptr[3] = arg3;
 106         atom->arg_ptr[4] = atom->arg_ptr[5] = NULL;
 107         atom->private = priv;
 108 }
 109
 110 /*
 111  * Use seek atom for sync
 112  */
 113 static void fio_syslet_prep_sync(struct io_u *io_u, struct fio_file *f)
 114 {
 115         init_atom(&io_u->req.atom, __NR_fsync, &f->fd, NULL, NULL, NULL,
 116                   &io_u->req.ret, 0, io_u);
 117 }
 118
 119 static void fio_syslet_prep_rw(struct io_u *io_u, struct fio_file *f)
 120 {
 121         int nr;
 122
 123         /*
 124          * prepare rw
 125          */
 126         if (io_u->ddir == DDIR_READ)
 127                 nr = __NR_pread64;
 128         else
 129                 nr = __NR_pwrite64;
 130
 131         init_atom(&io_u->req.atom, nr, &f->fd, &io_u->xfer_buf,
 132                   &io_u->xfer_buflen, &io_u->offset, &io_u->req.ret, 0, io_u);
 133 }
 134
 135 static int fio_syslet_prep(struct thread_data fio_unused *td, struct io_u *io_u)
 136 {
 137         struct fio_file *f = io_u->file;
 138
 139         if (io_u->ddir == DDIR_SYNC)
 140                 fio_syslet_prep_sync(io_u, f);
 141         else
 142                 fio_syslet_prep_rw(io_u, f);
 143
 144         return 0;
 145 }
 146
 147 static int fio_syslet_queue(struct thread_data *td, struct io_u *io_u)
 148 {
 149         struct syslet_data *sd = td->io_ops->data;
 150         long ret;
 151
 152         /*
 153          * On sync completion, the atom is returned. So on NULL return
 154          * it's queued asynchronously.
 155          */
 156         if (!async_exec(&io_u->req.atom))
 157                 return FIO_Q_QUEUED;
 158
 159         /*
 160          * completed sync
 161          */
 162         ret = io_u->req.ret;
 163         if (ret != (long) io_u->xfer_buflen) {
 164                 if (ret > 0) {
 165                         io_u->resid = io_u->xfer_buflen - ret;
 166                         io_u->error = 0;
 167                         return FIO_Q_COMPLETED;
 168                 } else
 169                         io_u->error = errno;
 170         }
 171
 172         if (!io_u->error)
 173                 sd->events[sd->nr_events++] = io_u;
 174         else
 175                 td_verror(td, io_u->error);
 176
 177         return FIO_Q_COMPLETED;
 178 }
 179
 180 static int async_head_init(struct syslet_data *sd, unsigned int depth)
 181 {
 182         unsigned long ring_size;
 183
 184         sd->ahu = malloc(sizeof(struct async_head_user));
 185         memset(sd->ahu, 0, sizeof(struct async_head_user));
 186
 187         ring_size = sizeof(struct syslet_uatom *) * depth;
 188         sd->ring = malloc(ring_size);
 189         memset(sd->ring, 0, ring_size);
 190
 191         sd->ahu->completion_ring = sd->ring;
 192         sd->ahu->ring_size_bytes = ring_size;
 193         sd->ahu->max_nr_threads = -1;
 194
 195         if (async_register(sd->ahu, sizeof(*sd->ahu)) < 0) {
 196                 perror("async_register");
 197                 fprintf(stderr, "fio: syslet likely not supported\n");
 198                 free(sd->ring);
 199                 free(sd->ahu);
 200                 return 1;
 201         }
 202
 203         return 0;
 204 }
 205
 206 static void async_head_exit(struct syslet_data *sd)
 207 {
 208         if (async_unregister(sd->ahu, sizeof(*sd->ahu)) < 0)
 209                 perror("async_register");
 210
 211         free(sd->ahu);
 212         free(sd->ring);
 213 }
 214
 215 static void fio_syslet_cleanup(struct thread_data *td)
 216 {
 217         struct syslet_data *sd = td->io_ops->data;
 218
 219         if (sd) {
 220                 async_head_exit(sd);
 221                 free(sd->events);
 222                 free(sd);
 223                 td->io_ops->data = NULL;
 224         }
 225 }
 226
 227 static int fio_syslet_init(struct thread_data *td)
 228 {
 229         struct syslet_data *sd;
 230
 231
 232         sd = malloc(sizeof(*sd));
 233         memset(sd, 0, sizeof(*sd));
 234         sd->events = malloc(sizeof(struct io_u *) * td->iodepth);
 235         memset(sd->events, 0, sizeof(struct io_u *) * td->iodepth);
 236
 237         /*
 238          * This will handily fail for kernels where syslet isn't available
 239          */
 240         if (async_head_init(sd, td->iodepth)) {
 241                 free(sd->events);
 242                 free(sd);
 243                 return 1;
 244         }
 245
 246         td->io_ops->data = sd;
 247         return 0;
 248 }
 249
 250 static struct ioengine_ops ioengine = {
 251         .name           = "syslet-rw",
 252         .version        = FIO_IOOPS_VERSION,
 253         .init           = fio_syslet_init,
 254         .prep           = fio_syslet_prep,
 255         .queue          = fio_syslet_queue,
 256         .getevents      = fio_syslet_getevents,
 257         .event          = fio_syslet_event,
 258         .cleanup        = fio_syslet_cleanup,
 259 };
 260
 261 #else /* FIO_HAVE_SYSLET */
 262
 263 /*
 264  * When we have a proper configure system in place, we simply wont build
 265  * and install this io engine. For now install a crippled version that
 266  * just complains and fails to load.
 267  */
 268 static int fio_syslet_init(struct thread_data fio_unused *td)
 269 {
 270         fprintf(stderr, "fio: syslet not available\n");
 271         return 1;
 272 }
 273
 274 static struct ioengine_ops ioengine = {
 275         .name           = "syslet-rw",
 276         .version        = FIO_IOOPS_VERSION,
 277         .init           = fio_syslet_init,
 278 };
 279
 280 #endif /* FIO_HAVE_SYSLET */
 281
 282 static void fio_init fio_syslet_register(void)
 283 {
 284         register_ioengine(&ioengine);
 285 }
 286
 287 static void fio_exit fio_syslet_unregister(void)
 288 {
 289         unregister_ioengine(&ioengine);
 290 }