ioengines.c

   1 /*
   2  * The io parts of the fio tool, includes workers for sync and mmap'ed
   3  * io, as well as both posix and linux libaio support.
   4  *
   5  * sync io is implemented on top of aio.
   6  *
   7  * This is not really specific to fio, if the get_io_u/put_io_u and
   8  * structures was pulled into this as well it would be a perfectly
   9  * generic io engine that could be used for other projects.
  10  *
  11  */
  12 #include <stdio.h>
  13 #include <stdlib.h>
  14 #include <unistd.h>
  15 #include <string.h>
  16 #include <dlfcn.h>
  17 #include <fcntl.h>
  18 #include <assert.h>
  19
  20 #include "fio.h"
  21 #include "diskutil.h"
  22
  23 static FLIST_HEAD(engine_list);
  24
  25 static int check_engine_ops(struct ioengine_ops *ops)
  26 {
  27         if (ops->version != FIO_IOOPS_VERSION) {
  28                 log_err("bad ioops version %d (want %d)\n", ops->version,
  29                                                         FIO_IOOPS_VERSION);
  30                 return 1;
  31         }
  32
  33         if (!ops->queue) {
  34                 log_err("%s: no queue handler\n", ops->name);
  35                 return 1;
  36         }
  37
  38         /*
  39          * sync engines only need a ->queue()
  40          */
  41         if (ops->flags & FIO_SYNCIO)
  42                 return 0;
  43
  44         if (!ops->event) {
  45                 log_err("%s: no event handler\n", ops->name);
  46                 return 1;
  47         }
  48         if (!ops->getevents) {
  49                 log_err("%s: no getevents handler\n", ops->name);
  50                 return 1;
  51         }
  52         if (!ops->queue) {
  53                 log_err("%s: no queue handler\n", ops->name);
  54                 return 1;
  55         }
  56
  57         return 0;
  58 }
  59
  60 void unregister_ioengine(struct ioengine_ops *ops)
  61 {
  62         dprint(FD_IO, "ioengine %s unregistered\n", ops->name);
  63         flist_del(&ops->list);
  64         INIT_FLIST_HEAD(&ops->list);
  65 }
  66
  67 void register_ioengine(struct ioengine_ops *ops)
  68 {
  69         dprint(FD_IO, "ioengine %s registered\n", ops->name);
  70         INIT_FLIST_HEAD(&ops->list);
  71         flist_add_tail(&ops->list, &engine_list);
  72 }
  73
  74 static struct ioengine_ops *find_ioengine(const char *name)
  75 {
  76         struct ioengine_ops *ops;
  77         struct flist_head *entry;
  78
  79         flist_for_each(entry, &engine_list) {
  80                 ops = flist_entry(entry, struct ioengine_ops, list);
  81                 if (!strcmp(name, ops->name))
  82                         return ops;
  83         }
  84
  85         return NULL;
  86 }
  87
  88 static struct ioengine_ops *dlopen_ioengine(struct thread_data *td,
  89                                             const char *engine_lib)
  90 {
  91         struct ioengine_ops *ops;
  92         void *dlhandle;
  93
  94         dprint(FD_IO, "dload engine %s\n", engine_lib);
  95
  96         dlerror();
  97         dlhandle = dlopen(engine_lib, RTLD_LAZY);
  98         if (!dlhandle) {
  99                 td_vmsg(td, -1, dlerror(), "dlopen");
 100                 return NULL;
 101         }
 102
 103         /*
 104          * Unlike the included modules, external engines should have a
 105          * non-static ioengine structure that we can reference.
 106          */
 107         ops = dlsym(dlhandle, engine_lib);
 108         if (!ops)
 109                 ops = dlsym(dlhandle, "ioengine");
 110         if (!ops) {
 111                 td_vmsg(td, -1, dlerror(), "dlsym");
 112                 dlclose(dlhandle);
 113                 return NULL;
 114         }
 115
 116         ops->dlhandle = dlhandle;
 117         return ops;
 118 }
 119
 120 struct ioengine_ops *load_ioengine(struct thread_data *td, const char *name)
 121 {
 122         struct ioengine_ops *ops, *ret;
 123         char engine[16];
 124
 125         dprint(FD_IO, "load ioengine %s\n", name);
 126
 127         strncpy(engine, name, sizeof(engine) - 1);
 128
 129         /*
 130          * linux libaio has alias names, so convert to what we want
 131          */
 132         if (!strncmp(engine, "linuxaio", 8) || !strncmp(engine, "aio", 3))
 133                 strcpy(engine, "libaio");
 134
 135         ops = find_ioengine(engine);
 136         if (!ops)
 137                 ops = dlopen_ioengine(td, name);
 138
 139         if (!ops) {
 140                 log_err("fio: engine %s not loadable\n", name);
 141                 return NULL;
 142         }
 143
 144         /*
 145          * Check that the required methods are there.
 146          */
 147         if (check_engine_ops(ops))
 148                 return NULL;
 149
 150         ret = malloc(sizeof(*ret));
 151         memcpy(ret, ops, sizeof(*ret));
 152         ret->data = NULL;
 153
 154         return ret;
 155 }
 156
 157 /*
 158  * For cleaning up an ioengine which never made it to init().
 159  */
 160 void free_ioengine(struct thread_data *td)
 161 {
 162         dprint(FD_IO, "free ioengine %s\n", td->io_ops->name);
 163
 164         if (td->eo && td->io_ops->options) {
 165                 options_free(td->io_ops->options, td->eo);
 166                 free(td->eo);
 167                 td->eo = NULL;
 168         }
 169
 170         if (td->io_ops->dlhandle)
 171                 dlclose(td->io_ops->dlhandle);
 172
 173         free(td->io_ops);
 174         td->io_ops = NULL;
 175 }
 176
 177 void close_ioengine(struct thread_data *td)
 178 {
 179         dprint(FD_IO, "close ioengine %s\n", td->io_ops->name);
 180
 181         if (td->io_ops->cleanup) {
 182                 td->io_ops->cleanup(td);
 183                 td->io_ops->data = NULL;
 184         }
 185
 186         free_ioengine(td);
 187 }
 188
 189 int td_io_prep(struct thread_data *td, struct io_u *io_u)
 190 {
 191         dprint_io_u(io_u, "prep");
 192         fio_ro_check(td, io_u);
 193
 194         lock_file(td, io_u->file, io_u->ddir);
 195
 196         if (td->io_ops->prep) {
 197                 int ret = td->io_ops->prep(td, io_u);
 198
 199                 dprint(FD_IO, "->prep(%p)=%d\n", io_u, ret);
 200                 if (ret)
 201                         unlock_file(td, io_u->file);
 202                 return ret;
 203         }
 204
 205         return 0;
 206 }
 207
 208 int td_io_getevents(struct thread_data *td, unsigned int min, unsigned int max,
 209                     struct timespec *t)
 210 {
 211         int r = 0;
 212
 213         /*
 214          * For ioengine=rdma one side operation RDMA_WRITE or RDMA_READ,
 215          * server side gets a message from the client
 216          * side that the task is finished, and
 217          * td->done is set to 1 after td_io_commit(). In this case,
 218          * there is no need to reap complete event in server side.
 219          */
 220         if (td->done)
 221                 return 0;
 222
 223         if (min > 0 && td->io_ops->commit) {
 224                 r = td->io_ops->commit(td);
 225                 if (r < 0)
 226                         goto out;
 227         }
 228         if (max > td->cur_depth)
 229                 max = td->cur_depth;
 230         if (min > max)
 231                 max = min;
 232
 233         r = 0;
 234         if (max && td->io_ops->getevents)
 235                 r = td->io_ops->getevents(td, min, max, t);
 236 out:
 237         if (r >= 0) {
 238                 /*
 239                  * Reflect that our submitted requests were retrieved with
 240                  * whatever OS async calls are in the underlying engine.
 241                  */
 242                 td->io_u_in_flight -= r;
 243                 io_u_mark_complete(td, r);
 244         } else
 245                 td_verror(td, r, "get_events");
 246
 247         dprint(FD_IO, "getevents: %d\n", r);
 248         return r;
 249 }
 250
 251 int td_io_queue(struct thread_data *td, struct io_u *io_u)
 252 {
 253         int ret;
 254
 255         dprint_io_u(io_u, "queue");
 256         fio_ro_check(td, io_u);
 257
 258         assert((io_u->flags & IO_U_F_FLIGHT) == 0);
 259         io_u->flags |= IO_U_F_FLIGHT;
 260
 261         assert(fio_file_open(io_u->file));
 262
 263         io_u->error = 0;
 264         io_u->resid = 0;
 265
 266         if (td->io_ops->flags & FIO_SYNCIO) {
 267                 if (fio_fill_issue_time(td))
 268                         fio_gettime(&io_u->issue_time, NULL);
 269
 270                 /*
 271                  * only used for iolog
 272                  */
 273                 if (td->o.read_iolog_file)
 274                         memcpy(&td->last_issue, &io_u->issue_time,
 275                                         sizeof(struct timeval));
 276         }
 277
 278         if (ddir_rw(io_u->ddir))
 279                 td->io_issues[io_u->ddir]++;
 280
 281         ret = td->io_ops->queue(td, io_u);
 282
 283         unlock_file(td, io_u->file);
 284
 285         /*
 286          * Add warning for O_DIRECT so that users have an easier time
 287          * spotting potentially bad alignment. If this triggers for the first
 288          * IO, then it's likely an alignment problem or because the host fs
 289          * does not support O_DIRECT
 290          */
 291         if (io_u->error == EINVAL && td->io_issues[io_u->ddir & 1] == 1 &&
 292             td->o.odirect) {
 293
 294                 log_info("fio: first direct IO errored. File system may not "
 295                          "support direct IO, or iomem_align= is bad.\n");
 296         }
 297
 298         if (!td->io_ops->commit || ddir_trim(io_u->ddir)) {
 299                 io_u_mark_submit(td, 1);
 300                 io_u_mark_complete(td, 1);
 301         }
 302
 303         if (ret == FIO_Q_COMPLETED) {
 304                 if (ddir_rw(io_u->ddir)) {
 305                         io_u_mark_depth(td, 1);
 306                         td->ts.total_io_u[io_u->ddir]++;
 307                 }
 308         } else if (ret == FIO_Q_QUEUED) {
 309                 int r;
 310
 311                 if (ddir_rw(io_u->ddir)) {
 312                         td->io_u_queued++;
 313                         td->ts.total_io_u[io_u->ddir]++;
 314                 }
 315
 316                 if (td->io_u_queued >= td->o.iodepth_batch) {
 317                         r = td_io_commit(td);
 318                         if (r < 0)
 319                                 return r;
 320                 }
 321         }
 322
 323         if ((td->io_ops->flags & FIO_SYNCIO) == 0) {
 324                 if (fio_fill_issue_time(td))
 325                         fio_gettime(&io_u->issue_time, NULL);
 326
 327                 /*
 328                  * only used for iolog
 329                  */
 330                 if (td->o.read_iolog_file)
 331                         memcpy(&td->last_issue, &io_u->issue_time,
 332                                         sizeof(struct timeval));
 333         }
 334
 335         return ret;
 336 }
 337
 338 int td_io_init(struct thread_data *td)
 339 {
 340         int ret = 0;
 341
 342         if (td->io_ops->init) {
 343                 ret = td->io_ops->init(td);
 344                 if (ret && td->o.iodepth > 1) {
 345                         log_err("fio: io engine init failed. Perhaps try"
 346                                 " reducing io depth?\n");
 347                 }
 348                 if (!td->error)
 349                         td->error = ret;
 350         }
 351
 352         return ret;
 353 }
 354
 355 int td_io_commit(struct thread_data *td)
 356 {
 357         int ret;
 358
 359         dprint(FD_IO, "calling ->commit(), depth %d\n", td->cur_depth);
 360
 361         if (!td->cur_depth || !td->io_u_queued)
 362                 return 0;
 363
 364         io_u_mark_depth(td, td->io_u_queued);
 365
 366         if (td->io_ops->commit) {
 367                 ret = td->io_ops->commit(td);
 368                 if (ret)
 369                         td_verror(td, -ret, "io commit");
 370         }
 371
 372         /*
 373          * Reflect that events were submitted as async IO requests.
 374          */
 375         td->io_u_in_flight += td->io_u_queued;
 376         td->io_u_queued = 0;
 377
 378         return 0;
 379 }
 380
 381 int td_io_open_file(struct thread_data *td, struct fio_file *f)
 382 {
 383         assert(!fio_file_open(f));
 384         assert(f->fd == -1);
 385
 386         if (td->io_ops->open_file(td, f)) {
 387                 if (td->error == EINVAL && td->o.odirect)
 388                         log_err("fio: destination does not support O_DIRECT\n");
 389                 if (td->error == EMFILE) {
 390                         log_err("fio: try reducing/setting openfiles (failed"
 391                                 " at %u of %u)\n", td->nr_open_files,
 392                                                         td->o.nr_files);
 393                 }
 394
 395                 assert(f->fd == -1);
 396                 assert(!fio_file_open(f));
 397                 return 1;
 398         }
 399
 400         fio_file_reset(f);
 401         fio_file_set_open(f);
 402         fio_file_clear_closing(f);
 403         disk_util_inc(f->du);
 404
 405         td->nr_open_files++;
 406         get_file(f);
 407
 408         if (f->filetype == FIO_TYPE_PIPE) {
 409                 if (td_random(td)) {
 410                         log_err("fio: can't seek on pipes (no random io)\n");
 411                         goto err;
 412                 }
 413         }
 414
 415         if (td->io_ops->flags & FIO_DISKLESSIO)
 416                 goto done;
 417
 418         if (td->o.invalidate_cache && file_invalidate_cache(td, f))
 419                 goto err;
 420
 421         if (td->o.fadvise_hint &&
 422             (f->filetype == FIO_TYPE_BD || f->filetype == FIO_TYPE_FILE)) {
 423                 int flags;
 424
 425                 if (td_random(td))
 426                         flags = POSIX_FADV_RANDOM;
 427                 else
 428                         flags = POSIX_FADV_SEQUENTIAL;
 429
 430                 if (posix_fadvise(f->fd, f->file_offset, f->io_size, flags) < 0) {
 431                         td_verror(td, errno, "fadvise");
 432                         goto err;
 433                 }
 434         }
 435
 436 #ifdef FIO_OS_DIRECTIO
 437         /*
 438          * Some OS's have a distinct call to mark the file non-buffered,
 439          * instead of using O_DIRECT (Solaris)
 440          */
 441         if (td->o.odirect) {
 442                 int ret = fio_set_odirect(f->fd);
 443
 444                 if (ret) {
 445                         td_verror(td, ret, "fio_set_odirect");
 446                         log_err("fio: the file system does not seem to support direct IO\n");
 447                         goto err;
 448                 }
 449         }
 450 #endif
 451
 452 done:
 453         log_file(td, f, FIO_LOG_OPEN_FILE);
 454         return 0;
 455 err:
 456         disk_util_dec(f->du);
 457         if (td->io_ops->close_file)
 458                 td->io_ops->close_file(td, f);
 459         return 1;
 460 }
 461
 462 int td_io_close_file(struct thread_data *td, struct fio_file *f)
 463 {
 464         if (!fio_file_closing(f))
 465                 log_file(td, f, FIO_LOG_CLOSE_FILE);
 466
 467         /*
 468          * mark as closing, do real close when last io on it has completed
 469          */
 470         fio_file_set_closing(f);
 471
 472         disk_util_dec(f->du);
 473         unlock_file_all(td, f);
 474
 475         return put_file(td, f);
 476 }
 477
 478 int td_io_get_file_size(struct thread_data *td, struct fio_file *f)
 479 {
 480         if (!td->io_ops->get_file_size)
 481                 return 0;
 482
 483         return td->io_ops->get_file_size(td, f);
 484 }
 485
 486 static int do_sync_file_range(struct thread_data *td, struct fio_file *f)
 487 {
 488         off64_t offset, nbytes;
 489
 490         offset = f->first_write;
 491         nbytes = f->last_write - f->first_write;
 492
 493         if (!nbytes)
 494                 return 0;
 495
 496         return sync_file_range(f->fd, offset, nbytes, td->o.sync_file_range);
 497 }
 498
 499 int do_io_u_sync(struct thread_data *td, struct io_u *io_u)
 500 {
 501         int ret;
 502
 503         if (io_u->ddir == DDIR_SYNC) {
 504                 ret = fsync(io_u->file->fd);
 505         } else if (io_u->ddir == DDIR_DATASYNC) {
 506 #ifdef FIO_HAVE_FDATASYNC
 507                 ret = fdatasync(io_u->file->fd);
 508 #else
 509                 ret = io_u->xfer_buflen;
 510                 io_u->error = EINVAL;
 511 #endif
 512         } else if (io_u->ddir == DDIR_SYNC_FILE_RANGE)
 513                 ret = do_sync_file_range(td, io_u->file);
 514         else {
 515                 ret = io_u->xfer_buflen;
 516                 io_u->error = EINVAL;
 517         }
 518
 519         if (ret < 0)
 520                 io_u->error = errno;
 521
 522         return ret;
 523 }
 524
 525 int do_io_u_trim(struct thread_data *td, struct io_u *io_u)
 526 {
 527 #ifndef FIO_HAVE_TRIM
 528         io_u->error = EINVAL;
 529         return 0;
 530 #else
 531         struct fio_file *f = io_u->file;
 532         int ret;
 533
 534         ret = os_trim(f->fd, io_u->offset, io_u->xfer_buflen);
 535         if (!ret)
 536                 return io_u->xfer_buflen;;
 537
 538         io_u->error = ret;
 539         return 0;
 540 #endif
 541 }
 542
 543 int fio_show_ioengine_help(const char *engine)
 544 {
 545         struct flist_head *entry;
 546         struct thread_data td;
 547         char *sep;
 548         int ret = 1;
 549
 550         if (!engine || !*engine) {
 551                 log_info("Available IO engines:\n");
 552                 flist_for_each(entry, &engine_list) {
 553                         td.io_ops = flist_entry(entry, struct ioengine_ops,
 554                                                 list);
 555                         log_info("\t%s\n", td.io_ops->name);
 556                 }
 557                 return 0;
 558         }
 559         sep = strchr(engine, ',');
 560         if (sep) {
 561                 *sep = 0;
 562                 sep++;
 563         }
 564
 565         memset(&td, 0, sizeof(td));
 566
 567         td.io_ops = load_ioengine(&td, engine);
 568         if (!td.io_ops) {
 569                 log_info("IO engine %s not found\n", engine);
 570                 return 1;
 571         }
 572
 573         if (td.io_ops->options)
 574                 ret = show_cmd_help(td.io_ops->options, sep);
 575         else
 576                 log_info("IO engine %s has no options\n", td.io_ops->name);
 577
 578         free_ioengine(&td);
 579
 580         return ret;
 581 }