engines/syslet-rw.c

   1 /*
   2  * syslet engine
   3  *
   4  * IO engine that does regular pread(2)/pwrite(2) to transfer data, but
   5  * with syslets to make the execution async.
   6  *
   7  */
   8 #include <stdio.h>
   9 #include <stdlib.h>
  10 #include <unistd.h>
  11 #include <errno.h>
  12 #include <assert.h>
  13 #include <asm/unistd.h>
  14
  15 #include "../fio.h"
  16 #include "../os.h"
  17
  18 #ifdef FIO_HAVE_SYSLET
  19
  20 #ifdef __NR_pread64
  21 #define __NR_fio_pread  __NR_pread64
  22 #define __NR_fio_pwrite __NR_pwrite64
  23 #else
  24 #define __NR_fio_pread  __NR_pread
  25 #define __NR_fio_pwrite __NR_pwrite
  26 #endif
  27
  28 struct syslet_data {
  29         struct io_u **events;
  30         unsigned int nr_events;
  31
  32         struct async_head_user ahu;
  33         struct syslet_uatom **ring;
  34
  35         struct syslet_uatom *head, *tail;
  36 };
  37
  38 static void fio_syslet_complete_atom(struct thread_data *td,
  39                                      struct syslet_uatom *atom)
  40 {
  41         struct syslet_data *sd = td->io_ops->data;
  42         struct syslet_uatom *last;
  43         struct io_u *io_u;
  44
  45         /*
  46          * complete from the beginning of the sequence up to (and
  47          * including) this atom
  48          */
  49         last = atom;
  50         io_u = atom->private;
  51         atom = io_u->req.head;
  52
  53         /*
  54          * now complete in right order
  55          */
  56         do {
  57                 long ret;
  58
  59                 io_u = atom->private;
  60                 ret = *atom->ret_ptr;
  61                 if (ret >= 0)
  62                         io_u->resid = io_u->xfer_buflen - ret;
  63                 else if (ret < 0)
  64                         io_u->error = ret;
  65
  66                 assert(sd->nr_events < td->o.iodepth);
  67                 sd->events[sd->nr_events++] = io_u;
  68
  69                 if (atom == last)
  70                         break;
  71
  72                 atom = atom->next;
  73         } while (1);
  74
  75         assert(!last->next);
  76 }
  77
  78 /*
  79  * Inspect the ring to see if we have completed events
  80  */
  81 static void fio_syslet_complete(struct thread_data *td)
  82 {
  83         struct syslet_data *sd = td->io_ops->data;
  84
  85         do {
  86                 struct syslet_uatom *atom;
  87
  88                 atom = sd->ring[sd->ahu.user_ring_idx];
  89                 if (!atom)
  90                         break;
  91
  92                 sd->ring[sd->ahu.user_ring_idx] = NULL;
  93                 if (++sd->ahu.user_ring_idx == td->o.iodepth)
  94                         sd->ahu.user_ring_idx = 0;
  95
  96                 fio_syslet_complete_atom(td, atom);
  97         } while (1);
  98 }
  99
 100 static int fio_syslet_getevents(struct thread_data *td, int min,
 101                                 int fio_unused max,
 102                                 struct timespec fio_unused *t)
 103 {
 104         struct syslet_data *sd = td->io_ops->data;
 105         long ret;
 106
 107         do {
 108                 fio_syslet_complete(td);
 109
 110                 /*
 111                  * do we have enough immediate completions?
 112                  */
 113                 if (sd->nr_events >= (unsigned int) min)
 114                         break;
 115
 116                 /*
 117                  * OK, we need to wait for some events...
 118                  */
 119                 ret = async_wait(1, sd->ahu.user_ring_idx, &sd->ahu);
 120                 if (ret < 0)
 121                         return -errno;
 122         } while (1);
 123
 124         ret = sd->nr_events;
 125         sd->nr_events = 0;
 126         return ret;
 127 }
 128
 129 static struct io_u *fio_syslet_event(struct thread_data *td, int event)
 130 {
 131         struct syslet_data *sd = td->io_ops->data;
 132
 133         return sd->events[event];
 134 }
 135
 136 static void init_atom(struct syslet_uatom *atom, int nr, void *arg0,
 137                       void *arg1, void *arg2, void *arg3, void *ret_ptr,
 138                       unsigned long flags, void *priv)
 139 {
 140         atom->flags = flags;
 141         atom->nr = nr;
 142         atom->ret_ptr = ret_ptr;
 143         atom->next = NULL;
 144         atom->arg_ptr[0] = arg0;
 145         atom->arg_ptr[1] = arg1;
 146         atom->arg_ptr[2] = arg2;
 147         atom->arg_ptr[3] = arg3;
 148         atom->arg_ptr[4] = atom->arg_ptr[5] = NULL;
 149         atom->private = priv;
 150 }
 151
 152 /*
 153  * Use seek atom for sync
 154  */
 155 static void fio_syslet_prep_sync(struct io_u *io_u, struct fio_file *f)
 156 {
 157         init_atom(&io_u->req.atom, __NR_fsync, &f->fd, NULL, NULL, NULL,
 158                   &io_u->req.ret, 0, io_u);
 159 }
 160
 161 static void fio_syslet_prep_rw(struct io_u *io_u, struct fio_file *f)
 162 {
 163         int nr;
 164
 165         /*
 166          * prepare rw
 167          */
 168         if (io_u->ddir == DDIR_READ)
 169                 nr = __NR_fio_pread;
 170         else
 171                 nr = __NR_fio_pwrite;
 172
 173         init_atom(&io_u->req.atom, nr, &f->fd, &io_u->xfer_buf,
 174                   &io_u->xfer_buflen, &io_u->offset, &io_u->req.ret, 0, io_u);
 175 }
 176
 177 static int fio_syslet_prep(struct thread_data fio_unused *td, struct io_u *io_u)
 178 {
 179         struct fio_file *f = io_u->file;
 180
 181         if (io_u->ddir == DDIR_SYNC)
 182                 fio_syslet_prep_sync(io_u, f);
 183         else
 184                 fio_syslet_prep_rw(io_u, f);
 185
 186         return 0;
 187 }
 188
 189 static void cachemiss_thread_start(void)
 190 {
 191         while (1)
 192                 async_thread(NULL, NULL);
 193 }
 194
 195 #define THREAD_STACK_SIZE (16384)
 196
 197 static unsigned long thread_stack_alloc()
 198 {
 199         return (unsigned long) malloc(THREAD_STACK_SIZE) + THREAD_STACK_SIZE;
 200 }
 201
 202 static void fio_syslet_queued(struct thread_data *td, struct syslet_data *sd)
 203 {
 204         struct syslet_uatom *atom;
 205         struct timeval now;
 206
 207         fio_gettime(&now, NULL);
 208
 209         atom = sd->head;
 210         while (atom) {
 211                 struct io_u *io_u = atom->private;
 212
 213                 memcpy(&io_u->issue_time, &now, sizeof(now));
 214                 io_u_queued(td, io_u);
 215                 atom = atom->next;
 216         }
 217 }
 218
 219 static int fio_syslet_commit(struct thread_data *td)
 220 {
 221         struct syslet_data *sd = td->io_ops->data;
 222         struct syslet_uatom *done;
 223
 224         if (!sd->head)
 225                 return 0;
 226
 227         assert(!sd->tail->next);
 228
 229         if (!sd->ahu.new_thread_stack)
 230                 sd->ahu.new_thread_stack = thread_stack_alloc();
 231
 232         fio_syslet_queued(td, sd);
 233
 234         /*
 235          * On sync completion, the atom is returned. So on NULL return
 236          * it's queued asynchronously.
 237          */
 238         done = async_exec(sd->head, &sd->ahu);
 239
 240         if (done == (void *) -1) {
 241                 log_err("fio: syslets don't appear to work\n");
 242                 return -1;
 243         }
 244
 245         sd->head = sd->tail = NULL;
 246
 247         if (done)
 248                 fio_syslet_complete_atom(td, done);
 249
 250         return 0;
 251 }
 252
 253 static int fio_syslet_queue(struct thread_data *td, struct io_u *io_u)
 254 {
 255         struct syslet_data *sd = td->io_ops->data;
 256
 257         if (sd->tail) {
 258                 sd->tail->next = &io_u->req.atom;
 259                 sd->tail = &io_u->req.atom;
 260         } else
 261                 sd->head = sd->tail = &io_u->req.atom;
 262
 263         io_u->req.head = sd->head;
 264         return FIO_Q_QUEUED;
 265 }
 266
 267 static int async_head_init(struct syslet_data *sd, unsigned int depth)
 268 {
 269         unsigned long ring_size;
 270
 271         memset(&sd->ahu, 0, sizeof(struct async_head_user));
 272
 273         ring_size = sizeof(struct syslet_uatom *) * depth;
 274         sd->ring = malloc(ring_size);
 275         memset(sd->ring, 0, ring_size);
 276
 277         sd->ahu.user_ring_idx = 0;
 278         sd->ahu.completion_ring = sd->ring;
 279         sd->ahu.ring_size_bytes = ring_size;
 280         sd->ahu.head_stack = thread_stack_alloc();
 281         sd->ahu.head_eip = (unsigned long) cachemiss_thread_start;
 282         sd->ahu.new_thread_eip = (unsigned long) cachemiss_thread_start;
 283
 284         return 0;
 285 }
 286
 287 static void async_head_exit(struct syslet_data *sd)
 288 {
 289         free(sd->ring);
 290 }
 291
 292 static int check_syslet_support(struct syslet_data *sd)
 293 {
 294         struct syslet_uatom atom;
 295         void *ret;
 296
 297         init_atom(&atom, __NR_getpid, NULL, NULL, NULL, NULL, NULL, 0, NULL);
 298         ret = async_exec(sd->head, &sd->ahu);
 299         if (ret == (void *) -1)
 300                 return 1;
 301
 302         return 0;
 303 }
 304
 305 static void fio_syslet_cleanup(struct thread_data *td)
 306 {
 307         struct syslet_data *sd = td->io_ops->data;
 308
 309         if (sd) {
 310                 async_head_exit(sd);
 311                 free(sd->events);
 312                 free(sd);
 313                 td->io_ops->data = NULL;
 314         }
 315 }
 316
 317 static int fio_syslet_init(struct thread_data *td)
 318 {
 319         struct syslet_data *sd;
 320
 321         sd = malloc(sizeof(*sd));
 322         memset(sd, 0, sizeof(*sd));
 323         sd->events = malloc(sizeof(struct io_u *) * td->o.iodepth);
 324         memset(sd->events, 0, sizeof(struct io_u *) * td->o.iodepth);
 325
 326         /*
 327          * This will handily fail for kernels where syslet isn't available
 328          */
 329         if (async_head_init(sd, td->o.iodepth)) {
 330                 free(sd->events);
 331                 free(sd);
 332                 return 1;
 333         }
 334
 335         if (check_syslet_support(sd)) {
 336                 log_err("fio: syslets do not appear to work\n");
 337                 free(sd->events);
 338                 free(sd);
 339                 return 1;
 340         }
 341
 342         td->io_ops->data = sd;
 343         return 0;
 344 }
 345
 346 static struct ioengine_ops ioengine = {
 347         .name           = "syslet-rw",
 348         .version        = FIO_IOOPS_VERSION,
 349         .init           = fio_syslet_init,
 350         .prep           = fio_syslet_prep,
 351         .queue          = fio_syslet_queue,
 352         .commit         = fio_syslet_commit,
 353         .getevents      = fio_syslet_getevents,
 354         .event          = fio_syslet_event,
 355         .cleanup        = fio_syslet_cleanup,
 356         .open_file      = generic_open_file,
 357         .close_file     = generic_close_file,
 358 };
 359
 360 #else /* FIO_HAVE_SYSLET */
 361
 362 /*
 363  * When we have a proper configure system in place, we simply wont build
 364  * and install this io engine. For now install a crippled version that
 365  * just complains and fails to load.
 366  */
 367 static int fio_syslet_init(struct thread_data fio_unused *td)
 368 {
 369         fprintf(stderr, "fio: syslet not available\n");
 370         return 1;
 371 }
 372
 373 static struct ioengine_ops ioengine = {
 374         .name           = "syslet-rw",
 375         .version        = FIO_IOOPS_VERSION,
 376         .init           = fio_syslet_init,
 377 };
 378
 379 #endif /* FIO_HAVE_SYSLET */
 380
 381 static void fio_init fio_syslet_register(void)
 382 {
 383         register_ioengine(&ioengine);
 384 }
 385
 386 static void fio_exit fio_syslet_unregister(void)
 387 {
 388         unregister_ioengine(&ioengine);
 389 }